powershell_base1 [Shyrka System Web Station]

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
====== Les bases de Powershell - 1ère partie ======
<label type="info">Création</label> --- //[[nekan@shyrkasystem.com|Nicolas THOREZ]] 2019/02/20 20:43//

Je vais juste récapituler ici certaines bases très utiles dans la plupart des scripts.

===== Les opérateurs logiques =====

Les opérateurs logiques permettent de comparer deux variables au moyen d'une opération et de renvoyer le résultat, généralement sous la forme d'un booléen ''$true'' ou ''$false''.

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_comparison_operators?view=powershell-6|Microsoft]]
==== Egalité ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-eq''  |  égal à  |Renvoie ''$true'' si les deux variables sont strictement identiques  | <sxh powershell>1 -eq 1
$true
1 -eq a
$false
</sxh> |
|  ''-ne''  |  différent de  |Renvoie ''$true'' si les deux variables sont strictement différentes  | <sxh powershell>1 -ne 1
$false
1 -ne a
$true
</sxh> |
|  ''-gt''  |  supérieur à  |Renvoie ''$true'' si la première variable est strictement supérieure à la seconde  |<sxh powershell>2 -gt 1
$true
2 -gt 2
$false
</sxh>|
|  ''-ge''  |  supérieur ou égal à  |Renvoie ''$true'' si la première variable est supérieure ou égale à la seconde  |<sxh powershell>2 -ge 1
$true
2 -ge 2
$true
</sxh>|
|  ''-lt''  |  inférieur à  |Renvoie ''$true'' si la première variable est strictement inférieure à la seconde  |<sxh powershell>1 -lt 2
$true
2 -lt 2
$false
</sxh>|
|  ''-le''  |  inférieur ou égal à  |Renvoie ''$true'' si la première variable est inférieure ou égale à la seconde  |<sxh powershell>1 -le 2
$true
2 -le 2
$true
</sxh>|

A noter que les vérification ne sont pas sensible à la casse par défaut. Ainsi A -eq a renvoie la valeur $true. Pour rendre ces opérateur sensible à la casse, il suffit d'insérer un ''c'' après le ''-'' (par ex: ''-eq'' devient ''-ceq''). De plus, on peut forcer l'insensibilité à la casse en insérant un ''i'' après le ''-'' (par ex: ''-eq'' devient ''-ieq'').

==== Similitude et Correspondance ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-like''  |  ressemble à  |Renvoie ''$true'' si la première variable ressemble au schéma de la seconde variable, cette dernière contenant au moins un joker  | <sxh powershell>"Nicolas" -like "Nico*"
$true
</sxh> |
|  ''-notlike''  |  ne ressemble pas à  |Renvoie ''$true'' si la première variable ne ressemble pas au schéma de la seconde variable, cette dernière contenant au moins un joker  | <sxh powershell>"Nicolas" -notlike "Jean*"
$true
</sxh> |
|  ''-match''  |  correspond à  |Renvoie ''$true'' si la première variable contient ou correspond à un élément de la seconde variable  | <sxh powershell>"Nicolas","Jean","Marc" -match "Nico"
$true
</sxh> |
|  ''-notmatch''  |  ne correspond pas à  |Renvoie ''$true'' si la première variable ne contient pas ou ne correspond pas à un élément de la seconde variable  | <sxh powershell>"Nicolas","Jean","Marc" -notmatch "Albert"
$true
</sxh> |

Comme pour les opérateurs d'égalité, ces opérateurs sont par défaut insensibles à la casse. Les modificateurs ''c'' et ''i'' peuvent être utilisés.
Les opérateurs de type ''match'' peut utiliser les expressions régulières dans leur recherche de correspondances (voir [[powershell_regex|Les expressions régulières (regex)]]).
==== Inclusion ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-contains''  |  est contenu dans  |Renvoie ''$true'' si une des deux variables est contenu dans la collection d'élément de l'autre variable. Les tests sont réalisé sur les références des variables et non leur valeur.  | <sxh powershell>"Nicolas","Jean","Marc" -contains "Nicolas","Marc"
$true
</sxh> |
|  ''-notcontains''  |  n'est pas contenu dans  |Renvoie ''$true'' si une des deux variables n'est pas contenu dans la collection d'élément de l'autre variable. Les tests sont réalisé sur les références des variables et non leur valeur.  | <sxh powershell>"Nicolas","Jean","Marc" -notcontains "Nicolas","Paul"
$true
</sxh> |
|  ''-in''  |  est contenu dans  |Renvoie ''$true'' si une des deux variables est contenu dans la collection d'élément de l'autre variable. Les tests sont réalisé sur les valeurs des variables et non leur référence.  | <sxh powershell>$Nom = "Nicolas","Marc"
"Nicolas","Jean","Marc" -in $Nom
$true
</sxh> |
|  ''-notin''  |  n'est pas contenu dans  |Renvoie ''$true'' si une des deux variables n'est pas contenu dans la collection d'élément de l'autre variable. Les tests sont réalisé sur les valeurs des variables et non leur référence.  | <sxh powershell>$Nom = "Nicolas","Paul"
"Nicolas","Jean","Marc" -notin $Nom
$true
</sxh> |

==== Correspondance de type ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-is''  |  est de même type que  |Renvoie ''$true'' si les deux variables sont de même type (''Int'', ''String'', ''Array'', etc.)  | <sxh powershell>"Jean" -is "Nicolas"
$true
"Nicolas" -is 1
$false
</sxh>|
|  ''-isnot''  |  n'est pas de même type que  |Renvoie ''$true'' si les deux variables ne sont pas de même type (''Int'', ''String'', ''Array'', etc.)  | <sxh powershell>"Jean" -is "Nicolas"
$false
"Nicolas" -is 1
$true
</sxh>|

==== Logique ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-and''  |  et logique  |Renvoie $true si les valeurs des deux variables sont $true. La valeur d'une variable est définie sur $true selon son type (par exemple : une valeur supérieur à 0 pour un entier (''Int'') ou le fait qu'un objet existe)   | <sxh powershell>$a = $true
$b = 1
$a -and $b
$true
</sxh>|
|  ''-or''  |  ou logique  |Renvoie $true si au moins une valeur d'une des deux variables est $true. La valeur d'une variable est définie sur $true selon son type (par exemple : une valeur supérieur à 0 pour un entier (''Int'') ou le fait qu'un objet existe)   | <sxh powershell>$a = $false
$b = 1
$a -or $b
$true
</sxh>|
|  ''-xor''  |  ou exclusif logique  |Renvoie $true si les valeurs logiques des deux variables sont différentes  | <sxh powershell>$true -xor $true
$false
$true -xor $false
$true
</sxh>|
|  ''!'' ou ''-not''  |  non logique  |Inverse le résultat de l'opération logique à laquelle il est appliqué. $true deviendra $false et inversement.  | <sxh powershell>1 -eq 1
$true
!(1 -eq 1)
$false
</sxh>|

==== Manipulation ====

|< 100% 10% 10% 50% 30% >|
^  Opérateur  ^  Fonction  ^ Explication  ^  Exemple  ^
|  ''-replace''  |  remplace  |  Remplace des éléments dans une collection par d'autres éléments. Insensible à la casse.  | <sxh powershell>$a = "Je m'appelle Nicolas."
$a -replace "Nicolas","Jean"
Je m'appelle Jean.
</sxh>|
|  ''-creplace''  |  remplace  |  Remplace des éléments dans une collection par d'autres éléments. Sensible à la casse.  | <sxh powershell>$a = "Je m'appelle Nicolas."
$a -creplace "nicolas","jean"
# Pas de changement car nicolas n'a pas la même casse que Nicolas.
Je m'appelle Nicolas.  
</sxh>|

===== Les conditions =====

Les conditions permettent de réaliser une action selon le résultat d'une opération logique.

==== If, ElseIf, Else ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_if?view=powershell-6|Micorsoft]]

''If'' effectue un test. Si le résultat est ''$true'' alors un code est exécuté. En option, on peut indiquer un comportement particulier en cas de résultat ''$false'' :
  * ''ElseIf'' : Effectue un nouveau test et permet d'exécuter un code si ce dernier est ''$true''. On peut enchaîner autant de ''ElseIf'' que l'on veut.
  * ''Else'' : Exécute un code si le résultat du test ''If'' est ''$false''. Il ne peut y avoir qu'un seul ''Else'' et il sera placé à la fin du bloc ''If''.

<sxh powershell>
If ($Var -eq 1)                                      # On vérifie si la valeur de $Var est égale à 1 
    {                                                # On ouvre le bloc de code pour un résultat $true de If
        Write-Host '$Var = 1'                        # On écrit dans la console : $Var = 1
    }                                                # On ferme le bloc
ElseIf ($Var -eq 2)                                  # Si le test de IF est $false, on peut faire un autre test avec ElseIF
    {                                                # On ouvre le bloc de code pour un résultat $true de ElseIf
        Write-Host '$Var = 2'                        # On écrit dans la console : $Var = 2
    }                                                # On ferme le bloc du ElseIF
Else                                                 # On peut finir avec un Else qui sera exécuté si tous les tests précédents sont $false
    {                                                # On ouvre le bloc Else
        Write-Host '$Var différent de 1 et 2'        # On écrit dans la console encore une fois
    }                                                # On ferme le bloc
</sxh>

==== Switch ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_switch?view=powershell-6|Microsoft]]

''Switch'' permet d'exécuter un code selon le résultat d'un test. On pourra indiquer autant de résultats attendus que l'on souhaite et on terminera le bloc avec l'instruction ''default'' correspondant au code à exécuter si le résultat du test ne correspond à aucune des valeurs précédemment indiquées.

<sxh powershell>
$Entry = Read-Host "Entrez votre âge"                # On demande à l'utilisateur d'écrire son âge qu'on stocke dans $Entry
Switch ($Entry)                                      # On teste la valeur de $Entry. On pourrait aussi faire une opération logique
    {                                                # On ouvre le bloc d'exécution de Switch
        1        { Write-Host "Age: 1" }             # Si c'est 1, on écrit Age: 1
        2        { Write-Host "Age: 2" }             # Si c'est 2, on écrit Age: 2
        99       { Write-Host "Age: 99" }            # Si c'est 99, on écrit Age: 99
        default  { Write-Host "Je sais pas" }        # Sinon, on écrit Je sais pas
    }                                                # On ferme le bloc
</sxh>

''Switch'' est par défaut insensible à la casse. Ainsi, ''a'' sera traité de la même manière que ''A''. Si les deux résultats sont dans la liste des résultats attendus alors le traitement sera effectué sur chaque entrée de la liste. Pour éviter ce fonctionnement ou pour rendre ''Switch'' sensible à la casse on peut ajouter le paramètre ''-CaseSensitive''.

<sxh powershell>$Letter = "a"
Switch ($Letter)
{
    "a" { Write-Host "Lettre a" }
    "A" { Write-Host "Lettre A" }
}

# Retour
Lettre a
Lettre A

$Letter = "a"
Switch -CaseSensitive ($Letter)
{
    "a" { Write-Host "Lettre a" }
    "A" { Write-Host "Lettre A" }
}

# Retour
Lettre a</sxh>
===== Les boucles =====

Les boucles permettent de répéter un code un certain nombre de fois.

<callout type="warning" icon="true" title="Boucle infinie">Il faut toujours faire attention à ne pas créer une boucle infinie. Pensez à prévoir une porte de sortie.</callout>

==== ForEach-Object ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_foreach?view=powershell-6|Microsoft]]

''ForEach-Object'' (ou son alias ''ForEach'') permet d'exécuter un code sur chaque élément d'un ensemble d'éléments.

<sxh powershell>
$Serie = 1,2,3,4,5                             # On crée une variable contenant les valeurs 1, 2, 3, 4 et 5
ForEach ($Chiffre in $Serie)                   # On stockera dans $Chiffre une valeur de $Serie de la première à la dernière
    {                                          # On ouvre le bloc
        Write-Host $Chiffre                    # On écrit la valeur de $Chiffre dans la console
    }                                          # On ferme le bloc
    
# Cette boucle va nous renvoyer le résultat suivant :
1
2
3
4
5
</sxh>

=== Parallélisation ===

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/foreach-object?view=powershell-7|Microsoft]]

<callout type="warning" icon="true" title="Mise à jour du 22/02/2020">Dans Powershell Core, **ForEach** n'est plus la même chose que **ForEach-Object**.
  * **ForEach-Object** :  Permet la gestion des éléments du pipeline. Dispose désormais de l'option ''-Parallel'' permettant la gestion de plusieurs boucles en simultané (parallélisation).
  * **ForEach** : Ne prend pas en charge ni le pipeline ni la parallélisation. Traite uniquement un nombre défini d'itération.
</callout>

<callout type="warning" icon="true" title="Version">Cet exemple n'est valable qu'en Powershell Core (version 7 ou supérieure).</callout>

Dans cette exemple, on crée une boucle qui va attendre 30 fois 1 seconde soit théoriquement un total de 30 secondes :
<sxh powershell>(Measure-Command { 1..30 | ForEach-Object { Start-Sleep -Seconds 1 } }).Seconds
30</sxh>

En activant le paramètre ''-Parallel'' :
<sxh powershell>(Measure-Command { 1..30 | ForEach-Object -Parallel { Start-Sleep -Seconds 1 } }).Seconds
6</sxh>

La commande n'a mis que 6 secondes car la parallélisation a traitée 5 commandes (valeur par défaut) en concurrence. Le paramètre ''-ThrottleLimit'' permet de définir le nombre de commandes concurrentes :
<sxh powershell>(Measure-Command { 1..30 | ForEach-Object -Parallel { Start-Sleep -Seconds 1 } -ThrottleLimit 10 }).Seconds
3</sxh>

La parallélisation permet d'améliorer le temps d'exécution des scripts mais attention tout de même. Chaque concurrent va créer son propre espace de travail (''runspace''), traiter la commande et le clore. Dans certains cas, ces multiples actions d'ouvertures et fermetures sont plus longues que le traitement, ce qui entraîne une augmentation global de la durée d'exécution du script. Par exemple :
<sxh powershell>(Measure-Command { Get-Process | ForEach-Object { Write-Host $_.Name } }).Milliseconds
91
(Measure-Command { Get-Process | ForEach-Object -Parallel { Write-Host $_.Name } }).Milliseconds
995</sxh>

<callout type="info" icon="true" title="Parallélisation">La parallélisation est donc très intéressante mais à utiliser avec sagesse.</callout>

==== For ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_for?view=powershell-6|Microsoft]]

''For'' nécessite une variable qui servira de compteur. Un test sera réalisé sur ce compteur et un code sera exécuté si ce test est ''$true''. Une fois le code exécuté, le compteur est incrémenté selon le pas indiqué. A la place du pas, on peut indiquer un nombre maximal d'itération.

<sxh powershell>
For ( $i=0 ; $i -lt 5 ; $i++ )             # On part de 0, on teste si $i est inférieur à 5 et à chaque boucle on ajoute 1 à $i
    {                                      # On ouvre le bloc
        Write-Host $i                      # On écrit la valeur de $i
    }                                      # On ferme le bloc
    
# La boucle suivante nous renvoie les résultats suivants :
0
1
2
3
4
</sxh>
==== Do, Until, While ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_do?view=powershell-6|Microsoft]]

''Do'' va exécuter un code puis effectuer un test. Selon le résultat de ce test, il continuera ou arrêtera la boucle. Le test est introduit par les commande ''Until'' ou ''While''.
  * ''Until'' : on continue jusqu'à ce que le résultat du test soit $true.
  * ''While'' : on continue tant que le résultat du test est $true.

<sxh powershell>
$i = 0                                                  # On crée une variable dont la valeur est 0
Do                                                      # On se prépare à faire une boucle
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc
Until ($i -eq 4)                                        # On teste si $i est égal à 4

# La boucle ci-dessus nous renvoie les résultat suivant :
0
1
2
3

$i = 0                                                  # On crée une variable dont la valeur est 0
Do                                                      # On se prépare à faire une boucle
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc
While ($i -eq 4)                                        # On teste si $i est égal à 4

# En changeant Until par While, on obtient :
0

# La boucle avec Until s'est arrêté à 3 car lorsque $i a eu la valeur 4, le test a renvoyé un $true.
#
# Dans le cas de While, la boucle n'a exécuté que la première itération car le test "$i est-il égal à 4 ?" a renvoyé un $false
# $i étant égal à 1, à ce moment là.
</sxh>
==== While ====

  * Référence : [[https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_while?view=powershell-6|Microsoft]]

''While'' (l'instruction seule et non celle qui termine l'instruction ''Do'') est différent de ''Do'' du fait qu'elle n'exécute le code qu'après avoir vérifier que son test soit vrai.
Ainsi ''Do'' effectue au moins une itération alors que ''While'' peut n'en effectuer aucune.

<sxh powershell>
$i = 0                                                  # On crée une variable dont la valeur est 0
While ($i -ne 4)                                        # On teste si $i est différent de 4
    {                                                   # On ouvre le bloc
        Write-Host $i                                   # On écrit la valeur de $i
        $i++                                            # On ajoute 1 à $i (Pour éviter les boucles infinies)
    }                                                   # On ferme le bloc

# La boucle suivante renvoie :
0
1
2
3 

# Si on avait remplacé -ne par -eq dans le test, la console n'aurait rien affiché car la vérification 
# du test aurait renvoyé $false
</sxh>

~~DISCUSSION~~