Adam de Automator

vaak moet u bij het schrijven van PowerShell-scripts een manier vinden om een set items op te slaan. Een veel voorkomende manier om dit te bereiken is met een array of specifiek type bekend als een ArrayList. Maar wat is een array eigenlijk? Een array is een datastructuur die is ontworpen om een verzameling items op te slaan. Dit kan zowel dezelfde als verschillende soorten items.

Arrays worden in veel verschillende programmeertalen gebruikt en PowerShell is niet anders. Er zijn vele manieren om arrays te maken, te manipuleren en te optimaliseren., In dit artikel leer je over ArrayLists, Arrays en collecties, evenals enkele best practices bij het toepassen ervan met PowerShell.

vereisten/vereisten

omdat u alleen met de PowerShell-taal zelf werkt, zijn er geen omgevingsvereisten. Je hoeft alleen maar een Windows-PC met PowerShell te hebben. Meer specifiek:

• Windows PowerShell 3 of hoger
• . NET Framework 4.5 of hoger

wilt u meer tips zoals deze?, Bekijk mijn persoonlijke PowerShell blog op: https://nkasco.com/FriendsOfATA

Arrays maken met PowerShell

Er zijn veel verschillende manieren om arrays te maken met PowerShell. Laten we aannemen dat je een lijst met namen hebt die je op een of andere manier moet verwerken, zoals hieronder weergegeven.

JohnSusieJimJohnnyCarrie

Arrays bouwen via door komma ’s gescheiden elementen

de meest eenvoudige manier om een array aan te maken is door simpelweg bekende ingangen, door komma’ s gescheiden, toe te wijzen aan een variabele zoals hieronder getoond.,

$BasicArray = "John", "Susie", "Jim", "Johnny", "Carrie"

Als u de methode GetType() uitvoert die beschikbaar is op alle objecten in PowerShell, zult u zien dat u met succes een array hebt aangemaakt zoals aangegeven door de eigenschap BaseType hieronder.

PS51> $BasicArray.GetType()IsPublic IsSerial Name BaseType -------- -------- ---- -------- True True Object System.Array

met behulp van de Subexpressie-Operator

kunt u ook arrays in PowerShell maken via een subexpressie-operator. Dit concept wordt vaak gebruikt wanneer u niet weet hoeveel items aan uw array zullen worden toegevoegd. Het resultaat kan nul of veel items bevatten wanneer het wordt gemaakt.,

Notice onder een array genaamd $MyArray is gemaakt met nul elementen erin.

#Create an empty array with the sub-expression operatorPS51> $MyArray = @()PS51> $MyArray.count0

gebruikmakend van de Range Operator

Arrays worden niet alleen gedegradeerd naar het opslaan van tekenreeksen zoals hierboven getoond. U kunt ook arrays maken met andere objecttypen zoals gehele getallen.

Als u een array van gehele getallen in volgorde nodig hebt, kunt u een sneltoets nemen en het bereik .. operator gebruiken. Hieronder kun je zien dat een array is gemaakt met de gehele getallen 2 tot en met 5 met een enkele regel code.,

PS51> $NumberedArray = 2..5PS51> $NumberedArray2345

PowerShell-ArrayList-collecties aanmaken

met behulp van een PowerShell-ArrayList is ook een manier waarop u een lijst met items met PowerShell kunt opslaan. De ArrayList klasse maakt deel uit van het systeem.Collecties namespace binnen. NET. door een nieuw object van dit type aan te maken kunt u vervolgens objecten opslaan in een ArrayList.

hieronder kunt u zien dat u expliciet een ArrayList object moet maken met behulp van deNew-Object cmdlet of door een standaard array naar een ArrayList object te gieten.,

merk op dat in dit geval de BaseType Een object is, terwijl de bovenstaande voorbeelden Basetypes van Arrays hebben die overerving van de objectklasse vertonen. Uiteindelijk, PowerShell is het verstrekken van toegang tot het.net type systeem.

Items toevoegen aan een Array

wanneer u een array maakt, kunt u alle elementen tijdens het aanmaken definiëren of ad-hoc toevoegen.

om elementen aan een bestaande verzameling toe te voegen, kunt u de += operator gebruiken of de Add methode. Maar weet dat er grote verschillen zijn in hoe ze werken.,

wanneer u een standaard array maakt met @(), gebruikt u de += operator, maar om elementen aan een ArrayList toe te voegen, gebruikt u de Add methode. Deze methoden verschillen in het feit dat de operator += de bestaande array vernietigt en een nieuwe creëert met het nieuwe item.

om aan te tonen, zie je hieronder dat je kunt verwijzen naar de IsFixedSize eigenschap voor een array of ArrayList om te weten welke onveranderlijk is en welke niet.,

PS51> $BasicArray.IsFixedSizeTruePS51> $MyArrayList.IsFixedSizeFalse

aangezien een basisarray een verzameling van vaste grootte is, kunt u deze niet wijzigen.

een poging om deAdd() methode te gebruiken met een array met een vaste grootte zal resulteren in een fout als gevolg van de vaste grootte. Hieronder kunt u een paar voorbeelden zien waarin u met succes items kunt toevoegen aan een array.

#Does NOT work$BasicArray.Add("Nate")#Works$BasicArray += "Nate"$MyArrayList.Add("Nate")$MyArrayList += "Nate"

Items uit een Array verwijderen

Nu u een beter begrip hebt van het toevoegen van items aan een array, laten we een paar manieren behandelen waarop u items uit een array kunt verwijderen.,

omdat een basisarray is opgelost, kunt u er geen items uit verwijderen. In plaats daarvan moet je een geheel nieuwe array maken. U kunt bijvoorbeeld een enkel element uit een array verwijderen door een voorwaardelijke verklaring te maken die alleen overeenkomt met de elementen die u wilt opnemen. Hieronder volgt een voorbeeld.

$NewBasicArray = $BasicArray -ne "Nate"

omdat een ArrayList niet is opgelost, kunt u elementen ervan verwijderen met behulp van de Remove() methode. Dit is een scenario waarin het gebruik van een ArrayList u kan helpen als u van plan bent om regelmatig items toe te voegen/te verwijderen.,

$MyArrayList.Remove("Nate")

specifieke Items uit een Array of ArrayList ophalen

om specifieke items uit een array of ArrayList op te halen, kunt u veel verschillende methoden gebruiken. Net als andere objecten in PowerShell, kunt u toegang krijgen tot alle elementen van een array door simpelweg het object aan te roepen.

PS51> $BasicArrayJohnSusieJimJohnnyCarrie

misschien moet u alleen het eerste element ophalen, arrays zullen altijd een oorsprong hebben van 0 die het eerste element van de array representeert. Om het eerste element van een array op te halen, specificeer je het indexnummer tussen haakjes zoals hieronder getoond.,

PS51> $BasicArrayJohn

omgekeerd kunt u indexen ook naar achteren verwijzen door een streepje (negatieve indicator) te gebruiken om het laatste X-aantal elementen uit de array aan te roepen. Een veelgebruikte manier om het laatste element in een array te vinden is -1 zoals hieronder getoond.

PS51> $BasicArrayCarrie

De range operator die u hierboven hebt geleerd, kan ook worden gebruikt om objecten van een array op te halen door dezelfde methode te volgen om de elementen aan te roepen. Stel dat je de eerste vier namen in de $BasicArray array wilt ophalen.,

hieronder kunt u een reeks indexen 0-3 opgeven die de eerste vier elementen retourneren.

PS51> $BasicArrayJohnSusieJimJohnny

Arrays optimaliseren met PowerShell

nu u een goede basis hebt voor het maken en manipuleren van arrays, welke moet u gebruiken? Om dat te beantwoorden, laten we een paar voorbeelden doornemen met de Measure-Command cmdlet. Met behulp van deMeasure-Command cmdlet, zult u beter begrijpen hoe lang commando ‘ s nodig hebben om elementen te verwerken terwijl ze via de pijplijn worden doorgegeven.,

in het algemeen, als je een kleine verzameling objecten hebt zal je waarschijnlijk niet veel verschil merken met hoe je je arrays manipuleert. Echter, als je een grote collectie van objecten is het belangrijk om de verschillen te begrijpen om optimale resultaten te bereiken.

laten we toepassen wat je net geleerd hebt in de vorige sectie over het verschil tussen += en het gebruik van de Add() methode met een lus van 50.000 items.

maak eerst een lege array en een lege ArrayList zoals hieronder getoond.,

PS51> $MyArray = @()PS51> $MyArrayList = @()

vul vervolgens 50.000 elementen in elke verzameling met behulp van de range operator en een foreach lus zoals hieronder getoond.

@(0..50000).foreach({$MyArray += $_})@(0..50000).foreach({$MyArrayList.Add($_)})

ten slotte, wikkel uw commando ‘ s in een expressie en geef die expressie door aan de Measure-Command cmdlet. Door de expressie uit te voeren met Measure-Command, kunt u zien hoe lang elk proces eigenlijk duurt om uit te voeren.

Houd er rekening mee dat, zoals u eerder hebt geleerd, += eigenlijk een nieuwe array maakt in plaats van aan een vaste array toe te voegen.,

het resultaat? Bijna 60 seconden tegen 139 milliseconden!

zoals u kunt zien, is het veel sneller om een ArrayList te gebruiken voor grote collecties in plaats van een array met een vaste grootte te gebruiken.

hoewel dit een basisvoorbeeld is, benadrukt het het belang om te begrijpen wat uw code doet tijdens het verwerken. Als het niet goed wordt begrepen, kan het resulteren in een slechte gebruikerservaring.,

Als u een bestaand script hebt dat baat zou kunnen hebben bij het gebruik van een ArrayList in plaats van een array, dan zou dit een fantastische kans zijn om een nachtelijke verbetering te maken!

verder lezen

• arrays vergelijken met PowerShell
• Hoe Arrays maken voor prestaties in PowerShell (MCPmag)

wilt u meer tips zoals deze? Bekijk mijn persoonlijke PowerShell blog op: https://nkasco.com/FriendsOfATA.