Cara tercepat untuk memeriksa apakah string JSON di PHP?

Saya membutuhkan metode yang sangat, sangat cepat untuk memeriksa apakah sebuah string adalah JSON atau tidak. Saya merasa ini bukan cara terbaik:

function isJson($string) {
    return ((is_string($string) &&
            (is_object(json_decode($string)) ||
            is_array(json_decode($string))))) ? true : false;
}

Adakah penggemar kinerja di luar sana yang ingin meningkatkan metode ini?

function isJson($string) {
 json_decode($string);
 return (json_last_error() == JSON_ERROR_NONE);
}

Jawab pertanyaan

Fungsi json_last_errormengembalikan kesalahan terakhir yang terjadi selama JSON encoding dan decoding. Jadi cara tercepat untuk memeriksa JSON yang valid adalah

// decode the JSON data
// set second parameter boolean TRUE for associative array output.
$result = json_decode($json);

if (json_last_error() === JSON_ERROR_NONE) {
    // JSON is valid
}

// OR this is equivalent

if (json_last_error() === 0) {
    // JSON is valid
}

Catatan yang json_last_errordidukung dalam PHP> = 5.3.0 saja.

Program lengkap untuk memeriksa GALAT yang tepat

Itu selalu baik untuk mengetahui kesalahan yang tepat selama waktu pengembangan. Berikut ini adalah program lengkap untuk memeriksa kesalahan yang sebenarnya berdasarkan pada dokumen PHP.

function json_validate($string)
{
    // decode the JSON data
    $result = json_decode($string);

    // switch and check possible JSON errors
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            $error = ''; // JSON is valid // No error has occurred
            break;
        case JSON_ERROR_DEPTH:
            $error = 'The maximum stack depth has been exceeded.';
            break;
        case JSON_ERROR_STATE_MISMATCH:
            $error = 'Invalid or malformed JSON.';
            break;
        case JSON_ERROR_CTRL_CHAR:
            $error = 'Control character error, possibly incorrectly encoded.';
            break;
        case JSON_ERROR_SYNTAX:
            $error = 'Syntax error, malformed JSON.';
            break;
        // PHP >= 5.3.3
        case JSON_ERROR_UTF8:
            $error = 'Malformed UTF-8 characters, possibly incorrectly encoded.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_RECURSION:
            $error = 'One or more recursive references in the value to be encoded.';
            break;
        // PHP >= 5.5.0
        case JSON_ERROR_INF_OR_NAN:
            $error = 'One or more NAN or INF values in the value to be encoded.';
            break;
        case JSON_ERROR_UNSUPPORTED_TYPE:
            $error = 'A value of a type that cannot be encoded was given.';
            break;
        default:
            $error = 'Unknown JSON error occured.';
            break;
    }

    if ($error !== '') {
        // throw the Exception or exit // or whatever :)
        exit($error);
    }

    // everything is OK
    return $result;
}

Menguji dengan INPUT JSON Valid

$json = '[{"user_id":13,"username":"stack"},{"user_id":14,"username":"over"}]';
$output = json_validate($json);
print_r($output);

OUTPUT yang valid

Array
(
    [0] => stdClass Object
        (
            [user_id] => 13
            [username] => stack
        )

    [1] => stdClass Object
        (
            [user_id] => 14
            [username] => over
        )
)

Menguji dengan JSON yang tidak valid

$json = '{background-color:yellow;color:#000;padding:10px;width:650px;}';
$output = json_validate($json);
print_r($output);

OUTPUT tidak valid

Syntax error, malformed JSON.

Catatan tambahan untuk (PHP> = 5.2 && PHP <5.3.0)

Karena json_last_errortidak didukung dalam PHP 5.2, Anda dapat memeriksa apakah penyandian atau decoding mengembalikan boolean FALSE. Berikut ini sebuah contoh

// decode the JSON data
$result = json_decode($json);
if ($result === FALSE) {
    // JSON is invalid
}

Semoga ini bermanfaat. Selamat Coding!

Yang perlu Anda lakukan hanyalah ini ...

if (is_object(json_decode($MyJSONArray))) 
{ 
    ... do something ...
}

Permintaan ini bahkan tidak memerlukan fungsi terpisah. Bungkus is_object sekitar json_decode dan lanjutkan. Tampaknya solusi ini membuat orang terlalu memikirkannya.

Menggunakan json_decode untuk "menyelidiki" itu mungkin sebenarnya bukan cara tercepat. Jika itu adalah struktur yang sangat bersarang, maka instantiasi banyak objek array untuk membuangnya adalah membuang-buang memori dan waktu.

Jadi mungkin lebih cepat untuk digunakan preg_matchdan regex RFC4627 juga memastikan validitas :

  // in JS:
  var my_JSON_object = !(/[^,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]/.test(
         text.replace(/"(\\.|[^"\\])*"/g, '')));

Hal yang sama di PHP:

  return !preg_match('/[^,:{}\\[\\]0-9.\\-+Eaeflnr-u \\n\\r\\t]/',
       preg_replace('/"(\\.|[^"\\\\])*"/', '', $json_string));

Namun, tidak cukup penggila kinerja yang peduli dengan tolok ukur di sini.

Ini akan mengembalikan true jika string Anda mewakili json array atau objek :

function isJson($str) {
    $json = json_decode($str);
    return $json && $str != $json;
}

Ini menolak string json yang hanya berisi angka, string atau boolean, meskipun string tersebut secara teknis valid json.

var_dump(isJson('{"a":5}')); // bool(true)
var_dump(isJson('[1,2,3]')); // bool(true)
var_dump(isJson('1')); // bool(false)
var_dump(isJson('1.5')); // bool(false)
var_dump(isJson('true')); // bool(false)
var_dump(isJson('false')); // bool(false)
var_dump(isJson('null')); // bool(false)
var_dump(isJson('hello')); // bool(false)
var_dump(isJson('')); // bool(false)

Ini adalah cara terpendek yang bisa saya lakukan.

Cara paling sederhana dan tercepat yang saya gunakan adalah mengikuti;

$json_array = json_decode( $raw_json , true );

if( $json_array == NULL )   //check if it was invalid json string
    die ('Invalid');  // Invalid JSON error

 // you can execute some else condition over here in case of valid JSON

Itu karena json_decode () mengembalikan NULL jika string yang dimasukkan bukan json atau json tidak valid.

Fungsi sederhana untuk memvalidasi JSON

Jika Anda harus memvalidasi JSON Anda di banyak tempat, Anda selalu dapat menggunakan fungsi berikut.

function is_valid_json( $raw_json ){
    return ( json_decode( $raw_json , true ) == NULL ) ? false : true ; // Yes! thats it.
}

Dalam fungsi di atas, Anda akan mendapatkan balasan jika itu adalah JSON yang valid.

function is_json($str){ 
    return json_decode($str) != null;
}

http://tr.php.net/manual/en/function.json-decode.php nilai kembali adalah nol ketika terdeteksi penyandian yang tidak valid.

Anda harus memvalidasi input Anda untuk memastikan string yang Anda lewati tidak kosong dan, pada kenyataannya, adalah string. String kosong bukan JSON yang valid.

function is_json($string) {
  return !empty($string) && is_string($string) && is_array(json_decode($string, true)) && json_last_error() == 0;
}

Saya pikir dalam PHP lebih penting untuk menentukan apakah objek JSON bahkan memiliki data, karena untuk menggunakan data Anda perlu menelepon json_encode()atau json_decode(). Saya sarankan menolak objek JSON kosong sehingga Anda tidak perlu menjalankan encode dan decode pada data kosong.

function has_json_data($string) {
  $array = json_decode($string, true);
  return !empty($string) && is_string($string) && is_array($array) && !empty($array) && json_last_error() == 0;
}

Ini akan melakukannya:

function isJson($string) {
    $decoded = json_decode($string); // decode our JSON string
    if ( !is_object($decoded) && !is_array($decoded) ) {
        /*
        If our string doesn't produce an object or array
        it's invalid, so we should return false
        */
        return false;
    }
    /*
    If the following line resolves to true, then there was
    no error and our JSON is valid, so we return true.
    Otherwise it isn't, so we return false.
    */
    return (json_last_error() == JSON_ERROR_NONE);
}

if ( isJson($someJsonString) ) {
    echo "valid JSON";
} else {
    echo "not valid JSON";
}

Seperti yang ditunjukkan dalam jawaban lain, json_last_error()mengembalikan kesalahan dari json_decode terakhir kami (). Namun ada beberapa kasus penggunaan tepi di mana fungsi ini saja tidak cukup komprehensif. Misalnya, jika Anda json_decode()bilangan bulat (misalnya:) 123, atau serangkaian angka tanpa spasi atau karakter lain (misalnya:) "123",json_last_error() fungsi tidak akan menangkap kesalahan.

Untuk mengatasi ini, saya telah menambahkan langkah ekstra yang memastikan hasil dari kami json_decode()adalah objek atau array. Jika tidak, maka kami kembalifalse .

Untuk melihat ini dalam tindakan, periksa dua contoh ini:

• Hanya periksa json_last_error()
• Memeriksa objek / array terlebih dahulu

Metode yang mudah adalah dengan memeriksa hasil json ..

$result = @json_decode($json,true);
    if (is_array($result)) {
        echo 'JSON is valid';
    }else{
        echo 'JSON is not valid';
    }

di GuzzleHttp :

/**
 * Wrapper for json_decode that throws when an error occurs.
 *
 * @param string $json    JSON data to parse
 * @param bool $assoc     When true, returned objects will be converted
 *                        into associative arrays.
 * @param int    $depth   User specified recursion depth.
 * @param int    $options Bitmask of JSON decode options.
 *
 * @return mixed
 * @throws \InvalidArgumentException if the JSON cannot be decoded.
 * @link http://www.php.net/manual/en/function.json-decode.php
 */
function json_decode($json, $assoc = false, $depth = 512, $options = 0)
{
    $data = \json_decode($json, $assoc, $depth, $options);
    if (JSON_ERROR_NONE !== json_last_error()) {
        throw new \InvalidArgumentException(
            'json_decode error: ' . json_last_error_msg());
    }

    return $data;
}

/**
 * Wrapper for JSON encoding that throws when an error occurs.
 *
 * @param mixed $value   The value being encoded
 * @param int    $options JSON encode option bitmask
 * @param int    $depth   Set the maximum depth. Must be greater than zero.
 *
 * @return string
 * @throws \InvalidArgumentException if the JSON cannot be encoded.
 * @link http://www.php.net/manual/en/function.json-encode.php
 */
function json_encode($value, $options = 0, $depth = 512)
{
    $json = \json_encode($value, $options, $depth);
    if (JSON_ERROR_NONE !== json_last_error()) {
        throw new \InvalidArgumentException(
            'json_encode error: ' . json_last_error_msg());
    }

    return $json;
}

Sebelumnya saya hanya memeriksa nilai null, yang sebenarnya salah.

    $data = "ahad";
    $r_data = json_decode($data);
    if($r_data){//json_decode will return null, which is the behavior we expect
        //success
    }

Sepotong kode di atas berfungsi baik dengan string. Namun begitu saya memberikan nomor, itu putus. Misalnya.

    $data = "1213145";
    $r_data = json_decode($data);

    if($r_data){//json_decode will return 1213145, which is the behavior we don't expect
        //success
    }

Untuk memperbaikinya apa yang saya lakukan sangat sederhana.

    $data = "ahad";
    $r_data = json_decode($data);

    if(($r_data != $data) && $r_data)
        print "Json success";
    else
        print "Json error";

//Tested thoroughly, Should do the job:
public static function is_json(string $json):bool
{
    json_decode($json);
    if (json_last_error() === JSON_ERROR_NONE) {
        return true;
    }
    return false;
}

Cara sederhana lainnya

function is_json($str)
{
    return is_array(json_decode($str,true));
}

Kita perlu memeriksa apakah string yang dikirimkan bukan numerik karena dalam kasus ini json_decode tidak menimbulkan kesalahan.

function isJson($str) {
    $result = false;
    if (!preg_match("/^\d+$/", trim($str))) {
        json_decode($str);
        $result = (json_last_error() == JSON_ERROR_NONE);
    }

    return $result;
}

Saya menemukan pertanyaan ini setelah menemukan sesuatu yang serupa dalam pekerjaan saya, kemarin. Solusi saya pada akhirnya adalah gabungan dari beberapa pendekatan di atas:

function is_JSON($string) {

  $String_Is_JSON = (is_null(json_decode($string, TRUE))) ? FALSE : TRUE;

  return $String_Is_JSON;
}

Saya sudah mencoba beberapa solusi itu tetapi tidak ada yang berhasil untuk saya. Saya mencoba hal sederhana ini:

$isJson = json_decode($myJSON);

if ($isJson instanceof \stdClass || is_array($isJson)) {
   echo("it's JSON confirmed");
} else {
   echo("nope");
}

Saya pikir ini solusi yang baik sejak JSON decode tanpa parameter kedua memberikan objek.

EDIT: Jika Anda tahu apa yang akan menjadi input, Anda dapat menyesuaikan kode ini dengan kebutuhan Anda. Dalam kasus saya, saya tahu saya memiliki Json yang dimulai dengan "{", jadi saya tidak perlu memeriksa apakah itu array.

Menggunakan PHPBench dengan kelas berikut, hasil di bawah ini dicapai:

<?php

declare(strict_types=1);

/**
 * Benchmark doctrine persistent collection count method vs sizeof toArray
 * Revs is the number of times you want the benchmark to run
 * @Revs(1000)
 * @Iterations(100)
 */
class BenchmarkJson
{
    public function benchCatchValid(): bool
    {
        $validJson = '{"validJson":true}';
        try {
            json_decode($validJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchCatchInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        try {
            json_decode($invalidJson, true, 512, JSON_THROW_ON_ERROR);
            return true;
        } catch(\JsonException $exception) {}
        return false;
    }

    public function benchLastErrorValid(): bool
    {
        $validJson = '{"validJson":true}';
        json_decode($validJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchLastErrorInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        json_decode($invalidJson, true);
        return (json_last_error() === JSON_ERROR_NONE);
    }

    public function benchNullValid(): bool
    {
        $validJson = '{"validJson":true}';
        return (json_decode($validJson, true) !== null);
    }

    public function benchNullInvalid(): bool
    {
        $invalidJson = '{"invalidJson"';
        return (json_decode($invalidJson, true) !== null);
    }
}

6 subjects, 600 iterations, 6,000 revs, 0 rejects, 0 failures, 0 warnings
(best [mean mode] worst) = 0.714 [1.203 1.175] 1.073 (μs)
⅀T: 721.504μs μSD/r 0.089μs μRSD/r: 7.270%
suite: 1343ab9a3590de6065bc0bc6eeb344c9f6eba642, date: 2020-01-21, stime: 12:50:14
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| benchmark     | subject               | set | revs | its | mem_peak   | best    | mean    | mode    | worst   | stdev   | rstdev | diff  |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+
| BenchmarkJson | benchCatchValid       | 0   | 1000 | 100 | 2,980,168b | 0.954μs | 1.032μs | 1.016μs | 1.428μs | 0.062μs | 6.04%  | 1.33x |
| BenchmarkJson | benchCatchInvalid     | 0   | 1000 | 100 | 2,980,184b | 2.033μs | 2.228μs | 2.166μs | 3.001μs | 0.168μs | 7.55%  | 2.88x |
| BenchmarkJson | benchLastErrorValid   | 0   | 1000 | 100 | 2,980,184b | 1.076μs | 1.195μs | 1.169μs | 1.616μs | 0.083μs | 6.97%  | 1.54x |
| BenchmarkJson | benchLastErrorInvalid | 0   | 1000 | 100 | 2,980,184b | 0.785μs | 0.861μs | 0.863μs | 1.132μs | 0.056μs | 6.54%  | 1.11x |
| BenchmarkJson | benchNullValid        | 0   | 1000 | 100 | 2,980,168b | 0.985μs | 1.124μs | 1.077μs | 1.731μs | 0.114μs | 10.15% | 1.45x |
| BenchmarkJson | benchNullInvalid      | 0   | 1000 | 100 | 2,980,184b | 0.714μs | 0.775μs | 0.759μs | 1.073μs | 0.049μs | 6.36%  | 1.00x |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+

Kesimpulan: Cara tercepat untuk memeriksa apakah json valid adalah kembali json_decode($json, true) !== null).

Saya tidak tahu tentang kinerja atau keanggunan solusi saya, tetapi itulah yang saya gunakan:

if (preg_match('/^[\[\{]\"/', $string)) {
    $aJson = json_decode($string, true);
    if (!is_null($aJson)) {
       ... do stuff here ...
    }
}

Karena semua string JSON saya yang dikodekan dimulai dengan {"cukup untuk menguji untuk ini dengan RegEx. Saya sama sekali tidak fasih dengan RegEx, jadi mungkin ada cara yang lebih baik untuk melakukan ini. Juga: strpos () mungkin lebih cepat.

Hanya mencoba untuk memberikan nilai kemampuan saya.

PS Baru saja memperbarui string RegEx /^[\[\{]\"/untuk juga menemukan string array JSON. Jadi sekarang terlihat baik ["atau {" di awal string.

Seharusnya seperti ini:

 function isJson($string)
 {
    // 1. Speed up the checking & prevent exception throw when non string is passed
    if (is_numeric($string) ||
        !is_string($string) ||
        !$string) {
        return false;
    }

    $cleaned_str = trim($string);
    if (!$cleaned_str || !in_array($cleaned_str[0], ['{', '['])) {
        return false;
    }

    // 2. Actual checking
    $str = json_decode($string);
    return (json_last_error() == JSON_ERROR_NONE) && $str && $str != $string;
}

UnitTest

public function testIsJson()
{
    $non_json_values = [
        "12",
        0,
        1,
        12,
        -1,
        '',
        null,
        0.1,
        '.',
        "''",
        true,
        false,
        [],
        '""',
        '[]',
        '   {',
        '   [',
    ];

   $json_values = [
        '{}',
        '{"foo": "bar"}',
        '[{}]',
        '  {}',
        ' {}  '
    ];

   foreach ($non_json_values as $non_json_value) {
        $is_json = isJson($non_json_value);
        $this->assertFalse($is_json);
    }

    foreach ($json_values as $json_value) {
        $is_json = isJson($json_value);
        $this->assertTrue($is_json);
    }
}

Memperluas jawaban ini Bagaimana dengan yang berikut:

<?php

    $json = '[{"user_id":13,"username":"stack"},{"user_id":14,"username":"over"}]';
    //$json = '12';

    function isJson($string) {
        json_decode($string);
        if(json_last_error() == JSON_ERROR_NONE) {
            if(substr($string,0,1) == '[' && substr($string,-1) == ']') { return TRUE; }
            else if(substr($string,0,1) == '{' && substr($string,-1) == '}') { return TRUE; }
            else { return FALSE; }
        }
    }

    echo isJson($json);
?>

Hai, ini potongan kecil dari perpustakaan saya, dalam kondisi pertama ini saya hanya memeriksa apakah data json kemudian mengembalikannya jika diterjemahkan dengan benar, harap perhatikan penggunaan substr untuk kinerja (saya belum melihat file json apa pun yang tidak memulai juga oleh {atau [

$input=trim($input);
if ((substr($input, 0, 1) == '{' && substr($input, -1) == '}') or (substr($input, 0, 1) == '[' && substr($input, -1) == ']')) {
    $output = json_decode($input, 1);
    if (in_array(gettype($output),['object','array'])) {
        #then it's definitely JSON
    }
}

Cara tercepat untuk mungkin memecahkan kode objek JSON mungkin untuk PHP objek / array:

/**
 * If $value is a JSON encoded object or array it will be decoded 
 * and returned.
 * If $value is not JSON format, then it will be returned unmodified.
 */
function get_data( $value ) {
    if ( ! is_string( $value ) ) { return $value; }
    if ( strlen( $value ) < 2 ) { return $value; }
    if ( '{' != $value[0] && '[' != $value[0] ) { return $value; }

    $json_data = json_decode( $value );
    if ( ! $json_data ) { return $value; }
    return $json_data;
}

Berikut ini adalah performa dan fungsi sederhana yang saya buat (yang menggunakan validasi string dasar sebelum digunakan json_decodeuntuk string yang lebih besar):

function isJson($string) {
    $response = false;

    if (
        is_string($string) &&
        ($string = trim($string)) &&
        ($stringLength = strlen($string)) &&
        (
            (
                stripos($string, '{') === 0 &&
                (stripos($string, '}', -1) + 1) === $stringLength
            ) ||
            (
                stripos($string, '[{') === 0 &&
                (stripos($string, '}]', -1) + 2) === $stringLength
            )
        ) &&
        ($decodedString = json_decode($string, true)) &&
        is_array($decodedString)
    ) {
        $response = true;
    }

    return $response;
}