ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕುಣಿಕೆಗಳು: ಸಂದರ್ಭದಲ್ಲಿ, ಏನು-ಸಂದರ್ಭದಲ್ಲಿ, ಫಾರ್

ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ವಾಕ್ಯ ರಚನೆಯ ಇತಿಹಾಸ ಬ್ರಹ್ಮಾಂಡದ ಜ್ಞಾನ ಪ್ರಕ್ರಿಯೆ ಹೋಲುತ್ತದೆ. ಮತ್ತು ಇದು ಆರಂಭದಲ್ಲಿ ಎಂದು ... ಆದರೆ ಈಗ ಎಲ್ಲವೂ ಸರಳ ಮತ್ತು ಒಳ್ಳೆ ಇದು.

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

ಬ್ರೌಸರ್: ಡಾಮ್, ಅವನ ಭಾಷೆ + ಸರ್ವರ್

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

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

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

ವಾಸ್ತವವಾಗಿ ಲೂಪ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಾಕ್ಯ ಅತ್ಯಂತ ಅಭಿವರ್ಧಕರು ಪ್ರಮಾಣಕ ವಿನ್ಯಾಸ ತಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಪೂರಕವಾಗಿ ಇರುತ್ತವೆ.

ಬಾಹ್ಯಾಕಾಶದಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಸ್ಥಾನವನ್ನು

ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮರ್ ಸಹ ಆತನು ಅದರ ಯೋಚಿಸುವುದಿಲ್ಲ (ಒಂದು ಸೈಕಲ್ , ಎನಿಸಿಕೊಳ್ಳುತ್ತದೆ ಸಂದರ್ಭದಲ್ಲಿ, ...) - ಕೊನೆಯಲ್ಲಿ ಆವರ್ತಗಳ ಸರಣಿ (ಚಕ್ರಗಳು) ಪ್ರೊಸೆಸರ್, ಅವಳಿ ಕಾರ್ಯಾಚರಣೆಗಳ ಒಂದು ಸರಳ ಅನುಕ್ರಮ, ಅಡಚಣೆಯಾಗುತ್ತದೆ ಚೆಕ್ಔಟ್ ಕೌಂಟರ್, ಅಂದರೆ ಪರಿಸ್ಥಿತಿಗಳು.

ಉದಾಹರಣೆಗೆ, ಸೈಕಲ್ ಯಂತ್ರಭಾಷೆ ಮಟ್ಟದಲ್ಲಿ ಅಲ್ಲ: ಸಾಮಾನ್ಯ ಆದೇಶಗಳು, ಷರತ್ತುಬದ್ಧ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಪರಿವರ್ತನೆಗಳು ಸಂಯೋಜನೆ. ಎಂಬುದನ್ನು ಸಾಧನವಾಗಿ ಬ್ರೌಸರ್ ಮತ್ತು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅಭಿವೃದ್ಧಿಗೆ ಬಳಸಬಹುದು ಯಾವುದೇ, ಮುಂದಿನ ಹಂತಕ್ಕೆ ಚಕ್ರಗಳನ್ನು ಅನನ್ಯವಾಗಿರುತ್ತದೆ. ಮತ್ತು "ಕೋಡ್ ತುಣುಕುಗಳನ್ನು" ಬೇರೆ ಬೇರೆ ಪ್ರೋಗ್ರಾಮರ್ಸ್ ಬೇರೆ ಬೇರೆ ಹಂತಗಳಲ್ಲಿ ಪರಿಚಯಿಸುವ. ಮೇಲಿನ ಮಹಡಿ "ನಿರ್ಮಿಸುತ್ತಿದೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್». ವಾಕ್ಯ ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚಕ್ರಗಳನ್ನು ನೀಡುತ್ತದೆ ಆಫ್.

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

ವಸ್ತುನಿಷ್ಠ ಆಧಾರದ

ಸೈಕಲ್ ಪರಿಸ್ಥಿತಿಯ ಅಥವಾ ಪ್ರತಿ ಕೇವಲ ಎರಡು ರೂಪಾಂತರಗಳು, ಆದರೆ ವಾಸ್ತವದಲ್ಲಿ ಯಾವುದೇ ಸೈಕಲ್ (ಅತ್ಯಂತ ಕೆಳಮಟ್ಟದಲ್ಲಿ) - ಕೇವಲ ಕಲ್ಪನೆ ಮೂಲಕ. ಕೆಲವು ಭಾಷೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯ ಚಕ್ರದಲ್ಲಿ "ಪ್ರತಿಯೊಂದು." ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆವರ್ತಗಳ foreach ರಚನೆಯ ವಸ್ತು ಪ್ರಾಪ್ ನಿರೂಪಿಸಲಾಗಿದೆ, ಆದರೆ ಇದು ಒಂದು ಭಿನ್ನ array.forEach (...) ಬಳಸಲು ಸಾಧ್ಯ.

ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ಆಯ್ಕೆಗಳು: ವ್ಯಾಖ್ಯಾನಿಸುವ ಭಾಷೆಗಳ ಸಹ ಬರೆಯುವ ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕ್ರಮಾವಳಿಗಳು ಕೊನೆಯಲ್ಲಿ ನಿರ್ವಹಿಸುವ ಯಂತ್ರದ ಕೋಡ್, ಯಾವುದೇ ಆಜ್ಞೆಯನ್ನು ಸರಣಿ ಪುನರಾವರ್ತಿತ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿರುತ್ತಾನೆ: ಅವನು ಪುನಃ ನಿರ್ವಹಿಸಲು ಏನಾದರೂ ಮಾಡಬಹುದು:

• ಕೌಂಟರ್ ಎಣಿಕೆಗಳು;
• ರವರೆಗೆ ಸ್ಥಿತಿಯನ್ನು ಭೇಟಿ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ - ಒಂದು ವಿಶಿಷ್ಟ ನಿರೂಪಕ. ಇದರ ವಿಶಿಷ್ಟವಾದ: ಒಳಗೆ ಬ್ರೌಸರ್ ಉದ್ದೇಶದ ಬಳಸುತ್ತದೆ ಮತ್ತು ಬ್ರೌಸರ್ನಲ್ಲಿ ಪುಟ ಲೋಡ್ ಕ್ಲೈಂಟ್ ಬದಿಯಲ್ಲಿ ಕ್ರಮಾವಳಿಗಳು ನಿರ್ವಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಮತ್ತು ತನ್ನ ಕೆಲಸವನ್ನು ಹಾದಿಯಲ್ಲಿ ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಪ್ರತಿಯೊಂದು ಸರಳ ಸೈಕಲ್

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ foreach ರಂದು ಕುಣಿಕೆಗಳು ರಚನೆಯ ಕಾರ್ಯಗಳ ಬಳಕೆಯಿಂದ ರೀತಿ:

ಇಂತಹ ಚಕ್ರಗಳನ್ನು ಬಳಕೆ ತೊಂದರೆಗಳನ್ನು ಉಂಟು ಮಾಡುವುದಿಲ್ಲ. ತಾಂತ್ರಿಕವಾಗಿ ಸೈಕಲ್ ಯಾವುದೇ ಇಲ್ಲ. ರಚನೆಯ ಅಂಶಗಳನ್ನು ಒಂದು ಸ್ಥಿರವಾದ ಚಿಕಿತ್ಸೆ ಕಾರ್ಯ ನಡೆಯುತ್ತಿದೆ.

ಔಷಧವು ಸೈಕಲ್

ಇನ್ನಷ್ಟು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಚಕ್ರಗಳನ್ನು ನೋಡಲು ಒಗ್ಗಿಕೊಂಡಿರಲಿಲ್ಲವಾದ್ದರಿಂದ:

ಇಲ್ಲಿ, ಕೌಂಟರ್ ಇದರ ಮೌಲ್ಯವು ಬದಲಾಗುತ್ತದೆ ಸೂತ್ರ ಮತ್ತು ಚಿಹ್ನೆಗೆ ತಕ್ಕಂತೆ ಸೈಕಲ್ ಪರಿಸ್ಥಿತಿಯ ಅಂತ್ಯ ವೇರಿಯಬಲ್ ನಿರ್ವಹಿಸುತ್ತದೆ. ಅಗತ್ಯವಾಗಿ ಸೂತ್ರದ ಮತ್ತು ಸ್ಥಿತಿಯನ್ನು ವೇರಿಯಬಲ್ ಸೈಕಲ್ ಒಳಗೊಂಡಿದೆ. ಆದರೆ ಚಕ್ರದಲ್ಲಿ ಕೊನೆಯಲ್ಲಿ ಬಿಂದುವಿನ ನಿಯಂತ್ರಣ ಸಂಪೂರ್ಣವಾಗಿ ತಮ್ಮ ವಿಷಯವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಷರತ್ತುಬದ್ಧ ಕುಣಿಕೆಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ನೀವು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಬೇಕು ಯಾವಾಗ ಅವಲಂಬಿಸಿ, ನೀಡುತ್ತದೆ ಆದರೆ ಜೊತೆ ಆಯ್ಕೆ. ಲೂಪ್ ದೇಹದ ಸಹ ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಅಲ್ಲ - ಈ ಒಂದು, ದೇಹದ, ಒಮ್ಮೆಲೇ ನಡೆಸಬೇಕು, ಇದು ಬೇರೆ ವಿಷಯ:

ಮೊದಲ ಪ್ರಕರಣದಲ್ಲಿ, ವಿನ್ಯಾಸ ಮಾಡುವಾಗ ವ್ಯಾಖ್ಯಾನಿಸುವ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮೊದಲ ಪರಿಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ಇದು ನಿಜವಾದ ವೇಳೆ, ಲೂಪ್ ಕಾರ್ಯರೂಪಕ್ಕೆ. ಎರಡನೇ ಸಂದರ್ಭದಲ್ಲಿ ಸೈಕಲ್ ಮೊದಲ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಒದಗಿಸಿದ ರಚನೆಗಳು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಅಸ್ಥಿರ ಪರಿಣಾಮವಾಗಿ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಿದರೆ, ಇದು ಒಂದು ತಪ್ಪು ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಲೂಪ್ ನಿಲ್ಲುತ್ತದೆ.

ಸರಳ ಕ್ರಮಾವಳಿಗಳ ಬೃಹತ್ ಸಂಯೋಜನೆಗಳನ್ನು

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

ಈ ಸರಳ ಸಿದ್ಧಾಂತ ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳಿಗೆ ಸಂಜೀವಿನಿಯಲ್ಲ ಆಫ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯನ್ನು ರೀತಿಯ ಪ್ರತಿ ಒಂದು ಲೂಪ್ ಮಾಡಿದ. ಆಧುನಿಕ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ವಿವಿಧ ವೇಗ. ಬ್ರೌಸರ್ ಸಾಕಷ್ಟು ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಟೈಮ್, ಯಾವುದೇ ಹಸಿವಿನಲ್ಲಿ ಇಲ್ಲ. ಇದು ಏನೋ ಏನನ್ನಾದರೂ ಔಟ್ ವಿಂಗಡಿಸಲು ಸುಲಭ. ಪರಿಣಾಮವಾಗಿ, ಜೆ avaScript ಕುಣಿಕೆಗಳು ಬಹಳ ಜನಪ್ರಿಯವಾಗುತ್ತಿವೆ.

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

ಕಾರ್ಯವಿಧಾನ, ವಾಸ್ತವತೆಯ ಇನ್ನೊಂದು ಪ್ರಾತಿನಿಧ್ಯ

однотипного кода можно представить функциями - алгоритм сразу преобразится, основное тело скрипта уменьшится в размере, все станет читаемым и понятным. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್-ಚಕ್ರಗಳನ್ನು ಬಳಸಿ, ಕೋಡ್ ಅದೇ ಮಾದರಿಯ ಕಾರ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಬಹುದು - ಅಲ್ಗಾರಿದಮ್ ಒಮ್ಮೆ ರೂಪಾಂತರಗೊಳ್ಳುತ್ತದೆ, ಗಾತ್ರ ಕಡಿಮೆ ಲಿಪಿಯ ಮುಖ್ಯ, ಎಲ್ಲಾ ಓದಬಲ್ಲ ಮತ್ತು ಅರ್ಥವಾಗುವ ಎಂದು.

ಈ ಒಂದು ಅಮೂಲಾಗ್ರವಾದ ಹೊಸ ಪರಿಹಾರ ಅಲ್ಲ, ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಇದು ಇತರ ಭಾಷಾ ರಚನೆಯ ವ್ಯಾಪ್ತಿ ಮೀರಿ ಅಲ್ಲ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಜೆ avaScript ಚಕ್ರಗಳನ್ನು ಶಾಸ್ತ್ರೀಯ ಒಡಕು () ಕಾರ್ಯ ಕಾಣಬಹುದು:

cResult = '9,8,7,6,5,4' ; ವರ್ cResult = '9,8,7,6,5,4';
aResult = cResult . ವರ್ aResult = cResult. ( ',' ); ಒಡಕು ( ',');

ಯಾವುದೇ ಆವರ್ತನವು, ಇಲ್ಲದಿದ್ದರೆ ವೇಳೆ ಸಂಕೇತವಾಗಲ್ಲದಿದ್ದರೆ '' ಹುಡುಕುತ್ತಿರುವ ಮತ್ತು ಇನ್ನೊಂದು ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಬಳಸಲು ಮೂಲಕ ಈ ಕಾರ್ಯ ನಿರ್ವಹಿಸಿದ.

ಹೆಚ್ಚು ಅನುಕೂಲಕರ - ಇದು ಒಡಕು () ಕಾರ್ಯ ಒಳಗೆ ಅಳವಡಿಸಲಾಗಿದೆ ಹೇಗೆ ಬೇರ್ಪಡಿಸುವ ಬಳಕೆಯ ನಿಯಮಗಳು ಆವರ್ತಗಳ ಬಳಸಿ ಅದರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯವನ್ನು ಪೂರಕವಾದ ಮಾಡಬಹುದು. ಇದು ಈ ವಿಧಾನವು ಪ್ರತಿಯೊಂದು ಕ್ರಿಯಾತ್ಮಕ ಉದ್ದೇಶಗಳನ್ನು ಕ್ರಮವಾಗಿ ಅಭಿವೃದ್ಧಿ ಹೊಂದುತ್ತದೆ ಮುಖ್ಯ, ಆದರೆ ಒಟ್ಟು ಇನ್ನೂ ಈ ವಿಧಾನದಲ್ಲಿ ಎಂದು.

ಈ ಕಾರ್ಯಗಳು allt (), padc (), padl () ಮತ್ತು padr () - ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಏನು ಇಲ್ಲ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ಆದರೆ ಅದನ್ನು ಸರಿಯಾಗಿ ಅಥವಾ ಎರಡೂ, ಎಡಕ್ಕೆ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ align ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಸ್ಥಳಗಳಿಂದ ತೆಗೆದುಹಾಕಿ ಕೆಲವೊಮ್ಮೆ ಅನಿವಾರ್ಯವಾಗಿ ಅಲ್ಲ. ದೇಹದ ಈ ಕ್ರಿಯೆಗಳನ್ನು - ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್-ಚಕ್ರಗಳನ್ನು. ಸರಳ, ಸುಲಭವಾಗಿ ಮತ್ತು ಅದು ಬಳಸಿದ ಅಲ್ಗಾರಿದಮ್ ಸ್ಥಗಿತಗೊಳ್ಳಲು ಎಂದಿಗೂ.

16-ದ 10 ನೇ ಲೆಕ್ಕ ಮತ್ತು ಮತ್ತೆ ವ್ಯವಸ್ಥೆಯ ಹ್ಯಾಟ್ಸ್ ಸಂಖ್ಯೆಯ ಪರಿವರ್ತನೆ ಕಾರ್ಯಗಳನ್ನು, ಇದು ಒಂದು ಮಾಡಬೇಡಿ ಚಕ್ರಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಇಲ್ಲಿ ರೂಪುಗೊಂಡ ಮತ್ತೊಂದು ರೂಪದಲ್ಲಿ ದತ್ತಾಂಶವನ್ನು ಹೇಳಲು ಸುಲಭ. ಅತ್ಯಂತ ಕಾಂಪ್ಯಾಕ್ಟ್ ಮತ್ತು ದಕ್ಷ ವಾಕ್ಯ.

ಸರಿಯಾದ ಚಕ್ರಗಳನ್ನು - ರಿಯಾಲಿಟಿ ಪ್ರಾತಿನಿಧ್ಯ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ - ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಮತ್ತು ಆವೃತ್ತಿಗಳು ವಿವಿಧ ವಿವಿಧ ಇಷ್ಟ, ಮತ್ತು ಅತ್ಯಂತ ಮುಖ್ಯವಾಗಿ, ವಾಕ್ಯ ಬದಲಾಯಿಸಲು, ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಅದನ್ನು ವಿಸ್ತರಿಸಲು ಹೇರಿಲ್ಲ ಅಲ್ಲ.

ಪ್ರೋಗ್ರಾಮರ್ ಜೆಎಸ್ ಬಳಸಿಕೊಂಡು ಆಲೋಚನೆ PHP ಪ್ರೋಗ್ರಾಮರ್ ಚಿಂತನೆ ಭಿನ್ನವಾಗಿದೆ (ನಿರ್ದಿಷ್ಟವಾಗಿ ಮತ್ತು ಒಟ್ಟು ಇತರ ಭಾಷೆಗಳು ಚೆನ್ನಾಗಿ, "ಪ್ರೊಲಾಗ್" ಮತ್ತು ಅವರ ಅನುಯಾಯಿಗಳು ಹೊರತುಪಡಿಸಿ ಸಾರ್ವತ್ರಿಕ ದಿಕ್ಕಿನಲ್ಲಿ ಸೇರ್ಪಡೆಗೊಳ್ಳದಿರುವ), ಅಲ್ಗಾರಿದಮ್ ಚರಾಂಕಗಳ ಸಾಲುಗಳು, ಹುದ್ದೆ ನಿರ್ವಾಹಕರು ಸೈಕ್ಲಿಕ್ ರಚನೆಗಳು ಸೀಮಿತವಾಗಿಲ್ಲ ಮಾಡಿದಾಗ .

ಪ್ರೋಗ್ರಾಂ ಮಾಹಿತಿಯನ್ನು ಆಕಾಶದಲ್ಲಿ ಒಂದು ಬಿಂದುವಿನ ಅಥವಾ ಅಂಕಗಳನ್ನು ವ್ಯವಸ್ಥೆಯ ಇವು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಡೇಟಾ ಆಗಿರುತ್ತದೆ ಸೂಚಿಸುತ್ತವೆ - ನಾವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಯಾವುದೇ ಚಕ್ರಗಳನ್ನು ಇವೆ ಕಲ್ಪನೆ, ಮತ್ತು ಇದು ಸುಲಭ ಆಯ್ಕೆಯು (ವಿವೇಚನೆಯಿಲ್ಲದ), ಅಗತ್ಯ. ಬುದನ್ನು ಮತ್ತು ಅಂಕಗಳನ್ನು ವ್ಯವಸ್ಥೆ - ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ವಿಷಯದ ಪ್ರದೇಶವಾಗಿದೆ. ಪ್ರೋಗ್ರಾಮರ್, ಈ ಪ್ರಬಂಧ ಅರ್ಥ: ಒಂದು ಸರಳ, ಈ ಸರಳ ದತ್ತಾಂಶದ ಗುಂಪಾಗಿದೆ. ಸ್ವಾಭಾವಿಕವಾಗಿ, ವ್ಯವಸ್ಥೆಯ ಕೆಳಗಿನ ಮಟ್ಟದಲ್ಲಿ ಈ ಸರಳ ಒಂದು ಮಟ್ಟದ ಇರುತ್ತದೆ, ಆದರೆ ಉನ್ನತ ಮಟ್ಟದ - ಪಾಯಿಂಟ್.

ಈ ವಿಧಾನ, ಆರೈಕೆಯ ಹಂತದಲ್ಲಿ - ತಮ್ಮ ವಿಧಾನಗಳ ಮೂಲಕ ತಮ್ಮ ಗುರುತನ್ನು ತೋರಿಸಲು. ತನ್ನ ಅಂಕಗಳನ್ನು ಸೇರಿದ ಘಟಕಗಳು ಸಂಯೋಜನೆಯನ್ನು ಅದರ ಮೂಲಭೂತವಾಗಿ ತೋರಿಸಲು - ಸೂಪರ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಪಾಯಿಂಟ್, ವ್ಯವಸ್ಥೆಯ ಕಾರ್ಯ ಯಾವಾಗ.

ಈ ವಿಧಾನವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳ ಕಲ್ಪನೆಯನ್ನು ಪುರಾತನವಾದದ್ದು, ಆದರೆ ಇನ್ನೂ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ತನ್ನ ಸಾಕಷ್ಟು ಪ್ರತಿಬಿಂಬ ಪಡೆದುಕೊಳ್ಳಲಿಲ್ಲ. ಅನೇಕ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಸರಿಯಾಗಿ ಭಾವಿಸುತ್ತೇನೆ, ಆದರೆ ತಮ್ಮ ಪಂದ್ಯದ ಬಯಸಿದ ಎಂದು ಬಿಟ್ಟು.

ಇದು ವಿಶ್ವದ ನೋಡಲು ತನ್ನ ಕಣ್ಣನ್ನು ಬ್ಯಾಂಡೇಜ್ ಧರಿಸಲು ಕೆಲವೊಮ್ಮೆ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ!