25 consejos y trucos de Laravel - Code Tuts - Envato Tuts+

Hubo un período de tiempo, no hace mucho tiempo, cuando PHP y su comunidad eran, por falta de mejores palabras, odiados. Aparentemente, el chiste de todos los días era uno que se relacionaba con lo terrible que era PHP. Vamos a ver, ¿qué nuevo artículo golpeando a PHP serán publicados hoy?

Sí, por desgracia, la comunidad y el ecosistema simplemente no estaban en el mismo nivel que otros idiomas modernos.

Sí, por desgracia, la comunidad y el ecosistema simplemente no estaban en el mismo nivel que otros idiomas modernos. Parecía que PHP estaba destinado a vivir su vida dominante en forma de temas desordenados de WordPress.

Pero, entonces, asombrosamente, las cosas comenzaron a cambiar - y rápidamente, también. Como una bruja moviendo la olla, nuevos proyectos innovadores comenzaron a surgir de la nada. Quizás el más notable de estos proyectos fue Composer: PHP gestor de pendencias definitivo (no a diferencia de Bundler de Ruby o NPM de Node). Mientras que, en el pasado, los desarrolladores de PHP se vieron obligados a crear una forma de PEAR (una pesadilla, de hecho), ahora, gracias a Composer, pueden simplemente actualizar un archivo JSON, e inmediatamente obtener su dependencia deseada. Un perfilador aquí, un marco de prueba allí... ¡todo en segundos!

En el atestado mundo del framework PHP, justo cuando CodeIgniter comenzó a fallar, el marco de Taylor Otwell Laravel surgió de las cenizas para convertirse en el favorito de la comunidad. Con una sintaxis tan simple y elegante, la creación de aplicaciones con Laravel y PHP fue - jadear - ¡francamente divertido! Además, con la versión 4 del marco que aprovechaba mucho Composer, las cosas parecían estar cayendo en su lugar para la comunidad.

¿Desea migraciones (control de versiones para su base de datos)? Hecho. ¿Qué tal una poderosa implementación Active-Record? Claro, Eloquent lo hará muy bien. ¿Qué pasa con las instalaciones de prueba? Por supuesto. ¿Y el enrutamiento? Por supuesto. ¿Qué pasa con una capa altamente probada HTTP? Gracias a Composer, Laravel puede aprovechar muchos de los excelentes componentes de Symfony. Cuando se trata a fin de cuentas, lo más probable es que, si lo necesita, Laravel lo ofrece.

Mientras que PHP no era diferente de un juego de Jenga - a sólo uno para caer a pedazos - de repente, gracias a Laravel y Composer, el futuro no podía parecer más brillante. Así que sacar algunos tonos, y cavar en todo lo que el marco tiene que ofrecer.

1. Consultas Eloquent
   Laravel ofrece una de las más poderosas implementaciones de Active-Record en el mundo de PHP. Digamos que usted tiene una tabla de pedidos orders, junto con un modelo de Orden Order en Eloquent:

1
class Order extends Eloquent {}
Podemos realizar fácilmente cualquier número de consultas de base de datos, usando PHP simple y elegante. No hay necesidad de tener SQL desordenado. Vamos a agarrar todos los pedidos.

1
$orders = Order::all();
Hecho. O tal vez, esas órdenes deben devolverse en orden, de acuerdo a la fecha de lanzamiento. Eso es fácil:

1
$orders = Order::orderBy('release_date', 'desc')->get();
¿Qué pasa si, en lugar de buscar un registro, en lugar de eso, necesitamos guardar un nuevo pedido en la base de datos? Claro, podemos hacer eso.

1
2
3
$order = new Order;
$order->title = 'Xbox One';
$order->save();
¡Terminado! Con Laravel, las tareas que solían ser incómodas de realizar son ridículamente simples.

1. Enrutamiento flexible
   Laravel es único en que se puede utilizar de varias maneras. ¿Prefiere un sistema de enrutamiento más simple y sinatra? Claro, Laravel puede ofrecer eso muy fácilmente, usando cierres.

1
2
3
4
5
Route::get('orders', function()
{
return View::make('orders.index')
->with('orders', Order::all());
});
Esto puede resultar útil para proyectos pequeños y API, pero es muy probable que necesite controladores para la mayoría de sus proyectos. Esta bien; ¡Laravel puede hacer eso, también!

1
Route::get('orders', 'OrdersController@index');
Hecho. ¿Observa cómo laravel crece con sus necesidades? Este nivel de comodidad es lo que hace que el marco sea tan popular como lo es hoy en día.

1. Relaciones fáciles
   ¿Qué hacemos en los casos en que debemos definir las relaciones? Por ejemplo, una tarea seguramente pertenecerá a un usuario. ¿Cómo podríamos representar eso en Laravel? Bueno, suponiendo que las tablas de base de datos necesarias estan configuradas, sólo tenemos que modificar los modelos relacionados Eloquent.

01
02
03
04
05
06
07
08
09
10
11
12
13
class Task extends Eloquent {
public function user()
{
return $this->belongsTo('User');
}
}

class User extends Eloquent {
public function tasks()
{
return $this->hasMany('Task');
}
}
Y, con eso, ¡hemos terminado! Vamos a obtener todas las tareas para el usuario con un id de 1. Podemos hacer eso en dos líneas de código.

1
2
$user = User::find(1);
$tasks = $user->tasks;
Sin embargo, debido a que hemos definido la relación de ambos extremos, si en vez de eso queremos buscar al usuario asociado con una tarea, también podemos hacerlo.

1
2
$task = Task::find(1);
$user = $task->user;

1. Vinculación de modelo a formulario
   A menudo, puede ser útil vincular un formulario a un modelo. El ejemplo obvio de esto es cuando desea editar algún registro en su base de datos. Con la vinculación de modelo a formulario, podemos rellenar instantáneamente los campos de formulario con los valores de la fila de tabla asociada.

01
02
03
04
05
06
07
08
09
10
11
{{ Form::model($order) }}

<div>
    {{ Form::label('description', 'Description:') }}
    {{ Form::textarea('description') }}
</div>

{{ Form::close() }}
Dado que el formulario está ahora vinculado a una instancia de orden específica Order, las entradas mostrarán los valores correctos de la tabla. ¡Simple!

1. Consultas de la base de datos caché
   Demasiadas consultas de base de datos, y, muy rápidamente, su aplicación puede convertirse en melaza. Por suerte, Laravel ofrece un mecanismo simple para almacenar en caché estas consultas, usando nada más que una sola llamada de método.

Vamos a tomar todas las preguntas questions de la base de datos, pero la caché de la consulta, ya que no es probable que esta tabla se actualizará con frecuencia.

1
$questions = Question::remember(60)->get();
¡Eso es! Ahora, para la próxima hora de solicitudes de páginas, esa consulta permanecerá en caché y no se tocará la base de datos.

1. Compositores de Vista
   Encontrará situaciones en las que varias vistas requieren una determinada variable o pieza de datos. Un buen ejemplo de esto es una barra de navegación que muestra una lista de etiquetas.

Para mantener los controladores tan mínimos como sea posible, Laravel ofrece a los compositores de vista para manejar cosas como esta.

1
2
3
4
View::composer('layouts.nav', function($view)
{
$view->with('tags', ['tag1', 'tag2']);
});
Con este pedazo de código, cada vez que se cargue la vista layouts/nav.blade.php, tendrá acceso a una variable, $tags, igual a la matriz proporcionada.

1. Autenticación simple
   Laravel adopta un enfoque simple de autenticación. Simplemente pase una matriz de credenciales, probablemente obtenida de un formulario de inicio de sesión, a Auth::attempt(). Si los valores proporcionados coinciden con lo que se almacena en la tabla de usuarios users, el usuario se conectará al instante.

01
02
03
04
05
06
07
08
09
10
$user = [
'email' => 'email',
'password' => 'password'
];

if (Auth::attempt($user))
{
// user is now logged in!
// Access user object with Auth::user()
}
¿Qué pasa si necesitamos registrar el usuario - tal vez, cuando un URI /logout es ingresada? Eso también es fácil.

1
2
3
4
5
6
Route::get('logout', function()
{
Auth::logout();

return Redirect::home();

});

1. Recursos
   Trabajar RESTful en Laravel nunca ha sido más fácil. Para registrar un controlador de recursos, simplemente llameRoute::resource(), así:

1
Route::resource('orders', 'OrdersController');
Con este código, Laravel registrará ocho rutas.

GET /orders
GET /orders/:order
GET /orders/create
GET /orders/:order/edit
POST /orders
PUT /orders/:order
PATCH /orders/:order
DELETE /orders/:order
Además, el controlador complementario se puede generar desde la línea de comandos:

1
php artisan controller:make OrdersController
Dentro de este controlador generado, cada método corresponderá a una de las rutas anteriores. Por ejemplo, los pedidos /orders se asignarán al método de índice index, /orders/create se mapeará a create, etc.

Ahora tenemos la energía necesaria para construir aplicaciones RESTful y APIs con facilidad.

1. Plantillas Blade
   Mientras que, sí, PHP es por naturaleza un lenguaje templating, no ha evolucionado para convertirse en un demasiado bueno. Eso está bien, sin embargo; Laravel ofrece su motor Blade para llenar el vacío. Simplemente nombre sus vistas con una extensión .blade.php, y se analizarán automáticamente, en consecuencia. Ahora, podemos hacer cosas como:

1
2
3
4
5
6
7
@if ($orders->count())

@foreach($orders as $order)

• {{ $order->title }}

@endforeach

@endif

1. Instalaciones de prueba
   Debido a que Laravel hace uso de Composer, instantáneamente tenemos el soporte de PHPUnit integrado. Instale el framework y ejecute phpunit desde la línea de comandos para probarlo.

Incluso mejor, sin embargo, Laravel ofrece una serie de ayudantes de prueba para los tipos más comunes de pruebas funcionales.

Vamos a verificar que la página de inicio devuelve un código de estado de 200.

1
2
3
4
5
public function test_home_page()
{
$this->call('GET', '/');
$this->assertResponseOk();
}
O tal vez queremos confirmar que, cuando se publica un formulario de contacto, el usuario es redirigido de nuevo a la página principal con un mensaje flash.

01
02
03
04
05
06
07
08
09
10
11
12
public function test_contact_page_redirects_user_to_home_page()
{
$postData = [
'name' => 'Joe Example',
'email' => 'email-address',
'message' => 'I love your website'
];

$this->call('POST', '/contact', $postData);

$this->assertRedirectedToRoute('home', null, ['flash_message']);

}

1. Componente remoto
   Como parte de Laravel 4.1 - programado para ser lanzado en noviembre de 2013 - puedes escribir fácilmente un comando Artisan a SSH en su servidor, y realizar cualquier número de acciones. Es tan simple como usar la fachada SSH:

1
2
3
4
SSH::into('production')->run([
'cd /var/www',
'git pull origin master'
]);
Pase una matriz de comandos al método run(), ¡y Laravel se encarga del resto! Ahora, porque tiene sentido ejecutar código como este como un comando Artisan, sólo necesita ejecutar el comando php artisan command:make DeployCommand e inserte el código aplicable en el método fire del comando para crear rápidamente un comando de despliegue dedicado.

1. Eventos
   Laravel ofrece una elegante implementación del patrón de observadores que puede utilizar en todas sus aplicaciones. Escuche los eventos nativos, como illuminate.query, o incluso disparar y escuchar a los suyos.

Un uso maduro de eventos en una aplicación puede tener un efecto increíble en su mantenibilidad y estructura.

1
2
3
4
5
Event::listen('user.signUp', function()
{
// do whatever needs to happen
// when a new user signs up
});
Como la mayoría de las cosas en Laravel, si prefiere hacer referencia a un nombre de clase, en lugar de un cierre, puede hacerlo libremente. Laravel lo resolverá entonces fuera del contenedor de IoC.

1
Event::listen('user.signUp', 'UserEventHandler');

1. Ver todas las rutas

A medida que crece una aplicación, puede ser difícil ver qué rutas han sido registradas. Esto es especialmente cierto si no se ha dado la debida atención a su archivo routes.php (es decir, el enrutamiento implícito abusivo).

Laravel ofrece un comando routes útil, que mostrará todas las rutas registradas, así como los métodos de control que activan.

1
php artisan routes

1. Colas
   Piense en cuándo un usuario se registra para su aplicación. Probablemente, una serie de eventos deben suceder. Una tabla de la base de datos se debe actualizar, una lista del boletín de noticias debe ser agregada, una factura se debe crear, un email de la recepción pudo ser enviado, etc. Desafortunadamente, estas clases de acciones tienen una tendencia a tomar un tiempo largo.

¿Por qué obligar al usuario a esperar estas acciones, cuando en vez de eso podemos ponerlas en segundo plano?

1
Queue::push('SignUpService', compact('user'));
Quizás la parte más emocionante, sin embargo, es que Laravel ofrece brillantemente soporte para las colas de empuje de Iron.io. Esto significa que, incluso sin una onza de experiencia "trabajador" o "daemon", todavía podemos aprovechar el poder de las colas. Simplemente registre un end-point de URL utilizando el útil comando php artisan queue:subscribe y Iron.io realizará un ping a su URL elegida cada vez que se agregue un trabajo a la cola.

¡Pasos sencillos para un rendimiento más rápido!

1. Validación fácil
   Cuando la validación se requiere (y cuando no es), ¡Laravel de nuevo viene al rescate! Usar la clase Validator es lo más intuitivo posible. Simplemente pase el objeto bajo validación, así como una lista de reglas para el método make, y Laravel se encargará del resto.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
$order = [
'title' => 'Wii U',
'description' => 'Game console from Nintendo'
];

$rules = [
'title' => 'required',
'description' => 'required'
];

$validator = Validator::make($order, $rules);

if ($validator->fails())
{
var_dump($validator->messages()); // validation errors array
}
Normalmente, este tipo de código se almacenará dentro de su modelo, lo que significa que la validación de, por ejemplo, un pedido podría reducirse a una sola llamada de método:

1
$order->isValid();

1. Tinker Tinker

Especialmente cuando estes aprendiendo Laravel, es útil para jugar con el núcleo. El comando Artisan tinker puede ayudar con esto.

Como parte de la versión 4.1, el comando tinker es aún más potente, ahora que aprovecha el popular componente Boris.

1
2
3
4
5
$ php artisan tinker

$order = Order::find(1);
var_dump($order->toArray());
array(...)

1. Migraciones
   Piense en las migraciones como control de versiones para su base de datos. En cualquier punto dado, puede "revertir" todas las migraciones, volver a ejecutarlas y mucho más. Tal vez el verdadero poder descansa en el poder de empujar una aplicación a la producción, y ejecutar un único operador de php artisan migrate para construir al instante su base de datos.

Para preparar el esquema para una nueva tabla de usuarios, podemos ejecutar:

1
php artisan migrate:make create_users_table
Esto generará un archivo de migración, que podrá rellenar de acuerdo a sus necesidades. Una vez completado, php artisan migrate creará la tabla. ¡Eso es! ¿Necesitas revertir esa creación? ¡Fácil! php artisan migrate:rollback.

He aquí un ejemplo del esquema para una tabla de preguntas frecuentes.

01
02
03
04
05
06
07
08
09
10
11
12
13
14
public function up()
{
Schema::create('faqs', function(Blueprint $table) {
$table->integer('id', true);
$table->text('question');
$table->text('answer');
$table->timestamps();
});
}

public function down()
{
Schema::drop('faqs');
}
Observe cómo el método drop() realiza la inversa de up(). Esto es lo que nos permite revertir la migración. ¿No es eso mucho más fácil que un montón de SQL en su lugar?

1. Generadores
   Mientras Laravel ofrece una serie de generadores útiles, un paquete de terceros increíblemente útil, llamado "Laravel 4 Generators", lleva esto aún más lejos. ¡Genere recursos, archivos de semillas, tablas dinámicas y migraciones con esquemas!

En esta sugerencia anterior, nos vimos obligados a escribir manualmente el esquema. Sin embargo, con el paquete de generadores habilitado, podemos hacer lo siguiente:

1
php artisan generate:migration create_users_table --fields="username:string, password:string"
El generador se hará cargo del resto. Esto significa que, con dos comandos, puede preparar y construir una nueva tabla de base de datos.

Los generadores Laravel 4 se pueden instalar a través de Composer.

1. Comandos
   Como se mencionó anteriormente, hay un número de casos en los que puede ser útil escribir comandos personalizados. Pueden utilizarse para aplicaciones scaffold, generar archivos, implementar aplicaciones y todo lo demás.

Debido a que esta es una tarea tan común, Laravel hace que el proceso de creación de un comando tan fácil como puede ser.

1
php artisan command:make MyCustomCommand
Este comando generará el boilerplate necesario para su nuevo comando personalizado. A continuación, de la nueva creación, app/commands/MyCustomCommand.php, rellene el nombre y la descripción apropiados:

1
2
protected $name = 'command:name';
protected $description = 'Command description.';
Y, finalmente, dentro de la clase de comando fire(), realice cualquier acción que necesite. Una vez finalizado, el único paso restante es registrar el comando con Artisan, desde app/start/Artisan.php.

1
Artisan::add(new MyCustomCommand);
Por extraño que parezca; ¡Eso es! Ahora puede llamar a su comando personalizado desde el terminal.

1. Fachadas falsas
   Laravel aprovecha el patrón de fachada. Esto permite la sintaxis estática-como limpia que indudablemente llegarás a amar (Route::get(), Config::get(), etc.), mientras que todavía permite la testabilidad completa detrás de las escenas.

Debido a que estas "clases subyacentes" se resuelven fuera del contenedor de IoC, podemos intercambiar fácilmente las instancias subyacentes con mocks, con el propósito de probar. Esto permite un control como:

1
Validator::shouldReceive('make')->once();
Sí, estamos llamando shouldReceive directamente fuera de la fachada. Detrás de las escenas, Laravel hace uso del marco Mockery para permitir esto. Esto significa que usted puede utilizar libremente estas fachadas en su código, mientras que todavía permite la testabilidad del 100%.

1. Ayudantes de Formas
   Debido a que las formas de construcción pueden ser frecuentemente una tarea engorrosa, el constructor de formularios de Laravel interviene para facilitar el proceso, así como aprovechar muchas de las idiosincrasias relacionadas con la construcción de formularios. Aquí están algunos ejemplos:

1
2
3
4
5
{{ Form::open() }}
{{ Form::text('name') }}
{{ Form::textarea('bio') }}
{{ Form::selectYear('dob', date('Y') - 80, date('Y')) }}
{{ Form::close() }}
¿Qué pasa con las tareas, como recordar la entrada de la presentación del formulario anterior? ¡Laravel puede hacer todo eso automáticamente!

1. El contenedor IoC
   En el núcleo de Laravel está su potente contenedor IoC, que es una herramienta que ayuda a administrar dependencias de clase. ¡Notablemente, el contenedor tiene la energía de resolver automáticamente clases sin la configuración!

Simplemente escriba sus dependencias dentro del constructor y, una vez instanciada, Laravel utilizará la API Reflection de PHP para leer inteligentemente las tipografías e intentará inyectarlas por ti.

1
2
3
4
public function __construct(MyDependency $thing)
{
$this->thing = $thing;
}
Siempre que solicite la clase fuera del contenedor de IoC, esta resolución se realizará automáticamente.

1
$myClass = App::make('MyClass');
Una nota importante es que los controladores siempre se resuelven fuera del contenedor de IoC. Como tal, puede inyectar dependencias en su controlador, y Laravel hará lo mejor posible para inyectarlos por ti.

1. Entornos
   Si bien un solo entorno podría funcionar para proyectos pequeños, para cualquier aplicación de tamaño, varios entornos resultarán esenciales. Desarrollo, pruebas, producción ... todos estos son esenciales y requieren su propia configuración.

Tal vez el entorno de prueba utilice una base de datos en la memoria para realizar pruebas. Tal vez su entorno de desarrollo utiliza diferentes claves API. Es probable que su entorno de producción utilice una cadena de conexión de base de datos personalizada.

Por suerte, Laravel vuelve a simplificar nuestro trabajo. Eche un vistazo a bootstrap/start.php en su aplicación.

Esta es una demostración básica de establecer un entorno local y de producción production, basado en la barra de direcciones del navegador.

1
2
3
4
$env = $app->detectEnvironment(array(
'local' => array('localhost'),
'production' => array('*.com')
));
Si bien esto funcionará, hablando en general, se prefiere utilizar variables de entorno para este tipo de cosas. Sin preocupaciones; ¡Esto es todavía factible en Laravel! En su lugar, simplemente devuelva una función del método detectEnvironment en el objeto contenedor.

1
2
3
4
$env = $app->detectEnvironment(function()
{
return getenv('ENV_NAME') ?: 'local';
});
Ahora, a menos que se haya establecido una variable de entorno (lo que se hará para la producción), el entorno predeterminado será local.

Advertisement

1. Configuración simple
   Laravel, una vez más, adopta un enfoque simple de la configuración. Cree una carpeta dentro de app/config que coincida con el entorno que desee y cualquier archivo de configuración que tenga dentro tendrá prioridad si el nombre del entorno coincide. Como tal, para, por ejemplo, establecer una clave de API de facturación diferente para el desarrollo, podrías hacer:

1
2
3
4
5

<?php app/config/development/billing.php

return [
'api_key' => 'your-development-mode-api-key'
];
La configuración es automática. Simplemente escriba Config::get('billing.api_key'), y Laravel determinará correctamente de qué archivo leer.

1. Aprendizaje Adicional
   Cuando se trata de educación, la comunidad Laravel, a pesar de su edad relativamente joven, es un pozo sin fin. En poco más de un año, una media docena de libros diferentes - relacionados con todos los asuntos de desarrollo de Laravel - han sido lanzados.

¡Aprende todo, desde lo básico hasta las pruebas, hasta la creación y el mantenimiento de aplicaciones grandes!