PHP
प्रकार

पूर्णांकों

PHP में Integers बेस 2 (बाइनरी), बेस 8 (ऑक्टल), बेस 10 (दशमलव), या बेस 16 (हेक्साडेसिमल) में मूल रूप से निर्दिष्ट किए जा सकते हैं।

$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;

echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42

प्लेटफ़ॉर्म के आधार पर, इंटीजर 32 या 64 बिट लंबे होते हैं। निरंतर PHP_INT_SIZE बाइट्स में पूर्णांक आकार रखता है। PHP_INT_MAX और (PHP 7.0 के बाद से) PHP_INT_MIN भी उपलब्ध हैं।

printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);

पूर्णांक मूल्यों को स्वचालित रूप से फ्लोट्स, बूलियन और स्ट्रिंग्स से आवश्यकतानुसार बनाया जाता है। यदि एक स्पष्ट टाइपकास्ट की आवश्यकता है, तो इसे (int) या (integer) कास्ट के साथ किया जा सकता है:

$my_numeric_string = "123";
var_dump($my_numeric_string);
// Output: string(3) "123"
$my_integer = (int)$my_numeric_string;
var_dump($my_integer);
// Output: int(123)

पूर्णांक ओवरफ़्लो को फ़्लोट में रूपांतरित किया जाएगा:

$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)

PHP में कोई पूर्णांक विभाजन ऑपरेटर नहीं है, लेकिन इसे एक निहित कलाकारों का उपयोग करके सिम्युलेटेड किया जा सकता है, जो हमेशा फ्लोट-पार्ट को त्यागकर 'राउंड' करता है। PHP संस्करण 7 के रूप में, एक पूर्णांक विभाजन फ़ंक्शन जोड़ा गया था।

$not_an_integer = 25 / 4;
var_dump($not_an_integer);
// Output: float(6.25)
var_dump((int) (25 / 4)); // (see note below)
// Output: int(6)
var_dump(intdiv(25 / 4)); // as of PHP7
// Output: int(6)

(ध्यान दें कि अतिरिक्त कोष्ठक (25 / 4) 25/4 (25 / 4) की आवश्यकता है क्योंकि (int) डाली में विभाजन की तुलना में अधिक पूर्वता है)

स्ट्रिंग्स

PHP में एक स्ट्रिंग एकल-बाइट वर्णों की एक श्रृंखला है (अर्थात कोई मूल यूनिकोड समर्थन नहीं है) जिसे चार विवरणों में निर्दिष्ट किया जा सकता है:

एकल उद्धरण

चीजों को लगभग पूरी तरह से "जैसा है" प्रदर्शित करता है। चर और सबसे अधिक भागने वाले दृश्यों की व्याख्या नहीं की जाएगी। अपवाद यह है कि शाब्दिक एकल उद्धरण प्रदर्शित करने के लिए, कोई इसे बैक स्लैश से बच सकता है ', और बैक स्लैश प्रदर्शित करने के लिए, कोई इसे किसी अन्य बैकस्लैश \ _ से बच सकता है

$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n';
var_dump($my_string);

/*
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n"
*/

दोहरा उद्धरण

एकल-उद्धृत स्ट्रिंग के विपरीत, स्ट्रिंग में सरल चर नाम और एस्केप अनुक्रम का मूल्यांकन किया जाएगा। घुंघराले ब्रेसिज़ (अंतिम उदाहरण के रूप में) का उपयोग जटिल चर नामों को अलग करने के लिए किया जा सकता है।

$variable1 = "Testing!";
$variable2 = [ "Testing?", [ "Failure", "Success" ] ];
$my_string = "Variables and escape characters are parsed:\n\n";
$my_string .= "$variable1\n\n$variable2[0]\n\n";
$my_string .= "There are limits: $variable2[1][0]";
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}";
var_dump($my_string);

/*
string(98) "Variables and escape characters are parsed:

Testing!

Testing?

There are limits: Array[0]"

But we can get around them by wrapping the whole variable in braces: Success

*/

हियरडॉक

एक वंशानुगत स्ट्रिंग में, चर नाम और भागने के क्रम को दोहरे-उद्धृत स्ट्रिंग्स के समान तरीके से पार्स किया जाता है, हालांकि जटिल चर नामों के लिए ब्रेसिज़ उपलब्ध नहीं हैं। स्ट्रिंग की शुरुआत को <<< identifier द्वारा सीमांकित किया जाता है, और identifier द्वारा अंत, जहां identifier कोई वैध PHP नाम है। अंतिम पहचानकर्ता स्वयं द्वारा एक पंक्ति में दिखाई देना चाहिए। पहचानकर्ता के पहले या बाद में किसी भी व्हाट्सएप की अनुमति नहीं है, हालांकि पीएचपी की किसी भी रेखा की तरह, इसे भी अर्धविराम द्वारा समाप्त किया जाना चाहिए।

$variable1 = "Including text blocks is easier";
$my_string = <<< EOF
Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. $variable1; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends.
EOF;
var_dump($my_string);

/*
string(268) "Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. Including text blocks is easier; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends."
*/

Nowdoc

एक नॉरडॉक स्ट्रिंग, हेरेडोक के एकल-उद्धृत संस्करण की तरह है, हालांकि सबसे बुनियादी बच अनुक्रमों का मूल्यांकन भी नहीं किया जाता है। स्ट्रिंग की शुरुआत में पहचानकर्ता एकल उद्धरण में लपेटा जाता है।

$my_string = <<< 'EOF'
A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)
EOF;
var_dump($my_string);

/*
string(116) "A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)"
*/

बूलियन

बूलियन एक प्रकार है, जिसमें दो मान होते हैं, जिन्हें true या false माना जाता है।

यह कोड $foo के मूल्य को true और $bar को false रूप में सेट करता है:

$foo = true;
$bar = false;

true और false मामला संवेदनशील नहीं होता है, इसलिए TRUE और FALSE का भी उपयोग किया जा सकता है, यहां तक कि FaLsE भी संभव है। निचले मामले का उपयोग करना सबसे आम है और अधिकांश कोड शैली गाइडों में अनुशंसित है, जैसे PSR-2 ।

बूलियन का उपयोग इस तरह के बयानों में किया जा सकता है:

if ($foo) { //same as evaluating if($foo == true)
    echo "true";
}

इस तथ्य के कारण कि PHP कमजोर रूप से टाइप किया गया है, अगर ऊपर $foo true या false , तो यह स्वचालित रूप से एक बूलियन मूल्य के लिए मजबूर है।
निम्नलिखित मानों का परिणाम false :

• एक शून्य मान: 0 (पूर्णांक), 0.0 (फ्लोट), या '0' (स्ट्रिंग)
• एक खाली स्ट्रिंग '' या सरणी []
• null (एक अस्थिर चर की सामग्री, या एक चर को सौंपा)

कोई अन्य मान true में परिणाम करता true ।

इस ढीली तुलना से बचने के लिए, आप === का उपयोग करके मजबूत तुलना को लागू कर सकते हैं, जो मूल्य और प्रकार की तुलना करता है। विवरण के लिए टाइप तुलना देखें।

एक प्रकार को बूलियन में बदलने के लिए, आप (bool) या (boolean) प्रकार से पहले डाली का उपयोग कर सकते हैं।

var_dump((bool) "1"); //evaluates to true

या boolval फ़ंक्शन को कॉल करें:

var_dump( boolval("1") ); //evaluates to true

एक स्ट्रिंग में बूलियन रूपांतरण (ध्यान दें कि false पैदावार एक खाली स्ट्रिंग):

var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""

पूर्णांक में बूलियन रूपांतरण:

var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)

ध्यान दें कि विपरीत भी संभव है:

var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)

इसके अलावा सभी गैर-शून्य सही वापस आ जाएंगे:

var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)

फ्लोट

$float = 0.123;

ऐतिहासिक कारणों से "डबल" को फ्लोट के मामले में gettype() द्वारा लौटाया जाता है, न कि केवल "फ्लोट" के लिए

फ़्लोट्स फ़्लोटिंग पॉइंट नंबर होते हैं, जो सादे पूर्णांक की तुलना में अधिक आउटपुट परिशुद्धता की अनुमति देते हैं।

PHP और चर प्रकारों की ढीली कास्टिंग के कारण फ्लोट्स और पूर्णांक एक साथ उपयोग किए जा सकते हैं:

$sum = 3 + 0.14;

echo $sum; // 3.14

उदाहरण के लिए, php फ्लोट संख्या की तरह फ्लोट नंबर नहीं दिखाता है:

$var = 1;
echo ((float) $var); //returns 1 not 1.0

चेतावनी

फ़्लोटिंग पॉइंट सटीक

( PHP मैनुअल पेज से )

फ्लोटिंग पॉइंट नंबरों की सीमित परिशुद्धता होती है। हालाँकि यह सिस्टम पर निर्भर करता है, आमतौर पर 1.11e-16 के क्रम में गोलाई के कारण PHP अधिकतम सापेक्ष त्रुटि देता है। गैर-प्राथमिक अंकगणितीय ऑपरेशन बड़ी त्रुटियां दे सकते हैं, और कई कार्यों के जटिल होने पर त्रुटि प्रसार पर विचार किया जाना चाहिए।

इसके अतिरिक्त, परिमेय संख्याएं जो कि आधार 10 में फ्लोटिंग पॉइंट नंबरों के रूप में प्रतिनिधित्व करने योग्य हैं, जैसे 0.1 या 0.7, बेस 2 (बाइनरी) में फ्लोटिंग पॉइंट नंबरों के रूप में सटीक प्रतिनिधित्व नहीं है, जो आंतरिक रूप से उपयोग किया जाता है, कोई फर्क नहीं पड़ता है । इसलिए, वे परिशुद्धता के एक छोटे नुकसान के बिना अपने आंतरिक बाइनरी समकक्षों में परिवर्तित नहीं किए जा सकते हैं। इससे भ्रामक परिणाम हो सकते हैं: उदाहरण के लिए, फ़्लोर ((0.1 + 0.7) * 10) आमतौर पर अपेक्षित 8 के बजाय 7 वापस आ जाएगा, क्योंकि आंतरिक प्रतिनिधित्व 7.9999999999999111118 जैसा कुछ होगा ...।

इसलिए कभी भी फ़्लोटिंग संख्या परिणामों पर अंतिम अंक पर भरोसा न करें, और फ़्लोटिंग पॉइंट नंबरों की तुलना सीधे समानता के लिए न करें। यदि उच्च परिशुद्धता आवश्यक है, तो मनमाने ढंग से सटीक गणित कार्य और जीएमपी कार्य उपलब्ध हैं।

प्रतिदेय

कॉलबल्स कुछ भी होते हैं जिन्हें कॉलबैक कहा जा सकता है। जिन चीजों को "कॉलबैक" कहा जा सकता है, वे इस प्रकार हैं:

• अनाम कार्य

• मानक PHP फ़ंक्शंस (नोट: भाषा निर्माण नहीं )

• स्थैतिक वर्ग

• गैर-स्थिर कक्षाएं ( एक वैकल्पिक वाक्यविन्यास का उपयोग करके )

• विशिष्ट वस्तु / कक्षा के तरीके

• वस्तुएं, जब तक कि वस्तु किसी सरणी के कुंजी 0 में पाई जाती है

  एक सरणी तत्व के रूप में एक वस्तु को संदर्भित करने का उदाहरण:

 $obj = new MyClass();
 call_user_func([$obj, 'myCallbackMethod']);

कॉलबैक को PHP 5.4 के रूप में callable प्रकार संकेत द्वारा निरूपित किया जा सकता है।

$callable = function () {
    return 'value';
};

function call_something(callable $fn) {
    call_user_func($fn);
}

call_something($callable);

शून्य

PHP null कीवर्ड के साथ "कोई मूल्य नहीं" का प्रतिनिधित्व करता है। यह कुछ हद तक C- भाषा में null पॉइंटर और SQL में NULL वैल्यू के समान है।

अशक्त को चर सेट करना:

$nullvar = null; // directly

function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar

चर शून्य करने के लिए सेट किया गया था, तो जाँच:

if (is_null($nullvar)) { /* variable is null */ }

if ($nullvar === null) {  /* variable is null */ }

अशक्त बनाम अपरिष्कृत चर

यदि चर परिभाषित नहीं किया गया था या Notice: Undefined variable: nullvar नहीं था, तो अशक्त के खिलाफ कोई भी परीक्षण सफल होगा, लेकिन वे एक Notice: Undefined variable: nullvar भी उत्पन्न करेंगे Notice: Undefined variable: nullvar :

$nullvar = null;
unset($nullvar);
if ($nullvar === null) {  /* true but also a Notice is printed */ }
if (is_null($nullvar)) {  /* true but also a Notice is printed */ }

इसलिए अपरिभाषित मानों को isset साथ isset चाहिए:

if (!isset($nullvar)) {  /* variable is null or is not even defined */  }

तुलना टाइप करें

तुलना के दो प्रकार हैं: == साथ ढीली तुलना और === साथ सख्त तुलना । सख्त तुलना सुनिश्चित करती है कि ऑपरेटर के दोनों पक्षों के प्रकार और मूल्य समान हैं।

// Loose comparisons
var_dump(1 == 1); // true
var_dump(1 == "1"); // true
var_dump(1 == true); // true
var_dump(0 == false); // true

// Strict comparisons
var_dump(1 === 1); // true
var_dump(1 === "1"); // false
var_dump(1 === true); // false
var_dump(0 === false); // false

// Notable exception: NAN — it never is equal to anything
var_dump(NAN == NAN); // false
var_dump(NAN === NAN); // false

यदि आप प्रकार और मान का उपयोग करके मेल नहीं खाते हैं, तो आप मजबूत तुलना का उपयोग कर सकते हैं !== ।

एक विशिष्ट उदाहरण जहां == ऑपरेटर पर्याप्त नहीं है, ऐसे फ़ंक्शन हैं जो विभिन्न प्रकारों को लौटा सकते हैं, जैसे कि strpos , जो searchword पर नहीं मिलता है और false वापस मिलता है, और मैच की स्थिति ( int ) अन्यथा:

if(strpos('text', 'searchword') == false)
  // strpos returns false, so == comparison works as expected here, BUT:
if(strpos('text bla', 'text') == false)
  // strpos returns 0 (found match at position 0) and 0==false is true.
  // This is probably not what you expect!
if(strpos('text','text') === false)
  // strpos returns 0, and 0===false is false, so this works as expected.

कास्टिंग टाइप करें

PHP आमतौर पर आपके द्वारा उपयोग किए जाने वाले संदर्भ से उपयोग किए जाने वाले डेटा प्रकार का सही अनुमान लगाएगा, हालांकि कभी-कभी यह मैन्युअल रूप से एक प्रकार को लागू करने के लिए उपयोगी होता है। यह कोष्ठक में आवश्यक प्रकार के नाम के साथ घोषणा को उपसर्ग करके पूरा किया जा सकता है:

$bool = true;
var_dump($bool); // bool(true)

$int = (int) true;
var_dump($int); // int(1)

$string = (string) true;
var_dump($string); // string(1) "1"
$string = (string) false;
var_dump($string); // string(0) ""

$float = (float) true;
var_dump($float); // float(1)

$array = ['x' => 'y'];
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" } 

$object = new stdClass();
$object->x = 'y';
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" }

$string = "asdf";
var_dump((unset)$string); // NULL

लेकिन ध्यान रखें: सभी प्रकार के कास्ट काम नहीं करते हैं जैसे कि कोई उम्मीद कर सकता है:

// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647)
// an integer value bigger than PHP_INT_MAX is automatically converted to float:
var_dump(       999888777666 ); // float(999888777666)
// forcing to (int) gives overflow:
var_dump((int)  999888777666 ); // int(-838602302)
// but in a string it just returns PHP_INT_MAX
var_dump((int) "999888777666"); // int(2147483647)

var_dump((bool) []);      // bool(false) (empty array)
var_dump((bool) [false]); // bool(true)  (non-empty array)

साधन

एक संसाधन एक विशेष प्रकार का चर है जो एक बाहरी संसाधन, जैसे कि फ़ाइल, सॉकेट, स्ट्रीम, दस्तावेज़ या कनेक्शन को संदर्भित करता है।

$file = fopen('/etc/passwd', 'r');

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

विभिन्न (उप-) प्रकार के संसाधन हैं। आप get_resource_type() का उपयोग करके संसाधन प्रकार की जांच कर सकते हैं:

$file = fopen('/etc/passwd', 'r');
echo get_resource_type($file);
#Out: stream

$sock = fsockopen('www.google.com', 80);
echo get_resource_type($sock);
#Out: stream

आप संसाधन प्रकार में निर्मित की एक पूरी सूची पा सकते हैं यहाँ ।

जुगलबंदी टाइप करें

PHP एक कमजोर टाइप की भाषा है। इसके लिए डेटा प्रकारों की स्पष्ट घोषणा की आवश्यकता नहीं है। जिस संदर्भ में चर का उपयोग किया जाता है वह उसके डेटा प्रकार को निर्धारित करता है; रूपांतरण स्वचालित रूप से किया जाता है:

$a = "2";             // string 
$a = $a + 2;          // integer (4) 
$a = $a + 0.5;        // float (4.5)
$a = 1 + "2 oranges"; // integer (3)