web-dev-qa-db-ja.com

CamelCase文字列をスペースで区切られた単語に区切るSwift

CamelCase文字列を新しい文字列内のスペースで区切られた単語に分割したいと思います。これが私がこれまでに持っているものです：

var camelCaps: String {
    guard self.count > 0 else { return self }
    var newString: String = ""

    let uppercase = CharacterSet.uppercaseLetters
    let first = self.unicodeScalars.first!
    newString.append(Character(first))
    for scalar in self.unicodeScalars.dropFirst() {
        if uppercase.contains(scalar) {
            newString.append(" ")
        }
        let character = Character(scalar)
        newString.append(character)
    }

    return newString
}

let aCamelCaps = "aCamelCaps"
let camelCapped = aCamelCaps.camelCaps // Produce: "a Camel Caps"

let anotherCamelCaps = "ÄnotherCamelCaps"
let anotherCamelCapped = anotherCamelCaps.camelCaps // "Änother Camel Caps"

タイトなループで、または何千回も呼び出すと、これがスペースで区切られた単語に変換する最も効率的な方法ではないのではないかと思う傾向があります。 Swiftでこれを行うためのより効率的な方法はありますか？

[編集1：]私が必要とする解決策は、Roman ASCII "A..Z"に固有ではなく、Unicodeスカラーに対して一般的である必要があります。

[編集2：]ソリューションでは、最初の文字もスキップする必要があります。つまり、最初の文字の前にスペースを追加しないでください。

[編集3：] Swift 4構文用に更新され、uppercaseLettersのキャッシュが追加されました。これにより、非常に長い文字列とタイトなループでのパフォーマンスが向上します。

iosswiftstringmacoscamelcasing
15
Brian Arnold

古いMacBookでテストした限り、コードは短い文字列に対して十分効率的であるようです。

import Foundation

extension String {

    var camelCaps: String {
        var newString: String = ""

        let upperCase = CharacterSet.uppercaseLetters
        for scalar in self.unicodeScalars {
            if upperCase.contains(scalar) {
                newString.append(" ")
            }
            let character = Character(scalar)
            newString.append(character)
        }

        return newString
    }

    var camelCaps2: String {
        var newString: String = ""

        let upperCase = CharacterSet.uppercaseLetters
        var range = self.startIndex..<self.endIndex
        while let foundRange = self.rangeOfCharacter(from: upperCase,range: range) {
            newString += self.substring(with: range.lowerBound..<foundRange.lowerBound)
            newString += " "
            newString += self.substring(with: foundRange)

            range = foundRange.upperBound..<self.endIndex
        }
        newString += self.substring(with: range)

        return newString
    }

    var camelCaps3: String {
        struct My {
            static let regex = try! NSRegularExpression(pattern: "[A-Z]")
        }
        return My.regex.stringByReplacingMatches(in: self, range: NSRange(0..<self.utf16.count), withTemplate: " $0")
    }
}
let aCamelCaps = "aCamelCaps"

assert(aCamelCaps.camelCaps == aCamelCaps.camelCaps2)
assert(aCamelCaps.camelCaps == aCamelCaps.camelCaps3)

let t0 = Date().timeIntervalSinceReferenceDate

for _ in 0..<1_000_000 {
    let aCamelCaps = "aCamelCaps"

    let camelCapped = aCamelCaps.camelCaps
}

let t1 = Date().timeIntervalSinceReferenceDate
print(t1-t0) //->4.78703999519348

for _ in 0..<1_000_000 {
    let aCamelCaps = "aCamelCaps"

    let camelCapped = aCamelCaps.camelCaps2
}

let t2 = Date().timeIntervalSinceReferenceDate
print(t2-t1) //->10.5831440091133

for _ in 0..<1_000_000 {
    let aCamelCaps = "aCamelCaps"

    let camelCapped = aCamelCaps.camelCaps3
}

let t3 = Date().timeIntervalSinceReferenceDate
print(t3-t2) //->14.2085000276566

（Playgroundで上記のコードをテストしようとしないでください。数値はCommandLineアプリとして実行された1回の試行から取得されます。）

8
OOPer

ここで同じことをする別の方法Swift 2.x

extension String {

    func camelCaseToWords() -> String {

        return unicodeScalars.reduce("") {

            if NSCharacterSet.uppercaseLetterCharacterSet().characterIsMember(uint_least16_t($1.value)) {
                return ($0 + " " + String($1))
            }
            else {

                return ($0 + String($1))
            }
        }
    }
}

Swift 3.x

extension String {

    func camelCaseToWords() -> String {

        return unicodeScalars.reduce("") {

            if CharacterSet.uppercaseLetters.contains($1) {

                return ($0 + " " + String($1))
            }
            else {

                return $0 + String($1)
            }
        }
    }
}

誰かに役立つかもしれません:)

11
Augustine P A

遅れるかもしれませんが、 Augustine P A 回答または Leo Dabus コメントに少し改善を加えたいと思います。
基本的に、upper camel case表記（「DuckDuckGo」など）を使用している場合、文字列の先頭にスペースが追加されるため、このコードは正しく機能しません。
この問題に対処するために、これはSwift 3.xを使用したコードのわずかに変更されたバージョンであり、両方の上位と互換性があります下のケース：

extension String {

    func camelCaseToWords() -> String {
        return unicodeScalars.reduce("") {
            if CharacterSet.uppercaseLetters.contains($1) {
                if $0.characters.count > 0 {
                    return ($0 + " " + String($1))
                }
            }
            return $0 + String($1)
        }
    }
}
5
matteodv

ワンラインソリューション

@ aircraft に同意します。正規表現を使用すると、この問題を1つのLOCで解決できます。

extension String {
    func titleCase() -> String {
        return (self as NSString)
            .replacingOccurrences(of: "([A-Z])", with: " $1", options: 
.regularExpression, range: NSRange(location: 0, length: count))
            // optional
            .trimmingCharacters(in: .whitespacesAndNewlines) 
            .capitalized // If input is in llamaCase
    }
}

このJSの答え への小道具。

P.S. snake_case → CamelCaseここ の要点があります。

5
AmitaiB

より良い完全な迅速なソリューション... AmitaiBの回答に基づく

extension String {
    func titlecased() -> String {
        return self.replacingOccurrences(of: "([A-Z])", with: " $1", options: .regularExpression, range: self.range(of: self))
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .capitalized
    }
}
4
busta117

この拡張機能は、より少ないコード行で（そしてCharacterSetなしで）実行できますが、大文字の前にスペースを挿入する場合は、基本的に各文字列を列挙する必要があります。

var differentCamelCaps: String {

    var newString: String = ""

    for eachCharacter in self.characters {
        if (eachCharacter >= "A" && eachCharacter <= "Z") == true {
            newString.append(" ")
        }
        newString.append(eachCharacter)
    }

    return newString
}
3
Michael Dautermann

より効率的にしたい場合は、Regular Expressionsを使用できます。

 extension String {
    func replace(regex: NSRegularExpression, with replacer: (_ match:String)->String) -> String {
    let str = self as NSString
    let ret = str.mutableCopy() as! NSMutableString

    let matches = regex.matches(in: str as String, options: [], range: NSMakeRange(0, str.length))
    for match in matches.reversed() {
        let original = str.substring(with: match.range)
        let replacement = replacer(original)
        ret.replaceCharacters(in: match.range, with: replacement)
    }
        return ret as String
    }
}

let camelCaps = "aCamelCaps"  // there are 3 Capital character
let pattern = "[A-Z]"
let regular = try!NSRegularExpression(pattern: pattern)
let camelCapped:String = camelCaps.replace(regex: regular) { " \($0)" }
print("Uppercase characters replaced: \(camelCapped)")
2
aircraft
extension String {
    func titlecased() -> String {
        return self
            .replacingOccurrences(of: "([a-z])([A-Z](?=[A-Z])[a-z]*)", with: "$1 $2", options: .regularExpression)
            .replacingOccurrences(of: "([A-Z])([A-Z][a-z])", with: "$1 $2", options: .regularExpression)
            .replacingOccurrences(of: "([a-z])([A-Z][a-z])", with: "$1 $2", options: .regularExpression)
            .replacingOccurrences(of: "([a-z])([A-Z][a-z])", with: "$1 $2", options: .regularExpression)
    }
}

In

 "ThisStringHasNoSpacesButItDoesHaveCapitals"
 "IAmNotAGoat"
 "LOLThatsHilarious!"
 "ThisIsASMSMessage"

アウト

"This String Has No Spaces But It Does Have Capitals" 
"I Am Not A Goat" 
"LOL Thats Hilarious!" 
"This Is ASMS Message" // (Difficult tohandle single letter words when they are next to acronyms.)

ここにリンクの説明を入力してください

1
小洋粉

Swift5ソリューション

extension String {

    func camelCaseToWords() -> String {
        return unicodeScalars.reduce("") {
            if CharacterSet.uppercaseLetters.contains($1) {
                if $0.count > 0 {
                    return ($0 + " " + String($1))
                }
            }
            return $0 + String($1)
        }
    }
}
1
Deepak