Taulukko, joka koostuu viidestä javascript-elementistä. JavaScript-taulukko ja sen luominen. Kaikki JavaScript-taulukoista. Lukeminen, kirjoittaminen ja taulukkoelementtien lisääminen

• Käännös

Useimmat nykyään kehitetyt sovellukset vaativat vuorovaikutusta jonkinlaisen tietojoukon kanssa. Kokoelmien elementtien käsittely on yleinen toiminto, jonka olet todennäköisesti kohdannut. Kun työskentelet esimerkiksi taulukoiden kanssa, voit ajattelematta käyttää säännöllistä for-silmukkaa, joka näyttää suunnilleen tältä: for (var i=0; i< value.length; i++){} . Однако, лучше, всё-таки, смотреть на вещи шире.

Oletetaan, että meidän täytyy näyttää luettelo tuotteista ja tarvittaessa jakaa se luokkiin, suodattaa se, suorittaa haku, muokata tätä luetteloa tai sen osia. Ehkä sinun on suoritettava nopeasti joitain laskelmia, jotka sisältävät luettelon elementtejä. Oletetaan, että sinun täytyy lisätä jotain johonkin, kertoa jotain jollakin. Onko JavaScriptistä mahdollista löytää työkaluja, joiden avulla voit ratkaista tällaiset ongelmat nopeammin ja kätevämmin kuin käyttämällä tavallista for-silmukkaa?

Itse asiassa JavaScriptissä on tällaisia ​​toimintoja. Joitakin niistä käsitellään materiaalissa, jonka käännöksen esittelemme huomionne tänään. Erityisesti puhumme leviämisoperaattorista, for...of-silmukasta ja menetelmistä include(), some(), every(), filter(), map() ja vähennys(). Puhumme tässä enimmäkseen taulukoista, mutta tässä käsitellyt tekniikat sopivat yleensä muun tyyppisten objektien kanssa työskentelyyn.

On huomattava, että JS-kehityksen nykyaikaisten lähestymistapojen katsaukset sisältävät yleensä esimerkkejä, jotka on valmistettu nuolifunktioilla. Ehkä et käytä niitä kovin usein – ehkä siksi, että et pidä niistä, ehkä siksi, että et halua käyttää liikaa aikaa uuden oppimiseen, tai ehkä ne eivät vain ole sinulle sopivia. Siksi tässä useimmissa tilanteissa näytetään kaksi vaihtoehtoa samojen toimintojen suorittamiseksi: käyttämällä tavallisia toimintoja (ES5) ja käyttämällä nuolitoimintoja (ES6). Niille, jotka eivät ole aiemmin käyttäneet nuolifunktioita, nuolifunktiot eivät ole funktiomäärittelyjä ja funktiolausekkeita vastaavia. Sinun ei pitäisi korvata yhtä toisella. Tämä johtuu erityisesti siitä, että tavallisissa ja nuolitoiminnot avainsana tämä käyttäytyy eri tavalla.

1. Laajennusoperaattori

Hajautusoperaattorin avulla voit "laajentaa" taulukoita korvaamalla niiden elementit taulukoiden sijasta paikassa, jossa tätä operaattoria käytetään. Samanlaista lähestymistapaa on ehdotettu objektiliteraaaleille.

▍Laajennusoperaattorin vahvuudet

• Se on yksinkertainen ja nopea tapa"vetää ulos" sen yksittäiset elementit taulukosta.
• Tämä operaattori soveltuu taulukko- ja objektiliteraalien työskentelyyn.
• Tämä on nopea ja intuitiivinen tapa työskennellä funktion argumenttien kanssa.
• Laajennusoperaattori ei vie paljon tilaa koodissa - se näyttää kolmelta pisteeltä (...).

▍ Esimerkki

Oletetaan, että sinun tehtäväsi on luetella suosikkiherkkusi ilman silmukkaa. Laajennusoperaattorilla tämä tehdään seuraavasti:

2. Silmukka… of

For… of -lause on suunniteltu kulkemaan iteroitavissa olevien objektien läpi. Se antaa pääsyn tällaisten objektien yksittäisiin elementteihin (erityisesti taulukkoelementteihin), mikä mahdollistaa esimerkiksi niiden muokkaamisen. Sitä voidaan pitää tavallisen korvaajana silmukalle.

▍For…of-silmukan vahvuudet

• Tämä on helppo tapa lisätä tai päivittää kokoelman kohteita.
• For...of-silmukan avulla voit suorittaa erilaisia ​​laskutoimituksia elementtien avulla (summaus, kertolasku ja niin edelleen).
• Se on kätevä käyttää, kun sinun on tarkistettava olosuhteet.
• Sen käyttö johtaa puhtaamman ja luettavamman koodin kirjoittamiseen.

▍ Esimerkki

Oletetaan, että sinulla on tietorakenne, joka kuvaa työkalupakin sisältöä, ja haluat näyttää kyseiset työkalut. Näin teet sen käyttämällä for...of-silmukkaa:

3. include()-menetelmä

include()-menetelmällä tarkistetaan, onko kokoelmassa tietty elementti, erityisesti esim. tietty rivi merkkijonoja sisältävässä taulukossa. Tämä menetelmä palauttaa tosi tai epätosi testin tuloksista riippuen. Sitä käytettäessä kannattaa huomioida, että se on isot ja pienet kirjaimet huomioitava. Jos kokoelmassa on esimerkiksi merkkijonoelementti SCHOOL ja merkkijonokoulun läsnäolo tarkistetaan komennolla include(), menetelmä palauttaa false.

▍Includes()-menetelmän vahvuudet

• include()-menetelmä on hyödyllinen luotaessa yksinkertaisia ​​tiedonhakumekanismeja.
• Se antaa kehittäjälle intuitiivisen selkeä tapa määritetään tiettyjen tietojen läsnäolo taulukossa.
• Se on kätevä käyttää ehdollisia lausekkeita muokata, suodattaa elementtejä ja suorittaa muita toimintoja.
• Sen käyttö parantaa koodin luettavuutta.

▍ Esimerkki

Oletetaan, että sinulla on autotalli, jota edustaa joukko autoja, etkä tiedä, onko tietty auto tässä autotallissa vai ei. Tämän ongelman ratkaisemiseksi sinun on kirjoitettava koodi, jonka avulla voit tarkistaa, onko auto tallissa. Käytetään include()-menetelmää:

4. jokin()-menetelmä

Some()-menetelmän avulla voit tarkistaa, onko joitain etsimiäsi elementtejä taulukossa. Tarkistuksen tulosten perusteella se palauttaa tosi tai epätosi . Se on samanlainen kuin yllä oleva sisältää menetelmän() , paitsi että sen argumentti on pikemminkin funktio kuin esimerkiksi säännöllinen merkkijono.

▍ Some()-menetelmän vahvuudet

• Some()-menetelmän avulla voimme tarkistaa, sisältääkö taulukko vähintään yhden meitä kiinnostavista elementeistä.
• Se suorittaa kuntotestin sille välitetyn toiminnon avulla.
• Tämä menetelmä on kätevä käyttää.

▍ Esimerkki

Oletetaan, että olet seuran omistaja, etkä yleensäkään ole kiinnostunut siitä, kuka tarkalleen ottaen tulee klubisi. Jotkut vierailijat eivät kuitenkaan pääse sisään klubiin, koska he ovat alttiita alkoholijuomien liialliselle kulutukselle. vähintään, jos he löytävät itsensä laitoksestasi yksin, eikä heidän kanssaan ole ketään, joka voisi huolehtia heistä. SISÄÄN tässä tapauksessa vierailijaryhmä pääsee klubiin vain, jos vähintään yksi heistä on vähintään 18-vuotias. Tämän tyyppisen tarkistuksen automatisoimiseksi käytämme some()-menetelmää. Alla sen sovellus on esitetty kahdessa versiossa.

ES5

ES6

5. Every()-metodi

Every()-menetelmä toistuu taulukon läpi ja testaa jokaisen elementin tiettyä ehtoa vasten. Palauttaa tosi, jos kaikki taulukon elementit vastaavat ehtoa, ja false muussa tapauksessa. Voit nähdä, että se on samanlainen kuin some()-menetelmä.

▍ Every()-menetelmän vahvuudet

• Every()-metodin avulla voit tarkistaa, täyttävätkö kaikki taulukon elementit ehdon.
• Ehdot voidaan asettaa funktioiden avulla.
• Se edistää deklaratiivista lähestymistapaa ohjelmointiin.

▍ Esimerkki

Palataanpa edelliseen esimerkkiin. Siellä päästit alle 18-vuotiaat vierailijat klubiin, mutta joku kirjoitti poliisille lausunnon, jonka jälkeen jouduit epämiellyttävään tilanteeseen. Kun kaikki oli selvitetty, päätit, että et tarvitse kaikkea tätä, ja tiukensit klubin vierailun sääntöjä. Nyt vierailijaryhmä pääsee kerhoon vain, jos jokainen ryhmän jäsen on vähintään 18-vuotias. Kuten viime kerralla, harkitsemme ongelman ratkaisemista kahdessa versiossa, mutta tällä kertaa käytämme every()-menetelmää.

ES5

ES6

6. filter()-menetelmä

Filter()-menetelmällä voit luoda taulukon perusteella uusi joukko, joka sisältää vain ne lähdetaulukon elementit, jotka täyttävät tietyn ehdon.

▍ Filter()-menetelmän vahvuudet

• Filter()-menetelmä välttää alkuperäisen taulukon muuttamisen.
• Sen avulla voit päästä eroon tarpeettomista elementeistä.
• Se parantaa koodin luettavuutta.

▍ Esimerkki

Oletetaan, että sinun on valittava hintaluettelosta vain ne, jotka ovat suurempia tai yhtä suuria kuin 30. Ratkaisemme tämän ongelman käyttämällä filter()-menetelmää.

ES5

ES6

7. Map()-menetelmä

Map()-menetelmä on samanlainen kuin filter()-menetelmä, koska se palauttaa myös uuden taulukon. Sitä käytetään kuitenkin alkuperäisen taulukon elementtien muokkaamiseen.

▍Map()-menetelmän vahvuudet

• Map()-menetelmä välttää tarpeen muuttaa alkuperäisen taulukon elementtejä.
• Sitä voidaan käyttää kätevästi taulukon elementtien muokkaamiseen.
• Se parantaa koodin luettavuutta.

▍ Esimerkki

Oletetaan, että sinulla on luettelo tuotteista ja hinnat. Esimiehenne tarvitsee uusi lista tavaroita, joiden hintoja on alennettu 25 %. Ratkaisemme tämän ongelman käyttämällä map()-menetelmää.

ES5

ES6

8. vähentää()-menetelmä

Reduction()-menetelmän avulla voit yksinkertaisimmassa muodossaan summata numeeristen taulukoiden elementit. Toisin sanoen se pienentää taulukon yhdeksi arvoksi. Näin voit käyttää sitä erilaisten laskelmien suorittamiseen.

▍Reducents()-menetelmän vahvuudet

• Reduction()-menetelmällä voit laskea taulukon elementtien summan tai keskiarvon.
• Tämä menetelmä nopeuttaa ja yksinkertaistaa laskelmia.

▍ Esimerkki

Oletetaan, että sinun on laskettava viikon kulut, jotka on tallennettu taulukkoon. Ratkaistaan ​​tämä ongelma vähentämismenetelmällä().

ES5

ES6

Lisää tageja

Taulukot ovat yksi yleisimmin käytetyistä muuttujatyypeistä, joiden avulla voit tallentaa useita muuttujia peräkkäisiä arvoja Yhdessä paikassa". JavaScriptin suhteen on kuitenkin parantamisen varaa.

Tässä artikkelissa tarkastellaan kolmea vähän tunnettua tekniikkaa, joita voidaan käyttää taulukoiden kanssa työskennellessä.

1. Lisäys mukautettuja ominaisuuksia taulukoihin

Jos käytät hakua löytääksesi taulukon JavaScript-määritelmän, useimmat lähteet ilmoittavat sen tämä tyyppi Muuttujan arvo esitetään objektina.

Yleisesti ottaen monet asiat, joita kohtaamme JavaScriptissä, ovat objekteja. Olisi kohtuullista huomata, että kieli sisältää myös "primitiivisiä" tietotyyppejä, mutta niiden arvoja käytetään jotenkin objektien sisällä olevissa ominaisuuksissa.

2. Matriisielementtien käyttäminen silmukassa

Koska taulukkoindeksit voivat saada vain positiivisia arvoja, laskenta alkaa nollasta. Voimme myöhemmin käyttää tätä indeksiä päästäksemme taulukon elementtiin tietyssä silmukan iteraatiossa.

ECMAScript6 esitteli tavan selata taulukkoa ilman indeksejä, vaan uuden for…of-silmukan kautta.

For...of-silmukka on suunniteltu iteroimaan taulukon elementtien läpi vaikuttamatta elementin indeksiin.

Var ary = ["oranssi", "omena", "litsi"]; for (let item of ary)( console.log(item); ) // "oranssi", "omena", "litsi" Vertailun vuoksi: tuoteindeksien tulostaminen for-silmukassa. var ary = ["oranssi","omena","litsi"]; for (var item = 0; item< ary.length; item++){ console.log(item); } // 0, 1, 2

3. Elementtien lukumäärä ei ole taulukon koko

Kun puhumme taulukon koosta, ajattelemme sitä yleensä siihen tallennettujen elementtien lukumääränä. Itse asiassa tämä ei ole täysin totta - pituusominaisuus lasketaan elementin enimmäisindeksin mukaan.

Pituusominaisuus on hyvin epäselvä. Tarkistaaksesi tämän, katso vain seuraavat manipulaatiot:

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6

Viimeisessä esimerkissä riitti, että elementti asetettiin viidenneksi, minkä seurauksena taulukon pituudeksi tuli 6. Jos luulet, että indeksit 0-4 luodaan automaattisesti, olet väärässä. Tämä voidaan tarkistaa käyttämällä in-operaattoria.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 console.log(0 in ary); // väärä

Tässä tapauksessa olisi reilua kutsua ary-taulukkoa "harvaksi".

Voimme myös muokata pituus-ominaisuutta taulukoiden leikkaamiseksi. Alla oleva esimerkki osoittaa elementin "menettämisen" indeksissä 5 vähentämällä aaritaulukon pituusominaisuutta.

Var ary = ; ary.length = 3; console.log(ary.length); // 3 ary = "abcd"; console.log(ary.length); // 6 ary.length = 2; console.log(ary.length); // 2 console.log(ary); // määrittelemätön

Taulukot

Array on järjestetty arvokokoelma. Taulukon arvoja kutsutaan elementeiksi, ja jokaiselle elementille on ominaista numeerinen sijainti taulukossa, jota kutsutaan indeksiksi. JavaScriptin taulukot ovat kirjoittamattomia: taulukkoelementit voivat olla mitä tahansa tyyppiä ja erilaisia ​​elementtejä sama taulukko voi olla eri tyyppejä. Matriisielementit voivat olla jopa objekteja tai muita taulukoita, joiden avulla voit luoda monimutkaiset rakenteet tiedot, kuten objektitaulukot ja taulukoiden taulukot.

JavaScript-taulukkoindeksit alkavat nollasta ja käyttävät 32-bittisiä kokonaislukuja - taulukon ensimmäisellä elementillä on indeksi 0. JavaScript-taulukot ovat dynaamisia: ne voivat kasvaa ja pienentyä tarpeen mukaan; kiinteitä taulukoiden kokoja ei tarvitse ilmoittaa niitä luotaessa tai varata muistia uudelleen niiden koon muuttuessa.

JavaScriptin taulukot ovat objektien erikoismuoto, ja taulukkoindeksit tarkoittavat vähän muuta kuin vain ominaisuuksien nimiä, jotka sattumalta ovat kokonaislukuja.

Arrayiden luominen

Helpoin tapa luoda taulukko on käyttää literaalia, joka on yksinkertainen pilkuilla eroteltu luettelo taulukon elementeistä, joka on ympäröity hakasulkeilla. Arvojen ei tarvitse olla vakioita - ne voivat olla mitä tahansa lausekkeita, mukaan lukien objektiliteraalit:

Muutt tyhjä = ; // Tyhjä array var numbers = ; // Taulukko viidellä numeerisella elementillä var misc = [ 1.1, true, "a", ]; // 3 erityyppistä elementtiä + loppupilkku var base = 1024; var table = ; // Joukko muuttujilla var arrObj = [, ]; // 2 taulukkoa, jotka sisältävät objekteja

Array literal -syntaksin avulla voit lisätä valinnaisen loppupilkun, ts. literaali [,] vastaa taulukkoa, jossa on kaksi elementtiä, ei kolme.

Toinen tapa luoda taulukko on kutsua rakentaja Array(). Voit soittaa rakentajalle kolmella eri tavalla:

Kutsu rakentaja ilman argumentteja:

Var arr = new Array();

Tässä tapauksessa luodaan tyhjä taulukko, joka vastaa literaalia.

Kutsu konstruktori yhdellä numeerisella argumentilla, joka määrittää taulukon pituuden:

Muutt arr = uusi Array(10);

Tässä tapauksessa luodaan määritetyn pituinen tyhjä taulukko. Tätä Array()-konstruktorin kutsun muotoa voidaan käyttää muistin ennakkovaraamiseen taulukolle, jos sen elementtien määrä on tiedossa etukäteen. Huomaa, että tämä ei tallenna arvoja taulukkoon.

Määritä nimenomaan kahden tai useamman ensimmäisen matriisin elementin tai yhden ei-numeerisen elementin arvot rakentajakutsussa:

Muutt arr = new Array(5, 4, 3, 2, 1, "testi");

Tässä tapauksessa rakentajan argumenteista tulee uuden taulukon elementtien arvot. Array-literaalien käyttäminen on lähes aina helpompaa kuin Array()-konstruktorin käyttäminen.

Matriisielementtien lukeminen ja kirjoittaminen

Matriisielementteihin päästään operaattorilla. Hakasulkeiden vasemmalla puolella on oltava taulukkoviittaus. Suluissa on oltava mielivaltainen lauseke, joka palauttaa ei-negatiivisen kokonaisluvun. Tämä syntaksi on hyödyllinen sekä taulukkoelementin arvon lukemiseen että kirjoittamiseen. Siksi kaikki seuraavat JavaScript-ohjeet ovat voimassa:

// Luo taulukko yhdellä elementillä var arr = ["maailma"]; // Lue elementti 0 var arvo = arr; // Kirjoita arvo elementille 1 arr = 3.14; // Kirjoita elementin 2 arvo i = 2; arr[i] = 3; // Kirjoita arvo elementille 3 arr = "hello"; // Lue elementit 0 ja 2, kirjoita arvo elementtiin 3 arr] = arr;

Haluan muistuttaa, että taulukot ovat erikoistunut objektityyppi. Hakasulkeet, joita käytetään pääsyyn taulukon elementteihin, toimivat täsmälleen samalla tavalla kuin hakasulkeet, jota käytetään objektin ominaisuuksien käyttämiseen. JavaScript-tulkki muuntaa suluissa olevat numeeriset indeksit merkkijonoiksi – indeksi 1 muuttuu merkkijonoksi "1" - ja käyttää sitten merkkijonoja ominaisuuksien niminä.

Muunnuksessa numeeriset indeksit merkkijonoissa ei ole mitään erityistä: sama voidaan tehdä tavallisilla esineillä:

Var obj = (); // Luo yksinkertainen objekti obj = "yksi"; // Indeksoi se kokonaisluvuilla

Taulukoissa on se, että kun käytät ominaisuuksien nimiä, jotka ovat ei-negatiivisia kokonaislukuja, taulukot määrittävät automaattisesti ominaisuuden arvon. pituus. Esimerkiksi yllä loimme taulukon arr, jossa on yksi elementti. Sen jälkeen se antoi arvot elementeilleen indekseissä 1, 2 ja 3. Näiden toimintojen seurauksena taulukon pituusominaisuuden arvo muuttui arvoon 4.

Sinun tulee erottaa taulukon indeksit selvästi objektien ominaisuuksien nimistä. Kaikki indeksit ovat ominaisuuksien nimiä, mutta vain ominaisuudet, joiden nimet edustavat kokonaislukuja, ovat indeksejä. Kaikki taulukot ovat objekteja, ja voit lisätä niihin ominaisuuksia millä tahansa nimellä. Jos kuitenkin kosketat ominaisuuksia, jotka ovat taulukon indeksejä, taulukot vastaavat päivittämällä pituusominaisuuden arvon tarvittaessa.

Huomaa, että negatiivisia ja ei-kokonaislukuja voidaan käyttää taulukkoindeksinä. Tässä tapauksessa luvut muunnetaan merkkijonoiksi, joita käytetään ominaisuuksien niminä.

Array-elementtien lisääminen ja poistaminen

Olemme jo nähneet, että helpoin tapa lisätä elementtejä taulukkoon on antaa arvoja uusille indekseille. Voit myös käyttää menetelmää yhden tai useamman elementin lisäämiseen taulukon loppuun. työntää():

Var arr = ; // Luo tyhjä taulukko arr.push("zero"); // Lisää arvo loppuun arr.push("one",2); // Lisää kaksi arvoa lisää

Voit myös lisätä elementin taulukon loppuun antamalla arvon arr-elementille. Jos haluat lisätä elementin taulukon alkuun, voit käyttää menetelmää unshift(), joka siirtää taulukon olemassa olevat elementit paikkoihin, joilla on korkeammat indeksit.

Voit poistaa taulukon elementtejä käyttämällä delete-operaattoria, esim normaaleja ominaisuuksia esineet:

Var arr = ; poista arr; 2 in arr; // false, taulukon indeksiä 2 ei ole määritelty arr.length; // 3: delete-operaattori ei muuta taulukon pituusominaisuutta

Elementin poistaminen on samanlaista (mutta hieman erilaista) kuin määrittämättömän arvon määrittäminen kyseiselle elementille. Huomaa, että poisto-operaattorin käyttäminen taulukkoelementtiin ei muuta pituus-ominaisuuden arvoa tai siirrä alaspäin elementtejä, joilla on korkeammat indeksit, täyttämään elementin poistamisen jälkeen jääneen tyhjiön.

On myös mahdollista poistaa elementtejä taulukon lopusta antamalla pituusominaisuuteen yksinkertaisesti uusi arvo. Tauluilla on menetelmä pop()(vastakohta push()-menetelmälle), joka pienentää taulukon pituutta yhdellä ja palauttaa poistetun elementin arvon. On myös menetelmä siirtää()(unshift()) vastakohta, joka poistaa elementin taulukon alusta. Toisin kuin delete-operaattori, shift()-menetelmä siirtää kaikki elementit alaspäin niiden nykyisen indeksin alapuolelle.

Lopuksi on monikäyttöinen menetelmä liitos(), jonka avulla voit lisätä, poistaa ja korvata taulukon elementtejä. Se muuttaa pituus-ominaisuuden arvoa ja siirtää taulukon elementtejä pienempiin tai korkeampiin indekseihin tarpeen mukaan. Tarkastelemme kaikkia näitä menetelmiä hieman myöhemmin.

Moniulotteiset taulukot

JavaScript ei tue "todellisia" moniulotteisia taulukoita, mutta se tarjoaa hyvän tavan simuloida niitä käyttämällä taulukoita. Jos haluat käyttää tietoelementtiä taulukoissa, käytä operaattoria kahdesti.

Oletetaan esimerkiksi, että muuttujamatriisi on joukko lukuja. Jokainen matriisin [x] elementti on joukko lukuja. Voit käyttää tiettyä numeroa taulukossa käyttämällä lausekematriisia[x][y]. Alla on konkreettinen esimerkki, jossa kaksiulotteista taulukkoa käytetään kertotaulukkona:

// Luo moniulotteinen taulukko var table = new Array(10); // Taulukossa on 10 riviä for(var i = 0; i

Array-luokan menetelmät

ECMAScript 3 -standardi määrittelee Array.prototypen joukoksi käteviä toimintoja taulukoiden kanssa työskentelemiseen, jotka ovat käytettävissä minkä tahansa taulukon menetelminä. Nämä menetelmät esitellään seuraavissa alaosissa.

join() -menetelmä

Array.join()-menetelmä muuntaa kaikki taulukon elementit merkkijonoiksi, yhdistää ne ja palauttaa tuloksena olevan merkkijonon. Valinnaisena argumenttina voit välittää menetelmälle merkkijonon, jota käytetään tulosmerkkijonon elementtien erottamiseen. Jos erotinmerkkijonoa ei ole määritetty, käytetään pilkkua. Esimerkiksi seuraava fragmentti johtaa merkkijonoon "1,2,3":

Var arr = ; arr.join(); // "1,2,3" arr.join("-"); // "1-2-3"

käänteinen()-menetelmä

Array.reverse()-menetelmä kääntää taulukon elementtien järjestyksen ja palauttaa uudelleen järjestetyn taulukon. Permutaatio suoritetaan suoraan alkuperäisessä taulukossa, ts. Tämä menetelmä ei luo uutta taulukkoa uudelleenjärjestetyillä elementeillä, vaan pikemminkin järjestää ne uudelleen jo olemassa olevaan taulukkoon. Esimerkiksi seuraava katkelma, joka käyttää reverse()- ja join()-menetelmiä, johtaa merkkijonoon "3,2,1":

Var arr = ; arr.reverse().join(); // "3,2,1"

sort()-menetelmä

Array.sort()-menetelmä lajittelee lähdetaulukon elementit ja palauttaa lajitellun taulukon. Jos sort()-menetelmää kutsutaan ilman argumentteja, lajittelu tapahtuu aakkosjärjestyksessä (elementit muunnetaan tilapäisesti merkkijonoiksi vertailua varten). Määrittämättömät elementit siirretään taulukon loppuun.

Jos haluat lajitella muuhun kuin aakkosjärjestykseen, voit välittää vertailufunktion argumenttina sort()-metodille. Tämä funktio määrittää, kumman sen kahdesta argumentista tulee olla ensin lajiteltussa luettelossa. Jos ensimmäisen argumentin on tultava ennen toista, vertailufunktion on palautettava negatiivinen luku. Jos ensimmäisen argumentin on määrä seurata toista lajitetussa taulukossa, funktion on palautettava numero, joka on suurempi kuin nolla. Ja jos kaksi arvoa ovat samanarvoisia (eli niiden järjestys ei ole tärkeä), vertailufunktion pitäisi palauttaa 0:

Var arr = ; arr.sort(); // aakkosjärjestys: 1111, 222, 33, 4 arr.sort(function(a,b) ( // Numerojärjestys: 4, 33, 222, 1111 return a-b; // Palauttaa 0 // riippuen a:n ja b:n lajittelujärjestyksestä) ); // Lajittele vastakkaiseen suuntaan, suurimmasta pienimpään arr.sort(function(a,b) (paluu b-a));

Huomaa, kuinka kätevää on käyttää nimeämätöntä funktiota tässä katkelmassa. Vertailutoimintoa käytetään vain tässä, joten sille ei tarvitse antaa nimeä.

concat()-menetelmä

Array.concat()-menetelmä luo ja palauttaa uuden taulukon, joka sisältää sen alkuperäisen taulukon elementit, jossa concat() kutsuttiin, ja concat()-funktiolle välitettyjen argumenttien arvot. Jos jokin näistä argumenteista on itse taulukko, sen elementit lisätään palautettuun taulukkoon. On kuitenkin huomattava, että taulukoiden joukosta ei tapahdu rekursiivista muuntamista yksiulotteiseksi taulukoksi. Concat()-metodi ei muuta alkuperäistä taulukkoa. Alla on joitain esimerkkejä:

Var arr = ; arr.concat(4, 5); // Palautus arr.concat(); // Return arr.concat(,) // Return arr.concat(4, ]) // Return ]

slice() -menetelmä

Array.slice()-menetelmä palauttaa määritetyn taulukon osion tai alitaulukon. Kaksi metodiargumenttia määrittävät palautetun fragmentin alun ja lopun. Palautettu taulukko sisältää elementin, jonka numero on määritetty ensimmäisessä argumentissa, sekä kaikki seuraavat elementit aina (mutta ei sisällä) elementtiin, jonka numero on määritetty toisessa argumentissa.

Jos annetaan vain yksi argumentti, palautettu taulukko sisältää kaikki elementit taulukon aloituspaikasta loppuun. Jos jokin argumenteista on negatiivinen, se määrittää elementin numeron suhteessa taulukon loppuun. Joten argumentti -1 vastaa viimeinen elementti taulukko, ja argumentti -3 on taulukon kolmas elementti lopusta. Tässä muutamia esimerkkejä:

Var arr = ; arr.slice(0,3); // Return arr.slice(3); // Return arr.slice(1,-1); // Palauttaa arr.slice(-3,-2); // Paluu

splice() -menetelmä

Array.splice() -menetelmä on universaali menetelmä, joka lisää tai poistaa elementtejä taulukosta. Toisin kuin menetelmät slice() ja concat(), splice()-menetelmä muokkaa alkuperäistä taulukkoa, jossa sitä kutsuttiin. Huomaa, että splice()- ja slice()-menetelmillä on hyvin samanlaiset nimet, mutta ne suorittavat täysin erilaisia ​​toimintoja.

Splice()-menetelmä voi poistaa elementtejä taulukosta, lisätä uusia elementtejä tai tehdä molemmat samanaikaisesti. Taulukon elementtejä siirretään tarpeen mukaan jatkuvan sekvenssin luomiseksi lisäyksen tai poistamisen jälkeen.

Splice()-menetelmän ensimmäinen argumentti määrittää taulukon sijainnin, josta lisäys ja/tai poisto suoritetaan. Toinen argumentti määrittää niiden elementtien määrän, jotka tulee poistaa (leikata) taulukosta. Jos toinen argumentti jätetään pois, kaikki taulukon elementit määritetystä taulukon loppuun asti poistetaan. Splice()-menetelmä palauttaa poistettujen elementtien taulukon tai (jos yhtään elementtiä ei ole poistettu) tyhjän taulukon.

Splice()-menetelmän kaksi ensimmäistä argumenttia määrittävät poistettavat taulukkoelementit. Näitä argumentteja voi seurata mikä tahansa määrä lisäargumentteja, jotka määrittelevät taulukkoon lisättävät elementit, alkaen ensimmäisessä argumentissa määritetystä kohdasta.

Var arr = ; arr.splice(4); // Return , arr = arr.splice(1,2); // Return , arr = arr.splice(1,1); // Paluu ; arr = arr = ; arr.splice(2,0"a","b"); // Paluu ; arr =

push()- ja pop()-menetelmiä

Push()- ja pop()-menetelmien avulla voit työskennellä taulukoiden kanssa ikään kuin ne olisivat pinoja. Push()-menetelmä lisää yhden tai useamman uuden elementin taulukon loppuun ja palauttaa sen uuden pituuden. Pop()-menetelmä tekee sen käänteinen toiminta- poistaa taulukon viimeisen elementin, lyhentää taulukon pituutta ja palauttaa poistetun arvon. Huomaa, että molemmat menetelmät muokkaavat alkuperäistä taulukkoa sen sijaan, että luotaisiin siitä muokattu kopio.

unshift()- ja shift()-metodit

Menetelmät unshift() ja shift() toimivat lähes samalla tavalla kuin push() ja pop(), paitsi että ne lisäävät ja poistavat elementtejä taulukon alkuun eikä sen loppuun. Unshift()-menetelmä siirtää olemassa olevia elementtejä suurempiin indekseihin tilan vapauttamiseksi, lisää elementin tai elementit taulukon alkuun ja palauttaa taulukon uuden pituuden. Shift()-menetelmä poistaa ja palauttaa taulukon ensimmäisen elementin siirtämällä kaikki seuraavat elementit yhden aseman alaspäin ottamaan taulukon alussa vapautuneen tilan.

Mikä on joukko

Taulukko on tietotyyppi, joka tallentaa numeroituja arvoja. Jokaista numeroitua arvoa kutsutaan taulukon elementiksi, ja numeroa, johon elementti liittyy, kutsutaan sen indeksiksi. JavaScript-taulukot ovat tyypittämättömiä, mikä tarkoittaa, että taulukon elementti voi olla mitä tahansa tyyppiä ja saman taulukon eri elementeillä voi olla erilaisia ​​tyyppejä. Lisäksi JavaScript-taulukot ovat dynaamisia, mikä tarkoittaa, että voit ilmoittaa kiinteä koko ei ole tarpeen, ja voit lisätä uusia elementtejä milloin tahansa.

Arrayn luominen

Taulukko voidaan luoda kahdella tavalla, ensimmäinen on luoda taulukko käyttäen taulukkoliteraalia - hakasulkeet, jonka sisällä on luettelo pilkuilla erotetuista elementeistä.

Muutt tyhjä = ; //tyhjä array var numbers = ; //taulukko, jossa on 5 numeerista elementtiä var diff = ; //joukko, jossa on 3 elementtiä erilaisia ​​tyyppejä

Arvojen ei tarvitse olla yksinkertaisia ​​(numeroita tai merkkijonoja) - ne voivat olla myös mitä tahansa muita lausekkeita, esimerkiksi: objektiliteraaleja, muita taulukoita tai funktioita.

Var num = 700; var tab = , numero + 1];

Toinen tapa luoda taulukko on kutsua Array()-konstruktori. On kolme tapaa kutsua Array()-konstrutoria.

• Konstruktorin kutsuminen ilman argumentteja:

var b = new Array();

Tässä tapauksessa luodaan tyhjä taulukko, joka vastaa tyhjää literaalia.

• Rakentaja määrittää nimenomaisesti n taulukkoelementin arvot:

var b = new Array(1, 3, 5, 8, "merkkijono", tosi);

Tässä tapauksessa rakentaja saa listan argumenteista, joista tulee uuden taulukon elementtejä. Argumentit kirjoitetaan taulukkoon siinä järjestyksessä, jossa ne on määritetty.

• Varaa tilaa myöhempää arvojen määritystä varten. Tämä tehdään määrittämällä yksi luku suluissa määritettäessä taulukkoa:

var b = uusi Array(5);

Tämä menetelmä taulukon määrittämiseksi edellyttää, että taulukolle allokoidaan tietty määrä elementtejä (joiden jokaisen arvo on määrittelemätön) ja arvot määritetään sitten skriptin edetessä. Tätä muotoa käytetään yleensä taulukon esiallokoimiseen, jos sen pituus tiedetään etukäteen.

Lukeminen, kirjoittaminen ja taulukkoelementtien lisääminen

Matriisielementteihin päästään operaattorilla. JavaScriptin taulukkoelementit numeroidaan nollasta alkaen. Halutun taulukkoelementin saamiseksi sinun on ilmoitettava sen numero hakasulkeissa.

Muuttujien numerot = ; document.write(numerot + ", "); //taulukon ensimmäinen elementti document.write(numerot + ", "); //taulukon toinen elementti document.write(numerot + ", "); //taulukon kolmas elementti document.write(numbers); //taulukon neljäs elementti

Taulukon elementtejä voidaan muuttaa:

Muuttujien numerot = ; numerot = 10; //muutti taulukon ensimmäistä elementtiä -

Lisätä uusi elementti taulukko, anna vain uusi arvo:

Muuttujien numerot = ; numerot = 7; //tuli

Huomautus: sisään JavaScript-taulukot kuinka monta tahansa elementtiä voidaan tallentaa.

Taulukon pituus

Kaikilla taulukoilla, olivatpa ne luotuja Array()-konstruktorilla tai taulukkoliteraalilla, on erityinen pituusominaisuus, joka palauttaa taulukkoon tallennettujen elementtien kokonaismäärän. Koska taulukoissa voi olla määrittelemättömiä elementtejä (niitä, joiden arvo on määrittelemätön), tarkempi muotoilu on, että pituusominaisuus on aina yhtä suurempi kuin taulukkoelementin suurin indeksi (luku). Pituus-ominaisuus päivitetään automaattisesti ja pysyy oikeana, kun uusia elementtejä lisätään taulukkoon.

Muutt v = uusi Array(); // v.length == 0 (elementtiä ei ole määritelty) v = new Array(1,2,3); // v.length == 3 (elementit 0–2 määritelty) v = ; // v.length == 2 (elementit 0 ja 1 on määritelty) document.write(v.length);

Jos haluat saada taulukon viimeisen elementin, voit myös käyttää pituus-ominaisuutta:

Var v = ["JavaScript", "Ominaisuus", "Matriisit"]; document.write(v);

Viimeisen elementin indeksi on 1 pienempi kuin taulukon pituus, koska laskenta alkaa nollasta. Siksi, jos et tiedä tarkkaa elementtien lukumäärää, mutta sinun on viitattava taulukon viimeiseen elementtiin, käytä merkintää: v.length - 1.

Silmukka taulukon elementtien läpi

Yleisin pituus-ominaisuuden käyttö on taulukon elementtien silmukka:

Tässä esimerkissä oletetaan, että taulukon elementit ovat vierekkäisiä ja alkavat ensimmäisestä elementistä (indeksi 0). Jos näin ei ole, ennen kuin käytät taulukon jokaista elementtiä, sinun on tarkistettava, onko se määritetty:

Var hedelmät = ["omena", "banaani", "mansikka", "persikka"]; for(var i = 0; i

Silmukkaa voidaan käyttää myös taulukon elementtien alustamiseen:

Var bar = uusi Array(10); for(var i = 0; i

Matriisin katkaisu ja kasvattaminen

Kun työskentelet taulukoiden kanssa, pituusominaisuus päivittyy automaattisesti, joten meidän ei tarvitse huolehtia siitä itse. Mutta yksi mainitsemisen arvoinen asia on, että pituusominaisuus on käytettävissä paitsi lukemiseen myös kirjoittamiseen. Jos pituus-ominaisuuden arvo on pienempi kuin nykyinen, matriisi katkaistaan ​​uuteen (määritettyyn) pituuteen, kaikki elementit, jotka eivät kuulu uuteen indeksialueeseen, hylätään ja niiden arvot menetetään, vaikka pituus olisi palautetaan myöhemmin, arvoja ei palauteta.

Var foo = ; foo.length = 1; //lyhennä 1 elementtiin - foo.length = 4; //palauta edellinen elementtien lukumäärä document.write(foo); //ei aikaisempaa arvoa

Eniten yksinkertaisella tavalla taulukon tyhjennys on: foo.length = 0.

Jos pituus-ominaisuudesta tehdään suurempi kuin sen nykyinen arvo, taulukon loppuun lisätään uusia määrittelemättömiä elementtejä, mikä kasvattaa taulukon määritettyyn kokoon.

Array Elementtien poistaminen

Poista-operaattori kirjoittaa määrittämättömän arvon taulukon elementtiin, kun taas itse elementti on edelleen olemassa. Jos haluat poistaa elementtejä niin, että loput elementit siirretään vapaaseen tilaan, sinun on käytettävä jotakin ennalta määritetyistä taulukkomenetelmistä. Array.shift()-menetelmä poistaa taulukon ensimmäisen elementin, pop() poistaa taulukon viimeisen elementin, splice() poistaa yhden tai joukon elementtejä mistä tahansa taulukosta. Näiden menetelmien käyttöä kuvataan yksityiskohtaisesti seuraavassa luvussa.

Moniulotteiset taulukot

Muista, että JavaScript-taulukot voivat sisältää muita taulukoita elementteinä. Tätä ominaisuutta voidaan käyttää luomiseen moniulotteisia taulukoita. Jotta pääset käsiksi taulukoiden elementteihin, sinun tarvitsee käyttää hakasulkeita vain kahdesti.

Muuttumatriisi = [ , , ]; document.write(matriisi); //keskuselementti valittu

Katsotaanpa, mitä esimerkissä on kirjoitettu: matriisi on joukko numerotaulukoita. Mikä tahansa matriisin[n] elementti on lukujono. Tietyn taulukon numeron saamiseksi sinun on kirjoitettava matriisi[n][n], toiset hakasulkeet osoittavat sisäisen taulukon elementin indeksin.

//analogisesti edellisen merkinnän kanssa - luominen rakentajalla var table = new Array(3); for(var i = 0; i

Assosiatiiviset taulukot

Objekteja voidaan käyttää assosiatiivisina taulukoina. Hieman teoriaa - assosiatiiviset taulukot (kutsutaan myös hash-taulukoiksi) antavat sinun käyttää merkkijonoja indeksien sijasta. Assosiatiivisten taulukoiden käyttäminen on hyvin samanlaista kuin tavallisen objektin ominaisuuden nimen käyttäminen, mutta tässä tapauksessa työskenneltäessä taulukkomuodossa. Koska JavaScriptillä ei ole menetelmiä assosiatiivisten taulukoiden kanssa työskentelyyn, niitä käytetään paljon harvemmin kuin tavallisia, vaikka niistä voi yhtä hyvin olla hyötyä tiedon tallentamisessa ja pääsyn vaativien elementtien muistamisen helpottamiseen.

Muutt s_list = new Object(); s_list["rasva"] = "Rasva"; s_list["small"] = "Pieni"; s_list["nimi"] = "Homer"; for (var x in s_list) //näytä kaikki elementit document.write(s_list[x] + "
");

Tässä artikkelissa tarkastellaan JavaScript-taulukkoa ja sen komponentteja. JavaScript on ihanteellinen ohjelmointiin. Itse asiassa se toteuttaa ECMAScript-kielen (ECMA-262-standardi).

Missä JavaScriptiä käytetään? Sitä käytetään upotettuna kielenä määrittelyyn ohjelmistopolku hakemuksen aiheeseen. Se löytyy selaimista, joissa sitä käytetään komentosarjakielenä, joka tekee verkkosivuista interaktiivisia.

Tämän tuotteen tärkeimmät arkkitehtoniset ominaisuudet ovat dynaaminen ja heikko kirjoitus, automaattinen muistinhallinta, täydellinen ohjelmointi ja ensiluokkaiset objektitoiminnot.

Yleensä JavaScript vaikutti eri syistä, koska kehitystyön aikana haluttiin luoda Javaa muistuttava kieli, mutta ohjelmoijien helppokäyttöinen. Muuten, JavaScript-kieltä ei omista mikään yritys tai organisaatio, mikä tekee siitä toisin kuin monet verkkokehittäjien käyttämät ohjelmointityylit.

On huomattava, että JavaScript on rekisteröity tavaramerkki koskee Oracle Corporationia.

Mikä on array?

Taulukko on sellainen, joka tallentaa numeroituja arvoja. Jokaista tällaista arvoa kutsutaan taulukkokomponentiksi ja numeroa, johon komponentti liittyy, kutsutaan indeksiksi. JavaScript-taulukko on kirjoittamaton. Tämä tarkoittaa, että taulukon osat voivat olla mitä tahansa tyyppiä ja samaan taulukkoon kuuluvilla eri osilla on täysin erilaisia ​​tyyppejä.

Lisäksi JavaScript-taulukko on dynaaminen, mikä tarkoittaa, että kiinteää kokoa ei tarvitse ilmoittaa. Loppujen lopuksi voit lisätä uusia tietoja milloin tahansa.

Array tuotanto

Käyttämällä JavaScript-kieli, taulukon luominen ei ole ollenkaan vaikeaa. Tätä varten on kaksi tapaa. Ensimmäinen sisältää taulukon luomisen kirjaimella - hakasulkeilla, jonka sisällä on luettelo osista pilkuilla erotettuna.

• var tyhjä = ; //tyhjä array;
• var numerot = ; //taulukko viidellä digitaalisella komponentilla;
• var diff = ; //taulukko, jossa on kolme erityyppistä elementtiä.

Tyypillisesti arvojen ei tarvitse olla yksinkertaisia ​​(merkkijonoja ja numeroita). Se voi olla myös mitä tahansa muita lausekkeita, esimerkiksi aiheliteraaleja, muita toimintoja ja taulukoita.

Toinen tapa luoda taulukko on kutsua Array()-suunnittelija. Voit kutsua hänet kolmella tavalla:

• Suunnittelijan kutsuminen ilman argumentteja: var b - new Array(). Täällä on mahdollista luoda tyhjä joukko, vastaa tyhjää literaalia.
• Konstruktori määrittää nimenomaisesti taulukon n komponentin arvon: var b = new Array (1, 3, 5, 8, "merkkijono", tosi). Tässä tapauksessa suunnittelijalle esitetään luettelo argumenteista, jotka muutetaan uuden taulukon komponenteiksi. Argumentit kirjoitetaan taulukkoon siinä paikassa, jossa ne on määritetty.
• Alueen määrittäminen myöhempää arvojen määritystä varten. Tämä tehdään määrittämällä taulukkoa tunnistettaessa yksi luku suluissa: var b = new Array(5). Tämä menetelmä tunnistus sisältää tarvittavan määrän komponentteja allokoinnin taulukkoon (joista jokainen on listattu määrittelemättömäksi) ja mahdollisuus antaa arvoja myöhemmin esitysprosessin aikana. Tätä lomaketta käytetään yleensä esiallokoimaan Javascript-taulukko, jonka pituus tiedetään etukäteen.

Kirjoittaminen, lukeminen ja taulukon yksityiskohtien lisääminen

Voit käyttää taulukon komponentteja käyttämällä operaattoria. Muuten, kaikki JavaScriptin komponentit nollasta alkaen on numeroitu. Tarvittavan elementin saamiseksi sen numero ilmoitetaan kohdassa Yksityiskohtia voidaan yleensä muuttaa. Ja jotta voit lisätä JavaScriptin taulukkoon, sinun tarvitsee vain määrittää uusi arvo.

On huomattava, että JavaScript-taulukot voivat tallentaa minkä tahansa määrän kaikenlaisia ​​elementtejä.

Taulukon pituus

Tiedämme siis, että taulukon pituus on yleensä mielenkiintoinen ilmiö. Katsotaanpa sitä tarkemmin. Kaikilla taulukoilla, olipa ne muodostettu Array()-suunnittelijalla tai paljastettu taulukkoliteraalilla, on tietty pituusominaisuus, joka ilmaisee tallennettujen elementtien kokonaismäärän. Koska matriisi voi sisältää määrittelemättömiä osia (merkitty undefined), tarkempi lauseke on: pituuden laatu on aina yhtä suurempi kuin suurin. iso huone taulukkokomponentin (indeksi). Pituuden laatu säädetään automaattisesti, pysyen tarkana, kun uusia osia ilmestyy joukkoon.

Voit käyttää pituus-ominaisuutta saadaksesi taulukon viimeisen komponentin näkyviin.

Viimeisen osan indeksi on yhden pienempi kuin taulukon koko. Loppujen lopuksi lähtölaskenta alkaa aina tyhjästä. Voi tätä JavaScriptiä! Taulukon pituus riippuu elementtien tarkasta määrästä. Joten jos et tiedä kuinka monta niitä pitäisi olla, mutta sinun on päästävä taulukon viimeiseen elementtiin, sinun on käytettävä merkintää: v.length - 1.

Iterointi taulukon yksityiskohtien yli

Hyvin usein pituus-ominaisuutta käytetään iteroimaan taulukon yksityiskohtia silmukassa:

• var hedelmät = ["mansikka", "persikka", "omena", "banaani"];
• for(var I = 0; i< fruits.lenght; i++);
• document.write(hedelmät[i] + "...").

Tässä esimerkissä komponentit näyttävät olevan jatkuvasti sijoitettuina ja alkavat ensimmäisestä osasta, jonka indeksi on nolla. Jos näin ei ole, sinun on ennen kunkin taulukon elementin kutsumista tarkistettava, onko se määritetty.

Silmukkaa käytetään joskus myös komponenttien alustamiseen.

Kasvata ja leikkaa ryhmää

Ihmettelen kuinka kieltä käytetään JavaScript-merkkijono lisätä joukkoon? Kun työskentelemme taulukoiden kanssa, laatupituus paranee automaattisesti, minkä vuoksi meidän on huolehdittava siitä itse. On tarpeen muistaa yksi yksityiskohta - pituusominaisuus ei ole vain luettavissa, vaan myös kirjoitettava. Jos pituuslaadulle on määritetty arvo, joka on kooltaan pienempi kuin nykyinen, taulukko pienennetään määritettyyn kokoon. Kaikki komponentit, jotka eivät ole uudella indeksialueella, hylätään ja niiden arvot menetetään, vaikka pituus palautettaisiin myöhemmin - arvoja ei palauteta.

On melko helppoa tyhjentää taulukko seuraavasti: foo.length = 0.

Jos pituuslaadusta tehdään nykyistä arvoa suurempi, taulukon loppuun ilmestyy uusia tunnistamattomia osia, mikä kasvattaa sen haluttuun kokoon.

Kuvioosien poistaminen

Poista-operaattori määrittää määrittelemättömän arvon taulukkokomponentissa, mutta se on edelleen olemassa. Jos sinun on poistettava JavaScript-taulukon elementti, jotta loput osat siirretään vapaaseen tilaan, sinun on käytettävä jotakin tarjotuista taulukkomenetelmistä. Array.shift() eliminoi ensimmäisen komponentin, pop() eliminoi viimeisen komponentin ja splice() poistaa yhden tai joukon komponentteja missä tahansa taulukossa.

Moniulotteiset taulukot

Näyttää siltä, ​​​​että olemme hieman järjestäneet asioita Kaksiulotteiset taulukot- Sitä on syytä harkita seuraavaksi. Muistatko, että JavaScript-taulukot voivat sisältää muita elementtejä komponentteina? Tätä ominaisuutta käytetään moniulotteisten taulukoiden tuottamiseen. Voit vierailla taulukoiden osissa käyttämällä hakasulkeita kahdesti.

Assosiatiiviset taulukot

Nyt tutkitaan kuinka hyödyke JavaScript-merkki käyttää assosiatiivisia taulukoita. Tätä varten meidän on tutkittava teoriaa: assosiatiivisia taulukoita kutsutaan joskus hash-taulukoiksi. Niiden ansiosta merkkijonoja käytetään indeksien sijasta. Tällaisten konstruktien käyttäminen on samanlaista kuin yksinkertaisen objektin ominaisuuden nimen käyttäminen, mutta in tämä vaihtoehto kun suoritat työtä taulukkomuodossa. Koska JavaScriptiltä puuttuu tapoja toimia assosiatiivisten taulukoiden kanssa, niitä käytetään paljon harvemmin kuin tavallisia. On syytä huomata, että ne voivat silti olla hyödyllisiä tietojen tallentamisessa ja helpottaa käsiksi tarvittavien yksityiskohtien muistamista.

Array-tulostus

Mitä nyt opiskellaan? JavaScript-järjestelmä? Matriisin näyttäminen valintaikkunassa (näytöllä) sekä taulukon komponenttien arvojen näyttäminen.

Jos haluat näyttää ohjelman kaikkien komponenttien arvot, on kätevää käyttää for-lausetta. Mielenkiintoista on, että for rule -laskurimuuttujaa käytetään taulukkokomponentin indeksinä.

Puhdistus

JavaScript-taulukon suodattamiseksi sinun on nollattava sen pituus:

• var myArray = ;
• myArray.length = 0.

• clear: function() (;
• this.length = 0;
• palauta tämä;

Komponenttien lisääminen ja poistaminen

No, jatketaan tämän mielenkiintoisen JavaScript-kielen tutkimista. Taulukkoelementti voidaan poistaa tai lisätä samalla tavalla kuin muiden objektien tavalliset ominaisuudet. Mutta on joitain eroja: numeeristen ominaisuuksien lisääminen voi muuttaa pituuden laatua ja pituusominaisuuden muokkaaminen voi poistaa numeerisia ominaisuuksia. Periaatteessa algoritmi taulukoiden ominaisuuksien asettamiseen on seuraava:

• Kun lisätään tuntematon digitaalinen ominaisuus i, jos pituus on yhtä suuri tai pienempi kuin i, pituudeksi määritetään i+1.
• Kun muutat laatupituutta, seuraavat toimet: jos määritetty arvo on pienempi kuin nolla, annetaan RangeError. Kaikki numeeriset ominaisuudet ja indeksit, jotka ovat yhtä suuret kuin uusi pituus ja jotka ovat suurempia, eliminoidaan.

Yleisesti ottaen JavaScript-taulukon elementin poistaminen ei ole vaikeaa. Loppujen lopuksi, jopa pituutta asetettaessa, sinun on poistettava siitä "ylimääräiset" komponentit. Tämä johtaa mahdollisuuteen tyhjentää taulukko. Jos tyhjän uuden taulukon annettu muuttuja jostain syystä ei ole tyydyttävä ja nykyinen on tarpeen nollata, riittää, että sen pituuslaadulle annetaan arvo nolla.

unshift, shift, pop ja push menetelmät

Vaikka taulukon komponentteja muokataan manuaalisesti, monet ihmiset suosittelevat sisäänrakennettujen menetelmien käyttöä tähän. Tämä vivahde takaa oikea arvo laatupituus ja aukkojen puuttuminen taulukossa. Muuten, oikean pituuden laatu vastaa komponenttien määrää.

Push-menetelmä siirtää välitetyt osat taulukon loppuun. Pop-menetelmä palauttaa perässä olevan komponentin ja poistaa sen.

Yleensä sisään Internet Explorer aikaisempi kuin kahdeksas versio, unshift voi palauttaa muissa selaimissa uuden pituusarvon. Joten on parempi olla luottamatta vaihdon palautuksesta saatuun arvoon.

Osien lisääminen ja poistaminen taulukon keskellä

Jos minun on poistettava JavaScript-taulukko, mitä minun pitäisi tehdä? Liitosmenetelmällä tiedetään olevan allekirjoitus Array.prototype.splice.

Se poistaa deleteCount-komponentit taulukosta aloittaen aloitusilmaisimesta. Jos ohitetaan enemmän kuin kaksi argumenttia, kaikki seuraavat taulukon argumentit sijoitetaan eliminoitujen sijaan. Jos aloitus on negatiivinen, indeksi, josta nosto jatkuu, on yhtä suuri kuin pituus + aloitus. Taulukko palautetaan poistetuista elementeistä.

Itse asiassa liitosmenetelmää käyttämällä voit poistaa komponentteja taulukon keskeltä tai lisätä minkä tahansa määrän komponentteja missä tahansa taulukossa.

Yksinkertaisimmassa versiossa, jos haluat poistaa komponentin indeksillä i, sinun on pyydettävä liitosmenetelmä taulukosta parametreilla i ja 1.

Periaatteessa liitosmenetelmän toinen parametri on valinnainen, mutta yhden argumentin funktion käyttäytyminen on erilainen jokaisessa selaimessa.

Esimerkiksi Firefoxissa, Operan uusimmissa muunnelmissa, Safarissa ja Chromessa kaikki tiedot taulukon loppuun asti poistetaan.

Mitään komponenttia ei poisteta IE:ssä. Operan ensimmäisissä muunnelmissa on mahdotonta ennustaa käyttäytymistä - yksi osa indeksialkusta - 1 poistetaan. Siksi se on aina tarpeen tätä menetelmää läpäisevät vähintään kaksi komponenttia.

Avaimet

Tietenkin JavaScriptiä oppiessa tulee pitää mielessä myös assosiatiiviset taulukot, kuten aiemmin mainittiin. Tämä on abstrakti tyyppinen tieto (rajapinta tietovarastoon), jonka avulla voit tallentaa muotoa "(avain, arvo)" olevia pareja ja tukea parin lisäämistä sekä parin poistamista ja etsimistä. avaimella:

ETSI (avain).

INSERT (arvo, avain).

POISTA (avain).

Oletetaan, että kahta samankaltaista paria ei voida tallentaa assosiatiiviseen taulukkoon. Parissa k + v v:tä kutsutaan avaimeen k liittyväksi arvoksi. Yllä olevien operaatioiden semantiikka ja nimet voivat olla erilaisia ​​tällaisten taulukoiden eri toteutuksissa.

Näin ollen FIND (avain) -toiminto palauttaa annettuun avaimeen liittyvän arvon tai jonkin tietyn UNDEF-objektin osoittaen, että annettuun avaimeen ei ole liitetty arvoa. Kaksi muuta toimintoa ei palauta mitään (paitsi onko toiminto onnistunut).

Yleisesti ottaen käyttöliittymän näkökulmasta on kätevää pitää assosiatiivista taulukkoa yksinkertaisena taulukkona, jossa indekseinä voidaan käyttää paitsi kokonaislukuja, myös muun tyyppisiä arvoja - esimerkiksi merkkijonoja.

Muuten, tuki tällaisille taulukoille on saatavilla monissa tulkittavissa ohjelmointikielet korkeatasoinen, kuten PHP, Perl, Ruby, Python, Tcl, JavaScript ja muut. Kielille, joilla ei ole sisäänrakennettuja työkaluja assosiatiivisten taulukoiden kanssa työskentelemiseen, on luotu valtava määrä toteutuksia kirjastojen muodossa.

Esimerkki assosiatiivinen matriisi voi palvella Puhelinluettelo. Tässä versiossa merkitys on monimutkainen "F. I. O. + osoite”, ja avain on puhelinnumero. Yksi puhelinnumero on yksi omistaja, mutta yksi henkilö voi omistaa useita numeroita.

Assosiatiiviset laajennukset

On huomattava, että tunnetuimpia laajennuksia ovat seuraavat:

• JOKAINEN - "käy läpi" kaikki tallennetut parit.
• CLEAR - poista kaikki tietueet.
• MIN - etsi pari, jolla on pienin avainarvo.
• MAX – etsi pari, jolla on suurin avainarvo.

Kaksi viimeistä vaihtoehtoa edellyttävät, että näppäimet osoittavat vertailutoiminnon.

Assosiatiivisten taulukoiden toteutukset

On olemassa monia erilaisia ​​toteutuksia assosiatiivinen matriisi. Yleisin toteutus saattaa perustua yksinkertainen joukko, jonka komponentit ovat (arvo, avain) pareja. Koventaa vauhtia hakutoiminnot voit järjestää komponentit tästä joukosta avaimella ja löydä se käyttämällä Mutta tämä pidentää lisäämiseen tarvittavaa aikaa uusi pariskunta, koska taulukon komponentit on "siirrettävä erilleen", jotta uusi tietue voidaan pakata näkyviin tulevaan tyhjään soluun.

Tunnetuimpia toteutuksia ovat erilaisiin hakupuihin perustuvat toteutukset. Esimerkiksi tyypillisessä C++ STL-lukijassa karttasäilö on toteutettu musta-mahonkipuun perusteella. Ruby-, Tcl- ja Python-tyylit käyttävät yhden tyyppistä hash-taulukkoa. On muitakin toteutuksia.

Yleensä jokaisella toteutuksella on omat haittansa ja etunsa. On tärkeää, että kaikki kolme toimintoa suoritetaan sekä keskimäärin että pahimmassa vivahteessa ajanjakson O(log n) aikana, missä n on senhetkinen tallennettavien parien lukumäärä. Vastaavien hakupuiden (mukaan lukien musta-punaiset puut) osalta tämä ehto täyttyy.

Hash-taulukkopohjaisilla toteutuksilla tiedetään olevan keskimääräinen aika O(1), mikä on parempi kuin hakupuupohjaisilla toteutuksilla. Tämä ei tietenkään takaa yksittäisten toimintojen nopeaa suorittamista: pahimman tapauksen INSERT-aika merkitään O(n). INSERT-prosessi käynnissä pitkä aika, kun täyttökerroin saavuttaa korkeimman pisteensä ja on välttämätöntä rekonstruoida hash-taulukon indeksi.

Muuten, nämä hash-luettelot ovat huonoja, koska niitä ei voida käyttää nopeaan suorittamiseen lisätoimia MAX, MIN ja algoritmi kaikkien tallennettujen parien läpikulkua varten laskevassa tai nousevassa näppäinjärjestyksessä.