Làm thế nào để so sánh hai chuỗi bỏ qua chữ hoa và chữ thường trong ngôn ngữ Swift?

Làm thế nào chúng ta có thể so sánh hai chuỗi trong trường hợp bỏ qua nhanh chóng? ví dụ:

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

Có phương thức nào sẽ trả về true nếu chúng ta so sánh var a & var b không

Thử cái này:

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)

kết quả là kiểu enum NSComparisonResult:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

Vì vậy, bạn có thể sử dụng câu lệnh if:

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

Thử cái này :

Đối với yến cũ:

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

Sử dụng caseInsensitiveComparephương pháp:

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

ComparisonResult cho bạn biết từ nào đến sớm hơn từ khác theo thứ tự từ vựng (tức là từ nào đến gần phía trước của từ điển). .orderedSamecó nghĩa là các chuỗi sẽ kết thúc ở cùng một vị trí trong từ điển

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

CÁCH ĐÚNG:

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

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

Xin lưu ý: ComparisonResult.orderedSame cũng có thể được viết tắt là .orderedSame.

NHỮNG CÁCH KHÁC:

a.

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

b.

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

c.

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

Có thể chỉ cuộn của riêng bạn:

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

localizedCaseInsensitiveContains : Trả về liệu bộ thu có chứa một chuỗi đã cho hay không bằng cách thực hiện tìm kiếm không phân biệt chữ hoa chữ thường, nhận biết ngôn ngữ

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

Đã chỉnh sửa :

caseInsensitiveCompare : Trả về kết quả của việc gọi so sánh (_: tùy chọn :) với NSCaseInsensitiveSearch là tùy chọn duy nhất.

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

Bạn cũng có thể viết hoa tất cả các chữ cái (hoặc chữ thường) và xem chúng có giống nhau không.

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

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

Điều này sẽ làm cho cả hai biến là ”CASH”và do đó chúng bằng nhau.

Bạn cũng có thể tạo một Stringphần mở rộng

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

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

Ví dụ so sánh số điện thoại; sử dụng nhanh chóng 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, tôi đã đi theo lộ trình mở rộng chuỗi bằng cách sử dụng caseInsensitiveCompare () làm mẫu (nhưng cho phép toán hạng là một tùy chọn). Đây là sân chơi mà tôi đã sử dụng để tập hợp nó lại với nhau (mới sử dụng Swift nên rất hoan nghênh phản hồi).

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

Bạn chỉ có thể viết Phần mở rộng chuỗi của mình để so sánh chỉ trong một vài dòng mã

extension String {

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

Đối với Swift 5 Bỏ qua trường hợp và so sánh hai chuỗi

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

Swift 3

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

}

Swift 3 : Bạn có thể xác định toán tử của riêng mình, ví dụ ~=.

infix operator ~=

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

Sau đó, bạn có thể thử trong một sân chơi

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

mẫu sử dụng

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

Swift 3:

Bạn cũng có thể sử dụng so sánh không phân biệt chữ hoa chữ thường được bản địa hóa giữa hàm hai chuỗi và nó trả về Bool

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

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