What is strict mode in php?

The default behavior in PHP is to attempt to convert scalar values of incorrect type into the expected type. For example, a function expecting a string can still be called with an integer argument, because an integer can be converted into a string as shown in the following example:

<?php

function getString(string $str) {
 var_dump($str);
}

$int = 12;
getString($int);
//string(2) "12"

Without strict typing, PHP will change the integer 12 to string "12". In strict mode, only a variable of the exact type of the type declaration will be accepted, or a TypeError will be thrown:

<?php

declare(strict_types = 1);

function getString(string $str) {
 var_dump($str);
}

$int = 12;
getString($int);

//Fatal error: Uncaught TypeError: Argument 1 passed to getString() must be of the type string, integer given...

The only exception to this rule is that an integer may be given to a function expecting a float. Function calls from within internal functions will not be affected by the strict_types declaration:

<?php
declare(strict_types = 1);

function getFloat(float $f) {
 var_dump ($f);
}

$int = 100;
var_dump($int);
//int(100)

getFloat($int);
//float(100)

declare(strict_types=1); affects both parameters and return type declarations of scalar type, which must then be of the exact type declared in the function:

<?php
declare(strict_types = 1);

function getFloat(float $f) : int 
{
 return (int) $f;
}

$int = getFloat(100);

Note: You must configure the declare(strict_types = 1); statement in the first line of your code, or else it will generate a compile error. Also, it does not affect the included files, you need to declare the declare(strict_types = 1); statement on the top of each file.

Data types in PHP:

1. Data Types
2. Determine Variable Data Type
3. Type Conversion: Convert variable data type
4. Type Declaration
5. Strict Typing Mode
6. Testing, setting, and unsetting variables

An improvement to @pekka's answer that also detects undefined array keys and offsets and undefined constants:

error_reporting(E_STRICT);

function terminate_undefineds($errno, $errstr, $errfile, $errline)
{ // $errno: E_NOTICE, etc.

    $errstr = strtolower($errstr);
    
    if (
            (strstr($errstr, "undefined variable")) ||
            (strstr($errstr, "undefined index"))    || // Such as $GLOBALS['some_unknown_var']
            (strstr($errstr, 'undefined constant')) || // Such as echo UNKNOWN_CONST
            (strstr($errstr, "undefined offset"))
            )
        die("$errstr in $errfile line $errline");
    else
        return false; // Let the PHP error handler handle all the rest
}

set_error_handler("terminate_undefineds"); 

As above code also restricts access to unknown $_GET and $_POST keys, you can define a similar method with related row commented and use set_error_handler before checking $_GET and $_POST keys. Also instead, you can use below methods to receive $_GET, $_POST and etc keys:

// Could be used in strict mode
function get_($what, $key) {
    switch (strtolower($what)) {
        case 'get':
            return isset($_GET[$key]) ? $_GET[$key] : null;
        case 'post':
            return isset($_POST[$key]) ? $_POST[$key] : null;
        case 'session':
            return isset($_SESSION[$key]) ? $_SESSION[$key] : null;
        case 'server':
            return isset($_SERVER[$key]) ? $_SERVER[$key] : null;
    }
}

declare(strict_types=1);

In December 2015, PHP 7 introduced scalar type declarations and with it the strict types flag.

To enable the strict mode, a single declare directive must be placed at the top of the file. This means that the strictness of typing for scalars is configured on a per-file basis. This directive not only affects the type declarations of parameters, but also a function’s return type.

The good thing about declaring a PHP file as strict is that it actually applies to ONLY the current file. It ensures that this file has strict types, but it doesn’t apply to any other file in the whole project. It allows you to do, step by step, this migration from non-strict code to strict code, especially for new files or projects.

Strict types affect coercion types

Using hint type without strict_types may lead to subtle bugs.

Prior to strict types, int $x meant $x must have a value coercible to an int. Any value that could be coerced to an int would pass the hint type, including:

• a proper int (example: 42 -> 42)
• a float (example: 13.1459 -> 13)
• a bool (example: true -> 1)
• a null (example: null -> 0)
• a string with leading digits (example: “15 Trees” -> 15)

By setting strict_types=1, you tell the engine that int $x means $x must only be an int proper, no type coercion allowed. You have the great assurance you're getting exactly and only what was given, without any conversion or potential loss.

Who should care about this “strict type” line?

Actually, declare(strict_types=1); is more for the reader than for the writer. Why? Because it will explicitly tell the reader:

• The types in this current scope (file/class) are treated strictly.

'strict_types=1' is more for the reader than for the writer

The writer just needs to maintain such strictness while writing the expected behavior. That said, as a writer, you should care about your readers, which also includes your future self. Because you are going to be one of them.

What is strict type?

Is PHP syntax strict?

How do you mention strict requirements about data types in PHP?

What is the purpose declare Strict_types 1 function in PHP?