Swift aplica .uppercaseString solo a la primera letra de una cadena

Estoy tratando de hacer un sistema de autocorrección, y cuando un usuario escribe una palabra con una letra mayúscula, la autocorrección no funciona. Para solucionar esto, hice una copia de la cadena escrita, apliqué .lowercaseString y luego las comparé. Si la cadena está mal escrita, debería corregir la palabra. Sin embargo, entonces la palabra que reemplaza la palabra escrita es minúscula. Entonces necesito aplicar .uppercaseString solo a la primera letra. Originalmente pensé que podría usar

nameOfString[0]

pero esto aparentemente no funciona. ¿Cómo puedo poner la primera letra de la cadena en mayúscula y luego poder imprimir la cadena completa con la primera letra en mayúscula?

¡Gracias por cualquier ayuda!

Incluyendo versiones mutantes y no mutantes que son consistentes con las pautas API.

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

Swift 4:

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

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

Swift 5.1 o posterior

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

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

Swift 3.0

para "Hello World"

nameOfString.capitalized

o para "HOLA MUNDO"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

o

string.capitalized

Sin embargo, esto pone en mayúscula la primera letra de cada palabra

Documentación de Apple:

Una cadena en mayúscula es una cadena con el primer carácter de cada palabra cambiado a su valor en mayúscula correspondiente, y todos los caracteres restantes configurados en sus valores en minúscula correspondientes. Una "palabra" es cualquier secuencia de caracteres delimitada por espacios, tabulaciones o terminadores de línea. No se considera alguna puntuación común delimitadora de palabras, por lo que esta propiedad generalmente no produce los resultados deseados para cadenas de varias palabras. Consulte el método getLineStart (_: end: contentsEnd: for :) para obtener información adicional.

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

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

Para el primer carácter en el uso de palabras .capitalizeden Swift y para uso de palabras completas.uppercased()

Swift 2.0 (línea única):

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

Swift 3 (xcode 8.3.3)

Todos los primeros caracteres de cadena en mayúscula

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

//Your String

Todos los caracteres en mayúscula

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

//YOUR STRING

Solo primer carácter en mayúscula de la cadena

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

//Your string

En Swift 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()
    }
}

usar con tu cuerda

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

Estoy obteniendo el primer personaje duplicado con la solución de Kirsteins. Esto capitalizará el primer personaje, sin ver doble:

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

No sé si es más o menos eficiente, solo sé que me da el resultado deseado.

Desde Swift 3 puedes usar fácilmente textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Aquí hay una versión para Swift 5 que usa la API de propiedades escalares Unicode para rescatar si la primera letra ya está en mayúscula o no tiene una noción de mayúsculas y minúsculas:

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

Poner en mayúscula el primer carácter de la cadena.

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

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

En Swift 3.0 (esto es un poco más rápido y seguro que la respuesta aceptada):

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

nameOfString.capitalized no funcionará , capitalizará todas las palabras en la oración

Créditos a Leonardo Savio Dabus:

Me imagino que la mayoría de los casos de uso es obtener una carcasa adecuada:

import Foundation

extension String {

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

Mi solución:

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
}

Al incorporar las respuestas anteriores, escribí una pequeña extensión que escribe en mayúscula la primera letra de cada palabra (porque eso es lo que estaba buscando y pensé que alguien más podría usarla).

Humildemente presento:

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

Swift 4

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

Esta es la forma en que lo hice en pequeños pasos, es similar a @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
}

También funciona, simplemente pasa tu cadena y recupera una en mayúscula.

Actualización de Swift 3

El replaceRangefunc es ahorareplaceSubrange

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

Soy parcial a esta versión, que es una versión limpia de otra respuesta:

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

Se esfuerza por ser más eficiente al evaluar solo los caracteres propios una vez, y luego usa formas consistentes para crear las subcadenas.

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

Si desea poner en mayúscula cada palabra de cadena, puede usar esta extensión

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

Usado

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

Si su cadena es todo mayúsculas, el siguiente método funcionará

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

Esta extensión te ayudará

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

Agregue esta línea en el método 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)
    }
}

Para swift 5, puede hacer simplemente así:

yourString.firstUppercased

Muestra: "abc" -> "Abc"