В чем разница между JSON и буквенной нотацией объекта?

https://stackoverflow.com/questions/2904131

04-10-2019
|

Вопрос

Может ли кто-нибудь сказать мне, в чем основное различие между объектом JavaScript, определенным с помощью Обозначение литерала объекта и JSON-объект?

Согласно книге по JavaScript, там говорится, что это объект, определенный с помощью Обозначение объекта:

var anObject = {
    property1 : true,
    showMessage : function (msg) { alert(msg) }
};

Почему в данном случае это не объект JSON?Только потому, что оно не определено в кавычках?

Решение

Давайте сначала уточним, что JSON на самом деле есть.JSON — это текстовый, независимый от языка формат обмена данными, очень похожий на XML, CSV или YAML.

Данные можно хранить разными способами, но если они должны храниться в текстовом файле и быть читаемыми компьютером, они должны иметь определенную структуру.JSON — один из многих форматов, определяющих такую структуру.

Такие форматы обычно не зависят от языка, то есть их можно обрабатывать с помощью Java, Python, JavaScript, PHP и т. д.

В отличие, JavaScript это язык программирования.Конечно, JavaScript также предоставляет способ определения/описания данных, но синтаксис очень специфичен для JavaScript.

В качестве противоположного примера в Python есть концепция кортежи, их синтаксис (x, y).В JavaScript нет чего-то подобного.

Давайте посмотрим на синтаксические различия между литералами объектов JSON и JavaScript.

JSON имеет следующие синтаксические ограничения:

Объект ключи должно быть струны (т.е.последовательность символов, заключенная в двойные кавычки ").
Значения могут быть следующими:
- строка
- число
- объект (JSON)
- массив
- true
- false
- null
Дублирующиеся ключи ({"foo":"bar","foo":"baz"}) дают неопределенные результаты, зависящие от реализации;спецификация JSON конкретно не определяет их семантику

В JavaScript литералы объектов могут иметь

Строковые литералы, числовые литералы или имена идентификаторов в качестве ключей (начиная с ES6, ключи теперь также можно вычислять, что вводит еще один синтаксис).
Значениями могут быть любые допустимые выражения JavaScript, включая определения функций и undefined.
Дублирующиеся ключи дают определенные, заданные результаты (в свободном режиме последнее определение заменяет первое;в строгом режиме это ошибка).

Зная это, просто посмотрите на синтаксис, ваш пример не JSON по двум причинам:

Ваши ключи не являются строками (литералами).Они есть имена идентификаторов.
Вы не можете присвоить функцию как значение «объекту JSON» (поскольку JSON не определяет синтаксис для функций).

Но самое главное, повторю свое объяснение с самого начала:Вы находитесь в контексте JavaScript.Вы определяете объект JavaScript.Если таковой имеется, «объект JSON» может содержаться только в строке:

 var obj = {foo: 42}; // creates a JavaScript object (this is *not* JSON)
 var json = '{"foo": 452}'; // creates a string containing JSON

То есть, если вы пишете исходный код JavaScript, а не имеете дело с нить, вы имеете дело не с JSON.Возможно, вы получили данные в формате JSON (например, через ajax или чтение из файла), но как только вы или используемая вами библиотека проанализировали их, это уже не JSON.

Только потому, что объектные литералы и JSON выглядят похожий, это не означает, что вы можете называть их взаимозаменяемо. Смотрите также Не существует такого понятия, как «Объект JSON»..

Другие советы

Json. имеет гораздо более ограниченный синтаксис, в том числе:

Ключевые значения должны быть указаны
Строки должны быть указаны с " и не '
У вас есть более ограниченный диапазон значений (например, не допускаются функции)

На самом деле нет такой вещи, как «объект JSON».

SEC JSON - это синтаксис для кодирования данных в виде строки. То, что люди называют «объектом JSON» (в JavaScript), действительно просто обычный объект JavaScript, который имеет (вероятно,) был десериал из действующей строки JSON и может быть легко повторно сериализуется как действительная строка JSON. Это вообще означает, что он содержит только данные (и не функции). Это также означает, что даты нет, потому что JSON не имеет типа даты (вероятно, самая болезненная вещь о JSON;)

Кроме того, (Side-Rant ...) Когда люди говорят о «объекте JSON», они почти всегда означают данные, которые имеют «фигурные скобки» на верхнем уровне. Это хорошо соответствует объекту JavaScript. Тем не менее, SPEC JSON не требует, чтобы на верхнем уровне json строки JSON не требуется один «кудрявые скобки». Это совершенно действует JSON, чтобы иметь список на верхнем уровне или даже иметь только одно значение. Таким образом, хотя каждый «объект JSON» соответствует действительным JSON, не все действительные строки JSON соответствуют тому, что мы бы назвали «объект JSON»! (Потому что строка может представлять список или атомное значение)

Согласно с JSON в JavaScript,

Джосон А. подмножество объекта буквальный обозначение JavaScript.

Другими словами, действительный JSON также является действительным объектом JavaScript буквальной обозначения, но не обязательно наоборот.

В дополнение к чтению документация, как предложил @Filix King, я также предлагаю играть с JSONLINT онлайн JSON Validator. Отказ Вот как я узнал, что ключи объектов JSON должны быть строками.

🔫 JSON:Безжировая альтернатива XML

JSON получил широкое распространение среди людей, которые обнаружили, что он значительно упрощает создание распределенных приложений и сервисов.Официальным типом JSON в Интернете является application/json RFC 4627.Имена файлов JSON используют расширение .json.

► Обозначение объектов JavaScript (JSON) — это легкий текстовый формат обмена данными, независимый от языка.JSON использовался для обмена данными между приложениями, написанными на любом языке программирования.

Объект JSON — это единый объект, содержащий две функции: parse и stringify, которые используются для анализа и построения текстов JSON.

JSON.stringify создает строку, соответствующую следующей грамматике JSON.

JSON.parse принимает строку, соответствующую грамматике JSON.

Метод parseJSON будет включен в Fourth Edition of ECMAScript.Тем временем реализация JavaScript доступна на json.org.

var objLiteral = {foo: 42}; // JavaScript Object
console.log('Object Literal : ', objLiteral ); // Object {foo: 42}foo: 42__proto__: Object

// This is a JSON String, like what you'd get back from an AJAX request.
var jsonString = '{"foo": 452}';
console.log('JOSN String : ', jsonString ); // {"foo": 452}

// This is how you deserialize that JSON String into an Object.
var serverResposnceObject = JSON.parse( jsonString );
console.log('Converting Ajax response to JavaScript Object : ', serverResposnceObject); // Object {foo: 42}foo: 42 __proto__: Object

// And this is how you serialize an Object into a JSON String.
var serverRequestJSON = JSON.stringify( objLiteral );
console.log('Reqesting server with JSON Data : ', serverRequestJSON); // '{"foo": 452}'

JSON — это подмножество JavaScript. Javascript был получен из стандарта языка программирования ECMAScript.

► ECMAScript

ECMAScript превратился в один из наиболее широко используемых в мире языков программирования общего назначения.Он наиболее известен как язык, встроенный в веб-браузеры, но также получил широкое распространение для серверных и встроенных приложений. ECMAScript основан на нескольких исходных технологиях, наиболее известной из которых является JavaScript (Netscape Communications)) и JScript (Корпорация Майкрософт).). Хотя до 1994 года ECMA была известна как «Европейская ассоциация производителей компьютеров», после 1994 года, когда организация стала глобальной, «торговая марка» «Ecma» была сохранена по историческим причинам.

ECMAScript — это язык, тогда как JavaScript, JScript и даже ActionScript называются "Dialects".

Диалекты произошли от одного и того же языка.Они очень похожи друг на друга, поскольку произошли от одного и того же языка, но претерпели некоторые изменения.Диалект – это разновидность самого языка.Оно происходит от одного языка.

Язык SQL — диалект Hibernate MySQL, диалект Oracle,..которые имеют некоторые изменения или добавлены функциональные возможности.

Информация о браузере и компьютере ваших пользователей.

navigator.appName // "Netscape"

ECMAScript — это язык сценариев, лежащий в основе JavaScript. JavaScript language resources.

ECMA-262 Links
Initial Edition, June 1997 PDF.
2nd Edition, August 1998 PDF.
3rd Edition, December 1999 PDF.
5th Edition, December 2009 PDF.
5.1 Edition, June 2011 HTML.
6th Edition, June 2015 HTML.
7ᵗʰ Edition, June 2016 HTML.
8th edition, June 2017 HTML.
9th Edition, 2018 HTML.

ПРИМЕЧАНИЕ " 4-е издание ECMAScript не опубликовано, поскольку работа была неполной.

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

► Значения ключей должны быть заключены в кавычки. Для ключей разрешены только строки.Если вы используете значение, отличное от String, оно преобразуется в String.Но не рекомендуется использовать ключи, отличные от String.Проверьте такой пример - { 'key':'val' } над RFC 4627 - jsonformatter

var storage = {
  0 : null,
  1 : "Hello"
};
console.log( storage[1] ); // Hello
console.log( JSON.stringify( storage ) ); // {"0":null,"1":"Hello","2":"world!"}

var objLiteral = {'key1':'val1'};
    var arr = [10, 20], arr2 = [ 'Yash', 'Sam' ];
    var obj = { k: 'v' }, obj2 = { k2: 'v2' };
    var fun = function keyFun() {} ;

objLiteral[ arr ] = 'ArrayVal';     objLiteral[ arr2 ] = 'OverridenArrayVal';
objLiteral[ obj ] = 'ObjectVal';    objLiteral[ obj2 ] = 'OverridenObjectVal';
objLiteral[ fun ] = 'FunctionVal';

console.log( objLiteral );
// Object {key1: "val1", 10,20: "ArrayVal", Yash,Sam: "OverridenArrayVal", [object Object]: "OverridenObjectVal", function keyFun() {}: "FunctionVal"}
console.log( JSON.stringify( objLiteral ) );
// {"key1":"val1","10,20":"ArrayVal","Yash,Sam":"OverridenArrayVal","[object Object]":"OverridenObjectVal","function keyFun() {}":"FunctionVal"}
console.log( JSON.parse( JSON.stringify( objLiteral ) ) );
// Object {key1: "val1", 10,20: "ArrayVal", Yash,Sam: "OverridenArrayVal", [object Object]: "OverridenObjectVal", function keyFun() {}: "FunctionVal"}

console.log('Accessing Array  Val : ', objLiteral[ [10,20] ] );
console.log('Accessing Object Val : ', objLiteral[ '[object Object]' ] );
console.log('Accessing Function Val : ', objLiteral[ 'function keyFun() {}' ] );

► Строки JSON должны быть заключены в кавычки с помощью «, а не '.Строка очень похожа на строку C или Java. Строки должны быть заключены в двойные кавычки.
- Литералы — это фиксированные значения, а не переменные, которые вы буквально указываете в своем скрипте.
- Строка — это последовательность из нуля или более символов, заключенная в кавычки с обратной косой чертой — та же нотация, которая используется в большинстве языков программирования.
  - 🔫 — В строке разрешены специальные символы, но их не рекомендуется использовать.
  - \" - Специальные символы можно экранировать.Но не рекомендуется избегать одинарных кавычек (').В строгом режиме выдается ошибка - SyntaxError: Unexpected token ' in JSON
Проверьте этот код { "Hai\" \n Team 🔫":5, "Bye \'": 7 } через онлайн-версии JSON Edtions. ModesnotStrict,Strinct.
```
var jsonString = "{'foo': 452}"; // {'foo': 452}
var jsonStr = '{"foo": 452}'; // {"foo": 452}

JSON.parse( jsonString ); // Unexpected token ' in JSON at position 1(…)
JSON.parse( jsonStr ); // Object {foo: 452}

objLiteral['key'] = 'val'; // Object {foo: 42, key: "val"}
objLiteral.key2 = 'val';

// objLiteral.key\n3 - SyntaxError: Invalid or unexpected token
objLiteral['key\n3'] = 'val'; // Object {"foo": "42", key: "val", key2: "val", "key↵3": "val"}

JSON.stringify( objLiteral ); // {"foo":"42","key":"val","key2":"val","key\n3":"val"}
```

Объект Средства доступа к свойствам обеспечить доступ к свойствам объекта, используя точечную нотацию или скобочную нотацию.

► У вас более ограниченный диапазон значений (например,никакие функции не разрешены).Значением может быть строка в двойных кавычках, число, логическое значение, значение NULL, объект или массив.Эти структуры могут быть вложенными.
```
var objLiteral = {};
objLiteral.funKey = function sayHello() {
    console.log('Object Key with function as value - Its outcome message.');
};

objLiteral['Key'] = 'Val';

console.log('Object Literal Fun : ', objLiteral );
// Object Literal Fun :  Object {Key: "Val"}Key: "Val"funKey: sayHello()__proto__: Object
console.log( JSON.stringify( objLiteral ) ); // {"Key":"Val"}
```

► JavaScript — самая популярная реализация стандарта ECMAScript.Основные функции Javascript основаны на стандарте ECMAScript, но Javascript также имеет другие дополнительные функции, которых нет в спецификациях/стандарте ECMA. В каждом браузере есть интерпретатор JavaScript.

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

Literals :

'37' - 7    // 30
'37' + 7    // "377"
+'37' + 7   // 44
+'37'       // 37
'37'        // "37"

parseInt('37');     // 37
parseInt('3.7');    // 3

parseFloat(3.7);    // 3.7

// An alternative method of retrieving a number from a string is with the + (unary plus) operator:
+'3.7'              // 3.7

Object literals RFC 7159

Структура объекта представлена в виде пары фигурных скобок, окружающих ноль или более пар имя/значение (или членов).Имя - это строка.После каждого имени ставится одно двоеточие, отделяющее имя от значения.Одна запятая отделяет значение от следующего имени.Имена внутри объекта ДОЛЖНЫ быть уникальными.

ECMAScript поддерживает наследование на основе прототипов.Каждый конструктор имеет связанный прототип, и каждый объект, созданный этим конструктором, имеет неявную ссылку на прототип (называемый прототипом объекта), связанный с его конструктором.Более того, прототип может иметь ненулевую неявную ссылку на свой прототип и так далее;это называется цепочкой прототипов.

В объектно-ориентированном языке, основанном на классах, состояние передается экземплярами, методы — классами, а наследование касается только структуры и поведения.В ECMAScript состояние и методы передаются объектами, а структура, поведение и состояние наследуются.

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

Для тех, кто до сих пор считает, что RFC важнее блогов и заблуждений, основанных на мнениях, попробуем ответить, разъясняя некоторые моменты.Я не собираюсь повторять все правильные различия, уже упомянутые в предыдущих ответах, здесь я просто пытаюсь добавить ценность, суммируя некоторые важные части rfc7159.

Выдержки из https://tools.ietf.org/html/rfc7159

JavaScript Объект Нотация (JSON) - это текстовый формат для сериализации структурированных данных.Он получен из объектЛитералы JavaScript, как определено в стандарте языка программирования ECMASCRIPT, третье издание [ECMA-262].
JSON может представлять четыре примитивных типа (струны, числа, логические и нулевые) и два структурированных типа (объекты и массивы).
Ан объект является неупорядоченной коллекцией из пар и более и более пар/значения, где имя - это строка, а значение - это строка, число, логическое, ноль, объект, или массив.
начало-объект = WS %x7B WS ;{ левая фигурная скобка
конечный объект = WS %x7D WS ;} правая фигурная скобка
Значение JSON ДОЛЖНО быть объект, массив, номер или строка, или одно из следующих трех буквальных имен:ложь ноль правда
Ан объект структура представлена в виде пары фигурных скобок
Имена внутри объект ДОЛЖНО быть уникальным. объект = начало-объект [член *(член-разделитель значений)] конечный объект
Ан объект чьи имена уникальны, совместимы в том смысле, что все реализации программного обеспечения получают это объект Согласится с отображением именных значений.Когда имена внутри объект не уникальны, поведение программного обеспечения, которое получает такое объект непредсказуем.

Примеры (со стр. 12 RFC)

Это объект JSON:

      {
        "Image": {
            "Width":  800,
            "Height": 600,
            "Title":  "View from 15th Floor",
            "Thumbnail": {
                "Url":    "http://www.example.com/image/481989943",
                "Height": 125,
                "Width":  100
            },
            "Animated" : false,
            "IDs": [116, 943, 234, 38793]
          }
      }

Его член Image является объект чей элемент миниатюры является объект и чей участник IDS является множеством чисел.

На самом деле не существует такого понятия, как «Объект JSON».

Действительно?

Насколько я понимаю, главное отличие гибкость.

JSON - это своего рода обертка на «JavaScript Object Notiator», который заставляет пользователей подчиняться более строгим правилам для определения объектов. И это делает это, ограничивая возможные способы объявления объекта, предусмотренные функцией объектной записи JavaScript.

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

Таким образом, в основном, NewObject в моем примере выше, представляет собой объект, определенный с использованием записи JavaScript Objeect; Но это не является «действительным» объектом JSON, потому что он не соответствует правилам, которые требуют стандартов JSON.

Эта ссылка также довольно полезна:http://msdn.microsoft.com/en-us/library/bb299886.aspx.

Сначала вы должны знать, что JSON:

Это язык агностического формата данных обмен данных. Синтаксис JSON был вдохновлен буквальной обозначением объекта JavaScript, но между ними есть различия.

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

// JSON: {"FOO": "BAR"}

// объект литерал: var o = {foo: "bar"}; Цитаты являются обязательными на JSON, потому что в JavaScript (более точно в Ecmascript 3RD. Edition) Использование зарезервированных слов в качестве имен свойств запрещено, например:

var o = {Если: "foo"}; // SyntaxError в ES3, в то время как, используя строку литерала в качестве имени свойства (цитирующее имя недвижимости) не дает проблем:

var o = {"если": "foo"}; Так что для «совместимости» (и легко Eval'ing может быть?) Цитаты обязательны.

Типы данных в JSON также ограничены следующими значениями:

Строковый номер объекта массив литерала как: ИСТИННЫЙ ЛОЖНЫЙ НУЛК Грамматика изменений строк. Они должны быть разграничены двойными кавычками, в то время как в JavaScript вы можете использовать одноменные или двойные цитаты.

// неверный JSON: {"FOO": 'BAR'} Принятая грамматика JSON из номеров также изменяется, в JavaScript вы можете использовать шестнадцатеричные литералы, например 0xFF, или (печально известные) восьмеричные литералы, например, в JSON, вы можете использовать только десятичные литералы.

// Неверный JSON: {"FOO": 0xff}

JavaScript объект Littleal VS JSON:

Объект литеральный синтаксис - очень удобный способ создания объектов JavaScript
То JSON Язык, который означает «javaScript Object Notiation», имеет свой синтаксис, полученный из букляльного синтаксиса объекта JavaScript. Он используется в качестве языка программирования независимый формат передачи текстовых данных.

Пример:

JS Объектная запись, используемая в JS для создания объектов в коде удобно:

const JS_Object = {
  1: 2,  // the key here is the number 1, the value is the number 2
  a: 'b', // the key is the string a, the value is the string b
  func: function () { console.log('hi') }
  // the key is func, the value is the function
}

Пример json:

{"widget": {
    "debug": "on",
    "window": {
        "title": "Sample Konfabulator Widget",
        "name": "main_window",
        "width": 500,
        "height": 500
    },
    "image": { 
        "src": "Images/Sun.png",
        "name": "sun1",
        "hOffset": 250,
        "vOffset": 250,
        "alignment": "center"
    },
    "text": {
        "data": "Click Here",
        "size": 36,
        "style": "bold",
        "name": "text1",
        "hOffset": 250,
        "vOffset": 100,
        "alignment": "center",
        "onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
    }
}}

Основные различия:

Все объектные клавиши в JSON должны быть строками. В JavaScript объектных клавиш могут быть строки или цифры
Все строки в JSON должны быть указаны в «двойных кадинатах». Принимая во внимание, что в JavaScript допускаются отдельные кавычки и двойные кавычки. Даже без котировок в объектной записи JavaScript клавиши объектов неявно избиты на строки.
В JSON функция не может быть определена как значение объекта (поскольку это конкретно JavaScript). В JavaScript это совершенно законно.

JavaScript Build In JSON объект:

JSON Объекты могут быть легко преобразованы в JavaScript и наоборот, используя встроенный JSON Объект, который предлагает JavaScript в своем выполнении. Например:

const Object = {
  property1: true,
  property2: false,
}; // creating object with JS object literal syntax

const JSON_object = JSON.stringify(Object);  // stringify JS object to a JSON string

console.log(JSON_object); // note that the (string) keys are in double quotes

const JS_object = JSON.parse(JSON_object);  // parse JSON string to JS object

console.log(JS_object.property1, JS_object.property2); 
// accessing keys of the newly created object

Вот одно удивительное различие: вы не можете использовать undefined В JSON и все поля объекта с неопределенными значениями исчезнут после JSON.stringify

let object =  { "a": undefined } ;

let badJSON= '{ "a": undefined }';


console.log('valid JS object :', object );
console.log('JSON from object:', JSON.stringify(object) );
console.log('invalid json    :', JSON.parse(badJSON) );

🙈🙉🙊

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow