Как сравнить две строки, игнорируя случай на языке Swift?

Question

Как мы можем сравнить две строки в случайном игнорировании? для например:

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

Есть ли метод, который возвращает истину, если мы сравним Var & Var Аргументы B

Answer 1

Попробуйте это:

Для старшего скор:

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

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

---

Swift 3,0

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

Answer 2

Попробуйте это:

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 NSComparisonResult : Int { 

    case OrderedAscending 
    case OrderedSame 
    case OrderedDescending 
} 

Вы можете использовать инструкцию if:

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

Answer 3

Может просто свернуть свой собственный:

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

Answer 4

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

Answer 5

Вы также могли бы сделать все буквы в верхний регистр (или строчные) и посмотреть, если они одинаковы.

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

Answer 6

Используйте caseInsensitiveCompare метод:

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

Answer 7

Swift 3

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

} 

Answer 8

Swift 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' 

Answer 9

Swift 3:

Вы также можете использовать локализованы регистрозависимости сравнение между функцией двух строк и возвращает Bool

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

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

Answer 10

Swift 3

ПРАВИЛЬНЫЙ ПУТЬ:

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 11

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

Answer 12

Swift 4, я пошел маршрут расширения строки с помощью caseInsensitiveCompare() в качестве шаблона (но позволяя операнд быть необязательным). Вот площадка, которую я использовал, чтобы собрать ее (новая для Swift так больше, чем приветствуется).

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 

Answer 13

localizedCaseInsensitiveContains: Возвращает приемник содержит ли данную строку, выполняя регистронезависимый, локализованный в курсе поиска

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