Le tube (| pipe, barre verticale) sert à rediriger la sortie standard d'une commande (l'affichage) vers l'entrée standard de la commande suivante (les paramètres).

Le point virgule (;) sert à écrire plusieurs commandes indépendantes sur une même ligne.

Visuellement, ces deux symboles peuvent se confondre. c'est pourquoi, on n'utilise le ; que dans des cas rares ou pour brouiller volontairement le code.

Exemples d'utilisation :

# ===========================================
# exemple pour le tube : 
ls monRep | Write-output
rmDir -Recurse monRep | Wrtie-output >> log.txt
 
# exemple pour le point-virgule : 
$messageCompte=" Entrez le nom du nouveau compte" : $messagePwd="Mot de passe ?"
$nom= Read-Host $message ; new-ADuser -Name $nom -AccountPassword (Read-Host -AsSecureString $messagePwd)
# ===========================================

Redirection :

La redirection est identique au DOS :

# ===========================================
dir >  lst.txt # > Vide ou crée le fichier lst.txt et y ajoute la sortie de dir.
dir >> lst.txt # >> Ajoute la sortie de dir à la suite du contenu du fichier lst.txt.
# ===========================================

Tester une commande - $?

Si une commande s'est bien/mal déroulée, on effectue un traitement ou pas.

Si la cde1 s'est bien déroulée alors cde2 s'exécute (cde1 et cde2)

# ===========================================
cde1
if ($?) {cde2 }
# ===========================================

Exemple :

Si cde1 est en erreur alors cde2 s'exécute (cde1 ou cde2)

# ===========================================
Cde1
if (-not $?) {cde2}
# ===========================================

Alias : where, ?

Exemple : Lister les fichiers dont la taille est supérieure à 100Mo

1. Combien d'octets dans un Mo ? (1Mo=1024Ko=1024*1024o = 1 048 576o)
2. La commande à lancer :

   Get-ChildItem | Where-Object {$_.Length -gt 104857600}

Les principaux opérateurs de test disponibles

Les opérateurs de test permettent de faire des comparaisons entre deux opérandes. Certaines commandes produisent aussi des résultats booléens (vrai/faux).

Les opérateurs booléens permettent d'associer deux comparaisons pour en faire une condition plus complexe. Le résultats est toujours booléen (vrai/faux).

Les connecteurs de comparaisons entre elles (voir aussi les tables de vérité)

Ajouter un c devant la commande pour la rendre sensible à la casse des chaînes ("toto" -ceq "Toto"  ==> false)

Il existe aussi des commandes dont le résultat est booléen (vrai ou faux)

Exemple (trrrès utile) :

Test-Path C:\Scripts\Archive est vrai si l'objet Archive existe

Rédiger le code nécessaire pour copier de c:\temp\ vers c:\sav\

A) les .txt de temp qui commencent par aa ou bb

#--- Indices ---
	Get-ChildItem c:\temp\
	 | Where-object ... 
	 | copy ...
#----------------

B) les .txt de temp qui existent déjà dans sav

Utiliser la commande : Split-path -Path "c:\sav\*.txt" -Leaf -Resolv pour récupérer la liste des noms seuls des fichiers de -Path.

Get-ChildItem récupère des objets fichier d'où il faut extraire le seul nom du fichier. C'est un poil plus compliqué.

#--- Indices ---
	Split-Path -Path " ... " -Leaf -Resolve
	 | foreach { ... }
#----------------

#----------------
$k0 = 0 
$k1 = 1 
for ($i=0;$i<10;$i++){ 		# début du bloc
    write-host "À l'indice $i, k est égal à $k."
    $k0=$k0+$k1
}   							# fin du bloc
 
if ($k0 -gt 100)
    write-host "résultat très grand"
 
#----------------

Un bloc d'instructions est un ensemble d'instructions entourées d'accolades.

Un bloc d'instructions sert à présenter un traitement complexe dans les structures. Le mot clé DO permet de construire des blocs indépendants.

C'est très utilisé dans les alternatives et les boucles, les fonctions.

Mots clés : DO, {...}.

Exemple :

#----------------
DO {
	plusieurs instructions et commandes
}
 
# ou simplement
{
	plusieurs instructions et commandes
}
 
#----------------

Une alternative est une instruction qui permet de choisir entre deux traitements selon le résultat d'une condition

Une alternative peut contenir un ou plusieurs traitements : si (condition1) alors TTmt1, sinon-si (condition2) alors ttmt2, ..., sinon ttmtn, fin si.

Mots clés : IF, ELSE, ELSEIF, utilise les blocs {...}.

Exemple :

#----------------
$r = Read-Host 
if ($r -eq "10"){
        "Le nombre est 10." 
} elseif ($r -eq "5"){
        "Le nombre est 5." 
} else {
        "Le nombre n'est ni 5 ni 10." 
}
#----------------

POUR a=départ, Tant que a

Une boucle de comptage effectue un nombre défini d'itérations entre deux bornes selon un pas imposé.

On détermine une borne de départ qui initialise un indice, une borne de fin à laquelle est comparée l'indice et un calcul qui défini le pas, le saut entre deux itérations de la boucle.

Mots clés : FOR, utilise des blocs {...} et souvent un opérateur d'incrémentation : ++ ou --.

Exemple :

#----------------
# Afficher les nombres de 1 à 7
for ( $i=1 ; $i -le 7 ; $i++ ){ 
	"Le chiffre est $i"
} 
 
#----------------

POUR CHAQUE élément d'une liste, exécuter l'instruction ou le bloc d'instructions demandé.

Une boucle de parcours effectue autant d'itérations que d'éléments dans la liste.

Une variable prend successivement la valeur de chaque élément de la lliste.

Mots clés : FOREACH, utilise des blocs {...} et souvent un tube (|).

Exemple :

#----------------
# Afficher les nombres de 1 à 7
$valeurs = 1,2,3,4,5,6,7 			# soit le tableau initial de 7 valeurs
 
foreach($valeur in $valeurs){		# Pour Chaque valeur du tableau
        "Le chiffre est $valeur"	# exécuter le traitement avec la valeur courante
}									# fin Pour Chaque
 
#------------------------------------
# Écriture alternative avec un tube
(1..7) | foreach { "Le chiffre est $_"}
#----------------

Exemple : créer les répertoires des utilisateurs de la liste contenue dans un fichier.

#----------------
# récupérer la liste contenue dans le fichier
 $liste=get-content listeLogin.txt
 
# pour chaque utilisateur de la liste, créer son répertoire
Foreach($val in $liste) { mkdir /users/$_}
 
#------------------------------------
# Écriture alternative avec un tube
gc listeLogin.txt | foreach  { mkdir /users/$_}
 
#----------------

Il existe deux façons d'écrire cette boucle avec deux manières de penser différentes.

• While simple
  : Tant que je gagne, je joue.
• do ... while
  : Je joue, tant que je gagne.

Exemples : compter de 1 à 7 :

#----------------
# Tant que i est inférieur à 8, écrire i
 $i=1 
while (  $i -le 7  )
{
  Write-Host "Le chiffre est $i"
  $i++
}
 
#----------------

#----------------
# Tant que i est inférieur à 8, écrire i
 $i=1 
do 
{
  Write-Host "Le chiffre est $i"
  $i++
} while (  $i -lt 8  )
 
#----------------

Attention à toujours utiliser des comparateurs d'inégalité (-le, -ge, -lt, -gt) pour éviter tout risque de boucle infinie !!!

Un utilisateur doit deviner un entier aléatoire entre 0 et 9.

Algorithme global

• Choisir un entier aléatoire entre 0 et 9 avec la commande : get-random 10
• Demander un entier à l'utilisateur,
• Répondre "trop haut" ou "trop bas" si le nombre n'est pas trouvé et reposer la question
• Répondre "Gagné" et s'arrêter, si le nombre est trouvé.

Rédiger le code correspondant

Améliorations possibles

• [important] Tant que la réponse de l'utilisateur n'est pas un nombre, dans l'intervalle défini, reposer la question
• Si l'utilisateur répond "Q" ou "q", arrêter le programme
• proposer de définir l'intervalle ou/et les bornes
• Compter le nombre de tentatives
• Enregistrer le meilleur score dans un fichier
• Coloriser les réponses
• Refaire le même jeu avec les lettres de a à z ;)

Voici un t-bon aide mémoire : http://my-powershell.fr/aide-memoire-powershell