Az Scopes-ról

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.

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ö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: 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.

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: – 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.

• 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, miközben szkripteket futtat olyan parancsmagokon keresztül, mint a Start-Job és Invoke-Command.

• 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 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-s kiadásában érhető el.

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 Session paramétereinek használatával (távoli munkamenet)
• A Start-Job (folyamaton kívüli munkamenet) kezdetű háttérfeladatok
• Szálfeladatok, amelyeket a Start-ThreadJob vagy ForEach-Object -Parallel használatával indítottak el (külön szál munkamenet)

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 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ó:

• Start-ThreadJob
• ForEach-objektum

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 objektumpé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 tartalmazza a Deserializedelőtaggal ellátott eredeti típusnevet, például Deserialized.System.Data.DataTable

Az AllScope beállítás

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. 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 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 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.

Ü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 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á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 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 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 globális hatókör-módosító 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 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 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.

In 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:

• a_Változókról
• környezeti változókról
• funkciókról
• Script blokkokról
• Start-ThreadJob