Require once php net

Включение файлов — Основы PHP

Сайты и программы на PHP содержат тысячи, десятки тысяч и сотни тысяч строк кода. В таких условиях одним файлом с кодом не обойдешься — его нужно разбивать на части.

Чтобы мы могли получить доступ к коду, который находится в других файлах, в PHP реализован механизм включения. Он состоит из четырех специальных конструкций:

В этом уроке мы познакомимся с этими конструкциями. Начнем с конструкции require :

 // file: print.php function sayHi()  print_r('Hi!'); > // file: index.php require_once 'print.php'; sayHi(); // => Hi! 

Включение файла с кодом делает доступным его содержимое в том месте, куда он включается. В примере выше функция sayHi определяется в файле print.php и становится видна из файла index.php .

То же самое относится не только к определению функций, но даже к переменным:

 // file: print.php $x = 'Hi!'; // file: index.php require_once 'print.php'; print_r($x); // => Hi! 

Последний пример наталкивает на интересную мысль. Раз переменная появилась внутри файла index.php , то это значит, что конструкция require_once исполняет весь код, который находится во включаемом файле. В этом легко убедиться, поставив эксперимент:

 // file: print.php print_r("Hi from print.php!\n"); // file: index.php require_once 'print.php'; print_r("Hi from index.php!\n"); 

Видно, что сначала выполнился код во включаемом файле, а только потом — код в файле index.php . Можно считать, что require_once берет содержимое включаемого файла и вставляет его вместо себя. То есть код выше работает так, как будто он написан следующим образом:

 // index.php print_r("Hi from print.php!\n"); print_r("Hi from index.php!\n"); 

Этот механизм рекурсивен по своей природе: если во включаемом файле есть другой включаемый файл, то сначала исполнится он. Такое поведение чем-то похоже на матрешку. Можно сказать, что весь код всех файлов проекта находится в одном пространстве и доступен для использования напрямую.

Из всех четырех конструкций для включения файлов пользоваться имеет смысл только одной — require_once . Она обладает двумя важными свойствами:

1. Если файл отсутствует, то эта конструкция приведет к ошибке, и программа остановит свое выполнение
2. Если в require_once передается файл, который уже был где-то загружен ранее, то она не будет выполнять этот файл повторно, но код этого файла все равно будет доступным

Эти два условия важны, потому что код, опирающийся на них, получается более качественным и простым. В отличие от require_once , остальные конструкции не отвечают этим требованиям:

• require исполняет включаемый файл каждый раз
• include и include_once не приводят к ошибке в ситуации, когда файла не существует

Этот урок нужен лишь для понимания происходящих внутри процессов. В реальном же коде за включение файлов отвечает Composer — менеджер управления зависимостями, который будем проходить в курсе про настройку окружения.

Как вы увидите в следующих курсах, современный стандарт разработки на PHP полагается на механизм автозагрузки и запрещает использование явного включения файлов.

Дополнительные материалы

Остались вопросы? Задайте их в разделе «Обсуждение»

Вам ответят команда поддержки Хекслета или другие студенты

Источник

Hello every one

«require_once» and «require» are language constructs and not functions. Therefore they should be written without «()» brackets!

require_once may not work correctly inside repetitive function when storing variable for example:

function foo () require_once( ‘var.php’ );
return $foo ;
>

to make sure variable bar available at each function call , replace require once with require. eg situation : https : //stackoverflow.com/questions/29898199/variables-not-defined-inside-function-on-second-time-at-foreach

function foo () require( ‘var.php’ );
return $foo ;
>

> php check2 . php
result :
bar
bar
bar
bar
bar

There’s been a lot of discussion about the speed differences between using require_once() vs. require().
I was curious myself, so I ran some tests to see what’s faster:
— require_once() vs require()
— using relative_path vs absolute_path

I also included results from strace for the number of stat() system calls. My results and conclusions below.

METHODOLOGY:
————
The script (test.php):
$start_time = microtime ( true );

/*
* Uncomment one at a time and run test below.
* sql_servers.inc only contains define() statements.
*/

//require (‘/www/includes/example.com/code/conf/sql_servers.inc’);
//require (‘../../includes/example.com/code/conf/sql_servers.inc’);
//require_once (‘/www/includes/example.com/code/conf/sql_servers.inc’);
//require_once (‘../../includes/example.com/code/conf/sql_servers.inc’);

$end_time = microtime ( true );

$handle = fopen ( «/tmp/results» , «ab+» );
fwrite ( $handle , ( $end_time — $start_time ) . «\n» );
fclose ( $handle );
?>

The test:
I ran ab on the test.php script with a different require*() uncommented each time:
ab -n 1000 -c 10 www.example.com/test.php

RESULTS:
———
The average time it took to run test.php once:
require(‘absolute_path’): 0.000830569960420
require(‘relative_path’): 0.000829198306664
require_once(‘absolute_path’): 0.000832904849136
require_once(‘relative_path’): 0.000824960252097

The average was computed by eliminating the 100 slowest and 100 fastest times, so a total of 800 (1000 — 200) times were used to compute the average time. This was done to eliminate any unusual spikes or dips.

The question of how many stat() system calls were made can be answered as follows:
— If you run httpd -X and then do an strace -p , you can view the system calls that take place to process the request.
— The most important thing to note is if you run test.php continuously (as the ab test does above), the stat() calls only happen for the first request:

first call to test.php (above):
——————————-
lstat64 («/www», lstat64 («/www/includes», lstat64 («/www/includes/example.com», lstat64 («/www/includes/example.com/code», lstat64 («/www/includes/example.com/code/conf», .
lstat64 («/www/includes/example.com/code/conf/sql_servers.inc», open («/www/includes/example.com/code/conf/sql_servers.inc», O_RDONLY) = 17

subsequent calls to test.php:
——————————
open («/www/includes/example.com/code/conf/sql_servers.inc», O_RDONLY) = 17

— The lack of stat() system calls in the subsequent calls to test.php only happens when test.php is called continusly. If you wait a certain period of time (about 1 minute or so), the stat() calls will happen again.
— This indicates that either the OS (Ubuntu Linux in my case), or Apache is «caching» or knows the results of the previous stat() calls, so it doesn’t bother repeating them.
— When using absolute_path there are fewer stat() system calls.
— When using relative_path there are more stat() system calls because it has to start stat()ing from the current directory back up to / and then to the include/ directory.

CONCLUSIONS:
————
— Try to use absolute_path when calling require*().
— The time difference between require_once() vs. require() is so tiny, it’s almost always insignificant in terms of performance. The one exception is if you have a very large application that has hundreds of require*() calls.
— When using APC opcode caching, the speed difference between the two is completely irrelevant.
— Use an opcode cache, like APC!

Konstantin Rozinov
krozinov [at] gmail

Источник

Подключение файлов

Способность вызывать сценарий из отдельного файла по его имени называется в PHP подключением файлов. Подключают PHP-сценарии, любые текстовые файлы или HTML-страницы.

Зачем разделять и подключать PHP-сценарии

PHP-разработчики дробят исходный код проекта на отдельные сценарии, чтобы было проще работать. Если написать код в одном файле, сценарий станет необъятным, и ориентироваться будет невозможно.

Если вынести повторяющиеся блоки кода в отдельные сценарии, то появится возможность повторно использовать один код в разных файлах и подключать его только по требованию.

Например, пользовательские функции удобно объявлять в отдельном сценарии, а затем подключать там, где эти функции понадобились.

Способы подключения файлов — require и require_once

Для подключения файлов в PHP есть две языковые конструкции: require и require_once . Отличия между ними минимальны. Оба этих ключевых слова подключают файл с указанным именем и вызывают ошибку, если данный файл не существует.

👉 Особенность работы require_once — он позволяет подключать файл только один раз, даже если вызывать инструкцию несколько раз с одним именем файла.

Примеры подключения файлов

Рассмотрим, как подключить один сценарий внутри другого. Для этого воспользуемся инструкцией require . Предположим, у нас есть два сценария: index.php и sub.php .

В файле index.php находится код, который подключит сценарий sub.php :

Интересный факт: require можно использовать как ключевое слово, либо как функцию.

Результат будет одним и тем же:

Результат работы:

Привет, я содержимое из sub.php! А я - index.php! 

Что произошло? Два сценария как бы склеились в один: выполнилось все содержимое sub.php и добавилось в начало сценария index.php .

О работе с функцией require подробно рассказано в этом задании.

Абсолютные и относительные пути

При подключении файла в качестве его адреса указывают абсолютный или относительный путь.

Абсолютный путь — это полный адрес файла от корня диска. Например, /var/www/web/site/inc/sub.php

Относительный путь содержит адрес относительно текущей рабочей директории. Если сценарий лежит в папке /var/www/web/site , то для подключения файла используется такой путь: inc/sub.php

Рекомендуется всегда указывать относительные пути, чтобы сайт продолжал работать, если его переместят в другую папку.

👉 В PHP есть полезные встроенные константы, их используют в пути к подключаемым файлам.

__DIR__ — полный путь к директории с текущим сценарием.

__FILE__ — полный путь к текущему сценарию.

Видимость переменных в подключаемых сценариях

При подключении файлы склеиваются в один, поэтому и все переменные в разных сценариях тоже получают общую область видимости.

В PHP нет системы модулей, как в других языках программирования (Python, Java, ECMAScript 12). Невозможно «импортировать» отдельные переменные или функции из подключаемого сценария.

Если подключить один сценарий дважды, то переменные и функции из него тоже объявятся повторно, а это вызовет ошибку. Чтобы такого не произошло, используйте require_once .

«Доктайп» — журнал о фронтенде. Читайте, слушайте и учитесь с нами.

Источник