Swift stosuje .uppercaseString tylko do pierwszej litery ciągu

Próbuję stworzyć system autokorekty, a gdy użytkownik wpisze słowo z wielką literą, autokorekta nie działa. Aby to naprawić, zrobiłem kopię napisanego łańcucha, zastosowałem .lowercaseString, a następnie porównałem je. Jeśli ciąg znaków jest rzeczywiście źle wpisany, powinien poprawić słowo. Jednak słowo, które zastępuje wpisane słowo, jest pisane małymi literami. Więc muszę zastosować .uppercaseString tylko do pierwszej litery. Początkowo myślałem, że mogę użyć

nameOfString[0]

ale to najwyraźniej nie działa. Jak uzyskać pierwszą literę ciągu na wielkie litery, a następnie móc wydrukować cały ciąg z wielką literą pierwszej litery?

Dzięki za wszelką pomoc!

W tym mutujące i niemutujące wersje zgodne z wytycznymi 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 lub nowszy

extension StringProtocol {
    var firstUppercased: String { prefix(1).uppercased() + dropFirst() }
    var firstCapitalized: String { prefix(1).capitalized + dropFirst() }
}

Szybki 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

za „Hello World”

nameOfString.capitalized

lub „HELLO WORLD”

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

lub

string.capitalized

Jednak litera każdego słowa jest wielką literą

Dokumentacja Apple:

Łańcuch wielkich liter to ciąg z pierwszym znakiem w każdym słowie zmienionym na odpowiadającą mu wielką literę, a wszystkie pozostałe znaki ustawione na odpowiadające im małe litery. „Słowo” to dowolna sekwencja znaków rozdzielona spacjami, tabulatorami lub znakami końca linii. Niektóre popularne słowa interpunkcyjne ograniczające nie są brane pod uwagę, więc ta właściwość może na ogół nie dawać pożądanych wyników dla ciągów wielowątkowych. Zobacz metodę getLineStart (_: end: contentEnd: for :), aby uzyskać dodatkowe informacje.

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

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

Dla pierwszego znaku w użyciu słowa .capitalizedw trybie szybkim i do użycia całego słowa.uppercased()

Swift 2.0 (pojedyncza linia):

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

Swift 3 (xcode 8.3.3)

Wielkie litery wszystkich pierwszych znaków ciągu

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

//Your String

Wielkie litery wszystkich znaków

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

//YOUR STRING

Wielkie litery tylko pierwszy znak ciągu

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

//Your string

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

użyj ze swoim ciągiem

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

Dostaję pierwszą postać powieloną z rozwiązaniem Kirsteinsa. Spowoduje to wielkie litery pierwszej postaci, bez podwójnego:

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

Nie wiem, czy jest bardziej czy mniej wydajny, po prostu wiem, że daje mi pożądany efekt.

Z Swift 3 możesz łatwo korzystać textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Oto wersja dla Swift 5, która korzysta z interfejsu API właściwości skalarnych Unicode, aby ratować, jeśli pierwsza litera jest już wielka lub nie ma pojęcia wielkości liter:

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

Wpisz pierwszy znak w ciągu

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

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

W Swift 3.0 (jest to trochę szybsze i bezpieczniejsze niż zaakceptowana odpowiedź):

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

nameOfString.capitalized nie będzie działać , będzie używać wielkich liter każdego słowa w zdaniu

Kredyty dla Leonardo Savio Dabus:

Wyobrażam sobie, że większość przypadków użycia polega na uzyskaniu odpowiedniej obudowy:

import Foundation

extension String {

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

Moje rozwiązanie:

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
}

Uwzględniając powyższe odpowiedzi, napisałem małe rozszerzenie, które zawiera pierwszą literę każdego słowa (ponieważ właśnie tego szukałem i pomyślałem, że ktoś inny może go użyć).

Pokornie składam:

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

Szybki 4

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

Oto jak to zrobiłem małymi krokami, jest podobny do @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
}

Działa również po prostu przekaż swój ciąg i odzyskaj wielką literę.

Aktualizacja Swift 3

replaceRangeFunc jest terazreplaceSubrange

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

Jestem częściowo zwolennikiem tej wersji, która jest oczyszczoną wersją z innej odpowiedzi:

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

Stara się być bardziej efektywny, oceniając tylko samopodobne postacie, a następnie używa spójnych formularzy do tworzenia podłańcuchów.

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

Jeśli chcesz wielkie litery każdego słowa ciągu, możesz użyć tego rozszerzenia

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

Używany

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

Jeśli ciąg zawiera wszystkie wielkie litery, zadziała poniższa metoda

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

To rozszerzenie ci pomoże

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

Dodaj ten wiersz w metodzie 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)
    }
}

W przypadku swift 5 możesz po prostu zrobić tak:

yourString.firstUppercased

Przykład: „abc” -> „Abc”