Come posso convertire una stringa in custodia cammello usando javascript regex?
EquipmentClass name
oppure
Equipment className
oppure equipment class name
oppureEquipment Class Name
dovrebbe diventare tutti: equipmentClassName
.
Come posso convertire una stringa in custodia cammello usando javascript regex?
EquipmentClass name
oppure
Equipment className
oppure equipment class name
oppureEquipment Class Name
dovrebbe diventare tutti: equipmentClassName
.
Risposte:
Guardando il tuo codice, puoi raggiungerlo con solo due replace
chiamate:
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"
Modifica: O con una sola replace
chiamata, catturando gli spazi bianchi anche in 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();
});
}
camelize("Let's Do It!") === "let'SDoIt!"
faccia triste . Ci proverò ma temo di aggiungere un altro sostituto.
return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,
...
const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
.toLowerCase()
metodo. Ad es. usando la soluzione di @ tabrindle sopra:const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
Se qualcuno sta usando lodash , c'è una _.camelCase()
funzione.
_.camelCase('Foo Bar');
// → 'fooBar'
_.camelCase('--foo-bar--');
// → 'fooBar'
_.camelCase('__FOO_BAR__');
// → 'fooBar'
Ho appena finito per fare questo:
String.prototype.toCamelCase = function(str) {
return str
.replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
.replace(/\s/g, '')
.replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}
Stavo cercando di evitare di concatenare più dichiarazioni di sostituzione. Qualcosa in cui avrei $ 1, $ 2, $ 3 nella mia funzione. Ma quel tipo di raggruppamento è difficile da capire e la tua menzione sui problemi tra browser è qualcosa a cui non ho mai pensato.
this.valueOf()
invece di passare str
. In alternativa (come nel mio caso), this.toLowerCase()
dato che le mie stringhe di input erano in TUTTI MAIUSCOLI che non avevano le porzioni senza gobba minuscole correttamente. L'uso di appena this
restituisce l'oggetto stringa stesso, che in realtà è un array di caratteri, quindi l'oggetto TypeError menzionato sopra.
Puoi usare questa soluzione:
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('');
}
toCamelCase
funzione fa proprio questo.
Per ottenere C amel C ase
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());
}
Per ottenere C amel S entence C ase o P ascal C ase
var camelSentence = function camelSentence(str) {
return (" " + str).toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
{
return chr.toUpperCase();
});
}
Nota:
per quella lingua con accenti. Includere À-ÖØ-öø-ÿ
con regex come segue
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g
https://stackoverflow.com/posts/52551910/revisions
ES6, non l'ho provato. Controllerò e aggiornerò.
Nel caso specifico di Scott andrei con qualcosa del tipo:
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
La regex corrisponderà al primo carattere se inizia con una lettera maiuscola e qualsiasi carattere alfabetico che segue uno spazio, ovvero 2 o 3 volte nelle stringhe specificate.
Arricchendo il regex con /^([A-Z])|[\s-_](\w)/g
esso camelizza anche i nomi di trattini e trattini bassi.
'hyphen-name-format'.toCamelCase() // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat
+
) al gruppo di caratteri, ovvero:/^([A-Z])|[\s-_]+(\w)/g
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, '' );
}
Stavo cercando di trovare una funzione JavaScript in camelCase
una stringa e volevo assicurarmi che i caratteri speciali fossero rimossi (e avevo difficoltà a capire cosa stavano facendo alcune delle risposte sopra). Questo si basa sulla risposta di cc young, con l'aggiunta di commenti e la rimozione di $ peci & l caratteri.
Esempio affidabile e funzionante che utilizzo da anni:
function camelize(text) {
text = text.replace(/[-_\s.]+(.)?/g, (_, c) => c ? c.toUpperCase() : '');
return text.substr(0, 1).toLowerCase() + text.substr(1);
}
Personaggi che cambiano caso:
-
_
.
Se regexp non è richiesto, potresti voler guardare il seguente codice che ho creato molto tempo fa per 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 );
}
Non ho eseguito alcun test delle prestazioni e le versioni regexp potrebbero o non potrebbero essere più veloci.
Il mio approccio 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"
return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld
lodash può fare il trucco sicuro e bene:
var _ = require('lodash');
var result = _.camelCase('toto-ce héros')
// result now contains "totoCeHeros"
Sebbene lodash
possa essere una libreria "grande" (~ 4kB), contiene molte funzioni per le quali normalmente utilizzeresti uno snippet o che ti costruiresti.
Ecco una fodera che fa il lavoro:
const camelCaseIt = string => string.toLowerCase().trim().split(/[.\-_\s]/g).reduce((string, word) => string + word[0].toUpperCase() + word.slice(1));
Suddivide la stringa di caratteri inferiori in base all'elenco dei caratteri forniti in RegExp [.\-_\s]
(aggiungine altri all'interno di []!) E restituisce un array di parole. Quindi, riduce la matrice di stringhe a una stringa concatenata di parole con le prime lettere maiuscole. Poiché la riduzione non ha alcun valore iniziale, inizierà a mettere in maiuscolo le prime lettere a partire dalla seconda parola.
Se vuoi PascalCase, aggiungi una stringa vuota iniziale ,'')
al metodo di riduzione.
seguendo l'approccio leggibile di @ Scott, un po 'di messa a punto
// converte qualsiasi stringa in camelCase var toCamelCase = function (str) { return str.toLowerCase () .replace (/ ['"] / g,' ') .replace (/ \ W + / g, '') .replace (/ (.) / g, function ($ 1) {return $ 1.toUpperCase ();}) .replace (/ / g, ''); }
Tutte le 14 permutazioni sottostanti producono lo stesso risultato di "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());
};
puoi usare questa soluzione:
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());
Perché questa domanda aveva bisogno di un'altra risposta ...
Ho provato diverse soluzioni precedenti e tutte avevano un difetto o un altro. Alcuni non hanno rimosso la punteggiatura; alcuni non gestivano casi con numeri; alcuni non gestivano più punteggiatura di seguito.
Nessuno di loro ha gestito una stringa come a1 2b
. Non esiste una convenzione esplicitamente definita per questo caso, ma alcune altre domande di StackOver hanno suggerito di separare i numeri con un carattere di sottolineatura.
Dubito che questa sia la risposta più performante (tre regex passano attraverso la stringa, piuttosto che una o due), ma supera tutti i test a cui riesco a pensare. Ad essere sincero, però, non riesco davvero a immaginare un caso in cui stai facendo così tante conversioni da caso a cammello che le prestazioni contano.
(L'ho aggiunto come pacchetto npm . Include anche un parametro booleano opzionale per restituire Pascal Case invece di 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();
});
}
Casi di prova (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`);
});
C'è la mia soluzione:
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'))
Questo metodo sembra sovraperformare la maggior parte delle risposte qui, è un po 'confuso, non sostituisce, non regex, semplicemente costruendo una nuova stringa che è 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;
}
Questo si basa sulla risposta di CMS rimuovendo tutti i caratteri non alfabetici inclusi i trattini bassi, che \w
non vengono rimossi.
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
Caso del cammello superiore ("TestString") al caso del cammello inferiore ("testString") senza usare regex (ammettiamolo, regex è male):
'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');
Ho finito per creare una soluzione leggermente più aggressiva:
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('');
}
Questo, sopra, rimuoverà tutti i caratteri non alfanumerici e le parti minuscole delle parole che altrimenti rimarrebbero maiuscole, ad es.
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('');
}
Ecco il mio suggerimento:
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());
}
o
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());
};
Casi test:
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');
});
});
So che questa è una vecchia risposta, ma gestisce sia gli spazi bianchi sia _ (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"
"
a .replace(/_/g", " ")
che gli errori di cause di compilazione?
const toCamelCase = str =>
str
.replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase())
.replace(/^\w/, c => c.toLowerCase());
EDIT : ora funziona in IE8 senza modifiche.
EDIT : ero in minoranza su ciò che effettivamente è camelCase (personaggio principale in minuscolo vs. maiuscolo). La comunità in generale ritiene che una minuscola protagonista sia il caso dei cammelli e una capitale principale sia il caso pasquale. Ho creato due funzioni che usano solo schemi regex. :) Quindi usiamo un vocabolario unificato, ho cambiato la mia posizione in modo che corrisponda alla maggioranza.
Tutto ciò di cui hai bisogno è una sola regex in entrambi i casi:
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"
o
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"
Nelle funzioni: Noterai che in queste funzioni il sostituto sta scambiando qualsiasi non az con uno spazio contro una stringa vuota. Questo serve a creare confini di parole per scrivere in maiuscolo. "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
}
Appunti:
Godere
Penso che dovrebbe funzionare ..
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('');
}
Non usare String.prototype.toCamelCase () perché String.prototypes sono di sola lettura, la maggior parte dei compilatori js ti darà questo avviso.
Come me, quelli che sanno che la stringa conterrà sempre solo uno spazio possono usare un approccio più semplice:
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('');
Buona giornata. :)