Slices-Verkettung in Go (Concat Slices)

Slices Verkettung In Go Concat Slices



Slices sind eine grundlegende Datenstruktur in Go, da sie es uns ermöglichen, mit einer Sammlung von Elementen zu arbeiten.

Eine der häufigsten Aufgaben bei der Arbeit mit Slices ist das Verketten von zwei oder mehr Slices zu einer einzigen Einheit.







In diesem Tutorial führen wir Sie durch die Methoden, die Sie zur Bewältigung dieser Aufgabe verwenden können.



Golang-Scheiben

Bevor wir uns mit dem Entfernen von Duplikaten aus einem Slice befassen, lassen Sie uns die Grundlagen von Slices erkunden, falls Sie nicht damit vertraut sind.



Was ist ein Slice?

In Go ist ein Slice eine flexible Ansicht in einem zugrunde liegenden Array mit dynamischer Größe. Es ist eine vielseitigere Alternative zu Arrays, da es je nach Bedarf vergrößert oder verkleinert werden kann, ohne dass wir eine feste Größe angeben müssen.





Wir können Slices verwenden, um Datensequenzen wie Listen, Sammlungen oder Arrays mit dynamischen Größen darzustellen.

Ein Slice besteht in Go aus drei Hauptkomponenten:



  1. Zeiger auf das zugrunde liegende Array
  2. Länge (Anzahl der Elemente im Slice)
  3. Kapazität (maximale Anzahl von Elementen, die das Slice aufnehmen kann, ohne die Größe des zugrunde liegenden Arrays zu ändern)

Das Folgende zeigt die grundlegende Syntax zum Deklarieren eines Slice in Go:

var Slice_name [ ] Typ

Grundlagen von Slices in Go

Die erste und gebräuchlichste Methode zum Erstellen eines Slice in Go ist die Verwendung der Literaldefinition, wie im folgenden Beispiel gezeigt:

Datenbanken := [ ] Zeichenfolge { „MySQL“ , „PostgreSQL“ , „Redis“ }

Wir können auch die Funktion „make“ verwenden, um ein neues Slice zu deklarieren, wie im folgenden Beispiel gezeigt:

Datenbanken := machen ( [ ] Schnur, 3 , 5 )

Dadurch sollte ein Ganzzahlsegment mit der Länge 3 und einer Kapazität von 5 erstellt werden.

Wir können ein Slice auch erstellen, indem wir ein vorhandenes Array wie folgt in Slices aufteilen:

arr := [ 5 ] int { 1 , 2 , 3 , 4 , 5 }
Scheibe := arr [ 1 : 4 ]

Dadurch sollte ein neues Slice aus dem zweiten und vierten Element des Arrays erstellt werden.

Elemente zu einem Slice hinzufügen

In Go können wir die Elemente mit der Funktion append() zu einem vorhandenen Slice hinzufügen, wie im folgenden Beispiel gezeigt:

Datenbanken := [ ] Zeichenfolge { „MySQL“ , „PostgreSQL“ }
Datenbanken = anhängen ( Datenbanken, „Redis“ )

In der „Append“-Funktion müssen wir das vorhandene Slice und die neuen Elemente übergeben, die wir dem Slice hinzufügen möchten.

Zugriff auf die Elemente

Wir können über den Elementindex auf die Slice-Elemente zugreifen, wie im folgenden Beispiel gezeigt:

i := Datenbanken [ 0 ]

Dies sollte das erste Element im Slice zurückgeben.

Iterieren über Slice

Wir können eine einfache „for“-Schleife verwenden, um die Elemente eines Slice zu durchlaufen, wie im folgenden Beispiel gezeigt:

für i, db := Bereichsdatenbanken {
fmt.Printf ( „Index: %d, Wert: %s \N ' , ich, db )
}

Gehen Sie zur Slice-Verkettung

Glücklicherweise verfügen wir über mehrere Methoden und Techniken, mit denen wir die Slices in Go verketten können. Schauen wir sie uns an:

Methode 1: Verwenden der Append-Funktion

Dies ist eine der gebräuchlichsten Methoden zum Anhängen von Elementen an ein Slice. Wir können es auch verwenden, um die Slices an andere Slices anzuhängen. Die Methode gibt auch den resultierenden Slice zurück, was sie recht einfach und effizient macht.

Ein Beispiel ist wie folgt:

Paket main
importieren „fmt“
Funktion main ( ) {
sql := [ ] Zeichenfolge { „MySQL“ , „PostgreSQL“ , „SQLite“ }
nosql := [ ] Zeichenfolge { „MongoDB“ , 'Kassandra' , „Redis“ }
Datenbanken := anhängen ( SQL, NoSQL... )
fmt.Println ( Datenbanken )
}

Das gegebene Beispiel verwendet den „…“-Operator, der als Slice-Unpacking bekannt ist. Sobald wir die Elemente des Slice entpackt haben, übergeben wir sie an die Funktion append(), um sie dem Slice hinzuzufügen.

Dies ist eine sehr effiziente und einfache Methode zur Slice-Verkettung in Go.

Methode 2: Kopieren der Elemente

Können wir jedoch das Kopieren vergessen? Wir können eine Kopierfunktion verwenden, um die Elemente aus den Elementen zu kopieren und sie einem neuen Slice hinzuzufügen, wie im folgenden Beispiel gezeigt:

Paket main
importieren „fmt“
Funktion main ( ) {
sql := [ ] Zeichenfolge { „MySQL“ , „PostgreSQL“ , „SQLite“ }
nosql := [ ] Zeichenfolge { „MongoDB“ , 'Kassandra' , „Redis“ }

totalLen := len ( sql ) + nur ( nosql )
Datenbanken := machen ( [ ] string, totalLen )
Kopieren ( Datenbanken, SQL )
Kopieren ( Datenbanken [ nur ( sql ) : ] , nosql )
fmt.Println ( Datenbanken )
}

Im gegebenen Beispiel berechnen wir zunächst die Gesamtlänge der verketteten Zeichenfolge. Anschließend erstellen wir einen neuen Slice mit der erforderlichen Kapazität.

Abschließend kopieren wir die Elemente des ersten und zweiten Slices in das neue Slice.

Abschluss

In diesem Beitrag haben wir untersucht, wie man die Slices zu einer einzigen Einheit verkettet, was eine häufige Aufgabe beim Umgang mit Sammlungen ist.