PowerShell Array Guide: Hur man använder och skapar
Arrays är ett grundläggande inslag i PowerShell. Arrays gör det möjligt att ta in, manipulera och mata ut sanna datastrukturer (och inte bara råa strängar). Denna förmåga gör PowerShell annorlunda och mer användbar än andra skriptspråk.
i den här artikeln förklarar vi vilka matriser som är och hur man använder dem i PowerShell. Vi ska först visa dig hur du skapar arrays i PowerShell och sedan hur du använder grundläggande funktioner för att manipulera dem., Då ska vi titta på flera olika typer av matriser och utforska några av de mer subtila egenskaperna hos dem.
Få Free PowerShell och Active Directory Essentials Video Course
vårt mål är att ge dig en bra jordning i att arbeta med matriser i PowerShell. När du har behärskat dessa grunder kan du ta en titt på vår kurs på PowerShell för att lära dig mer.,
- Array Fundamentals
- Arrays av objekt
- operatörer för Arrays
- hur man lägger till värden till en Array
- Array typer
- avancerade Array funktioner
PowerShell Arrays
Arrays är ett vanligt inslag i nästan alla Arrays.programmeringsspråk. De är en datastruktur som fungerar som en samling av flera bitar av data. När du arbetar med en array kan du antingen använda samma kommando för att utföra samma funktion på varje objekt i en array, eller komma åt och manipulera enskilda element med hjälp av ett index.,
matriser i PowerShell kan innehålla en eller flera objekt. Ett objekt kan vara en sträng, ett heltal, ett objekt eller till och med en annan matris, och en matris kan innehålla vilken kombination av dessa objekt som helst. Var och en av dessa objekt har ett index, som alltid börjar (ibland förvirrande) vid 0. Så det första objektet i en array ges indexet 0, det andra indexeras som 1 och så vidare.,
PowerShell arrays är en så grundläggande del av PowerShell att de visas i varje PowerShell-handledning där ute, och en god kunskap om hur man arbetar med dem är avgörande för många aspekter av att använda PowerShell, från att konfigurera Office 365 till att använda PowerShell för Pentesting.
ett exempel på en PowerShell Array
det enklaste sättet att illustrera vad en array är att ta ett exempel. Låt oss göra en matris som representerar en skål med frukt.,
det finns flera sätt att skapa matriser i Powershell, men det enklaste är att köra det här kommandot:
@()
det här skapar en tom array. En tom array är dock inte så användbar, så låt oss lägga till några frukter till vår nya array. Dessa kommer att representeras som textsträngar. För att göra det, kör det här kommandot
$fruit = @('Apples','Oranges','Bananas')
det här kommer att namnge en array ”fruit” och lägga till tre objekt till den., För att se att detta har fungerat kan du läsa matrisen med det här kommandot:
PS /Users/yourname> $fruit
som nu kommer tillbaka:
Apples Oranges Bananas
som du kan se är den här matrisen en grupp enskilda datastycken. PowerShell kommer automatiskt indexera dem på det sätt vi har förklarat ovan: ”Apple” kommer att indexeras som 0, ” apelsiner ”som 1 och” bananer ” som 2.
det här exemplet kan få det att verka som att arrayer är ganska enkla objekt, och på ett sätt som de är. Deras enkelhet är dock också det som gör dem så flexibla, kraftfulla föremål., I resten av den här guiden ger vi dig en smak av vad du kan göra med arrays.
Array Fundamentals
i det här avsnittet tittar vi på de mest grundläggande sätten att skapa och arbeta med arrays i PowerShell.
skapa en Array
först skapar vi en array. Det vanliga sättet att göra detta är att använda @ (), även om det finns andra sätt.
för tillfället, låt oss skapa en array som heter ”data”. För att göra detta, kör:
$data = @()
den här matrisen är tom för tillfället eftersom vi inte har angett några data för den., För att kontrollera hur många objekt som finns i en array kan vi använda räkningsfunktionen:
$data.count
som för närvarande kommer att returnera en 0, eftersom det inte finns några objekt i vår array. För att göra en matris med vissa data i den lägger vi dessa data inom parenteserna efter @:
$data = @('Zero','One','Two','Three')
kör samma räkningsfunktion nu, och du ser att det finns 4 objekt i den här matrisen. För att se dessa objekt igen åberopar vi bara matrisen:
$data
som listar de objekt vi lägger i matrisen.,
åtkomst till objekt
nu har vi en array, vi vill komma åt objekt från den. Det finns flera sätt att göra detta. Den första är att använda indexet för objekten i matrisen. Som vi sa tidigare börjar index på 0, så för att hämta det första objektet i vår array måste vi berätta för PowerShell att titta på objektet vars index är noll. Vi gör det genom att köra:
$data
detta kommer att returnera ”noll” eftersom det var den första strängen vi satte i vår array.,
Vi kan också utöka denna syntax för att returnera flera objekt från samma array, bara genom att lägga fler index i samma kommando. Kör till exempel:
$data
detta kommer att returnera ”Zero Two Three”. Objekten returneras i samma ordning som du angav indexerna. Du kan också använda ytterligare syntax för att returnera uppsättningar av objekt från en array. Till exempel:
$data
returnerar alla objekt med ett index mellan 1 och 3 (inklusive)., Och:
$data
returnerar det sista objektet i matrisen: det negativa numret berättar PowerShell att räkna bakåt från slutet av matrisen, så i det här fallet kommer det här kommandot att returnera ”Tre”, det sista objektet i vår testmatris.
ändra objekt
samma metod kan användas för att uppdatera objekten i en array. För att till exempel uppdatera objektet vars index är 2 (kom ihåg att det här är det tredje objektet i matrisen) kan vi köra:
$data = 'second'
detta ger oss direkt tillgång till objekten i en array.,
itererade åtgärder
en av de mest kraftfulla funktionerna i PowerShell (och i själva verket av något kommandoradsgränssnitt) är möjligheten att utföra samma åtgärd på alla objekt i en array. Det finns ett antal olika sätt att göra detta.
det mest grundläggande är att använda en rörledning, vilket är tecknet/. När du skickar en matris till en pipeline behandlas varje objekt i en matris individuellt. Som vi har påpekat i vår artikel om PowerShell-objekt och datarör, är detta ofta det enklaste sättet att utföra itererade åtgärder.,
till exempel, för att lägga till en beskrivning till varje objekt i vår array, kan vi använda det här kommandot:
$data | ForEach-Object {"Item: "}
det här kommandot berättar PowerShell att ta objekten i $data en åt gången, och sedan för var och en av dem lägga till ”Item:” till början, följt av det ursprungliga värdet.
det finns flera andra sätt att utföra itererade åtgärder i PowerShell, varav många kommer att vara bekanta om du har använt andra programmeringsspråk: PowerShell innehåller ForEach loopar, för loopar och Switch loopar. För mer information om dessa, kontrollera Microsoft-dokumentationen.,
matriser av objekt
hittills har vi arbetat med en matris som innehåller grundläggande data: en sträng. Arrays kan dock också innehålla objekt, och många av de vanligaste användningsområdena för PowerShell – liknande konfigurering av Office 365 – kräver att du vet hur man arbetar med objekt. Så låt oss titta på några grundläggande kommandon för att göra det.
skapa en rad objekt
Vi kan skapa en rad objekt på samma sätt som vi gjorde med strängar, med hjälp av @ () – funktionen., Till exempel, för att göra en testlista över anställda, kan vi använda:
de flesta cmdlets kommer att returnera en array av denna typ när du tilldelar dem en variabel att arbeta med.
åtkomst till objekt från matriser
processen vi körde igenom ovan för att komma åt enskilda datastycken kan lika användas med matriser som innehåller objekt., Till exempel kör:
$data
kommer att återvända:
FirstName LastName ----- ---- Kevin Marquette
Alternativt kan vi komma åt egenskaperna hos enskilda objekt genom att ange vilken egenskap vi vill ha inom samma kommando, så här:
$data.FirstName
som kommer att returnera ”Kevin”.
uppdatera Objektegenskaper i matriser
Om vi går vidare ger samma syntax oss möjlighet att uppdatera enskilda egenskaper inom objekt som hålls i matriser., Till exempel:
$data.FirstName = 'Jay'
uppdaterar egenskapen för förnamn i det första objektet i vår array till ”Jay”.
åtkomst till varje egenskap i en rad objekt
på de flesta programmeringsspråk måste vi använda en iterativ process (se ovan) för att komma åt alla egenskaper i en rad objekt. Vi kan också göra det i PowerShell, naturligtvis, genom att köra:
$data | ForEach-Object {$_.LastName}
detta kommer att returnera en lista över alla efternamn egenskaper i vår array, men det är beräkningsmässigt dyrt och svårt att skriva varje gång du vill se dessa data., Så istället har PowerShell en genväg. Kör detta:
$data.LastName
och du kommer att se samma lista. PowerShell tar faktiskt varje objekt i sin tur, precis som tidigare, men det döljer denna komplexitet från oss.
operatörer för arrayer
nästan alla operatörer som vi använder för enskilda dataobjekt i PowerShell kommer också att fungera med arrayer, men några av dem fungerar lite annorlunda när de används på detta sätt. Så låt oss ta en titt på de vanligaste operatörerna, och hur du kan använda dem i arrayer.,
-join
– join-operatören är en av de mest använda kommandona i PowerShell, och det är extremt användbart när man arbetar med arrays. Det kan användas iterativt på objekten i en array för att ansluta dem tillsammans i produktionen av en array.
låt oss ta ett exempel. Skapa först en enkel array:
$data = @(1,2,3,4)
och använd sedan-join för att infoga ett bindestreck mellan varje objekt och mata ut resultatet:
$data -join '-'
som kommer att returnera”1-2-3-4″., – Join operatören kan också användas utan en avgränsare, där objekten i en array kommer att matas ut som en serie oskiljaktiga värden.
-innehåller
– innehåller operatorn fungerar på arrayer på ett mycket liknande sätt som dess användning med enstaka datapunkter. Du kan använda den för att kontrollera om en array innehåller en viss sträng, och det kommer att mata ut ett booleskt värde. Till exempel:
PS> $data = @('red','green','blue') PS> $data -contains 'green' True
Equalities
det finns två operatörer för att kontrollera jämlikhet i PowerShell:- eq och-ne., Om du är van vid att använda dessa på enstaka värden kan dock det sätt som dessa arbeten i förhållande till arrays verkar lite konstigt. Om du använder-eq, till exempel, kommer operatören inte att mata ut en boolesk ”True”, men istället kommer att returnera objektet som matchar.
till exempel:
PS> $data = @('red','green','blue') PS> $data -eq 'green' green
– ne-operatören fungerar på ungefär samma sätt, förutom att det ger dig alla värden som inte är lika med ditt angivna värde., Så:
PS> $data = @('red','green','blue') PS> $data -ne 'green' red blue
Du kan dock använda en if () – sats för att jämföra dessa operatörers utdata med din förväntade utdata och returnera en ”True” eller ”False” – utgång.
hur man lägger till värden i en Array
Efter alla instruktioner ovan undrar du förmodligen varför vi har utelämnat att lägga till dataobjekt i en array. Det är för att det inte finns något sätt att göra det. En array, en gång skapad, förblir samma storlek för alltid, och så för att göra den större måste du kopiera den till en ny array och ta bort originalet.,
det låter komplicerat, men Powershell hanterar denna process för dig med en serie ganska enkla operatörer. Det finns två huvudsakliga sätt att göra detta.
Array Addition
PowerShell kan lägga till två matriser tillsammans med ” + ” – operatören, vilket döljer komplexiteten i vad systemet faktiskt gör. Till exempel, om du gör två testmatriser så här:
$first = @( 'Zero' 'One' ) $second = @( 'Two' 'Three' )
Du kan sedan lägga till dem tillsammans med bara:
PS> $first + $second
detta kommer att göra en ny array med alla fyra värden och mata ut resultaten., Observera dock att det inte kommer att ge denna nya array ett nytt namn. För att göra det använder vi + = – operatören.
Plus är lika med för att kombinera arrayer
istället för att använda ” + ”- operatören i ovanstående exempel kunde vi ha använt ”+ = ” – operatören, vilket ger oss en helt ny array:
$first += 'Two, Three'
kommandot ser enkelt ut, men det döljer vad PowerShell faktiskt gör här. Det kopierar alla värden från $först och gör en ny array som innehåller de extra värdena. Det tar sedan bort den ursprungliga matrisen.,
detta är något problematiskt eftersom det är beräkningsmässigt dyrt. Med små matriser kanske du inte märker, men med stora mängder data kan den här metoden snabbt låsa upp ditt system. Det är därför vi har gett dig en väg runt detta problem, nedan.
Array typer
hittills har vi arbetat med standard arrays i PowerShell. Även om PowerShell inte berättade för oss vid den tiden, är varje array som vi har skapat hittills av en typ, den] typen. Denna typ av matris kan hålla någon typ av datavärde.,
starkt skrivna matriser
det finns dock tillfällen när du vill begränsa de typer av data eller objekt som en array kan hålla till bara en. Vi kan göra detta genom att använda en starkt maskinskriven array, som endast kan innehålla den angivna datatypen.
till exempel, för att skapa en array som bara kan ta heltal, kan vi använda:
PS> ] $numbers = 1,2,3
om du försöker och lägger fel typ av datavärde i en starkt maskinskriven array kommer den att returnera en felkod.
ArrayList
som vi har sagt ovan kan det vara jobbigt att lägga till objekt i matriser., Det finns dock en annan typ av samling-ArrayList-som hanterar detta mer elegant. För att kunna använda denna typ av samling måste vi dock åberopa. NET framework, vilket kan kasta några olyckliga utgångar i vår väg.
för att skapa en ArrayList och sedan lägga till objekt i den, kör följande:
$myarray = ::new() $myArray.Add('Value')
Här kan vi använda standard.Net-konstruktören för att skapa en ny ArrayList och sedan använda-Lägg till operatör för att lägga till objekt till den. Operatören är där eftersom ibland dessa kommandon kasta ut konstiga utgångar som kan bråka med koden.,
gå vidare
det här är de vanligaste arraytyperna i PowerShell, men det finns några andra. Om du utvecklar som en PowerShell-användare är det användbart att börja använda arraylister istället för raka arrayer, men du bör också vara medveten om att denna typ av array inte används av avancerade användare.
istället kommer de flesta erfarna kodare att använda en generisk listtyp som heter List. Denna typ av lista är lite mer komplex att använda eftersom den är härledd direkt från C#, men när du har behärskat den, erbjuder den mycket mer flexibilitet än de arrayer vi har diskuterat hittills.,
avancerade Array-funktioner
förutom den grundläggande funktionalitet som vi hittills har täckt finns det också ett antal mer avancerade array-funktioner och några extra funktioner att notera, eftersom du börjar använda dem oftare.
förstora matriser
det vanliga sättet att skapa matriser ovan kommer att skapa en array med en storlek som bestäms av antalet objekt i den. Du kan dock skapa en array av en viss storlek med hjälp av den nya($size) konstruktören.
Du kan göra så här:
$data = ]::new(4)
om du kör en .,räkna fråga på denna array, det kommer att returnera ”4”, eftersom även om det inte har data i det, kommer det att fylla utrymmet med 0. Detta är faktiskt mycket användbart om du behöver initiera en ny array som är fylld med nollor eftersom en förstor array ursprungligen kommer att fyllas med 0.
multiplicera arrayer
multiplicera objekten i en array – och speciellt strängar – är något som förvirrar de flesta när de först måste göra det., Vi har sett extremt komplicerade om() skript för att uppnå detta resultat, men det finns ett mycket enklare sätt:
PS> $data = @('red','green','blue') PS> $data * 3
Japp, det är rätt. Detta kommer att skapa en ny array med varje värde upprepas tre gånger. Du kan också använda det här kommandot som ett alternativt sätt att fylla en matris med nollor (eller något annat standardvärde) genom att göra en matris med ditt valda värde och sedan multiplicera det så många gånger du vill.
kapslade matriser
liksom många andra programmeringsspråk stöder PowerShell kapslade matriser., Det vanliga sättet att göra detta i PowerShell är att använda en flerdimensionell array. Det enklaste exemplet på detta är att skapa en tvådimensionell array:
$data = @(@(1,2,3),@(4,5,6),@(7,8,9)) $data2 = @( @(1,2,3), @(4,5,6), @(7,8,9) )
datastrukturen du gör med det här kommandot är en klassisk matris, och det kan fungera med som de på andra programmeringsspråk. För att komma åt ett visst värde från den här matrisen måste du till exempel ange två dimensioner.,
till exempel, för att komma åt värdet ”3”, skulle vi använda detta:
PS> $outside = 0 PS> $inside = 2 PS> $data 3
det här kommandot kan sedan användas för att komma åt vilket värde som helst, men du måste lägga till kapslade parentes för att komma in i varje nivå i matrisen.
ett sista ord
alla instruktioner ovan kan vara mycket för användare som först kommer till PowerShell, men de har noggrant valts som ett sätt att lära sig språket. Genom att kombinera de olika teknikerna kan du bygga kraftfulla skript för att automatisera många av de vanligaste – och mest tidskrävande – arbetet du gör med PowerShell.,
dessa färdigheter kommer också att hjälpa dig att gå utöver PowerShell. Många av de vanligaste språken som används för att hantera cybersäkerhet, som NetCat och Nmap, använder många av samma principer som PowerShell gör. Och så använder PowerShell för att förbättra din cybersäkerhet är ett bra sätt att lära sig att säkra dina system mer allmänt.
