Compartir a través de

about_Switch

  • Artículo

Descripción breve

Explica cómo usar un modificador para controlar varias if instrucciones.

Descripción larga

Para comprobar una condición en un script o una función, use una if instrucción . La if instrucción puede comprobar muchos tipos de condiciones, incluido el valor de las variables y las propiedades de los objetos.

Para comprobar varias condiciones, use una switch instrucción . La switch instrucción es equivalente a una serie de if instrucciones, pero es más sencilla. La switch instrucción enumera cada condición y una acción opcional. Si se obtiene una condición, se realiza la acción.

La switch instrucción puede usar las $_ variables automáticas y $switch . Para obtener más información, vea about_Automatic_Variables.

Sintaxis

Una instrucción básica switch tiene el formato siguiente:

Switch (<test-expression>)
{
    <result1-to-be-matched> {<action>}
    <result2-to-be-matched> {<action>}
}

Las instrucciones equivalentes if son:

if (<result1-to-be-matched> -eq (<test-expression>)) {<action>}
if (<result2-to-be-matched> -eq (<test-expression>)) {<action>}

<test-expression> es una expresión única que se evalúa en modo de expresión para devolver un valor.

<result-to-be-matched> es una expresión cuyo valor se compara con el valor de entrada. Las expresiones incluyen valores literales (cadenas o números), variables y bloques de script que devuelven un valor booleano.

Cualquier valor sin comilla que no se reconozca como un número se trata como una cadena. Para evitar confusiones o conversión de cadenas no deseadas, siempre debe comillar valores de cadena. Incluya las expresiones entre paréntesis (), creando subexpresiones, para asegurarse de que la expresión se evalúa correctamente.

Es importante comprender que el <result-to-be-matched> valor está en el lado izquierdo de la expresión de comparación. Esto significa que el resultado de <test-expression> se encuentra en el lado derecho, que se puede convertir al tipo del valor del lado izquierdo para la comparación. Para obtener más información, consulte about_Comparison_Operators

El valor default está reservado para la acción utilizada cuando no hay ninguna otra coincidencia.

La $_ variable automática contiene el valor de la expresión que se pasa a la switch instrucción y está disponible para la evaluación y el uso dentro del ámbito de las <result-to-be-matched> instrucciones.

La sintaxis de instrucción completa switch es la siguiente:

switch [-regex | -wildcard | -exact] [-casesensitive] (<test-expression>)
{
    "string" | number | variable | { <value-scriptblock> } { <action-scriptblock> }
    default { <action-scriptblock> } # optional
}

o

switch [-regex | -wildcard | -exact] [-casesensitive] -file filename
{
    "string" | number | variable | { <value-scriptblock> } { <action-scriptblock> }
    default { <action-scriptblock> }  # optional
}

Si no se usa ningún parámetro, switch se comporta igual que con el parámetro Exact . Realiza una coincidencia que no distingue mayúsculas de minúsculas para el valor. Si el valor es una colección, cada elemento se evalúa en el orden en que aparece.

La switch instrucción debe incluir al menos una instrucción condition.

La default cláusula se desencadena cuando el valor no coincide con ninguna de las condiciones. Es equivalente a una else cláusula de una if instrucción . Solo se permite una default cláusula en cada switch instrucción.

switch tiene los parámetros siguientes:

  • Comodín : indica que la condición es una cadena comodín. Si la cláusula match no es una cadena, se omite el parámetro . La comparación distingue entre mayúsculas y minúsculas.
  • Exacto : indica que la cláusula match, si es una cadena, debe coincidir exactamente. Si la cláusula match no es una cadena, este parámetro se omite. La comparación distingue entre mayúsculas y minúsculas.
  • CaseSensitive : realiza una coincidencia que distingue mayúsculas de minúsculas. Si la cláusula match no es una cadena, este parámetro se omite.
  • Archivo: toma la entrada de un archivo en lugar de .<test-expression> Si se incluyen varios parámetros File , solo se usa el último. La instrucción lee y evalúa switch cada línea del archivo. La comparación distingue entre mayúsculas y minúsculas.
  • Regex : realiza la coincidencia de expresiones regulares del valor con la condición. Si la cláusula match no es una cadena, este parámetro se omite. La comparación distingue entre mayúsculas y minúsculas. La $matches variable automática está disponible para su uso en el bloque de instrucciones coincidente.

Nota:

Al especificar valores conflictivos, como Regex y Wildcard, el último parámetro especificado tiene prioridad y se omiten todos los parámetros en conflicto. También se permiten varias instancias de parámetros. Sin embargo, solo se usa el último parámetro enumerado.

Ejemplos

En el ejemplo siguiente, la switch instrucción compara el valor de prueba, 3, con cada una de las condiciones. Cuando el valor de prueba coincide con la condición, se realiza la acción.

switch (3)
{
    1 {"It is one."}
    2 {"It is two."}
    3 {"It is three."}
    4 {"It is four."}
}

It is three.

En este ejemplo sencillo, el valor se compara con cada condición de la lista, aunque haya una coincidencia para el valor 3. La instrucción siguiente switch tiene dos condiciones para un valor de 3. Muestra que, de forma predeterminada, se prueban todas las condiciones.

switch (3)
{
    1 {"It is one."}
    2 {"It is two."}
    3 {"It is three."}
    4 {"It is four."}
    3 {"Three again."}
}

It is three.
Three again.

Para dirigir a switch que deje de compararse después de una coincidencia, use la break instrucción . La break instrucción finaliza la switch instrucción .

switch (3)
{
    1 {"It is one."}
    2 {"It is two."}
    3 {"It is three."; Break}
    4 {"It is four."}
    3 {"Three again."}
}

It is three.

Si el valor de prueba es una colección, como una matriz, cada elemento de la colección se evalúa en el orden en que aparece. En los ejemplos siguientes se evalúan 4 y 2.

switch (4, 2)
{
    1 {"It is one." }
    2 {"It is two." }
    3 {"It is three." }
    4 {"It is four." }
    3 {"Three again."}
}

It is four.
It is two.

Las break instrucciones se aplican a la colección, no a cada valor, como se muestra en el ejemplo siguiente. La switch instrucción finaliza mediante la break instrucción en la condición del valor 4.

switch (4, 2)
{
    1 {"It is one."; Break}
    2 {"It is two." ; Break }
    3 {"It is three." ; Break }
    4 {"It is four." ; Break }
    3 {"Three again."}
}

It is four.

En este ejemplo, la switch instrucción está probando el tipo del valor en la tabla hash. Debe usar y expresión que devuelva un valor booleano para seleccionar el scriptblock que se va a ejecutar.

$var = @{A = 10; B = 'abc'}

foreach ($key in $var.Keys) {
    switch ($var[$key].GetType()) {
        { $_ -eq [int32]  }  { "$key + 10 = $($var[$key] + 10)" }
        { $_ -eq [string] }  { "$key = $($var[$key])"           }
    }
}

A + 10 = 20
B = abc

En este ejemplo, un objeto que no es una cadena o datos numéricos se pasa a .switch switch realiza una coerción de cadena en el objeto y evalúa el resultado.

$test = @{
    Test  = 'test'
    Test2 = 'test2'
}

$test.ToString()

switch -Exact ($test)
{
    'System.Collections.Hashtable'
    {
        'Hashtable string coercion'
    }
    'test'
    {
        'Hashtable value'
    }
}

System.Collections.Hashtable
Hashtable string coercion

En este ejemplo, no hay ningún caso coincidente, por lo que no hay ninguna salida.

switch ("fourteen")
{
    1 {"It is one."; Break}
    2 {"It is two."; Break}
    3 {"It is three."; Break}
    4 {"It is four."; Break}
    "fo*" {"That's too many."}
}

Al agregar la default cláusula , puede realizar una acción cuando ninguna otra condición se realice correctamente.

switch ("fourteen")
{
    1 {"It is one."; Break}
    2 {"It is two."; Break}
    3 {"It is three."; Break}
    4 {"It is four."; Break}
    "fo*" {"That's too many."}
    Default {
        "No matches"
    }
}

No matches

Para que la palabra "catorce" coincida con un caso, debe usar el -Wildcard parámetro o -Regex .

   PS> switch -Wildcard ("fourteen")
       {
           1 {"It is one."; Break}
           2 {"It is two."; Break}
           3 {"It is three."; Break}
           4 {"It is four."; Break}
           "fo*" {"That's too many."}
       }

That's too many.

En el ejemplo siguiente se usa el -Regex parámetro .

$target = 'https://bing.com'
switch -Regex ($target)
{
    '^ftp\://.*$' { "$_ is an ftp address"; Break }
    '^\w+@\w+\.com|edu|org$' { "$_ is an email address"; Break }
    '^(http[s]?)\://.*$' { "$_ is a web address that uses $($matches[1])"; Break }
}

https://bing.com is a web address that uses https

En el ejemplo siguiente se muestra el uso de bloques de script como switch condiciones de instrucción.

switch ("Test")
{
    {$_ -is [String]} {
        "Found a string"
    }
    "Test" {
        "This $_ executes as well"
    }
}

Found a string
This Test executes as well

En el ejemplo siguiente se procesa una matriz que contiene dos valores de fecha. <value-scriptblock> Compara la propiedad Year de cada fecha. <action-scriptblock> muestra un mensaje de bienvenida o el número de días hasta el comienzo del año 2022.

switch ((Get-Date 1-Jan-2022), (Get-Date 25-Dec-2021)) {
    { $_.Year -eq 2021 } {
        $days = ((Get-Date 1/1/2022) - $_).days
        "There are $days days until 2022."
    }
    { $_.Year -eq 2022 } { 'Welcome to 2022!' }
}

Si el valor coincide con varias condiciones, se ejecuta la acción de cada condición. Para cambiar este comportamiento, use las break palabras clave o continue .

La palabra clave detiene el break procesamiento y sale de la switch instrucción .

La continue palabra clave detiene el procesamiento del valor actual, pero continúa procesando los valores posteriores.

En el ejemplo siguiente se procesa una matriz de números y se muestra si son impares o incluso. Los números negativos se omiten con la continue palabra clave . Si se encuentra un no número, la ejecución finaliza con la break palabra clave .

switch (1,4,-1,3,"Hello",2,1)
{
    {$_ -lt 0} { continue }
    {$_ -isnot [Int32]} { break }
    {$_ % 2} {
        "$_ is Odd"
    }
    {-not ($_ % 2)} {
        "$_ is Even"
    }
}

1 is Odd
4 is Even
3 is Odd

Consulte también