如何编写函数来评估字符串是否只是字符？

Question

我已经看到了这个问题的其他答案，但我只是想以不同的方式来做。然而，无论我做什么，我都无法让我的类型匹配。

func ContainsOnlyAlphabets(_ word : String) -> Bool{
    let letters = CharacterSet.letters // Set<Character>

    let trimmed = word.trimmingCharacters(in: .whitespaces)

    let characterViewArray = Array(trimmed.characters) // Array<characterView>
    let characterArray = characterViewArray.map{Character($0)} // Error: Can't create Chars
    let wordCharactersSet = Set(characterArray) // Set<Character>

    let intersection = wordCharactersSet.intersection(letters)

    return intersection.count == characterArray.count

}

我必须进行所有的 Set、Char、String、Array 转换，但仍然无法正确处理 :(.

无法使用参数列表调用类型“Character”的初始化程序 '((String.CharacterView._Element))' 类型的

Answer 1

你的代码

let characterViewArray = Array(trimmed.characters)

已经创建了一个Array<Character>，所以你可以简单地跳过 下一行并使用

创建一个Set<Character>

let wordCharactersSet = Set(characterViewArray)

但这并没有真正的帮助，因为Set<Character> 和 CharacterSet 是不同的类型，所以

let intersection = wordCharactersSet.intersection(letters)

不编译。可能的替代方案是

return trimmed.rangeOfCharacter(from: letters.inverted) == nil

或

return CharacterSet(charactersIn: trimmed).isSubset(of: letters)

如果您的意图是同时允许字母 和 空白字符 那么它可能看起来像这样：

func containsOnlyLettersAndWhitespace(_ word : String) -> Bool{
    var allowedSet = CharacterSet.letters
    allowedSet.formUnion(CharacterSet.whitespaces)

    return word.rangeOfCharacter(from: allowedSet.inverted) == nil
    // Alternatively:
    return CharacterSet(charactersIn: word).isSubset(of: allowedSet.inverted)
}

Answer 2

正如 MartinR 所说，CharacterSet 不等于 Set<Character>

我能找到的最接近您原始解决方案的方法是从修剪后的字符串创建一个 CharacterSet 并将您的一些原始算法应用于该：

func ContainsOnlyAlphabets(_ word : String) -> Bool{
    let letters = CharacterSet.letters

    let trimmed = word.trimmingCharacters(in: .whitespaces)
    let wordCharacterSet = CharacterSet(charactersIn:trimmed)

    let intersection = wordCharacterSet.intersection(letters)

    return intersection == wordCharacterSet
}

严格保持在CharacterSet 的范围内并对其进行操作，您还可以使用：

func ContainsOnlyAlphabets(_ word : String) -> Bool{
    return CharacterSet.letters.isSuperset(of:
        CharacterSet(charactersIn: word.trimmingCharacters(in: .whitespaces))
    )
}

也就是说，我想我还是会选择 Martin 的解决方案：

func ContainsOnlyAlphabets(_ word : String) -> Bool{
    return word
        .trimmingCharacters(in: .whitespaces)
        .rangeOfCharacter(from: CharacterSet.letters.inverted) == nil
}

因为更直观。