Swift, bir dizenin yalnızca ilk harfine .uppercaseString uygular

Otomatik düzeltme sistemi yapmaya çalışıyorum ve bir kullanıcı büyük harfli bir sözcük yazdığında, otomatik düzeltme çalışmıyor. Bunu düzeltmek için, yazılan dizenin bir kopyasını yaptım .lowercaseString uyguladım ve sonra karşılaştırdım. Dize gerçekten yanlış yazılmışsa, kelimeyi düzeltmelidir. Ancak daha sonra, yazılan sözcüğün yerini alan kelimenin tümü küçük harf olur. Bu yüzden .uppercaseString öğesini yalnızca ilk harfe uygulamam gerekiyor. Aslında kullanabileceğimi düşündüm

nameOfString[0]

ama görünüşe göre bu çalışmıyor. Dizenin ilk harfini büyük harfe nasıl getirebilirim ve ardından ilk harfi büyük harfle yazarak dizenin tamamını yazdırabilir miyim?

Herhangi bir yardım için teşekkürler!

API yönergelerine uygun mutasyon ve mutasyona uğramamış sürümler dahil.

Hızlı 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()
    }
}

Hızlı 4:

extension String {
    func capitalizingFirstLetter() -> String {
      return prefix(1).uppercased() + self.lowercased().dropFirst()
    }

    mutating func capitalizeFirstLetter() {
      self = self.capitalizingFirstLetter()
    }
}

Swift 5.1 veya üstü

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

Hızlı 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

"Merhaba Dünya" için

nameOfString.capitalized

veya "HELLO WORLD" için

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

veya

string.capitalized

Ancak bu her kelimenin ilk harfini büyük yapar

Apple'ın belgeleri:

Büyük harfli dize, her sözcüğün ilk karakteri karşılık gelen büyük harf değerine ve kalan tüm karakterler karşılık gelen küçük harf değerlerine ayarlanmış bir dizedir. "Sözcük", boşluklar, sekmeler veya satır sonlandırıcılarla sınırlandırılmış herhangi bir karakter dizisidir. Bazı ortak kelime sınırlama noktalama işaretleri dikkate alınmadığından, bu özellik genellikle çok kelimeli dizeler için istenen sonuçları vermeyebilir. Ek bilgi için getLineStart (_: end: contentEnd: for :) yöntemine bakın.

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

Swift 5 için:

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

.capitalizedHızlı sözcük kullanımı ve tam sözcük kullanımı için ilk karakter.uppercased()

Swift 2.0 (Tek satır):

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

Swift 3 (xcode 8.3.3)

Dizenin tüm ilk karakterlerini büyük harfe çevirme

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

//Your String

Tüm karakterleri büyük harfe çevirme

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

//YOUR STRING

Dizenin yalnızca ilk karakteri büyük harf

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

//Your string

Hızlı 5'te

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

ipinle kullan

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

Kirsteins'in çözümü ile ilk karakteri tekrar ediyorum. Bu, çift görmeden ilk karakteri büyük harfe çevirir:

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

Az ya da çok verimli olup olmadığını bilmiyorum, sadece istenen sonucu verdiğini biliyorum.

Swift 3'ten kolayca kullanabilirsiniz textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Swift 5 için , ilk harf zaten büyük harfse veya büyük / küçük harf durumunda değilse kefalet için Unicode skaler özellikleri API'sini kullanan bir sürüm :

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

Dizedeki ilk karakteri büyük harfe çevirme

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

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

Swift 3.0'da (bu, kabul edilen cevaptan biraz daha hızlı ve daha güvenlidir):

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

nameOfString.capitalized çalışmaz , cümledeki her kelimeyi büyük harfe çevirir

Leonardo Savio Dabus'a verilen krediler:

Çoğu kullanım vakasının uygun kasa elde etmek olduğunu düşünüyorum:

import Foundation

extension String {

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

Çözümüm:

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
}

Yukarıdaki cevapları dahil ederek, her kelimenin ilk harfini büyük harfle yazan küçük bir uzantı yazdım (çünkü aradığım ve başka birinin kullanabileceğini düşündüm).

Alçakgönüllü gönderiyorum:

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

Hızlı 4

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

İşte bunu küçük adımlarla yaptım, @Kirsteins'e benziyor.

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
}

Ayrıca çalışır sadece dize geçmek ve büyük bir geri almak.

Swift 3 Güncellemesi

replaceRangeFonk şimdireplaceSubrange

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

Ben başka bir cevap temizlenmiş bir sürümü olan bu sürümü, kısmi:

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

Benlik karakterlerini yalnızca bir kez değerlendirerek daha verimli olmaya çalışır ve sonra alt dizeleri oluşturmak için tutarlı formlar kullanır.

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

Her bir string kelimesini büyük harfle yazmak istiyorsanız bu uzantıyı kullanabilirsiniz

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

Kullanılmış

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

Dizeniz tamamen büyük harfse, aşağıdaki yöntem işe yarayacaktır

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

Bu uzantı size yardımcı olacaktır

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

Bu satırı viewDidLoad () yöntemine ekleyin.

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

Hızlı 5 için şunları yapabilirsiniz:

yourString.firstUppercased

Örnek: "abc" -> "Abc"