Windows PowerShell La puissance des variables

Don Jones

Si vous travaillez avec un langage de script Windows, tel que VBScript ou KiXtart, vous êtes habitué à ce que les variables ne soient rien de plus qu’une sorte de mécanisme de stockage des données. Windows PowerShell dispose également de variables, mais elles sont beaucoup plus puissantes que les variables des anciens langages de script. Les variables Windows

Les variables PowerShell sont en fait mappées aux classes sous-jacentes de l’infrastructure Microsoft® .NET Framework. Dans cette infrastructure, les variables sont des objets, ce qui signifie qu’elles peuvent contenir des données, mais également les manipuler de nombreuses manières. En fait, les capacités robustes des variables dans Windows PowerShell™ sont la raison pour laquelle le langage de script Windows PowerShell ne contient pas de fonctions de manipulation de données intrinsèques. Ces fonctions ne sont pas nécessaires car les variables fournissent déjà cette fonctionnalité.

Déclaration des variables

Bien que le cmdlet New-Variable de Windows PowerShell vous permette de déclarer une variable et de lui affecter une valeur initiale, vous n’avez pas à l’utiliser. Vous pouvez au lieu de cela créer immédiatement une nouvelle variable en lui attribuant une valeur :

$var = "Hello"

Dans Windows PowerShell, les noms de variables démarrent toujours avec un signe dollar ($) et peuvent contenir un mélange de lettres, chiffres, symboles ou même espaces (toutefois, si vous utilisez des espaces, vous devez encadrer la variable de crochets, comme dans ${Ma Variable} = "Hello"). Cet exemple a créé une nouvelle variable nommée $var et lui a attribué la valeur initiale "Hello". Puisque la valeur est dans ce cas une chaîne de caractères, Windows PowerShell utilisera le type de données String pour enregistrer la valeur. Dans .NET Framework, il s’agit de la classe System.String, qui a peut-être les fonctionnalités les plus intégrées de tous les types de variables. Si je souhaite par exemple obtenir une version en minuscules de la valeur stockée dans $var, je peux faire ceci :

PS C:\> $var.ToLower()
hello
PS C:\>

La méthode ToLower est intégrée à la classe System.String et produit une représentation en minuscules uniquement de la valeur de la chaîne. Elle ne modifie toutefois pas le contenu véritable de la variable $var. Pour voir une liste complète des capacités de la classe System.String, redirigez une variable chaîne vers cmdlet Get-Member, comme ceci :

$var | get-member

La figure 1 affiche le résultat, qui comprend plus d’une vingtaine de méthodes utilisées pour manipuler des chaînes. La quasi-totalité des fonctionnalités offertes par les fonctions de manipulation de chaînes VBScript est fournie à la place par les méthodes d’une variable de chaîne dans Windows PowerShell.

Figure 1** Aperçu du résultat de la classe System.String. **(Cliquer sur l'image pour l'agrandir)

De nombreuses capacités des chaînes variables sont plus utiles dans un contexte administratif que dans les fonctions de chaînes d’un langage tel que VBScript. Imaginez que vous avez écrit un script qui lit les chemins d’accès UNC (Universal Naming Convention, convention de dénomination universelle) des fichiers et les utilise ensuite. Il est préférable de vérifier que chaque chemin est bien de type UNC avant de tenter de l’utiliser. La méthode StartsWith permet de confirmer que la valeur d’une chaîne démarre avec les caractères de barre oblique inverse nécessaires à UNC :

PS C:\> $path = "\\Server\Share"
PS C:\> $path.StartsWith("\\")
True
PS C:\>

Comme StartsWith renvoie une valeur booléenne True (Vrai) ou False (Faux), il est possible de l’utiliser dans les constructions logiques :

if ($path.StartsWith("\\")) {
 # code goes here
}

Windows PowerShell fournit même une forme de saisie automatique des méthodes des variables, ce qui réduit la quantité de frappe nécessaire. Si $var contient une chaîne, vous pouvez taper

$var. 

et appuyer ensuite sur la touche Tabulation pour afficher le nom de la première méthode de la variable $var. Vous accéderez à la méthode suivante en appuyant de nouveau sur la touche Tabulation, et à la méthode précédente avec Maj+Tabulation. Vous pouvez ainsi parcourir toutes les méthodes disponibles jusqu’à ce que vous trouviez celle que vous voulez.

Confusion et variables

Jusqu’ici, mes exemples ont permis à Windows PowerShell de déterminer le type de données de mes variables. L’affectation d’une chaîne à une variable force principalement la variable à appartenir à la classe System.String. L’affectation d’un nombre à une variable, par contre, a habituellement pour résultat de transformer la variable en un entier (ou, plus précisément, un type Int32, qui peut contenir une plage spécifique de valeurs). Prenez par exemple ceci :

PS C:\> $int = 5
PS C:\> $int | get-member

  TypeName: System.Int32

Cette sortie tronquée montre que Windows PowerShell traite $int comme un Int32, qui dispose de son propre ensemble de méthodes et de propriétés. Son ensemble de méthodes et de propriétés est en fait beaucoup plus réduit que celui du type String.

$Int a été transformé en Int32 car sa valeur n’était pas encadrée de guillemets et qu’elle se composait exclusivement de chiffres. Si elle avait été encadrée de guillemets, il aurait été interprété comme System.String.

Autoriser Windows PowerShell à décider du type de données à utiliser ne produira pas toujours le résultat que vous voulez. Supposez que vous lisez des valeurs d’un fichier et souhaitez que les valeurs soient toujours traitées comme des chaînes. Certaines valeurs peuvent cependant contenir seulement des chiffres, ce qui accroît la possibilité que Windows PowerShell les traite comme des Int32 ou un autre type numérique. Cela peut provoquer des problèmes pour votre script. Si Windows PowerShell ne reconnaît pas la valeur comme étant une chaîne, toutes les méthodes de la classe System.String ne sont alors pas disponibles (et votre script pourrait compter sur l’une des méthodes indisponibles).

Pour remédier à ceci, vous pouvez forcer Windows PowerShell à traiter une variable comme un certain type en déclarant ce type lors de votre première utilisation de la variable. Voici un exemple :

[string]$var = 5

Normalement, $var aurait été un Int32, mais j’ai ici forcé Windows PowerShell à faire de $var une chaîne, pour m’assurer ainsi que je peux utiliser toutes les méthodes associées à la classe System.String. La déclaration du type de variable offre également un type pratique d’auto-documentation du code, car le type de données devant entrer dans $var est alors évident. En fait, j’ai pris l’habitude de toujours déclarer un type spécifique pour toutes mes variables et d’empêcher complètement Windows PowerShell de prendre cette décision. Mes scripts sont ainsi plus prévisibles et cela m’a permis dans plusieurs cas d’économiser une quantité importante de temps de débogage.

Comme on peut s’y attendre, la déclaration de force des variables a des répercussions, bien qu’elles ne soient pas nécessairement mauvaises. Prenez cet exemple, dans lequel le type de la variable n’est pas déclaré :

PS C:\> $me = 5
PS C:\> $me = "Don"

La variable $me était initialement un Int32, mais Windows PowerShell l’a changée en String lorsque la valeur « Don » a été ajoutée. Windows PowerShell peut modifier le type d’une variable selon la nécessité, pourvu que la variable n’ait pas déjà été explicitement affectée d’un type spécifique.

Dans cet exemple, j’ai forcé $me à être un Int32 en utilisant le nom de type [int] :

PS C:\> [int]$me = 5
PS C:\> $me = "Don"
Cannot convert value "Don" to type 
"System.Int32". Error: "Input string 
was not in a correct format."
At line:1 char:4
+ $me <<<< = "Don"

Ensuite, lorsque j’ai essayé de lui affecter une valeur de chaîne, un message d’erreur s’est affiché. Puisque j’avais forcé explicitement $me à être un Int32, Windows PowerShell s’attendait à convertir la chaîne « Don » en valeur entière. Il n’a pas pu le faire et n’a pas non plus pu changer le type de $me en String.

Tous ces types

De nombreux types sont disponibles dans Windows PowerShell. Vous pouvez en fait utiliser tout type .NET Framework (et ses types disponibles se comptent par centaines). Cependant, Windows PowerShell définit plusieurs raccourcis pour les types de données communs. La figure 2 est seulement une liste partielle qui contient 10 des raccourcis de types les plus habituellement utilisés. Pour la liste complète, reportez-vous à la documentation de Windows PowerShell.

Figure 2 Raccourcis de types communs

Vous pouvez également déclarer le type d’une variable à l’aide du nom de classe .NET Framework complet, comme ceci :

[System.Int32]$int = 5

Cette technique vous permet d’utiliser des types qui sont dans .NET Framework mais ne disposent pas d’un raccourci spécifique dans Windows PowerShell.

Extension des types

Le plus intéressant avec Windows PowerShell est peut-être sa possibilité d’étendre les capacités de ces types de variables. Dans le dossier d’installation de Windows PowerShell (généralement %systemroot\system32\windowspowershell\v1.0, même si le chemin est un peu différent sur les systèmes 64 bits), vous trouverez un fichier appelé types.ps1xml. Vous pouvez modifier ce fichier dans le Bloc-notes ou dans un éditeur XML tel que PrimalScript. Par défaut, la classe System.String n’est pas listée, bien que de nombreux autres types le soient. Cependant, je peux ajouter une nouvelle capacité au type System.String en ajoutant ceci au fichier types.ps1xml.

Après avoir effectué la modification, je dois fermer et rouvrir Windows PowerShell. Je dois également m’assurer que la stratégie d’exécution de scripts locale autorise les scripts non signés à s’exécuter, puisque je n’ai pas signé types.ps1xml :

Set-executionpolicy remotesigned

Maintenant, après avoir redémarré Windows PowerShell, je peux utiliser la nouvelle fonctionnalité, comme ceci :

PS C:\> [string]$comp = "localhost"
PS C:\> $comp.canping
True
PS C:\>

Comme vous pouvez le voir, j’ai ajouté une propriété CanPing à la classe System.String. Elle renvoie True (Vrai) ou False (Faux) pour indiquer si l’ordinateur local est capable d’exécuter une commande ping sur l’adresse contenue dans la chaîne. Dans la figure 3, vous remarquerez que la requête WMI utilise une variable spéciale, $this. La variable $this représente la valeur actuelle contenue dans la chaîne et constitue la manière dont le contenu de la variable de chaîne est passé dans la requête WMI.

Figure 3 Extension du type System.String

<Type>
  <Name>System.String</Name>
  <Members>
    <ScriptProperty>
      <Name>CanPing</Name>
      <GetScriptBlock>
      $wmi = get-wmiobject -query "SELECT *
FROM Win32_PingStatus WHERE Address = '$this'"
      if ($wmi.StatusCode -eq 0) {
        $true
      } else {
        $false
      }
      </GetScriptBlock>
    </ScriptProperty>
  </Members>
</Type>

Laissez une variable faire le travail

Windows PowerShell fournit des types de variables souples et riches en fonctionnalités, ainsi qu’un système tout aussi souple pour l’extension de la fonctionnalité des types. Ces capacités permettent d’intégrer une puissance importante à vos scripts. En fait, les variables peuvent devenir un bloc de construction majeur dans les scripts complexes, en s’appropriant dans de nombreux cas des capacités avancées que vous trouveriez normalement dans une fonction plus complexe.

En apprendre plus en ligne

Rejoignez-moi pour cette série de Webcasts diffusés le second mardi de chaque mois pour continuer à plonger dans les fonctionnalités de création de scripts riches offertes par Windows PowerShell. Consultez microsoft.com/events/series/donjonesscripting.mspx pour vous inscrire dès aujourd’hui.

20 février 2007 Windows PowerShell : Cours intensif de création de scripts

Participez à ce Webcast pour en apprendre plus sur les variables, les constructions de langage, les scripts et les fonctions de Windows PowerShell. Avec ce cours intensif d’une heure, nous démontrons comment le langage de création de scripts simple mais efficace de Windows PowerShell accélère l’automatisation administrative de Windows®. Nous explorons également plusieurs outils de fournisseurs tiers qui facilitent l’écriture de scripts Windows PowerShell.

20 mars 2007 Windows PowerShell : Fonctions, filtres et efficacité

Apprenez à créer un code modularisé et efficace dans les fonctions et les filtres de Windows PowerShell. Nous explorons les règles robustes de portée de Windows PowerShell vous permettant d’encapsuler totalement des fonctions et des filtres et expliquons comment réemployer facilement ces fonctions et ces filtres avec des projets différents. Nous démontrons également comment vous pouvez ajouter vos propres fonctions personnalisées à la portée globale de Windows PowerShell, ce qui permet de créer facilement une bibliothèque de fonctions utilitaires.

17 avril 2007 Windows PowerShell et Windows Management Instrumentation

Windows PowerShell peut accéder à toute la puissance et à toutes les capacités de Windows Management Instrumentation, ou WMI. Nous décrivons non seulement comment utiliser Windows PowerShell pour accéder à WMI, mais également comment passer des objets et des collections WMI au travers du pipeline de Windows PowerShell. Nous explorons comment utiliser les propriétés de WMI et les méthodes des scripts Windows PowerShell et illustrons les fonctionnalités de sécurité et de configuration sous-jacentes de WMI.

22 mai 2007 Windows PowerShell : Conversion depuis VBScript

Vous souhaitez convertir vos scripts, ou peut-être seulement vos compétences, de VBScript vers Windows PowerShell ? Rejoignez ce Webcast pour découvrir comment y parvenir. Nous explorons comment Windows PowerShell inclut toutes les constructions et les fonctionnalités majeures de VBScript, et facilite ainsi la conversion de votre expérience de VBScript vers ce nouvel environnement administratif. Nous illustrons comment convertir des outils de VBScript vers le langage de création de scripts natif de Windows PowerShell. Nous examinons également la structure unique de Windows PowerShell et vous montrons comment commencer à utiliser le langage de création de scripts Windows PowerShell pour que votre travail soit plus efficace et plus performant.

19 juin 2007 Windows PowerShell : Extensions sous le capot

Au cours de ce Webcast, nous explorons comment Windows PowerShell utilise la puissance et la flexibilité de .NET Framework pour contrôler des données et vous procurer des centaines de fonctions intégrées pour la gestion des chaînes, des dates et d’autres types de données. Mais saviez-vous que vous pouvez étendre ces fonctions en utilisant des scripts Windows PowerShell ? Nous vous montrons comment créer des variables de chaîne qui contiennent non seulement un nom d’ordinateur mais peuvent également indiquer si cet ordinateur est en cours de fonctionnement. Apprenez à créer des variables de date et d’heure qui peuvent formater automatiquement leurs données sans avoir recours à des fonctions externes. Prenez part à cette session pour découvrir comment mettre en place toutes sortes de nouvelles fonctionnalités dans Windows PowerShell en quelques minutes seulement, pour une administration encore plus facile et rapide de Windows.

Don Jones est directeur des projets et services de SAPIEN Technologies et co-auteur de Windows PowerShell : TFM (SAPIEN Press). Vous pouvez contacter Don sur le site www.ScriptingAnswers.com.

© 2008 Microsoft Corporation et CMP Media, LLC. Tous droits réservés. Toute reproduction, totale ou partielle, est interdite sans autorisation préalable.