Wenden Sie .uppercaseString schnell nur auf den ersten Buchstaben einer Zeichenfolge an

Ich versuche, ein Autokorrektur-System zu erstellen, und wenn ein Benutzer ein Wort mit einem Großbuchstaben eingibt, funktioniert die Autokorrektur nicht. Um dies zu beheben, habe ich eine Kopie der eingegebenen Zeichenfolge erstellt, .lowercaseString angewendet und sie dann verglichen. Wenn die Zeichenfolge tatsächlich falsch geschrieben ist, sollte sie das Wort korrigieren. Dann ist das Wort, das das eingegebene Wort ersetzt, nur Kleinbuchstaben. Daher muss ich .uppercaseString nur auf den ersten Buchstaben anwenden. Ich dachte ursprünglich, ich könnte verwenden

nameOfString[0]

aber das funktioniert anscheinend nicht. Wie kann ich den ersten Buchstaben der Zeichenfolge in Großbuchstaben schreiben und dann die vollständige Zeichenfolge mit dem Großbuchstaben drucken?

Vielen Dank für jede Hilfe!

Einschließlich mutierender und nicht mutierender Versionen, die den API-Richtlinien entsprechen.

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 oder höher

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

für "Hallo Welt"

nameOfString.capitalized

oder für "HALLO WORLD"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

oder

string.capitalized

Dies aktiviert jedoch den ersten Buchstaben jedes Wortes

Apples Dokumentation:

Eine Zeichenfolge mit Großbuchstaben ist eine Zeichenfolge, bei der das erste Zeichen in jedem Wort in den entsprechenden Großbuchstaben geändert und alle verbleibenden Zeichen auf die entsprechenden Kleinbuchstaben gesetzt werden. Ein „Wort“ ist eine beliebige Folge von Zeichen, die durch Leerzeichen, Tabulatoren oder Zeilenabschlüsse begrenzt sind. Einige gängige Satzzeichen, die die Interpunktion einschränken, werden nicht berücksichtigt, sodass diese Eigenschaft im Allgemeinen möglicherweise nicht zu den gewünschten Ergebnissen für Mehrwortzeichenfolgen führt. Weitere Informationen finden Sie in der Methode getLineStart (_: end: contentEnd: 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()

Für 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())
    }
}

Für das erste Zeichen im Wortgebrauch .capitalizedin schneller und für den Ganzwortgebrauch.uppercased()

Swift 2.0 (einzeilig):

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

Swift 3 (xcode 8.3.3)

Alle ersten Zeichen der Zeichenfolge in Großbuchstaben schreiben

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

//Your String

Alle Zeichen in Großbuchstaben schreiben

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

//YOUR STRING

Nur das erste Zeichen der Zeichenfolge in Großbuchstaben

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

//Your string

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

Verwenden Sie mit Ihrer Zeichenfolge

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

Ich bekomme das erste Zeichen, das mit Kirsteins 'Lösung dupliziert wurde. Dadurch wird das erste Zeichen groß geschrieben, ohne das Doppelte zu sehen:

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

Ich weiß nicht, ob es mehr oder weniger effizient ist, ich weiß nur, dass es mir das gewünschte Ergebnis liefert.

Von Swift 3 können Sie leicht verwenden textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Hier ist eine Version für Swift 5 , die die Unicode-API für skalare Eigenschaften verwendet, um zu retten, wenn der erste Buchstabe bereits in Großbuchstaben geschrieben ist oder keine Vorstellung von Groß- und Kleinschreibung hat:

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

Großschreibung des ersten Zeichens in der Zeichenfolge

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

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

In Swift 3.0 (dies ist etwas schneller und sicherer als die akzeptierte Antwort):

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

nameOfString.capitalized funktioniert nicht , es werden alle Wörter im Satz großgeschrieben

Dank an Leonardo Savio Dabus:

Ich stelle mir vor, dass die meisten Anwendungsfälle darin bestehen, das richtige Gehäuse zu erhalten:

import Foundation

extension String {

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

Meine Lösung:

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
}

Unter Einbeziehung der obigen Antworten habe ich eine kleine Erweiterung geschrieben, die den ersten Buchstaben jedes Wortes groß schreibt (weil ich danach gesucht habe und dachte, jemand anderes könnte es verwenden).

Ich reiche demütig ein:

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

So habe ich es in kleinen Schritten gemacht, ähnlich wie bei @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
}

Funktioniert auch einfach, geben Sie Ihren String ein und erhalten Sie einen großgeschriebenen zurück.

Swift 3 Update

Die replaceRangeFunk ist jetztreplaceSubrange

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

Ich bin Teil dieser Version, die eine bereinigte Version einer anderen Antwort ist:

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

Es ist bestrebt, effizienter zu sein, indem self.characters nur einmal ausgewertet werden, und verwendet dann konsistente Formulare, um die Unterzeichenfolgen zu erstellen.

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

Wenn Sie jedes Wort der Zeichenfolge groß schreiben möchten, können Sie diese Erweiterung verwenden

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

Gebraucht

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

Wenn Ihre Zeichenfolge nur aus Großbuchstaben besteht, funktioniert die folgende Methode

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

Diese Erweiterung hilft Ihnen

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

Für Swift 5 können Sie einfach so vorgehen:

yourString.firstUppercased

Beispiel: "abc" -> "Abc"

Fügen Sie diese Zeile in der viewDidLoad () -Methode hinzu.

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