Pregunta Convertir camelCaseText en texto de caso de oración


¿Cómo puedo convertir una cadena como 'helloThere' o 'HelloThere' a 'Hello There' en JavaScript?


74
2017-08-29 02:03


origen


Respuestas:


var text = 'helloThereMister';
var result = text.replace( /([A-Z])/g, " $1" );
var finalResult = result.charAt(0).toUpperCase() + result.slice(1); // capitalize the first letter - as an example.

Tenga en cuenta el espacio en " $1".

EDITAR: agregó un ejemplo de mayúscula de la primera letra. Por supuesto, en caso de que la primera letra ya sea capital, tendrá un espacio libre para eliminar.


92
2017-08-29 02:11



Tuve un problema similar y lo resolví así:

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

Para una solución más robusta:

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

http://jsfiddle.net/PeYYQ/

Entrada:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

Salida:

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

38
2017-08-29 02:17



Alternativamente usando lodash:

lodash.startCase(str);

Ejemplo:

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

Lodash es una buena biblioteca para dar acceso directo a muchas tareas cotidianas js. Hay muchas otras funciones similares de manipulación de cadenas, como camelCase, kebabCase etc.


36
2017-07-28 11:49



Ejemplo sin efectos secundarios

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

En ES6

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

17
2017-09-27 07:32



Aquí está mi versión de eso. Agrega un espacio antes de cada letra de UpperCase en inglés que viene después de una letra en inglés minúscula y también escribe en mayúscula la primera letra si es necesario:

Por ejemplo:
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;
  }

8
2018-05-26 13:47



Ok, llegué unos años tarde al juego, pero tenía una pregunta similar, y quería hacer una solución de reemplazo para cada entrada posible. Debo darle la mayor parte del crédito a @ZenMaster en este hilo y @Benjamin Udink ten Cate en esta hilo. Aquí está el código:

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

Tiene tres cláusulas, todas usan mirar hacia el futuro para evitar que el motor de expresiones regulares consuma demasiados caracteres:

  1. [A-Z](?=[A-Z][a-z]) busca una letra mayúscula seguida de una mayúscula y luego una minúscula. Esto es para poner fin a acrónimos como Estados Unidos.
  2. [^A-Z](?=[A-Z]) busca una letra que no sea mayúscula seguida de una letra mayúscula. Esto termina palabras como myWord y símbolos como 99Bottles.
  3. [a-zA-Z](?=[^a-zA-Z]) busca una carta seguida de una falta de letra. Esto termina las palabras antes de símbolos como BFG9000.

Esta pregunta estaba en la parte superior de mis resultados de búsqueda, ¡así que espero poder ahorrarle a los demás algo de tiempo!


4
2018-01-08 15:49



La mejor cadena que he encontrado para probar las funciones camel-case-to-title-case es este ridículamente absurdo ejemplo, que prueba muchos casos extremos. Que yo sepa, ninguna de las funciones publicadas anteriormente maneja esto correctamente:

ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersolidIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D

Esto se debe convertir a:

Para obtener su GED a tiempo Una canción sobre los 26 ABC es de la esencia, pero una tarjeta de identificación personal para el usuario 456 En la sala 26 A que contiene ABC 26 veces no es tan fácil como 123 para C3PO o R2D2 o 2R2D

Si solo desea una función simple que maneje casos como el anterior (y más casos que muchas de las respuestas anteriores), aquí está el que escribí. Este código no es particularmente elegante o rápido, pero es simple, comprensible y funciona.

Un ejemplo ejecutable en línea está aquí: http://jsfiddle.net/q5gbye2w/56/

// Take a single camel case string and convert it to a string of separate words (with spaces) at the camel-case boundaries.
// 
// E.g.:
//    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);
}

Alternativamente, como El usuario Barno sugirió, utilizando SugarJS es una solución fácil si no te importa ingresar a esa biblioteca. Sin embargo, no estoy seguro si maneja la cadena de prueba que describo arriba; No lo he intentado en esa entrada.


4
2018-03-12 03:14