---
title: 06. Operadores
description: "Un operador é un símbolo ou frase especial que se utiliza para verificar, cambiar ou combinar valores. Por exemplo, o operador de adición (`+`) suma dous números, como en `let i = 1 + 2`, mentres que o operador lóxico…"
url: "https://www.drodicio.com/docs/swift/tema-1-comezando-con-swift/operadores/"
updated: "2024-11-06"
category: Tema 1. Comezando con Swift
---

# 06. Operadores

Un operador é un símbolo ou frase especial que se utiliza para verificar, cambiar ou combinar valores.

Por exemplo, o operador de adición (`+`) suma dous números, como en `let i = 1 + 2`, mentres que o operador lóxico `&&` (AND) combina dous valores booleanos, como en `if codigoPuertaIngresado && aproboEscanerDeRetina`.

## Asignación

O operador de asignación (`=`) úsase para asignar un valor. Ao nome do operando á esquerda asígnaselle o valor do operando á dereita. Na expresión `a = b`, se inicializa ou actualiza o valor da `a` co valor de `b`.

Así, por exemplo:

```swift
let b = 10
var a = 5

a = b // a es ahora igual a 10

let (x, y) = (1, 2) // x es igual a 1, y y es igual a 2

if x = y {
  // Esto no es válido, porque x = y no devuelve un valor.
}
```

## Aritméticos

- Suma (`+`)
- Resta (`-`)
- Multiplicación (`*`)
- División (`/`)
- Resto dunha división - módulo (`%`)

Exemplos:

```swift
1 + 2       // igual a 3
5 - 3       // igual a 2
2 * 3       // igual a 6
10.0 / 2.5  // igual a 4.0

"Hola, " + "mundo"  // es igual a "Hola, mundo"

9 % 4    // es igual a 1

let tres = 3
let menosTres = -tres       // menosTres es igual a -3
let masTres = -menosTres    // masTres es igual a 3, o «menos menos tres»

let menosSeis = -6
let tambienMenosSeis = +menosSeis  // tambienMenosSeis es igual a -6
```

## Asignación composta

Swift ofrece operadores de asignación composta, os cales combinan asignación (`=`) con outra operación. Un exemplo disto é o operador de adición asignación (`+=`):

Exemplo:

```swift
var a = 1
a += 2 // a es ahora igual a 3
```

## Comparación

- Igual que (==)
- Non igual que (!=)
- Maior que (>)
- Menor que (<)
- Maior ou igual que (>=)
- Menor ou igual que (<=)

Exemplos:

```swift
1 == 1   // true porque 1 es igual a 1
2 != 1   // true porque 2 no es igual a 1
2 > 1    // true porque 2 es mayor que 1
1 < 2    // true porque 1 es menor que 2
1 >= 1   // true porque 1 es mayor o igual a 1
2 <= 1   // false porque 2 no es mayor o igual a 1
let nombre = "mundo"

if nombre == "mundo" {
    print("Hola, mundo.")
} else {
    print("Lo siento, (nombre), pero no te reconozco.")
}
// Imprime "Hola, mundo." porque nombre es, en efecto, igual a "mundo".
(1, "pantera") < (2, "manzana")   // true porque 1 es menor que 2; "pantera" y "manzana" no se comparan
(3, "manzana") < (3, "naranja")    // true porque 3 es igual a 3, y "manzana" es menor que "naranja"
(4, "perro") == (4, "perro")       // true porque 4 es igual a 4, y "perro" es igual a "perro"
```

## Condicional (ternario)

O operador condicional ternario `pregunta ? resposta1 : resposta2` é un atallo para o seguinte código:

```swift
if pregunta {
  respuesta1
} else {
  respuesta2
}
```

Así, por exemplo:

```swift
let alturaContenido = 40
let tieneEncabezado = true
let alturaFila = alturaContenido + (tieneEncabezado ? 50 : 20) // alturaFila es igual a 90
```

O exemplo anterior é unha forma abreviada de poñer o seguinte:

```swift
let alturaContenido = 40
let tieneEncabezado = true
let alturaFila: Int

if tieneEncabezado {
    alturaFila = alturaContenido + 50
} else {
    alturaFila = alturaContenido + 20
}
// alturaFila es igual a 90
```

## Lóxicos

Os operadores lóxicos modifican ou combinan os valores lóxicos booleanos `true` e `false`:

- NOT (`!`)
- AND (`&&`)
- OR (`||`)

### NOT - `!`

O operador lóxico NOT (`!`):

- Invirte un valor booleano, de maneira que `true` convértese en `false` e `false` convértese en `true`.
- É un operador prefixo, e aparece inmediatamente antes do seu operando, sen ningún espazo en branco

```swift
let entradaPermitida = false

if !entradaPermitida {
    print("ACCESO DENEGADO")
}
// Imprime "ACCESO DENEGADO"
```

### AND - `&&`

O operador lóxico AND (`&&`):

- Crea expresións lóxicas, onde ambos os valores deben ser `true` para que toda a expresión sexa `true`.
- Se calquera dos dous valores é `false`, toda a expresión será `false`.

```swift
let codigoPuertaIngresado = true
let aproboEscanerDeRetina = false

if codigoPuertaIngresado && aproboEscanerDeRetina {
    print("¡Bienvenida!")
} else {
    print("ACCESO DENEGADO")
}
// Imprime "ACCESO DENEGADO"
```

### OR - `||`

O operador lóxico OR (`||`) úsase para crear expresións lóxicas, nas cales só un dos dous valores ten que ser `true` para que toda a expresión sexa `true`.

```swift
let tieneLlaveDeLaPuerta = false
let conoceClaveMaestra = true

if tieneLlaveDeLaPuerta || conoceClaveMaestra {
    print("¡Bienvenida!")
} else {
    print("ACCESO DENEGADO")
}
// Imprime "¡Bienvenida!"
```

### Combinación e parentése

```swift
if codigoPuertaIngresado && aproboEscanerDeRetina || tieneLlaveDeLaPuerta || conoceClaveMaestra {
    print("¡Bienvenida!")
} else {
    print("ACCESO DENEGADO")
}
// Imprime "¡Bienvenida!"

if (codigoPuertaIngresado && aproboEscanerDeRetina) || tieneLlaveDeLaPuerta || conoceClaveMaestra {
    print("¡Bienvenida!")
} else {
    print("ACCESO DENEGADO")
}
// Imprime "¡Bienvenida!"
```
