วิธีเปรียบเทียบสองสตริงโดยไม่สนใจตัวพิมพ์เล็กและใหญ่ในภาษา Swift

เราจะเปรียบเทียบสองสตริงในกรณีที่ไม่สนใจอย่างรวดเร็วได้อย่างไร สำหรับเช่น:

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

มีวิธีใดบ้างที่จะคืนค่าจริงถ้าเราเปรียบเทียบ var a & var b

ลองสิ่งนี้:

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)

ผลลัพธ์คือประเภทของ NSComparisonResult enum:

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

ดังนั้นคุณสามารถใช้คำสั่ง if:

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

ลองสิ่งนี้:

สำหรับสวิฟต์รุ่นเก่า:

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

ใช้caseInsensitiveCompareวิธีการ:

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

ComparisonResultจะบอกให้คุณทราบว่าคำใดมาเร็วกว่าคำอื่น ๆ ในลำดับพจนานุกรม (กล่าวคือคำใดเข้ามาใกล้หน้าพจนานุกรม) .orderedSameหมายความว่าสตริงจะจบลงที่จุดเดียวกันในพจนานุกรม

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

วิธีที่ถูกต้อง:

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

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

โปรดทราบ: ComparisonResult.orderedSame ยังสามารถเขียนเป็น. orderSame ในชวเลขได้

ทางอื่น:

ก.

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

ข.

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

ค.

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

สามารถม้วนของคุณเอง:

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

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

คุณยังสามารถทำให้ตัวอักษรทั้งหมดเป็นตัวพิมพ์ใหญ่ (หรือตัวพิมพ์เล็ก) และดูว่าเหมือนกันหรือไม่

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

ตัวอย่างการเปรียบเทียบหมายเลขโทรศัพท์ โดยใช้ 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 ฉันไปเส้นทางส่วนขยาย 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

คุณสามารถเขียน String Extension เพื่อเปรียบเทียบได้ในโค้ดไม่กี่บรรทัด

extension String {

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

สำหรับ Swift 5 ละเว้นเคสและเปรียบเทียบสองสตริง

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

สวิฟต์ 3

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

}

สวิฟท์ 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'

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

Swift 3:

คุณยังสามารถใช้การเปรียบเทียบแบบไม่คำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ที่แปลแล้วระหว่างฟังก์ชันสองสตริงและส่งกลับ Bool

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

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