{
  "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": "ಹೆಚ್ಚಿನ ಉದ್ಯೋಗ ಪ್ರಕಟಣೆಗಳಲ್ಲಿ “ಬಲವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್” ಎಂದರೆ ಇದೇ ಮಟ್ಟ. ನೀವು ಫಿಲ್ಟರ್/ಮ್ಯಾಪ್/ರಿಡ್ಯೂಸ್‌ನ ಸರಣಿಯನ್ನು ಓದುತ್ತೀರಿ ಮತ್ತು ಮೂಲ ಅರೇಯನ್ನು ಮ್ಯುಟೇಟ್ ಮಾಡದೆ ಅದು ನಿಖರವಾಗಿ ಏನನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಎಂದು ಊಹಿಸಬಲ್ಲಿರಿ, ಸಿಂಕ್ರೊನಸ್ 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 ಅನ್ನು ಡಿಫೈನ್ ಮಾಡಲಾಗಿಲ್ಲ"
            },
            {
              "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": "false ನಂತರ false"
            },
            {
              "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": "false ನಂತರ false"
            },
            {
              "icon": "",
              "label": "false ನಂತರ true"
            }
          ]
        },
        {
          "question": "console.log(typeof null);\nಇದು ಏನನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುತ್ತದೆ?",
          "options": [
            {
              "icon": "",
              "label": "\"null\""
            },
            {
              "icon": "",
              "label": "\"object\""
            },
            {
              "icon": "",
              "label": "\"undefined\""
            },
            {
              "icon": "",
              "label": "\"boolean\""
            }
          ]
        },
        {
          "question": "if ಕಂಡೀಶನ್‌ನಲ್ಲಿ ಬಳಸಿದಾಗ ಈ ಕೆಳಗಿನವುಗಳಲ್ಲಿ ಯಾವುದು ಟ್ರೂಥಿ ಆಗಿದೆ?",
          "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": "undefined ನಂತರ undefined"
            },
            {
              "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": "“ಹಾಯ್, undefined”"
            },
            {
              "icon": "",
              "label": "ಇದು TypeError ಅನ್ನು ಥ್ರೋ ಮಾಡುತ್ತದೆ"
            },
            {
              "icon": "",
              "label": "“ಹಾಯ್, ${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": "ಆರೋ ಫಂಕ್ಷನ್‌ಗಳು ಇದನ್ನು ಗ್ಲೋಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗೆ ಬೈಂಡ್ ಮಾಡುತ್ತವೆ"
            },
            {
              "icon": "",
              "label": "ಆರೋ ಫಂಕ್ಷನ್‌ಗಳು ಇದನ್ನು ಗ್ಲೋಬಲ್ ವೇರಿಯಬಲ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತವೆ"
            }
          ]
        },
        {
          "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": "undefined ನಂತರ 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": "ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರೀಕ್ಷೆ"
  }
}