Question Comment comparer deux chaînes en ignorant la casse dans le langage Swift?


Comment pouvons-nous comparer deux chaînes en ignorant rapidement les cas? pour par exemple:

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

Existe-t-il une méthode qui retourne true si on compare var a et var b


68
2018-05-29 14:53


origine


Réponses:


Essaye ça :

Pour les plus âgés:

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

128
2018-05-29 15:06



Utilisation caseInsensitiveCompare méthode:

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

ComparaisonRésultat vous indique quel mot est antérieur à l'autre dans l'ordre lexicographique (c'est-à-dire celui qui se rapproche le plus d'un dictionnaire). .orderedSame signifie que les chaînes se retrouveraient au même endroit dans le dictionnaire


25
2018-05-29 15:05



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

18
2018-05-29 15:00



Essaye ça:

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)

résultat est le type de NSComparisonResult enum:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Donc, vous pouvez utiliser if statement:

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

8
2018-05-29 14:57



Pourrais-tu rouler toi-même:

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

4
2018-05-29 14:59



Swift 3

VOIE CORRECTE:

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

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

Notez s'il vous plaît: ComparisonResult.orderedSame peut également être écrit en tant que .orderedSame en abrégé.

D'AUTRES MOYENS:

une.

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

b.

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

c.

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

3
2018-05-08 17:03



Vous pouvez également mettre toutes les lettres en majuscule (ou en minuscule) et voir si elles sont identiques.

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

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

Cela fera les deux variables comme ”CASH” et ainsi ils sont égaux.

Vous pourriez aussi faire un String extension

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

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

1
2018-05-29 15:01



extension String
{
    func equalIgnoreCase(_ compare:String) -> Bool
    {
        return self.uppercased() == compare.uppercased()
    }
}

échantillon d'utilisation

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

0
2017-12-22 06:58



Swift 4, je suis allé sur la route d'extension de chaîne en utilisant caseInsensitiveCompare () comme modèle (mais en permettant à l'opérande d'être facultatif). Voici le terrain de jeu que j'avais l'habitude de mettre en place (nouveau pour Swift, les commentaires sont donc les bienvenus).

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

0
2018-01-23 00:01



localizedCaseInsensitiveContains : Indique si le récepteur contient une chaîne donnée en effectuant une recherche insensible à la casse et aux paramètres régionaux

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

0
2018-03-05 05:02