Variabelen

Variabelen declareren

Voordat u een variabele in JavaScript kunt gebruiken, moet deze worden gedeclareerd. Variabelen worden gedeclareerd met behulp van een trefwoord var op de volgende manier:

Var ik; var som;

Door het trefwoord var één keer te gebruiken, kunt u meerdere variabelen declareren:

Het declareren van variabelen kan worden gecombineerd met hun initialisatie:

Var-bericht = "hallo"; var ik = 0, j = 0, k = 0;

Als er geen initiële waarde is opgegeven in de var-instructie, wordt de variabele gedeclareerd, maar de initiële waarde blijft ongedefinieerd totdat deze door het programma wordt gewijzigd.

Als je ervaring hebt met het gebruik van programmeertalen met statische gegevenstypen, zoals C# of Java, zul je merken dat bij variabele declaraties in JavaScript een typedeclaratie ontbreekt. Variabelen in JavaScript kunnen waarden van elk type opslaan. In JavaScript kunt u bijvoorbeeld een getal aan een variabele toewijzen en vervolgens een tekenreeks aan dezelfde variabele toewijzen:

Vari = 10; ik = "hallo";

Met de var-instructie kunt u dezelfde variabele meerdere keren declareren. Als de herhaalde declaratie een initialisatie bevat, gedraagt ​​deze zich als een gewone toewijzingsinstructie.

Als u de waarde van een niet-gedeclareerde variabele probeert te lezen, genereert JavaScript een fout. In de strikte modus van de ECMAScript 5-standaard treedt er ook een fout op wanneer wordt geprobeerd een waarde toe te wijzen aan een niet-gedeclareerde variabele. Historisch gezien, en wanneer het niet in de strikte modus wordt uitgevoerd, zal JavaScript echter, als u een waarde toewijst aan een variabele die niet is gedeclareerd met een var-instructie, die variabele creëren als een eigenschap van het globale object, en het zal vrijwel hetzelfde werken als een correct gedeclareerde variabele. Dit betekent dat globale variabelen niet hoeven te worden gedeclareerd. Dit wordt echter als een slechte gewoonte beschouwd en kan een bron van fouten zijn. Probeer dus altijd uw variabelen te declareren met var.

Variabel bereik

De reikwijdte van een variabele is het deel van het programma waarvoor de variabele is gedefinieerd. Een globale variabele heeft een globale reikwijdte: deze is gedefinieerd voor het gehele JavaScript-programma. Tegelijkertijd worden variabelen die binnen een functie worden gedeclareerd, alleen in de hoofdtekst ervan gedefinieerd. Ze worden lokaal genoemd en hebben een lokale reikwijdte. Functieparameters worden ook beschouwd als lokale variabelen, die alleen binnen de hoofdtekst van die functie worden gedefinieerd.

Binnen een functielichaam heeft een lokale variabele voorrang op een globale variabele met dezelfde naam. Als u een lokale variabele of functieparameter declareert met dezelfde naam als een globale variabele, wordt de globale variabele feitelijk verborgen:

Var-resultaat = "globaal"; function getResult() ( var result = "local"; return resultaat; ); console.log(getResult()); // Geef "lokaal" weer

Bij het declareren van variabelen met een globaal bereik kan de var-instructie worden weggelaten, maar bij het declareren van lokale variabelen moet u altijd de var-instructie gebruiken.

Variabelen dienen als "containers" voor het opslaan van informatie.

Herinner je je Algebra op de middelbare school nog?

Herinner je je schoolalgebra nog? x=5, y=6, z=x+y

Weet je nog dat je een letter (bijvoorbeeld x) kunt gebruiken om een ​​waarde op te slaan (bijvoorbeeld 5), en dat je de bovenstaande informatie kunt gebruiken om te berekenen dat de waarde van z 11 is?

Deze letters heten variabelen, en variabelen kunnen worden gebruikt om waarden (x=5) of uitdrukkingen (z=x+y) op te slaan.

JavaScript-variabelen

Net als in de algebra worden JavaScript-variabelen gebruikt om waarden of uitdrukkingen op te slaan.

De variabele kan een korte naam hebben, zoals x, of een meer beschrijvende naam, zoals carname.

Regels voor JavaScript-variabelenamen:

• Variabelenamen zijn hoofdlettergevoelig (y en Y zijn twee verschillende variabelen)
• Namen van variabelen moeten beginnen met een letter of een onderstrepingsteken

Opmerking: Omdat JavaScript hoofdlettergevoelig is, zijn de namen van variabelen ook hoofdlettergevoelig.

Voorbeeld

De waarde van een variabele kan veranderen terwijl het script actief is. U kunt aan de hand van de naam naar een variabele verwijzen om de waarde ervan weer te geven of te wijzigen.

JavaScript-variabelen declareren (creëren).

Het maken van variabelen in JavaScript wordt vaker 'declarerende' variabelen genoemd.

U declareert JavaScript-variabelen met behulp van een trefwoord var:

Na het volgen van de bovenstaande suggesties wordt de variabele X zal de waarde bevatten 5 , En naam zal de waarde bevatten Mercedes.

Opmerking: Wanneer u een tekstwaarde aan een variabele toewijst, plaatst u deze tussen aanhalingstekens.

Opmerking: Als u een variabele opnieuw declareert, verliest deze zijn waarde niet.

JavaScript lokale variabelen

Een variabele die binnen een JavaScript-functie wordt gedeclareerd, wordt LOKAAL en is alleen beschikbaar binnen deze functie. (de variabele heeft een lokaal bereik).

U kunt lokale variabelen met dezelfde naam in verschillende functies declareren, omdat lokale variabelen worden herkend in de functie waarin ze worden gedeclareerd.

Lokale variabelen worden vernietigd wanneer de functie wordt afgesloten.

In de volgende JavaScript-lessen leer je meer over functies.

JavaScript-globale variabelen

Variabelen die buiten de functie zijn gedeclareerd, worden GLOBAAL, en alle scripts en functies op de pagina hebben er toegang toe.

Globale variabelen worden vernietigd wanneer u de pagina sluit.

Als u een variabele declareert zonder "var" te gebruiken, wordt de variabele altijd GLOBAAL.

Waarden toewijzen aan niet-gedeclareerde JavaScript-variabelen

Als u waarden toekent aan variabelen die nog niet zijn gedeclareerd, worden de variabelen automatisch gedeclareerd als globale variabelen.

Deze aanbiedingen:

In de volgende JavaScript-les leert u meer over operators.

Dit hoofdstuk behandelt de basisgrammatica, variabeledeclaraties, gegevenstypen en letterlijke waarden.

Basisprincipes

JavaScript ontleent een groot deel van zijn syntaxis aan Java, maar wordt ook beïnvloed door talen als Awk, Perl en Python.

JavaScript hoofdlettergevoelig en maakt gebruik van tekencodering Unicode. Het woord Früh ("vroeg" in het Duits) kan bijvoorbeeld als variabelenaam worden gebruikt.

Var Früh = "foobar";

Maar de variabele früh is niet hetzelfde als Früh omdat JavaScript hoofdlettergevoelig is.

Opmerkingen

Syntaxis opmerkingen is hetzelfde als in C++ en vele andere talen:

// Commentaar beslaat één regel. /* Een commentaar dat meerdere regels beslaat. */ /* Je kunt /* een opmerking niet binnen een opmerking nesten */ Syntax error */

advertenties

Er zijn drie soorten declaraties in JavaScript:

var Declareert een variabele; initialisatie van de variabele naar een waarde is optioneel. laten Declareert een lokale variabele in blokbereik; initialisatie van de variabele naar een waarde is optioneel. const Declareert een benoemde alleen-lezen constante.

Variabelen

U kunt variabelen gebruiken als symbolische namen voor waarden in uw applicatie. Variabelenamen worden identifiers genoemd en moeten aan bepaalde regels voldoen.

Een ID in JavaScript moet beginnen met een letter, een onderstrepingsteken (_) of een dollarteken ($); daaropvolgende tekens kunnen ook cijfers zijn (0-9). Omdat JavaScript hoofdlettergevoelig is, bevatten letters de tekens "A" tot en met "Z" (hoofdletters) en de tekens "a" tot en met "z" (kleine letters).

U kunt ISO 8859-1- of Unicode-letters gebruiken in ID's, zoals å of ü. U kunt beide symbolen ook gebruiken in ID's.

Enkele voorbeelden van geldige namen: Number_hits, temp99, _name.

Variabelen declareren

Je kunt een variabele op drie manieren declareren:

• Met behulp van het trefwoord var. Bijvoorbeeld var x = 42 . Deze syntaxis kan worden gebruikt om zowel lokale als globale variabelen te declareren.
• Wijs gewoon een waarde toe aan de variabele. Bijvoorbeeld x = 42. Variabelen die op deze manier worden gedeclareerd, zijn globaal. Een dergelijke aangifte genereert een strikte waarschuwing (strikte modus). Het wordt niet aanbevolen om deze methode te gebruiken.
• Gebruik het sleutelwoord let. Stel bijvoorbeeld y = 13 . Deze syntaxis kan worden gebruikt om een ​​lokale variabele binnen het bereik van een blok te declareren.

Waarden toekennen

Een variabele die is gedeclareerd met var of let zonder een initiële waarde toe te kennen, heeft de waarde ongedefinieerd.

Als u probeert toegang te krijgen tot een niet-gedeclareerde variabele of een variabele voordat deze is gedeclareerd, wordt er een ReferenceError-uitzondering gegenereerd:​

Var een; console.log("De waarde van a is " + a); //De waarde van variabele a is ongedefinieerd console.log("De waarde van b is " + b); //Uncaught ReferenceError: b is niet gedefinieerd console.log("De waarde van c is " + c); //Waarde van variabele c ongedefinieerde var c; console.log("De waarde van x is " + x); //Uncaught ReferenceError: x is niet gedefinieerd, laat x;

Om te bepalen of een variabele een waarde heeft, kunt u undefined gebruiken. In het volgende voorbeeld wordt aan de invoervariabele geen waarde toegewezen en wordt de if-instructie geëvalueerd als true:

var-invoer; if (invoer === ongedefinieerd) (doThis ( ); ) anders (doe dat ( ) ; }

De waarde ongedefinieerd gedraagt ​​zich als false wanneer deze in een Booleaanse context wordt gebruikt. De volgende code voert bijvoorbeeld de functie myFunction uit omdat element myArray is niet gedefinieerd:

var mijnArray = ; if (! mijnArray[ 0 ] ) ( mijnFunctie ( ) ; }

De waarde ongedefinieerd wordt geconverteerd naar NaN wanneer deze in een numerieke context wordt gebruikt:

var een; een + 2 ; // NaN

Als een array wordt gemaakt met behulp van een letterlijke waarde in een script op het hoogste niveau, interpreteert JavaScript de array elke keer dat het een expressie evalueert die de letterlijke waarde bevat. Bovendien wordt de letterlijke waarde die in de functie wordt gebruikt, elke keer gemaakt wanneer de functie wordt aangeroepen.

Extra komma's in array-literalen

Het is niet nodig om alle elementen in de array letterlijk op te geven. Als je twee komma's achter elkaar zet, krijgen de ontbrekende elementen de waarde undefined . Bijvoorbeeld:

var fish = [ "Leeuw" , "Engel" ] ; // ["Leeuw", ongedefinieerd, "Engel"]

Deze array heeft 2 elementen met waarden en één leeg (vis is "Leeuw", vis is ongedefinieerd en vis is "Angel").

Als u een komma aan het einde van een lijst met elementen plaatst, wordt deze genegeerd. In het volgende voorbeeld is de lengte van de array 3. Er is geen myList . Alle andere komma's in de lijst geven een nieuw element aan.

Opmerking: Extra komma's kunnen fouten veroorzaken in oudere versies van browsers, dus u kunt het gebruik ervan het beste vermijden.

var mijnLijst = [ "thuis" , "school" , ] ; // ["thuis", ongedefinieerd, "school"]

In het volgende voorbeeld is de lengte van de array vier, de elementen myList en myList zijn ongedefinieerd:

var mijnLijst = [ , "thuis" , , "school" ] ; //

In het volgende voorbeeld is de lengte van de array vier, de elementen myList en myList hebben de waarde undefined. Alleen de laatste komma wordt genegeerd.

var mijnLijst = [ "thuis" , "school" , , ] ; // ["thuis", niet gedefinieerd, "school", niet gedefinieerd]

Het begrijpen van het gedrag van extra komma's is belangrijk voor het begrijpen van JavaScript als taal. Houd er echter bij het schrijven van uw eigen code rekening mee dat het expliciet declareren van ontbrekende elementen als ongedefinieerd de duidelijkheid van de code en het gemak van onderhoudbaarheid verbetert.

Booleaanse letterlijke waarden

Het Booleaanse type heeft twee letterlijke waarden: waar en onwaar.

Verwar de primitieve Booleaanse waarden waar en onwaar niet met de waar en onwaar waarden van een Booleaans object. Een Booleaans object is een wrapper-object over een primitief van het Booleaanse type. Lees Booleaanse waarde voor meer details.

Geheel getal letterlijk

Gehele getallen kunnen worden geschreven in decimale, hexadecimale, octale en binaire getalsystemen.

• Een decimaal geheel getal bestaat letterlijk uit een reeks cijfers zonder voorafgaande nul.
• Een voorloopnul in een geheel getal geeft aan dat het in een octaal getalsysteem is geschreven. Octale gehele getallen bestaan ​​alleen uit de cijfers 0-7.
• Voorlooptekens 0x (of 0X) geven aan dat het getal hexadecimaal is. Hexadecimale gehele getallen kunnen bestaan ​​uit de cijfers 0-9 en de letters a-f en A-F.
• De leidende tekens 0b (of 0B) geven aan dat het getal binair is. Binaire getallen kunnen alleen de cijfers 0 en 1 bevatten.

Enkele voorbeelden van gehele getallen:

0, 117 en -345 (decimaal) 015, 0001 en -077 (octaal) 0x1123, 0x00111 en -0xF1A7 (hex) 0b11, 0b0011 en -0b11 (binair)

Drijvende-kommagetal letterlijk

Drijvende-kommagetallen kunnen uit de volgende onderdelen bestaan:

• Een decimaal geheel getal dat een teken kan hebben (een "+" of "-" symbool vóór het getal),
• Decimale punt ("."),
• Breukdeel (een ander decimaal getal),
• Exposant.

Een exponent bestaat uit het teken "e" of "E", gevolgd door een geheel getal, dat eventueel een teken heeft. Een getal met drijvende komma moet uit ten minste één cijfer en een decimaalteken of het teken "e" (of "E") bestaan.

In een meer gecondenseerde vorm ziet de syntaxis er als volgt uit:

[(+|-)][.cijfers][(E|e)[(+|-)]cijfers]

3,14 -3,1E+12 -.33333333333333333333 .1e-23

Object letterlijk

Een letterlijk object is een lijst met nul of meer paren eigenschapsnamen en de bijbehorende waarden, tussen accolades (()). U moet een object niet letterlijk aan het begin van een expressie gebruiken omdat dit zal resulteren in een fout of gedrag dat u niet verwacht, omdat het teken "(" zal worden geïnterpreteerd als het begin van een blok.

In het volgende voorbeeld wordt de tekenreeks 'Saturn' toegewezen aan de eigenschap myCar van het object car, de eigenschap getCar aan het resultaat van het aanroepen van de functie CarTypes('Honda') en de speciale eigenschap aan de waarde van de variabele Sales:

var Verkoop = "Toyota" ; functie AutoTypes ( naam) ( if (naam == "Honda" ) ( retournaam; ) else ( retour "Sorry, wij verkopen niet"+ naam + "." ; ) ) var car = ( myCar: "Saturnus" , getCar: CarTypes ( "Honda" ), speciaal: Verkoop ); troosten. loggen ( auto. mijn auto); // Saturn-console. loggen ( auto. getCar); //Honda-console. loggen ( auto. speciaal); // Toyota

Bovendien kunt u numerieke of tekenreeksletterlijke waarden in eigenschapsnamen gebruiken, of het ene object in het andere nesten. Bijvoorbeeld:

var car = (vele auto's: ( a: "Saab", "b": "Jeep" ), 7: "Mazda" ); troosten. loggen ( auto. veel auto's. B) ; // Jeep-console. loggen ( auto[ 7 ]); // Mazda

De naam van de objecteigenschap kan elke tekenreeks zijn, inclusief de lege tekenreeks. Als de eigenschapsnaam geen geldige JavaScript-ID is, moet deze tussen aanhalingstekens staan. Om naar dergelijke namen te verwijzen, gebruikt u vierkante haakjes () in plaats van een punt (.):

var ongebruikelijkPropertyNames = ("" : "Een lege string" , "!": "Bang!" ) console. loggen ( ongebruikelijkePropertyNames. ""); // SyntaxError: onverwachte tekenreeks troosten. loggen ( ongebruikelijkePropertyNames[ "" ] ); // "Een lege string"-console. loggen ( ongebruikelijkePropertyNames. ! ); // SyntaxError: Onverwachte token ! troosten. loggen ( ongebruikelijkePropertyNames[ "!" ]) ; // "Knal!"

In ES2015 worden objectletterlijke waarden uitgebreid ter ondersteuning van het instellen van een prototype in de afkortingsconstructie voor foo: het instellen van foo , het definiëren van methoden, het maken van superaanroepen en het evalueren van eigenschapsnamen in expressies. Samen maken ze objectletterlijke waarden en klassedeclaraties vergelijkbaar, en zorgen ze ervoor dat objectontwerp van dezelfde functies kan profiteren.

Var obj = ( // __proto__ __proto__: theProtoObj, // Afkorting voor 'handler: handler' handler, // Methoden toString() ( // Superaanroepen retourneren "d " + super.toString(); ), // Dynamisch evalueren eigenschapsnamen [ "prop_" + (() => 42)() ]: 42 );

Let op het volgende voorbeeld:

var foo = (a: "alfa" , 2: "twee" ); troosten. loggen ( foe. A) ; // alpha-console. loggen ( foo[2] ); //twee //console.log(foo.2); // SyntaxError: onverwacht nummer// console.log(foo[a]); // ReferenceError: a is niet gedefinieerd troosten. loggen ( foo[ "een" ] ); // alpha-console. loggen ( foo[ "2" ] ); // twee

RegExp letterlijk

De letterlijke regexp is een patroon tussen schuine strepen. Het volgende is een voorbeeld van een letterlijke regex:

Varre = /ab+c/;

Tekenreeks letterlijk

Een letterlijke tekenreeks bestaat uit nul of meer tekens tussen dubbele aanhalingstekens ("") of enkele aanhalingstekens ("). De string moet worden gescheiden door aanhalingstekens van hetzelfde type, d.w.z. ofwel beide enkelspel of beide dubbelspel. Bijvoorbeeld:

"foo" "bar" "1234" "één regel \n nog een regel" "John's kat"

​ Je kunt elk van de methoden van het String-object aanroepen op een letterlijke string: JavaScript converteert de letterlijke string automatisch naar een tijdelijk String-object, roept de methode aan en vernietigt vervolgens het tijdelijke String-object. U kunt de eigenschap String.length ook gebruiken met een letterlijke tekenreeks:

Troosten. loggen ( "John's kat" lengte); // Aantal tekens in de regel, inclusief spatie.// In dit geval is de lengte van de string 10.

Rijsjablonen zijn ook beschikbaar in ES2015. Snaarpatronen bieden syntactische suiker voor het construeren van snaren. Dit is vergelijkbaar met de mogelijkheden voor stringinterpolatie in Perl, Python en andere. Bovendien kan een tag worden toegevoegd om de constructie van strings op maat mogelijk te maken, waardoor injectie-aanvallen en de constructie van datastructuren op hoog niveau op basis van de inhoud van de string worden vermeden.

// Eenvoudige tekenreekscreatie via letterlijke tekenreeks `In JavaScript is "\n" een regelfeed.` // Tekenreeksen met meerdere regels `In JavaScript is dit niet legaal.` // Tekenreeksinterpolatie var name = "Bobby", time = "Vandaag "; `Hallo $(naam), hoe gaat het $(tijd)?` // Bouw een HTTP-verzoekvoorvoegsel dat wordt gebruikt om vervangingen te interpreteren en POST te construeren`http://foo.org/bar?a=$(a)&b=$ ( b) Inhoudstype: application/json X-Credentials: $(credentials) ( "foo": $(foo), "bar": $(bar))`(myOnReadyStateChangeHandler);

U moet tekenreeksliterals gebruiken, tenzij u specifiek een String-object nodig heeft. Lees String voor meer informatie over het String-object.

Speciale tekens gebruiken in tekenreeksen

Naast gewone tekens kunt u ook speciale tekens in strings opnemen.

"één regel \n een andere regel"

In de volgende tabel worden de speciale tekens vermeld die u kunt gebruiken.

Speciale tekens in JavaScript

Symbool	Betekenis
\B	Terug (Backspace)
\F	Vertaling of paginafeed (formulierfeed)
\N	Nieuwe lijn
\R	Vervoer terug
\T	Tab
\v	Verticaal tabblad
\"	Apostrof of enkel aanhalingsteken
\"	Dubbele aanhalingstekens
\\	Backslash
\XXX	Latijns-1-teken weergegeven door drie octale cijfers XXX van 0 tot 377. Bijvoorbeeld \251 (het teken ©).
\X XX	Latijns-1-teken weergegeven door twee hexadecimale getallen XX van 00 tot FF. Bijvoorbeeld \xA9 (symbool ©).
\ u XXXX	Een Unicode-teken weergegeven door vier hexadecimale cijfers XXXX. Bijvoorbeeld \u00A9 (symbool ©).
\ u (XXXXXX)	Karakter in UTF-32BE. \u(2F804) betekent bijvoorbeeld hetzelfde als de reguliere notatie \uD87E\uDC04.

Ontsnap aan karakters

Voor tekens die niet in de bovenstaande tabel staan, wordt de leidende backslash genegeerd. Dit gebruik is verouderd en moet u vermijden.

U kunt een aanhalingsteken in een tekenreeks invoegen als u deze vooraf laat gaan door een backslash. Dit heet ontsnappende aanhalingstekens. Bijvoorbeeld:

var citaat = "Hij las 'De crematie van Sam McGee' van R.W. Service."; troosten. loggen ( citaat) ; // Hij las 'The Cremation of Sam McGee' van R.W. Dienst.

Als u een backslash in een string wilt opnemen, moet u deze vooraf laten gaan door een andere backslash. Bijvoorbeeld:

var home = "c:\\temp" ; // c:\temp

Je kunt ook aan de nieuwe regel ontsnappen. De backslash en nieuwe regel worden uit de tekenreeksinhoud verwijderd. Bijvoorbeeld:

var str = "deze string \ is gebroken \ over meerdere\ regels." console. loggen ( str); // deze string is verdeeld over meerdere regels.

Hoewel JavaScript de "heredoc"-syntaxis (opgemaakte tekst in een enkele tekenreeksvariabele) niet ondersteunt, kunt u deze emuleren door een nieuwe regel en een backslash aan het einde van elke regel toe te voegen:

var poem = "Rozen zijn rood, \n\ Viooltjes zijn blauw. \n\ Ik ben schizofreen, \n\ En ik ook."

Extra informatie

Dit hoofdstuk richt zich op de basissyntaxis voor declaraties en typen. Voor meer informatie over JavaScript-constructies leest u:

Het volgende hoofdstuk behandelt controleconstructies en foutafhandeling.

Een les waarin wordt onderzocht wat JSON is en welke voordelen het heeft ten opzichte van andere gegevensformaten.

Concept van JSON

JSON (JavaScript Object Notation) is een tekstformaat voor het weergeven van gegevens in JavaScript-objectnotatie.

Dit betekent dat de gegevens in JSON op dezelfde manier zijn georganiseerd als in een JavaScript-object. Maar in tegenstelling tot de laatste heeft het JSON-opnameformaat enkele functies die later zullen worden besproken.

JSON wordt meestal gebruikt in combinatie met AJAX, zodat de server gegevens in een handige vorm kan overbrengen naar een JavaScript-script, dat deze vervolgens op de pagina weergeeft.

JSON-formaatstructuur

Iedereen die bekend is met het proces van het maken van objecten in JavaScript, zal niets nieuws zien in de structuur van het JSON-formaat. Dit komt omdat de structuur van JSON de structuur van een JavaScript-object volgt, met enkele beperkingen.

Het is gemakkelijker om JSON te zien als een container die uit elementen bestaat. Elk element in zo’n container is een bepaalde structurele eenheid bestaande uit een sleutel en een waarde.

In dit geval is de waarde direct gerelateerd aan de sleutel en vormt een zogenaamd sleutel-waardepaar. Om de waarde van zo'n object te achterhalen, moet je de sleutel ervan kennen. Syntactisch worden dergelijke gegevens als volgt in JSON geschreven:

In de bovenstaande invoer kunt u zien dat de sleutel van de waarde wordt gescheiden met behulp van een dubbele punt (:). In dit geval moet de sleutel in het JSON-object tussen dubbele aanhalingstekens staan. Dit is het eerste kenmerk van JSON dat het onderscheidt van een JavaScript-object. Omdat in een JavaScript-object hoeft de sleutel (objecteigenschap) niet tussen dubbele aanhalingstekens te staan.

Bijvoorbeeld een objectstructuur die geldig is vanuit JavaScript-oogpunt, maar niet geldig vanuit JSON-oogpunt:

Var person = (naam: "Ivan"; ) // JavaScript-object

Waarschuwing: probeer de sleutel een naam te geven om de toegang tot de gegevens niet te bemoeilijken, d.w.z. Bij het samenstellen van een naam verdient het de voorkeur om de kameelnotatie te volgen of een onderstrepingsteken ("_") te gebruiken om woorden met elkaar te verbinden.

De sleutelwaarde in JSON kan in een van de volgende formaten worden geschreven: string, getal, object, array, boolean (booleaanse waarde waar of onwaar), null (speciale JavaScript-waarde).

Dit de tweede beperking in JSON, omdat Een JavaScript-object kan elk type gegevens bevatten, inclusief een functie.

Var person = ( "name": "Ivan"; "setName": function() ( console.log(this.name); ) ) // JavaScript-object

Om het ene element (sleutelwaardepaar) van het andere te scheiden, gebruikt u het kommateken (,).

Denk bijvoorbeeld aan JSON, dat uit verschillende datatypen bestaat.

Let op: het JSON-gegevensformaat staat geen commentaar toe binnen de structuur ervan.

Werken met JSON in JavaScript

In tegenstelling tot een JavaScript-object is JSON een string.

Bijvoorbeeld:

// de variabele personData bevat bijvoorbeeld een tekenreeks die JSON is var personData = "("name"Ivan", "age":37,"mother":("name"Olga", "age": 58),"kinderen":["Masha","Igor","Tanya"],"getrouwd": waar,"hond": null)";

Het werken met JSON gebeurt doorgaans in twee richtingen:

1. Parseren is het vertalen van een tekenreeks die JSON bevat naar een JavaScript-object.
2. Converteer een JavaScript-object naar een JSON-tekenreeks. Met andere woorden: deze actie doet het tegenovergestelde van parseren.

JSON-parsering

JSON-parsing, d.w.z. Het vertalen van een JSON-string naar een JavaScript-object gebeurt met behulp van de methode eval() of parse().

Met behulp van de eval() methode:

// de person-variabele is een JavaScript-object dat wordt verkregen door het uitvoeren van de JSON-code (string) var person= eval("("+personData+")");

Met behulp van de JSON.parse() methode:

// de person-variabele is een JavaScript-object dat wordt verkregen door het parseren van een JSON-string var person = JSON.parse(personData);

Een JavaScript-object converteren naar een JSON-tekenreeks

Het vertalen van een JavaScript-object naar een JSON-string gebeurt met behulp van de JSON.stringify() -methode. Deze methode doet het tegenovergestelde van de JSON.parse() methode.

Var personString = JSON.strigify(persoon);

Voordelen van het JSON-formaat

Het JSON-gegevensformaat heeft de volgende voordelen:

• handige en snel te gebruiken methoden die zijn ontworpen om een ​​JSON-string naar een JavaScript-object te converteren (parseren) en omgekeerd;
• duidelijke en eenvoudige datastructuur;
• zeer klein formaat in vergelijking met andere gegevensformaten (bijvoorbeeld XML). Dit komt omdat het JSON-formaat de minimaal mogelijke opmaak bevat, d.w.z. Bij het schrijven worden slechts enkele speciale tekens gebruikt. Dit is een zeer belangrijk voordeel, omdat... Gegevens gepresenteerd in JSON-indeling worden sneller geladen dan wanneer deze in andere indelingen worden gepresenteerd.

Vanwege het feit dat dit formaat zoveel voordelen heeft, wordt het niet alleen in JavaScript gebruikt, maar ook in veel andere talen, zoals C, Ruby, Perl, Python, PHP, enz.

Vergelijking van JSON- en XML-formaten

Het JSON-formaat heeft de volgende voordelen ten opzichte van het XML-formaat:

1. Voor sommige gegevensoverdrachten zal de JSON-grootte aanzienlijk kleiner zijn dan de XML-grootte.
2. JSON heeft betere conversiemethoden naar JavaScript-datastructuren dan XML.
3. JSON is gemakkelijker te maken dan XML.

Het werken met JSON-gegevens na het parseren gebeurt als een JavaScript-object.

//JSON var personData = "("name"Ivan", "leeftijd":37,"mother":("name"Olga", "leeftijd":58),,"children":["Masha " ,"Igor","Tanya"],"getrouwd": waar,"hond": null)"; //JavaScript-object persoon var persoon = JSON.parse(personData);

Laten we eens kijken naar de belangrijkste punten:

//haal de waarden op van de sleutel (eigenschap) naam person.name; persoon["naam"]; //haal de waarden op van de sleutelnaam (eigenschap) die zich in het object moeder person.mother.name bevindt; //verwijder het leeftijdselement delete(person.age) //voeg sleutel toe (of update) (eigenschap) person.eye = "bruin"; //als je met arrays werkt, moet je methoden gebruiken die specifiek zijn ontworpen om met arrays te werken //verwijder 1 element uit de array (splice-methode) person.children.splice(1,1) //voeg een element toe aan de array (push-methode ) persoon.kinderen.push("Katya");

Om de elementen in een object te doorlopen, kunt u een for..in-lus gebruiken:

For (sleutel persoonlijk) ( if (person.hasOwnProperty(key)) ( //key = key //value = person console.log("Key = " + key); console.log("Value = " + person) ; ) // als het persoonsobject een sleutel heeft (als de persoon een sleuteleigenschap heeft) ) // doorloop alle sleutels (eigenschappen) in het object

Om de elementen van een array te doorlopen, kunt u de volgende lus gebruiken:

Voor (var i=0; i

We hebben een nieuw boek uitgebracht, Social Media Content Marketing: hoe u in de hoofden van uw volgers kunt kruipen en ze verliefd kunt maken op uw merk.

JSON is een op tekst gebaseerd formaat voor gegevensuitwisseling, gebaseerd op een programmeertaal met meerdere paradigma's. Het belangrijkste doel is het opslaan en verzenden van een gestructureerde informatiestroom.

Door eenvoudige regels te gebruiken voor het construeren van karakters in JavaScript, kan een persoon een gemakkelijke en betrouwbare manier bieden om elk soort informatie op te slaan, of het nu een eenvoudig getal, hele reeksen of een groot aantal verschillende objecten is, uitgedrukt in platte tekst.

Bovendien wordt het JSON-formaat gebruikt om objecten en datastructuren te combineren tot een reeks componenten, waardoor software-eenheden worden gevormd waarmee u complexe records kunt opslaan en verwerken die uit verschillende variabelen van verschillende typen bestaan.

Zodra het bestand is aangemaakt, kunnen de regels die het bevat vrij eenvoudig via elk gegevenspad naar een andere locatie op het netwerk worden omgeleid. Dit komt omdat de tekenreeks platte tekst is.

Wat betekent JSON?

Hoewel het in bijna alle scripttalen kan worden gebruikt, verwijst de naam naar JavaScript. Het hulpmiddel heeft de volgende voordelen:

1. Neemt een relatief klein volume in beslag en is compact.
2. Tekstinhoud kan eenvoudig worden gegenereerd en leesbaar zijn voor computers en mensen.
3. Kan eenvoudig worden omgezet in een structuur voor bijna alle soorten formele talen die worden gebruikt om computerprogramma's te maken.
4. De meeste programmeertalen, of het nu JavaScript, Ruby, Python of PHP is, zijn uitgerust met functies en speciale tools voor het lezen en bewerken van een bestand.

In de overgrote meerderheid van de gevallen wordt het JSON-formaat gebruikt om te werken aan de overdracht van informatie van de server naar de browser. Dit proces vindt meestal op de achtergrond plaats tussen de browser en de webserver en de levering wordt uitgevoerd met behulp van AJAX. Dit komt doordat het tijdens het gegevensleveringsproces niet nodig is om de pagina opnieuw te laden.

Het werkt volgens het volgende scenario:

1. Een gebruiker klikt bijvoorbeeld op een productkaart in een webwinkel.
2. JavaScript, ingebouwd in de browser om webpagina's functioneler te maken, genereert met behulp van AJAX een verzoek aan een PHP-scriptprogrammabestand dat op de server draait. Hierdoor wordt de ID van het geselecteerde product overgedragen.
3. Het PHP-scriptprogrammabestand accepteert de productnaam, beschrijving, kosten en andere informatie in de database.
4. Hierna wordt een string gegenereerd en naar de browser verzonden.
5. JavaScript neemt deze tekenreeks, reconstrueert de informatie die deze bevat op basis van de gecodeerde weergave en geeft vervolgens informatie over het geselecteerde product weer op de webpagina van de gebruiker.

Dit alles gebeurt in een kwestie van milliseconden. Als JavaScript om welke reden dan ook op uw computer is uitgeschakeld, wordt de webpagina niet geladen of worden er fouten weergegeven.

Hoe het JSON-formaat werkt

In JSON zijn gegevenstypen onderverdeeld in verschillende categorieën: eenvoudig en complex. Het eerste type omvat in de eerste plaats tekstreeksen en cijfers, het tweede - objecten. In totaal zijn er zes hoofdtypen:

1. Cijfer. In dit geval kunnen getallen gehele getallen zonder teken of gehele getallen met teken zijn. In het bijzonder kan het een fractioneel deel bevatten en een weergave van reële getallen in de vorm van een fractioneel deel van een logaritme en een volgorde. Het bestand maakt het gebruik van gehele getallen en drijvende-kommaverdelingen gelijkelijk mogelijk. Deze techniek wordt zonder uitzondering in JavaScript voor alle numerieke waarden gebruikt, maar andere wiskundebibliotheken die deze techniek gebruiken, kunnen coderen met totaal andere algoritmen.
2. Een willekeurige reeks (reeks) Latijnse tekens, cijfers en leestekens (vanaf nul en Unicode-tekens). Elke volgende regel wordt van de vorige regel gescheiden door een paar leestekens - aanhalingstekens ("tekst") of door een symbool te gebruiken, met de omgekeerde spelling van het gebruikelijke symbool: een schuine streep.
3. Letterlijke waarden of constanten die rechtstreeks in de tekst zijn opgenomen. Dit kan elke waarde zijn, variërend van waar en onwaar of hun equivalenten.
4. Array. Het is een geordende lijst met tekens vanaf nul. Elk personage kan in welke vorm dan ook worden weergegeven.
5. Een voorwerp. Dit is een chaotisch samengestelde samenstelling van sleutel/waarde-paren. Omdat de primaire functie van objecten het representeren van een abstract gegevenstype is, wordt aanbevolen (maar niet vereist) dat sleutels uniek zijn.
6. Een lege waarde, aangegeven met het woord 'Null'.

Spaties tussen tekens zijn toegestaan ​​als ze tussen syntactische eenheden worden gebruikt. Hiervoor worden verschillende symbolen gebruikt: de gebruikelijke inspringing, horizontale teksttabbladen en een schuine streep.

Hoe het JSON-formaat te openen

Het tkan worden weergegeven in populaire coderingsstandaarden, die het mogelijk maken om Unicode-tekens compacter op te slaan en te verzenden. In het bijzonder is de standaardwaarde hier UTF-8. UTF-16 en UTF-32 kunnen ook worden gebruikt. Het gebruik ervan wordt bepaald door het feit dat alle drie de standaarden de volledige tekenset ondersteunen.

Maar als ze worden geëscaped (niet tussen aanhalingstekens geplaatst) om als reguliere expressie te worden gebruikt, kunnen ze worden geschreven om tekens in extra vlakken weer te geven met behulp van UTF-16.

De eenvoudigste manier om het JSON-formaat te openen is door Kladblok op pc te gebruiken. Om dit te doen, moet u een nieuw tekstdocument maken en openen, "Bestand" in de linkerbovenhoek selecteren en vervolgens "Openen".

Nadat u het gewenste document heeft gevonden, klikt u op de knop "Openen" van de Verkenner.

Het document wordt geopend en kan worden bekeken en bewerkt.

Daarnaast zijn er programma's van derden om het JSON-formaat te openen. Onder hen zijn Altova XMLSpy, Notepad++, Komodo Edit, Sublime Text, enz.

Hoe een bestand te maken

Het JSON-formaat wordt meestal gebruikt voor het werken (opslaan en gebruiken van) service-informatie. Meestal is dit een personeelstabel die noch de ontwikkelaar, noch het publiek van de webbron mag zien.

Er zijn verschillende manieren om een ​​bestand met de juiste extensie te maken. Allereerst kan dit worden gedaan met behulp van een gewone teksteditor, die deel uitmaakt van het Microsoft Windows-besturingssysteem. Om dit te doen, moet u Kladblok openen, de juiste code plakken en het document opslaan in de gebruikelijke en enige beschikbare extensie. Hierna moet u dit wijzigen in de gewenste optie.

De tweede methode omvat het gebruik van services van derden. De meest populaire is JSON Editor Online. Het is veel handiger dan de Kladblok-optie. De service-interface wordt gepresenteerd in de vorm van twee werkzones.

In de eerste zone vindt het eigenlijke werk van het genereren van data plaats, in de tweede zone bevinden zich de tools hiervoor. Nadat het creatieproces is voltooid, klikt u op de knop "Opslaan" en selecteert u hoe u het resultaat wilt opslaan: op schijf of online.

Zoals reeds opgemerkt, is het gebruik van de online service veel handiger dan Kladblok. Dit komt door het feit dat de service tijdens het gebruik automatisch syntaxisfouten detecteert en deze markeert, zodat de gebruiker omissies kan opmerken en deze onmiddellijk kan corrigeren.