Como comparar duas strings ignorando maiúsculas e minúsculas na linguagem Swift?

Como podemos comparar duas cordas ignorando maiúsculas e minúsculas? por exemplo:

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

Existe algum método que retornará verdadeiro se compararmos var a & var b

Experimente isto:

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)

o resultado é um tipo de enum NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Portanto, você pode usar a instrução if:

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

Experimente isto:

Para o Swift mais antigo:

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

caseInsensitiveCompareMétodo de uso :

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

ComparisonResult informa qual palavra vem antes da outra em ordem lexicográfica (ou seja, qual palavra vem mais perto do início de um dicionário). .orderedSamesignifica que as strings iriam parar no mesmo lugar no dicionário

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

Poderia apenas rolar o seu próprio:

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

MANEIRA CORRETA:

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

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

Observação: ComparisonResult.orderedSame também pode ser escrito como .orderedSame abreviadamente.

OUTRAS MANEIRAS:

uma.

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

b.

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

c.

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

localizedCaseInsensitiveContains : retorna se o receptor contém uma determinada string executando uma pesquisa que não diferencia maiúsculas de minúsculas e reconhece a localidade

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

Editado :

caseInsensitiveCompare : Retorna o resultado de chamar compare (_: options :) com NSCaseInsensitiveSearch como a única opção.

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

Você também pode colocar todas as letras em maiúsculas (ou minúsculas) e ver se elas são iguais.

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

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

Isso fará com que ambas as variáveis ”CASH”sejam iguais.

Você também pode fazer uma Stringextensão

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

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

Exemplo de comparação de números de telefone; usando o 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, usei a rota de extensão String usando caseInsensitiveCompare () como um modelo (mas permitindo que o operando seja opcional). Aqui está o playground que eu costumava montar (novo no Swift, então, o feedback é mais do que bem-vindo).

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

Você pode simplesmente escrever sua extensão de string para comparação em apenas algumas linhas de código

extension String {

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

Para Swift 5 Ignorar o caso e comparar duas cordas

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

Swift 3

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

}

Swift 3 : Você pode definir sua própria operadora, por exemplo ~=.

infix operator ~=

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

Que você pode tentar em um playground

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

amostra de uso

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

Swift 3:

Você também pode usar a comparação localizada sem distinção entre maiúsculas e minúsculas entre a função de duas strings e ela retorna Bool

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

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