{
  "assessmentTests": {
    "javascript_test": {
      "name": "JavaScript ਟੈਸਟ",
      "desc": "ਮੁੱਢਲੀ ਸੰਟੈਕਸ ਅਤੇ ਕੋਅਰਸ਼ਨ, ਫੰਕਸ਼ਨ/ਸਕੋਪ/ਕਲੋਜ਼ਰ ਅਤੇ this, ਆਬਜੈਕਟ/ਐਰੇ ਅਤੇ ਡਾਟਾ ਸਟ੍ਰਕਚਰ, ਅਤੇ ਈਵੈਂਟ ਲੂਪ/ਅਸਿੰਕ/ਪ੍ਰੋਟੋਟਾਈਪ ਇਡੀਅਮਸ 'ਤੇ 30 ਦ੍ਰਿਸ਼-ਆਧਾਰਿਤ ਸਵਾਲ — ਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਤੁਹਾਡੀ JavaScript ਓਨੀ ਹੀ ਮਜ਼ਬੂਤ ਹੈ ਜਿੰਨੀ ਕਿਸੇ ਨੌਕਰੀ ਦੀ ਪੋਸਟਿੰਗ ਦਾ ਮਤਲਬ JavaScript ਮੁਹਾਰਤ ਤੋਂ ਹੁੰਦਾ ਹੈ।",
      "recommendation": "ਤੁਹਾਡੀ JavaScript ਦੇ ਹੁਨਰ ਦਾ ਪ੍ਰੋਫਾਈਲ",
      "results": {
        "beginner": {
          "name": "ਸ਼ੁਰੂਆਤੀ",
          "desc": "ਤੁਸੀਂ ਕੰਮ ਕਰਨ ਵਾਲੇ ਫੰਕਸ਼ਨ ਅਤੇ ਆਬਜੈਕਟ ਲਿਖ ਸਕਦੇ ਹੋ, ਪਰ ਜੋ ਸਵਾਲ ਤੁਸੀਂ ਖੁੰਝ ਗਏ ਉਹ ਸੰਟੈਕਸ ਦੀ ਬਜਾਏ ਟਾਈਪ ਕੋਅਰਸ਼ਨ ਅਤੇ ਰੈਫਰੈਂਸ ਸਿਮੈਂਟਿਕਸ ਦੁਆਲੇ ਕੇਂਦਰਿਤ ਹਨ — == ਦਾ ਤੁਲਨਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਚੁੱਪਚਾਪ ਟਾਈਪ ਬਦਲ ਦੇਣਾ, ਐਰੇ ਅਸਾਈਨਮੈਂਟ ਦਾ ਇੱਕੋ ਆਬਜੈਕਟ ਨੂੰ ਕਾਪੀ ਕਰਨ ਦੀ ਬਜਾਏ ਸਾਂਝਾ ਕਰਨਾ, ਅਤੇ NaN ਕਦੇ ਵੀ ਆਪਣੇ ਆਪ ਦੇ ਬਰਾਬਰ ਕਿਉਂ ਨਹੀਂ ਹੁੰਦਾ। ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਤੁਸੀਂ JavaScript ਵਿੱਚ ਕਮਜ਼ੋਰ ਹੋ; ਇਹ ਉਹ ਖਾਸ ਨਿਯਮ ਹਨ ਜੋ ਉਹਨਾਂ ਲੋਕਾਂ ਨੂੰ ਉਲਝਾਉਂਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ ਇਹ ਭਾਸ਼ਾ ਅਜਿਹਾ ਕੋਡ ਲਿਖ ਕੇ ਸਿੱਖੀ ਜੋ ਇਤਫ਼ਾਕਨ ਕੰਮ ਕਰ ਗਿਆ, ਨਾ ਕਿ ਇਹ ਸਮਝ ਕੇ ਕਿ ਵੈਲਿਊਜ਼ ਅਤੇ ਰੈਫਰੈਂਸ ਅਸਲ ਵਿੱਚ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦੇ ਹਨ। ਇਹ ਕੰਮ 'ਤੇ ਇਸ ਲਈ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ ਕਿਉਂਕਿ ਹਰ ਇੱਕ ਅਜਿਹੀ ਥਾਂ ਹੈ ਜਿੱਥੇ ਕੋਡ ਬਿਨਾਂ ਕਿਸੇ ਐਰਰ ਦੇ ਚੱਲਦਾ ਹੈ ਅਤੇ ਫਿਰ ਵੀ ਗਲਤ ਕੰਮ ਕਰਦਾ ਹੈ।",
          "recommendation": "ਇਸ ਕ੍ਰਮ ਵਿੱਚ ਤਿੰਨ ਚੀਜ਼ਾਂ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ: == ਤੁਲਨਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਟਾਈਪ ਕਿਉਂ ਬਦਲਦਾ ਹੈ ਜਦਕਿ === ਨਹੀਂ ਬਦਲਦਾ, ਇੱਕ ਐਰੇ ਜਾਂ ਆਬਜੈਕਟ ਨੂੰ ਨਵੇਂ ਵੇਰੀਏਬਲ ਵਿੱਚ ਅਸਾਈਨ ਕਰਨ ਨਾਲ ਵੈਲਿਊ ਦੀ ਬਜਾਏ ਰੈਫਰੈਂਸ ਕਿਉਂ ਕਾਪੀ ਹੁੰਦਾ ਹੈ, ਅਤੇ var ਕਿਵੇਂ ਹੋਇਸਟ ਹੋ ਕੇ undefined ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਜਦਕਿ let ਅਤੇ const ਆਪਣੇ ਡਿਕਲੇਰੇਸ਼ਨ ਦੇ ਚੱਲਣ ਤੱਕ ਟੈਂਪੋਰਲ ਡੈੱਡ ਜ਼ੋਨ ਵਿੱਚ ਰਹਿੰਦੇ ਹਨ। MDN ਦੀ JavaScript ਗਾਈਡ ਇਹ ਤਿੰਨੇ ਚਲਾਉਣਯੋਗ ਉਦਾਹਰਣਾਂ ਨਾਲ ਕਵਰ ਕਰਦੀ ਹੈ।"
        },
        "intermediate": {
          "name": "ਵਿਚਕਾਰਲਾ",
          "desc": "ਤੁਸੀਂ ਰੋਜ਼ਾਨਾ ਦੇ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਆਰਾਮ ਨਾਲ ਸੰਭਾਲਦੇ ਹੋ — ਫੰਕਸ਼ਨ, ਐਰੇ ਮੈਥਡ, ਸਿੱਧਾ-ਸਾਦਾ ਕੰਟਰੋਲ ਫਲੋ — ਅਤੇ ਰੁਟੀਨ ਫੀਚਰ ਵਰਕ ਤੁਹਾਨੂੰ ਹੌਲੀ ਨਹੀਂ ਕਰੇਗਾ। ਇੱਥੋਂ Advanced ਤੱਕ ਦਾ ਫ਼ਰਕ ਜ਼ਿਆਦਾਤਰ ਉਦੋਂ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ ਜਦੋਂ JavaScript ਦੇ ਸਕੋਪਿੰਗ ਅਤੇ ਟਾਈਮਿੰਗ ਨਿਯਮ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾਉਂਦੇ ਹਨ: ਲੂਪ ਦੇ ਕਾਲਬੈਕਾਂ ਵਿੱਚ ਕੈਪਚਰ ਹੋਇਆ ਇੱਕ var, ਜੋ ਸਾਰੇ ਇੱਕੋ ਆਖਰੀ ਵੈਲਿਊ ਪੜ੍ਹਦੇ ਹਨ, ਇੱਕ this ਜੋ ਮੈਥਡ ਦੇ ਆਬਜੈਕਟ ਤੋਂ ਅਲੱਗ ਹੁੰਦੇ ਹੀ ਚੁੱਪਚਾਪ ਉਸ ਆਬਜੈਕਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨਾ ਬੰਦ ਕਰ ਦਿੰਦਾ ਹੈ, ਇੱਕ spread ਕਾਪੀ ਜੋ ਡੂੰਘੀ ਲੱਗਦੀ ਹੈ ਪਰ ਸਿਰਫ਼ ਇੱਕ ਪੱਧਰ ਹੀ ਕਾਪੀ ਕਰਦੀ ਹੈ। ਇਹ ਉਸ ਕਿਸਮ ਦੇ ਬੱਗ ਹਨ ਜੋ ਇੱਕ ਤੇਜ਼ ਰੀਡ-ਥਰੂ ਵਿੱਚੋਂ ਲੰਘ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸਿਰਫ਼ ਕਿਸੇ ਖਾਸ ਰਨਟਾਈਮ ਹਾਲਤ ਵਿੱਚ ਹੀ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ।",
          "recommendation": "ਇਸ 'ਤੇ ਧਿਆਨ ਦਿਓ ਕਿ scope ਅਤੇ this ਅਸਲ ਵਿੱਚ ਡੈਫੀਨੀਸ਼ਨ ਟਾਈਮ ਦੀ ਬਜਾਏ ਕਾਲ ਟਾਈਮ 'ਤੇ ਕਿਵੇਂ ਰੈਜ਼ੋਲਵ ਹੁੰਦੇ ਹਨ: var-ਆਧਾਰਿਤ for ਲੂਪ ਹਰ ਕਾਲਬੈਕ ਨੂੰ ਇੱਕੋ ਆਖਰੀ ਕਾਊਂਟਰ ਵੈਲਿਊ ਕਿਉਂ ਦਿੰਦਾ ਹੈ ਜਦਕਿ let ਨਹੀਂ ਦਿੰਦਾ, this ਇਸ ਗੱਲ ਤੋਂ ਕਿਵੇਂ ਤੈਅ ਹੁੰਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਨੂੰ ਕਿਵੇਂ ਕਾਲ ਕੀਤਾ ਗਿਆ, ਨਾ ਕਿ ਇਹ ਕਿੱਥੇ ਲਿਖਿਆ ਗਿਆ, ਅਤੇ spread ਜਾਂ Object.assign ਸਿਰਫ਼ ਆਬਜੈਕਟ ਦਾ ਉੱਪਰਲਾ ਪੱਧਰ ਹੀ ਕਿਉਂ ਕਾਪੀ ਕਰਦਾ ਹੈ। ਫਿਰ ਈਵੈਂਟ ਲੂਪ, ਕਿਉਂਕਿ ਇਹ ਉਹਨਾਂ ਲੋਕਾਂ ਨੂੰ ਉਲਝਾਉਂਦਾ ਹੈ ਜੋ ਪ੍ਰੌਮਿਸਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਨ।"
        },
        "advanced": {
          "name": "ਐਡਵਾਂਸਡ",
          "desc": "ਇਹ ਉਹ ਪੱਧਰ ਹੈ ਜਿਸਦਾ ਮਤਲਬ ਜ਼ਿਆਦਾਤਰ ਨੌਕਰੀ ਦੀਆਂ ਪੋਸਟਿੰਗਾਂ \"strong JavaScript\" ਤੋਂ ਲੈਂਦੀਆਂ ਹਨ। ਤੁਸੀਂ filter/map/reduce ਦੀ ਇੱਕ ਚੇਨ ਪੜ੍ਹ ਕੇ ਬਿਲਕੁਲ ਦੱਸ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਕੀ ਮੋੜੇਗੀ, ਬਿਨਾਂ ਅਸਲ ਐਰੇ ਨੂੰ ਬਦਲੇ, ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਇੱਕ synchronous console.log ਹਮੇਸ਼ਾ microtask ਤੋਂ ਪਹਿਲਾਂ ਕਿਉਂ ਚੱਲਦਾ ਹੈ ਅਤੇ microtask ਹਮੇਸ਼ਾ setTimeout ਤੋਂ ਪਹਿਲਾਂ, ਅਤੇ ਤੁਸੀਂ Promise.all ਇਹ ਜਾਣਦੇ ਹੋਏ ਵਰਤਦੇ ਹੋ ਕਿ ਇਹ ਬਾਕੀਆਂ ਦੀ ਉਡੀਕ ਕਰਨ ਦੀ ਬਜਾਏ, ਕੋਈ ਵੀ ਇੱਕ ਪ੍ਰੌਮਿਸ ਰਿਜੈਕਟ ਹੁੰਦੇ ਹੀ ਤੁਰੰਤ ਰਿਜੈਕਟ ਹੋ ਜਾਂਦੀ ਹੈ। ਇਸ ਪੱਧਰ ਨੂੰ ਸਭ ਤੋਂ ਉੱਪਰਲੇ ਪੱਧਰ ਤੋਂ ਜੋ ਚੀਜ਼ ਵੱਖ ਕਰਦੀ ਹੈ ਉਹ ਹੈ ਪ੍ਰੋਟੋਟਾਈਪ ਅਤੇ ਆਬਜੈਕਟ-ਮਾਡਲ ਵਾਲਾ ਪੱਖ: ਪ੍ਰੋਟੋਟਾਈਪ ਚੇਨ ਵਿਰਸੇ ਵਿੱਚ ਮਿਲੇ ਮੈਥਡ ਨੂੰ hasOwnProperty ਦੇ ਮੁਕਾਬਲੇ ਕਿਵੇਂ ਰੈਜ਼ੋਲਵ ਕਰਦੀ ਹੈ, ਅਤੇ ਇੱਕ ਪ੍ਰਾਈਵੇਟ ਕਲਾਸ ਫੀਲਡ ਅਸਲ ਵਿੱਚ ਕੀ ਛੁਪਾਉਂਦੀ ਹੈ।",
          "recommendation": "ਉਹਨਾਂ ਹਿੱਸਿਆਂ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਜਾਓ ਜੋ ਉਸ ਸਟੇਟ ਦੀ ਰਾਖੀ ਕਰਦੇ ਹਨ ਜਿਸਨੂੰ ਹੋਰ ਕੋਡ ਵੀ ਛੂੰਹਦਾ ਹੈ: JavaScript ਦੀ ਪ੍ਰੋਟੋਟਾਈਪ ਚੇਨ ਉਹਨਾਂ ਮੈਥਡ ਲੁੱਕਅੱਪਾਂ ਨੂੰ ਕਿਵੇਂ ਰੈਜ਼ੋਲਵ ਕਰਦੀ ਹੈ ਜੋ ਇੰਸਟੈਂਸ 'ਤੇ ਖੁਦ ਨਹੀਂ ਹਨ, ਇੱਕ ਕਲਾਸ ਦੇ ਪ੍ਰਾਈਵੇਟ #fields ਬਾਹਰੀ ਪਹੁੰਚ ਤੋਂ ਅਸਲ ਵਿੱਚ ਕੀ ਛੁਪਾਉਂਦੇ ਹਨ, ਅਤੇ JSON.stringify ਇੱਕ ਸਾਦੇ ਆਬਜੈਕਟ ਦੇ ਅੰਦਰ ਬਨਾਮ ਇੱਕ ਐਰੇ ਦੇ ਅੰਦਰ undefined ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਸਮਝਦਾ ਹੈ। ਈਵੈਂਟ ਲੂਪ ਅਤੇ ਪ੍ਰੋਟੋਟਾਈਪ ਚੇਨ ਬਾਰੇ MDN ਦੀ ਸਮੱਗਰੀ ਦੋਵਾਂ ਲਈ ਅਗਲਾ ਕੁਦਰਤੀ ਪੜਾਅ ਹੈ।"
        },
        "expert": {
          "name": "ਮਾਹਿਰ",
          "desc": "ਤੁਸੀਂ ਹਰ ਸੈਕਸ਼ਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵਧੀਆ ਸਕੋਰ ਕੀਤਾ — ਮੁੱਢਲੀ ਸੰਟੈਕਸ, ਟਾਈਪ ਅਤੇ ਕੋਅਰਸ਼ਨ; ਫੰਕਸ਼ਨ, ਸਕੋਪ, ਕਲੋਜ਼ਰ ਅਤੇ this; ਆਬਜੈਕਟ, ਐਰੇ ਅਤੇ ਡਾਟਾ ਸਟ੍ਰਕਚਰ; ਅਤੇ ਅਸਿੰਕ, ਈਵੈਂਟ ਲੂਪ, ਪ੍ਰੋਟੋਟਾਈਪ ਅਤੇ ਇਡੀਅਮਸ। ਵਿਹਾਰਕ ਤੌਰ 'ਤੇ, ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਅਣਜਾਣ ਵਿਅਕਤੀ ਦਾ ਫੰਕਸ਼ਨ ਦਿੱਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਸਮਝਾ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਜੋ ਮੋੜਦਾ ਹੈ ਉਹ ਕਿਉਂ ਮੋੜਦਾ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਇਹ ਕਿ ਸੰਟੈਕਸ ਦੇ ਹਿਸਾਬ ਨਾਲ ਇਸਨੂੰ ਕੀ ਮੋੜਨਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਔਖਾ ਅਤੇ ਜ਼ਿਆਦਾ ਕੀਮਤੀ ਹੁਨਰ ਹੈ। ਇਸ ਪੱਧਰ 'ਤੇ ਭਾਸ਼ਾ ਖੁਦ ਘੱਟ ਹੀ ਸੀਮਾ ਬਣਦੀ ਹੈ; ਸੀਮਾ ਆਮ ਤੌਰ 'ਤੇ ਅਸਿੰਕ ਕੰਟਰੋਲ ਫਲੋ ਜਾਂ ਉਸ ਦੇ ਹੇਠਾਂ ਡਾਟਾ ਦੀ ਸ਼ਕਲ ਹੁੰਦੀ ਹੈ।",
          "recommendation": "ਹੁਣ ਫਾਇਦਾ ਡਿਜ਼ਾਈਨ ਅਤੇ ਡਾਇਗਨੋਸਿਸ ਵਿੱਚ ਹੈ: Promise.all ਅਤੇ Promise.race ਵਿਚਕਾਰ ਇੱਕ ਰੇਸ ਕੰਡੀਸ਼ਨ ਬਾਰੇ ਸਿਰਫ਼ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੁਹਰਾਉਣ ਦੀ ਬਜਾਏ ਤਰਕ ਕਰਨਾ, ਇਹ ਚੁਣਨਾ ਕਿ ਪ੍ਰਾਈਵੇਟ ਸਟੇਟ ਲਈ ਕਲੋਜ਼ਰ ਸਹੀ ਟੂਲ ਕਦੋਂ ਹੈ ਬਨਾਮ ਕਲਾਸ ਦੀ ਪ੍ਰਾਈਵੇਟ ਫੀਲਡ ਕਦੋਂ ਹੈ, ਅਤੇ ਇੱਕ ਕਵਿਜ਼ ਦੀ ਬਜਾਏ ਪ੍ਰੋਡਕਸ਼ਨ ਲੌਗਾਂ ਵਿੱਚ microtask-vs-macrotask ਆਰਡਰਿੰਗ ਬੱਗ ਪੜ੍ਹਨਾ। ਜੇ ਤੁਹਾਡੀ ਕਿਸੇ ਭੂਮਿਕਾ ਲਈ ਸਕ੍ਰੀਨਿੰਗ ਹੋ ਰਹੀ ਹੈ, ਤਾਂ JavaScript ਫੀਚਰਾਂ ਦੇ ਨਾਂ ਲੈਣ ਦੀ ਬਜਾਏ ਤੁਹਾਨੂੰ ਮਿਲੀ ਕਿਸੇ ਟਾਈਮਿੰਗ ਬੱਗ ਦਾ ਵਰਣਨ ਕਰੋ — ਇੱਕ ਬਾਸੀ ਕਲੋਜ਼ਰ ਵੇਰੀਏਬਲ ਜਾਂ ਗਲਤ ਕ੍ਰਮ ਵਿੱਚ ਚੱਲਿਆ ਅਸਿੰਕ ਕਾਲਬੈਕ; ਇਹ ਤਰਕ ਦਿਖਾਉਂਦਾ ਹੈ, ਸਿਰਫ਼ ਸ਼ਬਦਾਵਲੀ ਨਹੀਂ।"
        }
      },
      "questions": [
        {
          "question": "console.log(x);\nvar x = 5;\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "5 — var ਦਾ ਐਲਾਨ ਤੁਰੰਤ ਚਲਦਾ ਹੈ, ਕਿਸੇ ਵੀ ਹੋਰ ਕੋਡ ਤੋਂ ਪਹਿਲਾਂ"
            },
            {
              "icon": "",
              "label": "ReferenceError: x is not defined"
            },
            {
              "icon": "",
              "label": "undefined — var ਦਾ ਐਲਾਨ ਆਪਣੇ ਸਕੋਪ ਦੇ ਸਿਖਰ 'ਤੇ ਚੁੱਕਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ undefined ਨਾਲ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਅਸਾਈਨਮੈਂਟ ਆਪਣੀ ਜਗ੍ਹਾ ਚਲਦੀ ਹੈ, ਇਸਲਈ ਚਲਣ ਤੋਂ ਪਹਿਲਾਂ ਵੇਰੀਏਬਲ ਮੌਜੂਦ ਹੈ ਪਰ undefined ਰਖਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "null"
            }
          ]
        },
        {
          "question": "console.log(y);\nlet y = 5;\nਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ ReferenceError ਸੁੱਟਦਾ ਹੈ: ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ 'y' ਤੱਕ ਅਸੀਂ ਨਹੀਂ ਪਹੁੰਚ ਸਕਦੇ — let ਆਪਣੇ ਸਕੋਪ ਦੇ ਸਿਖਰ 'ਤੇ ਚੁੱਕਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਅਸਥਾਈ ਮਰੀਜ਼ ਖੇਤਰ ਵਿੱਚ ਰਹਿ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਐਲਾਨ ਦੀ ਲਾਈਨ ਅਸਲ ਵਿੱਚ ਚਲਦੀ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਇਹ undefined ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ var ਕਰਦਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ 5 ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਪਾਰਸ ਸਮੇ 'ਤੇ SyntaxError ਸੁੱਟਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "const arr = [1, 2, 3];\narr.push(4);\nconsole.log(arr.length);\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "4 — const ਸਿਰਫ arr ਨੂੰ ਦੁਬਾਰਾ ਨਿਆਸ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ, ਪਰ ਉਸ ਐਰੇ ਕਨ ਅਤੇ ਤੰਬੀਹ ਪ੍ਰਦਾਨ ਕਰਨ ਤੋਂ ਨਹੀਂ, ਇਸਲਈ push ਅਜੇ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ TypeError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ arr const ਹੈ"
            },
            {
              "icon": "",
              "label": "3 — const ਐਰੇ ਉੱਪਰ push ਰੋਕਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "undefined"
            }
          ]
        },
        {
          "question": "console.log('' == 0);\nconsole.log('' === 0);\nਦੋ ਲਾਈਨਾਂ ਕੀ ਪ੍ਰਿੰਟ ਕਰਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "true ਫਿਰ true"
            },
            {
              "icon": "",
              "label": "false ਫਿਰ false"
            },
            {
              "icon": "",
              "label": "true ਫਿਰ false — == ਖਾਲੀ ਸਤਰ ਨੂੰ ਮੁਕਾਬਲਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ 0 ਵਿੱਚ ਪਰਿਵਰਤਿਤ ਕਰਦਾ ਹੈ, ਜਦੋਂ === ਕਿਸੇ ਵੀ ਮੁਬਦਲੇ ਬਿਨਾਂ ਕਿਸਮ ਅਤੇ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਤਰ ਕਦੀ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "false ਫਿਰ true"
            }
          ]
        },
        {
          "question": "console.log(NaN === NaN);\nconsole.log(Number.isNaN(NaN));\nਦੋ ਲਾਈਨਾਂ ਕੀ ਪ੍ਰਿੰਟ ਕਰਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "true ਫਿਰ true"
            },
            {
              "icon": "",
              "label": "true ਫਿਰ false"
            },
            {
              "icon": "",
              "label": "false ਫਿਰ false"
            },
            {
              "icon": "",
              "label": "false ਫਿਰ true — NaN ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਕੇਲਾ ਮੁੱਲ ਹੈ ਜੋ === ਦੇ ਅਧੀਨ ਆਪ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ, ਪਰ Number.isNaN() ਇਸ ਨੂੰ ਠੀਕ ਤਰ੍ਹਾਂ ਖਿਜੱਤ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\" — ਭਾਸ਼ਾ ਵਿੱਚ ਇਕ ਪੁਰਾਣਾ ਬਗ: typeof null \"object\" ਦਿੰਦਾ ਹੈ ਭਾਵ null ਇਕ primitive ਹੈ, ਅਤੇ ਇਹ ਪਿੱਛੇ ਨਾਲ ਸਮਰਥਤਾ ਲਈ ਬਰਕਰਾਰ ਰਖਿਆ ਗਿਆ ਹੈ"
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਵਿੱਚੋਂ ਕਿਹੜੀ if ਸ਼ਰਤ ਵਿੱਚ ਵਰਤੀ ਜਾਣ ਤੇ truthy ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "0"
            },
            {
              "icon": "",
              "label": "\"\" (ਇਕ ਖਾਲੀ ਸਤਰ)"
            },
            {
              "icon": "",
              "label": "null"
            },
            {
              "icon": "",
              "label": "\"0\" — ਇਕ ਗ਼ੈਰ-ਖਾਲੀ ਸਤਰ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਹਮੇਸ਼ਾਂ truthy ਹੈ, ਭਾਵ ਇਸ ਦੀ ਸਮੱਗਰੀ ਆਪ ਹੀ ਸਤਰ \"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 ਸੁੱਟਦਾ ਹੈ: bar ਇਕ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ — ਫੰਕਸ਼ਨ ਐਲਾਨ ਪੂਰੀ ਤਰ੍ਹਾਂ ਉਨ੍ਹਾਂ ਦੀ ਬਾਡੀ ਦੇ ਨਾਲ ਚੁੱਕੀ ਜਾਂਦਾ ਹੈ, ਪਰ var-ਨਿਆਸਿਤ ਫੰਕਸ਼ਨ ਪ੍ਰਗਟਾਵਾ ਸਿਰਫ var ਆਪ (undefined ਦੇ ਰੂਪ ਵਿੱਚ) ਚੁੱਕਿਆ ਜਾਂਦਾ ਹੈ, ਨਿਆਸ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਦੋਵੇਂ ਕਾਲ ReferenceError ਸੁੱਟਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "foo() ਸੁੱਟਦਾ ਹੈ; 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": "0 ਫਿਰ 1"
            },
            {
              "icon": "",
              "label": "undefined ਫਿਰ undefined"
            },
            {
              "icon": "",
              "label": "1 ਫਿਰ 2 — ਪਰਤਾਇਆ ਗਿਆ ਫੰਕਸ਼ਨ makeCounter ਦੀ ਗੰਜ ਤੋਂ ਉਸੇ count ਵੇਰੀਏਬਲ ਦਾ ਬੰਦ ਹੈ, ਅਤੇ ਇਹ ਵੇਰੀਏਬਲ ਕਾਲਾਂ ਵਿਚਕਾਰ ਮੌਜੂਦ ਰਹਿੰਦਾ ਹੈ ਦੁਬਾਰਾ ਸ਼ੁਰੂ ਹੋਣ ਦੀ ਬਜਾਏ"
            }
          ]
        },
        {
          "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 — var ਫੰਕਸ਼ਨ-ਸਕੋਪ ਹੈ, ਬਲਾਕ-ਸਕੋਪ ਨਹੀਂ, ਇਸਲਈ ਸਾਰੇ ਤਿੰਨ ਕਾਲਬੈਕ ਇਕੋ i ਦਾ ਬੰਦ ਕਰਦੇ ਹਨ, ਜੋ ਲੂਪ ਪੂਰੀ ਹੋ ਜਾਣ ਤੋਂ ਬਾਅਦ 3 ਬਰਾਬਰ ਹੈ"
            },
            {
              "icon": "",
              "label": "0, 0, 0"
            },
            {
              "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": "0, 0, 0"
            },
            {
              "icon": "",
              "label": "undefined, undefined, undefined"
            },
            {
              "icon": "",
              "label": "0, 1, 2 — let ਹਰ ਲੂਪ ਦੁਹਰਾਓ ਲਈ i ਦਾ ਤਾਜ਼ਾ ਬਿੰਡਿੰਗ ਬਣਾਉਂਦਾ ਹੈ, ਇਸਲਈ ਹਰ ਕਾਲਬੈਕ ਆਪਣੀ ਵੱਖਰਾ ਕਾਪੀ ਦਾ ਬੰਦ ਕਰਦਾ ਹੈ ਇਕ ਸਾਝਾ ਵੇਰੀਏਬਲ ਦੀ ਬਜਾਏ"
            }
          ]
        },
        {
          "question": "function greet() { return `Hi, ${this.name}`; }\nconst person = { name: 'Ana' };\nconsole.log(greet.call(person));\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "\"Hi, Ana\" — Function.prototype.call ਫੰਕਸ਼ਨ ਨੂੰ this ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਆਪਣੇ ਪਹਿਲੇ ਆਰਗੂਮੈਂਟ 'ਤੇ ਸੈਟ ਕਰਦੇ ਹੋਏ ਮੰਗਵਾਉਂਦਾ ਹੈ, ਇਸਲਈ this.name ਵਿਅਕਤੀ ਦੇ ਵਿਰੁੱਧ ਹੱਲ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "\"Hi, undefined\" — call() ਸਿਰਫ ਫੰਕਸ਼ਨਾਂ ਉੱਪਰ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਹੀ ਕਿਸੇ ਵਸਤੂ ਦੇ ਢੰਗ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਇਹ TypeError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ greet ਵਿਅਕਤੀ ਦਾ ਵਿਧੀ ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "\"Hi, ${this.name}\" — call() ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਦਾ ਮੁਲਾਂਕਣ ਨਹੀਂ ਕਰਦਾ"
            }
          ]
        },
        {
          "question": "const timer = {\n  seconds: 0,\n  start: function() {\n    setInterval(() => { this.seconds++; }, 1000);\n  },\n};\nਲੋਕ setInterval ਦੇ ਅੰਦਰ ਤੀਰ ਫੰਕਸ਼ਨ ਨੂੰ function() { this.seconds++ } ਉੱਪਰ ਕਿਉਂ ਤਰਜੀਹ ਦਿੰਦੇ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਤੀਰ ਫੰਕਸ਼ਨਾਂ ਦੇ ਕੋਲ ਆਪਣਾ this ਨਹੀਂ — ਉਹ ਆਲਾ-ਗਿਰਦ start ਫੰਕਸ਼ਨ ਤੋਂ ਲਕਸ਼ਮੀ ਤਰੀਕੇ ਨਾਲ this ਨਿਆਲ ਲਿਆ ਲੈਂਦੇ ਹਨ, ਜੋ timer ਹੈ (ਕਿਉਂਕਿ start ਨੂੰ timer.start() ਦੇ ਰੂਪ ਵਿੱਚ ਬੁਲਾਇਆ ਗਿਆ ਸੀ), ਇਸਲਈ this.seconds ਹਰ ਮੋੜ ਉੱਤੇ timer.seconds ਨੂੰ ਠੀਕ ਹੁਝਲੇ ਨਾਲ ਰੈਫਰ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਤੀਰ ਫੰਕਸ਼ਨਾਂ ਚਲਾ ਆਬਕਰਮ ਤੇ ਨਿਯਮਤ ਫੰਕਸ਼ਨਾਂ ਨਾਲੋਂ ਤੇਜ਼ ਹੁੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਤੀਰ ਫੰਕਸ਼ਨਾਂ ਸ਼ਾਲੀਨ ਬਿੰਦੂ 'ਤੇ ਸਵੈਚਲਿਤ ਤਰੀਕੇ ਨਾਲ this ਨੂੰ ਬਾਂਧ ਲਿਆ ਲੈਂਦੇ ਹਨ, ਜੋ timer ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ"
            },
            {
              "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": "ਇਹ ਆਰਕੇ ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ bind ਨੂੰ ਦੋਵੇਂ ਆਰਗੂਮੈਂਟ ਅਗਾਵਾਲੀ ਲਾਜ਼ਮੀ ਹਨ"
            },
            {
              "icon": "",
              "label": "10 — bind ਇਕ ਨਵਾਂ ਫੰਕਸ਼ਨ ਦਿੰਦਾ ਹੈ this ਅਤੇ ਕੋਈ ਪ੍ਰਮੁੱਖ ਆਰਗੁਮੈਂਟਾਂ ਅੰਧਕਰਿਤ; double(5) ਕੋ ਭੇਜਦਿਆਂ ਬਾਕੀ ਆਰਗੂਮੈਂਟ b=5 ਸਪਲਾਈ ਕਰੋ, ਤਾਂ multiply(2, 5) ਚੱਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "NaN"
            },
            {
              "icon": "",
              "label": "7, ਕਿਉਂਕਿ bind ਆਪਣੇ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਕਾਲ ਵਿੱਚ ਜੋੜਦਾ ਹੈ ਨਿਊਜ਼ ਦੀ ਬਜਾਏ ਬਦਲਿਆ ਕਰਦੇ ਹੋਏ"
            }
          ]
        },
        {
          "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 — inner ਦਾ ਆਪਣਾ let x inner ਦੀ ਥਾਂ ਵਿੱਚ ਭਾਗ ਤੋਂ ਸਾਹ x ਤੋਂ ਸ਼ਪਥ ਕਰਦਾ ਹੈ; outer ਦਾ ਆਪਣਾ x ਕਦਮ ਨਾ ਰਹਿਤ"
            },
            {
              "icon": "",
              "label": "10 ਫਿਰ 10"
            },
            {
              "icon": "",
              "label": "ਇਹ ReferenceError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ x ਦੁਬਾਰਾ ਘੋਸ਼ਿਤ ਹੈ"
            }
          ]
        },
        {
          "question": "const a = [1, 2, 3];\nconst b = a;\nb.push(4);\nconsole.log(a.length);\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "3 — b ਇਕ ਵੱਖਰੀ ਕਾਪੀ ਹੈ ਇਸ ਤੋਂ"
            },
            {
              "icon": "",
              "label": "undefined"
            },
            {
              "icon": "",
              "label": "ਇਹ TypeError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ a const ਹੈ"
            },
            {
              "icon": "",
              "label": "4 — ਐਰੇ ਆਬਜੈਕਟਾਂ ਹਨ, ਤਾਂ const b = a ਹਵਾਲਾ ਕਾਪੀ ਕਰਦਾ ਹੈ, ਐਰੇ ਨਹੀਂ; b ਰਾਹੀ push ਕਰ ਕੇ ਆਪਸ ਵਿੱਚ ਬਿਲਕੁਲ ਉਸੇ ਐਰੇ ਨੂੰ ਵਿਕਾਰ ਕਰਦਾ ਹੈ ਜਿਸ ਵੱਲ a ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "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 — ਸਪ੍ਰੈਡ ਸਿਰਫ ਅਤੁੱਟ ਕਾਪੀ ਹੈ: name ਵਰਗਾ primitive ਸੰਪੱਤੀ ਮੂਲ ਤੋਂ ਨਕਲ ਹੈ, ਇਸਲਈ copy.name ਨੂੰ ਦੁਬਾਰਾ ਨਿਯੁਕਤ ਕਿਵੇਂ ਮਸਲ ਨਾ ਛੋਹ; ਪਰ tags ਵਰਗਾ ਨਿਊਜ਼ੀ ਐਰੇ ਹਵਾਲੇ ਦੁਆਰਾ ਕਾਪੀ ਹੈ, ਇਸਲਈ copy.tags ਵਿੱਚ ਠੀਕ ਨਿਊਜ਼ੀ ਐਰੇ original.tags ਦਾ ਸਫਿਆ ਕਸਾ ਕਰ ਦਿੰਦਾ ਹੈ"
            },
            {
              "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 — a x ਦਾ ਨਾਮ ਬਦਲਿਆ ਗਿਆ ਹੈ ਅਤੇ ਮੌਜੂਦ ਹੈ, ਇਸਲਈ ਇਹ ਆਪਣਾ ਮੁੱਲ 5 ਰੱਖਦਾ ਹੈ; b y ਦਾ ਨਾਮ ਬਦਲਿਆ ਗਿਆ ਹੈ ਅਤੇ ਅਨੁਪਸਥਿਤ ਹੈ, ਇਸਲਈ ਆਪਣੇ ਡਿਫਾਲਟ 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] — rest ਪਹਿਲੀ ਦੇ ਬਾਅਦ ਹਰ ਬਾਕੀ ਪਾਸ਼ੋ ਨਾਲ ਨਿਕਾਸ ਕਰਦਾ ਹੈ ਨਵਾ ਵਿਯੂ ਵਿੱਚ"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "[1]"
            }
          ]
        },
        {
          "question": "const nums = [10, 1, 2];\nnums.sort();\nconsole.log(nums);\nਇਹ ਕੀ ਪ੍ਰਿੰਟ ਕਰੇਗਾ?",
          "options": [
            {
              "icon": "",
              "label": "[1, 2, 10] — sort ਹਮੇਸ਼ਾ ਸਭ ਤੋਂ ਪਹਿਲੇ ਅਪਰਨ ਵਾਧੇ ਦੁਆਰਾ ਅਹਲਾਫਰਤ ਸੰਖਿਆਵਾਂ ਦਾ ਇੱਲ ਲੁਕਾ ਰਿਹਾ"
            },
            {
              "icon": "",
              "label": "[10, 1, 2] — sort ਮਸਲ ਐਰੇ ਨੂੰ ਵਿਕਾਰ ਨਹੀਂ ਕਰਦਾ"
            },
            {
              "icon": "",
              "label": "[1, 10, 2] — Array.prototype.sort ਦਾ ਮਨਪਸੰਦ ਤੁਲਨਾ ਵਿਅਕਤੀਆਂ ਨੂੰ ਸ਼ਬਦਾਂ ਵਿੱਚ ਤਬਦੀਲ ਕਰਦਾ ਹੈ ਅਤੇ ਲੇਕਸੀ ਮਤਲਬ ਇੱਕ ਪਬਲਿਸ਼ ਕਰਦਾ ਹੈ, ਮਤਲਬ \"10\" \"2\" ਤੋਂ ਪਹਿਲਾ ਰੂਟ ਕਰਦਾ ਹੈ; sort ਐਲੀ ਦਾ ਮਤਲਬ ਪਲੇਸ ਵਿਧਾਆਇਆ ਨਾ ਨਵਾਂ ਦਿੰਦਾ"
            },
            {
              "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' — ?? 0 ਨੂੰ ਅਨੁਪਸਥਿਤ ਮੰਨਦਾ ਹੈ, ਜਿਵੇਂ || ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "0 ਫਿਰ 'unknown' — ?? ਸਿਰਫ ਨਲ ਜਾਂ undefined ਉੱਤੇ ਪੂਰਾ ਕਰਦਾ ਹੈ, 0 ਨਵੇਂ ਫਲਸੀ ਮੁੱਲ 'ਤੇ ਨਹੀਂ, ਇਸਲਈ age (0) ਜਿਵੇਂ ਬਚਿਆ ਹੈ; user.address undefined ਹੈ, ਤਾਂ ?. ਪੂਰੇ ਚੋਣ ਨੂੰ undefined ਵਿੱਚ ਰੋਕ ਦਿੰਦਾ ਹੈ ਅਤੇ ?? ਮਤਲਬ '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]}' — ਹਰ ਖਾਂਜ ਮੁੱਲ ਹਰ ਥਾਂ null ਬਰਾਬਰ ਹਵੇ, ਵਸਤੂ ਅਤੇ ਐਰੇ ਬਰਾਬਰ"
            },
            {
              "icon": "",
              "label": "'{\"a\":undefined,\"b\":undefined,\"c\":NaN,\"d\":[undefined,null,1]}'"
            },
            {
              "icon": "",
              "label": "'{\"c\":null,\"d\":[null,null,1]}' — ਵਸਤੁ ਸੰਪੱਤੀਆ ਜਿਨ੍ਹਾਂ ਮੁੱਲ undefined ਜਾਂ ਫੰਕਸ਼ਨ ਸਮਖਾ ਹਨ ਨਿਕਾਸ ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ NaN null ਵਿੱਚ ਅਂਬਿਕ ਹੈ, ਪਰ ਐਰੇ ਦੋ ਲੱਸਮ ਅਸਥਾ ਬਿਨਾ ਕਰਿਆ ਜਾਂਦੇ ਹਾਂ ਛੱਡ ਕਰ ਦਿੰਦੇ ਹੋ, ਕਿਉਂਕਿ ਐਰੇ ਤੁ ਛੱਡ ਕਰ ਕੇ ਅਰ ਸਥਿਤੀ ਹੋ ਜਾਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ TypeError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ NaN ਨੂੰ JSON ਵਿੱਚ ਵਿੱਥ ਨਹੀਂ ਸਕਦੀ"
            }
          ]
        },
        {
          "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 — ਸੱਕੂੰਡਾ ਕੋਡ ਪਹਿਲਾ ਚਲਦਾ ਹੈ (ਪਾਟ 1 ਅਤੇ 4 ਤੁਰੰਤ ਪ੍ਰਿੰਟ ਹੁੰਦੇ ਹਨ), ਮਾਇਕ੍ਰੋਟਾਸਕ ਕਿਸਮ (Promise ਕਾਲਬੈਕ) ਪੂਰੇ ਕਰਾਈ ਜਾਂਦੇ ਹਨ ਈਵਿੰਟ ਲੂਪ ਅਗਲੇ ਮੈਕ੍ਰੋਟਾਸਕ ਵੱਲ ਯਾਰੀ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤਾਂ 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 — foo() ਇਸ ਪਹਿਲੇ await ਤੱਕ ਸੱਕੂੰਡਾ ਚਲਦਾ ਹੈ, ਪਾਟ 'a' ਫੌਰਨ ਤੁਰੰਤ ਜਦੋਂ foo() ਕੋ ਬੁਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ; await ਮਤਲਬ ਸੁਲਟ ਕਰਦਾ ਹੈ ਅਤੇ ਕਰਤਵਾ ਨੂੰ ਮੌਕਾ ਫੈਲਾਉਂਦਾ ਹੈ, ਪਾਟ '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' — Promise.all ਰਿਜੈਕਟ ਕਰਦਾ ਹੈ ਜਿਵੇਂ ਹੀ ਇਸ ਦੇ ਕਿਸੇ ਇੱਕ ਅਹਲ ਪ੍ਰੋਮਿਸ reject ਕਰਦਾ ਹੈ, ਅਤੇ ਬਾਕੀ ਦੇ ਨਤੀਜੇ ਸੇਧਾ ਕਰਦਾ ਹੈ, ਤਾਂ catch ਹ੍ਰਾਂਡਲਰ ਰਜੈਕਸ਼ਨ ਕਾਰਨ ਦੇ ਨਾਲ ਚਲਦੇ ਹਨ"
            },
            {
              "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' — Promise.race ਆਪਣੇ ਕਿਸੇ ਇੱਕ ਅਹਲ ਪ੍ਰੋਮਿਸ ਬਸਣ ਤੋਂ ਜਿੰਨੇ ਹੀ ਬਸ ਜਾਂਦਾ ਹੈ, ਅਤੇ 10ms ਅਲਾਨ ਵਿੱਥ 100ms ਤੋਂ ਪਹਿਲਾਂ ਬਸ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਆਰਕੇ ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ race ਨੂੰ ਬਿਲਕੁਲ ਦੋ ਪਾਥਲਬੀ ਲਜ਼ੀ ਹੈ"
            }
          ]
        },
        {
          "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": "undefined ਫਿਰ false"
            },
            {
              "icon": "",
              "label": "ਇਹ TypeError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ dog ਕੋਲ ਆਪਣਾ ਵਿਤ ਵਿਧੀ ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "'Rex makes a sound' ਫਿਰ false — speak ਨਿਰਧਾਰਨਾ ਹੈ Animal.prototype ਉੱਤੇ, ਨਿੱਜੀ dog ਭਾਲ ਨਹੀਂ; dog ਇਸ ਨੂੰ ਪ੍ਰੋਟੋਟਾਈਪ ਚੇਨ ਰਾਹੀ ਲੁੱਭਦਾ ਹੈ ਜਦੋਂ ਇਹ ਬੁਲਾਇਆ ਜਾ ਸਕਦਾ ਹੈ, ਪਰ hasOwnProperty ਸਿਰਫ ਯਕਵਾਨ ਦੀ ਆਪਣੀ ਸੰਪੱਤੀ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਕਸੋ ਵਿਰਸਾ ਨਹੀਂ"
            }
          ]
        },
        {
          "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 — #count ਇਕ ਨਿੱਜੀ ਸ਼ਰਣੀ ਖੇਤਰ ਹੈ, ਪੜ੍ਹਨਯੋਗ ਅਤੇ ਲਿਖਣਯੋਗ ਸਿਰਫ ਸ਼ਣੀ ਦੇ ਆਪਣੇ ਵਿਧੀਆਂ ਤੋਂ; c.count (# ਬਿਨਾ) ਸਮਰਾ ਵੱਖਰੀ, ਨਿਰੰਜਨ ਸੰਪੱਤੀ ਹੈ ਜੋ ਕਦੀ ਸੈੱਟ ਨਹੀਂ ਸੀ, ਪਾਟ ਇਹ undefined ਹੈ"
            },
            {
              "icon": "",
              "label": "1 ਫਿਰ 0"
            },
            {
              "icon": "",
              "label": "1 ਫਿਰ 1"
            },
            {
              "icon": "",
              "label": "ਇਹ ਜਦੋਂ c.count ਲਕਬਾ ਮੰਗਦਾ ਹੈ 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' — ਭਾਸ਼ਾ ਲਿਟਰਲ ${...} ਅੰਦਰ ਕੋਈ ਪ੍ਰਗਣਨਾ ਮਤਲਬ ਲਏ, ਸੰਪੂਰਨ ternary ਸਭ, ਅਤੇ ਇਸ ਦਾ ਮਤਲਬ ਸਿਧਾ ਸਤਰ ਵਿੱਚ"
            },
            {
              "icon": "",
              "label": "ਇਹ SyntaxError ਸੁੱਟਦਾ ਹੈ, ਕਿਉਂਕਿ ternaries ਨੂੰ ਭਾਸ਼ਾ ਲਿਟਰਲ ਅੰਦਰ ਇਜਾਜ਼ਤ ਨਹੀਂ ਹੈ"
            }
          ]
        },
        {
          "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] — filter, map ਅਤੇ reduce ਹਰ ਇਕ ਨਾ ਨਵਾਂ ਐਰੇ ਜਾਂ ਮੁੱਲ ਮਸਲ ਨਾ ਵਿਕਾਰ ਬਿਨਾ ਆਪ ਐਰੇ ਦਾ, ਪਾਟ nums ਅਬਦਲ ਪੇਂਡ ਜਦੋਂ result ਇਕ ਅੰਤਮ ਸੋਖ ਰਾਸ਼ਿ ਹੈ (2 ਅਤੇ 4, ਨਿਲ ਨੀ 20 ਅਤੇ 40, ਸੋਖ ਨੀ 60)"
            },
            {
              "icon": "",
              "label": "60 [2, 4, 20, 40]"
            },
            {
              "icon": "",
              "label": "150 [1, 2, 3, 4, 5]"
            },
            {
              "icon": "",
              "label": "60 [20, 40]"
            }
          ]
        }
      ],
      "optionOrderVersion": "50fc0eba818f2d72"
    }
  },
  "testNames": {
    "javascript-test": "ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਟੈਸਟ"
  }
}