Convert dash-separated string to camelCase?

Question

For example suppose I always have a string that is delimited by "-". Is there a way to transform

it-is-a-great-day-today

to

itIsAGreatDayToday

Using RegEx?

Answer 1

Yes (edited to support non-lowercase input and Unicode):

function camelCase(input) { 
    return input.toLowerCase().replace(/-(.)/g, function(match, group1) {
        return group1.toUpperCase();
    });
}

See more about "replace callbacks" on MDN's "Specifying a function as a parameter" documentation.

The first argument to the callback function is the full match, and subsequent arguments are the parenthesized groups in the regex (in this case, the character after the the hyphen).

Answer 2

Another method using reduce:

function camelCase(str) {
  return str
    .split('-')
    .reduce((a, b) => a + b.charAt(0).toUpperCase() + b.slice(1));
}

Answer 3

You can match on the word character after each dash (-) or the start of the string, or you could simplify by matching the word character after each word boundary (\b):

function camelCase(s) {
  return (s||'').toLowerCase().replace(/(\b|-)\w/g, function(m) {
    return m.toUpperCase().replace(/-/,'');
  });
}
camelCase('foo-bar'); // => 'FooBar'
camelCase('FOo-BaR-gAH'); // => 'FooBarGah'

Answer 4

Here's a demo

var test = 'It-is-a-great-day-today';

function camelize(str) {
    return str[0].toLowerCase() + str.replace(/-([a-z])/g, function(a, b) {
        return b.toUpperCase();
    }).slice(1);
}

console.log(camelize(test));

Answer 5

This should also work:

function camelCase(str) {
  return str.replace(/^.|-./g, function(letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.substr(1).toUpperCase();
  });
}

And IMHO it is little bit more efficient since we're not converting whole input string to lowercase first and then convert to uppercase if needed. This function only converts first letter to lowercase and then every character after hyphen - to uppercase.

Answer 6

See http://jsfiddle.net/54ZcM/

function camelCase(string) {
    return string.toLowerCase().replace(/(\-[a-zA-Z])/g, function($1) {
        return $1.toUpperCase().replace('-','');
    })
}

alert(camelCase('fOo-BarBA-fo'));

Answer 7

I know this question is a bit old but,

Here's my version of camelCase function:

var camelCase = (function () {
    var DEFAULT_REGEX = /[-_]+(.)?/g;

    function toUpper(match, group1) {
        return group1 ? group1.toUpperCase() : '';
    }
    return function (str, delimiters) {
        return str.replace(delimiters ? new RegExp('[' + delimiters + ']+(.)?', 'g') : DEFAULT_REGEX, toUpper);
    };
})();

It handles all of the following edge cases:

• takes care of both underscores and hyphens by default (configurable with second parameter)
• string with unicode characters
• string that ends with hyphens or underscore
• string that has consecutive hyphens or underscores

Here's a link to live tests: http://jsfiddle.net/avKzf/2/

Here are results from tests:

• input: "ab-cd-ef", result: "abCdEf"
• input: "ab-cd-ef-", result: "abCdEf"
• input: "ab-cd-ef--", result: "abCdEf"
• input: "ab-cd--ef--", result: "abCdEf"
• input: "--ab-cd--ef--", result: "AbCdEf"
• input: "--ab-cd-__-ef--", result: "AbCdEf"

Notice that strings that start with delimiters will result in a uppercase letter at the beginning. If that is not what you would expect, you can always use lcfirst. Here's my lcfirst if you need it:

function lcfirst(str) {
    return str && str.charAt(0).toLowerCase() + str.substring(1);
}

Answer 8

This works great but someone might be able to clean it up.

var toCamelCase = function(str) {
        // Replace special characters with a space
        str = str.replace(/[^a-zA-Z0-9 ]/g, " ");
        // put a space before an uppercase letter
        str = str.replace(/([a-z](?=[A-Z]))/g, '$1 ');
        // Lower case first character and some other stuff that I don't understand
        str = str.replace(/([^a-zA-Z0-9 ])|^[0-9]+/g, '').trim().toLowerCase();
        // uppercase characters preceded by a space or number
        str = str.replace(/([ 0-9]+)([a-zA-Z])/g, function(a,b,c) {
            return b.trim() + c.toUpperCase();
        });
        return str;
};

console.log(toCamelCase('hyphen~name~ format'));
console.log(toCamelCase('hyphen.name.format'));
console.log(toCamelCase('hyphen-name-format'));
console.log(toCamelCase('Hyphen-Dame-Gormat'));
console.log(toCamelCase('EquipmentClass name'));
console.log(toCamelCase('Equipment className'));
console.log(toCamelCase('equipment class name'));
console.log(toCamelCase(' e    Equipment Class Name'));
console.log(toCamelCase('under9score_name_format'));
console.log(toCamelCase('Enderscore_name_format'));
console.log(toCamelCase('EnderscoreBameFormat'));
console.log(toCamelCase('_EnderscoreBameFormat'));

http://jsbin.com/yageqi/1/edit?js,console

Answer 9

'it-is-a-great-day-today'.split('-').map(function(x,i){
    return (i?x[0].toUpperCase():x[0]) + x.slice(1).toLowerCase()
}).join('')

Result:

'itIsAGreatDayToday'

Alternatively, .match(/\w+/g) rather than .split('-') -- depending on what you want to do in edge cases like "this--is-a-test".

Answer 10

var string = "it-is-a-great-day-today";
or
var string = "it_is_a_great_day_today";

var regex = /(_|-)([a-z])/g;

string.toLowerCase().replace(regex, toCamelCase );

function toCamelCase( string ){
  return string[1].toUpperCase();
}

Output: "itIsAGreatDayToday";

Answer 11

here is the jsfiddle you can play with to test this http://jsfiddle.net/5n84w/2/

```

/**
 * Function to convert any string to camelCase
 * var regex = 'chetan-Ankola###.com---m13ok#-#alo(*finding!R%S#%-GFF'; 
 * Where [-_ .] is the seperator, you can add eg: '@' too
 * + is to handle repetition of seperator           
 * ? is to take care of preceeding token 
 * match nov(ember)? matches nov and november
 */
var camelCaser = function (str) {
    var camelCased = str.replace(/[-_ .]+(.)?/g, function (match, p) {
        if (p) {
            return p.toUpperCase();
        }
        return '';
    }).replace(/[^\w]/gi, '');
    return camelCased;
};

```

Answer 12

lodash.camelCase can be another option

Sample:

const str = 'it-is-a-great-day-today';
lodash.camelCase(str.split('-'));

result: itIsAGreatDayToday

Answer 13

Better do this guys,

function camelCase(data) {
    var tmp;
    if (data && typeof data === 'object') {
        forEach(data, function (value, key) {
            var tmpvalue = camelCase(key);
            tmp[tmpvalue] = value;
        });
        return tmp;
    } else {
        return data.toLowerCase().replace(/(\_\w)/g, function (m) { return m[1].toUpperCase() }).replace(/(\-\w)/g, function (m) { return m[1].toUpperCase(); });
    }
}

console.log(camelCase("SucCCCess_dfds_dsqsdqs-dsdqs-dqsdqs"));

Works perfectly in any cases.

Answer 14

$scope.toCamelCase = function(arg){
    var arg = arg.toLowerCase();
    var arr = arg.split("");
    arr[0] = arr[0].toUpperCase();
    return arr.join("");
};