উত্তর:
==
এবং মধ্যে পার্থক্য===
আলগাভাবে ==
সমান অপারেটর এবং কঠোর ===
অভিন্ন অপারেটরের মধ্যে পার্থক্যটি ম্যানুয়ালটিতে ঠিক ব্যাখ্যা করা হয়েছে :
তুলনা অপারেটর
┌──────────┬───────────┬────────────────────────── ─────────────────────────────────┐ │ উদাহরণ │ নাম │ ফলাফল │ │ ├──────────┼───────────┼────────────────────────── ─────────────────────────────────┤ টাইপ জাগলিংয়ের পরে $ a সমান │ সত্য হলে is $ a == $ b │ সমান │ সত্য। │ $ $ A === $ b │ আইডেন্টিকাল │ TRUE যদি $ a সমান হয় $ b, এবং সেগুলি একই ধরণের। │ └──────────┴───────────┴────────────────────────── ─────────────────────────────────┘
==
সমান তুলনাআপনি যদি ==
অপারেটর, বা অন্য কোনও তুলনামূলক অপারেটর ব্যবহার করছেন যা যেমন স্বল্প তুলনা ব্যবহার করে !=
, <>
বা ==
, আপনাকে কী, কোথায় এবং কেন কিছু চলছে তা বুঝতে কী রূপান্তরিত হয় তা দেখতে সর্বদা প্রসঙ্গটি দেখতে হবে।
রেফারেন্স এবং উদাহরণ হিসাবে আপনি ম্যানুয়ালটিতে তুলনা টেবিলটি দেখতে পারেন :
আলগা তুলনা
==
┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ │ UE সত্য │ মিথ্যা │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ নুল │ অ্যারে () ph "পিএইচপি" │ "" │ ├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤ │ সত্য │ সত্য │ মিথ্যা UE সত্য │ মিথ্যা │ সত্য │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ সত্য │ মিথ্যা │ সত্য │ 1 │ সত্য │ মিথ্যা UE সত্য │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ 0 │ মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ সত্য │ │ -1 │ সত্য │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা 1 "1" │ সত্য │ মিথ্যা UE সত্য │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা 0 "0" AL মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা -"-1" │ সত্য │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ নকল AL মিথ্যা UE সত্য │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ সত্য │ মিথ্যা │ সত্য Ray অ্যারে () AL মিথ্যা │ সত্য │ মিথ্যা AL মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ সত্য │ মিথ্যা │ মিথ্যা Ph "php" │ সত্য │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা AL "" "│ মিথ্যা │ সত্য │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ সত্য └─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘
===
অভিন্ন তুলনাআপনি যদি ===
অপারেটর, বা অন্য কোনও তুলনামূলক অপারেটর ব্যবহার করছেন যা যেমন !==
বা এর মতো কঠোর তুলনা ব্যবহার করে ===
, তবে আপনি সর্বদা নিশ্চিত হতে পারেন যে প্রকারগুলি যাদুকরীভাবে পরিবর্তিত হবে না , কারণ কোনও রূপান্তর চলবে না। সুতরাং কঠোর তুলনার সাথে প্রকার এবং মান একই হতে হবে, কেবল মান নয়।
রেফারেন্স এবং উদাহরণ হিসাবে আপনি ম্যানুয়ালটিতে তুলনা টেবিলটি দেখতে পারেন :
এর সাথে কড়া তুলনা
===
┌─────────┬───────┬───────┬───────┬───────┬─────── ┬───────┬───────┬───────┬───────┬─────────┬─────── ┬───────┐ │ UE সত্য │ মিথ্যা │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ নুল │ অ্যারে () ph "পিএইচপি" │ "" │ ├─────────┼───────┼───────┼───────┼───────┼─────── ┼───────┼───────┼───────┼───────┼─────────┼─────── ┼───────┤ │ সত্য │ সত্য │ মিথ্যা AL মিথ্যা AL মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ 1 │ মিথ্যা │ মিথ্যা UE সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ 0 │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ -1 │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা 1 "1" AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা 0 "0" AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা -"-1" AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ নাল │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা │ মিথ্যা Ray অ্যারে () AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা │ মিথ্যা Ph "php" AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ মিথ্যা "" "│ মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা AL মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ মিথ্যা │ সত্য │ └─────────┴───────┴───────┴───────┴───────┴─────── ┴───────┴───────┴───────┴───────┴─────────┴─────── ┴───────┘
true
বা false
। Castালাই করা সহজ। অন্যান্য সমস্ত মানগুলি যদিও সমস্ত ব্যবহারিক উদ্দেশ্যে, কার্যত সীমাহীন সংমিশ্রণে রয়েছে। হয় "five" == 5
? array(0) == 0
? array(0,0,0) == 0
? 0.0000000000000000000000000000000000000000000000000001 == array()
?
false
জাভাস্ক্রিপ্টে বিভিন্ন অ্যারের জন্য দেয় তবে true
পিএইচপি-র জন্য যতক্ষণ না তাদের মান সমান হয় ।
"000" != "00"
, "000" == null
, "000" == false
, "0x0" == false
, array() == 0
, false != null
, array() != null
, false == "0x0"
, false == "000"
। পিএইচপি, এটা বিপরীত আচরণ: "000" == "00"
, "000" != null
, "000" != false
, "0x0" != false
, array() != 0
, false == null
, array() == null
, false != "0x0"
, false != "000"
।
অপারেটর == পৃথক হলে দুটি ভিন্ন ধরণের মধ্যে কাস্ট করে, যখন === অপারেটর একটি 'টাইপসেফের তুলনা' সম্পাদন করে। এর অর্থ হ'ল উভয় অপারেন্ডের একই ধরণের এবং একই মান একই হলে এটি সত্য হবে।
উদাহরণ:
1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value
সতর্কতা : সমমানের সদস্যদের সাথে একই শ্রেণির দুটি উদাহরণ ===
অপারেটরের সাথে মেলে না । উদাহরণ:
$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
একটি ছবি হাজার শব্দের সমান:
==
সমতার সমতা চার্ট:===
সমতা চার্ট:এই চিত্রগুলি তৈরি করার জন্য উত্স কোড:
https://github.com/sentientmachine/php_equality_charts
যারা তাদের বিচক্ষণতা বজায় রাখতে চান, তারা আর পড়বেন না কারণ এগুলির কোনওোটাই কোনও অর্থ বোধ করবে না, কেবল এই কথাটি বাদে যে পিএইচপি-এর উন্মাদ-ফ্র্যাক্টালটি এভাবেই তৈরি করা হয়েছিল।
NAN != NAN
কিন্তু NAN == true
। ==
বামে একটি সংখ্যা হলে বাম এবং ডান ক্রিয়াকলাপগুলিকে সংখ্যায় রূপান্তর করবে। তাই 123 == "123foo"
, কিন্তু"123" != "123foo"
উদ্ধৃতিতে একটি হেক্স স্ট্রিং মাঝেমধ্যে একটি ফ্লোট হয় এবং আপনার ইচ্ছার বিরুদ্ধে ভাসতে অবাক করে দেওয়া হবে, যার ফলে রানটাইম ত্রুটি হয়।
==
নয় সকর্মক কারণ "0"== 0
, এবং 0 == ""
কিন্তু"0" != ""
==
।"6" == " 6"
, "4.2" == "4.20"
এবং "133" == "0133"
কিন্তু 133 != 0133
। কিন্তু "0x10" == "16"
এবং "1e3" == "1000"
অষ্টালে আশ্চর্য স্ট্রিং রূপান্তরটি প্রকাশ করা আপনার নির্দেশ বা সম্মতি উভয়ই ঘটবে, একটি রানটাইম ত্রুটি সৃষ্টি করে।
False == 0
, ""
, []
এবং "0"
।
যখন সংখ্যাগুলি যথেষ্ট বড় হয় তারা == অনন্ত।
একটি নতুন শ্রেণি হল == থেকে 1।
আপনি যদি পিএইচপি ব্যবহার করছেন তবে আপনি দ্বিগুণ সমান অপারেটর ব্যবহার করবেন না কারণ আপনি যদি ট্রিপল সমান ব্যবহার করেন তবে চিন্তার একমাত্র প্রান্তের মামলাগুলি ন্যান এবং সংখ্যাগুলি অনন্তের এত কাছে যে এগুলি অনন্তকে ফেলে দেওয়া হয়। দ্বিগুণ সমান সমেত, যে কোনও কিছু আশ্চর্য ==
হতে পারে বা, বা আপনার ইচ্ছার বিরুদ্ধে এবং !=
এমন কিছুতে বিস্মিত হতে পারে যা এটি অবশ্যই সমান হওয়া উচিত।
আপনি যে কোনও জায়গায় ==
পিএইচপি ব্যবহার করেন না কেন এটি একটি খারাপ কোডের গন্ধ কারণ এতে থাকা 85 টি বাগগুলি ব্রাউনিয়ান মোশনের মাধ্যমে কয়েক মিলিয়ন প্রোগ্রামার প্রোগ্রামিং দ্বারা নকশাকৃত মনে হয় ing
জাভাস্ক্রিপ্ট সম্পর্কিত:
=== অপারেটর == অপারেটরের মতোই একইরূপে কাজ করে তবে এর অপারেশনগুলিতে কেবল একই মান নয়, একই ডেটা ধরণের প্রয়োজন।
উদাহরণস্বরূপ, নীচের নমুনাটি 'x এবং y সমান' প্রদর্শিত হবে, তবে 'x এবং y অভিন্ন নয়'।
var x = 4;
var y = '4';
if (x == y) {
alert('x and y are equal');
}
if (x === y) {
alert('x and y are identical');
}
বস্তুর তুলনা সম্পর্কিত অন্যান্য উত্তরগুলির সাথে যুক্ত:
== বস্তুর নাম এবং তাদের মানগুলি ব্যবহার করে বস্তুর তুলনা করে। দুটি বস্তু যদি একই ধরণের হয় এবং একই সদস্য মান হয় তবে $a == $b
সত্য ফলন হয়।
=== বস্তুর অভ্যন্তরীণ অবজেক্ট আইডি তুলনা করে। এমনকি সদস্যরা সমান হলেও $a !== $b
তারা ঠিক একই জিনিস না হলে।
class TestClassA {
public $a;
}
class TestClassB {
public $a;
}
$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();
$a1->a = 10;
$a2->a = 10;
$b->a = 10;
$a1 == $a1;
$a1 == $a2; // Same members
$a1 != $b; // Different classes
$a1 === $a1;
$a1 !== $a2; // Not the same object
সহজ কথায়:
== সমতুল্য হলে (কেবলমাত্র মূল্য) পরীক্ষা করে
=== সমান (মান ও & প্রকার)
সমান বনাম একই: অ্যানালজি কিনা তা পরীক্ষা করে
1 + 1 = 2 + 0 (সমতুল্য)
পিএইচপি-তে 1 + 1 = 1 + 1 (একই)
:
সত্য == 1 (সত্য - মান সমতুল্য)
সত্য === 1 (মিথ্যা - মান ও প্রকারের ক্ষেত্রে এক নয়)
এটি সব তথ্য ধরণের সম্পর্কে। BOOL
উদাহরণস্বরূপ একটি (সত্য বা মিথ্যা) নিন :
true
এছাড়াও সমান 1
এবং
false
সমান0
==
ডেটা প্রকার যখন তুলনা যত্ন সম্পর্কে না: তাই আপনি যদি একটি পরিবর্তনশীল যে 1 (এছাড়াও হতে পারে যা ছিল true
):
$var=1;
এবং তারপরে এর সাথে তুলনা করুন ==
:
if ($var == true)
{
echo"var is true";
}
কিন্তু $var
আসলে সমান হয় না true
, তাই না? এটির 1
পরিবর্তে এর মান মান রয়েছে যা ঘুরে ফিরে সত্যের সমান হয়।
সঙ্গে ===
, ধরনের তথ্য করতে পরীক্ষিত নিশ্চিত দুটি ভেরিয়েবল / বস্তু / যাই হোক না কেন একই ধরনের ব্যবহার করছেন।
তাই আমি যদি
if ($var === true)
{
echo "var is true";
}
এই অবস্থাটি সত্য হবে না, কারণ $var !== true
এটি কেবলমাত্র == true
(যদি আপনি জানেন তবে আমার অর্থ কী)।
আপনি এই প্রয়োজন হবে কেন?
সরল - আসুন পিএইচপি-র অন্যতম কার্যকারিতা দেখুন array_search()
:
array_search()
ফাংশন কেবল একটি অ্যারের মধ্যে একটি মান, এবং আয় উপাদান মান পাওয়া যায়নি মূল অনুসন্ধান করা হয়। মান অ্যারের মধ্যে খুঁজে পাওয়া যাবে না, এটা ফেরৎ মিথ্যা । তবে, আপনি যদি অ্যারের প্রথম উপাদানটিতে (যার অ্যারের কী থাকে ) array_search()
সংরক্ষণ করা কোনও মান নিয়ে কাজ করেন তবে .... ফাংশনটি 0 ফিরে আসবে ... যা মিথ্যের সমান ...0
array_search()
সুতরাং আপনি যদি:
$arr = array("name");
if (array_search("name", $arr) == false)
{
// This would return 0 (the key of the element the val was found
// in), but because we're using ==, we'll think the function
// actually returned false...when it didn't.
}
সুতরাং, আপনি কি দেখতে পান যে এটি এখন কীভাবে সমস্যা হতে পারে?
== false
কোনও ফাংশন মিথ্যা প্রত্যাবর্তন করে কিনা তা পরীক্ষা করার সময় বেশিরভাগ লোক ব্যবহার করেন না । পরিবর্তে, তারা ব্যবহার করুন !
। তবে বাস্তবে, এটি ব্যবহারের মতোই হ'ল ==false
, যদি আপনি এটি করেন:
$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)
সুতরাং এই জাতীয় জিনিসগুলির জন্য, আপনি ===
পরিবর্তে ব্যবহার করবেন , যাতে ডেটা টাইপ পরীক্ষা করা হয়।
একটি উদাহরণ হ'ল একটি ডাটাবেস বৈশিষ্ট্য নਾਲ বা "" হতে পারে:
$attributeFromArray = "";
if ($attributeFromArray == ""){} //true
if ($attributeFromArray === ""){} //true
if ($attributeFromArray == null){} //true
if ($attributeFromArray === null){} //false
$attributeFromArray = null;
if ($attributeFromArray == ""){} //true
if ($attributeFromArray === ""){} //false
if ($attributeFromArray == null){} //true
if ($attributeFromArray === null){} //true
পিএইচপি == হ'ল একটি তুলনামূলক অপারেটর যা ভেরিয়েবলের মান তুলনা করে। তবে === মান এবং ডেটা ধরণের তুলনা করে।
উদাহরণ স্বরূপ,
<?php
$var1 = 10;
$var2 = '10';
if($var1 == $var2) {
echo 'Variables are equal';
} else {
echo 'Variables are not equal';
}
?>
এক্ষেত্রে আউটপুটটি 'ভেরিয়েবলগুলি সমান' হবে, যদিও তাদের ডেটা ধরণগুলি আলাদা।
তবে আমরা যদি == এর পরিবর্তে === ব্যবহার করি তবে আউটপুট হবে 'ভেরিয়েবল সমান নয়'। পিএইচপি প্রথমে ভেরিয়েবলের মান এবং তারপরে ডেটা টাইপের সাথে তুলনা করে। এখানে মানগুলি একই, তবে তথ্যের ধরণগুলি পৃথক।
প্রদত্ত x = 5
1) অপারেটর: == "সমান" to x == 8
মিথ্যা
2) অপারেটর: === "হুবহু সমান" (মান এবং প্রকার) x === 5
সত্য, x === "5"
মিথ্যা
$a = 5; // 5 as an integer
var_dump($a == 5); // compare value; return true
var_dump($a == '5'); // compare value (ignore type); return true
var_dump($a === 5); // compare type/value (integer vs. integer); return true
var_dump($a === '5'); // compare type/value (integer vs. string); return false
যদিও সাবধান। এখানে একটি কুখ্যাত সমস্যা আছে।
// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
// code...
}
বনাম
// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
// code...
}
সংক্ষেপে, === অন্যান্য প্রোগ্রামিং ভাষায় == একইভাবে কাজ করে।
পিএইচপি আপনাকে এমন তুলনা করতে দেয় যা সত্যিকার অর্থে বোঝায় না। উদাহরণ:
$y = "wauv";
$x = false;
if ($x == $y)
...
যদিও এটি কিছু আকর্ষণীয় "শর্টকাটগুলি" মঞ্জুর করে এমন কোনও ফাংশন যা কিছু না করে (যেমন একটি সংখ্যার পরিবর্তে "ত্রুটি" দেয়) ফিরে না আসে সেজন্য আপনাকে সচেতন করা উচিত এবং কী ঘটেছে তা ভেবে আপনি অবাক হয়ে যাবেন।
পিএইচপি-তে, == মানগুলির তুলনা করে এবং প্রয়োজনে ধরণের রূপান্তর সম্পাদন করে (উদাহরণস্বরূপ, "12343sdfjskfjds" স্ট্রিং একটি পূর্ণসংখ্যার তুলনায় "12343" হয়ে যাবে)। === মান এবং টাইপটির সাথে তুলনা করবে এবং প্রকারটি একই রকম না হলে মিথ্যা ফিরবে।
আপনি যদি পিএইচপি ম্যানুয়ালটিতে দেখেন, আপনি দেখতে পাবেন যে ফাংশন ব্যর্থ হলে প্রচুর ফাংশনগুলি "মিথ্যা" প্রত্যাবর্তন করে তবে সফল পরিস্থিতিতে তারা 0 এ ফিরে আসতে পারে, এজন্য তারা "যদি (ফাংশন ()!" করার পরামর্শ দেয়! মিথ্যা) "ভুল এড়াতে।
উদাহরণ কয়েকটি
var_dump(5 == 5); // True
var_dump(5 == "5"); // True because == checks only same value not type
var_dump(5 === 5); // True
var_dump(5 === "5"); // False because value are same but data type are different.
পুনশ্চ
== শুধুমাত্র মানটির সাথে তুলনা করে, এটি ডেটা ধরণের সম্পর্কে বিরক্ত করবে না
বনাম
=== মান এবং ডেটা ধরণের তুলনা করে
আপনি কোনও ফাংশন বা ভেরিয়েবল মিথ্যা কিনা তা পরীক্ষা করার জন্য === ব্যবহার করবেন কেবল মিথ্যা (শূন্য বা একটি ফাঁকা স্ট্রিং) এর সাথে সমীকরণের চেয়ে।
$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
echo $needle . ' was not found in ' . $haystack;
} else {
echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}
এই ক্ষেত্রে স্ট্রপোজগুলি 0 ফেরত আসবে যা পরীক্ষায় মিথ্যা হিসাবে সমান হবে
if ($pos == false)
অথবা
if (!$pos)
যা আপনি এখানে চান না।
একে অপরের উপর কখন ব্যবহার করবেন, উদাহরণস্বরূপ fwrite()
পিএইচপি-তে ফাংশনটি ধরুন।
এই ফাংশনটি একটি ফাইল স্ট্রিমে লিখিত সামগ্রী দেয়। পিএইচপি অনুসারে, " fwrite()
লিখিত বাইটের সংখ্যা, বা ভুলতে মিথ্যা ফিরিয়ে দেয়"। যদি আপনি পরীক্ষা করতে চান যে ফাংশন কলটি সফল হয়েছিল, এই পদ্ধতিটি ত্রুটিযুক্ত:
if (!fwrite(stuff))
{
log('error!');
}
এটি শূন্য ফিরে আসতে পারে (এবং এটি সফল হিসাবে বিবেচিত হয়) এবং আপনার অবস্থাটি এখনও ট্রিগার হয়ে যায়। সঠিক উপায়টি হ'ল:
if (fwrite(stuff) === FALSE)
{
log('error!');
}
পিএইচপি হ'ল স্বল্প টাইপিত একটি ভাষা। ডাবল ইক্যুয়াল অপারেটর ব্যবহার করে একটি ভেরিয়েবলের checkingিলে checkingালা পরীক্ষার অনুমতি দেয়।
আলগাভাবে একটি মান পরীক্ষা করা কিছু অনুরূপ, তবে সমান নয়, মানগুলিকে সমান করার সুযোগ দেয়:
এই সমস্ত মানগুলি দ্বিগুণ সমান অপারেটরটি ব্যবহার করে সমান হিসাবে সমান হবে।
চলকগুলির একটি প্রকার এবং মান থাকে have
আপনি যখন এই ভেরিয়েবলগুলি ব্যবহার করেন (পিএইচপি তে), কখনও কখনও আপনার ভাল ধরণের থাকে না। উদাহরণস্বরূপ, যদি আপনি করেন
if ($var == 1) {... do something ...}
পিএইচপিকে ("কাস্ট করতে") $ var পূর্ণসংখ্যায় রূপান্তর করতে হবে। এই ক্ষেত্রে, "$ var == 1" সত্য কারণ কোনও খালি খালি স্ট্রিংটি 1 তে কাস্ট করা থাকে।
=== ব্যবহার করার সময়, আপনি পরীক্ষা করতে পারেন যে মান এবং টাইপ সমান, তাই "$ var === 1" মিথ্যা।
এটি দরকারী, উদাহরণস্বরূপ, যখন আপনার কোনও ফাংশন থাকে যা মিথ্যা (ত্রুটিতে) এবং 0 (ফলাফল) ফিরে আসতে পারে:
if(myFunction() == false) { ... error on myFunction ... }
এই কোড যেমন ভুল myFunction()
0 টি প্রত্যাবর্তন করে, এটি মিথ্যা হিসাবে কাস্ট করা হয় এবং আপনার মনে হয় কোনও ত্রুটি রয়েছে। সঠিক কোডটি হ'ল:
if(myFunction() === false) { ... error on myFunction ... }
কারণ পরীক্ষাটি হ'ল রিটার্ন মানটি "বুলিয়ান এবং মিথ্যা" এবং "মিথ্যাতে কাস্ট করা যায়"।
===
অপারেটর তুলনা অনুমিত হয় সঠিক বিষয়বস্তু সমতা যখন==
অপারেটর শব্দার্থিক সমতা তুলনা করবে। বিশেষত এটি সংখ্যাগুলিতে স্ট্রিংকে বাধ্য করবে।
সমতা একটি বিস্তৃত বিষয়। সমতা নিয়ে উইকিপিডিয়া নিবন্ধটি দেখুন ।
<?php
/**
* Comparison of two PHP objects == ===
* Checks for
* 1. References yes yes
* 2. Instances with matching attributes and its values yes no
* 3. Instances with different attributes yes no
**/
// There is no need to worry about comparing visibility of property or
// method, because it will be the same whenever an object instance is
// created, however visibility of an object can be modified during run
// time using ReflectionClass()
// http://php.net/manual/en/reflectionproperty.setaccessible.php
//
class Foo
{
public $foobar = 1;
public function createNewProperty($name, $value)
{
$this->{$name} = $value;
}
}
class Bar
{
}
// 1. Object handles or references
// Is an object a reference to itself or a clone or totally a different object?
//
// == true Name of two objects are same, for example, Foo() and Foo()
// == false Name of two objects are different, for example, Foo() and Bar()
// === true ID of two objects are same, for example, 1 and 1
// === false ID of two objects are different, for example, 1 and 2
echo "1. Object handles or references (both == and ===) <br />";
$bar = new Foo(); // New object Foo() created
$bar2 = new Foo(); // New object Foo() created
$baz = clone $bar; // Object Foo() cloned
$qux = $bar; // Object Foo() referenced
$norf = new Bar(); // New object Bar() created
echo "bar";
var_dump($bar);
echo "baz";
var_dump($baz);
echo "qux";
var_dump($qux);
echo "bar2";
var_dump($bar2);
echo "norf";
var_dump($norf);
// Clone: == true and === false
echo '$bar == $bar2';
var_dump($bar == $bar2); // true
echo '$bar === $bar2';
var_dump($bar === $bar2); // false
echo '$bar == $baz';
var_dump($bar == $baz); // true
echo '$bar === $baz';
var_dump($bar === $baz); // false
// Object reference: == true and === true
echo '$bar == $qux';
var_dump($bar == $qux); // true
echo '$bar === $qux';
var_dump($bar === $qux); // true
// Two different objects: == false and === false
echo '$bar == $norf';
var_dump($bar == $norf); // false
echo '$bar === $norf';
var_dump($bar === $norf); // false
// 2. Instances with matching attributes and its values (only ==).
// What happens when objects (even in cloned object) have same
// attributes but varying values?
// $foobar value is different
echo "2. Instances with matching attributes and its values (only ==) <br />";
$baz->foobar = 2;
echo '$foobar' . " value is different <br />";
echo '$bar->foobar = ' . $bar->foobar . "<br />";
echo '$baz->foobar = ' . $baz->foobar . "<br />";
echo '$bar == $baz';
var_dump($bar == $baz); // false
// $foobar's value is the same again
$baz->foobar = 1;
echo '$foobar' . " value is the same again <br />";
echo '$bar->foobar is ' . $bar->foobar . "<br />";
echo '$baz->foobar is ' . $baz->foobar . "<br />";
echo '$bar == $baz';
var_dump($bar == $baz); // true
// Changing values of properties in $qux object will change the property
// value of $bar and evaluates true always, because $qux = &$bar.
$qux->foobar = 2;
echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
echo '$qux->foobar is ' . $qux->foobar . "<br />";
echo '$bar->foobar is ' . $bar->foobar . "<br />";
echo '$bar == $qux';
var_dump($bar == $qux); // true
// 3. Instances with different attributes (only ==)
// What happens when objects have different attributes even though
// one of the attributes has same value?
echo "3. Instances with different attributes (only ==) <br />";
// Dynamically create a property with the name in $name and value
// in $value for baz object
$name = 'newproperty';
$value = null;
$baz->createNewProperty($name, $value);
echo '$baz->newproperty is ' . $baz->{$name};
var_dump($baz);
$baz->foobar = 2;
echo '$foobar' . " value is same again <br />";
echo '$bar->foobar is ' . $bar->foobar . "<br />";
echo '$baz->foobar is ' . $baz->foobar . "<br />";
echo '$bar == $baz';
var_dump($bar == $baz); // false
var_dump($bar);
var_dump($baz);
?>
এখনও পর্যন্ত সমস্ত উত্তর === নিয়ে একটি বিপজ্জনক সমস্যা উপেক্ষা করে। এটি পাস করার ক্ষেত্রে লক্ষ্য করা গেছে, তবে জোর দেওয়া হয়নি, যে পূর্ণসংখ্যা এবং ডাবল বিভিন্ন ধরণের, তাই নিম্নলিখিত কোডটি:
$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n == $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );
দেয়:
equal
not equal
মনে রাখবেন এটি কোনও "রাউন্ডিং ত্রুটির" ঘটনা নয়। দুটি সংখ্যা শেষ বিটের ঠিক সমান, তবে তাদের বিভিন্ন প্রকার রয়েছে।
এটি একটি বাজে সমস্যা কারণ === ব্যবহার করে একটি প্রোগ্রাম বছরের পর বছর ধরে সুখীভাবে চলতে পারে যদি সমস্ত সংখ্যা যথেষ্ট পরিমাণে কম থাকে (যেখানে "চালিত আপনি যে হার্ডওয়্যার এবং ওএসের উপর" "যথেষ্ট" ছোট "নির্ভর করে)। যাইহোক, যদি সুযোগক্রমে কোনও পূর্ণসংখ্যার দ্বিগুণ রূপান্তরিত হওয়ার মতো যথেষ্ট পরিমাণে ঘটে থাকে তবে তার ধরণটি "চিরতরে" পরিবর্তিত হয় যদিও পরবর্তী ক্রিয়াকলাপ বা অনেকগুলি ক্রিয়াকলাপ এটিকে আবার একটি ছোট পূর্ণসংখ্যার কাছে ফিরিয়ে আনতে পারে। এবং, এটি আরও খারাপ হয়। এটি ছড়িয়ে যেতে পারে - ডাবল-নেস ইনফেকশনটি এটি স্পর্শ করে যে কোনও কিছুতেও পাশ করা যেতে পারে, একসাথে একটি গণনা।
বাস্তব বিশ্বে, সম্ভবত এমন প্রোগ্রামগুলিতে সমস্যা হতে পারে যা 2038 সালের পরে তারিখগুলি পরিচালনা করে। এই মুহুর্তে, ইউনিক্স টাইমস্ট্যাম্পগুলি (1970-01-01 00:00:00 ইউটিসি থেকে সেকেন্ডের সংখ্যা) এর জন্য 32-বিট-এর বেশি প্রয়োজন হবে, সুতরাং তাদের উপস্থাপনা "সিস্টেমে" কিছু সিস্টেমে দ্বিগুণ হবে। অতএব, আপনি যদি দু'বারের মধ্যে পার্থক্য গণনা করেন তবে আপনি সম্ভবত কয়েক সেকেন্ডের মধ্যে শেষ হতে পারেন, তবে দ্বিগুণ হিসাবে, যা 2017 সালে ঘটে পূর্ণসংখ্যার ফলাফলের চেয়ে বেশি।
আমি মনে করি এটি স্ট্রিং এবং সংখ্যার মধ্যে রূপান্তরগুলির চেয়ে অনেক খারাপ কারণ এটি সূক্ষ্ম। আমি স্ট্রিংটি কী এবং কোন সংখ্যাটি কী তা ট্র্যাক করা সহজ মনে করি তবে সংখ্যায় বিটের সংখ্যার উপর নজর রাখা আমার বাইরে।
সুতরাং, উপরের উত্তরে কয়েকটি সুন্দর সারণী রয়েছে তবে 1 (একটি পূর্ণসংখ্যা হিসাবে) এবং 1 (সূক্ষ্ম ডাবল) এবং 1.0 (সুস্পষ্ট ডাবল) এর মধ্যে কোনও পার্থক্য নেই। এছাড়াও, আপনাকে সর্বদা ব্যবহার করা উচিত === এবং কখনই == ব্যবহার করা উচিত না কারণ === কখনও কখনও ব্যর্থ হবে যেখানে == সঠিকভাবে কাজ করে। এছাড়াও, জাভাস্ক্রিপ্ট এই ক্ষেত্রে সমতুল্য নয় কারণ এর কেবলমাত্র একটি নম্বর প্রকার রয়েছে (অভ্যন্তরীণভাবে এর বিট-বুদ্ধিমান বিভিন্ন উপস্থাপনা থাকতে পারে, তবে এটি ===) এর জন্য সমস্যা সৃষ্টি করে না।
আমার পরামর্শ - না ব্যবহার। সত্যিই এই জগাখিচুড়িটি ঠিক করতে আপনার নিজের তুলনা ফাংশনটি লিখতে হবে।
তার মাঝে দুই পার্থক্য আছে ==
এবং===
পিএইচপি অ্যারে এবং অবজেক্টগুলির মধ্যে যা আমি মনে করি যে এখানে উল্লেখ করা হয়নি; বিভিন্ন কী কী এবং ধরণের দুটি অ্যারে।
যদি আপনার কী কী বাছাই সহ আরে থাকে এবং অন্য কী কীর বাছাই সহ অন্য অ্যারে থাকে তবে সেগুলি কঠোরভাবে পৃথক (অর্থাত্ ব্যবহার করে ===
)। যদি আপনি কোনও অ্যারের কী-বাছাই করেন এবং সারণি করা অ্যারেটিকে মূলটির সাথে তুলনা করার চেষ্টা করেন তবে এটি হতে পারে।
উদাহরণস্বরূপ, একটি খালি অ্যারে বিবেচনা করুন। প্রথমে, আমরা কোনও বিশেষ সাজানো ছাড়াই অ্যারেতে কিছু নতুন সূচকগুলি ঠেলে দেওয়ার চেষ্টা করি। একটি ভাল উদাহরণ কী হিসাবে স্ট্রিং সহ একটি অ্যারে হবে। এখন গভীর উদাহরণ:
// Define an array
$arr = [];
// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";
এখন, আমাদের কাছে একটি সাজানো-কী-অ্যারে নেই (যেমন, 'তিনি' 'আপনি' এর পরে এসেছিলেন)। একই অ্যারে বিবেচনা করুন, তবে আমরা এর কীগুলি বর্ণমালা অনুসারে বাছাই করেছি:
// Declare array
$alphabetArr = [];
// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";
টিপ : আপনি কী ব্যবহার করে একটি অ্যারে বাছাই করতে পারেন কেএসোর্ট () ফাংশনটি ।
এখন আপনার প্রথম অ্যারের থেকে আলাদা কী কী বাছাইয়ের সাথে আরও একটি অ্যারে রয়েছে। সুতরাং, আমরা তাদের তুলনা করতে যাচ্ছি:
$arr == $alphabetArr; // true
$arr === $alphabetArr; // false
দ্রষ্টব্য : এটি সুস্পষ্ট হতে পারে তবে কঠোর তুলনা ব্যবহার করে দুটি ভিন্ন অ্যারে তুলনা করলে ফলাফল সর্বদা ফলাফল হয় false
। তবে দুটি স্বেচ্ছাসেবী অ্যারে ব্যবহার করে নাও সমান হতে পারে ===
।
আপনি বলবেন: "এই পার্থক্য নগণ্য"। তারপরে আমি বলি এটি একটি পার্থক্য এবং বিবেচনা করা উচিত এবং যে কোনও সময় ঘটতে পারে। উপরে উল্লিখিত হিসাবে, একটি অ্যারে কী বাছাই করা তার একটি ভাল উদাহরণ।
মনে রাখবেন, দুটি পৃথক বস্তু কখনই কঠোর-সমান হয় না । এই উদাহরণগুলি সাহায্য করবে:
$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;
// Comparing
$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false
দ্রষ্টব্য : অন্য কোনও ভেরিয়েবলের জন্য কোনও বিষয় বরাদ্দকরণ একটি অনুলিপি তৈরি করে না - বরং এটি বস্তুর মতো একই মেমরি অবস্থানের জন্য একটি রেফারেন্স তৈরি করে। এখানে দেখুন ।
দ্রষ্টব্য : পিএইচপি 7 হিসাবে, বেনামে ক্লাস যুক্ত করা হয়েছিল। ফলাফলগুলি থেকে, উপরের পরীক্ষাগুলির মধ্যে new class {}
এবং এর new stdClass()
মধ্যে কোনও পার্থক্য নেই ।