Úvod do problematiky
Pole představují klíčovou datovou strukturu v programovacím jazyce Ruby. Jsou to v podstatě uspořádané sbírky hodnot. K jednotlivým prvkům pole se přistupuje prostřednictvím indexu, přičemž indexování začíná od nuly.
Flexibilita polí umožňuje jejich využití pro ukládání rozličných typů dat, ať už se jedná o číselné hodnoty, textové řetězce nebo dokonce složitější objekty. Kromě toho s nimi lze provádět řadu operací, jako je třídění, vyhledávání konkrétních prvků nebo vkládání nových hodnot.
V tomto článku se podíváme na různé metody, které Ruby nabízí pro práci s poli, a ukážeme si, jak s jejich pomocí efektivně řešit běžné programátorské úlohy.
Metody pro přidávání prvků
Array#<<
Metoda Array#<< slouží k přidání nového prvku na konec stávajícího pole. Výsledkem je původní pole, ovšem rozšířené o nový prvek.
my_array = [1, 2, 3]
my_array << 4
=> [1, 2, 3, 4]
Array#push
Metoda Array#push je v podstatě synonymem pro Array#<<, tedy funguje naprosto stejně.
my_array = [1, 2, 3]
my_array.push(4)
=> [1, 2, 3, 4]
Array#unshift
Na rozdíl od předchozích metod, Array#unshift přidává prvek na začátek pole. Původní pole je opět upraveno, tentokrát rozšířením o nový prvek na první pozici.
my_array = [1, 2, 3]
my_array.unshift(0)
=> [0, 1, 2, 3]
Array#insert
Metoda Array#insert umožňuje vložení nového prvku na libovolnou pozici, určenou indexem. Index musí být platný, tzn. v rozmezí od 0 do délky pole. I zde se modifikuje původní pole.
my_array = [1, 2, 3]
my_array.insert(1, 4)
=> [1, 4, 2, 3]
Metody pro odstraňování prvků
Array#pop
Metoda Array#pop odebírá z pole poslední prvek a zároveň jej vrací jako výsledek. Původní pole je tak o jeden prvek kratší.
my_array = [1, 2, 3]
my_array.pop
=> 3
my_array => [1, 2]
Array#shift
Array#shift funguje podobně jako Array#pop, avšak odebírá prvek z počátku pole. Také vrací odebraný prvek a upravuje původní pole.
my_array = [1, 2, 3]
my_array.shift
=> 1
my_array => [2, 3]
Array#delete
Metoda Array#delete odstraní z pole první výskyt zadaného prvku. Jako výsledek vrací odstraněný prvek nebo nil, pokud se prvek v poli nenachází.
my_array = [1, 2, 3]
my_array.delete(2)
=> 2
my_array => [1, 3]
Array#delete_at
Metoda Array#delete_at odebere prvek na konkrétní pozici určenou indexem. Index musí být v platném rozsahu. Metoda vrací smazaný prvek.
my_array = [1, 2, 3]
my_array.delete_at(1)
=> 2
my_array => [1, 3]
Metody pro třídění
Array#sort
Metoda Array#sort setřídí prvky pole vzestupně, tedy od nejmenšího k největšímu. Výsledkem je nové, setříděné pole, přičemž původní pole zůstává nezměněné.
my_array = [3, 1, 2]
my_array.sort
=> [1, 2, 3]
my_array => [3, 1, 2]
Array#sort_by
Metoda Array#sort_by umožňuje třídit prvky pole na základě kritéria definovaného blokem kódu. Tento blok by měl přijímat prvek pole a vracet hodnotu, podle které se má třídit. I zde je výsledkem nové setříděné pole a původní zůstává beze změn.
my_array = [["John", 20], ["Mary", 25], ["Bob", 18]]
my_array.sort_by { |name, age| age }
=> [[„Bob“, 18], [„John“, 20], [„Mary“, 25]]
my_array => [[„John“, 20], [„Mary“, 25], [„Bob“, 18]]
Array#reverse
Metoda Array#reverse obrátí pořadí prvků v poli. Vrací nové pole s prvky v obráceném pořadí, zatímco původní pole je ponecháno v původním stavu.
my_array = [1, 2, 3]
my_array.reverse
=> [3, 2, 1]
my_array => [1, 2, 3]
Metody pro vyhledávání
Array#include?
Metoda Array#include? ověřuje, zda pole obsahuje zadaný prvek. Vrací true, pokud se prvek v poli nachází, jinak vrací false.
my_array = [1, 2, 3]
my_array.include?(2)
=> true
Array#index
Metoda Array#index vrací index prvního výskytu zadaného prvku v poli. Pokud se prvek v poli nenachází, vrací metoda nil.
my_array = [1, 2, 3]
my_array.index(2)
=> 1
Array#find
Metoda Array#find vrací první prvek, který splňuje zadanou podmínku, definovanou pomocí bloku kódu. Blok by měl přijímat prvek pole a vracet true, pokud prvek splňuje podmínku.
my_array = [1, 2, 3]
my_array.find { |num| num > 2 }
=> 3
Array#find_index
Metoda Array#find_index vrací index prvního prvku, který splňuje zadanou podmínku, definovanou blokem kódu. Blok by měl opět přijímat prvek a vracet true, pokud prvek vyhovuje podmínce.
my_array = [1, 2, 3]
my_array.find_index { |num| num > 2 }
=> 2
Závěr
Pole jsou v Ruby velmi užitečnou datovou strukturou pro ukládání a organizaci dat. Znalost různých metod pro práci s poli je klíčová pro efektivní programování. V tomto článku jsme si představili nejpoužívanější metody pro přidávání, odebírání, třídění a vyhledávání prvků v poli. S jejich pomocí můžete s daty efektivně a elegantně pracovat.
Často kladené dotazy
1. Jak v Ruby vytvořím pole?
Pole vytvoříte pomocí hranatých závorek. Například: my_array = [1, 2, 3].
2. Jak zjistím délku pole?
Délku pole získáte metodou Array#length. Například: my_array.length.
3. Jak spojím dvě pole?
Dvě pole spojíte operátorem +. Například: [1, 2, 3] + [4, 5, 6].
4. Jak převedu pole na textový řetězec?
Pole na řetězec převedete pomocí metody Array#join. Například: [1, 2, 3].join(", ").
5. Jak z pole odstraním duplicitní prvky?
Duplicitní prvky odstraníte metodou Array#uniq. Například: [1, 2, 3, 1, 2].uniq.
6. Jak najdu největší a nejmenší prvek v poli?
Největší a nejmenší prvek najdete pomocí metod Array#max a Array#min. Například: [1, 2, 3].max.
7. Jak obrátím pořadí prvků v poli?
Pořadí prvků obrátíte metodou Array#reverse. Například: [1, 2, 3].reverse.
8. Jak odstraním prvek z pole podle jeho indexu?
Prvek odstraníte pomocí metody Array#delete_at. Například: `[1, 2,