Switch powershell: Everything you ever wanted to know about the switch statement — PowerShell

Содержание

Примеры работы с Powershell Switch

Powershell Switch — это одна из особенностей, которое отличает язык команд от других. Самое первое условие, с которым мы начинаем работу в любых языках это IF. Его конструкция следующая:


If (Get-Item $way)
{
 Get-Content $way
}

Чаще нам нужно использовать сразу несколько условий прибегая к конструкциям elseif и else:


$day = (Get-Date).DayOfWeek
$day
if ($day -eq 'Sunday'){$result = 'Воскресенье'}
elseif ($day -eq 'Monday'){$result = 'Понедельник'}
elseif ($day -eq 'Tuesday'){$result = 'Вторник'}
elseif ($day -eq 'Wednesday'){$result = 'Среда'}
elseif ($day -eq 'Thursday'){$result = 'Четверг'}
elseif ($day -eq 'Friday'){$result = 'Пятница'}
elseif ($day -eq 'Saturday'){$result = 'Суббота'}
else {$result = 'Неизвестно'}
$result

Такой подход очень частый в использовании и один из способов решения это использование switch.

В отличие от IF оператор Switch позволяет указывать переменную со значением единожды. Так будет выглядеть прошлый пример в варианте со Switch:


$day = (Get-Date).DayOfWeek
switch ($day)
{
'Sunday' {$rus_date = 'Воскресенье'}
'Monday'{$rus_date = 'Понедельник'}
'Tuesday' {$rus_date = 'Вторник'}
'Wednesday' {$rus_date = 'Среда'}
'Thursday' {$rus_date = 'Четверг'}
'Friday' {$rus_date = 'Пятница'}
'Saturday' {$rus_date = 'Суббота'}
}
$rus_date

Мы передали переменную $day единожды и нам не нужно каждый раз выполнять сравнение. После успешного сравнения переменная $rus_date примет указанное значение.

В случаях со сравнением не обязательно указывать кавычки, но рекомендуется так как в случае использования символов типа проблема мы получим ошибки.

Предыдущий вариант можно еще больше сократить присвоив Switch в переменную:


$day = (Get-Date). DayOfWeek
$var = switch ($day)
{
'Sunday' {'Воскресенье'}
'Monday'{'Понедельник'}
'Tuesday' {'Вторник'}
'Wednesday' {'Среда'}
'Thursday' {'Четверг'}
'Friday' {'Пятница'}
'Saturday' {'Суббота'}
}
$var

По сути мы помещаем в переменную $var первый результат вернувший из конвейера True. Кроме строковых значений мы можем хранить и численные.

Значение Default — это как else, который будет присвоен если ни одно значение не совпадет:


$month = (Get-Date).Month
$month_rus = switch ($month)
{
1 {'Январь'}
2 {'Февраль'}
3 {'Март'}
default {'Месяц не перечислен'}
}
$month_rus

Мы можем использовать Switch с массивами. Будет проверено каждое значение, которое в нем находится. Пример ниже сработает только на ОС с русской локализацией иначе примется значение default:


$modules = (Get-Module). Name
$modules.GetType()
$modules_installed = switch($modules) {
'Dism' {'Управление дисками'}
'Microsoft.PowerShell.Management' {'Модуль для обслуживания систем'}
'Microsoft.PowerShell.Security' {'Модуль безопасности'}
default {'Такой модуль не указан'}
}
$modules_installed

После выполнения команды $modules_installed так же будет массивом вне зависимости от того сколько значений у нас было. Если у нас много одинаковых значений, то все они будут проверены.

Мы можем использовать дополнительные параметры при использовании switch.

-Wildcard

Параметр Wildcard позволяет использовать маски. Для примера мы хотим найти слово ‘параллелепипед’ в какой-то длинной строке (тексте) и мы можем использовать четыре способа:

*параллелепипед* — говорит о том, что мы может быть текст слева и справа.

параллелепипед* — значит, что текст начинается с этого слова, но после него идет какой-то текст.

*параллелепипед — текст заканчивается на это слово, но слева от него может быть текст.

*пара*елепипед* — в этом случае подразумеваеться что есть текст до «пара», затем какое-то количество символов до «елепипед» и после него текст.

Если знаки * не указаны, то будет искаться точные соответствия:


$string = 'Как использовать swich в Powershell и не допустить ошибку'
$search = switch -Wildcard ($string){
'*Powershell*' {'Тут идет речь про Powershell'}
'*Ошибку' {'Тут так же идет речь про ошибки, регистр не важен'}
'Как*' {'Это слово ищется только в начале строки'}
'*Испо*ь*' {'Пропуск букв'}
'использовать' {'Это не найдется, так как не указан знак *'}}
$string

Такой вариант сработает и с массивами:


$array = 'Текст один', 'два'
$search = switch -Wildcard ($array){
'*оди*' {'Это текст один'}
'два' {'Точное соответствие'}}
$search

-regex

Так же как макси мы можем использовать регулярные выражения, но знак * в регулярных выражениях и масках работает по-разному. На примере ниже ищется IP адрес в массиве:


$regular_mask_ip = "(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
$vals = 'smt','192.168.3.1','255.255.255.0','another var'
$find_ip = switch -regex ($vals){
$regular_mask_ip {'Похоже на IP: ' + $PSItem}
default {'Это не IP: '+ $PSItem}
}

Вы можете заметить, что мы можем передавать значение в виде переменных. $PSItem — это текущее значение, которое выполняется при сравнении. Чаще эту переменную указывают как «$_» .

-File

Отдельно и вместе с параметром маски и регулярных значений мы можем указывать и путь к файлу:


$path = 'C:\Windows\System32\drivers\etc\hosts'
$sw = switch -Wildcard -File $path {
"*localhost*" {'localhost прописан'}
"*127.0.0.1*" {'127. 0.0.1 тоже прописан '}
}
$sw

-casesensitive

Casesensitive добавляет учет регистра при анализе:


$word = 'Text'
$sw = switch -CaseSensitive ($word){
"text" {'Не будет учтен, так как пишется с маленькой буквы'}
"texT" {'Буквы отличаются'}
"Text" {'Полное совпадение'}
}
$sw

В этой главе рассмотрим дополнительные возможности применения в скриптах.

Выражения

Вместе значения, которое мы передаем в switch, можно использовать командлет. Для примера так я найду отключенных пользователей не объявляя отдельную переменную:


$users = switch ((Get-LocalUser | where -Property Enabled -eq $False).Name){
'Гость' {"Пользователь $PSItem выключен"}
'Guest' {"Пользователь $PSItem выключен"}
'Администратор' {"Пользователь $PSItem выключен"}
'Administrator' {"Пользователь $PSItem выключен"}
}

Обратите внимание, что переменные включаются в строки при двойных кавычках.

Вам так же будет интересно:

Как работать с операторами сравнения в Powershell

Поиск дополнительных вхождений

Если условия поиска совпадут, то это не значит что совпадения не будут искаться дальше. Это имеет весомое значение, когда мы используем регулярные выражения:


$val = '192.168.1.1'
switch -Wildcard ($val){
'*.*' {'Тут сработало'}
'*1*' {'И тут сработало'}
'*2*' {'И тут'}}

О том как избежать возможных проблем будет рассмотрено дальше.

Continue

Когда нам нужно найти все совпадающие значение, но единожды, нужно использовать Continue. Результат работы хорошо виден с массивами:


$val = '1','2','3'
switch($val){
'1' {'Это значение больше не будет проверяться' 
     continue}
'1' {'Этого текста не будет' 
     continue}
'2' {'Первый раз 2'}
'2' {'Второй раз 2'}
}

На примере 2 видно, что она проверяется каждый раз, так как в ней не указан Continue. Такой же подход будет работать и при регулярных выражениях.

В этом сценарии 6 будет проверена дважды, так как предыдущее выражение используется раньше и не использует Continue:


$val = '6','5'
switch($val){
'6' {'Первый' 
     }
'6' {'Второй' 
     continue}
}

Break

В отличие от Continue при использовании Break выполнения сравнение прервется на 1 не проверяя дальнейшие значения:


$val = '1','2','3'
switch($val){
'1' {'Это значение больше не будет проверяться' 
     break}
'1' {'Этого текста не будет' 
     }
'2' {'Первый раз 2'}
'2' {'Второй раз 2'}
}

Так же как и в Continue чем ниже оно находится, тем больше сравнений будет выполнено:


$for_break = 'Inet1','Inet2','Inet3','Inet4'
switch($for_break){
'Inet1' {'Продолжение 1'}
'Inet2' {'Продолжение 2'
continue}
'Inet3' {'Остановка выполнения'
break}
'Inet4' {'Не будет использоваться'}
}

Дополнительные условия

Вместо значений с которыми мы сравниваем можно использовать дополнительные условия:


$kopilka = 3000
switch($kopilka){
	{$PSItem -eq 3000}
		{'Кушай доширак'
		continue}
	{$PSItem -le 6000}
		{'Можно купить сосиски'
		continue}
	{$PSItem -le 9000}
		{'Возьму в кредит iPhone'
		continue}
default {'Моя копилка давно сломана'}
}

Можно добавить более интересные условия, но такой подход затруднит чтение кода. Скрипт ниже проверяет могут ли указанные пользователи менять пароль:


$case = 'Гость','Guest','Администратор','Administrator'
switch($case){
	{(Get-LocalUser -Name $PSItem).UserMayChangePassword -eq $False}
		{"Пользователь $PSItem не может менять пароль"
		continue}
	{(Get-LocalUser -Name $PSItem).UserMayChangePassword -eq $True}
		{"Пользователь $PSItem может менять пароль"
		continue}
	default {"Пользователя $PSItem нет в базе"}
}

Использование переменной $matches

Когда мы использовали регулярные выражения в массиве, мы выводили значение массива. Когда нам нужно вывести значение найденное через регулярное выражение нужно использовать $matches:


$case = 'Text 1234 text'
switch -regex ($case){
'(?<num>\d\d\d\d)' {"В тексте такие цифры $($matches.num)"}
}

Вам так же будет интересно:

Powershell настраиваем IP адрес

$null

С помощь switch удобно проверять на пустые значения:


$str = @($null,'',' ','Значения')
switch ($str){
$null {continue}
' ' {continue}
'' {continue}
'Значения' {'Работает'}
}

Можно обернуть в функцию и обращаться к ней для проверки:


function Check-Null($var){
    $result = switch ($var){
        $null {$false
            continue}
        ' ' {$false 
            continue}
        '' {$false 
            continue}
        default { $true
            continue}
         }
    $result
    return $result
}

Check-Null
Check-Null 'sss'

Вложенная проверка

Мы можем делать вложенную проверку, которая выполнит другие условия если первое является истиной. На примере ниже условия выполнятся если каждое из условий True:


# Объявляем имя пользователя
$user_name = 'Administrator'
# Получаем данные с AD
$user_data = Get-ADUser -Identity $user_name -Properties * | select *
# Узнаем устарел ли пароль (True или False)
$user_pass_exp = $user.PasswordExpired
# Заблокирован ли пользователь (True или False)
$user_locked = $user.LockedOut
# Если пользователь найден, то switch работает
$result = switch($user_data){
	# Если пользователь заблокирован, он разблокируется
	$user_locked {Unlock-ADAccount -identity $user_name}
	# Если пароль устаревший, то пароль будет запрошен для смены.
	$user_pass_exp {$password = Read-Host "Enter new password" -AsSecureString
				Set-ADAccountPassword -Identity $user_name -NewPassword $password}
}

О том как получать данные пользователей из AD в Powershell вы можете почитать в предыдущих статьях.

…

Рекомендую

Подписывайтесь на наш Telegram канал

Теги:

#powershell

Использование оператора Switch в PowerShell

Обычно для проверки какого либо условия в PowerShell используется конструкция If — Else. Напомню, что оператор If предназначен для проверки условия и выполнения определенного действия, связанного с этим условием. Если заданное условие соблюдено, то выполняем одно действие, если не соблюдено — то другое.

В принципе в одном скрипте подобную проверку можно выполнять неограниченное число раз, однако если условий много, то использование If становится несколько неудобным.

Поэтому при большом количестве проверяемых условий лучше применять оператор Switch, который позволяет объединять список условий в одной инструкции. Switch поочередно сопоставляет проверяемое значение (value) с каждым заданным условием (condition), и если находит совпадение, то выполняет действие (action), связанное с этим условием. Синтаксис выглядит так:

Switch (value) {
condition 1 {action}
condition 2 {action}
condition n {action}}

В качестве простого примера возьмем скрипт, в котором производится проверка значения переменной $a на соответствие одному из трех значений. При совпадении выводится найденное значение переменной:

$a = 1
Switch ($a) {
1 {″one″}
2 {″two″}
3 {″three″}}
Write-Host ″switched″

Как видно из предыдущего примера, действие производится только при совпадении значений. Если вы хотите, чтобы действие выполнялось и при отсутствии совпадений, то можно указать ключевое слово Default. В этом случае если ни одно из условий не будет выполнено, то будет произведено действие по умолчанию, указанное после Default. Например:

$a = 4
Switch ($a) {
1 {″one″}
2 {″two″}
3 {″three″}
Default {″Out of range″; exit}
}
Write-Host ″switched″

Может быть так, что в списке окажется несколько одинаковых условий, как в следующем примере:

$a = 1
switch ($a) {
1 {″one″}
2 {″two″}
3 {″three″}
1 {″another one″}
DEFAULT {″Out of range″; exit}
}
Write-Host ″switched″

Как видите, в этом случае оператор Switch выполнил оба действия. Если значение переменной совпало с одним из условий и код выполнился, обработка не прерывается, а производится сравнение со следующим условием и так далее. Избежать этого можно с помощью ключевых слов Break и Continue.

Указанное в конце инструкции, Break предписывает в случае совпадения прекратить дальнейший поиск и выполнить указанное действие. Ключевое слово Break означает, что обработка больше не выполняется и оператор Switch завершает свою работу.

$a = 1
switch ($a) {
1 {″one″, break}
2 {″two″}
3 {″three″}
1 {″another one″}
DEFAULT {″Out of range″; exit}
}
Write-Host ″switched″

Ключевое слово Continue указывает, что обработка текущего условия завершена и не будет продолжаться, после чего начнется поиск следующего условия. Т.е. в отличие от Break, Continue не завершает работу Switch, а переходит к следующему условию:

$a = 1
switch ($a) {
1 {″one″, continue}
2 {″two″}
3 {″three″}
1 {″another one″}
DEFAULT {″Out of range″; exit}
}
Write-Host ″switched″

Switch позволяет работать не только с константами. Так в качестве проверяемого значения можно указать одно выражение PowerShell, а вместо условия — другое. Для примера проверим состояние сервиса Spooler, и если он в выключенном состоянии, то включим его:

switch (Get-Service | where {$_.name -eq ″spooler″}) {
{$_.status -eq ″Running″} {″Service is running″}
{$_.status -eq ″Stopped″} {″Service is stopped, starting…″; Start-Service spooler}
}

Еще оператор Switch имеет несколько дополнительных параметров, предназначенных для обработки строк:

Exact — условие является строкой и должно точно соответствовать критерию;
Wildcard — условие является строкой, содержащей подстановочные символы;
Regex — условие содержит регулярные выражения;
CaseSensitive — условие чувствительно к регистру. Если условие не является строкой, то параметр игнорируется;
File — условие берется из файла.

Для примера возьмем текстовый файл с отрывком из ″Хоббита″, а в условии используем подстановочные символы. Условие срабатывает при каждом нахождении слов Hobbit и Baggins:

$content = Get-Content C:\Files\Hobbit.txt
Switch -Wildcard ($content) {
″*Hob*″ {″Word Hobbit is found″}
″*Bagg*″ {″Word Baggins is found″}
}

В статье я привел лишь несколько простых примеров. На самом деле возможности Switch гораздо шире, особенно в сочетании с регулярными выражениями. Но это уже совсем другая история 🙂

о коммутаторе — PowerShell | Microsoft Learn

Статья
19.09.2022

Краткое описание

Объясняет, как использовать переключатель для обработки нескольких операторов if .

Подробное описание

Чтобы проверить условие в сценарии или функции, используйте , если 9Заявление 0016. если оператор может проверять многие типы условий, включая значение переменных и свойства предметов.

Чтобы проверить несколько условий, используйте оператор switch . Оператор switch эквивалентна серии из операторов if , но она проще. Переключатель оператор перечисляет каждое условие и необязательное действие. Если условие выполняется, действие выполняется.

Переключатель 9Оператор 0016 может использовать автоматические переменные $_ и $switch . Для больше информации см. about_Automatic_Variables.

`Синтаксис`

Базовый оператор switch имеет следующий формат:

 Switch ()
{
    <результат1 для сопоставления> {<действие>}
    <результат2 для сопоставления> {<действие>}
}

Эквивалентными операторами if являются:

 if (<результат1 для сопоставления> -eq (<выражение-теста>)) {<действие>}
if ( -eq ()) {}

— это одно выражение, которое оценивается в выражении режим для возврата значения.

<результат для сопоставления> — это выражение, значение которого сравнивается с входное значение. Выражения включают буквенные значения (строки или числа), переменные и блоки сценариев, которые возвращают логическое значение.

Любое значение без кавычек, которое не распознано как число, обрабатывается как строка. Чтобы избежать путаницы или непреднамеренного преобразования строки, вы всегда должны заключать в кавычки строковые значения. Заключите любые выражения в круглые скобки (), создание подвыражения, чтобы убедиться, что выражение оценивается правильно.

Важно понимать, что значение <результат для сопоставления> находится на левая часть выражения сравнения. Это означает, что результат находится в правой части, что может быть преобразовано в тип левого значения для сравнения. Для получения дополнительной информации см. about_Comparison_Operators

Значение по умолчанию зарезервировано для действия, используемого, когда нет других Матчи.

Автоматическая переменная $_ содержит значение выражения, переданного в оператор switch и доступен для оценки и использования в рамках операторы <результат для сопоставления> .

Полный синтаксис оператора switch выглядит следующим образом:

 switch [-regex | -шаблон | -exact] [-с учетом регистра] (<выражение-теста>)
{
    "строка" | номер | переменная | {  } {  }
    default {  } # необязательный
}

или

 переключатель [-regex | -шаблон | -exact] [-с учетом регистра] -file имя файла
{
    "строка" | номер | переменная | {  } {  }
    default {  } # необязательный
}

Если никакие параметры не используются, переключатель ведет себя так же, как при использовании Exact параметр. Он выполняет сопоставление значения без учета регистра. Если значение коллекция, каждый элемент оценивается в том порядке, в котором он появляется.

Оператор switch должен включать хотя бы один оператор условия.

Предложение по умолчанию срабатывает, когда значение не соответствует ни одному из условия. Это эквивалентно предложению else в операторе if . Только один Предложение по умолчанию разрешено в каждом операторе switch .

переключатель имеет следующие параметры:

Подстановочный знак — Указывает, что условие является строкой подстановочного знака. Если предложение match не является строкой, параметр игнорируется. Сравнение без учета регистра.
Exact — указывает, что условие соответствия, если оно является строкой, должно совпадать точно. Если предложение match не является строкой, этот параметр игнорируется. сравнение не чувствительно к регистру.
CaseSensitive — Сопоставление с учетом регистра. Если условие соответствия не строка, этот параметр игнорируется.
Файл — принимает ввод из файла, а не из . Если включены несколько параметров File , используется только последний. Каждый строка файла читается и оценивается оператор переключения . сравнение не чувствительно к регистру.
Regex — выполняет сопоставление регулярного выражения значения с состояние. Если предложение match не является строкой, этот параметр игнорируется. Сравнение нечувствительно к регистру. Автоматическая переменная $matches доступны для использования в соответствующем блоке операторов.

Примечание

При указании конфликтующих значений, таких как Regex и Подстановочный знак , последний указанный параметр имеет приоритет, а все конфликтующие параметры игнорируется. Допускается также несколько экземпляров параметров. Однако только используется последний указанный параметр.

`Примеры`

В следующем примере оператор switch сравнивает проверочное значение 3 с каждое из условий. Когда тестовое значение соответствует условию, действие выполняется.

 переключатель (3)
{
    1 {"Это один."}
    2 {"Это два."}
    3 {"Это три."}
    4 {"Четыре."}
}

 Три.

В этом простом примере значение сравнивается с каждым условием в списке, хотя есть совпадение для значения 3. Следующие переключатель заявление имеет два условия для значения 3. Он демонстрирует, что по умолчанию все условия проверяются.

 переключатель (3)
{
    1 {"Это один."}
    2 {"Это два."}
    3 {"Это три."}
    4 {"Четыре."}
    3 {"Опять три."}
}

 Три.
Снова три.

Чтобы заставить переключатель остановить сравнение после совпадения, используйте прерывание заявление. Оператор break завершает оператор switch .

 переключатель (3)
{
    1 {"Это один."}
    2 {"Это два."}
    3 {"Это три."; Перерыв}
    4 {"Четыре."}
    3 {"Опять три."}
}

 Три.

Если проверочное значение представляет собой набор, например массив, каждый элемент в Коллекция оценивается в том порядке, в котором она появляется. Следующее примеры оценивают 4, а затем 2.

 переключатель (4, 2)
{
    1 {"Это один." }
    2 {"Это два." }
    3 {"Это три." }
    4 {"Четыре." }
    3 {"Опять три."}
}

 Уже четыре.
Это два.

Любые операторы break применяются к коллекции, а не к каждому значению, как показано в следующем примере. Оператор switch завершается оператором break . оператор в условии значения 4.

 переключатель (4, 2)
{
    1 {"Один."; Перерыв}
    2 {"Это два." ; Перерыв }
    3 {"Это три." ; Перерыв }
    4 {"Четыре." ; Перерыв }
    3 {"Опять три."}
}

 Четыре.

В этом примере объект, который не является строкой или числовым значением, передается в переключатель . Переключатель выполняет приведение строки к объекту и оценивает результат.

 $тест = @{
    Тест = 'тест'
    Тест2 = 'тест2'
}
$test.ToString()
переключатель -Точный ($ тест)
{
    'System.Collections.Hashtable'
    {
        «Приведение строки хэш-таблицы»
    }
    'тест'
    {
        'Значение хеш-таблицы'
    }
}

 System.Collections.Hashtable
Приведение строки хеш-таблицы

В этом примере нет подходящего регистра, поэтому нет вывода.

 переключатель ("четырнадцать")
{
    1 {"Один."; Перерыв}
    2 {"Это два."; Перерыв}
    3 {"Это три."; Перерыв}
    4 {"Четыре."; Перерыв}
    "fo*" {"Это слишком много."}
}

Добавив пункт по умолчанию , вы можете выполнять действие, когда нет других условия удаются.

 Переключатель ("четырнадцать")
{
    1 {"Один."; Перерыв}
    2 {"Это два."; Перерыв}
    3 {"Это три."; Перерыв}
    4 {"Четыре."; Перерыв}
    "fo*" {"Это слишком много."}
    По умолчанию {
        "Нет совпадений"
    }
}

 Нет совпадений

Чтобы слово "четырнадцать" соответствовало регистру, необходимо использовать - Подстановочный знак или - Параметр регулярного выражения .

 PS> переключатель - Подстановочный знак ("четырнадцать")
       {
           1 {"Один."; Перерыв}
           2 {"Это два."; Перерыв}
           3 {"Это три."; Перерыв}
           4 {"Четыре."; Перерыв}
           "fo*" {"Это слишком много."}
       }

 Слишком много.

В следующем примере используется параметр -Regex . 9(http[s]?)\://.*$' { "$_ — это веб-адрес, который использует $($matches[1])"; Перерыв } }

 https://bing.com — веб-адрес, использующий https

В следующем примере показано использование блоков сценариев в качестве переключателя условия заявления.

Переключатель

 ("Тест")
{
    {$_ - это [Строка]} {
        «Нашел строку»
    }
    "Тест" {
        "Этот $_ тоже выполняется"
    }
}

 Найдена строка
Этот тест также выполняется

В следующем примере обрабатывается массив, содержащий два значения даты. сравнивает свойство Year каждой даты. отображает приветственное сообщение или количество дней до начало 2022 года.

 переключатель ((Get-Date 1 января 2022 г.), (Get-Date 25 декабря 2021 г.)) {
    {$_.Год-экв 2021} {
        $дней = ((Получить дату 01.01.2022) - $_).дней
        «До 2022 года осталось $дней дней».
    }
    { $_.Year -eq 2022 } { 'Добро пожаловать в 2022!' }
}

Если значение соответствует нескольким условиям, действие для каждого условия казнен. Чтобы изменить это поведение, используйте перерыв или продолжение ключевых слов.

Ключевое слово break прекращает обработку и выходит из оператора switch .

Ключевое слово continue прекращает обработку текущего значения, но продолжает обработка любых последующих значений.

В следующем примере обрабатывается массив чисел и отображается, если они нечетное или четное. Отрицательные числа пропускаются с ключевым словом continue . Если встречается не число, выполнение прекращается с сломать ключевое слово .

 переключатель (1,4,-1,3,"Привет",2,1)
{
    {$_ -lt 0} {продолжить}
    {$_ - не [Int32]} { перерыв }
    {$_ % 2} {
        "$_ нечетно"
    }
    {-не ($_ % 2)} {
        "$_ четно"
    }
}

 1 нечетный
4 четно
3 нечетное

`См. также`

about_Break
about_Continue
о_Если
about_Script_Blocks

Коммутатор

`— PowerShell — SS64.com Коммутатор`

— PowerShell — SS64.com

СС64
PowerShell
Практическое руководство

Проверка нескольких условий, альтернатива использованию нескольких операторов if.

 Краткий синтаксис

      Переключатель ($ деталь )
      {
         значение  {  выражение  }
         значение  {  выражение  }
      }

Полный синтаксис

      Переключить [-регулярное выражение | -шаблон | -точный ] [-с учетом регистра] (   трубопровод   )
      {
        " строка " |  номер  |  переменная  | {  выражение  } {  список операторов  }
        [ по умолчанию {  список операторов  } ]
      }

      Переключить [-регулярное выражение | -шаблон | -exact ] [-с учетом регистра]  -file  имя файла  
      {
        " строка " |  номер  |  переменная  | {  выражение  } {  список операторов  }
        [ по умолчанию {  список операторов  } ]
      }
Ключ

     -r  egex Рассматривать предложение match, если оно является строкой, как регулярное выражение. 

   по умолчанию Это обеспечивает необязательный «улов» для любых элементов данных, которые не указаны явно.
                обрабатывается в списке операторов switch.
                Добавьте «по умолчанию {  список операторов  }» в качестве последнего варианта.
                «По умолчанию» будет использоваться только в том случае, если не найдено совпадений для других условий.

     -w  ildcard Рассматривать предложение match, если это строка, как строку с подстановочными знаками
                Подстановочные знаки:
                    ? = Любой одиночный неопределенный символ.
                    * = ноль или более неуказанных символов.
                  [a-b] = любой символ в диапазоне a-b
                  [ab] = указанные символы.
                Совпадение с подстановочным знаком не чувствительно к регистру

     -e  xact Точное совпадение строк (отключить подстановочные знаки)

   -c  асечувствительный Изменить условие соответствия, если оно является строкой, с учетом регистра

     -f  ile Получить ввод из файла (или представителя)

Опции переключения могут быть указаны в сокращенном формате с использованием первой буквы, поэтому -e эквивалентно -exact

.

Каждый случай проверяется по очереди, как и многие операторы if-else, поэтому рассмотрите возможность размещения наиболее распространенных случаев первыми.

Ключевое слово break указывает, что дальнейшая обработка не будет выполняться и оператор switch завершит работу.

Ключевое слово continue указывает, что обработка текущей лексемы не будет продолжена, и будет оцениваться следующая лексема в условном выражении. Если токены недоступны, оператор switch завершит работу.

Если конвейер приводит к массиву, каждый элемент массива будет оцениваться в порядке возрастания смещения (начиная с 0). Должен присутствовать хотя бы один элемент, отвечающий хотя бы одному условию, иначе возникнет ошибка.

`Примеры`

Чтобы сравнить два значения, строку, число или что-либо еще, мы могли бы использовать простой оператор IF:

$фрукт = "апельсин"

If ($fruit -eq "orange") {'Мы нашли апельсин'}

В этом примере мы просто повторяем строку текста, но выражение может быть чем угодно, копированием файла, запуском службы, чем угодно.

Чтобы протестировать более одного элемента, мы можем расширить это с помощью одного или нескольких операторов Elseif():

If ($fruit -eq "orange") {'Мы нашли апельсин'} ElseIf ($fruit -eq "apple") {'Мы нашли яблоко'} ElseIf ($fruit -eq "груша") {'Мы нашли грушу'}

Пока все хорошо, но для более чем пары тестов IF и ElseIf стали слишком многословными, нам пришлось повторять имя переменной $fruit в каждой строке. Оператор switch делает то же самое, но вводит гораздо меньше текста:

.

 $fruit = "апельсин"

переключатель ($ фрукты)  { 
   "apple" {"Мы нашли яблоко"; перерыв}
   "pear" {"Мы нашли грушу"; перерыв}
   "orange" {"Мы нашли апельсин"; перерыв}
   "персик" {"Мы нашли персик"; перерыв}
   "banana" {"Мы нашли банан"; перерыв}
   default {"Произошло что-то еще"; перерыв}
  }

`Сохранить результат`

Чтобы сохранить вывод switch в переменной, ее можно назначить прямо в начале с помощью конвейера, а не в каждом блоке скрипта.
 $fruit = "апельсин"

$ результат = переключатель ($ фрукты)  { 
   "apple" {"Мы нашли яблоко"; перерыв}
   "pear" {"Мы нашли грушу"; перерыв}
   "orange" {"Мы нашли апельсин"; перерыв}
   "персик" {"Мы нашли персик"; перерыв}
   "banana" {"Мы нашли банан"; перерыв}
   default {"Произошло что-то еще"; перерыв}
  } 

$результат 

`ПЕРЕРЫВ`

Разрыв в конце каждого условия указывает коммутатору прекратить дальнейшие поиски, если вы его пропустите, оператор switch продолжит проверку всех других параметров и потенциально может соответствовать более чем одному предложению и выполнять более одного действия.
При написании предложения switch без разрыва может быть полезно добавить комментарий #FALLTHHROUGH, чтобы было ясно, что последующие проверки все равно будут выполняться.
 $drink = Джин с тоником

$result = переключатель -шаблон ($drink)  { 
   "Джин*" {"Содержит джин"  } # FALLTHROUGH
   "Whisky*" {"Содержит виски"} # FALLTHROUGH
   "*тоник" {"Содержит тоник"  } # FALLTHROUGH
  } 
 
 $результат
 

`Проверка нескольких значений`

Можно проверить несколько значений для одной ветви с помощью -eq или подстановочного знака:

 $yesno = read-host "Пожалуйста, введите yes или no или y/n:" 

переключатель ($ да нет)
{
  { 'y', 'yes' -eq $_ } { 'Вы ввели Да. ' }
  { 'j', 'Ja', 'Já', 'Jā', 'Jah' -eq $_ } { 'Вы вошли в Ja.' }
  default { 'Вы ввели номер' }
}

`Массивы.`

При передаче массива оператору switch будет обрабатываться каждый элемент в коллекции. Итак, чтобы повторить последний пример, просто измените первую строку на массив различных напитков:
$drink = 'Джин с тоником', 'Водка с тоником'
 
Возвращаемый результат $result будет представлять собой массив всех результатов. Если вам нужно определить, какой результат является каким, рассмотрите возможность включения $_ или $psitem в возвращаемое значение. например "$_ содержит джин"

`Разобрать содержимое файла.`

Оператор switch может обрабатывать файл с параметром -File. Это работает так же, как передача массива значений, каждая строка в текстовом файле будет передана в переключатель.
В этом примере мы читаем текстовый файл, который не содержит ничего, кроме списка номеров ошибок, и переводим их в текстовое сообщение:
 $errlog = 'C:\logs\errorlog. txt'
переключатель -Файл $errlog
    {
        10 { "Обнаружена ошибка 10"; перерыв }
        50 { "Обнаружена ошибка пятьдесят"; перерыв }
        100 { "Ошибка сто"; перерыв}
    } 

Обратите внимание, что, поскольку в этих предложениях switch используется break, после совпадения любого числа дальнейшая обработка не выполняется. Разрыв не просто завершает текущий элемент и переходит к следующему, он прерывает всю обработку и завершает оператор switch.

"История учит нас, что люди и нации ведут себя мудро, как только они исчерпали все остальные альтернативы" ~ Абба Эбан

`Связанные командлеты PowerShell`

Оператор Break Оператор Continue ForEach-Object — (foreach) Цикл для каждого объекта в конвейере. ForEach — циклически перебирать значения в конвейере. For — циклический просмотр элементов, соответствующих условию. ЕСЛИ - Условно выполнить команду. Пока — Цикл, пока условие истинно.