Tutto quello che avreste voluto sapere su array

• 10/08/2020
• 24 minuti per leggere
• • j
  • h
  • 
  • V

Array sono una fondamentale caratteristica del linguaggio della maggior parte dei linguaggi di programmazione. Sono una raccolta di valori o oggetti difficili da evitare. Diamo un’occhiata da vicino agli array e a tutto ciò che hanno da offrire.,

Che cos’è un array?

Inizierò con una descrizione tecnica di base di quali sono gli array e come vengono utilizzati dalla maggior parte dei linguaggi di programmazione prima di passare agli altri modi in cui PowerShell ne fa uso.

Un array è una struttura dati che funge da raccolta di più elementi., È possibile iterare su thearray o accedere a singoli elementi utilizzando un indice. L’array viene creato come un blocco sequenziale ofmemory in cui ogni valore è memorizzato proprio accanto all’altro.

Toccherò ognuno di questi dettagli mentre andiamo.

Utilizzo di base

Poiché gli array sono una caratteristica di base di PowerShell, esiste una sintassi semplice per lavorare con loro in PowerShell.,

Crea un array

Un array vuoto può essere creato usando@()

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

Possiamo creare un array e seminare con i valori semplicemente mettendoli nel@() parentesi.

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

Questo array ha 4 elementi. Quando chiamiamo la variabile$data, vediamo l’elenco dei nostri articoli. Se è un anarray di stringhe, otteniamo una riga per stringa.

Possiamo dichiarare un array su più righe. La virgola è facoltativa in questo caso e generalmente lasciata fuori.,

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

Preferisco dichiarare i miei array su più righe in questo modo. Non solo diventa più facile da leggere quando si dispone di più elementi, ma rende anche più facile da confrontare con le versioni precedenti quando si utilizza sourcecontrol.

Altra sintassi

È comunemente inteso che@() è la sintassi per la creazione di un array, ma le liste separate da virgole funzionano la maggior parte del tempo.,

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

Write-Output per creare array

Un piccolo trucco interessante degno di nota è che è possibile utilizzare Write-Output per creare rapidamente stringhe nella console.

$data = Write-Output Zero One Two Three

Questo è utile perché non è necessario inserire virgolette attorno alle stringhe quando il parametro accettastringhe. Non lo farei mai in uno script, ma è un gioco equo nella console.

Accesso agli elementi

Ora che hai un array con elementi in esso, potresti voler accedere e aggiornare tali elementi.,

Offset

Per accedere ai singoli elementi, usiamo le parentesi con un valore di offset a partire da 0. Questo ècome otteniamo il primo elemento nel nostro array:

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

Il motivo per cui usiamo zero qui è perché il primo elemento è all’inizio della lista, quindi usiamoun offset di 0 elementi per arrivarci. Per arrivare al secondo elemento, avremmo bisogno di usare un offset di 1 toskip il primo elemento.

PS> $dataOne

Ciò significherebbe che l’ultimo elemento è all’offset 3.,

PS> $dataThree

Index

Ora puoi vedere perché ho scelto i valori che ho fatto per questo esempio. Ho introdotto questo come offsetperché è quello che è veramente, ma questo offset è più comunemente indicato come indice. Anindex che inizia da 0. Per il resto di questo articolo chiamerò l’offset un indice.

Trucchi indice speciale

Nella maggior parte delle lingue, è possibile specificare solo un singolo numero come indice e si ottiene un singolo elemento indietro.PowerShell è molto più flessibile. È possibile utilizzare più indici contemporaneamente., Fornendo un elenco diindici, possiamo selezionare diversi elementi.

PS> $dataZeroTwoThree

Gli articoli vengono restituiti in base all’ordine degli indici forniti. Se duplichi un indice, ottieni quell’elemento entrambe le volte.

PS> $dataThreeZeroThree

Possiamo specificare una sequenza di numeri con l’operatore.. incorporato.

PS> $dataOneTwoThree

Funziona anche al contrario.

PS> $dataThreeTwoOne

È possibile utilizzare valori di indice negativi per compensare dalla fine. Quindi, se hai bisogno dell’ultimo elemento nell’elenco,puoi usare -1.,

PS> $dataThree

Fuori dai limiti

Nella maggior parte delle lingue, se si tenta di accedere a un indice di un elemento che è oltre la fine dell’array, si otterrebbe un qualche tipo di errore o un’eccezione. PowerShell restituisce silenziosamente nulla.

PS> $null -eq $dataTrue

Non è possibile indicizzare in un array null

Se la variabile è $null e si tenta di indicizzarla come un array, si ottiene un’eccezioneSystem.Management.Automation.RuntimeException con il messaggioCannot index into a null array.,

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

Quindi assicurati che i tuoi array non siano $null prima di provare ad accedere agli elementi al loro interno.

Count

Gli array e le altre raccolte hanno una proprietà count che indica quanti elementi sono nell’array.

PS> $data.count4

PowerShell 3.0 ha aggiunto una proprietà count alla maggior parte degli oggetti. puoi avere un singolo oggetto e dovrebbe darti un conteggio di1.

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

Anche $nullha una proprietà count tranne che restituisce 0.,

PS> $null.count0

Ci sono alcune trappole qui che rivedrò quando coprirò il controllo di $null o array vuoti in questo articolo.

Errori off-by-one

Viene creato un errore di programmazione comune perché gli array iniziano dall’indice 0. Gli errori off-by-one possono essere introdotti in due modi.

Il primo è pensare mentalmente che si desidera il secondo elemento e utilizzare un indice di2 e ottenere davvero il terzo elemento. O pensando di avere quattro elementi e si desidera ultimo elemento, in modo da utilizzare il countto accedere all’ultimo elemento.,

$data

PowerShell è perfettamente felice di permetterti di farlo e di darti esattamente quale elemento esiste all’indice 4: $null. Dovresti usare $data.count - 1o-1 che abbiamo appreso sopra.

PS> $dataThree

Qui è possibile utilizzare l’indice-1 per ottenere l’ultimo elemento.

PS> $dataThree

Lee Dailey mi ha anche fatto notare che possiamo usare $data.GetUpperBound(0) per ottenere il numero massimo di indexnumber.,

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

Il secondo modo più comune è quando si itera l’elenco e non si ferma al momento giusto. Lo rivisiterò quando parliamo di utilizzare il ciclofor.

Aggiornamento degli elementi

Possiamo usare lo stesso indice per aggiornare gli elementi esistenti nell’array. Questo ci dà accesso diretto toupdate singoli elementi.

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

Se proviamo ad aggiornare un elemento che supera l’ultimo elemento, otteniamo un erroreIndex was outside the bounds of the array..

Lo rivisiterò più tardi quando parlerò di come ingrandire un array.,

Iterazione

Ad un certo punto, potrebbe essere necessario camminare o iterare l’intero elenco ed eseguire alcune azioni per eachitem nell’array.

Pipeline

Gli array e la pipeline PowerShell sono pensati l’uno per l’altro. Questo è uno dei modi più semplici perprocesso su quei valori. Quando si passa un array a una pipeline, ogni elemento all’interno dell’array viene elaborato individualmente.

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

Se non hai visto prima$PSItem, sappi che è la stessa cosa di$_., È possibile utilizzare eitherone perché entrambi rappresentano l’oggetto corrente nella pipeline.

Ciclo ForEach

Il cicloForEach funziona bene con le raccolte. Usando la sintassi: foreach ( <variable> in <collection> )

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

ForEach method

Tendo a dimenticarmi di questo ma funziona bene per operazioni semplici. PowerShell consente di chiamare .ForEach() su una raccolta.

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

Il.foreach() accetta un parametro che è un blocco di script., Puoi eliminare le parentesi e semplicementefornire il blocco di script.

$data.foreach{"Item "}

Questa è una sintassi meno conosciuta ma funziona allo stesso modo. Questo metodo foreach è stato aggiunto inPowerShell 4.0.

Per loop

Il for loop è usato pesantemente nella maggior parte delle altre lingue, ma non lo vedi molto in PowerShell. Quando lo vedi, è spesso nel contesto di camminare su un array.

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

La prima cosa che facciamo è inizializzare un$indexa0., Quindi aggiungiamo la condizione che$index deve essere inferiore a$data.count. Infine, specifichiamo che ogni volta che eseguiamo il loop che devo aumentare l’indice di 1. In questo caso $index++è l’abbreviazione di$index = $index + 1.

Ogni volta che si utilizza un ciclofor, prestare particolare attenzione alla condizione. Ho usato $index -lt $data.count qui. È facile ottenere la condizione leggermente sbagliata per ottenere un errore off-by-one nella tua logica., L’utilizzo di $index -le $data.count o $index -lt ($data.count - 1) è sempre leggermente sbagliato. Ciò causerebbe il risultato per elaborare troppi o troppo pochi elementi. Questo è il classico errore off-by-one.

Interruttore loop

Questo è uno che è facile da trascurare. Se si fornisce un array a un’istruzione switch, controlla ogni elemento nell’array.

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

TickTockTickTock

Ci sono molte cose interessanti che possiamo fare con l’istruzione switch. Ho un altro articolo dedicato a questo.,

• Tutto quello che avresti sempre voluto sapere sull’istruzione switch

Aggiornamento dei valori

Quando il tuo array è una raccolta di stringhe o numeri interi (tipi di valore), a volte potresti voler aggiungere i valori nell’array durante il ciclo su di essi. La maggior parte dei loop sopra utilizza una variabile in theloop che contiene una copia del valore. Se si aggiorna tale variabile, il valore originale nell’array non viene aggiornato.

L’eccezione a tale istruzione è il ciclofor., Se vuoi camminare su un array e aggiornare valuesinside it, allora il ciclo for è quello che stai cercando.

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

Questo esempio prende un valore per indice, apporta alcune modifiche e quindi utilizza lo stesso indice per assegnarlo.

Array di oggetti

Finora, l’unica cosa che abbiamo inserito in un array è un tipo di valore, ma gli array possono anche contenereoggetti.

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

Molti cmdlet restituiscono raccolte di oggetti come array quando li si assegna a una variabile.,

$processList = Get-Process

Tutte le funzionalità di base di cui abbiamo già parlato si applicano ancora agli array di oggetti con alcuni dettagli che vale la pena sottolineare.

Accesso alle proprietà

Possiamo usare un indice per accedere a un singolo elemento in una raccolta proprio come con i tipi di valore.

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

Possiamo accedere e aggiornare direttamente le proprietà.,

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

Proprietà array

Normalmente si dovrebbe enumerare l’intero elenco in questo modo per accedere a tutte le proprietà:

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

O utilizzando il Select-Object -ExpandProperty cmdlet.

PS> $data | Select-Object -ExpandProperty LastNameMarquetteDoe

Ma PowerShell ci offre la possibilità di richiedere LastName direttamente. PowerShell enumera themall per noi e restituisce un elenco pulito.

PS> $data.LastNameMarquetteDoe

L’enumerazione avviene ancora ma non vediamo la complessità dietro di essa.,

Where-Object filtering

Questo è doveWhere-Object entra in modo da poter filtrare e selezionare ciò che vogliamo dall’arraybased sulle proprietà dell’oggetto.

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

Possiamo scrivere la stessa query per ottenere ilFirstName che stiamo cercando.

$data | Where FirstName -eq Kevin

Dove ()

Gli array hanno un Where()metodo su di essi che consente di specificare un scriptblock per il filtro.

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

Questa funzione è stata aggiunta in PowerShell 4.0.,

Aggiornamento degli oggetti nei loop

Con i tipi di valore, l’unico modo per aggiornare l’array è utilizzare un ciclo for perché è necessario conoscere l’indice per sostituire il valore. Abbiamo più opzioni con gli oggetti perché sono tipi di riferimento. Ecco un rapido esempio:

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

Questo ciclo sta camminando su ogni oggetto nell’array $data. Poiché gli oggetti sono tipi di riferimento, la variabile$person fa riferimento allo stesso oggetto presente nell’array. Quindi gli aggiornamenti alle sue proprietà aggiornano l’originale.,

Non è ancora possibile sostituire l’intero oggetto in questo modo. Se si tenta di assegnare un nuovo oggetto alla variabile$person, si aggiorna il riferimento alla variabile a qualcos’altro che non punta più all’oggetto originale nell’array. Questo non funziona come ci si aspetterebbe:

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

Operatori

Gli operatori in PowerShell funzionano anche su array. Alcuni di loro funzionano in modo leggermente diverso.

-join

L’operatore-join è il più ovvio, quindi diamo un’occhiata prima., Mi piace l’operatore-joine lo uso spesso. Unisce tutti gli elementi dell’array con il carattere o la stringa chespecifica.

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

Una delle caratteristiche che mi piacciono dell’operatore -join è che gestisce singoli elementi.

PS> 1 -join '-'1

Lo uso all’interno della registrazione e dei messaggi dettagliati.

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

-join array array

Ecco un trucco intelligente che Lee Dailey mi ha fatto notare., Se vuoi unirti a tuttosenza un delimitatore, invece di fare questo:

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

Puoi usare -join con l’array come parametro senza prefisso. Date un’occhiata a questo esempio tosee che sto parlando.

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

-replace and-split

Gli altri operatori come-replacee-split eseguono su ogni elemento dell’array. Non posso dire che li abbia mai usati in questo modo, ma ecco un esempio.,

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

-contiene

L’operatore-contains consente di controllare un array di valori per vedere se contiene un valore specificato.

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

-in

Quando si dispone di un singolo valore che si desidera verificare corrisponde a uno dei diversi valori, è possibile utilizzare l’operatore-in. Il valore sarebbe a sinistra e l’array sul lato destro dell’operatore.

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

Questo può diventare costoso se l’elenco è grande. Uso spesso un modello regex se sto controllando più di pochi valori.,

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

-eq e-ne

L’uguaglianza e gli array possono complicarsi. Quando l’array si trova sul lato sinistro, ogni elemento ottieneconfrontato. Invece di restituire True, restituisce l’oggetto che corrisponde.

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

Quando si utilizza l’operatore-ne, otteniamo tutti i valori che non sono uguali al nostro valore.

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

Quando lo si utilizza in un’istruzioneif(), un valore che viene restituito è un valoreTrue., Se non viene restituito alcun valore, è un valoreFalse. Entrambe queste istruzioni successive valutano True.

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

Lo rivisiterò in un momento in cui parliamo di test per $null.

-match

L’operatore-match tenta di abbinare ogni elemento della raccolta.

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

Quando si utilizza-matchcon un singolo valore, una variabile speciale$Matches viene popolata con matchinfo., Questo non è il caso quando un array viene elaborato in questo modo.

Possiamo adottare lo stesso approccio con Select-String.

$servers | Select-String SQL

Do un’occhiata più da vicino aSelect-String, -matche la $matches variabile in un altro post chiamaToi molti modi per usare regex.

null null o empty

Il test per$null o array vuoti può essere complicato. Ecco le trappole comuni con gli array.

A colpo d’occhio, questa affermazione sembra che dovrebbe funzionare.,

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

Ma ho appena esaminato come-eq controlla ogni elemento nell’array. Quindi possiamo avere una matrice di severalitems con un singolo valore null null e valuterebbe $true

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

Questo è il motivo per cui è consigliabile posizionare $null sul lato sinistro dell’operatore. Questo makesthis scenario un non-problema.

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

A $null array non è la stessa cosa di un array vuoto. Se sai di avere un array, controlla ilconto di oggetti in esso contenuti., Se l’array è $null, il conteggio è 0.

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

C’è un’altra trappola a cui prestare attenzione qui. È possibile utilizzare countanche se si dispone di un singleobject, a meno che l’oggetto non sia unPSCustomObject. Questo è un bug che è stato risolto in PowerShell 6.1.Questa è una buona notizia, ma un sacco di persone sono ancora su 5.1 e hanno bisogno di guardare fuori per esso.

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

Se sei ancora su PowerShell 5.1, puoi avvolgere l’oggetto in un array prima di controllare il conteggio per ottenere un conteggio accurato.,

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

Per giocare completamente sul sicuro, controllare$null, quindi controllare il conteggio.

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

All-eq

Recentemente ho visto qualcuno chiedere come verificare che ogni valore in un array corrisponda a un dato valore.Reddit user / u / bis ha avuto questa soluzione intelligente che controlla eventuali valori errati e thenflips il risultato.

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

Aggiunta agli array

A questo punto, stai iniziando a chiederti come aggiungere elementi a un array. La risposta rapida è che non puoi. Un array è una dimensione fissa in memoria., Se hai bisogno di coltivarlo o aggiungere un singolo elemento ad esso, alloraè necessario creare un nuovo array e copiare tutti i valori dal vecchio array. Questo suona come un sacco di lavoro, tuttavia, PowerShell nasconde la complessità della creazione del nuovo array. powershellimplica l’operatore di addizione (+) per gli array.

Array addition

Possiamo usare l’operatore addition con array per creare un nuovo array. Quindi, dati questi due array:

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

Possiamo aggiungerli insieme per ottenere un nuovo array.

PS> $first + $secondZeroOneTwoThree

Più uguale a +=

Possiamo creare un nuovo array sul posto e aggiungere un elemento ad esso come questo:

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

Basta ricordare che ogni volta che si utilizza += che si sta duplicando e creando un nuovo matrice. Thisis un non un problema per piccoli set di dati, ma scala estremamente male.,

Assegnazione pipeline

È possibile assegnare i risultati di qualsiasi pipeline in una variabile. È un array se contiene multipleitems.

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

Normalmente quando pensiamo di usare la pipeline, pensiamo ai tipici one-liner di PowerShell. Possiamo utilizzare la pipeline conforeach() istruzioni e altri loop. Quindi, invece di aggiungere elementi ad anarray in un ciclo, possiamo rilasciare elementi sulla pipeline.

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

Tipi di array

Per impostazione predefinita, un array in PowerShell viene creato come tipo ]., Ciò consente di contenerequalsiasi tipo di oggetto o valore. Questo funziona perché tutto è ereditato dal tipoPSObject.

Array fortemente tipizzati

È possibile creare un array di qualsiasi tipo utilizzando una sintassi simile. Quando si crea un array fortemente tipizzato, può contenere solo valori o oggetti del tipo specificato.

ArrayList

L’aggiunta di elementi a un array è uno dei suoi più grandi limiti, ma ci sono alcune altre collezioni a cui possiamo rivolgerci per risolvere questo problema.,

Il ArrayList è comunemente una delle prime cose che pensiamo quando abbiamo bisogno di un array che isfaster con cui lavorare. Agisce come un array di oggetti in ogni posto in cui ne abbiamo bisogno, ma gestisce rapidamente addingitems.

Ecco come creiamo unArrayList e aggiungiamo elementi ad esso.

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

Stiamo chiamando in.NET per ottenere questo tipo. In questo caso, stiamo usando il costruttore predefinito percrearlo. Quindi chiamiamo il metodoAdd per aggiungere un elemento ad esso.,

Il motivo per cui sto usando all’inizio della riga è quello di sopprimere il codice di ritorno. Some.NET le chiamate fanno questo e possono creare output imprevisto.

Se gli unici dati che hai nel tuo array sono stringhe, dai un’occhiata anche a usingStringBuilder. È quasi la stessa cosa, ma ha alcuni metodi che sono solo per trattare withstrings. Il StringBuilder è appositamente progettato per le prestazioni.

È comune vedere le persone spostarsi su ArrayList dagli array. Ma viene da un momento in cui C # did’thave supporto generico., Il ArrayListè deprecato nel supporto per il genericoList

Elenco generico

Un tipo generico è un tipo speciale in c# che definisce una classe generalizzata e l’utente specifica i tipi di dati che utilizza quando viene creato. Quindi, se vuoi un elenco di numeri o stringhe, definiresti che vuoi un elenco di tipi int o string.

Ecco come si crea un elenco per le stringhe.

$mylist = ]::new()

O una lista per i numeri.,

$mylist = ]::new()

Possiamo lanciare un array esistente in una lista come questa senza creare prima l’oggetto:

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

Possiamo abbreviare la sintassi con l’istruzioneusing namespace in PowerShell 5 e versioni successive. L’istruzioneusing deve essere la prima riga dello script. Dichiarando uno spazio dei nomi, Powershelllet si lascia fuori dei tipi di dati quando li si fa riferimento.

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

Questo rende ilList molto più utilizzabile.,

Hai a disposizione un metodo simile Add. A differenza di ArrayList, non esiste alcun valore di ritorno sul metodo Add quindi non dobbiamo void.

$myList.Add(10)

E possiamo ancora accedere agli elementi come altri array.

PS> $myList10

List

Puoi avere un elenco di qualsiasi tipo, ma quando non conosci il tipo di oggetti, puoi usare ] per contenerli.,

$list = ]::new()

Remove ()

Il ArrayListe il generico List supportano entrambi la rimozione di elementi dalla collezione.

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

Quando si lavora con i tipi di valore, rimuove il primo dall’elenco. Puoi chiamarlo di nuovo andover per continuare a rimuovere quel valore. Se si dispone di tipi di riferimento, è necessario fornire l’oggetto che si desidera rimuovere.,

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

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

Il metodo remove restituiscetrue se è stato in grado di trovare e rimuovere l’elemento dalla raccolta.

Altre collezioni

Ci sono molte altre collezioni che possono essere utilizzate, ma queste sono le buone sostituzioni di array generici.Se siete interessati a conoscere più di queste opzioni, dare un’occhiata a thisGist thatMark Kraus messo insieme.

Altre sfumature

Ora che ho coperto tutte le principali funzionalità, ecco alcune altre cose che volevo ricordare prima di concludere questo.,

Array pre-dimensionati

Ho detto che non è possibile modificare le dimensioni di un array una volta creato. Possiamo creare una matrice di una dimensione predeterminata chiamandola con il costruttorenew($size).

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

Moltiplicare gli array

Un piccolo trucco interessante è che puoi moltiplicare un array per un numero intero.

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

Inizializza con 0

Uno scenario comune è che si desidera creare un array con tutti gli zeri. Se hai solo integeri, un array di numeri interi fortemente tipizzato è predefinito su tutti gli zeri.,

PS> ]::new(4)0000

Possiamo usare il trucco moltiplicatore anche per fare questo.

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

La cosa bella del trucco moltiplicativo è che puoi usare qualsiasi valore. Quindi, se si preferisce avere 255 come valore predefinito, questo sarebbe un buon modo per farlo.

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

Array nidificati

Un array all’interno di un array è chiamato array nidificato. Non li uso molto in PowerShell ma li ho usati di più in altre lingue. Considerare l’utilizzo di un array di array quando i dati si inseriscono in un modello a griglia.,

Ecco due modi in cui possiamo creare un array bidimensionale.

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

La virgola è molto importante in questi esempi. Ho dato un esempio precedente di un normale array su righe multiple in cui la virgola era facoltativa. Questo non è il caso di un array multidimensionale.

Il modo in cui usiamo la notazione dell’indice cambia leggermente ora che abbiamo un array nidificato. Usando$data sopra, questo è il modo in cui accederemmo al valore 3.

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

Aggiungi un set di parentesi per ogni livello di nidificazione dell’array., Il primo set di parentesi è per l’array più esterno e poi ti fai strada da lì.

Write-Output-NoEnumerate

PowerShell ama scartare o enumerare gli array. Questo è un aspetto fondamentale del modo in cui PowerShell utilizza thepipeline, ma ci sono volte in cui non vuoi che ciò accada.

Comunemente pipe oggetti aGet-Member per saperne di più su di loro. Quando pipe un array ad esso, itgets unwrapped e Get-Member vede i membri dell’array e non l’array effettivo.,

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

Per evitare che lo scartamento della matrice, è possibile utilizzareWrite-Object -NoEnumerate.

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

Ho un secondo modo che è più di un hack (e cerco di evitare hack come questo). È possibile posizionare acomma davanti all’array prima di condurlo.

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

Restituisce un array

Questo scartamento degli array avviene anche quando si emettono o restituiscono valori da una funzione. Puoi ancora ottenere un array se assegni l’output a una variabile, quindi questo non è comunemente un problema.

Il problema è che hai un nuovo array., Se questo è mai un problema, puoi usareWrite-Output -NoEnumerate $array oreturn ,$array per aggirarlo.

Qualcos’altro?