Come confrontare due stringhe ignorando il caso in linguaggio Swift?

Come possiamo confrontare due stringhe ignorando rapidamente il caso? per esempio:

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

Esiste un metodo che restituirà true se confrontiamo var a e var b

Prova questo:

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)

il risultato è il tipo di enumerazione NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Quindi puoi usare l'istruzione if:

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

Prova questo :

Per i più anziani Swift:

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

Usa il caseInsensitiveComparemetodo:

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

ComparisonResult ti dice quale parola viene prima dell'altra in ordine lessicografico (cioè quale si avvicina alla parte anteriore di un dizionario). .orderedSamesignifica che le stringhe finirebbero nello stesso punto del dizionario

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

MODO CORRETTO:

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

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

Nota: ComparisonResult.orderedSame può anche essere scritto come .orderedSame in forma abbreviata.

ALTRI MODI:

un.

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

b.

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

c.

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

Potrebbe semplicemente rotolare il tuo:

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

localizedCaseInsensitiveContains : restituisce se il destinatario contiene una determinata stringa eseguendo una ricerca senza distinzione tra maiuscole e minuscole, che riconosce le impostazioni locali

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

Modificato :

caseInsensitiveCompare : restituisce il risultato dell'invocazione di compare (_: opzioni :) con NSCaseInsensitiveSearch come unica opzione.

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

Potresti anche scrivere tutte le lettere in maiuscolo (o minuscolo) e vedere se sono uguali.

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

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

Questo renderà entrambe le variabili come ”CASH”e quindi saranno uguali.

Potresti anche creare Stringun'estensione

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

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

Esempio di confronto dei numeri di telefono; utilizzando 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, ho seguito il percorso di estensione String utilizzando caseInsensitiveCompare () come modello (ma consentendo all'operando di essere un opzionale). Ecco il parco giochi che ho usato per metterlo insieme (nuovo per Swift, quindi feedback più che benvenuto).

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

Puoi semplicemente scrivere la tua estensione stringa per il confronto in poche righe di codice

extension String {

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

Per Swift 5 Ignorare il caso e confrontare due stringhe

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

Swift 3

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

}

Swift 3 : puoi definire il tuo operatore, ad es ~=.

infix operator ~=

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

Che poi puoi provare in un parco giochi

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

campione di utilizzo

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

Swift 3:

È inoltre possibile utilizzare il confronto localizzato senza distinzione tra maiuscole e minuscole tra due funzioni di stringhe e restituisce Bool

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

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