Bagaimana cara membandingkan dua string mengabaikan kasus dalam bahasa Swift?

Bagaimana kita bisa membandingkan dua string dalam kasus pengabaian cepat? misalnya:

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

Apakah ada metode yang akan mengembalikan true jika kita membandingkan var a & var b

Coba ini:

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)

hasilnya adalah jenis enum NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Jadi Anda bisa menggunakan pernyataan if:

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

Coba ini :

Untuk swift yang lebih tua:

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

if(a.caseInsensitiveCompare(b) == NSComparisonResult.OrderedSame){
    println("voila")
}

Cepat 3+

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

if(a.caseInsensitiveCompare(b) == .orderedSame){
    print("voila")
}

Gunakan caseInsensitiveComparemetode:

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

ComparisonResult memberi tahu Anda kata mana yang muncul lebih awal dari yang lain dalam urutan leksikografik (yaitu kata mana yang lebih dekat ke depan kamus). .orderedSameartinya string akan berakhir di tempat yang sama di kamus

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

JALAN YANG BENAR:

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

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

Harap diperhatikan: ComparisonResult.orderedSame juga dapat ditulis sebagai .orderedSame dalam singkatan.

CARA LAIN:

Sebuah.

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

b.

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

c.

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

Bisa gulung sendiri:

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

localizedCaseInsensitiveContains : Mengembalikan apakah penerima berisi string tertentu dengan melakukan pencarian case-insensitive, locale-aware

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

Diedit :

caseInsensitiveCompare : Menampilkan hasil pemanggilan bandingkan (_: options :) dengan NSCaseInsensitiveSearch sebagai satu-satunya opsi.

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

Anda juga bisa membuat semua huruf menjadi huruf besar (atau huruf kecil) dan melihat apakah semuanya sama.

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

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

Ini akan membuat kedua variabel menjadi sama ”CASH”dan karenanya sama.

Anda juga bisa membuat Stringekstensi

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

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

Contoh perbandingan nomor telepon; menggunakan 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, saya menggunakan rute ekstensi String menggunakan caseInsensitiveCompare () sebagai template (tetapi mengizinkan operan menjadi opsional). Inilah taman bermain yang saya gunakan untuk menggabungkannya (baru mengenal Swift jadi umpan balik lebih dari diterima).

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

Anda bisa menulis Ekstensi String untuk perbandingan hanya dalam beberapa baris kode

extension String {

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

Untuk Swift 5 Mengabaikan case dan membandingkan dua string

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

Cepat 3

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

}

Swift 3 : Anda dapat menentukan operator Anda sendiri, mis ~=.

infix operator ~=

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

Yang kemudian bisa Anda coba di taman bermain

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

contoh penggunaan

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

Cepat 3:

Anda juga dapat menggunakan perbandingan tidak peka huruf besar / kecil yang dilokalkan antara dua fungsi string dan mengembalikannya Bool

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

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