5. Переменные и типы данных – Курс PHP

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

Давайте начнем с переменных, которые являются синтаксическими конструкциями для хранения значений в оперативной памяти компьютера. В программировании переменные используются для создания, изменения и чтения значений. Переменные могут содержать различные типы данных, такие как числа, строки и логические значения. В зависимости от типа данных применяются разные операторы и функции. Каждая переменная имеет тип, что позволяет интерпретатору понимать, какие операции можно выполнять с этой переменной. Например, переменные с типом “string” содержат строки текста, а переменные с типом “integer” хранят целые числа.

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

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

Переменные

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

Давайте создадим программу, которая выводит базовую цену билета в кинотеатре – 3000, а также цену с дополнительной наценкой в 500 за “премиум” место.

<?php
$basePrice = 3000;
$premiumPrice = $basePrice + 500;
echo "Цена билета: $basePrice<br />";
echo "Цена билета на премиум-место: $premiumPrice<br />";
?>

Программа объявляет две переменные:

• $basePrice для хранения базовой цены билета,
• $premiumPrice для хранения цены билета с наценкой.

Значение $premiumPrice вычисляется путем добавления 500 к значению $basePrice. Это значение сохраняется и потом выводится с помощью оператора echo в конце программы.

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

По этому примеру, в переменной $basePrice хранится число 3000, а в переменной $premiumPrice – число 3500. Важно отметить, что значение переменной $premiumPrice 3500 получается путем вычисления выражения $basePrice + 500. Это значение вычисляется один раз и затем используется для вывода в конце программы, не повторяя вычисление.

Имена переменных в PHP начинаются со знака доллара ($), за которым следует любое количество буквенно-цифровых символов и символов подчеркивания. Однако первый символ не может быть цифрой. Важно помнить, что имена переменных чувствительны к регистру – например, $myVariable отличается от $MyVariable или $MYVARIABLE.

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

Ключевая особенность PHP заключается в использовании символа доллара перед именами переменных в отличие от других языков программирования. Этот символ позволяет избежать конфликта имен переменных с ключевыми словами языка. Например, имена переменных $echo или $foreach не конфликтуют с соответствующими конструкциями echo и foreach, что обеспечивает более гибкую и надежную работу программы.

В PHP существуют также предопределенные переменные, которые не требуется объявлять самостоятельно – они создаются автоматически. Некоторые из них имеют специальный синтаксис, который будет подробно рассмотрен в следующих уроках. Попытка определить переменную с именем $this, которая используется для ссылки на текущий объект, приводит к ошибке, так как это ключевое слово специально зарезервировано в языке.

Переменные обладают свойством изменяемости – значение переменной может быть изменено в любой момент. Например, в листинге 5.2 значение переменной $premiumPrice изменено на строку “неизвестно”.

<?php
$basePrice = 3000;
$premiumPrice = $basePrice + 500;
$premiumPrice = "неизвестно";
echo $premiumPrice; // выводит "неизвестно"
?>

Таким образом, понятие переменных – это ключевая составляющая программирования, позволяющая сохранять и манипулировать данными внутри программы.

Типы переменных

Типы данных играют важную роль в программировании. Они определяют свойства и синтаксические особенности значений переменных, что в свою очередь определяет, как эти переменные будут вести себя в программе. Возможно объявление нескольких переменных одного типа. Создание новых базовых типов данных недоступно – их определение заложено в сам интерпретатор языка. Однако мы можем создавать собственные классы, которые будут вести себя подобно встроенным типам.

Переменная, содержащая целое число, имеет тип данных “integer” (целое число), а переменная, содержащая строку, имеет тип “string” (строка). Для чего это важно? Тип данных переменной позволяет интерпретатору контролировать допустимые операции с переменными. Например, можно складывать числа между собой, но нельзя складывать коллекцию (например, строку) с числом.

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

Пример сложения переменных представлен в листинге 5.3 Сначала происходит сложение двух переменных типа “integer”: $first и $second. Затем демонстрируется конкатенация (объединение) двух переменных типа “string”: $greeting и $subject.

Первоначально для объединения строк используется оператор точки, который допустим только для строковых значений. PHP успешно выполняет эту операцию. Затем происходит попытка использовать оператор “+” для объединения строк, который для строк запрещен. Это приводит к ошибке – “Fatal error: Uncaught TypeError: Unsupported operand types: string + string”. Таким образом, недопустимые операции вызывают ошибки типизации, которые помогают обнаружить потенциальные ошибки программиста.

$first = 1;
$second = 2;
echo $first + $second; // Вывод: 3

$greeting = 'Hello, ';
$subject = ' PHP!';
echo $greeting . $subject; // Вывод: Hello, PHP!
// Следующая строка вызовет ошибку
// Fatal error: Uncaught TypeError: Unsupported operand types: string + string
echo $greeting + $subject;

В приведенном коде типы переменных integer и string не указываются явно. Они определяются природой значений, которые они хранят. Интересно, что переменная, объявленная как строка, может использоваться не только для строковых операций, но и для арифметических операций, и даже как логическая переменная. Более того, в PHP переменной типа string также можно присвоить объект в конечном итоге. Все это позволяет разработчику практически не задумываться о типах данных в большинстве случаев.

Именно из-за такой гибкости и свободы в использовании переменных язык PHP относится к категории слабо типизированных языков. В большинстве ситуаций переменные в PHP не требуют строгого указания типа при объявлении. Тип переменной может меняться неявно в ходе выполнения программы без специальных преобразований.

Интересные особенности

• PHP позволяет выполнять операции между различными типами данных. Например, в примере выше строковое значение и целое число складываются, что в других языках программирования может вызвать ошибку.
• Массивы и объекты позволяют хранить множество значений в одной переменной. Массивы индексируются числовыми или строковыми ключами, а объекты объединяют данные и методы обработки.
• Ресурсы представляют собой дескрипторы, позволяющие оперировать внешними ресурсами, такими как файлы и базы данных.
• PHP 8.0 добавил новый тип данных mixed, который может хранить значения любых типов.
• Комбинированные типы (union types) в PHP 8.0 позволяют переменной иметь одновременно два или более типа.
• PHP 8.1 ввел поддержку пересечений типов (intersection types), что усиливает контроль над переменными, особенно в объектно-ориентированном программировании.

Эти особенности делают PHP гибким языком программирования, позволяющим разработчикам эффективно работать с разнообразными данными и операциями.

Целые числа: integer

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

В 32-битной версии PHP целое число может находиться в диапазоне от -2 147 483 648 до 2 147 483 647. В то время как в 64-битной версии, которую вы, вероятно, будете использовать, они могут быть от -9 223 372 036 854 775 807 до 9 223 372 036 854 775 807.

Обработка переполнений

Важно отметить, что в отличие от некоторых других языков программирования, в PHP нет переполнений. Переполнение – это ошибка, возникающая, когда значение превышает максимально допустимое для данного типа данных. В PHP, если целое число не умещается в тип integer, оно будет автоматически конвертировано в тип float (с плавающей точкой), который может обработать больший диапазон значений.

Использование префиксов для различных систем счисления

Чтобы более удобно работать с большими числами, в PHP можно использовать различные системы счисления, такие как двоичная, восьмеричная и шестнадцатеричная.

• Двоичные числа обозначаются префиксом 0b, за которым идут только цифры 0 и 1. Пример: 0b1010101 (85 в десятичной системе).
• Восьмеричные числа начинаются с префикса 0. Однако, чтобы избежать путаницы с обычными десятичными числами, начиная с PHP 8.1, вводится префикс 0o или 0O, например, 0o755 (493 в десятичной системе).
• Шестнадцатеричные числа начинаются с префикса 0x или 0X. Они могут содержать цифры от 0 до 9 и буквы от a до f (регистр не имеет значения). Пример: 0xFFCC00 (16763904 в десятичной системе).

Форматирование чисел для удобства чтения

Для удобства чтения больших чисел, PHP позволяет использовать символ подчеркивания для разделения разрядов. Это не влияет на значение числа, но значительно улучшает его восприятие. Например:

echo 2_000_000 + 1_900_200; // Вывод: 3900200

Такие методы форматирования упрощают работу с большими числами и делают код более читаемым.

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

Вещественные числа: double

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

• Обычная форма: Пример – 346.1256.
• Экспоненциальная форма: Позволяет записать число в виде произведения мантиссы (например, 3.461256) и соответствующей степени числа 10 (например, 2). В PHP, вместо символа “×” используется “е”, и число 0.00012 может быть записано как 1.2e-4.

Таким образом, обычная запись 346.1256 эквивалентна экспоненциальной записи 3.461256e+2.

Префиксы для чисел с плавающей точкой

• Чтобы обозначить число в экспоненциальной форме, используется символ “е” с последующим указанием степени. Например:

$x = 0.00012;
$y = 1.2e-4; // эквивалентно $x

• Также, важно учесть, что в компьютерных программах невозможно использовать символы верхнего регистра, поэтому вместо “× 10” записывается “е”.

Разные модели представления чисел с плавающей точкой

Ранее в PHP можно было явно указывать тип числа с плавающей точкой (Single, Extended, Double), определяющий количество байтов для представления числа и его диапазон значений. В современных версиях PHP используется модель Double, где число с плавающей точкой представляется 8 байтами, обеспечивая диапазон значений от примерно 2.23 × 10^-308 до 1.79 × 10^308.

Потери точности при представлении

При преобразовании десятичных чисел в вещественные с потерями могут возникнуть ошибки округления, так как некоторые дроби невозможно представить конечным числом цифр. Это может привести к накоплению ошибок при арифметических операциях. Например, число 1.3 может представляться как 1.29999999…

Особые значения

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

echo 1.8e307; // 1.8E+307
echo 1.8e308; // INF
echo -1.8e308 // -INF
echo sqrt(-1); // NAN

Понимание особенностей чисел с плавающей точкой в PHP важно для избегания ошибок и непредвиденного поведения в программе.

Логический тип: boolean

Логическая переменная (boolean) может иметь только два значения: true (истина) или false (ложь). В PHP логические переменные широко используются для выполнения операций сравнения, управления ходом программы (например, в условных операторах) и циклами.

Интерпретация значений в логическом контексте:

• Любое ненулевое число, непустая строка и ключевое слово true считаются истиной.
• Значения 0, пустая строка и ключевое слово false считаются ложью.

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

Пример объявления логической переменной:

$bool = true;

Использование логических переменных в операциях:

Логические переменные часто используются с операторами сравнения и в условных операторах. Например:

$age = 25;
$isAdult = ($age >= 18); // $isAdult будет true, так как $age >= 18

Отображение логических значений:

При выводе логических значений с помощью функции echo, true отображается как 1, а false не отображается вообще:

echo true;  // Вывод: 1
echo false; // Ничего не выводится

Преобразование логических переменных в числа:

При выполнении арифметических операций, логические переменные могут быть преобразованы в числа. В этом контексте true будет интерпретировано как 1, а false как 0:

$bool = true;
$number = $bool + 5; // $number будет равно 6

$bool = false;
$number = $bool + 10; // $number будет равно 10

Операторы инкремента и декремента:

Интересно, что операторы инкремента (++) и декремента (--) не работают со значениями логических переменных:

$b = true;
echo "b: $b<br>"; // Вывод: b: 1
$b++;
echo "b: $b<br>"; // Вывод: b: 1

Понимание логических переменных в PHP важно для написания эффективных условных выражений и управления ходом программы на основе различных условий.

Строки: string

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

Объявление строк:

Простейший способ объявления строки – это использование кавычек. В PHP поддерживаются следующие типы кавычек:

• Двойные кавычки (") – переменные и специальные символы (например, \n, \t) вставляются в строку.
• Одиночные кавычки (') – переменные и специальные символы не интерпретируются, символ $ отображается как есть.
• Обратные кавычки (“) – значение, заключенное в такие кавычки, рассматривается как системная команда, и результат выполнения команды возвращается.

Примеры объявления строк:

$str1 = "Hello, world!";
$str2 = 'Single quotes do not interpret variables: $str1';
$str3 = `ls -l`; // Результат выполнения команды 'ls -l'

Интерполяция переменных:

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

$name = "Alice";
$message = "Hello, $name!";

Экранирование символов:

Символы, имеющие особое значение (например, $ или \), могут быть экранированы обратным слешем (\) для того, чтобы они были восприняты как обычные символы:

$str = "The variable value is \$value"; // Вывод: The variable value is $value

Специальные символы:

Некоторые символы имеют специальное значение, например:

• \n – перевод строки
• \r – возврат каретки
• \t – символ табуляции

Фигурные скобки:

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

$number = 123;
echo "Value: ${number}456"; // Вывод: Value: 123456

Обратные кавычки:

Заключенные в обратные кавычки строки интерпретируются как системные команды:

$output = `ls -l`;
echo "Directory listing: $output";

Оператор <<<

В PHP существуют специальные синтаксические конструкции для объявления многострочных строк без явного использования кавычек. Эти конструкции называются heredoc и nowdoc.

Heredoc:

Heredoc позволяет объявить многострочную строку с использованием специальной метки. Синтаксис выглядит так:

$string = <<<EOT
This is a heredoc string.
It can span multiple lines.
EOT;

В этом примере EOT – это метка, которая указывается после <<<, и она должна быть одиночным словом. Строка заканчивается встречей этой метки без пробелов или других символов перед ней.

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

Пример использования heredoc:

$name = "Alice";
$description = <<<EOT
User's name: $name
This is a detailed description
EOT;

echo $description;

Nowdoc:

Nowdoc – это похожая на heredoc конструкция, но с одним отличием: в nowdoc переменные и специальные символы не интерполируются. Синтаксис nowdoc выглядит так:

$string = <<<'EOT'
This is a nowdoc string.
Variables are not interpolated: $variable
EOT;

В этом примере EOT – это метка, указанная после <<<', и строка также заканчивается встречей этой метки без пробелов или других символов перед ней.

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

Пример использования nowdoc:

$name = "Alice";
$description = <<<'EOT'
User's name: $name
This is a detailed description
EOT;

echo $description;

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

Устройство строки

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

Строка не просто представляет собой одиночное значение, подобно числам 1 и 2. Она скорее представляет собой последовательность символов. При этом изменение порядка двух букв может создать совершенно иную строку.

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

• Определение количества символов в строке, чтобы определить, помещается ли она в данное место текста.
• Замена одной подстроки другой, например, замена “Иван” на “Петр” в строке “Иванов Иван”.
• Определение вхождения подстроки в текст и, если она встречается, подсчет количества таких вхождений.

Решение этих задач требует умения манипулировать индивидуальными символами внутри строки. В PHP, например, каждому символу строки можно обратиться с помощью квадратных скобок и указав индекс символа внутри строки.

$str = 'Hello, world!';
echo $str[0]; // H

Если индекс изменить на 1, то будет получен второй символ “e”, и так далее. Обращение к несуществующему символу, например, $str[13], вызовет предупреждение.

$str = 'Hello, world!';
echo $str[13]; // PHP Warning: Uninitialized string offset 13

Используя операции с отдельными символами, можно из имеющегося слова составить другое:

$str = 'Hello, world!';
echo "$str[2]$str[4]$str[9]$str[11]";  // lord

Таким образом, путем комбинирования отдельных букв из строки “Hello, world!” получается слово “lord”.

Массивы: array

Массив, включая ассоциативный массив, представляет собой совокупность нескольких элементов, каждый из которых представляет пару “ключ” => “значение”. Символ “=>” используется для определения соответствия между определенным ключом и соответствующим значением.

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

Пример создания и использования ассоциативного массива:

// Создание массива с ключами 0, "surname" и "name"
$arr = [
    0 => "Нулевой элемент",
    "surname" => "Гейтс",
    "name" => "Билл",
];

echo $arr["surname"]; // Выводит "Гейтс"
$arr[1] = "Первый элемент"; // Создает элемент с ключом 1 и присваивает ему значение
$arr["name"] = "Вильям"; // Присваивает новое значение существующему элементу "name"

В данном примере массив $arr создается с использованием квадратных скобок. Ассоциативные массивы позволяют использовать более понятные ключи вместо индексов и обеспечивают более гибкий доступ к данным. Более подробное изучение массивов будет проведено в следующих уроках.

Объект: object

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

Внутренняя структура объекта напоминает ассоциативный массив, за исключением того, что доступ к отдельным свойствам (элементам) и методам (функциям) объекта осуществляется через оператор “->”, а не с помощью квадратных скобок. Подробное изучение объектов будет проведено в следующих уроках.

Ресурс: resource

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

К примеру, переменная, содержащая дескриптор открытого файла, может быть использована для указания PHP, с каким файлом нужно провести определенную операцию, например, чтение или запись. Еще одним примером может служить функция imageCreate() библиотеки GD, которая создает в памяти новое “пустое” изображение заданного размера и возвращает его идентификатор. Этот идентификатор позволяет вам работать с изображением, добавляя на него элементы, такие как линии или текст, и сохранять полученный результат в файл формата PNG или JPEG.

Следует отметить, что с появлением PHP версии 8.0, ресурсы активно заменяются встроенными классами. В будущем эта тенденция может привести к тому, что тип данных “ресурс” будет полностью заменен на классы.

Специальный тип null

Специальный тип данных null предназначен для обозначения неинициализированной переменной. Для присвоения переменной значения типа null используется константа null.

Пример инициализации переменной типа null:

$var = null;
echo $var;

Следует отметить, что при инициализации переменной с помощью константы null и последующем обращении к этой переменной в выражениях не вызывает появление предупреждения “PHP Warning: Undefined variable”.

Это объясняется особенностью работы интерпретатора PHP: любое выражение, в котором переменная используется слева от оператора =, приводит к регистрации этой переменной во внутренней таблице имен. В случае, когда переменная получает значение null, выделение памяти под это значение не происходит, однако имя переменной регистрируется. При любом обращении к переменным в PHP происходит проверка наличия переменной в таблице имен. Если переменная не обнаружена, будет выдано предупреждение “PHP Warning: Undefined variable”.

echo $var; // PHP Warning: Undefined variable $var

Действия с переменными

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

Присвоение значения

Вы можете присвоить переменной значение другой переменной, функции, или константе. При этом, если переменная встречается в программе впервые, она инициализируется. За исключением объектов, которые инициализируются с помощью ключевого слова “new”.

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

Уничтожение

Переменная может быть удалена с помощью функции unset(). Это приводит к удалению переменной из внутренних таблиц интерпретатора. В результате переменная снова становится невидимой для программы, как если бы она не была инициализирована.

Пример уничтожения переменной:

$var = "Hello there!";
// ...
unset($var);
// ...
// Это вызовет предупреждение "Undefined variable"
echo $var;

Функция unset() чаще применяется для удаления отдельных элементов массива, освобождая память. Например:

unset($programs["angel"]);

Проверка существования

Для проверки существования переменной используется функция isset(). Она возвращает true, если переменная существует, и false, если переменной нет. Пример:

$str = "";
if (isset($str)) {
    echo 'Переменная $str существует<br>';
}

Если переменная в данный момент не существует (то есть она не была нигде ранее инициализирована, или была удалена с помощью unset()), то isset() вернет false.

Важно помнить, что попытка использовать неинициализированную переменную может вызвать предупреждение со стороны интерпретатора. Для этого можно использовать isset() или empty() для проверки существования и пустоты переменной.

Пример использования empty() для проверки на пустую строку:

$str = "";
if (empty($str)) {
    echo 'Переменная $str пустая<br>';
}

Конструкция empty() вернет true, если переменная равна пустой строке "", нулю, символу нуля в строке "0", null, false, пустому массиву или неинициализированной переменной. В остальных случаях она вернет false.

Определение типа переменной

Для определения типа переменных в PHP существует несколько стандартных функций. Они могут быть полезны при проверке типа переменной перед выполнением определенных операций или в условных операторах. Вот некоторые из этих функций:

$isInt = is_int($a);        // Возвращает true, если $a - целое число
$isDouble = is_double($a);  // Возвращает true, если $a - действительное число
$isInfinite = is_infinite($a); // Возвращает true, если $a - бесконечное действительное число (INF)
$isNan = is_nan($a);        // Возвращает true, если $a - недопустимое числовое значение (NAN)
$isString = is_string($a);  // Возвращает true, если $a - строка
$isNumeric = is_numeric($a); // Возвращает true, если $a - числовое значение (целое, действительное или строка)
$isBool = is_bool($a);      // Возвращает true, если $a имеет значение true или false
$isScalar = is_scalar($a);  // Возвращает true, если $a - простой (скалярный) тип
$isNull = is_null($a);      // Возвращает true, если $a хранит значение null
$isArray = is_array($a);    // Возвращает true, если $a - массив
$isObject = is_object($a);  // Возвращает true, если $a содержит ссылку на объект
$type = gettype($a);        // Возвращает строку с названием типа переменной

Пример использования:

$value = "Hello";
if (is_string($value)) {
    echo 'Переменная $value является строкой<br>';
}

Эти функции помогают вам проверить тип переменной перед выполнением определенных действий с ней. Например, вы можете использовать is_numeric() для проверки, можно ли выполнить арифметические операции с переменной как с числом, независимо от того, в каком формате она представлена.

Примечание: функции is_int() и is_double() также могут использоваться с псевдонимами is_integer() и is_float(), соответственно.

Некоторые условные обозначения

Понятие типов данных и их аннотация стали более распространенными в современном программировании, и это позволяет программистам легче понимать, какие типы данных ожидаются и какие значения возвращаются из функций. В PHP с версии 7.0 и выше, а также в более современных версиях, введены подсказки типов (type hints) и аннотации типов, которые могут быть использованы для объявления ожидаемых типов аргументов функций и возвращаемых значений.

Пример использования подсказок типов и аннотаций типов:

function getArea(float $radius): float {
    return 3.14 * $radius * $radius;
}

$radius = 5.0;
$area = getArea($radius);
echo "Площадь круга: $area";

В приведенном примере функция getArea() ожидает аргумент типа float (действительное число) и возвращает значение типа float. Такие подсказки типов помогают легче читать код и предотвращать ошибки типов данных.

Однако стоит отметить, что использование аннотаций типов не является обязательным в PHP, и они могут быть применены по желанию программиста. В более старых версиях PHP (до 7.0) аннотации типов не поддерживаются, и вам придется полагаться на проверки типов вручную.

Неявное приведение типа

В языках программирования, строго ограничивающих типы данных (сильно типизированных), обычно требуется явно указать тип переменной при её объявлении. Попытка использовать переменную неправильного типа в выражении приводит к ошибке.

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

Пример, если строка содержит число и используется в арифметическом выражении, она автоматически приводится к числовому типу (см. код ниже). В PHP 8.0 и новее начинается постепенное усиление контроля над типизацией.

$str = '12.6';
$number = 3 + $str;
echo $number; // 15.6

В предыдущих версиях PHP, при использовании строк в арифметических операциях, PHP пытался выделить числовую информацию из строки, и если это не удавалось, строка преобразовывалась в ноль. Однако, начиная с PHP 8.0, такие операции вызывают предупреждение “A non-numeric value encountered”.

Есть возможность включить строгую типизацию с помощью конструкции declare(strict_types=1) в PHP-скрипте, что делает управление типами более строгим. Однако, PHP все равно остается слабо типизированным языком, и большинство преобразований базовых типов данных происходит неявно.

Пример, число автоматически преобразуется в строку, когда ожидается строковая переменная:

$price = 3500;
echo "Цена билета " . $price; // Цена билета 3500

Когда ожидается логический тип, числа равные нулю, пустые строки, строки с “0”, пустые массивы и объекты, а также значение null, автоматически преобразуются в false. Остальные переменные рассматриваются как true:

$float = 0.0;
if ($float) {
    echo 'Переменная $float рассматривается как true';
} else {
    echo 'Переменная $float рассматривается как false';
}

При преобразовании логического типа в строку, true преобразуется в пустую строку, а false в “false”. Преобразование логического типа в число заменяет true на 1, а false на 0. Это означает, что true всегда выводится как единица, а false – как пустая строка:

echo true; // "1"
echo false; // ""

Явное приведение типа

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

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

// Объявляем вещественную переменную
$double = 4.863;
// Преобразуем переменную $double к целому типу
$number = (int) $double;
echo $number; // 4

В таблице 5.2 приведены возможные варианты использования оператора круглых скобок для явного приведения типов.

Обычно явное приведение типов необходимо редко, но иногда оно может быть полезным. Например, в листинге 5.39 демонстрируется проверка числа на четность: число делится на 2 два раза, приводя его сначала к целому, а затем к вещественному типу. Полученные результаты вычитаются. Если число четное, результат будет 0, что автоматически интерпретируется как false. Если число нечетное, результат будет 0.5, что соответствует true.

$number = 15;
$flag = (float) ($number / 2) - (int) ($number / 2);

if ($flag) {
    echo "Число $number нечетное";
} else {
    echo "Число $number четное";
}

Кроме оператора круглых скобок, PHP предоставляет специальные функции для явного преобразования типов, включая функцию settype():

settype(mixed $var, string $type): bool

Эта функция позволяет преобразовать переменную $var в тип, указанный в параметре $type, который может принимать значения, такие как “boolean”, “integer”, “double”, “string”, “array”, “object” и “null”. Функция возвращает true при успешном преобразовании и false в противном случае.

Вместо settype() можно использовать специализированные функции, такие как intval(), floatval(), doubleval() и strval(), которые более удобны в использовании.

Пример использования intval() приведен в листинге 5.41:

echo intval(42); // 42
echo intval(4.2); // 4
echo intval('42'); // 42
echo intval('+42'); //42
echo intval('-42'); // -42
echo intval(042); // 34
echo intval('042'); // 42
echo intval('1e10'); // 10000000000
echo intval('le10'); // 0
echo intval(0x1A); // 26
echo intval(42000000); // 42000000

Функция intval() принимает аргумент и возвращает целое число. Она также может иметь второй аргумент для указания системы счисления.

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

Ссылочные переменные

В начале этого урока мы определили переменные как именованную область памяти, где имя переменной указывает на какое-то значение в оперативной памяти компьютера. Но что произойдет, если две переменные начнут указывать на одну и ту же область памяти? В таком случае изменение значения одной переменной будет автоматически приводить к изменению значения другой переменной. Связь между переменными, позволяющая им указывать на одну и ту же область памяти, называется ссылкой. Ссылки могут быть организованы разными способами, и существуют три разновидности ссылок: жесткие, символические и ссылки на объекты.

Жесткие ссылки

Жесткая ссылка – это просто переменная, которая становится синонимом другой переменной.

Для создания жесткой ссылки используется оператор &. Например:

$a = 10;
$b = &$a;
$b = 0;
// Теперь $b и $a указывают на одну и ту же область памяти
echo "b = $b, a = $a"; // Выводит "b = 0, a = 0"

Такие ссылки могут указывать не только на переменные, но и на элементы массивов:

$arr = [
    'restaurant' => 'Chinese Surprise',
    'motto' => 'Nosce te computerus'
];
$r = &$arr['restaurant'];
$r = "Moonrise";
// Теперь элемент 'restaurant' массива $arr изменился на "Moonrise"
echo $arr['restaurant']; // Выводит "Moonrise"

Однако, если элемента в массиве нет, но создается жесткая ссылка на этот несуществующий элемент, то он создается:

$arr = [
    'fork' => '271 rub. 82 kop.',
    'pan' => '818 rub. 28 kop.'
];
$b = &$arr['spoon']; // Создается элемент 'spoon' в массиве $arr
echo "Element 'spoon': " . $arr['spoon']; // Выводит "Element 'spoon': "
echo "Type of 'spoon' element: " . gettype($arr['spoon']); // Выводит "Type of 'spoon' element: string"

Сборщик мусора

Важно отметить, что оператор unset($r) для жестких ссылок не удаляет объект, на который ссылается ссылка. Он лишь разрывает связь между ссылкой и объектом, но объект будет удален только тогда, когда на него не останется ссылок.

Этот механизм, когда объекты удаляются только после потери последней ссылки на них, называется “сборщиком мусора”.

Символические ссылки

Символическая ссылка представляет собой строковую переменную, которая хранит имя другой переменной. Для доступа к значению переменной, на которую указывает символическая ссылка, используется оператор разыменования $. Например:

$right = "red";
$wrong = "blue";
$color = "right";
echo $$color; // Выводит значение переменной $right ("red")
$$color = "not blue"; // Присваивает переменной $right новое значение

Такие ссылки можно создавать, но они обычно малополезны и могут усложнить код.

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

Ссылки на объекты

В PHP, когда вы копируете объекты или массивы, фактически происходит копирование по ссылке. Рассмотрим пример создания объекта, представленный в листинге 5.46.

class AgentSmith {
    public $mind;
}

$first = new AgentSmith();
$first->mind = 0.123;

$second = $first;
$second->mind = 100;

echo "First mind: ($first->mind), second: ($second->mind)";

В этом примере, оба выводимых значения будут одинаковыми: 100 и 100. Почему так происходит? Это связано с тем, что в PHP переменная хранит не сам объект, а ссылку на него. Если бы вы попробовали вывести переменную $first с помощью echo, вы бы увидели что-то вроде “Object #1”. Это указывает на ссылку на объект с идентификатором 1. То же самое будет и с переменной $second, так как обе переменные ссылаются на один и тот же объект.

Так как переменные хранят только ссылки на объекты, при их присваивании копируются только эти ссылки, а не сами объекты. Вам можно представить это как сдачу в гардероб вашего пальто, получение номерка (ссылки), а затем создание дубликата номерка. У вас будет два номерка, но фактически только одно пальто. Таким образом, создание копии объекта в PHP влечет за собой копирование ссылки, а не создание нового объекта.

Отладочные функции

В PHP переменные могут легко изменять свой тип в процессе выполнения программы. Это может приводить к ситуациям, когда программа ведет себя неожиданно, возникают ошибки или предупреждения.

Если происходит ошибка, выполнение программы прерывается, и интерпретатор не продолжит работу до ее устранения. Предупреждения, в свою очередь, не прерывают выполнение программы, но их неожиданный вывод может нарушать пользовательский опыт, повреждать визуальное представление веб-сайта и раскрывать внутренние детали PHP-приложения. Более того, в будущих версиях PHP предупреждения могут превращаться в ошибки. Если предупреждения не обрабатываются, это может привести к невозможности запуска программы в новых версиях PHP.

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

print_r(mixed $value, bool $return = false): string|bool

Пример использования:

$arr = [
    'a' => 'apple',
    'b' => 'banana',
    'c' => ['x', 'y', 'z']
];

echo "<pre>";
print_r($arr);
echo "</pre>";

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

Когда аргумент $return указан и равен true, функция print_r() не выводит данные в браузер, а возвращает отладочное представление в виде строки.

Схожая с print_r(), функция var_dump() также позволяет выводить информацию о переменной, включая тип и структуру. Ее синтаксис:

var_dump(mixed $value, mixed ...$values): void

Пример использования:

$arr = [1, ["a", "b"]];
echo "<pre>";
var_dump($arr);
echo "</pre>";

Еще одной полезной функцией является var_export(), которая выводит значение переменной так, чтобы оно могло быть использовано как часть PHP-кода. Синтаксис:

var_export(mixed $value, bool $return = false): ?string

Пример использования:

$arr = [
    1,
    "Programs hacking programs. Why?",
    "д'Артаньян"
];
echo "<pre>";
var_export($arr);
echo "</pre>";

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

Резюме

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

Впереди нас ждет детальное изучение функционала PHP, в том числе мощных инструментов для отладки и анализа данных. Мы ознакомились с функциями print_r(), var_dump() и var_export(), которые предоставляют удобные способы вывода содержимого переменных. Эти навыки окажутся очень полезными при разработке и отладке программ.

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

Подписывайтесь на мой телеграмм канал о веб-разработке, чтобы оперативно узнавать о выходе новых уроков и не только https://t.me/SamuraisGoal

Заходите в чат для обсуждений https://t.me/SamuraisGoalChat

Так же буду рад видеть на своем личном ТГ канале, там я делюсь своими достижениями и просто мыслями https://t.me/ZxKillPublic