Madame Lelica

Les tableaux sont une caractéristique fondamentale de la plupart des langages de programmation. Ils sont une collection de valeurs ou d’objets et sont donc difficiles à éviter. Examinons de près les tableaux et tout ce qu’ils ont à offrir.

• Index de la Page
• qu’est Ce qu’un tableau?,match

qu’est Ce qu’un tableau?

je vais commencer par une description technique de base de ce que sont les tableaux et comment ils sont utilisés par la plupart des langages de programmation avant de passer aux autres façons dont PowerShell les utilise.

un tableau est une structure de données qui sert de collection de plusieurs éléments. Vous pouvez parcourir le tableau ou accéder à des éléments individuels à l’aide d’un index. Le tableau est créé séquentiel partie de la mémoire où chaque valeur est stockée juste à côté de l’autre.

je vais aborder chacun de ces détails au fur et à mesure.,

utilisation de base

parce que les tableaux sont une fonctionnalité de base de PowerShell, il existe une syntaxe simple pour travailler avec eux dans PowerShell.

Créer un tableau avec @()

Un tableau vide peut être créé à l’aide de @()

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

On peut créer un tableau et des semences avec des valeurs en les plaçant dans le @() parenthèses.

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

Ce tableau a 4 éléments. Lorsque nous appelons la variable$data, nous voyons la liste de nos éléments., S’il s’agit d’un tableau de chaînes, nous aurons une ligne par chaîne.

nous pouvons déclarer un tableau sur plusieurs lignes. La virgule est facultative dans ce cas et généralement omise.

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

je préfère déclarer mes tableaux sur plusieurs lignes comme ça. Non seulement il devient plus facile à lire lorsque vous avez plusieurs éléments, mais il est également plus facile de comparer aux versions précédentes lors de l’utilisation du contrôle de source.,

autre syntaxe

Il est communément admis que@() est la syntaxe pour créer un tableau, mais les listes séparées par des virgules fonctionnent la plupart du temps.

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

l’Écriture de Sortie pour créer des tableaux

Un peu de fraîcheur truc à noter est que vous pouvez utiliser Write-Output pour créer rapidement des chaînes de caractères dans la console.

 $data = Write-Output Zero One Two Three

C’est pratique parce que vous n’avez pas à mettre des guillemets autour des chaînes lorsque le paramètre accepte les chaînes., Je ne ferais jamais cela dans un script mais c’est un jeu juste dans la console.

Accès aux articles

Maintenant que vous avez un tableau avec des objets, vous pouvez accéder et mettre à jour ces éléments.

Offset

pour accéder à des éléments individuels, nous utilisons les crochets avec une valeur de décalage commençant à 0. C’est de cette façon nous obtenons le premier élément de notre tableau:

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

La raison pour laquelle nous utilisons zéro ici, c’est parce que le premier élément est au début de la liste, de sorte que nous utilisons un décalage de 0 articles pour l’obtenir., Pour accéder au deuxième élément, nous devrions utiliser un décalage de 1 pour ignorer le premier élément.

 PS> $data One

Cela signifie que le dernier élément est à l’offset 3.

 PS> $data Three

Index

Maintenant, vous pouvez voir pourquoi j’ai choisi les valeurs que j’ai fait pour cet exemple. J’ai présenté cela comme un décalage, parce que c’est ce qu’il est vraiment, mais ce décalage est plus communément appelé un index. Un index qui commence à 0. Pour le reste de cet article, j’appellerai le décalage un index.,

indice Spécial astuces

Dans la plupart des langues, vous ne pouvez spécifier qu’un seul numéro de l’index et vous obtiendrez un seul élément. PowerShell est beaucoup plus souple. Vous pouvez utiliser plusieurs index à la fois. En fournissant une liste d’Index, nous pouvons sélectionner plusieurs éléments.

 PS> $data Zero Two Three

Les articles seront retournés en fonction de l’ordre des indices fournis. Si vous dupliquez un index, vous obtiendrez l’élément deux fois.,

 PS> $data Three Zero Three

Nous pouvons spécifier une séquence de nombres avec la construction dans le .. opérateur.

 PS> $data One Two Three

Cela fonctionne dans le sens inverse aussi.

 PS> $data Three Two One

Vous pouvez utiliser negitive valeurs de l’indice de décalage à partir de la fin. Donc, si vous avez besoin du dernier élément de la liste, vous pouvez utiliser -1.,

 PS> $data Three

en Dehors des limites

Dans la plupart des langues, si vous essayez d’accéder à un index d’un élément qui est passé à la fin du tableau, vous obtenez un certain type d’erreur ou une exception. PowerShell ne vous donnera rien en silence.

 PS> $null -eq $data True

Ne peut pas indexer dans un null, array

Si votre variable est $null et vous essayez de l’indexer comme un tableau, vous recevrez un System.Management.Automation.RuntimeException exception avec le message Cannot index into a null array.,

 PS> $empty = $null SP> $empty Error: Cannot index into a null array.

Donc, assurez-vous que vos tableaux ne sont pas de $null avant d’essayer d’accéder à des éléments à l’intérieur d’eux.

Count

les Tableaux et d’autres collections ont un nombre biens que vous indique le nombre d’éléments dans le tableau.

 PS> $data.count 4

PowerShell 3.0 ajouté un compte à la propriété pour la plupart des objets. vous pouvez avoir un seul objet et il devrait vous donner un nombre de 1.,

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

Même $null a une propriété count sauf qu’il retourne 0.

 PS> $null.count 0

Il y a quelques pièges ici que je vais revoir quand je couvre la vérification de $null ou des tableaux vides plus tard dans cet article.

Désactivé par l’une des erreurs

Une erreur de programmation courantes est créé à car les tableaux commencent à l’indice 0. Une erreur off by one peut être introduite de deux manières très courantes.,

la première consiste à penser mentalement que vous voulez le 2ème élément et à utiliser un index de 2 et à obtenir vraiment le troisième élément. Ou en pensant que vous avez des éléments4 et que vous voulez le dernier élément, vous utiliserez donc simplement la taille pour accéder au dernier élément.

 $data

PowerShell est parfaitement heureux de vous permettre de le faire et de vous donner exactement ce que l’élément à l’indice 4, $null. Vous devriez utiliser $data.count - 1 ou le -1 que nous avons appris ci-dessus.,

 PS> $data Three

C’est là que vous pouvez utiliser la balise -1 index pour obtenir le dernier élément.

 PS> $data Three

Lee Dailey aussi m’a fait remarquer que l’on peut utiliser $data.GetUpperBound(0) pour obtenir le max de numéro d’index.

 PS> $data.GetUpperBound(0) Three

La deuxième façon la plus commune est lors d’une itération de la liste et juste de ne pas s’arrêter au bon moment. Je reviendrai sur ce point lorsque nous parlerons de l’utilisation de la boucle for.,

mise à jour des éléments

Nous pouvons utiliser le même index pour mettre à jour les éléments existants dans le tableau. Cela nous donne un accès direct à la mise à jour des éléments individuels.

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

Si nous essayons de mettre à jour un élément qui est passé le dernier élément, alors nous obtenons un Index was outside the bounds of the array. erreur.

je reviendrai plus tard quand je parlerai de la façon de faire un tableau plus grand.

itération

à un moment donné, vous devrez parcourir ou itérer la liste entière et effectuer une action pour chaque élément du tableau.,

Pipeline

Les Tableaux et le pipeline PowerShell sont destinés l’un à l’autre. C’est l’un des moyens les plus simples de traiter ces valeurs. Lorsque vous transmettez un tableau à un pipeline, chaque élément du tableau est traité individuellement.

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

Si vous n’avez pas vu $PSItem avant, il suffit de savoir que c’est la même chose que $_. Vous pouvez utiliser l’un ou l’autre car ils représentent tous deux l’objet en cours dans le pipeline.,

boucle ForEach

Le ForEach boucle fonctionne bien avec les collections. À l’aide de la syntaxe suivante: foreach ( <variable> in <collection> )

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

ForEach méthode

j’ai tendance à l’oublier, mais elle fonctionne bien pour les opérations simples. PowerShell vous permet d’appeler .ForEach() sur une collection.

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

Le .foreach() prend un paramètre qui est un bloc de script. Vous pouvez supprimer les parenthèses et simplement fournir le bloc de script.,

 $data.foreach{"Item "}

C’est moins connue de la syntaxe, mais il fonctionne tout de même. Cette méthodeforeach a été ajoutée dans PowerShell 4.0.

for loop

la bouclefor est fortement utilisée dans la plupart des autres langues mais vous ne la voyez pas beaucoup dans PowerShell. Quand vous le voyez, il est souvent dans le contexte de la marche d’un tableau.

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

La première chose à faire est d’initialiser un $index de 0., Ensuite, nous ajoutons la condition que le $index doit être $data.count. Enfin, nous spécifions que chaque fois que nous bouclons que je dois augmenter l’index par 1. Dans ce cas, $index++ est l’abréviation de $index = $index + 1.

chaque fois que vous utilisez une bouclefor, portez une attention particulière à la condition. J’ai utilisé $index -lt $data.count ici. Il est très facile d’obtenir la condition légèrement fausse pour obtenir un off par une erreur dans votre logique., En utilisant $index -le $data.count ou $index -lt ($data.count - 1) sont toujours si légèrement faux. Cela entraînerait votre résultat à traiter trop ou trop peu d’éléments. C’est le classique par une erreur.

Commutateur de boucle

C’est celui qui est très facile à oublier. Si vous fournissez un tableau à une instruction switch, il correspondra à chaque élément du tableau.

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

Cela va produire ce résultat:

 Tick Tock Tick Tock

Il y a beaucoup de choses cool comme ce que nous pouvons faire avec l’instruction switch., J’ai un autre article consacré à cela.

• Tout ce que vous avez toujours voulu savoir sur l’instruction switch

mise à jour des valeurs

lorsque votre tableau est une collection de chaînes ou d’entiers (types de valeurs), vous voudrez parfois mettre à jour les valeurs du tableau lorsque vous les parcourez. La plupart des boucles ci-dessus utilisent une variable dans la boucle qui contient une copie de la valeur. Si vous mettez à jour cette variable, la valeur d’origine du tableau n’est pas mise à jour.

l’exception à cette instruction est la bouclefor., Si vous souhaitez parcourir un tableau et mettre à jour les valeurs à l’intérieur, la boucle for est ce que vous recherchez.

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

Cet exemple prend une valeur par index, fait quelques modifications, puis utilise ce même indice pour l’affecter en retour.

les Tableaux d’Objets

jusqu’à présent, la seule chose que nous avons placées dans un tableau est un type de valeur, mais les tableaux peuvent également contenir des objets.

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

de Nombreux applets de commande de retour des collections d’objets comme des tableaux lorsque vous affecter à une variable.,

 $processList = Get-Process

Toutes les fonctions de base dont nous avons déjà parlé encore s’appliquer à des tableaux d’objets avec quelques détails, qui mérite d’être souligné.

accès aux propriétés

Nous pouvons utiliser un index pour accéder à un élément individuel dans une collection tout comme avec les types de valeur.

 PS> $data FirstName LastName ----- ---- Kevin Marquette

Nous pouvons accéder et mettre à jour les propriétés directement.,

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

les propriétés de la Matrice

Normalement, il faudrait énumérer toute la liste de ce genre pour accéder à toutes les propriétés:

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

Ou en utilisant la balise Select-Object -ExpandProperty applet de commande.

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

Mais PowerShell nous offre la possibilité de demander LastName directement. PowerShell les énumérera tous pour nous et nous donnera une liste propre.,

 PS> $data.LastName Marquette Doe

L’énumération qui se passe encore, mais nous ne voyons pas la complexité derrière elle.

Où le filtrage des Objets d’

C’est là Where-Object vient de nous pourrez filtrer et sélectionner ce que nous voulons de la matrice basée sur les propriétés de l’objet.

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

On peut écrire la même requête de ce genre pour obtenir le FirstName nous sommes à la recherche pour.,

 $data | Where FirstName -eq Kevin

Où()

les Tableaux ont un Where() méthode qui vous permet de spécifier une balise scriptblock pour le filtre.

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

Cette fonctionnalité a été ajoutée dans PowerShell 4.0.

mise à Jour des objets dans les boucles

Avec des types valeur, la seule façon de mettre à jour le tableau est d’utiliser une boucle for car nous avons besoin de connaître l’indice de remplacer la valeur. Nous avons plus d’options avec les objets car ce sont des types de référence., Voici un exemple rapide:

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

Cette boucle est de la marche chaque objet dans le $data array. Étant donné que les objets sont des types de référence, la variable$person référence exactement le même objet qui se trouve dans le tableau. Donc, les mises à jour de ses propriétés mettront à jour l’original.

Vous ne pouvez toujours pas remplacer l’objet entier de cette façon. Si vous essayez d’affecter un nouvel objet à la variable $person, vous mettez à jour la référence de variable vers autre chose qui ne pointe plus vers l’objet d’origine dans le tableau., Cela ne fonctionnera pas comme vous attendrait:

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

les Opérateurs

Les opérateurs en PowerShell également de travailler sur les tableaux. Certains d’entre eux fonctionnent légèrement différemment.

-join

Le -join opérateur est le plus évident, donc nous allons regarder en premier. J’aime l’opérateur-join et l’utilise souvent. Il joindra tous les éléments du tableau avec un caractère ou une chaîne que vous spécifiez.,

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

l’Une des caractéristiques que j’aime à propos de la balise -join opérateur est qu’il gère les éléments simples.

 PS> 1 -join '-' 1

je l’utiliser à l’intérieur de la journalisation et de messages détaillés.

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

-join $array

Voici une astuce que Lee Dailey me l’a fait remarquer., Si jamais vous voulez joindre le tout sans un délimiteur, au lieu de faire ceci:

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

Vous pouvez utiliser -join le tableau comme paramètre avec pas de préfixe. Jetez un oeil à cet exemple pour voir que je parle.

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

de remplacer et d’-split

Les autres opérateurs comme -replace et -split va exécuter sur chaque élément d’un tableau. Je ne peux pas dire que je les ai déjà utilisés de cette façon, Mais voici un exemple.,

 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

-contient

Le -contains opérateur vous permettra de vérifier un tableau de valeurs pour voir si elle contient une valeur spécifiée.

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

en

si vous avez une valeur unique que vous souhaitez vérifier correspond à l’un de plusieurs valeurs, vous pouvez utiliser la balise -in opérateur. La valeur serait sur la gauche et le tableau sur le côté droit de l’opération.,

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

Cela peut coûter cher si la liste est grande. J’utiliserai souvent un modèle regex si je vérifie plus de 4-5 valeurs.

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

-eq et -ne

l’Égalité et les tableaux peuvent se compliquer. Lorsque le tableau est sur le côté gauche, tous sont comparés. Au lieu de renvoyer True, il renverra l’objet qui correspond.,

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

Lorsque vous utilisez la balise -ne opérateur, nous aurons toutes les valeurs qui ne sont pas à la hauteur de notre valeur.

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

Lorsque vous utilisez cette option dans une if() déclaration, la valeur renvoyée est un True valeur. Si aucune valeur n’est renvoyée, il s’agit d’une valeur False. Ces deux instructions suivantes seront évaluées à True.,

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

je vais revoir tout cela dans un moment où l’on parle de test pour la $null.

match

Le -match opérateur va tenter de faire correspondre à chaque élément de la collection.

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

Lorsque vous utilisez la balise -match avec une seule valeur, une variable spéciale $Matches est renseigné avec le match d’info. Ce n’est pas le cas lorsqu’un tableau est traité de cette façon.

nous pouvons adopter la même approche avecSelect-String.,

 $servers | Select-String SQL

j’ai regarder de plus près Select-String,-match et le $matches variable dans un autre post appelé Les nombreuses façons d’utiliser les regex.

$null ou vide

de Test de $null ou des tableaux vides peut être délicat. Voici les pièges courants avec des tableaux.

en un coup d’œil, cette déclaration semble fonctionner.

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

Mais je suis juste allé sur la façon dont -eq vérifie chaque élément du tableau., Donc on peut avoir un tableau de plusieurs éléments avec un seul $valeur null et il serait d’évaluer la $true

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

C’est pourquoi il est recommandé de placer la balise $null sur le côté gauche de l’opérateur. Cela rend ce scénario un non-problème.

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

$null array n’est pas la même chose comme un tableau vide. Si vous savez que vous avez un tableau, vérifiez le nombre d’objets qu’il contient., Si le tableau est de $null, le comte sera 0.

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

Il y a un piège, à regarder ici. Vous pouvez utiliser la balise count même si vous avez un seul objet, à moins que cet objet est un PSCustomObject. C’est un bug qui est corrigé dans PowerShell 6.1. C’est une bonne nouvelle, mais beaucoup de gens sont toujours sur 5.1 et doivent faire attention.

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

Si vous êtes toujours sur PowerShell 5.,1, vous pouvez envelopper l’objet dans un tableau avant de vérifier le nombre pour obtenir un nombre précis.

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

Pour pleinement jouer la sécurité, vérifier $null, puis vérifier le décompte.

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

Tous -eq

j’ai récemment vu quelqu’un demander comment vérifier que toutes les valeurs dans un tableau correspond à une valeur donnée. Reddit utilisateur /u/bis a cette solution intelligente qui vérifie les valeurs incorrectes, puis retourne le résultat.,

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

Ajouter à des tableaux

À ce stade, vous commencez à vous demander comment ajouter des éléments à un tableau. La réponse rapide est que vous ne pouvez pas. un tableau est une taille fixe en mémoire. Si vous avez besoin de le développer ou d’y ajouter un seul élément, vous devez créer un nouveau tableau et copier toutes les valeurs de l’ancien tableau. Cela semble coûteux et comme beaucoup de travail, cependant, PowerShell cache la complexité de la création du nouveau tableau.

Array plus

On peut utiliser l’opérateur d’addition avec les tableaux pour créer un nouveau tableau., Donc, compte tenu de ces deux tableaux:

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

On peut ajouter à eux pour obtenir un nouveau tableau.

 PS> $first + $second Zero One Two Three

les Plus égal +=

Nous pouvons créer une nouvelle pile en place et ajouter un élément comme cela:

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

rappelez-vous Simplement que chaque fois que vous utilisez la balise += qui vous sont duplication et la création d’un nouveau tableau. Ce n’est pas un problème pour les petits ensembles de données, mais il évolue extrêmement mal.,

affectation de Pipeline

Vous pouvez affecter les résultats de n’importe quel pipeline dans une variable. Ce sera un tableau s’il contient plusieurs éléments.

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

Normalement, quand on pense à l’utilisation du pipeline, nous pensons à la typique PowerShell one-liners. Nous pouvons tirer parti du pipeline avec des instructionsforeach() et d’autres boucles. Donc, au lieu d’ajouter des éléments à un tableau dans une boucle, on peut déposer des éléments sur le pipeline.,

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

En attribuant les résultats de la balise foreach pour une variable, nous capturer tous les objets et créer un tableau unique.

types de tableau

par défaut, un tableau dans PowerShell est créé en tant que type]. Cela lui permet de contenir tout type d’objet ou de valeur. Cela fonctionne car tout est hérité du type PSObject.

Fortement typé tableaux

Vous pouvez créer un tableau de n’importe quel type en utilisant une syntaxe similaire., Lorsque vous créez un tableau fortement typé, il ne peut contenir que des valeurs ou des objets du type spécifié.

ArrayList

ajouter des éléments à un tableau est l’une de ses plus grandes limitations, mais il existe quelques autres collections vers lesquelles nous pouvons nous tourner pour résoudre ce problème.

leArrayList est généralement l’une des premières choses auxquelles nous pensons lorsque nous avons besoin d’un tableau plus rapide à utiliser. Il agit comme un tableau d’objets à chaque endroit où nous en avons besoin, mais il gère l’ajout d’éléments rapidement.

Voici comment nous créer un ArrayList et l’ajout d’éléments.,

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

Nous sommes à l’appel .Net pour obtenir ce type. Dans ce cas, nous utilisons le constructeur par défaut pour le créer. Ensuite, nous appelons la méthodeAdd pour y ajouter un élément.

la raison pour laquelle j’utilise au début de la ligne est de supprimer le code de retour. Certains appels. net le feront et peuvent créer une sortie inattendue.

Si les seules données que vous avez dans votre tableau sont des chaînes, alors jetez également un œil à l’utilisation de StringBuilder., C’est presque la même chose mais a quelques méthodes qui sont juste pour traiter les chaînes. Le StringBuilder est spécialement conçu pour les performances.

• concaténer des chaînes en utilisant StringBuilder

Il est très courant de voir des gens passer à ArrayList à partir de tableaux. Mais cela vient d’une époque où C# n’avait pas de support Générique., Le ArrayList est déprécié dans le support de la List

liste générique

un type générique est un type spécial en C# qui définit une classe généralisée et l’utilisateur spécifiera les types de données qu’il utilisera lors de sa création. Donc, si vous voulez une liste de nombres ou de chaînes, vous devez définir que vous voulez une liste de types int ou string.

Voici comment créer une liste pour les chaînes.

 $mylist = ]::new()

Ou une liste de nombres.,

 $mylist = ]::new()

Nous pouvons jeter un tableau existant pour une liste comme ça, sans la création de l’objet premier:

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

Nous pouvons raccourcir la syntaxe un peu avec la balise using namespace déclaration en PowerShell 5 et plus récent. L’instructionusing doit être la première ligne de votre script. En déclarant un espace de noms, PowerShell vous permettra de le laisser hors des types de données lorsque vous les référencerez.,

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

Cela fait de la balise List beaucoup plus utilisable.

Vous avez une méthode similaireAdd à votre disposition. Contrairement à ArrayList, il n’y a pas de valeur de retour sur la méthode Add donc nous n’avons pas besoin de void.

 $myList.Add(10)

Et on peut toujours accéder à des éléments comme les autres tableaux.,

 PS> $myList 10

Liste

Vous pouvez avoir une liste de tout type, mais quand vous ne connaissez pas le type des objets, vous pouvez utiliser ] pour les contenir.

 $list = ]::new()

Remove()

Le ArrayList et le générique List à la fois le soutien de la suppression d’éléments de la collection.

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

Lorsque l’on travaille avec des types valeur, il va supprimer la première de la liste., Vous pouvez l’appeler encore et encore pour continuer à supprimer cette valeur. Si vous avez des types de référence, vous devez fournir l’objet que vous souhaitez supprimer.

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

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

La suppression de la méthode renvoie true si elle a été en mesure de trouver et de supprimer l’élément de la collection.

Plus de collections

Il existe de nombreuses autres collections qui peuvent être utilisés, mais ce sont les bons génériques tableau de remplacement., Si vous souhaitez en savoir plus sur ces options, jetez un oeil à cet essentiel que Mark Kraus a mis en place.

Autres nuances

Maintenant que j’ai couvert toutes les grandes fonctionnalités, voici quelques autres choses que je voulais mentionner avant de conclure.

tableaux pré-dimensionnés

j’ai mentionné que vous ne pouvez pas changer la taille d’un tableau une fois qu’il est créé. Nous pouvons créer un tableau d’une taille prédéterminée en l’appelant avec le constructeur new($size).,

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

Multipliant les tableaux

Un intéressant petit truc, c’est que vous pouvez multiplier une matrice par un nombre entier.

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

Initialiser à 0

Un scénario commun, c’est que vous souhaitez créer un tableau avec tous les zéros. Si vous n’avez que des entiers, un tableau fortement typé d’entiers sera par défaut à tous les zéros.

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

On peut utiliser de la multiplication des astuce pour ce faire de trop.,

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

La bonne chose à propos de la multiplication des truc, c’est que vous pouvez utiliser n’importe quelle valeur. Donc, si vous préférez avoir 255 comme valeur par défaut, ce serait un bon moyen de le faire.

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

les tableaux Imbriqués

Un tableau à l’intérieur du tableau est appelé un tableau imbriqué. Je ne les utilise pas beaucoup dans PowerShell mais je les ai plus utilisés dans d’autres langues. Envisagez d’utiliser un tableau de tableaux lorsque vos données s’inscrivent dans un motif de type grille.

Voici deux façons de créer un 2 dimensions tableau.,

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

La virgule est très important dans ces exemples. J’ai donné un exemple précédent d’un tableau normal sur plusieurs lignes où la virgule était facultative. Ce n’est pas le cas avec un tableau multidimensionnel.

la façon dont nous utilisons la notation d’index change légèrement maintenant que nous avons un tableau imbriqué. En utilisant le $data ci-dessus, voici comment nous pourrions accéder à la valeur 3.

 PS> $outside = 0 PS> $inside = 2 PS> $data 3

Ajouter un ensemble de support pour chaque niveau de la matrice de nidification., Le premier ensemble de crochets est pour le tableau le plus externe, puis vous vous frayez un chemin à partir de là.

Write-Output-NoEnumerate

PowerShell aime déballer ou énumérer des tableaux. C’est un aspect fondamental de la façon dont PowerShell utilise le pipeline, mais il y a des moments où vous ne voulez pas que cela se produise.

je pipe généralement des objets versGet-Member pour en savoir plus à leur sujet. Lorsque j’y conduis un tableau, il est déballé et Get-Member voit les membres du tableau et non le tableau réel.,

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

Pour éviter que de déballer le tableau, vous pouvez utiliser Write-Object -NoEnumerate.

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

j’ai une deuxième façon de faire, ce qui est plus d’un hack (et j’essaie d’éviter les bidouilles de ce genre). Vous pouvez placer une virgule devant le tableau avant de vous diriger.

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

retourne un tableau

ce Désemballage des tableaux se produit également lorsque vous affichez ou renvoyez des valeurs d’une fonction., Vous pouvez toujours obtenir un tableau si vous affectez la sortie à une variable, ce n’est donc pas un problème courant.

le problème est que vous aurez un nouveau tableau. Si c’est jamais un problème, vous pouvez utiliser Write-Output -NoEnumerate $array ou return ,$array pour le contourner.

autre Chose?

je sais que c’est beaucoup à prendre dans. J’espère que vous apprendrez quelque chose de cet article chaque fois que vous le lirez et qu’il s’avérera être une bonne référence pour vous pendant longtemps., Si vous avez trouvé cela utile, veuillez le partager avec d’autres personnes qui, selon vous, en tireront de la valeur.

à partir de là, je vous recommande de consulter un article similaire que j’ai écrit sur les hashtables.