👩🏿‍🎤 🙆🏿 ❣️ Qu'est-ce que Windows PowerShell et que mange-t-il? Partie 2: Introduction au langage de programmation 🙏 📃 🤴🏿

Historiquement, les utilitaires de ligne de commande sur les systèmes Unix sont mieux développés que sur Windows, cependant, avec l'avènement d'une nouvelle solution, la situation a changé.

Pour PowerShell, vous pouvez écrire des scripts dans un langage multi-paradigme interprété qui contient des éléments de programmation procédurale classique, orientée objet et même fonctionnelle: ramification conditionnelle, boucles, variables, tableaux, tables de hachage, classes, gestion des erreurs, ainsi que fonctions, applets de commande et pipelines . L'article précédent était consacré aux bases du travail dans un environnement, et maintenant nous proposons à nos lecteurs un petit guide pour les programmeurs.

Table des matières:

Commentaires
Variables et leurs types
Variables système
Portées Variables d'
environnement (
arithmétique )
Opérateurs arithmétiques et de comparaison Opérateurs d'affectation
Opérateurs logiques
Transition conditionnelle
Boucles
Tableaux
Tables de hachage
Fonctions
Gestion des erreurs Vous

pouvez écrire du code dans n'importe quel éditeur de texte ou en utilisant l'environnement de développement intégré - la façon la plus simple de prendre Windows PowerShell ISE inclus avec les systèmes d'exploitation Microsoft Server. Cela n'est nécessaire que pour des scripts assez complexes: les ensembles courts 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 un trait 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 d'indiquer à l'interpréteur un nom valide:

Pour initialiser la variable (lui attribuer une valeur), l'opérateur d'affectation (symbole =) est utilisé:

$test = 100

Vous pouvez déclarer une variable en indiquant son type entre crochets (opérateur de conversion de type) avant le nom ou la valeur:

[int]$test = 100

$test = [int]100

Il est important de comprendre que les variables dans PowerShell sont des objets (classes) complets avec des propriétés et des méthodes dont les types sont basés sur ceux disponibles dans .NET Core. Nous listons les principaux:

Type (classe .NET)	La description	Exemple de code
[string] System.String	Unicode	$test = «» $test = ''
[char] System.Char	Unicode (16 )	[char]$test = 'c'
[bool] System.Boolean	( True False)	[bool]$test = $true
[int] System.Int32	(32 )	[int]$test = 123456789
[long] System.Int64	(64 )	[long]$test = 12345678910
[single] System.Single	32	[single]$test = 12345.6789
[double] System.Double	64 (8 )	[double]$test = 123456789.101112
[decimal] System.Decimal	Nombre à virgule flottante de 128 bits (assurez-vous d'inclure d à la fin)	[décimal] $ test = 12345.6789d
[DateTime] System.DateTime	date et l'heure	$ test = Get-Date
[tableau] System.Object []	un tableau dont l'indice d'élément commence à 0	$ test_array = 1, 2, "test", 3, 4
[table de hachage] System.Collections.Hashtable	tables de hachage - tableaux associatifs avec des clés nommées, construits sur le principe: @ {key = "value"}	$ test_hashtable = @ {one = "one"; deux = "deux"; trois = "trois"}

PowerShell prend en charge la conversion de type implicite, en outre, le type de la variable peut changer à la volée (par exemple, en utilisant l'opérateur d'affectation) si elle n'est pas spécifiée de force - dans ce cas, l'interpréteur générera une erreur. Vous pouvez déterminer le type d'une variable à partir 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 la gestion des 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 l'applet de commande spéciale:

Get-Variable | more

Cette 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 spécifier des paramètres supplémentaires. Il est important de comprendre que les variables utilisateur ne sont définies que dans la session en cours. Après avoir fermé la console ou terminé le script, 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, auxquelles aucune valeur arbitraire ne peut être attribuée par elles-mêmes. Ceux-ci incluent, par exemple, $ PWD:

$PWD.Path

Pour stocker les paramètres utilisateur, vous avez besoin de variables de préférence dont les valeurs peuvent être modifiées. Par exemple, à l'aide de $ ErrorActionPreference, la réponse de l'interpréteur de commandes à l'apparition d'erreurs non critiques est définie.

En plus des opérateurs et des applets de commande, le pseudo-accumulateur Variable: existe pour accéder aux variables déclarées. Vous pouvez travailler avec lui par analogie avec d'autres lecteurs, et les variables dans ce cas ressemblent aux objets du système de fichiers:

Get-ChildItem Variable: | more

ls Variable: | more

Portées

Pour les variables dans PowerShell, il y a la notion de portée. L'action de la zone globale (Global) s'étend à toute la session en cours - elle inclut, par exemple, les variables système. Les variables locales ne sont disponibles que dans la zone où elles ont été définies: disons à l'intérieur de la fonction. Il y a aussi le concept d'une portée de script, mais pour les commandes de script, c'est essentiellement local. Par défaut, lors de la déclaration de variables, on leur donne une portée locale, et pour changer cela, nous avons besoin d'une construction spéciale du formulaire: $ Global: variable = value.

Par exemple, comme ceci:

$Global:test = 100

Variables d'environnement

Un autre pseudo-lecteur Env est disponible auprès de PowerShell, qui 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 coïncident avec les valeurs du panneau de contrôle. Pour afficher les variables d'environnement, utilisez l'applet de commande Get-ChildItem ou ses alias (liaisons): ls et dir.

dir Env:

Ces variables sont des séquences d'octets (ou des caractères, si vous le souhaitez), dont l'interprétation ne dépend que du programme qui les utilise. * -Les applets de commande variables ne fonctionnent pas avec les variables d'environnement. Pour y accéder, vous devrez utiliser le préfixe de disque:

$env:TEST = "Hello, World!"

Opérateurs arithmétiques et de comparaison

PowerShell possède les opérateurs arithmétiques suivants: + (addition), - (soustraction), * (multiplication), / (division) et% (module ou reste de division). Le résultat d'une expression arithmétique est calculé de gauche à droite conformément à l'ordre d'opérations généralement accepté, et des parenthèses sont utilisées pour regrouper des parties de l'expression. Les espaces entre opérateurs sont ignorés, ils ne sont utilisés que pour faciliter la perception. L'opérateur + concatène également et l'opérateur * répète les lignes. Si vous essayez d'ajouter un nombre à une chaîne, il sera converti en chaîne. De plus, PowerShell possède de nombreux opérateurs de comparaison qui vérifient la correspondance entre deux valeurs et renvoient un booléen True ou False:

Opérateur	La description	Exemple de code
-eq	Égal (analogique = ou == dans d'autres langues)	$ test = 100 $ test -eq 123
-ne	Pas égal (analogique <> ou! =)	$ test = 100 $ test -ne 123
-gt	Supérieur à / Plus (analogique>)	$ test = 100 $ test -gt 123
-ge	Supérieur ou égal / Supérieur ou égal (analogique> =)	$ test = 100 $ test -ge 123
-lt	Moins de (analogique <)	$ test = 100 $ test -lt 123
-le	Inférieur ou égal / Inférieur ou égal (analogique <=)	$ test = 100 $ test -le 123

Il existe d'autres opérateurs similaires qui permettent, par exemple, de comparer des chaînes avec un caractère générique ou d'utiliser des expressions régulières pour faire correspondre des modèles. Nous les examinerons en détail dans les articles suivants. Les symboles <,> et = ne sont pas utilisés pour la comparaison, car ils sont utilisés à d'autres fins.

Opérateurs d'affectation

En plus de 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 - se comportent de manière similaire, qui augmentent ou diminuent la valeur d'une variable - ils concernent également les opérateurs d'affectation.

Opérateurs logiques

La comparaison n'est pas suffisante pour décrire des conditions difficiles. Vous pouvez écrire toutes les expressions logiques à l'aide des opérateurs suivants: -et, -ou, -xor, -pas et! .. Ils fonctionnent comme dans d'autres langages de programmation, tandis que vous pouvez utiliser des parenthèses pour spécifier l'ordre de calcul:

("" -eq "") -and (100 -eq 100)

-not (123 -gt 321) 

!(123 -gt 321)

Saut conditionnel

Les opérateurs de branchement dans PowerShell sont standard: IF (IF ... ELSE, IF ... ELSEIF ... ELSE) et SWITCH. Considérez 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

Il existe plusieurs types de boucles dans PowerShell: WHILE, DO WHILE, DO UNTIL, FOR et FOREACH.

La boucle de précondition fonctionne si / pendant son exécution:

[int]$test = 0
while ($test -lt 10) {
      Write-Host $test
      $test = $test + 1
}

Les boucles avec une postcondition fonctionneront au moins une fois, car la condition est vérifiée après l'itération. Dans ce cas, DO WHILE fonctionne tant que la condition est vraie, et DO UNTIL - alors 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 une 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. Les variétés les plus simples de ces variables sont les tableaux. Un tableau peut être composé de plusieurs éléments, un élément ou être vide, c'est-à-dire ne contiennent pas d'éléments. Pour le déclarer, utilisez l'opérateur @ (), dont nous aurons besoin dans l'article suivant - il est très important pour ajouter d'autres tableaux au tableau (créer des tableaux multidimensionnels), passer des tableaux à des fonctions comme arguments et des tâches similaires:

$test_array = @() #

Lorsque le tableau est initialisé, ses valeurs sont répertoriées avec une virgule (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, 4

Dans ce cas, un tableau d'un élément est initialisé comme suit

$test_array = , 1

Pour accéder aux éléments du tableau, un index entier commençant à zéro et un opérateur d'index (crochets) sont utilisés:

$test_array[0] = 1

Vous pouvez spécifier plusieurs indices, séparés par des virgules, y compris dupliquer:

$test_array = "", "", "", ""
$test_array[0,1,2,3]
$test_array[1,1,3,3,0]

L'opérateur ..(deux points - l'opérateur de plage) renvoie un tableau d'entiers sur un segment défini par les limites supérieure et inférieure. Par exemple, l'expression 1..4 affiche un tableau de quatre éléments @ (1, 2, 3, 4) et l'expression 8..5 affiche 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, c'est-à-dire une séquence d'éléments dans un tableau avec des indices d'un autre. Dans ce cas, un nombre négatif -1 indique le dernier élément du tableau, -2 - l'avant-dernier, etc.

$test_array = "", "", "", ""
$test_array[0..2]
$test_array[2..0]
$test_array[-1..0]
$test_array[-2..1]

Veuillez noter que les valeurs du tableau d'entiers peuvent être supérieures à la valeur maximale de l'index du tableau de données. Dans ce cas, toutes les valeurs sont renvoyées à 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 dans le 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 variable dans PowerShell est les tables de hachage, également appelées tableaux associatifs. La table de hachage est similaire à l'objet JSON et est construite sur une base de valeurs-clés. Contrairement aux tableaux ordinaires, l'accès à leurs éléments s'effectue à l'aide de clés nommées, qui sont des propriétés d'objet (vous pouvez également utiliser l'opérateur d'index - crochets).

Une table de hachage vide est déclarée à l'aide du symbole de service @ et des crochets 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 à la table de hachage, vous devez lui affecter une clé qui n'existe pas encore ou utiliser la méthode Add (). Si l'affectation est effectuée avec une clé existante, sa valeur changera. Pour supprimer un élément d'une table de hachage, utilisez la méthode Remove ().

$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 l'article suivant, nous allons apprendre à le faire, et également considérer un autre type similaire - PSCustomObject.

Les fonctions

PowerShell possède tous les éléments nécessaires à la programmation procédurale, y compris les fonctions. Le mot fonction Function est utilisé pour les décrire, après quoi il est nécessaire d'indiquer le nom de la fonction et le corps entre crochets opérateur. Si nécessaire, passez des arguments à la fonction, vous pouvez les spécifier immédiatement après le nom entre parenthèses.

function - (1, ..., N) 
{ 
        - 
}

Une fonction renvoie toujours un résultat - il s'agit d'un tableau des résultats de toutes ses instructions, s'il y en a plusieurs. S'il existe une instruction, une 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 abandonne la liste d'instructions, et une fonction vide renvoie $ null.

Par exemple, créez une fonction pour mettre au carré un nombre:

function sqr ($number)
{
      return $number * $number
}

Notez que dans le corps de la fonction, vous pouvez utiliser toutes les variables déclarées avant son appel, et les fonctions d'appel dans PowerShell peuvent sembler inhabituelles: les arguments (le cas échéant) ne sont pas placés entre parenthèses et sont séparés par des espaces.

sqr 2

ou alors:

sqr -number 2

En raison de la façon dont les arguments sont passés, la fonction elle-même doit parfois être placée entre crochets:

function test_func ($n) {}
test_func -eq $null     #   
(test_func) -eq $null   #   — $true

Lors de la description d'une fonction, vous pouvez affecter des valeurs par défaut aux arguments:

function func ($arg = value) {
         # 
}

Il existe une autre syntaxe pour décrire les arguments de la fonction, en outre, les paramètres peuvent être lus à partir du pipeline - tout cela sera utile dans le prochain article lorsque nous considérons les modules exportés et créons vos propres applets de commande.

Erreur de traitement

PowerShell a un mécanisme Try ... Catch ... Enfin pour gérer les exceptions. Le bloc Try contient du 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 Final 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 des exceptions de différents types. L'exception elle-même est écrite dans la variable de non-déclaration par défaut ($ _) et peut être facilement récupérée. Dans l'exemple ci-dessous, nous implémentons une protection contre la saisie d'une valeur incorrecte:

try {

        [int]$test = Read-Host " "
        100 / $test

} catch {

         Write-Warning " "
         Write-Host $_

}

C’est là que les bases de la programmation PowerShell sont concernées. Dans les articles suivants, nous étudierons plus en détail le travail avec des variables de différents types, collections, expressions régulières, la création de fonctions, de modules et d'applets de commande personnalisées, ainsi que la programmation orientée objet.

Partie 1: les principales fonctionnalités de Windows PowerShell
Partie 3: passage de paramètres aux scripts et fonctions, création d'applets de commande
Partie 4: Utilisation d'objets, de classes personnalisées

Qu'est-ce que Windows PowerShell et que mange-t-il? Partie 2: Introduction au langage de programmation