스위프트 언어에서 대소문자를 무시한 두 문자열을 비교하는 방법은 무엇입니까?

스위프트 언어에서 대소문자를 무시한 두 문자열을 비교하는 방법은 무엇입니까?

swift ignore case에서 두 문자열을 어떻게 비교할 수 있습니까? 예를 들어:

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

변수와 변수를 비교하면 참이 되는 방법이 있습니까?

사용해 보십시오.

오래된 스위프트의 경우:

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

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

---

스위프트 3+

var a : String = "Cash"
var b : String = "cash"
    
if(a.caseInsensitiveCompare(b) == .orderedSame){
    print("Et voila")
}

사용하다caseInsensitiveCompare방법:

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

비교 결과는 사전 순서에서 다른 단어보다 먼저 오는 단어(즉, 사전 앞에 가까운 단어)를 알려줍니다..orderedSame문자열이 사전의 같은 위치에 있다는 것을 의미합니다.

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

사용해 보십시오.

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는 NSComparisonResultenum 유형입니다.

enum NSComparisonResult : Int {

    case OrderedAscending
    case OrderedSame
    case OrderedDescending
}

따라서 if 문을 사용할 수 있습니다.

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

localizedCaseInsensitiveContains : 대소문자를 구분하지 않는 로케일 인식 검색을 수행하여 수신기에 지정된 문자열이 포함되어 있는지 여부를 반환합니다.

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

편집:

caseInsensitiveCompare : NSCaseInsensitiveSearch를 유일한 옵션으로 사용하여 비교(_:options:)를 호출한 결과를 반환합니다.

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

올바른 방법:

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

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

참고:ComparisonResult.orderedSame은 단축어로 .orderedSame으로 쓸 수도 있습니다.

기타 방법:

a.

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

b.

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

c.

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

그냥 당신만의 것을 굴릴 수 있습니다.

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

전화 번호 비교 예: 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")
}

문자열 확장자를 몇 줄의 코드로 비교할 수 있습니다.

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

스위프트 4, 나는 케이스를 이용하여 스트링 확장 루트를 갔습니다.InsensitiveCompare()를 템플릿으로 비교합니다(단, 피연산자를 선택 사항으로 허용).이것은 제가 그것을 조립하기 위해 사용했던 놀이터입니다. (스위프트는 처음이라 환영할 만합니다.)

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

이에 대한 확장 함수를 만들었습니다.통과하다caseSensitive~하듯이false대소문자를 구분하지 않는 비교를 원하는 경우.

extension String {
    
    func equals(to string: String, caseSensitive: Bool = true) -> Bool {
        if caseSensitive {
            return self.compare(string) == .orderedSame
        } else {
            return self.caseInsensitiveCompare(string) == .orderedSame
        }
    }
}

예:

"cash".equals(to: "Cash", caseSensitive: false) //returns true
"cash".equals(to: "Cash") //returns false

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'

또한 모든 문자를 대문자(또는 소문자)로 만들고 동일한지 확인할 수 있습니다.

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

스위프트 3

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

}

스위프트 3:

또한 두 문자열 함수 사이의 현지화된 대소문자 구분 안 함 비교를 사용할 수 있으며 이는 반환됩니다.Bool

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

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

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

언급URL : https://stackoverflow.com/questions/30532728/how-to-compare-two-strings-ignoring-case-in-swift-language