Alexander Makarov
9 years ago
10 changed files with 696 additions and 0 deletions
@ -0,0 +1,18 @@ |
|||||||
|
Pamięć podręczna |
||||||
|
================ |
||||||
|
|
||||||
|
Mechanizmy wykorzystujące pamięć podręczną pozwalają na poprawienie wydajności aplikacji sieciowej w tani i efektywny sposób. |
||||||
|
Zapisanie mniej lub bardziej statycznych danych w pamięci podręcznej i serwowanie ich stamtąd, zamiast generować je od podstaw przy każdym |
||||||
|
wywołaniu, pozwala na znaczne zaoszczędzenie czasu odpowiedzi aplikacji. |
||||||
|
|
||||||
|
Zapis pamięci podręcznej może odbywać się na wielu poziomach i w wielu miejscach aplikacji. Po stronie serwera, na niskim poziomie, |
||||||
|
można wykorzystać pamięć podręczną do zapisania podstawowych danych, takich jak zbiór informacji o najnowszych artykułach pobieranych z bazy danych. |
||||||
|
Na wyższym poziomie, pamięci podręcznej można użyć do przechowania części bądź całości strony www, na przykład w postaci rezultatu wyrenderowania |
||||||
|
listy ww. najświeższych artykułów. Po stronie klienta, pamięć podręczna HTTP przeglądarki może zapisać zawartość ostatnio odwiedzonej strony. |
||||||
|
|
||||||
|
Yii wpiera wszystkie te mechanizmy zapisu w pamięci podręcznej: |
||||||
|
|
||||||
|
* [Pamięć podręczna danych](caching-data.md) |
||||||
|
* [Pamięć podręczna fragmentów](caching-fragment.md) |
||||||
|
* [Pamięć podręczna stron](caching-page.md) |
||||||
|
* [Pamięć podręczna HTTP](caching-http.md) |
||||||
@ -0,0 +1,41 @@ |
|||||||
|
Pamięć podręczna stron |
||||||
|
====================== |
||||||
|
|
||||||
|
Pamięć podręczna stron odnosi się do zapisu zawartości całej strony po stronie serwera. Kiedy zostanie ona ponownie wywołana, |
||||||
|
zawartość zostanie wyświetlona od razu z pamięci podręcznej zamiast generować ją ponownie od podstaw. |
||||||
|
|
||||||
|
Pamięć podręczna stron jest obsługiwana przez [[yii\filters\PageCache]], [filtr akcji](structure-filters.md). |
||||||
|
Poniżej znajdziesz przykładowy sposób użycia w klasie kontrolera: |
||||||
|
|
||||||
|
```php |
||||||
|
public function behaviors() |
||||||
|
{ |
||||||
|
return [ |
||||||
|
[ |
||||||
|
'class' => 'yii\filters\PageCache', |
||||||
|
'only' => ['index'], |
||||||
|
'duration' => 60, |
||||||
|
'variations' => [ |
||||||
|
\Yii::$app->language, |
||||||
|
], |
||||||
|
'dependency' => [ |
||||||
|
'class' => 'yii\caching\DbDependency', |
||||||
|
'sql' => 'SELECT COUNT(*) FROM post', |
||||||
|
], |
||||||
|
], |
||||||
|
]; |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
W powyższym przykładzie kod zakłada użycie pamięci tylko dla akcji `index` - zawartość strony powinna zostać zapisana na maksymalnie |
||||||
|
60 sekund i powinna różnić się w zależności od wybranego w aplikacji języka. Dodatkowo, jeśli całkowita liczba postów w bazie danych ulegnie zmianie, |
||||||
|
zawartość pamięci powinna natychmiast stracić ważność i zostać pobrana ponownie. |
||||||
|
|
||||||
|
Jak widać, pamięć podręczna stron jest bardzo podobna do [pamięci podręcznej fragmentów](caching-fragment.md). W obu przypadkach można |
||||||
|
użyć opcji takich jak `duration` (czas ważności), `dependencies` (zależności), `variations` (warianty) oraz `enabled` (flaga aktywowania). |
||||||
|
Główną różnicą tych dwóch przypadków jest to, że pamięć podręczna stron jest implemetowana jako [filtr akcji](structure-filters.md), a |
||||||
|
pamięć podręczna fragmentów jako [widżet](structure-widgets.md). |
||||||
|
|
||||||
|
Oczywiście nic nie stoi na przeszkodzie, aby używać [pamięci podręcznej fragmentów](caching-fragment.md) jak |
||||||
|
i [zawartości dynamicznej](caching-fragment.md#dynamic-content) w połączeniu z pamięcią podręczną stron. |
||||||
|
|
||||||
@ -0,0 +1,234 @@ |
|||||||
|
Praca z bazami danych |
||||||
|
====================== |
||||||
|
|
||||||
|
Ta sekcja opisuje jak utworzyć nową stronę, która będzie wyświetlała dane krajów pobrane z tabeli bazy danych o nazwie `country`. |
||||||
|
Aby to osiągnąć, musisz skonfigurować swoje połączenie z bazą danych, utworzyć klasę [Active Record](db-active-record.md), zdefiniować [akcję](structure-controllers.md) oraz utworzyć [widok](structure-views.md) |
||||||
|
|
||||||
|
W tej sekcji nauczysz się: |
||||||
|
|
||||||
|
* konfigurowania połączenia z bazą danych, |
||||||
|
* tworzenia klasy Active Record, |
||||||
|
* tworzenia zapytań o dane przy użyciu klasy Active Record, |
||||||
|
* wyświetlania danych w widoku wraz ze stronicowaniem. |
||||||
|
|
||||||
|
|
||||||
|
Zauważ, że w celu przejścia tej sekcji należy mieć już podstawową wiedzę o bazach danych. |
||||||
|
W szczególności powinieneś wiedzieć, jak utworzyć bazę dancyh oraz jak wywołać komendę SQL używając klienta bazy danych. |
||||||
|
|
||||||
|
Przygotowanie bazy danych <span id="preparing-database"></span> |
||||||
|
---------------------- |
||||||
|
|
||||||
|
Aby rozpocząć musisz utworzyć bazę danych o nazwie `yii2basic`, z której będziesz pobierał dane do swojej aplikacji. |
||||||
|
Możesz utworzyć bazę SQLite, MySQL, PostgreSQL, MSSQL lub Oracle, ponieważ Yii posiada wbudowane wsparcie dla wielu aplikacji bazodanowych. |
||||||
|
Dla uproszczenia w naszym przykładzie wykorzystamy MySQL. |
||||||
|
|
||||||
|
Następnie, utwórz tabelę o nazwie `country` i wstaw przykładowe dane. Możesz użyc poniższej komendy: |
||||||
|
|
||||||
|
```sql |
||||||
|
CREATE TABLE `country` ( |
||||||
|
`code` CHAR(2) NOT NULL PRIMARY KEY, |
||||||
|
`name` CHAR(52) NOT NULL, |
||||||
|
`population` INT(11) NOT NULL DEFAULT '0' |
||||||
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8; |
||||||
|
|
||||||
|
INSERT INTO `country` VALUES ('AU','Australia',18886000); |
||||||
|
INSERT INTO `country` VALUES ('BR','Brazil',170115000); |
||||||
|
INSERT INTO `country` VALUES ('CA','Canada',1147000); |
||||||
|
INSERT INTO `country` VALUES ('CN','China',1277558000); |
||||||
|
INSERT INTO `country` VALUES ('DE','Germany',82164700); |
||||||
|
INSERT INTO `country` VALUES ('FR','France',59225700); |
||||||
|
INSERT INTO `country` VALUES ('GB','United Kingdom',59623400); |
||||||
|
INSERT INTO `country` VALUES ('IN','India',1013662000); |
||||||
|
INSERT INTO `country` VALUES ('RU','Russia',146934000); |
||||||
|
INSERT INTO `country` VALUES ('US','United States',278357000); |
||||||
|
``` |
||||||
|
|
||||||
|
W tym miejscu masz już utworzoną bazę danych o nazwie `yii2basic`, posiadającą tabelę `country` z trzeba kolumnami. Tabela zawiera 10 wierszy danych. |
||||||
|
|
||||||
|
Konfiguracja połączenia z bazą danych <span id="configuring-db-connection"></span> |
||||||
|
--------------------------- |
||||||
|
|
||||||
|
Przed przystąpieniem do tej części, upewnij się, że masz zainstalowane rozszerzenie [PDO](http://www.php.net/manual/en/book.pdo.php) oraz sterownik PDO dla bazy danych której używasz (np. `pdo_mysql` dla MySQL). |
||||||
|
Jest to podstawowe wymaganie jeśli Twoja aplikacja używa relacyjnej bazy danych. |
||||||
|
|
||||||
|
Jeśli posiadasz zainstalowane powyższe rozszerzenia, otwórz plik `config/db.php` i zmień parametry na odpowiednie do Twojej bazy danych. Domyślnie plik zawiera poniższy fragment: |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
|
||||||
|
return [ |
||||||
|
'class' => 'yii\db\Connection', |
||||||
|
'dsn' => 'mysql:host=localhost;dbname=yii2basic', |
||||||
|
'username' => 'root', |
||||||
|
'password' => '', |
||||||
|
'charset' => 'utf8', |
||||||
|
]; |
||||||
|
``` |
||||||
|
|
||||||
|
Plik `config/db.php` jest typowym narzędziem [konfiguracyjnym](concept-configurations.md) opartym na plikach. |
||||||
|
Ten szczególny plik konfiguracyjny określa parametry potrzebne do utworzenia oraz zainicjalizowania instancji [[yii\db\Connection]], dzięki czemu będziesz mógł wywoływać komendy SQL dp swojej bazy przez aplikację. |
||||||
|
|
||||||
|
Powyższa konfiguracja może być dostępna z poziomu kodu aplikacji używając wyrażenia `Yii::$app->db`. |
||||||
|
|
||||||
|
> Info: Plik `config/db.php` będzie załączony do głównej konfiguracji aplikacji `config/web.php`, która określa jak instancja [aplikacji](structure-applications.md) powinna zostać zainicjalizowana. |
||||||
|
Po więcej informacji zajrzyj do sekcji [konfiguracje](concept-configurations.md) |
||||||
|
|
||||||
|
|
||||||
|
Tworzenie klasy Active Record <span id="creating-active-record"></span> |
||||||
|
------------------------- |
||||||
|
|
||||||
|
Do pobrania i reprezentowania danych z tabeli `country` utwórz pochodną klasę [Active Record](db-active-record.md) o nazwie `Country`, kolejnie zapisz ją w pliku `models/Country.php`. |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
|
||||||
|
namespace app\models; |
||||||
|
|
||||||
|
use yii\db\ActiveRecord; |
||||||
|
|
||||||
|
class Country extends ActiveRecord |
||||||
|
{ |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Klasa `Country` rozszerza klasę [[yii\db\ActiveRecord]]. Nie musisz pisać w niej żadnego kodu! Posiadając tylko powyżej podany kod, Yii odgadnie nazwę powiązanej tabeli z nazwy klasy. |
||||||
|
|
||||||
|
> Info: Jeśli nie można dopasować tabeli do nazwy klasy, możesz nadpisać metodę [[yii\db\ActiveRecord::tableName()]] aby wskazywała na konkretną powiązaną tabelę. |
||||||
|
|
||||||
|
Używając klasy `Country` możesz w łatwy sposób manipulować danymi z tabeli `country`, tak jak pokazano w poniższych przykładach: |
||||||
|
|
||||||
|
```php |
||||||
|
use app\models\Country; |
||||||
|
|
||||||
|
// pobiera wszystkie wiersze tabeli `country` i porządkuje je według kolumny "name" |
||||||
|
$countries = Country::find()->orderBy('name')->all(); |
||||||
|
|
||||||
|
// pobiera wiersz, którego kluczem głównym jest "US" |
||||||
|
$country = Country::findOne('US'); |
||||||
|
|
||||||
|
// wyświetla "United States" |
||||||
|
echo $country->name; |
||||||
|
|
||||||
|
// modyfikuje nazwę kraju na "U.S.A." i zapisuje go do bazy danych |
||||||
|
$country->name = 'U.S.A.'; |
||||||
|
$country->save(); |
||||||
|
``` |
||||||
|
|
||||||
|
> Info: Active Record jest potężnym narzędziem do dostępu i manipulacji danymi w bazie danych w sposób zorientowany obiektowo. |
||||||
|
Więcej szczegółowych informacji znajdziesz w sekcji [Active Record](db-active-record.md). Alternatywnie, do łączenia się z bazą danych możesz użyć niskopoziomowej metody dostępu do danych nazwanej [Data Access Objects](db-dao.md). |
||||||
|
|
||||||
|
|
||||||
|
Tworzenie akcji <span id="creating-action"></span> |
||||||
|
------------------ |
||||||
|
|
||||||
|
Aby przedstawić kraje użytkownikowi musisz utworzyć nową akcję. Zamiast umieszczać nową akcję w kontrolerze `site`, tak jak w poprzednich sekcjach, bardziej sensownym rozwiązaniem jest utworzenie nowego kontrolera |
||||||
|
odpowiedzialnego za wszystkie akcje dotyczące danych z tabeli `country`. Nazwij nowy kontroler `CountryController`, a następnie utwórz w nim akcję `index`, tak jak na poniższym przykładzie: |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
|
||||||
|
namespace app\controllers; |
||||||
|
|
||||||
|
use yii\web\Controller; |
||||||
|
use yii\data\Pagination; |
||||||
|
use app\models\Country; |
||||||
|
|
||||||
|
class CountryController extends Controller |
||||||
|
{ |
||||||
|
public function actionIndex() |
||||||
|
{ |
||||||
|
$query = Country::find(); |
||||||
|
|
||||||
|
$pagination = new Pagination([ |
||||||
|
'defaultPageSize' => 5, |
||||||
|
'totalCount' => $query->count(), |
||||||
|
]); |
||||||
|
|
||||||
|
$countries = $query->orderBy('name') |
||||||
|
->offset($pagination->offset) |
||||||
|
->limit($pagination->limit) |
||||||
|
->all(); |
||||||
|
|
||||||
|
return $this->render('index', [ |
||||||
|
'countries' => $countries, |
||||||
|
'pagination' => $pagination, |
||||||
|
]); |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Zapisz powyższy kod w pliku `controllers/CountryController.php`. |
||||||
|
|
||||||
|
Akcja `index` wywołuje metodę `Country::find()`, pochodzącą z klasy Active Record, która buduje zapytanie bazodanowe i wyszukuje wszystkich danych z tabeli `country`. |
||||||
|
Aby ograniczyć liczbę zwracanych krajów w każdym żądaniu, zapytanie jest stronicowane przy pomocy obiektu [[yii\data\Pagination]]. Obiekt `Pagination` służy dwóm celom: |
||||||
|
|
||||||
|
* Ustawia klauzule `offset` i `limit` do komend SQL reprezentowanych przez zapytanie tak, aby zwracały tylko jedną stronę na raz (maksymalnie 5 wierszy na stronę), |
||||||
|
* Jest używany w widoku do wyświetlania stronicowania jako listy przycisków z numerami stron, co będzie wyjaśnione w kolejnej sekcji. |
||||||
|
|
||||||
|
Na końcu akcja `index` renderuje widok o nazwie `index`, do którego przekazuje dane krajów oraz informacje o ich stronicowaniu. |
||||||
|
|
||||||
|
|
||||||
|
Tworzenie widoku <span id="creating-view"></span> |
||||||
|
--------------- |
||||||
|
|
||||||
|
W katalogu `views` utwórz nowy katalog o nazwie `country`. Będzie on używany do przechowywania wszystkich plików widoków renderowanych przez kontroler `country`. W katalogu `views/country` utwórz plik o nazwie `index.php` zawierający poniższy kod: |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
use yii\helpers\Html; |
||||||
|
use yii\widgets\LinkPager; |
||||||
|
?> |
||||||
|
<h1>Kraje</h1> |
||||||
|
<ul> |
||||||
|
<?php foreach ($countries as $country): ?> |
||||||
|
<li> |
||||||
|
<?= Html::encode("{$country->name} ({$country->code})") ?>: |
||||||
|
<?= $country->population ?> |
||||||
|
</li> |
||||||
|
<?php endforeach; ?> |
||||||
|
</ul> |
||||||
|
|
||||||
|
<?= LinkPager::widget(['pagination' => $pagination]) ?> |
||||||
|
``` |
||||||
|
|
||||||
|
|
||||||
|
Widok posiada dwie części. Pierwsza część odpowiada za wyświetlenie danych krajów jako nieuporządkowana lista HTML, natomiast druga część renderuje widżet [[yii\widgets\LinkPager]] na podstawie dostarczonych mu informacji z akcji. |
||||||
|
Widżet `LinkPager` wyświetla listę przycisków z numerami stron. Kliknięcie w którykolwiek z nich zmienia dane z listy na dane odpowiadające wybranej stronie. |
||||||
|
|
||||||
|
Sprawdź jak to działa <span id="trying-it-out"></span> |
||||||
|
------------- |
||||||
|
|
||||||
|
Aby zobaczyć jak działa powyższy kod, użyj przeglądarki i przejdź pod podany adres URL: |
||||||
|
|
||||||
|
``` |
||||||
|
http://hostname/index.php?r=country/index |
||||||
|
``` |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Na początku zobaczysz stronę pokazującą pięć krajów. Poniżej listy znajduje się paginacja z czterema przyciskami. |
||||||
|
Jeśli klikniesz przycisk "2", zobaczysz stronę wyświetlającą pięć innych krajów z bazy danych: druga strona wierszy. |
||||||
|
Zauważ, że adres URL w przeglądarce również się zmienił na |
||||||
|
|
||||||
|
``` |
||||||
|
http://hostname/index.php?r=country/index&page=2 |
||||||
|
``` |
||||||
|
|
||||||
|
Za kulisami, [[yii\data\Pagination|Pagination]] dostarcza wszystkich niezbędnych funkcjonalności do stronicowania zbioru danych: |
||||||
|
|
||||||
|
* Początkowo, [[yii\data\Pagination|Pagination]] prezentuje pierwszą stronę, która odzwierciedla zapytanie "SELECT" tabeli `country` z klauzulą `LIMIT 5 OFFSET 0`. |
||||||
|
W rezultacie pobieranych i wyświetlanych jest pięć pierwszych krajów. |
||||||
|
* Widżet [[yii\widgets\LinkPager|LinkPager]] renderuje przyciski stron używając adresów URL tworzonych przez metodę [[yii\data\Pagination::createUrl()|Pagination]]. Adresy zawierają parametr zapytania `page`, który reprezentuje różne numery stron. |
||||||
|
* jeśli klikniesz przycisk "2", zostanie uruchomione i przetworzone nowe żądanie dla route'a `country/index`. |
||||||
|
[[yii\data\Pagination|Pagination]] odczytuje parametr `query` z adresu URL, a następnie ustawia aktualny numer strony na 2. |
||||||
|
Nowe zapytanie o kraje będzie zawierało klauzulę `LIMIT 5 OFFSET 5` i zwróci pięć kolejnych krajów do wyświetlenia. |
||||||
|
|
||||||
|
|
||||||
|
Podsumowanie <span id="summary"></span> |
||||||
|
------- |
||||||
|
|
||||||
|
W tej sekcji nauczyłeś się jak pracować z bazą danych. Nauczyłeś się również jak pobierać i wyświetlać dane ze stronicowaniem przy pomocy [[yii\data\Pagination]] oraz [[yii\widgets\LinkPager]]. |
||||||
|
|
||||||
|
W następnej sekcji nauczysz się jak używać potężnego narzędzie do generowania kodu nazwanego [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide/README.md), |
||||||
|
aby pomóc Ci w szybki sposób implementować niektóre powszechnie wymagane funkcjonalności, takie jak operacje CRUD dla zadań z danymi w bazie danych. |
||||||
|
W rzeczywistości, kod który właśnie napisaliśmy może być w pełni wygenerowany w Yii przy użyciu narzędzia Gii. |
||||||
@ -0,0 +1,128 @@ |
|||||||
|
Generowanie kodu w Gii |
||||||
|
======================== |
||||||
|
|
||||||
|
Ta sekcja opisuje jak używać [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide/README.md) do automatycznego generowania kodu, który implementuje podstawowe funkcjonalności do aplikacji Web. |
||||||
|
Używanie Gii do automatycznego generowania kodu jest po prostu kwestią wprowadzenia odpowiednich informacji w formularzach zgodnie z instrukcjami widocznymi na podstronach Gii. |
||||||
|
|
||||||
|
W tym poradniku nauczysz się: |
||||||
|
|
||||||
|
* aktywować Gii w Twojej aplikacji, |
||||||
|
* używać Gii do generowania klas Active Record, |
||||||
|
* używać Gii do generowania kodu implementującego operacje CRUD dla tabel bazy danych, |
||||||
|
* dostosować kod wygenerowany przez Gii, |
||||||
|
|
||||||
|
|
||||||
|
Początki z Gii <span id="starting-gii"></span> |
||||||
|
------------ |
||||||
|
|
||||||
|
[Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide/README.md) jest dostarczonym przez Yii [modułem](structure-modules.md). |
||||||
|
Możesz aktywować Gii konfigurując właściwość [[yii\base\Application::modules|modules]] aplikacji. Zależnie od tego, jak utworzyłeś swoją aplikację, może się okazać, że poniższy kod jest już zawarty w pliku konfiguracyjnym `config/web.php`: |
||||||
|
|
||||||
|
```php |
||||||
|
$config = [ ... ]; |
||||||
|
|
||||||
|
if (YII_ENV_DEV) { |
||||||
|
$config['bootstrap'][] = 'gii'; |
||||||
|
$config['modules']['gii'] = 'yii\gii\Module'; |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
Powyższa konfiguracja sprawdza, czy aplikacja jest w [środowisku rozwojowym](concept-configurations.md#environment-constants), jeśli tak, dołącza moduł `gii` określając klasę modułu [[yii\gii\Module]]. |
||||||
|
|
||||||
|
Jeśli sprawdzisz [skrypt wejściowy](structure-entry-scripts.md) `web/index.php` Twojej aplikacji, zauważysz linię, która ustawia `YII_ENV` na wartość `dev`. |
||||||
|
|
||||||
|
```php |
||||||
|
defined('YII_ENV') or define('YII_ENV', 'dev'); |
||||||
|
``` |
||||||
|
|
||||||
|
Dzięki tej linii, Twoja aplikacja jest w trybie rozwojowym, przez co aktywny jest moduł Gii. Możesz teraz uzyskać dostęp do Gii przez przejście pod podany adres URL: |
||||||
|
|
||||||
|
``` |
||||||
|
http://hostname/index.php?r=gii |
||||||
|
``` |
||||||
|
|
||||||
|
> Note: Jeśli próbujesz dostać się do Gii z maszyny innej niż localhost, dostęp domyślnie będzie zablokowany ze względów bezpieczeństwa. |
||||||
|
> Możesz dodać dozwolone adresy IP następująco: |
||||||
|
> |
||||||
|
```php |
||||||
|
'gii' => [ |
||||||
|
'class' => 'yii\gii\Module', |
||||||
|
'allowedIPs' => ['127.0.0.1', '::1', '192.168.0.*', '192.168.178.20'] // adjust this to your needs |
||||||
|
], |
||||||
|
``` |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
|
||||||
|
Generowanie klasy Active Record <span id="generating-ar"></span> |
||||||
|
--------------------------------- |
||||||
|
|
||||||
|
Aby użyć Gii do wygenerowania klasy Active Record, wybierz "Model Generator" z odnośników na stronie głównej Gii. Następnie uzupełnij formularz następująco: |
||||||
|
|
||||||
|
* Table Name: `country` |
||||||
|
* Model Class: `Country` |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Następnie, kliknij przycisk "Preview". Powinieneś zauważyć na liście plik `models/Country.php` który zostanie utworzony. Możesz kliknąć w nazwę pliku aby zobaczyć podgląd jego zawartości. |
||||||
|
|
||||||
|
Podczas używania Gii, jeśli posiadałeś już utworzony plik o tej samej nazwie i będziesz chciał go nadpisać, kliknij w przycisk `diff` obok nazwy pliku aby zobaczyć różnice w kodzie pomiędzy wygenerowanym a już istniejącym plikiem. |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Podczas nadpisywania istniejącego już pliku musisz zaznaczyć opcję "overwrite", a kolejnie kliknąć przycisk "Generate". Jeśli tworzysz nowy plik, wystarczy jeśli klikniesz "Generate". |
||||||
|
|
||||||
|
Następnie zobaczysz stronę potwierdzającą, że kod został pomyślnie wygenerowany. Jeśli nadpisywałeś istniejący już plik, zobaczysz również wiadomość o nadpisaniu go nowo wygenerowanym kodem. |
||||||
|
|
||||||
|
Generowanie kodu CRUD <span id="generating-crud"></span> |
||||||
|
-------------------- |
||||||
|
|
||||||
|
CRUD oznacza tworzyć, czytać, aktualizować oraz usuwać (Create-Read-Update-Delete), reprezentuje cztery podstawowe zadania dotyczące obsługi danych w większości serwisów internetowych. |
||||||
|
Aby utworzyć funkcjonalność CRUD używając Gii, wybierz na stronie głównej Gii "CRUD Generator". Do przykładu "country" uzupełnij formularz następująco: |
||||||
|
|
||||||
|
* Model Class: `app\models\Country` |
||||||
|
* Search Model Class: `app\models\CountrySearch` |
||||||
|
* Controller Class: `app\controllers\CountryController` |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Następnie kliknij przycisk "Preview". Zobaczysz listę plików które zostaną wygenerowane, tak jak pokazano niżej. |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Jeśli wcześniej utworzyłeś pliki `controllers/CountryController.php` oraz `views/country/index.php` (w sekcji baz danych tego poradnika), zaznacz opcję "overwrite" aby je zastąpić (Poprzednia wersja nie posiada pełnego wsparcia CRUD). |
||||||
|
|
||||||
|
Próba <span id="trying-it-out"></span> |
||||||
|
------------- |
||||||
|
|
||||||
|
Aby zobaczyć jak działa nowo wygenerowany kod użyj przeglądarki aby uzyskać dostęp do podanego adresu URL: |
||||||
|
|
||||||
|
``` |
||||||
|
http://hostname/index.php?r=country/index |
||||||
|
``` |
||||||
|
|
||||||
|
Zobaczysz tabelę prezentującą kraje z bazy danych. Możesz sortować tabelę, lub filtrować ją przez wpisanie odpowiednich warunków w nagłówkach kolumn. |
||||||
|
|
||||||
|
Dla każdego wyświetlanego kraju możesz zobaczyć jego szczegóły, zaktualizować go lub usunąć. |
||||||
|
Możesz również kliknąć przycisk "Create Country" aby przejść do formularza tworzenia nowego państwa. |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Poniżej przedstawiamy listę plików wygenerowanych przez Gii, jeśli chciałbyś zbadać jak zostały zaimplementowane te funkcjonalności (lub je edytować): |
||||||
|
|
||||||
|
* Kontroler: `controllers/CountryController.php` |
||||||
|
* Model: `models/Country.php` and `models/CountrySearch.php` |
||||||
|
* Widok: `views/country/*.php` |
||||||
|
|
||||||
|
> Info Gii zostało zaprojektowane jako wysoce konfiguralne i rozszerzalne narzędzie przeznaczone do generowania kodu. |
||||||
|
Prawidłowe używanie go może znacznie przyspieszyć szybkość tworzenia Twojej aplikacji. Po więcej szczegółów zajrzyj do sekcji [Gii](https://github.com/yiisoft/yii2-gii/blob/master/docs/guide/README.md) |
||||||
|
|
||||||
|
|
||||||
|
Podsumowanie <span id="summary"></span> |
||||||
|
------- |
||||||
|
|
||||||
|
W tej sekcji nauczyłeś się jak używać Gii do wygenerowania kodu, który implementuje pełną funkcjonalność CRUD dla treści zawartch w tabelach bazy danych. |
||||||
|
In this section, you have learned how to use Gii to generate the code that implements complete |
||||||
|
CRUD functionality for content stored in a database table. |
||||||
@ -0,0 +1,118 @@ |
|||||||
|
Witaj świecie |
||||||
|
============ |
||||||
|
|
||||||
|
Ta sekcja opisuje jak utworzyć nową stronę "Witaj" w Twojej aplikacji. |
||||||
|
Aby to osiągnąć, musisz utworzyć [akcję](structure-controllers.md#creating-actions) i [widok](structure-views.md): |
||||||
|
|
||||||
|
* Aplikacja wyśle żądanie strony web do akcji |
||||||
|
* Następnie akcja włączy widok, który pokazuje użytkownikowi słowo "Witaj". |
||||||
|
|
||||||
|
Podczas tego poradnika nauczysz się trzech rzeczy: |
||||||
|
|
||||||
|
1. Jak utworzyć [akcję](structure-controllers.md#creating-actions), która będzie odpowiadać na żądania, |
||||||
|
2. Jak utworzyć [widok](structure-views.md), aby wyeksponować treść odpowiedzi, |
||||||
|
3. Jak aplikacja wysyła żądania do [akcji](structure-controllers.md#creating-actions). |
||||||
|
|
||||||
|
Tworzenie akcji <span id="creating-action"></span> |
||||||
|
------------------ |
||||||
|
|
||||||
|
Do zadania "Witaj" utworzysz [akcję](structure-controllers.md#creating-actions) `say`, która odczytuje parametr `message` z żądania oraz wyświetla tą wiadomość użytkownikowi. |
||||||
|
Jeśli żądanie nie dostarczy parametru `message`, akcja wyświetli domyślnie wiadomość "Witaj". |
||||||
|
|
||||||
|
> Info: [Akcje](structure-controllers.md#creating-actions) są obiektami, do których użytkownik może bezpośrednio odnieść się, aby je wywołać. |
||||||
|
Akcje są pogrupowane przez [kontrolery](structure-controllers.md). Wynikiem użycia akcji jest odpowiedź, którą otrzyma końcowy użytkownik. |
||||||
|
|
||||||
|
Akcje muszą być deklarowane w [kontrolerach](structure-controllers.md). Dla uproszczenia, możesz zdeklarować akcję `say` w już istniejącym kontrolerze `SiteController`. |
||||||
|
Kontroler jest zdefiniowany w klasie `controllers/SiteController.php`. Oto początek nowej akcji: |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
|
||||||
|
namespace app\controllers; |
||||||
|
|
||||||
|
use yii\web\Controller; |
||||||
|
|
||||||
|
class SiteController extends Controller |
||||||
|
{ |
||||||
|
// ...obecny kod... |
||||||
|
|
||||||
|
public function actionSay($message = 'Hello') |
||||||
|
{ |
||||||
|
return $this->render('say', ['message' => $message]); |
||||||
|
} |
||||||
|
} |
||||||
|
``` |
||||||
|
|
||||||
|
W powyższym kodzie, akcja `say` jest zdefiniowana jako metoda o nazwie `actionSay` w klasie `SiteController`. |
||||||
|
Yii używa prefixu `action` do rozróżnienia metod akcji od zwykłych metod w klasie kontrolera. Nazwa po prefixie `action` kieruje do ID akcji. |
||||||
|
|
||||||
|
Podczas nazywania Twoich akcji powinieneś zrozumieć jak Yii traktuje ID akcji. Odwołanie do ID akcji zawsze występuje z małych liter. |
||||||
|
Jeśli ID akcji potrzebuje wielu słów, będą one łączone myślnikami (np. `create-comment`). Nazwy metod akcji są przypisywane do ID akcji przez usunięcie myślników z ID, przekształcenie piewszej litery w słowie na dużą literę |
||||||
|
oraz dodanie prefixu `action`. Dla przykładu akcja o ID `create-comment` odpowiada metodzie akcji o nazwie `actionCreateComment`. |
||||||
|
|
||||||
|
Metoda akcji w naszym przykładzie przyjmuje parametr `$message`, którego wartość domyślna to `"Hello"` (w ten sam sposób ustawiasz domyślną wartość dla każdego argumentu funkcji lub metody w PHP). |
||||||
|
Kiedy aplikacja otrzymuje żądanie i określa, że akcja `say` jest odpowiedzialna za jego obsługę, aplikacja uzupełni parametr znaleziony w żądaniu. |
||||||
|
Innymi słowy, jeśli żądanie zawiera parametr `message` z wartością `"Goodbye"` to do zmiennej `$message` w akcji będzie przypisana ta wartość. |
||||||
|
|
||||||
|
W metodzie akcji wywołana jest funkcja [[yii\web\Controller::render()|render()]], która renderuje nam [widok](structure-views.md) pliku o nazwie `say`. |
||||||
|
Parametr `message` jest również przekazywany do widoku, co sprawia, że może być w nim użyty. Metoda akcji zwraca wynik renderowania. Wynik ten będzie odebrany przez aplikację oraz wyświetlony końcowemu użytownikowi w przeglądarce(jako część kompletnej strony HTML). |
||||||
|
|
||||||
|
Tworzenie widoku <span id="creating-view"></span> |
||||||
|
--------------- |
||||||
|
|
||||||
|
[Widoki](structure-views.md) są skryptami, które piszesz do generowania treści odpowiedzi. |
||||||
|
Do zadania "Hello" utworzysz widok `say`, który wypisuje parametr `message` otrzymany z metody akcji. |
||||||
|
|
||||||
|
```php |
||||||
|
<?php |
||||||
|
use yii\helpers\Html; |
||||||
|
?> |
||||||
|
<?= Html::encode($message) ?> |
||||||
|
``` |
||||||
|
|
||||||
|
Widok `say` powinien być zapisany w pliku `views/site/say.php`. Kiedy wywołana jest metoda [[yii\web\Controller::render()|render()]] w akcji, będzie ona szukała pliku PHP nazwanego jako `views/ControllerID/ViewName.php`. |
||||||
|
|
||||||
|
Zauważ, że w powyższym kodzie parametr `message` jest kodowany funkcją [[yii\helpers\Html::encode()|HTML-encoded]] przed wypisaniem go. Jest to konieczne w przypadku, gdy parametr pochodzi od użytkownika, co sprawia go wrażliwym na ataki |
||||||
|
[XSS](http://en.wikipedia.org/wiki/Cross-site_scripting) przez podanie złośliwego kodu JavaScript w parametrze. |
||||||
|
|
||||||
|
Naturalnie możesz umieścić więcej zawartości w widoku `say`. Zawartość może zawierać tagi HTML, czysty tekst, a nawet kod PHP. |
||||||
|
Tak naprawdę, widok `say` jest tylko skryptem PHP, który jest wywoływany przez metodę [[yii\web\Controller::render()|render()]]. |
||||||
|
Zawartość wyświetlana przez skrypt widoku będzie zwrócona do aplikacji jako wynik odpowiedzi. Aplikacja z kolei przedstawi ten wynik końcowemu użytkownikowi. |
||||||
|
|
||||||
|
Próba <span id="trying-it-out"></span> |
||||||
|
------------- |
||||||
|
|
||||||
|
Po utworzeniu akcji oraz widoku możesz uzyskać dostęp do nowej strony przez przejście pod podany adres URL: |
||||||
|
|
||||||
|
``` |
||||||
|
http://hostname/index.php?r=site/say&message=Hello+World |
||||||
|
``` |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Wynikiem wywołania tego adresu jest wyświetlenie napisu "Hello World". Strona dzieli ten sam nagłówek i stopkę z innymi stronami aplikacji. |
||||||
|
|
||||||
|
Jeśli pominiesz parametr `message` w adresie URL, zobaczysz na stronie tylko "Hello". `message` jest przekazywane jako parametr do metody `actionSay`, i jeśli zostanie pominięty, zostanie użyta domyślna wartość `"Hello"`. |
||||||
|
|
||||||
|
> Info: Nowa strona dzieli ten sam nagłówek i stopkę z innymi stronami, ponieważ metoda [[yii\web\Controller::render()|render()]] automatycznie osadza wynik widoku `say` w tak zwanym [układzie strony](structure-views.md#layouts), |
||||||
|
który, w tym przypadku, znajduje się w `views/layouts/main.php`. |
||||||
|
|
||||||
|
Parametr `r` w powyższym adresie URL potrzebuje większego wyjaśnienia. Oznacza on [route'a](runtime-routing.md), szeroki, unikatowy ID aplikacji, który odnosi się do akcji. |
||||||
|
Format route'a to `ControllerID/ActionID`. Kiedy aplikacja otrzymuje żądanie, sprawdza ten parametr, a kolejnie używa części `ControllerID` aby ustalić, która klasa kontrolera powinna zostać zainstancjowana aby przetworzyć to żądanie. |
||||||
|
Następnie, kontroler używa części `ActionID` do ustalenia która akcja powinna zostać użyta. W tym przykładzie, route `site/say` będzie odczytany jako klasa kontrolera `SiteController` oraz akcja `say`. |
||||||
|
W rezultacie będzie wywołana metoda `SiteController::actionSay()` to przetworzenia tego żądania. |
||||||
|
|
||||||
|
> Info: Tak jak akcje, kontrolery również posiadają swoje ID, które jednoznacznie identyfikują je w aplikacji. |
||||||
|
ID kontrolerów używają tych samych zasad nazewnictwa co ID akcji. Nazwy klas kontrolerów uzyskiwane są z ID kontrolerów przez usunięcie myślników z ID, zamianę pierwszej litery na dużą w każdym słowie oraz dodanie suffix'a `Controller`. |
||||||
|
Dla przykładu ID kontrolera `post-comment` odpowiada nazwie klasy kontrolera `PostCommentController`. |
||||||
|
|
||||||
|
Podsumowanie <span id="summary"></span> |
||||||
|
------- |
||||||
|
|
||||||
|
W tej sekcji zobaczyłeś część kontrolerów oraz widoków wzorca architektonicznego MVC. |
||||||
|
Utworzyłeś akcję jako część kontrolera do obsługi specyficznego żądania. Utworzyłeś też widok, który prezentuje zawartość odpowiedzi. |
||||||
|
W tym prostym przykładzie nie został zaangażowany żaden model, ponieważ dane jakimi się posługiwaliśmy były zawarte w parametrze `message`. |
||||||
|
|
||||||
|
Nauczyłeś się też czegoś o routingu w Yii, który działa jak most pomiędzy żądaniami użytkownika a akcjami kontrolerów. |
||||||
|
|
||||||
|
W następnej sekcji nauczysz się jak utworzyć model oraz dodać nową stronę zawierającą formularz HTML. |
||||||
@ -0,0 +1,87 @@ |
|||||||
|
Uruchamianie aplikacji |
||||||
|
==================== |
||||||
|
|
||||||
|
Po zainstalowaniu Yii posiadasz działającą aplikację Yii dostępną pod adresem `http://hostname/basic/web/index.php` lub `http://hostname/index.php`, zależnie od Twojej konfiguracji. |
||||||
|
Ta sekcja wprowadzi Cię do wbudowanych funkcjonalności aplikacji, pokaże jak zorganizowany jest jej kod oraz jak aplikacja obsługuje żądania. |
||||||
|
|
||||||
|
> Info: Dla uproszczenia, zakładamy, że ustawiłeś główny katalog serwera na `basic/web`, według poradnika "Instalacja Yii", oraz skonfigurowałeś adres URL tak, aby Twoja aplikacja była dostępna pod adresem `http://hostname/index.php`. |
||||||
|
Dla Twoich potrzeb dostosuj odpowiednio adres URL w naszych opisach. |
||||||
|
|
||||||
|
Należy pamiętać, że w przeciwieństwie do samego framework'a, po zainstalowaniu szablonu projektu jest on cały Twój. Możesz dowolnie dodawać, modyfikować lub usuwać kod, zależnie od Twoich potrzeb. |
||||||
|
|
||||||
|
Funkcjonalność <span id="functionality"></span> |
||||||
|
------------- |
||||||
|
|
||||||
|
Zainstalowana podstawowa aplikacja posiada cztery strony: |
||||||
|
|
||||||
|
* stronę główną, która jest wyświetlana przy wywołaniu adresu `http://hostname/index.php`, |
||||||
|
* strona informacyjna `About`, |
||||||
|
* strona kontaktowa `Contact`, gdzie wyświetlany jest formularz kontaktowy, pozwalający użytkownikowi skontaktować się z Tobą przez email, |
||||||
|
* strona logowania `Login`, gdzie wyświetlany jest formularz logowania, który może być użyty do uwierzytelniania użytkowników. Zaloguj się danymi "admin/admin", przez co pozycja `Login` z menu zamieni się na `Logout`. |
||||||
|
|
||||||
|
Wszystkie te strony posiadają wspólne nagłówek i stopkę. Nagłówek zawiera główne menu pozwalające na nawigację po innych stronach. |
||||||
|
|
||||||
|
Powinieneś również widzieć pasek narzędzi na dole okna przeglądarki. |
||||||
|
Jest to użyteczne [narzędzie do debugowania](https://github.com/yiisoft/yii2-debug/blob/master/docs/guide/README.md) dostarczone przez Yii zapisujące i wyświetlające wiele informacji, takich jak wiadomości logów, statusy odpowiedzi, zapytania do baz danych i wiele innych. |
||||||
|
|
||||||
|
Dodatkowo do aplikacji Web dostarczono skrypt konsolowy nazwany `yii`, który jest ulokowany w głównym katalogu aplikacji. |
||||||
|
Skrypt może być użyty do uruchomienia w tle zadań dla aplikacji, które są opisane w sekcji [Komendy konsolowe](tutorial-console.md). |
||||||
|
|
||||||
|
Struktura aplikacji <span id="application-structure"></span> |
||||||
|
--------------------- |
||||||
|
|
||||||
|
Najważniejsze katalogi oraz pliki w Twojej aplikacji to (zakładając, że główny katalog aplikacji to `basic`): |
||||||
|
|
||||||
|
``` |
||||||
|
basic/ bazowa ścieżka aplikacji |
||||||
|
composer.json plik używany przez Composer, opisuje informacje paczek |
||||||
|
config/ zawiera wszystkie konfiguracje, w tym aplikacji |
||||||
|
console.php konfiguracja konsoli aplikacji |
||||||
|
web.php konfiguracja aplikacji Web |
||||||
|
commands/ zawiera klasy komend konsoli |
||||||
|
controllers/ zawiera klasy kontrolerów |
||||||
|
models/ zawiera klasy modeli |
||||||
|
runtime/ zawiera pliki wygenerowane przez Yii podczas pracy, takie jak logi i pliki cache |
||||||
|
vendor/ zawiera zainstalowane paczki Composer'a, w tym framework Yii |
||||||
|
views/ zawiera pliki widoków |
||||||
|
web/ ścieżka aplikacji Web, zawiera dostępne publicznie pliki |
||||||
|
assets/ zawiera opublikowane przez Yii pliki zasobów (javascript oraz css) |
||||||
|
index.php skrypt wejściowy dla aplikacji |
||||||
|
yii skrypt wykonujący komendy konsolowe Yii |
||||||
|
``` |
||||||
|
|
||||||
|
Ogólnie pliki aplikacji mogą zostać podzielone na dwa typy: pliki w katalogu `basic/web` oraz pliki w innych katalogach. |
||||||
|
Dostęp do pierwszego typu można uzyskać przez HTTP (np. przez przeglądarkę), podczas gdy reszta nie może, i nie powinna być, dostępna publicznie. |
||||||
|
|
||||||
|
Yii implementuje wzór architektoniczny [model-widok-kontroler (MVC)](http://wikipedia.org/wiki/Model-view-controller), który jest odzwierciedleniem przedstawionej wyżej organizacji katalogów. |
||||||
|
Katalog `models` zawiera wszystkie [klasy modeli](structure-models.md), katalog `views` zawiera wszystkie [skrypty widoków](structure-views.md), oraz katalog `controllers` zawiera wszystkie [klasy kontrolerów](structure-controllers.md). |
||||||
|
|
||||||
|
Poniższy schemat pokazuje statyczną strukturę aplikacji. |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
Każda aplikacja zawiera skrypt wejściowy `web/index.php`, który jest jedynym publicznie dostępnym skryptem PHP w aplikacji. |
||||||
|
Skrypt wejściowy pobiera przychodzące żądanie i tworzy instancję [aplikacji](structure-applications.md) do przetworzenia tego żądania. |
||||||
|
[Aplikacja](structure-applications.md) obsługuje żądanie z pomocą [komponentów](concept-components.md), po czym wysyła żądanie do elementów MVC. |
||||||
|
[Widżety](structure-widgets.md) są używane w [widokach](structure-views.md) aby pomóc zbudować złożone i dynamiczne elementy interfejsu użytkownika. |
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Cykl życia żądania <span id="request-lifecycle"></span> |
||||||
|
----------------- |
||||||
|
|
||||||
|
Poniższy schemat pokazuje jak aplikacja przetwarza żądania. |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
1. Użytkownik tworzy zapytanie do [skryptu wejściowego](structure-entry-scripts.md) `web/index.php`. |
||||||
|
2. Skrypy wejściowy ładuje [konfigurację](concept-configurations.md) aplikacji oraz tworzy instancję [aplikacji](structure-applications.md) w celu przetworzenia żądania. |
||||||
|
3. Aplikacja obsługuje żądanie [route'a](runtime-routing.md) z pomocą komponentu [żądania](runtime-requests.md) aplikacji. |
||||||
|
4. Aplikacja tworzy instancję [kontrolera](structure-controllers.md) do obsługi żądania. |
||||||
|
5. Kontroler tworzy instancję [akcji](structure-controllers.md) i wykonuje filtrowanie dla akcji. |
||||||
|
6. Jeśli warunek dowolnego z filtrów nie jest spełniony, akcja jest zatrzymana. |
||||||
|
7. W przeciwnym wypadku wywoływana jest akcja. |
||||||
|
8. Akcja wczytuje model danych, prawdopodobnie z bazy danych. |
||||||
|
9. Akcja renderuje widok, dostarczając mu model danych. |
||||||
|
10. Wynik zwracany jest do komponentu [odpowiedzi](runtime-responses.md) aplikacji. |
||||||
|
11. Komponent odpowiedzi wysyła wynik do przeglądarki użytkownika. |
||||||
@ -0,0 +1,23 @@ |
|||||||
|
Struktura aplikacji |
||||||
|
=================== |
||||||
|
|
||||||
|
Aplikacja Yii jest zorganizowana według wzorca architektonicznego [model-widok-kontroler (MVC)](https://pl.wikipedia.org/wiki/Model-View-Controller). |
||||||
|
[Modele](structure-models.md) reprezentują dane, logikę biznesową i zasady walidacji, [widoki](structure-views.md) |
||||||
|
są odpowiedzialne za wyświetlanie informacji związanych z modelami, a [kontrolery](structure-controllers.md) przyjmują dane wejściowe |
||||||
|
i przekształcają je w polecenia dla [modeli](structure-models.md) i [widoków](structure-views.md). |
||||||
|
|
||||||
|
Oprócz MVC, w aplikacjach Yii zdefiniowane są następujące struktury: |
||||||
|
|
||||||
|
* [skrypty wejściowe](structure-entry-scripts.md): skrypty PHP dostępne bezpośrednio dla użytkowników końcowych, |
||||||
|
odpowiedzialne za uruchomienie obsługi cyklu życia żądania. |
||||||
|
* [aplikacje](structure-applications.md): globalnie dostępne obiekty koordynujące działanie i zarządzające komponentami aplikacji. |
||||||
|
* [komponenty aplikacji](structure-application-components.md): obiekty zarejestrowane w aplikacji, zapewniające dostępność dedykowanych usług. |
||||||
|
* [moduły](structure-modules.md): niezależne pakiety kodu zawierające kompletną wewnętrzną strukturę MVC. |
||||||
|
Aplikacja może być zorganizowana modułowo. |
||||||
|
* [filtry](structure-filters.md): reprezentują kod, który musi być wykonany przed i po obsłużeniu każdego z żądań kontrolera. |
||||||
|
* [widżety](structure-widgets.md): obiekty, które mogą być dołączone w [widokach](structure-views.md). Mogą zawierać logikę kontrolera |
||||||
|
i być wykorzystane wielokrotnie w różnych miejscach. |
||||||
|
|
||||||
|
Poniższy diagram ilustruje statyczną strukturę aplikacji: |
||||||
|
|
||||||
|
 |
||||||
@ -0,0 +1,11 @@ |
|||||||
|
Testy akceptacyjne |
||||||
|
================== |
||||||
|
|
||||||
|
> Uwaga: Ta sekcja jest w trakcie tworzenia. |
||||||
|
|
||||||
|
- http://codeception.com/docs/04-AcceptanceTests |
||||||
|
|
||||||
|
Uruchamianie testów akceptacyjnych dla podstawowego i zaawansowanego szablonu projektu |
||||||
|
-------------------------------------------------------------------------------------- |
||||||
|
|
||||||
|
Prosimy o zapoznanie się z instrukcjami dostępnymi w plikach `apps/advanced/tests/README.md` i `apps/basic/tests/README.md`. |
||||||
@ -0,0 +1,11 @@ |
|||||||
|
Testy funkcjonalne |
||||||
|
================== |
||||||
|
|
||||||
|
> Uwaga: Ta sekcja jest w trakcie tworzenia. |
||||||
|
|
||||||
|
- http://codeception.com/docs/05-FunctionalTests |
||||||
|
|
||||||
|
Uruchamianie testów funkcjonalnych dla podstawowego i zaawansowanego szablonu projektu |
||||||
|
-------------------------------------------------------------------------------------- |
||||||
|
|
||||||
|
Prosimy o zapoznanie się z instrukcjami dostępnymi w plikach `apps/advanced/tests/README.md` i `apps/basic/tests/README.md`. |
||||||
@ -0,0 +1,25 @@ |
|||||||
|
Testy jednostkowe |
||||||
|
================= |
||||||
|
|
||||||
|
> Uwaga: Ta sekcja jest w trakcie tworzenia. |
||||||
|
|
||||||
|
Test jednostkowy weryfikuje poprawność działania pojedynczej jednostki kodu. W programowaniu zorientowanym obiektowo |
||||||
|
najbardziej podstawową jednostką kodu jest klasa. Test jednostkowy musi sprawdzić, czy każda z metod interfejsu klasy działa poprawnie tj. czy przy |
||||||
|
zadanych różnych parametrach wejściowych metoda zwraca spodziewane rezultaty. |
||||||
|
Testy jednostkowe są zazwyczaj tworzone przez osoby, które piszą klasy poddawane tym testom. |
||||||
|
|
||||||
|
Testy jednostkowe w Yii są oparte o PHPUnit oraz, opcjonalnie, Codeception, zatem zalecane jest, aby zapoznać się z ich dokumentacją: |
||||||
|
|
||||||
|
- [PHPUnit (dokumentacja zaczyna się w rozdziale 2)](http://phpunit.de/manual/current/en/writing-tests-for-phpunit.html). |
||||||
|
- [Testy jednostkowe Codeception](http://codeception.com/docs/05-UnitTests). |
||||||
|
|
||||||
|
Uruchamianie testów jednostkowych dla podstawowego i zaawansowanego szablonu projektu |
||||||
|
------------------------------------------------------------------------------------- |
||||||
|
|
||||||
|
Prosimy o zapoznanie się z instrukcjami dostępnymi w plikach `apps/advanced/tests/README.md` i `apps/basic/tests/README.md`. |
||||||
|
|
||||||
|
Testy jednostkowe frameworka |
||||||
|
---------------------------- |
||||||
|
|
||||||
|
Jeśli chcesz przeprowadzić testy jednostkowe na frameworku Yii przejdź do sekcji |
||||||
|
"[Od czego zacząć projektowanie w Yii2](https://github.com/yiisoft/yii2/blob/master/docs/internals/getting-started.md)". |
||||||
Loading…
Reference in new issue