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




symbols php-5.3 (15)

यह क्या है?

यह प्रश्नों का एक संग्रह है जो हर समय और फिर 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 के बाद से)

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


Answers

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"

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

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

$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

नल Coalesce ऑपरेटर PHP

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

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

स्पेसशिप ऑपरेटर <=> (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

PHP में ऑपरेटरों का एक सिंहावलोकन:

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

  • $ a && $ b: सत्य अगर दोनों $ a और $ b सत्य हैं।
  • $ ए || $ बी: सही अगर या तो $ एक या $ बी सत्य है।
  • $ एक xor $ b: सत्य अगर या तो $ एक या $ बी सत्य है, लेकिन दोनों नहीं।
  • ! $ ए: सही अगर $ एक सत्य नहीं है।
  • $ ए और $ बी: सही अगर दोनों $ और $ बी सत्य हैं।
  • $ ए या $ बी: सही अगर कोई $ या $ बी सत्य है।

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

  • $ a == $ b: सही अगर $ j टाइपिंग के बाद $ b के बराबर है।
  • $ a === $ b: सही अगर $ एक $ बी के बराबर है, और वे एक ही प्रकार के हैं।
  • $ ए! = $ बी: सही अगर $ j टाइपिंग के बाद $ b के बराबर नहीं है।
  • $ a <> $ b: सही अगर $ j टाइपिंग के बाद $ b के बराबर नहीं है।
  • $ ए! == $ बी: सही अगर $ ए $ बी के बराबर नहीं है, या वे एक ही प्रकार के नहीं हैं।
  • $ a <$ b : सही अगर $ ए कड़ाई से $ बी से कम है।
  • $ ए> $ बी : सही अगर $ ए कड़ाई से $ बी से अधिक है।
  • $ a <= $ b : सही अगर $ एक $ बी से कम या बराबर है।
  • $ a> = $ b : सही अगर $ एक $ बी से अधिक या बराबर है।
  • $ a <=> $ b : शून्य से कम, बराबर, या शून्य से अधिक एक पूर्णांक क्रमशः $ बी से कम, बराबर या उससे अधिक है। PHP 7 के रूप में उपलब्ध है।
  • $ ए? $ बी: $ सी : अगर $ एक वापसी $ बी और $ सी ( टर्नरी ऑपरेटर ) वापस
  • $ एक ?? $ सी : $ ए के समान? $ ए: $ सी ( शून्य कोलेसिंग ऑपरेटर - PHP> = 7 की आवश्यकता है)

अंकगणितीय आपरेटर:

  • - $ ए : $ ए के विपरीत।
  • $ ए + $ बी : $ ए और $ बी का योग।
  • $ ए - $ बी : $ ए और $ बी का अंतर।
  • $ ए * $ बी : $ ए और $ बी का उत्पाद।
  • $ ए / $ बी : $ ए और $ बी का कोटिएंट।
  • $ एक% $ बी : $ बी के विभाजित $ के शेष।
  • $ एक ** $ बी : $ b'th पावर को $ एक बढ़ाने का परिणाम (PHP 5.6 में पेश किया गया)

बढ़ते / घटाने वाले ऑपरेटरों:

  • ++ $ ए : $ एक से बढ़ता है, फिर $ ए देता है।
  • $ ए ++ : $ एक देता है, फिर $ एक को बढ़ाता है।
  • - $ ए : एक करके $ एक घटाता है, फिर $ ए देता है।
  • $ a-- : $ एक देता है, फिर $ एक को कम करता है।

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

  • $ ए और $ बी : बिट्स जो $ ए और $ बी दोनों में सेट हैं सेट हैं।
  • $ ए | $ बी : $ एक या $ बी में सेट बिट्स सेट हैं।
  • $ a ^ $ b : बिट्स जो $ a या $ b में सेट हैं लेकिन दोनों सेट नहीं हैं।
  • ~ $ ए : बिट्स जो $ एक में सेट हैं सेट नहीं हैं, और इसके विपरीत।
  • $ a << $ b : बाईं ओर $ $ b चरणों के बिट्स को Shift करें (प्रत्येक चरण का अर्थ है "दो से गुणा करें")
  • $ ए >> $ बी : दाईं ओर $ $ बी चरणों के बिट्स को शिफ्ट करें (प्रत्येक चरण का मतलब है "दो से विभाजित करें")

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

  • $ ए $ बी : $ ए और $ बी का संतोष।

ऐरे ऑपरेटर:

  • $ ए + $ बी : $ ए और $ बी का संघ।
  • $ a == $ b : सही अगर $ a और $ b में एक ही कुंजी / मान जोड़े हैं।
  • $ a === $ b : सही अगर $ ए और $ बी में एक ही कुंजी / वैल्यू जोड़े एक ही क्रम में और उसी प्रकार के होते हैं।
  • $ ए! = $ बी : सही अगर $ ए $ बी के बराबर नहीं है।
  • $ a <> $ b : सत्य अगर $ ए $ बी के बराबर नहीं है।
  • $ ए! == $ बी : सही अगर $ ए $ बी के समान नहीं है।

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

  • $ ए = $ बी : $ बी का मूल्य $ ए को सौंपा गया है
  • $ ए + = $ बी : $ ए = $ ए + $ बी के समान
  • $ ए - = $ बी : $ ए = $ ए - $ बी के समान
  • $ ए * = $ बी : $ ए = $ ए * $ बी के समान
  • $ ए / = $ बी : $ ए = $ ए / $ बी के समान
  • $ एक% = $ बी : $ = $ एक% $ बी के समान
  • $ एक ** = $ बी : $ = $ एक ** $ b के समान
  • $ ए। = $ बी : $ ए = $ ए के समान। $ ख
  • $ ए और = $ बी : $ एक = $ ए और $ बी के समान
  • $ ए | = $ बी : $ एक = $ ए के समान $ ख
  • $ a ^ = $ b : $ a = $ a ^ $ b के समान
  • $ a << = $ b : $ a = $ a << $ b के समान
  • $ ए >> = $ बी : $ एक = $ एक >> $ बी के समान

ध्यान दें

and ऑपरेटर और ऑपरेटर असाइनमेंट ऑपरेटर = तुलना में कम प्राथमिकता है।

इसका मतलब है कि $a = true and false; बराबर है ($a = true) and false

ज्यादातर मामलों में आप शायद && और || का उपयोग करना चाहेंगे , जो सी, जावा या जावास्क्रिप्ट जैसी भाषाओं से ज्ञात तरीके से व्यवहार करता है।


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

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

उदाहरण

$a = 5

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

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

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

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


जादू स्थिरांक : हालांकि ये केवल प्रतीक नहीं हैं बल्कि इस टोकन परिवार का महत्वपूर्ण हिस्सा हैं। आठ जादुई स्थिरांक हैं जो उनके उपयोग के आधार पर बदलते हैं।

__LINE__ : फ़ाइल की वर्तमान पंक्ति संख्या।

__FILE__ : फ़ाइल का पूरा पथ और फ़ाइल नाम। यदि किसी अंदर शामिल होता है, तो शामिल फ़ाइल का नाम वापस कर दिया जाता है। चूंकि PHP 4.0.2, __FILE__ हमेशा __FILE__ साथ एक पूर्ण पथ होता है जबकि पुराने संस्करणों में इसमें कुछ परिस्थितियों में सापेक्ष पथ होता है।

__DIR__ : फ़ाइल की निर्देशिका। यदि किसी अंदर शामिल किया गया है, तो शामिल फ़ाइल की निर्देशिका वापस कर दी गई है। यह dirname(__FILE__) बराबर है। इस निर्देशिका नाम में पीछे की ओर स्लैश नहीं है जब तक कि यह रूट निर्देशिका न हो। (PHP 5.3.0 में जोड़ा गया।)

__FUNCTION__ : फ़ंक्शन का नाम। (PHP 4.3.0 में जोड़ा गया) PHP 5 के रूप में यह निरंतर फ़ंक्शन नाम देता है क्योंकि इसे घोषित किया गया था (केस-संवेदी)। PHP 4 में इसका मान हमेशा कम हो जाता है।

__CLASS__ : कक्षा का नाम। (PHP 4.3.0 में जोड़ा गया) PHP 5 के रूप में यह निरंतर वर्ग नाम देता है क्योंकि इसे घोषित किया गया था (केस-संवेदी)। PHP 4 में इसका मान हमेशा कम हो जाता है। कक्षा के नाम में नामस्थान शामिल किया गया था (उदाहरण के लिए Foo\Bar )। ध्यान दें कि PHP 5.4 __CLASS__ रूप में लक्षणों में भी काम करता है। जब किसी विशेषता विधि में उपयोग किया जाता है, तो __CLASS__ कक्षा का नाम होता है जिसकी विशेषता का उपयोग किया जाता है।

__TRAIT__ : विशेषता का नाम। (PHP 5.4.0 में जोड़ा गया) PHP 5.4 के रूप में यह निरंतर गुण देता है क्योंकि इसे घोषित किया गया था (केस-संवेदी)। विशेषता नाम में उस नामस्थान को शामिल किया गया है जिसमें इसे घोषित किया गया था (उदाहरण के लिए Foo\Bar )।

__METHOD__ : कक्षा विधि का नाम। (PHP 5.0.0 में जोड़ा गया) विधि का नाम वापस कर दिया गया है क्योंकि इसे घोषित किया गया था (केस-संवेदी)।

__NAMESPACE__ : वर्तमान नामस्थान का नाम (केस-संवेदी)। यह निरंतर संकलन-समय में परिभाषित किया गया है (PHP 5.3.0 में जोड़ा गया)।

Source


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

प्रश्न :

PHP में "&" का अर्थ क्या है?

PHP "और" ऑपरेटर

एक बार जब हम इसका इस्तेमाल करते हैं तो जीवन को और अधिक आसान बनाता है .. (ध्यान से नीचे उदाहरण देखें)

और आमतौर पर $ बिट्स और $ बी दोनों में सेट बिट्स सेट की जाती हैं।

क्या आपने यह भी देखा है कि ये कॉल कैसे काम करती हैं?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

तो उपरोक्त सभी के पीछे bitwise ऑपरेटर और बिट्स का खेल है।

इनमें से एक उपयोगी मामला नीचे की तरह आसान कॉन्फ़िगरेशन है, इसलिए एक एकल पूर्णांक फ़ील्ड आपके लिए हजारों combos स्टोर कर सकता है।

अधिकांश लोगों ने पहले ही दस्तावेज़ों को पढ़ लिया है लेकिन इन बिटवाई ऑपरेटरों के वास्तविक विश्व उपयोग मामले को राहत नहीं दी है।

उदाहरण है कि आप प्यार करेंगे

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird


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

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)

नल Coalesce ऑपरेटर "??" (PHP 7 में जोड़ा गया)

एक ऑपरेटर के लिए सबसे आकर्षक नाम नहीं है, लेकिन PHP 7 बल्कि आसान काम को लाता है इसलिए मैंने सोचा कि मैं एक उदाहरण साझा करूंगा।

PHP 5 में, हमारे पास पहले से ही एक टर्नरी ऑपरेटर है, जो एक मान का परीक्षण करता है, और उसके बाद दूसरा तत्व देता है यदि यह सत्य लौटाता है और तीसरा यदि यह नहीं करता है:

echo $count ? $count : 10; // outputs 10

इसके लिए एक शॉर्टेंड भी है जो आपको दूसरे तत्व को छोड़ने की इजाजत देता है यदि यह पहले जैसा ही है: echo $ count?: 10; // 10 आउटपुट भी

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

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

यह निर्माण उपयोगकर्ता इनपुट या मौजूदा कॉन्फ़िगरेशन से आने वाले एक या अधिक मानों को प्राथमिकता देने के लिए उपयोगी है, और उस कॉन्फ़िगरेशन में अनुपलब्ध होने पर सुरक्षित रूप से दिए गए डिफ़ॉल्ट पर वापस गिरना उपयोगी है। यह एक छोटी सी सुविधा है लेकिन यह एक है जो मुझे पता है कि जैसे ही मेरे एप्लिकेशन PHP 7 में अपग्रेड हो जाएंगे।


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

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

-- कमी ऑपरेटर

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 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;
});

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

  1. उपयोग की mysql_real_escape_string(), में एक पूर्व निर्धारित समारोह है जो PHP : है, और इस कोड में निम्न वर्णों को बैकस्लैश जोड़ने \x00, \n, \r, \, ', "और \x1a। एसक्यूएल इंजेक्शन के मौके को कम करने के लिए इनपुट मानों को पैरामीटर के रूप में पास करें।
  2. पीडीओ का उपयोग करने का सबसे उन्नत तरीका है।

उम्मीद है इससे आपको मदद मिलेगी।

निम्नलिखित क्वेरी पर विचार करें:

$iId = mysql_real_escape_string("1 OR 1=1"); $sSql = "SELECT * FROM table WHERE id = $iId";

mysql_real_escape_string () यहां सुरक्षा नहीं करेगा। यदि आप अपनी क्वेरी के अंदर अपने चर के चारों ओर सिंगल कोट्स ('') का उपयोग करते हैं तो यह आपके खिलाफ सुरक्षा करता है। इसके लिए यहां एक समाधान दिया गया है:

$iId = (int) mysql_real_escape_string("1 OR 1=1"); $sSql = "SELECT * FROM table WHERE id = $iId";

इस question बारे में कुछ अच्छे जवाब हैं।

मेरा सुझाव है, पीडीओ का उपयोग करना सबसे अच्छा विकल्प है।

संपादित करें:

mysql_real_escape_string()PHP 5.5.0 के रूप में बहिष्कृत है। या तो mysqli या पीडीओ का प्रयोग करें।

Mysql_real_escape_string () का विकल्प है

string mysqli_real_escape_string ( mysqli $link , string $escapestr )

उदाहरण:

$iId = $mysqli->real_escape_string("1 OR 1=1");
$mysqli->query("SELECT * FROM table WHERE id = $iId");




php operators symbols php-5.3