À propos des étenduesAbout Scopes

Description courteShort description

Explique le concept de portée dans PowerShell et montre comment définir et modifier l’étendue des éléments.Explains the concept of scope in PowerShell and shows how to set and change the scope of elements.

Description longueLong description

PowerShell protège l’accès aux variables, aux alias, aux fonctions et aux lecteurs PowerShell (PSDrives) en limitant l’emplacement où ils peuvent être lus et modifiés.PowerShell protects access to variables, aliases, functions, and PowerShell drives (PSDrives) by limiting where they can be read and changed. PowerShell utilise des règles d’étendue pour s’assurer que vous ne modifiez pas par inadvertance un élément qui ne doit pas être modifié.PowerShell uses scope rules to ensure that you do not inadvertently change an item that should not be changed.

Voici les règles de base de l’étendue :The following are the basic rules of scope:

  • Les étendues peuvent s’imbriquer.Scopes may nest. Une étendue externe est appelée étendue parente.An outer scope is referred to as a parent scope. Toutes les étendues imbriquées sont des portées enfants de ce parent.Any nested scopes are child scopes of that parent.

  • Un élément est visible dans l’étendue dans laquelle il a été créé et dans toutes les portées enfants, sauf si vous le rendez explicitement privé.An item is visible in the scope in which it was created and in any child scopes, unless you explicitly make it private. Vous pouvez placer des variables, des alias, des fonctions ou des lecteurs PowerShell dans une ou plusieurs étendues.You can place variables, aliases, functions, or PowerShell drives in one or more scopes.

  • Un élément que vous avez créé dans une étendue peut être modifié uniquement dans l’étendue dans laquelle il a été créé, sauf si vous spécifiez explicitement une autre portée.An item that you created within a scope can be changed only in the scope in which it was created, unless you explicitly specify a different scope.

Si vous créez un élément dans une étendue et que l’élément partage son nom avec un élément dans une étendue différente, l’élément d’origine peut être masqué sous le nouvel élément, mais il n’est pas substitué ou modifié.If you create an item in a scope, and the item shares its name with an item in a different scope, the original item might be hidden under the new item, but it is not overridden or changed.

Étendues PowerShellPowerShell Scopes

PowerShell prend en charge les étendues suivantes :PowerShell supports the following scopes:

  • Global : portée en vigueur au démarrage de PowerShell ou lorsque vous créez une nouvelle session ou une instance d’exécution.Global: The scope that is in effect when PowerShell starts or when you create a new session or runspace. Les variables et les fonctions qui sont présentes au démarrage de PowerShell ont été créées dans la portée globale, telles que les variables automatiques et les variables de préférence.Variables and functions that are present when PowerShell starts have been created in the global scope, such as automatic variables and preference variables. Les variables, les alias et les fonctions de vos profils PowerShell sont également créés dans l’étendue globale.The variables, aliases, and functions in your PowerShell profiles are also created in the global scope. La portée globale est l’étendue parente racine dans une session.The global scope is the root parent scope in a session.

  • Local : étendue actuelle.Local: The current scope. La portée locale peut être la portée globale ou toute autre étendue.The local scope can be the global scope or any other scope.

  • Script : étendue créée pendant l’exécution d’un fichier de script.Script: The scope that is created while a script file runs. Seules les commandes du script s’exécutent dans l’étendue du script.Only the commands in the script run in the script scope. Pour les commandes dans un script, la portée de script est l’étendue locale.To the commands in a script, the script scope is the local scope.

Notes

Private n’est pas une étendue.Private is not a scope. Il s’agit d’une option qui modifie la visibilité d’un élément en dehors de la portée dans laquelle l’élément est défini.It is an option that changes the visibility of an item outside of the scope where the item is defined.

Étendues parent et enfantParent and Child Scopes

Vous pouvez créer une étendue enfant en appelant un script ou une fonction.You can create a new child scope by calling a script or function. La portée d’appel est l’étendue parente.The calling scope is the parent scope. La fonction ou le script appelé est la portée enfant.The called script or function is the child scope. Les fonctions ou les scripts que vous appelez peuvent appeler d’autres fonctions, créant ainsi une hiérarchie d’étendues enfants dont l’étendue racine est la portée globale.The functions or scripts you call may call other functions, creating a hierarchy of child scopes whose root scope is the global scope.

Sauf si vous rendez explicitement les éléments privés, les éléments de l’étendue parente sont disponibles pour l’étendue enfant.Unless you explicitly make the items private, the items in the parent scope are available to the child scope. Toutefois, les éléments que vous créez et modifiez dans l’étendue enfant n’affectent pas l’étendue parente, sauf si vous spécifiez explicitement l’étendue lors de la création des éléments.However, items that you create and change in the child scope do not affect the parent scope, unless you explicitly specify the scope when you create the items.

Notes

Les fonctions d’un module ne s’exécutent pas dans une étendue enfant de la portée d’appel.Functions from a module do not run in a child scope of the calling scope. Les modules ont leur propre état de session lié à la portée globale.Modules have their own session state that is linked to the global scope. L’ensemble du code de module s’exécute dans une hiérarchie spécifique à un module d’étendues ayant sa propre étendue racine.All module code runs in a module-specific hierarchy of scopes that has its own root scope.

HéritageInheritance

Une étendue enfant n’hérite pas des variables, des alias et des fonctions de l’étendue parente.A child scope does not inherit the variables, aliases, and functions from the parent scope. À moins qu’un élément ne soit privé, l’étendue enfant peut afficher les éléments dans l’étendue parente.Unless an item is private, the child scope can view the items in the parent scope. De plus, il peut modifier les éléments en spécifiant explicitement l’étendue parent, mais les éléments ne font pas partie de l’étendue enfant.And, it can change the items by explicitly specifying the parent scope, but the items are not part of the child scope.

Toutefois, une étendue enfant est créée avec un ensemble d’éléments.However, a child scope is created with a set of items. En règle générale, il comprend tous les alias qui ont l’option options AllScope .Typically, it includes all the aliases that have the AllScope option. Cette option est décrite plus loin dans cet article.This option is discussed later in this article. Elle comprend toutes les variables qui ont l’option options AllScope , ainsi que certaines variables automatiques.It includes all the variables that have the AllScope option, plus some automatic variables.

Pour rechercher les éléments dans une étendue particulière, utilisez le paramètre scope de Get-Variable ou Get-Alias .To find the items in a particular scope, use the Scope parameter of Get-Variable or Get-Alias.

Par exemple, pour obtenir toutes les variables dans la portée locale, tapez :For example, to get all the variables in the local scope, type:

Get-Variable -Scope local

Pour récupérer toutes les variables dans la portée globale, tapez :To get all the variables in the global scope, type:

Get-Variable -Scope global

Modificateurs d’étendueScope Modifiers

Une variable, un alias ou un nom de fonction peut inclure l’un des modificateurs d’étendue facultatifs suivants :A variable, alias, or function name can include any one of the following optional scope modifiers:

  • global: : Spécifie que le nom existe dans la portée globale .global: - Specifies that the name exists in the Global scope.

  • local: : Spécifie que le nom existe dans l’étendue locale .local: - Specifies that the name exists in the Local scope. La portée actuelle est toujours l’étendue locale .The current scope is always the Local scope.

  • private: : Spécifie que le nom est privé et visible uniquement pour l’étendue actuelle.private: - Specifies that the name is Private and only visible to the current scope.

  • script: : Spécifie que le nom existe dans l’étendue du script .script: - Specifies that the name exists in the Script scope. La portée du script est l’étendue du fichier de script ancêtre le plus proche ou globale s’il n’existe pas de fichier de script ancêtre le plus proche.Script scope is the nearest ancestor script file's scope or Global if there is no nearest ancestor script file.

  • using: -Utilisé pour accéder aux variables définies dans une autre portée lors de l’exécution de scripts via des applets de commande telles que Start-Job et Invoke-Command .using: - Used to access variables defined in another scope while running scripts via cmdlets like Start-Job and Invoke-Command.

  • workflow: : Spécifie que le nom existe dans un flux de travail.workflow: - Specifies that the name exists within a workflow. Remarque : les flux de travail ne sont pas pris en charge dans PowerShell Core.Note: Workflows are not supported in PowerShell Core.

  • <variable-namespace> -Modificateur créé par un fournisseur de PowerShell PSDrive.<variable-namespace> - A modifier created by a PowerShell PSDrive provider. Par exemple :For example:

    Espace de nomsNamespace DescriptionDescription
    Alias: Alias définis dans l’étendue actuelleAliases defined in the current scope
    Env: Variables d’environnement définies dans la portée actuelleEnvironment variables defined in the current scope
    Function: Fonctions définies dans l’étendue actuelleFunctions defined in the current scope
    Variable: Variables définies dans la portée actuelleVariables defined in the current scope

L’étendue par défaut des scripts est l’étendue du script.The default scope for scripts is the script scope. L’étendue par défaut des fonctions et des alias est l’étendue locale, même si elles sont définies dans un script.The default scope for functions and aliases is the local scope, even if they are defined in a script.

Utilisation de modificateurs d’étendueUsing scope modifiers

Pour spécifier l’étendue d’une nouvelle variable, d’un alias ou d’une fonction, utilisez un modificateur d’étendue.To specify the scope of a new variable, alias, or function, use a scope modifier.

La syntaxe d’un modificateur de portée dans une variable est la suivante :The syntax for a scope modifier in a variable is:

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

La syntaxe d’un modificateur de portée dans une fonction est la suivante :The syntax for a scope modifier in a function is:

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

La commande suivante, qui n’utilise pas de modificateur de portée, crée une variable dans l’étendue actuelle ou locale :The following command, which does not use a scope modifier, creates a variable in the current or local scope:

$a = "one"

Pour créer la même variable dans la portée globale , utilisez le global: modificateur de portée :To create the same variable in the global scope, use the scope global: modifier:

$global:a = "one"

Pour créer la même variable dans la portée de script , utilisez le script: modificateur de portée :To create the same variable in the script scope, use the script: scope modifier:

$script:a = "one"

Vous pouvez également utiliser un modificateur d’étendue avec des fonctions.You can also use a scope modifier with functions. La définition de fonction suivante crée une fonction dans la portée globale :The following function definition creates a function in the global scope:

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

Vous pouvez également utiliser des modificateurs de portée pour faire référence à une variable dans une étendue différente.You can also use scope modifiers to refer to a variable in a different scope. La commande suivante fait référence à la $test variable, d’abord dans l’étendue locale, puis dans la portée globale :The following command refers to the $test variable, first in the local scope and then in the global scope:

$test
$global:test

Using:Modificateur de portéeThe Using: scope modifier

L’utilisation de est un modificateur d’étendue spécial qui identifie une variable locale dans une commande à distance.Using is a special scope modifier that identifies a local variable in a remote command. Sans modificateur, PowerShell s’attend à ce que les variables des commandes distantes soient définies dans la session à distance.Without a modifier, PowerShell expects variables in remote commands to be defined in the remote session.

Le Using modificateur de portée est introduit dans PowerShell 3,0.The Using scope modifier is introduced in PowerShell 3.0.

Pour tout script ou commande qui s’exécute hors session, vous avez besoin du Using modificateur de portée pour incorporer les valeurs de variable de l’étendue de la session appelante, afin que le code hors session puisse y accéder.For any script or command that executes out of session, you need the Using scope modifier to embed variable values from the calling session scope, so that out of session code can access them. Le Using modificateur de portée est pris en charge dans les contextes suivants :The Using scope modifier is supported in the following contexts:

  • Exécuter des commandes à distance, démarré avec Invoke-Command à l’aide des paramètres ComputerName , hostname , SSHConnection ou session (session à distance)Remotely executed commands, started with Invoke-Command using the ComputerName , HostName , SSHConnection or Session parameters (remote session)
  • Travaux en arrière-plan, démarrés avec Start-Job (session hors processus)Background jobs, started with Start-Job (out-of-process session)
  • Travaux de thread, démarrés via Start-ThreadJob ou ForEach-Object -Parallel (session de threads distincte)Thread jobs, started via Start-ThreadJob or ForEach-Object -Parallel (separate thread session)

Selon le contexte, les valeurs des variables incorporées sont soit des copies indépendantes des données dans la portée de l’appelant, soit des références à celles-ci.Depending on the context, embedded variable values are either independent copies of the data in the caller's scope or references to it. Dans les sessions à distance et hors processus, il s’agit toujours de copies indépendantes.In remote and out-of-process sessions, they are always independent copies.

Pour plus d’informations, consultez about_Remote_Variables.For more information, see about_Remote_Variables.

Dans les sessions de thread, elles sont passées par référence.In thread sessions, they are passed by reference. Cela signifie qu’il est possible de modifier les variables d’étendue d’appel dans un thread différent.This means it is possible to modify call scope variables in a different thread. La modification en toute sécurité des variables requiert la synchronisation des threads.To safely modify variables requires thread synchronization.

Pour plus d’informations, consultez les pages suivantes :For more information see:

Sérialisation de valeurs de variablesSerialization of variable values

Les commandes exécutées à distance et les travaux en arrière-plan s’exécutent hors processus.Remotely executed commands and background jobs run out-of-process. 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.Out-of-process sessions use XML-based serialization and deserialization to make the values of variables available across the process boundaries. Le processus de sérialisation convertit des objets en PSObject qui contient les propriétés des objets d’origine, mais pas ses méthodes.The serialization process converts objects to a PSObject that contains the original objects properties but not its methods.

Pour un ensemble limité de types, la désérialisation réalimente les objets dans le type d’origine.For a limited set of types, deserialization rehydrates objects back to the original type. L’objet réalimenté est une copie de l’instance d’objet d’origine.The rehydrated object is a copy of the original object instance. Il a les propriétés et les méthodes de type.It has the type properties and methods. Pour les types simples, tels que System. version , la copie est exacte.For simple types, such as System.Version , the copy is exact. Pour les types complexes, la copie n’est pas parfaite.For complex types, the copy is imperfect. Par exemple, les objets de certificat réalimentés n’incluent pas la clé privée.For example, rehydrated certificate objects do not include the private key.

Les instances de tous les autres types sont des instances PSObject .Instances of all other types are PSObject instances. La propriété PSTypeNames contient le nom du type d’origine préfixé avec désérialisé , par exemple, Deserialized.SysTEM. Data. DataTableThe PSTypeNames property contains the original type name prefixed with Deserialized , for example, Deserialized.System.Data.DataTable

Option Options AllScopeThe AllScope Option

Les variables et les alias ont une propriété option qui peut prendre la valeur options AllScope.Variables and aliases have an Option property that can take a value of AllScope. Les éléments qui ont la propriété options AllScope deviennent partie intégrante des portées enfants que vous créez, bien qu’elles ne soient pas héritées rétroactivement par les étendues parentes.Items that have the AllScope property become part of any child scopes that you create, although they are not retroactively inherited by parent scopes.

Un élément qui a la propriété options AllScope est visible dans la portée enfant et fait partie de cette étendue.An item that has the AllScope property is visible in the child scope, and it is part of that scope. Les modifications apportées à l’élément dans toute portée affectent toutes les étendues dans lesquelles la variable est définie.Changes to the item in any scope affect all the scopes in which the variable is defined.

Gestion de l’étendueManaging Scope

Plusieurs applets de commande ont un paramètre d' étendue qui vous permet d’obtenir ou de définir (créer et modifier) des éléments dans une étendue particulière.Several cmdlets have a Scope parameter that lets you get or set (create and change) items in a particular scope. Utilisez la commande suivante pour rechercher toutes les applets de commande de votre session qui ont un paramètre d' étendue :Use the following command to find all the cmdlets in your session that have a Scope parameter:

Get-Help * -Parameter scope

Pour rechercher les variables qui sont visibles dans une étendue particulière, utilisez le Scope paramètre de Get-Variable .To find the variables that are visible in a particular scope, use the Scope parameter of Get-Variable. Les variables visibles incluent des variables globales, des variables dans l’étendue parente et des variables dans l’étendue actuelle.The visible variables include global variables, variables in the parent scope, and variables in the current scope.

Par exemple, la commande suivante obtient les variables qui sont visibles dans l’étendue locale :For example, the following command gets the variables that are visible in the local scope:

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 .To create a variable in a particular scope, use a scope modifier or the Scope parameter of Set-Variable. La commande suivante crée une variable dans la portée globale :The following command creates a variable in the global scope:

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

Vous pouvez également utiliser le paramètre scope des New-Alias applets de commande, Set-Alias ou Get-Alias pour spécifier l’étendue.You can also use the Scope parameter of the New-Alias, Set-Alias, or Get-Alias cmdlets to specify the scope. La commande suivante crée un alias dans l’étendue globale :The following command creates an alias in the global scope:

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

Pour obtenir les fonctions dans une portée particulière, utilisez l' Get-Item applet de commande lorsque vous êtes dans l’étendue.To get the functions in a particular scope, use the Get-Item cmdlet when you are in the scope. L' Get-Item applet de commande n’a pas de paramètre d' étendue .The Get-Item cmdlet does not have a Scope parameter.

Notes

Pour les applets de commande qui utilisent le paramètre scope , vous pouvez également faire référence aux étendues par numéro.For the cmdlets that use the Scope parameter, you can also refer to scopes by number. Le nombre décrit la position relative d’une étendue à une autre.The number describes the relative position of one scope to another. La portée 0 représente l’étendue actuelle, ou locale.Scope 0 represents the current, or local, scope. L’étendue 1 indique l’étendue parente immédiate.Scope 1 indicates the immediate parent scope. L’étendue 2 indique le parent de l’étendue parent, et ainsi de suite.Scope 2 indicates the parent of the parent scope, and so on. Les étendues numérotées sont utiles si vous avez créé de nombreuses étendues récursives.Numbered scopes are useful if you have created many recursive scopes.

Utilisation de la notation de source de point avec l’étendueUsing Dot Source Notation with Scope

Les scripts et les fonctions suivent toutes les règles de portée.Scripts and functions follow all the rules of scope. 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 de portée pour modifier cette étendue.You create them in a particular scope, and they affect only that scope unless you use a cmdlet parameter or a scope modifier to change that scope.

Toutefois, vous pouvez ajouter un script ou une fonction à l’étendue actuelle à l’aide de la notation par point source.But, you can add a script or function to the current scope by using dot source notation. Ensuite, lorsqu’un script s’exécute dans l’étendue actuelle, toutes les fonctions, tous les alias et toutes les variables créés par le script sont disponibles dans l’étendue actuelle.Then, when a script runs in the current scope, any functions, aliases, and variables that the script creates are available in the current scope.

Pour ajouter une fonction à l’étendue actuelle, tapez un point (.) et un espace avant le chemin d’accès et le nom de la fonction dans l’appel de fonction.To add a function to the current scope, type a dot (.) and a space before the path and name of the function in the function call.

Par exemple, pour exécuter le script Sample.ps1 à partir du répertoire C:\Scripts dans l’étendue du script (par défaut pour les scripts), utilisez la commande suivante :For example, to run the Sample.ps1 script from the C:\Scripts directory in the script scope (the default for scripts), use the following command:

c:\scripts\sample.ps1

Pour exécuter le script de Sample.ps1 dans l’étendue locale, utilisez la commande suivante :To run the Sample.ps1 script in the local scope, use the following command:

. c:\scripts.sample.ps1

Lorsque vous utilisez l’opérateur d’appel (&) pour exécuter une fonction ou un script, il n’est pas ajouté à l’étendue actuelle.When you use the call operator (&) to run a function or script, it is not added to the current scope. L’exemple suivant utilise l’opérateur d’appel :The following example uses the call operator:

& c:\scripts.sample.ps1

Vous pouvez en savoir plus sur l’opérateur d’appel dans about_Operators.You can read more about the call operator in about_operators.

Les alias, fonctions ou variables créés par le script de Sample.ps1 ne sont pas disponibles dans l’étendue actuelle.Any aliases, functions, or variables that the Sample.ps1 script creates are not available in the current scope.

Restriction sans étendueRestricting Without Scope

Quelques concepts de PowerShell sont similaires à l’étendue ou à l’interaction avec l’étendue.A few PowerShell concepts are similar to scope or interact with scope. Ces concepts peuvent être confondus avec l’étendue ou le comportement de l’étendue.These concepts may be confused with scope or the behavior of scope.

Les sessions, les modules et les invites imbriquées sont des environnements autonomes, mais il ne s’agit pas de portées enfants de la portée globale dans la session.Sessions, modules, and nested prompts are self-contained environments, but they are not child scopes of the global scope in the session.

SessionsSessions

Une session est un environnement dans lequel PowerShell s’exécute.A session is an environment in which PowerShell runs. Lorsque vous créez une session sur un ordinateur distant, PowerShell établit une connexion permanente à l’ordinateur distant.When you create a session on a remote computer, PowerShell establishes a persistent connection to the remote computer. La connexion persistante vous permet d’utiliser la session pour plusieurs commandes associées.The persistent connection lets you use the session for multiple related commands.

Étant donné qu’une session est un environnement contenu, elle a sa propre étendue, mais une session n’est pas une étendue enfant de la session dans laquelle elle a été créée.Because a session is a contained environment, it has its own scope, but a session is not a child scope of the session in which it was created. La session commence par sa propre étendue globale.The session starts with its own global scope. Cette étendue est indépendante de l’étendue globale de la session.This scope is independent of the global scope of the session. Vous pouvez créer des étendues enfants dans la session.You can create child scopes in the session. Par exemple, vous pouvez exécuter un script pour créer une étendue enfant dans une session.For example, you can run a script to create a child scope in a session.

ModulesModules

Vous pouvez utiliser un module PowerShell pour partager et fournir des outils PowerShell.You can use a PowerShell module to share and deliver PowerShell tools. 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.A module is a unit that can contain cmdlets, scripts, functions, variables, aliases, and other useful items. Sauf définition explicite, les éléments d’un module ne sont pas accessibles à l’extérieur du module.Unless explicitly defined, the items in a module are not accessible outside the 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.Therefore, you can add the module to your session and use the public items without worrying that the other items might override the cmdlets, scripts, functions, and other items in your session.

Par défaut, les modules sont chargés dans le niveau supérieur de l' État de session actuel et non dans l' étendue actuelle.By default, modules are loaded into the top-level of the current session state not the current scope. L’état actuel de la session peut être un état de session de module ou l’état de session global.The current session state could be a module session state or the global session state. L’ajout d’un module à une session ne modifie pas l’étendue.Adding a module to a session does not change the scope. Si vous êtes dans la portée globale, les modules sont chargés dans l’état de session global.If you are in the global scope, then modules are loaded into the global session state. Toutes les exportations sont placées dans les tables globales.Any exports are placed into the global tables. Si vous chargez Module2 à partir de Module1, Module2 est chargé dans l’état de session de Module1, et non dans l’état de session global.If you load module2 from within module1, module2 is loaded into the session state of module1 not the global session state. Toutes les exportations à partir de Module2 sont placées en haut de l’état de la session Module1.Any exports from module2 are placed at the top of the module1 session state. Si vous utilisez Import-Module -Scope local , les exportations sont placées dans l’objet de portée actuel plutôt que au niveau supérieur.If you use Import-Module -Scope local, then the exports are placed into the current scope object rather than at the top level. Si vous êtes dans un module et utilisez Import-Module -Scope global (ou Import-Module -Global ) pour charger un autre module, ce module et ses exportations sont chargés dans l’état de session global, et non dans l’état de session local du module.If you are in a module and use Import-Module -Scope global (or Import-Module -Global) to load another module, that module and it's exports are loaded into the global session state instead of the module's local session state. Cette fonctionnalité a été conçue pour écrire un module qui manipule des modules.This feature was designed for writing module that manipulate modules. Le module WindowsCompatibility effectue cette importation pour importer des modules de proxy dans l’état de session global.The WindowsCompatibility module does this to import proxy modules into the global session state.

Dans l’état de session, les modules ont leur propre étendue.Within the session state, modules have their own scope. Prenons le module suivant C:\temp\mod1.psm1 :Consider the following module C:\temp\mod1.psm1:

$a = "Hello"

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

Maintenant, nous créons une variable globale $a , lui attribuons une valeur et appelons la fonction foo.Now we create a global variable $a, give it a value and call the function foo.

$a = "Goodbye"
foo

Le module déclare la variable $a dans la portée du module, puis la fonction foo génère la valeur de la variable dans les deux étendues.The module declares the variable $a in the module scope then the function foo outputs the value of the variable in both scopes.

$a = Hello
$global:a = Goodbye

Invites imbriquéesNested Prompts

Les invites imbriquées n’ont pas leur propre étendue.Nested prompts do not have their own scope. Lorsque vous entrez une invite imbriquée, l’invite imbriquée est un sous-ensemble de l’environnement.When you enter a nested prompt, the nested prompt is a subset of the environment. Toutefois, vous restez dans l’étendue locale.But, you remain within the local scope.

Les scripts ont leur propre étendue.Scripts do have their own scope. Si vous déboguez un script et que vous atteignez un point d’arrêt dans le script, vous entrez la portée du script.If you are debugging a script, and you reach a breakpoint in the script, you enter the script scope.

Option privéePrivate Option

Les alias et les variables ont une propriété option qui peut prendre la valeur Private.Aliases and variables have an Option property that can take a value of 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.Items that have the Private option can be viewed and changed in the scope in which they are created, but they cannot be viewed or changed outside that scope.

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.For example, if you create a variable that has a private option in the global scope and then run a script, Get-Variable commands in the script do not display the private variable. L’utilisation du modificateur de portée globale dans cette instance n’affiche pas la variable privée.Using the global scope modifier in this instance does not display the private variable.

Vous pouvez utiliser le paramètre option des applets de commande,, New-Variable Set-Variable New-Alias et Set-Alias pour définir la valeur de la propriété option sur Private.You can use the Option parameter of the New-Variable, Set-Variable, New-Alias, and Set-Alias cmdlets to set the value of the Option property to Private.

VisibilitéVisibility

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éé.The Visibility property of a variable or alias determines whether you can see the item outside the container, in which it was created. Un conteneur peut être un module, un script ou un composant logiciel enfichable.A container could be a module, script, or snap-in. La visibilité est conçue pour les conteneurs de la même façon que la valeur privée de la propriété option est conçue pour les étendues.Visibility is designed for containers in the same way that the Private value of the Option property is designed for scopes.

La propriété Visibility prend les valeurs publiques et privées .The Visibility property takes the Public and Private values. 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.Items that have private visibility can be viewed and changed only in the container in which they were created. Si le conteneur est ajouté ou importé, les éléments qui ont une visibilité privée ne peuvent pas être affichés ou modifiés.If the container is added or imported, the items that have private visibility cannot be viewed or changed.

Étant donné que la visibilité est conçue pour les conteneurs, elle fonctionne différemment dans une étendue.Because visibility is designed for containers, it works differently in a scope.

  • 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 une étendue.If you create an item that has private visibility in the global scope, you cannot view or change the item in any scope.
  • Si vous essayez d’afficher ou de modifier la valeur d’une variable qui a une visibilité privée, PowerShell retourne un message d’erreur.If you try to view or change the value of a variable that has private visibility, PowerShell returns an error message.

Vous pouvez utiliser les New-Variable applets de commande et Set-Variable pour créer une variable qui a une visibilité privée.You can use the New-Variable and Set-Variable cmdlets to create a variable that has private visibility.

ExemplesExamples

Exemple 1 : modifier une valeur de variable uniquement dans un scriptExample 1: Change a Variable Value Only in a Script

La commande suivante modifie la valeur de la $ConfirmPreference variable dans un script.The following command changes the value of the $ConfirmPreference variable in a script. La modification n’affecte pas la portée globale.The change does not affect the global scope.

Tout d’abord, pour afficher la valeur de la $ConfirmPreference variable dans l’étendue locale, utilisez la commande suivante :First, to display the value of the $ConfirmPreference variable in the local scope, use the following command:

PS>  $ConfirmPreference
High

Créez un script de Scope.ps1 qui contient les commandes suivantes :Create a Scope.ps1 script that contains the following commands:

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

Exécutez le script.Run the script. Le script modifie la valeur de la $ConfirmPreference variable, puis indique sa valeur dans la portée du script.The script changes the value of the $ConfirmPreference variable and then reports its value in the script scope. La sortie doit ressembler à la sortie suivante :The output should resemble the following output:

The value of $ConfirmPreference is Low.

Ensuite, testez la valeur actuelle de la $ConfirmPreference variable dans la portée actuelle.Next, test the current value of the $ConfirmPreference variable in the current scope.

PS>  $ConfirmPreference
High

Cet exemple montre que les modifications apportées à la valeur d’une variable dans la portée du script n’affectent pas la valeur de la variable dans l’étendue parente.This example shows that changes to the value of a variable in the script scope does not affect the variable`s value in the parent scope.

Exemple 2 : afficher une valeur de variable dans différentes portéesExample 2: View a Variable Value in Different Scopes

Vous pouvez utiliser les modificateurs d’étendue pour afficher la valeur d’une variable dans la portée locale et dans une étendue parente.You can use scope modifiers to view the value of a variable in the local scope and in a parent scope.

Tout d’abord, définissez une $test variable dans l’étendue globale.First, define a $test variable in the global scope.

$test = "Global"

Ensuite, créez un script de Sample.ps1 qui définit la $test variable.Next, create a Sample.ps1 script that defines the $test variable. Dans le script, utilisez un modificateur de portée pour faire référence à la version globale ou locale de la $test variable.In the script, use a scope modifier to refer to either the global or local versions of the $test variable.

Dans Sample.ps1 :In 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 :When you run Sample.ps1, the output should resemble the following output:

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

Une fois le script terminé, seule la valeur globale de $test est définie dans la session.When the script is complete, only the global value of $test is defined in the session.

PS>  $test
Global

Exemple 3 : modifier la valeur d’une variable dans une étendue parenteExample 3: Change the Value of a Variable in a Parent Scope

Sauf si vous protégez un élément à l’aide de l’option Private ou d’une autre méthode, vous pouvez afficher et modifier la valeur d’une variable dans une étendue parente.Unless you protect an item by using the Private option or another method, you can view and change the value of a variable in a parent scope.

Tout d’abord, définissez une $test variable dans l’étendue globale.First, define a $test variable in the global scope.

$test = "Global"

Ensuite, créez un script de Sample.ps1 qui définit la $test variable.Next, create a Sample.ps1 script that defines the $test variable. Dans le script, utilisez un modificateur de portée pour faire référence à la version globale ou locale de la $test variable.In the script, use a scope modifier to refer to either the global or local versions of the $test variable.

Dans Sample.ps1 :In Sample.ps1:

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

Une fois le script terminé, la valeur globale de $test est modifiée.When the script is complete, the global value of $test is changed.

PS>  $test
Local

Exemple 4 : création d’une variable privéeExample 4: Creating a Private Variable

Une variable privée est une variable qui a une propriété option dont la valeur est Private.A private variable is a variable that has an Option property that has a value of Private. Les variables privées sont héritées par l’étendue enfant, mais elles ne peuvent être affichées ou modifiées que dans l’étendue dans laquelle elles ont été créées.Private variables are inherited by the child scope, but they can only be viewed or changed in the scope in which they were created.

La commande suivante crée une variable privée appelée $ptest dans l’étendue locale.The following command creates a private variable called $ptest in the local scope.

New-Variable -Name ptest -Value 1 -Option private

Vous pouvez afficher et modifier la valeur de $ptest dans l’étendue locale.You can display and change the value of $ptest in the local scope.

PS>  $ptest
1

PS>  $ptest = 2
PS>  $ptest
2

Ensuite, créez un Sample.ps1 script qui contient les commandes suivantes.Next, create a Sample.ps1 script that contains the following commands. La commande tente d’afficher et de modifier la valeur de $ptest .The command tries to display and change the value of $ptest.

Dans Sample.ps1 :In Sample.ps1:

"The value of `$Ptest is $Ptest."
"The value of `$Ptest is $global:Ptest."

La $ptest variable n’est pas visible dans l’étendue du script, la sortie est vide.The $ptest variable is not visible in the script scope, the output is empty.

"The value of $Ptest is ."
"The value of $Ptest is ."

Exemple 5 : utilisation d’une variable locale dans une commande à distanceExample 5: Using a Local Variable in a Remote Command

Pour les variables d’une commande distante créée dans la session locale, utilisez le Using modificateur de portée.For variables in a remote command created in the local session, use the Using scope modifier. PowerShell suppose que les variables des commandes distantes ont été créées dans la session à distance.PowerShell assumes that the variables in remote commands were created in the remote session.

La syntaxe est :The syntax is:

$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 :For example, the following commands create a $Cred variable in the local session and then use the $Cred variable in a remote command:

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

L’étendue using a été introduite dans PowerShell 3,0.The Using scope was introduced in PowerShell 3.0. Dans PowerShell 2,0, pour indiquer qu’une variable a été créée dans la session locale, utilisez le format de commande suivant.In PowerShell 2.0, to indicate that a variable was created in the local session, use the following command format.

$Cred = Get-Credential
Invoke-Command $s {
  param($c)
  Remove-Item .\Test*.ps1 -Credential $c
} -ArgumentList $Cred

Voir aussiSee also

about_Variablesabout_Variables

about_Environment_Variablesabout_Environment_Variables

about_Functionsabout_Functions

about_Script_Blocksabout_Script_Blocks

Start-ThreadJobStart-ThreadJob