क्या कैरेक्टरसेट में स्विफ्ट 4 में कैरेक्टर है या नहीं, यह जांचने का सबसे अच्छा तरीका क्या है?

Question

मैं स्विफ्ट 4 में एक तरीका ढूंढ रहा हूं, यह जांचने के लिए कि कोई कैरेक्टर मनमाने ढंग से कैरेक्टरसेट का सदस्य है या नहीं। मेरे पास यह Scanner वर्ग है जिसका उपयोग कुछ हल्के पार्सिंग के लिए किया जाएगा। कक्षा में कार्यों में से एक मौजूदा वर्ण पर, किसी भी वर्ण को छोड़ना है, जो संभव वर्णों के एक निश्चित सेट से संबंधित है।

class MyScanner { 
    let str: String 
    var idx: String.Index 
    init(_ string: String) { 
    str = string 
    idx = str.startIndex 
    } 
    var remains: String { return String(str[idx..<str.endIndex])} 

    func skip(charactersIn characters: CharacterSet) { 
    while idx < str.endIndex && characters.contains(str[idx])) { 
     idx = source.index(idx, offsetBy: 1) 
    } 
    } 
} 

let scanner = MyScanner("fizz buzz fizz") 
scanner.skip(charactersIn: CharacterSet.alphanumerics) 
scanner.skip(charactersIn: CharacterSet.whitespaces) 
print("what remains: \"\(scanner.remains)\"") 

मैं skip(charactersIn:) समारोह को लागू करने के लिए इतना है कि इसके बाद के संस्करण कोड buzz fizz मुद्रित होगा चाहते हैं।

मुश्किल हिस्सा while में characters.contains(str[idx])) है - .contains() एक Unicode.Scalar आवश्यकता है, और मैं एक नुकसान अगले कदम पता लगाने की कोशिश में हूँ।

मैं मैं skip कार्य करने के लिए एक String पास कर सकता है पता है, लेकिन मैं क्योंकि सभी सुविधाजनक स्थिर सदस्यों (alphanumerics, whitespaces, आदि) की, यह एक CharacterSet के साथ काम करने के लिए एक रास्ता खोजने के लिए चाहते हैं।

का परीक्षण कैसे करता है यदि इसमें Character है?

Answer 1

मुझे पता है कि आप उपयोग करना चाहता था कर रहे हैं कर सकते हैं CharacterSetString के बजाय, लेकिन CharacterSet एक से अधिक Unicode.Scalar से बना वर्णों का समर्थन नहीं करता है (अभी तक, कम से कम)। डब्ल्यूडब्ल्यूडीसी 2017 वीडियो What's New in Swift में स्ट्रिंग चर्चा में ऐप्पल ने "पारिवारिक" चरित्र() या अंतर्राष्ट्रीय ध्वज वर्ण (उदा। "" या "") देखें। कई त्वचा टोन इमोजी भी इस व्यवहार को प्रकट करते हैं (उदा। बनाम)।

परिणामस्वरूप, मैं CharacterSet का उपयोग करने से सावधान रहूंगा (जो "खोज परिचालनों में उपयोग के लिए यूनिकोड वर्ण मानों का सेट" है)। या, यदि आप सुविधा के लिए इस विधि को प्रदान करना चाहते हैं, तो ध्यान रखें कि यह एकाधिक यूनिकोड स्केलर्स द्वारा वर्णित वर्णों के साथ सही ढंग से काम नहीं करेगा।

तो, आप एक स्कैनर कि दोनों CharacterSet और Stringskip विधि के renditions प्रदान करता है पेश कर सकती है:

class MyScanner { 
    let string: String 
    var index: String.Index 

    init(_ string: String) { 
     self.string = string 
     index = string.startIndex 
    } 

    var remains: String { return String(string[index...]) } 

    /// Skip characters in a string 
    /// 
    /// This rendition is safe to use with strings that have characters 
    /// represented by more than one unicode scalar. 
    /// 
    /// - Parameter skipString: A string with all of the characters to skip. 

    func skip(charactersIn skipString: String) { 
     while index < string.endIndex, skipString.contains(string[index]) { 
      index = string.index(index, offsetBy: 1) 
     } 
    } 

    /// Skip characters in character set 
    /// 
    /// Note, character sets cannot (yet) include characters that are represented by 
    /// more than one unicode scalar (e.g. ‍‍‍ or or). If you want to test 
    /// for these multi-unicode characters, you have to use the `String` rendition of 
    /// this method. 
    /// 
    /// This will simply stop scanning if it encounters a multi-unicode character in 
    /// the string being scanned (because it knows the `CharacterSet` can only represent 
    /// single-unicode characters) and you want to avoid false positives (e.g., mistaking 
    /// the Jamaican flag, , for the Japanese flag,). 
    /// 
    /// - Parameter characterSet: The character set to check for membership. 

    func skip(charactersIn characterSet: CharacterSet) { 
     while index < string.endIndex, 
      string[index].unicodeScalars.count == 1, 
      let character = string[index].unicodeScalars.first, 
      characterSet.contains(character) { 
       index = string.index(index, offsetBy: 1) 
     } 
    } 

} 

इस प्रकार, आपके सरल उदाहरण अभी भी काम करेगा:

let scanner = MyScanner("fizz buzz fizz") 
scanner.skip(charactersIn: CharacterSet.alphanumerics) 
scanner.skip(charactersIn: CharacterSet.whitespaces) 
print(scanner.remains) // "buzz fizz" 

लेकिन String का उपयोग प्रतिपादन यदि आप जिन अक्षरों को छोड़ना चाहते हैं उनमें एकाधिक यूनिकोड स्केलर शामिल हो सकते हैं:

let family = "\u{200D}\u{200D}\u{200D}" // ‍‍‍ 
let boy = "" 

let charactersToSkip = family + boy 

let string = boy + family + "foobar" // ‍‍‍foobar 

let scanner = MyScanner(string) 
scanner.skip(charactersIn: charactersToSkip) 
print(scanner.remains)    // foobar 

---

माइकल झरना के रूप में नीचे टिप्पणी में बताया गया है, CharacterSet एक बग है और यहां तक ​​कि सही ढंग से 32-बिट Unicode.Scalar मानों का प्रबंधन नहीं है, जिसका अर्थ है कि यह और भी एकल अदिश वर्ण ठीक से संभाल नहीं करता है तो मूल्य 0xffff से अधिक है (इमोजी सहित, दूसरों के बीच)। String प्रतिपादन, उपरोक्त, इन सही ढंग से संभालता है, यद्यपि।

Answer 2

सुनिश्चित नहीं हैं कि अगर यह सबसे कारगर तरीका है, लेकिन आप एक नया CharSet बना सकते हैं और देखें कि क्या उन्होंने उप/सुपर सेट (सेट तुलना नहीं बल्कि जल्दी है)

let newSet = CharacterSet(charactersIn: "a") 
// let newSet = CharacterSet(charactersIn: "\(character)") 
print(newSet.isSubset(of: CharacterSet.decimalDigits)) // false 
print(newSet.isSubset(of: CharacterSet.alphanumerics)) // true