Swift将.uppercaseString仅应用于字符串的第一个字母

我正在尝试制作一个自动更正系统，并且当用户键入一个带有大写字母的单词时，自动更正不起作用。为了解决此问题，我制作了一个键入的字符串的副本，应用了.lowercaseString，然后对其进行了比较。如果确实输入了错误的字符串，则应更正单词。但是，替换键入的单词的单词全部为小写。所以我只需要将.uppercaseString应用于第一个字母。我本以为可以用

nameOfString[0]

但这显然行不通。如何将字符串的首字母转换为大写，然后将首字母大写的完整字符串打印出来？

谢谢你的帮助！

包括与API准则一致的变异版本和非变异版本。

斯威夫特3：

extension String {
    func capitalizingFirstLetter() -> String {
        let first = String(characters.prefix(1)).capitalized
        let other = String(characters.dropFirst())
        return first + other
    }

    mutating func capitalizeFirstLetter() {
        self = self.capitalizingFirstLetter()
    }
}

斯威夫特4：

extension String {
    func capitalizingFirstLetter() -> String {
      return prefix(1).uppercased() + self.lowercased().dropFirst()
    }

    mutating func capitalizeFirstLetter() {
      self = self.capitalizingFirstLetter()
    }
}

Swift 5.1或更高版本

extension StringProtocol {
    var firstUppercased: String { prefix(1).uppercased() + dropFirst() }
    var firstCapitalized: String { prefix(1).capitalized + dropFirst() }
}

迅捷5

extension StringProtocol {
    var firstUppercased: String { return prefix(1).uppercased() + dropFirst() }
    var firstCapitalized: String { return prefix(1).capitalized + dropFirst() }
}

"Swift".first  // "S"
"Swift".last   // "t"
"hello world!!!".firstUppercased  // "Hello world!!!"

"DŽ".firstCapitalized   // "Dž"
"Dž".firstCapitalized   // "Dž"
"dž".firstCapitalized   // "Dž"

斯威夫特3.0

对于“ Hello World”

nameOfString.capitalized

或“ HELLO WORLD”

nameOfString.uppercased

迅捷4.0

string.capitalized(with: nil)

要么

string.capitalized

但是，每个单词的首字母大写

苹果的文档：

大写字符串是一个字符串，其中每个单词的第一个字符均更改为其相应的大写值，而所有其余字符均设置为其相应的小写值。“单词”是由空格，制表符或行终止符分隔的任何字符序列。不考虑某些常见的单词定界标点，因此此属性通常可能无法为多单词字符串产生所需的结果。有关其他信息，请参见getLineStart（_：end：contentsEnd：for :)方法。

extension String {
    func firstCharacterUpperCase() -> String? {
        let lowercaseString = self.lowercaseString

        return lowercaseString.stringByReplacingCharactersInRange(lowercaseString.startIndex...lowercaseString.startIndex, withString: String(lowercaseString[lowercaseString.startIndex]).uppercaseString)
    }
}

let x = "heLLo"
let m = x.firstCharacterUpperCase()

对于Swift 5：

extension String {
    func firstCharacterUpperCase() -> String? {
        guard !isEmpty else { return nil }
        let lowerCasedString = self.lowercased()
        return lowerCasedString.replacingCharacters(in: lowerCasedString.startIndex...lowerCasedString.startIndex, with: String(lowerCasedString[lowerCasedString.startIndex]).uppercased())
    }
}

.capitalized快速使用单词中的第一个字符，使用完整单词中的第一个字符.uppercased()

Swift 2.0（单行）：

String(nameOfString.characters.prefix(1)).uppercaseString + String(nameOfString.characters.dropFirst())

斯威夫特3（xcode 8.3.3）

将字符串的所有首字符大写

let str = "your string"
let capStr = str.capitalized

//Your String

大写所有字符

let str = "your string"
let upStr = str.uppercased()

//YOUR STRING

字符串的仅大写第一个字符

 var str = "your string"
 let capStr = String(str.characters.prefix(1)).uppercased() + String(str.characters.dropFirst())

//Your string

迅速5

https://www.hackingwithswift.com/example-code/strings/how-to-capitalize-the-first-letter-of-a-string

extension String {
    func capitalizingFirstLetter() -> String {
        return prefix(1).capitalized + dropFirst()
    }

    mutating func capitalizeFirstLetter() {
        self = self.capitalizingFirstLetter()
    }
}

与你的弦一起使用

let test = "the rain in Spain"
print(test.capitalizingFirstLetter())

我正在用Kirsteins的解决方案复制第一个字符。这将大写第一个字符，而不会出现双重：

var s: String = "hello world"
s = prefix(s, 1).capitalizedString + suffix(s, countElements(s) - 1)

我不知道它的效率是高还是低，我只知道它能给我带来理想的结果。

在Swift 3中，您可以轻松使用 textField.autocapitalizationType = UITextAutocapitalizationType.sentences

这是Swift 5的一个版本，如果第一个字母已经是大写或没有大小写概念，则使用Unicode标量属性API进行纾困：

extension String {
  func firstLetterUppercased() -> String {
    guard let first = first, first.isLowercase else { return self }
    return String(first).uppercased() + dropFirst()
  }
}

大写字符串中的第一个字符

extension String {
    var capitalizeFirst: String {
        if self.characters.count == 0 {
            return self

        return String(self[self.startIndex]).capitalized + String(self.characters.dropFirst())
    }
}

在Swift 3.0中（这比接受的答案要快一些，也更安全）：

extension String {
    func firstCharacterUpperCase() -> String {
        if let firstCharacter = characters.first {
            return replacingCharacters(in: startIndex..<index(after: startIndex), with: String(firstCharacter).uppercased())
        }
        return ""
    }
}

nameOfString.capitalized将不起作用，它将大写句子中的每个单词

归功于Leonardo Savio Dabus：

我想大多数用例是获得适当的套管：

import Foundation

extension String {

    var toProper:String {
        var result = lowercaseString
        result.replaceRange(startIndex...startIndex, with: String(self[startIndex]).capitalizedString)
        return result
    }
}

我的解决方案：

func firstCharacterUppercaseString(string: String) -> String {
    var str = string as NSString
    let firstUppercaseCharacter = str.substringToIndex(1).uppercaseString
    let firstUppercaseCharacterString = str.stringByReplacingCharactersInRange(NSMakeRange(0, 1), withString: firstUppercaseCharacter)
    return firstUppercaseCharacterString
}

结合上面的答案，我写了一个小扩展名，将每个单词的首字母大写（因为这就是我要查找的内容，并认为其他人可以使用它）。

我谦虚地提出：

extension String {
    var wordCaps:String {
        let listOfWords:[String] = self.componentsSeparatedByString(" ")
        var returnString: String = ""
        for word in listOfWords {
            if word != "" {
                var capWord = word.lowercaseString as String
                capWord.replaceRange(startIndex...startIndex, with: String(capWord[capWord.startIndex]).uppercaseString)
                returnString = returnString + capWord + " "
            }
        }
        if returnString.hasSuffix(" ") {
            returnString.removeAtIndex(returnString.endIndex.predecessor())
        }
        return returnString
    }
}

斯威夫特4

func firstCharacterUpperCase() -> String {
        if self.count == 0 { return self }
        return prefix(1).uppercased() + dropFirst().lowercased()
    }

这是我一步一步完成的方式，类似于@Kirsteins。

func capitalizedPhrase(phrase:String) -> String {
    let firstCharIndex = advance(phrase.startIndex, 1)
    let firstChar = phrase.substringToIndex(firstCharIndex).uppercaseString
    let firstCharRange = phrase.startIndex..<firstCharIndex
    return phrase.stringByReplacingCharactersInRange(firstCharRange, withString: firstChar)
}

func helperCapitalizeFirstLetter(stringToBeCapd:String)->String{
    let capString = stringToBeCapd.substringFromIndex(stringToBeCapd.startIndex).capitalizedString
    return capString
}

也可以通过传递您的字符串并返回大写字母来起作用。

Swift 3更新

该replaceRange功能现在replaceSubrange

nameOfString.replaceSubrange(nameOfString.startIndex...nameOfString.startIndex, with: String(nameOfString[nameOfString.startIndex]).capitalized)

我偏爱这个版本，它是另一个答案的清理版本：

extension String {
  var capitalizedFirst: String {
    let characters = self.characters
    if let first = characters.first {
      return String(first).uppercased() + 
             String(characters.dropFirst())
    }
    return self
  }
}

它只通过评估一次self.characters来提高效率，然后使用一致的形式来创建子字符串。

斯威夫特4（Xcode 9.1）

extension String {
    var capEachWord: String {
        return self.split(separator: " ").map { word in
            return String([word.startIndex]).uppercased() + word.lowercased().dropFirst()
        }.joined(separator: " ")
    }
}

如果要大写字符串的每个单词，可以使用此扩展名

斯威夫特4 Xcode 9.2

extension String {
    var wordUppercased: String {
        var aryOfWord = self.split(separator: " ")
        aryOfWord =  aryOfWord.map({String($0.first!).uppercased() + $0.dropFirst()})
        return aryOfWord.joined(separator: " ")
    }
}

用过的

print("simple text example".wordUppercased) //output:: "Simple Text Example"

如果您的字符串全部大写，则下面的方法将起作用

labelTitle.text = remarks?.lowercased().firstUppercased

此扩展程序将帮助您

extension StringProtocol {
    var firstUppercased: String {
        guard let first = first else { return "" }
        return String(first).uppercased() + dropFirst()
    }
}

在viewDidLoad（）方法中添加此行。

 txtFieldName.autocapitalizationType = UITextAutocapitalizationType.words

extension String {
    var lowercased:String {
        var result = Array<Character>(self.characters);
        if let first = result.first { result[0] = Character(String(first).uppercaseString) }
        return String(result)
    }
}

对于Swift 5，您可以简单地执行以下操作：

yourString.firstUppercased

范例：“ abc”->“ Abc”