វិសាលភាពនៃអថេរគឺជាបរិបទដែលអថេរត្រូវបានកំណត់។

ក្នុងករណីភាគច្រើន អថេរ PHP ទាំងអស់មានវិសាលភាពតែមួយប៉ុណ្ណោះ។ វិសាលភាពតែមួយនេះក៏គ្របដណ្តប់ឯកសារដែលបានរួមបញ្ចូល និងដែលត្រូវការផងដែរ។ ឧទាហរណ៍៖
$a = 1 ;
?>

រួមបញ្ចូល "b.inc" ;

នៅទីនេះអថេរ $a នឹងមាននៅក្នុងស្គ្រីប b.inc ដែលរួមបញ្ចូល។ ទោះយ៉ាងណាក៏ដោយ និយមន័យ (តួ) នៃមុខងារកំណត់ដោយអ្នកប្រើប្រាស់ បញ្ជាក់ពីវិសាលភាពមូលដ្ឋាននៃមុខងារនោះ។ អថេរណាមួយដែលប្រើក្នុងអនុគមន៍គឺតាមលំនាំដើមកំណត់ចំពោះវិសាលភាពមូលដ្ឋានរបស់អនុគមន៍។

ឧទាហរណ៍៖
{
$a = 1 ; // វិសាលភាពសកល*/
}

ការធ្វើតេស្តមុខងារ ()
?>

បន្ទរ $a ;

/* យោងទៅអថេរវិសាលភាពមូលដ្ឋាន */ តេស្ត ();

ស្គ្រីបនេះនឹងមិនបង្កើតលទ្ធផលណាមួយទេ ដោយសារសេចក្តីថ្លែងការណ៍អេកូចង្អុលទៅកំណែមូលដ្ឋាននៃអថេរ $a ហើយវាមិនត្រូវបានផ្តល់តម្លៃនៅក្នុងវិសាលភាពនោះទេ។ អ្នកប្រហែលជាបានកត់សម្គាល់ឃើញថាវាខុសគ្នាបន្តិចបន្តួចពី C នៅក្នុងដែលអថេរសកលនៅក្នុង C អាចប្រើបានដោយស្វ័យប្រវត្តិចំពោះមុខងារ លុះត្រាតែពួកវាត្រូវបានសរសេរជាន់ពីលើដោយនិយមន័យក្នុងស្រុក។ នេះអាចបណ្តាលឱ្យមានបញ្ហាមួយចំនួន ដោយសារមនុស្សអាចផ្លាស់ប្តូរអថេរសកលដោយចៃដន្យ។ នៅក្នុង PHP ប្រសិនបើអថេរសកលត្រូវប្រើក្នុងមុខងារមួយ វាត្រូវតែត្រូវបានប្រកាសជាសកលនៅក្នុងនិយមន័យមុខងារ។ តេស្ត ();:

ពាក្យគន្លឹះ តេស្ត ();

ក្នុងករណីភាគច្រើន អថេរ PHP ទាំងអស់មានវិសាលភាពតែមួយប៉ុណ្ណោះ។ វិសាលភាពតែមួយនេះក៏គ្របដណ្តប់ឯកសារដែលបានរួមបញ្ចូល និងដែលត្រូវការផងដែរ។ ឧទាហរណ៍៖
សកល

ជាដំបូងឧទាហរណ៍នៃការប្រើប្រាស់
{
ឧទាហរណ៍ទី 1 ការប្រើប្រាស់

$b = 2 ;
}

ផលបូក()
សកល $a, $b;
?>

$b = $a + $b ; 3 ផលបូក();

បន្ទរ $b ;

$GLOBALS គឺ​ជា​អារេ​សហការ​ដែល​កូនសោ​គឺ​ឈ្មោះ​និង​តម្លៃ​ជា​ខ្លឹមសារ​នៃ​អថេរ​សកល។ សូមចំណាំថា $GLOBALS មាននៅក្នុងវិសាលភាពណាមួយ នេះគឺដោយសារតែ $GLOBALS ជាសកល។

ខាងក្រោមនេះជាឧទាហរណ៍ដែលបង្ហាញពីសមត្ថភាពរបស់ superglobals៖

ឧទាហរណ៍ #3 មហាសកល និងវិសាលភាព
{
មុខងារ test_global()
// អថេរដែលបានកំណត់ជាមុនភាគច្រើនគឺមិនមែនទេ។
// "អស្ចារ្យ" និងអាចរកបាននៅក្នុងតំបន់
// ភាពមើលឃើញ មុខងារតម្រូវឱ្យបញ្ជាក់ "សកល" ។

សកល $ HTTP_POST_VARS ;

អេកូ $HTTP_POST_VARS["ឈ្មោះ"];
// Superglobals មាននៅក្នុងវិសាលភាពណាមួយ។
// ភាពមើលឃើញនិងមិនតម្រូវឱ្យមាន "សកល" ត្រូវបានបញ្ជាក់។
// Superglobals មានតាំងពី PHP 4.1.0 និង
// ការប្រើប្រាស់ HTTP_POST_VARS ត្រូវបានបដិសេធ។
}
?>

បន្ទរ $_POST ["ឈ្មោះ" ];:

មតិយោបល់ តេស្ត ();ការប្រើប្រាស់ពាក្យគន្លឹះ

នៅខាងក្រៅមុខងារមិនមែនជាកំហុសទេ។ វា​អាច​ត្រូវ​បាន​ប្រើ​ក្នុង​ឯកសារ​ដែល​ត្រូវ​បាន​រួម​បញ្ចូល​ក្នុង​មុខងារ​មួយ។ ការប្រើប្រាស់ឋិតិវន្ត (ឋិតិវន្ត

) អថេរ លក្ខណៈសំខាន់មួយទៀតនៃវិសាលភាពអថេរគឺឋិតិវន្ត

អថេរ។ អថេរឋិតិវន្តមាននៅក្នុងវិសាលភាពមូលដ្ឋាននៃអនុគមន៍មួយប៉ុណ្ណោះ ប៉ុន្តែមិនបាត់បង់តម្លៃរបស់វានៅពេលដែលការប្រតិបត្តិកម្មវិធីចាកចេញពីវិសាលភាពនោះ។ សូមពិចារណាឧទាហរណ៍ខាងក្រោម៖

ឧទាហរណ៍ #4 បង្ហាញពីតម្រូវការសម្រាប់អថេរឋិតិវន្ត
{
ការធ្វើតេស្តមុខងារ ()
$a = 0 ;
បន្ទរ $a ;
}
?>

$a++; 0 មុខងារនេះពិតជាគ្មានប្រយោជន៍ទេ ព្រោះរាល់ពេលដែលគេហៅវាកំណត់ $a ទៅ 0 និងលទ្ធផល

. ការកើនឡើងនៃអថេរ $a ++ មិនដើរតួនាទីនៅទីនេះទេ ដោយសារអថេរ $a បាត់នៅពេលមុខងារចេញ។ ដើម្បីសរសេរមុខងាររាប់មានប្រយោជន៍ដែលមិនបាត់បង់តម្លៃរាប់បច្ចុប្បន្ន អថេរ $a ត្រូវបានប្រកាសថាឋិតិវន្ត៖

ឧទាហរណ៍ #4 បង្ហាញពីតម្រូវការសម្រាប់អថេរឋិតិវន្ត
{
ឧទាហរណ៍ #5 ឧទាហរណ៍នៃការប្រើប្រាស់អថេរឋិតិវន្ត
$a = 0 ;
បន្ទរ $a ;
}
?>

ឋិតិវន្ត $a = 0 ; ឥឡូវនេះ $a នឹងត្រូវបានចាប់ផ្តើមតែនៅលើការហៅមុខងារដំបូងប៉ុណ្ណោះ និងការហៅមុខងារនីមួយៗតេស្ត ()

នឹងបោះពុម្ពតម្លៃ $a ហើយបង្កើនវា។

បន្ទរ $_POST ["ឈ្មោះ" ];:

អថេរឋិតិវន្តអាចត្រូវបានប្រកាសដូចដែលបានបង្ហាញក្នុងឧទាហរណ៍មុន។ ការប៉ុនប៉ងកំណត់តម្លៃទៅអថេរទាំងនេះដែលជាលទ្ធផលនៃកន្សោមនឹងបណ្តាលឱ្យមានកំហុសក្នុងដំណើរការ។

ឧទាហរណ៍ #7 ការប្រកាសអថេរឋិតិវន្ត

មុខងារ foo ()(
ឋិតិវន្ត $int = 0 ; // ត្រូវហើយ។
ឋិតិវន្ត $int = 1 + 2 ; // មិនត្រឹមត្រូវ (ព្រោះវាជាកន្សោម)
ឋិតិវន្ត $int = sqrt(121); // មិន​ត្រឹម​ត្រូវ (ព្រោះ​នេះ​ក៏​ជា​កន្សោម​ដែរ)

$int++;
បន្ទរ $int ;
}
?>

បន្ទរ $_POST ["ឈ្មោះ" ];:

សេចក្តីប្រកាសឋិតិវន្តត្រូវបានវាយតម្លៃកំឡុងពេលចងក្រងស្គ្រីប។

តំណភ្ជាប់ជាមួយសកល ( តេស្ត ();) និងឋិតិវន្ត ( ការប្រើប្រាស់ឋិតិវន្ត () អថេរ

Zend Engine 1 ដែលផ្តល់ថាមពលដល់ PHP 4 ចាត់ទុកការកែប្រែអថេរឋិតិវន្ត និងសកលជាឯកសារយោង។ ឧទាហរណ៍ អថេរសកលពិតដែលបង្កប់ក្នុងវិសាលភាពនៃមុខងារដោយបញ្ជាក់ពាក្យគន្លឹះ តេស្ត ();ជាធរមាន បង្កើតសេចក្តីយោងទៅអថេរសកល។ នេះអាចនាំឱ្យមានអាកប្បកិរិយាដែលមិននឹកស្មានដល់ ដូចដែលបានបង្ហាញក្នុងឧទាហរណ៍ខាងក្រោម៖

មុខងារ test_global_ref() (
សកល $obj ;
$obj = &new stdclass ;
}

មុខងារ test_global_noref() (
សកល $obj ;
$obj = stdclass ថ្មី ;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

លទ្ធផលនៃការដំណើរការឧទាហរណ៍នេះ៖ get_instance_noref () (
ឋិតិវន្ត $obj ;

អេកូ "វត្ថុឋិតិវន្ត៖";
var_dump($obj);
ប្រសិនបើ (!isset($obj)) (
// កំណត់វត្ថុមួយទៅអថេរឋិតិវន្ត
$obj = stdclass ថ្មី ;
}
$obj -> ទ្រព្យសម្បត្តិ ++;
ត្រឡប់ $obj ;
}

$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
បន្ទរ "\n" ;
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>

លទ្ធផលនៃការដំណើរការឧទាហរណ៍នេះ៖

វត្ថុឋិតិវន្ត៖ NULL
វត្ថុឋិតិវន្ត៖ NULL

វត្ថុឋិតិវន្ត៖ NULL
វត្ថុឋិតិវន្ត៖ object(stdClass)(1)(
["ទ្រព្យសម្បត្តិ"]=>
int(1)
}

ឧទាហរណ៍នេះបង្ហាញថា នៅពេលអ្នកកំណត់សេចក្តីយោងទៅអថេរឋិតិវន្ត វាមិនមែនទេ។ គួរឱ្យចងចាំនៅពេលអ្នកហៅមុខងារ &get_instance_ref()ជាលើកទីពីរ។

វិសាលភាពអថេរគឺជាបរិបទដែលអថេរនោះត្រូវបានកំណត់។ អថេរ PHP ភាគច្រើនមានវិសាលភាពតែមួយ។ វិសាលភាពតែមួយនេះ (ហៅផងដែរថាវិសាលភាពសកល) ក៏គ្របដណ្តប់ឯកសាររួមបញ្ចូលផងដែរ៖

ក្នុងឧទាហរណ៍នេះ អថេរ $a ក៏នឹងមាននៅក្នុងស្គ្រីបដែលបានរួមបញ្ចូលផងដែរ - main.inc .

អថេរក្នុងស្រុក

និយមន័យមុខងារផ្ទាល់ខ្លួនបញ្ជាក់ វិសាលភាពក្នុងស្រុកសម្រាប់អថេរ i.e. អថេរណាមួយដែលប្រើនៅក្នុងអនុគមន៍គឺតាមលំនាំដើមកំណត់ចំពោះវិសាលភាពមូលដ្ឋាននៃអនុគមន៍ (អាចប្រើបានតែក្នុងអនុគមន៍ដែលវាត្រូវបានកំណត់)។ របៀបដែលវាដំណើរការ៖ ដើម្បីបំបែកអថេរដែលប្រើក្នុងកូដទូទៅពីអថេរដែលប្រើក្នុងមុខងារ PHP ផ្តល់នូវការផ្ទុកដាច់ដោយឡែកសម្រាប់អថេរនៅក្នុងមុខងារនីមួយៗ។ ការបែងចែកទំហំផ្ទុកនេះបង្កប់ន័យថា វិសាលភាព ពោលគឺតំបន់ដែលតម្លៃនៃអថេរអាចប្រើបាន គឺជាកន្លែងផ្ទុកមូលដ្ឋានរបស់មុខងារ។

ឧទាហរណ៍ខាងក្រោមបង្ហាញយ៉ាងច្បាស់ថាអថេរដែលបានប្រកាសនៅខាងក្រៅអនុគមន៍មិនផ្លាស់ប្តូរនៅក្នុងអនុគមន៍ទេ។ ខណៈពេលដែលអ្នកមិនគួរព្យាយាមយល់ពីរបៀបដែលមុខងារដំណើរការ រឿងសំខាន់គឺថាវាមានសំណុំអថេរតែមួយគត់របស់វា៖

30 ?>

ជាលទ្ធផលនៃការប្រតិបត្តិបំណែកនេះ ខាងក្រោមនេះនឹងត្រូវបានបង្ហាញ៖ 30.

នៅក្នុងមុខងារ born() អថេរ $age ត្រូវបានកំណត់ជា 1 ប៉ុន្តែនេះមិនមែនជាអថេរដូចគ្នាដែលត្រូវបានកំណត់ក្នុងវិសាលភាពសកលទេ។ ដូច្នេះនៅពេលដែលតម្លៃនៃអថេរ $age ត្រូវបានបោះពុម្ព តម្លៃដើមនៃ 30 ត្រូវបានបោះពុម្ព វាគួរអោយកត់សំគាល់ថាអថេរមូលដ្ឋានត្រូវបានបង្កើតនៅពេលមុខងារត្រូវបានហៅ ហើយត្រូវបានលុបបន្ទាប់ពីមុខងារបញ្ចប់។

ប្រសិនបើអ្នកពិតជាចង់អាន ឬផ្លាស់ប្តូរតម្លៃនៃអថេរសកល (ដូចដែលអថេរដែលប្រើក្នុងវិសាលភាពសកលត្រូវបានគេហៅថា) ជាជាងមូលដ្ឋាននៅក្នុងអនុគមន៍កំណើត () វាត្រូវតែត្រូវបានប្រកាសជាសកលនៅក្នុងនិយមន័យមុខងារ។

ដើម្បីបង្កើតគេហទំព័រពេញលេញមួយដែលមានមុខងារធំទូលាយអ្នកត្រូវដឹងច្រើន។ ទោះយ៉ាងណាក៏ដោយ PHP អាចផ្តល់ឱ្យគេហទំព័រនូវភាពពិសេសពិតប្រាកដមួយ។ ភាសាសរសេរកម្មវិធីនេះមិនប្រើអថេរសកលញឹកញាប់ទេ ប៉ុន្តែពេលខ្លះវាមានប្រយោជន៍ខ្លាំងណាស់ក្នុងការដឹងពីរបៀបដែលវាដំណើរការ។

នៅក្នុងអត្ថបទនេះ យើងនឹងសិក្សាឱ្យច្បាស់ថាតើអថេរសកលគឺជាអ្វី និងរបៀបដែលវាដំណើរការ។

អថេរសកល៖ វិសាលភាព
បរិបទដែលអថេរត្រូវបានកំណត់ត្រូវបានគេហៅថាវិសាលភាពរបស់វា។ ជាធម្មតា អថេរមានវិសាលភាពតែមួយប៉ុណ្ណោះ។ នៅពេលដែលអថេរសកលនៅក្នុង PHP ត្រូវបានផ្ទុកពីឯកសារផ្សេងទៀត ពួកវាអាចត្រូវបានទាមទារ ឬរួមបញ្ចូល។ ពួកវាត្រូវបានកំណត់តាមលំនាំដើមចំពោះវិសាលភាពមូលដ្ឋាននៃមុខងារ។ តើអ្នកអាចធ្វើឱ្យអថេរដែលអាចមើលឃើញដោយឯកសារហួសពីព្រំដែនរបស់វា ហើយក៏អាចប្រើវាបានដោយរបៀបណា? នេះជាមូលហេតុដែល PHP ផ្តល់អថេរសកល។ ពាក្យសំខាន់នៅទីនេះគឺ "សកល" ។ តើធ្វើដូចម្តេចដើម្បីប្រកាសអថេរសកលនៅក្នុង PHP? ដើម្បីសម្រេចបាននូវគោលដៅនេះ ពាក្យ "សកល" ត្រូវតែប្រើ។ វាត្រូវតែត្រូវបានដាក់ភ្លាមៗមុនពេលអថេរដែលអ្នកចង់បង្កើតជាសកល។ វាមើលទៅដូចនេះ៖ "អថេរ" សកល។ បន្ទាប់ពីអនុវត្តការណែនាំប្រភេទនេះ ឯកសារណាមួយនឹងអាចដំណើរការជាមួយទិន្នន័យបាន។

ប្រសិនបើមានឯកសារយោងទៅអថេរនេះនៅកន្លែងណាមួយ កម្មវិធីនឹងយកចិត្តទុកដាក់ចំពោះកំណែសកល។ ហេតុអ្វីបានជាគេប្រើពាក្យចម្លែកបែបនេះ? រឿងនេះគឺថានៅពេលជាមួយគ្នានោះកំណែក្នុងស្រុកក៏អាចមានផងដែរ។ ប៉ុន្តែពួកវានឹងអាចចូលប្រើបានច្រើនតែនៅក្នុងឯកសារដែលពួកគេត្រូវបានប្រកាស។ សម្រាប់អ្វីដែលនៅសល់ អថេរថ្នាក់ PHP សកលនឹងអនុវត្ត។ នៅទីនេះអ្នកត្រូវធ្វើសកម្មភាពយ៉ាងប្រុងប្រយ័ត្ននិងដោយប្រុងប្រយ័ត្ន។ ដើម្បីបងា្ករការសង្ស័យណាមួយ ចូរយើងផ្តល់ឧទាហរណ៍ដ៏សាមញ្ញមួយអំពីរបៀបដែលពួកគេអាចមើលទៅ៖ សកល a. ប្រសិនបើឯកសារមួយមានសិទ្ធិចូលប្រើអថេរច្រើន វាអាចបណ្តាលឱ្យមានជម្លោះ។ ប៉ុន្តែវាមិនអាចទៅរួចទេក្នុងការនិយាយឱ្យប្រាកដនៅទីនេះថាតើអថេរសកល ឬមូលដ្ឋាននឹងត្រូវបានអាន ឬថាតើកំហុសនឹងកើតឡើង។ ប្រសិនបើអ្នកសរសេរវានៅខាងក្នុងមុខងារ នោះគ្មានបញ្ហាអ្វីកើតឡើងទេ។ ការប្រើអថេរនៅខាងក្រៅព្រំដែននៃអនុគមន៍នឹងមានបញ្ហា។ ដូច្នេះហើយ អ្នកចាំបាច់ត្រូវត្រួតពិនិត្យយ៉ាងប្រុងប្រយ័ត្ននូវរចនាសម្ព័ន្ធនៃកូដ ហើយត្រូវប្រាកដថាមិនមានតម្រូវការជាមុនសម្រាប់ជម្លោះនៅកន្លែងណាមួយឡើយ។

អថេរសកល៖ សញ្ញាណមួយទៀត
តើមានវិធីផ្សេងទៀតដើម្បីកំណត់អថេរសកលទេ? បាទ/ចាស មិនមែនតែម្នាក់ឯងទេ។ សូមក្រឡេកមើល $GLOBALS ជាមុនសិន។ វា​គឺ​ជា​អារេ​សហការ​ដែល​កូនសោ​ជា​ឈ្មោះ។ មាតិកានៃអថេរសកលត្រូវបានប្រើជាតម្លៃ។ វាគួរឱ្យកត់សម្គាល់ថាបន្ទាប់ពីការប្រកាសអារេនេះមាននៅក្នុងវិសាលភាពណាមួយ។ នេះផ្តល់ហេតុផលដើម្បីចាត់ទុកថាវាជាសកល។ វាមើលទៅដូចនេះ៖ $GLOBALS ['Variable'] ។

សកលលោក
នៅក្នុងភាសាសរសេរកម្មវិធីណាមួយ មានឈ្មោះដែលត្រូវបានបម្រុងទុកសម្រាប់មុខងារនីមួយៗ។ វាមិនអាចបង្កើតអថេរសកលនៃឈ្មោះដូចគ្នានៅក្នុង PHP បានទេ។ ភាសាសរសេរកម្មវិធីនេះមានលក្ខណៈផ្ទាល់ខ្លួនរបស់វា។ ជាឧទាហរណ៍ វាមានសារៈសំខាន់ជាពិសេសដែលអថេរដែលបានកំណត់ជាមុនមិនមានបុព្វបទ "super" ទេ។ នេះមានន័យថា ពួកវាមិនមាននៅគ្រប់ទីតាំងទាំងអស់ទេ។ តើ​ស្ថានភាព​នេះ​អាច​ត្រូវ​បាន​កែ​តម្រូវ​ដោយ​របៀប​ណា? ដើម្បីធ្វើឱ្យអថេរដែលបានកំណត់ជាមុនមាននៅលើបណ្តាញមូលដ្ឋានមួយចំនួន អ្នកត្រូវប្រកាសវាដូចនេះ៖ "អថេរ" សកល។ នេះ​ត្រូវ​បាន​លើក​ឡើង​រួច​ហើយ​មុន​នេះ​បន្តិច។ ទោះយ៉ាងណាក៏ដោយនេះមិនពិតទាំងស្រុងទេ។ សូមក្រឡេកមើលឧទាហរណ៍ជាក់ស្តែង៖
សកល $HTTP_POST_VARS; បន្ទរ $HTTP_POST_VARS ['name']។
តើអ្នកមានអារម្មណ៍ខុសគ្នាទេ? វាគួរអោយចងចាំថានៅក្នុង PHP អថេរសកលត្រូវតែប្រើក្នុងមុខងារមួយ។ វាក៏អាចមានទីតាំងនៅក្នុងឯកសារដែលត្រូវបានរួមបញ្ចូលនៅក្នុងវា។

សុវត្ថិភាព និងតំណភ្ជាប់
ដូចដែលអ្នកអាចឃើញដោយខ្លួនឯង ការបង្កើតអថេរសកលនៅក្នុង PHP មិនមែនជាបញ្ហាទេ។ ប៉ុន្តែ​តើ​មាន​ភាព​ជាក់លាក់​ណាមួយ​ទាក់ទង​នឹង​តំណ​ដែរ​ឬ​ទេ? នៅពេលប្រើអថេរសកល អាកប្បកិរិយាដែលមិនរំពឹងទុកមួយចំនួនអាចធ្វើទៅបាន។ ប៉ុន្តែ​មុន​នឹង​សិក្សា​បញ្ហា​នេះ​ឱ្យ​បាន​លម្អិត​បន្ថែម​ទៀត​នោះ ចាំបាច់​ត្រូវ​ងាក​ទៅ​រក​សាវតារ។ ការណែនាំ register_globals ត្រូវបានប្តូរពីបានបើកទៅជាបិទតាមលំនាំដើមនៅក្នុងកំណែ 4.2។ សម្រាប់អ្នកប្រើប្រាស់ជាច្រើន នេះគឺមិនសំខាន់ទាំងស្រុង ហើយឥតប្រយោជន៍ទេ ព្រោះសុវត្ថិភាពនៃផលិតផលដែលកំពុងត្រូវបានបង្កើតដោយផ្ទាល់អាស្រ័យលើវា។ ប្រសិនបើអ្នកត្រូវការបង្កើតអថេរសកល នោះការណែនាំរបស់ PHP នឹងមិនប៉ះពាល់ដល់ការកំណត់នេះដោយផ្ទាល់ទេ។ ទោះយ៉ាងណាក៏ដោយ ការប្រើប្រាស់មិនត្រឹមត្រូវអាចក្លាយជាហានិភ័យសុវត្ថិភាព។ ដូច្នេះ ឧទាហរណ៍ ប្រសិនបើ register_globals ស្ថិតក្នុងស្ថានភាពបានបើក នោះអថេរចាំបាច់ផ្សេងៗនឹងត្រូវបានចាប់ផ្តើម មុនពេលកូដត្រូវបានប្រតិបត្តិ។ ដូច្នេះ​ហើយ ទើប​គេ​សម្រេច​បិទ​វា​ចោល។ ហេតុអ្វីបានជាអថេរសកលជំពាក់រដ្ឋច្រើនចំពោះការណែនាំដែលបានផ្តល់ឱ្យ? បញ្ហាគឺថានៅពេលដែលបើកដំណើរការ អ្នកអភិវឌ្ឍន៍មិនតែងតែអាចឆ្លើយសំណួរថាតើវាមកពីណានោះទេ ប៉ុន្តែផ្ទុយទៅវិញ វាបានជួយសម្រួលដល់ដំណើរការនៃការសរសេរកូដយ៉ាងខ្លាំង។ ទន្ទឹមនឹងនេះ អង្គការបែបនេះបានបង្កើតការគំរាមកំហែងជាក់លាក់មួយដល់សន្តិសុខ។ ដើម្បីជៀសវាងការលាយបញ្ចូលទិន្នន័យ និងកំហុស ការណែនាំត្រូវបានបិទ។ ឥឡូវនេះ សូមក្រឡេកមើលឧទាហរណ៍នៃកូដមិនមានសុវត្ថិភាព។ យើងក៏នឹងពិនិត្យមើលពីរបៀបដែលអ្នកអាចរកឃើញករណីនៅពេលដែលការប្រកាសនៃអថេរសកលរបស់ PHP ត្រូវបានអមដោយការប៉ុនប៉ងដើម្បីជំនួសព័ត៌មាន។ វាត្រូវបានទាមទារដើម្បីបង្កើតគេហទំព័រការងារដែលមានស្ថេរភាព ដែលមិនអាចត្រូវបានលួចចូលដោយអ្នកប្រើប្រាស់ដំបូងដែលឆ្លងកាត់ពួកវា។

លេខកូដគ្រោះថ្នាក់
ចូរកំណត់អថេរទៅពិតសម្រាប់អ្នកប្រើប្រាស់ទាំងនោះដែលត្រូវបានអនុញ្ញាត៖
ប្រសិនបើ (authenticate_user()) ($authoriza=true;) ប្រសិនបើ ($authorize) (រួមបញ្ចូល “/highly/sensitive/data.php”;) ។ អថេរនៅក្នុងស្ថានភាពនេះអាចត្រូវបានកំណត់ដោយស្វ័យប្រវត្តិ។ ដោយពិចារណាថាទិន្នន័យអាចត្រូវបានជំនួសដោយសាមញ្ញ ហើយប្រភពនៃប្រភពដើមរបស់វាមិនត្រូវបានបង្កើតឡើង នោះអ្នកប្រើប្រាស់ស្ទើរតែទាំងអស់អាចឆ្លងកាត់ការត្រួតពិនិត្យបែបនេះ និងក្លែងបន្លំនរណាម្នាក់បាន។ អ្នកវាយប្រហារ ប្រសិនបើចង់បាន អាចរំខានដល់តក្កវិជ្ជានៃស្គ្រីបទាំងមូល។ ប្រសិនបើអ្នកផ្លាស់ប្តូរតម្លៃនៃការណែនាំ នោះកូដនឹងដំណើរការត្រឹមត្រូវ។ នេះជាអ្វីដែលយើងត្រូវធ្វើ។ ទោះជាយ៉ាងណាក៏ដោយ ការចាប់ផ្ដើមអថេរមិនត្រឹមតែជាការអនុវត្តល្អក្នុងចំណោមអ្នកសរសេរកម្មវិធីប៉ុណ្ណោះទេ វាក៏ធានានូវស្ថេរភាពនៃស្គ្រីបផងដែរ។

ជម្រើសដែលអាចទុកចិត្តបាន។
ដើម្បីសម្រេចបាននូវគោលដៅនេះ អ្នកអាចព្យាយាមបិទការណែនាំ ឬសរសេរកូដស្មុគ្រស្មាញបន្ថែមទៀត ឧទាហរណ៍ដូចនេះ៖ if (isset($_SESSION ['username'])) (បន្ទរ “ជំរាបសួរ” ($_SESSION ['username'' ])”;) ផ្សេងទៀត (បន្ទរ “សួស្តីភ្ញៀវ”; បន្ទរ “សូមស្វាគមន៍!”;)។ ក្នុងករណីនេះវានឹងពិបាកក្នុងការធ្វើការជំនួស។ ទោះយ៉ាងណាក៏ដោយវាអាចទៅរួច។ ដើម្បីធ្វើដូច្នេះ អ្នកត្រូវមើលថែភាពអាចរកបាននៃឧបករណ៍ឆ្លើយតបរហ័សជាមុន។ ប្រសិនបើអ្នកត្រូវការបញ្ចូលអថេរសកលនៅក្នុង PHP អ្នកអាចប្រើឧបករណ៍ខាងក្រោម៖ ប្រសិនបើអ្នកដឹងច្បាស់ថាតម្លៃនឹងត្រូវបានទទួលនៅក្នុងជួរណានោះ អ្នកអាចសរសេរវាតាមរបៀបដែលស្គ្រីបពិនិត្យមើលការពិតដោយការប្រៀបធៀប។ ជាការពិតណាស់ នេះក៏មិនអាចធានាបាននូវការការពារ 100% ប្រឆាំងនឹងការជំនួសតម្លៃផងដែរ។ ទោះយ៉ាងណាក៏ដោយ ការឆ្លងកាត់ជម្រើសដែលអាចធ្វើបាននឹងធ្វើឱ្យប្រតិបត្តិការស្មុគស្មាញខ្លាំង។

តើធ្វើដូចម្តេចដើម្បីរកឃើញការប៉ុនប៉ងក្លែងបន្លំ?
ឥឡូវនេះ សូមពិនិត្យមើលថាតើអ្នកយល់គ្រប់យ៉ាងដែលបានសរសេរពីមុនបានត្រឹមត្រូវដែរឬទេ។ អ្នកនឹងត្រូវប្រកាសអថេរសកលនៅក្នុងមុខងារមួយដោយខ្លួនឯង។ នេះគឺជាប្រភេទនៃកិច្ចការផ្ទះ។ ដំបូង​នេះ​ជា​កូដ៖

ចូរយើងផ្តល់ការពន្យល់ខ្លះ។ អថេរ C_COOKIE ត្រូវបានយកចេញពីប្រភពដែលអាចទុកចិត្តបាន។ ដើម្បី​ប្រាកដ​ថា​លទ្ធផល​របស់​វា​គឺ​ដូច​ការ​រំពឹង​ទុក តម្លៃ​អថេរ​ត្រូវ​បាន​ពិនិត្យ។ ប្រសិនបើមានបញ្ហាកើតឡើង អ្នកគ្រប់គ្រងទទួលបានការជូនដំណឹង។ បើ​មិន​មាន​អ្វី​កើត​ឡើង​ទេ​នឹង​មិន​មាន​ចំណាត់ការ​អ្វី​ឡើយ។

ចំណាំ៖កំណែអាដាប់ធ័រនៃគេហទំព័រត្រូវបានធ្វើឱ្យសកម្ម ដែលសម្របខ្លួនដោយស្វ័យប្រវត្តិទៅនឹងទំហំតូចនៃកម្មវិធីរុករករបស់អ្នក និងលាក់ព័ត៌មានលម្អិតមួយចំនួននៃគេហទំព័រសម្រាប់ភាពងាយស្រួលនៃការអាន។ សូមរីករាយទស្សនា!

ជំរាបសួរអ្នកអានប្លក់ជាទីស្រឡាញ់ គេហទំព័រលើ!

• យើងបានរៀនថាមានមុខងារមួយនៅក្នុង PHP យើងបានរៀនពីរបៀបបង្កើតមុខងារផ្ទាល់ខ្លួនរបស់យើង បញ្ជូនអាគុយម៉ង់ទៅឱ្យពួកគេ ហើយហៅពួកវាសម្រាប់ប្រតិបត្តិ។ ការបន្តប្រធានបទនៃមុខងារនៅក្នុង PHP វាចាំបាច់ដើម្បីបញ្ជាក់រឿងដូចខាងក្រោម:
• នៅក្នុងមុខងារ អ្នកអាចប្រើកូដ PHP ណាមួយ (វដ្ត លក្ខខណ្ឌ ប្រតិបត្តិការណាមួយ) រួមទាំងមុខងារផ្សេងទៀត (ទាំងភ្ជាប់មកជាមួយ និងផ្ទាល់ខ្លួន)។
• ឈ្មោះមុខងារត្រូវតែចាប់ផ្តើមដោយអក្សរឡាតាំង ឬសញ្ញាគូសក្រោម បន្តដោយអក្សរឡាតាំង លេខ ឬសញ្ញាគូសខាងក្រោម។
• មុខងារទាំងអស់មានវិសាលភាពជាសកល ដែលមានន័យថាមុខងារណាមួយអាចត្រូវបានគេហៅថាគ្រប់ទីកន្លែង ទោះបីជាមុខងារនោះត្រូវបានកំណត់នៅខាងក្នុងមួយផ្សេងទៀតក៏ដោយ។
• មុខងារមិនចាំបាច់ត្រូវបានកំណត់មុនពេលពួកវាត្រូវបានប្រើទេ។ នោះគឺប្រសិនបើអ្នកហៅមុខងារមួយជាលើកដំបូង ហើយគ្រាន់តែពណ៌នាវានៅក្នុងកូដខាងក្រោម វានឹងមិនប៉ះពាល់ដល់ដំណើរការទេ ហើយនឹងមិនបង្កឱ្យមានកំហុសឡើយ។

មុខងារតាមលក្ខខណ្ឌ

យើងអាចបង្កើត (កំណត់ ពិពណ៌នា) មុខងារមួយអាស្រ័យលើលក្ខខណ្ឌ។ ឧទាហរណ៍៖

// ហៅថាមុខងារ sayHi វាអាចហៅបានគ្រប់ទីកន្លែង /* មុខងារ sayGoodbye មិន​អាច​ហៅ​បាន​នៅ​ទី​នេះ​ទេ ព្រោះ​យើង​មិន​ទាន់​បាន​ពិនិត្យ​លក្ខខណ្ឌ និង​មិន​បាន​ចូល​ទៅ​ក្នុង if construct*/ if($apply)(មុខងារ sayGoodbye())(បន្ទរ "សួស្តីអ្នកទាំងអស់គ្នា!
"; } } /* ឥឡូវនេះយើងអាចហៅពាក្យថា Goodbye*/
"; }

លទ្ធផល៖

ហើយមើលឧទាហរណ៍នេះ៖

/* ហើយនេះជាអ្វីដែលនឹងកើតឡើង ប្រសិនបើអ្នកហៅពាក្យថា Goodbye here*/លាហើយ (); if($apply)(មុខងារ sayGoodbye())(បន្ទរ "សួស្តីអ្នកទាំងអស់គ្នា!
"; )) មុខងារ sayHi())(បន្ទរ "សួស្តីអ្នកទាំងអស់គ្នា!
"; }

លទ្ធផល៖

តាម​ពិត​ទៅ ដូច​ជា​ខ្ញុំ​ធ្លាប់​ធ្វើ​ការ ខ្ញុំ​មិន​ដែល​ឃើញ​រឿង​បែប​នេះ​នៅ​កន្លែង​ណា​ទេ ប៉ុន្តែ​អ្នក​ត្រូវ​ចងចាំ​ពី​លទ្ធភាព​ទាំងអស់​នៃ​ភាសា។

មុខងារដែលបានដាក់

អនុគមន៍​ដែល​ជាប់​គ្នា​គឺ​ជា​អនុគមន៍​ដែល​បាន​ប្រកាស​នៅ​ក្នុង​អនុគមន៍​ផ្សេង​ទៀត។ ឧទាហរណ៍៖

/* អ្នកមិនអាចហៅពាក្យថា Goodbye នៅទីនេះបានទេ ព្រោះវានឹងបង្ហាញតែបន្ទាប់ពីហៅមុខងារ sayHi*/ sayHi(); /* ហៅមុខងារ sayHi វាអាចហៅបានគ្រប់ទីកន្លែង*/ /* ឥឡូវនេះយើងអាចហៅពាក្យថា Goodbye*/លាហើយ (); មុខងារ sayHi())(បន្ទរ "សួស្តីអ្នកទាំងអស់គ្នា!
"; មុខងារ say Goodbye()) (បន្ទរ "សួស្តីអ្នកទាំងអស់គ្នា!
"; } }

ជាថ្មីម្តងទៀត នៅលើការឆ្លងកាត់ដំបូង អ្នកបកប្រែ PHP សម្គាល់ខ្លួនវាថាវាបានរកឃើញការពិពណ៌នានៃមុខងារ sayHi ប៉ុន្តែមិនចូលទៅក្នុងខ្លួនរបស់វាទេ វាគ្រាន់តែឃើញឈ្មោះប៉ុណ្ណោះ ហើយចាប់តាំងពីអ្នកបកប្រែមិនចូលទៅក្នុងតួរបស់ sayHi បន្ទាប់មក វាមិនដឹងថាអ្វីដែលយើងកំពុងកំណត់នៅក្នុងមុខងារមួយផ្សេងទៀតនោះទេ - say Goodbye ។

បន្ទាប់មកកូដចាប់ផ្តើមប្រតិបត្តិ យើងហៅថា sayHi អ្នកបកប្រែ PHP ត្រូវចូលទៅក្នុងតួនៃអនុគមន៍ sayHi ដើម្បីប្រតិបត្តិវា ហើយនៅទីនោះវាបានរកឃើញការពិពណ៌នានៃមុខងារមួយផ្សេងទៀតដោយចៃដន្យ - sayGoodbye បន្ទាប់ពីនោះ sayGoodbye អាចហៅបានគ្រប់ទីកន្លែង ច្រើនដង។ ដូចដែលអ្នកចូលចិត្ត។

ប៉ុន្តែវាគួរអោយយកចិត្តទុកដាក់ចំពោះចំណុចដ៏ស្រទន់ក្នុងស្ថានភាពខាងលើ៖ មុខងារ sayHi ក្លាយជាតែម្តង ព្រោះប្រសិនបើយើងហៅវាម្តងទៀត PHP នឹងមកម្តងទៀតនូវនិយមន័យនៃមុខងារ sayGoodbye ហើយនៅក្នុង PHP អ្នកមិនអាចធ្វើបានទេ។ នេះ - អ្នកមិនអាចបដិសេធមុខងារបានទេ។ ខ្ញុំបានសរសេរអំពីរឿងនេះ និងរបៀបដោះស្រាយវានៅក្នុងអត្ថបទមុន។

នៅក្នុង PHP បច្ចេកទេសដែលបានពិពណ៌នាខាងលើត្រូវបានគេប្រើកម្រណាស់ ពួកគេអាចត្រូវបានគេមើលឃើញញឹកញាប់ជាងឧទាហរណ៍នៅក្នុង JavaScript ។

វិសាលភាពអថេរ

មានវិសាលភាពពីរយ៉ាងពិតប្រាកដនៅក្នុង PHP៖ សកលនិង ក្នុងស្រុក. រចនាសម្ព័ន្ធភាសាសរសេរកម្មវិធីនីមួយៗមានវិសាលភាពខុសៗគ្នា។ ឧទាហរណ៍ នៅក្នុង C ++ សូម្បីតែ loops មានវិសាលភាព (local) របស់ពួកគេ។ នៅក្នុង PHP ដោយវិធីនេះគឺជាវិសាលភាពសកល។ ប៉ុន្តែថ្ងៃនេះយើងកំពុងនិយាយអំពីមុខងារ។

មុខងារនៅក្នុង PHP មានវិសាលភាពផ្ទៃក្នុងផ្ទាល់ខ្លួន (local) ពោលគឺអថេរទាំងអស់នៅក្នុង function គឺអាចមើលឃើញតែនៅក្នុងមុខងារនេះប៉ុណ្ណោះ។

ដូច្នេះ ជាថ្មីម្តងទៀត៖ អ្វីគ្រប់យ៉ាងដែលនៅខាងក្រៅមុខងារគឺជាវិសាលភាពសកល អ្វីគ្រប់យ៉ាងដែលនៅខាងក្នុងមុខងារគឺជាវិសាលភាពក្នុងតំបន់។ ឧទាហរណ៍៖

សូមគោរពអ្នកជំនាញការយកចិត្តទុកដាក់សំណួរ! តើការណែនាំចុងក្រោយនឹងចេញអ្វីខ្លះ? បន្ទរ $name; ?

ដូចដែលអ្នកបានឃើញសម្រាប់ខ្លួនអ្នក យើងមាន 2 អថេរ $ ឈ្មោះមួយនៅខាងក្នុងអនុគមន៍ (វិសាលភាពក្នុងតំបន់) មួយទៀតនៅក្នុងកូដ (វិសាលភាពសកល) ការចាត់តាំងចុងក្រោយទៅអថេរ $ ឈ្មោះគឺ $name = "Rud Sergey";ប៉ុន្តែ​ដោយសារ​វា​នៅ​ក្នុង​មុខងារ វា​នៅ​ទីនោះ។ នៅក្នុងវិសាលភាពសកល កិច្ចការចុងក្រោយគឺ $name = "Andrey";ដែល​ជា​អ្វី​ដែល​យើង​ពិត​ជា​ឃើញ​ជា​លទ្ធផល។

នោះគឺជាអថេរពីរដូចគ្នា ប៉ុន្តែក្នុងវិសាលភាពផ្សេងៗគ្នា វាមិនប្រសព្វគ្នា និងមិនប៉ះពាល់ដល់គ្នាទៅវិញទៅមក។

ខ្ញុំសូមបង្ហាញវិសាលភាពក្នុងរូប៖

ក្នុងអំឡុងពេលឆ្លងកាត់លើកដំបូង អ្នកបកប្រែបានស្កែនវិសាលភាពជាសកលដោយសង្ខេប ដោយចងចាំនូវអថេរ និងមុខងារដែលមាន ប៉ុន្តែមិនប្រតិបត្តិកូដនោះទេ។

ការចូលប្រើអថេរសកលពីវិសាលភាពមូលដ្ឋាន

ប៉ុន្តែចុះយ៉ាងណាបើយើងនៅតែត្រូវចូលប្រើអថេរ $name ដូចគ្នាពីវិសាលភាពសកលពីមុខងារមួយ ហើយមិនត្រឹមតែចូលប្រើវាទេ ប៉ុន្តែត្រូវផ្លាស់ប្តូរវា? មានជម្រើសសំខាន់ 3 សម្រាប់រឿងនេះ។ ទីមួយគឺការប្រើពាក្យគន្លឹះ តេស្ត ();:

"; ឈ្មោះ $ សកល; /* ចាប់ពីពេលនេះតទៅ យើងមានន័យថាអថេរសកល $name*/$name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); បន្ទរ $name; // ?

លទ្ធផល៖

ប៉ុន្តែវិធីសាស្រ្តនេះមានគុណវិបត្តិចាប់តាំងពីយើងចូលប្រើអថេរសកល $ ឈ្មោះយើងបាត់បង់ (សរសេរជាន់លើ) អថេរមូលដ្ឋាន $ ឈ្មោះ.

វិធីទីពីរគឺត្រូវប្រើ អារេ PHP superglobal. PHP ខ្លួនវាដាក់អថេរនីមួយៗដែលយើងបានបង្កើតក្នុងវិសាលភាពសកលទៅក្នុងអារេនេះ។ ឧទាហរណ៍៖

$name = "Andrey"; // ដូចគ្នានឹង$GLOBALS["name"] = "Andrey";

ដូច្នេះ៖

"; $GLOBALS["name"] = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); បន្ទរ $name; // ?

លទ្ធផលគឺដូចគ្នានឹងពេលប្រើពាក្យគន្លឹះដែរ។ តេស្ត ();:

មានតែលើកនេះទេដែលយើងមិនបានសរសេរអថេរមូលដ្ឋានឡើងវិញ ពោលគឺអថេរ $ ឈ្មោះនៅខាងក្នុងមុខងារនៅតែដូចគ្នា និងស្មើគ្នា "Andrey"មិនមែនទេ។ "Rud Sergey".

ឆ្លងកាត់អាគុយម៉ង់ដោយឯកសារយោង

វិធីទីបី- នេះគឺជាការផ្ទេរអាសយដ្ឋាន ( តំណភ្ជាប់) នៃអថេរ មិនមែនតម្លៃរបស់វាទេ។ តំណភ្ជាប់ក្នុង PHP មិនជោគជ័យខ្លាំងទេ មិនដូចភាសាសរសេរកម្មវិធីផ្សេងទៀតទេ។ ទោះយ៉ាងណាក៏ដោយ ខ្ញុំនឹងប្រាប់អ្នកពីជម្រើសត្រឹមត្រូវតែមួយគត់សម្រាប់ការឆ្លងកាត់អាគុយម៉ង់ដោយយោងទៅមុខងារមួយ ដែលជាធម្មតាត្រូវបានគាំទ្រនៅក្នុង PHP 5.3 និងខ្ពស់ជាងនេះ។ មានវិធីផ្សេងទៀតដើម្បីធ្វើការជាមួយតំណភ្ជាប់ ប៉ុន្តែពួកគេបានធ្វើការនៅក្នុង PHP 5.2 និងទាបជាងនេះ ជាលទ្ធផលអ្នកអភិវឌ្ឍន៍ PHP ខ្លួនឯងបានសម្រេចចិត្តបោះបង់ចោលពួកគេ ដូច្នេះយើងនឹងមិននិយាយអំពីពួកគេទេ។

ដូច្នេះ ការឆ្លងកាត់ត្រឹមត្រូវនៃអាគុយម៉ង់ដោយយោងនៅក្នុង PHP 5.3 និងខ្ពស់ជាងនេះ ត្រូវបានធ្វើដូចខាងក្រោម:

មុខងារ sayHi(&$name)(

នៅក្នុងការពិពណ៌នាមុខងារខ្លួនវា យើងបានបន្ថែមរូបតំណាង ampersand (&) - រូបតំណាងនេះមានន័យថាយើងមិនទទួលយកតម្លៃនៃអថេរនោះទេ ប៉ុន្តែជាតំណភ្ជាប់ (អាសយដ្ឋាន) ទៅកាន់តម្លៃនេះនៅក្នុងអង្គចងចាំ។ ឯកសារយោងនៅក្នុង PHP អនុញ្ញាតឱ្យអ្នកបង្កើតអថេរពីរដែលចង្អុលទៅតម្លៃដូចគ្នា។ នេះមានន័យថានៅពេលដែលអថេរមួយក្នុងចំណោមអថេរទាំងនេះផ្លាស់ប្តូរ ការផ្លាស់ប្តូរទាំងពីរចាប់តាំងពីពួកគេសំដៅទៅលើតម្លៃដូចគ្នានៅក្នុងអង្គចងចាំ។

ហើយនៅទីបញ្ចប់យើងមាន៖

// មិន​ទទួល​យក​តម្លៃ​ទេ ប៉ុន្តែ​ជា​ការ​យោង​ទៅ​តម្លៃបន្ទរ "ជំរាបសួរ ".$name"!
"; $name = "Rud Sergey"; ) $name = "Andrey"; sayHi($name); បន្ទរ $name; // ?

លទ្ធផល៖

អថេរឋិតិវន្ត

ស្រមៃមើលស្ថានភាពខាងក្រោម៖ យើងត្រូវរាប់ចំនួនដងដែលយើងបាននិយាយជំរាបសួរសរុប។ នេះជាអ្វីដែលយើងកំពុងព្យាយាមធ្វើ៖

"; $c++; // បង្កើនចំនួនរាប់ដោយ 1

---

លទ្ធផល៖

អថេរ $cមិនចាំអត្ថន័យរបស់វាទេ វាត្រូវបានបង្កើតជាថ្មីរាល់ពេល។ យើងត្រូវធ្វើឱ្យអថេរក្នុងស្រុករបស់យើង។ $cចងចាំតម្លៃរបស់វាបន្ទាប់ពីប្រតិបត្តិមុខងារនេះ ពួកគេប្រើពាក្យគន្លឹះ ការប្រើប្រាស់ឋិតិវន្ត (:

// រាប់, ធ្វើឱ្យឋិតិវន្តបន្ទរ "ជំរាបសួរ ".$name"!
"; $c++; // បង្កើនចំនួនរាប់ដោយ 1បន្ទរ "គ្រាន់តែនិយាយថាជំរាបសួរ" ។ $c ។ "ម្តង។

---

";) sayHi("Rud Sergey"); sayHi("Andrey"); sayHi("Dmitry");

លទ្ធផល៖

ត្រឡប់តម្លៃ

អនុគមន៍​មាន​ភាព​ងាយ​ស្រួល​ដូច​ជា​ការ​ត្រឡប់​តម្លៃ។ នេះគឺជាពេលដែលមុខងារមួយ ជំនួសឱ្យការបោះពុម្ពអ្វីមួយទៅអេក្រង់ ដាក់អ្វីគ្រប់យ៉ាងទៅជាអថេរ ហើយផ្តល់ឱ្យយើងនូវអថេរនោះ។ ហើយ​យើង​កំពុង​សម្រេច​ចិត្ត​រួច​ហើយ​ថា​ត្រូវ​ធ្វើ​អ្វី​ជាមួយ​វា។ ឧទាហរណ៍ ចូរយើងយកអនុគមន៍នេះ វាដាក់លេខពីរ៖

លទ្ធផល៖

ចូរធ្វើវាដើម្បីឱ្យជំនួសឱ្យការបង្ហាញវានៅលើអេក្រង់វាត្រឡប់លទ្ធផលប្រតិបត្តិ។ ដើម្បីធ្វើដូចនេះសូមប្រើពាក្យគន្លឹះត្រឡប់៖

លទ្ធផល៖

ឥឡូវនេះយើងអាចប្រើវាតាមវិធីផ្សេងៗគ្នា៖

// បង្ហាញលទ្ធផលបន្ទរ "
"; $num = getSquare(5); បន្ទរ $num;

លទ្ធផល៖

សូមចំណាំថាពាក្យគន្លឹះ ត្រឡប់មកវិញមិនគ្រាន់តែត្រឡប់តម្លៃមួយទេ ប៉ុន្តែរំខានមុខងារទាំងស្រុង ពោលគឺកូដទាំងអស់ដែលស្ថិតនៅក្រោមពាក្យគន្លឹះ ត្រឡប់មកវិញនឹងមិនដែលត្រូវបានបំពេញ។ នៅក្នុងពាក្យផ្សេងទៀត, ត្រឡប់សម្រាប់មុខងារក៏ដំណើរការដូច សម្រាកសម្រាប់រង្វិលជុំ៖

បន្ទរ "PHP នឹងមិនទៅដល់ខ្ញុំទេ:(";) អេកូ getSquare (5); // បង្ហាញលទ្ធផលបន្ទរ "
"; $num = getSquare(5); // កំណត់លទ្ធផលទៅជាអថេរបន្ទរ $num; // បង្ហាញអថេរនៅលើអេក្រង់

លទ្ធផល៖

នោះគឺជា ត្រឡប់មកវិញ- នេះក៏ជាច្រកចេញពីមុខងារផងដែរ។ វាអាចត្រូវបានប្រើដោយគ្មានតម្លៃត្រឡប់មកវិញ, គ្រាន់តែសម្រាប់ជាប្រយោជន៍នៃទិន្នផល។

មុខងារកើតឡើងវិញ។

មុខងារ recursive គឺជាមុខងារដែលហៅខ្លួនឯង។ Recursion មិន​ត្រូវ​បាន​ប្រើ​ញឹកញាប់​ទេ ហើយ​ត្រូវ​បាន​គេ​ចាត់​ទុក​ថា​ជា​ប្រតិបត្តិការ​ដែល​ពឹងផ្អែក​លើ​ធនធាន (យឺត)។ ប៉ុន្តែវាកើតឡើងថាការប្រើការហៅឡើងវិញគឺជាជម្រើសជាក់ស្តែង និងសាមញ្ញបំផុត។ ឧទាហរណ៍៖

"; ប្រសិនបើ($number< 20){ // ដូច្នេះ​ការ​ធ្វើ​ឡើង​វិញ​មិន​ចេះ​ចប់ countPlease(++$number); // មុខងារ countPlease ហៅខ្លួនឯង) ) រាប់សូម(1);

លទ្ធផល៖

ប្រសិនបើអ្នកដឹងពីរបៀបធ្វើដោយមិនប្រើឡើងវិញ នោះជាការប្រសើរក្នុងការធ្វើដូច្នេះ។

ការវាយអក្សរខ្លាំងនៅក្នុង PHP (ការកែលម្អប្រភេទ)

PHP បោះជំហានតូចមួយឆ្ពោះទៅរកការវាយអក្សរខ្លាំង ដូច្នេះយើងអាចបញ្ជាក់ជាមុននូវប្រភេទមុខងារដែលគួរអនុវត្ត (នេះហៅថា ប្រភេទ-ជំនួយ):

លទ្ធផល៖

កំហុសធ្ងន់ធ្ងរដែលអាចចាប់បាន៖ អាគុយម៉ង់ទី 1 បានឆ្លងទៅ countPlease() ត្រូវតែជាអារេ ចំនួនគត់ដែលបានផ្តល់ឱ្យ ហៅក្នុង /home/index.php នៅលើបន្ទាត់ទី 7 និងកំណត់ក្នុង /home/index.php នៅលើបន្ទាត់ទី 3

កំហុសប្រាប់យើងថាអនុគមន៍រំពឹងថានឹងទទួលបានអារេមួយ ប៉ុន្តែយើងកំពុងហុចវាជាលេខ។ ជាអកុសល សម្រាប់ពេលនេះ យើងអាចបញ្ជាក់បានតែប្រភេទសម្រាប់ (អារេ) ហើយជាមួយ PHP 5.4 យើងក៏បានបន្ថែមជម្រើសដូចជា អាចហៅបាន។:

អាចហៅបាន។ពិនិត្យមើលថាតើតម្លៃដែលបានឆ្លងកាត់អាចត្រូវបានហៅជាមុខងារ។ អាចហៅបានអាចជាឈ្មោះនៃមុខងារដែលបានបញ្ជាក់ដោយអថេរខ្សែអក្សរ ឬវត្ថុមួយ និងឈ្មោះនៃវិធីសាស្ត្រដែលកំពុងត្រូវបានហៅ ប៉ុន្តែយើងនឹងនិយាយអំពីវត្ថុ និងវិធីសាស្ត្រនៅពេលក្រោយ (នេះគឺជាផ្នែកនៃកម្មវិធីតម្រង់ទិសវត្ថុ) ប៉ុន្តែអ្នកធ្លាប់ស្គាល់មុខងាររួចហើយ។ ខ្ញុំ​មិន​អាច​បង្ហាញ​អ្នក​ពី​លទ្ធផល​នៃ​ការ​ងារ​បាន​ទេ ព្រោះ​បច្ចុប្បន្ន​ខ្ញុំ​មាន PHP 5.3 ប៉ុន្តែ​វា​នឹង​ជា៖

ហៅថាមុខងារ getEcho

ការប្រើអាគុយម៉ង់ប្រវែងអថេរ

ហើយទីបំផុត មួយបន្ថែមទៀតកម្រប្រើ nuance ។ ស្រមៃមើលស្ថានភាព៖ យើងបញ្ជូនអាគុយម៉ង់ទៅមុខងារមួយ ទោះបីជាយើងមិនបានពិពណ៌នាពួកវានៅក្នុងមុខងារក៏ដោយ ឧទាហរណ៍៖

លទ្ធផល៖

ដូចដែលអ្នកអាចឃើញមិនមានកំហុសទេ ប៉ុន្តែអាគុយម៉ង់ដែលឆ្លងកាត់របស់យើងមិនត្រូវបានប្រើនៅកន្លែងណានោះទេ។ ប៉ុន្តែនេះមិនមានន័យថាពួកវាបានបាត់នោះទេ - ពួកគេនៅតែត្រូវបានបញ្ចូលទៅក្នុងមុខងារ ហើយយើងអាចប្រើប្រាស់វាបាន មានមុខងារ PHP ដែលភ្ជាប់មកជាមួយសម្រាប់នេះ៖

func_num_args()- ត្រឡប់ចំនួនអាគុយម៉ង់ដែលបានបញ្ជូនទៅអនុគមន៍
func_get_arg (លេខលំដាប់)- ត្រឡប់ធាតុមួយពីបញ្ជីអាគុយម៉ង់
func_get_args()- ត្រឡប់អារេដែលមានអាគុយម៉ង់មុខងារ

"; echo func_get_arg(0); ) $age = 22; getEcho("Rud Sergey", $age);

លទ្ធផល៖

សេចក្តីសន្និដ្ឋាន

អត្ថបទថ្ងៃនេះជាអត្ថបទចុងក្រោយលើប្រធានបទនៃមុខងារនៅក្នុង PHP ។ ឥឡូវនេះ អ្នកអាចមានទំនុកចិត្តលើភាពពេញលេញនៃចំណេះដឹងរបស់អ្នកទាក់ទងនឹងប្រធានបទនេះ ហើយអាចប្រើប្រាស់មុខងារសម្រាប់តម្រូវការរបស់អ្នកដោយទំនុកចិត្ត។

ប្រសិនបើនរណាម្នាក់មានបំណងចង់ឱ្យវាកាន់តែប្រសើរឡើង ប៉ុន្តែមិនដឹងពីរបៀបធ្វើវា វិធីល្អបំផុតគឺត្រូវសរសេរមុខងារ PHP ដែលត្រៀមរួចជាស្រេច (ភ្ជាប់មកជាមួយ) ឧទាហរណ៍ អ្នកអាចសរសេរមុខងារ count() ផ្ទាល់ខ្លួនរបស់អ្នក។ ឬផ្សេងទៀត។

អរគុណអ្នកទាំងអស់គ្នាសម្រាប់ការចាប់អារម្មណ៍ ហើយជួបគ្នាម្តងទៀត! ប្រសិនបើមានអ្វីមិនច្បាស់ សូមសួរសំណួររបស់អ្នកនៅក្នុងមតិយោបល់!

អថេរដែលបានកំណត់ក្នុងទម្រង់ការរង (មុខងារកំណត់ដោយអ្នកប្រើប្រាស់)។ ពួកវាអាចចូលប្រើបានតែនៅក្នុងមុខងារដែលពួកគេត្រូវបានកំណត់។

សម្រាប់ PHP រាល់អថេរទាំងអស់ដែលបានប្រកាស និងប្រើក្នុងមុខងារគឺស្ថិតនៅក្នុងមូលដ្ឋាននៃមុខងារតាមលំនាំដើម។ នោះគឺតាមលំនាំដើម វាមិនអាចផ្លាស់ប្តូរតម្លៃនៃអថេរសកលនៅក្នុងតួនៃអនុគមន៍បានទេ។

ប្រសិនបើនៅក្នុងតួនៃអនុគមន៍កំណត់ដោយអ្នកប្រើប្រាស់ អ្នកប្រើអថេរដែលមានឈ្មោះដូចគ្នាបេះបិទទៅនឹងឈ្មោះនៃអថេរសកល (ដែលមានទីតាំងនៅខាងក្រៅមុខងារកំណត់ដោយអ្នកប្រើប្រាស់) នោះអថេរមូលដ្ឋាននេះនឹងមិនមានទំនាក់ទំនងជាមួយអថេរសកលទេ។ ក្នុងស្ថានភាពនេះ អថេរមូលដ្ឋានដែលមានឈ្មោះដូចគ្នាបេះបិទនឹងឈ្មោះនៃអថេរសកលនឹងត្រូវបានបង្កើតនៅក្នុងមុខងារកំណត់ដោយអ្នកប្រើប្រាស់ ប៉ុន្តែអថេរមូលដ្ឋាននេះនឹងមាននៅក្នុងមុខងារកំណត់ដោយអ្នកប្រើប្រាស់នេះប៉ុណ្ណោះ។

ចូរយើងពន្យល់ការពិតនេះជាមួយនឹងឧទាហរណ៍ជាក់លាក់មួយ៖

$a = 100 ;

មុខងារមុខងារ () (
$a = 70;
បន្ទរ "

$a

" ;
}
មុខងារ ();
បន្ទរ "

$a

" ;
?>

ស្គ្រីបនឹងបោះពុម្ព 70 ដំបូងហើយបន្ទាប់មក 100៖

70
100

ដើម្បីកម្ចាត់គុណវិបត្តិនេះមានការណែនាំពិសេសនៅក្នុង PHP តេស្ត ();អនុញ្ញាតឱ្យមុខងារកំណត់ដោយអ្នកប្រើប្រាស់ដើម្បីធ្វើការជាមួយអថេរសកល។ សូមក្រឡេកមើលគោលការណ៍នេះដោយប្រើឧទាហរណ៍ជាក់លាក់៖

$a = 1 ;
សកល

ផលបូក ()
{
សកល $a, $b;

$b = 2 ;
}

ផលបូក()
បន្ទរ $b ;
?>

ស្គ្រីបខាងលើនឹងចេញ " 3 "។ បន្ទាប់ពីកំណត់ $aនិង $bនៅខាងក្នុងមុខងារដូចជា តេស្ត ();សេចក្តីយោងទាំងអស់ចំពោះអថេរទាំងនេះនឹងចង្អុលទៅកំណែសកលរបស់ពួកគេ។ មិនមានដែនកំណត់ចំពោះចំនួនអថេរសកលដែលអាចត្រូវបានគ្រប់គ្រងដោយមុខងារកំណត់ដោយអ្នកប្រើប្រាស់នោះទេ។

វិធីទីពីរដើម្បីចូលប្រើអថេរវិសាលភាពសកលគឺត្រូវប្រើអារេដែលកំណត់ដោយ PHP ពិសេស $GLOBALS. ឧទាហរណ៍មុនអាចត្រូវបានសរសេរឡើងវិញដូចនេះ៖

ការប្រើប្រាស់ $GLOBALS ជំនួសឱ្យសកល៖

$a = 1 ;
សកល

ផលបូក ()
{
$GLOBALS [ "b" ] = $GLOBALS [ "a" ] + $GLOBALS [ "b" ];
}

ផលបូក()
បន្ទរ $b ;
?>

$GLOBALSគឺ​ជា​អារេ​សហការ​ដែល​កូនសោ​គឺ​ជា​ឈ្មោះ ហើយ​តម្លៃ​របស់​វា​ជា​មាតិកា​នៃ​អថេរ​សកល។ ចំណាំថា $GLOBALS មាននៅក្នុងវិសាលភាពណាមួយ នេះគឺដោយសារតែនេះគឺជាអារេមួយ។ ខាងក្រោមនេះជាឧទាហរណ៍ដែលបង្ហាញពីសមត្ថភាពរបស់ superglobals៖

ឧទាហរណ៍ #3 មហាសកល និងវិសាលភាព
{
មុខងារ test_global()
// "អស្ចារ្យ" និងអាចរកបាននៅក្នុងតំបន់
// ការមើលឃើញមុខងារតម្រូវឱ្យបញ្ជាក់ "សកល" ។
// ភាពមើលឃើញ មុខងារតម្រូវឱ្យបញ្ជាក់ "សកល" ។

សកល $ HTTP_POST_VARS ;

អេកូ $HTTP_POST_VARS["ឈ្មោះ"];
// ភាពមើលឃើញនិងមិនតម្រូវឱ្យមាន "សកល" ត្រូវបានបញ្ជាក់។
// Superglobals មានតាំងពី PHP 4.1.0
// ការប្រើប្រាស់ HTTP_POST_VARS ត្រូវបានបដិសេធ។
}
?>