Swift Métodos

Los métodos de Swift son funciones asociadas con ciertos tipos específicos.

En Objective-C, la clase es el único tipo que puede definir métodos. Pero en Swift, no solo puedes elegir si definir una clase/estructura/enumeración, sino que también puedes definir métodos de manera flexible en el tipo que crees (clase/estructura/enumeración).

Métodos de instancia

En el lenguaje Swift, los métodos de instancia son métodos que pertenecen a una instancia de una clase, estructura o enumeración específica.

Los métodos de instancia ofrecen lo siguiente:

  • Pueden acceder y modificar las propiedades de la instancia.

  • Proporcionan funcionalidad relacionada con el propósito de la instancia.

Los métodos de instancia deben escribirse entre las llaves ({}) del tipo al que pertenecen.

Los métodos de instancia pueden acceder implícitamente a todos los demás métodos de instancia y propiedades de su tipo.

Un método de instancia solo puede ser llamado por una instancia específica de la clase a la que pertenece.

Un método de instancia no puede ser invocado independientemente de una instancia existente.

Sintaxis

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

Ejemplo

import Cocoa

class Counter {
    var count = 0
    func increment() {
        count += 1
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
// 初始计数值是0
let counter = Counter()

// 计数值现在是1
counter.increment()

// 计数值现在是6
counter.incrementBy(amount: 5)
print(counter.count)

// 计数值现在是0
counter.reset()
print(counter.count)

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

6
0

La clase Counter define tres métodos de instancia:

  • incrementIncrementar el contador en 1;
  • incrementBy(amount: Int)Incrementar el contador en un valor entero especificado;
  • resetRestablecer el contador a 0.

CounterEsta clase también declara una propiedad mutablecount, que se utiliza para mantener el seguimiento del valor actual del contador.

Nombres de parámetros locales y nombres de parámetros externos de los métodos

Los parámetros de las funciones de Swift pueden tener a la vez un nombre local (que se usa dentro del cuerpo de la función) y un nombre externo (que se usa al llamar a la función).

Los métodos en Swift son extremadamente similares a los métodos en Objective-C. Al igual que en Objective-C, los nombres de los métodos en Swift suelen usar una preposición para referirse al primer parámetro del método, por ejemplo: with, for, by, etc.

Swift, por defecto, solo asigna al primer parámetro del método un nombre de parámetro local; por defecto, asigna a los parámetros segundo y posteriores nombres de parámetros externos.

En el siguiente ejemplo, 'no1' se declara como nombre de parámetro local en Swift. 'no2' se declara como nombre externo y se accede a él desde fuera.

import Cocoa

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)

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

600
320
3666

Configuración de si se proporcionan nombres externos

Forzamos la adición de un nombre externo en el primer parámetro, usando ese nombre local como nombre externo (antes de Swift 2.0 se usaba el símbolo #).

Por el contrario, también podemos usar un guion bajo (_) para configurar que el segundo y los parámetros posteriores no proporcionen un nombre externo. 
import Cocoa

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

let counter = multiplication()
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

La propiedad self

Cada instancia de un tipo tiene una propiedad implícita llamada self; self es completamente equivalente a la propia instancia.

Puedes usar esta propiedad implícita self en un método de instancia para referenciar la instancia actual.

import Cocoa

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("Self 内: \(res)")
    }
    
    func tot(c: Int) -> Int {
        return res - c
    }
    
    func result() {
        print("结果为: \(tot(c: 20))")
        print("结果为: \(tot(c: 50))")
    }
}

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

pri.result()
sum.result()

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

Self 内: 900
Self 内: 1500
结果为: 880
结果为: 850
结果为: 1480
结果为: 1450

Modificar tipos de valor en métodos de instancia

En el lenguaje Swift, las estructuras y las enumeraciones son tipos de valor. En general, las propiedades de un tipo 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 optar por marcar este método como mutable (mutating); entonces el método podrá cambiar sus propiedades desde el interior, y cualquier cambio que haga se conservará en la estructura original al finalizar el método.

El método también puede asignar una instancia completamente nueva a su propiedad implícita self; esta nueva instancia reemplazará a la instancia original después de que el método termine.

import Cocoa

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)

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

9
15
270
450
81000
135000

Asignar un valor a self en métodos mutables

Un método mutable puede asignar una instancia completamente nueva a la propiedad implícita self.

import Cocoa

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)

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

39
65

Métodos de tipo

Los métodos de instancia son métodos que se llaman desde una instancia del tipo; también puedes definir métodos que se llamen desde el propio tipo, a estos se les llama métodos de tipo.

Para declarar métodos de tipo en estructuras y enumeraciones, se añade la palabra clave static antes de la palabra clave func del método. Las clases pueden usar la palabra clave class para permitir que las subclases sobrescriban la implementación del método de la clase padre.

Los métodos de tipo se invocan con la sintaxis de punto (.), igual que los métodos de instancia.

import Cocoa

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)

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

35
5
Otras extensiones