Swift applique .uppercaseString uniquement à la première lettre d'une chaîne

J'essaie de créer un système de correction automatique et lorsqu'un utilisateur tape un mot avec une majuscule, la correction automatique ne fonctionne pas. Afin de résoudre ce problème, j'ai fait une copie de la chaîne tapée, appliqué .lowercaseString, puis les ai comparés. Si la chaîne est en effet mal tapée, elle devrait corriger le mot. Cependant, le mot qui remplace le mot tapé est tout en minuscules. Je dois donc appliquer .uppercaseString à la première lettre uniquement. Au départ, je pensais pouvoir utiliser

nameOfString[0]

mais cela ne fonctionne apparemment pas. Comment puis-je obtenir la première lettre de la chaîne en majuscules, puis être en mesure d'imprimer la chaîne complète avec la première lettre en majuscule?

Merci pour toute aide!

Y compris les versions mutantes et non mutantes qui sont conformes aux directives de l'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 ou version ultérieure

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

pour "Hello World"

nameOfString.capitalized

ou pour "BONJOUR MONDE"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

ou

string.capitalized

Cependant, cela met en majuscule la première lettre de chaque mot

Documentation d'Apple:

Une chaîne en majuscule est une chaîne dont le premier caractère de chaque mot est remplacé par sa valeur en majuscules correspondante, et tous les caractères restants définis sur leurs valeurs en minuscules correspondantes. Un «mot» est une séquence de caractères délimitée par des espaces, des tabulations ou des terminateurs de ligne. Certains mots communs délimitant la ponctuation ne sont pas pris en compte, de sorte que cette propriété ne produit généralement pas les résultats souhaités pour les chaînes de mots multiples. Voir la méthode getLineStart (_: end: contentsEnd: for :) pour plus d'informations.

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

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

Pour le premier caractère du mot à utiliser .capitalizedrapidement et pour le mot entier.uppercased()

Swift 2.0 (une seule ligne):

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

Swift 3 (xcode 8.3.3)

Majuscules tous les premiers caractères de la chaîne

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

//Your String

Majuscules tous les caractères

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

//YOUR STRING

Majuscule uniquement le premier caractère de la chaîne

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

//Your string

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

utiliser avec votre chaîne

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

J'obtiens le premier caractère dupliqué avec la solution de Kirsteins. Cela mettra en majuscule le premier caractère, sans voir double:

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

Je ne sais pas si c'est plus ou moins efficace, je sais juste que ça me donne le résultat souhaité.

Depuis Swift 3, vous pouvez facilement utiliser textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Voici une version pour Swift 5 qui utilise l' API des propriétés scalaires Unicode pour renflouer si la première lettre est déjà en majuscule ou n'a pas de notion de casse:

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

Mettre en majuscule le premier caractère de la chaîne

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

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

Dans Swift 3.0 (c'est un peu plus rapide et plus sûr que la réponse acceptée):

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

nameOfString.capitalized ne fonctionnera pas , il mettra en majuscule tous les mots de la phrase

Crédits à Leonardo Savio Dabus:

J'imagine que la plupart des cas d'utilisation consistent à obtenir un boîtier approprié:

import Foundation

extension String {

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

Ma solution:

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
}

En incorporant les réponses ci-dessus, j'ai écrit une petite extension qui met en majuscule la première lettre de chaque mot (parce que c'est ce que je cherchais et j'ai pensé que quelqu'un d'autre pourrait l'utiliser).

Je soumets humblement:

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

Voici la façon dont je l'ai fait par petites étapes, c'est similaire à @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
}

Fonctionne également, passez simplement votre chaîne et récupérez-en une en majuscule.

Mise à jour Swift 3

Le replaceRangefunc est maintenantreplaceSubrange

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

Je suis partial pour cette version, qui est une version nettoyée d'une autre réponse:

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

Il s'efforce d'être plus efficace en n'évaluant les self.characters qu'une seule fois, puis utilise des formulaires cohérents pour créer les sous-chaînes.

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 vous souhaitez mettre en majuscule chaque mot de chaîne, vous pouvez utiliser cette extension

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

Utilisé

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

Si votre chaîne est entièrement en majuscules, la méthode ci-dessous fonctionnera

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

Cette extension vous aidera

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

Ajoutez cette ligne dans la méthode 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)
    }
}

Pour swift 5, vous pouvez simplement faire comme ça:

yourString.firstUppercased

Exemple: "abc" -> "Abc"