---
title: 02. Funcións
description: "**Unha función é un bloque de código que se pode chamar en diferentes partes da nosa aplicación.** Ao crear unha función asignámoslle un nome e dentro delas engadimos o noso código. Esta agrupación de código ofrécenos varias vantaxes: - Podemos…"
url: "https://www.drodicio.com/docs/swift/tema-2-swift-avanzado/funcions/"
updated: "2024-12-15"
category: Tema 2. Swift avanzado
---

# 02. Funcións

**Unha función é un bloque de código que se pode chamar en diferentes partes da nosa aplicación.**

Ao crear unha función asignámoslle un nome e dentro delas engadimos o noso código.

Esta agrupación de código ofrécenos varias vantaxes:

- Podemos dividir e estruturar mellor o código da nosa aplicación
- Facilitan a reutilización de código
- Permítenos chamar á función desde diferentes puntos do noso código.

## As nosas primeiras funcións

Para crear unha función debemos usar a keyword `func` e a continuación debemos engadir o nome da función.

No seguinte exemplo creamos a nosa primeira función en Swift:

```swift
func aMiñaPrimeiraFunción() {
    // TODO: Do something
}
```

Neste caso a función chámase `aMiñaPrimeiraFunción` e dentro do seu body (todo o que engadimos desde que abrimos as chaves `{` ata que as pechamos `}`) podemos engadir a lóxica que queiramos (neste caso a función está baleira).

A unha función dáslle un nome que usarás para chamar á función para que esta execute a súa tarefa.

- Cada función ten un tipo, o cal se conforma polos tipos dos argumentos da función e do valor de devolución da mesma.
- Este tipo, pódelo usar como calquera outro tipo en Swift, o cal facilita pasar funcións como parámetros a outras funcións e devolver funcións desde outras funcións.
- As funcións tamén poden definirse dentro doutras funcións para encapsular funcionalidade útil dentro do ámbito dunha función aniñada.

```swift
func saludar(persona: String) -> String {
    let saludo = "¡Hola, " + persona + "!"

    return saludo
}
```

## Definición

Ao definir unha función, podes especificar —de maneira opcional—:

- Cada función ten un **nome**, o cal describe a tarefa que a función executa. O nome da función vai precedido pola palabra chave `func`
- Ningún, un ou máis valores de entrada (**parámetros**).
- Un valor de saída (valor de **devolución**). Para indicar o tipo de devolución dunha función, utilizamos a frecha de devolución (`->`)

Para usar unha función:

- Debes chamar á función co seu nome
- Pasarlle valores de entrada (coñecidos como argumentos) que coincidan cos tipos dos parámetros da función. Os argumentos dunha función sempre deben proverse no mesmo orde da lista de parámetros da función.

A función do seguinte exemplo chámase `saudar(persoa)`, xa que iso é o que esta fai, toma o nome dunha persoa como entrada e devolve un saúdo para esta persoa. Para facer isto:

- Definimos un parámetro de entrada de tipo `String` chamado `persoa`
- Definimos un valor de devolución de tipo `String` chamado `saúdo` (o cal contén un saúdo para a persoa)

Vemos o exemplo:

```swift
func saudar(persoa: String) -> String {
    let saudo =  "Ola "+persoa+", que tal todo?"

    return saudo
}

func saudarOutraVez(persoa: String) -> String {
    return  "Ola "+persoa+", que tal todo?"
}

print(saudar(persoa: "Lola Mento"))
print(saudarOutraVez(persoa: "Lola Mento"))
//Imprimen: Ola Lola Mento, que tal todo?
```

## Parámetros de entrada

### Funcións sen parámetros

As funcións non requiren de parámetros de entrada.

No seguinte exemplo temos unha función sen parámetros de entrada, a cal sempre devolve o mesmo mensaxe `String` ao ser chamada:

```swift
func olaMundo() -> String {
    return  "Ola mundo"
}
print(olaMundo())
//Imprime: Ola Mundo
```

### Funcións con un parámetro

Exemplo de dúas funcións, cada unha con un único parámetro de entrada:

```swift
func saudar(persoa: String) -> String {
    let saudo =  "Ola "+persoa+", que tal todo?"

    return saudo
}

func saudarOutraVez(persoa: String) -> String {
    return  "Ola "+persoa+", que tal todo?"
}

print(saudar(persoa: "Lola Mento"))
print(saudarOutraVez(persoa: "Lola Mento"))
//Imprimen: Ola Lola Mento, que tal todo?
```

### Funcións con varios parámetros

As funcións poden ter múltiples parámetros de entrada, os cales se escriben dentro das parénteses da función, separados por coma.

Esta función toma como entrada o nome dunha persoa e un `Bool` para indicar se xa se saudou ou non a esa persoa; devolve un saúdo apropiado para a persoa:

```swift
func saudar(persoa: String, foiSaudada: Bool) -> String {
    if(!foiSaudada){
        return  "Ola "+persoa+", que tal todo?"
    }
    else {
        return  "Ola de novo "+persoa
    }
}
print(saudar(persoa: "Lola Mento",foiSaudada: false))
//Imprimen: Ola Lola Mento, que tal todo?
print(saudar(persoa: "Lola Mento",foiSaudada: true))
//Imprimen: Ola de novo Lola Mento
```

## Valor de devolución

### Un valor de devolución

Exemplo de dúas funcións, cada unha devolven un valor (`String`):

```swift
func saudar(persoa: String) -> String {
    let saudo =  "Ola "+persoa+", que tal todo?"

    return saudo
}

func saudarOutraVez(persoa: String) -> String {
    return  "Ola "+persoa+", que tal todo?"
}

print(saudar(persoa: "Lola Mento"))
print(saudarOutraVez(persoa: "Lola Mento"))
//Imprimen: Ola Lola Mento, que tal todo?
```

### Sen valores de devolución

Hai funcións que non requiren definir un valor de devolución.

Aquí temos unha versión da función `saudar(persoa:)`, a cal imprime a súa propia cadea en lugar de devolvela:

```swift
func saudo(persoa: String) {
    print("Ola "+persoa)
}
saudo(persoa: "Aitor Tilla")
//Imprime: Ola Aitor Tilla
```

### Tuplas: Múltiples valores de devolución

É posible usar unha `tupla` para devolver múltiples valores.

O seguinte exemplo define unha función chamada `minMax`, a cal atopa os números menor e maior no `array` de valores `Int` que lle pasamos como parámetro:

```swift
func minMax(numeros: [Int]) -> (min: Int, max: Int) {
    var minActual = numeros[0]
    var maxActual = numeros[0]

    for numero in numeros {
        if (numero<minActual) {
            minActual =  numero
        }
        if (numero>maxActual){
            maxActual = numero
        }
    }
    return (minActual,maxActual)
}

//Outra xeito de facer a función anterior
func minMax2(numeros: [Int]) -> (min: Int, max: Int) {
		//Desempaquetado de opcionais con nil coalescing
    var minActual = numeros.min() ?? 0
    var maxActual = numeros.max() ?? 0
    return (minActual,maxActual)
}

//Outra xeito de facer as funcións anteriores
func minMax3(numeros: [Int]) -> (min: Int, max: Int) {
    //Forzar o Desempaquetado de opcionais.
    //OLLO! Se numeros == nil dará un erro o programa

    return (numeros.min()!,numeros.max()!)
}
print(minMax(numeros: [1,9,23,4,56,0]))
//Imprime: (min: 0, max: 56)

let limites = minMax(numeros: [1,9,23,4,56,0])
print("O valor mínimo é (limites.min) e o máximo é (limites.max)")
//Imprime: O valor mínimo é 0 e o máximo é 56
```

Imos ver outro exemplo moi sinxelo. A continuación creamos unha función que retorna unha tupla:

```swift
func getTupla() -> (String, String) {
    let ies = "IES San Mamede"
    let curso = "2º DAM"
    return (ies, curso)
}

let (ies, curso) = getTupla()

print(ies)
print(curso)

// RESULTADO 👇
// IES San Mamede
// 2º DAM
```

Ás veces resulta útil poder retornar unha tupla con poucos valores, pero cando a tupla retorna moitos valores quizais é mellor crear unha `Struct` ou `Class` , nos que imos entrar en detalle no seguinte tema de orientación a obxectos.

### Múltiples valores de devolución con opcionais

```swift
func minMax(numeros: [Int]) -> (min: Int, max: Int)? {
    if numeros.isEmpty {
        return nil
    }
    else {
        var minActual = numeros[0]
        var maxActual = numeros[0]

        for numero in numeros {
            if (numero<minActual) {
                minActual =  numero
            }
            if (numero>maxActual){
                maxActual = numero
            }
        }
        return (minActual,maxActual)
    }
}

print(minMax(numeros: [1,9,23,4,56,0]))
//Imprime: (min: 0, max: 56)
print(minMax(numeros: []))
//Imprime: nil
```

## Etiquetas e nomes de parámetro

Cada parámetro dunha función ten:

- Unha **etiqueta** que se usa ao invocar unha función.
  - Utilízase cando chamamos á función.
  - Nunha mesma función, pódense repetir etiquetas
  - Non é obrigatoria utilizala.
- O **nome do parámetro** utilízase na implementación da función.
  - Todos os parámetros deben de ter nomes únicos
  - Se non empregamos etiquetas, o nome do parámetro equivale á etiqueta.

No seguinte exemplo, a función saudar recibe 2 parámetros:

- O nome da persoa a saudar
  - O nome de parámetro é `persona`. Émpregase no interior da función
  - Non ten etiqueta, polo que a etiqueta por defecto será o nome do parámetro (`persona`)
- A localidade da persoa a saudar
  - O nome de parámetro é: `lugarOrixe`. Émpregase no interior da función.
  - A etiqueta é `de`. Émpregase ao chamar á función.

```swift
func algunhaFuncion(etiqueta nomeParametro: Int) {

}

func saudar(persona: String, de lugarOrixe: String) -> String {
    return "Ola "+persona+". Gracias pola túa visita dende "+lugarOrixe
}
print(saudar(persona: "Aitor Tilla", de: "Cacharrequille"))
//Imprime: Ola Aitor Tilla. Gracias pola túa visita dende Cacharrequille
```

### Omitindo etiquetas

Se non queres unha etiqueta de argumento para un parámetro, agrega un guión baixo (`_`) en lugar dunha etiqueta.

Así, na seguinte función, omitimos a etiqueta para o parámetro `numeros`, de xeito que, ao chamar a función, en lugar de `minMax3(numeros:[1,9,23,4,56,0])`, ao non ter etiqueta, utilizamos `minMax3([1,9,23,4,56,0])`:

```swift
func minMax(_ numeros: [Int]) -> (min: Int, max: Int) {
    var minActual = numeros[0]
    var maxActual = numeros[0]

    for numero in numeros {
        if (numero<minActual) {
            minActual =  numero
        }
        if (numero>maxActual){
            maxActual = numero
        }
    }
    return (minActual,maxActual)
}

print(minMax([1,9,23,4,56,0]))
//Imprime: (min: 0, max: 56)
```

## Parámetros variables

Podemos enviar varios valores dun parámetro específico insertado tres puntos (`...`) despois do parámetro:

```swift
func mediaAritmetica(_ numeros: Double...) -> Double {
    var total: Double = 0

    for numero in numeros {
        total += numero
    }

    return total / Double(numeros.count)
}

print(mediaAritmetica(1, 2, 3, 4, 5))
// Devuelve 3.0, que es la media aritmética de esos cinco números.
print(mediaAritmetica(3, 8.25, 18.75))
// Devuelve 10.0, que es la media aritmética de esos tres números.
```

## Parámetros por defecto

Os parámetros de entrada dunha función poden ter valores por defecto:

```swift
func createDatabase(name: String, path: String = "/") {
    print(path)
}
```

Neste caso, creamos unha función que ten dous parámetros de entrada, e o segundo ten un valor por defecto

Isto significa que poderiamos chamar á función da seguinte maneira:

```swift
createDatabase(name: "Alumnado_2_DAM")
// Imprime: /

createDatabase(name: "Alumnado_2_DAM", path: "/users/root")
// Imprime: /users/root
```

Na primeira chamada o método `createDatabase` omitimos escribir o segundo parámetro xa que dentro do body da función queremos usar "/" (que é o valor por defecto que está asignado a ese parámetro).

Pero na seguinte chamada ao método `createDatabase`, estamos a especificar o segundo parámetro cunha ruta que non queremos que sexa o valor por defecto "`/`", por tanto sobrescribimos o valor por "`/users/root`".

## in-out: Parámetros de E/S

Os parámetros das funcións son, por defecto, constantes.

- Tentar cambiar o valor do parámetro dentro do corpo da función resultará nun erro de tempo de compilación.
- Isto significa que non podes cambiar o valor dun parámetro por accidente.

Para que unha función modifique o valor dun parámetro e que os cambios persistan despois de finalizada a execución da función, debemos definir devandito parámetro como un parámetro `in-out`.

- Para definir un parámetro `in-out`, agrega a palabra chave `inout` xusto antes do parámetro.
- Soamente podes pasar unha variable como o argumento para un parámetro in-out. Non é posible pasar unha constante.
- Ao pasar unha variable como argumento para un parámetro in-out, agrega o símbolo ampersand (`&`) xusto antes do nome da variable, para indicar que esta pode ser modificada pola función.

```swift
func intercambiarDousEnteiros(_ a: inout Int, _ b: inout Int) {
    let aTemporal = a

    a = b
    b = aTemporal
}

var algunEnteiro = 3
var otroEnteiro = 107

intercambiarDousEnteiros(&algunEnteiro, &otroEnteiro)

print("algunEnteiro agora é (algunEnteiro), e otroEnteiro é agora (otroEnteiro)")
// Imprime: algunEnteiro agora é 107, e otroEnteiro é agora 3
```

## Funcións anidadas

É posible definir funcións dentro doutras funcións, o que se coñece como funcións aniñadas.

As funcións aniñadas están ocultas do mundo exterior, pero poden ser chamadas e usadas polas funcións que as conteñen. Unha función que contén unha ou máis funcións aniñadas tamén pode devolver unha das súas funcións aniñadas para permitirlle ser usada noutro ambiente.

```swift
func elegirFuncionDeMovimiento2(debeRegresar: Bool) -> (Int) -> Int {
    func avanzar(input: Int) -> Int { return input + 1 }
    func regresar(input: Int) -> Int { return input - 1 }

    return debeRegresar ? regresar : avanzar
}

var valorActual = -4
var moverseHaciaCero = elegirFuncionDeMovimiento2(debeRegresar: valorActual > 0)
// moverseHaciaCero ahora se refiere a la función anidada avanzar()

while valorActual != 0 {
    print("Valor actual: (valorActual)... ")
    valorActual = moverseHaciaCero(valorActual)
}
//Imprime:
//Valor actual: -4...
//Valor actual: -3...
//Valor actual: -2...
//Valor actual: -1...
```
