PowerShell

• Tester une condition

if (<test1>)
    { <bloc_code> }

• Tester plusieurs conditions

if (<test1>)
    { <bloc_code> }
elseif (<test2>)
    { <bloc_code> }
else
    { <bloc_code> }    

• Exemple

> $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

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

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> }
}

• Exemple

> $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

Autre écriture possible (on affecte le résultét à la variable $result :

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

Exécute les commandes d'un bloc tant qu'une condition spécifiée prend la valeur TRUE.

• Syntaxe

for(<init>; <condition>; <répétition>)
    { <bloc_commandes> }

• Exemple : Incrémente la variable $i de 1 à 20

PS C:\> for($i=1; $i<21; $i++) { Write-Host $i }
1
2
3
...
19
20

Commande permettant de parcourir tous les éléments d'une collection.

• Syntaxe

foreach ($<élément> in $<collection>)
    { <bloc_commandes> }

• Parcourir un tableau

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

• Parcourir une collection

PS C:\> foreach ($fich in Get-ChildItem) { Write-Host $fich }
PerfLogs
Program Files
Program Files (x86)
Users
Windows

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

Function[portée:] <nom_fonction>(<arguments)
{
  param (<liste des paramètres>)
  #_Bloc d'instructions
}

• Exemple 1 : Fonction qui démarre un PowerShell avec l'option 'Exécuter en tant qu'administrateur'.

Function start-PSAdmin
{
  Start-Process PowerShell -Verb RunAs
}

• 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.

• 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}
  }

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)

Function <name> {
  param ([type]$parameter1 [,[type]$parameter2 ,...])
  <statement list>
}

Exemple : on récupère la variable $Size, passée en paramètre lors de l'appel à la fonction

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

• Cas 2 : Définir des paramètres en dehors des accolades

Function <name> ([type]$parameter1 [,[type]$parameter2 ,...]) {
  <statement list>
}

Exemple : on peut réécrire la fonction ci-dessus de cette manière.

Function Get-SmallFiles ( $Size ) {
  Get-ChildItem $HOME -recurse | Where-Object {$_.Length -lt $Size -and !$_.PSIsContainer}
}

• 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

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