संदर्भ-PHP में इस प्रतीक का क्या अर्थ है?




operators symbols (12)

ऑपरेटर टाइप करें

instanceof यह निर्धारित करने के लिए प्रयोग किया जाता है कि एक PHP चर एक निश्चित वर्ग की तत्काल वस्तु है या नहीं।

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

उपर्युक्त उदाहरण आउटपुट होगा:

bool(true)
bool(false)

कारण: उदाहरण के ऊपर $a mclass का एक ऑब्जेक्ट है इसलिए mclass उदाहरण के लिए केवल एक mclass डेटा का उपयोग न करें

विरासत के साथ उदाहरण

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

उपर्युक्त उदाहरण आउटपुट होगा:

bool(true)
bool(true)

क्लोन के साथ उदाहरण

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

उपर्युक्त उदाहरण आउटपुट होगा:

bool(true)
bool(true)

https://code.i-harness.com

यह क्या है?

यह प्रश्नों का एक संग्रह है जो हर समय और फिर PHP में वाक्यविन्यास के बारे में आता है। यह एक सामुदायिक विकी भी है, इसलिए इस सूची को बनाए रखने में सभी को भाग लेने के लिए आमंत्रित किया जाता है।

ऐसा क्यों है?

ऑपरेटरों और अन्य वाक्यविन्यास टोकन के बारे में प्रश्न ढूंढना मुश्किल था
मुख्य विचार है कि स्टैक ओवरफ़्लो पर मौजूदा प्रश्नों के लिंक हों, इसलिए हमारे लिए संदर्भित करना आसान है, PHP मैनुअल से सामग्री पर प्रतिलिपि न लें।

¹ नोट: जनवरी 2013 से, स्टैक ओवरफ़्लो विशेष वर्णों का समर्थन करता है । उद्धरणों से बस खोज शब्दों को घेरे, उदाहरण के लिए [php] "==" vs "==="

मुझे यहाँ क्या करना चाहिए?

अगर आपको किसी के द्वारा यहां बताया गया है क्योंकि आपने ऐसा प्रश्न पूछा है, तो कृपया नीचे दिए गए विशेष वाक्यविन्यास को ढूंढें। लिंक किए गए प्रश्नों के साथ PHP मैन्युअल में लिंक किए गए पृष्ठ शायद आपके प्रश्न का उत्तर देंगे। यदि ऐसा है, तो आपको उत्तर को ऊपर उठाने के लिए प्रोत्साहित किया जाता है। यह सूची दूसरों द्वारा प्रदान की गई सहायता के विकल्प के रूप में नहीं है।

सूचि

यदि आपका विशेष टोकन नीचे सूचीबद्ध नहीं है, तो आप इसे पार्सर टोकन की सूची में पा सकते हैं।

& बिटवाई ऑपरेटर या References

=& References

&= बिटवाई ऑपरेटर

&& लॉजिकल ऑपरेटर्स

% अंकगणितीय ऑपरेटरों

!! लॉजिकल ऑपरेटर्स

@ त्रुटि नियंत्रण ऑपरेटर

?: टर्नरी ऑपरेटर

?? नल कोलेसेस ऑपरेटर (PHP 7 के बाद से)

: नियंत्रण संरचनाओं , टर्नरी ऑपरेटर के लिए वैकल्पिक वाक्यविन्यास

:: स्कोप रेज़ोल्यूशन ऑपरेटर

\ Namespaces

-> कक्षाएं और वस्तुओं

=> Arrays

^ बिटवाई ऑपरेटर्स

>> बिटवाई ऑपरेटर

<< बिटवाई ऑपरेटर

<<< हेरेडोक या नाओडोक

= असाइनमेंट ऑपरेटर

== तुलना ऑपरेटर

=== तुलना ऑपरेटर

!== तुलना ऑपरेटर

!= तुलना ऑपरेटर

<> तुलना ऑपरेटर

<=> तुलना ऑपरेटर (PHP 7.0 के बाद से)

  • स्पेसशिप (तीन तरह की तुलना) ऑपरेटर

| बिटवाई ऑपरेटर

|| लॉजिकल ऑपरेटर्स

~ बिटवाई ऑपरेटर

+ अंकगणितीय ऑपरेटर , ऐरे ऑपरेटर

+= और -= असाइनमेंट ऑपरेटर

++ और -- बढ़ते / घटकों को कम करना

.= असाइनमेंट ऑपरेटर

. स्ट्रिंग ऑपरेटर

, फ़ंक्शन तर्क

, परिवर्तनीय घोषणाएं

$$ परिवर्तनीय चर

` निष्पादन ऑपरेटर

<?= लघु खुले टैग

[] Arrays (PHP 5.4 के बाद से लघु वाक्यविन्यास)

<? खुले और समापन टैग

... तर्क अनपॅकिंग (PHP 5.6 के बाद से)

** Exponentiation (PHP 5.6 के बाद से)

# वन-लाइन शेल-स्टाइल टिप्पणी


बिटवाई ऑपरेटर

थोड़ा सा क्या है थोड़ा सा 1 या 0 का प्रतिनिधित्व है। मूल रूप से बंद (0) और चालू (1)

बाइट क्या है? एक बाइट 8 बिट्स से बना होता है और बाइट का उच्चतम मूल्य 255 होता है, जिसका अर्थ यह होगा कि प्रत्येक बिट सेट हो। हम देखेंगे कि बाइट का अधिकतम मूल्य 255 क्यों है।

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

1 बाइट का यह प्रतिनिधित्व

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 बाइट)

बेहतर समझने के लिए कुछ उदाहरण

"और" ऑपरेटर: &

$a =  9;
$b = 10;
echo $a & $b;

यह संख्या 8 का उत्पादन करेगा क्यों? खैर देखते हैं कि हमारे टेबल उदाहरण का उपयोग करें।

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

तो आप तालिका से देख सकते हैं कि वे एक साथ साझा करते हैं केवल 8 बिट है।

दूसरा उदाहरण

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

दो साझा बिट्स 32 और 4 हैं, जो एक साथ जोड़े जाने पर 36 लौटते हैं।

"या" ऑपरेटर: |

$a =  9;
$b = 10;
echo $a | $b;

यह संख्या 11 आउटपुट होगा क्यों?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

आप देखेंगे कि हमारे पास 8 बिट्स सेट हैं, 8, 2 और 1 कॉलम में। उन्हें जोड़ें: 8 + 2 + 1 = 11।


<=> स्पेसशिप ऑपरेटर

PHP 7 में जोड़ा गया

स्पेसशिप ऑपरेटर <=> PHP 7 में जोड़ा गया नवीनतम तुलना ऑपरेटर है। यह समानता वाले ऑपरेटरों ( == != , === !== ) के समान प्राथमिकता वाला गैर-सहयोगी बाइनरी ऑपरेटर है। यह ऑपरेटर बाएं हाथ और दाएं हाथ के संचालन के बीच सरल तीन-तरफा तुलना करने की अनुमति देता है।

ऑपरेटर के परिणामस्वरूप पूर्णांक अभिव्यक्ति होती है:

  • 0 जब दोनों ऑपरेंड बराबर होते हैं
  • 0 से कम जब बाएं हाथ के ऑपरेंड दाएं हाथ के ऑपरेंड से कम है
  • 0 से बड़ा जब बाएं हाथ का ऑपरेंड दाएं हाथ के ऑपरेंड से बड़ा होता है

जैसे

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

इस ऑपरेटर का उपयोग करने का एक अच्छा व्यावहारिक अनुप्रयोग तुलनात्मक प्रकार कॉलबैक में होगा जो कि दो मानों के बीच तीन-तरफा तुलना के आधार पर शून्य, नकारात्मक, या सकारात्मक पूर्णांक लौटने की उम्मीद है। usort को पारित तुलना समारोह एक ऐसा उदाहरण है।

PHP 7 से पहले आप लिखेंगे ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

चूंकि PHP 7 आप लिख सकते हैं ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

स्पेसशिप ऑपरेटर <=> (PHP 7 में जोड़ा गया)

<=> स्पेसशिप ऑपरेटर के लिए उदाहरण (PHP 7, स्रोत: PHP मैनुअल):

चर के तीन-तरफा तुलना के लिए इंटीजर, फ़्लोट्स, स्ट्रिंग्स, Arrays और ऑब्जेक्ट्स।

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

==परिवर्तनीय डेटा-प्रकार पर विचार किए बिना चेक समानता के लिए प्रयोग किया जाता है

===वैरिएबल वैल्यू * और ** डेटा-टाइप दोनों के लिए चेक समानता के लिए प्रयोग किया जाता है

उदाहरण

$a = 5

  1. if ($a == 5) - सच का मूल्यांकन करेंगे

  2. if ($a == '5') - सत्य का मूल्यांकन करेगा, क्योंकि यह दोनों मूल्य की तुलना करते समय PHP आंतरिक रूप से उस स्ट्रिंग मान को पूर्णांक में परिवर्तित करता है और फिर दोनों मानों की तुलना करता है

  3. if ($a === 5) - सच का मूल्यांकन करेंगे

  4. if ($a === '5') - गलत का मूल्यांकन करेगा, क्योंकि मान 5 है, लेकिन यह मान 5 पूर्णांक नहीं है।


{} घुंघराले ब्रेसिज़

और अंतिम पोस्ट के बारे में कुछ शब्द

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

ऑपरेटर बढ़ाना / घटाना

++ वृद्धि ऑपरेटर

-- कमी ऑपरेटर

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

ये चर के पहले या बाद में जा सकते हैं।

यदि परिवर्तनीय से पहले रखा गया है, तो पहले वैरिएबल में वृद्धि / कमीशन ऑपरेशन किया जाता है तो परिणाम वापस कर दिया जाता है। यदि परिवर्तनीय के बाद रखा गया है, तो चर पहले लौटा दिया गया है, तो वृद्धि / कमी ऑपरेशन किया जाता है।

उदाहरण के लिए:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

लाइव उदाहरण

उपरोक्त मामले में ++$i का उपयोग किया जाता है, क्योंकि यह तेज़ है। $i++ के समान परिणाम होंगे।

प्री-इंक्रिमेंटमेंट थोड़ा तेज़ है क्योंकि यह वास्तव में चर को बढ़ाता है और उसके बाद परिणाम 'रिटर्न' होता है। पोस्ट-इंक्रिमेंटेशन एक विशेष चर बनाता है, पहले चर के मूल्य की प्रतिलिपि बनाता है और केवल पहले चर के उपयोग के बाद, इसके मूल्य को दूसरे के साथ बदल देता है।

हालांकि, आपको $apples-- उपयोग करना $apples-- , पहले से, आप सेब की वर्तमान संख्या प्रदर्शित करना चाहते हैं, और फिर आप इसे से घटा सकते हैं।

आप PHP में अक्षरों को भी बढ़ा सकते हैं:

$i = "a";
while ($i < "c") {
    echo $i++;
}

एक बार z पहुंचने के बाद z अगले है, और इसी तरह।

ध्यान दें कि चरित्र चर को बढ़ाया जा सकता है लेकिन कम नहीं किया जा सकता है और यहां तक ​​कि केवल सादा ASCII वर्ण (एज़ और एजेड) समर्थित हैं।

स्टैक ओवरफ़्लो पोस्ट:


PHP स्ट्रिंग्स: PHP स्ट्रिंग्स को चार तरीकों से निर्दिष्ट नहीं किया जा सकता है न कि केवल दो तरीकों से:

1) सिंगल कोट स्ट्रिंग्स:

$string = 'This is my string'; // print This is my string

2) डबल कोट स्ट्रिंग्स:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) हेरेडोक:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (PHP 5.3.0 के बाद से):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

नल Coalesce ऑपरेटर PHP

जारीकर्ता () के साथ संयोजन में एक टर्नरी का उपयोग करने की आवश्यकता के सामान्य मामले के लिए शून्य कोलेसिंग ऑपरेटर (??) को PHP7 में जोड़ा गया है। यदि यह अस्तित्व में है तो यह अपना पहला ऑपरेंड लौटाता है और न्यूल नहीं है अन्यथा यह अपना दूसरा ऑपरेंड देता है, जैसे कि निम्न उदाहरण:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

नल coalescing ऑपरेटर (??)

isset() के साथ संयोजन में एक टर्नरी ऑपरेटर का उपयोग करने की आवश्यकता के सामान्य मामले के लिए यह ऑपरेटर PHP 7.0 में जोड़ा गया है। यदि यह अस्तित्व में है और यह पूर्ण नहीं है तो यह अपना पहला ऑपरेंड देता NULL ; अन्यथा यह अपना दूसरा ऑपरेंड देता है।

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

सवाल:

क्या =>मतलब है?

उत्तर:

=>क्या प्रतीक हम इंसानों ने "Key" => "Value"एसोसिएटिव Arrays में जोड़े को अलग करने के लिए उपयोग करने का फैसला किया है ।

विस्तार से चर्चा करते:

इसे समझने के लिए, हमें पता होना चाहिए कि एसोसिएटिव Arrays क्या हैं। पहली बात यह है कि जब एक पारंपरिक प्रोग्रामर एक सरणी ( PHP में ) के बारे में सोचता है तो कुछ ऐसा ही होगा:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

जहां, अगर हम कोड के कुछ हिस्सों में सरणी को कॉल करना चाहते थे, तो हम कर सकते थे:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

अब तक सब ठीक है। हालांकि, इंसानों के रूप में, हमें यह याद रखना मुश्किल हो सकता है कि [0]सरणी का सूचकांक वर्ष 2016 का मूल्य है , [1]सरणी का सूचकांक एक बधाई है , और [2]सरणी का सूचकांक एक साधारण पूर्णांक मान है । हमारे पास वैकल्पिक विकल्प होगा जिसे एसोसिएटिव ऐरे कहा जाता है । एक एसोसिएटिव सरणी में अनुक्रमिक ऐरे से कुछ अंतर होते हैं ( जो कि पिछले मामले थे, क्योंकि प्रत्येक पूर्व मान के लिए 1 से बढ़कर, पूर्व निर्धारित अनुक्रम में उपयोग की गई इंडेक्स में वृद्धि होती है )।

मतभेद ( अनुक्रमिक और सहयोगी सरणी के बीच ):

  • एक एसोसिएटिव ऐरे की घोषणा को छोड़कर, आप केवल valueउस सरणी में शामिल नहीं करना चाहते हैं, जिसे आप सरणी में रखना चाहते हैं, लेकिन आप इंडेक्स वैल्यू (जिसे कहा जाता है key) भी डालते हैं जिसे आप सरणी को बाद के हिस्सों में कॉल करते समय उपयोग करना चाहते हैं कोड। निम्नलिखित वाक्यविन्यास का उपयोग इसकी घोषणा के दौरान किया जाता है "key" => "value":।

  • एसोसिएटिव ऐरे का उपयोग करते समय, keyमूल्य वांछित पुनर्प्राप्त करने के लिए सरणी के सूचकांक के अंदर रखा जाएगा value

उदाहरण के लिए:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

और अब, पहले के समान उत्पादन प्राप्त करने के लिए, keyमान का उपयोग सरणी अनुक्रमणिका में किया जाएगा:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

अंतिम अंक:

तो उपर्युक्त उदाहरण से, यह देखना बहुत आसान है कि =>सरणी के भीतर मानों की शुरुआत के दौरान एक सरणी में प्रत्येक keyऔर valueजोड़े के बीच एक एसोसिएटिव ऐरे के संबंध को व्यक्त करने के लिए प्रतीक का उपयोग किया जाता है ।


Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"






php-5.3