PHP
चर

वाक्य - विन्यास

• $ चर = 'मूल्य'; // सामान्य चर असाइन करें
• $ वस्तु-> संपत्ति = 'मूल्य'; // एक वस्तु संपत्ति असाइन करें
• क्लासनेम :: $ संपत्ति = 'मूल्य'; // स्थिर श्रेणी की संपत्ति असाइन करें
• $ सरणी [0] = 'मूल्य'; /> एक सरणी के एक सूचकांक के लिए एक मूल्य असाइन करें
• $ सरणी [] = 'मूल्य'; // एक सरणी के अंत में एक आइटम धक्का
• $ सरणी ['कुंजी'] = 'मूल्य'; // एक सरणी मान असाइन करें
• गूंज $ चर; // इको (प्रिंट) एक वैरिएबल वैल्यू
• some_function ($ चर); // फ़ंक्शन पैरामीटर के रूप में चर का उपयोग करें
• सेट नहीं ($ चर); // एक चर शुरू करो
• $ $ चर = 'मूल्य'; // एक चर चर के लिए असाइन करें
• isset ($ चर); // जांचें कि क्या एक चर सेट है या नहीं
• खाली ($ चर); // जांचें कि एक चर खाली है या नहीं

टिप्पणियों

<?php

/**
 * Juggle numbers and return true if juggling was
 * a great success.
 */
function numberJuggling(int $a, int $b) : bool
{
    $sum = $a + $b;

    return $sum % 2 === 0;
}

<?php
declare('strict_types=1');

नाम से एक चर गतिशील रूप से प्रवेश (चर चर)

चर गतिशील चर नामों के माध्यम से पहुँचा जा सकता है। एक चर का नाम दूसरे चर में संग्रहीत किया जा सकता है, जिससे इसे गतिशील रूप से एक्सेस किया जा सकता है। ऐसे चर को चर चर के रूप में जाना जाता है।

एक चर को एक चर चर में बदलने के लिए, आप अपने चर के सामने एक अतिरिक्त $ डालते हैं।

$variableName = 'foo';
$foo = 'bar';

// The following are all equivalent, and all output "bar":
echo $foo;
echo ${$variableName};
echo $$variableName;

//similarly,
$variableName  = 'foo';
$$variableName = 'bar';

// The following statements will also output 'bar'
echo $foo; 
echo $$variableName; 
echo ${$variableName};

वेरिएबल वेरिएबल फंक्शन / मेथड कॉल के लिए उपयोगी होते हैं:

function add($a, $b) {
    return $a + $b;
}

$funcName = 'add';

echo $funcName(1, 2); // outputs 3

यह PHP कक्षाओं में विशेष रूप से उपयोगी हो जाता है:

class myClass {
    public function __construct() {
        $functionName = 'doSomething';
        $this->$functionName('Hello World');
    }

    private function doSomething($string) {
        echo $string; // Outputs "Hello World"
    }
}

यह संभव है, लेकिन {} बीच $variableName रखने की आवश्यकता नहीं है:

${$variableName} = $value;

निम्नलिखित उदाहरण समकक्ष और आउटपुट "बाज़" दोनों हैं:

$fooBar = 'baz';
$varPrefix = 'foo';

echo $fooBar;               // Outputs "baz"
echo ${$varPrefix . 'Bar'}; // Also outputs "baz"

{} का उपयोग केवल तभी अनिवार्य है जब चर का नाम स्वयं एक अभिव्यक्ति है, जैसे:

${$variableNamePart1 . $variableNamePart2} = $value;

यह हमेशा {} उपयोग करने की सिफारिश की जाती है, क्योंकि यह अधिक पठनीय है।

हालांकि ऐसा करने की अनुशंसा नहीं की जाती है, लेकिन इस व्यवहार को चेन करना संभव है:

$$$$$$$$DoNotTryThisAtHomeKids = $value;

यह ध्यान रखना महत्वपूर्ण है कि चर चर का अत्यधिक उपयोग कई डेवलपर्स द्वारा एक बुरा अभ्यास माना जाता है। चूंकि वे आधुनिक आईडीई द्वारा स्थैतिक विश्लेषण के लिए अच्छी तरह से अनुकूल नहीं हैं, कई चर चर (या डायनेमिक विधि इनवोकेशन) वाले बड़े कोडबेस को बनाए रखना मुश्किल हो सकता है।

PHP5 और PHP7 के बीच अंतर

हमेशा {} या () उपयोग करने का एक अन्य कारण, यह है कि PHP5 और PHP7 में गतिशील चर से निपटने का एक अलग तरीका है, जिसके परिणामस्वरूप कुछ मामलों में एक अलग परिणाम होता है।

PHP7 में, डायनामिक वैरिएबल्स, प्रॉपर्टीज़ और तरीकों का अब लेफ्ट-टू-राइट ऑर्डर में कड़ाई से मूल्यांकन किया जाएगा, जैसा कि PHP5 में विशेष मामलों के मिश्रण के विपरीत है। नीचे दिए गए उदाहरण बताते हैं कि मूल्यांकन का क्रम कैसे बदल गया है।

केस 1: $$foo['bar']['baz']

• PHP5 व्याख्या: ${$foo['bar']['baz']}
• PHP7 व्याख्या: ($$foo)['bar']['baz'] बाज ($$foo)['bar']['baz']

केस 2: $foo->$bar['baz']

• PHP5 व्याख्या: $foo->{$bar['baz']}
• PHP7 व्याख्या: ($foo->$bar)['baz']

केस 3: $foo->$bar['baz']()

• PHP5 व्याख्या: $foo->{$bar['baz']}()
• PHP7 व्याख्या: ($foo->$bar)['baz']()

केस 4: Foo::$bar['baz']()

• PHP5 व्याख्या: Foo::{$bar['baz']}()
• PHP7 व्याख्या: (Foo::$bar)['baz']()

जानकारी का प्रकार

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

PHP में डेटा प्रकार निम्नलिखित हैं: अशक्त, बूलियन, पूर्णांक, फ्लोट, स्ट्रिंग, ऑब्जेक्ट, संसाधन और सरणी।

शून्य

नल को किसी भी चर को सौंपा जा सकता है। यह बिना मूल्य के एक चर का प्रतिनिधित्व करता है।

$foo = null;

यह वैरिएबल को अमान्य करता है और यदि इसे कहा जाता है तो यह अपरिभाषित या शून्य होगा। चर को मेमोरी से हटा दिया जाता है और कचरा कलेक्टर द्वारा हटा दिया जाता है।

बूलियन

यह केवल दो संभावित मूल्यों के साथ सबसे सरल प्रकार है।

$foo = true;
$bar = false;

बूलियन का उपयोग कोड के प्रवाह को नियंत्रित करने के लिए किया जा सकता है।

$foo = true;

if ($foo) {
    echo "true";
} else {
    echo "false";
}

पूर्णांक

पूर्णांक एक पूर्णांक धनात्मक या ऋणात्मक होता है। इसे किसी भी आधार के साथ प्रयोग किया जा सकता है। पूर्णांक का आकार प्लेटफ़ॉर्म-निर्भर है। PHP अहस्ताक्षरित पूर्णांकों का समर्थन नहीं करता है।

$foo = -3;  // negative
$foo = 0;   // zero (can also be null or false (as boolean)
$foo = 123; // positive decimal
$bar = 0123; // octal = 83 decimal
$bar = 0xAB; // hexadecimal = 171 decimal
$bar = 0b1010; // binary = 10 decimal
var_dump(0123, 0xAB, 0b1010); // output: int(83) int(171) int(10)

फ्लोट

फ्लोटिंग पॉइंट नंबर, "डबल्स" या बस "फ्लोट्स" कहा जाता है, दशमलव संख्याएं हैं।

$foo = 1.23;
$foo = 10.0;
$bar = -INF;
$bar = NAN;

सरणी

एक सरणी मानों की सूची की तरह है। किसी सरणी का सबसे सरल रूप पूर्णांक द्वारा अनुक्रमित किया जाता है, और सूचकांक द्वारा आदेशित किया जाता है, जिसमें पहला तत्व सूचकांक 0 पर स्थित होता है।

$foo = array(1, 2, 3); // An array of integers
$bar = ["A", true, 123 => 5]; // Short array syntax, PHP 5.4+

echo $bar[0];    // Returns "A"
echo $bar[1];    // Returns true
echo $bar[123];  // Returns 5
echo $bar[1234]; // Returns null

Arrays एक पूर्णांक इंडेक्स के अलावा एक कुंजी को एक मान से जोड़ सकता है। PHP में, सभी सरणियाँ पर्दे के पीछे साहचर्य सरणियाँ हैं, लेकिन जब हम विशिष्ट रूप से एक 'साहचर्य सरणी' का संदर्भ देते हैं, तो हमारा मतलब आमतौर पर एक या अधिक कुंजियाँ होती हैं जो पूर्णांक नहीं होती हैं।

$array = array();
$array["foo"] = "bar";
$array["baz"] = "quux";
$array[42] = "hello";
echo $array["foo"]; // Outputs "bar"
echo $array["bar"]; // Outputs "quux"
echo $array[42]; // Outputs "hello"

तार

एक स्ट्रिंग वर्णों की एक सरणी की तरह है।

$foo = "bar";

एक सरणी की तरह, एक स्ट्रिंग को अपने व्यक्तिगत वर्णों को लौटाने के लिए अनुक्रमित किया जा सकता है:

$foo = "bar";
echo $foo[0]; // Prints 'b', the first character of the string in $foo.

वस्तु

एक वस्तु एक वर्ग का एक उदाहरण है। इसके चर और तरीकों को -> ऑपरेटर के साथ एक्सेस किया जा सकता है।

$foo = new stdClass(); // create new object of class stdClass, which a predefined, empty class
$foo->bar = "baz";
echo $foo->bar; // Outputs "baz"
// Or we can cast an array to an object:
$quux = (object) ["foo" => "bar"];
echo $quux->foo; // This outputs "bar".

संसाधन

संसाधन चर खुली हुई फ़ाइलों, डेटाबेस कनेक्शन, स्ट्रीम, छवि कैनवास क्षेत्रों और जैसे (जैसे कि यह मैनुअल में कहा गया है) के लिए विशेष हैंडल रखते हैं।

$fp = fopen('file.ext', 'r'); // fopen() is the function to open a file on disk as a resource.
var_dump($fp); // output: resource(2) of type (stream)

स्ट्रिंग के रूप में एक चर के प्रकार को प्राप्त करने के लिए, gettype() फ़ंक्शन का उपयोग करें:

echo gettype(1); // outputs "integer"
echo gettype(true); // "boolean"

वैश्विक चर सर्वोत्तम प्रथाओं

हम निम्नलिखित छद्म कोड के साथ इस समस्या का वर्णन कर सकते हैं

function foo() {
    global $bob;
    $bob->doSomething();
}

यहाँ आपका पहला प्रश्न स्पष्ट है

$bob कहां से आए?

क्या आप भ्रमित हैं? अच्छा। आपने अभी-अभी जाना है कि ग्लोबल्स भ्रमित क्यों हैं और एक बुरा अभ्यास माना जाता है।

यदि यह एक वास्तविक कार्यक्रम था, तो आपका अगला थोड़ा सा मज़ा $bob सभी उदाहरणों को ट्रैक करने के लिए है और आशा है कि आप सही पाएंगे (यदि $bob को हर जगह उपयोग किया जाता है तो यह खराब हो जाता है)। इससे भी बदतर, अगर कोई और जाता है और $bob को परिभाषित करता है (या आप भूल गए और उस चर का पुन: उपयोग किया है) तो आपका कोड टूट सकता है (उपरोक्त कोड उदाहरण में, गलत वस्तु, या कोई भी वस्तु नहीं होने पर, एक घातक त्रुटि का कारण होगा)।

चूँकि वस्तुतः सभी PHP प्रोग्रामों में कोड का उपयोग करना include('file.php'); आपकी नौकरी का रखरखाव कोड इस तरह से और अधिक कठिन हो जाता है कि आप जितनी अधिक फाइलें जोड़ते हैं।

इसके अलावा, यह आपके अनुप्रयोगों के परीक्षण का कार्य बहुत कठिन बना देता है। मान लीजिए कि आप अपने डेटाबेस कनेक्शन को रखने के लिए एक वैश्विक चर का उपयोग करते हैं:

$dbConnector = new DBConnector(...);

function doSomething() {
    global $dbConnector;
    $dbConnector->execute("...");
}

इस फ़ंक्शन का यूनिट परीक्षण करने के लिए, आपको वैश्विक $dbConnector वैरिएबल को ओवरराइड करना होगा, परीक्षण चलाने होंगे और फिर इसे अपने मूल मूल्य पर रीसेट करना होगा, जो बहुत ही बग प्रवण है:

/**
 * @test
 */
function testSomething() {
     global $dbConnector;

     $bkp = $dbConnector; // Make backup
     $dbConnector = Mock::create('DBConnector'); // Override

     assertTrue(foo());

     $dbConnector = $bkp; // Restore
}

हम ग्लोबल्स से कैसे बचें?

ग्लोबल्स से बचने का सबसे अच्छा तरीका एक दर्शन है जिसे डिपेंडेंसी इंजेक्शन कहा जाता है। यह वह जगह है जहाँ हम फ़ंक्शन या वर्ग में आवश्यक उपकरण पास करते हैं।

function foo(\Bar $bob) {
    $bob->doSomething();
}

यह समझना और बनाए रखना बहुत आसान है। ऐसा कोई अनुमान नहीं है कि $bob कहां स्थापित किया गया था क्योंकि कॉल करने वाले को यह जानने के लिए जिम्मेदार है (यह हमें गुजर रहा है जिसे हमें जानने की आवश्यकता है)। बेहतर अभी भी, हम जो कुछ भी पारित किया जा रहा है उसे प्रतिबंधित करने के लिए प्रकार की घोषणाओं का उपयोग कर सकते हैं।

तो हम जानते हैं कि $bob या तो का एक उदाहरण है Bar वर्ग, या का एक बच्चा का एक उदाहरण Bar , जिसका अर्थ है कि हम जानते हैं कि हम उस वर्ग के तरीकों का उपयोग कर सकते हैं। एक मानक ऑटोलैडर (PHP 5.3 के बाद से उपलब्ध) के साथ संयुक्त, अब हम नीचे ट्रैक कर सकते हैं जहां Bar को परिभाषित किया गया है। PHP 7.0 या बाद में विस्तारित प्रकार की घोषणाएं शामिल हैं, जहां आप स्केलर प्रकार (जैसे int या string ) का भी उपयोग कर सकते हैं।

सभी परिभाषित चर प्राप्त करना

get_defined_vars() फ़ंक्शन कहे जाने वाले कार्यक्षेत्र में परिभाषित चर के सभी नामों और मूल्यों के साथ एक सरणी देता है। यदि आप डेटा प्रिंट करना चाहते हैं तो आप मानव-पठनीय डेटा, जैसे print_r या var_dump के आउटपुट के लिए मानक कार्यों का उपयोग कर सकते हैं।

var_dump(get_defined_vars());

नोट : यह फ़ंक्शन आमतौर पर केवल 4 सुपरग्लोब लौटाता है: $_GET , $_POST , $_COOKIE , $_FILES । अन्य सुपरग्लोबल्स केवल तभी लौटाए जाते हैं जब उनका उपयोग कोड में कहीं किया गया हो। यह auto_globals_jit निर्देश के कारण है जो डिफ़ॉल्ट रूप से सक्षम है। जब यह सक्षम होता है, तो स्क्रिप्ट शुरू होने के बजाय $_SERVER और $_ENV चर तब बनाए जाते हैं, जब वे पहली बार उपयोग किए जाते हैं। यदि इन चरों का उपयोग किसी स्क्रिप्ट के भीतर नहीं किया जाता है, तो इस निर्देश के होने से प्रदर्शन लाभ होगा।

अनइंस्टॉल किए गए चर के डिफ़ॉल्ट मान

हालांकि PHP में आवश्यक नहीं है लेकिन यह चर को शुरू करने के लिए एक बहुत अच्छा अभ्यास है। Uninitialized चर का उपयोग उस संदर्भ के आधार पर उनके प्रकार का डिफ़ॉल्ट मान होता है जिसमें वे उपयोग किए जाते हैं:

परेशान और अप्रकाशित

var_dump($unset_var); // outputs NULL

बूलियन

echo($unset_bool ? "true\n" : "false\n"); // outputs 'false' 

तार

$unset_str .= 'abc';
var_dump($unset_str); // outputs 'string(3) "abc"'

पूर्णांक

$unset_int += 25; // 0 + 25 => 25
var_dump($unset_int); // outputs 'int(25)'

फ्लोट / डबल

$unset_float += 1.25;
var_dump($unset_float); // outputs 'float(1.25)'

सरणी

$unset_arr[3] = "def";
var_dump($unset_arr); //  outputs array(1) {  [3]=>  string(3) "def" }

वस्तु

$unset_obj->foo = 'bar';
var_dump($unset_obj); // Outputs: object(stdClass)#1 (1) {  ["foo"]=>  string(3) "bar" }

एक फ़ाइल को दूसरी चर में उपयोग करने के मामले में एक असंबद्ध वैरिएबल के डिफ़ॉल्ट मान पर निर्भर होना एक समस्या है।

परिवर्तनीय मूल्य सच्चाई और पहचानकर्ता संचालक

PHP में, चर मानों में एक संबद्ध "सत्यता" होती है, इसलिए गैर-बूलियन मान भी true या false समान होंगे। यह किसी भी चर को सशर्त ब्लॉक में उपयोग करने की अनुमति देता है, जैसे

if ($var == true) { /* explicit version */ }
if ($var) { /* $var == true is implicit */ }

विभिन्न प्रकार के परिवर्तनशील मूल्यों के लिए कुछ मूलभूत नियम इस प्रकार हैं:

• करने के लिए गैर शून्य लंबाई समानता के साथ तार true केवल whitepace जैसे युक्त तार सहित ' '
• खाली तार '' false बराबर है।

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '   ';
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

• अगर वे नॉनवेज हैं तो इंटेगर true बराबर हैं, जबकि शून्य false बराबर है।

$var = -1;
$var_is_true = ($var == true); // true
$var = 99;
$var_is_true = ($var == true); // true
$var = 0;
$var_is_true = ($var == true); // false

• null false बराबर होता false

$var = null;
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• खाली तार '' और स्ट्रिंग शून्य '0' false बराबर है।

$var = '';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = '0';
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

• फ्लोटिंग-पॉइंट मान true बराबर होते हैं यदि वे नॉनज़रो हैं, जबकि शून्य मान false बराबर हैं।
  • NAN ( NAN -a-Number) true बराबर true , अर्थात NAN == true true । ऐसा इसलिए है क्योंकि NAN एक नॉनवेज फ्लोटिंग-पॉइंट वैल्यू है।
  • शून्य मानों में IE0 754 द्वारा परिभाषित +0 और -0 दोनों शामिल हैं। PHP अपने दोहरे-सटीक फ़्लोटिंग पॉइंट यानी floatval('0') == floatval('-0') में +0 और -0 के बीच अंतर नहीं करता है। floatval('0') == floatval('-0') true ।
    • वास्तव में, floatval('0') === floatval('-0') ।
    • इसके अतिरिक्त, दोनों floatval('0') == false और floatval('-0') == false ।

$var = NAN;
$var_is_true = ($var == true); // true
$var_is_false = ($var == false); // false

$var = floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

$var = floatval('0') == floatval('-0');
$var_is_true = ($var == true); // false
$var_is_false = ($var == false); // true

पहचानकर्ता

तुलना संचालकों के लिए PHP प्रलेखन में , एक पहचानकर्ता संचालक === । इस ऑपरेटर का उपयोग यह जांचने के लिए किया जा सकता है कि क्या एक चर संदर्भ मूल्य के समान है:

$var = null;
$var_is_null = $var === null; // true
$var_is_true = $var === true; // false
$var_is_false = $var === false; // false

यह एक समान नहीं ऑपरेटर समान है !== :

$var = null;
$var_is_null = $var !== null; // false
$var_is_true = $var !== true; // true
$var_is_false = $var !== false; // true

समरूप ऑपरेटर का उपयोग भाषा के कार्यों जैसे कि is_null() विकल्प के रूप में किया जा सकता है।

उपयोग के साथ मामले का उपयोग करें strpos()

strpos($haystack, $needle) भाषा फ़ंक्शन का उपयोग उस सूचकांक का पता लगाने के लिए किया जाता है, जिस पर $needle $haystack में होती है, या क्या यह बिल्कुल होता है। strpos() फ़ंक्शन संवेदनशील है; यदि केस-असंवेदनशील मिल जाए, तो आपको stripos($haystack, $needle) साथ जाने की आवश्यकता है

strpos & stripos से काम करने वाली तीसरी पैरामीटर शामिल है offset (पूर्णांक), जो करता है, तो निर्दिष्ट, खोज स्ट्रिंग की शुरुआत से गिना पात्रों की इस संख्या शुरू कर देंगे। स्ट्रैप और स्ट्रिप के विपरीत, ऑफसेट नकारात्मक नहीं हो सकता

फ़ंक्शन वापस आ सकता है:

• 0 यदि $needle की शुरुआत में $haystack $needle पाई जाती है;
• एक गैर शून्य पूर्णांक सूचकांक को निर्दिष्ट करता है, तो $needle कहीं में शुरुआत के अलावा अन्य पाया जाता है $haystack ;
• और मूल्य false अगर $needle $haystack में कहीं भी नहीं मिली है।

क्योंकि पीएचपी में 0 और false दोनों में सत्यता false , लेकिन strpos() लिए अलग-अलग स्थितियों का प्रतिनिधित्व करते हैं, उनके बीच अंतर करना और समान ऑपरेटर === का उपयोग करना महत्वपूर्ण है ताकि false लिए वास्तव में देखा जा सके और केवल एक मूल्य जो false लिए समान हो।

$idx = substr($haystack, $needle);
if ($idx === false) 
{
    // logic for when $needle not found in $haystack
} 
else
{
    // logic for when $needle found in $haystack
}

वैकल्पिक रूप से, समान ऑपरेटर का उपयोग नहीं कर रहा है:

$idx = substr($haystack, $needle);
if ($idx !== false) 
{
    // logic for when $needle found in $haystack
} 
else
{
    // logic for when $needle not found in $haystack
}