Có phải Go có nếu x trong cấu trúc tương tự như Python không?

Không lặp lại trên toàn bộ mảng, làm cách nào để kiểm tra xem xtrong mảng có sử dụng Go không? Liệu ngôn ngữ có một cấu trúc?

Giống như Python: if "x" in array: ...

Không có toán tử tích hợp để thực hiện trong Go. Bạn cần lặp lại trên mảng. Bạn có thể viết chức năng của riêng bạn để làm điều đó, như thế này:

func stringInSlice(a string, list []string) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}

Nếu bạn muốn có thể kiểm tra tư cách thành viên mà không lặp lại toàn bộ danh sách, bạn cần sử dụng bản đồ thay vì một mảng hoặc lát, như thế này:

visitedURL := map[string]bool {
    "http://www.google.com": true,
    "https://paypal.com": true,
}
if visitedURL[thisSite] {
    fmt.Println("Already been here.")
}

Một giải pháp khác nếu danh sách chứa các giá trị tĩnh.

ví dụ: kiểm tra giá trị hợp lệ từ danh sách các giá trị hợp lệ:

func IsValidCategory(category string) bool {
    switch category {
    case
        "auto",
        "news",
        "sport",
        "music":
        return true
    }
    return false
}

Đây là trích dẫn từ cuốn sách "Lập trình trong Go: Tạo ứng dụng cho thế kỷ 21":

Sử dụng một tìm kiếm tuyến tính đơn giản như thế này là tùy chọn duy nhất cho dữ liệu chưa được sắp xếp và tốt cho các lát nhỏ (tối đa hàng trăm mục). Nhưng đối với các lát cắt lớn hơn, đặc biệt là nếu chúng tôi thực hiện tìm kiếm nhiều lần, thì tìm kiếm tuyến tính rất kém hiệu quả, trung bình cần một nửa các mục để so sánh mỗi lần.

Go cung cấp phương thức sort.Search () sử dụng thuật toán tìm kiếm nhị phân: Điều này yêu cầu so sánh chỉ các mục log2 (n) (trong đó n là số lượng mục) mỗi lần. Để đặt điều này trong viễn cảnh, một tìm kiếm tuyến tính của 1000000 mục yêu cầu trung bình 500000 so sánh, trong trường hợp xấu nhất là 1000000 so sánh; một tìm kiếm nhị phân cần tối đa 20 so sánh, ngay cả trong trường hợp xấu nhất.

files := []string{"Test.conf", "util.go", "Makefile", "misc.go", "main.go"}
target := "Makefile"
sort.Strings(files)
i := sort.Search(len(files),
    func(i int) bool { return files[i] >= target })
if i < len(files) && files[i] == target {
    fmt.Printf("found \"%s\" at files[%d]\n", files[i], i)
}

https://play.golang.org/p/UIndYQ8FeW

Ví dụ trên sử dụng sort rất gần, nhưng trong trường hợp chuỗi chỉ cần sử dụng SearchString:

files := []string{"Test.conf", "util.go", "Makefile", "misc.go", "main.go"}
target := "Makefile"
sort.Strings(files)
i := sort.SearchStrings(files, target)
if i < len(files) && files[i] == target {
    fmt.Printf("found \"%s\" at files[%d]\n", files[i], i)
}

https://golang.org/pkg/sort/#SearchStrings

Chỉ cần có câu hỏi tương tự và quyết định thử một số gợi ý trong chủ đề này.

Tôi đã điểm chuẩn các tình huống tốt nhất và tồi tệ nhất trong 3 loại tra cứu:

• sử dụng bản đồ
• sử dụng một danh sách
• sử dụng câu lệnh chuyển đổi

đây là mã chức năng:

func belongsToMap(lookup string) bool {
list := map[string]bool{
    "900898296857": true,
    "900898302052": true,
    "900898296492": true,
    "900898296850": true,
    "900898296703": true,
    "900898296633": true,
    "900898296613": true,
    "900898296615": true,
    "900898296620": true,
    "900898296636": true,
}
if _, ok := list[lookup]; ok {
    return true
} else {
    return false
}
}


func belongsToList(lookup string) bool {
list := []string{
    "900898296857",
    "900898302052",
    "900898296492",
    "900898296850",
    "900898296703",
    "900898296633",
    "900898296613",
    "900898296615",
    "900898296620",
    "900898296636",
}
for _, val := range list {
    if val == lookup {
        return true
    }
}
return false
}

func belongsToSwitch(lookup string) bool {
switch lookup {
case
    "900898296857",
    "900898302052",
    "900898296492",
    "900898296850",
    "900898296703",
    "900898296633",
    "900898296613",
    "900898296615",
    "900898296620",
    "900898296636":
    return true
}
return false
}

trường hợp tốt nhất chọn mục đầu tiên trong danh sách, trường hợp xấu nhất sử dụng giá trị không tồn tại.

đây là kết quả:

BenchmarkBelongsToMapWorstCase-4 2000000 787 ns/op BenchmarkBelongsToSwitchWorstCase-4 2000000000 0.35 ns/op BenchmarkBelongsToListWorstCase-4 100000000 14.7 ns/op BenchmarkBelongsToMapBestCase-4 2000000 683 ns/op BenchmarkBelongsToSwitchBestCase-4 100000000 10.6 ns/op BenchmarkBelongsToListBestCase-4 100000000 10.4 ns/op

Switch thắng tất cả các cách, trường hợp xấu nhất là nhanh hơn so với trường hợp tốt nhất. Bản đồ là tồi tệ nhất và danh sách gần hơn để chuyển đổi.

Vì vậy, đạo đức là: Nếu bạn có một danh sách nhỏ, hợp lý, câu lệnh chuyển đổi là cách để đi.

Một tùy chọn khác là sử dụng bản đồ như một bộ. Bạn chỉ sử dụng các khóa và có giá trị giống như một boolean luôn luôn đúng. Sau đó, bạn có thể dễ dàng kiểm tra xem bản đồ có chứa chìa khóa hay không. Điều này hữu ích nếu bạn cần hành vi của một tập hợp, trong đó nếu bạn thêm một giá trị nhiều lần thì nó chỉ trong tập hợp một lần.

Đây là một ví dụ đơn giản trong đó tôi thêm các số ngẫu nhiên làm khóa vào bản đồ. Nếu cùng một số được tạo ra nhiều lần, điều đó không thành vấn đề, nó sẽ chỉ xuất hiện trong bản đồ cuối cùng một lần. Sau đó, tôi sử dụng một đơn giản nếu kiểm tra để xem liệu một phím có trong bản đồ hay không.

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    var MAX int = 10

    m := make(map[int]bool)

    for i := 0; i <= MAX; i++ {
        m[rand.Intn(MAX)] = true
    }

    for i := 0; i <= MAX; i++ {
        if _, ok := m[i]; ok {
            fmt.Printf("%v is in map\n", i)
        } else {
            fmt.Printf("%v is not in map\n", i)
        }
    }
}

Đây là trên sân chơi đi

Điều này gần đến mức tôi có thể có được cảm giác tự nhiên của toán tử "in" của Python. Bạn phải xác định loại của riêng bạn. Sau đó, bạn có thể mở rộng chức năng của loại đó bằng cách thêm một phương thức như "có" hoạt động như bạn hy vọng.

package main

import "fmt"

type StrSlice []string

func (list StrSlice) Has(a string) bool {
    for _, b := range list {
        if b == a {
            return true
        }
    }
    return false
}

func main() {
    var testList = StrSlice{"The", "big", "dog", "has", "fleas"}

    if testList.Has("dog") {
        fmt.Println("Yay!")
    }
}

Tôi có một thư viện tiện ích nơi tôi xác định một vài thứ phổ biến như thế này cho một số loại lát, như những loại có chứa số nguyên hoặc các cấu trúc khác của riêng tôi.

Vâng, nó chạy trong thời gian tuyến tính, nhưng đó không phải là vấn đề. Vấn đề là hỏi và tìm hiểu những cấu trúc ngôn ngữ phổ biến mà Go có và không có. Đó là một bài tập tốt. Cho dù câu trả lời này là ngớ ngẩn hay hữu ích là tùy thuộc vào người đọc.