it-swarm.com.de

Konvertieren einer beliebigen Zeichenfolge in eine Kamelhülle

Wie kann ich einen String mit Hilfe von Javascript Regex in einen Kamelfall konvertieren?

EquipmentClass name oder Equipment className oder equipment class name oder Equipment Class Name

sollten alle werden: equipmentClassName.

112
Scott

Ich endete gerade damit:

String.prototype.toCamelCase = function(str) {
    return str
        .replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
        .replace(/\s/g, '')
        .replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}

Ich versuchte zu vermeiden, mehrere Ersetzungsanweisungen miteinander zu verketten. Etwas, wo ich $ 1, $ 2, $ 3 in meiner Funktion hätte. Aber diese Art von Gruppierung ist schwer zu verstehen, und Ihre Erwähnung über Cross-Browser-Probleme ist etwas, woran ich auch nie gedacht habe.

41
Scott

Wenn Sie Ihren Code betrachten, können Sie ihn mit nur zwei replace-Aufrufen erreichen:

function camelize(str) {
  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(letter, index) {
    return index == 0 ? letter.toLowerCase() : letter.toUpperCase();
  }).replace(/\s+/g, '');
}

camelize("EquipmentClass name");
camelize("Equipment className");
camelize("equipment class name");
camelize("Equipment Class Name");
// all output "equipmentClassName"

Edit: Oder mit einem einzigen Aufruf von replace, der auch die Leerzeichen in RegExp erfasst.

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();
  });
}
178
CMS

Wenn jemand lodash verwendet, gibt es eine _.camelCase() - Funktion.

_.camelCase('Foo Bar');
// → 'fooBar'

_.camelCase('--foo-bar--');
// → 'fooBar'

_.camelCase('__FOO_BAR__');
// → 'fooBar'
49
d4nyll

Sie können diese Lösung verwenden: 

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('');
}
34
ismnoiet

Im speziellen Fall von Scott würde ich mit so etwas wie gehen:

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()  // -> equipmentClassName
'Equipment className'.toCamelCase()  // -> equipmentClassName
'equipment class name'.toCamelCase() // -> equipmentClassName
'Equipment Class Name'.toCamelCase() // -> equipmentClassName

Der reguläre Ausdruck stimmt mit dem ersten Zeichen überein, wenn er mit einem Großbuchstaben und einem beliebigen alphabetischen Zeichen beginnt, das einem Leerzeichen folgt, d. H. Zwei- oder dreimal in den angegebenen Zeichenfolgen.

Wenn Sie den Regex auf /^([A-Z])|[\s-_](\w)/g aufpeppen, werden auch die Namen von Bindestrich und Unterstrich typisiert.

'hyphen-name-format'.toCamelCase()     // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat
24
Fredric
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, '' );
}

Ich habe versucht, eine JavaScript-Funktion für camelCase einer Zeichenfolge zu finden, und wollte sicherstellen, dass Sonderzeichen entfernt werden (und ich hatte Schwierigkeiten, zu verstehen, was einige der obigen Antworten tun). Dies basiert auf der Antwort von c Young, mit zusätzlichen Kommentaren und dem Entfernen von $ peci & l-Zeichen. 

20
Eilidh

Mein ES6 Ansatz:

const camelCase = str => {
  let string = str.toLowerCase().replace(/[^A-Za-z0-9]/g, ' ').split(' ')
                  .reduce((result, Word) => result + capitalize(Word.toLowerCase()))
  return string.charAt(0).toLowerCase() + string.slice(1)
}

const capitalize = str => 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"
7
eledgaar

Wenn regexp nicht erforderlich ist, möchten Sie möglicherweise den folgenden Code anzeigen, den ich vor langer Zeit für Twinkle erstellt habe:

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 );
}

Ich habe keine Leistungstests durchgeführt, und Regex-Versionen sind möglicherweise nicht schneller.

6
azatoth

Hier ist ein One Liner, der die Arbeit erledigt:

const camelCaseIt = string => string.toLowerCase().trim().split(/[.\-_\s]/g).reduce((string, Word) => string + Word[0].toUpperCase() + Word.slice(1));

Es teilt die Zeichenfolge in Kleinbuchstaben basierend auf der Liste der Zeichen auf, die in RegExp [.\-_\s] angegeben sind (fügen Sie weitere Zeichen innerhalb von []!) Hinzu und gibt ein Word-Array zurück. Dann wird das Array von Zeichenfolgen auf eine verkettete Wortfolge mit großgeschriebenen Anfangsbuchstaben reduziert. Da die Verkleinerung keinen Anfangswert hat, werden die ersten Buchstaben beginnend mit dem zweiten Wort groß geschrieben. 

Wenn Sie PascalCase verwenden möchten, fügen Sie der reduzierten Methode einfach eine anfängliche leere Zeichenfolge ,'') hinzu.

4
Martin Szyska
return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
    return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld
4
Judzhin Miles

lodash kann den Trick sicher und gut machen:

var _ = require('lodash');
var result = _.camelCase('toto-ce héros') 
// result now contains "totoCeHeros"

Obwohl lodash eine "große" Bibliothek (~ 4kB) sein kann, enthält sie viele Funktionen, für die Sie normalerweise ein Snippet verwenden oder sich selbst bauen.

4
Alain Beauvois

c amelCase erhalten

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) => chr.toUpperCase());
}


C amelSentenceCase oderP ascalCase

var camelSentence = function camelSentence(str) {
    return  (" " + str).toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
    {
        return chr.toUpperCase();
    });
}
4
smilyface

Alle 14 folgenden Permutationen erzeugen dasselbe Ergebnis wie "equipmentClassName".

String.prototype.toCamelCase = function() {
  return this.replace(/[^a-z ]/ig, '')  // Replace everything but letters and spaces.
    .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, // Find non-words, uppercase letters, leading-Word letters, and multiple spaces.
      function(match, index) {
        return +match === 0 ? "" : match[index === 0 ? 'toLowerCase' : 'toUpperCase']();
      });
}

String.toCamelCase = function(str) {
  return str.toCamelCase();
}

var testCases = [
  "equipment class name",
  "equipment class Name",
  "equipment Class name",
  "equipment Class Name",
  "Equipment class name",
  "Equipment class Name",
  "Equipment Class name",
  "Equipment Class Name",
  "equipment className",
  "equipment ClassName",
  "Equipment ClassName",
  "equipmentClass name",
  "equipmentClass Name",
  "EquipmentClass Name"
];

for (var i = 0; i < testCases.length; i++) {
  console.log(testCases[i].toCamelCase());
};

3
Mr. Polywhirl

sie können diese Lösung verwenden:

String.prototype.toCamelCase = function(){
  return this.replace(/\s(\w)/ig, function(all, letter){return letter.toUpperCase();})
             .replace(/(^\w)/, function($1){return $1.toLowerCase()});
};

console.log('Equipment className'.toCamelCase());

3
Chang Hoon Lee

nach @ Scotts lesbarem Ansatz, ein bisschen Feinabstimmung

 // Konvertieren einer beliebigen Zeichenfolge in camelCase 
 var inCamelCase = function (str) {
 return str.toLowerCase () 
 .replace (/ ['"]/g,' ') 
 .replace (/\W +/g,' ') 
 .replace (/ (.)/g, Funktion ($ 1) {gibt $ 1 zurück. toUpperCase ();}) 
 .replace (//g, ''); 
} 
3
cc young

wenig modifizierte Antwort von Scott:

toCamelCase = (string) ->
  string
    .replace /[\s|_|-](.)/g, ($1) -> $1.toUpperCase()
    .replace /[\s|_|-]/g, ''
    .replace /^(.)/, ($1) -> $1.toLowerCase()

jetzt ersetzt es auch '-' und '_'.

2
sunstory

Es gibt meine Lösung:

const toCamelWord = (Word, idx) =>
  idx === 0 ?
  Word.toLowerCase() :
  Word.charAt(0).toUpperCase() + Word.slice(1).toLowerCase();

const toCamelCase = text =>
  text
  .split(/[_-\s]+/)
  .map(toCamelWord)
  .join("");

console.log(toCamelCase('User ID'))

2

Dies baut auf der Antwort von CMS auf, indem nicht-alphabetische Zeichen einschließlich Unterstriche - entfernt werden, die \w nicht entfernt. 

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
1
wheeler

Am Ende entwickelte ich eine etwas aggressivere Lösung:

function toCamelCase(str) {
  const [first, ...acc] = str.replace(/[^\w\d]/g, ' ').split(/\s+/);
  return first.toLowerCase() + acc.map(x => x.charAt(0).toUpperCase() 
    + x.slice(1).toLowerCase()).join('');
}

Mit diesem Befehl werden alle nicht-alphanumerischen Zeichen und Kleinbuchstaben von Wörtern entfernt, die sonst großgeschrieben wären, z.

  • Size (comparative) => sizeComparative
  • GDP (official exchange rate) => gdpOfficialExchangeRate
  • hello => hello
1
bjornl

Hier ist mein Vorschlag:

function toCamelCase(string) {
  return `${string}`
    .replace(new RegExp(/[-_]+/, 'g'), ' ')
    .replace(new RegExp(/[^\w\s]/, 'g'), '')
    .replace(
      new RegExp(/\s+(.)(\w+)/, 'g'),
      ($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
}

oder

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) => `${$2.toUpperCase() + $3.toLowerCase()}`
    )
    .replace(new RegExp(/\s/, 'g'), '')
    .replace(new RegExp(/\w/), s => s.toLowerCase());
};

Testfälle:

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');
  });
});
1
kalicki2k
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('');
}      
1
user6921695

Oberes Kamelgehäuse ("TestString") zum unteren Kamelgehäuse ("testString") ohne Verwendung von Regex (seien wir ehrlich, Regex ist böse):

'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');
1

Diese Methode scheint die meisten Antworten zu übertreffen, sie ist jedoch ein bisschen hackig, kein Ersatz, kein Regex.

String.prototype.camelCase = function(){
    var newString = '';
    var lastEditedIndex;
    for (var i = 0; i < 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;
}
1
Thieu

Ich denke das sollte funktionieren ..

function cammelCase(str){
    let arr = str.split(' ');
    let words = arr.filter(v=>v!='');
    words.forEach((w, i)=>{
        words[i] = w.replace(/\w\S*/g, function(txt){
            return txt.charAt(0).toUpperCase() + txt.substr(1);
        });
    });
    return words.join('');
}
0
Darryl Ceguerra

EDIT : Funktioniert jetzt im IE8 ohne Änderungen.

EDIT : Ich war in der Minderheit darüber, was camelCase eigentlich ist (Hauptcharakter in Klein- oder Großbuchstaben). Die Community im Allgemeinen glaubt, dass ein führender Kleinbuchstabe ein Kamelbuchstabe und ein führender Großbuchstabe ein Pascalbuchstabe ist. Ich habe zwei Funktionen erstellt, die nur Regex-Muster verwenden. :) Also verwenden wir ein einheitliches Vokabular. Ich habe meine Haltung geändert, um der Mehrheit zu entsprechen.


Ich glaube, Sie brauchen in beiden Fällen nur einen einzigen regulären Ausdruck:

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"

oder

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 Funktionen: Sie werden feststellen, dass in diesen Funktionen beim Ersetzen alle Nicht-A-Z-Zeichen durch Leerzeichen und leere Zeichenfolgen ersetzt werden. Dies dient zum Erstellen von Wortgrenzen für die Großschreibung. "Hallo-MEINE # Welt" -> "HalloMeineWelt"

// 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
}

Anmerkungen:

  • Ich habe A-Za-z verlassen, anstatt das Unterscheidungsmerkmal (i) dem Muster (/ [^ A-Z]/ig) zur besseren Lesbarkeit hinzuzufügen.
  • Dies funktioniert in IE8 (srsly, wer verwendet IE8 nicht mehr.) Mit den (F12) dev-Tools, die ich in IE11 getestet habe , IE10, IE9, IE8, IE7 und IE5. Funktioniert in allen Dokumentmodi.
  • Dadurch wird der erste Buchstabe von Zeichenfolgen, der mit oder ohne Leerzeichen beginnt, korrekt in Groß- und Kleinschreibung umgewandelt.

Genießen

0
Joe Johnston

Ich weiß, dass dies eine alte Antwort ist, aber dies behandelt sowohl Whitespace als auch _ (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"
0
Sampgun

Verwenden Sie String.prototype.toCamelCase () nicht, da String.prototypes schreibgeschützt sind. Die meisten js-Compiler geben diese Warnung aus.

Wer weiß, dass die Zeichenfolge immer nur ein Leerzeichen enthält, kann einen einfacheren Ansatz verwenden:

let name = 'test string';

let pieces = name.split(' ');

pieces = pieces.map((Word, index) => Word.charAt(0)[index===0 ? 'toLowerCase' :'toUpperCase']() + Word.toLowerCase().slice(1));

return pieces.join('');

Haben Sie einen guten Tag. :)

0
Jaskaran Singh

Ein super einfacher Weg mit der turboCommons-Bibliothek:

npm install turbocommons-es5

<script src="turbocommons-es5/turbocommons-es5.js"></script>

<script>
    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));
</script>

Sie können auch StringUtils.FORMAT_CAMEL_CASE und StringUtils.FORMAT_UPPER_CAMEL_CASE verwenden, um Variationen des ersten Buchstaben zu erzeugen.

Mehr Infos hier:

https://turbocommons.org/de/blog/2018-10-25/convert-string-to-camelcase-javascript-TypeScript-php

0

Ein grundlegender Ansatz wäre, die Zeichenfolge mit einem Regex zu trennen, der mit Großbuchstaben oder Leerzeichen übereinstimmt. Dann würden Sie die Teile wieder zusammenkleben. Trick befasst sich mit den verschiedenen Arten, in denen Regex-Splits zwischen Browsern gebrochen/seltsam sind. Es gibt eine Bibliothek oder etwas, das jemand geschrieben hat, um diese Probleme zu beheben. Ich werde danach suchen.

hier ist der Link: http://blog.stevenlevithan.com/archives/cross-browser-split

0
Pointy

Weil diese Frage noch eine Antwort brauchte ...

Ich habe mehrere der vorherigen Lösungen ausprobiert, und alle hatten den einen oder anderen Fehler. Einige haben die Interpunktion nicht entfernt; Einige behandelten keine Fälle mit Zahlen. Einige haben nicht mit mehreren Interpunktionen hintereinander gearbeitet.

Keiner von ihnen hat einen String wie a1 2b behandelt. Es gibt keine explizit definierte Konvention für diesen Fall, aber einige andere stackoverflow-Fragen schlagen vor, die Zahlen durch einen Unterstrich zu trennen.

Ich bezweifle, dass dies die performanteste Antwort ist (drei reguläre Ausdrücke durchlaufen die Saite statt einer oder zwei), aber sie bestehen alle Tests, die ich mir vorstellen kann. Um ehrlich zu sein, kann ich mir wirklich keinen Fall vorstellen, in dem Sie so viele Camel-Conversions durchführen, für die Leistung von Bedeutung ist.

(Ich habe dies als npm package hinzugefügt. Es enthält auch einen optionalen booleschen Parameter, um Pascal Case anstelle von Camel Case zurückzugeben.)

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();
        });
}

Testfälle (Jest)

test('Basic strings', () => {
    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', () => {
    expect(`a'b--d -- f.h`.toCamelCase()).toBe('aBDFH');
    expect(`...a...def`.toCamelCase()).toBe('aDef');
});

test('Strings with numbers', () => {
    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', () => {
    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`);
});
0
dx_over_dt