Métodos en Swift

Los métodos Swift están asociados con tipos específicos

En Objective-En C, la clase es el único tipo que puede definir métodos. Pero en Swift, no solo puedes elegir si deseas definir una clase/Estructuras/Enumeraciones, además pueden ser flexibles en los tipos que crea (clases/Estructuras/definir métodos en enumerados)

Métodos de ejemplo

En el lenguaje Swift, los métodos de ejemplo pertenecen a los métodos de un ejemplo específico de una clase, estructura o tipo enumerado.

Los métodos de ejemplo proporcionan los siguientes métodos:

• Puede acceder y modificar las propiedades del ejemplo

• Proporcionar funcionalidades relacionadas con el propósito del ejemplo

Los métodos de ejemplo deben escribirse entre los corchetes grandes ({}) del tipo al que pertenecen.

Los métodos de ejemplo pueden acceder implícitamente a todos los otros métodos y propiedades del tipo al que pertenecen.

Los métodos de ejemplo solo pueden ser llamados por un ejemplo específico de la clase a la que pertenecen.

Los métodos de ejemplo no pueden ser llamados independientemente de los ejemplos existentes.

Sintaxis

func nombrefunción(Parámetros) -> tiporetorno
{
    Declaración1
    Declaración2
    ……
    Declaración N
    devolver parámetros
}

Ejemplo en línea

import Cocoa
class Counter {
    var count = 0
    func increment() {
        count +}} 1
    }
    func incrementarPor(cantidad: Int) {
        count += cantidad
    }
    func reset() {
        count = 0
    }
}
// El valor de cuenta inicial es 0
let contador = Counter()
// El valor de cuenta ahora es1
contador.increment()
// El valor de cuenta ahora es6
contador.incrementarPor(cantidad: 5)
imprimir(contador.count)
// El valor de cuenta ahora es 0
contador.reset()
imprimir(contador.count)

El resultado de la ejecución del programa anterior es:

6
0

La clase Counter define tres métodos de ejemplo:

• increment para aumentar el contador en 1 aumentar;
• incrementarPor(cantidad: Int) para aumentar el contador en un valor entero específico;
• reset para restablecer el contador a 0.

Counter Esta clase también declara una propiedad mutable countpara mantener el seguimiento del valor actual del contador.

Nombres de parámetros locales y nombres de parámetros externos

Los parámetros de una función en Swift pueden tener tanto un nombre local (usado dentro del cuerpo de la función) como un nombre externo (usado al llamar a la función

Los métodos en Swift y Objective-Los métodos en C son extremadamente similares. Al igual que en Objective-Al igual que en C, los nombres de métodos en Swift suelen usar un preposicional para apuntar al primer parámetro del método, como: con, por, por etcétera.

Por defecto, Swift solo proporciona un nombre de parámetro local al primer parámetro de un método; por defecto, proporciona nombres de parámetros globales a los segundos y siguientes parámetros.

En el siguiente ejemplo, 'no1'' se declara en swift como nombre de parámetro local. ''no2'' se usa para declaraciones globales y se accede a través de programas externos.

import Cocoa
class división {
    var count: Int = 0
    func incrementarPor(no1: Int, no2: Int) {
        count = no1 / no2
        imprimir(count)
    }
}
let contador = división()
contador.incrementarPor(no1: 1800, no2: 3)
contador.incrementarPor(no1: 1600, no2: 5)
contador.incrementarPor(no1: 11000, no2: 3)

El resultado de la ejecución del programa anterior es:

600
320
3666

Configuración de si se proporciona un nombre externo

Nos forzamos a agregar un nombre externo al primer parámetro para usar este nombre local como nombre externo (Swift 2.0 antes se usa el símbolo #).

Por el contrario, también podemos usar guiones bajos (_ _) para establecer que los segundos y siguientes parámetros no tengan un nombre externo.

import Cocoa
class multiplicación {
    var count: Int = 0
    func incrementarPor(primer no1: Int, no2: Int) {
        count = no1 * no2
        imprimir(count)
    }
}
let contador = multiplicación()
counter.incrementBy(first: 800, no2: 3)
counter.incrementBy(first: 100, no2: 5)
counter.incrementBy(first: 15000, no2: 3)

El resultado de la ejecución del programa anterior es:

2400
500
45000

Propiedad self

Cada ejemplo del tipo tiene una propiedad implícita llamada self, que es completamente equivalente a la instancia en sí misma.

Puedes usar la propiedad implícita self en un método de instancia de una instancia para referirte a la instancia actual.

import Cocoa
class cálculos {
    let a: Int
    let b: Int
    let res: Int
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Self dentro de: \(res)")
    }
    func tot(c: Int) -> Int {
        devuelve res - c
    }
    func result() {
        print("El resultado es: \(tot(c: 20))
        print("El resultado es: \(tot(c: 50))
    }
}
let pri = cálculos(a: 600, b: 300)
let sum = cálculos(a: 1200, b: 300)
pri.result()
sum.result()

El resultado de la ejecución del programa anterior es:

Self dentro de: 900
Self dentro de: 1500
El resultado es: 880
El resultado es: 850
El resultado es: 1480
El resultado es: 1450

Modificación de tipos de valor en métodos de instancia

Los tipos de estructura y enumeración en Swift son tipos de valor. Generalmente, las propiedades de los tipos de valor no se pueden modificar en sus métodos de instancia.

Pero, si realmente necesitas modificar las propiedades de una estructura o enumeración en un método específico, puedes elegir el método mutando y, en ese caso, el método puede cambiar sus propiedades desde dentro; y cualquier cambio que realice se conservará en la estructura original al finalizar el método.

El método también puede asignar a la propiedad implícita self una nueva instancia completamente nueva, que reemplazará a la instancia original una vez que finalice el método.

import Cocoa
struct área {
    var longitud = 1
    var anchura = 1
    func área() -> Int {
        devuelve longitud * anchura
    }
    mutando func scaleBy(res: Int) {
        longitud *= res
        anchura *= res
        print(longitud)
        print(anchura)
    }
}
var val = área(longitud: 3, anchura: 5)
val.scaleBy(res: 3)
val.scaleBy(res: 30)
val.scaleBy(res: 300)

El resultado de la ejecución del programa anterior es:

9
15
270
450
81000
135000

Asignación de valores en métodos mutables

Los métodos mutables pueden asignar a la propiedad implícita self una nueva instancia completamente nueva.

import Cocoa
struct área {
    var longitud = 1
    var anchura = 1
    func área() -> Int {
        devuelve longitud * anchura
    }
    mutando func scaleBy(res: Int) {
        self.longitud *= res
        self.anchura *= res
        print(longitud)
        print(anchura)
    }
}
var val = área(longitud: 3, anchura: 5)
val.scaleBy(res: 13)

El resultado de la ejecución del programa anterior es:

39
65

Método de tipo

Los métodos de ejemplo son métodos llamados por una instancia del tipo, también puedes definir métodos llamados por el tipo mismo, estos métodos se llaman métodos de tipo.

Se declaran métodos de tipo para estructuras y enumeraciones antes de la palabra clave func con la palabra clave estática. Las clases pueden usar la palabra clave class para permitir que las subclases sobrescriban la implementación del padre.

Los métodos de tipo se llaman con la sintaxis de punto (.).

import Cocoa
class Math
{
    func abs(number: Int) de clase -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}
struct absno
{
    func abs(number: Int) estático -> 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)

El resultado de la ejecución del programa anterior es:

35
5