Perché json_encode restituisce una stringa vuota

Ho una semplice struttura php con 3 array annidati.

Non utilizzo oggetti particolari e costruisco io stesso gli array con 2 loop annidati.

Ecco un esempio del var_dump dell'array che voglio convertire in Json.

array (size=2)
  'tram B' => 
    array (size=2)
      0 => 
        array (size=3)
          'name' => string 'Ile Verte' (length=9)
          'distance' => int 298
          'stationID' => int 762
      1 => 
        array (size=3)
          'name' => string 'La Tronche Hôpital' (length=18)
          'distance' => int 425
          'stationID' => int 771
  16 => 
    array (size=4)
      0 => 
        array (size=3)
          'name' => string 'Bastille' (length=8)
          'distance' => int 531
          'stationID' => int 397
      1 => 
        array (size=3)
          'name' => string 'Xavier Jouvin' (length=13)
          'distance' => int 589
          'stationID' => int 438

In un altro script ho una struttura simile e json_encodefunziona bene. Quindi non capisco perché json_encodenon funzionerà qui.

Modifica: sembra esserci un problema con la codifica. Quando mb_detect_encodingrestituisce ASCII, json_encodefunziona ma quando restituisce UTF8, non funziona più.

Modifica2: json_last_error()restituisce JSON_ERROR_UTF8che significa: caratteri UTF-8 malformati , probabilmente codificati in modo errato .

Bene dopo 2 ore di scavo (cfr Modifiche)

Ho scoperto quanto segue:

• Nel mio caso è un problema di codifica
• mb_detect_encoding restituisce probabilmente una risposta errata, alcune stringhe probabilmente non erano UTF-8
• l'uso utf8_encode()su quelle stringhe ha risolto il mio problema, ma vedi la nota sotto

Ecco una funzione ricorsiva che può forzare la conversione in UTF-8 di tutte le stringhe contenute in un array:

function utf8ize($d) {
    if (is_array($d)) {
        foreach ($d as $k => $v) {
            $d[$k] = utf8ize($v);
        }
    } else if (is_string ($d)) {
        return utf8_encode($d);
    }
    return $d;
}

Usalo semplicemente in questo modo:

echo json_encode(utf8ize($data));

Nota: utf8_encode () codifica la stringa ISO-8859-1 in UTF-8 come da documentazione, quindi se non sei sicuro della codifica di input iconv () o mb_convert_encoding () potrebbero essere opzioni migliori come indicato nei commenti e in altre soluzioni.

Matthieu Riegler ha presentato una soluzione davvero buona, tuttavia ho dovuto modificarla leggermente per gestire anche gli oggetti:

function utf8ize($d) {
    if (is_array($d)) 
        foreach ($d as $k => $v) 
            $d[$k] = utf8ize($v);

     else if(is_object($d))
        foreach ($d as $k => $v) 
            $d->$k = utf8ize($v);

     else 
        return utf8_encode($d);

    return $d;
}

Un'altra nota: json_last_error () può essere utile nel debug delle funzioni json_encode () / json_encode ().

Per me, la risposta a questo problema è stata l'impostazione charset=utf8nella mia connessione PDO.

$dbo = new PDO('mysql:host=localhost;dbname=yourdb;charset=utf8', $username, $password);

Adam Bubela ha anche presentato una soluzione davvero buona che mi ha aiutato a risolvere il mio problema, ed ecco la funzione semplificata:

function utf8ize($d)
{ 
    if (is_array($d) || is_object($d))
        foreach ($d as &$v) $v = utf8ize($v);
    else
        return utf8_encode($d);

    return $d;
}

Ho esattamente lo stesso problema su PHP 5.6. Uso Open Server + Nginx su Windows 7. Tutti i set di caratteri sono impostati su UTF-8. In teoria, secondo la documentazione ufficiale , flag

JSON_UNESCAPED_UNICODE

dovrebbe risolvere questo problema. Purtroppo questo non è il mio caso. Non so perché. Tutti gli snippet di cui sopra non risolvono il mio problema, quindi ho trovato la mia implementazione. Credo che potrebbe aiutare qualcuno. Almeno, le lettere russe superano il test.

function utf8ize($d) {
    if (is_array($d) || is_object($d)) {
        foreach ($d as &$v) $v = utf8ize($v);
    } else {
        $enc   = mb_detect_encoding($d);

        $value = iconv($enc, 'UTF-8', $d);
        return $value;
    }

    return $d;
}

Questa risposta accettata funziona. Ma nel caso tu stia ottenendo i tuoi dati da MySQL (come me) c'è un modo più semplice.

Una volta aperto il database, prima di eseguire una query è possibile impostare il set di caratteri utilizzando mysqli come segue:

/* change character set to utf8 | Procedural*/
if (!mysqli_set_charset($link, "utf8")) {
    printf("Error loading character set utf8: %s\n", mysqli_error($link));
    exit();
}

O

/* change character set to utf8 | Object Oriented*/
if (!$mysqli->set_charset("utf8")) {
        printf("Error loading character set utf8: %s\n", $mysqli->error);
        exit();
 }

LINK: http://php.net/manual/en/mysqli.set-charset.php

Ho riscontrato questo problema su un server che esegue una versione precedente di PHP (5.2). Stavo usando il flag JSON_FORCE_OBJECT e apparentemente non è supportato fino alla 5.3

Quindi se stai usando quel flag assicurati di controllare la tua versione!

Una soluzione alternativa sembra essere solo il casting su un oggetto prima della codifica, come:

json_encode((object)$myvar);

La restituzione di mb_detect_encodingpotrebbe non essere corretta:

$data = iconv('UTF-8', 'ISO-8859-1', 'La Tronche Hôpital');
var_dump(
    mb_detect_encoding($data),
    mb_detect_encoding($data, array('ISO-8859-1', 'UTF-8'))
);

A seconda dell'ordine di rilevamento predefinito, quanto sopra può restituire risultati diversi, quindi la codifica viene erroneamente segnalata come UTF-8. ( Ecco un esempio più ampio .)

È probabile che i tuoi dati non siano codificati come UTF-8, quindi json_encodestanno tornando false. Dovresti esaminare la conversione delle stringhe in UTF-8 prima della codifica JSON:

$fromEncoding = 'ISO-8859-1'; // This depends on the data

array_walk_recursive($array, function (&$value, $key, $fromEncoding) {
    if (is_string($value)) {
        $value = iconv($fromEncoding, 'UTF-8', $value);
    }
}, $fromEncoding);

Stavo ottenendo dati da ob_get_clean () e ho avuto lo stesso problema, ma le soluzioni precedenti non funzionano per me. Nel mio caso la soluzione era questa, forse avrebbe aiutato qualcuno.

$var = mb_convert_encoding($var, 'UTF-8');

l'utilizzo di utf8_encode () su quelle stringhe ha risolto il mio problema.

Ho migliorato la risposta di Adam Bubela. Odio solo quando i blocchi non vengono chiusi da {e}. È più pulito e non introduci bug o forse è che ho usato Perl in passato :)

<?php

class App_Updater_String_Util {    
    /**
     * Usage: App_Updater_String_Util::utf8_encode( $data );
     *
     * @param mixed $d
     * @return mixed
     * @see http://stackoverflow.com/questions/19361282/why-would-json-encode-returns-an-empty-string
     */
    public static function utf8_encode($d) {
        if (is_array($d)) {
            foreach ($d as $k => $v) {
                $d[$k] = self::utf8_encode($v);
            }
        } elseif (is_object($d)) {
            foreach ($d as $k => $v) {
                $d->$k = self::utf8_encode($v);
            }
        } elseif (is_scalar($d)) {
            $d = utf8_encode($d);
        }

        return $d;
    }
}

?>

Se ottieni questi dati da un database, usali mysqli_set_charset($connection, "utf8");in connessione quando ottieni i parametri dal database

questo problema si verifica a volte: non stai passando il controllo dell'accesso all'intestazione.

Nel mio caso, se mi è stato aggiunto un echo prima di json_encode. Mostrava il risultato altrimenti stava arrivando una pagina vuota.

Ho aggiunto

header('Access-Control-Allow-Origin: *'); 

e il mio problema è stato risolto.