Partager via

about_Scopes

  • Article

Description courte

Explique le concept d’étendue dans PowerShell et montre comment définir et modifier l’étendue des éléments.

Description longue

PowerShell protège l’accès aux variables, alias, fonctions et lecteurs PowerShell (PSDrives) en limitant leur emplacement de lecture et de modification. PowerShell utilise des règles d’étendue pour vous assurer que vous n’apportez pas de modifications involontaires aux éléments d’autres étendues.

Règles d’étendue

Lorsque vous démarrez PowerShell, l’hôte (pwsh.exe) crée un runspace PowerShell. Les processus hôtes peuvent avoir plusieurs espaces d’exécution. Chaque runspace a son propre état de session et conteneurs d’étendue. L’état et les étendues de session ne sont pas accessibles sur les instances d’instance d’exécution.

Voici les règles de base de l’étendue :

  • Les étendues peuvent être imbriquées. Une étendue externe est appelée étendue parente. Toutes les étendues imbriquées sont des étendues enfants de ce parent.
  • Un élément est visible dans l’étendue qu’il a été créé et dans toutes les étendues enfants, sauf si vous le rendez explicitement privé.
  • Vous pouvez déclarer des variables, des alias, des fonctions et des lecteurs PowerShell pour une étendue en dehors de l’étendue actuelle.
  • Un élément que vous avez créé dans une étendue ne peut être modifié que dans l’étendue dans laquelle elle a été créée, sauf si vous spécifiez explicitement une autre étendue.
  • Lorsque le code s’exécutant dans un espace d’exécution fait référence à un élément, PowerShell recherche la hiérarchie d’étendue, en commençant par l’étendue actuelle et en passant par chaque étendue parente.
    • Si l’élément est introuvable, un nouvel élément est créé dans l’étendue actuelle.
    • S’il trouve une correspondance, la valeur de l’élément est récupérée à partir de l’étendue où est trouvé.
    • Si vous modifiez la valeur, l’élément est copié dans l’étendue actuelle afin que la modification affecte uniquement l’étendue actuelle.
  • Si vous créez explicitement un élément qui partage son nom avec un élément dans une autre étendue, l’élément d’origine peut être masqué par le nouvel élément, mais il n’est pas remplacé ou modifié.

Étendues parent et enfant

Vous pouvez créer une étendue enfant en appelant un script ou une fonction. L’étendue appelante est l’étendue parente. Le script ou la fonction appelé est l’étendue enfant. Les fonctions ou scripts que vous appelez peuvent appeler d’autres fonctions, créant une hiérarchie d’étendues enfants dont l’étendue racine est l’étendue globale.

Remarque

Les fonctions d’un module ne s’exécutent pas dans une étendue enfant de l’étendue appelante. Les modules ont leur propre état de session lié à l’étendue dans laquelle le module a été importé. Tout le code de module s’exécute dans une hiérarchie spécifique au module des étendues qui a sa propre étendue racine. Pour plus d’informations, consultez la section Modules de cet article.

Lorsqu’une étendue enfant est créée, elle inclut tous les alias et variables qui ont l’option AllScope et certaines variables automatiques. Cette option est abordée plus loin dans cet article.

À moins que vous ne rendiez explicitement les éléments privés, les éléments de l’étendue parente sont disponibles pour l’étendue enfant. Les éléments que vous créez ou modifiez dans une étendue enfant n’affectent pas l’étendue parente, sauf si vous spécifiez explicitement l’étendue lorsque vous créez les éléments.

Pour rechercher les éléments dans une étendue particulière, utilisez le paramètre Scope de Get-Variable ou Get-Alias.

Par exemple, pour obtenir toutes les variables dans l’étendue locale, tapez :

Get-Variable -Scope local

Pour obtenir toutes les variables dans l’étendue globale, tapez :

Get-Variable -Scope global

Lorsqu’une référence est faite à une variable, un alias ou une fonction, PowerShell recherche l’étendue actuelle. Si l’élément est introuvable, l’étendue parente est recherchée. Cette recherche est répétée jusqu’à l’étendue globale. Si une variable est privée dans une étendue parente, la recherche continue à travers la chaîne d’étendue. L’exemple 4 montre l’effet d’une variable privée dans une recherche d’étendue.

Noms des étendues PowerShell

PowerShell définit des noms pour certaines étendues afin d’autoriser l’accès plus facile à cette étendue. PowerShell définit les étendues nommées suivantes :

  • Global : étendue qui est en vigueur lorsque PowerShell démarre ou lorsque vous créez une session ou un espace d’exécution. Les variables et fonctions présentes au démarrage de PowerShell, telles que les variables automatiques et les variables de préférence, sont créées dans l’étendue globale. Les variables, alias et fonctions de vos profils PowerShell sont également créées dans l’étendue globale. L’étendue globale est l’étendue parente racine dans un runspace.
  • Local : étendue actuelle. L’étendue locale peut être l’étendue globale ou toute autre étendue.
  • Script : étendue créée pendant l’exécution d’un fichier de script. Les commandes du script s’exécutent dans l’étendue du script. Pour les commandes d’un script, l’étendue du script est l’étendue locale.

Pour les applets de commande qui prennent en charge les étendues, les étendues peuvent être référencées par un nombre qui décrit la position relative d’une étendue à une autre. L’étendue 0 indique l’étendue actuelle (locale), l’étendue 1 est le parent de l’étendue actuelle, l’étendue 2 est le grand-parent de l’étendue actuelle. Ce modèle se poursuit jusqu’à atteindre l’étendue racine.

Modificateurs d’étendue

Un nom de variable, d’alias ou de fonction peut inclure l’un des modificateurs d’étendue facultatifs suivants :

  • global: - Spécifie que le nom existe dans l’étendue globale .

  • local: - Spécifie que le nom existe dans l’étendue locale . L’étendue actuelle est toujours l’étendue locale .

  • private: - Spécifie que le nom est privé et visible uniquement dans l’étendue actuelle.

    Remarque

    private: n’est pas une étendue. Il s’agit d’une option qui modifie l’accessibilité d’un élément en dehors de l’étendue dans laquelle elle est définie.

  • script: - Spécifie que le nom existe dans l’étendue de script . L’étendue de script est l’étendue du fichier de script ancêtre le plus proche ou Global s’il n’existe aucun fichier de script ancêtre le plus proche.

  • using: - Utilisé pour accéder aux variables définies dans une autre étendue lors de l’exécution dans des sessions distantes, des travaux en arrière-plan ou des travaux de thread.

  • workflow: - Spécifie que le nom existe dans un flux de travail. Remarque : Les flux de travail ne sont pas pris en charge dans PowerShell v6 et versions ultérieures.

  • <variable-namespace> - Modificateur créé par un fournisseur PowerShell PSDrive . Par exemple :

    Espace de noms Description
    Alias: Alias définis dans l’étendue actuelle
    Env: Variables d’environnement définies dans l’étendue actuelle
    Function: Fonctions définies dans l’étendue actuelle
    Variable: Variables définies dans l’étendue actuelle

L’étendue par défaut des scripts est l’étendue du script. L’étendue par défaut pour les fonctions et les alias est l’étendue locale, même si elles sont définies dans un script.

Utilisation de modificateurs d’étendue

Pour spécifier l’étendue d’une nouvelle variable, d’un alias ou d’une fonction, utilisez un modificateur d’étendue.

La syntaxe d’un modificateur d’étendue dans une variable est la suivante :

$[<scope-modifier>:]<name> = <value>

La syntaxe d’un modificateur d’étendue dans une fonction est la suivante :

function [<scope-modifier>:]<name> {<function-body>}

La commande suivante, qui n’utilise pas de modificateur d’étendue, crée une variable dans l’étendue actuelle ou locale :

$a = "one"

Pour créer la même variable dans l’étendue globale , utilisez le modificateur d’étendue global: :

$global:a = "one"
Get-Variable a | Format-List *

Notez les valeurs des propriétés Visibility et Options .

Name        : a
Description :
Value       : one
Visibility  : Public
Module      :
ModuleName  :
Options     : None
Attributes  : {}

Comparez-le à une variable privée :

$private:pVar = 'Private variable'
Get-Variable pVar | Format-List *

L’utilisation du modificateur d’étendue private définit la propriété Options sur Private.

Name        : pVar
Description :
Value       : Private variable
Visibility  : Public
Module      :
ModuleName  :
Options     : Private
Attributes  : {}

Pour créer la même variable dans l’étendue du script , utilisez le modificateur d’étendue script: :

$script:a = "one"

Vous pouvez également utiliser un modificateur d’étendue avec des fonctions. La définition de fonction suivante crée une fonction dans l’étendue globale :

function global:Hello {
  Write-Host "Hello, World"
}

Vous pouvez également utiliser des modificateurs d’étendue pour faire référence à une variable dans une autre étendue. La commande suivante fait référence à la $test variable, d’abord dans l’étendue locale, puis dans l’étendue globale :

$test
$global:test

Modificateur d’étendue using:

L’utilisation est un modificateur d’étendue spécial qui identifie une variable locale dans une commande distante. Sans modificateur, PowerShell s’attend à ce que les variables dans les commandes distantes soient définies dans la session distante.

Le using modificateur d’étendue est introduit dans PowerShell 3.0.

Pour tout script ou commande qui s’exécute hors session, vous avez besoin du using modificateur d’étendue pour incorporer des valeurs de variable à partir de l’étendue de session appelante, afin que le code hors session puisse y accéder. Le using modificateur d’étendue est pris en charge dans les contextes suivants :

  • Commandes exécutées à distance, démarrées à Invoke-Command l’aide des paramètres ComputerName, HostName, SSHConnection ou Session (session distante)
  • Travaux en arrière-plan, démarrés avec Start-Job (session hors processus)
  • Travaux de thread, démarrés via Start-ThreadJob ou ForEach-Object -Parallel (session de thread distincte)

Selon le contexte, les valeurs de variables incorporées sont soit des copies indépendantes des données dans l’étendue de l’appelant, soit des références à celles-ci. Dans les sessions distantes et hors processus, elles sont toujours des copies indépendantes.

Pour plus d’informations, consultez about_Remote_Variables.

Une $using: référence s’étend uniquement à la valeur d’une variable. Si vous souhaitez modifier la valeur d’une variable dans l’étendue de l’appelant, vous devez avoir une référence à la variable elle-même. Vous pouvez créer une référence à une variable en obtenant l’instance PSVariable de la variable. L’exemple suivant montre comment créer une référence et apporter des modifications dans un travail de thread.

$Count = 1
$refOfCount = Get-Variable Count

Start-ThreadJob {
    ($using:refOfCount).Value = 2
} | Receive-Job -Wait -AutoRemoveJob

$Count

2

Remarque

Il ne s’agit pas d’une opération thread-safe. Vous pouvez provoquer une altération des données si vous essayez de modifier la valeur de plusieurs threads en même temps. Vous devez utiliser des types de données thread-safe ou des primitives de synchronisation pour protéger les données partagées. Pour plus d’informations, consultez collections Thread-Safe.

Sérialisation des valeurs de variables

Les commandes exécutées à distance et les travaux en arrière-plan s’exécutent hors processus. Les sessions hors processus utilisent la sérialisation et la désérialisation basées sur XML pour rendre les valeurs des variables disponibles dans les limites du processus. Le processus de sérialisation convertit les objets en objet PSObject qui contient les propriétés d’objets d’origine, mais pas ses méthodes.

Pour un ensemble limité de types, la désérialisation réhydrate les objets vers le type d’origine. L’objet réhydraté est une copie de l’instance d’objet d’origine. Il a les propriétés et méthodes de type. Pour les types simples, tels que System.Version, la copie est exacte. Pour les types complexes, la copie est parfaite. Par exemple, les objets de certificat réhydratés n’incluent pas la clé privée.

Les instances de tous les autres types sont des instances PSObject . La propriété PSTypeNames contient le nom de type d’origine préfixé par Désérialized, par exemple , Deserialized.System.Data.DataTable

The AllScope Option

Les variables et les alias ont une propriété Option qui peut prendre une valeur de AllScope. Les éléments dont la propriété AllScope fait partie des étendues enfants que vous créez, bien qu’ils ne soient pas hérités rétroactivement par les étendues parentes.

Un élément qui a la propriété AllScope est visible dans l’étendue enfant et fait partie de cette étendue. Les modifications apportées à l’élément dans n’importe quelle étendue affectent toutes les étendues dans lesquelles la variable est définie.

Gestion de l’étendue

Plusieurs applets de commande ont un paramètre Scope qui vous permet d’obtenir ou de définir (créer et modifier) des éléments dans une étendue particulière. Utilisez la commande suivante pour rechercher toutes les applets de commande de votre session qui ont un paramètre Scope :

Get-Help * -Parameter scope

Pour rechercher les variables visibles dans une étendue particulière, utilisez le Scope paramètre .Get-Variable Les variables visibles incluent des variables globales, des variables dans l’étendue parente et des variables dans l’étendue actuelle.

Par exemple, la commande suivante obtient les variables visibles dans l’étendue locale :

Get-Variable -Scope local

Pour créer une variable dans une étendue particulière, utilisez un modificateur d’étendue ou le paramètre Scope de Set-Variable. La commande suivante crée une variable dans l’étendue globale :

New-Variable -Scope global -Name a -Value "One"

Vous pouvez également utiliser le paramètre Scope du , Set-Aliasou Get-Alias des applets de New-Aliascommande pour spécifier l’étendue. La commande suivante crée un alias dans l’étendue globale :

New-Alias -Scope global -Name np -Value Notepad.exe

Pour obtenir les fonctions dans une étendue particulière, utilisez l’applet Get-Item de commande lorsque vous êtes dans l’étendue. L’applet Get-Item de commande n’a pas de paramètre Scope .

Remarque

Pour les applets de commande qui utilisent le paramètre Scope , vous pouvez également faire référence à des étendues par nombre. Le nombre décrit la position relative d’une étendue à une autre. L’étendue 0 représente l’étendue actuelle ou locale. L’étendue 1 indique l’étendue parente immédiate. L’étendue 2 indique le parent de l’étendue parente, et ainsi de suite. Les étendues numérotées sont utiles si vous avez créé de nombreuses étendues récursives.

Utilisation de la notation dot-source avec étendue

Les scripts et les fonctions suivent les règles d’étendue. Vous les créez dans une étendue particulière et elles affectent uniquement cette étendue, sauf si vous utilisez un paramètre d’applet de commande ou un modificateur d’étendue pour modifier cette étendue.

Toutefois, vous pouvez ajouter le contenu d’un script ou d’une fonction à l’étendue actuelle à l’aide de la notation dot-source. Lorsque vous exécutez un script ou une fonction à l’aide de la notation dot-source, elle s’exécute dans l’étendue actuelle. Toutes les fonctions, alias et variables du script ou de la fonction sont ajoutées à l’étendue actuelle.

Par exemple, pour exécuter le Sample.ps1 script à partir du C:\Scripts répertoire dans l’étendue du script (valeur par défaut pour les scripts), entrez simplement le chemin complet du fichier de script sur la ligne de commande.

c:\scripts\sample.ps1

Un fichier de script doit avoir une .ps1 extension de fichier à exécutable. Les fichiers qui ont des espaces dans leur chemin doivent être placés entre guillemets. Si vous essayez d’exécuter le chemin entre guillemets, PowerShell affiche le contenu de la chaîne entre guillemets au lieu d’exécuter le script. L’opérateur d’appel (&) vous permet d’exécuter le contenu de la chaîne contenant le nom de fichier.

L’utilisation de l’opérateur d’appel pour exécuter une fonction ou un script l’exécute dans l’étendue du script. L’utilisation de l’opérateur d’appel n’est pas différente de l’exécution du script par nom.

& c:\scripts\sample.ps1

Vous pouvez en savoir plus sur l’opérateur d’appel dans about_Operators.

Pour exécuter le Sample.ps1 script dans l’étendue locale, tapez un point et un espace (. ) avant le chemin d’accès au script :

. c:\scripts\sample.ps1

À présent, toutes les fonctions, alias ou variables définies dans le script sont ajoutées à l’étendue actuelle.

Restriction sans étendue

PowerShell propose certaines options et fonctionnalités similaires à l’étendue et peuvent interagir avec les étendues. Ces fonctionnalités peuvent être confondues avec l’étendue ou le comportement de l’étendue.

Les sessions, les modules et les invites imbriquées sont des environnements autonomes, et non des étendues enfants de l’étendue globale dans la session.

Sessions

Une session est un environnement dans lequel PowerShell s’exécute. Lorsque vous créez une session sur un ordinateur distant, PowerShell établit une connexion persistante à l’ordinateur distant. La connexion persistante vous permet d’utiliser la session pour plusieurs commandes associées.

Étant donné qu’une session est un environnement autonome, elle a sa propre étendue, mais une session n’est pas une étendue enfant de la session dans laquelle elle a été créée. La session commence par sa propre étendue globale. Cette étendue est indépendante de l’étendue globale de la session. Vous pouvez créer des étendues enfants dans la session. Par exemple, vous pouvez exécuter un script pour créer une étendue enfant dans une session.

Modules

Vous pouvez utiliser un module PowerShell pour partager et fournir des outils PowerShell. Un module est une unité qui peut contenir des applets de commande, des scripts, des fonctions, des variables, des alias et d’autres éléments utiles. À moins d’être exportés explicitement (à l’aide Export-ModuleMember ou au manifeste du module), les éléments d’un module ne sont pas accessibles en dehors du module. Par conséquent, vous pouvez ajouter le module à votre session et utiliser les éléments publics sans vous soucier que les autres éléments peuvent remplacer les applets de commande, les scripts, les fonctions et d’autres éléments de votre session.

Par défaut, les modules sont chargés dans l’étendue de niveau racine (global) de l’espace d’exécution. L’importation d’un module ne modifie pas l’étendue. Au sein de la session, les modules ont leur propre étendue. Considérez le module C:\temp\mod1.psm1suivant :

$a = "Hello"

function foo {
    "`$a = $a"
    "`$global:a = $global:a"
}

À présent, nous créons une variable $aglobale, donnez-lui une valeur et appelons la fonction foo.

$a = "Goodbye"
foo

Le module déclare la variable $a dans l’étendue du module, puis la fonction foo génère la valeur de la variable dans les deux étendues.

$a = Hello
$global:a = Goodbye

Les modules créent des conteneurs d’étendue parallèles liés à l’étendue dans laquelle ils ont été importés. Les éléments exportés par le module sont disponibles à partir du niveau d’étendue dans lequel ils sont importés. Les éléments non exportés à partir du module ne sont disponibles que dans le conteneur d’étendue du module. Les fonctions du module peuvent accéder aux éléments de l’étendue dans laquelle ils ont été importés, ainsi qu’aux éléments du conteneur d’étendue du module.

Si vous chargez Module2 à partir de Module1, Module2 est chargé dans le conteneur d’étendue de Module1. Toutes les exportations de Module2 sont placées dans l’étendue actuelle du module Module1. Si vous utilisez Import-Module -Scope local, les exportations sont placées dans l’objet d’étendue actuel plutôt qu’au niveau supérieur. Si vous êtes dans un module et que vous chargez un autre module à l’aide Import-Module -Scope global (ou Import-Module -Global), ce module et ses exportations sont chargés dans l’étendue globale au lieu de l’étendue locale du module. La fonctionnalité WindowsCompatibility effectue cette opération pour importer des modules proxy dans l’état de session global.

Invites imbriquées

Les invites imbriquées n’ont pas leur propre étendue. Lorsque vous entrez une invite imbriquée, l’invite imbriquée est un sous-ensemble de l’environnement. Mais vous restez dans l’étendue locale.

Les scripts ont leur propre étendue. Si vous déboguez un script et que vous atteignez un point d’arrêt dans le script, vous entrez l’étendue du script.

Option privée

Les alias et les variables ont une propriété Option qui peut prendre la valeur Private. Les éléments qui ont l’option Private peuvent être affichés et modifiés dans l’étendue dans laquelle ils sont créés, mais ils ne peuvent pas être affichés ou modifiés en dehors de cette étendue.

Par exemple, si vous créez une variable qui a une option privée dans l’étendue globale, puis exécutez un script, Get-Variable les commandes du script n’affichent pas la variable privée. L’utilisation du modificateur d’étendue globale dans cette instance n’affiche pas la variable privée.

Vous pouvez utiliser le paramètre Option des applets de commande , Set-Variableet New-AliasSet-Alias les applets de New-Variablecommande pour définir la valeur de la propriété Option sur Private.

Visibilité

La propriété Visibility d’une variable ou d’un alias détermine si vous pouvez voir l’élément en dehors du conteneur, dans lequel il a été créé. Un conteneur peut être un module, un script ou un composant logiciel enfichable. La visibilité est conçue pour les conteneurs de la même façon que la Private valeur de la propriété Option est conçue pour les étendues.

La propriété Visibility prend les valeurs et Private les Public valeurs. Les éléments qui ont une visibilité privée peuvent être affichés et modifiés uniquement dans le conteneur dans lequel ils ont été créés. Si le conteneur est ajouté ou importé, les éléments qui ont une visibilité privée ne peuvent pas être affichés ni modifiés.

Étant donné que la visibilité est conçue pour les conteneurs, elle fonctionne différemment dans une étendue.

  • Si vous créez un élément qui a une visibilité privée dans l’étendue globale, vous ne pouvez pas afficher ou modifier l’élément dans n’importe quelle étendue.
  • Si vous essayez d’afficher ou de modifier la valeur d’une variable ayant une visibilité privée, PowerShell retourne un message d’erreur.

Vous pouvez utiliser les New-Variable applets de commande et Set-Variable les applets de commande pour créer une variable qui a une visibilité privée.

Exemples

Exemple 1 : Modifier une valeur de variable uniquement dans un script

La commande suivante modifie la valeur de la $ConfirmPreference variable dans un script. La modification n’affecte pas l’étendue globale.

Tout d’abord, pour afficher la valeur de la $ConfirmPreference variable dans l’étendue locale, utilisez la commande suivante :

PS>  $ConfirmPreference
High

Créez un script Scope.ps1 qui contient les commandes suivantes :

$ConfirmPreference = "Low"
"The value of `$ConfirmPreference is $ConfirmPreference."

Exécutez le script. Le script modifie la valeur de la $ConfirmPreference variable, puis signale sa valeur dans l’étendue du script. La sortie doit ressembler à la sortie suivante :

The value of $ConfirmPreference is Low.

Ensuite, testez la valeur actuelle de la $ConfirmPreference variable dans l’étendue actuelle.

PS>  $ConfirmPreference
High

Cet exemple montre que les modifications apportées à la valeur d’une variable dans l’étendue du script n’affectent pas la valeur de la variable dans l’étendue parente.

Exemple 2 : Afficher une valeur de variable dans différentes étendues

Vous pouvez utiliser des modificateurs d’étendue pour afficher la valeur d’une variable dans l’étendue locale et dans une étendue parente.

Tout d’abord, définissez une $test variable dans l’étendue globale.

$test = "Global"

Ensuite, créez un Sample.ps1 script qui définit la $test variable. Dans le script, utilisez un modificateur d’étendue pour faire référence aux versions globales ou locales de la $test variable.

Dans Sample.ps1 :

$test = "Local"
"The local value of `$test is $test."
"The global value of `$test is $global:test."

Lorsque vous exécutez Sample.ps1, la sortie doit ressembler à la sortie suivante :

The local value of $test is Local.
The global value of $test is Global.

Une fois le script terminé, seule la valeur globale de celle-ci $test est définie dans la session.

PS> $test
Global

Exemple 3 : Modifier la valeur d’une variable dans une étendue parente

Sauf si vous protégez un élément à l’aide de l’option Privée ou d’une autre méthode, vous pouvez afficher et modifier la valeur d’une variable dans une étendue parente.

Tout d’abord, définissez une $test variable dans l’étendue globale.

$test = "Global"

Ensuite, créez un script Sample.ps1 qui définit la $test variable. Dans le script, utilisez un modificateur d’étendue pour faire référence aux versions globales ou locales de la $test variable.

Dans Sample.ps1 :

$global:test = "Local"
"The global value of `$test is $global:test."

Une fois le script terminé, la valeur globale de celle-ci $test est modifiée.

PS> $test
Local

Exemple 4 : Création d’une variable privée

Une variable peut être rendue privée à l’aide du modificateur d’étendue private: ou en créant la variable avec la propriété Option définie Privatesur . Les variables privées ne peuvent être consultées ou modifiées que dans l’étendue dans laquelle elles ont été créées.

Dans cet exemple, le ScopeExample.ps1 script crée cinq fonctions. La première fonction appelle la fonction suivante, qui crée une étendue enfant. L’une des fonctions a une variable privée qui ne peut être vue que dans l’étendue dans laquelle elle a été créée.

PS> Get-Content ScopeExample.ps1
# Start of ScopeExample.ps1
function funcA {
    "Setting `$funcAVar1 to 'Value set in funcA'"
    $funcAVar1 = "Value set in funcA"
    funcB
}

function funcB {
    "In funcB before set -> '$funcAVar1'"
    $private:funcAVar1 = "Locally overwrite the value - child scopes can't see me!"
    "In funcB after set  -> '$funcAVar1'"
    funcC
}

function funcC {
    "In funcC before set -> '$funcAVar1' - should be the value set in funcA"
    $funcAVar1 = "Value set in funcC - Child scopes can see this change."
    "In funcC after set  -> '$funcAVar1'"
    funcD
}

function funcD {
    "In funcD before set -> '$funcAVar1' - should be the value from funcC."
    $funcAVar1 = "Value set in funcD"
    "In funcD after set  -> '$funcAVar1'"
    '-------------------'
    ShowScopes
}

function ShowScopes {
    $funcAVar1 = "Value set in ShowScopes"
    "Scope [0] (local)  `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 0 -ValueOnly)'"
    "Scope [1] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 1 -ValueOnly)'"
    "Scope [2] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 2 -ValueOnly)'"
    "Scope [3] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 3 -ValueOnly)'"
    "Scope [4] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 4 -ValueOnly)'"
}
funcA
# End of ScopeExample.ps1
PS> .\ScopeExample.ps1

La sortie affiche la valeur de la variable dans chaque étendue. Vous pouvez voir que la variable privée n’est visible que dans funcB, l’étendue dans laquelle elle a été créée.

Setting $funcAVar1 to 'Value set in funcA'
In funcB before set -> 'Value set in funcA'
In funcB after set  -> 'Locally overwrite the value - child scopes can't see me!'
In funcC before set -> 'Value set in funcA' - should be the value set in funcA
In funcC after set  -> 'Value set in funcC - Child scopes can see this change.'
In funcD before set -> 'Value set in funcC - Child scopes can see this change.' - should be the value from funcC.
In funcD after set  -> 'Value set in funcD'
-------------------
Scope [0] (local)  $funcAVar1 = 'Value set in ShowScopes'
Scope [1] (parent) $funcAVar1 = 'Value set in funcD'
Scope [2] (parent) $funcAVar1 = 'Value set in funcC - Child scopes can see this change.'
Scope [3] (parent) $funcAVar1 = 'Locally overwrite the value - child scopes can't see me!'
Scope [4] (parent) $funcAVar1 = 'Value set in funcA'

Comme indiqué par la sortie de ShowScopes, vous pouvez accéder à des variables à partir d’autres étendues à l’aide Get-Variable et en spécifiant un nombre d’étendues.

Exemple 5 : Utilisation d’une variable locale dans une commande distante

Pour les variables d’une commande distante créée dans la session locale, utilisez le modificateur d’étendue using . PowerShell suppose que les variables dans les commandes distantes ont été créées dans la session distante.

La syntaxe est :

$using:<VariableName>

Par exemple, les commandes suivantes créent une $Cred variable dans la session locale, puis utilisent la $Cred variable dans une commande distante :

$Cred = Get-Credential
Invoke-Command $s {Remove-Item .\Test*.ps1 -Credential $using:Cred}

Le using modificateur d’étendue a été introduit dans PowerShell 3.0.

Voir aussi