Swift menerapkan .uppercaseString hanya untuk huruf pertama dari suatu string

Saya mencoba membuat sistem koreksi otomatis, dan ketika pengguna mengetik kata dengan huruf besar, koreksi otomatis tidak berfungsi. Untuk memperbaikinya, saya membuat salinan dari string yang diketik, diterapkan .lowercaseString, dan kemudian membandingkannya. Jika string tersebut salah ketik, seharusnya kata tersebut diperbaiki. Namun kemudian kata yang menggantikan kata yang diketik semuanya huruf kecil. Jadi saya perlu menerapkan .uppercaseString hanya huruf pertama. Awalnya saya pikir saya bisa menggunakan

nameOfString[0]

tetapi ini tampaknya tidak berhasil. Bagaimana saya bisa mendapatkan huruf pertama dari string menjadi huruf besar, dan kemudian dapat mencetak string penuh dengan huruf pertama dikapitalisasi?

Terima kasih atas bantuannya!

Termasuk versi mutasi dan non mutasi yang konsisten dengan pedoman 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 atau lebih baru

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

Cepat 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

untuk "Hello World"

nameOfString.capitalized

atau untuk "HELLO WORLD"

nameOfString.uppercased

Cepat 4.0

string.capitalized(with: nil)

atau

string.capitalized

Namun ini huruf kapital huruf pertama dari setiap kata

Dokumentasi Apple:

String huruf kapital adalah string dengan karakter pertama di setiap kata yang diubah ke nilai huruf besar yang sesuai, dan semua karakter yang tersisa diatur ke nilai huruf kecil yang sesuai. "Kata" adalah setiap urutan karakter yang dibatasi oleh spasi, tab, atau terminator garis. Beberapa tanda baca pembatas kata umum tidak dipertimbangkan, jadi properti ini mungkin tidak secara umum menghasilkan hasil yang diinginkan untuk string multi-kata. Lihat getLineStart (_: end: contentEnd: for :) metode untuk informasi tambahan.

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

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

Untuk karakter pertama dalam kata, gunakan .capitalizeddengan cepat dan untuk penggunaan seluruh kata.uppercased()

Swift 2.0 (baris tunggal):

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

Swift 3 (xcode 8.3.3)

Huruf besar semua karakter string pertama

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

//Your String

Huruf besar semua karakter

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

//YOUR STRING

Huruf besar hanya karakter pertama dari string

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

//Your string

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

gunakan dengan string Anda

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

Saya mendapatkan karakter pertama diduplikasi dengan solusi Kirsteins. Ini akan menggunakan huruf besar karakter pertama, tanpa melihat ganda:

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

Saya tidak tahu apakah ini lebih atau kurang efisien, saya hanya tahu itu memberi saya hasil yang diinginkan.

Dari Swift 3 Anda dapat dengan mudah menggunakan textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Berikut adalah versi untuk Swift 5 yang menggunakan properti skalar properti Unicode untuk menebus jika huruf pertama sudah huruf besar, atau tidak memiliki gagasan kasus:

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

Memanfaatkan karakter pertama dalam string

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

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

Di Swift 3.0 (ini sedikit lebih cepat dan lebih aman daripada jawaban yang diterima):

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

nameOfString.capitalized tidak akan berfungsi , itu akan memanfaatkan setiap kata dalam kalimat

Penghargaan untuk Leonardo Savio Dabus:

Saya membayangkan sebagian besar kasus penggunaan adalah untuk mendapatkan Casing yang Tepat:

import Foundation

extension String {

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

Solusi saya:

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
}

Menggabungkan jawaban di atas, saya menulis ekstensi kecil yang menggunakan huruf kapital dari setiap kata (karena itulah yang saya cari dan saya pikir orang lain bisa menggunakannya).

Dengan rendah hati saya serahkan:

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

Cepat 4

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

Inilah cara saya melakukannya dalam langkah-langkah kecil, mirip dengan @ Kirstein.

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
}

Juga berfungsi, cukup masukkan string Anda dan dapatkan kembali dengan huruf besar.

Pembaruan Swift 3

The replaceRangefunc sekarangreplaceSubrange

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

Saya setuju dengan versi ini, yang merupakan versi bersih dari jawaban lain:

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

Itu berusaha untuk menjadi lebih efisien dengan hanya mengevaluasi karakter diri sekali, dan kemudian menggunakan bentuk yang konsisten untuk membuat sub-string.

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

Jika Anda ingin menggunakan huruf kapital setiap kata string, Anda dapat menggunakan ekstensi ini

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

Bekas

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

Jika string Anda semua huruf besar maka metode di bawah ini akan berfungsi

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

Ekstensi ini akan membantu Anda

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

Tambahkan baris ini dalam metode 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)
    }
}

Untuk swift 5, Anda dapat melakukannya seperti itu:

yourString.firstUppercased

Contoh: "abc" -> "Abc"