Camel-case a string in Swift

camel_case.swift

func camelCaseString(source: String) -> String {
    if contains(source, " ") {
        let first = source.substringToIndex(advance(source.startIndex, 1))
        let cammel = NSString(format: "%@", (source as NSString).capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "", options: nil, range: nil)) as String
        let rest = dropFirst(cammel)
        return "\(first)\(rest)"
    } else {
        let first = (source as NSString).lowercaseString.substringToIndex(advance(source.startIndex, 1))
        let rest = dropFirst(source)
        return "\(first)\(rest)"
    }
}

camelCaseString("os version")
camelCaseString("HelloWorld")
camelCaseString("someword With Characters")

camel_cased_string_extension.swift

extension String {
    var camelCasedString: String {
        let source = self
        if contains(source, " ") {
            let first = source.substringToIndex(advance(source.startIndex, 1))
            let cammel = NSString(format: "%@", (source as NSString).capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "", options: nil, range: nil)) as String
            let rest = dropFirst(cammel)
            return "\(first)\(rest)"
        } else {
            let first = (source as NSString).lowercaseString.substringToIndex(advance(source.startIndex, 1))
            let rest = dropFirst(source)
            return "\(first)\(rest)"
        }
    }
}

"os version".camelCasedString
"HelloWorld".camelCasedString
"someword With Characters".camelCasedString

swift 2.1 version

extension String {
    var camelCasedString: String {
        let source = self
        if source.characters.contains(" ") {
            let first = source.substringToIndex(source.startIndex.advancedBy(1))
            let cammel = NSString(format: "%@", (source as NSString).capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "", options: [], range: nil)) as String
            let rest = String(cammel.characters.dropFirst())
            return "\(first)\(rest)"
        } else {
            let first = (source as NSString).lowercaseString.substringToIndex(source.startIndex.advancedBy(1))
            let rest = String(source.characters.dropFirst())
            return "\(first)\(rest)"
        }
    }
}

Swift 2.2 Version without NSString

extension String {
    var camelcaseString: String {
        let source = self
        if source.characters.contains(" ") {
            let first = source.substringToIndex(source.startIndex.advancedBy(1))
            let cammel = source.capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "")
            let rest = String(cammel.characters.dropFirst())
            return "\(first)\(rest)"
        } else {
            let first = source.lowercaseString.substringToIndex(source.startIndex.advancedBy(1))
            let rest = String(source.characters.dropFirst())
            return "\(first)\(rest)"

        }
    }
}

Hi,
Thanks for this !
Just a small remark, it doesn't works as expected on uppercase string.EXAMPLE will be printed as eXAMPLE.
So I've updated it like that:

extension String {
    var camelcaseStringLowerCase: String {
        let source = self
        if source.characters.contains(" ") {
            let first = source.substringToIndex(source.startIndex.advancedBy(1))
            let cammel = source.capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "")
            let rest = String(cammel.characters.dropFirst())
            return "\(first)\(rest)"
        } else {
            let first = source.lowercaseString.substringToIndex(source.startIndex.advancedBy(1))
            let rest = String(source.characters.dropFirst())
            return "\(first)\(rest)"
        }
    }
    var camelcaseStringUpperCase: String {
        let source = self
        if source.characters.contains(" ") {
            let first = source.lowercaseString.substringToIndex(source.startIndex.advancedBy(1))
            let rest = String(source.characters.dropFirst())
            return "\(first)\(rest)"
        } else {
            let first = source.substringToIndex(source.startIndex.advancedBy(1))
            let cammel = source.capitalizedString.stringByReplacingOccurrencesOfString(" ", withString: "")
            let rest = String(cammel.characters.dropFirst())
            return "\(first)\(rest)"
        }
    }
}

Regards,
vIVIEN

Updated for Swift 3/4

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

    var camelCasedString: String {
        return self.components(separatedBy: " ")
            .map { return $0.lowercased().capitalizingFirstLetter() }
            .joined()
    }

Swift 5
I have a rather distinct feeling this can be done more efficiently, but at least this works:

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

    var upperCamelCased: String {
        return self.lowercased()
            .split(separator: " ")
            .map { return $0.lowercased().capitalizingFirstLetter() }
            .joined()
    }
    
    var lowerCamelCased: String {
        let upperCased = self.upperCamelCased
        return upperCased.prefix(1).lowercased() + upperCased.dropFirst()
    }
}

For those that got a bit confused about the difference between upperCamelCased and lowerCamelCased. upper is PascalCasing, and lower is camelCasing. @Gatada Thanks for the snippet!

PascalCasing - did not know that term, thanks. So that would mean pascalCased, right?

@Gatada it's exactly like @MadsBogeskov wrote it.
Pascal Casing = PascalCasing
Camel Casing = camelCasing

@Gatada it's exactly like @MadsBogeskov wrote it.
Pascal Casing = PascalCasing
Camel Casing = camelCasing

Hehe, yeah, in retrospect I see how my reply was confusing. I was referring to the method name, not the formatting.