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

Ответ 1

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

Для старшего Свифта:

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

Ответ 2

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

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

ComparisonResult сообщает вам, какое слово встречается раньше, чем другое в лексикографическом порядке (т. Е. Какое слово ближе к началу словаря). .orderedSame означает, что строки .orderedSame в одном месте в словаре

Ответ 3

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

Ответ 4

Попробуйте следующее:

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)

result - тип перечисления NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Итак, вы можете использовать оператор if:

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

Ответ 5

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

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

Ответ 6

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 
    }

Ответ 7

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

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

Ответ 8

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

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

Отредактировано:

caseInsensitiveCompare: возвращает результат вызова сравнения (_: options :) с NSCaseInsensitiveSearch в качестве единственной опции.

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

Ответ 9

Пример сравнения телефонных номеров; используя 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")
     }

Ответ 10

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

Ответ 11

Swift 4, я пошел по пути расширения String, используя 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

Ответ 12

Вы можете просто написать свое String Extension для сравнения всего за несколько строк кода

extension String {

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

Ответ 13

Для Swift 5 игнорируем регистр и сравниваем две строки

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

Ответ 14

Swift 3

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

}

Ответ 15

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'

Ответ 16

Swift 3:

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

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

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