PHP7.1 json_encode() Float Issue

As a plugin developer I don't have general access to the php.ini settings of a server. So, based on Machavity's answer I wrote this small piece of code that you can use in your PHP script. Simply put it on top of the script and json_encode will keep working as usual.

if (version_compare(phpversion(), '7.1', '>=')) {
    ini_set( 'serialize_precision', -1 );
}

In some cases it is necessary to set one more variable. I am adding this as a second solution because I am not sure if the second solution works fine in all cases where the first solution has proven to work.

if (version_compare(phpversion(), '7.1', '>=')) {
    ini_set( 'precision', 17 );
    ini_set( 'serialize_precision', -1 );
}

I solved this by setting both precision and serialize_precision to the same value (10):

ini_set('precision', 10);
ini_set('serialize_precision', 10);

You can also set this in your php.ini

I was encoding monetary values and had things like 330.46 encoding to 330.4600000000000363797880709171295166015625. If you don't wish to, or can't, change the PHP settings and you know the structure of the data in advance there is a very simple solution that worked for me. Simply cast it to a string (both the following do the same thing):

$data['discount'] = (string) $data['discount'];
$data['discount'] = '' . $data['discount'];

For my use case this was a quick and effective solution. Just note that this means when you decode it back from JSON it will be a string since it'll be wrapped in double quotes.

On php 7.2.32 the solution was to set in php.ini:

precision=10
serialize_precision=10

I had the same problem but only serialize_precision = -1 did not solve the problem. I had to do one more step, to update the value of precision from 14 to 17 (as it was set on my PHP7.0 ini file). Apparently, changing the value of that number changes the value of the computed float.

$val1 = 5.5;
$val2 = (1.055 - 1) * 100;
$val3 = (float)(string) ((1.055 - 1) * 100);
var_dump(json_encode(['val1' => $val1, 'val2' => $val2, 'val3' => $val3]));

{
  "val1": 5.5,
  "val2": 5.499999999999994,
  "val3": 5.5
}

Store it as a string with the exact precision that you need by using number_format, then json_encode it using the JSON_NUMERIC_CHECK option:

$foo = array('max' => number_format(472.185, 3, '.', ''));
print_r(json_encode($foo, JSON_NUMERIC_CHECK));

You get:

{"max": 472.185}

Note that this will get ALL numeric strings in your source object to be encoded as numbers in the resulting JSON.

As for me the problem was when JSON_NUMERIC_CHECK as second argument of json_encode () was passed, which casting all (not only integer) numbers type to int.

It seems like the problem occurs when serialize and serialize_precision are set to different values. In my case 14 and 17 respectively. Setting them both to 14 resolved the issue, as did setting serialize_precision to -1.

The default value of serialize_precision was changed to -1 as of PHP 7.1.0 which means "an enhanced algorithm for rounding such numbers will be used". But if you are still experiencing this issue, it may be because you have a PHP config file in place from a prior version. (Maybe you kept your config file when you upgraded?)

Another thing to consider is if it makes sense to be using float values at all in your case. It may or may not make sense to use string values containing your numbers to ensure the proper number of decimal places is always retained in your JSON.

As others pointed out, the issue is due to the serialize_precision PHP setting in certain servers: WHM, Local WP, etc.

Here's a simple safe_json_encode function that changes the PHP setting, spits out the correct json_encode, and finally restores the setting to the original value:

/**
 * Encode the given array to JSON, avoiding float values being arbitrarily
 * added decimals.
 *
 * @link https://stackoverflow.com/questions/42981409/php7-1-json-encode-float-issue
 */
function safe_json_encode($array, $flags = 0)
{
    // Set the precision to the same value as the precision setting
    // to avoid float values being arbitrarily added decimals.
    $precision = ini_get('precision');
    $originalSerializePrecision = ini_get('serialize_precision');
    if ($originalSerializePrecision !== $precision) {
        ini_set('serialize_precision', $precision);
    }

    // Encode the array to JSON
    $json = json_encode($array, $flags);

    // Restore the original serialize precision
    if ($originalSerializePrecision !== ini_get('serialize_precision')) {
        ini_set('serialize_precision', $originalSerializePrecision);
    }

    return $json;
}

Test it with

echo safe_json_encode(array(472.185, round("45.99", 2)));

and it should return "[472.185,45.99]" as expected.

Same issue. On PHP 7.4 I tried different solutions but only this combination worked for me:

precision = 14
serialize_precision = 14

I did not want to mess with serialize_precision so I wrote my own simple encoder:

function JsonEncode($data) {
    $tr = [
        '"' => '\\"',
        '\\' => '\\\\',
        '/' => '\\/',
        "\010" => '\\b',
        "\f" => '\\f',
        "\n" => '\\n',
        "\r" => '\\r',
        "\t" => '\\t'
    ];
    if (is_object($data)) {
        $list = [];
        foreach (get_object_vars($data) as $k => $v) {
            $list[] = sprintf('"%s":%s', strtr($k, $tr), JsonEncode($v));
        }
        $json = sprintf('{%s}', implode(',', $list));
    } elseif (is_array($data)) {
        $list = [];
        foreach ($data as $v) {
            $list[] = JsonEncode($v);
        }
        $json = sprintf('[%s]', implode(',', $list));
    } elseif (is_string($data)) {
        $json = sprintf('"%s"', strtr($data, $tr));
    } elseif (is_bool($data)) {
        $json = $data ? "true" : "false";
    } elseif (is_null($data)) {
        $json = 'null';
    } else {
        $json = (string)$data;
    }
    return $json;
}