2. díl - Swift - Pole, funkce, operátory

Ostatní jazyky Swift Swift - Pole, funkce, operátory

Pole

Z minulého dílu zhruba víme, co je to pole. Abychom to shrnuli, pole je seznam hodnot jednoho typu. Není omezeno délkou, pouze typem.

Swift podporuje spojování polí pomocí operátoru + a přidávání hodnot do pole pomocí metody append.

Položky do pole lze tedy přidávat dvěma způsoby:

var pole: [String] = ["Ahoj"]

pole = pole + ["světe"] // Pomocí operátoru (závorky jsou zde důležité, přičtené pole bude "rozbaleno",
                      // takže pokud chceme pole vnořit, musíme uvést dvoje závorky - tedy pole v poli)

pole.append("!") // Pomocí metody (zde už závorky nejsou, pokud do pole vyloženě nechcete vnořit jiné)

Pole také nabízí množství atributů a metod. Například:

var pole = ["Ahoj", "světe", "světe"]

pole.count // 3, Počet položek
pole.contains("!") // false, Obsahuje položku?
pole.indexOf("světe") // 1, Poloha první nalezené položky
pole.insert("!", atIndex: 2) // Vloží položku na konkrétní místo v poli
pole.isEmpty // false, Je pole prázdné?
pole.removeAtIndex(2) // Smaže položku na konkrétním místě

Dále můžeme použít metody:

  • pole.sort() - uspořádá pole
  • pole.reverse() - převrátí pole pozpátku

a konstanty:

  • pole.first - první položka
  • pole.last - poslední položka.

Pokud potřebujeme rychle inicializovat pole s opakujícími se položkami, použijeme tento inicializátor:

var pole = [TypPole](count: kolikJichChceme, repeatedValue: hodnota)

Do pole můžeme přiřazovat:

pole[index] = hodnota
pole[zač...konec] = [položky] // Délka přiřazovaného pole nemusí být stejně dlouhá jako výseč, do které přiřazujeme.

Vícetypové Pole (struktura)

Co když chceme mít v jednom poli informace o uživateli - jméno, věk, a jestli je to muž? Na to samozřejmě potřebujeme tři různé typy.

Ve Swiftu existují dva speciální datové typy, které jsou základem všech existujících.

Je to Any (předek všech typů a hodnot) a AnyObject (předek všech tříd).

Any používáme, když potřebujeme ukládat i primitivní typy. AnyObject používáme, pokud chceme ukládat pouze instance tříd.

Uživatele tedy uložíme takto:

let janNovakInfo: AnyObject = ["Jan Novák", 28, true]

AnyObject používáme, pokud jde o třídu. Zatímco Any obsahuje úplně všechno, i primitivní datové typy. My budeme nejčastěji používat AnyObject.

Vícedimenzionální pole

Ale co pokud budeme chtít ukládat mnoho uživatelů tímto způsobem?

Rozhodně to neuděláme takto:

let u1: [AnyObject] = ["Jan Novák", 28, true]
let u2: [AnyObject] = ["Johanna Rychlá", 75, false]
// atd...

Nebo takto:

let uživatelé: [AnyObject] = ["Jan Novák", 28, true, "Johanna Rychlá", 75, false]

Použijeme tzv. vícedimenzionální pole:

var uživatelé: [[AnyObject]] = [["Jan Novák", 28, true], ["Johanna Rychlá", 75, false]]

Poznámka: Tento způsob je také velice neotřepaný, slouží spíš jako demonstrace vícedimenzionálních polí, v praxi použijeme pole tříd, na které se podíváme v budoucích dílech.

V podstatě je to pole v poli a může to být také pole v poli v poli v poli... Čím více bude typ "obalen" hranatými závorkami, tím více polí bude vnořeno.

Teoreticky bychom to mohli udělat takto:

var uživatelé: [AnyObject] = [["Jan Novák", 28, true], ["Johanna Rychlá", 75, false]]

Jelikož pole je typu Array a všechny objekty dědí z objektu AnyObject, je tento kód validní. Zároveň je ale poněkud nepřehledný.

Někdo by totiž mohl udělat toto:

var uživatelé: [AnyObject] = [["Jan Novák", 28, true], ["Johanna Rychlá", 75, false]]

uživatelé.append("Ahoj světe!") // Aplikace by nefungovala, jak si představujeme - očekává pole.

Složené operátory

Operátor přiřazení (=) můžeme skládat s jinými operátory.

Příklad:

var proměnná: Int = 13

proměnná += 5 // proměnná = proměnná + 5
proměnná /= 2 // proměnná = proměnná / 2

proměnná %= 4 // Modulo, zbytek po dělení - proměnná = proměnná % 4

Funkce

Funkce je konstrukce, která obsahuje kód, který se vykoná při každém jejím zavolání. Většinou má i návratovou hodnotu, ale není to nutné. Používá se typicky, pokud máme blok kódu, který chceme spustit vícekrát s jinými hodnotami.

Zapisuje se takto:

func jméno(parametry) -> NávratovýTyp {
    // Kód
}

Pokud nebudeme z naší funkce nic vracet, šipku a návratový typ vynecháme. Ani parametry nejsou povinné (v tom případě tam necháme prázdné závorky).

Parametry se zapisují jako proměnná bez slova var a bez hodnoty. Příklad: jméno: Typ

Příklad:

func jakoString(hodnota: AnyObject) -> String {
    return String(hondota) // Příkaz 'return' slouží k ukončení funkce a vrácení hodnoty.
}

let hodnota: Bool = true
let výsledek: String = jakoString(hodnota) // Funkce se volá jako konstruktor.

Ve funkci bez návratové hodnoty můžeme použít return pro její předčasné ukončení.

Zkusíme si opět nají chyby:

Příklad 1:

func jméno() -> {
    return "Ahoj"
}

let něco: Int = jméno()

Příklad 2:

func funkce(parametr: Any) -> String {
    return
}

let něco: Int = funkce(true)

Příklad 3:

func funkce() {
    return 13
}

let něco: Int = funkce() + 5

Příklad 1: Neplatná syntaxe u '->', typ byl vynechán.
Příklad 2: U 'return' byla očekávána hodnota typu String.
Příklad 3: Funkce vrací Int, i když je nadefinována bez návratové hodnoty.

Parametry

Parametry funkcí mohou být různé. U všech typů závisí na pozici.

Klasické parametry:
func fn(param: AnyObject) -> AnyObject {
    return param
}

fn("Ahoj")
Pojmenované:
func fn(jméno hodnota: AnyObject) -> AnyObject {
    return hodnota // K pojmenovanému parametru se zevnitř přistupuje přes jeho jméno u dvojtečky.
}

fn(jméno: "Ahoj světe!") // K pojmenovanému parametru se zvenčí přistupuje přes jeho jméno.
Parametry s výchozí hodnotou:
func fn(hodnota: String = "Hodnota") -> String {
    return hodnota
}

fn("Něco") // "Něco"
fn() // "Hodnota", pokud ho nevyplníme, načte se jeho výchozí hodnota.
Variadické parametry:
func fn(čísla: Double...) -> [Double] { // Double je reálné číslo.
    return čísla
}

fn(1, 2, 3.5, 4, 5) // [1.0, 2.0, 3.5, 4.0, 5.0]
fn() // []

Variadický parametr musí být uveden jako poslední (v každé funkci může být tedy jen jeden) a akceptuje nula nebo více hodnot daného typu (v příkladu Double). Tyto parametry jsou pak ve funkci k dispozici jako pole. Variadické parametry a parametry s výchozí hodnotou lze samozřejmě také pojmenovat.

Příště se podíváme na volitelné typy a třídy.


 

  Aktivity (5)

Článek pro vás napsal jan.ruzicka01
Avatar
Autor se věnuje programovaní v Pythonu, Ruby, Javě a trochu C#. Dříve tvořil aplikace v C/C++. Nyní se zajímá o webové technologie a tvorbu virtuálních strojů (/programovacího jazyka).

Jak se ti líbí článek?
Celkem (2 hlasů) :
3.53.53.53.5 3.5


 


Miniatura
Předchozí článek
Úvod do jazyka Swift
Miniatura
Všechny články v sekci
Swift

 

 

Komentáře

Avatar
David Novák
Tým ITnetwork
Avatar
David Novák:

Jak je to, když použiješ mnohonásobný parametr a chceš použít i jiné? Mnohonásobný musí být poslední?

Odpovědět 27.8.2015 9:57
Chyba je mezi klávesnicí a židlí.
Avatar
Dominik Gavrecký:

Ešte keby doriešili xcode ... Inač mi je to k ničomu :/

Odpovědět 27.8.2015 17:04
Hlupák nie je ten kto niečo nevie, hlupákom sa stávaš v momente keď sa na to bojíš opýtať.
Avatar
coells
Redaktor
Avatar
Odpovídá na David Novák
coells:

Variadické parametry (nikoliv mnohonásobné) musí být za všemi ostatními parametry včetně parametrů s implicitní hodnotou.

 
Odpovědět  +1 27.8.2015 17:31
Děláme co je v našich silách, aby byly zdejší diskuze co nejkvalitnější. Proto do nich také mohou přispívat pouze registrovaní členové. Pro zapojení do diskuze se přihlas. Pokud ještě nemáš účet, zaregistruj se, je to zdarma.

Zobrazeno 3 zpráv z 3.