3. Grundläggande begrepp

Redaktionell anteckning

Viktig

Windows PowerShell Language Specification 3.0 publicerades i december 2012 och baseras på Windows PowerShell 3.0. Den här specifikationen återspeglar inte det aktuella tillståndet för PowerShell. Det finns ingen plan för att uppdatera den här dokumentationen för att återspegla det aktuella tillståndet. Den här dokumentationen presenteras här för historisk referens.

Specifikationsdokumentet är tillgängligt som ett Microsoft Word-dokument från Microsoft Download Center på: https://www.microsoft.com/download/details.aspx?id=36389 Att Word-dokumentet har konverterats för presentation här på Microsoft Learn. Under konverteringen har vissa redaktionella ändringar gjorts för att anpassa formateringen för Docs-plattformen. Vissa stavfel och mindre fel har korrigerats.

3.1 Leverantörer och lagringsenheter

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 enhet i filsystemet.

Det data som en leverantör exponerar finns på en -enhetoch data nås via en -sökväg precis som med en hårddisk. Inbyggda cmdletar för varje leverantör hanterar data på leverantörens enhet.

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

Leverantör	Drivnamn	Beskrivning	Referens
Alias	Alias:	PowerShell-aliaser	§3.1.1
Miljö	Miljö:	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	Drivnamn	Beskrivning
Intyg	Certifikat:	x509-certifikat för digitala signaturer
Register	HKLM: (HKEY_LOCAL_MACHINE), HKCU: (HKEY_CURRENT_USER)	Windows-register
WSMan	WSMan:	WS-Management konfigurationsinformation

Följande cmdletar hanterar providrar och drivrutiner:

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 för ett objekt som representerar en enhet beskrivs i §4.5.2.

3.1.1 Aliasnamn

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 omväxlande. Ett alias kan omtilldelas. 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.

Provideraliaset är ett platt namnområde som endast innehåller objekt som representerar aliasen. Variablerna har inga barnobjekt.

PowerShell levereras med en uppsättning inbyggda alias.

Följande cmdletar 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 hjälp av New-Aliaskan parametrar till det kommandot inte ingå i det aliaset. Direkttilldelning till en variabel i Alias: namnområdet tillåter dock att parametrar inkluderas.

Note

Det är dock enkelt att skapa en funktion som inte gör något annat än att innehålla kommandots anrop med alla önskade parametrar och tilldela ett alias till den funktionen.

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

Aliasobjekt lagras på enheten Alias: (§3.1).

3.1.2 Miljövariabler

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

Providermiljön är ett platt namnområde som endast innehåller objekt som representerar miljövariablerna. Variablerna har inga barnobjekt.

Namnet på en miljövariabel kan 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 Env: (§3.1).

3.1.3 Filsystem

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

FileSystem-providern ä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 används med sökvägs notation (§3.4).

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

3.1.4 Funktioner

PowerShell-funktionsprovidern tillåter att funktioner (§8.10) och filter (§8.10.1) hämtas, läggs 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 i 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å drivenhet Funktion: (§3.1).

3.1.5 Variabler

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

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

Följande cmdletar hanterar även variabler:

new-variable: Skapar en variabel
Set-Variable: 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 det manipuleras av de flesta Objektrelaterade cmdletar.

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 den standardplats dit kommandon pekar. 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 nuvarande enheten.

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

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

Den aktuella arbetsplatsplatsen kan sparas i en stack och sedan ändras till en ny plats. Senare kan den sparade positionen återställas från den stacken och bli den aktuella arbetspositionen. Det finns två typer av platsstackar: standardarbetsplatsstackenoch noll eller fler 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 cmdletar hanterar platser:

Set-Location: Etablerar den aktuella arbetsplatsen
Get-Location: Avgör den aktuella arbetsplatsen för de angivna enheten eller arbetsplatserna för de angivna staplarna
Push-Location: Sparar den aktuella platsen överst i en angiven platsstack
Pop-Location: Återställer den aktuella arbetskatalogen från toppen av en angiven stack med kataloger

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 cmdletar hanterar objekt:

new-item: Skapar ett nytt objekt
Set-Item: Ändrar värdet för ett eller flera objekt
Get-Item: Hämtar objekten på den angivna platsen
Get-ChildItem: Hämtar objekt och barnobjekt på den angivna platsen
Copy-Item: Kopierar ett eller flera objekt från en plats till en annan
Move-Item: Flyttar ett eller flera objekt från en plats till en annan
Byt namn på objekt: Byter namn på ett objekt
Invoke-Item: Utför standardåtgärden på ett eller flera objekt
Clear-Item: Tar bort innehållet i ett eller flera objekt, men tar inte bort objekten (se
Remove-Item: Tar bort de angivna objekten

Följande cmdletar hanterar innehållet i objekt:

Get-Content: Hämtar innehållet i objektet
: Lägger till innehåll i de angivna objekten
Set-Content: Skriver eller ersätter innehållet i ett objekt
Clear-Content: 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 av deras sökvägsnamn. Ett sökvägsnamn är en kombination av objektnamnet, containern och undercontainrarna som objektet finns i, samt PowerShell-enheten genom vilken containrarna nås.

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 kvalificerat sökvägsnamn:

Tips

Den ~opt~ notationen 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   \

modulnamn refererar till den överordnade modulen.

provider refererar till den PowerShell-leverantör genom vilken datalagret nås.

enhet refererar till den PowerShell-enhet som stöds av en PowerShell-provider.

En container kan innehålla andra containrar, som kan innehålla andra containrar och så vidare, med den sista 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 kvalificerat 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. Följande tabell beskriver 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`
`..`	Förälder till den aktuella arbetsplatsen	`..\Program Files`	`C:\Program Files`
`\`	Enhetsrot för den aktuella arbetsplatsen	`\Program Files`	`C:\Program Files`
ingen	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 cmdletar hanterar sökvägar:

Convert-Path: 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 delväg till en samlad sökväg
Resolve-Path: Löser wildcardtecken i en sökväg
: Visar 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älformulerad

Vissa cmdletar (till exempel Add-Content och Copy-Item) använder 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 hanteras ofta som strängar.

3.5 Omfattning

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 specifikt objekt som ett namn anger visas namnet endast inom den skripttextregion som kallas dess omfång. Olika objekt som anges med samma namn har antingen olika omfång eller finns i olika namnutrymmen.

Omfång kan skapas inom varandra, i sådana fall kallas ett yttre omfång för ett överordnat omfång, och eventuella omfång som skapats inom detta är underordnade omfång till det överordnade. Omfånget för ett namn är räckvidden där det definieras och alla underordnade räckvidder, 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ällnotation (§3.5.5) används, skapar var och en av följande ett nytt omfång:

En skriptfil
Ett skriptblock
En funktion eller ett filter

Tänk på 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 $x och $y som skapas i skriptet är brödtexten i skriptet, inklusive den funktion som definierats i det. Funktion Get-Power definierar två parametrar med samma namn. Eftersom varje funktion har sitt 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 skapar den ännu 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 Områdesnamn och nummer

PowerShell stöder följande omfång:

Global: Det här är den översta 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.
Lokal: Det här är det aktuella omfånget vid vilken som helst körningspunkt i ett skript, skriptblock eller en funktion. Varje omfång kan vara ett lokalt omfång.
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 från det. Ett skriptblock har inte ett eget skriptomfång; istället är dess skriptomfång detsamma som den närmast föregående skriptfilens. Även om det inte finns något modulomfång ger skriptomfånget motsvarande.

Namn kan deklareras som privata, i så fall är de inte synliga utanför deras föräldraomfång, inte ens för barnomfå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 överordnat omfång, omfång 2 anger ett 2-generations överordnat omfång och så vidare. (Omfångsnummer används av cmdletar som manipulerar variabler.)

3.5.3 Variabelnamnsomfång

Som visas i följande kodstycke kan ett variabelnamn anges i någon av sex olika kontexter:

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 också omfånget när inget omfång uttryckligen anges:

Omfångsmodifierare	i en skriptfil	Inom ett skriptblock	i en funktion
Global	Globalt omfång	Globalt omfång	Globalt omfång
Skript	Närmaste överordnade skriptfils omfång eller Global om det inte finns någon närmaste överordnade skriptfil	Närmaste överordnade skriptfils omfång eller Global om det inte finns någon närmaste överordnade skriptfil	Närmaste överordnade skriptfils omfång eller Global om det inte finns någon närmaste överordnade skriptfil
Privat	Globalt/skript/lokalt omfång	Lokalt omfång	Lokalt omfång
Lokal	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
Ingen	Globalt/skript/lokalt omfång	Lokalt omfång	Lokalt omfång

Information om variabelt omfång kan också anges när du använder familjen med cmdletar som anges i (§3.1.5). Mer information finns i parametern Scopeoch parametrarna Option Private och Option AllScope.

Using:-omfångsmodifieraren används för att komma åt variabler som definierats i ett annat omfång när skript körs via cmdletar som Start-Job, Invoke-Commandeller inom en inlinescript-instruktion. Till exempel:

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

Omfångsarbetsflödet används med en parallellsats eller sekvenssats för åtkomst till en variabel som definierats i arbetsflödet.

3.5.4 Funktionsnamnsomfång

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

3.5.5 Punktkälla notation

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

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

Men när dot source-notation används, skapas inget nytt omfång innan kommandot körs, så tillägg/ändringar som skulle ha gjorts i det egna lokala omfånget görs istället i det aktuella omfånget. Till exempel

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

3.5.6 Moduler

Precis som en skriptfil på den översta nivån finns i roten i ett hierarkiskt kapslat omfångsträd, så är även varje modul (§3.14). Men som standard är endast de namn som exporteras av en modul tillgängliga med namn inifrån importkontexten. Parametern Global för cmdleten Import-Module tillåter att exporterade namn får ökad synlighet.

3.6 Skrivskyddade och konstanta egenskaper

Variabler och alias beskrivs av objekt som innehåller ett antal egenskaper. Dessa egenskaper anges och manipuleras av två grupper av cmdlets (§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 med namnet Konstant kan dock inte tas bort och dess egenskaper kan inte heller ändras.

3.7 Metodöverbelastningar och anropsupplösning

3.7.1 Introduktion

Som anges i §1 kallas ett externt förfarande som görs tillgängligt av körningsmiljön (och skrivs på något annat språk än PowerShell) en metod.

Namnet på en metod tillsammans med antalet och typerna av dess parametrar kallas tillsammans 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 annan signatur. När flera versioner av någon metod definieras sägs den metoden vara överbelastad. Typen Math (§4.3.8) innehåller till exempel en uppsättning metoder som kallas Abs, 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 endast efter argumenttyp.

Ett annat exempel omfattar typen Matris (§4.3.2), som innehåller en uppsättning metoder som kallas Kopiera som kopierar ett område med element från en matris till en annan, med början av varje matris (som standard) eller på något angivet 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 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 valda metoden är uppenbar. Men om så inte är fallet måste det finnas ett sätt att lösa vilken överbelastad version som ska anropas, om någon. Till 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 typen sträng (dvs. System.String), som har många överlagrade metoder.

Även om PowerShell har regler för att matcha metodanrop som inte matchar en överbelastad signatur exakt, tillhandahåller PowerShell inte själv ett sätt att definiera överlagrade metoder.

Note

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

3.7.2 Metodöverbelastningslösning

Med ett metodanrop (§7.1.3) med en lista över argumentuttryck och en uppsättning kandidatmetods (dvs. de metoder som kan anropas), kallas mekanismen för att välja den bästa metodenöverbelastningsmatchning.

Med tanke på uppsättningen med tillämpliga kandidatmetoder (§3.7.3) väljs den bästa metoden i uppsättningen. Om uppsättningen endast 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 de regler 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 är sant:

Antalet argument i A är identiskt med antalet parametrar som metoden accepterar.
Metoden har obligatoriska M-parametrar och valfria N-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 för konvertering är typen av egenskapen Value från ref-argumentet.

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

Om metoden accepterar ett variabelt antal argument kan metoden vara tillämplig i antingen normal form eller expanderat formulär. 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.
Konverteringens rangordning 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 matrisens elementtyp) gäller metoden i normal form, annars gäller den i expanderat format.

Om det finns fler argument än parametrar kan metoden endast användas i expanderad form. För att kunna användas i expanderat format måste den sista parametern ha matristyp. Metoden ersätts med en motsvarande metod som har den sista parametern ersatt med tillräckligt med 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. Ovanstående regler för en tillämplig metod tillämpas på den nya metoden och argumentlistan A.

3.7.4 Bättre metod

Med tanke på en argumentlista A med en uppsättning argumentuttryck { E~1~, E~2~, ..., E~N~ } och två anropsmetoder M~P~ och M~Q~ med parametertyperna { P~1~, P~2~, ..., P~N~ } och { Q~1~, Q~2~, ..., Q~N~ }, definieras M~P~ som en bättre metod än M~Q~ om den kumulativa rangordningen för konverteringar för M~P~ är bättre jämfört med den för M~Q~.

Den kumulativa rangordningen av konverteringar beräknas på följande sätt. Varje konvertering är värd ett annat värde beroende på antalet parametrar, med konverteringen av E~1~ 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 än den från E~X~ till Q~X~ackumulerar M~P~ N-X+1. annars ackumulerar M~Q~ N-X+1. Om M~P~ och M~Q~ har samma värde tillämpas följande regler för att avgöra en oavgjord situation i ordning:

Den kumulativa rangordningen av konverteringar mellan parametertyper (ignorerar argumenttyper) beräknas på ett sätt som liknar den tidigare rangordningen, så P~1~ jämförs med Q~1~, P~2~ mot Q~2~, ...och P~N~ mot Q~N~. Jämförelsen utelämnas om argumentet var $null, eller om parametertyperna inte är numeriska typer. Jämförelsen hoppas över om argumentkonverteringen E~X~ förlorar information när den konverteras till P~X~ men inte när den konverteras till Q~X~, eller vice versa. Om parameterkonverteringstyperna jämförs, så om konverteringen från P~X~ till Q~X~ är bättre än den från Q~X~ till P~X~, ackumulerar M~P~ N-X+1; annars ackumulerar M~Q~ N-X+1. Den här kopplingsregeln ä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 vid konverteringar, eller att föredra den mest allmänna metoden (dvs. metoden med parametrarna med de största datatyperna) om konverteringar resulterar i förlust av information.
Om båda metoderna använder sitt utökade formulär är metoden med fler parametrar den bättre metoden.
Om den ena metoden 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 som är markerad så här är specifik för Windows PowerShell.

Konverteringar 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 konvertering mellan T~1~ och T~2~
T omvandlas till sträng där T är vilken typ som helst
T~1~ till T~2~ där 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~ där T~1~ eller T~2~ implementerar metoden T~2~ op_Implicit(T1)
T~1~ till T~2~ där T~1~ eller T~2~ implementerar metoden T~2~ op_Explicit(T1)
T~1~ till T~2~ där T~2~ implementerar en konstruktor med ett enda argument av typen T~1~
Någon av följande konverteringar:
- sträng till T där T implementerar en statisk metod T Parse(string) eller T Parse(string, IFormatProvider)
- T~1~ till T~2~ där T~2~ är ett uppräkningsobjekt och T~1~ är antingen en sträng eller en samling objekt som kan konverteras till en sträng
T till PSObject där T är någon typ
Någon av följande konverteringar: Language
- T till bool där T är någon numerisk typ
- sträng till T där T är regex, wmisearcher, wmi, wmiclass, adsi, adsisearchereller type
- T till bool
- T~1~ till Nullable[T~2~] där en konvertering från T~1~ till T~2~ finns
- T att ogiltigförklara
- T~1~[] till T~2~[] där det finns en tilldelningsbar konvertering mellan T~1~ och T~2~
- T~1~ till T~2~[] där T~1~ är en samling
- IDictionary till Hashtable
- T till ref
- T till xml
- scriptblock till delegate
- T~1~ till T~2~ där T~1~ är en heltalstyp och T~2~ är en uppräkningstyp
$null till T där T är en värdetyp
$null till T där T är en 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, UInt32eller long
- long till T där T är SByte, byte, Int16, UInt16, inteller UInt32
- float till T där T är ett heltal eller decimal
- double till T där T är ett heltal eller decimal
- decimal till T där T är någon 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 till UInt64
- decimal till T där T är float eller double
Någon av följande konverteringar:
- T string där T är en numerisk typ
- T char där T är en numerisk typ
- string T där T är en numerisk typ
Någon av följande konverteringar anses vara en tilldelningsbar konvertering:
- byte till T där T är Int16, UInt16, int, UInt32, long, UInt64, single, doubleeller decimal
- SByte till T där T är Int16, UInt16, int, UInt32, long, UInt64, single, doubleeller decimal
- UInt16 T där T är int, UInt32, longeller UInt64, single, doubleeller decimal
- Int16 T där T är int, UInt32, longeller 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 till 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 till char[]
T till T – Den här konverteringen anses vara en tilldelningsbar konvertering.

För varje konvertering av formatet T~1~ till T~2~[] där T~1~ inte är en matris och ingen annan konvertering gäller, om det finns en konvertering från T~1~ till T~2~, är konverteringens rang sämre än konverteringen från T~1~ till T~2~, men bättre än alla konverteringar som rankas lägre än konverteringen från T~1~ till T~2~.

3.8 Namnsökning

Det är möjligt att ha kommandon av olika slag som alla har samma namn. I vilken ordning namnsökningen utförs i ett sådant fall är alias, funktion, cmdlet och externt kommando.

3.9 Typnamnsökning

§7.1.10 innehåller instruktionen "En typ-literal representeras i en implementation av någon ospecificerad underliggande typ. 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 angivet typnamn med listan över inbyggda typacceleratorer, till exempel int, long, double. Om en matchning hittas är detta typen. Anta annars att typnamnet är fullständigt kvalificerat och se om det finns en sådan typ i värdsystemet. Om en matchning hittas är detta typen. Annars lägger du till namnområdesprefixet System.. Om en matchning hittas är detta typen. Annars är typnamnet felaktigt. 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 cmdletar resulterar i allokering av minne för referenstypobjekt, 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 bieffekt är en ändring i tillståndet för ett kommandos körningsmiljö. En ändring av värdet för en variabel (via tilldelningsoperatorerna eller operatorerna pre- och post-increment och decrement) är en bieffekt, liksom en ändring av innehållet i en fil.

Om inget annat anges utförs uttalanden i lexikal ordning.

Förutom vad som anges för vissa operatorer är ordningen för utvärdering av termer i ett uttryck och ordningen i vilken biverkningar äger rum ospecificerade.

Ett uttryck som anropar ett kommando omfattar uttrycket som anger kommandot och noll eller fler uttryck som anger de argument vars värden ska skickas till kommandot. Den ordning i vilken dessa uttryck 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 felet registreras i en felpost, vars typ är ospecificerad (§4.5.15); Den här typen stöder dock nedsänkt text.

Ett fel ingår i någon av två kategorier. Antingen avslutas åtgärden (ett avslutande fel) eller inte (ett icke-avslutande fel). Vid ett fel som avslutar processen registreras felet och åtgärden stoppas. Med ett icke-avslutande fel registreras felet och operationen fortsätter.

Icke-terminerande fel skrivs till felströmmen. Även om den informationen kan omdirigeras till en fil konverteras felobjekten först till strängar och viktig information i dessa objekt skulle inte fångas, vilket gör diagnos svårt om inte omöjligt. 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 underhålls i en buffert så att gamla poster raderas 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 som blandas ihop 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 lagra samlingen.

3.13 Rörledningar

En pipeline är en serie med ett eller flera kommandon som var och en avgränsas av röroperatorn | (U+007C). Varje kommando tar emot indata från sin föregående och skriver utdata till dess efterföljande. Om inte utdata i slutet av pipelinen ignoreras 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 till exempel följande användning av kommandon Get-ChildItem, 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 katalogen/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 argumentet E:*.txt. Samlingen skrivs till kommandot Sort-Object, som som standard sorterar dem i stigande ordning med skiftlägeskänslighet (på grund av 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 enskilt objekt, tar dess efterträdare emot det och avslutas sedan efter att ha skrivit sitt eget objekt eller sina egna objekt till sin efterträdare. Men om ett kommando skriver flera objekt levereras de en i taget till det efterföljande kommandot, som körs en gång per objekt. Det här beteendet kallas strömmande. Vid dataströmbearbetning skrivs objekt längs pipelinen så snart de blir tillgängliga, inte när hela samlingen har skapats.

När du bearbetar en samling kan ett kommando skrivas så att det kan utfö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 cmdletar 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 fungerar kommandon och objekt som om de hade definierats lokalt. En modul importeras uttryckligen med kommandot Import-Module. En modul kan också importeras automatiskt enligt vad som fastställs på ett implementeringsdefinierat sätt.

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

Moduler diskuteras i detalj i §11.

3.15 Jokerteckenuttryck

Ett jokerteckenuttryck kan innehålla noll eller flera av följande element:

Element	Beskrivning
Andra tecken än *, ?eller [	Matchar den karaktären
*	Matchar noll eller fler tecken. Om du vill matcha ett * tecken använder du [*].
?	Matchar vilket som helst tecken. För att matcha en ? tecken, använd [?].
[ställ in]	Matchar vilket som helst tecken från -uppsättningen, som inte får vara tom. Om mängd börjar med ], anses den högra hakparentesen vara en del av mängd och nästa högra hakparentes avslutar uppsättningen; Annars avslutar den första högra hakparentesen uppsättningen. Om mängd börjar eller slutar med -, anses minustecknet vara en del av mängd. Annars anger det ett intervall med Unicode-kodpunkter i följd där tecknen på vardera sidan av minustecknet är inkluderande intervallavgränsare. A-Z anger till exempel de 26 engelska versaler och 0–9 anger de 10 decimaltalen.

Note

Mer information finns i Open Group Base Specifications: Pattern Matching", IEEE Std 1003.1, 2004 Edition.. Men i PowerShell är escape-tecknet "backtick", inte omvänt snedstreck.

3.16 Reguljära uttryck

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

Element	Beskrivning
Annat tecken än ., [, ^, *, $eller \	Matchar den karaktären
.	Matchar vilket som helst tecken. Så här matchar du en . För tecken, använd \..
[ställ in] [^ställ in]	Formatet [set] matchar valfritt tecken från uppsättningen . Setet [^set] matchar inga tecken från set. ange får inte vara tom. Om mängd set börjar med ] eller ^], anses den högra hakparentesen vara en del av mängd set och nästa högra hakparentes avslutar mängden; annars avslutar den första högra hakparentesen mängden. Om sättet börjar med - eller ^-, eller slutar med -, anses bindestreck-minustecknet vara en del av uppsättning; annars anger det ett intervall med unicode-kodpunkter i följd där tecknen på vardera sidan av bindestreck-minustecknet är avgränsare för inkluderande intervall. A-Z anger till exempel de 26 engelska versaler och 0–9 anger de 10 decimaltalen.
*	Matchar noll eller fler förekomster av det föregående elementet.
+	Matchar en av flera förekomster av föregående element.
?	Matchar noll eller en förekomst av föregående elementet.
^	Matchningar 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	Undflyr tecken c, så det känns inte igen som ett reguljärt uttryckselement.

Note

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

Windows PowerShell: Teckenklasser som är tillgängliga i vanliga uttryck i Microsoft .NET Framework stöds på följande sätt:

Element	Beskrivning
`\p{name}`	Matchar alla tecken i den namngivna teckenklassen som anges av 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 namn.
`\w`	Matchar valfritt ordtecken. Motsvarar unicode-teckenkategorierna `[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]`. Om ECMAScript-kompatibelt beteende anges med ECMAScript-alternativet 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 whitespace-tecken. Motsvarar unicode-teckenkategorierna `[\f\n\r\t\v\x85\p{Z}]`.
`\S`	Matchar alla tecken som inte är blanksteg. Motsvarar unicode-teckenkategorierna `[\^\f\n\r\t\v\x85\p{Z}]`.
`\d`	Matchar en valfri enskild decimalsiffra. Motsvarar `\p{Nd}` för Unicode och `[0-9]` för beteende som inte är Unicode.
`\D`	Matchar alla tecken som inte är siffror. Motsvarar `\P{Nd}` för Unicode och `[\^0-9]` för beteende som inte är Unicode.

Kvantifierare som är tillgängliga i vanliga uttryck i Microsoft .NET Framework stöds enligt följande:

Element	Beskrivning
`*`	Anger noll eller fler matchningar. till exempel `\w` eller `(abc).` motsvarande `{0,}`.
`+`	Identifierar upprepande instanser av föregående teckenföljd.
`?`	Anger noll eller en matchning; till exempel `\w?` eller `(abc)?`. Motsvarar `{0,1}`.
`{n}`	Anger exakt n träffar; till exempel `(pizza){2}`.
`{n,}`	Ange minst n matchningar; till exempel `(abc){2,}`.
`{n,m}`	Anger minst n, men inte mer än m, matcher.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-10

3. Grundläggande begrepp

Redaktionell anteckning

3.1 Leverantörer och lagringsenheter

3.1.1 Aliasnamn

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 Omfattning

3.5.1 Introduktion

3.5.2 Områdesnamn och nummer

3.5.3 Variabelnamnsomfång

3.5.4 Funktionsnamnsomfång

3.5.5 Punktkälla notation

3.5.6 Moduler

3.6 Skrivskyddade och konstanta egenskaper

3.7 Metodöverbelastningar och anropsupplösning

3.7.1 Introduktion

3.7.2 Metodöverbelastningslösning

3.7.3 Tillämplig metod

3.7.4 Bättre metod

3.7.5 Bättre konvertering

3.8 Namnsökning

3.9 Typnamnsökning

3.10 Automatisk minneshantering

3.11 Körningsordning

3.12 Felhantering

3.13 Rörledningar

3.14 Moduler

3.15 Jokerteckenuttryck

3.16 Reguljära uttryck

Feedback

Ytterligare resurser