Umwandlung einer Schnur in einen Kamelkoffer

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

EquipmentClass nameoder Equipment classNameoder equipment class nameoderEquipment Class Name

sollten alle werden : equipmentClassName.

Wenn Sie sich Ihren Code ansehen, können Sie ihn mit nur zwei replaceAufrufen erreichen:

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"

Bearbeiten: Oder mit einem einzigen replaceAnruf, wobei die Leerzeichen auch in der erfasst werden 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();
  });
}

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

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

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

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

Am Ende habe ich das gemacht:

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 habe versucht zu vermeiden, mehrere Ersetzungsanweisungen miteinander zu verketten. Etwas, bei dem ich $ 1, $ 2, $ 3 in meiner Funktion hätte. Aber diese Art der Gruppierung ist schwer zu verstehen, und Ihre Erwähnung von Cross-Browser-Problemen ist etwas, woran ich auch nie gedacht habe.

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

Um C amel C ase zu bekommen

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

Zu erhalten C amel S entence C ase oder P Ascal C ase

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

Hinweis:
Für Sprachen mit Akzenten. À-ÖØ-öø-ÿFügen Sie der Regex Folgendes hinzu
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

In Scotts speziellem Fall würde ich mich für etwas entscheiden wie:

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 beginnt, und mit jedem alphabetischen Zeichen, das auf ein Leerzeichen folgt, dh zwei- oder dreimal in den angegebenen Zeichenfolgen.

Durch Aufpeppen des regulären Ausdrucks /^([A-Z])|[\s-_](\w)/gwerden auch Bindestriche und Unterstriche von Typnamen getarnt.

'hyphen-name-format'.toCamelCase()     // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat

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 camelCaseeine Zeichenfolge zu finden, und wollte sicherstellen, dass Sonderzeichen entfernt werden (und ich hatte Probleme zu verstehen, was einige der obigen Antworten taten). Dies basiert auf der Antwort von cc young mit zusätzlichen Kommentaren und dem Entfernen von $ peci & l-Zeichen.

Zuverlässiges Arbeitsbeispiel, das ich seit Jahren verwende:

function camelize(text) {
    text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
    return text.substr(0, 1).toLowerCase() + text.substr(1);
}

Groß- / Kleinschreibung ändernde Zeichen:

• Bindestrich -
• unterstreichen _
• Zeitraum .
• Platz

Wenn kein regulärer Ausdruck erforderlich ist, sollten Sie sich den folgenden Code ansehen, 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 Regexp-Versionen sind möglicherweise schneller oder nicht.

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"

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

lodash kann den Trick sicher und gut machen:

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

Obwohl es sich lodashmöglicherweise um eine "große" Bibliothek handelt (~ 4 KB), enthält sie viele Funktionen, für die Sie normalerweise ein Snippet verwenden oder selbst erstellen würden.

Hier ist ein Einzeiler, 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 in RegExp bereitgestellten Zeichen auf [.\-_\s](fügen Sie mehr in [] hinzu!) Und gibt ein Wortarray zurück. Anschließend wird das Array von Zeichenfolgen auf eine verkettete Zeichenfolge mit Großbuchstaben reduziert. Da die Reduzierung keinen Anfangswert hat, werden die ersten Buchstaben beginnend mit dem zweiten Wort in Großbuchstaben geschrieben.

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

Nach dem lesbaren Ansatz von @ Scott ein wenig Feinabstimmung

// Konvertiere einen String in camelCase
var toCamelCase = Funktion (str) {
  return str.toLowerCase ()
    .replace (/ ['"] / g,' ')
    .replace (/ \ W + / g, '')
    .replace (/ (.) / g, function ($ 1) {return $ 1.toUpperCase ();})
    .replace (/ / g, '');
}}

wenig modifizierte Scotts Antwort:

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

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

Alle 14 Permutationen unten erzeugen das gleiche Ergebnis von "deviceClassName".

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

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

Weil diese Frage noch eine andere 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 Fälle mit Zahlen nicht. Einige haben nicht mehrere Satzzeichen hintereinander verarbeitet.

Keiner von ihnen handhabte eine Schnur wie a1 2b. Für diesen Fall gibt es keine explizit definierte Konvention, aber einige andere Fragen zum Stapelüberlauf schlugen vor, die Zahlen durch einen Unterstrich zu trennen.

Ich bezweifle, dass dies die performanteste Antwort ist (drei reguläre Ausdrücke durchlaufen die Zeichenfolge und nicht eine oder zwei), aber sie besteht alle Tests, die mir einfallen. Um ehrlich zu sein, kann ich mir keinen Fall vorstellen, in dem Sie so viele Kamel-Fall-Konvertierungen durchführen, dass die Leistung von Bedeutung wäre.

(Ich habe dies als npm-Paket 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 (Scherz)

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

Da ist 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'))

Diese Methode scheint die meisten Antworten hier zu übertreffen, sie ist jedoch ein bisschen hackig, keine Ersetzungen, keine Regex, sondern einfach eine neue Zeichenfolge aufzubauen, die camelCase ist.

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

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

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

Oberes Kamelgehäuse ("TestString") bis unteres 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), '');

Am Ende habe ich eine etwas aggressivere Lösung gefunden:

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

In diesem obigen Abschnitt werden alle nicht alphanumerischen Zeichen und Kleinbuchstaben von Wörtern entfernt, die ansonsten in Großbuchstaben bleiben würden, z

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

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

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

Ich weiß, dass dies eine alte Antwort ist, aber dies behandelt sowohl Leerzeichen 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"

const toCamelCase = str =>
  str
    .replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
    .replace(/^\w/, c => c.toLowerCase());

EDIT : Jetzt in IE8 ohne Änderungen arbeiten.

EDIT : Ich war in der Minderheit darüber, was camelCase eigentlich ist (Hauptzeichen Kleinbuchstaben vs. Großbuchstaben.). Die gesamte Gemeinde glaubt, dass ein führender Kleinbuchstabe ein Kamelfall und ein führendes Kapital ein Pascalfall 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 das Ersetzen jedes Nicht-Az durch ein Leerzeichen gegen eine leere Zeichenfolge austauscht. Dies dient dazu, Wortgrenzen für die Großschreibung zu erstellen. "hallo-MEINE # Welt" -> "HalloMyWorld"

// 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, um das Muster (/ [^ AZ] / ig) zur besseren Lesbarkeit mit dem Flag (i) für die Groß- und Kleinschreibung zu versehen.
• Dies funktioniert in IE8 (srsly, der IE8 nicht mehr verwendet). Verwenden der (F12) -Entwicklungstools, die ich in IE11, IE10, IE9, IE8, IE7 und IE5 getestet habe. Funktioniert in allen Dokumentmodi.
• Dadurch wird der erste Buchstabe der Zeichenfolgen, die mit oder ohne Leerzeichen beginnen, korrekt umschrieben.

Genießen

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

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

Wie ich können diejenigen, die wissen, dass die Zeichenfolge immer nur ein Leerzeichen enthält, 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. :) :)