ಕರೆ ಮಾಡುವಾಗ ಹೆಸರಿಸಲಾದ ಐಚ್ಛಿಕ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು PHP 4/5 ನಲ್ಲಿ ಸಾಧ್ಯವೇ, ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಬಯಸದ (ಪೈಥಾನ್‌ನಲ್ಲಿರುವಂತೆ) ಸ್ಕಿಪ್ ಮಾಡಬಹುದೇ?

ಫಂಕ್ಷನ್ ಫೂ($a,$b="", $c="") (//ಯಾವುದಾದರೂ) ಫೂ("ಹಲೋ", $ಸಿ="ಬಾರ್"); // ನಮಗೆ $b ಡೀಫಾಲ್ಟ್ ಆಗಿ ಬೇಕು, ಆದರೆ $c ಅನ್ನು ಸೂಚಿಸಿ

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

ಒಂದು "ಪರಿಹಾರ" ಕೇವಲ ಒಂದು ಪ್ಯಾರಾಮೀಟರ್, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಳಸುವುದು ಮತ್ತು ಅದನ್ನು ಯಾವಾಗಲೂ ರವಾನಿಸುವುದು ... ಆದರೆ ಯಾವಾಗಲೂ ಅದರಲ್ಲಿರುವ ಎಲ್ಲವನ್ನೂ ವ್ಯಾಖ್ಯಾನಿಸಬೇಡಿ.

ಫಂಕ್ಷನ್ ಫೂ ($ ಪ್ಯಾರಮ್ಸ್) (ವರ್_ಡಂಪ್ ($ ಪ್ಯಾರಮ್ಸ್); )

ಮತ್ತು ಇದನ್ನು ಈ ರೀತಿ ಕರೆಯುವುದು:

ಫೂ(ಅರೇ("ಎ" => "ಹಲೋ",)); foo ("a" => "ಹಲೋ", "c" => "glop",)); foo ("a" => "ಹಲೋ", "test" => "ಇನ್ನೊಂದು",));

ನಿಮಗೆ ಈ ಔಟ್‌ಪುಟ್ ಸಿಗುತ್ತದೆ:

ಅರೇ "a" => ಸ್ಟ್ರಿಂಗ್ "ಹಲೋ" (ಉದ್ದ = 5) ಅರೇ "a" => ಸ್ಟ್ರಿಂಗ್ "ಹಲೋ" (ಉದ್ದ = 5) "c" => ಸ್ಟ್ರಿಂಗ್ "ಗ್ಲೋಪ್" (ಉದ್ದ = 4) ಅರೇ "a" => ಸ್ಟ್ರಿಂಗ್ "ಹಲೋ" (ಉದ್ದ = 5) "ಪರೀಕ್ಷೆ" => ಸ್ಟ್ರಿಂಗ್ "ಇನ್ನೊಂದು" (ಉದ್ದ = 11)

ಆದರೆ ನಾನು ಈ ಪರಿಹಾರವನ್ನು ನಿಜವಾಗಿಯೂ ಇಷ್ಟಪಡುವುದಿಲ್ಲ:

• ನೀವು phpdoc ಅನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತೀರಿ
• ನಿಮ್ಮ IDE ಇನ್ನು ಮುಂದೆ ಯಾವುದೇ ಸುಳಿವು ನೀಡಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ… ಯಾವುದು ಕೆಟ್ಟದು

ಹಾಗಾಗಿ ನಾನು ಇದನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಮಾತ್ರ ಹೋಗುತ್ತೇನೆ - ಸಾಕಷ್ಟು ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿರುವ ಕಾರ್ಯಗಳಿಗಾಗಿ, ಉದಾಹರಣೆಗೆ…

ಇಲ್ಲ, PHP ಹೆಸರಿನ ಮೂಲಕ ವಾದಗಳನ್ನು ರವಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

ನೀವು ಬಹಳಷ್ಟು ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಕಾರ್ಯವನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಅವೆಲ್ಲವೂ ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ನೀವು ಕಾರ್ಯವನ್ನು ವಾದಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸ್ವೀಕರಿಸುವಂತೆ ಮಾಡುವುದನ್ನು ಪರಿಗಣಿಸಬಹುದು:

ಕಾರ್ಯ ಪರೀಕ್ಷೆ ($ args ರಚನೆ) ( $defaults = array("a" => "", "b" => "", "c" => ""); $args = array_merge($defaults, array_intersect_key($args) , $ಡಿಫಾಲ್ಟ್‌ಗಳು); ಪಟ್ಟಿ($a, $b, $c) = array_values ​​($args); // ನೀವು ಈಗ $a, $b ಅನ್ನು ಬಳಸಬಹುದು , $c)

ನೀವು ಅದನ್ನು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಮಾಡಬಹುದಾದ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ ಹೆಸರಿಸಲಾದ ಕೀಲಿಗಳೊಂದಿಗೆ ಅರೇಗಳನ್ನು ಬಳಸುವುದು ಮತ್ತು ಯಾವುದು ಅಲ್ಲ.

PHP ಯೊಂದಿಗೆ, ವಾದಗಳ ಕ್ರಮವು ಮುಖ್ಯವಾಗಿದೆ. ನೀವು ನಿರ್ದಿಷ್ಟ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಸ್ಥಳದಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಬದಲಿಗೆ, ನೀವು NULL ಅನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು, ಅಲ್ಲಿಯವರೆಗೆ ನೀವು NULL ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ನಿಮ್ಮ ಕಾರ್ಯದಲ್ಲಿನ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಿಸುವುದಿಲ್ಲ.

ಫೂ("ಹಲೋ", NULL, "ಬಾರ್");

PHP 5.4 ರಂತೆ ನೀವು ಶಾರ್ಟ್‌ಹ್ಯಾಂಡ್ ಅರೇ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೊಂದಿದ್ದೀರಿ (ತೊಡಕಿನ "ಅರೇ" ನೊಂದಿಗೆ ಸರಣಿಗಳನ್ನು ಸೂಚಿಸಲು ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಬದಲಿಗೆ "" ಅನ್ನು ಬಳಸಿ).

ನೀವು ಹೆಸರಿನ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹಲವು ವಿಧಗಳಲ್ಲಿ ಅನುಕರಿಸಬಹುದು, ಒಂದು ಉತ್ತಮ ಮತ್ತು ಸರಳ ಮಾರ್ಗ ಹೀಗಿರಬಹುದು:

ಬಾರ್("ಒಂದು", ["a1" => "ಎರಡು", "ಬಾರ್" => "ಮೂರು", "ಫೂ" => "ನಾಲ್ಕು"]); // ಔಟ್‌ಪುಟ್: ಎರಡು ಮೂರು ಫಂಕ್ಷನ್ ಬಾರ್ ($a1, $kwargs = ["bar" => null, "foo" => null]) ( ಸಾರ ($kwargs); ಪ್ರತಿಧ್ವನಿ $a1; ಪ್ರತಿಧ್ವನಿ $bar; ಪ್ರತಿಧ್ವನಿ $foo; )

ಇದು ನಿಖರವಾಗಿ ಸುಂದರವಾಗಿಲ್ಲ, ಆದರೆ ಇದು ಟ್ರಿಕ್ ಮಾಡುತ್ತದೆ, ಕೆಲವರು ಹೇಳಬಹುದು.

ವರ್ಗ ನೇಮ್ಡ್ ಆರ್ಗ್ಯುಮೆಂಟ್ಸ್ ( ಸ್ಟ್ಯಾಟಿಕ್ ಫಂಕ್ಷನ್ init($args) ($assoc = ಮರುಹೊಂದಿಸಿ($args); ವೇಳೆ (is_array($assoc)) ($diff = array_diff(array_keys($assoc), array_keys($args)); ವೇಳೆ (ಖಾಲಿ ($diff)) trigger_error("ಅಮಾನ್ಯ ನಿಯತಾಂಕಗಳು: ".join(","$diff), E_USER_ERROR ರಿಟರ್ನ್ ಅರೇ()) ) ವರ್ಗ ಪರೀಕ್ಷೆ (ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಕಾರ್ಯ ಫೂಬಾರ್($ಅಗತ್ಯವಿದೆ, $ಐಚ್ಛಿಕ1); "", $optional2 = "") ( Extract(NamedArguments::init(get_defined_vars())); printf("ಅಗತ್ಯವಿದೆ: %s, ಐಚ್ಛಿಕ1: %s, ಐಚ್ಛಿಕ2: %s\n", $ಅವಶ್ಯಕ, $ಐಚ್ಛಿಕ1, $optional2 ) ) ಪರೀಕ್ಷೆ :: foobar("ಅಗತ್ಯವಿದೆ", "ಐಚ್ಛಿಕ1", "ಐಚ್ಛಿಕ2"); ಪರೀಕ್ಷೆ:: ಫೂಬಾರ್(ಅರೇ("ಅಗತ್ಯವಿದೆ" => "ಅಗತ್ಯವಿದೆ", "ಐಚ್ಛಿಕ1" => "ಐಚ್ಛಿಕ1", "ಐಚ್ಛಿಕ2" => "ಐಚ್ಛಿಕ2"));

ರಚನೆಯ ಬದಲಿಗೆ ವಸ್ತುವನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ನೀವು phpdoc ಮತ್ತು ಡೀಫಾಲ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಇಟ್ಟುಕೊಳ್ಳಬಹುದು, ಉದಾ.

ವರ್ಗ FooOptions ( $opt1 = "x"; $opt2 = "y"; /* ಇತ್ಯಾದಿ */ );

ನೀವು ಬಯಸಿದರೆ, ನಿಮ್ಮ ಫಂಕ್ಷನ್ ಕರೆಯಲ್ಲಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೈಪ್ ಚೆಕ್ ಮಾಡಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ:

ಫಂಕ್ಷನ್ ಫೂ(FooOptions $opts) (... )

ಸಹಜವಾಗಿ, FooOptions ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಹೊಂದಿಸುವ ಹೆಚ್ಚುವರಿ ವಾಕ್ಚಾತುರ್ಯದೊಂದಿಗೆ ನೀವು ಪಾವತಿಸಬಹುದು. ದುರದೃಷ್ಟವಶಾತ್ ಯಾವುದೇ ಸಂಪೂರ್ಣ ಉಚಿತ ಸವಾರಿ ಇಲ್ಲ.

ಸಾಮಾನ್ಯವಾಗಿ ನಿಮಗೆ ಸಾಧ್ಯವಿಲ್ಲ ಆದರೆ PHP ಫಂಕ್ಷನ್‌ಗೆ ಹೆಸರಿಸಲಾದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಲು ಸಾಕಷ್ಟು ಮಾರ್ಗಗಳಿವೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ವೈಯಕ್ತಿಕವಾಗಿ ನಾನು ಸರಣಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ವ್ಯಾಖ್ಯಾನವನ್ನು ಪ್ರಸಾರ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ನಾನು ರವಾನಿಸಬೇಕಾದದ್ದನ್ನು ಕರೆ ಮಾಡಿ:

ವರ್ಗ ಪರೀಕ್ಷೆ(ಸಾರ್ವಜನಿಕ $a = ತಪ್ಪು; ಖಾಸಗಿ $b = ತಪ್ಪು; ಸಾರ್ವಜನಿಕ $c = ತಪ್ಪು; ಸಾರ್ವಜನಿಕ $d = ತಪ್ಪು; ಸಾರ್ವಜನಿಕ $e = ತಪ್ಪು; ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ _factory())( $args = func_get_args(); $args = $this->a = array_key_exists ("a",$args) : 0; $this->b = array_key_exists this->c = array_key_exists ("c",$args) : 0; $this->d = array_key_exists ("d",$args) ? >e = array_key_exists ("e",$args) ? 0; ) ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪ್ರದರ್ಶನ $args["c"]=999; $test->_factory($args); $ಪರೀಕ್ಷೆ->ಶೋ();

ನಾನು 10 ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಬೇಕಾದರೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ 3 ನನಗೆ ನಿಜವಾಗಿಯೂ ಅಗತ್ಯವಿರುವ ಡೇಟಾವಾಗಿದ್ದರೆ, ಈ ರೀತಿಯ ಕಾರ್ಯವನ್ನು ರವಾನಿಸಲು ಸಹ ಸ್ಮಾರ್ಟ್ ಅಲ್ಲ

ನನ್ನ ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸಿ (ತಪ್ಪು, ತಪ್ಪು, 10, ತಪ್ಪು, ತಪ್ಪು, "ದಿನಾಂಕ", ತಪ್ಪು, ತಪ್ಪು, ತಪ್ಪು, "ಡೆಸ್ಕ್");

ನಾನು ನೀಡುತ್ತಿರುವ ವಿಧಾನದೊಂದಿಗೆ, ನೀವು 10 ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ಒಂದು ಶ್ರೇಣಿಗೆ ಹೊಂದಿಸಬಹುದು:

$arr["count"]=10; $arr["ಟೈಪ್"]="ದಿನಾಂಕ"; $arr["ಆರ್ಡರ್"]="desc"; ರಿಟರ್ನ್ ಮೈಫಂಕ್ಷನ್ ($arr);

ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸುವ ಪೋಸ್ಟ್ ಅನ್ನು ನನ್ನ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ನಾನು ಹೊಂದಿದ್ದೇನೆ.

ನಾನು ಬಳಸುತ್ತಿರುವುದು ಇಲ್ಲಿದೆ. ಒಂದು ಫಂಕ್ಷನ್ ವ್ಯಾಖ್ಯಾನವು ಐಚ್ಛಿಕ ಹೆಸರಿನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಒಂದು ಐಚ್ಛಿಕ ರಚನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ:

ಫಂಕ್ಷನ್ ಫಂಕ್ ($ಆರ್ಗ್, $ಆಯ್ಕೆಗಳು = ಅರೇ()) ($ಡೀಫಾಲ್ಟ್‌ಗಳು = ಅರೇ ("ಫೂ" => 1.0, "ಬಾರ್" => ತಪ್ಪು); $ಆಯ್ಕೆಗಳು = ಅರೇ_ಮರ್ಜ್ ($ಡೀಫಾಲ್ಟ್, $ಆಯ್ಕೆಗಳು); // ಸಾಮಾನ್ಯ ಕಾರ್ಯ ಹೆಸರಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯಲು ಇಲ್ಲಿ $ಆಯ್ಕೆಗಳು["foo"] ಮತ್ತು // $options["bar"] ಬಳಸಿ.

ಯಾವುದೇ ಹೆಸರಿನ ವಾದಗಳಿಲ್ಲದೆ ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಕರೆ ಮಾಡಬಹುದು:

ಫಂಕ್ ("xyzzy")

ಐಚ್ಛಿಕ ಹೆಸರಿನ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು, ಅದನ್ನು ಐಚ್ಛಿಕ ರಚನೆಯಲ್ಲಿ ರವಾನಿಸಿ:

Func("xyzzy", Array("foo" => 5.7))

ಇಲ್ಲ ನಿಜವಾಗಿಯೂ ಅಲ್ಲ. ನೀವು ಬಳಸಬಹುದಾದ ಕೆಲವು ಪರ್ಯಾಯಗಳಿವೆ.

ಪರೀಕ್ಷೆ(ಶೂನ್ಯ, ಶೂನ್ಯ,"ಹಲೋ")

ಅಥವಾ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರವಾನಿಸಿ:

ಪರೀಕ್ಷೆ ("ಸಿ" => "ಹಲೋ"));

ನಂತರ, ಕಾರ್ಯವು ಹೀಗಿರಬಹುದು:

ಕಾರ್ಯ ಪರೀಕ್ಷೆ($ಅರೇ) ($c = isset($array[c]) ? $array[c] : ""; )

ಅಥವಾ ನಡುವೆ ಕಾರ್ಯವನ್ನು ಸೇರಿಸಿ, ಆದರೆ ನಾನು ಇದನ್ನು ಸೂಚಿಸುವುದಿಲ್ಲ:

ಫಂಕ್ಷನ್ ctest($c) (ಪರೀಕ್ಷೆ("","",$c); )

ಕಾರ್ಯ ಪರೀಕ್ಷೆಯನ್ನು ಪ್ರಯತ್ನಿಸಿ ($a="",$b="",&$c="")()

$c ಗಿಂತ ಮೊದಲು ಮತ್ತು ಹಾಕುವುದು

ನಾನು ಹಾಗೆ ಯೋಚಿಸುವುದಿಲ್ಲ ...
ನೀವು ಕರೆ ಮಾಡಬೇಕಾದರೆ, ಉದಾಹರಣೆಗೆ, 3 ಪ್ಯಾರಾಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ substr ಫಂಕ್ಷನ್, ಮತ್ತು $start ಅನ್ನು ಹೊಂದಿಸದೆ $length ಅನ್ನು ಹೊಂದಿಸಲು ಬಯಸಿದರೆ, ನೀವು ಹಾಗೆ ಮಾಡಲು ಒತ್ತಾಯಿಸಲಾಗುತ್ತದೆ.

Substr($str,0,10);

ಇದನ್ನು ಅತಿಕ್ರಮಿಸಲು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ ಯಾವಾಗಲೂ ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಅರೇಗಳನ್ನು ಬಳಸುವುದು

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

ಅಲ್ಲದೆ, ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಬದಲಿಗೆ ಶೂನ್ಯಗಳನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿ ಏಕೆಂದರೆ is_null() ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳ ಅಸ್ತಿತ್ವವನ್ನು ಪರೀಕ್ಷಿಸಲು ಇದು ಹೆಚ್ಚು ಖಚಿತವಾಗಿದೆ.

ಕಾರ್ಯ ಪರೀಕ್ಷೆ ($a=null,$b=null,$c=null)( if (is_null($a) (//$a ಕುರಿತು ಏನಾದರೂ ಮಾಡಿ) ವೇಳೆ (is_null($b) (//$b ಬಗ್ಗೆ ಏನಾದರೂ ಮಾಡಿ ) ವೇಳೆ (is_null($c) (//$c ಬಗ್ಗೆ ಏನಾದರೂ ಮಾಡಿ) )

ಪರೀಕ್ಷೆ (ಶೂನ್ಯ, ಶೂನ್ಯ, "ಹಲೋ");

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

ಫಂಕ್ಷನ್‌ಗಳು ನಿಮ್ಮ ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಕಾಣೆಯಾದ ಒಂದನ್ನು ನೀವೇ ನಿಭಾಯಿಸುವುದರಿಂದ ನಿಮ್ಮ ಸಮಸ್ಯೆಗೆ ಉತ್ತಮ ಪರಿಹಾರವೆಂದರೆ ಬಹುಶಃ 3 ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸುವುದು.

ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳೊಂದಿಗೆ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ರಚಿಸಲು func_get_arg() ಅನ್ನು func_num_args() ಮತ್ತು func_get_args() ಜೊತೆಗೆ ಬಳಸಬಹುದು.

ಬಳಕೆದಾರ ಕೊಡುಗೆ ಟಿಪ್ಪಣಿಗಳು ಬಿಷಪ್
11-ಡಿಸೆಂಬರ್-2004 08:58

ssc dot wisc dot edu ನಲ್ಲಿ dvogel ಗಾಗಿ "ಮುಂದೂಡುವಿಕೆ" ಆಪರೇಟರ್‌ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ನಿಮ್ಮ ವಿಷವನ್ನು ಆರಿಸಿ:

mw ಅಟ್ಟೊ ಲ್ಯಾನ್ಫಿಯರ್ ಡಾಟ್ಟೊ ಕಾಮ್
08-ಡಿಸೆಂಬರ್-2004 01:56

func_get_arg() ಅನ್ನು PHP 5.0.2 (wonk-ay!!!) ನಲ್ಲಿ ಕ್ಲಾಸ್ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗಳೊಳಗೆ ಒಂದು ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಬಳಸಲು ಅನುಮತಿಸುವಂತೆ ತೋರುತ್ತಿಲ್ಲ:

ಮತ್ತು all.php?act=funct&argument= ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ಯಾರಾಮೀಟರ್-ಗುರುತಿಸುವಿಕೆಗಾಗಿ ಟೈಪ್-ಚೆಕಿಂಗ್‌ನಂತಹ ತಂತ್ರಗಳನ್ನು ನೀವು ಮಾಡಬೇಕಾಗಿಲ್ಲ.
04-ಜೂನ್-2004 05:16

ಅಂತಹ "ಸಂಪೂರ್ಣವಾಗಿ ಎಲ್ಲವನ್ನೂ ಮಾಡಿ" ಕಾರ್ಯಗಳ ಅವಶ್ಯಕತೆಯಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ನಾನು ಅವುಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಕ್ಷಿಪ್ರ ಮೂಲಮಾದರಿಯ ಸಾಧನಗಳಾಗಿ ಬಳಸುತ್ತೇನೆ.
ಮತ್ತು ನೀವು ಒಂದು ಕಾರ್ಯಕ್ಕೆ ಹಲವಾರು ತಂತಿಗಳನ್ನು ರವಾನಿಸಲು ಸಾಧ್ಯವಾಗುವ ಒಂದು ವಿಧಾನವಿದೆ: ereg ();
ಅಂತಹ ಕಾರ್ಯಗಳಿಗೆ ಮತ್ತೊಂದು ಬಳಕೆ ಅಲ್ಲಿರುವ ಇತರ ಜನರಿಗೆ ಸ್ವಲ್ಪ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ರಚಿಸುವುದು. ಅವರು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸದಿದ್ದರೆ ಅವರು ಇನ್ನು ಮುಂದೆ ಕಾರ್ಯವನ್ನು ಸಂಪಾದಿಸಬೇಕಾಗಿಲ್ಲ. all.php?act=funct&argument= ಗೆ ಕರೆ ಮಾಡುವಾಗ ಅವರು ಅದನ್ನು ಹೆಸರಿಸುವುದಿಲ್ಲ.
ಇದು ಆಲ್ರೌಂಡರ್ ಫಂಕ್ಷನ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಅದು ಅವರ ಬಳಕೆಯಲ್ಲಿ ಹೆಚ್ಚು ದೃಢವಾಗಿರುತ್ತದೆ. ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಸ್ವಲ್ಪ ಕೋಡ್ ತುಣುಕನ್ನು ಹೊಂದಿರುವಿರಿ (ಉದಾ. IP- ನಿರ್ಬಂಧಿಸುವ ತುಣುಕುಗಳು). ಈ ರೀತಿಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂಲಕ ನೀವು ಸಂಪೂರ್ಣ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ.
26-ಮೇ-2004 08:29

ಬುದ್ಧಿವಂತಿಕೆಯ ಹೊರತು ನೀವು ಒಂದೇ ಪ್ರಕಾರದ ಕನಿಷ್ಠ ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಅಗತ್ಯವಿದೆ - ಯಾವುದು? ನಿಸ್ಸಂಶಯವಾಗಿ, ನೀವು ಕೆಲವು ಡೀಫಾಲ್ಟ್‌ಗಳನ್ನು ನಿರ್ಧರಿಸಬಹುದು, ಆದರೆ ನಂತರ ಇಡೀ ವಿಷಯವು ಕೊಳಕು ಆಗುತ್ತದೆ. ಬೂಲಿಯನ್ ಕೂಡ ಸರಬರಾಜು ಮಾಡಿದರೆ ಮಾತ್ರ ನಿಮಗೆ ಸ್ಟ್ರಿಂಗ್ ಅಗತ್ಯವಿದ್ದರೆ ಏನು? ಟೈಪ್-ಚೆಕಿಂಗ್ ನಿಮ್ಮ ಕಾರ್ಯದ ಮುಖ್ಯ ಕೇಂದ್ರವಾಗಿದೆ, ಶಿಟ್.
ಕ್ಲೀನ್ ಕೋಡ್‌ಗಾಗಿ ನೀವು ನಿಮ್ಮ ಕಾರ್ಯಗಳಿಗೆ ಕ್ಲೀನ್ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು ಮತ್ತು ವಾದವಾಗಿ ಏನು ಮತ್ತು ಎಲ್ಲಿ ರವಾನಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಿ. ಹೌದು, ನೀವು ಯಾವಾಗಲೂ do_absolutely_everything() ಕಾರ್ಯವನ್ನು ಕೋಡ್ ಮಾಡಬಹುದು, ಆದರೆ ಯಾವುದೇ ಅರ್ಥವಿದೆಯೇ?
ಆಂಡರ್ಸ್ ಅಟ್ ಇಂಗೇಮನ್ ಡಾಟ್ ಫೇಕ್ಸ್ಟಫ್ ಡಾಟ್ ಡೆ

30-ಏಪ್ರಿಲ್-2004 03:18
ಬಳಕೆದಾರ ವ್ಯಾಖ್ಯಾನಿಸಿದ ಕಾರ್ಯಗಳಿಗಾಗಿ ಸಾಕಷ್ಟು ತಂಪಾದ ವಿಷಯವೆಂದರೆ ಅಗತ್ಯವಿರುವ ನಿಯತಾಂಕಗಳನ್ನು ಸಲ್ಲಿಸುವುದು ಮಾತ್ರ.

ಮೂರು ಐಚ್ಛಿಕ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಫಂಕ್ಷನ್‌ಗೆ ನೀವು ಕರೆ ಮಾಡಿದರೆ, ಮೂರನೇ ಪ್ರಮುಖ ಪ್ಯಾರಾಮೀಟರ್ ಏನೆಂದು ನೀವು ಕಾರ್ಯಕ್ಕೆ ಹೇಳಲು ಸಾಧ್ಯವಾಗುವ ಮೊದಲು ನೀವು ಎರಡು ಮೊದಲನೆಯದನ್ನು (ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮಾನದಂಡದಂತೆ ಇರಬೇಕಾದರೂ ಸಹ) ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಬದಲಾಗಿ ನೀವು ನಮೂನೆ ಅಥವಾ ಸಲ್ಲಿಸಿದ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಪ್ರಕಾರವನ್ನು ಯಾವ ವೇರಿಯಬಲ್‌ಗೆ ನಿಯೋಜಿಸಬೇಕು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.
ಈ ರೀತಿ:

ಈಗ ನೀವು ಬಯಸುವ ಯಾವುದೇ ಪ್ಯಾರಾಮೀಟರ್‌ನೊಂದಿಗೆ ಕಾರ್ಯವನ್ನು ನೀವು ಕರೆಯಬಹುದು.

ಉದಾ:

ಆ ಸಂದರ್ಭದಲ್ಲಿ $ ಮಿತಿಯನ್ನು 3600 ನೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ.

ಆ ಸಂದರ್ಭದಲ್ಲಿ $ ಮಿತಿಯನ್ನು 3600 ನೊಂದಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ.

ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ ಪರವಾಗಿಲ್ಲ:
ಅಥವಾ ಇದು:
ನೀವು ereg() ಅನ್ನು ಸಹ ಬಳಸಬಹುದು. ಅದರ ಮೂಲಕ ನೀವು ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ನಿಯತಾಂಕಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಬಳಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
ಹಾಂ ಬಹುಶಃ ಎರೆಗ್ () ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದೆ...
ಪರವಾಗಿಲ್ಲ.
12-ಮಾರ್ಚ್-2004 08:45

func_get_arg() ವಾದದ * ನಕಲು * ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ನನ್ನ ಜ್ಞಾನಕ್ಕೆ ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ಹಿಂಪಡೆಯಲು ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲ.

ನನ್ನ ಆಟದಲ್ಲಿ ನಾನು ಮಾಡ್ಯೂಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ ಅಲ್ಲಿ ನಾನು ಮಾಡ್ಯೂಲ್‌ನಲ್ಲಿನ ಕಾರ್ಯಗಳಿಗೆ ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ರವಾನಿಸಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಅದನ್ನು ಉಲ್ಲೇಖದ ಮೂಲಕ ಕೇಳಿದರೆ ಅವುಗಳನ್ನು ಉಲ್ಲೇಖದ ಮೂಲಕ ರವಾನಿಸಲು ಬಯಸುತ್ತೇನೆ, ಆದರೆ ನೀವು ಸ್ವೀಕರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಐಚ್ಛಿಕ ನಿಯತಾಂಕಗಳನ್ನು ಉಲ್ಲೇಖಗಳಾಗಿ, ಅಥವಾ ನೀವು ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳ ಉಲ್ಲೇಖವನ್ನು ಹಿಂಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ. ನನ್ನ ಮಾಡ್ಯೂಲ್‌ಗಳು ಉಲ್ಲೇಖದ ಮೂಲಕ ತಮ್ಮ ಕಾರ್ಯಗಳಿಗೆ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಎಂದು ತೋರುತ್ತಿದೆ.
ಮಾರ್ಟಿನ್ ಕ್ಲಾಸ್ಸೆಕ್ಸ್ ಡಾಟ್ ಕಾಮ್
07-ಜೂನ್-2002 09:55

ಈ ಕಾರ್ಯವು ಸೊಗಸಾದ ಸಂದರ್ಭದಲ್ಲಿ ಎಚ್ಚರಿಕೆ ಸಂದೇಶಗಳನ್ನು ರಚಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ತಪ್ಪಿಸುವುದಿಲ್ಲ, ಅಲ್ಲಿ ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿಸಲಾಗಿಲ್ಲ, ನೀವು ಎಚ್ಚರಿಕೆಗಳನ್ನು ಸ್ವಿಚ್ ಆಫ್ ಮಾಡದ ಹೊರತು:
ದೋಷ_ವರದಿ ಮಾಡುವಿಕೆ (E_ERROR);

ಅಗತ್ಯ ಎಚ್ಚರಿಕೆಗಳನ್ನು ನೋಡಲು ಇಷ್ಟಪಡುವವರಿಗೆ ಉತ್ತರ?
ಇದನ್ನು ಹೀಗೆ ಕರೆಯಿರಿ:
@allSet($w , $x , $y , $z )

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

ಇಂದು ನಾವು ವಿಧಾನವನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ - ನಾವು ಸಾಮಾಜಿಕ ತತ್ವವನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದು ಅನೇಕ ಪ್ರಸಿದ್ಧ ಸೈಟ್‌ಗಳಿಗೆ ಯಶಸ್ಸನ್ನು ತಂದಿದೆ ಮತ್ತು ಮೇಲಾಗಿ, ಸಲಹೆಯನ್ನು ನೀಡಲು ಮತ್ತು ಭವಿಷ್ಯದ ಬದಲಾವಣೆಗಳಿಗೆ ಇತರರ ಸಲಹೆಗಳಿಗೆ ಮತ ಚಲಾಯಿಸಲು ಸಂತೋಷಪಡುವ ಸಂದರ್ಶಕರಲ್ಲಿ ಬಹಳ ಜನಪ್ರಿಯವಾಗಿದೆ. ಸೈಟ್.

XHTML

ಹೊಸ HTML5 ಡಾಕ್ಯುಮೆಂಟ್ ಪ್ರಕಾರವನ್ನು ಬಳಸುವುದು, ವಿಭಾಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ತಲೆಟ್ಯಾಗ್ ಸೇರಿಸಿ ಶೀರ್ಷಿಕೆ, ಮುಖ್ಯ ಶೈಲಿಯ ಹಾಳೆ styles.css ಆಗಿದೆ.

demo.php ಭವಿಷ್ಯಕ್ಕಾಗಿ ಶಿಫಾರಸುಗಳು (ನಾವು PHP, jQuery ಮತ್ತು MySQL ಅನ್ನು ಬಳಸುತ್ತೇವೆ) | ಸೈಟ್_ಮತದಾನ ಮಾಡಿದ್ದೀರಾ? "ನಿಷ್ಕ್ರಿಯ" : "ಸಕ್ರಿಯ").""> ".$this->ಸಲಹೆ." ".(int)$this->ರೇಟಿಂಗ್.""; } }

ವಸ್ತುವಿನ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ರಚಿಸಲು __toString() ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ರೀತಿಯಲ್ಲಿ ನಾವು ಪ್ರಸ್ತಾಪದ ಶೀರ್ಷಿಕೆ ಮತ್ತು ಮತಗಳ ಸಂಖ್ಯೆಯನ್ನು ಒಳಗೊಂಡಂತೆ HTML ಮಾರ್ಕ್ಅಪ್ ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು.

$data ಅರೇಗಾಗಿ ವಿವರಿಸಲಾಗದ ವರ್ಗ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಒದಗಿಸಲು __get() ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ನಾವು $obj-> ಸಲಹೆಯನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸಿದರೆ ಮತ್ತು ಆಸ್ತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ, ಅದನ್ನು $data ಶ್ರೇಣಿಯಿಂದ ಪಡೆಯಲಾಗುತ್ತದೆ ಮತ್ತು ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ರೀತಿಯಾಗಿ ನಾವು ಎಲ್ಲಾ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿಸುವ ಬದಲು ರಚನೆಯನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ರವಾನಿಸಬಹುದು. ನಾವು ajax.php ನಲ್ಲಿ ವಸ್ತುವನ್ನು ರಚಿಸಿದಾಗ ನಾವು ಈ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ.

ಈಗ ನಾವು ಪುಟಕ್ಕೆ ಕ್ರಮಿಸದ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಹೋಗೋಣ.

demo.php ಗೆ "connect.php" ಅಗತ್ಯವಿರುತ್ತದೆ; "suggestion.class.php" ಅಗತ್ಯವಿದೆ; // IP ಅನ್ನು ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಿ. ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ IP // ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವಾಗಿದೆ: $ip = sprintf("%u",ip2long($_SERVER["REMOTE_ADDR"])); // ಕೆಳಗಿನ ಪ್ರಶ್ನೆಯು // ಎಲ್ಲಾ ಸಲಹೆಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಎಡ ಸೇರುವಿಕೆಯನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಬಳಕೆದಾರರು ಅವರಿಗೆ ಮತ ಹಾಕಿದ್ದಾರೆಯೇ ಎಂಬುದನ್ನು ಏಕಕಾಲದಲ್ಲಿ ನಿರ್ಧರಿಸುತ್ತದೆ. $result = $mysqli->ಪ್ರಶ್ನೆ(" ಆಯ್ಕೆಗಳನ್ನು ಆರಿಸಿ ದಿನ = CURRENT_DATE ಮತ್ತು v.ip = $ip) s.rating DESC ಮೂಲಕ ಆದೇಶ, s.id DESC "); $str = ""; ವೇಳೆ(!$mysqli->ದೋಷ) (// UL $str = "ಉತ್ಪಾದಿಸಿ

"; // ಹೊಸ ವಸ್ತುವನ್ನು ರಚಿಸಲು MySQL fetch_object ವಿಧಾನವನ್ನು ಬಳಸಿ // ಮತ್ತು ಅದನ್ನು ಪ್ರಶ್ನೆ ಫಲಿತಾಂಶದ ಕಾಲಮ್‌ಗಳೊಂದಿಗೆ ಜನಪ್ರಿಯಗೊಳಿಸಿ: while($suggestion = $result->fetch_object("ಸಲಹೆ"))( $str.= $suggestion; // __toString ವಿಧಾನವನ್ನು ಬಳಸಿ ( ) $str .="

"; }

ವಿನಂತಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ನಂತರ, ನಾವು $result ವಸ್ತುವಿನ fetch_object() ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ. ಈ ವಿಧಾನವು ಪ್ರಶ್ನೆಯ ಫಲಿತಾಂಶದ ಪ್ರತಿ ಸಾಲಿಗೆ ನಿರ್ದಿಷ್ಟ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ ಸಾಲಿನ ಕಾಲಮ್‌ಗಳನ್ನು ವಸ್ತುವಿನ ಸಾರ್ವಜನಿಕ ಗುಣಲಕ್ಷಣಗಳಾಗಿ ನಿಯೋಜಿಸುತ್ತದೆ.

PHP jQuery ಮೂಲಕ ಕಳುಹಿಸಲಾದ AJAX ವಿನಂತಿಗಳನ್ನು ಸಹ ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದನ್ನು ajax.php ನಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ. AJAX ಕ್ರಿಯೆಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು, ಸ್ಕ್ರಿಪ್ಟ್ $_GET ["ಕ್ರಿಯೆ"] ನಿಯತಾಂಕವನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಎರಡು ಮೌಲ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಹೊಂದಬಹುದು - 'ಮತ' ಅಥವಾ 'ಸಲ್ಲಿಸು'.

ajax.php ಗೆ "connect.php" ಅಗತ್ಯವಿದೆ; "suggestion.class.php" ಅಗತ್ಯವಿದೆ; // ವಿನಂತಿಯು AJAX ನಿಂದ ಬರದಿದ್ದರೆ, ನಂತರ ನಿರ್ಗಮಿಸಿ: if($_SERVER["HTTP_X_REQUESTED_WITH"] !="XMLHttpRequest")( ನಿರ್ಗಮಿಸಿ; ) // IP ಅನ್ನು ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸಿ. ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ IP ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಇದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವಾಗಿದೆ: $ip = sprintf("%u",ip2long($_SERVER["REMOTE_ADDR"])); if($_GET["action"] == "vote")( $v = (int)$_GET["vote"]; $id = (int)$_GET["id"]; if($v != -1 && $v != 1)(ನಿರ್ಗಮನ; ) // ಅಂತಹ ಸಲಹೆಯ ಐಡಿ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ: ವೇಳೆ(!$mysqli->ಪ್ರಶ್ನೆ("ಸಲಹೆಗಳಿಂದ 1 ಆಯ್ಕೆಮಾಡಿ ಎಲ್ಲಿ ಐಡಿ = $id")->ಸಂಖ್ಯೆ_ಸಾಲುಗಳು)(ನಿರ್ಗಮಿಸಿ ); INTO suggestions_vote (suggestion_id, ip,day,vote) VALUES ($ id, $ip, CURRENT_DATE, $v) "); ಹೊಂದಿಸಿ " .($v == 1 ? "votes_up = votes_up + 1" : "votes_down = votes_down + 1")., ರೇಟಿಂಗ್ = ರೇಟಿಂಗ್ + $v ಎಲ್ಲಿ ಐಡಿ = $id ") ) ಇಲ್ಲದಿದ್ದರೆ($_GET[" ಕ್ರಿಯೆ"] == "ಸಲ್ಲಿಸು")( if(get_magic_quotes_gpc())( array_walk_recursive($_GET,create_function("&$v,$k","$v = ಸ್ಟ್ರಿಪ್‌ಲ್ಯಾಶ್‌ಗಳು($v);")); // ವಿಷಯವನ್ನು ತೆಗೆಯುವುದು $_GET["ವಿಷಯ"] = htmlspecialchars(strip_tags($_GET["content"]));

if(mb_strlen($_GET["content"],"utf-8")query("ಸಲಹೆಗಳಿಗೆ ಸೇರಿಸಿ SET ಸಲಹೆ = "".$mysqli->real_escape_string($_GET["content"])"""); // JSON ಫಾರ್ಮ್ಯಾಟ್‌ನಲ್ಲಿ ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ಸಲಹೆಯ HTML ಕೋಡ್ ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡಿ // ನಾವು (ಸ್ಟ್ರಿಂಗ್) ಅನ್ನು ಬಳಸುತ್ತೇವೆ __toString (ಅರೇ) ("html" => (ಸ್ಟ್ರಿಂಗ್)(ಹೊಸ ಸಲಹೆ(ಅರೇ). "id" =) > $mysqli->insert_id, "ಸಲಹೆ" => $_GET["ವಿಷಯ"])))));

jQuery 'ಮತ' ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಿದಾಗ, ಯಾವುದೇ ರಿಟರ್ನ್ ಮೌಲ್ಯವನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಸ್ಕ್ರಿಪ್ಟ್ ಏನನ್ನೂ ಔಟ್‌ಪುಟ್ ಮಾಡುವುದಿಲ್ಲ. 'ಸಲ್ಲಿಸು' ವಿನಂತಿಯನ್ನು ಮಾಡಿದಾಗ, jQuery ಕೇವಲ ಸೇರಿಸಲಾದ ವಾಕ್ಯಕ್ಕಾಗಿ HTML ಮಾರ್ಕ್ಅಪ್ ಅನ್ನು ಹೊಂದಿರುವ JSON ವಸ್ತುವನ್ನು ಹಿಂದಿರುಗಿಸಲು ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ಇಲ್ಲಿ __toString() ಮ್ಯಾಜಿಕ್ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಸಲಹೆಯ ವಸ್ತುವನ್ನು ರಚಿಸಲಾಗಿದೆ ಮತ್ತು json_encode() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ.

jQuery

script.js $(document).ready(function())( var ul = $("ul.suggestions"); // UP ಅಥವಾ DOWN ಬಾಣಗಳ ಮೇಲಿನ ಕ್ಲಿಕ್‌ಗಳನ್ನು ಮಾನಿಟರ್ ಮಾಡಿ: $("div.vote span").live( "ಕ್ಲಿಕ್ ",ಫಂಕ್ಷನ್())( var elem = $(ಇದು), ಪೋಷಕ = elem.parent(), li = elem.closest("li"), ratingDiv = li.find(".rating"), id = li.attr ("id").replace("s",""), v = 1; // ಬಳಕೆದಾರರು ಈಗಾಗಲೇ ಮತ ಹಾಕಿದ್ದರೆ: if(parent.hasClass("inactive"))( ತಪ್ಪು ಹಿಂತಿರುಗಿ removeClass("ಸಕ್ರಿಯ" ).addClass("ನಿಷ್ಕ್ರಿಯ"); if(elem.hasClass("down"))( v = -1; ) // ಬಲಭಾಗದಲ್ಲಿರುವ ಕೌಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸಿ: ratingDiv.text(v + +ratingDiv. ಪಠ್ಯ()); ಎಲ್ಲಾ LI ಅಂಶಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ // ಮತ್ತು ಮತಗಳ ಸಂಖ್ಯೆಯಿಂದ ವಿಂಗಡಿಸಿ: var arr = $.makeArray(ul.find("li")).sort(function(l,r)( return + $(".rating",r ).text() - +$(".rating",l).text()); UL ul.html(arr) ಗೆ ವಿಂಗಡಿಸಲಾದ LI ಅಂಶಗಳನ್ನು ಸೇರಿಸಿ // AJAX ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಿ $.get("ajax) .php",(ಆಕ್ಷನ್:"vote",vote:v,"id":id) ));submit(function()) = $(ಇದು), textField = $("#suggestionText");