mirror of
https://github.com/yiisoft/yii2.git
synced 2025-11-04 14:46:19 +08:00
guide [PL] intro
Polish translation for intro-upgrade-from-v1 and intro-yii. Few annotations for README as well.
This commit is contained in:
Bizley
@ -1,5 +1,5 @@
|
||||
Przewodnik po Yii 2.0
|
||||
===============================
|
||||
=====================
|
||||
|
||||
Ten poradnik udostępniony jest na [Warunkach dokumentacji Yii](http://www.yiiframework.com/doc/terms/).
|
||||
|
||||
@ -9,14 +9,14 @@ Wszelkie prawa zastrzeżone.
|
||||
|
||||
|
||||
Wstęp
|
||||
------------
|
||||
-----
|
||||
|
||||
* [O Yii](intro-yii.md)
|
||||
* [Aktualizacja z wersji 1.1](intro-upgrade-from-v1.md)
|
||||
|
||||
|
||||
Pierwsze kroki
|
||||
---------------
|
||||
--------------
|
||||
|
||||
* [Instalacja Yii](start-installation.md)
|
||||
* [Uruchamianie aplikacji](start-workflow.md)
|
||||
@ -28,7 +28,7 @@ Pierwsze kroki
|
||||
|
||||
|
||||
Struktura aplikacji
|
||||
---------------------
|
||||
-------------------
|
||||
|
||||
* [Przegląd](structure-overview.md)
|
||||
* [Skrypty wejściowe](structure-entry-scripts.md)
|
||||
@ -45,7 +45,7 @@ Struktura aplikacji
|
||||
|
||||
|
||||
Obsługa żądań
|
||||
-----------------
|
||||
-------------
|
||||
|
||||
* [Przegląd](runtime-overview.md)
|
||||
* [Bootstrapping](runtime-bootstrapping.md)
|
||||
@ -58,7 +58,7 @@ Obsługa żądań
|
||||
|
||||
|
||||
Kluczowe koncepcje
|
||||
------------
|
||||
------------------
|
||||
|
||||
* [Komponenty](concept-components.md)
|
||||
* [Właściwości](concept-properties.md)
|
||||
@ -72,10 +72,10 @@ Kluczowe koncepcje
|
||||
|
||||
|
||||
Praca z bazami danych
|
||||
----------------------
|
||||
---------------------
|
||||
|
||||
* [Obiekt dostępu do danych (DAO)](db-dao.md): Łączenie z bazą, podstawowe zapytania, transakcje i manipulacja schematem.
|
||||
* [Budowniczy kwerend](db-query-builder.md): Zapytania do bazy danych z użyciem warstwy abstrakcyjnej.
|
||||
* [Konstruktor kwerend](db-query-builder.md): Zapytania do bazy danych z użyciem warstwy abstrakcyjnej.
|
||||
* [Rekord aktywny](db-active-record.md): ORM Rekordu aktywnego, otrzymywanie i manipulacja rekordami oraz definiowanie relacji.
|
||||
* [Migracje](db-migrations.md): Użycie systemu kontroli wersji na twoich bazach danych podczas tworzenia aplikacji w grupie.
|
||||
* [Sphinx](db-sphinx.md)
|
||||
@ -85,7 +85,7 @@ Praca z bazami danych
|
||||
|
||||
|
||||
Odbieranie danych od użytkowników
|
||||
-----------------------
|
||||
---------------------------------
|
||||
|
||||
* [Tworzenie formularzy](input-forms.md)
|
||||
* [Walidacja danych wejściowych](input-validation.md)
|
||||
@ -95,7 +95,7 @@ Odbieranie danych od użytkowników
|
||||
|
||||
|
||||
Wyświetlanie danych
|
||||
---------------
|
||||
-------------------
|
||||
|
||||
* [Formatowanie danych](output-formatting.md)
|
||||
* [Stronicowanie](output-pagination.md)
|
||||
@ -103,11 +103,11 @@ Wyświetlanie danych
|
||||
* [Dostawcy danych](output-data-providers.md)
|
||||
* [Widżety danych](output-data-widgets.md)
|
||||
* [Praca ze skryptami po stronie klienta](output-client-scripts.md)
|
||||
* [Motywy (Theming)](output-theming.md)
|
||||
* [Skórki i motywy (Theming)](output-theming.md)
|
||||
|
||||
|
||||
Bezpieczeństwo
|
||||
--------
|
||||
--------------
|
||||
|
||||
* [Uwierzytelnianie](security-authentication.md)
|
||||
* [Autoryzacja](security-authorization.md)
|
||||
@ -117,7 +117,7 @@ Bezpieczeństwo
|
||||
|
||||
|
||||
Pamięć podręczna
|
||||
-------
|
||||
----------------
|
||||
|
||||
* [Przegląd](caching-overview.md)
|
||||
* [Pamięć podręczna danych](caching-data.md)
|
||||
@ -127,7 +127,7 @@ Pamięć podręczna
|
||||
|
||||
|
||||
Webserwisy z wykorzystaniem REST
|
||||
--------------------
|
||||
--------------------------------
|
||||
|
||||
* [Szybki start](rest-quick-start.md)
|
||||
* [Zasoby](rest-resources.md)
|
||||
@ -141,7 +141,7 @@ Webserwisy z wykorzystaniem REST
|
||||
|
||||
|
||||
Narzędzia wspomagające tworzenie aplikacji
|
||||
-----------------
|
||||
------------------------------------------
|
||||
|
||||
* [Pasek debugowania i debuger](tool-debugger.md)
|
||||
* [Generowanie kodu przy użyciu Gii](tool-gii.md)
|
||||
@ -149,7 +149,7 @@ Narzędzia wspomagające tworzenie aplikacji
|
||||
|
||||
|
||||
Testowanie
|
||||
-------
|
||||
----------
|
||||
|
||||
* [Przegląd](test-overview.md)
|
||||
* [Ustawienia środowiska testowego](test-endvironment-setup.md)
|
||||
@ -160,7 +160,7 @@ Testowanie
|
||||
|
||||
|
||||
Tematy specjalne
|
||||
--------------
|
||||
----------------
|
||||
|
||||
* [Szablon zaawansowanej aplikacji](tutorial-advanced-app.md)
|
||||
* [Tworzenie aplikacji od podstaw](tutorial-start-from-scratch.md)
|
||||
@ -169,7 +169,7 @@ Tematy specjalne
|
||||
* [Internacjonalizacja](tutorial-i18n.md)
|
||||
* [Wysyłanie poczty](tutorial-mailing.md)
|
||||
* [Poprawianie wydajności](tutorial-performance-tuning.md)
|
||||
* [Shared Hosting Environment](tutorial-shared-hosting.md)
|
||||
* [Współdzielone środowisko hostujące](tutorial-shared-hosting.md)
|
||||
* [Silniki szablonów](tutorial-template-engines.md)
|
||||
* [Praca z kodem zewnętrznym](tutorial-yii-integration.md)
|
||||
|
||||
@ -190,10 +190,19 @@ Widżety
|
||||
|
||||
|
||||
Klasy pomocnicze
|
||||
-------
|
||||
----------------
|
||||
|
||||
* [Przegląd](helper-overview.md)
|
||||
* [ArrayHelper](helper-array.md)
|
||||
* [Html](helper-html.md)
|
||||
* [Url](helper-url.md)
|
||||
|
||||
|
||||
Uwagi do polskiego tłumaczenia przewodnika
|
||||
------------------------------------------
|
||||
|
||||
Niektóre z użytych w tym przewodniku programistycznych nazw zostały celowo spolszczone, w przypadku, gdy
|
||||
w literaturze popularnej nie występują ich polskie odpowiedniki. Mam nadzieję, że czytelnik wybaczy mi okazjonalne
|
||||
"settery", "gettery" i "traity", które umieszczam tutaj licząc na powszechne zrozumienie tych terminów w polskiej
|
||||
społeczności programistycznej. Jednocześnie spolszczenia/tłumaczenia niektórych terminów, jak "Fixtures", odmawiam na razie
|
||||
całkowicie, licząc na to, że język polski w końcu nadgoni lub wchłonie, w ten, czy inny sposób, techniczne nowości.
|
||||
|
||||
515
docs/guide-pl/intro-upgrade-from-v1.md
Normal file
515
docs/guide-pl/intro-upgrade-from-v1.md
Normal file
@ -0,0 +1,515 @@
|
||||
Aktualizacja z wersji 1.1
|
||||
=========================
|
||||
|
||||
Pomiędzy wersjami 1.1 i 2.0 Yii jest ogrom różnic, ponieważ framework został całkowicie przepisany w 2.0.
|
||||
Z tego też powodu aktualizacja z wersji 1.1 nie jest tak trywialnym procesem, jak w przypadku aktualizacji pomiędzy pomniejszymi wersjami.
|
||||
W tym przewodniku zapoznasz się z największymi różnicami dwóch głównych wersji.
|
||||
|
||||
Jeśli nie korzystałeś wcześniej z Yii 1.1, możesz pominąć tę sekcję i przejść bezpośrednio do "[Pierwszych kroków](start-installation.md)".
|
||||
|
||||
Zwróć uwagę na to, że Yii 2.0 wprowadza znacznie więcej nowych funkcjonalności, niż wymienionych jest w tym podsumowaniu.
|
||||
Wskazane jest zapoznanie się z treścią całego przewodnika, aby poznać je wszystkie. Jest bardzo prawdopodobne, że niektóre z mechanizmów, które
|
||||
poprzednio musiałeś stworzyć samemu, teraz są częścią podstawowego kodu.
|
||||
|
||||
|
||||
Instalacja
|
||||
----------
|
||||
|
||||
Yii 2.0 w pełni korzysta z udogodnień [Composera](https://getcomposer.org/), będącego de facto menadżerem projektów PHP.
|
||||
Z jego pomocą odbywa się zarówno instalacja podstawowego frameworka, jak i wszystkich rozszerzeń. Aby zapoznać się ze szczegółową
|
||||
instrukcją instalacji Yii 2.0, przejdź do sekcji [Instalacja Yii](start-installation.md). Jeśli chcesz stworzyć nowe rozszerzenie
|
||||
lub zmodyfikować istniejące w wersji 1.1, aby było kompatybilne z 2.0, przejdź do sekcji [Tworzenie rozszerzeń](structure-extensions.md#creating-extensions).
|
||||
|
||||
|
||||
Wymagania PHP
|
||||
-------------
|
||||
|
||||
Yii 2.0 wymaga PHP w wersji 5.4 lub nowszej, która została znacząco ulepszona w stosunku do wersji 5.2 (wymaganej przez Yii 1.1).
|
||||
Z tego też powodu już na poziomie samego języka pojawiło się sporo różnic, na które należy zwrócić uwagę.
|
||||
Poniżej znajdziesz krótkie podsumowanie głównych różnic dotyczących PHP:
|
||||
|
||||
- [Przestrzenie nazw](http://php.net/manual/pl/language.namespaces.php).
|
||||
- [Funkcje anonimowe](http://php.net/manual/pl/functions.anonymous.php).
|
||||
- Skrócona składnia zapisu tablic `[...elementy...]` używana zamiast `array(...elementy...)`.
|
||||
- Krótkie tagi echo `<?=` używane w plikach widoków. Można ich używać bezpiecznie, począwszy od PHP 5.4.
|
||||
- [Klasy i interfejsy SPL](http://php.net/manual/pl/book.spl.php).
|
||||
- [Opóźnione statyczne wiązania](http://php.net/manual/pl/language.oop5.late-static-bindings.php).
|
||||
- [Data i czas](http://php.net/manual/pl/book.datetime.php).
|
||||
- [Traity](http://php.net/manual/pl/language.oop5.traits.php).
|
||||
- [Rozszerzenie intl](http://php.net/manual/pl/book.intl.php). Yii 2.0 korzysta z rozszerzenia PHP `intl` do wsparcia obsługi internacjonalizacji.
|
||||
|
||||
|
||||
Przestrzeń nazw
|
||||
---------------
|
||||
|
||||
Najbardziej oczywista zmiana w Yii 2.0 dotyczy używania przestrzeni nazw. Praktycznie każda z podstawowych klas je wykorzystuje, np. `yii\web\Request`.
|
||||
Prefiks "C" nie jest już używany w nazwach, a sam schemat nazewnictwa odpowiada teraz strukturze folderów - dla przykładu `yii\web\Request` wskazuje,
|
||||
że plik klasy to `web/Request.php` znajdujący się w folderze frameworka Yii.
|
||||
|
||||
Dzięki mechanizmowi ładowania klas Yii możesz użyć dowolnej podstawowej klasy frameworka bez konieczności bezpośredniego dołączania jej kodu.
|
||||
|
||||
|
||||
Komponent i obiekt
|
||||
------------------
|
||||
|
||||
Yii 2.0 rozdzielił klasę `CComponent` z 1.1 na dwie: [[yii\base\Object]] i [[yii\base\Component]].
|
||||
Lekka klasa [[yii\base\Object|Object]] pozwala na zdefiniowanie [właściwości obiektu](concept-properties.md) poprzez gettery i settery.
|
||||
Klasa [[yii\base\Component|Component]] dziedziczy po [[yii\base\Object|Object]] i dodatkowo wspiera obsługę [zdarzeń](concept-events.md) oraz [zachowań](concept-behaviors.md).
|
||||
|
||||
Jeśli Twoja klasa nie wymaga ww. wsparcia, rozważ użycie [[yii\base\Object|Object]] jako klasy podstawowej. Tak jest zazwyczaj w przypadku klas reprezentujących
|
||||
najbardziej podstawową strukturę danych.
|
||||
|
||||
|
||||
Konfiguracja obiektu
|
||||
--------------------
|
||||
|
||||
Klasa [[yii\base\Object|Object]] wprowadza ujednoliconą formę konfigurowania obiektów. Każda klasa dziedzicząca po [[yii\base\Object|Object]] powinna zadeklarować swój
|
||||
konstruktor (jeśli tego wymaga) w następujący sposób, dzięki czemu zostanie poprawnie skonfigurowana:
|
||||
|
||||
```php
|
||||
class MyClass extends \yii\base\Object
|
||||
{
|
||||
public function __construct($param1, $param2, $config = [])
|
||||
{
|
||||
// ... inicjalizacja przed skonfigurowaniem
|
||||
|
||||
parent::__construct($config);
|
||||
}
|
||||
|
||||
public function init()
|
||||
{
|
||||
parent::init();
|
||||
|
||||
// ... inicjalizacja po skonfigurowaniu
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
W powyższym przykładzie ostatnim parametrem konstruktora musi być tablica konfiguracyjna,
|
||||
zawierająca pary nazwa-wartość służące do zainicjowania właściwości na końcu konstruktora.
|
||||
Możesz nadpisać metodę [[yii\base\Object::init()|init()]], aby wykonać dodatkowy proces inicjalizacyjny po
|
||||
zaaplikowaniu konfiguracji.
|
||||
|
||||
Dzięki tej konwencji możesz tworzyć i konfigurować nowe obiekty, używając
|
||||
tablicy konfiguracyjnej:
|
||||
|
||||
```php
|
||||
$object = Yii::createObject([
|
||||
'class' => 'MyClass',
|
||||
'property1' => 'abc',
|
||||
'property2' => 'cde',
|
||||
], [$param1, $param2]);
|
||||
```
|
||||
|
||||
Więcej szczegółów na temat konfiguracji znajdziesz w sekcji [Konfiguracje](concept-configurations.md).
|
||||
|
||||
|
||||
Zdarzenia (Events)
|
||||
------------------
|
||||
|
||||
W Yii 1 zdarzenia były tworzone poprzez definiowanie `on`-metody (np., `onBeforeSave`). W Yii 2 możesz użyć dowolnej nazwy. Uruchomienie zdarzenia następuje
|
||||
poprzez wywołanie metody [[yii\base\Component::trigger()|trigger()]]:
|
||||
|
||||
```php
|
||||
$event = new \yii\base\Event;
|
||||
$component->trigger($eventName, $event);
|
||||
```
|
||||
|
||||
Aby dołączyć uchwyt do zdarzenia, użyj metody [[yii\base\Component::on()|on()]]:
|
||||
|
||||
```php
|
||||
$component->on($eventName, $handler);
|
||||
// a aby odłączyć uchwyt użyj:
|
||||
// $component->off($eventName, $handler);
|
||||
```
|
||||
|
||||
Zdarzenia zostały wzbogacone w wiele udoskonaleń. Więcej szczegółów na ten temat znajdziesz w sekcji [Zdarzenia (Events)](concept-events.md).
|
||||
|
||||
|
||||
Aliasy ścieżek
|
||||
--------------
|
||||
|
||||
Yii 2.0 rozszerza funkcjonalność aliasów ścieżek zarówno na ścieżki plików oraz folderów, jak i adresy URL. Yii 2.0 wymaga teraz też,
|
||||
aby nazwa aliasu zaczynała się znakiem `@` w celu odróżnienia jej od zwyczajnych ścieżek plików/folderów lub URLi.
|
||||
Dla przykładu: alias `@yii` odnosi się do folderu instalacji Yii. Aliasy ścieżek są wykorzystywane w większości miejsc w podstawowym
|
||||
kodzie Yii, choćby [[yii\caching\FileCache::cachePath]] - można tu przekazać zarówno zwykłą ścieżkę, jak i alias.
|
||||
|
||||
Alias ścieżki jest mocno powiązany z przestrzenią nazw klasy. Zalecane jest, aby zdefiniować alias dla każdej podstawowej
|
||||
przestrzeni nazw, dzięki czemu mechanizm automatycznego ładowania klas Yii nie będzie wymagał dodatkowej konfiguracji.
|
||||
Dla przykładu: dzięki temu, że `@yii` odwołuje się do folderu instalacji Yii, klasa taka jak `yii\web\Request` może być automatycznie załadowana.
|
||||
Jeśli używasz zewnętrznych bibliotek, jak np. Zend Framework, możesz zdefiniować alias `@Zend` odnoszący się do folderu instalacji tego frameworka.
|
||||
Od tej pory Yii będzie również w stanie automatycznie załadować każdą klasę z tej biblioteki.
|
||||
|
||||
Więcej o aliasach ścieżek dostępne jest w sekcji [Aliasy](concept-aliases.md).
|
||||
|
||||
|
||||
Widoki
|
||||
------
|
||||
|
||||
Najbardziej znaczącą zmianą dotyczącą widoków w Yii 2 jest użycie specjalnej zmiennej `$this`. W widoku nie odnosi się ona już do
|
||||
aktualnego kontrolera lub widżetu, lecz do obiektu *widoku*, nowej koncepcji przedstawionej w 2.0. Obiekt *widoku* jest klasą typu [[yii\web\View]], która
|
||||
reprezentuje część wzorca MVC. Jeśli potrzebujesz odwołać się do kontrolera lub widżetu w widoku, możesz użyć `$this->context`.
|
||||
|
||||
Aby zrenderować częściowy widok wewnątrz innego widoku, możesz użyć `$this->render()` zamiast dotychczasowego `$this->renderPartial()`.
|
||||
Wywołanie `render` musi teraz też być bezpośrednio wyechowane, ponieważ metoda `render()` zwraca rezultat renderowania zamiast od razu go wyświetlać.
|
||||
|
||||
```php
|
||||
echo $this->render('_item', ['item' => $item]);
|
||||
```
|
||||
|
||||
Oprócz wykorzystania PHP jako podstawowego języka szablonów, Yii 2.0 oficjalnie wspiera dwa popularne silniki szablonów: Smarty i Twig (The Prado nie jest już wspierany).
|
||||
Aby użyć któregokolwiek z tych silników, musisz skonfigurować komponent aplikacji `view` poprzez ustawienie właściwości [[yii\base\View::$renderers|View::$renderers]].
|
||||
Po więcej szczegółów przejdź do sekcji [Silniki szablonów](tutorial-template-engines.md).
|
||||
|
||||
|
||||
Modele
|
||||
------
|
||||
|
||||
Yii 2.0 korzysta z [[yii\base\Model]] jako bazowego modelu, podobnie jak `CModel` w 1.1.
|
||||
Klasa `CFormModel` została całkowicie usunięta, w Yii 2 należy rozszerzyć [[yii\base\Model]], aby stworzyć klasę modelu formularza.
|
||||
|
||||
Yii 2.0 wprowadza nową metodę [[yii\base\Model::scenarios()|scenarios()]], służącą do deklarowania scenariuszy, jak i do oznaczania, w którym scenariuszu
|
||||
atrybut będzie wymagał walidacji, może być uznany za bezpieczny lub nie itp. Dla przykładu:
|
||||
|
||||
```php
|
||||
public function scenarios()
|
||||
{
|
||||
return [
|
||||
'backend' => ['email', 'role'],
|
||||
'frontend' => ['email', '!role'],
|
||||
];
|
||||
}
|
||||
```
|
||||
|
||||
Widzimy tutaj dwa zadeklarowane scenariusze: `backend` i `frontend`. W scenariuszu `backend` obydwa atrybuty,
|
||||
`email` i `role`, są traktowane jako bezpieczne i mogą być przypisane zbiorczo. W przypadku scenariusza `frontend`,
|
||||
`email` może być przypisany zbiorczo, ale `role` już nie. Zarówno `email` jak i `role` powinny przejść proces walidacji.
|
||||
|
||||
Metoda [[yii\base\Model::rules()|rules()]] wciąż służy do zadeklarowania zasad walidacji. Zauważ, że z powodu wprowadzenia [[yii\base\Model::scenarios()|scenarios()]],
|
||||
nie ma już walidatora `unsafe`.
|
||||
|
||||
Jeśli metoda [[yii\base\Model::rules()|rules()]] deklaruje użycie wszystkich możliwych scenariuszy i jeśli nie masz potrzeby deklarowania atrybutów `unsafe` (niebezpiecznych),
|
||||
w większości przypadków nie potrzebujesz nadpisywać metody [[yii\base\Model::scenarios()|scenarios()]].
|
||||
|
||||
Aby dowiedzieć się więcej o modelach, przejdź do sekcji [Modele](structure-models.md).
|
||||
|
||||
|
||||
Kontrolery
|
||||
----------
|
||||
|
||||
Yii 2.0 używa [[yii\web\Controller]] jako bazowej klasy kontrolera, podobnie do `CController` w Yii 1.1.
|
||||
[[yii\base\Action]] jest bazową klasą dla akcji.
|
||||
|
||||
Najbardziej oczywistą implikacją tych zmian jest to, że akcja kontrolera powinna zwracać zawartość, którą chcesz wyświetlić, zamiast wyświetlać ją bezpośrednio:
|
||||
|
||||
```php
|
||||
public function actionView($id)
|
||||
{
|
||||
$model = \app\models\Post::findOne($id);
|
||||
if ($model) {
|
||||
return $this->render('view', ['model' => $model]);
|
||||
} else {
|
||||
throw new \yii\web\NotFoundHttpException;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Przejdź do sekcji [Kontrolery](structure-controllers.md), aby poznać więcej szczegółów na ten temat.
|
||||
|
||||
|
||||
Widżety
|
||||
-------
|
||||
|
||||
Yii 2.0 korzysta z [[yii\base\Widget]] jako bazowej klasy widżetów, podobnie jak `CWidget` w Yii 1.1.
|
||||
|
||||
Dla lepszego wsparcia frameworka w aplikacjach IDE Yii 2.0 wprowadził nową składnię używania widżetów. Używane są teraz metody
|
||||
[[yii\base\Widget::begin()|begin()]], [[yii\base\Widget::end()|end()]] i [[yii\base\Widget::widget()|widget()]] w następujący sposób:
|
||||
|
||||
```php
|
||||
use yii\widgets\Menu;
|
||||
use yii\widgets\ActiveForm;
|
||||
|
||||
// Zwróć uwagę na konieczność użycia "echo", aby wyświetlić rezultat
|
||||
echo Menu::widget(['items' => $items]);
|
||||
|
||||
// Przekazujemy tablicę, aby zainicjalizować właściwości obiektu
|
||||
$form = ActiveForm::begin([
|
||||
'options' => ['class' => 'form-horizontal'],
|
||||
'fieldConfig' => ['inputOptions' => ['class' => 'input-xlarge']],
|
||||
]);
|
||||
... pola formularza w tym miejscu ...
|
||||
ActiveForm::end();
|
||||
```
|
||||
|
||||
Więcej szczegółów na ten temat znajdziesz w sekcji [Widżety](structure-widgets.md).
|
||||
|
||||
|
||||
Skórki i motywy (Theming)
|
||||
-------------------------
|
||||
|
||||
Skórki działają zupełnie inaczej w 2.0. Oparte są teraz na mechanizmie mapowania ścieżki, który przekształca źródłowy plik widoku
|
||||
w plik widoku skórki. Dla przykładu, jeśli mapa ścieżki dla skórki to `['/web/views' => '/web/themes/basic']`, to skórkowa wersja pliku widoku
|
||||
`/web/views/site/index.php` to `/web/themes/basic/site/index.php`. Dzięki temu skórki mogą być użyte dla dowolnego pliku widoku, nawet w przypadku
|
||||
widoku wyrenderowanego poza kontekstem kontrolera lub widżetu.
|
||||
|
||||
Nie ma również już komponentu `CThemeManager`. Zamiast tego `theme` jest konfigurowalną właściwością komponentu aplikacji `view`.
|
||||
|
||||
Sekcja [Skórki i motywy (Theming)](output-theming.md) zawiera więcej szczegółów na ten temat.
|
||||
|
||||
|
||||
Aplikacje konsolowe
|
||||
-------------------
|
||||
|
||||
Aplikacje konsolowe używają teraz kontrolerów tak jak aplikacje webowe. Kontrolery konsolowe powinny rozszerzać klasę
|
||||
[[yii\console\Controller]], podobnie jak `CConsoleCommand` w 1.1.
|
||||
|
||||
Aby uruchomić polecenie konsoli, użyj `yii <route>`, gdzie `<route>` oznacza ścieżkę kontrolera (np. `sitemap/index`).
|
||||
Dodatkowe anonimowe argumenty są przekazywane jako parametry do odpowiedniej metody akcji kontrolera, natomiast nazwane
|
||||
argumenty są przetwarzane według deklaracji zawartych w [[yii\console\Controller::options()]].
|
||||
|
||||
Yii 2.0 wspiera automatyczne generowanie informacji pomocy poprzez bloki komentarzy.
|
||||
|
||||
Aby dowiedzieć się więcej na ten temat, przejdź do sekcji [Komendy konsolowe](tutorial-console.md).
|
||||
|
||||
|
||||
I18N
|
||||
----
|
||||
|
||||
Yii 2.0 usunął wbudowany formater dat i liczb na rzecz [modułu PECL intl PHP](http://pecl.php.net/package/intl).
|
||||
|
||||
Tłumaczenia wiadomości odbywają się teraz poprzez komponent aplikacji `i18n`, w którym można ustalić zestaw źródeł treści,
|
||||
dzięki czemu możliwy jest ich wybór dla różnych kategorii wiadomości.
|
||||
|
||||
W sekcji [Internacjonalizacja](tutorial-i18n.md) znajdziesz więcej szczegółów na ten temat.
|
||||
|
||||
|
||||
Filtry akcji
|
||||
------------
|
||||
|
||||
Filtry akcji są implementowane od teraz za pomocą zachowań (behavior). Aby zdefiniować nowy filtr, należy rozszerzyć klasę [[yii\base\ActionFilter]].
|
||||
Użycie filtru odbywa się poprzez dołączenie go do kontrolera jako zachowanie. Dla przykładu: aby użyć filtra [[yii\filters\AccessControl]], dodaj poniższy kod w kontrolerze:
|
||||
|
||||
```php
|
||||
public function behaviors()
|
||||
{
|
||||
return [
|
||||
'access' => [
|
||||
'class' => 'yii\filters\AccessControl',
|
||||
'rules' => [
|
||||
['allow' => true, 'actions' => ['admin'], 'roles' => ['@']],
|
||||
],
|
||||
],
|
||||
];
|
||||
}
|
||||
```
|
||||
|
||||
Więcej informacji na ten temat znajdziesz w sekcji [Filtry](structure-filters.md).
|
||||
|
||||
|
||||
Zasoby (Assets)
|
||||
---------------
|
||||
|
||||
Yii 2.0 wprowadza nowy mechanizm tzw. *pakietów zasobów*, który zastąpił koncepcję pakietów skryptowych z Yii 1.1.
|
||||
|
||||
Pakiet zasobów jest kolekcją plików zasobów (np. plików JavaScript, CSS, obrazków, itd.) zgromadzoną w folderze.
|
||||
Każdy pakiet jest reprezentowany przez klasę rozszerzającą [[yii\web\AssetBundle]]. Zarejestrowanie pakietu poprzez
|
||||
metodę [[yii\web\AssetBundle::register()]] pozwala na udostępnienie go publicznie. W przeciwieństwie do rozwiązania z Yii 1,
|
||||
strona rejestrująca pakiet będzie automatycznie zawierać referencje do plików JavaScript i CSS wymienionych na jego liście.
|
||||
|
||||
Sekcja [Zasoby (Assets)](structure-assets.md) zawiera szczegółowe informacje na ten temat.
|
||||
|
||||
|
||||
Klasy pomocnicze
|
||||
----------------
|
||||
|
||||
Yii 2.0 zawiera wiele powszechnie używanych statycznych klas pomocniczych (helperów), takich jak:
|
||||
|
||||
* [[yii\helpers\Html]]
|
||||
* [[yii\helpers\ArrayHelper]]
|
||||
* [[yii\helpers\StringHelper]]
|
||||
* [[yii\helpers\FileHelper]]
|
||||
* [[yii\helpers\Json]]
|
||||
|
||||
W sekcji [Klasy pomocnicze](helper-overview.md) znajdziesz więcej informacji na ten temat.
|
||||
|
||||
|
||||
Formularze
|
||||
----------
|
||||
|
||||
Yii 2.0 wprowadza koncepcję *pola* do budowy formularzy, korzystając z klasy [[yii\widgets\ActiveForm]].
|
||||
Pole jest kontenerem składającym się z etykiety, pola wprowadzenia danych formularza, informacji o błędzie i/lub tekstu podpowiedzi, reprezentowanym
|
||||
przez obiekt klasy [[yii\widgets\ActiveField|ActiveField]].
|
||||
Używając pól, możesz stworzyć formularz w sposób o wiele prostszy i bardziej przejrzysty niż do tej pory:
|
||||
|
||||
```php
|
||||
<?php $form = yii\widgets\ActiveForm::begin(); ?>
|
||||
<?= $form->field($model, 'username') ?>
|
||||
<?= $form->field($model, 'password')->passwordInput() ?>
|
||||
<div class="form-group">
|
||||
<?= Html::submitButton('Login') ?>
|
||||
</div>
|
||||
<?php yii\widgets\ActiveForm::end(); ?>
|
||||
```
|
||||
|
||||
Aby dowiedzieć się więcej na ten temat, przejdź do sekcji [Tworzenie formularzy](input-forms.md).
|
||||
|
||||
|
||||
Konstruktor kwerend
|
||||
-------------------
|
||||
|
||||
W 1.1 budowanie kwerend było rozrzucone pomiędzy kilka klas, tj. `CDbCommand`, `CDbCriteria` i `CDbCommandBuilder`.
|
||||
Yii 2.0 reprezentuje kwerendę bazodanową w postaci obiektu [[yii\db\Query|Query]], który może być zamieniony
|
||||
w komendę SQL za pomocą [[yii\db\QueryBuilder|QueryBuilder]].
|
||||
Przykładowo:
|
||||
|
||||
```php
|
||||
$query = new \yii\db\Query();
|
||||
$query->select('id, name')
|
||||
->from('user')
|
||||
->limit(10);
|
||||
|
||||
$command = $query->createCommand();
|
||||
$sql = $command->sql;
|
||||
$rows = $command->queryAll();
|
||||
```
|
||||
|
||||
Co najlepsze, taki sposób tworzenia kwerend może być również wykorzystany przy pracy z [Rekordem aktywnym](db-active-record.md).
|
||||
|
||||
Po więcej szczegółów udaj się do sekcji [Konstruktor kwerend](db-query-builder.md).
|
||||
|
||||
|
||||
Rekord aktywny
|
||||
--------------
|
||||
|
||||
Yii 2.0 wprowadza sporo zmian w [Rekordach aktywnych](db-active-record.md). Dwie najbardziej znaczące to
|
||||
konstruowanie kwerend i obsługa relacji.
|
||||
|
||||
Klasa `CDbCriteria` z 1.1 została zastąpiona przez [[yii\db\ActiveQuery]] w Yii 2. Klasa ta rozszerza [[yii\db\Query]], dzięki czemu
|
||||
dziedziczy wszystkie metody konstruowania kwerend. Aby rozpocząć budowanie kwerendy, wywołaj metodę [[yii\db\ActiveRecord::find()]]:
|
||||
|
||||
```php
|
||||
// Pobranie wszystkich *aktywnych* klientów i posortowanie po ich ID:
|
||||
$customers = Customer::find()
|
||||
->where(['status' => $active])
|
||||
->orderBy('id')
|
||||
->all();
|
||||
```
|
||||
|
||||
Deklaracja relacji polega na prostym zdefiniowaniu metody gettera, który zwróci obiekt [[yii\db\ActiveQuery|ActiveQuery]].
|
||||
Nazwa właściwości określonej przez tego gettera reprezentuje nazwę stworzonej relacji. Dla przykładu: w poniższym kodzie deklarujemy
|
||||
relację `orders` (w 1.1 konieczne było zadeklarowanie relacji wewnątrz wydzielonej specjalnie metody `relations()`):
|
||||
|
||||
```php
|
||||
class Customer extends \yii\db\ActiveRecord
|
||||
{
|
||||
public function getOrders()
|
||||
{
|
||||
return $this->hasMany('Order', ['customer_id' => 'id']);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Od tej pory można posługiwać się `$customer->orders`, aby uzyskać dostęp do tabeli zamówień klientów poprzez relację. Dodatkowo można również posłużyć się
|
||||
następującym kodem, aby wywołać relacyjną kwerendę dla zadanych warunków:
|
||||
|
||||
```php
|
||||
$orders = $customer->getOrders()->andWhere('status=1')->all();
|
||||
```
|
||||
|
||||
Przy "gorliwym" pobieraniu relacji ("eager", w przyciwieństwie do leniwego pobierania "lazy") Yii 2.0 działa inaczej niż w wersji 1.1. W 1.1 tworzono kwerendę JOIN,
|
||||
aby pobrać zarówno główne, jak i relacyjne rekordy. W Yii 2.0 wywoływane są dwie komendy SQL bez użycia JOIN - pierwsza pobiera główne rekordy, a druga relacyjne, filtrując je
|
||||
przy użyciu kluczy głównych rekordów.
|
||||
|
||||
Aby zmniejszyć zużycie CPU i pamięci, zamiast zwracać obiekty [[yii\db\ActiveRecord|ActiveRecord]], do kwerendy pobierającej dużą ilość rekordów możesz podpiąć metodę
|
||||
[[yii\db\ActiveQuery::asArray()|asArray()]], dzięki czemu zostaną one pobrane jako tablice. Przykładowo:
|
||||
|
||||
```php
|
||||
$customers = Customer::find()->asArray()->all();
|
||||
```
|
||||
|
||||
Inną istotną zmianą jest to, że nie można już definiować domyślnych wartości atrybutów poprzez publiczne właściwości.
|
||||
Jeśli potrzebujesz takich definicji, powinieneś przypisać je wewnątrz metody `init` w klasie rekordu.
|
||||
|
||||
```php
|
||||
public function init()
|
||||
{
|
||||
parent::init();
|
||||
$this->status = self::STATUS_NEW;
|
||||
}
|
||||
```
|
||||
|
||||
Nadpisywanie konstruktora klasy ActiveRecord w 1.1 wiązało się z pewnymi problemami, co nie występuje już w wersji 2.0.
|
||||
Zwróć jednak uwagę na to, że przy dodawaniu parametrów do konstruktora możesz potrzebować nadpisać metodę [[yii\db\ActiveRecord::instantiate()]].
|
||||
|
||||
W nowym rekordzie aktywnym znajdziesz wiele innych zmian i udogodnień. Aby zapoznać się z nimi, przejdź do sekcji [Rekord aktywny](db-active-record.md).
|
||||
|
||||
|
||||
Zachowania rekordu aktywnego
|
||||
----------------------------
|
||||
|
||||
W 2.0 zrezygnowaliśmy z bazowej klasy zachowania `CActiveRecordBehavior`. Jeśli chcesz stworzyć zachowanie dla rekordu aktywnego, musisz
|
||||
rozszerzyć bezpośrednio klasę `yii\base\Behavior`. Jeśli klasa zachowania ma reagować na zdarzenia, powinna nadpisywać metodę `events()`, jak zaprezentowano poniżej:
|
||||
|
||||
```php
|
||||
namespace app\components;
|
||||
|
||||
use yii\db\ActiveRecord;
|
||||
use yii\base\Behavior;
|
||||
|
||||
class MyBehavior extends Behavior
|
||||
{
|
||||
// ...
|
||||
|
||||
public function events()
|
||||
{
|
||||
return [
|
||||
ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
|
||||
];
|
||||
}
|
||||
|
||||
public function beforeValidate($event)
|
||||
{
|
||||
// ...
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
Klasa User i IdentityInterface
|
||||
------------------------------
|
||||
|
||||
Klasa `CWebUser` z 1.1 została zastąpiona przez [[yii\web\User]] i nie ma już klasy `CUserIdentity`.
|
||||
Zamiast tego należy zaimplementować interfejs [[yii\web\IdentityInterface]], który jest znacznie bardziej wygodny i oczywisty w użyciu.
|
||||
Szablon zaawansowanego projektu zawiera przykład takiego właśnie użycia.
|
||||
|
||||
Po więcej szczegółów zajrzyj do sekcji [Uwierzytelnianie](security-authentication.md), [Autoryzacja](security-authorization.md) i [Szablon zaawansowanego projektu](https://github.com/yiisoft/yii2-app-advanced/blob/master/docs/guide/README.md).
|
||||
|
||||
|
||||
Zarządzanie adresami URL
|
||||
------------------------
|
||||
|
||||
Zarządzanie adresami URL w Yii 2 jest bardzo podobne do tego znanego z 1.1. Głównym ulepszeniem tego mechanizmu jest teraz wsparcie dla parametrów opcjonalnych.
|
||||
Dla przykładu: warunek dla adresu zadeklarowany poniżej obejmie zarówno `post/popular` jak i `post/1/popular`. W 1.1 konieczne byłoby napisanie dwóch warunków, aby
|
||||
osiągnąć to samo.
|
||||
|
||||
```php
|
||||
[
|
||||
'pattern' => 'post/<page:\d+>/<tag>',
|
||||
'route' => 'post/index',
|
||||
'defaults' => ['page' => 1],
|
||||
]
|
||||
```
|
||||
|
||||
Przejdź do sekcji [Zarządzania adresami URL](runtime-routing.md) po więcej informacji.
|
||||
|
||||
Istotną zmianą konwencji nazw dla adresów jest to, że nazwy kontrolerów i akcji typu "camel case" są teraz
|
||||
konwertowane do małych liter, z każdym słowem oddzielonym za pomocą myślnika, np. ID kontrolera `CamelCaseController` zostanie
|
||||
przekształcone w `camel-case`.
|
||||
|
||||
Zapoznaj się z sekcją dotyczącą [ID kontrolerów](structure-controllers.md#controller-ids) i [ID akcji](structure-controllers.md#action-ids).
|
||||
|
||||
|
||||
Korzystanie z Yii 1.1 i 2.x jednocześnie
|
||||
----------------------------------------
|
||||
|
||||
Jeśli chciałbyś skorzystać z kodu napisanego dla Yii 1.1 w aplikacji Yii 2.0, prosimy o zapoznanie się z sekcją [Praca z kodem zewnętrznym](tutorial-yii-integration.md).
|
||||
@ -2,52 +2,56 @@ Czym jest Yii
|
||||
=============
|
||||
|
||||
Yii jest wysoko wydajnym, opartym na komponentach frameworkiem PHP do szybkiego programowania
|
||||
nowoczesnych stron internetowych. Nazwa Yii (wymawiana [ji:]) znaczy po chińsku "prosto i ewolucyjnie".
|
||||
Może to być również rozumiane jako akronim dla Yes It Is!
|
||||
nowoczesnych stron internetowych. Nazwa Yii (wymawiana [ji:]) oznacza w języku chińskim "prosto i ewolucyjnie".
|
||||
Może to być również rozumiane jako akronim dla **Yes It Is**!
|
||||
|
||||
|
||||
Do czego Yii jest najlepsze ?
|
||||
=============================
|
||||
Dla jakich zastosowań Yii jest najlepszy?
|
||||
-----------------------------------------
|
||||
|
||||
Yii jest frameworkiem www ogólnego przeznaczenia, co znaczy że może być użyte do kodowania
|
||||
wszystkich rodzajów aplikacji webowych używających PHP. Z uwagi na architekturę
|
||||
opartą na komponentach i wyrafinowane wsparcie dla mechanizmów buforowania, jest on odpowiedni
|
||||
do tworzenia wielkich aplikacji jak portale, fora, systemy zarządzania treścią (CMS),
|
||||
projekty komercyjne (e-sklepy), usługi webowe i inne.
|
||||
Yii jest frameworkiem ogólnego przeznaczenia, co oznacza, że może być wykorzystany do stworzenia
|
||||
każdego rodzaju aplikacji internetowych korzystających z PHP. Z uwagi na architekturę
|
||||
opartą na komponentach i zaawansowane wsparcie dla mechanizmów pamięci podręcznej jest on odpowiedni
|
||||
do tworzenia rozbudowanych aplikacji, takich jak: portale, fora, systemy zarządzania treścią (CMS),
|
||||
projekty komercyjne (e-sklepy), usługi sieciowe i inne.
|
||||
|
||||
Jak wygląda porównanie Yii z innymi frameworkami ?
|
||||
==================================================
|
||||
|
||||
Jeśli już znasz inny framework, możesz docenić następujące cechy:
|
||||
Jak wygląda porównanie Yii z innymi frameworkami?
|
||||
-------------------------------------------------
|
||||
|
||||
* Jak wiele frameworków, Yii implementuje architekturę MVC (model-widok-kontroller)
|
||||
i wspiera organizację kodu zgodną z tym wzorcem.
|
||||
* Yii opiera się na filozofii że kod powinien być pisany prosto i elegancko. Yii nie próbuje przeprojektowywać
|
||||
rzeczy tylko w celu dokładnego odwozowania wzorca projektowego.
|
||||
* Yii jest pełnym frameworkiem dostarczającym sprawdzone i gotowe do użycia funkcjonalności: konstruktory zapytań
|
||||
i ActiveRecord dla baz danych relacyjnych oraz NoSql; wsparcie dla RESTFull API;
|
||||
wielostopniowe wsparcie dla buforowania; i więcej.
|
||||
* Yii jest niezwykle rozszerzalne. Możesz dostosować lub zmienić prawie każdy fragment rdzennego kodu. Możesz wykorzystać architekturę rozszerzeń, aby używać lub tworzyć łatwe do rozpowszechniania rozszerzenia.
|
||||
* Wysoka wydajność jest zawsze głównym celem w Yii.
|
||||
Jeśli korzystałeś już z innych frameworków, na pewno docenisz, jak Yii wypada na ich tle:
|
||||
|
||||
* Jak większość frameworków, Yii wykorzystuje architekturę MVC (Model-Widok-Kontroler) i wspiera organizację kodu zgodną z tym wzorcem.
|
||||
* Yii opiera się na filozofii, która mówi, że kod powinien być napisany w prosty, ale jednocześnie elegancki sposób. Yii nigdy nie będzie upierać się przy przeprojektowaniu
|
||||
kodu jedynie w celu dokładnego trzymania się zasad wzorca projektowego.
|
||||
* Yii jest w pełni rozwiniętym frameworkiem dostarczającym sprawdzonych i gotowych do użycia funkcjonalności: konstruktorów zapytań
|
||||
oraz ActiveRecord dla baz danych relacyjnych i NoSQL, wsparcia dla tworzenia RESTful API oraz wielopoziomowych mechanizmów pamięci podręcznej i wielu, wielu innych.
|
||||
* Yii jest ekstremalnie rozszerzalny. Możesz dostosować lub wymienić praktycznie każdy fragment podstawowego kodu.
|
||||
Dodatkowo Yii wykorzystuje architekturę rozszerzeń, dzięki czemu możesz w prosty sposób stworzyć i opublikować swoje własne moduły i widżety.
|
||||
* Podstawowym celem, do którego Yii zawsze dąży, jest wysoka wydajność.
|
||||
|
||||
Yii nie jest efektem pracy pojedynczego programisty - projekt wspiera zarówno [grupa doświadczonych deweloperów][about_yii], jak i ogromna społeczność programistyczna, nieustannie
|
||||
przyczyniając się do jego rozwoju. Deweloperzy trzymają rękę na pulsie najnowszych trendów Internetu, za pomocą prostych i eleganckich interfejsów wzbogacając Yii w najlepsze sprawdzone
|
||||
rozwiązania i funkcjonalności, dostępne w innych frameworkach i projektach.
|
||||
|
||||
|
||||
Wersje Yii
|
||||
==========
|
||||
----------
|
||||
|
||||
Yii aktualnie dostępny jest w dwóch głównych wersjach: 1.1 i 2.0. Wersja 1.1 jest kodem starszej generacji, obecnie w fazie utrzymaniowej.
|
||||
Wersja 2.0 jest całkowicie przepisaną wersją Yii z uwzględnieniem najnowszych protokołów i technologii, takich jak Composer, PSR, przestrzenie nazw, traity i wiele innych.
|
||||
2.0 reprezentuje aktualną generację frameworka i na niej skupi się głównie praca programistów w ciągu najbliższych lat.
|
||||
Ten przewodnik opisuje wersję 2.0.
|
||||
|
||||
Yii ma aktualnie <i>(2014-12-28 - przyp tłumacza)</i> rozpowszechniane dwie główne wersje: 1.1 i 2.0. Wersja 1.1 jest starszej generacji <i>(dla PHP 5.1)</i>
|
||||
i jest w fazie utrzymaniowej. Wersja 2.0 jest całkowiecie przepisaną wersją Yii uwzględniającą
|
||||
najnowsze technologie i protokoły, w tym Composer,PSR,przestrzenie nazw, traity i więcej.
|
||||
Wersja 2.0 reprezentuje aktualną generację frameworka i otrzyma największe wsparcie programistów
|
||||
przez najbliższe lata. Ten podręcznik jest wyłącznie o wersji 2.0.
|
||||
|
||||
Wymagania i zależności
|
||||
======================
|
||||
----------------------
|
||||
|
||||
Yii 2.0 wymaga PHP 5.4.0 lub nowszego. Dokładniejsze wymagania dla konkretnych funkcjonalności
|
||||
możesz sprawdzić uruchamiając tester wymagań `requirements.php` dołączony w każdym wydaniu Yii.
|
||||
Yii 2.0 wymaga PHP w wersji 5.4.0 lub nowszej. Aby otrzymać więcej informacji na temat wymagań i indywidualnych funkcjonalności,
|
||||
uruchom specjalny skrypt testujący system `requirements.php`, dołączony w każdym wydaniu Yii.
|
||||
|
||||
Używanie Yii wymaga podstawowej wiedzy o programowaniu obiektowym w PHP (OOP), ponieważ Yii
|
||||
jest frameworkiem czysto obiektowym. Yii 2.0 wykorzystuje ostatnie udoskonalenia w PHP, jak
|
||||
przestrzenie nazw i traity. Zrozumienie tych konstrukcji pomoże ci łatwiej zdecydować się na Yii 2.0.
|
||||
[przestrzenie nazw](http://www.php.net/manual/pl/language.namespaces.php) i [traity](http://www.php.net/manual/pl/language.oop5.traits.php).
|
||||
Zrozumienie tych konstrukcji pomoże Ci szybciej i łatwiej rozpocząć pracę z Yii 2.0.
|
||||
|
||||
.
|
||||
|
||||
Reference in New Issue
Block a user