Chuyển đổi camelCaseText thành văn bản trường hợp câu

Làm cách nào tôi có thể chuyển đổi một chuỗi như 'helloThere' hoặc 'HelloThere' thành 'Hello there' trong JavaScript?

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

viết hoa chữ cái đầu tiên - làm ví dụ.

Lưu ý không gian trong " $1".

EDIT: thêm một ví dụ về viết hoa của chữ cái đầu tiên. Tất nhiên, trong trường hợp chữ cái đầu tiên đã có vốn - bạn sẽ có một không gian trống để xóa.

Hoặc sử dụng lodash :

lodash.startCase(str);

Thí dụ:

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

Lodash là một thư viện tốt để cung cấp lối tắt cho nhiều tác vụ js hàng ngày. Có nhiều hàm thao tác chuỗi tương tự khác camelCase, kebabCasev.v.

Tôi đã có một vấn đề tương tự và xử lý nó như thế này:

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

Đối với một giải pháp mạnh mẽ hơn:

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

http://jsfiddle.net/PeYYQ/

Đầu vào:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

Đầu ra:

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

Ví dụ không có tác dụng phụ.

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

Trong ES6

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

Chuỗi tốt nhất mà tôi đã tìm thấy để kiểm tra các chức năng trường hợp lạc đà-tiêu đề là ví dụ vô lý lố bịch này, kiểm tra rất nhiều trường hợp cạnh. Theo hiểu biết tốt nhất của tôi, không có chức năng nào được đăng trước đó xử lý chính xác điều này :

ToGetYourGEDInTimeASong Hướng dẫn

Điều này nên được chuyển đổi thành:

Để có được GED của bạn đúng lúc Một bài hát về 26 ABC là điều cốt yếu nhưng Thẻ ID cá nhân cho người dùng 456 Trong phòng 26A Có ABC 26 lần không dễ như 123 đối với C3PO hoặc R2D2 hoặc 2R2D

Nếu bạn chỉ muốn một hàm đơn giản xử lý các trường hợp như trường hợp trên (và nhiều trường hợp hơn nhiều câu trả lời trước đó), thì đây là bài tôi đã viết. Mã này không đặc biệt thanh lịch hoặc nhanh chóng, nhưng nó đơn giản, dễ hiểu và hoạt động.

Một ví dụ có thể chạy trực tuyến là trên jsfiddle hoặc bạn có thể xem đầu ra của đoạn trích bên dưới trong bảng điều khiển của mình:

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

Dựa trên một trong những ví dụ trên tôi đã đưa ra điều này:

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

Nó hoạt động với tôi bởi vì nó sử dụng .trim()để xử lý trường hợp cạnh trong đó chữ cái đầu tiên được viết hoa và bạn kết thúc với một không gian hàng đầu.

Tham khảo: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

Ok, tôi trễ trò chơi vài năm, nhưng tôi có một câu hỏi tương tự, và tôi muốn đưa ra giải pháp thay thế cho mọi đầu vào có thể. Tôi phải cung cấp phần lớn tín dụng cho @ZenMaster trong chuỗi này và @Benjamin Udink ten Cate trong chuỗi này . Đây là mã:

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

Nó có ba mệnh đề, tất cả đều sử dụng lookahead để ngăn công cụ regex tiêu thụ quá nhiều ký tự:

1. [A-Z](?=[A-Z][a-z])tìm kiếm một chữ cái viết hoa theo sau là một chữ cái viết thường. Điều này là để kết thúc các từ viết tắt như Hoa Kỳ.
2. [^A-Z](?=[A-Z])tìm kiếm một chữ cái không viết hoa và theo sau là chữ in hoa Điều này kết thúc các từ như myWord và các biểu tượng như 99Bottles.
3. [a-zA-Z](?=[^a-zA-Z])tìm kiếm một lá thư theo sau là một lá thư Điều này kết thúc các từ trước các ký hiệu như BFG9000.

Câu hỏi này nằm ở đầu kết quả tìm kiếm của tôi, vì vậy hy vọng tôi có thể tiết kiệm thời gian cho người khác!

Đây là phiên bản của tôi. Nó thêm một khoảng trắng trước mỗi chữ cái tiếng Anh UpperCase xuất hiện sau một chữ cái tiếng Anh viết thường và cũng viết hoa chữ cái đầu tiên nếu cần:

Ví dụ:
thisIsCamelCase -> Đây là Vỏ lạc đà Đây là
IsCamelCase -> Đây là Vỏ lạc đà
thisIsCamelCase123 -> Đây là Vỏ lạc đà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;
  }

Việc thực hiện này có các chữ cái và số viết hoa liên tiếp được xem xét.

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

Sản lượng dự kiến:

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

Bạn có thể sử dụng một chức năng như thế này:

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"

Mã với một chuỗi các chuỗi thử nghiệm ở đây: http://jsfiddle.net/jfriend00/FWLuV/ .

Phiên bản thay thế giữ các không gian hàng đầu tại đây: http://jsfiddle.net/jfriend00/Uy2ac/ .

thử thư viện này

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"

Không có câu trả lời nào ở trên hoàn hảo với tôi, vì vậy phải đi kèm với xe đạp riêng:

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

Các trường hợp thử nghiệm:

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

Điều này làm việc cho tôi kiểm tra này

CamelcaseToWord ("MyName"); // trả về Tên của tôi

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

Tôi nghĩ rằng điều này có thể được thực hiện chỉ với reg exp /([a-z]|[A-Z]+)([A-Z])/gvà thay thế "$1 $2".

ILoveTheUSADope -> Tôi yêu Dope Hoa Kỳ

Nếu bạn giao dịch với Capital Camel Case , đoạn trích này có thể giúp bạn, nó cũng chứa một số thông số kỹ thuật để bạn có thể chắc chắn rằng nó phù hợp với trường hợp của bạn.

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

Và thông số kỹ thuật:

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

Tôi đã không thử câu trả lời của mọi người, nhưng một vài giải pháp mà tôi đã nghiên cứu không phù hợp với tất cả các yêu cầu của tôi.

Tôi đã có thể nghĩ ra thứ gì đó đã ...

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

Dưới đây là liên kết thể hiện chuỗi trường hợp lạc đà đến chuỗi câu bằng regex.

Đầu vào

myCamelCaseSTRINGToSPLITDemo

Đầu ra

my Camel Case STRING To SPLIT Demo

Đây là regex để chuyển đổi trường hợp lạc đà thành văn bản câu

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

với $1 $2tư cách là hiến pháp

Nhấn vào đây để xem chuyển đổi trên regex

Nhập javaScript

Tập lệnh Java đầu ra

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

Thêm một giải pháp dựa trên RegEx.

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

Giải trình

RegEx ở trên bao gồm hai phần tương tự được phân tách bằng toán tử OR . Nửa đầu:

1. ([A-Z]) - khớp với chữ in hoa ...
2. (?=[A-Z][a-z]) - theo sau là một chuỗi các chữ cái viết hoa và chữ thường.

Khi được áp dụng cho chuỗi FOo , điều này thực sự phù hợp với chữ F của nó .

Hoặc kịch bản thứ hai:

1. ([a-z]) - khớp với chữ cái viết thường ...
2. (?=[A-Z]) - theo sau là một chữ cái viết hoa.

Khi được áp dụng cho chuỗi barFoo , điều này thực sự phù hợp với chữ r của nó .

Khi tất cả các ứng cử viên thay thế đã được tìm thấy, điều cuối cùng cần làm là thay thế chúng bằng cùng một chữ cái nhưng với một ký tự khoảng trắng bổ sung. Đối với điều này, chúng ta có thể sử dụng '$& 'như là một thay thế, và nó sẽ phân giải thành một chuỗi con phù hợp theo sau là một ký tự khoảng trắng.

Thí dụ

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

Thêm một giải pháp ES6 khác mà tôi thích hơn sau khi không hài lòng với một vài suy nghĩ ở trên.

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

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