Mga variable

Pagdedeklara ng mga Variable

Bago ka makagamit ng variable sa JavaScript, dapat itong ideklara. Ang mga variable ay ipinahayag gamit ang isang keyword var sa sumusunod na paraan:

Var i; var sum;

Sa pamamagitan ng paggamit ng var keyword nang isang beses, maaari kang magdeklara ng maraming variable:

Ang pagdedeklara ng mga variable ay maaaring isama sa kanilang pagsisimula:

Var message = "hello"; var i = 0, j = 0, k = 0;

Kung walang tinukoy na paunang halaga sa pahayag ng var, idineklara ang variable, ngunit ang paunang halaga nito ay nananatiling hindi natukoy hanggang sa mabago ito ng programa.

Kung mayroon kang karanasan sa paggamit ng mga programming language na may mga static na uri ng data, tulad ng C# o Java, maaari mong mapansin na ang mga variable na deklarasyon sa JavaScript ay walang uri ng deklarasyon. Ang mga variable sa JavaScript ay maaaring mag-imbak ng mga halaga ng anumang uri. Halimbawa, sa JavaScript maaari kang magtalaga ng numero sa isang variable, at pagkatapos ay magtalaga ng string sa parehong variable:

Var i = 10; i = "hello";

Gamit ang var statement, maaari mong ideklara ang parehong variable nang higit sa isang beses. Kung ang paulit-ulit na deklarasyon ay naglalaman ng isang initializer, kung gayon ito ay gumaganap bilang isang regular na pahayag ng pagtatalaga.

Kung susubukan mong basahin ang halaga ng isang hindi idineklara na variable, bubuo ng error ang JavaScript. Sa mahigpit na mode na ibinigay ng pamantayan ng ECMAScript 5, ang isang error ay itinaas din kapag sinusubukang magtalaga ng isang halaga sa isang hindi idineklara na variable. Gayunpaman, ayon sa kasaysayan, at kapag hindi naisakatuparan sa mahigpit na mode, kung magtatalaga ka ng isang halaga sa isang variable na hindi idineklara gamit ang isang var statement, gagawin ng JavaScript ang variable na iyon bilang isang pag-aari ng pandaigdigang bagay, at ito ay kikilos na halos kapareho ng isang wastong ipinahayag na variable. Nangangahulugan ito na ang mga pandaigdigang variable ay hindi kailangang ideklara. Gayunpaman, ito ay itinuturing na isang masamang ugali at maaaring pagmulan ng mga error, kaya palaging subukang ipahayag ang iyong mga variable gamit ang var.

Variable na saklaw

Ang saklaw ng isang variable ay ang bahagi ng programa kung saan tinukoy ang variable. Ang isang pandaigdigang variable ay may pandaigdigang saklaw - ito ay tinukoy para sa buong JavaScript program. Kasabay nito, ang mga variable na ipinahayag sa loob ng isang function ay tinukoy lamang sa katawan nito. Ang mga ito ay tinatawag na lokal at may lokal na saklaw. Ang mga parameter ng function ay itinuturing din na mga lokal na variable, na tinukoy lamang sa loob ng katawan ng function na iyon.

Sa loob ng isang function body, isang lokal na variable ang nangunguna sa isang global variable na may parehong pangalan. Kung idedeklara mo ang isang lokal na variable o function na parameter na may parehong pangalan bilang isang global variable, ang global variable ay talagang itatago:

Var resulta = "global"; function getResult() ( var result = "local"; return result; ); console.log(getResult()); // Ipakita ang "lokal"

Kapag nagdedeklara ng mga variable na may pandaigdigang saklaw, ang var statement ay maaaring tanggalin, ngunit kapag nagdedeklara ng mga lokal na variable, dapat mong palaging gamitin ang var statement.

Ang mga variable ay nagsisilbing "mga lalagyan" para sa pag-iimbak ng impormasyon.

Naaalala mo ba ang High School Algebra?

Naaalala mo ba ang algebra ng paaralan? x=5, y=6, z=x+y

Naaalala mo ba na ang isang titik (hal. x) ay maaaring gamitin upang mag-imbak ng isang halaga (hal. 5), at maaari mong gamitin ang impormasyon sa itaas upang kalkulahin na ang halaga ng z ay 11?

Ang mga titik na ito ay tinatawag mga variable, at ang mga variable ay maaaring gamitin upang mag-imbak ng mga halaga (x=5) o mga expression (z=x+y).

Mga Variable ng JavaScript

Tulad ng sa algebra, ang mga variable ng JavaScript ay ginagamit upang mag-imbak ng mga halaga o expression.

Maaaring magkaroon ng maikling pangalan ang variable, gaya ng x, o mas mapaglarawang pangalan, gaya ng carname.

Mga panuntunan para sa mga pangalan ng variable ng JavaScript:

• Ang mga pangalan ng variable ay case sensitive (y at Y ay dalawang magkaibang variable)
• Ang mga pangalan ng variable ay dapat magsimula sa isang titik o underscore

Komento: Dahil case sensitive ang JavaScript, case sensitive din ang mga pangalan ng variable.

Halimbawa

Maaaring magbago ang halaga ng isang variable habang tumatakbo ang script. Maaari kang sumangguni sa isang variable sa pamamagitan ng pangalan nito upang ipakita o baguhin ang halaga nito.

Pagdedeklara (Paggawa) ng Mga Variable ng JavaScript

Ang paggawa ng mga variable sa JavaScript ay mas karaniwang tinutukoy bilang "pagdedeklara" ng mga variable.

Nagdedeklara ka ng mga variable ng JavaScript gamit ang isang keyword var:

Pagkatapos sundin ang mga mungkahi sa itaas, ang variable x maglalaman ng halaga 5 , At carname maglalaman ng halaga Mercedes.

Komento: Kapag nagtalaga ka ng text value sa isang variable, ilakip ito sa mga panipi.

Komento: Kung magdedeklara ka muli ng isang variable, hindi ito mawawala ang halaga nito.

Mga Lokal na Variable ng JavaScript

Ang isang variable na ipinahayag sa loob ng isang JavaScript function ay nagiging LOKAL at magiging available lamang sa loob ng function na ito. (ang variable ay may lokal na saklaw).

Maaari mong ideklara ang mga lokal na variable na may parehong pangalan sa iba't ibang mga function dahil kinikilala ang mga lokal na variable sa function kung saan idineklara ang mga ito.

Nawawasak ang mga lokal na variable kapag lumabas ang function.

Matututunan mo ang higit pa tungkol sa mga function sa kasunod na mga aralin sa JavaScript.

Mga Global Variable ng JavaScript

Ang mga variable na idineklara sa labas ng function ay nagiging GLOBAL, at lahat ng script at function sa page ay maa-access ang mga ito.

Ang mga pandaigdigang variable ay masisira kapag isinara mo ang pahina.

Kung nagdedeklara ka ng isang variable nang hindi gumagamit ng "var", palaging nagiging ang variable GLOBAL.

Pagtatalaga ng Mga Halaga sa Mga Hindi Idineklara na Variable ng JavaScript

Kung magtatalaga ka ng mga halaga sa mga variable na hindi pa nadedeklara, ang mga variable ay awtomatikong idedeklara bilang mga global variable.

Ang mga alok na ito:

Matututunan mo ang higit pa tungkol sa mga operator sa susunod na aralin sa JavaScript.

Sinasaklaw ng kabanatang ito ang pangunahing grammar, variable na deklarasyon, uri ng data, at literal.

Mga pangunahing kaalaman

Hinihiram ng JavaScript ang karamihan sa syntax nito mula sa Java, ngunit naiimpluwensyahan din ng mga wika tulad ng Awk, Perl, at Python.

JavaScript case sensitive at gumagamit ng character encoding Unicode. Halimbawa, ang salitang Früh ("maaga" sa German) ay maaaring gamitin bilang variable na pangalan.

Var Früh = "foobar";

Ngunit, ang variable na früh ay hindi katulad ng Früh dahil ang JavaScript ay case sensitive.

Mga komento

Syntax mga komento ay kapareho ng sa C++ at marami pang ibang wika:

// Komento na sumasakop sa isang linya. /* Isang komentong sumasaklaw sa ilang linya. */ /* Hindi ka maaaring mag-nest /* ng komento sa loob ng komento */ SyntaxError */

mga ad

May tatlong uri ng mga deklarasyon sa JavaScript:

var Nagdedeklara ng variable; ang pagsisimula ng variable sa isang value ay opsyonal. hayaan Nagdedeklara ng lokal na variable sa saklaw ng block na opsyonal ang pagsisimula ng variable sa isang value. const Nagdedeklara ng pinangalanang read-only na pare-pareho.

Mga variable

Maaari kang gumamit ng mga variable bilang simbolikong pangalan para sa mga halaga sa iyong aplikasyon. Ang mga pangalan ng variable ay tinatawag na mga identifier at dapat sundin ang ilang partikular na panuntunan.

Ang isang identifier sa JavaScript ay dapat magsimula sa isang titik, isang underscore (_), o isang dollar sign ($); ang kasunod na mga character ay maaari ding mga numero (0-9). Dahil case sensitive ang JavaScript, kasama sa mga titik ang mga character na "A" hanggang "Z" (upper case) at ang mga character na "a" hanggang "z" (lower case).

Maaari mong gamitin ang ISO 8859-1 o Unicode na mga titik sa mga identifier, gaya ng å o ü. Maaari mo ring gamitin ang parehong mga simbolo sa mga identifier.

Ilang halimbawa ng wastong pangalan: Number_hits, temp99, _name.

Pagdedeklara ng mga Variable

Maaari kang magdeklara ng variable sa tatlong paraan:

• Gamit ang var keyword. Halimbawa, var x = 42 . Maaaring gamitin ang syntax na ito upang magdeklara ng mga lokal at pandaigdigang variable.
• Magtalaga lamang ng halaga sa variable. Halimbawa, x = 42. Ang mga variable na ipinahayag sa ganitong paraan ay pandaigdigan. Ang ganitong deklarasyon ay bumubuo ng isang mahigpit na babala (mahigpit na mode). Hindi inirerekomenda na gamitin ang pamamaraang ito.
• Gamit ang let keyword. Halimbawa, hayaan ang y = 13 . Ang syntax na ito ay maaaring gamitin upang magdeklara ng isang lokal na variable sa loob ng saklaw ng isang bloke.

Pagtatalaga ng mga halaga

Ang isang variable na idineklara na may var o let nang hindi nagtatalaga ng isang paunang halaga ay may hindi natukoy na halaga.

Kung susubukan mong i-access ang isang hindi idineklara na variable o isang variable bago ito ideklara, isang ReferenceError exception ang itatapon:

Var a; console.log("Ang halaga ng a ay " + a); //The value of variable a is undefined console.log("The value of b is " + b); //Uncaught ReferenceError: b ay hindi tinukoy console.log("Ang halaga ng c ay " + c); //Halaga ng variable c undefined var c; console.log("Ang halaga ng x ay " + x); //Uncaught ReferenceError: x is not definition let x;

Maaari mong gamitin ang hindi natukoy upang matukoy kung ang isang variable ay may halaga. Sa sumusunod na halimbawa, ang input variable ay hindi nakatalaga ng value at ang if statement ay magsusuri sa true:

var input; if (input === undefined) ( doThis ( ); ) iba pa (doThat ( ) ; }

Ang value na hindi natukoy ay kumikilos na parang false kapag ginamit sa isang boolean na konteksto. Halimbawa, ang sumusunod na code ay nagpapatupad ng myFunction function dahil elemento myArray ay hindi tinukoy:

var myArray = ; kung (! myArray[ 0 ] ) ( myFunction ( ) ; }

Ang value na hindi natukoy ay na-convert sa NaN kapag ginamit sa isang numeric na konteksto:

var a; a + 2 ; // NaN

Kung ang isang array ay ginawa gamit ang isang literal sa isang top-level na script, pagkatapos ay binibigyang-kahulugan ng JavaScript ang array sa tuwing susuriin nito ang isang expression na naglalaman ng literal. Bukod pa rito, ang literal na ginamit sa function ay nilikha sa tuwing tinatawag ang function.

Mga karagdagang kuwit sa mga literal ng array

Hindi kinakailangang tukuyin ang lahat ng elemento sa literal na array. Kung maglalagay ka ng dalawang kuwit sa isang hilera, ang mga nawawalang elemento ay magkakaroon ng value na hindi natukoy . Halimbawa:

var fish = [ "Leon" , , "Anghel" ] ; // ["Leon", hindi natukoy, "Anghel"]

Ang array na ito ay may 2 elemento na may mga halaga at isang walang laman (ang isda ay "Leon", ang isda ay hindi natukoy, at ang isda ay "Anghel").

Kung maglalagay ka ng kuwit sa dulo ng isang listahan ng mga elemento, ito ay hindi papansinin. Sa sumusunod na halimbawa, ang haba ng array ay 3. Walang myList . Ang lahat ng iba pang kuwit sa listahan ay nagpapahiwatig ng bagong elemento.

Komento: Ang mga karagdagang kuwit ay maaaring magdulot ng mga error sa mga mas lumang bersyon ng mga browser, kaya pinakamahusay na iwasan ang paggamit sa mga ito.

var myList = [ "tahanan" , , "paaralan" , ] ; // ["tahanan", hindi natukoy, "paaralan"]

Sa sumusunod na halimbawa, ang haba ng array ay apat, ang mga elementong myList at myList ay hindi natukoy:

var myList = [ , "tahanan" , , "paaralan" ] ; //

Sa sumusunod na halimbawa, ang haba ng array ay apat, ang mga elementong myList at myList ay may hindi natukoy na halaga. Ang huling kuwit lamang ang hindi pinapansin.

var myList = [ "tahanan" , , "paaralan" , , ] ; // ["home", undefined, "school", undefined]

Ang pag-unawa sa gawi ng mga karagdagang kuwit ay mahalaga sa pag-unawa sa JavaScript bilang isang wika. Gayunpaman, kapag nagsusulat ng sarili mong code, tandaan na ang tahasang pagdedeklara ng mga nawawalang elemento bilang hindi natukoy ay nagpapabuti sa kalinawan at kadalian ng pagpapanatili ng code.

Boolean literals

Ang uri ng Boolean ay may dalawang literal na halaga: totoo at mali.

Huwag malito ang primitive na mga halaga ng Boolean na totoo at mali sa totoo at mali na mga halaga ng isang bagay na Boolean. Ang Boolean object ay isang wrapper object sa isang Boolean type primitive. Para sa higit pang mga detalye, basahin ang Boolean.

Integer literal

Ang mga integer ay maaaring isulat sa decimal, hexadecimal, octal, at binary number system.

• Ang literal na decimal integer ay binubuo ng isang sequence ng mga digit na walang leading zero.
• Ang isang nangungunang zero sa isang integer literal ay nagpapahiwatig na ito ay nakasulat sa octal number system. Ang mga Octal integer ay binubuo lamang ng mga digit na 0-7.
• Ang mga nangungunang 0x (o 0X) na character ay nagpapahiwatig na ang numero ay hexadecimal. Ang mga hexadecimal integer ay maaaring binubuo ng mga numero 0-9 at ang mga titik a-f at A-F.
• Ang mga nangungunang character na 0b (o 0B) ay nagpapahiwatig na ang numero ay binary. Ang mga binary na numero ay maaari lamang isama ang mga digit na 0 at 1.

Ilang halimbawa ng integer literal:

0, 117 at -345 (decimal) 015, 0001 at -077 (octal) 0x1123, 0x00111 at -0xF1A7 (hex) 0b11, 0b0011 at -0b11 (binary)

Literal na numero ng floating point

Ang mga numero ng floating point ay maaaring binubuo ng mga sumusunod na bahagi:

• Isang decimal integer na maaaring magkaroon ng sign (isang "+" o "-" na simbolo bago ang numero),
• Decimal point ("."),
• Fractional na bahagi (isa pang decimal na numero),
• Exhibitor.

Ang isang exponent ay binubuo ng character na "e" o "E" na sinusundan ng isang integer, na maaaring may sign. Ang isang floating point number ay dapat na binubuo ng hindi bababa sa isang digit at alinman sa isang decimal point o ang character na "e" (o "E").

Sa isang mas condensed form, ang syntax ay ganito ang hitsura:

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

3.14 -3.1E+12 -.33333333333333333333 .1e-23

Literal na bagay

Ang literal na object ay isang listahan ng zero o higit pang mga pares ng mga pangalan ng property at ang mga nauugnay na value ng mga ito, na nakapaloob sa mga kulot na brace (()). Hindi ka dapat gumamit ng literal na object sa simula ng isang expression dahil ito ay magreresulta sa isang error o pag-uugali na hindi mo inaasahan dahil ang "(" na karakter ay bibigyang-kahulugan bilang simula ng isang bloke.

Ang sumusunod na halimbawa ay nagtatalaga ng string na "Saturn" sa myCar property ng car object, ang getCar property sa resulta ng pagtawag sa CarTypes("Honda") function, at ang espesyal na property sa value ng Sales variable:

var Sales = "Toyota" ; function na CarTypes ( pangalan) ( kung (pangalan == "Honda") ( ibalik ang pangalan; ) iba pa ( ibalik "Paumanhin, hindi kami nagbebenta"+ pangalan + "." ; ) ) var car = ( myCar: "Saturn" , getCar: CarTypes ( "Honda" ), espesyal: Sales ); console. log ( sasakyan. ang aking kotse); ( // Saturn console. log ( sasakyan. getCar); //Konsol ng Honda. log

sasakyan. espesyal); //Toyota

Bukod pa rito, maaari kang gumamit ng numeric o string literal sa mga pangalan ng property, o mag-nest ng isang bagay sa loob ng isa pa. Halimbawa: ( var car = ( manyCars: ( a: "Saab" , "b" : "Jeep" ), 7 : "Mazda" ); console. log ( sasakyan. maraming kotse. b); // Jeep console. log

kotse[ 7 ]); //Mazda

var unusualPropertyNames = ( "" : "Isang walang laman na string" , "!" : "Bang!" ) console. log ( hindi pangkaraniwangPropertyNames. ""); // SyntaxError: Hindi inaasahang string console. log ( hindi pangkaraniwangPropertyNames[ "" ]); // "Isang walang laman na string" console. log ( hindi pangkaraniwangPropertyNames. ! ); // SyntaxError: Hindi inaasahang token ! console. log ( hindi pangkaraniwangPropertyNames[ "!" ]); // "Bang!"

Sa ES2015, pinalawak ang mga object literal upang suportahan ang pagtatakda ng prototype sa shorthand construct para sa foo: setting foo , pagtukoy ng mga pamamaraan, paggawa ng mga super call, at pagsusuri ng mga pangalan ng property sa mga expression. Magkasama, ginagawa nilang magkatulad ang mga literal na bagay at mga deklarasyon ng klase, at pinapayagan ang disenyo ng bagay na makinabang mula sa parehong mga tampok.

Var obj = ( // __proto__ __proto__: theProtoObj, // Shorthand para sa 'handler: handler' handler, // Methods toString() ( // Super calls return "d " + super.toString(); ), // Dynamic evaluate mga pangalan ng ari-arian [ "prop_" + (() => 42)() ]: 42 );

Pakitandaan ang sumusunod na halimbawa:

var foo = ( a: "alpha" , 2 : "two" ); console. log ( foo. a) ; // alpha console. log ( foo[ 2 ]); // dalawa // console.log(foo.2); // SyntaxError: Hindi inaasahang numero// console.log(foo[a]); // ReferenceError: a ay hindi tinukoy console. log ( foo[ "a" ]); // alpha console. log ( foo[ "2" ]); // dalawa

RegExp literal

Ang literal na regexp ay isang pattern sa pagitan ng mga slash. Ang sumusunod ay isang halimbawa ng literal na regex:

Var re = /ab+c/;

Literal na string

Ang literal na string ay zero o higit pang mga character na nakapaloob sa double quotes (") o single quotes ("). Ang string ay dapat na delimited ng mga quote ng parehong uri, i.e. alinman sa parehong single o parehong doubles. Halimbawa:

"foo" "bar" "1234" "isang linya \n isa pang linya" "Pusa ni John"

Maaari mong tawagan ang alinman sa mga pamamaraan ng String object sa isang literal na string: Awtomatikong iko-convert ng JavaScript ang literal na string sa isang pansamantalang String object, tatawagin ang pamamaraan, at pagkatapos ay sisirain ang pansamantalang String object. Maaari mo ring gamitin ang String.length property na may literal na string:

Console. log ( "Pusa ni John" . // Bilang ng mga character sa linya, kabilang ang espasyo.// Sa kasong ito, ang haba ng string ay 10.

Available din ang mga row template sa ES2015. Ang mga pattern ng string ay nagbibigay ng syntactic sugar para sa pagbuo ng mga string. Ito ay katulad ng mga kakayahan sa interpolation ng string sa Perl, Python, at iba pa. Bukod pa rito, maaaring magdagdag ng tag upang payagan ang customized na pagbuo ng mga string, pag-iwas sa mga pag-atake ng injection at pagbuo ng mga high-level na istruktura ng data mula sa mga nilalaman ng string.

// Simpleng string creation sa pamamagitan ng literal na string `Sa JavaScript "\n" ay isang line-feed.` // Multi-line string `Sa JavaScript hindi ito legal.` // String interpolation var name = "Bobby", time = "ngayon"; `Kumusta $(pangalan), kumusta ka $(oras)?` // Bumuo ng HTTP request prefix na ginagamit upang bigyang-kahulugan ang mga kapalit at bumuo ng POST`http://foo.org/bar?a=$(a)&b=$ ( b) Content-Type: application/json X-Credentials: $(credentials) ( "foo": $(foo), "bar": $(bar))`(myOnReadyStateChangeHandler);

Dapat kang gumamit ng mga literal na string maliban kung kailangan mo ng isang String object. Para sa higit pang impormasyon tungkol sa String object, basahin ang String.

Paggamit ng mga espesyal na character sa mga string

Bilang karagdagan sa mga regular na character, maaari mo ring isama ang mga espesyal na character sa mga string.

"isang linya \n isa pang linya"

Inililista ng sumusunod na talahanayan ang mga espesyal na character na magagamit mo.

Mga espesyal na character sa JavaScript

Simbolo	Ibig sabihin
\b	Bumalik (Backspace)
\f	Pagsasalin o page feed (Form feed)
\n	Bagong linya
\r	Pagbabalik ng karwahe
\t	Tab
\v	Vertical na tab
\"	Apostrophe o solong quote
\"	Dobleng quote
\\	Backslash
\XXX	Latin-1 na character na kinakatawan ng tatlong octal digit XXX mula 0 hanggang 377. Halimbawa, \251 (ang © character).
\x XX	Latin-1 na character na kinakatawan ng dalawang hexadecimal na numero XX mula 00 hanggang FF. Halimbawa, \xA9 (simbolo ©).
\u XXXX	Isang Unicode na character na kinakatawan ng apat na hexadecimal digit XXXX. Halimbawa, \u00A9 (simbolo ©).
\u (XXXXX)	Character sa UTF-32BE. Halimbawa, ang ibig sabihin ng \u(2F804) ay pareho sa karaniwang notasyon na \uD87E\uDC04.

Mga character na tumakas

Para sa mga character na hindi nakalista sa talahanayan sa itaas, ang nangungunang backslash ay binabalewala. Ang paggamit na ito ay hindi na ginagamit at dapat mong iwasan ito.

Maaari kang magpasok ng isang quote sa isang string kung unahan mo ito ng isang backslash. Ito ay tinatawag na escaping quotes. Halimbawa:

var quote = "Nabasa niya ang \"The Cremation of Sam McGee\" ni R.W. Service."; console. log ( quote); // Binasa niya ang "The Cremation of Sam McGee" ni R.W. Serbisyo.

Upang magsama ng backslash sa isang string, kailangan mo itong unahan ng isa pang backslash. Halimbawa:

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

Maaari ka ring makatakas sa bagong linya. Ang backslash at newline ay aalisin sa nilalaman ng string. Halimbawa:

var str = "ang string na ito ay nasira \ sa maraming linya." log ( str); // ang string na ito ay nasira sa maraming linya.

Bagama't hindi sinusuportahan ng JavaScript ang syntax ng "heredoc" (na-format na text sa iisang string variable), maaari mo itong tularan sa pamamagitan ng pagdaragdag ng newline at backslash sa dulo ng bawat linya:

var poem = "Ang mga rosas ay pula, \n\ Ang mga violet ay asul. \n\ Ako ay schizophrenic, \n\ At gayon din ako."

karagdagang impormasyon

Nakatuon ang kabanatang ito sa pangunahing syntax para sa mga deklarasyon at uri. Para sa higit pang impormasyon tungkol sa mga konstruksyon ng JavaScript, basahin ang:

Ang susunod na kabanata ay sumasaklaw sa mga control construct at paghawak ng error.

Isang aralin na nagsusuri kung ano ang JSON at kung paano ito may mga pakinabang sa iba pang mga format ng data.

Konsepto ng JSON

Ang JSON (JavaScript Object Notation) ay isang text format para sa kumakatawan sa data sa JavaScript object notation.

Nangangahulugan ito na ang data sa JSON ay nakaayos sa parehong paraan tulad ng sa isang object ng JavaScript. Ngunit hindi tulad ng huli, ang format ng pag-record ng JSON ay may ilang mga tampok na tatalakayin sa ibang pagkakataon.

Karaniwang ginagamit ang JSON kasabay ng AJAX upang mailipat ng server ang data sa isang maginhawang anyo sa isang script ng JavaScript, na ipapakita ito sa pahina.

Istraktura ng format ng JSON

Ang sinumang pamilyar sa proseso ng paglikha ng mga bagay sa JavaScript ay hindi makakakita ng anumang bago sa istruktura ng JSON na format. Ito ay dahil ang istraktura ng JSON ay sumusunod sa istraktura ng isang object ng JavaScript, na may ilang mga limitasyon.

Mas madaling isipin ang JSON bilang isang lalagyan na binubuo ng mga elemento. Ang bawat elemento sa naturang lalagyan ay isang tiyak na yunit ng istruktura na binubuo ng isang susi at isang halaga.

Sa kasong ito, direktang nauugnay ang value sa key at bumubuo ng tinatawag na key-value pair. Upang makuha ang halaga sa naturang bagay, kailangan mong malaman ang susi nito. Syntactically, ang naturang data ay nakasulat sa JSON tulad ng sumusunod:

Sa entry sa itaas, makikita mo na ang susi ay pinaghihiwalay mula sa halaga gamit ang isang tutuldok (:). Sa kasong ito, ang susi sa JSON object ay dapat na nakapaloob sa double quotes. Ito ang unang feature ng JSON na nakikilala ito sa isang object ng JavaScript. kasi sa isang JavaScript object, ang key (object property) ay hindi kailangang isama sa double quotes.

Halimbawa, isang object structure na valid mula sa isang JavaScript point of view ngunit hindi valid mula sa JSON point of view:

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

Babala: subukang pangalanan ang susi upang hindi kumplikado ang pag-access sa data, i.e. Kapag bumubuo ng isang pangalan, mas mainam na sumunod sa notasyon ng kamelyo o gumamit ng salungguhit ("_") upang ikonekta ang mga salita.

Maaaring isulat ang key value sa JSON sa isa sa mga sumusunod na format: string, number, object, array, boolean (boolean value true or false), null (espesyal na value ng JavaScript).

Ito ang pangalawang limitasyon sa JSON, dahil Ang isang JavaScript object ay maaaring maglaman ng anumang uri ng data, kabilang ang isang function.

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

Upang paghiwalayin ang isang elemento (key-value pair) mula sa isa pa, gamitin ang comma (,) na character.

Halimbawa, isaalang-alang ang JSON, na binubuo ng iba't ibang uri ng data.

Pansin: hindi pinapayagan ng format ng data ng JSON ang mga komento sa loob ng istraktura nito.

Paggawa gamit ang JSON sa JavaScript

Hindi tulad ng JavaScript object, ang JSON ay isang string.

Halimbawa:

// halimbawa, ang variable ng personData ay naglalaman ng string na JSON var personData = "("name":"Ivan","age":37,"mother":("name":"Olga","age": 58),"mga anak":["Masha","Igor","Tanya"],"may asawa": totoo,"aso": null)";

Ang pagtatrabaho sa JSON ay karaniwang isinasagawa sa dalawang direksyon:

1. Ang pag-parse ay ang pagkilos ng pagsasalin ng string na naglalaman ng JSON sa isang JavaScript object.
2. I-convert ang isang JavaScript object sa isang JSON string. Sa madaling salita, ang pagkilos na ito ay kabaligtaran ng pag-parse.

Pag-parse ng JSON

Pag-parse ng JSON, ibig sabihin. Ang pagsasalin ng JSON string sa isang JavaScript object ay ginagawa gamit ang eval() o parse() na paraan.

Gamit ang eval() na pamamaraan:

// ang variable ng tao ay isang JavaScript object na nakuha sa pamamagitan ng pagpapatupad ng JSON code (string) var person= eval("("+personData+")");

Gamit ang JSON.parse() na pamamaraan:

// ang variable ng tao ay isang JavaScript object na nakukuha sa pamamagitan ng pag-parse ng JSON string var person = JSON.parse(personData);

Pag-convert ng JavaScript object sa isang JSON string

Ang pagsasalin ng JavaScript object sa isang JSON string ay ginagawa gamit ang JSON.stringify() method. Ginagawa ng pamamaraang ito ang kabaligtaran ng JSON.parse() na pamamaraan.

Var personString = JSON.strigify(tao);

Mga kalamangan ng JSON format

Ang format ng data ng JSON ay may mga sumusunod na pakinabang:

• maginhawa at mabilis na gamitin na mga pamamaraan na idinisenyo upang i-convert (i-parse) ang isang JSON string sa isang JavaScript object at pabalik;
• malinaw at simpleng istraktura ng data;
• napakaliit na sukat kumpara sa ibang mga format ng data (hal. XML). Ito ay dahil ang JSON format ay naglalaman ng pinakamababang posibleng pag-format, ibig sabihin. Sa pagsulat nito, kakaunti lamang ang mga espesyal na karakter ang ginagamit. Ito ay isang napakahalagang kalamangan, dahil... Ang data na ipinakita sa format na JSON ay maglo-load nang mas mabilis kaysa kung ipinakita ito sa ibang mga format.

Dahil sa katotohanan na ang format na ito ay may napakaraming pakinabang, ginamit ito hindi lamang sa JavaScript, kundi pati na rin sa maraming iba pang mga wika, tulad ng C, Ruby, Perl, Python, PHP, atbp.

Paghahambing ng mga format ng JSON at XML

Ang format ng JSON ay may mga sumusunod na pakinabang sa format na XML:

1. Para sa ilang paglilipat ng data, ang laki ng JSON ay magiging mas maliit kaysa sa laki ng XML.
2. Ang JSON ay may mas mahusay na mga paraan ng conversion sa mga istruktura ng data ng JavaScript kaysa sa XML.
3. Ang JSON ay mas madaling gawin kaysa sa XML.

Paggawa gamit ang data ng JSON pagkatapos gawin ang pag-parse bilang object ng JavaScript.

//JSON var personData = "("pangalan":"Ivan","edad":37,"ina":("pangalan":"Olga","edad":58),,"mga anak":["Masha " ,"Igor","Tanya"],"may asawa": totoo,"aso": null)"; //JavaScript object person var person = JSON.parse(personData);

Tingnan natin ang mga pangunahing punto:

//kunin ang mga halaga ng key (property) name person.name; tao ["pangalan"]; //kunin ang mga halaga ng key (property) na pangalan na matatagpuan sa object mother person.mother.name; //delete the age element delete(person.age) //add (o update) key (property) person.eye = "brown"; //kapag nagtatrabaho sa mga array, dapat kang gumamit ng mga pamamaraan na idinisenyo upang gumana nang partikular sa mga array //alisin ang 1 elemento mula sa array (paraan ng splice) person.children.splice(1,1) //magdagdag ng elemento sa array (paraan ng push ) tao.mga bata ("Katya");

Upang umulit sa mga elemento sa isang bagay, maaari kang gumamit ng for..in loop:

Para sa (key in person) ( if (person.hasOwnProperty(key)) ( //key = key //value = person console.log("Key = " + key); console.log("Value = " + tao) ; ) // kung ang object ng tao ay may susi (kung ang tao ay may key property) ) // umulit sa lahat ng key (properties) sa object

Upang umulit sa mga elemento ng isang array, maaari mong gamitin ang sumusunod na loop:

Para sa (var i=0; i

Naglabas kami ng bagong libro, Social Media Content Marketing: How to get Inside Your Followers' Heads and Make Them Fall in Love with Your Brand.

Ang JSON ay isang text-based na data exchange format batay sa isang multi-paradigm programming language. Ang pangunahing layunin nito ay mag-imbak at magpadala ng isang nakabalangkas na daloy ng impormasyon.

Sa pamamagitan ng paggamit ng mga simpleng panuntunan para sa pagbuo ng mga character sa JavaScript, ang isang tao ay makakapagbigay ng madali at maaasahang paraan upang mag-imbak ng anumang uri ng impormasyon, maging ito ay isang simpleng numero, buong string, o isang malaking bilang ng iba't ibang mga bagay na ipinahayag sa plain text.

Bilang karagdagan, ang format ng JSON ay ginagamit upang pagsamahin ang mga bagay at istruktura ng data sa isang hanay ng mga bahagi, sa gayon ay bumubuo ng mga yunit ng software na nagbibigay-daan sa iyong mag-imbak at magproseso ng mga kumplikadong talaan na binubuo ng ilang mga variable ng iba't ibang uri.

Kapag nalikha na ang file, ang mga linyang nilalaman nito ay medyo madaling i-redirect sa ibang lokasyon sa Network sa pamamagitan ng anumang path ng data. Ito ay dahil ang string ay plain text.

Ano ang ibig sabihin ng JSON?

Bagama't maaari itong gamitin sa halos lahat ng mga wika ng script, ang pangalan nito ay tumutukoy sa JavaScript. Ang tool ay may mga sumusunod na pakinabang:

1. Sumasakop sa medyo maliit na volume at compact.
2. Ang nilalaman ng teksto ay madaling mabuo at mababasa ng mga computer at tao.
3. Maaaring madaling ma-convert sa isang istraktura para sa halos lahat ng mga uri ng mga pormal na wika na ginagamit upang lumikha ng mga programa sa computer.
4. Karamihan sa mga programming language, maging ito JavaScript, Ruby, Python o PHP, ay nilagyan ng mga function at espesyal na tool para sa pagbabasa at pag-edit ng isang file.

Sa karamihan ng mga kaso, ang format ng JSON ay ginagamit upang magtrabaho sa paglilipat ng impormasyon mula sa server patungo sa browser. Ang prosesong ito ay karaniwang nangyayari sa background sa pagitan ng browser at ng web server, at ang paghahatid ay isinasagawa gamit ang AJAX. Ito ay dahil sa ang katunayan na sa panahon ng proseso ng paghahatid ng data ay hindi na kailangang i-reload ang pahina.

Gumagana ito ayon sa sumusunod na senaryo:

1. Halimbawa, nag-click ang isang user sa isang card ng produkto sa isang online na tindahan.
2. Ang JavaScript, na binuo sa browser upang gawing mas gumagana ang mga web page, ay bumubuo ng isang kahilingan gamit ang AJAX sa isang PHP script program file na tumatakbo sa server. Dahil dito, inililipat ang ID ng napiling produkto.
3. Ang PHP script program file ay tumatanggap ng pangalan ng produkto, paglalarawan, gastos at iba pang impormasyon na nakapaloob sa database.
4. Pagkatapos nito, nabuo ang isang string at ipinadala sa browser.
5. Kinukuha ng JavaScript ang string na ito, muling binubuo ang impormasyong nilalaman nito mula sa naka-encode na representasyon nito, at pagkatapos ay ipinapakita ang impormasyon tungkol sa napiling produkto sa web page ng user.

Nangyayari ang lahat ng ito sa loob lamang ng millisecond. Gayunpaman, kung hindi pinagana ang JavaScript sa iyong computer sa ilang kadahilanan, hindi maglo-load ang web page o magpapakita ng mga error.

Paano gumagana ang format ng JSON

Sa JSON, ang mga uri ng data ay nahahati sa ilang kategorya: simple at kumplikado. Kasama sa unang uri, una sa lahat, ang mga string ng teksto at numero, ang pangalawa - mga bagay. Sa kabuuan, mayroong anim na pangunahing uri:

1. Numeral. Sa kasong ito, maaaring maging unsigned integer o signed integer ang mga numero. Sa partikular, maaari itong maglaman ng isang fractional na bahagi at isang representasyon ng mga tunay na numero sa anyo ng isang fractional na bahagi ng isang logarithm at isang order. Pinapayagan ng file ang paggamit ng mga integer at floating point division nang pantay. Ang diskarteng ito ay ginagamit sa JavaScript para sa lahat ng mga numeric na halaga nang walang pagbubukod, ngunit ang iba pang mga math library na gumagamit nito ay maaaring mag-encode gamit ang ganap na magkakaibang mga algorithm.
2. Isang arbitrary na pagkakasunud-sunod (string) ng mga Latin na character, numero at elemento ng bantas (mula sa zero at Unicode na mga character). Ang bawat kasunod na linya ay pinaghihiwalay mula sa nakaraang linya ng isang pares ng mga bantas - mga panipi ("teksto") o sa pamamagitan ng paggamit ng isang simbolo, na may reverse spelling ng karaniwang simbolo, isang slash.
3. Ang mga literal o constant ay direktang kasama sa teksto. Maaari itong maging anumang halaga mula sa totoo at mali o sa kanilang mga katumbas.
4. Array. Ito ay isang nakaayos na listahan ng mga character mula sa zero pasulong. Ang bawat karakter ay maaaring katawanin sa anumang anyo.
5. Isang bagay. Ito ay isang magulo na komposisyon ng mga pares ng susi/halaga. Dahil ang pangunahing pag-andar ng mga bagay ay kumakatawan sa isang abstract na uri ng data, inirerekomenda (ngunit hindi kinakailangan) na maging natatangi ang mga susi.
6. Isang walang laman na halaga, na tinutukoy ng salitang "Null".

Pinapayagan ang mga puwang sa pagitan ng mga character kung ginagamit ang mga ito sa pagitan ng mga syntactic unit. Upang gawin ito, maraming mga simbolo ang ginagamit: ang karaniwang indentation, pahalang na mga tab ng teksto at isang slash.

Paano buksan ang JSON format

Ang format ng text data exchange ay maaaring katawanin sa mga sikat na pamantayan sa pag-encode, na ginagawang posible na mag-imbak at magpadala ng mga Unicode na character nang mas compact. Sa partikular, ang default dito ay UTF-8. Maaari ding gamitin ang UTF-16 at UTF-32. Ang kanilang paggamit ay tinutukoy ng katotohanan na ang lahat ng tatlong pamantayan ay sumusuporta sa buong set ng character.

Ngunit, kung sila ay nakatakas (hindi sinipi) upang magamit bilang isang regular na expression, maaari silang isulat upang kumatawan sa mga character sa karagdagang mga eroplano gamit ang UTF-16.

Ang pinakamadaling paraan upang buksan ang JSON format ay ang paggamit ng Notepad sa PC. Upang gawin ito, kailangan mong lumikha at magbukas ng bagong dokumento ng teksto, piliin ang "File" sa kaliwang sulok sa itaas, pagkatapos ay "Buksan".

Ang pagkakaroon ng natagpuan ang nais na dokumento, mag-click sa Explorer na "Buksan" na pindutan.

Ang dokumento ay magbubukas at magagamit para sa pagtingin at pag-edit.

Bilang karagdagan, may mga third-party na programa para sa pagbubukas ng JSON format. Kabilang sa mga ito ang Altova XMLSpy, Notepad++, Komodo Edit, Sublime Text, atbp.

Paano gumawa ng file

Ang format ng JSON ay karaniwang ginagamit para sa pagtatrabaho (pag-iimbak at paggamit) ng impormasyon ng serbisyo. Kadalasan ito ay isang talahanayan ng staffing na hindi dapat makita ng developer o ng audience ng web resource.

Mayroong ilang mga paraan upang lumikha ng isang file na may naaangkop na extension. Una sa lahat, ito ay maaaring gawin gamit ang isang regular na text editor, na bahagi ng Microsoft Windows operating system. Upang gawin ito, kailangan mong buksan ang Notepad, i-paste ang naaangkop na code at i-save ang dokumento sa karaniwan at magagamit lamang na extension. Pagkatapos nito, kailangan mong baguhin ito sa nais na opsyon.

Kasama sa pangalawang paraan ang paggamit ng mga serbisyo ng third-party. Ang pinakasikat ay ang JSON Editor Online. Ito ay mas maginhawa kaysa sa Notepad na opsyon. Ang interface ng serbisyo ay ipinakita sa anyo ng dalawang work zone.

Sa unang zone, ang aktwal na gawain ng pagbuo ng data ay nagaganap sa pangalawang zone, ang mga tool para dito ay matatagpuan. Matapos makumpleto ang proseso ng paglikha, kailangan mong mag-click sa pindutang "I-save" at piliin kung paano i-save ang resulta: sa disk o online.

Tulad ng nabanggit na, ang paggamit ng online na serbisyo ay mas maginhawa kaysa sa Notepad. Ito ay dahil sa ang katunayan na ang serbisyo ay awtomatikong nakakakita ng mga error sa syntax sa panahon ng operasyon at i-highlight ang mga ito upang ang user ay mapansin ang mga pagkukulang at itama ang mga ito kaagad.