Kõige tavalisemad rubiinmassiivi meetodid, mida peaksite teadma

Levinud massiivi meetodid

Rubiinimassiivid moodustavad rubiinis programmeerimise põhialuse ja tegelikult enamikus keeltes. Seda kasutatakse nii palju, et oleks kasulik teada ja isegi meelde jätta mõned massiivide kõige sagedamini kasutatavad meetodid. Kui soovite rohkem teada saada rubiinimassiividest, on meil nende kohta artikkel.

Selles juhendis on meie massiiv järgmine:

array = [0, 1, 2, 3, 4]

.pikkus

Meetod .length koondab teie massiivi elementide arvu ja tagastab loendi:

array.length => 5

.esiteks

Esimene meetod avab massiivi esimese elemendi, indeksi 0 elemendi:

array.first => 0

.viimaseks

Meetod .last pääseb massiivi viimasele elemendile juurde:

array.last => 4

.võtma

Meetod .takistab massiivi esimesed n elementi:

array.take(3) => [0, 1, 2]

.drop

Meetod .drop tagastab elemendid massiivi n elemendi järele:

array.drop(3) => [3, 4]

massiivi indeks

Massiivi konkreetsele elemendile pääsete juurde selle registrist. Kui massiivis ei ole indeksit, tagastatakse null:

array[2] => 2 array[5] => nil

.pop

.Pop-meetod eemaldab massiivi viimase elemendi püsivalt:

array.pop => [0, 1, 2, 3]

.vahetus

Meetod .shift eemaldab massiivi esimese elemendi püsivalt ja tagastab selle elemendi:

array.shift => 0 array => [1, 2, 3, 4]

.push

.Push-meetod võimaldab teil lisada massiivi lõppu elemendi:

array.push(99) => [0, 1, 2, 3, 4, 99]

.lülitus

Meetod .unshift võimaldab teil lisada massiivi algusesse elemendi:

array = [2, 3] array.unshift(1) => [1, 2, 3]

.kustuta

Meetod .delete eemaldab määratud elemendi massiivist jäädavalt:

array.delete(1) => [0, 2, 3, 4]

.delete_at

Meetod .delete_at võimaldab teil massiivi elemendi jäädavalt eemaldada määratud indeksist:

array.delete_at(0) => [1, 2, 3, 4]

.tagurpidi

Meetod .reverse muudab massiivi ümber, kuid ei muuda seda (algne massiiv jääb selliseks nagu on):

array.reverse => [4, 3, 2, 1, 0]

.vali

Meetod .select kordab massiivi ja tagastab uue massiivi, mis sisaldab kõiki üksusi, mis vastavad esitatud avaldisele.

array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] array.select  number > 4  => [5, 6, 7, 8, 9, 10] array => [5, 6, 7, 8, 9, 10]

. lisada

Kaasa arvatud? meetod kontrollib, kas antud argument sisaldub massiivis:

array = [1, 2, 3, 4, 5] => [1, 2, 3, 4, 5] array.include?(3) => true #### .flatten The flatten method can be used to take an array that contains nested arrays and create a one-dimensional array: ``` ruby array = [1, 2, [3, 4, 5], [6, 7]] array.flatten => [1, 2, 3, 4, 5, 6, 7]

.liitu

Meetod .join tagastab eraldusparameetriga eraldatud massiivi kõigi elementide stringi. Kui eraldaja parameeter on null, kasutab meetod stringide vahel eraldajana tühja stringi.

array.join => "1234" array.join("*") => "1*2*3*4"

.iga

Iga meetod kordab massiivi kõiki elemente, võimaldades teil nendega toiminguid teha.

array.each do |element| puts element end => 0 1 2 3 4

.kaart

Meetod .map on sama mis meetodiga .collect. .Map- ja .collect-meetodid korduvad massiivi iga elemendi kohal, võimaldades teil nendega toiminguid teha. Meetodid .map ja .collect erinevad meetoditest .each selle poolest, et nad tagastavad transformeeritud elemente sisaldava massiivi.

array.map  element * 2  puts element end => 0 2 4 6 8

.uniq

Meetod .uniq võtab sisse duplikaatelemente sisaldava massiivi ja tagastab massiivi koopia, mis sisaldab ainult unikaalseid elemente - massiivist eemaldatakse kõik duplikaatelemendid.

array = [1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 8] array.uniq => [1, 2, 3, 4, 5, 6, 7, 8]

.kass

Meetod .concat lisab elemendid massiivist algsesse massiivi. Meetod .concat võib argumendina võtta mitu massiivi, mis omakorda lisab algsele massiivile mitu massiivi.

array = [0, 1, 2, 3, 4] array.concat([5, 6, 7], [8, 9, 10]) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Rohkem informatsiooni

  • Ruby Array dokumendid
  • Kuus rubiinimassiivi meetodit, mida peate teadma
  • Rubiini õppimine - nullist kangelaseni