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

232

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!

Irgendein Typ
quelle

Antworten:

512

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()
    }
}
Kirsteins
quelle
3
Nur ein Hinweis, der .capitalizedStringin Xcode 7 Beta 4 nicht mehr funktioniert. Die Zeichenfolgen haben sich in Swift 2.0 etwas geändert.
Kakubei
2
@ Kirsteins: Du hast recht, mein schlechtes. Ich hatte vergessen, Foundation verlegenes Grinsen
Kakubei
3
@LoryLory Verwendung .uppercaseStringdafür
Kirsteins
2
Dies ist die ernsthaft effektive Antwort Kumpel .. Arbeiten mit Xcode 7.1.1 / Swift 2.1 .... Danke :)
onCompletion
20
es ist gerade .capitalizedjetzt. Beachten Sie auchcapitalizedStringWith(_ locale:)
Raphael
152

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ž"
Leo Dabus
quelle
3
Gut gemacht. Ich habe meine bearbeitet, um zuerst Kleinbuchstaben zu übergeben, und in Proper umbenannt.
Ericgu
Ich mag die schnelle 2.1.1-Lösung, aber wenn ich meine App starte und nach Lecks suche, zeigt dies, dass diese undicht ist.
Henny Lee
1
Ich habe gerade ein neues Projekt erstellt und es scheint, dass es einen Speicherverlust verursacht, wenn dieses zusammen mit einem UITextFieldBeobachter für verwendet wird UITextFieldTextDidChangeNotification.
Henny Lee
@ Henry das hat nichts mit dem Code selbst zu tun. Wenn bei Ihnen Leistungs- / Speicherprobleme auftreten, sollten Sie dies Apple melden.
Leo Dabus
1
@LeoDabus Ich denke, es hängt davon ab, welches die Absicht des Codes deutlicher macht. Ein leeres String-Literal ist vielleicht am besten.
Nicolas Miari
84

Swift 3.0

für "Hallo Welt"

nameOfString.capitalized

oder für "HALLO WORLD"

nameOfString.uppercased
Maselko
quelle
3
Charlesism hat bereits vor zwei Monaten mit der Swift 3-Version geantwortet ...
Eric Aya
11
Dadurch wird das erste Zeichen jedes Wortes des Strings großgeschrieben und nicht nur das erste Wort.
Bocaxica
Rückgabe: Eine Kopie der Zeichenfolge in Großbuchstaben. public func uppercased () -> String Swift 3.0 oder für "HELLO WORLD" nameOfString.uppercased STATT OBEN nameOfString.uppercased ()
Azharhussain Shaikh
40

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 :).

sam k
quelle
1
Ich habe keine Ahnung, warum die Leute für diese Antwort nicht empfänglich sind. Wenn die Leute nur das erste Wort großschreiben wollen, können sie das erste herausgreifen und es am einfachsten mit dem großgeschriebenen Eigentum großschreiben.
ScottyBlades
1
Wichtig ist, dass "Großgeschrieben" für alle Unicode-Zeichen korrekt ist, während die Verwendung von "Großbuchstaben" für das erste Zeichen nicht korrekt ist.
Gnasher729
23
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())
    }
}
user2260304
quelle
Dies ist die beste Antwort IMO - hält es für alle zukünftigen Fälle einfach.
Robert
Sie müssen nicht prüfen, ob eine Zeichenfolge vorhanden ist, isEmptyund eine Zeichenfolge initialisieren, um sie zu ersetzen. Sie können das erste Zeichen einfach auspacken und falls es fehlschlägt, geben Sie einfach nil zurück. Dies kann vereinfacht werden alsvar firstCharacterUpperCase: String? { guard let first = first else { return nil } return lowercased().replacingCharacters(in: startIndex...startIndex, with: first.uppercased()) }
Leo Dabus
17

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

DURGESH
quelle
10

Swift 2.0 (einzeilig):

String(nameOfString.characters.prefix(1)).uppercaseString + String(nameOfString.characters.dropFirst())
Phil
quelle
1
Upvoted. Dies setzt jedoch voraus, dass die ursprüngliche Zeichenfolge nur in Kleinbuchstaben geschrieben ist. Ich habe .localizedLowercaseStringam Ende hinzugefügt , damit es mit Zeichenfolgen wie: aNYsTring funktioniert. String(nameOfString.characters.prefix(1)).uppercaseString + String(nameOfString.characters.dropFirst()).localizedLowercaseString
Oyalhi
4

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
Oscar Castellon
quelle
Dies wird nicht nur das erste Zeichen einer Zeichenfolge groß schreiben
Rool Paap
3

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.

Marc Fearby
quelle
Sie können testen, ob die Großschreibung des ersten Zeichens dieses Zeichen ändert - indem Sie es in seiner eigenen Konstante speichern und dann die Gleichheit mit der neuen Zeichenfolge mit Großschreibung testen. Wenn diese Zeichen identisch sind, haben Sie bereits das, was Sie möchten.
David H
Ihr Beitrag hat diese Antwort inspiriert - danke!: Func capitaizeFirstChar (var s: String) -> String {if s.isEmpty == false {let range = s.startIndex ... s.startIndex let original = s.substringWithRange (range) let kapitalisiert = original.capitalizedString wenn original == kapitalisiert {return s} s.replaceRange (Bereich, mit: kapitalisiert)} return s}
David H
1
In neueren Versionen von Swift countElementsist nur count.
George Poulos
3

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

Yura
quelle
3

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()
  }
}
Adam Sharp
quelle
Es ist nicht erforderlich, einen String mit dem ersten Zeichen zu initialisieren. return first.uppercased() + dropFirst()oder ein Liner(first?.uppercased() ?? "") + dropFirst()
Leo Dabus
2

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

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

pierre23
quelle
1

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
    }
}
Ericgu
quelle
1

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
}
Nazariy Vlizlo
quelle
Das ist nicht ganz schnell.
Abhishek Bedi
1

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
    }
}
Matt
quelle
1
Swift String hat eine Methode namens capitalizedString. Wenn Sie es auf ein Array von Zeichenfolgen anwenden müssen, überprüfen Sie diese Antwort stackoverflow.com/a/28690655/2303865
Leo Dabus
1

Swift 4

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

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)
}
Guptron
quelle
0
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.

Dan Leonard
quelle
0

Swift 3 Update

Die replaceRangeFunk ist jetztreplaceSubrange

nameOfString.replaceSubrange(nameOfString.startIndex...nameOfString.startIndex, with: String(nameOfString[nameOfString.startIndex]).capitalized)
Brendt Bly
quelle
Die Methode "kapitalisiert" wurde in "kapitalisiert" umbenannt
Rool Paap
0

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.

Patrick Beard
quelle
0

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: " ")
    }
}
Daniel R.
quelle
String hat bereits eine Eigenschaft, die capitalizedgenau zu diesem Zweck aufgerufen wurde
Leo Dabus
0

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"
Shilpriya
quelle
2
Verwenden .capitalized
Sie
0

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()
    }
}
Ashu
quelle
1
Verwenden .capitalized
Sie
@kakubei Warum du negativ abstimmst. Diese Methode ist für den Fallfall vorgesehen. Großschreibung macht jedes erste Zeichen des Wortes zum Kapital. Beispielzeichenfolge: - (DIES IST EIN JUNGE) .capitalizedwird zurückgegeben (Dies ist ein Junge) und diese Methode wird zurückgegeben (Dies ist ein Junge). Beide sind unterschiedlich. (Bitte + ve abstimmen oder Negativ entfernen)
Ashu
Du hast Recht @ashu, ich entschuldige mich. Ich kann jedoch nicht upvoten, bis Sie die Antwort bearbeiten. Nehmen Sie also möglicherweise nur einen kleinen Leerraum vor und ich werde sie upvoten. Entschuldigung nochmal.
Kakubei
Es ist nicht erforderlich, einen String mit dem ersten Zeichen zu initialisieren. return first.uppercased() + dropFirst()oder ein Liner zurück(first?.uppercased() ?? "") + dropFirst()
Leo Dabus
0

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

yourString.firstUppercased

Beispiel: "abc" -> "Abc"

Hula
quelle
Es gibt keine firstUppercased-Immobilie in Swift
Leo Dabus
0

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

 txtFieldName.autocapitalizationType = UITextAutocapitalizationType.words
Pranit
quelle
-1
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)
    }
}
john07
quelle