3. Alapfogalmak

  • Cikk

3.1 Szolgáltatók és meghajtók

A szolgáltató olyan adatokhoz és összetevőkhöz biztosít hozzáférést, amelyek egyébként nem lesznek könnyen elérhetők a parancssorban. Az adatok egy fájlrendszer-meghajtóhoz hasonló konzisztens formátumban jelennek meg.

A szolgáltató által elérhetővé tért adatok egy meghajtón jelennek meg, és az adatokhoz a lemezmeghajtókhoz hasonló elérési úton lehet hozzáférni. Az egyes szolgáltatók beépített parancsmagai kezelik a szolgáltatói meghajtón található adatokat.

A PowerShell a következő beépített szolgáltatókat tartalmazza a különböző típusú adattárak eléréséhez:

Szolgáltató Meghajtó neve Leírás Ref.
Alias Alias: PowerShell-aliasok (3.1.1)
Környezet Env: Környezeti változók (3.1.2)
Fájlrendszer A:, B:, C:, ... Lemezmeghajtók, könyvtárak és fájlok (3.1.3)
Függvény Funkció: PowerShell-függvények (3.1.4)
Változó Változó: PowerShell-változók (3.1.5)

Windows PowerShell:

Szolgáltató Meghajtó neve Leírás
Tanúsítvány Bizonyos: x509-tanúsítványok digitális aláíráshoz
Regisztrációs adatbázis HKLM: (HKEY_LOCAL_MACHINE), HKCU: (HKEY_CURRENT_USER) Windows beállításjegyzék
WSMan WSMan: WS-Management konfigurációs információk

A következő parancsmagok szolgáltatókkal és meghajtókkal foglalkoznak:

  • Get-PSProvider: Egy vagy több szolgáltató adatait lekérte
  • Get-PSDrive: Egy vagy több meghajtóról szerez be információkat

A szolgáltatót jelképező objektum típusát a 4.5.1-es cikk írja le. A meghajtót képviselő objektum típusát a 4.5.2-es cikk írja le.

3.1.1 Aliasok

Az alias egy parancs alternatív neve. Egy parancs több aliast is kaphat, és az eredeti név és az összes aliasa felcserélhető. Az aliasok újra hozzárendeltek. Az alias egy elem (").3.3).

Egy alias hozzárendelhető egy másik aliashoz; az új alias azonban nem az eredeti parancs aliasa.

A szolgáltatói alias egy egyszerű névtér, amely csak az aliasokat képviselő objektumokat tartalmazza. A változók nem tartalmaznak gyermekelemeket.

Egyes aliasok a PowerShellbe vannak beépítve.

A következő parancsmagok aliasokkal foglalkoznak:

Ha egy parancshoz aliast hoz létre a New-Aliashasználatával, az adott parancs paraméterei nem szerepeltethetőek az aliasban. Az Alias: névtér egyik változóhoz való közvetlen hozzárendelése azonban lehetővé teszi paramétereket is.

Megjegyzés

Egyszerű azonban létrehozni egy olyan függvényt, amely nem más, mint az összes kívánt paramétert tartalmazó parancs meghívása, és egy alias hozzárendelése ehhez a függvényhez.

Az aliast jelképező objektum típusát a 4.5.4-es cikk írja le.

Az aliasobjektumokat a rendszer a következő meghajtón tárolja: Alias (").3.1).

3.1.2 Környezeti változók

A PowerShell-környezetszolgáltató lehetővé teszi az operációs rendszer környezeti változóinak lekérését, hozzáadását, változását, törlését és törléset.

A szolgáltatói környezet egy egyszerű névtér, amely csak a környezeti változókat képviselő objektumokat tartalmazza. A változók nem tartalmaznak gyermekelemeket.

A környezeti változók neve nem tartalmazhatja az egyenlőségjelet (=).

A környezeti változók módosításai csak az aktuális munkamenetre vannak hatással.

A környezeti változók elemek (").3.3).

A környezeti változókat képviselő objektumok típusát a 4.5.6-os cikk írja le.

A környezeti változók objektumai az Env meghajtón vannak tárolva (").3.1).

3.1.3 Fájlrendszer

A PowerShell-fájlrendszerszolgáltató lehetővé teszi a könyvtárak és fájlok létrejöttét, megnyitását, változását és törlését.

A fájlrendszer-szolgáltató egy hierarchikus névtér, amely a mögöttes fájlrendszert képviselő objektumokat tartalmaz.

A fájlok olyan meghajtókon vannak tárolva, amelyek neve például A:, B:, C: stb. (3.1). A könyvtárakat és fájlokat elérésiút-adatokat használva érheti el (").3.4).

A könyvtár vagy fájl egy elem (").3.3.

3.1.4-függvények

A PowerShell-függvényszolgáltató lehetővé teszi a függvények (azaz a 8.10-es és a szűrők) lekérését, beolvasását, hozzáadását, módosulását, törlését és törlését ( *8.10.1).

A provider Function egy egyszerű névtér, amely csak a függvény- és szűrőobjektumokat tartalmazza. Sem a függvények, sem a szűrők nem tartalmaznak gyermekelemeket.

A függvények módosításai csak az aktuális munkamenetre vannak hatással.

A függvények elemek (").3.3).

A függvényt képviselő objektum típusát a következő cikk írja le: .4.5.10. A szűrőt képviselő objektum típusát a 4.5.11-es cikk írja le.

A függvényobjektumok a következő meghajtón vannak tárolva: (").3.1).

3.1.5 Változók

A változók közvetlenül a PowerShell nyelven definiálhatók és manipulálhatók.

A provider Variable egy egyszerű névtér, amely csak a változókat képviselő objektumokat tartalmazza. A változók nem tartalmaznak gyermekelemeket.

A következő parancsmagok a változókat is kezelnie kell:

Mivel a változó egy elem (ér 3.3), a legtöbb elemhez kapcsolódó parancsmag képes módosítani.

A változót képviselő objektum típusát a 4.5.3-as cikk írja le.

A változóobjektumok a következő meghajtón vannak tárolva: (").3.1).

3.2 Munkahelyek

Az aktuális munkahely az az alapértelmezett hely, amelyre a parancsok mutatnak. Ezt a helyet használja a rendszer, ha nem ad meg explicit elérési utat (a parancs hívatakor[).3.4]. Ez a hely tartalmazza az aktuális meghajtót.

A PowerShell-gazdagépek több meghajtóval is lehetnek, amely esetben mindegyik meghajtó saját aktuális helyről rendelkezik.

Ha a meghajtó neve címtár nélkül van megadva, a rendszer ennek a meghajtónak az aktuális helyét adja meg.

Az aktuális munkahelyet mentheti egy verembe, majd beállíthatja egy új helyre. Később a mentett hely visszaállítható ebből a veremből, és az aktuálisan működő helyre állítható be. Kétféle hely verem létezik: az alapértelmezett munkahelyi verem , és nulla vagy több felhasználó által definiált elnevezett munkahelyi verem. A munkamenet elkezdődik, az alapértelmezett munkahelyi verem egyben az aktuális munkahelyi verem is. Azonban bármely elnevezett munkahely veremből az aktuális munkahely veremként is fel lehet készülni.

A következő parancsmagok a helyekkel foglalkoznak:

  • Hely beállítása: Meghatározza az aktuális munkahelyet
  • Get-Location : Meghatározza a megadott meghajtó(k) aktuális munkahelyét vagy a megadott verem(ök) munkahelyeit
  • Leküldési hely: Menti az aktuális munkahelyet a megadott helysor tetejére
  • Pop-Location (Előugró hely): Visszaállítja az aktuális munkahelyet a megadott helysor tetejéről

A munkahelyet és a munkahelyek vermét képviselő objektumtípusokat a 4.5.5-ös cikk ismerteti.

3.3 Elemek

Az elemek aliasok (").3.1.1), változók (").3.1.5), függvények (").3.1.4), környezeti változók (").3.1.2) vagy fájlrendszerben található fájlok vagy könyvtárak (").3.1.3).

Az alábbi parancsmagok az elemekkel foglalkoznak:

A következő parancsmagok az elemek tartalmával foglalkoznak:

A könyvtárat képviselő objektum típusát a következő cikk írja le: .4.5.17. A fájlt képviselő objektum típusát a következő cikk írja le: .4.5.18.

3.4 Elérésiút-nevek

Az adattár egy PowerShell-szolgáltatón keresztül elérhető összes elemét egyedileg azonosíthatja az elérési útjaik neve. Az elérési út neve az elem nevének, a tárolónak és az altárolóknak a kombinációja, amelyben az elem található, valamint a PowerShell-meghajtó, amelyen keresztül a tárolók elérhetők.

Az elérési utak nevei két típus egyikében oszlanak meg: teljes és relatív. A teljes elérési út neve az elérési utat felhozó összes elemből áll. Az alábbi szintaxis egy teljes elérési út nevének elemeit mutatja be:

Tipp

A ~opt~ szintaxisdefiníciókban a jel azt jelzi, hogy a lexikális entitás nem kötelező a szintaxisban.

path:
    provider~opt~   drive~opt~   containers~opt~   item

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

A module-name a szülőmodulra vonatkozik.

A szolgáltató arra a PowerShell-szolgáltatóra utal, amelyen keresztül az adattárhoz hozzáfér.

A meghajtó egy adott PowerShell-szolgáltató által támogatott PowerShell-meghajtóra vonatkozik.

A tárolók tartalmazhatnak más tárolókat is, amelyek tartalmazhatnak más tárolókat stb., az utolsó tároló pedig egy elemet tartalmaz. A tárolókat abban a hierarchikus sorrendben kell megadni, amelyben az adattárban vannak.

Példa egy elérési út nevére:

E:\Accounting\InvoiceSystem\Production\MasterAccount\MasterFile.dat

Ha egy elérési út utolsó eleme más elemeket is tartalmaz, akkor az egy tárolóelem; Ellenkező esetben levélelem.

Bizonyos esetekben nincs szükség teljes elérési út nevére; a relatív elérési út neve is elegendő lesz. A relatív elérési út neve az aktuális munkahelyen alapul. A PowerShell lehetővé teszi az elemek azonosítását az aktuális munkahelyhez viszonyított helye alapján. A relatív elérési út neve magában foglal néhány speciális karaktert. Az alábbi táblázat ezeket a karaktereket ismerteti, és példákat mutat be a relatív elérési utak nevére és a teljes elérési utak nevére. A táblázatban lévő példák az aktuális munkakönyvtár C:\Windows:

Szimbólum Leírás Relatív elérési út Teljes elérési út
. Aktuális munkahely .\System C:\Windows\System
.. Az aktuális munkahely szülője ..\Program Files C:\Program Files
\ Az aktuális munkahely gyökérkönyvtára \Program Files C:\Program Files
Nincs Nincsenek speciális karakterek System C:\Windows\System

Ha az elérési út nevét egy parancsban is használnia kell, adja meg ezt a nevet teljes vagy relatív elérési útként.

A következő parancsmagok elérési utakkal foglalkoznak:

Egyes parancsmagok (például a Tartalom hozzáadása és a fájlszűrők Copy-Item használata). A fájlszűrő egy olyan mechanizmus, amely meghatározza az elérési utak egy halmazának kiválasztási kritériumait.

A feloldott elérési utat képviselő objektumtípus leírása a következő: .4.5.5. Az elérési utakat gyakran sztringekként manipulálják.

3.5 Hatókörök

3.5.1 Bevezetés

A nevek egy változót, függvényt, aliast, környezeti változót vagy meghajtót is neveznek. Ugyanaz a név különböző elemeket is nevezhet a szkript különböző helyeiről. A név által jegyzett különböző elemeknél ez a név csak a szkriptszöveg hatókörének nevezett régión belül látható. Az azonos névvel jelöli különböző elemek eltérő hatókörrel vagy különböző névterekben vannak.

A hatókörök beágyazhatnak, ebben az esetben a külső hatókört szülőhatókörnek nevezzük , a beágyazott hatókörök pedig a szülő gyermekhatókörei. A név hatóköre az a hatókör, amelyben definiálva van, és az összes gyermekhatókör, kivéve, ha privátra van adva. A gyermekhatókörben megadott név elrejti az azonos nevű elemeket a szülőhatókörökben.

Hacsak nem használ pont típusú forrás-adatokat (a következő 3.5.5-öst), az alábbiak mind új hatókört hoznak létre:

  • Egy szkriptfájl
  • Egy szkriptblokk
  • Függvény vagy szűrő

Tekintse meg a következő példát:

# start of script
$x = 2; $y = 3
Get-Power $x $y

#function defined in script

function Get-Power([int]$x, [int]$y)
{
if ($y -gt 0) { return $x * (Get-Power $x (--$y)) }

else { return 1 }
}
# end of script

A szkriptben létrehozott változók $x $y hatóköre az adott szkript törzse, beleértve a benne definiált függvényt is. A Get-Power függvény két paramétert határoz meg ugyanazokkal a nevekkel. Mivel mindegyik függvény saját hatókörrel rendelkezik, ezek a változók eltérnek a szülőhatókörben definiáltaktól, és elrejtik azokat a szülőhatókörből. A függvényhatókör a szkripthatókörbe van beágyazva.

Vegye figyelembe, hogy a függvény rekurzívan hívja meg magát. Minden alkalommal, amikor ezt teszi, újabb beágyazott hatókört hoz létre, amelyek mindegyikének saját változói és $x $y.

Megjelenik egy összetettebb példa, amely a beágyazott hatókörök és a nevek újrafelhasználása is látható:

# start of script scope
$x = 2              # top-level script-scope $x created
                    # $x is 2
F1                  # create nested scope with call to function F1
                    # $x is 2
F3                  # create nested scope with call to function F3
                    # $x is 2

function F1 {       # start of function scope
                    # $x is 2
    $x = $true      # function-scope $x created
                    # $x is $true

    & {             # create nested scope with script block
                    # $x is $true
        $x = 12.345 # scriptblock-scope $x created
                    # $x is 12.345
    }               # end of scriptblock scope, local $x goes away

                    # $x is $true
    F2              # create nested scope with call to function F2
                    # $x is $true
}                   # end of function scope, local $x goes away

function F2 {       # start of function scope
                    # $x is $true
    $x = "red"      # function-scope $x created
                    # $x is "red"
}                   # end of function scope, local $x goes away

function F3 {       # start of function scope
                    # $x is 2
    if ($x -gt 0) {
                    # $x is 2
        $x = "green"
                    # $x is "green"
    }               # end of block, but not end of any scope
                    # $x is still "green"
}                   # end of function scope, local $x goes away
# end of script scope

3.5.2 Hatókörnevek és -számok

A PowerShell a következő hatókörök egyikét támogatja:

  • Globális: Ez a legfelső szintű hatókör. Ebben a hatókörben minden automatikus és preferenciaváltozó definiálva van. A globális hatókör az összes többi hatókör szülőhatóköre, a többi pedig a globális hatókör gyermekhatókörei.

  • Helyi: Ez az aktuális hatókör egy szkript, szkriptblokk vagy függvény bármely végrehajtási pontján. Bármelyik hatókör lehet a helyi hatókör.

  • Szkript: Ez a hatókör minden végrehajtott parancsfájlhoz létezik. A szkripthatókör a benne létrehozott összes hatókör szülőhatóköre. A szkriptblokk nem rendelkezik saját szkripthatókörrel; Ehelyett a szkript hatóköre a legközelebbi előd parancsfájljának hatóköre. Bár nincs olyan, hogy modulhatókör, a szkripthatókör biztosítja az egyenértékűt.

A nevek deklarálhatóak privátként, amely esetben nem láthatók a szülőhatókörükn kívül, még a gyermekhatókörökben sem. A privát fogalma nem külön hatókör; Ez a helyi hatókör aliasa, azzal a kiegészítéssel, hogy ha írható helyként használják, elrejti a nevet.

A hatókörök számmal is hivatkozhatóak, amely az egyik hatókör egymáshoz viszonyított pozícióját írja le. A 0 hatókör a helyi hatókört, az 1. hatókör egy 1 generációs előd hatókört, a 2. hatókör pedig egy 2 generációs előd hatókört és így tovább. (A hatókörszámokat változókat manipuláló parancsmagok használják.)

3.5.3 Változónév hatóköre

Ahogy az alábbi éles környezetben is látható, a változók neve a hat különböző hatókör bármelyikével megadva lehet:

variable-scope:
    global:
    local:
    private:
    script:
    using:
    workflow:
    variable-namespace

A hatókör nem kötelező. Az alábbi táblázat az egyes környezetek jelentését mutatja be minden lehetséges környezetben. A hatókört is megjeleníti, ha nincs explicit módon megadva hatókör:

Scope Modifier Szkriptfájlon belül Szkriptblokkon belül Függvényen belül
Globális Globális hatókör Globális hatókör Globális hatókör
parancsfájl A legközelebbi előd szkriptfájl hatóköre, vagy Globális, ha nincs legközelebbi előd szkriptfájl A legközelebbi előd szkriptfájl hatóköre, vagy Globális, ha nincs legközelebbi előd szkriptfájl A legközelebbi előd szkriptfájl hatóköre, vagy Globális, ha nincs legközelebbi előd szkriptfájl
Privát Globális/szkript/helyi hatókör Helyi hatókör Helyi hatókör
Helyi Globális/szkript/helyi hatókör Helyi hatókör Helyi hatókör
Használ Implementáció definiálva Implementáció definiálva Implementáció definiálva
munkafolyamat Implementáció definiálva Implementáció definiálva Implementáció definiálva
Nincs Globális/szkript/helyi hatókör Helyi hatókör Helyi hatókör

A változó hatókörre vonatkozó információk a (*3.1.5) alatt felsorolt parancsmagok család használata esetén is megadva vannak. További információért tekintse meg a paramétertScope, valamint a és Option AllScope Option Private a paramétert.

A hatókör using egy másik hatókörben Start-Jobdefiniált változók elérésére használható, miközben szkripteket futtat olyan parancsmagokkal, mint a , Invoke-Commandvagy egy inlinescript-utasításon belül. Például:

$a = 42
Invoke-Command --ComputerName RemoteServer { $using:a } # returns 42
workflow foo
{
    $b = "Hello"
    inlinescript { $using:b }
}
foo # returns "Hello"

A hatókör-munkafolyamat párhuzamos utasítással vagy sequence-utasítással együtt használható a munkafolyamatban definiált változók eléréséhez.

3.5.4 Függvénynév hatóköre

A függvények neve a négy különböző hatókör egyike is lehet, és a név láthatósága megegyezik a változók láthatóságával (").3.5.3).

3.5.5 Dot source notation

Ha egy szkriptfájlt, szkriptblokkot vagy függvényt egy másik szkriptfájlból, szkriptblokkból vagy függvényből hajt végre, a végrehajtott szkriptfájl létrehoz egy új beágyazott hatókört. Példa:

Script1.ps1
& "Script1.ps1"
& { ... }
FunctionA

Ha azonban pontos forrásként való megadást használ, a parancs végrehajtása előtt nem jön létre új hatókör, így a saját helyi hatókörében végrehajtott kiegészítések/módosítások ehelyett az aktuális hatókörben vannak végrehajtva. Példa:

. Script2.ps1
. "Script2.ps1"
. { ... }
. FunctionA

3.5.6 modulok

A legfelső szintű szkriptfájlhoz hasonló a hierarchikus beágyazott hatókörfa gyökerében van, ahogy az egyes modulok (").3.14) is. Alapértelmezés szerint azonban csak a modul által exportált nevek érhetők el név alapján az importálási környezetből. Az Import-Module parancsmag Globális paramétere lehetővé teszi az exportált nevek jobb átláthatóságát.

3.6 Csak olvasható és állandó tulajdonságok

A változókat és aliasokat olyan objektumok írják le, amelyek számos tulajdonságot tartalmaznak. Ezeket a tulajdonságokat két parancsmagcsalád adja meg és módosítja (").3.1.5, ").3.1.1). Az egyik ilyen tulajdonság az Options (Beállítások), amely beállítható ReadOnly (Csak olvasható) vagy Constant (Állandó) értékre (az Option paraméter használatával). A ReadOnly jelölésű változók vagy aliasok eltávolíthatók, és a tulajdonságaik módosíthatók, ha meg van adva a Force paraméter. A Constant jelölésű változók vagy aliasok azonban nem távolíthatók el, és a tulajdonságaik sem módosíthatók.

3.7 Metódus-túlterhelések és hívásfeloldás

3.7.1 Bevezetés

A végrehajtási környezet által elérhetővé tett (és a PowerShelltől különböző nyelven írt) külső eljárásokat metódusnak nevezzük.

A metódus nevét a paraméterek számával és típusával együtt ennek a metódusnak az aláírásának nevezzük. (Vegye figyelembe, hogy az aláírás nem tartalmazza a metódus visszatérési típusát.) A végrehajtási környezet lehetővé teheti, hogy egy típus több, azonos nevű metódussal is rendelkezik, feltéve, hogy mindegyik más aláírással rendelkezik. Egy metódus több verziójának definiáláskor a metódus túlterheltnek minősül. A Math (érc.4.3.8) Abstípus például egy nevű metóduskészletet tartalmaz, amely kiszámítja egy adott szám abszolút értékét, ahol a megadott szám többféle típus egyikével is lehet. A készlet metódusai a következő aláírásokkal vannak felállítva:

Abs(decimal)
Abs(float)
Abs(double)
Abs(int)
Abs(long)
Abs(SByte)
Abs(Int16)

Ebben az esetben az összes metódusnak azonos számú argumentuma van; az aláírásuk csak argumentumtípusonként eltérő.

Egy másik példa a Tömb (áv 4.3.2) típus, amely a Másolás nevű metóduskészletet tartalmazza, amely az elemek tartományát másolja egyik tömbből a másikba, az egyes tömbök elejétől kezdve (alapértelmezés szerint) vagy valamilyen kijelölt elemen. A készlet metódusai a következő aláírásokkal vannak felállítva:

Copy(Array, Array, int)
Copy(Array, Array, long)
Copy(Array, int, Array, int, int)
Copy(Array, long, Array, long, long)

Ebben az esetben az aláírások argumentumtípus, bizonyos esetekben argumentumszám szerint is eltérnek.

A legtöbb túlterhelt metódus hívásában a átadott argumentumok száma és típusa pontosan megegyezik az egyik túlterhelés számával, és a kiválasztott metódus nyilvánvaló. Ha azonban nem ez a helyzet, meg kell oldania, hogy melyik túlterhelt verziót hívja meg, ha van ilyen. Példa:

[Math]::Abs([byte]10) # no overload takes type byte
[Array]::Copy($source, 3, $dest, 5L, 4) # both int and long indexes

További példák a típussring (pl. System.String), amely számos túlterhelt metódust tartalmaz.

Bár a PowerShell rendelkezik olyan szabályokkal a metódushívások feloldására, amelyek nem egyeznek pontosan egy túlterhelt aláírással, maga a PowerShell nem biztosít módot a túlterhelt metódusok meghatározására.

Megjegyzés

Szerkesztő megjegyzése: A PowerShell 5.0 hozzáadta a szkriptalapú osztályok definiálási képességét. Ezek az osztályok túlterhelt metódusokat tartalmazhatnak.

3.7.2 A metódus túlterhelésének feloldási megoldása

Ha egy metódushívás (a 7.1.3) argumentumkifejezések listáját és a jelöltek metóduskészletét (vagyis a hívható metódusokat) tartalmazza, a legjobb metódus kiválasztásának mechanizmusát túlterhelés-feloldásnak nevezzük.

A megfelelő metódusok készlete (ér 3.7.3) alapján a készletben a legjobb módszer van kiválasztva. Ha a készlet csak egy metódust tartalmaz, akkor ez a legjobb módszer. Ellenkező esetben a legjobb metódus az egyetlen metódus, amely jobb, mint az összes többi metódus az adott argumentumlistához képest a 3.7.4-es szabályokkal. Ha nem létezik olyan metódus, amely minden más metódusnál jobb lenne, akkor a metódus meghívása nem egyértelmű, és hibaüzenetet kap.

A legjobb metódusnak elérhetőnek kell lennie abban a környezetben, amelyben a metódust hívják. A PowerShell-szkriptek például nem hívhatnak meg privát vagy védett metódusokat.

A statikus metódusok hívásának legjobb metódusának statikus metódusnak kell lennie, és a példány metódusának a legjobb metódusnak példányos metódusnak kell lennie.

3.7.3 Alkalmazható módszer

Egy metódus akkor alkalmazható az A argumentumlista esetén, ha az alábbiak egyike igaz:

  • Az A argumentumai száma megegyezik a metódus által elfogadt paraméterek számával.
  • A metódus M kötelező és N választható paraméterekkel rendelkezik, és az A argumentumainak száma nagyobb vagy egyenlő, mint M, de N-nél kevesebb.
  • A metódus változó számú argumentumot fogad el, és az A argumentumai száma nagyobb, mint a metódus által elfogadt paraméterek száma.

A megfelelő számú argumentum mellett az A argumentum minden argumentumának meg kell egyeznie az argumentum paraméterátadási módjával, és az argumentum típusának meg kell egyeznie a paramétertípussal, vagy az argumentumtípusról a paraméter típusra kell átalakítást alkalmazni.

If the argument type is ref (§4.3.6), the corresponding parameter must also be ref, and the argument type for conversion purposes is the type of the property Value from the ref argument.

Ha az argumentum típusa ref, a megfelelő paraméter lehet a out helyett ref.

Ha a metódus változó számú argumentumot fogad el, a metódus normál vagy bővített formában is alkalmazható lehet. Ha az A argumentumai száma megegyezik a metódus által elfogadandó paraméterek számával, és az utolsó paraméter egy tömb, akkor az űrlap a két lehetséges konverzió egyikének rangját használja:

  • Az A utolsó argumentumának típusától az utolsó paraméter tömbtípusra konvertálásának rangja.
  • Az A utolsó argumentumának típusától az utolsó paraméter tömbtípusának elemtípusig való konvertálásának rangja.

Ha az első átalakítás (tömb típusra) jobb, mint a második átalakítás (a tömb elemtípusa), akkor a metódus normál formában alkalmazható, ellenkező esetben bővített formában.

Ha több argumentum van, mint paraméter, akkor lehetséges, hogy a metódus csak kibontott formában alkalmazható. A bővített formában való alkalmazhatósághoz az utolsó paraméternek tömbtípussal kell lennie. A metódust egy egyenértékű metódus váltja fel, amelynél az utolsó paraméter az A minden nem egyező argumentumának megfelelő paraméterekkel van lecserélve. Minden további paramétertípus az eredeti metódus utolsó paraméterének tömbtípusának elemtípusa. Az alkalmazható metódus fenti szabályait a rendszer alkalmazza erre az új metódusra és az A argumentumlistára.

3.7.4 Better metódus

Egy argumentumlista esetén az A { E~1~, E~2~, ..., E~N~ } M~P~ M~P~ M~Q~ M~Q~``M~P~ { P~1~, P~2~, ..., P~N~ } { Q~1~, Q~2~, ..., Q~N~ }``M~Q~ argumentum-kifejezésekkel és két alkalmazás-metódussal, valamint a paramétertípusokkal és a paramétertípusokkal jobb módszerként van definiálva, mintha a konvertálásának összesített rangsorolása jobb lenne, mint a esetében.

A konverziók kumulatív rangsorolása az alábbiak szerint van kiszámítva. Minden konverzió a paraméterek számától függően más értéket ér, E~1~ az N,N-1 E~2~ értéket pedig 1-re E~N~ . Ha a -E~X~ P~X~ Q~X~``E~X~ ről a -re való átalakítás jobb, mint a és a között, M~P~ az N-X+1-et összesül, M~Q~ ellenkező esetben az N-X+1 halmozott. Ha M~P~ a és M~Q~ a értéke megegyezik, akkor a rendszer a következő, sorrendben alkalmazott tie breaking (kötetlen) szabályokat alkalmazza:

  • A paramétertípusok közötti konverziók kumulatív rangsorolása (az argumentumtípusok figyelmen kívül hagyása) az előző rangsoroláshoz hasonló módon van kiszámítva, P~1~ Q~1~így összehasonlítva a értékhez , P~2~ Q~2~a P~N~ , a stb. és a hez Q~N~képest. A rendszer kihagyja az összehasonlítást, ha az argumentum $null, vagy ha a paramétertípusok nem numerikus típusok. Az összehasonlítás akkor is E~X~ P~X~ Q~X~ki lesz hagyva, ha az argumentum konvertálása információ veszhet el, ha a konvertálva van, de nem veszíti el az adatokat, ha az -re van konvertálva, vagy fordítva. Ha összehasonlítja a paraméterkonverzió-típusokat, P~X~ Q~X~ P~X~``Q~X~ M~P~ akkor ha a típusról a típusra való átalakítás jobb, mint a értékről a típusra, akkor az N-X+1 érték összegyűl, M~Q~ ellenkező esetben pedig N-X+1 érték gyűlik össze. Ez az összekapcsolási szabály a legspecifikusabb metódust (vagyis a legkisebb adattípusú paraméterekkel rendelkező metódust) részesíti előnyben, ha az átalakítás során nem vesznek el információk, vagy a leg általánosabb módszert (vagyis a legnagyobb adattípusú paraméterekkel rendelkező metódust) részesíti előnyben, ha az átalakítások információvesztést eredményeznek.
  • Ha mindkét metódus a bővített formát használja, a több paramétert is használhatja a jobb módszer.
  • Ha az egyik módszer a kibontott formát, a másik pedig normál formát használ, akkor a normál formát használó metódus a jobb módszer.

3.7.5 Jobb átalakítás

Az alábbi, ehhez hasonló szöveg csak a Windows PowerShell.

A konverziók a következő sorrendben vannak rangsorolva, a legalacsonyabbtól a legmagasabbig:

  • T~1~[]odaT~2~[], ahol nincs hozzárendelhető átalakítás a és T~1~ a között T~2~
  • T–sztring, ahol a T bármilyen típusú lehet
  • T~1~ a T~2~ implementáció T~1~ által T~2~ meghatározott módon történő egyéni átalakítás végrehajtásához vagy definiáláshoz
  • T~1~ a T~2~ hová implementálja T~1~ az IConvertible-t
  • T~1~ a T~2~ metódus T~1~ megvalósításához vagy T~2~ megvalósításához T~2~ op_Implicit(T1)
  • T~1~ a T~2~ metódus T~1~ megvalósításához vagy T~2~ megvalósításához T~2~ op_Explicit(T1)
  • T~1~ oda T~2~ , ahol T~2~ implementálja a konstruktort, amely egyetlen típusú argumentumot vesz fel T~1~
  • Az alábbi átalakítások bármelyike:
    • sztring, T ahová T a statikus metódust implementálja, vagy T Parse(string)``T Parse(string, IFormatProvider)
    • T~1~ ahol T~2~ a T~2~ bármilyen felsorolás, T~1~ és vagy sztring, vagy sztringgé konvertálható objektumok gyűjteménye
  • T a PSObjectbe, ahol T bármely típus
  • Az alábbi átalakítások bármelyike: Language
    • T és bool, ahol T bármilyen numerikus típus
    • sztring T , ahol T a regex, wmisearcher, wmi, wmiclass, adsi, adsisearcher, vagy type
    • T a(nak) bool
    • T~1~ – oda Nullable[T~2~] , ahonnan a átalakítás T~1~ T~2~ létezik
    • T a érvénytelenítéshez
    • T~1~[] arra T~2~[] a helyre, ahol a és a közötti hozzárendelhető T~1~ átalakítás T~2~ létezik
    • T~1~ a T~2~[] gyűjtemény T~1~ helyéhez
    • IDictionary a(nak) Hashtable
    • T a(nak) ref
    • T a(nak) xml
    • scriptblock a(nak) delegate
    • T~1~ a T~2~ where T~1~ is a integer type (egész szám típus) és T~2~ a (enum)
  • $nulla where T is any value type (Tértéktípus)
  • $null a T where T is any reference type (a hely, ahol bármely referenciának van típusa)
  • Az alábbi átalakítások bármelyike:

    • bájttól a következő helyhez T T : SByte

    • UInt16a T , T SByte``bytevagy helyhezInt16

    • Int16a T vagy a T helyhez SByte``byte

    • UInt32a T , T SByte, byte``Int16, UInt16vagy helyhezint

    • inta T , T SByte, byte``Int16vagy helyhezUInt16

    • UInt64a T , T SByte, byte``Int16, UInt16, , int, UInt32vagy helyhezlong

    • longa T , T SByte, byte``Int16, UInt16, , intvagy helyhezUInt32

    • float ahol T a T bármilyen egész szám típusú, vagy decimal

    • double ahol T a T bármilyen egész szám típusú, vagy decimal

    • decimal a T where T is any integer type (a hely, ahol bármilyen egész számtípus)

  • Az alábbi átalakítások bármelyike:
    • SBytea T , T byte, uint6``UInt32vagy helyhezUInt64
    • Int16a T , T UInt16``UInt32vagy helyhezUInt64
    • inta T vagy a T helyhez UInt32``UInt64
    • long a(nak) UInt64
    • decimala T vagy a T helyhez float``double
  • Az alábbi átalakítások bármelyike:
    • T a string where T is any numeric type
    • T a char where T is any numeric type
    • string a T where T is any numeric type
  • Az alábbi átalakítások bármelyike hozzárendelhető konverziónak számít:
    • bytea T , T Int16, int``UInt16, UInt32, , long, , UInt64``single, doubleés helyhezdecimal
    • SBytea T , T Int16, int``UInt16, UInt32, , long, , UInt64``single, doubleés helyhezdecimal
    • UInt16a T , T int, UInt32``longvagy UInt64, , , single, doublevagy helyhezdecimal
    • Int16a T , T int, UInt32``longvagy UInt64, , , single, doublevagy helyhezdecimal
    • UInt32 a T , T longvagy UInt64, single, vagy doublehelyhez decimal
    • inta T , T long, UInt64``single, doublevagy helyhezdecimal
    • single a(nak) double
  • T~1~``T~2~ ahol T~2~ a az alaposztálya vagy felületeT~1~. Ez az átalakítás hozzárendelhető konverziónak minősül.
  • string a(nak) char[]
  • T – – T Ez az átalakítás hozzárendelhető konverziónak minősül.

Az űrlap minden olyan átalakítása esetén, ahol nem tömb, és nincs más konverzió, ha a értékről a -be van átváltva, T~2~``T~1~ T~2~``T~1~ T~1~ a konverzió rangsora rosszabb, mint a -ről a-be való átváltás, de jobban, mint bármely más konverzió, amely alacsonyabb, mint a és a között.T~1~ T~2~[] T~1~``T~2~

3.8 Névkeresés

Különböző típusú parancsok is lehetségesek, amelyek mindegyikének ugyanaz a neve. Ilyen esetben a névkeresés sorrendje az alias, a függvény, a parancsmag és a külső parancs.

3.9 Típusnév-keresés

A 7.1.10 a következő utasítást tartalmazza: "A típus-literál egy implementációban egy nem meghatározott mögöttes típussal van ábrázolva. Ennek eredményeképpen a típusnév az alapul szolgáló típus szinonimája." Ilyen típusok például a int, doublea , long[]a és Hashtablea .

A típusnevek a következők szerint vannak megfeleltetve: Hasonlítsa össze egy adott típus nevét a beépített típusgyorsítók listájával , például int, long, double. Ha talál egyezést, az a típus. Ellenkező esetben feltételezni kell, hogy a típusnév teljesen minősített, és nézze meg, hogy létezik-e ilyen típus a gazdarendszeren. Ha talál egyezést, az a típus. Ellenkező esetben adja hozzá a névtér előtagját System.. Ha talál egyezést, az a típus. Ellenkező esetben a típus neve hibás. Ezt az algoritmust az általános típusok minden típus-argumentuma esetében alkalmazza a rendszer. Nem szükséges azonban megadni az aritást (a függvény vagy operátor által tett argumentumok vagy operandusok számát).

3.10 Automatikus memóriakezelés

A különböző operátorok és parancsmagok a memória lefoglalását eredményezik a referenciás típusú objektumok, például sztringek és tömbök számára. A memória lefoglalását és felszabadítása a PowerShell-futtatás rendszerével kezelhető. Ez azt jelenti, hogy a PowerShell automatikus szemétgyűjtést biztosít.

3.11 Végrehajtási sorrend

A mellékhatás a parancs végrehajtási környezetének állapotának megváltozása. A változók értékének módosítása (a hozzárendelési operátorokkal, illetve a pre- és utólagos növelés és növelés operátorokkal) egy mellékhatás, akár egy fájl tartalmának módosítása.

Ha másként nincs megadva, az utasítások lexikális sorrendben vannak végrehajtva.

Egyes operátorok kivételével a kifejezések kifejezésben szereplő kifejezések kiértékelési sorrendje és a mellékhatások sorrendje nincs meghatározva.

A parancsot meghívó kifejezés magában foglalja a parancsot ki kijelölő kifejezést, valamint nulla vagy több olyan kifejezést, amely kijelöli azokat az argumentumokat, amelyeknek az értékeit át kell adni a parancsnak. A kifejezések egymáshoz viszonyított kiértékelésének sorrendje nincs meghatározva.

3.12 Hibakezelés

Ha egy parancs meghiúsul, ez hiba, és a hibával kapcsolatos információk egy hibarekordban vannak rögzítve, amelynek típusa nincs meghatározva (").4.5.15); Ez a típus azonban támogatja az alscriptet.

A hibák két kategóriába sorolhatók. Vagy megszakítja a műveletet (egy megszakítást megszakító hibát), vagy nem ( megszakítást nem megszakító hiba). Megszakítást jelező hiba esetén a rendszer rögzíti a hibát, és a művelet leáll. Megszakítás nélküli hiba esetén a rendszer rögzíti a hibát, és folytatja a műveletet.

A megszakítást nem meg nem hozó hibák a hibastreambe vannak írva. Bár ezek az információk átirányíthatók egy fájlba, a hibaobjektumok először sztringekká lesznek konvertálva, és az objektumokban lévő fontos információk nem lesznek rögzítettek, ami megnehezíti a diagnosztikát, ha nem lehetetlen. Ehelyett a hibaszöveg átirányítható (azaz 7.12), és a hibaobjektum egy változóban menthető, ahogyan a fájlban is $Error1 = command 2>&1.

Az automatikus változó $Error a legutóbbi hibákat képviselő hibarekordok gyűjteményét tartalmazza, a legutóbbi hiba pedig a fájlban található $Error[0]. Ez a gyűjtemény egy pufferben van fenntartva, így a régi rekordokat a rendszer elveti az újak hozzáadásakor. Az automatikus változó $MaximumErrorCount szabályozza a tárolható rekordok számát.

$Error az összes, egy gyűjteményben vegyesen vegyes parancsból származó hibát tartalmazza. A hibák egy adott parancsból való gyűjtéséhez használja az ErrorVariable közös paramétert, amely lehetővé teszi, hogy egy felhasználó által definiált változót határoz meg a gyűjteményhez.

3.13 Pipelines

A folyamat egy vagy több parancs sorozata, amelyek mindegyikét | a folyamat operátora választja el (U+007C). Minden parancs bemenetet kap az elődjétől, és kiírja a kimenetet az utódjának. Hacsak a folyamat végén található kimenetet nem veti el vagy nem irányítja át egy fájlba, a rendszer a gazdakörnyezetbe küldi, amely dönthet úgy, hogy standard kimenetbe írja. A folyamat parancsai argumentumok bemenetét is fogadhatják. Vegyük Get-ChildItem``Sort-Object``Process-Filepéldául a következő parancsokat, a , és parancsokat, amelyek fájlnevek listáját hozják létre egy adott fájlrendszerkönyvtárban, rendezik a szöveges rekordok egy halmazát, és valamilyen feldolgozást végeznek egy szöveges rekordon:

Get-ChildItem
Get-ChildItem e:*.txt | Sort-Object -CaseSensitive | Process-File >results.txt

Az első esetben Get-ChildItem a az aktuális/alapértelmezett könyvtárban található fájlok nevének gyűjteményét hozza létre. Ez a gyűjtemény a gazdakörnyezetbe lesz elküldve, amely alapértelmezés szerint minden elem értékét standard kimenetre írja.

A második esetben Get-ChildItem a a megadott könyvtárban található fájlok nevének gyűjteményét hozza létre a argumentum használatával e:*.txt. Ez a gyűjtemény a Sort-Objectparancsba van írva, amely alapértelmezés szerint növekvő sorrendbe rendezi őket, megkülönböztetve a kis- és nagybetűket (a CaseSensitive argumentum miatt). Az eredményül kapott gyűjtemény ezután a parancsba lesz írva Process-File, amely (ismeretlen) feldolgozást végez. A parancs kimenete ezután a fájlba lesz átirányítva results.txt.

Ha egy parancs egyetlen objektumot ír, az utódja megkapja ezt az objektumot, majd le fog állni, miután a saját objektuma(i)t írta az utódjának. Ha azonban egy parancs több objektumot ír, azokat a rendszer egyszerre csak egyszer kézbesíti az utódparancsnak, amely objektumonként egyszer fut le. Ezt a viselkedést streamelésnek nevezzük. A streamfeldolgozás során a rendszer az objektumokat a folyamaton keresztül írja, amint elérhetővé válnak, nem pedig a teljes gyűjtemény létrehozása után.

Gyűjtemény feldolgozásakor egy parancs úgy írható meg, hogy speciális feldolgozást is képes legyen a kezdeti elem előtt és az utolsó elem után is.

3.14 Modulok

A modulok önálló, újrahasználható egységek, amelyek lehetővé teszik a PowerShell-kódok particionálását, rendszerezését és absztrakcióját. A modulok egyetlen egységként használható parancsokat (például parancsmagokat és függvényeket) és elemeket (például változókat és aliasokat) tartalmazhatnak.

A modult a létrehozása után importálni kell egy munkamenetbe, mielőtt a benne lévő parancsok és elemek használhatók lesznek. Az importálás után a parancsok és elemek úgy viselkednek, mintha helyileg lenne definiálva. A modul explicit módon importálva lesz az paranccsal Import-Module . A modulok automatikusan importálhatók a megvalósítás által meghatározott módon.

A modult képviselő objektum típusát a következő cikk írja le: .4.5.12.

A modulokat részletesen a következőben tárgyaljuk: .11.

3.15 Helyettesítő karakteres kifejezések

A helyettesítő karakteres kifejezések az alábbi elemek közül nulla vagy több elemet tartalmazhatnak:

Elem Leírás
A *, ?, vagy [ karakteren kívül Az egy karakterre illeszkedik
* Nulla vagy több karakterre illeszkedik. A * karakterrel való egyeztetéshez használja a [*] karaktert.
? Egy karakterre illeszkedik. Egyezéshez ? character, használja a [?] karaktert.
[set]

A készlet bármely karakterét megegyezik, amely nem lehet üres.

Ha a beállítás kezdete ], akkor a jobb oldali szögletes zárójel a készlet részét képezi, és a következő, jobb oldali szögletes zárójel lezárja a készletet; Ellenkező esetben az első jobb oldali szögletes zárójel lezárja a készletet.

Ha a készlet a -jellel kezdődik vagy végződik, akkor a kötőjel és a mínusz a készlet részének számít; Ellenkező esetben egymást követő Unicode-kódpontok tartományát jelöli, amelyekben a kötőjel-mínusz karakterek a befogadó tartományhatárolók. Az A-Z például a 26 nagybetűs angol betűt, a 0–9 pedig a 10 tizedesjegyet jelöli.

Megjegyzés

További információ: The Open Group Base Specifications: Pattern Matching", IEEE Std 1003.1, 2004 Edition.. A PowerShellben azonban a escape-karakter a backtick, nem pedig a perjel.

3.16 Reguláris kifejezések

A reguláris kifejezések az alábbi elemek közül nulla vagy több elemet tartalmazhatnak:

Elem Leírás
A ., [, ^, *, $, vagy \ karakteren kívül más karakter Az egy karakterre illeszkedik
. Egy karakterre illeszkedik. Egyezéshez: . karakterrel, használja a et \..
[set]
[^set]

A [set] űrlap a készlet bármely karakterének megfelel. A [^set] űrlap nem egyezik a beállított karakterekkel. A set nem lehet üres.

Ha a beállítás kezdete ] vagy ^], akkor a jobb oldali szögletes zárójel a készlet részét képezi, és a következő jobb oldali szögletes zárójel lezárja a készletet; Ellenkező esetben az első jobb oldali szögletes zárójel lezárja a készletet.

Ha a készlet kezdete - vagy ^-, vagy végződésű -, akkor a kötőjel-mínusz a készlet részének számít; Ellenkező esetben egymást követő Unicode-kódpontok tartományát jelöli, amelyekben a kötőjel-mínusz karakterek a befogadó tartományhatárolók. Az A-Z például a 26 nagybetűs angol betűt, a 0–9 pedig a 10 tizedesjegyet jelöli.
* Az előző elem több előfordulásának nullára illeszkedik.
+ Az előző elem egy további előfordulásának egyezése.
? Nulla az előző elem egy előfordulásából.
^ Illeszkedik a sztring elején. A ^ karakterrel való egyeztetéshez használja a következőt: \^.
$ A sztring végén egyezést ad meg. Egy $ karakter egyeztetéshez használja a $ karaktert.
\C A c karaktert escape-karakterrel karakterrel kell felismerni, hogy ne ismerhető fel reguláriskifejezés-elemként.

Megjegyzés

További információ: The Open Group Base Specifications: Regular Expressions, IEEE Std 1003.1, 2004 Edition.

Windows PowerShell: A Microsoft .NET-keretrendszer elérhető karakterosztályok a következőképpen támogatottak:

Elem Leírás
\p{name} A névvel megadott elnevezett karakterosztályban szereplő bármely karakterre illeszkedik. A támogatott nevek unicode-csoportok és blokktartományok, például Ll, Nd, Z, IsGreek és IsBoxDrawing.
\P{name} Olyan szövegre illeszkedik, amely nem szerepel a névben megadott csoportokban és blokktartományban.
\w Bármilyen szó karakterre illeszkedik. A Unicode-karakterkategóriáknak felel meg [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]. Ha az ECMAScript-kompatibilis viselkedés az ECMAScript beállítással van megadva, a \w egyenértékű az értékével [a-zA-Z_0-9].
\W Bármely nem szóból karakterre illeszkedik. Egyenértékű a Unicode-kategóriákkal [\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}].
\s Bármilyen szóköz karakterre illeszkedik. A Unicode-karakterkategóriáknak felel meg [\f\n\r\t\v\x85\p{Z}].
\S Bármely nem szóköz karakterre illeszkedik. A Unicode-karakterkategóriáknak felel meg [\^\f\n\r\t\v\x85\p{Z}].
\d Bármely tizedesjegyre illeszkedik. Unicode és \p{Nd} nem Unicode [0-9] viselkedés esetén egyenértékű.
\D Bármely nem számjegyre illeszkedik. Unicode és \P{Nd} nem Unicode [\^0-9] viselkedés esetén egyenértékű.

A Microsoft-ban .NET-keretrendszer reguláris kifejezések a következőképpen támogatottak:

Elem Leírás
* Nulla vagy több egyezést ad meg; például vagy \w* egyenértékű (abc)*. a következővel: {0,}.
+ Az előző karakterek ismétlődő példányainak megfeleltethető.
? Nulla vagy egy egyezést ad meg; például vagy \w? (abc)?. Ezzel egyenértékű {0,1}: .
{n} Pontosan n egyezést ad meg; például: (pizza){2}.
{n,} Legalább n egyezést ad meg; például: (abc){2,}.
{n,m} Legalább n,de nem több, mint m egyezést ad meg.