base05 12

Типы данных

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

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

Общие сведения о типах

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

  • Целочисленные значения представляют собой целые числа без десятичной точки, такие как 495.

  • Числа с плавающей точкой двойной точности — это числа с плавающей точкой наподобие 3.14159 или 49.0, имеющие наибольший возможный формат представления.

  • Логические значения принимают только два возможных значения: TRUE и FALSE.

  • Значение NULL — это специальный тип, который имеет только одно значение: NULL.

  • Строки — это последовательности символов, например 'PHP поддерживает работу со строками'.

  • Массивы представляют собой именованные и индексированные коллекции других значений.

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

  • Ресурсами называют специальные переменные, которые хранят ссылки на ресурсы, внешние по отношению к интерпретатору PHP (такие как соединения с базой данных).

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

Отсутствие объявлений типов переменных

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

Код PHP
$pi = 3.14159;
$str = 'PHP поддерживает работу со строками';

Автоматическое преобразование типов

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

Код PHP
$pi = 3 + 0.14159;

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

Типизация с учетом контекста

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

Код PHP
$sub = substr(12345, 2, 2);
print("\$sub = $sub");

Функция substr предназначена для выделения подстроки из строки символов. В качестве первого параметра эта функция принимает строку символов и возвращает подстроку этой строки, начальная позиция которой и длина определяются следующими двумя входными параметрами функции. Но в данном случае функции substr вместо символьной строки передано целое число 12345. Что при этом происходит? Как оказалось, ошибка не возникает, а в окне браузера появляются следующие выходные данные:

Автоматическая типизация с учетом контекста

Поскольку для функции substr требуется символьная строка, а не целое число, интерпретатор PHP преобразует число 12345 в символьную строку "12345" которая затем поступает на обработку в функцию substr.

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

Простые типы

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

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

Например, в языке C предусмотрены тип short (для относительно небольших целых чисел), тип long (для чисел, которые могут оказаться весьма большими) и тип int (который может быть промежуточным между этими двумя типами, но на практике иногда рассматривается как идентичный либо типу short, либо long). Имеются также разные типы данных с плавающей точкой, которые отличаются по своей точности. Такого рода разнообразие типов имело смысл в то время, когда приходилось часто принимать очень жесткие компромиссные решения, выбирая между требованиями уменьшения объема используемой памяти и сохранения функциональных возможностей. По нашему мнению, проектировщики языка PHP приняли разумное решение по упрощению системы типов, предусмотрев только два числовых типа, соответствующих одному целочисленному типу и одному типу с плавающей точкой языка C (с наибольшими форматами представления).

Целые числа

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

Код PHP
$int_var = 12345;
$another_int = -12345 + 12345;    // Результат будет равен нулю

Форматы чтения

Целые числа фактически могут считываться в трех форматах, которые соответствуют основаниям систем счисления: десятичной (с основанием 10), восьмеричной (с основанием 8) и шестнадцатеричной (с основанием 16). Десятичный формат применяется по умолчанию, восьмеричные целые числа задаются с помощью ведущей цифры 0, а шестнадцатеричные — с помощью префикса 0x. Любой из этих форматов предусматривает возможность применения в качестве префикса знака минуса (-), который позволяет указать, что целое число является отрицательным. Рассмотрим следующий пример:

Код PHP
$integer_10 = 1000; 
$integer_8 = -01000; 
$integer_16 = 0x1000;

print("integer_10: $integer_10<br>");
print("integer_8: $integer_8<br>");
print("integer_16: $integer_16<br>");

Выполнение этого кода приводит к выводу в окне браузера такого текста:

8-ричное, 10-ричное и 16-ричное представление целых чисел в PHP

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

Диапазон представления

Насколько большие (или малые) значения могут принимать целочисленные данные? На этот вопрос трудно дать однозначный ответ, поскольку тип целых чисел PHP соответствует типу long языка C, который, в свою очередь, зависит от размера машинного слова компьютера. Но на большинстве широко используемых платформ наибольшее целое число равно 231 - 1 (или 2 147 483 647), а наименьшее равно - (231 - 1) (или -2 147 483 647).

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

Числа с плавающей точкой двойной точности

Примеры чисел с плавающей точкой двойной точности приведены ниже:

Код PHP
$first_double = 123.456;
$second_double = 0.456;
$even_double = 2.0;

Следует отметить, что присваивание переменной $even_double числового значения без значащих цифр после точки не влечет за собой то, что вместо числа с плавающей точкой присваивается целое число. Целые числа и числа с плавающей точкой двойной точности записываются в память с помощью разных форматов представления, поэтому результатом выполнения следующего примера становится присваивание числа с плавающей точкой, а не целого числа, даже несмотря на то, что это значение выводится как 5:

Код PHP
$five = $even_double +3;

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

Форматы чтения

Типичным форматом чтения для чисел с плавающей точкой двойной точности является формат -X.Y, в котором необязательный символ "-" определяет отрицательное число, а компоненты X и Y представляют собой последовательности цифр от 0 до 9. Если число находится в пределах от -1.0 до 1.0, то часть X может быть исключена; может быть также исключена и часть Y. Ведущие и заключительные нули игнорируются. Все приведенные ниже числа с плавающей точкой являются допустимыми:

Код PHP
$small_positive = 0.12345; 
$small_negative = -.12345; 
$even_double = 2.00000; 
$still_double = 2.;

Кроме того, числа с плавающей точкой двойной точности можно задавать в экспоненциальном формате, добавляя в конце приведенного выше формата с плавающей точкой (который рассматривается в экспоненциальном формате как мантисса) букву "e" и требуемое целочисленное значение степени 10 (показатель степени). Например, обозначение 2.2e-3 в экспоненциальном формате соответствует значению 0.0022.

Логические значения

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

Логические константы

В языке PHP предусмотрена пара констант, специально предназначенных для использования в качестве логических констант. Это — константы TRUE и FALSE, которые могут применяться примерно следующим образом:

Код PHP
if (TRUE)
	print("Этот текст всегда будет печататься<br>"); 
else
	print("Этот текст никогда не будет напечатан<br>");

Интерпретация значений других типов как логических значений

Ниже приведены правила определения истинности любого значения, которое еще не является логическим:

  • Если значение является числовым и точно равно нулю, то рассматривается как ложное, все прочие числовые значения считаются истинными.

  • Если значение является строковым, то рассматривается как ложное, если строка пуста (имеет длину, равную нулю) или представляет собой строку "0", и как истинное в противном случае.

  • Значения NULL всегда являются ложными.

  • Если значение имеет составной тип (представляет собой массив или объект), то рассматривается как ложное, если не содержит других значений, и как истинное в противном случае. Объект считается содержащим значение, если в его состав входит переменная экземпляра, которой было присвоено значение.

  • Действительные ресурсы рассматриваются как истинные (хотя некоторые функции, в случае успешного выполнения возвращающие ресурсы, после неудачного завершения работы возвращают значение FALSE).

Ниже приведены переменные, в именах которых указано истинностное значение (true — истина, false — ложь), принимаемое этими переменными при использовании в логическом контексте:

Код PHP
$true_num = 3 + 0.14159;
$true_str = "Строка true.";
$true_array[49] = "Элемент массива";

$false_array = array(); 
$false_null = NULL; 
$false_num = 999 - 999;
$false_str = ""; // Строка нулевой длины

Безусловно, из первого приведенного выше правила следует, что число с плавающей точкой двойной точности (0.0) преобразуется в ложное логическое значение. Но необходимо учитывать, что выражения с плавающей точкой опасно использовать в качестве логических выражений из-за возможных ошибок округления. Рассмотрим следующий пример:

Код PHP
$floatbool = sqrt(2.0) * sqrt(2.0) - 2.0;    // Должен быть 0, 
                                             // но из-за ошибок округления $floatbool не равно 0

if ($floatbool)
	print("Приведение дробных чисел к логическому значению опасно из-за ошибок округления<br><br>"); 
else
	print("Все работает правильно<br>"); 
	
print("\$floatbool = $floatbool");

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

Ошибки округления дробных чисел в PHP

Значение переменной $floatbool очень близко к 0.0, но отличается от нуля и поэтому, вопреки ожиданиям, является истинным. Для использования в качестве логических значений гораздо безопаснее применять целые числа. Поскольку в арифметических операциях с целыми числами участвуют только целые числа и дробные значения не возникают, то в результате выполнения таких операций не могут появляться ошибки округления.

Значение null

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

Код PHP
$my_var = NULL;

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

Код PHP
$my_var = null;

Так чем же отличаются значения NULL? Значение NULL представляет отсутствие значения (значение NULL можно рассматривать как недостающее или незаданное значение). Переменная, которой присвоено значение NULL, почти неотличима от переменной, которой вообще не было присвоено значение. В частности, переменная, которой присвоено значение NULL, обладает описанными ниже свойствами:

  • В логическом контексте вычисления, проведенные с этой переменной, приводят к получению значения FALSE.

  • Применение к этой переменной проверки с помощью функции IsSet() приводит к получению значения FALSE. (Таким свойством не обладают переменные каких-либо других типов.)

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

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

Строки

Как показано ниже, строки представляют собой символьные последовательности:

Код PHP
$string_1 = "Это строка в двойных кавычках.";
$string_2 = 'Это строка в одинарных кавычках';
$string_26 = "В этой строке 26 символов.";
$string_0 = "";    // Строка, количество символов в которой равно нулю

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

Строки в одинарных кавычках

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

Код PHP
$var = 12345;
$literally = 'Переменная var = $var.\\nOk';
print($literally);

приводит к получению в окне браузера следующего вывода:

Обработка строки с одинарными кавычками

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

Код PHP
$singly_quoted = 'В этой переменной двойные кавычки: " не приводят к нарушению в работе';

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

Код PHP
$singly_quoted = 'Вводим \'одинарную кавычку\' в строку';

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

Код PHP
// Получается строка 'C:\Windows\System32\'
$win_path = ' С:\\Windows\\System32\\';

Подводя итог, отметим, что строки в одинарных кавычках сохраняются в памяти в неизменном виде и единственными исключениями являются две указанные управляющие последовательности (\\ и \').

Строки в двойных кавычках

Строки, заключенные в двойные кавычки (например, "this"), подвергаются предварительной обработке интерпретатором PHP двумя приведенными ниже способами:

  1. Некоторые символьные последовательности, начинающиеся с обратной косой черты (\), заменяются специальными символами.

  2. Имена переменных (начинающиеся со знака $) заменяются строковыми представлениями их значений.

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

  • Последовательность \n заменяется символом обозначения конца строки.

  • Последовательность \r заменяется символом возврата каретки (переноса).

  • Последовательность \t заменяется символом табуляции.

  • Последовательность \$ заменяется самим знаком доллара ($).

  • Последовательность \" заменяется одной двойной кавычкой (").

  • Последовательность \\ заменяется одной наклонной чертой влево (\).

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

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

Код PHP
$has_apostrophe = "There's no problem here";

Подстановка значений переменных

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

  • Если переменной в настоящее время присвоено строковое значение, то оно заменяет в строке с двойными кавычками имя соответствующей переменной (иными словами, выполняется подстановка значения переменной вместо имени переменной).

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

  • Если переменной в настоящее время не присвоено значение, то интерпретатор PHP заменяет имя переменной пустым значением (или, если применить эквивалентную формулировку, интерпретатор PHP подставляет вместо имени переменной пустую строку).

Ресурсы

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

Общее определение понятия ресурса

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

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

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

Способы обработки ресурсов

Как правило, программисты, работающие на языке PHP, не создают ресурсы самостоятельно, а вызывают специальные функции, которые возвращают значения типа resource, а затем передают эти значения в другие функции, для которых требуются ресурсы. Например, в программе можно вызвать функцию mysql_connect() (которая возвращает значение ресурса, ссылающееся на соединение с базой данных MySQL), сохранить полученный результат в переменной, а затем передать значение ресурса в функцию mysql_query() (которая использует ресурс соединения для передачи запроса в базу данных).

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

Код PHP
// Сохранение ресурса в переменной
$my_resource = mysql_connect(...); 

// ... Код, в котором используется ресурс соединения ... 

// Переменная больше не ссылается на ресурс освобождая память
$my_resource = NULL; 

Присваивание переменной $my_resource неопределенного значения вынуждает интерпретатор PHP проверить, нет ли другого фрагмента кода, в котором используется этот ресурс MySQL, и в случае отрицательного ответа освободить этот ресурс. Еще один вариант состоит в том, что большинство функций открытия ресурса имеет противоположные по своему назначению функции закрытия ресурса. В качестве примера можно привести функцию mysql_close().

Проверка типа

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

Функции проверки типа
Функция Описание
gettype(arg) Возвращает строку, представляющую тип arg: integer (целое число), float (число с плавающей точкой), string (строковое значение), array (массив), object (объект) или unknown (неизвестный тип)
is_int(arg), is_integer(arg), is_long(arg) Возвращает значение true, если arg - целое число, в противном случае - false
is_double(arg), is_float(arg), is_real(arg) Возвращает значение true, если arg - число с плавающей точкой, в противном случае - false
is_bool(arg) Возвращает значение true, если arg - булево значение (true или false), в противном случае - false
is_null(arg) Возвращает значение true, если arg имеет тип null, в противном случае - false
is_string(arg) Возвращает значение true, если arg - строка, в противном случае - false
is_array(arg) Возвращает значение true, если arg - массив, в противном случае - false
is_object(arg) Возвращает значение true, если arg - объект, в противном случае - false
is_resource(arg) Возвращает значение true, если arg - ресурс, в противном случае - false
is_binary(arg) Возвращает значение true, если arg - двоичная строка, в противном случае - false
is_buffer(arg) Возвращает значение true, если arg - строка в Юникоде или двоичная строка, в противном случае - false
is_scalar(arg) Возвращает значение true, если arg - скалярная переменная, в противном случае - false
is_unicode(arg) Возвращает значение true, если arg - строка в Юникоде, в противном случае - false
is_numeric(arg) Возвращает значение true, если arg - числовое значение, в противном случае - false

Присваивание и приведение типа

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

Правила преобразования типов

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

  • Целое число — в число с плавающей точкой: создается число с плавающей точкой, полностью соответствующее исходному (например, int 4 становится равным float 4.0).

  • Число с плавающей точкой — в целое число: дробная часть отбрасывается, т.е. число округляется в сторону нуля.

  • Число — в булево значение: FALSE, если число точно равно 0, в противном случае TRUE.

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

  • Булево значение — в число: 1, если TRUE; 0, если FALSE.

  • Булево значение — в строку: '1', если TRUE, пустая строка, если FALSE.

  • Значение NULL — в число: 0.

  • Значение NULL — в булево значение: FALSE.

  • Строка — в число: преобразование эквивалентно чтению числа из строки с последующим преобразованием в требуемый тип. Если число не может быть считано успешно, то полученное значение является нулевым. Для того чтобы операция чтения считалась выполненной успешно, не обязательно требуется считывать всю строку.

  • Строка — в булево значение: FALSE, если это — пустая строка или строка, равная '0', TRUE в противном случае.

  • Простой тип (число или строка) — в массив: преобразование эквивалентно созданию нового массива с одним элементом, имеющим индекс нуль.

  • Массив — в число: преобразование не определено.

  • Массив — в булево значение: FALSE, если массив не имеет элементов, TRUE в противном случае.

  • Массив — в строку: 'Array'.

  • Объект — в число: преобразование не определено.

  • Объект — в булево значение: TRUE, если объект содержит любые переменные экземпляра, имеющие ненулевое значение, и FALSE в противном случае.

  • Объект — в строку: 'Object'.

  • Ресурс — в булево значение: FALSE.

  • Ресурс — в число: преобразование не определено.

  • Ресурс — в строку: строка, которая обычно принимает вид 'Resource id #1' (но этого нельзя гарантировать).

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

Явные преобразования

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

  1. Функции intval(), floatval () и strval() преобразуют свои параметры соответственно в целые числа, числа с плавающей точкой или строковые значения.

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

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

В следующем примере продемонстрированы все 3 версии приведения типов:

Код PHP
$str = "101 далматинец";

// Преобразуем строку в целое число
$count = intval($str);
echo $count;			// 101

// Преобразуем строку в булево значение
$bool = (bool)$str;
echo ($bool) ? "TRUE" : "FALSE";     // 'TRUE', т.к. строка не пустая и не '0'

// Преобразуем строку в число с плавающей точкой
settype($str, "float");
echo gettype($str);     // 'double'

Ключевые слова с именами шести основных типов (integer, float, boolean, string, array и object) являются допустимыми компонентами в операторах приведения типа, а также допустимыми строковыми параметрами функции settype(). Кроме того, в операторах приведения типа допускается использование некоторых альтернативных ключевых слов, обозначающих имена типов: (int) вместо (integer), (double) или (real) вместо (float) и (bool) вместо (boolean). Приведение типа resource не допускается, а приведение к типу NULL является бессмысленным (дело в том, что результатом такого приведения может быть только значение NULL, поэтому можно вместо этого присвоить переменной такое значение.)

Целочисленное переполнение

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

Код PHP
$too_big = 268;
for ($i = 0; $i < 5; $i++)
{
	// С каждой итерацией цикла увеличиваем число в 1000 раз,
	// чтобы достичь целочисленного переполнения
	$too_big *= 1000;
	echo "$too_big: тип переменной ".gettype($too_big)."
"; }
Целочисленное переполнение

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

Переменные и константы
Условные операторы

Комментарии (0)

Результаты поиска по запросу

Система Orphus