යොමුව - PHP හි මෙම සංකේතය අදහස් කරන්නේ කුමක්ද?

4481

මේ කුමක් ද?

මෙය PHP හි වාක්‍ය ඛණ්ඩය පිළිබඳව සෑම විටම මතු වන ප්‍රශ්න එකතුවකි. මෙයද ප්‍රජා විකියකි, එබැවින් මෙම ලැයිස්තුව නඩත්තු කිරීමට සහභාගී වීමට සැමට ආරාධනා කෙරේ.

ඇයි මේ?

ක්‍රියාකරුවන් සහ වෙනත් සින්ටැක්ස් ටෝකන පිළිබඳ ප්‍රශ්න සොයා ගැනීම දුෂ්කර විය. St
ප්‍රධාන අදහස වන්නේ දැනට පවතින ප්‍රශ්න වලට ස්ටැක් පිටාර ගැලීම සම්බන්ධ කිරීමයි, එබැවින් අපට ඒවා යොමු කිරීම පහසුය, PHP අත්පොතෙන් අන්තර්ගතය පිටපත් නොකිරීමට.

සටහන: 2013 ජනවාරි සිට, Stack Overflow විශේෂ අක්ෂර සඳහා සහය දක්වයි . උපුටා දැක්වීම් මගින් සෙවුම් වචන වට කරන්න, උදා[php] "==" vs "==="

මා මෙහි කුමක් කළ යුතුද?

ඔබ එවැනි ප්‍රශ්නයක් ඇසූ නිසා ඔබ යමෙකු විසින් මෙහි පෙන්වා තිබේ නම්, කරුණාකර පහත විශේෂිත වාක්‍ය ඛණ්ඩය සොයා ගන්න. PHP අත්පොත හා සම්බන්ධිත පිටු සමඟ සම්බන්ධිත ප්‍රශ්න ඔබේ ප්‍රශ්නයට පිළිතුරු සපයනු ඇත. එසේ නම්, පිළිතුර ඉහළ නැංවීමට ඔබව දිරිමත් කරනු ලැබේ. මෙම ලැයිස්තුව වෙනත් අය සපයන උපකාරයට ආදේශකයක් ලෙස අදහස් නොකෙරේ.

ලැයිස්තුව

ඔබගේ විශේෂිත ටෝකනය පහත ලැයිස්තුගත කර නොමැති නම්, ඔබට එය පාර්සර් ටෝකන ලැයිස්තුවෙන් සොයාගත හැකිය .

& Bitwise Operators හෝ References

=& යොමුව

&= බිට්වේස් ක්‍රියාකරුවන්

&& තාර්කික ක්‍රියාකරුවන්

% අංක ගණිත ක්‍රියාකරුවන්

!! තාර්කික ක්‍රියාකරුවන්

@ දෝෂ පාලන ක්‍රියාකරුවන්

?: තෘතීය ක්‍රියාකරු

?? Null Coalesce Operator (PHP 7 සිට)

?string ?int ?array ?bool ?float ආපසු හැරවිය හැකි ආකාරයේ ප්‍රකාශය (PHP 7.1 සිට)

: පාලන ව්‍යුහයන් සඳහා විකල්ප සින්ටැක්ස් , තෘතීය ක්‍රියාකරු

:: විෂය පථ විභේදන ක්‍රියාකරු

\ නාම අවකාශ

-> පන්ති සහ වස්තු

=> අරා

^ බිට්වේස් ක්‍රියාකරුවන්

>> බිට්වේස් ක්‍රියාකරුවන්

<< බිට්වේස් ක්‍රියාකරුවන්

<<< හෙරඩොක් හෝ නව්ඩොක්

= පැවරුම් ක්‍රියාකරුවන්

== සංසන්දනාත්මක ක්‍රියාකරුවන්

=== සංසන්දනාත්මක ක්‍රියාකරුවන්

!== සංසන්දනාත්මක ක්‍රියාකරුවන්

!= සංසන්දනාත්මක ක්‍රියාකරුවන්

<> සංසන්දනාත්මක ක්‍රියාකරුවන්

<=> සංසන්දනාත්මක ක්‍රියාකරුවන් (PHP 7.0 සිට)

| බිට්වේස් ක්‍රියාකරුවන්

|| තාර්කික ක්‍රියාකරුවන්

~ බිට්වේස් ක්‍රියාකරුවන්

+ අංක ගණිත ක්‍රියාකරුවන් , අරා ක්‍රියාකරුවන්

+=සහ -= පැවරුම් ක්‍රියාකරුවන්

++සහ -- ක්‍රියාකරුවන් වැඩි කිරීම / අඩු කිරීම

.= පැවරුම් ක්‍රියාකරුවන්

. සංගීත ක්‍රියාකරුවන්

, ක්‍රියාකාරී තර්ක

, විචල්ය ප්රකාශ

$$ විචල්ය විචල්යයන්

` ක්‍රියාත්මක කිරීමේ ක්‍රියාකරු

<?= කෙටි විවෘත ටැග්

[] අරා (PHP 5.4 සිට කෙටි වාක්‍ය ඛණ්ඩය)

<? ටැග් විවෘත කිරීම සහ වැසීම

... තර්ක ඉවත් කිරීම (PHP 5.6 සිට)

** On ාතීයකරණය (PHP 5.6 සිට)

# එක් පේළියේ ෂෙල් විලාසිතාවේ අදහස් දැක්වීම

:? ආපසු හැරවිය හැකි වර්ග

?-> NullSafe Operator ඇමතුම්

php  arguments  operators  symbols 
— ගෝර්ඩන්
source
36
මම මේ දැඩි PHP නොවේ කියලා, නමුත් මොන සම්බන්ධයක් ඇතුළු ගැන phpdoc.org පොදුවේ භාවිතා වන අතර එය සෙවීමට ද කළ නොහැකි දෙයක් වන, phpDocumentor අදහස් කාරක රීති සඳහා /**?
— මයික්
8
මට වර්ග වරහන සහ කැරලි වරහන යෝජනා කළ හැකිද?
— ajreal
124
මමද මෙම ගැටලුවට ගොදුරු වී සිටිමි (විශේෂ අක්ෂර සෙවීමට නොහැකි වීම), ඒ නිසා මම විශේෂ අක්ෂර නොසලකා හරින සෙවුම් යන්ත්‍රයක් වන සිම්බල්හවුන්ඩ් සෑදුවෙමි . මම එය StackApps හි ද පළ කළෙමි .
— dncrane
1
හොඳයි, ඇයි මේ? , මම හිතන්නේ එය "ප්‍රධාන අදහස වන්නේ දැනට පවතින ප්‍රශ්න වලට ස්ටැක් පිටාර ගැලීම සම්බන්ධ කිරීමයි, එබැවින් ඒවා යොමු කිරීම අපට පහසුය".
— හර්බට්
3
ඒ ප්රශ්නය අද ඉල්ලා සිටි (Nov.20 / 15) stackoverflow.com/questions/33833259/what-is-rscat-in-php ඉල්ලා "$ rsCat php යනු කුමක් ද" (එම ප්රශ්නය තවමත් දක්නට ඉදිරිපත් කළ යුතු අතර මකා දමන ලදී නොවේ) . පුදුමයට කරුණක් නම්, $විචල්යය ගැන සඳහනක් නැත , නමුත් $$විචල්ය විචල්යයන් ගැන පමණි. එය කොතැනක හෝ සංශෝධනය කළ යුතු යැයි මම විශ්වාස කරමි.
— ෆන්ක් හතළිස් නයිනර්

Answers:

1172

ක්‍රියාකරුවන් වැඩි කිරීම / අඩු කිරීම

++ වර්ධක ක්‍රියාකරු

-- අඩු කිරීමේ ක්‍රියාකරු

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.

මේවා විචල්‍යයට පෙර හෝ පසුව යා හැකිය.

විචල්යයට පෙර තැබුවහොත්, වර්ධක / අඩු කිරීමේ ක්රියාකාරිත්වය පළමුව විචල්යයට සිදු කරනු ලැබේ, පසුව ප්රති result ලය ලබා දෙනු ලැබේ. විචල්යයෙන් පසුව තැබුවහොත්, විචල්යය ප්රථමයෙන් ආපසු ලබා දෙනු ලැබේ, පසුව වර්ධක / අඩු කිරීමේ ක්රියාකාරිත්වය සිදු කෙරේ.

උදාහරණයක් වශයෙන්:

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

සජීවී උදාහරණය

ඉහත අවස්ථාවෙහිදී ++$iඑය වේගවත් බැවින් භාවිතා වේ. $i++එකම ප්‍රති .ල ලැබෙනු ඇත.

පෙර වර්ධක ටිකක් වේගවත් වන්නේ එය විචල්‍යය සැබවින්ම වැඩි කරන නිසා හා පසුව ප්‍රති return ලය 'ආපසු' ලබා දෙන බැවිනි. පශ්චාත් වර්ධකය විශේෂ විචල්‍යයක් නිර්මාණය කරයි, එහි පළමු විචල්‍යයේ අගය පිටපත් කරන අතර පළමු විචල්‍යය භාවිතා කිරීමෙන් පසුව පමණක් එහි අගය තත්පරයට ආදේශ කරයි.

කෙසේ වෙතත්, ඔබ භාවිතා කළ යුතුය $apples--, මුල සිටම, ඔබට දැනට පවතින ඇපල් සංඛ්‍යාව පෙන්වීමට අවශ්‍ය වන අතර, ඉන් එකක් එයින් අඩු කිරීමට ඔබට අවශ්‍යය.

ඔබට PHP හි අකුරු වැඩි කළ හැකිය:

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

zළඟා වූ පසු aaඊළඟට, සහ එසේ ය.

අක්ෂර විචල්‍යයන් වැඩි කළ හැකි නමුත් අඩු කළ නොහැකි බව සලකන්න. එසේ වුවද සහය දක්වන්නේ සරල ASCII අක්ෂර (az සහ AZ) පමණි.

පිටාර ගැලීම් සටහන් කරන්න:

— පීටර් අජ්තායි
source
9
අඩු කරන්නන් සංඛ්‍යා මත පමණක් ක්‍රියා නොකරන බව සටහන් කිරීම සඳහා +1
— මාර්ක් බේකර්
163
සෑම කෙනෙකුගේම යහපත උදෙසා, පූර්ව වර්ධක අසීමිත ලෙස වේගවත් වීම පිළිබඳ නිර්භීත තොරතුරු ඉවත් කරන්න. නොමේරූ ප්‍රශස්තිකරණයේ පරම නරකම උදාහරණය මෙය වන අතර ඔවුන් PHP ඉගෙන ගැනීමට පටන් ගන්නේ නම් මේ ආකාරයේ තොරතුරු මිනිසුන්ගේ ඔළුවේ නොතිබිය යුතුය.
— නෙළුම් සටහන්
14
Oot නෙළුම් - මම එය විනෝදජනක කරුණක් ලෙස සලකමි. ඔබ PHP, හෝ C ++ යනාදියෙහි ආරම්භකයකු නම්, ++ i සහ i ++ විවිධ වේගයෙන් වැඩ කිරීමට තරම් වෙනස් බව පෙනේ. මම එය සිත් ඇදගන්නා සුළු විය.
— පීටර් අජ්තායි
12
Et පීටර් අජ්තායි ඔව්, එය සිත්ගන්නා සුළුය, නමුත් ඔබ ඔබේ තනතුර ව්‍යුහගත කර ඇති ආකාරය අනුව එය භාෂාව භාවිතා කිරීම සඳහා අත්‍යවශ්‍ය වන PHP හි ප්‍රධාන කරුණු වලින් එකක් ලෙස පෙනේ.
— නෙළුම් සටහන්
4
එය මා පමණක්ද නැද්ද යන්න නිශ්චිත නැත, නමුත් ඇපල් උදාහරණය ටිකක් නොමඟ යවන බවක් පෙනේ. මට ඇපල් 10 ක් තියෙනවා. මම එකක් කෑවා 'මට ඇපල් 11 ක් ඇති බව මට විශ්වාසයි, නමුත් දැන් ඔබට 10 ක් තිබෙන්නේ ඔබ 10 ක් ඇති බව පැවසීමෙන් පසු එකක් අනුභව කරනවාට වඩා එකක් අනුභව කළ නිසා ඔබට 9 ක් ඇති බව ය.
— さ り げ な い 告白
440

බිට්වේස් ක්‍රියාකරු

ටිකක් මොකක්ද? ටිකක් යනු 1 හෝ 0 නිරූපණයකි. මූලික වශයෙන් OFF (0) සහ ON (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 බිට් 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, 2, සහ 1 තීරුවල අපට බිටු 3 ක් ඇති බව ඔබට පෙනෙනු ඇත. ඒවා එකතු කරන්න: 8 + 2 + 1 = 11.

— Ankur Saxena
source
6
$ A අගය 255 ට වඩා වැඩි නම් කුමක් කළ යුතුද?
— අයිකන් යාට්
Yc AycanYaşıt බොහෝ මෙහෙයුම් පද්ධතිය භාවිතා කරන්නේ බිට් 32 සහ බිට් 64 පද්ධතියයි, එයින් අදහස් වන්නේ සීමාව 255 (බිටු 8) ට වඩා වැඩිය.
— ඇල්බට් සැමුවෙල්
Yc AycanYaşıt ඇත්ත වශයෙන්ම, නවීන 64bit වේදිකාවක් මත කුඩාම නිඛිලය පවා මතකයේ 64 බිට් (බයිට් 8) තවමත් පවතින බැවින්, එක් බයිට් දිගකින් මෙහි නිරූපණය පවා නිවැරදි නොවේ.
— කයි
ඇයි and &වේ 0 0 0 0 1 0 0 0 හා or |වන 0 0 0 0 1 0 1 1?
— වීර්
285

<=> අභ්‍යවකාශ නැව් ක්‍රියාකරු

PHP 7 හි එකතු කරන ලදි

මෙම යානයට ක්රියාකරු <=> එය වේ, PHP 7. එකතු නවතම සංසන්දනය ක්රියාකරු වේ -associative නොවන සමානාත්මතාවය ක්රියාකරුවන් (සමාන තැනක්ද කෙරෙහි ද්වීමය ක්රියාකරු ==, !=, ===, !==). මෙම ක්‍රියාකරු වම් අත සහ දකුණත මෙහෙයුම් අතර සරල ත්‍රි-මාර්ග සැසඳීමක් කිරීමට ඉඩ දෙයි.

ක්‍රියාකරුගේ පූර්ණ සංඛ්‍යා ප්‍රකාශනයක ප්‍රති results ල:

  • 0 මෙහෙයුම් දෙකම සමාන වන විට
  • ට වඩා අඩු 0වම් අත විට යන අගයද මෙම අගයද දකුණු අත ට වඩා අඩු
  • ට වඩා වැඩි 0වන විට වම් අත යන අගයද මෙම අගයද දකුණු අත වඩා වැඩි

උදා

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

මෙම ක්‍රියාකරු භාවිතා කිරීම සඳහා හොඳ ප්‍රායෝගික යෙදුමක් වනුයේ අගයන් දෙකක් අතර ත්‍රිත්ව සංසන්දනයක් මත පදනම්ව ශුන්‍ය, negative ණ හෝ ධනාත්මක පූර්ණ සංඛ්‍යාවක් ආපසු ලබා දීමට අපේක්ෂා කරන සංසන්දනාත්මක ආකාරයේ ඇමතුම් ය. සංසන්දනය කිරීමේ ශ්‍රිතය 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;
});
— ෂෙරිෆ්
source
21
අවබෝධයක් නොමැති $a <=> $bවෙනස් වේ$a - $b
— rev
38
C ඇසිඩ්ෂවුට් $a - $bඅංක සඳහා ක්‍රියා කරයි, නමුත් නූල්, වස්තු හෝ අරා නොවේ.
— mcrumley
44
cmcrumley නැත, එය ඊට වඩා නරක ය. පොදුවේ ගත් කල $a - $bසංඛ්‍යා සඳහා පවා ක්‍රියා නොකරයි; එය ක්‍රියාත්මක වන්නේ පූර්ණ සංඛ්‍යා සඳහා පමණි . එය පූර්ණ සංඛ්‍යා නොවන සංඛ්‍යා සඳහා ක්‍රියා නොකරයි, මන්ද usortඔබේ සංසන්දක ශ්‍රිතයේ ප්‍රතිලාභ අගයන් int0.5 ට දමයි, එයින් අදහස් වන්නේ 0.5 ට 0 ට වාත්තු වන බවයි, එයින් අදහස් වන්නේ 1 ට වඩා අඩු වෙනසක් ඇති 4 සහ 4.6 වැනි සංඛ්‍යා දෙකක් (අනුව) ඔබේ සංසන්දක ශ්‍රිතයේ පළමු තර්කය ලෙස යමෙකු සම්මත වන විට) වැරදියට සමාන ලෙස සංසන්දනය කරන්න.
— මාර්ක් අමරි
5
Ark මාක්අමරි සංක්‍රමණ මාර්ගෝපදේශය යනු ක්‍රියාකරුගේ ලේඛනගත හැසිරීම නොවේ. ඒ සඳහා ඔබට එම php.net/language.operators.comparison සඳහා අත්පොතේ භාෂා ක්‍රියාකරුවන්ගේ අංශය දෙස බැලීමට අවශ්‍යය. මේ පිටුපස ඇති සත්‍ය හැසිරීම රඳා පවතින්නේ ඔබ නූල් සඳහා strcmp කරන විට වැනි, API හි විවිධ සංසන්දනාත්මක කාර්යයන් මත ය. සෑම අවස්ථාවකම සත්‍ය ප්‍රතිලාභ අගය ඔබට සහතික කළ නොහැක. ෂුවර්, එය සෑම විටම පාහේ 1, 0, හෝ -1 වේ, නමුත් ඔබට එය සහතික කළ නොහැකි අවස්ථාවන්හිදී, libc හි strcmp ඔතා තැබීමේදී මෙන්, ඔබ සුරක්‍ෂිත වීමට යටින් පවතින පිරිවිතරයට සමාන නිර්වචනය කළ හැසිරීමක් ඉදිරිපත් කරයි
— ෂෙරිෆ්
9
Ark මාක්අමරි මෙහි කාරණය වන්නේ නිර්වචනය නොකළ හැසිරීම් මත විශ්වාසය තැබීමට මිනිසුන්ට ඉඩ නොදීමයි. යමෙකුට හරියටම 1, 0, හෝ -1 නොවන අගයක් ලැබෙන එක් අවස්ථාවක, භාෂාවේ යම් වැරැද්දක් ඇතැයි සිතමින් යමෙකු දෝෂ වාර්තාවක් ගොනු කරයි. ඒ නිසාම අපට සහතික කළ හැකි සියල්ලම අගය 0 ට වඩා අඩු , විශාල හෝ සමාන වනු ඇති අතර අනිවාර්යයෙන්ම 1, 0 සහ -1 නොවිය යුතුය.
— ෂෙරිෆ්
273 
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
x or y     Or              True if any of x or y are true x=6 y=3
                           (x < 10 or y > 10) returns true 
x || y     Or              True if any of x or y are true x=6 y=3
                           (x < 3 || y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"
— අන්කූර් සක්සේනා
source
239

මැජික් නියතයන් : මේවා සංකේත පමණක් නොව මෙම ටෝකන පවුලේ වැදගත් කොටසකි. ඉන්ද්‍රජාලික නියතයන් අටක් ඒවා භාවිතා කරන ස්ථානය අනුව වෙනස් වේ.

__LINE__: ගොනුවේ වත්මන් පේළි අංකය.

__FILE__: ගොනුවේ සම්පූර්ණ මාර්ගය සහ ගොනු නාමය. ඇතුළත් කිරීමක් තුළ භාවිතා කරන්නේ නම්, ඇතුළත් කළ ගොනුවේ නම නැවත ලබා දෙනු ලැබේ. PHP 4.0.2 සිට, __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 හි එකතු කර ඇත).

මූලාශ්රය

— n.1
source
150

ක්‍රියාකරුවන් ටයිප් කරන්න

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නොකරන දත්ත පමණක් භාවිතා කරන්නsclass

උරුමය සමඟ උදාහරණය

<?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)
— Maulik patel
source
7
ඉහත සඳහන් වන්නේ 'අතුරුමුහුණත්' සමඟ ය. විශේෂිත අතුරු මුහුණතක් තිබේදැයි පරීක්ෂා කිරීමට මෙය ප්‍රයෝජනවත් වේ.
— රයන් වින්සන්ට්
133

PHP හි ක්‍රියාකරුවන් පිළිබඳ දළ විශ්ලේෂණයක් :

තාර්කික ක්‍රියාකරුවන්:

  • $ a && $ b: $ a සහ $ b යන දෙකම සත්‍ය නම් සත්‍යය.
  • $ a || $ b: $ a හෝ $ b සත්‍ය නම් සත්‍යය.
  • x a xor $ b: සත්‍යය $ a හෝ $ b සත්‍ය නම්, නමුත් දෙකම නොවේ.
  • ! $ a: TR a සත්‍ය නොවේ නම් සත්‍යය.
  • $ a සහ $ b: $ a සහ $ b යන දෙකම සත්‍ය නම් සත්‍යය.
  • $ a හෝ $ b: $ a හෝ $ b සත්‍ය නම් සත්‍යය.

සංසන්දනාත්මක ක්‍රියාකරුවන්:

  • $ a == $ b: යතුරු පැදවීමෙන් පසු $ a $ b ට සමාන නම් සත්‍යය.
  • $ a === $ b: සත්‍ය නම් $ a $ b ට සමාන වන අතර ඒවා එකම වර්ගයට අයත් වේ.
  • $ a! = $ b: යතුරු පැදවීමෙන් පසු $ a $ b ට සමාන නොවේ නම් සත්‍යය.
  • $ a <> $ b: යතුරු පැදවීමෙන් පසු $ a $ b ට සමාන නොවේ නම් සත්‍යය.
  • $ a! == $ b: $ a $ b ට සමාන නොවේ නම් හෝ ඒවා එකම වර්ගයට අයත් නොවේ නම් සත්‍යය.
  • $ a <$ b : $ a දැඩි ලෙස $ b ට වඩා අඩු නම් සත්‍යය.
  • $ a> $ b : $ a දැඩි ලෙස $ b ට වඩා වැඩි නම් සත්‍යය.
  • $ a <= $ b : $ a ට වඩා අඩු හෝ සමාන නම් සත්‍යය.
  • $ a> = $ b : $ a ට වඩා වැඩි හෝ සමාන නම් සත්‍යය.
  • $ a <=> $ b : inte a පිළිවෙලින් less b ට වඩා අඩු, සමාන හෝ වැඩි වූ විට පූර්ණ සංඛ්‍යාවක් ශුන්‍යයට වඩා අඩු, සමාන හෝ වැඩි වේ. PHP 7 සිට ලබා ගත හැකිය.
  • $ a? $ b: $ c : return ආපසු නම් $ b වෙනත් return c ( ත්‍රිමාණ ක්‍රියාකරු )
  • $ a ?? $ c : $ a ට සමානද? $ a: $ c ( ශුන්‍ය සිසිලන ක්‍රියාකරු - PHP> = 7 අවශ්‍ය වේ)

අංක ගණිත ක්‍රියාකරුවන්:

  • - $ a : $ a ට ප්‍රතිවිරුද්ධ.
  • $ a + $ b : $ a සහ $ b හි එකතුව.
  • $ a - $ b : $ a සහ $ b හි වෙනස.
  • $ a * $ b : $ a සහ $ b හි නිෂ්පාදිතය.
  • $ a / $ b : $ a සහ $ b හි ප්‍රමාණාත්මක.
  • $ a% $ b : ඉතිරි කොටස $ බෙදීමෙන් බෙදනු ලැබේ.
  • $ a ** $ b : power b බලයට $ a ඉහළ නැංවීමේ ප්‍රති ult ලය (PHP 5.6 හි හඳුන්වා දී ඇත)

ක්‍රියාකරුවන් වැඩි කිරීම / අඩු කිරීම:

  • ++ $ a : වැඩිවීම් $ a එකින් එක, ඉන්පසු return a ලබා දෙයි.
  • $ a ++ : Return a ලබා දෙයි, ඉන්පසු $ a එකින් එක වැඩි කරයි.
  • - $ a : අඩුවීම් $ a එකින් එක, ඉන්පසු return a.
  • $ a-- : $ a ආපසු, පසුව $ a එකින් එක අඩු කරයි.

බිට්වේස් ක්‍රියාකරුවන්:

  • $ a & $ b : $ a සහ $ b යන දෙකින්ම සකසා ඇති බිටු සකසා ඇත.
  • $ a | $ b : $ a හෝ $ b වලින් සකසා ඇති බිටු සකසා ඇත.
  • $ a ^ $ b : $ a හෝ $ b වලින් සකසා ඇති නමුත් දෙකම සකසා නැති බිටු.
  • ~ $ a : $ a හි සකසා ඇති බිටු සකසා නැති අතර අනෙක් අතට.
  • $ a << $ b : steps a $ b පියවර බිටු වමට මාරු කරන්න (සෑම පියවරක්ම අදහස් කරන්නේ "දෙකකින් ගුණ කිරීම")
  • $ a >> $ b : steps a $ b පියවර බිටු දකුණට මාරු කරන්න (සෑම පියවරක්ම "දෙකකින් බෙදන්න")

සංගීත ක්‍රියාකරුවන්:

  • $ a. $ b : $ a සහ $ b හි සංයුක්ත කිරීම.

අරාව ක්‍රියාකරුවන්:

  • $ a + $ b : $ a සහ $ b ඒකාබද්ධ වීම.
  • key a == $ b : key a සහ $ b එකම යතුරු / අගය යුගල තිබේ නම් සත්‍යය.
  • $ a === $ b : true a සහ $ b එකම යතුරු / අගය යුගල එකම අනුපිළිවෙලින් හා එකම වර්ගවල තිබේ නම් සත්‍යය.
  • $ a! = $ b : $ a $ b ට සමාන නොවේ නම් සත්‍යය.
  • $ a <> $ b : $ a $ b ට සමාන නොවේ නම් සත්‍යය.
  • $ a! == $ b : $ a $ b ට සමාන නොවේ නම් සත්‍යය.

පැවරුම් ක්‍රියාකරුවන්:

  • $ a = $ b : $ b හි අගය $ a ට පවරා ඇත
  • $ a + = $ b : $ a = $ a + $ b ට සමාන වේ
  • $ a - = $ b : $ a = $ a - $ b ට සමාන වේ
  • $ a * = $ b : $ a = $ a * $ b ට සමාන වේ
  • $ a / = $ b : $ a = $ a / $ b ට සමාන වේ
  • $ a% = $ b : $ a = $ a% $ b ට සමාන වේ
  • $ a ** = $ b : $ a = $ a ** $ b ට සමාන වේ
  • $ a. = $ b : $ a = $ a ට සමාන වේ. $ ආ
  • $ a & = $ b : $ a = $ a & $ b ට සමාන වේ
  • $ a | = $ b : $ a = $ a | $ ආ
  • $ a ^ = $ b : $ a = $ a ^ $ b ට සමාන වේ
  • $ a << = $ b : $ a = $ a << $ b ට සමාන වේ
  • $ a >> = $ b : $ a = $ a >>. b ට සමාන වේ

සටහන

andorපැවරුම් ක්‍රියාකරුට වඩා ක්‍රියාකරුට සහ ක්‍රියාකරුට අඩු ප්‍රමුඛතාවයක් =ඇත.

මෙයින් අදහස් කරන්නේ $a = true and false;එය සමාන බවයි ($a = true) and false.

බොහෝ අවස්ථාවන්හිදී ඔබට භාවිතා කිරීමට අවශ්‍ය වනු ඇති &&අතර ||, එය C, Java හෝ JavaScript වැනි භාෂාවලින් දන්නා ආකාරයකින් හැසිරේ.

— ජෝන් ස්ලෙගර්ස්
source
1
එහි දෝෂයක් තිබේ $a ?? $c, එය සමාන යැයි කියනු ලැබේ $a ? $a : $c, නමුත් අගය සත්‍යයක් දැයි තෘතීය ක්‍රියාකරු පරික්ෂා කරයි, අනෙක් අතට, ශුන්‍ය අගයන් සඳහා ශූන්‍ය සමතුලිතතා චෙක්පත්, එබැවින් $ a 0 නම්, ඔබට 0 ලැබෙනු ඇත (0 නිසා ශූන්ය නොවන), උදාහරණයක් ලෙස තිබේ නම්, ඔබ: $a=0; $c=5;එසේ නම් $a?$a:$c5 නැවත, හා $a??$cප්රතිලාභ 0
— stramin
104

අභ්‍යවකාශ නැව් ක්‍රියාකරු<=> (PHP 7 හි එකතු කර ඇත)

<=>අභ්‍යවකාශ නැව් ක්‍රියාකරු සඳහා උදාහරණ (PHP 7, මූලාශ්‍රය: PHP අත්පොත):

විචල්යයන් තුන් ආකාරයකින් සැසඳීම සඳහා පූර්ණ සංඛ්‍යා, පාවෙන, නූල්, අරා සහ වස්තු.

// 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
// Comparison is case-sensitive
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
— rajangupta
source
1
යොමුව සඳහා php.net/manual/en/language.operators.comparison.php පරීක්ෂා කරන්න
— rajangupta
74

{} කැරලි වරහන්

අන්තිම පෝස්ට් ගැන වචන කිහිපයක්

$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
— revs mnv
source
4
Property '' property දේපල නම් සඳහා අංකනය. echo $ movies-> movie -> great 'great-lines'} -> line; SimpleXMLElement හි දත්ත වෙත ප්‍රවේශ වීමට භාවිතා කළ හැකිය. සමහර විට එය වෙනත් අවස්ථාවල දී ද භාවිතා කළ හැකිය. php.net/manual/en/simplexml.examples-basic.php
— ඇන්ඩ්‍රි
68

ශුන්‍ය සිසිලන ක්‍රියාකරු (??)

මෙම ක්‍රියාකරු PHP 7.0 හි එකතු කර ඇත්තේ ත්‍රිමාණ ක්‍රියාකරුවෙකු සමඟ සම්බන්ධ වීමට අවශ්‍ය පොදු අවස්ථාව සඳහා ය isset(). එය පවතින අතර එසේ නොවේ නම් එය එහි පළමු ක්‍රියාකාරිත්වය ආපසු ලබා දෙයි 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';
?>
— VIPIN A ROY
source
64

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
— devpro
source
Iz රයිසියර් 123: "පංති ගුණාංග ආරම්භ කිරීම සඳහා හෙරෙඩොක්ස් භාවිතා කළ නොහැක. PHP 5.3 සිට, මෙම සීමාව වලංගු වන්නේ විචල්‍යයන් අඩංගු හෙරොඩොක්ස් සඳහා පමණි."
— PHPFan
48

ප්‍රශ්නය:

එයින් =>අදහස් කරන්නේ කුමක්ද?

පිළිතුර:

=>"Key" => "Value"ඇසෝසියේටිව් අරා වල යුගල වෙන් කිරීමට අපි මිනිසුන් තීරණය කළ සංකේතයද?

විස්තර කිරීම:

මෙය වටහා ගැනීම සඳහා, ඇසෝසියේටිව් අරා යනු කුමක්දැයි අප දැනගත යුතුය. සාම්ප්‍රදායික ක්‍රමලේඛකයෙකු අරාව ගැන සිතන විට ( 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

අවසාන කරුණ:

ඒ නිසා ඉහත උදාහරණය, එය බව දකින්න ලස්සන පහසු වේ =>සංකේතය එක් එක් අතර Associative Array අතර සම්බන්ධය ප්රකාශ කිරීමට භාවිතා කරයි keyසහ valueමාලාවක් දී යුගල තුළ අරාව තුළ සාරධර්ම ආරම්භය.

— revs Webeng
source
36

ප්‍රශ්නය :

PHP හි මෙහි "&" යන්නෙන් අදහස් කරන්නේ කුමක්ද?

PHP "සහ" ක්රියාකරු

අපි පුරුදු වූ පසු ජීවිතය වඩාත් පහසු කරයි .. (පහත උදාහරණය ප්‍රවේශමෙන් පරීක්ෂා කරන්න)

සහ සාමාන්යයෙන් $ a හා $ දෙකම ආ සකස් කළ චෙක්පත් බිටු මාලාවක් ඇත.

මෙම ඇමතුම් ක්‍රියාත්මක වන ආකාරය ඔබ දැක තිබේද?

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

එබැවින් ඉහත සියල්ල පිටුපස ඇත්තේ බිට්වේස් ක්‍රියාකරු සහ බිටු ගේම් ය.

මේවායේ එක් ප්‍රයෝජනවත් අවස්ථාවක් වන්නේ පහත දැක්වෙන වැනි පහසු වින්‍යාසයන් ය, එබැවින් තනි නිඛිල ක්ෂේත්‍රයකට ඔබ වෙනුවෙන් දහස් ගණනක් සංයෝජන ගබඩා කළ හැකිය.

බොහෝ අය මේ වන විටත් ලියකියවිලි කියවා ඇති නමුත් මෙම බිට්වේස් ක්‍රියාකරුවන්ගේ සැබෑ ලෝක භාවිත නඩුව විශ්වාස නොකරයි.

උදාහරණය ඔබ ආදරය කරන බව

<?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
— revs dev.mraj
source
30

==විචල්ය දත්ත වර්ගය සැලකිල්ලට නොගෙන චෙක් සමානාත්මතාවය සඳහා භාවිතා කරයි

===විචල්ය අගය සහ දත්ත වර්ගය යන දෙකම සඳහා චෙක් සමානාත්මතාවය සඳහා භාවිතා වේ

උදාහරණයක්

$a = 5

  1. if ($a == 5) - සත්‍ය ලෙස ඇගයීමට ලක් කරනු ඇත

  2. if ($a == '5') - සත්‍ය ලෙස තක්සේරු කරනු ඇත, මන්ද මෙම අගය දෙකම සංසන්දනය කරන විට PHP අභ්‍යන්තරව එම නූල් අගය පූර්ණ සංඛ්‍යාවක් බවට පරිවර්තනය කර අගයන් දෙකම සංසන්දනය කරයි

  3. if ($a === 5) - සත්‍ය ලෙස ඇගයීමට ලක් කරනු ඇත

  4. if ($a === '5') - අගය 5 ක් වන නමුත් මෙම අගය 5 පූර්ණ සංඛ්‍යාවක් නොවන නිසා අසත්‍යයට තක්සේරු කරනු ඇත.

— Parth Nayak
source
27

Null Coalesce operator "??" (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 වෙත යාවත්කාලීන වූ විගසම මම එය භාවිතා කරන බව මම දනිමි.

— යෝගී ගොරෙචා
source
12

ආපසු හැරවිය හැකි ආකාරයේ ප්‍රකාශය

PHP 7 ප්‍රතිලාභ වර්ග ප්‍රකාශ සඳහා සහය එක් කරයි. තර්ක වර්ග ප්‍රකාශන වලට සමානව, ප්‍රතිලාභ වර්ග ප්‍රකාශනයන් මඟින් ශ්‍රිතයකින් ආපසු ලබා දෙන අගය වර්ගය නියම කරයි. තර්ක වර්ග ප්‍රකාශ සඳහා ලබා ගත හැකි ප්‍රතිලාභ වර්ග සඳහා එකම වර්ග තිබේ.

දැඩි ටයිප් කිරීම නැවත පැමිණීමේ ප්‍රකාශන සඳහා ද බලපායි. පෙරනිමි දුර්වල මාදිලියේදී, ආපසු ලබා දුන් අගයන් දැනටමත් එම වර්ගයට අයත් නොවේ නම් නිවැරදි වර්ගයට බල කෙරෙනු ඇත. ශක්තිමත් ප්‍රකාරයේදී, ආපසු ලබා දුන් අගය නිවැරදි වර්ගයට අයත් විය යුතුය, එසේ නොමැති නම්, TypeError විසි කරනු ලැබේ.

PHP 7.1.0 වන විට, ප්‍රශ්නාර්ථ ලකුණක් (?) සමඟ ටයිප් නාමය උපසර්ග කිරීමෙන් ප්‍රතිලාභ අගයන් අහෝසි කළ හැකිය. මෙයින් ඇඟවෙන්නේ ශ්‍රිතය නිශ්චිත වර්ගය හෝ NULL නැවත ලබා දෙන බවයි.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

මූලාශ්රය

— ජෝන් කොන්ඩේ
source
7

ස්ප්ලට් ඔපරේටර් ලෙස ඩොට්ස් තුනක් (...) (PHP 5.6 සිට)

PHP හි ක්‍රියාකරු "..." (තිත් තුනක්) ඇති අතර එය ස්ප්ලට් ඔපරේටර් ලෙස හැඳින්වේ. ශ්‍රිතයක අත්තනෝමතික පරාමිති සංඛ්‍යාවක් සම්මත කිරීම සඳහා එය භාවිතා කරන අතර මෙම වර්ගයේ ශ්‍රිතය විචල්‍ය ශ්‍රිත ලෙස හැඳින්වේ. "..." (තිත් තුනක්) භාවිතා කිරීමට උදාහරණ ගනිමු.

උදාහරණ 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

ගණනය කිරීමේ සංඛ්‍යා () ශ්‍රිතයේ සෑම තර්කයක්ම “…” භාවිතා කරන විට $ පරාමිතීන් අරාව ලෙස ගමන් කරයි.

"…" ක්රියාකරු භාවිතා කිරීමට විවිධ ක්රම තිබේ. උදාහරණ කිහිපයක් පහත දැක්වේ:

උදාහරණ 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

උදාහරණ 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

උදාහරණ 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>
— යෝගී ගොරෙචා
source
0

? -> NullSafe Operator

මේ මොහොතේ, එය යෝජනාවක් පමණි, ඔබට එය මෙතැනින් සොයාගත හැකිය . එය ය NullSafe Operator, එය නැවත nullඔබ කටයුතු පතා හෝ අගයන් ලබා ගැනීමට උත්සාහ නඩුවේ null... නිදර්ශන

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object
— ජෝන් කොන්ඩේ
source
මෙය එකතු කිරීමෙන් නොමේරූ බවක් දැනේ, කිසිවෙකු මෙම ක්‍රියාකරු කිසිදු සජීවී කේතයකින් නොදකිනු ඇති අතර එය එකතු නොකෙරේ. විස්තර අවසන් වන තෙක් බලා සිටීම සහ එය නිසි ලෙස ලේඛනගත කිරීම වඩා හොඳය.
— IMSoP
අපට දැනටමත් ඒ පිළිබඳ ප්‍රශ්න ලැබෙමින් පවතී. : / යෝජනාව අසමත් වුවහොත් මෙය තබා ගැනීම වටී දැයි අපට තීරණය කළ හැකිය.
— ජෝන් කොන්ඩේ
@ ජෝන්කොන්ඩ් බලන්න? මේක තමයි මම කිව්වේ ...
— බර්ටෝ 99
@ ජෝන්කොන්ඩ් මම ඒවා මාතෘකාවෙන් බැහැර කිරීමට පෙළඹෙනු ඇත, මන්ද ඔවුන් අසන්නේ මන imag කල්පිත ක්‍රමලේඛන භාෂාවක් ගැන ය; හෝ සමහර විට "මෙම ප්‍රශ්නය
— කාලරාමුවේ
lol සිතුවිල්ල මගේ මනස හරහා ගියේය. මෙය අනාගත අමුත්තන්ට වටිනාකමක් ලබා දෙයිදැයි මම මගෙන්ම විමසුවෙමි. දැනට පිළිතුර “ඔව්” යන්නයි. නමුත් එය වෙනස් විය හැකිය ...
— ජෝන් කොන්ඩේ
0

Php8 සිට NullSafe Operator "? ->" (සමහර විට)

මේ මොහොතේ, එය යෝජනාවක් පමණි, ඔබට එය සබැඳි විස්තරය ඇතුළත් කළ හැකිය . ?->එය ය NullSafe Operator, එය නැවත nullඔබ කටයුතු පතා හෝ අගයන් ලබා ගැනීමට උත්සාහ නඩුවේ null...

උදාහරණ:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>
— revs Berto99
source
මෙය එකතු කිරීමෙන් නොමේරූ බවක් දැනේ, කිසිවෙකු මෙම ක්‍රියාකරු කිසිදු සජීවී කේතයකින් නොදකිනු ඇති අතර එය එකතු නොකෙරේ. විස්තර අවසන් වන තෙක් බලා සිටීම සහ එය නිසි ලෙස ලේඛනගත කිරීම වඩා හොඳය.
— IMSoP
@IMSoP මම ඔබ සමඟ සිටිමි, කෙසේ වෙතත් මට මෙහි ආරාධනා කරන ලද්දේ stackoverflow.com/questions/62178354/… ...
— Berto99
දැන් අපට මේ පිළිබඳව පිළිතුරු දෙකක් ඇති බව පෙනේ . පුද්ගලිකව, මම පිළිතුරු දීමට උත්සාහ කරනවාට වඩා අනෙක් ප්‍රශ්නයට වැසීමට ඡන්දය දෙන්නෙමි, මන්ද මේ වන විට එවැනි ක්‍රියාකරුවෙකු නොමැත.
— IMSoP
++IMSoP C ++ යෝජනාව ගැන ස්ටැක් ඕවර්ෆ්ලෝ හි බොහෝ ප්‍රශ්න ඇති අතර ඒවා වසා නැත: එසේ තිබියදීත්, මේ මොහොතේ මෙම ක්‍රියාකරු මෙහි පළ නොකිරීම ගැන මම ඔබ සමඟ සිටිමි
— බර්ටෝ 99
C ++ ක්‍රියාවලිය ගැන මම වැඩි යමක් නොදන්නා අතර, යෝජනා සාකච්ඡා කිරීම සාධාරණ වන විට සහ සාධාරණව කිවහොත් මෙය ව්‍යායාම වෙනස් කිරීම සාර්ථක වීමට බොහෝ දුරට ඉඩ ඇති බව පෙනේ, නමුත් පොදුවේ ගත් කල PHP සඳහා යෝජනා කරන ලද විශේෂාංග රාශියක් ඇත. භාෂාව, සහ පරිශීලකයන්ට ඒවා සියල්ලම විමර්ශන ලැයිස්තු තුළට පැමිණීම තරමක් ව්‍යාකූල වනු ඇත. එයින්
— කියැවුණේ
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.