DEV Community

Daily Challenge #95 - CamelCase Method

dev.to staff on October 18, 2019

Write simple .camelCase method (camel_case function in PHP, CamelCase in C# or camelCase in Java) for strings. All words must have their first lett...

Read full post

SavagePixie • Oct 18 '19 • Edited

Replace to the rescue!

const camelCase = str => str.replace(/\s([a-z])/g, (_, x) => x.toUpperCase())

Rafael Acioly • Oct 18 '19

very clever :)

Mihail Malo • Oct 23 '19

Doesn't match the first word, should be /(?:^|\s)([a-z])/g for that or something.

SavagePixie • Oct 24 '19 • Edited

I don't capitalise the first word of a camelCase construct. As far as I'm aware, it isn't customary in JavaScript.

But you are right, if one were to capitalise the first word as well, the regular expression would have to be modified accordingly.

Avalander • Oct 26 '19

The confusion is because the description says camelCase but they mean PascalCase.

La blatte • Oct 18 '19

Here comes a naive oneliner:

camel=s=>s.split` `.map(e=>e[0].toUpperCase()+e.slice(1).toLowerCase()).join``

For every word, it uppercases its first letter and lowercases the following ones

Balaji K • Oct 19 '19

Nice one liner :). But if s is an empty string, then str[0] will be undefined and toUpperCase will throw an error.

Jacob Evans • Oct 19 '19

It's not about finding edge cases. This is a great solution for a coding challenge... Most coding challenges are things you'd put in production anyways

K.V.Harish • Oct 18 '19

My solution in js

const camelCase = (words = '') => words.split(' ')
                                       .map(word => `${word.charAt(0).toUpperCase()}${word.slice(1).toLowerCase()}`)
                                       .join('');

Asfo • Oct 18 '19 • Edited

Maybe not the best option :) but it works.
JS:

const camelCase = (str) => { if(typeof str !== 'string') { throw 'Not a string'; } return str.trim().toLowerCase().split(' ').map(el => { return el[0].toUpperCase() + el.slice(1); }).join(''); }

J. R. Swab • Oct 18 '19 • Edited

How about in Go?

func camelcase(s string) string {
    var cameled string
    split := strings.Fields(s)

    for _, v := range split {
        cameled = fmt.Sprintf("%s%s", cameled, strings.Title(v))
    }
    return cameled
}

Playground

Elliot DeNolf • Oct 19 '19

Crystal

def to_camel(input : String)
  input.split(" ").map(&.capitalize).join
end

Tests

describe "to_camel" do
  it "handles 1 word" do
    to_camel("hello").should eq "Hello"
  end

  it "handles 2 words" do
    to_camel("hello world").should eq "HelloWorld"
  end

  it "handles empty string" do
    to_camel("").should eq ""
  end

  it "handles extra whitespace" do
    to_camel("  hello  world  ").should eq "HelloWorld"
  end
end

Ricardo Delgado • Oct 19 '19 • Edited

var camelcase = (s) => {
    var o = new Object(s)
    return o.split` `
                 .map(p => p.split``
                       .map((q, i) => i === 0 ? q.toUpperCase(): q)
                                .join``)
                                        .join``
}

Blessed T Mahuni • Oct 18 '19

A beginner solution

function camelCase(stringToBeCamelCased) {
  let wordsArr = stringToBeCamelCased.split(' ')
  let casedWordsArr = []
  for (const word of wordsArr) {
    let casedWord = []
    for (let i = 0; i < word.length; i++) {
      if(i == 0)
        casedWord.push(word[i].toUpperCase())
      else
        casedWord.push(word[i])
    }
    casedWordsArr.push(casedWord.join(''))
  }

  return casedWordsArr.join('')
}

// refined

function camelCaseV2(stringToBeCamelCased) {
  let casedWordsArr = []
  stringToBeCamelCased.split(' ').forEach(word => {
    casedWordsArr.push(word[0].toUpperCase() + word.slice(1))
  })
  return casedWordsArr.join('')
}

Amin • Oct 18 '19

Haskell

import Data.Char

(|>) = flip ($)

split :: String -> [String]
split [] = [""]
split (character : characters)
    | character == ' ' = "" : rest
    | otherwise = (character : head rest) : tail rest
    where rest = split characters

uppercase :: String -> String
uppercase string =
    map toUpper string

lowercase :: String -> String
lowercase string =
    map toLower string

capitalize :: String -> String
capitalize string =
    uppercase firstCharacter ++ lowercase remainingCharacters
    where
        firstCharacter :: String
        firstCharacter = take 1 string

        remainingCharacters :: String
        remainingCharacters = drop 1 string

join :: [String] -> String
join strings =
    foldl (++) "" strings

camelcase :: String -> String
camelcase string =
    string
        |> split
        |> map capitalize
        |> join

main :: IO ()
main = do
    print $ camelcase "hello case"      -- HelloCase
    print $ camelcase "camel case word" -- CamelCaseWord

Source-Code

Available on repl.it.

gholden • Oct 18 '19

  const camelcase = (stringToConvert) => {
    const stringArray = stringToConvert.trim().split(" ")
    const camel =  stringArray.map(indie => {
      return indie[0].toUpperCase() + indie.slice(1)
    })
    return camel.join('');
  }

Rafael Acioly • Oct 18 '19

def to_camel_case(value: str) -> str:
    content = value.split(' ')
    return content[0] + ''.join(
        word.title()
        for word in content[1:] 
        if not word.isspace()
    )

This test was easy because i've written a python package that convert snake_case to camelCase and vice-versa :)

github.com/rafa-acioly/animal_case

Craig McIlwrath • Oct 18 '19

Haskell:

import Data.Char (toUpper, toLower)

camelCase :: String -> String
camelCase = unwords . map toCamel . words
            where toCamel (x:xs) = toUpper x ++ map toLower xs

Anders • Oct 19 '19

function CamelCase(s) {

    var uppercase = true;
    var rv = '';

    for (var i = 0; i < s.length; ++i) {

        var c = s[i];
        if (c == ' ') { uppercase = true; continue; }

        if (uppercase) {

            rv += c.toUpperCase();
            uppercase = false;

        } else {

            rv += c;
        }
    }

    return rv;
}

And benchmarked:

(Chrome 77, Win 10, 100K runs):

86 ms for LaBlatte
79 ms for SavagePixie
56 ms for Asfo
55 ms for BlessedTMahuni
54 ms for HVHarish
30 ms for Anders

(Firefox 69, Win 10, 100K runs):

116 ms for LaBlatte
55 ms for HVHarish
53 ms for Asfo
51 ms for BlessedTMahuni
29 ms for SavagePixie
23 ms for Anders

(Edge, Win 10, 100K runs):

208 ms for LaBlatte
127 ms for HVHarish
91 ms for Asfo
77 ms for BlessedTMahuni
46 ms for SavagePixie
27 ms for Anders

Ed Reeseg • Oct 21 '19

C

Still very much learning - had to iterate an initial time to decide how large my result array should be once spaces are removed. Not sure if there's a better way. Still, this was fun - decided to iterate through the argument string in two different ways, to practice.

#include <stdio.h>
#include <ctype.h>

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./camelCase \"argument\"\n");
        return 1;
    }
    char *c = argv[1];
    int len = 0;
    for (int i = 0; c[i] != '\0'; i++)
    {
        if (c[i] != ' ')
        {
            len++;
        }
    }
    char result[len + 1];
    int wordStart = 0, counter = 0;
    while(*c != '\0')
    {
        if (*c == ' ')
        {
            wordStart = 1;
        }
        else if (wordStart)
        {
            wordStart = 0;
            result[counter++] = toupper(*c);
        }
        else
        {
            wordStart = 0;
            result[counter++] = tolower(*c);
        }
        c++;
    }
    result[counter] = '\0';
    printf("%s\n", result);
    return 0;
}

willsmart • Oct 21 '19

I agree with SavagePixie. replace is the way to go if you're in JS!

Here's an extended version that covers all the cases I can think of...

const toUpperCamelCase = str => str.replace(
  /[^a-zA-Z]*([a-zA-Z]?)([a-z]+|[A-Z]*)/g,
  (_, firstLetter, rest) => firstLetter.toUpperCase() + rest.toLowerCase()
);

> [
  'Fudge And Sprite', // Words
  'fudge and sprite', // words
  'fudge-and-sprite', // kebab-case
  'fudge_and_sprite', // underscore_case
  'fudgeAndSprite',   // lowerCamelCase
  'FudgeAndSprite',   // UpperCamelCase stays as it is
  'FUDGE_AND_SPRITE', // CONSTANT_CASE
  'fUDGEaNDsPRITE',   // um, uPSIDEDOWNcASE I guess
  '>>> Fudge,    (and SPRITE!)' // or whatevs
].map(toUpperCamelCase);
< ["FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite", "FudgeAndSprite"]

Regex:

test in Debuggex

kesprit • Oct 21 '19

My solution in Swift with an extension of String :

extension String {
    var camelCase: String {
        self.capitalized.filter {
            !$0.isWhitespace
        }
    }
}

Jacob Evans • Oct 19 '19

Isn't this camelCase and this is PascalCase?

Candy • Oct 18 '19

python

def camel_case(text):
    return "".join([x.capitalize() for x in text.split()])

Balaji K • Oct 19 '19 • Edited

Javascript:

const camelCase = (string) => 
      string.split(" ").map(str => 
        `${str.charAt(0).toUpperCase()}${str.slice(1).toLowerCase()}`
      ).join('');