web/nec/moocs/powershell.org

#+title: Powershell
#+date: <2022-03-26 sam.>

* Avant-propos
  
  Sources : [[https://www.skilleos.com/cours/apprendre-powershell-pour-debutants][Mooc Powershell sur Skilleos]]

  **Les commandes n'ont pas pu être testées dans le cadre de ce
  Mooc.**

  Je m'appuie quelques fois sur le Bash pour expliquer comment marche
  une commande.

* Introduction

  Les commandes DOS marchent sous Powershell. Les commandes
  Powershell sont appelées des *cmdlets*. Ces commandes peuvent
  être système, utilisateur ou créées par l'utilisateur. Elles sont
 *insensibles à la casse*, contrairement à Bash, et séparées par un
 =;=. Elles retournent et affichent leur résultats sous la forme
  d'objets ou de tableaux.

  Une commande Powershell se découpe en 2 parties :
 =verbe-nom=. Elles sont séparées par un =-=. Il existe différents
  verbes (liste non exhaustive) :

  | Verbe | Action générique     |
  |-------+----------------------|
  | Get   | récupérer            |
  | Set   | définir              |
  | Start | exécuter             |
  | Stop  | arreter              |
  | Out   | sortir quelque chose |
  | New   | créer quelque chose  |

  Exemple de commandes :

  * Get-Help : affiche l'aide
  * Get-ChildItem : affiche les objets enfants
  * Clear-Host : nettoie la console (= clear en bash)

  Il existe des alias pour certaines commandes, =Clear-Host= = =cls=
  par exemple. Pour pouvoir voir la liste des alias existants :
 =Get-Alias=.

  Powershell dispose de *son propre IDE*. Il se lance avec la commande
 =ise=.
  
* <<comp>>Opérateurs de comparaison

** Nombres et String
  
   On retrouve les mêmes opérateurs que Bash pour *les comparaisons
   mathématiques* : =-eq=, =-ne=, =-gt=, =-lt=...

   | Opérateur | Type   | Effet                                                             |
   |-----------+--------+-------------------------------------------------------------------|
   | -eq       | int    | ==                                                                |
   | -ne       | int    | !=                                                                |
   | -lt       | int    | <                                                                 |
   | -le       | int    | <=                                                                |
   | -ge       | int    | >=                                                                |
   | -gt       | int    | >                                                                 |
   | -eq       | string | Vérifie si 2 strings sont égales, ne prend pas en compte la casse |
   | -ceq      | string | Idem mais prend en compte la casse                                |
   | -like     | string | Comparaison avec une regex                                        |

** Connecteurs logiques

   Les opérateurs logiques sont tous simplement =-and= et =-or=.

* Pipeline

  Elle s'utilise comme en Bash, avec =|= entre les commandes.
  C'est intéressant de l'utiliser avec certaines méthodes pour filtrer
  les sorties:
 =get-member= (affiche attributs et méthodes) ou =select-object
  attribut,attribut..= (affiche uniquement les attributs se
  trouvant dans la liste).

  Il est possible de manipuler l'objet passé dans le pipeline (ou les
  objets s'il s'agit d'une liste). Cela peut être utile pour mieux
  filtrer les objets et n'afficher que ceux avec un certain
  attribut. *Il faut utiliser la variable* =$_= pour avoir l'objet
  courant.

  Exemple: =Get-PrinterDriver | Where-Object -FilterScript {$_.Manufacturer -eq "HP"}=

  Aller voir [[comp][les opérateurs de comparaison]] pour plus d'informations.

* Sécurité

  Il est possible d'avoir un filtre de sécurité pour interdire
  l'exécution de scripts téléchargés sur des sites non officiels.

  On peut vérifier le niveau de la politique d'exécution avec
 =Get-ExecutionPolicy=. ELle peut être de plusieurs niveaux :

  | Politique    | Effet                                                              |
  |--------------+--------------------------------------------------------------------|
  | Unrestricted | On exécute tout                                                    |
  | Restricted   | Bloque tout                                                        |
  | RemoteSigned | Demande la signature numérique de l'éditeur de script (par défaut) |
  | Bypass       | aucune restriction                                                 |

* Script

  Les commentaires sur une ligne se font comme en Bash, avec un #.
  Pour les blocs de commentaires, ils sont entourés par
 =<# commentaires #>=.

** Variables

   Les variables se déclarent et s'utilisent comme en Bash. Les espaces
   peuvent cependant être mis lors de l'affectation de la variable :
 =$variable = 5=.

 *Il est possible de multiplier les strings*, comme en Python, pour
   pouvoir avoir X fois une string : ="coucou " * 5= donne
   "coucou coucou coucou coucou coucou".

   Pour *faire des retours à la ligne* : =`n= dans la string.

   Pour déclarer des blocs de textes, il faut utiliser des
 *here-strings*.

  #+begin_src powershell
    $variable = @"
	Bloc de texte
	sur plusieurs lignes
    "@
  #+end_src
  
*** Typage

    Il est possible de typer des variables lorsqu'on les déclare :
 =[type] $variable=

    On peut remplacer =type= par =string= ou =int=.

*** Constante

    La déclaration des constantes se fait avec une commande :
 =New-Variable=. Il faut lui préciser le nom ainsi que la valeur :
 =New-Variable -name variable -value 1 -option Constant=.

    Il faut utiliser =Remove-Variable= pour supprimer les constantes
    créées.   

*** Caste

    Si la variable est typée, il est possible de la caster.

    Pour caster en int : =[convert]::ToInt32($variable, string, int)=

*** Formatage de string

    Pour pouvoir facilement formatter des strings, il existe
 *l'opérateur -F* lors de la déclaration de la string :
 ="String 1 : {0} et une variable X : {1}" -F $val,$value=

    Comme en C, il est possible de préciser des formats de valeurs à
    afficher comme de l'héxadécimal à partir du décimal ou un certain
    nombres de chiffres après la virgule. Exemple
 *pour avoir 2 chiffres après la virgule* :
 ="2 chiffres après la virgule: {0:n2}" -F 3.1419=

    [[https://social.technet.microsoft.com/wiki/contents/articles/7855.powershell-using-the-f-format-operator.aspx][Plus d'informations sur le formatage de string]].

** Instructions

   La structure du if est classique, on y utilise les opérateurs de
   comparaisons.

   #+begin_src powershell
     # le if et les else
     if (variable -le val) {
	 # instructions
     } elseif (variable -gt val ) {
	 # instructions
     } else {
	 # instructions
     }

     # le switch
     switch (value) {
	 {$_ -le val} {
	     # instructions;
	     break
	 } default {
	     # instructions
	 }
     }
   #+end_src

** Tableaux

   Un tableau se déclare avec comme une variable. Ses différents
   éléments sont séparés par une virgule : =$tableau =
   "elem1","elem2"=. Pour initialiser *un tableau vide*, il faut lui
   assigner =@()=.

   Un tableau est un objet et on peut récupérer par exemple sa taille
   via l'attribut =Count= : =$tableau.Count=.

   On accède à un élément comme un tableau en Python ou en Java :
 =$tableau[index]= et on modifie une valeur de la même manière :
 =$tableau[index] = val=. Une autre méthode pour sélectionner le
   premier object consiste à passer par un pipe :
 =$tableau | Select-Object -First 1=.

   Pour ajouter une valeur : ~$tableau += val~.

   Il existe quelques fonctions dans l'objet des tableaux :

   | Fonction | Effet                                              | Paramètre | Valeur de retour                            |
   |----------+----------------------------------------------------+-----------+---------------------------------------------|
   | clear    | vide le tableau                                    |           |                                             |
   | contains | vérifie si une valeur est présente dans le tableau | value     | true si la valeur est présente, false sinon |

   Pour pouvoir trouver un élément ressemblant à une regex ou à une
   valeur : =$tableau -like regex=. Il retourne l'élément
   correspondant.
   
   Exemple de boucle pour itérer sur tous les éléments d'un tableau :
   
   #+begin_src powershell
     for ($i = 0; $i -le ($tableau.Count - 1); $i = $i + 1) {
	 # instructions
     }

     foreach ($i in $tableau) {
	 # instructions
     }
   #+end_src

** Fonctions

   Si vous utilisez l'éditeur de Powershell, il faut *enregistrer puis
   recharger* le script pour pouvoir exécuter les fonctions.

   Contrairement au Bash, il faut déclarer les attributs en début de
   fonction. Il est aussi possible de rajouter des contraintes sur ces
   paramètres (juste sur un champ de valeur, obligatoire...). Les
   paramètres peuvent avoir des alias qui seront utilisés comme des
   arguments. Par exemple, un paramètre avec l'alias nombre :
 =fonction -nombre 1=.

   Il est possible de rajouter certaines fonctionnalités aux
   fonctions. =[cmdletbinding()]= va permettre l'ajout d'options
   automatiques liés aux cmdlet, comme l'option =-Verbose= qui permet
   d'afficher les commentaires lors de l'exécution de la fonction. Ça
   appelle automatiquement la méthode =Write-Verbose=.

   Comme dans AWK, on peut préciser des blocs d'instructions qui
   seront exécutés tout le temps en début et fin de fonction. Ils sont
   cependant *optionnels* et il est possible d'écrire une fonction sans
   aucun bloc spécial.

   | Nom  du bloc | Exécution               |
   |--------------+-------------------------|
   | BEGIN        | Au début de la fonction |
   | END          | À la fin de la fonction |
   | PROCESS      | Corp de la fonction     |

   Une fonction *avec des arguments non obligatoires*, qui est appelée
   sans, va utiliser *des valeurs vides* à la place.
   
   #+begin_src powershell
     function foo {
	 [cmdletbinding()]
	 param (
	     [parameter (mandatory=$true)] # le paramètre est obligatoir
	     [string]$var,
	     [validaterange (0, 10)]       # le paramètre doit être compris entre 0 et 10
	     [alias ("nombre")]            # et a pour alias nombre
	     [int]$val,
	     [int]$bar                     # paramètre classique
	 )
    
	 BEGIN {
	     # instructions
	 }
	 PROCESS {
	     # instructions
	 }
	 END {
	     # instructions
	 }
     }
   #+end_src
   
* Liste de commandes

  Il s'agit juste de montrer leur utilité, pas les arguments. Je vous
  conseille de vérifier en premier comme la commande s'utilise avant
  de l'exécuter.
  
  | Commande      | Fonctionnalité                | Paramètres possibles                                            |
  |---------------+-------------------------------+-----------------------------------------------------------------|
  | Get-Help      | Affiche l'aide                |                                                                 |
  | Get-Service   | Liste des services            |                                                                 |
  | Get-Command   | Liste de toutes les commandes | Regex pour filtrer les commandes                                |
  | Get-Alias     | Liste de tous les alias       | alias pour n'avoir les informations que sur celui-ci (et Regex) |
  | New-Alias     | Créer un nouveau alias        |                                                                 |
  | Get-ChildItem | Affiche les objets enfants    |                                                                 |
  | Clear-Host    | Clear en Bash                 |                                                                 |
  | Write-Output  | Echo en Bash                  |                                                                 |
  | Write-Host    | Idem                          | -foregroung pour changer la couleur du texte                    |
  | Out-File      | Ecrit dans un fichier         |                                                                 |