JavaScript array at paglikha nito. Lahat ng tungkol sa arrays JavaScript

Sa artikulong ito ay isasaalang-alang namin ang array ng JavaScript, mga bahagi nito. JavaScript ay isang ideyal na oriented na script na wika na idinisenyo para sa programming. Sa katunayan, ipinapatupad nito ang wika ng ECMAScript (ECMA-262 standard).

Saan ginagamit ang JavaScript? Ginagamit ito bilang isang naka-embed na wika upang matukoy ang path ng software sa object ng application. Ito ay matatagpuan sa mga browser: ginagamit ito doon bilang isang wika ng script na nagbibigay sa interactivity ng mga web page.

Ang pinakamahalagang katangian ng arkitektura ng produktong ito ay pabago-bago at mahina ang pag-type, awtomatikong pamamahala ng memorya, perpektong programming, mga function na mga bagay sa unang kategorya.

Sa pangkalahatan, ang JavaScript ay naiimpluwensyahan ng iba't ibang dahilan, dahil sa pag-unlad na nais nilang lumikha ng isang wika katulad ng Java, ngunit madaling gamitin ng mga programmer. Sa pamamagitan ng ang paraan, ang wika ng JavaScript ay hindi pagmamay-ari ng anumang enterprise o organisasyon, na ginagawang hindi tulad ng isang bilang ng mga estilo ng software na ginagamit ng mga web developer.

Dapat tandaan na ang JavaScript ay isang rehistradong trademark ng Oracle Corporation.

Ano ang isang array?

Ang isang array ay isang uri ng data na nag-iimbak ng mga numerong may halaga. Ang bawat ganoong halaga ay tinatawag na isang bahagi ng array, at ang figure na kung saan ang bahagi ay nauugnay ay tinatawag na isang index. Ang JavaScript array ay untyped. Nangangahulugan ito na ang mga detalye ng array ay maaaring magkaroon ng anumang uri, at iba't ibang mga bahagi na kabilang sa parehong array ay may ganap na iba't ibang uri.

Bilang karagdagan, ang array ng JavaScript ay pabago-bago, na nangangahulugan na hindi na kailangang ipahayag ang isang nakapirming laki. Pagkatapos ng lahat, maaari kang magdagdag ng mga bagong bahagi sa anumang oras.

Array Production

Gamit ang wika ng JavaScript, ang paggawa ng isang array ay hindi mahirap. Mayroong dalawang pamamaraan para dito. Ang una ay nagsasangkot ng paggawa ng isang array na may literal na square brackets, na sa loob ay isang listahan ng mga bahagi, na pinaghihiwalay ng mga kuwit.

• Var empty = []; / Blank array;
• Var numers = [4, 1, 2, 5]; / / Isang array na may limang mga digital na bahagi;
• Var diff = [1.5, false, "text"]; // isang array na may tatlong elemento ng iba't ibang uri.

Kadalasan, hindi ito nangangailangan na ang mga halaga ay simple (mga string at mga numero). Ito ay maaari ding maging anumang iba pang mga expression, halimbawa, paksa literals, iba pang mga function at arrays.

Ang pangalawang paraan upang lumikha ng isang array ay ang tawag sa taga-disenyo ng Array (). Maaari mo itong anyayahan sa tatlong paraan:

• Pagtawag sa taga-disenyo nang walang mga argumento: var b - bagong Array (). Dito, isang walang laman na array ay nilikha na katumbas ng isang walang laman na literal [].
• Ang tagapagbuo ay tahasang may mga halaga ng n mga sangkap ng array: var b = bagong Array (1, 3, 5, 8, "string", totoo). Sa kasong ito, ang taga-disenyo ay iniharap sa isang listahan ng mga argumento na nagiging sangkap ng isang bagong array. Ang mga argumento ay nakasulat sa array sa lokasyon kung saan tinukoy ang mga ito.
• Tukuyin ang saklaw para sa kasunod na pagtatalaga ng mga halaga. Ginagawa ito sa pamamagitan ng pagtukoy ng isang array ng isang numero na nakapaloob sa panaklong: var b = bagong Array (5). Ang pamamaraan ng pagtuklas ay nagsasangkot ng paglalaan sa hanay ng kinakailangang bilang ng mga bahagi (bawat isa ay nakalista bilang hindi natukoy) na may posibilidad ng kasunod na pagpapalagay ng mga halaga sa proseso ng pagtatanghal. Ang ganitong uri ay karaniwang ginagamit upang ilagay sa lugar na Javascript array na ang haba ay kilala nang maaga.

Isulat, basahin, at idagdag ang mga detalye ng array

Maaari mong ma-access ang mga bahagi ng isang array gamit ang [] operator. Sa pamamagitan ng ang paraan, ang lahat ng mga sangkap sa JavaScript, simula sa zero, ay may bilang. Upang makuha ang kinakailangang sangkap, ang numero nito ay ipinahiwatig sa mga parisukat na bracket. Bilang isang tuntunin, ang mga detalye ay maaaring mabago. At upang magdagdag ng JavaScript sa array, magtakda lamang ng isang bagong halaga.

Dapat pansinin na sa arrays ng JavaScript maaari kang mag-imbak ng anumang bilang ng mga elemento ng anumang uri.

Haba ng array

Kaya, alam namin kung ano ang JavaScript. Ang haba ng array ay karaniwang isang kagiliw-giliw na kababalaghan. Isaalang-alang natin ito nang mas detalyado. Ang lahat ng mga arrays, na parehong dinisenyo sa tulong ng taga-disenyo ng Array (), at tinukoy ng array literal, ay may isang tiyak na haba ng ari-arian na naalaala ang kabuuang bilang ng mga elemento na na-save. Dahil maaaring mayroong hindi natukoy na mga detalye sa array (naipaliwanag hindi natukoy), ang isang mas tumpak na pagpapahayag ay ganito ang tunog: ang haba ng kalidad ay laging mas malaki sa pamamagitan ng isa kaysa sa pinakamalaking numero (index) ng sangkap ng array. Awtomatikong inaayos ang haba ng kalidad, natitirang tumpak kapag lumilitaw ang mga bagong bahagi sa array.

Upang ipakita ang pangwakas na bahagi ng array, maaari mong gamitin ang haba ng ari-arian.

Ang huling detalye ay may isang indeks na mas mababa kaysa sa sukat ng array. Pagkatapos ng lahat, ang pagbibilang ay nagsisimula palagi mula sa scratch. Oh, JavaScript na ito! Ang haba ng array ay depende sa eksaktong bilang ng mga elemento. Kaya kung hindi mo alam kung gaano karami ang dapat sa mga ito, ngunit kailangan mong sumangguni sa trailing element ng array, kailangan mong ilapat ang entry: v.length - 1.

Mga array ng mga detalye ng array

Kadalasan ang haba ng ari-arian ay ginagamit upang magbilang ng mga detalye ng isang array sa isang loop:

• Var fruits = ["strawberry", "peach", "apple", "banana"];
• Para sa (var I = 0; i
• Document.write (prutas [i] + "...").

Sa halimbawang ito, lumilitaw na patuloy na inilalagay ang mga sangkap at magsimula sa unang bahagi na nagmamay-ari ng zero index. Kung hindi ito ang kaso, bago tawagan ang bawat elemento ng array, kinakailangan upang suriin kung ito ay tinukoy.

Ang isang loop ay minsan din ginagamit upang magpasimula ng mga bahagi.

Ang pagpapataas at pagputol ng isang array

Nagtataka ako kung paano ginagamit ang string ng wika ng JavaScript sa array upang idagdag? Sa proseso ng pagtatrabaho sa mga arrays, ang haba ng kalidad ng haba ay awtomatikong nagpapabuti, na ang dahilan kung bakit kailangan nating alagaan ang ating sarili. Kailangan na isaalang-alang ang isang detalye: ang haba ng ari-arian ay hindi lamang nababasa, kundi pati na rin sa pagsulat. Kung ang kalidad ng haba ay itinalaga ng isang halaga na mas mababa sa kasalukuyang laki, pagkatapos ay ang array ay mabawasan sa tinukoy na halaga. Ang anumang mga sangkap na wala sa bagong hanay ng mga index ay naka-recline, at ang kanilang mga halaga ay nawala, kahit na sa kalaunan upang bumalik ang haba pabalik - ang mga halaga ay hindi naibalik.

Napakadaling i-clear ang array tulad nito: foo.length = 0.

Kung ang kalidad ng haba ay mas malaki kaysa sa kasalukuyang halaga nito, sa dulo ng array, lilitaw ang mga bagong na-uninstall na bahagi, na kung saan ay tataas ito sa ninanais na laki.

Tinatanggal ang mga detalye ng array

Tinutukoy ng operator ng delete ang isang di-natukoy na halaga sa array component, at patuloy itong umiiral. Kung nais mong tanggalin ang isang sangkap ng array ng JavaScript upang ang mga natitirang mga detalye ay inilipat sa bakanteng espasyo, kailangan mong gamitin ang isa sa predictable na pamamaraan ng array. Ang Array.shift () method ay nag-aalis ng unang bahagi, ang pop () ay ang terminating component, at ang splice () na paraan ay isa o isang hanay ng mga sangkap saanman sa array.

Naglalaman ng multidimensional

Tila nag-uuri kami nang kaunti tungkol sa kung ano ang JavaScript. Dalawang-dimensional arrays - na kung ano ang kailangang isaalang-alang sa karagdagang. Naaalala mo ba na ang arrays ng JavaScript ay maaaring maglaman ng iba pang mga elemento bilang mga sangkap? Ang tampok na ito ay ginagamit upang makabuo ng mga multidimensional arrays. Upang bisitahin ang mga sangkap sa isang hanay ng mga arrays, ito ay sapat na upang ilapat ang parisukat na mga bracket nang dalawang beses.

Associative arrays

At ngayon matututunan namin kung paano ginagamit ang mga nag-uugnay na trademark ng JavaScript na mga arrays. Para sa mga ito, kailangan naming tingnan ang teorya: associative arrays ay minsan tinatawag na hash talahanayan. Gumagamit sila ng mga string sa halip na ini-index. Ang paggamit ng gayong mga istraktura ay kahawig ng paggamit ng pangalan ng ari-arian ng isang simpleng bagay, ngunit sa bersyong ito kapag gumaganap ng trabaho sa isang format ng array. Dahil ang JavaScript ay walang anumang paraan ng paghawak ng mga associative arrays, ginagamit ang mga ito nang mas madalas kaysa sa mga maginoo. Dapat tandaan na maaari pa rin itong maging kapaki-pakinabang sa pag-iimbak ng data at gawing madaling matandaan ang mga detalye na kailangan mong ma-access.

Array Output

At ngayon ano ang matututunan natin sa sistema ng JavaScript? Outputting isang array sa isang dialog box (sa monitor screen), pati na rin ang pagpapakita ng mga halaga ng mga sangkap ng array.

Kung kailangan ng programa upang ipakita ang mga halaga ng lahat ng mga sangkap, pagkatapos ay maginhawa upang gamitin ang para sa pahayag. Ito ay kagiliw-giliw na ang variable-counter ng para sa mga panuntunan ay ginagamit bilang isang index ng bahagi ng array.

Paglilinis

Upang mai-filter ang array ng JavaScript, kailangan mong i-clear ang haba nito:

• Var myArray = [1, 2, 5, 23];
• MyArray.length = 0.

Ang mga sumusunod ay nagpapakita ng pagpapatupad ng malinaw na () na pagtatalaga sa mahusay na kilala balangkas ng JavaScript ng prototype:

• Maaliwalas: function () {;
• This.length = 0;
• Ibalik ito;
• }.

Pagdagdag at Pagtanggal ng Mga Bahagi

Bueno, patuloy naming pinag-aaralan ang kagiliw-giliw na wika ng JavaScript na ito. Ang elemento ng array ay maaaring tanggalin at idinagdag sa parehong paraan tulad ng karaniwang mga katangian ng iba pang mga bagay. Ngunit mayroong ilang mga pagkakaiba: kapag nagdadagdag ng mga katangian ng numeric, maaaring baguhin ang kalidad ng haba, at kapag ang haba ng ari-arian ay binago, ang mga de-kalidad na katangian ay maaaring alisin. Sa prinsipyo, ang algorithm para sa pagtatakda ng mga katangian ng arrays ay ang mga sumusunod:

• Kapag nagdadagdag ng isang hindi kilalang digital na ari-arian i, kung ang haba ay katumbas ng o mas mababa kaysa sa i, ang haba ay tinukoy bilang i + 1.
• Kapag binabago ang kalidad ng haba, ang mga sumusunod na pagkilos ay ginaganap: kung ang nakatalagang halaga ay mas mababa sa zero, Saklaw ang RangeError. Tanggalin ang lahat ng numerical katangian at mga indeks, na katumbas ng bagong haba at kung alin ay mas malaki.

Sa pangkalahatan, ang pag-alis ng isang elemento ng isang JavaScript array ay hindi mahirap. Matapos ang lahat, kahit na itakda ang haba, kailangan mong alisin ang "dagdag" na bahagi mula rito. Kaya ang pagpipilian ng paglilinis ng array. Kung ang nakatalagang variable ng isang walang laman na bagong array para sa ilang kadahilanan ay hindi angkop, at ito ay kinakailangan upang pawalang-bisa ang kasalukuyang, ito ay sapat na upang italaga ang halaga ng zero sa kalidad nito.

Ang mga pamamaraan ay hindi nauugnay, palitan, pop at itulak

Kahit na ang mga sangkap ng array ay binago nang manu-mano, maraming pinapayo na ginagamit mo ang mga built-in na pamamaraan para sa ito. Ito ang pananalig na ito na tinitiyak ang tamang halaga ng haba ng kalidad at ang kawalan ng mga pagtanggal sa array. Sa pamamagitan ng ang paraan, ang tamang haba ay tumutugma sa bilang ng mga sangkap.

Ang push method ay nagdadala ng mga nailipat na bahagi sa dulo ng array. Ang paraan ng pop ay nagbabalik sa sumusunod na bahagi at tinatanggal ito.

Sa pangkalahatan, sa Internet Explorer sa ilalim ng ikawalo na bersyon, ang unshift ay maaaring bumalik hindi natukoy, sa ibang mga browser - isang bagong halaga ng haba. Kaya mas mahusay na huwag umasa sa halaga ng pagbalik mula sa unshift.

Pagdaragdag at pag-aalis ng mga bahagi sa gitna ng isang array

Kung kailangan mong tanggalin ang isang hanay ng JavaScript, ano ang dapat kong gawin? Ito ay kilala na ang paraan ng pag-splice ay may pirma na Array.prototype.splice.

Tinatanggal mula sa array ang deleteCount ng mga sangkap, simula sa simula. Kung higit sa dalawang argumento ang naipasa, pagkatapos ay ang lahat ng kasunod na mga argumento sa array ay inilagay sa halip na ang mga naalis. Kung simula ay minus, pagkatapos ay ang index kung saan ang withdrawal ay magpapatuloy ay katumbas ng haba + simula. Bumalik sa array ay mula sa malayuang elemento.

Sa katunayan, gamit ang paraan ng pag-splice, maaari mong alisin ang mga bahagi mula sa gitna ng array o magdagdag ng anumang numero sa anumang lugar sa array.

Sa pinakasimpleng bersyon, kung nais mong alisin ang isang bahagi na may index i, kailangan mong hilingin ang array para sa paraan ng pag-splice gamit ang mga parameter na i at 1.

Sa prinsipyo, ang pangalawang parameter ng paraan ng pagsabog ay hindi sapilitan, ngunit ang pag-uugali ng isang function na may isang argument sa bawat browser ay iba.

Halimbawa, sa Firefox, sa mga pinakabagong bersyon ng Opera, sa Safari at sa Chrome, ang lahat ng mga detalye ay aalisin sa dulo ng array.

Sa IE, walang sangkap ang maaalis. Sa unang mga bersyon ng Opera, ang pag-uugali ay hindi maaaring hinulaan - isang bagay na may index ng pagsisimula ay aalisin. Samakatuwid, laging kinakailangan upang ilipat ang hindi bababa sa dalawang bahagi sa pamamaraang ito.

Mga Key

Siyempre, kapag nag-aaral ng JavaScript, nag-uugnay arrays, tulad ng nabanggit mas maaga, hindi rin dapat overlooked. Ito ay isang abstract uri ng impormasyon (ang interface sa bodega ng data), na nagbibigay-daan sa iyo upang i-save ang mga pares ng form "(key, halaga)" at suportahan ang mga pagpapatakbo ng pagdaragdag ng isang pares, pati na rin ang pagtanggal at paghahanap para sa isang key pares:

- HANAPIN (key).

- INSERT (halaga, susi).

- TANGGALIN (key).

Ipinapalagay na ang dalawang pares na may katulad na mga key ay hindi maitatago sa nakakaugnay na array. Sa isang pares, ang k + vv ay tinatawag na halaga na nauugnay sa key k. Ang mga semantiko at mga pangalan ng mga pagpapatakbo sa itaas sa iba't ibang mga pagpapatupad ng naturang mga arrays ay maaaring magkakaiba.

Kaya, ang FIND action (key) ay nagbabalik ng halaga na nauugnay sa tinukoy na susi, o ilang tukoy na bagay na UNDEF, ibig sabihin ay nawawala ang halaga na nauugnay sa tinukoy na key. Ang dalawang iba pang mga pagkilos ay hindi nagbabalik ng anumang bagay (maliban kung matagumpay ang operasyon).

Sa pangkalahatan, mula sa punto ng view ng interface, ang nauugnay na array ay madaling isaalang-alang bilang isang simpleng array na kung saan hindi lamang ang mga integer ay maaaring gamitin bilang mga indeks, kundi pati na rin ang iba pang mga uri ng mga halaga - halimbawa, mga string.

Sa pamamagitan ng paraan, ang suporta para sa mga naturang arrays ay magagamit sa maraming mga mataas na antas ng interpreted na mga wika ng software, tulad ng PHP, Perl, Ruby, Python, Tcl, JavaScript, at iba pa. Para sa mga wika na walang built-in na kasangkapan para sa pagtatrabaho sa mga nag-uugnay na arrays, isang malaking bilang ng mga pagpapatupad ang nalikha sa anyo ng mga aklatan.

Ang isang halimbawa ng isang nag-uugnay na array ay maaaring isang direktoryo ng telepono. Sa ganitong uri, ang halaga ay ang kumplikadong "F. IO + address ", at ang key - numero ng telepono. Ang isang numero ng telepono ay may isang master, ngunit ang isang tao ay maaaring magkaroon ng maraming numero.

Associative extensions

Dapat itong nabanggit na ang mga pinakasikat na extension ay kinabibilangan ng mga sumusunod na pagkilos:

• BAWAT - "lumakad" sa lahat ng naka-save na mga pares.
• CLEAR - tanggalin ang lahat ng mga tala.
• MIN - hanapin ang pares ng pinakamaliit na halaga ng key.
• MAX - hanapin ang mag-asawa na may pinakamataas na halaga ng key.

Sa huling dalawang variant, kailangan mong tukuyin ang pagkilos sa paghahambing sa mga key.

Pagpapatupad ng Associative Arrays

Mayroong maraming iba't ibang mga pagpapatupad ng nag-uugnay array. Ang pinaka-karaniwang pagpapatupad ay maaaring batay sa isang simpleng array, ang mga bahagi na kung saan ay mga pares (halaga, susi). Upang pabilisin ang mga pagkilos ng paghahanap, maaari mong ayusin ang mga bahagi ng array na ito sa pamamagitan ng susi at gumawa ng paghahanap gamit ang binary na paghahanap. Ngunit ito ay tataas ang agwat ng oras na kinakailangan upang magdagdag ng bagong pares, dahil kinakailangan upang "ilipat ang hiwalay" ang mga sangkap ng array upang mag-pack ng isang bagong rekord sa lumilitaw na walang laman na cell.

Ang pinakamahusay na kilalang pagpapatupad ay batay sa iba't ibang mga puno ng paghahanap. Halimbawa, sa tipikal na C + + reading room STL, ang mapa ng mapa ay ipinatupad batay sa isang itim-at-pula na puno. Sa mga estilo Ruby, Tcl, Python ang isa sa mga uri ng hash table ay ginagamit. May iba pang mga pagpapatupad.

Sa pangkalahatan, ang bawat pagpapatupad ay may sariling mga kakulangan at pakinabang. Mahalaga na ang lahat ng tatlong aksyon ay isinasagawa sa parehong average at pinakamasamang pananaw para sa panahon O (log n), kung saan n ang kasalukuyang bilang ng mga naka-save na pares. Para sa mga pinagsama-samang puno ng paghahanap (kabilang ang para sa black-and-red tree) ang kalagayan na ito ay natupad.

Ito ay kilala na sa pagpapatupad batay sa hash talahanayan, ang average na oras ay tinukoy bilang D (1), na kung saan ay mas mahusay kaysa sa mga pagkilos batay sa mga puno ng paghahanap. Of course, ito ay hindi nagbibigay ng garantiya ang isang mataas na bilis ng pagganap ng hiwalay na mga pagpapatakbo: INSERT pagkilos oras sa ang pinakamasama kaso, naka-denote bilang O (n). INSERT proseso ay ginanap sa loob ng mahabang panahon na ang duty ratio umabot sa pinakamataas na punto, at doon ay ang kailangan upang buuin muli ang hash talahanayan index.

Siya nga pala, ang mga pahayag na sumira masamang na sa batayan na ito ay imposible upang maisagawa ang sunud karagdagang pagkilos MAX, MIN, at isang algorithm upang hanapin ang lahat sine-save ng mga pares sa pababang pagkakasunud-sunod o pataas key.