PHP выполняются на сервере, а результат отправляется в веб-браузер в виде обычного HTML. PHP может быть интегрирован с рядом популярных баз данных, включая MySQL, PostgreSQL, Oracle, Microsoft SQL Server, Sybase и др. Текущая основная версия PHP - 7. Весь код в этом руководстве был протестирован и проверен на соответствие самой последней версии PHP 7.
Эта серия руководств по PHP охватывает все основные концепции программирования, включая типы данных, операторы, создание и использование переменных, генерацию выходных данных, структурирование кода для принятия решений в ваших программах или многократного циклического выполнения одного и того же блока кода, создания и манипулирования строками, массивами, определение, вызов функций и пр.
Как только вы освоитесь с основами, вы перейдете на следующий уровень, который объясняет концепцию файловой системы, сеансов и файлов cookie, даты и времени, а также как отправлять электронную почту с ваших скриптов, обрабатывать и проверять формы, выполнять фильтрацию и обработку ошибок в PHP.
Наконец, вы познакомитесь с некоторыми продвинутыми понятиями, такими как классы и объекты, синтаксический анализ JSON-данных, сопоставление шаблонов с регулярными выражениями, обработка исключений, а также способы использования PHP для управления данными в базе данных MySQL и создания полезных функций, таких как система входа пользователя в систему, Ajax-поиск и т.д.
Каждая глава в этом руководстве содержит множество реальных примеров, которые вы можете протестировать. Эти примеры помогут вам лучше понять концепцию или тему. Кроме того, все руководства содержат полезные советы и важные заметки.
Прежде чем вы начнете писать любую PHP-программу, вам необходимо установить на свой компьютер следующие программы.
Набор этих программ часто называют LAMP, по первым буквам этого набора. Вы можете установить их по отдельности или выбрать предварительно настроенный локальный сервер для вашей операционной системы. Популярные предварительно настроенные программы — XAMPP, Open Server или Laragon.
Теперь, когда вы успешно установили локальный сервер на свой компьютер. В этом разделе мы создадим очень простой PHP-скрипт, который отображает текст «Hello, world!» в окне браузера.
На большинстве локальных серверов нужный вам каталог будет называться www, доступ к каталогу будет расположен по пути вида C:\laragon\www, а на панели управления будет соответствующий значок для управления сервером. Но для комфортной работы вам лучше ознакомиться с документацией по вашему серверу или посмотреть ознакомительные видео на Youtube.
Для дальнейшей работы вам понадобиться создать первый локальный проект. Создайте в каталоге www новый проект с названием project.
Теперь откройте ваш любимый редактор кода и создайте новый файл PHP, затем введите следующий код:
Справочники, инструменты, документация<?php
// Показываем приветственное сообщение
echo "Hello, world!";
?>Теперь сохраните этот файл как hello.php в папке проекта (расположенной по адресу C:\laragon\www\project) и просмотрите результат в своем браузере по URL-адресу: http://localhost/project/hello.php.
PHP может быть встроен в обычную веб-страницу HTML. Это означает, что внутри вашего HTML-документа вы можете свободно писать PHP-операторы, как показано в следующем примере:
<!DOCTYPE HTML>
<html>
<head>
<title>PHP Application</title>
</head>
<body>
<?php
// Показываем приветственное сообщение
echo 'Hello World!';
?>
</body>
</html>Комментарий — это просто текст, который игнорируется интерпретатором PHP. Цель комментариев — сделать код более читабельным. Это может помочь другому разработчику (или вам в будущем при редактировании исходного кода) понять, что вы пытались сделать с PHP. PHP поддерживает как однострочные, так и многострочные комментарии. Чтобы написать однострочный комментарий, начните строку с двух косых черт // или символа решетки #. Например:
<?php
// Это однострочный комментарий
# Это тоже однострочный комментарий
echo "Hello, world!";
?>Однако, чтобы писать многострочные комментарии, начинайте комментарий с косой черты, за которой следует звездочка /*, и заканчивайте комментарий звездочкой, за которой следует косая черта */, например:
<?php
/*
Это многострочный блок комментариев
который охватывает более
одной строки
*/
echo "Hello, world!";
?>Переменные используются для хранения данных, например строк, чисел, массивов или объектов. Значения переменных могут изменяться в ходе выполнения сценария. Вот несколько важных вещей, которые нужно знать о переменных:
= используется для присвоения значения переменной.PHP-переменную можно объявить как: $var_name = value;
<?php
// Объявляем переменную
$txt = "Hello World!";
$number = 10;
// Отображаем значения переменных
echo $txt; // Output: Hello World!
echo $number; // Output: 10
?>В приведенном выше примере мы создали две переменные, первой из которых присвоено строковое значение, а второй — число. Позже мы отобразили значения переменных в браузере с помощью оператора echo. PHP-оператор echo часто используется для вывода данных в браузер.
$, за которым следует имя переменной._.A-z, 0-9, и _).Имена переменных в PHP чувствительны к регистру, это означает, что $x и $X — две разные переменные. Так что будьте осторожны при определении имен переменных.
Имена переменных в PHP чувствительны к регистру. В результате переменные $color, $Color и $COLOR обрабатываются как три разные переменные.
<?php
// Присваиваем значение переменной
$color = "blue";
// Попробуем распечатать значение переменной
echo "The color of the sky is " . $color . "<br>";
echo "The color of the sky is " . $Color . "<br>";
echo "The color of the sky is " . $COLOR . "<br>";
?>Если вы попытаетесь запустить приведенный выше пример кода, он отобразит только значение переменной $color и выдаст предупреждение Undefined variable для переменных $Color и $COLOR.
Однако имена ключевых слов, функций и классов нечувствительны к регистру. В результате вызов gettype() или GETTYPE() дает один и тот же результат.
<?php
// Присваиваем значение переменной
$color = "blue";
// Получаем тип переменной
echo gettype($color) . "<br>";
echo GETTYPE($color) . "<br>";
?>Если вы попытаетесь запустить приведенный выше пример кода, обе функции gettype() и GETTYPE() выдадут один и тот же результат: blue.
Константа — это имя или идентификатор с фиксированным значением. Константы похожи на переменные, за исключением того, что после того, как они определены, они не могут быть переопределены или изменены (кроме магических констант).
Константы очень полезны для хранения данных, которые не меняются во время работы скрипта. Общие примеры таких данных включают параметры конфигурации, такие как имя пользователя и пароль базы данных, базовый URL-адрес веб-сайта, название компании и т. д.
Константы определяются с помощью PHP-функции define(), которая принимает два аргумента: имя константы и ее значение. После определения значения константы можно получить доступ в любое время, просто сославшись на ее имя. Вот простой пример:
<?php
// Определяем константы
define("SITE_URL", "https://youtube.com/");
// Используем константу
echo 'Thank you for visiting - ' . SITE_URL;
?>Сохраняя значение в константе вместо переменной, вы можете быть уверены, что значение не изменится случайно при запуске вашего приложения.
Имя констант должно соответствовать тем же правилам, что и имена переменных; это означает, что допустимое имя константы должно начинаться с буквы или символа подчеркивания, за которым следует любое количество букв, цифр или подчеркиваний с одним исключением: префикс $ не требуется для имен констант.
По соглашению имена констант обычно пишутся заглавными буквами. Это сделано для их простой идентификации и отличия от переменных в исходном коде.
Оператор echo может выводить одну или несколько строк. В общих чертах, оператор echo может отображать все, что может быть отображено в браузере, например строку, число, значение переменной, результат функции и т.д.
Поскольку echo — это языковая конструкция, а не функция (как например оператор if), вы можете использовать ее без скобок, например echo или echo(). Однако, если вы хотите передать более одного параметра для echo, параметры не должны быть заключены в круглые скобки.
В следующем примере показано, как отобразить строку текста с помощью оператора echo:
<?php
// Отображение строки текста
echo "Hello World!";
?>В следующем примере показано, как отображать HTML-код с помощью оператора echo:
<?php
// Отображение HTML-кода
echo "<h4>Это простой заголовок.</h4>";
echo "<h4 style='color: red;'>Это простой заголовок с красным стилем.</h4>";
?>В следующем примере показано, как отображать переменные с помощью оператора echo:
<?php
// Определение переменных
$txt = "Hello World!";
$num = 123456789;
$colors = array("Red", "Green", "Blue");
// Отображение переменных
echo $txt;
echo "<br>";
echo $num;
echo "<br>";
echo $colors[0];
?>Вы также можете использовать конструкцию print как альтернативу echo для отображения вывода в браузере. Как и echo, print также является конструкцией языка, а не функцией. Таким образом, вы также можете использовать его без скобок, например: print или print().
Операторы echo и print работают одинаково, за исключением того, что оператор print может выводить только одну строку и всегда возвращает 1. Оператор echo считается немного быстрее, чем оператор print, поскольку он не возвращает никакого значения.
В следующем примере показано, как отобразить строку текста с помощью оператора print:
<?php
// Отображение строки текста
print "Hello World!";
?>В следующем примере показано, как отображать HTML-код с помощью оператора print:
<?php
// Отображение HTML-кода
print "<h4>Это простой заголовок.</h4>";
print "<h4 style='color: red;'>Это простой заголовок с красным стилем.</h4>";
?>В следующем примере показано, как отображать переменные с помощью оператора print:
<?php
// Определение переменных
$txt = "Hello World!";
$num = 123456789;
$colors = array("Red", "Green", "Blue");
// Отображение переменных
print $txt;
print "<br>";
print $num;
print "<br>";
print $colors[0];
?>Значения, присвоенные переменной PHP, могут относиться к различным типам данных, включая простые строковые и числовые типы, а также более сложные типы данных, такие как массивы и объекты.
PHP поддерживает всего восемь примитивных типов данных: целое число, число с плавающей запятой, строка, логическое значение, массив, объект, ресурс и NULL. Эти типы данных используются для создания переменных. А теперь давайте подробно обсудим каждый из них.
Целые числа Integers — это числа без знака десятичной точки (…, -2, -1, 0, 1, 2, …). Целые числа могут быть указаны в десятичном (основание 10), шестнадцатеричном (основание 16 — с префиксом 0x) или восьмеричном (основание 8 — с префиксом 0) нотации, необязательно с предшествующим знаком (- или +).
<?php
$a = 123; // десятичное число
var_dump($a);
echo "<br>";
$b = -123; // отрицательное число
var_dump($b);
echo "<br>";
$c = 0x1A; // шестнадцатеричное число
var_dump($c);
echo "<br>";
$d = 0123; // восьмеричное число
var_dump($d);
?>Начиная с PHP 5.4+, вы также можете указывать целые числа в двоичной (основание 2) нотации. Чтобы использовать двоичную запись, перед числом укажите 0b (например $var = 0b11111111;).
Строки Strings могут содержать буквы, цифры и специальные символы; они могут иметь размер до 2 ГБ (максимум 2147483647 байт). Самый простой способ указать строку — заключить ее в одинарные кавычки (например, Hello world!), но вы также можете использовать двойные кавычки "Hello world!".
<?php
$a = 'Hello world!';
echo $a;
echo "<br>";
$b = "Hello world!";
echo $b;
echo "<br>";
$c = 'Stay here, I\\'ll be back.';
echo $c;
?>Числа с плавающей запятой (Floating Point, Doubles или Real Numbers) представляют собой десятичные или дробные числа, как показано в примере ниже.
<?php
$a = 1.234;
var_dump($a);
echo "<br>";
$b = 10.2e3;
var_dump($b);
echo "<br>";
$c = 4E-10;
var_dump($c);
?>Логические значения похожи на переключатель с двумя возможными значениями: 1 (true) или 0 (false).
<?php
// // Присваиваем значение TRUE переменной
$show_error = true;
var_dump($show_error);
?>Массив — это переменная, которая может одновременно содержать больше одного значения. Полезно объединить ряд связанных элементов вместе, например, набор названий стран или городов.
Массив формально определяется как индексированный набор значений данных. Каждый индекс (также известный как ключ) массива уникален и ссылается на соответствующее значение.
<?php
$colors = array("Red", "Green", "Blue");
var_dump($colors);
echo "<br>";
$color_codes = array(
"Red" => "#ff0000",
"Green" => "#00ff00",
"Blue" => "#0000ff"
);
var_dump($color_codes);
?>Объект — это тип данных, который позволяет не только хранить данные, но и информацию о том, как обрабатывать эти данные. Объект — это конкретный экземпляр класса, который служит шаблоном для объекта. Объекты создаются на основе этого шаблона с помощью ключевого слова new.
Каждый объект имеет свойства и методы, соответствующие свойствам и методам его родительского класса. Каждый экземпляр объекта полностью независим, имеет свои собственные свойства и методы, и поэтому им можно управлять независимо от других объектов того же класса.
Вот простой пример определения класса, за которым следует создание объекта.
<?php
// Определение класса
class greeting{
// Свойства
public $str = "Hello World!";
// Методы
function show_greeting(){
return $this->str;
}
}
// Создаем объект из класса
$message = new greeting;
var_dump($message);
?>Элементы данных, хранящиеся в объекте, называются его свойствами, а информация или код, описывающий, как обрабатывать данные, называется методами объекта.
Специальное значение NULL используется для представления пустых переменных в PHP. Переменная типа NULL — это переменная без данных. NULL — единственное возможное значение типа null.
<?php
$a = NULL;
var_dump($a);
echo "<br>";
$b = "Hello World!";
$b = NULL;
var_dump($b);
?>Когда переменная создается без значения в PHP, например $var; ему автоматически присваивается значение null. Многие начинающие PHP-разработчики ошибочно считают, что $var1 = NULL; и $var2 = ""; одно и тоже, но это не так. Переменная $var1 имеет нулевое значение, а $var2 указывает, что ей не присвоено значения.
Ресурс — это специальная переменная, содержащая ссылку на внешний ресурс.
Переменные ресурса обычно содержат специальные обработчики для открытых файлов и соединений с базой данных.
<?php
// Открываем файл для чтения
$handle = fopen("note.txt", "r");
var_dump($handle);
echo "<br>";
// Подключаемся к серверу базы данных MySQL с настройкой по умолчанию
$link = mysql_connect("localhost", "root", "");
var_dump($link);
?>Строка — это последовательность букв, цифр, специальных символов, арифметических значений или их комбинация. Самый простой способ создать строку — заключить строковый литерал (то есть строковые символы) в одинарные кавычки ', например:
$my_string = 'Hello World';Вы также можете использовать двойные кавычки ". Однако одинарные и двойные кавычки работают по-разному. Строки, заключенные в одинарные кавычки, обрабатываются почти буквально, тогда как строки, разделенные двойными кавычками, заменяют переменные строковыми представлениями их значения, а также специальной интерпретацией определенных escape-последовательностей.
Замены escape-последовательности:
\n заменяется символом новой строки\r заменяется символом возврата каретки\t заменяется символом табуляции\$ заменяется самим знаком доллара $\" заменяется одинарной двойной кавычкой "\\\\ заменяется одиночной обратной косой чертой \\Вот пример, поясняющий разницу между строками в одинарных и двойных кавычках:
<?php
$my_str = 'World';
echo "Hello, $my_str!<br>"; // Отображает: Hello World!
echo 'Hello, $my_str!<br>'; // Отображает: Hello, $my_str!
echo '<pre>Hello\tWorld!</pre>'; // Отображает: Hello\tWorld!
echo "<pre>Hello\tWorld!</pre>"; // Отображает: Hello World!
echo 'I\'ll be back'; // Отображает: I'll be back
?>Функция strlen() используется для вычисления количества символов внутри строки. Она также включает в себя пробелы внутри строки.
<?php
$my_str = 'Welcome to Zolin Digital';
// Выводим: 28
echo strlen($my_str);
?>Функция str_word_count() подсчитывает количество слов в строке.
<?php
$my_str = 'The quick brown fox jumps over the lazy dog.';
// Выводим: 9
echo str_word_count($my_str);
?>Функция str_replace() заменяет все вхождения искомого текста в целевой строке.
<?php
$my_str = 'If the facts do not fit the theory, change the facts.';
// Выводим замененную строку
echo str_replace("facts", "truth", $my_str);
?>При желании вы можете передать четвертый аргумент функции str_replace(), чтобы узнать, сколько раз были выполнены замены строк, например:
<?php
$my_str = 'If the facts do not fit the theory, change the facts.';
// Выполняем замену строки
str_replace("facts", "truth", $my_str, $count);
// Выводим количество выполненных замен
echo "The text was replaced $count times.";
?>Функция strrev() отображает строку в обратном направлении.
<?php
$my_str = 'You can do anything, but not everything.';
// Выводим перевернутую строку
echo strrev($my_str);
?>Операторы — это символы, которые говорят процессору PHP выполнить определенные действия. Например, символ сложения + — это оператор, который сообщает PHP о необходимости добавления двух переменных или значений, а символ «больше» > — это оператор, который сообщает PHP о необходимости сравнения двух значений.
Арифметические операторы используются для выполнения общих арифметических операций, таких как сложение, вычитание, умножение и т.д. Вот полный список арифметических операторов PHP:
| Оператор | Описание | Пример | Результат |
|---|---|---|---|
| + | Сложение | $x + $y | Сумма $x и $y |
| - | Вычитание | $x - $y | Разница $x и $y |
| * | Умножение | $x * $y | Умножение $x на $y |
| / | Деление | $x / $y | Деление $x на $y |
| % | Деление по модулю | $x % $y | Остаток $x деленный на $y |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = 10;
$y = 4;
echo($x + $y); // Вывод: 14
echo($x - $y); // Вывод: 6
echo($x * $y); // Вывод: 40
echo($x / $y); // Вывод: 2.5
echo($x % $y); // Вывод: 2
?>| Оператор | Описание | Пример | Тоже самое |
|---|---|---|---|
| = | Присвоить | $x = $y | $x = $y |
| += | Добавить и присвоить | $x += $y | $x = $x + $y |
| -= | Вычесть и присвоить | $x -= $y | $x = $x - $y |
| *= | Умножить и присвоить | $x *= $y | $x = $x * $y |
| /= | Разделить и присвоить частное | $x /= $y | $x = $x / $y |
| %= | Разделить и присвоить модуль | $x %= $y | $x = $x % $y |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = 10;
echo $x; // Вывод: 10
$x = 20;
$x += 30;
echo $x; // Вывод: 50
$x = 50;
$x -= 20;Операторы сравнения используются для сравнения двух значений логическим способом.
| Оператор | Имя | Пример | Результат |
|---|---|---|---|
| == | Равенство | $x == $y | Истинно, если $x равно $y |
| === | Строгое равенство | $x === $y | Верно, если $x равно $y, и они одного типа |
| != | Не равно | $x != $y | Истинно, если $x не равно $y |
| <> | Не равно | $x <> $y | Истинно, если $x не равно $y |
| !== | Не строгое равенство | $x !== $y | Истинно, если $x не равно $y или они не одного типа |
| < | Меньше, чем | $x < $y | Истинно, если $x меньше $y |
| > | Больше, чем | $x > $y | Истинно, если $x больше $y |
| >= | Больше или равно | $x >= $y | Истинно, если $x больше или равно $y |
| <= | Меньше или равно | $x <= $y | Истинно, если $x меньше или равно $y |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = 25;
$y = 35;
$z = "25";
var_dump($x == $z); // Вывод: boolean true
var_dump($x === $z); // Вывод: boolean false
var_dump($x != $y); // Вывод: boolean true
var_dump($x !== $z); // Вывод: boolean true
var_dump($x < $y); // Вывод: boolean true
var_dump($x > $y); // Вывод: boolean false
var_dump($x <= $y); // Вывод: boolean true
var_dump($x >= $y); // Вывод: boolean false
?>Операторы увеличения / уменьшения используются для увеличения / уменьшения значения переменной.
| Оператор | Название | Эффект |
|---|---|---|
| ++$x | Pre-increment | Увеличивает $x на единицу, затем возвращает $x |
| $x++ | Post-increment | Возвращает $x, затем увеличивает $x на единицу |
| --$x | Pre-decrement | Уменьшает $x на единицу, затем возвращает $x |
| $x-- | Post-decrement | Возвращает $x, затем уменьшает $x на единицу |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = 10;
echo ++$x; // Вывод: 11
echo $x; // Вывод: 11
$x = 10;
echo $x++; // Вывод: 10
echo $x; // Вывод: 11
$x = 10;
echo --$x; // Вывод: 9
echo $x; // Вывод: 9
$x = 10;
echo $x--; // Вывод: 10
echo $x; // Вывод: 9
?>Логические операторы обычно используются для объединения условных операторов.
| Оператор | Имя | Пример | Результат |
|---|---|---|---|
| and | И | $x и $y | Верно, если $x и $y верны |
| or | Или | $x or $y | Истинно, если либо $x, либо $y истинно |
| xor | X или | $x xor $y | Верно, если либо $x, либо $y истинно, но не оба |
| && | И | $x && $y | Верно, если $x и $y верны |
| Или | $x | $y | Истинно, если истинно значение $x или $y |
| ! | Нет | !$x | Верно, если $x неверно |
Следующий пример покажет вам эти операторы в действии:
<?php
$year = 2014;
// Високосные годы делятся на 400 или на 4, но не на 100
if(($year % 400 == 0) || (($year % 100 != 0) && ($year % 4 == 0))){
echo "$year is a leap year.";
} else{
echo "$year is not a leap year.";
}
?>Есть два оператора, специально разработанные для строк.
| Оператор | Описание | Пример | Результат |
|---|---|---|---|
| . | Конкатенация | $str1 . $str2 | Объединение $str1 и $str2 |
| .= | Присваивание конкатенации | $str1 .= $str2 | Добавляет $str2 к $str1 |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = "Hello";
$y = " World!";
echo $x . $y; // Вывод: Hello World!
$x .= $y;
echo $x; // Вывод: Hello World!
?>Операторы массива используются для сравнения массивов:
| Оператор | Название | Пример | Результат |
|---|---|---|---|
| + | Объединение | $x + $y | Объединение $x и $y |
| == | Равенство | $x == $y | Истинно, если $x и $y имеют одинаковые пары ключ / значение |
| === | Тождественность | $x === $y | Истинно, если $x и $y имеют одинаковые пары ключ / значение в одинаковом порядке и одного типа. |
| != | Неравенство | $x != $y | Истинно, если $x не равно $y |
| <> | Неравенство | $x <> $y | Истинно, если $x не равно $y |
| !== | Не-тождественность | $x !== $y | Истинно, если $x не совпадает с $y |
Следующий пример покажет вам эти операторы в действии:
<?php
$x = array("a" => "Red", "b" => "Green", "c" => "Blue");
$y = array("u" => "Yellow", "v" => "Orange", "w" => "Pink");
$z = $x + $y; // Объединение $x и $y
var_dump($z);
var_dump($x == $y); // Вывод: boolean false
var_dump($x === $y); // Вывод: boolean false
var_dump($x != $y); // Вывод: boolean true
var_dump($x <> $y); // Вывод: boolean true
var_dump($x !== $y); // Вывод: boolean true
?>PHP 7 представляет новый оператор «космического корабля» (<=>), который можно использовать для сравнения двух выражений. Он также известен как комбинированный оператор сравнения.
Оператор космического корабля возвращает 0, если оба операнда равны; 1, если левый больше; -1, если больше правый. В основном он обеспечивает трехстороннее сравнение, как показано в следующей таблице:
| Оператор | <=> Эквивалент |
|---|---|
| $x < $y | ($x <=> $y) === -1 |
| $x <= $y | ($x <=> $y) === -1 |
| $x == $y | ($x <=> $y) === 0 |
| $x != $y | ($x <=> $y) !== 0 |
| $x >= $y | ($x <=> $y) === 1 |
| $x > $y | ($x <=> $y) === 1 |
Следующий пример покажет вам, как на самом деле работает оператор космического корабля:
<?php
// Сравнение целых чисел
echo 1 <=> 1; // Вывод: 0
echo 1 <=> 2; // Вывод: -1
echo 2 <=> 1; // Вывод: 1
// Сравнение
echo 1.5 <=> 1.5; // Вывод: 0
echo 1.5 <=> 2.5; // Вывод: -1
echo 2.5 <=> 1.5; // Вывод: 1
// Сравнение строк
echo "x" <=> "x"; // Вывод: 0
echo "x" <=> "y"; // Вывод: -1
echo "y" <=> "x"; // Вывод: 1
?>Как и большинство языков программирования, PHP также позволяет писать код, который выполняет различные действия на основе результатов логических или сравнительных условий во время выполнения. Это означает, что вы можете создавать условия тестирования в форме выражений, которые оцениваются как true или false, и на основе этих результатов вы можете выполнять определенные действия.
В PHP есть несколько операторов, которые можно использовать для принятия решений:
Мы рассмотрим каждый из них в этом разделе.
Оператор if используется для выполнения блока кода только в том случае, если указанное условие истинно. Это простейший условный оператор PHP, который можно записать так:
if(condition) {
// Код для выполнения
}В следующем примере будет выведено «Хороших выходных!» если текущий день пятница:
<?php
$d = date("D");
if($d == "Fri") {
echo "Хороших выходных!";
}
?>Вы можете улучшить процесс принятия решений, предоставив альтернативный выбор, добавив оператор else к оператору if. Оператор if…else позволяет вам выполнить один блок кода, если указанное условие оценивается как истинное, и другой блок кода, если оно оценивается как ложное. Его можно записать так:
if(condition) {
// Код для выполнения, если условие condition верно
} else {
// Код для выполнения, если условие condition ложно
}В следующем примере будет выведено «Хороших выходных!» если текущий день — пятница, иначе будет выведено «Хорошего дня!»
<?php
$d = date("D");
if($d == "Fri") {
echo "Хороших выходных!";
} else {
echo "Хорошего дня!";
}
?>if… elseif… else — специальный оператор, который используется для объединения нескольких операторов if… else.
if(condition1) {
// Код для выполнения, если condition1 истинно
} elseif(condition2) {
// Код для выполнения, если condition1 ложно, а condition2 истинно
} else{
// Код для выполнения, если и condition1, и condition2 ложны
}В следующем примере будет выведено «Хороших выходных!» если текущий день пятница, и «Хорошего воскресенья!» если текущий день — воскресенье, иначе будет выведено «Хорошего дня!»
<?php
$d = date("D");
if($d == "Fri") {
echo "Хороших выходных!";
} elseif($d == "Sun") {
echo "Хорошего воскресенья!";
} else {
echo "Хорошего дня!";
}
?>Тернарный оператор обеспечивает сокращенный способ написания операторов if… else. Тернарный оператор представлен знаком вопроса ? и принимает три операнда: условие для проверки, результат для true и результат для false.
<?php
if($age < 18) {
echo 'Child'; // Отображаем "Child", если возраст меньше 18
} else {
echo 'Adult'; // Отображаем "Adult", если возраст больше или равен 18
}
?>Используя тернарный оператор, тот же код можно написать более компактно:
<?php echo ($age < 18) ? 'Child' : 'Adult'; ?>Тернарный оператор в приведенном выше примере выбирает значение слева от двоеточия (т.е. 'Child'), если условие оценивается как истинное (т.е. если $age меньше 18), и выбирает значение справа от двоеточия (т.е. 'Adult'), если условие оценивается как ложное.
Код, написанный с использованием тернарного оператора, может быть трудночитаемым. Однако это отличный способ писать компактные операторы if-else.
PHP 7 представляет новый оператор объединения с нулевым значением ??, который вы можете использовать как сокращение, когда вам нужно использовать тернарный оператор в сочетании с функцией isset().
Чтобы лучше понять это, рассмотрим следующую строку кода. Он извлекает значение $_GET['name'], если оно не существует или NULL, оно возвращает anonymous.
<?php
$name = isset($_GET['name']) ? $_GET['name'] : 'anonymous';
?>Используя нулевой оператор объединения, тот же код можно записать как:
<?php
$name = $_GET['name'] ?? 'anonymous';
?>Как видите, этот синтаксис более компактен и прост в написании.
Оператор switch-case является альтернативой оператору if-elseif-else, который делает почти то же самое. Оператор switch-case проверяет переменную на соответствие серии значений, пока не найдет совпадение, а затем выполняет блок кода, соответствующий этому совпадению.
switch(n) {
case label1:
// Код для выполнения, если n=label1
break;
case label2:
// Код для выполнения, если n=label2
break;
...
default:
// Код для выполнения, если n отличается от всех меток
}Рассмотрим следующий пример, в котором для каждого дня отображаются разные сообщения.
<?php
$today = date("D");
switch($today) {
case "Mon":
echo "Сегодня понедельник. Нужно убрать в своем доме.";
break;
case "Tue":
echo "Сегодня вторник. Нужно купить немного еды.";
break;
case "Wed":
echo "Сегодня среда. Нужно посетите врача.";
break;
case "Thu":
echo "Сегодня четверг. Нужно отремонтировать свою машину.";
break;
case "Fri":
echo "Сегодня пятница. У нас запланирована вечеринка.";
break;
case "Sat":
echo "Сегодня суббота. Время кино.";
break;
case "Sun":
echo "Сегодня воскресенье. Пора немного отдохнуть.";
break;
default:
echo "Нет информации на этот день.";
break;
}
?>У switch-case есть одно важное отличие от оператора if-elseif-else. Оператор switch выполняется строка за строкой (т.е. оператор за оператором), и как только PHP находит оператор case, который оценивается как истинный, он не только выполняет код, соответствующий этому оператору case, но также выполняет все последующие операторы case до конца.
Чтобы предотвратить это, нужно добавить оператор break в конец каждого блока case. Оператор break сообщает PHP выйти из блока операторов switch-case после выполнения кода, связанного с первым истинным случаем.
Массивы — это сложные переменные, которые позволяют нам хранить группу значений под одним именем переменной. Предположим, вы хотите сохранить цвета в своем PHP-скрипте. Сохранение цветов по одному в переменной может выглядеть примерно так:
<?php
$color1 = "Red";
$color2 = "Green";
$color3 = "Blue";
?>Но что, если вы хотите сохранить названия штатов или городов страны в переменных, и на этот раз их не три, а несколько сотен. Хранить название каждого города в отдельной переменной — это довольно сложно. Для этого используются массивы.
Вы можете создавать массивы трех типов:
В индексированном или числовом массиве каждый элемент массива хранится с числовым индексом. В следующих примерах показаны два способа создания индексированного массива, самый простой способ:
<?php
// Определяем индексированный массив
$colors = array("Red", "Green", "Blue");
?>В индексированном или числовом массиве индексы назначаются автоматически и начинаются с 0, а значения могут быть любого типа данных. Это эквивалентно следующему примеру, в котором индексы назначаются вручную:
<?php
$colors[0] = "Red";
$colors[1] = "Green";
$colors[2] = "Blue";
?>В ассоциативном массиве ключи, присвоенные значениям, могут быть произвольными и определяемыми пользователем строками. В следующем примере в массиве используются ключи вместо номеров индексов:
<?php
// Определяем ассоциативный массив
$ages = array("Peter"=>22, "Clark"=>32, "John"=>28);
?>Следующий пример эквивалентен предыдущему, но показывает другой способ создания ассоциативных массивов:
<?php
$ages["Peter"] = "22";
$ages["Clark"] = "32";
$ages["John"] = "28";
?>Многомерный массив — это массив, в котором каждый элемент также может быть массивом и каждый элемент во вложенном массиве может быть массивом или дополнительно содержать массив внутри себя и так далее. Пример многомерного массива будет выглядеть примерно так:
<?php
// Определяем многомерный массив
$contacts = array(
array(
"name" => "Peter Parker",
"email" => "peterparker@mail.com",
),
array(
"name" => "Clark Kent",
"email" => "clarkkent@mail.com",
),
array(
"name" => "Harry Potter",
"email" => "harrypotter@mail.com",
)
);
// Доступ к вложенному значению
echo "Peter Parker's Email-id is: " . $contacts[0]["email"];
?>Вы можете увидеть структуру и значения любого массива, используя один из двух операторов — var_dump() или print_r(). Однако оператор print_r() дает несколько меньше информации. Рассмотрим следующий пример:
<?php
// Определяем массив
$cities = array("London", "Paris", "New York");
// Определяем массив городов
print_r($cities);
// Выводит на экран: Array ( [0] => London [1] => Paris [2] => New York )
?>Этот вывод показывает ключ и значение для каждого элемента в массиве. Чтобы получить дополнительную информацию, используйте следующую конструкцию:
<?php
// Определяем массив
$cities = array("London", "Paris", "New York");
// Определяем массив городов
var_dump($cities);
// Выводит на экран: array(3) { [0]=> string(6) "London" [1]=> string(5) "Paris" [2]=> string(8) "New York" }
?>Эти выходные данные показывают тип данных каждого элемента, например строку из 6 символов, в дополнение к ключу и значению.
В предыдущей главе мы узнали основы массивов PHP, т.е. что такое массивы, как их создавать, как просматривать их структуру, как получить доступ к их элементам и т.д. С массивами можно делать еще больше вещей, например, сортировать элементы в любом порядке.
В PHP есть ряд встроенных функций, разработанных специально для сортировки элементов массивов различными способами, например, в алфавитном, числовом, возрастающем или убывающем порядке. Здесь мы рассмотрим некоторые из этих функций, наиболее часто используемых для сортировки массивов:
sort() и rsort() — для сортировки индексированных массивов;asort() и arsort() — для сортировки ассоциативных массивов по значению;ksort() и krsort() — для сортировки ассоциативных массивов по ключу.Функция sort() используется для сортировки элементов индексированного массива в порядке возрастания (в алфавитном порядке для букв и в числовом для чисел).
<?php
// Определяем массив
$colors = array("Red", "Green", "Blue", "Yellow");
// Сортируем и печатаем массив
sort($colors);
print_r($colors);
// Выводит: Array ( [0] => Blue [1] => Green [2] => Red [3] => Yellow )
?>Точно так же вы можете отсортировать числовые элементы массива в порядке возрастания.
<?php
// Определяем массив
$numbers = array(1, 2, 2.5, 4, 7, 10);
// Сортируем и печатаем массив
sort($numbers);
print_r($numbers);
// Выводит: Array ( [0] => 1 [1] => 2 [2] => 2.5 [3] => 4 [4] => 7 [5] => 10 )
?>Функция rsort() используется для сортировки элементов индексированного массива в порядке убывания (в алфавитном порядке для букв и в числовом для чисел).
<?php
// Определяем массив
$colors = array("Red", "Green", "Blue", "Yellow");
// Сортируем и печатаем массив
rsort($colors);
print_r($colors);
// Выводит: Array ( [0] => Yellow [1] => Red [2] => Green [3] => Blue )
?>Аналогичным образом вы можете отсортировать числовые элементы массива в порядке убывания.
<?php
// Определяем массив
$numbers = array(1, 2, 2.5, 4, 7, 10);
// Сортируем и печатаем массив
rsort($numbers);
print_r($numbers);
// Выводит: Array ( [0] => 10 [1] => 7 [2] => 4 [3] => 2.5 [4] => 2 [5] => 1 )
?>Функция asort() сортирует элементы ассоциативного массива в порядке возрастания в соответствии со значением. Она работает так же, как sort(), но сохраняет связь между ключами и их значениями при сортировке.
<?php
// Определяем массив
$age = array("Peter"=>20, "Harry"=>14, "John"=>45, "Clark"=>35);
// Сортируем по значению и печатаем массив
asort($age);
print_r($age);
// Выводит: Array ( [Harry] => 14 [Peter] => 20 [Clark] => 35 [John] => 45 )
?>Функция arsort() сортирует элементы ассоциативного массива в порядке убывания по значению. Она работает так же, как rsort(), но сохраняет связь между ключами и их значениями при сортировке.
<?php
// Определяем массив
$age = array("Peter"=>20, "Harry"=>14, "John"=>45, "Clark"=>35);
// Сортируем по значению и печатаем массив
arsort($age);
print_r($age);
// Выводит: Array ( [John] => 45 [Clark] => 35 [Peter] => 20 [Harry] => 14 )
?>Функция ksort() сортирует элементы ассоциативного массива в порядке возрастания по их ключам. Она сохраняет связь между ключами и их значениями при сортировке, как и функция asort().
<?php
// Определяем массив
$age = array("Peter"=>20, "Harry"=>14, "John"=>45, "Clark"=>35);
// Сортируем по ключу и печатаем массив
ksort($age);
print_r($age);
// Выводит: Array ( [Clark] => 35 [Harry] => 14 [John] => 45 [Peter] => 20 )
?>Функция krsort() сортирует элементы ассоциативного массива в порядке убывания их ключей. Она сохраняет связь между ключами и их значениями при сортировке, как и функция arsort().
<?php
// Определяем массив
$age = array("Peter"=>20, "Harry"=>14, "John"=>45, "Clark"=>35);
// Сортируем по ключу и печатаем массив
krsort($age);
print_r($age);
// Выводит: Array ( [Peter] => 20 [John] => 45 [Harry] => 14 [Clark] => 35 )
?>Циклы в PHP используются для выполнения одного и того же блока кода снова и снова, пока выполняется определенное условие. Основная идея цикла — автоматизировать повторяющиеся задачи в программе для экономии времени и усилий. PHP поддерживает четыре различных типа циклов.
Вы также узнаете, как перебирать значения массива с помощью цикла foreach() в конце этой главы. Цикл foreach() работает специально для массивов.
Оператор while будет перебирать блок кода до тех пор, пока условие, указанное в операторе while, будет истинным.
while(condition) {
// Код для выполнения
}В приведенном ниже примере определяется цикл, который начинается с $i=1. Цикл будет продолжать выполняться до тех пор, пока $i меньше или равно 3. Значение $i будет увеличиваться на 1 при каждой итерации цикла:
<?php
$i = 1;
while($i <= 3) {
$i++;
echo "The number is " . $i . "<br>";
}
?>Цикл do… while — это вариант цикла while, который проверяет условие в конце каждой итерации цикла. В цикле do… while блок кода выполняется один раз, а затем условие проверяется; если условие истинно, оператор повторяется до тех пор, пока указанное условие, которое является истинным.
do{
// Код для выполнения
}
while(condition);В следующем примере цикл начинается с $i=1. Затем он увеличивает $i на 1 и печатает результат. Затем условие проверяется и цикл продолжается пока $i меньше или равно 3.
<?php
$i = 1;
do{
$i++;
echo "The number is " . $i . "<br>";
}
while($i <= 3);
?>Цикл while отличается от цикла do… while одним важным аспектом — с помощью цикла while условие проверяется в начале каждой итерации цикла, поэтому, если условное выражение оценивается как ложное, цикл заканчивает выполнение.
С другой стороны, с циклом do… while цикл всегда будет выполняться один раз, даже если условное выражение ложно, потому что условие оценивается в конце итерации цикла, а не в начале.
Цикл for исполняет блок кода, пока выполняется определенное условие. Обычно он используется для выполнения блока кода определенное количество раз.
for(initialization; condition; increment) {
// Код для выполнения
}Параметры цикла for имеют следующие значения:
initialization — используется для инициализации переменных счетчика и вычисляется один раз безоговорочно перед первым выполнением тела цикла;condition — в начале каждой итерации проверяется состояние. Если оно имеет значение true, цикл продолжается, и выполняются вложенные операторы. Если оно принимает значение false выполнение цикла завершается;increment — обновляет счетчик цикла новым значением. Оно проверяется в конце каждой итерации.В приведенном ниже примере цикл начинается с $i=1. Цикл будет продолжаться до тех пор, пока $i не станет меньше или равно 3. Переменная $i будет увеличиваться на 1 каждый раз при запуске цикла:
<?php
for($i=1; $i<=3; $i++){
echo "The number is " . $i . "<br>";
}
?>Цикл foreach используется для перебора массивов.
foreach($array as $value) {
// Код для выполнения
}В следующем примере демонстрируется цикл, который будет печатать значения данного массива:
<?php
$colors = array("Red", "Green", "Blue");
// Цикл массива цветов
foreach($colors as $value) {
echo $value . "<br>";
}
?>Есть еще один синтаксис цикла foreach, который является расширенной версией первого.
foreach($array as $key => $value) {
// Код для выполнения
}<?php
$superhero = array(
"name" => "Peter Parker",
"email" => "peterparker@mail.com",
"age" => 18
);
// Цикл массива супергероев
foreach($superhero as $key => $value) {
echo $key . " : " . $value . "<br>";
}
?>Функция — это автономный блок кода, который выполняет определенную задачу.
PHP имеет огромную колличество внутренних или встроенных функций, которые вы можете вызывать непосредственно в своих PHP-скриптах для выполнения конкретной задачи, например gettype(), print_r(), var_dump и т. д.
Пожалуйста, ознакомьтесь с разделом справки по PHP, чтобы получить полный список полезных встроенных функций PHP.
В дополнение к встроенным функциям PHP также позволяет вам определять свои собственные функции. Это способ создания повторно используемых пакетов кода, которые выполняют определенные задачи и могут храниться и поддерживаться отдельно от основной программы. Вот некоторые преимущества использования функций:
Базовый синтаксис создания пользовательской функции может быть задан следующим образом:
function functionName() {
// Код для выполнения
}Объявление пользовательской функции начинается со слова function, за которым следует имя функции, которую вы хотите создать, после нее круглые скобки, т.е. (), и, наконец, сам код вашей функции должен быть расположен между фигурными скобками {}.
Вот простой пример пользовательской функции, отображающей сегодняшнюю дату:
<?php
// Определяем функцию
function whatIsToday() {
echo "Today is " . date('l', mktime());
}
// Вызываем функцию
whatIsToday();
?>Имя функции должно начинаться с буквы или символа подчеркивания, а не с числа; за первым символом могут следовать дополнительные буквы, цифры или символы подчеркивания. Имена функций нечувствительны к регистру.
Вы можете указать параметры, когда определяете свою функцию для приема входящих значений во время выполнения. Параметры работают как переменные-заполнители внутри функции; они заменяются во время выполнения функции значениями (называемыми аргументами).
function myFunc($oneParameter, $anotherParameter) {
// Код для выполнения
}Вы можете определить столько параметров, сколько захотите. Однако для каждого указанного вами параметра при вызове функции необходимо передать соответствующий аргумент.
Функция getSum() в следующем примере принимает в качестве аргументов два целочисленных значения, просто складывает их вместе и затем отображает результат в браузере.
<?php
// Определяем функцию
function getSum($num1, $num2) {
$sum = $num1 + $num2;
echo "Сумма двух чисел $num1 и $num2 равна: $sum";
}
// Вызываем функцию
getSum(10, 20); // Выводит: 30
?>Аргумент — это значение, которое вы передаете функции, а параметр — это переменная внутри функции, которая получает аргумент. Однако в обычном использовании эти термины взаимозаменяемы.
Вы также можете создавать функции с необязательными параметрами — просто вставьте имя параметра, затем знак равенства = и значение по умолчанию, как здесь:
<?php
// Определяем функцию
function customFont($font, $size=1.5) {
echo "<p style=\"font-family: $font; font-size: {$size}em;\">Hello, world!</p>";
}
// Вызываем функцию
customFont("Arial", 2);
customFont("Times", 3);
customFont("Courier");
?>Как видите, третий вызов customFont() не включает второй аргумент. Это заставляет механизм PHP использовать значение по умолчанию для параметра $size, равное 1,5.
Функция может вернуть значение скрипту, который вызвал функцию, используя оператор return. Значение может быть любого типа, включая массивы и объекты.
<?php
// Определяем функцию
function getSum($num1, $num2) {
$total = $num1 + $num2;
return $total;
}
// Печатаем возвращенное значение
echo getSum(5, 10); // Выводит: 15
?>Функция не может возвращать несколько значений. Однако вы можете получить аналогичные результаты, вернув массив, как показано в следующем примере.
<?php
// Определяем функцию
function divideNumbers($dividend, $divisor){
$quotient = $dividend / $divisor;
$array = array($dividend, $divisor, $quotient);
return $array;
}
// Назнаем переменные, как если бы они были массивом
list($dividend, $divisor, $quotient) = divideNumbers(10, 2);
echo $dividend; // Выводит: 10
echo $divisor; // Выводит: 2
echo $quotient; // Выводит: 5
?>В PHP есть два способа передать аргументы функции: по значению value и по ссылке reference. По умолчанию аргументы функции передаются по значению, поэтому, если значение аргумента внутри функции изменяется, оно не затрагивается за пределами функции. Однако, чтобы функция могла изменять свои аргументы, они должны передаваться по ссылке.
Передача аргумента по ссылке выполняется путем добавления амперсанда & к имени аргумента в определении функции, как показано в примере ниже:
<?php
/* Определяем функцию умножения числа
само по себя и возвращаем новое значение */
function selfMultiply(&$number){
$number *= $number;
return $number;
}
$mynum = 5;
echo $mynum; // Выводит: 5
selfMultiply($mynum);
echo $mynum; // Выводит: 25
?>Вы можете объявить переменные где угодно в PHP-скрипте. Но расположение объявления определяет степень видимости переменной в PHP-программе, т.е. где переменная может быть использована или доступна. Эта доступность известна как область видимости переменных variable scope.
По умолчанию переменные, объявленные внутри функции, являются локальными, и их нельзя использовать и управлять извне, как показано в примере ниже:
<?php
// Определяем функцию
function test() {
$greet = "Hello World!";
echo $greet;
}
test(); // Выводит: Hello World!
echo $greet; // Выводит ошибку undefined variable error
?>Точно так же, если вы попытаетесь получить доступ или импортировать внешнюю переменную внутри функции, вы получите ошибку неопределенной переменной, как показано в примере:
<?php
$greet = "Hello World!";
// Определяем функцию
function test() {
echo $greet;
}
test(); // Выводит ошибку undefined variable error
echo $greet; // Выводит: Hello World!
?>Как вы можете видеть в приведенных выше примерах, переменная, объявленная внутри функции, недоступна извне, точно так же переменная, объявленная вне функции, недоступна внутри функции. Это разделение снижает вероятность того, что переменные в функции будут затронуты переменными в основной программе.
Можно повторно использовать одно и то же имя для переменной в разных функциях, поскольку локальные переменные распознаются только функцией, в которой они объявлены.
Может возникнуть ситуация, когда вам нужно импортировать переменную из основной программы в функцию или наоборот. В таких случаях вы можете использовать ключевое слово global перед переменными внутри функции. Это ключевое слово превращает переменную в глобальную, делая ее видимой или доступной как внутри, так и вне функции, как показано в примере ниже:
<?php
$greet = "Hello World!";
// Определяем функцию
function test() {
global $greet;
echo $greet;
}
test(); // Выводит: Hello World!
echo $greet; // Выводит: Hello World!
// Присваиваем новое значение переменной
$greet = "Goodbye";
test(); // Выводит: Goodbye
echo $greet; // Выводит: Goodbye
?>Рекурсивная функция — это функция, которая вызывает себя снова и снова, пока не будет выполнено условие. Рекурсивные функции часто используются для решения сложных математических вычислений или для обработки глубоко вложенных структур, например, для печати всех элементов глубоко вложенного массива.
В следующем примере показано, как работает рекурсивная функция.
<?php
// Определяем рекурсивную функцию
function printValues($arr) {
global $count;
global $items;
// Проверяем существование массива
if(!is_array($arr)){
die("ERROR: Input is not an array");
}
/*
Перебираем массив, если значение само по себе является массивом, рекурсивно вызываем эту же функцию;
функция else добавляет найденное значение в новый массив элементов $items,
и увеличивать счетчик на 1 для каждого найденного значения
*/
foreach($arr as $a){
if(is_array($a)){
printValues($a);
} else{
$items[] = $a;
$count++;
}
}
// Возвращаем общее количество и значения, найденные в массиве
return array('total' => $count, 'values' => $items);
}
// Определяем вложенный массив
$species = array(
"birds" => array(
"Eagle",
"Parrot",
"Swan"
),
"mammals" => array(
"Human",
"cat" => array(
"Lion",
"Tiger",
"Jaguar"
),
"Elephant",
"Monkey"
),
"reptiles" => array(
"snake" => array(
"Cobra" => array(
"King Cobra",
"Egyptian cobra"
),
"Viper",
"Anaconda"
),
"Crocodile",
"Dinosaur" => array(
"T-rex",
"Alamosaurus"
)
)
);
// Считаем и печатаем значения во вложенном массиве
$result = printValues($species);
echo $result['total'] . ' value(s) found: ';
echo implode(', ', $result['values']);
?>Будьте осторожны при создании рекурсивных функций, потому что, если код написан неправильно, это может привести к бесконечному циклу вызова функции. Это приведет к чрезмерной нагрузке на сервер и служба поддержки хостинга заблокирует ваш сайт до устранения ошибок.
В PHP есть несколько встроенных функций, которые помогут вам выполнить практически любую математическую операцию.
<?php
echo 7 + 3; // Вывод: 10
echo 7 - 2; // Вывод: 5
echo 7 * 2; // Вывод: 14
echo 7 / 2; // Вывод: 3.5
echo 7 % 2; // Вывод: 1
?>Каждая математическая операция имеет определенный уровень приоритета; обычно умножение и деление выполняются перед сложением и вычитанием. Однако скобки могут изменить этот приоритет; выражения, заключенные в круглые скобки, всегда считаются первыми, независимо от уровня приоритета операции, как показано в следующем примере:
<?php
echo 5 + 4 * 10; // Вывод: 45
echo (5 + 4) * 10; // Вывод: 90
echo 5 + 4 * 10 / 2; // Вывод: 25
echo 8 * 10 / 4 - 2; // Вывод: 18
echo 8 * 10 / (4 - 2); // Вывод: 40
echo 8 + 10 / 4 - 2; // Вывод: 8.5
echo (8 + 10) / (4 - 2); // Вывод: 9
?>В следующем разделе мы рассмотрим некоторые встроенные PHP-функции, которые наиболее часто используются при выполнении математических операций.
Абсолютное значение целого числа или числа с плавающей запятой можно найти с помощью функции abs(), как показано в следующем примере:
<?php
echo abs(5); // Вывод: 5 (integer)
echo abs(-5); // Вывод: 5 (integer)
echo abs(4.2); // Вывод: 4.2 (double/float)
echo abs(-4.2); // Вывод: 4.2 (double/float)
?>Как вы можете видеть, если заданное число отрицательное, возвращаемое значение положительное. Но, если число положительное, эта функция просто возвращает число.
Функцию ceil() можно использовать для округления дробного значения до следующего наибольшего целочисленного значения, тогда как функцию floor() можно использовать для округления дробного значения до следующего наименьшего целочисленного значения, как показано в следующем примере:
<?php
// Округление дроби вверх
echo ceil(4.2); // Вывод: 5
echo ceil(9.99); // Вывод: 10
echo ceil(-5.18); // Вывод: -5
// Округление дроби вниз
echo floor(4.2); // Вывод: 4
echo floor(9.99); // Вывод: 9
echo floor(-5.18); // Вывод: -6
?>Вы можете использовать функцию sqrt(), чтобы найти квадратный корень из положительного числа. Эта функция возвращает специальное значение NAN для отрицательных чисел. Вот пример:
<?php
echo sqrt(9); // Вывод: 3
echo sqrt(25); // Вывод: 5
echo sqrt(10); // Вывод: 3.1622776601684
echo sqrt(-16); // Вывод: NAN
?>Функцию rand() можно использовать для генерации случайного числа. При желании вы можете указать диапазон, передав аргументы min, max, как показано в следующем примере:
<?php
// Сгенерируем случайные числа
echo rand() . "<br>";
echo rand() . "<br>";
// Генерация случайных чисел от 1 до 10 (включительно)
echo rand(1, 10) . "<br>";
echo rand(1, 10) . "<br>";
?>Если функция rand() вызывается без необязательных аргументов min, max, она возвращает псевдослучайное число от 0 и getrandmax(). Функция getrandmax() показывает максимально возможное случайное значение, которое на платформе Windows составляет всего 32767. Итак, если вам требуется диапазон больше 32767, вы можете просто указать аргументы min и max.
Функция decbin() используется для преобразования десятичного числа в двоичное. В то время как ее аналог функция bindec() преобразует число из двоичного в десятичное.
<?php
// Преобразование десятичных чисел в двоичные
echo decbin(2); // Вывод: 10
echo decbin(12); // Вывод: 1100
echo decbin(100); // Вывод: 1100100
// Преобразование двоичных чисел в десятичные
echo bindec(10); // Вывод: 2
echo bindec(1100); // Вывод: 12
echo bindec(1100100); // Вывод: 100
?>Функция dechex() используется для преобразования десятичного числа в шестнадцатеричное. В то время как функция hexdec() используется для преобразования шестнадцатеричной строки в десятичное число.
<?php
// Преобразование десятичного числа в шестнадцатеричное
echo dechex(255); // Вывод: ff
echo dechex(196); // Вывод: c4
echo dechex(0); // Вывод: 0
// Преобразование шестнадцатеричного числа в десятичное
echo hexdec('ff'); // Вывод: 255
echo hexdec('c4'); // Вывод: 196
echo hexdec(0); // Вывод: 0
?>Функция decoct() используется для преобразования десятичного числа в восьмеричное, в то время как функция octdec() используется для преобразования восьмеричного числа в десятичное.
<?php
// Преобразование десятичного числа в восьмеричное
echo decoct(12); // Вывод: 14
echo decoct(256); // Вывод: 400
echo decoct(77); // Вывод: 115
// Преобразовать восьмеричного числа в десятичное
echo octdec('14'); // Вывод: 12
echo octdec('400'); // Вывод: 256
echo octdec('115'); // Вывод: 77
?>Функцию base_convert() можно использовать для преобразования числа из одной базовой системы в другую. Например, вы можете преобразовать десятичное (основание 10) в двоичное (основание 2), шестнадцатеричное (основание 16) в восьмеричное (основание 8), восьмеричное в шестнадцатеричное, шестнадцатеричное в десятичное и т. д.
Эта функция принимает три параметра: число, которое нужно преобразовать, основание, в котором оно находится, и основание, в которое оно должно быть преобразовано. Базовый синтаксис следующий:
base_convert(number, frombase, tobase);Здесь число может быть целым числом или строкой, представляющей целое число. Оба параметра frombase и tobase должны быть от 2 до 36 включительно. Цифры в числах с основанием больше 10 будут представлены буквами a-z, где a означает 10, b означает 11, а z означает 35. Вот простой пример, показывающий, как работает эта функция:
<?php
// Преобразование десятичного числа в двоичное
echo base_convert('12', 10, 2); // Вывод: 1100
// Преобразовать двоичного числа в десятичное
echo base_convert('1100', 2, 10); // Вывод: 12
// Преобразование десятичного числа в шестнадцатеричное
echo base_convert('10889592', 10, 16); // Вывод: a62978
// Преобразование шестнадцатеричного числа в десятичное
echo base_convert('a62978', 16, 10); // Вывод: 10889592
// Преобразование десятичного числа в восьмеричное
echo base_convert('82', 10, 8); // Вывод: 122
// Преобразовать восьмеричного числа в десятичное
echo base_convert('122', 8, 10); // Вывод: 82
// Преобразование шестнадцатеричного числа в восьмеричное
echo base_convert('c2c6a8', 16, 8); // Вывод: 60543250
// Преобразование восьмеричного числа в шестнадцатеричное
echo base_convert('60543250', 8, 16); // Вывод: c2c6a8
// Преобразование восьмеричного числа в двоичное
echo base_convert('42', 8, 2); // Вывод: 100010
// Преобразование двоичного числа в восьмеричное
echo base_convert('100010', 2, 8); // Вывод: 42
// Преобразование шестнадцатеричного числа в двоичное
echo base_convert('abc', 16, 2); // Вывод: 101010111100
// Преобразование двоичного числа в шестнадцатеричное
echo base_convert('101010111100', 2, 16); // Вывод: abc
?>Функция base_convert() всегда возвращает строковое значение. Если возвращаемое значение имеет основание 10, результирующая строка может использоваться как числовая строка в вычислениях, и PHP преобразует ее в число при выполнении вычисления.
Веб-браузер связывается с сервером, как правило, с помощью одного из двух HTTP-методов (протокола передачи гипертекста) — GET и POST. Оба метода передают информацию по-разному и имеют разные преимущества и недостатки, как описано ниже.
В методе GET данные отправляются в виде параметров URL, которые обычно представляют собой строки пар имени и значения, разделенные амперсандами &. В целом URL-адрес с данными GET будет выглядеть так: http://www.example.com/action.php?name=john&age=24, где name и age в URL-адресе параметры GET, а john и 24 — значения этих параметров. В URL-адрес можно встроить более одного parameter=value, объединив их с помощью амперсанда &. С помощью метода GET можно отправлять только простые текстовые данные.
PHP предоставляет суперглобальную переменную $_GET для доступа ко всей информации, отправляемой либо через URL-адрес, либо через HTML-форму с использованием method="get".
<!DOCTYPE html>
<html lang="en">
<head>
<title>Example of PHP GET method</title>
</head>
<body>
<?php
if(isset($_GET["name"])){
echo "<p>Hi, " . $_GET["name"] . "</p>";
}
?>
<form method="get" action="<?php echo $_SERVER["PHP_SELF"];?>">
<label for="inputName">Name:</label>
<input type="text" name="name" id="inputName">
<input type="submit" value="Submit">
</form>
</body>В методе POST данные отправляются на сервер в виде пакета в отдельном сообщении со скриптом обработки. Данные, отправленные с помощью метода POST, не будут отображаться в URL-адресе.
Как и $_GET, PHP предоставляет другую суперглобальную переменную $_POST для доступа ко всей информации, отправляемой методом POST или отправляемой через HTML-форму с помощью method="post".
<!DOCTYPE html>
<html lang="en">
<head>
<title>Example of PHP POST method</title>
</head>
<body>
<?php
if(isset($_POST["name"])){
echo "<p>Hi, " . $_POST["name"] . "</p>";
}
?>
<form method="post" action="<?php echo $_SERVER["PHP_SELF"];?>">
<label for="inputName">Name:</label>
<input type="text" name="name" id="inputName">
<input type="submit" value="Submit">
</form>
</body>PHP предоставляет еще одну суперглобальную переменную $_REQUEST, которая содержит значения переменных $_GET и $_POST, а также значения суперглобальной переменной $_COOKIE.
<!DOCTYPE html>
<html lang="en">
<head>
<title>Example of PHP $_REQUEST variable</title>
</head>
<body>
<?php
if(isset($_REQUEST["name"])){
echo "<p>Hi, " . $_REQUEST["name"] . "</p>";
}
?>
<form method="post" action="<?php echo $_SERVER["PHP_SELF"];?>">
<label for="inputName">Name:</label>
<input type="text" name="name" id="inputName">
<input type="submit" value="Submit">
</form>
</body>Суперглобальные переменные $_GET, $_POST и $_REQUEST — это встроенные переменные, которые всегда доступны во всех областях скрипта.
PHP-функция date() преобразует метку времени в более удобочитаемые дату и время.
Компьютер хранит дату и время в формате, который называется UNIX Timestamp; он измеряет время как количество секунд с начала эпохи Unix (полночь по Гринвичу 1 января 1970 г., т.е. 1 января 1970 г., 00:00:00 по Гринвичу). Поскольку это непрактичный формат для чтения людьми, PHP преобразует временную метку в формат, понятный людям, и даты из вашей записи в метку времени, понятную компьютеру. Синтаксис PHP-функции date() можно задать с помощью:
date(format, timestamp)Параметр формата в функции date() является обязательным, который определяет формат возвращаемых даты и времени. Однако метка времени timestamp является необязательным параметром; если она не указана, будут использоваться текущая дата и время. Следующая инструкция отображает сегодняшнюю дату:
<?php
$today = date("d/m/Y");
echo $today;
?>PHP-функция date() возвращает текущую дату и время в соответствии со встроенными часами веб-сервера, на котором был выполнен скрипт.
Параметр формата функции date() на самом деле представляет собой строку, которая может содержать несколько символов, что позволяет вам сгенерировать строку даты, содержащую различные компоненты даты и времени, такие как день недели, AM или PM и т. д. Вот некоторые из символов форматирования, связанные с датой, которые обычно используются в этой строке:
d — обозначает день месяца; две цифры с ведущими нулями (01 или 31)D — обозначение дня недели в тексте в виде сокращения (с понедельника по воскресенье)m — обозначает месяц цифрами с ведущими нулями (01 или 12)M — обозначает месяц в тексте, сокращенно (с января по декабрь)y — обозначают год двумя цифрами (08 или 14)Y — обозначает год четырьмя цифрами (2008 или 2014)Части даты можно разделить, вставив другие символы, например дефисы -, точки ., слеши / или пробелы, чтобы добавить дополнительное визуальное форматирование.
<?php
echo date("d/m/Y") . "<br>";
echo date("d-m-Y") . "<br>";
echo date("d.m.Y");
?>Вы можете использовать PHP-функцию date() для автоматического обновления срока действия авторских прав на вашем веб-сайте, например: Copyright © 2010-<?php echo date("Y")?>.
Точно так же вы можете использовать следующие символы для форматирования строки времени:
h — обозначает час в 12-часовом формате с ведущими нулями (от 01 до 12)H — часы в 24-часовом формате с ведущими нулями (от 00 до 23)i — минуты с ведущими нулями (от 00 до 59)s — секунды с ведущими нулями (от 00 до 59)a — представляют нижний регистр ante meridiem и post meridiem (am или pm)A — обозначает верхний регистр Ante meridiem и Post meridiem (AM или PM)PHP-код в следующем примере отображает дату в разных форматах:
<?php
echo date("h:i:s") . "<br>";
echo date("F d, Y h:i:s A") . "<br>";
echo date("h:i a");
?>Функция time() используется для получения текущего времени в виде метки времени Unix (количество секунд с начала эпохи Unix: 1 января 1970 г. 00:00:00 по Гринвичу).
<?php
// Текущая дата 05 March 2014, 07:19:18
$timestamp = time();
echo($timestamp); // Выводит: 1394003958
?>Мы можем преобразовать эту метку времени в удобочитаемую дату, передав ее в ранее введенную функцию date().
<?php
$timestamp = 1394003958;
echo(date("F d, Y h:i:s", $timestamp)); // Выводит: March 05, 2014 07:19:18
?>Функция mktime() используется для создания отметки времени на основе определенной даты и времени. Если дата и время не указаны, возвращается метка времени для текущей даты и времени.
Синтаксис функции mktime() может быть задан следующим образом:
mktime(hour, minute, second, month, day, year)В следующем примере отображается метка времени, соответствующая 15:20:12 10 мая 2014 года:
<?php
// Создаем метку времени для определенной даты
echo mktime(15, 20, 12, 5, 10, 2014); // Выводит: 1399735212
?>Вы можете не указывать столько аргументов, вместо них будет использоваться значение, соответствующее текущему времени. Если вы опустите все аргументы, функция mktime() вернет временную метку UNIX, соответствующую текущей дате и времени, как и time().
Функцию mktime() можно использовать для поиска названия дня недели, соответствующего определенной дате. Для этого просто используйте символ l (строчная буква L) со своей меткой времени, как в следующем примере, который отображает день, приходящийся на 1 апреля 2014 года:
<?php
// Получаем название дня недели определенной даты
echo date('l', mktime(0, 0, 0, 4, 1, 2014)); // Выводит: Tuesday
?>Функцию mktime() также можно использовать для поиска определенной даты в будущем по истечении определенного периода времени. Как в следующем примере, где отображается дата, которая наступает спустя 30 месяцев относительно 5 Марта 2014.
<?php
// Текущая дата March 05, 2014
$futureDate = mktime(0, 0, 0, date("m")+30, date("d"), date("Y"));
echo date("d/m/Y", $futureDate); // Выводит: 05/09/2016
?>Операторы include() и require() позволяют включать код, содержащийся в файле PHP в другой файл PHP. Включение файла дает тот же результат, что и копирование скрипта из указанного файла и вставка в место, где он был вызван.
Эти функции помогут вам сэкономить много времени — просто сохраните блок кода в отдельном файле и подключите его куда угодно, используя операторы include() и require() вместо того, чтобы набирать весь блок кода несколько раз. Типичный пример — подключение файлов header, footer и menu на все страницы веб-сайта.
Базовый синтаксис операторов include() и require() может быть задан следующим образом:
include("path/to/filename"); /* или */ include "path/to/filename";
require("path/to/filename"); /* или */ require "path/to/filename";Как и операторы print и echo, вы можете опустить круглые скобки при использовании операторов include и require, как показано выше.
В следующем примере показано, как подключить отдельные файлы header.php, footer.php и menu.php на всех страницах вашего веб-сайта. Используя этот метод, вы можете обновлять все страницы веб-сайта сразу, внося изменения только в один файл, что избавляет от множества повторяющихся действий.
<!DOCTYPE html>
<html lang="en">
<head>
<title>Zolin Digital</title>
</head>
<body>
<?php include "header.php"; ?>
<?php include "menu.php"; ?>
<h1>Добро пожаловать на наш сайт!</h1>
<p>Здесь вы найдете много полезной информации.</p>
<?php include "footer.php"; ?>
</body>
</html>Вы можете подумать: если мы можем включать файлы с помощью оператора include(), тогда зачем нам require(). Обычно оператор require() работает как include().
Единственное отличие заключается в том, что оператор include() будет генерировать только предупреждение PHP, но позволит продолжить выполнение скрипта, если файл, который нужно включить, не может быть найден, тогда как оператор require() вызовет фатальную ошибку и остановит выполнение скрипта.
<?php require "my_variables.php"; ?>
<?php require "my_functions.php"; ?>
<!DOCTYPE html>
<html lang="en">
<head>
<title><?php displayTitle($home_page); ?></title>
</head>
<body>
<?php include "header.php"; ?>
<?php include "menu.php"; ?>
<h1>Добро пожаловать на наш сайт!</h1>
<p>Здесь вы найдете много полезной информации.</p>
<?php include "footer.php"; ?>
</body>
</html>Рекомендуется использовать оператор require(), если вы включаете файлы библиотеки или файлы, содержащие функции и переменные конфигурации, которые необходимы для запуска вашего приложения, например файл конфигурации базы данных.
Если вы случайно включите один и тот же файл (обычно файлы функций или классов) в код более одного раза с помощью операторов include и require, это может вызвать конфликты. Чтобы предотвратить эту ситуацию, PHP предоставляет операторы include_once и require_once. Эти операторы ведут себя так же, как операторы include и require, за одним исключением.
Операторы include_once и require_once будут включать файл только один раз, даже если будет предложено включить его второй раз, т.е. если указанный файл уже был включен в предыдущий оператор, файл не включается снова. Чтобы лучше понять, как это работает, давайте рассмотрим пример. Предположим, у нас есть файл my_functions.php со следующим кодом:
<?php
function multiplySelf($var) {
$var *= $var; // умножаем переменную на саму себя
echo $var;
}
?>Вот PHP-скрипт, в который мы включили файл my_functions.php.
<?php
// Подключаем файл через require
require "my_functions.php";
// Вызываем функцию
multiplySelf(2); // Выводит: 4
echo "<br>";
// Подключаем файл через require
require "my_functions.php";
// Вызываем функцию
multiplySelf(5); // Функция не выполняется
?>Когда вы запустите приведенный выше скрипт, вы увидите сообщение об ошибке примерно такого рода: Fatal error: Cannot redeclare multiplySelf(). Это происходит из-за того, что my_functions.php подключен дважды и функция multiplySelf() определяется дважды, что заставило PHP остановить выполнение скрипта и сгенерировать фатальную ошибку. Теперь перепишем приведенный выше пример с помощью require_once.
<?php
// Подключаем файл через require_once
require_once "my_functions.php";
// Вызываем функцию
multiplySelf(2); // Выводит: 4
echo "<br>";
// Подключаем файл через require_once
require_once "my_functions.php";
// Вызываем функцию
multiplySelf(5); // Выводит: 25
?>Как видите, при использовании require_once вместо require скрипт работает так, как мы того ожидаем.
Поскольку PHP является серверным языком программирования, он позволяет вам работать с файлами и каталогами, хранящимися на веб-сервере. В этом руководстве вы узнаете, как создавать, получать доступ и управлять файлами на вашем веб-сервере с помощью функций файловой системы PHP.
Для работы с файлом вам сначала нужно открыть файл. Функция PHP fopen() используется для открытия файла. Базовый синтаксис этой функции может быть задан следующим образом:
fopen(filename, mode)Первый параметр, передаваемый в fopen(), указывает имя файла, который вы хотите открыть, а второй параметр указывает, в каком режиме файл должен быть открыт. Например:
<?php
$handle = fopen("data.txt", "r");
?>Файл можно открыть в одном из следующих режимов:
r - открывает файл только для чтения.r+ - открывает файл для чтения и записи.w - открывает файл только для записи и очищает содержимое файла. Если файл не существует, PHP попытается его создать.w+ - открывает файл для чтения, записи и очищает содержимое файла. Если файл не существует, PHP попытается его создать.a - открывает файл только для записи. Сохраняет содержимое файла, записывая его в конец. Если файл не существует, PHP попытается его создать.a+ - открывает файл для чтения и записи. Сохраняет содержимое файла, записывая его в конец. Если файл не существует, PHP попытается его создать.x - открывает файл только для записи. Возвращает false и выдает ошибку, если файл уже существует. Если файл не существует, PHP попытается его создать.x+ - открывает файл для чтения и записи; в противном случае он ведет себя так же, как x.Если вы попытаетесь открыть несуществующий файл, PHP выдаст предупреждающее сообщение. Итак, чтобы избежать появления этих сообщений об ошибках, вы всегда должны выполнять простую проверку, существует ли файл или каталог, прежде чем пытаться получить к нему доступ, с помощью PHP-функции file_exists().
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Попытка открыть файл
$handle = fopen($file, "r");
} else{
echo "ERROR: File does not exist.";
}
?>Операции с файлами и каталогами подвержены ошибкам. Поэтому рекомендуется реализовать некоторую форму проверки ошибок, чтобы в случае возникновения ошибки ваш скрипт корректно ее обработал.
Закончив работу с файлом, его нужно закрыть. Функция fclose() используется для закрытия файла, как показано в следующем примере:
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Открываем файл для чтения
$handle = fopen($file, "r") or die("ERROR: Cannot open the file.");
/* Некоторый код для выполнения */
// Закрываем дескриптор файла
fclose($handle);
} else{
echo "ERROR: File does not exist.";
}
?>Хотя PHP автоматически закрывает все открытые файлы при завершении скрипта, рекомендуется закрывать файл после выполнения всех операций.
Теперь, когда вы поняли, как открывать и закрывать файлы. В следующем разделе вы узнаете, как читать данные из файла. В PHP есть несколько функций для чтения данных из файла. Вы можете прочитать от одного символа до всего файла с помощью одной операции.
Функцию fread() можно использовать для чтения указанного количества символов из файла. Базовый синтаксис этой функции можно задать с помощью.
fread(file handle, length in bytes)Эта функция принимает два параметра — дескриптор файла и количество байтов для чтения. В следующем примере из файла data.txt считывается 20 байтов, включая пробелы. Предположим, файл data.txt содержит абзац текста The quick brown fox jumps over the lazy dog.
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Открываем файл для чтения
$handle = fopen($file, "r") or die("ERROR: Cannot open the file.");
// Читаем фиксированное количество байтов из файла
$content = fread($handle, "20");
// Закрываем дескриптора файла
fclose($handle);
// Отображаем содержимое файла
echo $content; // Выводит: The quick brown fox
} else{
echo "ERROR: File does not exist.";
}
?>Функцию fread() можно использовать вместе с функцией filesize() для одновременного чтения всего файла. Функция filesize() возвращает размер файла в байтах.
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Открываем файл для чтения
$handle = fopen($file, "r") or die("ERROR: Cannot open the file.");
// Читаем весь файл
$content = fread($handle, filesize($file));
// Закрываем дескриптора файла
fclose($handle);
// Отображаем содержимое файла
echo $content; // Выводит: The quick brown fox jumps over the lazy dog.
} else{
echo "ERROR: File does not exist.";
}
?>Самый простой способ прочитать все содержимое файла в PHP — использовать функцию readfile(). Эта функция позволяет вам читать содержимое файла, не открывая его. В следующем примере будет сгенерирован тот же результат, что и в примере выше:
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Читаем и выводим весь файл
readfile($file) or die("ERROR: Cannot open the file.");
} else{
echo "ERROR: File does not exist.";
}
?>Другой способ прочитать все содержимое файла без необходимости его открытия — использовать функцию file_get_contents(). Эта функция принимает имя и путь к файлу и считывает весь файл в строковую переменную. Вот пример:
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Читаем весь файл в строку
$content = file_get_contents($file) or die("ERROR: Cannot open the file.");
// Отображаем содержимое файла
echo $content;
} else{
echo "ERROR: File does not exist.";
}
?>Еще один метод чтения всех данных из файла — это PHP-функция file(). Она выполняет ту же работу, что и функция file_get_contents(), но возвращает содержимое файла в виде массива строк, а не отдельной строки. Каждый элемент возвращаемого массива соответствует строке в файле.
Для обработки данных файла необходимо выполнить итерацию по массиву с помощью цикла foreach. Вот пример, который считывает файл в массив, а затем отображает его с помощью цикла:
<?php
$file = "data.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Читаем и преобразуем весь файл в массив
$arr = file($file) or die("ERROR: Cannot open the file.");
foreach($arr as $line){
echo $line;
}
} else{
echo "ERROR: File does not exist.";
}
?>Точно так же вы можете записывать или добавлять данные в существующий файл с помощью PHP-функции fwrite(). Базовый синтаксис этой функции может быть задан следующим образом:
fwrite(file handle, string)Функция fwrite() принимает два параметра — дескриптор файла и строку данных, которые должны быть записаны, как показано в следующем примере:
<?php
$file = "note.txt";
// Строка данных для записи
$data = "The quick brown fox jumps over the lazy dog.";
// Открываем файл для записи
$handle = fopen($file, "w") or die("ERROR: Cannot open the file.");
// Пишем данные в файл
fwrite($handle, $data) or die ("ERROR: Cannot write the file.");
// Закрываем дескриптор файла
fclose($handle);
echo "Data written to the file successfully.";
?>В приведенном выше примере, если файл note.txt не существует, PHP автоматически создаст его и запишет данные. Но если файл note.txt уже существует, PHP удалит содержимое этого файла, если оно есть, перед записью новых данных, однако, если вы просто хотите добавить файл и сохранить существующее содержимое, просто используйте режим a вместо w в приведенном выше примере.
Альтернативный способ — использовать функцию file_put_contents(). Это аналог функции file_get_contents() и простой метод записи данных в файл без необходимости его открытия. Эта функция принимает имя и путь к файлу вместе с данными, которые будут записаны в файл. Вот пример:
<?php
$file = "note.txt";
// Строка данных для записи
$data = "The quick brown fox jumps over the lazy dog.";
// Пишем данные в файл
file_put_contents($file, $data) or die("ERROR: Cannot write the file.");
echo "Data written to the file successfully.";
?>Если файл, указанный в функции file_put_contents(), уже существует, PHP по умолчанию перезапишет его. Если вы хотите сохранить содержимое файла, вы можете передать специальный флаг FILE_APPEND в качестве третьего параметра функции file_put_contents(). Он просто добавит новые данные в файл вместо того, чтобы перезаписывать его. Вот пример:
<?php
$file = "note.txt";
// Строка данных для записи
$data = "The quick brown fox jumps over the lazy dog.";
// Пишем данные в файл
file_put_contents($file, $data, FILE_APPEND) or die("ERROR: Cannot write the file.");
echo "Data written to the file successfully.";
?>Вы можете переименовать файл или каталог с помощью PHP-функции rename(), например:
<?php
$file = "file.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Пытаемся переименовать файл
if(rename($file, "newfile.txt")){
echo "File renamed successfully.";
} else{
echo "ERROR: File cannot be renamed.";
}
} else{
echo "ERROR: File does not exist.";
}
?>Вы можете удалять файлы или каталоги с помощью PHP-функции unlink(), например:
<?php
$file = "note.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Пытаемся удалить файл
if(unlink($file)){
echo "File removed successfully.";
} else{
echo "ERROR: File cannot be removed.";
}
} else{
echo "ERROR: File does not exist.";
}
?>В следующей таблице представлен обзор некоторых других полезных функций файловой системы PHP, которые можно использовать для динамического чтения и записи файлов.
fgetc() - читает по одному символу за раз.fgets() - читает по одной строке за раз.fgetcsv() - читает строку значений, разделенных запятыми.filetype() - возвращает тип файла.feof() - проверяет, достигнут ли конец файла.is_file() - проверяет, является ли файл обычным файлом.is_dir() - проверяет, является ли файл каталогом.is_executable() - проверяет, является ли файл исполняемым.realpath()- возвращает канонизированный абсолютный путь.rmdir() - удаляет пустой каталог.В предыдущей главе мы узнали, как работать с файлами в PHP. Точно так же PHP также позволяет вам работать с каталогами в файловой системе, например, вы можете открыть каталоги, читать содержимое, создавать или удалять каталоги, перечислить все файлы в каталоге и так далее.
Вы можете создать новый пустой каталог, вызвав PHP-функцию mkdir(), указав путь и имя каталога, который будет создан, как показано в примере ниже:
<?php
// Путь к каталогу
$dir = "testdir";
// Проверяем наличие каталога
if(!file_exists($dir)){
// Попытка создать каталог
if(mkdir($dir)){
echo "Directory created successfully.";
} else{
echo "ERROR: Directory could not be created.";
}
} else{
echo "ERROR: Directory already exists.";
}
?>Чтобы функция mkdir() работала, родительские каталоги в параметре пути к каталогу должны уже существовать, например, если вы укажете путь к каталогу как testdir/subdir, тогда должен существовать testdir, иначе PHP сгенерирует ошибку.
Вы можете скопировать файл из одного места в другое, вызвав PHP-функцию copy() с исходным и конечным путями файла в качестве аргументов. Если целевой файл уже существует, он будет перезаписан. Вот пример, который создает копию файла example.txt в папке резервного копирования backup.
<?php
// Путь к исходному файлу
$file = "example.txt";
// Путь к конечному файлу
$newfile = "backup/example.txt";
// Проверяем наличие файла
if(file_exists($file)){
// Пытаемся скопировать файл
if(copy($file, $newfile)){
echo "File copied successfully.";
} else{
echo "ERROR: File could not be copied.";
}
} else{
echo "ERROR: File does not exist.";
}
?>Чтобы этот пример работал, целевой каталог, который является резервной копией и исходный файл, то есть example.txt, должны уже существовать; в противном случае PHP выдаст ошибку.
Вы можете использовать PHP-функцию scandir() для вывода списка файлов и каталогов внутри указанного пути.
Теперь мы собираемся создать специальную функцию, которая рекурсивно перечислит все файлы в каталоге с помощью PHP. Этот сценарий будет полезен, если вы работаете с глубоко вложенной структурой каталогов.
<?php
// Определяем функцию для вывода файлов в каталог
function outputFiles($path){
// Проверяем, существует ли каталог
if(file_exists($path) && is_dir($path)){
// Сканируем файлы в этом каталоге
$result = scandir($path);
// Отфильтруем текущий (.) и родительский (..) каталоги
$files = array_diff($result, array('.', '..'));
if(count($files) > 0){
// Цикл через перенастроенный массив
foreach($files as $file){
if(is_file("$path/$file")){
// Печатаем filename
echo $file . "<br>";
} else if(is_dir("$path/$file")){
// Рекурсивно вызываем функцию, если каталоги найдены
outputFiles("$path/$file");
}
}
} else{
echo "ERROR: No files found in the directory.";
}
} else {
echo "ERROR: The directory does not exist.";
}
}
// Вызываем функцию
outputFiles("mydir");
?>При работе с каталогом и файловой структурой иногда вам может потребоваться найти определенные типы файлов в каталоге, например, перечислить только файлы .text или .png. Вы можете легко сделать это с помощью PHP-функции glob(), который соответствует файлам на основе шаблона.
Код PHP в следующем примере будет искать в каталоге документов и перечислять все файлы с расширением .text. Поиск в подкаталогах не выполняется.
<?php
/* В цикле ищем совпадающие файлы */
foreach(glob("documents/*.txt") as $file){
echo basename($file) . " (size: " . filesize($file) . " bytes)" . "<br>";
}
?>Функцию glob() также можно использовать для поиска всех файлов в каталоге или его подкаталогах. Функция, определенная в следующем примере, будет рекурсивно перечислять все файлы в каталоге, как мы это делали в предыдущем примере с функцией scandir().
<?php
// Определяем функцию для вывода файлов в каталог
function outputFiles($path){
// Проверяем, существует ли каталог
if(file_exists($path) && is_dir($path)){
// Ищем файлы в этом каталоге
$files = glob($path ."/*");
if(count($files) > 0){
// Запускаем цикл
foreach($files as $file){
if(is_file("$file")){
// Печатаем имя файла
echo basename($file) . "<br>";
} else if(is_dir("$file")){
// Рекурсивно вызывать функцию, если каталоги найдены
outputFiles("$file");
}
}
} else{
echo "ERROR: No such file found in the directory.";
}
} else {
echo "ERROR: The directory does not exist.";
}
}
// Вызываем функцию
outputFiles("mydir");
?>В этом руководстве мы узнаем, как загружать файлы на удаленный сервер с помощью простой HTML-формы и PHP. Вы можете загружать файлы любого типа, например изображения, видео, ZIP-файлы, документы Microsoft Office, PDF-файлы, а также исполняемые файлы и множество других типов файлов.
В следующем примере будет создана простая HTML-форма, которую можно использовать для загрузки файлов.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>File Upload Form</title>
</head>
<body>
<form action="upload-manager.php" method="post" enctype="multipart/form-data">
<h2>Загрузить файл</h2>
<label for="fileSelect">Имя файла:</label>
<input type="file" name="photo" id="fileSelect">
<input type="submit" name="submit" value="Upload">
<p><strong>Внимание:</strong> Разрешены только .jpg, .jpeg, .gif, .png форматы до 5 МБ.</p>
</form>
</body>
</html>В дополнение к полю выбора файла форма загрузки должна использовать метод HTTP post и должна содержать атрибут enctype="multipart/form-data". Этот атрибут гарантирует, что данные формы кодируются как многокомпонентные данные MIME, что необходимо для загрузки больших объемов двоичных данных, таких как изображения, аудио, видео и т.д.
Вот полный код нашего файла upload-manager.php. Он будет хранить загруженный файл в папке upload на постоянной основе, а также выполнять некоторые базовые проверки безопасности, такие как тип файла и размер файла, чтобы гарантировать, что пользователи загружают файл правильного типа и в пределах разрешенного лимита.
<?php
// Проверяем, была ли отправлена форма
if($_SERVER["REQUEST_METHOD"] == "POST"){
// Убеждаемся, что файл загружен без ошибок
if(isset($_FILES["photo"]) && $_FILES["photo"]["error"] == 0){
$allowed = array("jpg" => "image/jpg", "jpeg" => "image/jpeg", "gif" => "image/gif", "png" => "image/png");
$filename = $_FILES["photo"]["name"];
$filetype = $_FILES["photo"]["type"];
$filesize = $_FILES["photo"]["size"];
// Проверяем расширение файла
$ext = pathinfo($filename, PATHINFO_EXTENSION);
if(!array_key_exists($ext, $allowed)) die("Error: Please select a valid file format.");
// Проверяем размер файла - максимум 5 МБ
$maxsize = 5 * 1024 * 1024;
if($filesize > $maxsize) die("Error: File size is larger than the allowed limit.");
// Проверяем MIME-тип файла
if(in_array($filetype, $allowed)){
// Перед загрузкой проверяем, существует ли файл
if(file_exists("upload/" . $filename)){
echo $filename . " is already exists.";
} else{
move_uploaded_file($_FILES["photo"]["tmp_name"], "upload/" . $filename);
echo "Your file was uploaded successfully.";
}
} else{
echo "Error: There was a problem uploading your file. Please try again.";
}
} else{
echo "Error: " . $_FILES["photo"]["error"];
}
}
?>Приведенный выше скрипт предотвратит загрузку файла, если в папке уже есть файл с таким же именем. Однако, если вы хотите разрешить это, просто добавьте к имени файла случайную строку или временную метку, например $filename = time() . '_' . $_FILES["photo"]["name"];.
Давайте рассмотрим каждую часть этого примера кода, чтобы лучше понять этот процесс.
После отправки формы информация о загруженном файле может быть доступна через суперглобальный массив PHP, называемый $_FILES. Например, наша форма загрузки содержит поле выбора файла с именем photo (т.е. name="photo"). Если какой-либо пользователь загрузил файл, используя это поле, мы можем получить его данные, такие как имя, тип, размер, временное имя или любую ошибку через ассоциативный массив $_FILES["photo"], например:
$_FILES["photo"]["name"] — значение этого массива указывает исходное имя файла, включает расширение файла, но не включает путь к файлу.$_FILES["photo"]["type"] — значение этого массива указывает MIME-тип файла.$_FILES["photo"]["size"] — значение этого массива определяет размер файла в байтах.$_FILES["photo"]["tmp_name"] — значение этого массива указывает временное имя, включая полный путь, который назначается файлу после его загрузки на сервер.$_FILES["photo"]["error"] — значение этого массива указывает код ошибки или статуса, связанный с загрузкой файла, например это будет 0, если ошибки нет.Код PHP в следующем примере просто отобразит сведения о загруженном файле и сохранит его во временном каталоге на веб-сервере.
<?php
if($_FILES["photo"]["error"] > 0){
echo "Error: " . $_FILES["photo"]["error"] . "<br>";
} else{
echo "File Name: " . $_FILES["photo"]["name"] . "<br>";
echo "File Type: " . $_FILES["photo"]["type"] . "<br>";
echo "File Size: " . ($_FILES["photo"]["size"] / 1024) . " KB<br>";
echo "Stored in: " . $_FILES["photo"]["tmp_name"];
}
?>После успешной загрузки файла он автоматически сохраняется во временном каталоге на сервере. Чтобы сохранить этот файл на постоянной основе, вам необходимо переместить его из временного каталога в постоянное место с помощью PHP-функции move_uploaded_file().
Обычно вам не обязательно использовать какой-либо серверный язык, например PHP, для загрузки изображений, zip-файлов, PDF-документов, exe-файлов и т. д. Если такой тип файла хранится в общедоступной папке, вы можете просто создать гиперссылку, указывающую на этот файл, и всякий раз, когда пользователь будет кликать на ссылку, браузер будет автоматически загружать этот файл.
<a href="downloads/test.zip">Download Zip file</a>
<a href="downloads/masters.pdf">Download PDF file</a>
<a href="downloads/sample.jpg">Download Image file</a>
<a href="downloads/setup.exe">Download EXE file</a>Щелчок по ссылке, указывающей на PDF-файл или файл с изображением, не приведет к его загрузке на ваш жесткий диск напрямую. Он откроет файл только в вашем браузере. В дальнейшем вы можете сохранить его на свой жесткий диск. Однако по умолчанию файлы .zip и .exe загружаются на жесткий диск автоматически.
Вы можете заставить изображения или другие файлы загружаться непосредственно на жесткий диск пользователя с помощью PHP-функции readfile(). Здесь мы собираемся создать простую галерею изображений, которая позволяет пользователям загружать файлы изображений из браузера одним щелчком мыши.
Давайте создадим файл с именем image-gallery.php и поместим в него следующий код.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Simple Image Gallery</title>
<style type="text/css">
.img-box{
display: inline-block;
text-align: center;
margin: 0 15px;
}
</style>
</head>
<body>
<?php
// Массив, содержащий имена файлов изображений
$images = array("kites.jpg", "balloons.jpg");
// Запускаем цикл массива изображений
foreach($images as $image){
echo '<div class="img-box">';
echo '<img src="images/' . $image . '" width="200" alt="' . pathinfo($image, PATHINFO_FILENAME) .'">';
echo '<p><a href="download.php?file=' . urlencode($image) . '">Загрузить</a></p>';
echo '</div>';
}
?>
</body>
</html>Если вы внимательно посмотрите на приведенный выше пример кода, вы обнаружите, что ссылка для скачивания указывает на файл download.php, URL также содержит имя файла изображения в виде строки запроса. Кроме того, мы использовали PHP-функцию urlencode() для кодирования имен файлов изображений, чтобы их можно было безопасно передать как параметр URL, поскольку имена файлов могут содержать небезопасные символы URL.
Вот полный код файла download.php, который принудительно загружает изображение.
<?php
if(isset($_REQUEST["file"])){
// Получаем параметры
$file = urldecode($_REQUEST["file"]); // Декодируем строку в кодировке URL
/* Проверяем, содержит ли имя файла недопустимые символы
например "../" с использованием регулярного выражения */
if(preg_match('/^[^.][-a-z0-9_.]+[a-z]$/i', $file)){
$filepath = "images/" . $file;
// Процесс загрузки
if(file_exists($filepath)) {
header('Content-Description: File Transfer');
header('Content-Type: application/octet-stream');
header('Content-Disposition: attachment; filename="'.basename($filepath).'"');
header('Expires: 0');
header('Cache-Control: must-revalidate');
header('Pragma: public');
header('Content-Length: ' . filesize($filepath));
flush(); // Flush system output buffer
readfile($filepath);
die();
} else {
http_response_code(404);
die();
}
} else {
die("Invalid file name!");
}
}
?>Точно так же вы можете принудительно загрузить файлы других форматов, такие как word .doc, .pdf и т. д.
Регулярное выражение в приведенном выше примере (строка № 8) просто не разрешит те файлы, имя которых начинается или заканчивается символом точки ., Например, оно разрешает имена файлов, такие как kites.jpg или Kites.jpg, myscript.min.js, но не разрешает kites.jpg. или .kites.jpg.
Файл cookie — это небольшой текстовый файл, который позволяет хранить небольшой объем данных (около 4 КБ) на компьютере пользователя. Обычно эти файлы используются для отслеживания такой информации, как, например, имя пользователя, которое сайт может извлечь для персонализации страницы, когда пользователь посетит сайт в следующий раз.
Функция setcookie() используется для установки cookie в PHP. Убедитесь, что вы вызываете функцию setcookie() перед любым выводом, сгенерированным вашим скриптом, иначе cookie не будет установлен. Базовый синтаксис этой функции может быть задан следующим образом:
setcookie(name, value, expire, path, domain, secure);Параметры функции setcookie() имеют следующие значения:
name - название cookie.value - значение файла cookie. Не храните конфиденциальную информацию, поскольку это значение хранится на компьютере пользователя.expires - дата истечения срока хранения в формате временной метки UNIX. По истечении этого времени cookie станет недоступным. Значение по умолчанию — 0.path - путь на сервере по которому будет доступен файл cookie. Если установлено значение /, cookie будет доступен во всем домене.domain - указывает домен, для которого cookie доступен, например www.example.com.secure - это поле, если оно присутствует, указывает на то, что файл cookie следует отправлять только при наличии защищенного HTTPS-соединения.Если срок действия cookie установлен на 0 или опущен, срок действия cookie истечет в конце сеанса, то есть при закрытии браузера.
Вот пример, в котором функция setcookie() используется для создания файла cookie с именем username и присваивает ему значение value John Carter. Она также указывает, что срок действия cookie истечет через 30 дней 30 days * 24 hours * 60 min * 60 sec.
<?php
// Установка куки
setcookie("username", "John Carter", time()+30*24*60*60);
?>Все аргументы, кроме имени, необязательны. Вы также можете заменить аргумент пустой строкой «», чтобы пропустить этот аргумент, однако, чтобы пропустить аргумент истечения срока действия expires, используйте вместо него ноль 0.
Не храните конфиденциальные данные в файлах cookie, поскольку злоумышленник потенциально может ими манипулировать. Для безопасного хранения конфиденциальных данных используйте вместо этого сессии.
Суперглобальная переменная PHP $_COOKIE используется для получения значений cookie. Обычно это ассоциативный массив, содержащий список всех значений файлов cookie, отправленных браузером в текущем запросе, с ключом по имени файла cookie.
Доступ к индивидуальному значению cookie можно получить, используя стандартную нотацию массива, например, для отображения файла cookie имени пользователя, установленного в предыдущем примере, вы можете использовать следующий код.
<?php
// Доступ к индивидуальному значению cookie
echo $_COOKIE["username"]; // Выводит: John Carter
?>Перед тем, как получить доступ к его значению, рекомендуется проверить, установлен ли файл cookie или нет. Для этого вы можете использовать PHP-функцию isset(), например:
<?php
// Проверяем, установлен ли cookie или нет
if(isset($_COOKIE["username"])){
echo "Hi " . $_COOKIE["username"];
} else{
echo "Welcome Guest!";
}
?>Вы можете использовать функцию print_r(), например print_r($_COOKIE); чтобы увидеть структуру этого ассоциативного массива $_COOKIE.
Вы можете удалить cookie, вызвав ту же функцию setcookie() с именем cookie и любым значением (например, пустой строкой), однако на этот раз вам нужно установить дату истечения срока действия в прошлом, как показано в примере ниже:
<?php
// Удаление куки
setcookie("username", "", time()-3600);
?>Вы должны передать точно такой же путь, домен и другие аргументы, которые вы использовали при первом создании файла cookie, чтобы гарантированно удалить файл cookie.
Вы можете хранить данные с помощью файлов cookie, но из-за этого могут возникнуть некоторые проблемы с безопасностью. Поскольку файлы cookie хранятся на компьютере пользователя, злоумышленник может легко изменить содержимое файлов cookie, чтобы вставить в ваше приложение потенциально опасные данные, которые могут нарушить работу вашего приложения.
Кроме того, каждый раз, когда браузер запрашивает URL-адрес на сервере, все данные cookie для веб-сайта автоматически отправляются на сервер в запросе. Это означает, что если вы сохранили 5 файлов cookie в системе пользователя, каждый размером 4 КБ, браузеру необходимо загружать 20 КБ данных каждый раз, когда пользователь просматривает страницу, что может повлиять на производительность вашего сайта.
Вы можете решить обе эти проблемы, используя сессии PHP. Сессии PHP хранят данные на сервере, а не на компьютере пользователя. В сессии каждый пользователь идентифицируется с помощью уникального номера, называемого идентификатором сеанса или SID. Этот уникальный идентификатор сеанса используется для связи каждого пользователя с его собственной информацией на сервере, такой как электронные письма, сообщения и т.д.
Идентификаторы сеанса генерируются механизмом PHP случайным образом, который практически невозможно угадать. Кроме того, поскольку данные сеанса хранятся на сервере, их не нужно отправлять с каждым запросом браузера.
Прежде чем вы сможете сохранить какую-либо информацию в переменных сессии, вы должны сначала ее запустить. Чтобы начать новую сессию, просто вызовите PHP-функцию session_start(). Она создаст новый сеанс и сгенерирует уникальный идентификатор сеанса для пользователя.
Код PHP в приведенном ниже примере просто запускает новую сессию.
<?php
// Начало сессии
session_start();
?>Функция session_start() сначала проверяет, существует ли уже сессия через проверку наличия идентификатора. Если она его находит, то есть если сессия уже запущена, оно устанавливает переменные сессии, а если нет, она запускает новую сессию, создавая новый идентификатор.
Вы должны вызвать функцию session_start() в начале страницы, то есть до любого вывода, сгенерированного вашим скриптом в браузере, так же, как вы это делаете при установке файлов cookie с помощью функции setcookie().
Вы можете хранить все данные сессии в виде пар ключ-значение в суперглобальном массиве $_SESSION[]. Доступ к сохраненным данным можно получить в течение всей сессии. Рассмотрим следующий сценарий, который создает новую сессию и зарегистрирует две переменные.
<?php
// Начало сессии
session_start();
// Хранение данных сессии
$_SESSION["firstname"] = "Peter";
$_SESSION["lastname"] = "Parker";
?>Чтобы получить доступ к данным сессии, которые мы установили в нашем предыдущем примере с любой другой страницы в том же веб-домене — просто воссоздайте сессию, вызвав session_start(), а затем передайте соответствующий ключ в ассоциативный массив $_SESSION.
<?php
// Начало сессии
session_start();
// Доступ к данным сессии
echo 'Hi, ' . $_SESSION["firstname"] . ' ' . $_SESSION["lastname"]; // Выводит: Hi, Peter Parker
?>Для доступа к данным сеанса на той же странице нет необходимости воссоздавать сеанс, поскольку он уже был запущен в верхней части страницы.
Если вы хотите удалить определенные данные сессии, просто удалите соответствующий ключ ассоциативного массива $_SESSION, как показано в следующем примере:
<?php
// Начало сессии
session_start();
// Удаление данных сессии
if(isset($_SESSION["lastname"])){
unset($_SESSION["lastname"]);
}
?>Однако, чтобы полностью уничтожить сессию, просто вызовите функцию session_destroy(). Эта функция не требует аргументов, и один вызов уничтожает все данные сессии.
<?php
// Начало сессии
session_start();
// Уничтожение сессии
session_destroy();
?>Перед тем, как уничтожить сессию с помощью функции session_destroy(), вам нужно сначала ее создать, если ее еще нет, с помощью функции session_start(), чтобы было что уничтожать.
Каждая сессия PHP имеет значение тайм-аута — продолжительность, измеряемую в секундах, — которая определяет, как долго сессия должна оставаться активной при отсутствии каких-либо действий пользователя. Вы можете настроить этот тайм-аут, изменив значение переменной session.gc_maxlifetime в файле конфигурации PHP php.ini.
Отправка сообщений электронной почты очень распространенная функция у сайтов и веб-приложений. Например, вы можете отправить приветственное сообщение по электронной почте, когда пользователь создает учетную запись на вашем веб-сайте или получить отзывы или комментарии через контактную форму на веб-сайте.
Вы можете использовать встроенную в PHP-функцию mail() для динамического создания и отправки сообщений электронной почты одному или нескольким получателям из вашего PHP-приложения либо в текстовой форме, либо в формате HTML. Базовый синтаксис этой функции может быть задан следующим образом:
mail(to, subject, message, headers, parameters)Ниже приведены параметры этой функции.
Следующие параметры обязательны:
to - электронный адрес получателя.subject - тема отправляемого электронного письма. Этот параметр, т.е. строка темы не может содержать символ новой строки \n.message - определяет сообщение для отправки. Каждую строку следует разделять символом перевода строки-LF \n. Строки не должны превышать 70 символов.Следующие параметры являются необязательными:
headers - обычно это используется для добавления дополнительных заголовков, таких как «От», «Копия», «Скрытая копия». Дополнительные заголовки следует разделять символом возврата каретки и символа перевода строки — CRLF \r\n.parameters - используется для передачи дополнительных параметров.Самый простой способ отправить электронное письмо с помощью PHP — отправить текстовое письмо. В приведенном ниже примере мы сначала объявляем переменные — адрес электронной почты получателя, строку темы и тело сообщения — затем мы передаем эти переменные функции mail() для отправки электронного письма.
<?php
$to = 'maryjane@email.com';
$subject = 'Marriage Proposal';
$message = 'Hi Jane, will you marry me?';
$from = 'peterparker@email.com';
// Отправляем письмо
if(mail($to, $subject, $message)){
echo 'Your mail has been sent successfully.';
} else{
echo 'Unable to send email. Please try again.';
}
?>Когда вы отправляете текстовое сообщение с помощью PHP, все содержимое будет рассматриваться как простой текст. Мы собираемся улучшить этот вывод и превратить электронное письмо в электронное письмо в формате HTML.
Чтобы отправить электронное письмо в формате HTML, процесс будет таким же. Однако на этот раз нам нужно предоставить дополнительные заголовки, а также сообщение в формате HTML.
<?php
$to = 'maryjane@email.com';
$subject = 'Marriage Proposal';
$from = 'peterparker@email.com';
// Для отправки HTML-почты необходимо установить заголовок Content-type.
$headers = 'MIME-Version: 1.0' . "\r\n";
$headers .= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";
// Создаем заголовки писем
$headers .= 'From: '.$from."\r\n".
'Reply-To: '.$from."\r\n" .
'X-Mailer: PHP/' . phpversion();
// Составляем простое сообщение электронной почты в формате HTML
$message = '<html><body>';
$message .= '<h1 style="color:#f40;">Hi Jane!</h1>';
$message .= '<p style="color:#080;font-size:18px;">Will you marry me?</p>';
$message .= '</body></html>';
// Отправляем письмо
if(mail($to, $subject, $message, $headers)){
echo 'Your mail has been sent successfully.';
} else{
echo 'Unable to send email. Please try again.';
}
?>PHP-функция mail() является частью ядра PHP, но вам необходимо настроить почтовый сервер на своем компьютере, чтобы она работала. Как правило на хостинге уже все работает по умолчанию, если нет — обращайтесь в службу поддержки.
В этом руководстве мы собираемся создать простую контактную HMTL-форму, которая позволяет пользователям вводить свои комментарии и отзывы, а затем отображать их в браузере с помощью PHP.
Откройте ваш любимый редактор кода и создайте новый PHP-файл. Теперь введите следующий код и сохраните этот файл как contact-form.php в корневом каталоге вашего проекта.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Contact Form</title>
</head>
<body>
<h2>Связаться с нами</h2>
<p>Заполните эту форму.</p>
<form action="process-form.php" method="post">
<p>
<label for="inputName">Имя:<sup>*</sup></label>
<input type="text" name="name" id="inputName">
</p>
<p>
<label for="inputEmail">Email:<sup>*</sup></label>
<input type="text" name="email" id="inputEmail">
</p>
<p>
<label for="inputSubject">Тема:</label>
<input type="text" name="subject" id="inputSubject">
</p>
<p>
<label for="inputComment">Сообщение:<sup>*</sup></label>
<textarea name="message" id="inputComment" rows="5" cols="30"></textarea>
</p>
<input type="submit" value="Отправить">
<input type="reset" value="Очистить">
</form>
</body>
</html>Обратите внимание, что в открывающем теге <form> есть два возможных атрибута:
action ссылается на PHP-файл process-form.php, который получает данные, введенные в форму, когда пользователь отправляет их, нажимая кнопку отправки.method сообщает браузеру отправлять данные формы через метод POST.Чтобы получить доступ к значению определенного поля формы, вы можете использовать следующие суперглобальные переменные. Эти переменные доступны во всех областях скрипта.
$_GET - содержит список всех имен полей и значений, отправленных формой с помощью метода get (т.е. через параметры URL).$_POST - содержит список всех имен полей и значений, отправленных формой с использованием метода post (данные не будут отображаться в URL).$_REQUEST - содержит значения переменных $_GET и $_POST, а также значения суперглобальной переменной $_COOKIE.Когда пользователь отправляет указанную выше контактную форму, нажав кнопку отправки, данные формы отправляются в файл process-form.php на сервер для обработки. Он просто фиксирует информацию, отправленную пользователем, и отображает ее в браузере. PHP-код файла process-form.php будет выглядеть примерно так:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Contact Form</title>
</head>
<body>
<h1>Спасибо</h1>
<p>Вот информация, которую вы отправили:</p>
<ol>
<li><em>Имя:</em> <?php echo $_POST["name"]?></li>
<li><em>Email:</em> <?php echo $_POST["email"]?></li>
<li><em>Тема:</em> <?php echo $_POST["subject"]?></li>
<li><em>Сообщение:</em> <?php echo $_POST["message"]?></li>
</ol>
</body>
</html>Приведенный выше PHP-код довольно прост. Поскольку данные формы отправляются через метод post, вы можете получить значение определенного поля формы, передав его имя в суперглобальный массив $_POST и отобразить каждое значение поля с помощью оператора echo().
В реальном мире нельзя доверять вводимым пользователем данным; вы должны реализовать своего рода проверку — валидацию формы, чтобы фильтровать вводимые пользователем данные перед их использованием. В следующей главе руководства вы узнаете, как очистить и проверить данные этой контактной формы и отправить их по электронной почте с помощью PHP.
Как мы узнали в предыдущем руководстве, процесс сбора и отображения отправленных данных формы довольно прост. В этом руководстве вы узнаете, как реализовать на своем веб-сайте простую контактную форму, которая позволяет пользователям отправлять свои комментарии и отзывы по электронной почте. Мы будем использовать ту же PHP-функцию mail() для отправки писем.
Мы также собираемся реализовать некоторые базовые функции безопасности, такие как санитизация и валидация полей, чтобы пользователь не мог вставлять потенциально опасные данные, которые ставят под угрозу безопасность веб-сайта или могут нарушить работу приложения.
Ниже приводится наш универсальный PHP-скрипт, который выполняет следующие функции:
Введите следующий код в файл contact.php и сохраните его в корневом каталоге проекта:
<?php
// Функции для фильтрации введенных пользовательских данных
function filterName($field){
// Санитизация имени пользователя
$field = filter_var(trim($field), FILTER_SANITIZE_STRING);
// Валидация имени пользователя
if(filter_var($field, FILTER_VALIDATE_REGEXP, array("options"=>array("regexp"=>"/^[a-zA-Z\s]+$/")))){
return $field;
} else{
return FALSE;
}
}
function filterEmail($field){
// Санитизация e-mail
$field = filter_var(trim($field), FILTER_SANITIZE_EMAIL);
// Валидация e-mail
if(filter_var($field, FILTER_VALIDATE_EMAIL)){
return $field;
} else{
return FALSE;
}
}
function filterString($field){
// Санитизация строки
$field = filter_var(trim($field), FILTER_SANITIZE_STRING);
if(!empty($field)){
return $field;
} else{
return FALSE;
}
}
// Определяем переменные и инициализирем с пустыми значениями
$nameErr = $emailErr = $messageErr = "";
$name = $email = $subject = $message = "";
// Обрабатываем данные формы при отправке формы
if($_SERVER["REQUEST_METHOD"] == "POST"){
// Валидация имени пользователя
if(empty($_POST["name"])){
$nameErr = "Пожалуйста, введите ваше имя.";
} else{
$name = filterName($_POST["name"]);
if($name == FALSE){
$nameErr = "Пожалуйста, введите верное имя.";
}
}
// Валидация e-mail
if(empty($_POST["email"])){
$emailErr = "Пожалуйста, введите адрес вашей электронной почты.";
} else{
$email = filterEmail($_POST["email"]);
if($email == FALSE){
$emailErr = "Пожалуйста, введите действительный адрес электронной почты.";
}
}
// Валидация темы сообщения
if(empty($_POST["subject"])){
$subject = "";
} else{
$subject = filterString($_POST["subject"]);
}
// Валидация комментария пользователя
if(empty($_POST["message"])){
$messageErr = "Пожалуйста, введите свой комментарий.";
} else{
$message = filterString($_POST["message"]);
if($message == FALSE){
$messageErr = "Пожалуйста, введите правильный комментарий.";
}
}
// Проверяем ошибки ввода перед отправкой электронной почты
if(empty($nameErr) && empty($emailErr) && empty($messageErr)){
// Электронный адрес получателя
$to = 'webmaster@example.com';
// Создаем заголовки письма
$headers = 'From: '. $email . "\r\n" .
'Reply-To: '. $email . "\r\n" .
'X-Mailer: PHP/' . phpversion();
// Отправляем электронную почту
if(mail($to, $subject, $message, $headers)){
echo '<p class="success">Ваше сообщение было отправлено успешно!</p>';
} else{
echo '<p class="error">Невозможно отправить электронное письмо. Пожалуйста, попробуйте еще раз!</p>';
}
}
}
?><!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Contact Form</title>
<style type="text/css">
.error{ color: red; }
.success{ color: green; }
</style>
</head>
<body>
<h2>Связаться с нами</h2>
<p>Заполните эту форму, чтобы связаться с нами.</p>
<form action="contact.php" method="post">
<p>
<label for="inputName">Имя:<sup>*</sup></label>
<input type="text" name="name" id="inputName" value="<?php echo $name; ?>">
<span class="error"><?php echo $nameErr; ?></span>
</p>
<p>
<label for="inputEmail">Email:<sup>*</sup></label>
<input type="text" name="email" id="inputEmail" value="<?php echo $email; ?>">
<span class="error"><?php echo $emailErr; ?></span>
</p>
<p>
<label for="inputSubject">Тема:</label>
<input type="text" name="subject" id="inputSubject" value="<?php echo $subject; ?>">
</p>
<p>
<label for="inputComment">Сообщение:<sup>*</sup></label>
<textarea name="message" id="inputComment" rows="5" cols="30"><?php echo $message; ?></textarea>
<span class="error"><?php echo $messageErr; ?></span>
</p>
<input type="submit" value="Отправить">
<input type="reset" value="Очистить">
</form>
</body>
</html>Разберем этот код подробнее.
filterName() (строка №-03) проверяет входное значение емени пользователя. Допустимое имя может содержать только буквы алфавита (a-z, A-Z).filterEmail() (строка №-14) проверяет входное значение адреса электронной почты.filterString() (строка № 25) только очищает входное значение, удаляя HTML-теги и специальные символы. Она не проверяет входящее значение.action="contact.php" (строка № 111) внутри тега <form> указывает, что тот же файл contact.php отображает форму, а также обрабатывает данные формы.value <input> и <textarea>, например, <?php echo $name; ?> отображает предварительно заполненное значение, когда форма повторно отображается при ошибке проверки.error, например, <span class="error"><?php echo $nameErr; ?></span> отображает ошибку для соответствующего поля.Вам необходимо настроить почтовый сервер на вашем компьютере, чтобы PHP-функция mail() работала. Если вы просто хотите реализовать проверку формы, вы можете заменить часть почты (строки с 81 по 94) своим собственным кодом.
Очистка и проверка введенных пользователем данных — одна из наиболее распространенных задач в веб-приложении. Чтобы упростить эту задачу в PHP есть встроенные фильтры, которое вы можете использовать для очистки или проверки данных, таких как адреса электронной почты, URL-адреса, IP-адреса и т.д.
Для проверки данных с помощью расширения фильтра вам необходимо использовать PHP-функцию filter_var(). Базовый синтаксис этой функции может быть задан следующим образом:
filter_var(variable, filter, options)Эта функция принимает три параметра, последние два из которых являются необязательными. Первый параметр — это значение, которое нужно отфильтровать, второй параметр — это идентификатор применяемого фильтра, а третий параметр — это массив параметров, связанных с фильтром. Посмотрим, как это работает.
В следующем примере выполняется очистка строки путем удаления из нее всех HTML-тегов:
<?php
// Пример комментария пользователя
$comment = "<h1>Hey there! How are you doing today?</h1>";
// Очистка и печать строки комментария
$sanitizedComment = filter_var($comment, FILTER_SANITIZE_STRING);
echo $sanitizedComment; // Выводит: Hey there! How are you doing today?
?>В следующем примере будет проверяться, является ли значение действительным целым числом или нет.
<?php
// Пример целочисленного значения
$int = 20;
// Проверка целочисленного значения
if(filter_var($int, FILTER_VALIDATE_INT)){
echo "Переменная <b>$int</b> является действительным целым числом";
} else{
echo "Переменная <b>$int</b> не является действительным целым числом";
}
?>В приведенном выше примере, если переменная $int установлена в 0, код примера отобразит, что это недопустимое целочисленное значение. Чтобы решить эту проблему, вам необходимо явно проверить значение 0, как показано ниже:
<?php
// Пример целочисленного значения
$int = 0;
// Проверка целочисленного значения
if(filter_var($int, FILTER_VALIDATE_INT) === 0 || filter_var($int, FILTER_VALIDATE_INT)){
echo "Переменная <b>$int</b> является действительным целым числом";
} else{
echo "Переменная <b>$int</b> не является действительным целым числом";
}
?>В следующем примере будет проверяться, является ли значение действительным IP-адресом или нет.
<?php
// Пример IP-адреса
$ip = "172.16.254.1";
// Проверка IP-адреса
if(filter_var($ip, FILTER_VALIDATE_IP)){
echo "Переменная <b>$ip</b> действительный IP-адрес";
} else {
echo "Переменная <b>$ip</b> не действительный IP-адрес";
}
?>Вы можете дополнительно применить проверку для IP-адресов IPV4 или IPV6, используя флаги FILTER_FLAG_IPV4 и FILTER_FLAG_IPV6 соответственно. Вот пример:
<?php
// Пример IP-адреса
$ip = "172.16.254.1";
// Проверка IP-адреса
if(filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6)){
echo "Переменная <b>$ip</b> это действительный адрес IPV6";
} else {
echo "Переменная <b>$ip</b> не является действительным адресом IPV6";
}
?>В следующем примере показано, как очистить и проверить адрес электронной почты.
<?php
// Образец электронного адреса
$email = "someone
© example.com";
// Удаляем из электронной почты все недопустимые символы
$sanitizedEmail = filter_var($email, FILTER_SANITIZE_EMAIL);
// Проверка адреса электронной почты
if($email == $sanitizedEmail && filter_var($email, FILTER_VALIDATE_EMAIL)){
echo "Переменная $email это действительный адрес электронной почты";
} else{
echo "Переменная $email не действительный адрес электронной почты";
}
?>Фильтр FILTER_SANITIZE_EMAIL удаляет все недопустимые символы из предоставленной строки адреса электронной почты, кроме букв, цифр и символов:
!#$%&'*+-=?^_`{|}~@.[]В следующем примере показано, как очистить и проверить URL-адрес.
<?php
// Пример URL-адреса веб-сайта
$url = "http:://www.example.com";
// Удаляем все недопустимые символы из URL
$sanitizedUrl = filter_var($url, FILTER_SANITIZE_URL);
// Проверка URL-адрес веб-сайта
if($url == $sanitizedUrl && filter_var($url, FILTER_VALIDATE_URL)){
echo "Переменная $url действительный URL-адрес веб-сайта";
} else{
echo "Переменная $url недействительный URL-адрес веб-сайта";
}
?>Фильтр FILTER_SANITIZE_URL удаляет все недопустимые символы из предоставленной строки URL, кроме букв, цифр и символов:
$-_.+!*'(),{}|\\^~[]`<>#%";/?:@&=Вы также можете проверить, содержит ли URL-адрес строку запроса используя флаг FILTER_FLAG_QUERY_REQUIRED, как показано в следующем примере:
<?php
// Пример URL-адреса веб-сайта
$url = "http://www.example.com?topic=filters";
// Проверяем URL-адрес веб-сайта для строки запроса
if(filter_var($url, FILTER_VALIDATE_URL, FILTER_FLAG_QUERY_REQUIRED)){
echo "Переменная <b>$url</b> содержит строку запроса";
} else{
echo "Переменная <b>$url</b> не содержит строку запроса";
}
?>В следующем примере проверяется, является ли предоставленное значение целым числом или нет, а также находится ли оно в диапазоне от 0 до 100 или нет.
<?php
// Пример целочисленного значения
$int = 75;
// Проверка целочисленного значения
if(filter_var($int, FILTER_VALIDATE_INT, array("options" => array("min_range" => 0,"max_range" => 100)))){
echo "Переменная <b>$int</b> находится в диапазоне от 0 до 100";
} else{
echo "Переменная <b>$int</b> is not within the range of 0 to 100";
}
?>Иногда ваше приложение не запускается должным образом, что приводит к ошибкам. Есть ряд причин, которые могут вызвать ошибки, например:
Эти типы ошибок известны как ошибки времени выполнения, потому что они возникают во время выполнения скрипта. Они отличаются от синтаксических ошибок, которые необходимо исправлять перед запуском скриптов.
Профессиональное приложение должно иметь возможность изящно обрабатывать такие ошибки времени выполнения. Обычно это означает более четкое и точное информирование пользователя о проблеме.
Обычно, когда возникает проблема, препятствующая правильной работе скрипта, механизм PHP выдает ошибку. Каждая ошибка представлена целым числом и соответствующей константой. В следующей таблице перечислены некоторые из распространенных уровней ошибок:
| Название | Значение | Описание |
|---|---|---|
| E_ERROR | 1 | Неустранимая ошибка времени выполнения от которой невозможно избавиться. Выполнение скрипта немедленно прекращается. |
| E_WARNING | 2 | Предупреждение во время выполнения. Она несущественна, и большинство ошибок попадают в эту категорию. Выполнение скрипта не останавливается. |
| E_NOTICE | 8 | Уведомление во время выполнения. Указывает, что скрипт обнаружил что-то, что могло быть ошибкой, хотя такая ситуация также может возникнуть при обычном запуске скрипта. |
| E_USER_ERROR | 256 | Сообщение о фатальной пользовательской ошибке. Она похожа на E_ERROR, за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error(). |
| E_USER_WARNING | 512 | Предупреждающее сообщение, созданное пользователем без фатального исхода. Она похожа на E_WARNING, за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error(). |
| E_USER_NOTICE | 1024 | Сообщение с уведомлением, созданное пользователем. Она похожа на E_NOTICE за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error(). |
| E_STRICT | 2048 | Не совсем ошибка, но срабатывает всякий раз, когда PHP встречает код, который может привести к проблемам или несовместимости пересылки. |
| E_ALL | 8191 | Все ошибки и предупреждения, кроме E_STRICT до PHP 5.4.0. |
Механизм PHP вызывает ошибку всякий раз, когда он сталкивается с проблемой в вашем скрипте, но вы также можете инициировать ошибки самостоятельно, чтобы генерировать более удобные сообщения об ошибках. Таким образом вы можете сделать свое приложение более сложным. В следующем разделе описаны некоторые из распространенных методов, используемых для обработки ошибок в PHP:
Рассмотрим следующий пример, в котором просто попытаемся открыть текстовый файл только для чтения.
<?php
// Пробуем открыть несуществующий файл
$file = fopen("sample.txt", "r"); // Выводит: Warning: fopen(sample.txt) [function.fopen]: failed to open stream: No such file or directory in C:\wamp\www\project\test.php on line 2
?>Если мы выполним несколько простых шагов, мы сможем предотвратить получение пользователями такого сообщения об ошибке.
<?php
if(file_exists("sample.txt")){
$file = fopen("sample.txt", "r");
} else{
die("Error: The file you are trying to access doesn't exist.");
}
?>Как вы можете видеть, реализовав простую проверку, существует ли файл перед попыткой доступа к нему, мы можем сгенерировать сообщение об ошибке, которое будет более понятным для пользователя.
Используемая выше функция die() просто отображает пользовательское сообщение об ошибке и завершает текущий скрипт, если файл sample.txt не найден.
Вы можете создать свою собственную функцию обработчика ошибок, чтобы справляться с ошибкой времени выполнения, генерируемой механизмом PHP. Пользовательский обработчик ошибок обеспечивает большую гибкость и лучший контроль над ошибками; он может проверять ошибку и решать, что с ней делать — отображать сообщение пользователю, регистрировать ошибку в файле или базе данных или отправлять по электронной почте, попытаться исправить проблему и продолжить, выйти из выполнения скрипта или вообще игнорировать ошибку.
Функция пользовательского обработчика ошибок должна иметь возможность обрабатывать как минимум два параметра errno и errstr, однако она может дополнительно принимать три дополнительных параметра errfile, errline и errcontext, как описано ниже:
Следующие параметры обязательны:
errno - задает уровень ошибки в виде целого числа. Это соответствует соответствующей константе уровня ошибки (E_ERROR, E_WARNING и т.д.).errstr - задает сообщение об ошибке в виде строки.Следующие параметры являются необязательными:
errfile - задает имя файла скрипта, в котором произошла ошибка.errline - задает номер строки, в которой произошла ошибка.errcontext - задает массив, содержащий все переменные и их значения, которые существовали на момент возникновения ошибки. Полезно для отладки.Вот пример простой пользовательской функции обработки ошибок. Этот обработчик customError() запускается всякий раз, когда возникает ошибка, какой бы тривиальной она ни была. Затем он выводит сведения об ошибке в браузер и останавливает выполнение скрипта.
<?php
// Функция обработчика ошибок
function customError($errno, $errstr){
echo "<b>Error:</b> [$errno] $errstr";
}
?>Вам нужно указать PHP, чтобы он использовал вашу пользовательскую функцию обработчика ошибок — просто вызовите встроенную функцию set_error_handler(), передав имя функции.
<?php
// Функция обработчика ошибок
function customError($errno, $errstr){
echo "<b>Error:</b> [$errno] $errstr";
}
// Устанавливаем обработчик ошибок
set_error_handler("customError");
// Вызываем ошибку
echo($test);
?>Вы также можете записать подробную информацию об ошибке в файл журнала, например:
<?php
function calcDivision($dividend, $divisor){
if($divisor == 0){
trigger_error("calcDivision(): The divisor cannot be zero", E_USER_WARNING);
return false;
} else{
return($dividend / $divisor);
}
}
function customError($errno, $errstr, $errfile, $errline, $errcontext){
$message = date("Y-m-d H:i:s - ");
$message .= "Error: [" . $errno ."], " . "$errstr in $errfile on line $errline, ";
$message .= "Variables:" . print_r($errcontext, true) . "\r\n";
error_log($message, 3, "logs/app_errors.log");
die("There was a problem, please try again.");
}
set_error_handler("customError");
echo calcDivision(10, 0);
echo "This will never be printed.";
?>Вы также можете отправить электронное письмо с подробностями об ошибке, используя ту же функцию error_log().
<?php
function calcDivision($dividend, $divisor){
if ($divisor == 0){
trigger_error("calcDivision(): The divisor cannot be zero", E_USER_WARNING);
return false;
} else{
return($dividend / $divisor);
}
}
function customError($errno, $errstr, $errfile, $errline, $errcontext){
$message = date("Y-m-d H:i:s - ");
$message .= "Error: [" . $errno ."], " . "$errstr in $errfile on line $errline, ";
$message .= "Variables:" . print_r($errcontext, true) . "\r\n";
error_log($message, 1, "webmaster@example.com");
die("There was a problem, please try again. Error report submitted to webmaster.");
}
set_error_handler("customError");
echo calcDivision(10, 0);
echo "This will never be printed.";
?>Хотя движок PHP выдает ошибку всякий раз, когда он сталкивается с проблемой в вашем скрипте, вы также можете вызвать ошибки самостоятельно. Это может помочь сделать ваше приложение более надежным, поскольку оно может выявлять потенциальные проблемы до того, как они перерастут в серьезные ошибки.
Чтобы вызвать ошибку в скрипте, вызовите функцию trigger_error(), передав сообщение об ошибке, которое вы хотите сгенерировать:
trigger_error("There was a problem.");Рассмотрим следующую функцию, которая вычисляет деление двух чисел.
<?php
function calcDivision($dividend, $divisor){
return($dividend / $divisor);
}
// Вызываем функцию
echo calcDivision(10, 0); // Выводит: Warning: Division by zero in C:\wamp\www\project\test.php on line 3
?>Это сообщение выглядит не очень информативным. Рассмотрим следующий пример, в котором для генерации ошибки используется функция trigger_error().
<?php
function calcDivision($dividend, $divisor){
if($divisor == 0){
trigger_error("Делитель не может быть нулевым", E_USER_WARNING);
return false;
} else{
return($dividend / $divisor);
}
}
// Вызываем функцию
echo calcDivision(10, 0); // Выводит: Warning: Делитель не может быть нулевым C:\wamp\www\project\error.php on line 4
?>Как видите, сообщение об ошибке, созданное во втором примере, более четко объясняет проблему по сравнению с предыдущим.
Объектно-ориентированное программирование (ООП) — это модель программирования, основанная на концепции классов и объектов. В отличие от процедурного программирования, где основное внимание уделяется написанию процедур или функций, выполняющих операции с данными, в объектно-ориентированном программировании основное внимание уделяется созданию объектов, которые содержат как данные, так и функции вместе.
Объектно-ориентированное программирование имеет несколько преимуществ перед обычным или процедурным стилем программирования. Наиболее важные из них перечислены ниже:
В этом разделе будет описано, как классы и объекты работают в PHP.
Идея, лежащая в основе принципа «Не повторяйся» (DRY), состоит в том, чтобы уменьшить повторение кода за счет абстрагирования кода, который является общим для приложения, и размещения его в одном месте и повторного использования вместо его повторения.
Классы и объекты — это два основных аспекта объектно-ориентированного программирования. Класс — это автономный, независимый набор переменных и функций, которые работают вместе для выполнения одной или нескольких конкретных задач, в то время как объекты являются отдельными экземплярами класса.
Класс действует как шаблон или план, из которого можно создать множество отдельных объектов. Когда создаются отдельные объекты, они наследуют одни и те же общие свойства и поведение, хотя каждый объект может иметь разные значения для определенных свойств.
Например, представим класс как проект дома. Сам чертеж — это не дом, а подробный план дома. А объект похож на настоящий дом, построенный по этому проекту. Мы можем построить несколько одинаковых домов по одному и тому же проекту, но у каждого дома может быть разная окраска, интерьер и семья.
Класс можно объявить с помощью ключевого слова class, за которым следует имя класса и пара фигурных скобок {}, как показано в следующем примере.
Давайте создадим PHP-файл с именем rectangle.php и поместим в него следующий пример кода, чтобы код нашего класса был отделен от остальной части программы. Затем мы можем использовать его везде, где это необходимо, просто включив файл rectangle.php.
<?php
class Rectangle
{
// Объявляем свойства
public $length = 0;
public $width = 0;
// Функция для получения периметра
public function getPerimeter(){
return (2 * ($this->length + $this->width));
}
// Функция для получения площади
public function getArea(){
return ($this->length * $this->width);
}
}
?>Ключевое слово public перед свойствами и методами в приведенном выше примере является модификатором доступа, который указывает, что это свойство или метод доступен из любого места. Мы узнаем об этом больше немного позже в этой главе.
Синтаксически переменные внутри класса называются свойствами, а функции — методами. Также имена классов обычно записываются в PascalCase, т.е. каждое объединенное слово начинается с заглавной буквы (например, MyClass).
После определения класса объекты могут быть созданы из класса с помощью ключевого слова new. Доступ к методам и свойствам класса можно получить напрямую через этот экземпляр объекта.
Создайте еще один PHP-файл с именем test.php и поместите в него следующий код.
<?php
// Включаем определение класса
require "Rectangle.php";
// Создаем новый объект из класса Rectangle
$obj = new Rectangle;
// Получаем значения свойств объекта
echo $obj->length; // Выводит: 0
echo $obj->width; // Выводит: 0
// Устанавливаем значения свойств объекта
$obj->length = 30;
$obj->width = 20;
// Читаем значения свойств объекта еще раз, чтобы показать изменение
echo $obj->length; // Выводит: 30
echo $obj->width; // Выводит: 20
// Вызываем методы объекта
echo $obj->getPerimeter(); // Выводит: 100
echo $obj->getArea(); // Выводит: 600
?>Символ стрелки -> — это конструкция ООП, которая используется для доступа к содержащимся в ней свойствам и методам данного объекта. Псевдопеременная $this предоставляет ссылку на вызывающий объект, то есть объект, которому принадлежит метод.
Настоящая мощь объектно-ориентированного программирования становится очевидной при использовании нескольких экземпляров одного и того же класса, как показано в следующем примере:
<?php
// Включвем определение класса
require "Rectangle.php";
// Создаем несколько объектов из класса Rectangle
$obj1 = new Rectangle;
$obj2 = new Rectangle;
// Вызываем методы обоих объектов
echo $obj1->getArea(); // Выводит: 0
echo $obj2->getArea(); // Выводит: 0
// Устанавливаем значения свойств $obj1
$obj1->length = 30;
$obj1->width = 20;
// Устанавливаем значения свойств $obj2
$obj2->length = 35;
$obj2->width = 50;
// Снова вызываем методы обоих объектов
echo $obj1->getArea(); // Выводит: 600
echo $obj2->getArea(); // Выводит: 1750
?>Как вы можете видеть в приведенном выше примере, вызов метода getArea() для разных объектов заставляет этот метод работать с разным набором данных. Каждый экземпляр объекта полностью независим, со своими собственными свойствами и методами, и поэтому ими можно управлять независимо, даже если они принадлежат к одному классу.
Чтобы упростить объектно-ориентированное программирование, PHP предоставляет некоторые волшебные методы, которые выполняются автоматически при выполнении определенных действий внутри объекта.
Например, магический метод __construct() (конструктор) выполняется автоматически всякий раз, когда создается новый объект. Точно так же магический метод __destruct() (деструктор) выполняется автоматически при уничтожении объекта. Функция деструктора очищает все ресурсы, выделенные объекту, после его уничтожения.
<?php
class MyClass
{
// Конструктор
public function __construct(){
echo 'The class "' . __CLASS__ . '" was initiated!<br>';
}
// Деструктор
public function __destruct(){
echo 'The class "' . __CLASS__ . '" was destroyed.<br>';
}
}
// Создаем новый объект
$obj = new MyClass;
// Выводим сообщение в конце файла
echo "The end of the file is reached.";
/* Выводит: The class "MyClass" was initiated!
The end of the file is reached.
The class "MyClass" was destroyed. */
?>Деструктор вызывается автоматически при завершении скрипта. Однако для явного запуска деструктора вы можете уничтожить объект с помощью PHP-функции unset(), как показано ниже:
<?php
class MyClass
{
// Конструктор
public function __construct(){
echo 'The class "' . __CLASS__ . '" was initiated!<br>';
}
// Деструктор
public function __destruct(){
echo 'The class "' . __CLASS__ . '" was destroyed.<br>';
}
}
// Создаем новый объект
$obj = new MyClass;
// Уничтожаем объект
unset($obj);
// Выводим сообщение в конце файла
echo "The end of the file is reached.";
/* Выводит: The class "MyClass" was initiated!
The class "MyClass" was destroyed.
The end of the file is reached. */
?>__CLASS__ — это магическая константа, которая содержит имя класса, в котором она встречается. Пустая, если вызывается вне класса.
Классы могут наследовать свойства и методы другого класса с помощью ключевого слова extends. Этот процесс расширяемости называется наследованием. Это, вероятно, самая веская причина использования объектно-ориентированной модели программирования.
<?php
// Включаем определение класса
require "Rectangle.php";
// Определяем новый класс на основе существующего класса
class Square extends Rectangle
{
// Метод проверки, является ли прямоугольник также квадратом
public function isSquare(){
if($this->length == $this->width){
return true; // Квадрат
} else{
return false; // Не квадрат
}
}
}
// Создаем новый объект из класса Square
$obj = new Square;
// Устанавливаем значения свойств объекта
$obj->length = 20;
$obj->width = 20;
// Вызываем методы объекта
if($obj->isSquare()){
echo "The area of the square is ";
} else{
echo "The area of the rectangle is ";
};
echo $obj->getArea(); // Выводит: The area of the square is 400
?>Как вы можете видеть в приведенном выше примере, хотя определение класса Square явно не содержит ни метод getArea(), ни свойства $length и $width, экземпляры класса Square могут использовать их, поскольку они унаследованы от родительского класса Rectangle.
Поскольку дочерний класс является производным от родительского класса, он также называется производным классом, а его родительский класс называется базовым классом.
При работе с классами вы даже можете ограничить доступ к его свойствам и методам, используя ключевые слова видимости для большего контроля. Существует три ключевых слова видимости (от наиболее заметного до наименее заметного): public, protected, private, которые определяют, как и откуда можно получить доступ к свойствам и методам для их изменения.
public — доступ к общедоступному свойству или методу можно получить где угодно, как внутри класса, так и за его пределами. Это видимость установлена по умолчанию для всех классов в PHP;protected — доступ к защищенному свойству или методу можно получить только внутри самого класса, в дочерних или унаследованных классах, то есть классах, расширяющих этот класс;private — частное свойство или метод доступны только из класса, который его определяет. Даже дочерние или унаследованные классы не могут получить доступ к частным свойствам или методам.Следующий пример покажет вам, как на самом деле работает эта видимость:
<?php
// Определяем класс
class Automobile
{
// Объявляем свойства
public $fuel;
protected $engine;
private $transmission;
}
class Car extends Automobile
{
// Конструктор
public function __construct(){
echo 'The class "' . __CLASS__ . '" was initiated!<br>';
}
}
// Создаем объект из класса Automobile
$automobile = new Automobile;
// Попытка установить свойства объекта $cars
$automobile->fuel = 'Petrol'; // ok
$automobile->engine = '1500 cc'; // fatal error
$automobile->transmission = 'Manual'; // fatal error
// Создаем объект из класса Car
$car = new Car;
// Попытка установить свойства объекта $car
$car->fuel = 'Diesel'; // ok
$car->engine = '2200 cc'; // fatal error
$car->transmission = 'Automatic'; // undefined
?>В дополнение к видимости свойства и методы также могут быть объявлены как static, что делает их доступными без создания экземпляра класса. Доступ к статическим свойствам и методам можно получить с помощью оператора разрешения области видимости ::, например: ClassName::$property и ClassName::method().
К свойству, объявленному как static, нельзя получить доступ через объект этого класса, хотя можно использовать статический метод, как показано в следующем примере:
<?php
// Определяем класс
class HelloClass
{
// Объявляем статическое свойство
public static $greeting = "Hello World!";
// Объявляем статический метод
public static function sayHello(){
echo self::$greeting;
}
}
// Попытка получить доступ к статическому свойству и методу напрямую
echo HelloClass::$greeting; // Выводит: Hello World!
HelloClass::sayHello(); // Выводит: Hello World!
// Попытка получить доступ к статическому свойству и методу через объект
$hello = new HelloClass;
echo $hello->greeting; // Strict Warning
$hello->sayHello(); // Выводит: Hello World!
?>Ключевое слово self в приведенном выше примере означает «текущий класс». Ему никогда не предшествует знак доллара $, а за ним всегда следует оператор :: (например, self::$name).
Ключевое слово self отличается от ключевого слова this, которое означает «текущий объект» или «текущий экземпляр класса». Ключевому слову this всегда предшествует знак доллара $, за которым следует оператор -> (например, $this->name).
Поскольку статические методы могут быть вызваны без экземпляра класса (то есть объекта), псевдопеременная $this недоступна внутри метода, объявленного как static.
В руководстве по константам PHP мы узнали, как определять и использовать константы в PHP-скриптах.
Кроме того, PHP также предоставляет набор специальных предопределенных констант, которые меняются в зависимости от того, где они используются. Эти константы называются магическими константами. Например, значение __LINE__ зависит от строки, в которой оно используется в вашем скрипте.
Магические константы начинаются с двух знаков подчеркивания и заканчиваются двумя знаками подчеркивания. В этом разделе описаны некоторые из самых полезных магических констант PHP.
Константа __LINE__ возвращает текущий номер строки файла, например:
<?php
echo "Line number " . __LINE__ . "<br>"; // Displays: Line number 2
echo "Line number " . __LINE__ . "<br>"; // Displays: Line number 3
echo "Line number " . __LINE__ . "<br>"; // Displays: Line number 4
?>Константа __FILE__ возвращает полный путь и имя исполняемого PHP-файла. Если используется внутри включения include, возвращается имя включенного файла.
<?php
// Отображает абсолютный путь к этому файлу
echo "The full path of this file is: " . __FILE__;
?>Константа __DIR__ возвращает каталог файла. Если используется внутри включения include, возвращается каталог включаемого файла. Вот пример:
<?php
// Отображает каталог этого файла
echo "The directory of this file is: " . __DIR__;
?>Константа __FUNCTION__ возвращает имя текущей функции.
<?php
function myFunction(){
echo "The function name is - " . __FUNCTION__;
}
myFunction(); // Выводит: The function name is - myFunction
?>Константа __CLASS__ возвращает имя текущего класса. Вот пример:
<?php
class MyClass
{
public function getClassName(){
return __CLASS__;
}
}
$obj = new MyClass();
echo $obj->getClassName(); // Выводит: MyClass
?>Константа __METHOD__ возвращает имя текущего метода класса.
<?php
class Sample
{
public function myMethod(){
echo __METHOD__;
}
}
$obj = new Sample();
$obj->myMethod(); // Выводит: Sample::myMethod
?>Константа __NAMESPACE__ возвращает имя текущего пространства имен.
<?php
namespace MyNamespace;
class MyClass
{
public function getNamespace(){
return __NAMESPACE__;
}
}
$obj = new MyClass();
echo $obj->getNamespace(); // Выводит: MyNamespace
?>JSON расшифровывается как JavaScript Object Notation. JSON — это стандартный легкий формат обмена данными, который просто и быстро анализировать и генерировать.
JSON, как и XML, представляет собой текстовый формат, который легко писать и легко читать как людям, так и для компьютерам, но в отличие от XML, структуры JSON-данных имеют меньшую пропускную способность, чем их версии XML. JSON основан на двух основных структурах:
Object: определяется как набор пар ключ/значение key:value. Каждый объект начинается с левой фигурной скобки { и заканчивается правой фигурной скобкой }. Несколько пар ключ/значение разделяются запятой ,.Array: это упорядоченный список значений. Массив начинается с левой скобки [ и заканчивается правой скобкой ]. Значения разделяются запятой ,.В JSON ключи всегда являются строками, а значение может быть string, number, true или false, null и даже object или array. Строки должны быть заключены в двойные кавычки " и могут содержать escape-символы, такие как \n, \t и \. Объект JSON может выглядеть следующим образом:
{
"book": {
"name": "Harry Potter and the Goblet of Fire",
"author": "J. K. Rowling",
"year": 2000,
"genre": "Fantasy Fiction",
"bestseller": true
}
}В то время как пример JSON-массива будет выглядеть примерно так:
{
"fruits": [
"Apple",
"Banana",
"Strawberry",
"Mango"
]
}Формат обмена данными — это текстовый формат, который используется для обмена данными между различными платформами и операционными системами. JSON — самый популярный и легкий формат обмена данными для веб-приложений.
Структуры JSON-данных очень похожи на массивы PHP. PHP имеет встроенные функции для кодирования и декодирования данных JSON. Это функции json_encode() и json_decode() соответственно. Обе функции работают только со строковыми данными в кодировке UTF-8.
В PHP функция json_encode() используется для кодирования значения в JSON-формат. Кодируемое значение может быть любым типом данных PHP, кроме ресурса, такого как база данных или дескриптор файла. В приведенном ниже примере показано, как кодировать ассоциативный массив PHP в объект JSON:
<?php
// Ассоциативный массив
$marks = array("Peter"=>65, "Harry"=>80, "John"=>78, "Clark"=>90);
echo json_encode($marks);
/* Выводит: {"Peter":65,"Harry":80,"John":78,"Clark":90} */
?>Точно так же вы можете закодировать индексированный массив PHP в массив JSON, например:
<?php
// Индексированный массив
$colors = array("Red", "Green", "Blue", "Orange", "Yellow");
echo json_encode($colors);
/* Выводит: ["Red","Green","Blue","Orange","Yellow"] */
?>Вы также можете заставить функцию json_encode() возвращать индексированный массив PHP как объект JSON, используя параметр JSON_FORCE_OBJECT, как показано в примере ниже:
<?php
// Индексированный массив
$colors = array("Red", "Green", "Blue", "Orange");
echo json_encode($colors, JSON_FORCE_OBJECT);
/* Выводит: {"0":"Red","1":"Green","2":"Blue","3":"Orange"} */
?>Как вы можете видеть в приведенных выше примерах, неассоциативный массив может быть закодирован как массив или объект. Однако ассоциативный массив всегда кодируется как объект.
Расшифровать или декодировать JSON-данные так же просто, как и закодировать. Вы можете использовать PHP-функцию json_decode() для преобразования закодированной JSON-строки в соответствующий тип данных PHP. В следующем примере показано, как декодировать или преобразовать объект JSON в объект PHP.
<?php
// Хранение JSON-данных в переменной PHP
$json = '{"Peter":65,"Harry":80,"John":78,"Clark":90}';
var_dump(json_decode($json));
/* Выводит: object(stdClass)#1 (4) { ["Peter"]=> int(65) ["Harry"]=> int(80) ["John"]=> int(78) ["Clark"]=> int(90) } */
?>По умолчанию функция json_decode() возвращает объект. Однако вы можете дополнительно указать второй параметр $assoc, который принимает логическое значение, которое при установке в качестве true для JSON-объекта декодируется в ассоциативные массивы. По умолчанию — false. Вот пример:
<?php
// Хранение JSON-данных в переменной PHP
$json = '{"Peter":65,"Harry":80,"John":78,"Clark":90}';
var_dump(json_decode($json, true));
/* Выводит: array(4) { ["Peter"]=> int(65) ["Harry"]=> int(80) ["John"]=> int(78) ["Clark"]=> int(90) } */
?>Теперь давайте рассмотрим пример, который покажет вам, как декодировать JSON-данные и получить доступ к отдельным элементам объекта или массива JSON в PHP.
<?php
// Назначаем закодированную JSON-строку переменной PHP
$json = '{"Peter":65,"Harry":80,"John":78,"Clark":90}';
// Декодируем JSON-данные в ассоциативный массив PHP
$arr = json_decode($json, true);
// Доступ к значениям из ассоциативного массива
echo $arr["Peter"]; // Выводит: 65
echo $arr["Harry"]; // Выводит: 80
echo $arr["John"]; // Выводит: 78
echo $arr["Clark"]; // Выводит: 90
// Декодируем JSON-данные в объект PHP
$obj = json_decode($json);
// Доступ к значениям из объекта
echo $obj->Peter; // Выводит: 65
echo $obj->Harry; // Выводит: 80
echo $obj->John; // Выводит: 78
echo $obj->Clark; // Выводит: 90
?>Вы также можете просмотреть декодированные данные с помощью цикла foreach(), например:
<?php
// Назначаем закодированную JSON-строку переменной PHP
$json = '{"Peter":65,"Harry":80,"John":78,"Clark":90}';
// Декодируем JSON-данные в ассоциативный массив PHP
$arr = json_decode($json, true);
// Цикл ассоциативного массива
foreach($arr as $key=>$value){
echo $key . "=>" . $value . "<br>";
}
echo "<hr>";
// Декодируем JSON-данные в объект PHP
$obj = json_decode($json);
// Цикл объекта
foreach($obj as $key=>$value){
echo $key . "=>" . $value . "<br>";
}
?>Объекты и массивы JSON также могут быть вложенными. Объект JSON может произвольно содержать другие объекты JSON, массивы, вложенные массивы, массивы объектов JSON и т. д. В следующем примере показано, как декодировать вложенный объект JSON и распечатать все его значения в PHP.
<?php
// Определяем рекурсивную функцию для извлечения вложенных значений
function printValues($arr) {
global $count;
global $values;
// Проверяем, что это массив
if(!is_array($arr)){
die("ERROR: Input is not an array");
}
/* Запускаем основной цикл
Если значение само по себе является массивом, рекурсивно вызываем эту же функцию
Добавляем все найденные значения в массив элементов вывода и увеличиваем счетчик на 1 для каждого найденного значения */
foreach($arr as $key=>$value){
if(is_array($value)){
printValues($value);
} else{
$values[] = $value;
$count++;
}
}
// Возвращаем общее количество и значения, найденные в массиве
return array('total' => $count, 'values' => $values);
}
// Назначаем закодированную JSON-строку переменной PHP
$json = '{
"book": {
"name": "Harry Potter and the Goblet of Fire",
"author": "J. K. Rowling",
"year": 2000,
"characters": ["Harry Potter", "Hermione Granger", "Ron Weasley"],
"genre": "Fantasy Fiction",
"price": {
"paperback": "$10.40", "hardcover": "$20.32", "kindle": "4.11"
}
}
}';
// Декодируем JSON-данные в формат ассоциативного массива PHP
$arr = json_decode($json, true);
// Вызываем функцию и печатаем все значения
$result = printValues($arr);
echo "<h3>" . $result["total"] . " value(s) found: </h3>";
echo implode("<br>", $result["values"]);
echo "<hr>";
// Выводим одно значение
echo $arr["book"]["author"] . "<br>"; // Выводит: J. K. Rowling
echo $arr["book"]["characters"][0] . "<br>"; // Выводит: Harry Potter
echo $arr["book"]["price"]["hardcover"]; // Выводит: $20.32
?>Регулярные выражения в англоязычной практике часто называются regex или RegExp и представляют собой текстовые строки в специальном формате, используемые для поиска шаблонов в тексте. Регулярные выражения — один из самых мощных инструментов, доступных сегодня для эффективной обработки текста и манипуляций с ним.
Например, его можно использовать для проверки правильности формата данных — имени, адреса электронной почты, номера телефона, поиска или замены совпадающих строк в текстовом содержимом и т.д.
PHP (версия 5.3+) поддерживает регулярные выражения в синтаксисе Perl. Perl (Practical Extraction and Report Language) был первым распространенным языком программирования, который обеспечивал интегрированную поддержку регулярных выражений и большие возможности обработки и манипулирования текстом.
Давайте начнем с краткого обзора часто используемых встроенных функций сопоставления с образцом в PHP:
preg_match() - выполняет сопоставление регулярного выражения.preg_match_all() - выполняет глобальное сопоставление регулярного выражения.preg_replace() - выполняет поиск и замену по регулярному выражению.preg_grep() - возвращает элементы входного массива, соответствующие шаблону.preg_split() - разбивает строку на подстроки с помощью регулярного выражения.preg_quote() - цитирует символы регулярного выражения, найденные в строке.PHP-функция preg_match() прекращает поиск после нахождения первого совпадения, тогда как функция preg_match_all() продолжает поиск до конца строки и находит все возможные совпадения вместо остановки на первом совпадении.
Синтаксис регулярных выражений включает использование специальных символов (не путать со специальными символами HTML). В регулярном выражении особое значение имеют следующие символы: . * ? + [ ] ( ) { } ^ $ | \\. Вам нужно будет использовать обратную косую черту (слеш) для этих символов всякий раз, когда вы захотите использовать их буквально. Например, если вы хотите использовать в регулярном выражении символ . вам нужно будет писать \\.. Все остальные символы автоматически принимают свои буквальные значения.
В следующих разделах описаны различные варианты, доступные для формулирования шаблонов.
Квадратные скобки, окружающие набор символов, называются классом символов, например [abc]. Класс символов всегда соответствует одному символу из списка указанных символов, что означает, что выражение [abc] соответствует только символу a, b или c.
Также могут быть определены классы отрицательных символов, соответствующие любому символу, кроме символов, содержащихся в скобках. Класс инвертируемых символов определяется помещением символа каретки ^ сразу после открывающей скобки, как, например [^abc].
Вы также можете определить диапазон символов, используя символ дефиса - внутри класса символов, например [0-9]. Давайте посмотрим на несколько примеров этих классов:
[abc] - соответствует любому из символов a, b или c.[^abc] - соответствует любому символу, кроме a, b или c.[a-z] - соответствует любому символу от строчного a до строчного z.[A-Z] - соответствует любому символу от верхнего регистра A до верхнего регистра Z.[a-Z] - соответствует любому символу от нижнего a до верхнего Z.[0-9] - соответствует одной цифре от 0 до 9.[a-z0-9] - соответствует одиночному символу между a и z или между 0 и 9.В следующем примере показано, как определить, существует ли шаблон в строке или нет, используя регулярное выражение и PHP-функцию preg_match():
<?php
$pattern = "/ca[kf]e/";
$text = "He was eating cake in the cafe.";
if(preg_match($pattern, $text)){
echo "Match found!";
} else{
echo "Match not found.";
}
?>Точно так же вы можете использовать функцию preg_match_all(), чтобы найти все совпадения в строке:
<?php
$pattern = "/ca[kf]e/";
$text = "He was eating cake in the cafe.";
$matches = preg_match_all($pattern, $text, $array);
echo $matches . " matches were found.";
?>Регулярные выражения не являются уникальными для PHP. Такие языки, как Java, Perl, Python и т. д., используют ту же нотацию для поиска шаблонов в тексте.
Некоторые классы символов, такие как цифры, буквы и пробелы, используются так часто, что для них есть предопределенные ярлыки. В следующей таблице перечислены эти предопределенные классы символов:
. - соответствует любому одиночному символу, кроме новой строки \n.\d - соответствует любому цифровому символу. Тоже, что и [0-9].\D - соответствует любому нецифровому символу. Тоже, что и [^0-9].\s - соответствует любому пробельному символу (пробел, табуляция, новая строка или символ возврата каретки). Тоже, что и [ \t\n\r].\S - соответствует любому непробельному символу. Тоже, что и [^ \t\n\r].\w - соответствует любому буквенному символу (определяется как от a до z, от A до Z, от 0 до 9 и подчеркивание). Тоже, что и [a-zA-Z_0-9].\W - соответствует любому не буквенному символу. Тоже, что и [^a-zA-Z_0-9].В следующем примере показано, как найти и заменить пробел символом дефиса в строке с помощью регулярного выражения и PHP-функции preg_replace():
<?php
$pattern = "/\s/";
$replacement = "-";
$text = "Earth revolves around\nthe\tSun";
// Заменяем пробелы, символы новой строки и табуляции
echo preg_replace($pattern, $replacement, $text);
echo "<br>";
// Заменяем только пробелы
echo str_replace(" ", "-", $text);
?>В предыдущем разделе мы узнали, как сопоставлять сиволы разными способами. Но что, если вы хотите сопоставить более одного символа? Например, предположим, что вы хотите найти слова, содержащие один или несколько экземпляров буквы p, или слова, содержащие как минимум две буквы p, и так далее. Здесь вам помогут квантификаторы. С помощью квантификаторов вы можете указать, сколько раз должен совпадать символ в регулярном выражении.
В следующей таблице перечислены различные способы количественной оценки конкретного паттерна:
p+ - соответствует одному или нескольким вхождениям буквы p.p* - соответствует нулю или более вхождений буквы p.p? - соответствует нулю или одному появлению буквы p.p{2} - соответствует ровно двум вхождениям буквы p.p{2,3} - соответствует как минимум двум, но не более трем появленям буквы p.p{2,} - соответствует двум или более вхождениям буквы p.p{,3} - соответствует не более чем трем появлениям буквы p.Регулярное выражение в следующем примере разбивает строку на запятую, последовательность запятых, пробелы или их комбинацию с помощью PHP-функции preg_split():
<?php
$pattern = "/[\s,]+/";
$text = "My favourite colors are red, green and blue";
$parts = preg_split($pattern, $text);
// Перебираем массив частей и отображать подстроки
foreach($parts as $part){
echo $part . "<br>";
}
?>Есть определенные ситуации, когда вы захотите сопоставить начало или конец слова или строки. Для этого можно использовать два якоря — это каретка (^), обозначающая начало строки, и знак доллара ($), обозначающий конец строки.
^p - соответствует букве p в начале строки.p$ - соответствует букве p в конце строки.Регулярное выражение в следующем примере будет отображать только те имена из массива names, которые начинаются с буквы J с использованием PHP-функции preg_grep():
<?php
$pattern = "/^J/";
$names = array("Jhon Carter", "Clark Kent", "John Rambo");
$matches = preg_grep($pattern, $names);
// Перебираем массив и отображаем совпадающие имена
foreach($matches as $match){
echo $match . "<br>";
}
?>Модификатор шаблона позволяет вам контролировать способ обработки соответствия шаблону. Модификаторы размещаются непосредственно после регулярного выражения, например, если вы хотите искать шаблон без учета регистра, вы можете использовать модификатор i, например: /pattern/i.
i - делает совпадение нечувствительным к регистру.m - изменяет поведение ^ и $ для соответствия границе новой строки (т. е. начало или конец каждой строки в многострочной строке) вместо границы строки.g - выполняет глобальное сопоставление, т.е. ищет все вхождения.o - оценивает выражение только один раз.s - изменяет поведение . (точка) для соответствия всем символам, включая символы новой строки.x - Позволяет использовать пробелы и комментарии в регулярном выражении для ясности.В следующем примере показано, как выполнить глобальный поиск без учета регистра с использованием модификатора i и PHP-функции preg_match_all().
<?php
$pattern = "/color/i";
$text = "Color red is more visible than color blue in daylight.";
$matches = preg_match_all($pattern, $text, $array);
echo $matches . " matches were found.";
?>Точно так же в следующем примере показано, как сопоставить начало каждой строки в многострочной строке с помощью привязки ^ и модификатора m с PHP-функцией preg_match_all().
<?php
$pattern = "/^color/im";
$text = "Color red is more visible than \ncolor blue in daylight.";
$matches = preg_match_all($pattern, $text, $array);
echo $matches . " matches were found.";
?>Символ границы слова \b помогает вам искать слова, которые начинаются и/или заканчиваются определенным шаблоном. Например, регулярное выражение /\bcar/ соответствует словам, начинающимся с шаблона car, и будет соответствовать cart, carrot, или cartoon, но не будет совпадать с oscar.
Аналогично, регулярное выражение /car\b/ соответствует словам, оканчивающимся шаблоном car, и будет соответствовать oscar или supercar, но не будет соответствовать cart. Аналогично, /\bcar\b/ соответствует словам, начинающимся и заканчивающимся шаблоном car и будет соответствовать только слову car.
Следующий пример выделит слова, начинающиеся с car жирным шрифтом:
<?php
$pattern = '/\bcar\w*/';
$replacement = '<b>$0</b>';
$text = 'Words begining with car: cart, carrot, cartoon. Words ending with car: scar, oscar, supercar.';
echo preg_replace($pattern, $replacement, $text);
?>Обработка исключений (Exception Handling) — это сигнал, указывающий на какое-то исключительное событие или ошибку. Исключения могут быть вызваны разными причинами, например, сбой подключения к базе данных или запроса, файл, к которому вы пытаетесь получить доступ, не существует и так далее.
PHP предоставляет мощный механизм обработки исключений, который позволяет их изящно обрабатывать. В отличие от традиционной системы обработки ошибок PHP, обработка исключений — это объектно-ориентированный подход к обработке ошибок, который обеспечивает более контролируемую и гибкую форму сообщения об ошибках. Модель исключений была впервые представлена в PHP 5.
В подходе, основанном на исключениях, программный код записывается в блоке try, исключение может быть создано с помощью оператора throw, когда во время выполнения кода в блоке try возникает исключительное событие. Затем он перехватывается и разрешается одним или несколькими блоками catch.
В следующем примере показано, как работает обработка исключений:
<?php
function division($dividend, $divisor){
// Выбрасываем исключение, если делитель равен нулю
if($divisor == 0){
throw new Exception('Division by zero.');
} else{
$quotient = $dividend / $divisor;
echo "<p>$dividend / $divisor = $quotient</p>";
}
}
try{
division(10, 2);
division(30, -4);
division(15, 0);
// Если выбрано исключение, следующая строка не будет выполняться
echo '<p>All divisions performed successfully.</p>';
} catch(Exception $e){
// Обработка исключений
echo "<p>Caught exception: " . $e->getMessage() . "</p>";
}
// Продолжаем выполнение
echo "<p>Hello World!</p>";
?>Система обработки исключений PHP состоит в основном из четырех частей: try, throw, catch и класс Exception. В следующем списке описывается, как именно работает каждая часть.
division() в приведенном выше примере проверяет, равен ли делитель нулю. Если это так, то с помощью оператора throw PHP генерируется исключение. В противном случае эта функция выполняет деление с использованием заданных чисел и отображает результат.try вызывается функция division() с разными аргументами. Если при выполнении кода в блоке try генерируется исключение, PHP останавливает выполнение в этой точке и пытается найти соответствующий блок catch. Если он найден, выполняется код в этом блоке catch, если нет, генерируется фатальная ошибка.catch обычно перехватывает исключение, созданное в блоке try, и создает объект $e, содержащий информацию об исключении. Сообщение об ошибке от этого объекта можно получить с помощью метода getMessage().PHP-класс Exception также предоставляет методы getCode(), getFile(), getLine() и getTraceAsString(), которые можно использовать для генерации подробной отладочной информации.
<?php
// Отключаем отчет об ошибках по умолчанию
error_reporting(0);
try{
$file = "somefile.txt";
// Попытка открыть файл
$handle = fopen($file, "r");
if(!$handle){
throw new Exception("Cannot open the file!", 5);
}
// Попытка прочитать содержимое файла
$content = fread($handle, filesize($file));
if(!$content){
throw new Exception("Could not read file!", 10);
}
// Закрытие дескриптора файла
fclose($handle);
// Показываем содержимое файла
echo $content;
} catch(Exception $e){
echo "<h3>Caught Exception!</h3>";
echo "<p>Error message: " . $e->getMessage() . "</p>";
echo "<p>File: " . $e->getFile() . "</p>";
echo "<p>Line: " . $e->getLine() . "</p>";
echo "<p>Error code: " . $e->getCode() . "</p>";
echo "<p>Trace: " . $e->getTraceAsString() . "</p>";
}
?>Конструктор Exception дополнительно принимает сообщение об исключении и код исключения. Хотя сообщение об исключении обычно используется для отображения общей информации о том, что пошло не так, код исключения можно использовать для классификации ошибок. Предоставленный код исключения можно получить позже с помощью метода Exception getCode().
Исключения следует использовать только для обозначения исключительных условий; они не должны использоваться для управления обычным потоком приложения, например, для перехода в другое место в скрипте в определенной точке. Это отрицательно скажется на производительности вашего приложения.
Вы даже можете определить свои собственные обработчики исключений, чтобы обрабатывать разные типы исключений по-разному. Это позволяет вам использовать отдельный блок catch для каждого типа исключения.
Вы можете определить настраиваемое исключение, расширив класс Exception, потому что Exception является базовым классом для всех исключений. Пользовательский класс исключения наследует все свойства и методы от класса исключений PHP. Вы также можете добавить свои собственные методы в собственный класс исключений. Давайте посмотрим на следующий пример:
<?php
// Расширение класса Exception
class EmptyEmailException extends Exception {}
class InvalidEmailException extends Exception {}
$email = "someuser@example..com";
try{
// Проверяем, если адрес электронной почты пуст
if($email == ""){
throw new EmptyEmailException("<p>Please enter your E-mail address!</p>");
}
// Проверяем, если адрес электронной почты недействителен
if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE) {
throw new InvalidEmailException("<p><b>$email</b> is not a valid E-mail address!</p>");
}
// Отображаем сообщение об успешном завершении, если адрес электронной почты действителен
echo "<p>SUCCESS: Email validation successful.</p>";
} catch(EmptyEmailException $e){
echo $e->getMessage();
} catch(InvalidEmailException $e){
echo $e->getMessage();
}
?>В приведенном выше примере мы создали два новых класса исключений: EmptyEmailException, и InvalidEmailException из базового класса Exception. Несколько блоков catch используются для отображения различных сообщений об ошибках в зависимости от типа сгенерированного исключения.
Поскольку эти настраиваемые классы исключений наследуют свойства и методы класса Exception, мы можем использовать методы класса Exception, такие как getMessage(), getLine(), getFile() и т. д., для извлечения информации об ошибке из объекта исключения.
Как мы уже обсуждали ранее в этой главе, если исключение не перехвачено, PHP генерирует фатальную ошибку с сообщением Uncaught Exception …. Это сообщение об ошибке может содержать конфиденциальную информацию, такую как имя файла и номер строки, в которой возникает проблема. Если вы не хотите предоставлять такую информацию пользователю, вы можете создать собственную функцию и зарегистрировать ее с помощью функции set_exception_handler() для обработки всех неперехваченных исключений.
<?php
function handleUncaughtException($e){
// Отображаем общее сообщение об ошибке для пользователя
echo "Opps! Something went wrong. Please try again, or contact us if the problem persists.";
// Создаем строку ошибки
$error = "Uncaught Exception: " . $message = date("Y-m-d H:i:s - ");
$error .= $e->getMessage() . " in file " . $e->getFile() . " on line " . $e->getLine() . "\n";
// Записываем сведения об ошибке в файл
error_log($error, 3, "var/log/exceptionLog.log");
}
// Регистрируем пользовательский обработчик исключений
set_exception_handler("handleUncaughtException");
// Исключение
throw new Exception("Testing Exception!");
?>Неперехваченное исключение всегда приводит к завершению работы скрипта. Поэтому, если вы хотите, чтобы скрипт продолжал выполняться после того, как произошло исключение, у вас должен быть хотя бы один соответствующий блок catch для каждого блока try.
Следующие функции для работы со строками являются частью ядра PHP, поэтому вы можете использовать эти функции в своих скриптах без дополнительной установки.
addcslashes() - Возвращает строку с обратной косой чертой перед указанными символами.addslashes() - Возвращает строку с обратной косой чертой перед символами, которые необходимо экранировать. Это одинарная кавычка ‘, двойная кавычка «, обратная косая черта \\ и NULL.bin2hex() - Преобразует двоичные данные в шестнадцатеричные значения.chop() - Удаляет пробелы (или другие символы) из конца строки. Псевдоним rtrim().chr() - Возвращает односимвольную строку, содержащую символ, указанный в ASCII.chunk_split() - Разделяет строку на более мелкие куски.convert_cyr_string() - Преобразует строку из одного набора символов кириллицы в другой.convert_uudecode() - Декодирует строку uuencoded.convert_uuencode() - Кодирует строку с использованием алгоритма uuencode.count_chars() - Возвращает информацию о символах, используемых в строке.crc32() - Вычисляет полином crc32 строки.crypt() - Одностороннее шифрование строки (или хеширование).echo() - Выводит одну или несколько строк.explode() - Разделяет строку в массив по указанной строке.fprintf() - Записывает отформатированную строку в указанный выходной поток.get_html_translation_table() - Возвращает таблицу перевода, используемую htmlspecialchars() и htmlentities().hebrev() - Преобразует логический текст на иврите в визуальный текст.hebrevc() - Преобразует логического текста на иврите в визуальный текст с преобразованием новой строки.hex2bin() - Декодирует двоичную строку с шестнадцатеричным кодированием.html_entity_decode() - Преобразует все объекты HTML в соответствующие символы.htmlentities() - Преобразует все применимые символы в объекты HTML.htmlspecialchars_decode() - Преобразует специальные HTML-объекты обратно в символы.htmlspecialchars() - Преобразует специальные символы в объекты HTML.implode() - Возвращает строку, объединив элементы массива с указанной строкой.join() - Псевдоним implode().lcfirst() - Преобразует первый символ строки в нижний регистр.levenshtein() - Вычисляет расстояние Левенштейна между двумя струнами.localeconv() - Возвращает локализованную информацию о числовом и денежном форматировании.ltrim() - Удаляет пробелы (или другие символы) из начала строки.md5() - Вычисляет хэш md5 строки.md5_file() - Вычисляет md5-хэш файла.metaphone() - Вычисляет метафонный ключ строки.money_format() - Форматирует число как строку валюты.nl_langinfo() - Возвращает конкретную местную информацию.nl2br() - Вставляет разрывы строк HTML перед всеми символами новой строки в строке.number_format() - Форматирует число сгруппированными тысячами.ord() - Возвращает значение ASCII первого символа строки.parse_str() - Разбирает строку на переменные.print() - Выводит строку.printf() - Выводит форматированную строку.quoted_printable_decode() - Преобразует строки с кавычками для печати в 8-битную строку.quoted_printable_encode() - Преобразует 8-битную строку в строку с кавычками.quotemeta() - Цитаты мета персонажей.rtrim() - Удаляет пробелы (или другие символы) из конца строки.setlocale() - Устанавливает информацию о локали.sha1() - Вычисляет SHA1-хэш строки.sha1_file() - Вычисляет SHA1-хэш файла.similar_text() - Вычисляет сходство между двумя строками.soundex() - Вычисляет звуковой ключ строки.sprintf() - Возвращает отформатированную строку.sscanf() - Анализирует ввод из строки в соответствии с форматом.str_getcsv() - Разбирает строку CSV в массив.str_ireplace() - Заменяет все вхождения строки на заменяющую строку. Версия без учета регистра str_replace().str_pad() - Дополняет строку до определенной длины другой строкой.str_repeat() - Повторяет строку указанное количество раз.str_replace() - Заменяет все вхождения строки поиска на заменяющую строку (с учетом регистра).str_rot13() - Выполняет кодирование ROT13 строки.str_shuffle() - Случайным образом перемешивает все символы в строке.str_split() - Разбивает строку на массив.str_word_count() - Подсчитывает количество слов в строке.strcasecmp() - Бинарное безопасное сравнение двух строк (без учета регистра).strchr() - Находит первое вхождение строки внутри другой строки. Псевдоним strstr().strcmp() - Бинарное безопасное сравнение двух строк (с учетом регистра).strcoll() - Сравнение двух строк на основе локали (с учетом регистра).strcspn() - Возвращает количество символов, найденных в строке до того, как будет найдена какая-либо часть некоторых указанных символов.strip_tags() - Убирает HTML и PHP теги из строки.stripcslashes() - Удаляет кавычки из строки, заключенной в addcslashes().stripos() - Находит позицию первого вхождения подстроки без учета регистра в строке.stripslashes() - Удаляет кавычка из строки в кавычках.stristr() - Находит первое вхождение строки внутри другой строки (без учета регистра). Версия без учета регистра strstr().strlen() - Returns the length of a string.strnatcasecmp() - Сравнивает две строки с использованием алгоритма «естественного порядка» (без учета регистра).strnatcmp() - Сравнивает две строки с использованием алгоритма «естественного порядка» (с учетом регистра).strncasecmp() - Бинарное безопасное сравнение первых n символов строк (без учета регистра).strncmp() - Бинарное безопасное сравнение первых n символов строк (с учетом регистра).strpbrk() - Ищет в строке любой набор символов.strpos() - Находит позицию первого вхождения подстроки в строке.strrchr() - Находит последнее вхождение символа в строке.strrev() - Переворачивает строку.strripos() - Находит позицию последнего вхождения строки внутри другой строки (без учета регистра).strrpos() - Находит позицию последнего вхождения строки внутри другой строки (с учетом регистра).strspn() - Возвращает количество символов, найденных в строке, содержащей только символы из указанного списка символов.strstr() - Находит первое вхождение строки внутри другой строки (с учетом регистра).strtok() - Разбивает строку на более мелкие.strtolower() - Преобразует строку в нижний регистр.strtoupper() - Преобразует строку в верхний регистр.strtr() - Переводит символы или заменяет подстроки.substr() - Возвращает часть строки.substr_compare() - Сравнивает две строки от указанной начальной позиции до длины сравнения. Сравнение бинарно безопасно и возможно с учетом регистра.substr_count() - Подсчитывает, сколько раз подстрока встречается в строке.substr_replace() - Заменяет часть строки другой строкой.trim() - Удаляет пробелы (или другие символы) в начале и конце строки.ucfirst() - Преобразует первый символ строки в верхний регистр.ucwords() - Преобразует первый символ каждого слова в строке в верхний регистр.vfprintf() - Записывает отформатированную строку в указанный выходной поток.vprintf() - Выводит форматированную строку.vsprintf() - Возвращает отформатированную строку.wordwrap() - Переносит строку в заданное количество символов.Следующие функции для работы с массивами являются частью ядра PHP, поэтому вы можете использовать эти функции в своих скриптах без дополнительной установки.
array() - Создает массив.array_change_key_case() - Изменяет регистр всех ключей в массиве (нижний или верхний регистр).array_chunk() - Разбивает массив на части массивов.array_column() - Возвращает значения из одного столбца во входном массиве.array_combine() - Создает массив, используя один массив для ключей и другой для его значений.array_count_values() - Подсчитывает все значения массива.array_diff() - Сравнивает значения массивов, и возвращает различия.array_diff_assoc() - Сравнивает массивы ключей и значений, и возвращает различия.array_diff_key() - Сравнивает ключи массивов, и возвращает различия.array_diff_uassoc() - Сравнивает массивы ключей и значений, используя определяемую пользователем функцию сравнения ключей, и возвращает различия.array_diff_ukey() - Сравнивает ключи массива, используя определяемую пользователем функцию сравнения ключей, и возвращает различия.array_fill() - Заполняет массив значениями.array_fill_keys() - Заполняет массив значениями, указав ключи.array_filter() - Фильтрует элементы массива с помощью пользовательской функции.array_flip() - Переворачивает или меняет все ключи на связанные с ними значения в массиве.array_intersect() - Сравнивает значения массивов, и возвращает совпадения.array_intersect_assoc() - Сравнивает массивы ключей и значений, и возвращает совпадения.array_intersect_key() - Сравнивает ключи массивов, и возвращает совпадения.array_intersect_uassoc() - Сравнивает массивы ключей и значений, используя определяемую пользователем функцию сравнения ключей, и возвращает совпадения.array_intersect_ukey() - Сравнивает ключи массивов, используя определенную пользователем функцию сравнения ключей, и возвращает совпадения.array_keys() - Возвращает все ключи или подмножество ключей массива.array_key_exists() - Проверяет, существует ли указанный ключ в массиве.array_map() - Отправляет элементы данных массивов пользовательской функции, которая может использовать их для возврата новых значений.array_merge() - Объединяет один или несколько массивов в один массив.array_merge_recursive() - Рекурсивно объединяет один или несколько массивов в один.array_multisort() - Сортирует множественные или многомерные массивы.array_pad() - Вставляет указанное количество элементов с указанным значением в массив.array_pop() - Удаляет последний элемент массива, и возвращает значение удаленного элемента.array_product() - Вычисляет произведение значений в массиве.array_push() - Вставляет один или несколько элементов в конец массива.array_rand() - Возвращает один или несколько случайных ключей из массива.array_reduce() - Уменьшает массив до одного значения с помощью определяемой пользователем функции обратного вызова.array_replace() - Заменяет значения первого массива значениями из следующих массивов.array_replace_recursive() - Рекурсивно заменяет значения первого массива значениями из следующих массивов.array_reverse() - Возвращает массив с элементами в обратном порядке.array_search() - Ищет в массиве заданное значение и возвращает соответствующий ключ в случае успеха.array_shift() - Удаляет первый элемент из массива, и возвращает значение удаленного элемента.array_slice() - Извлекает фрагмент из массива.array_splice() - Удаляет часть массива и заменяет на что-нибудь другое.array_sum() - Вычисляет сумму значений в массиве.array_udiff() - Сравнивает только значения массивов, используя определенную пользователем функцию обратного вызова сравнения, и возвращает различия.array_udiff_assoc() - Сравнивает значения массивов с помощью определяемой пользователем функции обратного вызова сравнения, с дополнительным сравнением ключей с использованием внутренней (или встроенной) функции, и возвращает различия.array_udiff_uassoc() - Сравнивает ключи и значения массивов, используя две отдельные пользовательские функции обратного вызова сравнения, и возвращает различия.array_uintersect() - Сравнивает только значения массивов, используя определенную пользователем функцию обратного вызова сравнения, и возвращает совпадения.array_uintersect_assoc() - Сравнивает значения массивов с помощью определяемой пользователем функции обратного вызова сравнения, в то время как использует внутреннюю (или встроенную) функцию для сравнения ключа, и возвращает совпадения.array_uintersect_uassoc() - Сравнивает ключи и значения массивов, используя две отдельные пользовательские функции обратного вызова сравнения, и возвращает совпадения.array_unique() - Удаляет повторяющиеся значения из массива.array_unshift() - Добавляет один или несколько элементов в начало массива.array_values() - Возвращает все значения массива.array_walk() - Применяет пользовательскую функцию к каждому элементу массива.array_walk_recursive() - Рекурсивно применяет пользовательскую функцию к каждому элементу массива.asort() - Сортирует ассоциативный массив по значению в возрастающем порядке.arsort() - Сортирует ассоциативный массив по значению в обратном или убывающем порядке.compact() - Создает массив, содержащий переменные и их значения.count() - Подсчитывает все элементы в массиве.current() - Возвращает текущий элемент в массив.each() - Возвращает текущую пару ключ и значение из массива и перемещает курсор массива.end() - Устанавливает внутренний указатель массива на его последний элемент.extract() - Импортирует переменные в текущую таблицу символов из массива.in_array() - Проверяет, существует ли значение в массиве.key_exists() - Проверяет, существует ли указанный ключ в массиве. Псевдоним array_key_exists().key() - Получает ключ из массива.ksort() - Сортирует ассоциативный массив по ключу в порядке возрастания.krsort() - Сортирует ассоциативный массив по ключу в обратном или убывающем порядке.list() - Назначает переменные, как если бы они были массивом.natcasesort() - Сортируем массив с использованием алгоритма «естественного порядка» без учета регистра.natsort() - Сортируем массив с использованием алгоритма «естественного порядка».next() - Перемещает внутренний указатель массива на следующий.pos() - Возвращает текущий элемент в массив. Псевдоним current().prev() - Перемещает внутренний указатель массива на предыдущий.range() - Создает массив, содержащий диапазон элементов.reset() - Устанавливает внутренний указатель массива на его первый элемент.rsort() - Сортирует массив в обратном или убывающем порядке.shuffle() - Перемешивает массив.sizeof() - Подсчитывает все элементы в массиве. Псевдоним count().sort() - Сортирует массив в порядке возрастания.uasort() - Сортирует массив с использованием пользовательской функции сравнения и поддержки ассоциацивного индекса.uksort() - Сортировка массива по ключам с помощью пользовательской функции сравнения.usort() - Сортировка массива по значениям с помощью пользовательской функции сравнения.Следующие функции для работы с файловой системой являются частью ядра PHP, поэтому вы можете использовать эти функции в своих скриптах без дополнительной установки.
basename() - Возвращает компонент имени файла пути.chgrp() - Изменяет файловую группу.chmod() - Изменяет режим файла.chown() - Меняет владельца файла.clearstatcache() - Очищает кеш состояния файла.copy() - Копирует файл.delete() - Смотрите unlink() или unset().dirname() - Возвращает путь к родительскому каталогу.disk_free_space() - Возвращает доступное пространство в файловой системе или разделе диска.disk_total_space() - Возвращает общий размер файловой системы или раздела диска.diskfreespace() - Возвращает доступное пространство в файловой системе или разделе диска. Псевдоним disk_free_space().fclose() - Закрывает указатель открытого файла.feof() - Тесты на конец файла для указателя файла.fflush() - Сбрасывает буферизованный вывод в файл.fgetc() - Возвращает символ из указателя файла.fgetcsv() - Получает строку из указателя файла и парсинг для полей CSV.fgets() - Читает определенное количество байтов из файла.fgetss() - Читает определенное количество байтов из файла и удаляет HTML-теги и PHP-код.file() - Читает весь файл в массив.file_exists() - Проверяет, существует ли файл или каталог.file_get_contents() - Читает весь файл в строку.file_put_contents() - Записаывает строку в файл.fileatime() - Возвращает время последнего доступа к файлу.filectime() - Возвращает время последнего изменения файла.filegroup() - Возвращает идентификатор группы файла.fileinode() - Возвращает номер inode файла.filemtime() - Возвращает время последней модификации файла.fileowner() - Возвращает идентификатор пользователя владельца файла.fileperms() - Возвращает разрешения для файла.filesize() - Возвращает размер файла.filetype() - Returns the file type.flock() - Блокирует или освобождает файл.fnmatch() - Сопоставляет имя файла или строку с указанным шаблоном.fopen() - Открывает файл или URL.fpassthru() - Выводит все оставшиеся данные в указатель файла.fputcsv() - Форматирует строку как CSV и записать в указатель файла.fputs() - Псевдоним fwrite().fread() - Читает определенное количество байтов из файла.fscanf() - Анализирует ввод из файла в соответствии с указанным форматом.fseek() - Ищет указатель файла.fstat() - Возвращает информацию о файле, используя указатель открытого файла.ftell() - Возвращает текущую позицию указателя чтения / записи файла.ftruncate() - Обрезает файл до заданной длины.fwrite() - Записывает содержимое строки в указатель файла.glob() - Возвращает массив имен файлов / каталогов, соответствующих указанному шаблону.is_dir() - Проверяет, является ли файл каталогом.is_executable() - Проверяет, является ли файл исполняемым.is_file() - Проверяет, является ли файл обычным файлом.is_link() - Проверяет, является ли имя файла символической ссылкой.is_readable() - Проверяет, существует ли файл и доступен ли для чтения.is_uploaded_file() - Проверяет, был ли файл загружен через HTTP POST.is_writable() - Проверяет, доступно ли для записи имя файла.is_writeable() - Псевдоним is_writable().lchgrp() - Изменяет групповое владение символической ссылкой.lchown() - Изменяет право собственности пользователя на символическую ссылку.link() - Создает жесткую ссылку.linkinfo() - Возвращает информацию о ссылке.lstat() - Возвращает информацию о файле или символической ссылке.mkdir() - Создает каталог.move_uploaded_file() - Перемещает загруженный файл в новое место.parse_ini_file() - Разбирает файл конфигурации.parse_ini_string() - Разбирает строку конфигурации.pathinfo() - Возвращает информацию о пути к файлу.pclose() - Закрывает указатель файла процесса.popen() - Открывает указатель файла процесса.readfile() - Читает файл и записывает в буфер вывода.readlink() - Возвращает цель символьной ссылки.realpath() - Возвращает канонизированный абсолютный путь.realpath_cache_get() - Возвращает записи кэша realpath.realpath_cache_size() - Возвращает размер кеша realpath.rename() - Переименовывает файл или каталог.rewind() - Перематывает назад позиции указателя файла.rmdir() - Удаляет пустой каталог.set_file_buffer() - Устанавливает размер буфера файла.stat() - Возвращает информацию о файле.symlink() - Создает символическую ссылку.tempnam() - Создает временный файл с уникальным именем файла.tmpfile() - Создает уникальный временный файл.touch() - Устанавливает время доступа и изменения файла.umask() - Изменяет текущую маску.unlink() - Удаляет файл.Следующие ниже функции для работы с датами и временем являются частью ядра PHP, поэтому вы можете использовать эти функции в своих скриптах без дополнительной установки.
checkdate() - Проверяет дату по григорианскому календарю.date_add() - Добавляет к дате количество дней, месяцев, лет, часов, минут и секунд.date_create_from_format() - Возвращает новый объект DateTime, отформатированный в соответствии с указанным форматом.date_create() - Возвращает новый объект DateTime.date_date_set() - Устанавливает новую дату.date_default_timezone_get() - Возвращает часовой пояс по умолчанию, используемый всеми функциями даты и времени в скрипте.date_default_timezone_set() - Устанавливает часовой пояс по умолчанию, используемый всеми функциями даты / времени в скрипте.date_diff() - Возвращает разницу между двумя датами.date_format() - Возвращает дату, отформатированную в соответствии с указанным форматом.date_get_last_errors() - Возвращает предупреждения и ошибки, обнаруженные при разборе строки даты / времени.date_interval_create_from_date_string() - Устанавливает DateInterval из относительных частей строки.date_interval_format() - Форматирует интервал.date_isodate_set() - Устанавливает дату в соответствии со стандартом ISO 8601.date_modify() - Изменяет отметку времени.date_offset_get() - Возвращает смещение часового пояса.date_parse_from_format() - Возвращает ассоциативный массив с подробной информацией о заданной дате, отформатированной в соответствии с указанным форматом.date_parse() - Возвращает ассоциативный массив с подробной информацией об указанной дате.date_sub() - Вычитает количество дней, месяцев, лет, часов, минут и секунд из даты.date_sun_info() - Возвращает массив с информацией о закате / восходе и начале / конце сумерек для указанного дня и местоположения.date_sunrise() - Возвращает время восхода солнца для заданного дня и местоположения.date_sunset() - Возвращает время заката для заданного дня и местоположения.date_time_set() - Устанавливает время.date_timestamp_get() - Возвращает временную метку Unix, представляющую дату.date_timestamp_set() - Устанавливает дату и время на основе отметки времени Unix.date_timezone_get() - Возвращает часовой пояс относительно заданного DateTime.date_timezone_set() - Устанавливает часовой пояс для объекта DateTime.date() - Форматирует местную дату и время.getdate() - Возвращает дату / время метки времени или текущую местную дату / время.gettimeofday() - Возвращает текущее время.gmdate() - Форматирует дату и время GMT / UTC.gmmktime() - Получает временную метку Unix для даты по Гринвичу.gmstrftime() - Форматирует дату и время GMT / UTC в соответствии с локальными настройками.idate() - Форматирует местное время / дату как целое число.localtime() - Возвращает местное время.microtime() - Возвращает текущую временную метку Unix с микросекундами.mktime() - Возвращает временную метку Unix для даты.strftime() - Форматирует местное время / дату в соответствии с настройками локали.strptime() - Анализирует время / дату, созданную с помощью strftime().strtotime() - Преобразует текстовое datetime на английском языке в метку времени Unix.time() - Возвращает текущее время как отметку времени Unix.timezone_abbreviations_list() - Возвращает ассоциативный массив, содержащий dst, смещение и имя часового пояса.timezone_identifiers_list() - Возвращает индексированный массив, содержащий все определенные идентификаторы часовых поясов.timezone_location_get() - Возвращает информацию о местоположении для указанного часового пояса.timezone_name_from_abbr() - Возвращает название часового пояса по сокращению.timezone_name_get() - Возвращает название часового пояса.timezone_offset_get() - Возвращает смещение часового пояса от GMT.timezone_open() - Создает новый объект DateTimeZone.timezone_transitions_get() - Возвращает все переходы для часового пояса.timezone_version_get() - Возвращает текущую версию часового timezonedb.Следующие функции работы с календарем являются частью ядра PHP, поэтому вы можете использовать эти функции в своих скриптах без дополнительной установки.
cal_days_in_month() - Возвращает количество дней в месяце для указанного года и календаря.cal_from_jd() - Преобразует счетчик дней по юлианскому календарю в дату указанного календаря.cal_info() - Возвращает информацию об указанном календаре.cal_to_jd() - Преобразует дату в указанном календаре в число дней по юлианскому календарю.easter_date() - Возвращает отметку времени Unix для полуночи Пасхи данного года.easter_days() - Возвращает количество дней после 21 марта, на которое выпадает Пасха в данном году.frenchtojd() - Преобразует дату из французского республиканского календаря в число дней по юлианскому календарю.gregoriantojd() - Преобразует дату по григорианскому календарю в число дней по юлианскому календарю.jddayofweek() - Возвращает день недели.jdmonthname() - Возвращает название месяца.jdtofrench() - Преобразует количество дней по юлианскому календарю во французскую республиканскую дату.jdtogregorian() - Преобразует счетчик дней по юлианскому календарю в дату по григорианскому календарю.jdtojewish() - Преобразует количество дней по юлианскому календарю в дату по еврейскому календарю.jdtojulian() - Преобразует количество дней по юлианскому календарю в дату по юлианскому календарю.jdtounix() - Преобразование юлианских дней в метку времени Unix.jewishtojd() - Преобразует дату в еврейском календаре в число юлианских дней.juliantojd() - Преобразует дату по юлианскому календарю в число дней по юлианскому календарю.unixtojd() - Преобразование метки времени Unix в юлианский день.Начиная с PHP 5.2.0, функции фильтрации включены по умолчанию. Вы можете использовать их прямо в своем коде без дополнительной установки.
filter_has_var() - Проверяет, существует ли переменная указанного типа.filter_id() - Возвращает идентификационный номер указанного фильтра.filter_input() - Получает конкретную внешнюю переменную по имени и при желании фильтрует ее.filter_input_array() - Получает несколько внешних переменных и при желании фильтрует их.filter_list() - Возвращает массив всех поддерживаемых фильтров.filter_var_array() - Получает несколько переменных и при желании фильтрует их.filter_var() - Фильтрует переменную с помощью указанного фильтра.Обычно, когда движок PHP сталкивается с проблемой, препятствующей правильной работе скрипта, он генерирует сообщение об ошибке. Существует шестнадцать различных уровней ошибок, и каждый уровень представлен целым числом и связанной с ним константой. Вот список уровней ошибок:
| Название | Значение | Описание |
|---|---|---|
| E_ERROR | 1 | Неустранимая ошибка времени выполнения от которой невозможно избавиться. Выполнение скрипта немедленно прекращается |
| E_WARNING | 2 | Предупреждение во время выполнения. Она несущественна, и большинство ошибок попадают в эту категорию. Выполнение скрипта не останавливается |
| E_PARSE | 4 | Ошибка синтаксического анализа времени компиляции. Ошибки синтаксического анализа должен генерировать только анализатор |
| E_NOTICE | 8 | Уведомление во время выполнения. Указывает, что скрипт обнаружил что-то, что могло быть ошибкой, хотя такая ситуация также может возникнуть при обычном запуске скрипта |
| E_CORE_ERROR | 16 | Неустранимая ошибка, возникающая при первоначальном запуске движка PHP. Это похоже на E_ERROR, за исключением того, что она генерируется ядром PHP |
| E_CORE_WARNING | 32 | Не критическая ошибка, возникающая при первоначальном запуске движка PHP. Это похоже на E_WARNING, за исключением того, что оно генерируется ядром PHP |
| E_COMPILE_ERROR | 64 | Неустранимая ошибка, возникающая при компиляции скрипта. Это похоже на E_ERROR, за исключением того, что он генерируется Zend Scripting Engine |
| E_COMPILE_WARNING | 128 | Во время компиляции скрипта произошла нефатальная ошибка. Это похоже на E_WARNING, за исключением того, что оно генерируется Zend Scripting Engine |
| E_USER_ERROR | 256 | Сообщение о фатальной пользовательской ошибке. Она похожа на E_ERROR, за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error() |
| E_USER_WARNING | 512 | Предупреждающее сообщение, созданное пользователем без фатального исхода. Она похожа на E_WARNING, за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error() |
| E_USER_NOTICE | 1024 | Сообщение с уведомлением, созданное пользователем. Она похожа на E_NOTICE за исключением того, что она генерируется PHP-скриптом с использованием функции trigger_error() |
| E_STRICT | 2048 | Не совсем ошибка, но срабатывает всякий раз, когда PHP встречает код, который может привести к проблемам или несовместимости пересылки |
| E_RECOVERABLE_ERROR | 4096 | Устранимая фатальная ошибка. Если ошибка не обнаружена пользовательским мастером ошибок (см. set_error_handler()), приложение прерывается, поскольку это была ошибка E_ERROR |
| E_ALL | 8191 | Все ошибки и предупреждения, кроме E_STRICT до PHP 5.4.0 |
| E_USER_DEPRECATED | 16384 | Предупреждающее сообщение, созданное пользователем. Это похоже на E_DEPRECATED, за исключением того, что онf генерируется кодом PHP с использованием функции trigger_error(), а не движка PHP |
| E_ALL | 32767 | Все ошибки и предупреждения, кроме уровня E_STRICT до PHP 5.4.0 |