{
  "assessmentTests": {
    "javascript_test": {
      "name": "જાવાસ્ક્રિપ્ટ ટેસ્ટ",
      "desc": "કોર સિન્ટેક્સ અને કોઅર્શન, ફંક્શન્સ/સ્કોપ/ક્લોઝર્સ અને this, ઓબ્જેક્ટ્સ/એરેઝ અને ડેટા સ્ટ્રક્ચર્સ, અને ઇવેન્ટ લૂપ/અસિંક/પ્રોટોટાઇપ રૂઢિપ્રયોગો પર 30 દૃશ્ય પ્રશ્નો — જાણો કે શું તમારું જાવાસ્ક્રિપ્ટ નોલેજ જોબ પોસ્ટિંગમાં જાવાસ્ક્રિપ્ટ પ્રાવીણ્યના અર્થ સાથે મેળ ખાય છે કે નહીં.",
      "recommendation": "તમારી જાવાસ્ક્રિપ્ટ કૌશલ્ય પ્રોફાઇલ",
      "results": {
        "beginner": {
          "name": "પ્રારંભિક",
          "desc": "તમે કાર્યરત ફંક્શન્સ અને ઓબ્જેક્ટ્સ લખી શકો છો, પરંતુ તમે જે પ્રશ્નો ચૂકી ગયા તે સિન્ટેક્સને બદલે ટાઇપ કોઅર્શન અને રેફરન્સ સિમેન્ટિક્સની આસપાસના છે — સરખામણી કરતા પહેલા == શાંતિથી ટાઇપ્સને કન્વર્ટ કરે છે, એક એરે અસાઇનમેન્ટ જે એક ઓબ્જેક્ટને કોપી કરવાને બદલે શેર કરે છે, શા માટે NaN ક્યારેય પોતાની બરાબર નથી હોતું. આમાંથી કંઈ પણ જાવાસ્ક્રિપ્ટમાં ખરાબ હોવા વિશે નથી; આ તે ચોક્કસ નિયમો છે જે એવા લોકોને ગૂંચવે છે જેમણે મૂલ્યો અને રેફરન્સ ખરેખર કેવી રીતે વર્તે છે તે શીખવાને બદલે એવો કોડ લખીને ભાષા શીખી છે જે કામ કરતો હતો. તે કામ પર મહત્વપૂર્ણ છે કારણ કે દરેક તે જગ્યા છે જ્યાં કોડ ભૂલ વિના ચાલે છે અને છતાં ખોટું કામ કરે છે.",
          "recommendation": "આ ક્રમમાં ત્રણ બાબતોથી શરૂઆત કરો: શા માટે === સરખામણી કરતા પહેલા ટાઇપ્સને કોઅર્સ કરતું નથી જ્યારે == કરે છે, શા માટે એક એરે અથવા ઓબ્જેક્ટને નવા વેરિયેબલમાં અસાઇન કરવાથી મૂલ્યને બદલે રેફરન્સ કોપી થાય છે, અને કેવી રીતે var હોઇસ્ટ થાય છે અને undefined પર ઇનિશિયલાઇઝ થાય છે જ્યારે let અને const તેમની ઘોષણા ચાલે ત્યાં સુધી ટેમ્પોરલ ડેડ ઝોનમાં રહે છે. MDNની જાવાસ્ક્રિપ્ટ ગાઇડ આ ત્રણેયને ચલાવી શકાય તેવા ઉદાહરણો સાથે આવરી લે છે."
        },
        "intermediate": {
          "name": "મધ્યમ",
          "desc": "તમે રોજિંદા એપ્લિકેશન કોડને આરામથી સંભાળી શકો છો — ફંક્શન્સ, એરે મેથડ્સ, સીધો કંટ્રોલ ફ્લો — અને નિયમિત ફીચર વર્કથી ધીમા નહીં પડો. અહીં અને એડવાન્સ્ડ વચ્ચેનું અંતર મોટે ભાગે એ છે કે જ્યારે જાવાસ્ક્રિપ્ટના સ્કોપિંગ અને ટાઇમિંગ નિયમો એકબીજા સાથે ક્રિયાપ્રતિક્રિયા કરે છે ત્યારે શું થાય છે: લૂપના કોલબેક્સની અંદર કેપ્ચર થયેલું var જે બધા સમાન અંતિમ મૂલ્ય વાંચે છે, એક this જે શાંતિથી ઓબ્જેક્ટ પર પોઇન્ટ કરવાનું બંધ કરી દે છે જ્યારે એક મેથડ તેમાંથી અલગ થઈ જાય છે, એક સ્પ્રેડ કોપી જે ઊંડી દેખાય છે પરંતુ ફક્ત એક જ સ્તરની કોપી કરે છે. આ તે પ્રકારની બગ્સ છે જે ઝડપી વાંચનમાંથી પસાર થઈ જાય છે અને ફક્ત ચોક્કસ રનટાઇમ સ્થિતિ હેઠળ જ દેખાય છે.",
          "recommendation": "સ્કોપ અને this ખરેખર ડેફિનેશન સમયે નહીં પણ કોલ સમયે કેવી રીતે રિઝોલ્વ થાય છે તેના પર ધ્યાન કેન્દ્રિત કરો: શા માટે var-આધારિત for લૂપ દરેક કોલબેકને સમાન અંતિમ કાઉન્ટર મૂલ્ય આપે છે જ્યારે let નથી આપતું, કેવી રીતે this તે ક્યાં લખાયેલું છે તેના બદલે ફંક્શનને કેવી રીતે કોલ કરવામાં આવે છે તેના દ્વારા નક્કી થાય છે, અને શા માટે સ્પ્રેડ અથવા Object.assign ફક્ત ઓબ્જેક્ટના ટોચના સ્તરની જ કોપી કરે છે. પછી ઇવેન્ટ લૂપ, કારણ કે તે એવા લોકોને ગૂંચવે છે જેઓ પહેલાથી જ પ્રોમિસિસને વ્યક્તિગત રીતે જાણે છે."
        },
        "advanced": {
          "name": "એડવાન્સ્ડ",
          "desc": "આ તે સ્તર છે જે મોટાભાગની જોબ પોસ્ટિંગ્સ “મજબૂત જાવાસ્ક્રિપ્ટ” દ્વારા સૂચવે છે. તમે filter/map/reduce ની ચેઇન વાંચો છો અને મૂળ એરેને મ્યુટેટ કર્યા વિના તે બરાબર શું પરત કરશે તેની આગાહી કરી શકો છો, તમે જાણો છો કે શા માટે સિંક્રનસ console.log હંમેશા માઇક્રોટાસ્કને હરાવે છે જે હંમેશા setTimeout ને હરાવે છે, અને તમે Promise.all નો ઉપયોગ એ જાણીને કરો છો કે તે કોઈ એક પ્રોમિસ રિજેક્ટ થતાં જ રિજેક્ટ કરે છે, બાકીનાની રાહ જોવાને બદલે. આ બેન્ડને ટોચથી જે અલગ પાડે છે તે કામની પ્રોટોટાઇપ અને ઓબ્જેક્ટ-મોડેલ બાજુ છે: પ્રોટોટાઇપ ચેઇન કેવી રીતે વારસાગત મેથડને hasOwnProperty ની વિરુદ્ધમાં રિઝોલ્વ કરે છે, અને પ્રાઇવેટ ક્લાસ ફીલ્ડ ખરેખર શું છુપાવે છે.",
          "recommendation": "એવા ભાગોમાં આગળ વધો જે અન્ય કોડ દ્વારા પણ સ્પર્શતી સ્ટેટને સુરક્ષિત કરે છે: જાવાસ્ક્રિપ્ટની પ્રોટોટાઇપ ચેઇન કેવી રીતે મેથડ લુકઅપ્સને રિઝોલ્વ કરે છે જે ઇન્સ્ટન્સ પર જ નથી, ક્લાસના પ્રાઇવેટ #ફીલ્ડ્સ ખરેખર બહારની એક્સેસથી શું છુપાવે છે, અને JSON.stringify કેવી રીતે પ્લેન ઓબ્જેક્ટની અંદર અને એરેની અંદર undefined અને ફંક્શન્સને અલગ રીતે ટ્રીટ કરે છે. ઇવેન્ટ લૂપ અને પ્રોટોટાઇપ ચેઇન પર MDNની સામગ્રી બંને માટે સ્વાભાવિક આગલું પગલું છે."
        },
        "expert": {
          "name": "નિષ્ણાત",
          "desc": "તમે દરેક વિભાગમાં ટોચનો સ્કોર કર્યો છે — કોર સિન્ટેક્સ, ટાઇપ્સ અને કોઅર્શન; ફંક્શન્સ, સ્કોપ, ક્લોઝર્સ અને this; ઓબ્જેક્ટ્સ, એરેઝ અને ડેટા સ્ટ્રક્ચર્સ; અને અસિંક, ઇવેન્ટ લૂપ, પ્રોટોટાઇપ્સ અને ઇડિયમ્સ. વ્યવહારિક રીતે, તેનો અર્થ એ છે કે તમને કોઈ અજાણ્યા વ્યક્તિનું ફંક્શન આપી શકાય છે અને તમે સમજાવી શકો છો કે તે જે પરત કરે છે તે શા માટે પરત કરે છે, ફક્ત સિન્ટેક્સ શું કહે છે તે નહીં, જે વધુ મુશ્કેલ અને વધુ મૂલ્યવાન કૌશલ્ય છે. આ સ્તરે ભાષા પોતે ભાગ્યે જ મર્યાદિત પરિબળ હોય છે; મર્યાદા સામાન્ય રીતે અસિંક કંટ્રોલ ફ્લો અથવા તેની નીચેના ડેટાનો આકાર હોય છે.",
          "recommendation": "હવે વળતર ડિઝાઇન અને નિદાનમાં છે: Promise.all અને Promise.race વચ્ચેની રેસ કન્ડિશન વિશે તર્ક કરવો, તેમની વ્યાખ્યાઓનું પુનરાવર્તન કરવાને બદલે, પ્રાઇવેટ સ્ટેટ માટે ક્લોઝર ક્યારે યોગ્ય સાધન છે અને ક્લાસનું પ્રાઇવેટ ફીલ્ડ ક્યારે યોગ્ય છે તે પસંદ કરવું, અને ક્વિઝને બદલે પ્રોડક્શન લોગ્સમાં માઇક્રોટાસ્ક-વિ-મેક્રોટાસ્ક ઓર્ડરિંગ બગ વાંચવી. જો તમને કોઈ ભૂમિકા માટે સ્ક્રીન કરવામાં આવી રહ્યા હોય, તો તમે શોધેલી ટાઇમિંગ બગનું વર્ણન કરો — એક સ્ટેલ ક્લોઝર વેરિયેબલ અથવા આઉટ-ઓફ-ઓર્ડર અસિંક કોલબેક — જાવાસ્ક્રિપ્ટ ફીચર્સના નામ લેવાને બદલે; તે ફક્ત શબ્દભંડોળ જ નહીં, પણ તર્ક પણ દર્શાવે છે."
        }
      },
      "questions": [
        {
          "question": "console.log(x);\nvar x = 5;\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "5"
            },
            {
              "icon": "",
              "label": "ReferenceError: x is not defined"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "null"
            }
          ]
        },
        {
          "question": "console.log(y);\nlet y = 5;\nશું થશે?",
          "options": [
            {
              "icon": "",
              "label": "તે ReferenceError ફેંકશે"
            },
            {
              "icon": "",
              "label": "તે undefined પ્રિન્ટ કરશે"
            },
            {
              "icon": "",
              "label": "તે 5 પ્રિન્ટ કરશે"
            },
            {
              "icon": "",
              "label": "તે SyntaxError ફેંકશે"
            }
          ]
        },
        {
          "question": "const arr = [1, 2, 3];\narr.push(4);\nconsole.log(arr.length);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "4"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "3"
            },
            {
              "icon": "",
              "label": "undefined"
            }
          ]
        },
        {
          "question": "console.log('' == 0);\nconsole.log('' === 0);\nઆ બે લાઇન શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "true પછી true"
            },
            {
              "icon": "",
              "label": "ખોટું પછી ખોટું"
            },
            {
              "icon": "",
              "label": "true પછી false"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            }
          ]
        },
        {
          "question": "console.log(NaN === NaN);\nconsole.log(Number.isNaN(NaN));\nઆ બે લાઇન શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "true પછી true"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "ખોટું પછી ખોટું"
            },
            {
              "icon": "",
              "label": "false પછી true"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\""
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "જો કોઈ શરતમાં ઉપયોગમાં લેવામાં આવે તો નીચેનામાંથી કયું સત્ય (truthy) છે?",
          "options": [
            {
              "icon": "",
              "label": "0"
            },
            {
              "icon": "",
              "label": "\"\" (એક ખાલી સ્ટ્રિંગ)"
            },
            {
              "icon": "",
              "label": "null"
            },
            {
              "icon": "",
              "label": "\"0\" (શૂન્ય સ્ટ્રિંગ)"
            }
          ]
        },
        {
          "question": "foo();\nfunction foo() { console.log('a'); }\nbar();\nvar bar = function() { console.log('b'); };\nશું થશે?",
          "options": [
            {
              "icon": "",
              "label": "બંને કોલ્સ પ્રિન્ટ કરશે: “a” અને પછી “b”"
            },
            {
              "icon": "",
              "label": "foo() “a” પ્રિન્ટ કરશે; bar() TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "foo() અને bar() બંને ReferenceError ફેંકશે"
            },
            {
              "icon": "",
              "label": "foo() ReferenceError ફેંકશે; bar() “b” પ્રિન્ટ કરશે"
            }
          ]
        },
        {
          "question": "function makeCounter() {\n  let count = 0;\n  return function() { count++; return count; };\n}\nconst counter = makeCounter();\nconsole.log(counter());\nconsole.log(counter());\nઆ બે લાઇન શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "1 પછી 1"
            },
            {
              "icon": "",
              "label": "NaN પછી NaN"
            },
            {
              "icon": "",
              "label": "અનિર્ધારિત પછી અનિર્ધારિત"
            },
            {
              "icon": "",
              "label": "1 પછી 2"
            }
          ]
        },
        {
          "question": "for (var i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "0, 1, 2"
            },
            {
              "icon": "",
              "label": "3, 3, 3"
            },
            {
              "icon": "",
              "label": "તે ReferenceError ફેંકશે"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            }
          ]
        },
        {
          "question": "for (let i = 0; i < 3; i++) {\n  setTimeout(() => console.log(i), 0);\n}\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "3, 3, 3"
            },
            {
              "icon": "",
              "label": "તે ReferenceError ફેંકશે"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            },
            {
              "icon": "",
              "label": "0, 1, 2"
            }
          ]
        },
        {
          "question": "function greet() { return `Hi, ${this.name}`; }\nconst person = { name: 'Ana' };\nconsole.log(greet.call(person));\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "“Hi, Ana”"
            },
            {
              "icon": "",
              "label": "“Hi, undefined”"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "“Hi, ${this.name}”"
            }
          ]
        },
        {
          "question": "const timer = {\n  seconds: 0,\n  start: function() {\n    setInterval(() => { this.seconds++; }, 1000);\n  },\n};\nલોકો અહીં setInterval ની અંદર function() { this.seconds++ } ને બદલે એરો ફંક્શન શા માટે પસંદ કરે છે?",
          "options": [
            {
              "icon": "",
              "label": "એરો ફંક્શન્સ start નું this વાપરે છે, જે timer છે"
            },
            {
              "icon": "",
              "label": "એરો ફંક્શન્સ નિયમિત ફંક્શન્સ કરતાં વધુ ઝડપથી ચાલે છે"
            },
            {
              "icon": "",
              "label": "એરો ફંક્શન્સ this ને ગ્લોબલ ઓબ્જેક્ટ સાથે જોડે છે"
            },
            {
              "icon": "",
              "label": "એરો ફંક્શન્સ this ને ગ્લોબલ વેરિયેબલમાં ફેરવે છે"
            }
          ]
        },
        {
          "question": "function multiply(a, b) { return a * b; }\nconst double = multiply.bind(null, 2);\nconsole.log(double(5));\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "5"
            },
            {
              "icon": "",
              "label": "10"
            },
            {
              "icon": "",
              "label": "NaN"
            },
            {
              "icon": "",
              "label": "7"
            }
          ]
        },
        {
          "question": "function outer() {\n  let x = 10;\n  function inner() {\n    let x = 20;\n    console.log(x);\n  }\n  inner();\n  console.log(x);\n}\nouter();\nબંને console.log કોલ્સ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "20 પછી 20"
            },
            {
              "icon": "",
              "label": "20 પછી 10"
            },
            {
              "icon": "",
              "label": "10 પછી 10"
            },
            {
              "icon": "",
              "label": "તે SyntaxError ફેંકશે"
            }
          ]
        },
        {
          "question": "const a = [1, 2, 3];\nconst b = a;\nb.push(4);\nconsole.log(a.length);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "3"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "4"
            }
          ]
        },
        {
          "question": "const original = { name: 'Ana', tags: ['x', 'y'] };\nconst copy = { ...original };\ncopy.name = 'Bea';\ncopy.tags.push('z');\nconsole.log(original.name, original.tags.length);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'Ana' 2"
            },
            {
              "icon": "",
              "label": "'Ana' 3"
            },
            {
              "icon": "",
              "label": "'Bea' 3"
            },
            {
              "icon": "",
              "label": "'Bea' 2"
            }
          ]
        },
        {
          "question": "const { a: x = 10, b: y = 20 } = { a: 5 };\nconsole.log(x, y);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "undefined undefined"
            },
            {
              "icon": "",
              "label": "5 undefined"
            },
            {
              "icon": "",
              "label": "10 20"
            },
            {
              "icon": "",
              "label": "5 20"
            }
          ]
        },
        {
          "question": "const [first, ...rest] = [1, 2, 3, 4];\nconsole.log(rest);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 3, 4]"
            },
            {
              "icon": "",
              "label": "[2, 3, 4]"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "[1]"
            }
          ]
        },
        {
          "question": "const nums = [10, 1, 2];\nnums.sort();\nconsole.log(nums);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 10]"
            },
            {
              "icon": "",
              "label": "[10, 1, 2]"
            },
            {
              "icon": "",
              "label": "[1, 10, 2]"
            },
            {
              "icon": "",
              "label": "[2, 1, 10]"
            }
          ]
        },
        {
          "question": "const user = { profile: { age: 0 } };\nconsole.log(user.profile?.age ?? 'unknown');\nconsole.log(user.address?.city ?? 'unknown');\nઆ બે લાઈનો શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'unknown' પછી 'unknown'"
            },
            {
              "icon": "",
              "label": "0 પછી 'unknown'"
            },
            {
              "icon": "",
              "label": "0 પછી undefined"
            },
            {
              "icon": "",
              "label": "'unknown' પછી 0"
            }
          ]
        },
        {
          "question": "const obj = { a: undefined, b: function(){}, c: NaN, d: [undefined, function(){}, 1] };\nconsole.log(JSON.stringify(obj));\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'{\"a\":null,\"b\":null,\"c\":null,\"d\":[null,null,1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":NaN,\"d\":[1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":null,\"d\":[null,null,1]}'"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            }
          ]
        },
        {
          "question": "console.log('1');\nsetTimeout(() => console.log('2'), 0);\nPromise.resolve().then(() => console.log('3'));\nconsole.log('4');\nઆ કયા ક્રમમાં પ્રિન્ટ થશે?",
          "options": [
            {
              "icon": "",
              "label": "1, 2, 3, 4"
            },
            {
              "icon": "",
              "label": "1, 4, 2, 3"
            },
            {
              "icon": "",
              "label": "1, 4, 3, 2"
            },
            {
              "icon": "",
              "label": "1, 3, 4, 2"
            }
          ]
        },
        {
          "question": "async function foo() {\n  console.log('a');\n  await null;\n  console.log('b');\n}\nconsole.log('start');\nfoo();\nconsole.log('end');\nઆ કયા ક્રમમાં પ્રિન્ટ થશે?",
          "options": [
            {
              "icon": "",
              "label": "start, a, end, b"
            },
            {
              "icon": "",
              "label": "start, a, b, end"
            },
            {
              "icon": "",
              "label": "start, end, a, b"
            },
            {
              "icon": "",
              "label": "a, start, end, b"
            }
          ]
        },
        {
          "question": "Promise.all([\n  Promise.resolve(1),\n  Promise.reject('err'),\n  Promise.resolve(3),\n]).then(r => console.log('ok', r)).catch(e => console.log('fail', e));\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'fail err'"
            },
            {
              "icon": "",
              "label": "'ok' [1, 3]"
            },
            {
              "icon": "",
              "label": "'ok' [1, undefined, 3]"
            },
            {
              "icon": "",
              "label": "તે થ્રો કરે છે, અને કોઈ હેન્ડલર ચાલતું નથી"
            }
          ]
        },
        {
          "question": "const fast = new Promise(res => setTimeout(() => res('fast'), 10));\nconst slow = new Promise(res => setTimeout(() => res('slow'), 100));\nPromise.race([fast, slow]).then(v => console.log(v));\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'slow'"
            },
            {
              "icon": "",
              "label": "['fast', 'slow']"
            },
            {
              "icon": "",
              "label": "'fast'"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            }
          ]
        },
        {
          "question": "function Animal(name) { this.name = name; }\nAnimal.prototype.speak = function() { return `${this.name} makes a sound`; };\nconst dog = new Animal('Rex');\nconsole.log(dog.speak());\nconsole.log(dog.hasOwnProperty('speak'));\nઆ બે લાઈનો શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'Rex makes a sound' પછી true"
            },
            {
              "icon": "",
              "label": "અનિર્ધારિત પછી false"
            },
            {
              "icon": "",
              "label": "તે TypeError ફેંકશે"
            },
            {
              "icon": "",
              "label": "'Rex makes a sound' પછી false"
            }
          ]
        },
        {
          "question": "class Counter {\n  #count = 0;\n  increment() { this.#count++; return this.#count; }\n}\nconst c = new Counter();\nconsole.log(c.increment());\nconsole.log(c.count);\nઆ બે લાઈનો શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "1 પછી undefined"
            },
            {
              "icon": "",
              "label": "1 પછી 0"
            },
            {
              "icon": "",
              "label": "1 પછી 1"
            },
            {
              "icon": "",
              "label": "તે SyntaxError ફેંકશે"
            }
          ]
        },
        {
          "question": "const items = ['a', 'b'];\nconst label = `Items: ${items.length > 0 ? items.join(', ') : 'none'}`;\nconsole.log(label);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "'Items: ${items.length > 0 ? items.join(\\', \\') : \\'none\\'}'"
            },
            {
              "icon": "",
              "label": "'Items: none'"
            },
            {
              "icon": "",
              "label": "'Items: a, b'"
            },
            {
              "icon": "",
              "label": "તે SyntaxError ફેંકશે"
            }
          ]
        },
        {
          "question": "const nums = [1, 2, 3, 4, 5];\nconst result = nums.filter(n => n % 2 === 0).map(n => n * 10).reduce((sum, n) => sum + n, 0);\nconsole.log(result, nums);\nઆ શું પ્રિન્ટ કરશે?",
          "options": [
            {
              "icon": "",
              "label": "60 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [2, 4, 20, 40]"
            },
            {
              "icon": "",
              "label": "150 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [20, 40]"
            }
          ]
        }
      ],
      "optionOrderVersion": "7335aa056fc9d33a"
    }
  },
  "testNames": {
    "javascript-test": "જાવાસ્ક્રિપ્ટ ટેસ્ટ"
  }
}