Header.html ფაილი:

Footer.html ფაილი:
მთავარი კომპანია, 2005 წ.

Script.php ფაილი
მოითხოვს "header.htm";
// სკრიპტი აჩვენებს თავად დოკუმენტის ნაწილს
მოითხოვს "footer.htm";
?>

ასე რომ, დიზაინი მოითხოვსსაშუალებას გაძლევთ შეიკრიბოთ PHP სკრიპტები რამდენიმე ცალკეული ფაილიდან, რომლებიც შეიძლება იყოს მსგავსი html-გვერდები და php- სკრიპტები.

დიზაინი მოითხოვსმხარს უჭერს ჩანართებს წაშლილი ფაილები(PHP 4.3.0-დან). მაგალითად:

// შემდეგი მაგალითი არ მუშაობს, რადგან ის ცდილობს ლოკალური ფაილის ჩართვას
მოითხოვს "file.php?foo=1&bar=2" ;
// მუშაობს შემდეგი მაგალითი
მოითხოვს ;
?>

! დიზაინი მოითხოვსსაშუალებას გაძლევთ ჩართოთ დისტანციური ფაილები, თუ ეს ფუნქცია ჩართულია კონფიგურაციის ფაილი PHP.

დისტანციური ფაილების ჩათვლით

PHP საშუალებას გაძლევთ იმუშაოთ URL ობიექტებთან, როგორიცაა რეგულარული ფაილები. ნაგულისხმევად ხელმისაწვდომი პაკერები გამოიყენება დისტანციურ ფაილებთან მუშაობისთვის ftp პროტოკოლიან http.

თუ "fopen-wrapper URLs" შედის PHP-ში (როგორც ნაგულისხმევი კონფიგურაციაში), შეგიძლიათ მიუთითოთ ფაილი, რომელიც უნდა იყოს ჩართული. URL-ის გამოყენებით(HTTP-ის საშუალებით), ადგილობრივი ბილიკის ნაცვლად. თუ სამიზნე სერვერი განმარტავს სამიზნე ფაილს, როგორც PHP კოდს, ცვლადები შეიძლება გადაეცეს მოიცავს ფაილს URL მოთხოვნის სტრიქონის გამოყენებით, როგორც HTTP GET-ში. მკაცრად რომ ვთქვათ, ეს არ არის იგივე, რაც ფაილის ჩართვა და მისი მემკვიდრეობითი საწყისი ფაილის ცვლადების არეალი; რადგან სცენარი მუშაობს დისტანციური სერვერიდა შედეგი შედის ადგილობრივ სკრიპტში.

იმისათვის, რომ ფაილების დისტანციური ჩართვა იყოს ხელმისაწვდომი, თქვენ უნდა დააყენოთ კონფიგურაციის ფაილში (php.ini) allow_url_fopen=1.

გთხოვთ გაითვალისწინოთ: PHP ვერსიები Windows-ის ვერსიები PHP 4.3.0-მდე არ არის მხარდაჭერილი ამ ფუნქციით დისტანციური ფაილების გამოყენების უნარს, მაშინაც კი, თუ allow_url_fopen ოფცია ჩართულია.

/* ეს ვარაუდობს, რომ www.example.com კონფიგურირებულია parse.php-ზე
* ფაილები და არა .txt ფაილები. ასევე "მუშაობს" აქ ნიშნავს, რომ ცვლადები
* $foo და $bar ხელმისაწვდომია თანდართულ ფაილში. */

//არ ​​იმუშავებს, რადგან file.txt არ არის დამუშავებული www.example.com-ის მიერ, როგორიცაა PHP
მოითხოვს "http://www.example.com/file.txt?foo=1&bar=2";

// არ იმუშავებს, რადგან ის ეძებს ფაილს "file.php?foo=1&bar=2" ლოკალურში
// ფაილური სისტემა.
მოითხოვს "file.php?foo=1&bar=2" ;

// მუშაობს შემდეგი მაგალითი:
მოითხოვს "http://www.example.com/file.php?foo=1&bar=2";

$foo = 1;
$bar = 2;
მოითხოვს "file.txt" ; // სამუშაოები
მოითხოვს "file.php" ; // სამუშაოები

?>

თუ ფუნქციები მოთავსებულია ცალკე ფაილი, მაშინ ორი ოპერატორი მოითხოვს და მოიცავს საშუალებას გაძლევთ დააკავშიროთ იგი. განცხადებებს აქვს შემდეგი ფორმატი:
მოითხოვს (<Имя файла>);
მოითხოვს<Имя файла>;
მოიცავს (<Имя файла>);
მოიცავს<Имя файла>;
მოდით გადავიტანოთ f_Sum() ფუნქცია ცალკე ფაილში ( ჩამონათვალი 17) და დააკავშირეთ საჭირო ოპერატორის გამოყენებით ( ჩამონათვალი 16).

ჩამონათვალი 16. მოთხოვნის განცხადების გამოყენება

ჩამონათვალი 17. script.inc ფაილის შინაარსი

თქვენ შეგიძლიათ შექმნათ script.inc ფაილი, მაგალითად, Notepad++-ის გამოყენებით. უნდა აღინიშნოს, რომ ჩართულ ფაილს შეიძლება ჰქონდეს ნებისმიერი გაფართოება, თუმცა ჩვეულებრივია ჩართული ფაილების მიცემა გაფართოება inc (ამისთვის "include").
შევეცადოთ გავხსნათ script.inc ფაილი ვებ ბრაუზერის გამოყენებით. შედეგად, ბრაუზერის ფანჯარა გამოჩნდება წყარო კოდი:

ამ მიზეზით, თქვენ უნდა მოათავსოთ ჩათვლით ფაილები დირექტორიაში, რომელიც ხელმისაწვდომია მხოლოდ სკრიპტისთვის, მაგრამ მიუწვდომელია ინტერნეტით. PHP-ის ინსტალაციისა და კონფიგურაციისას, ჩვენ დავაზუსტეთ ჩართული ფაილების მდებარეობა php.ini ფაილის include_path დირექტივაში:

აქ, მძიმით გამოყოფილი, არის ორი ადგილი, სადაც უნდა მოძებნოთ თანდართული ფაილები:
□ . (წერტილი) - იმავე საქაღალდეში, სადაც შესრულებადი ფაილი;
□ C:\php5\includes - მოიცავს საქაღალდეში (c:\php5\ მოიცავს).
სხვა სიტყვებით რომ ვთქვათ, თუ ის ვერ იპოვის მოიცავს ფაილს იმავე საქაღალდეში, სადაც შესრულებადი ფაილი, თარჯიმანი მოძებნის მოიცავს საქაღალდეში (c:\php5\includes).
თქვენ ასევე შეგიძლიათ შეინახოთ ჩათვლით ფაილი php გაფართოება. ამ შემთხვევაში, წყაროს კოდი არ გამოჩნდება ბრაუზერის ფანჯარაში.

თუ ჩართული ფაილი შეიცავს შესრულებად კოდს, მაშინ უნდა იყოს მითითებული PHP დესკრიპტორები. წინააღმდეგ შემთხვევაში, PHP კოდი გამოჩნდება უბრალო ტექსტის სახით და მასში განსაზღვრული ფუნქციების გამოძახებისას გამოჩნდება შეცდომის შეტყობინება:
ფუნქცია f_Sum ($x, $y=2) ( დაბრუნება ($x + $y); )
ფატალური შეცდომა: გამოძახება დაუზუსტებელ ფუნქციაზე f_Sum() in
C:\Apache2\htdocs\index.php მე-9 ხაზზე
სხვა სიტყვებით რომ ვთქვათ, ჩართული ფაილი შეიძლება არ შეიცავდეს PHP კოდს. მაგალითად, ჩავდოთ header და f_Sum() ფუნქცია header.inc ფაილში ( ჩამონათვალი 19), ა ქვედა კოლონტიტულიფაილში footer.inc ( ჩამონათვალი 20). შემდეგ ჩვენ დავაკავშირებთ ამ ფაილებს მთავარ სკრიპტთან ( ჩამონათვალი 18).

ჩამონათვალი 18. HTML კოდის განთავსება მოიცავს ფაილში

ჩამონათვალი 19. header.inc ფაილის შიგთავსი

ჩამონათვალი 20. footer.inc ფაილის შიგთავსი

IN ჩამონათვალი 21წყაროს HTML კოდი ნაჩვენებია წინა პროგრამის შესრულების შემდეგ.

ჩამონათვალი 21. HTML წყარო კოდი

7

ამ გზით თქვენ შეგიძლიათ შექმნათ შაბლონები მრავალი გვერდისთვის. თარჯიმანი, როდესაც შეხვდება მოთხოვნის განცხადებას, მოიცავს ფაილის შიგთავსს გვერდის ნაწილად აქცევს. თუ ფაილის ჩატვირთვა შეუძლებელია, განცხადება წარმოქმნის გამოუსწორებელ შეცდომას და სკრიპტი მთავრდება.
მოთხოვნის განცხადების ნაცვლად, შეგიძლიათ გამოიყენოთ ჩათვლით განცხადება. თუ მოიცავს ფაილი ვერ მოიძებნა, განცხადებაში გამოჩნდება შეცდომის შეტყობინება, მაგრამ სკრიპტი გააგრძელებს შესრულებას. თუ ეს ფაილი შეიცავს ფუნქციებს, მაშინ ამ ფაილიდან ყველა ფუნქციის გამოძახება ასევე წარმოქმნის შეცდომას.

Include განცხადება უბრუნებს true-ს, თუ ფაილი ჩატვირთულია, და false-ს, თუ არის შეცდომა. შეცდომის შეტყობინების აღკვეთა შეგიძლიათ @ ოპერატორის გამოყენებით ( ჩამონათვალი 22).

ჩამონათვალი 22. შეცდომის შეტყობინების ჩახშობა

PHP ოპერატორები: require(), require_once(), include_once()

თარიღი: 2012-10-15

PHP ფუნქციები: require(), require_once(), include(), include_once()

ბოლო გაკვეთილზე დეტალურად განვიხილეთ ნამუშევარი. შეგახსენებთ, რომ ოპერატორი მოიცავს () PHP-ში, ცვლის ერთი ვებ გვერდის შინაარსს სხვა ვებ გვერდით. მაგრამ PHP-ს აქვს სხვა ფუნქციები, რომლებიც საშუალებას გაძლევთ განახორციელოთ მსგავსი დავალება. კერძოდ, ეს არის ფუნქციები:

მოიცავს_ერთხელ ()
მოითხოვს ()
მოთხოვნა_ერთხელ ()

კონკრეტული ვებ გვერდის შინაარსის ჩასართავად საკმარისია მიუთითოთ გზა საჭირო ფაილი. მაგალითად, ასე:

მოიცავს ("file.php") ან მოითხოვს ("file.php")

ყველა ამ ფუნქციის ამოცანა იგივეა: ჩადეთ სასურველი კოდი ან ტექსტი ერთი ფაილიდან მეორე ფაილში. მაგრამ, მიუხედავად ამისა, ეს ფუნქციები განსხვავდება ერთმანეთისგან. მოდი გავარკვიოთ.

სუფიქსი " _ერთხელ" საშუალებას გაძლევთ დააკავშიროთ ფაილის კოდი ჩანაცვლებისთვის სხვა ფაილში მხოლოდ ერთხელ, რამდენი ზარიც არ უნდა განხორციელდეს. სიცხადისთვის, მოდით შევხედოთ მარტივ მაგალითს. ბოლო გაკვეთილზე გავარკვიეთ, რომ ოპერატორის გამოყენებით მოიცავს (), შეგიძლიათ განათავსოთ საიტის სათაური ცალკე ფაილში header.php, სიმარტივისთვის, ვივარაუდებთ, რომ ამ ფაილში ვდებთ საიტის გრაფიკულ ლოგოს. ვებ გვერდზე სწორ ადგილას (ამ შემთხვევაში, საიტის სათაურის ადგილას) ვწერთ კოდს ჩამონათვალი 1.

ჩამონათვალი 1.

შემდეგ, შესაბამისად, საიტის ლოგოც ორჯერ გამოჩნდება, დაახლოებით ასე:

დამეთანხმებით, არც ისე ლამაზად გამოიყურება, არა? გამოდის, რომ ოპერატორი მოიცავს ()ორჯერ ამოიღებს მას საქაღალდიდან ბლოკებიფაილი header.phpდა ანაცვლებს მას ორჯერ საიტის სათაურის ნაცვლად.

ზოგადად, ჩართული ფაილი შეიძლება შეიცავდეს ფუნქციებს, რომლებიც, როდესაც დაემატება წყაროს ფაილს, შეიძლება გამოიწვიოს შეცდომები და თქვენი ვებ გვერდი შეიძლება საერთოდ არ ჩაიტვირთოს.

დიდ საიტებზე ძალიან ადვილია დაბნეულობა იმის შესახებ, თუ სად და რა ფაილი შეიტანეთ და შეგიძლიათ თუ არა მისი ხელახლა ჩასმა და ამან შეიძლება გამოიწვიოს შეცდომა. ამიტომ გამოუვიდათ პრეფიქსი " _ერთხელ"ფუნქციებზე მოიცავსდა მოითხოვს, რომელიც მხოლოდ ერთხელ ათავსებს ფაილის შიგთავსს სხვა ვებ გვერდზე.

რით განსხვავდება include() მოთხოვნებისგან ()

ახლა მოდით ვისაუბროთ ფუნქციაზე მოიცავს ()განსხვავდება ფუნქციისგან მოითხოვს (). მათ შორის არავითარი განსხვავება არ არის მათ საქმიანობაში. ორივე ფუნქცია აერთიანებს ერთი ფაილის შინაარსს მეორეში. მაგრამ მათ აქვთ განსხვავება და ის მდგომარეობს იმაში, თუ როგორ რეაგირებენ ისინი სიტუაციაზე, როდესაც ფაილი, რომელსაც ჩვენ ვაკავშირებთ, არ არის ადგილზე.

მოდით დავუბრუნდეთ წინა მაგალითის კოდს ჩამონათვალი 1. ჩვენ გვაქვს შემდეგი კოდი:

ვცადოთ ფაილის წაშლა header.php, რომელსაც რეალურად ვაკავშირებთ, მაგალითად, ფაილი დაზიანებულია ან შემთხვევით წაიშალა ჩრდილოეთიდან.

ჩვენ ვაახლებთ სატესტო ფაილს და ვხედავთ ამ შეცდომას:

როგორც ხედავთ, ჩნდება შეტყობინება, რომელშიც ნათქვამია, რომ დირექტორიაში (საქაღალდეში) ბლოკებიფაილი ვერ მოიძებნა header.php, მაგრამ პროგრამა კვლავ შესრულებულია და საიტის დანარჩენი ვებ გვერდი ჩვეულებრივ ნაჩვენებია.

რა მოხდება, თუ ჩვენ დავწერთ კოდს ( ჩამონათვალი 3) ფუნქციის გამოყენებით მოითხოვს ():

ჩამონათვალი 3.

ეს არის ის, რაც ჩვენ გვაქვს მხოლოდ ერთი შეცდომის შეტყობინება გამოჩნდება, და პროგრამა აღარ შესრულდებადა თქვენ მხოლოდ ამ შეტყობინებას ნახავთ.

კავშირის მნიშვნელობა ში php მარტივირუსულად:

ფაილი 1.php
ზედა მენიუ

ფაილი 2.php
ქვედა მენიუ

example.php ფაილი
დააკავშირეთ ფაილი 1.php
გვერდის შინაარსი
დააკავშირეთ ფაილი 2.php

example.php ფაილის დამუშავების შედეგად გამოჩნდება
ზედა მენიუ
გვერდის შინაარსი
ქვედა მენიუ
შესაბამისად, ქვედა მენიუში რაიმეს შესაცვლელად საჭიროა ცვლილებების შეტანა მხოლოდ 2.php ფაილში

ფაილის გზა

PHP კოდი

// ფარდობითი გზის მაგალითი
მოიცავს "include/your_file.php"; // ფაილი არის include საქაღალდეში, რომელიც მდებარეობს იმავე დირექტორიაში, სადაც კავშირის ფაილი

// აბსოლუტური ბილიკის მაგალითი
მოიცავს $_SERVER["DOCUMENT_ROOT"]."/include/your_file.php"; // $_SERVER["DOCUMENT_ROOT"] - მიუთითებს საიტის ძირეულ დირექტორიაზე

მოიცავს და მოიცავს_ერთხელ

მოდით შევხედოთ, თუ როგორ მოიცავს სამუშაოებს ორი ფაილის გამოყენებით, როგორც მაგალითი: index.phpდა text.php. სამუშაოს სიმარტივისთვის, დავუშვათ, რომ ისინი განლაგებულია იმავე დირექტორიაში.

PHP კოდი(ფაილი index.php)

ექო" უბრალო ტექსტი, შეიცავს მთავარ ფაილში";
ჩართეთ "text.php"; // მოიცავს text.php ფაილის შიგთავსს

?>
PHP კოდი(ფაილი text.php)

Echo "ტექსტი, რომელიც შეიცავს ფაილში";

?>
index.php ფაილის გაშვების შედეგი იქნება:

ძირითადი ფაილი შეიცავს უბრალო ტექსტს
ტექსტი, რომელიც შეიცავს ფაილში
მართლა მოსახერხებელია? ახლა, text.php ფაილში შინაარსის შეცვლით, index.php-ის შედეგი სრულიად განსხვავებული იქნება!

ახლა მოდით ვისაუბროთ სხვა დიზაინზე - მოიცავს_ერთხელ. ის მუშაობს ზუსტად ისევე, როგორც მოიცავს, მხოლოდ მოგვიანებით შეიქმნა და იმ შემთხვევისთვის, როდესაც ფაილის ხელახლა ჩასმა შეუძლებელია. მაგალითად, გეშინიათ, რომ შეცდომის შედეგად შეიძლება 2 ან მეტჯერ დააკავშიროთ ფაილი, რაც გავლენას მოახდენს გვერდის არასწორად მუშაობაზე და შესაბამისი შეცდომის შეტყობინების მიღებაზე.

PHP კოდი

Include_once "text.php"; // text.php ფაილი ჩართული იქნება მხოლოდ ერთხელ

// ქვემოთ მოცემული ხელახალი კავშირი არ იქნება გათვალისწინებული და არ იქნება ნაჩვენები
// და ეს არ გამოიწვევს შეცდომის შეტყობინების ჩვენებას
include_once "text.php"; // არაფერი მოხდება

მოითხოვენ და მოითხოვენ_ერთხელ

თუ შედის ან მოითხოვს არ მუშაობს

1. შეამოწმეთ, მუშაობს თუ არა თქვენი სერვერი და php, მუშაობს თუ არა რომელიმე მათგანი php კოდისაიტზე
2. შეამოწმეთ, არის თუ არა ჩართული ფაილი
3. შეამოწმეთ, არის თუ არა ფაილის სახელი და გაფართოება შეყვანილი კავშირში სწორად
4. დარწმუნდით, რომ ჩართული php ფაილი რეალურად მდებარეობს თქვენ მიერ მითითებულ მისამართზე
5. სცადეთ მიუთითოთ აბსოლუტური გზა (ფაილის სრული გზა) და არა შედარებითი გზა.

მაგალითი PHP კოდი

ჩართეთ "http://www.example.com/include/your_file.php";

// DOCUMENT_ROOT - აღნიშნავს რესურსის ძირეულ დირექტორიას
მოიცავს $_SERVER["DOCUMENT_ROOT"]."/include/your_file.php";

6. თუ თქვენი ფაილი არ უკავშირდება და შეცდომა არ არის ნაჩვენები, მაშინ იმ ფაილის დირექტორიაში, რომელსაც აკავშირებთ, შექმენით ფაილი .htaccessშემდეგი შინაარსით

Php_flag display_errors ჩართულია
ან php ფაილში, დაკავშირებამდე ჩასვით შემდეგი ხაზი

შეცდომის_მოხსენება (E_ALL);
ორივე პარამეტრი აიძულებს შეცდომების ჩვენებას

29 პასუხი

ასევე არის საჭირო და მოიცავს_ერთხელ.

ასე რომ, თქვენი შეკითხვა უნდა იყოს ...

1. როდის უნდა გამოვიყენო მოთხოვნა და შევიტანო?
2. როდის უნდა გამოვიყენო request_one vs მოთხოვნა

მოთხოვნა() ფუნქცია იდენტურია მოიცავს()-ს გარდა იმისა, რომ ის შეცდომებს განსხვავებულად უმკლავდება. შეცდომის შემთხვევაში, include() ფუნქცია წარმოქმნის გაფრთხილებას, მაგრამ სკრიპტი გააგრძელებს შესრულებას. Require() წარმოქმნის ფატალურ შეცდომას და სკრიპტი ჩერდება.

მოთხოვნა_once() განაცხადის იდენტურია მოთხოვნა(), გარდა იმისა, რომ PHP შეამოწმებს, არის თუ არა ფაილი უკვე ჩართული და, თუ ასეა, აღარ მოიცავს (მოითხოვს) მას.

ჩემი წინადადებაა, რომ გამოიყენოთ მოთხოვნა_ერთჯერ 99,9%-ში.

მოთხოვნის ან ჩართვის ნაცვლად გამოყენება გულისხმობს, რომ თქვენი კოდის ხელახლა გამოყენება შეუძლებელია სხვაგან, ანუ იმ სკრიპტებში, რომლებსაც რეალურად აკრეფთ. შეასრულოსკლასის ან ზოგიერთი ფუნქციის ბიბლიოთეკის მიწოდების ნაცვლად,

თუ თქვენ გჭირდებათ/მათ შორის კოდი, რომელიც მუშაობს ადგილზე, ეს არის პროცედურული კოდი და გჭირდებათ ისწავლეთ ახალი პარადიგმა. ობიექტზე ორიენტირებული პროგრამირების, ფუნქციური პროგრამირების ან ფუნქციური პროგრამირების მსგავსი.

თუ თქვენ უკვე აკეთებთ OO-ს ან ფუნქციურ პროგრამირებას, ჩათვლით_once-ის გამოყენება ძირითადად გადაიდება, როდესაც დასტაზე აღმოაჩენთ შეცდომებს/შეცდომებს. გსურთ იცოდეთ, რომ do_cool_stuff() ფუნქცია მიუწვდომელია, როცა მოგვიანებით გადახვალთ მის დასარეკად, ან იმ მომენტში, როდესაც თქვენ მოელით, რომ ის ხელმისაწვდომი იქნება, გჭირდებათ ბიბლიოთეკა? ზოგადად უკეთესია წინასწარ იცოდეთ, თუ რამე გჭირდებათ და რას უნდა ელოდოთ მიუწვდომელია, ამიტომ უბრალოდ გამოიყენეთ request_once .

ალტერნატიულად, თანამედროვე OOP-ში, ავტომატურად ჩატვირთეთ თქვენი კლასები გამოყენებისას.

განსხვავება _once ფუნქციებსა და _once ფუნქციებს შორის: კოდის გარეშე _once ისევ ჩაირთვება, ხოლო _once ფუნქციებით PHP ადევნებს თვალყურს შეტანილ ფაილებს და ჩართავს მხოლოდ ერთხელ.

განსხვავება მოთხოვნასა და მოიცავს შორის: თუ საჭირო ფაილი ვერ მოიძებნა, PHP წარმოქმნის ფატალურ შეცდომას, ხოლო მოიცავს მხოლოდ გაფრთხილებას.

include() გამოსცემს გაფრთხილებას, თუ ის ვერ მოიცავს ფაილს, მაგრამ სკრიპტის დანარჩენი ნაწილი იმუშავებს.

require() გადააგდებს E_COMPILE_ERROR-ს და შეაჩერებს სკრიპტს, თუ ის ვერ შეიცავს ფაილს.

ფუნქციები include_once() და require_once() არ შეიცავს ფაილს მეორედ, თუ ის უკვე ჩართულია.

იხილეთ შემდეგი დოკუმენტაციის გვერდები:

როდესაც იყენებთ require_once()-ს, შეგიძლიათ გამოიყენოთ იგი ფაილზე სხვა ფაილის ჩასართავად, თუ უბრალოდ გჭირდებათ მითითებული ფაილიმიმდინარე ფაილში. აი მაგალითში მაქვს test1.php.

და სხვა ფაილში, რომელსაც დავარქვი test2.php

როდესაც უყურებთ m, საჭიროებს ფაილს test1 ორჯერ, მაგრამ ფაილი შეიცავს test1 ერთხელ და მეორედ დარეკვისას ის იგნორირებული იქნება. და შეჩერების გარეშე გამოჩნდება გამომავალი ერთხელ.

როდესაც იყენებთ "include_once()"-ს, ის შეიძლება გამოყენებულ იქნას ფაილში სხვა ფაილის ჩასართავად, თუ თქვენ გჭირდებათ ფაილი არაერთხელ გამოძახებული მიმდინარე ფაილში. აქ მაგალითში მაქვს ფაილი სახელად test3.php.

და სხვა ფაილში, რომელსაც დავარქვი test4.php

რადგან თქვენ უყურებთ m ფაილს test3-ს ჩათვლით, ფაილს ერთხელ შეასრულებს, მაგრამ შეაჩერებს შემდგომ შესრულებას.

განსხვავება არის შეცდომა, რომელსაც ბრძანებები ქმნიან. მოთხოვნით, მას რეალურად სჭირდება ფაილი, რომლის გამოყენებაც გსურთ და ამით წარმოქმნის E_ERROR-ს, თუ ის არ არის ნაპოვნი.

მოთხოვნა() იდენტურია მოიცავს() გარდა იმისა, რომ წარუმატებლობა ასევე გამოიწვევს ფატალური შეცდომადონე E_ERROR.

მოიცავს წარმოქმნის E_WARNING შეცდომას, თუ ის ვერ მოხერხდება, რომელიც მეტ-ნაკლებად ჩუმად არის.

ასე რომ, გამოიყენეთ იგი, თუ ფაილი საჭიროა დარჩენილი კოდის გასაშვებად და გსურთ, რომ სკრიპტი წარუმატებელი იყოს და ფაილი მიუწვდომელია.

*_ერთჯერ() :

include_once() შეიძლება გამოყენებულ იქნას იმ შემთხვევებში, როდესაც ერთი და იგივე ფაილი შეიძლება იყოს ერთზე მეტჯერ შეტანილი და შეფასებული კონკრეტული სკრიპტის შესრულების დროს, ასე რომ, ამ შემთხვევაში მას შეუძლია თავიდან აიცილოს ისეთი პრობლემები, როგორიცაა ფუნქციის გადაფარვა, გადაფარვა. ცვლადი მნიშვნელობებიდა ა.შ.

იგივე ეხება require_once()-ს, რა თქმა უნდა.

ეს კითხვა შვიდი წლის წინ დაისვა და არცერთი პასუხი არ არის პრაქტიკული დახმარებაამ საკითხში. თანამედროვე PHP პროგრამირებაში, თქვენ ძირითადად იყენებთ საჭირო_ერთჯერ მხოლოდ ერთხელ, რათა ჩართოთ თქვენი ავტოჩამტვირთავი (ხშირად კომპოზიტორის ავტოჩამტვირთავი) და ის ჩატვირთავს თქვენს ყველა კლასს და ფუნქციას (ფუნქციის ფაილები აშკარად უნდა დაემატოს composer.json-ს, რომ ხელმისაწვდომი იყოს ყველა სხვა ფაილში). თუ რაიმე მიზეზით თქვენი კლასი არ იტვირთება ავტოჩამტვირთველიდან, თქვენ იყენებთ request_once-ს მის ჩასატვირთად.

ამ დღეებში საჭიროა მხოლოდ PHP ფაილის დიდი ნაწილის გაყოფა. ეს ძირითადად დიდი მასივის განმარტებაა. ასეთ შემთხვევებში თქვენ იყენებთ მხოლოდ მოთხოვნა მოთხოვნა_ერთჯერადს.

"y"];

თუ ფაილი, რომლის გამოყენებასაც აპირებთ, შეიცავს შესრულებადს ან გამოაცხადებს ზოგიერთ ცვლადს, თქვენ თითქმის ყოველთვის დაგჭირდებათ მოთხოვნა, რადგან თუ იყენებთ require_once სხვაგან, თქვენი კოდი არ შესრულდება და/ან თქვენი ცვლადები არ გააქტიურდება ჩუმად. იწვევს შეცდომებს, რომელთა იდენტიფიცირება აბსოლუტურად რთულია.

მოიცავს და მოიცავს_ერთჯერადის პრაქტიკა პრაქტიკულად არ გამოიყენება.

თქვენ უნდა შეინახოთ კლასების და ფუნქციების განმარტებები ფაილებში.

გამოიყენეთ მოთხოვნა_once() ჩატვირთვისთვის დამოკიდებულებები

გამოიყენეთ მოთხოვნა() ჩატვირთვისთვის შაბლონის მსგავსი ფაილები.

გამოიყენეთ include_once() ჩატვირთვისთვის არჩევითი დამოკიდებულებები(კლასები, ფუნქციები, მუდმივები).

გამოიყენეთ include() ჩატვირთვისთვის არჩევითი შაბლონის მსგავსი ფაილები.

საჭიროგამოიწვევს ფატალურ შეცდომას (E_COMPILE_ERROR) და შეაჩერებს სკრიპტს.

ჩართეთგამოსცემს გაფრთხილებას (E_WARNING) და სკრიპტი გაგრძელდება.

ოპერატორი მოითხოვს_ერთხელშეიძლება გამოყენებულ იქნას PHP ფაილის სხვაში ჩასართავად, როდესაც შეიძლება დაგჭირდეთ მოწოდებული ფაილის ჩართვა არაერთხელ.

თუ a.php არის PHP სკრიპტი, რომელიც იძახებს b.php-ს მოთხოვნა_once()-ით და ვერ პოულობს b.php-ს, a.php წყვეტს შესრულებას, რაც იწვევს ფატალურ შეცდომას.

მოიცავს ()

ის შეიცავს მითითებულ ფაილს. ის გამოსცემს გაფრთხილებას, თუ ვერ იპოვის ფაილს და ვერ შეასრულებს დარჩენილი სკრიპტები

საჭირო ()

ის შეიცავს მითითებულ ფაილს. ეს გამოიწვევს ფატალურ შეცდომას, თუ ის ვერ პოულობს ფაილს და შეწყვეტს შესრულებას

ის შეიცავს მითითებულ ფაილს. ფაილი უკვე შედის, ის აღარ იქნება ჩართული. ის გასცემს გაფრთხილებას, თუ ის ვერ პოულობს ფაილს და აწარმოებს დანარჩენ სკრიპტებს.

ის შეიცავს მითითებულ ფაილს. ფაილი უკვე შედის, ის აღარ იქნება ჩართული. ეს გამოიწვევს ფატალურ შეცდომას, თუ ის ვერ პოულობს ფაილს და შეწყვეტს შესრულებას.

იდენტურია ჩართვის/მოთხოვნის გარდა, გარდა იმისა, რომ PHP ამოწმებს, არის თუ არა ფაილი უკვე ჩართული, და თუ ასეა, აღარ ჩართოთ იგი (საჭიროა).

PSR-0/PSR-4 ავტოჩამტვირთველების ეპოქაში, შესაძლოა სრულიად ზედმეტი იყოს რაიმე განცხადების გამოყენება, თუ ყველაფერი რაც თქვენ გჭირდებათ არის თქვენი კოდისთვის ხელმისაწვდომი გახადოთ რამდენიმე ფუნქცია/კლასი (რა თქმა უნდა, თქვენ კვლავ უნდა გამოიყენოთ request_once თქვენი ფაილის ჩატვირთვისას. და ჩართეთ შაბლონები, თუ ჯერ კიდევ იყენებთ PHP-ს, როგორც შაბლონის ძრავას).

require() იდენტურია მოიცავს()-ს გარდა, მარცხი ასევე გამოიწვევს შეცდომის ფატალურ დონეს E_COMPILE_ERROR. სხვა სიტყვებით რომ ვთქვათ, ის შეაჩერებს სკრიპტს, ხოლო include() გასცემს მხოლოდ გაფრთხილებას (E_WARNING), რომელიც საშუალებას აძლევს სკრიპტს გაგრძელდეს.

იგივე ეხება _once() ვარიანტებს.

მე გამოვიყენე ფუნქცია, როგორც ქვემოთ:

ფუნქცია doSomething() ( require_once(xyz.php); .... )

მუდმივი მნიშვნელობები დაფიქსირდა xyz.php-ში.

მე უნდა გამოვიძახო ეს doSomething() ფუნქცია სხვა PHP სკრიპტის ფაილიდან.

მაგრამ მე დავაკვირდი ქცევას ამ ფუნქციის ციკლში გამოძახებისას, რადგან პირველი გამეორება doSomething() იღებდა მუდმივ მნიშვნელობებს xyz.php-ში, მაგრამ მოგვიანებით doSomething()-ის ყოველი გამეორება ვერ ახერხებდა xyz-ში გამოცხადებული მუდმივი მნიშვნელობების მიღებას. php .

მე გადავწყვიტე ჩემი პრობლემა მოთხოვნა_once()-დან include()-ზე გადართვით, განახლებული doSomething() კოდი ასე გამოიყურება:

ფუნქცია doSomething() ( include(xyz.php); .... )

ახლა ყოველი განმეორებითი ზარი doSomething()-ზე იღებს xyz.php-ში განსაზღვრულ მუდმივებს.

როდის უნდა გამოიყენოთ მოთხოვნა ან შეიცავდეს?

მოთხოვნისა და შეყვანის ფუნქციები ასრულებენ ერთსა და იმავე ამოცანას, ანუ მოიცავს და აფასებენ მითითებულ ფაილს, მაგრამ საჭირო განსხვავება გამოიწვევს ფატალურ შეცდომას, თუ ფაილის მითითებული მდებარეობა არასწორია ან რაიმე შეცდომის გამო, ხოლო ჩათვლით გამოიმუშავებს გაფრთხილებას და გაგრძელდება. კოდის შესრულება.

ასე რომ, თქვენ შეგიძლიათ გამოიყენოთ მოთხოვნის ფუნქცია იმ შემთხვევაში, თუ ფაილი, რომლის ჩართვას ცდილობთ, არის სისტემის გულიდა შეიძლება დიდი გავლენა იქონიოს დანარჩენ კოდზე, და შეიძლება დაგჭირდეთ ჩართვის ფუნქცია, როდესაც ფაილი, რომლის ჩასმასაც ცდილობთ, არის მარტივი ფაილი, რომელიც შეიცავს ნაკლებად მნიშვნელოვან კოდს.

და ჩემი პირადი რეკომენდაცია (ნაკლებად მნიშვნელოვანი კოდისთვის) არის გამოიყენოს საჭირო ფუნქცია ყველგან თქვენს კოდში, სანამ ის შემუშავების პროცესშია, რათა შეგეძლოთ კოდის გამართვა და შემდეგ შეცვალოთ ყველა საჭირო ფუნქციით, სანამ მის წარმოებაში გადაიტანოთ. თქვენ გამოტოვებთ შეცდომებს, ეს არ იმოქმედებს საბოლოო მომხმარებელზე და დანარჩენი კოდი სწორად შესრულდება...

როდის უნდა გამოიყენოთ მოთხოვნა_ერთჯერ ან მოთხოვნა?

ძირითადი განსხვავება მოთხოვნასა და require_once is require_once-ს შორის შეამოწმებს, შედის თუ არა ფაილი, თუ ის უკვე შედის, მაშინ ის არ შეიცავს ფაილს, ხოლო მოთხოვნა ფუნქცია მოიცავს ფაილს, ჩართულია თუ არა ფაილი.

ასე რომ, იმ შემთხვევებში, როდესაც გსურთ დაამატოთ კოდის ნაწილი ისევ და ისევ, გამოიყენეთ მოთხოვნა ფუნქცია, ხოლო თუ გსურთ კოდის მხოლოდ ერთხელ შეტანა თქვენს კოდში, გამოიყენეთ მოთხოვნა_ერთჯერ.

ეს არის ფაილების ჩართვის ყველა გზა.

მოთხოვნა ნიშნავს იმას, რომ საჭიროა. Require_one ნიშნავს, რომ საჭირო იქნება, მაგრამ მხოლოდ ერთხელ. Include ნიშნავს, რომ ის შეიცავს ფაილს, მაგრამ არ არის საჭირო გაგრძელება.

მოითხოვეთ "ფაილის სახელი" Require_once "ფაილის სახელი" ჩართეთ "ფაილის სახელი"

ასევე არის include_one ფუნქცია, რომელიც შეიცავს ფაილს ერთხელ.

Include_once "ფაილის სახელი"

არ გამოიყენოთ დიდი ასოები, სადაც ტელეფონზე ვწერ.

ძირითადად, თუ გსურთ არასწორი გზა, PHP აგდებს ფატალურ შეცდომას და გამოიძახება გამორთვის ფუნქცია, მაგრამ როცა არასწორ გზას ჩართავთ, PHP გააგრძელებს შესრულებას, მაგრამ ის უბრალოდ აჩვენებს გაფრთხილებას, რომ ფაილი არ არსებობს.

ინგლისური სიტყვიდან საჭირო, PHP ამბობს, რომ გვერდის ან ფაილის შესრულება დამოკიდებულია საჭირო ფაილზე.

ჩემი გამოცდილებით, ეს არის ნორმა, რომელიც მოითხოვს მნიშვნელოვან ფაილებს, როგორიცაა კონფიგურაციის ფაილები, მონაცემთა ბაზის კლასები და სხვა მნიშვნელოვანი კომუნალური საშუალებები.