Это то, что я до сих пор (для целей тестирования):
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, но для меня это кажется неправильным. Как я могу сделать это только с быстрым?
В Swift 5 теперь мы можем проверять свойства символов в соответствии со стандартом Unicode.
На ваш вопрос chr.isUppercase chr.isLowercase chr.isUppercase и chr.isLowercase.
Я не уверен, что вы имеете в виду, пытаясь избежать C-функций. Я надеюсь, что это не включает в себя отказ от каркасов и базовых библиотек, которые OS X и iOS предлагают вам при разработке приложения, как, например, класс NSCharacterSet, который обеспечивает именно то, что вам нужно в реализации, совместимой с Unicode.
Чтобы расширить ответ Мэтта, приблизив его к требованиям вашего вопроса:
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.")
}
}
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.")
}
}
Вы всегда можете увидеть, отличается ли представление в нижнем регистре от текущего значения;
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
Расширяясь 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 для этих расширений состоит в том, чтобы реорганизовать isUppercase на Character, чтобы не преобразовать в String.
В Swift 3 я делаю такие вещи
import UIKit
...
let ch = "A".unicodeScalars.first!
let is_ch_upperCase = CharacterSet.uppercaseLetters.contains(ch)
Очиститель, но, возможно, медленнее, чем цикл:
let str = "The quick BroWn fOX jumpS Over tHe lazY DOg"
let nonUpperCase = NSCharacterSet.uppercaseLetterCharacterSet().invertedSet
let letters = str.componentsSeparatedByCharactersInSet(nonUpperCase)
"".join(letters) // "TBWOXSOHYDO"
Расширяя функцию Bob Prystaneks, вы всегда можете расширить класс Swift "Character". Просто поставьте следующее расширение в любом месте своего кода, и теперь вы можете спросить любого персонажа, если он заглавными.
extension Character
{
public func isUpper() -> Bool
{
let characterString = String(self)
return (characterString == characterString.uppercaseString) && (characterString != characterString.lowercaseString)
}
}
Добавьте это расширение 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!)
}
}
SWIFT 4:
Вы можете просто не нуждаться во всех других причудливых вещах, если только вы не проверяете числа или скаляр в юникоде и т.д.:
extension String {
var isLowercase: Bool {
return self == self.lowercased()
}
var isUppercase: Bool {
return self == self.uppercased()
}
}
Как другой прокомментировал, используя только uppercaseString или lowercaseString не принимает "не-альфа" символы во внимание.
Вот как я реализовал isupper. Символ имеет только верхний регистр, если он не равен нижнему регистру.
func isupper(c:Character) -> Bool
{
let cs = String(c)
return (cs == cs.uppercaseString) && (cs != cs.lowercaseString)
}
Каждому символу может быть присвоено значение UTF или Unicode (8/16/21 бит):
Например:
UTF-8 "Dog!": 68, 111, 103, 33
Unicode (Dog Face): U+1F436
Итак, если вы хотите проверить верхний и нижний регистр, вы можете просто соответствовать диапазону UTF.
(PS: следите за различными форматами UTF-XX/Unicode)
создайте и используйте это расширение:
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
}
}
создайте и используйте это расширение:
extension Character {
var isUppercase: Bool {
return (String(self).unicodeScalars.filter {
$0.value >= "A".unicodeScalars.first!.value &&
$0.value <= "Z".unicodeScalars.first!.value
}).count != 0
}
}
Swift 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"]
Простой Swifty:
extension String {
var isLower: Bool {
return String(self.filter { String($0) == String($0).lowercased() }) == self
}
}
Swift 5 Проверьте свойства персонажа
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 для
а → 97 б → 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
}
}
Просто чтобы проверить, содержит ли строка символы Upper, Lower или Special:
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) })
Простое расширение принимает любой 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#>)