Swift ใช้. ตัวกรองสตริงกับอักษรตัวแรกของสตริงเท่านั้น

ฉันพยายามสร้างระบบแก้ไขอัตโนมัติและเมื่อผู้ใช้พิมพ์คำด้วยอักษรตัวใหญ่การแก้ไขอัตโนมัติจะไม่ทำงาน เพื่อแก้ไขปัญหานี้ฉันได้ทำสำเนาของสตริงที่พิมพ์ใช้. lowercaseString แล้วเปรียบเทียบมัน หากสายอักขระนั้นพิมพ์ผิดมันควรแก้ไขคำนั้น อย่างไรก็ตามคำที่แทนที่คำที่พิมพ์คือตัวพิมพ์เล็กทั้งหมด ดังนั้นฉันจำเป็นต้องใช้. ผู้จัดหาสตริงกับตัวอักษรตัวแรกเท่านั้น ฉันคิดว่าฉันสามารถใช้

nameOfString[0]

แต่สิ่งนี้ดูเหมือนจะไม่ทำงาน ฉันจะรับตัวอักษรตัวแรกของสตริงเป็นตัวพิมพ์ใหญ่ได้อย่างไรจากนั้นสามารถพิมพ์สตริงแบบเต็มด้วยตัวอักษรตัวใหญ่เป็นตัวพิมพ์ใหญ่ได้

ขอบคุณสำหรับความช่วยเหลือใด ๆ !

รวมถึงการกลายพันธุ์และไม่กลายพันธุ์รุ่นที่สอดคล้องกับแนวทาง API

สวิฟท์ 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()
    }
}

สวิฟท์ 4:

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

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

Swift 5.1 หรือใหม่กว่า

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

สวิฟท์ 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ž"

สวิฟท์ 3.0

สำหรับ "Hello World"

nameOfString.capitalized

หรือสำหรับ "สวัสดีโลก"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

หรือ

string.capitalized

อย่างไรก็ตามนี่ใช้อักษรตัวแรกของทุกคำ

เอกสารของ Apple:

สตริงตัวพิมพ์ใหญ่เป็นสตริงที่มีอักขระตัวแรกในแต่ละคำเปลี่ยนเป็นค่าตัวพิมพ์ใหญ่ที่สอดคล้องกันและอักขระที่เหลือทั้งหมดตั้งค่าเป็นค่าตัวพิมพ์เล็กที่สอดคล้องกัน “ คำ” คือลำดับของอักขระที่คั่นด้วยช่องว่างแท็บหรือตัวคั่นบรรทัด เครื่องหมายวรรคตอนทั่วไปบางตัวจะไม่นำมาพิจารณาเพื่อเว้นวรรคดังนั้นโดยทั่วไปคุณสมบัตินี้อาจไม่ให้ผลลัพธ์ที่ต้องการสำหรับสตริงหลายคำ ดูที่ getLineStart (_: end: contentEnd: for :) วิธีการสำหรับข้อมูลเพิ่มเติม

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:

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

สำหรับอักขระตัวแรกในการใช้คำ.capitalizedอย่างรวดเร็วและสำหรับการใช้ทั้งคำ.uppercased()

Swift 2.0 (บรรทัดเดียว):

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

Swift 3 (xcode 8.3.3)

พิมพ์ใหญ่อักขระตัวแรกของสตริงทั้งหมด

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

//Your String

ตัวพิมพ์ใหญ่ทั้งหมด

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

//YOUR STRING

ตัวพิมพ์ใหญ่ตัวอักษรตัวแรกของสตริงเท่านั้น

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

//Your string

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

ใช้กับสตริงของคุณ

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

ฉันได้ตัวละครแรกที่ซ้ำกับโซลูชันของ Kirsteins สิ่งนี้จะทำให้ตัวละครตัวแรกเป็นตัวพิมพ์ใหญ่โดยไม่เห็นตัวละครซ้ำ:

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

ฉันไม่รู้ว่ามันมีประสิทธิภาพมากกว่าหรือน้อยกว่าฉันเพิ่งรู้ว่ามันให้ผลลัพธ์ที่ต้องการ

จาก Swift 3 คุณสามารถใช้งานได้อย่างง่ายดาย textField.autocapitalizationType = UITextAutocapitalizationType.sentences

นี่เป็นเวอร์ชั่นสำหรับSwift 5ที่ใช้API คุณสมบัติ Unicode scalarเพื่อประกันตัวอักษรหากอักษรตัวแรกเป็นตัวพิมพ์ใหญ่แล้วหรือไม่มีความคิด:

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

ใช้อักษรตัวแรกในสตริง

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 (นี่เร็วกว่าเล็กน้อยและปลอดภัยกว่าคำตอบที่ยอมรับ):

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

nameOfString.capitalized จะไม่ทำงานมันจะเป็นตัวพิมพ์ใหญ่ทุกคำในประโยค

เครดิตสำหรับ Leonardo Savio Dabus:

ฉันคิดว่ากรณีการใช้งานส่วนใหญ่คือการได้รับปลอกที่เหมาะสม:

import Foundation

extension String {

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

ทางออกของฉัน:

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
}

เมื่อรวมคำตอบข้างต้นฉันได้เขียนส่วนขยายขนาดเล็กที่ใช้อักษรตัวแรกของทุกคำ (เพราะนั่นคือสิ่งที่ฉันกำลังมองหาและคิดว่าคนอื่นสามารถใช้มันได้)

ฉันอ่อนน้อมถ่อมตน:

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

สวิฟต์ 4

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

นี่คือวิธีที่ฉันทำในขั้นตอนเล็ก ๆ คล้ายกับ @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
}

นอกจากนี้ยังใช้งานได้เพียงส่งสตริงของคุณและได้รับหนึ่งกลับเป็นตัวพิมพ์ใหญ่

อัพเดต Swift 3

replaceRangefunc อยู่ในขณะนี้replaceSubrange

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

ฉันเป็นส่วนหนึ่งของรุ่นนี้ซึ่งเป็นรุ่นที่ปรับปรุงแล้วจากคำตอบอื่น:

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

มันมุ่งมั่นที่จะมีประสิทธิภาพมากขึ้นโดยการประเมิน self.characters เพียงครั้งเดียวแล้วใช้รูปแบบที่สอดคล้องกันเพื่อสร้างสตริงย่อย

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

หากคุณต้องการใช้อักษรตัวพิมพ์ใหญ่แต่ละคำคุณสามารถใช้ส่วนขยายนี้ได้

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

มือสอง

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

หากสตริงของคุณคือตัวพิมพ์ใหญ่ทั้งหมดวิธีด้านล่างจะทำงาน

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

ส่วนขยายนี้จะช่วยคุณ

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

เพิ่มบรรทัดนี้ในเมธอด 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)
    }
}

สำหรับ Swift 5 คุณสามารถทำเช่นนั้นได้ง่ายๆ:

yourString.firstUppercased

ตัวอย่าง: "abc" -> "Abc"