Hedegare's Blog

Building - Learning - Optimizing - Growing

How to Convert a String to Camel Case

String manipulation is an important skill in programming, often used in data parsing, formatting, and preparing values for further processing. In this coding problem, the task is to convert a string containing words separated by dashes (kebab-case) or underscores (snake case) into camel case.

These naming conventions help keep code consistent and easier to read, making it more maintainable and future-proof. We’ll be using Javascript to solve this problem.

Before diving into the full problem statement, it’s helpful to understand these naming conventions and how they differ. Here’s a quick breakdown:

• snake_case - words separated by underscores (example_string)
• kebab-case - words separated by dashes (example-string)
• camelCase - first word either lower or capitalized, following words all capitalized (exampleString or ExampleString)

The problem

This challenge comes from Codewars.

Complete the method/function so that it converts dash/underscore-delimited words into camel casing. The first word within the output should be capitalized only if the original word was capitalized (known as Upper Camel Case, also often referred to as Pascal Case). The next words should be always capitalized.

This is the starting code:

1
function toCamelCase(str) {
2

3
}

Examples:

kebabs-taste-Very-Good gets converted to kebabsTasteVeryGood

snakes_are_reptiles gets converted to snakesAreReptiles

The_Last-Example gets converted to TheLastExample

The plan

1. Break the string into a list of words based on the delimited - and _;
2. Keep the first word unchanged;
3. Capitalize the remaining words;
4. Join everything together into a string.

The implementation

Start by using the split function to break the string into a list of words. The split function takes a separator parameter that defines where each split should occur.

Since there are two cases where a string can be separated (- and _), using a regular expression (regex) is a good choice to use as a separator. The regex /-|_/g finds all dashes and underscores in the string.

1
function toCamelCase(str) {
2
    var result = str.split(/-|_/g);
3
    return result;
4
}

Now that the words are separated and stored in an array, we can iterate through it and start capitalizing each word. But first, we need to make sure that the first word maintains its original form.

1
function toCamelCase(str) {
2
    var result = str.split(/-|_/g);
3
    result = result.map((word, index) => {
4
        if (index === 0) {
5
            return word;
6
        } else {
7
            return word.charAt(0).toUpperCase() + word.slice(1);
8
        }
9
    });
10
    return result;
11
}

We use the map iterative method to go through each word and capitalize it, but only if it’s not the first word in the list; this is done by checking the index value.

The final step is to join all the words back into a single string.

1
function toCamelCase(str) {
2
    var result = str.split(/-|_/g);
3
    result = result.map((word, index) => {
4
        if (index === 0) {
5
            return word;
6
        } else {
7
            return word.charAt(0).toUpperCase() + word.slice(1);
8
        }
9
    });
10
    result = result.join("");
11
    return result;
12
}

Running this code with the examples above will show that it successfully converts the strings into camelCase.

The problem is solved, but we can simplify the code further by rewriting the function as a concise one-liner, like this:

1
function toCamelCase(str) {
2
    return str.split(/-|_/)
3
        .map((word, index) => {
4
            return index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
5
        })
6
        .join("");
7
}

Instead of storing the result in a variable and changing it step by step, we directly return the transformed string by chaining methods together. The map callback uses a ternary operator instead of a if ... else statement.

These changes make the code more concise and easier to read without changing its result.

The recap

Let’s recap what we’ve done:

• Define the separator: we defined the regex where the string would be splitted;
• Split the string: we split the string into an array of words;
• Iterate each word: we went over each word by using the map method;
• Check and capitalize: we checked if it wasn’t the first word and capitalized its first letter;
• Join back the words: we used the join method to merge the array into a single string;
• Return the string: finally, we returned the string in a camel case form.

String manipulation is a classic coding exercise. This challenge is a great way to practice logic, string operations, and array transformations in a clean and practical way.

Additional Resources

Last updated on 2025-07-06