A php csatlakozás jelentése egyszerű oroszul:
Fájl 1.php
Főmenü
2.php fájl
Alsó menü
example.php fájl
Fájl csatlakoztatása 1.php
Az oldal tartalma
Csatlakoztassa a 2.php fájlt
Az example.php fájl feldolgozása eredményeként megjelenik
Főmenü
Az oldal tartalma
Alsó menü
Ennek megfelelően ahhoz, hogy bármit is módosíthasson az alsó menüben, csak a 2.php fájlban kell változtatásokat végrehajtania
PHP kód
// relatív elérési út példa
include "include/your_file.php"; // a fájl az include mappában található, amely ugyanabban a könyvtárban található, mint a kapcsolattal rendelkező fájl
// abszolút elérési út példa
include $_SERVER["DOKUMENTUM_GYÖKÉR"]."/include/your_file.php"; // $_SERVER["DOCUMENT_ROOT"] - a webhely gyökérkönyvtárát adja meg
Tekintsük az include munkáját két fájl példáján: index.phpÉs text.php. Az egyszerűség kedvéért tegyük fel, hogy ugyanabban a könyvtárban vannak.
PHP kód(fájl index.php)
Echo "A fő fájlban található egyszerű szöveg";
tartalmazza a "text.php"; // tartalmazza a text.php fájl tartalmát
?>
PHP kód(fájl text.php)
Echo "Szöveg a mellékelt fájlban";
?>
Az index.php fájl hatására a következő jelenik meg:
A fő fájlban található egyszerű szöveg
A mellékelt fájlban található szöveg
Tényleg kényelmes? Most a text.php fájl tartalmának megváltoztatásával az index.php eredménye teljesen más lesz!
Most beszéljünk egy másik tervezésről - tartalmazza_egyszer. Pontosan ugyanúgy működik, mint az include, csak később jön létre, és olyan esetekben, amikor nem tudja újra beilleszteni a fájlt. Például attól tart, hogy egy hiba következtében 2-szer vagy többször is beilleszthet egy fájlt, ami befolyásolja az oldal hibás működését és a megfelelő hibaüzenet megérkezését.
PHP kód
include_once "text.php"; // text.php fájl csak egyszer kerül bele
// Az alábbi újracsatlakozás figyelmen kívül lesz hagyva és megjelenik
// és nem generál hibaüzenetet
include_once "text.php"; // semmi sem fog történni
1.
Ellenőrizze, hogy a szerver és a php működik-e, ha egyáltalán működik php kód Online
2.
Ellenőrizze, hogy létezik-e az include fájl
3.
Ellenőrizze, hogy a fájlnév és a kiterjesztés helyesen van-e megadva a kapcsolatban
4.
Győződjön meg arról, hogy a mellékelt php fájl valóban az Ön által megadott címen található
5.
Próbáljon meg nem relatív elérési utat megadni, hanem abszolút elérési utat (a fájl teljes elérési útját).
Példa PHP kód
Tartalmazza "http://www.example.com/include/your_file.php";
// DOCUMENT_ROOT - az erőforrás gyökérkönyvtárát jelöli ki
include $_SERVER["DOKUMENTUM_GYÖKÉR"]."/include/your_file.php";
6. Ha nem csatlakoztatja a fájlt, és nem jelenik meg hiba, akkor a csatlakoztatni kívánt fájl könyvtárában hozzon létre egy fájlt .htaccess a következő tartalommal
php_flag display_errors Be
vagy php fájlban, csatlakozás előtt szúrja be a következő sort
hibabejelentés(E_ALL);
Mindkét beállítás kikényszeríti a megjelenítési hibákat
Oldalelrendezések
A request() operátor hasonlóan működik, mint a C++ programozási nyelv #include() preprocessor direktívája. Ha ismeri ezt a nyelvet, akkor nem lesz nehéz elsajátítania a következő operátorokat, de még ha nem is ismeri, megpróbáljuk részletesebben leírni ezeknek az operátoroknak a működését. A request() utasítás lecseréli, meghívja azon fájlok tartalmát, amelyek elérési útját és nevét az utasításblokkban megadtuk:
request("elérési út/fájlnév.html");
Ha az fopen_wrapper_SB PHP URL-paraméterei engedélyezve vannak (általában ezek az alapértelmezettek), akkor a fájlt megadhatja a követelmény() utasításban is URL-cím (Uniform Resource Locator) használatával ahelyett, hogy a szükséges fájl helyi elérési útját használná a request() utasítás, például:
$url = http://saját_új_cím/index.phtml;
A request() utasítás nem függvény. Valószínűleg nyelvi konstrukciónak nevezhető. Miért nem tekinthetjük ezt az állítást függvénynek:
A Require() nincs alárendelve egyetlen vezérlőstruktúrának sem;
A Require() nem ad vissza semmilyen értéket, amit a függvény viszont megad.
Ha bármilyen értéket megkísérelünk meghívni a request() utasításból, az hibát eredményez, és megszakítja a további programvégrehajtást.
nem úgy mint tartalmazza megköveteli mindig beolvassa a fájl címsorát, még akkor is, ha nem fut. Ha feltételesen kell belefoglalnia egy fájlt, használja az include() utasítást. Csak arról van szó, hogy a feltételes kifejezések nem tekinthetők hatékonynak, ha a követelmény utasítással dolgozunk, de ha az a sor, amelyen a requre utasítás található, nem kerül végrehajtásra, akkor ezen a címen a fájl egyetlen kódsora sem kerül végrehajtásra. Ez logikus, mivel hozzáférést biztosít a fájlhoz ez az esetés a request() operátoron keresztül történik.
A ciklusvégrehajtási struktúrák nem befolyásolják a request() utasítás viselkedését, bár a végső fájlban található kód továbbra is a ciklus hatálya alá tartozik. Ebből arra a következtetésre juthatunk, hogy az include utasítással ellentétben a request utasítás csak egyszer kerül végrehajtásra.
Ezért/nem helyezhet be egy követelmény() utasítást az összes kísérő utasításával egy ciklus utasításblokkjába, és várhatja meg, hogy ugyanaz a ciklus lefusson eltérő teljesítmény adott operátor minden iterációnál. Ennek kihasználásához javasoljuk az include() utasítás használatát.
Ha egy fájlt a request() utasítással futtatunk, a benne lévő cbd örökli annak a sornak a képességváltozóit, amelyen a requre() végrehajtódik. Az ezen a sorban elérhető bármely változó elérhető lesz a hívott fájlban. Ha egy követelmény utasítás egy függvényen belül van hívó fájl, akkor a hívott fájlban található összes kód úgy fog viselkedni, mintha ebben lenne definiálva
Abban az esetben, ha a request() operátor olyan fájlon dolgozik, amelyet HTTP-n keresztül hívnak meg, és fopen wrappereket használ, és ha az állomás címe a végső fájlt PHP kódként értelmezi, akkor a változók átadhatók a request() operátornak a URL -request mint HTTP Get metódus. Nem ugyanaz. hogy a request utasítás fájlhívása azért van, mert a szkript gyakorlatilag folytatja a szkript végrehajtását a távoli szerveren, és az eredmények ezután bekerülnek a helyi szkriptbe:
/* nem fog működni, mert nem dolgozta fel a szerver */
request("http://my_domain_name/file.txt?varone=1&vartwo=2");
/* nem működik, mert a fájl neve "file.php?varone=1&vartwo=2"
helyire koncentrál fájlrendszer */
request("file.php?varone=1&vartwo=2");
/* hiba nélkül fog működni */
request("http://my_domain_name/test.php?varone=1Svartwo=2");
igényel("fájl.txt");
igényel("fájl.php");
Ezek a példák segítenek vizuálisan megérteni, hogyan kell használni a request() operátort, valamint elkerülni a hibákat a programok létrehozásakor. Ezután megnézzük az include() utasítást, hasonlóan a request() utasításhoz, és a működésének alapelveit.
29 válasz
Van még a követelmény és az include_once is.
Tehát a kérdésed az lenne, hogy...
A request() függvény megegyezik az include() függvénysel, azzal a különbséggel, hogy másképp kezeli a hibákat. Ha hiba történik, funkciót tartalmaz() figyelmeztetést generál, de a szkript továbbra is fut. A Require() végzetes hibát dob, és a szkript leáll.
A request_once() utasítás megegyezik a request() utasítással, azzal a különbséggel, hogy a PHP ellenőrzi, hogy a fájl szerepel-e már benne, és ha igen, akkor nem fogja újra belefoglalni (require).
Azt javaslom, hogy az esetek 99,9%-ában csak a request_once-t használja.
A követelmény vagy az include használata azt jelenti, hogy a kódot nem lehet máshol újra felhasználni, azaz a ténylegesen beírt szkriptekben végrehajtani osztály vagy néhány függvénykönyvtár megadása helyett,
Ha olyan kódot igényel/beleértve, amely helyben fut, akkor erre az eljárási kódra és szüksége van új paradigmát tanulni. Hasonló az objektum orientált programozáshoz, a funkcionális programozáshoz vagy a funkcionális programozáshoz.
Ha már OO-t vagy funkcionális programozást végez, az include_once használata alapvetően elhúzódik, amikor hibákat/hibákat talál a veremben. Tudni szeretné, hogy a do_cool_stuff() függvény nem érhető el, amikor később meghívja, vagy abban a pillanatban, amikor elvárja, hogy elérhető legyen, könyvtárra van szüksége? Általában a legjobb, ha azonnal megtudja, ha valami, amire szüksége van, és amire szüksége van, nem érhető el, ezért csak használja a request_once parancsot.
Alternatív megoldásként a modern OOP-ban automatikusan betölti az osztályokat használat közben.
Különbség az _once függvények és az _once függvények között: Kód nélkül az _once ismét szerepelni fog, míg az _once függvényekkel a PHP nyomon követi a benne foglalt fájlokat, és csak egyszer veszi fel.
Különbség a követelmény és az include között: Ha a kívánt fájl nem található, a PHP végzetes hibát generál, míg az include csak figyelmeztetést ad.
Az include() figyelmeztetést ad, ha nem tartalmazza a fájlt, de a szkript többi része futni fog.
A request() kidobja az E_COMPILE_ERROR parancsot, és leállítja a szkriptet, ha nem tudja tartalmazni a fájlt.
Az include_once() és a request_once() függvények nem tartalmazzák a fájlt másodszor, ha már szerepelt.
Tekintse meg a következő dokumentációs oldalakat:
Amikor a request_once() függvényt használja, a on file segítségével egy másik fájlt is beilleszthet, ha szüksége van az éppen megadott fájlra az aktuális fájlban. Itt a példában a test1.php.
egy másik fájlban pedig a test2.php-t hívtam
amikor kétszer megnézi az m-et, amely a teszt1 fájlt kéri, de a fájl egyszer tartalmazni fogja a test1-et, másodszor pedig figyelmen kívül hagyja. És megállás nélkül egyszer megjelenik a kimenet.
Az "include_once() ` használatakor használhatja a fájlban egy másik fájlt, ha azt szeretné, hogy a fájlt többször is meg kell hívni az aktuális fájlban. Itt a példában van egy test3.php nevű fájlom.
És egy másik fájlban, amelyet test4.php-nek hívtam
mivel az m-t nézi, beleértve a fájlt, a test3 egyszer tartalmazza a fájlt, de leállítja a további végrehajtást.
A különbség a parancsok által generált hibában rejlik. A request esetén valóban szüksége van a használni kívánt fájlra, és ezért E_ERROR-t generál, ha nem található.
A request() megegyezik az include()-val, kivéve a hibát, ez egy végzetes E_ERROR szintű hibát is eredményez.
Az include E_WARNING hibát dob, ha nem sikerül, ami többé-kevésbé néma.
Tehát akkor használja, ha a fájlra szükség van a kód többi részének működéséhez, és azt szeretné, hogy a szkript sikertelen legyen, a fájl nem érhető el.
Most az egyszer() :
Az include_once() olyan esetekben használható, amikor ugyanazt a fájlt egy adott szkript végrehajtása során többször is fel lehet venni és kiértékelni, így ebben az esetben segíthet elkerülni az olyan problémákat, mint a függvény újradefiniálása, újradefiniálása változó értékek stb.
Ugyanez vonatkozik természetesen a request_once() -ra is.
Ezt a kérdést hét éve tették fel, és egyik válasz sem nyújt gyakorlati segítséget ehhez a kérdéshez. A modern PHP programozásban alapvetően csak egyszer használjuk a required_once-t, hogy engedélyezzük az automatikus betöltőt (gyakran a zeneszerző automatikus betöltőjét), és az betölti az összes osztályt és funkciót (a szolgáltatásfájlokat kifejezetten hozzá kell adni a composer.json fájlhoz, hogy az összes többi fájlban elérhető legyen) . Ha valamilyen oknál fogva az osztály nem töltődik be az automatikus betöltőből, akkor a request_once használatával töltse be.
Manapság csak egy nagy töredéket kell felosztani PHP fájl. Ez alapvetően egy nagy tömb definíciója. Ilyen esetekben csak a request_once parancsot használja.
"y"];
Ha a használni kívánt fájl tartalmaz valami végrehajtható fájlt, vagy olyan változókat deklarál, amelyeket szinte mindig használnod kell, mert ha máshol használod a request_once-t, akkor a kód nem fut le és/vagy a változók nem inicializálódnak csendben, ami hibákat okoz. amiket nagyon nehéz észrevenni.
Az include és include_once gyakorlata gyakorlatilag nem használatos.
Az osztály- és függvénydefiníciókat fájlokban kell tárolnia.
Használja a request_once() függvényt a betöltéshez függőségek
A betöltéshez használja a request()-et sablonszerű fájlok.
A betöltéshez használja az include_once() függvényt választható függőségek(osztályok, függvények, konstansok).
A betöltéshez használja az include()-ot opcionális sablonszerű fájlok.
kívánt végzetes hibát (E_COMPILE_ERROR) eredményez, és leállítja a szkriptet.
bekapcsol figyelmeztetést (E_WARNING) ad ki, és a szkript folytatódik.
Operátor igényel_egyszer használható PHP fájl beillesztésére egy másikba, ha előfordulhat, hogy a hívott fájlt többször is bele kell foglalnia.
Ha az a.php egy PHP-szkript, amely meghívja a b.php-t a követelmény_once()-vel, és nem találja a b.php-t, akkor az a.php megszakítja a végrehajtást, ami végzetes hibát okoz.
include()
A megadott fájlt tartalmazza. Figyelmeztetést ad, ha nem találja a fájlt, és nem hajtja végre a többi parancsfájlt
kívánt()
A megadott fájlt tartalmazza. Ez végzetes hibát eredményez, ha nem találja a fájlt, és leáll a végrehajtás
A megadott fájlt tartalmazza. a fájl már benne van, többé nem lesz benne. Figyelmeztetést ad, ha nem találja a fájlt, és nem hajtja végre a többi parancsfájlt.
A megadott fájlt tartalmazza. a fájl már benne van, többé nem lesz benne. Ez végzetes hibát eredményez, ha nem találja a fájlt, és megszakítja a végrehajtást.
megegyezik az include/require értékkel, kivéve, hogy a PHP ellenőrzi, hogy a fájl már szerepel-e benne, és ha igen, akkor ne adja hozzá (kötelező) újra.
A PSR-0/PSR-4 automatikus betöltő korszakában teljesen felesleges lehet bármilyen utasítást használni, ha csak néhány függvényt/osztályt akarsz elérhetővé tenni a kódod számára (természetesen továbbra is használnod kell a request_once parancsot a fájl bootstrapjében és tartalmazzon sablonokat, ha továbbra is PHP-t használ sablonmotorként).
A request() megegyezik az include() -val, kivéve, hogy meghiúsul, ez egy végzetes E_COMPILE_ERROR szintű hibát is eredményez. Más szavakkal, leállítja a szkriptet, míg az include() csak figyelmeztetést (E_WARNING) ad ki, amely lehetővé teszi a szkript folytatását.
Ugyanez igaz az _once() opciókra is.
Az alábbihoz hasonló függvényt használtam:
Függvény doSomething() ( request_once(xyz.php); .... )
Az állandó értékeket rögzítettük az xyz.php-ben.
Meg kell hívnom ezt a doSomething() függvényt egy másik PHP szkriptfájlból.
De megfigyeltem a viselkedést a függvény hurokban történő meghívásakor, az első iterációnál a doSomething() állandó értékeket kapott az xyz.php-n belül, de később a doSomething() minden iterációja nem tudta elérni az xyz-ben deklarált állandó értékeket. .php .
A problémámat úgy oldottam meg, hogy a request_once()-ről átváltottam az include()-ra, a frissített doSomething() kód így néz ki:
Függvény doSomething() ( include(xyz.php); .... )
Most minden iteratív doSomething() hívás megkapja az xyz.php fájlban meghatározott állandókat.
Mikor kell használni a követelményt vagy az include-ot?
A követelmény és az include függvény ugyanazt a feladatot hajtja végre, azaz tartalmazza és kiértékeli a megadott fájlt, de az eltérési követelmény végzetes hibát eredményez, ha a megadott fájl helye érvénytelen, vagy bármilyen hiba esetén, míg az include figyelmeztetést generál, és folytatja a végrehajtást. kód.
Így használhatja a követelmény függvényt abban az esetben, ha a beilleszteni kívánt fájl az a rendszer szíveés óriási hatással lehet a kód többi részére, és használhatja az include függvényt, ha a beilleszteni kívánt fájl egy egyszerű fájl, amely kevésbé fontos kódot tartalmaz.
Személyes ajánlásom pedig (a kevésbé fontos kódoknál) az, hogy a kódodban mindenhol használd a request függvényt, amíg az fejlesztés alatt áll, így hibakeresést végezhetsz a kódon, majd az összes követelmény függvényt az include-ra cserélheted, mielőtt áthelyeznéd a termelésbe, így ha kihagy minden hibát, ez nem lesz hatással a végfelhasználóra, és a kód többi része megfelelően fog futni...
Mikor érdemes a request_once vagy a követelményt használni?
A követelmény és a request_once közötti fő különbség az, hogy a request_once ellenőrzi, hogy a fájl benne van-e vagy sem, ha már benne van, akkor nem fogja tartalmazni a fájlt, míg a request függvény tartalmazza a fájlt, hogy a fájl szerepel-e vagy sem.
Tehát azokban az esetekben, amikor újra és újra hozzá szeretne adni egy kódrészletet, használja a request függvényt, míg ha csak egyszer szeretne kódot beletenni a kódba, használja a request_once függvényt.
Ezek mind a fájlok beillesztésének módjai.
A megkövetelés azt jelenti, hogy kötelező. A Require_once azt jelenti, hogy kötelező lesz, de csak egyszer. Az Include azt jelenti, hogy tartalmazza a fájlt, de nem szükséges a folytatáshoz.
Require "filename" Require_once "filename" Tartalmazza a "fájlnév" kifejezést
Létezik az include_once függvény is, amely egyszer tartalmaz egy fájlt.
include_once "fájlnév"
Ne használjon nagybetűket, amikor a telefonomról írok.
Alapvetően, ha rossz elérési útra van szüksége, a PHP végzetes hibát dob, és a shutdown függvény meghívódik, de ha rossz utat ad meg, a PHP folytatja a végrehajtást, de csak figyelmeztetést ad, hogy a fájl nem létezik.
Az angol szükséges szóból a PHP azt mondja, hogy egy oldal vagy fájl végrehajtása a szükséges fájltól függ.
Tapasztalataim szerint ez a norma, amely fontos fájlokat, például konfigurációs fájlokat, adatbázis-osztályokat és más fontos segédprogramokat igényel.
Bármilyen webhely és bármilyen összetettség fejlesztésekor először a kódírás helyességére kell irányulnia. Például, ha az összes kódot számos fájllal egy oldalon hozza létre, ez zavart és nagy kényelmetlenséget okoz. Ehhez pedig kategorizálnia kell a fájlokat, majd a megfelelő helyeken csatlakoztatnia kell a fő kódhoz. Ezt a módszert - szerepeltetett fájloknak nevezhetjük. Ez egy meglehetősen egyszerű név, de aki először találkozott ezzel a témával, annak nevezheti. És ahhoz, hogy az összes mellékelt fájlt egyetlen kódba gyűjthesse, alkalmaznia kell az előző cikkben leírtakat, vagy használja az utasításokat igényel és igényel_egyszer amelyeket ebben a szövegben ismertetünk.
Gyakorlati utasítások igényel és igényel_egyszer ugyanazokat a funkciókat hajtja végre, mint az utasítások include és include_once, néhány kivételtől eltekintve.
Ezen utasítások szintaxisa a következő:
Require_once 'config.php'; - beállítási fájl
request_once 'fejléc.php'; - webhely fejléce
igényel 'left.php'; - bal oldalsáv
igényel 'content.php'; - weboldal tartalma
igényel 'lábláb.php'; - webhely lábléce
A különbség pedig a következő. A kód feldolgozásakor a PHP először belső reprezentációvá alakítja át a szkriptet, majd soronként kezdi feldolgozni a kódot. És ha a PHP megtalálja a kódban az utasításban szereplő fájlt tartalmazza, majd a fájl betöltése után teljesen átvált annak végrehajtására, a fájlt belső reprezentációvá alakítja, és csak ezután hajtja végre lépésről lépésre ...
És itt az utasítás igényelnek kicsit másképp működik. A script végrehajtása előtt lefordítják a segítségével összekapcsolt fájlt, vagyis a teljes kód feldolgozásakor ez a fájl már le van fordítva!!! És innen a következtetés - az utasítás által összekapcsolt fájlok igényelnek- gyorsabban fog működni. És nekem például ez az utasítás előnyösebb. De persze van egy DE! Amikor a böngésző betölti az oldalt, előfordulhat, hogy az internet meghiúsul, és a felhasználó csak az oldalnak azt a részét láthatja, amelyet sikerült betölteni. Illetve valamilyen feldolgozási hiba esetén a feldolgozás nem megy tovább a leakasztott fájlnál. De ez ritkán fordul elő egy webhelyen, ezért ez az utasítás továbbra is előnyösebb.
Majdnem elfelejtettem. Utasítás igényel_egyszer- azt a szerepet is betölti, hogy a fájlt csak egyszer tartalmazza a közös kódban, hogy ne legyen ismétlés.
Ez nagyjából minden, amit tudnia kell arról, hogyan lehet fájlokat belefoglalni az általános kódolási folyamatba a kezdéshez. A mélyebb tudás általában a tanulás folyamatában és az igények függvényében érkezik, amit természetesen nem tudok megjósolni. Köszönöm megtisztelő figyelmüket és elnézést kérünk, hogy a szerző bemutatta ezeket a témákat.
| Hétfő | kedd | Házasodik | cs | Péntek | Ült | Nap |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 8 | 9 | 10 | 11 | 12 | 13 | 14 |
| 15 | 16 | 17 | 18 | 19 | 20 | 21 |
| 22 | 23 | 24 | 25 | 26 | 27 | 28 |
| 29 | 30 | 31 | ||||
PHP include utasítás, php include_once utasítás, include fájlok. Egy egyszerű dinamikus webhely vagy fejlettebb programok fejlesztése lehetetlen
Az oldalmotor felépítése, miből áll az oldalmotor, a webhelyvezérlő panel, sablonmotor. Egy korábbi cikkben ezt leírták
Mi az a webhelymotor, hogyan készítsünk webhelymotort, webhelykezelő rendszert php-ben. Hogy megértsük, mi az
A kód olvashatóbbá tétele érdekében például elhelyezheti a függvény- és/vagy osztálydefiníciókat egy külön fájlban. A fájlok PHP-ben való szerepeltetésének lehetőségét négy nyelvi utasítás biztosítja:
Mind a négy utasítás felvehet egy helyi fájlnevet paraméterként. Az include és a request utasítások működésükben nagyon hasonlóak, és csak a kért erőforrás beszerzésének lehetetlenségére adott válaszukban különböznek. Például, ha egy erőforrás nem érhető el, az include és include_once adjon ki figyelmeztetést, és próbálja meg folytatni a program végrehajtását. A request és a request_once leállítja az adott oldal feldolgozását, ha a kért erőforrás nem érhető el.
Az include utasítás lehetővé teszi más szkriptek felvételét és csatolását a PHP szkriptjéhez. A program futtatásakor az értelmező egyszerűen lecseréli az utasítást a mellékelt fájl tartalmára. Lássuk, hogyan működik, hozz létre egy add.php nevű fájlt, és írd be:
Most hozzunk létre egy másik fájlt, és nevezzük el például test.php-nek, amelybe belefoglaljuk az add.php fájlt:
\$var2 = $var2" ?>
Amint a példából is látható, az include utasítás csatolja a benne lévő fájl tartalmát, aminek köszönhetően a programod hozzáfér más változókhoz, függvényekhez, osztályokhoz stb.
Megjegyzés: Bármilyen nevet adhat az include fájloknak, de mindig adja hozzá a .php kiterjesztést, mert ha más kiterjesztést használ, a támadók lekérhetik a fájlt, és a webszerver visszaadja a szövegét. Ez biztonsági kockázatot jelent, mivel a jelszavak vagy a program működése nyilvánosságra kerülhet, így a támadók egy hátsó ajtót kaphatnak. Ennek elkerülése érdekében az include fájlokat a PHP értelmezőnek kell feldolgoznia.
Ha egy fájl szerepel egy függvényben, akkor a benne lévő fájlban lévő összes kód úgy fog viselkedni, mintha az adott függvényen belül lenne definiálva, azaz. a kód helyi hatályú lesz. Írjuk át egy kicsit az előző példát:
Most adjunk hozzá egy függvényt a test.php fájlhoz:
Globális hatókörben: $var1"; ?>
Mivel a $var1 globális változót a függvényen belül deklaráltuk, a globális hatókörben is elérhetővé válik.
A fájlok a fájl megadott elérési útja alapján kerülnek bele, ha az elérési út nincs megadva, akkor az include_path direktívában megadott elérési út kerül felhasználásra (a konfigurációs fájl php.ini). Ha a fájl nem található az include_path -ban megadott elérési úton, az include utasítás megpróbálja ellenőrizni az aktuális munkakönyvtárat, ahol az include fájl szkriptje található, ha az include konstrukció nem találja a fájlt, figyelmeztetés jelenik meg.
Ha meg van adva egy elérési út - függetlenül attól, hogy abszolút vagy relatív (az aktuális könyvtárhoz képest, ahol az include script található) - az include_path direktíva figyelmen kívül marad.
Az include_once viselkedése megegyezik az include utasítással, azzal az egyetlen különbséggel, hogy ha a fájl kódja már egyszer szerepel, akkor az nem kerül bele, és újra lefut. Ez segít elkerülni a függvények, változók stb. újradefiniálásának problémáját. Hogy jobban megértsük, hogyan működik, íme egy példa:
A test.php fájlban a következő kódot próbáljuk végrehajtani:
Ez hibaüzenetet fog eredményezni, mivel a funkciók nem bírálhatók felül. Az ilyen jellegű hibák elkerülése érdekében használja az include_once utasítást. Írjuk át a kódot a test.php fájlba:
A követelmény és a követelmény_egyszer utasítások azonosan működnek az include és include_once tekintetében, egy különbség kivételével. Ha az include fájl nem található, a szkript végrehajtása leáll, miközben az include és include_once figyelmeztetést ad ki, és folytatja a szkript végrehajtását.
Tipp : próbáld meg egyáltalán ne használni az include és a követelményt, használd a megfelelőit az _once utótaggal. Ez megkönnyíti egy nagy és összetett program viszonylag független modulokra bontását.
