반응형
camel Case 변환Text to Title 대문자 텍스트
JavaScript에서 'HelloThere' 또는 'HelloThere'와 같은 문자열을 'HelloThere'로 변환하려면 어떻게 해야 합니까?
const text = 'helloThereMister';
const result = text.replace(/([A-Z])/g, " $1");
const finalResult = result.charAt(0).toUpperCase() + result.slice(1);
console.log(finalResult);을 사용법「」의 ." $1".
물론 첫 번째 글자가 이미 대문자인 경우에는 제거할 여유 공간이 있습니다.
또는 lodash 사용:
lodash.startCase(str);
예:
_.startCase('helloThere');
// ➜ 'Hello There'
Lodash는 많은 일상적인 js 태스크에 바로 가기 기능을 제공하는 훌륭한 라이브러리입니다.에도 비슷한 .camelCase,kebabCasesyslog.
저도 비슷한 문제가 있어서 이렇게 대처했습니다.
stringValue.replace(/([A-Z]+)*([A-Z][a-z])/g, "$1 $2")
보다 견고한 솔루션:
stringValue.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1")
입력:
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())
.trim();
camel-case-to-title-case 함수를 테스트하기 위해 찾은 최고의 문자열은 많은 엣지 케이스를 테스트하는 터무니없이 터무니없는 예입니다.내가 아는 한 이전에 게시된 기능 중 이를 올바르게 처리하는 기능은 없습니다.
__Get Your GEDIn Time(To Get Your GEDIn Time)ASong About The 26ABC Is Of The Essence ButAP 퍼스널IDCardForUser_456InRoom26AContaining ABC26TimesIsNotAsEasyAs123ForC3POOR2D2Or2R2D
이 값은 다음과 같이 변환해야 합니다.
26개의 ABC에 관한 노래는 필수지만, 26개의 ABC가 포함된 룸 26A의 사용자용 개인 ID카드는 C3PO, R2D2 또는 2DR의 123만큼 간단하지 않습니다.
위의 예와 같은 간단한 기능(및 이전 답변보다 더 많은 예)을 원하는 경우, 제가 쓴 것은 다음과 같습니다.이 코드는 특별히 우아하거나 빠르지는 않지만 단순하고 이해하기 쉬우며 작동합니다.
다음 부분에는 온라인 실행 가능한 예가 나와 있습니다.
var mystrings = [ "__ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser_456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D", "helloThere", "HelloThere", "ILoveTheUSA", "iLoveTheUSA", "DBHostCountry", "SetSlot123ToInput456", "ILoveTheUSANetworkInTheUSA", "Limit_IOC_Duration", "_This_is_a_Test_of_Network123_in_12__days_", "ASongAboutTheABCsIsFunToSing", "CFDs", "DBSettings", "IWouldLove1Apple", "Employee22IsCool", "SubIDIn", "ConfigureABCsImmediately", "UseMainNameOnBehalfOfSubNameInOrders" ];
// Take a single camel case string and convert it to a string of separate words (with spaces) at the camel-case boundaries.
//
// E.g.:
// __ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser_456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D
// --> 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 --> I 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 // "__ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser_456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D"
.replace(/(_)+/g, ' ') // " ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser 456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D"
.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() // "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"
;
// capitalize the first letter
return result.charAt(0).toUpperCase() + result.slice(1);
}
for (var i = 0; i < mystrings.length; i++) {
jQuery(document.body).append("<br />\"");
jQuery(document.body).append(camelCaseToTitleCase(mystrings[i]));
jQuery(document.body).append("\"<br>(was: \"");
jQuery(document.body).append(mystrings[i]);
jQuery(document.body).append("\") <br />");
}<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.2.3/jquery.min.js"></script>위의 예 중 하나를 바탕으로 다음과 같은 것을 생각해 냈습니다.
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
네, 몇 년 늦었지만 비슷한 질문이 있어서 가능한 모든 입력에 대해 원치환 솔루션을 만들고 싶었어요.저는 이 스레드에서는 @ZenMaster, 이 스레드에서는 @Benjamin Udink ten Kate에게 대부분의 공을 돌려야 합니다.코드는 다음과 같습니다.
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 < textArray.length; i++){
text = textArray[i];
text = text.replace(camelEdges,'$1 ');
text = text.charAt(0).toUpperCase() + text.slice(1);
resultArray.push(text);
}
여기에는 3개의 구가 있으며, 모두 lookahead를 사용하여 regex 엔진이 너무 많은 문자를 소비하지 않도록 합니다.
[A-Z](?=[A-Z][a-z])는 대문자와 소문자 뒤에 이어지는 대문자를 찾습니다.이것은 USA와 같은 줄임말을 끝내기 위한 것입니다.[^A-Z](?=[A-Z])는 대문자가 아닌 문자 뒤에 대문자가 이어지는 것을 찾습니다.myWord 99병[a-zA-Z](?=[^a-zA-Z])는 문자 뒤에 문자가 없는 문자를 찾습니다.BFG9000은 BFG9000입니다.
이 질문이 검색 결과의 상위에 있었기 때문에, 다른 사람에게 시간을 절약해 주었으면 합니다.
여기 제 버전이 있습니다.영문 소문자 뒤에 오는 모든 대문자 영문자 앞에 공백이 추가되며 필요에 따라 첫 글자도 대문자로 표시됩니다.
를 들면, '먹다'와 같이요.
Camel Case --> 케이스입니다 --> 카멜 케이스입니다.
Case --> Case Is Camel Case --> Camel Case > Camel Case 。
이것은 카멜 케이스 123 --> 카멜 케이스 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/
캐피털 카멜 케이스를 취급하는 경우는, 이 스니펫이 도움이 됩니다.또, 고객의 케이스에 적절한 사양이 기재되어 있습니다.
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')
})
})
이 라이브러리를 사용해 보세요.
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"
RegEx를 기반으로 한 또 하나의 솔루션.
respace(str) {
const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g;
return str.replace(regex, '$& ');
}
설명.
위의 RegEx는 OR 연산자에 의해 분리된 두 개의 유사한 부품으로 구성됩니다.전반부:
([A-Z])- 대문자 일치...(?=[A-Z][a-z])- 대소문자가 .
시퀀스 FOO에 적용하면 F 문자와 효과적으로 일치합니다.
또는 두 번째 시나리오:
([a-z])- 소문자 일치...(?=[A-Z])- 대문자. - 대문자.
시퀀스 bar Foo에 적용하면 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"]
JS의 String.protype.replace() 및 String.protype.toUpperCase() 사용
const str = "thisIsATestString";
const res = str.replace(/^[a-z]|[A-Z]/g, (c, i) => (i? " " : "") + c.toUpperCase());
console.log(res); // "This Is A Test String"원하는 대로 동작하는 스플릿 케이스 솔루션:
const splitCase = s => !s || s.indexOf(' ') >= 0 ? s :
(s.charAt(0).toUpperCase() + s.substring(1))
.split(/(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g)
.map(x => x.replace(/([0-9]+)/g,'$1 '))
.join(' ')
입력
'a,abc,TheId,TheID,TheIDWord,TheID2Word,Leave me Alone!'
.split(',').map(splitCase)
.forEach(x => console.log(x))
산출량
A
Abc
The Id
The ID
The ID Word
The ID2 Word
Leave me Alone!
위의 함수는 현재 Safari에서 구현되지 않은 JS에서 Lookbehind가 필요하기 때문에 아래 RegEx를 사용하지 않도록 구현을 다시 작성했습니다.
const isUpper = c => c >= 'A' && c <= 'Z'
const isDigit = c => c >= '0' && c <= '9'
const upperOrDigit = c => isUpper(c) || isDigit(c)
function splitCase(s) {
let to = []
if (typeof s != 'string') return to
let lastSplit = 0
for (let i=0; i<s.length; i++) {
let c = s[i]
let prev = i>0 ? s[i-1] : null
let next = i+1 < s.length ? s[i+1] : null
if (upperOrDigit(c) && (!upperOrDigit(prev) || !upperOrDigit(next))) {
to.push(s.substring(lastSplit, i))
lastSplit = i
}
}
to.push(s.substring(lastSplit, s.length))
return to.filter(x => !!x)
}
위의 답변 중 어느 것도 나에게 완벽하게 맞지 않았기 때문에 자전거를 가지고 와야 했다.
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("MyName"); // 내 이름을 반환합니다.
function CamelcaseToWord(string){
return string.replace(/([A-Z]+)/g, " $1").replace(/([A-Z][a-z])/g, " $1");
}
나는 모두의 대답을 시도하지 않았지만, 내가 만지작거린 몇 가지 해결책이 나의 모든 요구 사항을 충족시키지 못했다.
난 뭔가 할 수 있는 걸 생각해 낼 수 있었어...
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(),
'')
reg exp만으로 할 수 있을 것 같아요./([a-z]|[A-Z]+)([A-Z])/g및 교환"$1 $2".
ILove The USADope -> I Love The USA Dop
연속되는 대문자와 소문자 단어에 가장 적합한 답은 다음과 같습니다.
const text = 'theKD';
const result = text.replace(/([A-Z]{1,})/g, " $1");
const finalResult = result.charAt(0).toUpperCase() + result.slice(1);
console.log(finalResult);- 또, 이 제품은,
The KD변환되지 않습니다.The K D.
다음은 regex를 사용하여 camel 대소문자열을 문장 문자열로 표시하는 링크입니다.
입력
myCamelCaseSTRINGToSPLITDemo
산출량
my Camel Case STRING To SPLIT Demo
이것은 camel 대소문자를 문장 텍스트로 변환하기 위한 regex입니다.
(?=[A-Z][a-z])|([A-Z]+)([A-Z][a-rt-z][a-z]\*)
와 함께$1 $2침하로서.
자바스크립트 입력
Java 스크립트 출력
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");
HTTPRequest_ToServer-AndWaiting --> HTTP Request To Server And Waiting
function toSpaceCase(str) {
return str
.replace(/[-_]/g, ' ')
/*
* insert a space between lower & upper
* HttpRequest => Http Request
*/
.replace(/([a-z])([A-Z])/g, '$1 $2')
/*
* space before last upper in a sequence followed by lower
* XMLHttp => XML Http
*/
.replace(/\b([A-Z]+)([A-Z])([a-z])/, '$1 $2$3')
// uppercase the first character
.replace(/^./, str => str.toUpperCase())
.replace(/\s+/g, ' ')
.trim();
}
const input = 'HTTPRequest_ToServer-AndWaiting';
const result = toSpaceCase(input);
console.log(input,'-->', result)비밀리에 C프로그래머를 고용했어나처럼 머리글자를 유지하고 암호 패턴을 보고 싶지 않다면 다음과 같이 하십시오.
function isUpperCase (str) {
return str === str.toUpperCase()
}
export function camelCaseToTitle (str) {
for (let i = str.length - 1; i > 0; i--) {
if (!isUpperCase(str[i - 1]) && isUpperCase(str[i])) {
str = str.slice(0, i) + ' ' + str.slice(i)
}
}
return str.charAt(0).toUpperCase() + str.slice(1)
}
이 솔루션은 [A-Z] 범위에 포함되지 않는 다른 유니코드 문자에도 사용할 수 있습니다.예: ,, ,, ,.
let camelCaseToTitleCase = (s) => (
s.split("").reduce(
(acc, letter, i) => (
i === 0 || console.log(acc, letter, i)
? [...acc, letter.toUpperCase()]
: letter === letter.toUpperCase()
? [...acc, " ", letter]
: [...acc, letter]
), []
).join("")
)
const myString = "ArchipelagoOfÅland"
camelCaseToTitleCase(myString)
위의 몇 가지 생각에 만족하지 못하고 마음에 들었던 ES6 솔루션을 추가.
https://codepen.io/902Labs/pen/mxdxRv?editors=0010#0
const camelize = (str) => str
.split(' ')
.map(([first, ...theRest]) => (
`${first.toUpperCase()}${theRest.join('').toLowerCase()}`)
)
.join(' ');
언급URL : https://stackoverflow.com/questions/7225407/convert-camelcasetext-to-title-case-text
반응형
'source' 카테고리의 다른 글
| Java에서 파일 크기를 가져오는 방법 (0) | 2022.11.26 |
|---|---|
| 도커 ufw를 호스트 시스템에 연결 (0) | 2022.11.26 |
| PHP의 ==는 대소문자를 구분하는 문자열 비교입니까? (0) | 2022.11.26 |
| 플라스크 마개: 어떻게 작동하는지 이해할 수 없습니다. (0) | 2022.11.26 |
| 스프링 MVC 유형 변환: PropertyEditor 또는 Converter? (0) | 2022.11.26 |