Development

Documentation/cs_CZ/book/1.0/02-Exploring-Symfony-s-Code (diff)

You must first sign up to be able to contribute.

Changes between Version 15 and Version 16 of Documentation/cs_CZ/book/1.0/02-Exploring-Symfony-s-Code

Show
Ignore:
Author:
Vit.Kotacka (IP: 85.160.96.204)
Timestamp:
07/31/07 21:51:37 (10 years ago)
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • Documentation/cs_CZ/book/1.0/02-Exploring-Symfony-s-Code

    v15 v16  
    562562 
    563563>**POZNÁMKA** 
    564  
    565 >**NOTE** 
    566 >The `config/`, `lib/`, and `validate/` directories are empty for a new module. 
    567  
    568 #### Web Tree Structure 
    569  
    570 There are very few constraints for the `web` directory, which is the directory of publicly accessible files. Following a few basic naming conventions will provide default behaviors and useful shortcuts in the templates. Here is an example of a `web` directory structure: 
     564>Adresáře `config/`, `lib/` a `validate/` jsou u nového modulu prázdné. 
     565 
     566#### Webová stromová struktura 
     567 
     568Pro adresář `web`, který obsahuje veřejně přístupné soubory, existuje několik málo omezení. Pár následujících jmenných konvencí bude poskytovat výchozí chování a užitečné zkratky v šablonách. Příklad adresářové struktury v adresáři `web`: 
    571569 
    572570    web/ 
    576574      uploads/ 
    577575 
    578 Conventionally, the static files are distributed in the directories listed in Table 2-4
    579  
    580 Table 2-4 - Typical Web Subdirectories 
    581  
    582 Directory  | Description 
     576Obvykle jsou statické soubory rozděleny do následujících adresářů (Tabulka 2-4)
     577 
     578Tabulka 2-4 - Typické webové podadresáře 
     579 
     580Adresář    | Popis 
    583581---------- | ----------- 
    584 `css/`     | Contains style sheets with a `.css` extension
    585 `images/`  | Contains images with a `.jpg`, `.png`, or `.gif` format
    586 `js/`      | Holds JavaScript files with a `.js` extension
    587 `uploads/` | Must contain the files uploaded by the users. Even though the directory usually contains images, it is distinct from the images directory so that the synchronization of the development and production servers does not affect the uploaded images
    588  
    589 >**NOTE** 
    590 >Even though it is highly recommended that you maintain the default tree structure, it is possible to modify it for specific needs, such as to allow a project to run in a server with different tree structure rules and coding conventions. Refer to Chapter 19 for more information about modifying the file tree structure
    591  
    592 Common Instruments 
    593 ------------------ 
    594  
    595 A few techniques are used repeatedly in symfony, and you will meet them quite often in this book and in your own projects. These include parameter holders, constants, and class autoloading
    596  
    597 ### Parameter Holders 
    598  
    599 Many of the symfony classes contain a parameter holder. It is a convenient way to encapsulate attributes with clean getter and setter methods. For instance, the sfResponse class holds a parameter holder that you can retrieve by calling the `getParameterHolder()` method. Each parameter holder stores data the same way, as illustrated in Listing 2-15. 
    600  
    601 Listing 2-15 - Using the `sfResponse` Parameter Holder 
     582`css/`     | Obsahuje stylopisy s příponou `.css`
     583`images/`  | Obsahuje obrázky ve formátu`.jpg`, `.png`, nebo `.gif`
     584`js/`      | Obsahuje JavaScriptové soubory s příponou `.js`
     585`uploads/` | Je určen pro soubory uploadované uživateli. Ačkoliv adresář většinou obsahuje obrázky, je oddělen od adresáře images, takže pokud dojde k synchronizaci vývojového a produkčního serveru, nijak to neovlivní uploadované soubory
     586 
     587>**POZNÁMKA** 
     588>Ačkoliv je silně doporučeno dodržovat výchozí stromovou strukturu, je možné ji podle potřeb modifikovat, například pokud je potřeba provozovat projekt na serveru s odlišně definovanou stromovou strukturou a kódovacími konvencemi. O úpravě stromové struktury souborů pojednává Kapitola 19
     589 
     590Společné nástroje 
     591----------------- 
     592 
     593V symfony se opakovaně používá několik technik, které budete v této knize dosti často potkávat a také ve vašich projektech. Tyto zahrnují zásobníky parametrů, konstanty a automatické zavádění tříd
     594 
     595### Zásobníky parametrů 
     596 
     597Mnoho tříd v symfony obsahuje zásobník parametrů. Je to vhodný způsob zapouzdření atributů pomocí transparentních getter a setter metod. Třída sfResponse například obsahuje zásobník parametrů, který můžete získat voláním metody `getParameterHolder()`. Každý zásobník parametrů uchovává data stejným způsobem, který je zobrazen ve Výpisu 2-15. 
     598 
     599Výpis 2-15 - Použití zásobníku parametrů `sfResponse` 
    602600 
    603601    [php] 
    606604     => 'bar' 
    607605 
    608 Most of the classes using a parameter holder provide proxy methods to shorten the code needed for get/set operations. This is the case for the `sfResponse` object, so you can do the same as in Listing 2-15 with the code of Listing 2-16. 
    609  
    610 Listing 2-16 - Using the `sfResponse` Parameter Holder Proxy Methods 
     606Většina tříd používajících zásobník parametrů poskytuje proxy metody, které zkracují kód potřebný pro get/set operace. To je i případ objektu `sfResonse`, takže toho samého jako ve Výpisu 2-15 dosáhnete s kódem ve Výpisu 2-16. 
     607 
     608Výpis 2-16 - Použití proxy metody zásobníku parametrů `sfResponse` 
    611609 
    612610    [php] 
    615613     => 'bar' 
    616614 
    617 The parameter holder getter accepts a default value as a second argument. This provides a useful fallback mechanism that is much more concise than possible with a conditional statement. See Listing 2-17 for an example
    618  
    619 Listing 2-17 - Using the Attribute Holder Getter's Default Value 
     615Getter zásobníku parametrů přijímá druhý argument jako výchozí hodnotu. To dává k dispozici použitelný reverzní mechanizmus, který je mnohem stručnější než možnost s podmínkovým příkazem. Podívejte se na příklad ve Výpisu 2-17
     616 
     617Výpis 2-17 - Použití atributu výchozí hodnoty u metody getter zásobníku 
    620618 
    621619    [php] 
    639637     => default 
    640638 
    641 The parameter holders even support namespaces. If you specify a third argument to a setter or a getter, it is used as a namespace, and the parameter will be defined only within that namespace. Listing 2-18 shows an example
    642  
    643 Listing 2-18 - Using the `sfResponse` Parameter Holder Namespace 
     639Zásobníky parametrů dokonce podporují jmenné prostory. Pokud specifikujete třetí argument u metod setter a getter, bude použit jako jmenný prostor a parametr bude definován pouze v uvnitř tohoto jmenného prostoru. Příklad je ve Výpisu 2-18
     640 
     641Výpis 2-18 - Použití jmenného prostoru zásobníku parametrů `sfResponse` 
    644642 
    645643    [php] 
    651649     => 'bar2' 
    652650 
    653 Of course, you can add a parameter holder to your own classes to take advantage of its syntax facilities. Listing 2-19 shows how to define a class with a parameter holder
    654  
    655 Listing 2-19 - Adding a Parameter Holder to a Class 
    656  
    657     [php] 
    658     class MyClass 
     651Zásobníky parametrů můžete samozřejmě přidat do svých vlastních tříd a využít tak výhody jejich syntaktických možností. Výpis 2-19 zobrazuje jako definovat třídu se zásobníkem parametrů
     652 
     653Výpis 2-19 - Přidání zásobníku parametrů do třídy 
     654 
     655    [php] 
     656    class MyClas 
    659657    { 
    660658      protected $parameter_holder = null; 
    672670    } 
    673671 
    674 ### Constants 
    675  
    676 Surprisingly, you will find very few constants in symfony. This is because constants have a major drawback in PHP: you can't change their value once they are defined. So symfony uses its own configuration object, called sfConfig, which replaces constants. It provides static methods to access parameters from everywhere. Listing 2-20 demonstrates the use of sfConfig class methods
    677  
    678 Listing 2-20 - Using the `sfConfig` Class Methods Instead of Constants 
     672### Konstanty 
     673 
     674Překvapivě, v symfony najdete velmi málo konstant. Je to z toho důvodu, protože konstanty v PHP mají jeden veliký nedostatek: nemůžete, poté co byly definovány, změnit jejich hodnotu. Proto symfony používá vlastní konfigurační objekt nazvaný sfConfig, který konstanty nahrazuje. Poskytuje statické metody pro přístup k parametrům, které jsou přístupné odkudkoli. Výpis 2-20 demonstruje použití třídních metod sfConfig
     675 
     676Výpis 2-20 - Použití třídních metod `sfConfig` namísto konstant 
    679677 
    680678    [php] 
    686684    echo sfConfig::get('sf_foo'); 
    687685 
    688 The sfConfig methods support default values, and you can call the sfConfig::set() method more than once on the same parameter to change its value. Chapter 5 discusses `sfConfig` methods in more detail
    689  
    690 ### Class Autoloading 
    691  
    692 Classically, when you use a class method or create an object in PHP, you need to include the class definition first
     686Metody sfConfig podporují výchozí hodnoty a metodu sfConfig::set() lze volat vícekrát se stejným parametrem pro změnu jeho hodnoty. Metody `sfConfig' jsou detailněji probírány v Kapitole 5
     687 
     688### Automatické nahrávání tříd 
     689 
     690Obecně, pokud v PHP použijete metodu třídy, nebo vytvoříte objekt, je nejprve potřeba inkludovat definici třídy
    693691 
    694692    [php] 
    696694    $myObject = new MyClass(); 
    697695 
    698 But on large projects with many classes and a deep directory structure, keeping track of all the class files to include and their paths takes a lot of time. By providing an `spl_autoload_register()` function, symfony makes `include` statements unnecessary, and you can write directly
     696U velkých projektů s mnoha třídami a hlubokou adresářovou strukturou, ale zabírá sledování všech souborů s třídami a cest k nim mnoho času. Symfony poskytuje funkci `spl_autoload_register()`, díky které není potřeba příkazy `include` používat a lze psát přímo
    699697 
    700698    [php] 
    701699    $myObject = new MyClass(); 
    702700 
    703 Symfony will then look for a `MyClass` definition in all files ending with `php` in one of the project's `lib/` directories. If the class definition is found, it will be included automatically
    704  
    705 So if you store all your classes in lib/ directories, you don't need to include classes anymore. That's why the symfony projects usually do not contain any `include` or `require` statements
    706  
    707 >**NOTE** 
    708 >For better performance, the symfony autoloading scans a list of directories (defined in an internal configuration file) during the first request. It then registers all the classes these directories contain and stores the class/file correspondence in a PHP file as an associative array. That way, future requests don't need to do the directory scan anymore. This is why you need to clear the cache every time you add or move a class file in your project by calling the `symfony clear-cache` command (except in the development environment). You will learn more about the cache in Chapter 12, and about the autoloading configuration in Chapter 19. 
    709  
    710 Summary 
     701Symfony se potom podívá po definici `MyClass` ve všech souborech s příponou `php` v jednom z `lib/` adresářů projektu. Pokud je definice třídy nalezena, bude automaticky inkludována
     702 
     703Takže pokud uchováváte své třídy v lib/ adresářích, nepotřebujete třídy inkludovat. To je důvod, proč symfony projekty obvykle neobsahují žádné příkazy `include` nebo `require`
     704 
     705>**POZNÁMKA** 
     706>Pro zlepšení výkonu, symfony skenuje během prvního požadavku seznam adresářů (definovaný v interním konfiguračním souboru). Přitom zaregistruje všechny třídy, které tyto adresáře obsahují a uloží tyto údaje do PHP souboru jako asociativní pole. Proto není potřeba při dalších požadavcích znovu skenovat adresáře. A je to také důvod, proč je pokaždé, když je v projektu přidán nebo přesunut soubor se třídou, potřeba vyčistit cache příkazem `symfony clear-cache` (s výjimkou vývojového prostředí). Více o cache se můžete dozvědět v Kapitole 12 a o konfiguraci automatického nahrávání v Kapitole 19. 
     707 
     708Shrnutí 
    711709------- 
    712710 
    713 Using an MVC framework forces you to divide and organize your code according to the framework conventions. Presentation code goes to the view, data manipulation code goes to the model, and the request manipulation logic goes to the controller. It makes the application of the MVC pattern both very helpful and quite restricting
    714  
    715 Symfony is an MVC framework written in PHP 5. Its structure is designed to get the best of the MVC pattern, but with great ease of use. Thanks to its versatility and configurability, symfony is suitable for all web application projects
    716  
    717 Now that you understand the underlying theory behind symfony, you are almost ready to develop your first application. But before that, you need a symfony installation up and running on your development server. 
     711Používání MVC frameworku vás nutí rozdělit a organizovat kód podle konvencí frameworku. Prezentační kód patří do pohledu, kód pro manipulaci s daty patří do modelu a na požadavku závislá manipulační logika patří do kontroleru. Z těchto důvodů je aplikace MVC frameworku zároveň velice užitečná a zároveň dosti omezující
     712 
     713Symfony je MVC framework napsaný v PHP 5. Jeho struktura je navržena, aby bylo použito to nejlepší z MVC vzoru, ale zároveň aby bylo jednoduché na použití. Díky jeho univerzálnosti a konfigurovatelnosti je symfony vhodné pro všechny projekty webových aplikací
     714 
     715Nyní byste měli rozumět základní teorii, na níž je symfony postaveno, takže jste téměř připraveni na vývoj své první aplikace. Ale ještě předtím budete potřebovat symfony nainstalovat a rozběhnout vývojový server. 
    718716 
    719717}}}