Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. PowerShell Core et Windows PowerShell
  3. Variables et types de données
Extrait - PowerShell Core et Windows PowerShell Les fondamentaux du langage (2e édition)
Extraits du livre
PowerShell Core et Windows PowerShell Les fondamentaux du langage (2e édition)
4 avis
Revenir à la page d'achat du livre

Variables et types de données

Les variables

1. Création et affectation

La création de variables en PowerShell est vraiment chose facile. À l’inverse des véritables langages de programmation, PowerShell n’est pas un langage fortement typé, c’est-à-dire que les variables n’ont pas besoin d’être définies ni initialisées avant d’être utilisées. Ainsi, il suffit d’affecter via l’opérateur = une valeur à une variable et PowerShell se charge du reste, à savoir la créer en mémoire et déterminer son type. Ceci est le fonctionnement par défaut, mais nous verrons par la suite que nous pouvons faire en sorte de rendre PowerShell beaucoup moins permissif.

Exemple :


$variable = valeur d'un type quelconque
 
  • En tapant $var1 = 12 dans la console PowerShell, nous créons une variable du nom de var1 et lui affectons la valeur 12. PowerShell déterminera alors qu’il s’agit d’une valeur entière et lui affectera automatiquement le type int (integer).

  • En tapant $var2 = ’A’ nous réalisons la même opération que précédemment à l’exception que cette fois-ci var2 sera de type string (chaîne) même si cette dernière ne contient qu’un seul caractère.

    Bien que non recommandé, il est possible de créer des variables...

Les constantes

Les constantes sont des variables dont le contenu ne doit (et/ou ne peut) pas changer au cours du temps.

Bien qu’il soit possible de se contenter d’une simple affectation de variable, cette technique n’empêche pas une éventuelle modification du contenu de la variable. Ainsi, il est préférable d’utiliser la commande New-Variable ainsi que le paramètre -Option Constant, comme dans l’exemple ci-après :


PS > New-Variable -Name PI -Value 3.14 -Option Constant
 

De cette manière, nous sommes protégés du risque de modification du contenu. Pour nous en convaincre, essayons de voir ce qu’il se passe si nous essayons d’affecter une nouvelle valeur :


PS > $PI = 4 
 
Cannot overwrite variable PI because it is read-only or constant. 
At line:1 char:1 
+ $PI=4 
+ ~~~~~ 
    + CategoryInfo  : WriteError: (PI:String) [],  
SessionStateUnauthorized... 
    + FullyQualifiedErrorId : VariableNotWritable
 
Il est d’usage, afin de distinguer facilement une constante d’une variable dans un programme, de mettre son nom en majuscules.

Le paramètre -Option accepte également d’autres valeurs, telles que : None, ReadOnly, Constant, Private, AllScope, Unspecified.. Celles-ci peuvent s’avérer utiles afin de spécifier la visibilité d’une variable...

Types de données

Bien qu’en général, dans les scripts de tous les jours, nous nous contentions des types de données les plus basiques qui soient, il est néanmoins possible d’en utiliser un très grand nombre. En effet, comme PowerShell tire toute sa puissance du framework .NET, tous les types .NET sont potentiellement accessibles et utilisables.

Pour le moment, nous nous contenterons de vous parler des types les plus communément utilisés.

Type

Description

Int, Int32, Int64

Représente les entiers dans une plage comprise entre -2 147 483 648 et 2 147 483 647 inclus.

Le type de données int est stocké comme un entier de quatre octets (32 bits).

Double

Représente les nombres à virgule aussi grands que 10308 (positifs ou négatifs), avec une précision sur 15 chiffres, et aussi petits que 10-323 (64 bits).

Char

Représente n’importe lequel des 65 536 caractères Unicode sur deux octets (16 bits).

String

Représente une chaîne sous forme de suite de caractères Unicode.

Boolean

Représente une valeur booléene (true ou false).

Array

Représente un tableau contenant de multiples valeurs. Un tableau peut contenir des données de types différents.

Object, PSObject, PSCustomObject

Représente un objet généralement personnalisé....

Affectation manuelle de types et transtypage

Que les inconditionnels du « typage fort » se rassurent, il existe une alternative au typage automatique afin de rester maître du typage des variables. Pour ce faire, il nous faut définir le type souhaité entre crochets et placer ce dernier devant le nom de la variable, comme par exemple :


PS > [int]$var = 12
 

En écrivant cela, vous êtes sûr que la variable $var sera du type entier. Mais il n’y a aucune différence entre $var = 12 et [int]$var = 12, nous direz-vous ! Certes, pour l’instant l’intérêt est minime, mais lorsque vous serez de grands « powershelleurs » et que vos scripts commenceront à prendre de l’ampleur, le fait de déclarer vos variables avec un type associé rendra votre travail beaucoup plus compréhensible pour les autres mais permettra surtout d’éviter qu’une valeur d’un type différent ne lui soit affectée par erreur.

Exemple


PS > [int]$nombre = Read-Host 'Entrez un nombre '  
Entrez un nombre : cent 
 
Cannot convert value "cent" to type "System.Int32".  
Error: "Input string was not in a correct format."
 

Dans l’exemple ci-dessus, le texte saisi cent n’a pas été reconnu comme un nombre entier, il est donc...

Rendre obligatoires la déclaration et l’initialisation des variables

Une bonne pratique veut que l’on s’oblige à déclarer toutes nos variables dans un script, dans une fonction ou dans un bloc de script. En effet, à qui n’est-il jamais arrivé de chercher un bug dans un programme pendant des heures à cause d’une simple faute de frappe sur un nom de variable ?

Bien que ce comportement ne soit pas celui par défaut, il est possible d’imposer ce mode de fonctionnement grâce à l’utilisation de la commande Set-StrictMode.

Voici la syntaxe de cette commande :


PS > Get-Command Set-StrictMode -Syntax 
 
Set-StrictMode -Version <Version> [<CommonParameters>] 
Set-StrictMode -Off [<CommonParameters>]
 

Le paramètre -Version autorise les valeurs suivantes :

  • 1.0 :

  • Dans ce mode, toute référence à une variable non initialisée provoquera une erreur (sauf à l’intérieur d’une chaîne de caractères).

  • 2.0 :

  • Toute référence à une variable non initialisée provoquera une erreur (y compris à l’intérieur d’une chaîne).

  • Interdit toute référence à une propriété d’objet qui n’existe pas.

  • Interdit les appels de fonctions utilisant la même syntaxe que l’appel de méthodes....

Variables prédéfinies

1. Variables automatiques

PowerShell dispose de deux types de variables prédéfinies. Les variables automatiques qui stockent des informations de traitement, et les variables de préférence qui servent à définir le comportement de PowerShell.

Commençons par les variables automatiques :

Variable

Description

$$

Variable (d’usage peu fréquent) contenant la dernière valeur de la commande saisie dans la console.

$?

Variable contenant true si la dernière opération a réussi ou false dans le cas contraire.

Variable (d’usage peu fréquent) contenant le premier jeton de la dernière ligne reçue par l’environnement (c’est-à-dire le premier mot de la dernière commande tapée dans la console).

$_

Variable contenant l’objet courant transmis par le pipe |.

$AllNodes

Variable utilisée par DSC. Celle-ci contient les données de configuration passées via le paramètre -ConfigurationData.

$Args

Variable contenant un tableau des arguments passés à une fonction ou à un script.

$ConsoleFileName

Variable qui contient le chemin d’accès du fichier console (.psc1) qui a été utilisé en dernier dans la session.

$Error

Variable de type tableau contenant toutes les erreurs rencontrées depuis le lancement de la session PowerShell courante (cf. chapitre Gestion des erreurs et débogage).

$Event

Variable contenant l’événement courant traité dans le bloc de script d’une commande d’enregistrement d’événement, typiquement comme Register-ObjectEvent

$EventArgs

Variable contenant les arguments se rapportant à $Event. Comme cette dernière, $EventArgs est uniquement renseignée dans le bloc de script d’une commande d’enregistrement d’événement.

$EventSubscriber

Variable contenant le souscripteur se rapportant à $Event. Comme cette dernière, $EventSubscriber est uniquement renseignée dans le bloc de script d’une commande d’enregistrement d’événement.

$ExecutionContext

Variable contenant un objet EngineIntrinsics représentant le contexte d’exécution de l’hôte Windows PowerShell.

$False

Variable...

Portée des variables

La portée, appelée aussi « étendue » (scope en anglais), détermine la visibilité des variables (ou des fonctions). Dans cette partie, nous ne ferons qu’effleurer le sujet car il est très vaste et peut vite devenir complexe. Pour des explications plus détaillées, nous vous recommandons de consulter la rubrique d’aide About_Scopes.

La notion de portée est cependant importante, puisqu’elle garantit une indépendance des variables, ou du moins un mode de fonctionnement qu’il est utile de connaître afin d’éviter de probables interférences et autres effets indésirables.

Imaginez un instant que vous exécutiez un script et qu’une fois le script terminé vous souhaitiez vérifier une valeur en tapant son nom dans la console, aïe ! Ce n’est pas possible (par défaut, dans la console classique), car la variable n’est pas disponible ; ceci est tout simplement dû à la portée des variables.

PowerShell utilise la notion de portée parent et de portée enfant. Une portée enfant est une portée créée à l’intérieur d’une portée parent. C’est-à-dire qu’à chaque fois que nous exécutons une fonction, un script ou un bloc d’instructions, une nouvelle portée est créée. Et sauf spécification contraire de votre part, PowerShell définit qu’une variable peut être lue dans sa propre portée, ainsi que dans les portées enfants. Mais elle ne peut être modifiée que dans la portée où elle a été créée. De plus, les portées parentes ne peuvent ni lire ni modifier les variables définies dans leurs portées enfants. 

Le schéma ci-après...

Quantificateurs d’octets

L’une des caractéristiques de PowerShell est sa capacité à utiliser des quantificateurs d’octets. Ces derniers permettent de manipuler des multiples d’octets sans avoir à effectuer d’opération particulière. Les quantificateurs reconnus sont les suivants :

Quantificateur

Valeur

Description

Exemple d’utilisation

KB

1024

Kilo-octets

2KB --> 2048

MB

1024²

Mégaoctets

1MB --> 1048576, 2MB --> 2097152

GB

10243

Gigaoctets

1GB --> 1073741824, 10GB --> 10737418240

TB

10244

Téraoctets

1TB --> 1099511627776

PB

10245

Pétaoctets

1PB --> 1125899906842624

Historiquement, les scripteurs que nous sommes avons toujours contourné ces difficultés en faisant un peu de mathématiques : nous divisions un nombre d’octets par 1024, ce qui nous donnait des kilo-octets. On divisait ensuite par 1024 pour avoir des mégaoctets, etc. Mais il faut reconnaître que cela est bien plus pratique quand l’interpréteur de commandes gère cela nativement.

L’utilisation de ces quantificateurs est bien évidemment liée aux calculs de tailles, et cela est bien souvent le cas lorsqu’il s’agit de la capacité des disques ou de la mémoire, de la taille des fichiers ou des répertoires, etc.

Prenons pour exemple la requête CIM/WMI suivante qui retourne...