Every program needs to react. A user clicks a button. An API returns data. A form field goes blank. Without a way to bra

દરેક પ્રોગ્રામને પ્રતિક્રિયા આપવાની જરૂર હોય છે. એક યુઝર બટન પર ક્લિક કરે છે. એક API ડેટા રિટર્ન કરે છે. ફોર્મ ફીલ્ડ ખાલી થઈ જાય છે. શાખાઓ (branching) બનાવવાની રીત વગર, ખરેખર શું થઈ રહ્યું છે તેનાથી પરવા કર્યા વગર તમારો કોડ લાઇન બાય લાઇન ચાલશે. કન્ડીશનલ્સ (Conditionals) JavaScript ને પસંદગી કરવાની ક્ષમતા આપે છે. તેઓ તમારા ફંક્શન્સની અંદર નિર્ણય લેનારા છે, તેવા નિયંત્રકો છે જે નક્કી કરે છે કે શું ચાલશે અને શું સ્કીપ થશે. એકવાર તમે તેમને સારી રીતે કેવી રીતે લખવા તે સમજી લો, પછી તમે જડ સ્ક્રિપ્ટ્સ લખવાનું બંધ કરશો અને ખરેખર પ્રતિસાદ આપતું સોફ્ટવેર બનાવવાનું શરૂ કરશો.

કન્ડીશનલ્સ (Conditionals) શા માટે મહત્વના છે

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

કન્ડીશનલ્સ વગર, તમારું એપ્લિકેશન સંવાદને બદલે એકલપંતી સંવાદ (monologue) જેવું બની જશે. તે વિવિધ ડેટા પરિસ્થિતિઓને હેન્ડલ કરી શકશે નહીં, ભૂલોને યોગ્ય રીતે મેનેજ કરી શકશે નહીં, અથવા યુઝરની ક્રિયાઓ પર કોઈ અર્થપૂર્ણ રીતે પ્રતિક્રિયા આપી શકશે નહીં. તે તમને વાસ્તવિક દુનિયાની અનિશ્ચિતતા હેઠળ તમારો પ્રોગ્રામ કેવી રીતે ચાલે છે તેના પર નિયંત્રણ રાખવા દે છે.

મૂળભૂત if સ્ટેટમેન્ટ

શરૂઆત કરવા માટે સૌથી સરળ જગ્યા એકલ if છે. તે કહે છે કે, જો આ વસ્તુ સાચી હોય, તો આ કામ કરો. બસ એટલું જ. કોઈ ફોલબેક નહીં, કોઈ વૈકલ્પિક માર્ગ નહીં.

if (x % 2 === 0) {
    console.log("Even");
}

આ સ્નિપેટમાં, મોડ્યુલસ ઓપરેટર તપાસે છે કે x બે વડે નિઃશેષ ભાગી શકાય છે કે નહીં. જ્યારે શેષ શૂન્ય હોય, ત્યારે કન્સોલ સ્ટ્રિંગ લોગ કરે છે. જો x એકી સંખ્યા હોય, તો કંઈ થતું નથી. બ્લોકને અવગણવામાં આવે છે અને એક્ઝિક્યુશન નીચે ચાલુ રહે છે.

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

if-else સાથે વિકલ્પ ઉમેરવો

વાસ્તવિક નિર્ણયોમાં સામાન્ય રીતે બે પાસાઓ હોય છે. કાં તો યુઝર પૂરતી ઉંમરનો છે, અથવા નથી. કાં તો પેમેન્ટ સફળ થયું છે, અથવા નિષ્ફળ ગયું છે. if-else સ્ટ્રક્ચર બંનેને આવરી લે છે.

if (age >= 18) {
    console.log("Adult");
} else {
    console.log("Not an Adult");
}

else બ્લોક પહેલી શરત દ્વારા નકારવામાં આવેલી તમામ બાબતોને પકડી લે છે. તે એક સ્વચ્છ બાઈનરી શાખા (binary branch) બનાવે છે. આ પેટર્ન ટોગલ્સ, પરમિશન અને ફીચર ફ્લેગ્સ માટે સારી રીતે કામ કરે છે. દરેક બ્લોકની અંદરના લોજિકને કેન્દ્રિત રાખો. જો તમે એક જ શાખામાં ઘણા બધા કાર્યો એકઠા કરતા હોવ, તો તે સામાન્ય રીતે કામને નાના ફંક્શન્સમાં વિભાજિત કરવાનો સંકેત છે.

else if સાથે બહુવિધ માર્ગો તપાસવા

જીવન ભાગ્યે જ માત્ર બે જ પસંદગીઓ આપે છે. તમારે સંખ્યાને પોઝિટિવ, નેગેટિવ અથવા ઝીરો તરીકે વર્ગીકૃત કરવાની જરૂર પડી શકે છે. તમે વજનના આધારે શિપિંગ રેટ નક્કી કરી શકો છો. ક્રમબદ્ધ, બહુવિધ સરખામણીઓ માટે, else if નો ઉપયોગ કરો.

if (x > 0) {
    console.log("Positive");
} else if (x < 0) {
    console.log("Negative");
} else {
    console.log("Zero");
}

JavaScript આને ઉપરથી નીચે તરફ તપાસે છે. જેવી એક શરત પસાર થાય છે, તે તરત જ તે બ્લોક ચલાવે છે અને બાકીનાને અવગણે છે. ક્રમ મહત્વનો છે. જો તમે x > 100 તપાસ્યા પછી x > 0 તપાસશો, તો કડક તપાસ ક્યારેય ચાલશે નહીં કારણ કે હળવી તપાસ તેને પહેલા પકડી લેશે. else if ને પ્રાયોરિટી લિસ્ટ (priority list) તરીકે વિચારો.

switch સ્ટેટમેન્ટ

જ્યારે તમે એક કિંમતને ઘણા અલગ-અલગ વિકલ્પો સાથે સરખાવો છો, ત્યારે else if સ્ટેટમેન્ટ્સની લાંબી સાંકળ પુનરાવર્તિત લાગી શકે છે. switch સ્ટેટમેન્ટ તેને સાફ કરે છે. તે એક્સપ્રેશનને case ક્લોઝ સાથે મેચ કરે છે અને મેચિંગ બ્લોક ચલાવે છે.

switch (true) {
    case marks >= 90:
        Branch = "Computer science";
        break;
    case marks >= 80:
        Branch = "Mechanical";
        break;
    default:
        Branch = "Other";
}

આ ઉદાહરણ સીધા બુલિયન (boolean) કન્ડિશન્સનું મૂલ્યાંકન કરવા માટે switch(true) નો ઉપયોગ કરે છે, જે એક સામાન્ય JavaScript પેટર્ન છે જ્યારે તમારું લોજિક ચોક્કસ સમાનતાને બદલે રેન્જ (ranges) પર આધારિત હોય. break કીવર્ડ આવશ્યક છે. તેના વગર, એક્ઝિક્યુશન પછીના કેસમાં જતું રહે છે ભલે તે મેચ થતું હોય કે નહીં, જે અહીં ભાગ્યે જ તમે ઈચ્છતા હોવ. default ક્લોઝ અંતિમ else જેવું કામ કરે છે, જે અગાઉના કેસમાં ન ફિટ થતી કોઈપણ બાબતને પકડી લે છે.

જ્યારે તમારી પાસે સ્પષ્ટ, નિશ્ચિત વિકલ્પો હોય ત્યારે switch શ્રેષ્ઠ કામ કરે છે. તે else if બ્લોક્સના લાંબા સ્ટેક કરતા સ્કેન કરવામાં સરળ હોય છે, ખાસ કરીને જ્યારે દરેક શાખા ફક્ત કિંમત અસાઇન કરે છે અથવા સિંગલ ફંક્શનને કોલ કરે છે.

ટેરનરી ઓપરેટર (Ternary Operator)

ટૂંકા બાઈનરી નિર્ણયો માટે, ટેરનરી ઓપરેટર વસ્તુઓને સંક્ષિપ્ત રાખે છે. તે ત્રણ ઓપરેન્ડ

જટિલ લોજિક માટે ક્યારેક અનુગામી પ્રશ્નો પૂછવાની જરૂર પડે છે. તમે નિર્ણયને વધુ સચોટ બનાવવા માટે એક if ની અંદર બીજું if ને નેસ્ટ કરી શકો છો.

if (weather === "sunny") {
    if (temp > 30) {
        console.log("