स्विफ्ट भाषा में मामले की अनदेखी करने वाले दो तारों की तुलना कैसे करें?

Question

हम तेजी से अनदेखी मामले में दो तार की तुलना कैसे कर सकते हैं? उदाहरण के लिए:

var a = "Cash"
var b = "cash"

क्या कोई ऐसा तरीका है जो अगर हम var a और var b की तुलना में सही है

Comments

तुलना करने से पहले आप दोनों को लोअर केस में बदल सकते हैं।

— डीनो ट्वि

बस ध्यान दें कि lowercaseStringकुछ उत्तरों में उल्लेख किया गया है कि कुछ भाषाओं में विफल हो जाएगा (Stra !e! = STRASSE उदाहरण के लिए)

— अल्लादीन

@ अलादीन आप इसे तब कैसे करने का सुझाव देंगे। इस मुद्दे को हल करने के लिए अधिकांश उदाहरण सभी ऊपरी मामले या सभी निचले मामले में परिवर्तित होते हैं?

— स्टीव

@ सेब ने सुझाव दिया caseInsensitiveCompare:और localizedCaseInsensitiveCompare:इसके बजाय

— अलादीनिन

@ सच ज़रूर! (आप कोशिश कर सकते हैं "Straße".localizedCaseInsensitiveCompare("STRASSE")- आयात करने के लिए याद रखें Foundation)

— अलादीनिन

Answer 1

इसे इस्तेमाल करे:

var a = "Cash"
var b = "cash"
let result: NSComparisonResult = a.compare(b, options: NSStringCompareOptions.CaseInsensitiveSearch, range: nil, locale: nil)

// You can also ignore last two parameters(thanks 0x7fffffff)
//let result: NSComparisonResult = a.compare(b, options: NSStringCompareOptions.CaseInsensitiveSearch)

परिणाम NSComparisonResult enum का प्रकार है:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

तो अगर आप बयान का उपयोग कर सकते हैं:

if result == .OrderedSame {
    println("equal")
} else {
    println("not equal")
}

Comments

यदि मैं सही ढंग से याद करता हूं, तो रेंज और लोकेल पैरामीटर वैकल्पिक हैं और इसे पूरी तरह से छोड़ा जा सकता है।

— मिक मैक्लम

हां वास्तव में, मैं सभी मापदंडों के साथ पूरी विधि दिखाना चाहता था।

— ग्रेग

आपके पास यहाँ सही उत्तर होना चाहिए। तार की तुलना केवल यह जानने के बारे में नहीं है कि वे समान हैं या नहीं

— मिकेल

Answer 2

इसे इस्तेमाल करे :

पुराने स्विफ्ट के लिए:

var a : String = "Cash"
var b : String = "cash"

if(a.caseInsensitiveCompare(b) == NSComparisonResult.OrderedSame){
    println("voila")
}

---

स्विफ्ट 3+

var a : String = "Cash"
var b : String = "cash"

if(a.caseInsensitiveCompare(b) == .orderedSame){
    print("voila")
}

Comments

स्विफ्ट 3 में आपको उपयोग करने की आवश्यकता हैa.caseInsensitiveCompare(b) == ComparisonResult.orderedSame

— azhidkov

नोट: caseInsensitiveCompare(_:)स्विफ्ट मानक लाइब्रेरी में शामिल नहीं है, बल्कि यह Foundationरूपरेखा का हिस्सा है , इस प्रकार, आवश्यकता है import Foundation।

— चिरमांसे

Answer 3

उपयोग caseInsensitiveCompareविधि:

let a = "Cash"
let b = "cash"
let c = a.caseInsensitiveCompare(b) == .orderedSame
print(c) // "true"

ComparisonResult आपको बताता है कि लेक्सिकोग्राफिक ऑर्डर में दूसरे शब्द की तुलना में कौन सा शब्द पहले आया है (यानी जो किसी शब्दकोश के सामने आता है)। .orderedSameइसका मतलब है कि शब्दकोष में तार एक ही स्थान पर समाप्त होंगे

Comments

क्या .orderedSameमतलब है? डॉक्स सिर्फ इतना कहना दो ऑपरेंड बराबर हैं । लेकिन यहां 'आदेश' शब्द का इस्तेमाल क्यों किया जाता है? कोई क्रम है या कुछ और है? और क्या करता है बाएं ऑपरेंड दाएं ऑपरेंड से छोटा है। ( .orderedAscending) स्ट्रिंग्स के लिए मतलब

— हनी

@ हनी तुलना परिणाम आपको बताता है कि लेक्सिकोग्राफिक क्रम में दूसरे शब्द की तुलना में पहले कौन सा शब्द आता है (यानी जो किसी शब्दकोश के सामने आता है)। .orderedSameइसका मतलब है कि शब्दकोष में तार एक ही स्थान पर समाप्त होंगे।

— dasblinkenlight

@Honey .orderedSameकम है ComparisonResult.orderSame... आपको उस प्रकार का नाम नहीं देना है क्योंकि कंपाइलर को पता है कि caseInsensitiveCompareरिटर्न देता है ComparisonResult। "दो ऑपरेंड समान हैं" - वे एक विशिष्ट आदेश के अनुसार समान हैं ... स्पष्ट रूप से, "कैश" और "कैश" समान स्ट्रिंग मान नहीं हैं। "लेकिन 'आदेश' शब्द यहाँ क्यों इस्तेमाल किया गया है?" - क्योंकि यह एक आदेशित तुलना का परिणाम है। अन्य मूल्य हैं orderedAscendingऔर orderedDescending... यह केवल एक ही या अलग का सवाल नहीं है। "छोटे" के रूप में: तार एक बड़े आधार में संख्याओं की तरह हैं।

— जिम बाल्टर

मुझे लगता है कि यह भयानक एपीआई डिजाइन है। हस्ताक्षर को पढ़ना आसान नहीं है ... इसे बनाना a.caseInsensitiveCompare(b, comparing: .orderedSame)अधिक पठनीय होगा ...

— हनी

Answer 4

if a.lowercaseString == b.lowercaseString {
    //Strings match
}

Comments

शुद्ध स्विफ्ट यहाँ जाने का रास्ता है। नींव की कोई जरूरत नहीं।

— अलेक्जेंडर -

मामले को बदलना और फिर तुलना करना गलत है। प्रश्न के तहत टिप्पणी देखें।

— जिम बैटर

@JimBalter मैं इसे "गलत" नहीं कहूंगा क्योंकि यह ओपी के प्रश्न में दिए गए उदाहरण का जवाब देता है। हम में से जिन लोगों को स्थानीयकरण का समर्थन करने की आवश्यकता नहीं है, उनके लिए यह बहुत साफ है!

— टॉड

^ नहीं, यह गलत है। एक उदाहरण के लिए काम करने के लिए कुछ होता है अप्रासंगिक। यह हैक "क्लीनर" बिल्कुल नहीं है। स्वीकृत उत्तर सही, स्वच्छ समाधान देता है।

— जिम बाल्टर

Answer 5

बस अपना रोल कर सकते हैं:

func equalIgnoringCase(a:String, b:String) -> Bool {
    return a.lowercaseString == b.lowercaseString
}

Comments

मामले को बदलना और फिर तुलना करना गलत है। प्रश्न के तहत टिप्पणी देखें।

— जिम बैटर

Answer 6

सही तरीका:

let a: String = "Cash"
let b: String = "cash"

if a.caseInsensitiveCompare(b) == .orderedSame {
    //Strings match 
}

कृपया ध्यान दें: ComparisonResult.orderedSame को शॉर्टहैंड में .orderedSame के रूप में भी लिखा जा सकता है।

दूसरा तरीका:

ए।

if a.lowercased() == b.lowercased() {
    //Strings match 
}

ख।

if a.uppercased() == b.uppercased() {
    //Strings match 
}

सी।

if a.capitalized() == b.capitalized() {
    //Strings match 
}

Answer 7

localizedCaseInsensitiveContains : देता है कि क्या रिसीवर के पास केस-असंवेदनशील, स्थानीय-जागरूक खोज करके स्ट्रिंग है

if a.localizedCaseInsensitiveContains(b) {
    //returns true if a contains b (case insensitive)
}

संपादित :

caseInsensitiveCompare : केवल तुलना के रूप में NSCaseInsensitiveSearch के साथ तुलना (_: विकल्प :) को लागू करने का परिणाम देता है।

if a.caseInsensitiveCompare(b) == .orderedSame {
    //returns true if a equals b (case insensitive)
}

Comments

सवाल तुलना के बारे में है, न कि नियंत्रण के बारे में।

— जिम बेल्टर

यदि "a बी" और "बी" शामिल हैं, तो वे समान हैं। तो यह निश्चित रूप से एक संभव समाधान है, भले ही यह सबसे प्रभावी न हो।

— फिलिप मौरर

Answer 8

आप सभी अक्षरों को अपरकेस (या लोअरकेस) भी बना सकते हैं और देखें कि क्या वे समान हैं।

var a = “Cash”
var b = “CASh”

if a.uppercaseString == b.uppercaseString{
  //DO SOMETHING
}

यह दोनों चर को ”CASH”इस प्रकार बना देगा और इस प्रकार वे समान होंगे।

आप एक Stringएक्सटेंशन भी बना सकते हैं

extension String{
  func equalsIgnoreCase(string:String) -> Bool{
    return self.uppercaseString == string.uppercaseString
  }
}

if "Something ELSE".equalsIgnoreCase("something Else"){
  print("TRUE")
}

Comments

मामले को बदलना और फिर तुलना करना गलत है। प्रश्न के तहत टिप्पणी देखें।

— जिम बैटर

Answer 9

फोन नंबर तुलना उदाहरण; तेजी से 4.2 का उपयोग करना

var selectPhone = [String]()

if selectPhone.index(where: {$0.caseInsensitiveCompare(contactsList[indexPath.row].phone!) == .orderedSame}) != nil {
    print("Same value")
} else {
    print("Not the same")
}

Answer 10

स्विफ्ट 4, मैं एक टेम्पलेट के रूप में caseInsensitiveCompare () का उपयोग करके स्ट्रिंग एक्सटेंशन मार्ग पर गया (लेकिन ऑपरेंड को वैकल्पिक होने की अनुमति देता है)। यहाँ खेल का मैदान मैं इसे एक साथ रखा था (स्वागत से अधिक प्रतिक्रिया स्विफ्ट करने के लिए नया)।

import UIKit

extension String {
    func caseInsensitiveEquals<T>(_ otherString: T?) -> Bool where T : StringProtocol {
        guard let otherString = otherString else {
            return false
        }
        return self.caseInsensitiveCompare(otherString) == ComparisonResult.orderedSame
    }
}

"string 1".caseInsensitiveEquals("string 2") // false

"thingy".caseInsensitiveEquals("thingy") // true

let nilString1: String? = nil
"woohoo".caseInsensitiveEquals(nilString1) // false

Comments

आप .orderedSameइसके बजाय बस का उपयोग कर सकते हैं ComparisonResult.orderedSame।

— जिम बाल्टर

Answer 11

आप कोड के कुछ ही लाइन में तुलना के लिए अपने स्ट्रिंग एक्सटेंशन को लिख सकते हैं

extension String {

    func compare(_ with : String)->Bool{
        return self.caseInsensitiveCompare(with) == .orderedSame
    } 
}

Answer 12

स्विफ्ट 5 के लिए मामले की अनदेखी और दो स्ट्रिंग की तुलना करें

var a = "cash"
var b = "Cash"
if(a.caseInsensitiveCompare(b) == .orderedSame){
     print("Ok")
}

Answer 13

स्विफ्ट 3

if a.lowercased() == b.lowercased() {

}

Comments

ये गलत है। प्रश्न के तहत टिप्पणी देखें।

— जिम बैटर

Answer 14

स्विफ्ट 3 : आप अपने खुद के ऑपरेटर को परिभाषित कर सकते हैं, जैसे ~=।

infix operator ~=

func ~=(lhs: String, rhs: String) -> Bool {
   return lhs.caseInsensitiveCompare(rhs) == .orderedSame
}

जिसे आप तब खेल के मैदान में आजमा सकते हैं

let low = "hej"
let up = "Hej"

func test() {
    if low ~= up {
        print("same")
    } else {
        print("not same")
    }
}

test() // prints 'same'

Comments

मैंने इसे कम नहीं किया, लेकिन ध्यान दें कि यह आम तौर पर एक बहुत बुरा विचार है, क्योंकि ऊपर दिया गया कस्टम पैटर्न मिलान ऑपरेटर मूल पैटर्न पर वरीयता प्राप्त करेगा, जो आमतौर पर प्रत्येक String(या अन्य Stringशाब्दिक) से मिलान करते समय उपयोग किए जाने वाले मिलान पर होता है । let str = "isCAMELcase"एक मामले के साथ, इस प्रकार स्विच किए जाने की कल्पना करें case "IsCamelCase": ... :। ऊपर की विधि के साथ, यह caseसफलतापूर्वक दर्ज किया जाएगा, जो कि Stringपैटर्न मिलान के मानक libs कार्यान्वयन से आने की उम्मीद नहीं है । एक अद्यतन स्विफ्ट 3 का उत्तर हालांकि अभी भी अच्छा है, लेकिन ...

— 20

... एक कस्टम फ़ंक्शन (या Stringएक्सटेंशन) का उपयोग करके डिफ़ॉल्ट Stringपैटर्न से मेल खाने के बजाय सहायक के रूप में ऊपर विचार करें ।

— 20

Answer 15

extension String
{
    func equalIgnoreCase(_ compare:String) -> Bool
    {
        return self.uppercased() == compare.uppercased()
    }
}

उपयोग का नमूना

print("lala".equalIgnoreCase("LALA"))
print("l4la".equalIgnoreCase("LALA"))
print("laLa".equalIgnoreCase("LALA"))
print("LALa".equalIgnoreCase("LALA"))

Comments

यह कुछ भाषाओं में कुछ स्ट्रिंग्स के लिए काम नहीं करता है ... प्रश्न के तहत टिप्पणियों को देखें, और कई सही उत्तर, जिनमें से कुछ - स्वीकार किए गए एक सहित - आपके द्वारा वर्षों से पहले।

— जिम बाल्टर

Answer 16

स्विफ्ट 3:

आप दो स्ट्रिंग्स फ़ंक्शन के बीच स्थानीयकृत केस असंवेदनशील तुलना का उपयोग कर सकते हैं और यह वापस आ जाता है Bool

var a = "cash"
var b = "Cash"

if a.localizedCaseInsensitiveContains(b) {
    print("Identical")           
} else {
    print("Non Identical")
}

Comments

आपका समाधान गलत है। स्ट्रिंग्स "काशा" और "कैश" पर विचार करें

— क्लार्ककोक्स 3