गो परीक्षण स्ट्रिंग में विकल्प शामिल हैं

Question

मैं कैसे जांच करूं कि एक स्ट्रिंग गो में दूसरे स्ट्रिंग का विकल्प है? उदाहरण के लिए, मैं जाँच करना चाहता हूँ someString.contains("something")।

Answer 1

स्ट्रिंग पैकेज Containsसे फ़ंक्शन का उपयोग करें ।

import (
    "strings"
)
strings.Contains("something", "some") // true

Answer 2

तुलना करने के लिए, अधिक विकल्प हैं:

import (
    "fmt"
    "regexp"
    "strings"
)

const (
    str    = "something"
    substr = "some"
)

// 1. Contains
res := strings.Contains(str, substr)
fmt.Println(res) // true

// 2. Index: check the index of the first instance of substr in str, or -1 if substr is not present
i := strings.Index(str, substr)
fmt.Println(i) // 0

// 3. Split by substr and check len of the slice, or length is 1 if substr is not present
ss := strings.Split(str, substr)
fmt.Println(len(ss)) // 2

// 4. Check number of non-overlapping instances of substr in str
c := strings.Count(str, substr)
fmt.Println(c) // 1

// 5. RegExp
matched, _ := regexp.MatchString(substr, str)
fmt.Println(matched) // true

// 6. Compiled RegExp
re = regexp.MustCompile(substr)
res = re.MatchString(str)
fmt.Println(res) // true

बेंचमार्क: Containsआंतरिक रूप से कॉल करता है Index, इसलिए गति लगभग समान होती है (btw Go 1.11.5 गो 1.14.3 की तुलना में थोड़ा बड़ा अंतर दिखाती है)।

BenchmarkStringsContains-4              100000000               10.5 ns/op             0 B/op          0 allocs/op
BenchmarkStringsIndex-4                 117090943               10.1 ns/op             0 B/op          0 allocs/op
BenchmarkStringsSplit-4                  6958126               152 ns/op              32 B/op          1 allocs/op
BenchmarkStringsCount-4                 42397729                29.1 ns/op             0 B/op          0 allocs/op
BenchmarkStringsRegExp-4                  461696              2467 ns/op            1326 B/op         16 allocs/op
BenchmarkStringsRegExpCompiled-4         7109509               168 ns/op               0 B/op          0 allocs/op