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 gazdafolyamatok 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á.
• A hatókör-módosítók használatával 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 át lesz másolva az aktuális hatókörbe, 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.

Jegyzet

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ót a cikk modulok szakaszában talál.

A gyermekhatókör létrehozásakor az összes olyan aliast és változót tartalmazza, amely rendelkezik az AllScope beállítással, valamint néhány automatikus változóval. 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.

Egy adott hatókör elemeinek megkereséséhez használja a Get-Variable vagy Get-AliasHatókör paraméterét.

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. 4. példa egy privát változó hatását jeleníti meg a hatókör-keresésben.

PowerShell-hatókörnevek

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: A PowerShell indításakor vagy új munkamenet vagy futtatótér létrehozásakor érvényes hatókör. 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ásakor 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.

Az olyan parancsmagok esetében, amelyek támogatják a hatóköröket, a hatókörökre egy szám hivatkozhat, amely leírja egy hatókör másikhoz viszonyított helyzetét. 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ökeret.

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: – Azt adja meg, hogy a név szerepel-e a Globális hatókörben.

• Local: – Megadja, hogy a név szerepel-e a Helyi hatókörben. Az aktuális hatókör mindig a Helyi hatókör. A hatókör-módosító használatakor a Local: PowerShell nem keres szülőhatóköröket. Ha az elem az aktuális hatókörben található, akkor azt használja a rendszer. Ha az elem nem létezik az aktuális hatókörben, a PowerShell létrehoz egy új elemet az aktuális hatókörben.

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

  Jegyzet

  Private: nem hatókör. Ez egy lehetőség,, amely módosítja egy elem akadálymentességét azon 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. szkript hatókör az ő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 távoli munkamenetekben, háttérfeladatokban vagy szálfeladatokban való futtatáskor.

• Workflow: – Azt adja meg, 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éldául:

  Namespace	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 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 Global: módosító értékét:

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

Figyelje meg a Láthatósági és Beállítások tulajdonságértékeket.

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 *

A Private: hatókör-módosító használatával a Beállítások tulajdonságot Privateértékre állítja.

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

Ha ugyanazt a változót szeretné létrehozni a szkriptben hatókörben, 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 "Using" egy speciális hatókör-módosító, amely egy helyi változót azonosít egy távoli utasításban. 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 lett bevezetve.

Minden olyan szkripthez vagy parancshoz, amely munkameneten kívül fut, a Using: hatókör-módosítóra van szüksége a 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, Invoke-Command a ComputerName, HostName, SSHConnection vagy munkamenet paramétereinek használatával (távoli munkamenet)
• A Start-Job (folyamaton kívüli munkamenet) kezdetű háttérfeladatok
• Szálmunkák, amelyeket Start-ThreadJob vagy ForEach-Object -Parallel (külön szálmunkamenet) indít el

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.

A további információkért lásd: about_Remote_Variables.

A $Using: hivatkozás csak egy változó értékére bontható ki. Ha módosítani szeretné egy változó értékét a hívó hatókörében, akkor magának a változónak kell hivatkoznia. A változóra mutató hivatkozást a változó PSVariable példányának lekérésével hozhat létre. Az alábbi példa bemutatja, hogyan hozhat létre hivatkozást, és hogyan végezhet módosításokat egy szálfeladatban.

$Count = 1
$refOfCount = Get-Variable Count

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

$Count

2

Jegyzet

Ez nem szálbiztos művelet. Adatsérülést okozhat, ha egyszerre több szálból próbálja módosítani az értéket. A megosztott adatok védelméhez szálbiztos adattípusokat vagy szinkronizálási primitíveket kell használnia. További információért lásd: Thread-Safe gyűjtemények.

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 átalakítja az objektumokat egy PSObject, 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 objektum példány másolata. Típustulajdonságokkal és metódusokkal rendelkezik. Az olyan egyszerű típusok esetében, mint például System.Version, 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 PSObject példányok. A pstypenames tulajdonság az eredeti típusnevet tartalmazza, amely deszerializáltszerepel, például Deserialized.System.Data.DataTable

Az AllScope opció

A változók és aliasok Option tulajdonsága értéket vehet fel, például AllScope. Az AllScope tulajdonságú elemek a létrehozott gyermekhatókörök részévé válnak, de 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 egy Hatókör paramé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). Az alábbi paranccsal megkeresheti a munkamenet összes olyan parancsmagját, amely rendelkezik Hatókör paraméterrel:

Get-Help * -Parameter Scope

Az adott hatókörben látható változók megkereséséhez használja az ScopeGet-Variable paraméterét. 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.

Jegyzet

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. szintű hatókör az azt megelőző hatókör szülőjé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 Sample.ps1 szkriptet a szkript hatókörében lévő C:\Scripts 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 .ps1 fájlkiterjesztéssel kell rendelkeznie, hogy végrehajtható legyen. 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_Operatorscímű témakörben olvashat bővebben.

A Sample.ps1 szkript helyi hatókörben való futtatásához í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 olyan beállításokkal és funkciókkal, amelyek hasonlóak a hatókörökhöz, és együttműködhetnek a hatókörökkel. 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 munkamenet globális hatókörének alhatókörök.

Ülés

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 egy önálló környezet, saját hatókörrel rendelkezik, de nem annak a munkamenetnek az alá tartozó 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. Például futtathat 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álják explicit módon (Export-ModuleMember vagy a moduljegyzék használatával), 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ő modul C:\temp\mod1.psm1:

$a = "Hello"

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

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

$a = "Goodbye"
foo

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

$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 2. modul a 1. modulbelsejéből töltődik be, akkor a 2. modul az 1. modul hatókörtárolójába kerül betöltésre. A Module2-ből származó exportálások a Module1aktuális modul hatókörébe kerülnek. Ha Import-Module -Scope Localhasznál, akkor az exportálások a legfelső szint helyett az aktuális hatókörobjektumba kerülnek. Ha a modulban a és egy másik modult tölt be a(z) Import-Module -Scope Global (vagy Import-Module -Global) használatával, akkor az a modul és annak exportjai a modul helyi hatóköre helyett a globális hatókörbe lesznek 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 egy szkript hibakeresését végzi, és elér egy töréspontot a szkriptben, belép a szkript hatókörébe.

Privát lehetőség

Az aliasok és a változók Option tulajdonsága Privateértéket vehet fel. Az Private beállítással rendelkező 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 azon 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 parancsok a szkriptben nem jelenítik meg a privát változót. A Global: hatókör-módosító használata ebben a példányban nem jeleníti meg a privát változót.

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

Láthatóság

A Láthatóság tulajdonsága egy változónak vagy aliasnak határozza meg, hogy az elem látható-e 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 ugyanúgy van kialakítva a tárolók számára, mint ahogy a Private tulajdonság értéke a hatókörök számára van kialakítva.

A Láthatóság tulajdonság Public és Private értékeket vesz fel. 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 konténerekhez van tervezve, ezért másként működik egy hatókörben.

• 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 New-Variable és Set-Variable parancsmagokkal 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

Az alábbi parancs módosítja az $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 az aktuális hatókörben lévő $ConfirmPreference változó aktuális értékét.

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 $test változót a globális hatókörben.

$test = "Global"

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

A Sample.ps1:

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

A Sample.ps1futtatásakor a 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 $test globális értéke lesz definiálva.

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 $test változót a globális hatókörben.

$test = "Global"

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

A Sample.ps1:

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

Amikor a szkript elkészült, a $test globális értéke megváltozik.

PS> $test
Local

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

A változó priváttá tehető a Private: hatókör-módosító használatával, vagy a változó létrehozásakor a Option tulajdonság Privatebeállítá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 a funcB-ban, abban a hatókörben látható, amelyben létrehozták.

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 ShowScopeskimenete is mutatja, más hatókörök változóit is elérheti Get-Variable használatával, és megadhat egy hatókörszámot.

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 $Cred változót 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

• környezeti változókról
• a_Függvényekről
• about_Script_Blocks
• a_változókról
• ForEach-Object
• Start-ThreadJob