Alles wat u al wilde weten over arrays

• 10/08/2020
• 24 minuten te lezen
• • j
  • h
  • s
  • V

Arrays zijn een fundamentele taal eigenschap van de meeste programmeertalen. Het is een verzameling waarden of objecten die moeilijk te vermijden zijn. Laten we eens een kijkje nemen op arrays en alles wat ze te bieden hebben.,

Wat is een array?

Ik ga beginnen met een fundamentele technische beschrijving van wat arrays zijn en hoe ze worden gebruikt door de meeste programmeertalen voordat ik overschakel naar de andere manieren waarop PowerShell er gebruik van maakt.

een array is een gegevensstructuur die dient als een verzameling van meerdere items., U kunt itereren over de array of toegang tot afzonderlijke items met behulp van een index. De array wordt gemaakt als een opeenvolgend stuk van Memory waar elke waarde wordt opgeslagen vlak naast de andere.

Ik zal op elk van deze details als we gaan.

basisgebruik

omdat arrays zo ‘ n basisfunctie van PowerShell zijn, is er een eenvoudige syntaxis voor het werken met ze in PowerShell.,

Creëer een array

een lege array kan worden aangemaakt met @()

PS> $data = @()PS> $data.count0

We kunnen een array maken en deze met waarden beginnen door ze in de @() haakjes te plaatsen.

PS> $data = @('Zero','One','Two','Three')PS> $data.count4PS> $dataZeroOneTwoThree

deze array heeft 4 items. Als we de $data variabele aanroepen, zien we de lijst met onze items. Als het een array van snaren is, dan krijgen we één regel per snaar.

we kunnen een array Declareren op meerdere regels. De komma is optioneel in dit geval en meestal links.,

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

Ik geef de voorkeur aan het declareren van mijn arrays op meerdere regels zoals deze. Niet alleen wordt het makkelijker om te lezen wanneer u meerdere items hebt, het maakt het ook gemakkelijker om te vergelijken met eerdere versies bij het gebruik van sourcecontrol.

andere syntaxis

het is algemeen bekend dat @() de syntaxis is voor het maken van een array, maar kommagescheiden lijsten werken meestal.,

$data = 'Zero','One','Two','Three'

Write-Output om arrays

aan te maken een leuke truc die het vermelden waard is, is dat u Write-Output kunt gebruiken om snel strings aan te maken op de console.

$data = Write-Output Zero One Two Three

Dit is handig omdat je geen aanhalingstekens rond de strings hoeft te plaatsen wanneer de parameter strings accepteert. Ik zou dit nooit doen in een script, maar het is eerlijk spel in de console.

toegang tot items

Nu u een array hebt met items erin, kunt u deze items openen en bijwerken.,

Offset

om toegang te krijgen tot individuele items, gebruiken we de haakjes met een offset waarde vanaf 0. Dit is hoe we het eerste item in onze array krijgen:

PS> $data = 'Zero','One','Two','Three'PS> $dataZero

de reden waarom we hier nul gebruiken is omdat het eerste item aan het begin van de lijst staat, dus we gebruiken een verschuiving van 0 items om er bij te komen. Om bij het tweede item te komen, zouden we een offset van 1 toskip het eerste item moeten gebruiken.

PS> $dataOne

Dit zou betekenen dat het laatste item op offset 3 staat.,

PS> $dataThree

Index

nu kunt u zien waarom ik de waarden koos die ik voor dit voorbeeld deed. Ik introduceerde dit als een offset omdat dat is wat het echt is, maar deze offset wordt meer algemeen aangeduid als een index. Eenindex die begint bij 0. Voor de rest van dit artikel noem ik de offset een index.

speciale index trucs

in de meeste talen kunt u slechts een enkel nummer als index opgeven en krijgt u een enkel item terug.PowerShell is veel flexibeler. U kunt meerdere indexen tegelijk gebruiken., Door een lijst met indexen op te geven, kunnen we verschillende items selecteren.

PS> $dataZeroTwoThree

De items worden geretourneerd op basis van de volgorde van de verstrekte indexen. Als je een index dupliceert, krijg je dat item beide keren.

PS> $dataThreeZeroThree

We kunnen een reeks getallen specificeren met de ingebouwde .. operator.

PS> $dataOneTwoThree

Dit werkt ook in omgekeerde richting.

PS> $dataThreeTwoOne

u kunt negatieve indexwaarden gebruiken om van het einde af te wijken. Dus als je het laatste item in de lijst nodig hebt,kun je -1gebruiken.,

PS> $dataThree

Out of bounds

In de meeste talen, als u probeert toegang te krijgen tot een index van een item dat voorbij het einde van de array is, zou u een soort fout of een uitzondering krijgen. PowerShell geeft in stilte niets terug.

PS> $null -eq $dataTrue

kan niet indexeren in een null array

als uw variabele $null is en u probeert deze te indexeren als een array, krijgt u eenSystem.Management.Automation.RuntimeException uitzondering met het berichtCannot index into a null array.,

PS> $empty = $nullSP> $emptyError: Cannot index into a null array.

dus zorg ervoor dat uw arrays niet $null zijn voordat u toegang probeert te krijgen tot elementen binnen hen.

Count

Arrays en andere collecties hebben een count-eigenschap die u vertelt hoeveel items er in de array zijn.

PS> $data.count4

PowerShell 3.0 heeft een count-eigenschap toegevoegd aan de meeste objecten. u kunt een enkel object hebben en het zou u een telling moeten geven van 1.

PS> $date = Get-DatePS> $date.count1

Even $null heeft een count-eigenschap, behalve dat het 0retourneert.,

PS> $null.count0

Er zijn hier enkele traps die Ik zal herzien wanneer ik de controle op $null of lege arrayslater in dit artikel.

Off-by-one fouten

een veelvoorkomende programmeerfout wordt gemaakt omdat arrays beginnen bij index 0. Off-by-one fouten kunnen op twee manieren worden ingevoerd.

de eerste is door mentaal te denken dat je het tweede item wilt en een index van 2 te gebruiken en het derde item echt te krijgen. Of door te denken dat je vier items hebt en je wilt het laatste item, zodat u de countto toegang tot het laatste item.,

$data

PowerShell laat u dat graag doen en geeft u precies welk item bestaat op index 4:$null. U zou $data.count - 1 moeten gebruiken of de -1 waarover we hierboven hebben geleerd.

PS> $dataThree

Hier kunt u de -1 index gebruiken om het laatste element te verkrijgen.

PS> $dataThree

Lee Dailey wees me er ook op dat we$data.GetUpperBound(0) kunnen gebruiken om het Max-indexnummer te krijgen.,

PS> $data.GetUpperBound(0)3PS> $dataThree

de tweede meest voorkomende manier is wanneer de lijst wordt herhaald en niet op het juiste moment wordt gestopt. Dit bezoek ik als we praten over het gebruik van de for lus.

items bijwerken

We kunnen dezelfde index gebruiken om bestaande items in de array bij te werken. Dit geeft ons directe toegang toupdate individuele items.

$data = 'dos'$data = 'tres'

als we een item proberen bij te werken dat voorbij het laatste element is, dan krijgen we eenIndex was outside the bounds of the array. fout.

Ik kom hier later nog op terug als ik het heb over hoe een array groter te maken.,

iteratie

op een gegeven moment moet u misschien de hele lijst lopen of herhalen en wat actie uitvoeren voor elk item in de array.

pijplijn

Arrays en de PowerShell-pijplijn zijn voor elkaar bedoeld. Dit is een van de eenvoudigste manieren om deze waarden te verwerken. Wanneer u een array doorgeeft aan een pijplijn, wordt elk item in de array afzonderlijk verwerkt.

PS> $data = 'Zero','One','Two','Three'PS> $data | ForEach-Object {"Item: "}Item: Item: Item: Item: 

als u $PSItem niet eerder hebt gezien, weet dan dat het hetzelfde is als $_., Je kunt eitherone gebruiken omdat ze allebei het huidige object in de pijplijn vertegenwoordigen.

ForEach loop

deForEach loop werkt goed met Collecties. Gebruikmakend van de syntaxis:foreach ( <variable> in <collection> )

foreach ( $node in $data ){ "Item: "}

ForEach method

Ik heb de neiging om deze methode te vergeten, maar het werkt goed voor eenvoudige operaties. Met PowerShell kunt u .ForEach() oproepen op een verzameling.

PS> $data.foreach({"Item "})Item Item Item Item 

de .foreach() neemt een parameter die een scriptblok is., Je kunt de haakjes laten vallen en gewoon het script blokkeren.

$data.foreach{"Item "}

Dit is een minder bekende syntaxis, maar het werkt precies hetzelfde. Dezeforeach methode werd toegevoegd in PowerShell 4.0.

voor loop

defor loop wordt veel gebruikt in de meeste andere talen, maar je ziet het niet veel in PowerShell. Als je het ziet, is het vaak in de context van het lopen van een reeks.

for ( $index = 0; $index -lt $data.count; $index++){ "Item: " -f $data}

het eerste wat we doen is een $index initialiseren naar 0., Vervolgens voegen we de voorwaarde toe dat $index kleiner moet zijn dan $data.count. Tenslotte specificeren we dat elke keer als we lus dat me de index moet verhogen met 1. In dit geval is $index++ de afkorting van $index = $index + 1.

wanneer u een for lus gebruikt, let dan speciaal op de voorwaarde. Ik heb hier$index -lt $data.count gebruikt. Het is gemakkelijk om de conditie enigszins verkeerd te krijgen om een off-by-oneerror in je logica te krijgen., Het gebruik van $index -le $data.count of $index -lt ($data.count - 1) zijn altijd duidelijk verkeerd. Dat zou ervoor zorgen dat uw resultaat te veel of te weinig items te verwerken. Dit is de klassieke fout.

Switch loop

Dit is er een die gemakkelijk over het hoofd te zien is. Als u een array geeft aan een switch statement, controleert het elk item in de array.

$data = 'Zero','One','Two','Three'switch( $data ){ 'One' { 'Tock' } 'Three' { 'Tock' } Default { 'Tick' }}

TickTockTickTock

Er zijn veel coole dingen die we kunnen doen met het switch statement. Ik heb hier nog een artikel aan gewijd.,

• alles wat u ooit wilde weten over het switch statement

waarden bijwerken

wanneer uw array een verzameling van tekenreeksen of gehele getallen (waardetypen) is, Wilt u soms de waarden in de array toupdateren als u ze doorloopt. De meeste lussen hierboven gebruiken een variabele in theloop die een kopie van de waarde bevat. Als je die variabele bijwerkt, wordt de oorspronkelijke waarde in de array niet bijgewerkt.

De uitzondering op dat statement is de for lus., Als je een array wilt lopen en waarden wilt bijwerken, dan is de for lus waar je naar op zoek bent.

for ( $index = 0; $index -lt $data.count; $index++ ){ $data = "Item: " -f $data}

dit voorbeeld neemt een waarde per index, maakt een paar wijzigingen, en gebruikt dan dezelfde index om terug te wijzen.

Arrays van objecten

tot nu toe is het enige wat we in een array hebben geplaatst een waardetype, maar arrays kunnen ook objecten bevatten.

$data = @( @{FirstName='Kevin';LastName='Marquette'} @{FirstName='John'; LastName='Doe'})

veel cmdlets retourneren collecties van objecten als arrays wanneer u ze toewijst aan een variabele.,

$processList = Get-Process

alle basisfuncties waar we het al over hadden, zijn nog steeds van toepassing op arrays van objecten met een paar details die het waard zijn om op te wijzen.

toegang tot eigenschappen

we kunnen een index gebruiken om toegang te krijgen tot een individueel item in een verzameling, net als met waarde types.

PS> $dataFirstName LastName----- ----Kevin Marquette

We kunnen eigenschappen direct benaderen en bijwerken.,

PS> $data.FirstNameKevinPS> $data.FirstName = 'Jay'PS> $dataFirstName LastName----- ----Jay Marquette

Array-eigenschappen

normaal zou u de hele lijst op deze manier moeten opsommen om toegang te krijgen tot alle eigenschappen:

PS> $data | ForEach-Object {$_.LastName}MarquetteDoe

of met behulp van de Select-Object -ExpandProperty cmdlet.

PS> $data | Select-Object -ExpandProperty LastNameMarquetteDoe

maar PowerShell biedt ons de mogelijkheid om LastName direct aan te vragen. PowerShell somt alles voor ons op en geeft een schone lijst terug.

PS> $data.LastNameMarquetteDoe

de opsomming gebeurt nog steeds, maar we zien de complexiteit er niet achter.,

waar-Object filtering

Hier komt Where-Object zodat we kunnen filteren en selecteren wat we willen uit de array gebaseerd op de eigenschappen van het object.

PS> $data | Where-Object {$_.FirstName -eq 'Kevin'}FirstName LastName----- ----Kevin Marquette

We kunnen dezelfde query schrijven om de FirstName te krijgen die we zoeken.

$data | Where FirstName -eq Kevin

waarbij()

Arrays een Where() methode hebben waarmee u een scriptblock Voor het filter kunt specificeren.

$data.Where({$_.FirstName -eq 'Kevin'})

Deze functie is toegevoegd in PowerShell 4.0.,

objecten in lussen bijwerken

met waardetypen is de enige manier om de array bij te werken door een for-lus te gebruiken omdat we de index moeten kennen om de waarde te vervangen. We hebben meer opties met objecten omdat ze referentietypen zijn. Hier is een snel voorbeeld:

foreach($person in $data){ $person.FirstName = 'Kevin'}

deze lus loopt elk object in de $data array. Omdat objecten referentietypen zijn, verwijst de variabele$person naar exact hetzelfde object dat zich in de array bevindt. Dus updates voor haarproperties updaten het origineel.,

u kunt nog steeds niet het hele object op deze manier vervangen. Als u probeert een nieuw object toe te wijzen aan de variabele$person, werkt u de variabele referentie bij naar iets anders dat niet meer wijst naar het oorspronkelijke object in de array. Dit werkt niet zoals je zou verwachten:

foreach($person in $data){ $person = @{ FirstName='Kevin' LastName='Marquette' }}

Operators

de operators in PowerShell werken ook op arrays. Sommige werken iets anders.

– join

de-join operator is de meest voor de hand liggende dus laten we het eerst bekijken., Ik hou van de-joinoperator en gebruik het vaak. Het voegt alle elementen in de array samen met het teken of de tekenreeks die u opgeeft.

PS> $data = @(1,2,3,4)PS> $data -join '-'1-2-3-4PS> $data -join ','1,2,3,4

een van de functies die ik leuk vind aan de -join operator is dat het enkele items afhandelt.

PS> 1 -join '-'1

Ik gebruik dit in logging en uitgebreide berichten.

PS> $data = @(1,2,3,4)PS> "Data is $($data -join ',')."Data is 1,2,3,4.

-join $array

Hier is een slimme truc die Lee Dailey me wees., Als u ooit alles wilt samenvoegen zonder een scheidingsteken, in plaats van dit te doen:

PS> $data = @(1,2,3,4)PS> $data -join $null1234

kunt u -join gebruiken met de array als de parameter zonder voorvoegsel. Kijk eens naar dit voorbeeld om te zien waar ik het over heb.

PS> $data = @(1,2,3,4)PS> -join $data1234

-vervang en splits

de andere operators zoals -replace en -split voeren uit op elk item in de array. Ik kan niet zeggen dat ik ze ooit op deze manier heb gebruikt, maar hier is een voorbeeld.,

PS> $data = @('ATX-SQL-01','ATX-SQL-02','ATX-SQL-03')PS> $data -replace 'ATX','LAX'LAX-SQL-01LAX-SQL-02LAX-SQL-03

-bevat

met de operator -contains kunt u een reeks waarden controleren om te zien of deze een specifieke waarde bevat.

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

-in

wanneer u een enkele waarde hebt waarvan u wilt controleren of deze overeenkomt met een van de verschillende waarden, kunt u de operator -in gebruiken. De waarde zou aan de linkerkant en de array aan de rechterkant van de operator.

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

Dit kan duur worden als de lijst groot is. Ik gebruik vaak een regex patroon als ik ben het controleren van meer thana paar waarden.,

PS> $data = @('red','green','blue')PS> $pattern = "^({0})$" -f ($data -join '|')PS> $pattern^(red|green|blue)$PS> 'green' -match $patternTrue

-eq en-ne

gelijkheid en arrays kunnen ingewikkeld worden. Wanneer de array aan de linkerkant staat, wordt elk item vergeleken. In plaats van True terug te geven, geeft het het object terug dat overeenkomt.

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

wanneer u de operator -ne gebruikt, krijgen we alle waarden die niet gelijk zijn aan onze waarde.

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

wanneer u dit gebruikt in een if() statement, is een waarde die wordt geretourneerd een True waarde., Als er geen waarde wordt geretourneerd, dan is het een False waarde. Beide volgende statements evalueren naar True.

$data = @('red','green','blue')if ( $data -eq 'green' ){ 'Green was found'}if ( $data -ne 'green' ){ 'And green was not found'}

Ik zal dit opnieuw bespreken in een moment wanneer we praten over het testen voor $null.

– match

de operator -match probeert elk item uit de verzameling te matchen.

PS> $servers = @( 'LAX-SQL-01' 'LAX-API-01' 'ATX-SQL-01' 'ATX-API-01')PS> $servers -match 'SQL'LAX-SQL-01ATX-SQL-01

wanneer u -match gebruikt met een enkele waarde, wordt een speciale variabele $Matches ingevuld met matchinfo., Dit is niet het geval wanneer een array op deze manier wordt verwerkt.

We kunnen dezelfde aanpak volgen met Select-String.

$servers | Select-String SQL

Ik neem een nadere blik op Select-String,-match en de $matches variabele in een ander bericht noemde de vele manieren om regex te gebruiken.

$null of leeg

testen voor $null of lege arrays kunnen lastig zijn. Hier zijn de Algemene vallen met arrays.

in één oogopslag ziet het ernaar uit dat dit statement zou moeten werken.,

if ( $array -eq $null){ 'Array is $null'}

maar ik heb net besproken hoe -eq elk item in de array controleert. Dus we kunnen een array van verschillende items hebben met een enkele $ null waarde en het zou evalueren naar $true

$array = @('one',$null,'three')if ( $array -eq $null){ 'I think Array is $null, but I would be wrong'}

daarom is het een beste praktijk om de $null aan de linkerkant van de operator te plaatsen. Dit maakt dit scenario een non-issue.

if ( $null -eq $array ){ 'Array actually is $null'}

A $null array is niet hetzelfde als een lege array. Als je weet dat je een array hebt, controleer dan het aantal objecten erin., Als de array $null is, is de count 0.

if ( $array.count -gt 0 ){ "Array isn't empty"}

Er is nog een val om op te letten. U kunt count gebruiken, zelfs als u een enkelobject hebt, tenzij dat object een PSCustomObjectis. Dit is een bug die is opgelost in PowerShell 6.1.Dat is goed nieuws, maar veel mensen zijn nog steeds op 5.1 en moeten uitkijken.

PS> $object = @{Name='TestObject'}PS> $object.count$null

Als u nog steeds PowerShell 5.1 gebruikt, kunt u het object in een array wikkelen voordat u de telling controleert om een nauwkeurige telling te geven.,

if ( @($array).count -gt 0 ){ "Array isn't empty"}

om het volledig veilig af te spelen, controleer op $null, controleer dan het aantal.

if ( $null -ne $array -and @($array).count -gt 0 ){ "Array isn't empty"}

All-eq

onlangs zag ik iemand vragen hoe te verifiëren dat elke waarde in een array overeenkomt met een bepaalde waarde.Reddit user / u / bis had deze slimme oplossing die controleert op eventuele onjuiste waarden en vervolgens het resultaat flips.

$results = Test-Somethingif ( -not ( $results -ne 'Passed') ){ 'All results a Passed'}

toevoegen aan arrays

Op dit punt begint u zich af te vragen hoe u items aan een array kunt toevoegen. Het snelle antwoord is dat je niet kunt. een array is een vaste grootte in het geheugen., Als u het wilt laten groeien of er een enkel item aan wilt toevoegen, dan moet u een nieuwe array maken en alle waarden uit de oude array kopiëren. Dit klinkt als veel werk, echter, PowerShell verbergt de complexiteit van het maken van de nieuwe array. Powershellimplementeert de additie-operator (+) voor arrays.

Array additie

We kunnen de additie operator met arrays gebruiken om een nieuwe array te maken. Dus gegeven deze twee arrays:

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

kunnen we ze samenvoegen om een nieuwe array te krijgen.

PS> $first + $secondZeroOneTwoThree

Plus is gelijk aan +=

we kunnen een nieuwe array aanmaken en er een item aan toevoegen als volgt:

$data = @( 'Zero' 'One' 'Two' 'Three')$data += 'four'

onthoud dat elke keer dat u += dupliceert en een nieuwe array maakt. Dit is geen probleem voor kleine datasets, maar het schaalt extreem slecht.,

Pipeline toewijzing

u kunt de resultaten van elke pipeline toewijzen aan een variabele. Het is een array als het multipleitems bevat.

$array = 1..5 | ForEach-Object { "ATX-SQL-$PSItem"}

normaal gesproken als we denken aan het gebruik van de pijplijn, denken we aan de typische PowerShell one-liners. We kunnen de pijplijn vergelijken met foreach() statements en andere loops. Dus in plaats van items toe te voegen aan anarray in een lus, kunnen we items laten vallen op de pijplijn.

$array = foreach ( $node in (1..5)){ "ATX-SQL-$node"}

Array Types

standaard wordt een array in PowerShell aangemaakt als een ] type., Hierdoor kan het elk type object of waarde bevatten. Dit werkt omdat alles overgenomen is van het PSObject type.

sterk getypte arrays

u kunt een array van elk type maken met behulp van een soortgelijke syntaxis. Wanneer u een sterk getypte array maakt,kan deze alleen waarden of objecten van het opgegeven type bevatten.

ArrayList

het toevoegen van items aan een array is een van de grootste beperkingen, maar er zijn een paar andere collections die we kunnen gebruiken om dit probleem op te lossen.,

de ArrayList is gewoonlijk een van de eerste dingen die we bedenken wanneer we een array nodig hebben waarmee isfaster kan werken. Het werkt als een object array elke plaats die we nodig hebben, maar het behandelt addingitems snel.

Hier is hoe we een ArrayList aanmaken en er items aan toevoegen.

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

We roepen. net op om dit type te krijgen. In dit geval gebruiken we de standaard constructor om het te maken. Dan noemen we de Add methode om een item toe te voegen.,

de reden dat ik aan het begin van de regel gebruik is om de return code te onderdrukken. Some.NET oproepen doen dit en kunnen onverwachte output creëren.

als de enige gegevens die je in je array hebt strings zijn, kijk dan ook eens naar usingStringBuilder. Het is bijna hetzelfde, maar heeft een aantal methoden die alleen voor het omgaan metstrings. De StringBuilder is speciaal ontworpen voor prestaties.

Het is gebruikelijk om mensen vanuit arrays naar ArrayList te zien gaan. Maar het komt uit een tijd waar C# geen generieke ondersteuning had., De ArrayList is verouderd ter ondersteuning van de generieke List

Generieke lijst

een generiek type is een speciaal type in C# dat een gegeneraliseerde klasse definieert en de gebruiker specificeert de gegevenstypen die het gebruikt wanneer het wordt aangemaakt. Dus als je een lijst met getallen of tekenreeksen wilt, definieer je dat je een lijst wilt met int of string types.

Hier is hoe u een lijst voor tekenreeksen maakt.

$mylist = ]::new()

of een lijst voor getallen.,

$mylist = ]::new()

We kunnen een bestaande array naar een lijst als deze casten zonder eerst het object aan te maken:

$mylist = ]@(1,2,3)

We kunnen de syntaxis inkorten met het using namespace statement in PowerShell 5 en nieuwer. Hetusing statement moet de eerste regel van je script zijn. Door het declareren van een naamruimte, PowerShelllets je laat het uit van de gegevenstypen wanneer u ze verwijzen.

using namespace System.Collections.Generic$myList = ]@(1,2,3)

Dit maakt de List veel bruikbaarder.,

u beschikt over een vergelijkbare Add methode. In tegenstelling tot de ArrayList is er geen retourwaarde op de Add methode, dus we hoeven niet void it.

$myList.Add(10)

en we kunnen nog steeds toegang krijgen tot de elementen zoals andere arrays.

PS> $myList10

List

U kunt een lijst van elk type hebben, maar als u het type objecten niet kent, kunt u] gebruiken om ze te bevatten.,

$list = ]::new()

Remove()

de ArrayList en de generieke List ondersteunen beide het verwijderen van items uit de collectie.

using namespace System.Collections.Generic$myList = ]@('Zero','One','Two','Three')$myList.Remove("Two")ZeroOneThree

bij het werken met waarde types, verwijdert het de eerste uit de lijst. Je kunt het steeds opnieuw noemen om die waarde te blijven verwijderen. Als u referentietypen hebt, moet u het object opgeven dat u wilt verwijderen.,

]$drives = Get-PSDrive$drives.remove($drives)

$delete = $drives$drives.remove($delete)

De verwijdermethode geeft true terug als het item uit de collectie kon vinden en verwijderen.

meer collecties

er zijn veel andere collecties die gebruikt kunnen worden, maar dit zijn de goede generic array replacements.Als u geïnteresseerd bent in het leren over meer van deze opties, neem een kijkje op thisGist thatMark Kraus samen.

andere nuances

nu ik alle belangrijke functionaliteit heb behandeld, zijn hier nog een paar dingen die ik wilde opmerken voordat ik dit afrond.,

Pre-sized arrays

Ik zei dat je de grootte van een array niet kunt veranderen zodra deze is aangemaakt. We kunnen een array van een vooraf bepaalde grootte maken door het aan te roepen met de new($size) constructor.

$data = ]::new(4)$data.count4

vermenigvuldig arrays

een interessant trucje is dat je een array kunt vermenigvuldigen met een geheel getal.

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

initialiseren met 0

een algemeen scenario is dat u een array met alle nullen wilt maken. Als je alleen naar hebeintegers gaat, staat een sterk getypte array van gehele getallen standaard op alle nullen.,

PS> ]::new(4)0000

We kunnen de vermenigvuldigingstruc ook gebruiken om dit te doen.

PS> $data = @(0) * 4PS> $data0000

Het leuke aan de vermenigvuldigingstruc is dat je elke waarde kunt gebruiken. Dus als je 255 als standaardwaarde zou hebben, zou dit een goede manier zijn om het te doen.

PS> $data = @(255) * 4PS> $data255255255255

geneste arrays

een array binnen een array wordt een geneste array genoemd. Ik gebruik deze niet veel in PowerShell, maar ik heb ze meer in andere talen gebruikt. Overweeg om een array van arrays te gebruiken wanneer uw gegevens in een rasterachtig patroon passen.,

hier zijn twee manieren waarop we een tweedimensionale array kunnen maken.

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

de komma is erg belangrijk in deze voorbeelden. Ik gaf een eerder voorbeeld van een normale array op meerdere regels waar de komma optioneel was. Dat is niet het geval met een multidimensionale array.

de manier waarop we de index notatie gebruiken verandert iets nu we een geneste array hebben. Met behulp van de$data hierboven, is dit hoe we de waarde 3 zouden benaderen.

PS> $outside = 0PS> $inside = 2PS> $data3

voeg een haakje toe voor elk niveau van array-nesting., De eerste set van haakjes is voor de buitenste array en dan werk je je weg naar binnen vanaf daar.

Write-Output-NoEnumerate

PowerShell wil arrays uitpakken of opsommen. Dit is een kernaspect van de manier waarop PowerShell thepipeline gebruikt, maar er zijn momenten dat je niet wilt dat dat gebeurt.

i gewoonlijk pipe objecten naar Get-Member voor meer informatie over hen. Als ik er een array naar pijp, wordt het uitgepakt en krijgt-lid ziet de leden van de array en niet de werkelijke array.,

PS> $data = @('red','green','blue')PS> $data | Get-MemberTypeName: System.String...

om dat uitpakken van de array te voorkomen, kunt u Write-Object -NoEnumerategebruiken.

PS> Write-Output -NoEnumerate $data | Get-MemberTypeName: System.Object...

Ik heb een tweede manier die meer een hack is (en ik probeer hacks als deze te vermijden). Je kunt acomma voor de array plaatsen voordat je het pijpt.

PS> ,$data | Get-MemberTypeName: System.Object...

retourneer een array

Dit uitpakken van arrays gebeurt ook wanneer u waarden uit een functie uitvoert of retourneert. Je kunt nog steeds een array krijgen als je de uitvoer toewijst aan een variabele, dus dit is meestal geen probleem.

De vangst is dat je een nieuwe array hebt., Als dat ooit een probleem is, kunt uWrite-Output -NoEnumerate $array of return ,$array gebruiken om er omheen te werken.

nog iets?