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

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

ನಾವು ಈ ವರ್ಗದ ಸಣ್ಣ ಪ್ರತಿಯನ್ನು ಬರೆಯೋಣ, ಆದರೆ PHP ಗಾಗಿ ಮಾತ್ರ:

ವರ್ಗ ಗಣಿತ (
ಖಾಸಗಿ ಸ್ಥಿರ $ ಎಣಿಕೆ = 0;
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ನಿರ್ಮಾಣ () (
ಸ್ವಯಂ:: $ ಎಣಿಕೆ++;
}
ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ calcSin($x) (
ರಿಟರ್ನ್ ಸಿನ್($x);
}
ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ calcSQRT($x) (
ರಿಟರ್ನ್ sqrt ($x);
}
ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ getCount() (
ಸ್ವಯಂ ಹಿಂತಿರುಗಿ:: $ ಎಣಿಕೆ;
}
}
ಪ್ರತಿಧ್ವನಿ ಗಣಿತ :: calcSin (1);
ಪ್ರತಿಧ್ವನಿ "
";
ಪ್ರತಿಧ್ವನಿ ಗಣಿತ ::calcSQRT(9);
ಪ್ರತಿಧ್ವನಿ "
";
$ ಗಣಿತ = ಹೊಸ ಗಣಿತ();
$math_2 = ಹೊಸ ಗಣಿತ();
ಪ್ರತಿಧ್ವನಿ ಗಣಿತ ::getCount ();
?>

ಈ ಕೋಡ್‌ನಲ್ಲಿ ನಾನು ತೋರಿಸಿದೆ ಸ್ಥಿರ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸುವುದು. ನಾನು ಕ್ಲಾಸಿಕ್ ಆಬ್ಜೆಕ್ಟ್ ಕೌಂಟರ್ ವಿಧಾನವನ್ನು ಅಳವಡಿಸಿದ್ದೇನೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಕ್ಷೇತ್ರ ಎಂಬ ಕಾರಣದಿಂದಾಗಿ ಇದು ಸಂಭವಿಸಿತು ಎಣಿಕೆಸ್ಥಿರವಾಗಿದೆ ಮತ್ತು ಇದು ಎಲ್ಲಾ ವಸ್ತುಗಳಿಗೆ ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

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

PHP 5.3.0 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ, ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್ ಎಂಬ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊಂದಿದ್ದು, ಇದನ್ನು ಸ್ಥಿರವಾದ ಉತ್ತರಾಧಿಕಾರದ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆಯಬಹುದಾದ ವರ್ಗಕ್ಕೆ ಉಲ್ಲೇಖವನ್ನು ಪಡೆಯಲು ಬಳಸಬಹುದು.

ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್ ಕೊನೆಯ "ಫಾರ್ವರ್ಡ್ ಮಾಡದ ಕರೆ" ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವರ್ಗದ ಹೆಸರನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ. ಸ್ಥಿರ ಕರೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವರ್ಗವಾಗಿದೆ (ಸಾಮಾನ್ಯವಾಗಿ ಆಪರೇಟರ್‌ನ ಎಡಕ್ಕೆ :: ); ಸ್ಥಿರವಲ್ಲದ ಕರೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ವಸ್ತುವಿನ ವರ್ಗವಾಗಿದೆ. "ಮರುನಿರ್ದೇಶನ ಮಾಡಲಾದ ಕರೆ" ಎಂಬುದು ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಸ್ಥಿರ ಕರೆಯಾಗಿದೆ, ಸ್ವಯಂ ::, ಪೋಷಕ::ಸ್ಥಿರ:: , ಅಥವಾ, ನಾವು ವರ್ಗ ಕ್ರಮಾನುಗತವನ್ನು ಸರಿಸಿದರೆ,ಫಾರ್ವರ್ಡ್_ಸ್ಟ್ಯಾಟಿಕ್_ಕಾಲ್() .ಕಾರ್ಯ ಪೋಷಕ::ಗೆಟ್_ಕಾಲ್ಡ್_ಕ್ಲಾಸ್()

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

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

ಕರೆಯಲ್ಪಡುವ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ವರ್ಗಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ ಲೆಕ್ಕ ಹಾಕಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ರನ್ಟೈಮ್ನಲ್ಲಿನ ಮಾಹಿತಿಯ ಆಧಾರದ ಮೇಲೆ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಸ್ಥಿರವಲ್ಲದ ಕರೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ವಸ್ತುವಿನ ವರ್ಗವಾಗಿದೆ. "ಮರುನಿರ್ದೇಶನ ಮಾಡಲಾದ ಕರೆ" ಎಂಬುದು ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಸ್ಥಿರ ಕರೆಯಾಗಿದೆ

ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು "ಸ್ಥಿರ ಬೈಂಡಿಂಗ್" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ ಏಕೆಂದರೆ ಇದನ್ನು ಸ್ಥಿರ ವಿಧಾನಗಳಲ್ಲಿ ಬಳಸಬಹುದು (ಆದರೆ ಮಾಡಬೇಕಾಗಿಲ್ಲ).
ನಿರ್ಬಂಧಗಳು ;
}
ಉದಾಹರಣೆ #1 ಬಳಕೆವರ್ಗ ಎ (
ಪ್ರತಿಧ್ವನಿ __ಕ್ಲಾಸ್__
}
}

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ
ಪರೀಕ್ಷೆ()(
ಸ್ವಯಂ :: ಯಾರು ();
}
}

ವರ್ಗ ಬಿ ಎ (ಎ) ವಿಸ್ತರಿಸುತ್ತದೆ
?>

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ ಯಾರು() (

ಪ್ರತಿಧ್ವನಿ __CLASS__ ; ಬಿ:: ಪರೀಕ್ಷೆ ();ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್ ಅನ್ನು ಬಳಸುವುದು ನಂತರ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್ ರನ್ಟೈಮ್ನಲ್ಲಿ ನೇರವಾಗಿ ಕರೆಯಲ್ಪಡುವ ವರ್ಗವನ್ನು ಉಲ್ಲೇಖಿಸುವ ಕೀವರ್ಡ್ ಅನ್ನು ಒದಗಿಸುವ ಮೂಲಕ ಈ ಮಿತಿಯನ್ನು ಜಯಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ನೀವು ಲಿಂಕ್ ಮಾಡಲು ಅನುಮತಿಸುವ ಕೀವರ್ಡ್ಬಿ ನಿಂದಪರೀಕ್ಷೆ ()

ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿ. ಹೊಸ ಕೀವರ್ಡ್ ಅನ್ನು ಪರಿಚಯಿಸದಿರಲು ನಿರ್ಧರಿಸಲಾಯಿತು, ಆದರೆ ಬಳಸಲು ಪೋಷಕ::

ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು "ಸ್ಥಿರ ಬೈಂಡಿಂಗ್" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ ಏಕೆಂದರೆ ಇದನ್ನು ಸ್ಥಿರ ವಿಧಾನಗಳಲ್ಲಿ ಬಳಸಬಹುದು (ಆದರೆ ಮಾಡಬೇಕಾಗಿಲ್ಲ).
ಪರೀಕ್ಷೆ()(
ನಿರ್ಬಂಧಗಳು ;
}
ಉದಾಹರಣೆ #1 ಬಳಕೆವರ್ಗ ಎ (
ಸ್ಥಿರ , ಇದು ಈಗಾಗಲೇ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ.
}
}

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ
ಪರೀಕ್ಷೆ()(
ಸ್ವಯಂ :: ಯಾರು ();
}
}

ವರ್ಗ ಬಿ ಎ (ಎ) ವಿಸ್ತರಿಸುತ್ತದೆ
?>

ಉದಾಹರಣೆ #2 ಬಳಸಲು ಸುಲಭ

ಸ್ಥಿರ :: ಯಾರು ();:

// ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್ ಇಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ ಈ ಉದಾಹರಣೆಯನ್ನು ಚಲಾಯಿಸುವ ಫಲಿತಾಂಶ:ಕಾಮೆಂಟ್ ಮಾಡಿ ಪೋಷಕ::ಸ್ಥಿರವಲ್ಲದ ಸಂದರ್ಭದಲ್ಲಿ, ಆಬ್ಜೆಕ್ಟ್ ನಿದರ್ಶನವು ಸೇರಿರುವ ವರ್ಗ ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ. ಏಕೆಂದರೆ ಪೋಷಕ::$this->

ಬಳಸಿ, ಅದೇ ವ್ಯಾಪ್ತಿಯಿಂದ ಖಾಸಗಿ ವಿಧಾನಗಳನ್ನು ಕರೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಪೋಷಕ::ವಿಭಿನ್ನ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಬಹುದು.

ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು "ಸ್ಥಿರ ಬೈಂಡಿಂಗ್" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ ಏಕೆಂದರೆ ಇದನ್ನು ಸ್ಥಿರ ವಿಧಾನಗಳಲ್ಲಿ ಬಳಸಬಹುದು (ಆದರೆ ಮಾಡಬೇಕಾಗಿಲ್ಲ).
ಇನ್ನೊಂದು ವ್ಯತ್ಯಾಸವೆಂದರೆ ಅದು
ವರ್ಗದ ಸ್ಥಿರ ಕ್ಷೇತ್ರಗಳನ್ನು ಮಾತ್ರ ಉಲ್ಲೇಖಿಸಬಹುದು.
}
ಉದಾಹರಣೆ #3 ಬಳಕೆ
ಸ್ಥಿರವಲ್ಲದ ಸಂದರ್ಭದಲ್ಲಿ
ಖಾಸಗಿ ಕಾರ್ಯ foo() (
}
}

ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ
ಪ್ರತಿಧ್ವನಿ "ಯಶಸ್ಸು!\n" ;
ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ ಪರೀಕ್ಷೆ()
}

$ಇದು -> ಫೂ();
ಇನ್ನೊಂದು ವ್ಯತ್ಯಾಸವೆಂದರೆ ಅದು
ಸ್ಥಿರ :: foo ();
}
}

/* foo() ಅನ್ನು B ಗೆ ನಕಲಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದರ ವ್ಯಾಪ್ತಿ ಇನ್ನೂ A ಆಗಿದೆ,
ಮತ್ತು ಕರೆ ಯಶಸ್ವಿಯಾಗುತ್ತದೆ*/
ವರ್ಗ ಸಿ ಎ (ಎ) ವಿಸ್ತರಿಸುತ್ತದೆ
/* ಮೂಲ ವಿಧಾನವನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ; ಹೊಸ ಸಿ ವಿಧಾನದ ವ್ಯಾಪ್ತಿ */
?>

ಉದಾಹರಣೆ #2 ಬಳಸಲು ಸುಲಭ

$b = ಹೊಸ B();

ಸ್ಥಿರ :: ಯಾರು ();:

ತಡವಾದ ಸ್ಥಿರ ಬೈಂಡಿಂಗ್‌ನ ಪರಿಹರಿಸುವ ಪ್ರದೇಶವನ್ನು ಅದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಸ್ಥಿರ ಕರೆಯಿಂದ ಸರಿಪಡಿಸಲಾಗುತ್ತದೆ. ಮತ್ತೊಂದೆಡೆ, ಅಂತಹ ನಿರ್ದೇಶನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ಕರೆಗಳು ಸ್ವಯಂ ::ಅಥವಾ ಸ್ಥಿರವಲ್ಲದ ಕರೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ವಸ್ತುವಿನ ವರ್ಗವಾಗಿದೆ. "ಮರುನಿರ್ದೇಶನ ಮಾಡಲಾದ ಕರೆ" ಎಂಬುದು ಇದರೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಸ್ಥಿರ ಕರೆಯಾಗಿದೆಕರೆ ಮಾಹಿತಿಯನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ #4 ಮರುನಿರ್ದೇಶಿಸಲಾದ ಮತ್ತು ಮರುನಿರ್ದೇಶಿಸದ ಕರೆಗಳು

PHP ಒಂದು ವಿಧಾನವನ್ನು ಸ್ಥಿರ ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ. ಸ್ಥಿರ ವಿಧಾನವು ವಸ್ತುವಿನ ಗುಣಲಕ್ಷಣಗಳಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ. ಅಂತಹ ವಿಧಾನಗಳನ್ನು ಒಂದು ವರ್ಗದ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ಕರೆಯಬಹುದು, ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ.

ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳು ವರ್ಗಗಳಿಗೆ ಸೇರಿವೆ, ವಸ್ತುಗಳಲ್ಲ.

ಒಂದು ಉದಾಹರಣೆಯು ಅದನ್ನು ತಕ್ಷಣವೇ ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ. ಗಣಿತದ ವಸ್ತುವನ್ನು ರಚಿಸೋಣ (ಇಂಗ್ಲಿಷ್‌ನಲ್ಲಿ ಗಣಿತಕ್ಕೆ ಚಿಕ್ಕದಾಗಿದೆ).

"; $math_1 = ಹೊಸ ಗಣಿತ (); $math_2 = ಹೊಸ ಗಣಿತ (); $math_3 = ಹೊಸ ಗಣಿತ (); $math_4 = ಹೊಸ ಗಣಿತ (); ಪ್ರತಿಧ್ವನಿ "ಆಬ್ಜೆಕ್ಟ್ಸ್ ರಚಿಸಲಾಗಿದೆ:" . ಗಣಿತ::getCount(); ?>

ಈ ವರ್ಗವು ವಸ್ತುವನ್ನು ರಚಿಸದೆಯೇ ಗಣಿತದ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ವರ್ಗವು ಸ್ಟ್ಯಾಟಿಕ್ ಪ್ರಾಪರ್ಟಿ $ಕೌಂಟ್ ಅನ್ನು ಒಂದರಿಂದ ಹೆಚ್ಚಿಸುವ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಹೊಂದಿದೆ. ವರ್ಗವು ಈ ಆಸ್ತಿಯ ಮೌಲ್ಯವನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.

ಮೂಲಕ, ವಿಧಾನ ಅಥವಾ ಆಸ್ತಿ ಸ್ಥಿರವನ್ನು ಘೋಷಿಸಲು, ಸ್ಥಿರ ಪದವನ್ನು ಬಳಸಿ ಮತ್ತು ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು, ಸ್ವಯಂ ಪದವನ್ನು ಬಳಸಿ ನಂತರ ಡಬಲ್ ಕೊಲೊನ್ "::".

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

ಕೌಂಟರ್++;
) ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ calcSin($x) (ರಿಟರ್ನ್ sin($x); ) ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ calcSQRT($x) (ರಿಟರ್ನ್ sqrt($x); ) ಸಾರ್ವಜನಿಕ ಸ್ಥಾಯೀ ಕಾರ್ಯ getCount() (Return self::$count; ) ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ getCounter() ($this->ಕೌಂಟರ್ ಹಿಂತಿರುಗಿ; ) ) echo Math ::calcSin(1); ಪ್ರತಿಧ್ವನಿ "
"; ಪ್ರತಿಧ್ವನಿ ಗಣಿತ:: calcSQRT(9); ಪ್ರತಿಧ್ವನಿ "
"; $math_1 = ಹೊಸ ಗಣಿತ (); $math_2 = ಹೊಸ ಗಣಿತ (); $math_3 = ಹೊಸ ಗಣಿತ (); $math_4 = ಹೊಸ ಗಣಿತ (); ಪ್ರತಿಧ್ವನಿ "ಆಬ್ಜೆಕ್ಟ್ಸ್ ರಚಿಸಲಾಗಿದೆ: " . ಗಣಿತ::getCount (); ಪ್ರತಿಧ್ವನಿ "

"; ಪ್ರತಿಧ್ವನಿ "ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ: " . $math_4->getCounter(); ?>

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಕ್ಲಾಸ್‌ಗೆ ನಿಯಮಿತ $ಕೌಂಟರ್ ಆಸ್ತಿಯನ್ನು ಸೇರಿಸಿದ್ದೇವೆ, ಅದನ್ನು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಒಬ್ಬರಿಂದ ಹೆಚ್ಚಿಸಲಾಗಿದೆ. ಆದರೆ ನಿಯಮಿತ ಆಸ್ತಿಯು ವಸ್ತುವಿಗೆ ಸೇರಿದೆ, ಆದ್ದರಿಂದ ಇದು ವಸ್ತುಗಳಿಗೆ ಕರೆಗಳ ನಡುವೆ ಉಳಿಯುವುದಿಲ್ಲ. ಒಂದು ವರ್ಗದ (ವಸ್ತು) ನಿದರ್ಶನವನ್ನು ರಚಿಸಿದಾಗ, ಆಸ್ತಿಯು ಶೂನ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ, ಅದು ಒಂದರಿಂದ ಹೆಚ್ಚಾಗುತ್ತದೆ.

ಸ್ಥಿರ ಆಸ್ತಿ ವರ್ಗಕ್ಕೆ ಸೇರಿದೆ, ಆದ್ದರಿಂದ ಅದರ ಮೌಲ್ಯವನ್ನು ಸಂರಕ್ಷಿಸಲಾಗಿದೆ.

$this ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸ್ಥಿರ ವಿಧಾನದಲ್ಲಿ ಬಳಸಲು ಪ್ರಯತ್ನಿಸುವುದು ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ (ಮಾರಣಾಂತಿಕ ದೋಷ: ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ ಇಲ್ಲದಿದ್ದಾಗ $ಥಿಸ್ ಅನ್ನು ಬಳಸುವುದು).

ವಯಸ್ಸು. "ಹಳೆಯ."; // ಇದು "ಆಬ್ಜೆಕ್ಟ್ ಸನ್ನಿವೇಶದಲ್ಲಿ ಇಲ್ಲದಿದ್ದಾಗ $ಥಿಸ್ ಅನ್ನು ಬಳಸುವುದು" ದೋಷವಾಗಿದೆ.

) ) $TestClass = ಹೊಸ TestClass(); $TestClass->ಹೇಹಲೋ(); ?>

ಮೂಲಕ, ಸಾಲು ಇಲ್ಲದೆ:

$TestClass->ಹೇಹಲೋ();

ಯಾವುದೇ ದೋಷವಿರುವುದಿಲ್ಲ, ಆದರೆ ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ $this ವೇರಿಯೇಬಲ್‌ನೊಂದಿಗೆ ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಚಲಾಯಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿದ ತಕ್ಷಣ, ನೀವು ತಕ್ಷಣ ದೋಷ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸುತ್ತೀರಿ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನೀವು ಸ್ಥಿರ ಪದವನ್ನು ತೆಗೆದುಹಾಕಿದರೆ, ಯಾವುದೇ ದೋಷವಿರುವುದಿಲ್ಲ.

ಸ್ಥಿರ ವಿಧಾನದಿಂದ ನೀವು ವಸ್ತುವಿನ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಿದರೆ, ಇದು ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಸ್ವಯಂ ::$age ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸಬಹುದು. $this-> ವಯಸ್ಸಿನ ರಚನೆಯಂತಲ್ಲದೆ, ವೇರಿಯಬಲ್ ಹೆಸರಿನ ಮೊದಲು $ ಚಿಹ್ನೆ ಇದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ.

ಹಲೋ (); ?>

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನೀವು ಆಸ್ತಿಯ ಹೆಸರಿನ ಮೊದಲು ಸ್ಥಿರ ಪದವನ್ನು ತೆಗೆದುಹಾಕಿದರೆ, "ಅಘೋಷಿತ ಸ್ಥಿರ ಆಸ್ತಿಗೆ ಪ್ರವೇಶ" ದೋಷವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ.

ವರ್ಗ ವಸ್ತುಗಳ ಮೇಲೆ ಯಾವುದೇ ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳಿಲ್ಲ."; ?>

"; print_r($TestClass); ಪ್ರತಿಧ್ವನಿ "

ಸ್ವಯಂ :: ವಿಧಾನ () ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ವಿಧಾನವನ್ನು ಕರೆಯಬಹುದು. ಉದಾಹರಣೆ:

ಪ್ರಿಂಟ್ ಹಲೋ (); ?>

ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗದ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಪಡೆಯಬಹುದು:

ಪ್ರತಿಧ್ವನಿ TestClass :: $age;

ಇದಲ್ಲದೆ, ಈ ರೀತಿಯಾಗಿ ನಿಯಮಿತ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸುವ ಪ್ರಯತ್ನವು ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ: "ಮಾರಣಾಂತಿಕ ದೋಷ: ಅಘೋಷಿತ ಸ್ಥಿರ ಆಸ್ತಿಗೆ ಪ್ರವೇಶ."

ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗದ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಬದಲಾಯಿಸಬಹುದು:

ಟೆಸ್ಟ್ಕ್ಲಾಸ್:: $ ವಯಸ್ಸು += 20; // ಉದಾಹರಣೆಗೆ

ಸ್ಥಿರ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಮತ್ತೊಂದು ಕೋಡ್ ಉದಾಹರಣೆ

ಈ ಉದಾಹರಣೆಯು ಸ್ಥಿರ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಬಳಸುವ ಸರಳ ಆಯ್ಕೆಗಳನ್ನು ಸಹ ತೋರಿಸುತ್ತದೆ. ನೀವು ಹೆಚ್ಚು ಸರಳವಾದ ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡರೆ, ನೀವು ವಿಷಯವನ್ನು ಉತ್ತಮವಾಗಿ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತೀರಿ.
".TestClass::$age; // echo TestClass::$txt; // ದೋಷ: ಮಾರಕ ದೋಷ: ಅಘೋಷಿತ ಸ್ಥಿರ ಆಸ್ತಿಗೆ ಪ್ರವೇಶ. ಪ್ರತಿಧ್ವನಿ "
"; TestClass ::sayHi(); echo "
"; TestClass::sayHello(); // ಮತ್ತು ನಾನು ವಸ್ತುವಿನ ಮೂಲಕ ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಹೇಗೆ ನಿರ್ವಹಿಸಿದೆ ($obj::$age)... ಪ್ರತಿಧ್ವನಿ "

"; $obj = ಹೊಸ TestClass; ಪ್ರತಿಧ್ವನಿ "ಒಂದು ವಸ್ತುವಿನ ಮೂಲಕ ಸ್ಥಿರ ವೇರಿಯಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸುವುದು: " . $obj::$age; ?>

ದಯವಿಟ್ಟು ಗಮನಿಸಿ, ಮತ್ತು ಇದು ಮುಖ್ಯವಾಗಿದೆ, ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಸ್ಥಿರ ವರ್ಗದ ಸದಸ್ಯರನ್ನು ಪ್ರವೇಶಿಸಲು ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರವಲ್ಲದ sayHi() ವಿಧಾನವನ್ನು ಪ್ರವೇಶಿಸಿದ್ದೇವೆ.

• ಪುನರಾರಂಭಿಸಿ
• ಮುಖ್ಯ ವಿಷಯ: ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ವರ್ಗಗಳಿಗೆ ಸೇರಿವೆ, ವಸ್ತುಗಳಲ್ಲ.
• ಸ್ಥಿರ ವಿಧಾನದಿಂದ ನೀವು ಸಾಮಾನ್ಯ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮತ್ತು ವರ್ಗದ ವಿಧಾನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ $this->ಹೆಸರು ಇಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ.
• ಸ್ಥಿರ ವಿಧಾನದಿಂದ, ನೀವು self ::$name ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
• ಒಂದು ಸಾಮಾನ್ಯ ವಿಧಾನವು ಸ್ವಯಂ ::$ಹೆಸರನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.
• ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವರ್ಗದ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಪಡೆಯಬಹುದು: TestClass::$age .
• ನಿಯಮಿತ ವಿಧಾನವನ್ನು ಆಬ್ಜೆಕ್ಟ್ ($ಆಬ್ಜೆಕ್ಟ್->ಮೆಥೋಡ್()) ಮತ್ತು ಟೆಸ್ಟ್‌ಕ್ಲಾಸ್ ::ಮೆಥೋಡ್() ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸುವ ಕ್ಲಾಸ್ ಎರಡರ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆಯಬಹುದು.
• $object::$age ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಾನು ವಸ್ತುವಿನ ಮೂಲಕ ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಯಿತು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ನೊಂದಿಗೆ ಸಮಾನಾಂತರಗಳು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಗಣಿತ ವರ್ಗವನ್ನು ಹೊಂದಿದ್ದು ಅದು ಹಲವು ವಿಭಿನ್ನ ಗಣಿತದ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಗಣಿತದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು (ಸೈನ್ ಅಥವಾ ಘಾತವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು) ಕೈಗೊಳ್ಳಲು, ನೀವು ಗಣಿತ ವರ್ಗದ ವಸ್ತುವನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ, ಏಕೆಂದರೆ ಅದರ ವಿಧಾನಗಳು ಸ್ಥಿರವಾಗಿರುತ್ತವೆ. PHP ಕಲಿಯುವ ಮೊದಲು, ಅದು ಏನೆಂದು ನನಗೆ ಅರ್ಥವಾಗಲಿಲ್ಲ, ಮತ್ತು PHP ಯಲ್ಲಿ ತರಗತಿಗಳು ಮತ್ತು ವಸ್ತುಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡಿದ ನಂತರ ಮಾತ್ರ ಎಲ್ಲವೂ ನನ್ನ ತಲೆಯಲ್ಲಿ ಬಿದ್ದವು.

ವಸ್ತುವನ್ನು ರಚಿಸದೆಯೇ ಗಣಿತ ವರ್ಗದ ಗಣಿತ ವಿಧಾನಗಳಿಗೆ ನೇರ ಪ್ರವೇಶವನ್ನು ಹೊಂದಲು ಇದು ನಿಜವಾಗಿಯೂ ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ.

". ನಾನು ಪ್ರತಿಕ್ರಿಯೆ ಲೇಖನವನ್ನು ಬರೆದಿದ್ದೇನೆ, ಆದರೆ ಅದನ್ನು ಎಂದಿಗೂ ಪ್ರಕಟಿಸಲಿಲ್ಲ. ಆದರೆ ಇತ್ತೀಚೆಗೆ ನಾನು "ವರ್ಗ-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್" ಎಂದು ಕರೆಯಬಹುದಾದ ಯಾವುದನ್ನಾದರೂ ನೋಡಿದೆ. ಇದು ವಿಷಯದ ಬಗ್ಗೆ ನನ್ನ ಆಸಕ್ತಿಯನ್ನು ನವೀಕರಿಸಿದೆ ಮತ್ತು ಇದು ಫಲಿತಾಂಶವಾಗಿದೆ.

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

• ಇದು ಕಾರ್ಯವಿಧಾನದ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗಿಂತ ಯಾವುದೇ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುವುದಿಲ್ಲ
• ವಸ್ತುಗಳನ್ನು ಬಿಟ್ಟುಕೊಡಬೇಡಿ
• ಸ್ಥಿರ ವರ್ಗದ ಸದಸ್ಯರ ಉಪಸ್ಥಿತಿ = ಪರೀಕ್ಷೆಗಳಿಗೆ ಸಾವು

ಈ ಲೇಖನವು PHP ಬಗ್ಗೆ ಇದ್ದರೂ, ಪರಿಕಲ್ಪನೆಗಳು ಇತರ ಭಾಷೆಗಳಿಗೂ ಅನ್ವಯಿಸುತ್ತವೆ.

ಅವಲಂಬನೆಗಳು

ವಿಶಿಷ್ಟವಾಗಿ, ಕೋಡ್ ಇತರ ಕೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

$foo = substr($bar, 42);
ಈ ಕೋಡ್ $bar ವೇರಿಯೇಬಲ್ ಮತ್ತು substr ಕಾರ್ಯವನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. $ಬಾರ್ ಕೇವಲ ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್ ಆಗಿದ್ದು, ಅದೇ ಫೈಲ್‌ನಲ್ಲಿ ಮತ್ತು ಅದೇ ಸ್ಕೋಪ್‌ನಲ್ಲಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚಿನದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. substr ಒಂದು PHP ಕೋರ್ ಕಾರ್ಯವಾಗಿದೆ. ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ.

ಈಗ, ಈ ಉದಾಹರಣೆ:

ವರ್ಗ ಬ್ಲೂಮ್‌ಫಿಲ್ಟರ್ (... ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ __ಕನ್ಸ್ಟ್ರಕ್ಟ್($m, $k) (... ) ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ getK($m, $n) ( ರಿಟರ್ನ್ ceil(($m / $n) * log(2)); )...)
ಈ ಚಿಕ್ಕ ಸಹಾಯಕ ಕಾರ್ಯವು ಕೇವಲ ಒಂದು ನಿರ್ದಿಷ್ಟ ಅಲ್ಗಾರಿದಮ್‌ಗೆ ಹೊದಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ನಲ್ಲಿ ಬಳಸಲಾದ $k ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗೆ ಉತ್ತಮ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಏಕೆಂದರೆ ವರ್ಗ ನಿದರ್ಶನವನ್ನು ರಚಿಸುವ ಮೊದಲು ಅದನ್ನು ಕರೆಯಬೇಕು, ಅದು ಸ್ಥಿರವಾಗಿರಬೇಕು. ಈ ಅಲ್ಗಾರಿದಮ್ ಯಾವುದೇ ಬಾಹ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ. ಇದನ್ನು ಈ ರೀತಿ ಬಳಸಲಾಗುತ್ತದೆ:

$m = 10000; $n = 2000; $b = ಹೊಸ BloomFilter($m, BloomFilter ::getK($m, $n));
ಇದು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಅವಲಂಬನೆಗಳನ್ನು ರಚಿಸುವುದಿಲ್ಲ. ವರ್ಗವು ಸ್ವತಃ ಅವಲಂಬಿಸಿರುತ್ತದೆ.

ಪರ್ಯಾಯ ನಿರ್ಮಾಣಕಾರ. PHP ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ DateTime ವರ್ಗವು ಉತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ. ಅದರ ನಿದರ್ಶನವನ್ನು ಎರಡು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ರಚಿಸಬಹುದು:

$ ದಿನಾಂಕ = ಹೊಸ ದಿನಾಂಕ ಸಮಯ("2012-11-04"); $date = DateTime::createFromFormat("d-m-Y", "04-11-2012");
ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಫಲಿತಾಂಶವು DateTime ನಿದರ್ಶನವಾಗಿರುತ್ತದೆ ಮತ್ತು ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ಕೋಡ್ ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ DateTime ವರ್ಗಕ್ಕೆ ಬದ್ಧವಾಗಿದೆ. DateTime ::createFromFormat ಸ್ಟ್ಯಾಟಿಕ್ ವಿಧಾನವು ಪರ್ಯಾಯ ವಸ್ತು ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಆಗಿದ್ದು ಅದು ಹೊಸ ದಿನಾಂಕದ ಸಮಯ , ಆದರೆ ಹೆಚ್ಚುವರಿ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ನೀಡುತ್ತದೆ. ನೀವು ಹೊಸ ವರ್ಗವನ್ನು ಎಲ್ಲಿ ಬರೆಯಬಹುದು, ನೀವು Class ::method() ಅನ್ನು ಸಹ ಬರೆಯಬಹುದು. ಇದು ಯಾವುದೇ ಹೊಸ ಅವಲಂಬನೆಗಳನ್ನು ಸೃಷ್ಟಿಸುವುದಿಲ್ಲ.

ಸ್ಥಿರ ವಿಧಾನಗಳ ಇತರ ಬಳಕೆಯು ಬಂಧಿಸುವಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ ಮತ್ತು ಸೂಚ್ಯ ಅವಲಂಬನೆಗಳನ್ನು ರಚಿಸಬಹುದು.

ಅಮೂರ್ತತೆಯ ಬಗ್ಗೆ ಒಂದು ಮಾತು

ವ್ಯಸನಗಳ ಜೊತೆ ಈ ಗಲಾಟೆ ಏಕೆ? ಅಮೂರ್ತ ಸಾಮರ್ಥ್ಯ! ನಿಮ್ಮ ಉತ್ಪನ್ನವು ಬೆಳೆದಂತೆ, ಅದರ ಸಂಕೀರ್ಣತೆ ಹೆಚ್ಚಾಗುತ್ತದೆ. ಮತ್ತು ಅಮೂರ್ತತೆಯು ಸಂಕೀರ್ಣತೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಕೀಲಿಯಾಗಿದೆ.

ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ವರ್ಗವನ್ನು ನೀವು ಹೊಂದಿದ್ದೀರಿ. ಇದು ಬಳಕೆದಾರ ವರ್ಗದೊಂದಿಗೆ ಮಾತನಾಡುತ್ತದೆ, ಇದು ಬಳಕೆದಾರರ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ. ಇದು ಡೇಟಾಬೇಸ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತದೆ. ಡೇಟಾಬೇಸ್ ವರ್ಗಕ್ಕೆ ಡೇಟಾಬೇಸ್ ಡ್ರೈವರ್ ಅಗತ್ಯವಿದೆ. ಡೇಟಾಬೇಸ್ ಡ್ರೈವರ್‌ಗೆ ಸಂಪರ್ಕ ನಿಯತಾಂಕಗಳ ಅಗತ್ಯವಿದೆ. ಮತ್ತು ಹೀಗೆ. ನೀವು ಕೇವಲ ಅಪ್ಲಿಕೇಶನ್::start() ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಕರೆದರೆ, ಅದು ಬಳಕೆದಾರ ::getData() ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಕರೆಯುತ್ತದೆ, ಇದು DB ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಕರೆಯುತ್ತದೆ, ಮತ್ತು ಹೀಗೆ, ಮತ್ತು ಪ್ರತಿ ಪದರವು ಅದರ ಅವಲಂಬನೆಗಳನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಭಾವಿಸಿದರೆ, ನೀವು ಕೊನೆಗೊಳ್ಳಬಹುದು ಏನಾದರೂ ತಪ್ಪಾದರೆ ಭಯಾನಕ ಅವ್ಯವಸ್ಥೆ ಹಾಗೆ ಅಲ್ಲ. ಆಂತರಿಕ ಅವಲಂಬನೆಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿಲ್ಲದ ಕಾರಣ ಅಪ್ಲಿಕೇಶನ್::ಪ್ರಾರಂಭ () ಅನ್ನು ಕರೆಯುವುದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆಯೇ ಎಂದು ಊಹಿಸಲು ಅಸಾಧ್ಯವಾಗಿದೆ. ಇನ್ನೂ ಕೆಟ್ಟದಾಗಿ, ಅಪ್ಲಿಕೇಶನ್‌ನ ವರ್ತನೆಯ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರುವ ಏಕೈಕ ಮಾರ್ಗವೆಂದರೆ::ಪ್ರಾರಂಭ () ಆ ವರ್ಗದ ಮೂಲ ಕೋಡ್ ಮತ್ತು ಅದು ಕರೆಯುವ ವರ್ಗಗಳ ಕೋಡ್ ಮತ್ತು ಆ ವರ್ಗಗಳನ್ನು ಕರೆಯುವ ವರ್ಗಗಳ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸುವುದು... ಜ್ಯಾಕ್ ನಿರ್ಮಿಸಿದ ಮನೆ.

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

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

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

ವರ್ಗ-ಆಧಾರಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂರ್ಖತನವಾಗಿದೆ. OOP ಬಳಸಲು ಕಲಿಯಿರಿ.

• ಟ್ಯುಟೋರಿಯಲ್

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

ಈ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಒಂದನ್ನು "ತುಂಡು ತುಂಡಾಗಿ" ಪ್ರತ್ಯೇಕಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ - PHP ಯಲ್ಲಿ "ಸ್ಥಿರ" ಪದದ ಅರ್ಥವೇನು ಮತ್ತು ಅದನ್ನು ಏಕೆ ಬಳಸಲಾಗುತ್ತದೆ?

ಸ್ಥಿರ ಕೀವರ್ಡ್ PHP ಯಲ್ಲಿ ಮೂರು ವಿಭಿನ್ನ ಅರ್ಥಗಳನ್ನು ಹೊಂದಿದೆ. ಭಾಷೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡಂತೆ ಅವುಗಳನ್ನು ಕಾಲಾನುಕ್ರಮದಲ್ಲಿ ನೋಡೋಣ.

ಮೊದಲ ಮೌಲ್ಯವು ಸ್ಥಿರ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಆಗಿದೆ

ಫಂಕ್ಷನ್ foo() ($a = 0; ಪ್ರತಿಧ್ವನಿ $a; $a = $a + 1;) foo(); // 0 foo(); // 0 foo(); // 0

PHP ಯಲ್ಲಿ, ವೇರಿಯೇಬಲ್‌ಗಳು ಸ್ಥಳೀಯವಾಗಿರುತ್ತವೆ. ಇದರರ್ಥ ಒಂದು ಫಂಕ್ಷನ್ (ವಿಧಾನ) ಒಳಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ನೀಡಿದ ವೇರಿಯೇಬಲ್ ಆ ಕಾರ್ಯವನ್ನು (ವಿಧಾನ) ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ. ವಿಧಾನದಿಂದ ನಿರ್ಗಮಿಸುವಾಗ, ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ನಾಶವಾಗುತ್ತದೆ, ಮತ್ತು ಮರು-ಪ್ರವೇಶಿಸುವಾಗ, ಅದನ್ನು ಹೊಸದಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ. ಮೇಲಿನ ಕೋಡ್‌ನಲ್ಲಿ, ಅಂತಹ ಸ್ಥಳೀಯ ವೇರಿಯೇಬಲ್ $a ವೇರಿಯೇಬಲ್ ಆಗಿದೆ - ಇದು foo() ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ಈ ಕಾರ್ಯವನ್ನು ಕರೆಯುವಾಗ ಹೊಸದಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ. ಈ ಕೋಡ್‌ನಲ್ಲಿ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವುದು ಅರ್ಥಹೀನವಾಗಿದೆ, ಏಕೆಂದರೆ ಕೋಡ್‌ನ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ ಕಾರ್ಯವು ತನ್ನ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ವೇರಿಯೇಬಲ್‌ನ ಮೌಲ್ಯವು ಕಳೆದುಹೋಗುತ್ತದೆ. ನಾವು foo() ಕಾರ್ಯವನ್ನು ಎಷ್ಟು ಬಾರಿ ಕರೆದರೂ ಅದು ಯಾವಾಗಲೂ 0 ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ...

ಆದಾಗ್ಯೂ, ನಾವು ನಿಯೋಜನೆಯ ಮೊದಲು ಸ್ಥಿರ ಕೀವರ್ಡ್ ಅನ್ನು ಹಾಕಿದರೆ ಎಲ್ಲವೂ ಬದಲಾಗುತ್ತದೆ:

ಫಂಕ್ಷನ್ ಫೂ() (ಸ್ಥಿರ $a = 0; ಪ್ರತಿಧ್ವನಿ $a; $a = $a + 1;) foo(); // 0 foo(); // 1 ಫೂ(); // 2

ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್‌ಗೆ ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸುವ ಮೊದಲು ಬರೆಯಲಾದ ಸ್ಥಿರ ಕೀವರ್ಡ್ ಈ ಕೆಳಗಿನ ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿದೆ:

1. ಕಾರ್ಯಕ್ಕೆ ಮೊದಲ ಕರೆಯಲ್ಲಿ ನಿಯೋಜನೆಯನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ
2. ಈ ರೀತಿಯಲ್ಲಿ ಗುರುತಿಸಲಾದ ವೇರಿಯೇಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಕಾರ್ಯವು ಮುಗಿದ ನಂತರ ಉಳಿಸಲಾಗುತ್ತದೆ.
3. ಕಾರ್ಯಕ್ಕೆ ನಂತರದ ಕರೆಗಳಲ್ಲಿ, ನಿಯೋಜನೆಯ ಬದಲಿಗೆ, ವೇರಿಯೇಬಲ್ ಹಿಂದೆ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ

ಸ್ಥಿರ ಪದದ ಈ ಬಳಕೆಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಸ್ಥಿರ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್.

ಸ್ಥಿರ ಅಸ್ಥಿರಗಳ ಮೋಸಗಳು

ಸಹಜವಾಗಿ, PHP ಯಲ್ಲಿ ಯಾವಾಗಲೂ, ಕೆಲವು ಮೋಸಗಳಿವೆ.

ಮೊದಲ ಕಲ್ಲು ಸ್ಥಿರ ವೇರಿಯಬಲ್‌ಗೆ ಸ್ಥಿರ ಅಥವಾ ಸ್ಥಿರ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಮಾತ್ರ ನಿಯೋಜಿಸಬಹುದು.ಕೋಡ್ ಇಲ್ಲಿದೆ:
ಸ್ಥಿರ $a = ಬಾರ್ ();
ಅನಿವಾರ್ಯವಾಗಿ ಪಾರ್ಸರ್ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಅದೃಷ್ಟವಶಾತ್, ಆವೃತ್ತಿ 5.6 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಸ್ಥಿರಾಂಕಗಳನ್ನು ಮಾತ್ರವಲ್ಲದೆ ನಿರಂತರ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಾಗಿದೆ (ಉದಾಹರಣೆಗೆ, “1+2” ಅಥವಾ “”), ಅಂದರೆ, ಇತರ ಕೋಡ್ ಅನ್ನು ಅವಲಂಬಿಸಿರದ ಮತ್ತು ಲೆಕ್ಕ ಹಾಕಬಹುದಾದ ಅಭಿವ್ಯಕ್ತಿಗಳು ಸಂಕಲನ ಹಂತದಲ್ಲಿ

ಎರಡನೆಯ ಕಲ್ಲು ವಿಧಾನಗಳು ಒಂದೇ ನಕಲಿನಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ.
ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗಿದೆ. ಸಾರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಕೋಡ್ ಇಲ್ಲಿದೆ:
ವರ್ಗ A (ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ foo() (ಸ್ಥಿರ $x = 0; ಪ್ರತಿಧ್ವನಿ ++$x;) ) $a1 = ಹೊಸ A; $a2 = ಹೊಸ A; $a1->foo(); // 1 $a2->foo(); // 2 $a1->foo(); // 3 $a2->foo(); // 4
"ವಿವಿಧ ವಸ್ತುಗಳು - ವಿಭಿನ್ನ ವಿಧಾನಗಳು" ಎಂಬ ಅರ್ಥಗರ್ಭಿತ ನಿರೀಕ್ಷೆಗೆ ವಿರುದ್ಧವಾಗಿ, PHP ಯಲ್ಲಿನ ಕ್ರಿಯಾತ್ಮಕ ವಿಧಾನಗಳು "ಗುಣಿಸುವುದಿಲ್ಲ" ಎಂದು ನಾವು ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ನೋಡುತ್ತೇವೆ. ನಾವು ಈ ವರ್ಗದ ನೂರು ವಸ್ತುಗಳನ್ನು ಹೊಂದಿದ್ದರೂ ಸಹ, ವಿಧಾನವು ಕೇವಲ ಒಂದು ನಿದರ್ಶನದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿರುತ್ತದೆ, ಇದು ಪ್ರತಿ ಕರೆಯೊಂದಿಗೆ ವಿಭಿನ್ನ $ ಅನ್ನು ಎಸೆಯಲಾಗುತ್ತದೆ.

ಈ ನಡವಳಿಕೆಯು ಇದಕ್ಕೆ ಸಿದ್ಧವಾಗಿಲ್ಲದ ಡೆವಲಪರ್‌ಗೆ ಅನಿರೀಕ್ಷಿತವಾಗಿರಬಹುದು ಮತ್ತು ದೋಷಗಳ ಮೂಲವಾಗಿರಬಹುದು. ವರ್ಗ (ಮತ್ತು ವಿಧಾನ) ಆನುವಂಶಿಕತೆಯು ಹೊಸ ವಿಧಾನದ ಸೃಷ್ಟಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಎಂದು ಗಮನಿಸಬೇಕು:

ವರ್ಗ A (ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ foo() (ಸ್ಥಿರ $x = 0; ಪ್ರತಿಧ್ವನಿ ++$x;) ) ವರ್ಗ B ವಿಸ್ತರಿಸುತ್ತದೆ A ( ) $a1 = ಹೊಸ A; $b1 = ಹೊಸ B; $a1->foo(); // 1 $b1->foo(); // 1 $a1->foo(); // 2 $b1->foo(); // 2

ತೀರ್ಮಾನ: PHP ಯಲ್ಲಿನ ಡೈನಾಮಿಕ್ ವಿಧಾನಗಳು ತರಗತಿಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ವಸ್ತುಗಳಲ್ಲ. ಮತ್ತು ರನ್ಟೈಮ್ನಲ್ಲಿ ಮಾತ್ರ "$this = current_object" ಪರ್ಯಾಯ ಸಂಭವಿಸುತ್ತದೆ

ಎರಡನೆಯ ಅರ್ಥವು ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವರ್ಗಗಳ ವಿಧಾನಗಳು

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

ವರ್ಗ A (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $x = "foo"; ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ ಪರೀಕ್ಷೆ() (ರಿಟರ್ನ್ 42; ) ) ಎಕೋ A::$x; // "ಫೂ" ಎಕೋ ಎ :: ಟೆಸ್ಟ್ (); // 42
ಅಂತಹ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ಡಬಲ್-ಕೊಲೊನ್ (“ಪಾಮಯಿಮ್ ನೆಕುಡೋಟೈಮ್”) ರಚನೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ CLASS_NAME::$Variablename ಮತ್ತು CLASS_NAME::Methodname().

ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ಸ್ಥಿರ ವಿಧಾನಗಳು ತಮ್ಮದೇ ಆದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮತ್ತು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಮೋಸಗಳನ್ನು ಹೊಂದಿವೆ ಎಂದು ಹೇಳದೆ ಹೋಗುತ್ತದೆ.

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

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

ಈ ರೀತಿಯ ಕೋಡ್:
ವರ್ಗ A (ಸಾರ್ವಜನಿಕ $id = 42; ಸ್ಥಿರ ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ foo() (echo $this->id; ) )
ನೀವು foo () ವಿಧಾನವನ್ನು ಅನುಚಿತವಾಗಿ ಬಳಸಲು ಪ್ರಯತ್ನಿಸದಿರುವವರೆಗೆ ಯಾವುದೇ ದೋಷಗಳನ್ನು ಉಂಟುಮಾಡುವುದಿಲ್ಲ:
$a = ಹೊಸ A; $a->foo();

(ಮತ್ತು ತಕ್ಷಣವೇ "ಮಾರಣಾಂತಿಕ ದೋಷ: ವಸ್ತುವಿನ ಸಂದರ್ಭದಲ್ಲಿ ಇಲ್ಲದಿದ್ದಾಗ $ಥಿಸ್ ಅನ್ನು ಬಳಸುವುದು")
ಎರಡನೆಯ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಸ್ಥಾಯಿಯು ಒಂದು ಮೂಲತತ್ವವಲ್ಲ!
ವರ್ಗ A (ಸ್ಥಿರ ಸಾರ್ವಜನಿಕ ಕಾರ್ಯ foo() (echo 42;) ) $a = ಹೊಸ A; $a->foo();

ಅಷ್ಟೇ, ಹೌದು. ಒಂದು ಸ್ಥಿರ ವಿಧಾನ, ಅದು ಕೋಡ್‌ನಲ್ಲಿ $ಥಿಸ್ ಅನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಆಬ್ಜೆಕ್ಟ್ ವಿಧಾನದಂತೆ ಡೈನಾಮಿಕ್ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆಯಬಹುದು. ಇದು PHP ಯಲ್ಲಿನ ದೋಷವಲ್ಲ.
ಹಿಮ್ಮುಖವು ಸಂಪೂರ್ಣವಾಗಿ ನಿಜವಲ್ಲ:
$ಥಿಸ್ ಅನ್ನು ಬಳಸದ ಡೈನಾಮಿಕ್ ವಿಧಾನವನ್ನು ಸ್ಥಿರ ಸಂದರ್ಭದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ನೀವು E_STRICT ಮಟ್ಟದಲ್ಲಿ "ಸ್ಥಿರವಲ್ಲದ ವಿಧಾನ A::foo() ಅನ್ನು ಸ್ಥಿರವಾಗಿ ಕರೆಯಬಾರದು" ಎಂಬ ಎಚ್ಚರಿಕೆಯನ್ನು ನೀವು ಸ್ವೀಕರಿಸುತ್ತೀರಿ. ಕೋಡ್ ಮಾನದಂಡಗಳನ್ನು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅನುಸರಿಸಬೇಕೆ ಅಥವಾ ಎಚ್ಚರಿಕೆಗಳನ್ನು ನಿಗ್ರಹಿಸಬೇಕೆ ಎಂದು ನಿರ್ಧರಿಸುವುದು ನಿಮಗೆ ಬಿಟ್ಟದ್ದು. ಮೊದಲನೆಯದು, ಸಹಜವಾಗಿ, ಯೋಗ್ಯವಾಗಿದೆ.

ಮತ್ತು ಮೂಲಕ, ಮೇಲೆ ಬರೆದ ಎಲ್ಲವೂ ವಿಧಾನಗಳಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ. "->" ಮೂಲಕ ಸ್ಥಿರ ಆಸ್ತಿಯನ್ನು ಬಳಸುವುದು ಅಸಾಧ್ಯ ಮತ್ತು ಮಾರಣಾಂತಿಕ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಮೂರನೇ ಅರ್ಥ, ಇದು ಅತ್ಯಂತ ಕಷ್ಟಕರವೆಂದು ತೋರುತ್ತದೆ - ತಡವಾದ ಸ್ಥಿರ ಬೈಂಡಿಂಗ್

PHP ಭಾಷೆಯ ಅಭಿವರ್ಧಕರು "ಸ್ಥಿರ" ಎಂಬ ಕೀವರ್ಡ್‌ನ ಎರಡು ಅರ್ಥಗಳಲ್ಲಿ ನಿಲ್ಲಲಿಲ್ಲ ಮತ್ತು ಆವೃತ್ತಿ 5.3 ರಲ್ಲಿ ಅವರು ಭಾಷೆಯ ಮತ್ತೊಂದು "ವೈಶಿಷ್ಟ್ಯವನ್ನು" ಸೇರಿಸಿದರು, ಅದನ್ನು ಅದೇ ಪದದೊಂದಿಗೆ ಅಳವಡಿಸಲಾಗಿದೆ! ಇದನ್ನು "ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್" ಅಥವಾ LSB (ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

LSB ಯ ಸಾರವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಸರಳ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ:

ವರ್ಗ ಮಾದರಿ (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $ಟೇಬಲ್ = "ಟೇಬಲ್"; ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ getTable() ( ಸ್ವಯಂ ಹಿಂತಿರುಗಿ ::$table; ) ) ಪ್ರತಿಧ್ವನಿ ಮಾದರಿ ::getTable(); // "ಟೇಬಲ್"
PHP ಯಲ್ಲಿನ ಸ್ವಯಂ ಕೀವರ್ಡ್ ಯಾವಾಗಲೂ "ಈ ಪದವನ್ನು ಬರೆಯಲಾದ ವರ್ಗದ ಹೆಸರು" ಎಂದರ್ಥ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ವಯಂ ಅನ್ನು ಮಾದರಿ ವರ್ಗದಿಂದ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಸ್ವಯಂ:: $ ಟೇಬಲ್ ಅನ್ನು ಮಾದರಿ:: $ ಟೇಬಲ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಲಾಗುತ್ತದೆ.
ಈ ಭಾಷಾ ವೈಶಿಷ್ಟ್ಯವನ್ನು "ಆರಂಭಿಕ ಸ್ಥಿರ ಬೈಂಡಿಂಗ್" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಏಕೆ ಬೇಗ? ಏಕೆಂದರೆ ಸ್ವಯಂ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ವರ್ಗದ ಹೆಸರಿನ ಬೈಂಡಿಂಗ್ ರನ್ಟೈಮ್ನಲ್ಲಿ ಸಂಭವಿಸುವುದಿಲ್ಲ, ಆದರೆ ಹಿಂದಿನ ಹಂತಗಳಲ್ಲಿ - ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡುವುದು. ಸರಿ, “ಸ್ಥಿರ” - ಏಕೆಂದರೆ ನಾವು ಸ್ಥಿರ ಗುಣಲಕ್ಷಣಗಳು ಮತ್ತು ವಿಧಾನಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ.

ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಸ್ವಲ್ಪ ಬದಲಾಯಿಸೋಣ:

ವರ್ಗ ಮಾದರಿ (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $ಟೇಬಲ್ = "ಟೇಬಲ್"; ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ getTable() (ರಿಟರ್ನ್ ಸ್ವಯಂ::$ಟೇಬಲ್; ) ) ವರ್ಗ ಬಳಕೆದಾರರು ಮಾದರಿಯನ್ನು ವಿಸ್ತರಿಸುತ್ತಾರೆ (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $ಟೇಬಲ್ = "ಬಳಕೆದಾರರು"; ) ಪ್ರತಿಧ್ವನಿ ಬಳಕೆದಾರ::getTable() ; // "ಟೇಬಲ್"

ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ PHP ಏಕೆ ಅರ್ಥಹೀನವಾಗಿ ವರ್ತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈಗ ನೀವು ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ. ಬಳಕೆದಾರ ವರ್ಗದ ಬಗ್ಗೆ ಏನೂ ತಿಳಿದಿಲ್ಲದಿದ್ದಾಗ ಸ್ವಯಂ ಮಾದರಿ ವರ್ಗದೊಂದಿಗೆ ಸಂಬಂಧ ಹೊಂದಿತ್ತು ಮತ್ತು ಆದ್ದರಿಂದ ಮಾದರಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ನಾನು ಏನು ಮಾಡಬೇಕು?

ಈ ಸಂದಿಗ್ಧತೆಯನ್ನು ಪರಿಹರಿಸಲು, ರನ್ಟೈಮ್ ಹಂತದಲ್ಲಿ "ಲೇಟ್" ಬೈಂಡಿಂಗ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಕಂಡುಹಿಡಿಯಲಾಯಿತು. ಇದು ತುಂಬಾ ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ - "ಸ್ವಯಂ" ಪದದ ಬದಲಿಗೆ "ಸ್ಥಿರ" ಎಂದು ಬರೆಯಿರಿ ಮತ್ತು ಈ ಕೋಡ್ ಅನ್ನು ಕರೆಯುವ ವರ್ಗದೊಂದಿಗೆ ಸಂಪರ್ಕವನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬರೆಯಲಾದ ಒಂದರೊಂದಿಗೆ ಅಲ್ಲ:
ವರ್ಗ ಮಾದರಿ (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $ಟೇಬಲ್ = "ಟೇಬಲ್"; ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ ಕಾರ್ಯ getTable() (ರಿಟರ್ನ್ ಸ್ಟ್ಯಾಟಿಕ್::$ಟೇಬಲ್; ) ) ವರ್ಗ ಬಳಕೆದಾರರು ಮಾದರಿಯನ್ನು ವಿಸ್ತರಿಸುತ್ತಾರೆ (ಸಾರ್ವಜನಿಕ ಸ್ಥಿರ $ಟೇಬಲ್ = "ಬಳಕೆದಾರರು"; ) ಪ್ರತಿಧ್ವನಿ ಬಳಕೆದಾರ ::getTable() ; // "ಬಳಕೆದಾರರು"

ಇದು ನಿಗೂಢ "ಲೇಟ್ ಸ್ಟ್ಯಾಟಿಕ್ ಬೈಂಡಿಂಗ್" ಆಗಿದೆ.

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

ಸಂತೋಷದ ಸಂದರ್ಶನಗಳು!