将驼峰大小写文本转换为标题大小写文本
Convert camelCaseText to Title Case Text
如何在JavaScript中将像"helloThere"或"HelloThere"这样的字符串转换为"Hello There"？
const text = 'helloThereMister';
const result = text.replace(/([A-Z])/g, " $1");
const finalResult = result.charAt(0).toUpperCase() + result.slice(1);
console.log(finalResult);将第一个字母大写 - 例如。请注意 " $1" 中的空格。
这里有一个打字稿函数也可以做到这一点：
function camelCaseToWords(s: string) {
const result = s.replace(/([A-Z])/g, ' $1');
return result.charAt(0).toUpperCase() + result.slice(1);
}
当然，如果第一个字母已经是大写字母 - 您将有一个多余的空间可以删除。
或者使用 lodash：
lodash.startCase(str);
例：
_.startCase('helloThere');
// ➜ 'Hello There'
Lodash 是一个很好的库，可以为许多日常 js 任务提供快捷方式。还有许多其他类似的字符串操作函数，如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())
.trim();
我发现的用于测试驼峰大小写到标题大小写函数的最佳字符串是这个荒谬无意义的示例，它测试了很多边缘情况。据我所知，以前发布的函数都没有正确处理这个问题：
__ToGetYourGEDInTimeASongAboutThe26ABCsIsOfTheEssenceButAPersonalIDCardForUser_456InRoom26AContainingABC26TimesIsNotAsEasyAs123ForC3POOrR2D2Or2R2D
这应该转换为：
为了及时获得您的 GED，一首关于 26 个 ABC 的歌曲至关重要，但包含 ABC 26 次的用户 456 的个人身份证并不像 C3PO 或 R2D2 或 2R2D 的 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 Cate。代码如下：
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);
}
它有三个子句，都使用前瞻来防止正则表达式引擎消耗太多字符：
-
[A-Z](?=[A-Z][a-z])查找一个大写字母，后跟大写字母，然后是小写字母。这是为了结束像美国这样的首字母缩略词。 -
[^A-Z](?=[A-Z])查找一个非大写字母，后跟一个大写字母。这结束了像myWord这样的单词和像99Bottles这样的符号。 -
[a-zA-Z](?=[^a-zA-Z])寻找一个字母，后跟一个非字母。这结束了像BFG9000这样的符号之前的单词。
这个问题在我的搜索结果中名列前茅，所以希望我能为其他人节省一些时间！
这是我
的版本。它会在每个小写英文字母之后的大写英文字母之前添加一个空格，并在需要时将第一个字母大写：
例如：
这是骆驼案 --> 这是骆驼案
这个是骆驼案 --> 这是骆驼案
这是骆驼案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/。
另一个基于正则表达式的解决方案。
respace(str) {
const regex = /([A-Z])(?=[A-Z][a-z])|([a-z])(?=[A-Z])/g;
return str.replace(regex, '$& ');
}
解释
上面的正则表达式由两个由 OR 运算符分隔的相似部分组成。上半场：
-
([A-Z])- 匹配大写字母... -
(?=[A-Z][a-z])- 后跟一系列大写和小写字母。
当应用于序列FOo时，这有效地匹配其F字母。
或者第二种情况：
-
([a-z])- 匹配小写字母... -
(?=[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"]
如果您处理资本骆驼案例，此代码段可以为您提供帮助，它还包含一些规范，因此您可以确保它与您的案例相匹配。
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')
})
})
使用 JS 的 String.prototype.replace(( 和 String.prototype.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!
由于上面的函数需要在 JS 中查找，而目前尚未在 Safari 中实现，因此我重写了实现以不使用下面的正则表达式：
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)
}
试试这个库
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"
连续大写单词最兼容的答案是：
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。
上面的答案都不适合我，所以不得不自带自行车：
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"(;//返回 My Name
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(),
'')
这可以通过注册 exp /([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')
// add space between numbers and letters: Col1 => Col 1
.replace(/([a-zA-Z])([0-9])/g, '$1 $2').replace(/([0-9])([a-zA-Z])/g, '$1 $2')
// uppercase the first character
.replace(/^./, firstChar => firstChar.toUpperCase())
// replace multiple whitespaces with one
.replace(/'s+/g, ' ')
.trim();
}
console.log('HTTPRequest_ToServer-AndWaiting','->', toSpaceCase('HTTPRequest_ToServer-AndWaiting'))
console.log('simple','->', toSpaceCase('simple'))
console.log('testCol1','->', toSpaceCase('testCol1'))下面是使用正则表达式演示驼峰大小写字符串到句子字符串的链接。
输入
myCamelCaseSTRINGToSPLITDemo
输出
my Camel Case STRING To SPLIT Demo
这是将骆驼大小写转换为句子文本的正则表达式
(?=[A-Z][a-z])|([A-Z]+)([A-Z][a-rt-z][a-z]'*)
以$1 $2作为替代。
单击以查看正则表达式上的转换
输入JavaScript
输出爪哇脚本
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");
卧
底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] 范围内的其他 Unicode 字符。 例如 ä、ö、å。
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)
.replace(/([a-z])([A-Z])/g, '$1 $2')
.replace(/([A-Z]+)([A-Z][a-z]+)/g, '$1 $2')
.replace(/^./, m => m.toUpperCase())
第一个RE：将"xyzABCDef"替换为"xyz ABCDef">
第二个RE：将"xyz ABCDef"替换为"xyz ABC Def">
第三个：大写首字母
添加另一个 ES6 解决方案，在对上面的一些想法不满意之后，我更喜欢它。
https://codepen.io/902Labs/pen/mxdxRv?editors=0010#0
const camelize = (str) => str
.split(' ')
.map(([first, ...theRest]) => (
`${first.toUpperCase()}${theRest.join('').toLowerCase()}`)
)
.join(' ');
相关文章：
- 如何使用jquery在填充自动完成的值后使文本框只读
- 使用Clipboard.js复制span文本
- 使用JS如何动态更改显示的html文件中的文本背景颜色
- 用程序搜索JQuery数据表中的文本
- jQuery匹配JSON对象的部分文本
- 将文本更改为驼色大小写
- :包含不区分大小写的解决方案在替换文本以突出显示时不起作用
- 替换*variable*文本，但保留大小写
- 对文本框强制执行大小写约束
- 使搜索文本框输入值不区分大小写
- 如何使大小写为区分大小写的文本输入
- 无论大小写，请检查文本框中是否有单词
- 替换文本但保留大小写
- 基于文本输入的重定向，不区分大小写
- 将驼峰大小写文本转换为标题大小写文本
- 如何在javascript中突出显示相等的忽略大小写搜索文本记录
- 垂直翻转文本，保留文本的大小写
- JQuery-OnKeyPress输入文本标题大小写
- 在文本框中搜索不区分大小写的字母
- 单击按钮时，输入文本需要更改大小写.为此创建 JS 时遇到问题
