PHP
कार्यात्मक प्रोग्रामिंग

परिचय

चर के लिए असाइनमेंट

बेनामी फ़ंक्शंस को उन मापदंडों के रूप में उपयोग करने के लिए असाइन किया जा सकता है जहाँ कॉलबैक अपेक्षित है:

$uppercase = function($data) {
    return strtoupper($data);
};

$mixedCase = ["Hello", "World"];
$uppercased = array_map($uppercase, $mixedCase);
print_r($uppercased);

इन चरों को स्टैंडअलोन फ़ंक्शन कॉल के रूप में भी इस्तेमाल किया जा सकता है:

echo $uppercase("Hello world!"); // HELLO WORLD!

बाहरी चरों का उपयोग करना

use फ़ंक्शन का उपयोग अनाम फ़ंक्शन के दायरे में चर आयात करने के लिए किया जाता है:

$divisor = 2332;
$myfunction = function($number) use ($divisor) {
    return $number / $divisor;
};

echo $myfunction(81620); //Outputs 35

चर भी संदर्भ द्वारा आयात किया जा सकता है:

$collection = [];

$additem = function($item) use (&$collection) {
    $collection[] = $item;
};

$additem(1);
$additem(2);

//$collection is now [1,2]

एक पैरामीटर के रूप में कॉलबैक फ़ंक्शन पास करना

: वहाँ कई पीएचपी कार्यों कि एक पैरामीटर के रूप उपयोगकर्ता परिभाषित कॉलबैक कार्यों स्वीकार करते हैं, इस तरह के रूप हैं call_user_func() , usort() और array_map() ।

उपयोगकर्ता द्वारा परिभाषित कॉलबैक फ़ंक्शन को जहां परिभाषित किया गया था, उसके आधार पर उन्हें पास करने के विभिन्न तरीके हैं:

प्रक्रियात्मक शैली:

function square($number)
{
    return $number * $number;
}

$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map('square', $initial_array);
var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

ऑब्जेक्ट ओरिएंटेड शैली:

class SquareHolder
{
    function square($number)
    {
        return $number * $number;
    }
}

$squaredHolder = new SquareHolder();
$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map([$squaredHolder, 'square'], $initial_array);

var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

स्थैतिक विधि का उपयोग करते हुए ऑब्जेक्ट ओरिएंटेड शैली:

class StaticSquareHolder
{
    public static function square($number)
    {
        return $number * $number;
    }
}

$initial_array = [1, 2, 3, 4, 5];
$final_array = array_map(['StaticSquareHolder', 'square'], $initial_array);
// or:
$final_array = array_map('StaticSquareHolder::square', $initial_array); // for PHP >= 5.2.3

var_dump($final_array); // prints the new array with 1, 4, 9, 16, 25

कॉलबैक के रूप में अंतर्निहित कार्यों का उपयोग करना

एक तर्क के रूप में callable करने callable कार्यों में, आप PHP अंतर्निहित फ़ंक्शन के साथ एक स्ट्रिंग भी रख सकते हैं। सरणी में सभी स्ट्रिंग्स से प्रमुख और अनुगामी array_map को हटाने के लिए array_map पैरामीटर के रूप में trim का उपयोग करना आम है।

$arr = ['   one  ', 'two   ', '   three'];
var_dump(array_map('trim', $arr));

// array(3) {
//   [0] =>
//   string(3) "one"
//   [1] =>
//   string(3) "two"
//   [2] =>
//   string(5) "three"
// }

अनाम फ़ंक्शन

एक अनाम फ़ंक्शन केवल एक फ़ंक्शन है जिसमें कोई नाम नहीं है।

// Anonymous function
function() {
    return "Hello World!";
};

PHP में, एक अनाम फ़ंक्शन को एक अभिव्यक्ति की तरह माना जाता है और इस कारण से, इसे अर्धविराम के साथ समाप्त किया जाना चाहिए ; ।

एक अनाम फ़ंक्शन को एक चर को सौंपा जाना चाहिए।

// Anonymous function assigned to a variable
$sayHello = function($name) {
    return "Hello $name!";
};

print $sayHello('John'); // Hello John

या इसे किसी अन्य फ़ंक्शन के पैरामीटर के रूप में पारित किया जाना चाहिए।

$users = [
    ['name' => 'Alice', 'age' => 20], 
    ['name' => 'Bobby', 'age' => 22], 
    ['name' => 'Carol', 'age' => 17]
];

// Map function applying anonymous function
$userName = array_map(function($user) {
    return $user['name'];
}, $users);

print_r($usersName); // ['Alice', 'Bobby', 'Carol']

या किसी अन्य फ़ंक्शन से भी लौटा दिए गए हैं ।

स्व-निष्पादित अनाम कार्य:

// For PHP 7.x
(function () {
    echo "Hello world!";
})();

// For PHP 5.x
call_user_func(function () {
    echo "Hello world!";
});

स्व-निष्पादित अनाम कार्यों में एक तर्क पारित करना:

// For PHP 7.x
(function ($name) {
    echo "Hello $name!";
})('John');

// For PHP 5.x
call_user_func(function ($name) {
    echo "Hello $name!";
}, 'John');

क्षेत्र

PHP में, एक अनाम फ़ंक्शन का किसी भी अन्य PHP फ़ंक्शन की तरह अपना दायरा होता है।

जावास्क्रिप्ट में, एक अनाम फ़ंक्शन बाहरी दायरे में एक चर तक पहुंच सकता है। लेकिन PHP में, यह अनुमति नहीं है।

$name = 'John';

// Anonymous function trying access outside scope
$sayHello = function() {
    return "Hello $name!";
}

print $sayHello('John'); // Hello !
// With notices active, there is also an Undefined variable $name notice

बंद

एक बंद एक अनाम फ़ंक्शन है जो बाहरी दायरे तक नहीं पहुंच सकता है।

अनाम फ़ंक्शन को इस प्रकार परिभाषित करते समय, आप उस फ़ंक्शन के लिए "नाम स्थान" बना रहे हैं। वर्तमान में इसका केवल उस नामस्थान तक ही पहुँच है।

$externalVariable = "Hello";
$secondExternalVariable = "Foo"; 
$myFunction = function() { 
  
  var_dump($externalVariable, $secondExternalVariable); // returns two error notice, since the variables aren´t defined 

}

इसमें किसी भी बाहरी चर का उपयोग नहीं है। बाहरी चर तक पहुँचने के लिए इस नाम स्थान के लिए यह अनुमति देने के लिए, आपको इसे क्लोजर ( use() ) के माध्यम से प्रस्तुत करना होगा।

$myFunction = function() use($externalVariable, $secondExternalVariable) {
   var_dump($externalVariable, $secondExternalVariable); // Hello Foo
}

यह पीएचपी के टाइट वैरिएबल स्कूपिंग के लिए बहुत अधिक जिम्मेदार है - यदि कोई वैरिएबल दायरे के भीतर परिभाषित नहीं है, या global साथ नहीं लाया गया है, तो इसका अस्तित्व नहीं है।

यह भी नोट करें:

पैरेंट स्कोप से वेरिएबल इनहेरिट करना वैश्विक वैरिएबल का उपयोग करने के समान नहीं है। ग्लोबल वैरिएबल ग्लोबल स्कोप में मौजूद हैं, जो कि समान है जो किसी भी फंक्शन को अंजाम दे रहा है।

किसी क्लोजर का पैरेंट स्कोप वह फंक्शन है जिसमें क्लोजर घोषित किया गया था (जरूरी नहीं कि जिस फंक्शन से इसे कॉल किया गया था)।

^{बेनामी कार्यों के लिए PHP प्रलेखन से लिया गया}

PHP में, क्लोजर एक प्रारंभिक-बाध्यकारी दृष्टिकोण का उपयोग करते हैं। इसका मतलब यह है कि use कीवर्ड के उपयोग से क्लोजर के नाम स्थान पर जाने वाले वेरिएबल्स में वही मान होंगे जब क्लोजर को परिभाषित किया गया था।

इस व्यवहार को बदलने के लिए आपको चर उप संदर्भ को पास करना चाहिए।

$rate = .05;

// Exports variable to closure's scope
$calculateTax = function ($value) use ($rate) {
    return $value * $rate;
};

$rate = .1; 

print $calculateTax(100); // 5

$rate = .05;

// Exports variable to closure's scope
$calculateTax = function ($value) use (&$rate) { // notice the & before $rate
    return $value * $rate;
};

$rate = .1;

print $calculateTax(100); // 10

जब बिना / बंद किए अनाम कार्यों को परिभाषित करते समय डिफ़ॉल्ट तर्क की आवश्यकता नहीं होती है।

$message = 'Im yelling at you';

$yell = function() use($message) {
    echo strtoupper($message);
};

$yell(); // returns: IM YELLING AT YOU

शुद्ध कार्य

एक शुद्ध फ़ंक्शन एक फ़ंक्शन है, जिसे एक ही इनपुट दिया जाता है, हमेशा एक ही आउटपुट लौटाएगा और साइड-इफ़ेक्ट फ्री होगा।

// This is a pure function
function add($a, $b) {
    return $a + $b;
}

कुछ साइड-इफेक्ट्स फाइल सिस्टम को बदल रहे हैं, डेटाबेस के साथ बातचीत कर रहे हैं, स्क्रीन पर प्रिंट कर रहे हैं ।

// This is an impure function
function add($a, $b) {
    echo "Adding...";
    return $a + $b;
}

एक समारोह के रूप में वस्तुओं

class SomeClass {
    public function __invoke($param1, $param2) {
        // put your code here
    }
}

$instance = new SomeClass();
$instance('First', 'Second'); // call the __invoke() method

__invoke विधि के साथ एक वस्तु का उपयोग किसी अन्य फ़ंक्शन के समान किया जा सकता है।

__invoke विधि में ऑब्जेक्ट के सभी गुणों तक पहुंच होगी और किसी भी तरीके को कॉल करने में सक्षम होगा।

PHP में सामान्य कार्यात्मक तरीके

मानचित्रण

किसी सरणी के सभी तत्वों के लिए एक फ़ंक्शन लागू करना:

array_map('strtoupper', $array);

ज्ञात हो कि यह सूची का एकमात्र तरीका है जहां कॉलबैक पहले आता है।

कम करना (या तह करना)

किसी सरणी को एक मान से कम करना:

$sum = array_reduce($numbers, function ($carry, $number) {
   return $carry + $number;
});

छनन

केवल सरणी आइटम देता है जिसके लिए कॉलबैक true :

$onlyEven = array_filter($numbers, function ($number) {
    return ($number % 2) === 0;
});