Wie vergleiche ich zwei Zeichenfolgen, wobei die Groß- und Kleinschreibung in der Swift-Sprache ignoriert wird?

Wie können wir zwei Zeichenfolgen in einem schnell ignorierenden Fall vergleichen? für zB:

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

Gibt es eine Methode, die true zurückgibt, wenn wir var a & var b vergleichen?

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-Aufzählung:

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")
}

Versuche dies :

Für ältere schnelle:

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

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

Swift 3+

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

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

Verwendung caseInsensitiveCompareMethode:

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

ComparisonResult gibt an, welches Wort in lexikografischer Reihenfolge früher als das andere kommt (dh welches näher an die Vorderseite eines Wörterbuchs kommt). .orderedSamebedeutet, dass die Zeichenfolgen an derselben Stelle im Wörterbuch landen würden

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

Könnte einfach dein eigenes rollen:

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

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 in Kurzform als .orderedSame 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 
}

localizedCaseInsensitiveContains : Gibt zurück, ob der Empfänger eine bestimmte Zeichenfolge enthält, indem eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung durchgeführt wird

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 einziger Option zurück.

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

Sie können auch alle Buchstaben in Groß- oder Kleinbuchstaben schreiben und prüfen, ob sie identisch sind.

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

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

Dadurch werden beide Variablen als ”CASH” und somit gleich.

Sie können auch eine StringErweiterung vornehmen

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

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

Beispiel für den Vergleich von Telefonnummern; 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")
}

Swift 4, ich bin die String-Erweiterungsroute mit caseInsensitiveCompare () als Vorlage gegangen (wobei der Operand optional sein konnte). Hier ist der Spielplatz, auf dem ich ihn zusammengestellt habe (neu bei Swift, daher Feedback 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

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

extension String {

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

Für Swift 5 Ignorieren Sie den Fall und vergleichen Sie zwei Zeichenfolgen

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

Swift 3

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

}

Swift 3 : Sie können Ihren eigenen Operator definieren, z ~=.

infix operator ~=

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

Was Sie dann auf einem Spielplatz ausprobieren können

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

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

test() // prints 'same'

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"))

Swift 3:

Sie können auch den lokalisierten Vergleich zwischen zwei Zeichenfolgen verwenden, bei dem die Groß- und Kleinschreibung nicht berücksichtigt wird und der zurückgegeben wird Bool

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

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