Converti camelCaseText in maiuscolo / minuscolo

Come posso convertire una stringa come "helloThere" o "HelloThere" in "Hello There" in JavaScript?

var text = 'helloThereMister';
var result = text.replace( /([A-Z])/g, " $1" );
var finalResult = result.charAt(0).toUpperCase() + result.slice(1);
console.log(finalResult);

scrivere in maiuscolo la prima lettera, ad esempio.

Nota lo spazio in " $1".

EDIT: aggiunto un esempio di capitalizzazione della prima lettera. Naturalmente, nel caso in cui la prima lettera sia già maiuscola, avresti uno spazio libero da rimuovere.

In alternativa usando lodash :

lodash.startCase(str);

Esempio:

_.startCase('helloThere');
// ➜ 'Hello There'

Lodash è una libreria eccellente per dare scorciatoia a molte attività js di tutti i giorni. Ci sono molte altre funzioni di manipolazione delle stringhe simili come camelCase, kebabCaseecc.

Ho avuto un problema simile e ho affrontato in questo modo:

stringValue.replace(/([A-Z]+)*([A-Z][a-z])/g, "$1 $2")

Per una soluzione più solida:

stringValue.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1")

http://jsfiddle.net/PeYYQ/

Ingresso:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

Produzione:

 hello There 
 Hello There 
 I Love The USA
 i Love The USA

Esempio senza effetti collaterali.

function camel2title(camelCase) {
  // no side-effects
  return camelCase
    // inject space before the upper case letters
    .replace(/([A-Z])/g, function(match) {
       return " " + match;
    })
    // replace first char with upper case
    .replace(/^./, function(match) {
      return match.toUpperCase();
    });
}

In ES6

const camel2title = (camelCase) => camelCase
  .replace(/([A-Z])/g, (match) => ` ${match}`)
  .replace(/^./, (match) => match.toUpperCase());

La migliore stringa che ho trovato per testare le funzioni da caso cammello a titolo caso è questo esempio ridicolmente privo di senso, che verifica molti casi limite. Per quanto ne so, nessuna delle funzioni precedentemente pubblicate lo gestisce correttamente :

ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D

Questo dovrebbe essere convertito in:

Ottenere in tempo il tuo GED Una canzone sui 26 ABC è dell'essenza, ma una carta d'identità personale per l'utente 456 nella sala 26A contenente ABC 26 volte non è facile come 123 per C3PO o R2D2 o 2R2D

Se vuoi solo una semplice funzione che gestisca casi come quello sopra (e più casi di molte delle risposte precedenti), ecco quello che ho scritto. Questo codice non è particolarmente elegante o veloce, ma è semplice, comprensibile e funziona.

Un esempio eseguibile online è su jsfiddle , oppure puoi visualizzare l'output dello snippet di seguito nella tua console:

// Take a single camel case string and convert it to a string of separate words (with spaces) at the camel-case boundaries.
// 
// E.g.:
var examples = [
    'ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D',
    //                                          --> To Get Your GED In Time A Song About The 26 ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D
    'helloThere', //                              --> Hello There
    'HelloThere', //                              --> Hello There
    'ILoveTheUSA', //                             --> I Love The USA
    'iLoveTheUSA', //                             --> I Love The USA
    'DBHostCountry', //                           --> DB Host Country
    'SetSlot123ToInput456', //                    --> Set Slot 123 To Input 456
    'ILoveTheUSANetworkInTheUSA', //              --> I Love The USA Network In The USA
    'Limit_IOC_Duration', //                      --> Limit IOC Duration
    'This_is_a_Test_of_Network123_in_12_days', // --> This Is A Test Of Network 123 In 12 Days
    'ASongAboutTheABCsIsFunToSing', //            --> A Song About The ABCs Is Fun To Sing
    'CFDs', //                                    --> CFDs
    'DBSettings', //                              --> DB Settings
    'IWouldLove1Apple', //                        --> 1 Would Love 1 Apple
    'Employee22IsCool', //                        --> Employee 22 Is Cool
    'SubIDIn', //                                 --> Sub ID In
    'ConfigureCFDsImmediately', //                --> Configure CFDs Immediately
    'UseTakerLoginForOnBehalfOfSubIDInOrders', // --> Use Taker Login For On Behalf Of Sub ID In Orders
]

function camelCaseToTitleCase(in_camelCaseString) {
        var result = in_camelCaseString                         // "ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D"
            .replace(/([a-z])([A-Z][a-z])/g, "$1 $2")           // "To Get YourGEDIn TimeASong About The26ABCs IsOf The Essence ButAPersonalIDCard For User456In Room26AContainingABC26Times IsNot AsEasy As123ForC3POOrR2D2Or2R2D"
            .replace(/([A-Z][a-z])([A-Z])/g, "$1 $2")           // "To Get YourGEDIn TimeASong About The26ABCs Is Of The Essence ButAPersonalIDCard For User456In Room26AContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
            .replace(/([a-z])([A-Z]+[a-z])/g, "$1 $2")          // "To Get Your GEDIn Time ASong About The26ABCs Is Of The Essence But APersonal IDCard For User456In Room26AContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
            .replace(/([A-Z]+)([A-Z][a-z][a-z])/g, "$1 $2")     // "To Get Your GEDIn Time A Song About The26ABCs Is Of The Essence But A Personal ID Card For User456In Room26A ContainingABC26Times Is Not As Easy As123ForC3POOr R2D2Or2R2D"
            .replace(/([a-z]+)([A-Z0-9]+)/g, "$1 $2")           // "To Get Your GEDIn Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC26Times Is Not As Easy As 123For C3POOr R2D2Or 2R2D"
            
            // Note: the next regex includes a special case to exclude plurals of acronyms, e.g. "ABCs"
            .replace(/([A-Z]+)([A-Z][a-rt-z][a-z]*)/g, "$1 $2") // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC26Times Is Not As Easy As 123For C3PO Or R2D2Or 2R2D"
            .replace(/([0-9])([A-Z][a-z]+)/g, "$1 $2")          // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456In Room 26A Containing ABC 26Times Is Not As Easy As 123For C3PO Or R2D2Or 2R2D"  

            // Note: the next two regexes use {2,} instead of + to add space on phrases like Room26A and 26ABCs but not on phrases like R2D2 and C3PO"
            .replace(/([A-Z]{2,})([0-9]{2,})/g, "$1 $2")        // "To Get Your GED In Time A Song About The 26ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D"
            .replace(/([0-9]{2,})([A-Z]{2,})/g, "$1 $2")        // "To Get Your GED In Time A Song About The 26 ABCs Is Of The Essence But A Personal ID Card For User 456 In Room 26A Containing ABC 26 Times Is Not As Easy As 123 For C3PO Or R2D2 Or 2R2D"
            .trim();


  // capitalize the first letter
  return result.charAt(0).toUpperCase() + result.slice(1);
}

examples.forEach(str => console.log(str, ' --> \n', camelCaseToTitleCase(str)));

Sulla base di uno degli esempi precedenti ho trovato questo:

const camelToTitle = (camelCase) => camelCase
  .replace(/([A-Z])/g, (match) => ` ${match}`)
  .replace(/^./, (match) => match.toUpperCase())
  .trim()

Funziona per me perché utilizza .trim()per gestire il caso limite in cui la prima lettera è maiuscola e si finisce con uno spazio aggiuntivo.

Riferimento: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

Ok, sono in ritardo di qualche anno, ma avevo una domanda simile e volevo creare una soluzione a sostituzione singola per ogni possibile input. Devo dare la maggior parte del merito a @ZenMaster in questo thread e @Benjamin Udink ten Cate in questo thread. Ecco il codice:

var camelEdges = /([A-Z](?=[A-Z][a-z])|[^A-Z](?=[A-Z])|[a-zA-Z](?=[^a-zA-Z]))/g;
var textArray = ["lowercase",
                 "Class",
                 "MyClass",
                 "HTML",
                 "PDFLoader",
                 "AString",
                 "SimpleXMLParser",
                 "GL11Version",
                 "99Bottles",
                 "May5",
                 "BFG9000"];
var text;
var resultArray = [];
for (var i = 0; i < a.length; i++){
    text = a[i];
    text = text.replace(camelEdges,'$1 ');
    text = text.charAt(0).toUpperCase() + text.slice(1);
    resultArray.push(text);
}

Ha tre clausole, tutte che usano lookahead per impedire al motore regex di consumare troppi personaggi:

1. [A-Z](?=[A-Z][a-z])cerca una lettera maiuscola seguita da una maiuscola e poi da una minuscola. Questo per porre fine agli acronimi come gli Stati Uniti.
2. [^A-Z](?=[A-Z])cerca una lettera non maiuscola seguita da una lettera maiuscola. Questo finisce parole come myWord e simboli come 99Bottles.
3. [a-zA-Z](?=[^a-zA-Z])cerca una lettera seguita da una non lettera. Questo termina le parole prima di simboli come BFG9000.

Questa domanda era in cima ai miei risultati di ricerca, quindi spero di poter risparmiare un po 'di tempo!

Ecco la mia versione di esso. Aggiunge uno spazio prima di ogni lettera inglese UpperCase che viene dopo una lettera inglese minuscola e, se necessario, rende maiuscola la prima lettera:

Ad esempio:
thisIsCamelCase -> This Is Camel Case
this IsCamelCase -> This Is Camel Case
thisIsCamelCase123 -> This Is Camel Case123

  function camelCaseToTitleCase(camelCase){
    if (camelCase == null || camelCase == "") {
      return camelCase;
    }

    camelCase = camelCase.trim();
    var newText = "";
    for (var i = 0; i < camelCase.length; i++) {
      if (/[A-Z]/.test(camelCase[i])
          && i != 0
          && /[a-z]/.test(camelCase[i-1])) {
        newText += " ";
      }
      if (i == 0 && /[a-z]/.test(camelCase[i]))
      {
        newText += camelCase[i].toUpperCase();
      } else {
        newText += camelCase[i];
      }
    }

    return newText;
  }

Questa implementazione prende in considerazione lettere maiuscole e numeri consecutivi.

function camelToTitleCase(str) {
  return str
    .replace(/[0-9]{2,}/g, match => ` ${match} `)
    .replace(/[^A-Z0-9][A-Z]/g, match => `${match[0]} ${match[1]}`)
    .replace(/[A-Z][A-Z][^A-Z0-9]/g, match => `${match[0]} ${match[1]}${match[2]}`)
    .replace(/[ ]{2,}/g, match => ' ')
    .replace(/\s./g, match => match.toUpperCase())
    .replace(/^./, match => match.toUpperCase())
    .trim();
}

// ----------------------------------------------------- //

var testSet = [
    'camelCase',
    'camelTOPCase',
    'aP2PConnection',
    'superSimpleExample',
    'aGoodIPAddress',
    'goodNumber90text',
    'bad132Number90text',
];

testSet.forEach(function(item) {
    console.log(item, '->', camelToTitleCase(item));
});

Uscita prevista:

camelCase -> Camel Case
camelTOPCase -> Camel TOP Case
aP2PConnection -> A P2P Connection
superSimpleExample -> Super Simple Example
aGoodIPAddress -> A Good IP Address
goodNumber90text -> Good Number 90 Text
bad132Number90text -> Bad 132 Number 90 Text

Puoi usare una funzione come questa:

function fixStr(str) {
    var out = str.replace(/^\s*/, "");  // strip leading spaces
    out = out.replace(/^[a-z]|[^\s][A-Z]/g, function(str, offset) {
        if (offset == 0) {
            return(str.toUpperCase());
        } else {
            return(str.substr(0,1) + " " + str.substr(1).toUpperCase());
        }
    });
    return(out);
}

"hello World" ==> "Hello World"
"HelloWorld" ==> "Hello World"
"FunInTheSun" ==? "Fun In The Sun"

Codice con un sacco di stringhe di test qui: http://jsfiddle.net/jfriend00/FWLuV/ .

Versione alternativa che mantiene gli spazi iniziali qui: http://jsfiddle.net/jfriend00/Uy2ac/ .

prova questa libreria

http://sugarjs.com/api/String/titleize

'man from the boondocks'.titleize()>"Man from the Boondocks"
'x-men: the last stand'.titleize()>"X Men: The Last Stand"
'TheManWithoutAPast'.titleize()>"The Man Without a Past"
'raiders_of_the_lost_ark'.titleize()>"Raiders of the Lost Ark"

Nessuna delle risposte sopra ha funzionato perfettamente per me, quindi ho dovuto venire con la propria bicicletta:

function camelCaseToTitle(camelCase) {
    if (!camelCase) {
        return '';
    }

    var pascalCase = camelCase.charAt(0).toUpperCase() + camelCase.substr(1);
    return pascalCase
        .replace(/([a-z])([A-Z])/g, '$1 $2')
        .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
        .replace(/([a-z])([0-9])/gi, '$1 $2')
        .replace(/([0-9])([a-z])/gi, '$1 $2');
}

Casi test:

null => ''
'' => ''
'simpleString' => 'Simple String'
'stringWithABBREVIATIONInside => 'String With ABBREVIATION Inside'
'stringWithNumber123' => 'String With Number 123'
'complexExampleWith123ABBR890Etc' => 'Complex Example With 123 ABBR 890 Etc'

Questo funziona per me, dai un'occhiata

CamelcaseToWord ( "MyName"); // restituisce il mio nome

    function CamelcaseToWord(string){
      return string.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1");
    }

Penso che questo possa essere fatto solo con il registro exp /([a-z]|[A-Z]+)([A-Z])/ge la sostituzione "$1 $2".

ILoveTheUSADope -> I Love The USA Dope

Se hai a che fare con Capital Camel Case questo frammento può aiutarti, inoltre contiene alcune specifiche in modo che tu possa essere sicuro che corrisponda al tuo caso.

export const fromCamelCaseToSentence = (word) =>
  word
    .replace(/([A-Z][a-z]+)/g, ' $1')
    .replace(/([A-Z]{2,})/g, ' $1')
    .replace(/\s{2,}/g, ' ')
    .trim();

E specifiche:

describe('fromCamelCaseToSentence', () => {
 test('does not fall with a single word', () => {
   expect(fromCamelCaseToSentence('Approved')).toContain('Approved')
   expect(fromCamelCaseToSentence('MDA')).toContain('MDA')
 })

 test('does not fall with an empty string', () => {
   expect(fromCamelCaseToSentence('')).toContain('')
 })

 test('returns the separated by space words', () => {
   expect(fromCamelCaseToSentence('NotApprovedStatus')).toContain('Not Approved Status')
   expect(fromCamelCaseToSentence('GDBState')).toContain('GDB State')
   expect(fromCamelCaseToSentence('StatusDGG')).toContain('Status DGG')
 })
})

Non ho provato la risposta di tutti, ma le poche soluzioni con cui ho armeggiato non soddisfacevano tutti i miei requisiti.

Sono stato in grado di inventare qualcosa che ha fatto ...

export const jsObjToCSSString = (o={}) =>
    Object.keys(o)
          .map(key => ({ key, value: o[key] }))
          .map(({key, value}) =>
              ({
                key: key.replace( /([A-Z])/g, "-$1").toLowerCase(),
                value
              })
          )
          .reduce(
              (css, {key, value}) => 
                  `${css} ${key}: ${value}; `.trim(), 
              '')

Di seguito è riportato un link che mostra la stringa della custodia del cammello alla stringa di frase usando regex.

Ingresso

myCamelCaseSTRINGToSPLITDemo

Produzione

my Camel Case STRING To SPLIT Demo

Questo è regex per la conversione del caso del cammello in testo di frase

(?=[A-Z][a-z])|([A-Z]+)([A-Z][a-rt-z][a-z]\*)

con $1 $2come sussidio.

Fare clic per visualizzare la conversione su regex

Immettere javaScript

Output script Java

   var text = 'javaScript';
    text.replace(/([a-z])([A-Z][a-z])/g, "$1 $2").charAt(0).toUpperCase()+text.slice(1).replace(/([a-z])([A-Z][a-z])/g, "$1 $2");

Un'altra soluzione basata su RegEx.

respace(str) {
  const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g;
  return str.replace(regex, '$& ');
}

Spiegazione

Il precedente RegEx è costituito da due parti simili separate dall'operatore OR . La prima metà:

1. ([A-Z]) - corrisponde a lettere maiuscole ...
2. (?=[A-Z][a-z]) - seguito da una sequenza di lettere maiuscole e minuscole.

Se applicato alla sequenza FOo , corrisponde effettivamente alla sua lettera F.

O il secondo scenario:

1. ([a-z]) - corrisponde a lettere minuscole ...
2. (?=[A-Z]) - seguito da una lettera maiuscola.

Se applicato alla sequenza barFoo , corrisponde effettivamente alla sua lettera r .

Quando sono stati trovati tutti i candidati sostitutivi, l'ultima cosa da fare è sostituirli con la stessa lettera ma con un carattere spazio aggiuntivo. Per questo possiamo usare '$& 'come rimpiazzo e si risolverà in una sottostringa abbinata seguita da un carattere spazio.

Esempio

const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g
const testWords = ['ACoolExample', 'fooBar', 'INAndOUT', 'QWERTY', 'fooBBar']

testWords.map(w => w.replace(regex, '$& '))
->(5) ["A Cool Example", "foo Bar", "IN And OUT", "QWERTY", "foo B Bar"]

Aggiunta di un'altra soluzione ES6 che mi è piaciuta di più dopo non essere soddisfatta di alcuni pensieri sopra.

https://codepen.io/902Labs/pen/mxdxRv?editors=0010#0

const camelize = (str) => str
    .split(' ')
    .map(([first, ...theRest]) => (
        `${first.toUpperCase()}${theRest.join('').toLowerCase()}`)
    )
    .join(' ');