Подтвердить что ты не робот

Преобразование любой струны в корпус верблюда

Как преобразовать строку в случай верблюда с помощью javascript regex?

EquipmentClass name или   Equipment className или equipment class name или equipment class name

все должны стать: equipmentClassName.

4b9b3361

ОТВЕТЫ

Ответ 1

Я только что закончил это:

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

Я пытался избежать объединения нескольких операторов замены. Что-то, где у меня будет $1, $2, $3 в моей функции. Но этот тип группировки трудно понять, и ваше упоминание о проблемах с перекрестным браузером - это то, о чем я никогда не думал.

Ответ 2

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

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"

Изменить: Или с помощью одного вызова 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();
  });
}

Ответ 3

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

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

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

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

Ответ 4

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

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

Ответ 5

В конкретном случае Id Скотта идет что-то вроде:

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

Ответ 6

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

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

Ответ 7

Для того, чтобы получить с Амель C аза

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 amel S entence C ase или P ascal C ase

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

Замечания :
Для тех, язык с акцентами. Включите À-ÖØ-öø-ÿ в регулярное выражение, как указано ниже
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g

Ответ 8

Если regexp не требуется, вы можете посмотреть следующий код, который я сделал давно, для 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 );
}

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

Ответ 9

Мой 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"

Ответ 10

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

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

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

Ответ 11

Вот один лайнер, выполняющий работу:

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

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

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

Ответ 12

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

Ответ 13

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

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

Ответ 14

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

Ответ 15

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

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

Ответ 16

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

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

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

Ответ 17

Есть мое решение:

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

Ответ 18

Этот метод, кажется, превосходит большинство ответов здесь, он немного взломан, хотя и не заменяет, не имеет регулярного выражения, просто создает новую строку, которая является 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;
}

Ответ 19

Это основано на ответе 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

Ответ 20

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

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

Ответ 21

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

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

Ответ 22

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

Ответ 23

Потому что на этот вопрос нужен еще один ответ...

Я попробовал несколько предыдущих решений, и у всех них был тот или иной недостаток. Некоторые не убрали пунктуацию; некоторые не обрабатывали дела с номерами; некоторые не обрабатывали несколько знаков препинания подряд.

Никто из них не обращался со строкой, подобной a1 2b. Для этого случая не существует явно определенного соглашения, но некоторые другие вопросы о стековом потоке предлагали разделять числа подчеркиванием.

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

(Я добавил это как пакет npm. Он также включает необязательный логический параметр для возврата Pascal Case вместо 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();
        });
}

Тестовые случаи (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');
});

Ответ 24

Вот мое предложение:

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

или же

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

Тестовые случаи:

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

Ответ 25

Я знаю, что это старый ответ, но он обрабатывает как пробелы, так и _ (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"

Ответ 26

Базовый подход состоял бы в том, чтобы разбить строку на соответствие верхнему регистру или пробелам с регулярным выражением. Затем вы приклеите кусочки обратно вместе. Trick будет иметь дело с различными способами разложения регулярных выражений сломаны/странны в браузерах. Там есть библиотека или что-то, что кто-то написал, чтобы исправить эти проблемы; Я буду искать его.

здесь ссылка: http://blog.stevenlevithan.com/archives/cross-browser-split

Ответ 27

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

РЕДАКТИРОВАТЬ. Я был в меньшинстве о том, что на самом деле является 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"

В функциях: вы заметите, что в этих функциях замена заменяет любой не -z-z пробелом vs пустой строкой. Это делается для создания границ слов для капитализации. "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 против добавления флага нечувствительности к регистру (i) к шаблону (/[^ A-Z]/ig) для удобочитаемости.
  • Это работает в IE8 (srsly, который больше использует IE8.) Используя инструменты (F12) dev, которые я тестировал в IE11, IE10, IE9, IE8, IE7 и IE5. Работает во всех режимах документа.
  • Это будет верно в случае первой буквы строк, начинающихся с пробелов или без них.

Enjoy

Ответ 28

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

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

Ответ 29

Супер простой способ, используя библиотеку turboCommons:

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>

Вы также можете использовать StringUtils.FORMAT_CAMEL_CASE и StringUtils.FORMAT_UPPER_CAMEL_CASE, чтобы сгенерировать варианты, состоящие из первых букв.

Больше информации здесь:

Преобразовать строку в CamelCase, UpperCamelCase или lowerCamelCase

Ответ 30

Не используйте String.prototype.toCamelCase(), потому что String.prototypes доступны только для чтения, большинство компиляторов js выдает это предупреждение.

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

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

Хорошего дня. :)