Cet article rassemble quelques rappels concernant Powershell pour se remettre en mémoire les instructions principales de ce langage. D’autres fonctionnalités sont détaillées davantage dans Powershell en 10 min.

Quelques remarques en préambule:

Powershell n’est pas sensible à la casse
Pour commenter du code, il faut utiliser le caractère #

# Code Powershell commenté

Variables

Généralement le type n’est pas indiqué explicitement mais le type est déterminé par le type de la valeur d’initialisation:

$var=65 
$var2="class string"

On peut forcer un typage particulier de cette façon:

[string]$var = 65      # $var est une chaîne de caractères

Raccourcis pour indiquer explicitement le type

D’autres types peuvent être indiqués de cette façon:

Raccourci	Type de données
`[datetime]`	Date ou heure
`[string]`	Chaîne de caractères
`[char]`	Un seul caractère
`[double]`	Nombre flottant double précision
`[single]`	Nombre flottant simple précision
`[int]`	Entier 32 bits
`[Boolean]`	Valeur True ou False (Vrai ou Faux)

Typage avec des types .NET

On peut indiquer un typage .NET avec une syntaxe de ce type:

[System.Int32]$var = 5

Utilisation des variables

Quelques exemples d’utilisation de variables:

$var="powershell"  
Write-Host "classic $var string"     # $var est remplacé par sa valeur 
# à cause des double quotes " "

$var2='classic $a string'      # $var2 n'est pas interprété car 
# on utilise de simples quotes ' ' 
Write-Host $var2

On peut aussi utiliser le caractère accent grave ([AltGr] + [7]):

$var2="classic `$a string" 
Write-Host $var2

“Cmdlets” principales

Affiche de l’aide

D’une façon générale, pour avoir de l’aide concernant une cmdlet (i.e. command let):

Get-Help <nom de la commande>

Quelques “cmdlets”

Cmdlet	Raccourcis	Explications	Exemples
`Get-Location`	`pwd gl`	Permet d’avoir le répertoire courant	`Get-Location`
`Set-Location`	`cd chdir sl`	Permet de changer le répertoire courant	`Set-Location "C:\Directory"`
`Copy-Item`	`copy cp cpi`	Copie un élément	`Copy-Item "C:\Directory\file.txt" -Destination "C:\OtherDirectory" Copy-Item C:\Directory -Destination C:\OtherDirectory -Recurse`
`Move-Item`	`move mv mi`	Déplace et/ou renomme un élément	`Move-Item -Path C:\Directory\file.txt -Destination C:\OtherDirectory\otherFile.txt Move-Item -Path .\*.txt -Destination C:\TextFiles`
`Remove-Item`	`del rm`	Supprime des éléments	`Remove-Item -Path C:\Directory\file.txt Remove-Item C:\Directory\. Remove-Item * -Include .txt -Exclude 1*`
`Rename-Item`	`rni ren`	Renomme un élément	`Rename-Item -Path "C:\Directory\file.txt" -NewName "new_file.txt"`
`New-Item`		Permet de créer un nouvel élément	`New-Item -Path "C:\Directory" -Name "NewDirectory" -ItemType "directory" New-Item -ItemType "file" -Path "C:\Directory\NewDirectory\file.txt"`
`Get-ChildItem`	`dir ls gci`	Permet d’afficher le contenu d’élément enfant à l’intérieur d’un élément (par exemple les fichiers d’un répertoire)	`Get-ChildItem Get-ChildItem -Path C:\Directory\* -Include .txt -Exclude A Get-ChildItem -Path *.txt -Recurse`
`Write-Host`		Permet d’afficher une erreur sur la console	`Write-Error "Une erreur est survenue."`
`Clear-Host`	`cls clear`	Permet d’effacer le contenu de la console	`Clear-Host`
`Get-History`	`h history ghy`	Affiche l’historique de la console	`Get-History Get-History -Count 1`
`Get-Content`	`cat gc type`	Affiche le contenu d’un fichier	`Get-Content -Path "C:\Directory\file.txt"`
`Set-Content`	`sc`	Ecrit ou remplace le contenu d’un fichier avec un nouveau contenu	`Set-Content -Path "C:\Directory\file.txt" -Value "Nouveau contenu" Set-Content -Path "C:\Directory\file.txt" -Value $var`
`Add-Content`		Permet d’ajouter un contenu à un fichier	`Add-Content -Path "C:\Directory\file.txt" -Exclude "Log" -Value "Nouvelle valeur"`

Utilisation de “cmdlets” avec un “pipe”

Le pipe permet d’exécuter des instructions successivement, par exemple:

Get-ChildItem | Where-Object { $_.Length -gt 100kb } # Affiche les fichiers de plus de 100kb

Effectuer un traitement sur chacun des éléments listés:

Get-Process | ForEach-Object {$_.ProcessName}

Pour écrire les résultats dans un fichier:

Get-Process | Out-File -filepath C:\Directory\process.txt

PowerShell Module Browser

Microsoft a mis en place un browser capable d’afficher de l’aide sur toutes les commandes Powershell suivant la version: PowerShell Module Browser.

Pour vérifier la version de Powershell, il faut taper:

$PSVersionTable.PSVersion

Instructions

if…then…else

$var = 2  
if ($var -eq 1)  
{  
  Write-Host "OK"
}  
else  
{  
  Write-Host "KO"
}

On peut aussi écrire l’instruction en ligne:

$var = 2; if ($var -eq 1) { Write-Host "OK" } else { Write-Host "KO" };

Opérateurs de comparaison

Opérateur	Signification	Commentaires
`-eq`	Comparateur d’égalité
`-ne`	“not equal to”	La valeur est `True` si les opérandes ne sont pas égales
`-ge`	“greater than or equal”	La valeur est `True` si l’opérande de gauche est supérieure ou égale à l’opérande de droite
`-gt`	“greater than”	La valeur est `True` si l’opérande de gauche est strictement supérieure à l’opérande de droite
`-le`	“less than or equal”	La valeur est `True` si l’opérande de gauche est inférieure ou égale à l’opérande de droite
`-lt`	“less than”	La valeur est `True` si l’opérande de gauche est strictement inférieure à l’opérande de droite
`-like` et `-notlike`		Permet d’effectuer des comparaisons d’égalité de chaines de caractères en utilisant des wildcards: ? pour désigner un seul caractère non spécifié * pour désigner un ou plusieurs caractères non spécifiés Par exemple: `$var -like "*uary"`
`-match` et `-notmatch`		Permet de vérifier si une chaine de caractères respecte une expression régulière. Par exemple: `$string -match "\w"`
`-contains` et `-notcontains`		Permet de tester si une valeur se trouve dans une liste. Par exemple: `$names = "val1", "val2", "val3" $names -Contains "val2"`
`-is` et `-isnot`		Permet de tester le type d’une variable .NET (même opérateur qu’en C#). Par exemple: `$stringToTest = "chaine de caracteres" ($stringToTest -is [System.String])`

Variables automatiques

Les variables les plus importantes:

Variable	Signification
`$FALSE`	Faux
`$TRUE`	Vrai
`$NULL`	Valeur nulle
`$PWD`	Chemin du répertoire courant

Il existe d’autres variables automatiques: About Automatic Variables.

Boucle “foreach”

Par exemple:

$array = 1, 2, 3, 4  
foreach ($item in $array)  
{  
  "`$item = $item"  
}

Autre exemple:

foreach ($file in Get-ChildItem)  
{  
  break # Permet d'arrêter l'exécution de la boucle.

  # On peut aussi utiliser continue comme en C#
}

Try…Catch…Finally

On peut utiliser un bloc try...catch...finally comme en C#:

Try 
{ 
    $arg= 3/0 
} 
Catch 
{ 
    Write-Host "Une erreur est survenue" 
}

En spécialisant l’erreur pour un type précis d’exception:

Try 
{ 
    $arg= 3/0 
} 
Catch [System.DivideByZeroException] 
{ 
    Write-Host "Division par 0" 
} 
Catch 
{ 
    Write-Host "Une erreur est survenue" 
}

Une autre syntaxe est possible en utilisant le mot clé: trap.

Fonctions

Une fonction se définit avec le mot-clé function:

function NomFonction()  
{  
     Write-Host "Executed" 
}

Avec des paramètres, on peut utiliser cette syntaxe:

function ExecuteMe  
{ 
     param( $parameter1, $parameter2 ) 
     Write-Host "Executed with parameter: $parameter1 $parameter2"  
}

Pour lancer l’exécution avec la syntaxe précédente:

ExecuteMe -parameter1 "Value1" -parameter2 "Value2"

Ou une autre syntaxe est possible:

function ExecuteMe( $parameter1, $parameter2) 
{ 
     Write-Host "Executed with parameter: $parameter1 $parameter2"  
}

Pour lancer l’exécution, il ne faut pas utiliser de parenthèses:

ExecuteMe "Value1" "Value2"

Return

Pour retourner une valeur dans une fonction:

function ReturnValue( [int]$parameter1, [int]$parameter2) 
{ 
     return $parameter1 + $parameter2 
}

Pour lancer l’exécution:

$returnedValue = ReturnValue 2 3

Lancer l’exécution d’instructions

A partir d’une ligne de commandes classique

%windir%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy ByPass 
  -NoLogo –NoProfile -Command "& '<Fichier PS1 ou commandes Powershell>'"

En 32 bits, il faut utiliser le chemin: %windir%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe.

Pour exécuter un fichier:

%windir%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy ByPass 
  –NoLogo –NoProfile -File "<Chemin du fichier PS1>"

A partir d’une console Powershell

D’autres syntaxes sont utilisables à partir de la console Powershell:

."\\c$\Directory\file.ps1" 
&"\\c$\Directory\file.ps1"

Pour exécuter directement des instructions (utilisation de script-blocks):

& { <Instructions Powershell> }

Passage d’arguments à un script Powershell

On peut passer des arguments à un script Powershell en déclarant dans le fichier du script:

param([Int32]$parameter1=1, [Int32]$parameter2=3) # Doit être à la 1ère ligne du script 

Write-Host $parameter1 
Write-Host $parameter2

Le lancement du script se fait de cette façon:

%windir%\System32\WindowsPowerShell\v1.0\powershell.exe -ExecutionPolicy ByPass 
  –NoLogo –NoProfile -File "<Chemin du fichier PS1>" -parameter1 3 –parameter2 6

On peut utiliser une syntaxe plus simple sans nommer les arguments:

$parameter1=$args[0] 
$parameter2=$args[1] 

Write-Host $parameter1 
Write-Host $parameter2