Could not decode json syntax error malformed json

1. Home

2. php — Could not decode JSON, syntax error — malformed JSON

760 votes

2 answers

Get the solution ↓↓↓

I am sending an AJAX POST with JSON data to a Symfony2 controller. Without any data specified, the controller does create an empty record and returns success (no errors). However, when I pass data in POST it gives me the error shown in title. Here is my code for AJAX:

              $.ajax({
                dataType: "json",
                type: "POST",
                data: {
                        "useruid": "Nothing",
                        "type": "Office in Space",
                        "latitude": "12",
                        "longitude": "100",
                        "displayed": "true",
                        "public": "true",
                        "verified": "true",
                        "street": "Something",
                        "city": "Something",
                        "country": "Space",
                        "region": "North Space",
                        "created": "2009-03-07T00:00:00-0500",
                        "delete_status": "active"
},
                url: "/web/app_dev.php/address/",
                success: function (responseText)
                {
                    console.log("Request was successful, data received: " + JSON.stringify(responseText)); 

                },
                error: function (error) {
                    alert(JSON.stringify(error));
                }
            });

To deserialize the JSON, here is my controller code:

public function createAction(Request $request)
{


    $content = $this->get('request')->getContent();
    var_dump($content); 
    $serializer = $this->get('jms_serializer'); 
    $entity = $serializer->deserialize($content, 'NameNameBundleEntityAddress', 'json');
        $em = $this->getDoctrine()->getManager();
        $em->persist($entity);
        $em->flush();

    return array(
        'entity' => $entity,
        'form'   => $form->createView(),
    );

}

I am using JMSSerializer bundle. What is the reason why it cannot decode the JSON? I validated my JSON with JSONlint and it was okay. Any ideas?

** Edited code: Added Entity Class **

namespace FactoryWebServicesBundleEntity;

use DoctrineORMMapping as ORM;

use JMSSerializerAnnotationType;

/**
 * Address
 * @ORMTable(name="address")
 * @ORMEntity
 */
class Address
{
/**
 * @var integer
 *
 * @ORMColumn(name="id", type="integer", nullable=false)
 * @ORMId
 * @ORMGeneratedValue(strategy="IDENTITY")
 * @JMSSerializerAnnotationType("integer")
 */
private $id;

/**
 * @var string
 *
 * @ORMColumn(name="useruid", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $useruid;

/**
 * @var string
 *
 * @ORMColumn(name="type", type="string", nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $type;

/**
 * @var string
 *
 * @ORMColumn(name="latitude", type="string", length=120, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $latitude;

/**
 * @var string
 *
 * @ORMColumn(name="longitude", type="string", length=120, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $longitude;

/**
 * @var boolean
 *
 * @ORMColumn(name="displayed", type="boolean", nullable=true)
 * @JMSSerializerAnnotationType("boolean")
 */
private $displayed;

/**
 * @var boolean
 *
 * @ORMColumn(name="public", type="boolean", nullable=true)
 * @JMSSerializerAnnotationType("boolean")
 */
private $public;

/**
 * @var boolean
 *
 * @ORMColumn(name="verified", type="boolean", nullable=true)
 * @JMSSerializerAnnotationType("boolean")
 */
private $verified;

/**
 * @var string
 *
 * @ORMColumn(name="street", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $street;

/**
 * @var string
 *
 * @ORMColumn(name="city", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $city;

/**
 * @var string
 *
 * @ORMColumn(name="country", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $country;

/**
 * @var string
 *
 * @ORMColumn(name="locality", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $locality;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="region", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $region;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="code", type="string", length=100, nullable=true)
 * @JMSSerializerAnnotationType("string")
 * 
 */
private $code;

/**
 * 
 * @var string
 *
 * 
 * @ORMColumn(name="pobox", type="string", length=100, nullable=true)
 * @JMSSerializerAnnotationType("string")
 * 
 */
private $pobox;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="telephone", type="string", length=60, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $telephone;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="cellphone", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $cellphone;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="email", type="string", length=200, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $email;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="facsmile", type="string", length=60, nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $facsmile;

/**
 * @var DateTime
 *
 * 
 * @ORMColumn(name="created", type="datetime", nullable=true)
 * @JMSSerializerAnnotationType("DateTime")
 */
private $created;

/**
 * @var DateTime
 *
 * 
 * @ORMColumn(name="modified", type="datetime", nullable=true)
 * @JMSSerializerAnnotationType("DateTime")
 */
private $modified;

/**
 * @var string
 *
 * 
 * @ORMColumn(name="delete_status", type="string", nullable=true)
 * @JMSSerializerAnnotationType("string")
 */
private $deleteStatus;

2022-03-13

Write your answer

---

245

votes

Answer

Solution:

You have to instruct the JMS Serializer in how to deserialize your fields.
You can do that by using annotations, e.g.@JMSSerializerAnnotationType("string")
The JMS Serializer documentation lists all possible types.

Just to be clear, you put the annotation on every field of your entity that you want to be deserialized, e.g.

/**
 * @var string
 *
 * @JMSSerializerAnnotationType("string")
 * @ORMColumn(name="street", type="string", length=200, nullable=true)
 */
private $street;

Hope this helps…

---

890

votes

---

Share solution ↓

Additional Information:

Date the issue was resolved:

2022-03-13

Link To Source

Link To Answer
People are also looking for solutions of the problem: dompdf image not found or type unknown

Didn’t find the answer?

Our community is visited by hundreds of web development professionals every day. Ask your question and get a quick answer for free.

---

Similar questions

Find the answer in similar questions on our website.

Write quick answer

Do you know the answer to this question? Write a quick response to it. With your help, we will make our community stronger.

About the technologies asked in this question

PHP

PHP (from the English Hypertext Preprocessor — hypertext preprocessor) is a scripting programming language for developing web applications. Supported by most hosting providers, it is one of the most popular tools for creating dynamic websites.
The PHP scripting language has gained wide popularity due to its processing speed, simplicity, cross-platform, functionality and distribution of source codes under its own license.
https://www.php.net/

Symfony

Symfony compares favorably with other PHP frameworks in terms of reliability and maturity. This framework appeared a long time ago, in 2005, that is, it has existed much longer than most of the other tools we are considering. It is popular for its web standards compliance and PHP design patterns.
https://symfony.com/

JavaScript

JavaScript is a multi-paradigm language that supports event-driven, functional, and mandatory (including object-oriented and prototype-based) programming types. Originally JavaScript was only used on the client side. JavaScript is now still used as a server-side programming language. To summarize, we can say that JavaScript is the language of the Internet.
https://www.javascript.com/

JQuery

JQuery is arguably the most popular JavaScript library with so many features for modern development. JQuery is a fast and concise JavaScript library created by John Resig in 2006. It is a cross-platform JavaScript library designed to simplify client-side HTML scripting. Over 19 million websites are currently using jQuery! Companies like WordPress, Facebook, Google, IBM and many more rely on jQuery to provide a kind of web browsing experience.
https://jquery.com/

PHP
JSON

Вступление

JSON ( JavaScript Object Notation ) — это независимый от платформы и язык способ сериализации объектов в открытый текст. Поскольку он часто используется в Интернете, а также PHP, существует базовое расширение для работы с JSON в PHP.

Синтаксис

• string json_encode (mixed $ value [, int $ options = 0 [, int $ depth = 512]])
• смешанный json_decode (строка $ json [, bool $ assoc = false [, int $ depth = 512 [, int $ options = 0]]])

параметры

замечания

• Обработка json_decode недопустимого JSON очень шелушащая, и очень сложно надежно определить, удалось ли декодировать, json_decode возвращает значение null для недопустимого ввода, хотя null также является вполне допустимым объектом для JSON для декодирования. Чтобы предотвратить такие проблемы, вы всегда должны вызывать json_last_error каждый раз, когда используете его.

Декодирование строки JSON

Функция json_decode() принимает JSON-кодированную строку в качестве своего первого параметра и анализирует ее в переменной PHP.

Обычно json_decode() возвращает объект stdClass, если элемент верхнего уровня в объекте JSON является словарем или индексированным массивом, если объект JSON является массивом. Он также вернет скалярные значения или NULL для определенных скалярных значений, таких как простые строки, «true» , «false» и «null» . Он также возвращает NULL при любой ошибке.

Используйте var_dump() для просмотра типов и значений каждого свойства объекта, который мы расшифровали выше.

Выход (обратите внимание на типы переменных):

Примечание. Типы переменных в JSON были преобразованы в их эквивалент PHP.

Чтобы вернуть ассоциативный массив для объектов JSON вместо возвращения объекта, передайте true как второй параметр json_decode() .

Вывод (обратите внимание на ассоциативную структуру массива):

Второй параметр ( $assoc ) не действует, если возвращаемая переменная не является объектом.

Примечание. Если вы используете параметр $assoc , вы потеряете различие между пустым массивом и пустым объектом. Это означает, что запуск json_encode() на вашем декодированном выходе снова приведет к другой структуре JSON.

Если строка JSON имеет «глубину» более 512 элементов ( 20 элементов в версиях старше 5.2.3 или 128 в версии 5.2.3 ) в рекурсии, функция json_decode() возвращает NULL . В версиях 5.3 или новее этот предел можно контролировать с помощью третьего параметра ( $depth ), как обсуждается ниже.

PHP реализует надмножество JSON, как указано в оригинале »RFC 4627 — он также кодирует и декодирует скалярные типы и NULL. RFC 4627 поддерживает только эти значения, когда они вложены внутри массива или объекта. Хотя это дополнение соответствует расширенному определению «текста JSON» в новой версии RFC 7159 (целью которого является замещение RFC 4627) и « ECMA-404» , это может вызвать проблемы совместимости со старыми анализаторами JSON, которые строго придерживаются RFC 4627, когда кодируя одно скалярное значение.

Это означает, что, например, простая строка будет считаться допустимым объектом JSON в PHP:

Но простые строки, а не в массиве или объекте, не являются частью стандарта RFC 4627 . В результате такие онлайн-шашки, как JSLint , JSON Formatter & Validator (в режиме RFC 4627) дадут вам ошибку.

Для глубины рекурсии существует третий параметр $depth (значение по умолчанию — 512 ), что означает количество вложенных объектов внутри исходного объекта, подлежащего декодированию.

Существует четвертый параметр $options . В настоящее время он принимает только одно значение: JSON_BIGINT_AS_STRING . Поведение по умолчанию (которое оставляет эту опцию) заключается в том, чтобы отличать целые числа от float вместо строк.

Недействительные варианты с нижним регистром истинных, ложных и нулевых литералов больше не принимаются в качестве допустимого ввода.

Итак, этот пример:

Аналогичное поведение имеет место для false и null .

Обратите внимание, что json_decode() возвращает NULL если строка не может быть преобразована.

Небезопасно полагаться только на возвращаемое значение NULL для обнаружения ошибок. Например, если строка JSON содержит ничего, кроме «null» , json_decode() вернет значение null , даже если ошибка не возникла.

Кодирование строки JSON

Функция json_encode преобразует массив PHP (или, начиная с PHP 5.4, объект, который реализует интерфейс JsonSerializable ) в строку, закодированную в JSON. Он возвращает строку с кодировкой JSON при успешном завершении или FALSE при сбое.

Во время кодирования строки данных типа PHP, integer и boolean преобразуются в эквивалент JSON. Ассоциативные массивы кодируются как объекты JSON, а при вызове с аргументами по умолчанию индексированные массивы кодируются как массивы JSON. (Если ключи массива не являются непрерывной числовой последовательностью, начиная с 0, в этом случае массив будет закодирован как объект JSON.)

аргументы

Начиная с PHP 5.3, второй аргумент json_encode является битовой маской, которая может быть одной или несколькими из следующих.

Как и в любой битовой маске, их можно комбинировать с двоичным оператором OR | ,

JSON_FORCE_OBJECT

Заставляет создать объект вместо массива

JSON_HEX_TAG , JSON_HEX_AMP , JSON_HEX_APOS , JSON_HEX_QUOT

Обеспечивает следующие преобразования во время кодирования:

JSON_NUMERIC_CHECK

Обеспечивает преобразование числовых строк в целые числа.

JSON_PRETTY_PRINT

Делает JSON легко читаемым

JSON_UNESCAPED_SLASHES

Включает неэкранированные / косые черты на выходе

JSON_UNESCAPED_UNICODE

Включает символы с кодировкой UTF8 в выводе вместо u -encoded строк.

JSON_PARTIAL_OUTPUT_ON_ERROR

Позволяет продолжить кодирование, если встречаются некоторые неприменимые значения.

JSON_PRESERVE_ZERO_FRACTION

Обеспечивает, чтобы поплавки всегда кодировались как плавающие.

JSON_UNESCAPED_LINE_TERMINATORS

При использовании с JSON_UNESCAPED_UNICODE возвращается к поведению старых версий PHP и не выходит из символов U + 2028 LINE SEPARATOR и U + 2029 PARAPRAPH SEPARATOR. Хотя они действительны в JSON, эти символы недействительны в JavaScript, поэтому поведение по умолчанию JSON_UNESCAPED_UNICODE было изменено в версии 7.1.

Отладка ошибок JSON

Когда json_encode или json_decode не удается проанализировать предоставленную строку, он вернет false . Сам PHP не вызывает никаких ошибок или предупреждений, когда это происходит, бремя на пользователя заключается в использовании функций json_last_error () и json_last_error_msg (), чтобы проверить, произошла ли ошибка и действовать соответственно в вашем приложении (отладить ее, показать сообщение об ошибке , так далее.).

В следующем примере показана общая ошибка при работе с JSON, неспособность декодировать / кодировать строку JSON (например, из-за передачи плохой кодированной строки UTF-8) .

json_last_error_msg

json_last_error_msg() возвращает человекообразное сообщение о последней ошибке, возникшей при попытке кодирования / декодирования строки.

• Эта функция всегда вернет строку , даже если ошибка не возникла.
  Строка по умолчанию без ошибок не No Error
• Он вернет false если произошла какая-либо другая (неизвестная) ошибка
• Будьте осторожны при использовании этого в циклах, поскольку json_last_error_msg будет переопределяться на каждой итерации.

Вы должны использовать эту функцию только для получения сообщения для отображения, а не для проверки в контрольных операторах.

Эта функция не существует до PHP 5.5. Вот реализация полиполнения:

json_last_error

json_last_error() возвращает целое число, сопоставленное с одной из предварительно определенных констант, предоставляемых PHP.

Использование JsonSerializable в объекте

Когда вы создаете API REST, вам может потребоваться уменьшить информацию об объекте, который будет передан клиентскому приложению. С этой целью в этом примере показано, как использовать интерфейс JsonSerialiazble .

В этом примере User класса фактически расширяет объект модели DB гипотетической ORM.

Добавьте реализацию JsonSerializable в класс, предоставив метод jsonSerialize() .

Теперь в вашем контроллере приложения или скрипте при передаче объекта User в json_encode() вы получите возвращаемый json-кодированный массив метода jsonSerialize() вместо всего объекта.

пример значений свойств.

Это уменьшит количество данных, возвращаемых конечной точкой RESTful, и позволит исключить свойства объекта из представления json.

Использование частных и защищенных свойств с помощью json_encode()

Чтобы избежать использования JsonSerializable, также можно использовать частные или защищенные свойства, чтобы скрыть информацию о классе из вывода json_encode() . Затем классу не нужно реализовывать JsonSerializable.

Функция json_encode () будет кодировать только общедоступные свойства класса в JSON.

Выход:

Заголовок json и возвращаемый ответ

Добавив заголовок с типом контента как JSON:

Заголовок там, так что ваше приложение может обнаружить, какие данные были возвращены и как он должен справиться с этим.
Обратите внимание: заголовок содержимого представляет собой только информацию о типе возвращаемых данных.

Если вы используете UTF-8, вы можете использовать:

Источник

PHP: json_encode / json_decode error handling.

Unfortunately, the error handling in the earlier versions of PHP is non-existent. It wasn’t until PHP version 5.3.0 that the function json_last_error was introduced that. Before that, json_encode would return a NULL value or a FALSE value and you’d have to use an external JSON validation tool to try and figure out what was going wrong.

For example, if your data had special (non-UTF8) characters, the json_encode function would often return a NULL value. If the depth of your PHP array was too “deep”, then it would return a FALSE value. The json_decode function was also pretty similar in the way that it returned NULL whenever it received malformed / incorrect JSON strings.

Prior to PHP 5.3.0, JSON error handling in PHP looked a little like this (throwing Exceptions):

or, with json_decode:

Thankfully, in PHP 5.3.0, the function json_last_error was introduced. If an error has occurred, it will return one of the following constants:

• JSON_ERROR_NONE: No error has occured.
• JSON_ERROR_DEPTH: Max depth exceeded.
• JSON_ERROR_STATE_MISMATCH: Invalid JSON.
• JSON_ERROR_CTRL_CHAR: Bad character was found.

In PHP 5.3.3, another constant was added:

• JSON_ERROR_UTF8: Bad UTF8 character was found. Incorrect encoding.

Then, in PHP 5.5, they added three more constants:

• JSON_ERROR_RECURSION: Recursion detected.
• JSON_ERROR_INF_OR_NAN: One or more NAN or INF values in the value to be encoded.
• JSON_ERROR_UNSUPPORTED_TYPE: An unsupported type was found.

Using these constants, we can carry out our error handling like so:

Unfortunately, this isn’t the type of code that you should be repeating throughout your script. If you stay true to the DRY (Don’t Repeat Yourself) principle (which you should), then you will wrap this kind of error checking into a function or a class method.

Personally, I would prefer it if json_last_error returned a string-based error message (like the internal XML library does). That way, you wouldn’t need to implement an ugly-looking switch statement.

Still, at least it is far more informative than it used to be!

Источник

Парсинг многоэтажного json?

Есть огромный json:, пытаюсь обработать его через json_decode и получаю:

Т.е., обрабатывает, но не полностью
Как можно получить доступ к оставшемуся куску json?

• Вопрос задан более трёх лет назад
• 3132 просмотра

Оценить 4 комментария

JSON_ERROR_RECURSION One or more recursive references in the value to be encoded

скорее всего проблема в правильности самого json
json_decode пропускает значения, если они были сформированы неправильно (не по описанному стандарту)

Для debug: после json_decode вставить что-то типа:

ну а дальше уже действовать по обстоятельствам 🙂

Я все же сильно сомневаюсь в том что у вас стандартный JSON. Он у вас игнорируется, не парсится. Так что можно предположить вто чнутри json еще один json как строка и его надо парсить отдельно. Ибо если бы была ошибка по глубине json_decode выдал бы null и тогда можно было бы отлавливать это через json_get_error (или как-то так). В документации есть пример как хэндлить такие случаи.

Так же попробуйте сторонние парсеры: https://github.com/Seldaek/jsonlint например. Оно должно нормально разобрать если у вас нормальный json.

Если же у вас слоенка с JSON то нужно вручную рекурсивно обходить полученный массив/объект и пробовать делать json_decode. Если поддается, оставляем. НЕ поддается — оставляем старое значение.

Источник

Unfortunately, the error handling in the earlier versions of PHP is non-existent. It wasn’t until PHP version 5.3.0 that the function json_last_error was introduced that. Before that, json_encode would return a NULL value or a FALSE value and you’d have to use an external JSON validation tool to try and figure out what was going wrong.

For example, if your data had special (non-UTF8) characters, the json_encode function would often return a NULL value. If the depth of your PHP array was too “deep”, then it would return a FALSE value. The json_decode function was also pretty similar in the way that it returned NULL whenever it received malformed / incorrect JSON strings.

Prior to PHP 5.3.0, JSON error handling in PHP looked a little like this (throwing Exceptions):

$val = json_encode($myArr);
if($val === false || is_null($val)){
    throw new Exception('Could not encode JSON');
}

or, with json_decode:

$val = json_decode($structure, true);
if(!is_array($val)){
    throw new Exception('Could not decode JSON');
}

Thankfully, in PHP 5.3.0, the function json_last_error was introduced. If an error has occurred, it will return one of the following constants:

• JSON_ERROR_NONE: No error has occured.
• JSON_ERROR_DEPTH: Max depth exceeded.
• JSON_ERROR_STATE_MISMATCH: Invalid JSON.
• JSON_ERROR_CTRL_CHAR: Bad character was found.

In PHP 5.3.3, another constant was added:

• JSON_ERROR_UTF8: Bad UTF8 character was found. Incorrect encoding.

Then, in PHP 5.5, they added three more constants:

• JSON_ERROR_RECURSION: Recursion detected.
• JSON_ERROR_INF_OR_NAN: One or more NAN or INF values in the value to be encoded.
• JSON_ERROR_UNSUPPORTED_TYPE: An unsupported type was found.

Using these constants, we can carry out our error handling like so:

<?php

//Attempt to decode JSON.
$decoded = json_decode($arr);

//Backwards compatability.
if(!function_exists('json_last_error')){
    if($decoded === false || $decoded === null){
        throw new Exception('Could not decode JSON!');
    }
} else{
    
    //Get the last JSON error.
    $jsonError = json_last_error();
    
    //In some cases, this will happen.
    if(is_null($decoded) && $jsonError == JSON_ERROR_NONE){
        throw new Exception('Could not decode JSON!');
    }
    
    //If an error exists.
    if($jsonError != JSON_ERROR_NONE){
        $error = 'Could not decode JSON! ';
        
        //Use a switch statement to figure out the exact error.
        switch($jsonError){
            case JSON_ERROR_DEPTH:
                $error .= 'Maximum depth exceeded!';
            break;
            case JSON_ERROR_STATE_MISMATCH:
                $error .= 'Underflow or the modes mismatch!';
            break;
            case JSON_ERROR_CTRL_CHAR:
                $error .= 'Unexpected control character found';
            break;
            case JSON_ERROR_SYNTAX:
                $error .= 'Malformed JSON';
            break;
            case JSON_ERROR_UTF8:
                 $error .= 'Malformed UTF-8 characters found!';
            break;
            default:
                $error .= 'Unknown error!';
            break;
        }
        throw new Exception($error);
    }
}

Unfortunately, this isn’t the type of code that you should be repeating throughout your script. If you stay true to the DRY (Don’t Repeat Yourself) principle (which you should), then you will wrap this kind of error checking into a function or a class method.

Personally, I would prefer it if json_last_error returned a string-based error message (like the internal XML library does). That way, you wouldn’t need to implement an ugly-looking switch statement.

Still, at least it is far more informative than it used to be!

6 ответов

$_POST = array(
    'bad data'
);
$data = @json_decode($_POST);

if ($data === null
    && json_last_error() !== JSON_ERROR_NONE) {
    echo "incorrect data";
}

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

    /**
 * Parse the JSON response body and return an array
 *
 * @return array|string|int|bool|float
 * @throws RuntimeException if the response body is not in JSON format
 */
public function json()
{
    $data = json_decode((string) $this->body, true);
    if (JSON_ERROR_NONE !== json_last_error()) {
        throw new RuntimeException('Unable to parse response body into JSON: ' . json_last_error());
    }

    return $data === null ? array() : $data;
}

$ft = json_decode(html_entity_decode(urldecode(filter_input(INPUT_GET, 'ft', FILTER_SANITIZE_STRING))));

/**
 * 
 * custom json_decode 
 * handle json_decode errors
 * 
 * @param type $json_text
 * @return type
 */
public static function custom_json_decode($json_text) {

    $decoded_array = json_decode($json_text, TRUE);
    switch (json_last_error()) {
        case JSON_ERROR_NONE:
            return array(
                "status" => 0,
                "value" => $decoded_array
            );


        case JSON_ERROR_DEPTH:
            return array(
                "status" => 1,
                "value" => 'Maximum stack depth exceeded'
            );

        case JSON_ERROR_STATE_MISMATCH:
            return array(
                "status" => 1,
                "value" => 'Underflow or the modes mismatch'
            );

        case JSON_ERROR_CTRL_CHAR:
            return array(
                "status" => 1,
                "value" => 'Unexpected control character found'
            );

        case JSON_ERROR_SYNTAX:
            return array(
                "status" => 1,
                "value" => 'Syntax error, malformed JSON'
            );

        case JSON_ERROR_UTF8:
            return array(
                "status" => 1,
                "value" => 'Malformed UTF-8 characters, possibly incorrectly encoded'
            );

        default:
            return array(
                "status" => 1,
                "value" => 'Unknown error'
            );
    }
}

try {  
  json_decode("{", false, 512, JSON_THROW_ON_ERROR);  
}  
catch (JsonException $exception) {  
  echo $exception->getMessage(); // displays "Syntax error"  
}

    $(window).scroll(function () {
if($(window).scrollTop() + $(window).height()>= $(document).height()){
getmoredata();
}

})

var page = 1;

function getmoredata(array_data_file) {
var array_data_file = { {{ announces }} } ;
var theurl = '{{ path('announce_page', {'id': "id", 'game': game}) }}';
theurl = theurl.replace("id", page);
$.ajax({
type: "GET",
data: {data_array:array_data_file},
url: theurl,
dataType: "json",
cache: false,
success: function (response) {
$("#content").append(response.classifiedList);
page = page + 1;
$('#spinner').hide();
console.log(response);
},
error: function (response) {
console.log(response);
}
});
}

</script>

    public function pageAction(Request $request, $id, $game)
{
$em = $this->getDoctrine()->getManager();
//$announces = $em->getRepository('PlatformBundle:Announce')->byGame($game);
$announces = $request->request->get('data_array');
$list = $this->renderView('announce/result.html.twig', array(
'announces' => $announces,
'game' => $game
));

$response = new JsonResponse();
$response->setData(array('classifiedList' => $list));
return $response;

}

var array_data_file = { {{ announces }} } ;

var array_data_file ={{ announces|json_encode() }};

$announces = $request->request->get('data_array');

$announces = $em->getRepository('PlatformBundle:Announce')->byUser($user);

var contactsArray = "{{ announces|serialize('json') }}";

$data = $request->request->get('data_array');

$serializer = $this->container->get('jms_serializer');
$announces = $serializer->deserialize($data, 'WolkPlatformBundleEntityAnnounce', 'json');

"Could not decode JSON, syntax error - malformed JSON."

Решение

Задача ещё не решена.

Другие решения

Других решений пока нет …