ES6 හි 'let' vs 'const' කොපමණ ප්‍රමාණයක් භාවිතා කළ යුතුද?

මම මෑතකදී io.js සඳහා බොහෝ ES6 කේත ලියා ඇත. ඉගෙන ගැනීමට බොහෝ කේතයන් වනයේ නොමැත, එබැවින් මම යන විට මගේ සම්මුතීන් නිර්වචනය කර ඇති බවක් මට හැඟේ.

මගේ ප්‍රශ්නය constඑදිරිව භාවිතා කරන්නේ කවදාද letයන්නයි.

මම මෙම නියමය ක්‍රියාත්මක කරමි: හැකි නම් භාවිතා කරන්න const. letඑහි වටිනාකම වෙනස් විය යුතු බව ඔබ දන්නේ නම් පමණක් භාවිතා කරන්න. (ඔබට සැමවිටම ආපසු ගොස් a ට වෙනස් කළ constහැකිය let, පසුව එය හැරී ගියහොත් එහි වටිනාකම වෙනස් කළ යුතුය.)

මෙම රීතියට ප්‍රධාන හේතුව වන්නේ නිරන්තරයෙන් අයදුම් කිරීම පහසුය. අළු පැහැති ප්රදේශ නොමැත.

කාරණය නම්, මම මෙම රීතිය ක්‍රියාත්මක කරන විට, ප්‍රායෝගිකව මගේ ප්‍රකාශවලින් 95% ක්ම වේ const. මේක මට අමුතුයි වගේ. මම භාවිතා කරන එකම කරනවා letවගේ දේවල් iතුළ forපුඩුවක්, හෝ එකතු ෆිබොනාච්චි එකතූන් (බොහෝ සැබෑ ජීවිතයේ එන්න නොවන) වැනි දෑ වෙනුවෙන් කලාතුරකිනි. මා මෙයින් පුදුමයට පත් විය - මේ දක්වා මගේ ES5 කේතයේ 95% 'විචල්‍යයන්' වෙනස් නොවන අගයන් සඳහා වූ බව පෙනේ. නමුත් constමගේ කේතය පුරාම දැකීම කෙසේ හෝ වැරදියි.

ඉතින් මගේ ප්‍රශ්නය: constමෙය මෙතරම් භාවිතා කිරීම හරිද ? මම ඇත්තටම මෙවැනි දේ කළ යුතුද const foo = function () {...};?

නැතහොත් constමොඩියුලයක ඉහළින්ම ඔබ වචනානුසාරයෙන් කේත කරන එවැනි තත්වයන් සඳහා මා වෙන් කළ යුතුද - ඔබ සම්පූර්ණ තොප්පි වලින් කරන ආකාරයේද const MARGIN_WIDTH = 410;?

මෙහි මගේ පිළිතුර ජාවාස්ක්‍රිප්ට් විශේෂිත නොවේ.

ඕනෑම භාෂාවක මාපට ඇඟිල්ලේ රීතියක් ලෙස අර්ධ පහසු ආකාරයකින් මට එය කිරීමට ඉඩ සලසයි, හැකි සෑම විටම ඔබේ භාෂාවෙන් හැඳින්වෙන ඕනෑම දෙයක් const / final / readonly / ඕනෑම දෙයක් භාවිතා කරන්න. හේතුව සරලයි, කේතය මිය ගිය විට එය වෙනස් කළ හැකි දේ සහ වෙනස් කළ නොහැකි දේ පැහැදිලි කිරීම පහසුය. මීට අමතරව, බොහෝ භාෂාවලින් ඔබට මෙවලම් සහය ලබා ගත හැකි අතර එය ඔබ වැරදීමකින් සිදුකරන බව පවසන අතර ඔබ වැරදීමකින් ඔබ කොන්ස් ලෙස ප්‍රකාශයට පත් කළ විචල්‍යයකට අනුයුක්ත කරයි.

ආපසු ගොස් කොන්ස් එකක් ලයිට් එකකට වෙනස් කිරීම සරලයි. පෙරනිමියෙන් සංක්ෂිප්තව යාම ඔබට එසේ කිරීමට පෙර දෙවරක් සිතීමට සලස්වයි. මෙය බොහෝ අවස්ථාවලදී හොඳ දෙයකි.

සම්බන්ධිත විචල්‍යයන් අනපේක්ෂිත ලෙස වෙනස් වන බව ඔබ කොපමණ දෝෂ දැක තිබේද? මම ගොඩක් අනුමාන කරනවා. මා දකින දෝෂ වලින් බහුතරයක් අනපේක්ෂිත තත්වයේ වෙනස්කම් වලට සම්බන්ධ බව මම දනිමි. කොන්ස්ට් භාවිතා කිරීමෙන් ඔබට මෙම සියලු දෝෂ ඉවත් නොවනු ඇත, නමුත් ඔබ ඒවායින් බොහොමයක් ඉවත් කරනු ඇත!

එසේම, බොහෝ ක්‍රියාකාරී භාෂාවන්ට වෙනස් කළ නොහැකි විචල්‍යයන් ඇති අතර එහිදී සියලු විචල්‍යයන් පෙරනිමියෙන් සංයුක්ත වේ. උදාහරණයක් ලෙස අර්ලන්ග් දෙස බලන්න, නැතහොත් එෆ් #. පැවරුමකින් තොරව කේතනය කිරීම මෙම භාෂාවලින් පරිපූර්ණව ක්‍රියාත්මක වන අතර මිනිසුන් ක්‍රියාකාරී වැඩසටහන් වලට ආදරය කිරීමට බොහෝ හේතු වලින් එකකි. වඩා හොඳ ක්‍රමලේඛකයෙකු වීමට රාජ්‍ය කළමනාකරණය පිළිබඳව මෙම භාෂාවලින් ඉගෙන ගැනීමට බොහෝ දේ ඇත.

ඒ සියල්ල ආරම්භ වන්නේ කොන්ස් සමඟ අතිශයින් ලිබරල් වීමෙනි! ;) ඉඩ දීමට සාපේක්ෂව ලිවීමට තවත් අක්ෂර දෙකක් පමණි, එබැවින් ඉදිරියට යන්න සහ constසියලු දේ!

constවස්තු යතුරු විකෘති වන බැවින් ප්‍රවේශම් වන්න .

මෙතැන් සිට: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const

වස්තු යතුරු ආරක්ෂා නොවේ

මෙම උදාහරණය සලකා බලන්න:

const colors = {red: "#f00"}; 
console.log(colors); // { "red": "#f00" }

colors.red = "#00f";
colors.green = "#0f0";
console.log(colors); // { "red": "#00f", "green": "#0f0" }

අරා සඳහා එකම දේ:

const numbers = [1, 2, 3];
console.log(numbers); // [ 1, 2, 3 ]

numbers.push(4);
console.log(numbers); // [ 1, 2, 3, 4 ]

මම මුළුමනින්ම මා විසින්ම තීරණය කර නැත, නමුත් මම සලකා බලන්නේ constසියලු අරාව නොවන / වස්තු නොවන සහ letවස්තු / අරා සඳහා භාවිතා කිරීමටයි.

ඒ ගැන කරදර නොවන්න. constජාවාස්ක්‍රිප්ට් සඳහා පුදුමාකාර එකතු කිරීමක් වන අතර, එය අර්ථවත් වන සියලුම ස්ථාන භාවිතා කිරීමට මම ඔබට නිර්දේශ කරමි. එය වඩාත් ශක්තිමත් කේතයක් නිර්මාණය කරයි.

වස්තූන් සම්බන්ධයෙන් ගත් විට, constඔබේ විචල්‍යය නැවත පැවරීමෙන් ආරක්ෂා කරනු ඇත, නමුත් ඔබට වෙනස් කළ නොහැකි වස්තූන් අවශ්‍ය නම්, ඔබට Object.freezeක්‍රමවේදය අවශ්‍ය වනු ඇත , පහත බලන්න.

const immutableOject = Object.freeze({immutableProperty: 'foo'});

constනැවත පැවරීමෙන් පමණක් ආරක්ෂා වන අතර, මෙම freezeක්‍රමය මඟින් සියලු ක්ෂණික දේපල ආරක්ෂා කරනු ඇත. ඔබට සියලු කැදැලි දේපල ද වෙනස් කළ නොහැකි නම්, ඔබට freezeඒවා පුනරාවර්තනය කිරීමට අවශ්‍ය වනු ඇත.

මගේ ES6 හි constවෙනස් කළ නොහැකි තනතුර ගැන නොවේconst , පිරිවිතරයට අනුව හරියටම අදහස් කරන්නේ කුමක්ද යන්න මම පැහැදිලි කරමි .

එම වෛෂයික කරුණු මත පදනම්ව, මෙන්න මගේ පෞද්ගලික මනාපය:

[...] එය භාවිතා කිරීමට තේරුමක් letහා constඔබේ ES6 කේතය පහත සඳහන්:

• constපෙරනිමියෙන් භාවිතා කරන්න
• letනැවත භාවිතා කිරීම (එනම් ඕනෑම ආකාරයක නැවත පැවරීමක්) අවශ්‍ය නම් පමණක් භාවිතා කරන්න
• ( varES6 හි භාවිතා නොකළ යුතුය)

විෂයානුබද්ධව, මෙය පිරිවිතරයේ අභිප්‍රාය සමඟ වඩාත් සමීපව ගැලපෙන සත්‍යයකි.

letපෙරනිමියෙන් භාවිතා කරන පුද්ගලයින් සාමාන්‍යයෙන් constවිචල්‍යයන් නියතයන් ලෙස සලකයි (ඒවා අවශ්‍යයෙන්ම නිර්මාණයෙන් නොවේ!). එක් එක් කෙනාට, නමුත් මම කැමති දේ ඔවුන්ගේ අපේක්ෂිත අරමුණු සඳහා භාවිතා කිරීමට මිස වරදවා වටහාගැනීමක් මත පදනම්ව මිනිසුන් එයට පවරන සමහර සැකසූ අර්ථයන් සඳහා නොවේ.

constනියතයන් සඳහා පමණක් භාවිතා කිරීම හරියට HTML <aside>අංගය පැති තීරු අන්තර්ගතයට පමණක් භාවිතා කිරීම වැනිය .

මගේ පුද්ගලික ප්‍රවේශය, කේත කියවීමේ හැකියාව සහ අවබෝධය සඳහා උපකාර කිරීම සඳහා වූ සිතුවිල්ල:

letකෙටි කාලීන විචල්‍යයන් සඳහා පමණක් වන අතර එය තනි පේළියකින් අර්ථ දක්වා ඇති අතර පසුව වෙනස් නොවේ. සාමාන්‍යයෙන් එම විචල්‍යයන් යතුරු ලියනය කිරීමේ ප්‍රමාණය අඩු කිරීමට පමණි. උදාහරණයක් වශයෙන්:

for (let key in something) {
  /* we could use `something[key]` for this entire block,
     but it would be too much letters and not good for the
     fingers or the eyes, so we use a radically temporary variable
  */
  let value = something[key]
  ...
}

constසමස්ත මොඩියුලය පුරා නියත බව දන්නා සියලුම නම් සඳහා . දේශීයව නියත අගයන් ඇතුළත් නොවේ. මෙම valueඉහත නිදසුනේ, උදාහරණයක් ලෙස, එහි විෂය පථය තුල, නියත වන සහ සමග ප්රකාශ කළ හැකි විය const, නමුත් බොහෝ අනුකරණ ඇත හා එක් එක් එක් සඳහා එම සමඟ අගය තියෙනවා සිට නම , චින්තනය ගැන පාඨකයා රැවැට්ටුවේ හැකි බව "වටිනාකම", valueහැම විටම එකම. මොඩියුල සහ කාර්යයන් constවිචල්යයන් සඳහා හොඳම උදාහරණය වේ :

const PouchDB = require('pouchdb')
const instantiateDB = function () {}
const codes = {
  23: 'atc',
  43: 'qwx',
  77: 'oxi'
}

varවිචල්‍ය විය හැකි හෝ නොවිය හැකි සියල්ල සඳහා. කේතය කියවන පුද්ගලයින් දේශීයව නිරන්තරයෙන් පැවතියද ඒවා සුදුසු නොවන let(එනම්, ඒවා සරල සෘජු ප්‍රකාශයකින් සම්පූර්ණ කර නැත) නම් ප්‍රකාශයට පත් කිරීම සඳහා අදාළ වේ var. උදාහරණයක් වශයෙන්:

var output = '\n'
lines.forEach(line => {
  output += '  '
  output += line.trim()
  output += '\n'
})
output += '\n---'

for (let parent in parents) {
  var definitions = {}
  definitions.name = getName(parent)
  definitions.config = {}
  definitions.parent = parent
}

වැඩිදුර විවරණ සහ අනාගත යාවත්කාලීන කිරීම් මෙහි දැක්වේ .

ජාවාස්ක්‍රිප්ට් යනු එම විචල්‍යයන්හි තරමක් විශේෂ වන අතර ඒවා ශ්‍රිත විය හැකි අතර, නමුත් C #, Java හෝ වෙනත් සමාන C විලාසිතාවේ භාෂාවෙන් සලකා බලන්න:

const public void DoSomething()

මෙම constඅමුතු වන අතර, ඔවුන්, (තිබිය හැක ඒ ලෙවෙල් කලේ මාරාවේශයෙන් සිදුකරන ඇතැම් නොසලකා හරිමින්) මොන දේ උනත්, ඔවුන් කළ දැය බව, වෙන දෙයක් සම්පාදනය කරන්නේ වරක්, මෙම භාෂා ක්රමය ප්රකාශ වෙනස් කළ නොහැකි නිසා ය.

ජාවාස්ක්‍රිප්ට් වෙනස් විය යුත්තේ ඇයි? එබැවින් එය සම්පාදනය කර නැත, නමුත් එයින් අදහස් කරන්නේ සම්පාදකයින්ට ලබා දිය හැකි ආරක්ෂාව අප විසින් ඉවත දැමිය යුතු බවයි. constමූල පදය භාවිතා කිරීමෙන් අපට වැඩි ආරක්ෂාවක් ලබා දෙන අතර, එය නිසැකවම වඩා ශක්තිමත් යෙදුම් වලට තුඩු දෙනු ඇත.