#+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=. * <>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 | |