Swift применяет .uppercaseString только к первой букве строки

Xcode 9 • Swift 4

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

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

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

Swift 3.0

для "Hello World"

nameOfString.capitalized

или для "HELLO WORLD"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

или

string.capitalized

Однако это заглавные буквы первой буквы каждого слова

Документация Apple:

Заглавная строка - это строка с первым символом в каждом слове, измененным на соответствующее значение верхнего регистра, а все остальные символы установлены на соответствующие строчные значения. "Слово" - это любая последовательность символов, разделенных пробелами, вкладками или терминаторами строк. Некоторая распространенная пунктуация, ограничивающая слово, не учитывается, поэтому это свойство обычно не может давать желаемые результаты для многословных строк. Дополнительную информацию см. В методе 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 2.0 (Single line):

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

Для первого символа в слове используйте .capitalized в быстром и для целого слова .uppercased()

В Swift 3 вы можете легко использовать textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Я получаю первый символ, дублированный решением Kirsteins. Это будет использовать первый символ, не видя двойного:

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

Я не знаю, более или менее эффективен, я просто знаю, что он дает мне желаемый результат.

Swift 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

Запишите первый символ в строке

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

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

Swift 4

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

В 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 не будет работать, он будет использовать все слова в предложении

Включая ответы выше, я написал небольшое расширение, которое заглавные буквы первой буквы каждого слова (потому что то, что я искал, и полагал, что кто-то другой может его использовать).

Я смиренно представляю:

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
    }
}

Мое решение:

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
}

Кредиты Леонардо Савио Дабусу:

Я предполагаю, что большинство случаев использования - это правильный корпус:

import Foundation

extension String {

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

Вот версия для Swift 5, которая использует API скалярных свойств Unicode для спасения, если первая буква уже в верхнем регистре или не имеет понятия case:

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

Если ваша строка написана заглавными буквами, то метод ниже

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

Это расширение поможет вам

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

Swift 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: " ")
    }
}

Я частично отношусь к этой версии, которая является очищенной версией из другого ответа:

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 один раз, а затем использует согласованные формы для создания подстроки.

Обновление Swift 3

Функция replaceRange теперь replaceSubrange

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

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

Также работает только передать вашу строку и получить заглавную копию.

Вот так я сделал это маленькими шагами, похожими на @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)
}

Если вы хотите использовать заглавные буквы в каждом слове строки, вы можете использовать это расширение

Swift 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"

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)
    }
}