Introduction

Il  existe  de  très  nombreux  types  d’opérateurs,  mais  qu’ils  soient  arithmétiques,  binaires, logiques  ou  autres,  tous 
permettent  d’agir  sur  les  variables.  Gardez  bien  à  l’esprit que  connaître  et  maîtriser  ces  différents  opérateurs  est 
essentiel pour l’élaboration d’un bon script. 

1. Opérateurs arithmétiques

En ce qui concerne les opérations arithmétiques, PowerShell traite les expressions de gauche à droite en respectant 
les règles des propriétés mathématiques ainsi que les parenthèses.  

Exemple 

PS > 2+4*3
14
PS > (2+4)*3
18

La liste des opérateurs arithmétiques disponibles vous est donnée ci­dessous : 

Signe  Signification 

+  Addition 

-  Soustraction 

*  Multiplication 

/  Division 

%  Modulo 

Les quatre premiers opérateurs doivent logiquement vous sembler familiers, quant au dernier, l’opérateur modulo, 
celui­ci permet de retourner le reste d’une division entière de a par b. 

Par exemple, en tapant  5%3 dans la console, nous obtenons  2. Tout simplement parce qu’il y a  1 fois  3 dans  5 et 

que le reste de la division vaut 2. 

Vous constaterez que les opérations arithmétiques s’appliquent également aux variables. Ainsi,  $var1 + $var2 

vous  retournera  la  somme  des  deux  variables  si  elles  contiennent  des  valeurs  numériques.  Dans  le  cas  d’un type 
chaîne, l’opérateur + aura pour effet de concaténer le contenu des variables. 

Exemple de l’opérateur + sur deux entiers 

PS > $int1 = 10
PS > $int2 = 13
PS > $int2 + $int1
23

L’opérateur  addition  s’emploie  également  avec  des  chaînes  (variables  de  type  string).  Dans  ce  cas­là,  l’opérateur 
sert à concaténer les deux chaînes : 
 PS > $chaine1 = ’A’
PS > $chaine2 = ’B’
PS > $chaine1 + $chaine2
AB

Toujours  avec  les  chaînes  de  caractères,  sachez  qu’il  est  possible  de  répéter  le  contenu  d’une  chaîne  grâce  à 
l’opérateur multiplication : 

PS > $chaine1 = 10 * ’A’

PS > $chaine1
AAAAAAAAAA
PS > $chaine1 = ’ABC’ * 10
PS > $chaine1
ABCABCABCABCABCABCABCABCABCABC

Retrouvez d’autres opérateurs mathématiques comme le calcul d’un sinus, d’un cosinus, d’une racine 
carrée, etc. via la classe System.Math disponible dans le framework .NET (cf. chapitre Framework .NET 
et .NET Core). 
Opérateurs de comparaison

Avec  un  nom  aussi  évocateur,  inutile  de  préciser  que  les  opérateurs  de  comparaison  permettent  de  comparer  des 
données entre elles. Contrairement à d’autres  langages,  PowerShell  utilise  les  mêmes  opérateurs  que  ce  soit  pour 
comparer  des  nombres,  des  chaînes  de  caractères,  ainsi  que  pour  effectuer  des  recherches  d’éléments  dans  un 
tableau.  

Voici l’ensemble des opérateurs de comparaison : 

Opérateur  Signification 

-eq  Égal 

-ne  Non égal (différent) 

-gt  Strictement supérieur 

-ge  Supérieur ou égal 

-lt  Strictement inférieur 

-le  Inférieur ou égal 

Important :  il  faut  connaître  une  petite  subtilité  du  langage  qui  fait  que  les  opérateurs n’ont  pas  le  même 
comportement lorsqu’ils  sont  appliqués  à  une  valeur  scalaire ou  à  un  tableau.  En  effet,  appliqués  à  un  scalaire,  les 
opérateurs retournent une valeur booléenne, ce qui n’est pas le cas avec un tableau. 

1. Comparaison sur des scalaires

Une  valeur  scalaire  est  une  valeur  atomique,  telle  qu’un  nombre,  un  caractère  ou  une  chaîne  de  caractères.  On 
oppose généralement les tableaux aux scalaires, tableaux qui contiennent généralement (mais pas tout le temps) 
des valeurs scalaires. 

Exemples 

Opération sur les chaînes  Opération sur les nombres 

PS > ’A’ -eq ’a’  PS > 1 -lt 2 

True  True 
PS > ’A’ -ceq ’a’  PS > 2 -lt 1 
False  False 
PS > ’A’ -ceq ’A’  PS > 2 -gt 1 
True  True 
PS > ’PowerShell’ -eq ’powershell’  PS > 2 -eq 2 
True  True 

Appliqués  aux  chaînes  de  caractères,  les  opérateurs  de  comparaison  ne  sont  pas  sensibles  à  la 
casse,  c’est­à­dire  qu’ils  ne  font  pas  la  distinction  entre  les  minuscules  et  les  majuscules.  Pour 
remédier à cela, faites simplement précéder le nom de l’opérateur de la lettre c, comme par exemple 
-ceq. 

2. Comparaison sur des tableaux

Appliqués  sur  des  tableaux,  les  opérateurs  ne  retournent  pas  un  booléen  comme  sur  les  scalaires,  mais  ils 
retournent la ou les valeurs trouvées. On utilise généralement les opérateurs d’égalité afin de vérifier si une valeur 
est contenue ou non dans un tableau. 

Exemples 

PS > "Arnaud","Robin","Eléonore" -eq "Eléonore"

Eléonore

PS > "Arnaud","Robin","Eléonore" -ne "Eléonore"

Arnaud
Robin

PS > "Arnaud","Robin","Eléonore" -cne "eléonore"

Arnaud
Robin
Eléonore

PS > 1,2,3,4,5 -eq 4

4

PS > 1,2,3,4,5 -ne 4

1
2
3
5
Opérateurs de comparaison générique
Une  expression  générique  est  une  expression  qui  contient  un  caractère  dit « générique ».  Par  exemple,  l’étoile  (*) 
remplace n’importe quelle suite de caractères, et le point d’interrogation (?) se substitue à un caractère unique.  

Comme  les  opérateurs  de  comparaison  précédents,  les  opérateurs  génériques  ne  retournent pas  le  même  type  de 
données selon qu’ils sont appliqués à une valeur scalaire ou à un tableau. 

Il existe deux opérateurs de comparaison permettant de comparer une chaîne avec une expression générique. 

Opérateur  Signification 

-like  Comparaison d’égalité d’expression générique. 

-notlike  Comparaison d’inégalité d’expression générique. 

Pour mieux comprendre l’utilisation de ces opérateurs, voici quelques exemples d’applications : 

# Opérations sur scalaires

PS > ’Powershell’ -like ’*shell’

True

PS > ’powershell’ -like ’power*’

True

PS > ’Powershell’ -clike ’p*shell’

False

PS > ’powershell’ -like ’*war*’

False

PS > ’powershell’ -like ’*wer*’

True

PS > ’powershell’ -like ’po?er*’

True

PS > ’power’ -like ’po?er*’

True

PS > ’potter’ -like ’po?er*’

False

PS > ’powershell’ -like ’power?????’

True

# Opérations sur tableaux

PS > "Arnaud","Robin","Eléonore" -like "*onore"

Eléonore
PS > "Arnaud","Robin","Eléonore","arthur" -clike "A*"
Arnaud

PS > "Arnaud","Robin","Eléonore","arthur" -like "a*"

Arnaud
arthur

PS > "Arnaud","Robin","Eléonore","arthur" -notlike "a*"

Robin
Eléonore

PS > "Arnaud","Robin","Eléonore","arthur" -cnotlike "*a*"

Robin
Eléonore

PS > "Arnaud","Robin","Eléonore","arthur" -cnotlike "a*"

Arnaud
Robin
Eléonore

Les opérateurs de comparaison générique peuvent (comme les opérateurs de comparaison) ou non respecter la casse. 
Si  vous  souhaitez  que  l’opérateur  respecte  la  casse,  faites  précéder  son  nom  de  la  lettre  c,  ce  qui  nous  donne  -
clike et -cnotlike. 
Opérateur de comparaison des expressions régulières

Les  expressions  régulières  (regex)  sont  bien  connues  des  administrateurs  systèmes  Unix/Linux, mais  généralement 
beaucoup  moins  connues  des  administrateurs  Windows.  La  raison  vient  du  fait  que  les  premiers  sont  habitués  à 
manipuler du texte avec des outils en ligne de commandes usuels tels que grep, awk, tail, etc. 

Les expressions régulières représentent un métalangage extrêmement puissant dédié à la manipulation des chaînes 
de caractères. On les utilise pour comparer des chaînes et/ou pour capturer des chaînes de caractères répondant à 
un modèle spécifique à l’intérieur de fichiers texte. 

Les  expressions  régulières  sont,  dans  les  années  1950,  sorties  de  la  tête  d’un  mathématicien chevronné,  puis 
implémentées  dans  les  années  70  dès  les  premières  versions  d’Unix.  C’est  peut­être  la  raison  pour  laquelle  leur 
syntaxe peut paraître assez cabalistique au premier abord, mais ne vous laissez pas impressionner ! 

Nous vous invitons à consulter l’aide en ligne et en particulier la rubrique d’aide about_Regular_Expression qui 
constitue une entrée en matière intéressante. 

PowerShell dispose des deux opérateurs de comparaison d’expressions régulières suivants : 

Opérateur  Signification 

-match  Comparaison d’égalité entre un pattern et une expression régulière. 

-notmatch  Comparaison d’i 
négalité entre un pattern et une expression régulière. 

Le principe des expressions régulières est de faire correspondre un modèle (appelé « pattern » en anglais) avec une 

chaîne  de  caractères.  Elles  permettent  d’analyser  de  grandes  quantités  de  données,  et  ce  de  manière  très 
performante et en un minimum d’efforts (lorsqu’on les maîtrise). 

Le principal inconvénient est que le modèle peut vite devenir très complexe, et être encore plus difficile à déchiffrer et 
à maintenir plusieurs mois après l’avoir écrit ; surtout lorsque l’on ne les pratique pas tous les jours ! 

Les  regex  sont  souvent  utilisées  pour  valider  des  données  saisies,  comme  par  exemple  une  adresse  IP  ou  une 
adresse e­mail. En effet, dans ces deux cas il est aisé d’établir un modèle. Si l’on prend le cas d’une  adresse  IPv4, 
nous savons qu’elle est composée de quatre groupes de chiffres séparés par le caractère « . ». Un modèle de regex 
peut facilement correspondre à ce modèle… 

Mais  l’usage  le  plus  répandu  est  certainement  l’analyse  de  fichiers  de  logs.  En  effet,  il  s’agit  du  domaine  de 
prédilection des regex. Dans un tel contexte, il est facile de déterminer si une information existe et il est tout aussi 
facile de la capturer. 

Nous  ne  rentrerons  pas  dans  davantage  de  détails  mais  préférons  illustrer  par  l’exemple  la  puissance  des  regex. 
Encore une fois, le résultat de la comparaison avec une regex diffère selon qu’on l’effectue avec un scalaire ou avec 
un tableau. 

1. Opérations sur les scalaires

Lorsque  l’on  compare  une  expression  régulière  avec  un  scalaire,  la  valeur  de  retour  est  de  type  booléen  et  la 
variable automatique $Matches contient le résultat de la correspondance (si correspondance il y a). 

Exemples 
 # Opérations sur scalaires

# Commence par la lettre p ?

PS > ’PowerShell’ -match ’ˆp’
True

PS > $matches
Name Value
---- -----
0 P

# Se termine par la lettre l ?

PS > ’Powershell’ -match ’l$’
True

PS > $Matches
Name Value
---- -----
0 l

# Accepte à la place du s l’un des caractères s, o, l

PS > ’Powershell’ -match ’power[sol]hell’
True

PS > $matches
Name Value
---- -----
0 Powershell

À  présent,  voyons  un  exemple  un  peu  plus  complexe.  Nous  allons  créer  un  modèle  de  regex  qui  correspond  à  la 
chaîne  Date: 17/01/2018. Ensuite nous capturerons uniquement la date et nous nous assurerons que la date 
capturée respecte un certain format (jour et mois codés sur deux caractères, slash comme séparateur, année sur 
quatre caractères). Ainsi une date ne respectant pas ce format ne sera pas prise en compte. 

PS > ’Date: 17/01/2018’ -match ’ˆDate:\s\d{2}/\d{2}/\d{4}$’

True

PS > $matches
Name Value
---- -----
0 Date: 17/01/2018

Le ˆ indique que la chaîne doit commencer par le caractère suivant, dans notre cas la lettre d ou D. 

\s représente un caractère blanc tel qu’un espace, une tabulation ou un retour chariot.  

\d représente un nombre compris entre 0 et 9. 

{2} représente un quantificateur qui indique que nous voulons 2 occurrences du caractère précédent. 

\/ représente le caractère slash (/). L’antislash (\) est le caractère d’échappement des regex. 
$ indique que la chaîne doit se terminer par le caractère précédent, dans notre cas un nombre. 

Si nous n’avions pas indiqué les caractères ˆ et $, notre expression régulière se serait appliquée de façon glissante. 
Ces  caractères  sont  conseillés  lorsque  l’on  travaille  avec  les  regex  afin  d’éviter  toute  capture  inattendue.  Pour 
illustrer ces propos, observons les exemples ci­dessous : 

PS > ’### date: 17/01/2018 ###’ -match ’Date:\s\d{2}/\d{2}/\d{4}’

True

PS > ’### date: 17/01/2018 ###’ -match ’ˆDate:\s\d{2}/\d{2}/\d{4}$’

False

Intéressons­nous  maintenant  à  la  capture  en  observons  le  contenu  de  $Matches  (qui  a  eu  lieu  uniquement 
lorsque la comparaison retourne la valeur True) : 

PS > $matches

Name Value
---- -----
0 date: 17/01/2018

Il  faut  remarquer  que  $Matches[0]  contient  seulement  la  valeur  qui  a  correspondu  à  l’expression  régulière  (et 
non pas toute la chaîne qui contient la valeur). $Matches est en réalité un tableau associatif. Il contient toutes les 
captures  réalisées  par  l’expression  régulière.  Il  est  à  noter  que  nous  pouvons  capturer  plusieurs  sous­
expressions grâce aux parenthèses. 

Exemples de captures 

# Capture simple

PS > ’Date: 17/01/2018’ -match ’ˆDate:\s(\d{2}/\d{2}/\d{4})$’

True

PS > $matches

Name Value
---- -----
1 17/01/2018
0 Date: 17/01/2018

# Capture multiple
PS > ’Date: 17/01/2018’ -match ’ˆDate:\s((\d{2})/(\d{2})/(\d{4}))$’
True

PS > $matches

Name Value
---- -----
4 2018
3 01
2 17
 1 17/01/2018
0 Date: 17/01/2018

Puissant n’est­ce pas ? Ainsi, si seule l’année de la date nous intéresse il suffit de récupérer la valeur contenue dans 
$Matches[4]. 

Nous pouvons encore aller un peu plus loin en nommant chaque capture. Cette fois la regex risque de devenir un 
peu moins lisible et sembler bien spéciale à des yeux non initiés : 

PS > ’Date: 17/01/2018’ -match

’ˆDate:\s(?<date>(?<jour>\d{2})/(?<mois>\d{2})/(?<annee>\d{4}))$’
True

PS > $matches

Name Value
---- -----
date 17/01/2018
mois 01
jour 17
annee 2018
0 Date: 17/01/2018

Chaque groupe possède à présent un nom. Ainsi nous pouvons accéder à la valeur de chaque capture de la façon 
suivante : $Matches.<nom de capture>, comme par exemple $Matches.annee. 

2. Opérations sur les tableaux

Lorsque  l’on  applique  une  expression  régulière  sur  un  tableau,  cette  fois  pas  de  booléen en  retour  ni  de  valeur 
contenue  dans  $Matches.  Seules  les  chaînes  répondant  à  la  regex  sont  retournées.  Si  aucune  chaîne  ne 
correspond à la regex alors rien n’est retourné. 

Exemple 

PS > ’boolean’,’bol’,’bouche’,’baobab’,’boule’ -match ’ˆb[ou]{2,}\w+$’

boolean
bouche
boule

PS > ’boolean’,’bol’,’bouche’,’baobab’,’boule’ -match ’ˆc[ou]{2,}\w+$’

Dans l’exemple ci­dessus, la regex correspond à une chaîne qui : 

l Commence par la lettre b ou B. 

l Suivie de deux fois ou plus de l’un des caractères o ou u. 

l Suivie de n’importe quel caractère ou plus. 

l Se terminant par un caractère (mais non un nombre ou un espace). 
Les  opérateurs  de  comparaison  d’expressions  régulières  peuvent,  comme  les  opérateurs  de  comparaison,  être 
sensibles à la casse. Pour ce faire, faites précéder le nom de l’opérateur de la lettre c. 
Opérateur de plage
L’opérateur  de  plage  se  note  ..  (prononcez  « point  point »).  Il  permet,  comme  son  nom  l’indique,  de  couvrir  une 
plage de valeurs. Admettons que nous souhaitions couvrir une plage de valeurs allant de 1 à 10 (pour réaliser une 
boucle par exemple), eh bien il suffit de taper la ligne qui suit : 

PS > 1..10
1
2
3
..
10

On peut, de la même manière, définir une plage dynamiquement en utilisant des variables. Rien ne vous empêche de 
définir une plage allant de $var1 à $var2 si ces valeurs sont des entiers. 

Exemple 

PS > $var1 = 5
PS > $var2 = 10
PS > $var1 .. $var2
5
6
7
8
9
10
Opérateurs d’appartenance

En PowerShell, on parle souvent de collection d’objets ou de tableau d’objets. L’opérateur d’appartenance, introduit 
depuis PowerShell 3.0, permet de savoir si oui ou non un objet est présent dans une collection. 

Opérateur  Signification 

-in  Teste si une valeur est dans une collection. 

-notIn  Teste si une valeur n’est pas dans une collection. 

Pour mieux comprendre l’utilisation de ces opérateurs, voici quelques exemples d’applications : 

PS > ’shell’ -in ’Console’, ’shell’

True

PS > ’shell’ -in ’Console’, ’powershell’

False

PS > 85 -in 1..99

True

L’opérateur  jumeau  de  -in  est  l’opérateur  -contains.  En  effet,  il  fonctionne  comme  -in  mais  de  façon  inverse. 
Libre à vous de choisir celui qui correspond le mieux à la logique de votre script. 

Opérateur  Signification 

-contains  Teste si une collection contient une valeur particulière. 

-notContains  Teste si une collection ne contient pas une valeur particulière.  

Pour mieux comprendre l’utilisation de ces opérateurs, voici quelques exemples d’applications : 

PS > ’Console’, ’shell’ -contains ’shell’

True

PS > ’Console’, ’powershell’ -contains ’shell’

False

PS > 1..99 -contains 85

True
Opérateur de remplacement
L’opérateur de remplacement  -replace est un opérateur extrêmement puissant. Il aurait probablement mérité de 
s’appeler -searchAndReplace tellement il est efficace, mais probablement que son nom aurait été jugé trop long. 

Dans  sa  forme  la  plus  simple  -replace  peut  s’appliquer  sur  une  chaîne  simple  (scalaire), comme  dans  l’exemple 
suivant : 

PS > ’PowerShell’ -replace ’Shell’, ’Guy’

PowerGuy

Shell représente la chaîne à rechercher, et Guy la chaîne de remplacement. 

Bien que cela fonctionne parfaitement, ce cas d’usage n’offre pas plus de fonctionnalité que la méthode Replace() 
appliquée à une chaîne, tel que ci­dessous : 

PS > $MaChaine = ’PowerShell’

PS > $MaChaine.Replace(’Shell’,’Guy’)
PowerGuy

Le gros intérêt de cet opérateur c’est qu’il peut s’appliquer à un tableau afin de chercher et remplacer une valeur par 
une  autre.  Mieux  encore,  -replace  accepte  en  entrée  une  expression  régulière,  ce  qui  permet  des  recherches 
complexes et bien plus encore… 

1. Remplacements à l’aide d’une expression régulière

Même  si  on  utilise  une  chaîne  de  caractères  simple  pour  effectuer  une  recherche,  l’opérateur  -replace  la 
considère comme une expression régulière. 

Dans l’exemple ci­dessous, nous créons une expression régulière qui correspond à une date quelconque au format 
JJ/MM/AAAA que nous remplaçons par la chaîne Samedi : 

PS > ’Il a plu le 12/01/2018...’ -replace ’\d{2}\/\d{2}\/\d{4}’,

’Samedi’
Il a plu le Samedi...

Lorsque l’on utilise une regex avec l’opérateur  -replace, la première chaîne capturée se trouve stockée dans la 
variable $1, la seconde dans  $2, la troisième dans $3, etc. Ainsi nous pouvons réutiliser ces variables pour produire 
un résultat complètement différent de la chaîne d’origine, comme ci­dessous : 

PS > $str = "PowerShell c’est dépassé, VBScript c’est mieux !"

PS > $regex = "(PowerShell)( c\’est dépassé, )(VBScript)( c\’est mieux !)"
PS > $str -replace $regex, ’** $3$2$1$4 **’
** VBScript c’est dépassé, PowerShell c’est mieux ! **

Notez que les parenthèses sont utilisées dans les regex pour indiquer une capture et que les antislashs permettent 
« d’échapper » un caractère. 
2. Remplacements appliqués sur un tableau

C’est maintenant que les choses sérieuses commencent car  -replace est d’une redoutable efficacité lorsqu’il est 

appliqué  à  un  tableau.  Il  va  nous  éviter  d’avoir  à  parcourir chacun  des  éléments  pour  effectuer  un  remplacement. 
Dans  certains  cas,  il  nous  évitera  également  d’avoir  à  écrire  un  algorithme  pour  remplacer  certaines  chaînes  bien 
précises. 

Définissons le tableau suivant contenant les jours de la semaine : 

PS > $tbJours = "Lundi Mardi", "Mercredi Jeudi", "Samedi Dimanche"

Remplaçons à présent la chaîne di par do de tout le tableau : 

PS > $tbJours -replace ’di’, ’do’

Lundo Mardo
Mercredo Jeudo
Samedo domanche

Parfait ! Enfin presque car le remplacement s’est aussi appliqué à Dimanche qui est devenu Domanche. À présent, 

nous décidons de n’appliquer le remplacement qu’au premier mot de chaque élément du tableau. 

Pour ce faire, nul besoin d’algorithme, une petite regex va nous tirer d’affaire, comme ci­dessous : 

PS > $tbJours -replace ’ˆ(\w*)di’, ’$1do’

Lundo Mardi
Mercredo Jeudi
Samedo Dimanche

Que s’est­il passé ? Eh bien tout simplement la regex a capturé chaque début de chaîne (grâce à ˆ) et ce jusqu’à di 
(soit  Lun,   Mer et  Sam)  et  l’a  stocké  dans  $1.  Ensuite avec  $1do nous  effectuons  une  petite  concaténation. 
L’opération  de  remplacement  s’est  donc  uniquement  limitée  à  l’expression  régulière  sans  toucher  au  reste  de  la 
chaîne. 

Afin  de  mettre  au  point  la  regex,  n’oubliez  pas  d’utiliser l’opérateur  -match  qui  vous  retournera  vrai  ou  faux  en 
fonction du résultat. N’oubliez pas non plus de l’appliquer à une chaîne simple. Comme par exemple : 

PS > $tbJours[0] -match ’ˆ(\w*)di’

True

PS > $matches

Name Value
---- -----
1 Lun
0 Lundi
L’opérateur  de  remplacement  peut  (comme  les  opérateurs  de  comparaison)  ou  non  être  sensible  à  la  casse.  Pour 
qu’il respecte la casse, faites précéder son nom de la lettre c. Ainsi -replace devient -creplace. 
Opérateurs de type

Jusqu’à  présent,  nous  vous  avons  montré  comment  typer  votre  valeur  et  même  comment récupérer  le  type  avec  la 
méthode GetType. Mais ce que nous allons désormais découvrir est comment tester le type d’une variable.  

Ces opérateurs sont relativement peu utilisés dans la mesure où lorsque nous définissons des paramètres (dans les 
scripts ou les fonctions), nous leur donnons un type. Il n’est donc pas vraiment utile de tester leur type… Ceci étant, 
comme ces opérateurs existent, il nous semblait utile de vous en parler. 

Opérateur  Signification 

-is  Test si l’objet est du même type. 

-isNot  Test si l’objet n’est pas du même type. 

Pour illustrer l’utilisation de ces opérateurs, voici quelques exemples d’applications : 

PS > ’Bonjour’ -is [string]

True

PS > 20 -is [int]

True

PS > ’B’ -is [int]

False
Opérateurs logiques

Les  opérateurs  logiques  permettent  de  vérifier  jusqu’à  plusieurs  comparaisons  dans  une  même  expression.  Par 
exemple :  ($var1 -eq $var2) -and ($var3 -eq $var4) renverra le booléen  true  si  $var1 est égal à 
$var2  et  que  $var3  est  égal  à  $var4,  dans  le  cas  contraire  la  valeur  false  sera  renvoyée.  Voici  la  liste  des 
opérateurs logiques disponibles : 

Opérateur  Signification 

-and  ET logique 

-or  OU logique 

-not  NON logique 

!  NON logique 

-xor  OU exclusif 

Pour mieux comprendre l’utilisation de ces opérateurs, voici quelques exemples d’applications : 

PS > (5 -eq 5) -and (8 -eq 9)

False

Faux, car 5 est bien égal à 5, mais 8 n’est pas égal à 9. 

PS > (5 -eq 5) -or (8 -eq 9)

True

Vrai, car l’une des deux expressions est vraie, 5 est bien égal à 5. 

PS > -not (8 -eq 9)

True

PS > !(8 -eq 9)

True

Vrai, car 8 n’est pas égal à 9. 
Opérateurs binaires

Les opérateurs binaires sont utilisés pour effectuer des opérations entre nombres binaires. Pour rappel, le système 
binaire  est  un  système  en  base  2,  contrairement  au  système  décimal  qui  lui  est  en  base  10.  C’est­à­dire  que  la 
notation ne comporte que des 0 et des 1. 

Exemple de conversion de nombres décimaux en base binaire 

Décimal Binaire
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101

Lorsque nous faisons appel à l’un des opérateurs binaires suivants, les bits des valeurs sont comparés les uns après 
les autres, puis selon que nous appliquons un ET ou un OU nous obtenons un résultat différent. 

Opérateur  Signification 

-band  Opérateur ET 

-bor  Opérateur OU 

-bnot  Opérateur NON 

-bxor  Opérateur OU exclusif 

-shr  Décalage des bits vers la droite

-shl  Décalage des bits vers la gauche

Le résultat retourné après une comparaison binaire est automatiquement converti en système décimal et non pas en 
système binaire. 

Imaginons  que  pour  une  application  quelconque  nous  souhaitions  savoir  si  le  bit  de  poids  faible  d’une  variable  est 
égal à 1. Prenons pour exemple la valeur décimale 13, soit 1101 en binaire. Alors évidemment on voit clairement que 
le bit de poids faible est bien à  1, mais pour vérifier cette affirmation via PowerShell, utilisons plutôt notre opérateur 
binaire -band. 

En utilisant cet opérateur, nous réalisons en fait ce que l’on appelle un masque sur le bit de poids faible. Si le résultat 
est  conforme  au  masque  appliqué  alors  le  bit  de  poids  faible  est  bien  à  la  valeur  1.  Voici  ce  que  donnerait 
graphiquement la comparaison : 
Résultat 

PS > $var = 13
PS > $var -band 1
1
Opérateurs d’affectation

Vous savez donc maintenant comment affecter une valeur à une variable et réaliser une opération sur cette dernière. 
Maintenant nous allons vous montrer comment faire les deux en même temps en une seule opération. 

Les opérations qui sont décrites dans ce tableau donnent strictement le même résultat.  

Notation classique  Notation raccourcie 

$i=$i+8  $i+=8 
$i=$i-8  $i-=8 
$i=$i*8  $i*=8 
$i=$i/8  $i/=8 
$i=$i%8  $i%=8 
$i=$i+1  $i++ 
$i=$i-1  $i-- 

La  notation $i++  ou $i-- est très utilisée dans les conditions de boucle de façon à incrémenter $i  de 1 à chaque 

passage. 

Ainsi, par exemple, voici comment ajouter une valeur avec l’opérateur d’affectation +=. 

PS > $i = 0
PS > $i += 15
PS > $i
15

Si on affiche la valeur de la variable $i, on obtient bien 15, car cette instruction est équivalente à : $i = $i + 15. 

Poursuivons avec cette fois le calcul des factoriels des chiffres allant de 1 à 10. 

Pour cela, nous créons une boucle et, pour chaque valeur de $i, nous la multiplions par la valeur de  $var avant de 
la lui réaffecter : 

PS > $var = 1
PS > foreach($i in 1..10){$var *= $i ; $var}
1
2
6
24
120
720
5040
40320
362880
3628800
 Comme  nous  n’avons  pas  encore  abordé  la  notion  de  boucle  foreach,  n’y  prêtez  pas  trop  attention  dans  cet 
exemple. L’essentiel est que ayez compris qu’il  s’agit d’une boucle, allant de  1 à 10, dans laquelle pour chaque valeur 
de i, on multiplie la valeur de $i par la valeur de $var et on stocke le tout dans $var. 
Opérateurs de redirection

Il faut savoir que les interpréteurs de commandes traitent les informations selon une entrée, une sortie et une erreur 
standard, chaque élément étant identifié par un descripteur de fichier. 

Descripteur  Identification  Explication 

0  Standard Input  Flux  d’entrée  par  lequel  les  données  sont  entrées  dans  le 
shell.  Par  défaut,  le  clavier  est  utilisé  comme  entrée 
standard. 

1  Standard Output  Flux  de  sortie  par  défaut  par  lesquelles  les  données  sont 
émises.  Le  flux  standard  est  utilisé  par  la  plupart  des 
commandes qui affichent un résultat à l’écran. 

2  Error  Flux  de  sortie  permettant  au  shell  d’émettre  les  messages 
d’erreur. La visibilité de ces derniers est gérée via la variable 
$ErrorActionPreference. 
3  Warning  Flux  de  sortie  permettant  au  shell  d’émettre  les  messages 
d’avertissement.  Ces  derniers  ne  sont  visibles  que  si  la 
variable  $WarningPreference  est  positionnée  à  la 
valeur  Continue. 

4  Verbose  Flux  de  sortie  des  messages  verbeux.  Ces  messages  sont 
visibles  lorsque  le  mode verbose  est  activé  via  la 
variable  $VerbosePreference. 

5  Debug  Flux  de  sortie  des  messages  de  débogage.  Ces  messages 
sont  visibles  lorsque  le  mode debug  est  activé  via  la 
variable  $DebugPreference. 

6  Information  Flux  de  sortie  des  messages  d’information.  Ces  derniers  ne 
sont  visibles  que  si  la  variable 
$InformationPreference  est  positionnée  à  la 
valeur  Continue. 

*  Tous les flux  Le caractère étoile représente tous les flux. 

Les flux *, 3, 4 et 5 et leurs variables de préférence associées ont été introduits dans la version 3 de PowerShell. 

Le flux 6 (information) a été introduit dans la version 5. 

Par  défaut,  c’est  la  console  qui  est  la  sortie  standard  de  tous  les  flux  énumérés  précédemment.  Mais  de  façon  à 
pouvoir les rediriger avec souplesse, PowerShell dispose d’une batterie d’opérateurs. Ces derniers sont identiques à 
ceux utilisés dans le shell Unix : 

Opérateur  Signification 

x> y  Redirige le flux  x  vers  le  fichier  y.  Si  le  fichier  y  existe  déjà,  le  contenu  du  fichier  est 
remplacé.  Exemple  2> error.log  redirige  l’erreur  standard  vers  le  fichier 
error.log. 
x>> y  Redirige le flux  x  vers  le  fichier  y en mode ajout. Si le fichier  y existe déjà, le flux est 
alors ajouté à la fin du fichier. 

x>&1  Redirige  le  flux  x  vers  la  sortie  standard.  Exemple :  2>&1  redirige  les  messages 
d’erreurs vers la sortie standard. 

x>&1 > y  Redirige le flux  x  vers  la  sortie  standard,  puis  redirige  la  sortie  standard  vers  le  fichier 
y 
 ATTENTION :  lorsque  vous  travaillez  avec  les  opérateurs  de  redirection  de  flux,  ne  pas  mettre  d’espace  entre  le 
numéro de flux et l’opérateur >&1 sous peine de générer une erreur. 

Supposons que nous souhaitions envoyer le résultat d’une commande dans un fichier texte plutôt qu’à l’intérieur de la 
console, pour cela utilisons l’opérateur > : 

PS > Get-Process > C:\Temp\process.txt

Nous  obtenons  un  fichier  texte  dans  C:\Temp  du  nom  de  process.txt  contenant  tous  les  processus  en  cours 
d’exécution. 

PS > Get-Content C:\Temp\process.txt

Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName

------- ----- ----- ----- ----- ------ -- -----------
66 4 1768 3520 57 0,14 4200 acrotray
62 2 940 2924 31 1424 audiodg
297 76 4832 452 72 0,70 2096 ccApp
851 14 13008 7532 105 548 CcmExec
497 11 9528 5320 87 1800 ccSvcHst
34 2 796 3464 36 0,05 5152 conime
582 5 1712 3124 87 768 csrss
301 10 2732 12728 135 4784 csrss
202 6 2256 5720 70 540 DefWatch
82 3 1388 4436 45 0,09 2636 dwm
678 27 27960 41488 189 20,42 368 explorer
0 0 0 16 0 0 Idle

Maintenant,  si  nous  écrivons  de  nouveau  une  commande  dont  la  sortie  serait  dirigée  dans  le  même  fichier  via 
l’opérateur  >, les données seront écrasées. Le contenu du fichier est effacé et remplacé par la nouvelle sortie. Pour 
éviter cela, il faut utiliser l’opérateur  >> qui indique à PowerShell d’ajouter la sortie de la commande à la fin du fichier 
spécifié. 

Pour  rediriger  un  flux  vers  un  fichier,  vous  pouvez  aussi  utiliser  la  commandelette  Out-File  à  la 
place  des  opérateurs  de  redirection,  notamment  si  vous  souhaitez  utiliser  des  paramètres  tels  que 
l’encodage, le nombre de caractères dans chaque ligne de sortie, etc.  

Dernier exemple, la redirection du flux d’erreur standard vers un fichier. Pour cela utilisons simplement une commande 
susceptible de retourner un message d’erreur, tel que demander les fichiers et les dossiers d’un répertoire inexistant. 
Puis envoyons le tout dans un fichier via l’opérateur 2>. 

PS > Get-ChildItem C:\Temp\RepInexistant 2> .\err.txt

Aucun message n’est affiché dans la console. Mais en récupérant le contenu du fichier  err.txt,  on  s’aperçoit qu’il 

contient bien le message d’erreur relatif à la commande saisie. 

PS > Get-Content .\err.txt

Get-ChildItem : Cannot find path ’C:\Temp\RepInexistant’ because it
 does not exist...

Redirection appliquée à une fonction 

Il est possible d’utiliser la redirection des flux sur des fonctions. Prenons par exemple la fonction définie ci­après : 

function maFonction
{
[CmdletBinding()]
Param ()

Write-Information "Ceci est un message d’information"

Write-Verbose "Ceci est un message verbeux"
}

Grâce aux instructions  [CmdletBinding()] et  Param(), nous activons les paramètres communs sur la fonction 

maFonction.  Les  paramètres  communs  qui  vont  nous  intéresser  spécifiquement  ici  sont  -verbose  et  -
InformationAction.  Ils  seront  plus  pratiques  à  manipuler  que  les  variables  $VerbosePreference  et 
$InformationPreference. 

# Activation des commandes Write-Information et Write-Verbose

PS > maFonction -Verbose -InformationAction Continue
Ceci est un message d’information
VERBOSE: Ceci est un message verbeux

# Redirection de tous les flux vers un fichier texte

PS > maFonction -Verbose -InformationAction Continue *> C:\temp\log.txt

# Redirection du flux verbose uniquement vers un fichier texte

PS > maFonction -Verbose -InformationAction Continue 4> C:\temp\log.txt
Ceci est un message d’information

Lors du premier appel de la fonction, les messages d’information et verbeux s’affichent normalement dans la console. 

Lors du second appel, rien ne s’affiche dans la console et un fichier log.txt est créé. Ce dernier contient les messages 
verbeux et d’information. 

Enfin, lors du troisième appel de la fonction, le fichier texte contient uniquement le message verbeux (flux 4) car seul 
celui­ci est redirigé. Le message d’information s’affiche quant à lui logiquement dans la console. 
Opérateurs de fractionnement et de concaténation

Les opérateurs de fractionnement et de concaténation permettent de combiner ou bien de fractionner à volonté des 
chaînes de caractères. 

Opérateur  Signification 

-split  Fractionne une chaîne en sous­chaînes. 

-join  Concatène plusieurs chaînes en une seule. 

Ainsi, par exemple, voici comment fractionner une chaîne en plaçant l’opérateur -split en début de ligne. 

PS > -split ’PowerShell c’est facile’

PowerShell
c’est
facile

Par  défaut,  le  fractionnement  est  réalisé  avec  le  délimiteur  espace  « ».  Pour  changer  de  délimiteur,  il  convient  de 
placer l’opérateur en fin de ligne et de le faire suivre du caractère souhaité. 

Exemple 

PS > ’Nom:Prénom:Adresse:Date’ -split ’:’

Nom
Prénom
Adresse
Date

Le délimiteur peut être : un caractère unique, une chaîne de caractères, une expression régulière ou un bloc de script 
(scriptblock).  

Pour plus de détails, il existe la rubrique d’aide about_Split qui est très complète. 

L’opérateur -join permet de réaliser la concaténation de différentes chaînes de caractères d’un même tableau. 

Exemple 

PS > $tableau = ’Lundi’, ’Mardi’, ’Mercredi’, ’jeudi’, ’Vendredi’,

’Samedi’, ’Dimanche’

PS > -join $tableau

LundiMardiMercredijeudiVendrediSamediDimanche

PS > $tableau -join ’, puis ’

Lundi, puis Mardi, puis Mercredi, puis jeudi, puis Vendredi,
puis Samedi, puis Dimanche

Pour plus de détails, nous vous invitons à consulter la rubrique d’aide about_Join. 
Opérateur de format ­f

1. Notions de base

L’opérateur de format  -f permet de formater des chaînes de caractères façon .NET, c’est­à­dire exactement de la 
même manière que nous pourrions le faire en VB.NET ou C#. 

Le principe de base est très simple ; en effet, il va s’agir de réserver un ou plusieurs emplacements prédéfinis dans 
une chaîne de caractères et de substituer ces derniers par une valeur (ou expression). Il suffit alors de placer un ou 
plusieurs  nombres  entre  accolades (commençant  par  zéro)  dans  une  chaîne,  et  automatiquement  ces  derniers 
seront substitués par une valeur au moment de l’exécution. 

Exemple 1 : 

PS > $str = ’powershell’

PS > ’{0} est un puissant langage de scripts.’ -f $str.ToUpper()
POWERSHELL est un puissant langage de scripts.

Il  existe  bien  entendu  d’autres  façons  de  concaténer  des  chaînes  de  caractères,  néanmoins nous  affectionnons 
particulièrement  l’opérateur  -f  car  il  apporte  une  certaine  facilité  d’écriture  et  une  aisance  accrue  pour  la 
compréhension  du  code.  Cela  est  d’autant  plus  vrai  lorsque  l’on  a  de  nombreuses  données  à  concaténer,  à 
présenter à l’écran ou à mettre en forme dans un fichier texte. 

Exemple 2 : 

PS > $str1 = ’powershell’

PS > $str2 = ’{0}, un concentré de puissance en seulement {1}
caractères !’
PS > $str2 -f $str1.ToUpper(), $str1.length
POWERSHELL, un concentré de puissance en seulement 10 caractères !

Nous  pouvons  ainsi,  en  utilisant  {0}, {1},  …,  {n},  réserver  autant  d’espace  que  nécessaire pour  créer  une 
chaîne.  En  contrepartie,  il  faut  bien  évidemment  indiquer  après  l’opérateur -f  autant  d’expressions  que 
d’emplacements réservés, le tout séparé par une virgule. 

Exemple 3 : 

PS > $tb = ’Charb’, ’Cabu’, ’Wolinski’, ’Tignous’

PS > $journal = ’Charlie Hebdo’
PS > $str = ’{0}, {1}, {3}, et {2}, tous les {4} étaient les dessinateurs
de {5}.’
PS > $str -f $tb[0],$tb[1],$tb[2],$tb[3],$tb.length,$journal

Charb, Cabu, Tignous, et Wolinski, tous les 4 étaient les dessinateurs

de Charlie Hebdo.

2. Aller plus loin avec les formateurs de chaîne
Ce que nous venons de voir est le fonctionnement « basique » de l’opérateur de formatage. Il est possible d’en tirer 
beaucoup  plus  parti  en  association  avec  un  formateur  de  chaîne  (FormatString)  ainsi  qu’avec  une  valeur 
d’alignement. 

Voici la syntaxe complète d’un emplacement réservé :  

{<Index><,Alignement><:FS>}

Index = numéro d’ordre. On commence toujours à l’index 0. 

FS = formateur de chaîne. 

Une  valeur  d’alignement  positive  aligne  de  n  caractères  vers  la  droite,  alors  qu’une  valeur  négative  aligne  de  n 
caractères vers la gauche. Notez qu’une valeur d’alignement est facultative. 

Si aucun formateur de chaîne n’est spécifié, c’est le spécificateur de format général (« G ») pour un type numérique, 
de date et d’heure ou d’énumération qui est utilisé. 

Exemple d’alignements : 

PS > "{0,-25}{1,-25}`n{3,-25}{2,-25}" -f $tb[0],$tb[1],$tb[2],$tb[3]

Charb Cabu
Tignous Wolinski

PS > "{0,25}{1,25}`n{3,25}{2,25}" -f $tb[0],$tb[1],$tb[2],$tb[3]

Charb Cabu
Tignous Wolinski

L’utilisation d’une valeur d’alignement ajoute des blancs dans la chaîne résultante. 

Il  y  a  un  très  grand  nombre  de  formateurs  de  chaîne  regroupés  par  thème ;  en  effet  il  en  existe  pour  la  mise  en 
forme  de  nombres  (entiers,  décimaux,  hexadécimaux,  pourcentages,  etc.),  de  chaînes  de  caractères,  de  dates  et 
d’heures, etc. 

Nous ne les énumérerons pas ici car ils sont trop nombreux, mais vous pouvez les retrouver aisément sur MSDN en 
effectuant une recherche sur les termes « mise en forme composite ». 

Exemple de formatage de date : 

PS > "Nous sommes le {0:dd/MM/yyyy}." -f (Get-Date)

Nous sommes le 18/01/2018.

Exemple de formatage de monnaie : 

PS > ’Le prix de la place de cinéma est de {0:c}.’ -f 11.20

Le prix de la place de cinéma est de 11,20 €.
Dans l’exemple ci­après, nous demandons explicitement que le prix retourné le soit sur une seule décimale c1 : 

PS > ’Le prix de la place de cinéma est de {0:c1}.’ -f 11.20

Le prix de la place de cinéma est de 11,2 €.
Récapitulatif sur les opérateurs

Dans cette liste vous retrouverez tous les opérateurs énoncés au cours de ce chapitre : 

Opérateur  Signification 

-eq  Égal. 

-lt  Inférieur à. 

-gt  Supérieur à. 

-le  Inférieur ou égal à. 

-ge  Supérieur ou égal à. 

-ne  Différent de. 

-not  Non logique. 

!  Non logique. 

-match  Comparaison d’égalité entre une expression et une expression régulière. 

-notMatch  Comparaison d’inégalité entre une expression et une expression régulière. 

-like  Comparaison d’égalité d’expression générique. 

-notLike  Comparaison d’inégalité d’expression générique. 

-replace  Opérateur de remplacement. 

-and  ET logique. 

-or  OU logique. 

-bor  Opérateur de bits OU. 

-band  Opérateur de bits ET. 

-bxor  Opérateur de bits OU exclusif. 

-shr  Décalage des bits vers la droite. 

-shl  Décalage des bits vers la gauche. 

-xor  OU exclusif. 

-is  Opérateur d’égalité de type. 

-isNot  Opérateur d’inégalité de type. 

-in  Teste si une valeur est dans une collection. 

-notIn  Teste si une valeur n’est pas dans une collection. 

-contains  Teste si une collection contient une valeur. 

-notContains  Teste si une collection ne contient pas une valeur. 

-ceq  Égal (respecte la casse). 

-clt  Inférieur à (respecte la casse). 

-cgt  Supérieur à (respecte la casse). 

-cle  Inférieur ou égal à (respecte la casse). 

-cge  Supérieur ou égal à (respecte la casse). 

-cne  Différent de (respecte la casse). 

-cmatch  Comparaison  d’égalité  entre  une  expression  et  une  expression  régulière  (respecte  la 
casse). 

-cnotmatch  Comparaison d’inégalité  entre  une  expression  et  une  expression  régulière  (respecte  la 
 casse). 

-clike  Comparaison d’égalité d’expression générique (respecte la casse). 

-cnotlike  Comparaison d’inégalité d’expression générique (respecte la casse). 

-creplace  Opérateur de remplacement (respecte la casse). 

x > y  Redirige  le  flux  x  vers  un  fichier,  si  le  fichier  y  est  déjà  créé,  le  contenu  du  fichier 
précédent est remplacé. 

x >> y  Redirige le flux x  vers  un  fichier,  si  le  fichier  y  est  déjà  créé,  le  flux  est  ajouté  à  la  fin 
du fichier. 

x>&1  Redirige le flux  x vers la sortie standard. 

-split  Fractionne une chaîne en sous­chaînes. 

-csplit  Fractionne une chaîne en sous­chaînes (respecte la casse). 

-join  Concatène plusieurs chaînes en une seule. 

-f  Opérateur de formatage de chaînes façon C# ou VB.NET.