about_Scopes

Rövid leírás

Ismerteti a PowerShell hatókörének fogalmát, és bemutatja, hogyan állíthatja be és módosíthatja az elemek hatókörét.

Hosszú leírás

A PowerShell azzal védi a változókhoz, aliasokhoz, függvényekhez és PowerShell-meghajtókhoz (PSDrive-ok) való hozzáférést, hogy korlátozza azok olvasási és módosítási helyét. A PowerShell hatókörszabályokat használ annak biztosítására, hogy a más hatókörökben lévő elemeken ne hajtson végre véletlen módosításokat.

Hatókörszabályok

A PowerShell indításakor a gazdagép (pwsh.exe) létrehoz egy PowerShell-futtatóteret. A gazdagépfolyamatok több futtatóteret is tartalmazhatnak. Minden futtatótér saját munkamenet-állapotú és hatókörtárolókkal rendelkezik. A munkamenet állapota és hatókörei nem érhetők el a futtatókörnyezet példányai között.

A hatókör alapvető szabályai a következők:

• A hatókörök beágyazhatók. A külső hatókört szülőhatókörnek nevezzük. A beágyazott hatókörök az adott szülő gyermek hatókörei.
• Az elemek a létrehozott hatókörben és a gyermekhatókörökben is láthatók, hacsak nem teszi kifejezetten privátsá.
• Az aktuális hatókörön kívüli hatókörhöz deklarálhat változókat, aliasokat, függvényeket és PowerShell-meghajtókat.
• A hatókörön belül létrehozott elemek csak abban a hatókörben módosíthatók, amelyben létrehozták, kivéve, ha explicit módon más hatókört ad meg.
• Amikor egy runspace-ben futó kód egy elemre hivatkozik, a PowerShell megkeresi a hatókörhierarchiát, kezdve az aktuális hatókörrel, és halad végig az egyes szülőhatókörön. Ha az elem nem található, a rendszer új elemet hoz létre az aktuális hatókörben. Ha talál egyezést, a rendszer lekéri az elem értékét abból a hatókörből, ahol megtalálható. Ha módosítja az értéket, az elem az aktuális hatókörbe másolt, hogy a módosítás csak az aktuális hatókörre legyen hatással.
• Ha kifejezetten olyan elemet hoz létre, amely a nevét egy másik hatókörben lévő elemgel osztja meg, előfordulhat, hogy az eredeti elemet elrejti az új elem, de nem bírálja felül vagy módosítja.

Szülő- és gyermekhatókörök

Egy szkript vagy függvény meghívásával létrehozhat egy új gyermekhatókört. A hívó hatókör a szülőhatókör. Az úgynevezett szkript vagy függvény a gyermek hatóköre. A hívott függvények vagy szkriptek más függvényeket is meghívhatnak, és olyan gyermekhatókörök hierarchiáját hozhatják létre, amelyek gyökér hatóköre a globális hatókör.

Feljegyzés

A modulból származó függvények nem futnak a hívó hatókör gyermek hatókörében. A modulok saját munkamenet-állapotukkal rendelkeznek, amely ahhoz a hatókörhöz van társítva, amelyben a modult importálták. Minden modulkód a saját gyökérhatókörrel rendelkező hatókörök modulspecifikus hierarchiájában fut. További információkért tekintse meg a cikk Modulok szakaszát.

A gyermekhatókör létrehozásakor tartalmazza az összes olyan aliast és változót, amely rendelkezik az AllScope beállítással, valamint néhány automatikus változót. Ezt a lehetőséget a cikk későbbi részében tárgyaljuk.

Ha nem teszi kifejezetten privátsá az elemeket, a szülő hatókörben lévő elemek elérhetők a gyermekhatókör számára. A gyermekhatókörben létrehozott vagy módosított elemek nem érintik a szülő hatókört, kivéve, ha explicit módon adja meg a hatókört az elemek létrehozásakor.

Ha egy adott hatókör elemeit szeretné megtalálni, használja a Hatókör paramétertGet-Variable.Get-Alias

Ha például az összes változót le szeretné kapni a helyi hatókörben, írja be a következőt:

Get-Variable -Scope local

A globális hatókör összes változójának lekéréséhez írja be a következőt:

Get-Variable -Scope global

Amikor változóra, aliasra vagy függvényre hivatkozik, a PowerShell megkeresi az aktuális hatókört. Ha az elem nem található, a rendszer megkeresi a szülőhatókört. Ez a keresés a globális hatókörig ismétlődik. Ha egy változó privát egy szülőhatókörben, a keresés a hatókörláncon keresztül folytatódik. A 4 . példa egy privát változó hatását mutatja be a hatókör-keresésben.

PowerShell-hatókörök nevei

A PowerShell definiálja egyes hatókörök nevét, hogy könnyebb legyen az adott hatókörhöz való hozzáférés. A PowerShell a következő elnevezett hatóköröket határozza meg:

• Globális: Az a hatókör, amely a PowerShell indításakor vagy új munkamenet vagy futtatótér létrehozásakor lép érvénybe. A PowerShell indításakor jelen lévő változók és függvények, például az automatikus változók és a beállítási változók a globális hatókörben jönnek létre. A PowerShell-profilok változói, aliasai és függvényei szintén a globális hatókörben jönnek létre. A globális hatókör a fő szülőhatókör egy runspace-ben.
• Helyi: Az aktuális hatókör. A helyi hatókör lehet a globális vagy bármely más hatókör.
• Szkript: A szkriptfájl futtatása közben létrehozott hatókör. A szkript parancsai a szkript hatókörében futnak. A szkript parancsai esetében a szkript hatóköre a helyi hatókör.

A hatóköröket támogató parancsmagok esetében a hatókörökre olyan szám hivatkozhat, amely az egyik hatókör egymáshoz viszonyított pozícióját írja le. A 0. hatókör az aktuális (helyi) hatókört jelöli, az 1. hatókör az aktuális hatókör szülője, a 2. hatókör az aktuális hatókör nagyszülője. Ez a minta addig folytatódik, amíg el nem éri a gyökértartományt.

Hatókör-módosítók

A változók, aliasok vagy függvénynevek a következő választható hatókörmódosítók bármelyikét tartalmazhatják:

• global: – Megadja, hogy a név létezik-e a globális hatókörben.

• local: – Megadja, hogy a név létezik-e a Helyi hatókörben. Az aktuális hatókör mindig a Helyi hatókör.

• private:– Azt adja meg, hogy a név privát, és csak az aktuális hatókör számára látható.

  Feljegyzés

  private: nem hatókör. Ez egy olyan lehetőség , amely megváltoztatja egy elem akadálymentességét azon a hatókörön kívül, amelyben definiálva van.

• script: – Megadja, hogy a név szerepel-e a szkript hatókörében. A szkript hatóköre a legközelebbi ősszkriptfájl hatóköre, vagy globális , ha nincs legközelebbi ősszkriptfájl.

• using: - Egy másik hatókörben definiált változók elérésére szolgál, miközben szkripteket futtat olyan parancsmagokkal, mint az Start-Job és Invoke-Command.

• workflow: – Megadja, hogy a név létezik-e egy munkafolyamaton belül. Megjegyzés: A munkafolyamatok nem támogatottak a PowerShell 6-os és újabb verzióiban.

• <variable-namespace> – Egy PowerShell PSDrive-szolgáltató által létrehozott módosító. Példa:

  Névtér	Leírás
  Alias:	Az aktuális hatókörben definiált aliasok
  Env:	Az aktuális hatókörben definiált környezeti változók
  Function:	Az aktuális hatókörben definiált függvények
  Variable:	Az aktuális hatókörben definiált változók

A szkriptek alapértelmezett hatóköre a szkript hatóköre. A függvények és aliasok alapértelmezett hatóköre a helyi hatókör, még akkor is, ha szkriptben vannak definiálva.

Hatókör-módosítók használata

Egy új változó, alias vagy függvény hatókörének megadásához használjon hatókör-módosítót.

A változó hatókör-módosítójának szintaxisa a következő:

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

Egy függvény hatókör-módosítójának szintaxisa a következő:

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

Az alábbi parancs, amely nem használ hatókör-módosítót, létrehoz egy változót az aktuális vagy a helyi hatókörben:

$a = "one"

Ha ugyanazt a változót szeretné létrehozni a globális hatókörben, használja a hatókör-módosítót global: :

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

Figyelje meg a Láthatóság és beállítások tulajdonság értékeit.

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

Hasonlítsa össze ezt egy privát változóval:

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

private A hatókör-módosító használatával a Beállítások tulajdonság értéke .Private

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

Ha ugyanazt a változót szeretné létrehozni a szkript hatókörében, használja a script: hatókör-módosítót:

$script:a = "one"

A hatókör-módosító függvényekkel is használható. A következő függvénydefiníció létrehoz egy függvényt a globális hatókörben:

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

A hatókör-módosítók használatával egy másik hatókörben lévő változóra is hivatkozhat. A következő parancs a $test változóra hivatkozik, először a helyi hatókörben, majd a globális hatókörben:

$test
$global:test

A using: hatókör-módosító

A használat egy speciális hatókör-módosító, amely egy helyi változót azonosít egy távoli parancsban. Módosító nélkül a PowerShell elvárja, hogy a távoli parancsok változói definiálva legyenek a távoli munkamenetben.

A using hatókör-módosító a PowerShell 3.0-ban jelenik meg.

Minden olyan szkripthez vagy parancshoz, amely munkameneten kívül fut, a hatókör-módosítónak szüksége van a using változóértékek beágyazásához a hívási munkamenet hatóköréből, hogy a munkameneten kívüli kód hozzáférhessen hozzájuk. A using hatókör-módosító a következő környezetekben támogatott:

• Távolról végrehajtott parancsok, a ComputerName, a HostName, az SSH Csatlakozás ion vagy a Munkamenet paraméterek (távoli munkamenet) használatával kezdődtekInvoke-Command.
• Háttérfeladatok, első lépések Start-Job (folyamaton kívüli munkamenet)
• Szálfeladatok, elindítva Start-ThreadJob vagy ForEach-Object -Parallel (külön szál munkamenettel)

A környezettől függően a beágyazott változóértékek vagy a hívó hatókörében lévő adatok független másolatai, vagy azokra mutató hivatkozások. A távoli és a folyamaton kívüli munkamenetekben mindig független másolatok.

További információ: about_Remote_Variables.

A szál-munkamenetekben a program hivatkozással továbbítja őket. Ez azt jelenti, hogy a gyermekhatókör változói módosíthatók egy másik szálon. A változók biztonságos módosításához szálszinkronizálás szükséges.

További információk:

• Start-ThreadJob
• ForEach-Object

Változóértékek szerializálása

A távolról végrehajtott parancsok és háttérfeladatok folyamaton kívül futnak. A folyamaton kívüli munkamenetek XML-alapú szerializálással és deszerializálással teszik elérhetővé a változók értékeit a folyamathatárok között. A szerializálási folyamat olyan PSObject-objektummá alakítja az objektumokat, amely az eredeti objektumtulajdonságokat tartalmazza, a metódusait azonban nem.

Korlátozott típusok esetén a deszerializálás visszahidratálja az objektumokat az eredeti típusra. A rehidratált objektum az eredeti objektumpéldány másolata. Típustulajdonságokkal és metódusokkal rendelkezik. Az egyszerű típusok, például a System.Version esetében a másolat pontos. Összetett típusok esetén a másolat nem tökéletes. A rehidratált tanúsítványobjektumok például nem tartalmazzák a titkos kulcsot.

Az összes többi típus példányai a PSObject-példányok . A PSTypeNames tulajdonság az eredeti típusnevet tartalmazza deszerializált előtaggal, például Deserialized.System.Data.DataTable

Az AllScope beállítás

A változók és aliasok egy Option tulajdonságot is tartalmazhatnak, amely az AllScope értékét is figyelembe veheti. Az AllScope tulajdonságú elemek a létrehozott gyermekhatókörök részévé válnak, bár a szülőhatókörök nem öröklik visszamenőlegesen őket.

Az AllScope tulajdonságot tartalmazó elem látható a gyermekhatókörben, és ennek a hatókörnek a része. Az elem bármely hatókörben történő módosítása hatással van az összes hatókörre, amelyben a változó definiálva van.

Hatókör kezelése

Több parancsmag rendelkezik hatókörparaméterrel, amely lehetővé teszi egy adott hatókör elemeinek lekérését vagy beállítását (létrehozását és módosítását). A következő paranccsal megkeresheti a munkamenet összes olyan parancsmagját, amely hatókörparaméterrel rendelkezik:

Get-Help * -Parameter scope

Az adott hatókörben látható változók megkereséséhez használja a Scope következő paramétert Get-Variable: . A látható változók közé tartoznak a globális változók, a szülőhatókör változói és az aktuális hatókör változói.

A következő parancs például lekéri a helyi hatókörben látható változókat:

Get-Variable -Scope local

Ha egy változót egy adott hatókörben szeretne létrehozni, használjon egy hatókör-módosítót vagy a hatókör paraméterét Set-Variable. A következő parancs létrehoz egy változót a globális hatókörben:

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

A hatókör megadásához használhatja a New-Alias, Set-Aliasvagy Get-Alias parancsmagok Hatókör paraméterét is. A következő parancs létrehoz egy aliast a globális hatókörben:

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

Ha egy adott hatókörben szeretné lekérni a függvényeket, használja a Get-Item parancsmagot, amikor a hatókörben van. A Get-Item parancsmag nem rendelkezik Hatókör paraméterrel.

Feljegyzés

A Hatókör paramétert használó parancsmagok esetében szám szerint is hivatkozhat a hatókörökre. A szám az egyik hatókör egymáshoz viszonyított pozícióját írja le. A 0. hatókör az aktuális vagy helyi hatókört jelöli. Az 1. hatókör az azonnali szülőhatókört jelöli. A 2. hatókör a szülőhatókör szülőét jelöli, és így tovább. A számozott hatókörök akkor hasznosak, ha számos rekurzív hatókört hozott létre.

Pontforrás jelölésének használata hatókörrel

A szkriptek és függvények a hatókör szabályait követik. Ezeket egy adott hatókörben hozza létre, és csak erre a hatókörre van hatással, kivéve, ha parancsmagparamétert vagy hatókör-módosítót használ a hatókör módosításához.

A szkriptek vagy függvények tartalmát azonban pontforrás-jelöléssel is hozzáadhatja az aktuális hatókörhöz. Ha pontforrás-jelöléssel futtat egy szkriptet vagy függvényt, az az aktuális hatókörben fut. A szkript vagy függvény minden függvénye, aliasa és változója hozzá lesz adva az aktuális hatókörhöz.

Ha például a szkriptet a Sample.ps1C:\Scripts szkript hatókörében lévő könyvtárból szeretné futtatni (ez a szkriptek alapértelmezett értéke), egyszerűen adja meg a parancssorban található szkriptfájl teljes elérési útját.

c:\scripts\sample.ps1

Egy szkriptfájlnak végrehajtható fájlkiterjesztéssel kell rendelkeznie .ps1 . Az elérési útjukban szóközöket tartalmazó fájlokat idézőjelek közé kell tenni. Ha megpróbálja végrehajtani az idézett elérési utat, a PowerShell a szkript futtatása helyett megjeleníti az idézett sztring tartalmát. A híváskezelő (&) lehetővé teszi a fájlnevet tartalmazó sztring tartalmának végrehajtását.

Egy függvény vagy szkript futtatásához használja a híváskezelőt a szkript hatókörében. A híváskezelő használata nem különbözik a szkript név szerinti futtatásától.

& c:\scripts\sample.ps1

A híváskezelőről a about_Operators olvashat bővebben.

A szkript helyi hatókörben való futtatásához Sample.ps1 írjon be egy pont és egy szóközt (. ) a szkript elérési útja előtt:

. c:\scripts\sample.ps1

A szkriptben definiált függvények, aliasok és változók mostantól hozzáadódnak az aktuális hatókörhöz.

Hatókör nélküli korlátozás

A PowerShell rendelkezik a hatókörhöz hasonló és a hatókörökhöz hasonló beállításokkal és funkciókkal. Ez a funkció összetéveszthető a hatókörrel vagy a hatókör viselkedésével.

A munkamenetek, modulok és beágyazott kérések önálló környezetek, nem pedig a globális hatókör gyermek hatókörei a munkamenetben.

Előadások

A munkamenetek olyan környezetek, amelyekben a PowerShell fut. Amikor munkamenetet hoz létre egy távoli számítógépen, a PowerShell állandó kapcsolatot létesít a távoli számítógéppel. Az állandó kapcsolat lehetővé teszi, hogy a munkamenetet több kapcsolódó parancshoz használja.

Mivel a munkamenet tartalmazott környezet, saját hatókörrel rendelkezik, de a munkamenet nem annak a munkamenetnek a gyermek hatóköre, amelyben létrejött. A munkamenet a saját globális hatókörével kezdődik. Ez a hatókör független a munkamenet globális hatókörétől. A munkamenetben gyermekhatóköröket hozhat létre. Futtathat például egy szkriptet egy gyermekhatókör létrehozásához egy munkamenetben.

Modulok

PowerShell-modullal megoszthatja és kézbesítheti a PowerShell-eszközöket. A modul olyan egység, amely parancsmagokat, szkripteket, függvényeket, változókat, aliasokat és egyéb hasznos elemeket tartalmazhat. Hacsak nem exportálja explicit módon (a moduljegyzéket vagy a moduljegyzéket), Export-ModuleMember a modul elemei nem érhetők el a modulon kívül. Ezért hozzáadhatja a modult a munkamenethez, és anélkül használhatja a nyilvános elemeket, hogy a többi elem felülírhatná a munkamenet parancsmagjait, szkripteit, függvényeit és egyéb elemeit.

Alapértelmezés szerint a modulok betöltve vannak a futtatótér gyökérszintű (globális) hatókörébe. A modul importálása nem változtatja meg a hatókört. A munkameneten belül a modulok saját hatókörrel rendelkeznek. Vegye figyelembe a következő modult C:\temp\mod1.psm1:

$a = "Hello"

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

Most létrehozunk egy globális változót$a, megadunk egy értéket, és meghívjuk a foo függvényt.

$a = "Goodbye"
foo

A modul deklarálja a változót $a a modul hatókörében, majd a függvény foo mindkét hatókörben adja ki a változó értékét.

$a = Hello
$global:a = Goodbye

A modulok párhuzamos hatókörtárolókat hoznak létre ahhoz a hatókörhöz csatolva, amelyben importálták őket. A modul által exportált elemek az importálás hatókörszintjén érhetők el. A modulból nem exportált elemek csak a modul hatókörtárolójában érhetők el. A modul függvényei hozzáférhetnek a hatókör azon elemeihez, amelyekbe importálták őket, valamint a modul hatókörtárolójában lévő elemeket.

Ha a Modul2 modult az 1. modulból tölti be, a modul2 be lesz töltve az 1. modul hatókörtárolójába. A Modul2-ből származó exportálások a Modul1 aktuális modulhatókörébe kerülnek. Ha használja Import-Module -Scope local, akkor az exportálások a legfelső szint helyett az aktuális hatókörobjektumba kerülnek. Ha egy modulban dolgozik, és egy másik modult tölt be a modul használatával Import-Module -Scope global (vagy Import-Module -Global), akkor a modul helyi hatóköre helyett az adott modul és annak exportálása a globális hatókörbe lesz betöltve. A Windows kompatibilitási funkcióval proxymodulokat importálhat a globális munkamenet állapotába.

Beágyazott kérések

A beágyazott kérések nem rendelkeznek saját hatókörrel. Beágyazott parancssor megadásakor a beágyazott parancssor a környezet egy részhalmaza. De továbbra is a helyi hatókörön belül marad.

A szkripteknek saját hatókörük van. Ha hibakereséssel keres egy szkriptet, és eléri a töréspontot a szkriptben, adja meg a szkript hatókörét.

Privát lehetőség

Az aliasok és a változók olyan Option tulajdonságot is tartalmazhatnak, amely a Private. A beállítással rendelkező Private elemek megtekinthetők és módosíthatók abban a hatókörben, amelyben létrehozták őket, de nem tekinthetők meg és nem módosíthatók ezen a hatókörön kívül.

Ha például létrehoz egy olyan változót, amelynek a globális hatókörben van egy privát lehetősége, majd futtat egy szkriptet, Get-Variable a szkript parancsai nem jelenítik meg a privát változót. A globális hatókör-módosító ebben a példányban nem jeleníti meg a privát változót.

A , Set-Variable, New-Aliasés Set-Alias parancsmagok Option paraméterével New-Variableaz Option tulajdonság értékét Privát értékre állíthatja.

Látótávolság

Egy változó vagy alias láthatósági tulajdonsága határozza meg, hogy láthatja-e az elemet azon a tárolón kívül, amelyben létrejött. A tároló lehet modul, szkript vagy beépülő modul. A láthatóság a tárolókhoz ugyanúgy van kialakítva, mint az PrivateOption tulajdonság értéke a hatókörökhöz.

A Láthatóság tulajdonság az és Private az Public értékeket veszi át. A privát láthatóságú elemek csak abban a tárolóban tekinthetők meg és módosíthatók, amelyben létrehozták őket. A tároló hozzáadása vagy importálása esetén a privát láthatóságú elemek nem tekinthetők meg és nem módosíthatók.

Mivel a láthatóság tárolókhoz van tervezve, a hatókörben másként működik.

• Ha olyan elemet hoz létre, amely privát láthatóságot biztosít a globális hatókörben, nem tekintheti meg és nem módosíthatja az elemet egyetlen hatókörben sem.
• Ha megkísérli megtekinteni vagy módosítani egy privát láthatóságú változó értékét, a PowerShell hibaüzenetet ad vissza.

A parancsmagok és Set-Variable a New-Variable parancsmagok segítségével létrehozhat egy privát láthatóságú változót.

Példák

1. példa: Változó értékének módosítása csak szkriptben

A következő parancs módosítja a $ConfirmPreference változó értékét egy szkriptben. A módosítás nincs hatással a globális hatókörre.

Először is a következő paranccsal jelenítheti meg a $ConfirmPreference változó értékét a helyi hatókörben:

PS>  $ConfirmPreference
High

Hozzon létre egy Scope.ps1 szkriptet, amely a következő parancsokat tartalmazza:

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

Futtassa a szkriptet. A szkript módosítja a $ConfirmPreference változó értékét, majd jelentést készít annak értékéről a szkript hatókörében. A kimenetnek a következő kimenethez kell hasonlítania:

The value of $ConfirmPreference is Low.

Ezután tesztelje $ConfirmPreference a változó aktuális értékét az aktuális hatókörben.

PS>  $ConfirmPreference
High

Ez a példa azt mutatja be, hogy a szkript hatókörében lévő változó értékének módosítása nem befolyásolja a változó szülőhatókörbeli értékét.

2. példa: Változóérték megtekintése különböző hatókörökben

A hatókör-módosítók használatával megtekintheti egy változó értékét a helyi hatókörben és a szülő hatókörben.

Először definiáljon egy változót $test a globális hatókörben.

$test = "Global"

Ezután hozzon létre egy Sample.ps1 szkriptet, amely meghatározza a változót $test . A szkriptben használjon hatókör-módosítót a változó globális vagy helyi verzióira $test való hivatkozáshoz.

A Sample.ps1-ben:

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

Futtatáskor Sample.ps1a kimenetnek a következő kimenethez kell hasonlítania:

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

Ha a szkript befejeződött, a munkamenetben csak a globális érték $test van meghatározva.

PS> $test
Global

3. példa: Változó értékének módosítása egy szülőhatókörben

Ha nem véd meg egy elemet a Privát beállítással vagy más módszerrel, megtekintheti és módosíthatja egy változó értékét a szülőhatókörben.

Először definiáljon egy változót $test a globális hatókörben.

$test = "Global"

Ezután hozzon létre egy Sample.ps1 szkriptet, amely meghatározza a változót $test . A szkriptben használjon hatókör-módosítót a változó globális vagy helyi verzióira $test való hivatkozáshoz.

A Sample.ps1 fájlban:

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

Ha a szkript elkészült, a rendszer megváltoztatja $test a globális értéket.

PS> $test
Local

4. példa: Privát változó létrehozása

A változók privátsá tehetők a private: hatókör-módosítóval, vagy a változó az Option tulajdonsággal Privatevaló létrehozásával. A privát változók csak abban a hatókörben tekinthetők meg vagy módosíthatók, amelyben létrehozták őket.

Ebben a példában a ScopeExample.ps1 szkript öt függvényt hoz létre. Az első függvény meghívja a következő függvényt, amely létrehoz egy gyermekhatókört. Az egyik függvény rendelkezik egy privát változóval, amely csak abban a hatókörben látható, amelyben létrejött.

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

A kimenet a változó értékét jeleníti meg az egyes hatókörökben. Láthatja, hogy a privát változó csak abban a hatókörben funcBlátható, amelyben létrejött.

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'

Ahogy a kimenet mutatja ShowScopes, más hatókörök változóit is elérheti egy hatókörszám használatával Get-Variable és megadásával.

5. példa: Helyi változó használata távoli parancsban

A helyi munkamenetben létrehozott távoli parancs változóihoz használja a using hatókör-módosítót. A PowerShell feltételezi, hogy a távoli parancsok változói a távoli munkamenetben lettek létrehozva.

A szintaxis a következő:

$using:<VariableName>

A következő parancsok például létrehoznak egy változót $Cred a helyi munkamenetben, majd egy távoli parancsban használják a $Cred változót:

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

A using hatókör-módosító a PowerShell 3.0-ban lett bevezetve.

Lásd még

• about_Variables
• about_Environment_Variables
• about_Functions
• about_Script_Blocks
• Start-ThreadJob