Wie man ein leeres Array von Arrays in PowerShell erstellt

1. Verständnis von Arrays in PowerShell
2. So erstellen Sie ein leeres Array von Arrays in PowerShell mit dem @() Array-Unterausdrucksoperator
3. So erstellen Sie ein leeres Array von Arrays in PowerShell mit dem New-Object Cmdlet und der System.Collections.ArrayList Klasse
4. So erstellen Sie ein leeres Array von Arrays in PowerShell mit der @{} Hashtable
5. Fazit

PowerShell bietet mit seinen vielseitigen Skriptmöglichkeiten mehrere Möglichkeiten, Arrays zu erstellen und zu manipulieren.

Eine häufige Anforderung besteht darin, ein leeres Array zu erstellen, das andere Arrays aufnehmen kann. Dieses Szenario tritt häufig auf, wenn Sie Daten in einer multidimensionalen Struktur organisieren müssen.

In diesem Artikel werden wir verschiedene Methoden erkunden, um ein leeres Array von Arrays in PowerShell zu erstellen.

Verständnis von Arrays in PowerShell

Bevor wir uns mit der Erstellung eines leeren Arrays von Arrays befassen, ist es wichtig, die Grundlagen von Arrays in PowerShell zu verstehen. Ein Array in PowerShell ist eine Datenstruktur, die eine Sammlung von Elementen speichert.

Diese Elemente können jeden Datentyp haben, und Arrays können dynamisch angepasst werden, um bei Bedarf neue Elemente aufzunehmen. PowerShell bietet mehrere Möglichkeiten, mit Arrays zu arbeiten, einschließlich der Erstellung, des Zugriffs auf und der Modifikation ihrer Inhalte.

Hier ist ein einfaches Beispiel zur Erstellung eines Arrays in PowerShell:

$myArray = @(1, 2, 3, 4, 5)
$myArray

In diesem Beispiel wird $myArray ein Array zugewiesen, das fünf Ganzzahlen enthält.

Ausgabe:

In PowerShell können Arrays Elemente jeden Typs enthalten, einschließlich anderer Arrays. Ein Array von Arrays, auch bekannt als gezacktes Array, ist eine Datenstruktur, die aus mehreren Arrays besteht, wobei jedes Element des Hauptarrays ein anderes Array enthält.

Diese Struktur ermöglicht es Ihnen, heterogene Daten in einem mehrdimensionalen Format zu speichern, was das Verwalten und den Zugriff auf Elemente basierend auf unterschiedlichen Kriterien erleichtert.

Arrays in PowerShell sind nullbasiert, was bedeutet, dass das erste Element mit dem Index 0, das zweite Element mit dem Index 1 usw. zugegriffen wird. PowerShell-Arrays können dynamisch vergrößert werden, was Flexibilität beim Verwalten von Daten ermöglicht.

So erstellen Sie ein leeres Array von Arrays in PowerShell mit dem @() Array-Unterausdrucksoperator

Der @() Array-Unterausdrucksoperator ist ein vielseitiges Werkzeug in PowerShell, das für verschiedene Array-Operationen, einschließlich der Erstellung leerer Arrays, verwendet werden kann. Wenn er verwendet wird, um ein leeres Array von Arrays zu erstellen, wird ein Array-Container initialisiert, der in der Lage ist, andere Arrays als seine Elemente zu halten.

Durch die Verwendung dieses Operators zusammen mit dem Komma ,, um Elemente zu trennen, können wir eine Array-Struktur erstellen, bei der jedes Element selbst ein Array ist.

Sehen wir uns ein Code-Beispiel an, um zu veranschaulichen, wie man ein leeres Array von Arrays mit dem @() Array-Unterausdrucksoperator erstellt.

$arrayOfArrays = @()

Hier initialisieren wir ein leeres Array namens $arrayOfArrays mit dem @() Array-Unterausdrucksoperator. Dies erstellt einen leeren Array-Container, der in der Lage ist, andere Arrays aufzunehmen.

Da keine Elemente innerhalb des @() Operators bereitgestellt werden, ist das resultierende Array leer.

Hinzufügen von Arrays zum leeren Array

Sobald Sie das leere Array von Arrays erstellt haben, können Sie einzelne Arrays als Elemente hinzufügen. Dies geschieht normalerweise mit dem += Operator, der ein Element zu einem bestehenden Array hinzufügt:

$arrayOfArrays += , (1, 2, 3)
$arrayOfArrays += , (4, 5)
$arrayOfArrays += , (6, 7, 8, 9)

Write-Host "First Array:"
$arrayOfArrays[0]

Write-Host "Second Array:"
$arrayOfArrays[1]

Write-Host "Third Array:"
$arrayOfArrays[2]

In diesem Codeabschnitt fügen wir Unterarrays zu $arrayOfArrays hinzu. Um sicherzustellen, dass jedes Unterarray als ein einzelnes Element behandelt wird, setzen wir ein Komma , davor.

Dies verhindert, dass PowerShell die Unterarrays zu einem einzigen Array verkettet. Jedes Unterarray ist in Klammern eingeschlossen und wird durch Kommas getrennt.

Wir fügen drei Unterarrays mit unterschiedlichen Längen hinzu, um die Flexibilität zu demonstrieren.

Schließlich zeigen wir den Inhalt des $arrayOfArrays an, um seine Struktur und Inhalte zu überprüfen. PowerShell gibt das Array aus und zeigt jedes Element als separates Unterarray an.

Codeausgabe:

Die Ausgabe zeigt, dass $arrayOfArrays tatsächlich ein Array mit mehreren Unterarrays ist, von denen jedes eine separate Menge von Werten hält. Dies bestätigt die erfolgreiche Erstellung eines leeren Arrays von Arrays mit dem @() Array-Unterausdrucksoperator in PowerShell.

So erstellen Sie ein leeres Array von Arrays in PowerShell mit dem New-Object Cmdlet und der System.Collections.ArrayList Klasse

Ein weiterer Ansatz, den wir verwenden können, um ein leeres Array von Arrays zu erstellen, um strukturierte Daten zu speichern, ist das New-Object Cmdlet in Verbindung mit der System.Collections.ArrayList Klasse.

Die System.Collections.ArrayList Klasse in PowerShell bietet eine flexible und dynamische arrayähnliche Datenstruktur. Durch die Nutzung des New-Object Cmdlets können wir eine Instanz dieser Klasse instanziieren, um ein leeres Array zu erstellen.

Anschließend können wir Unterarrays als Elemente zu diesem Array von Arrays hinzufügen. Dieser Ansatz ermöglicht dynamisches Größenmanagement und effizientes Management von Arrays, was ihn für verschiedene Skriptszenarien geeignet macht.

Sehen wir uns an, wie wir ein leeres Array von Arrays mit diesem Ansatz erstellen können:

$arrayOfArrays = New-Object System.Collections.ArrayList

Hier verwenden wir das New-Object Cmdlet, um eine neue Instanz der System.Collections.ArrayList Klasse zu instanziieren. Dies erstellt einen leeren Array-Container, der in der Lage ist, andere Arrays aufzunehmen.

Die Variable $arrayOfArrays verweist jetzt auf dieses leere ArrayList Objekt.

Zugriff auf Elemente des Arrays von Arrays

Nachdem wir das leere Array erstellt haben, können wir nun nach Bedarf auf seine Elemente zugreifen und sie manipulieren:

$arrayOfArrays.Add(@(11, 12, 13))
$arrayOfArrays.Add(@(14, 15))
$arrayOfArrays.Add(@(16, 17, 18, 19))

Write-Host "First Array:"
$arrayOfArrays[0]

Write-Host "Second Array:"
$arrayOfArrays[1]

Write-Host "Third Array:"
$arrayOfArrays[2]

In diesem Codeabschnitt fügen wir Unterarrays zum $arrayOfArrays ArrayList-Objekt hinzu. Wir verwenden die .Add() Methode des ArrayList Objekts, um Unterarrays zum Array hinzuzufügen.

Jedes Unterarray ist in @() eingeschlossen, um sicherzustellen, dass es als ein einzelnes Element behandelt wird. Wir fügen drei Unterarrays mit unterschiedlichen Längen hinzu, um die Flexibilität dieses Ansatzes zu zeigen.

Schließlich zeigen wir den Inhalt des $arrayOfArrays ArrayList-Objekts an, um seine Struktur und Inhalte zu überprüfen. PowerShell gibt die ArrayList aus und zeigt jedes Element als separates Unterarray an.

Codeausgabe:

Die Ausgabe bestätigt, dass $arrayOfArrays eine ArrayList ist, die mehrere Unterarrays enthält, von denen jedes eine eigene Menge von Werten hält. Dies zeigt die erfolgreiche Erstellung eines leeren Arrays von Arrays mit dem New-Object Cmdlet und der System.Collections.ArrayList Klasse in PowerShell.

So erstellen Sie ein leeres Array von Arrays in PowerShell mit der @{} Hashtable

In PowerShell bieten Hashtables (@{}) eine praktische Möglichkeit, Schlüssel-Wert-Paare zu speichern. Während sie typischerweise für Schlüssel-Wert-Paare verwendet werden, können wir Hashtables auch nutzen, um ein leeres Array von Arrays zu erstellen, indem wir jeden Schlüssel mit einem leeren Array verknüpfen.

Diese Methode bietet eine klare Organisationsstruktur zum Verwalten mehrerer Arrays und ermöglicht einen einfachen Zugriff und eine einfache Manipulation der Array-Elemente.

So erstellen Sie ein leeres Array von Arrays mit der @{} Hashtable-Syntax:

$arrayOfArrays = @{}

Hinzufügen von Elementen zum Array von Arrays

Jetzt, da wir das leere Array von Arrays mit dem Hashtable-Ansatz erstellt haben, können wir nach Bedarf auf seine Elemente zugreifen und sie manipulieren:

$arrayOfArrays["Array1"] += @(1, 2, 3)
$arrayOfArrays["Array2"] += @(4, 5)
$arrayOfArrays["Array3"] += @(6, 7, 8, 9)
$arrayOfArrays

In diesem Codeabschnitt fügen wir Unterarrays zu den leeren Arrays innerhalb von $arrayOfArrays hinzu. Wir verwenden die Array-Indexierung, um auf jedes leere Array über seinen Schlüssel ("Array1", "Array2", "Array3") zuzugreifen und fügen dann Unterarrays mit dem += Operator hinzu.

Jedes Unterarray ist in @() eingeschlossen, um sicherzustellen, dass es als ein einzelnes Element behandelt wird.

Schließlich zeigen wir den Inhalt der $arrayOfArrays Hashtable an, um ihre Struktur und Inhalte zu überprüfen. PowerShell gibt die Hashtable aus und zeigt jedes Schlüssel-Wert-Paar, wobei die Werte Arrays sind, die Unterarrays enthalten.

Codeausgabe:

Die Ausgabe bestätigt, dass $arrayOfArrays eine Hashtable ist, die drei Schlüssel ("Array1", "Array2", "Array3") enthält, die jeweils mit einem Array verknüpft sind, das eine eigene Menge von Werten enthält.

Fazit

Zusammenfassend lässt sich sagen, dass die Erstellung eines leeren Arrays von Arrays in PowerShell Vielseitigkeit und Flexibilität bei der Verwaltung komplexer Datenstrukturen in Skript- und Automatisierungsaufgaben bietet.

Wir haben drei verschiedene Methoden untersucht, um dies zu erreichen: die Verwendung des @() Array-Unterausdrucksoperators, des New-Object Cmdlets mit der System.Collections.ArrayList Klasse und die Umnutzung der @{} Hashtable-Syntax. Jede Methode bietet ihre eigenen Vorteile und Überlegungen und richtet sich an unterschiedliche Präferenzen und Anforderungen.

Der @() Array-Unterausdrucksoperator bietet einen prägnanten und einfachen Ansatz, der die native PowerShell-Syntax nutzt, um leere Arrays effizient zu erstellen. Gleichzeitig bietet das New-Object Cmdlet mit der System.Collections.ArrayList Klasse dynamisches Größenmanagement und Verwaltungsfähigkeiten, die für Szenarien geeignet sind, die häufige Array-Manipulation erfordern.

Schließlich bietet die Umnutzung der @{} Hashtable-Syntax, obwohl unkonventionell, Einfachheit und Lesbarkeit in bestimmten Kontexten.

Unabhängig von der gewählten Methode ausgestattet sein, das Erstellen von leeren Arrays von Arrays zu meistern, vermittelt PowerShell-Nutzern wesentliche Fähigkeiten zur Entwicklung robuster Skripte und Automatisierung.