By Leave a Comment on Powershell: Tutto quello che volevi sapere su array

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

  • Indice della pagina
  • Che cos’è un array?,match
  • $null o vuoto
    • Tutti -eq
  • Aggiunta alle matrici
    • Array aggiunta
    • Plus è uguale a +=
    • Pipeline di assegnazione
  • Tipi di Matrice
    • Fortemente tipizzato array
    • ArrayList
    • Elenco Generico
      • Lista
      • Remove()
    • Altre collezioni
  • Altre sfumature
    • Pre-dimensioni array
    • Moltiplicazione di matrici
    • Inizializza con 0
    • array Nidificati
    • Scrivere-Uscita -NoEnumerate
      • restituisce un array
  • qualcos’altro?,

    • 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 scorrere l’array o accedere a singoli elementi utilizzando un indice. L’array viene creato come un blocco sequenziale di memoria in cui ogni valore viene memorizzato 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 con @()

    Un array vuoto può essere creato usando@()

     PS> $data = @() PS> $data.count 0

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

     PS> $data = @('Zero','One','Two','Three') PS> $data.count 4 PS> $data Zero One Two Three

    Questo array ha 4 elementi. Quando chiamiamo la variabile$data, vediamo l’elenco dei nostri articoli., Se si tratta di una matrice di stringhe, avremo 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 il controllo del codice sorgente.,

    Altra sintassi

    È comunemente inteso che@() è la sintassi per la creazione di un array, ma gli elenchi separati 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 alla console.

     $data = Write-Output Zero One Two Three

    Questo è utile perché non è necessario inserire virgolette intorno alle stringhe quando il parametro accetta stringhe., 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 a singoli elementi, utilizziamo le parentesi con un valore di offset a partire da 0. Questo è il modo in cui otteniamo il primo elemento nel nostro array:

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

    Il motivo per cui usiamo zero qui è perché il primo elemento è all’inizio dell’elenco, quindi usiamo un offset di 0 elementi per arrivarci., Per arrivare al secondo elemento, dovremmo usare un offset di 1 per saltare il primo elemento.

     PS> $data One

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

     PS> $data Three

    Index

    Ora puoi capire perché ho scelto i valori che ho fatto per questo esempio. Ho introdotto questo come offset perché è quello che è veramente, ma questo offset è più comunemente indicato come indice. Un indice 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 otterrà un singolo elemento indietro. PowerShell è molto più flessibile. È possibile utilizzare più indici contemporaneamente. Fornendo un elenco di indici, possiamo selezionare diversi elementi.

     PS> $data Zero Two Three

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

     PS> $data Three Zero Three

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

     PS> $data One Two Three

    Funziona anche al contrario.

     PS> $data Three Two One

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

     PS> $data Three

    Fuori dai limiti

    Nella maggior parte delle lingue, se si tenta di accedere a un indice di un elemento che è oltre la fine della matrice, si otterrebbe un qualche tipo di errore o un’eccezione. PowerShell silenziosamente non ti darà nulla.

     PS> $null -eq $data True

    Non è indice in un null, array

    Se la variabile è $null e si tenta di indice, come un array, si otterrà un System.Management.Automation.RuntimeException eccezione con il messaggio Cannot index into a null array.,

     PS> $empty = $null SP> $empty Error: 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.count 4

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

     PS> $date = Get-Date PS> $date.count 1

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

     PS> $null.count 0

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

    Off by one errors

    Viene creato un errore di programmazione comune perché gli array iniziano dall’indice 0. Un errore off by one può essere introdotto in due modi molto comuni.,

    Il primo è pensare mentalmente di volere il 2 ° elemento e usare un indice di2 e ottenere davvero il terzo elemento. O pensando di avere 4 elementi e vuoi l’ultimo elemento, quindi userai la dimensione per 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 - 1 o-1 che abbiamo appreso sopra.,

     PS> $data Three

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

     PS> $data Three

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

     PS> $data.GetUpperBound(0) Three

    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 per aggiornare i singoli elementi.

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

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

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

    Iterazione

    Ad un certo punto, dovrai camminare o iterare l’intero elenco ed eseguire alcune azioni per ogni elemento dell’array.,

    Pipeline

    Gli array e la pipeline PowerShell sono pensati l’uno per l’altro. Questo è uno dei modi più semplici per elaborare questi 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 uno dei due perché entrambi rappresentano l’oggetto corrente nella pipeline.,

    Ciclo ForEach

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

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

    ForEach metodo

    Tendo a dimenticare 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. È possibile eliminare le parentesi e fornire semplicemente il blocco di script.,

     $data.foreach{"Item "}

    Questa è una sintassi meno conosciuta ma funziona allo stesso modo. Questo metodoforeach è stato aggiunto in PowerShell 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 $indexa 0., 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. È molto facile ottenere la condizione leggermente sbagliata per ottenere un errore nella logica., Usare$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 spento da un errore.

    Interruttore loop

    Questo è uno che è molto facile da trascurare. Se si fornisce un array a un’istruzione switch, corrisponderà a ciascun elemento dell’array.

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

    Questo produrrà questo output:

     Tick Tock Tick Tock

    Ci sono molte cose interessanti come questa 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 interi (tipi di valore), a volte vorrai aggiornare i valori nell’array mentre li esegui in loop. La maggior parte dei loop sopra utilizza una variabile nel ciclo 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 i valori al suo interno, 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 contenere oggetti.

     $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 caratteristiche 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> $data FirstName LastName ----- ---- Kevin Marquette

    Possiamo accedere e aggiornare direttamente le proprietà.,

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

    Array proprietà

    Normalmente è necessario enumerare tutta la lista come questa per accedere a tutte le proprietà:

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

    O utilizzando il Select-Object -ExpandProperty cmdlet.

     PS> $data | Select-Object -ExpandProperty LastName Marquette Doe

    Ma PowerShell ci offre la possibilità di richiedere LastName direttamente. PowerShell li enumererà tutti per noi e ci darà una lista pulita.,

     PS> $data.LastName Marquette Doe

    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’array in base alle proprietà dell’oggetto.

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

    Possiamo scrivere la stessa query in questo modo per ottenere il FirstName che stiamo cercando.,

     $data | Where FirstName -eq Kevin

    Dove()

    Array hanno un Where() metodo 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à aggiorneranno l’originale.

    Non è ancora possibile sostituire l’intero oggetto in questo modo. Se si tenta di assegnare un nuovo oggetto alla variabile $person, si sta aggiornando il riferimento della variabile a qualcos’altro che non punta più all’oggetto originale nell’array., Questo non funzionerà 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 lo esamineremo prima. Mi piace l’operatore-join e lo uso spesso. Si unirà tutti gli elementi della matrice con un carattere o una stringa specificata.,

     PS> $data = @(1,2,3,4) PS> $data -join '-' 1-2-3-4 PS> $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 tutto senza un delimitatore, invece di fare questo:

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

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

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

    -sostituire e -split

    Gli altri operatori come -replace e -split verrà eseguito su ogni elemento dell’array. Non posso dire di averli 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-01 LAX-SQL-02 LAX-SQL-03

    -contiene

    L’operatore -contains ti permetterà 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 ha 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’operazione.,

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

    Questo può diventare costoso se l’elenco è grande. Userò spesso un modello regex se sto controllando più di 4-5 valori.

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

    -eq e-ne

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

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

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

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

    Quando si utilizza questo in un if() istruzione, un valore che viene restituito è un True valore. Se non viene restituito alcun valore, si tratta di un valoreFalse. Entrambe queste istruzioni successive valuteranno 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 cercherà di abbinare ogni elemento della collezione.

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

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

    Possiamo adottare lo stesso approccio con Select-String.,

     $servers | Select-String SQL

    mi date un ‘ occhiata a Select-String-match e $matches variabile in un altro post chiamato molti modi per usare le 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., Così possiamo avere un array di vari elementi con un solo $valore null e sarebbe valutare $true

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

    Questo è il motivo per cui si consiglia di posizionare il $null sul lato sinistro dell’operatore. Questo rende questo scenario un non-problema.

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

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

     if ( $array.count -gt 0 ) { 'Array is not empty' }

    C’è un’altra trappola a cui prestare attenzione qui. Puoi usare count anche se hai un singolo oggetto, a meno che quell’oggetto non sia un PSCustomObject. 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, è possibile avvolgere l’oggetto in un array prima di controllare il conteggio per ottenere un conteggio accurato.

     if ( @($array).count -gt 0 ) { 'Array is not empty' }

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

     if ( $null -ne $array -and @($array).count -gt 0 ) { 'Array is not 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 quindi ribalta il risultato.,

     $results = Test-Something if ( -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 è necessario coltivarlo o aggiungere un singolo elemento ad esso, è necessario creare un nuovo array e copiare tutti i valori dal vecchio array. Questo suona costoso e come un sacco di lavoro, tuttavia, PowerShell nasconde la complessità della creazione del nuovo 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 + $second Zero One Two Three

    Plus è uguale a +=

    Siamo in grado di creare un nuovo array in luogo e di aggiungere un elemento come questo:

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

    Basta ricordare che ogni volta che si utilizza += che si sono duplicazione e la creazione di un nuovo array. Questo non è un problema per i piccoli set di dati, ma si ridimensiona estremamente male.,

    Assegnazione pipeline

    È possibile assegnare i risultati di qualsiasi pipeline in una variabile. Sarà un array se contiene più elementi.

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

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

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

    Assegnando i risultati di foreach a una variabile, catturiamo tutti gli oggetti e creiamo un singolo array.

    Tipi di array

    Per impostazione predefinita, un array in PowerShell viene creato come tipo]. Ciò consente di contenere qualsiasi tipo di oggetto o valore. 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

    Aggiungere elementi a un array è uno dei suoi maggiori limiti, ma ci sono alcune altre collezioni a cui possiamo rivolgerci per risolvere questo problema.

    IlArrayList è comunemente una delle prime cose a cui pensiamo quando abbiamo bisogno di un array con cui lavorare più velocemente. Agisce come un array di oggetti in ogni posto in cui ne abbiamo bisogno, ma gestisce rapidamente l’aggiunta di elementi.

    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 per crearlo. 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. Alcune chiamate. Net lo faranno e possono creare output imprevisti.

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

    • Concatenare le stringhe usando StringBuilder

    È davvero comune vedere le persone spostarsi su ArrayList dagli array. Ma viene da un momento in cui c# non aveva il supporto generico., Il ArrayListè ammortizzato in supporto per il genericoList

    Elenco generico

    Un tipo generico è un tipo speciale in c# che definisce una classe generalizzata e l’utente specificherà i tipi di dati che utilizzerà quando creato. Quindi, se vuoi un elenco di numeri o stringhe, definisci che vuoi un elenco di tipiint ostring.

    Ecco come si crea un elenco per le stringhe.

     $mylist = ]::new()

    O un elenco di numeri.,

     $mylist = ]::new()

    Siamo in grado di lanciare un array esistente per una lista come questa, senza la creazione di oggetto:

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

    Siamo in grado di ridurre la sintassi un po ‘ con i using namespace dichiarazione in PowerShell 5 e versioni successive. L’istruzione using deve essere la prima riga dello script. Dichiarando uno spazio dei nomi, PowerShell ti permetterà di lasciarlo fuori dai tipi di dati quando li fai riferimento.,

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

    Questo rende il List molto più utilizzabile.

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

     $myList.Add(10)

    E possiamo ancora accedere agli elementi come altri array.,

     PS> $myList 10

    List

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

     $list = ]::new()

    Remove ()

    Il ArrayList e il generico List supportano entrambi la rimozione di elementi dalla raccolta.

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

    Quando si lavora con i tipi di valore, rimuoverà il primo dall’elenco., Puoi chiamarlo più e più volte per continuare a rimuovere quel valore. Se si dispone di tipi di riferimento, è necessario fornire l’oggetto che si desidera rimuovere.

    =”b47349a7be”>
     $delete = $drives $drives.remove($delete)

    Il metodo di rimozione restituirà true 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 sei interessato a conoscere più di queste opzioni, dai un’occhiata a questo succo che Mark Kraus ha messo insieme.

    Altre sfumature

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

    Array pre-dimensionati

    Ho detto che non è possibile modificare le dimensioni di un array una volta creato. Possiamo creare un array di dimensioni predeterminate chiamandolo con il costruttorenew($size).,

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

    Moltiplicare gli array

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

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

    Inizializza con 0

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

     PS> ]::new(4) 0 0 0 0

    Possiamo usare il trucco moltiplicatore anche per fare questo.,

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

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

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

    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 simile a una griglia.

    Ecco due modi in cui possiamo creare un array dimensionale 2.,

     $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 array normale su più righe 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 = 0 PS> $inside = 2 PS> $data 3

    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 la pipeline, ma ci sono volte in cui non si desidera che ciò accada.

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

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

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

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

    Ho un secondo modo per farlo che è più di un hack (e cerco di evitare hack come questo). È possibile posizionare una virgola davanti all’array prima di condurla.

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

    Restituisce un array

    Questo non-wrapping di array si verifica anche quando si emettono o restituiscono valori da una funzione., È comunque possibile ottenere un array se si assegna l’output a una variabile, quindi questo non è comunemente un problema.

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

    Qualcos’altro?

    So che questo è tutto molto da prendere in. La mia speranza è che imparerai qualcosa da questo articolo ogni volta che lo leggi e che si rivelerà un buon riferimento per te per molto tempo a venire., Se hai trovato questo per essere utile, si prega di condividere con gli altri che si pensa otterrà valore fuori di esso.

    Da qui, ti consiglio di controllare un post simile che ho scritto su hashtables.

    Lascia un commento

    Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *