Guida agli array PowerShell: come utilizzarli e crearli

Gli array sono una caratteristica fondamentale di PowerShell. Consentono di inserire, manipolare e produrre strutture di dati reali (e non solo stringhe grezze). Questa funzionalità rende PowerShell diverso e più utile rispetto ad altri linguaggi di scripting.

In questo articolo spiegheremo cosa sono gli array e come utilizzarli in PowerShell. Per prima cosa, ti mostreremo come creare array in PowerShell e poi come utilizzare le funzioni di base per manipolarli. Infine, esamineremo diversi tipi di array ed esploreremo alcune delle caratteristiche meno evidenti.

Il nostro obiettivo è darti una buona base per lavorare con gli array in PowerShell. Una volta padroneggiati questi elementi di base, puoi dare un'occhiata al nostro corso su PowerShell per saperne di più.

• Nozioni fondamentali sugli array
• Array di oggetti
• Operatori per array
• Come aggiungere valori a un array
• Tipi di array
• Funzioni avanzate per gli array

Array PowerShell

Gli array sono una caratteristica comune di quasi tutti i linguaggi di programmazione. Si tratta di una struttura di dati che ha la funzione di raccogliere più pezzi di dati. Quando si lavora con un array, si può utilizzare lo stesso comando per eseguire la stessa funzione su ogni elemento all'interno dell'array stesso, oppure accedere ai singoli elementi e manipolarli usando un indice.

Gli array in PowerShell possono contenere uno o più elementi. Un elemento può essere costituito da una stringa, un numero intero, un oggetto o anche un altro array; un array può contenere una combinazione qualsiasi di questi. Ognuno di questi elementi ha un indice, che inizia sempre (a volte confondendo) da 0. Quindi al primo elemento di un array viene assegnato l'indice 0, il secondo è indicizzato come 1 e così via.

Gli array sono una parte fondamentale di PowerShell che appaiono in ogni tutorial PowerShell. Una buona conoscenza di come lavorare con gli array è fondamentale per molti aspetti dell'uso di PowerShell, dalla configurazione di Office 365 all'utilizzo di PowerShell per Pentesting.

Un esempio di array PowerShell

Il modo più semplice per illustrare cos'è un array è fare un esempio. Creiamo un array che rappresenta una ciotola di frutta.

Esistono diversi modi per creare array in Powershell, ma il modo più semplice è eseguire questo comando:

@()

Verrà creato un array vuoto. Questo elemento non è molto utile, quindi aggiungiamo dei frutti. Questi saranno rappresentati come stringhe di testo. Per farlo, esegui questo comando

$frutta = @('Mele','Arance','Banane')

In questo modo, l'array prenderà il nome "frutta" e vi aggiungerà tre elementi. Per vedere se funziona, è possibile leggere l'array utilizzando questo comando:

PS /Users/yourname> $frutta

che ora restituisce:

  Mele

  Arance

  Banane

Come puoi vedere, questo array è un gruppo di singoli dati. PowerShell li indicizzerà automaticamente come abbiamo spiegato in precedenza: "Mele" sarà indicizzato come 0, "Arance" come 1 e "Banane" come 2.

Questo esempio potrebbe indurre a pensare che gli array siano oggetti abbastanza semplici, e in un certo senso lo sono. La loro semplicità, tuttavia, è anche ciò che li rende oggetti così flessibili e potenti. Nel resto di questa guida, presenteremo sommariamente ciò che è possibile fare con gli array.

Nozioni fondamentali sugli array

In questa sezione esamineremo i modi più semplici per creare e lavorare con array in PowerShell.

Creazione di un array

Innanzitutto, creiamo un array. Il modo più comune per farlo è usare @(), sebbene esistano altri modi.

Per ora, creiamo un array chiamato "dati". A tale scopo, esegui:

$dati = @()

Attualmente, questo array è vuoto perché non abbiamo specificato alcun dato da inserire. Per verificare quanti elementi si trovano in un array, possiamo utilizzare la funzione count:

$dati .count

che, al momento, restituirà uno 0, perché non ci sono elementi. Per creare un array con alcuni dati, abbiamo inserito questi dati tra le parentesi dopo la @:

$dati = @('Zero','Uno','Due','Tre')

Esegui ora la stessa funzione di conteggio e vedrai che nell'array sono presenti 4 elementi. Per visualizzarli di nuovo, è sufficiente richiamare l'array:

$dati

che elenca gli elementi appena inseriti all'interno di esso.

Accesso agli elementi

Ora abbiamo un array e vogliamo accedere agli elementi in esso contenuti. Esistono diversi modi per farlo. Il primo è usare l'indice degli elementi nell'array. Come abbiamo spiegato in precedenza, gli indici cominciano da 0, quindi per recuperare il primo elemento contenuto nel nostro array dovremo dire a PowerShell di indicare l'elemento il cui indice è zero. Lo facciamo eseguendo:

$dati[0]

Il comando restituirà "zero" perché è stata la prima stringa che abbiamo inserito nel nostro array.

Possiamo anche estendere questa sintassi per restituire più elementi dallo stesso array, semplicemente inserendo più indici nello stesso comando. Ad esempio, esegui:

$dati[0,2,3]

In questo caso, avremo "Zero Due Tre". Gli elementi vengono restituiti nello stesso ordine in cui sono stati inseriti gli indici. È anche possibile utilizzare un'ulteriore sintassi per restituire set di elementi da un array. Ad esempio:

$dati[1..3]

Restituisce tutti gli elementi con un indice compreso tra 1 e 3 (incluso). E:

$dati[-1]

Restituisce l'ultimo elemento dell'array: il numero negativo indica a PowerShell di contare all'indietro dalla fine dell'array, quindi, in questo caso, il comando restituisce "Tre",ossia l'ultimo elemento nel nostro array di prova.

Modifica degli elementi

Lo stesso metodo può essere utilizzato per aggiornare gli elementi di un array. Ad esempio, per aggiornare l'elemento il cui indice è 2 (ricordare che questo è il terzo elemento nell'array), possiamo eseguire:

$dati[2] = 'secondo'

In tal modo, avremo un accesso diretto agli elementi contenuti dentro un array.

Azioni ripetute

Una delle funzioni più potenti di PowerShell (e, in effetti, di qualsiasi interfaccia della riga di comando) è la possibilità di eseguire la stessa azione su tutti gli elementi di una serie. Esistono diversi modi per farlo.

Il più semplice è usare una pipeline, cioè il carattere |. Quando si passa un array a una pipeline, ogni elemento dell'array viene trattato in modo individuale. Come abbiamo sottolineato nel nostro articolo sugli oggetti PowerShell e la precompilazione dei dati, questo è spesso il modo più semplice per eseguire azioni iterate.

Ad esempio, per aggiungere una descrizione a ogni elemento del nostro array, possiamo usare questo comando:

$dati | ForEach-Object {"Elemento: [$PSItem]"}

Questo comando indica a PowerShell di prendere uno alla volta gli elementi in $data, quindi per ciascuno di essi aggiunge "Elemento:" all'inizio, seguito dal valore originale.

Esistono diversi altri modi per eseguire azioni iterate in PowerShell, molti dei quali già noti a chi conosce altri linguaggi di programmazione: PowerShell include ForEach loop, For loop e Switch loop. Per ulteriori dettagli su queste azioni, consulta la documentazione Microsoft.

Array di oggetti

Finora, abbiamo lavorato con un array che contiene dati di base: una stringa. Tuttavia, gli array possono anche contenere oggetti e molti degli usi più comuni di PowerShell, come la configurazione di Office 365, richiedono la conoscenza del lavoro con gli oggetti. Quindi diamo un'occhiata ad alcuni comandi di base per farlo.

Creazione di un array di oggetti

Possiamo creare un array di oggetti come abbiamo fatto con le stringhe, usando la funzione @(). Ad esempio, per creare un elenco di test dei dipendenti, possiamo utilizzare:

$dati = @(

       [pscustomobject]@{Nome='Andrea';Cognome='Rossi'}

       [pscustomobject]@{Nome='Marco'; Cognome='Bianchi'}

   )

La maggior parte dei cmdlet restituisce un array di questo tipo quando si assegna loro una variabile con cui lavorare.

Accedere agli oggetti degli array

Il processo descritto in precedenza per accedere a singoli dati può essere utilizzato anche con array contenenti oggetti. Ad esempio, se si esegue:

$dati[0]

viene restituito:

   Nome Cognome

    -----     ----

    Andrea    Rossi

In alternativa, possiamo accedere alle proprietà dei singoli oggetti specificando quale proprietà vogliamo all'interno dello stesso comando, in questo modo:

$dati[0].Nome

che restituisce "Andrea".

Aggiornare le proprietà degli oggetti negli array

Procedendo oltre, la stessa sintassi ci consente di aggiornare le proprietà individuali all'interno degli oggetti che sono contenuti negli array. Ad esempio:

$dati[0].Nome = 'Rocco'

Aggiorna la proprietà FirstName nel primo elemento del nostro array su "Rocco".

Accedere a tutte le proprietà presenti in un array di oggetti

Nella maggior parte dei linguaggi di programmazione, dovremmo usare un processo iterativo (vedi sopra) per accedere a tutte le proprietà in un array di oggetti. Possiamo farlo anche in PowerShell, ovviamente, eseguendo:

$dati | ForEach-Object {$_.Cognome}

Questo comando restituisce un elenco di tutte le proprietà LastName presenti nel nostro array, ma è molto impegnativo dal punto di vista informatico e difficile da scrivere ogni volta che si desidera visualizzare questi dati. Quindi, PowerShell ha una scorciatoia. Esegui:

$dati.Cognome

Vedrai lo stesso elenco. PowerShell sta effettivamente prendendo ogni oggetto a turno, proprio come prima, ma ci nasconde questa complessità.

Operatori per array

Quasi tutti gli operatori che utilizziamo per singoli elementi di dati in PowerShell funzionano anche con gli array, ma alcuni di essi funzionano in modo leggermente diverso se utilizzati in questo modo. Diamo quindi un'occhiata agli operatori più comuni e a come utilizzarli negli array.

-join

L'operatore -join è uno dei comandi più usati in PowerShell ed è estremamente utile quando si lavora con gli array. Può essere usato iterativamente sugli elementi di un array per unirli insieme nell'output dello stesso.

Facciamo alcuni esempi. Per prima cosa, crea un array semplice:

$dati = @(1,2,3,4)

Quindi utilizza -join per inserire un trattino tra ogni elemento e generare il risultato:

$dati -join '-'

Che restituisce "1-2-3-4". L'operatore -join può essere utilizzato anche senza un delimitatore, in cui gli elementi di un array generano una serie di valori non separati.

-contains

L'operatore -contains funziona sugli array in modo molto simile al suo utilizzo con punti di dati singoli. Puoi usarlo per verificare se un array contiene una stringa particolare e, eventualmente, produrrà un valore booleano. Ad esempio:

    PS> $dati = @('rosso','verde','blu')

    PS> $dati -contains 'verde'

    Vero

Uguaglianze

Esistono due operatori per verificare l'uguaglianza in PowerShell: -eq e -ne. Tuttavia, se si utilizzano questi valori su valori singoli, il modo in cui questi funzionano in relazione agli array può sembrare un po' strano. Se si utilizza -eq, ad esempio, l'operatore non restituisce l'output di un valore booleano "Vero", ma restituisce invece l'oggetto corrispondente.

Ad esempio:

    PS> $dati = @('rosso','verde','blu')

    PS> $dati -eq 'verde'

    verde

L'operatore -ne funziona più o meno allo stesso modo, tranne per il fatto che restituisce tutti i valori che non sono uguali al valore specificato. Quindi:

    PS> $dati = @('rosso','verde','blu')

    PS> $dati -ne 'verde'

    rosso

    blu

Tuttavia, è possibile utilizzare un'istruzione if() per confrontare l'output di questi operatori con l'output previsto e restituire un output "Vero" o "Falso".

Come aggiungere valori a un array

Dopo tutte le istruzioni di cui sopra, probabilmente ti starai chiedendo perché abbiamo tralasciato l'aggiunta di elementi di dati a un array. Questo perché non c'è modo di farlo. Una volta creato, un array rimane per sempre della stessa dimensione, quindi per ingrandirlo è necessario copiarlo in un nuovo array ed eliminare l'originale.

Sembra complicato, ma Powershell gestisce questo processo per l'utente utilizzando una serie di operatori piuttosto semplici. Ci sono diversi modi per farlo.

Aggiunta di array

PowerShell può unire due array utilizzando l'operatore "+", che nasconde la complessità di ciò che il sistema sta effettivamente facendo. Ad esempio, se si creano due array di prova come questo:

    $first = @(

        'Zero'

        'Uno'

    )

    $second = @(

        'Due'

        'Tre'

    )

È possibile unirli utilizzando semplicemente:

    PS> $first + $second

In tal modo, verrà creato un nuovo array con tutti e quattro i valori e verranno mostrati i risultati. Tieni presente, tuttavia, che l'array non verrà rinominato. Per farlo, utilizziamo l'operatore +=.

Più uguale per la combinazione di array

Invece di usare l'operatore "+", visto nell'esempio precedente, avremmo potuto usare l'operatore "+=", che ci restituisce un array completamente nuovo:

    $first += 'Due, Tre'

Il comando sembra semplice, ma nasconde ciò che PowerShell sta facendo in realtà. Copia tutti i valori da $first e crea un nuovo array che include i valori aggiuntivi. Elimina quindi l'array originale.

Si tratta di una procedura problematica perché è piuttosto dispendiosa a livello computazionale. Con array di piccole dimensioni, potresti non rendertene conto, ma in presenza di grandi quantità di dati, il metodo può bloccare rapidamente il tuo sistema. Ecco perché più avanti ti proporremo un modo per risolvere il problema.

Tipi di array

Finora, abbiamo discusso di array predefiniti in PowerShell. Sebbene PowerShell non ce l'abbia detto in quel momento, ogni array che abbiamo creato finora è dello stesso tipo, il tipo [PSObject []]. Questo tipo di array può contenere qualsiasi tipo di valore di dati.

Array fortemente tipizzati

Tuttavia, a volte si desidera limitare a uno i tipi di dati o oggetti che un array può contenere. Possiamo farlo utilizzando un array fortemente tipizzato, che può contenere solo il tipo di dati specificato.

Ad esempio, per creare un array che possa accettare solo numeri interi, possiamo usare:

    PS> [int[]] $numbers = 1,2,3

Se si tenta di inserire il tipo errato di valore dei dati in un array fortemente tipizzato, viene restituito un codice di errore.

ArrayList

Come abbiamo detto in precedenza, aggiungere oggetti agli array può essere complicato. Tuttavia, un tipo diverso di raccolta, ArrayList, gestisce l'operazione in modo più elegante. Per poter utilizzare questo tipo di raccolta, tuttavia, dovremo richiamare framework.Net, che può produrre alcuni risultati anomali durante la procedura.

Per creare un ArrayList e aggiungervi gli elementi, esegui le operazioni seguenti:

   $ilmioarray = [System.Collections.ArrayList]::new()

    [void]$ilmioarray.Add('Value')

Qui, possiamo usare il costruttore .Net predefinito per creare un nuovo ArrayList, quindi utilizzare l'operatore -Add per aggiungervi elementi. L'operatore [void] è presente perché a volte questi comandi generano risultati anomali, che possono interferire con il codice.

Approfondimenti

Questi sono i tipi di array più comuni di PowerShell, ma ce ne sono altri. Se stai svolgendo un'attività di sviluppo come utente PowerShell, è utile iniziare a utilizzare ArrayList invece di array puri, ma devi anche essere consapevole che questo tipo di array non è utilizzato da utenti avanzati.

I programmatori più esperti, invece, usano un tipo di elenco generico detto List[]. Questo tipo di elenco è un po' più complesso da utilizzare perché proviene direttamente da C#, ma una volta padroneggiato, offre molta più flessibilità rispetto agli array di cui abbiamo discusso finora.

Funzioni avanzate per gli array

Oltre alle funzionalità di base presentate finora, esistono anche una serie di funzioni di array più avanzate e alcune funzioni aggiuntive, man mano che inizi a utilizzarle più frequentemente.

Array pre-dimensionati

Il procedimento standard per la creazione degli array di cui sopra prevede la realizzazione di un array con una dimensione determinata dal numero di elementi in esso contenuti. Tuttavia, è possibile creare un array di dimensioni specifiche utilizzando il costruttore new($size).

Puoi farlo in questo modo:

    $dati = [Object[]]::new(4)

Se esegui una query .count su questo array, viene restituito "4", perché, anche se non ha dati al suo interno, riempie lo spazio con 0. Questo è in realtà estremamente utile se devi inizializzare un nuovo array che viene riempito di zero, perché un array pre-dimensionato viene prima riempito di 0.

Moltiplicazione di array

Moltiplicare gli oggetti in un array, specialmente le stringhe, è qualcosa che confonde la maggior parte degli utenti che devono farlo per la prima volta. Abbiamo visto script if() estremamente complicati per raggiungere questo risultato, ma esiste un modo molto più semplice:

    PS> $dati = @('rosso','verde','blu')

    PS> $data * 3

Sì, esatto. Il comando crea un nuovo array con ogni valore ripetuto tre volte. Puoi anche utilizzarlo come metodo alternativo per riempire un array con zero (o qualsiasi altro valore predefinito) creando un array con il valore selezionato e moltiplicandolo tutte le volte che vuoi.

Array nidificati

Come molti altri linguaggi di programmazione, PowerShell supporta gli array nidificati. La procedura standard per farlo in PowerShell consiste nell'utilizzare un array multidimensionale. L'esempio più semplice è creare un array bidimensionale:

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




    $dati2 = @(

        @(1,2,3),

        @(4,5,6),

        @(7,8,9)

    )

La struttura dei dati che si sta realizzando con questo comando è una matrice classica e può essere utilizzata come quelle di altri linguaggi di programmazione. Ad esempio, per accedere a un valore particolare di questo array, è necessario specificare due dimensioni.

Ad esempio, per accedere al valore "3", useremo:

    PS> $outside = 0

    PS> $inside = 2

    PS> $dati[$outside][$inside]

    3

Questo comando può quindi essere utilizzato per accedere a qualsiasi valore, ma è necessario aggiungere parentesi quadre nidificate per entrare in ogni livello della matrice.

Conclusioni

Tutte le istruzioni di cui sopra potrebbero essere molto utili per gli utenti che si avvicinano per la prima volta a PowerShell, ma sono stati attentamente scelti come un modo per imparare il linguaggio. Combinando le diverse tecniche, è possibile creare script molto efficaci per automatizzare molte delle attività più frequenti e più dispendiose in termini di tempo che si svolgono con PowerShell.

Queste competenze ti aiuteranno anche ad andare oltre PowerShell. Molti dei linguaggi più comuni utilizzati per la gestione della sicurezza informatica, come NetCat e Nmap, utilizzano molti degli stessi principi di PowerShell. Quindi, usare PowerShell per migliorare la tua sicurezza informatica è un ottimo modo per imparare a proteggere i tuoi sistemi più in generale.