Metody pole

Pole poskytují mnoho metod. Pro usnadnění jsou v této kapitole rozděleny do skupin.

Přidat/odebrat položky

Již známe metody, které přidávají a odebírají položky od začátku nebo konce:

  • arr.push(...items) – přidává položky na konec,
  • arr.pop() – vyjme položku z konce,
  • arr.shift() – extrahuje položku od začátku,
  • arr.unshift(...items) – přidá položky na začátek.

Zde je několik dalších.

split

Jak odstranit prvek z pole?

Pole jsou objekty, takže můžeme zkusit použít delete :

let arr = ["I", "go", "home"];

delete arr[1]; // remove "go"

alert( arr[1] ); // undefined

// now arr = ["I", , "home"];
alert( arr.length ); // 3

Prvek byl odstraněn, ale pole má stále 3 prvky, vidíme, že arr.length == 3 .

To je přirozené, protože delete obj.key odebere hodnotu pomocí key . To je vše, co dělá. Vhodné pro předměty. Ale u polí obvykle chceme, aby se zbytek prvků posunul a obsadil uvolněné místo. Očekáváme, že nyní budeme mít kratší pole.

Měly by se tedy používat speciální metody.

Metoda arr.splice je švýcarský armádní nůž pro pole. Dokáže vše:vkládat, odebírat a nahrazovat prvky.

Syntaxe je:

arr.splice(start[, deleteCount, elem1, ..., elemN])

Upravuje arr počínaje indexem start :odstraní deleteCount prvky a poté vloží elem1, ..., elemN na jejich místě. Vrátí pole odstraněných prvků.

Tuto metodu lze snadno pochopit na příkladech.

Začněme s mazáním:

let arr = ["I", "study", "JavaScript"];

arr.splice(1, 1); // from index 1 remove 1 element

alert( arr ); // ["I", "JavaScript"]

Snadné, že? Počínaje indexem 1 odstranilo to 1 prvek.

V dalším příkladu odstraníme 3 prvky a nahradíme je dalšími dvěma:

let arr = ["I", "study", "JavaScript", "right", "now"];

// remove 3 first elements and replace them with another
arr.splice(0, 3, "Let's", "dance");

alert( arr ) // now ["Let's", "dance", "right", "now"]

Zde vidíme, že splice vrátí pole odstraněných prvků:

let arr = ["I", "study", "JavaScript", "right", "now"];

// remove 2 first elements
let removed = arr.splice(0, 2);

alert( removed ); // "I", "study" <-- array of removed elements

splice metoda je také schopna vkládat prvky bez jakéhokoli odstranění. K tomu potřebujeme nastavit deleteCount na 0 :

let arr = ["I", "study", "JavaScript"];

// from index 2
// delete 0
// then insert "complex" and "language"
arr.splice(2, 0, "complex", "language");

alert( arr ); // "I", "study", "complex", "language", "JavaScript"
Záporné indexy jsou povoleny

Zde a v jiných metodách pole jsou povoleny záporné indexy. Určují pozici od konce pole, jako zde:

let arr = [1, 2, 5];

// from index -1 (one step from the end)
// delete 0 elements,
// then insert 3 and 4
arr.splice(-1, 0, 3, 4);

alert( arr ); // 1,2,3,4,5

výřez

Metoda arr.slice je mnohem jednodušší než podobně vypadající arr.splice .

Syntaxe je:

arr.slice([start], [end])

Vrátí nové pole, které do něj zkopíruje všechny položky z indexu start na end (nezahrnuje end ). Oba start a end může být záporná, v takovém případě se předpokládá poloha od konce pole.

Je to podobné řetězcové metodě str.slice , ale místo podřetězců vytváří podpole.

Například:

let arr = ["t", "e", "s", "t"];

alert( arr.slice(1, 3) ); // e,s (copy from 1 to 3)

alert( arr.slice(-2) ); // s,t (copy from -2 till the end)

Můžeme to také volat bez argumentů:arr.slice() vytvoří kopii arr . To se často používá k získání kopie pro další transformace, které by neměly ovlivnit původní pole.

concat

Metoda arr.concat vytvoří nové pole, které obsahuje hodnoty z jiných polí a další položky.

Syntaxe je:

arr.concat(arg1, arg2...)

Přijímá libovolný počet argumentů – buď pole nebo hodnoty.

Výsledkem je nové pole obsahující položky z arr a poté arg1 , arg2 atd.

Pokud je argument argN je pole, pak se zkopírují všechny jeho prvky. Jinak se zkopíruje samotný argument.

Například:

let arr = [1, 2];

// create an array from: arr and [3,4]
alert( arr.concat([3, 4]) ); // 1,2,3,4

// create an array from: arr and [3,4] and [5,6]
alert( arr.concat([3, 4], [5, 6]) ); // 1,2,3,4,5,6

// create an array from: arr and [3,4], then add values 5 and 6
alert( arr.concat([3, 4], 5, 6) ); // 1,2,3,4,5,6

Normálně pouze kopíruje prvky z polí. Ostatní objekty, i když vypadají jako pole, jsou přidány jako celek:

let arr = [1, 2];

let arrayLike = {
 0: "something",
 length: 1
};

alert( arr.concat(arrayLike) ); // 1,2,[object Object]

…Ale pokud má objekt podobný poli speciální Symbol.isConcatSpreadable vlastnost, pak se s ním zachází jako s polem pomocí concat :místo toho jsou přidány jeho prvky:

let arr = [1, 2];

let arrayLike = {
 0: "something",
 1: "else",
 [Symbol.isConcatSpreadable]: true,
 length: 2
};

alert( arr.concat(arrayLike) ); // 1,2,something,else

Opakovat:pro každého

Metoda arr.forEach umožňuje spustit funkci pro každý prvek pole.

Syntaxe:

arr.forEach(function(item, index, array) {
 // ... do something with item
});

Toto například zobrazuje každý prvek pole:

// for each element call alert
["Bilbo", "Gandalf", "Nazgul"].forEach(alert);

A tento kód je podrobnější o jejich pozicích v cílovém poli:

["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {
 alert(`${item} is at index ${index} in ${array}`);
});

Výsledek funkce (pokud nějaký vrátí) je zahozen a ignorován.

Vyhledávání v poli

Nyní se podíváme na metody, které vyhledávají v poli.

indexOf/lastIndexOf a zahrnuje

Metody arr.indexOf a arr.includes mají podobnou syntaxi a dělají v podstatě totéž jako jejich řetězcové protějšky, ale místo znaků fungují s položkami:

  • arr.indexOf(item, from) – hledá item počínaje indexem from a vrátí index, kde byl nalezen, jinak -1 .
  • arr.includes(item, from) – hledá item počínaje indexem from , vrátí true pokud je nalezen.

Obvykle se tyto metody používají pouze s jedním argumentem:item k vyhledávání. Ve výchozím nastavení je hledání od začátku.

Například:

let arr = [1, 0, false];

alert( arr.indexOf(0) ); // 1
alert( arr.indexOf(false) ); // 2
alert( arr.indexOf(null) ); // -1

alert( arr.includes(1) ); // true

Vezměte prosím na vědomí, že indexOf používá přísnou rovnost === pro srovnání. Pokud tedy hledáme false , najde přesně false a ne nula.

Pokud chceme zkontrolovat, zda item existuje v poli a nepotřebuje přesný index, pak arr.includes je preferováno.

Metoda arr.lastIndexOf je stejná jako indexOf , ale hledá zprava doleva.

let fruits = ['Apple', 'Orange', 'Apple']

alert( fruits.indexOf('Apple') ); // 0 (first Apple)
alert( fruits.lastIndexOf('Apple') ); // 2 (last Apple)
includes metoda zpracovává NaN správně

Drobná, ale pozoruhodná vlastnost includes je, že správně zpracovává NaN , na rozdíl od indexOf :

const arr = [NaN];
alert( arr.indexOf(NaN) ); // -1 (wrong, should be 0)
alert( arr.includes(NaN) );// true (correct)

To proto, že includes byl přidán do JavaScriptu mnohem později a interně používá modernější srovnávací algoritmus.

najít a najítIndex/findLastIndex

Představte si, že máme řadu objektů. Jak najdeme objekt se specifickou podmínkou?

Zde se hodí metoda arr.find(fn).

Syntaxe je:

let result = arr.find(function(item, index, array) {
 // if true is returned, item is returned and iteration is stopped
 // for falsy scenario returns undefined
});

Funkce je volána pro prvky pole, jeden po druhém:

  • item je prvkem.
  • index je jeho index.
  • array je pole samotné.

Pokud vrátí true , vyhledávání se zastaví, item je vráceno. Pokud nebylo nic nalezeno, undefined je vráceno.

Máme například pole uživatelů, z nichž každý má pole id a name . Pojďme najít ten s id == 1 :

let users = [
 {id: 1, name: "John"},
 {id: 2, name: "Pete"},
 {id: 3, name: "Mary"}
];

let user = users.find(item => item.id == 1);

alert(user.name); // John

V reálném životě jsou pole objektů běžná věc, takže find metoda je velmi užitečná.

Všimněte si, že v příkladu poskytujeme find funkci item => item.id == 1 s jedním argumentem. To je typické, jiné argumenty této funkce se používají zřídka.

Metoda arr.findIndex má stejnou syntaxi, ale namísto samotného prvku vrací index, kde byl prvek nalezen. Hodnota -1 je vráceno, pokud není nic nalezeno.

Metoda arr.findLastIndex je podobná findIndex , ale vyhledává zprava doleva, podobně jako lastIndexOf .

Zde je příklad:

let users = [
 {id: 1, name: "John"},
 {id: 2, name: "Pete"},
 {id: 3, name: "Mary"},
 {id: 4, name: "John"}
];

// Find the index of the first John
alert(users.findIndex(user => user.name == 'John')); // 0

// Find the index of the last John
alert(users.findLastIndex(user => user.name == 'John')); // 3

filtr

find metoda hledá jeden (první) prvek, který způsobí, že funkce vrátí true .

Pokud jich může být mnoho, můžeme použít arr.filter(fn).

Syntaxe je podobná find , ale filter vrátí pole všech odpovídajících prvků:

let results = arr.filter(function(item, index, array) {
 // if true item is pushed to results and the iteration continues
 // returns empty array if nothing found
});

Například:

let users = [
 {id: 1, name: "John"},
 {id: 2, name: "Pete"},
 {id: 3, name: "Mary"}
];

// returns array of the first two users
let someUsers = users.filter(item => item.id < 3);

alert(someUsers.length); // 2

Transformace pole

Pojďme k metodám, které transformují a mění uspořádání pole.

mapa

Metoda arr.map je jednou z nejužitečnějších a často používaných.

Volá funkci pro každý prvek pole a vrací pole výsledků.

Syntaxe je:

let result = arr.map(function(item, index, array) {
 // returns the new value instead of item
});

Zde například transformujeme každý prvek na jeho délku:

let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
alert(lengths); // 5,7,6

řadit (fn)

Volání arr.sort() seřadí pole na místě , která změní pořadí prvků.

Vrátí také seřazené pole, ale vrácená hodnota je obvykle ignorována jako arr sám je upraven.

Například:

let arr = [ 1, 2, 15 ];

// the method reorders the content of arr
arr.sort();

alert( arr ); // 1, 15, 2

Všimli jste si na výsledku něčeho divného?

Objednávka se stala 1, 15, 2 . Nesprávný. Ale proč?

Položky jsou ve výchozím nastavení seřazeny jako řetězce.

Doslova jsou všechny prvky převedeny na řetězce pro porovnání. Pro řetězce se používá lexikografické řazení a skutečně "2" > "15" .

Abychom mohli použít vlastní pořadí řazení, musíme zadat funkci jako argument arr.sort() .

Funkce by měla porovnat dvě libovolné hodnoty a vrátit:

function compare(a, b) {
 if (a > b) return 1; // if the first value is greater than the second
 if (a == b) return 0; // if values are equal
 if (a < b) return -1; // if the first value is less than the second
}

Chcete-li například seřadit jako čísla:

function compareNumeric(a, b) {
 if (a > b) return 1;
 if (a == b) return 0;
 if (a < b) return -1;
}

let arr = [ 1, 2, 15 ];

arr.sort(compareNumeric);

alert(arr); // 1, 2, 15

Nyní to funguje, jak bylo zamýšleno.

Ustupme stranou a zamysleme se nad tím, co se děje. arr může být řada čehokoli, ne? Může obsahovat čísla nebo řetězce nebo předměty nebo cokoli jiného. Máme sadu některých položek . K jeho třídění potřebujeme funkci řazení který ví, jak porovnat jeho prvky. Výchozí je pořadí řetězců.

arr.sort(fn) metoda implementuje obecný třídicí algoritmus. Nemusí nás zajímat, jak to interně funguje (optimalizovaný quicksort nebo Timsort většinu času). Projde pole, porovná jeho prvky pomocí poskytnuté funkce a změní jejich pořadí, vše, co potřebujeme, je poskytnout fn což dělá srovnání.

Mimochodem, pokud bychom někdy chtěli vědět, které prvky jsou porovnávány – nic nebrání je upozornit:

[1, -2, 15, 2, 0, 8].sort(function(a, b) {
 alert( a + " <> " + b );
 return a - b;
});

Algoritmus může porovnávat prvek s několika dalšími v procesu, ale snaží se provést co nejméně srovnání.

Porovnávací funkce může vrátit libovolné číslo

Ve skutečnosti je porovnávací funkce vyžadována pouze k tomu, aby vrátila kladné číslo, pokud chcete říct „větší“, a záporné číslo, abyste řekli „méně“.

To umožňuje psát kratší funkce:

let arr = [ 1, 2, 15 ];

arr.sort(function(a, b) { return a - b; });

alert(arr); // 1, 2, 15
Šipka funguje pro nejlepší

Pamatujete si funkce šipek? Můžeme je zde použít pro přehlednější třídění:

arr.sort( (a, b) => a - b );

Funguje to úplně stejně jako delší verze výše.

Použijte localeCompare pro struny

Pamatujete si algoritmus porovnávání řetězců? Ve výchozím nastavení porovnává písmena podle jejich kódů.

Pro mnoho abeced je lepší použít str.localeCompare metoda pro správné řazení písmen, jako je Ö .

Seřaďme například několik zemí v němčině:

let countries = ['Österreich', 'Andorra', 'Vietnam'];

alert( countries.sort( (a, b) => a > b ? 1 : -1) ); // Andorra, Vietnam, Österreich (wrong)

alert( countries.sort( (a, b) => a.localeCompare(b) ) ); // Andorra,Österreich,Vietnam (correct!)

zpětně

Metoda arr.reverse obrátí pořadí prvků v arr .

Například:

let arr = [1, 2, 3, 4, 5];
arr.reverse();

alert( arr ); // 5,4,3,2,1

Vrátí také pole arr po obrácení.

rozdělte se a připojte se

Zde je situace z reálného života. Píšeme aplikaci pro zasílání zpráv a osoba zadá seznam příjemců oddělených čárkami:John, Pete, Mary . Ale pro nás by pole jmen bylo mnohem pohodlnější než jeden řetězec. Jak to získat?

Metoda str.split(delim) dělá přesně to. Rozdělí řetězec do pole daným oddělovačem delim .

V níže uvedeném příkladu rozdělujeme čárkou následovanou mezerou:

let names = 'Bilbo, Gandalf, Nazgul';

let arr = names.split(', ');

for (let name of arr) {
 alert( `A message to ${name}.` ); // A message to Bilbo (and other names)
}

split metoda má volitelný druhý číselný argument – ​​omezení délky pole. Pokud je poskytnuta, pak jsou nadbytečné prvky ignorovány. V praxi se však používá zřídka:

let arr = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);

alert(arr); // Bilbo, Gandalf
Rozdělit na písmena

Volání na split(s) s prázdným s by rozdělil řetězec na pole písmen:

let str = "test";

alert( str.split('') ); // t,e,s,t

Volání arr.join(glue) provede opačný postup než split . Vytvoří řetězec arr položky spojené glue mezi nimi.

Například:

let arr = ['Bilbo', 'Gandalf', 'Nazgul'];

let str = arr.join(';'); // glue the array into a string using ;

alert( str ); // Bilbo;Gandalf;Nazgul

zmenšit/zmenšit vpravo

Když potřebujeme iterovat přes pole – můžeme použít forEach , for nebo for..of .

Když potřebujeme iterovat a vrátit data pro každý prvek – můžeme použít map .

Metody arr.reduce a arr.reduceRight také patří k tomuto plemeni, ale jsou o něco složitější. Používají se k výpočtu jedné hodnoty na základě pole.

Syntaxe je:

let value = arr.reduce(function(accumulator, item, index, array) {
 // ...
}, [initial]);

Funkce je aplikována na všechny prvky pole jeden po druhém a „přenáší“ svůj výsledek do dalšího volání.

Argumenty:

  • accumulator – je výsledkem předchozího volání funkce, rovná se initial poprvé (pokud initial je poskytována).
  • item – je aktuální položka pole.
  • index – je jeho pozice.
  • array – je pole.

Když je funkce aplikována, výsledek předchozího volání funkce je předán dalšímu jako první argument.

Takže prvním argumentem je v podstatě akumulátor, který ukládá kombinovaný výsledek všech předchozích provedení. A na konci se stane výsledkem reduce .

Zní to složitě?

Nejjednodušší způsob, jak to pochopit, je příklad.

Zde dostaneme součet pole na jednom řádku:

let arr = [1, 2, 3, 4, 5];

let result = arr.reduce((sum, current) => sum + current, 0);

alert(result); // 15

Funkce předána reduce používá pouze 2 argumenty, to obvykle stačí.

Podívejme se na podrobnosti o tom, co se děje.

  1. Při prvním spuštění sum je initial hodnota (poslední argument z reduce ), rovná se 0 a current je první prvek pole, rovná se 1 . Takže výsledek funkce je 1 .
  2. Při druhém spuštění sum = 1 , přidáme druhý prvek pole (2 ) a vraťte se.
  3. Při 3. spuštění sum = 3 a přidáme k tomu ještě jeden prvek a tak dále…

Postup výpočtu:

Nebo ve formě tabulky, kde každý řádek představuje volání funkce na dalším prvku pole:

sum current výsledek
první hovor 0 1 1
druhý hovor 1 2 3
třetí hovor 3 3 6
čtvrtý hovor 6 4 10
pátý hovor 10 5 15

Zde jasně vidíme, jak se výsledek předchozího volání stává prvním argumentem následujícího.

Můžeme také vynechat počáteční hodnotu:

let arr = [1, 2, 3, 4, 5];

// removed initial value from reduce (no 0)
let result = arr.reduce((sum, current) => sum + current);

alert( result ); // 15

Výsledek je stejný. Je to proto, že pokud není iniciála, pak reduce vezme první prvek pole jako počáteční hodnotu a zahájí iteraci od 2. prvku.

Výpočtová tabulka je stejná jako výše, mínus první řádek.

Takové použití však vyžaduje extrémní opatrnost. Pokud je pole prázdné, pak reduce volání bez počáteční hodnoty dává chybu.

Zde je příklad:

let arr = [];

// Error: Reduce of empty array with no initial value
// if the initial value existed, reduce would return it for the empty arr.
arr.reduce((sum, current) => sum + current);

Proto se doporučuje vždy zadat počáteční hodnotu.

Metoda arr.reduceRight dělá totéž, ale jde zprava doleva.

Array.isArray

Pole netvoří samostatný jazykový typ. Jsou založeny na objektech.

Takže typeof nepomáhá rozlišit prostý objekt od pole:

alert(typeof {}); // object
alert(typeof []); // object (same)

…Ale pole se používají tak často, že na to existuje speciální metoda:Array.isArray(value). Vrátí true pokud value je pole a false jinak.

alert(Array.isArray({})); // false

alert(Array.isArray([])); // true

Většina metod podporuje „thisArg“

Téměř všechny metody pole, které volají funkce – jako find , filter , map , s významnou výjimkou sort , přijměte volitelný další parametr thisArg .

Tento parametr není ve výše uvedených částech vysvětlen, protože se používá zřídka. Ale pro úplnost to musíme pokrýt.

Zde je úplná syntaxe těchto metod:

arr.find(func, thisArg);
arr.filter(func, thisArg);
arr.map(func, thisArg);
// ...
// thisArg is the optional last argument

Hodnota thisArg parametr se změní na this pro func .

Například zde používáme metodu army objekt jako filtr a thisArg předá kontext:

let army = {
 minAge: 18,
 maxAge: 27,
 canJoin(user) {
 return user.age >= this.minAge && user.age < this.maxAge;
 }
};

let users = [
 {age: 16},
 {age: 20},
 {age: 23},
 {age: 30}
];

// find users, for who army.canJoin returns true
let soldiers = users.filter(army.canJoin, army);

alert(soldiers.length); // 2
alert(soldiers[0].age); // 20
alert(soldiers[1].age); // 23

Pokud jsme ve výše uvedeném příkladu použili users.filter(army.canJoin) a poté army.canJoin bude volána jako samostatná funkce s this=undefined , což vede k okamžité chybě.

Volání na číslo users.filter(army.canJoin, army) lze nahradit users.filter(user => army.canJoin(user)) , to dělá to samé. To druhé se používá častěji, protože je pro většinu lidí o něco snazší.

Shrnutí

Cheat sheet metod pole:

  • Chcete-li přidat/odebrat prvky:

    • push(...items) – přidává položky na konec,
    • pop() – vyjme položku z konce,
    • shift() – extrahuje položku od začátku,
    • unshift(...items) – přidá položky na začátek.
    • splice(pos, deleteCount, ...items) – na indexu pos smaže deleteCount prvky a vložky items .
    • slice(start, end) – vytvoří nové pole, zkopíruje prvky z indexu start do end (nevčetně) do něj.
    • concat(...items) – vrátí nové pole:zkopíruje všechny členy aktuálního pole a přidá items k tomu. Pokud některý z items je pole, pak se převezmou jeho prvky.
  • Chcete-li vyhledávat mezi prvky:

    • indexOf/lastIndexOf(item, pos) – vyhledejte item od pozice pos , vraťte index nebo -1 pokud nebyl nalezen.
    • includes(value) – vrátí true pokud má pole value , jinak false .
    • find/filter(func) – filtrovat prvky přes funkci, vracet první/všechny hodnoty, díky kterým vrací true .
    • findIndex je jako find , ale místo hodnoty vrátí index.
  • Iterace přes prvky:

    • forEach(func) – zavolá func pro každý prvek nic nevrací.
  • Transformace pole:

    • map(func) – vytvoří nové pole z výsledků volání func pro každý prvek.
    • sort(func) – seřadí pole na místě a poté jej vrátí.
    • reverse() – obrátí pole na místě a poté jej vrátí.
    • split/join – převést řetězec na pole a zpět.
    • reduce/reduceRight(func, initial) – vypočítat jednu hodnotu přes pole voláním func pro každý prvek a předání mezivýsledku mezi voláními.
  • Navíc:

    • Array.isArray(value) kontroluje value protože se jedná o pole, pokud ano, vrátí true , jinak false .

Vezměte prosím na vědomí, že metody sort , reverse a splice upravit samotné pole.

Tyto metody jsou nejpoužívanější, pokrývají 99 % případů užití. Ale existuje několik dalších:

  • arr.some(fn)/arr.every(fn) zkontrolujte pole.

    Funkce fn se volá na každý prvek pole podobně jako map . Pokud jsou všechny výsledky true , vrátí true , jinak false .

    Tyto metody se chovají podobně jako || a && operátory:if fn vrátí pravdivou hodnotu, arr.some() okamžitě vrátí true a přestane opakovat zbytek položek; pokud fn vrátí falešnou hodnotu, arr.every() okamžitě vrátí false a přestane iterovat i přes zbytek položek.

    Můžeme použít every pro porovnání polí:

    function arraysEqual(arr1, arr2) {
     return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
    }
    
    alert( arraysEqual([1, 2], [1, 2])); // true
  • arr.fill(value, start, end) – vyplní pole opakováním value z indexu start na end .

  • arr.copyWithin(target, start, end) – zkopíruje své prvky z pozice start do pozice end do sebe , na pozici target (přepíše existující).

  • arr.flat(depth)/arr.flatMap(fn) vytvoří nové ploché pole z vícerozměrného pole.

Úplný seznam naleznete v příručce.

Na první pohled se může zdát, že existuje tolik metod, které jsou jen těžko zapamatovatelné. Ale ve skutečnosti je to mnohem jednodušší.

Podívejte se přes cheat sheet, abyste si jich byli vědomi. Poté vyřešte úkoly z této kapitoly k procvičení, abyste měli zkušenosti s metodami pole.

Poté, kdykoli budete potřebovat něco udělat s polem, a nebudete vědět jak – pojďte sem, podívejte se na cheat sheet a najděte správnou metodu. Ke správnému zápisu vám pomohou příklady. Brzy si metody automaticky zapamatujete, aniž byste se museli nějak zvlášť snažit.