ජාවාස්ක්‍රිප්ට් හි නූලක ලොකු අකුරක පළමු අකුර සාදා ගන්නේ කෙසේද?

නූලක ලොකු අකුරක පළමු අකුර සාදා ගන්නේ කෙසේද, නමුත් වෙනත් අක්ෂරවල නඩුව වෙනස් නොකරන්නේ කෙසේද?

උදාහරණයක් වශයෙන්:

• "this is a test" -> "This is a test"
• "the Eiffel Tower" -> "The Eiffel Tower"
• "/index.html" -> "/index.html"

මූලික විසඳුම:

function capitalizeFirstLetter(string) {
  return string.charAt(0).toUpperCase() + string.slice(1);
}

console.log(capitalizeFirstLetter('foo')); // Foo

තවත් සමහර පිළිතුරු වෙනස් කරයි String.prototype(මෙම පිළිතුර ද භාවිතා කර ඇත), නමුත් නඩත්තු කිරීමේ හැකියාව නිසා මම දැන් එයට එරෙහිව උපදෙස් දෙමි (ශ්‍රිතය කොතැනට එකතු වේදැයි සොයා ගැනීමට අපහසු වන අතර prototypeවෙනත් කේත එකම නමක් / බ්‍රව්සරයක් භාවිතා කරන්නේ නම් ගැටුම් ඇති විය හැක. අනාගතයේදී එම නම සමඟම ස්වදේශීය ශ්‍රිතයක් එක් කරයි).

... එවිට, ජාත්‍යන්තරකරණය සලකා බැලීමේදී මෙම ප්‍රශ්නයට තවත් බොහෝ දේ ඇත, මෙම විශ්මය ජනක හොඳ පිළිතුර ලෙස (පහත වළලනු ලැබේ) පෙන්නුම් කරයි.

කේත ඒකක වෙනුවට යුනිකෝඩ් කේත ලක්ෂ්‍ය සමඟ වැඩ කිරීමට ඔබට අවශ්‍ය නම් (නිදසුනක් ලෙස මූලික බහුභාෂා ගුවන්යානයෙන් පිටත යුනිකෝඩ් අක්ෂර හැසිරවීමට) ඔබට String#[@iterator]කේත ලක්ෂ්‍ය සමඟ ක්‍රියා කරන කාරණය උත්තේජනය කළ හැකි අතර , ඔබට toLocaleUpperCaseස්ථානීය-නිවැරදි ඉහළ අකුරු ලබා ගැනීමට භාවිතා කළ හැකිය:

function capitalizeFirstLetter([ first, ...rest ], locale = navigator.language) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

console.log(capitalizeFirstLetter('foo')); // Foo
console.log(capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉")); // "𐐎𐐲𐑌𐐼𐐲𐑉" (correct!)
console.log(capitalizeFirstLetter("italya", 'tr')); // İtalya" (correct in Turkish Latin!)

ඊටත් වඩා ජාත්‍යන්තරකරණ විකල්ප සඳහා, කරුණාකර පහත මුල් පිළිතුර බලන්න .

මෙන්න වඩාත් වස්තු-නැඹුරු ප්‍රවේශයකි:

String.prototype.capitalize = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

ඔබ ශ්‍රිතය අමතන්නේ, මේ ආකාරයට ය:

"hello world".capitalize();

අපේක්ෂිත ප්‍රතිදානය සමඟ:

"Hello world" 

CSS හි:

p:first-letter {
    text-transform:capitalize;
}

නූල් අරාව ලෙස සලකමින් පළමු අකුර ලබා ගන්නා ජනප්‍රිය පිළිතුරේ කෙටි අනුවාදය මෙන්න:

function capitalize(s)
{
    return s[0].toUpperCase() + s.slice(1);
}

යාවත්කාලීන කිරීම:

පහත දැක්වෙන අදහස් වලට අනුව මෙය IE 7 හෝ ඊට පහළින් ක්‍රියා නොකරයි.

යාවත්කාලීන 2:

undefinedහිස් නූල් වලක්වා ගැනීම සඳහා (පහත j njzk2 ගේ අදහස බලන්න ), ඔබට හිස් නූලක් පරීක්ෂා කළ හැකිය:

function capitalize(s)
{
    return s && s[0].toUpperCase() + s.slice(1);
}

පළ කරන ලද විවිධ ක්‍රම කිහිපයක ක්‍රියාකාරිත්වය ගැන ඔබ උනන්දු නම්:

මෙම jsperf පරීක්ෂණය මත පදනම් වූ වේගවත්ම ක්‍රම මෙන්න (වේගවත් සිට මන්දගාමී දක්වා ඇණවුම් කර ඇත).

ඔබට පෙනෙන පරිදි, පළමු ක්‍රම දෙක කාර්ය සාධනය අනුව සැසඳිය හැකි අතර, එය වෙනස් String.prototypeකිරීම කාර්ය සාධනය අනුව මන්දගාමී වේ.

// 10,889,187 operations/sec
function capitalizeFirstLetter(string) {
    return string[0].toUpperCase() + string.slice(1);
}

// 10,875,535 operations/sec
function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

// 4,632,536 operations/sec
function capitalizeFirstLetter(string) {
    return string.replace(/^./, string[0].toUpperCase());
}

// 1,977,828 operations/sec
String.prototype.capitalizeFirstLetter = function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

තවත් අවස්ථාවකට පළමු අකුර කැපිටල් කර ඉතිරි කොටස කුඩා කිරීමට මට එය අවශ්‍ය වේ. පහත දැක්වෙන අවස්ථා නිසා මෙම කාර්යය වෙනස් කිරීමට මට හැකි විය:

//es5
function capitalize(string) {
    return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
}
capitalize("alfredo")  // => "Alfredo"
capitalize("Alejandro")// => "Alejandro
capitalize("ALBERTO")  // => "Alberto"
capitalize("ArMaNdO")  // => "Armando"

// es6 using destructuring 
const capitalize = ([first,...rest]) => first.toUpperCase() + rest.join('').toLowerCase();

මෙය 2018 ECMAScript 6+ විසඳුමයි :

const str = 'the Eiffel Tower';
const newStr = `${str[0].toUpperCase()}${str.slice(1)}`;
console.log('Original String:', str); // the Eiffel Tower
console.log('New String:', newStr); // The Eiffel Tower

ඔබ දැනටමත් භාවිතා කරන්නේ නම් (හෝ සලකා බලමින්) lodash, විසඳුම පහසුය:

_.upperFirst('fred');
// => 'Fred'

_.upperFirst('FRED');
// => 'FRED'

_.capitalize('fred') //=> 'Fred'

ඔවුන්ගේ ලියකියවිලි බලන්න: https://lodash.com/docs#capitalize

_.camelCase('Foo Bar'); //=> 'fooBar'

https://lodash.com/docs/4.15.0#camelCase

_.lowerFirst('Fred');
// => 'fred'

_.lowerFirst('FRED');
// => 'fRED'

_.snakeCase('Foo Bar');
// => 'foo_bar'

පළමු ඉහළ නඩුව සඳහා වැනිලා ජේඑස්:

function upperCaseFirst(str){
    return str.charAt(0).toUpperCase() + str.substring(1);
}

සියලුම වචනවල පළමු අකුරක් ලොකු අකුරකින් කැපිටල් කරන්න:

function ucFirstAllWords( str )
{
    var pieces = str.split(" ");
    for ( var i = 0; i < pieces.length; i++ )
    {
        var j = pieces[i].charAt(0).toUpperCase();
        pieces[i] = j + pieces[i].substr(1);
    }
    return pieces.join(" ");
}

අපට පළමු චරිතය මගේ ප්‍රියතම එකක් සමඟ ලබා ගත හැකිය RegExp, එය හුරුබුහුටි සිනහවක් සේ පෙනේ:/^./

String.prototype.capitalize = function () {
  return this.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

සහ සියලු කෝපි-ජුන්කි සඳහා:

String::capitalize = ->
  @replace /^./, (match) ->
    match.toUpperCase()

... සහ දේශීය මූලාකෘති දිගු නොකර මෙය කිරීමට වඩා හොඳ ක්‍රමයක් ඇතැයි සිතන සියලුම පිරිමි ළමයින් සඳහා:

var capitalize = function (input) {
  return input.replace(/^./, function (match) {
    return match.toUpperCase();
  });
};

භාවිත:

var str = "ruby java";

console.log(str.charAt(0).toUpperCase() + str.substring(1));

එය "Ruby java"කොන්සෝලය වෙත ප්‍රතිදානය කරනු ඇත.

ඔබ underscore.js හෝ Lo-Dash භාවිතා කරන්නේ නම් , undererscore.string පුස්තකාලය ප්‍රාග්ධනීකරණය ඇතුළුව නූල් දිගු සපයයි:

_.capitalize (string) නූලෙහි පළමු අකුර ලොකු අකුරට පරිවර්තනය කරයි.

උදාහරණයක්:

_.capitalize("foo bar") == "Foo bar"

String.prototype.capitalize = function(allWords) {
   return (allWords) ? // if all words
      this.split(' ').map(word => word.capitalize()).join(' ') : //break down phrase to words then  recursive calls until capitalizing all words
      this.charAt(0).toUpperCase() + this.slice(1); // if allWords is undefined , capitalize only the first word , mean the first char of the whole string
}

ඊළගට:

 "capitalize just the first word".capitalize(); ==> "Capitalize just the first word"
 "capitalize all words".capitalize(true); ==> "Capitalize All Words"

FUN සඳහා නොවැම්බර් 2016 (ES6) යාවත්කාලීන කරන්න:

const capitalize = (string = '') => [...string].map(    //convert to array with each item is a char of string by using spread operator (...)
    (char, index) => index ? char : char.toUpperCase()  // index true means not equal 0 , so (!index) is the first char which is capitalized by `toUpperCase()` method
 ).join('')                                             //return back to string

එවිට capitalize("hello") // Hello

කෙටිම විසඳුම් 3, sනූල් ඇති විට 1 සහ 2 අවස්ථා හසුරුවන්න "", nullසහ undefined:

 s&&s[0].toUpperCase()+s.slice(1)        // 32 char

 s&&s.replace(/./,s[0].toUpperCase())    // 36 char - using regexp

'foo'.replace(/./,x=>x.toUpperCase())    // 31 char - direct on string, ES6

let s='foo bar';

console.log( s&&s[0].toUpperCase()+s.slice(1) );

console.log( s&&s.replace(/./,s[0].toUpperCase()) );

console.log( 'foo bar'.replace(/./,x=>x.toUpperCase()) );

ප්‍රතිස්ථාපනය කිරීමෙන් එය ක්‍රියාත්මක කිරීමට ඉතා සරල ක්‍රමයක් තිබේ . ECMAScript 6 සඳහා:

'foo'.replace(/^./, str => str.toUpperCase())

ප්‍රති ult ලය:

'Foo'

CSS පමණි

p::first-letter {
  text-transform: uppercase;
}

• නමින් තිබියදීත් ::first-letter, එය පළමු අදාළ චරිතය එනම් string වූ අවස්ථාවක, %aමෙම තේරීම් සඳහා අදාල වනු ඇත %එම නිසා ඒවාa ප්රාග්ධනිත වන්නේ නැහැ.
• IE9 + හෝ IE5.5 + හි එය එක් මහා බඩවැලක් ( :first-letter) සමඟ පමණක් උරුම අංකනය සඳහා සහය දක්වයි .

ES2015 එක් ලයිනර්

පිළිතුරු රාශියක් ඇති නමුත් ES2015 හි මුල් ගැටළුව කාර්යක්ෂමව විසඳිය හැකි කිසිවක් නොමැති බැවින් මම පහත සඳහන් කරුණු ඉදිරිපත් කළෙමි.

const capitalizeFirstChar = str => str.charAt(0).toUpperCase() + str.substring(1);

සටහන්

• parameters => functionඊතල ශ්‍රිතය ලෙස හැඳින්වේ .
• මම ගියේ නම capitalizeFirstCharවෙනුවටcapitalizeFirstLetter , මන්දයත් OP විසින් සම්පූර්ණ නූලෙහි පළමු අකුර කැපිටල් කේතයක් ඉල්ලා නොසිටි නමුත් පළමු වර්‍ගය (එය අකුර නම්, ඇත්ත වශයෙන්ම).
• const ප්‍රකාශ කිරීමේ හැකියාව අපට ලබා දෙයි capitalizeFirstCharනියතයක් ලෙස , ක්‍රමලේඛකයෙකු ලෙස ඔබ සැමවිටම ඔබේ අභිප්‍රායයන් පැහැදිලිව ප්‍රකාශ කළ යුතුය.
• මා විසින් සිදු කරන ලද මිණුම් ලකුණෙහි string.charAt(0)සහ අතර සැලකිය යුතු වෙනසක් නොමැත string[0]. සටහන කෙසේ වෙතත්, එම string[0]වනු ඇත undefinedහිස් අගයක් සඳහා, එම නිසා එය කිරීමට නැවත ලිව යුතුstring && string[0] , විකල්ප සාපේක්ෂව ද විස්ථරාත්මක මගක් වන.
• string.substring(1)වඩා වේගවත් string.slice(1).

මිණුම් ලකුණ

• මෙම විසඳුම සඳහා 4,956,962 ops / s ± 3.03%,
• 4,577,946 ops / s ± 1.2% වැඩිපුරම ඡන්දය දුන් පිළිතුර සඳහා.
• ගූගල් ක්‍රෝම් 57 හි JSBench.me සමඟ නිර්මාණය කරන ලදි .

තාරකා තල කේත ලක්ෂ්‍යවලට අදාළ ගැටළු වල දැනට පවතින පිළිතුරු වල කිසිදු සඳහනක් මා දුටුවේ නැත ජාත්‍යන්තරකරණය . ලබා දී ඇති ස්ක්‍රිප්ට් එකක් භාවිතා කරමින් “ලොකු අකුරු” යනු සෑම භාෂාවකම එකම දේ නොවේ.

තාරකා තල කේත ලක්ෂ්‍ය හා සම්බන්ධ ගැටළු වලට මුලදී මම පිළිතුරු දුටුවේ නැත. එහි එක් (මෙම එක් වනු ඇත වැනි මම හිතන්නේ!), නමුත්, එය ටිකක් තැන්පත් වෙනවා

යෝජිත කාර්යයන් බොහොමයක් මේ ආකාරයෙන් පෙනේ:

function capitalizeFirstLetter(str) {
  return str[0].toUpperCase() + str.slice(1);
}

කෙසේ වෙතත්, සමහර අක්ෂර අක්ෂර BMP වලින් පිටත වැටේ (මූලික බහුභාෂා තලය, කේත ලකුණු U + 0 සිට U + FFFF දක්වා). උදාහරණයක් ලෙස මෙම Deseret පා take ය ගන්න:

capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉"); // "𐐶𐐲𐑌𐐼𐐲𐑉"

මෙහි පළමු අක්‍ෂරය ප්‍රාග්ධනීකරණය කිරීමට අසමත් වන්නේ නූල් වල අරාව-සුචිගත කරන ලද ගුණාංග “අක්ෂර” හෝ කේත ලක්ෂ්‍යවලට ප්‍රවේශ නොවන බැවිනි. ඔවුන් UTF-16 කේත ඒකක වලට ප්‍රවේශ වේ. පෙති කපන විටද මෙය සත්‍ය වේ - දර්ශක අගයන් කේත ඒකක වෙත යොමු වේ.

එය සිදුවන්නේ යූටීඑෆ් -16 කේත ඒකක 1: 1 ක් වන අතර යූඑස්වී කේත ලක්ෂ්‍ය පරාස දෙකක් තුළ ය, යූ + 0 සිට යූ + ඩී 7 එෆ්එෆ් සහ යූ + ඊ 1000 සිට යූ + එෆ්එෆ්එෆ්එෆ් ඇතුළත් වේ. බොහෝ අක්ෂර අක්ෂර එම පරාස දෙකට වැටේ, නමුත් ඒවා සියල්ලම නොවේ.

ES2015 සිට මේ සමඟ කටයුතු කිරීම ටිකක් පහසු විය. String.prototype[@@iterator]කේත ලකුණු වලට අනුරූප නූල් ලබා දෙයි **. උදාහරණයක් ලෙස, අපට මෙය කළ හැකිය:

function capitalizeFirstLetter([ first, ...rest ]) {
  return [ first.toUpperCase(), ...rest ].join('');
}

capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

දිගු නූල් සඳහා, මෙය බොහෝ විට කාර්යක්ෂම නොවේ *** - ඉතිරි කොටස නැවත කියවීමට අපට අවශ්‍ය නැත. අපට භාවිතා කළ හැකියString.prototype.codePointAtඑම පළමු (හැකි) ලිපිය ලබා ගැනීමට කළ හැකිය, නමුත් පෙත්ත ආරම්භ විය යුත්තේ කොතැනින්ද යන්න අපට තවමත් තීරණය කළ යුතුය. ඉතිරිය නැවත නොකිරීමට එක් ක්‍රමයක් නම් පළමු කේත ලක්ෂ්‍යය BMP වලින් පිටත දැයි පරීක්ෂා කිරීමයි; එය එසේ නොවේ නම්, පෙත්ත 1 න් ආරම්භ වන අතර, එසේ නම්, පෙත්ත 2 න් ආරම්භ වේ.

function capitalizeFirstLetter(str) {
  const firstCP = str.codePointAt(0);
  const index = firstCP > 0xFFFF ? 2 : 1;

  return String.fromCodePoint(firstCP).toUpperCase() + str.slice(index);
}

capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

ඔබට > 0xFFFFඑහි වෙනුවට බිට්වයිස් ගණිතය භාවිතා කළ හැකිය , නමුත් බොහෝ විට මේ ආකාරයෙන් තේරුම් ගැනීම පහසු වන අතර එක්කෝ එකම දේ සාක්ෂාත් කර ගනු ඇත.

අවශ්‍ය නම් එම තර්කය තව ටිකක් ඉදිරියට ගෙන යාමෙන් අපට ES5 සහ ඊට පහළින් මෙම කාර්යය කළ හැකිය. කේත ලක්ෂ්‍ය සමඟ වැඩ කිරීම සඳහා ES5 හි සහජ ක්‍රම නොමැත, එබැවින් පළමු කේත ඒකකය අන්‍යාගමිකද යන්න අප විසින් අතින් පරීක්ෂා කළ යුතුය ****:

function capitalizeFirstLetter(str) {
  var firstCodeUnit = str[0];

  if (firstCodeUnit < '\uD800' || firstCodeUnit > '\uDFFF') {
    return str[0].toUpperCase() + str.slice(1);
  }

  return str.slice(0, 2).toUpperCase() + str.slice(2);
}

capitalizeFirstLetter("𐐶𐐲𐑌𐐼𐐲𐑉") // "𐐎𐐲𐑌𐐼𐐲𐑉"

ආරම්භයේ දී මම ජාත්‍යන්තරකරණ සලකා බැලීම් ද සඳහන් කළෙමි. මේවායින් සමහරක් ගණනය කිරීම ඉතා අපහසු වන්නේ ඔවුන්ට දැනුම පමණක් අවශ්‍ය නොවන බැවිනි කුමක් ගැන භාෂාව භාවිතා කොට ඇත, පමණක් නොව, භාෂාව යන වචන නිශ්චිත දැනුම අවශ්ය විය හැක. උදාහරණයක් ලෙස, අයර්ලන්ත ඩිග්‍රැෆ් "mb" වචනයේ ආරම්භයේදීම "mB" ලෙස ප්‍රාග්ධනීකරණය කරයි. තවත් උදාහරණයක්, ජර්මානු එසෙට්, කිසි විටෙක වචනයක් (අෆයික්) ආරම්භ නොකරයි, නමුත් ගැටලුව නිරූපණය කිරීමට තවමත් උපකාරී වේ. සිම්පල් එසෙට් (“ß”) “එස්එස්” ලෙස ප්‍රාග්ධනීකරණය කරයි, නමුත් “එස්එස්” ට “ß” හෝ “එස්එස්” ලෙස කුඩා කළ හැකිය - නිවැරදි දේ දැන ගැනීමට ඔබට ජර්මානු භාෂාව පිළිබඳ බාහිර දැනුමක් අවශ්‍ය වේ!

මේ ආකාරයේ ගැටළු වලට වඩාත්ම ප්‍රසිද්ධ උදාහරණය බොහෝ විට තුර්කි ය. තුර්කි ලතින් භාෂාවෙන්, i හි ප්‍රාග්ධන ස්වරූපය is වන අතර, මගේ කුඩා අකුර is වේ - ඒවා වෙනස් අක්ෂර දෙකකි. වාසනාවකට අපට මේ සඳහා ගණන් දිය හැකි ක්‍රමයක් තිබේ:

function capitalizeFirstLetter([ first, ...rest ], locale) {
  return [ first.toLocaleUpperCase(locale), ...rest ].join('');
}

capitalizeFirstLetter("italy", "en") // "Italy"
capitalizeFirstLetter("italya", "tr") // "İtalya"

බ්‍රව්සරයක, පරිශීලකයාගේ වඩාත්ම කැමති භාෂා ටැගය මඟින් දක්වනු ලැබේ navigator.language, මනාප අනුපිළිවෙලින් ලැයිස්තුවක් සොයාගත හැකි අතර navigator.languages, ලබා දී ඇති DOM මූලද්‍රව්‍යයේ භාෂාව Object(element.closest('[lang]')).lang || YOUR_DEFAULT_HEREබහු භාෂා ලේඛන සමඟ (සාමාන්‍යයෙන්) ලබා ගත හැකිය .

ES2018 හි හඳුන්වා දුන් RegExp හි යුනිකෝඩ් දේපල චරිත පංති සඳහා සහය දක්වන නියෝජිතයින් තුළ, අප උනන්දු වන චරිත මොනවාදැයි කෙලින්ම ප්‍රකාශ කිරීමෙන් අපට තවදුරටත් දේවල් පිරිසිදු කළ හැකිය:

function capitalizeFirstLetter(str, locale=navigator.language) {
  return str.replace(/^\p{CWU}/u, char => char.toLocaleUpperCase(locale));
}

තරමක් හොඳ නිරවද්‍යතාවයකින් යුත් වචන කිහිපයක වචන විශාලනය කිරීම සඳහා මෙය ටිකක් වෙනස් කළ හැකිය. මෙම CWUහෝ Changes_When_Uppercased චරිතය දේපල uppercased විට, හොඳින්, වෙනස් සියලු කේතය ලකුණු තරග. අපි ලන්දේසි වැනි titlecased digraph චරිත සමග මෙය සිදු කළ හැකි ij , උදාහරණයක් ලෙස:

capitalizeFirstLetter('ijsselmeer'); // "IJsselmeer"

ලියන අවස්ථාව වන විට (2020 පෙබරවාරි), ෆයර්ෆොක්ස් / ස්පයිඩර්මන්කි විසින් පසුගිය දෙවසර තුළ හඳුන්වා දුන් රෙජීඑක්ස් විශේෂාංග කිසිවක් තවමත් ක්‍රියාත්මක කර නොමැත *****. ඔබට මෙම අංගයේ වත්මන් තත්වය කැන්ගක්ස් සංයුක්ත වගුවෙන් පරීක්ෂා කළ හැකිය . රෙජෙක්ස් වචනාර්ථයෙන් තොරව සමාන රටාවන්ට දේපල යොමු කිරීම් සමඟ සම්පාදනය කිරීමට බාබෙල්ට හැකි නමුත් එහි ප්‍රති code ලය වන කේතය අති විශාල විය හැකි බව මතක තබා ගන්න.

බොහෝ දුරට, මෙම ප්‍රශ්නය අසන පුද්ගලයින් ඩෙසරෙට් ප්‍රාග්ධනීකරණය හෝ ජාත්‍යන්තරකරණය ගැන සැලකිලිමත් නොවනු ඇත. නමුත් මෙම ගැටළු පිළිබඳව දැනුවත්ව සිටීම හොඳය, මන්දයත් වර්තමානයේදී ඒවා ගැන සැලකිලිමත් නොවුනත් අවසානයේදී ඔබට ඒවා හමුවීමට හොඳ අවස්ථාවක් තිබේ. ඒවා “එජ්” නඩු නොවේ, නැතහොත් ඒවා අර්ථ දැක්වීමේ අද්දර අවස්ථා නොවේ - බොහෝ අය තුර්කි භාෂාව කථා කරන මුළු රටක්ම ඇත, කෙසේ වෙතත්, කේත ඒකක සමඟ කේත ඒකක ගැටීම තරමක් පොදු දෝෂ ප්‍රභවයකි (විශේෂයෙන් ඉමොජි සම්බන්ධයෙන්). නූල් සහ භාෂාව යන දෙකම සෑහෙන්න සංකීර්ණයි!

* UTF-16 / UCS2 හි කේත ඒකක ද යුනිකෝඩ් කේත ලක්ෂ්‍ය වේ. උදා: U + D800 තාක්‍ෂණිකව කේත ලක්ෂ්‍යයකි, නමුත් එය මෙහි “තේරුම” නොවේ ... වර්ග කිරීම ... එය ලස්සන වුව ද නොපැහැදිලි. අන්‍යාගමිකයින් අනිවාර්යයෙන්ම USVs නොවේ (යුනිකෝඩ් පරිමාණ අගයන්).

** අන්‍යාදේශ කේත ඒකකයක් “අනාථ” නම් - එනම්, තාර්කික යුගලයක කොටසක් නොවේ - ඔබට තවමත් මෙහි අන්‍යාගමිකයින් ලබා ගත හැකිය.

*** සමහරවිට. මම එය අත්හදා බැලුවේ නැත. ප්‍රාග්ධනීකරණය අර්ථවත් බාධකයක් බව ඔබ තීරණය කර නොමැති නම්, මම එය දහඩිය දමන්නේ නැත - වඩාත්ම පැහැදිලි හා කියවිය හැකි යැයි ඔබ විශ්වාස කරන ඕනෑම දෙයක් තෝරන්න.

**** එවැනි ශ්‍රිතයක් පළමු ඒකකය වෙනුවට පළමු හා දෙවන කේත ඒකක දෙකම පරීක්ෂා කිරීමට කැමති විය හැකිය, මන්ද පළමු ඒකකය අනාථ අන්‍යාගමිකයෙකු විය හැකි බැවිනි. උදාහරණයක් ලෙස "D uD800x" ආදානය X ප්‍රාග්ධනීකරණය කරයි, එය අපේක්ෂා කළ හැකි හෝ නොවිය හැකිය.

***** ප්‍රගතිය වඩාත් .ජුව අනුගමනය කිරීමට ඔබට අවශ්‍ය නම් මෙන්න බග්සිලා ප්‍රශ්නය .

CSS හි එය පහසු බව පෙනේ:

<style type="text/css">
    p.capitalize {text-transform:capitalize;}
</style>
<p class="capitalize">This is some text.</p>

මෙය CSS පෙළ-පරිණාමන දේපලෙන් ( W3Schools හි ) ය.

var capitalized = yourstring[0].toUpperCase() + yourstring.substr(1);

පළමුවෙන්ම CSS භාවිතා කරමින් මෙවැනි දේ හැසිරවීම වඩා හොඳය , පොදුවේ, ඔබට CSS භාවිතා කර යමක් විසඳිය හැකි නම්, පළමුව ඒ සඳහා යන්න, ඉන්පසු ඔබේ ගැටළු විසඳීමට JavaScript උත්සාහ කරන්න, එබැවින් මෙම අවස්ථාවේදී :first-letterCSS භාවිතා කර උත්සාහ කරන්නtext-transform:capitalize;

එබැවින් ඒ සඳහා පංතියක් නිර්මාණය කිරීමට උත්සාහ කරන්න, එවිට ඔබට එය ගෝලීයව භාවිතා කළ හැකිය, උදාහරණයක් ලෙස: .first-letter-uppercaseසහ ඔබේ CSS හි පහත වැනි දෙයක් එක් කරන්න:

.first-letter-uppercase:first-letter {
    text-transform:capitalize;
}

විකල්ප විකල්පය වන්නේ ජාවාස්ක්‍රිප්ට් ය, එබැවින් හොඳම දේ මේ වගේ දෙයක් වනු ඇත:

function capitalizeTxt(txt) {
  return txt.charAt(0).toUpperCase() + txt.slice(1); //or if you want lowercase the rest txt.slice(1).toLowerCase();
}

එය මෙසේ අමතන්න:

capitalizeTxt('this is a test'); // return 'This is a test'
capitalizeTxt('the Eiffel Tower'); // return 'The Eiffel Tower'
capitalizeTxt('/index.html');  // return '/index.html'
capitalizeTxt('alireza');  // return 'Alireza'

ඔබට එය නැවත නැවත භාවිතා කිරීමට අවශ්‍ය නම්, එය ජාවාස්ක්‍රිප්ට් ස්වදේශීය සංගීතයට අනුයුක්ත කිරීම වඩා හොඳය, එබැවින් පහත වැනි දෙයක්:

String.prototype.capitalizeTxt = String.prototype.capitalizeTxt || function() {
    return this.charAt(0).toUpperCase() + this.slice(1);
}

එය පහත පරිදි අමතන්න:

'this is a test'.capitalizeTxt(); // return 'This is a test'
'the Eiffel Tower'.capitalizeTxt(); // return 'The Eiffel Tower'
'/index.html'.capitalizeTxt();  // return '/index.html'
'alireza'.capitalizeTxt();  // return 'Alireza'

ඔබට සියලු කැප්ස් පෙළ නැවත ආකෘතිකරණය කිරීමට අවශ්‍ය නම්, ඔබට වෙනත් උදාහරණ වෙනස් කිරීමට අවශ්‍ය වනු ඇත:

function capitalize (text) {
    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
}

පහත පා text ය වෙනස් කර ඇති බව මෙය සහතික කරයි:

TEST => Test
This Is A TeST => This is a test

මෙන්න ucfirst () නමින් හැඳින්වෙන ශ්‍රිතයක් ( "ඉහළ අකුරු පළමු අකුර" සඳහා කෙටි):

function ucfirst(str) {
    var firstLetter = str.substr(0, 1);
    return firstLetter.toUpperCase() + str.substr(1);
}

Ucfirst ("සමහර නූල්") ඇමතීමෙන් ඔබට නූලක් විශාල කර ගත හැකිය - උදාහරණයක් ලෙස

ucfirst("this is a test") --> "This is a test"

එය ක්‍රියා කරන්නේ නූල් කැබලි දෙකකට බෙදීමෙනි. පළමු පෙළ මත ඉවත් වෙයි firstLetter පසුව දෙවන පෙළ මත පවුරක් firstLetter ඇමතීම මගින් firstLetter.toUpperCase () හා ඉල්ලා විසින් සොයා වන නූල්, ඉතිරි සමග එය එක්වෙයි str.substr (1) .

මෙය හිස් නූලක් සඳහා අසමත් වනු ඇතැයි ඔබ සිතනු ඇත, ඇත්ත වශයෙන්ම සී වැනි භාෂාවකින් ඔබට මෙය සපුරාලිය යුතුය. කෙසේ වෙතත්, ජාවාස්ක්‍රිප්ට් හි, ඔබ හිස් නූලක උපස්ථරයක් ගත් විට, ඔබට හිස් නූලක් ආපසු ලැබෙනු ඇත.

function capitalize(s) {
    // returns the first letter capitalized + the string from index 1 and out aka. the rest of the string
    return s[0].toUpperCase() + s.substr(1);
}


// examples
capitalize('this is a test');
=> 'This is a test'

capitalize('the Eiffel Tower');
=> 'The Eiffel Tower'

capitalize('/index.html');
=> '/index.html'

String.prototype.capitalize = function(){
    return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase();
    } );
};

භාවිතය:

capitalizedString = someString.capitalize();

මෙය පෙළ නූලකි => මෙය පෙළ නූලකි

var str = "test string";
str = str.substring(0,1).toUpperCase() + str.substring(1);

මෙම විසඳුම පරීක්ෂා කරන්න:

var stringVal = 'master';
stringVal.replace(/^./, stringVal[0].toUpperCase()); // returns Master 

yourString.replace(/^[a-z]/, function(m){ return m.toUpperCase() });

.

මෙම ucfirstකාර්යය වැඩ ඔයාට මේ වගේ ඒක කරන්න නම්.

function ucfirst(str) {
    var firstLetter = str.slice(0,1);
    return firstLetter.toUpperCase() + str.substring(1);
}

ස්තූතියි ජේ.පී.

ඔබට මෙය එක් පේළියකින් කළ හැකිය

string[0].toUpperCase() + string.substring(1)

yourString.replace(/\w/, c => c.toUpperCase())

මෙම ඊතල ක්‍රියාකාරිත්වය පහසුම බව මට පෙනී ගියේය. ප්‍රතිස්ථාපනය\w ඔබගේ නූලෙහි පළමු අක්‍ෂරයට ( ) ගැලපෙන අතර එය ලොකු අකුරක් බවට පරිවර්තනය කරයි. රසික රසිකාවියන් අවශ්‍ය නොවේ.