Slicing-Filter in Golang (Filter Slice)

Slicing Filter In Golang Filter Slice



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 die Slice-Filterung.







Slicing-Filter sind eine wesentliche Technik für die Arbeit mit Datensammlungen wie Arrays oder Slices. Es ermöglicht uns, anhand bestimmter Kriterien bestimmte Elemente aus einem Slice zu extrahieren.



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 zum Slice hinzufügen

In Go können wir mit der Funktion append() Elemente 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 )
}

Golang Filter Slice

Bei der Slice-Filterung werden bestimmte Elemente ausgewählt, die einer bestimmten Bedingung entsprechen, und diejenigen verworfen, die dies nicht tun.

1.      Verwenden der „For“-Schleife

Dies ist eine grundlegende und gängige Methode bei der Datenbearbeitung, wie im folgenden Codebeispiel gezeigt:

Paket main
importieren (
„fmt“
)
Funktion main ( ) {
Zahlen := [ ] int { 1012 , 32 , 32 , 232 , 212 , Vier fünf , 2 , 12 , 64 , 23 , 54 , 76 , 872 }
gefiltert := [ ] int { }
für _, num := Bereichsnummern {
Wenn Auf eins % 2 == 0 {
gefiltert = anhängen ( gefiltert, num )
}
}
fmt.Println ( gefiltert )
}

Dabei werden eine basierte „for“-Schleife und ein Bedingungsprüfer verwendet, um alle Elemente zu entfernen, die keine geraden Zahlen sind.

2.      Verwendung des Filterpakets

Für erweiterte Filtervorgänge können wir externe Pakete wie „go-funk“ verwenden:

https://github.com/thoas/go-funk

Diese Bibliothek bietet Hilfsfunktionen (Zuordnen, Suchen, Enthält, Filtern und mehr).

Paket main
importieren (
„fmt“

'github.com/thoas/go-funk'
)
Funktion main ( ) {
r := funk.Filter ( [ ] int { 1 , 10 , 2 , 8 , 3 , 7 , 4 , 6 , 5 , 9 } , Funktion ( x int ) bool {
zurückkehren X % 2 == 0
} )
fmt.Println ( R )
}

Dabei wird das Funk-Paket verwendet, um einen Filter durchzuführen und die Slice-Werte zu sortieren.

3.      Verwendung von Kanälen und Goroutinen

Für größere Slices oder komplexe Filterbedingungen können wir die Goroutinen und Kanäle zur gleichzeitigen Filterung verwenden.

Paket main

importieren (
„fmt“
)

Funktion concurrentFilter ( Scheibe [ ] int, Bedingungsfunktion ( int ) bool ) [ ] int {
Ergebnis := machen ( [ ] int, 0 )
ch := machen ( chan int )

für _, v := Bereichsscheibe {
gehen func ( val int ) {
Wenn Zustand ( val ) {
CH < - Wert
} anders {
CH < - -1
}
} ( In )
}

für Bereichsscheibe {
Wert := < -CH
Wenn val ! = -1 {
Ergebnis = anhängen ( Ergebnis, Wert )
}
}

zurückkehren Ergebnis
}

Funktion main ( ) {
Zahlen := [ ] int { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 }

gefiltert := concurrentFilter ( Zahlen, Funkt ( n int ) bool { zurückkehren N % 2 == 0 } )

fmt.Println ( gefiltert )
}

Dadurch wird die Leistungsfähigkeit von Goroutinen und Kanälen kombiniert, um eine komplexere und gleichzeitige Filterung zu ermöglichen.

Abschluss

In diesem Tutorial haben wir die Methoden und Techniken zur Durchführung der Slice-Filterung behandelt, von der einfachen „for“-Schleife bis hin zur erweiterten Filterung mithilfe von Kanälen und Goroutinen.