learnxinyminutes-docs/cs-cz/hack.html.markdown
Vojta Svoboda 0edf991301 [hack/cs] Add cs_CZ locale for Hack
* [hack/cs] Add cs_CZ locale for Hack

* Add -cs suffix

Add -cs suffix
2016-04-15 12:08:55 +02:00

310 lines
7.5 KiB
Markdown

---
language: Hack
filename: learnhack-cs.hh
contributors:
- ["Stephen Holdaway", "https://github.com/stecman"]
translators:
- ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
lang: cs-cz
---
Hack je nadmnožinou PHP a běží v rámci virtuálního stroje zvaného HHVM. Hack
dokáže skoro plně spolupracovat s existujícím PHP a přidává několik vylepšení,
které známe ze staticky typovaných jazyků.
Níže jsou popsané pouze vlastnosti jazyka Hack. Detaily ohledně jazyka PHP a jeho
syntaxe pak najdete na těchto stránkách v samostatném
[článku o PHP](http://learnxinyminutes.com/docs/php/).
```php
<?hh
// Hack je aktivní pouze pro soubory, které začínají <?hh.
// TODO <?hh soubory nemohou být jendoduše přeloženy v HTML tak jako <?php.
// Použitím značky <?hh //strict zapnete striktní mód typové kontroly.
// Typování skalární parametrů
function repeat(string $word, int $count)
{
$word = trim($word);
return str_repeat($word . ' ', $count);
}
// Typování návratových hodnot
function add(...$numbers) : int
{
return array_sum($numbers);
}
// Funkce které nic nevrací jsou typované jako "void"
function truncate(resource $handle) : void
{
// ...
}
// U typování musíme explicitně povolit prázdné (null) hodnoty
function identity(?string $stringOrNull) : ?string
{
return $stringOrNull;
}
// Typování může být použito i na proměnné třídy
class TypeHintedProperties
{
public ?string $name;
protected int $id;
private float $score = 100.0;
// Typ proměnné si můžeme zadat přímo u definice proměnné v rámci třídy,
// ale pak ho snadně přetížit v konstruktoru metody.
public function __construct(int $id)
{
$this->id = $id;
}
}
// Stručné anonymní funkce (lambda funkce)
$multiplier = 5;
array_map($y ==> $y * $multiplier, [1, 2, 3]);
// Generika (generické funkce)
class Box<T>
{
protected T $data;
public function __construct(T $data) {
$this->data = $data;
}
public function getData(): T {
return $this->data;
}
}
function openBox(Box<int> $box) : int
{
return $box->getData();
}
// Tvary
//
// Hack zavádí koncept tvaru pro definování strukturovaných polí s garantovanou
// typovou kontrolou pro klíče.
type Point2D = shape('x' => int, 'y' => int);
function distance(Point2D $a, Point2D $b) : float
{
return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
}
distance(
shape('x' => -1, 'y' => 5),
shape('x' => 2, 'y' => 50)
);
// Type aliasing
//
// Hack přidává několik vylepšení pro lepší čitelnost komplexních typů
newtype VectorArray = array<int, Vector<int>>;
// Množina obsahující čísla
newtype Point = (int, int);
function addPoints(Point $p1, Point $p2) : Point
{
return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
}
addPoints(
tuple(1, 2),
tuple(5, 6)
);
// Výčtový typ
enum RoadType : int
{
Road = 0;
Street = 1;
Avenue = 2;
Boulevard = 3;
}
function getRoadType() : RoadType
{
return RoadType::Avenue;
}
// Automatické nastavení proměnných třídy
//
// Aby se nemuseli definovat proměnné třídy a její konstruktor,
// který pouze nastavuje třídní proměnné, můžeme v Hacku vše
// definovat najednou.
class ArgumentPromotion
{
public function __construct(public string $name,
protected int $age,
private bool $isAwesome) {}
}
// Takto by to vypadalo bez automatického nastavení proměnných
class WithoutArugmentPromotion
{
public string $name;
protected int $age;
private bool $isAwesome;
public function __construct(string $name, int $age, bool $isAwesome)
{
$this->name = $name;
$this->age = $age;
$this->isAwesome = $isAwesome;
}
}
// Ko-operativní multi-tasking
//
// Nová klíčová slova "async" and "await" mohou být použité pro spuštění mutli-taskingu
// Tato vlastnost ovšem zahrnuje vícevláknové zpracování, pouze povolí řízení přenosu
async function cooperativePrint(int $start, int $end) : Awaitable<void>
{
for ($i = $start; $i <= $end; $i++) {
echo "$i ";
// Dává ostatním úlohám šanci něco udělat
await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
}
}
// Toto vypíše "1 4 7 2 5 8 3 6 9"
AwaitAllWaitHandle::fromArray([
cooperativePrint(1, 3),
cooperativePrint(4, 6),
cooperativePrint(7, 9)
])->getWaitHandle()->join();
// Atributy
//
// Atributy jsou určitou formou metadat pro funkce. Hack přidává některé vestavěné
// atributy které aktivnují uživatečné chování funkcí.
// Speciální atribut __Memoize způsobí, že výsledek funkce je uložen do cache
<<__Memoize>>
function doExpensiveTask() : ?string
{
return file_get_contents('http://example.com');
}
// Tělo funkce je v tomto případě vykonáno pouze jednou:
doExpensiveTask();
doExpensiveTask();
// Speciální atribut __ConsistentConstruct signalizuje typové kontrole Hacku, že
// zápis __construct bude stejný pro všechny podtřídy.
<<__ConsistentConstruct>>
class ConsistentFoo
{
public function __construct(int $x, float $y)
{
// ...
}
public function someMethod()
{
// ...
}
}
class ConsistentBar extends ConsistentFoo
{
public function __construct(int $x, float $y)
{
// Typová kontrola Hacku zajistí volání konstruktoru rodičovské třídy
parent::__construct($x, $y);
// ...
}
// Anotace __Override je volitelný signál pro typovou kontrolu Hacku, že
// tato metoda přetěžuje metodu rodičovské třídy, nebo traitu. Bez uvedení
// této anotace vyhodí typová kontrola chybu.
<<__Override>>
public function someMethod()
{
// ...
}
}
class InvalidFooSubclass extends ConsistentFoo
{
// Nedodržení zápisu dle rodičovského konstruktoru způsobí syntaktickou chybu:
//
// "Tento objekt je typu ConsistentBaz a není kompatibilní v tímto objektem,
// který je typu ConsistentFoo protože některé jeho metody nejsou kompatibilní."
//
public function __construct(float $x)
{
// ...
}
// Použitím anotace __Override na nepřetíženou metodu způsobí chybu typové kontroly:
//
// "InvalidFooSubclass::otherMethod() je označená jako přetížená, ale nebyla nalezena
// taková rodičovská metoda, nebo rodič kterého přetěžujete není zapsán v <?hh kódu"
//
<<__Override>>
public function otherMethod()
{
// ...
}
}
// Traity mohou implementovat rozhraní, což standardní PHP neumí
interface KittenInterface
{
public function play() : void;
}
trait CatTrait implements KittenInterface
{
public function play() : void
{
// ...
}
}
class Samuel
{
use CatTrait;
}
$cat = new Samuel();
$cat instanceof KittenInterface === true; // True
```
## Více informací
Pro více informací navštivte [referenční příručku jazyka Hack](http://docs.hhvm.com/manual/en/hacklangref.php),
kde se dozvíte více detailu a vylepšení, které jazyk Hack přidává do PHP, a nebo navštivte [oficiální stránky jazyka Hack](http://hacklang.org/)
pro obecné informace.
Pro instrukce k instalaci jazyka Hack navštivte [oficiální HHVM stránky](http://hhvm.com/).
Pro více informací ohledně zpětné kompatibility s PHP navštivte článek o [nepodporovaných PHP vlastnostech Hacku](http://docs.hhvm.com/manual/en/hack.unsupported.php).