Перейти к основному содержимому

Условные выражения и циклы

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ
Разработчику Архитектору

Условные выражения и циклы​

Базовые принципы управления потоком выполнения​

Управление потоком выполнения скрипта в среде PowerShell базируется на возможности принятия решений и организации повторяющихся действий. Язык предоставляет мощные конструкции, позволяющие адаптировать поведение программы под изменяющиеся условия данных или состояния системы. В отличие от текстовых оболочек предыдущих поколений, PowerShell оперирует объектами .NET, что накладывает специфику на работу с условиями: сравнение объектов происходит не по их строковому представлению, а по их типам и свойствам.

Основой условной логики служит проверка истинности выражения. Результатом такой проверки является булево значение True (истина) или False (ложь). Скрипт использует эти значения для выбора ветки исполнения кода. Циклические конструкции позволяют выполнять блок инструкций многократно до тех пор, пока выполняется определенное условие или пока не будет достигнута заданная граница итераций.

PowerShell реализует классические алгоритмы программирования, адаптированные под объектно-ориентированную природу платформы. Конструкции условных операторов и циклов интегрированы в синтаксис языка так, чтобы обеспечивать читаемость кода и удобство отладки. Каждый оператор имеет четкое назначение и правила использования параметров.

Операторы сравнения и логические операции​

Операторы сравнения служат инструментом оценки отношений между двумя значениями. Они возвращают булево значение, которое затем используется в конструкциях if, while или for. В PowerShell существует набор специализированных операторов, каждый из которых выполняет свою функцию. Все они начинаются со знака дефиса, что отличает их от операторов других языков программирования.

Операторы эквивалентности и неравенства​

Оператор -eq проверяет равенство двух значений. Он сравнивает объекты по их значению, игнорируя различия в типах данных при определенных условиях. Например, числовое значение 5 и строковое значение "5" могут считаться равными при использовании этого оператора, если включено автоматическое приведение типов. Оператор -ne проверяет неравенство. Он возвращает True, если значения не совпадают.

$number = 10
$stringNumber = "10"

if ($number -eq $stringNumber) {
    Write-Host "Значения равны"
} else {
    Write-Host "Значения не равны"
}

if ($number -ne 20) {
    Write-Host "Число 10 не равно 20"
}

Операторы -eq и -ne являются стандартными средствами проверки тождественности. При работе с массивами эти операторы сравнивают элементы последовательно, возвращая массив булевых значений, если сравниваются коллекция и скалярное значение.

Операторы числового сравнения​

Для работы с числами используются операторы, определяющие порядок следования значений. Оператор -gt означает «больше» (Greater Than). Он возвращает True, если левое значение строго больше правого. Оператор -ge означает «больше или равно» (Greater Than or Equal). Он учитывает случай равенства.

Оператор -lt означает «меньше» (Less Than). Он возвращает True, если левое значение строго меньше правого. Оператор -le означает «меньше или равно» (Less Than or Equal). Эти операторы работают корректно с числами разных типов, приводя их к общему знаменателю перед сравнением.

$a = 15
$b = 10

if ($a -gt $b) {
    Write-Host "$a больше чем $b"
}

if ($a -ge 15) {
    Write-Host "Значение a равно или больше 15"
}

if ($b -lt $a) {
    Write-Host "$b меньше чем $a"
}

if ($a -le 20) {
    Write-Host "Значение a меньше или равно 20"
}

При сравнении строк эти операторы используют лексикографический порядок. Это означает, что сравнение происходит побуквенно согласно кодировке символов. Строка "Apple" считается меньшей, чем "Banana", так как буква 'A' идет раньше буквы 'B'.

Операторы соответствия шаблонам​

Оператор -like проверяет соответствие строки шаблону. Шаблон может содержать специальные символы, такие как звездочка * (любая последовательность символов) и вопросительный знак ? (один любой символ). Оператор чувствителен к регистру по умолчанию, но это можно изменить с помощью флага -c (case-sensitive) или без него (регистронезависимый поиск).

Оператор -match использует регулярные выражения для более сложного сопоставления. Он позволяет искать сложные паттерны, такие как диапазоны цифр, специфические комбинации букв или структуру адреса. Результатом работы -match является не только булево значение, но и сохранение совпавших частей в переменную $Matches.

$filename = "report_2024.pdf"

# Проверка по простому шаблону
if ($filename -like "*.pdf") {
    Write-Host "Файл является PDF документом"
}

# Проверка с учетом регистра (если нужно)
if ($filename -clike "REPORT*.PDF") {
    Write-Host "Найдено совпадение с учетом регистра"
}

# Использование регулярного выражения
if ($filename -match "\d{4}") {
    Write-Host "В имени файла найдены четыре цифры подряд"
}

# Получение совпавшей части
if ($filename -match "(?<year>\d{4})") {
    Write-Host "Год найден: $($Matches.year)"
}

Оператор -notlike работает аналогично -like, но возвращает True, если соответствие отсутствует. Оператор -notmatch возвращает True, если регулярное выражение не нашло совпадений.

Логические операторы​

Логические операторы объединяют несколько условий в одно сложное выражение. Они позволяют строить гибкую логику принятия решений.

Оператор -and (логическое И) возвращает True только тогда, когда оба operandа истинны. Если хотя бы одно условие ложно, результат всего выражения будет False. Этот оператор часто используется для проверки нескольких требований одновременно.

Оператор -or (логическое ИЛИ) возвращает True, если хотя бы одно из условий истинно. Выражение становится ложным только в случае, когда все условия ложны. Это полезно для определения принадлежности к одной из групп состояний.

Оператор -xor (исключающее ИЛИ) возвращает True, если истинно ровно одно из условий. Если оба условия истинны или оба ложны, результат будет False.

Оператор -not или его сокращенная форма ! инвертирует значение условия. True превращается в False, и наоборот.

$age = 25
$status = "active"

# Пример использования -and
if ($age -ge 18 -and $status -eq "active") {
    Write-Host "Пользователь активен и старше 18 лет"
}

# Пример использования -or
if ($status -eq "active" -or $status -eq "suspended") {
    Write-Host "Статус пользователя либо активен, либо приостановлен"
}

# Пример использования -xor
$x = $true
$y = $false
if ($x -xor $y) {
    Write-Host "Истинно ровно одно из условий"
}

# Пример использования -not
if (-not ($status -eq "inactive")) {
    Write-Host "Статус не является неактивным"
}

# Использование краткой формы !
if (!($age -lt 18)) {
    Write-Host "Возраст не меньше 18"
}

Приоритет выполнения операторов важен для правильного построения сложных условий. Оператор -not имеет высший приоритет, затем следует -and, и в конце -or. Для изменения порядка вычислений используют круглые скобки ().

Конструкция условного оператора If​

Конструкция if является фундаментальным элементом управления потоком в PowerShell. Она позволяет выполнить блок кода только при выполнении определенного условия. Синтаксис конструкции поддерживает цепочки проверок через elseif и финальную ветку else.

Базовая структура If​

Базовая конструкция состоит из ключевого слова if, за которым следует условие в круглых скобках, и блока кода в фигурных скобках. Если условие истинно, исполняется блок внутри фигурных скобок. Если условие ложно, выполнение переходит к следующей инструкции после блока if.

$temperature = 30

if ($temperature -gt 25) {
    Write-Host "Сегодня жарко"
}
Write-Host "Конец проверки температуры"

В этом примере текст "Сегодня жарко" будет выведен только если температура превышает 25 градусов. После завершения блока if скрипт продолжает выполнение с команды Write-Host.

Цепочка условий ElseIf​

Когда требуется проверить несколько взаимоисключающих вариантов, используется конструкция elseif. Она позволяет добавить дополнительные условия, которые проверяются последовательно, если предыдущие условия оказались ложными. Можно использовать любое количество блоков elseif.

$score = 85

if ($score -ge 90) {
    Write-Host "Отличная оценка"
} elseif ($score -ge 75) {
    Write-Host "Хорошая оценка"
} elseif ($score -ge 60) {
    Write-Host "Удовлетворительная оценка"
} else {
    Write-Host "Неудовлетворительная оценка"
}

В данном примере система проверяет оценки по порядку. Если балл выше 90, выводится первая фраза, и остальные проверки пропускаются. Если балл ниже 90, но выше 75, выполняется блок elseif, и проверка останавливается. Только если ни одно из условий не выполнено, исполняется блок else.

Обработка ошибок и пустых значений​

Особое внимание следует уделить работе с пустыми значениями и объектами. В PowerShell пустая строка "", нуль 0, объект $null и пустой массив @() могут вести себя по-разному в условиях. Оператор -eq считает $null равным пустой строке, что иногда приводит к неожиданным результатам.

Для надежной проверки существования объекта лучше использовать оператор -ne $null или конструкцию if ($object). Конструкция if ($object) автоматически интерпретирует объект как булево значение: пустой объект или $null считаются ложью, а заполненный объект — истиной.

$userName = ""
$serverName = $null
$processCount = 0

if ($userName) {
    Write-Host "Имя пользователя задано"
} else {
    Write-Host "Имя пользователя не задано"
}

if ($serverName -ne $null) {
    Write-Host "Сервер подключен"
} else {
    Write-Host "Сервер не подключен"
}

if ($processCount -gt 0) {
    Write-Host "Процессы запущены"
} else {
    Write-Host "Нет активных процессов"
}

Вложенные условия​

PowerShell поддерживает вложенные конструкции if, что позволяет создавать сложные деревья решений. Однако чрезмерная вложенность усложняет чтение кода и отладку. Рекомендуется использовать логические операторы для объединения простых условий вместо глубокой вложенности.

$isAdmin = $true
$isOnline = $true

if ($isAdmin) {
    if ($isOnline) {
        Write-Host "Администратор онлайн"
    } else {
        Write-Host "Администратор офлайн"
    }
} else {
    Write-Host "Обычный пользователь"
}

# Альтернативный вариант с использованием -and
if ($isAdmin -and $isOnline) {
    Write-Host "Администратор онлайн"
}

Специфика работы с массивами​

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

$numbers = @(1, 5, 10)

if ($numbers -gt 3) {
    Write-Host "В массиве есть числа больше трех"
}
# Этот блок выполнится, так как 5 и 10 больше 3

Для проверки всех элементов массива на соответствие условию необходимо использовать метод .All() или цикл foreach.

Конструкция Switch​

Конструкция switch представляет собой альтернативу цепочке if-elseif-else. Она предназначена для выбора действия на основе точного совпадения значения переменной с одним из перечисленных случаев. Конструкция особенно полезна при работе с большим количеством дискретных вариантов.

Базовый синтаксис Switch​

Конструкция начинается с ключевого слова switch, за которым следует выражение или переменная, подлежащая проверке. Внутри фигурных скобок находятся блоки case, каждый из которых содержит значение для сравнения и блок кода для выполнения при совпадении. Ключевое слово break завершает выполнение текущего случая и выходит из конструкции.

$dayOfWeek = "Tuesday"

switch ($dayOfWeek) {
    "Monday" {
        Write-Host "Начало рабочей недели"
        break
    }
    "Tuesday" {
        Write-Host "Среда недели"
        break
    }
    "Friday" {
        Write-Host "Предвкушение выходных"
        break
    }
    default {
        Write-Host "Обычный день"
        break
    }
}

Если значение переменной совпадает с одним из случаев, выполняется код внутри этого блока. После выполнения блока break управление передается дальше по скрипту. Если ни одно условие не совпало, исполняется блок default.

Поддержка множественных совпадений​

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

$color = "Red"

switch ($color) {
    "Red", "Orange", "Yellow" {
        Write-Host "Это теплые цвета"
        break
    }
    "Blue", "Green", "Purple" {
        Write-Host "Это холодные цвета"
        break
    }
    default {
        Write-Host "Неизвестный цвет"
        break
    }
}

Работа с регулярными выражения​

Оператор switch поддерживает использование регулярных выражений для проверки совпадений. Для этого значение в блоке case оборачивается в квадратные скобки []. Это позволяет реализовать гибкую логику фильтрации.

$email = "user@example.com"

switch ($email) {
    { $_ -match "@gmail\.com$" } {
        Write-Host "Почта Gmail"
        break
    }
    { $_ -match "@yahoo\.com$" } {
        Write-Host "Почта Yahoo"
        break
    }
    default {
        Write-Host "Другой провайдер"
        break
    }
}

В этом примере используется специальная переменная $_, представляющая текущее значение, передаваемое в конструкцию switch. Выражение { ... } позволяет писать произвольную логику проверки.

Режим точного совпадения и режим шаблонов​

По умолчанию switch использует режим точного совпадения. Однако можно включить режим шаблонов с помощью параметра -regex или режима -wildcard для поиска по маске. Параметр -exact заставляет искать только полное совпадение.

$fileExt = ".txt"

switch ($fileExt) {
    case "*.txt" {
        Write-Host "Текстовый файл"
        break
    }
    case "*.doc" {
        Write-Host "Документ Word"
        break
    }
    default {
        Write-Host "Неизвестный формат"
        break
    }
}

При использовании -wildcard звезда * заменяет любую последовательность символов.

Производительность Switch​

Конструкция switch часто работает быстрее, чем длинная цепочка if-elseif, особенно при большом количестве условий. Это связано с внутренней оптимизацией движка PowerShell, который может использовать хеш-таблицы для быстрого поиска совпадений.

Циклы For и Foreach​

Циклы обеспечивают повторение выполнения блока кода. В PowerShell существуют различные типы циклов, каждый из которых предназначен для конкретных задач. Конструкция for идеальна для ситуаций, когда известно количество итераций. Конструкция foreach предназначена для обхода коллекций объектов.

Интерактивное демо — пошаговый цикл на примере JavaScript (for, while). В PowerShell синтаксис другой, но порядок шагов тот же. Обобщённо: циклы в коде.

Загрузка интерактивного демо…

Цикл For​

Конструкция for состоит из трех частей: инициализации счетчика, условия продолжения цикла и оператора обновления счетчика. Инициализация выполняется один раз перед началом цикла. Затем проверяется условие; если оно истинно, выполняется тело цикла. После выполнения тела цикла обновляется счетчик, и процесс повторяется.

for ($i = 1; $i -le 5; $i++) {
    Write-Host "Итерация номер $i"
}

В этом примере переменная $i инициализируется значением 1. Пока $i меньше или равно 5, выполняется блок кода. После каждой итерации $i увеличивается на 1. Когда $i становится равным 6, условие перестает быть истинным, и цикл завершается.

Детали работы цикла For​

Первая часть for ($i = 1) выполняется единожды. Вторая часть ($i -le 5) проверяется перед каждой итерацией. Третья часть ($i++) выполняется после каждого прохода тела цикла. Если условие сразу ложно, тело цикла не выполнится ни разу.

Можно использовать любые выражения в частях цикла. Например, можно инициализировать несколько переменных или изменять шаг цикла.

for ($i = 10; $i -ge 1; $i--) {
    Write-Host "Обратный отсчет: $i"
}

for ($i = 0; $i -lt 10; $i += 2) {
    Write-Host "Четное число: $i"
}

В первом примере цикл идет от 10 до 1 с шагом минус 1. Во втором примере шаг составляет 2, поэтому выводятся только четные числа.

Цикл Foreach​

Конструкция foreach предназначена для перебора элементов коллекции. Она автоматически проходит по каждому элементу массива, списка или любого другого объекта, поддерживающего итерацию. Переменная цикла принимает значение текущего элемента на каждой итерации.

$fruits = @("Яблоко", "Банан", "Вишня")

foreach ($fruit in $fruits) {
    Write-Host "Фрукт: $fruit"
}

В этом примере переменная $fruit последовательно принимает значения "Яблоко", "Банан" и "Вишня". Тело цикла выполняется три раза.

Особенности обработки коллекций​

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

$users = Get-Content users.txt

foreach ($line in $users) {
    Write-Host "Пользователь: $line"
}

Этот пример читает файл построчно и обрабатывает каждую строку как отдельный элемент.

Разница между For и Foreach​

Конструкция for требует явного управления счетчиком и подходит для числовых последовательностей. Конструкция foreach абстрагирует управление счетчиком и фокусируется на содержании коллекции. Использование foreach делает код более читаемым при работе с данными.

# Использование for для чисел
for ($num = 1; $num -le 10; $num++) {
    Write-Host $num
}

# Использование foreach для списка
$items = @("A", "B", "C")
foreach ($item in $items) {
    Write-Host $item
}

Циклы While и Do-While​

Циклы while и do-while основаны на проверке условия. Они подходят для ситуаций, когда количество итераций заранее неизвестно и зависит от изменений данных во время выполнения.

Цикл While​

Конструкция while проверяет условие перед каждым выполнением тела цикла. Если условие истинно, выполняется блок кода. Затем проверка повторяется. Если условие изначально ложно, тело цикла не выполнится ни разу.

$count = 1

while ($count -le 5) {
    Write-Host "Счетчик: $count"
    $count++
}

В этом примере цикл продолжается, пока $count не превысит 5. На каждой итерации счетчик увеличивается. Если бы начальное значение было больше 5, цикл не запустился бы.

Цикл Do-While​

Конструкция do-while гарантирует выполнение тела цикла хотя бы один раз. Условие проверяется после выполнения блока кода. Это отличает её от while, где условие проверяется в начале.

$password = ""

do {
    $password = Read-Host "Введите пароль"
} while ($password -ne "secret")

Write-Host "Пароль принят"

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

Сравнение While и Do-While​

Различие заключается в моменте проверки условия. While проверяет перед действием, Do-While — после. Выбор конструкции зависит от требований задачи: нужно ли гарантировать выполнение хотя бы одного раза или достаточно проверить условие заранее.

# Пример While
$i = 10
while ($i -gt 5) {
    Write-Host $i
    $i--
}

# Пример Do-While
$j = 10
do {
    Write-Host $j
    $j--
} while ($j -gt 5)

Оба примера выведут числа от 10 до 6. Но если начальное значение i или j будет 5, первый цикл ничего не выведет, а второй выведет 5.

Управление циклом: Break и Continue​

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

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

$numbers = @(1, 2, 3, 4, 5)

foreach ($num in $numbers) {
    if ($num -eq 3) {
        break
    }
    Write-Host "Текущее число: $num"
}
Write-Host "Цикл завершен"

В этом примере цикл остановится, когда встретит число 3. Числа 1 и 2 будут выведены, но 3 и последующие — нет.

Ключевое слово continue пропускает остаток тела цикла на текущей итерации и переходит к следующей итерации. Оно позволяет пропустить обработку определенных элементов без остановки всего цикла.

$numbers = @(1, 2, 3, 4, 5)

foreach ($num in $numbers) {
    if ($num -eq 3) {
        continue
    }
    Write-Host "Текущее число: $num"
}

Здесь число 3 будет пропущено, но цикл продолжится для 4 и 5.

Рекурсивные циклы и бесконечные циклы​

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

# Бесконечный цикл (остановить вручную Ctrl+C)
while ($true) {
    Write-Host "Работаю..."
    Start-Sleep -Seconds 1
}

Для предотвращения таких ситуаций всегда следует предусмотреть механизм прерывания или условие выхода.

Работа с объектами в условиях и циклах​

Специфика PowerShell заключается в том, что условия и циклы работают с объектами .NET, а не с текстом. Это требует понимания структуры объектов и их свойств.

Сравнение объектов​

При сравнении объектов операторы -eq и -ne сравнивают их значения. Если объекты имеют разные типы, PowerShell пытается привести их к общему типу. При сравнении сложных объектов учитываются их свойства.

$object1 = New-Object PSObject -Property @{Name="Test"; Value=10}
$object2 = New-Object PSObject -Property @{Name="Test"; Value=10}

if ($object1 -eq $object2) {
    Write-Host "Объекты равны по значению"
}

Для проверки идентичности объектов (ссылочное равенство) используется оператор -is [object] или метод .Equals().

Фильтрация коллекций​

Циклы часто используются для фильтрации коллекций. Комбинация foreach и условных операторов позволяет выбирать нужные элементы.

$processes = Get-Process | Where-Object {$_.CPU -gt 100}

foreach ($proc in $processes) {
    Write-Host "Процесс: $($proc.Name), CPU: $($proc.CPU)"
}

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

Изменение объектов в цикле​

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

$items = @("apple", "banana", "cherry")

foreach ($item in $items) {
    $item = $item.ToUpper()
}

# Массив останется неизменным, так как строки передаются по значению
Write-Host $items[0] # apple

Для изменения содержимого массива нужно обращаться к элементам по индексу.

$items = @("apple", "banana", "cherry")

for ($i = 0; $i -lt $items.Count; $i++) {
    $items[$i] = $items[$i].ToUpper()
}

Write-Host $items[0] # APPLE

Оптимизация производительности условных конструкций и циклов​

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

Использование хеш-таблиц для Switch​

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

$commands = @{
    "start" = { Write-Host "Запуск" }
    "stop"  = { Write-Host "Остановка" }
    "restart" = { Write-Host "Перезапуск" }
}

$action = "start"

if ($commands.ContainsKey($action)) {
    & $commands[$action]
}

Минимизация вызовов команд в циклах​

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

# Медленный вариант
for ($i = 1; $i -le 100; $i++) {
    $date = Get-Date
    Write-Host "$i: $date"
}

# Быстрый вариант
$date = Get-Date
for ($i = 1; $i -le 100; $i++) {
    Write-Host "$i: $date"
}

Предварительная фильтрация данных​

Фильтрация данных перед циклом снижает нагрузку на процессор. Использование Where-Object до начала цикла эффективнее, чем проверка внутри цикла.

# Менее эффективно
$Данные = Get-Content largefile.txt
foreach ($line in $Данные) {
    if ($line -match "error") {
        Write-Host $line
    }
}

# Более эффективно
$Данные = Get-Content largefile.txt | Where-Object { $_ -match "error" }
foreach ($line in $Данные) {
    Write-Host $line
}

Практические примеры применения​

Рассмотрим реальные сценарии использования условных выражений и циклов в администрировании и разработке.

Проверка состояния системы​

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

$services = Get-Service | Where-Object {$_.Status -eq "Stopped"}

if ($services.Count -gt 0) {
    Write-Host "Обнаружены остановленные службы:"
    foreach ($svc in $services) {
        Write-Host "- $($svc.Name)"
    }
} else {
    Write-Host "Все службы работают"
}

Обработка файлов по расширению​

Скрипт может перебирать файлы в директории и выполнять действия в зависимости от расширения.

$files = Get-ChildItem -Path "." -Filter "*.log"

foreach ($file in $files) {
    $size = $file.Length / 1MB
    
    if ($size -gt 100) {
        Write-Host "Файл слишком большой: $($file.Name)"
    } elseif ($size -gt 10) {
        Write-Host "Файл средний: $($file.Name)"
    } else {
        Write-Host "Файл маленький: $($file.Name)"
    }
}

Интерактивный ввод данных​

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

$username = ""

while ($username -eq "") {
    $username = Read-Host "Введите имя пользователя"
    
    if ($username -eq "") {
        Write-Host "Имя пользователя не может быть пустым"
    }
}

Write-Host "Привет, $username!"

Автоматизация резервного копирования​

Скрипт может проверять наличие места на диске и выполнять резервное копирование.

$drive = "D:"
$freeSpace = (Get-PSDrive -Name $drive.Split(":")[0]).Free / 1GB

if ($freeSpace -lt 50) {
    Write-Host "Недостаточно места на диске D:"
} else {
    Copy-Item "C:\Данные\*" "D:\Backup\" -Recurse -Force
    Write-Host "Резервная копия создана"
}

См. также

Другие статьи этого же раздела в боковом меню (как на странице «О разделе»).

Ещё 2 статьи в разделе

Освоение главы0%