JavaScript માં let અને var વચ્ચેના

Arthur Petit

બુધવાર, 5 જૂન, 2024 એ 11:40:40 PM વાગ્યે

JavaScript માં વેરિયેબલ ઘોષણાઓને પકડવી
JavaScript ની દુનિયામાં, let અને var વચ્ચેનો તફાવત સમજવો સ્વચ્છ અને કાર્યક્ષમ કોડ લખવા માટે નિર્ણાયક છે. ECMAScript 6 માં રજૂ કરાયેલ, લેટ સ્ટેટમેન્ટે વેરીએબલ ડિક્લેરેશનમાં એક નવું પરિમાણ ઉમેર્યું છે, જે ઘણી વખત વેરીએબલના અવકાશ પર વધુ નિયંત્રણ પૂરું પાડવા તરીકે વર્ણવવામાં આવે છે.
જ્યારે બંને દો અને var ચલોને જાહેર કરવા માટે વપરાય છે, તેઓ વિવિધ વર્તણૂકો દર્શાવે છે જે તમારા કોડને નોંધપાત્ર રીતે પ્રભાવિત કરી શકે છે. આ લેખમાં, અમે આ તફાવતોનું અન્વેષણ કરીશું અને ક્યારે ઉપયોગ કરવો તે અંગે માર્ગદર્શન આપીશું દો ની બદલે var.

આદેશ વર્ણન

var ચલ જાહેર કરે છે, વૈકલ્પિક રીતે તેને મૂલ્યમાં પ્રારંભ કરે છે. તે ફંક્શન-સ્કોપ્ડ અથવા વૈશ્વિક સ્તરે-સ્કોપ્ડ છે અને તેને ફરીથી જાહેર અને અપડેટ કરી શકાય છે.

let એક બ્લોક-સ્કોપ્ડ લોકલ વેરીએબલ જાહેર કરે છે, વૈકલ્પિક રીતે તેને મૂલ્યમાં પ્રારંભ કરે છે. તે સમાન કાર્યક્ષેત્રમાં ફરીથી જાહેર કરી શકાતું નથી.

const બ્લોક-સ્કોપ્ડ, ફક્ત વાંચવા માટેનો સ્થિરાંક જાહેર કરે છે. તે ઘોષણા સમયે શરૂ થવું આવશ્યક છે અને તેને ફરીથી સોંપી શકાતું નથી.

writeHead Node.js માં HTTP પ્રતિસાદ માટે સ્ટેટસ કોડ અને હેડરો સેટ કરે છે.

createServer Node.js માં HTTP સર્વર બનાવે છે, જે વિનંતીઓ સાંભળી શકે છે અને તેનો પ્રતિસાદ આપી શકે છે.

listen ઉલ્લેખિત પોર્ટ પર ઇનકમિંગ કનેક્શન્સ માટે સાંભળવાનું શરૂ કરવા માટે સર્વરને સેટ કરે છે.

console.log કન્સોલ પર સંદેશાઓ છાપે છે, ડીબગીંગ હેતુઓ માટે ઉપયોગી છે.

આદેશ	વર્ણન
var	ચલ જાહેર કરે છે, વૈકલ્પિક રીતે તેને મૂલ્યમાં પ્રારંભ કરે છે. તે ફંક્શન-સ્કોપ્ડ અથવા વૈશ્વિક સ્તરે-સ્કોપ્ડ છે અને તેને ફરીથી જાહેર અને અપડેટ કરી શકાય છે.
let	એક બ્લોક-સ્કોપ્ડ લોકલ વેરીએબલ જાહેર કરે છે, વૈકલ્પિક રીતે તેને મૂલ્યમાં પ્રારંભ કરે છે. તે સમાન કાર્યક્ષેત્રમાં ફરીથી જાહેર કરી શકાતું નથી.
const	બ્લોક-સ્કોપ્ડ, ફક્ત વાંચવા માટેનો સ્થિરાંક જાહેર કરે છે. તે ઘોષણા સમયે શરૂ થવું આવશ્યક છે અને તેને ફરીથી સોંપી શકાતું નથી.
writeHead	Node.js માં HTTP પ્રતિસાદ માટે સ્ટેટસ કોડ અને હેડરો સેટ કરે છે.
createServer	Node.js માં HTTP સર્વર બનાવે છે, જે વિનંતીઓ સાંભળી શકે છે અને તેનો પ્રતિસાદ આપી શકે છે.
listen	ઉલ્લેખિત પોર્ટ પર ઇનકમિંગ કનેક્શન્સ માટે સાંભળવાનું શરૂ કરવા માટે સર્વરને સેટ કરે છે.
console.log	કન્સોલ પર સંદેશાઓ છાપે છે, ડીબગીંગ હેતુઓ માટે ઉપયોગી છે.

કેવી રીતે "લેટ" અને "var" વ્યવહારમાં અલગ પડે છે

ફ્રન્ટએન્ડ સ્ક્રિપ્ટ ઉદાહરણ વચ્ચેના મુખ્ય તફાવતોને સમજાવે છે અને . માં કાર્ય, ચલ var x એક if બ્લોકની અંદર જાહેર કરવામાં આવે છે અને સમગ્ર ફંક્શન સ્કોપમાં સમાન ચલને ફરીથી સોંપે છે. આના પરિણામે બંને કન્સોલ લોગ 2 નું આઉટપુટ થાય છે, તે કેવી રીતે દર્શાવે છે બ્લોક સ્કોપનો આદર કરતું નથી. તેનાથી વિપરીત, ધ કાર્ય જાહેર કરે છે if બ્લોકની અંદર અને બહાર બંને. આ let બ્લોકની અંદરની ઘોષણા એ એક અલગ ચલ છે, તેથી પ્રથમ કન્સોલ લોગ આઉટપુટ 2, અને બીજો કન્સોલ લોગ આઉટપુટ 1, બ્લોક સ્કોપને ધ્યાનમાં રાખીને.

બેકએન્ડ Node.js ઉદાહરણ આ તફાવતોને વધુ પ્રદર્શિત કરવા માટે એક સરળ HTTP સર્વર સેટ કરે છે. ઉપયોગ કરીને જો બ્લોકની અંદર, આપણે તે જોઈએ છીએ બાહ્ય પર ફરીથી લખે છે કાર્ય અવકાશને કારણે ચલ. આ let message બ્લોકની અંદર તે બ્લોક માટે સ્થાનિક રહે છે, દરેક બ્લોક માટે અલગ-અલગ સંદેશાઓ આઉટપુટ કરીને બ્લોક-સ્કોપિંગનું પ્રદર્શન કરે છે. નો ઉપયોગ અને આદેશો સર્વરને સ્થાપિત કરે છે, જે ક્લાયંટને પ્રતિભાવો લખે છે, જેનાં વ્યવહારુ કાર્યક્રમોનું નિદર્શન કરે છે. અને let વાસ્તવિક દુનિયાના દૃશ્યોમાં.

JavaScript માં "let" અને "var" વચ્ચેનો તફાવત

ફ્રન્ટએન્ડ JavaScript ઉદાહરણ

// Example demonstrating the difference between 'var' and 'let'
function varTest() {
    var x = 1;
    if (true) {
        var x = 2;  // same variable
        console.log(x);  // 2
    }
    console.log(x);  // 2
}

function letTest() {
    let y = 1;
    if (true) {
        let y = 2;  // different variable
        console.log(y);  // 2
    }
    console.log(y);  // 1
}

varTest();
letTest();

"લેટ" અને "var" સાથે સ્કોપિંગને સમજવું

બેકએન્ડ Node.js ઉદાહરણ

// Backend example using Node.js to demonstrate 'let' and 'var'
const http = require('http');

http.createServer((req, res) => {
    res.writeHead(200, {'Content-Type': 'text/plain'});
    var count = 10;
    let message = "The count is: ";

    if (true) {
        var count = 20;  // 'count' is hoisted and overwritten
        let message = "New count is: ";  // block-scoped
        res.write(message + count);  // New count is: 20
    }
    res.write(message + count);  // The count is: 20
    res.end();
}).listen(8080);

console.log('Server running at http://127.0.0.1:8080/');

સ્કોપ અને હોસ્ટિંગમાં વધુ ઊંડે ડાઇવ

સરખામણી કરતી વખતે ધ્યાનમાં લેવાનું બીજું મુખ્ય પાસું અને ફરકાવે છે. વર્તમાન અવકાશની ટોચ પર ઘોષણાઓ ખસેડવાની JavaScript વર્તણૂકમાં હોસ્ટિંગ. સાથે , ચલોને ફરકાવવામાં આવે છે અને તેની સાથે પ્રારંભ કરવામાં આવે છે undefined, જે અણધાર્યા પરિણામો તરફ દોરી શકે છે જો વેરીએબલનો ઉપયોગ તેની ઘોષણા પહેલાં કરવામાં આવે. વિપરીત, પણ ફરકાવવામાં આવે છે, પરંતુ તે શરૂ કરવામાં આવતું નથી. આનો અર્થ એ છે કે એ તેની ઘોષણા પહેલા ચલ એ પરિણમશે .

વધુમાં, લૂપ્સમાં બંધ થવાની સમસ્યાઓને રોકવામાં મદદ કરે છે. ઉપયોગ કરતી વખતે લૂપમાં, તમામ પુનરાવર્તનો સમાન ચલનો સંદર્ભ આપે છે, જે બગ્સ તરફ દોરી શકે છે. જો કે, દરેક પુનરાવૃત્તિ માટે એક નવું બંધનકર્તા બનાવે છે, ખાતરી કરીને કે દરેક લૂપ પુનરાવર્તનનો પોતાનો અવકાશ છે. આ વર્તન બનાવે છે let લૂપ્સની અંદર ચલોની ઘોષણા કરવા માટે સલામત અને વધુ અનુમાનિત પસંદગી.

JavaScript માં ફરકાવવું શું છે?
હોસ્ટિંગ એ જાવાસ્ક્રિપ્ટની ડિફૉલ્ટ વર્તણૂક છે જે ઘોષણાઓને વર્તમાન અવકાશની ટોચ પર ખસેડવાની છે. ઘોષણાઓ ફરકાવવામાં આવે છે અને તેની સાથે પ્રારંભ કરવામાં આવે છે , જ્યારે ઘોષણાઓ ફરકાવવામાં આવે છે પરંતુ પ્રારંભ કરવામાં આવતો નથી.
જો તમે a નો ઉપયોગ કરો તો શું થાય છે તેની ઘોષણા પહેલા ચલ?
એક્સેસિંગ એ તેની ઘોષણા પહેલાં ચલ એ પરિણમે છે .
કરી શકે છે અને સમાન અવકાશમાં ફરીથી જાહેર કરવામાં આવશે?
ના, તે જ અવકાશમાં ફરીથી જાહેર કરી શકાતું નથી, જ્યારે સમાન અવકાશમાં ફરીથી જાહેર કરી શકાય છે.
શા માટે છે લૂપ્સમાં પ્રાધાન્યક્ષમ છે?
લૂપના દરેક પુનરાવૃત્તિ માટે એક નવું બંધનકર્તા બનાવે છે, ખાતરી કરીને કે દરેક લૂપ પુનરાવર્તનનો પોતાનો અવકાશ છે. આ બંધ સાથે સંકળાયેલ સામાન્ય ભૂલોને અટકાવે છે.
કરે છે આદર બ્લોક અવકાશ?
ના, બ્લોક અવકાશને માન આપતું નથી; તે ફંક્શન-સ્કોપ્ડ અથવા વૈશ્વિક સ્તરે-સ્કોપ્ડ છે.
ટેમ્પોરલ ડેડ ઝોન શું છે?
ટેમ્પોરલ ડેડ ઝોન એ અવકાશમાં પ્રવેશવા અને ચલની વાસ્તવિક ઘોષણા વચ્ચેનો સમય છે, જે દરમિયાન ચલ એ ફેંકશે .
કરી શકે છે માટે સમાન રીતે ઉપયોગ કરવો ?
હા, જેવા બ્લોક-સ્કોપ્ડ છે , પરંતુ તેનો ઉપયોગ વેરીએબલ્સની ઘોષણા કરવા માટે થાય છે જેને ફરીથી સોંપવામાં આવવો જોઈએ નહીં.
ક્યારે જોઈએ ઉપર ઉપયોગ કરવો ?
ઉપર ઉપયોગ કરવો જોઈએ જ્યારે તમને બ્લોક સ્કોપની જરૂર હોય અને વેરિયેબલ હોસ્ટિંગ અને ક્લોઝર સાથે સમસ્યાઓ ટાળવા માટે.

ચલ ઘોષણાઓ પર અંતિમ વિચારો

નિષ્કર્ષમાં, ની રજૂઆત ECMAScript 6 માં વિકાસકર્તાઓને JavaScriptમાં વેરીએબલ ડિક્લેરેશન માટે વધુ મજબૂત સાધન પ્રદાન કર્યું છે. વચ્ચેના તફાવતોને સમજવું અને ક્લીનર, વધુ જાળવી શકાય તેવા કોડ લખવા માટે જરૂરી છે. જ્યારે var અમુક પરિસ્થિતિઓમાં હજુ પણ ઉપયોગી થઈ શકે છે, અવકાશ અને હોસ્ટિંગ પર બહેતર નિયંત્રણ પ્રદાન કરે છે, ભૂલોની સંભાવના ઘટાડે છે.

પસંદ કરીને ઉપર યોગ્ય પરિસ્થિતિઓમાં, વિકાસકર્તાઓ બ્લોક-સ્કોપિંગનો લાભ લઈ શકે છે અને વેરીએબલ ડિક્લેરેશન અને હોસ્ટિંગ સાથે સંકળાયેલ સામાન્ય મુશ્કેલીઓ ટાળી શકે છે. આધુનિક JavaScript વિકાસમાં નિપુણતા મેળવવા માંગતા કોઈપણ માટે આ જ્ઞાન મૂળભૂત છે.

JavaScript માં "let" અને "var" વચ્ચેના તફાવતને સમજવું

કેવી રીતે "લેટ" અને "var" વ્યવહારમાં અલગ પડે છે

JavaScript માં "let" અને "var" વચ્ચેનો તફાવત

"લેટ" અને "var" સાથે સ્કોપિંગને સમજવું

સ્કોપ અને હોસ્ટિંગમાં વધુ ઊંડે ડાઇવ

ચલ ઘોષણાઓ પર અંતિમ વિચારો