如何比较 swift 中包含 unicode 字符的字符串相等性？

Question

In my application I am trying to compare the values coming in from a repo which has number of JSON files, each JSON file will have values for some country as a dictionary for example:

{cz: "Doplňky k Apple TV"
 dk: "Apple TVtilbehør" }  //string1 == "Doplňky k Apple TV"

Similary I have a local plist which also will have dict for same countries for example:

{cz: "Doplňky*k*Apple*TV"
 dk: "*Apple*TV*Tilbehør*" } //string2 == "Doplňky*k*Apple*TV"

So, basically I need to compare each country values and then show only differences to the user.

So, in this case cz value in JSON file(string1) and local plist(string2) are same except for the fact that string2 has asterisk in it. When I just remove asterisk and compare the strings, they still don't match since Doplňky k Apple TV has invisible unicode space after Apple in string1 which looks like a whitespace.

Below is my code to implement the logic:

if string2.replaceString(["*", "\u{00a0}"], " ").trimmingCharacters(in: .whitespaces) == string1.replacingOccurrences(of: "\u{00a0}", with: " "){
  //Do something
}

Answer 1

Doplňky k Apple TV string looks like that it comes from the Apple website. When I checked it on their website, this string, it contains NO-BREAK SPACE (U+00A0) between Apple & TV . It's a white space character, but it doesn't equal to a normal SPACE (U+0020).

"Doplňky k Apple\u{00a0}TV" == "Doplňky k Apple TV" // false

First thing to specify - does it matter? Should we treat it as equal or not?

Then you have Apple TVtilbehør & *Apple*TV*Tilbehør* strings. Is it intentional typo? Or Apple TVtilbehør should be Apple TV Tilbehør ? Let's assume it's intentional typo to test your comparison.

Next, these * (at the beginning/end) in the *Apple*TV*Tilbehør* string are...? Second thing to specify - should we ignore them? Do they represent a whitespace?

Next thing is the Unicode equivalence . How would you like to compare these two strings? Swift helps you here (source ):

Comparing strings for equality using the equal-to operator ( == ) or a relational operator (like < or >= ) is always performed using Unicode canonical representation. As a result, different representations of a string compare as being equal.

"Cafe\u{301}" == "Café" // true

What about other countries? Like Germany where Straße equals to Strasse ? Third thing to specify - how we should treat these strings?

As you can see, there's a lot of things one should think about. Do you have a specification? Follow it. No specification? Your algorithm will stop working sooner or later.

Playground

I took the liberty to specify all these things by myself:

• All whitespaces do equal
• * at the beginning/end doesn't matter (ignored)
• Straße does not equal to Strasse

Sample code:

import Foundation

let json = [
    // U+00A0 is NO-BREAK SPACE which looks like a normal space (U+0020)
    "cz": "Doplňky k Apple\u{00a0}TV",
    "dk": "Apple TV Tilbehør",
    "en": "Hello",
    "de": "Straße",
    "fr": "Expos\u{00E9}" // Exposé
]

let plist = [
    "cz": "Doplňky*k*Apple*TV",
    "dk": "*Apple*TV*Tilbehør*",
    "es": "Hola",
    "de": "Strasse",
    "fr": "Expose\u{0301}" // Exposé
]

let jsonKeys = Set(json.keys)
let plistKeys = Set(plist.keys)
let commonKeys = jsonKeys.intersection(plistKeys)
let keysMissingInJson = plistKeys.subtracting(jsonKeys)
let keysMissingInPlist = jsonKeys.subtracting(plistKeys)

print("Languages missing in JSON: \(keysMissingInJson.count)")
keysMissingInJson.forEach { key in
    print(" - \(key)")
}

print("Languages missing in PLIST: \(keysMissingInPlist.count)")
keysMissingInPlist.forEach { key in
    print(" - \(key)")
}

let differentValueKeys: [String] = commonKeys.compactMap { key in
    guard let initialJsonValue = json[key], let initialPlistValue = plist[key] else {
        fatalError("Fix commonKeys")
    }
    
    // Replace all whitespace characters with a normal space
    let jsonValue = String(
        initialJsonValue.map { $0.isWhitespace ? " " : $0 }
    )
    
    let plistValue = initialPlistValue
        // Replace all * with a normal whitespace
        .replacingOccurrences(of: "*", with: " ")
        // Trim all whitespace characters from the beginning/end
        .trimmingCharacters(in: .whitespaces)
    
    return jsonValue == plistValue ? nil : key
}

print("Different values: \(differentValueKeys.count)")
differentValueKeys.forEach { key in
    print(" - \(key): JSON(\(json[key]!)) PLIST(\(plist[key]!))")
}

Output:

Languages missing in JSON: 1
 - es
Languages missing in PLIST: 1
 - en
Different values: 1
 - de: JSON(Straße) PLIST(Strasse)