camelCaseText를 문장 케이스 텍스트로 변환

JavaScript에서 'helloThere'또는 'HelloThere'를 'Hello There'로 변환하는 방법은 무엇입니까?

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

첫 글자를 대문자로-예를 들어.

의 공백에 유의하십시오 " $1".

편집 : 첫 글자의 대문자 예를 추가했습니다. 물론 첫 번째 문자가 이미 대문자 인 경우 제거 할 여유 공간이 있습니다.

또는 lodash 사용 :

lodash.startCase(str);

예:

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

Lodash 많은 일상 JS tasks.There에 같은 다른 많은 유사한 문자열 조작 함수 바로 가기를하는주는 훌륭한 라이브러리 camelCase, kebabCase등

비슷한 문제가 있었고 다음과 같이 처리했습니다.

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

보다 강력한 솔루션 :

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

http://jsfiddle.net/PeYYQ/

입력:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

산출:

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

부작용이없는 예.

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

ES6에서

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

낙타-대-대-제목-사례 함수를 테스트하기 위해 찾은 최고의 문자열은 엄청나게 비이성적 인 예입니다. 내가 아는 한, 이전에 게시 된 함수는 이것을 올바르게 처리하지 않습니다 .

GEDInTime ASong에 대해 26ABCs에 대한 에센스 그러나 AP4 사용자 ID 카드에 대한 456 개의 실습실 26ACC26 시간에 대한 NotAsEasyAs123ForC3POOrR2D2Or2R2D

이것은 다음으로 변환되어야합니다.

시간에 당신의 GED를 얻기 위해 26 ABC에 관한 노래는 본질이지만 사용자 26에 대한 개인 ID 카드 ABC 26 시간을 포함하는 26A 방 26A에있는 C3PO 또는 R2D2 또는 2R2D를 위해 123만큼 쉽지 않습니다

위와 같은 경우 (그리고 이전의 많은 답변보다 많은 경우)를 처리하는 간단한 함수를 원한다면 여기에 내가 쓴 것이 있습니다. 이 코드는 특별히 우아하거나 빠르지는 않지만 간단하고 이해 가능하며 작동합니다.

온라인 실행 가능한 예는 jsfiddle에 , 또는 당신은 당신의 콘솔에서 아래의 코드 조각의 출력을 볼 수 있습니다 :

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

위의 예 중 하나를 기반으로 나는 이것을 생각해 냈습니다.

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

.trim()첫 글자가 대문자로 끝나고 여분의 선행 공간이있는 가장자리 케이스를 처리하는 데 사용되기 때문에 그것은 나를 위해 작동 합니다.

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

좋아, 나는 게임에 몇 년 늦었지만 비슷한 질문이 있었고 가능한 모든 입력에 대해 하나의 대체 솔루션을 만들고 싶었습니다. 나는이 스레드 @Benjamin Udink 열 케이트에 @ZenMaster에 신용의 대부분을 부여해야 이 스레드. 코드는 다음과 같습니다.

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

정규식 엔진이 너무 많은 문자를 사용하지 못하도록 lookahead 를 사용하는 세 개의 절이 있습니다 .

1. [A-Z](?=[A-Z][a-z])대문자와 대문자, 대문자를 찾습니다. 이것은 미국처럼 두문자어를 끝내는 것입니다.
2. [^A-Z](?=[A-Z])대문자가 아닌 대문자를 찾습니다. 그러면 myWord와 같은 단어와 99Bottles와 같은 기호가 끝납니다.
3. [a-zA-Z](?=[^a-zA-Z])문자가 아닌 문자를 찾습니다. BFG9000과 같은 기호 앞의 단어가 끝납니다.

이 질문은 검색 결과의 최상위에 있었으므로 다른 사람들도 시간을 절약 할 수 있기를 바랍니다.

여기 내 버전이 있습니다. 소문자 영어 문자 뒤에 오는 모든 대문자 영어 문자 앞에 공백을 추가하고 필요한 경우 첫 문자를 대문자로 만듭니다.

예를 들면 다음과 같습니다.
thisIsCamelCase-> 이것은 낙타 케이스입니다
IsCamelCase-> 이것은 낙타 케이스입니다
thisIsCamelCase123-> 이것은 낙타 케이스 123입니다

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

이 구현은 연속적인 대문자와 숫자를 고려합니다.

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

예상 출력 :

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

다음과 같은 기능을 사용할 수 있습니다.

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"

http://jsfiddle.net/jfriend00/FWLuV/ 에 테스트 문자열이 많은 코드가 있습니다 .

여기 선행 공백을 유지 대체 버전 : http://jsfiddle.net/jfriend00/Uy2ac/ .

이 라이브러리를 사용해보십시오

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"

위의 답변 중 어느 것도 나를 위해 완벽하게 작동하지 않았으므로 자체 자전거와 함께 제공해야했습니다.

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

테스트 사례 :

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

이것은 나를 위해 작동합니다.

CamelcaseToWord ( "내 이름"); // 내 이름을 반환

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

나는 이것이 정규 표현식 /([a-z]|[A-Z]+)([A-Z])/g과 교체 로 수행 할 수 있다고 생각합니다 "$1 $2".

ILoveTheUSADope-> 나는 미국 마약을 좋아한다

Capital Camel Case 를 다루는 경우이 스 니펫이 도움이 될 수 있으며 일부 사양이 포함되어 있으므로 사례와 적절하게 일치하는지 확인할 수 있습니다.

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

그리고 사양 :

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

나는 모든 사람의 대답을 시도하지는 않았지만 내가 생각한 몇 가지 솔루션이 모든 요구 사항과 일치하지는 않았습니다.

나는 무언가를 생각 해낼 수있었습니다 ...

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

아래는 정규식을 사용하여 낙타 문자 문자열을 문장 문자열로 보여주는 링크입니다.

입력

myCamelCaseSTRINGToSPLITDemo

산출

my Camel Case STRING To SPLIT Demo

이것은 낙타 사건을 문장 텍스트로 변환하는 정규식입니다.

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

와 $1 $2subsitution있다.

정규식에서 전환을 보려면 클릭하십시오

자바 스크립트 입력

출력 자바 스크립트

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

RegEx를 기반으로 한 추가 솔루션.

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

설명

위의 RegEx는 OR 연산자로 구분 된 두 개의 유사한 부분으로 구성됩니다 . 상반기 :

1. ([A-Z]) -대문자와 일치합니다 ...
2. (?=[A-Z][a-z]) -대문자와 소문자로 구성됩니다.

시퀀스 FOo에 적용하면 F 문자 와 효과적으로 일치합니다 .

또는 두 번째 시나리오 :

1. ([a-z]) -소문자와 일치합니다 ...
2. (?=[A-Z]) -대문자가 뒤 따릅니다.

시퀀스 barFoo에 적용하면 r 문자 와 효과적으로 일치합니다 .

대체 후보를 모두 찾았을 때 마지막으로해야 할 일은 동일한 문자로 대체 문자를 추가하는 것입니다. 이를 위해 '$& '대체로 사용할 수 있으며 일치하는 하위 문자열과 공백 문자가 뒤 따릅니다.

예

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"]

위의 몇 가지 생각에 만족하지 않아서 더 좋아하는 ES6 솔루션을 추가했습니다.

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

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