# базовый шаблон — один сайт, самый простой старт
composer create-project --prefer-dist yiisoft/yii2-app-basic basic

# продвинутый шаблон — frontend + backend + common, для команд
composer create-project --prefer-dist yiisoft/yii2-app-advanced advanced

cd basic
php requirements.php          # проверка требований к PHP
php yii serve --port=8080     # http://localhost:8080
php yii                       # список всех консольных команд

<?php
// web/index.php
defined('YII_DEBUG') or define('YII_DEBUG', true);
defined('YII_ENV') or define('YII_ENV', 'dev');

require __DIR__ . '/../vendor/autoload.php';           // автозагрузчик Composer
require __DIR__ . '/../vendor/yiisoft/yii2/Yii.php';   // класс Yii

$config = require __DIR__ . '/../config/web.php';
(new yii\web\Application($config))->run();

$application = new yii\console\Application($config);
exit($application->run());   // код возврата = exit code

server {
    listen 80;
    server_name mysite.test;
    root /path/to/basic/web;
    index index.php;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }
    location ~ \.php$ {
        include fastcgi.conf;
        fastcgi_pass 127.0.0.1:9000;
    }
    location ~ /\.(ht|svn|git) { deny all; }
}

DocumentRoot "path/to/basic/web"
<Directory "path/to/basic/web">
    RewriteEngine on
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteRule . index.php
</Directory>

// controllers/SiteController.php
namespace app\controllers;

use yii\web\Controller;

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

// views/site/say.php
<?php use yii\helpers\Html; ?>
<?= Html::encode($message) ?>

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

// models/Country.php — таблица определяется по имени класса
namespace app\models;

class Country extends \yii\db\ActiveRecord {}

$countries = Country::find()->orderBy('name')->all();
$country = Country::findOne('US');
$country->name = 'U.S.A.';
$country->save();

// config/web.php
if (YII_ENV_DEV) {
    $config['bootstrap'][] = 'gii';
    $config['modules']['gii'] = [
        'class' => 'yii\gii\Module',
        'allowedIPs' => ['127.0.0.1', '::1', '192.168.0.*'],
    ];
}

if (YII_ENV_DEV) {
    $config['bootstrap'][] = 'debug';
    $config['modules']['debug'] = [
        'class' => 'yii\debug\Module',
        'allowedIPs' => ['127.0.0.1', '::1'],
    ];
}

// config/web.php
return [
    'id' => 'basic',                       // обязателен: уникальный идентификатор
    'basePath' => dirname(__DIR__),        // обязателен: корень приложения (@app)
    'language' => 'ru-RU',
    'sourceLanguage' => 'en-US',
    'timeZone' => 'Europe/Kyiv',
    'defaultRoute' => 'site/index',
    'bootstrap' => ['log'],                // что грузить при каждом запросе
    'aliases' => ['@images' => '@webroot/images'],
    'components' => [
        'db' => require __DIR__ . '/db.php',
        'cache' => ['class' => 'yii\caching\FileCache'],
        'user' => [
            'identityClass' => 'app\models\User',
            'enableAutoLogin' => true,
        ],
        'urlManager' => [
            'enablePrettyUrl' => true,
            'showScriptName' => false,
            'rules' => ['post/<id:\d+>' => 'post/view'],
        ],
        'request' => ['cookieValidationKey' => 'секрет-из-переменной-окружения'],
    ],
    'modules' => ['admin' => ['class' => 'app\modules\admin\Module']],
    'params' => require __DIR__ . '/params.php',
];

// В конфиге — синтаксис "on <имя события>"
'on beforeRequest' => function ($event) { /* ... */ },

// Или в коде
Yii::$app->on(yii\base\Application::EVENT_BEFORE_ACTION, function ($event) {
    if (!$ok) { $event->isValid = false; }   // отменить выполнение действия
});

'components' => [
    'cache' => 'yii\caching\ApcCache',               // просто класс
    'db' => ['class' => 'yii\db\Connection', 'dsn' => '...'],   // конфиг-массив
    'search' => function () { return new app\components\SolrService; },  // фабрика
],

namespace app\controllers;

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

class PostController extends Controller
{
    public $layout = 'post';              // свой layout для всего контроллера
    public $defaultAction = 'index';      // действие по умолчанию

    public function actions()             // «отдельные» действия классами
    {
        return [
            'error' => ['class' => 'yii\web\ErrorAction'],
            'captcha' => ['class' => 'yii\captcha\CaptchaAction'],
        ];
    }

    public function actionView($id, $version = null)   // параметры берутся из $_GET
    {
        $model = Post::findOne($id);
        if ($model === null) {
            throw new NotFoundHttpException('Пост не найден.');
        }
        return $this->render('view', ['model' => $model]);
    }

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

namespace app\components;

use yii\base\Action;

class HelloWorldAction extends Action
{
    public function run()        // роль та же, что у actionXxx()
    {
        return 'Hello World';
    }
}

namespace app\models;

use yii\base\Model;

class ContactForm extends Model
{
    public $name;
    public $email;
    public $body;
    public $verifyCode;

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

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

$model = new ContactForm();
$model->load(Yii::$app->request->post());    // массовое присвоение по имени класса
if ($model->validate()) { /* ... */ }
$errors = $model->errors;                    // ['email' => ['Email некорректен.']]
$model->hasErrors('email');
$model->getFirstError('email');

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

    public function scenarios()
    {
        return [
            self::SCENARIO_LOGIN => ['username', 'password'],
            self::SCENARIO_REGISTER => ['username', 'email', 'password', '!secret'],
        ];
    }

    public function rules()
    {
        return [
            [['username', 'email', 'password'], 'required', 'on' => self::SCENARIO_REGISTER],
            [['username', 'password'], 'required', 'on' => self::SCENARIO_LOGIN],
        ];
    }
}

$model = new User(['scenario' => User::SCENARIO_LOGIN]);

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

public function fields()
{
    $fields = parent::fields();
    unset($fields['auth_key'], $fields['password_hash']);  // убрать секреты
    $fields['name'] = fn () => $this->first_name . ' ' . $this->last_name;
    return $fields;
}

<?php
// views/post/view.php
use yii\helpers\Html;

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

$this->title = $model->title;
$this->params['breadcrumbs'][] = ['label' => 'Посты', 'url' => ['index']];
$this->params['breadcrumbs'][] = $this->title;
?>
<h1><?= Html::encode($model->title) ?></h1>
<div><?= \yii\helpers\HtmlPurifier::process($model->text) ?></div>
<?= $this->render('_comments', ['comments' => $model->comments]) ?>

<?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() ?>
    <?= $content ?>
<?php $this->endBody() ?>
</body>
</html>
<?php $this->endPage() ?>

$this->title = 'Заголовок';
$this->registerMetaTag(['name' => 'description', 'content' => '...'], 'description');
$this->registerLinkTag(['rel' => 'canonical', 'href' => Url::canonical()]);
$this->registerCss('.red { color: red }');
$this->registerJs('alert(1);', \yii\web\View::POS_READY);
$this->registerJsFile('@web/js/app.js', ['depends' => [\yii\web\YiiAsset::class]]);

// блоки: записать в виде, вывести в layout
$this->beginBlock('sidebar'); echo '...'; $this->endBlock();
echo $this->blocks['sidebar'] ?? '';

// данные между видом и layout
$this->params['breadcrumbs'][] = 'О нас';

modules/admin/
    Module.php
    controllers/DefaultController.php
    models/
    views/layouts/  views/default/index.php

namespace app\modules\admin;

class Module extends \yii\base\Module
{
    public $layout = 'admin';
    public $defaultRoute = 'default';

    public function init()
    {
        parent::init();
        \Yii::configure($this, require __DIR__ . '/config.php');

        if (\Yii::$app instanceof \yii\console\Application) {
            $this->controllerNamespace = 'app\modules\admin\commands';
        }
    }
}

// подключение
'modules' => ['admin' => ['class' => 'app\modules\admin\Module']],

// вариант 1: всё сразу
<?= \yii\widgets\Menu::widget([
    'items' => [
        ['label' => 'Главная', 'url' => ['site/index']],
        ['label' => 'Вход', 'url' => ['site/login'], 'visible' => Yii::$app->user->isGuest],
    ],
]) ?>

// вариант 2: виджет с содержимым между begin() и end()
<?php $form = \yii\widgets\ActiveForm::begin(['id' => 'login-form']); ?>
    <?= $form->field($model, 'username') ?>
<?php \yii\widgets\ActiveForm::end(); ?>

namespace app\components;

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

class HelloWidget extends Widget
{
    public $message;

    public function init()
    {
        parent::init();
        $this->message ??= 'Hello World';
        // ob_start();  // если нужен захват содержимого между begin() и end()
    }

    public function run()
    {
        return $this->render('hello', ['message' => $this->message]);
        // или: return Html::encode(ob_get_clean());
    }
}

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

use yii\filters\AccessControl;
use yii\filters\VerbFilter;

public function behaviors()
{
    return [
        'access' => [
            'class' => AccessControl::class,
            'only' => ['create', 'update', 'delete'],   // или except => [...]
            'rules' => [
                ['allow' => true, 'actions' => ['create'], 'roles' => ['@']],
                ['allow' => true, 'roles' => ['admin']],
                ['allow' => true, 'ips' => ['192.168.*'], 'roles' => ['?']],
            ],
        ],
        'verbs' => [
            'class' => VerbFilter::class,
            'actions' => [
                'index' => ['get'],
                'create' => ['get', 'post'],
                'update' => ['get', 'put', 'post'],
                'delete' => ['post', 'delete'],
            ],
        ],
    ];
}

namespace app\components;

use yii\base\ActionFilter;

class ActionTimeFilter extends ActionFilter
{
    private $_start;

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

    public function afterAction($action, $result)
    {
        \Yii::debug('Действие ' . $action->uniqueId . ': ' . (microtime(true) - $this->_start));
        return parent::afterAction($action, $result);
    }
}

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-Allow-Credentials' => true,
            'Access-Control-Max-Age' => 86400,
        ]],
    ], parent::behaviors());
}

namespace app\assets;

use yii\web\AssetBundle;
use yii\web\View;

class AppAsset extends AssetBundle
{
    public $basePath = '@webroot';      // файлы уже в вебруте — публикация не нужна
    public $baseUrl = '@web';
    // public $sourcePath = '@bower/some-lib';   // файлы вне вебрута → будут опубликованы
    public $css = ['css/site.css'];
    public $js = ['js/app.js'];
    public $jsOptions = ['position' => View::POS_END];
    public $cssOptions = ['media' => 'screen'];
    public $depends = [
        'yii\web\YiiAsset',
        'yii\bootstrap5\BootstrapAsset',
    ];
}

\app\assets\AppAsset::register($this);

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

yii asset/template assets.php   # создать конфиг
yii asset assets.php config/assets-prod.php

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

composer require yiisoft/yii2-imagine

{
    "name": "vendor/yii2-mywidget",
    "type": "yii2-extension",
    "require": { "yiisoft/yii2": "~2.0.0" },
    "autoload": { "psr-4": { "vendor\\mywidget\\": "" } },
    "extra": { "bootstrap": "vendor\\mywidget\\Bootstrap" }
}

'urlManager' => [
    'enablePrettyUrl' => true,      // ЧПУ вместо ?r=post/view
    'showScriptName' => false,      // убрать index.php из URL
    'enableStrictParsing' => false, // true → URL обязан совпасть с правилом, иначе 404
    'suffix' => '.html',            // необязательный суффикс
    'normalizer' => [               // слеши в конце: 301-редирект на канонический вид
        'class' => 'yii\web\UrlNormalizer',
    ],
    'rules' => [
        'posts' => 'post/index',
        'post/<id:\d+>' => 'post/view',
        'posts/<year:\d{4}>/<category>' => 'post/index',
        '<controller:(post|comment)>/<id:\d+>/<action:(create|update|delete)>' => '<controller>/<action>',
        'PUT,POST post/<id:\d+>' => 'post/create',          // привязка к HTTP-методам
        'http://<language:\w+>.example.com/posts' => 'post/index',   // имя сервера
        ['pattern' => 'posts', 'route' => 'post/index', 'suffix' => '.json'],
        ['pattern' => 'posts/<page:\d+>/<tag>', 'route' => 'post/index',
         'defaults' => ['page' => 1, 'tag' => '']],         // необязательные параметры
    ],
],

use yii\helpers\Url;

Url::to(['post/index']);                       // /index.php?r=post/index
Url::to(['post/view', 'id' => 100]);           // с параметром
Url::to(['post/view', 'id' => 1, '#' => 'c']); // с якорем
Url::to(['post/index'], true);                 // абсолютный URL
Url::to(['post/index'], 'https');              // абсолютный с указанной схемой
Url::toRoute('post/index');                    // то же, что to([...]) для маршрута
Url::current(['page' => 2]);                   // текущий маршрут + изменённые параметры
Url::home();  Url::base();  Url::canonical();
Url::remember();  Url::previous();             // запомнить/вернуть URL

public function bootstrap($app)
{
    $app->getUrlManager()->addRules([/* правила модуля */], false);
}

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

$request->get('id', 1);            // $_GET с значением по умолчанию
$request->post('name');            // $_POST
$request->getBodyParam('id');      // тело PUT/PATCH/DELETE (см. parsers)
$request->bodyParams;              // все параметры тела
$request->getQueryParams();

$request->method;                  // GET, POST, ...
$request->isGet; $request->isPost; $request->isPut; $request->isAjax; $request->isPjax;
$request->isSecureConnection;

$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; $request->scriptUrl; $request->serverName; $request->serverPort;

$request->headers->get('Accept');
$request->userAgent; $request->contentType;
$request->acceptableContentTypes; $request->acceptableLanguages;
$request->getPreferredLanguage(['ru-RU', 'en-US']);
$request->userIP; $request->userHost;
$request->getCsrfToken();

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

'request' => [
    'trustedHosts' => ['10.0.2.0/24'],
    // при нестандартных заголовках: ipHeaders, secureHeaders, secureProtocolHeaders
],

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

$response->statusCode = 201;
$response->headers->set('Pragma', 'no-cache');   // add() не перезаписывает
$response->content = 'hello';
$response->format = yii\web\Response::FORMAT_JSON;  // HTML | JSON | JSONP | XML | RAW
$response->data = ['message' => 'hello'];

// Файлы
Yii::$app->response->sendFile('/path/file.pdf');
Yii::$app->response->sendContentAsFile($csv, 'report.csv');
Yii::$app->response->sendStreamAsFile($handle, 'big.zip');
Yii::$app->response->xSendFile('/path/file.zip');   // отдаёт веб-сервер

// Редиректы
return $this->redirect(['post/view', 'id' => 1]);
return $this->redirect('https://example.com/new', 301);
Yii::$app->response->redirect($url)->send();        // вне действия — сразу send()
return $this->goHome();  return $this->goBack();  return $this->refresh();

$session = Yii::$app->session;
$session->open(); $session->close(); $session->destroy();
$session->isActive;

$session->set('language', 'ru');    // или $session['language'] = 'ru';
$session->get('language', 'en');
$session->remove('language');
$session->has('language');

// Flash-сообщения — живут до следующего запроса
$session->setFlash('success', 'Сохранено');
$session->addFlash('alerts', 'Ещё сообщение');   // накапливает массив
echo $session->getFlash('success');
$session->hasFlash('success');

// Чтение кук запроса
$cookies = Yii::$app->request->cookies;
$language = $cookies->getValue('language', 'ru');

// Отправка кук
Yii::$app->response->cookies->add(new \yii\web\Cookie([
    'name' => 'language',
    'value' => 'ru',
    'expire' => time() + 86400 * 30,
    'httpOnly' => true,
    'secure' => true,
    'sameSite' => \yii\web\Cookie::SAME_SITE_LAX,
]));
Yii::$app->response->cookies->remove('language');

'components' => [
    'errorHandler' => [
        'errorAction' => 'site/error',   // действие для показа ошибки
        'maxSourceLines' => 20,
    ],
],

// Готовое действие
public function actions()
{
    return ['error' => ['class' => 'yii\web\ErrorAction']];
}
// или своё
public function actionError()
{
    $exception = Yii::$app->errorHandler->exception;
    return $this->render('error', ['exception' => $exception]);
}

Yii::debug('сообщение', __METHOD__);     // уровень trace
Yii::info('инфо', 'app.payment');
Yii::warning('что-то странное');
Yii::error($exception);

Yii::beginProfile('block1');
// ... измеряемый код (вложенность обязана быть корректной)
Yii::endProfile('block1');

'bootstrap' => ['log'],       // компонент log должен подниматься сразу
'components' => [
    'log' => [
        'traceLevel' => YII_DEBUG ? 3 : 0,
        'flushInterval' => 1000,
        'targets' => [
            [
                'class' => 'yii\log\FileTarget',
                'levels' => ['error', 'warning'],
                'categories' => ['yii\db\*', 'app\*'],
                'except' => ['yii\web\HttpException:404'],
                'logVars' => ['_SERVER'],
                'maskVars' => ['_SERVER.HTTP_X_PASSWORD', '_SERVER.*_SECRET'],
                'exportInterval' => 1000,
            ],
            [
                'class' => 'yii\log\EmailTarget',
                'levels' => ['error'],
                'message' => ['to' => ['admin@example.com'], 'subject' => 'Ошибка'],
            ],
        ],
    ],
],

yii\base\BaseObject   → свойства (геттеры/сеттеры), init(), конфигурация через массив
yii\base\Component    → BaseObject + события + поведения

class MyClass extends \yii\base\BaseObject
{
    public $prop1;

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

    public function init()
    {
        parent::init();                                  // родитель — в начале
        // проверки и нормализация ПОСЛЕ конфигурации
    }
}

class Foo extends \yii\base\BaseObject
{
    private $_label;

    public function getLabel()          { return $this->_label; }
    public function setLabel($value)    { $this->_label = trim($value); }
}

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

class Mailer extends \yii\base\Component
{
    const EVENT_MESSAGE_SENT = 'messageSent';

    public function send($message)
    {
        // ...
        $event = new MessageEvent(['message' => $message]);
        $this->trigger(self::EVENT_MESSAGE_SENT, $event);
    }
}

// Подписка: строка-функция, [$obj,'method'], ['Class','method'], анонимка
$mailer->on(Mailer::EVENT_MESSAGE_SENT, function ($event) {
    echo $event->name, $event->sender, $event->data;
});
$mailer->on(Mailer::EVENT_MESSAGE_SENT, 'handler', $data, $append = false);  // в начало очереди

$mailer->off(Mailer::EVENT_MESSAGE_SENT, $handler);   // отписать один
$mailer->off(Mailer::EVENT_MESSAGE_SENT);             // отписать все

// в конфигурации
'components' => ['db' => ['on afterOpen' => function ($e) { /* ... */ }]],

// на уровне класса — для всех экземпляров и наследников
Event::on(ActiveRecord::class, ActiveRecord::EVENT_AFTER_INSERT, fn ($e) => /* ... */);
Event::trigger(Foo::class, Foo::EVENT_HELLO);       // $event->sender === null
Event::off(Foo::class, Foo::EVENT_HELLO);

// на уровне интерфейса
Event::on('app\interfaces\DanceEventInterface', DanceEventInterface::EVENT_DANCE, $h);

// глобальные события — через синглтон приложения
Yii::$app->on('backend.mail.sent', $handler);
Yii::$app->trigger('backend.mail.sent', new Event(['sender' => $this]));

namespace app\components;

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

class MyBehavior extends Behavior
{
    public $prop1;

    public function events()
    {
        return [ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate'];
    }

    public function beforeValidate($event)
    {
        $this->owner;        // компонент, к которому прикреплено поведение
    }

    public function foo() { /* станет методом компонента */ }
}

// статически
public function behaviors()
{
    return [
        MyBehavior::class,                                   // анонимное
        'myBehavior' => ['class' => MyBehavior::class, 'prop1' => 'v'],  // именованное
    ];
}

// динамически
$component->attachBehavior('myBehavior', new MyBehavior());
$component->detachBehavior('myBehavior');
$component->getBehavior('myBehavior');
$component->getBehaviors();

// через конфигурацию
['as myBehavior' => ['class' => MyBehavior::class, 'prop1' => 'v']]

use yii\behaviors\TimestampBehavior;
use yii\behaviors\BlameableBehavior;
use yii\behaviors\SluggableBehavior;

public function behaviors()
{
    return [
        [
            'class' => TimestampBehavior::class,
            'attributes' => [
                ActiveRecord::EVENT_BEFORE_INSERT => ['created_at', 'updated_at'],
                ActiveRecord::EVENT_BEFORE_UPDATE => ['updated_at'],
            ],
            // 'value' => new \yii\db\Expression('NOW()'),   // для типа datetime
        ],
        ['class' => BlameableBehavior::class, 'createdByAttribute' => 'author_id'],
        ['class' => SluggableBehavior::class, 'attribute' => 'title', 'ensureUnique' => true],
    ];
}

$user->touch('login_time');    // TimestampBehavior: обновить поле и сохранить

[
    'class' => 'app\components\SearchEngine',   // что создавать
    'apiKey' => 'xxx',                          // свойства
    'on search' => function ($event) { },       // обработчики событий
    'as indexer' => ['class' => IndexerBehavior::class],   // поведения
]

$object = Yii::createObject($config);     // создать по конфигу
Yii::configure($object, $config);         // применить к существующему (без ключа class)

Yii::$container->set('yii\widgets\LinkPager', ['maxButtonCount' => 5]);
// или декларативно, в конфиге приложения (с 2.0.11):
'container' => [
    'definitions' => ['yii\widgets\LinkPager' => ['maxButtonCount' => 5]],
    'singletons' => [/* ... */],
],

if (YII_ENV_DEV) { $config['bootstrap'][] = 'debug'; }

Yii::setAlias('@images', '@webroot/images');
Yii::setAlias('@cdn', 'https://cdn.example.com');
echo Yii::getAlias('@images/logo.png');    // /var/www/web/images/logo.png

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

$locator->set('cache', 'yii\caching\ApcCache');
$locator->set('db', ['class' => 'yii\db\Connection', 'dsn' => '...']);
$locator->set('search', fn () => new app\components\SolrService());
$locator->set('pageCache', new FileCache());

$locator->get('cache');   // == $locator->cache
$locator->has('cache');

// Регистрация
Yii::$container->set('yii\mail\MailerInterface', 'yii\symfonymailer\Mailer');  // интерфейс → класс
Yii::$container->set('db', ['class' => 'yii\db\Connection', 'dsn' => '...']);  // алиас + конфиг
Yii::$container->set('Foo', fn ($c, $params, $config) => new Foo(new Bar()));  // фабрика
Yii::$container->setSingleton('app\storage\FileStorage', [['class' => FileStorage::class], ['/var/tmp']]);

// Получение
$obj = Yii::$container->get('app\components\SearchEngine', [$apiKey], ['type' => 1]);
Yii::$container->invoke([$obj, 'doSomething'], ['param1' => 42]);  // внедрение в метод

class HotelController extends \yii\web\Controller
{
    public function __construct($id, $module, BookingInterface $booking, $config = [])
    {
        $this->booking = $booking;
        parent::__construct($id, $module, $config);
    }
}
// нужно лишь сказать контейнеру, какая реализация используется:
Yii::$container->set(BookingInterface::class, BookingService::class);

'db' => [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=localhost;dbname=example',
    'username' => 'root',
    'password' => '',
    'charset' => 'utf8mb4',
    'tablePrefix' => 'tbl_',
    'enableSchemaCache' => true,          // кеш схемы — обязателен на продакшене
    'schemaCacheDuration' => 3600,
    'schemaCache' => 'cache',
    'on afterOpen' => function ($event) {
        $event->sender->createCommand("SET time_zone = '+00:00'")->execute();
    },
],

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

$posts  = $db->createCommand('SELECT * FROM post')->queryAll();      // [] если пусто
$post   = $db->createCommand('SELECT * FROM post WHERE id=1')->queryOne();  // false если пусто
$titles = $db->createCommand('SELECT title FROM post')->queryColumn();
$count  = $db->createCommand('SELECT COUNT(*) FROM post')->queryScalar();

$rows = $db->createCommand('UPDATE post SET status=1 WHERE id=1')->execute();  // кол-во строк

$post = $db->createCommand('SELECT * FROM post WHERE id=:id AND status=:s')
    ->bindValue(':id', $id)
    ->bindValue(':s', 1)
    ->queryOne();

// или сразу
$db->createCommand($sql, [':id' => $id, ':s' => 1])->queryOne();

// bindParam() привязывает по ссылке — удобно в циклах (запрос готовится один раз)
$command = $db->createCommand('SELECT * FROM post WHERE id=:id')->bindParam(':id', $id);
foreach ([1, 2, 3] as $id) { $rows[] = $command->queryOne(); }

$db->createCommand()->insert('user', ['name' => 'Sam', 'age' => 30])->execute();
$db->createCommand()->batchInsert('user', ['name', 'age'], [
    ['Tom', 30], ['Jane', 20],
])->execute();
$db->createCommand()->update('user', ['status' => 1], 'age > 30')->execute();
$db->createCommand()->delete('user', ['status' => 0])->execute();
$db->createCommand()->upsert('user', ['email' => 'a@b.c', 'hits' => 1], ['hits' => new Expression('hits + 1')])->execute();
$db->getLastInsertID();

// [[столбец]] и {{таблица}}; {{%таблица}} подставляет tablePrefix
$db->createCommand("SELECT COUNT([[id]]) FROM {{%employee}}")->queryScalar();

// краткая форма
Yii::$app->db->transaction(function ($db) {
    $db->createCommand($sql1)->execute();
    $db->createCommand($sql2)->execute();
}, \yii\db\Transaction::REPEATABLE_READ);

// полный контроль
$transaction = Yii::$app->db->beginTransaction();
try {
    // ...
    $transaction->commit();
} catch (\Throwable $e) {
    $transaction->rollBack();
    throw $e;
}

[
    'class' => 'yii\db\Connection',
    'dsn' => 'мастер',
    'username' => 'master', 'password' => '',
    'slaveConfig' => ['username' => 'slave', 'password' => '',
                      'attributes' => [PDO::ATTR_TIMEOUT => 10]],
    'slaves' => [
        ['dsn' => 'слейв 1'],
        ['dsn' => 'слейв 2'],
    ],
    // либо несколько мастеров: 'masters' => [...], 'masterConfig' => [...]
]

$rows = Yii::$app->db->useMaster(fn ($db) => $db->createCommand($sql)->queryAll());
Yii::$app->db->enableSlaves = false;

$db->createCommand()->createTable('post', ['id' => 'pk', 'title' => 'string', 'text' => 'text'])->execute();

$table = Yii::$app->db->getTableSchema('post');   // yii\db\TableSchema
$table->columns['title']->type;
$table->primaryKey;
Yii::$app->db->schema->getTableNames();

use yii\db\Query;

$rows = (new Query())
    ->select(['id', 'email'])
    ->from('user')
    ->where(['last_name' => 'Smith'])
    ->limit(10)
    ->all();

$query->select(['user_id' => 'user.id', 'email']);            // алиасы через ключи
$query->select(["CONCAT(first_name,' ',last_name) AS full_name"]);
$query->addSelect(['created_at'])->distinct();
$query->from(['u' => 'public.user', 'p' => 'public.post']);

$sub = (new Query())->select('COUNT(*)')->from('user');
$query->select(['id', 'count' => $sub])->from('post');        // подзапрос в SELECT
$query->from(['u' => $sub]);                                  // подзапрос во FROM

// 1. строка (только с привязкой параметров!)
$query->where('status=:status', [':status' => $status]);

// 2. хеш — равенства через AND, корректно обрабатывает null и массивы
$query->where(['status' => 10, 'type' => null, 'id' => [4, 8, 15]]);
// WHERE (status=10) AND (type IS NULL) AND (id IN (4,8,15))

// 3. операторы
$query->where(['and', ['status' => 1], ['or', ['>', 'age', 30], ['type' => 2]]]);

$query->andWhere(['like', 'title', $search])->orWhere(['author_id' => 1]);

// filterWhere игнорирует пустые значения (null, '', [], пробелы) — для форм поиска
$query->filterWhere(['username' => $username, 'email' => $email])
      ->andFilterWhere(['like', 'name', $name]);

$query->orderBy(['id' => SORT_ASC, 'name' => SORT_DESC])->addOrderBy('age');
$query->groupBy(['id', 'status'])->addGroupBy('age');
$query->having(['status' => 1])->andHaving(['>', 'age', 30]);
$query->limit(10)->offset(20);

$query->join('LEFT JOIN', 'post', 'post.user_id = user.id');
$query->innerJoin('post', 'post.user_id = user.id');
$query->leftJoin(['u' => $subQuery], 'u.id = author_id');
$query->union($otherQuery);
$query->withQuery($cteQuery, 'cte');      // CTE, с 2.0.35

$query->all();      // массив строк
$query->one();      // первая строка (LIMIT не добавляется — ставьте limit(1) сами)
$query->column();   // первый столбец
$query->scalar();   // одно значение
$query->exists();   // bool
$query->count();  $query->sum('x');  $query->average('x');  $query->max('x');  $query->min('x');

$query->indexBy('id')->all();                       // индексация результата
$query->indexBy(fn ($row) => $row['id'] . $row['username'])->all();

foreach ($query->batch(100) as $rows) { }           // пакетами по 100
foreach ($query->each(100) as $row) { }             // по одной строке, память экономится

// Посмотреть SQL
$command = $query->createCommand();
echo $command->getRawSql();          // с подставленными параметрами
echo $command->sql; print_r($command->params);

namespace app\models;

use yii\db\ActiveRecord;

class Customer extends ActiveRecord
{
    const STATUS_ACTIVE = 1;

    public static function tableName()      // по умолчанию: camel2id(имя класса)
    {
        return '{{%customer}}';             // %  → подставится tablePrefix
    }

    public static function getDb()          // другое соединение
    {
        return \Yii::$app->db2;
    }
}

Customer::findOne(123);                                   // по первичному ключу
Customer::findOne(['id' => 123, 'status' => 1]);           // по условию-хешу
Customer::findAll([100, 101, 123]);                        // несколько PK
Customer::find()->where(['status' => 1])->orderBy('id')->all();
Customer::find()->where(['status' => 1])->count();
Customer::find()->indexBy('id')->all();
Customer::find()->asArray()->all();                        // массивы вместо объектов — экономнее
Customer::findBySql('SELECT * FROM customer WHERE status=:s', [':s' => 1])->all();
Customer::find()->limit(1)->one();                         // one() сам LIMIT не добавляет!

foreach (Customer::find()->batch(100) as $customers) { }   // пакетная выборка
foreach (Customer::find()->each(100) as $customer) { }

$customer = new Customer();
$customer->name = 'James';
$customer->save();                       // insert + валидация
$customer->save(false);                  // без валидации
$customer->insert();  $customer->update();   // явно

$customer = Customer::findOne(123);
$customer->email = 'new@example.com';
$customer->save();                       // update только «грязных» атрибутов

$customer->attributes = ['name' => 'X']; // массовое присвоение (только безопасные атрибуты)
$customer->loadDefaultValues();          // значения DEFAULT из схемы БД

$post->updateCounters(['view_count' => 1]);          // UPDATE ... SET view_count = view_count + 1
Customer::updateAll(['status' => 1], ['like', 'email', '@example.com']);
Customer::updateAllCounters(['age' => 1]);
$customer->delete();
Customer::deleteAll(['status' => 0]);                // осторожно: без условия удалит всё

$customer->isNewRecord;
$customer->getDirtyAttributes();  $customer->markAttributeDirty('name');
$customer->getOldAttributes();  $customer->getOldAttribute('name');
$customer->refresh();
$customer->getPrimaryKey();  Customer::primaryKey();

public function beforeSave($insert)
{
    if (!parent::beforeSave($insert)) { return false; }   // false → сохранение отменяется
    $this->slug = \yii\helpers\Inflector::slug($this->title);
    return true;
}

Customer::getDb()->transaction(function ($db) use ($customer) {
    $customer->save();
    // ...
});

public function transactions()
{
    return [
        'admin' => self::OP_INSERT,
        'api' => self::OP_ALL,   // OP_INSERT | OP_UPDATE | OP_DELETE
    ];
}

class Customer extends ActiveRecord
{
    public function getOrders()            // hasMany: ['чужой_столбец' => 'свой_столбец']
    {
        return $this->hasMany(Order::class, ['customer_id' => 'id'])->inverseOf('customer');
    }

    public function getCountry()
    {
        return $this->hasOne(Country::class, ['id' => 'country_id']);
    }

    public function getBigOrders($threshold = 100)   // связь с параметром
    {
        return $this->hasMany(Order::class, ['customer_id' => 'id'])
            ->where(['>', 'subtotal', $threshold]);
    }
}

public function getItems()
{
    return $this->hasMany(Item::class, ['id' => 'item_id'])
        ->viaTable('order_item', ['order_id' => 'id']);
}

// или через уже объявленную связь
public function getOrderItems() { return $this->hasMany(OrderItem::class, ['order_id' => 'id']); }
public function getItems()      { return $this->hasMany(Item::class, ['id' => 'item_id'])->via('orderItems'); }

$customer->orders;          // массив Order — запрос выполняется один раз и кешируется
$customer->getOrders();     // объект ActiveQuery — можно донастроить
$customer->getOrders()->where(['>', 'subtotal', 200])->all();
unset($customer->orders);   // сбросить кеш связи

// 101 запрос — плохо
$customers = Customer::find()->limit(100)->all();
foreach ($customers as $c) { $c->orders; }

// 2 запроса — хорошо
$customers = Customer::find()->with('orders')->limit(100)->all();

// вложенные связи и настройка запроса на лету
Customer::find()->with([
    'country',
    'orders' => fn ($q) => $q->andWhere(['status' => Order::STATUS_ACTIVE]),
    'orders.items',
])->all();

// фильтр по связной таблице + жадная загрузка
Customer::find()->joinWith('orders')->where(['order.status' => 1])->all();
Customer::find()->innerJoinWith('orders')->all();
Customer::find()->joinWith('orders', false)->all();            // без жадной загрузки

// псевдоним связной таблицы (с 2.0.7)
$query->joinWith(['orders o'])->orderBy('o.id');
$query->joinWith(['orders o' => fn ($q) => $q->joinWith('product p')])->where('o.amount > 100');

// условие в ON, а не в WHERE: вернутся ВСЕ покупатели, но только активные заказы
Customer::find()->joinWith([
    'orders' => fn ($q) => $q->onCondition(['order.status' => Order::STATUS_ACTIVE]),
])->all();

$order->link('customer', $customer);        // проставит FK и сохранит
$order->link('items', $item);               // вставит строку в промежуточную таблицу
$customer->unlink('orders', $order);        // FK → null
$customer->unlink('orders', $order, true);  // удалить связную запись/строку связи
$customer->unlinkAll('orders', true);

class Comment extends ActiveRecord
{
    public static function find()
    {
        return new CommentQuery(get_called_class());
    }
}

class CommentQuery extends \yii\db\ActiveQuery
{
    public function active($state = true)
    {
        return $this->andWhere(['active' => $state]);   // именно andWhere, не where
    }
}

Comment::find()->active()->all();
Customer::find()->with(['comments' => fn ($q) => $q->active()])->all();

class Room extends ActiveRecord
{
    public $volume;
}

Room::find()
    ->select(['{{room}}.*', '([[length]] * [[width]] * [[height]]) AS volume'])
    ->orderBy('volume DESC')
    ->all();

yii migrate/create create_news_table     # создать миграцию
yii migrate                              # применить все новые
yii migrate 3                            # применить 3 следующие
yii migrate/to 150101_185401             # применить/откатить до конкретной миграции
yii migrate/down                         # откатить последнюю
yii migrate/down 3                       # откатить 3 последние
yii migrate/redo                         # откатить и применить заново
yii migrate/history all                  # применённые миграции
yii migrate/new all                      # ещё не применённые
yii migrate/mark 150101_185401           # отметить применённой, ничего не выполняя
yii migrate/fresh                        # очистить БД и применить всё заново (не для прода!)
yii help migrate

use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function safeUp()        // safeUp/safeDown выполняются в транзакции
    {
        $this->createTable('{{%news}}', [
            'id' => $this->primaryKey(),
            'title' => $this->string(255)->notNull(),
            'content' => $this->text(),
            'author_id' => $this->integer()->notNull(),
            'status' => $this->smallInteger()->defaultValue(1),
            'created_at' => $this->integer()->notNull(),
        ], $this->db->driverName === 'mysql' ? 'ENGINE=InnoDB DEFAULT CHARSET=utf8mb4' : null);

        $this->createIndex('idx-news-author_id', '{{%news}}', 'author_id');
        $this->addForeignKey('fk-news-author_id', '{{%news}}', 'author_id', '{{%user}}', 'id', 'CASCADE');
        $this->insert('{{%news}}', ['title' => 'Первая новость', 'created_at' => time()]);
    }

    public function safeDown()      // обратный порядок операций
    {
        $this->dropForeignKey('fk-news-author_id', '{{%news}}');
        $this->dropTable('{{%news}}');
    }
}

$this->primaryKey()        $this->bigPrimaryKey()
$this->string(64)          $this->text()          $this->char(2)
$this->integer()           $this->bigInteger()    $this->smallInteger()  $this->tinyInteger()
$this->decimal(10, 2)      $this->float()         $this->double()        $this->money()
$this->boolean()           $this->binary()        $this->json()
$this->date()              $this->time()          $this->dateTime()      $this->timestamp()

// модификаторы — цепочкой
$this->string(12)->notNull()->unique()->defaultValue('x')->comment('Комментарий')->after('id')

yii migrate/create create_post_table --fields="title:string(12):notNull:unique,body:text"

yii migrate/create create_post_table \
  --fields="author_id:integer:notNull:foreignKey(user),category_id:integer:foreignKey,title:string,body:text"

yii migrate/create add_position_column_to_post_table --fields=position:integer
yii migrate/create create_junction_table_for_post_and_tag_tables

// config/console.php
'controllerMap' => [
    'migrate' => [
        'class' => 'yii\console\controllers\MigrateController',
        'migrationPath' => null,                      // отключить путь по умолчанию
        'migrationNamespaces' => [
            'app\migrations',
            'module\migrations',
            'some\extension\migrations',
        ],
        'migrationTable' => '{{%migration}}',
    ],
],

yii migrate --db=db2                              # мигрировать другую базу
yii migrate --migrationPath=@app/migrations/shop  # отдельный набор миграций

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

$form = ActiveForm::begin([
    'id' => 'login-form',
    'options' => ['class' => 'form-horizontal', 'enctype' => 'multipart/form-data'],
    'enableClientValidation' => true,
    'enableAjaxValidation' => false,
    'validateOnBlur' => true,
    'fieldConfig' => ['template' => "{label}\n{input}\n{hint}\n{error}"],
]) ?>

    <?= $form->field($model, 'username')->textInput(['maxlength' => true, 'autofocus' => true]) ?>
    <?= $form->field($model, 'password')->passwordInput() ?>
    <?= $form->field($model, 'email')->input('email')->hint('Например, user@example.com') ?>
    <?= $form->field($model, 'rememberMe')->checkbox() ?>
    <?= $form->field($model, 'about')->textarea(['rows' => 6]) ?>
    <?= $form->field($model, 'category_id')->dropDownList($items, ['prompt' => 'Выберите…']) ?>
    <?= $form->field($model, 'tags[]')->checkboxList($items) ?>
    <?= $form->field($model, 'type')->radioList($items) ?>
    <?= $form->field($model, 'file')->fileInput() ?>
    <?= $form->field($model, 'code')->widget(\yii\captcha\Captcha::class) ?>
    <?= $form->field($model, 'name')->label('Ваше имя')->error(['class' => 'help-block']) ?>
    <?= $form->errorSummary($model) ?>

    <?= Html::submitButton('Войти', ['class' => 'btn btn-primary']) ?>

<?php ActiveForm::end() ?>

echo $form->field($model, 'uploadFile[]')->fileInput(['multiple' => true]);
echo $form->field($model, 'items[]')->checkboxList(['a' => 'A', 'b' => 'B']);

public function rules()
{
    return [
        [['name', 'email'], 'required'],
        ['email', 'email'],
        ['age', 'integer', 'min' => 18, 'max' => 120],
        ['username', 'string', 'length' => [4, 24]],
        ['username', 'unique', 'targetClass' => User::class],
        ['password_repeat', 'compare', 'compareAttribute' => 'password'],
        ['status', 'in', 'range' => array_keys(self::statuses())],
        [['created_at'], 'safe'],
        // только в сценарии, с условием и своим сообщением
        ['state', 'required', 'on' => self::SCENARIO_REGISTER,
            'message' => 'Укажите регион',
            'when' => fn ($model) => $model->country === 'USA',
            'whenClient' => "function (attribute, value) { return $('#country').val() == 'USA'; }"],
    ];
}

$model->validate();                       // все активные атрибуты
$model->validate(['email']);              // только указанные
$model->hasErrors();  $model->errors;  $model->getFirstErrors();
$model->addError('email', 'Занят');
$model->clearErrors();

// самые частые комбинации
[['username', 'email'], 'trim'],
[['from_date', 'to_date'], 'default', 'value' => null],
['phone', 'filter', 'filter' => fn ($v) => preg_replace('/\D/', '', $v)],
['tags', 'each', 'rule' => ['integer']],
['email', 'unique', 'targetClass' => User::class, 'filter' => ['status' => 10]],
['category_id', 'exist', 'targetClass' => Category::class, 'targetAttribute' => 'id'],
['age', 'compare', 'compareValue' => 30, 'operator' => '>=', 'type' => 'number'],

public function rules()
{
    return [
        ['country', 'validateCountry'],
        ['token', function ($attribute, $params, $validator) {
            if (!ctype_alnum($this->$attribute)) {
                $this->addError($attribute, 'Только буквы и цифры.');
            }
        }, 'skipOnEmpty' => false, 'skipOnError' => false],
    ];
}

public function validateCountry($attribute, $params)
{
    if (!in_array($this->$attribute, ['USA', 'Indonesia'], true)) {
        $this->addError($attribute, 'Недопустимая страна.');
    }
}

namespace app\components;

use yii\validators\Validator;

class CountryValidator extends Validator
{
    public function init()
    {
        parent::init();
        $this->message = $this->message ?? 'Недопустимая страна.';
    }

    public function validateAttribute($model, $attribute)
    {
        if (!in_array($model->$attribute, ['USA', 'Indonesia'], true)) {
            $this->addError($model, $attribute, $this->message);
        }
    }

    // для проверки значения без модели
    protected function validateValue($value)
    {
        return in_array($value, ['USA', 'Indonesia'], true) ? null : [$this->message, []];
    }

    // клиентская часть
    public function clientValidateAttribute($model, $attribute, $view)
    {
        $message = json_encode($this->message, JSON_UNESCAPED_UNICODE);
        return "if ($.inArray(value, ['USA','Indonesia']) === -1) { messages.push($message); }";
    }
}

// один валидатор
$validator = new \yii\validators\EmailValidator();
if ($validator->validate($email, $error)) { /* ok */ } else { echo $error; }

// набор правил «на лету»
$model = \yii\base\DynamicModel::validateData(compact('name', 'email'), [
    [['name', 'email'], 'string', 'max' => 128],
    ['email', 'email'],
]);
if ($model->hasErrors()) { /* ... */ }

// представление
$form = ActiveForm::begin(['id' => 'registration-form', 'enableAjaxValidation' => true]);
echo $form->field($model, 'username', ['enableAjaxValidation' => true]);

// действие
if (Yii::$app->request->isAjax && $model->load(Yii::$app->request->post())) {
    Yii::$app->response->format = Response::FORMAT_JSON;
    return ActiveForm::validate($model);
}

class UploadForm extends \yii\base\Model
{
    /** @var \yii\web\UploadedFile[] */
    public $imageFiles;

    public function rules()
    {
        return [[['imageFiles'], 'file', 'skipOnEmpty' => false,
                 'extensions' => 'png, jpg', 'maxFiles' => 4]];
    }

    public function upload()
    {
        if (!$this->validate()) { return false; }
        foreach ($this->imageFiles as $file) {
            $file->saveAs('uploads/' . $file->baseName . '.' . $file->extension);
        }
        return true;
    }
}

// представление
<?= $form->field($model, 'imageFiles[]')->fileInput(['multiple' => true, 'accept' => 'image/*']) ?>

// контроллер
$model->imageFiles = UploadedFile::getInstances($model, 'imageFiles');  // getInstance() для одного

// одна форма — несколько разных моделей
if ($user->load(Yii::$app->request->post()) && $profile->load(Yii::$app->request->post())
    && Model::validateMultiple([$user, $profile])) {
    // сохраняем в транзакции
}

// табличный ввод: массив однотипных моделей
$models = Item::findAll($ids);
if (Model::loadMultiple($models, Yii::$app->request->post())
    && Model::validateMultiple($models)) {
    foreach ($models as $model) { $model->save(false); }
}

// в представлении — индексы в именах полей
foreach ($models as $i => $model) {
    echo $form->field($model, "[$i]name");
}

$f = Yii::$app->formatter;

$f->asDate('2014-01-01', 'long');      // 1 января 2014 г.
$f->asDate('now', 'php:d.m.Y');        // через формат date()
$f->asDatetime($ts);  $f->asTime($ts);  $f->asTimestamp($date);
$f->asRelativeTime($ts);               // «час назад»
$f->asDuration(3720);                  // «1 час 2 минуты»

$f->asInteger(42);  $f->asDecimal(2542.123);  $f->asPercent(0.125, 2);
$f->asCurrency(420, 'EUR');  $f->asScientific(42000);
$f->asSize(1024 * 410);  $f->asShortSize(1024 * 410);

$f->asText($str);  $f->asNtext($str);  $f->asParagraphs($str);
$f->asHtml($str);  $f->asRaw($str);
$f->asEmail($m);  $f->asUrl($u);  $f->asImage($src);  $f->asBoolean(true);

$f->format($value, 'date');            // по имени формата
$f->format(0.125, ['percent', 2]);     // формат с параметрами
$f->asDate(null);                      // «(не задано)» — nullDisplay

'formatter' => [
    'dateFormat' => 'dd.MM.yyyy',
    'datetimeFormat' => 'dd.MM.yyyy HH:mm',
    'decimalSeparator' => ',',
    'thousandSeparator' => ' ',
    'currencyCode' => 'UAH',
    'nullDisplay' => '—',
    'locale' => 'ru-RU',
    'timeZone' => 'Europe/Kyiv',
],

$query = Article::find()->where(['status' => 1]);
$pages = new \yii\data\Pagination([
    'totalCount' => $query->count(),
    'pageSize' => 20,
    'pageSizeParam' => false,      // не читать per-page из URL
]);
$models = $query->offset($pages->offset)->limit($pages->limit)->all();

echo \yii\widgets\LinkPager::widget(['pagination' => $pages, 'maxButtonCount' => 5]);

$sort = new \yii\data\Sort([
    'attributes' => [
        'age',
        'name' => [
            'asc' => ['first_name' => SORT_ASC, 'last_name' => SORT_ASC],
            'desc' => ['first_name' => SORT_DESC, 'last_name' => SORT_DESC],
            'default' => SORT_DESC,
            'label' => 'Имя',
        ],
    ],
    'defaultOrder' => ['age' => SORT_ASC],
]);

$articles = Article::find()->orderBy($sort->orders)->all();
echo $sort->link('name') . ' | ' . $sort->link('age');

use yii\data\ActiveDataProvider;

$provider = new ActiveDataProvider([
    'query' => Post::find()->where(['status' => 1]),
    'pagination' => ['pageSize' => 20],
    'sort' => ['defaultOrder' => ['created_at' => SORT_DESC]],
    'key' => 'slug',                     // или функция: fn ($model) => md5($model->id)
]);

$provider->getModels();  $provider->getKeys();
$provider->getCount();   $provider->getTotalCount();

use yii\grid\GridView;

echo GridView::widget([
    'dataProvider' => $dataProvider,
    'filterModel' => $searchModel,
    'summary' => 'Показано {begin}–{end} из {totalCount}',
    'columns' => [
        ['class' => 'yii\grid\SerialColumn'],
        'id',
        'title',
        'author.name',                                  // атрибут связи
        'created_at:datetime',                          // формат
        [
            'attribute' => 'status',
            'value' => fn ($model) => $model->statusLabel,
            'filter' => ['0' => 'Черновик', '1' => 'Опубликован'],
            'filterInputOptions' => ['class' => 'form-control', 'prompt' => 'Все'],
            'contentOptions' => ['class' => 'text-center'],
        ],
        [
            'class' => 'yii\grid\ActionColumn',
            'template' => '{view} {update} {delete}',
            'buttons' => [
                'view' => fn ($url, $model, $key) => Html::a('👁', $url),
            ],
            'visibleButtons' => [
                'update' => fn ($model) => Yii::$app->user->can('updatePost', ['post' => $model]),
            ],
            'urlCreator' => fn ($action, $model, $key, $index) => Url::to([$action, 'id' => $model->id]),
        ],
        ['class' => 'yii\grid\CheckboxColumn'],
    ],
]);

class PostSearch extends Post
{
    public $createdFrom;
    public $createdTo;

    public function rules()
    {
        return [
            [['id'], 'integer'],
            [['title', 'created_at', 'author.name', 'createdFrom', 'createdTo'], 'safe'],
        ];
    }

    public function scenarios() { return \yii\base\Model::scenarios(); }  // все атрибуты активны

    public function attributes()
    {
        return array_merge(parent::attributes(), ['author.name']);   // атрибут связи для поиска
    }

    public function search($params)
    {
        $query = Post::find();
        $dataProvider = new ActiveDataProvider(['query' => $query]);

        $query->joinWith(['author' => fn ($q) => $q->from(['author' => 'user'])]);
        $dataProvider->sort->attributes['author.name'] = [
            'asc' => ['author.name' => SORT_ASC],
            'desc' => ['author.name' => SORT_DESC],
        ];

        if (!($this->load($params) && $this->validate())) {
            return $dataProvider;
        }

        $query->andFilterWhere(['id' => $this->id])
            ->andFilterWhere(['like', 'title', $this->title])
            ->andFilterWhere(['like', 'author.name', $this->getAttribute('author.name')])
            ->andFilterWhere(['>=', 'created_at', $this->createdFrom])
            ->andFilterWhere(['<=', 'created_at', $this->createdTo]);

        return $dataProvider;
    }
}

$searchModel = new PostSearch();
$dataProvider = $searchModel->search(Yii::$app->request->queryParams);

$userProvider->pagination->pageParam = 'user-page';
$userProvider->sort->sortParam = 'user-sort';

echo \yii\widgets\ListView::widget([
    'dataProvider' => $dataProvider,
    'itemView' => '_post',                 // в виде доступны $model, $key, $index, $widget
    'viewParams' => ['fullView' => true],
    'layout' => "{summary}\n{items}\n{pager}",
]);

echo \yii\widgets\DetailView::widget([
    'model' => $model,
    'attributes' => [
        'title',
        'description:html',
        ['label' => 'Автор', 'value' => $model->author->name],
        'created_at:datetime',
    ],
]);

$this->registerJs("$('#b').on('click', fn);", View::POS_READY, 'my-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']);
$this->registerJsVar('yiiOptions', $options);     // безопасная передача данных в JS

$this->registerJs('var opts = ' . \yii\helpers\Json::htmlEncode($options) . ';', View::POS_HEAD, 'opts');

'components' => [
    'view' => [
        'theme' => [
            'basePath' => '@app/themes/basic',
            'baseUrl' => '@web/themes/basic',
            'pathMap' => [
                '@app/views' => '@app/themes/basic',
                '@app/modules' => '@app/themes/basic/modules',   // темы для модулей
                '@app/widgets' => '@app/themes/basic/widgets',
            ],
        ],
    ],
],

'components' => [
    'user' => [
        'identityClass' => 'app\models\User',
        'enableAutoLogin' => true,        // «запомнить меня» через cookie
        'enableSession' => true,          // false для stateless REST API
        'loginUrl' => ['site/login'],
        'authTimeout' => 3600,
    ],
],

class User extends ActiveRecord implements \yii\web\IdentityInterface
{
    public static function findIdentity($id) { return static::findOne($id); }

    public static function findIdentityByAccessToken($token, $type = null)
    {
        return static::findOne(['access_token' => $token]);
    }

    public function getId() { return $this->id; }
    public function getAuthKey() { return $this->auth_key; }
    public function validateAuthKey($authKey) { return $this->getAuthKey() === $authKey; }

    public function beforeSave($insert)
    {
        if (!parent::beforeSave($insert)) { return false; }
        if ($this->isNewRecord) {
            $this->auth_key = Yii::$app->security->generateRandomString();
        }
        return true;
    }
}

Yii::$app->user->identity;     // объект identity или null
Yii::$app->user->id;
Yii::$app->user->isGuest;

Yii::$app->user->login($identity, 3600 * 24 * 30);   // второй аргумент — срок cookie
Yii::$app->user->logout();          // logout(false) — сохранить данные сессии
Yii::$app->user->loginRequired();

use yii\filters\AccessControl;

public function behaviors()
{
    return [
        'access' => [
            'class' => AccessControl::class,
            'only' => ['login', 'logout', 'signup', 'admin'],
            'denyCallback' => function ($rule, $action) {
                throw new \yii\web\ForbiddenHttpException('Нет доступа');
            },
            'rules' => [
                ['allow' => true, 'actions' => ['login', 'signup'], 'roles' => ['?']],   // гости
                ['allow' => true, 'actions' => ['logout'], 'roles' => ['@']],            // авторизованные
                ['allow' => true, 'actions' => ['admin'], 'roles' => ['admin'],          // роль RBAC
                 'ips' => ['192.168.*'], 'verbs' => ['GET', 'POST'],
                 'matchCallback' => fn ($rule, $action) => date('N') < 6],
            ],
        ],
    ];
}

'components' => [
    'authManager' => [
        'class' => 'yii\rbac\DbManager',        // или yii\rbac\PhpManager (файлы в @app/rbac)
        'defaultRoles' => ['guest'],
    ],
],

// консольная команда инициализации
$auth = Yii::$app->authManager;

$createPost = $auth->createPermission('createPost');
$createPost->description = 'Создание поста';
$auth->add($createPost);

$updatePost = $auth->createPermission('updatePost');
$auth->add($updatePost);

$author = $auth->createRole('author');
$auth->add($author);
$auth->addChild($author, $createPost);

$admin = $auth->createRole('admin');
$auth->add($admin);
$auth->addChild($admin, $updatePost);
$auth->addChild($admin, $author);       // роль включает другую роль

$auth->assign($author, 2);              // ID пользователя из getId()
$auth->assign($admin, 1);

namespace app\rbac;

class AuthorRule extends \yii\rbac\Rule
{
    public $name = 'isAuthor';

    public function execute($user, $item, $params)
    {
        return isset($params['post']) ? $params['post']->createdBy == $user : false;
    }
}

$rule = new \app\rbac\AuthorRule();
$auth->add($rule);

$updateOwnPost = $auth->createPermission('updateOwnPost');
$updateOwnPost->ruleName = $rule->name;
$auth->add($updateOwnPost);
$auth->addChild($updateOwnPost, $updatePost);
$auth->addChild($author, $updateOwnPost);

if (Yii::$app->user->can('createPost')) { /* ... */ }
if (Yii::$app->user->can('updatePost', ['post' => $post])) { /* ... */ }
Yii::$app->authManager->checkAccess($userId, 'updatePost', ['post' => $post]);

$hash = Yii::$app->security->generatePasswordHash($password);   // bcrypt
if (Yii::$app->security->validatePassword($password, $hash)) { /* ok */ }

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

$security->generateRandomString(32);        // токены сброса пароля и т.п.
$security->generateRandomKey(32);

$encrypted = $security->encryptByPassword($data, $password);
$data = $security->decryptByPassword($encrypted, $password);
$encrypted = $security->encryptByKey($data, $key);
$data = $security->decryptByKey($encrypted, $key);

$signed = $security->hashData($data, $secretKey);         // подпись целостности
$data = $security->validateData($signed, $secretKey);     // false, если подделали

$security->compareString($expected, $actual);             // сравнение без утечки по времени

// глобальный фильтр допустимых хостов
'as hostControl' => [
    'class' => 'yii\filters\HostControl',
    'allowedHosts' => ['example.com', '*.example.com'],
    'fallbackHostInfo' => 'https://example.com',
],

// белый список вместо подстановки имени столбца из запроса
public function actionList($orderBy = null)
{
    if (!in_array($orderBy, ['name', 'status'], true)) {
        throw new \yii\web\BadRequestHttpException('Недопустимая сортировка.');
    }
}

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

// классический паттерн
$data = $cache->get($key);
if ($data === false) {
    $data = $this->calculate();
    $cache->set($key, $data, 3600);
}

// то же самое одной строкой (с 2.0.11)
$data = $cache->getOrSet($key, fn () => $this->calculate(), 3600, $dependency);

'components' => [
    'cache' => [
        'class' => 'yii\caching\MemCache',
        'keyPrefix' => 'myapp',          // если хранилище общее для нескольких приложений
        'defaultDuration' => 3600,
        'servers' => [
            ['host' => 'server1', 'port' => 11211, 'weight' => 100],
            ['host' => 'server2', 'port' => 11211, 'weight' => 50],
        ],
    ],
],

$dependency = new \yii\caching\DbDependency(['sql' => 'SELECT MAX(updated_at) FROM post']);
$cache->set($key, $data, 30, $dependency);

$cache->set($key, $data, 0, new \yii\caching\TagDependency(['tags' => ['post', "post-$id"]]));
\yii\caching\TagDependency::invalidate(Yii::$app->cache, "post-$id");

$result = $db->cache(function ($db) {
    return Customer::find()->where(['id' => 1])->one();
}, $duration, $dependency);

$db->cache(function ($db) {
    $db->noCache(function ($db) {
        // этот запрос не кешируется
    });
});

// точечно для одной команды
$db->createCommand($sql)->cache(60)->queryOne();
$db->createCommand($sql)->noCache()->queryOne();

'db' => [
    'enableSchemaCache' => true,
    'schemaCacheDuration' => 3600,
    'schemaCache' => 'cache',
],

if ($this->beginCache($id, [
    'duration' => 3600,
    'dependency' => ['class' => 'yii\caching\DbDependency', 'sql' => 'SELECT MAX(updated_at) FROM post'],
    'variations' => [Yii::$app->language],
    'enabled' => Yii::$app->request->isGet,
])) {

    // ... тяжёлая генерация содержимого ...

    $this->endCache();
}

echo $this->renderDynamic('return Yii::$app->user->identity->name;');

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

public function behaviors()
{
    return [
        [
            'class' => 'yii\filters\HttpCache',
            'only' => ['index', 'view'],
            'lastModified' => fn ($action, $params) => Post::find()->max('updated_at'),
            'etagSeed' => fn ($action, $params) => serialize([$this->findModel()->title]),
            'cacheControlHeader' => 'public, max-age=300',
            'sessionCacheLimiter' => '',
        ],
    ];
}

yii cache                     # список кеширующих компонентов
yii cache/flush cache1 cache2
yii cache/flush-all
yii cache/flush-schema db     # сброс кеша схемы БД

// 1. Контроллер
namespace app\controllers;

class UserController extends \yii\rest\ActiveController
{
    public $modelClass = 'app\models\User';
}

// 2. Маршруты
'urlManager' => [
    'enablePrettyUrl' => true,
    'enableStrictParsing' => true,
    'showScriptName' => false,
    'rules' => [
        ['class' => 'yii\rest\UrlRule', 'controller' => 'user'],
    ],
],

// 3. Приём JSON
'request' => [
    'parsers' => ['application/json' => 'yii\web\JsonParser'],
],

[
    'class' => 'yii\rest\UrlRule',
    'controller' => ['u' => 'user'],          // явное имя в URL
    'except' => ['delete'],
    'extraPatterns' => ['GET search' => 'search'],
]

class User extends ActiveRecord implements \yii\web\Linkable
{
    public function fields()
    {
        return [
            'id',
            'email' => 'email_address',                         // переименование
            'name' => fn () => $this->first_name . ' ' . $this->last_name,
        ];
    }

    public function extraFields()
    {
        return ['profile', 'orders'];        // доступны по ?expand=profile
    }

    public function getLinks()               // HATEOAS
    {
        return [\yii\web\Link::REL_SELF => \yii\helpers\Url::to(['user/view', 'id' => $this->id], true)];
    }
}

GET /users?fields=id,email
GET /users?expand=profile
GET /users?fields=id,email&expand=profile
GET /users?sort=-email
GET /users?filter[id][in][]=2&filter[title][like]=cheese

public function actionIndex()
{
    return new ActiveDataProvider(['query' => Post::find()]);
}

public function actions()
{
    $actions = parent::actions();
    unset($actions['delete'], $actions['create']);
    $actions['index']['prepareDataProvider'] = [$this, 'prepareDataProvider'];
    return $actions;
}

public function checkAccess($action, $model = null, $params = [])
{
    if (in_array($action, ['update', 'delete'], true) && $model->author_id !== Yii::$app->user->id) {
        throw new \yii\web\ForbiddenHttpException('Можно менять только свои записи.');
    }
}

public function behaviors()
{
    $behaviors = parent::behaviors();
    $behaviors['contentNegotiator']['formats']['text/html'] = \yii\web\Response::FORMAT_HTML;
    return $behaviors;
}

// «конверт» для коллекции: items + _links + _meta в теле ответа
class UserController extends ActiveController
{
    public $modelClass = 'app\models\User';
    public $serializer = [
        'class' => 'yii\rest\Serializer',
        'collectionEnvelope' => 'items',
    ];
}

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

use yii\filters\auth\{CompositeAuth, HttpBasicAuth, HttpBearerAuth, QueryParamAuth};

public function behaviors()
{
    $behaviors = parent::behaviors();
    $behaviors['authenticator'] = [
        'class' => CompositeAuth::class,
        'authMethods' => [
            HttpBasicAuth::class,
            HttpBearerAuth::class,
            QueryParamAuth::class,
        ],
        'except' => ['options'],
    ];
    return $behaviors;
}

public function getRateLimit($request, $action)  { return [100, 600]; }  // 100 запросов / 600 сек
public function loadAllowance($request, $action) { return [$this->allowance, $this->allowance_updated_at]; }
public function saveAllowance($request, $action, $allowance, $timestamp)
{
    $this->allowance = $allowance;
    $this->allowance_updated_at = $timestamp;
    $this->save();
}

'modules' => [
    'v1' => ['class' => 'app\modules\v1\Module'],
    'v2' => ['class' => 'app\modules\v2\Module'],
],
'urlManager' => ['rules' => [
    ['class' => 'yii\rest\UrlRule', 'controller' => ['v1/user', 'v1/post']],
    ['class' => 'yii\rest\UrlRule', 'controller' => ['v2/user', 'v2/post']],
]],

$filter = new \yii\data\ActiveDataFilter([
    'searchModel' => (new \yii\base\DynamicModel(['id', 'title']))
        ->addRule(['id'], 'integer')
        ->addRule(['title'], 'string', ['min' => 2, 'max' => 200]),
    'attributeMap' => ['authorName' => '{{author}}.[[name]]'],
]);

$query = Post::find();
if ($filter->load(Yii::$app->request->get())) {
    $condition = $filter->build();
    if ($condition === false) { return $filter; }   // вернёт ошибки валидации фильтра
    $query->andWhere($condition);
}
return new ActiveDataProvider(['query' => $query]);

'response' => [
    'on beforeSend' => function ($event) {
        $response = $event->sender;
        if ($response->data !== null && Yii::$app->request->get('suppress_response_code')) {
            $response->data = ['success' => $response->isSuccessful, 'data' => $response->data];
            $response->statusCode = 200;
        }
    },
],

yii <маршрут> [--опция1=значение1 ... аргумент1 аргумент2]
yii                       # список всех команд
yii help migrate          # справка по команде
yii <маршрут> --appconfig=path/to/config.php    # другой конфиг

namespace app\commands;

use yii\console\Controller;
use yii\console\ExitCode;
use yii\helpers\Console;

/**
 * Управление рассылкой писем.
 */
class MailController extends Controller
{
    public $message;
    public $limit = 100;

    public function options($actionID)          // какие свойства доступны как --опции
    {
        return ['message', 'limit'];
    }

    public function optionAliases()             // короткие псевдонимы: -m
    {
        return ['m' => 'message'];
    }

    /**
     * Отправляет письма пачкой.
     * @param string $category категория рассылки
     */
    public function actionSend($category, $order = 'name')
    {
        $this->stdout("Отправка...\n", Console::BOLD);
        $name = $this->ansiFormat($category, Console::FG_YELLOW);

        if (!$this->confirm("Отправить рассылку $name?")) {
            return ExitCode::OK;
        }
        if ($somethingWrong) {
            $this->stderr("Ошибка\n", Console::FG_RED);
            return ExitCode::UNSPECIFIED_ERROR;   // 1
        }
        return ExitCode::OK;                      // 0
    }

    public function actionBatch(array $ids) { /* yii mail/batch 1,2,3 */ }
}

yii mail/send news -m=Привет --limit=50

'language' => 'ru-RU',           // язык вывода
'sourceLanguage' => 'en-US',     // язык строк в коде

Yii::$app->language = 'ru-RU';   // можно менять в рантайме (до вывода)
echo Yii::t('app', 'Hello, {username}!', ['username' => $name]);

'components' => [
    'i18n' => [
        'translations' => [
            'app*' => [
                'class' => 'yii\i18n\PhpMessageSource',   // либо GettextMessageSource / DbMessageSource
                'basePath' => '@app/messages',
                'sourceLanguage' => 'en-US',
                'fileMap' => ['app' => 'app.php', 'app/error' => 'error.php'],
                'on missingTranslation' => ['app\components\TranslationEventHandler', 'handleMissingTranslation'],
            ],
            'yii' => [                                    // переопределение сообщений фреймворка
                'class' => 'yii\i18n\PhpMessageSource',
                'basePath' => '@app/messages',
            ],
            '*' => ['class' => 'yii\i18n\PhpMessageSource'],   // fallback для всех категорий
        ],
    ],
],

Yii::t('app', 'Баланс: {0, number, currency}', $sum);
Yii::t('app', 'Сегодня {0, date, long}', time());
Yii::t('app', 'Время {0, time, short}', time());
Yii::t('app', '{n, spellout}', ['n' => 42]);          // сорок два
Yii::t('app', 'Вы {n, ordinal} посетитель', ['n' => 42]);
Yii::t('app', 'Прошло {n, duration}', ['n' => 47]);

echo Yii::t('app',
    'На диване {n, plural, =0{нет кошек} =1{лежит одна кошка} one{лежит # кошка} few{лежит # кошки} many{лежит # кошек} other{лежит # кошки}}!',
    ['n' => $count]
);

Yii::t('app', '{name} — {gender, select, женщина{ей} мужчина{ему} other{ему}} нравится Yii!',
    ['name' => 'Василий', 'gender' => 'мужчина']);

yii message/config-template config/i18n.php    # создать конфиг
yii message config/i18n.php                    # извлечь строки в файлы переводов

'components' => [
    'mailer' => [
        'class' => 'yii\symfonymailer\Mailer',   // в старых проектах: yii\swiftmailer\Mailer
        'viewPath' => '@app/mail',
        'useFileTransport' => YII_ENV_DEV,       // письма в @runtime/mail вместо отправки
        'transport' => [
            'scheme' => 'smtps',
            'host' => 'smtp.example.com',
            'username' => 'user',
            'password' => 'secret',
            'port' => 465,
        ],
    ],
],

Yii::$app->mailer->compose()
    ->setFrom('from@example.com')
    ->setTo('to@example.com')
    ->setSubject('Тема')
    ->setTextBody('Текст')
    ->setHtmlBody('<b>HTML</b>')
    ->send();

Yii::$app->mailer->compose('greetings', ['user' => $user])       // одно представление
Yii::$app->mailer->compose(['html' => 'contact-html', 'text' => 'contact-text'], $params)
    ->setFrom(...)->setTo(...)->setSubject(...)->send();

$message->attach('/path/to/file.pdf');
$message->attachContent($csv, ['fileName' => 'report.csv', 'contentType' => 'text/csv']);

// картинка внутри письма (в представлении)
<img src="<?= $message->embed($imageFileName) ?>">

Yii::$app->mailer->sendMultiple($messages);      // пачкой, одним соединением

use yii\helpers\ArrayHelper;

// Чтение вложенных значений — без isset-лапши
ArrayHelper::getValue($array, 'foo.bar.name', 'по умолчанию');
ArrayHelper::getValue($user, fn ($u, $default) => $u->firstName . ' ' . $u->lastName);
ArrayHelper::setValue($array, 'key.in', ['arr' => 'val']);
$type = ArrayHelper::remove($array, 'type');            // вернуть и удалить

ArrayHelper::keyExists('username', $data, false);       // без учёта регистра

// Столбцы, индексация, пары
ArrayHelper::getColumn($rows, 'id');
ArrayHelper::index($rows, 'id');                        // ['123' => [...], ...]
ArrayHelper::index($rows, null, 'class');               // группировка
ArrayHelper::map($rows, 'id', 'name');                  // для dropDownList
ArrayHelper::map($rows, 'id', 'name', 'class');         // с группировкой

// Сортировка и проверки
ArrayHelper::multisort($data, ['age', 'name'], [SORT_ASC, SORT_DESC]);
ArrayHelper::isIndexed($array);  ArrayHelper::isAssociative($array);
ArrayHelper::isIn('a', $traversable);  ArrayHelper::isSubset($a, $b);

// Прочее
ArrayHelper::merge($a, $b, $c);                         // рекурсивное слияние
ArrayHelper::htmlEncode($data);  ArrayHelper::htmlDecode($data);
ArrayHelper::flatten($nested, '.');                     // ['a.b.c' => 1]
ArrayHelper::filter($array, ['A', '!A.B']);             // выборка по путям
ArrayHelper::toArray($posts, [
    Post::class => ['id', 'title', 'createTime' => 'created_at',
                    'length' => fn ($post) => strlen($post->content)],
]);

use yii\helpers\Html;

Html::encode($text);  Html::decode($html);
Html::tag('p', Html::encode($name), ['class' => 'username']);
Html::beginTag('div', $options) . Html::endTag('div');

// CSS-классы и стили в массиве опций
Html::addCssClass($options, ['btn-success', 'btn-lg']);      // без дублей
Html::removeCssClass($options, 'btn-default');
Html::addCssStyle($options, ['height' => '200px']);
Html::removeCssStyle($options, ['width', 'height']);
Html::cssStyleFromArray($styles);  Html::cssStyleToArray($style);

// Ссылки, письма, картинки, списки
Html::a('Профиль', ['user/view', 'id' => $id], ['class' => 'link']);
Html::mailto('Написать', 'admin@example.com');
Html::img('@web/images/logo.png', ['alt' => 'Логотип']);
Html::ul($items, ['item' => fn ($item, $i) => Html::tag('li', $item)]);
Html::ol($items);

// Стили и скрипты
Html::style('.danger { color: #f00 }', ['media' => 'print']);
Html::script('alert(1);');
Html::cssFile('@web/css/print.css', ['media' => 'print']);
Html::jsFile('@web/js/main.js');
Html::csrfMetaTags();

// Формы
Html::beginForm(['order/update', 'id' => $id], 'post', ['enctype' => 'multipart/form-data']);
Html::endForm();
Html::submitButton('Отправить');  Html::button('Кнопка');  Html::resetButton('Сброс');

// Поля ввода: обычные и «active» (значение берётся из модели)
Html::textInput('username', $value, $options);
Html::activeTextInput($model, 'username', $options);
Html::activeHiddenInput($model, 'version');
Html::activePasswordInput($model, 'password');
Html::activeFileInput($model, 'file');
Html::activeTextarea($model, 'about');
Html::activeCheckbox($model, 'agree');   Html::activeRadio($model, 'type');
Html::activeDropDownList($model, 'id', ArrayHelper::map($rows, 'id', 'name'));
Html::activeListBox($model, 'ids', $items);
Html::activeCheckboxList($model, 'roles', $items);
Html::activeRadioList($model, 'role', $items);

// Метки, ошибки, служебные имена
Html::activeLabel($model, 'username');
Html::errorSummary($models, ['class' => 'errors']);
Html::error($model, 'title');
Html::getInputName($model, 'title');    // Post[title]
Html::getInputId($model, 'title');      // post-title
Html::getAttributeValue($model, '[0]authors[0]');
Html::getAttributeName('dates[0]');     // dates

use yii\helpers\HtmlPurifier;
echo HtmlPurifier::process($userHtml);              // очистка HTML от XSS (медленно — кешируйте)

use yii\helpers\Url;

Url::home();  Url::home(true);  Url::home('https');
Url::base();  Url::base(true);
Url::toRoute('site/index');
Url::toRoute(['post/view', 'id' => 42, '#' => 'comments']);
Url::to(['post/index', 'page' => 2]);
Url::to('@web/images/logo.gif', true);
Url::to();                                   // текущий URL
Url::current(['page' => 2]);                 // текущий маршрут + изменённые GET-параметры
Url::current(['src' => null]);               // удалить параметр
Url::canonical();
Url::remember();  Url::previous();
Url::remember(['product/view', 'id' => 42], 'product');  Url::previous('product');
Url::isRelative('test/it');

use yii\helpers\Json;

Json::encode($data);                        // JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE
Json::encode($data, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
Json::htmlEncode($data);                    // безопасно для вставки в HTML/JS
Json::decode($json);                        // в массив
Json::$prettyPrint = YII_DEBUG;             // глобально

Json::encode(['fn' => new \yii\web\JsExpression('function () { return 1; }')]);  // JS-выражение не экранируется

use yii\helpers\StringHelper;

StringHelper::byteLength($str);  StringHelper::byteSubstr($str, 0, 10);
StringHelper::truncate($str, 30, '…');
StringHelper::truncateWords($str, 10);
StringHelper::startsWith($str, 'Yii');  StringHelper::endsWith($str, '.php');
StringHelper::basename('app\models\Post');       // Post — удобно для имени класса
StringHelper::dirname($path);
StringHelper::explode('a, b, c', ',', true, true);
StringHelper::countWords($str);
StringHelper::normalizeNumber('4.2');
StringHelper::base64UrlEncode($str);  StringHelper::base64UrlDecode($str);
StringHelper::matchWildcard('*.example.com', $host);
StringHelper::mb_ucfirst($str);  StringHelper::mb_ucwords($str);

use yii\helpers\FileHelper;

FileHelper::createDirectory('@runtime/export', 0775, true);
FileHelper::copyDirectory($src, $dst, ['only' => ['*.php'], 'except' => ['.svn/']]);
FileHelper::removeDirectory($dir);
FileHelper::findFiles('@app/views', ['only' => ['*.php'], 'recursive' => true]);
FileHelper::findDirectories($dir);
FileHelper::getMimeType('/path/file.pdf');
FileHelper::getExtensionsByMimeType('image/jpeg');
FileHelper::normalizePath($path);
FileHelper::localize('@app/views/site/index.php');   // версия под текущий язык

use yii\helpers\Inflector;

Inflector::pluralize('box');          // boxes
Inflector::singularize('boxes');      // box
Inflector::camelize('post_comment');  // PostComment
Inflector::camel2words('PostComment');// Post Comment
Inflector::camel2id('PostComment');   // post-comment
Inflector::id2camel('post-comment');  // PostComment
Inflector::underscore('PostComment'); // post_comment
Inflector::slug('Привет, мир!', '-'); // privet-mir (нужен intl для транслитерации)
Inflector::titleize($str);
Inflector::ordinalize(21);            // 21st
Inflector::sentence(['a', 'b', 'c']); // a, b and c

use yii\helpers\{VarDumper, Markdown, FormatConverter, IpHelper, Console};

VarDumper::dump($var, 10, true);              // безопасный var_dump с подсветкой
VarDumper::export($var);                      // валидный PHP-код
echo Markdown::process($text, 'gfm');         // Markdown → HTML
FormatConverter::convertDateIcuToPhp('yyyy-MM-dd');
IpHelper::inRange('192.168.1.5', '192.168.0.0/16');
Console::stdout(Console::ansiFormat('OK', [Console::FG_GREEN]));

composer require --dev codeception/codeception codeception/module-yii2 codeception/module-asserts
vendor/bin/codecept run
vendor/bin/codecept run unit
vendor/bin/codecept run functional

namespace app\tests\fixtures;

class UserFixture extends \yii\test\ActiveFixture
{
    public $modelClass = 'app\models\User';       // либо $tableName
}

class UserProfileFixture extends \yii\test\ActiveFixture
{
    public $modelClass = 'app\models\UserProfile';
    public $depends = [UserFixture::class];       // загрузится ПОСЛЕ UserFixture
}

return [
    'user1' => ['username' => 'lmayert', 'email' => 'a@example.com', 'auth_key' => '...'],
    'user2' => ['username' => 'napoleon69', 'email' => 'b@example.com', 'auth_key' => '...'],
];

public function fixtures()          // или globalFixtures() для общих
{
    return ['profiles' => UserProfileFixture::class];
}

$row = $this->profiles['user1'];    // строка данных
$model = $this->profiles('user1');  // AR-модель

yii fixture/load User
yii fixture "User, UserProfile"
yii fixture/load "*"
yii fixture "*, -DoNotLoadThisOne"
yii fixture/unload "*"
yii fixture User --namespace='app\tests\fixtures'

// узкие места ищем профайлером
Yii::beginProfile('heavy-block');
// ...
Yii::endProfile('heavy-block');

// web/index.php на продакшене
defined('YII_DEBUG') or define('YII_DEBUG', false);
defined('YII_ENV') or define('YII_ENV', 'prod');

'components' => [
    'request' => ['csrfParam' => '_backendCSRF', 'csrfCookie' => ['path' => '/admin']],
    'user' => ['identityCookie' => ['name' => '_backendIdentity', 'path' => '/admin']],
    'session' => ['name' => 'BACKENDSESSID', 'cookieParams' => ['path' => '/admin']],
],

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

{
    "require": { "yiisoft/yii2": "~2.0.0" },
    "repositories": [{ "type": "composer", "url": "https://asset-packagist.org" }]
}

// config.php
return [
    'id' => 'micro-app',
    'basePath' => __DIR__,
    'controllerNamespace' => 'micro\controllers',
    'aliases' => ['@micro' => __DIR__],
    'components' => [
        'db' => ['class' => 'yii\db\Connection', 'dsn' => 'sqlite:@micro/database.sqlite'],
    ],
];

// web/index.php
require __DIR__ . '/../vendor/autoload.php';
require __DIR__ . '/../vendor/yiisoft/yii2/Yii.php';
(new yii\web\Application(require __DIR__ . '/../config.php'))->run();

vendor/bin/yii serve --docroot=./web
vendor/bin/yii migrate/create --appconfig=config.php create_post_table --fields="title:string,body:text"

// библиотека без автозагрузчика, но с PSR-4
'aliases' => ['@xyz' => '@vendor/foo/bar'],

// совсем legacy — карта классов
Yii::$classMap['Class1'] = 'path/to/Class1.php';

require __DIR__ . '/../vendor/yiisoft/yii2/Yii.php';
new yii\web\Application(require __DIR__ . '/../config/yii/web.php');  // без run()

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

Yii::$app->request        // GET/POST, заголовки, куки, IP
Yii::$app->response       // код, заголовки, формат, файлы, редиректы
Yii::$app->db             // соединение с БД
Yii::$app->user           // identity, id, isGuest, login(), logout(), can()
Yii::$app->session        // сессия, flash-сообщения
Yii::$app->cache          // кеш
Yii::$app->urlManager     // разбор/создание URL
Yii::$app->view           // рендеринг, registerJs/registerCss
Yii::$app->assetManager   // публикация ресурсов
Yii::$app->formatter      // даты, числа, размеры
Yii::$app->i18n           // переводы
Yii::$app->mailer         // почта
Yii::$app->security       // хеши, шифрование, случайные строки
Yii::$app->authManager    // RBAC
Yii::$app->errorHandler   // текущее исключение
Yii::$app->log            // цели логов
Yii::$app->params['key']  // свои параметры
Yii::$app->language       // текущий язык
Yii::$app->controller     // текущий контроллер (и ->action, ->module)
Yii::$app->getModule('admin')
Yii::$container           // DI-контейнер

Yii::getAlias('@app/runtime');       Yii::setAlias('@img', '@webroot/img');
Yii::createObject($config);          Yii::configure($object, $config);
Yii::t('app', 'Сообщение', $params);
Yii::debug($msg, __METHOD__);  Yii::info();  Yii::warning();  Yii::error();
Yii::beginProfile('x');  Yii::endProfile('x');
Yii::$classMap['Foo'] = '@app/Foo.php';
Yii::getVersion();

// данные запроса
$id = Yii::$app->request->get('id');
$data = Yii::$app->request->post();
$isAjax = Yii::$app->request->isAjax;

// ответы
return $this->render('view', ['model' => $model]);
return $this->renderAjax('_form', ['model' => $model]);
return $this->redirect(['view', 'id' => $model->id]);
return $this->goBack();  return $this->goHome();  return $this->refresh();
return $this->asJson(['ok' => true]);
Yii::$app->response->format = Response::FORMAT_JSON;  return $data;

// flash + сохранение
if ($model->load(Yii::$app->request->post()) && $model->save()) {
    Yii::$app->session->setFlash('success', 'Сохранено');
    return $this->redirect(['index']);
}

// ошибки
throw new \yii\web\NotFoundHttpException('Не найдено');
throw new \yii\web\ForbiddenHttpException('Нет прав');

// типовой findModel
protected function findModel($id)
{
    if (($model = Post::findOne(['id' => $id])) !== null) {
        return $model;
    }
    throw new \yii\web\NotFoundHttpException('Запись не найдена.');
}

Post::findOne($id);                         Post::findOne(['slug' => $slug]);
Post::findAll(['status' => 1]);
Post::find()->where(['status' => 1])->andWhere(['>', 'created_at', $ts])
    ->orderBy(['created_at' => SORT_DESC])->limit(10)->all();
Post::find()->with('author', 'tags')->all();          // жадная загрузка
Post::find()->joinWith('author')->where(['user.status' => 1])->all();
Post::find()->count();  Post::find()->exists();  Post::find()->asArray()->all();
Post::find()->select(['status', 'cnt' => 'COUNT(*)'])->groupBy('status')->all();

$post = new Post(['title' => 'X']);  $post->save();
$post->updateAttributes(['views' => 1]);              // без валидации и событий
$post->updateCounters(['views' => 1]);
Post::updateAll(['status' => 0], ['<', 'created_at', $ts]);
$post->delete();  Post::deleteAll(['status' => 0]);
$post->link('tags', $tag);  $post->unlink('tags', $tag, true);

php yii                                  # список команд
php yii serve --port=8080                # встроенный сервер
php yii migrate                          # применить миграции
php yii migrate/create create_post_table --fields="title:string,body:text"
php yii migrate/down 1                   # откатить
php yii cache/flush-all                  # сбросить кеши
php yii cache/flush-schema db            # сбросить кеш схемы
php yii asset assets.php config/assets-prod.php
php yii message config/i18n.php          # извлечь строки для перевода
php yii fixture/load "*"
php yii gii/model --tableName=post --modelClass=Post
php yii help <команда>

return [
    'id' => 'app',
    'basePath' => dirname(__DIR__),
    'language' => 'ru-RU',
    'timeZone' => 'UTC',
    'bootstrap' => ['log'],
    'components' => [
        'request' => [
            'cookieValidationKey' => getenv('COOKIE_KEY'),
            'parsers' => ['application/json' => 'yii\web\JsonParser'],
        ],
        'db' => [
            'class' => 'yii\db\Connection',
            'dsn' => getenv('DB_DSN'),
            'username' => getenv('DB_USER'),
            'password' => getenv('DB_PASS'),
            'charset' => 'utf8mb4',
            'enableSchemaCache' => !YII_DEBUG,
        ],
        'cache' => ['class' => 'yii\caching\FileCache'],
        'user' => ['identityClass' => 'app\models\User', 'enableAutoLogin' => true],
        'session' => ['class' => 'yii\web\DbSession'],
        'errorHandler' => ['errorAction' => 'site/error'],
        'urlManager' => [
            'enablePrettyUrl' => true,
            'showScriptName' => false,
            'rules' => [],
        ],
        'log' => [
            'traceLevel' => YII_DEBUG ? 3 : 0,
            'targets' => [['class' => 'yii\log\FileTarget', 'levels' => ['error', 'warning']]],
        ],
    ],
    'params' => require __DIR__ . '/params.php',
];

basic/
  commands/        консольные команды
  config/          web.php, console.php, db.php, params.php
  controllers/     контроллеры
  mail/            представления писем
  migrations/      миграции
  models/          модели, формы, AR
  runtime/         логи, кеш (на запись)
  tests/           тесты
  vendor/          зависимости Composer
  views/           представления + layouts/
  web/             ПУБЛИЧНЫЙ корень: index.php, assets/, css/, js/
  yii              консольная точка входа