Les variables sont la structure de données la plus élémentaire dans tout type de codage^{(any type of coding)} . Mais des variables uniques sont à peine suffisantes pour la plupart des objectifs, en particulier lorsqu'il s'agit d'algorithmes plus complexes.

C'est là qu'interviennent les tableaux. Qu'il s'agisse de C++ ou de Python , les tableaux sont présents dans tous les langages de programmation sous une forme ou une autre. Mais qu'en est-il de Windows PowerShell ? Comment fonctionnent les baies PowerShell ? Comment les utilisez-vous ? Quelle est leur syntaxe ? Découvrons-le.

Baies PowerShell 101

En termes simples^(Simply) , un tableau n'est qu'un ensemble structuré de variables. L'idée est d'éliminer les tracas liés au suivi de dizaines de noms en regroupant les variables associées dans un ensemble numéroté.

Dans PowerShell , vous pouvez créer une variable en ajoutant le symbole $ au début d'un nom de variable. Par exemple:

$prime = 13

La variable peut contenir n'importe quel type de données, des nombres aux chaînes. Il vous suffit d'utiliser des guillemets doubles ou simples pour spécifier une chaîne.

$name = “Levin”

Maintenant, pour créer un nouveau tableau, affectez simplement plusieurs valeurs à la même variable, séparées par des virgules. Comme ça:

$week = “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”

Certaines personnes préfèrent transtyper explicitement une variable dans un tableau pour éviter toute confusion, bien que cela ne soit pas nécessaire. Pour ce faire, mettez les valeurs entre parenthèses précédées du symbole @.

$week = @(“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”)

Cela est généralement pratique lorsque vous essayez de placer la sortie d'autres commandes dans un tableau, où vous ne pouvez pas les écrire manuellement dans le bon format.

Création d'un tableau

Nous avons déjà vu la méthode la plus courante de création d'un tableau. Mais selon la situation, il existe d'autres moyens qui pourraient être plus appropriés. Par exemple, si vous souhaitez créer un tableau contenant une plage de nombres, vous pouvez utiliser l'opérateur de plage :

$digits = (0..9)

Cela créera un tableau de tous les dix chiffres de zéro à neuf. Vous pouvez également initialiser un tableau vide, au cas où vous voudriez juste un endroit pour stocker les valeurs plus tard.

$values = @()

Plusieurs^(Multiple) baies peuvent même être imbriquées les unes dans les autres, bien que ce type d'utilisation puisse devenir déroutant très rapidement.

$coordinates = @(
    (5, 10, 23),
    (11, 7, 16)
)

Par défaut, un tableau peut stocker n'importe quel type de variable, qu'il s'agisse de nombres, de chaînes ou d'un mélange des deux. Mais vous pouvez définir explicitement un type au cas où vous voudriez limiter les valeurs qui y sont entrées. Par exemple:

[int[]] $numbers = 2,3,4,5

De cette façon, le tableau ne peut contenir que des entiers. Tenter de lui affecter tout autre type de valeur renverra une erreur. Cela peut être utile pour éviter les erreurs simples pour les tableaux fonctionnant exclusivement avec des valeurs numériques, car la saisie d'une chaîne dans une variable à utiliser dans les calculs créera des problèmes.

Accéder aux baies

Jusqu'à présent, nous avons vu plusieurs méthodes pour créer des tableaux contenant différents types de données. Mais comment fait-on pour accéder à ces données ?

Les tableaux PowerShell^(PowerShell) utilisent le même format que celui utilisé par d'autres langages de programmation. Chaque variable de tableau est accessible par son numéro d'index. Par exemple:

$var = $numbers[5]

Cela copiera la valeur stockée dans l'index cinq du tableau $numbers dans la variable $varNotez que les indices de tableau commencent à compter à partir de 0, donc le premier élément est accessible avec zéro.

Si nous devions afficher ceci, par exemple :

“$days[2]”

Nous aurons mercredi, pas mardi.

Vous pouvez également utiliser cette même méthode pour modifier ces valeurs. Par exemple, la commande suivante changera le deuxième élément du tableau en zéro :

$numbers[1] = 0

Vous pouvez également ajouter plus d'éléments à un tableau existant au lieu de modifier les valeurs des entrées actuelles simplement en les ajoutant comme une expression arithmétique.

$names += “Johny”

Cette méthode peut également être utilisée pour ajouter plusieurs entrées à la fois, voire des tableaux entiers.

$names += “Charlie, Liam, Teresa”

$names += $surnames

La méthode séparée par des virgules est également valable pour accéder à plusieurs éléments de tableau. La saisie de this, par exemple, stocke les cinq premiers éléments de $days dans $weekdays .

$weekdays = $days[0,1,2,3,4]

Itérer dans les tableaux

Accéder manuellement à des éléments particuliers d'un tableau est bien beau, mais si vous souhaitez effectuer des actions sur l'ensemble du contenu d'un tableau, cela peut devenir fastidieux. Une approche plus élégante consiste à utiliser une boucle For.

Les boucles for peuvent parcourir systématiquement tous les éléments d'un tableau, traitant chaque valeur selon les instructions. Voici comment vous pouvez construire une telle boucle :

For ($i = 0 ; $i -lt $days.Length ; $i++){
    $days[$i]}

La fonction array.Length renvoie la taille du tableau, qui correspond essentiellement au nombre d'éléments qu'il contient. Cela peut être connecté au paramètre d'expression de test d'une boucle For pour itérer de manière exhaustive sur tous les éléments.

La boucle Foreach et la boucle Foreach -object peuvent faire la même chose avec un script PowerShell encore plus léger.^(PowerShell)

Foreach ($day in $days){
    $day}

Cela vous évite d'avoir à déterminer la taille du tableau, laissant les détails à PowerShell à gérer.

Quand devriez-vous utiliser des tableaux PowerShell^{(PowerShell Arrays)}

La plus grande source de bogues dans un script complexe est les variables mal référencées. Cela se produit en raison de la présence d'un grand nombre de variables nommées de manière unique, ce qui rend difficile la mémorisation de leur objectif.

La solution la plus simple à ce problème consiste à utiliser les tableaux de manière intensive. Toutes les variables liées d'une manière ou d'une autre peuvent être affectées à un seul tableau et accessibles via leurs numéros d'index.

Le principal cas d'utilisation de Microsoft PowerShell^{(Microsoft PowerShell’s)} est l'automatisation, et les baies y jouent un rôle central. Les objets renvoyés par les applets de commande PowerShell peuvent être stockés dans des tableaux et itérés. Cela permet d'effectuer automatiquement des tâches séquentielles, ce qui simplifie considérablement l'administration du système.

PowerShell Arrays: How to Create and Use Them

Variаbles are the most basic data structure in any type of coding. But single variables are hardly sufficient for most purposes, especially when dealing with more complex algorithms.

That’s where arrays come in. Be it C++ or Python, arrays are present in every programming language in some form. But what about Windows PowerShell? How do PowerShell arrays work? How do you use them? What is their syntax? Let’s find out.

PowerShell Arrays 101

Simply speaking, an array is just a structured collection of variables. The idea is to eliminate the hassle of keeping track of dozens of names by collapsing related variables into a numbered set.

In PowerShell, you can create a variable by prepending the $ symbol to a variable name. For example:

$prime = 13

The variable can contain any data type, from numbers to strings. You just need to use double or single quotes to specify a string.

$name = “Levin”

Now to create a new array, simply assign multiple values to the same variable, separated by commas. Like this:

$week = “Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”

Some people prefer to explicitly cast a variable into an array to avoid confusion, though that isn’t necessary. To do this, put the values into parentheses prefaced with the @ symbol.

$week = @(“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”)

This usually comes in handy when trying to put the output of other commands into an array, where you cannot manually write them in the correct format.

Creating an Array

We’ve already seen the most common method of creating an array. But depending on the situation, there are other ways that might be more suitable. For example, if you want to create an array that contains a range of numbers, you can use the range operator:

$digits = (0..9)

This will create an array of all the ten digits from zero to nine. You can also initialize an empty array, in case you just want a place to store values later.

$values = @()

Multiple arrays can even be nested into one another, though this type of usage can get confusing very fast.

$coordinates = @(
    (5, 10, 23),
    (11, 7, 16)
)

By default an array can store any variable type, be it numbers, strings, or a mix of both. But you can explicitly define a type in case you want to limit the values put in it. For example:

[int[]] $numbers = 2,3,4,5

This way, the array can only hold integers. Attempting to assign any other type of value to it will return an error. This can be useful to prevent simple errors for arrays exclusively working with numeric values, since entering a string into a variable to be used in calculations will create issues.

Accessing Arrays

So far we have seen multiple methods for creating arrays containing various types of data. But how do you go about accessing this data?

PowerShell arrays use the same format used by other programming languages. Each array variable can be accessed by its index number. For example:

$var = $numbers[5]

This will copy the value stored in the index five of the $numbers array in the $var variable. Note that array indices start counting from 0, so the first item is accessed with zero.

If we were to output this, for example:

“$days[2]”

We will get Wednesday, not Tuesday.

You can use this same method to modify these values as well. For example, the following command will change the second element of the array to zero:

$numbers[1] = 0

You can also add more elements to an existing array instead of changing the values of current entries just by adding them like an arithmetic expression.

$names += “Johny”

This method can be used to add multiple entries at once too, or even entire arrays.

$names += “Charlie, Liam, Teresa”

$names += $surnames

The comma-separated method holds for accessing multiple array elements too. Entering this, for example, stores the first five elements of $days in $weekdays.

$weekdays = $days[0,1,2,3,4]

Iterating Through Arrays

Manually accessing particular elements of an array is well and good, but if you want to perform actions on the entire contents of an array, it can get tedious. A more elegant approach is to use a For loop.

For loops can systematically go through all the elements of an array, processing each value according to instructions. This is how you can construct such a loop:

For ($i = 0 ; $i -lt $days.Length ; $i++)
{
    $days[$i]
}

The array.Length function returns the size of the array, which is basically the number of elements in it. This can be plugged into a For loop’s test expression parameter to comprehensively iterate over all the elements.

The Foreach loop and the Foreach-object loop can do the same with an even leaner PowerShell script.

Foreach ($day in $days)
{
    $day
}

This saves you the effort of determining the array’s size, leaving the details for PowerShell to handle.

When Should You Use PowerShell Arrays

The biggest source of bugs in a complex script is incorrectly referenced variables. This happens due to the presence of a large number of uniquely named variables, which makes it difficult to remember their purpose.

The simplest fix for this issue is to use arrays extensively. All variables related in some manner can be assigned to a single array and accessed through their index numbers.

Microsoft PowerShell’s prime use case is automation, and arrays play a pivotal role in that. The objects returned by PowerShell cmdlets can be stored into arrays and iterated over. This allows sequential tasks to be performed automatically, greatly simplifying system administration.

Related posts

• Comment créer et utiliser une clé USB de récupération Windows 11

• Comment faire du tout Delete ou créer une tâche planifiée avec PowerShell dans Windows 11

• Pourquoi mon PC n'est-il pas compatible avec Windows 11? Use WhyNotWin11!

• Comment ajouter le menu contextuel Créer un point de restauration dans Windows 11

• PowerShell vs invite de commande : avantages et inconvénients

• Activer ou désactiver le Wi-Fi et Ethernet adapter sur Windows 11

• Comment masquer Badges sur Taskbar Icons en Windows 11

• Comment vérifier si votre ordinateur peut exécuter Windows 11 PC Health Check tool

• Click ici pour entrer votre message de certification le plus récent dans Windows 11

• Comment activer ou désactiver Refresh Rate (Dynamic DRR) en Windows 11

• Comment ajuster Webcam Brightness dans Windows 11

• Comment accélérer Windows 10 et le faire tourner Start, Run, Shutdown faster

• Stop minimizing Windows Lorsqu'un moniteur est déconnecté sous Windows 11

• Comment changer Insider Channel sur Windows 11

• Comment changer Taskbar size sur Windows 11

• Comment activer ou désactiver Snap Layouts sur Windows 11

• Comment ouvrir Windows Tools en Windows 11

• Comment activer et utiliser TPM Diagnostics Tool dans Windows 11

• Comment s'inscrire de email account dans Mail app dans Windows 11

• Exigences système Windows 11: Feature-Wise Minimum Hardware