Преобразовать любую строку в верхний регистр

глядя на ваш код, вы можете достичь его только два replace вызовы:

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: или в replace вызов, захватывая пробелы также в 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();
  });
}

Если кто-то использует лодашь, есть _.camelCase()

вы можете использовать это решение :

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

в конкретном случае Скотта я бы пошел с чем-то вроде:

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

регулярное выражение будет соответствовать первому символу, если оно начинается с заглавной буквы и любого алфавитного символа после пробела, т. е. 2 или 3 раза в указанных строках.

приправляя регулярное выражение до /^([A-Z])|[\s-_](\w)/g Он также будет камелизировать имена типов дефиса и подчеркивания.

'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() { return .toUpperCase(); })
    // Removes spaces 
    .replace( / /g, '' );
}

Я пытался найти функцию JavaScript для camelCase строка, и хотел убедиться, что специальные символы будут удалены (и у меня были проблемы с пониманием того, что делали некоторые из ответов выше). Это основано на ответе c C young, с добавленными комментариями и удалением символов $peci&L.

мой ES6 подход:

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"

если регулярное выражение не требуется, вы можете посмотреть на следующий код, который я сделал давно для блеск:

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

Я не делал никаких тестов производительности, и версии регулярных выражений могут быть или не быть быстрее.

лодашь может сделать трюк уверены и так:

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

хотя lodash может быть" большая " библиотека (~4kB), она содержит много функций, для которых вы обычно используете фрагмент или строите себя.

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

все 14 перестановок ниже дают тот же результат "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());
};

вы можете использовать это решение:

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

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

следуя читабельному подходу @ Scott, немного тонкой настройки

// convert any string to camelCase
var toCamelCase = function(str) {
  return str.toLowerCase()
    .replace( /['"]/g, '' )
    .replace( /\W+/g, ' ' )
    .replace( / (.)/g, function() { return .toUpperCase(); })
    .replace( / /g, '' );
}

немного модифицированный ответ Скотта:

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

теперь он заменяет '-' и '_' тоже.

вот мое решение:

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

этот метод, кажется, превосходит большинство ответов здесь, это немного хаки, хотя, не заменяет, не регулярное выражение, просто создавая новую строку, которая является camelCase.

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

это основывается на ответе CMS, удаляя любые неалфавитные символы в том числе подчеркивает, что \w не удалить.

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

верхний случай верблюда ("TestString") для нижнего случая верблюда ("testString") без использования регулярного выражения (давайте посмотрим правде в глаза, регулярное выражение-это зло):

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

Я закончил тем, что создал немного более агрессивное решение:

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

этот, выше, удалит все не буквенно-цифровые символы и строчные части слов, которые в противном случае остались бы в верхнем регистре, например

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

вот один лайнер делает работу:

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

он разбивает строку в нижнем регистре на основе списка символов, предоставленных в регулярном выражении [.\-_\s] (добавить больше внутри []!) и возвращает массив слов . Затем он уменьшает массив строк до одной сцепленной строки слов с прописными первыми буквами. Поскольку reduce не имеет начального значения, он начнет прописывать первые буквы, начиная со второго слова.

Если вы хотите PascalCase, просто добавьте начальная пустая строка ,'') в метод reduce.

основным подходом было бы разделить строку с регулярным выражением, соответствующим верхнему регистру или пробелам. Тогда ты склеиваешь кусочки обратно вместе. Трюк будет иметь дело с различными способами разделения регулярных выражений сломаны / странно через браузеры. Есть библиотека или что-то, что кто-то написал, чтобы исправить эти проблемы, я буду искать его.

вот ссылка:http://blog.stevenlevithan.com/archives/cross-browser-split

EDIT: теперь работает в IE8 без изменений.

EDIT: Я был в меньшинстве о том, что camelCase на самом деле (ведущий символ нижнего регистра против верхнего регистра.). Сообщество в целом считает, что ведущим строчным регистром является случай верблюда, а ведущим капиталом-случай Паскаля. Я создал две функции, которые используют только шаблоны регулярных выражений. :) Поэтому мы используем единый словарь я изменил свою позицию, чтобы соответствовать большинству.

---

все, во что я верю вам нужно одно регулярное выражение в любом случае:

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"

или

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: вы заметите, что в этих функциях замена заменяет любую не a-z пробелом против пустой строки. Это делается для создания границ слов Для заглавной буквы. "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
}

Примечания:

• я оставил A-Za-z vs добавление флага нечувствительности к регистру (i) к шаблону (/[^A-Z] / ig) для удобочитаемости.
• это работает в IE8 (srsly, который больше использует IE8.) Используя инструменты разработки (F12), которые я тестировал в IE11, IE10, IE9, IE8, IE7 и IE5. Работает во всех режимах документа.
• это будет правильно в случае первой буквы строк, начиная с или без пробелов.

наслаждайтесь

Я думаю, что это должно работать..

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

и cАмельченкоCase

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

и CАмельченкоSнаказаниеCase или PascalCase

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

мой подход для одного слова. Не требуется регулярное выражение

function camelize(word) {
    const [first, ...rest] = word;
    return [first.toUpperCase(), ...rest].join();
}

на приговор

function camelizeSentence(sentence) {
    return sentence.split(" ").map(camelize).join(" ");
}