Funktioner

När du har arbetat med PowerShell under en tid, är det en uppenbar utveckling att skapa återanvändbara verktyg för att undvika att skriva samma kod om och om igen. Du vill ha modulära kodstycken som bara gör ett jobb och gör det bra, det är syftet med funktioner.

Funktioner består av följande delar:

  • Nyckelordet FUNCTION
  • Funktionens namn
  • Funktionen argument (innehåller parametrar)
  • Funktionens kod (kommando-utförande)

Funktion är ett namngivet block av kod som kan refereras till inom PowerShell. Genom att anropa funktionsnamnet exekveras koden som är definierade i funktionen.

PowerShell stödjer två typer av funktioner, standard funktioner och avancerade funktioner:

  • Enkla eller standard funktioner
  • Avancerade funktioner

Standard funktioner

Enkla funktioner som kan konstrueras direkt på PS konsolen:

För att konstruera en funktion som en enkel räknare med namn MinCalc exekvera:
PS C:\>function MinCalc ($tal1, $tal2) { $tal1 + $tal2 }
Observera att parametrar till funktioner separeras med kommatecken.
För att använda funktionen MinCalc anropa namnet och ange argumentet:
PS C:\>MinCalc  5  5
10
För att addera 4 och 6 exekvera:
PS C:\>MinCalc  4  6
10
För att specificera parametrarna i argumentet exekvera:
PS C:\>MinCalc  -tal1  9  -tal2  10
19
För att få fram datum och tiden exekvera:
PS C:\>function Tid {Get-Date}
PS C:\>tid
den 8 januari 2018 13:40:45
Funktioner kan exekveras även om de inte har ett argument.
För att få fram inloggad användare med hjälp av miljövariabeln USERNAME exekvera:
PS C:\>$env:username
chalo
För att få hälsa den inloggade användare exekvera:
PS C:\>function Amigo {”Hej $env:USERNAME” }
PS C:\Amigo
Hej chalo
För att ta fram tillgängliga funktioner i enheten med samma namn exekvera:
PS C:\>gci  function: | ft  -Auto
gci är alias till Get-ChildItem och ft till Format-Table, tabellens kolumner justeras med -AutoSize eller bara -a. Kommandot visar flera funktioner, bland annat C: D: det vill säga att dessa enheter är egentligen funktioner.
För att få fram de första 10 funktioner i enheten function: exekvera:
PS C:\>Get-ChildItem function: | Select -First 10 | Format-Table -Auto
För att få fram de första 10 funktioner i enheten function: exekvera:
PS C:\>Get-Command -CommandType function | Select -First 10 | Format-Table –Auto
För att få fram information om funktionen Amigo kan vi exekvera:
PS C:\>Get-ChildItem function:Amigo | Format-Table -Auto
En funktion accepterar även parameter som anges direkt på prompten. Dessutom kan vi styra argumentet genom att definiera dess parametrar.
PS C:\>function hej ([string]$Namn) { ”Hej $Namn” }
PS C:\>hej ”Chalo Reyes”
Hej Chalo Reyes
Argumentet anges av användaren direkt på prompten. Citationstecken är pga de två strängar: Chalo och Reyes. Genom att deklarera variabeln $Namn till typen System.String omvandlas inmatningen automatiskt till ett strängvärde.
Om vi istället vill definiera ett parameters typ exempelvis till ett numeriskt värde deklarerar vi variabeln till typen System.Int istället.
PS C:\>function hej ([int]$Namn){”Hej $Namn” }
PS C:\>hej ”Jonas Olsson”
Error!
PS C:\>hej 123
Hej 123
När vi försöker använda ett strängvärde som indata returneras ett felmeddelande.
När vi ger ett numeriskt värde som indata accepteras värdet och koden inom klammerparentesen exekveras.

Funktionens argument i exekverings koden

Det går även att ange parametrar inne i en funktions kod (exekverings-kod) genom en ”växlings parameter”, PARAM. Notera att param måste vara första raden i funktionens exekverings-koden. Till funktionsnamnet följer endast kod i klammerparenteser.

För att konstruera en funktion och endast exekverings-koden exekvera:
PS C:\>function Add {param ($x, $y); $Ans = $x + $y; Write-Host ”The answer is $Ans”}
PS C:\> Add 2 2
The answer is 4
Argumentet anges på prompten ( 2 och 2). Semikolon används för att separera kodens avsnitt (liksom rader).
För att definiera datatypen och för att visa namnet i rät ordning exekvera:
PS C:\>function Namn {param ([string]$Namn, [string]$Efternamn);”Förnamn: $Namn”, ”Efternamn: $Efternamn”}
PS C:\>Namn Chalo Reyes
Förnamn: Chalo
Efternamn: Reyes
För att ange endast efternamnet exekvera
PS C:\>namn  -Efternamn Reyes
Förnamn:
Efternamn: Reyes
För att skapa en tvingande parameter kan vi använda param i kombination med throw. När vi använder throw med param genereras ett fel om kraven inte uppfylls. När vi anropar på funktionen utan att ange någon indata returneras ett felmeddelande.
PS C:\>function Namn {param ($Fnamn = $(throw “Skriv in ditt förnamn”),$Enamn = $(throw ”Skriv in ditt efternamn”));”Ditt förnamn är: $Fnamn”,”Ditt Efternamn är: $Enamn”
PS C:\>Namn Chalo Reyes
Ditt förnamn är: Chalo
Ditt efternamn är: Reyes
När vi anropar en funktion med flera parametrar i argument utan att namnge parametrarna tas argumenten i deklarationsordningen.
PS C:\>DittNamn Reyes Chalo
Ditt förnamn är: Reyes
Ditt Efternamn är: Chalo

$args

Ett annat sätt att förse argument till funktioner är via den inbyggda variabeln $args. Variabeln representerar aktuella argument som ges exempelvis direkt på prompten.

För att hämta argument till funktionen direkt från prompten exekvera:
PS C:\>function Hello {”Hello $args. How are you?”}
PS C:\>Hello Chalo
Hello Chalo. How are you?
För att addera två heltal som anges på prompten exekvera:
PS C:\>function Add { $args[0] + $args[1] }
PS C:\> Add 8 8
16
Den inbyggda variabeln $args kan jämföras som en låda där man fyller i många värde exempelvis 1 2 3 4 5.
PS C:\>function echo-args { $args }
PS C:\>echo-args 1 2 3 4 5
1
2
3
4
5
Om vi bara vill returnera första parameter i argumentet kan vi anropa på $args[0] inom funktionen.
PS C:\>function echo-args { $args[0] }
PS C:\>echo-args 1 2 3 4 5
1
Det går även att räkna antalet parametrar i ett argument.
PS C:\>function echo-args { $args.Count }
PS C:\>echo-args 1 2 3 4 5
5

$input

Variabeln $input innehåller en räknare som räknar upp all indata och därefter överför de till funktioner. Denna variabel är case-sensitive och den är tillgänglig endast för funktioner och scriptblock. $input accepterar som argument data från en pipe.

För att addera ett antal heltal exekvera:
PS C:\>function sum {$sum = 0; $input | foreach {$sum += $_};$sum}
PS C:\>1, 2, 3, 4, 5, 6 | sum
21
  • Från prompten skickas ett antal tal (parametrar)
  • Variabeln $sum tilldelas 0
  • Användarens indata lagras i variabeln $input
  • $input pipas (skickas till) foreach
  • Foreach adderar värdena i $input
För att få fram mappen Windows och ingenting annat exekvera:
PS C:\>function FindFolder{$input | Where-Object {$_.Name -eq ”Windows”}}
PS C:\> gci -path c:\ | FindFolder
För att ta emot indata via en pipe och skicka den till skärmen exekvera:
PS C:\>function indata { $input }
PS C:\>1..5 | indata
1
2
3
4
5