Comment pouvons-nous comparer deux chaînes dans Swift en ignorant la casse?
var a = "Cash"
var b = "cash"
Existe-t-il une méthode qui retourne true si on compare var a & var b
Essaye ça :
Pour les Swift plus âgés:
var a : String = "Cash"
var b : String = "cash"
if(a.caseInsensitiveCompare(b) == NSComparisonResult.OrderedSame){
println("voila")
}
Swift 3.0 & 4.1
var a : String = "Cash"
var b : String = "cash"
if(a.caseInsensitiveCompare(b) == .orderedSame){
print("voila")
}
Utilisez la méthode caseInsensitiveCompare
:
let a = "Cash"
let b = "cash"
let c = a.caseInsensitiveCompare(b) == .orderedSame
print(c) // "true"
ComparisonResult vous indique quel mot vient plus tôt que l'autre dans l'ordre lexicographique (c'est-à-dire lequel se rapproche le plus du début d'un dictionnaire). .orderedSame
signifie que les chaînes se retrouveraient au même endroit dans le dictionnaire
if a.lowercaseString == b.lowercaseString {
//Strings match
}
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)
le résultat est le type de NSComparisonResult enum:
enum NSComparisonResult : Int {
case OrderedAscending
case OrderedSame
case OrderedDescending
}
Donc, vous pouvez utiliser si déclaration:
if result == .OrderedSame {
println("equal")
} else {
println("not equal")
}
Pourriez rouler le vôtre:
func equalIgnoringCase(a:String, b:String) -> Bool {
return a.lowercaseString == b.lowercaseString
}
Swift 3
CORRIGER LA VOIE:
let a: String = "Cash"
let b: String = "cash"
if a.caseInsensitiveCompare(b) == .orderedSame {
//Strings match
}
Remarque:ComparisonResult.orderedSame peut également être écrit au format .orderedSame.
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
}
Exemple de comparaison de numéros de téléphone; en utilisant 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")
}
Vous pouvez également mettre toutes les lettres en majuscule (ou minuscule) et voir si elles sont identiques.
var a = “Cash”
var b = “CASh”
if a.uppercaseString == b.uppercaseString{
//DO SOMETHING
}
Cela rendra les deux variables sous la forme ”CASH”
et elles seront donc égales.
Vous pouvez également créer une extension String
extension String{
func equalsIgnoreCase(string:String) -> Bool{
return self.uppercaseString == string.uppercaseString
}
}
if "Something ELSE".equalsIgnoreCase("something Else"){
print("TRUE")
}
localizedCaseInsensitiveContains : Indique si le destinataire contient une chaîne donnée en effectuant une recherche tenant compte des paramètres régionaux et respectant les cas
if a.localizedCaseInsensitiveContains(b) {
//returns true if a contains b (case insensitive)
}
Edité :
caseInsensitiveCompare : Renvoie le résultat de l'appel de compare (_: options :) avec NSCaseInsensitiveSearch comme seule option.
if a.caseInsensitiveCompare(b) == .orderedSame {
//returns true if a equals b (case insensitive)
}
Vous pouvez simplement écrire votre extension de chaîne à des fins de comparaison en quelques lignes de code.
extension String {
func compare(_ with : String)->Bool{
return self.caseInsensitiveCompare(with) == .orderedSame
}
}
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"))
Pour Swift 5 Ignorer la casse et comparer deux chaînes
var a = "cash"
var b = "Cash"
if(a.caseInsensitiveCompare(b) == .orderedSame){
print("Ok")
}
Swift 4, j’ai choisi la route d’extension String 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 alors vos commentaires sont plus que 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