web-dev-qa-db-fra.com

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

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 typée, appliqué .lowercaseString, puis comparé. Si la chaîne est en effet mal typée, cela devrait corriger le mot. Cependant, le mot qui remplace le mot saisi est tout en minuscule. Je dois donc appliquer .uppercaseString à la première lettre seulement. 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 majuscule, puis pouvoir imprimer la chaîne complète avec la première lettre en majuscule?

Merci pour toute aide!

iosswiftstringios8-extension
218
SomeGuy

Incluant des versions mutantes et non mutantes 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()
    }
}
475
Kirsteins

Swift 5 ou version ultérieure

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ž"
124
Leo Dabus

Swift 3.0

pour "Hello World"

nameOfString.capitalized

ou pour "BONJOUR MONDE"

nameOfString.uppercased
76
Maselko

Swift 4.

string.capitalized(with: nil)

ou

string.capitalized

Cependant, cela capitalise la première lettre de chaque mot

Documentation d'Apple:

Une chaîne en majuscule est une chaîne avec le premier caractère de chaque mot remplacé par sa valeur majuscule correspondante et tous les caractères restants définis par leurs valeurs minuscules correspondantes. Un "mot" est une séquence de caractères délimitée par des espaces, des tabulations ou des fins de ligne. Certains signes de ponctuation délimitant Word courants ne sont pas pris en compte. Par conséquent, cette propriété peut ne pas générer les résultats souhaités pour les chaînes de plusieurs mots. Voir la méthode getLineStart (_: end: contentsEnd: for :) pour plus d'informations.

34
sam k
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 {
        let lowerCasedString = self.lowercased()
        return lowerCasedString.replacingCharacters(in: lowerCasedString.startIndex...lowerCasedString.startIndex, with: String(lowerCasedString[lowerCasedString.startIndex]).uppercased())
    }
}
22
user2260304

Pour le premier caractère de Word, utilisez .capitalized dans Swift et pour Word entier, .uppercased().

12
DURGESH Chaurasiya

Swift 2.0 (Une seule ligne):

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

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

3
Yura

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

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

Swift 3 (xcode 8.3.3)

Mettre en majuscule tous les premiers caractères de la chaîne

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

//Your String

Mettre tous les caractères en majuscule

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

//YOUR STRING

Premier caractère de la chaîne en majuscule

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

//Your string
3
oscar castellon

Je fais dupliquer le premier personnage avec la solution de Kirsteins. Cela va capitaliser le premier personnage, sans en 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é.

3
Marc Fearby

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

Crédits à Leonardo Savio Dabus:

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

import Foundation

extension String {

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

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

1
pierre23

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
}
1
Nazariy Vlizlo

Swift 4

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

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

}

utiliser avec votre ficelle

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

En intégrant les réponses ci-dessus, j'ai écrit une petite extension qui met en majuscule la première lettre de chaque mot (car 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
    }
}
1
Matt

Je suis partial à 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 qu'une seule fois les personnages indépendants. Il utilise ensuite des formulaires cohérents pour créer les sous-chaînes.

0
Patrick Beard

Si votre chaîne est en majuscule, 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()
    }
}
0
Ashu

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

tilisé

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

Mise à jour Swift

La replaceRange func est maintenant replaceSubrange

nameOfString.replaceSubrange(nameOfString.startIndex...nameOfString.startIndex, with: String(nameOfString[nameOfString.startIndex]).capitalized)
0
Brendt Bly
func helperCapitalizeFirstLetter(stringToBeCapd:String)->String{
    let capString = stringToBeCapd.substringFromIndex(stringToBeCapd.startIndex).capitalizedString
    return capString
}

Cela fonctionne également, il suffit de passer votre chaîne et d’en récupérer une en majuscule.

0
Daniel Leonard

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

Voici comment je l'ai fait par petites étapes, semblable à @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)
}
0
guptron