[ರಿವ್ಯೂ: ರಸಪ್ರಶ್ನೆ 1]
 [ಅಲಿ Nahm, Oreoluwa Barbarinsa, ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್, ರಾಬ್ ಬೌಡೆನ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]
 [ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]
 [ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್] ಎಲ್ಲರಿಗೂ ಸ್ವಾಗತ. ಈ ರಸಪ್ರಶ್ನೆ 1 ವಿಮರ್ಶೆ.
 ಕೇವಲ ಒಂದು ಹಕ್ಕುನಿರಾಕರಣೆ ಮಾಹಿತಿ, ಈ - ನಾನು ಅರ್ಥ, ನಾವು ರಕ್ಷಣೆ ಪ್ರಯತ್ನಿಸಿ ನೀನು
 ಸಾಧ್ಯ, ಆದರೆ ಅಷ್ಟು ವಸ್ತು ಎಂದು ಅರ್ಥವಲ್ಲ
 ನಾವು ರಸಪ್ರಶ್ನೆ 1 ಮಾಡಬಹುದು ವಸ್ತುಗಳ ಎಲ್ಲಾ ರಕ್ಷಣೆ ನೀನು.
 ಆದ್ದರಿಂದ ನೀವು ಸಹ ಒಂದು ಉಪನ್ಯಾಸ ನೋಟ ವಿಭಾಗಗಳು, ನೀವು ಎಲ್ಲವನ್ನೂ ತೆಗೆದುಕೊಂಡು ಮರೆಯಬೇಡಿ.
 ರಸಪ್ರಶ್ನೆ 1 ಬುಧವಾರ, ಮುಂದಿನ ಬುಧವಾರ ಏರಲಿದೆ.
 ಆದ್ದರಿಂದ ಅಧ್ಯಯನ ಮರೆಯಬೇಡಿ. ಇದು ಮೊದಲ ರಸಪ್ರಶ್ನೆ ರೀತಿಯಲ್ಲಿ, ಅತ್ಯಧಿಕವಾಗಿ, ಎಂದು ವಿಶೇಷವೇನು
 ಅದರ ಸ್ವರೂಪ ಬಗ್ಗೆ, ಆದರೆ ಬಹುಶಃ ಹೆಚ್ಚು ಕಷ್ಟ ಎಂದು ವಿಶೇಷವೇನು.
 ನಾನು 50 ಪಡೆದಾಗ ಕನಿಷ್ಠ, ಕಳೆದ ವರ್ಷ, ನಾನು ತುಂಬಾ ಕಷ್ಟವಾಯಿತು ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.
 ಆದ್ದರಿಂದ ಸಾಕಷ್ಟು ಅಧ್ಯಯನ.
 

ನಾನು ಡೇಟಾ ರಚನೆಗಳು ರಕ್ಷಣೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ ಮತ್ತು ಹಫ್ಮನ್ ಕೋಡಿಂಗ್.
 ಈ, ಜನರು ಬಹಳಷ್ಟು ಸಂಕೀರ್ಣ ಎಂದು ವಿಷಯ
 ಆದರೆ ನಾನು ಸಾಧ್ಯವಾದಷ್ಟು ಸುಲಭ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ.
 ಎಲ್ಲಾ ಮೊದಲ, ನಾವು ನೀವು ಹುಡುಗರಿಗೆ ರಸಪ್ರಶ್ನೆ 1 ತಿಳಿಯಲು ಬಯಸುವ ಆಗಿದೆ
 ನಾನು ಪ್ರಸ್ತುತ ಪಡೆಯಲಿದ್ದೇನೆ ದತ್ತಾಂಶ ರಚನೆಗಳು ಪ್ರತಿ ಕಲ್ಪನಾತ್ಮಕ ವಿವರಣೆಗಳನ್ನು ಅರ್ಥ.
 ನೀವು ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ ವಾಸ್ತವವಾಗಿ
 ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ 1 ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಜಾರಿಗೆ.
 ನಾವು ನೀವು ಇಡೀ ಹ್ಯಾಷ್ ಟೇಬಲ್ ಜಾರಿಗೆ ಬಯಸುವುದಿಲ್ಲ; ಬಹುಶಃ ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮಾಡುತ್ತೇವೆ
 ನೀವು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಜಾರಿಗೆ ಮಾಡಲು,
 ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳ, ಆದರೆ ನಾವು ನೀವು ಎಲ್ಲವೂ ಜಾರಿಗೆ ಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ.
 ಆದ್ದರಿಂದ ನೀವು ಪ್ರತಿ ಡೇಟಾ ರಚನೆ ಹಿಂದೆ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅರ್ಥ ಮುಖ್ಯವಾಗಿರುತ್ತದೆ
 ಮತ್ತು ನೀವು ಸಿ ಕೋಡ್ ಸಮರ್ಥವಾಗಿರುತ್ತವೆ,
 ಅವರು ಪ್ರತಿ ಡೇಟಾ ರಚನೆ ಹೊಂದಿವೆ ಸಾಮಾನ್ಯ ಕಾರ್ಯಾಚರಣೆಗಳ.
 ಮತ್ತು, ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ
 ಅವರು ಈ ಡೇಟಾವನ್ನು ರಚನೆಗಳು ಸಾಕಷ್ಟು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಏಕೆಂದರೆ.
 

ಮೊದಲ, ಪಟ್ಟಿಯಲ್ಲಿ ಲಿಂಕ್. ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ರಚನೆಗಳು ಇವೆ,
 ಆದರೆ ಲಿಂಕ್ ಪಟ್ಟಿ ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಡುವಿನ ವ್ಯತ್ಯಾಸ,
 ಎಲ್ಲಾ ಮೊದಲ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಗಾತ್ರದ ಹೊಂದಿದೆ
 ಸರಣಿಗಳ ನೀವು ರಚನೆಯ ಒಂದು ಅತ್ಯಂತ ದೊಡ್ಡ ಗಾತ್ರದ ಎರಡೂ ಆಯ್ಕೆ ಹೊಂದಿರುತ್ತವೆ,
 ಆದ್ದರಿಂದ ನೀವು, ನೀವು ಆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನೀನು ತಿಳಿದಿದೆ
 ಅಥವಾ ನೀವು ರಚನೆಯ ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಉದ್ದವನ್ನು, malloc ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ.
 ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಇದು ಕೇವಲ ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಪಡೆಯಲು ಬಹಳ ಸುಲಭ,
 ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಹಾಕಲು ಅಥವಾ ಅಂಶಗಳನ್ನು ತೆಗೆದು.
 ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿ ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಬಯಸದಿದ್ದರೆ,
 ನೀವು ಹುಡುಕಲು ಮತ್ತು ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು,
 ಆದ್ದರಿಂದ ಓ (1) ಸಮಯ, ಆದ್ದರಿಂದ ಬಹಳ ಅನುಕೂಲಕರ.
 ನೀವು, ಗ್ರಂಥಿಗಳು ಯಾವಾಗಲೂ malloc ನೆನಪಿಡುವ ಎಚ್ಚರಿಕೆಯಿಂದ ಮತ್ತು ಉಚಿತ ಇರಬೇಕು
 ನೀವು ವೇಳೆ, ನೀವು ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಹೊಂದಿರುತ್ತದೆ ಕೇವಲ.
 ಆದ್ದರಿಂದ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು - ಒಂದು ನೋಡ್ ವ್ಯಾಖ್ಯಾನವನ್ನು ಕೇವಲ ನಾವು ಅಲ್ಲಿ ಏನು ಹಾಗೆ.
 ನಾನು ಇಂಟ್ N ಪುಟ್, ಆದರೆ ನೀವು ಬಯಸುವ ಯಾವುದೇ ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು.
 ನೀವು ಸ್ಟ್ರಿಂಗ್ ಶೇಖರಿಸಿಡಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು ಉತ್ತಮ ಇಲ್ಲಿದೆ.
 ನೀವು struct ಶೇಖರಿಸಿಡಲು ಬಯಸಿದರೆ, ನೀವು ಬಯಸುವ ಯಾವುದೇ, ಎರಡು ಉತ್ತಮ ಇಲ್ಲಿದೆ.
 ನಾನು ಇಲ್ಲಿ ಉದಾಹರಣೆಗಳು ಇಂಟ್ N ಪುಟ್.
 ಮತ್ತು ನೀವು ಮುಂದಿನ ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ.
 ಮೂಲತಃ, ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಕೆಲವು ದಶಮಾಂಶ ಹೊಂದಿದೆ, ಮತ್ತು ನಂತರ ಮುಂದಿನ ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.
 ಇದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಕೊನೆಯ ಅಂಶ ಅದನ್ನು ಶೂನ್ಯ ತೋರಿಸಲು ವಿಶೇಷವೇನು.
 ಆದ್ದರಿಂದ ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
 

ಸರಿ, ಈಗ ನಾನು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಅಂಶ ಸೇರಿಸಲು ಬಯಸುವ ನಾವು ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ನೋಡೋಣ.
 ಮೊದಲ, ಒಂದು ಕಾರ್ಯವನ್ನು ಸೇರಿಸಿ ರೀತಿಯ ಶೂನ್ಯವನ್ನು ಇರುತ್ತದೆ
 ನಾನು ಏನು ಮರಳಲು ಬಯಸುವ ಕಾರಣ.
 ನಾನು ವಾದವನ್ನು ಒಂದು ಇಂಟ್ ತೆಗೆದುಕೊಳ್ಳಲು ಪಡೆಯಲಿದ್ದೇನೆ,
 ನಾನು ಸೇರಿಸಲು ಬಯಸುವ ಎಂಬುದನ್ನು ತಿಳಿಯಲು ಬಯಸುವ ಏಕೆಂದರೆ.
 ಹಾಗಾಗಿ ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ಎಂಬುದರ? ನಾನು newnode ಮೇಲೆ malloc ಮಾಡಬೇಕು,
 ಆದ್ದರಿಂದ ಮೊದಲ ಸಾಲು.
 ನಾನು ಕೇವಲ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಹಾಕಲು ಹೊಸ ನೋಡ್ ರಚಿಸುವ ನುಡಿದರು.
 ಹಾಗಾಗಿ ಏನು ಮಾಡಬಹುದು? ಅಲ್ಲದೆ, ನಾವು ತಿಳಿದಿರುವ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ನಮ್ಮ ಅಳವಡಿಕೆಗಳು
 ವರ್ಗ, ನಾವು ಯಾವಾಗಲೂ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಂದು ತಲೆ ಪುಟ್.
 ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು ತಲೆ ಬದಲಾವಣೆ.
 ನಾನು ಈ ಹೊಸ ನೋಡ್ ಹೊಸ ಮುಖ್ಯಸ್ಥ ಎಂದು ಮಾಡಬಹುದು,
 ಮತ್ತು ಇದು ಹಿಂದಿನ ತಲೆಗೆ ತೋರಿಸಲು ವಿಶೇಷವೇನು.
 ನಾವು ಹೇಗೆ ಮಾಡಬಹುದು? ನಾನು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ
 , ಮೌಲ್ಯ ಹೊಸ ನೋಡ್ 'ಎನ್' ಬದಲಾವಣೆ
 ಕಾರ್ಯ ಅಂಗೀಕರಿಸಿತು.
 ನಂತರ newnode ಮುಂದಿನ ತಲೆ ಏರಲಿದೆ.
 ತಲೆ newnode ಏರಲಿದೆ. ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಸರಳ.
 ಒಂದು ನೋಡ್ ಅಳಿಸುವುದು, ನಾವು ಹಾಗೆ ಮಾಡಬಹುದು -
 ನಾವು ಮಾಡಬಹುದಾದ ಒಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳಲು ಹೊಂದಿದೆ,
 ಸರಿ, ನಾನು ಅಳಿಸಲು ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, 3,
 ನಾನು ಹಾಗೆ ಕೇವಲ ಹಿಂದಿನ ನೋಡ್ ಪಾಯಿಂಟ್ ಆಗಿದೆ
 3 ಮುಂದಿನ ನೋಡ್.
 ಆದ್ದರಿಂದ ನಾನು ಆ ರೀತಿಯ ಮಾಡಲು ಎಂದು.
 ಆದರೆ ಅದನ್ನು ಮಾಡುವ ಸಮಸ್ಯೆ ಏನು?
 ನಾನು ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ನಾನು ಎಂದಿಗೂ ಸಂಖ್ಯೆ 3 ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ.
 ಸಮಸ್ಯೆ ನಾನು ನೋಡ್ ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನಾನೇನು ಎಂದು.
 ನಾನು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಮತ್ತು (ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ) ನನ್ನನ್ನು ದ್ವೇಷಿಸುವೆ ಹೋಗುತ್ತದೆ ಹೊಂದಿವೆ ಪಡೆಯಲಿದ್ದೇನೆ.
 ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಮಾಡುವ, ನಾನು ಬಹುಶಃ ತಾತ್ಕಾಲಿಕ ಪಾಯಿಂಟರ್ ಇರಬೇಕು.
 ಹಾಗಾಗಿ ಟೆಂಪ್ ಪುಟ್. ಇದು ನಾನು ಅಳಿಸಲು ನೋಡ್ ತೋರಿಸಲು ಹೋಗುತ್ತದೆ.
 ತದನಂತರ ನಾನು ಮುಂದಿನ ನೋಡ್ ತೋರಿಸಲು ಹಿಂದಿನ ಗ್ರಂಥಿಗಳು ಚಲಿಸಬಹುದು
 ನಾನು ಅಳಿಸಲು ನೋಡ್.
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ಪಾಯಿಂಟರ್ ಮಾಡಬಹುದು.
 ನಾನು ನಾನು ಅಲ್ಲಿ ರಚಿಸಿದ ಪಾಯಿಂಟರ್ ಹೊಂದಿದ್ದೀರಾ?
 ನಾನು, ಕೇವಲ ಇಲ್ಲ -
 ವ್ಯತ್ಯಾಸ ಈ ನೋಡ್ malloc ಬಳಸಿಕೊಂಡು ದಾಖಲಿಸಿದವರು ಎಂದು,
 ಈ ಒಂದು ಕೇವಲ ಸ್ಟಾಕ್ ನಲ್ ಸ್ವಿಚ್ ಎಂದು ಘೋಷಿಸಲಾಯಿತು ಸಂದರ್ಭದಲ್ಲಿ ಆದ್ದರಿಂದ, ರಾಶಿ ಇಲ್ಲಿದೆ. ಆದ್ದರಿಂದ ನಾನು ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿಲ್ಲ.
 

ಸರಿ. ಈಗ ರಾಶಿಯನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.
 ಬಣವೆಗಳು ಬಹಳ ಸರಳವಾಗಿದ್ದು.
 ನಾವು ಸರಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗ ಬಣವೆಗಳು ಮತ್ತು ಸಾಲುಗಳನ್ನು ಮಾಡಿದರು,
 ಆದರೆ ನೀವು ಪರಿಚಿತ ಇರಬೇಕು - ಕೇವಲ ತಿಳಿದಿರಲಿ
 ನೀವು ಸಹ ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಬಳಸಿ ಸಾಲುಗಳನ್ನು ಸ್ಟ್ಯಾಕ್ಗಳಲ್ಲಿ ಮಾಡಬಹುದು.
 ನೀವು ಒಂದು ಸರಣಿ ವೇಳೆ ಆದ್ದರಿಂದ, ಒಂದು ಸ್ಟಾಕ್ ಎಂದು?
 ಸ್ಟಾಕ್ ಮೊದಲ, ಒಂದು ಗಾತ್ರ ಹೊಂದಿವೆ ಹೊಂದಿರುತ್ತದೆ.
 ನೀವು ಇದೀಗ ಹೊಂದಿರುವ ಸ್ಟಾಕ್ ಗಾತ್ರ ಯಾವ ಶೇಖರಿಸಿಡಲು ಹೊಂದಿವೆ.
 ಮತ್ತು ನೀವು, ಸಂಖ್ಯೆಗಳ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ
 ಆದರೆ ನೀವು ಬಯಸಿದರೆ, ಒಂದು ರಚನೆಯ ಮಾಡಬಹುದು
 ತಂತಿಗಳ, struct ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ನೀವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ಏನು.
 ಸ್ಟಾಕ್ ಬಗ್ಗೆ: ಸ್ಟಾಕ್ ಮತ್ತು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ನಡುವಿನ ವ್ಯತ್ಯಾಸ
 ಸ್ಟಾಕ್ ನೀವು ಮಾತ್ರ ಸ್ಟಾಕ್ ಸೇರಿಸಲಾಗಿತ್ತು ಕೊನೆಯ ಅಂಶ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ ಎಂದು.
 ಇದು ಮೊದಲು, ಕಳೆದ ರಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ.
 ನೀವು ಟ್ರೇನಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಇರುವ ರೀತಿಯ
 ನೀವು ಸ್ಟಾಕ್ ಮೇಲೆ ಟ್ರೇ ಪುಟ್ ವೇಳೆ,
 ನೀವು ಇತರ ಟ್ರೇಗಳು ಪ್ರವೇಶವನ್ನು ಮೊದಲ ಟ್ರೇ ತೆಗೆದುಹಾಕಲು ಹೊಂದಿರುತ್ತವೆ.
 ಇದು ಸಂಗ್ರಹಗಳು ಅದೇ ವಿಷಯ.
 ನಾನು, ಉದಾಹರಣೆಗೆ, ಸ್ಟಾಕ್ ಒಂದು ಅಂಶ ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಏನು ಮಾಡಬೇಕು?
 ತಳ್ಳಿ ಎಂದು, ಮತ್ತು ಇದು ಬಹಳ ಸರಳ ವಿಶೇಷವೇನು.
 ನೀವು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ಪರಿಶೀಲಿಸಿ ವೇಳೆ, ಸಂಗ್ರಹದ ಗಾತ್ರ
 ಹೆಚ್ಚಿನ ಅಥವಾ ಸ್ಟಾಕ್ ಸಾಮರ್ಥ್ಯ ಸಮಾನವಾಗಿರುತ್ತದೆ ಅಲ್ಲ.
 ನೀವು ಈಗಾಗಲೇ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯದ ಮೇಲೆ ಇದ್ದರೆ, ನೀವು ಬೇರೇನೂ ಸೇರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
 ಅಲ್ಲ ನಂತರ, ನೀವು ಕೇವಲ ಸ್ಟಾಕ್ ಅಂಶ ಸೇರಿಸಲು ಹೊಂದಿವೆ.
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು. ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಸರಳ.
 ಆದ್ದರಿಂದ ನಾನು ಸಂಖ್ಯೆ 2 ಸೇರಿಸಿ.
 ನಾನು ಪಾಪ್ ಬಯಸಿದರೆ ಮತ್ತು, ಇದು ನಾನು ತೆಗೆದುಹಾಕಲು ಬಯಸುವ ಅರ್ಥ
 ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಅಂಶ ಮೌಲ್ಯವನ್ನು ಮರಳಲು ಕಳೆದ ಅಂಶ,
 ನಾನು ಪರಿಶೀಲಿಸಿ ಮೊದಲನೆಯದಾಗಿ ಸ್ಟಾಕ್ ಖಾಲಿ ಎಂದು.
 ಅದು ಖಾಲಿ ಇದ್ದರೆ, ನಾನು ಏನು ಮರಳಿ ಏಕೆಂದರೆ.
 ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು -1 ಹಿಂದಿರುಗಿದ ನುಡಿದರು.
 ಇಲ್ಲವಾದರೆ, ನಾನು ವಿಶೇಷ ಗಾತ್ರ ಇಳಿಕೆ ಪಡೆಯಲಿದ್ದೇನೆ
 ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು (s.size,) ಮರಳಲು.
 ನಾನು ಗಾತ್ರ ಇಳಿಕೆ ಮತ್ತು ನಂತರ, s.size ಮರಳಲು ನೀಡಲಿಲ್ಲ?
 ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಶೇಷ ಗಾತ್ರ 4 ಹೊಂದಿದೆ, ಕಾರಣ ಇದು,
 ಮತ್ತು ನಾನು ನಾಲ್ಕನೇ ಅಂಶ ಮರಳಿ ಬಯಸುವ, ಬಲ?
 ಆದರೆ ನಾಲ್ಕನೇ ಅಂಶ ಸೂಚ್ಯಂಕ ಎಂದರೇನು? ಮೂರು.
 ನಾನು ಗಾತ್ರ ರಿಂದ - 3 ಏರಲಿದೆ, ನಾನು (s.size,) s.numbers ಮರಳಬಹುದು
 ಇದು 3 ಏಕೆಂದರೆ. ಆದ್ದರಿಂದ ಕೇವಲ ಸೂಚ್ಯಂಕ.
 

ಈಗ ಸಾಲುಗಳನ್ನು. ಸಾಲುಗಳನ್ನು ಅತ್ಯಧಿಕವಾಗಿ ಒಂದೇ ಆಗಿವೆ.
 ವ್ಯತ್ಯಾಸವೆಂದರೆ, ಬದಲಿಗೆ ಕಳೆದ ರಲ್ಲಿ ಹೊಂದುವ, ಮೊದಲ ಔಟ್
 ನೀವು ಮೊದಲು, ಮೊದಲ ಹೊಂದಿವೆ.
 ನೀವು ಸಂಗೀತ ಹೋಗಲು ನಿರೀಕ್ಷಿಸುತ್ತಿವೆ ಬಹುಶಃ ವೇಳೆ,
 ನೀವು ಬದಲಿಗೆ ಕ್ಯೂ ಸ್ಟಾಕ್ ವೇಳೆ ನೀವು ಸಂತೋಷವಾಗಿರುವಿರಿ ಎಂದು.
 ಬರಲು ಕಳೆದ ವ್ಯಕ್ತಿಯಾಗಿ ಸಂಗೀತ ಪ್ರವೇಶಿಸಿದ ಮೊದಲ ವ್ಯಕ್ತಿ ಎಂದು.
 ನೀವು ಬಹುಶಃ ಸಂತೋಷವಾಗಿರುವಿರಿ ಎಂದು.
 ಸರದಿಯಲ್ಲಿ, ಪಡೆಯಲು ಮೊದಲ ವ್ಯಕ್ತಿ ಸಹ ಹೊರಬರಲು ಮೊದಲ ವ್ಯಕ್ತಿ.
 ಆದ್ದರಿಂದ ಒಂದು ಕ್ಯೂ ವ್ಯಾಖ್ಯಾನ, ಶ್ರೇಣಿಯಲ್ಲಿನ ಗಾತ್ರ ಹೊಂದಿರುವ ಅಲ್ಲದೆ,
 ನೀವು ಸ್ಟಾಕ್ ಮುಖ್ಯಸ್ಥ ಇಂಡೆಕ್ಸ್ ಇದು ತಲೆ, ಹೊಂದಿರಬೇಕು.
 ಇದೀಗ ಮೊದಲ ಅಂಶ ಆದ್ದರಿಂದ.
 ಸರತಿಯಲ್ಲದ ರಾಶಿಯನ್ನು ಪ್ರೇರಣೆಯ ಅದೇ ವಿಷಯ.
 ನೀವು ಬಹಳ ನಿಷ್ಕಪಟ, ನೀವು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದರು,
 ನಾನು ತಳ್ಳುವ ಮಾಡಿದರು ಹಾಗೂ, ನಾನು ನಿಖರವಾಗಿ ಒಂದೇ ಮಾಡಬಹುದು.
 ಇದು ಸಾಮರ್ಥ್ಯ ಮೀರಿ ಅಲ್ಲ ನಾನು ಪರಿಶೀಲಿಸಬಹುದು.
 ಇದು ಇದ್ದರೆ, ನಾನು ಇಲ್ಲದಿದ್ದರೆ ನಾನು ಹೊಸ ಮೌಲ್ಯದ ರಫ್ತು ಮಾಡಬಹುದು, ಸುಳ್ಳು ಹಿಂತಿರುಗಿ
 ತದನಂತರ ಗಾತ್ರ ಹೆಚ್ಚಿಸಲು.
 ಆದರೆ ಏಕೆ ಈ ತಪ್ಪು?
 ನ ಈ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.
 ನಾನು ವಿಷಯವನ್ನು ಒಂದು ಗುಂಪೇ ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು,
 ಮತ್ತು ನಂತರ ನಾನು dequeue ಮತ್ತು ಎನ್ಕ್ಯೂ ಪಡೆಯಲಿದ್ದೇನೆ.
 ಇಲ್ಲ ಆಜ್ಞೆಗಳನ್ನು ಸಂಗತಿಯೇ, ಆದರೆ ಇದು ಬಹಳ ಸರಳ.
 ನಾನು 5 ಎನ್ಕ್ಯೂ, ಆದ್ದರಿಂದ 5 ಸೇರಿಸಲು ನೀನು ತದನಂತರ 7, ಬಾಗುತ್ತೇನೆ
 1, 4, 6, ಮತ್ತು ನಂತರ ನಾನು ಏನನ್ನಾದರೂ dequeue ಬಯಸುವ,
 ಇದು ನಾನು ಮೊದಲ ಅಂಶ ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ ಅರ್ಥ.
 ಆದ್ದರಿಂದ ನಾನು, ಸಂಖ್ಯೆ 3 ತೆಗೆದುಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ?
 ಮೊದಲ ಅಂಶ. ಸರಿ.
 ನಾನು ಬೇರೆ ಏನಾದರೂ ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿದರೆ ಈಗ ಯಾವ ಸಂಭವಿಸಿ ಹೋಗಿ?
 ನನ್ನ ಅನುಷ್ಠಾನ ಪ್ರಕಾರ,
 ನಾನು ಸೂಚ್ಯಂಕ q.size ಮುಂದಿನ ಸಂಖ್ಯೆ ಹಾಕಲು ಹೋಗಿ.
 ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಗಾತ್ರ 8,
 ಆದ್ದರಿಂದ ಸೂಚ್ಯಂಕ 8 ಕೊನೆಯ ಸ್ಥಾನ ಇಲ್ಲಿಯೇ ಇರುತ್ತದೆ.
 ನಾನು ಇಲ್ಲಿಯೇ 1 ಎನ್ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿದರೆ, ನಾನು ಕಳೆದ ಸ್ಥಾನವನ್ನು ಮೇಲೆಯೆ ಎಂದು
 ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪು ಇದು ಸಂಖ್ಯೆ 1, ಗೆ.
 ಏನು ನಾನು ಬಯಸುವ ಸುಮಾರು ಕಟ್ಟಲು ಮತ್ತು ಮೊದಲ ಸ್ಥಾನವನ್ನು ಹೋಗಿ.
 ಬಹುಶಃ ನೀವು ಚೆನ್ನಾಗಿ, ನಾನು ಪರಿಶೀಲಿಸಿ, ಹೇಳುತ್ತಿದ್ದರು
 ನಾನು ನಿಜವಾಗಿ ಏನೋ ಹಾಕಬಹುದು.
 ಅಲ್ಲ, ನಾನು ಓಹ್, ಹೊಸ ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೇಳುತ್ತಾರೆ
 ವಾಸ್ತವವಾಗಿ ಸಾಮರ್ಥ್ಯ - 1, ಮತ್ತು ನೀವು ಒಂದು ಅಂಶ ಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.
 ಆದರೆ ಸಮಸ್ಯೆ ಏನು? ಸಮಸ್ಯೆ ಎಂದು ನಾನು ಇಲ್ಲಿ ಎಲ್ಲವೂ dequeue ವೇಳೆ
 ಮತ್ತು ನಂತರ ನಾನು ಯಾವುದೋ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿ, ಇದು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದರು,
 ಅಲ್ಲದೆ, ನೀವು 0 ಇದು ಪೂರ್ಣ ಸಾಮರ್ಥ್ಯವನ್ನು ನಲ್ಲಿ ಇದ್ದರು.
 ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕ್ಯೂ ಹೋದ.
 ನೀವು ಸುಮಾರು ಕಟ್ಟಲು, ಮತ್ತು ಸುತ್ತಲೂ ಸುತ್ತಿಕೊಳ್ಳುವ ಒಂದು ರೀತಿಯಲ್ಲಿ
 ನೀವು ದಾರ್ಶನಿಕ ಮತ್ತು ಇತರ psets ಕಲಿತ ವ್ಯಕ್ತಿಗಳು ಮೋಡ್ ಬಳಸಿ ಎಂದು.
 ನೀವು q.size + q.head ಏಕೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮನೆಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಬಹುದು
 ಮಾಡ್ ಸಾಮರ್ಥ್ಯ, ಆದರೆ ನೀವು ಇಲ್ಲಿಯೇ ಪರಿಶೀಲಿಸಿ ವೇಳೆ,
 ನಾವು ಕೆಲಸ ನೋಡಬಹುದು.
 ಆದ್ದರಿಂದ ಕೊನೆಯ ಉದಾಹರಣೆಯಲ್ಲಿ, 8 q.size ಆಗಿತ್ತು
 ಇಲ್ಲಿ ರಚನೆಯ ಈ ಸ್ಥಾನವನ್ನು ಏಕೆಂದರೆ ಮತ್ತು ತಲೆ, 1 ಆಗಿತ್ತು.
 ಆದ್ದರಿಂದ + 1 8, 9 ಇರುತ್ತದೆ. ಮಾಡ್ ಸಾಮರ್ಥ್ಯ 9 0 ಆಗಿರುತ್ತದೆ.
 ಇದು ಸೂಚ್ಯಂಕ 0 ಹೋಗುತ್ತಿದ್ದೆ. ನಾವು ಸರಿಯಾದ ಸ್ಥಾನದಲ್ಲಿ ಇರುವಿರಿ. ತದನಂತರ ಮನೆಯಲ್ಲಿ ಕ್ಯೂ ಪ್ರಯತ್ನಿಸಿ.
 ಕೆಲವು ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು: ಒಂದು ಸ್ಟಾಕ್ ಮತ್ತು ಕ್ಯೂ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ತಿಳಿಯಲು ಪ್ರಯತ್ನಿಸಿ.
 ಮನೆಯಲ್ಲಿ, ಎನ್ಕ್ಯೂ, dequeue, ಪುಶ್ ಮತ್ತು ಪಾಪ್ ಅನುಷ್ಠಾನಕ್ಕೆ ಅತ್ಯಂತ ಪರಿಚಿತ ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸಿ.
 ನೀವು ಅವರನ್ನು ಪ್ರತಿ ಬಳಸಬಹುದು ಆಗ ಅರ್ಥ.
 

ಆದ್ದರಿಂದ Pokemons ಕನಸುಗಳಿವೆ 10 ಸೆಕೆಂಡುಗಳ ಕಾಲ ವಿಶ್ರಾಂತಿ ಅವಕಾಶ.
 ಮತ್ತು ಈಗ ಮತ್ತೆ ಡೇಟಾ ರಚನೆಗಳು ಹೋಗಿ ಅವಕಾಶ.
 ಕೋಷ್ಟಕಗಳು ಹ್ಯಾಶ್. ಬಹಳಷ್ಟು ಜನರು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಹೆದರುತ್ತಿದ್ದರು.
 ಸಮಸ್ಯೆ 6 ಸೆಟ್ ನಲ್ಲಿ, ಪದಪರೀಕ್ಷಕ.
 ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಮತ್ತು ಪ್ರಯತ್ನಗಳ, ಜನರು ಬಹಳಷ್ಟು ಅವುಗಳನ್ನು ದಿಗಿಲುಗೊಂಡ ಪಡೆಯಿರಿ.
 ಅವರು ತಿಳಿಯಲು ಆದ್ದರಿಂದ ಹಾರ್ಡ್ ನನಗನ್ನಿಸುತ್ತದೆ. ಹೌದು?
 [ರಾಬ್ ಬೌಡೆನ್] ಪ್ರಾಬ್ಲಂ 5 ಸೆಟ್. 

ಸಮಸ್ಯೆ ಹೌದು, 5 ಸೆಟ್. ಧನ್ಯವಾದಗಳು ರಾಬ್.
 ಹೌದು. ಆರು ಹಫ್ ಎನ್ 'ಪಫ್, ಹೌದು ಆಗಿತ್ತು.
 ಪ್ರಾಬ್ಲಂ ಪದಪರೀಕ್ಷಕ ಮಾಡಲಾಯಿತು 5 ಸೆಟ್, ಮತ್ತು ನೀವು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಅಥವಾ ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಎರಡೂ ಬಳಸಲು ಹೊಂದಿತ್ತು.
 ಬಹಳಷ್ಟು ಜನರು ಅವರು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸೂಪರ್ ಹಾರ್ಡ್ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ, ಆದರೆ ವಾಸ್ತವವಾಗಿ ಬಹಳ ಸರಳ ಆರ್.
 ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಮೂಲತಃ, ಏನು? ಹ್ಯಾಷ್ ಟೇಬಲ್ ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.
 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ
 ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಎಂದು ಏನೋ ಹೊಂದಿರುತ್ತವೆ.
 ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಎಂದರೇನು?
 ನೀವು ಹುಡುಗರಿಗೆ ಇಲ್ಲಿ ಓದಬಹುದು ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.
 ಈ ಒಂದು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕದ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
 ಆದ್ದರಿಂದ ನೀವು 31 ಅಂಶಗಳೊಂದಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ ನೋಡಬಹುದು.
 ಮತ್ತು ನಾವು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಮಾಡಲು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಇದೆ
 ಒಂದು ಪ್ರಮುಖ ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ, ಪ್ರತಿ ಸೂಚ್ಯಂಕ ಇಂಟ್.
 , ಉದಾಹರಣೆಗೆ, ನಾನು ಬಿ ಹ್ಯಾರಿಸನ್ ಆಯ್ಕೆ ಬಯಸಿದರೆ,
 ನನ್ನ ಹ್ಯಾಶ್ ಕ್ರಿಯೆಗಳನ್ನು ಬಿ ಹ್ಯಾರಿಸನ್ ಹಾಕುತ್ತಾನೆ,
 ಮತ್ತು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ 24 ಹಿಂದಿರುಗುತ್ತಿದ್ದವು.
 ಆದ್ದರಿಂದ ನಾನು 24 ರಲ್ಲಿ ಬಿ ಹ್ಯಾರಿಸನ್ ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ತಿಳಿದಿದೆ.
 ಇದರಿಂದ ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ ಮತ್ತು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಹೊಂದಿರುವ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಇಲ್ಲಿದೆ.
 ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ನೀವು ಹೇಳಲು ಹೋಗುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್ ಮಾಡುತ್ತೇವೆ
 ಅಲ್ಲಿ ನೀವು ಸಂಗ್ರಹಿಸಲು ಬಯಸುವ ದತ್ತಾಂಶವನ್ನು ಶೇಖರಿಸಿಡಲು.
 ಹ್ಯಾಶ್ ಕ್ರಿಯೆ, ನೀವು ಒಂದು ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ನೋಡಲು ಬಯಸುವ
 ಎಂದು ಕಂಡುಹಿಡಿಯುವಿಕೆ ಹಾಗೂ ಚೆನ್ನಾಗಿ ವಿತರಿಸಲಾಗುತ್ತದೆ.
 ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಎಂದು, ನೀವು ನಾನು ಶೇಖರಿಸಿಡಲು ಬಯಸಿದ್ದರು ಎಂದು ದಶಮಾಂಶ ಬಹಳಷ್ಟು ವಾಸ್ತವವಾಗಿ 19 ಎಂದು ನೋಡಿ
 ಬದಲಿಗೆ ಎಲ್ಲಾ ಉಚಿತ ಇದರಲ್ಲಿ 31 ಮತ್ತು 30 ಮತ್ತು 29, ಬಳಸಿ.
 ಆದ್ದರಿಂದ ನಾನು ಬಳಸಿದ ಹ್ಯಾಶ್ ಕ್ರಿಯೆ ಬಹಳ ಚೆನ್ನಾಗಿ ವಿತರಣೆ ಅಲ್ಲ.
 ನಾವು ಚೆನ್ನಾಗಿ ವಿತರಣೆ ಹೇಳುವುದಾದರೆ, ಇದು, ನಾವು ಬೇಕು ಎಂದರ್ಥ
 ಸ್ಥೂಲವಾಗಿ, ಕನಿಷ್ಠ 1 ಅಥವಾ ಪ್ರತಿ 2 -
 ಹಾಗೆ, ಸರಣಿಗಳ ಸೂಚ್ಯಂಕಗಳು ಪ್ರತಿಯೊಂದು 1 ಅಥವಾ 2 ಒಂದು ವ್ಯತ್ಯಾಸ.
 ನೀವು, ಸ್ಥೂಲವಾಗಿ, ಶ್ರೇಣಿಯಲ್ಲಿನ ಪ್ರತಿ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದೇ ಸಂಖ್ಯೆಯ ಬೇಕು.
 ಮತ್ತು ಇದು, ಹ್ಯಾಷ್ ಟೇಬಲ್ ನಲ್ಲಿ ಮಾನ್ಯವಾದ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ವೀಕ್ಷಿಸಲು ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಸುಲಭ.
 

ನಂತರ ಮರಗಳು. ಈ ಒಂದು ಮರವಾಗಿದೆ.
 ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಮರಗಳು ಕಾರಣಕ್ಕೆ ತಲೆಕೆಳಗಾಗಿ ಇವೆ.
 ಆದ್ದರಿಂದ ಇಲ್ಲಿಯೇ ನೀವು ಮರದ ಬೇರಿನ ಮತ್ತು ನಂತರ ಎಲೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
 ನೀವು ಪೋಷಕರು ಮತ್ತು ಮಗುವಿಗೆ ನಾಮಕರಣ ತಿಳಿಯಬೇಕಿದೆ.
 ಪ್ರತಿ ನೋಡ್ ಮೂಲ ಕೆಳಗಿರುವ ಗ್ರಂಥಿಗಳು ಅದರ ಮಕ್ಕಳು, ಹೊಂದಿದೆ.
 ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, 2, ಬಲ ಅಲ್ಲಿ 3 ಮತ್ತು ಇತರ ಮಗುವಿಗೆ ಪೋಷಕ ಏರಲಿದೆ
 3 1 ಪೋಷಕ ಮತ್ತು ಇವೆ ಎಂದು ಇತರ ಮಕ್ಕಳು ಹೋಗುವ ಸಮಯ.
 ಮತ್ತು 1 ಹೀಗೆ 3 ಮಗು ಎಂದು ಹೋಗುತ್ತದೆ.
 ನಾವು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಏನೋ, ಒಂದು ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಯನ್ನು ಎಂದು
 ಇದು ಒಂದು ನೋಡ್ ಬಲ ಮೇಲೆ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು
 ಇಲ್ಲಿಯೇ, ಬಲ ಮೇಲೆ ಹೋಗುವ - ಬಲ,
 ಮೂಲ ಅಂಶ ಹೆಚ್ಚು ಎಂದು ಹೋಗುವ.
 ಬಲ ಮೇಲೆ ಹಾಗಾಗಿ ಇಲ್ಲಿಯೇ ಸಂಖ್ಯೆ 5 ಹೊಂದಿದ್ದರೆ, ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು
 5 ಹೆಚ್ಚು ಎಂದು ಹೋಗುವ, ಮತ್ತು ಎಡ ಮೇಲೆ
 ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು 5 ಕಡಿಮೆ ಎಂದು ಹೋಗುವ.
 ಏಕೆ ಈ ಉಪಯುಕ್ತ?
 ನಾನು ಸಂಖ್ಯೆ 7 ಇಲ್ಲಿ ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ವೇಳೆ, ಉದಾಹರಣೆಗೆ,
 ನಾನು ಮೊದಲ 5 ಹೋಗಿ ನಾನು ನೋಡಿ ಪಡೆಯಲಿದ್ದೇನೆ, 5 7 ಹೆಚ್ಚಿನ ಅಥವಾ ಕಡಿಮೆ?
 ಇದು ಹೆಚ್ಚಿನ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಮರದ ಬಲ ಮೇಲೆ ಇರಬೇಕು ವಿಶೇಷವೇನು ತಿಳಿದಿರುವ.
 ಹಾಗಾಗಿ ನೋಡಲು ಕಡಿಮೆ ವಿಷಯವನ್ನು ಹೊಂದಿಲ್ಲ.
 ಒಂದು ಬೈನರಿ ಸರ್ಚ್ ಟ್ರೀಯನ್ನು, ನೋಡ್ ಅಳವಡಿಕೆಯಲ್ಲಿ, ನಾನು, ದಶಮಾಂಶ ಹೊಂದಿರಬೇಕು ಪಡೆಯಲಿದ್ದೇನೆ
 ಆದ್ದರಿಂದ ಇಂಟ್ N; ನೀವು ಸ್ಟ್ರಿಂಗ್ ತೋರಿಸಬಹುದಿತ್ತು
 ಅಥವಾ ನೀವು ಬಯಸಿದ ಏನೂ.
 ನೀವು ಹೆಚ್ಚಿನ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಮೇಲೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಇರಬೇಕು, ಕಡಿಮೆ ಏನು.
 ಆದ್ದರಿಂದ ನೀವು ತಂತಿ ಹೊಂದಿತ್ತು, ಉದಾಹರಣೆಗೆ, ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
 ಬಲ ಮೇಲೆ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ದೊಡ್ಡ ಉದ್ದ ಮಾಡಲಿಕ್ಕೆ ಎಂದು,
 ಎಡ ಕಡಿಮೆ ಉದ್ದವನ್ನು ಹೋಗುವ, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಅಪ್.
 

ನಾನು ಹೇಗೆ BST ಹೇಗೆ ಬಳಸಿಕೊಂಡು?
 ನಾವು ಮಾಡುತ್ತೇವೆ ಮೊದಲನೆಯದಾಗಿ ಮೂಲ ಶೂನ್ಯ ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ.
 ಇದು ಶೂನ್ಯ ಆಗಿದ್ದರೆ, ಅದು ವಿಷಯ ಇಲ್ಲ ಎಂದರ್ಥ
 ನೀವು ಸಹ ಒಂದು ಮರ, ಬಲ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ?
 ಹಾಗಾಗಿ ತಪ್ಪು ಹಿಂತಿರುಗಿ.
 ಇಲ್ಲವಾದರೆ, ನಾನು ಸಂಖ್ಯೆ ಹೆಚ್ಚಿನ ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ
 ಮೂಲ ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚು.
 ನಾನು ಮೇಲೆ ಅಂಶ ಹುಡುಕಲು ಪ್ರಯತ್ನಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ
 ಮರದ.
 ನೀವು ನಾನು ಇಲ್ಲಿ ಪುನರಾವರ್ತನ ಬಳಸಿಕೊಂಡು ನಾನು ನೋಡಿ.
 ಇದು ಕಡಿಮೆ ಇದ್ದರೆ ನಂತರ, ನಾನು ಎಡ ನೋಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಹೆಚ್ಚಿನ ಕಡಿಮೆ ಅಥವಾ ಅಲ್ಲ ವೇಳೆ,
 ಇದು ಮೌಲ್ಯ ಸ್ವತಃ ಎಂದರ್ಥ.
 ಆದ್ದರಿಂದ ನಾನು ನಿಜವಾದ ಹಿಂತಿರುಗಿ.
 ನೀವು ನಾನು ವೇಳೆ, ವೇಳೆ, ವೇಳೆ ಬಳಸಲಾಗುತ್ತದೆ ಇಲ್ಲಿ ನೋಡಬಹುದು.
 ಮತ್ತು ನೆನಪಿಡಿ ರಸಪ್ರಶ್ನೆ 0, ನಾವು, ವೇಳೆ, ವೇಳೆ ಎಂದು ಸಮಸ್ಯೆ
 ಮತ್ತು ನೀವು ಅದಕ್ಷ ಹೇಗೆ ಭಾವಿಸಲಾಗಿತ್ತು,
 ಮತ್ತು ಅದಕ್ಷ ನೀವು ಬಳಸಿದ ಆಗಿತ್ತು. ನೀವು ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ವೇಳೆ ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಬೇರೆ ಮಾಡಬೇಕು.
 ವೇಳೆ ಮತ್ತು ಬೇರೆ ವೇಳೆ ಮತ್ತು ಬೇರೆ ಇಲ್ಲಿ ಆದ್ದರಿಂದ, ನಾನು ಬೇರೆ ಬಳಸಬೇಕು?
 ಡಸ್ ಯಾರಾದರೂ - ಹೌದು?
 [ವಿದ್ಯಾರ್ಥಿ ಮಾತನಾಡುವ, ಕೇಳಿಸುವುದಿಲ್ಲ]
 ಆ ಪರಿಪೂರ್ಣ ಇಲ್ಲಿದೆ. ಆದ್ದರಿಂದ ಅವರು, ಇದು ವಿಷಯವಲ್ಲ ಎಂದು ಹೇಳುವ
 ಕೇವಲ ನಾವು ಮೊದಲು ಎಂದು ಅದಕ್ಷ
 ಎಂದು, ಕೆಲವು ಸ್ಥಿತಿಯನ್ನು ತೃಪ್ತಿ ಬಹುಶಃ ವೇಳೆ, ಏಕೆಂದರೆ
 ಆದ್ದರಿಂದ ಕ್ರಿಯಾಶೀಲ ಪ್ರದರ್ಶಿಸಿದರು ಆದರೆ ನಂತರ ನೀವು ಇತರ ಪರಿಸ್ಥಿತಿಗಳು ಎಲ್ಲಾ ಪರಿಶೀಲಿಸಿ ಹೊರಟಿದ್ದ.
 ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಈಗಿನಿಂದಲೇ ಮರಳಿದರು, ಆದ್ದರಿಂದ ಇದು ವಿಷಯವಲ್ಲ.
 ಆದ್ದರಿಂದ ನೀವು ಬೇರೆ ಬಳಸಲು ಇಲ್ಲ.
 

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನ ಪ್ರಯತ್ನಗಳಲ್ಲಿ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ,
 ಇದು ಪ್ರತಿಯೊಬ್ಬರ ಮೆಚ್ಚಿನ ಆಗಿದೆ.
 ಪ್ರಯತ್ನಿಸಿ ಸಾಲುಗಳು ಮರವಾಗಿದೆ.
 ಇದು ಮೌಲ್ಯಗಳನ್ನು ಹುಡುಕುವ ಅತ್ಯಂತ ವೇಗವಾಗಿ, ಆದರೆ ಮೆಮೊರಿ ಬಹಳಷ್ಟು ಬಳಸುತ್ತದೆ.
 ಮತ್ತು ಪದಗಳನ್ನು ಫಿಲ್ಟರ್ ಸಾಮಾನ್ಯವಾಗಿ, ಆದ್ದರಿಂದ ನೀವು
 ನಿಮ್ಮ ಫೋನ್ ಫೋನ್ ಪುಸ್ತಕ, ಉದಾಹರಣೆಗೆ, ನನಗೆ ಗೊತ್ತಿಲ್ಲ, ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುತ್ತೀರಿ
 ಮತ್ತು ನೀವು ಬಿ ಟೈಪ್ ಮಾಡಲು ಬಯಸುವ
 ಮತ್ತು ಕೇವಲ ಬಿ ಜನರ ಹೆಸರುಗಳು
 ಇದು ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತ ಬಹಳ ಸುಲಭ.
 ನೀವು ಪ್ರಯತ್ನಿಸಿ ಒಂದು ನೋಡ್ ವ್ಯಾಖ್ಯಾನಿಸಲು ಇಲ್ಲ?
 ನೀವು is_word ಏರಲಿದೆ ಎಂದು ಒಂದು bool ಹೊಂದಿರಬೇಕು.
 ಆ, ಎಂದು ನೋಡ್ ಮೊದಲು ಎಲ್ಲಾ ಪಾತ್ರಗಳು ಬಳಸಿ ಎಂದು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
 ನೀವು ಒಂದು ಪದ ರೂಪಿಸಲು ಸಾಧ್ಯವಾಯಿತು,
 ತದನಂತರ ನೀವು ಗ್ರಂಥಿಗಳು ರೀತಿಯು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ.
 ನೀವು ನಾವು ಪೇರೆಂಟ್ ನೋಡ್ಗಳನ್ನು ರಚನೆಯ, ಆದ್ದರಿಂದ ನೋಡ್ * ಸರಣಿ ಎಂದು ನೋಡಬಹುದು? ಹೌದು?
 ಇದರಿಂದ ಆ ಕೆಲಸ ಹೇಗೆ ನೋಡೋಣ. ಕಾಗುಣಿತ ಚೆಕ್,
 ನಾವು 27 ಅಂಶಗಳ ಒಂದು ಸರಣಿ,
 ನಾವು ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ಪ್ಲಸ್ ಅಪಾಸ್ಟ್ರಫಿ ಏಕೆಂದರೆ.
 ನಾನು ಮಂಡಳಿಯಲ್ಲಿ ಬರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಬಯಸುವ ಏಕೆಂದರೆ ಇಲ್ಲಿ ಮೊದಲು ನಾನು 2 ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.
 ಸರಿ. ಆದ್ದರಿಂದ ಈ ಒಂದು ಪ್ರಯತ್ನಿಸಿ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
 ನಾನು ಮೊದಲ ನೋಡ್ ವ್ಯಾಖ್ಯಾನಿಸಲು, ನಾನು 2 ಅಂಶಗಳ ಒಂದು ಸರಣಿ ಹೊಂದಿರುತ್ತದೆ
 ಶೂನ್ಯ 2 ಪಾಯಿಂಟರ್ಸ್, ಆದ್ದರಿಂದ ನಾನು 'ಎ' ಮತ್ತು 'ಬಿ' ಪುಟ್.
 ನಾನು is_word ಹೇಳುತ್ತದೆ ಒಂದು bool ಹೊಂದಿವೆ ಪಡೆಯಲಿದ್ದೇನೆ.
 ಇದು ಮೊದಲ ಒಂದು ಸುಳ್ಳು ಎಂದು ವಿಶೇಷವೇನು,
 ಕೇವಲ, ಏಕೆಂದರೆ ಮೊದಲು ನೀವು ಯಾವುದೇ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿಲ್ಲ.
 ಆದ್ದರಿಂದ ಖಾಲಿ ಪದ ಒಂದು ಪದ ಅಲ್ಲ. ಆದ್ದರಿಂದ ತಪ್ಪು.
 ನಾನು ಈ ನಿಘಂಟು 'ಒಂದು' ಸೇರಿಸಲು ಬಯಸಿದರೆ, ನಾನು ಏನನ್ನು ಎಂದು?
 ನಾನು 'ಒಂದು' ಹೊಸ ನೋಡ್ malloc ಹೊಂದಿರುತ್ತದೆ,
 ತದನಂತರ ನಿಜವಾದ ತನ್ನ ಪದ ಸೇರಿಸಿ.
 ಆದ್ದರಿಂದ ಕೇವಲ 'ಒಂದು' ನಿಜವಾದ ಏರಲಿದೆ ನಂತರ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಅರ್ಥ?
 ನಾನು 'ಬಾ' ಸೇರಿಸಲು ಬಯಸಿದರೆ ನಂತರ, ನಾನು 'ಬಿ' ಗೆ malloc 1 ಮಾಡಬೇಕಾಗಬಹುದು,
 ತದನಂತರ ನಾನು ಸುಳ್ಳು ಬೂಲಿಯನ್ ಸ್ಥಾಪಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
 ಸ್ವತಃ 'ಬಿ' ಒಂದು ಪದ ಅಲ್ಲ ಏಕೆಂದರೆ.
 ನಂತರ ನಾನು ಮತ್ತೊಂದು 'ಒಂದು' ಒಂದು, ಆದ್ದರಿಂದ 'ಬಾ' malloc ಪಡೆಯಲಿದ್ದೇನೆ
 ಮತ್ತು ನಂತರ ನಾನು ನಿಜವಾದ ವರ್ಡ್ ಸ್ಥಾಪಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.
 'ಬಾ' ಒಂದು ಪದ ಕಾರಣ.
 ನಾನು ನೋಡಲು ಬಯಸಿದರೆ ತದನಂತರ 'ಬಿ', ಈ ನಿಘಂಟಿನಲ್ಲಿ ವೇಳೆ
 ನಾನು ಮೊದಲ ಒಂದು, 'ಬಿ' ಹೋಗಿ. ನಾನು ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು ನಾನು ಪದ ನೋಡಲು ಮತ್ತು ಅದು ತಪ್ಪು ಹೇಳುತ್ತಾರೆ.
 ಆದ್ದರಿಂದ ಒಂದು ಪದ ಅಲ್ಲ. ನಾನು 'ಬಾ' ಪರಿಶೀಲಿಸಿ ಬಯಸಿದರೆ,
 ನಾನು ಮೊದಲ ಒಂದು, 'ಬಿ' ಗೆ ಹೋಗಿ, ನಂತರ 'ಒಂದು' ಹೋಗಿ, ಮತ್ತು ನಾನು ನಿಜವಾದ ನೋಡಿ, ಆದ್ದರಿಂದ ಒಂದು ಪದ. ಅರ್ಥ?
 ಬಹಳಷ್ಟು ಜನರು ಪ್ರಯತ್ನಗಳ ಮೂಲಕ ತಪ್ಪಾಗಿ. ಯಾವುದೇ?
 

ಅಂತಿಮವಾಗಿ, ಹಫ್ಮನ್ ಕೋಡಿಂಗ್. ಹಫ್ಮನ್ ಕೋಡಿಂಗ್ ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ
 ಮೆಮೊರಿ ಉಳಿಸಲು ಮತ್ತು ಪಠ್ಯ ಕಡತಗಳನ್ನು ಸಂಕುಚಿತ,
 ಕೇವಲ ನೀವು ಉದಾಹರಣೆಗೆ, 'ಎ' ಮತ್ತು 'ಇ' ಬಳಸಲು ಬಾರಿ ಸಾಕಷ್ಟು,
 ನೀವು ಹುಡುಗರಿಗೆ ಹೆಚ್ಚು 'ಕ್ಯೂ' ಅಥವಾ 'Z' ಬಳಸುತ್ತಿದ್ದರೆ ನಿಮ್ಮ ದಾಖಲೆಗಳನ್ನು, ಆದರೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.
 ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಕೇವಲ 1 ಬೈಟ್ ಹೊಂದಿರುವ,
 ಪ್ರತಿಯೊಂದು - ನಾವು ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಹೊಂದಿರುವ 256 ಪಾತ್ರಗಳು ಬಹಳ ಸೂಕ್ತ ಅಲ್ಲ,
 ನೀವು ಹೆಚ್ಚು ಬಳಸುವ ಕೆಲವು ಪಾತ್ರಗಳು ಇವೆ ಕಾರಣ
 ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಆ ಕಡಿಮೆ ಮೆಮೊರಿ ಬಳಸಬೇಕು.
 ನಾನು ಹೇಗೆ ಹಫ್ಮನ್ ಕೋಡಿಂಗ್ ಬಳಸುವುದು?
 ನಾವು ಹಫ್ಮನ್ ಮರದ ಮಾಡಬೇಕು.
  ಹಫ್ಮನ್ ಮರದ ಗ್ರಂಥಿಗಳು ಹೊಂದಿದೆ
 ಪತ್ರ, 'ಸಿ', 'ಬಿ', 'ಒಂದು', ಹಾಗೆ ಹೋಗುತ್ತದೆ ಸಂಕೇತವಾಗಿ ಎಂದು,
 ನೀವು ಏನೇ ಅಕ್ಷರದ, ಪದದ ಪಠ್ಯ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಆವರ್ತನ ಒಂದು ಆವರ್ತನ,
 ನೀವು, ಫಾರ್ ಹಫ್ಮನ್ ಮರದ ಸೃಷ್ಟಿಸುತ್ತಿದ್ದಾರೆ ಎಂದು
 ತದನಂತರ ಹಫ್ಮನ್ ಮರದ ಎಡ ತೋರಿಸಲು ಹೋಗುತ್ತದೆ ಒಂದು ನೋಡ್
 ಮತ್ತು ಬಲ ತೋರಿಸಲು ಏರಲಿದೆ ಮತ್ತೊಂದು ನೋಡ್. ಆದ್ದರಿಂದ ಕೇವಲ ಒಂದು ಮರ.
 ಹೇಗೆ ನೀವು ಹಫ್ಮನ್ ಮರದ ನಿರ್ಮಿಸಲು ಇಲ್ಲ?
 ನೀವು ಕಡಿಮೆ ಆವರ್ತನಗಳನ್ನು ಹೊಂದಿರುವ 2 ಗ್ರಂಥಿಗಳು ಆಯ್ಕೆ ನೀನು.
 ನೀವು ಟೈ ಇದ್ದರೆ ನೀವು 2 ಗ್ರಂಥಿಗಳು ಆಯ್ಕೆ ನೀನು
 ಹಾಗೆಯೇ ಕಡಿಮೆ ಮಾಡಿದ ASCII ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ.
 ನಂತರ ನೀವು ಆ 2 ಗ್ರಂಥಿಗಳು ಔಟ್ ಹೊಸ ಮರ ರಚಿಸಲು ನೀನು
 ಪೋಷಕ ನೋಡ್ ಸೇರಿ ಆವರ್ತನ ಮಾಡಲಿಕ್ಕೆ ಇದೆ.
 ತದನಂತರ ನೀವು ಕಾಡು 2 ಮಕ್ಕಳ ತೆಗೆದು ನೀನು
 ಮತ್ತು ಮೂಲ ಅವುಗಳನ್ನು ಬದಲಿಗೆ.
 ಮತ್ತು ನೀವು ಮಾತ್ರ ಕಾಡಿನಲ್ಲಿ 1 ಮರದ ತನಕ ಎಂದು ಪುನರಾವರ್ತಿಸಲು ನೀನು.
 ಆದ್ದರಿಂದ ನೀವು, Zamyla ಹಫ್ಮನ್ ಮರದ ಮಾಡಲು ಹೇಗೆ ನೋಡೋಣ.
 ನೀವು ಎಲ್ಲಾ ಅಕ್ಷರಗಳು 'ಎ' ಹೊರತುಪಡಿಸಿ ಆವರ್ತನ 1 ಹೊಂದಿರುವ ಇಲ್ಲಿ ನೋಡಬಹುದು; ಆವರ್ತನ 2 ಹೊಂದಿದೆ.
 ಆದ್ದರಿಂದ ನಾನು ASCII ಮೌಲ್ಯ ಮತ್ತು ಆವರ್ತನದ ಸಲುವಾಗಿ ಪುಟ್ ಎಲ್ಲಾ ಅಕ್ಷರಗಳು ಗ್ರಂಥಿಗಳು ದಾಖಲಿಸಿದವರು.
 ನಾನು ಮೊದಲ ಮರ ರಚಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು 'ಎಲ್' ಮತ್ತು 'ಎಮ್' ಇರುತ್ತದೆ.
 ಆದ್ದರಿಂದ ಇಲ್ಲಿ. ಜೋಡಿ ಆವರ್ತನ 2 ಆಗಿರುತ್ತದೆ
 + 1 1 ಏಕೆಂದರೆ, ನಂತರ ಕಡಿಮೆ ಆವರ್ತನಗಳಲ್ಲಿ ಮುಂದಿನ 2 'ವೈ' ಮತ್ತು 'ಝಡ್' ಇವೆ.
 2 ಒಂದು ಆವರ್ತನ ಹೊಂದಿವೆ - ತದನಂತರ ನಾನು ಎಂಬ ಎಲ್ಲಾ ಹೊಂದಿವೆ.
 ಆದ್ದರಿಂದ ಮುಂದಿನ ಒಂದು ಕಡಿಮೆ ASCII ಮೌಲ್ಯ ಬಯಸುವುದನ್ನು ಇದು ಇವನ್ನು?
 'ಎ' ಮತ್ತು 'ಎಲ್'. ಹಾಗಾಗಿ ಹೊಸ ನೋಡ್ ರಚಿಸಲು,
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇದು 4 ಮತ್ತು 2, ಆದ್ದರಿಂದ 2 ಎಡ ಏರಲಿದೆ.
 ಮತ್ತು ಈ ಹಫ್ಮನ್ ಮರವಾಗಿದೆ. ನಾನು ಕೆಲವು ಪಠ್ಯ ಬರೆಯಲು ಬಯಸುವ ನಂತರ ವೇಳೆ,
 ಹಾಗೆ ಹಫ್ಮನ್ ಮರದ ಬಳಸಿ, ಪಠ್ಯ ಮತಾಂತರಗೊಳ್ಳಲು ಅವಳಿ ಬಹಳ ಸುಲಭ.
 ನಾನು ಎಡಕ್ಕೆ ಚಲಿಸುವ 0 ಮತ್ತು ಬಲಕ್ಕೆ ಚಲಿಸುವ ಎಂದು ಹೇಳಲು ಉದಾಹರಣೆಗೆ, ಒಂದು 1
 ಏನು ಪ್ರತಿನಿಧಿಸಲು ಎಂದು?
 ಆದ್ದರಿಂದ ಹಾಗೆ 1, 1, ಬಲ, ಆದ್ದರಿಂದ ಬಲ,
 ತದನಂತರ ಆದ್ದರಿಂದ ಬಿಟ್ಟು 0, ಎಲ್ ಎಂದು, ಮತ್ತು ನಂತರ 1, 0, 0.
 ಆದ್ದರಿಂದ 1, 0, ಆದ್ದರಿಂದ ಕೇವಲ 1, 0, 'ಎ'.
 ತದನಂತರ 0, 1, ಆದ್ದರಿಂದ 'ಝಡ್'.
 ತದನಂತರ 1, 0, 0 - ಯಾವುದೇ.
 0, 0 'ವೈ' ಎಂದು, ಆದ್ದರಿಂದ ಲೇಜಿ ಕಾಣಿಸುತ್ತದೆ.
 ಆದ್ದರಿಂದ ನನ್ನನ್ನು ಅಷ್ಟೆ ರಾಬ್ ಮೇಲೆ ತೆಗೆದುಕೊಳ್ಳುವುದು.
 

[ರಾಬ್ ಬೌಡೆನ್] ಆದ್ದರಿಂದ, ವಾರ 7 ಸ್ಟಫ್.
 ನಾವು ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಮೇಲೆ ಹೋಗಲು ಸಾಕಷ್ಟು ಮಾಡಲೇಬೇಕು.
 Bitwise ನಿರ್ವಾಹಕರು, ಬಫರ್,
 CS50 ಗ್ರಂಥಾಲಯದ, ನಂತರ ಎಚ್ಟಿಎಮ್ಎಲ್, HTTP ಸಿಎಸ್ಎಸ್.
 15 ರಿಂದ 20 ನಿಮಿಷಗಳ ನಂತಹ ಎಲ್ಲಾ.
 Bitwise ನಿರ್ವಾಹಕರು. ನೀವು ತಿಳಿಯಬೇಕಾದ ಅವುಗಳಲ್ಲಿ 6 ಇವೆ.
 Bitwise ಮತ್ತು, bitwise ಅಥವಾ, XOR, ಎಡ ಶಿಫ್ಟ್, ಬಲ Shift, ಮತ್ತು.
 ಬಲ Shift ಮತ್ತು ನೀವು ಕೇವಲ ಎಲ್ಲಾ ಉಪನ್ಯಾಸ ಕಂಡಿತು ಅಲ್ಲ.
 ನಾವು ಬೇಗನೆ ಇಲ್ಲಿ ಹೋಗುತ್ತೇನೆ, ಆದರೆ ಈ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ 6 ಎಂದು ತಿಳಿಯಲು ಒಳ್ಳೆಯದು.
 Bitwise ನಿರ್ವಾಹಕರು ನೀವು + 4 3 ಮಾಡಿದಾಗ ರೀತಿಯ ನೆನಪಿಡಿ.
 ನೀವು 3 ಮತ್ತು 4 ಬೈನರಿ ವ್ಯವಹರಿಸುವಾಗ ಇಲ್ಲ.
 Bitwise ನಿರ್ವಾಹಕರು ನಿಮಗೆ ನಿಜವಾಗಿ ಸಂಖ್ಯೆಗಳನ್ನು 3 ಮತ್ತು 4 ಪ್ರತ್ಯೇಕ ಬಿಟ್ಗಳು ವ್ಯವಹರಿಸುತ್ತದೆ.
 

ನಾವು ಹೇಳುತ್ತೇನೆ ಮೊದಲ ಒಂದು bitwise, ಅಲ್ಲ
 ಮತ್ತು ಅದು ಎಲ್ಲಾ ಎಲ್ಲಾ ಬಿಟ್ಗಳು ಮಿಡಿ ಹೊಂದಿದೆ.
 ನೀವು ಸಿ ಈ ಬರೆಯುತ್ತಿದ್ದೇವೆ ವೇಳೆ ಇಲ್ಲಿ, ನೀವು ಬರೆಯಲು
 ~ 11011 ಅಥವಾ ಯಾವುದೇ, ನೀವು, ಇದು ~ 4 ಇಷ್ಟ ಬರೆಯಬೇಕಿತ್ತು
 ನಂತರ ಅದನ್ನು 4 ಬೈನರಿ ಪ್ರಾತಿನಿಧ್ಯ ಮಿಡಿ ಎಂದು.
 ಇಲ್ಲಿ, 1 ನ ~ ಕೆಲವು ಬೈನರಿ ಸಂಖ್ಯೆಯ 1101101 ನಿಖರವಾಗಿ 0 ನ ಎಲ್ಲಾ 1 ಫ್ಲಿಪ್ ಹೋಗುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ 0 ನ.
 ನಾನು ಹೇಳಿದಂತೆ, ಈ ಆಗಾಗ್ಗೆ ಬಳಕೆ,
 ನಾವು ಕೆಲವು ಸಂಖ್ಯೆಯ ಮಂದಿ ಬಯಸುವ ಮತ್ತು ನಾವು ಸ್ವಲ್ಪ ಅದನ್ನು ನೋಡುತ್ತಾರೆ, ಆಗಿದೆ
 ಬಿಟ್ಗಳು ಎಲ್ಲಾ ಅವುಗಳಲ್ಲಿ ಒಂದು ಹೊರತುಪಡಿಸಿ, 1 ಅಲ್ಲಿ.
 ಆದ್ದರಿಂದ ಸಂಖ್ಯೆ ವ್ಯಕ್ತಪಡಿಸಲು ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭ
 ಕೇವಲ ಒಂದೇ ಬಿಟ್ ಸೆಟ್ ಅಲ್ಲಿ,
 ನಂತರ ಅದನ್ನು ~, ಆದ್ದರಿಂದ ಪ್ರತಿ ಇತರ ಬಿಟ್ ಒಂದು ಹೊರತುಪಡಿಸಿ ಸೆಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.
 ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ಬಳಸಲು ನೀನು ಇಲ್ಲಿದೆ.
 

Bitwise ಅಥವಾ. ಇಲ್ಲಿ 2 ಬೈನರಿ ಸಂಖ್ಯೆಗಳು, ಮತ್ತು ಈ 2 ಸಂಖ್ಯೆಗಳು
 ಅವರು ಪ್ರತಿಯೊಂದು ಸಂಭವನೀಯ ಪ್ರತಿನಿಧಿಸುವಂತಹ, ಬಹಳ ಪ್ರತಿನಿಧಿಗಳು
 ಬಿಟ್ಗಳು ಸಂಯೋಜನೆಯನ್ನು ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿದೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.
 ನಾನು ಪ್ರತಿ ಬಿಟ್ or'd ಮಾಡಿದಾಗ ಇಲ್ಲಿ, ನಾವು ನೇರ ಕೆಳಗೆ ಹೋಲಿಸಲು ನೀನು.
 ಆದ್ದರಿಂದ ಎಡಭಾಗದಲ್ಲಿ ನಾವು 1 ಮತ್ತು 1 ಹೊಂದಿವೆ.
 ನಾನು bitwise ಮಾಡಿದಾಗ | ಆ, ನಾನು ಪಡೆಯಲು ನಾನು? ಒಂದು.
 0 ಮತ್ತು 1 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ | ನಂತರ bitwise? ಒಂದು.
 Bitwise 1 ಮತ್ತು 0 ಒಂದೇ, ಒಂದು ಏರಲಿದೆ.
 Bitwise 0 | 0 ನನಗೆ 0 ನೀಡಲು ಹೋಗುತ್ತದೆ.
 0 ಸಂದರ್ಭದಲ್ಲಿ | ಹಾಗಾಗಿ 0 ಪಡೆಯಲು ಅಲ್ಲಿ ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ 0 ಆಗಿದೆ.
 ಮತ್ತು ನೀವು ನಿಮ್ಮ ತಾರ್ಕಿಕ ಅದರ್ಸ್ ಹಾಗೆ ಎಂದು ನಗರದ.
 ನೀವು ನಿಜವಾದ 1 ಮತ್ತು ಹುಸಿ 0 ಅನಿಸಿದರೆ, ಒಂದೇ ಇಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ.
 ಆದ್ದರಿಂದ ನಿಜವಾದ ಅಥವಾ ನಿಜವಾದ ನಿಜ; ಸರಿ ಅಥವಾ ತಪ್ಪು ನಿಜ.
 ತಪ್ಪು ಅಥವಾ ನಿಜವಾದ ನಿಜ; ತಪ್ಪು ಅಥವಾ ತಪ್ಪು ವಾಸ್ತವವಾಗಿ ತಪ್ಪು ಏಕೈಕ ವಿಷಯ.
 ಇಲ್ಲಿ ನಿಮಗೆ ಎಂದು ಉದಾಹರಣೆ
 bitwise ನಿರ್ವಾಹಕರು ಬಳಸಿದಾಗ ಒಂದು ಒಳ್ಳೆಯ ಉದಾಹರಣೆಯಾಗಿ.
 ಇಲ್ಲಿ ನಾವು ಅಥವಾ Ox20 ಬಂಡವಾಳ 'ಎ',
 ಮತ್ತು ನಾವು ಏನೋ ಪಡೆಯಲು, ಎರಡನೇ ಈ ನೋಡಲು ಮಾಡುತ್ತೇವೆ.
 ನಾವು ಅಥವಾ ಸಣ್ಣ 'ಒಂದು' Ox20 ಜೊತೆ, ನಾವು ಏನೋ ಪಡೆಯಲು ವೇಳೆ.
 ಆದ್ದರಿಂದ ASCII ಟೇಬಲ್ ಎಳೆಯಲು ಅವಕಾಶ.
 ಸರಿ. ಇಲ್ಲಿ ನಾವು 'ಎ' ಎಂದು ನೋಡಿ -
 ಇಲ್ಲಿ ನಾವು 'ಎ' 65 ರೇಖಾಂಶ ಹೊಂದಿರುತ್ತವೆ.
 ಆದರೆ ನಾನು Ox41 ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್, ಹೋಗುತ್ತೇನೆ.
 ಬಹಳ ಖಚಿತವಾಗಿ ನಾವು ವರ್ಗ ನೋಡಿದ. ನಾನು ತರಗತಿಯಲ್ಲಿ ನಾವು ನೋಡಿದ ಭಾವಿಸುತ್ತೇನೆ
 ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ರಿಂದ ಅವಳಿ ಪರಿವರ್ತಿಸುವುದು ಬಹಳ ಸುಲಭ ಎಂದು.
 ಇಲ್ಲಿ ನಾನು ಅವಳಿ 4 ಪುಟ್ ಬಯಸಿದರೆ,
 ಕೇವಲ 0100 ಎಂದು ವಿಶೇಷವೇನು.
 ಈ 1 ಸ್ಥಾನವನ್ನು, 2 ಸ್ಥಾನ, 4 ಸ್ಥಾನವನ್ನು, ಈ 4.
 ನಂತರ ನಾನು 0001 ಏರಲಿದೆ ಬೈನರಿ, ಒಳಗೆ 1 ವಿಭಾಗಿಸಬಹುದು.
 ಆದ್ದರಿಂದ ಈ ಅವಳಿ 'ಎ' ಪ್ರಾತಿನಿಧ್ಯ ಏರಲಿದೆ.
 ಸಣ್ಣ 'ಒಂದು', ಈಗ Ox61 ಎಂದು ವಿಶೇಷವೇನು ಟೇಕಿಂಗ್,
 ಅದರ ಬೈನರಿ ಈ ವಿಭಜಿಸುವ ಅಲ್ಲಿ,, ಒಂದು 6 -
 ವಾಸ್ತವವಾಗಿ ಇದು ಮಾಡೋಣ - ಯಾವುದೇ ಎರೇಸರ್ ಇಲ್ಲ? ಎರೇಸರ್.
 Ox61. ಆದ್ದರಿಂದ ಬೈನರಿ ಒಳಗೆ 6 ವಿಭಜಿಸುವ + 4 + 2 + 0 0 ಏರಲಿದೆ.
 ಮತ್ತು ವಿಭಜಿಸುವ 1 0001 ಏರಲಿದೆ.
 ಈ 2 ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡುತ್ತಿರುವುದು
 ನಾವು ಒಂದು ಸಣ್ಣ ಮತ್ತು ಒಂದು ರಾಜಧಾನಿ 'ಎ' ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಈ ಬಿಟ್ ಎಂದು ನೋಡಿ.
 ಸರಿ - ಆದ್ದರಿಂದ ಮತ್ತೆ ಇಲ್ಲಿ ಬರುವ.
 ನಾವು ಸ್ವಲ್ಪ Ox20 ಏನು ನೋಡಿದರೆ, ಇಲ್ಲಿ ಮತ್ತೆ ಬರುವ
 ತನ್ನ ಅವಳಿ ಒಳಗೆ ಆದ್ದರಿಂದ ವಿಭಜಿಸುವ Ox20,
 0010, 0000 ಆಗಿದೆ.
 Ox20, ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಮಾತ್ರ ಬಿಟ್, ನಾವು ಸಂಬಂಧಿಸಿರುತ್ತವೆ ಎಂದು ಈ ಬಿಟ್
 ರಾಜಧಾನಿ ಮತ್ತು ಸಣ್ಣ 'ಒಂದು' ಬದಲಾಯಿಸುವಾಗ ಜೊತೆ.
 ಈ ಒಂದು, 'ಎ' ಇದು ನಾನು ಅಥವಾ 'ಎ',
 ನಾನು ಅಥವಾ Ox20 ಜೊತೆ 'ಎ',
 ನಾನು ಪಡೆಯಲು ನಾನು?
 [ವಿದ್ಯಾರ್ಥಿ, ಕೇಳಿಸುವುದಿಲ್ಲ] 

ಸಣ್ಣ 'ಒಂದು', ಇದು 1 ಈ ಬಿಟ್ ಮಿಡಿ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ.
 ಮತ್ತು ನಾನು ಅಥವಾ 'ಒಂದು' Ox20 ಜೊತೆ, ನಾನು ಪಡೆಯಲು ನಾನು?
 ಒಂದು ಸಣ್ಣ, ಏಕೆಂದರೆ ಕೇವಲ oring 'ಒಂದು' Ox20 ಜೊತೆ,
 ನಾನು ಒಂದು 1 ಈ ಬಿಟ್ oring ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ; ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ಈಗಾಗಲೇ 1 ಇಲ್ಲಿದೆ.
 ನಾವು 'ಎ' ಮತ್ತು 'ಒಂದು' ಪಡೆಯಿರಿ.
 

Bitwise ಮತ್ತು. ಮತ್ತೆ, ನಾವು ನಮ್ಮ ತಾರ್ಕಿಕ ಮತ್ತು ಪ್ರತಿರೂಪವಾಗಿ ಈ ನಗರದ.
 ಎಡಭಾಗದಲ್ಲಿ ನಾವು ನಿಜವಾದ ಹಾಗೂ ನಿಜವಾದ ಹೊಂದಿವೆ.
 ಇದು ನಿಜ ಎಂದು ವಿಶೇಷವೇನು, ಮತ್ತು ಸಂದರ್ಭಗಳಲ್ಲಿ ಎಲ್ಲಾ ವಿಶೇಷವೇನು
 , ಸುಳ್ಳು ಹಾಗೂ ನಿಜವಾದ ಅಥವಾ ನಿಜವಾದ & ಸುಳ್ಳು, ಅಥವಾ ತಪ್ಪು ಮತ್ತು ಸುಳ್ಳು
 ಆ ವಸ್ತುಗಳ ಯಾವುದೇ ನಿಜವಾಗಿದ್ದರೆ.
 ಹಾಗಾಗಿ ನಾವು ಪಡೆಯುವಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ 1000 ಆಗಿದೆ.
 ಈಗ, ಇಲ್ಲಿ, ಇಲ್ಲಿ ನಾನು ನಂಬಲರ್ಹ bitwise ಅಲ್ಲ ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಿದ ಅಲ್ಲಿ ಇಲ್ಲಿದೆ,
 ನಾವು Ox20 ಅಲ್ಲಿ. ಆದ್ದರಿಂದ ಈ Ox20 ಆಗಿದೆ.
 ಈಗ ನಾನು ಯಾವ, bitwise Ox20 ಆಫ್ ~.
 ಎಲ್ಲಾ ಬಿಟ್ಗಳು ಮಿಡಿ ಹೋಗುತ್ತದೆ.
 ಹಾಗಾಗಿ 1101, 1111 ಹೊಂದಿವೆ.
 ಆದ್ದರಿಂದ 'ಎ' ~ Ox20 ನನಗೆ ಏನು ನೀಡಲು ಹೋಗುತ್ತದೆ ಜೊತೆ anded?
 ನಾವು ನಿಜವಾಗಿಯೂ ಬಗ್ಗೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಮಾತ್ರ ಬಿಟ್, ಈ ಒಂದಾಗಿದೆ
 ರಿಂದ ಈ ಬಿಟ್ಗಳು ಎಲ್ಲಾ 1 ಸಿದ್ಧವಾಗಿವೆ ವೇಳೆ,
 ನಂತರ ನಾವು ನಿಖರವಾಗಿ 'ಎ' ಆಗಿತ್ತು ಪಡೆಯಲು ನೀನು,
 ಹೊರತುಪಡಿಸಿ, ಬಹುಶಃ, ಈ ಭಾಗ.
 ಇದು 1 ಎಂದು, ಈಗ, ಒಂದು 0 ಅನ್ನು ವಿಶೇಷವೇನು ಏಕೆಂದರೆ
 ಈ ಏನೇ ಈ 0 ಏರಲಿದೆ ಜೊತೆ anded ಏಕೆಂದರೆ.
 ಆದ್ದರಿಂದ 'ಎ' ~ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗಿ & ಏನು?
 [ವಿದ್ಯಾರ್ಥಿಗಳು ಉತ್ತರಿಸಲು, ಕೇಳಿಸುವುದಿಲ್ಲ] 

ಮತ್ತು 'ಒಂದು' ಮತ್ತು ಏನು - ಇದು 'ಎ' ಇಲ್ಲಿದೆ.
 ಮತ್ತು 'ಒಂದು' ಹಾಗೂ ~ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗಿ ಏನು?
 'ಎ' ಈ ಪ್ರಸ್ತುತ 1 ಕಾರಣ.
 ಈ 0 Anding, ಇದು 0 ಮಾಡಲು ಹೋಗುತ್ತದೆ
 ಮತ್ತು ಈಗ ನಾವು ಒಂದು 'ಎ' ಪಡೆಯಲು ನೀನು.
 

ಎರಡೂ ', ಒಂದು' ಮತ್ತು ಈ ರೀತಿಯ ಕನಿಷ್ಠ ಕೊನೆಯಾಗಿ ಆದರೆ,
 ನಾವು XOR ಹೊಂದಿವೆ. ಇದು ತುಂಬಾ ಇಲ್ಲಿದೆ ಅಥವಾ,
 ಇದು ಪ್ರತ್ಯೇಕವಾಗಿ ಅರ್ಥ ಅಥವಾ ಹೊರತುಪಡಿಸಿ.
 ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಅಥವಾ ನಿಜವಾದ ವಿಶ್ವದ ನಗರದ ಯಾವ ಹಾಗೆ.
 ಆದ್ದರಿಂದ ನೀವು ಎರಡೂ 'X' ಅಥವಾ 'ವೈ', ಆದರೆ ಎರಡೂ.
 ಇಲ್ಲಿ ^ 1 1 0 ಏರಲಿದೆ.
 ನಿಜವಾದ ಕಾರಣ, ಈ - ಇದು ತಾರ್ಕಿಕ ನಿಜವಾದ ಮತ್ತು ತಪ್ಪು ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ
 , bitwise ಹಾಗೂ ಮತ್ತು ಅಥವಾ ಮಾಡುವಂತೆ
 ಆದರೆ ನಿಜವಾದ ^ ನಿಜವಾದ ತಪ್ಪಾಗಿದೆ.
 ಅವುಗಳನ್ನು ಮಾತ್ರ ನಿಜವಾದ ವೇಳೆ ನಾವು ಮಾತ್ರ ನಿಜವಾದ ಮರಳಲು ಬಯಸುವ ಕಾರಣ.
 ಆದ್ದರಿಂದ ^ 1 1 0. ಏನು ^ 1 0 ಬಗ್ಗೆ?
 1. ^ 0 ^ 1 0 0 0, 1.
 ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಸಂದರ್ಭಗಳಲ್ಲಿ, 0 bitwise ಏನೋ 0 0 ಏರಲಿದೆ.
 1 bitwise ಏನೋ 0 0 ಅಥವಾ bitwise 1,
 ಇದು ಇದ್ದರೆ | ಅಥವಾ ^, ಇದು 1 ಆಗಬಹುದು, ಮತ್ತು ಇದು & ಇಲ್ಲಿದೆ ಅದು 0 ಇರುವಿರಿ.
 ಮತ್ತು 1 bitwise 1 1 ಅಲ್ಲಿ ಮಾತ್ರ ಸಂದರ್ಭದಲ್ಲಿ ಮೀಸಲು ಅಥವಾ ಆಗಿದೆ.
 ಆ 0110 ಇಲ್ಲಿದೆ.
 ಇಲ್ಲಿ ಈಗ, XOR ಬಳಸಿ - ಆದ್ದರಿಂದ ನಾವು ಹಿಂದೆ 20 ಆರ್.
 'ಎ' ^ Ox20 ನಾವು ಹೋಲಿಸುವ ನೀವು ಈ 2 ಬಿಟ್ಗಳು.
 ಆದ್ದರಿಂದ ಒಂದು 1 ^ 0 ಅಂತ ಏನು ನೀಡಲು ಹೋಗುತ್ತದೆ? ಒಂದು ಒಂದು.
 'ಎ' ^ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ? ಒಂದು ಸಣ್ಣ.
 'ಒಂದು' ^ Ox20 ನನಗೆ ನೀಡಲು ಹೋಗುತ್ತದೆ? ರಾಜಧಾನಿ ಎ
 ಈ ಮಾಡುವುದರಿಂದ ಯಾವುದೇ, Ox20 ಈ XORing
 ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಈ ಬಿಟ್ ಏನೇ ಫ್ಲಿಪ್ಪಿಂಗ್ ಇದೆ.
 ಈ 0, ಅದನ್ನು ಈಗ 1 ಆಗಲು ವಿಶೇಷವೇನು.
 ಈ ಒಂದು 1 ಏಕೆಂದರೆ, ^ 1 1 0.
 ಆದ್ದರಿಂದ ನಮ್ಮ 'ಒಂದು' 'ಎ' ಮಾರ್ಪಟ್ಟಿದೆ, ಮತ್ತು ನಮ್ಮ 'ಎ' 'ಒಂದು' ಮಾರ್ಪಟ್ಟಿದೆ.
 ಆದ್ದರಿಂದ XOR ಕೇವಲ ಸಂದರ್ಭದಲ್ಲಿ ಫ್ಲಿಪ್ಪಿಂಗ್ ನಿಜವಾಗಿಯೂ ಅನುಕೂಲಕರ.
 ನೀವು ಕೇವಲ ಅಕ್ಷರಗಳ ಸರಣಿಯನ್ನು ಮೇಲೆ ಮರಳಿ ಬಯಸುವ
 ಮತ್ತು ಪ್ರತಿಯೊಂದು ಪಾತ್ರದ ಸಂದರ್ಭದಲ್ಲಿ ಪರ್ಯಾಯವಾಗಿ,
 Ox20 ಜೊತೆ ನೀವು XOR ಎಲ್ಲವೂ.
 

ಈಗ ನಾವು ಶಿಫ್ಟ್ ಬಿಟ್ಟು. ಎಡ ಶಿಫ್ಟ್ ಕೇವಲ ಮೂಲತಃ, ಹೋಗುತ್ತದೆ
 ಒಳಗೆ, ಅಥವಾ ಎಡಕ್ಕೆ ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ ತಳ್ಳಲು, ಮತ್ತು ಅವುಗಳನ್ನು ಹಿಂದೆ 0 ಸೇರಿಸಲು.
 ಇಲ್ಲಿ ನಾವು 00001101 ಹೊಂದಿವೆ.
 ನಾವು ಬಲ, 3 0 ರ ತಳ್ಳಲು ನೀನು
 ಮತ್ತು ನಾವು 01101000 ಪಡೆಯಿರಿ.
 Nonbinary ಪರಿಭಾಷೆಯಲ್ಲಿ,
 ನಾವು ನಿಜವಾಗಿಯೂ 13 ಎಡ ಸ್ಥಳಾಂತರಿಸಲಾಯಿತು 3, ನಮಗೆ 104 ನೀಡುತ್ತದೆ ವ್ಯವಹರಿಸುವಾಗ ಎಂದು ನೋಡಿ.
 ಆದ್ದರಿಂದ ಎಡ ಶಿಫ್ಟಿಂಗ್, ನಾವು ಇಲ್ಲಿ ನೋಡಿ, ಎಕ್ಸ್ << ವೈ ಮೂಲತಃ X * 2 ^ y ಆಗಿದೆ.
 ^ 3 13 * 2, ^ 3 2 ಆದ್ದರಿಂದ * 8 13 104 ಆಗಿದೆ, 8.
 ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಬೈನರಿ, ಹೇಗೆ ಪ್ರತಿ ಅಂಕಿಯ, ಬಗ್ಗೆ ಯೋಚಿಸಿದರೆ
 ನಾವು ಬಲದಿಂದ ಆರಂಭಿಸುವ ವೇಳೆ, ಇದು ನಂತರ 1 ಸ್ಥಾನವನ್ನು, ನಂತರ 2 ಸ್ಥಾನ, 4 ನ ಸ್ಥಳವಾಗಿದೆ.
 ಆದ್ದರಿಂದ ಬಲದಿಂದ 0 ರ ತಳ್ಳುತ್ತದೆ,
 ನಾವು, 8 ಸ್ಥಾನವನ್ನು 4 ಸ್ಥಳದಲ್ಲಿ ಎಂದು ವಿಷಯಗಳನ್ನು ತಳ್ಳುವುದು
 ಮತ್ತು 16 ಸ್ಥಾನವನ್ನು 8 ಸ್ಥಾನ ಎಂದು ವಸ್ತುಗಳ.
 ಪ್ರತಿ ಶಿಫ್ಟ್ ಕೇವಲ 2 ಗುಣಿಸಿದರೆ. ಹೌದು?
 ನೀವು 5 ಬದಲಾಯಿಸಿತು [ವಿದ್ಯಾರ್ಥಿ] ಏನಾಗುತ್ತದೆ?
 [ಬೌಡೆನ್] ನೀವು 5 ವರ್ಗಾಯಿಸಲಾಯಿತು ನೀವು ಕೇವಲ ಅಂಕೆಗಳನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ.
 ಅನಿವಾರ್ಯವಾಗಿ, ಅದೇ ವಿಷಯ. ಲೈಕ್, ಪೂರ್ಣಾಂಕಗಳ ಮಾತ್ರ 32 ಬಿಟ್ಗಳು ಇವೆ,
 ನೀವು 2 ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕಗಳ ಸೇರಿಸಿ ಆದ್ದರಿಂದ, ಇದು ಕೇವಲ ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಕೊಳ್ಳದಿದ್ದರೆ.
 ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಅದೇ ವಿಷಯ. ನೀವು 5 ಬದಲಾಯಿಸಿತು,
 ನಾವು ಕೇವಲ ಒಂದು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ.
 ಮತ್ತು ", ಸ್ಥೂಲವಾಗಿ" ನಾನು ಏನು ಭಾಸವಾಗುತ್ತದೆ
 ನೀವು ತುಂಬಾ ಬದಲಾಯಿಸುವಂತೆ, ನೀವು ಬಿಟ್ಗಳು ಕಳೆದುಕೊಳ್ಳಬಹುದು ಅಲ್ಲಿ.
 

ಹಕ್ಕು ಶಿಫ್ಟ್ ವಿರುದ್ಧ ಏರಲಿದೆ,
 ನಾವು, ಕೊನೆಯಲ್ಲಿ ಆಫ್ 0 ನ ನೂಕು ನೀನು ಅಲ್ಲಿ
 ಮತ್ತು ನಮ್ಮ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಎಡದಿಂದ 0 ನ ತುಂಬಲು.
 ಆದ್ದರಿಂದ ಈ ರೀತಿ, ನಾವು ಮೂಲಭೂತವಾಗಿ ನಾವು ಈಗಾಗಲೇ ಮಾಡಿದ ತಿರುಗುವ ಮಾಡುತ್ತಿದ್ದೇವೆ.
 ನಾವು, ಬಲಭಾಗದಲ್ಲಿ ಮೂರು 0 ನ ಕೇವಲ ಆಫ್ ಬಿದ್ದ ನೋಡಿ
 ಮತ್ತು ನಾವು ಬಲಕ್ಕೆ 1101 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಮಂಡಿಸಿದರು.
 ಈ ಪರಿಣಾಮಕಾರಿಯಾಗಿ, X / 2 ^ ವೈ, ಇದು 104 

3 ಮಾಡುತ್ತಿರುವ.
 ಈಗ, ಇಲ್ಲಿ, ಅದು ಒಂದು ರೀತಿಯ ಉಪಾಯ.
 ಏಕೆ ಸ್ಥೂಲವಾಗಿ X / 2 ^ ವೈ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ x / 2 ^ ವೈ?
 ನಾನು 4 ಸಂಗಮದತ್ತ ವೇಳೆ, ನಾನು 1 ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ ಎಂದು ಕಾರಣ.
 ಮೂಲತಃ, ಹೇಳಬೇಕಾದ ಪೂರ್ಣಾಂಕ ವಿಭಾಗ ಯಾವ ನೀವು ನಗರದ, ಭಾವಿಸುತ್ತೇನೆ.
 ಆದ್ದರಿಂದ, 5/2 ನಂತಹ 2. ಇದು 2.5 ಅಲ್ಲ.
 ಇಲ್ಲಿ ಅದೇ ಉಪಾಯ. 2 ಭಾಗಿಸಿದಾಗ, ಯಾವಾಗ
 ನಾವು ದಾರಿಯುದ್ದಕ್ಕೂ ಬೆಸ ಬಿಟ್ಗಳು ಕಳೆದುಕೊಳ್ಳಬಹುದು.
 ಈಗ - ಎಂದು bitwise ಅದು. ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲಾ ಇಲ್ಲಿದೆ.
 ನಾವು ವರ್ಗ ಕಂಡಿತು ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ನೆನಪಿಡಿ,
 ಒಂದು ಬಿಟ್ ಮುಖವಾಡ bitwise ನಿರ್ವಾಹಕರು ಉಪಯುಕ್ತ
 ಅಥವಾ ನೀವು ಸ್ವಲ್ಪ ಮುಖವಾಡಗಳನ್ನು ಬಳಸಲು.
 ಅಕ್ಷರಗಳಲ್ಲಿ ಮತ್ತು ಸಣ್ಣ ಅಕ್ಷರಗಳ, ಪರಿವರ್ತನೆಗಳು ಒಂದು ಸುಂದರ ಪಕ್ಕಾ ಉದಾಹರಣೆಯಾಗಿದೆ.
 

ಸರಿ, ಆದ್ದರಿಂದ ಉಕ್ಕಿ ದಾಳಿ ಬಫರ್.
 ಯಾರಾದರೂ ಈ ಕಾರ್ಯದ ತಪ್ಪು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ?
 ನಾವು 12 ಬೈಟ್ಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು, 12 ಅಕ್ಷರಗಳು, ಡಿಕ್ಲೇರ್ಡ್ ಗಮನಿಸಿ
 ನಂತರ ನಾವು 12 ಅಕ್ಷರಗಳನ್ನು ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಬಾರ್ ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ನಕಲಿಸಿ. ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಇಲ್ಲಿ ಏನಿದೆ?
 ಏಕೆ 12 - ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ 12 ಬಹುಮಟ್ಟಿಗೆ ತಕ್ಷಣ ಮಾಹಿತಿ ಪಾಪ್ ಔಟ್ ಮಾಡಬೇಕು?
 ಬಾರ್ ಹೆಚ್ಚು 12 ಪಾತ್ರಗಳು ಎಂದು ಏನಾಗುತ್ತದೆ ವೇಳೆ?
 ಏನು ಬಾರ್ ಅಕ್ಷರಗಳನ್ನು ಲಕ್ಷಾಂತರ ವೇಳೆ?
 ಇಲ್ಲಿ ಸಮಸ್ಯೆ memcpy ಆಗಿದೆ. ಬಾರ್ ದೀರ್ಘ ಸಾಕಷ್ಟು ವೇಳೆ
 ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಕಾಣಿಸುತ್ತದೆ - 'ಸಿ', 'ಸಿ' ಕೇವಲ 12 ಪಾತ್ರಗಳು ಎಂದು ಲೆಕ್ಕಕ್ಕೆ;
 'ಸಿ' ಇದು ಅನೇಕ ಬೈಟ್ಗಳು ಹೊಂದಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಲೆಕ್ಕಕ್ಕೆ.
 ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಚಾರ್ ಬದಲಿಸಿ, ನಾವು ಮಂಜೂರು ಮಾಡಿದ 12 ಬೈಟ್ಗಳು,
 ಮತ್ತು ಮೆಮೊರಿ ಕಳೆದ ಎಲ್ಲವೂ ವಾಸ್ತವವಾಗಿ ಬಫರ್ ಸೇರುವುದಿಲ್ಲ ಎಂದು
 ಏನೇ ಸ್ಟ್ರಿಂಗ್ ಬಾರ್ ಜೊತೆ.
 ಈ ನಾವು ವರ್ಗ ಕಂಡಿತು ಚಿತ್ರವನ್ನು
 ನಮ್ಮ ಸ್ಟಾಕ್ ಬೆಳೆಯುವ ಹೊಂದಿವೆ.
 ನೀವು ಈ ಚಿತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಅಥವಾ ಮತ್ತೆ ಅವುಗಳನ್ನು ಪರಿಚಿತವಾಗಿರುವ ಪಡೆಯಲು ಮಾಡಬೇಕು.
 ನಮ್ಮ ಸ್ಟಾಕ್ ಬೆಳೆಯಲು, ಮೆಮೊರಿ ವಿಳಾಸಗಳನ್ನು ಮೇಲ್ಭಾಗದಲ್ಲಿ 0 ಆರಂಭವಾಗುವುದು
 ಮತ್ತು ಕೆಳಭಾಗದಲ್ಲಿ 4 ಶತಕೋಟಿ ಕೆಳಗೆ ಬೆಳೆಯಲು.
 ನಾವು, ಎಲ್ಲೋ ಮೆಮೊರಿ ನಮ್ಮ ರಚನೆಯ 'ಸಿ' ಹೊಂದಿವೆ
 ನಂತರ ನಾವು ಬಲ ಕೆಳಗೆ ಬಾರ್ಗೆ ನಮ್ಮ ಪಾಯಿಂಟರ್,
 ತದನಂತರ ಈ ಉಳಿಸಿದ ಫ್ರೇಮ್ ನಮ್ಮ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ರಲ್ಲಿ ಪಾಯಿಂಟರ್ ಮತ್ತು ನಮ್ಮ ಮೂಲ ದಿನಚರಿಯ ಸ್ಟಾಕ್ ಹೊಂದಿವೆ.
 ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಏನು ನೆನಪಿಡಿ?
 ಮುಖ್ಯ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಬಾರ್, ಒಂದು ಕಾರ್ಯ foo ​​ಕರೆಗಳು ಅದು ಇಲ್ಲಿದೆ
 ಅನಿವಾರ್ಯವಾಗಿ, ಆದಾಯ ಅಡ್ಡಿಯುಂಟು.
 ಆದ್ದರಿಂದ ಬಾರ್ ಆದಾಯ, ಅವರು ಎಂಬ foo, ಮತ್ತೆ ವಿಶೇಷವೇನು ಎಂದು ತಿಳಿದುಕೊಳ್ಳಬೇಕು.
 ಆದ್ದರಿಂದ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಮಾಡಿದಾಗ ಕಾರ್ಯ ಮರಳುತ್ತದೆ ಮರಳಲು ಎಂದು ಕಾರ್ಯ ವಿಳಾಸ.
 , ಅನುಕೂಲಕರವಾಗಿ, ಏಕೆಂದರೆ ಬಫರ್ ದಾಳಿ ಪ್ರಮುಖ ಕಾರಣ
 ಹ್ಯಾಕರ್ಸ್ ರಿಟರ್ನ್ ವಿಳಾಸಕ್ಕೆ ಬದಲಾಯಿಸಲು ಬಯಸುತ್ತೀರೆ.
 ಬದಲಿಗೆ ಮತ್ತೆ foo, ಹೋಗುವ, ನಾನು ಮತ್ತೆ ಹ್ಯಾಕರ್ ನನಗೆ ಮತ್ತೆ ಹೋಗಲು ಬಯಸುತ್ತಾರೆ ಎಲ್ಲೆಲ್ಲಿ ಹೋಗಿ ಪಡೆಯಲಿದ್ದೇನೆ.
 ಮತ್ತು, ಅನುಕೂಲಕರವಾಗಿ, ಹ್ಯಾಕರ್ ಆಗಾಗ್ಗೆ ಹಿಂದಕ್ಕೆ ಹೋಗಬೇಕು ಅಲ್ಲಿ
 ನಾವು ಮೂಲತಃ ಎಂದು ಬಫರ್ ಪ್ರಾರಂಭ.
 ಆದ್ದರಿಂದ, ಮತ್ತೆ, ಲಿಟಲ್ ಭಾರತೀಯ ಗಮನಕ್ಕೆ.
 APPLIANCE ಒಂದು ಲಿಟಲ್ ಭಾರತೀಯ ವ್ಯವಸ್ಥೆಯ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ,
 ಆದ್ದರಿಂದ ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಪಾಯಿಂಟರ್ ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ ಬೈಟ್ಗಳು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
 ಇಲ್ಲಿ ನಾವು ನೋಡಿ - ಈ? ಹೌದು.
 ನಾವು Ox80, OxC0, Ox35, OxO8 ನೋಡಿ.
 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ನೆನಪಿಡಿ?
 ನಾವು, ಲಿಟಲ್ ಭಾರತೀಯ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ರಿವರ್ಸ್ ಇಲ್ಲ
 2 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ಒಂದು ಬೈಟ್ ಮಾಡಲು, ಮತ್ತು ನಾವು ಬೈಟ್ಗಳು ರಿವರ್ಸ್ ಏಕೆಂದರೆ.
 ಏಕೆ ನಾವು, ಹಾಗೆ, 80530CO8 ಸಂಗ್ರಹಿಸಲು ಎಂದು ಇಲ್ಲಿದೆ.
 ನಾವು ಬಲ ಆರಂಭಿಸಿ, ಬದಲಿಗೆ, 2 ಅಂಕೆಗಳು ಪ್ರತಿ ಜೋಡಿ ಶೇಖರಿಸಿಡಲು.
 ಆ ವಿಳಾಸ ಪ್ರಾರಂಭ ವಿಳಾಸವನ್ನು ಸೂಚಿಸುತ್ತದೆ
 ನಾವು ವಾಸ್ತವವಾಗಿ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ನಕಲಿಸಿ ಮಾಡಬೇಕೆಂದು ನಮ್ಮ ಬಫರ್.
 ಉಪಯುಕ್ತ ಎಂದು ಕಾರಣ ಏನು ವೇಳೆ, ಏಕೆಂದರೆ ಆಕ್ರಮಣಕಾರರೊಂದಿಗೆ
 ಬದಲಿಗೆ ಕೇವಲ ಎಂದು ಸ್ಟ್ರಿಂಗ್ ಹೊಂದುವ, ಏನಾಯಿತು
 ಹಾಗೆ ಒಂದು ನಿರುಪದ್ರವ ಸ್ಟ್ರಿಂಗ್, ಅವರ ಹೆಸರು ಅಥವಾ ಏನೋ,
 ಹೀಗಾದರೆ, ಬದಲಿಗೆ, ಆ ವಾಕ್ಯವನ್ನು ಕೆಲವು ನಿರಂಕುಶ ಕೋಡ್ ಇದ್ದರು
 ಅವರು ಅದನ್ನು ಮಾಡಲು ನಮಗೇನು ಮಾಡಿದರು?
 ಆದ್ದರಿಂದ ಅವರು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ - ನಾನು ಯಾವುದೇ ತಂಪಾದ ಕೋಡ್ ಯೋಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
 ಇದು ಆದರೂ, ಏನು ಎಂದು. ಯಾವುದೇ ಹಾನಿಕಾರಕ ಕೋಡ್.
 ಅವರು ಬಯಸಿದರೆ, ಅವರು ಕೇವಲ seg ದೋಷಗಳನ್ನು ನಲ್ಲಿ ಏನಾದರೂ ಸಾಧ್ಯವಾಯಿತು, ಆದರೆ ನಿರರ್ಥಕವಾಗುತ್ತದೆ.
 ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಹ್ಯಾಕ್ ಅದನ್ನು.
 

ಸರಿ. CS50 ಗ್ರಂಥಾಲಯದ.
 ಈ, ಮೂಲತಃ, GetInt, GetString, ಎಲ್ಲಾ ಆ ಕಾರ್ಯಗಳನ್ನು ನಾವು ನಿಮಗಾಗಿ ಒದಗಿಸಲಾಗುತ್ತದೆ.
 ನಾವು ಚಾರ್ * ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ದೂರ ಬೀಸಿದ ಅಮೂರ್ತತೆ ಇಲ್ಲಿದೆ
 ಸೆಮಿಸ್ಟರ್ ಸಂದರ್ಭದಲ್ಲಿ.
 ಸ್ಟ್ರಿಂಗ್ ಕೇವಲ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.
 ಇಲ್ಲಿ ನಾವು GetString ಒಂದು ಸಂಕ್ಷಿಪ್ತ ಆವೃತ್ತಿಯನ್ನು ನೋಡಿ.
 ನೀವು ನಿಜವಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಹೇಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಇದು, ಹಿಂತಿರುಗಿ ನೋಡಲು.
 ಕೀ ವಿವರಗಳನ್ನು, ನಾವು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಪಡೆಯಲು ಗಮನಕ್ಕೆ
 ಕೇವಲ ನಮಗೆ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಟೈಪ್ ಹಾಗೆ, ಗುಣಮಟ್ಟದ ನಿಂದ.
 ಆದ್ದರಿಂದ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಮತ್ತು ನಾವು ಹಲವು ಪಾತ್ರಗಳು ಸಿಕ್ಕಿದರೆ,
 ಆದ್ದರಿಂದ n + 1 ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಾಗಿದೆ ವೇಳೆ,
 ನಂತರ ನಾವು ನಮ್ಮ ಬಫರ್ ಸಾಮರ್ಥ್ಯ ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿದೆ.
 ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಬಫರ್ ಗಾತ್ರದ ಡಬಲ್ ಆಗಿರುವ.
 ಮತ್ತು ದುವರಿಯುತ್ತಿರುತ್ತದೆ; ನಾವು ನಮ್ಮ ಬಫರ್ ಒಳಗೆ ಚಿಹ್ನೆಯನ್ನು ಸೇರಿಸಲು
 ಒಂದು ಹೊಸ ಸಾಲನ್ನು ಅಥವಾ ಫೈಲ್ ಅಥವಾ ಯಾವುದೇ ಕೊನೆಯಲ್ಲಿ ಪಡೆಯುವ ತನಕ,
 ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸ್ಟ್ರಿಂಗ್ ತದನಂತರ ನಿಜವಾದ getString ಪೂರೈಸಿದ
 ನಾವು ತುಂಬಾ ಮೆಮೊರಿ ಹಂಚಿಕೆ ಅದು ಮತ್ತೆ ಹೋಗಿ ಸ್ವಲ್ಪ ಕುಗ್ಗಿಸಿ ಮಾಡುತ್ತೇವೆ ಹಾಗೆ, ಮೆಮೊರಿ ಕುಗ್ಗುತ್ತದೆ.
 ಆದ್ದರಿಂದ ನಾವು ತೋರಿಸುವುದಿಲ್ಲ, ಆದರೆ ಮುಖ್ಯ ಕಲ್ಪನೆ
 ಇದು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಪಾತ್ರ ಓದಲು ಹೊಂದಿದೆ.
 ಇದು ಕೇವಲ ಒಮ್ಮೆ ಒಂದು ವಿಷಯವನ್ನು ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ,
 ತಮ್ಮ ಬಫರ್ ಕೇವಲ ಒಂದು ನಿರ್ದಿಷ್ಟ ಗಾತ್ರದ ಏಕೆಂದರೆ.
 ಇದು ಬಫರ್ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಸ್ಟ್ರಿಂಗ್ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ ಆದ್ದರಿಂದ, ಅದು ಉಕ್ಕಿ ಎಂದು.
 ಇಲ್ಲಿ ನಾವು ತಪ್ಪಿಸುವ ಒಂದೇ ಅಕ್ಷರ ಓದುವ ಮೂಲಕ
 ಒಂದು ಸಮಯದಲ್ಲಿ ಮತ್ತು ನಾವು ಅಗತ್ಯವಿದೆ ಬಂದ ಬೆಳೆಯುತ್ತಿರುವ.
 ಆದ್ದರಿಂದ GetInt ಮತ್ತು ಇತರ CS50 ಗ್ರಂಥಾಲಯದ ಕಾರ್ಯಗಳನ್ನು GetString ಬಳಸಲು ಒಲವು
 ತಮ್ಮ ಅಳವಡಿಕೆಗಳು.
 ಹಾಗಾಗಿ ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು ಹೈಲೈಟ್.
 ಇದು ಸ್ಟ್ರಿಂಗ್ ಪಡೆಯಲು GetString ಕರೆಗಳನ್ನು.
 ನೆನಪಿನಿಂದ GetString ಮರಳಲು ವಿಫಲವಾದರೆ,
 getString ಏನೋ mallocs ನೆನಪಿಡಿ, ಆದ್ದರಿಂದ ನೀವು GetString ಕರೆ ಬಂದ
 ನೀವು (ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ) ನೀವು ಕೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ ಮುಕ್ತಗೊಳಿಸಲು ಮಾಡಬಾರದು.
 ಇದು ಏನೋ malloc ವಿಫಲವಾಗಿದೆ ಆದ್ದರಿಂದ ಇಲ್ಲಿ, ನಾವು ಕೇವಲ ಒಂದು ಇಲ್ಲದ್ದನ್ನು INT_MAX ಮರಳಿ ಎಂದು,
 ಹೇ, ನಾವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.
 ನೀವು ನಾನು ನೀವು ಮರಳಲು ಯಾವುದೇ ನಿರ್ಲಕ್ಷಿಸಿ, ಅಥವಾ ಮಾಡಬೇಕು
 ನೀವು ಮಾನ್ಯ ಇನ್ಪುಟ್ ಈ ಚಿಕಿತ್ಸೆ ಮಾಡಬಾರದು. ಅಂತಿಮವಾಗಿ, ಆ ಯಶಸ್ಸನ್ನು ಕಾಣಲಿಲ್ಲ ಊಹಿಸಿಕೊಂಡು, ನಾವು, ಆ ವಿಶೇಷ ಧ್ವಜವು sscanf ಬಳಸಲು
 ಅಂದರೆ, ಮೊದಲ ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಸಲು,
 ನಂತರ ಪೂರ್ಣಾಂಕ ನಂತರ ಯಾವುದೇ ಅಕ್ಷರಗಳಿಗೆ.
 ಆದ್ದರಿಂದ ನಾವು 1 ಸಮನಾಗಿರಬೇಕು ಬಯಸುವ ಗಮನಕ್ಕೆ.
 ಆದ್ದರಿಂದ sscanf ಮರಳುತ್ತದೆ ಯಶಸ್ವಿಯಾಗಿ ಎಷ್ಟು ಪಂದ್ಯಗಳಲ್ಲಿ ಮಾಡಿದ ವೇಳೆ?
 ಇದು ಯಶಸ್ವಿಯಾಗಿ ಒಂದು ಪೂರ್ಣಾಂಕ ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ ವೇಳೆ 1 ಹಿಂತಿರುಗುವುದು,
 ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಹೊಂದಿಕೆಯಾಗಲಿಲ್ಲ ವೇಳೆ 0 ಹಿಂತಿರುಗುವುದು, ಮತ್ತು ಇದು 2 ಹಿಂತಿರುಗುವುದು
 ಇದು ದಾಖಲೆಗಳುಸರಿಹೊಂದಿವೆ ವೇಳೆ ಒಂದು ಪೂರ್ಣಾಂಕ ಕೆಲವು ಪಾತ್ರದ ನಂತರ.
 ನಾವು 1 ಆದರೆ ಏನು ಹೊಂದಾಣಿಕೆ ವೇಳೆ ನಾವು ಮರುಪ್ರಯತ್ನಿಸಿ ಗಮನಕ್ಕೆ.
 ನಾವು ದಾಖಲಿಸಿದರೆ 1, 2, 3, ಸಿ, ಅಥವಾ 1, 2, 3, ಎಕ್ಸ್,
 ನಂತರ 1, 2, 3 ಪೂರ್ಣಾಂಕ ಸಂಗ್ರಹವಾಗುತ್ತದೆ ಎಂದು,
 ಎಕ್ಸ್, ಪಾತ್ರದ ನಲ್ಲಿ ಸಂಗ್ರಹವಾಗುತ್ತದೆ ಎಂದು
 ನಾವು ಮಾತ್ರ ಒಂದು ಪೂರ್ಣಾಂಕ ಬಯಸುವ ಏಕೆಂದರೆ, sscanf 2 ಹಿಂತಿರುಗಿ, ಮತ್ತು ನಾವು ಮರುಪ್ರಯತ್ನಿಸಿ ಎಂದು.
 

ತ್ವರಿತವಾಗಿ ಎಚ್ಟಿಎಮ್ಎಲ್, HTTP ಸಿಎಸ್ಎಸ್ ಮೂಲಕ ಊದುವ.
 ಹೈಪರ್ ಟೆಕ್ಸ್ಟ್ ಮಾರ್ಕಪ್ ಲಾಂಗ್ವೇಜ್ ವೆಬ್ ರಚನೆ ಮತ್ತು ಶಬ್ದಾರ್ಥ ಆಗಿದೆ.
 ಇಲ್ಲಿ ನಾವು HTML ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ ಉಪನ್ಯಾಸ ಉದಾಹರಣೆಯಾಗಿದೆ.
 ನಾವು ತಲೆ ಟ್ಯಾಗ್ಗಳು, ದೇಹದ ಟ್ಯಾಗ್ಗಳನ್ನು ಹೊಂದಿವೆ
 ನಾವು, ನಾವು ವಾಸ್ತವವಾಗಿ ಒಂದು ಆರಂಭದ ಮತ್ತು ನಿಕಟ ಟ್ಯಾಗ್ ಇಲ್ಲ ಅಲ್ಲಿ ಖಾಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ಉದಾಹರಣೆಗಳು ಹೊಂದಿವೆ
 ನಾವು ಲಿಂಕ್ ಮತ್ತು ಇಮೇಜ್.
 ಯಾವುದೇ ಮುಚ್ಚುವ ಚಿತ್ರ ಟ್ಯಾಗ್ ಇಲ್ಲ; ಟ್ಯಾಗ್ ಅಗತ್ಯವಿದೆ ಎಲ್ಲವೂ ಒಳಗೊಂಡಿದೆ ಕೇವಲ ಒಂದು ಟ್ಯಾಗ್ ಇಲ್ಲ.
 ಲಿಂಕ್ ಉದಾಹರಣೆಯಾಗಿದೆ; ನಾವು ನೀವು ಸಿಎಸ್ಎಸ್ ಸಂಪರ್ಕ ಹೇಗೆ ನೋಡುತ್ತಾರೆ,
 ಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ಬಾಹ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಂಪರ್ಕ ಹೇಗೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
 ಇದು HTML ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಅಲ್ಲ, ಬಹಳ ಸರಳ, ಮತ್ತು ನೆನಪು.
 ಇಲ್ಲಿ, ನೀವು ಈ ಏನು ಒಂದು ರೂಪ ವ್ಯಾಖ್ಯಾನಿಸಲು ಅಥವಾ ಕನಿಷ್ಠ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ?
 ಇಂತಹ ರೂಪ ಕ್ರಿಯಾಶೀಲ ಮತ್ತು ವಿಧಾನ ಹೊಂದಿದೆ.
 ನೀವು ಎಂದಾದರೂ ನೋಡುತ್ತಾರೆ ವಿಧಾನಗಳು ಮತ್ತು ಪೋಸ್ಟ್.
 ಆದ್ದರಿಂದ GET ವಿಷಯ URL ಅನ್ನು ಪುಟ್ ಅಲ್ಲಿ ಆವೃತ್ತಿಯಾಗಿದೆ.
 ಇದು URL ನಲ್ಲಿ ಹಾಕಿ ಇದೆ ಅಲ್ಲಿ ಪೋಸ್ಟ್ ಆಗಿದೆ.
 ಬದಲಿಗೆ, ರೂಪ ಯಾವುದೇ ದಶಮಾಂಶ HTTP ವಿನಂತಿ ಹೆಚ್ಚು ಗುಪ್ತ ಸೇರಿಸಲಾಗುತ್ತದೆ.
 HTTP ವಿನಂತಿ ಹೋಗುತ್ತದೆ ಅಲ್ಲಿ ಇಲ್ಲಿ, ಕ್ರಮ ವರ್ಣಿಸಬಹುದು.
 ಇದು ವಿಶೇಷವೇನು ಅಲ್ಲಿ google.com / ಶೋಧನೆ.
 ವಿಧಾನ. GET ಮತ್ತು ಪೋಸ್ಟ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು ನೆನಪಿಡಿ,
 ನೀವು ಬುಕ್ಮಾರ್ಕ್ ಏನೋ ಬಯಸಿದರೆ, ಕೇವಲ, ಉದಾಹರಣೆಯಾಗಿ ಹೇಳಬಹುದು.
 ನೀವು ಒಂದು ಪೋಸ್ಟ್ URL ಅನ್ನು ಬುಕ್ಮಾರ್ಕ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಎಂದಿಗೂ
 ಡೇಟಾ URL ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿಲ್ಲ ಏಕೆಂದರೆ.
 

ಎಚ್ಟಿಟಿಪಿ, ಈಗ, ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಟ್ರಾನ್ಸ್ಫರ್ ಪ್ರೊಟೋಕಾಲ್ ಆಗಿದೆ.
 ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಟ್ರಾನ್ಸ್ಫರ್ ಪ್ರೊಟೋಕಾಲ್, ನೀವು ವರ್ಗಾಯಿಸಲು ನಿರೀಕ್ಷಿಸಬಹುದು
 ಹೈಪರ್ ಟೆಕ್ಸ್ಟ್ ಮಾರ್ಕಪ್ ಲಾಂಗ್ವೇಜ್, ಮತ್ತು ಅದು.
 ಆದರೆ ಇದು ನೀವು ವೆಬ್ ಹುಡುಕಲು ಯಾವುದೇ ಚಿತ್ರಗಳನ್ನು ವರ್ಗಾಯಿಸುತ್ತದೆ,
 ನೀವು ಮಾಡುವ ಯಾವುದೇ ಡೌನ್ಲೋಡ್ಗಳು ಒಂದು HTTP ಕೋರಿಕೆಯನ್ನು ಆರಂಭಿಸಲು.
 ಆದ್ದರಿಂದ HTTP ಕೇವಲ ವರ್ಲ್ಡ್ ವೈಡ್ ವೆಬ್ ಭಾಷೆಯಾಗಿದೆ.
 ಇಲ್ಲಿ ನೀವು ಒಂದು HTTP ಕೋರಿಕೆಯನ್ನು ಈ ರೀತಿಯ ಗುರುತಿಸುವ ಅಗತ್ಯವಿದೆ.
 ಬದಿಯಲ್ಲಿ ಇಲ್ಲಿ HTTP/1.1 ಕೇವಲ ಆವೃತ್ತಿ ಹೇಳುತ್ತಾರೆ
 ಶಿಷ್ಟಾಚಾರದ ನಾನು ಬಳಸಿಕೊಂಡು ನಾನು.
 ನೀವು ನೋಡುತ್ತಾರೆ ಎಂದು ಬಹುಮಟ್ಟಿಗೆ ಯಾವಾಗಲೂ, HTTP/1.1 ಎಂದು ವಿಶೇಷವೇನು.
 ನಂತರ ನಾವು ಈ ನೀವು ನೋಡಿ ಎಂದು, ಪರ್ಯಾಯ ಪೋಸ್ಟ್ ಬೀಯಿಂಗ್, ಪಡೆಯಲು ಎಂದು ನೋಡಿ.
 ನಾನು ಭೇಟಿ ಹಾಕಿದ್ದೆ ಆ URL www.google.com/search?q = blah, blah blah ಆಗಿತ್ತು.
 ಆದ್ದರಿಂದ ನೆನಪಿಡಿ ಈ, ಪ್ರಶ್ನೆ ಗುರುತು Q = blah blah blah,
 ಒಂದು ರೂಪ ಸಲ್ಲಿಸಿದ ಇದೆ ವಿಷಯವನ್ನು ತೆರನಾದ.
 ನನಗೆ ಮರಳಿ ಇರಬಹುದು ಪ್ರತಿಕ್ರಿಯೆಯ ಈ ರೀತಿಯ ನೋಡುತ್ತಿದ್ದರು.
 ಮತ್ತೆ ಆ ಏರಲಿದೆ ಇದು ಪ್ರೋಟೋಕಾಲ್ ಆರಂಭಗೊಂಡು,
 ಸ್ಥಿತಿಯನ್ನು ಕೋಡ್ ನಂತರ. ಇಲ್ಲಿ 200 ಒಕೆ.
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ವಾಸ್ತವವಾಗಿ ಕೇಳಿದರು ವೆಬ್ ಪುಟ ಅನುಸರಿಸಲಾಗುವುದು.
 ಸಾಧ್ಯವಾದಷ್ಟು ಸ್ಥಿತಿಯನ್ನು ಕೋಡ್ ನೀವು ವೀಕ್ಷಿಸಬಹುದು, ಮತ್ತು ನೀವು ಅವುಗಳನ್ನು ಹಲವಾರು ತಿಳಿಯಬೇಕಿದೆ.
 200 ಸರಿ ನೀವು ಬಹುಶಃ ಮೊದಲು ಕಂಡ.
 403 ಫರ್ಬಿಡನ್, 404 ಕಂಡುಬಂದಿಲ್ಲ, 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷ
 ನೀವು ವೆಬ್ಸೈಟ್ಗೆ ಹೋಗಿ ಮತ್ತು ಏನೋ ಮುರಿದ ಅಥವಾ ತಮ್ಮ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಕ್ರ್ಯಾಶ್, ಸಾಮಾನ್ಯವಾಗಿ
 ಉಪಕರಣಗಳಲ್ಲಿರುವ ನಾವು ಆದರೆ ದೊಡ್ಡ ಕಿತ್ತಳೆ ಬಾಕ್ಸ್
 ಎಂದು ಬರುತ್ತದೆ ಮತ್ತು ಹಾಗೆ, ಏನೋ ತಪ್ಪು, ಹೇಳುತ್ತಾರೆ, ಈ ಕೋಡ್ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ
 ಅಥವಾ ಈ ಕಾರ್ಯ ಕೆಟ್ಟ.
 ಸಾಮಾನ್ಯವಾಗಿ ವೆಬ್ಸೈಟ್, ನೀವು ಕಾರ್ಯಗಳನ್ನು ನಿಜವಾಗಿ ಕೆಟ್ಟ ತಿಳಿದುಕೊಳ್ಳುವುದರಿಂದ ಬಯಸುವುದಿಲ್ಲ
 ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಅವರು ಕೇವಲ ನೀವು 500 ಆಂತರಿಕ ಸರ್ವರ್ ದೋಷಗಳು ನೀಡುತ್ತೇನೆ.
 

ಟಿಸಿಪಿ / ಐಪಿ ಎಚ್ಟಿಟಿಪಿ ಅಡಿಯಲ್ಲಿ 1 ಪದರ.
 ಇಂಟರ್ನೆಟ್ ವರ್ಲ್ಡ್ ವೈಡ್ ವೆಬ್ ಹೊರಗೆ ಎಂದು ನೆನಪಿಡಿ.
 ಲೈಕ್ ನೀವು HTTP ಮೂಲಕ ಹೋಗುವುದಿಲ್ಲ ಎಂದು ಆನ್ಲೈನ್ ಆಟ ವೇಳೆ,
 ಇದು ಬೇರೆ ಮೂಲಕ ವಿಶೇಷವೇನು - ಇದು ಇನ್ನೂ ಇಂಟರ್ನೆಟ್ ಬಳಸಿಕೊಂಡು,
 ಆದರೆ ಇದು HTTP ಬಳಸುವುದಿಲ್ಲ.
 ಎಚ್ಟಿಟಿಪಿ TCP / IP ನಿರ್ಮಿಸಿದ ಪ್ರೋಟೋಕಾಲ್ ಕೇವಲ ಒಂದು ಉದಾಹರಣೆ.
 ಐಪಿ ಅಕ್ಷರಶಃ ಇಂಟರ್ನೆಟ್ ಪ್ರೊಟೊಕಾಲ್ ಅರ್ಥ.
 ಪ್ರತಿ ಕಂಪ್ಯೂಟರ್ IP ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ; ಅವರು ಆ 4 ಅಂಕಿಯ ವಸ್ತುಗಳು
 192.168.2.1, ಅಥವಾ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ; ಎಂದು ಸ್ಥಳೀಯ ಒಂದಾಗಿದೆ ಕಾಣುತ್ತಾರೆ.
 ಆದರೆ ಒಂದು IP ವಿಳಾಸ ರೀತಿಯಾಗಿದೆ.
 ಆದ್ದರಿಂದ, DNS, ಡೊಮೈನ್ ಹೆಸರು ಸೇವೆ,
 ನಿಜವಾದ IP ಗೆ google.com ವಿಷಯಗಳನ್ನು ಅನುವಾದಿಸಲಾಗುತ್ತದೆ ಇಲ್ಲಿದೆ.
 ಆದ್ದರಿಂದ ನೀವು ಒಂದು URL ಒಳಗೆ ಎಂದು IP ವಿಳಾಸವನ್ನು ನಮೂದಿಸಿ ವೇಳೆ,
 ಎಂದು Google ಗೆ ನೀವು ತರುವ, ಆದರೆ ನೀವು ಆ ನೆನಪಿಡಿ ಪ್ರವೃತ್ತಿ.
 ನೀವು ಬದಲಿಗೆ google.com ನೆನಪು ಒಲವು.
 ನಾವು ಕೊನೆಯ ವಿಷಯ ಈ ಐಪಿ ಟಿಸಿಪಿ ಭಾಗವಾಗಿದೆ ಅಲ್ಲಿ ಪೋರ್ಟುಗಳನ್ನು, ಆಗಿದೆ.
 ಟಿಸಿಪಿ ಹೆಚ್ಚು ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ವೆಬ್ ಬ್ರೌಸರ್ ರನ್ ಹೊಂದಿವೆ, ಹಾಗೆ, ಬಗ್ಗೆ ಯೋಚಿಸಿ.
 ಬಹುಶಃ ನೀವು ಕೆಲವು ಇಮೇಲ್ ಅಪ್ಲಿಕೇಶನ್ ಚಲಿಸುತ್ತಿರುವ;
 ಬಹುಶಃ ನೀವು ಇಂಟರ್ನೆಟ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಳಸುವ ಕೆಲವು ಇತರ ಪ್ರೋಗ್ರಾಂ.
 ಅವರು ಎಲ್ಲಾ ಇಂಟರ್ನೆಟ್ ಪ್ರವೇಶ ಅಗತ್ಯವಿದೆ,
 ಆದರೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಮಾತ್ರ 1 ವೈಫೈ ಕಾರ್ಡ್ ಅಥವಾ ಯಾವುದೇ ಹೊಂದಿದೆ.
 ಆದ್ದರಿಂದ ಪೋರ್ಟುಗಳನ್ನು ನಾವು ಬೇರ್ಪಡಿಸಲು ಸಾಧ್ಯವಾಯಿತು ಕೋರುತ್ತೇವೆ ಎಂದು ಮಾರ್ಗವಾಗಿದೆ
 ಈ ಅನ್ವಯಗಳ ಇಂಟರ್ನೆಟ್ ಬಳಸಲು ಹೇಗೆ.
 ಪ್ರತಿ ಅಪ್ಲಿಕೇಶನ್, ಇದು ಆಲಿಸಬಹುದು ಎಂದು 1 ನಿರ್ದಿಷ್ಟ ಪೋರ್ಟ್ ಪಡೆಯುತ್ತದೆ
 ಮತ್ತು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಎಚ್ಟಿಟಿಪಿ ಬಂದರು 80 ಬಳಸುತ್ತದೆ. ಕೆಲವು ಇಮೇಲ್ ಸೇವೆಗಳು 25 ಬಳಸಲು.
 ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಪದಗಳಿಗಿಂತ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ ಒಲವು.
 ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನಿಮ್ಮನ್ನು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಪದಗಳಿಗಿಂತ ಸಮರ್ಥರಾಗುತ್ತಾರೆ.
 

ಸಿಎಸ್ಎಸ್, ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ಸ್ಟೈಲ್ ಶೀಟ್ಸ್.
 ಸಿಎಸ್ಎಸ್ ನಾವು ಶೈಲಿ ವೆಬ್ ಪುಟಗಳು, ಅಲ್ಲ ಎಚ್ಟಿಎಮ್ಎಲ್.
 ನಿಮ್ಮ ಸಿಎಸ್ಎಸ್ ಹಾಕಬಹುದು 3 ಸ್ಥಳಗಳು ಇವೆ.
 ಇದು ಶೈಲಿ ಟ್ಯಾಗ್ಗಳನ್ನು ನಡುವೆ, ಅಥವಾ ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕ ಕಡತದಲ್ಲಿ ಮತ್ತು ನಂತರ ಸೈನ್ ಲಿಂಕ್, ಇನ್ಲೈನ್ ಮಾಡಬಹುದು
 ಇಲ್ಲಿ ಸಿಎಸ್ಎಸ್ ಕೇವಲ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
 ಈ ಮಾದರಿಯನ್ನು ಗುರುತಿಸಲು ಮಾಡಬೇಕು,
 ಮೊದಲ ಉದಾಹರಣೆಗೆ ನಾವು ದೇಹದ ಟ್ಯಾಗ್ ಹೊಂದಾಣಿಕೆ, ನೀವು ಅಲ್ಲಿ
 ಮತ್ತು ಇಲ್ಲಿ ನಾವು ದೇಹದ ಟ್ಯಾಗ್ ಕೇಂದ್ರೀಕರಿಸಿ ಮಾಡುತ್ತಿದ್ದೇವೆ.
 ಎರಡನೇ ಉದಾಹರಣೆಗೆ, ನಾವು ವಿಷಯ ಹೊಂದಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ
 ID ಯನ್ನು ಫೂಟರ್, ಮತ್ತು ನಾವು ಕೆಲವು ಶೈಲಿಗಳು ಹಾಕುತ್ತಿವೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.
 ಎಡಕ್ಕೆ ID ಯನ್ನು ಅಡಿಟಿಪ್ಪಣಿ ಪಠ್ಯ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ ಗಮನಿಸಿ,
 ದೇಹದ ಪಠ್ಯ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ ಸೆಂಟರ್ ಆದರೆ.
 ಅಡಿಟಿಪ್ಪಣಿ ಶರೀರದ ಒಳಗೆ ಇದೆ.
 ಇದು, ಬದಲಿಗೆ, ಪಠ್ಯ align ದೇಹದ ಪಠ್ಯ align ಸೆಂಟರ್ ಹೇಳುತ್ತಾರೆ ಸಹ, ಬಿಟ್ಟು ಕಾಣಿಸುತ್ತದೆ.
 ಇದು ಇಡೀ ಕ್ಯಾಸ್ಕೇಡಿಂಗ್ ಭಾಗವಾಗಿದೆ.
 ನೀವು ಹೊಂದಬಹುದು - ನೀವು ದೇಹದ ಶೈಲಿಗಳು ಸೂಚಿಸಬಹುದು,
 ಮತ್ತು ನಂತರ ದೇಹದಲ್ಲಿ ವಿಷಯಗಳನ್ನು ನೀವು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಶೈಲಿಗಳು ಸೂಚಿಸಬಹುದು,
 ಮತ್ತು ವಿಷಯಗಳನ್ನು ನೀವು ನಿರೀಕ್ಷಿಸಬಹುದು ಕೆಲಸ.
 ಇನ್ನಷ್ಟು ನಿರ್ದಿಷ್ಟ ಸಿಎಸ್ಎಸ್ ಸ್ಪೆಸಿಫೈಯರ್ಸ್ ಆದ್ಯತೆಯಾಗಿ.
 ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
 

[ಅಲಿ Nahm] ಎಲ್ಲರೂ ಹೈ. ನಾನು ನಿಮ್ಮ ಗಮನ ಸೆಳೆಯುವುದು ಎಂದು.
 ನಾನು ಅಲಿ ನಾನು ಮತ್ತು ನಾನು ವೇಗವಾಗಿ ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಮೂಲಕ ಹೋಗಿ ಪಡೆಯಲಿದ್ದೇನೆ.
 ನಾವು ಪ್ರಾರಂಭಿಸಬಹುದು. ಪಿಎಚ್ಪಿ ಪಿಎಚ್ಪಿ ಫಾರ್ ಚಿಕ್ಕದಾಗಿದೆ: ಹೈಪರ್ಟೆಕ್ಸ್ಟ್ ಪ್ರಿಪ್ರೊಸೆಸರ್.
 ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾಗಿದೆ, ಇದು ಸರ್ವರ್ ಸೈಡ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯನ್ನು ಇಲ್ಲಿದೆ,
 ಮತ್ತು ನಾವು ವೆಬ್ಸೈಟ್ಗಳ ಮತ್ತೆ ಕೊನೆಯಲ್ಲಿ ಬಳಸುತ್ತಾರೆ,
 ಮತ್ತು ಗಣನೆಗಳನ್ನು, ದೃಶ್ಯಗಳ ಹಿಂದಿನ ಭಾಗ ಬಹಳಷ್ಟು ಮಾಡುತ್ತದೆ ಹೇಗೆ.
 ಸಿಂಟ್ಯಾಕ್ಸ್. ಇದು C, ಅನಿರೀಕ್ಷಿತ, ಆಶ್ಚರ್ಯ ಅಲ್ಲ.
 ನಾನು ಮುಂದೆ ಚಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ - ಯಾವಾಗಲೂ ನೀವು ನೋಡಬಹುದು ವೇಳೆ, ಜೊತೆಗೆ ಆರಂಭಿಸಲು ಹೊಂದಿದೆ.
 ನೀವು ಬ್ರೇಸ್ ಹೊಸ ರೀತಿಯ ಅಗತ್ಯವಿದೆ ನೋಡಬಹುದು ಮತ್ತು ನಂತರ ನೀವು ಸಹ ಪಿಎಚ್ಪಿ ಅಗತ್ಯವಿದೆ.
 ನೀವು ನಿಮ್ಮ PHP ಪಠ್ಯ, ನಿಮ್ಮ ಪಿಎಚ್ಪಿ ಕೋಡ್ ಫ್ರೇಮ್ ಹೇಗೆ ಯಾವಾಗಲೂ ಇಲ್ಲಿದೆ.
 ಆದ್ದರಿಂದ ನೀವು ರೀತಿಯ ಮೊದಲ ಪುಟ್ ಅಲ್ಲಿ ಸಿ, ಹಾಗೆ ಸಾಧ್ಯವಿಲ್ಲ.
 ನೀವು ಯಾವಾಗಲೂ ಅದನ್ನು ಸುತ್ತುವರೆದಿರುವ ಅಗತ್ಯವಿದೆ.
 ಈಗ, ಪ್ರಮುಖ ವಾಕ್ಯ ಎಲ್ಲಾ ಅಸ್ಥಿರ $ ಪಾತ್ರ ಆರಂಭಿಸಲು ಅಗತ್ಯವಿದೆ ಎಂದು.
 ನೀವು ಅವುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಮಾಡಿದಾಗ ಅದನ್ನು ಮಾಡಬೇಕು; ನೀವು ಮಾಡಬೇಕಾದ್ದು
 ನೀವು ನಂತರ ಅವರಿಗೆ ಉಲ್ಲೇಖಿಸಿ ಮಾಡಿದಾಗ.
 ನೀವು ಯಾವಾಗಲೂ ಎಂದು $ ಅಗತ್ಯವಿದೆ. ಇದು ಅತ್ಯಧಿಕವಾಗಿ, ನಿಮ್ಮ ಹೊಸ ಉತ್ತಮ ಸ್ನೇಹಿತ.
 ನೀವು ಇಲ್ಲ - ಸಿ ಭಿನ್ನವಾಗಿ, ನೀವು ಅದು ವೇರಿಯಬಲ್ ರೀತಿಯ ಯಾವ ರೀತಿಯ ಪುಟ್ ಅಗತ್ಯವಿಲ್ಲ.
 ನೀವು $ ಬೇಕು ಹಾಗೆಯೇ, ನೀವು,, ಪುಟ್ ಮಾಡಬೇಕಿಲ್ಲ
 ಇಂಟ್ X ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ವೈ, etcetera, etcetera.
 ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವ್ಯತ್ಯಾಸ.
 ಈ ಪರಿಣಾಮವಾಗಿ, ಇದು ಪಿಎಚ್ಪಿ ದುರ್ಬಲವಾಗಿ ರೀತಿಯ ಎಂದರ್ಥ.
 ಪಿಎಚ್ಪಿ ದುರ್ಬಲವಾಗಿ ಮಾದರಿ ಭಾಷೆ, ಮತ್ತು ಇದು ದುರ್ಬಲವಾಗಿ ಅಸ್ಥಿರ ಟೈಪಿಸಿದ.
 ಅರ್ಥಾತ್, ನೀವು ವೇರಿಯಬಲ್ ರೀತಿಯ ಬಗೆಯ ನಡುವೆ ಬದಲಾಯಿಸಬಹುದು ಎಂದರ್ಥ.
 ನೀವು ಒಂದು ಇಂಟ್ ನಿಮ್ಮ ಸಂಖ್ಯೆ 1 ಸಂಗ್ರಹಿಸಬಹುದು,
 ನೀವು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಸಂಗ್ರಹಿಸಬಹುದು, ಮತ್ತು ನೀವು ಒಂದು ಫ್ಲೋಟ್ ಎಂದು ಸಂಗ್ರಹಿಸಬಹುದು,
 ಮತ್ತು ಎಲ್ಲಾ ಆ ಸಂಖ್ಯೆ 1 ಆಗಿರುತ್ತದೆ.
 ನೀವು ವಿವಿಧ ರೂಪಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ನೀವು ಕೂಡ,
 ಇನ್ನೂ - ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ರೀತಿಯ ಇನ್ನೂ ಕೊನೆಯಲ್ಲಿ ಹಿಡುವಳಿ.
 ಆದ್ದರಿಂದ ನೀವು ಇಲ್ಲಿ ನೋಡಿದರೆ, ನೀವು pset 7 ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ,
 ನೀವು ಅನೇಕ ಬಹುಶಃ ಈ ಸಮಸ್ಯೆಯಿಂದ.
 ಎರಡು ಸಮಾನ ಚಿಹ್ನೆಗಳು, 3 ಸಮಾನ ಚಿಹ್ನೆಗಳು, 4 ಸಮಾನ ಚಿಹ್ನೆಗಳು.
 ಸರಿ, ಯಾವುದೇ 4 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಇವೆ, ಆದರೆ 2 ಮತ್ತು 3 ಇವೆ.
 ನೀವು ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಿ 2 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಬಳಸಲು.
 ಇದು ರೀತಿಯ ಪರಿಶೀಲಿಸಬಹುದು.
 ಆದ್ದರಿಂದ ನೀವು ಮೊದಲ ಉದಾಹರಣೆಯನ್ನು ನೋಡಬಹುದು ವೇಳೆ,
 ನಾನು num_int == num_string ಹೊಂದಿವೆ.
 ಆದ್ದರಿಂದ ನಿಮ್ಮ ಇಂಟ್ ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಎರಡೂ, ತಾಂತ್ರಿಕವಾಗಿ, 1,
 ಆದರೆ ವಿವಿಧ ಆರ್. ಆದರೆ ಎರಡು ಸಮ, ಇದು ಇನ್ನೂ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ.
 ಆದಾಗ್ಯೂ, ಟ್ರಿಪಲ್ ಸಮ, ಇದು ಮೌಲ್ಯ ಹಾಗೂ ವಿವಿಧ ಪರಿಶೀಲಿಸುತ್ತದೆ.
 ಅದು ಇಲ್ಲಿ ಎರಡನೇ ಸಂದರ್ಭದಲ್ಲಿ ಹಾದು ಹೋಗುವ ಅಲ್ಲ ಎಂದರ್ಥ
 ನೀವು ಬದಲಿಗೆ 3 ಸಮಾನ ಚಿಹ್ನೆಗಳು ಬಳಸುತ್ತಿದ್ದರೆ ಅಲ್ಲಿ.
 ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ ಈಗ ತೋರಿಸಿವೆ ಎಂದು ಒಂದು ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಇಲ್ಲಿದೆ.
 

ತಂತುವಿನ ಪೋಣಿಸುವಿಕೆಯ ನೀವು ಪಿಎಚ್ಪಿ ಬಳಸಬಹುದಾದ ಮತ್ತೊಂದು ಪ್ರಬಲ ವಿಷಯ.
 ಇದು, ಮೂಲತಃ ಕೇವಲ ಸೂಕ್ತ ಡಾಟ್ ಸಂಕೇತಗಳನ್ನು ಇಲ್ಲಿದೆ
 ಮತ್ತು ನೀವು ಒಟ್ಟಿಗೆ ತಂತಿಗಳನ್ನು ಬಂಧಿಸಬಹುದು ಹೇಗೆ.
 ಆದ್ದರಿಂದ ನೀವು ಕ್ಯಾಟ್ ಮತ್ತು ನೀವು ಡಾಗ್, ಮತ್ತು ನೀವು ಒಟ್ಟಿಗೆ 2 ತಂತಿಗಳು ಪುಟ್ ಬಯಸಿದರೆ,
 ನೀವು ಅವಧಿಯಲ್ಲಿ ಬಳಸಬಹುದು, ಮತ್ತು ಅದು ಹೇಗೆ ಕೆಲಸ ಭಾಸವಾಗುತ್ತದೆ.
 ನೀವು ಕೇವಲ ಪರಸ್ಪರ ಮುಂದಿನ ಇಡಿ,
 ನೀವು ಕೆಳಗೆ ಉದಾಹರಣೆಗೆ ಇಲ್ಲಿ ನೋಡಬಹುದು ಎಂದು,
 ನಾನು ಸ್ಟ್ರಿಂಗ್ 1, ಸ್ಪೇಸ್ ಸ್ಟ್ರಿಂಗ್ 2 ಪ್ರತಿಧ್ವನಿ ಅಲ್ಲಿ.
 ಪಿಎಚ್ಪಿ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಲು ತಿಳಿಯುವುದಿಲ್ಲ.
 ಅರೆಸ್. ಈಗ, ಪಿಎಚ್ಪಿ ಸರಣಿಗಳ 2 ಬಗೆಯ.
 ನೀವು ಸಾಮಾನ್ಯ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ ಮತ್ತು ನೀವು ಸಹ ಸಹಾಯಕ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ
 ಮತ್ತು ನಾವು ಇದೀಗ ಅವುಗಳನ್ನು ಮೂಲಕ ಹೋಗಲು ನೀನು.
 ನಿಯಮಿತ ಸಾಲುಗಳು, ಕೇವಲ ಈ ಸಿ
 ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ನೀಡಲಾಗುತ್ತದೆ ಎಂಬುದರ ಸೂಚಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
 ಇದೀಗ ನಾವು ಕೇವಲ ಒಂದು ರಚಿಸಲು ಹೋಗುವ ಮತ್ತು ಮಾಡುತ್ತಿದ್ದೇವೆ -
 ಆದ್ದರಿಂದ ನಾವು ಖಾಲಿ ರಚನೆಯ ರಚಿಸಲು ಹೇಗೆ, ನಾವು ನೀನು
 ಸೂಚ್ಯಂಕ 0 ಜಾರಿಗೆ.
 ನಾವು ಸಂಖ್ಯೆ 6, ಮೌಲ್ಯ 6 ಹಾಕಲು ನೀನು.
 ನೀವು ಇಲ್ಲಿ ಕೆಳಗೆ ನೋಡಬಹುದು.
 Where's - ಸೂಚ್ಯಂಕ 1 ನಲ್ಲಿ ನಾವು ಮೌಲ್ಯ ಸಂಖ್ಯೆ 4 ಹಾಕಲು ನೀನು
 ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಒಂದು 6 ನೋಡಬಹುದು, ಒಂದು 4, ಇಲ್ಲ
 ನಂತರ ನಾವು ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುವ ಎಂದು,
 ನಾವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಸೂಚ್ಯಂಕ 0 ಸಂಗ್ರಹಿಸಿಡಬೇಕು ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ,
 ನಂತರ ನಾವು ಮುದ್ರಿಸುವುದು 6 ಮೌಲ್ಯವನ್ನು ನೋಡುತ್ತಾರೆ. ಕೂಲ್?
 ಆದ್ದರಿಂದ ನೀವು ಸಾಮಾನ್ಯ ಸರಣಿಗಳ ಇಲ್ಲಿದೆ.
 ನೀವು ಈಗ ಸಾಮಾನ್ಯ ಸರಣಿಗಳ ವಿಷಯಗಳನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ
 ನೀವು ಕೊನೆಯಲ್ಲಿ ಅವುಗಳನ್ನು ಸೇರಿಸಬಹುದು ಆಗಿದೆ. ನೀವು ನಿರ್ದಿಷ್ಟ ಸೂಚ್ಯಂಕ ಸೂಚಿಸಲು ಇಲ್ಲ ಎಂದರ್ಥ.
 ನೀವು ಸಂಖ್ಯೆ ನೋಡಬಹುದು, ಮತ್ತು ಚೌಕಾಕಾರದ ಆವರಣ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಯಾವುದೇ ಸೂಚ್ಯಂಕ ಇಲ್ಲ.
 ಮತ್ತು ಇದು ತಿಳಿಯುವುದಿಲ್ಲ - ಪಿಎಚ್ಪಿ ಕೇವಲ ಪಟ್ಟಿ, ಮುಂದಿನ ಉಚಿತ ಸ್ಪಾಟ್ ಕೊನೆಯಲ್ಲಿ ಇದನ್ನು ಸೇರಿಸಲು ತಿಳಿಯುವುದಿಲ್ಲ.
 ಆದ್ದರಿಂದ ನೀವು ಆ 0 ಸ್ಪಾಟ್ ಸರಿಯಾದ ಇಲ್ಲ 1 ನೋಡಬಹುದು
 2 ಮೊದಲ ಸ್ಥಾನ ಸರಿಯಾದ ಅಲ್ಲಿ ಹೋದರು.
 3 ಹೋಗುತ್ತದೆ - ಹಾಗೆಯೇ ಅಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.
 ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಅರ್ಥವಿಲ್ಲ. ನೀವು ನಿರಂತರವಾಗಿ ಅದನ್ನು ಸೇರಿಸುವ ನೀವು,
 ನಂತರ ನಾವು, ಸಂಖ್ಯೆ 1 ಸೂಚ್ಯಂಕ ಪ್ರತಿಧ್ವನಿಸುವ ಮಾಡಿದಾಗ
 ಇದು ಮೌಲ್ಯ 2 ಮುದ್ರಿಸುತ್ತದೆ.
 

ನಂತರ ನಾವು ಸಹವರ್ತನೀಯ ಸರಣಿಗಳ ಎಂದು ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.
 ಬದಲಿಗೆ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕಗಳು ಹೊಂದಿರುವ ಸಹಕಾರಿ ಸಾಲುಗಳು,,
 ಅವರು ಏನು ಅವರು ಸ್ಟ್ರಿಂಗ್ ಎಂದು ಸೂಚಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಆಗಿದೆ.
 ನೀವು ಬದಲಿಗೆ, ನೋಡಬಹುದು - ನಾನು ಆ ಸಂಖ್ಯೆ ಸೂಚ್ಯಂಕಗಳು ಹೊರಬಂದಿತು,
 ಈಗ key1, key2, key3, ಮತ್ತು ಅವರು ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಎಂಬುದನ್ನು ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಎರಡು ಉಲ್ಲೇಖಗಳು ಆರ್.
 ಆದ್ದರಿಂದ ನಾವು ಈ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ ಹೊಂದಿವೆ.
 ಈ ಉದಾಹರಣೆಗೆ ನಾವು TF ಹೊಂದಿರುತ್ತವೆ, ಮತ್ತು ಸೂಚ್ಯಂಕ ಹೆಸರು.
 ನಾವು, ಕ್ಯಾಲೊರಿ ಬೇಕಾದರೂ, ಸೂಚ್ಯಂಕ, ಹೆಸರು "ಅಲಿ" ಹಾಕಲು ನೀನು
 ನಾವು ಬದಲಿಗೆ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಇಂಟ್ ಈ ಬಾರಿ ಹಾಕಬಹುದು,
 ತದನಂತರ ಸೂಚ್ಯಂಕ ಸಾಲಿಗೆ, ನಾವು ಒಳಗೆ ಇಡೀ ರಚನೆಯ ಹಾಕಬಹುದು.
 ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ಇದೆ - ಅದು ನಾವು ಹೇಗೆ ಒಂದು ರೀತಿಯ ಪರಿಕಲ್ಪನೆಯನ್ನು
 ಸಂಖ್ಯೆಯ ಸೂಚ್ಯಂಕಗಳು ಆದರೆ ಈಗ ನಾವು ಸುಮಾರು ಸೂಚ್ಯಂಕಗಳು ಬದಲಾಯಿಸಬಹುದು
 ಬದಲಿಗೆ ತಂತಿಗಳನ್ನು ಅವುಗಳನ್ನು ಹೊಂದಲು.
 ನೀವು ಕೇವಲ ಪ್ರತ್ಯೇಕವಾಗಿ ಮಾಡುತ್ತಿದ್ದೆ ಜೊತೆಗೆ, ಈ ಮಾಡಬಹುದು
 ನೀವು ಒಂದು ಚಂಕ್ ಎಲ್ಲಾ ಮಾಡಬಹುದು. ಆದ್ದರಿಂದ ನೀವು ಆ ರಚನೆಯ TF ನೋಡಬಹುದು
 ನಂತರ ನಾವು ಒಂದು ದೈತ್ಯ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಸೆಟ್ ಅವರನ್ನು ಎಲ್ಲಾ ಸೆಟ್.
 ಆದ್ದರಿಂದ ವಸ್ತುಗಳನ್ನು ವೇಗವನ್ನು ಮಾಡಬಹುದು.
 ಇದು ಹೆಚ್ಚು ಶೈಲಿಯ ಆಯ್ಕೆ ಹೆಚ್ಚಿನ.
 ನಾವು ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ.
 ಸಿ ನಾವು ಈ ರೀತಿಯ ಕೆಲಸ ಕುಣಿಕೆಗಳು ಹೊಂದಿವೆ.
 ನಮ್ಮ ರಚನೆಯ ಹೊಂದಿತ್ತು, ಮತ್ತು ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಸೂಚ್ಯಂಕ 0 ಹೋದರು,
 ಮತ್ತು ನಾವು ಸರಿ, ಎಲ್ಲಾ ಮುದ್ರಿಸಲು?
 , ಸಮಸ್ಯೆ ಸಹವರ್ತನೀಯ ಸರಣಿಗಳ ಫಾರ್, ಹೊರತುಪಡಿಸಿ
 ನಾವು ಅಗತ್ಯವಾಗಿ ಆ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕಗಳು ಗೊತ್ತಿಲ್ಲ
 ಈಗ ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸೂಚ್ಯಂಕಗಳು ಏಕೆಂದರೆ.
 ಈಗ ನಾವು ಮತ್ತೆ, ನೀವು ಆಶಾದಾಯಕವಾಗಿ pset 7 ಬಳಸಲಾಗುತ್ತದೆ ಇದು, foreach ಕುಣಿಕೆಗಳು, ಬಳಸಿ.
 Foreach ಕುಣಿಕೆಗಳು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಭಾಗ ತಿಳಿಯುವುದಿಲ್ಲ.
 ಮತ್ತು ಇದು, ನೀವು ನಿಖರವಾಗಿ ಸಂಖ್ಯಾತ್ಮಕ ಸೂಚ್ಯಂಕ ತಿಳಿಯಲು ಹೊಂದಿಲ್ಲ.
 ಆದ್ದರಿಂದ ನೀವು ಸರಣಿ ಪುಟ್, ನೀವು foreach ವಾಕ್ಯ, ಆದ್ದರಿಂದ foreach ಇಲ್ಲಿದೆ.
 , ಆದ್ದರಿಂದ ನನ್ನ ರಚನೆಯ pset ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ ಪದ, ಮಾಹಿತಿ
 ತದನಂತರ ನೀವು ಬಳಸಲು ನೀನು ಈ ಸ್ಥಳೀಯ ತಾತ್ಕಾಲಿಕ ವೇರಿಯಬಲ್ ಪುಟ್
 ಕೇವಲ ನಿರ್ದಿಷ್ಟ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ ವಿಶೇಷವೇನು ನಿರ್ದಿಷ್ಟ ವಿಚಾರಕ್ಕೆ -
 ಒಂದು ಉದಾಹರಣೆಗೆ ಅಥವಾ ರಚನೆಯ ಒಂದು ವಿಭಾಗ.
 , Pset NUM 1 ಅನ್ವಯಿಸುತ್ತದೆ, ಮತ್ತು ನಂತರ ಬಹುಶಃ ಇದು ಸಂಖ್ಯೆಯ 6 ಅನ್ವಯಿಸುತ್ತದೆ
 ತದನಂತರ ಅದು 2 ಅನ್ವಯಿಸುತ್ತದೆ.
 ಅದು ರಚನೆಯ ಇಲ್ಲಿದೆ ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯ ಮೂಲಕ ಹೋಗಲು ಖಾತರಿ ವಿಶೇಷವೇನು.
 ನೀವು ಪಿಎಚ್ಪಿ ರಲ್ಲಿ ತಿಳಿದಿದೆ ಎಂದು ಉಪಯುಕ್ತ ಕಾರ್ಯಗಳನ್ನು ಅಗತ್ಯವಿದೆ,
 ನಿರ್ಗಮನ, ಖಾಲಿ, ಪ್ರತಿಧ್ವನಿ ಆದ್ದರಿಂದ, ನೀವು ಕೆಲವು ಕಡತಗಳನ್ನು ಸೇರಿದಂತೆ ಇಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
 ನಾನು ಹೆಚ್ಚು ನೀವು pset 7 ನೋಡಲು ಮತ್ತು ಆ ಕಾರ್ಯಗಳನ್ನು ನೋಡಲು ಶಿಫಾರಸು.
 ನೀವು ಆ ತಿಳಿಯಲು ಹೊಂದಿರಬಹುದು,
 ಆದ್ದರಿಂದ ನಾನು ಖಂಡಿತವಾಗಿ ನಿಖರವಾಗಿ, ಆ ಎಲ್ಲಾ ಏನು, ತಿಳಿಯುವುದಿಲ್ಲ.
 

ಈಗ ನಾವು ತ್ವರಿತವಾಗಿ ವ್ಯಾಪ್ತಿ ಮೂಲಕ ಹೋಗಲು ನೀನು.
 ವ್ಯಾಪ್ತಿ, ಪಿಎಚ್ಪಿ, ಸಿ ಭಿನ್ನವಾಗಿ, ಒಂದು ಮೋಜಿನ ವಿಷಯ ರೀತಿಯ
 ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ತ್ವರಿತವಾಗಿ ಮೂಲಕ ಹೋಗಲು ನೀನು.
 ಆದ್ದರಿಂದ ನಾವು ನಾವು ಹೊಂದಿರುವ ಆ ಬಾಣದ ಆರಂಭವಾಗುವುದು ಹೇಳಲು ಅವಕಾಶ.
 ನಾವು $ ನಾನು ಪ್ರಾರಂಭಿಸಿ ನೀನು. ಆದ್ದರಿಂದ ವೇರಿಯಬಲ್ 'ನಾನು', 0 ಏರಲಿದೆ
 ಮತ್ತು ನಾವು ಅಲ್ಲಿ ಮೇಲೆ ದೊಡ್ಡ ಬಿಳಿ ಬಾಕ್ಸ್ ನಲ್ಲಿ ಅದನ್ನು ಮುದ್ರಿಸುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು.
 ನಾವು i0 ಆರಂಭಿಸಲು ನೀನು, ಮತ್ತು ನಾವು ಅದನ್ನು ಪ್ರತಿಧ್ವನಿ ನೀನು.
 ಆದ್ದರಿಂದ 0 ಇಲ್ಲ.
 ನಂತರ ನಾವು, ಲೂಪ್ ಮೂಲಕ ಇದನ್ನು ಹೆಚ್ಚಿಸಲು ನೀನು
 ಮತ್ತು ಇದು 1 ಮೌಲ್ಯವನ್ನು ಎಂದು ವಿಶೇಷವೇನು.
 , ಒಂದು ಕಡಿಮೆ 3, ಆದ್ದರಿಂದ ಎಂದು ಲೂಪ್ ಮೂಲಕ ಹಾದು ಹೋಗುವುದಿಲ್ಲ
 ನಂತರ ನಾವು ಮತ್ತೆ ಮುದ್ರಿತ ನೋಡಲು ನೀನು.
 ನಾವು, 2 ಮತ್ತೆ ಹೆಚ್ಚಿಸಲು ನೀನು
 ಮತ್ತು 2 3 ಕಡಿಮೆ, ಆದ್ದರಿಂದ ಲೂಪ್ ಪಾಸ್ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಇದು 2 ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ.
 ನಂತರ ನೀವು 3 3 ಕಡಿಮೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ಭೇದಿಸಿ ಮಾಡುತ್ತೇವೆ.
 ಈಗ ನಾವು ನಿರ್ಗಮಿಸಿದೆ ಬಂದಿದೆ ನಂತರ ನಾವು aFunction ಹೋಗಿ ನೀನು.
 ಸರಿ. ಆದ್ದರಿಂದ ನೀವು, ಈ ವೇರಿಯಬಲ್ ನಾವು ರಚಿಸಿದ ಗಮನಿಸಿ ಮಾಡಬೇಕು
 'ನಾನು' ವೇರಿಯಬಲ್, ಸ್ಥಳೀಯವಾಗಿ ಕ್ಷೇತ್ರ ಇದೆ.
 ಅದು ಲೂಪ್ ಸ್ಥಳೀಯ ಅಲ್ಲ ಎಂದರ್ಥ,
 ಮತ್ತು ವೇರಿಯಬಲ್ ನಾವು ಇನ್ನೂ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ನಂತರ ಬದಲಾಯಿಸಲು, ಮತ್ತು ಇದು ಇನ್ನೂ ಪರಿಣಾಮಕಾರಿ ಮಾಡಬಹುದು.
 ನೀವು ಈಗ ಕಾರ್ಯ ಹೋಗಿ ಆದ್ದರಿಂದ, ನೀವು, ನಾವು 'ನಾನು' ವೇರಿಯಬಲ್ ಬಳಸುವ ನೋಡುತ್ತಾರೆ
 ಮತ್ತು ನಾವು 'ನಾನು' + ಹೆಚ್ಚಿಸಲು ನೀನು.
 ನೀವು 'ನಾನು' ವೇರಿಯಬಲ್ ಪ್ರತಿಯನ್ನು ಎಂದು, ಸಿ ಆಧರಿಸಿ, ಮೊದಲಿಗೆ, ಯೋಚಿಸುವುದಿಲ್ಲ.
 ಇದು ಸರಿಯಾದ ಇದು, ಸಂಪೂರ್ಣವಾಗಿ ಬೇರೆ ವಿಷಯ.
 ನಾವು ಅದನ್ನು ಮುದ್ರಿಸಲು ಮಾಡಿದಾಗ, ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಹೋಗುವ ಇದು, 'ನಾನು' + ಮುದ್ರಿಸಿ ನೀನು 4,
 ಕ್ಷಮಿಸಿ - ಮತ್ತು ನಾವು ನೀನು.
 ನಂತರ ನಾವು ಆ ಕ್ರಿಯೆಯ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು,
 ಮತ್ತು ನಾವು ಬಾಣದ ಇದೀಗ ಅಲ್ಲಿ ಎಂದು ನೀನು.
 ಆ ನಂತರ, ಆದಾಗ್ಯೂ, ಕಾರ್ಯ 'ನಾನು' ಮೌಲ್ಯವನ್ನು ಬದಲಾವಣೆ ಕೂಡ ಅರ್ಥ,
 ಇದು ಹೊರಗೆ ಕ್ರಿಯೆಯ ಬದಲಾಗಲಿಲ್ಲ,
 ಕಾರ್ಯ ಪ್ರತ್ಯೇಕ ವ್ಯಾಪ್ತಿಯನ್ನು ಹೊಂದಿದೆ ಏಕೆಂದರೆ.
 ಆ, ನಾವು 'ನಾನು' ಪ್ರತಿಧ್ವನಿ ಅದು ಕಾರ್ಯ ವ್ಯಾಪ್ತಿಯ ಬದಲಾಗಿಲ್ಲ ಅರ್ಥ
 ಆದ್ದರಿಂದ ನಾವು ಮತ್ತೆ 3 ಮುದ್ರಿಸಲು ನೀನು.
 ಸಿ ಹೆಚ್ಚು PHP ಯಲ್ಲಿ ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ ಬೇರೆಬೇರೆ 

ಈಗ PHP ಮತ್ತು HTML ನಲ್ಲಿ.
 ಪಿಎಚ್ಪಿ ವೆಬ್ ಪುಟಗಳು ಕ್ರಿಯಾತ್ಮಕ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.
 ಇದು ರೀತಿಯ ವಸ್ತುಗಳ ವಿವಿಧ ಮಾಡುತ್ತದೆ.
 ನಾವು HTML ಇದನ್ನು ವಿವಿಧ ಹೊಂದಿವೆ.
 ಎಚ್ಟಿಎಮ್ಎಲ್, ನಾವು ಯಾವಾಗಲೂ ಕೇವಲ, ರಾಬ್ ತೋರಿಸಿದರು ಹೇಗೆ ಅದೇ ಸ್ಥಿರ ವಿಷಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ
 ಪಿಎಚ್ಪಿ ಆದರೆ, ನೀವು ಬಳಕೆದಾರ ಯಾರು ಆಧರಿಸಿ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು.
 ನಾನು ಈ ಹಾಗಾಗಿ, ನಾನು, "ನೀವು ಪ್ರವೇಶಿಸಿದಾಗ -" ಮತ್ತು ನಂತರ ಹೆಸರು,
 ಮತ್ತು ನಾನು ಹೆಸರನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಆದ್ದರಿಂದ ಈಗ ಹೆಸರು, ಜೋಸೆಫ್
 ಮತ್ತು ಇದು ", ನನ್ನ ಬಗ್ಗೆ" ಹೊಂದಿದೆ ಆದರೆ ನಂತರ ನಾನು ಟಾಮಿ ಹೊಂದಲು ಹೆಸರು ಬದಲಾಯಿಸಬಹುದು.
 ಮತ್ತು ಬೇರೆ ವಿಷಯ.
 ಆದ್ದರಿಂದ ನಾವು ಅವನ ಬಗ್ಗೆ ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು,
 ಮತ್ತು ಹೆಸರು ಆಧರಿಸಿ ವಿವಿಧ ವಿಷಯ ತೋರಿಸುತ್ತದೆ.
 ಆದ್ದರಿಂದ ಪಿಎಚ್ಪಿ ರೀತಿಯ ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಬಹುದು.
 ಇಲ್ಲಿ ಅದೇ. ಸ್ಟಿಲ್, ಅವರು ಬೇರೆ ವಿಷಯವನ್ನು ಹೊಂದಿರುವ ಗಮನಿಸಿ,
 ನೀವು ತಾಂತ್ರಿಕವಾಗಿ ಇನ್ನೂ ಮೇಲ್ಮೈ ಮೇಲೆ ಅದೇ ವೆಬ್ ಪುಟ ಪ್ರವೇಶಿಸುವ ಸಹ.
 HTML ಉತ್ಪತ್ತಿ. ನೀವು ಹಾಗೆ ಮಾಡಬಹುದು 2 ವಿವಿಧ ಬಗೆಗಳು.
 ನಾವು ಇದೀಗ ಮೂಲಕ ಹೋಗುತ್ತೇನೆ. ಮೊದಲ ರೀತಿಯಲ್ಲಿ ನೀವು, - ಹೌದು, ಕ್ಷಮಿಸಿ.
 ಆದ್ದರಿಂದ ನೀವು, ಪಿಎಚ್ಪಿ ಲೂಪ್ ನಿಮ್ಮ ನಿಯಮಿತ ಹೊಂದಿವೆ
 ತದನಂತರ ನೀವು ಪಿಎಚ್ಪಿ ಪ್ರತಿಧ್ವನಿ ಮತ್ತು ನೀವು HTML ಔಟ್ ಪ್ರತಿಧ್ವನಿ.
 ರಾಬ್ ಎಚ್ಟಿಎಮ್ಎಲ್ ಲಿಪಿಯ ನೀವು ತೋರಿಸಿದ ಬಳಕೆ
 ತದನಂತರ ಕೇವಲ ವೆಬ್ ಪುಟ ಮುದ್ರಿಸುತ್ತದೆ ಪಿಎಚ್ಪಿ ಮುದ್ರಣ ಬಳಸಿ.
 ಪರ್ಯಾಯ ರೀತಿಯಲ್ಲಿ ನೀವು PHP ಮತ್ತು HTML ಬೇರ್ಪಡಿಸಲು ವೇಳೆ ಅದನ್ನು ಮಾಡುವುದು.
 ಆದ್ದರಿಂದ ನೀವು, ಲೂಪ್ ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಪಿಎಚ್ಪಿ ಒಂದು ಸಾಲಿನ ಹೊಂದಬಹುದು
 ನಂತರ ನೀವು ಒಂದು ಪ್ರತ್ಯೇಕ ವಿಷಯ HTML ನ ಲೈನ್ ಹೊಂದಬಹುದು,
 ತದನಂತರ ನೀವು PHP, ಮತ್ತೆ, ಲೂಪ್ ಮುಕ್ತಾಯಗೊಳ್ಳಲಿವೆ.
 ಆದ್ದರಿಂದ ರೀತಿಯ ಇದು ಬೇರ್ಪಡಿಸುವ ವಿಶೇಷವೇನು.
 ಎಡಭಾಗದಲ್ಲಿ, ನೀವು ಹೊಂದಬಹುದಾದ ಎಲ್ಲಾ -
 ಇದು ಪಿಎಚ್ಪಿ ಕೇವಲ 1 ಪಾಲನ್ನು ಇಲ್ಲಿದೆ.
 ಬಲ ಮೇಲೆ ನೀವು, ನೀವು ಪಿಎಚ್ಪಿ ಒಂದು ಲೈನ್ ಎಂದು ನೋಡಬಹುದು
 ನೀವು HTML ಲೈನ್, ಮತ್ತು ನೀವು ಮತ್ತೆ ಪಿಎಚ್ಪಿ ಒಂದು ಲೈನ್.
 ಆದ್ದರಿಂದ ಅವರು ಮಾಡುತ್ತಿರುವುದು ಅದನ್ನು ಬೇರ್ಪಡಿಸುವುದು.
 ಮತ್ತು ನೀವು ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ, ಅವುಗಳನ್ನು ಎರಡೂ, ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ
 ಅವರು ಇನ್ನೂ ಚಿತ್ರ ಮುದ್ರಿಸುತ್ತದೆ, ಚಿತ್ರ, ಚಿತ್ರ,
 ಆದ್ದರಿಂದ HTML ಇನ್ನೂ ಅದೇ ರೀತಿಯಲ್ಲಿ ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.
 ತದನಂತರ ನೀವು ಇನ್ನೂ 3 ಚಿತ್ರಗಳನ್ನು ನಿಮ್ಮ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವುದಿಲ್ಲ ನೋಡುತ್ತಾರೆ.
 ಆದ್ದರಿಂದ ಒಂದೇ ಮಾಡುವ 2 ರೀತಿಯಲ್ಲಿ ಇಲ್ಲಿದೆ.
 

ಈಗ ನಾವು ರೂಪಗಳು ಮತ್ತು ವಿನಂತಿಗಳನ್ನು ಹೊಂದಿವೆ. ರಾಬ್, ನೀವು ತೋರಿಸಿದೆ
 ಅಲ್ಲಿ HTML ರೂಪಗಳು, ಮತ್ತು ನಾವು ಈ ಮೂಲಕ ಗಾಳಿ ಕಾಣಿಸುತ್ತದೆ.
 ಕ್ರಿಯಾಶೀಲ ಮತ್ತು ನೀವು ಒಂದು ವಿಧಾನವನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ನಿಮ್ಮ ಕ್ರಮ
 ರೀತಿಯ ನೀವು ಕಳುಹಿಸಲು ನೀನು ಅಲ್ಲಿ ನೀವು ತೋರಿಸುತ್ತದೆ, ಮತ್ತು ವಿಧಾನ ಎಂದು
 ಇದು ಒಂದು ಪಡೆಯಲು ಅಥವಾ ಪೋಸ್ಟ್ ಎಂದು ವಿಶೇಷವೇನು.
 ಮತ್ತು ಪಡೆಯಿರಿ ವಿನಂತಿಯನ್ನು, ರಾಬ್ ಹೇಳಿದಂತೆ, ನೀವು ರೂಪದಲ್ಲಿ ಪುಟ್ ನೀನು ಅರ್ಥ
 ಒಂದು ವಸತಿ ವಿನಂತಿಯನ್ನು ನೀವು ಒಂದು URL ನೋಡಿ ಸಾಧ್ಯವಿಲ್ಲ ಆದರೆ ಮತ್ತು ನೀವು, ಒಂದು URL ಇದನ್ನು ನೋಡುತ್ತಾರೆ.
 ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವ್ಯತ್ಯಾಸ.
 ಆದರೆ, ಇದೇ ವಿಷಯ ಒಂದು ವಿಷಯ
 ಪೋಸ್ಟ್ ಪಡೆಯಿರಿ ಸಮನಾಗಿ ಅಸುರಕ್ಷಿತ ಎಂಬುದು.
 ಆದ್ದರಿಂದ ನೀವು, ಕೇವಲ ನೀವು URL ನಲ್ಲಿ ನೋಡದಿದ್ದರೆ ಎಂದು ಭಾವಿಸಬಹುದು
 ಎಂದು, ಪೋಸ್ಟ್ಗೆ ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಅರ್ಥ
 ಆದರೆ ನೀವು ಇನ್ನೂ ನೀವು ಕಳುಹಿಸಲು ನೀವು ಮಾಹಿತಿಯನ್ನು ನಿಮ್ಮ ಕುಕೀಸ್ ಇದನ್ನು ನೋಡಬಹುದು.
 ಆದ್ದರಿಂದ ಯೋಚಿಸುವುದಿಲ್ಲ ಬಗ್ಗೆ ಒಂದು ಅಥವಾ ಇತರ.
 ಗಮನಿಸಬೇಕಾದ ಇನ್ನೊಂದು ವಿಷಯ ನೀವು ವಿಭಾಗದಲ್ಲಿ ಅಸ್ಥಿರ ಹೊಂದಿರುತ್ತವೆ.
 ನೀವು ಹುಡುಗರಿಗೆ ನಿಮ್ಮ ಬಳಕೆದಾರ ID ಮಾಹಿತಿ ಪಡೆಯಲು pset 7 ರಲ್ಲಿ ಈ ಬಳಸಲಾಗುತ್ತದೆ.
 ಏನಾಯಿತು ಈ ಸಹಾಯಕ ರಚನೆಯ ಬಳಸಬಹುದಾದ ಆಗಿತ್ತು,
 $ _SESSION, ಮತ್ತು ನಂತರ ನೀವು ವಿವಿಧ ವಿಷಯಗಳಿಗೆ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನೀವು
 ಮತ್ತು ಪುಟಗಳು ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು.
 

ಕೊನೆಯ ವಿಷಯ, ನಾವು SQL, ರಚನಾತ್ಮಕ ವೈಚಾರಿಕ ಭಾಷೆ ಹೊಂದಿರುತ್ತವೆ
 ಮತ್ತು ಈ ಡೇಟಾಬೇಸ್ ನಿರ್ವಹಿಸಲು ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.
 , ನಿಖರವಾಗಿ, ಡೇಟಾಬೇಸ್ ಯಾವುವು? ಅವರು ಕೋಷ್ಟಕಗಳು ಸಂಗ್ರಹಣೆಗಳು ಆರ್,
 ಮತ್ತು ಪ್ರತಿ ಟೇಬಲ್ ವಸ್ತುಗಳ ಇದೇ ರೀತಿಯ ಹೊಂದಬಹುದು.
 ನಾವು ನಿಮ್ಮ ಹಣಕಾಸು pset ರಲ್ಲಿ ಬಳಕೆದಾರರು ಒಂದು ಟೇಬಲ್ ಹೊಂದಿತ್ತು.
 ಯಾಕೆ ಅವರು ಉಪಯುಕ್ತ? ಇದು ಶಾಶ್ವತವಾಗಿ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಒಂದು ರೀತಿಯಲ್ಲಿ ಕಾರಣ.
 ಇದು ವಿಷಯಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮತ್ತು ವಿಷಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
 ಮತ್ತು ವಾಸ್ತವವಾಗಿ ವಿವಿಧ ಪುಟಗಳು ಮತ್ತು ಕೀಪಿಂಗ್ ಟ್ರ್ಯಾಕ್ ಮೇಲೆ ನೋಡಿದ.
 ಆದರೆ ನೀವು ಕೇವಲ ಒಂದು ತಕ್ಷಣದ ಕ್ಷಣದಲ್ಲಿ ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇಳೆ
 ನಂತರ ಅದನ್ನು ಬಳಸಲು, ನೀವು ಉಳಿಸಿದ್ದೇವೆ ಏನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
 ನಾವು ನಾವು SQL ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಲು 4 ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು.
 ನಾವು ಆಯ್ಕೆ ಸೇರಿಸು, ಅಳಿಸಿ, ಮತ್ತು ಅಪ್ಡೇಟ್ ಹೊಂದಿವೆ.
 ಆ ನೀವು ಹುಡುಗರಿಗೆ ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ ತಿಳಿಯಲು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯ.
 

ಬೇಗ ಇದೀಗ ಮೇಲೆ ಆಯ್ಕೆ ಹೋಗುತ್ತೇನೆ.
 ಮೂಲಭೂತವಾಗಿ, ನೀವು ಒಂದು ಡೇಟಾಬೇಸ್ ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.
 ಆದ್ದರಿಂದ ನೀವು ಇಲ್ಲಿಯೇ, ಹೊಂದಿದ್ದರೆ -
 ನಾವು ಈ 2 ಬೇರೆಬೇರೆ, ಮತ್ತು ನಾವು ತರಗತಿಗಳು ಟೇಬಲ್ ಆಯ್ಕೆ ಬಯಸುವ
 ನಿಜಕ್ಕೂ - ನಾಡಿದು ಅಂಕಣದಲ್ಲಿ ಮೌಲ್ಯ 1 ಅಲ್ಲಿ.
 ನೀವು ಇಲ್ಲಿ ನೋಡಬಹುದು ಆದ್ದರಿಂದ, ನಾವು, ವರ್ಗ ಹೆಸರಿನ ಈ 2 ವಿಷಯಗಳನ್ನು
 CS50 ಮತ್ತು Stat110, ಮತ್ತು ನಾವು ವರ್ಗ ID ಗಳು ಮತ್ತು ಘೋಷಣೆ ಹೊಂದಿವೆ.
 ನಾವು ಎಲ್ಲಾ ಮಾಹಿತಿಗಳನ್ನು ಆಯ್ಕೆ ಬಯಸುವ.
 ನಂತರ ನೀವು, ಇದು ರೀತಿಯ ನಿಜಕ್ಕೂ ಅಂಕಣ ಉಂಟಾಗದಂತೆ ಎಂದು ಇಲ್ಲಿಯೇ ನೋಡಬಹುದು
 ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು 1, ಮತ್ತು ನಂತರ ಅದನ್ನು ವರ್ಗ ID ಯನ್ನು, ವರ್ಗದ ಹೆಸರು ಮತ್ತು ತೆಗೆಯಬೇಡಿ ಎಂದು ಘೋಷಣೆ ಹೊಂದಿದೆ ಅಲ್ಲಿ.
 ನೀವು ಈ ಕೋಡ್ ಹೇಗೆ ನಿಖರವಾಗಿ ಮಾಡಬೇಕು? ನೀವು ಪಿಎಚ್ಪಿ ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ.
 ಆದ್ದರಿಂದ ಆ ರೀತಿಯ ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಪರಸ್ಪರ ಸಂಬಂಧಿಸಿದ ಹೇಗೆ ಇಲ್ಲಿದೆ.
 ಈಗ ನಾವು ನಮ್ಮ ಕೋಡ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾವು ನಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಕಾರ್ಯ ಬಳಸಲು ನೀನು
 ನಾವು pset 7 ಮಾಡಿದರು, ಮತ್ತು ನಾವು SQL ಪ್ರಶ್ನೆ ಚಲಾಯಿಸಲು ನೀನು.
 ನಂತರ ನಾವು ನೀನು -
 ನಾವು ಯಾವಾಗಲೂ ಸುಳ್ಳು ವೇಳೆ ಸಾಲು ತ್ರಿವಳಿ ಸಮಾನ ವೇಳೆ ಪರೀಕ್ಷಿಸಲು ಹೊಂದಿಲ್ಲ. ಆದ್ದರಿಂದ ಮತ್ತೆ, ನೀವು ರೀತಿಯ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸಿ ಬಯಸುವ,
 ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ನಂತರ ನೀವು ನಾವು pset 7 ಮಾಡಿದಂತೆ, ಎಂದಿನಂತೆ, ಕ್ಷಮೆ ಬಯಸುವ.
 ಇಲ್ಲವಾದರೆ, ನೀವು ಆ HANDY ಎಲ್ಲವೂ ಮೂಲಕ ಲೂಪ್ ಬಯಸುವ
 foreach ನಾವು ಹೋದೆ ಕುಣಿಕೆಗಳು.
 , ನಾವು ಮೂಲಕ ಲೂಪ್ ನೀವು ಮತ್ತು ನಾವು ಕಳೆದ ಅದನ್ನು ಮಾಡಿದ ಈಗ ಆ
 ನಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಜಾರಿಗೆ ಎಂದು ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ, ಈಗ ನಮ್ಮ foreach ಲೂಪ್ ಹೊಂದಿರುತ್ತವೆ.
 ಮತ್ತು ಮೊದಲ ಸಾಲು ಇದು, ಇಲ್ಲಿ ಸಾಲು ಇಲ್ಲಿಯೇ, ಇಲ್ಲಿದೆ; ಇದು, ಪೆಟ್ಟಿಗೆಯ.
 ಇದು ನೆತ್ತಿಗೇರಿದೆ ಎಂದು ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು.
 ಆದ್ದರಿಂದ ಕೆಳಭಾಗದಲ್ಲಿ ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು "ವಾನ್ನಾ HTML ತಿಳಿಯಿರಿ?"
 ಇದು ಲೂಪ್ ಮೊದಲ ಸಂಪೂರ್ಣಗೊಂಡ ನಂತರ ಏಕೆಂದರೆ ಇದು, ಮುಂದಿನ ಸಾಲು ಹೋಗಲು ವಿಶೇಷವೇನು
 ಹೀಗಾಗಿ ಅದು, ಇದು ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ ಔಟ್ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
 STAT110 ಏರಲಿದೆ ಇದು, ಎಲ್ಲಾ ಕ್ಷಣಗಳ ಕ್ಲಿಕ್.
 

ಒಂದು ಕೊನೆಯ ವಿಷಯ SQL ಲೋಪಗಳ ಮೇಲೆ.
 ನಾನು ಡೇವಿಡ್ ಈ ಮೇಲೆ ಉಪನ್ಯಾಸ ಸ್ವಲ್ಪ ಮುಟ್ಟಲಿಲ್ಲ ಗೊತ್ತು.
 ನೀವು ನಂತರ ಈ ಓದಬಹುದು. ಇದು ನಿಜವಾಗಿಯೂ ಹಾಸ್ಯಾಸ್ಪದ.
 SQL ಇಂಜೆಕ್ಷನ್ ಟ್ರಿಕಿ ವಿಷಯ ಒಂದು ರೀತಿಯ.
 ನೀವು ಸರಿಯಾದ ನಿಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಒಳಗೆ ಆ ಅಸ್ಥಿರ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಎಂದು ಹೇಳುತ್ತಾರೆ,
 ನೀವು ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ನೋಡಬಹುದು.
 ಆದ್ದರಿಂದ ಬಲ, ಉತ್ತಮ ತೋರುತ್ತದೆ? ನೀವು ಬಳಕೆದಾರ ಹೆಸರು ಪುಟ್ಟಿಂಗ್ ಮಾಡುತ್ತಿರುವ
 ನಿಮ್ಮ SQL ಪ್ರಶ್ನೆ ಪಾಸ್ವರ್ಡ್, ಮತ್ತು ನೀವು ಅದನ್ನು ಆಫ್ ಹಡಗು ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಕೋಷ್ಟಕದಲ್ಲಿ ಏನೇ ಸಿಗತ್ತೆ.
 ಬಹಳ ಸರಳ ತೋರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಯಾರಾದರೂ ಇರಿಸುತ್ತದೆ ಹೇಳಲು ಅವಕಾಶ
 ಪಾಸ್ವರ್ಡ್, ಈ ಅಥವಾ ಪಠ್ಯ ಇಲ್ಲಿಯೇ -
 ವಾಸ್ತವವಾಗಿ ಕೆಂಪು ಬಾಕ್ಸ್ ನಲ್ಲಿ ಇರಬೇಕು.
 ಆದ್ದರಿಂದ ಅವರು ಒಳಗೆ ಪಾಸ್ವರ್ಡ್ ಪುಟ್ ಎಂದು ತಿಳಿಸಿ - ಎಂದು ಅವರು ನಮೂದಿಸಿ ಇಲ್ಲಿದೆ.
 ಆದ್ದರಿಂದ ಅವರು ಹಾಕುವ ಅಥವಾ "1" = 1 ಮಾಡುತ್ತಿದ್ದೇವೆ.
 ಹೊಂದಲು ಒಂದು ಸಿಲ್ಲಿ ಗುಪ್ತಪದವನ್ನು ರೀತಿಯ.
 ಈಗ ಅದನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ, ಮತ್ತು ನೀವು ಈಗ SQL ಪ್ರಶ್ನೆ ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ,
 ನೀವು ಗಮನಿಸಿ ನೀವು ಏಕೆಂದರೆ ಇದು, ಯಾವಾಗಲೂ ನಿಜವೆಂದು ಮಾಪನ ಎಂದು
 ನೀವು SQL ಪ್ರಶ್ನೆ ಈ ಮಾಹಿತಿಯನ್ನು ಎಲ್ಲಾ ಆಯ್ಕೆ ಮಾಡಬಹುದು
 ಅಥವಾ ನೀವು ಕೇವಲ = 1 1 ಹೊಂದಬಹುದು.
 ಆದ್ದರಿಂದ ಯಾವಾಗಲೂ ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ವಿಶೇಷವೇನು.
 ಎಂದು ಹ್ಯಾಕರ್ ನಿಮ್ಮ ವ್ಯವಸ್ಥೆಯ ಮುರಿದು ಎಂದರ್ಥ ಏಕೆಂದರೆ, ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಹಿಂದಿರುಗಬಹುದೆಂದು.
 ಈ ಪರಿಹಾರ ನೀವು, PDO ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಲು ಹೊಂದಿರುತ್ತವೆ,
 ಇದು, ನೀವು ಪ್ರಶ್ನೆ ಅಂಕಗಳನ್ನು ಬಳಸಲು ಎಂದು ಅರ್ಥ
 ಏನು ನೀವು pset 7 ಬಳಸಲಾಗುತ್ತದೆ ಹುಡುಗರಿಗೆ, ಇದು
 ನೀವು ಏನಾದರೂ ಹಾಕಲು ಬಯಸುವ ಸ್ಥಳದಲ್ಲಿ ಒಂದು ಪ್ರಶ್ನೆ ಗುರುತು ಬಳಸಲು ನೀನು ಅಲ್ಲಿ,
 ಮತ್ತು, ನಂತರ ನೀವು ಚಿಹ್ನೆಗಳಿಂದ ಮಾಡಲಿಕ್ಕೆ, ಮತ್ತು ನಂತರ ನೀವು ನಂತರ ಹೊಂದಿರುತ್ತದೆ
 ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ನಂತರ, ನೀವು ಬಯಸುವ ವಿಭಿನ್ನ ಅಸ್ಥಿರ ನಿಮ್ಮ ಪ್ರಶ್ನೆ ಗುರುತು ಒಳಗೆ ಬದಲಿಗೆ.
 ಆದ್ದರಿಂದ ನೀವು ಈಗ ನಾನು ಈ ಕೆಂಪು ಪ್ರಶ್ನೆ ಅಂಕಗಳನ್ನು ಹೊಂದಿವೆ ಇಲ್ಲಿ ಗಮನಿಸಿ ಮಾಡುತ್ತೇವೆ.
 ನಾನು ನಂತರ ಎಂದು ಸಲುವಾಗಿ ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಲು ಗೊತ್ತು ಆದ್ದರಿಂದ ನನ್ನ ತಂತಿಗಳನ್ನು ನಂತರ ಅಸ್ಥಿರ ಪುಟ್.
 ಯಾರಾದರೂ ಈ ರೀತಿ ಇದ್ದಲ್ಲಿ, ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಕಾಣಿಸುತ್ತದೆ
 ಮತ್ತು ಅವರು, ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಎಂದು, ಅಥವಾ 1 = 1 ಪರಿಸ್ಥಿತಿ ಹೊಂದಿವೆ
 ಮತ್ತೆ ಕೊನೆಯಲ್ಲಿ, ಇದು ವಾಸ್ತವವಾಗಿ SQL ಪ್ರಶ್ನೆ ಮುರಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
 ಸರಿ, ಪಿಎಚ್ಪಿ ಮತ್ತು SQL ಸುಂಟರಗಾಳಿ, ಬಹುಮಟ್ಟಿಗೆ ಅದು ಇಲ್ಲಿದೆ.
 ನೀವು ಎಲ್ಲಾ ಅದೃಷ್ಟ ಉತ್ತಮ, ಮತ್ತು ಈಗ Ore. ಗೆ
 

[Oreoluwatomiwa Babarinsa] ಸರಿ ಎಲ್ಲರೂ. ಕೆಲವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೇಲೆ ಹೋಗಲು ಟೈಮ್
 ಮತ್ತು ಇತರ ವಿಷಯಗಳನ್ನು ಬೇಗನೆ ಆದ್ದರಿಂದ ನಾವು ನೀವು ಟುನೈಟ್ ಪಡುವುದಿಲ್ಲ.
 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್. ಹೌದು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ, ತಂಪಾದ ವಿಷಯ ರೀತಿಯ.
 ನೀವು ನಿಜವಾಗಿಯೂ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ತಿಳಿದುಕೊಳ್ಳಬೇಕು ವಿಷಯಗಳನ್ನು, ಇದು ರೀತಿಯ ಹೀಗಿದೆ
 ನಿಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡುವಾಗ ಏನಾಗುತ್ತಿದೆ ಕ್ಲೈಂಟ್ ಸೈಡ್ ಕೊನೆಯಲ್ಲಿ.
 ನೀವು ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ಸಾರ್ವಕಾಲಿಕ ಆರೈಕೆಯನ್ನು ಬಯಸುವುದಿಲ್ಲ ಕೆಲವು ವಿಷಯಗಳಿವೆ.
 ಎಲ್ಲಾ ಸ್ವಲ್ಪ ಪರಸ್ಪರ, ಒಂದು ವಿಷಯ ಹೈಲೈಟ್ ಏನೋ ಕಣ್ಮರೆಯಾಗಿ ಮಾಡುವ.
 ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಪರಿಚಾರಕಕ್ಕೆ ಸಾರ್ವಕಾಲಿಕ ಮಾತನಾಡಲು ಹೊಂದಿವೆ ಬಯಸುವುದಿಲ್ಲ.
 ಮತ್ತು ಕೆಲವು ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ಮಾಡಲು ಸಹ ಸಾಧ್ಯವಿಲ್ಲ.
 ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯ ಅಗತ್ಯವಿದೆ ಏಕೆ ಇದು.
 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಗ್ಗೆ ಕೂಲ್ ವಿಷಯಗಳನ್ನು: ಇದು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಟೈಪಿಸಿದ ಇದೆ.
 ಏನು ಇದರರ್ಥ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ತಿಳಿದುಕೊಳ್ಳಬೇಕು ಮಾಡುವುದಿಲ್ಲ ಎಂದು
 ನೀವು ಇದನ್ನು ಬರೆಯಲು ಏನು, ನಿಖರವಾಗಿ, ಚರಾಂಕಗಳ ಇವೆ.
 ಇದು ಚಾಲನೆಯಲ್ಲಿರುವ ಎಂದು ಕೇವಲ ರೀತಿಯ ಇದು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ.
 ಅದರ ಬಗ್ಗೆ ತಂಪಾದ ಇತರ ವಸ್ತುಗಳ: ಇದು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಭಾಷೆ,
 ಇದು ವಾಕ್ಯ ಸಿ ಮತ್ತು ಪಿಎಚ್ಪಿ ಹೋಲುತ್ತದೆ ಅರ್ಥ.
 ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಲಿಕೆ ಮಾಡಿದಾಗ ಹೆಚ್ಚು ಮರು ಮಾಡಲು ಹೊಂದಿಲ್ಲ.
 ಇಲ್ಲಿ ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸ್ವಲ್ಪ ಹೊಂದಿವೆ.
 ಇಲ್ಲಿಯೇ ಕುತೂಹಲಕಾರಿ ವಿಷಯ, ನೀವು ಅದನ್ನು ನೋಡಿದರೆ, ಆಗಿದೆ
 ನಾವು ತಲೆ ಟ್ಯಾಗ್ ಬಲ ಅಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಂದು ಬಿಟ್ ಹೊಂದಿವೆ.
 ಏನು ಮೂಲತಃ ಕೇವಲ ಒಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಡತ ಸೇರಿವೆ ಇದೆ ಮಾಡುವುದಿಲ್ಲ.
 ಈ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಳಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೊಳ್ಳಬಹುದು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.
 ನಂತರ ಎರಡನೇ ಸ್ವಲ್ಪ, ವಾಸ್ತವವಾಗಿ ಕೆಲವು ಇನ್ಲೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆಗಿದೆ
 ಅತ್ಯಂತ ಸಿಎಸ್ಎಸ್ ಒಂದು ಇನ್ಲೈನ್ ಶೈಲಿ ಹೋಲುವ,
 ಮತ್ತು ನೀವು ಬೇಗನೆ ಕೆಲವು ಕೋಡ್ ಬರೆಯುತ್ತಿದ್ದೇವೆ.
 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಾಲುಗಳು ಹೊಂದಿದೆ.
 ತುಂಬಾ ಉಪಯುಕ್ತ, ಸುಮಾರು ದಶಮಾಂಶ ಇರಿಸಿಕೊಳ್ಳಲು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ.
 ಬಹಳ ಸಂತೋಷವನ್ನು ಮತ್ತು ಸುಲಭ ವಾಕ್ಯ.
 ನೀವು ಎಲ್ಲವನ್ನೂ ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಒಟ್ಟಿಗೆ ಎಲ್ಲವೂ ಇರಿಸಿಕೊಳ್ಳಲು ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಬಳಸಿ.
 ತುಂಬಾ ಸಂಕೀರ್ಣ ನಥಿಂಗ್.
 ಸಾಮಾನ್ಯವಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಲಿಪಿಗಳ ಬಗ್ಗೆ ತಂಪಾದ ವಿಷಯ
 ನೀವು ರಚನೆಯ ಗಾತ್ರಗಳು ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ ಎಂಬುದು.
 ನೀವು array.length ಬಳಸಲು ಮತ್ತು ಇದು ಟ್ರ್ಯಾಕ್,
 ಮತ್ತು ರಚನೆಯ ಬೆಳೆಯಲು ಅಥವಾ ನೀವು ಅಗತ್ಯವಿರುವ ಕುಗ್ಗಿಸಿ ಮಾಡಬಹುದು.
 ಆದ್ದರಿಂದ ನೀವು ಸಹ, ಯಾವುದೇ ರೀತಿಯ ಬಗ್ಗೆ ಚಿಂತೆ ಮಾಡಬೇಕಿಲ್ಲ
 ಓಹ್ ಇಲ್ಲ, ನಾನು ಹೆಚ್ಚು ವಿಷಯಗಳನ್ನು, ಅಥವಾ ಹಾಗೆ ಏನು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ.
 

ಇಲ್ಲಿ ತಂಪಾದ ವಿಷಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಸ್ತುಗಳು ಕರೆಯುವುದನ್ನು ಹೊಂದಿದೆ. ಇದು ವಸ್ತುನಿಷ್ಟವಾದ ಭಾಷೆ, ಆದ್ದರಿಂದ ಅದು ಯಾವ, ಮೂಲಭೂತವಾಗಿ,
 ಗುಂಪು ಡೇಟಾ ನಿಮ್ಮನ್ನು ಒಂದು ರೀತಿಯಲ್ಲಿ ಒಟ್ಟಿಗೆ, ಒಂದು struct ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಹೋಲುತ್ತದೆ,
 ಆದರೆ ನೀವು struct ಹಾಗೆ ಅಥವಾ ಒಂದು ಸಹಾಯಕ ರಚನೆಯ ವಾಕ್ಯ ಇದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
 ಇದು ಬಹಳ ಸರಳ ಮತ್ತು ನೀವು ಈ ಮಾಡಬಹುದು ಒಟ್ಟಿಗೆ ಗುಂಪು ದಶಮಾಂಶ ಆಗಿದೆ
 ನೀವು ಸಂಬಂಧಿಸಿದ ಇಲ್ಲಿದೆ ದತ್ತಾಂಶದ ಒಂದು ಗುಂಪೇ ಇದ್ದರೆ.
 ಇದು ನೀವು ಒಂದು ಕಾರು ವಿವರಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಏಕೆಂದರೆ,
 ನೀವು ಬೇರೆ ಸ್ಥಳಗಳಲ್ಲಿ ಒಂದು ಗುಂಪೇ ಅದನ್ನು ಮಾಡಬೇಕಿಲ್ಲ.
 ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ 1 ವಸ್ತು ಅದನ್ನು ಉಳಿಸಿಕೊಳ್ಳಿ.
 ನೀವು ಬಹುಶಃ ತಿಳಿದಿರುವಂತೆ, iterating ಆ ಬೇಸರದ ಕಾರ್ಯಗಳನ್ನು ಒಂದು.
 ನೀವು ಮತ್ತೆ ಒಂದು ಓವರ್ ಅದನ್ನು. ನೀವು, ಕಾರು ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿನ ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ
 ಅಥವಾ ನೀವು ಪಟ್ಟಿ ಅಥವಾ ಸ್ವಲ್ಪ ಪ್ರತಿ ಐಟಂ ಅನುಸರಿಸುವ ಅಗತ್ಯವಿದೆ.
 ಆದ್ದರಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಪಿಎಚ್ಪಿ, ಒಂದು foreach ವಾಕ್ಯ ಹೋಲುತ್ತದೆ.
 ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಲೂಪ್ ಒಂದು ಇಲ್ಲಿದೆ.
 ನೀವು ಕೇವಲ ವಸ್ತುಗಳ ಮೇಲೆ ಈ ಬಳಸಲು ಬಯಸುವ.
 ನೀವು ಸರಣಿಗಳ ಮೇಲೆ ಈ ಬಳಸುತ್ತಿದ್ದರೆ ಸಂಭವಿಸುವ ಕೆಲವು ಸಮಸ್ಯೆಗಳಿವೆ.
 ಇದು ಸಾಮಾನ್ಯವಾಗಿ, ಆದರೂ, ಬಹಳ ಸಹಾಯಕವಾಗಿದೆ, ಆ ವಸ್ತುಗಳ ಒಂದು
 ನೀವು ಓವರ್ಹೆಡ್ ಬಹಳಷ್ಟು ತೊಡೆದುಹಾಕಲು ಏಕೆಂದರೆ
 ನೀವು ಅದಕ್ಕೆ ನಿಮ್ಮ ವಸ್ತು ಎಲ್ಲವನ್ನೂ ಅಪ್ ಎಳೆಯಿರಿ ಇಲ್ಲ ಏಕೆಂದರೆ.
 ನೀವು ಎಲ್ಲಾ ಪ್ರಮುಖ ಹೆಸರುಗಳು ನೆನಪಿಡಿ ಇಲ್ಲ.
 ನೀವು ಕೇವಲ ರೀತಿಯ ಈ ವಾಕ್ಯ ಅವುಗಳನ್ನು ಮರಳಿ ಪಡೆಯಲು.
 ಈ ರಲ್ಲಿ, ಫಾರ್, ನೀವು ಕೇವಲ ನೆನಪಿಡುವ ಬಯಸುವ
 ನೀವು ಟೇಬಲ್ ಹ್ಯಾಶ್ ಒಂದು ತುಂಬಾ ಇದೇ ರೀತಿಯಲ್ಲಿ, ಎಲ್ಲಾ ಕೀಲಿಗಳನ್ನು ಮತ್ತೆ ಬರುತ್ತಿದೆ.
 ನೀವು ಎಂದು ನೆನಪಿಡಿ ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಹಾಕುತ್ತಾನೆ, ನೀವು ಏನೋ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
 ಇದು ಒಂದು ಸಂಬಂಧ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತದೆ.
 ನೀವು ಈ ಮಾಡಬಹುದು, ನೀವು, ಸರಿ ಹೇಳಬಹುದು
 ನಾನು ಕಾರು ಪುಟ್, ಮತ್ತು ನಾನು ಫೆರಾರಿ ಕರೆಯಲಾಗುತ್ತದೆ.
 ಆದ್ದರಿಂದ ನೀವು ನಂತರ ಮತ್ತೆ ಸ್ಟ್ರಿಂಗ್ ಫೆರಾರಿ ಹಾಕಬಹುದು, ಮತ್ತು ನೀವು ಎಂದು ಪಡೆಯುವುದು.
 ಮತ್ತು ನೀವು ಚಕ್ರಕ್ಕೆ ಜೊತೆ, ಲೂಪ್ ಮಾಡಬಹುದು.
 ಆದ್ದರಿಂದ ಕೇವಲ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು. ನೀವು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಈ ಪ್ರಮುಖ ವಿಷಯ
 , ನೀವು ಈ ಬೇಕಾದಾಗ ನೀವು ವಾಕ್ಯ ವಸ್ತು struct ಬಳಸಿ ಮಾಡಬಹುದು
 ಏನು ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಬಳಸಲು ಹೋಗುವ ಮಾನ್ಯ ವೇರಿಯಬಲ್ ಹೆಸರು ಒಂದು ವೇಳೆ ಹೊರತುಪಡಿಸಿ.
 ನೀವು ಅಲ್ಲಿ ನೋಡಲು ಆದ್ದರಿಂದ, ನಾವು ಖಾಲಿ ಕೀ.
 ಅಲ್ಲದೆ, ನೀವು object.key ಹಾಕಲು ವೇಳೆ, ಬಾಹ್ಯಾಕಾಶ, ಜೊತೆ, ಬಾಹ್ಯಾಕಾಶ, ಖಾಲಿ,
 ಕೇವಲ syntactically ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.
 ಆದ್ದರಿಂದ ನೀವು ಮಾತ್ರ ಬ್ರಾಕೆಟ್ ವಾಕ್ಯ ಈ ರೀತಿಯ ಆ ಮಾಡಬಹುದು.
 

ಸಹ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಬಹಳ ವ್ಯಾಪ್ತಿ ಬಲ್ಲ ಪಿಎಚ್ಪಿ ಹೊಂದಿದೆ.
 ನೀವು ವ್ಯಾಪ್ತಿ ಸಂಬೋಧಿಸುವ 2 ಮಾರ್ಗಗಳಿವೆ.
 ನೀವು ವೇರಿಯಬಲ್ ಮುಂದೆ ವರ್ ಹೊಂದುವಂತಿಲ್ಲ,
 ಮತ್ತು ಕೇವಲ ಈ ಜಾಗತಿಕ ಅರ್ಥ.
 ನೀವು ಎಲ್ಲಿಯಾದರೂ ಅದನ್ನು ನೋಡಬಹುದು. ನೀವು ಒಂದು ವೇಳೆ ಹೇಳಿಕೆ ಈ ಹಾಕಲು ಸಹ,
 ಎಲ್ಲಕ್ಕಿಂತ ನಿಮ್ಮ ಕೋಡ್ ಆ ನಂತರ ನೀವು ವೇರಿಯಬಲ್ ನೋಡಬಹುದು.
 ಇನ್ನೊಂದು ವಿಷಯ, ಆದರೂ, ನೀವು ಸೈನ್ ಆರ್ ಯಾವುದೇ ಕಾರ್ಯ ಸೀಮಿತ ವರ್ ಜೊತೆ
 ನೀವು ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಇಲ್ಲದಿದ್ದರೆ, ಚೆನ್ನಾಗಿ, ಇದು ಜಾಗತಿಕ ಇಲ್ಲಿದೆ.
 ನೀವು ಒಂದು ಕಾರ್ಯದಲ್ಲಿ ಆದರೆ ಇದು ಕಾರ್ಯ ಒಳಗೆ ಮಾತ್ರ ಗೋಚರ ಇಲ್ಲಿದೆ.
 ನಾನು ಹೌದು, ಉದಾಹರಣೆಗೆ, ಆದರೆ ಇಲ್ಲ. ಇದು ಆ ವಸ್ತುಗಳ ಒಂದು ಅಲ್ಲಿ
 ನೀವು, ನೀವು ಜಾಗತಿಕ ಯಾವ ಅಸ್ಥಿರ ನಿರ್ವಹಿಸಬಹುದು
 ಏನು ಅಸ್ಥಿರ ನೀವು ಸ್ಥಳೀಯ ಬಯಸುತ್ತೇನೆ, ಆದರೆ ನೀವು ಈ ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆ ಬೇಕು,
 ನೀವು ಸಿ ಮಾಡಲು ಸೂಕ್ಷ್ಮ ಧಾನ್ಯ ನಿಯಂತ್ರಣ ಮಾದರಿ ಹೊಂದಿಲ್ಲ ಏಕೆಂದರೆ,
 ಏನೋ ಲೂಪ್ ಒಂದು ಘೋಷಿಸಿದರು ಅದನ್ನು ಲೂಪ್ ಎಂದು ಉಳಿಯಲು ವಿಶೇಷವೇನು ಅಲ್ಲಿ.
 ನಾವು ನಿಜವಾಗಿ JavaScript ಬಳಸಿ ಕಾಳಜಿ ವಿಷಯ ಬಲ, ವೆಬ್ ಪುಟಗಳು ಕುಶಲಬಳಕೆಯ ಇದೆ?
 ನಾನು ಅರ್ಥ, ಎಂದು ಏಕೆ ನಾವು ಮಾಡುತ್ತಿರುವುದು ಇಲ್ಲಿದೆ.
 

ನಾವು DOM ಕರೆಯುವುದನ್ನು ಬಳಸಿ, ಹಾಗೆ.
 ಡಾಕ್ಯುಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಮಾಡೆಲ್.
 ಮೂಲತಃ, ಏನು ಅದು ಇದು ಎಲ್ಲಾ ನಿಮ್ಮ HTML ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
 ಮತ್ತು ಪರಸ್ಪರ ಟಾಪನ್ನು ವಸ್ತುಗಳ ಒಂದು ಗುಂಪೇ ಮಾದರಿಗಳು ಇದನ್ನು.
 ನೀವು ಈ ರೀತಿಯ ಔಟ್ ಆರಂಭಿಸಲು.
 ನೀವು ಅಲ್ಲಿಗೆ ಕೋಡ್ ಒಂದು ಗುಂಪೇ ಆ ರೀತಿಯ ಇಲ್ಲಿದೆ, ನನಗೆ ಬಲಭಾಗದಲ್ಲಿ, ಹೊಂದಿವೆ -
 ನೀವು ಕುಶಲತೆಯಿಂದ ಬಹಳ ಕಷ್ಟ ಬಯಸುವ ಯೋಚಿಸುವುದಿಲ್ಲ,
 ನೀವು ಪಠ್ಯ ಒಂದು ಗುಂಪನ್ನು ಮೂಲಕ ಪಾರ್ಸಿಂಗ್ ಎಂದೆನಿಸಿತ್ತು ಏಕೆಂದರೆ
 ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಪೀಸ್ ಹೊಂದಿರುವ. ಮತ್ತು ಅದು ಸರಿಯಾಗಿ ಏನು ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದರೆ?
 ಕೆಟ್ಟ ಕೆಲಸಗಳನ್ನು ಏನಾಗಬಹುದು.
 ಆದ್ದರಿಂದ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ಈ ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ, ಮತ್ತು ನೀವು ಒಂದು ಸಂತೋಷವನ್ನು ಡೇಟಾ ರಚನೆ ಪಡೆಯಲು
 ನೀವು ಕೇವಲ ಒಂದು ಡಾಕ್ಯುಮೆಂಟ್ ಅಲ್ಲಿ ನನ್ನ ಬಿಟ್ಟು ಒಂದು ರೀತಿಯ,
 ಮತ್ತು ಒಳಗೆ, HTML ಎಂಬ ಅಂಶವಿದೆ
 ಮತ್ತು ಒಳಗೆ ನೀವು, ಒಂದು ತಲೆ ಮತ್ತು ದೇಹದ
 ಮತ್ತು ತಲೆ ಒಳಗೆ ನೀವು, etcetera, etcetera etcetera ಒಂದು ಶೀರ್ಷಿಕೆ.
 ಇದು ಕೇವಲ ಇಲ್ಲಿದೆ ಆದ್ದರಿಂದ ಒಂದು ವೆಬ್ ಪುಟ ಕುಶಲಬಳಕೆಯ ಸುಲಭಗೊಳಿಸುತ್ತದೆ
 ಓಹ್, ನಾನು ಈ ವಸ್ತು ಮಾತನಾಡಲು ಬಯಸುವ.
 ನೀವು ನೀವೇ ಮಾಡಿದ ಇನ್ನೊಂದು ವಸ್ತುವಿನ ಮಾತನಾಡಿ ಎಂದು ತುಂಬಾ ಇದೇ ರೀತಿಯಲ್ಲಿ ವಿಂಗಡಿಸಿ.
 ನಾನು ಹೇಳಿದ ಹಾಗೆ, ಎಲ್ಲಾ DOM ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ಹೊಂದಿದೆ.
 ಒಂದೋ, ಇದು ಕೇವಲ ಒಂದು ಸ್ಥಳವಾಗಿದೆ ಮತ್ತು ನಂತರ ನೀವು ವಿಷಯಗಳನ್ನು ಹುಡುಕಲು ಇದು ಒಳಗೆ ಹೋಗಿ
 ಮತ್ತು ನೀವು ಮಾಡಬಹುದು - ಈ ಅಪ್, ಅದನ್ನು ಮಾಡುವ ಹಳೆಯ ಶೈಲಿ,
 ನೀವು document.getElementById ಎಂದು, ಮತ್ತು ಅಲ್ಲಿ ನಂತರ ಹೆಸರು,
 ನೀವು ಬಹುಶಃ ಹೇಳಬಹುದು ಎಂದು ಮತ್ತು, ಈ ಒಂದು ನಂತರ ಬಹಳ ಒಡ್ಡೊಡ್ಡಾದ ಪಡೆಯುತ್ತದೆ.
 ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಹಾಗೆ ಬಯಸುವುದಿಲ್ಲ. ನಾವು ಏಕೆ ಆ
 ನಾವು ಈ ನಂತರ ಬಗ್ಗೆ ನೀನು ಮುಂದೆ.
 ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯ, ಸರಿ, ನೀವು ಬಲ, ಈ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಹೊಂದಿವೆ?
 ಆದ್ದರಿಂದ ಬಹುಶಃ ನಾನು ಪುಟದ ಲೋಡ್ ಏನೋ ಬಣ್ಣವನ್ನು ಬದಲಾಯಿಸಬಹುದು.
 ಹಾಗಾಗಿ? ಏನು ನನ್ನ ಬಳಕೆದಾರ ಏನೋ ಕ್ಲಿಕ್ ವೇಳೆ?
 ನಾನು ಅವರು ಏನೋ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ಇದು ಕುತೂಹಲಕಾರಿ ಏನೋ ಮಾಡಲು ಬಯಸುವ.
 ನಾವು ಘಟನೆಗಳು ಏಕೆ ಆ. ನೀವು ಮೂಲತಃ, ನಿಮ್ಮ ಡಾಮ್ ಯಾವುದೇ ಅಂಶ ಕಾಣಬಹುದು,
 ತದನಂತರ ಹೇ, ಹೇಳುತ್ತಾರೆ. , ಈ ಲೋಡ್ ಅಥವಾ ಯಾರಾದರೂ ಅದನ್ನು ಒತ್ತಿದಾಗ
 ಅಥವಾ ಅವರು ಅದು ಮೇಲೆ ಮೌಸ್, ಅದನ್ನು ಏನಾದರೂ ಮಾಡಿದಾಗ.
 ಮತ್ತು ನೀವು ನೀವು ಈ ನಿರ್ವಹಿಸುವ ಕಾರ್ಯಗಳನ್ನು, ಆಗಿದೆ.
 ಈ ಕಾರ್ಯಗಳನ್ನು ಈವೆಂಟ್ ನಿರ್ವಹಣಾಕಾರರು ಇವೆ.
 ಏನು they're - ಇದು ಹೇಳುವ ಒಂದು ಅಲಂಕಾರಿಕ ಮಾರ್ಗವಾಗಿದೆ,
 ಈ ಘಟನೆ ಸಂಭವಿಸಿದರೂ ಈ ಕಾರ್ಯ ಕೇವಲ ಕಾರ್ಯರೂಪಕ್ಕೆ.
 ಆದ್ದರಿಂದ ಸಂಭವಿಸುವ ಘಟನೆಯನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.
 ನೀವು ಕ್ರಿಯೆಯನ್ನು ಹ್ಯಾಂಡ್ಲರ್ ಮೊಟ್ಟ ಹೇಗೆ ಹೊಂದಿದೆ.
 ನಾನು ಕೆಲವು ಬಟನ್ ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಸ್ಫೋಟಗೊಳ್ಳುತ್ತದೆ.
 ಆದ್ದರಿಂದ ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಬೇಡಿ.
 ಈ ಬಲ, ಇದು ಸಮೀಪಿಸುತ್ತಿರುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ?
 , ನೀವು ಬಟನ್ ಟ್ಯಾಗ್, ಮತ್ತು ಕ್ಲಿಕ್ ಮೇಲೆ ನೀವು ಹೇಳುವಂತೆ ಸ್ಟ್ರಿಂಗ್
 ಓಹ್, ಮೂಲಕ, ನನ್ನ ಈ ಸ್ಫೋಟದಿಂದಾಗಿ ವಿಷಯವನ್ನು.
 ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಕೇವಲ ನೀವು ಮಾಡಿದ ಸಾಮಾನ್ಯ ಬಟನ್ ಅನಿಸುತ್ತದೆ.
 ನೀವು ಈ ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು,
 ನಾವು jQuery ಬಗ್ಗೆ ಮಾತನಾಡಲು ನಂತರ DOM ಮತ್ತು ಅಂಶ ಧರಿಸುವುದನ್ನು, ಆದರೆ ಅದಕ್ಕೆ ನಾವು ಉಳಿಸುತ್ತೇವೆ.
 

JQuery: ಇದು ಅಡ್ಡ ಬ್ರೌಸರ್ ಒಂದು ಗ್ರಂಥಾಲಯವಾಗಿದೆ.
 ನೀವು ಅತ್ಯಧಿಕವಾಗಿ ಏನು ಬಳಸಬಹುದು.
 ಮತ್ತು ಇದು ಕೇವಲ ನೀವು ಕೆಲಸ ಉಪಕರಣಗಳು ಸಾಕಷ್ಟು ನೀಡುತ್ತದೆ.
 ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಪ್ರಬಲ ಆದರೆ, ನೀವು ಎಲ್ಲಾ ಉಪಕರಣಗಳು ಕಾರಣ
 ನಿಜವಾಗಿಯೂ ಒಂದು ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ನಿಭಾಯಿಸಲು ಬಾಕ್ಸ್ ಹೊರಗೆ ನೀವು ಬಯಸಬಹುದು.
 ಆದ್ದರಿಂದ, ವಸ್ತುಗಳ ಬಹಳಷ್ಟು ಸುಲಭಗೊಳಿಸುತ್ತದೆ ನೀವು ಕಾರ್ಯಗಳನ್ನು ಸಾಕಷ್ಟು ನೀಡುತ್ತದೆ
 ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತು ಮೇಲೆ, ನೀವೇ ಬರೆಯಲು ಹೊಂದಿಲ್ಲ ಎಂದು ಔಟ್ ಬಾಕ್ಸ್.
 ಮತ್ತು ಕೇವಲ ವಿಷಯಗಳನ್ನು ಸರಳ ಮಾಡುತ್ತದೆ.
 ನೀವು ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನೋಡೋಣ ಇದು ಆಯ್ಕೆದಾರರು ಹೊಂದಿವೆ
 ನಿಮ್ಮ DOM ಮತ್ತು ಹೆಚ್ಚು ನಿಂದ ಸರಳವಾಗಿ, ಬದಲಿಗೆ ಈ ಬಹಳ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಅನ್ನು ಹೊಂದುವ.
 ಈ ಆಯ್ಕೆದಾರರಿಗೆ ಇನ್ನಷ್ಟು. ನೀವು, ಹೇಳಿ ನೋಡೋಣ ಅಪ್ ಇಲ್ಲ, ಹೊಂದಿವೆ
 ನಾನು ID ಒಂದು ಅಂಶ ಸಿಗತ್ತೆ "ರಾಕ್."
 ಅಲ್ಲದೆ, jQuery ರಲ್ಲಿ, ಅದು ಕೇವಲ $ ಮತ್ತು ನಂತರ ಒಂದು ಪೌಂಡ್ ಎಂದು ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ನಂತರ "ರಾಕ್."
 ಇದು ಅತ್ಯಂತ ಸರಳ ಮತ್ತು ಈ ಸಮಸ್ಯೆ ಪರಿಹರಿಸುವಲ್ಲಿ ಸಾಂಪ್ರದಾಯಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೀತಿಯಲ್ಲಿ ವೇಗವಾಗಿ ಬಹಳಷ್ಟು ಇಲ್ಲಿದೆ.
 ಮತ್ತು ನೀವು ತರಗತಿಗಳು ಮತ್ತು ಅಂಶ ರೀತಿಯ ರೀತಿಯ ವಿಷಯಗಳನ್ನು.
 jQuery ಆಗಿದೆ - ತಂಪಾದ ವೈಶಿಷ್ಟ್ಯಗಳ ಒಂದು ನೀವು ರೀತಿಯ ಕುಗ್ಗಿಸುವಾಗ ಮಾಡಬಹುದು
 ನಿಮ್ಮ DOM ಮತ್ತು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೆಳಗೆ ತುಂಬಾ ವೇಗವಾಗಿ.
 ಈಗ ನಾವು ಮತ್ತೆ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಣೆ ಆರ್, ಮತ್ತು ಈ ನೀವು jQuery ರಲ್ಲಿ ಒಂದು ಘಟನೆ ನಿಭಾಯಿಸಲು ಹೇಗೆ ಆಗಿದೆ.
 ಆದ್ದರಿಂದ ಇಲ್ಲಿರುವುದು ನೀನು ನಾವು ಸರಿ, ಹೇಳುವ ಆಗಿದೆ. ನಾನು ಸ್ಕ್ರಿಪ್ಟ್ ಟ್ಯಾಗ್, ಬಲ?
 ಹಾಗಾಗಿ ಈ ಇನ್ಲೈನ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಿವೆ.
 ನಾವು ಮಾಡಲು ನೀನು ನಾವು ಸರಿ, ಹೇಳಲು ನೀನು ಆಗಿದೆ.
 ಡಾಕ್ಯುಮೆಂಟ್, ಡಾಕ್ಯುಮೆಂಟ್ ಲೋಡ್ ಮಾಡಲಾಗಿದೆ ಅಂದರೆ, ಸಿದ್ಧವಾದಾಗ
 , ನಾವು ಆ ಕಾರ್ಯಕ್ಕೆ ರಲ್ಲಿ ಹೋಗುತ್ತಿದ್ದೇವೆ, ಮತ್ತು ನಾವು, ಸರಿ ಹೇಳಲು ನೀನು
 ಈ ಕಾರ್ಯ ವಾಸ್ತವವಾಗಿ ಯಾವುದೋ ಮಾಡುತ್ತಿದ್ದಾರೆ.
 ಇದು ಮೂಲತಃ ಸರಿ, ನನಗೆ ID ಜೊತೆ ಅಂಶ ಪಡೆಯಲು, ಹೇಳುವ "myid."
 ತದನಂತರ ಈ ನೀವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ ನಿರ್ವಹಿಸುವ ಒಂದು ಕಾರ್ಯ ಹ್ಯಾಂಡ್ಲರ್ ನೀಡಿ.
 ಮೂಲತಃ ಈ ಏನು ಹೇಳುತ್ತಾರೆ, ಎಲ್ಲಾ ಸರಿ.
 , ಪುಟ ಲೋಡ್ ಇದೆ, ಆದ್ದರಿಂದ ನಾನು, ಈ ಅಂಶ ಹುಡುಕಲು ಪಡೆಯಲಿದ್ದೇನೆ
 ಇದು ಈ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ನೀಡಲು, ಮತ್ತು ಇದು ಮೂಲತಃ ನೀವು ನಿಮ್ಮ ಪುಟ ನಿಲ್ಲುತ್ತಾನೆ.
 ಮತ್ತು ಈ ನೀವು ಈವೆಂಟ್ ನಿರ್ವಹಣೆ ಬಗ್ಗೆ ಯೋಚನೆ ಮಾಡಲು ಹೇಗೆ.
 ನೀವು ಬಗ್ಗೆ ಯೋಚನೆ ಸರಿ, ಏನೋ ಸಂಭವಿಸುತ್ತದೆ, ನಾನು ಸಂಭವಿಸಿ ಏನು ಬಯಸುತ್ತೀರಿ ಬಯಸುವ?
 ನೀವು, ಸರಿ, ನಾನು ಈ ವಿಷಯ ಖಚಿತವಾಗಿ ಈ ವಿಷಯ ಮಾತುಕತೆ ಅಗತ್ಯವಿದೆ, ಬಗ್ಗೆ ಯೋಚನೆ ಬಯಸುವುದಿಲ್ಲ
 ಈ ವಿಷಯ blah blah blah, ನೀವು ಕೇವಲ ಘಟನೆಗಳ ಅರ್ಥದಲ್ಲಿ ವಿಷಯ ಮಾತನಾಡಲು ಬಯಸುವ ಏಕೆಂದರೆ.
 ಇದು ಸಂಭವಿಸಿದಾಗ, ಈ ಸಂಭವಿಸುತ್ತದೆ. ಇದು ಸಂಭವಿಸಿದಾಗ, ಎಂದು ಸಂಭವಿಸುತ್ತದೆ.
 ವಿಷಯಗಳನ್ನು ಇತರ ವಿಷಯಗಳ ಪ್ರಚೋದಿಸುತ್ತದೆ ಮತ್ತು, ಅಭಿನಂದನೆಗಳು.
 ಆದರೆ ನೀವು ಸಂಕೀರ್ಣ ಕೋಡ್ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ
 ಅಲ್ಲಿ ನೀವು, ಅದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ವಿಷಯಗಳನ್ನು ಪ್ರಚೋದಿಸಿ ಮಾಡುತ್ತಿದ್ದೇವೆ
 ನೀವು ನಿಮ್ಮ ಒಂದು ತಲೆನೋವು ನೀಡಲು ನೀನು ಏಕೆಂದರೆ.
 

ಸರಿ. ಈಗ ನಾವು ನಮ್ಮ ಪುಟ ಘಟನೆಗಳು ನಿರ್ವಹಿಸಲು ಪಡೆಯುವುದು,
 ಆದರೆ ನನ್ನ ಬಳಕೆದಾರರಿಗೆ ಒಂದು ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್ ಹೇಳಲು ಅವಕಾಶ.
 ಏನು, ನಾನು ಮತ್ತೆ ಪರಿಚಾರಕಕ್ಕೆ ಮನವಿ ಕಳುಹಿಸಲು ಬಯಸಿದರೆ
 ಹೊಸ ಪುಟ ರಿಲೋಡ್ ಹೊಂದಿರುವ ಕಾರಣ ನಾನು, ಪುಟ ರಿಲೋಡ್ ಬಯಸುವುದಿಲ್ಲ
 ಪ್ರತಿಯೊಂದು ಬಾರಿ ಬೇಸರದ ರೀತಿಯ ಪಡೆಯುತ್ತದೆ, ಮತ್ತು ಏಕೆ ಬೇಕು
 ಮತ್ತೆ ಹೆಡರ್ ಕೆಳಗೆ ಎಳೆಯಿರಿ, ಮತ್ತು ಮತ್ತೆ ಅಡಿಟಿಪ್ಪಣಿ,
 ಮತ್ತು ಎಲ್ಲಾ ಪುಟ ಅಂಶಗಳನ್ನು ಮತ್ತೆ
 ಕೇವಲ ಶುಭಾಶಯ ಅಥವಾ ಸಮಯ ರಿಫ್ರೆಶ್?
 ನಾವು ಅಜಾಕ್ಸ್ ರೀತಿಯ ಏಕೆ ಆ ನ.
 ನಾವು ಅಜಾಕ್ಸ್ ಇಲ್ಲಿ ಮಾಡಬಹುದು, ನಾವು, ಸರಿ ಹೇಳಬಹುದು
 ನಾನು ಸರ್ವರ್ ಕೆಲವು ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ಬಯಸುವ,
 ಮತ್ತು ನಾನು ನನ್ನ ಪುಟ ನವೀಕರಿಸಬಹುದು ಮತ್ತೆ ಪ್ರತಿಕ್ರಿಯೆ ಸಿಗತ್ತೆ,
 ಅಥವಾ ಬಹುಶಃ ಕೇವಲ ಅಗತ್ಯವಾಗಿ ಬಳಕೆದಾರರು ಏನು ತೋರಿಸುವುದಿಲ್ಲ ಕೆಲವು ಕ್ರಮಾವಳಿಯ ಲೆಕ್ಕ.
 ನೀವು ಈ ಏನು ಬರೆಯಬೇಕು? ಸರಿ, ನೀವು ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ ಒಂದು URL ಬೇಕಾಗುತ್ತದೆ.
 ನಿಮ್ಮ ಪರಿಚಾರಕವು ಮಾಂತ್ರಿಕವಾಗಿ ಎಲ್ಲಿಯೂ ಕೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ.
 ನೀವು ಈ ಡೇಟಾವನ್ನು ಕಳುಹಿಸಲು ನೀವು ನಿರ್ದಿಷ್ಟ ಸ್ಥಳದಲ್ಲಿ ಮಾಡಬೇಕು.
 ಮತ್ತು ನೀವು ಕಳುಹಿಸಲು ಕೆಲವು ಡೇಟಾವನ್ನು ಅಗತ್ಯವಿದೆ, ಅಥವಾ ಬಹುಶಃ ಇದು ಒಂದು dataless ಪ್ರಶ್ನೆಗೆ ಇಲ್ಲಿದೆ.
 ನೀವು ಹೇ, ನಾನು ಜೀವಂತವಾಗಿ, ಅಥವಾ ಸ್ವಲ್ಪ ಮನುಷ್ಯ, ಮತ್ತೆ ಪರಿಚಾರಕಕ್ಕೆ ಪಿಂಗ್ ಮತ್ತು ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ.
 ತದನಂತರ ನೀವು ಮೂಲತಃ ಯಶಸ್ಸನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ ಕಾರ್ಯ ಬಯಸುವ.
 ನ ನಿಮ್ಮ ಪರಿಚಾರಕದಿಂದ ಕೆಲವು ಮಾಹಿತಿ ಪಡೆಯಲು ಮತ್ತೆ ಹೇಳುತ್ತಾರೆ,
 ಮತ್ತು ನೀವು ತಮ್ಮ ಪುಟ ಬಳಕೆದಾರರ ಶೀರ್ಷಿಕೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ.
 ಆದ್ದರಿಂದ ನೀವು ಮಾಹಿತಿ ಹಿಂದಕ್ಕೆ ಪಡೆಯಲು ಎಂದು,
 ಮತ್ತು ನೀವು ತೆರೆಗೆ ಎಂದು ತಳ್ಳಲು.
 ಪುಟ ಸಿದ್ಧವಾಗಿದೆ ಏನಾಗುತ್ತದೆ, ಆಗಿದೆ
 ನೀವು greeter ಎಂಬ ಈ ಬಟನ್ ಕ್ಲಿಕ್ ಕಾರ್ಯದ ಒಂದು ರಚಿಸಲು. ಎಂದು ಬಟನ್ ತಳ್ಳಲಾಗುತ್ತದೆ ಏನು ಈ ನಂತರ ಮಾಡುತ್ತದೆ, ಆಗಿದೆ,
 ನೀವು greetings.php ಮಾತನಾಡಲು, ನೀವು, ಒಂದು ವಸತಿ ವಿನಂತಿಯನ್ನು ಮಾಡಲು
 ಮತ್ತು ನೀವು ಹೇ, ನನಗೆ ನಿಮ್ಮ ಪುಟ ಏನನ್ನೋ ಪಡೆಯಲು, ಹೇಳುತ್ತಾರೆ.
 ನಾವು ನಿಜವಾಗಿಯೂ, ಎಂದು ವಿವರಿಸಲು ಅಗತ್ಯವಿದೆ, ಆದರೆ greetings.php ಇಲ್ಲ
 ಕೇವಲ ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ, "ಹಲೋ ವರ್ಲ್ಡ್." ಮತ್ತೆ ನೀಡುತ್ತದೆ
 ನಾವು, "ಹಲೋ ವರ್ಲ್ಡ್" ಈ ಹಿಂದೆ ಮತ್ತು ಈ ಯಶಸ್ಸು
 ಏನೂ ತಪ್ಪು ಹೋಗುತ್ತದೆ ಊಹಿಸಿಕೊಂಡು, ನಂತರ ನಾವು ಈ ಗುರಿ ಸ್ಥಳಕ್ಕೆ ಹೋಗಿ
 ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮತ್ತು ನಾವು ಅಲ್ಲಿ ಪ್ರತಿಕ್ರಿಯೆಯ ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ.
 ಮತ್ತು ಈ ಒಂದು ಅಜಾಕ್ಸ್ ಪ್ರಶ್ನೆಗೆ ಸ್ಥಾಪನೆಗೆ ಒಂದು ಸರಳ ಮಾರ್ಗವಾಗಿದೆ.
 

ಬೇಗನೆ, ರಾಬ್ ರೀತಿಯ, ಈಗಾಗಲೇ ಈ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ
 ಸಂಗತಿಗಳು ತಪ್ಪು ಹೋಗಬಹುದು, ಕೆಟ್ಟ ಕೆಲಸಗಳನ್ನು ಸಂಭವಿಸಬಹುದು,
 ಆದ್ದರಿಂದ ನೀವು ಈ HTTP ಪ್ರತಿಕ್ರಿಯೆ ಸಂಕೇತಗಳು ನಿಮಗಾಗಿ ಪರಿಚಯ ಬಯಸುವ.
 ಏನು ಈ ಎಲ್ಲವೂ ಸರಿ ಹೋದರು, 200, ಹಾಗೆ, ಅವು.
 ಯಾವುದೋ, ಕೆಟ್ಟ ಸಂಗತಿಗಳು ಸಂಭವಿಸಿದ.
 ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ನೆನಪಿಡುವ ಬಯಸುವ ವಿಷಯ.
 ಆದರೆ ಈ ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಇಲ್ಲಿದೆ.
 ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನಾವು ಎಲ್ಲಾ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ,
 ನಾವು, ವಿನ್ಯಾಸ ಬಗ್ಗೆ ಬೇಗನೆ ಮಾತನಾಡಲು ಅಗತ್ಯವಿದೆ
 ನಂತರ ನಾವು ನೀವು ಎಲ್ಲಾ ಬಿಟ್ಟು ಅವಕಾಶ ಮಾಡಬಹುದು.
 ಡಿಸೈನ್. ನೀವು ನೆನಪಿಡುವ ಬಯಸುವ ವಿಷಯಗಳನ್ನು.
 ಈ ಪ್ರಶ್ನೆಗಳಿಗೆ ನೀವೇ ಕೇಳಿ: ಯಾರು ಈ ಬಳಸಿಕೊಂಡು ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ?
 ಅವರು ಅದನ್ನು ಬಳಸಿ ಮಾಡಲಾಗುತ್ತದೆ? ನನ್ನ ಬಳಕೆದಾರರು ಏನು ಬಗ್ಗೆ ಕಾಳಜಿ ಇಲ್ಲ?
 ಅವರು ಏನು ಕಾಳಜಿ ಇಲ್ಲ?
 ನೀವು ಕೇವಲ ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಮಾಡಲು ಮತ್ತು ಇದು ಬೆಳೆಯಲು ಅವಕಾಶ ಬಯಸುವುದಿಲ್ಲ
 ಮತ್ತು ಈ ದೈತ್ಯ, ನೀವು ಸಹ ಮುಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ಎಲ್ಲಾ ತೆಗೆದುಕೊಳ್ಳುವ ವಿಷಯ ಆಗಲು.
 ನೀವು ವಿಳಾಸ ಬಯಸುವ ಪ್ರತ್ಯೇಕವಾದ ಗುರಿಗಳನ್ನು ಮತ್ತು ಯೋಜನೆಗಳನ್ನು ಮತ್ತು ವಿಷಯಗಳನ್ನು ಬೇಕು.
 ಇದು ಪ್ರಯತ್ನವಿಲ್ಲದ ಮಾಡಿ. ಈ ಎಲ್ಲಾ, ಮೂಲತಃ ಹೇಳುತ್ತಾರೆ
 ಸುಲಭವಾಗಿ ಬಳಕೆದಾರ ಬಳಸಲು ಮಾಡಲು; ವಾಸ್ತವವಾಗಿ, ಇದು ಈ ಸ್ಲೈಡ್ ರೀತಿ ಪಠ್ಯದ ಒಂದು ದೈತ್ಯ ಆಕೃತಿಯಿಂದ ಆಗಿದೆ ಮಾಡುವುದಿಲ್ಲ.
 ನೀವು ಅದನ್ನು ಯಾರಾದರೂ ಹೋಗಿ ತುಂಬಾ ಸುಲಭ ಅಲ್ಲಿ ಏನೋ ಬಯಸುತ್ತೇನೆ
 ಮತ್ತು ಅವರು ಮಾಡಲು ಬಯಸುವ ಏನು.
 ನೀವು ಅವುಗಳನ್ನು 5 ಪುಟಗಳು ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಬಯಸುವುದಿಲ್ಲ
 ನಿಮ್ಮ ಸೈಟ್ ನಿಮ್ಮ ಅವಿಭಾಜ್ಯ ಕಾರ್ಯ ಪಡೆಯಲು.
 ಗೂಗಲ್ ಮೊದಲು 5 ಪುಟಗಳಷ್ಟು ನೀವು ಏನೋ ಹುಡುಕಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ,
 ಯಾರೂ ಅದನ್ನು ಬಳಸಬಹುದು.
 ಮತ್ತು ಕೊನೆಯದಾಗಿ, ಕಾಗದದ ಮಾದರಿ, ಕೇಂದ್ರೀಕೃತ ಸಮೂಹ.
 ಉತ್ತಮ ವಿನ್ಯಾಸ ಮತ್ತು ಪರೀಕ್ಷಾ ಪರಿಪಾಠಗಳನ್ನು ಹ್ಯಾವ್.
 ನೀವು ನೀವು ಕೆಲಸ ಭಾವಿಸುತ್ತೇನೆ ಕಾರಣ
 ಬೇರೆ ಯಾರಾದರೂ ಇದನ್ನು ಕೆಲಸ ಯೋಚಿಸುತ್ತಾನೆ ಅರ್ಥವಲ್ಲ.
 ಆದರೆ ಹೌದು, ಅದು ಇಲ್ಲಿದೆ.
 [CS50.TV]