Json error none

Вернуться к: JSON

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

Следующие константы указывают на тип ошибки, возвращенной функцией
json_last_error().

JSON_ERROR_NONE
(integer)

Не произошло никаких ошибок.
Доступна начиная с PHP 5.3.0.

JSON_ERROR_DEPTH
(integer)

Была превышена максимальная глубина стека.
Доступна начиная с PHP 5.3.0.

JSON_ERROR_STATE_MISMATCH
(integer)

Неверный или поврежденный JSON.
Доступна начиная с PHP 5.3.0.

JSON_ERROR_CTRL_CHAR
(integer)

Ошибка управляющих символов, вероятно из-за неверного кодирования.
Доступна начиная с PHP 5.3.0.

JSON_ERROR_SYNTAX
(integer)

Синтаксическая ошибка.
Доступна начиная с PHP 5.3.0.

JSON_ERROR_UTF8
(integer)

Поврежденные символы UTF-8, вероятно, из-за неверного кодирования.
Эта константа стала доступна начиная с PHP 5.3.3.

JSON_ERROR_RECURSION
(integer)

Объект или массив, переданный в функцию json_encode() включает
рекурсивные ссылки и не может быть закодирован.
Если была передана опция JSON_PARTIAL_OUTPUT_ON_ERROR, то
на месте рекурсивных ссылок будет выведен NULL.

Эта константа стала доступна начиная с PHP 5.5.0.

JSON_ERROR_INF_OR_NAN
(integer)

Значение, переданное в функцию json_encode() включает либо
NAN,
либо INF.
Если была указана константа JSON_PARTIAL_OUTPUT_ON_ERROR,
то вместо указанных особых значений будет выведен 0.

Эта константа стала доступна начиная с PHP 5.5.0.

JSON_ERROR_UNSUPPORTED_TYPE
(integer)

В функцию json_encode() было передано значение
неподдерживаемого типа, например, resource.
Если была указана константа JSON_PARTIAL_OUTPUT_ON_ERROR,
то вместо неподдерживаемого значения будет выводиться NULL.

Эта константа стала доступна начиная с PHP 5.5.0.

Следующие константы можно комбинировать для использования в
json_encode().

JSON_HEX_TAG
(integer)

Все < и > кодируются в u003C и u003E.
Доступна начиная с PHP 5.3.0.

JSON_HEX_AMP
(integer)

Все & кодируются в u0026.
Доступна начиная с PHP 5.3.0.

JSON_HEX_APOS
(integer)

Все символы ‘ кодируются в u0027.
Доступна начиная с PHP 5.3.0.

JSON_HEX_QUOT
(integer)

Все символы » кодируются в u0022.
Доступна начиная с PHP 5.3.0.

JSON_FORCE_OBJECT
(integer)

Выдавать объект вместо массива при использовании неассоциативного
массива. Это полезно, когда принимающая программа или код ожидают
объект или же массив пуст.
Доступна начиная с PHP 5.3.0.

JSON_NUMERIC_CHECK
(integer)

Кодирование строк, содержащих числа, как
числа. Доступна начиная с PHP 5.3.3.

JSON_BIGINT_AS_STRING
(integer)

Кодирует большие целые числа в виде их строковых эквивалентов.
Доступна начиная с PHP 5.4.0.

JSON_PRETTY_PRINT
(integer)

Использовать пробельные символы в возвращаемых данных
для их форматирования. Доступна начиная с PHP 5.4.0.

JSON_UNESCAPED_SLASHES
(integer)

Не экранировать /.
Доступна начиная с PHP 5.4.0.

JSON_UNESCAPED_UNICODE
(integer)

Не кодировать многобайтные символы Unicode (по умолчанию они кодируются как uXXXX).
Доступна начиная с PHP 5.4.0.

Вернуться к: JSON

JSON (JavaScript Object Notation) – текстовый формат обмена данными, основанный на JavaScript, который представляет собой набор пар {ключ: значение}. Значение может быть массивом, числом, строкой и булевым значением.

В PHP поддержка JSON появилась с версии 5.2.0 и работает только с кодировкой UTF-8.

$array = array(
	'1' => 'Значение 1', 
	'2' => 'Значение 2', 
	'3' => 'Значение 3', 
	'4' => 'Значение 4', 
	'5' => 'Значение 5'
);

$json = json_encode($array);
echo $json;

{"1":"u0417u043du0430u0447u0435u043du0438u0435 1","2":"u0417u043du0430u0447u0435u043du0438u0435 2","3":"u0417u043du0430u0447u0435u043du0438u0435 3","4":"u0417u043du0430u0447u0435u043du0438u0435 4","5":"u0417u043du0430u0447u0435u043du0438u0435 5"}

$json = json_encode($array, JSON_UNESCAPED_UNICODE);
echo $json;

{"1":"Значение 1","2":"Значение 2","3":"Значение 3","4":"Значение 4","5":"Значение 5"}

header('Content-Type: application/json');
echo $json;
exit();

$json = '{"1":"Значение 1","2":"Значение 2","3":"Значение 3","4":"Значение 4","5":"Значение 5"}';
$array = json_decode($json);
print_r($array);

stdClass Object
(
    [1] => Значение 1
    [2] => Значение 2
    [3] => Значение 3
    [4] => Значение 4
    [5] => Значение 5
)

$json = '{"1":"Значение 1","2":"Значение 2","3":"Значение 3","4":"Значение 4","5":"Значение 5"}';
$array = json_decode($json, true);
print_r($array);

Array
(
    [1] => Значение 1
    [2] => Значение 2
    [3] => Значение 3
    [4] => Значение 4
    [5] => Значение 5
)

$json = '{"1:"Значение 1"}';
$array = json_decode($json, true);

switch (json_last_error()) {
	case JSON_ERROR_NONE:
		echo 'Ошибок нет';
	break;
	case JSON_ERROR_DEPTH:
		echo 'Достигнута максимальная глубина стека';
	break;
	case JSON_ERROR_STATE_MISMATCH:
		echo 'Некорректные разряды или несоответствие режимов';
	break;
	case JSON_ERROR_CTRL_CHAR:
		echo 'Некорректный управляющий символ';
	break;
	case JSON_ERROR_SYNTAX:
		echo 'Синтаксическая ошибка, некорректный JSON';
	break;
	case JSON_ERROR_UTF8:
		echo 'Некорректные символы UTF-8, возможно неверно закодирован';
	break;
	default:
		echo 'Неизвестная ошибка';
	break;
}

$constants = get_defined_constants(true);
foreach ($constants['json'] as $name => $value) {
	echo $name . ': ' . $value . '<br>';
}

JSON_HEX_TAG: 1
JSON_HEX_AMP: 2
JSON_HEX_APOS: 4
JSON_HEX_QUOT: 8
JSON_FORCE_OBJECT: 16
JSON_NUMERIC_CHECK: 32
JSON_UNESCAPED_SLASHES: 64
JSON_PRETTY_PRINT: 128
JSON_UNESCAPED_UNICODE: 256
JSON_PARTIAL_OUTPUT_ON_ERROR: 512
JSON_PRESERVE_ZERO_FRACTION: 1024
JSON_UNESCAPED_LINE_TERMINATORS: 2048
JSON_OBJECT_AS_ARRAY: 1
JSON_BIGINT_AS_STRING: 2
JSON_ERROR_NONE: 0
JSON_ERROR_DEPTH: 1
JSON_ERROR_STATE_MISMATCH: 2
JSON_ERROR_CTRL_CHAR: 3
JSON_ERROR_SYNTAX: 4
JSON_ERROR_UTF8: 5
JSON_ERROR_RECURSION: 6
JSON_ERROR_INF_OR_NAN: 7
JSON_ERROR_UNSUPPORTED_TYPE: 8
JSON_ERROR_INVALID_PROPERTY_NAME: 9
JSON_ERROR_UTF16: 10

$json = '{...}';

// Удаление управляющих символов
for ($i = 0; $i <= 31; ++$i) { 
	$json = str_replace(chr($i), '', $json); 
}

// Удаление символа Delete
$json = str_replace(chr(127), '', $json);

// Удаление BOM
if (0 === strpos(bin2hex($json), 'efbbbf')) {
   $json = substr($json, 3);
}

$res = json_decode($json, true);
print_r($res);

$data = array(
	'name' => 'snipp.ru'
	'text' => 'Отправка сообщения',
);

$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($ch, CURLOPT_HEADER, false);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json')); 	
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
$res = curl_exec($ch);
curl_close($ch);

$data = file_get_contents('php://input');
$data = json_decode($data, true);

json_last_error

(PHP 5 >= 5.3.0, PHP 7, PHP

json_last_error — Возвращает последнюю ошибку

Описание

Возвращает последнюю ошибку (если она есть), произошедшую во время последнего кодирования/декодирования JSON если при вызове не использовался флаг JSON_THROW_ON_ERROR .

Список параметров

У этой функции нет параметров.

Возвращаемые значения

Возвращает целочисленное значение, которое может быть одной из следующих констант:

Коды ошибок JSON

Примеры

Пример #1 Пример использования json_last_error()

// Неверная json-строка, которая вызовет синтаксическую ошибку,
// здесь в качестве кавычек мы используем ‘ вместо »
$json [] = «<‘Organization’: ‘PHP Documentation Team’>» ;

foreach ( $json as $string ) <
echo ‘Декодируем: ‘ . $string ;
json_decode ( $string );

switch ( json_last_error ()) <
case JSON_ERROR_NONE :
echo ‘ — Ошибок нет’ ;
break;
case JSON_ERROR_DEPTH :
echo ‘ — Достигнута максимальная глубина стека’ ;
break;
case JSON_ERROR_STATE_MISMATCH :
echo ‘ — Некорректные разряды или несоответствие режимов’ ;
break;
case JSON_ERROR_CTRL_CHAR :
echo ‘ — Некорректный управляющий символ’ ;
break;
case JSON_ERROR_SYNTAX :
echo ‘ — Синтаксическая ошибка, некорректный JSON’ ;
break;
case JSON_ERROR_UTF8 :
echo ‘ — Некорректные символы UTF-8, возможно неверно закодирован’ ;
break;
default:
echo ‘ — Неизвестная ошибка’ ;
break;
>

Результат выполнения данного примера:

Пример #2 Совместное использование json_last_error() и json_encode()

// Некорректная последовательность UTF8
$text = «xB1x31» ;

$json = json_encode ( $text );
$error = json_last_error ();

var_dump ( $json , $error === JSON_ERROR_UTF8 );
?>

Результат выполнения данного примера:

Пример #3 json_last_error() и JSON_THROW_ON_ERROR

// Некорректная последовательность UTF8, вызывающая JSON_ERROR_UTF8
json_encode ( «xB1x31» );

// Не вызовет ошибки JSON
json_encode ( ‘okay’ , JSON_THROW_ON_ERROR );

// Глобальное состояние не будет изменено json_encode()
var_dump ( json_last_error () === JSON_ERROR_UTF8 );
?>

Результат выполнения данного примера:

Смотрите также

• json_last_error_msg() — Возвращает строку с сообщением об ошибке последнего вызова json_encode() или json_decode()
• json_decode() — Декодирует строку JSON
• json_encode() — Возвращает JSON-представление данных

Источник

Возврат JSON из PHP-скрипта

Я хочу вернуть JSON из скрипта PHP. Надо ли устанавливать Content-Type заголовок?

Ответ 1

Хотя обычно все работает и без этого, но , согласно спецификации, вам обязательно необходимо устанавливать Content-Type заголовок:

$data = /** все, что вы сериализуете **/;

Если я не использую конкретный фреймворк, я обычно разрешаю некоторым параметрам запроса изменять поведение вывода. Как правило, для быстрого устранения неполадок может быть полезно не отправлять заголовок, а использовать print_r и другую полезную нагрузку данных (хотя в большинстве случаев в этом нет необходимости).

Ответ 2

Полный фрагмент допустимого и понятного PHP-кода, возвращающего JSON, выглядит так:

// декодируем в JSON массив: [«a»,»b»,»c»]

$data = [ ‘name’ => ‘God’, ‘age’ => -1 ];

// декодируем в JSON объект:

echo json_encode( $data );

Ответ 3

Согласно руководству по методу json_encode, он может возвращать нестроковый ответ ( false ): Возвращает строку в кодировке JSON в случае успеха или FALSE, если ошибка .

Когда это произойдет, echo json_encode($data) будет выведена пустая строка, которая является недопустимым JSON .

json_encode, например, завершится с ошибкой (и вернет false ), если его аргумент содержит строку, отличную от UTF-8.

Это состояние ошибки должно быть зафиксировано в PHP, например, следующим образом:

// Соберите все необходимое в переменную $data.

// Избегайте эха пустой строки (которая является недействительным JSON)

$json = json_encode([«jsonError» => json_last_error_msg()]);

// Этого не должно быть, но мы идем до конца:

// Установка кода статуса ответа HTTP: 500 — Внутренняя ошибка сервера http_response_code(500);

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

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

Дополнительные сведения о работе с ошибками JSON см. в документации PHP .

Ответ 3

Также хорошо установить безопасность доступа — просто замените «*» на домен, к которому вы хотите получить доступ.

Ответ 4

На этот вопрос было много ответов, но ни один из них не охватывает весь процесс возврата чистого JSON со всем необходимым для предотвращения искажения ответа JSON.

function returnJsonHttpResponse($success, $data) <

// удалите любую строку, которая может создать недопустимый JSON

// такие как PHP Notice, Warning, logs.

// это очистит все ранее добавленные заголовки, чтобы начать с чистого листа

// Установите тип содержимого JSON и charset

// (charset может быть установлен на что-то другое)

header(«Content-type: application/json; charset=utf-8»);

// Установите код ответа HTTP, 2xx = SUCCESS,

// любой другой будет ошибкой, обратитесь к документации HTTP

// кодируйте ваш объект или массив PHP в строку JSON.

// stdClass или массив

Ответ 5

Простая функция для возврата ответа JSON с кодом состояния HTTP .

function json_response($data=null, $httpStatus=200) <

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.

Источник

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, вы можете использовать:

Источник

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!

Вступление

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-кодированную строку в качестве своего первого параметра и анализирует ее в переменной PHP.

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

// Returns an object (The top level item in the JSON string is a JSON dictionary)
$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$object = json_decode($json_string);
printf('Hello %s, You are %s years old.', $object->name, $object->age);
#> Hello Jeff, You are 20 years old.

// Returns an array (The top level item in the JSON string is a JSON array)
$json_string = '["Jeff", 20, true, ["red", "blue"]]';
$array = json_decode($json_string);
printf('Hello %s, You are %s years old.', $array[0], $array[1]);

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

// Dump our above $object to view how it was decoded
var_dump($object);

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

class stdClass#2 (4) {
 ["name"] => string(4) "Jeff"
 ["age"] => int(20)
 ["active"] => bool(true)
 ["colors"] =>
   array(2) {
     [0] => string(3) "red"
     [1] => string(4) "blue"
   }
}

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

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

$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$array = json_decode($json_string, true); // Note the second parameter
var_dump($array);

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

array(4) {
  ["name"] => string(4) "Jeff"
  ["age"] => int(20)
  ["active"] => bool(true)
  ["colors"] =>
  array(2) {
    [0] => string(3) "red"
    [1] => string(4) "blue"
  }
}

Второй параметр ( $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:

$json = json_decode('"some string"', true);
var_dump($json, json_last_error_msg());

Выход:

string(11) "some string"
string(8) "No error"

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

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

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

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

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

var_dump(json_decode('tRue'), json_last_error_msg());
var_dump(json_decode('tRUe'), json_last_error_msg());
var_dump(json_decode('tRUE'), json_last_error_msg());
var_dump(json_decode('TRUe'), json_last_error_msg());
var_dump(json_decode('TRUE'), json_last_error_msg());
var_dump(json_decode('true'), json_last_error_msg());

До PHP 5.6:

bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"

И после:

NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
bool(true)
string(8) "No error"

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

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

$json = "{'name': 'Jeff', 'age': 20 }" ;  // invalid json 

$person = json_decode($json);
echo $person->name;    //  Notice: Trying to get property of non-object: returns null
echo json_last_error();     
#  4 (JSON_ERROR_SYNTAX)
echo json_last_error_msg(); 
#  unexpected character 

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

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

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

$array = [
    'name' => 'Jeff',
    'age' => 20,
    'active' => true,
    'colors' => ['red', 'blue'],
    'values' => [0=>'foo', 3=>'bar'],
];

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

echo json_encode($array);

Выход:

{"name":"Jeff","age":20,"active":true,"colors":["red","blue"],"values":{"0":"foo","3":"bar"}}

аргументы

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

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

$array = ['Joel', 23, true, ['red', 'blue']];
echo json_encode($array);
echo json_encode($array, JSON_FORCE_OBJECT);

["Joel",23,true,["red","blue"]]
{"0":"Joel","1":23,"2":true,"3":{"0":"red","1":"blue"}}

$array = ["tag"=>"<>", "amp"=>"&", "apos"=>"'", "quot"=>"""];
echo json_encode($array);
echo json_encode($array, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT);

{"tag":"<>","amp":"&","apos":"'","quot":"""}
{"tag":"u003Cu003E","amp":"u0026","apos":"u0027","quot":"u0022"}

$array = ['23452', 23452];
echo json_encode($array);
echo json_encode($array, JSON_NUMERIC_CHECK);

["23452",23452]    
[23452,23452]

$array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
echo json_encode($array);
echo json_encode($array, JSON_PRETTY_PRINT);

{"a":1,"b":2,"c":3,"d":4}
{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4
}

$array = ['filename' => 'example.txt', 'path' => '/full/path/to/file/'];
echo json_encode($array);
echo json_encode($array, JSON_UNESCAPED_SLASHES);

{"filename":"example.txt","path":"/full/path/to/file"}
{"filename":"example.txt","path":"/full/path/to/file"}

$blues = ["english"=>"blue", "norwegian"=>"blå", "german"=>"blau"];
echo json_encode($blues);
echo json_encode($blues, JSON_UNESCAPED_UNICODE);

{"english":"blue","norwegian":"blu00e5","german":"blau"}
{"english":"blue","norwegian":"blå","german":"blau"}

$fp = fopen("foo.txt", "r");
$array = ["file"=>$fp, "name"=>"foo.txt"];
echo json_encode($array); // no output
echo json_encode($array, JSON_PARTIAL_OUTPUT_ON_ERROR);

{"file":null,"name":"foo.txt"}

$array = [5.0, 5.5];
echo json_encode($array);
echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);

[5,5.5]
[5.0,5.5]

$array = ["line"=>"xe2x80xa8", "paragraph"=>"xe2x80xa9"];
echo json_encode($array, JSON_UNESCAPED_UNICODE);
echo json_encode($array, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_LINE_TERMINATORS);

{"line":"u2028","paragraph":"u2029"}
{"line":"
","paragraph":"
"}

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

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

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

// An incorrectly formed JSON string
$jsonString = json_encode("{'Bad JSON':xB1x31}");

if (json_last_error() != JSON_ERROR_NONE) {
    printf("JSON Error: %s", json_last_error_msg());
}

#> JSON Error: Malformed UTF-8 characters, possibly incorrectly encoded

json_last_error_msg

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

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

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

// Don't do this:
if (json_last_error_msg()){} // always true (it's a string)
if (json_last_error_msg() != "No Error"){} // Bad practice

// Do this: (test the integer against one of the pre-defined constants)
if (json_last_error() != JSON_ERROR_NONE) {
    // Use json_last_error_msg to display the message only, (not test against it)
    printf("JSON Error: %s", json_last_error_msg());
}

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

if (!function_exists('json_last_error_msg')) {
    function json_last_error_msg() {
        static $ERRORS = array(
            JSON_ERROR_NONE => 'No error',
            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
            JSON_ERROR_STATE_MISMATCH => 'State mismatch (invalid or malformed JSON)',
            JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded',
            JSON_ERROR_SYNTAX => 'Syntax error',
            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters, possibly incorrectly encoded'
        );

        $error = json_last_error();
        return isset($ERRORS[$error]) ? $ERRORS[$error] : 'Unknown error';
    }
}

json_last_error

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

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

class User extends Model implements JsonSerializable {
    public $id;
    public $name;
    public $surname;
    public $username;
    public $password;
    public $email;
    public $date_created;
    public $date_edit;
    public $role;
    public $status;

    public function jsonSerialize() {
        return [
            'name' => $this->name,
            'surname' => $this->surname,
            'username' => $this->username
        ];
    }
}

public function jsonSerialize()

json_encode($User);

{"name":"John", "surname":"Doe", "username" : "TestJson"}

<?php

class User {
    // private properties only within this class
    private $id;
    private $date_created;
    private $date_edit;

    // properties used in extended classes
    protected $password;
    protected $email;
    protected $role;
    protected $status;

    // share these properties with the end user        
    public $name;
    public $surname;
    public $username;

    // jsonSerialize() not needed here
}        

$theUser = new User();

var_dump(json_encode($theUser));

string(44) "{"name":null,"surname":null,"username":null}"

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

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

<?php
 $result = array('menu1' => 'home', 'menu2' => 'code php', 'menu3' => 'about');

//return the json response :
header('Content-Type: application/json');  // <-- header declaration
echo json_encode($result, true);    // <--- encode
exit();

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

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

header("Content-Type: application/json;charset=utf-8");

Пример jQuery:

$.ajax({
        url:'url_your_page_php_that_return_json'        
    }).done(function(data){
        console.table('json ',data);
        console.log('Menu1 : ', data.menu1);
    });

Introduction

JSON (JavaScript Object Notation) is a platform and language independent way of serializing objects into plaintext. Because it is often used on web and so is PHP, there is a basic extension for working with JSON in PHP.

Syntax

• string json_encode ( mixed $value [, int $options = 0 [, int $depth = 512 ]] )
• mixed json_decode ( string $json [, bool $assoc = false [, int $depth = 512 [, int $options = 0 ]]] )

Parameters

Decoding a JSON string

The json_decode() function takes a JSON-encoded string as its first parameter and parses it into a PHP variable.

Normally, json_decode() will return an object of stdClass if the top level item in the JSON object is a dictionary or an indexed array if the JSON object is an array. It will also return scalar values or NULL for certain scalar values, such as simple strings, "true", "false", and "null". It also returns NULL on any error.

// Returns an object (The top level item in the JSON string is a JSON dictionary)
$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$object = json_decode($json_string);
printf('Hello %s, You are %s years old.', $object->name, $object->age);
#> Hello Jeff, You are 20 years old.

// Returns an array (The top level item in the JSON string is a JSON array)
$json_string = '["Jeff", 20, true, ["red", "blue"]]';
$array = json_decode($json_string);
printf('Hello %s, You are %s years old.', $array[0], $array[1]);

Use var_dump() to view the types and values of each property on the object we decoded above.

// Dump our above $object to view how it was decoded
var_dump($object);

Output (note the variable types):

class stdClass#2 (4) {
 ["name"] => string(4) "Jeff"
 ["age"] => int(20)
 ["active"] => bool(true)
 ["colors"] =>
   array(2) {
     [0] => string(3) "red"
     [1] => string(4) "blue"
   }
}

Note: The variable types in JSON were converted to their PHP equivalent.

To return an associative array for JSON objects instead of returning an object, pass true as the second parameter to json_decode().

$json_string = '{"name": "Jeff", "age": 20, "active": true, "colors": ["red", "blue"]}';
$array = json_decode($json_string, true); // Note the second parameter
var_dump($array);

Output (note the array associative structure):

array(4) {
  ["name"] => string(4) "Jeff"
  ["age"] => int(20)
  ["active"] => bool(true)
  ["colors"] =>
  array(2) {
    [0] => string(3) "red"
    [1] => string(4) "blue"
  }
}

The second parameter ($assoc) has no effect if the variable to be returned is not an object.

Note: If you use the $assoc parameter, you will lose the distinction between an empty array and an empty object. This means that running json_encode() on your decoded output again, will result in a different JSON structure.

If the JSON string has a «depth» more than 512 elements (20 elements in versions older than 5.2.3, or 128 in version 5.2.3) in recursion, the function json_decode() returns NULL. In versions 5.3 or later, this limit can be controlled using the third parameter ($depth), as discussed below.

According to the manual:

PHP implements a superset of JSON as specified in the original » RFC 4627 — it will also encode and decode scalar types and NULL. RFC 4627 only supports these values when they are nested inside an array or an object.
Although this superset is consistent with the expanded definition of «JSON text» in the newer » RFC 7159 (which aims to supersede RFC 4627) and » ECMA-404, this may cause interoperability issues with older JSON parsers that adhere strictly to RFC 4627 when encoding a single scalar value.

This means, that, for example, a simple string will be considered to be a valid JSON object in PHP:

$json = json_decode('"some string"', true);
var_dump($json, json_last_error_msg());

Output:

string(11) "some string"
string(8) "No error"

But simple strings, not in an array or object, are not part of the RFC 4627 standard. As a result, such online checkers as JSLint, JSON Formatter & Validator (in RFC 4627 mode) will give you an error.

There is a third $depth parameter for the depth of recursion (the default value is 512), which means the amount of nested objects inside the original object to be decoded.

There is a fourth $options parameter. It currently accepts only one value, JSON_BIGINT_AS_STRING. The default behavior (which leaves off this option) is to cast large integers to floats instead of strings.

Invalid non-lowercased variants of the true, false and null literals
are no longer accepted as valid input.

So this example:

var_dump(json_decode('tRue'), json_last_error_msg());
var_dump(json_decode('tRUe'), json_last_error_msg());
var_dump(json_decode('tRUE'), json_last_error_msg());
var_dump(json_decode('TRUe'), json_last_error_msg());
var_dump(json_decode('TRUE'), json_last_error_msg());
var_dump(json_decode('true'), json_last_error_msg());

Before PHP 5.6:

bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"
bool(true)
string(8) "No error"

And after:

NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
NULL
string(12) "Syntax error"
bool(true)
string(8) "No error"

Similar behavior occurs for false and null.

Note that json_decode() will return NULL if the string cannot be converted.

$json = "{'name': 'Jeff', 'age': 20 }" ;  // invalid json 

$person = json_decode($json);
echo $person->name;    //  Notice: Trying to get property of non-object: returns null
echo json_last_error();     
#  4 (JSON_ERROR_SYNTAX)
echo json_last_error_msg(); 
#  unexpected character 

It is not safe to rely only on the return value being NULL to detect errors. For example, if the JSON string contains nothing but "null", json_decode() will return null, even though no error occurred.

Encoding a JSON string

The json_encode function will convert a PHP array (or, since PHP 5.4, an object which implements the JsonSerializable interface) to a JSON-encoded string. It returns a JSON-encoded string on success or FALSE on failure.

$array = [
    'name' => 'Jeff',
    'age' => 20,
    'active' => true,
    'colors' => ['red', 'blue'],
    'values' => [0=>'foo', 3=>'bar'],
];

During encoding, the PHP data types string, integer, and boolean are converted to their JSON equivalent. Associative arrays are encoded as JSON objects, and – when called with default arguments – indexed arrays are encoded as JSON arrays. (Unless the array keys are not a continuous numeric sequence starting from 0, in which case the array will be encoded as a JSON object.)

echo json_encode($array);

Output:

{"name":"Jeff","age":20,"active":true,"colors":["red","blue"],"values":{"0":"foo","3":"bar"}}

Arguments

Since PHP 5.3, the second argument to json_encode is a bitmask which can be one or more of the following.

As with any bitmask, they can be combined with the binary OR operator |.

$array = ['Joel', 23, true, ['red', 'blue']];
echo json_encode($array);
echo json_encode($array, JSON_FORCE_OBJECT);

["Joel",23,true,["red","blue"]]
{"0":"Joel","1":23,"2":true,"3":{"0":"red","1":"blue"}}

$array = ["tag"=>"<>", "amp"=>"&", "apos"=>"'", "quot"=>"""];
echo json_encode($array);
echo json_encode($array, JSON_HEX_TAG | JSON_HEX_AMP | JSON_HEX_APOS | JSON_HEX_QUOT);

{"tag":"<>","amp":"&","apos":"'","quot":"""}
{"tag":"u003Cu003E","amp":"u0026","apos":"u0027","quot":"u0022"}

$array = ['23452', 23452];
echo json_encode($array);
echo json_encode($array, JSON_NUMERIC_CHECK);

["23452",23452]    
[23452,23452]

$array = ['a' => 1, 'b' => 2, 'c' => 3, 'd' => 4];
echo json_encode($array);
echo json_encode($array, JSON_PRETTY_PRINT);

{"a":1,"b":2,"c":3,"d":4}
{
    "a": 1,
    "b": 2,
    "c": 3,
    "d": 4
}

$array = ['filename' => 'example.txt', 'path' => '/full/path/to/file/'];
echo json_encode($array);
echo json_encode($array, JSON_UNESCAPED_SLASHES);

{"filename":"example.txt","path":"/full/path/to/file"}
{"filename":"example.txt","path":"/full/path/to/file"}

$blues = ["english"=>"blue", "norwegian"=>"blå", "german"=>"blau"];
echo json_encode($blues);
echo json_encode($blues, JSON_UNESCAPED_UNICODE);

{"english":"blue","norwegian":"blu00e5","german":"blau"}
{"english":"blue","norwegian":"blå","german":"blau"}

$fp = fopen("foo.txt", "r");
$array = ["file"=>$fp, "name"=>"foo.txt"];
echo json_encode($array); // no output
echo json_encode($array, JSON_PARTIAL_OUTPUT_ON_ERROR);

{"file":null,"name":"foo.txt"}

$array = [5.0, 5.5];
echo json_encode($array);
echo json_encode($array, JSON_PRESERVE_ZERO_FRACTION);

[5,5.5]
[5.0,5.5]

$array = ["line"=>"xe2x80xa8", "paragraph"=>"xe2x80xa9"];
echo json_encode($array, JSON_UNESCAPED_UNICODE);
echo json_encode($array, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_LINE_TERMINATORS);

{"line":"u2028","paragraph":"u2029"}
{"line":"
","paragraph":"
"}

Debugging JSON errors

When json_encode or json_decode fails to parse the string provided, it will return false. PHP itself will not raise any errors or warnings when this happens, the onus is on the user to use the json_last_error() and json_last_error_msg() functions to check if an error occurred and act accordingly in your application (debug it, show an error message, etc.).

The following example shows a common error when working with JSON, a failure to decode/encode a JSON string (due to the passing of a bad UTF-8 encoded string, for example).

// An incorrectly formed JSON string
$jsonString = json_encode("{'Bad JSON':xB1x31}");

if (json_last_error() != JSON_ERROR_NONE) {
    printf("JSON Error: %s", json_last_error_msg());
}

#> JSON Error: Malformed UTF-8 characters, possibly incorrectly encoded

json_last_error_msg

json_last_error_msg() returns a human readable message of the last error that occurred when trying to encode/decode a string.

• This function will always return a string, even if no error occurred.
  The default non-error string is No Error
• It will return false if some other (unknown) error occurred
• Careful when using this in loops, as json_last_error_msg will be overridden on each iteration.

You should only use this function to get the message for display, not to test against in control statements.

// Don't do this:
if (json_last_error_msg()){} // always true (it's a string)
if (json_last_error_msg() != "No Error"){} // Bad practice

// Do this: (test the integer against one of the pre-defined constants)
if (json_last_error() != JSON_ERROR_NONE) {
    // Use json_last_error_msg to display the message only, (not test against it)
    printf("JSON Error: %s", json_last_error_msg());
}

This function doesn’t exist before PHP 5.5. Here is a polyfill implementation:

if (!function_exists('json_last_error_msg')) {
    function json_last_error_msg() {
        static $ERRORS = array(
            JSON_ERROR_NONE => 'No error',
            JSON_ERROR_DEPTH => 'Maximum stack depth exceeded',
            JSON_ERROR_STATE_MISMATCH => 'State mismatch (invalid or malformed JSON)',
            JSON_ERROR_CTRL_CHAR => 'Control character error, possibly incorrectly encoded',
            JSON_ERROR_SYNTAX => 'Syntax error',
            JSON_ERROR_UTF8 => 'Malformed UTF-8 characters, possibly incorrectly encoded'
        );

        $error = json_last_error();
        return isset($ERRORS[$error]) ? $ERRORS[$error] : 'Unknown error';
    }
}

json_last_error

json_last_error() returns an integer mapped to one of the pre-defined constants provided by PHP.

Using JsonSerializable in an Object

class User extends Model implements JsonSerializable {
    public $id;
    public $name;
    public $surname;
    public $username;
    public $password;
    public $email;
    public $date_created;
    public $date_edit;
    public $role;
    public $status;

    public function jsonSerialize() {
        return [
            'name' => $this->name,
            'surname' => $this->surname,
            'username' => $this->username
        ];
    }
}

public function jsonSerialize()

json_encode($User);

{"name":"John", "surname":"Doe", "username" : "TestJson"}

<?php

class User {
    // private properties only within this class
    private $id;
    private $date_created;
    private $date_edit;

    // properties used in extended classes
    protected $password;
    protected $email;
    protected $role;
    protected $status;

    // share these properties with the end user        
    public $name;
    public $surname;
    public $username;

    // jsonSerialize() not needed here
}        

$theUser = new User();

var_dump(json_encode($theUser));

string(44) "{"name":null,"surname":null,"username":null}"

Header json and the returned response

By adding a header with content type as JSON:

<?php
 $result = array('menu1' => 'home', 'menu2' => 'code php', 'menu3' => 'about');

//return the json response :
header('Content-Type: application/json');  // <-- header declaration
echo json_encode($result, true);    // <--- encode
exit();

The header is there so your app can detect what data was returned and how it should handle it.
Note that : the content header is just information about type of returned data.

If you are using UTF-8, you can use :

header("Content-Type: application/json;charset=utf-8");

Example jQuery :

$.ajax({
        url:'url_your_page_php_that_return_json'        
    }).done(function(data){
        console.table('json ',data);
        console.log('Menu1 : ', data.menu1);
    });