extensions - extension app ios

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

Question

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!

Answer 1

Swift 3.0

para "Hello World"

nameOfString.capitalized

o para "HOLA MUNDO"

nameOfString.uppercased

Answer 2

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

Answer 3

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

Answer 4

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

Answer 5

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

Answer 6

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

Answer 7

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

Answer 8

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

Answer 9

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.

Answer 10

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

Answer 11

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
}

Answer 12

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

Answer 13

Para swift 5, puede hacer simplemente así:

yourString.firstUppercased

Muestra: "abc" -> "Abc"

Answer 14

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

Answer 15

Si su cadena es todo en 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()
}
}

Answer 16

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.

Answer 17

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 mayúscula primer carácter de cadena

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

Answer 18

Swift 4

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

Answer 19

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

Answer 20

Actualización de Swift 3

La función replaceSubrange ahora es replaceSubrange

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

Answer 21

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"

Answer 22

Swift 2.0 (línea única):

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

Answer 23

Swift 4.0

string.capitalized(with: nil)

o

string.capitalized

Sin embargo, esto capitaliza 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.

Answer 24

Swift 5 o posterior

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

Xcode 9 • Swift 4

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

"Swift".first // "S"
"Swift".last // "t"
"hello world!!!".firstUppercased // "Hello world!!!"
"DŽ".firstCapitalized // "Dž"
"Dž".firstCapitalized // "Dž"
"dž".firstCapitalized // "Dž"

Answer 25

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

Answer 26

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

Answer 27

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.