Swift - Métodos

En el lenguaje Swift 4, las funciones asociadas con tipos particulares se denominan métodos. En Objective C, las Clases se utilizan para definir métodos, mientras que el lenguaje Swift 4 proporciona al usuario flexibilidad para tener métodos para Clases, Estructuras y Enumeraciones.

Métodos de instancia

En el lenguaje Swift 4, se accede a las instancias de Clases, Estructuras y Enumeración a través de los métodos de instancia.

Los métodos de instancia proporcionan funcionalidad

Para acceder y modificar las propiedades de la instancia
funcionalidad relacionada con la necesidad de la instancia

El método de instancia se puede escribir dentro de las llaves {}. Tiene acceso implícito a métodos y propiedades de la instancia de tipo. Cuando se llama a una instancia específica del tipo, obtendrá acceso a esa instancia en particular.

Sintaxis

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Ejemplo

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}
let pri = calculations(a: 600, b: 300)
pri.result()

Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:

Result is: 880
Result is: 850

Cálculos de clase define dos métodos de instancia:

init () está definido para sumar dos números ayb y almacenarlo en el resultado 'res'
tot () se usa para restar la 'res' de pasar el valor 'c'

Finalmente, para imprimir los métodos de cálculo con valores para ay b se llama. Se accede a los métodos de instancia con '.' sintaxis de puntos

Nombres de parámetros locales y externos

Las funciones Swift 4 describen declaraciones tanto locales como globales para sus variables. De manera similar, las convenciones de nomenclatura de Swift 4 Methods también se parecen a las de Objective C. Pero las características de las declaraciones de nombres de parámetros locales y globales son diferentes para las funciones y los métodos. El primer parámetro en Swift 4 se conoce mediante nombres de preposición como 'con', 'para' y 'por' para acceder fácilmente a las convenciones de nomenclatura.

Swift 4 proporciona flexibilidad en los métodos al declarar el nombre del primer parámetro como nombres de parámetros locales y los nombres de parámetros restantes como nombres de parámetros globales. Aquí 'no1' es declarado por los métodos de Swift 4 como nombres de parámetros locales. 'no2' se usa para declaraciones globales y se accede a él a través del programa.

class division {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 / no2
      print(count)
   }
}

let counter = division()
counter.incrementBy(no1: 1800, no2: 3)
counter.incrementBy(no1: 1600, no2: 5)
counter.incrementBy(no1: 11000, no2: 3)

Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:

600
320
3666

Nombre de parámetro externo con símbolo # y _

Aunque los métodos de Swift 4 proporcionan los nombres de los primeros parámetros para las declaraciones locales, el usuario tiene la posibilidad de modificar los nombres de los parámetros de declaraciones locales a globales. Esto se puede hacer anteponiendo el símbolo '#' al nombre del primer parámetro. Al hacerlo, se puede acceder al primer parámetro de forma global en todos los módulos.

Cuando el usuario necesita acceder a los nombres de los parámetros posteriores con un nombre externo, el nombre de los métodos se anula con la ayuda del símbolo '_'.

class multiplication {
   var count: Int = 0
   func incrementBy(no1: Int, no2: Int) {
      count = no1 * no2
      print(count)
   }
}

let counter = multiplication()

counter.incrementBy(no1: 800, no2: 3)
counter.incrementBy(no1: 100, no2: 5)
counter.incrementBy(no1: 15000, no2: 3)

Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:

2400
500
45000

Propiedad propia en métodos

Los métodos tienen una propiedad implícita conocida como 'self' para todas sus instancias de tipo definidas. La propiedad 'Self' se utiliza para hacer referencia a las instancias actuales para sus métodos definidos.

class calculations {
   let a: Int
   let b: Int
   let res: Int

   init(a: Int, b: Int) {
      self.a = a
      self.b = b
      res = a + b
      print("Inside Self Block: \(res)")
   }
   
   func tot(c: Int) -> Int {
      return res - c
   }
   
   func result() {
      print("Result is: \(tot(c: 20))")
      print("Result is: \(tot(c: 50))")
   }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

Modificación de tipos de valor a partir de métodos de instancia

En Swift 4, las estructuras del lenguaje y las enumeraciones pertenecen a tipos de valores que no pueden ser alterados por sus métodos de instancia. Sin embargo, el lenguaje Swift 4 proporciona flexibilidad para modificar los tipos de valores mediante el comportamiento 'mutante'. Mutate realizará cualquier cambio en los métodos de instancia y volverá a la forma original después de la ejecución del método. Además, por la propiedad 'self' se crea una nueva instancia para su función implícita y reemplazará el método existente después de su ejecución

struct area {
   var length = 1
   var breadth = 1
   
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      length *= res
      breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

Cuando ejecutamos el programa anterior usando el patio de recreo, obtenemos el siguiente resultado:

Propiedad propia para el método de mutación

Los métodos de mutación combinados con la propiedad 'self' asignan una nueva instancia al método definido.

struct area {
   var length = 1
   var breadth = 1
   func area() -> Int {
      return length * breadth
   }
   mutating func scaleBy(res: Int) {
      self.length *= res
      self.breadth *= res
      print(length)
      print(breadth)
   }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(res: 13)

Cuando ejecutamos el programa anterior usando playground, obtenemos el siguiente resultado. -

39
65

Métodos de tipo

Cuando se llama a una instancia particular de un método, se llama como método de instancia; y cuando el método llama a un tipo particular de método, se llama como 'Métodos de tipo'. Los métodos de tipo para 'clases' se definen con la palabra clave 'func' y las estructuras y métodos de tipo enumeraciones se definen con la palabra clave 'estática' antes de la palabra clave 'func'.

Los métodos de tipo son llamados y accesibles por '.' sintaxis donde en lugar de llamar a una instancia en particular se invoca todo el método.

class Math {
   class func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

struct absno {
   static func abs(number: Int) -> Int {
      if number < 0 {
         return (-number)
      } else {
         return number
      }
   }
}

let no = Math.abs(number: -35)
let num = absno.abs(number: -5)

print(no)
print(num)

Cuando ejecutamos el programa anterior usando playground, obtenemos el siguiente resultado. -

35
5