ಓಹ್, ನಾನು ಅದನ್ನು ಮತ್ತೊಮ್ಮೆ ಮಾಡಿದ್ದೇನೆ: JavaScript ನಲ್ಲಿ ಸಾಮಾನ್ಯ ದೋಷಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವುದು ಸವಾಲಿನ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಸರಳವಾಗಿ ಬೆದರಿಸಬಹುದು, ಏಕೆಂದರೆ ಅನೇಕ ಡೆವಲಪರ್‌ಗಳು ಪರಿಚಿತರಾಗಿದ್ದಾರೆ. ಕೆಲಸದ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ದೋಷಗಳು ಅನಿವಾರ್ಯವಾಗಿ ಉದ್ಭವಿಸುತ್ತವೆ, ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಕೆಲವು ಆಗಾಗ್ಗೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತವೆ. ಅನನುಭವಿ ಡೆವಲಪರ್‌ಗಳನ್ನು ಗುರಿಯಾಗಿಟ್ಟುಕೊಂಡು ಈ ಲೇಖನವು ಈ ದೋಷಗಳ ಬಗ್ಗೆ ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತದೆ. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ಕಾರ್ಯಗಳು, ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಸ್ತುಗಳ ಹೆಸರುಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಜನಪ್ರಿಯ ಹಾಡು. ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳನ್ನು ಹೇಗೆ ಸರಿಪಡಿಸುವುದು ಎಂಬುದನ್ನು ತ್ವರಿತವಾಗಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಇವೆಲ್ಲವೂ ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ನಾವು ನೆನಪಿಸುತ್ತೇವೆ: ಎಲ್ಲಾ Habr ಓದುಗರಿಗೆ - Habr ಪ್ರೊಮೊ ಕೋಡ್ ಬಳಸಿಕೊಂಡು ಯಾವುದೇ ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಕೋರ್ಸ್‌ಗೆ ದಾಖಲಾಗುವಾಗ 10 ರೂಬಲ್ ರಿಯಾಯಿತಿ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ: ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ಮೊಬೈಲ್ ಡೆವಲಪರ್ ಪ್ರೊ".

ಟೈಪ್ ದೋಷ: ಆಸ್ತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ

let girl = {
    name: "Lucky",
    location: "Hollywood",
    profession: "star",
    thingsMissingInHerLife: true,
    lovely: true,
    cry: function() {
        return "cry, cry, cries in her lonely heart"
    }
}
console.log(girl.named.lucky)

ಮೇಲಿನ ಉದಾಹರಣೆ ಕೋಡ್ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ Uncaught TypeError: undefined ಆಸ್ತಿ 'ಲಕ್ಕಿ' ಅನ್ನು ಓದಲಾಗುವುದಿಲ್ಲ. ಸಮಸ್ಯೆ ಏನೆಂದರೆ, ಹೆಣ್ಣು ವಸ್ತುವಿಗೆ ಹೆಸರಿನ ಆಸ್ತಿ ಇದ್ದರೂ ಹೆಸರಿಲ್ಲ. ಮತ್ತು ಹುಡುಗಿ.ಹೆಸರಿನ ಆಸ್ತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದ ಕಾರಣ, ನೀವು ಅದನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಔಪಚಾರಿಕವಾಗಿ ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಆದರೆ ನೀವು girl.named.lucky ಅನ್ನು girl.name ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿದರೆ, ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಲಕ್ಕಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ನೀವು ಗುಣಲಕ್ಷಣಗಳ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಬಹುದು ಇಲ್ಲಿ ಓದಿ.

ಟೈಪ್ ದೋಷಗಳನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು

ಪ್ರೋಗ್ರಾಮರ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದ ಡೇಟಾದ ಮೇಲೆ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಟೈಪ್ ದೋಷಗಳು ಸಂಭವಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗಳು .bold(), ವಿವರಿಸಲಾಗದ ಆಸ್ತಿಯನ್ನು ಕೇಳುವುದು ಅಥವಾ ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯವಲ್ಲದ ಕಾರ್ಯವನ್ನು ಕರೆಯುವುದು.

ಆದ್ದರಿಂದ, ನೀವು ಹುಡುಗಿ()ಗೆ ಕರೆ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ನೀವು ದೋಷವನ್ನು ಪಡೆಯುತ್ತೀರಿ Uncaught TypeError: yourVariable.bold ಒಂದು ಕಾರ್ಯವಲ್ಲ ಮತ್ತು ಹುಡುಗಿ ಒಂದು ಕಾರ್ಯವಲ್ಲ, ಏಕೆಂದರೆ ಇದು ವಾಸ್ತವವಾಗಿ ಕರೆಯಲಾಗುವ ವಸ್ತುವಾಗಿದೆ, ಕಾರ್ಯವಲ್ಲ.

ದೋಷಗಳನ್ನು ತೊಡೆದುಹಾಕಲು, ನೀವು ಅಸ್ಥಿರಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಹಾಗಾದರೆ, ಹುಡುಗಿ ಎಂದರೇನು? ಹುಡುಗಿಯ ಹೆಸರೇನು? ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸುವ ಮೂಲಕ, console.log, ಡೀಬಗರ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸುವ ಮೂಲಕ ಅಥವಾ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಕರೆಯುವ ಮೂಲಕ ನೀವು ಕಂಡುಹಿಡಿಯಬಹುದು. ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿರುವ ಡೇಟಾ ಪ್ರಕಾರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಸಾಧ್ಯವಿದೆಯೇ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಅದು ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ಅದನ್ನು ಬದಲಾಯಿಸಿ, ಉದಾಹರಣೆಗೆ, ಷರತ್ತು ಸೇರಿಸಿ ಅಥವಾ ಪ್ರಯತ್ನಿಸಿ..ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ - ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ಪಡೆಯಿರಿ.

ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ

ಬೇಬಿ ಒನ್ ಮೋರ್ ಟೈಮ್ (ಇದು ಬ್ರಿಟ್ನಿ ಸ್ಪಿಯರ್ಸ್, ಹೌದು) ಹಾಡಿನ ಸಾಹಿತ್ಯದ ಲೇಖಕರನ್ನು ನೀವು ನಂಬಿದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹಿಟ್ ಎಂಬ ಪದವು ಗಾಯಕನನ್ನು ಮತ್ತೆ ಕರೆಯುವ ಬಯಕೆ ಎಂದರ್ಥ (ಇಲ್ಲಿ ಅತ್ಯಂತ ಸನ್ನಿವೇಶದ ವಿವರಣೆಯಿದೆ ಹಾಡು - ಅನುವಾದಕರ ಟಿಪ್ಪಣಿ). ಈ ಬಯಕೆ ನಿಜ ಜೀವನದಲ್ಲಿ ಕರೆಗಳ ಸಂಖ್ಯೆಯಲ್ಲಿ ಹೆಚ್ಚಳಕ್ಕೆ ಕಾರಣವಾಗಬಹುದು. ಆದರೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ, ಇದು ಪುನರಾವರ್ತನೆಯಾಗಿದ್ದು ಅದು ಕರೆ ಸ್ಟಾಕ್ ಉಕ್ಕಿ ಹರಿದರೆ ದೋಷವನ್ನು ಉಂಟುಮಾಡಬಹುದು.

ದೋಷಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:

ದೋಷ: ಸ್ಟಾಕ್ ಸ್ಥಳದಿಂದ ಹೊರಗಿದೆ (ಎಡ್ಜ್)
ಆಂತರಿಕ ದೋಷ: ತುಂಬಾ ಪುನರಾವರ್ತನೆ (ಫೈರ್‌ಫಾಕ್ಸ್)
RangeError: ಗರಿಷ್ಠ ಕರೆ ಸ್ಟಾಕ್ ಗಾತ್ರ ಮೀರಿದೆ (Chrome)

ಡೆವಲಪರ್ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ ಬೇಸ್ ಕೇಸ್ ಅನ್ನು ಪರಿಗಣಿಸದಿದ್ದರೆ ಅಥವಾ ಕೋಡ್ ಉದ್ದೇಶಿತ ಪ್ರಕರಣವನ್ನು ತಿಳಿಸದಿದ್ದರೆ ಸ್ಟಾಕ್ ಓವರ್‌ಫ್ಲೋ ಸಂಭವಿಸುತ್ತದೆ.

function oneMoreTime(stillBelieve=true, loneliness=0) {
    if (!stillBelieve && loneliness < 0) return
    loneliness++
    return oneMoreTime(stillBelieve, loneliness)
}

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಟಿಲ್‌ಬಿಲೀವ್ ಎಂದಿಗೂ ಸುಳ್ಳಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಒನ್‌ಮೋರ್‌ಟೈಮ್ ಅನ್ನು ಪ್ರತಿ ಬಾರಿಯೂ ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಕಾರ್ಯವು ಎಂದಿಗೂ ಪೂರ್ಣಗೊಳ್ಳುವುದಿಲ್ಲ.

ನೀವು ಇಬ್ಬರು ಸ್ನೇಹಿತರನ್ನು ಅವಲಂಬಿಸಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ಇದು ಒಂಟಿತನವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನೀವು ಕರೆಗಾಗಿ ಕಾಯಬೇಕಾಗಿಲ್ಲ.

function oneMoreTime(stillBelieve=true, loneliness=0) {
    if (!stillBelieve && loneliness < 0) return
    loneliness--
    stillBelieve = false
    return oneMoreTime(stillBelieve, loneliness)
}

ಸಿಸ್ಟಮ್ ದೋಷ ಸಂದೇಶವನ್ನು ರಚಿಸದಿದ್ದಾಗ ಅನಂತ ಲೂಪ್‌ಗಳೊಂದಿಗಿನ ಪ್ರಕರಣಗಳು ಉದಾಹರಣೆಯಾಗಿದೆ, ಆದರೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಪುಟವು ಸರಳವಾಗಿ ಫ್ರೀಜ್ ಆಗುತ್ತದೆ. ಲೂಪ್ ಮುಕ್ತಾಯದ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಇದು ಸಂಭವಿಸುತ್ತದೆ.

let worldEnded = false
 
while (worldEnded !== true) {
  console.log("Keep on dancin' till the world ends")
}

ನೀವು ಸಮಸ್ಯೆಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಪರಿಹರಿಸಬಹುದು:

let worldEnded = false
 
while (worldEnded !== true) {
  console.log("Keep on dancin' till the world ends")
  worldEnded = true
}

ಅನಂತ ಲೂಪ್‌ಗಳು ಮತ್ತು ಪುನರಾವರ್ತನೆಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ನೀವು ಅನಂತ ಲೂಪ್ ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿದ್ದರೆ, ನೀವು Chrome ಅಥವಾ Edge ನಲ್ಲಿ ಟ್ಯಾಬ್ ಅನ್ನು ಮುಚ್ಚಬೇಕು ಮತ್ತು Firefox ನಲ್ಲಿ ಬ್ರೌಸರ್ ವಿಂಡೋವನ್ನು ಮುಚ್ಚಬೇಕು. ಇದರ ನಂತರ, ನೀವು ಕೋಡ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ವಿಶ್ಲೇಷಿಸಬೇಕು. ನಿಮಗೆ ಸಮಸ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗದಿದ್ದರೆ, ನಿಮ್ಮ ಲೂಪ್ ಅಥವಾ ಕಾರ್ಯಕ್ಕೆ ಡೀಬಗರ್ ಆಜ್ಞೆಯನ್ನು ಸೇರಿಸುವುದು ಮತ್ತು ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ. ಫಲಿತಾಂಶವು ನಿರೀಕ್ಷಿಸಿದ್ದಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ, ನಾವು ಅದನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ, ಇದನ್ನು ಸುಲಭವಾಗಿ ಮಾಡಬಹುದು.

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಡೀಬಗರ್ ಅನ್ನು ಫಂಕ್ಷನ್ ಅಥವಾ ಲೂಪ್‌ನ ಮೊದಲ ಸಾಲಿನಂತೆ ಸೇರಿಸಬೇಕು. ನಂತರ ನೀವು Chrome ನಲ್ಲಿ ಡೀಬಗ್ ಟ್ಯಾಬ್ ಅನ್ನು ತೆರೆಯಬೇಕು, ವ್ಯಾಪ್ತಿಯಲ್ಲಿರುವ ಅಸ್ಥಿರಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿ. ಮುಂದಿನ ಬಟನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಅವರ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು. ಇದೆಲ್ಲವನ್ನೂ ಮಾಡುವುದು ಸುಲಭ, ಮತ್ತು ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸಮಸ್ಯೆ ಕಂಡುಬರುತ್ತದೆ.

ಈ ಎಲ್ಲದರ ಬಗ್ಗೆ ನೀವು ಇಲ್ಲಿ ಇನ್ನಷ್ಟು ಓದಬಹುದು (Chrome ಗಾಗಿ) ಮತ್ತು ಇಲ್ಲಿ (Firefox ಗಾಗಿ).

ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಸಾಮಾನ್ಯ ದೋಷವೆಂದರೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷ. ಪಠ್ಯ ಸಂಪಾದಕ ವಿಸ್ತರಣೆಗಳು ಅವುಗಳನ್ನು ತಪ್ಪಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಬ್ರಾಕೆಟ್ ಪೇರ್ ಬಣ್ಣಕಾರಕವು ವಿಭಿನ್ನ ಬಣ್ಣಗಳೊಂದಿಗೆ ಕೋಡ್‌ನಲ್ಲಿ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರೆಟಿಯರ್ ಅಥವಾ ಅಂತಹುದೇ ವಿಶ್ಲೇಷಣಾ ಸಾಧನವು ದೋಷಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಕಂಡುಹಿಡಿಯಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷದ ಸಂಭವನೀಯತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಉತ್ತಮ ಆಯ್ಕೆಯು ಕನಿಷ್ಟ ಗೂಡುಕಟ್ಟುವದು.

ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಹಂಚಿಕೊಳ್ಳಿ: ತಪ್ಪುಗಳನ್ನು ತಡೆಯಲು ಅಥವಾ ಅವುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ತೊಡೆದುಹಾಕಲು ನೀವು ಏನು ಮಾಡುತ್ತೀರಿ?

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:

• ಎರಡು ವರ್ಷಗಳ ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ನಾನು PRO ವೆಬ್ ಡೆವಲಪರ್".
• ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "0 ರಿಂದ C# ಡೆವಲಪರ್".
• ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ "0 ರಿಂದ PRO ವರೆಗೆ PHP ಡೆವಲಪರ್".

ಮೂಲ: www.habr.com