Tengo este objeto JSON almacenado en un archivo de texto sin formato:

{
    "MySQL": {
        "Server": "(server)",
        "Username": "(user)",
        "Password": "(pwd)",
        "DatabaseName": "(dbname)"
    },
    "Ftp": {
        "Server": "(server)",
        "Username": "(user)",
        "Password": "(pwd)",
        "RootFolder": "(rf)"
    },
    "BasePath": "../../bin/",
    "NotesAppPath": "notas",
    "SearchAppPath": "buscar",
    "BaseUrl": "http:\/\/montemaiztusitio.com.ar",
    "InitialExtensions": [
        "nem.mysqlhandler",
        "nem.string",
        "nem.colour",
        "nem.filesystem",
        "nem.rss",
        "nem.date",
        "nem.template",
        "nem.media",
        "nem.measuring",
        "nem.weather",
        "nem.currency"
    ],
    "MediaPath": "media",
    "MediaGalleriesTable": "journal_media_galleries",
    "MediaTable": "journal_media",
    "Journal": {
        "AllowedAdFileFormats": [
            "flv:1",
            "jpg:2",
            "gif:3",
            "png:4",
            "swf:5"
        ],
        "AdColumnId": "3",
        "RSSLinkFormat": "%DOMAIN%\/notas\/%YEAR%-%MONTH%-%DAY%\/%TITLE%/",
        "FrontendLayout": "Flat",
        "AdPath": "ad",
        "SiteTitle": "Monte Maíz: Tu Sitio",
        "GlobalSiteDescription": "Periódico local de Monte Maíz.",
        "MoreInfoAt": "Más información aquí, en el Periódico local de Monte Maíz.",
        "TemplatePath": "templates",
        "WeatherSource": "accuweather:SAM|AR|AR005|MONTE MAIZ",
        "WeatherMeasureType": "1",
        "CurrencySource": "cotizacion-monedas:Dolar|Euro|Real",
        "TimesSingular": "vez",
        "TimesPlural": "veces"
    }
}

Cuando intento decodificarlo json_decode(), devuelve NULL. ¿Por qué? El archivo es legible (intenté hacer eco file_get_contents()y funcionó bien).

Probé JSON contra http://jsonlint.com/ y es perfectamente válido.

¿Qué pasa aquí?

Solución

Buscando respuestas en Google, volví a SO: json_decode devuelve NULL después de la llamada al servicio web . Mi archivo JSON tenía la secuencia UTF BOM (algunos caracteres binarios que no deberían estar allí), rompiendo así la estructura JSON. Fui al editor hexadecimal, borré los bytes. Todo volvió a la normalidad. ¿Por qué ha sucedido esto? Porque edité el archivo usando el Bloc de notas de Microsoft Windows. ¡Terrible idea!

Podría ser la codificación de los caracteres especiales. Puede pedirle a json_last_error () que obtenga información definitiva.

Actualización: el problema está resuelto, consulte el párrafo "Solución" de la pregunta.

Esto funcionó para mi

json_decode( preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $json_string), true );

Podrías intentarlo.

json_decode(stripslashes($_POST['data']))

Si marca la solicitud en Chrome, verá que el JSON es texto, por lo que se ha agregado un código en blanco al JSON.

Puedes borrarlo usando

$k=preg_replace('/\s+/', '',$k);

Entonces puedes usar:

json_decode($k)

print_r luego mostrará la matriz.

Tuve el mismo problema y lo resolví simplemente reemplazando el carácter de cita antes de decodificar.

$json = str_replace('"', '"', $json);
$object = json_decode($json);

Mi valor JSON fue generado por la función JSON.stringify.

Tal vez algunos personajes ocultos estén jugando con su json, intente esto:

$json = utf8_encode($yourString);
$data = json_decode($json);

$k=preg_replace('/\s+/', '',$k); 

lo hizo por mí. Y sí, probando en Chrome. Gracias al usuario2254008

Solo pensé en agregar esto, ya que me encontré con este problema hoy. Si hay algún relleno de cadena alrededor de su cadena JSON, json_decode devolverá NULL.

Si está extrayendo el JSON de una fuente que no sea una variable de PHP, sería prudente "recortarlo" primero:

$jsonData = trim($jsonData);

esto le ayudará a comprender cuál es el tipo de error

<?php
// A valid json string
$json[] = '{"Organization": "PHP Documentation Team"}';

// An invalid json string which will cause an syntax 
// error, in this case we used ' instead of " for quotation
$json[] = "{'Organization': 'PHP Documentation Team'}";


foreach ($json as $string) {
    echo 'Decoding: ' . $string;
    json_decode($string);

    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            echo ' - No errors';
        break;
        case JSON_ERROR_DEPTH:
            echo ' - Maximum stack depth exceeded';
        break;
        case JSON_ERROR_STATE_MISMATCH:
            echo ' - Underflow or the modes mismatch';
        break;
        case JSON_ERROR_CTRL_CHAR:
            echo ' - Unexpected control character found';
        break;
        case JSON_ERROR_SYNTAX:
            echo ' - Syntax error, malformed JSON';
        break;
        case JSON_ERROR_UTF8:
            echo ' - Malformed UTF-8 characters, possibly incorrectly encoded';
        break;
        default:
            echo ' - Unknown error';
        break;
    }

    echo PHP_EOL;
}
?>

Solo guarda algo una vez. Pasé 3 horas para descubrir que era solo un problema de codificación html. Prueba esto

if(get_magic_quotes_gpc()){
   $param = stripslashes($row['your column name']);
}else{
  $param = $row['your column name'];
}

$param = json_decode(html_entity_decode($param),true);
$json_errors = array(
JSON_ERROR_NONE => 'No error has occurred',
JSON_ERROR_DEPTH => 'The maximum stack depth has been exceeded',
JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded',
JSON_ERROR_SYNTAX => 'Syntax error',
);
echo 'Last error : ', $json_errors[json_last_error()], PHP_EOL, PHP_EOL;
print_r($param);

Como lo indicó Jürgen Math, el uso del método preg_replace enumerado por user2254008 también lo solucionó para mí.

Esto no se limita a Chrome, parece ser un problema de conversión de juego de caracteres (al menos en mi caso, Unicode -> UTF8) Esto solucionó todos los problemas que estaba teniendo.

Como nodo futuro, el objeto JSON que estaba decodificando provino de la función json.dumps de Python. Esto, a su vez, provocó que otros datos insalubres aparecieran, aunque se trató fácilmente.

Si obtiene json de la base de datos, coloque

mysqli_set_charset($con, "utf8");

después de definir el enlace de conexión $ con

Aquí puede encontrar un pequeño contenedor JSON con acciones correctivas que abordan el problema de BOM y no ASCI: https://stackoverflow.com/a/43694325/2254935

En mi caso, se debe a la comilla simple en la cadena JSON.

El formato JSON solo acepta comillas dobles para claves y valores de cadena.

Ejemplo:

$jsonString = '{\'hello\': \'PHP\'}'; // valid value should be '{"hello": "PHP"}'
$json = json_decode($jsonString);
print $json; // null

Tengo esto confundido debido a la sintaxis de Javascript. En Javascript, por supuesto, podemos hacer así:

let json = {
    hello: 'PHP' // no quote for key, single quote for string value
}

// OR:
json = {
    'hello': 'PHP' // single quote for key and value
}

pero más tarde, cuando convierta esos objetos en una cadena JSON:

JSON.stringify(json); // "{"hello":"PHP"}"

Resolví este problema imprimiendo el JSON y luego verificando la fuente de la página (CTRL / CMD + U):

print_r(file_get_contents($url));

Resultó que había una <pre>etiqueta al final .

deberías asegurarte estos puntos

1. su cadena json no tiene caracteres desconocidos

2. la cadena json se puede ver desde el visor json en línea (puede buscar en google como visor o analizador en línea para json) debería verse sin ningún error

3. su cadena no tiene entidades html, debe ser texto sin formato / cadena

para la explicación del punto 3

$html_product_sizes_json=htmlentities($html);
    $ProductSizesArr = json_decode($html_product_sizes_json,true);

para (eliminar la función htmlentities ())

$html_product_sizes_json=$html;
    $ProductSizesArr = json_decode($html_product_sizes_json,true);

Para mí, tuve que desactivar el error_reporting para que json_decode () funcione correctamente. Suena extraño, pero cierto en mi caso. Porque hay un aviso impreso entre la cadena JSON que estoy tratando de decodificar.

Lo más importante que debe recordar, cuando obtiene un resultado NULL de datos JSON que es válido es usar el siguiente comando:

json_last_error_msg();

Es decir.

var_dump(json_last_error_msg());
string(53) "Control character error, possibly incorrectly encoded"

Luego arregla eso con:

$new_json = preg_replace('/[[:cntrl:]]/', '', $json);

Entonces, html_entity_decode () funcionó para mí. Por favor intente esto.

$input = file_get_contents("php://input");
$input = html_entity_decode($input);
$event_json = json_decode($input,true);

<?php 
$json_url = "http://api.testmagazine.com/test.php?type=menu";
$json = file_get_contents($json_url);
$json=str_replace('},

]',"}

]",$json);
$data = json_decode($json);

echo "<pre>";
print_r($data);
echo "</pre>";
?>