Qiang Xue
10 years ago
92 changed files with 1695 additions and 1164 deletions
@ -0,0 +1,71 @@
|
||||
Localizador de Servicios |
||||
======================== |
||||
|
||||
Un localizador de servicios es un objeto que sabe cómo proporcionar todo tipo de servicios (o componentes) que puede necesitar una aplicación. Dentro de un localizador de servicios, existe en cada componente como una única instancia, únicamente identificado por un ID. Se utiliza el ID para recuperar un componente desde el localizador de servicios. |
||||
|
||||
En Yii, un localizador de servicio es simplemente una instancia de [[yii\di\ServiceLocator]], o de una clase hija. |
||||
|
||||
El localizador de servicio más utilizado en Yii es el objeto *aplicación*, que se puede acceder a través de `\Yii::$app`. Los servicios que prestá son llamadas *componentes de la aplicación*, como los componentes `request`, `response`, and `urlManager`. Usted puede configurar estos componentes, o incluso cambiarlos por sus propias implementaciones fácilmente a través de la funcionalidad proporcionada por el localizador de servicios. |
||||
|
||||
Además del objeto de aplicación, cada objeto módulo es también un localizador de servicios. |
||||
|
||||
Para utilizar un localizador de servicios, el primer paso es registrar los componentes de la misma. Un componente se puede registrar a través de [[yii\di\ServiceLocator::set()]]. El código siguiente muestra diferentes maneras de registrarse componentes: |
||||
|
||||
```php |
||||
use yii\di\ServiceLocator; |
||||
use yii\caching\FileCache; |
||||
|
||||
$locator = new ServiceLocator; |
||||
|
||||
// register "cache" using a class name that can be used to create a component |
||||
$locator->set('cache', 'yii\caching\ApcCache'); |
||||
|
||||
// register "db" using a configuration array that can be used to create a component |
||||
$locator->set('db', [ |
||||
'class' => 'yii\db\Connection', |
||||
'dsn' => 'mysql:host=localhost;dbname=demo', |
||||
'username' => 'root', |
||||
'password' => '', |
||||
]); |
||||
|
||||
// register "search" using an anonymous function that builds a component |
||||
$locator->set('search', function () { |
||||
return new app\components\SolrService; |
||||
}); |
||||
|
||||
// register "pageCache" using a component |
||||
$locator->set('pageCache', new FileCache); |
||||
``` |
||||
|
||||
Una vez que el componente se ha registrado, usted puede acceder a él utilizando su ID, en una de las dos formas siguientes: |
||||
|
||||
```php |
||||
$cache = $locator->get('cache'); |
||||
// or alternatively |
||||
$cache = $locator->cache; |
||||
``` |
||||
|
||||
Como puede observarse, [[yii\di\ServiceLocator]] le permite acceder a un componente como una propiedad utilizando el ID de componente. Cuando acceda a un componente, por primera vez, [[yii\di\ServiceLocator]] utilizará la información de registro de componente para crear una nueva instancia del componente y devolverlo. Más tarde, si se accede de nuevo al componente, el localizador de servicio devolverá la misma instancia. |
||||
|
||||
Usted puede utilizar [[yii\di\ServiceLocator::has()]] para comprobar si un ID de componente ya ha sido registrada. |
||||
Si llama [[yii\di\ServiceLocator::get()]] con una identificación válida, se produce una excepción. |
||||
|
||||
Debido a que los localizadores de servicios a menudo se crean con [configuraciones](concept-configurations.md), se proporciona una propiedad que puede escribir el nombre [[yii\di\ServiceLocator::setComponents()|components]]. Esto le permite configurar y registrar varios componentes a la vez. El siguiente código muestra un arreglo de configuración que se puede utilizar para configurar una aplicación, al mismo tiempo que el registro de la "db", "cache" y "buscar" componentes: |
||||
|
||||
```php |
||||
return [ |
||||
// ... |
||||
'components' => [ |
||||
'db' => [ |
||||
'class' => 'yii\db\Connection', |
||||
'dsn' => 'mysql:host=localhost;dbname=demo', |
||||
'username' => 'root', |
||||
'password' => '', |
||||
], |
||||
'cache' => 'yii\caching\ApcCache', |
||||
'search' => function () { |
||||
return new app\components\SolrService; |
||||
}, |
||||
], |
||||
]; |
||||
``` |
||||
|
Before Width: | Height: | Size: 36 KiB After Width: | Height: | Size: 39 KiB |
|
Before Width: | Height: | Size: 16 KiB After Width: | Height: | Size: 15 KiB |
@ -0,0 +1,24 @@
|
||||
Bootstrapping |
||||
============= |
||||
|
||||
El Bootstrapping hace referencia al proceso de preparar el entorno antes de que una aplicación se inicie para resolver y procesar una petición entrante. El se ejecuta en dos lugares: el [script de entrada](structure-entry-scripts.md) y la [aplicación](structure-applications.md). |
||||
|
||||
En el [script de entrada](structure-entry-scripts.md), se registran los cargadores automáticos de clase para diferentes librerías. Esto incluye el cargador automático de Composer a través de su fichero ‘autoload.php’ y del cargador automático de Yii a través del fichero de clase ‘Yii’. El script de entrada después carga la [configuración](concept-configurations.md) de la aplicación y crea una instancia de la [aplicación](structure-applications.md). |
||||
|
||||
El constructor de la aplicación, ejecuta el siguiente trabajo de bootstrapping: |
||||
|
||||
Llama a [[yii\base\Application::preInit()|preInit()]], que configura algunas propiedades de alta prioridad de la aplicación, como [[yii\base\Application::basePath|basePath]]. |
||||
Registra el [[yii\base\Application::errorHandler|error handler]]. |
||||
Inicializa las propiedades de aplicación usando la configuración de la aplicación dada. |
||||
Llama a [[yii\base\Application::init()|init()]] que a su vez llama a [[yii\base\Application::bootstrap()|bootstrap()]] para ejecutar componentes de bootstrapping. |
||||
Incluye el archivo de manifiesto de extensiones ‘vendor/yiisoft/extensions.php’ |
||||
Crea y ejecuta [compoentenes de bootstrap](structure-extensions.md#bootstrapping-classes) declarados por las extensiones. |
||||
Crea y ejecuta [componentes de aplicación](structure-application-components.md) y/o [módulos](structure-modules.md) que se declaran en la [propiedad bootstrap](structure-applications.md#bootstrap) de la aplicación. |
||||
|
||||
Debido a que el trabajo de bootstrapping se tiene que ejecutar antes de gestionar *todas* las peticiones, es muy importante mantener este proceso ligero y optimizado lo máximo que sea posible. |
||||
|
||||
Intenta no registrar demasiados componentes de bootstrapping. Un componente de bootstrapping sólo es necesario si tiene que interaccionar en todo el ciclo de vida de la gestión de la petición. Por ejemplo, si un modulo necesita registrar reglas de análisis de URL adicionales, se debe incluirse en la [propiedad bootstrap](structure-applications.md#bootstrap) para que la nueva regla de URL tenga efecto antes de que sea utilizada para resolver peticiones. |
||||
|
||||
En modo de producción, hay que habilitar la cache bytecode, así como [APC](http://php.net/manual/es/book.apc.php), para minimizar el tiempo necesario para incluir y analizar archivos PHP. |
||||
|
||||
Algunas grandes aplicaciones tienen [configuraciones](concept-configurations.md) de aplicación muy complejas que están dividida en muchos archivos de configuración más pequeños. |
||||
@ -1,22 +1,22 @@
|
||||
Información General |
||||
Información General |
||||
=============== |
||||
|
||||
Cada vez que una aplicación Yii gestiona una petición, se somete a una flujo de trabajo similar. |
||||
Cada vez que una aplicación Yii gestiona una petición, se somete a un flujo de trabajo similar. |
||||
|
||||
1. Un usuario hace una petición al [script de entrada](structure-entry-scripts.md) ‘web/index.php’. |
||||
2. El script de entrada carga la [configuración](concept-configurations.md) y crea una instancia de la [aplicación](structure-applications.md) para gestionar la petición. |
||||
3. La aplicación resuelve la [ruta](runtime-routing.md) solicitada con la ayuda del componente [petición](runtime-requests.md) de la aplicación. |
||||
4. La aplicación crea una instancia del [controlador](structure-controllers.md) para gestionar la petición. |
||||
5. El controlador crea una instancia de la [acción](structure-controllers.md) y ejecuta los filtros para la acción. |
||||
6. Si algun filtro falla, se cancela la acción. |
||||
6. Si algún filtro falla, se cancela la acción. |
||||
7. Si pasa todos los filtros, se ejecuta la acción. |
||||
8. La acción carga un modelo de datos, posiblemente de la base de datos. |
||||
9. La acción interpreta una vista, proporcionandole el modelo de datos. |
||||
10. El resultado interpretado se devuelve al componente [respuesta](runtime-responses.md) de la aplicación. |
||||
11. El componente respuesta envía el resultado interpretado al navegador del usuario. |
||||
9. La acción renderiza una vista, proporcionándole el modelo de datos. |
||||
10. El resultado renderizado se devuelve al componente [respuesta](runtime-responses.md) de la aplicación. |
||||
11. El componente respuesta envía el resultado renderizado al navegador del usuario. |
||||
|
||||
El siguiente diagrama muestra como una aplicación gestiona una petición. |
||||
|
||||
 |
||||
|
||||
En esta sección, se describirá en detalle cómo funcionan algunos de estos pasos. |
||||
En esta sección, se describirá en detalle cómo funcionan algunos de estos pasos. |
||||
|
||||
@ -0,0 +1,108 @@
|
||||
Peticiones |
||||
======== |
||||
Las peticiones(requests) hechas a una aplicación son representadas como objetos [[yii\web\Request]] que proporcionan información como parámetros de la petición, cabeceras HTTP, cookies, etc. Dada una petición, se puede acceder al objeto request correspondiente a través del [componente de aplicación](structure-application-components.md) 'request' que, por defecto, es una instancia de [[yii\web\Request]]. En esta sección se describirá como hacer uso de este componente en las aplicaciones. |
||||
|
||||
## Parámetros de Request <a name="request-parameters"></a> |
||||
|
||||
Para obtener los parámetros de la petición, se puede llamar a los métodos [[yii\web\Request::get()|get()]] y [[yii\web\Request::post()|post()]] del componente 'request'. Estos devuelven los valores de '$_GET' y '$_POST', respectivamente. Por ejemplo: |
||||
|
||||
```php |
||||
$request = Yii::$app->request; |
||||
|
||||
$get = $request->get(); |
||||
// equivalente a: $get = $_GET; |
||||
|
||||
$id = $request->get('id'); |
||||
// equivalente a: $id = isset($_GET['id']) ? $_GET['id'] : null; |
||||
|
||||
$id = $request->get('id', 1); |
||||
// equivalente a: $id = isset($_GET['id']) ? $_GET['id'] : 1; |
||||
|
||||
$post = $request->post(); |
||||
// equivalente a: $post = $_POST; |
||||
|
||||
$name = $request->post('name'); |
||||
// equivalente a: $name = isset($_POST['name']) ? $_POST['name'] : null; |
||||
|
||||
$name = $request->post('name', ''); |
||||
// equivalente a: $name = isset($_POST['name']) ? $_POST['name'] : ''; |
||||
``` |
||||
|
||||
>Info: En lugar de acceder directamente a '$_GET' y '$_POST' para obtener los parámetros de la petición, es recomendable que se obtengan mediante el componente 'request' como en el ejemplo anterior. Esto facilitará la creación de tests ya que se puede simular una componente de request con datos de peticiones personalizados. |
||||
|
||||
Cuando se implementan [APIs RESTful](rest-quick-start.md), a menudo se necesita obtener parámetros enviados desde el formulario a través de PUT, PATCH u otros [métodos de request](runtime-requests.md#request-methods). Se pueden obtener estos parámetros llamando a los métodos [[yii\web\Request::getBodyParam()]]. Por ejemplo: |
||||
|
||||
```php |
||||
$request = Yii::$app->request; |
||||
|
||||
// devuelve todos los parámetros |
||||
$params = $request->bodyParams; |
||||
|
||||
// devuelve el parámetro "id" |
||||
$param = $request->getBodyParam('id'); |
||||
``` |
||||
|
||||
>Info: A diferencia de los parámetros 'GET', los parámetros enviados desde el formulario a través de 'POST', 'PUT', 'PATCH', etc. se envían en el cuerpo de la petición. El componente 'request' convierte los parámetros cuando se acceda a él a través de los métodos descritos anteriormente. Se puede personalizar la manera en como los parámetros se convierten configurando la propiedad [[yii\web\Request::parsers]]. |
||||
|
||||
## Métodos de Request <a name="request-methods"></a> |
||||
|
||||
Se puede obtener el método HTTP usado por la petición actual a través de la expresión 'Yii::$app->request->method'. Se proporcionan un conjunto de propiedades booleanas para comprobar si el método actual es de un cierto tipo. Por ejemplo: |
||||
|
||||
```php |
||||
$request = Yii::$app->request; |
||||
|
||||
if ($request->isAjax) { // la request una request AJAX } |
||||
if ($request->isGet) { // el método de la request es GET } |
||||
if ($request->isPost) { // el método de la request es POST } |
||||
if ($request->isPut) { // el método de la request es PUT } |
||||
``` |
||||
|
||||
## URLs de Request <a name="request-urls"></a> |
||||
|
||||
El componente 'request' proporciona muchas maneras de inspeccionar la URL solicitada actualmente. |
||||
|
||||
Asumiendo que la URL que se está solicitando es 'http://example.com/admin/index.php/product?id=100', se pueden obtener varias partes de la URL explicadas en los siguientes puntos: |
||||
|
||||
* [[yii\web\Request::url|url]]: devuelve `/admin/index.php/product?id=100`, que es la URL sin la parte de información del host. |
||||
* [[yii\web\Request::absoluteUrl|absoluteUrl]]: devuelve `http://example.com/admin/index.php/product?id=100`, que es la URL entera, incluyendo la parte de información del host. |
||||
* [[yii\web\Request::hostInfo|hostInfo]]: devuelve `http://example.com`, que es la parte de información del host dentro de la URL. |
||||
* [[yii\web\Request::pathInfo|pathInfo]]: devuelve `/product`, que es la parte posterior al script de entrada y anterior al interrogante (query string) |
||||
* [[yii\web\Request::queryString|queryString]]: devuelve `id=100`, que es la parte posterior al interrogante. |
||||
* [[yii\web\Request::baseUrl|baseUrl]]: devuelve `/admin`, que es la parte posterior a la información del host y anterior al nombre de script de entrada. |
||||
* [[yii\web\Request::scriptUrl|scriptUrl]]: devuelve `/admin/index.php`, que es la URL sin la información del la ruta ni la query string. |
||||
* [[yii\web\Request::serverName|serverName]]: devuelve `example.com`, que es el nombre del host dentro de la URL. |
||||
* [[yii\web\Request::serverPort|serverPort]]: devuelve 80, que es el puerto que usa el servidor web. |
||||
|
||||
## Cabeceras HTTP <a name="http-headers"></a> |
||||
|
||||
Se pueden obtener la información de las cabeceras HTTP a través de [[yii\web\HeaderCollection|header collection]] devueltas por la propiedad [[yii\web\Request::headers]]. Por ejemplo: |
||||
|
||||
```php |
||||
// $headers es un objeto de yii\web\HeaderCollection |
||||
$headers = Yii::$app->request->headers; |
||||
|
||||
// devuelve el valor Accept de la cabecera |
||||
$accept = $headers->get('Accept'); |
||||
|
||||
if ($headers->has('User-Agent')) { // la cabecera contiene un User-Agent } |
||||
``` |
||||
|
||||
El componente 'request' también proporciona soporte para acceder rápidamente a las cabeceras usadas más comúnmente, incluyendo: |
||||
|
||||
* [[yii\web\Request::userAgent|userAgent]]: devuelve el valor de la cabecera 'User-Agen'. |
||||
* [[yii\web\Request::contentType|contentType]]: devuelve el valor de la cabecera `Content-Type` que indica el tipo MIME de los datos del cuerpo de la petición. |
||||
* [[yii\web\Request::acceptableContentTypes|acceptableContentTypes]]: devuelve los tipos de contenido MIME aceptado por los usuarios, ordenados por puntuación de calidad. Los que tienen mejor puntuación, se devolverán primero. |
||||
* [[yii\web\Request::acceptableLanguages|acceptableLanguages]]: devuelve los idiomas aceptados por el usuario. Los idiomas devueltos son ordenados según su orden de preferencia. El primer elemento representa el idioma preferido. |
||||
|
||||
Si la aplicación soporta múltiples idiomas y se quiere mostrar las páginas en el idioma preferido por el usuario, se puede usar el método de negociación de idioma [[yii\web\Request::getPreferredLanguage()]]. Este método obtiene una lista de idiomas soportados por la aplicación, comparados con [[yii\web\Request::acceptableLanguages|acceptableLanguages]], y devuelve el idioma más apropiado. |
||||
|
||||
>Consejo: También se puede usar el filtro [[yii\filters\ContentNegotiator|ContentNegotiator]] para determinar diatónicamente el content type y el idioma que debe usarse en la respuesta. El filtro implementa la negociación de contenido en la parte superior de las propiedades y métodos descritos anteriormente. |
||||
|
||||
## Información del cliente <a name="client-information"></a> |
||||
|
||||
Se puede obtener el nombre del host y la dirección IP de la máquina cliente a través de [[yii\web\Request::userHost|userHost]] y [[yii\web\Request::userIP|userIP]], respectivamente. Por ejemplo: |
||||
|
||||
```php |
||||
$userHost = Yii::$app->request->userHost; |
||||
$userIP = Yii::$app->request->userIP; |
||||
``` |
||||
@ -0,0 +1,51 @@
|
||||
Routing |
||||
======= |
||||
Cuando se llama al método [[yii\web\Application::run()|run()]] a través del [script de entrada](structure-entry-scripts.md), lo primero que hace es resolver la petición entrante e instanciar una [accion de controlador](structure-controllers.md) apropiada para gestionar la petición. A este proceso se le llama *routing*. |
||||
|
||||
## Resolver una Ruta <a name="resolving-route"></a> |
||||
|
||||
El primer paso el primer paso de routing es convertir la petición entrante una ruta que, tal y como se describe en la sección [Controladores](structure-controllers.md#routes), se usa para dirigirse a una acción de controlador. El método invoca al [gestor de URLs](runtime-url-handling.md) para hacer que la conversión de la petición actual funcione. |
||||
|
||||
Por defecto, si la petición entrante contiene un parámetro 'GET' llamado 'r', su valor será considerado como la ruta. Sin embargo, si la [[yii\web\UrlManager::enablePrettyUrl|pretty URL feature]] esta habilitada, se tendrá que hacer más trabajo para determinar la ruta solicitada. Para conocer más detalles, por favor refiérase a la sección [generación y conversión de URLs](runtime-url-handling.md). |
||||
|
||||
En el caso que una ruta no pueda ser determinada, el componente 'petición' lanzará una [[yii\web\NotFoundHttpException]]. |
||||
|
||||
### Ruta por defecto <a name="default-route"></a> |
||||
|
||||
Si una petición entrante no especifica una ruta, cosa que sucede habitualmente en las paginas de inicio, se usará la ruta especificada por [[yii\web\Application::defaultRoute]]. El valor por defecto de esta propiedad es 'site/index', que hace referencia a la acción 'index' del controlador 'site'. Se puede personalizar esta propiedad en la configuración de aplicación como en el siguiente ejemplo: |
||||
|
||||
```php |
||||
return [ |
||||
// ... |
||||
'defaultRoute' => 'main/index', |
||||
]; |
||||
``` |
||||
|
||||
### La ruta `catchAll` <a name="catchall-route"></a> |
||||
|
||||
A veces, queremos poner una aplicación Web en modo de mantenimiento temporalmente y mostrar la misma pagina de información para todas las peticiones. Hay varias maneras de llevar esta operación a cabo. Pero una de las maneras más simples es configurando la propiedad [[yii\web\Application::catchAll]] como en la siguiente configuración de aplicación: |
||||
|
||||
```php |
||||
return [ |
||||
// ... |
||||
'catchAll' => ['site/offline'], |
||||
]; |
||||
``` |
||||
|
||||
La propiedad 'catchAll' debe componerse de un array cuyo primer elemento especifique la ruta, y el resto de elementos(pares de nombre-valor) especifiquen los parámetros que van ligados a la acción. |
||||
|
||||
Cuando se especifica la propiedad 'catchAll', esta reemplazará cualquier otra ruta resuelta a partir de la petición entrante. Con la anterior configuración, la misma acción 'site/offline' se usará para gestionar todas las peticiones entrantes. |
||||
|
||||
## Crear una Acción <a name="creating-action"></a> |
||||
|
||||
Una vez que se determina la ruta solicitada, el siguiente paso es crear el objecto de la acción correspondiente a la ruta. |
||||
|
||||
La ruta se desglosa en múltiples partes mediante barras oblicuas '/'. Por ejemplo, 'site/index' será desglosado en 'site' y 'index'. Cada parte es un ID que puede hacer referencia a un modulo, un controlador o una acción. |
||||
|
||||
Empezando por la primera parte de la ruta, la aplicación lleva a cabo los siguientes pasos para crear módulos(si los hay), el controlador y la acción. |
||||
|
||||
1. Establece la aplicación como el modulo actual. |
||||
2. Comprueba si el [[yii\base\Module::controllerMap|controller map]] del modulo actual contiene un ID actual. Si lo tiene, se creará un objecto controlador de acuerdo con la configuración encontrada en el mapa, y ejecuta el Paso 5 con el resto de partes de la ruta. |
||||
3. Comprueba si el ID hace referencia a un modulo de la lista de la propiedad[[yii\base\Module::modules|modules]] del actual modulo. Si es así, se crea un modulo de acuerdo con la configuración encontrada en la lista del modulo, y se ejecuta el Paso 2 con la siguiente parte de la ruta dentro del contexto del modulo recién creado. |
||||
4. Trata el ID como un ID de controlador y crea un objeto controlador. Ejecuta el siguiente paso con el resto de la ruta. |
||||
5. El controlador busca el ID actual en su [[yii\base\Controller::actions()|action map]]. Si lo encuentra, crea una acción de acuerdo con la configuración encontrada en el mapa. De lo contrario, el controlador intentará crear una acción en linea que esta definida por el método de la acción correspondiente con el ID actual. |
||||
|
Before Width: | Height: | Size: 39 KiB After Width: | Height: | Size: 42 KiB |
|
Before Width: | Height: | Size: 24 KiB After Width: | Height: | Size: 26 KiB |
@ -0,0 +1,39 @@
|
||||
En savoir plus |
||||
============= |
||||
|
||||
Si vous avez entièrement lu la section "Mise en Route", vous avec maintenant créé une application Yii complète. Ce |
||||
faisant, vous avez appris comment implémenter des fonctionnalités couramment utilisées, telles que recueillir des |
||||
données d'un utilisateur via un formulaire HTML, chercher des données dans une base de données, et afficher des données |
||||
de manière paginée. Vous avez également appris à utiliser [Gii](tool-gii.md) pour générer du code automatiquement. |
||||
Utiliser Gii pour générer du code rend le gros de votre processus de développement Web aussi simple que de remplir de |
||||
simples formulaires. |
||||
|
||||
Cette section va résumer les ressources Yii disponibles pour vous aider à être plus productif dans l'utilisation du |
||||
framework. |
||||
|
||||
* Documentation |
||||
- Le Guide définitif : |
||||
Comme son nom l'indique, le guide définit précisément comment Yii fonctionne et fournit des instructions générales |
||||
sur l'utilisation de Yii. C'est le tutoriel pour Yii le plus important, un que vous devriez lire avant d'écrire le |
||||
moindre code Yii. |
||||
- La Référence de Classes : |
||||
Elle spécifie l'usage de toutes les classes fournies par Yii. Elle doit être principalement utilisée lorsque |
||||
vous utilisez du code et souhaitez comprendre l'usage d'une classe, méthode ou propriété particulière. |
||||
L'utilisation de la référence de classe est plus appropriée quand vous avez une compréhension contextuelle du |
||||
framework entier. |
||||
- Les Articles Wiki: |
||||
Les articles wiki sont écrits par des utilisateurs de Yii en fonction de leurs propres expériences. Ils sont en |
||||
général écrits comme des recettes de cuisine, et montrent comment résoudre des problèmes pratiques en utilisant |
||||
Yii. Bien que la qualité de ces articles peut être inférieure à celle du Guide Définitif, ils sont utiles du fait |
||||
qu'ils couvrent des sujets plus vastes et peuvent fournir des solutions clef-en-main. |
||||
- Livres |
||||
* [Extensions](http://www.yiiframework.com/extensions/): |
||||
Yii est fort d'une librairie de milliers d'extensions créées par les utilisateurs, qui peuvent être facilement |
||||
ajoutées à votre application, rendant son développement encore plus facile et plus rapide. |
||||
* Communauté |
||||
- Forum : <http://www.yiiframework.com/forum/> |
||||
- Chat IRC : Les canal #yii sur le réseau freenode (<irc://irc.freenode.net/yii>) |
||||
- GitHub : <https://github.com/yiisoft/yii2> |
||||
- Facebook : <https://www.facebook.com/groups/yiitalk/> |
||||
- Twitter : <https://twitter.com/yiiframework> |
||||
- LinkedIn : <https://www.linkedin.com/groups/yii-framework-1483367> |
||||
@ -0,0 +1,117 @@
|
||||
Scripts d'entrée |
||||
============= |
||||
|
||||
Les scripts d'entrée sont la première chaîne dans le processus de d'amorçage de l'application. Une application (qu'elle |
||||
soit une application Web ou une application console) a un unique script de démarrage. Les utilisateurs font des |
||||
requêtes au scripts de démarrage qui instancient des instances d'application et leur transmettent les requêtes. |
||||
|
||||
Les scripts d'entrée pour application Web doivent être placés dans des dossiers accessibles par le Web pour que les |
||||
utilisateurs puissent y accéder. Ils sont souvent nommés `index.php`, mais peuvent également avoir tout autre nom, |
||||
du moment que les serveurs Web peuvent les trouver. |
||||
|
||||
Les scripts d'entrée pour les applications console sont généralement placés dans le [répertoire de base](structure-applications.md) |
||||
des applications et sont nommés `yii` (avec le suffixe `.php`). Ils doivent être rendus exécutables afin que les |
||||
utilisateurs puissent lancer des applications console grâce à la commande `./yii <route> [arguments] [options]`. |
||||
|
||||
Les scipts de démarrage effectuent principalement les tâches suivantes : |
||||
|
||||
* Définir des constantes globales; |
||||
* Enregistrer l'[autoloader Composer](http://getcomposer.org/doc/01-basic-usage.md#autoloading); |
||||
* Inclure le fichier de classe de [[Yii]]; |
||||
* Charger la configuration de l'application; |
||||
* Créer et configurer une instance d'[application](structure-applications.md); |
||||
* Appeler [[yii\base\Application::run()]] pour traiter la requête entrante. |
||||
|
||||
|
||||
## Applications Web <a name="web-applications"></a> |
||||
|
||||
Ce qui suit est le code du script de démarrage du [Modèle Basique d'Application Web](start-installation.md). |
||||
|
||||
```php |
||||
<?php |
||||
|
||||
defined('YII_DEBUG') or define('YII_DEBUG', true); |
||||
defined('YII_ENV') or define('YII_ENV', 'dev'); |
||||
|
||||
// register Composer autoloader |
||||
require(__DIR__ . '/../vendor/autoload.php'); |
||||
|
||||
// include Yii class file |
||||
require(__DIR__ . '/../vendor/yiisoft/yii2/Yii.php'); |
||||
|
||||
// load application configuration |
||||
$config = require(__DIR__ . '/../config/web.php'); |
||||
|
||||
// create, configure and run application |
||||
(new yii\web\Application($config))->run(); |
||||
``` |
||||
|
||||
|
||||
## Applications Console <a name="console-applications"></a> |
||||
|
||||
De même, le code qui suit est le code du script de démarrage d'une application console : |
||||
|
||||
```php |
||||
#!/usr/bin/env php |
||||
<?php |
||||
/** |
||||
* Yii console bootstrap file. |
||||
* |
||||
* @link http://www.yiiframework.com/ |
||||
* @copyright Copyright (c) 2008 Yii Software LLC |
||||
* @license http://www.yiiframework.com/license/ |
||||
*/ |
||||
|
||||
defined('YII_DEBUG') or define('YII_DEBUG', true); |
||||
|
||||
// fcgi doesn't have STDIN and STDOUT defined by default |
||||
defined('STDIN') or define('STDIN', fopen('php://stdin', 'r')); |
||||
defined('STDOUT') or define('STDOUT', fopen('php://stdout', 'w')); |
||||
|
||||
// register Composer autoloader |
||||
require(__DIR__ . '/vendor/autoload.php'); |
||||
|
||||
// include Yii class file |
||||
require(__DIR__ . '/vendor/yiisoft/yii2/Yii.php'); |
||||
|
||||
// load application configuration |
||||
$config = require(__DIR__ . '/config/console.php'); |
||||
|
||||
$application = new yii\console\Application($config); |
||||
$exitCode = $application->run(); |
||||
exit($exitCode); |
||||
``` |
||||
|
||||
|
||||
## Définir des Constantes <a name="defining-constants"></a> |
||||
|
||||
Les scripts de démarrage sont l'endroit idéal pour définir des constantes globales. Yii supporte les trois constantes suivantes : |
||||
|
||||
* `YII_DEBUG` : spécifie si une application tourne en mode de débogage. Si elle est en mode de débogage, une |
||||
application loguera plus d'informations, et révélera des piles d'appels d'erreurs détaillées si des exceptions |
||||
sont lancées. C'est pour cette raison que le mode de débogage doit être utilisé principalement pendant la phase |
||||
de développement. La valeur par défaut de `YII_DEBUG` est faux. |
||||
* `YII_ENV` : spécifie sur quel environnement l'application est en train de tourner. Cela a été décrit plus en détails |
||||
dans la section [Configurations](concept-configurations.md#environment-constants). La valeur par défaut de `YII_ENV` |
||||
est `'prod'`, ce qui signifie que l'application tourne en environnement de production. |
||||
* `YII_ENABLE_ERROR_HANDLER` : spécifie si le gestionnaire d'erreurs fourni par Yii doit être activé. La valeur par |
||||
défaut de cette constantes est vrai. |
||||
|
||||
Quand on définit une constant, on utilise souvent le code suivant : |
||||
|
||||
```php |
||||
defined('YII_DEBUG') or define('YII_DEBUG', true); |
||||
``` |
||||
|
||||
qui est l'équivalent du code suivant : |
||||
|
||||
```php |
||||
if (!defined('YII_DEBUG')) { |
||||
define('YII_DEBUG', true); |
||||
} |
||||
``` |
||||
|
||||
Clairement, le premier est plus succinct et plus aisé à comprendre. |
||||
|
||||
Les définitions de constantes doit être faite au tout début d'un script de démarrage pour qu'elles puissent prendre |
||||
effet quand d'autres fichiers PHP sont inclus. |
||||
@ -0,0 +1,27 @@
|
||||
Vue d'ensemble |
||||
======== |
||||
|
||||
Les applications Yii sont organisées suivant le patron de conception |
||||
[model-view-controller (MVC)](http://wikipedia.org/wiki/Model-view-controller). Les [Modèles](structure-models.md) |
||||
représentent les données, la logique métier et les règles; les [vues](structure-views.md) sont les représentations |
||||
visuelles des modèles, et les [contrôleurs](structure-controllers.md) prennent une entrée et la convertissent en |
||||
commandes pour les [modèles](structure-models.md) et les [vues](structure-views.md). |
||||
|
||||
En plus du MVC, les applications Yii ont les entités suivantes : |
||||
|
||||
* [scripts de démarrage](structure-entry-scripts.md): ce sont des scripts PHP qui sont directement accessibles aux |
||||
utilisateurs. Ils sont responsables du démarrage d'un cycle de gestion de requête. |
||||
* [applications](structure-applications.md): ce sont des objets globalement accessibles qui gèrent les composants |
||||
d'application et les coordonnent pour satisfaire des requêtes. |
||||
* [composants d'application](structure-application-components.md): ce sont des objets enregistrés avec des applications et |
||||
qui fournissent différents services pour satisfaire des requêtes. |
||||
* [modules](structure-modules.md): ce sont des paquets auto-contenus qui contiennent du MVC complet. Une application peut |
||||
être organisée en termes de multiples modules. |
||||
* [filtres](structure-filters.md): ils représentent du code qui doit être invoqué avant et après la gestion effective |
||||
de chaque requête par des contrôleurs. |
||||
* [widgets](structure-widgets.md): ce sont des objets qui peuvent être intégrés dans des [vues](structure-views.md). Ils |
||||
peuvent contenir de la logique contrôleur et peuvent être réutilisés dans différentes vues. |
||||
|
||||
Le diagramme suivant montre la structure statique d'une application : |
||||
|
||||
 |
||||
@ -0,0 +1,37 @@
|
||||
Yii nima o`zi? |
||||
============== |
||||
|
||||
Yii – bu tez ishlovchi komponentli PHP freymvork bo'lib, zamonaviy web ilovalarni tez yaratish uchun mo'ljallangan. Yii (`Yi` `[ji:]` kabi talaffuz qilinadi) so'zi xitoy tilida "oddiy va evolyutsiyalovchi" degan ma'noni anglatadi. Shuningdek Yii akronim sifatida qaralganda uning yoyilma matni **Yes It Is** tarzida qaralishi ham mumkin! |
||||
|
||||
|
||||
Yii ko'proq qanday masalalar uchun mos keladi? |
||||
---------------------------------------------- |
||||
|
||||
Yii – bu universal freymvork va uni barcha turdagi web ilovalar uchun qo'llash mumkin. Uning komponentli strukturasi va keshlashni juda zo'r qo'llab-quvvatlashi evaziga freymvork asosan portallar, forumlar, CMS, magazinlar yoki RESTful ilovalar kabi katta proyektlar uchun qo'l keladi. |
||||
|
||||
|
||||
Yii ni boshqa freymvorklar bilan solishtirish |
||||
--------------------------------------------- |
||||
|
||||
- Boshqa ko'pgina PHP freymvorklar singari Yii ham kodni tashkillashtirish uchun MVC (Model-View-Controller) modelidan foydalanadi. |
||||
- Yii faqat loyihalashtirishning ma'lum bir qolipiga ergashib dizaynni murakkablashtirmasdan sodda va elegantli kod yozish falsafasiga tayanadi. |
||||
- Yii full-stack freymvork hisoblanadi. Shuningdek o'z ichiga tekshirilgan va o'zini yaxshi ko'rsatgan relatsion va NoSQL ma'lumotlar ombori uchun yaratilgan ActiveRecord, REST API ni qo'llab quvvatlash, ko'p qatlamli keshlash kabi imkoniyatlarni oladi. |
||||
- Yii juda yaxhsi kengayishi mumkin. Siz asosiy kodni ixtiyoriy qismini almashtirishingiz yoki sozlashingiz mumkin. Kengaytirish arxitekturasiga bo'ysunib kodni boshqalar bilan ulashish yoki jamoatning kodidan foydalanish mumkin. |
||||
- Yii ning asosiy maqsadlaridan biri - ishlash tezligi. |
||||
|
||||
Yii — bir odamning loyihasi emas. U unga yordam berayotgan ishlab chiquvchilar [katta jamoa][]si tomonidan qo'llab quvvatlanadi va rivojlantiriladi. Freymvork ishlab chiquvchilari web ishlab chiqish va boshqa ilovalarni maromini kuzatishadi. Ko'proq mos keluvchi imkoniyatlar va eng yaxshi sinalgan amaliyotlar freymvork sodda va elegantli interfeysi tarzida qo'llaniladi. |
||||
|
||||
[katta jamoa]: http://www.yiiframework.com/about/ |
||||
|
||||
Yii talqinlari |
||||
-------------- |
||||
|
||||
Ayni vaqtda Yii ning ikkita yo'nalishi mavjud: 1.1 va 2.0. 1.1 yo'nalishi avvalgi avlod hisoblanadi va qo'llab quvvatlash holatida. 2.0 talqini - bu Composer, PSR, nomlar sohasi, treytlar(traits) va boshqa shular kabi ko'pgina oxirgi texnologiyalarni va *qaydnoma*larni qo'llovchi Yii ning to'liq boshqatdan yozilgan talqini. Mana shu talqinda navbatdagi yillarda uni yanada kuchaytirish nazarda tutilgan. Ushbu qo'llanma aynan 2.0 talqin haqida. |
||||
|
||||
|
||||
DT va bilimlarga talablar |
||||
------------------------- |
||||
|
||||
Yii 2.0 PHP 5.4.0 va undan yuqorisini talab qiladi. Boshqa imkoniyatlar uchun talablarni bilish uchun har bir alohida yo'lga qo'yilgan freymvork bilan birga mos o'rnatilgan talablar tekshiruv skriptini ishga tushirishingiz mumkin. |
||||
|
||||
Freymvork to'liq obektga mo'ljallangan dasturlashga (OMD) asoslanganligi bois Yii da ishlash uchun OMD ni umumiy tushunish talab etiladi. Shuningdek, PHP ning zamonaviy imkoniyatlari bo'lmish [nomlar soxasi](http://www.php.net/manual/ru/language.namespaces.php) va [treytlar](http://www.php.net/manual/ru/language.oop5.traits.php) ni o'rganish talab etiladi. |
||||
@ -0,0 +1,46 @@
|
||||
Flujo de Trabajo de Traducción |
||||
============================== |
||||
|
||||
Yii se traduce en muchos idiomas con el fin de ser útil para desarrolladores de aplicaciones e internacionales. |
||||
Dos áreas principales donde la contribución es muy bienvenida son la documentación y los mensajes del framework. |
||||
|
||||
Mensajes del Framework |
||||
---------------------- |
||||
|
||||
El framework tiene dos tipos de mensajes: excepciones que están destinadas al desarrollador y nunca se traducen, y mensajes |
||||
que en realidad son visibles para el usuario final, tales como errores de validación. |
||||
|
||||
El orden para comenzar con la traducción de mensajes: |
||||
|
||||
1. Comprobar que en `framework/messages/config.php` su idioma aparece en `languages`. Si no, añade tu idioma allí (recuerda que debes mantener la lista en orden alfabético). |
||||
El formato de código de idioma debe seguir el [Código de Idiomas IETF](http://es.wikipedia.org/wiki/C%C3%B3digo_de_idioma_IETF), por ejemplo, `es`. |
||||
2. Ir al directorio `framework` y ejecutar el comando `yii message/extract messages/config.php`. |
||||
3. Traducir los mensajes en `framework/messages/tu-idioma/yii.php`. Asegúrate de guardar el archivo con codificación UTF-8. |
||||
4. [Crear un pull request](https://github.com/yiisoft/yii2/blob/master/docs/internals-es/git-workflow.md). |
||||
|
||||
Con el fin de mantener la traducción al día puedes ejecutar `yii message/extract messages/config.php` nuevamente. |
||||
Se volverán a extraer automáticamente los mensajes de mantenimiento intactos sin los cambios. |
||||
|
||||
En el archivo de traducción de cada elemento del `array` representa un mensaje (clave) y su la traducción (valor). Si el valor está vacío, el mensaje se considera como no traducido. |
||||
Los mensajes que ya no necesiten traducción tendrán sus traducciones encerrado entre un par de marcas '@@'. El texto de los mensajes se puede utilizar con el formato de formas plurales. |
||||
Chequea la [sección i18n de la guía](../guide-es/tutorial-i18n.md) para más detalles. |
||||
|
||||
Documentación |
||||
------------- |
||||
|
||||
Coloca las traducciones de la documentación bajo `docs/<original>-<language>` donde `<original>` es el nombre de la documentación original como `guide` o `internals` |
||||
y `<language>` es el código del idioma al que se está traduciendo. Para la traducción al español de la guía, es `docs/guide-es`. |
||||
|
||||
Después de que el trabajo inicial está hecho, puedes obtener los cambios desde la última traducción del archivo usando un comando especial del directorio `build`: |
||||
|
||||
``` |
||||
php build translation "../docs/guide" "../docs/guide-es" "Reporte de traducción guia en Español" > report_guide_es.html |
||||
``` |
||||
|
||||
Si recibes un error de composer, ejecuta `composer install` en el directorio raíz. |
||||
|
||||
Convenios para la traducción |
||||
---------------------------- |
||||
|
||||
Las palabras en inglés que son propias del framework o de PHP, o traducibles pero que están muy ligadas a conceptos extendidos o nombres de clases, se pueden dejar en idioma original. |
||||
Ejemplos: `namespace`, `assets`, `helper`, `widget`, etc. |
||||
@ -0,0 +1,27 @@
|
||||
<?php |
||||
/** |
||||
* @link http://www.yiiframework.com/ |
||||
* @copyright Copyright (c) 2008 Yii Software LLC |
||||
* @license http://www.yiiframework.com/license/ |
||||
*/ |
||||
|
||||
namespace yii\bootstrap; |
||||
|
||||
use yii\web\AssetBundle; |
||||
|
||||
/** |
||||
* Asset bundle for the Twitter bootstrap default theme. |
||||
* |
||||
* @author Alexander Makarov <sam@rmcreative.ru> |
||||
* @since 2.0 |
||||
*/ |
||||
class BootstrapThemeAsset extends AssetBundle |
||||
{ |
||||
public $sourcePath = '@bower/bootstrap/dist'; |
||||
public $css = [ |
||||
'css/bootstrap-theme.css', |
||||
]; |
||||
public $depends = [ |
||||
'yii\bootstrap\BootstrapAsset', |
||||
]; |
||||
} |
||||
@ -0,0 +1,137 @@
|
||||
<?php |
||||
|
||||
|
||||
namespace yii\web; |
||||
|
||||
/** |
||||
* Mock for the time() function for web classes |
||||
* @return int |
||||
*/ |
||||
function time() |
||||
{ |
||||
return \yiiunit\framework\web\UserTest::$time ?: \time(); |
||||
} |
||||
|
||||
namespace yiiunit\framework\web; |
||||
|
||||
use yii\base\NotSupportedException; |
||||
use yii\base\Component; |
||||
use yii\rbac\PhpManager; |
||||
use yii\web\IdentityInterface; |
||||
use yii\web\UrlManager; |
||||
use yii\web\UrlRule; |
||||
use yii\web\Request; |
||||
use Yii; |
||||
use yiiunit\TestCase; |
||||
|
||||
/** |
||||
* @group web |
||||
*/ |
||||
class UserTest extends TestCase |
||||
{ |
||||
/** |
||||
* @var integer virtual time to be returned by mocked time() function. |
||||
* Null means normal time() behavior. |
||||
*/ |
||||
public static $time; |
||||
|
||||
protected function tearDown() |
||||
{ |
||||
Yii::$app->session->removeAll(); |
||||
static::$time = null; |
||||
parent::tearDown(); |
||||
} |
||||
|
||||
public function testLoginExpires() |
||||
{ |
||||
if (getenv('TRAVIS') == 'true') { |
||||
$this->markTestSkipped('Can not reliably test this on travis-ci.'); |
||||
} |
||||
|
||||
$appConfig = [ |
||||
'components' => [ |
||||
'user' => [ |
||||
'identityClass' => UserIdentity::className(), |
||||
'authTimeout' => 10, |
||||
], |
||||
'authManager' => [ |
||||
'class' => PhpManager::className(), |
||||
'itemFile' => '@runtime/user_test_rbac_items.php', |
||||
'assignmentFile' => '@runtime/user_test_rbac_assignments.php', |
||||
'ruleFile' => '@runtime/user_test_rbac_rules.php', |
||||
] |
||||
], |
||||
]; |
||||
$this->mockWebApplication($appConfig); |
||||
|
||||
$am = Yii::$app->authManager; |
||||
$am->removeAll(); |
||||
$am->add($role = $am->createPermission('rUser')); |
||||
$am->add($perm = $am->createPermission('doSomething')); |
||||
$am->addChild($role, $perm); |
||||
$am->assign($role, 'user1'); |
||||
|
||||
Yii::$app->session->removeAll(); |
||||
static::$time = \time(); |
||||
Yii::$app->user->login(UserIdentity::findIdentity('user1')); |
||||
|
||||
// print_r(Yii::$app->session); |
||||
// print_r($_SESSION); |
||||
|
||||
$this->mockWebApplication($appConfig); |
||||
$this->assertFalse(Yii::$app->user->isGuest); |
||||
$this->assertTrue(Yii::$app->user->can('doSomething')); |
||||
|
||||
static::$time += 5; |
||||
$this->mockWebApplication($appConfig); |
||||
$this->assertFalse(Yii::$app->user->isGuest); |
||||
$this->assertTrue(Yii::$app->user->can('doSomething')); |
||||
|
||||
static::$time += 11; |
||||
$this->mockWebApplication($appConfig); |
||||
$this->assertTrue(Yii::$app->user->isGuest); |
||||
$this->assertFalse(Yii::$app->user->can('doSomething')); |
||||
|
||||
} |
||||
|
||||
} |
||||
|
||||
class UserIdentity extends Component implements IdentityInterface |
||||
{ |
||||
private static $ids = [ |
||||
'user1', |
||||
'user2', |
||||
'user3', |
||||
]; |
||||
|
||||
private $_id; |
||||
|
||||
public static function findIdentity($id) |
||||
{ |
||||
if (in_array($id, static::$ids)) { |
||||
$identitiy = new static(); |
||||
$identitiy->_id = $id; |
||||
return $identitiy; |
||||
} |
||||
} |
||||
|
||||
public static function findIdentityByAccessToken($token, $type = null) |
||||
{ |
||||
throw new NotSupportedException(); |
||||
} |
||||
|
||||
public function getId() |
||||
{ |
||||
return $this->_id; |
||||
} |
||||
|
||||
public function getAuthKey() |
||||
{ |
||||
throw new NotSupportedException(); |
||||
} |
||||
|
||||
public function validateAuthKey($authKey) |
||||
{ |
||||
throw new NotSupportedException(); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue