Arrays zijn een fundamenteel kenmerk van de meeste programmeertalen. Ze zijn een verzameling van waarden of objecten en zijn daarom moeilijk te vermijden. Laten we eens een kijkje nemen op arrays en alles wat ze te bieden hebben.
Paginaindex
Wat is een array?,match
$null of leeg
Alle -eq
toe te Voegen aan arrays
Array toevoeging
Plus is gelijk aan +=
Pijplijn toewijzing
Array Types
Sterk getypeerde arrays
ArrayList
Algemene Lijst
Lijst
Verwijderen()
Meer collecties
Andere nuances
Pre-formaat arrays
het Vermenigvuldigen van matrices
Initialiseren met 0
Geneste matrices
Schrijven-Output -NoEnumerate
retourneert een array
Iets anders?,
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 krijgen tot afzonderlijke items met behulp van een index. De array wordt gemaakt als een opeenvolgend stuk geheugen waar elke waarde naast de andere wordt opgeslagen.
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 met @()
een lege array kan worden aangemaakt met @()
PS> $data = @() PS> $data.count 0
We kunnen een array maken en deze met waarden beginnen door ze in de haakjes.
PS> $data = @('Zero','One','Two','Three') PS> $data.count 4 PS> $data Zero One Two Three
deze array heeft 4 items. Als we de $data variabele aanroepen, zien we de lijst met onze items., Als het een array van strings is, dan hebben we één regel per string.
we kunnen een array Declareren op meerdere regels. De komma is in dit geval optioneel en meestal weggelaten.
$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 als je meerdere items hebt, het maakt het ook makkelijker om te vergelijken met eerdere versies bij het gebruik van Broncontrole.,
andere syntaxis
algemeen wordt aangenomen 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-Outputkunt gebruiken om snel tekenreeksen aan te maken op de console.
$data = Write-Output Zero One Two Three
Dit is handig omdat u geen aanhalingstekens rond de tekenreeksen hoeft te plaatsen wanneer de parameter tekenreeksen 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> $data Zero
de reden waarom we hier nul gebruiken is omdat het eerste item aan het begin van de lijst staat, dus we gebruiken een offset van 0 items om er bij te komen., Om bij het tweede item te komen, moeten we een offset van 1 gebruiken om het eerste item over te slaan.
PS> $data One
Dit zou betekenen dat het laatste item op verschuiving 3 staat.
PS> $data Three
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. Een index 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 aan te bieden, kunnen we verschillende items selecteren.
PS> $data Zero Two Three
de items zullen worden geretourneerd op basis van de volgorde van de verstrekte indexen. Als u een index dupliceert, krijgt u dat item beide keren.,
PS> $data Three Zero Three
We kunnen een reeks getallen specificeren met de ingebouwde ..operator.
PS> $data One Two Three
Dit werkt ook in omgekeerde richting.
PS> $data Three Two One
u kunt negitieve indexwaarden gebruiken om van het einde af te wijken. Dus als je het laatste item in de lijst nodig hebt, kun je -1gebruiken.,
PS> $data Three
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 je in stilte niets.
PS> $null -eq $data True
kan niet indexeren in een null array
als uw variabele $null en u probeert deze te indexeren als een array, krijgt u een System.Management.Automation.RuntimeException uitzondering met het bericht Cannot index into a null array.,
PS> $empty = $null SP> $empty Error: Cannot index into a null array.
dus zorg ervoor dat uw arrays niet $null 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.count 4
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-Date PS> $date.count 1
Even $nullheeft een count-eigenschap, behalve dat het0geeft.
PS> $null.count 0
er zijn enkele traps hier die Ik zal opnieuw bekijken wanneer ik dekking controle voor $null of lege arrays later in dit artikel.
uitgeschakeld door één fout
een veelvoorkomende programmeerfout wordt gemaakt omdat arrays beginnen bij index 0. Een uit door één fout kan op twee veel voorkomende 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 4 items hebt en je wilt het laatste item, dus gebruik je gewoon de grootte om toegang te krijgen 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> $data Three
Hier kunt u de -1 index gebruiken om het laatste element te verkrijgen.
PS> $data Three
Lee Dailey wees me er ook op dat we$data.GetUpperBound(0) kunnen gebruiken om het maximale indexnummer te krijgen.
PS> $data.GetUpperBound(0) Three
de tweede meest voorkomende manier is wanneer de lijst wordt herhaald en niet op het juiste moment wordt gestopt. Ik zal dit opnieuw bekijken 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 tot individuele items bij te werken.
$data = 'dos' $data = 'tres'
als we een item proberen bij te werken dat voorbij het laatste element is, dan krijgen we een Index 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 de hele lijst lopen of herhalen en een 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 over deze waarden te verwerken. Wanneer u een array doorgeeft aan een pijplijn, wordt elk item in de array afzonderlijk verwerkt.
als u $PSItemniet eerder hebt gezien, weet dan dat het hetzelfde is als$_. U kunt een van beide gebruiken omdat ze beide het huidige object in de pijplijn vertegenwoordigen.,
ForEach loop
deForEach loop werkt goed met Collecties. Gebruik 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() aanroepen op een verzameling.
PS> $data.foreach({"Item "}) Item Item Item Item
de .foreach() neemt een parameter die een scriptblok is. U kunt de haakjes laten vallen en gewoon het script blok.,
$data.foreach{"Item "}
Dit is een minder bekende syntaxis, maar het werkt precies hetzelfde. Dezeforeach methode is 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 array.
het eerste wat we doen is een $index naar 0initialiseren., Vervolgens voegen we de voorwaarde toe dat $index kleiner moet zijn dan $data.count. Tot slot 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, besteed dan speciale aandacht aan de voorwaarde. Ik heb hier $index -lt $data.count gebruikt. Het is heel gemakkelijk om de conditie enigszins verkeerd te krijgen om een off door één fout in uw logica te krijgen., Het gebruik van $index -le $data.count of $index -lt ($data.count - 1) zijn enigszins verkeerd. Dat zou ervoor zorgen dat uw resultaat te veel of te weinig items te verwerken. Dit is de klassieker uit door een fout.
Switch loop
Dit is er een die heel gemakkelijk over het hoofd te zien is. Als u een array geeft aan een switch statement, zal deze overeenkomen met elk item in de array.
Er zijn veel coole dingen zoals deze die we kunnen doen met het switch statement., Ik heb nog een artikel gewijd aan dit.
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 bijwerken terwijl u ze doorloopt. De meeste lussen hierboven gebruiken een variabele in de lus die een kopie van de waarde bevat. Als u die variabele bijwerkt, wordt de oorspronkelijke waarde in de array niet bijgewerkt.
De uitzondering op dat statement is de lus for., Als u een array wilt lopen en waarden erin wilt bijwerken, dan is de for lus waarnaar u op zoek bent.
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 vermelden waard zijn.
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> $data FirstName LastName ----- ---- Kevin Marquette
We kunnen eigenschappen direct benaderen en bijwerken.,
PS> $data.FirstName Kevin PS> $data.FirstName = 'Jay' PS> $data FirstName 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} Marquette Doe
of door gebruik te maken van de Select-Object -ExpandPropertycmdlet.
PS> $data | Select-Object -ExpandProperty LastName Marquette Doe
maar PowerShell biedt ons de mogelijkheid om LastName direct aan te vragen. PowerShell zal ze allemaal voor ons opsommen en ons een schone lijst geven.,
PS> $data.LastName Marquette Doe
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 op basis van de eigenschappen van het object.
We kunnen dezelfde query als deze schrijven om de FirstNamete krijgen die we zoeken.,
$data | Where FirstName -eq Kevin
waarbij ()
Arrays een Where()methode hebben waarmee u eenscriptblockVoor het filter kunt specificeren.
$data.Where({$_.FirstName -eq 'Kevin'})
Deze functie is toegevoegd in PowerShell 4.0.
objecten in lussen bijwerken
Met value types is de enige manier om de array bij te werken door een for loop te gebruiken omdat we de index moeten weten 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 $dataarray. Omdat objecten referentietypen zijn, verwijst de variabele $person naar exact hetzelfde object dat in de array zit. Dus updates aan zijn eigenschappen zal het origineel bijwerken.
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 naar het oorspronkelijke object in de array wijst., Dit zal niet werken zoals u zou verwachten:
de operators in PowerShell werken ook op arrays. Sommige werken iets anders.
– join
de-join operator is de meest voor de hand liggende, dus we zullen het eerst bekijken. Ik hou van de-join operator en gebruik het vaak. Het zal alle elementen in de array samenvoegen met een teken of tekenreeks die u opgeeft.,
een van de functies die ik leuk vind aan de -joinis 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 zonder scheidingsteken wilt samenvoegen, in plaats van dit te doen:
PS> $data = @(1,2,3,4) PS> $data -join $null 1234
kunt u -joingebruiken met de array als parameter zonder prefix. Kijk eens naar dit voorbeeld om te zien waar ik het over heb.
PS> $data = @(1,2,3,4) PS> -join $data 1234
-replace and-split
de andere operators zoals -replace en -split zullen op elk item in de array worden uitgevoerd. Ik kan niet zeggen dat ik ze ooit op deze manier heb gebruikt, maar hier is een voorbeeld.,
wanneer u een enkele waarde hebt die u wilt verifiëren of 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 operatie.,
gelijkheid en arrays kunnen ingewikkeld worden. Wanneer de array aan de linkerkant staat, wordt elk item vergeleken. In plaats van True terug te geven, zal het object dat overeenkomt worden geretourneerd.,
PS> $data = @('red','green','blue') PS> $data -eq 'green' green
wanneer u de operator -negebruikt, krijgen we alle waarden die niet gelijk zijn aan onze waarde.
PS> $data = @('red','green','blue') PS> $data -ne 'green' red blue
wanneer u dit gebruikt in een if()statement, is een waarde die wordt geretourneerd eenTruewaarde. Als er geen waarde wordt geretourneerd, is het een False waarde. Beide volgende statements zullen evalueren naar True.,
$data = @('red','green','blue') if ( $data -eq 'green' ) { 'Green was found' } if ( $data -ne 'green' ) { 'And green was not found' }
Ik kom hier zo nog op terug als we het hebben over testen voor $null.
– match
de operator -match zal proberen elk item in de verzameling te matchen.
wanneer u -matchgebruikt met een enkele waarde, wordt een speciale variabele$Matchesgevuld met match info. 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,-matchen de$matchesvariabele in een ander bericht genaamd 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 $nullarray 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, zal de telling 0zijn.
if ( $array.count -gt 0 ) { 'Array is not empty' }
Er is nog een val om op te letten. U kunt count gebruiken, zelfs als u een enkel object 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.
Als u nog steeds op PowerShell 5 zit.,1, U kunt het object in een array wikkelen voordat u de telling controleert om een nauwkeurige telling te krijgen.
if ( @($array).count -gt 0 ) { 'Array is not empty' }
om het geheel veilig af te spelen, controleer op $null, controleer dan het aantal.
if ( $null -ne $array -and @($array).count -gt 0 ) { 'Array is not empty' }
All-eq
Ik zag onlangs 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 omdraait.,
$results = Test-Something if ( -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 je het moet laten groeien of er een enkel item aan moet toevoegen, dan moet je een nieuwe array maken en alle waarden uit de oude array kopiëren. Dit klinkt duur en als veel werk, echter, PowerShell verbergt de complexiteit van het maken van de nieuwe array.
Array additie
We kunnen de additie operator met arrays gebruiken om een nieuwe array te maken., Dus gegeven deze twee arrays:
normaal gesproken als we denken aan het gebruik van de pijplijn, denken we aan de typische PowerShell one-liners. We kunnen de pijplijn gebruiken met foreach() statements en andere loops. Dus in plaats van items toe te voegen aan een array in een lus, kunnen we items op de pijplijn laten vallen.,
$array = foreach ( $node in (1..5)) { "ATX-SQL-$node" }
door de resultaten van de foreachtoe te wijzen aan een variabele, vangen we alle objecten en maken we een enkele array.
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 collecties 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 die sneller is om mee te werken. Het werkt als een object array elke plaats die we nodig hebben, maar het behandelt het toevoegen van items snel.
Hier is hoe we een ArrayList aanmaken en er items aan toevoegen.,
$myarray = ::new() $myArray.Add('Value')
We roepen.net aan om dit type te verkrijgen. In dit geval gebruiken we de standaard constructor om het aan te maken. Dan noemen we de Add methode om er een item aan toe te voegen.
de reden dat ik aan het begin van de regel gebruik is om de return code te onderdrukken. Sommige. net-aanroepen doen dit en kunnen onverwachte uitvoer creëren.
als de enige data die je in je array hebt strings zijn, kijk dan ook eens naar het gebruik van StringBuilder., Het is bijna hetzelfde, maar heeft een aantal methoden die alleen voor het omgaan met snaren. De StringBuilder is speciaal ontworpen voor prestaties.
aaneengeschakelde Tekenreeksen met behulp van StringBuilder
Het is echt gebruikelijk om mensen vanuit arrays naar ArrayList te zien gaan. Maar het komt uit een tijd waarin C# geen generieke ondersteuning had., De ArrayList wordt afgeschreven 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 zal de gegevenstypen specificeren die het zal gebruiken wanneer het wordt aangemaakt. Dus als je een lijst met getallen of tekenreeksen wilt, zou je definiëren dat je een lijst wilt van int of string types.
Hier is hoe u een lijst voor tekenreeksen maakt.
$mylist = ]::new()
of een lijst met getallen.,
$mylist = ]::new()
We kunnen een bestaande array naar een lijst als deze casten zonder het object eerst aan te maken:
$mylist = ]@(1,2,3)
We kunnen de syntaxis een beetje inkorten met de using namespacestatement in PowerShell 5 en nieuwer. Hetusing statement moet de eerste regel van je script zijn. Door een naamruimte te declareren, laat PowerShell je het van de datatypes afhouden wanneer je ze refereert.,
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 return waarde op de Add methode, dus we hoeven niet void it.
$myList.Add(10)
en we hebben nog steeds toegang tot de elementen zoals andere arrays.,
PS> $myList 10
lijst
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 ArrayListen de generiekeListondersteunen beide het verwijderen van items uit de collectie.
using namespace System.Collections.Generic $myList = ]@('Zero','One','Two','Three') $myList.Remove("Two") Zero One Three
wanneer met waardetypen wordt gewerkt, zal het de eerste uit de lijst verwijderen., Je kunt het keer op keer bellen 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 in staat was het item uit de verzameling te vinden en te 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 deze Gist die Mark Kraus samen te stellen.
andere nuances
nu ik alle belangrijke functionaliteit heb behandeld, zijn hier nog een paar dingen die ik wilde vermelden voordat ik dit afrond.
Pre-sized arrays
Ik zei dat je de grootte van een array niet kunt veranderen zodra deze is gemaakt. We kunnen een array van een vooraf bepaalde grootte maken door het aan te roepen met de new($size) constructor.,
$data = ]::new(4) $data.count 4
vermenigvuldig arrays
een interessant trucje is dat je een array kunt vermenigvuldigen met een geheel getal.
PS> $data = @('red','green','blue') PS> $data * 3 red green blue red green blue red green blue
initialiseren met 0
een algemeen scenario is dat u een array met alle nullen wilt maken. Als je alleen gehele getallen zult hebben, zal een sterk getypte array van gehele getallen standaard op alle nullen staan.
PS> ]::new(4) 0 0 0 0
We kunnen de vermenigvuldigingstruc ook gebruiken om dit te doen.,
PS> $data = @(0) * 4 PS> $data 0 0 0 0
het mooie aan de vermenigvuldigingstruc is dat je elke waarde kunt gebruiken. Dus als je liever 255 als standaard waarde hebt, zou dit een goede manier zijn om het te doen.
PS> $data = @(255) * 4 PS> $data 255 255 255 255
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 2 dimensionale array kunnen maken.,
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 = 0 PS> $inside = 2 PS> $data 3
voeg een haakje toe voor elk niveau van array-nesting., De eerste set van haakjes is voor de buitenste meest 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 de pijplijn 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 buig, wordt het uitgepakt en Get-Member ziet de leden van de array en niet de werkelijke array.,
Ik heb een tweede manier om dit te doen die meer een hack is (en ik probeer hacks als deze te vermijden). Je kunt een komma voor de array plaatsen voordat je hem pijpt.
deze verwijdering van arrays vindt ook plaats 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 u een nieuwe array zult hebben. Als dat ooit een probleem is, kunt u Write-Output -NoEnumerate $array of return ,$array gebruiken om er omheen te werken.
nog iets?
Ik weet dat dit allemaal veel is om te verwerken. Mijn hoop is dat je iets leert van dit artikel elke keer dat je het leest en dat het zal blijken te zijn een goede referentie voor u voor een lange tijd te komen., Als je dit nuttig vond, deel het dan met anderen waarvan je denkt dat ze er waarde uit zullen halen.
vanaf hier zou ik je aanraden een vergelijkbaar bericht te bekijken dat ik schreef over hashtables.