ಫೋರ್ಚ್ ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಎಂಬುದು ರಚನೆಯ ಅಂಶಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯನ್ನು ಸುಲಭಗೊಳಿಸಲು ಭಾಷೆಯಲ್ಲಿ ಸೇರಿಸಲಾದ ಒಂದು ಬದಲಾವಣೆಯಾಗಿದೆ. ಫೋರ್ಚ್ ಆಜ್ಞೆಯ ಎರಡು ಆವೃತ್ತಿಗಳಿವೆ, ವಿವಿಧ ರೀತಿಯ ಅರೇಗಳಿಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ:
foreach ($element ನಂತೆ ರಚನೆ) (
foreach ($key => $ಎಲಿಮೆಂಟ್ ಆಗಿ ರಚನೆ) (
ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ತುಣುಕನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ:
$menu = аrrау("ಪಾಸ್ಟಾ", "ಸ್ಟೀಕ್", "ಆಲೂಗಡ್ಡೆ", "ಮೀನು", "ಫ್ರೈಸ್");
foreach ($menu as $item) (
"$ ಐಟಂ ಅನ್ನು ಮುದ್ರಿಸಿ
";
ಕೆಳಗಿನ ಫಲಿತಾಂಶವು ಔಟ್ಪುಟ್ ಆಗಿರುತ್ತದೆ:
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಗಮನಿಸಬೇಕಾದ ಎರಡು ಅಂಶಗಳಿವೆ. ಮೊದಲನೆಯದಾಗಿ, ಫೋರ್ಚ್ ರಚನೆಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚನೆಯ ಪ್ರಾರಂಭಕ್ಕೆ ಮರಳುತ್ತದೆ (ಇತರ ಲೂಪಿಂಗ್ ರಚನೆಗಳಲ್ಲಿ ಇದು ಸಂಭವಿಸುವುದಿಲ್ಲ). ಎರಡನೆಯದಾಗಿ, ಕೌಂಟರ್ ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೆಚ್ಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ ಅಥವಾ ರಚನೆಯ ಮುಂದಿನ ಅಂಶಕ್ಕೆ ಚಲಿಸುವ ಅಗತ್ಯವಿಲ್ಲ - ಇದು ಫೋರ್ಚ್‌ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ.
ಸಹಾಯಕ ರಚನೆಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಎರಡನೇ ಆಯ್ಕೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ:
$wine_inventory = ಶ್ರೇಣಿ (
"ಮರ್ಲೋಟ್" => 15,
"zinfandel" => 17,
"ಸಾವಿಗ್ನಾನ್" => 32
foreach ($wine_inventory ನಂತೆ $i => $item_count) (
"$i ಉಳಿದಿರುವ $i ಯ $item_count ಬಾಟಲಿಗಳನ್ನು ಮುದ್ರಿಸಿ
";
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಫಲಿತಾಂಶವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
15 ಮೆರ್ಲಾಟ್ ಬಾಟಲಿಗಳು ಉಳಿದಿವೆ
ಜಿನ್‌ಫಾಂಡೆಲ್‌ನ 17 ಬಾಟಲಿಗಳು ಉಳಿದಿವೆ
32 ಸೌವಿಗ್ನಾನ್ ಬಾಟಲಿಗಳು ಉಳಿದಿವೆ
ಮೇಲಿನ ಉದಾಹರಣೆಗಳಿಂದ ನೀವು ನೋಡುವಂತೆ, ಫೋರ್ಚ್ ರಚನೆಯು ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುತ್ತದೆ.
ಸ್ವಿಚ್ ರಚನೆಯ ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವವು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ನೆನಪಿಗೆ ಬರುತ್ತದೆ - ಅಭಿವ್ಯಕ್ತಿ ಮೌಲ್ಯಮಾಪನದಿಂದ ಪಡೆದ ಫಲಿತಾಂಶವನ್ನು ಸಂಭಾವ್ಯ ಹೊಂದಾಣಿಕೆಗಳ ಪಟ್ಟಿಯ ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ.
ಬಹು ಮೌಲ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ, ಏಕೆಂದರೆ ಸ್ವಿಚ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ ಪ್ರೋಗ್ರಾಂ ಹೆಚ್ಚು ದೃಶ್ಯ ಮತ್ತು ಸಾಂದ್ರವಾಗಿರುತ್ತದೆ. ಸ್ವಿಚ್ ಆಜ್ಞೆಯ ಸಾಮಾನ್ಯ ಸ್ವರೂಪ:
ಸ್ವಿಚ್ (ಅಭಿವ್ಯಕ್ತಿ) (
ಪ್ರಕರಣ (ಷರತ್ತು):
ಪ್ರಕರಣ (ಷರತ್ತು):
ಸ್ವಿಚ್ ಕೀವರ್ಡ್ ನಂತರ ಆವರಣಗಳಲ್ಲಿ ಪರೀಕ್ಷಿಸಲ್ಪಡುವ ಸ್ಥಿತಿಯನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಅದರ ಲೆಕ್ಕಾಚಾರದ ಫಲಿತಾಂಶವನ್ನು ಪ್ರಕರಣದ ವಿಭಾಗಗಳಲ್ಲಿನ ಪರಿಸ್ಥಿತಿಗಳೊಂದಿಗೆ ಅನುಕ್ರಮವಾಗಿ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಹೊಂದಾಣಿಕೆ ಕಂಡುಬಂದರೆ, ಅನುಗುಣವಾದ ವಿಭಾಗದ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಕಂಡುಬರದಿದ್ದರೆ, ಐಚ್ಛಿಕ ಡೀಫಾಲ್ಟ್ ವಿಭಾಗ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
ನಂತರದ ಅಧ್ಯಾಯಗಳಲ್ಲಿ ನೀವು ನೋಡುವಂತೆ, PHP ಯ ಅತ್ಯುತ್ತಮ ಸಾಮರ್ಥ್ಯವೆಂದರೆ ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ಅನ್ನು ನಿರ್ವಹಿಸುವುದು. ಪ್ರೋಗ್ರಾಂ ಹಲವಾರು ಆಯ್ಕೆಗಳೊಂದಿಗೆ ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ ಎಂದು ಹೇಳೋಣ, ಮತ್ತು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಸಾಲು ಪ್ರತ್ಯೇಕ ಪ್ರಕರಣದ ರಚನೆಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾದ ಆಜ್ಞೆಗೆ ಅನುರೂಪವಾಗಿದೆ. ಸ್ವಿಚ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಷ್ಠಾನವನ್ನು ನಿರ್ಮಿಸಲು ಇದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ:
$user_input = "ಪಾಕವಿಧಾನಗಳು"; // ಬಳಕೆದಾರ-ಆಯ್ಕೆ ಮಾಡಿದ ಆಜ್ಞೆ
ಸ್ವಿಚ್ ($user_input) :
ಪ್ರಕರಣ ("ಹುಡುಕಾಟ"):
"ಹುಡುಕಾಟವನ್ನು ಮಾಡೋಣ!" ಎಂದು ಮುದ್ರಿಸು;
ಪ್ರಕರಣ ("ನಿಘಂಟು"):
ಮುದ್ರಿಸು "ನೀವು ಯಾವ ಪದವನ್ನು ಹುಡುಕಲು ಬಯಸುತ್ತೀರಿ?";
ಪ್ರಕರಣ ("ಪಾಕವಿಧಾನಗಳು"):
ಪ್ರಿಂಟ್ "ಇಲ್ಲಿ ಪಾಕವಿಧಾನಗಳ ಪಟ್ಟಿ...";
ಪ್ರಿಂಟ್ "ಇಲ್ಲಿ ಮೆನು...";
ಮೇಲಿನ ತುಣುಕಿನಿಂದ ನೀವು ನೋಡುವಂತೆ, ಸ್ವಿಚ್ ಆಜ್ಞೆಯು ಕೋಡ್‌ನ ಸ್ಪಷ್ಟ ಮತ್ತು ದೃಶ್ಯ ಸಂಘಟನೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸ್ವಿಚ್ ಸ್ಥಿತಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವೇರಿಯಬಲ್ (ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, $user_input) ಎಲ್ಲಾ ನಂತರದ ಕೇಸ್ ವಿಭಾಗಗಳ ಷರತ್ತುಗಳೊಂದಿಗೆ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಕೇಸ್ ವಿಭಾಗದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಮೌಲ್ಯವು ಹೋಲಿಸಿದ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತಿದ್ದರೆ, ಈ ವಿಭಾಗದ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಬ್ರೇಕ್ ಕಮಾಂಡ್ ಮತ್ತಷ್ಟು ಕೇಸ್ ವಿಭಾಗಗಳನ್ನು ಪರಿಶೀಲಿಸದಂತೆ ತಡೆಯುತ್ತದೆ ಮತ್ತು ಸ್ವಿಚ್ ರಚನೆಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ. ಪರಿಶೀಲಿಸಿದ ಯಾವುದೇ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸದಿದ್ದರೆ, ಐಚ್ಛಿಕ ಡೀಫಾಲ್ಟ್ ವಿಭಾಗವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ. ಯಾವುದೇ ಡೀಫಾಲ್ಟ್ ವಿಭಾಗವಿಲ್ಲದಿದ್ದರೆ ಮತ್ತು ಯಾವುದೇ ಷರತ್ತುಗಳು ನಿಜವಾಗದಿದ್ದರೆ, ಸ್ವಿಚ್ ಆಜ್ಞೆಯು ಸರಳವಾಗಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಮುಂದಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಮುಂದುವರಿಯುತ್ತದೆ.
ಕೇಸ್ ವಿಭಾಗದಲ್ಲಿ ಯಾವುದೇ ಬ್ರೇಕ್ ಕಮಾಂಡ್ ಇಲ್ಲದಿದ್ದರೆ (ಮುಂದಿನ ವಿಭಾಗವನ್ನು ನೋಡಿ), ಬ್ರೇಕ್ ಆಜ್ಞೆಯು ಎದುರಾಗುವವರೆಗೆ ಅಥವಾ ಸ್ವಿಚ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನ ಅಂತ್ಯವನ್ನು ತಲುಪುವವರೆಗೆ ಸ್ವಿಚ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಮುಂದಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಮುಂದುವರಿಯುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೆನಪಿನಲ್ಲಿಡಬೇಕು. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಬ್ರೇಕ್ ಕಮಾಂಡ್ ಅನ್ನು ಕಳೆದುಕೊಂಡಿರುವ ಪರಿಣಾಮಗಳನ್ನು ತೋರಿಸುತ್ತದೆ: $value = 0.4;
ಸ್ವಿಚ್ ($ ಮೌಲ್ಯ):
ಪ್ರಿಂಟ್ "ಮೌಲ್ಯ 0.4 ಆಗಿದೆ
";
ಪ್ರಿಂಟ್ "ಮೌಲ್ಯ 0.6 ಆಗಿದೆ
";
ಪ್ರಿಂಟ್ "ಮೌಲ್ಯ 0.3 ಆಗಿದೆ
";
ಪ್ರಿಂಟ್ "ನೀವು ಮೌಲ್ಯವನ್ನು ಆಯ್ಕೆ ಮಾಡಿಲ್ಲ!";
ಫಲಿತಾಂಶವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ಬ್ರೇಕ್ ಆಜ್ಞೆಯ ಅನುಪಸ್ಥಿತಿಯು ಹೊಂದಾಣಿಕೆಯು ಕಂಡುಬಂದ ವಿಭಾಗದಲ್ಲಿ ಮುದ್ರಣ ಆಜ್ಞೆಯನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾಯಿತು, ಆದರೆ ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಮುದ್ರಣ ಆಜ್ಞೆಯೂ ಸಹ. ನಂತರ ಸ್ವಿಚ್ ಹೇಳಿಕೆಗಳ ಮರಣದಂಡನೆಯು ಎರಡನೇ ಮುದ್ರಣ ಆಜ್ಞೆಯನ್ನು ಅನುಸರಿಸಿ ಸ್ವಿಚ್ ಹೇಳಿಕೆಯಿಂದ ಅಡಚಣೆಯಾಯಿತು.
ಸ್ವಿಚ್ ಮತ್ತು if ಆಜ್ಞೆಗಳ ನಡುವಿನ ಆಯ್ಕೆಯು ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ವಾಸ್ತವಿಕವಾಗಿ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಒಂದು ಅಥವಾ ಇನ್ನೊಂದು ವಿನ್ಯಾಸವನ್ನು ಬಳಸುವ ನಿರ್ಧಾರವು ಪ್ರೋಗ್ರಾಮರ್ಗೆ ವೈಯಕ್ತಿಕ ವಿಷಯವಾಗಿದೆ.
ಬ್ರೇಕ್ ಆಜ್ಞೆಯು ತಕ್ಷಣವೇ ಅದು ಕಂಡುಬರುವ ಸಮಯದಲ್ಲಿ, ಫಾರ್, ಅಥವಾ ಸ್ವಿಚ್ ಹೇಳಿಕೆಯ ಮರಣದಂಡನೆಯನ್ನು ಮುರಿಯುತ್ತದೆ. ಈ ಆಜ್ಞೆಯನ್ನು ಈಗಾಗಲೇ ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ, ಆದರೆ ಪ್ರಸ್ತುತ ಲೂಪ್ ಅನ್ನು ಅಡ್ಡಿಪಡಿಸುವುದು ಬ್ರೇಕ್ ಆಜ್ಞೆಯ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊರಹಾಕುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯವಾಗಿ, ಬ್ರೇಕ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ಐಚ್ಛಿಕ ಪ್ಯಾರಾಮೀಟರ್ n ಬ್ರೇಕ್ ಆಜ್ಞೆಯಿಂದ ಕೊನೆಗೊಂಡ ನಿಯಂತ್ರಣ ರಚನೆಗಳ ಹಂತಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ಬ್ರೇಕ್ ಕಮಾಂಡ್ ಅನ್ನು ಎರಡು ಸಮಯದಲ್ಲಿ ಕಮಾಂಡ್‌ಗಳೊಳಗೆ ನೆಸ್ಟ್ ಮಾಡಿದರೆ ಮತ್ತು ಬ್ರೇಕ್ ಅನ್ನು ಸಂಖ್ಯೆ 2 ರಿಂದ ಅನುಸರಿಸಿದರೆ, ಎರಡೂ ಲೂಪ್‌ಗಳು ತಕ್ಷಣವೇ ನಿರ್ಗಮಿಸುತ್ತವೆ. n ಗಾಗಿ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯವು 1 ಆಗಿದೆ; ಒಂದು ಹಂತಕ್ಕೆ ನಿರ್ಗಮಿಸುವುದನ್ನು 1 ಅನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುವ ಮೂಲಕ ಅಥವಾ ಪ್ಯಾರಾಮೀಟರ್ ಇಲ್ಲದೆ ಬ್ರೇಕ್ ಆಜ್ಞೆಯನ್ನು ಸೂಚಿಸುವ ಮೂಲಕ ಸೂಚಿಸಬಹುದು. i f ಆಜ್ಞೆಯು ಬ್ರೇಕ್ ಆಜ್ಞೆಯಿಂದ ಅಡ್ಡಿಪಡಿಸಬಹುದಾದ ನಿಯಂತ್ರಣ ರಚನೆಗಳಲ್ಲಿ ಒಂದಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
PHP foreach ಲೂಪ್ ಅನ್ನು ಈ ರೀತಿ ಬಳಸಬಹುದು:
foreach($array_name as $value)( //ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು)
foreach($array_name as $key =>$value)( // //ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್)
ಸಂಖ್ಯಾ ರಚನೆಯೊಂದಿಗೆ ಫೋರ್ಚ್ ಲೂಪ್ ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಐದು ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ. ಈ ರಚನೆಯ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಲು PHP foreach ಲೂಪ್ ಅನ್ನು ನಂತರ ಬಳಸಲಾಗುತ್ತದೆ. ಫೋರ್ಚ್ ಲೂಪ್ ಒಳಗೆ ನಾವು ಅರೇ ಮೌಲ್ಯಗಳನ್ನು ಮುದ್ರಿಸಲು ಪ್ರತಿಧ್ವನಿಯನ್ನು ಬಳಸಿದ್ದೇವೆ:
ಡೆಮೊ ಮತ್ತು ಕೋಡ್ ವೀಕ್ಷಿಸಿ
ಅರೇ ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಉದಾಹರಣೆ
ಈ ಉದಾಹರಣೆಯು PHP foreach loop ಅನ್ನು ಬಳಸುವ ಇನ್ನೊಂದು ವಿಧಾನವನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಮೂರು ಅಂಶಗಳ ಸಹಾಯಕ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಇದು ನೌಕರರ ಹೆಸರುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ( ಕೀಲಿಗಳಾಗಿ) ಮತ್ತು ವೇತನದ ಮೊತ್ತ ( ಮೌಲ್ಯಗಳಾಗಿ):
ಡೆಮೊ ಮತ್ತು ಕೋಡ್ ವೀಕ್ಷಿಸಿ
ಫೋರ್ಚ್ ಲೂಪ್‌ನಲ್ಲಿ ರಚನೆಯ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವ ಉದಾಹರಣೆ
ಅರೇ ಅಂಶಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲು ನೀವು PHP ಅರೇ ಫೋರ್ಚ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು. ಮೌಲ್ಯ ವೇರಿಯೇಬಲ್‌ಗಾಗಿ "$" ಮೊದಲು "&" ಅನ್ನು ಬಳಸುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:
&$value_of_element
ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದು. ಅದನ್ನು ಸ್ಪಷ್ಟಪಡಿಸಲು, ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಐದು ಅಂಶಗಳ ಸಂಖ್ಯಾ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿದ್ದೇವೆ. ಅದರ ನಂತರ, ಅಂಶಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ನಾವು ಫೋರ್ಚ್ ಲೂಪ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ.
ನಂತರ ನಾವು ಇನ್ನೊಂದು foreach ಲೂಪ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅಲ್ಲಿ $value_of_element ಮೊದಲು "&" ಸೇರಿಸಲಾಗುತ್ತದೆ. ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳ ಒಳಗೆ ನಾವು ರಚನೆಯ ಅಂಶಗಳಿಗೆ ಹೊಸ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.
ಹೊಸ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುವ ಮೊದಲು ಮತ್ತು ನಂತರ ವ್ಯತ್ಯಾಸವನ್ನು ನೋಡಲು, ಅರೇ ಅನ್ನು print_r() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ಡೆಮೊ ಮತ್ತು ಕೋಡ್ ವೀಕ್ಷಿಸಿ
PHP foreach loop ಅನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ?
PHP foreach ಲೂಪ್ ಅನ್ನು ರಚನೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಇದು ಅದರ ಪ್ರತಿಯೊಂದು ಅಂಶಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ.
ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನೀವು ಫಾರ್ ಲೂಪ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ರಚನೆಯ ಉದ್ದವನ್ನು ಪಡೆಯಲು ಉದ್ದದ ಆಸ್ತಿಯನ್ನು ಬಳಸುವುದು ಮತ್ತು ನಂತರ ಅದನ್ನು ಗರಿಷ್ಠ ಆಪರೇಟರ್ ಆಗಿ ಅನ್ವಯಿಸುವುದು. ಆದರೆ ಅರೇಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಿರುವುದರಿಂದ ಫೋರ್ಚ್ ಅದನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.
ನೀವು MySQL ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿದರೆ, ಈ ಚಕ್ರವು ಇದಕ್ಕೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಡೇಟಾಬೇಸ್ ಕೋಷ್ಟಕದಿಂದ ಹಲವಾರು ಸಾಲುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಗೆ ರವಾನಿಸಬಹುದು. ಅದರ ನಂತರ, ಫೋರ್ಚ್ ಲೂಪ್ ಬಳಸಿ, ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೂಲಕ ಪುನರಾವರ್ತಿಸಿ ಮತ್ತು ಕೆಲವು ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಿ.
ನೀವು ಅರೇ ಅಥವಾ ಕೇವಲ ಒಂದು ವಸ್ತುವಿನೊಂದಿಗೆ ಫೋರ್ಚ್ ಲೂಪ್ ಅನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಫೋರ್ಚ್ ಲೂಪ್ ಅನ್ನು ಬಳಸುವುದು
PHP ನಲ್ಲಿ PHP foreach loop ಅನ್ನು ಬಳಸಲು ಎರಡು ಮಾರ್ಗಗಳಿವೆ. ಎರಡನ್ನೂ ಕೆಳಗೆ ವಿವರಿಸಲಾಗಿದೆ.
- ಮೊದಲ ವಿಧಾನದ ಸಿಂಟ್ಯಾಕ್ಸ್:
foreach($array_name as $value)( ಪ್ರತಿಧ್ವನಿ $value )
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು ರಚನೆಯ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು ಮತ್ತು ನಂತರ $ ಮೌಲ್ಯ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೂಚಿಸಬೇಕು.
ಪ್ರತಿ ಪುನರಾವರ್ತನೆಗೆ, ಪ್ರಸ್ತುತ ಅಂಶದ ಮೌಲ್ಯವನ್ನು $ ಮೌಲ್ಯ ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಪುನರಾವರ್ತನೆ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ವೇರಿಯಬಲ್ ಮುಂದಿನ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮತ್ತು ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವವರೆಗೆ.
- ಎರಡನೇ ವಿಧಾನದ ಸಿಂಟ್ಯಾಕ್ಸ್ ( ಪ್ರಮುಖ ಮೌಲ್ಯವಾಗಿ PHP foreach):
ಕೀ/ಮೌಲ್ಯ ಜೋಡಿಗಳನ್ನು ಬಳಸುವ ಅಸೋಸಿಯೇಟಿವ್ ಅರೇಗಳಿಗೆ ಇದು ಸೂಕ್ತವಾಗಿದೆ.
ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ, ಪ್ರಸ್ತುತ ಅಂಶದ ಮೌಲ್ಯವನ್ನು $value_of_element ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ. ಜೊತೆಗೆ, ಎಲಿಮೆಂಟ್ ಕೀಯನ್ನು $key_of_element ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗಿದೆ.
ನೀವು ಸಂಖ್ಯಾ ಸರಣಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ನೀವು ಮೊದಲ ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು, ಇದು ಎಲಿಮೆಂಟ್ ಕೀಗಳ ಅಗತ್ಯವಿಲ್ಲ.
ಈ ಪ್ರಕಟಣೆಯು ಲೇಖನದ ಅನುವಾದವಾಗಿದೆ " PHP foreach loop ಅದನ್ನು ಬಳಸಲು 2 ಮಾರ್ಗಗಳು", ಸೌಹಾರ್ದ ಯೋಜನೆಯ ತಂಡವು ಸಿದ್ಧಪಡಿಸಿದೆ
PHP ಕುರಿತು ಆಸಕ್ತಿದಾಯಕ ಲಿಂಕ್‌ಗಳ ಇತ್ತೀಚಿನ ಡೈಜೆಸ್ಟ್‌ನಲ್ಲಿ, ಸ್ಟಾಕ್‌ಓವರ್‌ಫ್ಲೋನಲ್ಲಿ ನಿಕಿತಾ ಪೊಪೊವ್ ಅವರ ಕಾಮೆಂಟ್‌ಗೆ ಲಿಂಕ್ ಅನ್ನು ನಾನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ, ಅಲ್ಲಿ ಅವರು ಫೋರ್ಚ್ ಕಂಟ್ರೋಲ್ ಸ್ಟ್ರಕ್ಟ್‌ನ "ಹುಡ್ ಅಡಿಯಲ್ಲಿ" ಯಾಂತ್ರಿಕತೆಯ ಬಗ್ಗೆ ವಿವರವಾಗಿ ಮಾತನಾಡುತ್ತಾರೆ.
foreach ಕೆಲವೊಮ್ಮೆ ಸ್ವಲ್ಪ ವಿಚಿತ್ರ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರಿಂದ, ಈ ಉತ್ತರವನ್ನು ಭಾಷಾಂತರಿಸಲು ನನಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ.
ಗಮನ: ಈ ಪಠ್ಯವು PHP ಯಲ್ಲಿನ zval ಗಳ ಕಾರ್ಯಚಟುವಟಿಕೆಗಳ ಮೂಲಭೂತ ಜ್ಞಾನವನ್ನು ಊಹಿಸುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ನೀವು ರೀಕೌಂಟ್ ಮತ್ತು is_ref ಏನೆಂದು ತಿಳಿದಿರಬೇಕು.
foreach ವಿವಿಧ ಪ್ರಕಾರಗಳ ಘಟಕಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಸರಣಿಗಳೊಂದಿಗೆ, ಸರಳ ವಸ್ತುಗಳೊಂದಿಗೆ (ಲಭ್ಯವಿರುವ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪಟ್ಟಿಮಾಡಲಾಗಿದೆ) ಮತ್ತು ಟ್ರಾವೆರ್ಸಬಲ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳೊಂದಿಗೆ (ಅಥವಾ ಬದಲಿಗೆ, ಆಂತರಿಕ get_iterator ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಹೊಂದಿರುವ ವಸ್ತುಗಳು). ನಾವು ಇಲ್ಲಿ ರಚನೆಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚಾಗಿ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ, ಆದರೆ ನಾನು ಉಳಿದವುಗಳ ಬಗ್ಗೆ ಕೊನೆಯಲ್ಲಿ ಮಾತನಾಡುತ್ತೇನೆ.
ನಾವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ಅರೇಗಳು ಮತ್ತು ಅವುಗಳ ಅಡ್ಡಹಾಯುವಿಕೆಯ ಬಗ್ಗೆ ಕೆಲವು ಪದಗಳು, ಸಂದರ್ಭವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮುಖ್ಯವಾಗಿದೆ.
ಅರೇ ಟ್ರಾವರ್ಸಲ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?
PHP ಯಲ್ಲಿನ ಅರೇಗಳು ಆದೇಶದ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು (ಹ್ಯಾಶ್ ಅಂಶಗಳನ್ನು ದ್ವಿಗುಣವಾಗಿ ಲಿಂಕ್ ಮಾಡಲಾದ ಪಟ್ಟಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ) ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಕ್ರಮವನ್ನು ಅನುಸರಿಸಿ ಸರಣಿಯನ್ನು ಟ್ರಾವೆಸ್ ಮಾಡುತ್ತದೆ.
PHP ಒಂದು ಶ್ರೇಣಿಯನ್ನು ದಾಟಲು ಎರಡು ಮಾರ್ಗಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
- ಮೊದಲ ಮಾರ್ಗವೆಂದರೆ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್. ಈ ಪಾಯಿಂಟರ್ ಹ್ಯಾಶ್‌ಟೇಬಲ್ ರಚನೆಯ ಭಾಗವಾಗಿದೆ ಮತ್ತು ಪ್ರಸ್ತುತ ಹ್ಯಾಶ್ ಟೇಬಲ್ ಅಂಶಕ್ಕೆ ಸರಳವಾಗಿ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ನಿರ್ಭಯದಿಂದ ಬದಲಾಯಿಸಬಹುದು, ಅಂದರೆ, ಪ್ರಸ್ತುತ ಅಂಶವನ್ನು ಅಳಿಸಿದರೆ, ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ಮುಂದಿನದಕ್ಕೆ ಸರಿಸಲಾಗುತ್ತದೆ.
- ಎರಡನೇ ಪುನರಾವರ್ತನೆಯ ಕಾರ್ಯವಿಧಾನವು ಹ್ಯಾಶ್‌ಪೊಸಿಷನ್ ಎಂಬ ಬಾಹ್ಯ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಆಗಿದೆ. ಇದು ಮೂಲಭೂತವಾಗಿ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್‌ನಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಇದು ಹ್ಯಾಶ್‌ಟೇಬಲ್‌ನ ಭಾಗವಾಗಿಲ್ಲ. ಪುನರಾವರ್ತನೆಯ ಈ ಬಾಹ್ಯ ಮಾರ್ಗವು ಬದಲಾವಣೆ-ಸುರಕ್ಷಿತವಲ್ಲ. HashPosition ಮೂಲಕ ಸೂಚಿಸಲಾದ ಅಂಶವನ್ನು ನೀವು ತೆಗೆದುಹಾಕಿದರೆ, ನೀವು ತೂಗಾಡುವ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಿಡುತ್ತೀರಿ, ಇದು ವಿಭಜನೆಯ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಹೀಗಾಗಿ, ಪ್ರಯಾಣದ ಸಮಯದಲ್ಲಿ ಯಾವುದೇ ಬಳಕೆದಾರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಖಚಿತವಾಗಿದ್ದಾಗ ಮಾತ್ರ ಬಾಹ್ಯ ಅರೇ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಬೇಕು. ಮತ್ತು ಅಂತಹ ಕೋಡ್ ದೋಷ ಹ್ಯಾಂಡ್ಲರ್ ಅಥವಾ ಡಿಸ್ಟ್ರಕ್ಟರ್‌ನಂತಹ ಅತ್ಯಂತ ಅನಿರೀಕ್ಷಿತ ಸ್ಥಳಗಳಲ್ಲಿ ಕೊನೆಗೊಳ್ಳಬಹುದು. ಅದಕ್ಕಾಗಿಯೇ ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ PHP ಬಾಹ್ಯದ ಬದಲಿಗೆ ಆಂತರಿಕ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಅದು ಇಲ್ಲದಿದ್ದರೆ, ಬಳಕೆದಾರರು ಅಸಾಮಾನ್ಯವಾದುದನ್ನು ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿದ ತಕ್ಷಣ PHP ವಿಭಜನೆಯ ದೋಷದೊಂದಿಗೆ ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು.
ಆಂತರಿಕ ಪಾಯಿಂಟರ್ನ ಸಮಸ್ಯೆಯೆಂದರೆ ಅದು ಹ್ಯಾಶ್‌ಟೇಬಲ್‌ನ ಭಾಗವಾಗಿದೆ. ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ಬದಲಾಯಿಸಿದಾಗ, ಹ್ಯಾಶ್‌ಟೇಬಲ್ ಅದರೊಂದಿಗೆ ಬದಲಾಗುತ್ತದೆ. ಮತ್ತು PHP ಯಲ್ಲಿನ ಸರಣಿಗಳನ್ನು ಮೌಲ್ಯದಿಂದ ಪ್ರವೇಶಿಸುವುದರಿಂದ (ಮತ್ತು ಉಲ್ಲೇಖದಿಂದ ಅಲ್ಲ), ಅದರ ಅಂಶಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಲು ನೀವು ರಚನೆಯನ್ನು ನಕಲಿಸಲು ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ.
ನಕಲು ಮಾಡುವ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ತೋರಿಸುವ ಒಂದು ಸರಳ ಉದಾಹರಣೆ (ಅದು ಸಾಮಾನ್ಯವಲ್ಲ, ಮೂಲಕ) ನೆಸ್ಟೆಡ್ ಪುನರಾವರ್ತನೆಯಾಗಿದೆ:
Foreach ($array as $a) ( foreach ($array as $b) (// ... ) )
ಇಲ್ಲಿ ನೀವು ಎರಡೂ ಕುಣಿಕೆಗಳು ಸ್ವತಂತ್ರವಾಗಿರಬೇಕು ಮತ್ತು ಒಂದು ಪಾಯಿಂಟರ್ನೊಂದಿಗೆ ಜಾಣತನದಿಂದ ಎಸೆಯಬಾರದು.
ಆದ್ದರಿಂದ ನಾವು ಮುನ್ನುಗ್ಗಲು ಬರುತ್ತೇವೆ.
ಫೋರ್ಚ್‌ನಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹಾದುಹೋಗುವುದು
ಫೋರ್ಚ್ ಅದನ್ನು ದಾಟುವ ಮೊದಲು ಅದರ ನಕಲನ್ನು ಏಕೆ ರಚಿಸಬೇಕು ಎಂದು ಈಗ ನಿಮಗೆ ತಿಳಿದಿದೆ. ಆದರೆ ಇದು ಸ್ಪಷ್ಟವಾಗಿ ಸಂಪೂರ್ಣ ಕಥೆಯಲ್ಲ. PHP ನಕಲು ಮಾಡುತ್ತದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದು ಹಲವಾರು ಅಂಶಗಳ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ:
- ಪುನರಾವರ್ತನೀಯ ರಚನೆಯು ಉಲ್ಲೇಖವಾಗಿದ್ದರೆ, ಯಾವುದೇ ನಕಲು ಸಂಭವಿಸುವುದಿಲ್ಲ, ಬದಲಿಗೆ addref ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ:
$ref =& $array; // $array has_ref=1 now foreach ($array as $val) (// ... )
ಏಕೆ? ಏಕೆಂದರೆ ರಚನೆಯ ಯಾವುದೇ ಬದಲಾವಣೆಯು ಆಂತರಿಕ ಪಾಯಿಂಟರ್ ಸೇರಿದಂತೆ ಉಲ್ಲೇಖದ ಮೂಲಕ ಪ್ರಚಾರ ಮಾಡಬೇಕು. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಫೋರ್ಚ್ ನಕಲು ಮಾಡಿದರೆ, ಅದು ಲಿಂಕ್‌ನ ಶಬ್ದಾರ್ಥವನ್ನು ಮುರಿಯುತ್ತದೆ. - ರಚನೆಯು refcount=1 ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನಕಲು ಮಾಡುವಿಕೆಯನ್ನು ಮತ್ತೆ ನಿರ್ವಹಿಸಲಾಗುವುದಿಲ್ಲ. refcount=1 ಎಂದರೆ ರಚನೆಯನ್ನು ಬೇರೆಡೆ ಬಳಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು foreach ಅದನ್ನು ನೇರವಾಗಿ ಬಳಸಬಹುದು. ಮರುಎಣಿಕೆಯು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ, ನಂತರ ಸರಣಿಯನ್ನು ಇತರ ವೇರಿಯಬಲ್‌ಗಳೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಲಾಗುತ್ತದೆ ಮತ್ತು ಮಾರ್ಪಾಡುಗಳನ್ನು ತಪ್ಪಿಸಲು, foreach ಅದನ್ನು ನಕಲಿಸಬೇಕು (ಮೇಲೆ ವಿವರಿಸಿದ ಉಲ್ಲೇಖದ ಪ್ರಕರಣವನ್ನು ಲೆಕ್ಕಿಸದೆ).
- ರಚನೆಯು ಉಲ್ಲೇಖ-ಪ್ರವೇಶವಾಗಿದ್ದರೆ (ಫೋರ್ಚ್ ($ಅರೇ &$ref)), ನಂತರ - ನಕಲು ಅಥವಾ ನಕಲು-ಅಲ್ಲದ ಕಾರ್ಯವನ್ನು ಲೆಕ್ಕಿಸದೆ - ರಚನೆಯು ಉಲ್ಲೇಖವಾಗುತ್ತದೆ.
ಆದ್ದರಿಂದ ಇದು ರಹಸ್ಯದ ಮೊದಲ ಭಾಗವಾಗಿದೆ: ನಕಲು ಕಾರ್ಯ. ಎರಡನೇ ಭಾಗವು ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆಯನ್ನು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಇದು ತುಂಬಾ ವಿಚಿತ್ರವಾಗಿದೆ. ನಿಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿರುವ "ಸಾಮಾನ್ಯ" ಪುನರಾವರ್ತನೆಯ ಮಾದರಿಯು (ಮತ್ತು ಇದನ್ನು ಹೆಚ್ಚಾಗಿ PHP ಯಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ - ಫೋರ್ಚ್‌ನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿದೆ) ಈ ರೀತಿ ಕಾಣುತ್ತದೆ (ಸೂಡೊಕೋಡ್):
ಮರುಹೊಂದಿಸಿ (); ಹಾಗೆಯೇ (get_current_data(&data) == ಯಶಸ್ಸು) (ಕೋಡ್(); move_forward(); )
ಫೋರ್ಚ್ ಪುನರಾವರ್ತನೆಯು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿ ಕಾಣುತ್ತದೆ:
ಮರುಹೊಂದಿಸಿ (); ಹಾಗೆಯೇ (get_current_data(&data) == ಯಶಸ್ಸು) (move_forward(); code(); )
ವ್ಯತ್ಯಾಸವೆಂದರೆ ಮೂವ್_ಫಾರ್ವರ್ಡ್() ಅನ್ನು ಲೂಪ್ನ ಅಂತ್ಯಕ್ಕಿಂತ ಆರಂಭದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೀಗಾಗಿ, ಬಳಕೆದಾರ ಕೋಡ್ ಅಂಶ $i ಅನ್ನು ಬಳಸಿದಾಗ, ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಈಗಾಗಲೇ ಅಂಶ $i+1 ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ.
ಫೋರ್ಚ್‌ನ ಈ ಕಾರ್ಯಾಚರಣೆಯ ವಿಧಾನವು ಹಿಂದಿನದಕ್ಕಿಂತ (ನೀವು ನಿರೀಕ್ಷಿಸಿದಂತೆ) ಪ್ರಸ್ತುತವನ್ನು ಅಳಿಸಿದರೆ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಮುಂದಿನ ಅಂಶಕ್ಕೆ ಚಲಿಸಲು ಕಾರಣವಾಗಿದೆ. ಎಲ್ಲವನ್ನೂ ಫೋರ್ಚ್‌ನೊಂದಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ (ಆದರೆ ನಿಸ್ಸಂಶಯವಾಗಿ ಉಳಿದಂತೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ, ಅಂಶಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು).
ಕೋಡ್ ಪರಿಣಾಮಗಳು
ಮೇಲಿನ ನಡವಳಿಕೆಯ ಮೊದಲ ಪರಿಣಾಮವೆಂದರೆ ಫೋರ್ಚ್ ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ (ನಿಧಾನವಾಗಿ) ಪುನರಾವರ್ತನೀಯ ಶ್ರೇಣಿಯನ್ನು ನಕಲಿಸುತ್ತದೆ. ಆದರೆ ಭಯಪಡಬೇಡಿ: ನಾನು ನಕಲು ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕಲು ಪ್ರಯತ್ನಿಸಿದೆ ಮತ್ತು ಕೃತಕ ಮಾನದಂಡಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಿಯೂ ಯಾವುದೇ ವೇಗವನ್ನು ನೋಡಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ (ಇದು ಎರಡು ಪಟ್ಟು ವೇಗವಾಗಿ ಪುನರಾವರ್ತನೆಯಾಯಿತು). ಜನರು ಸಾಕಷ್ಟು ಪುನರಾವರ್ತಿಸುವುದಿಲ್ಲ ಎಂದು ತೋರುತ್ತದೆ.
ಎರಡನೆಯ ಪರಿಣಾಮವೆಂದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಯಾವುದೇ ಇತರ ಪರಿಣಾಮಗಳು ಇರಬಾರದು. ಫೋರ್ಚ್‌ನ ನಡವಳಿಕೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಕೆದಾರರಿಗೆ ಸಾಕಷ್ಟು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ ಮತ್ತು ಅದು ಮಾಡಬೇಕಾದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಕಲು ಹೇಗೆ ಸಂಭವಿಸುತ್ತದೆ (ಅಥವಾ ಅದು ಸಂಭವಿಸುತ್ತದೆಯೇ) ಅಥವಾ ಯಾವ ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಪಾಯಿಂಟರ್ ಅನ್ನು ಸರಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ಕಾಳಜಿ ವಹಿಸಬಾರದು.
ಮತ್ತು ಮೂರನೇ ಪರಿಣಾಮ - ಮತ್ತು ಇಲ್ಲಿ ನಾವು ನಿಮ್ಮ ಸಮಸ್ಯೆಗೆ ಬರುತ್ತೇವೆ - ಕೆಲವೊಮ್ಮೆ ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕಷ್ಟಕರವಾದ ವಿಚಿತ್ರ ನಡವಳಿಕೆಯನ್ನು ನೋಡುತ್ತೇವೆ. ನೀವು ಲೂಪ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತಿರುವ ರಚನೆಯನ್ನು ಸ್ವತಃ ಮಾರ್ಪಡಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಸಂಭವಿಸುತ್ತದೆ.
ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾರ್ಪಡಿಸಿದಾಗ ಸಂಭವಿಸುವ ಎಡ್ಜ್ ಕೇಸ್ ನಡವಳಿಕೆಯ ದೊಡ್ಡ ಸಂಗ್ರಹವನ್ನು PHP ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಕಾಣಬಹುದು. ನೀವು ಈ ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು, ನಂತರ ವಿಳಾಸದಲ್ಲಿ 012 ರಿಂದ 013 ಗೆ ಬದಲಾಯಿಸಬಹುದು, ಇತ್ಯಾದಿ. ವಿಭಿನ್ನ ಸಂದರ್ಭಗಳಲ್ಲಿ (ಎಲ್ಲಾ ರೀತಿಯ ಲಿಂಕ್‌ಗಳ ಸಂಯೋಜನೆಗಳು, ಇತ್ಯಾದಿ) ಫೋರ್ಚ್ ನಡವಳಿಕೆಯು ಹೇಗೆ ಪ್ರಕಟವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ.
ಈಗ ನಿಮ್ಮ ಉದಾಹರಣೆಗಳಿಗೆ ಹಿಂತಿರುಗಿ ನೋಡೋಣ:
Foreach ($array as $item) (ಪ್ರತಿಧ್ವನಿ "$item\n"; $array = $item; ) print_r($array); /* ಔಟ್ಪುಟ್ ಇನ್ ಲೂಪ್: 1 2 3 4 5 $ಅರೇ ನಂತರ ಲೂಪ್: 1 2 3 4 5 1 2 3 4 5 */
ಇಲ್ಲಿ $array ಲೂಪ್ನ ಮೊದಲು refcount=1 ಅನ್ನು ಹೊಂದಿದೆ ಆದ್ದರಿಂದ ಅದನ್ನು ನಕಲಿಸಲಾಗುವುದಿಲ್ಲ ಆದರೆ addref ಪಡೆಯುತ್ತದೆ. ಒಮ್ಮೆ ನೀವು $array ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಿದರೆ, zval ಅನ್ನು ವಿಭಜಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಅಂಶಗಳನ್ನು ಸೇರಿಸುತ್ತಿರುವ ರಚನೆ ಮತ್ತು ನೀವು ಪುನರಾವರ್ತಿಸುತ್ತಿರುವ ರಚನೆಯು ಎರಡು ವಿಭಿನ್ನ ಸರಣಿಗಳಾಗಿರುತ್ತದೆ.
Foreach ($array as $key => $item) ($array[$key + 1] = $item + 2; echo "$item\n"; ) print_r($array); /* ಔಟ್ಪುಟ್ ಇನ್ ಲೂಪ್: 1 2 3 4 5 $ಅರೇ ನಂತರ ಲೂಪ್: 1 3 4 5 6 7 */
ಮೊದಲ ಟೆಸ್ಟ್‌ನಲ್ಲೂ ಅದೇ ಪರಿಸ್ಥಿತಿ.
// ಪಾಯಿಂಟರ್ ಅನ್ನು ಒಂದರಿಂದ ಶಿಫ್ಟ್ ಮಾಡಿ ಅದು foreach var_dump (ಪ್ರತಿ($ಅರೇ)) ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ; foreach ($array as $item) (echo "$item\n"; ) var_dump(each($array)); /* ಔಟ್ಪುಟ್ ಅರೇ(4) ( => int(1) ["value"]=> int(1) => int(0) ["key"]=> int(0) ) 1 2 3 4 5 bool( ಸುಳ್ಳು) */
ಮತ್ತೆ ಅದೇ ಕಥೆ. foreach ಲೂಪ್ ಸಮಯದಲ್ಲಿ, ನೀವು refcount=1 ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ನೀವು addref ಅನ್ನು ಮಾತ್ರ ಪಡೆಯುತ್ತೀರಿ, ಆಂತರಿಕ $array ಪಾಯಿಂಟರ್ ಅನ್ನು ಮಾರ್ಪಡಿಸಲಾಗುತ್ತದೆ. ಲೂಪ್ನ ಕೊನೆಯಲ್ಲಿ, ಪಾಯಿಂಟರ್ NULL ಆಗುತ್ತದೆ (ಇದರರ್ಥ ಪುನರಾವರ್ತನೆ ಪೂರ್ಣಗೊಂಡಿದೆ). ಪ್ರತಿಯೊಂದೂ ಇದನ್ನು ತಪ್ಪಾಗಿ ಹಿಂದಿರುಗಿಸುವ ಮೂಲಕ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
Foreach ($array as $key => $item) (ಪ್ರತಿಧ್ವನಿ "$item\n"; each($array); ) /* ಔಟ್ಪುಟ್: 1 2 3 4 5 */
Foreach ($array as $key => $item) (ಪ್ರತಿಧ್ವನಿ "$item\n"; reset($array); ) /* ಔಟ್ಪುಟ್: 1 2 3 4 5 */
ಆದರೆ ಈ ಉದಾಹರಣೆಗಳು ಸಾಕಷ್ಟು ಮನವರಿಕೆಯಾಗುವುದಿಲ್ಲ. ನೀವು ಲೂಪ್‌ನಲ್ಲಿ ಕರೆಂಟ್ ಅನ್ನು ಬಳಸಿದಾಗ ನಡವಳಿಕೆಯು ನಿಜವಾಗಿಯೂ ಅನಿರೀಕ್ಷಿತವಾಗಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ:
Foreach ($val as $val) (var_dump(ಪ್ರಸ್ತುತ($array)); ) /* ಔಟ್ಪುಟ್: 2 2 2 2 2 */
ರಚನೆಯನ್ನು ಮಾರ್ಪಡಿಸದಿದ್ದರೂ ಸಹ ಉಲ್ಲೇಖದ ಮೂಲಕ ಪ್ರಸ್ತುತವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಎಂಬುದನ್ನು ಇಲ್ಲಿ ನೀವು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕು. ಉಲ್ಲೇಖದ ಮೂಲಕ ಪ್ರವೇಶದಂತಹ ಎಲ್ಲಾ ಇತರ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಸ್ಥಿರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಇದು ಅಗತ್ಯವಿದೆ (ಪ್ರಸ್ತುತವು ವಾಸ್ತವವಾಗಿ ಆದ್ಯತೆಯ ref ಕಾರ್ಯವಾಗಿದೆ; ಇದು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಬಹುದು, ಆದರೆ ಅದು ಸಾಧ್ಯವಾದರೆ ಉಲ್ಲೇಖವನ್ನು ಬಳಸುತ್ತದೆ). ಒಂದು ಉಲ್ಲೇಖ ಎಂದರೆ ರಚನೆಯನ್ನು ಬೇರ್ಪಡಿಸಬೇಕು, ಆದ್ದರಿಂದ $array ಮತ್ತು $array ನ ನಕಲು foreach ಬಳಸುವ ಸ್ವತಂತ್ರವಾಗಿರುತ್ತದೆ. ನೀವು 2 ಅನ್ನು ಏಕೆ ಪಡೆಯುತ್ತೀರಿ ಮತ್ತು 1 ಅಲ್ಲ ಎಂಬುದನ್ನು ಸಹ ಮೇಲೆ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ: foreach increments array pointer ಬಳಕೆದಾರ ಕೋಡ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು, ನಂತರ ಅಲ್ಲ. ಆದ್ದರಿಂದ ಕೋಡ್ ಇನ್ನೂ ಮೊದಲ ಅಂಶದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ ಸಹ, foreach ಈಗಾಗಲೇ ಪಾಯಿಂಟರ್ ಅನ್ನು ಎರಡನೆಯದಕ್ಕೆ ಸರಿಸಿದೆ.
ಈಗ ನಾವು ಒಂದು ಸಣ್ಣ ಬದಲಾವಣೆಯನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:
$ref = &$array; foreach ($val as $val) (var_dump(ಪ್ರಸ್ತುತ($array)); ) /* ಔಟ್ಪುಟ್: 2 3 4 5 ತಪ್ಪು */
ಇಲ್ಲಿ ನಾವು is_ref=1 ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ಸರಣಿಯನ್ನು ನಕಲಿಸಲಾಗಿಲ್ಲ (ಮೇಲಿನಂತೆಯೇ). ಆದರೆ ಈಗ is_ref ಇರುವುದರಿಂದ, ಸರಣಿಯನ್ನು ಇನ್ನು ಮುಂದೆ ವಿಭಜಿಸಬೇಕಾಗಿಲ್ಲ, ಪ್ರಸ್ತುತವನ್ನು ಉಲ್ಲೇಖಿಸಿ ಹಾದುಹೋಗುತ್ತದೆ. ಈಗ ಪ್ರಸ್ತುತ ಮತ್ತು ಫೋರ್ಚ್ ಒಂದೇ ರಚನೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಫೋರ್ಚ್ ಪಾಯಿಂಟರ್ ಅನ್ನು ಪರಿಗಣಿಸುವ ವಿಧಾನದ ಕಾರಣದಿಂದ ಸರಣಿಯನ್ನು ನಿಖರವಾಗಿ ಬದಲಾಯಿಸಿರುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ.
ಉಲ್ಲೇಖದ ಮೂಲಕ ನೀವು ಶ್ರೇಣಿಯನ್ನು ದಾಟಿದಾಗ ನೀವು ಅದೇ ವಿಷಯವನ್ನು ನೋಡುತ್ತೀರಿ:
Foreach ($array as &$val) ( var_dump(ಪ್ರಸ್ತುತ($array)); ) /* ಔಟ್ಪುಟ್: 2 3 4 5 ತಪ್ಪು */
ಇಲ್ಲಿ ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ foreach ನಮ್ಮ $array is_ref=1 ಅನ್ನು ಉಲ್ಲೇಖದ ಮೂಲಕ ಲೂಪ್ ಮಾಡಿದಾಗ ಅದನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದು ಮೇಲಿನಂತೆಯೇ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ.
ಮತ್ತೊಂದು ಸಣ್ಣ ಬದಲಾವಣೆ, ಇಲ್ಲಿ ನಾವು ನಮ್ಮ ಶ್ರೇಣಿಯನ್ನು ಮತ್ತೊಂದು ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸುತ್ತೇವೆ:
$foo = $array; foreach ($array as $val) (var_dump(ಪ್ರಸ್ತುತ($array)); ) /* ಔಟ್ಪುಟ್: 1 1 1 1 1 */
ಇಲ್ಲಿ ಲೂಪ್ ಪ್ರಾರಂಭವಾದಾಗ $array ನ ಮರುಎಣಿಕೆಯನ್ನು 2 ಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ನಕಲನ್ನು ಮಾಡಬೇಕಾಗಿದೆ. ಆದ್ದರಿಂದ $array ಮತ್ತು foreach ಬಳಸುವ ಅರೇ ಆರಂಭದಿಂದ ವಿಭಿನ್ನವಾಗಿರುತ್ತದೆ. ಅದಕ್ಕಾಗಿಯೇ ನೀವು ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ಸಂಬಂಧಿತವಾದ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ನ ಸ್ಥಾನವನ್ನು ಪಡೆಯುತ್ತೀರಿ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿದೆ).
ವಸ್ತುಗಳ ಪುನರಾವರ್ತನೆ
ವಸ್ತುಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವಾಗ, ಎರಡು ಪ್ರಕರಣಗಳನ್ನು ಪರಿಗಣಿಸಲು ಇದು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ:
ಆಬ್ಜೆಕ್ಟ್ ಟ್ರಾವರ್ಸಬಲ್ ಅಲ್ಲ (ಅಥವಾ ಬದಲಿಗೆ, ಆಂತರಿಕ get_iterator ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ)
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪುನರಾವರ್ತನೆಯು ಸರಣಿಗಳಂತೆಯೇ ಸಂಭವಿಸುತ್ತದೆ. ನಕಲು ಮಾಡುವ ಅದೇ ಶಬ್ದಾರ್ಥ. ಒಂದೇ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಪ್ರಸ್ತುತ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಲಭ್ಯವಿಲ್ಲದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲು foreach ಕೆಲವು ಹೆಚ್ಚುವರಿ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಒಂದೆರಡು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ಸಂಗತಿಗಳು:
- ಘೋಷಿತ ಗುಣಲಕ್ಷಣಗಳಿಗಾಗಿ, PHP ಪ್ರಾಪರ್ಟಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ ಅನ್ನು ಮರುಹೊಂದಿಸುತ್ತದೆ. ನೀವು ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಿದರೆ, ಅದು ಹ್ಯಾಶ್ ಟೇಬಲ್ ಅನ್ನು ಪುನರ್ನಿರ್ಮಿಸಬೇಕು (ಇದು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ). ನೀವು ಅದರ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ, ತಿಳಿದಿರಲಿ.
- ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿ, ಪ್ರಾಪರ್ಟಿ ಹ್ಯಾಶ್ ಟೇಬಲ್ ಅನ್ನು ಮರು-ಪಡೆಯಲಾಗುತ್ತದೆ, ಅಂದರೆ PHP ಮತ್ತೆ ಮತ್ತೆ get_properties ಅನ್ನು ಕರೆಯುತ್ತದೆ. "ನಿಯಮಿತ" ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಇದು ತುಂಬಾ ಮುಖ್ಯವಲ್ಲ, ಆದರೆ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ರಚಿಸಿದರೆ (ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಅಂತರ್ನಿರ್ಮಿತ ತರಗತಿಗಳಿಂದ ಮಾಡಲಾಗುತ್ತದೆ) ನಂತರ ಆಸ್ತಿ ಕೋಷ್ಟಕವನ್ನು ಪ್ರತಿ ಬಾರಿ ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗುತ್ತದೆ.
ಸಂಚರಿಸಬಹುದಾದ ವಸ್ತು
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೇಲೆ ಹೇಳಿದ ಎಲ್ಲವೂ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಅನ್ವಯಿಸುವುದಿಲ್ಲ. ಅಲ್ಲದೆ, PHP ನಕಲಿಸುವುದಿಲ್ಲ ಮತ್ತು ಲೂಪ್ ಮೊದಲು ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವಂತಹ ಯಾವುದೇ ತಂತ್ರಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ. ಟ್ರಾವರ್ಸಬಲ್ ವಸ್ತುವಿನ ಮೂಲಕ ಹಾದುಹೋಗುವ ವಿಧಾನವು ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಮತ್ತು ಹೆಚ್ಚಿನ ವಿವರಣೆಯ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.
ಲೂಪ್ ಸಮಯದಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಬದಲಾಯಿಸುವುದು
ನಾನು ಉಲ್ಲೇಖಿಸದ ಮತ್ತೊಂದು ಅಸಾಮಾನ್ಯ ಪ್ರಕರಣವೆಂದರೆ ಲೂಪ್ ಸಮಯದಲ್ಲಿ ಪುನರಾವರ್ತನೆಯನ್ನು ಬದಲಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು PHP ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಒಂದು ರಚನೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು ಮತ್ತು ಅರ್ಧದಾರಿಯಲ್ಲೇ ಇನ್ನೊಂದನ್ನು ಬದಲಿಸುವ ಮೂಲಕ ಮುಂದುವರಿಸಬಹುದು. ಅಥವಾ ರಚನೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ, ನಂತರ ಅದನ್ನು ವಸ್ತುವಿನೊಂದಿಗೆ ಬದಲಾಯಿಸಿ:
$arr = ; $obj = (ವಸ್ತು) ; $ref =& $arr; foreach ($ref ಎಂದು $val) (ಪ್ರತಿಧ್ವನಿ "$val\n"; ವೇಳೆ ($val == 3) ($ref = $obj; ) ) /* ಔಟ್ಪುಟ್: 1 2 3 6 7 8 9 10 */
ನೀವು ನೋಡುವಂತೆ, ಬದಲಿ ಸಂಭವಿಸಿದ ತಕ್ಷಣ PHP ಇತರ ಘಟಕವನ್ನು ಸರಳವಾಗಿ ಚಲಿಸಲು ಪ್ರಾರಂಭಿಸಿತು.
ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು
ನಾನು ಉಲ್ಲೇಖಿಸದ foreach ನಡವಳಿಕೆಯ ಕೊನೆಯ ವಿವರ (ಏಕೆಂದರೆ ಅದನ್ನು ಪಡೆಯಲು ಬಳಸಬಹುದು ನಿಜವಾಗಿಯೂ ವಿಚಿತ್ರ ವರ್ತನೆ): ನೀವು ಲೂಪ್ ಸಮಯದಲ್ಲಿ ಆಂತರಿಕ ರಚನೆಯ ಪಾಯಿಂಟರ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಏನಾಗಬಹುದು.
ಇಲ್ಲಿ ನೀವು ನಿರೀಕ್ಷಿಸಿದ್ದನ್ನು ನೀವು ಪಡೆಯದಿರಬಹುದು: ನೀವು ಲೂಪ್ನ ದೇಹದಲ್ಲಿ ಮುಂದಿನ ಅಥವಾ ಹಿಂದಿನ ಕರೆ ಮಾಡಿದರೆ (ಉಲ್ಲೇಖದ ಮೂಲಕ ಹಾದುಹೋಗುವ ಸಂದರ್ಭದಲ್ಲಿ), ಆಂತರಿಕ ಪಾಯಿಂಟರ್ ಚಲಿಸಿರುವುದನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ, ಆದರೆ ಇದು ನಡವಳಿಕೆಯ ಮೇಲೆ ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ ಪುನರಾವರ್ತಕ. ಕಾರಣವೇನೆಂದರೆ, ಲೂಪ್ನ ಪ್ರತಿ ಪಾಸ್‌ನ ನಂತರ ಹ್ಯಾಶ್‌ಪಾಯಿಂಟರ್‌ನಲ್ಲಿನ ಪ್ರಸ್ತುತ ಸ್ಥಾನ ಮತ್ತು ಹ್ಯಾಶ್‌ನ ಪ್ರಸ್ತುತ ಅಂಶದ ಬ್ಯಾಕ್‌ಅಪ್ ಅನ್ನು foreach ಮಾಡುತ್ತದೆ. ಮುಂದಿನ ಪಾಸ್‌ನಲ್ಲಿ, ಆಂತರಿಕ ಪಾಯಿಂಟರ್ನ ಸ್ಥಾನವು ಬದಲಾಗಿದೆಯೇ ಎಂದು ನೋಡಲು foreach ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಈ ಹ್ಯಾಶ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಮರುಸ್ಥಾಪಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ.
"ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ" ಎಂದರೆ ಏನು ಎಂದು ನೋಡೋಣ. ಆಂತರಿಕ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸುವುದು ಫೋರ್ಚ್ ಮೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಮೊದಲ ಉದಾಹರಣೆ ತೋರಿಸುತ್ತದೆ:
$ ರಚನೆ = ; $ref =& $array; foreach ($array as $value) (var_dump($value); ಮರುಹೊಂದಿಸಿ($array); ) // ಔಟ್ಪುಟ್: 1, 2, 3, 4, 5
ಈಗ ಮೊದಲ ಪಾಸ್‌ನಲ್ಲಿ (ಕೀ 1) ಪ್ರವೇಶಿಸುವ ಅಂಶವನ್ನು ಅನ್ಸೆಟ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸೋಣ:
$ ರಚನೆ = ; $ref =& $array; foreach ($array as $value) (var_dump($value); unset($array); ಮರುಹೊಂದಿಸಿ($array); ) // output: 1, 1, 3, 4, 5
ಇಲ್ಲಿ ನೀವು ಕೌಂಟರ್ ಅನ್ನು ಮರುಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ನೋಡುತ್ತೀರಿ ಏಕೆಂದರೆ ಹೊಂದಾಣಿಕೆಯ ಹ್ಯಾಶ್ ಹೊಂದಿರುವ ಅಂಶವು ಕಂಡುಬಂದಿಲ್ಲ.
ನೆನಪಿನಲ್ಲಿಡಿ, ಹ್ಯಾಶ್ ಕೇವಲ ಹ್ಯಾಶ್ ಆಗಿದೆ. ಘರ್ಷಣೆಗಳು ಸಂಭವಿಸುತ್ತವೆ. ಈಗ ಇದನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:
$array = ["EzEz" => 1, "EzFY" => 2, "FYEz" => 3]; $ref =& $array; foreach ($array as $value) (unset($array["EzFY"]); $array["FYFZ"] = 4; reset($array); var_dump($value); ) // ಔಟ್ಪುಟ್: 1 1 3 4
ನಾವು ನಿರೀಕ್ಷಿಸಿದಂತೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ನಾವು EzFY ಕೀಯನ್ನು ತೆಗೆದುಹಾಕಿದ್ದೇವೆ (ಫೋರ್ಚ್ ಇರುವ ಸ್ಥಳ), ಆದ್ದರಿಂದ ಮರುಹೊಂದಿಕೆಯನ್ನು ಮಾಡಲಾಗಿದೆ. ನಾವು ಹೆಚ್ಚುವರಿ ಕೀಲಿಯನ್ನು ಕೂಡ ಸೇರಿಸಿದ್ದೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಕೊನೆಯಲ್ಲಿ 4 ಅನ್ನು ನೋಡುತ್ತೇವೆ.
ಮತ್ತು ಇಲ್ಲಿ ಅಜ್ಞಾತ ಬರುತ್ತದೆ. ನೀವು FYFY ಕೀಯನ್ನು FYFZ ನೊಂದಿಗೆ ಬದಲಾಯಿಸಿದರೆ ಏನಾಗುತ್ತದೆ? ಪ್ರಯತ್ನಿಸೋಣ:
$array = ["EzEz" => 1, "EzFY" => 2, "FYEz" => 3]; $ref =& $array; foreach ($array as $value) (unset($array["EzFY"]); $array["FYFY"] = 4; reset($array); var_dump($value); ) // ಔಟ್ಪುಟ್: 1 4
ಈಗ ಲೂಪ್ ನೇರವಾಗಿ ಹೊಸ ಅಂಶಕ್ಕೆ ಸ್ಥಳಾಂತರಗೊಂಡಿದೆ, ಎಲ್ಲವನ್ನೂ ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಏಕೆಂದರೆ FYFY ಕೀಯು EzFY ನೊಂದಿಗೆ ಘರ್ಷಣೆಯನ್ನು ಹೊಂದಿದೆ (ವಾಸ್ತವವಾಗಿ, ಈ ರಚನೆಯ ಎಲ್ಲಾ ಕೀಗಳು ಕೂಡ). ಇದಲ್ಲದೆ, FYFY ಅಂಶವು ಈಗಷ್ಟೇ ಅಳಿಸಲಾದ EzFY ಅಂಶದಂತೆಯೇ ಅದೇ ಮೆಮೊರಿ ವಿಳಾಸದಲ್ಲಿದೆ. ಆದ್ದರಿಂದ PHP ಗಾಗಿ ಅದು ಅದೇ ಹ್ಯಾಶ್‌ನೊಂದಿಗೆ ಅದೇ ಸ್ಥಾನವಾಗಿರುತ್ತದೆ. ಸ್ಥಾನವನ್ನು "ಮರುಸ್ಥಾಪಿಸಲಾಗಿದೆ" ಮತ್ತು ರಚನೆಯ ಅಂತ್ಯಕ್ಕೆ ಪರಿವರ್ತನೆ ಸಂಭವಿಸುತ್ತದೆ.
ಸಾಮಾನ್ಯವಾಗಿ ನೀವು PHP ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೂಲಕ ಪುನರಾವರ್ತನೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಅಂಶದ ಮೇಲೆ ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕು. ಉದಾಹರಣೆಗೆ, ನೀವು ಪ್ರತಿ ಮೌಲ್ಯವನ್ನು HTML ಟೇಬಲ್‌ಗೆ ಔಟ್ಪುಟ್ ಮಾಡಬಹುದು ಅಥವಾ ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಹೊಸ ಮೌಲ್ಯವನ್ನು ನೀಡಬಹುದು.
ಈ ಪಾಠದಲ್ಲಿ ನಾವು ಸೂಚ್ಯಂಕ ಮತ್ತು ಸಂಬಂಧಿತ ಅರೇಗಳ ಮೇಲೆ ಲೂಪ್ ಅನ್ನು ಆಯೋಜಿಸುವಾಗ ಫೋರ್ಚ್ ರಚನೆಯನ್ನು ನೋಡುತ್ತೇವೆ.
ಅಂಶ ಮೌಲ್ಯಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಿ
ಸೂಚ್ಯಂಕ ಶ್ರೇಣಿಯಲ್ಲಿನ ಮೌಲ್ಯಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡುವುದು ಫೋರ್ಚ್‌ಗೆ ಸರಳವಾದ ಬಳಕೆಯ ಸಂದರ್ಭವಾಗಿದೆ. ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್:
Foreach ($array as $value) (// $value ನೊಂದಿಗೆ ಏನಾದರೂ ಮಾಡಿ) // ಇಲ್ಲಿ ಲೂಪ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ
ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಸೂಚ್ಯಂಕದ ರಚನೆಯಲ್ಲಿ ನಿರ್ದೇಶಕರ ಪಟ್ಟಿಯ ಮೂಲಕ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಯೊಂದರ ಹೆಸರನ್ನು ಮುದ್ರಿಸುತ್ತದೆ:
$ನಿರ್ದೇಶಕರು = ವ್ಯೂಹ("ಆಲ್ಫ್ರೆಡ್ ಹಿಚ್ಕಾಕ್", "ಸ್ಟಾನ್ಲಿ ಕುಬ್ರಿಕ್", "ಮಾರ್ಟಿನ್ ಸ್ಕಾರ್ಸೆಸೆ", "ಫ್ರಿಟ್ಜ್ ಲ್ಯಾಂಗ್"); foreach ($ನಿರ್ದೇಶಕರು $director) (ಪ್ರತಿಧ್ವನಿ $director . "
";
}
ಮೇಲಿನ ಕೋಡ್ ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ:
ಆಲ್ಫ್ರೆಡ್ ಹಿಚ್ಕಾಕ್ ಸ್ಟಾನ್ಲಿ ಕುಬ್ರಿಕ್ ಮಾರ್ಟಿನ್ ಸ್ಕಾರ್ಸೆಸೆ ಫ್ರಿಟ್ಜ್ ಲ್ಯಾಂಗ್
ಕೀ-ಮೌಲ್ಯ ಲೂಪ್
ಸಂಬಂಧಿತ ಸರಣಿಗಳ ಬಗ್ಗೆ ಏನು? ಈ ಪ್ರಕಾರದ ರಚನೆಯನ್ನು ಬಳಸುವಾಗ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿ ಅಂಶದ ಕೀ ಮತ್ತು ಅದರ ಮೌಲ್ಯಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರಬೇಕು. ಫೋರ್ಚ್ ರಚನೆಯು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಹೊಂದಿದೆ:
Foreach ($array as $key => $value) (// $key ಮತ್ತು/ಅಥವಾ $value ನೊಂದಿಗೆ ಏನನ್ನಾದರೂ ಮಾಡಿ) // ಇಲ್ಲಿ ಲೂಪ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ
ಚಲನಚಿತ್ರಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯೊಂದಿಗೆ ಸಂಯೋಜಿತ ರಚನೆಯ ಮೂಲಕ ಲೂಪ್ ಅನ್ನು ಸಂಘಟಿಸುವ ಉದಾಹರಣೆ, ಪ್ರತಿ ಅಂಶದ ಕೀಲಿಯನ್ನು ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಗಳ HTML ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರದರ್ಶಿಸುತ್ತದೆ:
$ಚಲನಚಿತ್ರ = ವ್ಯೂಹ("ಶೀರ್ಷಿಕೆ" => "ಹಿಂದಿನ ಕಿಟಕಿ", "ನಿರ್ದೇಶಕ" => "ಆಲ್ಫ್ರೆಡ್ ಹಿಚ್ಕಾಕ್", "ವರ್ಷ" => 1954, "ನಿಮಿಷಗಳು" => 112); ಪ್ರತಿಧ್ವನಿ "
- "; foreach ($ಚಲನಚಿತ್ರ $key => $value) (ಪ್ರತಿಧ್ವನಿ "
- $ಕೀ: "; ಪ್ರತಿಧ್ವನಿ"
- $ಮೌಲ್ಯ ";) ಪ್ರತಿಧ್ವನಿ"
ಕಾರ್ಯಗತಗೊಳಿಸಿದಾಗ, ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ:
ಶೀರ್ಷಿಕೆ: ಹಿಂದಿನ ಕಿಟಕಿಯ ನಿರ್ದೇಶಕ: ಆಲ್ಫ್ರೆಡ್ ಹಿಚ್ಕಾಕ್ ವರ್ಷ: 1954 ನಿಮಿಷಗಳು: 112
ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವುದು
ಲೂಪ್ ಹಾದು ಹೋದಂತೆ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವ ಬಗ್ಗೆ ಏನು? ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಬಹುದು:
Foreach ($myArray ಅನ್ನು $ಮೌಲ್ಯವಾಗಿ) ($value = 123;)
ಆದಾಗ್ಯೂ, ನೀವು ಅದನ್ನು ಚಲಾಯಿಸಿದರೆ, ರಚನೆಯಲ್ಲಿನ ಮೌಲ್ಯಗಳನ್ನು ನೀವು ಕಾಣಬಹುದು ಬದಲಾಯಿಸಬೇಡಿ. ಕಾರಣ foreach ಕೆಲಸ ಮಾಡುತ್ತದೆ ಒಂದು ಪ್ರತಿರಚನೆಯ ಮೌಲ್ಯಗಳು, ಮೂಲದೊಂದಿಗೆ ಅಲ್ಲ. ಈ ರೀತಿಯಾಗಿ ಮೂಲ ರಚನೆಯು ಹಾಗೇ ಉಳಿಯುತ್ತದೆ.
ರಚನೆಯ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲು ನಿಮಗೆ ಅಗತ್ಯವಿರುತ್ತದೆ ಲಿಂಕ್ಅರ್ಥಕ್ಕೆ. ಇದನ್ನು ಮಾಡಲು, ನೀವು foreach ಕನ್‌ಸ್ಟ್ರಕ್ಟ್‌ನಲ್ಲಿ ಮೌಲ್ಯ ವೇರಿಯೇಬಲ್‌ನ ಮುಂದೆ & ಚಿಹ್ನೆಯನ್ನು ಹಾಕಬೇಕು:
Foreach ($myArray &$value) ($value = 123; )
ಉದಾಹರಣೆಗೆ, ಈ ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ $ಡೈರೆಕ್ಟರ್ಸ್ ಅರೇಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಅಂಶದ ಮೂಲಕ (ನಿರ್ದೇಶಕರ ಹೆಸರು) ಲೂಪ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಹೆಸರುಗಳನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸಲು PHP ಎಕ್ಸ್‌ಪ್ಲೋಡ್() ಕಾರ್ಯ ಮತ್ತು ಪಟ್ಟಿಯ ರಚನೆಯನ್ನು ಬಳಸುತ್ತದೆ:
$ನಿರ್ದೇಶಕರು = ವ್ಯೂಹ("ಆಲ್ಫ್ರೆಡ್ ಹಿಚ್ಕಾಕ್", "ಸ್ಟಾನ್ಲಿ ಕುಬ್ರಿಕ್", "ಮಾರ್ಟಿನ್ ಸ್ಕಾರ್ಸೆಸೆ", "ಫ್ರಿಟ್ಜ್ ಲ್ಯಾಂಗ್"); // ಪ್ರತಿ ಎಲಿಮೆಂಟ್ ಫೋರ್ಚ್‌ಗಾಗಿ ಹೆಸರಿನ ಸ್ವರೂಪವನ್ನು ಬದಲಾಯಿಸಿ ($ನಿರ್ದೇಶಕರು &$ನಿರ್ದೇಶಕ) (ಪಟ್ಟಿ($ಮೊದಲ ಹೆಸರು, $lastName) = ಸ್ಫೋಟ (" ", $director); $director = "$lastName, $firstName"; ) ಹೊಂದಿಸಲಾಗಿಲ್ಲ ($ನಿರ್ದೇಶಕ); // ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸಿ ($ನಿರ್ದೇಶಕರು $ನಿರ್ದೇಶಕರಾಗಿ) (ಪ್ರತಿಧ್ವನಿ $director . "
";
}
ಸ್ಕ್ರಿಪ್ಟ್ ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ:
ಹಿಚ್ಕಾಕ್, ಆಲ್ಫ್ರೆಡ್ ಕುಬ್ರಿಕ್, ಸ್ಟಾನ್ಲಿ ಸ್ಕೋರ್ಸೆಸೆ, ಮಾರ್ಟಿನ್ ಲ್ಯಾಂಗ್, ಫ್ರಿಟ್ಜ್
ಮೊದಲ ಲೂಪ್ ಪೂರ್ಣಗೊಂಡ ನಂತರ $director ವೇರಿಯೇಬಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ಸೆಟ್() ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಂತರ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬೇರೆ ಸಂದರ್ಭದಲ್ಲಿ ಬಳಸಲು ನೀವು ಯೋಜಿಸಿದರೆ ಇದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ.
ನೀವು ಉಲ್ಲೇಖವನ್ನು ತೆಗೆದುಹಾಕದಿದ್ದರೆ, ನೀವು $ ಡೈರೆಕ್ಟರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸಿದರೆ, ಅರೇ ("ಲ್ಯಾಂಗ್, ಫ್ರಿಟ್ಜ್") ನಲ್ಲಿನ ಕೊನೆಯ ಅಂಶವನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಉಲ್ಲೇಖಿಸುವ ಕೋಡ್ ಅನ್ನು ಮತ್ತಷ್ಟು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಪಾಯವನ್ನು ನೀವು ಎದುರಿಸುತ್ತೀರಿ, ಇದು ಅನಪೇಕ್ಷಿತ ಪರಿಣಾಮಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ!
ಪುನರಾರಂಭಿಸಿ
ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ರಚನೆಯ ಅಂಶಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಲು PHP ಫೋರ್ಚ್ ರಚನೆಯನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ನಾವು ನೋಡಿದ್ದೇವೆ. ಕೆಳಗಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗಿದೆ:
- ಅರೇ ಅಂಶಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡುವುದು ಹೇಗೆ
- ಪ್ರತಿ ಅಂಶದ ಕೀ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸುವುದು
- ನೀವು ಲೂಪ್ ಮೂಲಕ ಹೋಗುವಾಗ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲು ಉಲ್ಲೇಖವನ್ನು ಹೇಗೆ ಬಳಸುವುದು
ನೀವು ಪುನರಾವರ್ತಿಸಲು ಬಯಸುವ ಸಹಾಯಕ ರಚನೆಯನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. PHP Foreach ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರಣಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಬಳಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಸರಳ ಭಾಷೆಯಲ್ಲಿ ಇದು ಈ ರೀತಿ ಧ್ವನಿಸುತ್ತದೆ:
"ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ರಚನೆಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕಾಗಿ, ಈ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ."
ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವವರೆಗೆ ಅದು ಮುಂದುವರಿಯುತ್ತದೆ, ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಹಾದುಹೋಗುವವರೆಗೆ ಫೋರ್ಚ್ ಲೂಪ್ ಮುಂದುವರಿಯುತ್ತದೆ.
PHP Foreach: ಉದಾಹರಣೆ
ನಮ್ಮ ಕಂಪನಿಯಲ್ಲಿನ ಜನರ ಹೆಸರುಗಳು ಮತ್ತು ಅವರ ವಯಸ್ಸನ್ನು ಸಂಗ್ರಹಿಸುವ ಸಹಾಯಕ ಶ್ರೇಣಿಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಪ್ರತಿಯೊಬ್ಬ ಉದ್ಯೋಗಿಯ ವಯಸ್ಸು ಎಷ್ಟು ಎಂದು ತಿಳಿಯಲು ನಾವು ಬಯಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ಪ್ರತಿಯೊಬ್ಬರ ಹೆಸರು ಮತ್ತು ವಯಸ್ಸನ್ನು ಮುದ್ರಿಸಲು ನಾವು ಪ್ರತಿ ಲೂಪ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
$employeeAges; $employeeAges["ಲಿಸಾ"] = "28"; $employeeAges["ಜ್ಯಾಕ್"] = "16"; $employeeAges["Ryan"] = "35"; $employeeAges["ರಾಚೆಲ್"] = "46"; $employeeAges["ಗ್ರೇಸ್"] = "34"; foreach($employeeAges as $key => $value)( ಪ್ರತಿಧ್ವನಿ "ಹೆಸರು: $key, ವಯಸ್ಸು: $value
";
}
ನಾವು ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ:
ಹೆಸರು: ಲಿಸಾ, ವಯಸ್ಸು: 28 ಹೆಸರು: ಜ್ಯಾಕ್, ವಯಸ್ಸು: 16 ಹೆಸರು: ರಯಾನ್, ವಯಸ್ಸು: 35 ಹೆಸರು: ರಾಚೆಲ್, ವಯಸ್ಸು: 46 ಹೆಸರು: ಗ್ರೇಸ್, ವಯಸ್ಸು: 34
ಸರಿ, ಫಲಿತಾಂಶವು ಒಳ್ಳೆಯದು ಮತ್ತು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ, ಆದರೆ ಫೋರ್ಚ್ ರಚನೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ತುಂಬಾ ಸುಲಭ ಮತ್ತು ಅರ್ಥವಾಗುವುದಿಲ್ಲ. ಅದನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡೋಣ.
ಪ್ರತಿ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗೆ: $something as $key => $value
ಈ ಎಲ್ಲಾ ಹುಚ್ಚುತನವು ಸ್ಥೂಲವಾಗಿ ಹೀಗೆ ಅನುವಾದಿಸುತ್ತದೆ: “$employeeAges ಸಹಾಯಕ ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶಕ್ಕಾಗಿ, ನಾನು $key ಮತ್ತು ಅದರಲ್ಲಿರುವ ಮೌಲ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸುತ್ತೇನೆ, ಅಂದರೆ $value.
"=>" ಆಪರೇಟರ್ ಕೀ ಮತ್ತು ಮೌಲ್ಯದ ನಡುವಿನ ಸಂಬಂಧವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಅವುಗಳನ್ನು ಕೀ - $ ಕೀ ಮತ್ತು ಮೌಲ್ಯ - $ ಮೌಲ್ಯ ಎಂದು ಹೆಸರಿಸಿದ್ದೇವೆ. ಆದಾಗ್ಯೂ, ಅವುಗಳನ್ನು ಹೆಸರು ಮತ್ತು ವಯಸ್ಸು ಎಂದು ಯೋಚಿಸುವುದು ಸುಲಭವಾಗುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ಕೆಳಗೆ ನಾವು ಇದನ್ನು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಫಲಿತಾಂಶವು ಒಂದೇ ಆಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಏಕೆಂದರೆ ನಾವು ಕೀಗಳು ಮತ್ತು ಮೌಲ್ಯಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ವೇರಿಯೇಬಲ್‌ಗಳ ಹೆಸರನ್ನು ಮಾತ್ರ ಬದಲಾಯಿಸಿದ್ದೇವೆ.
$employeeAges; $employeeAges["ಲಿಸಾ"] = "28"; $employeeAges["ಜ್ಯಾಕ್"] = "16"; $employeeAges["Ryan"] = "35"; $employeeAges["ರಾಚೆಲ್"] = "46"; $employeeAges["ಗ್ರೇಸ್"] = "34"; foreach($employeeAges as $name => $age)( ಪ್ರತಿಧ್ವನಿ "ಹೆಸರು: $ಹೆಸರು, ವಯಸ್ಸು: $age
";
}
ಸರಿ, ಫಲಿತಾಂಶ, ನಾವು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ, ಒಂದೇ ಆಗಿರುತ್ತದೆ.
