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" વ્યવહારમાં અલગ પડે છે

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

બેકએન્ડ Node.js ઉદાહરણ આ તફાવતોને વધુ પ્રદર્શિત કરવા માટે એક સરળ HTTP સર્વર સેટ કરે છે. ઉપયોગ કરીને var count જો બ્લોકની અંદર, આપણે તે જોઈએ છીએ var બાહ્ય પર ફરીથી લખે છે count કાર્ય અવકાશને કારણે ચલ. આ let message બ્લોકની અંદર તે બ્લોક માટે સ્થાનિક રહે છે, દરેક બ્લોક માટે અલગ-અલગ સંદેશાઓ આઉટપુટ કરીને બ્લોક-સ્કોપિંગનું પ્રદર્શન કરે છે. નો ઉપયોગ createServer અને listen આદેશો સર્વરને સ્થાપિત કરે છે, જે ક્લાયંટને પ્રતિભાવો લખે છે, જેનાં વ્યવહારુ કાર્યક્રમોનું નિદર્શન કરે છે. var અને 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/');

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

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

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

JavaScript માં 'let' અને 'var' વિશે સામાન્ય પ્રશ્નો

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

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

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

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

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