আমি জাভাস্ক্রিপ্ট রিজেক্স ব্যবহার করে কীভাবে একটি স্ট্রিংকে উটের ক্ষেত্রে রূপান্তর করতে পারি?
EquipmentClass name
বা
Equipment className
বা equipment class name
বাEquipment Class Name
সব হওয়া উচিত: equipmentClassName
।
আমি জাভাস্ক্রিপ্ট রিজেক্স ব্যবহার করে কীভাবে একটি স্ট্রিংকে উটের ক্ষেত্রে রূপান্তর করতে পারি?
EquipmentClass name
বা
Equipment className
বা equipment class name
বাEquipment Class Name
সব হওয়া উচিত: equipmentClassName
।
উত্তর:
আপনার কোডটি দেখে, আপনি কেবল দুটি replace
কল দিয়ে এটি অর্জন করতে পারবেন :
function camelize(str) {
return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
return index === 0 ? word.toLowerCase() : word.toUpperCase();
}).replace(/\s+/g, '');
}
camelize("EquipmentClass name");
camelize("Equipment className");
camelize("equipment class name");
camelize("Equipment Class Name");
// all output "equipmentClassName"
সম্পাদনা করুন: বা একটি একক replace
কল সহ, সাদা স্পেসগুলি ক্যাপচার করে RegExp
।
function camelize(str) {
return str.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, function(match, index) {
if (+match === 0) return ""; // or if (/\s+/.test(match)) for white spaces
return index === 0 ? match.toLowerCase() : match.toUpperCase();
});
}
camelize("Let's Do It!") === "let'SDoIt!"
দু: খিত মুখ । আমি নিজে চেষ্টা করব তবে ভয় করব যে আমি আরও একটি প্রতিস্থাপন যুক্ত করব।
return this.replace(/[^a-z ]/ig, '').replace(/(?:^\w|[A-Z]|\b\w|\s+)/g,
...
const toCamelCase = (str) => str.replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
.toLowerCase()
Eg যেমন Eg উপরে @ ট্যাব্রিন্ডেলের সমাধানটি ব্যবহার করুন:const toCamelCase = (str) => str.toLowerCase().replace(/(?:^\w|[A-Z]|\b\w)/g, (ltr, idx) => idx === 0 ? ltr.toLowerCase() : ltr.toUpperCase()).replace(/\s+/g, '');
যদি কেউ লোডাশ ব্যবহার করে তবে একটি _.camelCase()
ফাংশন রয়েছে।
_.camelCase('Foo Bar');
// → 'fooBar'
_.camelCase('--foo-bar--');
// → 'fooBar'
_.camelCase('__FOO_BAR__');
// → 'fooBar'
আমি এই কাজটি শেষ করেছি:
String.prototype.toCamelCase = function(str) {
return str
.replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
.replace(/\s/g, '')
.replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}
আমি একসাথে একাধিক প্রতিস্থাপনের বিবৃতিতে শৃঙ্খলা এড়ানোর চেষ্টা করছিলাম। আমার ফাংশনে যেখানে আমার I'd 1, $ 2, $ 3 থাকত। তবে এই ধরণের গোষ্ঠীকরণ বোঝা শক্ত এবং ক্রস ব্রাউজার সমস্যা সম্পর্কে আপনার উল্লেখ এমন কিছু যা আমি কখনও ভাবিনি।
this.valueOf()
পাস করার পরিবর্তে ব্যবহার করা উচিত str
। বিকল্পভাবে (আমার ক্ষেত্রে this.toLowerCase()
যেমন ) আমার ইনপুট স্ট্রিংগুলি সমস্ত ক্যাপগুলিতে ছিল যার নন-হ্যাম্প অংশগুলি সঠিকভাবে কম করা হয়নি ased কেবল this
স্ট্রিং অবজেক্টটি ব্যবহার করে নিজেই ফিরে আসে, যা আসলে চরের একটি অ্যারে, সুতরাং উপরে উল্লিখিত টাইপএররর।
আপনি এই সমাধানটি ব্যবহার করতে পারেন:
function toCamelCase(str){
return str.split(' ').map(function(word,index){
// If it is the first word make sure to lowercase all the chars.
if(index == 0){
return word.toLowerCase();
}
// If it is not the first word only upper case the first char and lowercase the rest.
return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
}).join('');
}
toCamelCase
ফাংশন ঠিক এটি করে।
পেতে গ amel সি ASE
ES5
var camalize = function camalize(str) {
return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
{
return chr.toUpperCase();
});
}
ES6
var camalize = function camalize(str) {
return str.toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, (m, chr) => chr.toUpperCase());
}
পেতে সি amel এস entence সি ASE বা পি ascal সি ASE
var camelSentence = function camelSentence(str) {
return (" " + str).toLowerCase().replace(/[^a-zA-Z0-9]+(.)/g, function(match, chr)
{
return chr.toUpperCase();
});
}
দ্রষ্টব্য:
উচ্চারণ সহ সেই ভাষার জন্য। À-ÖØ-öø-ÿ
নিম্নলিখিত হিসাবে রেজেক্স সঙ্গে অন্তর্ভুক্ত করবেন না
.replace(/[^a-zA-ZÀ-ÖØ-öø-ÿ0-9]+(.)/g
https://stackoverflow.com/posts/52551910/revisions
, আমি এটি পরীক্ষা করে দেখিনি। আমি পরীক্ষা করে আপডেট করব।
স্কটের নির্দিষ্ট ক্ষেত্রে আমি এই জাতীয় কিছু নিয়ে যাব:
String.prototype.toCamelCase = function() {
return this.replace(/^([A-Z])|\s(\w)/g, function(match, p1, p2, offset) {
if (p2) return p2.toUpperCase();
return p1.toLowerCase();
});
};
'EquipmentClass name'.toCamelCase() // -> equipmentClassName
'Equipment className'.toCamelCase() // -> equipmentClassName
'equipment class name'.toCamelCase() // -> equipmentClassName
'Equipment Class Name'.toCamelCase() // -> equipmentClassName
মূল চরিত্রের সাথে শুরু হয়ে এবং কোনও স্থানের পরে বর্ণানুক্রমিক বর্ণগুলি, যেমন নির্দিষ্ট স্ট্রিংগুলিতে 2 বা 3 বারের সাথে শুরু হয় তবে রেজেক্স প্রথম অক্ষরের সাথে মিলবে।
থেকে Regex আপ spicing দ্বারা /^([A-Z])|[\s-_](\w)/g
এটি হাইফেন এবং আন্ডারস্কোর টাইপ নামের camelize হবে।
'hyphen-name-format'.toCamelCase() // -> hyphenNameFormat
'underscore_name_format'.toCamelCase() // -> underscoreNameFormat
+
) যুক্ত করতে হবে , যেমন:/^([A-Z])|[\s-_]+(\w)/g
function toCamelCase(str) {
// Lower cases the string
return str.toLowerCase()
// Replaces any - or _ characters with a space
.replace( /[-_]+/g, ' ')
// Removes any non alphanumeric characters
.replace( /[^\w\s]/g, '')
// Uppercases the first character in each group immediately following a space
// (delimited by spaces)
.replace( / (.)/g, function($1) { return $1.toUpperCase(); })
// Removes spaces
.replace( / /g, '' );
}
আমি camelCase
একটি স্ট্রিংয়ের জন্য একটি জাভাস্ক্রিপ্ট ফাংশন সন্ধান করার চেষ্টা করছিলাম, এবং এটি নিশ্চিত করতে চেয়েছিলাম যে বিশেষ অক্ষরগুলি সরানো হবে (এবং উপরের উত্তরগুলির মধ্যে কিছু কী করছে তা বুঝতে আমার সমস্যা হয়েছিল)। এটি সিসি অল্পবয়সের উত্তরের উপর ভিত্তি করে যুক্ত করা মন্তব্য এবং $ পেসি ও এল অক্ষর অপসারণ করা হবে।
যদি রেজিপ্স্পের প্রয়োজন হয় না, আপনি টুইঙ্কলের জন্য আমি অনেক আগে তৈরি নীচের কোডটি দেখতে চাই :
String.prototype.toUpperCaseFirstChar = function() {
return this.substr( 0, 1 ).toUpperCase() + this.substr( 1 );
}
String.prototype.toLowerCaseFirstChar = function() {
return this.substr( 0, 1 ).toLowerCase() + this.substr( 1 );
}
String.prototype.toUpperCaseEachWord = function( delim ) {
delim = delim ? delim : ' ';
return this.split( delim ).map( function(v) { return v.toUpperCaseFirstChar() } ).join( delim );
}
String.prototype.toLowerCaseEachWord = function( delim ) {
delim = delim ? delim : ' ';
return this.split( delim ).map( function(v) { return v.toLowerCaseFirstChar() } ).join( delim );
}
আমি কোনও পারফরম্যান্স পরীক্ষা করিনি, এবং রেজিপ এক্স সংস্করণগুলি সম্ভবত আরও দ্রুত হতে পারে বা নাও পারে।
আমার ES6 পদ্ধতির:
const camelCase = str => {
let string = str.toLowerCase().replace(/[^A-Za-z0-9]/g, ' ').split(' ')
.reduce((result, word) => result + capitalize(word.toLowerCase()))
return string.charAt(0).toLowerCase() + string.slice(1)
}
const capitalize = str => str.charAt(0).toUpperCase() + str.toLowerCase().slice(1)
let baz = 'foo bar'
let camel = camelCase(baz)
console.log(camel) // "fooBar"
camelCase('foo bar') // "fooBar"
camelCase('FOO BAR') // "fooBar"
camelCase('x nN foo bar') // "xNnFooBar"
camelCase('!--foo-¿?-bar--121-**%') // "fooBar121"
return "hello world".toLowerCase().replace(/(?:(^.)|(\s+.))/g, function(match) {
return match.charAt(match.length-1).toUpperCase();
}); // HelloWorld
লোডাশ নিশ্চিত এবং ভাল কৌশলটি করতে পারে:
var _ = require('lodash');
var result = _.camelCase('toto-ce héros')
// result now contains "totoCeHeros"
যদিও lodash
এটি একটি "বড়" লাইব্রেরি (k 4 কেবি) হতে পারে তবে এতে প্রচুর ফাংশন রয়েছে যা আপনি সাধারণত একটি স্নিপেট ব্যবহার করতে বা নিজের তৈরি করতে চাই।
এখানে কাজ করার জন্য একটি লাইনার রয়েছে:
const camelCaseIt = string => string.toLowerCase().trim().split(/[.\-_\s]/g).reduce((string, word) => string + word[0].toUpperCase() + word.slice(1));
এটি রেজিএক্সপ্যাক্টে প্রদত্ত অক্ষরের তালিকার উপর ভিত্তি করে লোয়ার-কেসড স্ট্রিংগুলিকে বিভক্ত করে [.\-_\s]
([] এর ভিতরে আরও যুক্ত করুন!) এবং একটি শব্দের অ্যারে প্রদান করে। তারপরে, এটি স্ট্রিংগুলির অ্যারেটিকে বড় আকারের প্রথম অক্ষরের সাথে শব্দের একটি সংক্ষিপ্ত স্ট্রিংয়ে হ্রাস করে। হ্রাসটির কোনও প্রাথমিক মান নেই বলে এটি দ্বিতীয় শব্দের সাথে শুরু করে প্রথম অক্ষরগুলি বড়হাতে শুরু করবে।
আপনি যদি পাস্কেলকেস চান ,'')
তবে হ্রাস পদ্ধতিতে কেবল একটি প্রাথমিক খালি স্ট্রিং যুক্ত করুন ।
@ স্কটের পঠনযোগ্য পদ্ধতির অনুসরণ করে কিছুটা সূক্ষ্ম সুরকরণ
// যে কোনও স্ট্রিংকে উট কেসে রূপান্তর করুন var toCamelCase = ফাংশন (str) { str.toLowerCase () প্রত্যাবর্তন .replace (/ [''] / g, '') .re place (/ \ W + / g, '') .replace (/ (।) / g, ফাংশন ($ 1) {রিটার্ন করুন $ 1.touper কেস ();}) .replace (/ / g, ''); }
নীচের সমস্ত 14 ক্রমানুসারে "EquipmentClassName" একই ফলাফল উত্পাদন করে।
String.prototype.toCamelCase = function() {
return this.replace(/[^a-z ]/ig, '') // Replace everything but letters and spaces.
.replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, // Find non-words, uppercase letters, leading-word letters, and multiple spaces.
function(match, index) {
return +match === 0 ? "" : match[index === 0 ? 'toLowerCase' : 'toUpperCase']();
});
}
String.toCamelCase = function(str) {
return str.toCamelCase();
}
var testCases = [
"equipment class name",
"equipment class Name",
"equipment Class name",
"equipment Class Name",
"Equipment class name",
"Equipment class Name",
"Equipment Class name",
"Equipment Class Name",
"equipment className",
"equipment ClassName",
"Equipment ClassName",
"equipmentClass name",
"equipmentClass Name",
"EquipmentClass Name"
];
for (var i = 0; i < testCases.length; i++) {
console.log(testCases[i].toCamelCase());
};
আপনি এই সমাধানটি ব্যবহার করতে পারেন:
String.prototype.toCamelCase = function(){
return this.replace(/\s(\w)/ig, function(all, letter){return letter.toUpperCase();})
.replace(/(^\w)/, function($1){return $1.toLowerCase()});
};
console.log('Equipment className'.toCamelCase());
কারণ এই প্রশ্নের আরও একটি উত্তর প্রয়োজন ...
আমি পূর্ববর্তী কয়েকটি সমাধান সমাধান করে দেখেছি এবং তাদের সবার একটির ত্রুটি ছিল। কিছু বিরামচিহ্ন অপসারণ করেনি; কেউ কেউ সংখ্যা দিয়ে মামলা পরিচালনা করেনি; কিছু একটি সারিতে একাধিক বিরামচিহ্ন পরিচালনা করেনি।
তাদের কেউই এর মতো স্ট্রিং পরিচালনা করেনি a1 2b
। এই মামলার জন্য সুস্পষ্টভাবে সংজ্ঞায়িত কোনও কনভেনশন নেই, তবে কিছু অন্যান্য স্ট্যাকওভারফ্লো প্রশ্নগুলি আন্ডারস্কোর দিয়ে সংখ্যাগুলি পৃথক করার পরামর্শ দিয়েছে।
আমি সন্দেহ করি এটি সর্বাধিক পারফরম্যান্স উত্তর (তিনটি রেজেক্স এক বা দু'টির পরিবর্তে স্ট্রিং দিয়ে যায়) তবে আমি যে সমস্ত পরীক্ষাগুলি চিন্তা করতে পারি তা এটি পাস করে। সত্য কথা বলতে গেলে, আমি সত্যিই এমন কোনও ক্ষেত্রে কল্পনা করতে পারি না যেখানে আপনি এতগুলি উট-কেস রূপান্তর করছেন যা পারফরম্যান্সের জন্য গুরুত্বপূর্ণ।
(আমি এটি এনপিএম প্যাকেজ হিসাবে যুক্ত করেছি It এটিতে উটের কেসের পরিবর্তে পাস্কেল কেস ফিরিয়ে আনতে একটি alচ্ছিক বুলিয়ান প্যারামিটারও রয়েছে))
const underscoreRegex = /(?:[^\w\s]|_)+/g,
sandwichNumberRegex = /(\d)\s+(?=\d)/g,
camelCaseRegex = /(?:^\s*\w|\b\w|\W+)/g;
String.prototype.toCamelCase = function() {
if (/^\s*_[\s_]*$/g.test(this)) {
return '_';
}
return this.replace(underscoreRegex, ' ')
.replace(sandwichNumberRegex, '$1_')
.replace(camelCaseRegex, function(match, index) {
if (/^\W+$/.test(match)) {
return '';
}
return index == 0 ? match.trimLeft().toLowerCase() : match.toUpperCase();
});
}
পরীক্ষার কেস (জেস্ট)
test('Basic strings', () => {
expect(''.toCamelCase()).toBe('');
expect('A B C'.toCamelCase()).toBe('aBC');
expect('aB c'.toCamelCase()).toBe('aBC');
expect('abc def'.toCamelCase()).toBe('abcDef');
expect('abc__ _ _def'.toCamelCase()).toBe('abcDef');
expect('abc__ _ d_ e _ _fg'.toCamelCase()).toBe('abcDEFg');
});
test('Basic strings with punctuation', () => {
expect(`a'b--d -- f.h`.toCamelCase()).toBe('aBDFH');
expect(`...a...def`.toCamelCase()).toBe('aDef');
});
test('Strings with numbers', () => {
expect('12 3 4 5'.toCamelCase()).toBe('12_3_4_5');
expect('12 3 abc'.toCamelCase()).toBe('12_3Abc');
expect('ab2c'.toCamelCase()).toBe('ab2c');
expect('1abc'.toCamelCase()).toBe('1abc');
expect('1Abc'.toCamelCase()).toBe('1Abc');
expect('abc 2def'.toCamelCase()).toBe('abc2def');
expect('abc-2def'.toCamelCase()).toBe('abc2def');
expect('abc_2def'.toCamelCase()).toBe('abc2def');
expect('abc1_2def'.toCamelCase()).toBe('abc1_2def');
expect('abc1 2def'.toCamelCase()).toBe('abc1_2def');
expect('abc1 2 3def'.toCamelCase()).toBe('abc1_2_3def');
});
test('Oddball cases', () => {
expect('_'.toCamelCase()).toBe('_');
expect('__'.toCamelCase()).toBe('_');
expect('_ _'.toCamelCase()).toBe('_');
expect('\t_ _\n'.toCamelCase()).toBe('_');
expect('_a_'.toCamelCase()).toBe('a');
expect('\''.toCamelCase()).toBe('');
expect(`\tab\tcd`.toCamelCase()).toBe('abCd');
expect(`
ab\tcd\r
-_
|'ef`.toCamelCase()).toBe(`abCdEf`);
});
আমার সমাধান আছে:
const toCamelWord = (word, idx) =>
idx === 0 ?
word.toLowerCase() :
word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
const toCamelCase = text =>
text
.split(/[_-\s]+/)
.map(toCamelWord)
.join("");
console.log(toCamelCase('User ID'))
এই পদ্ধতিটি এখানে বেশিরভাগ উত্তরকে ছাড়িয়ে গেছে বলে মনে হচ্ছে, এটি সামান্য কিছুটা হ্যাকি, যদিও কোনও প্রতিস্থাপন নেই, কোনও রেজেক্স নয়, কেবল একটি নতুন স্ট্রিং তৈরি করছে যা উটের কেস।
String.prototype.camelCase = function(){
var newString = '';
var lastEditedIndex;
for (var i = 0; i < this.length; i++){
if(this[i] == ' ' || this[i] == '-' || this[i] == '_'){
newString += this[i+1].toUpperCase();
lastEditedIndex = i+1;
}
else if(lastEditedIndex !== i) newString += this[i].toLowerCase();
}
return newString;
}
এটি আন্ডারস্কোর সহ কোনও অ-বর্ণমালা অক্ষর মুছে ফেলার মধ্য দিয়ে সিএমএসের উত্তরের ভিত্তিতে তৈরি করে , যা \w
মুছে না।
function toLowerCamelCase(str) {
return str.replace(/[^A-Za-z0-9]/g, ' ').replace(/^\w|[A-Z]|\b\w|\s+/g, function (match, index) {
if (+match === 0 || match === '-' || match === '.' ) {
return ""; // or if (/\s+/.test(match)) for white spaces
}
return index === 0 ? match.toLowerCase() : match.toUpperCase();
});
}
toLowerCamelCase("EquipmentClass name");
toLowerCamelCase("Equipment className");
toLowerCamelCase("equipment class name");
toLowerCamelCase("Equipment Class Name");
toLowerCamelCase("Equipment-Class-Name");
toLowerCamelCase("Equipment_Class_Name");
toLowerCamelCase("Equipment.Class.Name");
toLowerCamelCase("Equipment/Class/Name");
// All output e
উচ্চতর উটের কেস ("টেস্টস্ট্রিং") থেকে রেটেক্স ব্যবহার না করে নিম্ন উটের ক্ষেত্রে ("টেস্টস্ট্রিং") (আসুন এটির মুখোমুখি হোন, রেজেক্সটি মন্দ):
'TestString'.split('').reduce((t, v, k) => t + (k === 0 ? v.toLowerCase() : v), '');
আমি আরও কিছুটা আক্রমণাত্মক সমাধান তৈরি করেছি:
function toCamelCase(str) {
const [first, ...acc] = str.replace(/[^\w\d]/g, ' ').split(/\s+/);
return first.toLowerCase() + acc.map(x => x.charAt(0).toUpperCase()
+ x.slice(1).toLowerCase()).join('');
}
এটি উপরে, সমস্ত অক্ষর অক্ষর এবং শব্দের ছোট অংশগুলিকে সরিয়ে ফেলবে যা অন্যথায় বড় থাকবে না, যেমন
Size (comparative)
=> sizeComparative
GDP (official exchange rate)
=> gdpOfficialExchangeRate
hello
=> hello
function convertStringToCamelCase(str){
return str.split(' ').map(function(item, index){
return index !== 0
? item.charAt(0).toUpperCase() + item.substr(1)
: item.charAt(0).toLowerCase() + item.substr(1);
}).join('');
}
আমার পরামর্শটি এখানে:
function toCamelCase(string) {
return `${string}`
.replace(new RegExp(/[-_]+/, 'g'), ' ')
.replace(new RegExp(/[^\w\s]/, 'g'), '')
.replace(
new RegExp(/\s+(.)(\w+)/, 'g'),
($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
)
.replace(new RegExp(/\s/, 'g'), '')
.replace(new RegExp(/\w/), s => s.toLowerCase());
}
অথবা
String.prototype.toCamelCase = function() {
return this
.replace(new RegExp(/[-_]+/, 'g'), ' ')
.replace(new RegExp(/[^\w\s]/, 'g'), '')
.replace(
new RegExp(/\s+(.)(\w+)/, 'g'),
($1, $2, $3) => `${$2.toUpperCase() + $3.toLowerCase()}`
)
.replace(new RegExp(/\s/, 'g'), '')
.replace(new RegExp(/\w/), s => s.toLowerCase());
};
পরীক্ষার কেস:
describe('String to camel case', function() {
it('should return a camel cased string', function() {
chai.assert.equal(toCamelCase('foo bar'), 'fooBar');
chai.assert.equal(toCamelCase('Foo Bar'), 'fooBar');
chai.assert.equal(toCamelCase('fooBar'), 'fooBar');
chai.assert.equal(toCamelCase('FooBar'), 'fooBar');
chai.assert.equal(toCamelCase('--foo-bar--'), 'fooBar');
chai.assert.equal(toCamelCase('__FOO_BAR__'), 'fooBar');
chai.assert.equal(toCamelCase('!--foo-¿?-bar--121-**%'), 'fooBar121');
});
});
আমি জানি এটি একটি পুরানো উত্তর, তবে এটি হোয়াইটস্পেস এবং _ উভয়ই পরিচালনা করে (লোডাশ)
function toCamelCase(s){
return s
.replace(/_/g, " ")
.replace(/\s(.)/g, function($1) { return $1.toUpperCase(); })
.replace(/\s/g, '')
.replace(/^(.)/, function($1) { return $1.toLowerCase(); });
}
console.log(toCamelCase("Hello world");
console.log(toCamelCase("Hello_world");
// Both print "helloWorld"
"
দেখা দেয় .replace(/_/g", " ")
যে সংকলন ত্রুটি ঘটায়?
সম্পাদনা : এখন কোনও পরিবর্তন ছাড়াই আইই 8 তে কাজ করছেন।
সম্পাদনা : উটকেস আসলে কী তা নিয়ে আমি সংখ্যালঘুতে ছিলাম (শীর্ষস্থানীয় চরিত্রের ছোট হাতের বনাম বনাম বড় হাতের অক্ষর)। সম্প্রদায়টি বিশ্বাস করে যে শীর্ষস্থানীয় ছোট হাতের অক্ষরটি উটের ক্ষেত্রে এবং একটি শীর্ষস্থানীয় মূলধনটি প্যাসকেল কেস। আমি দুটি ফাংশন তৈরি করেছি যা কেবলমাত্র রেজেক্স প্যাটার্ন ব্যবহার করে। :) সুতরাং আমরা একটি ইউনিফাইড শব্দভাণ্ডার ব্যবহার করি আমি সংখ্যাগরিষ্ঠের সাথে মেলে আমার অবস্থান পরিবর্তন করেছি।
আমি বিশ্বাস করি যে আপনার প্রয়োজন কেবল উভয় ক্ষেত্রেই একটি একক রেজেক্স:
var camel = " THIS is camel case "
camel = $.trim(camel)
.replace(/[^A-Za-z]/g,' ') /* clean up non-letter characters */
.replace(/(.)/g, function(a, l) { return l.toLowerCase(); })
.replace(/(\s.)/g, function(a, l) { return l.toUpperCase(); })
.replace(/[^A-Za-z\u00C0-\u00ff]/g,'');
// Returns "thisIsCamelCase"
অথবা
var pascal = " this IS pascal case "
pascal = $.trim(pascal)
.replace(/[^A-Za-z]/g,' ') /* clean up non-letter characters */
.replace(/(.)/g, function(a, l) { return l.toLowerCase(); })
.replace(/(^.|\s.)/g, function(a, l) { return l.toUpperCase(); })
.replace(/[^A-Za-z\u00C0-\u00ff]/g,'');
// Returns "ThisIsPascalCase"
ফাংশনগুলিতে: আপনি লক্ষ্য করবেন যে এই ফাংশনগুলিতে প্রতিস্থাপনটি কোনও ফাঁকা স্ট্রিং বনাম একটি স্থানের সাথে কোনও অ অজ অদলবদল করছে। এটি মূলধনের জন্য শব্দ সীমানা তৈরি করা। "হ্যালো-আমার # বিশ্ব" -> "হ্যালোমাই ওয়ার্ল্ড"
// remove \u00C0-\u00ff] if you do not want the extended letters like é
function toCamelCase(str) {
var retVal = '';
retVal = $.trim(str)
.replace(/[^A-Za-z]/g, ' ') /* clean up non-letter characters */
.replace(/(.)/g, function (a, l) { return l.toLowerCase(); })
.replace(/(\s.)/g, function (a, l) { return l.toUpperCase(); })
.replace(/[^A-Za-z\u00C0-\u00ff]/g, '');
return retVal
}
function toPascalCase(str) {
var retVal = '';
retVal = $.trim(str)
.replace(/[^A-Za-z]/g, ' ') /* clean up non-letter characters */
.replace(/(.)/g, function (a, l) { return l.toLowerCase(); })
.replace(/(^.|\s.)/g, function (a, l) { return l.toUpperCase(); })
.replace(/[^A-Za-z\u00C0-\u00ff]/g, '');
return retVal
}
মন্তব্য:
উপভোগ করুন
আমি এই কাজ করা উচিত..
function cammelCase(str){
let arr = str.split(' ');
let words = arr.filter(v=>v!='');
words.forEach((w, i)=>{
words[i] = w.replace(/\w\S*/g, function(txt){
return txt.charAt(0).toUpperCase() + txt.substr(1);
});
});
return words.join('');
}
স্ট্রিং.প্রোটোটাইপ. টো ক্যামেলকেস () ব্যবহার করবেন না কারণ স্ট্রিং.প্রোটোটাইপগুলি কেবল পঠনযোগ্য, বেশিরভাগ জেএস সংকলক আপনাকে এই সতর্কতা দেবে।
আমার মতো, যারা জানেন যে স্ট্রিংয়ে সর্বদা কেবলমাত্র একটি স্থান থাকবে একটি সহজ পদ্ধতির ব্যবহার করতে পারে:
let name = 'test string';
let pieces = name.split(' ');
pieces = pieces.map((word, index) => word.charAt(0)[index===0 ? 'toLowerCase' :'toUpperCase']() + word.toLowerCase().slice(1));
return pieces.join('');
আপনার দিনটি শুভ হোক. :)