मैं GoLang में तार की तुलना कैसे करूं?

Question

जब मैं गो स्ट्रिंग तुलना करता हूं तो मैं 'सही' परिणाम नहीं दे पाता हूं। मैंने समस्या को समझाने के लिए निम्नलिखित लिखा और आउटपुट का स्क्रीनशॉट संलग्न किया

// string comparison in Go
package main
import "fmt"
import "bufio"
import "os"

func main() {
    var isLetterA bool 

    fmt.Println("Enter the letter a")
    reader := bufio.NewReader(os.Stdin)
    input, _ := reader.ReadString('\n')

    if(input == "a") {
        isLetterA = true
    } else {
        isLetterA = false 
    }

    fmt.Println("You entered",input)
    fmt.Println("Is it the letter a?",isLetterA)

}

Comments

विंडोज़ उपयोगकर्ता मेरे उत्तर की जांच करते हैं :)

— दक्ष मिगलानी

Answer 1

==गो में तार की तुलना करने के लिए सही ऑपरेटर है। हालाँकि, स्ट्रींग जिसे आपने STDIN से पढ़ा है, उसमें reader.ReadStringशामिल नहीं हैं "a", लेकिन "a\n"(यदि आप बारीकी से देखते हैं, तो आपको अपने उदाहरण आउटपुट में अतिरिक्त लाइन ब्रेक दिखाई देगा)।

आप strings.TrimRightअपने इनपुट से ट्रेलिंग व्हाट्सएप को हटाने के लिए फ़ंक्शन का उपयोग कर सकते हैं :

if strings.TrimRight(input, "\n") == "a" {
    // ...
}

Answer 2

प्लेटफ़ॉर्म स्वतंत्र उपयोगकर्ताओं या विंडोज उपयोगकर्ताओं के लिए, आप क्या कर सकते हैं:

आयात रनटाइम:

import (
    "runtime"
    "strings"
)

और फिर स्ट्रिंग को इस तरह से ट्रिम करें:

if runtime.GOOS == "windows" {
  input = strings.TrimRight(input, "\r\n")
} else {
  input = strings.TrimRight(input, "\n")
}

अब आप इसे इस तरह से तुलना कर सकते हैं:

if strings.Compare(input, "a") == 0 {
  //....yourCode
}

जब आप कई प्लेटफार्मों पर STDIN का उपयोग कर रहे हों तो यह एक बेहतर तरीका है।

व्याख्या

ऐसा इसलिए होता है क्योंकि विंडोज़ लाइनों पर अंत होता है "\r\n"जिसके साथ CRLF के रूप में जाना जाता है, लेकिन UNIX लाइनों पर "\n"जिसके साथ LF के रूप में जाना जाता है और इसीलिए हम विंडोज़ पर "\n"ट्रिम करते हुए यूनिक्स आधारित ऑपरेटिंग सिस्टम "\r\n"पर ट्रिम कर देते हैं।

Comments

अंतर करने की कोई आवश्यकता नहीं है। दूसरा तर्क एक कटसेट है, एक प्रत्यय नहीं है, और कटसेट में किसी भी वर्ण को किसी भी क्रम / संयोजन में छंटनी होगी। "\ R \ n" को ट्रिम करना दोनों पर पर्याप्त होगा।

— जेसन कार्लसन

Answer 3

यह मानते हुए कि व्हॉट्सएप के पात्रों की कोई पूर्ववर्ती / सफलता नहीं है, स्ट्रिंग समानता का दावा करने के लिए अभी भी कुछ तरीके हैं। उनमें से कुछ हैं:

• strings.ToLower(..) फिर ==
• strings.EqualFold(.., ..)
• cases#Lower के साथ रखा ==
• cases#Fold के साथ रखा ==

यहां कुछ बुनियादी बेंचमार्क परिणाम दिए गए हैं (इन परीक्षणों में, strings.EqualFold(.., ..)सबसे अधिक पसंद करने वाले विकल्प की तरह लगते हैं):

goos: darwin
goarch: amd64
BenchmarkStringOps/both_strings_equal::equality_op-4               10000        182944 ns/op
BenchmarkStringOps/both_strings_equal::strings_equal_fold-4        10000        114371 ns/op
BenchmarkStringOps/both_strings_equal::fold_caser-4                10000       2599013 ns/op
BenchmarkStringOps/both_strings_equal::lower_caser-4               10000       3592486 ns/op

BenchmarkStringOps/one_string_in_caps::equality_op-4               10000        417780 ns/op
BenchmarkStringOps/one_string_in_caps::strings_equal_fold-4        10000        153509 ns/op
BenchmarkStringOps/one_string_in_caps::fold_caser-4                10000       3039782 ns/op
BenchmarkStringOps/one_string_in_caps::lower_caser-4               10000       3861189 ns/op

BenchmarkStringOps/weird_casing_situation::equality_op-4           10000        619104 ns/op
BenchmarkStringOps/weird_casing_situation::strings_equal_fold-4    10000        148489 ns/op
BenchmarkStringOps/weird_casing_situation::fold_caser-4            10000       3603943 ns/op
BenchmarkStringOps/weird_casing_situation::lower_caser-4           10000       3637832 ns/op

चूंकि काफी कुछ विकल्प हैं, इसलिए यहां बेंचमार्क बनाने के लिए कोड है।

package main

import (
    "fmt"
    "strings"
    "testing"

    "golang.org/x/text/cases"
    "golang.org/x/text/language"
)

func BenchmarkStringOps(b *testing.B) {
    foldCaser := cases.Fold()
    lowerCaser := cases.Lower(language.English)

    tests := []struct{
        description string
        first, second string
    }{
        {
            description: "both strings equal",
            first: "aaaa",
            second: "aaaa",
        },
        {
            description: "one string in caps",
            first: "aaaa",
            second: "AAAA",
        },
        {
            description: "weird casing situation",
            first: "aAaA",
            second: "AaAa",
        },
    }

    for _, tt := range tests {
        b.Run(fmt.Sprintf("%s::equality op", tt.description), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                benchmarkStringEqualsOperation(tt.first, tt.second, b)
            }
        })

        b.Run(fmt.Sprintf("%s::strings equal fold", tt.description), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                benchmarkStringsEqualFold(tt.first, tt.second, b)
            }
        })

        b.Run(fmt.Sprintf("%s::fold caser", tt.description), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                benchmarkStringsFoldCaser(tt.first, tt.second, foldCaser, b)
            }
        })

        b.Run(fmt.Sprintf("%s::lower caser", tt.description), func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                benchmarkStringsLowerCaser(tt.first, tt.second, lowerCaser, b)
            }
        })
    }
}

func benchmarkStringEqualsOperation(first, second string, b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = strings.ToLower(first) == strings.ToLower(second)
    }
}

func benchmarkStringsEqualFold(first, second string, b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = strings.EqualFold(first, second)
    }
}

func benchmarkStringsFoldCaser(first, second string, caser cases.Caser, b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = caser.String(first) == caser.String(second)
    }
}

func benchmarkStringsLowerCaser(first, second string, caser cases.Caser, b *testing.B) {
    for n := 0; n < b.N; n++ {
        _ = caser.String(first) == caser.String(second)
    }
}

Answer 4

गोलंग में तार के अंदर की सामग्री की तुलना ==ऑपरेटर के उपयोग से की जा सकती है । यदि परिणाम अपेक्षित नहीं हैं , तो कुछ छिपे हुए अक्षर जैसे \n, \rरिक्त स्थान आदि हो सकते हैं , इसलिए अंगूठे के एक सामान्य नियम के रूप में, stringsगोलंग में पैकेज द्वारा प्रदान किए गए कार्यों का उपयोग करने वालों को हटाने का प्रयास करें ।

उदाहरण के लिए, strings.TrimSpaceफ़ंक्शन का उपयोग करके रिक्त स्थान को हटाया जा सकता है । आप किसी भी वर्ण को हटाने के लिए एक कस्टम फ़ंक्शन को भी परिभाषित कर सकते हैं। strings.TrimFuncफ़ंक्शन आपको अधिक शक्ति दे सकता है।