Windows PowerShell är en kommandoshell-miljö med stöd för objektorienterade skript som bygger på Microsoft .NET Framework. Kärnan är PowerShell cmdlet, ett lättviktigt kommando som utför en specifik åtgärd och i samband med detta returnerar ett .NET-objekt. Med PowerShell kan du använda cmdlets för att komma åt en mängd olika system och utföra många uppgifter mot dessa system. Det räcker dock inte alltid med enbart cmdlets för att utföra vissa åtgärder. För dessa åtgärder måste du ofta skapa egna objekt baserade på .NET-klasser. En typ av .NET-objekt som du kan skapa är det anpassade objektet. Med ett anpassat objekt kan du definiera vilka typer av data som tilldelas objektet och vilka åtgärder det kan utföra. När du har förstått hur du bygger ett anpassat objekt har du ett kraftfullt verktyg för att bygga skript som kan utöka PowerShells redan betydande räckvidd.
Bemärk att .NET Framework och objektorienterad programmering är komplexa ämnen som ligger långt utanför det här området. För att till fullo uppskatta PowerShells objektorienterade karaktär kan det hjälpa att ha åtminstone en grundläggande förståelse för dessa begrepp. Mer information om .NET Framework finns i MSDN-artikeln ”Overview of the .NET Framework”. En introduktion till objektorienterad programmering finns i MSDN-artikeln ”Object-Oriented Programming (C# and Visual Basic).”
Skapa ett anpassat objekt
För att skapa ett anpassat objekt i PowerShell måste du först använda cmdlet New-Object för att bygga det ursprungliga objektet. Med den här cmdlet kan du skapa .NET- eller COM-objekt från ett sortiment av klasser. Ett anpassat objekt är en speciell typ av .NET-objekt som bygger på antingen Object- eller PSObject .NET-klassen. Det finns ingen skillnad mellan de två när du skapar det ursprungliga objektet. Klassen PSObject är dock i allmänhet att föredra på grund av de problem som kan uppstå när man lägger till egenskaper till ett objekt baserat på klassen Object, så låt oss använda PSObject.
För att skapa ett objekt baserat på klassen PSObject måste du använda cmdlet New-Object med parametern -TypeName och ange klassen PSObject som parameterns värde, så här:
$system = New-Object -TypeName PSObject
När du kör det här kommandot genereras ett PSCustomObject-objekt och det tilldelas variabeln $system. Oftast vill du tilldela objektet till en variabel så att du enkelt kan arbeta med objektets medlemmar. Medlemmarna är de komponenter som utgör ett objekt, t.ex. egenskaper, metoder, aliasegenskaper och medlemsuppsättningar.
När du arbetar med objekt i PowerShell är de två medlemstyper som du sannolikt kommer att använda egenskaper och metoder. En egenskap beskriver en specifik aspekt av objektet. En av medlemmarna i FileInfo .NET-klassen är till exempel egenskapen Length, som anger en filstorlek i byte. Om du skapar ett FileInfo-objekt baserat på den klassen kan du använda egenskapen Length för att få tillgång till storleken på den fil som är associerad med det objektet. En metod utför en åtgärd som är relaterad till objektet. Klassen FileInfo innehåller till exempel också metoden Delete, som du kan använda för att ta bort den fil som representeras av objektet.
Att kunna identifiera ett objekts medlemmar på ett enkelt sätt gör det lättare att arbeta med det objektet. Om du vill få en lista över de medlemmar som ingår i ett objekt kan du använda cmdlet Get-Member. Om du till exempel vill se medlemmarna i det nya objektet som tilldelades variabeln $system kan du överföra variabeln $system till cmdlet Get-Member:
$system | Get-Member
Som framgår av figur 1 är det objekt som du har skapat baserat på klassen System.Management.Automation.PSCustomObject, som endast innehåller ett litet antal medlemmar, som alla är metoder. Men det är därför det kallas ett anpassat objekt – du kan anpassa det genom att lägga till egna medlemmar.
Innan jag visar hur du lägger till medlemmar vill jag bara tillägga att klassen PSCustomObject, liksom många .NET-klasser, också innehåller ett antal dolda medlemmar av olika typer, till exempel memberset och codeproperty. Du kan visa dessa medlemmar genom att inkludera parametern -Force när du anropar cmdlet Get-Member. Även om en diskussion om dolda medlemmar ligger utanför ramen för det här, kan det vara användbart att vid något tillfälle utforska de dolda medlemmar som är tillgängliga för klassen PSCustomObject och andra .NET-klasser för att dra full nytta av dina PowerShell-objekt.
Lägga till egenskaper till ett anpassat objekt
Ett anpassat objekt är bara så användbart som de medlemmar som är associerade med objektet. Du kan lägga till flera olika typer av medlemmar till ett anpassat objekt. I det här exemplet lägger du till medlemmarna NoteProperty och ScriptMethod. En NoteProperty-medlem liknar en vanlig egenskap och en ScriptMethod-medlem liknar en vanlig metod. Du kan inte lägga till en vanlig egenskap eller metod till ett anpassat objekt, vilket är anledningen till att du kommer att använda NoteProperty och ScriptMethod. (Information om vilka medlemmar som stöds i ett anpassat objekt finns i PowerShell TechNet-ämnet ”Add-Member”.)
Vi börjar med att lägga till ett par NoteProperty-medlemmar i objektet $system. För att lägga till medlemmarna kan du använda cmdlet Add-Member för att definiera egenskapens namn och värden. Anta till exempel att du vill lägga till anteckningsegenskaper baserat på data som hämtas via WMI-funktionerna (Windows Management Instrumentation) som är inbyggda i PowerShell. (WMI tillhandahåller en infrastruktur för hantering av data och operationer i Windows operativsystem.) WMI-objektmodellen innehåller många klasser som stöder ett stort antal hanteringsoperationer. Klassen Win32_OperatingSystem ger till exempel tillgång till information som namnet på det operativsystem som är installerat på en dator och det senaste servicepaketet som tillämpats på det operativsystemet.
För att skapa ett WMI-objekt använder du cmdlet Get-WmiObject och anger den önskade klassen. Om du till exempel vill skapa ett Win32_OperatingSystem WMI-objekt och tilldela det till variabeln $os använder du koden:
$os = Get-WmiObject Win32_OperatingSystem
I det här fallet hämtar du systeminformation från den lokala datorn, men det fina med WMI är dess förmåga att även få åtkomst till och hantera fjärrstyrda Windows-datorer.
Du kan sedan använda variabeln $os för att få åtkomst till den information som returneras av det objektet. Genom att tilldela ett objekt till en variabel på det här sättet låses informationen vid den tidpunkten. Om till exempel ett nytt servicepack tillämpas på operativsystemet efter att du har skapat variabeln $os, kommer objektets egenskap CSDVersion inte att återspegla ändringen eftersom objektet hade skapats baserat på de ursprungliga uppgifterna.
När du har definierat variabeln $os måste du ange två Add-Member-kommandon. Varje kommando tar emot fyra parametrar:
- -InputObject. Du använder parametern -InputObject för att identifiera det objekt som tar emot de nya notegenskaperna. I det här fallet måste du ange objektet $system.
- -MemberType. Parametern -MemberType anger vilken typ av medlem som ska skapas, så du måste ange NoteProperty.
- -Name. Du använder parametern -Name för att ange namnet på den nya medlemmen. I det här exemplet ger vi den första medlemmen namnet OperatingSystem och den andra medlemmen ServicePack.
- -Value. Den här parametern anger medlemmens värde. För den första noteregenskapen måste du ange $os.Caption för att återge namnet på operativsystemet. För den andra notisegenskapen måste du ange $os.CSDVersion för att returnera det senaste servicepack som tillämpats på operativsystemet.
Här ser de två Add-Member-kommandona ut:
Add-Member -InputObject $system -MemberType NoteProperty ` -Name OperatingSystem -Value $os.CaptionAdd-Member -InputObject $system -MemberType NoteProperty ` -Name ServicePack -Value $os.CSDVersion
Bemärk att jag har delat upp varje Add-Member-kommando i två rader. I slutet av varje första rad har jag inkluderat ett bakre kryss (`) så att PowerShell-processorn vet att den ska fortsätta till nästa rad för att få det fullständiga kommandot.
När du har kört Add-Member-kommandona kan du anropa variabeln $system för att se dess innehåll:
$system
Figur 2 visar ett exempel på resultat.
Du kan också använda variabeln $system för att anropa enskilda medlemmar. Ange helt enkelt variabelns namn, följt av en punkt och sedan medlemmens namn. Följande kommando returnerar till exempel det aktuella värdet för notegenskapen OperatingSystem:
$system.OperatingSystem
En fördel med att skapa ett anpassat objekt är att du kan skapa notegenskaper baserade på data som kommer från olika källor samt en notegenskap vars värde är en specifik sträng. Ta till exempel en titt på koden i Listing 1, som lägger till tre nya anteckningsegenskaper till objektet $system.
$mem = Get-WmiObject Win32_PhysicalMemory$disk = Get-WmiObject Win32_DiskDriveAdd-Member -InputObject $system -MemberType NoteProperty ` -Name PhysicalMemory ` -Value (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name DiskSize ` -Value (("{0:N2}" -f ($disk.Size/1GB)) + ' GB')Add-Member -InputObject $system -MemberType NoteProperty ` -Name Owner -Value "janetp"
De flesta av elementen i Listing 1 såg du i föregående exempel. Lägg dock märke till att koden skapar en instans av klassen Win32_PhysicalMemory, som tilldelas variabeln $mem, och en instans av klassen Win32_DiskDrive, som tilldelas variabeln $disk. Två av de tillagda anteckningsegenskaperna använder dessa nya WMI-objekt som datakällor.
Det första kommandot Add-Member hämtar data från egenskapen $mem.Capacity, som anger minnets kapacitet på målsystemet. I det här fallet är parametern -Value dock lite mer komplex än vad du såg i det föregående exemplet. Först anges i kommandot ”{0:N2}” följt av -f, som är en .NET-konstruktion för att formatera det utmatade talet. I princip anger detta att ett tal ska returneras med två decimaler. Formateringsinstruktionerna följs av ett kort uttryck ($mem.Capacity/1GB) som dividerar värdet Capacity med 1 GB. Värdet Capacity anger minnets storlek i bytes. PowerShell gör det enkelt att konvertera byte till gigabyte helt enkelt genom att dividera med 1 GB. Slutligen markerar kommandot strängen ’ GB’ (inklusive mellanslag) på utmatningen och omsluter det hela med parenteser.
Det andra kommandot Add-Member följer samma logik för att återge storleken på datorns hårddisk. Det använder egenskapen $disk.Size för att återge storleken i byte och omvandlar den sedan till gigabyte.
Det tredje kommandot Add-Member lägger till en anteckningsegenskap som heter Owner och tilldelar den strängvärdet janetp. I det här fallet kan ”owner” betyda vad som helst – den primära användaren, den sista användaren, administratören eller vilken betydelse du vill ge egenskapen. Jag inkluderade den här bara för att visa att du kan lägga till en anteckningsegenskap vars värde är en enkel sträng.
När du har lagt till de tre medlemmarna till det anpassade objektet kan du återigen anropa variabeln $system. Den kommer att ge resultat som de som visas i figur 3.
Du har nu ett enda objekt som innehåller data som härrör från tre olika WMI-objekt. Objektet innehåller också egenskapen Owner, som är baserad på ett strängvärde. Du kan anropa den där note-egenskapen på samma sätt som vilken annan medlem som helst:
$system.Owner
Som du kan förvänta dig returnerar kommandot värdet janetp. Du kan dock ändra det värdet till ett annat genom att tilldela egenskapen ett nytt värde, på följande sätt:
$system.Owner = "rogert"
I det här fallet har värdet rogert tilldelats egenskapen Owner note. Om du nu anropar den notegenskapen returneras det nya värdet.
Likt många av de uppgifter du kan utföra i PowerShell finns det ett antal olika sätt att lägga till en medlem i ett anpassat objekt. Med PowerShell 3.0 kan du till exempel skapa en hashtabell och skicka hashtabellen till kommandot New-Object. Koden i Listing 2 skapar samma fem anteckningsegenskaper men använder en hashtabell för att skicka in medlemsnamnen och värdena.
$info = @{ "OperatingSystem" = $os.Caption; "ServicePack" = $os.CSDVersion; "PhysicalMemory" = (("{0:N2}" -f ($mem.Capacity/1GB)) + ' GB'); "DiskSize" = (("{0:N2}" -f ($disk.Size/1GB)) + ' GB'); "Owner" = 'janetp'}$system = New-Object -TypeName PSObject -Property $info$system
Koden skapar först en hashtabell som definierar fem egenskaps-/värdepar, som var och en motsvarar anteckningsegenskaperna. Som koden visar måste du separera egenskap/värdeparen med semikolon. Du måste också innesluta de fem egenskapsparen/värdeparen i parenteser och föregå den öppna parentesen med symbolen at (@). Slutligen måste du tilldela hashtabellen till variabeln $info.
Efter att ha definierat hashtabellen använder koden cmdlet New-Object för att skapa ett objekt baserat på PSObject-klassen och tilldelar det till variabeln $system. Men den här gången innehåller kommandot parametern -Property, som tar variabeln $info som värde.
Slutligt anropar koden variabeln $system, som returnerar resultat som i figur 4. Lägg märke till den ordning i vilken egenskaperna har lagts till i objektet. Ett av problemen med att använda en hashtabell för att lägga till anteckningsegenskaper är att du inte kan kontrollera deras ordning. För att styra ordningen måste du använda cmdlet Add-Member för att lägga till varje medlem.
Lägga till metoder till ett anpassat objekt
Nu när du har sett hur enkelt det är att lägga till egenskaper, få tillgång till deras värden och ändra dessa värden, ska vi gå vidare till metoder. Dessa blir lite mer komplicerade eftersom metoder måste göra något och du måste definiera detta som en del av metodens värde.
Koden i Listing 3 skapar till exempel en metod som hämtar det aktuella datumet och klockan och returnerar dem både i sitt ursprungliga format och som UTC-värden (Coordinated Universal Time).
$method ={ $a = Get-Date -Format F; "Local: " + $a; $b = Get-Date; "UTC: " + $b.ToUniversalTime().DateTime}Add-Member -InputObject $system -MemberType ScriptMethod ` -Name GetUTC -Value $method
För att hålla koden lättläst kan du tilldela metodens värde till en variabel (t.ex. $method). Det värdet innehåller de uttryck som är nödvändiga för att returnera datum- och tidsinformationen. Du måste dock definiera värdet som ett skriptblock för att kunna skicka det till kommandot Add-Member. För att göra det omsluter du värdet i parenteser. PowerShell tilldelar sedan värdet i sin nuvarande form till variabeln som ett ScriptBlock-objekt.
I Listing 3 innehåller metodens värde två uttryck. Det första uttrycket returnerar det aktuella datumet och den aktuella tiden och det andra uttrycket returnerar UTC-versionen. Du börjar det första uttrycket genom att använda cmdlet Get-Date för att hämta det aktuella datumet och den aktuella tiden, som du tilldelar variabeln $a. Observera att när du anropar cmdlet Get-Date måste du inkludera parametern -Format tillsammans med värdet F. Detta säger åt PowerShell att visa tidsstämpeln i ett fullständigt datum- och tidsformat, som i måndagen den 19 augusti 2013 12:28:25 PM. Därefter lägger du till strängen ”Local: ”
I det andra uttrycket börjar du återigen med cmdlet Get-Date för att returnera det aktuella datumet och den aktuella tiden, som du tilldelar variabeln $b. Du använder sedan variabelns metod ToUniversalTime för att returnera datum och tid som ett UTC-värde och anger sedan egenskapen DateTime för att returnera rätt format.
Om du skulle anropa variabeln $method vid det här laget skulle den returnera de två uttrycken som strängar, precis som de skrevs. Eftersom du definierade det variabla värdet som ett skriptblock behandlas inte kommandona när de tilldelas variabeln $method. Istället skapas variabeln $method som ett ScriptBlock-objekt, vilket du kan bekräfta genom att använda GetType-metoden för att se variabelns typ:
$method.GetType()
För att arbeta med skriptblocket måste du lägga till metoden som en medlem i objektet $system efter att du definierat variabeln $method. För att göra det skapar du ett Add-Member-kommando som anger ScriptMethod som typ, GetUTC som namn och variabeln $method som värde.
När du kört koden i Listing 3 kan du använda variabeln $system för att anropa GetUTC-metoden på ungefär samma sätt som du anropade egenskaperna:
$system.GetUTC()
Observera dock att när du anropar skriptmetoden måste du inkludera parenteserna, precis som du gör för alla andra metoder, även om du inte lämnar in argument. Metoden bör nu returnera resultat som liknar resultaten i figur 5, men med datum och tid när du kallade metoden.
I verkligheten kommer du förmodligen att vilja skapa metoder som är mer slagkraftiga. Objektet $system kan till exempel innehålla WMI-hanteringsuppgifter i sina skriptmetoder. Om du gör det måste du testa metoden fullständigt för att se till att dina kommandon gör exakt vad de ska göra. PowerShell och WMI är båda kraftfulla verktyg, så de bör användas med försiktighet när du hanterar Windows-datorer.
Lägga till anpassade objekt i en array
Anpassade objekt är inte begränsade till fristående objekt som du använder en gång och sedan kastar åt sidan. Du kan lägga till dessa objekt i en objektmatris och sedan få tillgång till objekten via matrisen. Anta till exempel att du vill manipulera information som du hämtar från flera datorer. Informationen kan innehålla uppgifter om det minne och de logiska enheter som finns tillgängliga i systemen. Du vill kunna arbeta med dessa uppgifter på ett meningsfullt sätt i PowerShell. På grund av PowerShells objektorienterade karaktär är det ofta det enklaste sättet att arbeta med dessa data att placera informationen i objekt.
Vi tittar på ett exempel på hur du kan göra detta. För den här diskussionen är det oviktigt vilket tillvägagångssätt som används för att samla in informationen om de olika datorerna. Du kan till exempel sätta upp en foreach-slinga i PowerShell som använder WMI för att hämta information från de olika arbetsstationerna. Oavsett vilken metod som används antar vi för enkelhetens skull att du har samlat in informationen i en kommaseparerad textfil som innehåller de data som visas i figur 6.
Textsfilen innehåller en rubrikrad och en rad för varje systems logiska enheter. Den första dataraden innehåller till exempel information om den logiska enheten C på datorn ws01. Den logiska enheten har en kapacitet på 500 GB, med 225 GB ledigt utrymme. Systemet har också 4 GB minne. Den andra raden anger att samma dator även innehåller den logiska enheten D, som har samma kapacitet som enheten C men med 320 GB ledigt utrymme.
Målet är att omvandla varje datarad till ett eget anpassat objekt och sedan lägga till dessa objekt i en array. Du kan sedan vidta åtgärder på objekten i arrayen genom att pipa data till andra PowerShell-kommandon. Koden i Listing 4 definierar en tom array, importerar data från textfilen och använder sedan en foreach-slinga för att skapa objekten och lägga till dem i arrayen.
$SystemInfo = @()$SourceData = Import-CSV C:\DataFiles\SourceData.txtforeach ($source in $SourceData){ $system = New-Object -TypeName PSObject $system | Add-Member -Type NoteProperty ` -Name Computer -Value $source.Computer $system | Add-Member -Type NoteProperty ` -Name DeviceID -Value $source.DeviceID $system | Add-Member -Type NoteProperty ` -Name DriveSize -Value ($source.DriveSize) $system | Add-Member -Type NoteProperty ` -Name UsedSpace ` -Value ($source.DriveSize - $Source.FreeSpace) $system | Add-Member -Type NoteProperty ` -Name FreeSpace -Value ($source.FreeSpace) $SystemInfo += $system}
Som du kan se är det första steget att skapa den tomma arrayen (@()) och tilldela den till variabeln $SystemInfo. Så småningom lägger du till de anpassade objekten i denna array.
Nästan använder du cmdlet Import-CSV för att importera data till variabeln $SourceData. I den här övningen heter textfilen SourceData.txt och sparas i mappen C:\DataFiles. Cmdletten Import-CSV hämtar varje rad som ett eget objekt och sparar den i $SourceData. I det här läget kan du använda den variabeln för att få tillgång till data, men du har ingen kontroll över de medlemmar som ingår i objektet och du kan inte heller lägga till medlemmar.
Nästa steg är att skapa en foreach-slinga så att du kan skapa ett anpassat objekt för varje rad i textfilen. I foreach-villkoret ($source in $SourceData) anges att varje rad i $SourceData ska tilldelas variabeln $source när koden itererar genom foreach-slingan. Den logik som definieras i foreach-skriptblocket (inom parenteser) kommer sedan att köras en gång för varje rad, med ett annat $source-objekt som tillämpas under varje iteration. (Mer information om hur man skapar en foreach-slinga finns i PowerShell TechNet-ämnet about_ForEach.)
Vi ska titta närmare på skriptblocket foreach. Det första kommandot skapar det första objektet och sparar det i variabeln $system, som du såg i tidigare exempel. Därefter leds variabeln $system till ett Add-Member-kommando för att skapa den första notegenskapen. Detta är ett något annorlunda format än det som använts tidigare. Istället för att inkludera parametern -InputObject i Add-Member-kommandot, så rör du helt enkelt $system till kommandot. Detta ger samma resultat som du såg i de tidigare exemplen på Add-Member-kommandon. Jag har valt det här tillvägagångssättet här bara för att visa ytterligare ett sätt som PowerShell låter dig lägga till medlemmar.
För Add-Member-kommandots värde använder du variabeln $source för att anropa egenskapen Computer, som motsvarar fältet Computer i källdata. Det andra kommandot Add-Member fungerar på samma sätt, förutom att det hämtar data från egenskapen DeviceID. Observera att egenskapen Memory inte ingår. När du skapar ett anpassat objekt kan du utelämna vissa egenskaper eller placera dem i en annan ordning.
Det tredje kommandot Add-Member fungerar ungefär på samma sätt som de två första, förutom att det ger tillgång till egenskapen DriveSize. Eftersom du kanske vill arbeta med de här uppgifterna som ett numeriskt värde snarare än som en sträng, omvandlar kommandot uttryckligen uppgifterna till ett tal. Detta uppnås genom att föregå egenskapsnamnet med för att ange att du vill ha datatypenint och sedan omsluta hela egenskapsuttrycket med parenteser.
Det fjärde kommandot Add-Member gör något lite annorlunda. Det skapar en beräknad medlem som subtraherar FreeSpace-värdet från DriveSize-värdet för att bestämma mängden använt utrymme. Återigen föregås egenskapsnamnet av och hela uttrycket omsluts av parenteser. Att kunna skapa en beräknad egenskap är en av de viktigaste anledningarna till att du kanske vill skapa anpassade objekt.
Det sista kommandot Add-Member fungerar precis som det tredje, förutom att det hämtar data från FreeSpace-egenskapen.
Det sista kommandot i foreach-skriptblocket lägger till det aktuella $system-objektet till arrayen $SystemInfo. Observera att operatören += används för att se till att det nya $system-objektet läggs till vid varje iteration av slingan, utan att något skrivs över.
När du kört koden i Listing 4 kan du anropa variabeln för att visa dess innehåll. Figur 7 visar en partiell lista över de data som nu lagras i matrisen $SystemInfo.
Specifikt visar den data för de första sju objekten i matrisen, vilket motsvarar de första sju raderna data i den ursprungliga textfilen. Varje gruppering representerar ett av de objekt som lagts till i arrayen $SystemInfo. Du kan kontrollera att du har skapat en objektarray genom att använda GetType-metoden för att hämta variabelns typ:
$SystemInfo.GetType()
Om det här kommandot returnerar BaseType System.Array är variabeln $SystemInfo verkligen en objektarray som kan innehålla anpassade objekt. Du kan sedan använda variabeln för att manipulera data som du vill. Du kan till exempel leda variabeln till ett Sort-Object-kommando för att sortera data i fallande ordning, baserat på FreeSpace-värdena:
$SystemInfo | Sort FreeSpace -Descending
I det här fallet använder kommandot aliaset Sort för att hänvisa till Sort-Object-cmdletten och inkluderar FreeSpace-egenskapen och parametern -Descending. Som du kan se i figur 8 listas objekten nu i enlighet med värdena för FreeSpace, med det största fria utrymmet först. Återigen är detta bara en partiell lista.
Du kan också sortera data baserat på flera kolumner. Du kan till exempel sortera data först efter egenskapen Dator och sedan efter egenskapen Fritt utrymme, i fallande ordning:
$SystemInfo | Sort Computer, FreeSpace -Descending
Som du kan förvänta dig är resultaten nu mycket annorlunda, vilket framgår av figur 9.
En av konsekvenserna av att sortera kolumnerna på det här sättet är att datorvärdena såväl som värdena för ledigt utrymme sorteras i fallande ordning. Med cmdlet Sort-Object kan du inte enkelt sortera en kolumn i stigande ordning och en annan i fallande ordning. Om du anger parametern -Descending sorteras alla data i den ordningen. Du kan dock kringgå den här begränsningen genom att skapa uttryck för varje egenskap som anger hur värdena ska sorteras. Följande kommando sorterar till exempel först efter egenskapen Computer i stigande ordning och sedan efter egenskapen FreeSpace i fallande ordning:
$SystemInfo | Sort ` @{Expression="Computer"; Descending=$false}, @{Expression="FreeSpace"; Descending=$true}
Det första uttrycket Sort-Object ställer in egenskapen Expression på Computer och egenskapen Descending på $false. Det andra uttrycket ställer in Expression-egenskapen på FreeSpace och Descending-egenskapen på $true. (Variablerna $true och $false är inbyggda systemvariabler som ger de booleska värdena 1 respektive 0 som sant och falskt.) Du måste sedan innesluta varje uttryck i parenteser och föregå varje öppnande parentes med symbolen at (@). Nu sorteras data i önskad ordning, vilket visas i figur 10.
Detta kan tyckas vara överdrivet när det gäller sortering, men det pekar på flexibiliteten i att arbeta med objekt i en array. Och du är verkligen inte begränsad till cmdlet Sort-Object. I följande kommando skickas till exempel variabeln $SystemInfo till cmdlet Where-Object:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending
I det här fallet använder kommandot aliaset Where för att referera till cmdlet Where-Object. Dessutom anges att DriveSize-värdet måste vara större än 250 för att inkluderas i resultaten. (I PowerShell används -gt för operatorn större än.) De resultat som uppfyller dessa kriterier leds till cmdlet Sort-Object så att data visas i rätt ordning.
Du kan till och med leda de sorterade data till ett Select-Object-kommando, som i det här kommandot:
$SystemInfo | Where DriveSize -gt 250 | Sort FreeSpace -Descending | Select -First 5
Det här kommandot använder cmdlet Select-Object (som refereras till av aliaset Select) för att endast returnera de fem första raderna i resultatuppsättningen. Som du kan se har du en mängd olika alternativ för att arbeta med dessa objekt när du lägger till anpassade objekt i arrayen $SystemInfo.
För att få ut det mesta av dina anpassade objekt
För det mesta är det ganska enkelt att skapa anpassade objekt i PowerShell. Om det finns någon komplexitet inblandad kommer den i allmänhet från de värdeuttryck som du definierar för dina noteregenskaper eller skriptmetoder. Uttrycken i de här exemplen är relativt enkla jämfört med de typer av uttryck du kan skapa i PowerShell. Trots detta bör det du har sett här ge dig den grund du behöver för att skapa anpassade objekt. När de används effektivt kan de vara en kraftfull komponent i dina PowerShell-skript, oavsett om du skapar enskilda objekt, lägger till dem i en array eller använder dem på något annat sätt. Du kan till exempel skapa anpassade objekt i din PowerShell-profil så att de är tillgängliga varje gång du startar en ny session. Hur du använder anpassade objekt i dina skript är upp till dig. Du ska bara veta att det anpassade objektet är ett effektivt och flexibelt verktyg som kan tjäna många av dina skriptbehov.
För ytterligare information om hur du skapar anpassade objekt i Windows PowerShell, se Bill Stewarts ”Creating Custom Objects in Windows PowerShell.”