Czy ktoś może mi powiedzieć, jaka jest główna różnica między obiektem JavaScript zdefiniowanym za pomocą Object Literal Notation a obiektem JSON ?

Według książki JavaScript mówi, że jest to obiekt zdefiniowany za pomocą Notacji obiektowej :

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

Dlaczego w tym przypadku nie jest to obiekt JSON? Tylko dlatego, że nie jest zdefiniowany za pomocą cudzysłowów?

Najpierw wyjaśnijmy, czym tak naprawdę jest JSON . JSON to tekstowy , niezależny od języka format wymiany danych, podobnie jak XML, CSV lub YAML.

Dane mogą być przechowywane na wiele sposobów, ale jeśli powinny być przechowywane w pliku tekstowym i czytelne dla komputera, muszą mieć pewną strukturę. JSON jest jednym z wielu formatów definiujących taką strukturę.

Takie formaty są zwykle niezależne od języka, co oznacza, że ​​mogą być przetwarzane przez Java, Python, JavaScript, PHP, jak go nazwiesz.

Natomiast JavaScript jest językiem programowania. Oczywiście JavaScript zapewnia również sposób definiowania / opisywania danych, ale jego składnia jest bardzo specyficzna dla JavaScript.

Jako przeciwny przykład Python ma pojęcie krotek , a ich składnia to (x, y). JavaScript nie ma czegoś takiego.

Przyjrzyjmy się różnicom składniowym między literałami obiektów JSON i JavaScript.

JSON ma następujące ograniczenia składniowe:

• Klucze obiektowe muszą być łańcuchami (tj. Sekwencją znaków zamkniętą w podwójnych cudzysłowach ").
• Wartości mogą być albo:
  • sznurek
  • numer
  • obiekt (JSON)
  • tablica
  • true
  • false
  • null
• Zduplikowane klucze ( {"foo":"bar","foo":"baz"}) dają niezdefiniowane, specyficzne dla implementacji wyniki; specyfikacja JSON wyraźnie nie definiuje ich semantyki

W JavaScript, literały obiektów mogą mieć

• Literały łańcuchowe, literały liczbowe lub nazwy identyfikatorów jako klucze (od ES6 klucze mogą być teraz obliczane, co wprowadza jeszcze inną składnię).
• Wartości mogą być dowolnymi poprawnymi wyrażeniami JavaScript, w tym definicjami funkcji i undefined.
• Duplikaty kluczy dają określone, określone wyniki (w trybie swobodnym druga definicja zastępuje poprzednią; w trybie ścisłym jest to błąd).

Wiedząc o tym, po prostu patrząc na składnię , twój przykład nie jest JSON z dwóch powodów:

1. Twoje klucze nie są ciągami (literałami). Są to nazwy identyfikatorów .
2. Nie można przypisać funkcji jako wartości do „obiektu JSON” (ponieważ JSON nie definiuje żadnej składni funkcji).

Ale co najważniejsze, aby powtórzyć moje wyjaśnienie od początku: jesteś w kontekście JavaScript. Definiujesz obiekt JavaScript. Jeśli istnieje, „obiekt JSON” może być zawarty tylko w ciągu:

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

Oznacza to, że jeśli piszesz kod źródłowy JavaScript i nie masz do czynienia z łańcuchem , nie masz do czynienia z JSON. Być może otrzymałeś dane jako JSON (np. Poprzez ajax lub odczyt z pliku), ale kiedy ty lub biblioteka, której używasz, przeanalizowało je, nie jest już JSON.

Tylko dlatego, że literały obiektów i JSON wyglądają podobnie , nie oznacza to, że można je nazywać zamiennie. Zobacz także Nie ma czegoś takiego jak „Obiekt JSON” .

JSON ma znacznie bardziej ograniczoną składnię, w tym:

• Kluczowe wartości muszą być cytowane
• Ciągi muszą być cytowane za pomocą "i nie'
• Masz bardziej ograniczony zakres wartości (np. Niedozwolone funkcje)

Tak naprawdę nie ma czegoś takiego jak „Obiekt JSON”.

Specyfikacja JSON to składnia do kodowania danych jako ciąg. To, co ludzie nazywają „Obiektem JSON” (w javascript), jest tak naprawdę zwykłym obiektem javascript, który (prawdopodobnie) został zdezserializowany z prawidłowego ciągu JSON i może być łatwo ponownie serializowany jako prawidłowy ciąg JSON. Ogólnie oznacza to, że zawiera tylko dane (a nie funkcje). Oznacza to również, że nie ma żadnych dat, ponieważ JSON nie ma typu daty (prawdopodobnie najbardziej bolesna rzecz w JSON;)

Ponadto (side-rant ...), gdy ludzie mówią o „obiekcie JSON”, prawie zawsze mają na myśli dane, które mają „nawiasy klamrowe” na najwyższym poziomie. Odpowiada to ładnie obiektowi javascript. Jednak specyfikacja JSON nie wymaga, aby istniał pojedynczy obiekt „nawiasów klamrowych” na najwyższym poziomie ciągu JSON. JSON jest całkowicie poprawny, aby mieć listę na najwyższym poziomie, a nawet mieć tylko jedną wartość. Tak więc, podczas gdy każdy „obiekt JSON” odpowiada prawidłowemu JSON, nie wszystkie prawidłowe ciągi JSON odpowiadają temu, co nazwalibyśmy „obiektem JSON”! (ponieważ ciąg może reprezentować listę lub wartość atomową)

Według JSON w JavaScript ,

JSON jest podzbiorem literalnej notacji obiektowej JavaScript.

Innymi słowy, poprawny JSON jest także poprawną notacją dosłowną obiektu JavaScript, ale niekoniecznie na odwrót.

Oprócz czytania dokumentacji , jak sugerował @Filix King, sugeruję również zabawę z internetowym walidatorem JSON JSONLint . W ten sposób dowiedziałem się, że klucze obiektów JSON muszą być łańcuchami.

🔫 JSON : Beztłuszczowa alternatywa dla XML

JSON został powszechnie przyjęty przez ludzi, którzy stwierdzili, że znacznie ułatwia tworzenie rozproszonych aplikacji i usług. Oficjalny typ mediów internetowych dla JSON to application/json RFC 4627. Nazwy plików JSON używają rozszerzenia .json.

► JavaScript Object Notation ( JSON) to lekki, tekstowy, niezależny od języka format wymiany danych. JSON został wykorzystany do wymiany danych między aplikacjami napisanymi w dowolnym języku programowania.

Obiekt JSON to pojedynczy obiekt, który zawiera dwie funkcje: parsowanie i stringify, które są używane do parsowania i konstruowania tekstów JSON.

• JSON.stringify tworzy ciąg, który jest zgodny z następującą gramatyką JSON.
• JSON.parse akceptuje ciąg znaków zgodny z gramatyką JSON.

Metoda parseJSON zostanie uwzględniona w pliku Fourth Edition of ECMAScript. W międzyczasie implementacja JavaScript jest dostępna na 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 jest podzbiorem JavaScript. Javascript został wyprowadzony ze standardu ECMAScript Programming Language Standard.

► ECMAScript

ECMAScript stał się jednym z najczęściej używanych na świecie języków programowania ogólnego przeznaczenia. Jest najlepiej znany jako język osadzony w przeglądarkach internetowych, ale jest również szeroko stosowany w aplikacjach serwerowych i osadzonych. ECMAScript jest oparta na kilku technologii, pochodzących z najbardziej znaną istotą JavaScript(Netscape Communications)) i JScript(Microsoft Corporation).) . Chociaż przed 1994 r. ECMA była znana jako „Europejskie Stowarzyszenie Producentów Komputerów”, po 1994 r., Kiedy organizacja stała się globalna, „znak towarowy” „Ecma” został zachowany ze względów historycznych.

ECMAScript jest językiem, podczas gdy JavaScript, JScript, a nawet ActionScript są nazywane "Dialects".

Dialekty pochodzą z tego samego języka. Są do siebie bardzo podobne, ponieważ pochodzą z tego samego języka, ale przeszły pewne zmiany. Dialekt jest odmianą samego języka. Pochodzi z jednego języka.

• Język SQL - Hibernacja MySQL Dialect, Oracle Dialect, .. które mają pewne zmiany lub dodatkowe funkcje.

Informacje o przeglądarce i komputerze użytkowników.

navigator.appName // "Netscape"

ECMAScript to język skryptowy, który stanowi podstawę 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.

UWAGA « Czwarte wydanie ECMAScript nie zostało opublikowane, ponieważ praca była niekompletna .

JSON definiuje mały zestaw reguł formatowania do przenośnej reprezentacji danych strukturalnych.

1. ► Wartości klucza muszą być cytowane, tylko klucze są dozwolone dla kluczy. Jeśli użyjesz innego niż String, zostanie przekonwertowany na String. Ale nie zaleca się używania kluczy innych niż String. Sprawdź przykład taki jak ten - { 'key':'val' }ponadRFC 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() {}' ] );
   

2. ► Ciągi JSON muszą być cytowane za pomocą „a nie”. Ciąg jest bardzo podobny do ciągu C lub Java. Ciągi powinny być zawinięte w podwójne cudzysłowy.

   • Literały to stałe wartości, a nie zmienne, które dosłownie podajesz w skrypcie.
   • Ciąg jest sekwencją zero lub więcej znaków owiniętych w cudzysłów z odwrotnym ukośnikiem, ta sama notacja stosowana w większości języków programowania.
     • 🔫 - Symbole specjalne są dozwolone w łańcuchach, ale nie zaleca się ich używania.
     • \ "- Znaki specjalne można uciec. Nie zaleca się jednak ucieczki (') Pojedyncze cudzysłowy. W trybie ścisłym będzie rzucał, a błąd - SyntaxError: Unexpected token ' in JSON

   Sprawdź za pomocą tego kodu { "Hai\" \n Team 🔫":5, "Bye \'": 7 }w Internecie 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"}
   

Accessory właściwości obiektu zapewniają dostęp do właściwości obiektu za pomocą notacji kropkowej lub notacji nawiasowej.

3. ► Masz bardziej ograniczony zakres wartości (np. Niedozwolone funkcje). Wartością może być ciąg znaków w podwójnych cudzysłowach, liczba, wartość logiczna, null, obiekt lub tablica. Struktury te można zagnieżdżać.

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

► JavaScriptjest najpopularniejszą implementacją standardu ECMAScript. Podstawowe funkcje Javascript są oparte na standardzie ECMAScript, ale Javascript ma również inne dodatkowe funkcje, których nie ma w specyfikacji / standardzie ECMA. Każda przeglądarka ma interpreter JavaScript.

JavaScript jest językiem pisanym dynamicznie. Oznacza to, że nie musisz określać typu danych zmiennej podczas jej deklarowania, a typy danych są konwertowane automatycznie w razie potrzeby podczas wykonywania skryptu.

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

Struktura obiektu jest reprezentowana jako para nawiasów klamrowych otaczających zero lub więcej par nazwa / wartość (lub członków). Nazwa to ciąg znaków. Po każdej nazwie występuje pojedynczy dwukropek, oddzielający nazwę od wartości. Pojedynczy przecinek oddziela wartość od następującej nazwy. Nazwy w obiekcie POWINNY być unikalne.

ECMAScript obsługuje dziedziczenie oparte na prototypach. Każdy konstruktor ma powiązany prototyp, a każdy obiekt utworzony przez ten konstruktor ma niejawne odniesienie do prototypu (zwanego prototypem obiektu) powiązanego z jego konstruktorem. Ponadto prototyp może zawierać niejawne odniesienie do swojego prototypu i tak dalej; nazywa się to łańcuchem prototypowym.

W zorientowanym obiektowo języku zorientowanym na ogół stan jest przenoszony przez instancje, metody są przenoszone przez klasy, a dziedziczenie ma jedynie strukturę i zachowanie. W ECMAScript stan i metody są przenoszone przez obiekty, a struktura, zachowanie i stan są dziedziczone.

Prototyp to obiekt służący do implementacji dziedziczenia struktury, stanu i zachowania w ECMAScript. Kiedy konstruktor tworzy obiekt, obiekt ten domyślnie odwołuje się do powiązanego z nim prototypu konstruktora w celu rozstrzygania odwołań do właściwości. Powiązany prototyp konstruktora może być przywoływany przez wyrażenie programu konstruktor. Prototyp, a właściwości dodane do prototypu obiektu są współdzielone, poprzez dziedziczenie, przez wszystkie obiekty współużytkujące prototyp.

Dla tych, którzy nadal uważają, że RFC są ważniejsze niż blogi i nieporozumienia oparte na opiniach, spróbujmy odpowiedzieć na wyjaśnienia niektórych kwestii. Nie zamierzam powtarzać wszystkich poprawnych różnic wspomnianych już w poprzednich odpowiedziach, tutaj próbuję tylko dodać wartość podsumowującą jakąś kluczową część rfc7159

Wyciągi z https://tools.ietf.org/html/rfc7159

1. JavaScript Object Notation (JSON) to format tekstowy do serializacji danych strukturalnych. Pochodzi z literałów obiektowych JavaScript, zgodnie z definicją w ECMAScript Programming Language Standard, wydanie trzecie [ECMA-262].
2. JSON może reprezentować cztery prymitywne typy (łańcuchy, liczby, logiczne i zerowe) oraz dwa typy strukturalne ( obiekty i tablice).
3. Przedmiot jest nieuporządkowana zbiór zero lub więcej par Nazwa / wartości, przy czym nazwa jest łańcuch, a wartość jest łańcuch, numer logiczną, pusty, obiekt lub matryca.
4. obiekt- początkowy = ws% x7B ws; {lewy nawias klamrowy
5. obiekt końcowy = ws% x7D ws; } prawy nawias klamrowy
6. Wartość JSON MUSI być obiektem , tablicą, liczbą lub łańcuchem albo jedną z następujących trzech literalnych nazw: false null true
7. Przedmiotem struktura jest przedstawiona w postaci pary klamrowych
8. Nazwy w obiekcie POWINNY być unikalne. object = begin-object [member * (value-separator member)] obiekt końcowy
9. Obiekt których nazwy są unikalne może współpracować w tym sensie, że wszystkie implementacje programowe odbiorczego, że obiekt będzie uzgodnić mapowania nazwa-wartość. Gdy nazwy w obiekcie nie są unikalne, zachowanie oprogramowania, które odbiera taki obiekt, jest nieprzewidywalne.

10. Przykłady (od strony 12 RFC)

    To jest obiekt 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]
              }
          }

    Jego element członkowski Image jest obiektem, którego element Miniatura jest obiektem, a element ID jest tablicą liczb.

Tak naprawdę nie ma czegoś takiego jak „Obiekt JSON”.

Naprawdę?

O ile rozumiem, główną różnicą jest elastyczność .

JSON jest rodzajem opakowania „JavaScript Object Notation”, który zmusza użytkowników do przestrzegania bardziej surowych zasad definiowania obiektów. Robi to poprzez ograniczenie możliwych sposobów deklaracji obiektów udostępnianych przez funkcję JavaScript Object Notation.

W rezultacie mamy prostsze i bardziej znormalizowane obiekty, które lepiej pasują do wymiany danych między platformami.

Zasadniczo newObject w powyższym przykładzie jest obiektem zdefiniowanym za pomocą JavaScript Objeect Notation; ale nie jest to „prawidłowy” obiekt JSON, ponieważ nie przestrzega zasad wymaganych przez standardy JSON.

Ten link jest również bardzo pomocny: http://msdn.microsoft.com/en-us/library/bb299886.aspx

Najpierw powinieneś wiedzieć, co to jest JSON:

Jest to niezależny od języka format wymiany danych. Składnia JSON została zainspirowana notacją dosłowną Object JavaScript, ale istnieją między nimi różnice.

Na przykład w JSON wszystkie klucze muszą być cytowane, podczas gdy w literałach obiektowych nie jest to konieczne:

// JSON: {„foo”: „bar”}

// Literał obiektu: var o = {foo: "bar"}; Cytaty są obowiązkowe w JSON, ponieważ w JavaScript (a dokładniej w ECMAScript 3. wydanie) użycie słów zastrzeżonych jako nazw właściwości jest niedozwolone, na przykład:

var o = {if: "foo"}; // SyntaxError w ES3 Podczas gdy użycie literału ciągu jako nazwy właściwości (cytowanie nazwy właściwości) nie stwarza problemów:

var o = {"if": "foo"}; Tak więc dla „kompatybilności” (i łatwej oceny?) Cytaty są obowiązkowe.

Typy danych w JSON są również ograniczone do następujących wartości:

liczba ciągów tablica obiektów Literał jako: prawda fałsz null Zmienia się gramatyka ciągów. Muszą być one rozdzielone podwójnymi cudzysłowami, podczas gdy w JavaScript można używać zamiennie pojedynczych lub podwójnych cudzysłowów.

// Niepoprawny JSON: {"foo": 'bar'} Zmienia się również zaakceptowana gramatyka liczb JSON, w JavaScript możesz używać literałów szesnastkowych, na przykład 0xFF, lub (niesławnych) literałów ósemkowych, np. 010. W JSON możesz używać tylko dziesiętne literały.

// Niepoprawny JSON: {"foo": 0xFF}

JavaScript Object Literal vs JSON:

• Składnia dosłowna obiektu jest bardzo wygodnym sposobem tworzenia obiektów javascript
• JSONJęzyk, który oznacza „JavaScript Object Notation”, ma swoją składnię pochodzącą ze składnią dosłownym obiekt JavaScript. Jest używany jako niezależny od języka programowania format przesyłania danych tekstowych.

Przykład:

Notacja obiektowa JS, używana w JS do wygodnego tworzenia obiektów w kodzie:

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
}

Przykład 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;"
    }
}}

Główne różnice:

• Wszystkie klucze obiektów w JSON muszą być ciągami. W JavaScript obiektowymi kluczami mogą być ciągi lub liczby

• Wszystkie ciągi w JSON muszą być cytowane w „cudzysłowach”. Natomiast w Javascript dozwolone są zarówno pojedyncze, jak i podwójne cudzysłowy. Nawet bez cudzysłowów w notacji obiektu JavaScript klucze obiektów są domyślnie rzutowane na łańcuchy.

• W JSON funkcji nie można zdefiniować jako wartości obiektu (ponieważ jest to specyficzne dla Javascript). W Javascript jest to całkowicie legalne.

JavaScript wbudowany w JSONobiekt:

JSONobiekty można łatwo przekonwertować na Javascript i odwrotnie za pomocą wbudowanego JSONobiektu, który JavaScript oferuje w swoim środowisku wykonawczym. Na przykład:

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

Oto jedna zaskakująca różnica: nie można używać undefinedw Jsonie, a wszystkie pola obiektów o nieokreślonych wartościach znikną późniejJSON.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) );

🙈🙉🙊