CamelCaseText'i Cümle Büyük / Küçük Harf Metinine Dönüştür

JavaScript'te 'helloThere' veya 'HelloThere' gibi bir dizeyi 'Merhaba Orada' ya nasıl dönüştürebilirim?

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

ilk harfi büyük yaz - örnek olarak.

İçindeki boşluğa dikkat edin " $1".

DÜZENLEME: ilk harfin büyük yazılması örneği eklendi. Tabii ki, ilk harf zaten büyükse - kaldırmak için boş bir alanınız olacaktır.

Alternatif olarak, lodash kullanarak :

lodash.startCase(str);

Misal:

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

Lodash birçok hergün'ın js Tasks.There için gibi diğer birçok benzer dize düzenleme işlevlerini kısayol edilir vermek için iyi bir kütüphane camelCase, kebabCasevb

Ben benzer bir sorun vardı ve bunun gibi ele:

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

Daha sağlam bir çözüm için:

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

http://jsfiddle.net/PeYYQ/

Giriş:

 helloThere 
 HelloThere 
 ILoveTheUSA
 iLoveTheUSA

Çıktı:

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

Yan etkileri olmayan örnek.

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'da

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

Deve-case-to-title-case fonksiyonlarını test etmek için bulduğum en iyi dize, çok sayıda uç durumu test eden bu gülünç saçma örnek. Bildiğim kadarıyla, önceden gönderilen işlevlerin hiçbiri bunu doğru bir şekilde işlemez :

ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D

Bunun şuna dönüştürülmesi gerekir:

GED'inizi Zamanla Almak için 26 ABC Hakkında Bir Şarkı Özüdür Ama Oda 26A ABC 26 Kez İçeren Kullanıcı 456 için Kişisel Kimlik Kartı C3PO veya R2D2 veya 2R2D için 123 kadar kolay değildir

Yukarıdaki gibi vakaları (ve daha önce cevapların çoğundan daha fazla vakayı) ele alan basit bir işlev istiyorsanız, burada yazdım. Bu kod özellikle zarif veya hızlı değildir, ancak basit, anlaşılabilir ve çalışır.

Bir çevrimiçi katedilebilen örnek jsfiddle üzerindedir , ya da konsolda aşağıdaki pasajı çıktısını görebilirsiniz:

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

Yukarıdaki örneklerden birine dayanarak şunu buldum:

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

Benim için işe yarıyor çünkü .trim()ilk harfin büyük harflerle yazıldığı ve ekstra bir boşluk bıraktığınız kenar kasasını işlemek için kullanıyor .

Referans: https://developer.mozilla.org/tr-TR/docs/Web/JavaScript/Reference/Global_Objects/String/Trim

Tamam, oyuna birkaç yıl geç kaldım, ama benzer bir sorum vardı ve mümkün olan her giriş için tek yerine bir çözüm yapmak istedim. Ben de bu konuya ve @Benjamin Udink on Cate içinde @ZenMaster kredi çoğunu vermelidir bu konu. İşte kod:

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

Regex motorunun çok fazla karakter tüketmesini önlemek için ileriye doğru kullanan üç cümle vardır :

1. [A-Z](?=[A-Z][a-z])büyük harf ve ardından büyük harf olmak üzere büyük harf arar. Bu, ABD gibi kısaltmaları sonlandırmak içindir.
2. [^A-Z](?=[A-Z])büyük harf olmayan bir harf ve ardından büyük harf arar. Bu myWord gibi kelimeleri ve 99Bottles gibi sembolleri sona erdirir.
3. [a-zA-Z](?=[^a-zA-Z])harfi ve ardından harfi olmayan bir harf arar. Bu, kelimeler BFG9000 gibi sembollerden önce sona erer.

Bu soru arama sonuçlarımın tepesindeydi, umarım başkalarına biraz zaman kazandırabilirim!

İşte benim versiyonum. Küçük harfli bir İngiliz harfinden sonra gelen her UpperCase İngilizce harfinden önce bir boşluk ekler ve ayrıca gerekirse ilk harfi büyük yapar:

Örneğin:
thisIsCamelCase -> Bu Deve Kılıfı
Bu IsCamelCase -> Bu Deve Kılıfı
thisIsCamelCase123 -> Bu Deve Kılıfı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;
  }

Bu uygulama ardışık büyük harf ve sayıları dikkate alır.

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

Beklenen çıktı:

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

Bunun gibi bir işlev kullanabilirsiniz:

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"

Buradaki test dizelerini bir grupla kodlayın: http://jsfiddle.net/jfriend00/FWLuV/ .

Burada önde gelen alanları koruyan alternatif sürüm: http://jsfiddle.net/jfriend00/Uy2ac/ .

bu kütüphaneyi dene

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"

Yukarıdaki cevapların hiçbiri benim için mükemmel çalıştı, bu yüzden kendi bisikletiyle gelmek zorunda kaldı:

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

Test senaryoları:

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

Bu benim için işe yarar

CamelcaseToWord ( "Kimimben"); // İsmimi döndürüyor

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

Bu sadece reg exp /([a-z]|[A-Z]+)([A-Z])/gve değiştirme ile yapılabilir düşünüyorum "$1 $2".

ILoveTheUSADope -> ABD Uyuşturucusunu Seviyorum

Capital Camel Case ile ilgilenirseniz bu snippet size yardımcı olabilir, ayrıca sizin durumunuza uygun olduğundan emin olmak için bazı özellikler içerir.

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

Ve özellikleri:

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

Herkesin cevabını denemedim, ama uğraştığım birkaç çözüm tüm gereksinimlerime uymadı.

Yapan bir şey bulabildim ...

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

Aşağıda, regex kullanarak cümle dizesine deve durum dizesini gösteren bağlantı verilmiştir.

Giriş

myCamelCaseSTRINGToSPLITDemo

Çıktı

my Camel Case STRING To SPLIT Demo

Deve davasının cümle metnine dönüştürülmesi için normal ifade

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

ile $1 $2subsitution olarak.

Normal ifadedeki dönüşümü görüntülemek için tıklayın

JavaScript'i girin

Çıktı Java Komut Dosyası

   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 tabanlı bir çözüm daha.

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

açıklama

Yukarıdaki RegEx, OR operatörü tarafından ayrılmış iki benzer parçadan oluşur . İlk yarı:

1. ([A-Z]) - büyük harflerle eşleşir ...
2. (?=[A-Z][a-z]) - ardından büyük ve küçük harfler dizisi gelir.

FOo dizisine uygulandığında , bu onun F harfiyle etkili bir şekilde eşleşir .

Veya ikinci senaryo:

1. ([a-z]) - küçük harflerle eşleşir ...
2. (?=[A-Z]) - ardından büyük harf.

BarFoo sekansına uygulandığında , bu r harfiyle etkili bir şekilde eşleşir .

Tüm yedek adaylar bulunduğunda, yapılacak son şey, aynı harfle ancak ek boşluk karakteriyle değiştirilmesidir. Bunun için '$& 'bir yedek olarak kullanabiliriz ve eşleşen bir alt dizeye ve ardından bir boşluk karakterine çözümlenir.

Misal

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

Yukarıdaki birkaç düşünceden memnun kaldıktan sonra daha sevdiğim başka bir ES6 çözümü ekliyoruz.

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

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