Powershell - Quelques bases

Installer Powershell :

Si vous êtes un utilisateur de Windows 7, vous possédez déjà la version 2.0 de PowerShell.

Si vous utilisez Windows 2008, vous pouvez installer PowerShell 1.0 à partir du CD d'installation de Windows 2008 ou télécharger la version 2.0 pour service pack 1 ou 2.

A noter que le Exchange Management Shell d'Exchange 2010 est installer en Powershell 2.0 !!

Avec Windows Server 2012, c'est la version Powershell 3.0 qui est installée. Il est possible d'installer cette version 3.0 sur  Windows 7 SP1, Windows Server 2008 R2 SP1 et Windows Server 2008 Service Pack 2. A noter que Powershell 3.0 :

• Est inclut dans Windows Management Framework 3.0
• Requière Framework.net 4.0 au préalable

• Windows 7 avec Service Pack 1
• Windows Server 2008 R2 avec Service Pack 1
• Windows Server 2012

Lancer Powershell :


Un prompt (invite de commande) vous est affiché. Cette invite est composée des lettres "PS", du chemin du répertoire courant (vous devriez avoir déjà constaté que ce n'est pas toujours un répertoire réel), puis du symbole ">". Vous pouvez y taper des commandes ( get-help, get-command et get-service, ...) et l'interface réagit en les exécutant et en vous affichant le résultat. Gardez en mémoire qu'en fait, le résultat de ces commandes n'est pas du texte, mais un objet contenant du texte, qui est formaté par défaut puis affiché. Il est possible de modifier ce formatage.

 
Les scripts :

Pour exécuter un script, il suffit d'en créer un dans un fichier texte et de changer son extension en .ps1. Vous pourrez ensuite l'exécuter dans PowerShell en l'appelant par son nom. Notez que vous disposez depuis PowerShell 2.0 de  PowerShell ISE (Integrated Scripting Environment) qui vous permet d'éditer un script et de le tester directement.

Il faut savoir deux choses importantes pour exécuter nos scripts:

PowerShell ne vérifie jamais dans le répertoire courant si un script est présent lorsque l'on tente de l'exécuter. Vous devrez donc toujours taper un chemin complet. Toutefois, les chemins relatifs sont permis alors on peut faire quelque chose comme: .\test.ps1
Par défaut, PowerShell ne permet pas l'exécution de scripts, par mesure de sécurité. Tout dépend de votre ExecutionPolicy 

Get-executionpolicy permet de vérifier votre policy active  ("Restricted" par défaut).

Set-executionpolicy suivi d'un paramètre permet de la modifier
Les choix possibles sont :

• "Restricted",
• "AllSigned",
• "RemoteSigned",
• "Unrestricted"

Attention : vous devrez démarrer PowerShell en tant qu'administrateur pour que set-executionpolicy puisse être exécuté

Les variables :

Un nom de variable commence toujours par un "$". On l'utilise chaque fois qu'on utilise la variable, que ce soit pour y placer quelque chose ou pour lire son contenu.
Si votre variable contient des caractères spéciaux (comme le "-" ou un espace), placez son nom entre accolades: ${ma-variable}
Si votre variable contient des accolades, placez-la entre accolades et précédez les accolades faisant partie du nom d'un `(backtick ou accent grave): ${voici`{une`}variable}

On assigne une valeur à une variable ainsi: $variable = valeur
La valeur peut être un nombre, du texte (entre guillemets), un booléen ou une liste de valeurs séparées par des virgules (la liste peut contenir des valeurs de types différents).

Lorsque l'on assigne une liste à une variable ($variable = 1, 45, "allo"), on peut ensuite accéder à une des valeurs de la liste en utilisant un index de 0 à x entre crochets ($variable[1]).

Notez que l'on peut aussi faire ceci: $variable[0] = "bonjour"
Les valeurs booléennes vrai/faux s'écrivent $true et $false. Ce sont elles-mêmes des variables qui contiennent les "vraies" valeurs booléennes, que seul le système peut manipuler.

Il est possible d'incrémenter une variable numérique de 1 en utilisant l'opérateur ++ de cette façon: $nombre++ (ceci est équivalent à $nombre = $nombre + 1)
On peut appliquer le même principe à la décrémentation avec l'opérateur --
Écrire simplement $variable comme une commande affiche le contenu de la variable.
On n'a pas besoin de déclarer une variable avant de l'utiliser.
La variable reste valide tout au long de la session, mais pas plus longtemps (pour rendre une variable "permanente", il faudra l'ajouter à notre profil (ce qu'on verra plus tard)).
Il existe déjà plusieurs variables prédéfinies - certaines que l'on peut modifier (contenant nos préférences) et d'autres non (contenant l'état du système).
get-variable utilisé seul permet de lister les variables présentement définies.
get-variable suivi du nom d'une variable permet de recevoir un objet englobant la variable (et donc de l'afficher).
cd variable: permet d'accéder à l'emplacement des variables, comme si c'était un disque!

Lecture et écriture à la console :

La console s'appelle "Host" et les fonctions/applets de commande suivants existent:

Write-Host permet d'écrire: Write-Host "Bonjour les amis!" (notez que les guillemets sont facultatifs)

Read-Host permet d'afficher un message à l'écran et de saisir la réponse du clavier: $nom = Read-Host "Veuillez entrer votre nom"

Clear-Host vide la console

Write-Error permet d'écrire un message sous forme de message d'erreur! Write-Error "Attention, vous allez tout briser!"
Ne vous gênez pas pour aller chercher de l'aide sur ces commandes, elles offrent beaucoup de possibilités!

 
Les conditions :

La structure if existe évidemment en PowerShell, mais sa syntaxe est calquée sur celle de C# (et donc pas sur celle de VB.NET). Les différences sont mineures:

Principe :
-------------

if (<condition 1>)
{
    <liste d'instructions 1>
}
[elseif (<condition 2>)
 {
    <liste d'instructions 2>
 }]
[else
 {
    <liste d'instructions 3>
 }]

 Les conditions sont entre parenthèses
Les blocs d'instructions sont entre accolades (obligatoire!)
Le elseif est facultatif (et il peut y en avoir plusieurs)
Le else est facultatif (mais il ne peut pas y en avoir plus d'un)
La structure a un seul point de sortie - au plus un bloc d'instructions sera exécuté


Les opérateurs :

Les conditions sont normalement faites avec des opérateurs de comparaison. Ces opérateurs commencent par un tiret suivi d'un mot (ou d'une abréviation):

-eq = égal (equal)
-ne = non-égal (not equal)
-lt = plus petit que (lesser than)
-le = plus petit ou égal (lesser or equal)
-gt = plus grand que (greater than)
-ge = plus grand ou égal (greater or equal)
-like = comme (permet de comparer avec le caractère générique "*")
-notlike = pas comme (l'inverse)
-contains = contient (permet de vérifier si une liste contient une valeur)
-notcontains = ne contient pas (l'inverse)

 Les opérateurs logiques permettent d'unir plusieurs conditions pour obtenir un seul résultat global. Ils fonctionnent de façon très similaire à leurs équivalents VB.NET:

-and = et (deux vrais = vrai, sinon c'est faux)
-or = ou (deux faux = faux, sinon c'est vrai)
-not = non (inverse le résultat du test)
! = non (une autre syntaxe)

Les répétitives :

Les formes do/while et do/until existent en PowerShell, mais encore une fois, leur syntaxe se rapproche de celle du C#:

Principe :
------------

do
{
   <liste d'instructions>
}
while (<condition>)

do
{
   <liste d'instructions>
}
until (<condition>)

while (<condition>)
{
   <liste d'instructions>
}

 
Les blocs d'instructions sont entre accolades
Les conditions sont entre parenthèses et sont bâties comme pour le if
On peut commencer une boucle par while ou par do selon si on veut que la condition soit évaluée en entrant ou en sortant de la boucle.
Le until ne peut pas être placé au début - on devra se résoudre à inverser notre condition si c'est ce qu'on veut faire.


Les boucles for :

for (<initialisation>; <condition>; <répétition>)
{
    <liste d'instructions>
}

La syntaxe du for est bien différente de celle de VB.NET. Elle offre beaucoup plus de flexibilité en ne faisant pas nécessairement que varier un compteur d'une borne à une autre. 

Un for est suivi de trois sections séparées par des point-virgules, le tout entre parenthèses.
La liste d'instructions à exécuter est entre accolades.

La partie initialisation contient les instructions à exécuter lorsqu'on entre dans la boucle la première fois. Généralement, il s'agit simplement d'une initialisation d'une variable compteur.

La condition représente la condition pour rester dans la boucle. À chaque tour, elle est évaluée. Si elle est vraie, on fait une boucle de plus. Sinon, on sort de la boucle.

La répétition contient des instructions à exécuter à chaque fois que la boucle a fait un cycle. Généralement, on y placera là une modification à la variable compteur.

Par exemple:
for ($i=1; i -le 5; i++)
{
    Write-host $i
}

Les boucles foreach existent aussi. Très puissantes et simples à utiliser, elles permettent de parcourir aisément une collection afin d'accéder une à une à chacune de ses valeurs.

 Principe :
-------------

foreach ({cke-peak}lt;élément> in <collection>)
{
    <liste d'instructions>
}


Un exemple d'application courante est une liste dans une variable:

$liste = "a", "y", "p", "u", "e",
foreach ($lettre in $liste)
{
    Write-Host $lettre
}       

Mais le foreach est extrêmement pratique en PowerShell parce que beaucoup de fonctions retournent une collection d'objets, qu'on peut ensuite parcourir un à un. Par exemple, get-childitem retourne une collection d'objets, chacun d'eux contenant un "enfant" de la position courante (c'est à dire le répertoire courant).

foreach ($fichier in get-childitem)
{
    Write-Host $fichier
}


TRY..CATCH :

Une dernière chose avant d'aller plus loin. Pour bien concevoir son code, il est important de gérer les erreur et les exceptions. Powershell implémente bien entendu la technique Try...CATCH :

Principe :
------------
Try {
# votre codeà exécuter
}

Catch {
# Code qui s'éxécute si une erreur se produit au sein du code inserer dans le Try {  }

# A noter que la variable  $_ represente ici l'erreur survenue 
$_
}

Finally {
# Code qui est toujours exécuter à la fin du script quel que soit le résultat
}

Les fonctions :

Pour crer une fonction simple , utilisr le code suivant :

function <name> { <script block> }

<script block> contient le code Powershell qu'éxécute la fonction. Sauvegardez votre fonction dans un fichier avec l'extension .PS1 (comme pour tout script Powerhell)

Donc, vous avez sauvegardé votre fonction dans un fichier ps1 et vous voulez maintenant la rendre disponibles dans votre session Powershell interactive ? C'est simple; votre script juste besoin d'être "dotté" ou 'DOT sourcé". Vous faites cela en tapant un . suivi d'un espace, puis le chemin vers le fichier. ATTENTION  : Il doit y avoir un espace entre le point et le nom du fichier, sinon cela ne fonctionnera pas. Une fois que vous avez exécuté la commande suivante, les fonctions dans votre script de ps1 seront disponibles pour vous dans votre session Shell.

[PS:1] . C:\functions.ps1 

Lorsque vous appelez une fonction, chaque argument que vous incluez est ajouté au tableau (Array) $args. En conséquence, vous pouvez manipuler autant d'arguments que vous voukez dans votre fonction. Toutefois, en travaillant avec des arguments de cette façon peut-être confus lorsque que le nombre augmente. Cela est particulièrement génant lorsque vous ne saisissez pas les arguments dans le bon ordre lors de l'appel de la fonction. En outre, il ya des limites sur la façon dont vous pouvez définir les arguments. En conséquence, la création de paramètres nommés dans la définition de fonction est souvent un moyen plus efficace pour traiter les arguments. Pour créer des paramètres nommés, vous incluez les noms de vos paramètres, qui doivent être précédés par le signe $, entre parenthèses après le nom de la fonction. Lorsque vous créez plus d'un paramètre nommé, vous devez utiliser une virgule pour séparer les noms de paramètres. Par exemple, la fonction suivante  est défini avec 2 paramètres nommés :  $dir et $minSize. Le "script block" utilise les valeur transmises par ces paramètres pour identifier le répertoire cible et la taille minimum de fichier à rechercher par la fonction :

function FileSize3 ($dir, $minSize)

{

  dir $dir |  where {$_.length -gt $minsize

}

A vous de jouer et n'hésitez pas à consulter la foultitude de blogs et de sites (dont technet et CODEPLEX) qui vous aideront à utiliser Powershell

​Retour...