Swift Language
Condicionales

C Language firebase HTML iOS Java Language JavaScript Node.js Objective-C Language PHP Regular Expressions
Buscar..


Introducción

Las expresiones condicionales, que incluyen palabras clave como if, else if, y else, brindan a los programas Swift la capacidad de realizar diferentes acciones dependiendo de una condición booleana: Verdadero o Falso. Esta sección cubre el uso de condicionales Swift, lógica booleana y declaraciones ternarias.

Observaciones

Para obtener más información sobre sentencias condicionales, consulte El lenguaje de programación Swift .

Usando guardia

2.0

El guardia comprueba una condición y, si es falso, entra en la rama. Las sucursales de los cheques de guardia deben dejar su bloque adjunto ya sea a través de return , break o continue (si corresponde); no hacerlo resulta en un error de compilación. Esto tiene la ventaja de que cuando se escribe una guard , no es posible dejar que el flujo continúe accidentalmente (como sería posible con un if ).

El uso de guardas puede ayudar a mantener bajos los niveles de anidamiento , lo que generalmente mejora la legibilidad del código. 

func printNum(num: Int) {
    guard num == 10 else {
        print("num is not 10")
        return
    }
    print("num is 10")
}

Guard también puede verificar si hay un valor en un opcional , y luego desenvolverlo en el alcance externo: 

func printOptionalNum(num: Int?) {
    guard let unwrappedNum = num else {
        print("num does not exist")
        return
    }
    print(unwrappedNum)
}

Guard puede combinar el desenvolvimiento opcional y la verificación de condición usando la palabra clave where : 

func printOptionalNum(num: Int?) {
guard let unwrappedNum = num, unwrappedNum == 10 else {
    print("num does not exist or is not 10")
    return
}
print(unwrappedNum)
}

Condicionales básicos: declaraciones if

Una sentencia if comprueba si una condición Bool es true : 

let num = 10

if num == 10 {
    // Code inside this block only executes if the condition was true.
    print("num is 10")
}

let condition = num == 10   // condition's type is Bool
if condition {
    print("num is 10")
}

if declaraciones aceptan else if y else blocks, que pueden probar condiciones alternativas y proporcionar un respaldo: 

let num = 10
if num < 10 {  // Execute the following code if the first condition is true.
    print("num is less than 10")
} else if num == 10 {  // Or, if not, check the next condition...
    print("num is 10")
} else {  // If all else fails...
    print("all other conditions were false, so num is greater than 10")
}

Operadores básicos como && y || Puede ser utilizado para múltiples condiciones:

El operador lógico AND 

let num = 10
let str = "Hi"
if num == 10 && str == "Hi" {
    print("num is 10, AND str is \"Hi\"")
}

Si num == 10 era falso, el segundo valor no sería evaluado. Esto se conoce como evaluación de cortocircuito.

El operador lógico O 

if num == 10 || str == "Hi" {
    print("num is 10, or str is \"Hi\")
}

Si num == 10 es verdadero, el segundo valor no sería evaluado.

El operador lógico NO 

if !str.isEmpty {
    print("str is not empty")
}

Encuadernación opcional y cláusulas "donde".

Los opcionales se deben desenvolver antes de que se puedan usar en la mayoría de las expresiones. if let es un enlace opcional , que tiene éxito si el valor opcional no era nil : 

let num: Int? = 10 // or: let num: Int? = nil

if let unwrappedNum = num {
    // num has type Int?; unwrappedNum has type Int
    print("num was not nil: \(unwrappedNum + 1)")
} else {
    print("num was nil")
}

Puede reutilizar el mismo nombre para la nueva variable vinculada, sombreando el original: 

// num originally has type Int?
if let num = num {
    // num has type Int inside this block
}
1.2 3.0

Combine múltiples enlaces opcionales con comas ( , ): 

if let unwrappedNum = num, let unwrappedStr = str {
    // Do something with unwrappedNum & unwrappedStr
} else if let unwrappedNum = num {
    // Do something with unwrappedNum
} else {
    // num was nil
}

Aplique más restricciones después del enlace opcional utilizando una cláusula where : 

if let unwrappedNum = num where unwrappedNum % 2 == 0 {
    print("num is non-nil, and it's an even number")
}

Si te sientes aventurero, intercala cualquier número de enlaces opcionales y cláusulas where : 

if let num = num                           // num must be non-nil
    where num % 2 == 1,                    // num must be odd
    let str = str,                         // str must be non-nil
    let firstChar = str.characters.first   // str must also be non-empty
    where firstChar != "x"                 // the first character must not be "x"
{
    // all bindings & conditions succeeded!
}
3.0

En Swift 3, where se han reemplazado las cláusulas ( SE-0099 ): simplemente use otra , para separar enlaces opcionales y condiciones booleanas. 

if let unwrappedNum = num, unwrappedNum % 2 == 0 {
    print("num is non-nil, and it's an even number")
}

if let num = num,                           // num must be non-nil
    num % 2 == 1,                           // num must be odd
    let str = str,                          // str must be non-nil
    let firstChar = str.characters.first,   // str must also be non-empty
    firstChar != "x"                        // the first character must not be "x"
{
    // all bindings & conditions succeeded!
}

Operador ternario

Las condiciones también pueden evaluarse en una sola línea utilizando el operador ternario:

Si quisiera determinar el mínimo y el máximo de dos variables, podría usar sentencias if, así: 

let a = 5
let b = 10
let min: Int

if a < b {
    min = a 
} else {
    min = b 
}

let max: Int

if a > b {
    max = a 
} else {
    max = b 
}

El operador condicional ternario toma una condición y devuelve uno de dos valores, dependiendo de si la condición era verdadera o falsa. La sintaxis es la siguiente: Esto es equivalente a tener la expresión: 

(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>

El código anterior se puede reescribir usando el operador condicional ternario de la siguiente manera: 

let a = 5
let b = 10
let min = a < b ? a : b
let max = a > b ? a : b

En el primer ejemplo, la condición es a <b. Si esto es cierto, el resultado asignado de nuevo a min será de a; si es falso, el resultado será el valor de b.

Nota: Debido a que encontrar el mayor o el menor de dos números es una operación tan común, la biblioteca estándar de Swift proporciona dos funciones para este propósito: max y min.

Operador sin coalescencia

El operador nulo coalescente <OPTIONAL> ?? <DEFAULT VALUE> desenvuelve el <OPTIONAL> si contiene un valor, o devuelve <DEFAULT VALUE> si es nulo. <OPTIONAL> es siempre de un tipo opcional. <DEFAULT VALUE> debe coincidir con el tipo que está almacenado dentro de <OPTIONAL> .

El operador de unión nula es una abreviatura del código siguiente que utiliza un operador ternario: 

a != nil ? a! : b

Esto puede ser verificado por el siguiente código: 

(a ?? b) == (a != nil ? a! : b) // ouputs true

Tiempo para un ejemplo 

let defaultSpeed:String = "Slow"
var userEnteredSpeed:String? = nil

print(userEnteredSpeed ?? defaultSpeed) // ouputs "Slow"

userEnteredSpeed = "Fast"
print(userEnteredSpeed ?? defaultSpeed) // ouputs "Fast"


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow