Premiers pas

Ecrit par @mickyballadelli

Introduction

Cette section du blog est un projet dans le projet: enseigner la programmation sous Powershell pour les néophytes.

Powershell est bien un langage pour créer des scripts, mais derrière cette fonction se cache un langage orienté objet, tout ce qu’il y a de plus puissant. Powershell s’appuie sur le Framework .NET pour accéder aux recoins les plus reculés de votre système, et rend des tâches complexes très simples.

Nous reviendrons sur ces concepts d’orienté objet, et libraries plus tard.

Reculons dans le temps un peu.

Dans les années 70-80, Digital Equipment Corp. avait conçu VAX/VMS, un système d’exploitation extrêmement stable, conçu et développé par David Cutler et qui ensuite a donné naissance à Windows NT.

Et bien VMS a un langage de commande appelé DCL (Digital Command Language). Ce langage a été l’« inspiration » pour Powershell.

Bien que les deux langages ont pas mal de points en commun, DCL n’est pas un langage orienté objet, par contre, il est basé sur des bibliothèques runtime comme Powershell, et donc tout le système est disponible, ainsi que les programmes qui exposent des interface à travers le CLI$.

Tout ceci pour dire que Powershell, trouve ses racines dans les années 70-80, et est bien plus proche de VMS et DCL que de UNIX et ses langages de script.

 

D’ailleurs, Unix est plutôt orienté document, alors que VMS (et NT) est plutot orienté commande. Comme le kernel de NT est très proche de VMS. Ceci explique cela.

D’ailleurs, il suffit d’être un fan de 2001 Odyssée de l’espace et de son ordinateur star: HAL, et savoir que HAL c’est IBM – 1, qu’on se rend compte que Windows NT, ou WNT est VMS + 1.

Reculons encore un peu.

La programmation est une histoire longue. Très longue. Elle prend racine au 18eme siècle tout d’abord avec Basile Bouchon, qui utilisa des rubans perforés pour programmer des machines à tisser. Technique ensuite améliorée par Jean-Baptiste Falcon en 1728 qui utilisa des cartes perforées, et surtout par Joseph Jackard qui a combiné les techniques de ses deux prédécesseurs pour automatiser une machine à tisser la soie. On retrouvera cette technique de cartes perforées jusqu’aux années 60.

Autre figure importante dans la programmation et surtout l’algorithmique est Ada Lovelace. Ada Lovelace a développé les premiers algorithmes pour une machine imaginaire créée par Charles Babbage. Nous sommes en 1834.

Reculons encore un peu.

Nous sommes maintenant au 17eme siècle. Blaise Pascal développe une machine à calculer, appelée la « Pascaline » qui fût un point de départ pour aboutir au développement des microprocesseurs inventés par Intel dans les années 70.

Revenons au 20eme siècle.

En 1936 Alan Turing crée la première machine programmable avec des 0 et des 1: le binaire.

En 1945 von Neumann crée le premier programme stocké en mémoire. Cette année là Grace Hopper trouve une panne d’ordinateur due à un insecte coincé, le terme Bug (déjà utilisé à cette époque) est universalisé.

Toujours en 1945, Vannevar Bush imagine une machine appelée Memex censée étendre la mémoire humaine. A travers son article, As we may think, il définit l’hypertexte, ceci 45 ans avant la création de HTML et du WWW.

Le premier compilateur arrive en 1954: Fortran (John Backus).

Arrivent ensuite Lisp (John McCarthy) et BASIC (Kemeny et Kurtz) dans les années ’60.

A partir de 1970 plusieurs langages font leur apparition dont Ada et Pascal en mémoire à Ada Lovelace et Blaise Pascal.

Mais début des années ’70 Dennis Ritchie invente le C qui est la base de pas mal de langages de programmation, et de systèmes d’exploitation.

Les interfaces graphiques apparaissent aussi dans le milieu des années ’70 grâce à Xerox, l’idée est ensuite reprise par…tout le monde!

C’est en 1983 qu’est né le C++ (Bjarne Stroustrup). Explosion de l’orienté objet et arrivée de Java, PHP, Objective-C et bien d’autres langages.

Microsoft introduit Powershell en 2005 (Jeffrey Snover).

Premières lignes de code

Les variables

Une variable c’est comme une boîte en carton, on y met des trucs dedans. Les variables sont composées de trois choses: un nom, un type et une valeur.

Le nom nous permet de référencer la variable et d’y accéder à tout moment.

Le type nous renseigne s’il s’agit d’un caractère [char], d’une chaîne de caractères [string], un nombre [bool][int][double]…, une date [DateTime], ou tout autre type prédéfini.

La valeur c’est ce qu’on veut y stocker et/ou récupérer. La valeur suit les règles imposées par le type.

On appelle déclaration la création d’une variable.

En Powershell il n’est pas nécessaire de définir le type de la variable lors de sa déclaration comme d’autres langages, Powershell déduit le type en fonction de la valeur utilisée.

Exemples:

D’après ces déclarations $test sera un [string], $nombre un [int] et $bool un [bool]. Toute variable en Powershell commence par le signe $.

On appelle typecast ou casting la transformation d’un type de variable vers une autre. Ceci permet par exemple de disposer d’une date en format lisible plutôt qu’un format interne quel qu’il soit et totalement illisible pour nous (par exemple le nombre de secondes depuis 1970). Le cast se fait en indiquant le type demandé entre parenthèses carrées ([ ]). Dans l’exemple ci-dessous, le chiffre 1 est transformé en booléen (c’est à dire une valeur de True ou False, Oui ou Non, 1 ou 0). Le fait de ‘caster’ cette variable en booléen, force Powershell à l’afficher selon les règles des booléens, c-a-d écrire True si la valeur est 1, et False si la valeur est 0.

Le fait de ne pas avoir assigné cette déclaration ([bool]1) à une variable, Powershell l’envoi directement à la console. Nous verrons la gestion des entrèes et sorties vers la console plus tard.

Voici une autres formes de déclaration, en définissant le type. Dans ce cas, la valeur 1 (integer), est transformée en bool:

Opérations basiques

Dans cette section nous allons voir quelques opérations basiques. C’est surtout pour s’imprégner de la syntaxe utilisée par Powershell.

Comme vous pouvez le voir, l’addition est comme les autres langages, c’est la même chose pour la soustraction (-), la multiplication (*) et la division (/).

Supposons que $c contienne déjà une valeur, et nous voulons l’augmenter par $a qui vaut 3. Voici deux possibilités:

Remarquez la ligne $c += $a. L’opérateur d’assignement ‘=’ assigne une valeur à une variable. Par contre l’opérateur ‘+=’ signifie qu’on ajoute la valeur de $a à la variable de destination $c en prenant en compte la valeur existante de $c. Cette approche est très utile lors des boucles qu’on verra un plus tard.

Pour soustraire le montant d’une variable on peut utiliser ‘-= ».

Cette approche peut être également utilisée lors d’une multiplication (*=) ou une division (/=) bien que généralement plus rare dans les scripts.

Deux autres opérateurs très utiles en Powershell, sont le ++ et le .++ ajoute 1 à une variable, et — enlève 1, ces opérateurs sont utilisés dans les boucles, mais on verra cette utilisation plus tard. Voici un exemple:

C’est avec ces quelques lignes de code qu’on voit que Powershell est très proche du C. Tellement proche que tout ce qui fait que C est magnifique est disponible en Powershell.

Opérations avec des chaînes de caractères

Les opérations avec des chaînes de caractères ne sont pas très diffèrentes des opérations avec des nombres.

Voici un autre exemple, cette fois-ci nous allons utiliser le cast pour transformer un nombre en caractère, nous utiliserons les codes ASCII pour les valeurs.

Le nombre 65 en ASCII est le A. Le cast a transformé l’integer 65 en type ‘char’ qui a ensuite transformé la valeur en ‘string’ pour être visualisée sur la console. [char] est un type qui stocke des nombres, généralement de l’ASCII, ASCII étendu ou de l’Unicode. D’ailleurs on peut déclarer une variable de type [char] et lui donner la valeur 65, si on envoyait la valeur de cette variable vers la console, un A sortirait.

En résumé. Nous avons vu les déclarations de variables, les types qui définissent le contenu des variables, quelques opérations basiques, le casting pour changer le type de notre variable, et les opérateurs d’assignement.

Les conditions

Les conditions nous permettent d’évaluer et d’agir en fonction de la valeur d’une variable. Par exemple nous voulons savoir si la valeur de la variable $a est 1:

Dans cet exemple $a est evalué avec la commande if (si) et l’opérateur -eq (égale à), si cette condition n’est pas remplie, la commande elseif (ou si) sera évaluée, et si elle ne remplit pas les conditions demandées, else (sinon) sera exécuté.

Remarquez les accolades ({}), celles-ci permettent de créer un block de code. Toutes les commandes entre les accolades seront exécutées.

Le tableau suivant liste les opérateurs de comparaison les plus utilisés:

-eq Egal
-ne Pas égal
-ge Plus grand ou égal
-gt Plus grand que
-le Plus petit ou égal
-lt Plus petit que
-like Comparaison Utilisant les wildcards (Ex: *)
-notlike Comparaison excluant les wildcards
-contains Contient
-notcontains Ne contient pas

Le Switch

Le switch est une variante des opérateurs de comparaison permettant d’exécuter des blocs de code en fonction de la valeur d’une variable.

Voici la structure d’un switch:

Voici un exemple:

On peut combiner plusieurs valeurs dans un switch et les évaluer avec un opérateur de comparaison, si nous voulons éviter du code en double. Dans l’exemple, si $feu est Orange ou Rouge, nous voulons exécuter le même bloc de code car le résultat est le même. Voici un exemple:

Dans l’exemple, $_ est une variable contextuelle, c’est à dire, pré-remplie en fonction du contexte en cours. Dans l’exemple elle fait réference à $feu donc contient sa valeur. Dans le monde C++, $_ équivaut à this. On peut optimiser encore un peu, finalement on passe que si le feu est vert, et on s’arrête dans tous les autres cas. Nous pouvons utiliser default qui sera le choix par défault. Default sera toujours exécuté si les autres cas ne l’ont pas été.

Les boucles

Les boucles sont un concept incontournable de la programmation. Elles permettent d’effectuer des opérations répétitives tout en maintenant un contrôle lors de l’exécution.

Il existe différentes types de boucles que l’on peut choisir en fonction de son besoin (et de son style de programmation).

For

Le For est une boucle que l’on verra souvent en programmation, dérivée du C, elle est utilisée très souvent. Voici comment elle fonctionne :

L’initialisation permet de positionner une valeur de base à une variable (souvent appelée «$i» ou «$j» ou «$z»), celle-ci doit être dans les limites imposées par les conditions de validité et généralement (mais pas forcément), sera mis à jour lors de l’opération successive. A noter que la variable sera mise à jour seulement lorsque le block de code sera exécuté.

Voici un exemple :

Cet exemple parcourt le texte stocké dans une variable $s, et chaque caractère est envoyé sur la console individuellement.

While et Do-While

While et Do-While dont des boucles qui permettent l’exécution de code si l’évaluation d’une valeur booléenne est vraie (True). Tant que la valeur de la condition booléenne est True le code est exécuté en boucle. La différence entre les deux boucles est que While vérifie la valeur de la condition booléenne avant d’exécuter le code alors que Do –While exécute d’abord le code, et ensuite vérifie la valeur.

Voici un exemple en Powershell:

Foreach

Foreach est aux boucles ce que le fromage est à la pizza, on pourrait faire sans, mais c’est bien meilleur avec.

Foreach permet de recuperer toutes les valeurs d’une liste de façon très simple et intuitive. Exemple

Foreach devient très utile avec les arrays simple, les hash tables, et les arrays d’objets, ainsi que les objets .NET plus complexes qui contiennent souvent des arrays. Mais on en a pas encore parlé, donc on verra ça un peu plus tard.

Les arrays

Il est des fois nécessaire de stocker plusieurs valeurs dans une variable, c’est le cas, par exemple, si on veut énumérer les éléments appartenant à une classification prédefinie.

On appelle array, une variable à valeurs multiples. Ces valeurs sont indexées, et chaque valeur peut être récupérée à travers son index unique.

Il existe deux types de array :

    Les Arrays simples
    Les Hash Tables
Les arrays simples

Voici un exemple :

La déclaration d’une Array simple se fait toujours avec le préfixe @ suivi des valeurs entre parenthèses. Pour accéder aux membres d’une array on doit indiquer son numéro d’index renseigné entre crochets. Ainsi [0] est le premier élément, [1] le deuxième, ainsi de suite. [-1]fait référence au dernier élément de l’array.

Chaque Array, dispose de méthodes (ou fonctions) et de variables membres permettant d’interagir avec l’objet et obtenir plus d’informations.

Count est une variable membre qui nous renseigne sur le nombre d’éléments dans l’Array.

Les éléments d’une Array ne doivent pas forcément être du même type. Ainsi nous pouvons imaginer les arrays suivantes:

Les hash tables

Les Hash tables (tables de hachage) sont des listes contenant des valeurs associées à un nom d’index (ou clés) unique.

La structure d’une Hash Table est toujours une liste de paires Clé et Valeur , chaque clé a forcément une valeur.

Les Hash Tables sont définies avec un arobas (@) suivi d’accolades, contrairement aux arrays simples qui utilisent des parenthèses. Voici un exemple :

Oui ce sont des vitesses en Km/h.

Pour accéder à une valeur, on utilise le nom de la variable de l’array, suivi de sa clé :

Une fois la table créée on peut ajouter des paires clé, valeur avec la méthode Add(clé, valeur) :

La variable membre $v.Keys permet de lister les clés dans l’array, et la variable membre $v.Values permet de lister les valeurs.

On peut également utiliser les crochets sur la variable pour définir une nouvelle entrée:

On peut enlever des entrées avec la méthode Remove(clé).

Les cmdlets

Les cmdlets (prononcées « commande-lets ») sont des commandes ou des bouts de programme effectuant des tâches bien précises. C’est la clé de voûte de la stratégie d’administration pour les produits Microsoft ainsi que les systèmes d’exploitation Windows de dernière génération.

Une autre façon de voir les cmdlets est qu’elles permettent de s’affranchir de beaucoup de complexité. Elles peuvent faire abstraction, ou cacher des milliers de lignes de code, permettant à nos scripts de rester simples et faciles à maintenir.

En Powershell, les cmdlets suivent toujours la même règle de nommage:

Verbe-Nom -paramètres

Voici un exemple d’utilisation de cmdlet. Revenons à notre hash table $v créée un peu plus haut:

On peut remarquer que la table n’est pas ordonnée. Les tables hash ne sont jamais dans un ordre quelconque.

Pour ordonner cette table en fonction des valeurs, nous devons énumérer les entrées de notre table et les passer à une cmdlet appelée Sort-Object.

Sort-Object est une cmdlet très utile, elle permet de trier des objets en fonction d’une propriété choisie.

Pour passer les entrées, nous allons utiliser une barre verticale, appelée un pipe, représenté par le caractère « | ». Le résultat d’une opération est envoyé à la commande après le pipe qui le traite comme un argument. Le piping est très utilisé en Powershell et peut réduire considerablement les lignes de code tout en maintenant une certaine simplicité dans la structure du script.

Nous utilisons une méthode de l’objet hash table appelée GetEnumerator qui permet de sortir tous les éléments de la table, et nous les passons à la cmdlet Sort-Object à travers le pipe.

Voici le résultat:

On peut également trier les entrées en fonction de la clé (Name):

Il existe plus de 3000 cmdlets pour Windows Server 2012R2, seulement pour la géstion du système d’exploitation. S’il faut se souvenir d’une seule cmdlet vaut mieux se souvenir de Get-Help qui permet de trouver les informations sur toutes les autres cmdlets, leurs paramètres et les exemples d’utilisation. En gros c’est le Help façon Powershell.

Les objets

En Powershell tout est objet, mais qu’est-ce qu’un objet ? Voici quelques bases.

Un objet est une variable complexe qui encapsule des données ou attributs ainsi que les fonctions membres pour y accéder. Dans le monde orienté objet, les fonctions s’appellent aussi des méthodes.

En C++ chaque objet est dérivé d’une classe qui en définit la structure. Une classe c’est un peu comme les plans d’architecture d’un bâtiment, alors que l’objet est le bâtiment lui-même.

En Powershell il n’y a pas de classes jusqu’a la version 5, qui les introduit . Néanmoins dans les versions plus anciennes la déclaration d’un objet c’est un peu comme la définition d‘une classe, les variables et fonctions membres sont ainsi créés.

Powershell peut de plus, permettre de modifier un objet à posteriori et y ajouter des méthodes ou des variables, ceci peut s’avérer très utile dans des cas précis.

Par exemple on peut définir un objet qui représente une habitation, si l’on veut faire évoluer cet objet lors de l’exécution du programme et y ajouter, par exemple, un jardin, on peut le faire sans devoir revenir au début du programme.

Créons un objet :

Nous créons une variable $i qui contient l’integer 1. Powershell va en fait créer un objet de type Int32 et y stocker la valeur assignée.

Tous les objets Powershell définissent une fonction membre appelée GetType(), cette fonction ne prend pas de paramètres et retourne le type d’objet de l’objet en question.

Cette fonction retourne ceci :

Nous pouvons faire de même avec une variable d’un autre type, par exemple une chaîne de caractères :

Nous pouvons utiliser les méthodes de la classe String directement sur l’objet.

Par exemple si nous voulons savoir si $s contient le caractère «b» on appelle la méthode ‘Contains’ :

Puisque c’est le cas, Powershell retourne true.

En fait les objets permettent de cacher la complexité de l’implémentation des fonctions. Ceci s’appelle l’abstraction, est c’est un concept important de l’orienté objet.

Dand notre exemple nous voulions savoir si le caractère b se trouvait dans la chaîne $s, le comment du pourquoi du détail de l’implémentation de la fonction Contains ne nous intéresse pas. On voulait le résultat c’est tout. C’est ça l’abstraction.

C’est comme aller au resto, et commander une pizza, on veut pas savoir comment se fabrique la mozzarella, ni comment se cultivent les tomates, on veut seulement notre pizza.

Autre exemple. Imaginons maintenant la string suivante:

Si on veut récupérer les mots, un par un, de cette chaîne, nous pouvons utiliser la méthode Split:

Powershell retourne un array de n éléments et les affiche un par un.

Du coup on peut demander à l’array combien d’éléments il possède :

Count est une variable membre de l’objet Array. Et nous avons bien 4 mots dans notre string.

Nous pouvons créer nos propres objets. Je me sers beaucoup de cette fonctionnalité pour gérer les données de mes scripts d’une façon organisée et ainsi exécuter des fonctions sur l’ensemble des objets tels que l’export vers le HTML ou le CSV.

Pour créer notre propre objet nous utilisons la cmdlet New-Object qui prend comme paramètres le type ainsi qu’une hash table définissant les méthodes et variables membres.

Ajoutons maintenant une nouvelle variable membre à notre objet. Nous utilisons pour ceci la cmdlet Add-Member.

Le type de membre qu’on ajoute est un script. Le nom est « Date » et la valeur est un script block qui appelle la cmdlet Get-Date qui retourne la date et l’heure actuelle.

Nous pouvons accéder aux variables membres en utilisant leurs noms, exemple :

Imaginons maintenant qu’on veut traiter une liste de contacts et pas un seul. Pour cela nous allons créer une array vide appelée $contacts :

Nous pouvons ajouter les objets $contact créés à notre array avec l’opérateur += :

Avec cette liste de contacts nous pouvons faire plusieurs opérations, par exemple nous pouvons l’exporter vers un fichier de type CSV :

Nous allons ‘piper’ l’array (à travers l’opérateur |) vers la cmdlet Select-Object (qui peut être raccourci à Select). Select-Object nous permet de sélectionner les variables membres ainsi que leur ordre. Ainsi nous voulons, le Prenom en premier suivi du Nom et de l’Adresse. Nous ne voulons pas par exemple sélectionner la date, elle ne sera pas sauvegardée. Le résultat du Select est lui-même pipé vers la cmdlet Export-Csv qui prend en paramètre le path pour le fichier de sortie.

Si nous voulons récupérer notre liste de contacts à partir d’un fichier CSV, nous pouvons utiliser la cmdlet Import-Csv:

Et voilà.

Les fonctions

Une fonction est une bout de programme qui permet d’encapsuler l’implémentation d’une ou plusieurs fonctionnalité et permettre à qui s’en sert de n’avoir à gérer que les paramètres d’entrée et de sortie.

En powershell une fonction est définie ainsi :

Les paramètres sont définis à la première ligne de la fonction, ils peuvent être requis, avoir une valeur par défaut, et s’ils ne sont pas présents une exception peut être générée :

Une fonction peut retourner un seul élément, généralement le résultat d’une opération, ou une valeur, selon besoin.

Pas besoin de mentionner return comme dans l’exemple, la variable suffit.

Il y a beaucoup à dire sur les fonctions, mais pour des premiers pas, je n’irai pas plus loin pour le moment.

Les Jobs

Lorsqu’il est nécessaire d’exécuter plusieurs tâches en parallèle de façon asynchrone on fait appel aux Jobs. Les Jobs sont des tâches de fond exécutées dans leur propre contexte Powershell. Les jobs sont la façon de Powershell pour faire du multi-threading.

Chaud devant.

Il y a plusieurs cmdlets importantes pour la création et la gestion des jobs :

Start-job permet de créer un job en lui passant comme paramètre un script block
Get-job permet de lister les jobs en cours d’exécution ou complétés
Receive-job permet de récupérer les données des consoles des jobs (les sorties)
Wait-job attend qu’un ou plusieurs jobs finissent leurs exécution
Remove-job Arrête et efface des jobs

Ces cmdlets peuvent être invoquées à travers un pipe, ce qui rend la gestion des jobs bien plus facile.

Voici comment créer un job avec Start-job

Cette commande va créer une tache de fond qui récupère l’heure actuelle et la rend sur la console.

Nous allons combiner plusieurs cmdlets pour ne pas avoir à gérer les identifiants de jobs.

Avec Get-Job nous récupérons tous les jobs en cours et nous passons directement cette liste à Wait-job, qui attendra tant qu’un job de la liste est en cours d’exécution.

Une fois que Wait-job nous rend la main, nous allons faire la même chose avec Receive-job

Get-Job | Receive-Job

Voici l’output sur la console :

Evidemment nous n’avons pas besoin d’une tâche de fond pour récupérer l’heure actuelle, ce n’était qu’un exemple pour montrer la gestion des jobs. Généralement les jobs sont utilisés pour des tâches longues qui peuvent être parallélisées.

Imaginons maintenant que nous voulons démarrer un Job pour exécuter une fonction. Là nous avons une problème car si nous définissons une fonction dans notre script, celle-ci ne sera pas vue dans le contexte Powershell créé par le Job. Un job est une nouvelle instance de Powershell qui n’a pas connaissance de notre script ni de nos fonctions et autres variable définies.

Ceci ne fonctionnera pas :

Ni la fonction MaFonction, ni $str ne seront définis dans le contexte du job.

Pour que ça fonctionne nous devons encapsuler notre fonction dans un script block :

Et nous allons passer le script block au Job:

Maintenant MaFonction sera reconnue comme une fonction dans le contexte d’exécution du Job.

Réglons le problème de l’argument.

Nous ne pouvons pas passer $str tel quel, nous devons créer une liste d’arguments, qui n’est autre qu’une array et référencer chaque argument dans cette liste. Exemple :

Maintenant notre fonction peut être appelée sans problèmes et recevoir des paramètres.

Encore un peu plus de complexité. Imaginons maintenant que notre Job veut à son tour créer d’autres jobs en passant notre script block comme paramètre. Pour faire ceci nous devons transformer le script block en string. Ceci est nécessaire car le type ScriptBlock ne peut pas être passé comme paramètre (ça génère une exception).

Nous allons ensuite recréer un script block dans MaFonction:

Ainsi nous pouvons créer de nouveaux jobs en préservant les définitions dans notre script block. Plus sur les jobs ici.

Création d’une Cmdlet

Les cmdlets sont des fonctions qui sont définies afin d’être utilisées par plusieurs scripts, ou programmes.

Le but premier de toute cmdlet est d’introduire une notion d’abstraction et rendre des concepts difficiles, simples à utiliser.

Une bonne cmdlet doit faire face à plusieurs paramètres potentiellement de différents types et être capable de gérer chaque cas.

Imaginons une cmdlet capable d’ouvrir un fichier pour traitement.

Nous définissons une fonction et créons un bind vers une cmdlet. Ceci permettra à la cmdlet d’être vue par des cmdlets type Get-Help.

Nous définissons ensuite les paramètres. ValueFromPipeline veut dire que le paramètre peut être passé à travers le pipeline. Pas forcément mais c’est un cas possible.

Powershell a introduit depuis la V2 trois méthodes utilisées pour la gestion d’input venant du pipeline.

Ces méthodes sont beginprocessend.

Begin n’est appelé qu’une fois, et est utilisé pour initialiser les variables de la cmdlet. Par exemple si nous voulons ouvrir un fichier Excel, on initialiserait Excel dans la méthode begin.

End est aussi appelé qu’une seule fois, et sert à faire le ménage avec ses variables s’il y a besoin. Par exemple on pourrait fermer Excel.

Process est appelé autant de fois qu’il y a d’éléments envoyés à travers le pipeline.

Dans notre exemple je peux définir les trois méthodes ainsi:

L’exécution du script initialise la cmdlet OpenFile mais ne l’exécute pas encore. Pour l’exécuter nous devons l’appeler.

Nous pouvons également appeler la cmdlet de façon plus classique.

Nous pouvons créer un array de fichiers et le passer à travers le pipeline vers notre cmdlet. La méthode process sera dans cet exemple exécutée deux fois.

Imaginons maintenant que nous utilisons une autre cmdlet pour récupérer les informations du fichier mycsv.txt.

Je voudrais envoyer le résultat de la cmdlet Get-Item directement à notre cmdlet. Est-ce possible?

Oui, bien que le résultat de Get-Item soit du type [system.IO.FileSystemInfo], Powershell récupère l’essentiel, i.e. le nom du fichier, et le passe à notre cmdlet.

C’est un peu comme dire, on veut un jus d’orange, mais on lui passe un champ d’orangers. Powershell nous donne notre jus d’orange à partir de quelque chose de complexe.

En fait bien que l’objet soit du type [system.IO.FileSystemInfo] Powershell voit qu’on lui demande une simple [string] (c’est défini dans notre liste de paramètres) et nous rend l’information essentielle, c-a-d le nom du fichier.

Nous pouvons par contre augmenter notre liste de paramètres pour lister certaines propriétés de l’objet passé, un objet [system.IO.FileSystemInfo] contient par exemple les variables membres Name et LastAccessTime. Nous pouvons donc déclarer:

A noter que nous avons utilisé ValueFromPipelinebyPropertyName. Dans ce cas, Powershell remplira ces paramètres avec les variables équivalentes trouvées dans l’objet passé.

Il faudra bien sur s’assurer que chaque variable déclarée dans la cmdlet est bien remplie avant de l’utiliser. Powershell ne remplira que les variables qui peuvent être remplies que si l’information est disponible et si Powershell peut trouver un paramètre adéquat.

 

A suivre…

Partager ce contenu

Une réflexion au sujet de « Premiers pas »

  1. Ping : Announcing our 2015 PowerShell Heroes | PowerShell.org

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *