web-dev-qa-db-de.com

CamelCaseText in Satzfalltext konvertieren

Wie kann ich eine Zeichenfolge wie "Hallo" oder "Hallo" in "Hallo dort" in JavaScript konvertieren?

91
HyderA
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.

Beachten Sie das Leerzeichen in " $1".

EDIT: Ein Beispiel für die Großschreibung des ersten Buchstabens wurde hinzugefügt. Falls der erste Buchstabe bereits Großbuchstaben ist, haben Sie natürlich freien Platz zum Entfernen.

109
ZenMaster

Alternativ mit lodash :

lodash.startCase(str);

Beispiel:

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

Lodash ist eine feine Bibliothek, die eine Abkürzung zu vielen alltäglichen Aufgaben von js bietet. Es gibt viele andere ähnliche Funktionen zur String-Bearbeitung wie camelCase, kebabCase usw.

52
Wtower

Ich hatte ein ähnliches Problem und behandelte es so:

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

Für eine robustere Lösung:

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

http://jsfiddle.net/PeYYQ/

Eingang:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

Ausgabe:

 hello There 
 Hello There 
 I Love The USA
 i Love The USA
41
James Khoury

Beispiel ohne Nebenwirkungen.

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

Hier ist meine Version davon. Vor jedem englischen Buchstaben in UpperCase, der nach einem Kleinbuchstaben in Kleinbuchstaben steht, wird ein Leerzeichen eingefügt, und bei Bedarf wird auch der erste Buchstabe groß geschrieben:

Zum Beispiel:
thisIsCamelCase -> Dies ist ein Kamelfall
this IsCamelCase -> Dies ist ein Kamel-Fall
thisIsCamelCase123 -> Dies ist ein Kamelfall123

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

Die beste Saite, die ich für das Testen von Kamel-Case-zu-Case-Case-Funktionen gefunden habe, ist dieses lächerlich unsinnige Beispiel, das viele Edge-Cases testet. Nach meinem besten Wissen kann keine der zuvor veröffentlichten Funktionen dies korrekt handhaben []:

ToGetYourGEDInTimeASongAboutThe26ABCsIstTheEssenceButAPersonalIDCardFürUser456InRoom26AnthaltenABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D

Dies sollte umgewandelt werden in:

Um Ihr GED rechtzeitig zu erhalten, ist ein Song über die 26 ABCs von der Essenz, aber ein persönlicher Ausweis für Benutzer 456 in Raum 26A, der 26 mal ABC enthält, ist nicht so einfach wie 123 für C3PO oder R2D2 oder 2R2D

Wenn Sie nur eine einfache Funktion haben möchten, die Fälle wie die oben genannten behandelt (und mehr Fälle als viele der vorherigen Antworten), haben wir hier eine von mir geschrieben. Dieser Code ist nicht besonders elegant oder schnell, aber er ist einfach und verständlich und funktioniert.

Ein online lauffähiges Beispiel dafür ist hier: 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);
}

Als user Barno schlug alternativ vor, dass die Verwendung von SugarJS eine einfache Lösung ist, wenn es Ihnen nichts ausmacht, diese Bibliothek einzulesen. Ich bin mir jedoch nicht sicher, ob er die oben beschriebene Testzeichenfolge verarbeitet. Ich habe es bei diesem Input nicht probiert.

7
Chris Kline

Ok, ich bin ein paar Jahre zu spät im Spiel, aber ich hatte eine ähnliche Frage und wollte für jeden möglichen Input eine One-Replacement-Lösung erstellen. Ich muss @ZenMaster in diesem Thread und @Benjamin Udink zehn Cate in this thread ..__ den Großteil der Anerkennung geben. Hier ist der Code:

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

Es enthält drei Klauseln, die alle mit lookahead verwenden, um zu verhindern, dass die Regex-Engine zu viele Zeichen verbraucht:

  1. [A-Z](?=[A-Z][a-z]) sucht nach einem Großbuchstaben, dem ein Großbuchstabe gefolgt von einem Kleinbuchstaben folgt. Damit werden Akronyme wie die USA beendet.
  2. [^A-Z](?=[A-Z]) sucht nach einem Nicht-Großbuchstaben, gefolgt von einem Großbuchstaben. Dies beendet Wörter wie meinWort und Symbole wie 99 Flaschen.
  3. [a-zA-Z](?=[^a-zA-Z]) sucht nach einem Buchstaben, gefolgt von einem Nichtbrief. Dies beendet Wörter vor Symbolen wie BFG9000.

Diese Frage stand ganz oben in meinen Suchergebnissen. Hoffentlich kann ich anderen Zeit sparen!

5

Sie können eine Funktion wie folgt verwenden:

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"

Code mit einigen Test-Strings hier: http://jsfiddle.net/jfriend00/FWLuV/ .

Alternative Version, die führende Leerzeichen hier hält: http://jsfiddle.net/jfriend00/Uy2ac/ .

3
jfriend00

Dies funktioniert für mich, überprüfen Sie dies

CamelcaseToWord ("MyName"); // gibt meinen Namen zurück

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

Basierend auf einem der oben genannten Beispiele kam ich dazu:

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

Es funktioniert für mich, weil es .trim() verwendet, um den Edge-Fall zu behandeln, bei dem der erste Buchstabe groß geschrieben wird und Sie ein zusätzliches führendes Leerzeichen erhalten. 

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

2
Anthony S.

probieren Sie diese Bibliothek aus

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"
2
Barno

Ich habe nicht alle Antworten ausprobiert, aber die wenigen Lösungen, mit denen ich gebastelt habe, entsprachen nicht allen meinen Anforderungen.

Ich konnte mir etwas einfallen, das tat ...

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(), 
              '')
1
Tabbyofjudah

Unten finden Sie einen Link, der die Verwendung von regulären Ausdrücken zwischen Groß- und Kleinschreibung demonstriert.

Eingang

myCamelCaseSTRINGToSPLITDemo

Ausgabe

my Camel Case STRING To SPLIT Demo


Dies ist ein regulärer Ausdruck für die Konvertierung von Groß- und Kleinschreibung in Satztext

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

mit $1 $2 als ersatz.

Klicken Sie, um die Konvertierung auf Regex anzuzeigen

1
Rahul

Ich denke, das kann man nur mit dem reg exp /([a-z]|[A-Z]+)([A-Z])/g und dem Ersetzen "$1 $2" machen.

ILoveTheUSADope -> Ich liebe die USA Dope

Keine der obigen Antworten funktionierte perfekt für mich und musste daher mit dem eigenen Fahrrad kommen:

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

Testfälle:

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

Eingabe JavaScript

Ausgabe Java Script

   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");
0
Manas