Taulukot javascriptissä yksinkertaisin sanoin. Merkkijonon muuntaminen taulukoksi - jakaa. Osien lisääminen ja poistaminen taulukon keskellä
Taulukot
Array on järjestetty arvokokoelma. Taulukon arvoja kutsutaan elementeiksi, ja jokaiselle elementille on ominaista numeerinen sijainti taulukossa, jota kutsutaan indeksiksi. Taulukot sisään JavaScript ovat kirjoittamattomia: taulukkoelementit voivat olla mitä tahansa tyyppiä ja erilaisia elementtejä Samalla taulukolla 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ä hakasulkeissa. 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 elementtiä eri tyyppejä+ 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 se luodaan tyhjä joukko, vastaa kirjaimellista .
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 melkein 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ä taulukon elementin 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, joita käytetään objektin ominaisuuksiin. 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 4:ksi.
Sinun tulee erottaa taulukon indeksit selvästi objektien ominaisuuksien nimistä. Kaikki indeksit ovat ominaisuuksien nimiä, mutta vain ominaisuudet, joiden nimet esitetään kokonaisluvuilla, 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 esineitä:
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ä poista-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 aukon.
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()-menetelmän 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 "oikeita" moniulotteisia taulukoita, mutta se tarjoaa hyvän tavan simuloida niitä käyttämällä taulukkotaulukoita. 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, Missä kaksiulotteinen matriisi Käytetään kertotauluna:
// 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 alaluvuissa.
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 uusi joukko uudelleenjärjestetyillä elementeillä, mutta 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ärjestyksellä ei ole väliä), 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 // a:n ja b:n lajittelujärjestyksestä riippuen) ); // 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 rekursiivisesti muuttaminen yksiulotteinen matriisi ei tapahdu. 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ä on joitain 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.
Ensimmäinen argumentti liitosmenetelmä() 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ä() toteuttaa 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ä. sitä paitsi JavaScript-taulukot ovat dynaamisia, mikä tarkoittaa, että julistaa 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 = ; //taulukko, 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:
Tässä tapauksessa luodaan tyhjä taulukko, joka vastaa tyhjää literaalia.
- Rakentaja määrittää nimenomaisesti n taulukkoelementin arvot:
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 numero suluissa taulukkoa määritettäessä:
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: JavaScript-taulukot voivat tallentaa minkä tahansa määrän minkä tahansa tyyppisiä elementtejä.
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);
Voit saada taulukon viimeisen elementin myös pituusominaisuuden avulla:
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 taulukkoelementtien 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. Pieni teoria - 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 in tässä tapauksessa kun työskentelet taulukkomuodossa. Koska JavaScriptillä ei ole menetelmiä työskentelyyn assosiatiiviset taulukot Niitä käytetään paljon harvemmin kuin tavallisia, vaikka niistä voi yhtä hyvin olla hyötyä tiedon tallentamisessa ja käsiksi tarvittavien elementtien muistamisessa.
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] + "
");
JavaScriptissä, kuten muissakin ohjelmointikielissä, käytetään erilaisia menetelmiä taulukoiden kanssa työskentelyyn.
Menetelmät yksinkertaistavat logiikan rakentamista ja sen toteuttamista skriptissä.
Alla ovat perusmenetelmiä taulukoiden kanssa työskentelyyn JS:ssä.
työntää
Push()-menetelmä lisää arvon taulukon loppuun.
Olkoon arr = ; arr.push(312); console.log(arr); // →
pop
Pop()-menetelmä poistaa viimeisen elementin taulukosta tai palauttaa sen arvon.
Olkoon arr = ; arr.pop(); console.log(arr); // →
Käyttämällä kykyä saada esimerkkinä taulukon viimeisen elementin arvo, voimme saada kuvamuodon:
Anna img = "https://example.com/img/name.png"; anna muoto = img.split(".").pop(); console.log(format); // → png console.log(img.split(".")); // → ["https://example", "com/img/name", "png"]
poista vaihto
Unshift()-menetelmä lisää elementin taulukon alkuun.
Olkoon arr = ; arr.unshift(312); console.log(arr); // →
siirtää
Shift()-menetelmä poistaa ensimmäisen elementin taulukosta.
Olkoon arr = ; arr.shift(); console.log(arr); // → ;
Sinun on ymmärrettävä, että kun käytät shift- ja unshift-menetelmiä, jokainen taulukon elementti muuttaa indeksiään. Tämä voi hidastaa ohjelman suorittamista, jos joukko on suuri.
jakaa
Split()-menetelmää käytetään muuntamaan merkkijono taulukoksi. Split jakaa merkkijonon määritetyn parametrin mukaan.
Olkoon str = "Anya, Masha, Sasha, Dasha"; // tämä on merkkijono anna arr = str.split(", "); console.log(arr); // → ["Anya", "Masha", "Sasha", "Dasha"] on joukko
liittyä seuraan
Join()-menetelmä yhdistää taulukon elementit merkkijonoksi käyttämällä parametrissa määritettyä erotinta.
Olkoon arr = ["Notpad++", "Sublime", "VSCode"]; // tämä on taulukko anna str = arr.join(", "); console.log("Koodin editorit: " + str); // → "Koodin editorit: Notpad++, Sublime, VSCode"
viipale
Slice()-menetelmä luo uuden taulukon, johon se kopioi elementtejä lähteestä alkaen elementistä, jolla on menetelmälle välitetty ensimmäisen parametrin indeksi, toisen parametrin indeksin sisältävään elementtiin.
Esimerkiksi: slice(3, 7) palauttaa elementit indekseillä 3, 4, 5, 6. Elementtiä, jonka indeksi on 7, ei sisällytetä taulukkoon.
Jos parametri, jolla on negatiivinen arvo, välitetään slice(:lle), se palauttaa uuden taulukon, jossa on parametrissa määritetty määrä elementtejä, jotka on jo otettu alkuperäisen taulukon lopusta.
Slice-menetelmä ei muuta alkuperäistä taulukkoa.
Tässä on esimerkkejä slice()-menetelmästä toiminnassa:
Olkoon arr = ["A", "B", "C", "D", "E", "F", "G"]; // Palauttaa taulukon, joka sisältää elementtejä indekseillä 2-5 console.log(arr.slice(2, 5)); // → ["C", "D", "E"] // Palauttaa uuden taulukon, joka sisältää elementtejä indekseillä 3 arr.length console.log(arr.slice(3)); // → ["D", "E", "F", "G"] // Palauttaa kopion alkuperäisestä taulukosta console.log(arr.slice()); // → ["A", "B", "C", "D", "E", "F", "G"] // Palauttaa uuden taulukon, joka koostuu alkuperäisen console.login kolmesta viimeisestä elementistä (arr.slice (-3)); // → ["E", "F", "G"]
liitos
Splice()-menetelmä muuttaa taulukon sisältöä poistamalla olemassa olevia elementtejä ja/tai lisäämällä uusia.
Syntaksi:
Array.splice(alku, deleteCount[, item1[, item2[, ...]]])
Vaihtoehdot:
- alkaa- Indeksi, josta taulukon muuttaminen aloitetaan. Jos suurempi kuin taulukon pituus, todellinen indeksi asetetaan taulukon pituudeksi. Jos negatiivinen, määrittää elementin indeksin lopusta.
- deleteCount- Kokonaisluku, joka ilmaisee taulukosta poistettavien vanhojen elementtien määrän. Jos deleteCount on 0, mitään elementtejä ei poisteta. Tässä tapauksessa sinun on määritettävä vähintään yksi uusi elementti. Jos deleteCount enemmän määrää taulukossa jäljellä olevat elementit aloitusindeksistä alkaen, sitten kaikki elementit taulukon loppuun asti poistetaan.
- tuoteN- Valinnaiset parametrit. Matriisiin lisättävät elementit. Jos et määritä mitään elementtiä, splice() yksinkertaisesti poistaa elementit taulukosta.
Palautusarvo
Kuvaus
Jos lisättävien elementtien määrä on eri kuin poistettavien elementtien määrä, taulukon pituus muuttuu kutsun jälkeen.
Olkoon arr = ["Barca", "Shakhtar", "Manchester United", "Milan", "Real", "Ajax", "Juventus"]; anna nax = arr.splice(2, 3); arr.splice(2, 3); console.log(nax); // → ["Manchester United", "Milan", "Real"] console.log(arr); // → ["Barca", "Shakhtar"] arr.splice(1, 0, "Zenit", "CSKA", "Spartak"); console.log(arr); // → [Barça, Zenit, CSKA, Spartak, Shakhtar]
käänteinen
Reverse()-menetelmä kääntää taulukon elementtien järjestyksen. Tämän seurauksena taulukon ensimmäisestä elementistä tulee viimeinen ja viimeisestä elementistä ensimmäinen.
Olkoon arr = ; console.log(arr.reverse()); // → console.log(["Alice", "BG", "GO", "DDT"].reverce()); // → ["DDT", "GO", "BG", "Liisa"]
kartta
Map()-menetelmä toistuu taulukon elementtien läpi ja tuottaa niiden avulla määritellyt toimet ja palauttaa kopion taulukosta muuttuneine elementteineen.
Alla olevassa esimerkissä jokaiseen taulukkoelementtiin lisätään tämän elementin indeksiarvo (7 + 0, 2 + 1, 15 + 2, 4 + 3, 31 + 4):
Olkoon arr = ; anna testMap = arr.map((elementti, indeksi) => elementti + indeksi); console.log(testMap); //
tai kerro jokainen taulukon arvo esimerkiksi 12:lla
Olkoon arr = ; anna testMap = arr.map(a => a * 12); console.log(testMap); // →
suodattaa
Filter()-menetelmää käytetään taulukoiden suodattamiseen. Se toistuu taulukon läpi palauttaen vain ne elementit, jotka läpäisevät tietyn ehdon.
Suodatetaan esimerkiksi lukujoukon arvot jättäen vain ne, jotka ovat suurempia kuin 21
Olkoon arr = ; anna testFilter = arr.filter(element => elementti > 21); console.log(testFilter); // →
Huomaa, että 21 ei sisällytetty taulukon tulokseen, koska ehto oli palauttaa jotain, joka on suurempi kuin 21. Jotta 21 sisällytettäisiin taulukkoon, asetimme ehdon suuremmaksi tai yhtä suureksi kuin: elementti >= 21
vähentää
Reduction()-menetelmä kulkee peräkkäin taulukon elementtien läpi ja kerää välituloksen funktion ehdossa määritellyn funktion mukaan. Lopputuloksessa se palauttaa vain yhden arvon.
Tätä menetelmää käytetään usein taulukon kaikkien lukujen summan löytämiseen. Esimerkki:
Olkoon arr = ; anna summa = arr.reduce((acc, element) => acc + element); console.log(sum); // → 370
järjestellä
Sort()-menetelmää käytetään taulukon elementtien lajitteluun määritettyjen parametrien mukaan.
Esimerkki - otetaan joukko numeroita ja lajitellaan ne nousevaan järjestykseen:
Olkoon arr = ; anna testSortArr = arr.sort((a, b) => a - b); console.log(testSortArr); // →
sisältää
include()-menetelmä määrittää, sisältääkö taulukko tietty elementti, palauttaa tosi tai epätosi tästä riippuen.
Esimerkki include() -funktion käytöstä.
Tässä on looginen ilmaus:
Olkoon eläin = "koira"; if (eläin == "kissa" || eläin == "koira" || eläin == "leijona" || eläin == "hevonen") ( // ........ )
käyttämällä sisältää menetelmän voidaan kirjoittaa näin:
Olkoon eläin = "koira"; const eläimet = ["kissa", "koira", "leijona", "hevonen"]; if (eläimet.sisältää(eläin)) ( // ........... )
Opitaan indeksoimaan taulukoita js:ssä, poistamaan ja lisäämään niiden elementtejä.
JavaScript-taulukko on globaali objekti, joka on suunniteltu tallentamaan arvoluettelo.
Se on samanlainen kuin muut muuttujat siinä mielessä, että se voi tallentaa kaikentyyppisiä tietoja. Mutta joukossa on yksi tärkeä ero muuttujasta: se voi tallentaa useamman kuin yhden elementin kerrallaan.
Taulukko on järjestys arvojen kokoelma. Jokaista arvoa kutsutaan elementiksi ja sillä on oma numeronsa, jota kutsutaan indeksiksi.
Matriisin sisällä oleva elementti voi olla mitä tahansa tyyppiä. Lisäksi yhden taulukon elementit voivat olla erityyppisiä: numeroita, merkkijonoja, logiikka portit ja jopa esineitä tai muita matriiseja.
Taulukon elementtien järjestys alkaa 0:sta. Osoittautuu, että taulukossa on aina indeksisiirtymä yhdellä: ensimmäisellä elementillä on indeksi 0, toisella 1 jne.
Tässä on esimerkki taulukosta, jossa on erityyppisiä elementtejä:
Taulukon luominen (ilmoittaminen).
Taulukot ovat erittäin käteviä, koska ne voivat tallentaa niin paljon tietoa kuin tarvitset. js-taulukon suurin mahdollinen koko on 2 32 elementtiä.
Meidän on kerrottava JavaScriptille, että haluamme luoda taulukon. Tähän on kaksi vaihtoehtoa: arvo hakasulkeissa tai avainsana Uusi.
Lyhyt merkintä: hakasulkeilla
Pilkuilla eroteltu luettelo arvoista hakasulkeissa.
var myArray = [ "Jack", "Sawyer", "John", "Desmond" ];
Taulukon sisältö määräytyy sen mukaan, mitä välissä on hakasulkeet. Jokainen arvo erotetaan pilkulla.
Arvot määritetään samalla tavalla kuin yksinkertaiset muuttujat, eli merkkijonot on ilmoitettava lainausmerkkien sisällä jne.
Jos haluat ilmoittaa tyhjän taulukon, jätä sulut tyhjiksi:
var myArray = ;
Pitkä merkintä: Array()-konstruktorin avulla
var lostArray = new Array("Jack", "Sawyer", "John", "Desmond"); var twinPeaksArray = new Array("Laura", 2, ["Bob", "Leland", "Dale"]);
Uusi avainsana käskee JavaScriptiä luomaan uuden taulukon, jonka arvot välitetään parametreina.
Jos tiedät etukäteen kuinka monta elementtiä taulukossasi on, voit välittää tämän arvon välittömästi rakentajassa.
var myArray = uusi Array(80);
Yllä oleva lauseke luo tyhjän taulukon, joka koostuu 80 paikasta määrittelemättömillä arvoilla.
Tyhjän taulukon ilmoittaminen:
var myArray = new Array();
Array Elementtien käyttäminen
Kunkin elementin indeksin avulla voit työskennellä minkä tahansa taulukon tietojen kanssa ja käyttää sitä operaattorilla:
var myArray = ["Jack", "Sawyer", "John", "Desmond"]; console.log(myArray); // Tulostaa "Jack" console.log(myArray); // Tulostaa "Desmond"
Taulukossa voi olla useita tasoja, eli jokainen elementti voi itse olla taulukko. Tuloksena on kaksiulotteinen js-taulukko. Kuinka voimme käyttää näitä taulukoita, jotka sijaitsevat muiden sisällä - " moniulotteisia taulukoita»?
Tarkastellaan esimerkkinä perhettä edustavaa taulukkoa. Tämän perheen lapset kirjataan erilliseen taulukkoon pääryhmän sisällä:
var familyArray = ["Marge", "Homer", ["Bart", "Lisa", "Maggie"]];
Voit kuvitella sen näin:
Arvoon "Lisa" viittaaminen:
var lisa = perheArray; console.log(lisa); // tulostaa "Lisa"
Tätä voidaan jatkaa lähes loputtomiin, jolloin voit tallentaa sisäkkäisiä tietojoukkoja taulukoihin ja käyttää niitä indeksien avulla.
Elementtien lisääminen taulukkoon
Selvitimme, kuinka päästään taulukon elementteihin käyttämällä niitä vastaavia indeksejä. Samalla tavalla voit lisätä (tai muuttaa) elementtejä ilmoittamalla esimerkiksi:
var myArray = ["Kate", "Aurinko"]; myArray = "Julia"; console.log(myArray); // Tulostaa "Kate, Sun, Juliet"
Mitä tapahtuu, jos ilmoitan elementin indeksillä, jonka edessä ei ole muita elementtejä? Taulukko itse luo kaikki puuttuvat elementit ja antaa niille arvon undefined:
var myArray = ["Kate", "Aurinko"]; myArray = "Julia"; console.log(myArray.length); // Tulostaa "6" console.log(myArray); // Tulostaa ["Kate", "Sung", undefined, undefined, undefined, "Juliet"]
Voit selvittää js-taulukon pituuden käyttämällä pituus-ominaisuutta. Yllä olevassa esimerkissä taulukossa on kuusi elementtiä, joista kolmelle ei ole annettu arvoa - ne on merkitty määrittelemättömiksi .
push() -menetelmä
Push()-menetelmällä voit lisätä yhden tai useamman elementin js-taulukkoon. Push() hyväksyy rajattoman määrän parametreja, jotka kaikki lisätään taulukon loppuun.
var myArray = ["Kate", "Sut"]; myArray.push("Julia"); // Lisää elementin "Juliet" taulukon loppuun myArray.push("Libby", "Shannon" // Lisää elementit "Libby" ja "Shannon" taulukon loppuun console.log(myaArray); ); // Tulosteet ["Kate", "Soon", "Juliet", "Libby", "Shannon"]
unshift()-metodi
Unshift()-menetelmä toimii samalla tavalla kuin push(), paitsi että se lisää elementtejä taulukon alkuun.
var myArray = ["Kate", "Aurinko"]; myArray.unshift("Julia"); // Lisää elementin "Juliet" taulukon alkuun myArray.unshift("Libby", "Shannon"); // Lisää elementit "Libby" ja "Shannon" taulukon alkuun console.log(myArray); // Tulosteet ["Libby", "Shannon", "Juliet", "Kate", "Pian"]
Array Elementtien poistaminen
pop()- ja shift()-menetelmiä
Pop()- ja shift()-menetelmät poistavat taulukon viimeisen ja ensimmäisen elementin, vastaavasti:
var myArray = ["Jack", "Sawyer", "John", "Desmond", "Kate"]; myArray.pop(); // Poistaa "Kate"-elementin myArray.shift(); // Poistaa "Jack"-elementin console.log(myArray); // Tulostaa ["Sawyer", "John", "Desmond"]
splice() -menetelmä
Splice()-menetelmällä voit poistaa tai lisätä elementtejä taulukkoon määrittäen samalla tarkasti elementtien indeksin.
Seuraavassa esimerkissä splice()-menetelmä lisää kaksi elementtiä alkaen indeksistä 2 ( eli kolmannesta elementistä):
var fruitArray = ["omena", "persikka", "appelsiini", "sitruuna", "lime", "kirsikka"]; hedelmäArray.splice(2, 0, "meloni", "banaani"); console.log(fruitArray); // Tulokset ["omena", "persikka", "meloni", "banaani", "appelsiini", "sitruuna", "lime", "kirsikka"]
Splice()-menetelmän ensimmäinen parametri on indeksi. Se osoittaa, mihin kohtaan elementtejä tulee lisätä/poistaa. Esimerkissämme valitsimme indeksin 2 ( tarkoittaa "oranssia").
Toinen parametri on poistettavien elementtien määrä. Määritimme arvon 0, joten mitään ei poisteta.
Seuraavat parametrit ovat valinnaisia. Ne lisäävät taulukkoon uusia arvoja. Meidän tapauksessamme meidän on lisättävä "meloni" ja "banaani" alkaen indeksistä 2.
- Käännös
Useimmat nykyään kehitetyt sovellukset vaativat vuorovaikutusta jonkinlaisen tietojoukon kanssa. Kokoelmien elementtien käsitteleminen on yleinen toimenpide, 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 elementtejä. 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ä muuntyyppisten 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 funktion määrittelyjä ja funktiolausekkeita vastaavia. Sinun ei pitäisi korvata yhtä toisella. Tämä johtuu erityisesti siitä, että tavallisissa ja nuolitoiminnot tämä avainsana 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 se tehdään for...of-silmukalla:
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 ottaa huomioon, että se on isot ja pienet kirjaimet huomioitava. Jos kokoelma sisältää esimerkiksi merkkijonoelementin SCHOOL ja sisältää() tarkistaa sen olemassaolon käyttämällä merkkijonokoulua, menetelmä palauttaa arvon 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 include()-menetelmä, paitsi että sen argumentti on funktio eikä esimerkiksi tavallinen 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ä 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ä. 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 vastaan. 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 klubilla 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än avulla voit luoda tietyn taulukon perusteella uuden taulukon, joka sisältää vain ne alkuperäisen taulukon 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. Ratkaistaan tämä ongelma 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
