មុខងារ

មេរៀន​នេះ មាន​ជា​វីដេអូ ។

មេរៀន​ជា​វីដេអូ

មុខងារ (function) គឺ​ជា​ការ​បណ្ដុំ​នៃ​ដំណើរការ ។ យើង​អាច​ធ្វើ​ឲ្យ​របស់​ជាច្រើន​ដំណើរការ នៅ​ពេល​ដែល​ហៅ function ដែល​យើង​បង្កើត​មួយ ។

មូលដ្ឋាន​គ្រឹះ​នៃ function

ខាងក្រោម​នេះ​គឺ​ជា​ទម្រង់​ក្នុង​ការ​បង្កើត function មួយ ដែល​ប្រើ​សំរាប់​គណនា​ផ្ទៃ​ក្រឡា​ចតុកោណកែង ៖

<?php
// function សំរាប់​គណនា ផ្ទៃ​ក្រឡា​ចតុកោណកែង
// ដើម្បី​គណនា​ផ្ទៃ​ក្រឡាចតុកោណកែង យើង​ត្រូវ​ការ​ប្រវែង​បាត និង​កម្ពស់
// បាត ខ្ញុំ​តាង​ដោយ width
// កំពស់ ខ្ញុំ​តាង​ដោយ height
function rectangleArea($width, $height) {
    echo "បាត : " . $width . "<br>";
    echo "កម្ពស់ : " . $height . "<br>";
    echo "នាំ​ឲ្យ​ផ្ទៃ : " . $width*$height;
}

// ហៅ function ខាងលើ
rectangleArea(10, 20);
?>

រចនាសម្ព័ន្ធ function

return

នៅ​ក្នុង function បើ​យើង​ប្រើ echo គឺ​វា​បាន​តែ​បង្ហាញ​ចេញ​មក​ក្រៅ​ប៉ុណ្ណោះ ។ យើង​មិន​អាច​យក​លទ្ធផល​នៃ function នោះ ទៅ​ធ្វើ​អ្វី​ផ្សេង​បាន​ទេ ។ ដោយ​ប្រើប្រាស់ return តម្លៃ​មួយ​នោះ​មិន​ទាន់​បាន​ចេញ​មក​ក្រៅ​នៅ​ឡើយ​ទេ ដូចនេះ​យើង​អាច​យក​វា​ទៅ​គណនា ឬ​ធ្វើ​អ្វី​ផ្សេង​ក៏​បាន​ដែរ ។

<?php
// ទម្រង់​សមរម្យ ក្នុង​ការ​បង្កើត function សំរាប់​គណនា​ផ្ទៃក្រឡា​ចតុកោណកែង
function rectangleArea($width, $height) {
    return $width*$height;
}

// បម្រើបម្រាស់
$a1 = rectangleArea(10, 20);
echo $a1 + rectangleArea(20, 50);
?>

ពេល​ប៉ះ return នោះ function ទាំង​មូល​នឹង​បញ្ចប់ ទោះ​បី​ជា​នៅ​ពាក់​កណ្ដាល loop ក៏​ដោយ ។

កំណត់​តម្លៃ​ដើម​នៃ​តម្រូវការ

<?php
function rectangleArea($width, $height) {
    return $width*$height;
}
echo rectangleArea(10); // បញ្ហា
?>

ឧទាហរណ៍​ខាងលើ វា​នឹង​ចេញ​ជា​បញ្ហា ដោយ​វា​ទាមទារ​ឲ្យ​កំណត់​តម្រូវ​ការ​មួយ​ទៀត ។ បើ​យើង​ចង់​បាន​បែប​នឹង​ក៏​បាន​ដែរ ប៉ុន្តែ​យើង​ក៏​អាច​កំណត់​តម្លៃ​ដើម​ទៅ​ឲ្យ​វា​ដែរ ។

<?php
function rectangleArea($width, $height=1) {
    return $width*$height;
}
echo rectangleArea(10); // 10
?>

ខាងលើ មិន​ជះ​ជា​បញ្ហា​ទេ ព្រោះ height មាន​តម្លៃ​ដើម 1 ។ បើ​វា​ត្រូវ​បាន​កំណត់ វា​មាន​តម្លៃ​តាម​តែ​យើង​កំណត់ ។ បើ​វា​មិន​ត្រូវ​បាន​កំណត់​ទេ វា​នឹង​មាន​តម្លៃ​តាម​តម្លៃ​ដើម ។

ដែន​នៃ function

អញ្ញាត​នៅ​ក្នុង function

យើង​មិន​អាច​យក​អញ្ញាត​ដែល​បង្កើត​ក្នុង function យក​មកប្រើ​ខាង​ក្រៅ​បាន​ទេ ។

<?php
function rectangleArea($width, $height) {
    $test = 10;
    return $width*$height;
}
echo rectangleArea(10, 20); // 200
echo $test;     // បញ្ហា
echo $height;   // បញ្ហា
?>

អញ្ញាត​នៅ​ក្នុង function គឺ​ត្រូវ​បាន​លុប​ចោល នៅ​ពេល​ដែល​ដើរ function នោះ​ចប់ ។

អញ្ញាត​នៅ​ក្រៅ function

អញ្ញាត​ដែល​បង្កើត​នៅ​ក្រៅ function យើង​អាច​ហៅ​វា​ថា​ជា អញ្ញាត​សកល ។ យើង​មិន​អាច​យក​អញ្ញាត​ក្រៅ function យក​មក​ប្រើ​ក្នុង function ផ្ទាល់​តែ​ម្ដង​បាន​ទេ ។ ប៉ុន្តែ​មាន ២ វិធី ដើម្បី​ធ្វើ​វា ។

ប្រើប្រាស់ global keyword

<?php
function test() {
    global $ttt;
    echo $ttt;
}
$ttt = 10;
test();     // 10
?>

វា​ជះ​ជា​បញ្ហា បើ​សិន​ជា​យើង​ហៅ function នោះ មុន​នឹង​អញ្ញាត​សកល​ដែល​ប្រើ​ក្នុង function នោះ ត្រូវ​បាន​បង្កើត ។

ប្រើប្រាស់​អញ្ញាត $GLOBALS

អញ្ញាត​ដែល​បង្កើត​នៅ​ក្នុង function វា​នឹង​ក្លាយ​ទៅ​ជា​តម្លៃ​មួយ​នៃ array $GLOBALS ។ ហើយ $GLOBALS ជា​អញ្ញាត superglobals ដែល​យើង​អាច​ប្រើ​វា​នៅ​កន្លែង​ណា​ក៏​បាន​ដែរ ។

<?php
function test() {
    echo $GLOBALS['ttt'];
}
$ttt = 10;
test();     // 10
?>

ដោយ​ហេតុ​តែ​អញ្ញាត​នៅ​ក្នុង​និង​ក្រៅ function វាមិន​ទាក់ទង​គ្នា ។ ដូចនេះ យើង​អាច​កំណត់​ឈ្មោះ​អញ្ញាត​ដែល​នៅ​ក្នុង function ឲ្យ​ជាន់​នឹង​ឈ្មោះ​នៃ​អញ្ញាត​ដែលនៅ​ក្រៅ function បាន ។

function នៅ​ក្នុង function

យើង​អាច​ប្រើ function ដែល​បង្កើត​នៅ​ក្នុង function បាន ដរាប​ណា function ដែលនៅ​ក្រៅ​នោះ ត្រូវ​បាន​ដំណើរការ ។

<?php
function a() {
    function b() {
        echo 5 . "<br>";
    }
    echo 10 . "<br>";
}

// កន្លែង​នេះ មិន​ទាន់​អាច​ហៅ b() យក​មក​ប្រើ​បាន​ទេ
// ព្រោះ a() មិន​ទាន់​បាន​ហៅ
// កាលណា a() មិន​ទាន់​បាន​ដំណើរការ
// នោះ b() ក៏​មិន​ទាន់​បាន​បង្កើត​ដែរ

a();    // 10

// កន្លែង​នេះ អាច​ហៅ b() បាន
b();    // 5
?>

function ដែល​មាន​តម្រូវការ​ជា reference

ខាង​ក្រោម​នេះ គឺ​ជា​ទម្រង់​ធម្មតា ក្នុង​ការ​ប្ដូរ​តម្លៃ​រវាង​២​អញ្ញាត ។

<?php
$a = 10;
$b = 20;

// ប្ដូរ​ទៅ​ជា $a = 20, $b = 20
$temp = $a;
$a = $b;
$b = $temp;

echo $a . "<br>";
echo $b;
?>

បង្កើត function ដែល​ប្រើ​សំរាប់​ផ្លាស់​ប្ដូរ​តម្លៃ​នៃ​២​អញ្ញាត ។

<?php
$one = 1;
$two = 2;

function swap($a, $b) {
    $temp = $a;
    $a = $b;
    $b = $temp;
}

swap($one, $two);

echo $one . "<br>";  // 1;
echo $two;  // 2;
?>

ឧទាហរណ៍​ខាងលើ យើង​ចង់​ឲ្យ $one ទៅ​ជា 2 ហើយ $two ទៅ​ជា 1 វិញ ។ តែ​ដូច​ខាងលើ វា​មិន​ដំណើរការ​ទេ ហេតុអ្វី? ព្រោះ​ដូចក្នុង​មេរៀន Reference យើង​បាន​ដឹង​ហើយ ការ​បោះ​តម្លៃ​ទៅ​ឲ្យ​គ្នា​នៅ​ក្នុង PHP គឺ​វា​បោះ​តែ​តម្លៃ​ទេ ។ ឧទាហរណ៍​ខាងលើ $one បោះ​តម្លៃ 1 ទៅ​ឲ្យ $a ហើយ $two បោះ​តម្លៃ 2 ទៅ​ឲ្យ $b ។ ហើយ​នៅ​ក្នុង swap() វា​បាន​ប្ដូរ​តម្លៃ $a និង $b បាន​ជោគជ័យ ប៉ុន្តែ​វា​អត់​ទាក់ទង​អី​នឹង $one និង $two ទេ ។ ដូចនេះ​ហើយ​បាន​ជា one និង two នៅ​ដដែល ។

ដើម្បី​ដោះ​ស្រាយ​បញ្ហា​នេះ យើង​ត្រូវ​ប្រើ​លក្ខណៈ​នៃ reference ។ អ្នក​ទាំងអស់​គ្នា ប្រហែល​ជា​គិត​បែប​នេះ swap(&$one, &$two) ប៉ុន្តែ​អត់​ទេ PHP ធ្វើ​ឲ្យ​មាន​លក្ខណៈ​ងាយ​ស្រួល​ប្រើ​ជាង​នេះ ។

<?php
$one = 1;
$two = 2;

function swap(&$a, &$b) {
    $temp = $a;
    $a = $b;
    $b = $temp;
}

swap($one, $two);

echo $one . "<br>";  // 2;
echo $two;  // 1;
?>

អញ្ញាត static

<?php
function add() {
    $number = 0;
    $number++;
    return $number;
}
echo add() . "<br>";     // 1
echo add() . "<br>";     // 1
echo add() . "<br>";     // 1
echo add() . "<br>";     // 1
echo add() . "<br>";     // 1
?>

ឧទាហរណ៍​ខាងលើ ចេញ 1 រហូត ដោយសារ​តែ​នៅ​ក្នុង add() អញ្ញាត $number គឺ​ថ្មី​រហូត ។ យើង​អាច​មិន​ឲ្យ​វា​ថ្មី​រហូត​បាន ដោយ​បង្កើត​វា​ដោយ​ប្រើ static ។

<?php
function add() {
    static $number = 0;
    $number++;
    return $number;
}
echo add();     // 1
echo add();     // 2
echo add();     // 3
echo add();     // 4
echo add();     // 5
?>

បង្កើត​ខាងលើ ពេល add() ត្រូវ​បាន​ហៅ​លើក​ទី១ វា​បង្កើត $number ជា​ធម្មតា តែ​ដោយ $number ជា static ដូចនេះ វា​មិន​ត្រូវ​បាន​លុប​ចោល​នៅពេល function នោះ​ដើរ​ចប់​នោះ​ទេ ។ ពេល​ហៅ add() លើក​ក្រោយៗ​ទៀត បន្ទាត់​កន្លែង static នឹង​មិន​ដើរ​ទៀត​ទេ ព្រោះ​បន្ទាត់​នឹង វា​ធ្វើ​ការ​បង្កើត​អញ្ញាត​ប្រភេទ static តែ​អញ្ញាត​នោះ​បាន​បង្កើត​រួច​ហើយ ។ ដូចនេះ វា​រំលង​បន្ទាត់​នឹង​ចោល ហើយ​បន្ត​ដំណើរការ​បន្ទាត់​ក្រោមៗ​ទៀត​ជា​ធម្មតា ។

ការ return ជា reference

ដោយ​បាន​សិក្សា​អំពី static យើង​អាច​សិក្សា​អំពី​ការ return ជា reference បាន​ហើយ ។

<?php
// ដើម្បី​ឲ្យ function មួយ​អាច return ជា reference
// ត្រូវ​សរសេរ & នៅ​ពី​មុខ​ឈ្មោះ​នៃ function
function &add() {
    static $number = 1;
    $number++;
    return $number;
}
echo add() . "<br>";      // 1
echo add() . "<br>";      // 2

$c = &add();
// អញ្ញាត c ចាប់​យក reference ដែល add() បញ្ជូន​មក
// ដោយ add() បញ្ជូន​មក​ជា​តម្លៃ​នៃ $number ដែល​នៅ​ក្នុង add() នោះ
// នោះ c ចាប់​បាន reference នៃ $number នោះ​ឯង
// កែ c ក៏​ដូច​ជា​កែ $number
$c = 100;
echo add() . "<br>";      // 101
echo add() . "<br>";      // 102
echo add() . "<br>";      // 103
?>

Recursive

Recursive គឺ​ជា​ទម្រង់​មួយ​នៃ function ដែល​ដំណើរការ​របស់​វា ហៅ function ខ្លួន​ឯង​នឹង មក​ប្រើ ។

<?php
// បង្កើត function ដែល return 1 រហូត​ដល់​លេខ​ដែលត្រូវ​បាន​កំណត់

/* ទម្រង់​ធម្មតា
function oneTo($number) {
    $r = '';
    for ($i = 1; $i <= $number; $i++)
        $r .= $i;
    return $r;
}
*/

// ទម្រង់ recursive
function oneTo($number) {
    if ($number == 1)
        return '1';
    return oneTo($number-1) . $number;
}

echo oneTo(5);
?>
ទំព៏រ​ដើម កូដ វីដេអូ បញ្ជី ចែករំលែក បោះពុម្ភ ឡើង​លើ Facebook Google Plus Twitter មតិ ឧបត្ថម្ភ ទំនាក់ទំនង អាជ្ញាប័ណ្ឌ សិទ្ធ​អ្នក​និពន្ធ បិទ Khode Academy មុន បន្ទាប់ ប្ដូរ​ម៉ូត