Return to Video

Typy objektů

  • 0:01 - 0:03
    Teď, když už znáte
    základy Javascriptu,
  • 0:03 - 0:06
    ukážu vám jeden skvělý
    způsob, jak ho používat.
  • 0:06 - 0:10
    A tím způsobem je objektově
    orientované programování.
  • 0:10 - 0:12
    Nejdříve musíme pochopit,
    proč je to vlastně užitečné.
  • 0:12 - 0:14
    Takže mám tady program,
  • 0:14 - 0:18
    který by byl mnohem lepší,
    kdyby byl objektově orientován.
  • 0:18 - 0:20
    Program jako takový
    je docela dobrý.
  • 0:20 - 0:21
    Nahoře máme dvě proměnné,
  • 0:21 - 0:25
    které v sobě ukládají
    jednoduché literály objektů.
  • 0:25 - 0:29
    Literál objektu je druh objektu,
    se kterým jsme se už setkali.
  • 0:29 - 0:31
    Vytvoříme ho pomocí
    dvou složených závorek,
  • 0:31 - 0:34
    do kterých pak vložíme všechny
    názvy vlastností a hodnot.
  • 0:34 - 0:37
    Takže máme dvě proměnné
    těchto objektových literálů.
  • 0:37 - 0:41
    A pak zde dole máme funkci drawWinston,
    která očekává jenom jeden argument.
  • 0:41 - 0:43
    Nakonec vykreslí argument,
  • 0:43 - 0:48
    a to tak, že nakreslí obrázek na
    základě x a y vlastností objektu.
  • 0:48 - 0:53
    Následuje titulek založený na
    jménu a věku tohoto objektu.
  • 0:53 - 0:56
    Nakonec úplně dole
    zavoláme drawWinston.
  • 0:56 - 0:59
    Nejprve na dospívajícího Winstona
    a pak na dospělého Winstona.
  • 0:59 - 1:01
    A díky tomu se objeví.
  • 1:02 - 1:07
    Když teď půjdeme sem nahoru
    a podíváme se na objektové literály,
  • 1:07 - 1:09
    možná si na nich něco všimnete.
  • 1:09 - 1:11
    Jde o to, že vypadají
    opravdu podobně.
  • 1:11 - 1:14
    Oba mají stejné sady vlastností,
  • 1:14 - 1:18
    a oba mohou být ovládány pomocí
    stejné funkce drawWinston.
  • 1:18 - 1:20
    Když nad tím zapřemýšlíte,
  • 1:20 - 1:24
    tak si uvědomíte, že oba
    literály popisují typ Winstona.
  • 1:24 - 1:29
    Můžeme o tom přemýšlet jako o
    abstraktním typu Winstona ve světě.
  • 1:29 - 1:32
    A každý Winston má
    stejnou sadu vlastností.
  • 1:32 - 1:36
    Jako jméno, věk, x a y.
  • 1:36 - 1:42
    Takže jsme zde vlastně
    vytvořili dvě instance Winstona,
  • 1:42 - 1:45
    které popisují konkrétního Winstona.
  • 1:45 - 1:48
    Těmi jsou dospívající Winston
    a dospělý Winston.
  • 1:48 - 1:55
    Opravdu jsou si oba velmi podobní
    a mají spustu věcí společných.
  • 1:55 - 1:58
    Pokud se zamyslíte, tak ve světě
    to funguje velmi podobně.
  • 1:58 - 2:01
    Máme abstraktní datové
    typy jako například lidé.
  • 2:01 - 2:04
    A my všichni jsme pak
    konkrétní instancí těchto typů.
  • 2:04 - 2:06
    Ale máme naše
    jedinečné vlastnosti.
  • 2:06 - 2:10
    Teď využijeme objektově
    orientované techniky v Javascriptu.
  • 2:10 - 2:18
    Uděláme tyto proměnné Winstona
    formálními instancemi objektu Winston.
  • 2:18 - 2:22
    Takže instance vědí, že
    společně sdílejí určité věci.
  • 2:22 - 2:25
    Abychom to provedli,
    potřebujeme jednu věc.
  • 2:25 - 2:30
    Popsat tento abstraktní datový
    typ Winstona a udělat z něj proměnnou.
  • 2:30 - 2:33
    Datový typ uložíme do proměnné.
  • 2:33 - 2:35
    Takže napíšeme var Winston,
    uděláme velké W,
  • 2:35 - 2:39
    protože vždy začínáme
    naše typy objektů velkým písmenem,
  • 2:39 - 2:42
    a nastavíme to tak,
    že se to rovná funkci.
  • 2:42 - 2:47
    Tato funkce je speciální funkce,
    kterou nazýváme "konstruktor".
  • 2:47 - 2:49
    Protože se jedná o to,
    co se volá pokaždé,
  • 2:49 - 2:52
    když chceme vytvořit novou
    instanci Winstona.
  • 2:52 - 2:56
    Takže když chceme vytvořit dospívajícího
    Winstona, volá se tato funkce.
  • 2:56 - 2:58
    A když chceme dospělého Winstona,
    volá se funkce znovu.
  • 2:58 - 3:03
    To znamená, že tato funkce by
    měla obsahovat všechny argumenty,
  • 3:03 - 3:06
    které potřebuje pro vytvoření
    kompletního Winstona.
  • 3:06 - 3:11
    V tomto případě musí obsahovat
    jméno, věk, x a y.
  • 3:11 - 3:15
    Jakmile máme tyto argumenty,
    musíme s nimi něco udělat.
  • 3:15 - 3:21
    Musíme tyto informace
    připojit k objektu Winston.
  • 3:21 - 3:25
    A k tomu použijeme speciální
    klíčové slovo "this".
  • 3:25 - 3:29
    A "this" bude odkazovat
    k aktuální instanci objektu.
  • 3:29 - 3:32
    Takže napíšeme this.nickname.
  • 3:32 - 3:38
    Název vlastnosti tohoto objektu
    se rovná obsahu funkce konstruktoru.
  • 3:38 - 3:42
    A this.age se rovná věku,
    který vložíme.
  • 3:42 - 3:45
    A this.x se rovná hodnotě x,
    kterou vložíme.
  • 3:45 - 3:47
    A this.y se rovná y,
    které vložíme.
  • 3:47 - 3:53
    Tak a teď máme tento abstraktní
    datový typ s názvem Winston.
  • 3:53 - 3:56
    A má funkci konstruktoru, kterou
    můžeme použít k vytvoření nového Winstona.
  • 3:57 - 3:59
    Zkusme to použít!
  • 4:00 - 4:03
    Budeme znovu vytvářet winstonTeen,
  • 4:03 - 4:05
    ale tentokrát napíšeme
    winstonTeen se rovná.
  • 4:05 - 4:10
    A místo složených závorek
    napíšeme rovná se "new Winston".
  • 4:10 - 4:14
    Tím říkáme, že zkoušíme
    vytvořit novou instanci Winstona.
  • 4:14 - 4:16
    A pak vložíme informace,
    které instance potřebuje.
  • 4:16 - 4:21
    Takže "Winsteen", "15", "20", "50".
  • 4:22 - 4:27
    Pak můžeme tento starý kód smazat,
    protože ho už nepotřebujeme.
  • 4:27 - 4:30
    Takže teď jsme vytvořily
    nového Winsteena.
  • 4:31 - 4:36
    Nyní můžeme napsat
    winstonAdult = new Winston ().
  • 4:36 - 4:40
    A samozřejmě jeho jméno je
    "Pane Winst-a-lot".
  • 4:41 - 4:45
    Je mu 30 let a nachází se
    na pozicích 229 a 50.
  • 4:45 - 4:51
    Poté můžeme smazat tento literál
    a náš kód bude pořád fungovat.
  • 4:51 - 4:54
    Co jsme udělali je to,
    že jsme řekli,
  • 4:54 - 4:58
    že máme tento druh abstraktního
    typu dat, což je tento Winston,
  • 4:58 - 5:01
    a můžeme vytvořit
    nové instance Winstona,
  • 5:01 - 5:05
    které mají tyto vlastnosti,
    které jsou pro ně jedinečné.
  • 5:05 - 5:09
    Tyto vlastnosti uvnitř
    si budeme pamatovat.
  • 5:09 - 5:11
    Pamatování je opravdu důležité.
  • 5:11 - 5:14
    Takže tady máme:
    this.nickname, this.age.
  • 5:14 - 5:20
    Pokud bychom náhodou this.age neměli,
    konzole nám řekne "nedefinováno".
  • 5:20 - 5:23
    To proto, že tady dole,
    tato funkce drawWinston,
  • 5:23 - 5:28
    očekává, že ať už dostane jakýkoli objekt,
    očekává, že bude mít vlastnost "age".
  • 5:28 - 5:32
    A pokud jsme nenapsali this.age,
    pak to tuto vlastnost nemá.
  • 5:32 - 5:35
    Předali jsme ji konstruktoru,
    ale pak jsme s tím nic nedělali.
  • 5:35 - 5:39
    Musíme to k objektu připojit
    pomocí klíčového slova "this".
  • 5:40 - 5:42
    Dáme to zpět.
  • 5:42 - 5:46
    Možná si říkáte, že
    váš kód přece funguje,
  • 5:46 - 5:50
    ale de facto jsme udělali
    to samé, co jsme měli předtím.
  • 5:50 - 5:52
    Ale je na tom
    jedna skvělá věc.
  • 5:52 - 5:56
    Teď všichni naši Winstoni prochází
    stejnou funkcí konstruktoru.
  • 5:56 - 6:01
    Takže pokud chceme, můžeme
    o Winstonovi některé věci změnit.
  • 6:01 - 6:03
    O všech Winstonech,
    a to tady uvnitř.
  • 6:03 - 6:06
    Takže možná chceme upravit věk a
    připojit k němu na konec "yrs old".
  • 6:06 - 6:10
    Můžeme to prostě dát sem,
    a tím se ke všem Winstonům připíše:
  • 6:10 - 6:13
    "15 let", "30 let" atd.
  • 6:13 - 6:15
    Takže tato část
    o nich je jedinečná,
  • 6:15 - 6:17
    ale pak mají taky věci,
    které jsou společné.
  • 6:17 - 6:20
    A skvělou věcí na objektově
    orientovaném programování je to,
  • 6:20 - 6:23
    že na světě existuje
    spousta druhů předmětů,
  • 6:23 - 6:26
    ze kterých můžete
    vytvářet instance.
  • 6:26 - 6:28
    V některých věcech
    jsou si velmi podobny.
  • 6:28 - 6:30
    Všechny mají řadu
    stejných vlastnosti.
  • 6:30 - 6:31
    Pak jsou věci,
    které jsou odlišné.
  • 6:31 - 6:35
    Jako například tato vlastnost,
    která je ve skutečnosti jiná hodnota,
  • 6:35 - 6:36
    než tato jiná vlastnost.
  • 6:36 - 6:41
    Dále pak s nimi můžeme dělat
    stejné věci, jako volat stejné funkce.
  • 6:41 - 6:43
    A používat je podobným způsobem.
  • 6:43 - 6:46
    To je jen několik skvělých věcí na
    objektově orientovaném programování.
  • 6:46 - 6:49
    Ale jak uvidíte,
    je toho mnohem víc!
  • 6:49 - 6:50
    Takže se máte na co těšit.
Title:
Typy objektů
Description:

Pamela vysvětluje první část objektově orientovaného programování: vytváření typů objektů a jejich instancí.

more » « less
Video Language:
English
Duration:
06:51

Czech subtitles

Revisions Compare revisions