Arrays te gebruiken en te maken zijn een fundamentele eigenschap van PowerShell. Arrays maken het mogelijk om echte datastructuren in te nemen, te manipuleren en uit te voeren (en niet alleen raw strings). Deze mogelijkheid maakt PowerShell anders en nuttiger dan andere scripttalen.

in dit artikel zullen we uitleggen wat arrays zijn, en hoe ze te gebruiken in PowerShell. We zullen je eerst laten zien hoe je arrays maakt in PowerShell, en dan hoe je basisfuncties gebruikt om ze te manipuleren., Dan zullen we kijken naar verschillende soorten arrays, en verkennen een aantal van de meer subtiele kenmerken van hen.

ons doel is om u een goede basis te geven in het werken met arrays in PowerShell. Zodra je deze basis onder de knie hebt, kun je een kijkje nemen op onze cursus over PowerShell voor meer informatie.,

• Array Fundamentals
• Arrays van objecten
• Operators voor Arrays
• Hoe waarden toe te voegen aan een Array
• Arrays
• geavanceerde Arrays

PowerShell Arrays

Arrays zijn een veel voorkomende kenmerk van bijna alle programmeertalen. Ze zijn een gegevensstructuur die dient als een verzameling van meerdere stukken gegevens. Wanneer u met een array werkt, kunt u hetzelfde commando gebruiken om dezelfde functie uit te voeren op elk item in een array, of individuele elementen benaderen en manipuleren met behulp van een index.,

Arrays in PowerShell kunnen een of meer items bevatten. Een item kan een string, een geheel getal, een object of zelfs een andere array zijn, en een array kan elke combinatie van deze items bevatten. Elk van deze items heeft een index, die altijd begint (soms verwarrend) op 0. Dus het eerste item in een array krijgt de index 0, het tweede wordt geïndexeerd als 1, enzovoort.,

PowerShell-arrays zijn zo ‘ n fundamenteel onderdeel van PowerShell dat ze in elke PowerShell-tutorial verschijnen, en een goede kennis van hoe ermee te werken is cruciaal voor veel aspecten van het gebruik van PowerShell, van het configureren van Office 365 tot het gebruik van PowerShell voor Pentesting.

een voorbeeld van een PowerShell Array

De makkelijkste manier om te illustreren wat een array is door een voorbeeld te nemen. Laten we een array maken die een kom fruit voorstelt.,

Er zijn verschillende manieren om arrays aan te maken in Powershell, maar het makkelijkste is om dit commando uit te voeren:

@()

Dit maakt een lege array aan. Een lege array is echter niet zo nuttig, dus laten we wat vruchten toevoegen aan onze nieuwe array. Deze worden weergegeven als tekstreeksen. Om dat te doen, voer je dit commando uit

$fruit = @('Apples','Oranges','Bananas')

Dit zal een array “fruit” noemen en er drie items aan toevoegen., Om te zien of dit heeft gewerkt, kunt u de array lezen met het volgende commando:

PS /Users/yourname> $fruit

die nu zal teruggeven:

 Apples Oranges Bananas

zoals u kunt zien, is deze array een groep van individuele stukken data. PowerShell zal ze automatisch indexeren op de manier die we hierboven hebben uitgelegd:” Apple “zal worden geïndexeerd als 0,” sinaasappels “als 1, en” Bananas ” als 2.

dit voorbeeld kan het doen lijken alsof arrays vrij eenvoudige objecten zijn, en in zekere zin zijn ze dat ook. Hun eenvoud is echter ook wat hen zulke flexibele, krachtige objecten maakt., In de rest van deze gids geven we u een voorproefje van wat u kunt doen met arrays.

Array Fundamentals

In deze sectie zullen we kijken naar de meest elementaire manieren om arrays te maken en te werken in PowerShell.

Maak een Array

eerst maken we een array. De standaard manier om dit te doen is om @ () te gebruiken, hoewel er andere manieren zijn.

laten we nu een array maken met de naam “data”. Om dit te doen, voer je uit:

$data = @()

deze array is leeg op dit moment omdat we er geen gegevens voor hebben opgegeven., Om te controleren hoeveel items er in een array staan, kunnen we de count functie gebruiken:

$data.count

die op dit moment een 0 retourneert, omdat er geen items in onze array zijn. Om een array te maken met wat data erin, plaatsen we deze data tussen de haakjes na de @:

$data = @('Zero','One','Two','Three')

Voer nu dezelfde count functie uit, en je zult zien dat er 4 items in deze array zijn. Om deze items weer te zien, roepen we gewoon de array aan:

$data

die de items zal tonen die we in de array zetten.,

toegang tot Items

nu we een array hebben, zullen we items daaruit willen benaderen. Er zijn verschillende manieren om dit te doen. De eerste is om de index van de items in de array te gebruiken. Zoals we al eerder zeiden, beginnen indexen op 0, dus om het eerste item in onze array op te halen moeten we PowerShell vertellen om naar het item te kijken waarvan de index nul is. We doen dat door het uitvoeren van:

$data

Dit geeft” zero ” terug omdat dat de eerste string was die we in onze array zetten.,

we kunnen deze syntaxis ook uitbreiden om meerdere items uit dezelfde array te retourneren, gewoon door meer indexen in hetzelfde commando te plaatsen. Bijvoorbeeld:

$data

Dit geeft”Zero Two Three” terug. De items worden geretourneerd in dezelfde volgorde als u de indexen hebt ingevoerd. U kunt ook verdere syntaxis gebruiken om sets van items uit een array te retourneren. Bijvoorbeeld:

$data

retourneert alle items met een index tussen 1 en 3 (inclusief)., En:

$data

geeft het laatste item in de array terug: het negatieve getal vertelt PowerShell om terug te tellen vanaf het einde van de array, dus in dit geval geeft dit commando” Three ” terug, Het Laatste item in onze test array.

items wijzigen

dezelfde methode kan worden gebruikt om items in een array bij te werken. Bijvoorbeeld, om het item waarvan de index 2 is bij te werken (onthoud dat dit het derde item in de array is), kunnen we uitvoeren:

$data = 'second'

Dit geeft ons directe toegang tot de items in een array.,

herhaalde acties

een van de krachtigste functies van PowerShell (en, in feite, van elke command-line interface) is de mogelijkheid om dezelfde actie uit te voeren op alle items in een array. Er zijn een aantal verschillende manieren om dit te doen.

het meest basic is het gebruik van een pijplijn, dat is het teken |. Wanneer u een array doorgeeft aan een pijplijn, wordt elk item in een array afzonderlijk verwerkt. Zoals we hebben aangegeven in ons artikel over PowerShell objecten en data piping, dit is vaak de eenvoudigste manier om herhaalde acties uit te voeren.,

bijvoorbeeld, om een beschrijving toe te voegen aan elk item in onze array, kunnen we dit commando gebruiken:

$data | ForEach-Object {"Item: "}

Dit commando vertelt PowerShell om de items in $data één voor één te nemen, en vervolgens voor elk van hen “Item:” aan het begin toe te voegen, gevolgd door de oorspronkelijke waarde.

Er zijn verschillende andere manieren om herhaalde acties uit te voeren in PowerShell, waarvan veel bekend zullen zijn als u andere programmeertalen hebt gebruikt: PowerShell bevat ForEach loops, For loops, en Switch loops. Raadpleeg de documentatie van Microsoft voor meer informatie hierover.,

Arrays van objecten

tot nu toe hebben we gewerkt met een array die basisgegevens bevat: een string. Arrays kunnen echter ook objecten bevatten, en veel van de meest voorkomende toepassingen van PowerShell – zoals het configureren van Office 365 – vereisen dat u weet hoe u met objecten moet werken. Laten we eens kijken naar enkele basiscommando ‘ s om dat te doen.

een Array van objecten maken

we kunnen een array van objecten maken op dezelfde manier als we deden met tekenreeksen, met behulp van de functie @ ()., Om bijvoorbeeld een testlijst van werknemers te maken, kunnen we gebruiken:

De meeste cmdlets zullen een array van dit type retourneren wanneer je ze een variabele toewijst om mee te werken.

toegang tot objecten vanuit Arrays

het proces dat we hierboven hebben doorlopen om toegang te krijgen tot afzonderlijke stukken gegevens kan ook worden gebruikt met arrays die objecten bevatten., Bijvoorbeeld:

$data

geeft:

 FirstName LastName ----- ---- Kevin Marquette

als alternatief kunnen we de eigenschappen van individuele objecten benaderen door te specificeren welke eigenschap we binnen hetzelfde commando willen, zoals:

$data.FirstName

die”Kevin” zal teruggeven.

Objecteigenschappen bijwerken in Arrays

verder gaat het met dezelfde syntaxis dat we de mogelijkheid hebben om individuele eigenschappen bij te werken binnen objecten die in arrays worden bewaard., Bijvoorbeeld:

$data.FirstName = 'Jay'

zal de eigenschap voornaam in het eerste item in onze array bijwerken naar”Jay”.

toegang krijgen tot elke eigenschap in een Array van objecten

in de meeste programmeertalen zouden we een iteratief proces moeten gebruiken (zie hierboven) om toegang te krijgen tot alle eigenschappen in een array van objecten. Dat kunnen we natuurlijk ook in PowerShell doen door het volgende uit te voeren:

$data | ForEach-Object {$_.LastName}

Dit geeft een lijst van alle LastName eigenschappen in onze array terug, maar het is berekenend duur en moeilijk om te schrijven elke keer dat u deze gegevens wilt zien., Dus in plaats daarvan, PowerShell heeft een snelkoppeling. Voer dit uit:

$data.LastName

en u zult dezelfde lijst zien. PowerShell neemt elk object op zijn beurt, net als voorheen, maar het verbergt deze complexiteit voor ons.

Operators voor Arrays

bijna alle operators die we gebruiken voor individuele data-items in PowerShell zullen ook werken met arrays, maar sommige werken een beetje anders wanneer ze op deze manier worden gebruikt. Laten we eens kijken naar de meest voorkomende operators, en hoe je ze kunt gebruiken in arrays.,

– join

De-join operator is een van de meest gebruikte commando ‘ s in PowerShell, en het is zeer nuttig bij het werken met arrays. Het kan iteratief worden gebruikt op de items in een array om ze samen te voegen in de uitvoer van een array.

laten we een voorbeeld nemen. Maak eerst een eenvoudige array:

$data = @(1,2,3,4)

en gebruik dan-join om een koppelteken tussen elk item in te voegen, en voer het resultaat uit:

$data -join '-'

Wat”1-2-3-4″ zal teruggeven., De-join operator kan ook worden gebruikt zonder een scheidingsteken, waarin kunnen de items in een array worden uitgevoerd als een reeks van niet-gescheiden waarden.

-bevat

De-bevat operator werkt op arrays op een zeer vergelijkbare manier als het gebruik ervan met enkele gegevenspunten. Je kunt het gebruiken om te controleren of een array een bepaalde tekenreeks bevat, en het zal een Booleaanse waarde uitvoeren. Bijvoorbeeld:

 PS> $data = @('red','green','blue') PS> $data -contains 'green' True

gelijkenissen

Er zijn twee operatoren voor het controleren op gelijkheid in PowerShell: -eq en-ne., Als je gewend bent om deze op enkele waarden te gebruiken, kan de manier waarop deze werken in relatie tot arrays een beetje vreemd lijken. Als je bijvoorbeeld-eq gebruikt, zal de operator geen Booleaanse “True” uitvoeren, maar in plaats daarvan het object retourneren dat overeenkomt.

bijvoorbeeld:

 PS> $data = @('red','green','blue') PS> $data -eq 'green' green

De-ne operator werkt op vrijwel dezelfde manier, behalve dat het u alle waarden geeft die niet gelijk zijn aan uw opgegeven waarde., Dus:

 PS> $data = @('red','green','blue') PS> $data -ne 'green' red blue

u kunt echter een IF() statement gebruiken om de uitvoer van deze operators te vergelijken met uw verwachte uitvoer, en een” True “of” False ” uitvoer retourneren.

hoe waarden aan een Array toe te voegen

na alle bovenstaande instructies vraagt u zich waarschijnlijk af waarom we geen gegevensitems aan een array hebben toegevoegd. Dat komt omdat er geen manier is om dat te doen. Een array, eenmaal gemaakt, blijft voor altijd dezelfde grootte, en dus om het groter te maken moet je het kopiëren naar een nieuwe array, en het origineel verwijderen.,

dat klinkt ingewikkeld, maar Powershell behandelt dit proces voor u met behulp van een reeks vrij eenvoudige operators. Er zijn twee manieren om dit te doen.

Array additie

PowerShell kan twee arrays aan elkaar toevoegen met behulp van de “+” operator, die de complexiteit verbergt van wat het systeem eigenlijk doet. Bijvoorbeeld, als je twee test arrays als deze maakt:

 $first = @( 'Zero' 'One' ) $second = @( 'Two' 'Three' )

dan kun je ze samenvoegen met alleen:

 PS> $first + $second

Dit zal een nieuwe array maken met alle vier de waarden, en de resultaten uitvoeren., Merk echter op dat het deze nieuwe array geen nieuwe naam zal geven. Daarvoor gebruiken we de + = operator.

Plus is gelijk aan voor het combineren van Arrays

in plaats van de “+” operator in het bovenstaande voorbeeld te gebruiken, hadden we de “+=” operator kunnen gebruiken, die ons een geheel nieuwe array geeft:

 $first += 'Two, Three'

het commando ziet er eenvoudig uit, maar het verbergt wat PowerShell hier eigenlijk doet. Het is het kopiëren van alle waarden van $first, en het maken van een nieuwe array die de extra waarden bevat. Het verwijdert dan de originele array.,

Dit is enigszins problematisch omdat het rekenkundig duur is. Met kleine arrays merkt u het misschien niet, maar met grote hoeveelheden gegevens kan deze methode uw systeem snel vergrendelen. Daarom hebben we je hieronder een manier gegeven om dit probleem te omzeilen.

Array Types

tot nu toe hebben we te maken gehad met standaard arrays in PowerShell. Hoewel PowerShell ons toen niet vertelde, is elke array die we tot nu toe hebben gemaakt van één type, het] type. Dit type array kan elk type gegevenswaarde bevatten.,

sterk getypte Arrays

echter, er zijn momenten waarop u de soorten gegevens of objecten die een array kan houden tot slechts één wilt beperken. We kunnen dit doen door een sterk getypte array te gebruiken, die alleen het opgegeven gegevenstype kan bevatten.

bijvoorbeeld, om een array te maken die alleen gehele getallen kan bevatten, kunnen we gebruik maken van:

 PS> ] $numbers = 1,2,3

als je probeert de verkeerde gegevenswaarde in een sterk getypte array te zetten, zal het een foutcode teruggeven.

ArrayList

zoals we hierboven hebben gezegd, kan het toevoegen van items aan arrays een gedoe zijn., Er is echter een ander soort collectie-ArrayList-die dit eleganter behandelt. Om dit soort collectie te gebruiken, echter, zullen we een beroep moeten doen op het.NET framework, dat een aantal ongelukkige uitgangen in onze weg kan gooien.

om een ArrayList aan te maken en er vervolgens items aan toe te voegen, voer je het volgende uit:

 $myarray = ::new() $myArray.Add('Value')

Hier kunnen we de standaard.net-constructor gebruiken om een nieuwe ArrayList aan te maken en vervolgens de operator-Add gebruiken om er items aan toe te voegen. De operator is er omdat soms deze commando ‘ s gooien vreemde uitgangen die kunnen knoeien met de code.,

verder gaan

Dit zijn de meest voorkomende array types in PowerShell, maar er zijn een paar andere. Als u zich ontwikkelt als een PowerShell-gebruiker, is het handig om ArrayLists te gebruiken in plaats van straight arrays, maar u moet er ook rekening mee houden dat dit type array niet wordt gebruikt door gevorderde gebruikers.

in plaats daarvan gebruiken de meeste ervaren programmeurs een generiek lijsttype genaamd List. Dit type lijst is een beetje complexer om te gebruiken omdat het rechtstreeks is afgeleid van C#, maar als je het eenmaal onder de knie hebt, biedt het veel meer flexibiliteit dan de arrays die we tot nu toe hebben besproken.,

geavanceerde Array-functies

naast de basisfunctionaliteit die we tot nu toe hebben behandeld, zijn er ook een aantal meer geavanceerde array-functies en enkele extra functies om op te merken, als u ze vaker begint te gebruiken.

Pre-Sized Arrays

De standaard manier om arrays hierboven aan te maken zal een arrays creëren met een grootte bepaald door het aantal items erin. U kunt echter een array van een opgegeven grootte maken met behulp van de nieuwe($size) constructor.

u kunt dat als volgt doen:

 $data = ]::new(4)

Als u a uitvoert .,count query op deze array, het zal terugkeren “4”, Want hoewel het geen gegevens in het, het zal de ruimte te vullen met 0. Dit is erg handig als je een nieuwe array moet initialiseren die gevuld is met nullen omdat een Pre-sized array in eerste instantie gevuld zal zijn met 0.

het vermenigvuldigen van Arrays

het vermenigvuldigen van objecten in een array – en vooral strings – is iets dat de meeste mensen verwart wanneer ze het eerst moeten doen., We hebben extreem ingewikkelde if() scripts gezien om dit resultaat te bereiken, maar er is een veel eenvoudiger manier:

 PS> $data = @('red','green','blue') PS> $data * 3

Yep, dat klopt. Dit maakt een nieuwe array met elke waarde drie keer herhaald. U kunt dit commando ook gebruiken als een alternatieve manier om een array te vullen met nullen (of een andere standaardwaarde) door een array te maken met de door u gekozen waarde en deze vervolgens zo vaak te vermenigvuldigen als u wilt.

geneste Arrays

net als vele andere programmeertalen ondersteunt PowerShell geneste arrays., De standaard manier om dit te doen in PowerShell is om een multi-dimensionale array te gebruiken. Het eenvoudigste voorbeeld hiervan is het maken van een tweedimensionale array:

 $data = @(@(1,2,3),@(4,5,6),@(7,8,9)) $data2 = @( @(1,2,3), @(4,5,6), @(7,8,9) )

de gegevensstructuur die u maakt met dit commando is een klassieke matrix, en het kan worden gewerkt met zoals die in andere programmeertalen. Om bijvoorbeeld toegang te krijgen tot een bepaalde waarde uit deze array, moet u twee dimensies opgeven.,

bijvoorbeeld, om toegang te krijgen tot de waarde “3”, zouden we dit gebruiken:

 PS> $outside = 0 PS> $inside = 2 PS> $data 3

Dit commando kan dan worden gebruikt om toegang te krijgen tot elke waarde, maar je moet geneste haakjes toevoegen om binnen elk niveau van de matrix te komen.

een laatste woord

alle bovenstaande instructies kunnen veel zijn voor gebruikers die als eerste naar PowerShell komen, maar ze zijn zorgvuldig gekozen als een manier om de taal te leren. Door de verschillende technieken te combineren, kun je krachtige scripts bouwen om veel van de meest voorkomende – en meest tijdrovende – werk dat je doet met PowerShell te automatiseren.,

Deze vaardigheden zullen u ook helpen om verder te gaan dan PowerShell. Veel van de meest gebruikte talen voor het beheren van cybersecurity, zoals NetCat en Nmap, gebruiken veel van dezelfde principes als PowerShell. En dus is het gebruik van PowerShell om uw cybersecurity te verbeteren een geweldige manier om te leren hoe u uw systemen meer in het algemeen kunt beveiligen.