Swift gelten .uppercaseString nur den ersten Buchstaben einer Zeichenfolge

Einschließlich mutiert und nicht mutierenden Versionen, sind in übereinstimmung mit API-Richtlinien.

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

InformationsquelleAutor Kirsteins

Swift 3.0

für "Hallo Welt"

nameOfString.capitalized

oder für "HALLO WELT"

nameOfString.uppercased

InformationsquelleAutor Maselko

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

InformationsquelleAutor user2260304

Für das erste Zeichen in word verwenden .capitalized im swift-und für ganze Wörter verwenden .uppercased()

InformationsquelleAutor DURGESH Chaurasiya

Swift 3 (xcode 8.3.3)

Großbuchstaben allen ersten Zeichen von string

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

//Your String

Großschreibung alle Zeichen

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

//YOUR STRING

Groß-nur erste Zeichen des string

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

//Your string

InformationsquelleAutor oscar castellon

Hier eine version für Swift 5 , verwendet die Unicode-scalar-Eigenschaften API zu retten, wenn der erste Brief ist bereits Großbuchstaben, oder nicht haben eine Vorstellung des case:

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

InformationsquelleAutor Adam Sharp

Credits zu Leonardo Savio Dabus:

Stell ich mir die meisten Anwendungsfälle ist eine gute Gehäuse:

import Foundation

extension String {

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

InformationsquelleAutor ericgu

Einbeziehung der oben genannten Antworten, schrieb ich eine kleine Erweiterung, die Großschreibung des ersten Buchstabens jedes Wortes (denn das ist das, was ich suchte und dachte, jemand anderes könnte es).

Ich demütig Einreichen:

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

InformationsquelleAutor Matt

Swift 4

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

InformationsquelleAutor Gayratjon

func helperCapitalizeFirstLetter(stringToBeCapd:String)->String{
    let capString = stringToBeCapd.substringFromIndex(stringToBeCapd.startIndex).capitalizedString
    return capString
}

Funktioniert auch, nur pass den string aus und erhalten Sie eine aktivierte zurück.

InformationsquelleAutor Daniel Leonard

Ich bin teilweise zu dieser version, die bereinigt version von einem anderen Antwort:

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 nur die Bewertung selbst.Zeichen einmal, und dann verwendet, einheitliche Formen zu erstellen, die sub-strings.

InformationsquelleAutor Patrick Beard

Wenn Ihr string ist alle Kappen dann unten Methode funktioniert

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

InformationsquelleAutor Ashu

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

InformationsquelleAutor john07