Converting any string into camel case

Question

How can I convert a string into camel case using javascript regex   EquipmentClass name or  Equipment className or equipment class name or Equipment Class Name  should all become  equipmentClassName

User · Answer

you can use this solution    x000D   x000D  String prototype toCamelCase   function    x000D    return this replace   s  w  ig  function all  letter  return letter toUpperCase      x000D                replace     w    function  1  return  1 toLowerCase      x000D     x000D   x000D  console log  Equipment className  toCamelCase     x000D   x000D   x000D

User · Answer

Looking at your code   you can achieve it with only two replace calls   function camelize str      return str replace       w  A-Z   b w  g  function word  index        return index     0   word toLowerCase     word toUpperCase         replace   s  g          camelize  EquipmentClass name    camelize  Equipment className    camelize  equipment class name    camelize  Equipment Class Name       all output  equipmentClassName    Edit  Or in with a single replace call  capturing the white spaces also in the RegExp   function camelize str      return str replace       w  A-Z   b w  s   g  function match  index        if   match     0  return        or if    s   test match   for white spaces     return index     0   match toLowerCase     match toUpperCase

User · Answer

This builds on the answer by CMS by removing any non-alphabetic characters including underscores  which  w does not remove    function toLowerCamelCase str        return str replace    A-Za-z0-9  g       replace    w  A-Z   b w  s  g  function  match  index            if   match     0    match      -     match                         return        or if    s   test match   for white spaces                   return index     0   match toLowerCase     match toUpperCase               toLowerCamelCase  EquipmentClass name    toLowerCamelCase  Equipment className    toLowerCamelCase  equipment class name    toLowerCamelCase  Equipment Class Name    toLowerCamelCase  Equipment-Class-Name    toLowerCamelCase  Equipment Class Name    toLowerCamelCase  Equipment Class Name    toLowerCamelCase  Equipment Class Name       All output e

User · Answer

lodash can do the trick sure and well   var     require  lodash    var result     camelCase  toto-ce h  ros       result now contains  totoCeHeros    Although lodash may be a  big  library   4kB   it contains a lot of functions that you d normally use a snippet for  or build yourself

User · Answer

The top answer is terse but it doesn t handle all edge cases  For anyone needing a more robust utility  without any external dependencies  function camelCase str        return  str slice 0  1  toLowerCase     str slice 1          replace    -     1   g              split   -             reduce  cur  acc    gt            return cur   acc 0  toUpperCase     acc substring 1                function sepCase str  sep    -         return str        replace   A-Z  g   letter  index    gt            const lcLet   letter toLowerCase            return index   sep   lcLet   lcLet                  replace    -     1   g  sep        All will return  fooBarBaz  console log camelCase  foo bar baz    console log camelCase  foo-bar-baz    console log camelCase  foo bar--baz    console log camelCase  FooBar  Baz    console log camelCase  FooBarBaz    console log camelCase  fooBarBaz        All will return  foo-bar-baz  console log sepCase  fooBarBaz     console log sepCase  FooBarBaz     console log sepCase  foo-bar-baz     console log sepCase  foo bar baz     console log sepCase  foo    bar -baz     console log sepCase  foo-bar-baz         All will return  foo  bar  baz  console log sepCase  fooBarBaz           console log sepCase  foo-bar-baz            Demo here  https   codesandbox io embed admiring-field-dnm4r fontsize 14 amp hidenavigation 1 amp theme dark

User · Answer

This method seems to outperform most answers on here  it s a little bit hacky though  no replaces  no regex  simply building up a new string that s camelCase   String prototype camelCase   function        var newString           var lastEditedIndex      for  var i   0  i  lt  this length  i             if this i            this i      -     this i                       newString    this i 1  toUpperCase                lastEditedIndex   i 1                    else if lastEditedIndex     i  newString    this i  toLowerCase              return newString

User · Answer

Because this question needed yet another answer     I tried several of the previous solutions  and all of them had one flaw or another   Some didn t remove punctuation  some didn t handle cases with numbers  some didn t handle multiple punctuations in a row   None of them handled a string like a1 2b   There s no explicitly defined convention for this case  but some other stackoverflow questions suggested separating the numbers with an underscore   I doubt this is the most performant answer  three regex passes through the string  rather than one or two   but it passes all the tests I can think of   To be honest  though  I really can t imagine a case where you re doing so many camel-case conversions that performance would matter    I added this as an npm package   It also includes an optional boolean parameter to return Pascal Case instead of Camel Case    const underscoreRegex          w s      g      sandwichNumberRegex      d  s     d  g      camelCaseRegex         s  w  b w  W   g   String prototype toCamelCase   function         if     s    s     g test this             return                 return this replace underscoreRegex                replace sandwichNumberRegex    1             replace camelCaseRegex  function match  index                if     W    test match                     return                                return index    0   match trimLeft   toLowerCase     match toUpperCase                    Test cases  Jest   test  Basic strings        gt        expect    toCamelCase    toBe          expect  A B C  toCamelCase    toBe  aBC        expect  aB c  toCamelCase    toBe  aBC        expect  abc      def  toCamelCase    toBe  abcDef        expect  abc      def  toCamelCase    toBe  abcDef        expect  abc     d  e    fg  toCamelCase    toBe  abcDEFg         test  Basic strings with punctuation        gt        expect  a b--d -- f h  toCamelCase    toBe  aBDFH        expect     a   def  toCamelCase    toBe  aDef         test  Strings with numbers        gt        expect  12 3 4 5  toCamelCase    toBe  12 3 4 5        expect  12 3 abc  toCamelCase    toBe  12 3Abc        expect  ab2c  toCamelCase    toBe  ab2c        expect  1abc  toCamelCase    toBe  1abc        expect  1Abc  toCamelCase    toBe  1Abc        expect  abc 2def  toCamelCase    toBe  abc2def        expect  abc-2def  toCamelCase    toBe  abc2def        expect  abc 2def  toCamelCase    toBe  abc2def        expect  abc1 2def  toCamelCase    toBe  abc1 2def        expect  abc1 2def  toCamelCase    toBe  abc1 2def        expect  abc1 2   3def  toCamelCase    toBe  abc1 2 3def         test  Oddball cases        gt        expect     toCamelCase    toBe           expect      toCamelCase    toBe           expect       toCamelCase    toBe           expect   t    n  toCamelCase    toBe           expect   a   toCamelCase    toBe  a        expect      toCamelCase    toBe          expect   tab tcd  toCamelCase    toBe  abCd        expect   ab tcd r  -     ef  toCamelCase    toBe  abCdEf

User · Answer

function convertStringToCamelCase str       return str split      map function item  index           return index     0                item charAt 0  toUpperCase     item substr 1                 item charAt 0  toLowerCase     item substr 1          join

User · Answer

I ended up crafting a slightly more aggressive solution   function toCamelCase str      const  first     acc    str replace     w d  g       split   s       return first toLowerCase     acc map x   gt  x charAt 0  toUpperCase          x slice 1  toLowerCase    join          This one  above  will remove all non-alphanumeric characters and lowercase parts of words that would otherwise remain uppercased  e g    Size  comparative     sizeComparative GDP  official exchange rate     gdpOfficialExchangeRate hello    hello

User · Answer

following  Scott s readable approach  a little bit of fine tuning    convert any string to camelCase var toCamelCase   function str      return str toLowerCase        replace      quot   g            replace    W  g             replace        g  function  1    return  1 toUpperCase            replace     g

User · Answer

Here s my suggestion   function toCamelCase string      return    string        replace new RegExp   -       g              replace new RegExp     w s     g             replace        new RegExp   s      w      g            1   2   3    gt      2 toUpperCase      3 toLowerCase                replace new RegExp   s    g             replace new RegExp   w    s   gt  s toLowerCase         or  String prototype toCamelCase   function       return this      replace new RegExp   -       g              replace new RegExp     w s     g             replace        new RegExp   s      w      g            1   2   3    gt      2 toUpperCase      3 toLowerCase                replace new RegExp   s    g             replace new RegExp   w    s   gt  s toLowerCase          Test cases   describe  String to camel case   function       it  should return a camel cased string   function         chai assert equal toCamelCase  foo bar     fooBar        chai assert equal toCamelCase  Foo Bar     fooBar        chai assert equal toCamelCase  fooBar     fooBar        chai assert equal toCamelCase  FooBar     fooBar        chai assert equal toCamelCase  --foo-bar--     fooBar        chai assert equal toCamelCase    FOO BAR       fooBar        chai assert equal toCamelCase   --foo-   -bar--121-        fooBar121

User · Answer

EDIT  Now working in IE8 without changes    EDIT  I was in the minority about what camelCase actually is  Leading character lowercase vs  uppercase    The community at large believes a leading lowercase is camel case and a leading capital is pascal case   I have created two functions that use regex patterns only      So we use a unified vocabulary I have changed my stance to match the majority      All I believe you need is a single regex in either case    var camel     THIS is camel case   camel     trim camel       replace    A-Za-z  g         clean up non-letter characters         replace      g  function a  l    return l toLowerCase            replace    s   g  function a  l    return l toUpperCase            replace    A-Za-z u00C0- u00ff  g         Returns  thisIsCamelCase    or  var pascal     this IS pascal case   pascal     trim pascal     replace    A-Za-z  g         clean up non-letter characters       replace      g  function a  l    return l toLowerCase          replace       s   g  function a  l    return l toUpperCase          replace    A-Za-z u00C0- u00ff  g         Returns  ThisIsPascalCase    In functions  You will notice that in these functions the replace is swapping any non a-z with a space vs an empty string  This is to create word boundaries for capitalization   hello-MY world  -   HelloMyWorld       remove  u00C0- u00ff  if you do not want the extended letters like    function toCamelCase str        var retVal            retVal     trim str         replace    A-Za-z  g          clean up non-letter characters           replace      g  function  a  l    return l toLowerCase              replace    s   g  function  a  l    return l toUpperCase              replace    A-Za-z u00C0- u00ff  g            return retVal    function toPascalCase str        var retVal            retVal     trim str         replace    A-Za-z  g          clean up non-letter characters           replace      g  function  a  l    return l toLowerCase              replace       s   g  function  a  l    return l toUpperCase              replace    A-Za-z u00C0- u00ff  g            return retVal     Notes    I left A-Za-z vs adding the case insensitivity flag  i  to the pattern      A-Z  ig  for readability    This works in IE8  srsly  who uses IE8 anymore   Using the  F12  dev tools I have tested in IE11  IE10  IE9  IE8  IE7 and IE5   Works in all document modes    This will correctly case the first letter of strings starting with or without whitespace      Enjoy

User · Answer

If regexp isn t required  you might want to look at following code I made a long time ago for Twinkle   String prototype toUpperCaseFirstChar   function         return this substr  0  1   toUpperCase     this substr  1       String prototype toLowerCaseFirstChar   function         return this substr  0  1   toLowerCase     this substr  1       String prototype toUpperCaseEachWord   function  delim         delim   delim   delim            return this split  delim   map  function v    return v toUpperCaseFirstChar       join  delim       String prototype toLowerCaseEachWord   function  delim         delim   delim   delim            return this split  delim   map  function v    return v toLowerCaseFirstChar       join  delim        I haven t made any performance tests  and regexp versions might or might not be faster

User · Answer

If anyone is using lodash  there is a   camelCase   function     camelCase  Foo Bar          fooBar     camelCase  --foo-bar--          fooBar     camelCase    FOO BAR            fooBar

User · Answer

Upper camel case   TestString   to lower camel case   testString   without using regex  let s face it  regex is evil     TestString  split     reduce  t  v  k    gt  t    k     0   v toLowerCase     v

User · Answer

return  hello world  toLowerCase   replace            s     g  function match        return match charAt match length-1  toUpperCase           HelloWorld

User · Answer

function toCamelCase str         Lower cases the string   return str toLowerCase          Replaces any - or   characters with a space       replace    -    g              Removes any non alphanumeric characters       replace      w s  g             Uppercases the first character in each group immediately following a space          delimited by spaces        replace        g  function  1    return  1 toUpperCase              Removes spaces       replace     g            I was trying to find a JavaScript function to camelCase a string  and wanted to make sure special characters would be removed  and I had trouble understanding what some of the answers above were doing   This is based on c c young s answer  with added comments and the removal of  peci amp l characters

User · Answer

In Scott   s specific case I   d go with something like   String prototype toCamelCase   function         return this replace     A-Z    s  w  g  function match  p1  p2  offset            if  p2  return p2 toUpperCase            return p1 toLowerCase                         EquipmentClass name  toCamelCase       - gt  equipmentClassName  Equipment className  toCamelCase       - gt  equipmentClassName  equipment class name  toCamelCase      - gt  equipmentClassName  Equipment Class Name  toCamelCase      - gt  equipmentClassName   The regex will match the first character if it starts with a capital letter  and any alphabetic character following a space  i e  2 or 3 times in the specified strings   By spicing up the regex to     A-Z     s-    w  g it will also camelize hyphen and underscore type names    hyphen-name-format  toCamelCase          - gt  hyphenNameFormat  underscore name format  toCamelCase      - gt  underscoreNameFormat

User · Answer

I just ended up doing this   String prototype toCamelCase   function str        return str          replace   s    g  function  1    return  1 toUpperCase                replace   s g               replace         function  1    return  1 toLowerCase            I was trying to avoid chaining together multiple replace statements   Something where I d have  1   2   3 in my function   But that type of grouping is hard to understand  and your mention about cross browser problems is something I never thought about as well

User · Answer

I think this should work    function cammelCase str       let arr   str split           let words   arr filter v  gt v           words forEach  w  i   gt           words i    w replace   w S  g  function txt               return txt charAt 0  toUpperCase     txt substr 1                           return words join

User · Answer

My ES6 approach   const camelCase   str   gt      let string   str toLowerCase   replace    A-Za-z0-9  g       split                         reduce  result  word    gt  result   capitalize word toLowerCase       return string charAt 0  toLowerCase     string slice 1     const capitalize   str   gt  str charAt 0  toUpperCase     str toLowerCase   slice 1   let baz    foo bar  let camel   camelCase baz  console log camel       fooBar  camelCase  foo bar        fooBar  camelCase  FOO BAR        fooBar  camelCase  x nN foo bar        xNnFooBar  camelCase   --foo-   -bar--121-           fooBar121

User · Answer

I know this is an old answer  but this handles both whitespace and    lodash   function toCamelCase s       return s            replace    g                  replace   s    g  function  1    return  1 toUpperCase                  replace   s g                 replace         function  1    return  1 toLowerCase           console log toCamelCase  Hello world    console log toCamelCase  Hello world        Both print  helloWorld

User · Answer

There is my solution    x000D   x000D  const toCamelWord    word  idx    gt  x000D    idx     0   x000D    word toLowerCase     x000D    word charAt 0  toUpperCase     word slice 1  toLowerCase    x000D   x000D  const toCamelCase   text   gt  x000D    text x000D     split    - s     x000D     map toCamelWord  x000D     join      x000D   x000D  console log toCamelCase  User ID    x000D   x000D   x000D

User · Answer

A super easy way  using the turboCommons library   npm install turbocommons-es5   lt script src  turbocommons-es5 turbocommons-es5 js  gt  lt  script gt    lt script gt      var StringUtils   org turbocommons StringUtils      console log StringUtils formatCase  EquipmentClass   StringUtils FORMAT LOWER CAMEL CASE        console log StringUtils formatCase  Equipment className   StringUtils FORMAT LOWER CAMEL CASE        console log StringUtils formatCase  equipment class name   StringUtils FORMAT LOWER CAMEL CASE        console log StringUtils formatCase  Equipment Class Name   StringUtils FORMAT LOWER CAMEL CASE     lt  script gt    You can also use StringUtils FORMAT CAMEL CASE and StringUtils FORMAT UPPER CAMEL CASE to generate first letter case variations   More info here   Convert string to CamelCase  UpperCamelCase or lowerCamelCase

User · Answer

You can use this solution     function toCamelCase str     return str split      map function word index          If it is the first word make sure to lowercase all the chars      if index    0         return word toLowerCase                 If it is not the first word only upper case the first char and lowercase the rest      return word charAt 0  toUpperCase     word slice 1  toLowerCase         join

User · Answer

Reliable  working example that I ve been using for years   function camelize text        text   text replace   -  s        g      c    gt  c   c toUpperCase              return text substr 0  1  toLowerCase     text substr 1       Case-changing characters    hyphen - underscore   period   space

User · Answer

This function by pass cammelcase such these tests  Foo      Bar --foo-bar--   FOO BAR  - foo123Bar foo Bar   x000D   x000D  function toCamelCase str      var arr  str match   a-z    d  gi     return arr map  m i   gt       let low   m toLowerCase        if  i  0         low   low split     map  s k   gt k  0 s toUpperCase   s  join             return low       join      console log toCamelCase  Foo      Bar     console log toCamelCase  --foo-bar--     console log toCamelCase    FOO BAR  -     console log toCamelCase  foo123Bar     console log toCamelCase  foo Bar      console log toCamelCase  EquipmentClass name     console log toCamelCase  Equipment className     console log toCamelCase  equipment class name     console log toCamelCase  Equipment Class Name     x000D   x000D   x000D

User · Answer

To get camelCase   ES5  var camalize   function camalize str        return str toLowerCase   replace    a-zA-Z0-9      g  function match  chr                return chr toUpperCase                ES6  var camalize   function camalize str        return str toLowerCase   replace    a-zA-Z0-9      g   m  chr    gt  chr toUpperCase              To get CamelSentenceCase or PascalCase   var camelSentence   function camelSentence str        return         str  toLowerCase   replace    a-zA-Z0-9      g  function match  chr                return chr toUpperCase                Note    For those language with accents  Do include   -    -    -   with the regex as following   replace    a-zA-Z  -    -    -  0-9      g

User · Answer

All 14 permutations below produce the same result of  equipmentClassName     x000D   x000D  String prototype toCamelCase   function     x000D    return this replace    a-z   ig          Replace everything but letters and spaces  x000D       replace       w  A-Z   b w  s   g     Find non-words  uppercase letters  leading-word letters  and multiple spaces  x000D        function match  index    x000D          return  match     0        match index     0    toLowerCase     toUpperCase      x000D            x000D    x000D   x000D  String toCamelCase   function str    x000D    return str toCamelCase    x000D    x000D   x000D  var testCases     x000D     equipment class name   x000D     equipment class Name   x000D     equipment Class name   x000D     equipment Class Name   x000D     Equipment class name   x000D     Equipment class Name   x000D     Equipment Class name   x000D     Equipment Class Name   x000D     equipment className   x000D     equipment ClassName   x000D     Equipment ClassName   x000D     equipmentClass name   x000D     equipmentClass Name   x000D     EquipmentClass Name  x000D     x000D   x000D  for  var i   0  i  lt  testCases length  i      x000D    console log testCases i  toCamelCase     x000D     x000D   x000D   x000D

User · Answer

Don t use String prototype toCamelCase   because String prototypes are read-only  most of the js compilers will give you this warning   Like me  those who know that the string will always contains only one space can use a simpler approach   let name    test string    let pieces   name split        pieces   pieces map  word  index    gt  word charAt 0  index   0    toLowerCase    toUpperCase       word toLowerCase   slice 1     return pieces join        Have a good day

User · Answer

const toCamelCase   str   gt    str      replace    a-zA-Z0-9      g   m  chr    gt  chr toUpperCase         replace    w   c   gt  c toLowerCase

User · Answer

Here is a one liner doing the work   const camelCaseIt   string   gt  string toLowerCase   trim   split     -  s  g  reduce  string  word    gt  string   word 0  toUpperCase     word slice 1      It splits the lower-cased string based on the list of characters provided in the RegExp    -  s   add more inside the      and returns a word array   Then  it reduces the array of strings to one concatenated string of words with uppercased first letters  Because the reduce has no initial value  it will start uppercasing first letters starting with the second word    If you want PascalCase  just add an initial empty string      to the reduce method

User · Answer

little modified Scott s answer   toCamelCase    string  - gt    string      replace    s   -     g    1  - gt   1 toUpperCase        replace    s   -  g          replace           1  - gt   1 toLowerCase     now it replaces  -  and     too

User · Answer

Basic approach would be to split the string with a regex matching upper-case or spaces  Then you d glue the pieces back together  Trick will be dealing with the various ways regex splits are broken weird across browsers  There s a library or something that somebody wrote to fix those problems  I ll look for it   here s the link  http   blog stevenlevithan com archives cross-browser-split

[javascript] Converting any string into camel case

Examples related to javascript

Examples related to regex

Examples related to camelcasing