如何快速识别字符串中的大写和小写字符？

Question

这是我到目前为止（出于测试目的）的内容：

let string = "The quick BroWn fOX jumpS Over tHe lazY DOg"

for chr in string {
    if isupper(String(chr)) {
        print(String(chr).lowercaseString)
        continue
    }
    print(chr)
}

如何测试大写和小写字符？

我知道我可以迅速调用C函数，但这对我来说似乎不正确。 我该如何只用swift做到这一点？

Answer 1

我不确定您要避免使用C函数是什么意思。 我希望这不包括避免开发应用程序时OS X和iOS为您提供的框架和基础库，例如NSCharacterSet类 ，它提供了与Unicode兼容的实现中所需的功能。

为了扩展Matt的答案，使其更接近您的问题要求：

import UIKit

let testString = "Åke röstet un café in Владивосток!"
let lowerCase = NSCharacterSet.lowercaseLetterCharacterSet()
let upperCase = NSCharacterSet.uppercaseLetterCharacterSet()

for currentCharacter in testString.utf16 {
  if lowerCase.characterIsMember(currentCharacter) {
    println("Character code \(currentCharacter) is lowercase.")
  } else if upperCase.characterIsMember(currentCharacter) {
    println("Character code \(currentCharacter) is UPPERCASE.")
  } else {
    println("Character code \(currentCharacter) is neither upper- nor lowercase.")
  }
}

迅捷3

let testString = "Åke röstet un café in Владивосток!"
let lowerCase = CharacterSet.lowercaseLetters
let upperCase = CharacterSet.uppercaseLetters

for currentCharacter in testString.unicodeScalars {
    if lowerCase.contains(currentCharacter) {
        print("Character code \(currentCharacter) is lowercase.")
    } else if upperCase.contains(currentCharacter) {
        print("Character code \(currentCharacter) is UPPERCASE.")
    } else {
        print("Character code \(currentCharacter) is neither upper- nor lowercase.")
    }
}

Answer 2

您总是可以看到小写表示形式是否不同于当前值；

let string = "The quick BroWn fOX jumpS Over tHe lazY DOg"
var output = ""

for chr in string {
    var str = String(chr)
    if str.lowercaseString != str {
        output += str
    }
}
print(output)

>>> TBWOXSOHYDO

Answer 3

通过扩展String和Character我想我已经找到了一个完全灵活的，完全了解Unicode的解决方案。 以下语法适用于Swift 3.0。 尽管这里没有什么是Swift 2.x中不可能做到的。

extension String {
    func isUppercased(at: Index) -> Bool {
        let range = at..<self.index(after: at)
        return self.rangeOfCharacter(from: .uppercaseLetters, options: [], range: range) != nil
    }
}

extension Character {
    var isUppercase: Bool {
      let str = String(self)
      return str.isUppercased(at: str.startIndex)
    }
}

let str = "AaÀàΓγ!2😂🇺🇸"
let uppercase = str.characters.filter({ $0.isUppercase }) // ["A", "À", "Γ"]
for char in str.characters {
    "\(char): \(char.isUppercase)"
}

// A: true
// a: false
// À: true
// à: false
// Γ: true
// γ: false
// !: false
// 2: false
// 😂: false
// 🇺🇸: false

这些扩展的TODO是在Character上重构isUppercase而不转换为String 。

Answer 4

在Swift 3中，我做这种事情

import UIKit
...
let ch = "A".unicodeScalars.first!
let is_ch_upperCase = CharacterSet.uppercaseLetters.contains(ch)

Answer 5

更干净，但可能比循环慢：

let str = "The quick BroWn fOX jumpS Over tHe lazY DOg"
let nonUpperCase = NSCharacterSet.uppercaseLetterCharacterSet().invertedSet
let letters = str.componentsSeparatedByCharactersInSet(nonUpperCase)
"".join(letters) // "TBWOXSOHYDO"

Answer 6

扩展Bob Prystaneks函数，您总是可以扩展Swift“ Character”类。 只需将以下扩展名放在代码中的任何位置，现在您可以询问任何字符是否为大写。

extension Character
{
    public func isUpper() -> Bool
    {
        let characterString = String(self)
        return (characterString == characterString.uppercaseString) && (characterString != characterString.lowercaseString)
    }
}

Answer 7

添加此Swift扩展，以便Character类的所有实例都具有两个新功能：isUpperCase（）用于测试字符是否为大写，isLowerCase（）用于测试字符是否为小写。 该实现只是检查字符实例是否在所需集中。

extension Character {

        func isUpperCase() -> Bool {
            return CharacterSet.uppercaseLetters.contains(self.unicodeScalars.first!)
        }

        func isLowerCase() -> Bool {
            return CharacterSet.lowercaseLetters.contains(self.unicodeScalars.first!)
        }

  }

Answer 8

SWIFT 4：

除非检查数字或unicode标量等，否则您根本不需要其他所有奇特的东西：

extension String {

   var isLowercase: Bool {
       return self == self.lowercased()
   }

   var isUppercase: Bool {
       return self == self.uppercased()
   }

}

Answer 9

在Swift 5中，我们现在可以根据Unicode标准检查字符属性 。

对于您的问题，答案是chr.isUppercase和chr.isLowercase 。

Answer 10

正如其他人所评论的那样，仅使用uppercaseString或lowercaseString不会考虑“非字母”字符。

这就是我实现isupper的方式。 如果字符不等于小写字母，则只能是大写字母。

func isupper(c:Character) -> Bool
{
    let cs = String(c)
    return (cs == cs.uppercaseString) && (cs != cs.lowercaseString)
}

Answer 11

每个字符都可以显示为UTF或Unicode值（8/16/21位）：

例如：

UTF-8 "Dog!": 68, 111, 103, 33
Unicode (Dog Face): U+1F436

因此，如果您要检查大小写，则可以匹配UTF范围。

（PS：注意不同的UTF-XX / Unicode格式）

Answer 12

创建并使用此扩展名：

extension Character {
    var isUppercase: Bool {
        guard self.asciiValue != nil else {
            return false
        }

        return self.asciiValue! >= Character("A").asciiValue! &&
                self.asciiValue! <= Character("Z").asciiValue!
    }

    var asciiValue: UInt32? {
        return String(self).unicodeScalars.first?.value
    }
}

Answer 13

创建并使用此扩展名：

extension Character {
        var isUppercase: Bool {
            return (String(self).unicodeScalars.filter {
                $0.value >= "A".unicodeScalars.first!.value &&
                $0.value <= "Z".unicodeScalars.first!.value
            }).count != 0
        }
    }

Answer 14

斯威夫特3：

var str = "Hello"

let upperChars = str.unicodeScalars.flatMap({ char in
    CharacterSet.uppercaseLetters.contains(char) ? char : nil
})

let lowerChars = str.unicodeScalars.flatMap({ char in
    CharacterSet.lowercaseLetters.contains(char) ? char : nil
})

// upperChars -> ["H"]
// lowerChars -> ["e", "l", "l", "o"]

Answer 15

简单的Swifty扩展：

extension String {
    var isLower: Bool {
        return String(self.filter { String($0) == String($0).lowercased() }) == self
    }
}

Answer 16

Swift 5 Check with角色属性

let string = "The quick BroWn fOX jumpS Over tHe lazY DOg"
for (_,ch) in string.enumerated() {
    if ch.isUppercase {
         //uppercase
   }
   else {
        //lowercase: ch.isLowercase
   }
}

Swift 4枚举字符串并获取字符的ASCII码，然后进行比较。

ASCII代码

a-> 97 b-> 98 ...

A-> 65 B-> 66 ...

let string = "The quick BroWn fOX jumpS Over tHe lazY DOg"
for (_,ch) in string.enumerated()
{
    let chValue = String(ch).unicodeScalars
    let asciiValue = chValue[chValue.startIndex].value
    if (asciiValue>=97)
    {
           //lowercase
    }
    else
    {
           //uppercase
    }
}

Answer 17

仅检查字符串是否包含大写，小写或特殊字符：

let lowerCase = CharacterSet.lowercaseLetters
let upperCase = CharacterSet.uppercaseLetters
let numbers = CharacterSet.decimalDigits

let containsNumbers = text.unicodeScalars.contains(where: { numbers.contains($0) })
let containsLowerCase = text.unicodeScalars.contains(where: { lowerCase.contains($0) })
let containsUpperCase = text.unicodeScalars.contains(where: { upperCase.contains($0) })
let containsSpecial = text.unicodeScalars.contains(where: { !lowerCase.contains($0) && !upperCase.contains($0) && !numbers.contains($0) })

Answer 18

简单扩展接受任何CharacterSet进行检查：

extension String {
    func hasCharacter(in characterSet: CharacterSet) -> Bool {
        return rangeOfCharacter(from: characterSet) != nil
    }
}

用法：

"aBc".hasCharacter(in: .lowercaseLetters)
"aBc".hasCharacter(in: .uppercaseLetters)
"aBc".hasCharacter(in: <#AnyOtherCharacterSetYouWant#>)