Historiquement, les utilitaires de ligne de commande sur les systèmes Unix sont mieux développés que sur Windows, mais avec l'avènement d'une nouvelle solution, la situation a changé.
PowerShell peut être scripté dans un langage interprété multi-paradigme qui contient des éléments de programmation procédurale classique, orientée objet et même fonctionnelle : branchement conditionnel, boucles, variables, tableaux, tables de hachage, classes, gestion des erreurs, ainsi que des fonctions, applets de commande et pipelines . était consacré aux bases du travail dans l'environnement, et maintenant nous offrons aux lecteurs un petit guide pour les programmeurs.
Table des matières:
Vous pouvez écrire du code dans n'importe quel éditeur de texte ou à l'aide d'un environnement de développement intégré. Le moyen le plus simple consiste à utiliser Windows PowerShell ISE fourni avec les systèmes d'exploitation serveur Microsoft. Ceci n'est nécessaire que pour les scripts assez complexes : de courts ensembles de commandes sont plus faciles à exécuter de manière interactive.
Commentaires
L'utilisation de commentaires est considérée comme faisant partie d'un bon style de programmation avec une indentation et des espaces appropriés :
# Для строчных комментариев используется символ решетки — содержимое строки интерпретатор не обрабатывает.
<#
Так обозначаются начало и конец блочного комментария.
Заключенный между ними текст интерпретатор игнорирует.
#>
Variables et leurs types
Les variables dans PowerShell sont des objets nommés. Leurs noms peuvent inclure le caractère de soulignement, ainsi que des lettres et des chiffres. Le symbole $ est toujours utilisé avant le nom, et pour déclarer une variable, il suffit de donner à l'interpréteur un nom valide :
Pour initialiser une variable (lui affecter une valeur), l'opérateur d'affectation (symbole =) est utilisé :
$test = 100Vous pouvez déclarer une variable en spécifiant son type entre crochets (opérateur de conversion de type) avant le nom ou la valeur :
[int]$test = 100
$test = [int]100Il est important de comprendre que les variables dans PowerShell sont des objets à part entière (classes) avec des propriétés et des méthodes dont les types sont basés sur ceux de .NET Core. Nous listons les principaux :
Tapez (classe .NET)
description
Exemple de code
[chaîne] System.StringChaîne Unicode
$test = "test"
$test = 'test'
Caractère Unicode (16 bits)
[char]$test = 'c' [bool] System.Booléentype booléen (booléen Vrai ou Faux)
[bool]$test = $vrai [int] System.Int32entier trente-deux bits (32 bits)
[int]$test = 123456789 [long] System.Int64entier de soixante-quatre bits (64 bits)
[long]$test = 12345678910 [single] System.Singlenombre à virgule flottante de 32 bits de long
[simple]$test = 12345.6789 [double]Système.Doublenombre à virgule flottante de longueur 64 bits (8 octets)
[double]$test = 123456789.101112 [décimal]System.DecimalNombre à virgule flottante 128 bits (nécessaire pour se terminer par d)
[décimal]$test = 12345.6789d [DateHeure]Système.DateHeuredate et heure
$test = GetDate
[tableau] System.Object[]un tableau dont l'indice d'élément commence à 0
$tableau_test = 1, 2, "test", 3, 4
[hashtable] System.Collections.Hashtableles tables de hachage sont des tableaux associatifs à clés nommées, construits selon le principe : @{key="value"}
$test_hashtable = @{un="un" ; deux="deux" ; trois="trois"}
PowerShell prend en charge la conversion de type implicite. De plus, le type d'une variable peut être modifié à la volée (par exemple, à l'aide d'un opérateur d'affectation), s'il n'est pas spécifié de force - dans ce cas, l'interpréteur donnera une erreur. Vous pouvez déterminer le type de la variable de l'exemple précédent en appelant la méthode GetType() :
$test.GetType().FullName
Il existe un certain nombre d'applets de commande pour manipuler les variables. Leur liste sous une forme pratique est affichée à l'aide de la commande :
Get-Command -Noun Variable | ft -Property Name, Definition -AutoSize -Wrap
Pour afficher les variables déclarées et leurs valeurs, vous pouvez utiliser une applet de commande spéciale :
Get-Variable | moreCette méthode semble trop lourde, il est beaucoup plus pratique de travailler avec des variables via des opérateurs ou en accédant directement à leurs propriétés et méthodes. Cependant, les applets de commande ont le droit d'exister car elles vous permettent de définir certains paramètres supplémentaires. Il est important de comprendre que les variables utilisateur ne sont définies que dans la session en cours. Lorsque la console est fermée ou que le script se termine, ils sont supprimés.
Variables système
En plus de celles déclarées par l'utilisateur, il existe des variables (système) intégrées qui ne sont pas supprimées après la fin de la session en cours. Ils sont divisés en deux types, tandis que les données d'état PowerShell sont stockées dans des variables automatiques qui ne peuvent pas se voir attribuer de valeurs arbitraires par elles-mêmes. Ceux-ci incluent, par exemple, $PWD :
$PWD.Path
Les variables de préférence sont nécessaires pour stocker les préférences de l'utilisateur, dont les valeurs peuvent être modifiées. Par exemple, en utilisant $ErrorActionPreference , la réaction de l'interpréteur de commandes à l'apparition d'erreurs non fatales est définie.
En plus des opérateurs et applets de commande pour accéder aux variables déclarées, il existe un pseudo-accumulateur Variable :. Vous pouvez travailler avec lui par analogie avec d'autres lecteurs, et les variables dans ce cas ressemblent à des objets du système de fichiers :
Get-ChildItem Variable: | moreou
ls Variable: | more
Champs d'application
Pour les variables dans PowerShell, il existe le concept de portée (Scope). L'action de la portée globale (Global) s'applique à toute la session en cours - elle inclut, par exemple, les variables système. Les variables locales (Local) ne sont disponibles que dans la portée où elles ont été définies : disons à l'intérieur d'une fonction. Il y a aussi la notion de portée du script (Script), mais pour les commandes de script, elle est essentiellement locale. Par défaut, lors de la déclaration de variables, on leur donne une portée locale, et pour changer cela, vous avez besoin d'une construction spéciale comme : $Global : variable = value.
Par exemple, ceci:
$Global:test = 100
Variables d'environnement (environnement)
Un autre pseudo-lecteur, Env:, est disponible auprès de PowerShell et peut être utilisé pour accéder aux variables d'environnement. Lorsque le shell démarre, ils sont copiés à partir du processus parent (c'est-à-dire du programme qui a lancé la session en cours) et généralement leurs valeurs initiales sont les mêmes que les valeurs du panneau de configuration. Pour afficher les variables d'environnement, utilisez l'applet de commande Get-ChildItem ou ses alias (alias) : ls et dir.
dir Env:
Ces variables sont des séquences d'octets (ou de caractères, si vous préférez), dont l'interprétation ne dépend que du programme qui les utilise. Les applets de commande *-Variable ne fonctionnent pas avec les variables d'environnement. Pour y accéder, vous devez utiliser le préfixe du lecteur :
$env:TEST = "Hello, World!"
Opérateurs arithmétiques et de comparaison
PowerShell fournit les opérateurs arithmétiques suivants : + (addition), - (soustraction), * (multiplication), / (division) et % (modulo ou modulo). Le résultat d'une expression arithmétique est évalué de gauche à droite conformément à l'ordre généralement accepté des opérations, et des parenthèses sont utilisées pour regrouper des parties de l'expression. Les espaces entre les opérateurs sont ignorés, ils ne sont utilisés que pour faciliter la lecture. L'opérateur + concatène également et l'opérateur * répète les chaînes. Si vous essayez d'ajouter un nombre à une chaîne, il sera converti en chaîne. De plus, le langage PowerShell possède de nombreux opérateurs de comparaison qui vérifient une correspondance entre deux valeurs et renvoient le booléen Vrai ou Faux :
Opérateur
description
Exemple de code
-eq
Equal / Equals (similaire à = ou == dans d'autres langues)
$test = 100
$test -eq 123
-Ne
Pas égal / Pas égal (similaire à <> ou !=)
$test = 100
$test -ne 123
-Gt
Supérieur à / Plus (analogique >)
$test = 100
$test-gt 123
-donner
Supérieur ou égal / Supérieur ou égal (similaire à >=)
$test = 100
$test -ge 123
-lt
Moins de / Moins (similaire à <)
$test = 100
$test -lt 123
-Le
Inférieur ou égal / Inférieur ou égal (similaire à <=)
$test = 100
$test-le 123
Il existe d'autres opérateurs similaires qui vous permettent, par exemple, de comparer des chaînes basées sur un caractère générique ou d'utiliser des expressions régulières pour faire correspondre un modèle. Nous les détaillerons dans de prochains articles. Les symboles <, > et = ne sont pas utilisés à des fins de comparaison car ils sont utilisés à d'autres fins.
Opérateurs d'affectation
Outre l'opérateur = le plus courant, il existe d'autres opérateurs d'affectation : +=, -=, *=, /= et %=. Ils changent la valeur avant l'affectation. Les opérateurs unaires ++ et -, qui augmentent ou diminuent la valeur d'une variable, se comportent de manière similaire - ils s'appliquent également aux opérateurs d'affectation.
Opérateurs logiques
La comparaison seule ne suffit pas pour décrire des conditions complexes. Vous pouvez écrire n'importe quelle expression logique en utilisant les opérateurs : -and, -or, -xor, -not and! .. Ils fonctionnent comme dans d'autres langages de programmation, tandis que vous pouvez utiliser des parenthèses pour spécifier l'ordre d'évaluation :
("Тест" -eq "Тест") -and (100 -eq 100)
-not (123 -gt 321)
!(123 -gt 321)
Saut conditionnel
Les opérateurs de branche dans PowerShell sont standard : IF(IF…ELSE, IF…ELSEIF…ELSE) et SWITCH. Regardons leur utilisation avec des exemples :
[int]$test = 100
if ($test -eq 100) {
Write-Host "test = 100"
}
[int]$test = 50
if ($test -eq 100) {
Write-Host "test = 100"
}
else {
Write-Host "test <> 100"
}
[int]$test = 10
if ($test -eq 100) {
Write-Host "test = 100"
}
elseif ($test -gt 100) {
Write-Host "test > 100"
}
else {
Write-Host "test < 100"
}
[int]$test = 5
switch ($test) {
0 {Write-Host "test = 0"}
1 {Write-Host "test = 1"}
2 {Write-Host "test = 2"}
3 {Write-Host "test = 3"}
4 {Write-Host "test = 4"}
5 {Write-Host "test = 5"}
default {Write-Host "test > 5 или значение не определено"}
}
Cycles
PowerShell a plusieurs variétés de boucles : WHILE, DO WHILE, DO UNTIL, FOR et FOREACH.
Une boucle avec une précondition fonctionne si/tant qu'elle est vraie :
[int]$test = 0
while ($test -lt 10) {
Write-Host $test
$test = $test + 1
}
Les boucles avec une postcondition s'exécuteront au moins une fois, car la condition est vérifiée après l'itération. En même temps, DO WHILE fonctionne tant que la condition est vraie, et DO UNTIL fonctionne tant qu'elle est fausse :
[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
while ($test -lt 10)
[int]$test = 0
do {
Write-Host $test
$test = $test + 1
}
until ($test -gt 9)
Le nombre d'itérations de la boucle FOR est connu à l'avance :
for ([int]$test = 0; $test -lt 10; $test++) {
Write-Host $test
}
Dans la boucle FOREACH, itère sur les éléments d'un tableau ou d'une collection (table de hachage) :
$test_collection = "item1", "item2", "item3"
foreach ($item in $test_collection)
{
Write-Host $item
}
Tableaux
Les variables PowerShell stockent non seulement des objets uniques (nombre, chaîne, etc.), mais également plusieurs objets. Le type le plus simple de ces variables sont les tableaux. Un tableau peut être composé de plusieurs éléments, d'un élément, ou être vide, c'est-à-dire ne contiennent aucun élément. Il est déclaré à l'aide de l'opérateur @(), dont nous aurons besoin dans le prochain article - il est très important pour ajouter d'autres tableaux à un tableau (créer des tableaux multidimensionnels), passer des tableaux à des fonctions en tant qu'argument et tâches similaires :
$test_array = @() #создаем пустой массивLorsqu'un tableau est initialisé, ses valeurs sont listées séparées par des virgules (opérateur spécial ,) :
$test_array = @(1, 2, 3, 4) # создаем массив из четырех элементов Dans la plupart des cas, l'opérateur @() peut être omis :
$test_array = 1, 2, 3, 4Dans ce cas, un tableau d'un élément est initialisé comme suit
$test_array = , 1Les éléments du tableau sont accessibles à l'aide d'un index entier de base zéro et de l'opérateur d'index (crochets) :
$test_array[0] = 1Vous pouvez spécifier plusieurs index séparés par des virgules, incl. récurrent:
$test_array = "один", "два", "три", "четыре"
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]
Opérateur .. (deux points - opérateur de plage) renvoie un tableau d'entiers dans les limites supérieure et inférieure spécifiées. Par exemple, l'expression 1..4 génère un tableau de quatre éléments @(1, 2, 3, 4) et l'expression 8..5 génère un tableau @(8, 7, 6, 5).
En utilisant l'opérateur de plage, vous pouvez initialiser un tableau ($test_array = 1..4) ou obtenir une tranche (slice), c'est-à-dire une séquence d'éléments d'un tableau avec des indices d'un autre. Dans ce cas, un nombre négatif -1 désigne le dernier élément du tableau, -2 - l'avant-dernier, et ainsi de suite.
$test_array = "один", "два", "три", "четыре"
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]Notez que les valeurs du tableau d'entiers peuvent être supérieures à la valeur d'index maximale du tableau de données. Dans ce cas, toutes les valeurs sont retournées jusqu'à la dernière :
$test_array[0..100]Si vous essayez d'accéder à un seul élément de tableau inexistant, $null est renvoyé.
Dans PowerShell, les tableaux peuvent contenir des éléments de différents types ou être fortement typés :
$test_array = 1, 2, "тест", 3, 4
for ([int]$i = 0; $i -lt $test_array.count; $i++)
{
Write-Host $test_array[$i]
}
Où la propriété $test_array.count est le nombre d'éléments du tableau.
Un exemple de création d'un tableau fortement typé :
[int[]]$test_array = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
Tables de hachage
Un autre type de base de variables dans le langage PowerShell sont les tables de hachage, également appelées tableaux associatifs. Les tables de hachage sont similaires aux objets JSON et sont construites sur une base clé-valeur. Contrairement aux tableaux ordinaires, leurs éléments sont accessibles par des clés nommées, qui sont des propriétés de l'objet (vous pouvez également utiliser l'opérateur d'index - crochets).
Une table de hachage vide est déclarée à l'aide du symbole @ et des parenthèses de l'opérateur :
$test_hashtable = @{}Lors de la déclaration, vous pouvez immédiatement créer des clés et leur attribuer des valeurs :
$test_hashtable = @{one="один"; two="два"; three="три"; "some key"="some value"}Pour ajouter un élément à une table de hachage, vous devez lui affecter une clé qui n'existe pas encore, ou utiliser la méthode Add(). Si une affectation est faite à une clé existante, sa valeur changera. La méthode Remove() est utilisée pour supprimer un élément d'une table de hachage.
$test_hashtable."some key"
$test_hashtable["some key"]
$test_hashtable.Add("four", "четыре")
$test_hashtable.five = "пять"
$test_hashtable['five'] = "заменяем значение"
$test_hashtable.Remove("one")
Les variables de ce type peuvent être transmises en tant qu'arguments aux fonctions et applets de commande - dans le prochain article, nous étudierons comment cela est fait, et considérerons également un autre type similaire - PSCustomObject.
fonctions
PowerShell a tout ce dont vous avez besoin pour la programmation procédurale, y compris les fonctions. Pour les décrire, le mot de fonction Function est utilisé, après quoi vous devez spécifier le nom de la fonction et le corps entre parenthèses d'opérateur. Si vous devez transmettre des arguments à la fonction, vous pouvez les spécifier immédiatement après le nom entre parenthèses.
function имя-функции (аргумент1, ..., аргументN)
{
тело-функции
}
La fonction renvoie toujours un résultat - c'est un tableau des résultats de toutes ses instructions, s'il y en a plusieurs. S'il n'y a qu'une seule instruction, la seule valeur du type correspondant est renvoyée. La construction return $value ajoute un élément avec la valeur $value au tableau de résultats et interrompt l'exécution de la liste d'instructions, et la fonction vide renvoie $null.
Par exemple, créons une fonction pour élever au carré un nombre :
function sqr ($number)
{
return $number * $number
}
Notez que dans le corps d'une fonction, vous pouvez utiliser n'importe quelle variable déclarée avant de l'appeler, et l'appel de fonctions dans PowerShell peut sembler inhabituel : les arguments (le cas échéant) ne sont pas entre parenthèses et sont séparés par des espaces.
sqr 2Ou alors:
sqr -number 2En raison de la manière dont les arguments sont passés, la fonction elle-même doit parfois être placée entre parenthèses :
function test_func ($n) {}
test_func -eq $null # функция не вызывалась
(test_func) -eq $null # результат выражения — $true
Lors de la description d'une fonction, vous pouvez attribuer des valeurs par défaut aux arguments :
function func ($arg = value) {
#тело функции
}
Il existe une autre syntaxe pour décrire les arguments de la fonction. De plus, les paramètres peuvent être lus à partir du pipeline - tout cela sera utile dans le prochain article, lorsque nous examinerons les modules exportés et créerons nos propres applets de commande.
Traitement des erreurs
PowerShell a un mécanisme Try...Catch...Finally pour gérer les exceptions. Le bloc Try contient le code dans lequel une erreur peut se produire et le bloc Catch contient son gestionnaire. S'il n'y a pas eu d'erreur, il n'est pas exécuté. Le bloc Finally est exécuté après le bloc Try, quelle que soit l'occurrence d'une erreur, et il peut y avoir plusieurs blocs Catch pour différents types d'exceptions. L'exception elle-même est écrite dans une variable par défaut non déclarée ($_) et peut être récupérée facilement. Dans l'exemple ci-dessous, nous implémentons une protection contre la saisie d'une valeur invalide :
try {
[int]$test = Read-Host "Введите число"
100 / $test
} catch {
Write-Warning "Некорректное число"
Write-Host $_
}
Ceci conclut la revue des bases de la programmation dans le langage PowerShell. Dans les articles suivants, nous étudierons plus en détail le travail avec des variables de différents types, des collections, des expressions régulières, la création de fonctions, de modules et d'applets de commande personnalisés, ainsi que la programmation orientée objet.
Source: habr.com