Swift는 문자열의 첫 글자에만 .uppercaseString을 적용합니다

자동 고침 시스템을 만들려고하는데 사용자가 대문자로 단어를 입력하면 자동 고침이 작동하지 않습니다. 이 문제를 해결하기 위해 문자열 형식의 사본을 만들어 .lowercaseString을 적용한 다음 비교했습니다. 문자열이 실제로 잘못 입력 된 경우 단어를 수정해야합니다. 그러나 입력 된 단어를 대체하는 단어는 모두 소문자입니다. 따라서 첫 번째 문자에만 .uppercaseString을 적용해야합니다. 나는 원래 내가 사용할 수 있다고 생각

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

스위프트 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

또는 "HELLO WORLD"

nameOfString.uppercased

스위프트 4.0

string.capitalized(with: nil)

또는

string.capitalized

그러나 이것은 모든 단어의 첫 글자를 대문자로

Apple의 설명서 :

대문자 문자열은 각 단어의 첫 번째 문자가 해당하는 대문자 값으로 변경되고 나머지 모든 문자는 해당하는 소문자 값으로 설정된 문자열입니다. "단어"는 공백, 탭 또는 줄 종결 자로 구분되는 일련의 문자입니다. 일반적인 구두점 구분 구두점은 고려되지 않으므로이 속성은 일반적으로 여러 단어로 된 문자열에 대해 원하는 결과를 생성하지 않을 수 있습니다. 추가 정보는 getLineStart (_ : end : contentsEnd : 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()

스위프트 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()

스위프트 2.0 (한 줄) :

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

스위프트 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

여기에 대한 버전의 스위프트 (5) 용도 유니 코드 스칼라 속성 API를 첫 글자가 대문자 이미 켜져있는 경우 구제, 또는 케이스의 개념이없는이 :

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
}

또한 문자열을 전달하고 대문자를 다시 가져옵니다.

스위프트 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를 한 번만 평가하여보다 효율적으로 노력하고 일관된 양식을 사용하여 하위 문자열을 작성합니다.

스위프트 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: " ")
    }
}

각 문자열을 대문자로 사용하려면이 확장을 사용할 수 있습니다

스위프트 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)
    }
}

신속한 5의 경우 다음과 같이 간단하게 수행 할 수 있습니다.

yourString.firstUppercased

샘플 : "abc"-> "Abc"