¿Cómo comparar dos cadenas ignorando mayúsculas y minúsculas en lenguaje Swift?

¿Cómo podemos comparar dos cadenas en caso de ignorar rápidamente? por ejemplo:

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

¿Existe algún método que devuelva verdadero si comparamos var a & var b

Prueba esto:

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)

el resultado es el tipo de enumeración NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Entonces puede usar la declaración if:

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

Prueba esto :

Para vencejos mayores:

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 le dice qué palabra viene antes que la otra en orden lexicográfico (es decir, cuál se acerca al principio de un diccionario). .orderedSamesignifica que las cadenas terminarían en el mismo lugar en el diccionario

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

MANERA CORRECTA:

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

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

Tenga en cuenta: ComparisonResult.orderedSame también se puede escribir como .orderedSame en forma abreviada.

OTRAS MANERAS:

a.

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

si.

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

C.

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

Podría simplemente rodar el suyo:

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

localizedCaseInsensitiveContains : Devuelve si el receptor contiene una cadena determinada mediante la realización de una búsqueda que no distingue entre mayúsculas y minúsculas y que reconoce la configuración regional.

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

Editado :

caseInsensitiveCompare : Devuelve el resultado de invocar compare (_: options :) con NSCaseInsensitiveSearch como única opción.

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

También puede poner todas las letras en mayúsculas (o minúsculas) y ver si son iguales.

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

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

Esto hará que ambas variables sean ”CASH” sean iguales.

También puedes hacer una Stringextensión

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

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

Ejemplo de comparación de números de teléfono; usando 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, fui por la ruta de extensión String usando caseInsensitiveCompare () como plantilla (pero permitiendo que el operando sea opcional). Aquí está el campo de juegos que solía armar (nuevo en Swift, así que los comentarios son más que bienvenidos).

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

Puede escribir su extensión de cadena para comparar en solo unas pocas líneas de código

extension String {

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

Para Swift 5 Ignorando el caso y comparar dos cuerdas

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

Swift 3

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

}

Swift 3 : puede definir su propio operador, por ejemplo ~=.

infix operator ~=

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

Que luego puedes probar en un parque infantil

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

muestra de uso

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

Swift 3:

También puede utilizar la comparación localizada que no distingue entre mayúsculas y minúsculas entre la función de dos cadenas y devuelve Bool

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

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