Wie vergleiche ich zwei Zeichenketten ohne Berücksichtigung von Fällen in Swift?

Verwenden Sie die caseInsensitiveCompare-Methode:

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

ComparisonResult gibt an, welches Wort in lexikographischer Reihenfolge früher kommt als das andere (d. H. Welches Wort näher an die Vorderseite eines Wörterbuchs kommt). .orderedSame bedeutet, dass die Zeichenfolgen an derselben Stelle im Wörterbuch enden

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

Versuche dies:

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)

ergebnis ist der Typ der NSComparisonResult-Enumeration:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Sie können also die if-Anweisung verwenden:

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

Könnte einfach nur selbst rollen:

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

Swift 3

DER RICHTIGE WEG:

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

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

Bitte beachten Sie:ComparisonResult.orderedSame kann auch als .orderedSame in Kurzform geschrieben werden.

ANDERE MÖGLICHKEITEN:

ein.

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

b.

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

c.

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

Beispiel für Telefonnummernvergleich; mit Swift 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")
     }

Sie können auch alle Buchstaben in Großbuchstaben (oder Kleinbuchstaben) setzen und sehen, ob sie gleich sind.

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

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

Dies macht beide Variablen zu ”CASH” und somit sind sie gleich.

Sie können auch eine Erweiterung String erstellen

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

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

localizedCaseInsensitiveContains : Gibt zurück, ob der Empfänger eine bestimmte Zeichenfolge enthält, indem eine Groß-/Kleinschreibung verwendet wird, die die Ländereinstellung berücksichtigt

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

bearbeitet :

caseInsensitiveCompare : Gibt das Ergebnis des Aufrufs von compare (_: options :) mit NSCaseInsensitiveSearch als einzige Option zurück.

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

Sie können einfach Ihre String-Erweiterung zum Vergleich in nur wenigen Codezeilen schreiben

extension String {

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

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

verwendungsbeispiel

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

Für Swift 5 Ignorieren Sie die Groß-/Kleinschreibung und vergleichen Sie zwei Zeichenfolgen

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

In Swift 4 ging ich die String-Erweiterungsroute mit caseInsensitiveCompare () als Vorlage (wobei der Operand optional sein konnte). Hier ist der Spielplatz, an dem ich ihn zusammengebaut habe (neu bei Swift, also Feedback ist mehr als willkommen).

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