cd basic && php requirements.php     # или откройте /requirements.php в браузере

basic/
    composer.json       описание проекта и зависимостей
    config/             конфигурация
        web.php         веб-приложение
        console.php     консольное приложение
        db.php          подключение к БД
        params.php      произвольные параметры (Yii::$app->params)
    commands/           консольные команды
    controllers/        контроллеры
    models/             модели
    views/              представления и шаблоны (layouts/)
    web/                корень для веб-сервера — единственная папка, доступная снаружи
        assets/         опубликованные ресурсы (JS/CSS), создаётся автоматически
        index.php       входной скрипт
    runtime/            логи, кеш, временные файлы — должна быть доступна на запись
    vendor/             пакеты Composer, включая сам фреймворк
    yii                 консольный входной скрипт: ./yii help

defined('YII_DEBUG') or define('YII_DEBUG', true);   // подробные ошибки, отладочная панель
defined('YII_ENV') or define('YII_ENV', 'dev');      // dev | prod | test

docker-compose up -d                          # поднять все сервисы в фоне
docker-compose ps                             # что запущено
docker-compose logs -f                        # хвост логов
docker-compose run --rm php composer install  # разовая команда в новом контейнере
docker-compose exec php bash                  # шелл в работающем контейнере
docker-compose stop                           # остановить
docker-compose down -v                        # остановить и удалить вместе с томами (данные!)

namespace app\controllers;

use yii\web\Controller;

class SiteController extends Controller
{
    public function actionSay($message = 'Привет')
    {
        return $this->render('say', ['message' => $message]);
    }
}

<?php use yii\helpers\Html; ?>
<?= Html::encode($message) ?>

namespace app\models;

use yii\base\Model;

class EntryForm extends Model
{
    public $name;
    public $email;

    public function rules()
    {
        return [
            [['name', 'email'], 'required'],
            ['email', 'email'],
        ];
    }
}

public function actionEntry()
{
    $model = new EntryForm();

    // load() кладёт $_POST['EntryForm'] в атрибуты, validate() проверяет по rules()
    if ($model->load(Yii::$app->request->post()) && $model->validate()) {
        return $this->render('entry-confirm', ['model' => $model]);
    }

    return $this->render('entry', ['model' => $model]);   // первый показ или ошибки
}

<?php
use yii\helpers\Html;
use yii\widgets\ActiveForm;
?>
<?php $form = ActiveForm::begin(); ?>
    <?= $form->field($model, 'name')->label('Ваше имя') ?>
    <?= $form->field($model, 'email') ?>
    <div class="form-group">
        <?= Html::submitButton('Отправить', ['class' => 'btn btn-primary']) ?>
    </div>
<?php ActiveForm::end(); ?>

return [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=localhost;dbname=yii2basic',
    'username' => 'root',
    'password' => '',
    'charset' => 'utf8',
];

namespace app\models;

use yii\db\ActiveRecord;

class Country extends ActiveRecord
{
}

$countries = Country::find()->orderBy('name')->all();   // все строки как объекты
$country = Country::findOne('US');                       // по первичному ключу
$country->name = 'U.S.A.';
$country->save();                                        // UPDATE

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,
        ]);
    }
}

<?php
use yii\helpers\Html;
use yii\widgets\LinkPager;
?>
<h1>Countries</h1>
<ul>
<?php foreach ($countries as $country): ?>
    <li><?= Html::encode("{$country->code} ({$country->name})") ?>: <?= $country->population ?></li>
<?php endforeach; ?>
</ul>
<?= LinkPager::widget(['pagination' => $pagination]) ?>

if (YII_ENV_DEV) {
    $config['bootstrap'][] = 'gii';
    $config['modules']['gii'] = [
        'class' => 'yii\gii\Module',
        'allowedIPs' => ['127.0.0.1', '::1', '192.168.0.*'],   // по умолчанию только localhost
    ];
}

return [
    'id' => 'basic',                    // уникальный идентификатор приложения
    'basePath' => dirname(__DIR__),     // корень с кодом; задаёт псевдоним @app
    // ...
];

return [
    'on beforeRequest' => function ($event) {
        // приложение создано, запрос ещё не обрабатывался — удобно выбрать язык по домену
    },
    'on beforeAction' => function (\yii\base\ActionEvent $event) {
        if ($somethingWrong) {
            $event->isValid = false;   // отменить выполнение действия
        }
    },
    'on afterAction' => function (\yii\base\ActionEvent $event) {
        $event->result = strtoupper($event->result);   // изменить результат действия
    },
];

'components' => [
    'cache' => 'yii\caching\ApcCache',                 // просто имя класса
    'db' => [                                          // массив конфигурации
        'class' => 'yii\db\Connection',
        'dsn' => 'mysql:host=localhost;dbname=demo',
        'username' => 'root',
        'password' => '',
        'charset' => 'utf8',
    ],
    'search' => function () {                           // фабрика-замыкание
        return new app\components\SolrService('127.0.0.1');
    },
],

'bootstrap' => ['log'],

namespace app\controllers;

use Yii;
use app\models\Post;
use yii\web\Controller;
use yii\web\NotFoundHttpException;

class PostController extends Controller
{
    public function actionView($id)
    {
        $model = Post::findOne($id);
        if ($model === null) {
            throw new NotFoundHttpException();          // → страница 404
        }
        return $this->render('view', ['model' => $model]);
    }

    public function actionCreate()
    {
        $model = new Post();
        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            return $this->redirect(['view', 'id' => $model->id]);
        }
        return $this->render('create', ['model' => $model]);
    }
}

'controllerMap' => [
    'account' => 'app\controllers\UserController',
    'article' => [
        'class' => 'app\controllers\PostController',
        'enableCsrfValidation' => false,
    ],
],

class SiteController extends Controller
{
    public $defaultAction = 'home';
}

public function actions()
{
    return [
        'error' => 'yii\web\ErrorAction',                      // страница ошибки
        'captcha' => ['class' => 'yii\captcha\CaptchaAction'],
        'page' => ['class' => 'yii\web\ViewAction', 'viewPrefix' => 'pages'],   // статические страницы
    ];
}

namespace app\components;

use yii\base\Action;

class HelloWorldAction extends Action
{
    public $greeting = 'Hello';

    public function run($name = 'World')
    {
        return "{$this->greeting}, {$name}";
    }
}

public function actionForward()
{
    return $this->redirect('https://example.com');   // redirect() возвращает Response
}

public function actionInfo()
{
    Yii::$app->response->format = \yii\web\Response::FORMAT_JSON;
    return ['message' => 'hello', 'code' => 100];
}

public function actionView($id, $version = null) { /* ... */ }

use yii\filters\VerbFilter;
use yii\web\NotFoundHttpException;

class PostController extends Controller
{
    public function behaviors()
    {
        return [
            'verbs' => [
                'class' => VerbFilter::class,
                'actions' => ['delete' => ['POST']],
            ],
        ];
    }

    public function actionIndex()
    {
        $searchModel = new PostSearch();
        $dataProvider = $searchModel->search(Yii::$app->request->queryParams);
        return $this->render('index', compact('searchModel', 'dataProvider'));
    }

    public function actionUpdate($id)
    {
        $model = $this->findModel($id);
        if ($model->load(Yii::$app->request->post()) && $model->save()) {
            Yii::$app->session->setFlash('success', 'Сохранено');
            return $this->redirect(['view', 'id' => $model->id]);
        }
        return $this->render('update', ['model' => $model]);
    }

    public function actionDelete($id)
    {
        $this->findModel($id)->delete();
        return $this->redirect(['index']);
    }

    protected function findModel($id)
    {
        if (($model = Post::findOne($id)) !== null) {
            return $model;
        }
        throw new NotFoundHttpException('Запись не найдена.');
    }
}

class ContactForm extends \yii\base\Model
{
    public $name;
    public $email;
    public $subject;
    public $body;
}

$model = new ContactForm();
$model->name = 'Иван';
$model['email'] = 'ivan@example.com';        // ArrayAccess
foreach ($model as $attr => $value) { }      // Traversable

public function attributeLabels()
{
    return [
        'name' => Yii::t('app', 'Ваше имя'),
        'email' => Yii::t('app', 'E-mail'),
    ];
}

public function attributeHints()
{
    return ['email' => 'Мы не будем присылать спам'];
}

echo $model->getAttributeLabel('name');   // Ваше имя

$model = new User(['scenario' => User::SCENARIO_LOGIN]);
// или
$model->scenario = User::SCENARIO_LOGIN;

class User extends ActiveRecord
{
    const SCENARIO_LOGIN = 'login';
    const SCENARIO_REGISTER = 'register';

    public function scenarios()
    {
        $scenarios = parent::scenarios();                       // сохраняем сценарии из rules()
        $scenarios[self::SCENARIO_LOGIN] = ['username', 'password'];
        $scenarios[self::SCENARIO_REGISTER] = ['username', 'email', 'password'];
        return $scenarios;
    }

    public function rules()
    {
        return [
            [['username', 'email', 'password'], 'required', 'on' => self::SCENARIO_REGISTER],
            [['username', 'password'], 'required', 'on' => self::SCENARIO_LOGIN],
            ['email', 'email'],                                 // во всех сценариях
        ];
    }
}

public function rules()
{
    return [
        [['name', 'email', 'subject', 'body'], 'required'],
        ['email', 'email'],
        ['subject', 'string', 'max' => 100, 'on' => 'contact'],
        // именованное правило — легко удалить в наследнике
        'password' => [['password'], 'string', 'min' => 8],
    ];
}

if ($model->validate()) {
    // всё хорошо
} else {
    $errors = $model->errors;               // ['email' => ['Email is not a valid email address.']]
    $model->getFirstError('email');
    $model->hasErrors();
}

$model->attributes = Yii::$app->request->post('ContactForm');   // напрямую
$model->load(Yii::$app->request->post());                       // то же, но сам возьмёт $_POST[formName()]

public function rules()
{
    return [
        [['title', 'description'], 'safe'],   // безопасны без проверки
    ];
}

public function scenarios()
{
    return [
        // ! — проверять, но не присваивать массово
        self::SCENARIO_LOGIN => ['username', 'password', '!secret'],
    ];
}
$model->secret = $value;   // только явно

$array = $model->attributes;                          // все атрибуты
$array = $model->toArray();                           // поля из fields()
$array = $model->toArray([], ['prettyName', 'fullAddress']);   // + поля из extraFields()

public function fields()
{
    return [
        'id',
        'email' => 'email_address',                    // переименование
        'name' => function () {                        // вычисляемое поле
            return $this->first_name . ' ' . $this->last_name;
        },
    ];
}

// или: взять родительские поля и убрать чувствительные
public function fields()
{
    $fields = parent::fields();
    unset($fields['auth_key'], $fields['password_hash'], $fields['password_reset_token']);
    return $fields;
}

<?php
use yii\helpers\Html;
use yii\widgets\ActiveForm;

/** @var \yii\web\View $this */
/** @var \app\models\LoginForm $model */

$this->title = 'Вход';
?>
<h1><?= Html::encode($this->title) ?></h1>

<?php $form = ActiveForm::begin(); ?>
    <?= $form->field($model, 'username') ?>
    <?= $form->field($model, 'password')->passwordInput() ?>
    <?= Html::submitButton('Войти') ?>
<?php ActiveForm::end(); ?>

<?= Html::encode($user->name) ?>              <!-- текст: экранируем < > & " ' -->
<?= HtmlPurifier::process($post->text) ?>     <!-- HTML от пользователя: вырезаем опасное -->

// явно — через второй параметр: массив превращается в переменные через extract()
return $this->render('report', ['foo' => 1, 'bar' => 2]);

// из контекста
ID контроллера: <?= $this->context->id ?>

// общие данные между представлением и шаблоном
$this->params['breadcrumbs'][] = 'О нас';     // в представлении
Breadcrumbs::widget(['links' => $this->params['breadcrumbs'] ?? []]);   // в шаблоне

<?php
use yii\helpers\Html;
use app\assets\AppAsset;

AppAsset::register($this);
?>
<?php $this->beginPage() ?>
<!DOCTYPE html>
<html lang="<?= Yii::$app->language ?>">
<head>
    <meta charset="<?= Yii::$app->charset ?>">
    <?= Html::csrfMetaTags() ?>
    <title><?= Html::encode($this->title) ?></title>
    <?php $this->head() ?>
</head>
<body>
<?php $this->beginBody() ?>
    <header>Моя компания</header>
    <?= $content ?>
    <footer>&copy; <?= date('Y') ?></footer>
<?php $this->endBody() ?>
</body>
</html>
<?php $this->endPage() ?>

class PostController extends Controller
{
    public $layout = 'post';       // @app/views/layouts/post.php только для этого контроллера
}

<?php $this->beginContent('@app/views/layouts/main.php'); ?>
<div class="row">
    <div class="col-8"><?= $content ?></div>
    <div class="col-4"><?= $this->blocks['sidebar'] ?? 'Боковая панель по умолчанию' ?></div>
</div>
<?php $this->endContent(); ?>

<?php $this->beginBlock('sidebar'); ?>
    <h3>Похожие статьи</h3>
<?php $this->endBlock(); ?>

$this->title = 'Заголовок';                                             // → <title> в шаблоне
$this->registerMetaTag(['name' => 'description', 'content' => '…'], 'description');   // ключ = без дублей
$this->registerLinkTag(['rel' => 'alternate', 'type' => 'application/rss+xml', 'href' => '/rss']);
$this->registerCss('body { background: #fff }');
$this->registerJs("$('#btn').on('click', …);", View::POS_READY, 'btn-handler');
$this->registerCssFile('@web/css/print.css', ['media' => 'print']);
$this->registerJsFile('@web/js/main.js', ['depends' => [JqueryAsset::class]]);
AppAsset::register($this);                                              // лучший способ: пакеты ресурсов

Yii::$app->view->on(View::EVENT_END_BODY, function () {
    echo '<!-- rendered ' . date('c') . ' -->';
});

public function actions()
{
    // ?r=site/page&view=about → views/site/pages/about.php
    return ['page' => ['class' => 'yii\web\ViewAction']];
}

'view' => [
    'theme' => [
        'basePath' => '@app/themes/basic',
        'baseUrl' => '@web/themes/basic',
        'pathMap' => [
            // views/site/about.php → themes/basic/site/about.php
            '@app/views' => '@app/themes/basic',
            '@app/modules' => '@app/themes/basic/modules',         // темизация модулей
            '@app/widgets' => '@app/themes/basic/widgets',         // темизация виджетов
        ],
    ],
],

'@app/views' => ['@app/themes/christmas', '@app/themes/basic'],

'view' => [
    'renderers' => [
        'twig' => [
            'class' => 'yii\twig\ViewRenderer',
            'cachePath' => '@runtime/Twig/cache',
            'options' => ['auto_reload' => true],
            'globals' => ['html' => '\yii\helpers\Html'],
        ],
        'tpl' => ['class' => 'yii\smarty\ViewRenderer'],
    ],
],

modules/forum/
    Module.php                  класс модуля (обязателен, в корне модуля)
    controllers/
        DefaultController.php   контроллер по умолчанию
        PostController.php
    models/
    views/
        layouts/                шаблоны модуля
        default/index.php       представления контроллера default
        post/
    migrations/
    config.php                  необязательно: конфигурация модуля

namespace app\modules\forum;

class Module extends \yii\base\Module
{
    public $controllerNamespace = 'app\modules\forum\controllers';   // так и по умолчанию

    public function init()
    {
        parent::init();
        $this->params['foo'] = 'bar';
        \Yii::configure($this, require __DIR__ . '/config.php');   // components, params… из файла

        if (\Yii::$app instanceof \yii\console\Application) {
            $this->controllerNamespace = 'app\modules\forum\commands';   // консольные команды модуля
        }
    }
}

namespace app\modules\forum\controllers;

class PostController extends \yii\web\Controller
{
    public function actionIndex()
    {
        return $this->render('index');   // modules/forum/views/post/index.php
    }
}

'modules' => [
    'forum' => [
        'class' => 'app\modules\forum\Module',
        'params' => ['postsPerPage' => 20],
    ],
],

$module = \Yii::$app->getModule('forum');          // по ID
$module = \Yii::$app->controller->module;          // модуль текущего контроллера
$module = \app\modules\forum\Module::getInstance();  // экземпляр, созданный для текущего запроса (или null)

$max = $module->params['postsPerPage'];

'bootstrap' => ['forum'],

class Module extends \yii\base\Module implements \yii\base\BootstrapInterface
{
    public function bootstrap($app)
    {
        $app->urlManager->addRules([
            ['class' => 'yii\web\GroupUrlRule', 'prefix' => 'forum', 'rules' => [
                'posts' => 'post/index',
                'post/<id:\d+>' => 'post/view',
            ]],
        ], false);
    }
}

class Module extends \yii\base\Module
{
    public function init()
    {
        parent::init();
        $this->modules = [
            'admin' => ['class' => 'app\modules\forum\modules\admin\Module'],
        ];
    }
}

use yii\filters\HttpCache;

public function behaviors()
{
    return [
        [
            'class' => HttpCache::class,
            'only' => ['index', 'view'],             // только эти действия
            'except' => [],                         // или все, кроме перечисленных
            'lastModified' => function ($action, $params) {
                return (new \yii\db\Query())->from('user')->max('updated_at');
            },
        ],
    ];
}

namespace app\components;

use Yii;
use yii\base\ActionFilter;

class ActionTimeFilter extends ActionFilter
{
    private $_startTime;

    public function beforeAction($action)
    {
        $this->_startTime = microtime(true);
        return parent::beforeAction($action);      // true — выполнять действие
    }

    public function afterAction($action, $result)
    {
        Yii::debug("{$action->uniqueId}: " . (microtime(true) - $this->_startTime) . ' c');
        return parent::afterAction($action, $result);   // можно подменить $result
    }
}

use yii\filters\AccessControl;

'access' => [
    'class' => AccessControl::class,
    'only' => ['create', 'update', 'delete'],
    'rules' => [
        ['allow' => true, 'actions' => ['create'], 'roles' => ['@']],          // @ — аутентифицирован
        ['allow' => true, 'actions' => ['update', 'delete'], 'roles' => ['admin']],   // роль RBAC
        ['allow' => false, 'ips' => ['10.0.0.*']],
        // всё, что не совпало ни с одним правилом, — запрещено
    ],
    'denyCallback' => function ($rule, $action) {
        throw new \yii\web\ForbiddenHttpException('Нельзя');
    },
],

use yii\filters\VerbFilter;

'verbs' => [
    'class' => VerbFilter::class,
    'actions' => [
        'index'  => ['GET'],
        'create' => ['GET', 'POST'],
        'delete' => ['POST', 'DELETE'],   // иначе 405 Method Not Allowed
    ],
],

'authenticator' => ['class' => \yii\filters\auth\HttpBearerAuth::class],

use yii\filters\ContentNegotiator;
use yii\web\Response;

[
    'class' => ContentNegotiator::class,
    'formats' => [
        'application/json' => Response::FORMAT_JSON,
        'application/xml' => Response::FORMAT_XML,
    ],
    'languages' => ['ru', 'en-US'],   // первый — по умолчанию
],

use yii\filters\PageCache;
use yii\caching\DbDependency;

'pageCache' => [
    'class' => PageCache::class,
    'only' => ['index'],
    'duration' => 60,
    'dependency' => ['class' => DbDependency::class, 'sql' => 'SELECT COUNT(*) FROM post'],
    'variations' => [\Yii::$app->language],
],

use yii\filters\Cors;
use yii\helpers\ArrayHelper;

public function behaviors()
{
    return ArrayHelper::merge([
        [
            'class' => Cors::class,
            'cors' => [
                'Origin' => ['https://app.example.com'],
                'Access-Control-Request-Method' => ['GET', 'POST', 'OPTIONS'],
                'Access-Control-Request-Headers' => ['*'],
                'Access-Control-Allow-Credentials' => true,
                'Access-Control-Max-Age' => 86400,
            ],
            'actions' => [
                'login' => ['Access-Control-Allow-Credentials' => true],   // переопределение для действия
            ],
        ],
    ], parent::behaviors());
}

'as hostControl' => [
    'class' => 'yii\filters\HostControl',
    'allowedHosts' => ['example.com', '*.example.com'],
    'fallbackHostInfo' => 'https://example.com',
],

<?php
use yii\widgets\ActiveForm;
use yii\widgets\LinkPager;
use yii\helpers\Html;
?>

<!-- 1. widget(): конфигурация → готовый HTML -->
<?= LinkPager::widget(['pagination' => $pagination, 'maxButtonCount' => 5]) ?>

<!-- 2. begin()/end(): виджет с содержимым между вызовами -->
<?php $form = ActiveForm::begin(['id' => 'login-form']); ?>
    <?= $form->field($model, 'username') ?>
    <?= $form->field($model, 'password')->passwordInput() ?>
    <?= Html::submitButton('Войти', ['class' => 'btn btn-primary']) ?>
<?php ActiveForm::end(); ?>

\Yii::$container->set('yii\widgets\LinkPager', ['maxButtonCount' => 5]);

// или в конфигурации приложения (с 2.0.11)
'container' => [
    'definitions' => [
        'yii\widgets\LinkPager' => ['maxButtonCount' => 5],
    ],
],

namespace app\components;

use yii\base\Widget;
use yii\helpers\Html;

class HelloWidget extends Widget
{
    public $message;

    public function init()
    {
        parent::init();
        if ($this->message === null) {
            $this->message = 'Hello World';
        }
    }

    public function run()
    {
        return Html::encode($this->message);
    }
}

<?= HelloWidget::widget(['message' => 'Доброе утро']) ?>

class HelloWidget extends Widget
{
    public function init()
    {
        parent::init();
        ob_start();
    }

    public function run()
    {
        $content = ob_get_clean();
        return Html::tag('div', Html::encode($content), ['class' => 'hello']);
    }
}

<?php HelloWidget::begin(); ?>
    содержимое, которое может содержать <tag>'и
<?php HelloWidget::end(); ?>

public function run()
{
    return $this->render('hello', ['message' => $this->message]);
}

public function run()
{
    DatePickerAsset::register($this->view);
    $this->view->registerJs("jQuery('#{$this->id}').datepicker();");
    return Html::activeTextInput($this->model, $this->attribute, ['id' => $this->id]);
}

namespace app\assets;

use yii\web\AssetBundle;

class AppAsset extends AssetBundle
{
    public $basePath = '@webroot';          // файлы уже доступны из веба
    public $baseUrl = '@web';
    public $css = ['css/site.css'];
    public $js = ['js/app.js'];
    public $depends = [
        'yii\web\YiiAsset',                 // jQuery + yii.js
        'yii\bootstrap5\BootstrapAsset',
    ];
}

<?php
use app\assets\AppAsset;
AppAsset::register($this);   // $this — объект View; в виджете: $this->view
?>

"repositories": [
    {"type": "composer", "url": "https://asset-packagist.org"}
],
"require": {
    "bower-asset/jquery": "^3.6",
    "npm-asset/chart.js": "^4.0"
}

'aliases' => [
    '@bower' => '@vendor/bower-asset',
    '@npm' => '@vendor/npm-asset',
],

'assetManager' => [
    'bundles' => [
        'yii\web\JqueryAsset' => [
            'sourcePath' => null,                         // не публиковать
            'js' => ['//code.jquery.com/jquery-3.7.1.min.js'],   // взять с CDN
        ],
        'yii\bootstrap5\BootstrapPluginAsset' => false,   // отключить пакет совсем
    ],
    'assetMap' => [
        'jquery.js' => '//code.jquery.com/jquery-3.7.1.min.js',   // заменить файл во всех пакетах
    ],
    'linkAssets' => true,        // публиковать симлинками, а не копированием
    'appendTimestamp' => true,   // /assets/abc/yii.js?v=1423448645 — сброс кеша браузера
],

yii asset/template assets.php          # шаблон конфигурации
yii asset assets.php config/assets-prod.php   # объединить, сжать, сгенерировать конфиг пакетов

return [
    'jsCompressor' => 'java -jar compiler.jar --js {from} --js_output_file {to}',
    'cssCompressor' => 'java -jar yuicompressor.jar --type css {from} -o {to}',
    'bundles' => ['app\assets\AppAsset', 'yii\web\YiiAsset'],
    'targets' => [
        'all' => [
            'class' => 'yii\web\AssetBundle',
            'basePath' => '@webroot/assets',
            'baseUrl' => '@web/assets',
            'js' => 'js/all-{hash}.js',
            'css' => 'css/all-{hash}.css',
        ],
    ],
    'assetManager' => ['basePath' => '@webroot/assets', 'baseUrl' => '@web/assets'],
];

'assetManager' => [
    'bundles' => require __DIR__ . '/' . (YII_ENV_PROD ? 'assets-prod.php' : 'assets-dev.php'),
],

$this->registerJs(
    "$('#myButton').on('click', function () { alert('Clicked'); });",
    View::POS_READY,          // POS_HEAD | POS_BEGIN | POS_END | POS_READY (по умолчанию) | POS_LOAD
    'my-button-handler'       // ключ: повторная регистрация заменит, а не продублирует
);
$this->registerJsFile('@web/js/main.js', ['depends' => [\yii\web\JqueryAsset::class]]);
$this->registerCss('body { background: #f00; }');
$this->registerCssFile('@web/css/print.css', ['media' => 'print'], 'css-print');

$options = ['baseUrl' => Yii::$app->request->baseUrl, 'language' => Yii::$app->language];
$this->registerJs('var appOptions = ' . \yii\helpers\Json::htmlEncode($options) . ';', View::POS_HEAD, 'app-options');
$this->registerJsVar('appOptions', $options, View::POS_HEAD);   // то же одной строкой (с 2.0.14)

$message = \yii\helpers\Json::htmlEncode(Yii::t('app', 'Button clicked!'));
$this->registerJs(<<<JS
    $('#myButton').on('click', function () { alert($message); });
JS);

composer require yiisoft/yii2-imagine "~2.0.0"

use yii\imagine\Image;

Image::thumbnail('@webroot/img/test-image.jpg', 120, 120)
    ->save(Yii::getAlias('@runtime/thumb.jpg'), ['quality' => 50]);

'aliases' => ['@myext' => '@vendor/mycompany/myext'],   // классы myext\Foo → vendor/mycompany/myext/Foo.php

{
    "name": "myname/yii2-mywidget",
    "type": "yii2-extension",
    "description": "Виджет для…",
    "license": "BSD-3-Clause",
    "require": {
        "yiisoft/yii2": "~2.0.0"
    },
    "autoload": {
        "psr-4": {"myname\\mywidget\\": "src/"}
    },
    "extra": {
        "bootstrap": "myname\\mywidget\\Bootstrap"
    }
}

namespace myname\mywidget;

use yii\base\Application;
use yii\base\BootstrapInterface;

class Bootstrap implements BootstrapInterface
{
    public function bootstrap($app)
    {
        $app->on(Application::EVENT_BEFORE_REQUEST, function () {
            // ...
        });
        \Yii::$container->set('myname\mywidget\StorageInterface', 'myname\mywidget\FileStorage');
    }
}

composer require yiisoft/yii2

require __DIR__ . '/../vendor/yiisoft/yii2/Yii.php';

$yiiConfig = require __DIR__ . '/../config/yii/web.php';
new yii\web\Application($yiiConfig);   // НЕ вызывать run(): обработка запроса остаётся за хост-системой

'urlManager' => [
    'enablePrettyUrl' => true,
    'showScriptName' => false,       // без /index.php в адресах — нужна настройка веб-сервера
    'enableStrictParsing' => false,  // true: URL без подходящего правила → 404
    'rules' => [
        'posts' => 'post/index',
        'post/<id:\d+>' => 'post/view',
    ],
],

'catchAll' => ['site/offline', 'reason' => 'update'],

use yii\helpers\Url;

Url::to(['post/index']);                                  // /posts
Url::to(['post/view', 'id' => 100]);                      // /post/100
Url::to(['post/view', 'id' => 100, '#' => 'comments']);   // /post/100#comments
Url::to(['post/view', 'id' => 100, 'src' => 'ad']);       // /post/100?src=ad — лишние параметры уходят в query
Url::to(['post/index'], true);                            // https://example.com/posts — абсолютный
Url::to(['post/index'], 'https');                         // с явной схемой

Url::to('@web/images/logo.png');   // строка: псевдоним или URL как есть
Url::to();                         // текущий URL
Url::home();  Url::base();  Url::canonical();  Url::current(['page' => 2]);
Url::remember();  Url::previous();               // запомнить и вернуться — так работает goBack()

'rules' => [
    // краткая форма: шаблон => маршрут
    'posts' => 'post/index',
    'posts/<year:\d{4}>/<category>' => 'post/index',
    'post/<id:\d+>' => 'post/view',

    // параметры в маршруте: одно правило вместо шести
    '<controller:(post|comment)>/<id:\d+>/<action:(create|update|delete)>' => '<controller>/<action>',
    '<controller:(post|comment)>/<id:\d+>' => '<controller>/view',
    '<controller:(post|comment)>s' => '<controller>/index',

    // полная форма — когда нужны опции
    [
        'pattern' => 'posts/<page:\d+>/<tag>',
        'route' => 'post/index',
        // необязательные параметры: /posts, /posts/2, /posts/2/news, /posts/news
        'defaults' => ['page' => 1, 'tag' => ''],
        'suffix' => '.json',
    ],

    // ограничение по HTTP-методу учитывается только при разборе;
    // при генерации ссылки метод не смотрят, поэтому правило может сработать и там
    'PUT,POST post/<id:\d+>' => 'post/update',
    'DELETE post/<id:\d+>' => 'post/delete',

    // имена серверов: поддомен → параметр
    'http://<language:\w+>.example.com/posts' => 'post/index',
    'https://admin.example.com/login' => 'admin/user/login',
],

'urlManager' => [
    // все URL — с .html; без суффикса → 404 (хорошо для SEO); '/' — завершающий слеш
    'suffix' => '.html',
    'normalizer' => [
        'class' => 'yii\web\UrlNormalizer',   // /path/ и /path//x → 301 на канонический вид
        'action' => \yii\web\UrlNormalizer::ACTION_REDIRECT_TEMPORARY,
    ],
],

public function bootstrap($app)
{
    $app->urlManager->addRules([
        ['class' => 'yii\web\GroupUrlRule', 'prefix' => 'forum', 'rules' => [
            'posts' => 'post/index',
            'post/<id:\d+>' => 'post/view',
        ]],
    ], false);
}

namespace app\components;

use yii\base\BaseObject;
use yii\web\UrlRuleInterface;

class CarUrlRule extends BaseObject implements UrlRuleInterface
{
    public function createUrl($manager, $route, $params)
    {
        if ($route === 'car/index' && isset($params['manufacturer'])) {
            return $params['manufacturer'] . (isset($params['model']) ? '/' . $params['model'] : '');
        }
        return false;   // правило не применимо
    }

    public function parseRequest($manager, $request)
    {
        if (preg_match('%^(\w+)(/(\w+))?$%', $request->pathInfo, $m)) {
            // проверить $m[1], $m[3] по базе и вернуть ['car/index', $params]
        }
        return false;
    }
}

'rules' => [['class' => 'app\components\CarUrlRule']],

$request = Yii::$app->request;

$request->get();                 // весь $_GET
$request->get('id');             // $_GET['id'] или null
$request->get('id', 1);          // со значением по умолчанию
$request->post('name', '');      // то же для $_POST

$request->bodyParams;            // тело PUT/PATCH/JSON-запроса
$request->getBodyParam('id');
$request->queryParams;           // = get()

'request' => [
    'parsers' => ['application/json' => 'yii\web\JsonParser'],
],

$request->method;                                   // 'GET', 'POST'…
$request->isGet; $request->isPost; $request->isPut; $request->isAjax; $request->isPjax;

// для https://example.com/admin/index.php/product?id=100
$request->url;             // /admin/index.php/product?id=100
$request->absoluteUrl;     // https://example.com/admin/index.php/product?id=100
$request->hostInfo;        // https://example.com
$request->pathInfo;        // product
$request->queryString;     // id=100
$request->baseUrl;         // /admin
$request->scriptUrl;       // /admin/index.php
$request->serverName;      // example.com
$request->isSecureConnection;

$headers = $request->headers;                       // HeaderCollection
$headers->get('Accept'); $headers->has('User-Agent');
$request->userAgent; $request->contentType;
$request->acceptableContentTypes;                   // по убыванию q
$request->acceptableLanguages;
$request->getPreferredLanguage(['ru', 'en']);       // лучший из поддерживаемых

$request->userIP; $request->userHost;
$request->cookies;                                  // см. раздел о куках
$request->csrfToken;                                // для ручных AJAX-запросов

'request' => [
    'trustedHosts' => ['10.0.2.0/24'],   // только их X-Forwarded-For / X-Forwarded-Proto учитываются
    // если прокси шлёт нестандартные заголовки:
    // 'trustedHosts' => ['10.0.2.0/24' => ['X-ProxyUser-Ip', 'Front-End-Https']],
    // 'ipHeaders' => ['X-ProxyUser-Ip'],
    // 'secureProtocolHeaders' => ['Front-End-Https' => ['on']],
],

Yii::$app->response->statusCode = 201;    // по умолчанию 200
throw new \yii\web\NotFoundHttpException();   // обработчик ошибок сам выставит 404
throw new \yii\web\HttpException(402, 'Payment required');

$headers = Yii::$app->response->headers;
$headers->add('Pragma', 'no-cache');     // добавить (существующие сохраняются)
$headers->set('Pragma', 'no-cache');     // заменить
$headers->remove('Pragma');

// готовая строка
Yii::$app->response->content = 'hello';

// данные + формат: отформатирует JsonResponseFormatter
$response = Yii::$app->response;
// FORMAT_HTML | FORMAT_XML | FORMAT_JSON | FORMAT_JSONP | FORMAT_RAW
$response->format = \yii\web\Response::FORMAT_JSON;
$response->data = ['message' => 'hello'];

// обычно проще вернуть данные из действия
public function actionInfo()
{
    return $this->asJson(['message' => 'hello', 'code' => 100]);
}

'response' => [
    'formatters' => [
        \yii\web\Response::FORMAT_JSON => [
            'class' => 'yii\web\JsonResponseFormatter',
            'prettyPrint' => YII_DEBUG,
            'encodeOptions' => JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE,
        ],
    ],
],

public function actionOld()
{
    return $this->redirect(['post/view', 'id' => 1]);          // 302
    return $this->redirect('https://example.com/new', 301);    // навсегда
    return $this->goHome();   // $this->goBack();   $this->refresh();
}

// вне действия — сразу отправить
Yii::$app->response->redirect($url)->send();

return Yii::$app->response->sendFile('/path/to/report.pdf');                    // существующий файл
return Yii::$app->response->sendContentAsFile($csv, 'export.csv');              // строка как файл
return Yii::$app->response->sendStreamAsFile($stream, 'big.zip');               // поток — для больших файлов
// отдачу делает веб-сервер (X-Sendfile / X-Accel-Redirect)
return Yii::$app->response->xSendFile('/path/to/file');

$session = Yii::$app->session;

$session->isActive;   $session->open();   $session->close();   $session->destroy();

// три эквивалентных способа — компонент сам откроет сессию
$session->set('language', 'ru');    $session['language'] = 'ru';    $_SESSION['language'] = 'ru';
$session->get('language');          $session['language'];
$session->remove('language');       unset($session['language']);
$session->has('language');          isset($session['language']);
foreach ($session as $name => $value) { }

'session' => [
    'class' => 'yii\web\DbSession',
    // 'db' => 'db', 'sessionTable' => 'session',
],

CREATE TABLE session (
    id CHAR(40) NOT NULL PRIMARY KEY,   -- 64, если session.hash_function = sha256
    expire INTEGER,
    data BLOB                           -- LONGBLOB в MySQL, BYTEA в PostgreSQL
)

// запрос 1
Yii::$app->session->setFlash('success', 'Пост удалён.');
Yii::$app->session->addFlash('alerts', 'Ещё одно сообщение');   // накапливает в массив

// запрос 2
Yii::$app->session->getFlash('success');      // 'Пост удалён.'
Yii::$app->session->getFlash('alerts');       // массив
Yii::$app->session->hasFlash('success');
Yii::$app->session->getAllFlashes();

// запрос 3: сообщений уже нет

// чтение
$cookies = Yii::$app->request->cookies;
$language = $cookies->getValue('language', 'en');
if (($cookie = $cookies->get('language')) !== null) { $language = $cookie->value; }
$cookies->has('language');   isset($cookies['language']);

// отправка
$cookies = Yii::$app->response->cookies;
$cookies->add(new \yii\web\Cookie([
    'name' => 'language',
    'value' => 'ru',
    'expire' => time() + 86400 * 365,
    // 'domain', 'path', 'secure', 'httpOnly' (по умолчанию true), 'sameSite'
]));
$cookies->remove('language');   unset($cookies['language']);

'request' => [
    'cookieValidationKey' => 'длинная-случайная-строка',   // не коммитьте в репозиторий
],

try {
    10 / 0;
} catch (\yii\base\ErrorException $e) {
    Yii::warning('Деление на ноль');
}

throw new \yii\web\NotFoundHttpException('Такой страницы нет');   // → 404 с правильным статусом

'components' => [
    'errorHandler' => [
        'errorAction' => 'site/error',
        // 'maxSourceLines' => 20,  'errorView', 'exceptionView' — свои шаблоны
    ],
],

public function actions()
{
    return ['error' => ['class' => 'yii\web\ErrorAction']];   // рендерит views/site/error.php
}

'response' => [
    'on beforeSend' => function ($event) {
        $response = $event->sender;
        if ($response->data !== null) {
            $response->data = ['success' => $response->isSuccessful, 'data' => $response->data];
            $response->statusCode = 200;
        }
    },
],

Yii::debug('начало расчёта', __METHOD__);      // уровень trace — только при разработке
Yii::info('пользователь вошёл', 'app\auth');
Yii::warning('неожиданное состояние');
Yii::error('не удалось отправить письмо', __METHOD__);

return [
    'bootstrap' => ['log'],
    'timeZone' => 'Europe/Moscow',
    'components' => [
        'log' => [
            'traceLevel' => YII_DEBUG ? 3 : 0,   // сколько строк стека добавлять к сообщению
            'flushInterval' => 1000,             // передавать целям каждые N сообщений (и в конце запроса)
            'targets' => [
                'file' => [
                    'class' => 'yii\log\FileTarget',
                    'levels' => ['error', 'warning'],
                    'categories' => ['yii\db\*', 'yii\web\HttpException:*'],
                    'except' => ['yii\web\HttpException:404'],
                    'logVars' => ['_SERVER'],        // какие глобальные массивы прикладывать; [] — никакие
                    'maskVars' => ['_SERVER.HTTP_X_PASSWORD', '_SERVER.*_SECRET'],
                    'exportInterval' => 1000,        // писать в хранилище каждые N отфильтрованных сообщений
                    'prefix' => function ($message) {
                        return '[' . (Yii::$app->user->id ?? '-') . ']';
                    },
                ],
                'email' => [
                    'class' => 'yii\log\EmailTarget',
                    'levels' => ['error'],
                    'categories' => ['yii\db\*'],
                    'message' => [
                        'from' => ['log@example.com'], 'to' => ['admin@example.com'], 'subject' => 'Ошибки БД',
                    ],
                ],
            ],
        ],
    ],
];

Yii::beginProfile('import');
    // код
    Yii::beginProfile('parse');   // вложенные пары должны быть сбалансированы
    Yii::endProfile('parse');
Yii::endProfile('import');

namespace app\components;

use yii\base\BaseObject;

class Foo extends BaseObject
{
    private $_label;

    public function getLabel()
    {
        return $this->_label;
    }

    public function setLabel($value)
    {
        $this->_label = trim($value);   // логика в одном месте, а не во всех точках присваивания
    }
}

$foo->label = '  Hello ';   // вызовет setLabel()
echo $foo->label;           // вызовет getLabel() → 'Hello'

namespace app\components;

use yii\base\BaseObject;

class MyClass extends BaseObject
{
    public $prop1;
    public $prop2;

    public function __construct($param1, $param2, $config = [])
    {
        // до применения конфигурации: значения по умолчанию
        parent::__construct($config);    // родительский конструктор — последним
    }

    public function init()
    {
        parent::init();                  // родительский init() — первым
        // после применения конфигурации: проверка, нормализация свойств
    }
}

$obj = new MyClass(1, 2, ['prop1' => 3, 'prop2' => 4]);
$obj = \Yii::createObject(['class' => MyClass::class, 'prop1' => 3], [1, 2]);   // через DI-контейнер

$foo->on(Foo::EVENT_HELLO, 'function_name');                 // глобальная функция
$foo->on(Foo::EVENT_HELLO, [$object, 'methodName']);         // метод объекта
$foo->on(Foo::EVENT_HELLO, ['app\components\Bar', 'method']); // статический метод
$foo->on(Foo::EVENT_HELLO, function ($event) {               // замыкание
    echo $event->name;       // имя события
    echo $event->sender;     // кто вызвал trigger()
    echo $event->data;       // данные, переданные при подписке
});

// данные для обработчика — третий аргумент
$foo->on(Foo::EVENT_HELLO, function ($event) { echo $event->data; }, 'abc');

// в начало очереди, а не в конец
$foo->on(Foo::EVENT_HELLO, $handler, null, false);

'components' => [
    'db' => [
        'class' => 'yii\db\Connection',
        'on afterOpen' => function ($event) {
            $event->sender->createCommand("SET time_zone = '+00:00'")->execute();
        },
    ],
],

$foo->on(Foo::EVENT_HELLO, function ($event) {
    $event->handled = true;   // следующие обработчики не вызовутся
});

namespace app\components;

use yii\base\Component;
use yii\base\Event;

class MessageEvent extends Event
{
    public $message;           // свои данные — в наследнике Event
}

class Mailer extends Component
{
    const EVENT_MESSAGE_SENT = 'messageSent';   // имя — константой: без опечаток, видно в IDE

    public function send($message)
    {
        // ...отправка...
        $this->trigger(self::EVENT_MESSAGE_SENT, new MessageEvent(['message' => $message]));
    }
}

$foo->off(Foo::EVENT_HELLO, 'function_name');
$foo->off(Foo::EVENT_HELLO, $anonymousFunction);   // замыкание нужно сохранить в переменную при подписке
$foo->off(Foo::EVENT_HELLO);                        // все обработчики события

use yii\base\Event;
use yii\db\ActiveRecord;

Event::on(ActiveRecord::class, ActiveRecord::EVENT_AFTER_INSERT, function ($event) {
    Yii::debug(get_class($event->sender) . ' добавлен');
});

Event::trigger(Foo::class, Foo::EVENT_HELLO);    // событие без объекта: $event->sender === null
Event::off(Foo::class, Foo::EVENT_HELLO);

interface DanceEventInterface { const EVENT_DANCE = 'dance'; }

Event::on(DanceEventInterface::class, DanceEventInterface::EVENT_DANCE, function ($event) {
    Yii::debug(get_class($event->sender) . ' танцует');
});

Yii::$app->on('app.mail.sent', function ($event) { /* ... */ });
Yii::$app->trigger('app.mail.sent', new Event(['sender' => $mailer]));

namespace app\components;

use yii\base\Behavior;
use yii\db\ActiveRecord;

class MyBehavior extends Behavior
{
    public $prop1;
    private $_prop2;

    public function getProp2() { return $this->_prop2; }
    public function setProp2($value) { $this->_prop2 = $value; }

    public function foo()
    {
        return $this->owner->id;          // $this->owner — компонент, к которому прикреплены
    }

    public function events()             // реакция на события владельца
    {
        return [
            ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
        ];
    }

    public function beforeValidate($event)
    {
        // ...
    }
}

class User extends ActiveRecord
{
    public function behaviors()
    {
        return [
            MyBehavior::class,                              // анонимное
            'myBehavior2' => MyBehavior::class,             // именованное
            [                                               // с конфигурацией
                'class' => MyBehavior::class,
                'prop1' => 'value1',
            ],
            'myBehavior4' => ['class' => MyBehavior::class, 'prop1' => 'value1'],
        ];
    }
}

// динамически
$component->attachBehavior('myBehavior', new MyBehavior());
$component->attachBehaviors(['a' => MyBehavior::class, 'b' => ['class' => MyBehavior::class]]);
$component->detachBehavior('myBehavior');
$component->detachBehaviors();

// в конфигурации — ключ 'as имя'
'as myBehavior' => ['class' => MyBehavior::class, 'prop1' => 'value1'],

$component->prop1 = 'x';          // свойство поведения
$component->foo();                // метод поведения
$component->getBehavior('myBehavior2');
$component->getBehaviors();

use yii\behaviors\TimestampBehavior;
use yii\db\Expression;

public function behaviors()
{
    return [
        [
            'class' => TimestampBehavior::class,
            'attributes' => [                       // так и по умолчанию — можно не писать
                ActiveRecord::EVENT_BEFORE_INSERT => ['created_at', 'updated_at'],
                ActiveRecord::EVENT_BEFORE_UPDATE => ['updated_at'],
            ],
            // 'value' => new Expression('NOW()'),  // если столбцы DATETIME, а не INT с unix timestamp
        ],
    ];
}

$user->touch('login_at');   // проставить текущее время в атрибут и сохранить

$config = [
    'class' => 'app\components\SearchEngine',   // полное имя класса
    'apiKey' => 'xxxxxxxx',                      // публичное поле или свойство через сеттер
    'on search' => function ($event) {           // обработчик события
        Yii::info('Искали: ' . $event->keyword);
    },
    'as indexer' => [                            // поведение
        'class' => 'app\components\IndexerBehavior',
    ],
];

$engine = Yii::createObject($config);            // создать (через DI-контейнер)
Yii::configure($engine, ['apiKey' => 'yyy']);    // настроить существующий объект (без ключа class)

echo Menu::widget([
    'activateItems' => false,
    'items' => [
        ['label' => 'Home', 'url' => ['site/index']],
        ['label' => 'Login', 'url' => ['site/login'], 'visible' => Yii::$app->user->isGuest],
    ],
]);

$params = require __DIR__ . '/params.php';
$db = require __DIR__ . '/db.php';

$config = [
    'id' => 'basic',
    'basePath' => dirname(__DIR__),
    'bootstrap' => ['log'],
    'aliases' => ['@bower' => '@vendor/bower-asset', '@npm' => '@vendor/npm-asset'],
    'components' => [
        'request' => ['cookieValidationKey' => '...'],
        'cache' => ['class' => 'yii\caching\FileCache'],
        'user' => ['identityClass' => 'app\models\User', 'enableAutoLogin' => true],
        'errorHandler' => ['errorAction' => 'site/error'],
        'log' => [
            'traceLevel' => YII_DEBUG ? 3 : 0,
            'targets' => [['class' => 'yii\log\FileTarget', 'levels' => ['error', 'warning']]],
        ],
        'db' => $db,
    ],
    'params' => $params,
];

if (YII_ENV_DEV) {
    $config['bootstrap'][] = 'debug';
    $config['modules']['debug'] = 'yii\debug\Module';
    $config['bootstrap'][] = 'gii';
    $config['modules']['gii'] = 'yii\gii\Module';
}

return $config;

'container' => [
    'definitions' => [
        'yii\widgets\LinkPager' => ['maxButtonCount' => 5],
        'yii\mail\MailerInterface' => 'yii\symfonymailer\Mailer',
    ],
    'singletons' => [],
],

Yii::setAlias('@foo', '/path/to/foo');              // корневой псевдоним
Yii::setAlias('@bar', 'https://www.example.com');
Yii::setAlias('@foobar', '@foo/bar');                // на основе другого

Yii::getAlias('@foo/bar/file.php');                  // /path/to/foo/bar/file.php — производный
Yii::getAlias('@bar');                               // https://www.example.com

Yii::$classMap['foo\bar\MyClass'] = '@app/lib/MyClass.php';   // карта классов: без поиска, самый быстрый путь