DE
RU
EN
ES
ZH
FR
PT
AR
HI
alex_dev56
·
Gibt es in Go eine "if x in"-Konstruktion zur Überprüfung der Elementzugehörigkeit wie in Python?
Hallo zusammen! Ich lerne Go nach Python und bin auf ein kleines Problem gestoßen. In Python habe ich oft die Konstruktion `if x in list:` verwendet, um zu prüfen, ob ein Element in einer Liste ist. Zum Beispiel:
```python
fruits = ["apple", "banana", "cherry"]
if "banana" in fruits:
print("Found it!")
```
Sehr praktisch und lesbar. Aber in Go habe ich keine ähnliche Syntax gefunden. Ich habe versucht, so etwas zu schreiben:
```go
fruits := []string{"apple", "banana", "cherry"}
if "banana" in fruits { // Compiler-Fehler
fmt.Println("Found it!")
}
```
Go gibt einen Compiler-Fehler aus. Ich verstehe, dass Go eine niedrigere Sprache ist, aber gibt es wirklich keine eingebaute Möglichkeit zu prüfen, ob ein Slice oder Array ein bestimmtes Element enthält? Vielleicht gibt es eine Funktion in der Standardbibliothek? Oder muss ich jedes Mal eine Schleife schreiben? Ich wäre dankbar für eine ausführliche Erklärung mit Code-Beispielen.
<<>>
Es gibt keine direkte "if x in"-Syntax in Go, aber mehrere effiziente Lösungen
In Go gibt es tatsächlich keine direkte Entsprechung zu Pythons `if x in` für Slices oder Arrays. Die Sprache bietet keinen eingebauten Operator oder eine generische Funktion in der Standardbibliothek dafür. Stattdessen muss man entweder eine Schleife schreiben oder eine Hilfsfunktion definieren. Hier sind die gängigsten Ansätze:
- Manuelle Schleife: Der einfachste und idiomatischste Weg in Go ist eine `for`-Schleife mit `range`:
package main
import "fmt"
func main() {
fruits := []string{"apple", "banana", "cherry"}
found := false
for _, fruit := range fruits {
if fruit == "banana" {
found = true
break
}
}
if found {
fmt.Println("Found it!")
}
}
- Hilfsfunktion: Für häufige Verwendung kann man eine generische Funktion schreiben (ab Go 1.18 mit Generics):
package main
import "fmt"
func contains[T comparable](slice []T, element T) bool {
for _, v := range slice {
if v == element {
return true
}
}
return false
}
func main() {
fruits := []string{"apple", "banana", "cherry"}
if contains(fruits, "banana") {
fmt.Println("Found it!")
}
}
- Map für häufige Lookups: Wenn Sie viele Prüfungen durchführen müssen, konvertieren Sie das Slice in eine Map für O(1)-Lookups:
package main
import "fmt"
func main() {
fruits := []string{"apple", "banana", "cherry"}
fruitSet := make(map[string]bool)
for _, fruit := range fruits {
fruitSet[fruit] = true
}
if fruitSet["banana"] {
fmt.Println("Found it!")
}
}
Die Schleifenlösung ist am idiomatischsten und wird in Go-Community bevorzugt. Für kleine Slices ist sie effizient und klar. Die generische Funktion ist nützlich, wenn Sie die Prüfung oft wiederholen. Maps sind ideal, wenn Sie viele Lookups auf demselben Datensatz durchführen.
