====== PowerShell ======

===== Structure de contrôle =====
\\ 

|Opérateurs de comparaison |[[windows:powershell:variables#operateurs_de_comparaison|Voir]] |

==== Test IF ====
  * **Tester une condition**
<cli>if (<test1>)
    { <bloc_code> }</cli>
  * **Tester plusieurs conditions**
<cli>if (<test1>)
    { <bloc_code> }
elseif (<test2>)
    { <bloc_code> }
else
    { <bloc_code> }    
    </cli>
  * **Exemple**
<cli>> $day = 3
> if ( $day -eq 0 ) { $result = 'Sunday'        }
> elseif ( $day -eq 1 ) { $result = 'Monday'    }
> elseif ( $day -eq 2 ) { $result = 'Tuesday'   }
> elseif ( $day -eq 3 ) { $result = 'Wednesday' }
> elseif ( $day -eq 4 ) { $result = 'Thursday'  }
> elseif ( $day -eq 5 ) { $result = 'Friday'    }
> elseif ( $day -eq 6 ) { $result = 'Saturday'  }

PS C:\> $result
Wednesday
</cli>
\\ 
==== Test SWITCH ====
L’instruction switch vous permet de fournir une variable et une liste de valeurs possibles. Si la valeur correspond à la variable, son scriptblock est exécuté.
  * **Syntaxe**
<cli>switch ( $var_à_tester )
{
    0 { $var = <choix_1> }
    # ...
    6 { $var = <choix_7> }
    default { $var = <choix_par_defaut> }
}

#_ou

$var = switch ( $var_à_tester )
{
    0 { <choix_1> }
    # ...
    6 { <choix_7> }
    default { <choix_par_defaut> }
}
</cli>
  * **Exemple**
<cli>> $day = 3

> switch ( $day )
> {
>     0 { $result = 'Sunday'    }
>     1 { $result = 'Monday'    }
>     2 { $result = 'Tuesday'   }
>     3 { $result = 'Wednesday' }
>     4 { $result = 'Thursday'  }
>     5 { $result = 'Friday'    }
>     6 { $result = 'Saturday'  }
> }

PS C:\> $result
Wednesday
</cli>
Autre écriture possible (on affecte le résultét à la variable ''$result'' :
<cli>> $result = switch ( $day )
> {
>     0 { 'Sunday'    }
>     1 { 'Monday'    }
>     2 { 'Tuesday'   }
>     3 { 'Wednesday' }
>     4 { 'Thursday'  }
>     5 { 'Friday'    }
>     6 { 'Saturday'  }
> }
</cli>
\\ 
==== Boucle FOR ====
Exécute les commandes d'un bloc tant qu'une condition spécifiée prend la valeur TRUE.
  * **Syntaxe**
<cli>for(<init>; <condition>; <répétition>)
    { <bloc_commandes> }
</cli>

  * Exemple : Incrémente la variable $i de 1 à 20
<cli>PS C:\> for($i=1; $i<21; $i++) { Write-Host $i }
1
2
3
...
19
20</cli>
\\ 
==== Boucle FOREACH ====
Commande permettant de parcourir tous les éléments d'une collection.
  * **Syntaxe**
<code>foreach ($<élément> in $<collection>)
    { <bloc_commandes> }</code>
  * **Parcourir un tableau**
<cli>PS C:\> $planetes_array = @("Terre","Venus","Mercure","Jupiter")
PS C:\> foreach ($planete in $planetes_array) { "$planete : " + $planete.Length + "lettres" }
Terre : 5 lettres
Venus : 5 lettres
Mercure : 7 lettres
Jupiter : 7 lettres</cli>

  * **Parcourir une collection**
<cli>PS C:\> foreach ($fich in Get-ChildItem) { Write-Host $fich }
PerfLogs
Program Files
Program Files (x86)
Users
Windows</cli>
\\ 
==== Boucle FOREACH-OBJECT ====
**ForEach-Object** est identique à ForEach, mais permet également l'usage de 3 blocs :
  * Un bloc **begin** exécuté une seule fois au début
  * Un bloc **process** exécuté à chaque entrée d'objet dans le pipeline
  * Un bloc **end** exécuté une seule fois à la fin

__Exemple__ : Retourne les adresses MAC de type Ethernet de la machine locale
<konsole>PS C:\> Get-WmiObject Win32_networkAdapter | Where {$_.adapterType -match "eth"} | ForEach-Object {Write-Host "Adresse MAC" -fore green}{$_.macaddress}{Write-Host "FIN" -fore yellow}
<color green>Adresse MAC</color>
EC:55:F9:84:89:A1
EC:55:F8:81:98:A7
F6:55:F9:84:89:A1
<color yellow>FIN</color>
</konsole>
\\ 

----
===== Fonctions =====
\\ 
==== Structure d'une fonction ====
<cli>
Function[portée:] <nom_fonction>(<arguments)
{
  param (<liste des paramètres>)
  #_Bloc d'instructions
}
</cli>
\\ 
==== Fonctions sans argument ====
  * Exemple 1 : Fonction qui démarre un PowerShell avec l'option 'Exécuter en tant qu'administrateur'.
<cli>Function start-PSAdmin
{
  Start-Process PowerShell -Verb RunAs
}
</cli>
  * Exemple 2 : Fonction qui recherche tous les fichiers ''.jpg'' dans un répertoire donné et qui ont été modifiés après la date de début.
  * <cli>Function Get-NewPix
{
  $start = Get-Date -Month 1 -Day 1 -Year 2020
  $allpix = Get-ChildItem -Path $env:UserProfile\*.jpg -Recurse
  $allpix | Where-Object {$_.LastWriteTime -gt $start}
}
</cli>
\\ 
==== Fonctions avec arguments ====
Les arguments dans les fonctions permettent le passage de variables, de valeurs.
  * **Cas 1** : Définir des paramètres à l'intérieur des accolades (''**param**'')
<cli>Function <name> {
  param ([type]$parameter1 [,[type]$parameter2 ,...])
  <statement list>
}
</cli>
__Exemple__ : on récupère la variable $Size, passée en paramètre lors de l'appel à la fonction
<cli>Function Get-SmallFiles {
  param($Size)
  Get-ChildItem $HOME -recurse | Where-Object {$_.Length -lt $Size -and !$_.PSIsContainer}
}

PS C:\> Get-SmallFiles 50
#_ou
PS C:\> Get-SmallFiles -Size 50
</cli>

  * **Cas 2** : Définir des paramètres en dehors des accolades
<cli>Function <name> ([type]$parameter1 [,[type]$parameter2 ,...]) {
  <statement list>
}
</cli>
__Exemple__ : on peut réécrire la fonction ci-dessus de cette manière.
<cli>Function Get-SmallFiles ( $Size ) {
  Get-ChildItem $HOME -recurse | Where-Object {$_.Length -lt $Size -and !$_.PSIsContainer}
}
</cli>

  * **Stockage et appel des arguments**
Lorsque des arguments sont placés dans une fonction, ils sont stockés dans un tableau nommé ''**$args**''.

__Exemple__ : Utilisation des arguments passés en paramètres de la fonction
<cli>Function get-fic {
  Get-ChildItem $args[0] | Where length -gt $args[1]
}

PS C:\> get-fic C:\Temp 100KB
#_Retourne tous les fichiers >100KB dans le répertoire C:\Temp 
</cli>