PHP
Типы

Целые

Целые числа в PHP могут быть изначально заданы в базе 2 (двоичная), база 8 (восьмеричная), база 10 (десятичная) или база 16 (шестнадцатеричная).

$my_decimal = 42;
$my_binary = 0b101010;
$my_octal = 052;
$my_hexadecimal = 0x2a;

echo ($my_binary + $my_octal) / 2;
// Output is always in decimal: 42

Целые числа 32 или 64 бит в зависимости от платформы. Постоянный PHP_INT_SIZE имеет целочисленный размер в байтах. PHP_INT_MAX и (начиная с PHP 7.0) также доступны PHP_INT_MIN .

printf("Integers are %d bits long" . PHP_EOL, PHP_INT_SIZE * 8);
printf("They go up to %d" . PHP_EOL, PHP_INT_MAX);

Целочисленные значения автоматически создаются по мере необходимости из float, booleans и strings. Если требуется явно заданный тип, это может быть сделано с помощью (int) или (integer) cast:

$my_numeric_string = "123";
var_dump($my_numeric_string);
// Output: string(3) "123"
$my_integer = (int)$my_numeric_string;
var_dump($my_integer);
// Output: int(123)

Целочисленное переполнение будет обрабатываться путем преобразования в float:

$too_big_integer = PHP_INT_MAX + 7;
var_dump($too_big_integer);
// Output: float(9.2233720368548E+18)

В PHP нет целочисленного оператора деления, но его можно моделировать с помощью неявного литья, который всегда «обходит», просто отбрасывая float-часть. Начиная с версии PHP 7, была добавлена ​​функция целочисленного деления.

$not_an_integer = 25 / 4;
var_dump($not_an_integer);
// Output: float(6.25)
var_dump((int) (25 / 4)); // (see note below)
// Output: int(6)
var_dump(intdiv(25 / 4)); // as of PHP7
// Output: int(6)

(Обратите внимание, что дополнительные скобки вокруг (25 / 4) необходимы, потому что (int) имеет более высокий приоритет, чем деление)

Струны

Строка в PHP - это серия однобайтовых символов (т. Е. Нет поддержки Unicode), которая может быть указана четырьмя способами:

Единый котировочный

Отображает вещи почти полностью «как есть». Переменные и большинство управляющих последовательностей не будут интерпретироваться. Исключением является то, что для отображения буквенной одинарной кавычки можно избежать ее с помощью обратной косой черты », а для отображения обратной косой черты можно избежать ее с помощью другой обратной косой черты \

$my_string = 'Nothing is parsed, except an escap\'d apostrophe or backslash. $foo\n';
var_dump($my_string);

/*
string(68) "Nothing is parsed, except an escap'd apostrophe or backslash. $foo\n"
*/

Двойной кавычек

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

$variable1 = "Testing!";
$variable2 = [ "Testing?", [ "Failure", "Success" ] ];
$my_string = "Variables and escape characters are parsed:\n\n";
$my_string .= "$variable1\n\n$variable2[0]\n\n";
$my_string .= "There are limits: $variable2[1][0]";
$my_string .= "But we can get around them by wrapping the whole variable in braces: {$variable2[1][1]}";
var_dump($my_string);

/*
string(98) "Variables and escape characters are parsed:

Testing!

Testing?

There are limits: Array[0]"

But we can get around them by wrapping the whole variable in braces: Success

*/

Heredoc

В строке heredoc имена переменных и escape-последовательности анализируются аналогично строкам с двойными кавычками, хотя фигурные скобки недоступны для имен сложных переменных. Начало строки ограничено identifier <<< , а конец - identifier , где identifier - любое допустимое имя PHP. Идентификатор окончания должен отображаться в отдельной строке. До или после идентификатора не допускается пробел, хотя, как и любая строка в PHP, он также должен быть прерван точкой с запятой.

$variable1 = "Including text blocks is easier";
$my_string = <<< EOF
Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. $variable1; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends.
EOF;
var_dump($my_string);

/*
string(268) "Everything is parsed in the same fashion as a double-quoted string,
but there are advantages. Including text blocks is easier; database queries and HTML output
can benefit from this formatting.
Once we hit a line containing nothing but the identifier, the string ends."
*/

Nowdoc

Строка nowdoc похожа на однонаправленную версию heredoc, хотя не оцениваются даже самые основные escape-последовательности. Идентификатор в начале строки заключен в одинарные кавычки.

$my_string = <<< 'EOF'
A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)
EOF;
var_dump($my_string);

/*
string(116) "A similar syntax to heredoc but, similar to single quoted strings,
nothing is parsed (not even escaped apostrophes \' and backslashes \\.)"
*/

логический

Boolean - это тип, имеющий два значения, обозначаемые как true или false .

Этот код устанавливает значение $foo как true и $bar как false :

$foo = true;
$bar = false;

true и false не чувствительны к регистру, поэтому можно использовать TRUE и FALSE возможно даже FaLsE . Использование нижнего регистра является наиболее распространенным и рекомендуется в большинстве руководств по стилю кода, например, PSR-2 .

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

if ($foo) { //same as evaluating if($foo == true)
    echo "true";
}

Из-за того, что PHP слабо типизирован, если $foo выше отличается от true или false , он автоматически привязывается к логическому значению.
Следующие значения приводят к false :

• нулевое значение: 0 (целое число), 0.0 (float) или '0' (строка)
• пустая строка '' или массив []
• null (содержимое измененной переменной или назначается переменной)

Любое другое значение приводит к true .

Чтобы избежать этого непростого сравнения, вы можете обеспечить сильное сравнение, используя === , который сравнивает значение и тип . Подробнее см. В разделе « Сравнение типов» .

Чтобы преобразовать тип в boolean, вы можете использовать (bool) или (boolean) cast перед типом.

var_dump((bool) "1"); //evaluates to true

или вызовите функцию boolval :

var_dump( boolval("1") ); //evaluates to true

Булево преобразование в строку (обратите внимание, что false дает пустую строку):

var_dump( (string) true ); // string(1) "1"
var_dump( (string) false ); // string(0) ""

Логическое преобразование в целое число:

var_dump( (int) true ); // int(1)
var_dump( (int) false ); // int(0)

Обратите внимание, что возможно также и обратное:

var_dump((bool) "");        // bool(false)
var_dump((bool) 1);         // bool(true)

Также все ненулевые возвращают true:

var_dump((bool) -2);        // bool(true)
var_dump((bool) "foo");     // bool(true)
var_dump((bool) 2.3e5);     // bool(true)
var_dump((bool) array(12)); // bool(true)
var_dump((bool) array());   // bool(false)
var_dump((bool) "false");   // bool(true)

терка

$float = 0.123;

По историческим причинам «double» возвращается gettype() в случае поплавка, а не просто «плавать»,

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

Поплавки и целые числа могут использоваться вместе из-за неуправляемого литья PHP переменных типов:

$sum = 3 + 0.14;

echo $sum; // 3.14

php не показывает float как число с плавающей точкой, например, другие языки, например:

$var = 1;
echo ((float) $var); //returns 1 not 1.0

Предупреждение

Точность плавающей точки

(На странице руководства PHP )

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

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

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

подлежащий выкупу

Callables - это все, что можно назвать обратным вызовом. Вещи, которые можно назвать «обратным вызовом», следующие:

• Анонимные функции

• Стандартные функции PHP (примечание: не языковые конструкции )

• Статические классы

• нестатические классы ( с использованием альтернативного синтаксиса )

• Специальные методы объекта / класса

• Объекты сами по себе, пока объект находится в ключе 0 массива

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

 $obj = new MyClass();
 call_user_func([$obj, 'myCallbackMethod']);

Обратные callable могут быть обозначены подсказкой типа hint с PHP 5.4.

$callable = function () {
    return 'value';
};

function call_something(callable $fn) {
    call_user_func($fn);
}

call_something($callable);

Ноль

PHP представляет «нет значения» с ключевым словом null . Он несколько похож на нулевой указатель на C-языке и на значение NULL в SQL.

Установка переменной в значение null:

$nullvar = null; // directly

function doSomething() {} // this function does not return anything
$nullvar = doSomething(); // so the null is assigned to $nullvar

Проверка, была ли переменная установлена ​​равной нулю:

if (is_null($nullvar)) { /* variable is null */ }

if ($nullvar === null) {  /* variable is null */ }

Null vs undefined variable

Если переменная не была определена или была отменена, любые тесты против null будут успешными, но они также будут генерировать Notice: Undefined variable: nullvar :

$nullvar = null;
unset($nullvar);
if ($nullvar === null) {  /* true but also a Notice is printed */ }
if (is_null($nullvar)) {  /* true but also a Notice is printed */ }

Поэтому неопределенные значения должны быть проверены с помощью isset :

if (!isset($nullvar)) {  /* variable is null or is not even defined */  }

Сравнение типов

Существует два типа сравнения : свободное сравнение с == и строгое сравнение с === . Строгое сравнение гарантирует, что тип и стоимость обеих сторон оператора одинаковы.

// Loose comparisons
var_dump(1 == 1); // true
var_dump(1 == "1"); // true
var_dump(1 == true); // true
var_dump(0 == false); // true

// Strict comparisons
var_dump(1 === 1); // true
var_dump(1 === "1"); // false
var_dump(1 === true); // false
var_dump(0 === false); // false

// Notable exception: NAN — it never is equal to anything
var_dump(NAN == NAN); // false
var_dump(NAN === NAN); // false

Вы также можете использовать сильное сравнение , чтобы проверить , если тип и значение не совпадают с использованием !== .

Типичным примером, когда оператора == недостаточно, являются функции, которые могут возвращать разные типы, такие как strpos , которые возвращают false если searchword не найдено, а позиция соответствия ( int ) иначе:

if(strpos('text', 'searchword') == false)
  // strpos returns false, so == comparison works as expected here, BUT:
if(strpos('text bla', 'text') == false)
  // strpos returns 0 (found match at position 0) and 0==false is true.
  // This is probably not what you expect!
if(strpos('text','text') === false)
  // strpos returns 0, and 0===false is false, so this works as expected.

Литье под давлением

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

$bool = true;
var_dump($bool); // bool(true)

$int = (int) true;
var_dump($int); // int(1)

$string = (string) true;
var_dump($string); // string(1) "1"
$string = (string) false;
var_dump($string); // string(0) ""

$float = (float) true;
var_dump($float); // float(1)

$array = ['x' => 'y'];
var_dump((object) $array); // object(stdClass)#1 (1) { ["x"]=> string(1) "y" } 

$object = new stdClass();
$object->x = 'y';
var_dump((array) $object); // array(1) { ["x"]=> string(1) "y" }

$string = "asdf";
var_dump((unset)$string); // NULL

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

// below 3 statements hold for 32-bits systems (PHP_INT_MAX=2147483647)
// an integer value bigger than PHP_INT_MAX is automatically converted to float:
var_dump(       999888777666 ); // float(999888777666)
// forcing to (int) gives overflow:
var_dump((int)  999888777666 ); // int(-838602302)
// but in a string it just returns PHP_INT_MAX
var_dump((int) "999888777666"); // int(2147483647)

var_dump((bool) []);      // bool(false) (empty array)
var_dump((bool) [false]); // bool(true)  (non-empty array)

Ресурсы

Ресурс - это особый тип переменной, который ссылается на внешний ресурс, такой как файл, сокет, поток, документ или соединение.

$file = fopen('/etc/passwd', 'r');

echo gettype($file);
# Out: resource

echo $file;
# Out: Resource id #2

Существуют разные (суб) типы ресурсов. Вы можете проверить тип ресурса, используя get_resource_type() :

$file = fopen('/etc/passwd', 'r');
echo get_resource_type($file);
#Out: stream

$sock = fsockopen('www.google.com', 80);
echo get_resource_type($sock);
#Out: stream

Вы можете найти полный список встроенных типов ресурсов здесь .

Тип Жонглирование

PHP - это слабо типизированный язык. Он не требует явного объявления типов данных. Контекст, в котором используется переменная, определяет его тип данных; преобразование выполняется автоматически:

$a = "2";             // string 
$a = $a + 2;          // integer (4) 
$a = $a + 0.5;        // float (4.5)
$a = 1 + "2 oranges"; // integer (3)