Php преобразовать число в строку – Приведение типов. Преобразование в строку, число, null

PHP: Манипуляции с типами — Manual

Манипуляции с типами

PHP не требует (и не поддерживает) явного типа при определении переменной; тип переменной определяется по контексту, в котором она используется. То есть, если вы присвоите значение типа string переменной $var, то $var изменит тип на string. Если вы затем присвоите $var значение типа integer, она станет целым числом (integer).

Примером автоматического преобразования типа является оператор умножения ‘*’. Если какой-либо из операндов является float, то все операнды интерпретируются как float, и результатом также будет float. В противном случае операнды будут интерпретироваться как integer и результат также будет integer. Обратите внимание, что это НЕ меняет типы самих операндов; меняется только то, как они вычисляются и сам тип выражения.

<?php
$foo = "1";  // $foo - это строка (ASCII-код 49)
$foo *= 2;   // $foo теперь целое число (2)


$foo = $foo * 1.3;  // $foo теперь число с плавающей точкой (2.6)
$foo = 5 * "10 Little Piggies"; // $foo - это целое число (50)
$foo = 5 * "10 Small Pigs";     // $foo - это целое число (50)
?>

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

Если вы хотите, чтобы переменная принудительно вычислялась как определенный тип, смотрите раздел приведение типов. Если вы хотите изменить тип переменной, смотрите settype().

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

Замечание

:

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

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

<?php
$a    = 'car'; // $a - это строка
$a[0] = 'b';   // $a все еще строка
echo $a;       // bar
?>

Более подробно смотрите в разделе Доступ к символу в строке.

Приведение типов

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

<?php
$foo = 10;   // $foo - это целое число
$bar = (boolean) $foo;   // $bar - это булев тип
?>

Допускаются следующие приведения типов:

• (int), (integer) — приведение к integer
• (bool), (boolean) — приведение к boolean
• (float), (double), (real) — приведение к float
• (string) — приведение к string
• (array) — приведение к array
• (object) — приведение к object
• (unset) — приведение к NULL

Приведение типа (binary) и поддержка префикса b были добавлены в PHP 5.2.1. Обратите внимание, что (binary) по существу то же самое, что и (string), но не следует полагаться на этот тип приведения.

Приведение типа (unset) объявлено устаревшим с PHP 7.2.0. Обратите внимание, что приведение типа (unset) это то же самое, что присвоение NULL переменной. Тип приведения (unset) будет удален в PHP 8.0.0.

Обратите внимание, что внутри скобок допускаются пробелы и символы табуляции, поэтому следующие примеры равносильны по своему действию:

<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>

Приведение строковых литералов и переменных к бинарным строкам:

<?php
$binary = (binary) $string;
$binary = b"binary string";
?>

Замечание:

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

<?php
$foo = 10;            // $foo - это целое число
$str = "$foo";        // $str - это строка
$fst = (string) $foo; // $fst - это тоже строка

// Это напечатает "они одинаковы"

if ($fst === $str) {
    echo "они одинаковы";
}
?>

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

www.php.net

Манипуляции с типами в PHP

У Вас в браузере заблокирован JavaScript. Разрешите JavaScript для работы сайта!

PHP не требует (и не поддерживает) явного определения типа при объявлении переменной; тип переменной определяется по контексту, в котором она используется. То есть, если вы присвоите строковое значение переменной $var, $var станет строкой. Если вы затем присвоите $var целочисленное значение, она станет целым числом.

Примером автоматического преобразования типа является оператор сложения ‘+’. Если любой из операндов является числом с плавающей точкой, то все операнды интерпретируются как числа с плавающей точкой, результатом будет также число с плавающей точкой. В противном случае операнды будут интерпретироваться как целые числа и результат также будет целочисленным. Обратите внимание, что это НЕ меняет типы самих операндов; меняется только то, как они вычисляются.

$foo = "0"; // $foo это строка (ASCII 48)
$foo += 2; // $foo теперь целое число (2)
$foo = $foo + 1.3; // $foo теперь число с плавающей точкой (3.3)
$foo = 5 + "10 Little Piggies"; // $foo это целое число (15)
$foo = 5 + "10 Small Pigs"; // $foo это целое число (15)

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

Если вы хотите, чтобы переменная принудительно вычислялась как определенный тип, смотрите раздел приведение типов. Если вы хотите изменить тип переменной, смотрите settype().

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

Замечание: Поведение автоматического преобразования в массив в настоящий момент не определено.

$a = "1"; // $a это строка
 $a[0] = "f"; // А как же смещение строки? Что произойдет?

Поскольку PHP поддерживает индексирование в строках с использованием такого же синтаксиса, как и при индексировании массива, вышеприведенный пример приводит к проблеме: следует ли $a стать массивом, первым элементом которого будет «f» или «f» должна стать первым символом строки $a?

Текущая версия PHP воспринимает второе присваивание как определение смещения строки, поэтому $a станет «f», результат же этого автоматического преобразования следует, однако, рассматривать как неопределенный. В PHP 4 для доступа к символам строки был введен новый синтаксис фигурных скобок, используйте этот синтаксис вместо вышеприведенного:

$a = "abc"; // $a это строка
 $a{1} = "f"; // $a теперь содержит "afc"

Для дополнительной информации смотрите раздел Доступ к символу в строке.

Приведение типов

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

 $foo = 10; // $foo это целое число
$bar = (boolean) $foo; // $bar это булев тип

Допускаются следующие приведения типов:
• (int), (integer) — приведение к целому числу
• (bool), (boolean) — приведение к булеву типу
• (float), (double), (real) — приведение к числу с плавающей точкой (float)
• (string) — приведение к строке
• (array) — приведение к массиву
• (object) — приведение к объекту

Обратите внимание, что внутри скобок допускаются пробелы и символы табуляции, поэтому следующее равносильно по своему действию:

$foo = (int) $bar;
$foo = ( int ) $bar; 

Замечание: Вместо приведения переменной к строке, вы можете заключить ее в двойные кавычки.

$foo = 10; // $foo это целое число
 $str = "$foo"; // $str это строка
 $fst = (string) $foo; // $fst это также строка

 // Это напечатает "они одинаковы"
 if ($fst === $str) {
 echo "они одинаковы";
 }

Возможно, вам не совсем ясно, что происходит при приведении между типами. Для дополнительной информации смотрите разделы:

Смотрите также:
Описание на ru2.php.net
Описание на php.ru

htmlweb.ru

PHP :: Манипуляции с типами

Приведение типов в PHP

Поскольку PHP относится к языкам программирования с

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

Приведением типа называется процесс преобразования значения одного типа в значение другого типа.

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

• (bool), (boolen) – приведение к логическому типу;
• (int), (integer) – приведение к целочисленному типу;
• (float), (double), (real) – приведение к вещественному типу;
• (string) – приведение к строковому типу;
• (array) – приведение к типу array;
• (object) – приведение к типу object;
• (unset) – приведение к NULL.

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

Приведение к типу bool

Во время преобразования к типу bool следующие значения рассматриваются как FALSE:

• само значение false,
• 0 и 0.0,
• пустая строка «» и строка «0»,
• массив без элементов (пустой массив) [],
• значение null,
• объект SimpleXML, созданный из пустых тегов.

Все остальные значения преобразуются в значение TRUE, включая значения типа resource, а также число -1, поскольку оно представляет собой обычное отрицательное число, отличное от нуля.

Приведение к типу integer

В случае привидения к типу integer:

• Логическое значение true преобразуется в 1, false – в 0.
• Значение null преобразуется в 0.
• Вещественные числа округляются вниз, т.е. в сторону нуля. Например, в случае приведения вещественного числа 7.9 к целочисленному типу оно будет преобразовано в число 7. При этом вещественное число не должно превышать максимально допустимые для целых чисел размеры (смотреть) иначе результат будет неопределенным, что вызвано отсутствием достаточной точности у вещественных чисел, чтобы вернуть верный результат. Более того, в данном случае не будет выведено даже замечания. Также не стоит приводить неизвестную дробь к целочисленному типу во избежание получения неожиданных результатов. Например, если привести к типу integer результат выражения ‘(0.1+0.7)*10’, то интерпретатор преобразует его в число 7, а не 8, как ожидалось.
• Если строка начинается с верной записи целого числа, то интерпретатор в процессе приведения строки к целочисленному типу вернет это число, отбросив всю остальную часть строки. Если же строка является пустой «» или начинается не с цифры, знака плюс ‘+’ или знака минус ‘-‘, она будет преобразована в число 0. Например, строка ‘-25 яблок’ будет преобразована в число -25, строка ‘3.5 яблока’ – в число 3, а строка ‘Яблок было 25’ – в число 0.

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

Приведение к типу float

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

• если строка начинается с верной записи вещественного числа (включая экспоненциальную форму записи), интерпретатор в процессе приведения строки к вещественному типу вернет это число, отбросив всю остальную часть строки;
• если же строка является пустой «» или начинается не с цифры, знака плюс ‘+’, знака минус ‘-‘ или символа точки ‘.’ (напомним, что при записи вещественных чисел перед точкой ноль разрешается опускать), то она будет преобразована в число 0.

Например, строка ‘1.567e2 кг яблок’ будет преобразована в число 156.7, строка ‘.5 яблока’ – в число 0.5, а строка ‘Было 2.5 кг яблок’ – в число 0.

Приведение к типу string

В случае преобразования значений в строки (т.е. приведение к типу string):

• Логическое значение true преобразуется в строку «1», false – в пустую строку «».
• Целое или вещественное число преобразуется в строку, состоящую из самого числа. При этом учитывается и показатель степени вещественного числа. Например, число 1.567e2 будет преобразовано в строку ‘156.7’, а число .5 – в строку ‘0.5’.
• Специальное значение null преобразуется в пустую строку «».
• Массивы всегда преобразуются в строку ‘Array’.
• Ресурсы (данные типа resource) преобразуются в строку вида «Resource id #№», где № – номер ресурса во время выполнения.

Приведение к типу array

В случае преобразования значения типа bool, integer, float, string или resource в массив, результатом будет массив с этим элементом, индекс которого будет равен 0.

Приведение к типу NULL

Явное приведение переменной к специальному значению null с использованием конструкции ‘(unset) $var’ не удаляет переменную и ее значение, а только возвращает значение null для дальнейшего использования.

Примеры приведения типов

Код, содержащий операции приведения типа, представлен в примере №1.

<?php

//Присвоили логическое значение true
$var_1=true; 							
//Присвоили логическое значение false
$var_2=false; 						

//Теперь $var_1==1
$var_1=(integer) $var_1; 	
//Теперь $var_2==0
$var_2=(integer) $var_2; 	

//Теперь $var_1=="1"
$var_1=(string) $var_1; 	
//Теперь $var_2=="0"
$var_2=(string) $var_2; 	

//------------------------------------------------

//Присвоили строку "-1"
$var_3="-1"; 							
//Присвоили строку ".9345E3"
$var_4=".9345E3"; 				

//Теперь $var_3==1
$var_3=(bool) $var_3; 		
//Теперь $var_4==0
$var_4=(integer) $var_4; 	

//------------------------------------------------

//Присвоили строку "-.57"
$var_5="-.57"; 						
//Присвоили вещественное число, тоже самое, что и 934.5
$var_6=.9345E3; 					

//Теперь $var_5==["-.57"]
$var_5=(array) $var_5; 		
//Теперь $var_6==[934.5]
$var_6=(array) $var_6; 		

?>

Пример №1. Приведение типов переменных

Приведение к другим типам

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

Быстрый переход к другим страницам

belarusweb.net

Манипуляции с типами | Руководство по PHP

PHP не требует (и не поддерживает) явного типа при определении переменной; тип переменной определяется по контексту, в котором она используется. То есть, если вы присвоите значение типа string переменной $var, то $var станет строкой. Если вы затем присвоите $var целочисленное значение, она станет целым числом.

Примером автоматического преобразования типа является оператор сложения ‘+’. Если какой-либо из операндов является float, то все операнды интерпретируются как float, и результатом также будет float. В противном случае операнды будут интерпретироваться как целые числа и результат также будет целочисленным. Обратите внимание, что это НЕ меняет типы самих операндов; меняется только то, как они вычисляются и сам тип выражения.

<?php
$foo = "0";  // $foo это строка (ASCII 48)
$foo += 2;   // $foo теперь целое число (2)
$foo = $foo + 1.3;  // $foo теперь число с плавающей точкой (3.3)
$foo = 5 + "10 Little Piggies"; // $foo это целое число (15)
$foo = 5 + "10 Small Pigs";     // $foo это целое число (15)
?>

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

Если вы хотите, чтобы переменная принудительно вычислялась как определенный тип, смотрите раздел приведение типов. Если вы хотите изменить тип переменной, смотрите settype().

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

Замечание:

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

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

<?php
$a    = 'car'; // $a - это строка
$a[0] = 'b';   // $a все еще строка
echo $a;       // bar
?>

Более подробно смотрите в разделе Доступ к символу в строке.

Приведение типов

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

<?php
$foo = 10;   // $foo это целое число
$bar = (boolean) $foo;   // $bar это булев тип
?>

Допускаются следующие приведения типов:

• (int), (integer) — приведение к integer
• (bool), (boolean) — приведение к boolean
• (float), (double), (real) — приведение к float
• (string) — приведение к string
• (array) — приведение к array
• (object) — приведение к object
• (unset) — приведение к NULL (PHP 5)

Приведение типа (binary) и поддержка префикса b были добавлены в PHP 5.2.1

Обратите внимание, что внутри скобок допускаются пробелы и символы табуляции, поэтому следующие примеры равносильны по своему действию:

<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>

Приведение строковых литералов и переменных к бинарным строкам:

<?php
$binary = (binary) $string;
$binary = b"binary string";
?>

Замечание:

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

<?php
$foo = 10;            // $foo - это целое число
$str = "$foo";        // $str - это строка
$fst = (string) $foo; // $fst - это тоже строка

// Это напечатает "они одинаковы"

if ($fst === $str) {
    echo "они одинаковы";
}
?>

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

Вернуться к: Типы

php.ru

Приведение типов в PHP == табурет о двух ножках? / Habr

— В PHP приведение типов работает нормально, надо только включать здравый смысл.
— А чего там, просто сравниваешь и все…
— Ого, глюк какой-то в PHP, смотри, сравниваю два флоата, они должны быть одинаковые, а он мне говорит, что они не равны.
— А, ну когда число со строкой сравниваешь, перебирать надо, что сработает.

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

Буду краток, дальше будут только примерчики. А к тебе, дорогой читатель, просьба. Некоторые ответы спрятаны под спойлер. Перед тем, как заглянуть в ответ под спойлером, попробуй ответить сам. За каждый правильный ответ заслуженно прибавляй себе по баллу. В конце поста в опросе не забудь проставить свой результат. Договорились?
Тогда поехали.

Начнем с чисел

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

Для порядка проверяем очевидное:

11 == 11 // true, воистину
12 == 11 // false, само собой
12 == 0xC // true, сравниваем с 16-ричным

Как насчет такого сравнения?

12 == "0xC"

Попробуйте ответить

true. Да, тут значение в строке преобразовалось в целое с учетом системы счисления, здорово, правда?

А если так попробуем?

12 == 014

Чур не подглядываем, помните?

true. А как иначе? 014 — это же 12 в 8-ричной системе счисления.

Теперь так:

12 == "014"

Результат…

false. Те, кто хотел и тут true, умерьте свои требования, «0xC» преобразовалось в 12 и хватит.

И еще так:

14 == "014"

Равно…

true, вполне ожидаемо с учетом предыдущего примера.

Тут вроде все наглядно:

014 == "014"

Правильный ответ…

false, хотя чисто визуально это трудно заметить сходу, особенно, если читаешь чужой код.

Внимание:

0 == "0,9"

Ответ…

true, чего? А, ну да, так false: 0 == «0.9». Запятая посчиталась строковым символом и она и все после нее отбросилось.

Сравним такие значения:

"1e2" == "100"

Получим…

true, так как 1 умножить на 10 в квадрате равно 100.

0b11 == 3 // true, 0b - это относится к двоичной системе

А если 0b11 в строке?

"0b11" == 3

Сравниваем…

false, для 16-ричной системы это работает, а для двоичной — извините.

Теперь попробуем так:

2.333 == "2.333petrovich" // true, тут Петрович в конце строки и поэтому исключается из сравнения.
2.333 == "ivanovich3.333" // false, а тут Иванович вначале, поэтому сравнение идет со строкой.
0 == "ivanovich3.333" // true, строка равна нулю.

А тут попробуйте сами:

"2.33a" == "2.33b"

И получаем…

false, тут никакого преобразования нет, сравниваются строки.

233 == "233w1" // true, по аналогии с Петровичем

Почти тоже самое:

233 == "233e1"

Ответ…

false, да, кто заметил, тут 233 * 10.

"233" == "233w1" // false
233 == "233*1" // true

А если так скалькулировать?

233 == "233*2"

Вот…

Правильно, снова true, по аналогии с Петровичем.

0 == "" // true

Не подглядывайте, сперва сами:

"0" == ""

Пытаемся включить здравый смысл…

false, смиритесь.

"1.000000000000000123" == "1.000000000000000456" // false, логично, разные ж числа.

Тоже два float в строках:

"2.000000000000000123" == "2.000000000000000456"

Догадались?

true, не удивляйтесь, с виду числа хоть и разные, но 2 == 2, тут все до 2 округлилось.

Булевы сравнения

Раз с числами все проще простого и все ответили правильно, то вот еще простые примерчики.

Сперва такой каламбур… вспомнился анекдот про Поручика, но пожалуй воздержусь.

"true" == true // true
"false" == true // true, строка равна true
"false" == false // false, строка равна true
"true" == false // false, строка равна true

Тут все просто и понятно.

true == "0" // false, тут уже идет сравнение не со строкой, а с нулем
true == "00" // true, а тут со строкой...
true == 00 // false
true == "00" + 0 // false, тут к строке с нулем 0 прибавили

А если так прибавить:

true == "01" + 0

То получим…

true, а тут уже к 1 прибавление.

true == "0x" + 0 // false

Пробел пред нулем:

true == " 0"

Сверяемся…

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

true == 0x0 // false
true == "0x0" // true, так-то, тут уже не 0, а строка
true == "0.0" // true, и тут строка

true == " " // true
true == [] // false, пустой массив - это false
true == [0] // а массив с нулем - true

А если так?

true == [[]]

Проверяем…

true, тут массив что-то себе содержит, пустой массив.

NULL

Позвольте еще несколько сравнений, теперь с null.

null == false // true,
null == 0 // true,
false == "0" // true,

Попробуйте догадаться по аналогии:

null == "0"

Получаем…

false, видимо, надо просто запомнить.

null == [] // true, так как массив пустой
null == [0] // false, не пустой массив все-таки

Массивы

Ну и для особо любознательных — сравнения массивов.

Тут надеюсь, сами догадаетесь, только не подглядывайте:

[] == 0

Сверяем…

Точно, false, хотя null == 0 и [] == null.

[0] == 0 // false,

В документации сказано, что «$a == $b — TRUE в случае, если $a и $b содержат одни и те же пары ключ/значение».
Проверим, как именно работает это утверждение. тем более, что в доке ничего ни сказано про то, как сравниваются ключи.

[1 => 1] == [1 => 1] // true
[1 => 1] == ["1" => 1] // true, при этом:
[1 => 1] == ["0x1" => 1] // false, при том, что если отдельно сравнить ключи таким образом:
array_keys([1 => 1]) == array_keys(["0x1" => 1]) // true
Зато:
[1 => 1] == [1 => "0x1"] // true

Загадочка

И на десерт загадочка (загадка не от меня, коллега однажды ее мне дал).
Может ли когда-либо выполниться условие $x == 1 && $x == 2, если может, то когда, если нет, то почему?

А как-же резюме?

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

habr.com

PHP: Числа с плавающей точкой

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

Числа с плавающей точкой (также известные как «float», «double» или «real») могут быть определены следующими синтаксисами:

<?php
$a = 1.234; 
$b = 1.2e3; 
$c = 7E-10;
?>

Формально:

LNUM          [0-9]+
DNUM          ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})

Размер числа с плавающей точкой зависит от платформы, хотя максимум, как правило, составляет 1.8e308 с точностью около 14 десятичных цифр (64-битный формат IEEE).

Внимание

Числа с плавающей точкой имеют ограниченную точность. Хотя это зависит от операционной системы, в PHP обычно используется формат двойной точности IEEE 754, дающий максимальную относительную ошибку округления порядка 1.11e-16. Неэлементарные арифметические операции могут давать большие ошибки, и, разумеется, необходимо принимать во внимание распространение ошибок при совместном использовании нескольких операций.

Кроме того, рациональные числа, которые могут быть точно представлены в виде чисел с плавающей точкой с основанием 10, например, 0.1 или 0.7, не имеют точного внутреннего представления в качестве чисел с плавающей точкой с основанием 2, вне зависимости от размера мантиссы. Поэтому они и не могут быть преобразованы в их внутреннюю двоичную форму без небольшой потери точности. Это может привести к неожиданным результатам: например, floor((0.1+0.7)*10) скорее всего вернет 7 вместо ожидаемого 8, так как результат внутреннего представления будет чем-то вроде 7.9999999999999991118….

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

«Простое» объяснение можно найти в » руководстве по числам с плавающей точкой, которое также называется «Why don’t my numbers add up?» («Почему мои числа не складываются?»)

Преобразование в число с плавающей точкой

Информацию о преобразовании строк в числа с плавающей точкой смотрите в разделе Преобразование строк в числа. Для значений других типов преобразование будет сначала осуществлено в тип integer, а затем в число с плавающей точкой. Дополнительную информацию смотрите в разделе Преобразование к целому. Начиная с версии PHP 5, при преобразовании объекта к числу с плавающей точкой выводится замечание об ошибке.

Сравнение чисел с плавающей точкой

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

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

$a и $b равны до 5-ти знаков после запятой.

<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if (

abs($a - $b) < $epsilon) {
    echo "true";
}
?>

NaN

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

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

www.php.net

дата — Как преобразовать строку в дату php?

Stack Overflow на русском

Loading…

2. 0
3. +0
• Тур Начните с этой страницы, чтобы быстро ознакомиться с сайтом
• Справка Подробные ответы на любые возможные вопросы
• Мета Обсудить принципы работы и политику сайта
• О нас Узнать больше о компании Stack Overflow
• Бизнес Узнать больше о поиске разработчиков или рекламе на сайте

ru.stackoverflow.com