Json ошибка как исправить - Решение и исправление самых разных ошибок на TopOshibok.ru

JSON ( JavaScript Object Notation), is widely used format for asynchronous communication between webpage or mobile application to back-end servers. Due to increasing trend in Single Page Application or Mobile Application, popularity of the JSON is extreme.

Why do we get JSON parse error?

Parsing JSON is a very common task in JavaScript. JSON.parse() is a built-in method in JavaScript which is used to parse a JSON string and convert it into a JavaScript object. If the JSON string is invalid, it will throw a SyntaxError.

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json);
console.log(obj.count);
// expected output: 42
console.log(obj.result);
// expected output: true

How to handle JSON parse error?

There are many ways to handle JSON parse error. In this post, I will show you how to handle JSON parse error in JavaScript.

1. Using try-catch block

The most common way to handle JSON parse error is using try-catch block. If the JSON string is valid, it will return a JavaScript object. If the JSON string is invalid, it will throw a SyntaxError.

try {
  const json = '{"result":true, "count":42}';
  const obj = JSON.parse(json);
  console.log(obj.count);
  // expected output: 42
  console.log(obj.result);
  // expected output: true
} catch (e) {
  console.log(e);
  // expected output: SyntaxError: Unexpected token o in JSON at position 1
}

2. Using if-else block

Another way to handle JSON parse error is using if-else block.

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json);
if (obj instanceof SyntaxError) {
  console.log(obj);
  // expected output: SyntaxError: Unexpected token o in JSON at position 1
} else {
  console.log(obj.count);
  // expected output: 42
  console.log(obj.result);
  // expected output: true
}

3. Using try-catch block with JSON.parse()

The third way to handle JSON parse error is using try-catch block with JSON.parse().

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json, (key, value) => {
  try {
    return JSON.parse(value);
  } catch (e) {
    return value;
  }
});
console.log(obj.count);
// expected output: 42
console.log(obj.result);
// expected output: true

4. Using try-catch block with JSON.parse() and JSON.stringify()

The fourth way to handle JSON parse error is using try-catch block with JSON.parse() and JSON.stringify(). If the JSON string is valid, it will return a JavaScript object. If the JSON string is invalid, it will return a SyntaxError.

const json = '{"result":true, "count":42}';
const obj = JSON.parse(json, (key, value) => {
  try {
    return JSON.parse(value);
  } catch (e) {
    return value;
  }
});
const str = JSON.stringify(obj);
console.log(str);
// expected output: {"result":true,"count":42}

Источник

The above Idea is good but I had problem with that. My json Sting consisted only one additional double quote in it.
So, I made a fix to the above given code.

The jsonStr was

{
    "api_version": "1.3",
    "response_code": "200",
    "id": "3237490513229753",
    "lon": "38.969916127827",
    "lat": "45.069889625267",
    "page_url": null,
    "name": "ATB",
    "firm_group": {
        "id": "3237499103085728",
        "count": "1"
    },
    "city_name": "Krasnodar",
    "city_id": "3237585002430511",
    "address": "Turgeneva,   172/1",
    "create_time": "2008-07-22 10:02:04 07",
    "modification_time": "2013-08-09 20:04:36 07",
    "see_also": [
        {
            "id": "3237491513434577",
            "lon": 38.973110606808,
            "lat": 45.029031222211,
            "name": "Advance",
            "hash": "5698hn745A8IJ1H86177uvgn94521J3464he26763737242Cf6e654G62J0I7878e",
            "ads": {
                "sponsored_article": {
                    "title": "Center "ADVANCE",
                    "text": "Business.English."
                },
                "warning": null
            }
        }
    ]
}

The fix is as follows:

import json, re
def fixJSON(jsonStr):
    # Substitue all the backslash from JSON string.
    jsonStr = re.sub(r'\\', '', jsonStr)
    try:
        return json.loads(jsonStr)
    except ValueError:
        while True:
            # Search json string specifically for '"'
            b = re.search(r'[\w|"]\s?(")\s?[\w|"]', jsonStr)

            # If we don't find any the we come out of loop
            if not b:
                break

            # Get the location of \"
            s, e = b.span(1)
            c = jsonStr[s:e]

            # Replace \" with \'
            c = c.replace('"',"'")
            jsonStr = jsonStr[:s] + c + jsonStr[e:]
        return json.loads(jsonStr)

This code also works for JSON string mentioned in problem statement

OR you can also do this:

def fixJSON(jsonStr):
    # First remove the " from where it is supposed to be.
    jsonStr = re.sub(r'\\', '', jsonStr)
    jsonStr = re.sub(r'{"', '{`', jsonStr)
    jsonStr = re.sub(r'"}', '`}', jsonStr)
    jsonStr = re.sub(r'":"', '`:`', jsonStr)
    jsonStr = re.sub(r'":', '`:', jsonStr)
    jsonStr = re.sub(r'","', '`,`', jsonStr)
    jsonStr = re.sub(r'",', '`,', jsonStr)
    jsonStr = re.sub(r',"', ',`', jsonStr)
    jsonStr = re.sub(r'\["', '\[`', jsonStr)
    jsonStr = re.sub(r'"\]', '`\]', jsonStr)

    # Remove all the unwanted " and replace with ' '
    jsonStr = re.sub(r'"',' ', jsonStr)

    # Put back all the " where it supposed to be.
    jsonStr = re.sub(r'\`','\"', jsonStr)

    return json.loads(jsonStr)

Источник

Online JSON Fixer is easy to use for repair or fix invalid JSON data online. Json Fixer / Debugger also helps to fix error in JSON data that makes your life easier.

JSON Fixer can fix these JSON data issues:

It will add / fix missing quotes around keys
It will add / fix missing escape characters
It will add / fix missing commas
It will add / fix missing closing brackets
It will replace with double quotes in place of single quotes
It will replace with regular double quotes in place of special quote characters like “…”
It will replace with regular spaces in place of special white space characters
It will replace with null, true, and false in place of Python constants None, True, and False
It will clean trailing commas
It will clean comments like /* … */ and // …
It will clean JSONP notation like callback({ … })

It will clean escape characters from an escaped string like {\»stringified\»: \»content\»}
It will clean MongoDB data types like NumberLong(2) and ISODate(«2022-03-03T05:02:11.111Z»)
It will concatenate strings like «longer text» + «more text on next line»

What can you do with JSON File Fixer?

It helps to fix JSON files and APIs data.
This tool allows loading the JSON URL to Fix. Use your JSON REST URL to Fix. Click on the URL button, Enter URL and Submit.
Users can also debug the JSON file by uploading the file.
Once you have fix JSON Data. User can download it as a file or save it as a link and Share it to social sites.
JSON Fixer online works well on Windows, MAC, Linux, Chrome, Firefox, Edge, and Safari.

Know more about JSON.

How to Create JSON File?

JSON Full Form
What is JSON?
JSON Example with JSON Array
Pretty Print JSON using Python
Read JSON File Using Python
Validate JSON using PHP
Comment Inside JSON
How to open JSON File?
Json_Encode() Pretty Print using PHP
JSON to CSV Python
Python JSON
JSON Cheat Sheet

Example for JSON Fixer

Invalid JSON

{
"InsuranceCompanies": {
    "source": "investopedia.com
    }
}

Fixed JSON

{
"InsuranceCompanies": {
    "source": "investopedia.com"
    }
}

Источник

Getting «[object Object]» is not valid JSON error in your code is annoying, but there is often a simple fix. Maybe you don’t need JSON.parse(), or maybe you’re giving it the wrong data. Here’s an easy fix (and how to troubleshoot if you’re still stuck).

If you are using JSON.parse() and have run into the Uncaught SyntaxError: "[object Object]" is not valid JSON error, you’re not alone! This error pops up from time to time and is usually because you’re not giving JSON.parse() a JSON string.

So let’s see how we can fix that!

The easiest fix — you don’t need `JSON.parse()`!

Often this error happens because you are giving JSON.parse() a JavaScript object.

JSON.parse()‘s job is to turn JSON back into JavaScript, so if you already have the JavaScript, you don’t need JSON.parse()!

For example, this could happen where you were expecting to get JSON back from a server response, but it’s already been converted to JavaScript* before reaching your code.

Here’s a simple example of how removing JSON.parse() gets rid of the error.

// ❌ ERROR!
const obj = JSON.parse({ name: "my object" });
// Error: "[object Object]" is not valid JSON

// ✅ WORKS!
const obj = { name: "my object" };

*Some libraries will automatically parse JSON back to JavaScript for you. For example, Axios does this in the browser and Express query parser will do this on the server too.

The most common mistake — `JSON.parse()` instead of `JSON.stringify()`

If you’re giving JSON.parse() an object, maybe you meant to use JSON.stringify() instead?

JSON.parse() turns JSON into JavaScript
JSON.stringify() turns JavaScript into JSON

So if you were trying to turn your JavaScript object into JSON, use JSON.stringify().

Turn the object into JSON with `JSON.stringify()`

If you really do want to use JSON.parse(), you need to give it some valid JSON. You can turn an object into JSON with JSON.stringify() and get rid of the error that way too.

Here’s an example, but I really wouldn’t do this since all we are doing is turning the object into JSON and back to an object, which seems pretty, pointless.

// 🤷‍♀️
const obj = JSON.parse(JSON.stringify({ name: "my object" }));

This may be useful if something else happens in between the conversion. For example, you turn the object into a JSON string for localStorage, and then need to retrieve it and turn it back into an object at a later time.

JSON.stringify() turns JavaScript into a valid JSON string, and you can also do this manually like in the example below.

const obj = JSON.parse(`{ "name": "my object" }`);

Troubleshooting

Still stuck? Here’s how I would troubleshoot this issue in my code:

1. Check if what you are passing to `JSON.parse()` is a string

// ❌ ERROR!
const result = { name: "my object" };
console.log(typeof result);
// "object" ❌
const obj = JSON.parse(result);
// Error: "[object Object]" is not valid JSON

// ✅ WORKS!
const result = `{ "name": "my object" }`;
console.log(typeof result);
// "string" ✅
const obj = JSON.parse(result);

2. Check the string is valid JSON

Chances are, if you get this error, it’s because you are passing an object to JSON.parse(). If you are passing a string and it’s not valid JSON, you’re more likely to get an error like:

Error: Expected property name or '}' in JSON at position 2

Nonetheless, double check your JSON is valid.

// ❌ ERROR!
const result = "{ hfkdshfd }";
console.log(typeof result);
// "string" ✅
const obj = JSON.parse(result); // ❌
// Error: Expected property name or '}' in JSON at position 2

3. Check if you need to `await` the result

Maybe you are getting valid JSON, but you are just calling JSON.parse() too soon.

This can happen when using the FetchAPI, for example.

async function logJSONData() {
  const response = await fetch("http://example.com/movies.json");
  const jsonData = response.json(); // ❌ no await
  console.log(jsonData);
};

Make sure you await the response too.

async function logJSONData() {
  const response = await fetch("http://example.com/movies.json");
  const jsonData = await response.json(); // ✅ await
  console.log(jsonData);
};

Источник

Уровень сложности
Простой

Время на прочтение
9 мин

Количество просмотров 6.1K

JSON — это инструмент, которым каждый веб-разработчик пользуется ежедневно. На первый взгляд кажется, что JSON слишком прост и незамысловат, чтобы читать про него целую статью. Но если вы не знаете, что такое санитизация данных, никогда не слышали про JSON Injection или XSS атаки, если информация о том, что JSON.parse и JSON.stringify принимают 2 и 3 аргумента для вас новость, то эта статья будет вам полезна.

Общие положения

JSON (JavaScript Object Notation) — это легковесный формат данных, который используется для обмена данными между клиентом и сервером в веб-приложениях.

В начале 2000-х годов была потребность в формате данных, который был бы удобнее и проще XML. Дуглас Крокфорд предложил использовать для обмена данными формат объектного литерала JavaScript, так и появился JSON. Предложенный Крокфордом формат оказался более компактным по сравнению с XML, проще для чтения и записи и прост в парсинге и генерации. В результате сейчас JSON является основным форматом обмена данными в веб-разработке.

JSON основан на двух основных структурах данных: объекте и массиве. Объект — это набор пар «ключ-значение», массив — это упорядоченный список значений. Ключи в объектах JSON всегда являются строками, а значения могут быть строками, числами, объектами, массивами, булевыми значениями или null.

{
  "name": "John",
  "age": 30,
  "is_student": false,
  "courses": ["math", "history", "chemistry"],
  "personal_info": {
    "address": "123 Main St",
    "phone_number": "123-456-7890"
  }
}

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

Безопасное использование JSON

Основные виды атак

1. JSON Injection

Эта атака заключается в том, что злоумышленник вставляет вредоносный код в JSON, который затем обрабатывается веб-приложением.

Пример: Если веб-приложение берет пользовательский ввод и непосредственно вставляет его в JSON без проверки или санитизации (об этом подробно дальше), злоумышленник может вставить вредоносный код. Этот код может быть выполнен при обработке JSON.

const userInput = getUserInput();
const data = `{"name": "${userInput}"}`
const jsonData = JSON.parse(data);

В этом случае, если пользователь вводит что-то вроде "", "isAdmin": "true"}, вредоносный код будет добавлен в JSON, создавая объект { "name": "", "isAdmin": "true"}.

2. Cross-Site Scripting (XSS)

XSS — это тип атаки, при которой злоумышленник вставляет вредоносный скрипт в веб-страницу, который затем выполняется в браузере пользователя.

Пример: Если веб-приложение вставляет данные JSON напрямую в HTML без предварительной санитизации, это может привести к XSS-атаке.

const jsonData = getJsonData();
const element = document.getElementById('output');
element.innerHTML = jsonData.content;

Если jsonData.content содержит что-то вроде

<script>maliciousCode()</script>

вредоносный код будет выполнен в браузере пользователя.

3. SQL Injection и JSON

SQL-инъекция — это вид атаки, при которой злоумышленник внедряет или «инъецирует» вредоносный SQL код в запрос к базе данных через ввод пользователя. SQL-инъекции могут привести к несанкционированному доступу к базе данных, краже, изменению или уничтожению данных.

Примером может служить ситуация, когда данные с клиентской стороны, например, из формы на веб-странице, принимаются в формате JSON, и затем используются для построения SQL-запроса.

const userData = JSON.parse(userInput);
const query = `SELECT * FROM users WHERE name = '${userData.name}' AND password = '${userData.password}'`;

Злоумышленник может подставить в поле name или password строку, которая, будучи вставлена в запрос SQL, изменит его логику. Например, следующий JSON:

{
  "name": "' OR '1'='1'; --",
  "password": "any"
}

после подстановки в запрос приведет к его изменению:

SELECT * FROM users WHERE name = '' OR '1'='1'; --' AND password = 'any'

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

Дисклеймер: я привел стандартный пример SQL-инъекции, он призван демонстрировать концепцию, а не реальный вектор атаки.

Важно понимать, что JSON сам по себе не имеет отношения к SQL-инъекциям. Однако, если данные, полученные в формате JSON, используются для формирования SQL-запросов без предварительной валидации и санитизации, то это может создать уязвимости для таких атак.

Чтобы предотвратить SQL-инъекции, рекомендуется использовать подготовленные или параметризованные запросы, а также проводить валидацию и санитизацию всех входных данных. Подготовленные запросы используют параметры вместо прямой вставки ввода пользователя в запрос. Библиотеки баз данных обычно предоставляют функции для создания подготовленных запросов.

Пример использования подготовленного запроса на Node.js с использованием MySQL:

const userData = JSON.parse(userInput);
let sql = `SELECT * FROM users WHERE name = ? AND password = ?`;
const inserts = [userData.name, userData.password];
sql = mysql.format(sql, inserts);

В этом примере, даже если злоумышленник попытается внедрить вредоносный код через JSON, он будет безопасно обработан библиотекой MySQL, и SQL-инъекция не произойдет.

Предотвращение атак

Основой безопасного использования JSON являются валидация и санитизация данных. Эти инструменты универсальны и эффективны против всех описанных выше видов атак.

Санитизация данных

Санитизация данных — это процесс очистки данных от вредоносных или нежелательных элементов. В контексте веб-разработки это обычно включает удаление или замену символов, которые могут быть использованы для проведения атак, таких как вставка SQL, XSS или JSON Injection.

Инструменты для санитизации данных:

DOMPurify: Это библиотека для JavaScript, которая позволяет очищать HTML, MathML и SVG от XSS атак. DOMPurify очень прост в использовании. Просто передайте ей строку, которую нужно санитизировать, и она вернет безопасную строку.

const clean = DOMPurify.sanitize(dirty);

express-validator: Это набор middleware функций для Express.js, который предоставляет мощные инструменты валидации и санитизации.

const express = require('express');
const { query, validationResult } = require('express-validator');

const app = express();
app.use(express.json());
app.get('/hello', query('person').notEmpty().escape(), (req, res) => {
  const result = validationResult(req);
  if (result.isEmpty()) {
    return res.send(`Hello, ${req.query.person}!`);
  }
  res.send({ errors: result.array() });
});
app.listen(3000);

В этом примере ‘express-validator’ проверяет, что имя пользователя не пустое, а вызов escape() производит санитизацию данных.

Валидация данных

Валидация — это процесс проверки данных на соответствие определенным критериям или правилам. В контексте JSON валидация обычно включает в себя проверку следующего:

Соответствие структуры и типов данных предполагаемым. Например, если ожидается объект с определенными полями, валидация должна убедиться, что все эти поля присутствуют и имеют правильные типы данных.
Отсутствие нежелательных символов или паттернов, которые могут вызвать проблемы при обработке данных (например, вредоносный код).
Соответствие данных бизнес-правилам. Например, валидация может включать проверку того, что значение определенного поля находится в допустимом диапазоне.

JavaScript предоставляет некоторые базовые функции для валидации JSON.

JSON.stringify

JSON.stringify() преобразует объект JavaScript в строку JSON. Этот метод принимает три аргумента: значение для преобразования, функцию-заменитель и пробелы.

Значение: это может быть любой объект JavaScript или значение, которое вы хотите преобразовать в JSON.
Функция-заменитель (replacer): это опциональная функция, которая преобразует значения объекта перед их сериализацией. Она может использоваться для фильтрации или преобразования значений.
Пробелы: опциональный параметр, который контролирует отступы в сериализованном JSON. Это может быть число (количество пробелов) или строка (до 10 символов, используемых в качестве пробела).

const json = JSON.stringify(obj, (key, value) => {
  if (key === 'id') return undefined;
  return value;
}, 2);

В этом примере значение «id» удаляется из сериализованного JSON и используются два пробела для отступов в JSON.

Сериализация — это процесс преобразования состояния объекта в формат, который может быть сохранен или передан и затем восстановлен. В контексте JSON, сериализация обычно включает преобразование объекта JavaScript в строку JSON.

Десериализация — это обратный процесс. Он преобразует сериализованные данные обратно в их первоначальную форму. В контексте JSON, десериализация обычно включает преобразование строки JSON обратно в объект JavaScript.

JSON.parse

JSON.parse() преобразует строку JSON обратно в объект JavaScript. Этот метод принимает два аргумента: строку для преобразования и функцию-ревайвер.

Строка: это должна быть корректная строка JSON, которую вы хотите преобразовать в объект JavaScript.
Функция-ревайвер (reviver): это опциональная функция, которая преобразует значения объекта после их десериализации. Она может использоваться для преобразования или восстановления определенных значений.

const obj = JSON.parse(str, (key, value) => {
  if (key === 'date') return new Date(value);
  return value;
});

В примере выше, функция-ревайвер преобразует строку в объект Date в процессе десериализации JSON.

JSON Schema

Для более сложных случаев валидации, таких как проверка структуры объекта JSON и типов данных, может потребоваться использование сторонних библиотек, таких как Ajv (Another JSON Schema Validator).

Ajv использует стандарт, который называется JSON Schema который нужен для описания и валидации структуры JSON-данных.

Пример JSON Schema:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Product",
  "type": "object",
  "properties": {
    "id": {
      "type": "number"
    },
    "name": {
      "type": "string"
    },
    "price": {
      "type": "number",
      "exclusiveMinimum": 0
    },
    "tags": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "minItems": 1,
      "uniqueItems": true
    }
  },
  "required": ["id", "name", "price"]
}

Обратите внимание на поле:

"$schema": "http://json-schema.org/draft-07/schema#",

"$schema" является особым полем в JSON Schema. Это URI, который указывает на версию JSON Schema, которая была использована для создания вашей схемы. Это необходимо для корректной интерпретации и валидации схемы.

Вышеуказанная схема описывает объект «Product» с полями «id», «name», «price» и «tags». Поля «id», «name» и «price» являются обязательными. Поле «tags» должно быть массивом уникальных строк.

В данном примере, "$schema": "http://json-schema.org/draft-07/schema#" указывает, что ваша схема написана с использованием версии "draft-07" JSON Schema. Это помогает программам, которые обрабатывают вашу схему, правильно интерпретировать и применять правила валидации.

Ajv позволяет определить схему для данных, а затем проверять объекты на соответствие этой схеме.

const Ajv = require("ajv")
const ajv = new Ajv()
const schema = {
  type: "object",
  properties: {
    foo: {type: "integer"},
    bar: {type: "string"}
  },
  required: ["foo","bar"],
  additionalProperties: false
}
const data = {foo: 1, bar: "abc"}
const valid = ajv.validate(schema, data)
if (!valid) console.log(ajv.errors)

В этом примере, если данные не соответствуют схеме (например, foo не является числом, или одно из полей отсутствует), Ajv вернет ошибки, которые затем можно обработать.

Общие ошибки при работе с JSON и их решения

Синтаксические ошибки, ошибки сериализации/десериализации и ошибки передачи данных — это некоторые из наиболее распространенных проблем, с которыми разработчики сталкиваются при работе с JSON.

Синтаксические ошибки: JSON имеет строгий синтаксис. Например, все ключи должны быть заключены в двойные кавычки, а не в одинарные.
```
{ 'key': "value" } // ошибка
{ "key": "value" } // правильно
```
Кроме того, каждый элемент в массиве или пара ключ-значение в объекте должны быть разделены запятыми.
```
{ "key1": "value1" "key2": "value2" } // ошибка
{ "key1": "value1", "key2": "value2" } // правильно
```
Синтаксические ошибки могут быть легко обнаружены с помощью JSON валидаторов, например, JSONLint.
Ошибки сериализации/десериализации: Некоторые объекты JavaScript не могут быть корректно сериализованы в JSON или десериализованы из JSON. Например, функции и объекты Date в JavaScript не могут быть преобразованы в JSON. В этих случаях необходимо преобразовать объекты в поддерживаемые типы данных перед сериализацией или после десериализации. В этом примере, при преобразовании JSON обратно в объект, функция ревайвер преобразует строку даты обратно в объект Date. Без функции ревайвер, дата осталась бы строкой.
```
const user = {
  name: 'Tom',
  registered: new Date(),
};
const json = JSON.stringify(user);
// Преобразуем JSON обратно в объект, восстанавливая дату с помощью функции ревайвер
const parsedUser = JSON.parse(json, (key, value) => {
  if (key == 'registered') return new Date(value);
  return value;
});
console.log(parsedUser.registered); // Выведет объект Date, а не строку
```
Ошибки при передаче данных: JSON часто используется для передачи данных между клиентом и сервером. Если эти данные не правильно кодируются или декодируются, или если они теряются в процессе передачи, это может привести к ошибкам. Обычно ошибки кодирования и декодирования связаны с ошибками в заголовке ‘Content-Type’, там необходимо указать значение ‘application/json’.

'Content-Type': 'text/plain' // ошибка 
'Content-Type': 'application/json' // правильно

Заключение

Правильное использование JSON в веб-разработке критически важно для обеспечения безопасности и эффективности приложения. Валидация и санитизация данных, использование безопасных функций для обработки JSON и избегание распространенных ошибок могут помочь обеспечить надежную и безопасную работу с JSON. Надеюсь теперь вы согласитесь, что даже в таком простом инструменте, как JSON, могут быть неожиданные подводные камни и особенности, о которых нужно знать.

Также напоследок хочу пригласить вас на бесплатный урок, на котором поговорим о том, как работать с многопоточностью в NodeJS. Также на уроке вы познакомитесь с WorkerThreads. Регистрация доступна по ссылке.

Полезные ссылки

Что еще почитать по теме:

Документация MDN по JSON
Руководство OWASP по предотвращению SQL инъекций.
Подробнее о истории и важности JSON можно прочитать здесь и здесь.
Подробнее про JSON Schema тут и тут.

Инструменты:

Ajv (Another JSON Schema Validator): Один из самых популярных JSON Schema валидаторов. Он позволяет создавать сложные правила валидации, используя JSON Schema стандарт.
DOMPurify: Библиотека для санитизации HTML, которая помогает предотвращать XSS атаки.
express-validator: Библиотека для валидации и санитизации данных в Express.js приложениях.
Joi: Мощная библиотека для валидации данных в JavaScript. Она поддерживает множество типов данных и позволяет создавать сложные правила валидации.
validator.js: Библиотека строковой валидации и санитизации.
js-xss: Безопасный и мощный модуль санитизации HTML для JavaScript, предназначенный для предотвращения XSS атак.
sanitize-html: Библиотека, которая позволяет обрабатывать HTML, сохраняя только те элементы и атрибуты, которые вы хотите разрешить.

Источник

Why do we get JSON parse error?

How to handle JSON parse error?

1. Using try-catch block

2. Using if-else block

3. Using try-catch block with JSON.parse()

4. Using try-catch block with JSON.parse() and JSON.stringify()

JSON Fixer can fix these JSON data issues:

What can you do with JSON File Fixer?

Example for JSON Fixer

The easiest fix — you don’t need JSON.parse()!

The most common mistake — JSON.parse() instead of JSON.stringify()

Turn the object into JSON with JSON.stringify()

Troubleshooting

1. Check if what you are passing to JSON.parse() is a string

2. Check the string is valid JSON

3. Check if you need to await the result

Общие положения

Безопасное использование JSON

Основные виды атак

Предотвращение атак

Общие ошибки при работе с JSON и их решения

Заключение

Полезные ссылки

The easiest fix — you don’t need `JSON.parse()`!

The most common mistake — `JSON.parse()` instead of `JSON.stringify()`

Turn the object into JSON with `JSON.stringify()`

1. Check if what you are passing to `JSON.parse()` is a string

3. Check if you need to `await` the result