අවශ්‍ය, ඇතුළත්, අවශ්‍ය_අවස්ථාව සහ ඇතුළත්_අවස්ථාව අතර වෙනස?

PHP හි:

• මම requireඑදිරිව භාවිතා කළ යුත්තේ කවදාද include?
• මම require_onceඑදිරිව භාවිතා කළ යුත්තේ කවදාද include_once?

ඇත requireසහ include_onceමෙන්ම.

ඉතින් ඔබේ ප්‍රශ්නය විය යුත්තේ ...

1. මම requireඑදිරිව භාවිතා කළ යුත්තේ කවදාද include?
2. මම require_onceඑදිරිව භාවිතා කළ යුත්තේ කවදාද?require

1 සඳහා පිළිතුර මෙහි විස්තර කෙරේ .

අවශ්‍ය () ශ්‍රිතය ඇතුළත් කිරීමට සමාන වේ (), එය දෝෂ වෙනස් ලෙස හසුරුවයි. දෝෂයක් සිදුවුවහොත්, ඇතුළත් කිරීමේ () ශ්‍රිතය අනතුරු ඇඟවීමක් ජනනය කරයි, නමුත් ස්ක්‍රිප්ට් එක දිගටම ක්‍රියාත්මක වේ. අවශ්‍යතාවය () මාරාන්තික දෝෂයක් ජනනය කරන අතර පිටපත නතර වනු ඇත.

2 සඳහා පිළිතුර මෙහි සොයාගත හැකිය .

Require_once () ප්‍රකාශය අවශ්‍යතාවයට සමාන වේ () PHP හැර ගොනුව දැනටමත් ඇතුළත් කර ඇත්දැයි පරීක්ෂා කරනු ඇත, එසේ නම්, එය නැවත ඇතුළත් නොකරන්න (අවශ්‍ය නොවේ).

භාවිත

• අවශ්ය
  ගොනුව විට අවශ්ය වැදගත් පණිවිඩයක් සැකිල්ල හෝ යෙදුම බිඳ දමන්නේ නැතිව වින්යාස විචල්යයන් අඩංගු ගොනු වර්ග උදා, ඔබගේ යෙදුම මඟින්.

• required_once
  ගොනුවේ අන්තර්ගතය පසුකාලීනව ඇතුළත් කිරීමේදී දෝෂයක් ඇති වන විට, උදා: function important() { /* important code */}ඔබගේ යෙදුමට අනිවාර්යයෙන්ම අවශ්‍ය වන නමුත් කාර්යයන් නැවත ප්‍රකාශ කළ නොහැකි බැවින් නැවත ඇතුළත් කළ යුතු නොවේ.

• ගොනුව අවශ්‍ය නොවන විට ඇතුළත් කරන්න සහ සොයාගත නොහැකි වූ විට යෙදුම් ප්‍රවාහය අඛණ්ඩව පැවතිය යුතුය, උදා:
  වත්මන් විෂය පථයෙන් හෝ වෙනත් දෙයකින් විචල්‍යයන් සඳහන් කරන සැකිලි සඳහා විශිෂ්ටයි

• include_once
  ඔබ HTTP පොදු කාර්ය නිසා දෙවරක් සිදු කිරීමට අවශ්ය නැති බව පසුව පැටවීම හෝ සමහරවිට දුරස්ථ ගොනු නමක් ඇතුලත් දෝෂ බිහි කරන බවත් ඒ විකල්ප පරායත්තයන්

නමුත් මූලික වශයෙන්, කුමන ඒවා භාවිතා කළ යුතුද යන්න ඔබට භාරයි.

මගේ යෝජනාව වන්නේ require_once99.9% ක් පමණක් භාවිතා කිරීමයි.

ඔබේ කේතය වෙනත් තැනක නැවත භාවිතා කළ නොහැකි බව භාවිතා කිරීම requireහෝ includeඒ වෙනුවට ගම්‍ය වේ, එනම් ඔබ ඇද ගන්නා ස්ක්‍රිප්ට් පංතියක් හෝ සමහර ක්‍රියාකාරී පුස්තකාල ලබා දීම වෙනුවට කේත ක්‍රියාත්මක කරයි.

ඔබට එම ස්ථානයේදීම ක්‍රියාත්මක වන කේතයක් අවශ්‍ය නම් / ඇතුළත් වන්නේ නම්, එය ක්‍රියා පටිපාටි කේතය වන අතර, ඔබ නව ආදර්ශයක් දැනගත යුතුය . වස්තු නැඹුරු වැඩසටහන්කරණය, ක්‍රියාකාරීත්වය පදනම් කරගත් ක්‍රමලේඛනය හෝ ක්‍රියාකාරී වැඩසටහන්කරණය වැනි.

ඔබ දැනටමත් OO හෝ ක්‍රියාකාරී ක්‍රමලේඛයක් කරන්නේ include_onceනම් , භාවිතා කිරීම බොහෝ විට ප්‍රමාද වන්නේ තොගයේ ඇති දෝෂ / දෝෂ සොයාගත හැකි තැනකය. ඔබ do_cool_stuff()පසුව ඇමතීමට යන විට ශ්‍රිතය ලබා ගත නොහැකි බව දැන ගැනීමට ඔබට අවශ්‍යද , නැතහොත් පුස්තකාලය අවශ්‍ය වීමෙන් එය ලබා ගත හැකි යැයි ඔබ අපේක්ෂා කරන මොහොතද? සාමාන්‍යයෙන්, ඔබට අවශ්‍ය සහ බලාපොරොත්තු වන දෙයක් නොමැති නම් වහාම දැන ගැනීම වඩාත් සුදුසුය, එබැවින් භාවිතා කරන්න require_once.

විකල්පයක් ලෙස, නවීන OOP හි, භාවිතයෙන් පසු ඔබේ පන්ති ස්වයංක්‍රීයව පටවන්න .

_Once ශ්‍රිත අතර සහ _once ශ්‍රිත නොමැතිව වෙනස: _once කේතය නොමැතිව නැවත ඇතුළත් වන අතර _once ශ්‍රිත සමඟ PHP ඇතුළත් කළ ලිපිගොනු නිරීක්ෂණය කරන අතර එය එක් වරක් පමණක් ඇතුළත් වේ.

අවශ්‍ය සහ ඇතුළත් කිරීම් අතර වෙනස: අවශ්‍ය ගොනුවක් සොයාගත නොහැකි නම් PHP මාරාන්තික දෝෂයක් නිකුත් කරන අතර ඇතුළත් කිරීම සඳහා අනතුරු ඇඟවීමක් පමණක් විමෝචනය වේ.

include() ගොනුව ඇතුළත් කළ නොහැකි නම් අනතුරු ඇඟවීමක් කරයි, නමුත් ඉතිරි ස්ක්‍රිප්ට් ක්‍රියාත්මක වේ.

require()E_COMPILE_ERRORගොනුව ඇතුළත් කළ නොහැකි නම් එය විසි කර ස්ක්‍රිප්ට් එක නවත්වනු ඇත.

මෙම include_once()සහ require_once()එය දැනටමත් ඇතුළත් කර තිබේ නම්, කාර්යයන් ගොනුව දෙවන කාලය ඇතුළත් නොවේ.

පහත ප්‍රලේඛන පිටු බලන්න:

• ඇතුළත් කරන්න
• අවශ්‍යයි
• include_once
• required_once

ඔබ භාවිතා කරන සෑම අවස්ථාවකම require_once()ගොනුවක භාවිතා කර වෙනත් ගොනුවක් ඇතුළත් කිරීමට අවශ්‍ය නම් ඔබට අවශ්‍ය ගොනුව වත්මන් ගොනුවේ එක් වරක් පමණක් අවශ්‍ය වේ. මෙන්න උදාහරණයේ මට test1.php ඇත.

<?php  
echo "today is:".date("Y-m-d");  
?>  

මම test2.php ලෙස නම් කර ඇති තවත් ගොනුවක

<?php  
require_once('test1.php');  
require_once('test1.php');  
?>

ටෙස්ට් 1 ගොනුව දෙවරක් අවශ්‍ය වන m දෙස ඔබ බලා සිටින නමුත් ගොනුවට එක් වරක් test1 ඇතුළත් වන අතර දෙවන වරට ඇමතීම සඳහා මෙය නොසලකා හරිනු ඇත. නවත්වන්නේ නැතිව ප්‍රතිදානය එකවර පෙන්වනු ඇත.

ඔබ 'include_once ()' භාවිතා කරන සෑම විටම වත්මන් ගොනුවේ එක් වරකට වඩා කැඳවූ ගොනුව අවශ්‍ය වූ විට වෙනත් ගොනුවක් ඇතුළත් කිරීමට ගොනුවක භාවිතා කළ හැකිය. මෙන්න උදාහරණයේ මට test3.php නමින් ගොනුවක් ඇත.

<?php  
echo "today is:".date("Y-m-d");  
?> 

මම test4.php ලෙස නම් කර ඇති තවත් ගොනුවක

<?php  
include_once('test3.php');  
include_once('test3.php');  
?>

ටෙස්ට් 3 ගොනුව ඇතුළුව ඔබ එම් දෙස බලා සිටින විට ගොනුව එක් වරක් ඇතුළත් වන නමුත් තවදුරටත් ක්‍රියාත්මක කිරීම නවත්වනු ඇත.

නැවත භාවිතා කළ හැකි PHP සැකිලි සඳහා "ඇතුළත් කරන්න" භාවිතා කරන්න . අවශ්‍ය පුස්තකාල සඳහා "අවශ්‍ය" යන්න භාවිතා කරන්න.

"* _once" හොඳයි, මන්ද එය ගොනුව දැනටමත් පටවා තිබේද නැද්ද යන්න පරීක්ෂා කරයි, නමුත් එය මට අවශ්‍ය වන්නේ "required_once" තුළ පමණි.

ඔබ පන්ති සහ ක්‍රියාකාරී අර්ථ දැක්වීම් ලිපිගොනු තුළ සංවිධානය කළ යුතුය.

පරායත්තතාrequire_once() පැටවීමට භාවිතා කරන්න (පන්ති, කාර්යයන්, නියත).

අච්චු වැනි ගොනුrequire() පූරණය කිරීමට භාවිතා කරන්න .

විකල්ප පරායත්තතාinclude_once() පැටවීමට භාවිතා කරන්න (පන්ති, කාර්යයන්, නියත).

විකල්ප අච්චු වැනි ගොනුinclude() පූරණය කිරීමට භාවිතා කරන්න .

2018 සඳහා වසර 7 කට පසු පිළිතුරක්

මෙම ප්‍රශ්නය මීට වසර හතකට පෙර විමසන ලද අතර, පිළිතුරු කිසිවක් ප්‍රශ්නයට ප්‍රායෝගික උපකාර ලබා නොදේ. නූතන PHP ක්‍රමලේඛනයේදී ඔබ ප්‍රධාන වශයෙන් භාවිතා required_onceකරන්නේ ඔබේ ස්වයංක්‍රීය පැටවුම් පන්තිය (බොහෝ විට නිර්මාපක ස්වයංක්‍රීය පැටවුම) ඇතුළත් කිරීමට වන අතර, එය ඔබගේ සියලුම පන්ති සහ ක්‍රියාකාරකම් පටවනු ඇත ( composer.jsonඅනෙකුත් සියලුම ලිපිගොනු වල ලබා ගත හැකි වන පරිදි කාර්යයන් ගොනු පැහැදිලිවම ගොනුවට එක් කළ යුතුය). කිසියම් හේතුවක් නිසා ඔබ භාවිතා කරන ස්වයංක්‍රීය පැටවුමෙන් ඔබේ පන්තිය පූරණය කළ නොහැකි නම්require_once පැටවිය නොහැකි නම් එය පූරණය කිරීමට කරයි.

අප භාවිතා කළ යුතු අවස්ථා කිහිපයක් තිබේ require. උදාහරණයක් ලෙස, ඔබට විශාල අරා අර්ථ දැක්වීමක් තිබේ නම් සහ ඔබට මෙය ඔබගේ පන්ති අර්ථ දැක්වීමේ ප්‍රභව කේතයට එක් කිරීමට අවශ්‍ය නොවන්නේ නම්:

 <?php
// arr.php
return ['x'=>'y'];

 <?php
//main.php
$arr= require 'arry.php'

ඔබ ඇතුළත් කිරීමට අදහස් කරන ගොනුවේ ක්‍රියාත්මක කළ හැකි යමක් තිබේ නම් හෝ ඔබ නිතරම භාවිතා කළ යුතු විචල්‍යයන් ප්‍රකාශ requireකරන්නේ නම්, මන්ද ඔබ භාවිතා කරන්නේ නම්require_once පළමු ස්ථානයෙන් බැහැරව ඔබේ කේතය ක්‍රියාත්මක නොවනු ඇති අතර / හෝ ඔබේ විචල්‍යයන් නිශ්ශබ්දව ආරම්භ නොවනු ඇත. නිශ්චිතවම හඳුනා ගැනීම දුෂ්කර ය.

කිසිදු ප්රායෝගික භාවිතය නඩුවක් නොමැති includeහා include_onceඇත්තටම.

වෙනස වන්නේ විධාන ජනනය කරන දෝෂයයි. සමඟ require, ඔබට භාවිතා කිරීමට අවශ්‍ය ගොනුව සැබවින්ම අවශ්‍ය වන අතර E_ERRORඑය සොයාගත නොහැකි නම් එය ජනනය කරයි .

require()include() අසමත් වූ විට හැර එය සමාන වන අතර එය මාරාන්තික E_ERROR මට්ටමේ දෝෂයක් ද ඇති කරයි.

includeE_WARNINGදෝෂයක් ජනනය කරන්නේ එය අසමත් වුවහොත් වැඩි හෝ අඩු නිහ .ව පමණි.

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

සඳහා *_once():

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

require_once()ඇත්ත වශයෙන්ම එයම අදාළ වේ .

මූලාශ්ර: require(),include_once()

අවශ්‍යතාවය සමඟ ගොනුව පැවතිය යුතුය, එසේ නොවේ නම් දෝෂයක් පෙන්වනු ඇත; ඇතුළත් කිරීමත් සමඟ - ගොනුව නොපවතී නම් පිටුව දිගටම පූරණය වේ.

අවසර දීම වැනි විවේචනාත්මක කොටස් අවශ්‍ය වන අතර අනෙක් සියල්ල ඇතුළත් කරන්න.

බහුවිධ ඇතුළත් කිරීම් ඉතා නරක නිර්මාණයක් වන අතර එය කිසිසේත් වළක්වා ගත යුතුය. ඉතින්, * _once ඇත්ත වශයෙන්ම වැදගත් නොවේ.

ඇතුළත් / ඕනෑ ඔබ ද එක් වරකට වඩා එම ගොනුව ඇතුලත් කර ගත හැක:

අවශ්‍ය () ඇතුළත් කිරීමට සමාන වේ () අසමත් වූ විට හැර එය මාරාන්තික E_COMPILE_ERROR මට්ටමේ දෝෂයක් ද ඇති කරයි. වෙනත් වචන වලින් කිවහොත්, එය ස්ක්‍රිප්ට් එක නවතා දමනු ඇති අතර () ඇතුළත් වන්නේ අනතුරු ඇඟවීමක් (E_WARNING) පමණක් විමෝචනය වන අතර එමඟින් ස්ක්‍රිප්ටය දිගටම කරගෙන යාමට ඉඩ ලබා දේ.

required_once / include_once

PHP හැර ගොනුව දැනටමත් ඇතුළත් කර ඇත්දැයි පරීක්ෂා කර බැලීමට හැර / ඇතුළත් කිරීමට / අවශ්‍ය වේ. එසේ නම්, එය නැවත ඇතුළත් නොකරන්න (අවශ්‍ය නොවේ).

include()එය ගොනුවක් සොයා නොගත් විට අනතුරු ඇඟවීමක් ජනනය කරනු ඇත, නමුත් require_once()මාරාන්තික දෝෂයක් ජනනය කරයි.

තවත් දෙයක් නම් ගොනුව මීට පෙර ඇතුළත් කර ඇත්නම්. ඉන්පසු require_once()එය නැවත ඇතුළත් නොකරනු ඇත.

මම පහත පරිදි ශ්‍රිතය භාවිතා කරමින් සිටියෙමි:

function doSomething() {
    require_once(xyz.php);
    ....
}

Xyz.php හි නියත අගයන් ප්‍රකාශ විය.

මට මෙම doSomething () ශ්‍රිතය වෙනත් PHP ස්ක්‍රිප්ට් ගොනුවකින් ඇමතිය යුතුය.

නමුත් මෙම ශ්‍රිතය ලූපයක් ලෙස කැඳවන විට මම හැසිරීම නිරීක්ෂණය කළෙමි, මන්ද යත් පළමු පුනරාවර්තනය doSomething () තුළ නියත අගයන් ලැබෙමින් පවතින xyz.phpනමුත් පසුව සෑම doSomething()ක්‍රියාවලියකටම නියත අගයන් ප්‍රකාශ කිරීමට නොහැකි විය.xyz.php .

මම මාරු වූ විට මගේ ප්රශ්නය විසඳා require_once()ගැනීමට include(), යාවත්කාලීන doSomething()කේතය පහත පරිදි වේ:

function doSomething() {
    include(xyz.php);
    ....
}

දැන් සෑම පුනරාවර්තන ඇමතුමකින්ම doSomething()අර්ථ දක්වා ඇති නියත අගයන් ලබා ගනී xyz.php.

සිට අත්පොත :

require()include()අසමත් වූ විට හැර එය සමාන වන අතර එය මාරාන්තික E_COMPILE_ERRORමට්ටමේ දෝෂයක් ද ඇති කරයි. වෙනත් වචන වලින් කිවහොත්, එය ස්ක්‍රිප්ට් include()එක නවත්වන අතර අනතුරු ඇඟවීමක් පමණක් නිකුත් කරයි ( E_WARNING) එය පිටපත දිගටම කරගෙන යාමට ඉඩ දෙයි.

_once()ප්‍රභේද සඳහා ද එය එසේම වේ .

PSR-0 / PSR-4ස්වයංක්‍රීය පැටවුම්කරුවන්ගේ යුගයේදී , ඔබට අවශ්‍ය වන්නේ යම් යම් ක්‍රියාකාරකම් / පන්ති ඔබේ කේතයට ලබා දීම නම් ඔබට අවශ්‍ය ඕනෑම ප්‍රකාශයක් භාවිතා කිරීම සම්පූර්ණයෙන්ම අනවශ්‍ය විය හැකිය (ඇත්ත වශයෙන්ම, ඔබ තවමත් require_onceඔබේ ඇරඹුම් ගොනුවේ සහ includeසැකිලි වල ස්වයංක්‍රීයව පැටවිය යුතුය. තවමත් අච්චු එන්ජිමක් ලෙස PHP භාවිතා කරන්න).

1. විට එක් භාවිතා කළ යුතු requireහෝ include?

   මෙම requireසහ includeකාර්යයන් ද එම කාර්යයේම කරන්න, එනම්, ඇතුළත් වේ හා නිශ්චිත ගොනුව ඇගයීමට ලක්, නමුත් එම වෙනස requireෙහයින් නිශ්චිත ගොනුව ස්ථානය අවලංගු හෝ වැරදි සඳහා වූ විට මාරාන්තික දෝෂයක් හේතු වනු ඇත includeඅනතුරු ඇඟවීමක් ජනනය සහ කේතය ක්රියාත්මක කරනු ඇත.

   එබැවින් ඔබ requireඇතුළත් කිරීමට උත්සාහ කරන ගොනුව පද්ධතියේ හදවත වන අතර අනෙක් කේතයට විශාල බලපෑමක් ඇති කළ හැකි අතර ඔබ includeඇතුළත් කිරීමට උත්සාහ කරන ගොනුව a වන විට ඔබට ශ්‍රිතය භාවිතා කළ හැකිය . අඩු වැදගත් කේත කිහිපයක් අඩංගු සරල ගොනුව.

   මගේ පුද්ගලික නිර්දේශය (අඩු වැදගත් කේතයක් සඳහා) requireඔබේ කේතයේ සෑම තැනකම ක්‍රියාකාරිත්වය සඳහා යාමයි. එය සංවර්ධන අවධියේදී ඔබට කේත නිදොස්කරණය කළ හැකි අතර පසුව නිෂ්පාදනයට ගෙන යාමට පෙර සියලු requireකාර්යයන් ශ්‍රිතය මගින් ප්‍රතිස්ථාපනය කළ හැකිය. includeඕනෑම දෝෂයක් එය අවසාන පරිශීලකයාට බලපාන්නේ නැති අතර ඉතිරි කේතය නිසි ලෙස ක්‍රියාත්මක වේ ...

2. එකක් භාවිතා කළ යුතු විට require_onceහෝrequire?

   අතර මූලික වෙනසක් requireහා require_onceවන require_onceඑය දැනටමත් එය ඇති ෙහයින් ගොනුව ඇතුළත් නොවේ ඇතුළත් නම්, ගොනුවක් දැනටමත් ඇතුළත් ද නැද්ද යන්න පරීක්ෂා කරනු ඇතrequire කාර්යය නොසලකා ගොනුවක් දැනටමත් ඇතුළත් නැද්ද යන්න මෙම ගොනුවේ අඩංගු වේ.

   එබැවින් ඔබට යම් කේත කැබැල්ලක් නැවත නැවත ඇතුළත් කිරීමට අවශ්‍ය අවස්ථාවන්හිදී requireශ්‍රිතය භාවිතා කරන අතර ඔබේ කේතයට එක් වරක් පමණක් කේතයක් ඇතුළත් කිරීමට අවශ්‍ය නම් භාවිතා කරන්න require_once.

1. ඔබට ඕනෑම පන්තියක්, ශ්‍රිතයක් හෝ යැපීමක් පැටවීමට අවශ්‍ය වූ විට අවශ්‍ය ශ්‍රිතය භාවිතා කරන්න .

2. ඔබට අච්චු හැඩැති ගොනුවක් පූරණය කිරීමට අවශ්‍ය විට ඇතුළත් කිරීමේ ශ්‍රිතය භාවිතා කරන්න

ඔබ තවමත් ව්‍යාකූල වී ඇත්නම්, සෑම විටම required_once භාවිතා කරන්න .

ඒවා සියල්ලම ගොනු ඇතුළත් කිරීමේ ක්‍රම වේ.

අවශ්‍යයි යන්නෙන් අදහස් කරන්නේ එයට එය අවශ්‍ය බවයි. Require_once යන්නෙන් අදහස් කරන්නේ එයට එය අවශ්‍ය වනු ඇති නමුත් එය අවශ්‍ය වන්නේ එක් වරක් පමණි. ඇතුළත් කරන්න යන්නෙන් අදහස් කරන්නේ එයට ගොනුවක් ඇතුළත් වන නමුත් එය දිගටම කරගෙන යාමට අවශ්‍ය නොවන බවයි.

උදාහරණ:

Require 'filename'
Require_once 'filename'
Include 'filename'

එක් වරක් ගොනුවක් ඇතුළත් වන include_once ශ්‍රිතයක් ද ඇත.

Include_once 'filename'

මගේ දුරකථනයෙන් යතුරු ලියනය කරන විට මා සතුව ඇති ලොකු අකුරු භාවිතා නොකරන්න.

මා දුටු එක් දෙයක් නම්, ඇතුළත් කිරීම භාවිතා කරන විට මට ඇතුළත් කළ ගොනුවේ ක්‍රියාකාරිත්වයට පමණක් ප්‍රවේශ විය හැකිය. Require_once සමඟ, මට අවශ්‍ය දෙවන තත්පර ගොනුවකින් එම ශ්‍රිතය ක්‍රියාත්මක කළ හැකිය.

එසේම: එකතු කිරීමට මම නිර්දේශ කරමි

if(file_exists($RequiredFile)){
    require_once($RequiredFile);
}else{
  die('Error: File Does Not Exist');
}

Require_once පිටුව මරා දැමූ විට, එය සමහර විට ඔබේ වෙබ් අඩවි ගොනු වල නාමාවලිය දෝංකාර දෙයි

ලිපිගොනු අවශ්‍ය කිරීම සඳහා මා විසින් සාදන ලද අභිරුචි ශ්‍රිතයක් මෙන්න:

function addFile($file, $type = 'php', $important=false){
    //site-content is a directory where I store all the files that I plan to require_once
    //the site-content directory has "deny from all" in its .htaccess file to block direct connections
    if($type && file_exists('site-content/'.$file.'.'.$type) && !is_dir('site-content/'.$file.'.'.$type)){
        //!is_dir checks that the file is not a folder
        require_once('site-content/'.$file.'.'.$type);
        return 'site-content/'.$file.'.'.$type;
    }else if(!$type && file_exists('site-content/'.$file) && !is_dir('site-content/'.$file)){
        //if you set "$type=false" you can add the file type (.php, .ect) to the end of the "$file" (useful for requiring files named after changing vars)
        require_once('site-content/'.$file);
        return 'site-content/'.$file;
    }else if($important){
        //if you set $important to true, the function will kill the page (which also prevents accidentally echoing the main directory path of the server)
        die('Server Error: Files Missing');
        return false;
    }else{
        //the function returns false if the file does not exist, so you can check if your functions were successfully added
        return false;
    }
}

භාවිත උදාහරණය:

$success = addFile('functions/common');

if($success){
    commonFunction();
}else{
    fallbackFunction();
}

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

ඉංග්‍රීසි වචනයෙන් අවශ්‍යයි , PHP හට පිටුව හෝ ගොනුව ක්‍රියාත්මක කිරීම අවශ්‍ය ගොනුව මත රඳා පවතින බව කියනු ලැබේ.

මගේ අත්දැකීම් අනුව, වින්‍යාස ගොනු, දත්ත සමුදා පන්ති සහ වෙනත් වැදගත් උපයෝගිතා වැනි වැදගත් ලිපිගොනු අවශ්‍ය වේ.

ඔබට බොහෝ විට සේවාදායක පුස්තකාලයක් කොන්දේසි සහිතව පූරණය කිරීමට අවශ්‍යද, නැතහොත් ඉදිරියට ගොස් ඔබ එය භාවිතා කිරීමට යනවාද නැද්ද යන්න ගැටළුවක් වේ.

මෙන්න ස්ථිර උදාහරණය; pcj කියපු දේ විස්තාරනය කරනවා.

ඔබේ දත්ත සමුදා පරිශීලක නාමය සහ මුරපදය ගබඩා කරන වින්‍යාස ගොනුවක් ඔබ සතුව ඇති බව පවසන්න (conf.php):

<?php
//my site configuration file

//For Database
$location='localhost';
$dbuser='yourname';
$userpw='yourpassword';
$database='nameofdatabase';
?>

දත්ත සමුදාය භාවිතා කරන ස්ථිතික ශ්‍රිතයක් සහිත පන්තියක්:

<?php
class UsedInLoop {
    public static function databaseQuery(){
        require(/path/to/conf.php);                //require_once will not work here
        $db = new mysqli($location, $dbuser, $userpw, $database);
        //yada yada yada
    }
}
?>

එම ස්ථිතික ශ්‍රිතය වෙනත් ශ්‍රිතයක් තුළ පුනර්භවයක් ලෙස පුඩුවක් තුළ භාවිතා වේ:

<?php
require_once('path/to/arbitraryObject.php');  //either will likely be OK at this level
$obj = new arbitraryObject();
foreach($array as $element){
    $obj->myFunction();
}
?>

ඔබට අවශ්‍ය වන්නේ එක් වරක් පමණි. ඔබගේ ලූපයේ සෑම පුනරාවර්තනයක් සඳහාම ඔබට එය අවශ්‍ය නම් / ඇතුළත් කළහොත් ඔබට දෝෂයක් ලැබෙනු ඇත. කෙසේ වෙතත්, ස්ථිතික ශ්‍රිතය හැඳින්වෙන සෑම අවස්ථාවකම ඔබේ වින්‍යාස ගොනුව ඇතුළත් කළ යුතුය.

<?php
class arbitraryObject {
    public function myFunction(){
        require_once(/path/to/UsedInLoop.php);   //This must be require_once. require() will not work
        UsedInLoop::databaseQuery();
    }
}
?>

ඇත්ත වශයෙන්ම, එය ශ්‍රිතයෙන් පිටත ගෙනයාම එම ගැටලුවට විසඳුමක් විය හැකිය:

<?php
require(/path/to/UsedInLoop.php);   //now require() is fine   
class arbitraryObject {
    public function myFunction(){
        UsedInLoop::databaseQuery();
    }
}
?>

සමහර කොන්දේසි යටතේ පමණක් භාවිතා කළ හැකි පංතියක් පැටවීමේ පොදු කාර්යය ගැන ඔබ සැලකිලිමත් නොවන්නේ නම් සහ එය නොමැති විට එය පූරණය කිරීමට අවශ්‍ය නොවේ.

requireincludeගොනුව පළමුව විග්‍රහ කළ යුතු බැවින් ඊට වඩා වැඩි පොදු කාර්යයක් ඇත. වෙනුවට requiresසමග includesබොහෝ විට හොඳ ප්රශස්තිකරණය තාක්ෂණයකි.

අවශ්‍යතාවය සහ ඇතුළත් කිරීම භාවිතා කරන්න.

Include_once හෝ required_once සමඟ වැඩ කරන්නේ කෙසේදැයි සිතන්න. එය ඇතුළත් කර ඇති හෝ අවශ්‍ය PHP ගොනු සුරකින ලොග් දත්ත සොයමින් සිටී. එබැවින් එය ඇතුළත් කිරීමට හා අවශ්‍ය වීමට වඩා මන්දගාමී වේ.

if (!defined(php)) {
    include 'php';
    define(php, 1);
}

මේ වගේ පාවිච්චි කරනවා ...