Swift áp dụng .uppercaseString chỉ chữ cái đầu tiên của chuỗi

Tôi đang cố gắng tạo một hệ thống tự động sửa lỗi và khi người dùng nhập một từ bằng chữ in hoa, thì tự động sửa không hoạt động. Để khắc phục điều này, tôi đã tạo một bản sao của chuỗi đã nhập, áp dụng .lowercaseString và sau đó so sánh chúng. Nếu chuỗi thực sự bị sai, nó sẽ sửa từ. Tuy nhiên, sau đó từ thay thế từ đánh máy là tất cả chữ thường. Vì vậy, tôi cần phải áp dụng .uppercaseString cho chữ cái đầu tiên. Ban đầu tôi nghĩ mình có thể sử dụng

nameOfString[0]

nhưng điều này dường như không hoạt động. Làm cách nào tôi có thể nhận được chữ cái đầu tiên của chuỗi thành chữ hoa và sau đó có thể in toàn bộ chuỗi với chữ cái đầu tiên được viết hoa?

Cảm ơn vì bất kì sự giúp đỡ!

Bao gồm các phiên bản đột biến và không đột biến phù hợp với nguyên tắc 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 trở lên

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

Swift 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

cho "Xin chào thế giới"

nameOfString.capitalized

hoặc cho "HELLO WORLD"

nameOfString.uppercased

Swift 4.0

string.capitalized(with: nil)

hoặc là

string.capitalized

Tuy nhiên, chữ này viết hoa chữ cái đầu tiên của mỗi từ

Tài liệu của Apple:

Chuỗi viết hoa là một chuỗi có ký tự đầu tiên trong mỗi từ được thay đổi thành giá trị chữ hoa tương ứng và tất cả các ký tự còn lại được đặt thành giá trị chữ thường tương ứng của chúng. Một từ tiếng Nhật là một chuỗi các ký tự được phân cách bằng dấu cách, tab hoặc dấu kết thúc dòng. Một số dấu chấm phân cách từ phổ biến không được xem xét, do đó, thuộc tính này thường không tạo ra kết quả mong muốn cho chuỗi đa từ. Xem phương thức getLineStart (_: end: nội dungEnd: for :) để biết thêm thông tin.

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

Dành cho 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())
    }
}

Đối với ký tự đầu tiên trong việc sử dụng từ .capitalizedtrong swift và cho toàn bộ từ sử dụng.uppercased()

Swift 2.0 (Dòng đơn):

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

Swift 3 (xcode 8.3.3)

Viết hoa tất cả các ký tự đầu tiên của chuỗi

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

//Your String

Viết hoa tất cả các ký tự

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

//YOUR STRING

Ký tự đầu tiên của chuỗi

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

//Your string

Trong 5

https://www.hackingwithswift.com/example-code/strings/how-to-capitalize-the-first-letter-of-a-opes

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

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

sử dụng với chuỗi của bạn

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

Tôi nhận được nhân vật đầu tiên được nhân đôi với giải pháp của Kirsteins. Điều này sẽ viết hoa ký tự đầu tiên, mà không nhìn thấy gấp đôi:

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

Tôi không biết nó hiệu quả hơn hay kém hơn, tôi chỉ biết rằng nó mang lại cho tôi kết quả mong muốn.

Từ Swift 3 bạn có thể dễ dàng sử dụng textField.autocapitalizationType = UITextAutocapitalizationType.sentences

Đây là phiên bản dành cho Swift 5 sử dụng API thuộc tính vô hướng Unicode để bảo lãnh nếu chữ cái đầu tiên là chữ hoa hoặc không có khái niệm về trường hợp:

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

Viết hoa ký tự đầu tiên trong chuỗi

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

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

Trong Swift 3.0 (điều này nhanh hơn một chút và an toàn hơn câu trả lời được chấp nhận):

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

nameOfString.capitalized sẽ không hoạt động , nó sẽ viết hoa mọi từ trong câu

Tín dụng cho Leonardo Savio Dabus:

Tôi tưởng tượng hầu hết các trường hợp sử dụng là để có Vỏ đúng:

import Foundation

extension String {

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

Giải pháp của tôi:

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
}

Kết hợp các câu trả lời ở trên, tôi đã viết một phần mở rộng nhỏ viết hoa chữ cái đầu tiên của mỗi từ (vì đó là những gì tôi đang tìm kiếm và hình dung người khác có thể sử dụng nó).

Tôi khiêm tốn nộp:

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

Swift 4

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

Đây là cách tôi đã làm trong các bước nhỏ, tương tự như @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
}

Cũng hoạt động chỉ cần vượt qua chuỗi của bạn và nhận lại một viết hoa.

Cập nhật Swift 3

Các replaceRangeFunc tại làreplaceSubrange

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

Tôi là một phần của phiên bản này, đây là phiên bản đã được dọn sạch từ một câu trả lời khác:

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

Nó cố gắng để có hiệu quả hơn bằng cách chỉ đánh giá self.char character một lần, sau đó sử dụng các biểu mẫu nhất quán để tạo các chuỗi con.

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

Nếu bạn muốn viết hoa từng từ của chuỗi, bạn có thể sử dụng tiện ích mở rộng này

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

Đã sử dụng

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

Nếu chuỗi của bạn là tất cả các mũ thì phương thức bên dưới sẽ hoạt động

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

Tiện ích mở rộng này sẽ giúp bạn

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

Đối với swift 5, bạn có thể đơn giản làm như vậy:

yourString.firstUppercased

Mẫu: "abc" -> "Abc"

Thêm dòng này trong phương thức 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)
    }
}