3. Grundläggande begrepp

Artikel
03/09/2022
30 minuter för att läsa

3.1 Leverantörer och enheter

En provider ger åtkomst till data och komponenter som annars inte skulle vara lättillgängliga på kommandoraden. Data presenteras i ett konsekvent format som liknar en filsystemenhet.

De data som en provider exponerar visas på en enhet och data nås via en sökväg precis som med en diskenhet. Inbyggda cmdlets för varje provider hanterar data på providerenheten.

PowerShell innehåller följande uppsättning inbyggda providers för åtkomst till de olika typerna av datalager:

Leverantör	Enhetsnamn	Beskrivning	Referens.
Alias	Alias:	PowerShell-alias	3.1.1
Miljö	Env:	Miljövariabler	–3.1.2
Filsystem	A:, B:, C:, ...	Diskenheter, kataloger och filer	–3.1.3
Funktion	Funktion:	PowerShell-funktioner	3.1.4
Variabel	Variabel:	PowerShell-variabler	–3.1.5

Windows PowerShell:

Leverantör	Enhetsnamn	Beskrivning
Certifikat	Cert:	x509-certifikat för digitala signaturer
Register	HKLM: (HKEY_LOCAL_MACHINE), HKCU: (HKEY_CURRENT_USER)	Windows register
WSMan	WSMan:	WS-Management konfigurationsinformation

Följande cmdlets hanterar leverantörer och enheter:

Get-PSProvider: Hämtar information om en eller flera leverantörer
Get-PSDrive: Hämtar information om en eller flera enheter

Typen av ett objekt som representerar en provider beskrivs i 4.5.1. Typen av ett objekt som representerar en enhet beskrivs i -4.5.2.

3.1.1 Alias

Ett alias är ett alternativt namn för ett kommando. Ett kommando kan ha flera alias, och det ursprungliga namnet och alla dess alias kan användas synonymt. Ett alias kan tilldelas på nytt. Ett alias är ett objekt (3.3).

Ett alias kan tilldelas till ett annat alias. Det nya aliaset är dock inte ett alias för det ursprungliga kommandot.

Provideralias är en platt namnrymd som endast innehåller objekt som representerar alias. Variablerna har inga underordnade objekt.

Vissa alias är inbyggda i PowerShell.

Följande cmdlets hanterar alias:

New-Alias: Skapar ett alias
Set-Alias: Skapar eller ändrar ett eller flera alias
Get-Alias: Hämtar information om ett eller flera alias
Export-Alias: Exporterar ett eller flera alias till en fil

När ett alias skapas för ett kommando med , New-Aliaskan parametrar till det kommandot inte inkluderas i det aliaset. Direkt tilldelning till en variabel i aliaset: namnområdet tillåter dock att parametrar inkluderas.

Anteckning

Det är dock enkelt att skapa en funktion som bara innehåller anropet av kommandot med alla önskade parametrar och att tilldela ett alias till den funktionen.

Typen av ett objekt som representerar ett alias beskrivs i -4.5.4.

Aliasobjekt lagras på enhetens alias: (–3.1).

3.1.2 Miljövariabler

PowerShell-miljöprovidern tillåter att operativsystemmiljövariabler hämtas, läggs till, ändras, rensas och tas bort.

Providermiljön är en platt namnrymd som endast innehåller objekt som representerar miljövariablerna. Variablerna har inga underordnade objekt.

Miljövariabelns namn får inte innehålla likhetstecknet (=).

Ändringar i miljövariablerna påverkar endast den aktuella sessionen.

En miljövariabel är ett objekt (3.3).

Typen av ett objekt som representerar en miljövariabel beskrivs i -4.5.6.

Miljövariabelobjekt lagras på enheten Miljö: (3.1).

3.1.3 Filsystem

PowerShell-filsystemprovidern tillåter att kataloger och filer skapas, öppnas, ändras och tas bort.

Filsystemsprovidern är ett hierarkiskt namnområde som innehåller objekt som representerar det underliggande filsystemet.

Filer lagras på enheter med namn som A:, B:, C: och så vidare (3.1). Kataloger och filer nås med sökvägs notation (3.4).

En katalog eller fil är ett objekt (3.3).

3.1.4 Funktioner

Med PowerShell-funktionsprovidern kan funktioner (8.10) och filter (·8.10.1) hämtas, läggas till, ändras, rensas och tas bort.

Providerfunktionen är ett platt namnområde som endast innehåller funktions- och filterobjekten. Varken funktioner eller filter har underordnade objekt.

Ändringar av funktionerna påverkar endast den aktuella sessionen.

En funktion är ett objekt (3.3).

Typen av ett objekt som representerar en funktion beskrivs i -4.5.10. Typen av ett objekt som representerar ett filter beskrivs i -4.5.11.

Funktionsobjekt lagras på enhetsfunktionen: (3.1).

3.1.5 Variabler

Variabler kan definieras och ändras direkt i PowerShell-språket.

Providervariabeln är ett platt namnområde som endast innehåller objekt som representerar variablerna. Variablerna har inga underordnade objekt.

Följande cmdlets hanterar också variabler:

New-Variable: Skapar en variabel
Ange variabel: Skapar eller ändrar egenskaperna för en eller flera variabler
Get-Variable: Hämtar information om en eller flera variabler
Clear-Variable: Tar bort värdet för en eller flera variabler
Remove-Variable: Tar bort en eller flera variabler

Eftersom en variabel är ett objekt (3.3) kan den ändras av de flesta objektrelaterade cmdlets.

Typen av ett objekt som representerar en variabel beskrivs i -4.5.3.

Variabelobjekt lagras på enheten Variabel: (3.1).

3.2 Arbetsplatser

Den aktuella arbetsplatsen är standardplatsen som kommandon pekar på. Det här är den plats som används om en explicit sökväg (3.4) inte anges när ett kommando anropas. Den här platsen innehåller den aktuella enheten.

En PowerShell-värd kan ha flera enheter, vilket innebär att varje enhet har sin egen aktuella plats.

När ett enhetsnamn anges utan en katalog är den aktuella platsen för den enheten underförstådd.

Den aktuella arbetsplatsen kan sparas i en stack och sedan ställas in på en ny plats. Senare kan den sparade platsen återställas från den stacken och göra den aktuella arbetsplatsen. Det finns två typer av platsstackar: standardarbetsplatsstacken och noll eller flera användardefinierade namngivna arbetsplatsstackar. När en session börjar är standardarbetsplatsstacken också den aktuella arbetsplatsstacken. Alla namngivna arbetsplatsstackar kan dock göras till den aktuella arbetsplatsstacken.

Följande cmdlets hanterar platser:

Ange plats: Upprättar den aktuella arbetsplatsen
Get-Location: Anger den aktuella arbetsplatsen för de angivna diskarna eller arbetsplatserna för de angivna stackarna
Push-plats: Sparar den aktuella arbetsplatsen överst i en angiven platsstack
Popup-plats: Återställer den aktuella arbetsplatsen överst i en angiven platsstack

De objekttyper som representerar en arbetsplats och en stack med arbetsplatser beskrivs i -4.5.5.

3.3 Objekt

Ett objekt är ett alias (â 3.1.1), en variabel (3.1.5), en funktion (3.1.4), en miljövariabel (3.1.2) eller en fil eller katalog i ett filsystem (3.1.3).

Följande cmdlets hanterar objekt:

Nytt objekt: Skapar ett nytt objekt
Ange objekt: Ändrar värdet för ett eller flera objekt
Get-Item: Hämtar objekten på den angivna platsen
Get-ChildItem: Hämtar objekten och underordnade objekt på den angivna platsen
Kopiera objekt: Kopierar ett eller flera objekt från en plats till en annan
Flytta objekt: Flyttar ett eller flera objekt från en plats till en annan
Rename-Item: Byter namn på ett objekt
Invoke-Item: Utför standardåtgärden på ett eller flera objekt
Rensa objekt: Tar bort innehållet i ett eller flera objekt, men tar inte bort objekten (se
Remove-Item: Tar bort de angivna objekten

Följande cmdlets hanterar innehållet i objekt:

Get-Content: Hämtar innehållet i objektet
Lägg till innehåll: Lägger till innehåll i de angivna objekten
Ange innehåll: Skriver eller ersätter innehållet i ett objekt
Rensa innehåll: Tar bort innehållet i ett objekt

Typen av ett objekt som representerar en katalog beskrivs i -4.5.17. Typen av ett objekt som representerar en fil beskrivs i -4.5.18.

3.4 Sökvägsnamn

Alla objekt i ett datalager som är tillgängliga via en PowerShell-provider kan identifieras unikt med deras sökvägsnamn. Ett sökvägsnamn är en kombination av objektnamnet, containern och undercontainrarna där objektet finns samt Den PowerShell-enhet som containrarna används till.

Sökvägsnamn är indelade i en av två typer: fullständigt kvalificerade och relativa. Ett fullständigt kvalificerat sökvägsnamn består av alla element som utgör en sökväg. Följande syntax visar elementen i ett fullständigt sökvägsnamn:

Tips

Notationen ~opt~ i syntaxdefinitionerna anger att den lexikala entiteten är valfri i syntaxen.

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

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

module-name refererar till den överordnade modulen.

providern refererar till Den PowerShell-provider som datalagret nås via.

- enheten refererar till Den PowerShell-enhet som stöds av en viss PowerShell-provider.

En container kan innehålla andra containrar, som kan innehålla andra containrar och så vidare, med den slutliga containern som innehåller ett objekt. Containrar måste anges i den hierarkiska ordning som de finns i datalagret.

Här är ett exempel på ett sökvägsnamn:

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

Om det sista elementet i en sökväg innehåller andra element är det ett containerelement. Annars är det ett lövelement.

I vissa fall behövs inte ett fullständigt sökvägsnamn. ett relativt sökvägsnamn räcker. Ett relativt sökvägsnamn baseras på den aktuella arbetsplatsen. Med PowerShell kan ett objekt identifieras baserat på dess plats i förhållande till den aktuella arbetsplatsen. Ett relativt sökvägsnamn omfattar användning av vissa specialtecken. I följande tabell beskrivs vart och ett av dessa tecken och innehåller exempel på relativa sökvägsnamn och fullständigt kvalificerade sökvägsnamn. Exemplen i tabellen baseras på den aktuella arbetskatalogen som anges till C:\Windows:

Symbol	Beskrivning	Relativ sökväg	Fullständigt kvalificerad sökväg
`.`	Aktuell arbetsplats	`.\System`	`C:\Windows\System`
`..`	Överordnad till den aktuella arbetsplatsen	`..\Program Files`	`C:\Program Files`
`\`	Enhetsrot för den aktuella arbetsplatsen	`\Program Files`	`C:\Program Files`
inget	Inga specialtecken	`System`	`C:\Windows\System`

Om du vill använda ett sökvägsnamn i ett kommando anger du det namnet som ett fullständigt kvalificerat eller relativt sökvägsnamn.

Följande cmdlets hanterar sökvägar:

Konvertera sökväg: Konverterar en sökväg från en PowerShell-sökväg till en PowerShell-providersökväg
Join-Path: Kombinerar en sökväg och en underordnad sökväg till en enda sökväg
Resolve-Path: Matchar jokertecken i en sökväg
Split-Path: Returnerar den angivna delen av en sökväg
Test-Path: Avgör om elementen i en sökväg finns eller om en sökväg är väl utformad

Vissa cmdlets (till exempel Add-Content och använda Copy-Item filfilter. Ett filfilter är en mekanism för att ange kriterier för att välja från en uppsättning sökvägar.

Objekttypen som representerar en matchad sökväg beskrivs i -4.5.5. Sökvägar ändras ofta som strängar.

3.5 Omfattningar

3.5.1 Introduktion

Ett namn kan ange en variabel, en funktion, ett alias, en miljövariabel eller en enhet. Samma namn kan ange olika objekt på olika platser i ett skript. För varje enskilt objekt som ett namn anger är namnet bara synligt inom den region i skripttexten som kallas dess omfång. Olika objekt som betecknas med samma namn har antingen olika omfång eller finns i olika namnområden.

Omfång kan kapslas, vilket innebär att ett yttre omfång kallas för ett överordnat omfång , och alla kapslade omfång är underordnade omfång för det överordnade omfånget. Omfånget för ett namn är det omfång där det definieras och alla underordnade omfång, såvida det inte görs privat. Inom ett underordnat omfång döljer ett namn som definierats där alla objekt som definierats med samma namn i överordnade omfång.

Såvida inte punktkälls notation (·3.5.5) används skapar vart och ett av följande ett nytt omfång:

En skriptfil
Ett skriptblock
En funktion eller ett filter

Se följande exempel:

# 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

Omfånget för variablerna som skapas $y i skriptet är skriptets brödtext, inklusive den funktion som definierats $x i skriptet. Funktionen Get-Power definierar två parametrar med samma namn. Eftersom varje funktion har ett eget omfång skiljer sig dessa variabler från de som definierats i det överordnade omfånget och de döljer dem från det överordnade omfånget. Funktionsomfånget är kapslat i skriptomfånget.

Observera att funktionen anropar sig själv rekursivt. Varje gång den gör det skapas ytterligare ett kapslat omfång, var och en med sina egna variabler $x och $y.

Här är ett mer komplext exempel som även visar kapslade omfång och återanvändning av namn:

# 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 Namn och siffror för omfång

PowerShell stöder följande omfång:

Global: Det här är det översta omfånget på nivån. Alla automatiska variabler och inställningsvariabler definieras i det här omfånget. Det globala omfånget är det överordnade omfånget för alla andra omfång och alla andra omfång är underordnade omfång för det globala omfånget.
Lokalt: Det här är det aktuella omfånget vid alla körningspunkt inom ett skript, skriptblock eller en funktion. Alla omfång kan vara det lokala omfånget.
Skript: Det här omfånget finns för varje skriptfil som körs. Skriptomfånget är det överordnade omfånget för alla omfång som skapats inifrån det. Ett skriptblock har inte sitt eget skriptomfång. I stället är dess skriptomfång det för den närmaste överordnade skriptfilen. Även om det inte finns något sådant som modulomfång ger skriptomfånget motsvarande .

Namn kan deklareras som privata, vilket innebär att de inte visas utanför det överordnade omfånget, inte ens för underordnade omfång. Begreppet privat är inte ett separat omfång. Det är ett alias för lokalt omfång med tillägget att dölja namnet om det används som en skrivbar plats.

Omfång kan refereras till av ett tal, som beskriver den relativa positionen för ett omfång till ett annat. Omfång 0 anger det lokala omfånget, omfång 1 anger ett 1-generations överlagringsomfång, omfång 2 anger ett 2-generations överordnade omfång och så vidare. (Omfångsnummer används av cmdlets som manipulerar variabler.)

3.5.3 Omfång för variabelnamn

Som du ser i följande produktion kan ett variabelnamn anges med vilket som helst av sex olika omfång:

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

Omfånget är valfritt. I följande tabell visas innebörden av var och en i alla möjliga kontexter. Den visar även omfånget när inget omfång har angetts uttryckligen:

Omfångsmodifierare	I en skriptfil	Inom ett skriptblock	Inom en funktion
Globala	Globalt omfång	Globalt omfång	Globalt omfång
skript	Omfånget för den närmaste överordnade skriptfilen eller Global om det inte finns någon skriptfil för närmaste överordnade	Omfånget för den närmaste överordnade skriptfilen eller Global om det inte finns någon skriptfil för närmaste överordnade	Omfånget för den närmaste överordnade skriptfilen eller Global om det inte finns någon skriptfil för närmaste överordnade
Privat	Globalt/skript/lokalt omfång	Lokalt omfång	Lokalt omfång
lokalt	Globalt/skript/lokalt omfång	Lokalt omfång	Lokalt omfång
använda	Implementering definierad	Implementering definierad	Implementering definierad
arbetsflöde	Implementering definierad	Implementering definierad	Implementering definierad
inget	Globalt/skript/lokalt omfång	Lokalt omfång	Lokalt omfång

Information om variabelomfång kan också anges när du använder familjen med cmdlets som anges i (âl 3.1.5). Mer information finns i parametern Scope, parametrarna Option Private och Option AllScope .

Omfånget using används för att komma åt variabler som definierats i ett annat omfång när skript körs via cmdlets Start-Jobsom , Invoke-Commandeller i en inlinescript-instruktion. Ett exempel:

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

Arbetsflödet för omfång används med en parallell -instruktion eller sekvens-instruktion för att få åtkomst till en variabel som definierats i arbetsflödet.

3.5.4 Funktionsnamnsomfång

Ett funktionsnamn kan också ha ett av de fyra olika omfången, och synligheten för namnet är densamma som för variabler (3.5.3).

3.5.5 Punktkälls notation

När en skriptfil, ett skriptblock eller en funktion körs inifrån en annan skriptfil, skriptblock eller funktion, skapar den körda skriptfilen ett nytt kapslat omfång. Exempel:

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

Men när punktkälls notation används skapas inget nytt omfång innan kommandot körs, så tillägg/ändringar som den skulle ha gjort i sitt eget lokala omfång görs i det aktuella omfånget i stället. Exempel:

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

3.5.6 Moduler

Precis som en skriptfil på den översta nivån finns i roten på ett hierarkiskt kapslat omfångsträd, så är också varje modul (3.14). Som standard är dock endast de namn som exporteras av en modul tillgängliga efter namn inifrån importkontexten. Den globala parametern för cmdleten Import-Module gör att exporterade namn får bättre synlighet.

3.6 Skrivskyddade och konstanta egenskaper

Variabler och alias beskrivs av objekt som innehåller ett antal egenskaper. Dessa egenskaper anges och ändras av två familjer av cmdlet:ar (âl 3.1.5, 3.1.1). En sådan egenskap är Alternativ, som kan anges till ReadOnly eller Constant (med parametern Alternativ). En variabel eller ett alias med namnet ReadOnly kan tas bort och dess egenskaper kan ändras förutsatt att force-parametern har angetts. En variabel eller ett alias som har markerats med Konstant kan dock inte tas bort och dess egenskaper kan inte ändras.

3.7 Metodöverlagringar och anropsupplösning

3.7.1 Introduktion

Enligt vad som anges i -1 kallas en extern procedur som görs tillgänglig av körningsmiljön (och skrivs på något annat språk än PowerShell) som en metod.

Namnet på en metod tillsammans med antalet och typerna av dess parametrar kallas gemensamt för den metodens signatur. (Observera att signaturen inte innehåller metodens returtyp.) Körningsmiljön kan tillåta att en typ har flera metoder med samma namn förutsatt att var och en har en egen signatur. När flera versioner av en viss metod definieras, sägs den metoden vara överbelastad. Till exempel innehåller typen Math (·4.3.8) Absen uppsättning metoder som kallas , som beräknar det absoluta värdet för ett angivet tal, där det angivna talet kan ha en av ett antal typer. Metoderna i den uppsättningen har följande signaturer:

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

I det här fallet har alla metoder samma antal argument. deras signaturer skiljer sig åt endast efter argumenttyp.

Ett annat exempel är typen Matris (4.3.2), som innehåller en uppsättning metoder som kallas Kopiera som kopierar ett antal element från en matris till en annan, med början i början av varje matris (som standard) eller vid något anvisat element. Metoderna i den uppsättningen har följande signaturer:

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

I det här fallet skiljer sig signaturerna åt efter argumenttyp och i vissa fall även efter argumentnummer.

I de flesta anrop till överlagrade metoder matchar antalet och typen av argument exakt en av överlagringarna, och den metod som valts är uppenbar. Men om så inte är fallet måste det finnas ett sätt att lösa vilken överlagrad version som ska anropas, om en sådan finns. Exempel:

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

Andra exempel är typsträngen (dvs. System.String), som har flera överlagrade metoder.

Även om PowerShell har regler för att matcha metod-anrop som inte matchar en överlagrad signatur exakt, är inte PowerShell själv ett sätt att definiera överlagrade metoder.

Anteckning

Redigerarens kommentar: PowerShell 5.0 har lagt till möjligheten att definiera skriptbaserade klasser. Dessa klasser kan innehålla överlagrade metoder.

3.7.2 Metodöverlagringsupplösning

Med ett metodanrop (·7.1.3) som har en lista över argumentuttryck och en uppsättning kandidatmetoder (d.v.s. de metoder som kan anropas) kallas mekanismen för att välja den bästa metoden för överlagringsupplösning .

Med tanke på uppsättningen tillämpliga kandidatmetoder (–3.7.3) väljs den bästa metoden i den uppsättningen. Om uppsättningen bara innehåller en metod är den metoden den bästa metoden. Annars är den bästa metoden den metod som är bättre än alla andra metoder med avseende på den angivna argumentlistan med hjälp av reglerna som visas i 3.7.4. Om det inte finns exakt en metod som är bättre än alla andra metoder är metodanropet tvetydigt och ett fel rapporteras.

Den bästa metoden måste vara tillgänglig i den kontext där den anropas. Ett PowerShell-skript kan till exempel inte anropa en metod som är privat eller skyddad.

Den bästa metoden för ett anrop till en statisk metod måste vara en statisk metod, och den bästa metoden för ett anrop till en instansmetod måste vara en instansmetod.

3.7.3 Tillämplig metod

En metod sägs vara tillämplig med avseende på en argumentlista A när något av följande stämmer:

Antalet argument i A är identiskt med antalet parametrar som metoden accepterar.
Metoden har M obligatoriska parametrar och N valfria parametrar, och antalet argument i A är större än eller lika med M, men mindre än N.
Metoden accepterar ett variabelt antal argument och antalet argument i A är större än antalet parametrar som metoden accepterar.

Förutom att ha ett lämpligt antal argument måste varje argument i A matcha argumentets parameter-passing-läge, och argumenttypen måste matcha parametertypen, eller så måste det finnas en konvertering från argumenttypen till parametertypen.

Om argumenttypen är ref (–4.3.6) måste motsvarande parameter också vara referens, och argumenttypen i konverteringssyfte är typen av egenskapsvärdet från referensargumentet.

Om argumenttypen är refkan motsvarande parameter vara i stället out för ref.

Om metoden accepterar ett variabelt antal argument kan metoden vara tillämplig i normalt format eller expanderat format. Om antalet argument i A är identiskt med antalet parametrar som metoden accepterar och den sista parametern är en matris, beror formuläret på rangordningen för en av två möjliga konverteringar:

Rangordningen för konverteringen från typen av det sista argumentet i A till matristypen för den sista parametern.
Rangordningen för konverteringen från typen av det sista argumentet i A till elementtypen för matristypen för den sista parametern.

Om den första konverteringen (till matristypen) är bättre än den andra konverteringen (till elementtypen för matrisen) gäller metoden i normal form, annars kan den användas i expanderad form.

Om det finns fler argument än parametrar kan metoden endast användas i expanderat format. För att den sista parametern ska kunna användas i expanderat format måste den ha matristyp. Metoden ersätts med en motsvarande metod som har den sista parametern ersatt med tillräckliga parametrar för att ta hänsyn till varje omatchat argument i A. Varje ytterligare parametertyp är elementtypen för matristypen för den sista parametern i den ursprungliga metoden. Reglerna ovan för en tillämplig metod tillämpas på den nya metoden och argumentlistan A.

3.7.4 Bättre metod

Givet en argumentlista A med en uppsättning argumentuttryck { E~1~, E~2~, ..., E~N~ } M~P~ M~Q~ och två programmetoder och med parametertyper { Q~1~, Q~2~, ..., Q~N~ }``{ P~1~, P~2~, ..., P~N~ } och definieras M~P~ M~P~ M~Q~ M~Q~det som en bättre metod än om den kumulativa rangordningen av konverteringar för är bättre än för .

Den kumulativa rangordningen för konverteringar beräknas på följande sätt. Varje konvertering är värd ett annat värde beroende på antalet parametrar, E~1~ där konverteringen är värd N, E~2~ värd N-1, ned till E~N~ värd 1. Om konverteringen från E~X~ till P~X~ är bättre E~X~ än från till Q~X~ackumuleras M~P~ N-X+1. M~Q~ Annars ackumuleras N-X+1. Om M~P~ och M~Q~ har samma värde används följande regler för oavgjord brytning som tillämpas i ordning:

Den kumulativa rangordningen av konverteringar mellan parametertyper (ignorera argumenttyper) beräknas på ett sätt som liknar den tidigare rangordningen, P~1~ så jämförs mot , Q~2~``P~2~ mot , ... och P~N~ mot Q~N~.Q~1~ Jämförelsen hoppas över om argumentet var $null, eller om parametertyperna inte är numeriska typer. Jämförelsen hoppas också över om argumentkonverteringen E~X~ förlorar information P~X~ när den konverteras till men inte förlorar information när den konverteras till Q~X~, eller tvärtom. Om parameterkonverteringstyperna P~X~ Q~X~ P~X~``Q~X~ M~P~ jämförs så ackumuleras N-X+1 M~Q~ om konverteringen från till är bättre än från till . Annars ackumuleras N-X+1. Den här regeln för att koppla samman data är avsedd att föredra den mest specifika metoden (dvs . metoden med parametrar som har de minsta datatyperna) om ingen information går förlorad i konverteringar, eller att föredra den mest allmänna metoden (dvs . metoden med parametrarna med de största datatyperna) om konverteringar leder till förlust av information.
Om båda metoderna använder sin expanderade form är metoden med fler parametrar den bättre metoden.
Om en metod använder det expanderade formuläret och den andra använder normal form är metoden med normal form den bättre metoden.

3.7.5 Bättre konvertering

Texten nedan markerad så här är specifik för Windows PowerShell.

Konverteringarna rangordnas på följande sätt, från lägsta till högsta:

T~1~[] till T~2~[] där det inte finns någon tilldelningsbar T~1~ konvertering T~2~ mellan och
T till sträng där T är någon typ
T~1~ till T~2~ var T~1~ eller T~2~ definiera en anpassad konvertering på ett implementeringsdefinierat sätt
T~1~ till T~2~ där T~1~ implementerar IConvertible
T~1~ till T~2~ var T~1~ eller T~2~ implementerar metoden T~2~ op_Implicit(T1)
T~1~ till T~2~ var T~1~ eller T~2~ implementerar metoden T~2~ op_Explicit(T1)
T~1~ till T~2~ där T~2~ implementerar en konstruktor som tar ett enda argument av typen T~1~
Någon av följande konverteringar:
- sträng dit T implementerar T en statisk metod eller T Parse(string)``T Parse(string, IFormatProvider)
- T~1~ till T~2~ där T~2~ är en uppräkning och T~1~ antingen är en sträng eller en samling objekt som kan konverteras till sträng
T till PSObject där är T vilken typ som helst
Någon av följande konverteringar: Language
- T till bool där T är valfri numerisk typ
- sträng till T där T är regex, wmisearcher, wmi, wmiclass, adsi, adsisearcher, eller type
- T Att bool
- T~1~ till Nullable[T~2~] där en konvertering från T~1~ till T~2~ finns
- T att annullera
- T~1~[] till T~2~[] den plats där en tilldelningsbar konvertering T~1~ mellan och T~2~ finns
- T~1~ till T~2~[] där T~1~ är en samling
- IDictionary Att Hashtable
- T Att ref
- T Att xml
- scriptblock Att delegate
- T~1~ till T~2~ där T~1~ är en heltalstyp och T~2~ är en uppräkning
$null till T där T är valfri värdetyp
$null till T där T finns valfri referenstyp
Någon av följande konverteringar:
- byte till T där T är SByte
- UInt16 till T där T är SByte, byteeller Int16
- Int16 till T där T är SByte eller byte
- UInt32 till T där T är SByte, byte, Int16, UInt16eller int
- int till T där T är SByte, byte, Int16eller UInt16
- UInt64 till T där T är SByte, byte, Int16, UInt16, int, UInt32, eller long
- long till T där T är SByte, byte, Int16, UInt16, inteller UInt32
- float till T där T är valfri heltalstyp eller decimal
- double till T där T är valfri heltalstyp eller decimal
- decimal till T där T är valfri heltalstyp
Någon av följande konverteringar:
- SByte till T där T är byte, uint6, UInt32eller UInt64
- Int16 till T där T är UInt16, UInt32eller UInt64
- int till T där T är UInt32 eller UInt64
- long Att UInt64
- decimal till T där T är float eller double
Någon av följande konverteringar:
- T till string där T är valfri numerisk typ
- T till char där T är valfri numerisk typ
- string till T där T är valfri numerisk typ
Någon av följande konverteringar, dessa konverteringar betraktas som en tilldelningsbar konvertering:
- byte till T där T är Int16, UInt16, int, UInt32, long, UInt64, single, , double, eller decimal
- SByte till T där T är Int16, UInt16, int, UInt32, long, UInt64, single, , double, eller decimal
- UInt16 till T där T är int, UInt32, long, eller UInt64, single, doubleeller decimal
- Int16 till T där T är int, UInt32, long, eller UInt64, single, doubleeller decimal
- UInt32 till T där T är long, eller UInt64, single, doubleeller decimal
- int till T där T är long, UInt64, single, doubleeller decimal
- single Att double
T~1~ till T~2~ där T~2~ är en basklass eller ett gränssnitt för T~1~. Den här konverteringen anses vara en tilldelningsbar konvertering.
string Att char[]
T till T – den här konverteringen anses vara en tilldelningsbar konvertering.

För varje T~1~ T~2~[] T~1~ konvertering av formuläret till där inte är en matris och ingen annan konvertering gäller, T~2~``T~1~ om det finns en konvertering från till , är konverteringens T~1~ T~2~rangordning sämre än konverteringen från till , T~1~ men bättre än någon konvertering rangordnad mindre än konverteringen från tillT~2~

3.8 Namnuppslag

Det är möjligt att kommandon av olika typer har samma namn. Den ordning i vilken namnuppslag utförs i ett sådant fall är alias, funktion, cmdlet och externt kommando.

3.9 Typnamnsuppslag

–7.1.10 innehåller instruktionen "A type-literal is represented in an implementation by some unspecified underlying type. Därför är ett typnamn en synonym för dess underliggande typ." Exempel på typer är int, double, long[]och Hashtable.

Typnamn matchas på följande sätt: Jämför ett visst typnamn med listan över inbyggda typacceleratorer, till exempel int, long, double. Om en matchning hittas är det typen . Annars förutsätter du att typnamnet är fullständigt kvalificerat och ser om en sådan typ finns i värdsystemet. Om en matchning hittas är det typen . Annars lägger du till namnområdesprefixet System.. Om en matchning hittas är det typen . Annars är typnamnet fel. Den här algoritmen används för varje typargument för generiska typer. Det finns dock inget behov av att ange ariteten (antalet argument eller operander som tas av en funktion eller operator).

3.10 Automatisk minneshantering

Olika operatorer och cmdlets resulterar i allokering av minne för referensobjekt, till exempel strängar och matriser. Allokering och frigöring av det här minnet hanteras av PowerShell-körningssystemet. Det innebär att PowerShell tillhandahåller automatisk skräpinsamling.

3.11 Körningsordning

En sidoeffekt är en ändring i tillståndet för ett kommandos körningsmiljö. En ändring av värdet för en variabel (via tilldelningsoperatorer eller operatorerna för för- och eftersteg och ökning) är en bieffekt, liksom en ändring av innehållet i en fil.

Om inget annat anges körs -instruktioner i lexikal ordning.

Förutom vad som anges för vissa operatorer är utvärderingsordningen för termer i ett uttryck och i vilken ordning sidoeffekter sker ospecificerade.

Ett uttryck som anropar ett kommando omfattar uttrycket som anger kommandot och noll eller flera uttryck som anger de argument vars värden ska skickas till kommandot. Den ordning i vilken uttrycken utvärderas i förhållande till varandra är ospecificerad.

3.12 Felhantering

När ett kommando misslyckas anses detta vara ett fel och information om det felet registreras i en felpost vars typ är ospecificerad (4.5.15); Den här typen stöder dock uppskrivning.

Ett fel hamnar i en av två kategorier. Antingen avslutas åtgärden (ett avslutande fel) eller inte (ett icke-avslutande fel). Med ett avslutande fel registreras felet och åtgärden stoppas. Med ett icke-avslutande fel registreras felet och åtgärden fortsätter.

Icke-avslutande fel skrivs till felströmmen. Även om informationen kan omdirigeras till en fil konverteras felobjekten först till strängar och viktig information i dessa objekt skulle inte fångas in, vilket gör diagnostiseringen svår om inte omöjlig. I stället kan feltexten omdirigeras (7.12) och felobjektet sparas i en variabel, som i $Error1 = command 2>&1.

Den automatiska variabeln $Error innehåller en samling felposter som representerar de senaste felen och det senaste felet finns i $Error[0]. Den här samlingen finns i en buffert så att gamla poster tas bort när nya läggs till. Den automatiska variabeln $MaximumErrorCount styr antalet poster som kan lagras.

$Error innehåller alla fel från alla kommandon tillsammans i en samling. Om du vill samla in felen från ett visst kommando använder du den gemensamma parametern ErrorVariable, som gör att en användardefinierad variabel kan anges för att innehålla samlingen.

3.13 Pipelines

En pipeline är en serie med ett eller flera kommandon som var och en avgränsas med pipe-operatorn | (U+007C). Varje kommando tar emot indata från föregångaren och skriver utdata till sin efterföljare. Om inte utdata i slutet av pipelinen tas bort eller omdirigeras till en fil, skickas de till värdmiljön, som kan välja att skriva den till standardutdata. Kommandon i en pipeline kan också ta emot indata från argument. Tänk dig Get-ChildItemtill exempel följande användning av kommandona , Sort-Objectoch Process-File, som skapar en lista med filnamn i en viss filsystemkatalog, sorterar en uppsättning textposter och utför viss bearbetning på en textpost:

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

I det första fallet skapar Get-ChildItem en samling namn på filerna i den aktuella/standardkatalogen. Samlingen skickas till värdmiljön, som som standard skriver varje elements värde till standardutdata.

I det andra fallet skapar Get-ChildItem en samling namn på filerna i den angivna katalogen med hjälp av argumentet e:*.txt. Samlingen skrivs till Sort-Objectkommandot , som som standard sorterar dem i stigande ordning, känsliga för case (enligt argumentet CaseSensitive ). Den resulterande samlingen skrivs sedan till kommandot Process-File, som utför viss (okänd) bearbetning. Utdata från kommandot omdirigeras sedan till filen results.txt.

Om ett kommando skriver ett enda objekt tar dess efterföljare emot objektet och avslutas sedan efter att ha skrivit sina egna objekt till sin efterföljare. Men om ett kommando skriver flera objekt levereras de ett i taget till det efterföljande kommandot, som körs en gång per objekt. Det här beteendet kallas för strömning. Vid strömbearbetning skrivs objekt längs pipelinen så fort de blir tillgängliga, inte när hela samlingen har producerats.

När en samling bearbetas kan ett kommando skrivas så att det kan göra särskild bearbetning före det första elementet och efter det sista elementet.

3.14 Moduler

En modul är en fristående återanvändbar enhet som gör att PowerShell-kod kan partitioneras, organiseras och abstraheras. En modul kan innehålla kommandon (till exempel cmdlets och funktioner) och objekt (till exempel variabler och alias) som kan användas som en enda enhet.

När en modul har skapats måste den importeras till en session innan kommandona och objekten i den kan användas. När de har importerats beter sig kommandon och objekt som om de hade definierats lokalt. En modul importeras explicit med Import-Module kommandot . En modul kan också importeras automatiskt enligt en implementering som definierats.

Typen av ett objekt som representerar en modul beskrivs i -4.5.12.

Modulerna beskrivs i detalj i -11.

3.15 Uttryck med jokertecken

Ett uttryck med jokertecken kan innehålla noll eller flera av följande element:

Element	Beskrivning
Andra tecken än *, ?, eller [	Matchar det tecknet
*	Matchar noll eller flera tecken. Om du vill matcha ett -tecken använder du [].
?	Matchar ett tecken. För att matcha en ? tecken, använd [?].
[ange]	Matchar ett tecken från uppsättningen, som inte får vara tomt. Om uppsättningen börjar med ], betraktas den högra hakparentesen som en del av uppsättningen och nästa högra hakparentes avslutar uppsättningen. Annars avslutar den första högra hakparentesen uppsättningen. Om uppsättningen börjar eller slutar med -, betraktas bindestreck minus som en del av uppsättningen. Annars indikerar det ett intervall med på varandra följande Unicode-kodpunkter där tecknen på endera sidan av bindestreck minus är avgränsare för inkluderande intervall. Till exempel anger A-Z de 26 versala engelska bokstäverna och 0–9 anger de 10 decimalsiffrorna.

Anteckning

Mer information finns i The Open Group Base Specifications: Pattern Matching", IEEE Std 1003.1, 2004 Edition.. I PowerShell är escape-tecknet dock bakåtklick, inte omsnedstreck.

3.16 Reguljära uttryck

Ett reguljärt uttryck kan innehålla noll eller flera av följande element:

Element	Beskrivning
Andra tecken än ., [, ^, *, $, eller \	Matchar det tecknet
.	Matchar ett tecken. Så här matchar du en . använder du \..
[ange] [^set]	Formuläret [set] matchar ett tecken från uppsättningen. Formuläret [^set] matchar inga tecken från uppsättningen. kan inte vara tom. Om uppsättningen börjar med ] eller ^] betraktas den högra hakparentesen som en del av uppsättningen och nästa högra hakparentes avslutar uppsättningen. Annars avslutar den första högra hakparentesen uppsättningen. Om uppsättningen börjar med - eller ^-, eller slutar med -, betraktas bindestreck minus som en del av uppsättningen. Annars indikerar det ett intervall med på varandra följande Unicode-kodpunkter där tecknen på endera sidan av bindestreck minus är avgränsare för inkluderande intervall. Till exempel anger A-Z de 26 versala engelska bokstäverna och 0–9 anger de 10 decimalsiffrorna.
*	Matchar noll av fler förekomster av föregående element.
+	Matchar en av flera förekomster av föregående element.
?	Matchar noll av en förekomst av föregående element.
^	Matchar i början av strängen. Om du vill matcha ett ^-tecken använder du \^.
$	Matchar i slutet av strängen. Om du vill matcha ett $-tecken använder du $.
\C	Escape-tecken c, så det känns inte igen som ett element för reguljära uttryck.

Anteckning

Mer information finns i Open Group Base Specifications: Regular Expressions, IEEE Std 1003.1, 2004 Edition..

Windows PowerShell: Teckenklasser som är tillgängliga i Microsoft .NET Framework reguljära uttryck stöds enligt följande:

Element	Beskrivning
`\p{name}`	Matchar alla tecken i den namngivna teckenklassen som anges med namn. Namn som stöds är Unicode-grupper och blockintervall som Ll, Nd, Z, IsGreek och IsBoxDrawing.
`\P{name}`	Matchar text som inte ingår i de grupper och blockintervall som anges i namnet.
`\w`	Matchar alla ordtecken. Motsvarar Unicode-teckenkategorierna `[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]`. Om ECMAScript-kompatibelt beteende anges med ALTERNATIVET ECMAScript motsvarar \w `[a-zA-Z_0-9]`.
`\W`	Matchar alla tecken som inte är ord. Motsvarar Unicode-kategorierna `[\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]`.
`\s`	Matchar alla blankstegstecken. Motsvarar kategorierna med Unicode-tecken `[\f\n\r\t\v\x85\p{Z}]`.
`\S`	Matchar alla tecken som inte är blankstegstecken. Motsvarar Unicode-teckenkategorierna `[\^\f\n\r\t\v\x85\p{Z}]`.
`\d`	Matchar valfri decimalsiffra. Motsvarar för `\p{Nd}` Unicode och för `[0-9]` icke-Unicode-beteende.
`\D`	Matchar alla icke-siffriga. Motsvarar för `\P{Nd}` Unicode och för `[\^0-9]` icke-Unicode-beteende.

Kvantifierare som är tillgängliga i Microsoft .NET Framework reguljära uttryck stöds på följande sätt:

Element	Beskrivning
`*`	Anger noll eller flera matchningar. till exempel eller `\w` Motsvarande `(abc).` .`{0,}`
`+`	Matchar upprepade instanser av föregående tecken.
`?`	Anger noll eller ett matchningar. till exempel eller `\w?` `(abc)?`. `{0,1}`Motsvarar .
`{n}`	Anger exakt n matchningar. till exempel `(pizza){2}`.
`{n,}`	Anger minst n matchningar. till exempel `(abc){2,}`.
`{n,m}`	Anger minst n, men högst m, matchningar.

3. Grundläggande begrepp

3.1 Leverantörer och enheter

3.1.1 Alias

3.1.2 Miljövariabler

3.1.3 Filsystem

3.1.4 Funktioner

3.1.5 Variabler

3.2 Arbetsplatser

3.3 Objekt

3.4 Sökvägsnamn

3.5 Omfattningar

3.5.1 Introduktion

3.5.2 Namn och siffror för omfång

3.5.3 Omfång för variabelnamn

3.5.4 Funktionsnamnsomfång

3.5.5 Punktkälls notation

3.5.6 Moduler

3.6 Skrivskyddade och konstanta egenskaper

3.7 Metodöverlagringar och anropsupplösning

3.7.1 Introduktion

3.7.2 Metodöverlagringsupplösning

3.7.3 Tillämplig metod

3.7.4 Bättre metod

3.7.5 Bättre konvertering

3.8 Namnuppslag

3.9 Typnamnsuppslag

3.10 Automatisk minneshantering

3.11 Körningsordning

3.12 Felhantering

3.13 Pipelines

3.14 Moduler

3.15 Uttryck med jokertecken

3.16 Reguljära uttryck

Feedback