Kung ang mga function ay inilagay sa isang hiwalay na file, pagkatapos ay dalawang pahayag, nangangailangan at isama, ay nagbibigay-daan sa iyo upang ikonekta ito. Ang mga pahayag ay may sumusunod na format:
kailangan(<Имя файла>);
nangangailangan<Имя файла>;
isama (<Имя файла>);
isama<Имя файла>;
Ilipat natin ang function na f_Sum() sa isang hiwalay na file ( Listahan 17) at ikonekta ito gamit ang require operator ( Listahan 16).

Listahan 16. Gamit ang pahayag na kailangan

Listahan 17. Mga nilalaman ng script.inc file

Maaari kang lumikha ng script.inc file, halimbawa, gamit ang Notepad++. Dapat tandaan na ang isang kasamang file ay maaaring magkaroon ng anumang extension, bagama't karaniwan na bigyan ang mga kasamang file ng extension inc (para sa "isama").
Subukan nating buksan ang script.inc file gamit ang isang Web browser. Bilang resulta, ang source code ay ipapakita sa window ng Web browser:

Para sa kadahilanang ito, dapat mong ilagay ang mga kasamang file sa isang direktoryo na naa-access lamang sa script ngunit hindi naa-access sa Internet. Sa pag-install at pag-configure ng PHP, tinukoy namin ang lokasyon ng mga kasamang file sa include_path na direktiba ng php.ini file:

Dito, na pinaghihiwalay ng mga semicolon, mayroong dalawang lugar upang maghanap ng mga kasamang file:
□ . (tuldok) - sa parehong folder bilang executable file;
□ C:\php5\includes - sa includes folder (c:\php5\includes).
Sa madaling salita, kung hindi ito makakita ng kasamang file sa parehong folder ng executable file, maghahanap ang interpreter sa mga kasamang folder (c:\php5\includes).
Maaari mo ring i-save ang kasamang file na may extension ng php. Sa kasong ito, hindi ipapakita ang source code sa window ng Web browser.

Kung ang kasamang file ay naglalaman ng executable code, dapat na tukuyin ang mga PHP descriptor. Kung hindi, ang PHP code ay ipapakita bilang plain text, at kapag tumatawag sa mga function na tinukoy dito, isang mensahe ng error ang ipapakita:
function f_Sum($x, $y=2) ( return ($x + $y); )
Malalang error: Tumawag sa hindi natukoy na function f_Sum() in
C:\Apache2\htdocs\index.php sa linya 9
Sa madaling salita, maaaring walang PHP code ang kasamang file. Halimbawa, ilagay natin ang header at ang f_Sum() function sa file header.inc ( Listahan 19), at ang footer sa file footer.inc ( listahan 20). Pagkatapos ay ikokonekta namin ang mga file na ito sa pangunahing script ( listahan 18).

Listahan 18. Paglalagay ng HTML code sa isang file na kasama

Listahan 19. Mga nilalaman ng header.inc file

Listahan 20. Mga nilalaman ng footer.inc file

SA listahan 21 Ang source HTML code ay ipinapakita pagkatapos isagawa ang nakaraang programa.

Listahan 21. HTML Source Code

7

Sa ganitong paraan maaari kang lumikha ng mga template para sa maraming mga pahina. Ang interpreter, kapag nakatagpo ng isang hinihinging pahayag, ay gagawing bahagi ng pahina ang mga nilalaman ng kasamang file. Kung hindi ma-load ang file, bubuo ang statement ng hindi mababawi na error at magwawakas ang script.
Sa halip na ang requirement na pahayag, maaari mong gamitin ang include statement. Kung ang kasamang file ay hindi natagpuan, ang pahayag ay magpapakita ng isang mensahe ng error, ngunit ang script ay patuloy na ipapatupad. Kung ang file na ito ay naglalaman ng mga function, ang bawat function na tawag mula sa file na ito ay bubuo din ng error.

Nagbabalik ng true ang include statement kung na-load ang file, at false kung may error. Maaari mong pigilan ang mensahe ng error gamit ang @ operator ( Listahan 22).

Listahan 22. Pagpigil sa Mensahe ng Error

29 na tugon

Mayroon ding nangangailangan at isama_isang beses .

Kaya dapat ang tanong mo ay...

1. Kailan ko dapat gamitin ang require at isama?
2. Kailan ko dapat gamitin ang require_once vs require

Ang require() function ay magkapareho sa include() maliban na iba ang paghawak nito sa mga error. Kung may naganap na error, ang include() function ay bubuo ng babala, ngunit ang script ay magpapatuloy sa pagpapatupad. Ang Require() ay bumubuo ng isang nakamamatay na error at huminto ang script.

Ang require_once() statement ay kapareho ng require(), maliban na ang PHP ay susuriin kung ang file ay naisama na at, kung gayon, ay hindi na isasama (kailangan) muli.

Ang aking mungkahi ay gamitin lamang ang require_once 99.9% ng oras.

Ang paggamit ng require o isama sa halip ay nagpapahiwatig na ang iyong code ay hindi magagamit muli sa ibang lugar, ibig sabihin, ang mga script na talagang tina-type mo isagawa, sa halip na magbigay ng klase o ilang function na library,

Kung kailangan mo/kasama ang code na tumatakbo sa lugar, ito ay procedural code at kailangan mo matuto ng bagong paradigm. Katulad ng object-oriented programming, functional programming o functional programming.

Kung gumagawa ka na ng OO o functional programming, ang paggamit ng include_once ay kadalasang maaantala kapag nakakita ka ng mga bug/bug sa stack. Gusto mong malaman na ang do_cool_stuff() function ay hindi available kapag tinawagan mo ito sa ibang pagkakataon, o sa sandaling inaasahan mong magiging available ito, nangangailangan ng library? Sa pangkalahatan, mas mahusay na malaman nang maaga kung ang isang bagay na kailangan mo at kung ano ang aasahan ay hindi magagamit, kaya gamitin lang require_once .

Bilang kahalili, sa modernong OOP, i-autoload ang iyong mga klase kapag ginamit.

Pagkakaiba sa pagitan ng _once function at _once function: Kapag walang code _once ay papaganahin muli, samantalang sa _once functions, sinusubaybayan ng PHP ang mga kasamang file at paganahin lamang ito nang isang beses.

Pagkakaiba sa pagitan ng nangangailangan at kasama: Kung ang kinakailangang file ay hindi nahanap, ang PHP ay bubuo ng isang nakamamatay na error, samantalang ang pagsasama ay magdudulot lamang ng babala.

include() ay magbibigay ng babala kung hindi nito maisama ang file, ngunit ang natitirang bahagi ng script ay tatakbo.

require() ay magtapon ng E_COMPILE_ERROR at ihihinto ang script kung hindi nito maisama ang file.

Ang mga function na include_once() at require_once() ay hindi isasama ang file sa pangalawang pagkakataon kung naisama na ito.

Tingnan ang mga sumusunod na pahina ng dokumentasyon:

Sa tuwing gagamit ka ng require_once() , maaari mo itong gamitin sa isang file upang magsama ng isa pang file kung kailangan mo ang file na iyong tinukoy sa kasalukuyang file. Dito sa halimbawa mayroon akong test1.php.

at sa isa pang file na tinawag kong test2.php

kapag tumingin ka m, na nangangailangan ng file test1 dalawang beses, ngunit ang file ay isasama ang test1 isang beses at para sa pagtawag sa pangalawang pagkakataon ito ay hindi papansinin. At nang walang tigil ay ipapakita nito ang output nang isang beses.

Sa tuwing gagamit ka ng "include_once()` maaari itong gamitin sa isang file upang magsama ng isa pang file kung kailangan mo ang file na tinatawag nang higit sa isang beses sa kasalukuyang file. Dito sa halimbawa ay mayroon akong file na tinatawag na test3.php.

At sa isa pang file na tinawag kong test4.php

dahil tinitingnan mo ang m kasama ang file test3 ay isasama ang file nang isang beses ngunit itigil ang karagdagang pagpapatupad.

Ang pagkakaiba ay ang error na nabuo ng mga utos. Sa nangangailangan ito ay talagang nangangailangan ng file na gusto mong gamitin at sa gayon ay bumubuo ng E_ERROR kung hindi ito matagpuan.

require() ay magkapareho sa isama() maliban sa kabiguan ay magreresulta din sa isang nakamamatay na antas ng error E_ERROR .

isama ay bumubuo ng isang E_WARNING error kung ito ay nabigo, na kung saan ay higit pa o hindi gaanong tahimik.

Kaya gamitin ito kung kailangan ang file para tumakbo ang natitirang code at gusto mong mabigo ang script na hindi available ang file.

Para sa *_once() :

Ang include_once() ay maaaring gamitin sa mga kaso kung saan ang parehong file ay maaaring isama at masuri nang higit sa isang beses sa panahon ng isang partikular na pagpapatupad ng script, kaya sa kasong ito ay makakatulong ito na maiwasan ang mga problema tulad ng pag-override ng function, pag-override ng variable na halaga, atbp. d.

Ang parehong naaangkop sa require_once() , siyempre.

Ang tanong na ito ay tinanong pitong taon na ang nakakaraan at wala sa mga sagot ang nagbibigay ng anumang praktikal na tulong sa bagay na ito. Sa modernong PHP programming, karaniwang ginagamit mo ang required_once nang isang beses lamang upang paganahin ang iyong autoloader (madalas ang autoloader ng kompositor) at ilo-load nito ang lahat ng iyong mga klase at function (dapat na tahasang idagdag ang mga function na file sa composer.json upang maging available sa lahat ng iba pang mga file). Kung sa ilang kadahilanan ay hindi naglo-load ang iyong klase mula sa autoloader, ginagamit mo ang require_once para i-load ito.

Sa mga araw na ito kailangan mo lamang na hatiin ang isang malaking tipak ng isang PHP file. Ito ay karaniwang ang kahulugan ng isang malaking array. Sa ganitong mga kaso ginagamit mo lang require require_once .

"y"];

Kung ang file na iyong gagamitin ay naglalaman ng isang bagay na maipapatupad o nagdedeklara ng ilang mga variable, halos palaging kailangan mong gumamit ng require , dahil kung gagamit ka ng require_once sa ibang lugar ay hindi ipapatupad ang iyong code at/o ang iyong mga variable ay hindi tahimik na magpapagana, nagiging sanhi ng mga error na talagang mahirap tukuyin.

Ang pagsasanay ng isama at isama_isang beses ay halos hindi ginagamit.

Dapat kang mag-imbak ng mga kahulugan ng klase at function sa mga file.

Gumamit ng require_once() para mag-load dependencies

Gumamit ng require() para mag-load tulad ng template na mga file.

Gamitin ang include_once() para mag-load mga opsyonal na dependencies(mga klase, function, constants).

Gamitin ang include() para mag-load opsyonal na mga file na tulad ng template.

kinakailangan ay magreresulta sa isang nakamamatay na error (E_COMPILE_ERROR) at ihihinto ang script.

i-on ay magbibigay ng babala (E_WARNING) at magpapatuloy ang script.

Operator nangangailangan_minsan ay maaaring gamitin upang isama ang isang PHP file sa loob ng isa pa kapag maaaring kailanganin mong isama ang tinatawag na file nang higit sa isang beses.

Kung ang a.php ay isang script ng PHP na tumatawag sa b.php na may require_once(), at hindi mahanap ang b.php, hihinto ang a.php sa pag-execute, na nagdudulot ng nakamamatay na error.

isama ang()

Naglalaman ito ng tinukoy na file. Magbibigay ito ng babala kung hindi nito mahanap ang file at isagawa ang natitirang mga script

kinakailangan()

Naglalaman ito ng tinukoy na file. Magtatapon ito ng nakamamatay na error kung hindi nito mahanap ang file at hihinto sa pag-execute

Naglalaman ito ng tinukoy na file. kasama na ang file, hindi na isasama. Nagbibigay ito ng babala kung hindi nito mahanap ang file at isagawa ang natitirang mga script.

Naglalaman ito ng tinukoy na file. kasama na ang file, hindi na isasama. Magtatapon ito ng nakamamatay na error kung hindi nito mahanap ang file at hihinto sa pag-execute.

Parehong isama/kailangan, maliban na ang PHP ay nagsusuri upang makita kung ang file ay naisama na, at kung gayon, huwag na itong isama (kinakailangan) muli.

Sa panahon ng mga autoloader ng PSR-0/PSR-4, maaaring hindi na kailangang gumamit ng anumang mga pahayag kung ang kailangan mo lang ay gawing available ang ilang function/klase sa iyong code (siyempre kailangan mo pa ring gumamit ng require_once sa iyong file bootstrap at isama ang mga template kung gumagamit ka pa rin ng PHP bilang iyong template engine).

require() ay magkapareho sa isama() maliban sa kabiguan ay magreresulta din sa isang nakamamatay na antas ng error E_COMPILE_ERROR . Sa madaling salita, ihihinto nito ang script, samantalang ang include() ay naglalabas lamang ng babala (E_WARNING) na nagpapahintulot sa script na magpatuloy.

Ang parehong ay totoo para sa _once() na mga opsyon.

Ginamit ko ang function tulad ng sa ibaba:

Function doSomething() ( require_once(xyz.php); .... )

Ang mga patuloy na halaga ay naayos sa xyz.php.

Kailangan kong tawagan itong doSomething() function mula sa isa pang PHP script file.

Ngunit naobserbahan ko ang pag-uugali kapag tinawag ang function na ito sa isang loop, para sa unang pag-ulit na doSomething() ay nakakakuha ng mga pare-parehong halaga sa loob ng xyz.php ngunit sa paglaon ang bawat pag-ulit ng doSomething() ay hindi nakakuha ng mga pare-parehong halaga na idineklara sa xyz. php .

Nalutas ko ang aking problema sa pamamagitan ng paglipat mula sa require_once() upang isama ang() , ang na-update na doSomething() code ay ganito ang hitsura:

Function doSomething() ( include(xyz.php); .... )

Ngayon ang bawat umuulit na tawag sa doSomething() ay tumatanggap ng mga constant na tinukoy sa xyz.php .

Kailan mo dapat gamitin ang nangangailangan o isama?

Ang mga function na nangangailangan at kasama ay gumaganap ng parehong gawain, iyon ay, isama at suriin ang tinukoy na file, ngunit ang pagkakaiba na kinakailangan ay magreresulta sa isang nakamamatay na error kung ang tinukoy na lokasyon ng file ay hindi wasto o para sa anumang error, samantalang ang kasama ay bubuo ng babala at magpapatuloy pagpapatupad ng code.

Kaya maaari mong gamitin ang kinakailangan function kung sakaling ang file na sinusubukan mong isama ay puso ng sistema at maaaring magkaroon ng malaking epekto sa natitirang bahagi ng code, at maaaring gusto mong gamitin ang function na kasama kapag ang file na sinusubukan mong isama ay isang simpleng file na naglalaman ng hindi gaanong mahalagang code.

At ang aking personal na rekomendasyon (para sa hindi gaanong mahalagang code) ay gamitin ang kinakailangan na function sa lahat ng dako sa iyong code habang ito ay nasa pag-unlad, upang ma-debug mo ang code, at pagkatapos ay palitan ang lahat ng mga kinakailangang function na may kasama bago ito ilipat sa produksyon upang kung napalampas mo ang anumang mga error na hindi ito makakaapekto sa end user at ang natitirang code ay ipapatupad nang tama...

Kailan mo dapat gamitin ang require_once o require ?

Ang pangunahing pagkakaiba sa pagitan ng require at require_once ay require_once ay susuriin kung ang file ay kasama o hindi, kung ito ay kasama na pagkatapos ay hindi ito isasama ang file samantalang ang require function ay isasama ang file kung ang file ay kasama o hindi.

Kaya, sa mga kaso kung saan gusto mong magdagdag ng isang piraso ng code nang paulit-ulit, gamitin ang function na nangangailangan, samantalang kung gusto mong isama ang ilang code nang isang beses lamang sa iyong code, gumamit ng require_once.

Ito ang lahat ng mga paraan upang maisama ang mga file.

Ang kailangan ay nangangahulugan na ito ay kinakailangan. Nangangahulugan ang Require_once na kakailanganin ito, ngunit isang beses lang kinakailangan. Isama ay nangangahulugang isasama nito ang file, ngunit hindi ito kailangan upang magpatuloy.

Mangailangan ng "filename" Require_once "filename" Isama ang "filename"

Mayroon ding feature na include_once, na kasama ang file nang isang beses.

Isama ang_once "filename"

Huwag gumamit ng malalaking titik kung saan ako nagsusulat sa aking telepono.

Karaniwan, kung nais mo ang maling landas, ang PHP ay naghagis ng isang nakamamatay na error at ang shutdown function ay tinatawag, ngunit kapag binuksan mo ang maling landas, ang PHP ay magpapatuloy sa pagpapatupad, ngunit ito ay magpapakita lamang ng babala na ang file ay hindi umiiral.

Mula sa salitang Ingles na kinakailangan, sinasabi ng PHP na ang pagpapatupad ng isang pahina o file ay nakasalalay sa kinakailangang file.

Sa aking karanasan, ito ang pamantayan, na nangangailangan ng mahahalagang file tulad ng mga file ng pagsasaayos, mga klase sa database, at iba pang mahahalagang kagamitan.

Kapag bumubuo ng anumang website at anumang kumplikado, kailangan mo munang tumuon sa kawastuhan ng code. Halimbawa, kung gagawin mo ang lahat ng code na may maraming mga file sa isang pahina, hahantong ito sa pagkalito at malaking abala. At upang gawin ito, kailangan mong ayusin ang mga file sa mga kategorya, at pagkatapos ay ikonekta ang mga ito sa pangunahing code sa mga tamang lugar. Ang pamamaraang ito ay maaaring tawaging kasama na mga file. Ito ay isang medyo simpleng pangalan, ngunit para sa isang taong nakatagpo ng paksang ito sa unang pagkakataon, maaari itong tawaging ganoon. At para makolekta ang lahat ng kasamang file sa isang code, kailangan mong ilapat ang inilarawan sa nakaraang artikulo, o gamitin ang mga tagubilin nangangailangan at nangangailangan_minsan na inilalarawan sa tekstong ito.

Mga praktikal na tagubilin nangangailangan at nangangailangan_minsan gumanap ng parehong mga function tulad ng mga tagubilin isama at isama_isang beses, maliban sa ilang puntos.

Ang syntax para sa mga tagubiling ito ay:

Require_once 'config.php'; - file ng mga setting
require_once 'header.php'; - header ng site
nangangailangan ng 'left.php'; - kaliwang sidebar
nangangailangan ng 'content.php'; — nilalaman ng site
nangangailangan ng 'footer.php'; - footer ng site

At ang pagkakaiba ay ito. Kapag nagpoproseso ng code, kino-convert muna ng PHP ang script sa isang panloob na representasyon, pagkatapos nito ay magsisimulang iproseso ang code sa bawat linya. At kung nakahanap ang PHP ng isang file sa code na kasama ng pagtuturo isama, pagkatapos pagkatapos i-load ang file ay ganap itong lumipat sa pagpapatupad nito, kino-convert ang file sa isang panloob na representasyon, at pagkatapos ay ipapatupad ito nang sunud-sunod...

Narito ang mga tagubilin nangangailangan gumagana nang medyo naiiba. Ang file na konektado sa tulong nito ay isinalin bago ang script ay naisakatuparan, sa madaling salita, sa oras ng pagproseso ng lahat ng code, ang file na ito ay naisalin na!!! At samakatuwid ang konklusyon - mga file na konektado sa pamamagitan ng mga tagubilin nangangailangan- gagana nang mas mabilis. At para sa akin, halimbawa, ang pagtuturo na ito ay mas kanais-nais. Pero syempre, may PERO! Kapag nag-load ang browser ng page, maaaring mag-crash ang Internet at makikita lang ng user ang bahaging iyon ng page na na-load na. O kung mayroong ilang uri ng pagkabigo sa pagproseso, ang pagproseso ay hindi magpapatuloy sa kabila ng nakapirming file. Ngunit ito ay bihirang mangyari sa isang website, kaya ang pagtuturo na ito ay mas mainam pa rin.

Muntik ko nang makalimutan. Mga tagubilin nangangailangan_minsan- nagsisilbi rin ang papel na isama ang isang file sa pangkalahatang code nang isang beses lamang, upang walang mga pag-uulit.

Halos iyon lang ang kailangan mong malaman tungkol sa kung paano ikonekta ang mga file sa pangkalahatang daloy ng pagsulat ng code. Ang mas malalim na kaalaman ay kadalasang dumarating sa proseso ng pag-aaral at depende sa mga pangangailangan, na natural na hindi ko mahuhulaan. Salamat sa iyong pansin at paumanhin sa pagtatanghal ng may-akda ng mga paksang ito.

ADVERTISING

Ang include statement sa PHP, ang include_once na statement sa php, kasama ang mga file. Kapag bumubuo ng isang simpleng dynamic na website, o mas advanced na mga programa, imposible

Ang istraktura ng site engine, kung ano ang binubuo ng site engine, ang control panel ng site, ang template engine. Sa nakaraang artikulo ay inilarawan iyon

Ano ang isang website engine, kung paano gumawa ng isang website engine, isang website management system sa PHP. Upang maunawaan kung ano ito

Ang pagbuo ng nangangailangan ng mga inklusyon

Disenyo nangangailangan nagbibigay-daan sa iyong magsama ng mga file sa isang PHP script upang magpatakbo ng isang PHP script. Pangkalahatang syntax nangangailangan ganito:

nangangailangan ng filename;

Kapag sinimulan (tumpak sa pagsisimula, hindi sa panahon ng pagpapatupad!) ng programa, papalitan lang ng interpreter ang pagtuturo ng mga nilalaman ng file_name (ang file na ito ay maaari ding maglaman ng PHP script, naka-frame, gaya ng dati, na may mga tag At ?> ). Bukod dito, gagawin ito kaagad bago simulan ang programa (hindi katulad isama, na tinatalakay sa ibaba). Maaari itong maging maginhawa para sa pagsasama ng iba't ibang mga pahina ng template na may HTML code sa output ng script. Narito ang isang halimbawa: