Theory
સરવાળામાં ભળી ગયેલો string
Event portal form માંથી બેઠકોની સંખ્યા વાંચે છે. Form નો data હંમેશા STRING તરીકે જ આવે છે, એટલે $seats માં અવતરણ સાથે "350" હોય છે. તો પણ આ ચાલે છે:
echo "350" + 10; // 360 છાપે છે
Java માં એ type ની ભૂલ ગણાત; PHP માં એ બસ... ચાલી જાય છે, કારણ કે PHP એ ચૂપચાપ string ને સંખ્યામાં ફેરવી નાખ્યો. મદદરૂપ પણ જોખમી એવા આ વર્તનને type juggling કહે છે, અને એને (તથા એમાંથી જન્મતા == સામે === ના ભેદને) સમજવો એ જ આ પાઠનું હૃદય છે.
At a glance
PHP ના data types
| Type | શું સમાવે છે | દાખલો |
|---|---|---|
| string | લખાણ | $e = "Garba Night"; |
| int | પૂર્ણ સંખ્યાઓ | $seats = 350; |
| float | દશાંશ સંખ્યાઓ | $fee = 49.5; |
| bool | true કે false | $open = true; |
| array | ક્રમમાં કે ચાવીવાળો સંગ્રહ | $list = ["Riya", "Aman"]; |
| object | કોઈ class નો નમૂનો | $user = new User(); |
Theory
Type juggling અને casting
PHP dynamically typed છે: variable નો type એની અંદરની કિંમત પ્રમાણે નક્કી થાય છે અને બદલાઈ પણ શકે છે.
Type juggling એટલે કોઈ ક્રિયા દરમિયાન PHP નું આપોઆપ types બદલી નાખવું: "5" + 3 માં string "5" ને સંખ્યા 5 માં juggle કરીને 8 મળે છે. સગવડભર્યું ખરું, પણ એ તમને ચોંકાવી શકે છે.
Type casting એટલે એ જ કામ સ્પષ્ટ રીતે કરવું: (int)"5abc" આપે છે 5 (એ આગળના અંકો વાંચી લે છે), (int)"abc" આપે છે 0, અને (float)"3.5" આપે છે 3.5.
Form માંથી આવતું બધું હંમેશા strings હોય છે, એટલે juggling ને લીધે જ form ના data પર ગણતરી ઘણી વાર સીધી ચાલી જાય છે, અને casting એ રીત છે જેનાથી તમે એ ફેરબદલી ઇરાદાપૂર્વક અને સલામત બનાવો છો.
Practical
Operators અને == સામે === નો ફાંદો (દરેકનું અનુમાન કરો)
<?php
echo 10 % 3; // 1 (modulus: remainder)
echo 2 ** 3; // 8 (exponent)
echo "5" + 3; // 8 (juggling: string to number)
$msg = "Seats: ";
$msg .= 350; // .= appends -> "Seats: 350"
echo $msg;
var_dump("5" == 5); // bool(true) loose: juggles, then compares
var_dump("5" === 5); // bool(false) strict: different types
?>
Theory
== ઢીલું છે, === કડક છે
PHP માં operators નો આ સૌથી અગત્યનો એક વિચાર છે:
- `==` (ઢીલી સમાનતા) સરખાવતાં પહેલાં types ને juggle કરે છે, એટલે
"5" == 5true આવે છે અને0 == ""જેવા વિચિત્ર કિસ્સા પણ તમને ચોંકાવી શકે છે - `===` (સર્વથા સમાન) કિંમત અને type બંનેને juggling વગર સરખાવે છે, એટલે
"5" === 5false આવે છે (string સામે int)
Juggling અણધાર્યાં true ઉપજાવી શકે છે, એટલે વ્યાવસાયિક ટેવ એ છે કે ભરોસાપાત્ર સરખામણી જોઈતી હોય ત્યારે `===` ને પસંદ કરો. એ જ વાત != (ઢીલું) સામે !== (કડક) ને પણ લાગુ પડે છે. Form માંથી આવેલા string ને અપેક્ષિત કિંમત સાથે સરખાવો ત્યારે === તમને PHP ની મદદગારી ઊલટી પડવાથી બચાવે છે.
Quiz
var_dump("5" == 5); અને var_dump("5" === 5); અનુક્રમે શું છાપશે?
- true અને true
- true અને false: == string ને સંખ્યામાં juggle કરે છે (સમાન), જ્યારે === type પણ તપાસે છે (string સામે int, એટલે સર્વથા સમાન નહીં)
- false અને false
- false અને true
Show the answer
true અને false: == string ને સંખ્યામાં juggle કરે છે (સમાન), જ્યારે === type પણ તપાસે છે (string સામે int, એટલે સર્વથા સમાન નહીં)
== ઢીલું છે: એ "5" ને સંખ્યા 5 માં juggle કરે છે, એટલે "5" == 5 એ true આવે છે. === કડક છે: એ કિંમત અને type બંને સરખાવે છે, અને string એ int નથી, એટલે "5" === 5 એ false આવે છે. PHP માં સરખામણીનો આ જ મુખ્ય ભેદ છે, અને === ને પસંદ કરવાથી ઢીલા juggling થી થતાં આશ્ચર્યો ટળે છે. વિકલ્પ A ભૂલી જાય છે કે === type પણ તપાસે છે. વિકલ્પ C ભૂલી જાય છે કે == juggle કરે છે. વિકલ્પ D બંનેને ઊલટાવે છે. યાદ રાખો: == પૂછે છે 'juggle કર્યા પછી સમાન?', જ્યારે === પૂછે છે 'એ જ કિંમત અને એ જ type?'.
Think first
Form ની ચકાસણી === ને કેમ પસંદ કરે છે?
Portal તપાસે છે કે મોકલાયેલી role એ "admin" string જેટલી છે કે નહીં. અહીં == વાપરવું કેમ જોખમી હોઈ શકે, અને === કેમ વધુ સલામત? Juggling ના આધારે વિચારીને પછી tap કરો.
Show the answer
== સાથે PHP સરખાવતાં પહેલાં types juggle કરે છે, અને છેડાના કિસ્સાઓમાં એથી અણધાર્યાં true નીકળી શકે છે (દાખલા તરીકે 0 કે ખાલી કિંમતો વાળી સરખામણીઓ ઢીલા નિયમો હેઠળ ચોંકાવનારી રીતે વર્તે છે). 'આ વપરાશકાર admin છે કે નહીં' જેવી સલામતી સાથે જોડાયેલી તપાસમાં અણધાર્યું true એ આફત છે. === કિંમત અને type બંનેને juggling વગર સરખાવે છે, એટલે એ ત્યારે જ true આપે છે જ્યારે input બરાબર "admin" string હોય: કોઈ આશ્ચર્ય નહીં. નિયમ, ખાસ કરીને ચકાસણી અને અધિકાર માટે: === (અને !==) વાપરો જેથી PHP નું આપોઆપ થતું type પરિવર્તન ખોટા મેળમાં ઊલટું ન પડે. ઢીલી સમાનતા એ સગવડ છે જેને સાચાપણું અગત્યનું હોય ત્યાં તમે બંધ કરી દો છો.
Watch out
Type અને operator ના ફાંદા
== નાં આશ્ચર્યો: ઢીલી સમાનતા types juggle કરે છે; ભરોસાપાત્ર સરખામણી માટે === પસંદ કરો.
. = સામે +=: .= STRING ને છેડે જોડે છે; += સંખ્યાઓ ઉમેરે છે: બંને ગૂંચવાય તો data બગડે છે.
બિનસંખ્યાત્મક strings ને cast કરવા: (int)"abc" એ 0 છે, ભૂલ નહીં: ભરોસો કરતાં પહેલાં ચકાસો.
Form નો data સંખ્યા હશે એમ માની લેવું: $_GET અને $_POST ની કિંમતો STRINGS હોય છે; ગણતરી પહેલાં cast કરો કે ચકાસો.
/ હંમેશા પરિણામ આપે છે: 10 / 3 એ float 3.333... છે; પૂર્ણ સંખ્યા જોઈતી હોય તો intdiv() કે % વાપરો.
Theory
Types હાથમાં, હવે logic
Portal ને જોઈતા દરેક પ્રકારના data ને હવે તમે સંઘરી અને એની ગણતરી કરી શકો છો, અને PHP ને સગવડભર્યું તથા ક્યારેક કપટી બનાવતું juggling પણ સમજો છો. હવે portal ને નિર્ણય લેવા પડશે અને પુનરાવર્તન કરવું પડશે (if, switch, loops), અને સૌથી અગત્યનું, યાદીઓ સાચવવી પડશે: registration ની list એ ARRAY છે. Control structures અને arrays, સાથે PHP નાં શક્તિશાળી array functions, હવે પછી આવે છે.
Summary
Key takeaways
- PHP ના types: string, int, float, bool, array, object (અને null); એ dynamically typed છે (type કિંમત પ્રમાણે નક્કી થાય છે).
- Type juggling ક્રિયાઓમાં types આપોઆપ બદલે છે: "5" + 3 = 8; type casting ((int)"5abc" = 5) સ્પષ્ટ રીતે થાય છે.
- Operators: અંકગણિતના (+ - / % *), કિંમત આપવાના (=, +=, અને strings જોડતું .=), સરખામણીના, તાર્કિક (&& || !).
- == ઢીલું છે (types juggle કરે છે, એટલે "5" == 5 એ true છે); === કડક છે (કિંમત અને type બંને, એટલે "5" === 5 એ false છે).
- ભરોસાપાત્ર સરખામણી માટે === (અને !==) પસંદ કરો, ખાસ કરીને ચકાસણી અને અધિકારની તપાસમાં.
- Form નો data strings તરીકે આવે છે: ગણતરી કરતાં પહેલાં cast કરો કે ચકાસો.
- યાદ રાખવાની કડી: == juggle કરે છે, === નથી કરતું.