PHP에서 문자열이 JSON인지 확인하는 가장 빠른 방법은 무엇입니까?

문자열이 JSON인지 여부를 확인하는 정말 빠르고 빠른 방법이 필요합니다. 나는 이것이 최선의 방법이 아니라고 생각합니다.

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

성능 애호가라면이 방법을 개선하고 싶습니까?

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

질문에 대한 답변

이 함수 json_last_error는 JSON 인코딩 및 디코딩 중에 발생한 마지막 오류를 반환합니다. 유효한 JSON을 확인하는 가장 빠른 방법은

// 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
}

참고 json_last_errorPHP에서 지원됩니다> = 5.3.0 만.

정확한 오류를 확인하는 전체 프로그램

개발 시간 동안 정확한 오류를 아는 것이 항상 좋습니다. 다음은 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;
}

유효한 JSON INPUT으로 테스트

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

유효한 출력

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

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

잘못된 JSON으로 테스트

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

잘못된 출력

Syntax error, malformed JSON.

(PHP> = 5.2 && PHP <5.3.0)에 대한 추가 참고 사항

json_last_errorPHP 5.2에서는 지원되지 않기 때문에 인코딩 또는 디코딩이 boolean을 반환하는지 확인할 수 있습니다 FALSE. 여기에 예가 있습니다

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

이것이 도움이 되길 바랍니다. 행복한 코딩!

당신이 정말로해야 할 일은 이것입니다 ...

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

이 요청에는 별도의 기능도 필요하지 않습니다. json_decode 주위에 is_object를 감싸고 계속 진행하십시오. 이 솔루션으로 사람들이 너무 많은 생각을하고있는 것 같습니다.

사용 json_decode"프로브"에 실제로 가장 빠른 방법하지 않을 수 있습니다. 깊게 중첩 된 구조라면 배열의 많은 객체를 인스턴스화하여 버리는 것은 메모리와 시간 낭비입니다.

더 빨리 될 수 있도록 사용 preg_match과 RFC4627의 정규식 에 또한 유효 기간을 확인 :

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

PHP에서도 마찬가지입니다 :

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

그러나 벤치마킹에 신경 쓸만한 성능 애호가는 충분하지 않습니다.

문자열이 json 배열 또는 객체를 나타내는 경우 true 를 반환 합니다 .

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

기술적으로 유효한 json이지만 숫자, 문자열 또는 부울 만 포함하는 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)

내가 생각해 낼 수있는 가장 짧은 방법입니다.

내가 사용하는 가장 간단하고 빠른 방법은 다음과 같습니다.

$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

입력 한 문자열이 json이 아니거나 유효하지 않은 json이 아닌 경우 json_decode () 가 NULL을 리턴 하기 때문 입니다.

JSON을 검증하는 간단한 기능

여러 곳에서 JSON의 유효성을 검사해야하는 경우 언제든지 다음 기능을 사용할 수 있습니다.

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

위 함수에서 유효한 JSON 인 경우 대가로 반환됩니다.

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

잘못된 인코딩이 감지되면 http://tr.php.net/manual/en/function.json-decode.php 반환 값이 null입니다.

전달한 문자열이 비어 있지 않고 실제로 문자열인지 확인하려면 입력의 유효성을 검사해야합니다. 빈 문자열은 유효한 JSON이 아닙니다.

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

PHP에서는 JSON 객체 에 데이터 가 있는지 확인하는 것이 더 중요하다고 생각 합니다. 데이터를 사용하려면 json_encode()또는 을 사용해야하기 때문 json_decode()입니다. 빈 JSON 객체를 거부하여 빈 데이터에서 불필요하게 인코딩 및 디코딩을 실행하지 않는 것이 좋습니다.

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;
}

이것은 그것을 할 것입니다 :

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";
}

다른 답변에 표시된 것처럼 json_last_error()마지막 json_decode ()에서 오류를 반환합니다. 그러나이 기능만으로는 충분하지 않은 일부 엣지 유스 케이스가 있습니다. 예를 들어 json_decode()정수 (예 123:) 또는 공백이나 다른 문자가없는 숫자 문자열 (예 :) "123"인 경우 json_last_error()함수는 오류를 포착하지 않습니다.

이를 방지하기 위해 결과를 json_decode()객체 또는 배열로 만드는 추가 단계를 추가했습니다 . 그렇지 않으면를 반환 false합니다.

이를 실제로 보려면 다음 두 가지 예를 확인하십시오.

• 확인 만 json_last_error()
• 객체 / 배열을 먼저 확인

쉬운 방법은 JSON 결과를 확인하는 것입니다.

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

에 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;
}

이전에는 null 값을 확인하고 있었는데 실제로 잘못되었습니다.

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

위의 코드는 문자열과 잘 작동합니다. 그러나 숫자를 제공하자마자 깨집니다.

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

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

내가 한 일을 고치는 것은 매우 간단했습니다.

    $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;
}

또 다른 간단한 방법

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

전달 된 문자열이 숫자가 아닌지 확인해야합니다.이 경우 json_decode에서 오류가 발생하지 않습니다.

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

    return $result;
}

나는 그 해결책 중 일부를 시도했지만 아무것도 나를 위해 일하지 않았다. 나는이 간단한 것을 시도한다 :

$isJson = json_decode($myJSON);

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

두 번째 매개 변수가없는 JSON 디코딩이 객체를 제공하기 때문에 훌륭한 해결책이라고 생각합니다.

편집 : 입력 내용을 알고 있으면이 코드를 필요에 맞게 조정할 수 있습니다. 제 경우에는 "{"로 시작하는 Json이 있다는 것을 알고 있으므로 배열인지 확인할 필요가 없습니다.

다음 클래스에서 PHPBench를 사용하면 다음과 같은 결과를 얻을 수 있습니다.

<?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 |
+---------------+-----------------------+-----+------+-----+------------+---------+---------+---------+---------+---------+--------+-------+

결론 : json이 유효한지 확인하는 가장 빠른 방법은 return json_decode($json, true) !== null)입니다.

어제 직장에서 비슷한 것을 발견 한 후에이 질문을 발견했습니다. 결국 내 솔루션은 위의 방법 중 일부의 하이브리드였습니다.

function is_JSON($string) {

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

  return $String_Is_JSON;
}

솔루션의 성능이나 우아함에 대해서는 잘 모르지만 사용하고 있습니다.

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

모든 JSON 인코딩 문자열은 { "로 시작하므로 RegEx를 사용하여이를 테스트하기에 충분합니다. RegEx에 능숙하지 않으므로 더 나은 방법이있을 수 있습니다. 또한 strpos () 가 더 빠를 수 있습니다.

내 tuppence 가치를 제공하려고합니다.

추신 /^[\[\{]\"/JSON 배열 문자열을 찾기 위해 RegEx 문자열을 업데이트했습니다 . 이제 문자열의 시작 부분에서 [ "또는 {"를 찾습니다.

다음과 같아야합니다.

 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;
}

단위 테스트

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);
    }
}

이 답변 확장 다음은 어떻습니까?

<?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);
?>

안녕하세요 여기 내 라이브러리의 작은 조각이 있습니다.이 첫 번째 조건에서는 데이터가 json인지 확인한 다음 올바르게 디코딩 된 경우 반환합니다. 성능에 대한 substr 사용법을 확인하십시오 (아직 json 파일이 시작되지 않은 것을 보지 못했습니다) {또는 [

$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
    }
}

나에게서 또 다른 제안 :)

function isJson(string $string) {
  return ($result = json_decode($string, true)) ? $result : $string;
}

맞춤 기능

function custom_json_decode(&$contents=NULL, $normalize_contents=true, $force_array=true){

    //---------------decode contents---------------------

    $decoded_contents=NULL;

    if(is_string($contents)){

        $decoded_contents=json_decode($contents,$force_array);

    }

    //---------------normalize contents---------------------

    if($normalize_contents===true){

        if(is_string($decoded_contents)){

            if($decoded_contents==='NULL'||$decoded_contents==='null'){

                $contents=NULL;
            }
            elseif($decoded_contents==='FALSE'||$decoded_contents==='false'){

                $contents=false;
            }
        }
        elseif(!is_null($decoded_contents)){

            $contents=$decoded_contents;
        }
    }
    else{

        //---------------validation contents---------------------

        $contents=$decoded_contents;
    }

    return $contents;
}

사례

$none_json_str='hello';

//------------decoding a none json str---------------

$contents=custom_json_decode($none_json_str); // returns 'hello'

//------------checking a none json str---------------

custom_json_decode($none_json_str,false);

$valid_json=false;

if(!is_null($none_json_str)){

    $valid_json=true;

}

자원

https://gist.github.com/rafasashi/93d06bae83cc1a1f440b

성공시 디코딩 된 데이터가 필요한 경우 PHP 5.2 호환성을 위해 새롭게 만들어진 기능 :

function try_json_decode( $json, & $success = null ){
  // non-strings may cause warnings
  if( !is_string( $json )){
    $success = false;
    return $json;
  }

  $data = json_decode( $json );

  // output arg
  $success =

    // non-null data: success!
    $data !==  null  ||

    // null data from 'null' json: success!
    $json === 'null' ||

    // null data from '  null  ' json padded with whitespaces: success!
    preg_match('/^\s*null\s*$/', $json );

  // return decoded or original data
  return $success ? $data : $json;
}

용법:

$json_or_not = ...;

$data = try_json_decode( $json_or_not, $success );

if( $success )
     process_data( $data );
else what_the_hell_is_it( $data );

일부 테스트 :

var_dump( try_json_decode( array(), $success ), $success );
// ret = array(0){}, $success == bool(false)

var_dump( try_json_decode( 123, $success ), $success );
// ret = int(123), $success == bool(false)

var_dump( try_json_decode('      ', $success ), $success );
// ret = string(6) "      ", $success == bool(false)

var_dump( try_json_decode( null, $success ), $success );
// ret = NULL, $success == bool(false)

var_dump( try_json_decode('null', $success ), $success );
// ret = NULL, $success == bool(true)

var_dump( try_json_decode('  null  ', $success ), $success );
// ret = NULL, $success == bool(true)

var_dump( try_json_decode('  true  ', $success ), $success );
// ret = bool(true), $success == bool(true)

var_dump( try_json_decode('  "hello"  ', $success ), $success );
// ret = string(5) "hello", $success == bool(true)

var_dump( try_json_decode('  {"a":123}  ', $success ), $success );
// ret = object(stdClass)#2 (1) { ["a"]=> int(123) }, $success == bool(true)

function is_json($input) {

    $input = trim($input);

    if (substr($input,0,1)!='{' OR substr($input,-1,1)!='}')
        return false;

    return is_array(@json_decode($input, true));
}

가장 필요한 가능성을 다루기위한 헨릭의 답변에 대한 간단한 수정.

( "{} 및 []"포함)

function isValidJson($string) {
    json_decode($string);
    if(json_last_error() == JSON_ERROR_NONE) {

        if( $string[0] == "{" || $string[0] == "[" ) { 
            $first = $string [0];

            if( substr($string, -1) == "}" || substr($string, -1) == "]" ) {
                $last = substr($string, -1);

                if($first == "{" && $last == "}"){
                    return true;
                }

                if($first == "[" && $last == "]"){
                    return true;
                }

                return false;

            }
            return false;
        }

        return false;
    }

    return false;

}

가장 빠른 방법은하기 어쩌면 PHP는 객체 / 배열에 가능한 JSON 오브젝트를 디코딩 :

/**
 * 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;
}

다음은 내가 만든 성능 있고 간단한 함수입니다 ( json_decode더 큰 문자열에 사용하기 전에 기본 문자열 유효성 검사를 사용함 ).

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;
}