Type Casting

Introduction

PHP is a loosely typed language, which means a variable's type is not fixed and can change depending on how it is used. Sometimes PHP converts values between types for you automatically, and sometimes you need to tell PHP explicitly what type you want a value to be. Both processes are forms of type casting.

Understanding when PHP converts types on its own, and when you should do it yourself, will save you from some of the most common and confusing bugs in PHP code.

What is Type Casting?

Type casting means converting a value from one data type to another — for example, turning the string "5" into the integer 5. PHP performs this conversion in two ways: implicitly (automatically, behind the scenes) and explicitly (when you request it directly in your code).

Implicit Type Conversion (Type Juggling)

PHP's "type juggling" happens when an operator expects one type but receives another. Numeric strings are automatically converted to numbers when used in arithmetic, so PHP can figure out what you meant without you writing any extra code.

<?php
    $result = "5" + 3;       // string "5" is converted to int 5
    echo $result;            // 8
    echo gettype($result);   // integer

    $total = "10" . 5;       // int 5 is converted to string "5"
    echo $total;             // "105"
    echo gettype($total);    // string

    $sum = "3.5" + 1;        // numeric string with decimal becomes float
    echo $sum;               // 4.5
?>

8
integer
105
string
4.5

Notice the pattern: the + operator pulls both operands toward numbers, while the . (concatenation) operator pulls both operands toward strings. PHP decides the target type based on the operator being used, not the other way around.

Explicit Type Casting

When you want full control over a value's type instead of relying on PHP to guess, you can cast it explicitly by placing the target type in parentheses directly before the value.

<?php
    $value = "42";

    $asInt    = (int) $value;
    $asFloat  = (float) $value;
    $asString = (string) 42;
    $asBool   = (bool) $value;
    $asArray  = (array) $value;

    var_dump($asInt);
    var_dump($asFloat);
    var_dump($asString);
    var_dump($asBool);
    var_dump($asArray);
?>

int(42)
float(42)
string(2) "42"
bool(true)
array(1) { [0]=> string(2) "42" }

Casting to Integer and Float

Casting to (int) truncates any decimal portion — it does not round. Casting numeric strings works as you would expect, extracting the leading numeric portion of the string.

<?php
    var_dump((int) 9.9);        // int(9) - truncated, not rounded
    var_dump((int) -9.9);      // int(-9)
    var_dump((int) "42");      // int(42)
    var_dump((int) "42.9abc"); // int(42) - stops at the first invalid character
    var_dump((float) "3.14 is pi"); // float(3.14)
?>

int(9)
int(-9)
int(42)
int(42)
float(3.14)

Casting to String

Casting numbers and booleans to (string) is straightforward: numbers become their digit representation, true becomes "1", and false becomes an empty string.

<?php
    $a = (string) 42;     // "42"
    $b = (string) 3.14;   // "3.14"
    $c = (string) true;   // "1"
    $d = (string) false;  // "" (empty string)

    var_dump($a, $b, $c, $d);
?>

string(2) "42"
string(4) "3.14"
string(1) "1"
string(0) ""

Casting to Boolean

This is where type casting matters most for controlling program flow, since if statements and loops constantly evaluate values as booleans behind the scenes. PHP has a strict, memorizable list of values that are considered "falsy" — every other value is "truthy".

<?php
    var_dump((bool) 0);      // false
    var_dump((bool) 0.0);    // false
    var_dump((bool) "");     // false
    var_dump((bool) "0");    // false - a famous gotcha!
    var_dump((bool) []);     // false
    var_dump((bool) null);   // false

    var_dump((bool) "0.0");  // true! "0.0" is NOT the same as "0"
    var_dump((bool) "false"); // true! Any non-empty string other than "0" is truthy
    var_dump((bool) -1);      // true! Any non-zero number, including negatives, is truthy
?>

bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(false)
bool(true)
bool(true)
bool(true)

Casting to Array

Casting a non-array scalar value to (array) wraps it in a new array with a single element at index 0. Casting null produces an empty array.

<?php
    $wrapped = (array) "hello";
    $empty   = (array) null;

    print_r($wrapped);
    print_r($empty);
?>

Array
(
    [0] => hello
)
Array
(
)

Common Gotchas

The most surprising thing about PHP's casting rules is how forgiving they are with invalid input — casts almost never throw errors, they just do their best to produce a sensible value.

<?php
    var_dump((int) "abc");    // int(0)
    var_dump((int) "12abc"); // int(12)
    var_dump((int) "   7");  // int(7) - leading whitespace is ignored
?>

int(0)
int(12)
int(7)

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Type casting lets you both understand PHP's automatic conversions and take deliberate control over a value's type when it matters. Mastering the falsy-value rules in particular will prevent a huge class of subtle logic bugs.