Swift – Declaración de cambio

En Swift, una declaración de cambio es un tipo de mecanismo de control que permite que un programa cambie su flujo de control y tome algunas decisiones sobre la base de algunas condiciones impuestas sobre el valor de una variable. El flujo de control de un programa sale del bloque de sentencias switch tan pronto como se cumple la condición correspondiente. También proporciona una condición predeterminada si no se cumple ninguna de las condiciones mencionadas. La declaración predeterminada dentro de una declaración de cambio es opcional siempre que la declaración de cambio sea exhaustiva. En palabras simples, podemos omitir la declaración predeterminada solo si la declaración de cambio ya cubre todos los casos posibles para manejar el valor de la variable. Si la declaración de cambio no cubre todos los casos posibles y, al mismo tiempo, se omite la declaración predeterminada, el compilador de Swift genera un error de tiempo de compilación. 

Sintaxis:

var miVariable = valor

cambiar miVariable {

             condición de caso 1:

             expresión 1

             Fallthrough // Opcional

             condición de caso 2:

             expresión 2

             Fallthrough // Opcional

             ……………………

             ……………………

             ……………………

             predeterminado: // Opcional si el bloque de interruptores es exhaustivo

             expresión

}

Diagrama de flujo:

¿Por qué cambiar las declaraciones?

Las declaraciones Switch son equivalentes a un montón de declaraciones if-else. En palabras simples, podemos lograr la misma tarea con la ayuda de un montón de declaraciones if-else como lo hace la declaración switch. Pero las sentencias switch son más eficientes en comparación con las sentencias if-else, ya que mejoran la legibilidad del código.

Por ejemplo,

Consideremos un escenario en el que queremos imprimir una string de acuerdo con una string marcada correspondiente a un carácter,

• “A” -> “Manzana”
• “B” -> “Niño”
• “C” -> “Gato”
• “D” -> “Perro”

Podemos realizar esta tarea con la ayuda de una declaración de cambio como se muestra a continuación:

// Swift program to illustrate the 
// working of switch statement
  
// Initializing a character
var myCharacter = "B"
  
// Switch block 
switch myCharacter 
{
      
    // If myCharacter is equal to "A"
    case "A":
      
        // Then print "Apple"
        print("Apple")
      
    // If myCharacter is equal to "B"
    case "B":
      
        // Then print "Apple"  
        print("Boy")
      
    // If myCharacter is equal to "C"  
    case "C":
      
        // Then print "Cat" 
        print("Cat")
      
    // If myCharacter is equal to "D"   
    case "D":
      
        // Then print "Dog"   
        print("Dog")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

Boy

Declaración de Fallthrough 

Una declaración fallthrough permite que el flujo de control de un programa pase al siguiente caso. El cuerpo del siguiente caso se ejecutará sin importar si coincide con el valor de la variable. Ahora bien, si el siguiente caso también contiene una declaración fallida, el flujo de control del programa pasa al siguiente del siguiente caso y así sucesivamente. De lo contrario, si no contiene una sentencia fallthrough, el flujo de control del programa sale inmediatamente de la sentencia switch. 

Sintaxis:

var miVariable = valor

cambiar mi variable 

{

             condición de caso 1:

             expresión 1

             caer a través                   

             condición de caso 2:

             expresión 2

}

Ejemplo:

// Swift program to illustrate the working 
// of fallthrough statement in switch statement
  
// Initializing a character
var myCharacter = "B"
  
// Switch block 
switch myCharacter
{
      
    // If myCharacter is equal to "A"
    case "A":
      
        // Then print "Apple"
        print("Apple")
      
    // If myCharacter is equal to "B"
    case "B":
      
        // Then print "Apple"  
        print("Boy")
      
    // Using fallthrough so that
    // below case also gets executed
    fallthrough
      
    // If myCharacter is equal to "C"  
    case "C":
      
        // Then print "Cat" 
        print("Cat")
      
    // If myCharacter is equal to "D"   
    case "D":
      
        // Then print "Dog"   
        print("Dog")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

Boy
Cat

Explicación: Como myCharacter es igual a «B», se ejecutó el cuerpo del segundo caso. Debido a que hemos utilizado la declaración fallthrough justo después del cuerpo del segundo caso, el cuerpo del tercer caso también se ejecutará. Tenga en cuenta que aunque no cumple la tercera condición (claramente, «B» es igual a «C»), el tercer caso se está ejecutando. Esto muestra cuán poderosas son las declaraciones fallidas en Swift. 

Sin fallos implícitos

En una declaración de cambio, si una condición de caso no contiene un cuerpo, el compilador de Swift produce un error de tiempo de compilación. Esto se debe a que Swift no proporciona una declaración de error implícita para tratar con tales condiciones de casos. 

Ejemplo:

// Swift program to illustrate 
// No implicit fallthrough
  
// Initializing a character
var myCharacter = "B"
  
// Switch block 
switch myCharacter 
{
      
    // If myCharacter is equal to "A"
    case "A":
      
        // Then print "Apple"
        print("Apple")
      
    // If myCharacter is equal to "B"
    case "B":
      
    // No body
      
    // If myCharacter is equal to "C"  
    case "C":
      
        // Then print "Cat" 
        print("Cat")
      
    // If myCharacter is equal to "D"   
    case "D":
      
        // Then print "Dog"   
        print("Dog")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

main.swift:18:5: error: 'case' label in a 'switch' should have at least one executable statement
    case "B":
    ^~~~~~~~~
              break

Explicación: En el programa anterior, myCharacter es igual a «B». Aunque tenemos una condición de caso para manejar este caso, no contiene ninguna instrucción ejecutable en el cuerpo. 

Coincidencia de intervalos

Swift proporciona una funcionalidad mediante la cual podemos usar la coincidencia de intervalos como una condición de caso en una declaración de cambio.

Sintaxis:

case myValue1..<myValue2:
// body of case

Si el valor de la expresión variable se encuentra entre myValue1 y myValue2 inclusive, se ejecutará el cuerpo del caso anterior.

Ejemplo:

// Swift program to illustrate the interval 
// matching in the switch statement
  
// Initializing an integer
var myInteger = 18
  
// Switch block 
switch myInteger 
{
      
    // If myInteger is equal to 2
    case 2:
      
        // Then print "Apple"
        print("Equal to 2")
      
    // If myInteger is between 3 and 5
    case 3..<5:
      
        // Then print "Between 3 and 5"  
        print("Between 3 and 5")
      
    // If myInteger is between 6 and 10  
    case 6..<10:
      
        // Then print "Between 6 and 10"  
        print("Between 6 and 10")
      
    // If myInteger is between 11 and 22
    case 11..<22:
      
        // Then print "Between 11 and 22"  
        print("Between 11 and 22")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

Between 11 and 22

Coincidencia de tuplas

En Swift, una tupla se usa para contener o agrupar varios elementos. Los elementos de una tupla pueden ser del mismo tipo así como de diferentes tipos. Podemos inicializar una tupla en Swift usando la siguiente sintaxis.

Sintaxis:

var myTuple = (myElement1, myElement2, . . . .)

Swift nos proporciona una funcionalidad mediante la cual podemos usar una tupla como una expresión variable, así como una condición de caso en una declaración de cambio para probar múltiples valores. Cada elemento de la tupla se compara con un valor diferente. O podemos usar el carácter de subrayado (_) para hacer coincidir el valor posible. Aquí, el carácter de subrayado se conoce como patrón comodín.

case (value1, value2,. . . .):
// Body of case
case(_, value1):
// Body of case

Ejemplo:

// Swift program to illustrate the working
// of tuples with switch statement
  
// Initializing a tuple
var myTuple = (4, 10)
  
// Switch block 
switch myTuple 
{
  
    // If myTuple is equal to (2,3)
    case (2, 3):
      
        // Then print
        print("First case gets executed")
      
    // If myTuple is (between 1 and 3,between 5 and 11) 
    case (1...3, 5...11):
      
        // Then print  
        print("Second case gets executed")
      
    // If myTuple is (between 1 and 5, between 8 and 13)   
    case (1...5, 8...13):
      
        // Then print  
        print("Third case gets executed")
          
    // If myTuple is (between 11 and 13, between 15 and 18) 
    case (11...13, 15...18):
      
        // Then print  
        print("Fourth case gets executed")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

Third case gets executed

Enlace de valor

Swift nos permite inicializar una variable temporal en una condición de caso en declaraciones de cambio, esta variable solo es accesible en el cuerpo del caso en el que se inicializa. Esta propiedad se conoce como enlace de valor.

Sintaxis

case (let myElement1, let myElement2,..., let myElementN value1, value2, ...., valueN):
     // body

Ahora, si todos los valores constantes de la condición del caso coinciden con los valores de la expresión variable, el resto de los valores se asignan automáticamente a las variables temporales correspondientes y se ejecutará el cuerpo del caso.

Ejemplo:

// Swift program to illustrate the working 
// of value binding with switch statement
  
// Initializing a tuple
var myTuple = (2, 4, 6)
  
// Switch block 
switch myTuple 
{
  
    // If myTuple is equal to (2,3)
    case (let myElement1, 3, 6):
      
        // Then print
        print("myElement1 is equal to \(myElement1)")
      
    // If myTuple is (between 1 and 3, between 5 and 11) 
    case (let myElement1, let myElement2, 6):
      
        // Then print
        print("myElement1 is equal to \(myElement1)", 
              "myElement3 is equal to \(myElement2)")
      
    // If myTuple is (between 1 and 5, between 8 and 13)   
    case (let myElement1, let myElement2, let myElement3):
      
        // Then print
        print("myElement1 is equal to \(myElement1)", 
              "myElement1 is equal to \(myElement2)", 
              "myElement1 is equal to \(myElement3)")
      
}

Producción:

myElement1 is equal to 2 myElement3 is equal to 4

Explicación: En el programa anterior, myTuple es igual a (2, 4, 6). Para la condición del primer caso, como el segundo valor de la tupla no es igual al segundo valor de myTuple, el cuerpo de este caso no se ejecuta. Para la segunda condición de caso, como el tercer elemento de la tupla es igual al tercer valor de myTuple, los valores del primer y segundo elemento se vinculan automáticamente con el primer y segundo elemento de la condición de caso.

Uso de la cláusula where con una declaración de cambio

Swift también acepta la cláusula where en caso de condición en una declaración de cambio mediante la cual podemos ejecutar declaraciones. o podemos decir que la cláusula where se usa para verificar condiciones extra o adicionales.

Sintaxis:

case let(myElement1, myElement2) where "condition":
     // body

Ejemplo:

// Swift program to illustrate the 
// working of where clause with switch statement
  
// Initializing a tuple
var myTuple = (20, 10)
  
// Switch block 
switch myTuple
{
  
    // If myElement1 is thrice of myElement2
    case let (myElement1, myElement2) where myElement1 == 3 * myElement2:
        
        // Then print
        print("myElement1 is thrice of myElement2")
      
    // If myElement1 is twice of myElement2
    case let (myElement1, myElement2) where myElement1 == 2 * myElement2:
       
        // Then print
        print("myElement1 is twice of myElement2")
      
    // If myElement1 is equal to myElement2
    case let (myElement1, myElement2) where myElement1 ==  myElement2:
      
        // Then print
        print("myElement1 is equal to myElement2")
      
    default:
      
        // Then print
        print("Invalid")
}

Producción:

myElement1 is twice of myElement2

Uso de casos compuestos con una declaración de cambio

En Swift, podemos usar casos compuestos con una declaración de cambio. Las condiciones de caso que comparten un cuerpo común pueden agruparse usando comas ( , ). O podemos decir que cuando varios casos separados por comas tienen el mismo cuerpo, los casos se conocen como casos compuestos. En casos compuestos, si algún patrón coincide con la condición de cambio, ese caso se considera una coincidencia. Esta técnica debe seguirse siempre que sea necesario, ya que reduce el tamaño del código y mejora la calidad de nuestro código.

Sintaxis:

case condition1, condition2, ....:
    // body

Ejemplo:

// Swift program to illustrate the compound cases
  
// Initializing a character
var myCharacter = "B"
  
// Switch block 
switch myCharacter
{
  
    // If myCharacter is equal to either "A" or "B"
    case "A", "B":
      
        // Then print "Either Apple or Boy"
        print("Either Apple or Boy")
      
    // If myCharacter is equal to "C"  
    case "C":
      
        // Then print "Cat" 
        print("Cat")
      
    // If myCharacter is equal to "D"   
    case "D":
      
        // Then print "Dog"   
        print("Dog")
      
    // Default statement
    default:
        print("Invalid")
}

Producción:

Either Apple or Boy