Sabemos que podemos definir verbos de peticiones HTTP que queramos asociar usando los métodos
de rutas. Esto es realmente conveniente a la hora de enrutar a Closures. No obstante, cuando
enrutamos a Controladores puede que quieras mantener la definición del verbo de la petición junto
a la lógica de tu aplicación. Bueno, las buenas noticias es que Laravel te ofrece esta configuración
alternativa.
Alteremos nuestro Controlador un poco, ¿vale?
<?php
// app/controllers/Articulo.php
namespace Blog\Controller;
use View;
use BaseController;
class Articulo extends BaseController
{
public function getCrear()
{
return View::make('crear');
}
16
17
public function postCrear()
{
18
// Gestionar el formulario de creacion
19
}
20
21
92
}
Aquí tenemos nuestro Controlador de Articulo una vez más. La intención de las acciones son
facilitar una forma de crear y gestionar la creación de un nuevo artículo del blog. Descubrirás que
los nombres de las acciones tienen como prefijo get y post . Esos son nuestros verbos HTTP.
Por tanto, en nuestro ejemplo podrías pensar que hemos representado puntos para las siguientes
URLs:
1
2
GET /crear
POST /crear
También podrías preguntarte cómo enrutamos hacia nuestro controlador RESTful. Como verás, usar
métodos de verbos en la clase Route no tendría mucho sentido. Bueno, di adios a enrutar acciones
individuales. Echemos un vistazo a otro método de enrutado.
<?php
// app/routes.php
Route::controller('Articulo', 'Blog\Controller\Articulo');
Este único método enrutará todas las acciones representada en nuestro controlador RESTFul.
Miremos con más detenimiento al método.
El primer parámetro es la URL base. Normalmente, el enrutado RESTful es usado para representar
un objeto por lo que, en la mayoría de las ocasiones, la URL base será el nombre de ese objeto. Puedes
pensar en ello como un prefijo de las acciones que hemos creado en nuestro controlador RESTful.
El segundo parámetro ya te será familiar. Es el controlador al que intentamos enrutar. Una vez más,
Laravel aceptará felizmente un controlador con un espacio de nombre como objetivo de la ruta por
lo que eres libre de organizar tus Controladores como quieras.
Como puedes ver, usar este método de enrutado a tus controladores, te ofrece una ventaja distinta
sobre el método de enrutado original. Con este método, solo tendrás que facilitar una única entrada
de enrutado para el controlador, en vez de enrutar cualquier acción de forma independiente.
viernes, 24 de octubre de 2014
Enrutado de Controlador
Los Controladores son bonitos y limpios y ofrecen una forma sencilla de agrupar lógica común.
No obstante, no son útiles a menos que nuestros usuarios puedan alcanzar esa lógica. por suerte, el
método para enlazar una URI a un Controlador es similar al método que usamos para las Closures.
Echemos un ojo.
<?php
// app/routes.php
Route::get('index', 'ArticuloController@mostrarIndex');
Para enlazar una URI a un Controlador, tenemos que definir una nueva ruta en el archivo
/app/routes.php . Estamos usando el mismo método Route::get() que utilizamos al usar Closures.
No obstante, el segundo parámetro es totalmente diferente. En esta ocasión tenemos una cadena.
La cadena consiste en dos secciones que están separadas por una arroba ( @ ). Echemos un ojo otra
vez al Controlador que creamos en la última sección.
Route::post('articulo/nuevo', 'ArticuloController@nuevoArticulo');
<?php
// app/routes.php
Route::post('index', 'Blog\Controller\Articulo@mostrarIndex');
Es igual que antes, solo que en esta ocasión el nombre del controlador ha sido prefijado con su
espacio de nombre. Como ves, ¡los espacios de nombre no tienen que complicar las cosas! Incluso
puedes almacenar tu controlador con espacio de nombre en un directorio anidado, o en cualquier
sitio con un esquema de carga PSR-0. A Laravel no le importa, mientras que Composer sepa dónde
encontrar tu clase, Laravel podrá usarla.
Controladores
El Controlador es una clase usada para alojar lógica de enrutado. Normalmente, el Controlador
contendrá un número de métodos públicos conocidos como acciones. Puedes pensar en las acciones
como la alternativa directa a las closures que usamos en el capítulo anterior, son muy similares tanto
en apariencia como en funcionalidad.
?php
// app/controllers/ArticuloController.php
class ArticuloController extends BaseController
{
public function mostrarIndex()
{
return View::make('index');
}
public function mostrarUnico($idArticulo)
{
return View::make('unico');
}
}
Puedes llamar al Controlador como quieras. Mientras este extienda a BaseController o Controller ,
Laravel sabrá lo que intentas hacer. No obstante, añadirle el sufijo Controller es algo estándar que
los programadores web usan. Si piensas trabajar con otros, los estándares pueden ser realmente
útiles.
contendrá un número de métodos públicos conocidos como acciones. Puedes pensar en las acciones
como la alternativa directa a las closures que usamos en el capítulo anterior, son muy similares tanto
en apariencia como en funcionalidad.
?php
// app/controllers/ArticuloController.php
class ArticuloController extends BaseController
{
public function mostrarIndex()
{
return View::make('index');
}
public function mostrarUnico($idArticulo)
{
return View::make('unico');
}
}
Puedes llamar al Controlador como quieras. Mientras este extienda a BaseController o Controller ,
Laravel sabrá lo que intentas hacer. No obstante, añadirle el sufijo Controller es algo estándar que
los programadores web usan. Si piensas trabajar con otros, los estándares pueden ser realmente
útiles.
Patrones de filtro
El patrón de filtros te permite hacer coincidir un filtro before a un número de rutas facilitando un
patrón de enrutado con un asterisco. Veámoslo en acción.
?php
// app/routes.php
Route::when('perfil/*', 'cumpleanos');
El método Route::when() de arriba, ejecutará el filtro cumpleanos en todas las rutas cuya URI
comiencen con perfil/ . El asterisco del primer parámetro actúa como comodín. Es una gran forma
de adjuntar un filtro before a varias rutas a la vez.
patrón de enrutado con un asterisco. Veámoslo en acción.
?php
// app/routes.php
Route::when('perfil/*', 'cumpleanos');
El método Route::when() de arriba, ejecutará el filtro cumpleanos en todas las rutas cuya URI
comiencen con perfil/ . El asterisco del primer parámetro actúa como comodín. Es una gran forma
de adjuntar un filtro before a varias rutas a la vez.
Parámetros de los filtros
Al igual que las funciones de PHP, los filtros pueden aceptar parámetros. Esta es una gran forma de
evitar repeticiones y que permite mayor flexibilidad. Vamos allá con un ejemplo, como siempre.
<?php
// app/filters.php
// before
Route::filter('test', function($ruta, $peticion)
{
// after
Route::filter('test', function($ruta, $peticion, $respuesta)
{
});
evitar repeticiones y que permite mayor flexibilidad. Vamos allá con un ejemplo, como siempre.
<?php
// app/filters.php
// before
Route::filter('test', function($ruta, $peticion)
{
// after
Route::filter('test', function($ruta, $peticion, $respuesta)
{
});
Filtros múltiples
Otra cosa que deberías saber es que puedes aplicar tantos filtros como quieras a una ruta. Echemos
un vistazo a algunos ejemplos en acción. Primero, añadamos varios filtros before :
1
<?php
// app/routes.php
Route::get('/', array(
'before' => 'cumpleanos|navidad',
function()
{
return View::make('hola');
}
));
Aquí hemos añadido los filtros tanto cumpleanos como navidad en el apartado before a la ruta.
Dejaré que tu imaginación decida lo que hace el filtro navidad , pero asegúrate de que sea algo
mágico.
El caracter | (tubería) puede ser usado para separar una lista de filtros. Serán ejecutados de izquierda
a derecha, y el primero que devuelva una respuesta terminará la petición y esa respuesta será
devuelta como resultado.
Si quieres, puedes usar una matriz para ofrecer varios filtros. Puede que eso te parezca más del estilo
php.
Si quieres, puedes usar una matriz para ofrecer varios filtros. Puede que eso te parezca más del estilo
php.
Route::get('/', array(
'before' => array('cumpleanos', 'navidad'),
function()
{
return View::make('hola');
}
));
<?php
// app/routes.php
Route::get('/', array(
'before'
=> 'cumpleanos',
'after'
=> 'navidad',
function()
{
return View::make('hola');
}
));
Filtros Básicos
Los filtros son ciertos conjuntos de reglas que pueden ser aplicados a una ruta. Pueden ser aplicados
antes o después de que se ejecute la lógica de una ruta. No obstante, descubrirás que los filtros que
se ejecutan antes son más útiles. Estos filtros pueden alterar el flujo de la aplicación si no se cumplen
una serie de reglas o criterios. Es una forma maravillosa de proteger nuestras rutas.
<?php
// app/filters.php
Route::filter('cumpleanos', function()
{
if (date('d/m') == '12/12') {
return View::make('cumpleanos');
}
});
Aquí tenemos nuestro primer filtro. Laravel nos da un archivo en app/filters.php como ubicación
genérica para nuestros filtros, pero podemos ponerlos donde queramos.
Usamos el método Route::filter() para crear un nuevo filtro. El primer parámetro es un nombre
amistoso que usaremos más tarde para aisgnar el filtro a una ruta. En este ejemplo he nombrado al
filtro cumpleanos . El segundo parámetro es un callback, que en este ejemplo es una Closure.
El callback es una función que es llamada cuando se ejecuta el filtro. Si devuelve un objeto de tipo
respuesta, como aquellos que usamos en la lógica de nuesutra ruta, la respuesta será devuelta y
servida en vez del resultado de la lógica de nuestra ruta. Si no hay respuesta desde el filtro, la lógica
de la ruta continuará normalmente.
<?php
// app/routes.php
Route::get('/', array(
'before' => 'cumpleanos',
function()
{
return View::make('hola');
}
));
Como puedes ver, hemos creado otra opción en nuestra matriz. El índice before le dice al framework
que queremos ejecutar nuestro filtro cumpleanos antes de que la lógica de la ruta sea ejecutada. El
valor cumpleanos es igual al apodo que le dimos a nuestro filtro.
Vamos a probar a ejecutar nuestra ruta / . Ahora, asumiendo que hoy no es el 12 de Diciembre, verás
la página de Laravel. Esto es porque la condición del filtro ha fallado y no se devuelve ninguna
respuesta.
antes o después de que se ejecute la lógica de una ruta. No obstante, descubrirás que los filtros que
se ejecutan antes son más útiles. Estos filtros pueden alterar el flujo de la aplicación si no se cumplen
una serie de reglas o criterios. Es una forma maravillosa de proteger nuestras rutas.
<?php
// app/filters.php
Route::filter('cumpleanos', function()
{
if (date('d/m') == '12/12') {
return View::make('cumpleanos');
}
});
Aquí tenemos nuestro primer filtro. Laravel nos da un archivo en app/filters.php como ubicación
genérica para nuestros filtros, pero podemos ponerlos donde queramos.
Usamos el método Route::filter() para crear un nuevo filtro. El primer parámetro es un nombre
amistoso que usaremos más tarde para aisgnar el filtro a una ruta. En este ejemplo he nombrado al
filtro cumpleanos . El segundo parámetro es un callback, que en este ejemplo es una Closure.
El callback es una función que es llamada cuando se ejecuta el filtro. Si devuelve un objeto de tipo
respuesta, como aquellos que usamos en la lógica de nuesutra ruta, la respuesta será devuelta y
servida en vez del resultado de la lógica de nuestra ruta. Si no hay respuesta desde el filtro, la lógica
de la ruta continuará normalmente.
<?php
// app/routes.php
Route::get('/', array(
'before' => 'cumpleanos',
function()
{
return View::make('hola');
}
));
Como puedes ver, hemos creado otra opción en nuestra matriz. El índice before le dice al framework
que queremos ejecutar nuestro filtro cumpleanos antes de que la lógica de la ruta sea ejecutada. El
valor cumpleanos es igual al apodo que le dimos a nuestro filtro.
Vamos a probar a ejecutar nuestra ruta / . Ahora, asumiendo que hoy no es el 12 de Diciembre, verás
la página de Laravel. Esto es porque la condición del filtro ha fallado y no se devuelve ninguna
respuesta.
jueves, 23 de octubre de 2014
Vistas en laravel
Una vista es simplemente una plantilla de texto plano que puede ser devuelta al navegador, aunque
es muy probable que tus vistas contengan HTML. Las vistas usan la extensión .php y normalmente
están ubicadas dentro del directorio app/views . Esto significa que puedes parsear código PHP también
en las vistas.
<!-- app/views/simple.php -->
<!doctype html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>¡Vistas!</title>
</head>
<body>
<p>¡Oh sí! ¡VISTAS!</p>
</body>
</html>
¡Genial! Un pequeño trozo de HTML guardado en app/views/simple.php . Ahora hagamos una vista.
ruta.:get('/', function()
{
return View::make('simple');
});
Usando el método View::make() podemos crear una nueva instancia de un objeto de respuesta View .
El primer parámetro que pasamos al método make() es la plantilla de la vista que queremos usar.
Habrás observado que no usamos la ruta completa app/views/simple.php . Esto es porque Laravel
es inteligente. Por defecto asumirá que tus vistas están ubicadas en app/views y buscará un archivo
con una extensión apropiada para una vista.
Si miras con detenimiento la Closure verás que el objeto View que hemos creado está siendo devuelto.
Esto es muy importante ya que Laravel servirá el contenido de la closure al navegadore web.
Datos de la vista
Poder mostrar plantillas es increíble. Realmente lo es. ¿Qué pasa si queremos usar algunos datos de
nuestra Closure? En un capítulo anterior hemos aprendido cómo podemos usar parámetros en las
rutas. Quizá queramos poder referirnos a esos parámetros en la Vista. Echemos un vistazo a cómo
podríamos hacer eso.
<?php
// app/routes.php
ruta.:get('/{ardilla}', function($ardilla)
{
$data['ardilla'] = $ardilla;
return View::make('simple', $data);
});
Redirecciones
<?php
// app/routes.php
ruta.:get('primera', function()
{
return Redirect::to('segunda');
});
ruta.:get('segunda', function()
{
return 'Segunda ruta.';
});
En la primera ruta, estamos ahora devolviendo el resultado del método Redirect::to() y pasando la
URI de la ubicación del objetivo. En este caso estamos pasando la URI para la segunda ruta, segunda
como la ubicación.
Esto puede ser muy útil cuando alguna condición de algún tipo ha fallado y tienes que redirigir
al usuario a una ubicación más útil. He aquí un ejemplo usando el sistema de autenticación (que
cubriremos más tarde) que te dará otro caso de uso.
<?php
// app/routes.php
ruta.:get('libros', function()
{
if (Auth::guest()) return Redirect::to('login');
// Solo mostramos los libros a los usuarios logados
});
Response personalizado
<?php
// app/routes.php
ruta.:get('respuesta/personalizada', function()
{
return Response::make('¡Hola mundo!', 200);
})
<?php
// app/routes.php
ruta.:get('respuesta/markdown', function()
{
$response = Response::make('***algo de texto en negrita***', 200);
$response->headers->set('Content-Type', 'text/x-markdown');
return $response;
});
es muy probable que tus vistas contengan HTML. Las vistas usan la extensión .php y normalmente
están ubicadas dentro del directorio app/views . Esto significa que puedes parsear código PHP también
en las vistas.
<!-- app/views/simple.php -->
<!doctype html>
<html lang="es">
<head>
<meta charset="UTF-8">
<title>¡Vistas!</title>
</head>
<body>
<p>¡Oh sí! ¡VISTAS!</p>
</body>
</html>
¡Genial! Un pequeño trozo de HTML guardado en app/views/simple.php . Ahora hagamos una vista.
ruta.:get('/', function()
{
return View::make('simple');
});
Usando el método View::make() podemos crear una nueva instancia de un objeto de respuesta View .
El primer parámetro que pasamos al método make() es la plantilla de la vista que queremos usar.
Habrás observado que no usamos la ruta completa app/views/simple.php . Esto es porque Laravel
es inteligente. Por defecto asumirá que tus vistas están ubicadas en app/views y buscará un archivo
con una extensión apropiada para una vista.
Si miras con detenimiento la Closure verás que el objeto View que hemos creado está siendo devuelto.
Esto es muy importante ya que Laravel servirá el contenido de la closure al navegadore web.
Datos de la vista
Poder mostrar plantillas es increíble. Realmente lo es. ¿Qué pasa si queremos usar algunos datos de
nuestra Closure? En un capítulo anterior hemos aprendido cómo podemos usar parámetros en las
rutas. Quizá queramos poder referirnos a esos parámetros en la Vista. Echemos un vistazo a cómo
podríamos hacer eso.
<?php
// app/routes.php
ruta.:get('/{ardilla}', function($ardilla)
{
$data['ardilla'] = $ardilla;
return View::make('simple', $data);
});
Redirecciones
<?php
// app/routes.php
ruta.:get('primera', function()
{
return Redirect::to('segunda');
});
ruta.:get('segunda', function()
{
return 'Segunda ruta.';
});
En la primera ruta, estamos ahora devolviendo el resultado del método Redirect::to() y pasando la
URI de la ubicación del objetivo. En este caso estamos pasando la URI para la segunda ruta, segunda
como la ubicación.
Esto puede ser muy útil cuando alguna condición de algún tipo ha fallado y tienes que redirigir
al usuario a una ubicación más útil. He aquí un ejemplo usando el sistema de autenticación (que
cubriremos más tarde) que te dará otro caso de uso.
<?php
// app/routes.php
ruta.:get('libros', function()
{
if (Auth::guest()) return Redirect::to('login');
// Solo mostramos los libros a los usuarios logados
});
Response personalizado
<?php
// app/routes.php
ruta.:get('respuesta/personalizada', function()
{
return Response::make('¡Hola mundo!', 200);
})
<?php
// app/routes.php
ruta.:get('respuesta/markdown', function()
{
$response = Response::make('***algo de texto en negrita***', 200);
$response->headers->set('Content-Type', 'text/x-markdown');
return $response;
});
Enrutado basico
Para accesar a
http://dominio.com/mi/pagina
Las rutas son definidas en el archivo app/routes.php , así que
vamos allá y creemos una ruta que escuche la petición que hemos mencionado arriba.
<?php
// app/routes.php
Route::get('mi/pagina', function() {
return '¡Hola mundo!';
});
Las rutas están siempre declaradas usando la clase Route . Eso es lo que tenemos al principio, antes
de :: . La parte get es el método que usamos para ‘capturar’ las peticiones que son realizadas usando
el verbo ‘GET’ de HTTP hacia una URL concreta.
Otros métodos
<?php
// app/routes.php
Route::get();
Route::post();
Route::put();
Route::delete();
Route::any();
Todos esos métodos aceptan los mismo parámetros, por lo que puedes usar cualquier método HTTP
que sea apropiado para la situación. Esto es conocido como enrutado REST .
Route::get('mi/pagina', function() {
return '¡Hola mundo!';
});
La siguiente porción del código es el primer parámetro del método get() (o cualquier otro verbo).
Este parámetro define la URI con la que quieres hacer coincidir la URL. En este caso estamos
haciendo coincidir mi/pagina .
El parámetro final es usado para ofrecer lógica para gestionar la petición. Aquí estamos usando
una Closure , que también es conocida como una función anónima . Las closures son simplemente
funciones sin nombre que pueden ser asignadas a variables, como lo haríamos con cualquier valor.
Las URLs pueden tener tantos segmentos (partes entre las barras) como quieras. Puedes usarlo para
construir una jerarquía en el sitio.
Considera la siguiente estructura:
Route::get('/', function() {});
// Rutas para la sección de libros
Route::get('/libros', function() {});
Route::get('/libros/ficcion', function() {});
Route::get('/libros/ciencia', function() {});
Route::get('/libros/romance', function() {});
// Rutas para la sección de revistas
Route::get('/revistas', function() {});
Route::get('/revistas/celebridades', function() {});
Route::get('/revistas/tecnologia', function() {});
Parámetros de las rutas
Los parámetros de las rutas pueden ser utilziados para introducir valores de relleno en tus
definiciones de ruta. Esto creará un patrón sobre el cual podamos recoger segmentos de la URI y
pasarlos al gestor de la lógica de la aplicación.
Esto puede sonar un poco confuso, pero cuando lo veas en acción todo tendrá sentido. Allá vamos.
<?php
// app/routes.php
// routes for the books section
Route::get('/libros', function()
{
return 'Índice de libros.';
});
Route::get('/libros/{genero}', function($genero)
{
return "Libros en la categoría {$genero}.";
})
http://dominio.com/mi/pagina
Las rutas son definidas en el archivo app/routes.php , así que
vamos allá y creemos una ruta que escuche la petición que hemos mencionado arriba.
<?php
// app/routes.php
Route::get('mi/pagina', function() {
return '¡Hola mundo!';
});
Las rutas están siempre declaradas usando la clase Route . Eso es lo que tenemos al principio, antes
de :: . La parte get es el método que usamos para ‘capturar’ las peticiones que son realizadas usando
el verbo ‘GET’ de HTTP hacia una URL concreta.
Otros métodos
<?php
// app/routes.php
Route::get();
Route::post();
Route::put();
Route::delete();
Route::any();
Todos esos métodos aceptan los mismo parámetros, por lo que puedes usar cualquier método HTTP
que sea apropiado para la situación. Esto es conocido como enrutado REST .
Route::get('mi/pagina', function() {
return '¡Hola mundo!';
});
La siguiente porción del código es el primer parámetro del método get() (o cualquier otro verbo).
Este parámetro define la URI con la que quieres hacer coincidir la URL. En este caso estamos
haciendo coincidir mi/pagina .
El parámetro final es usado para ofrecer lógica para gestionar la petición. Aquí estamos usando
una Closure , que también es conocida como una función anónima . Las closures son simplemente
funciones sin nombre que pueden ser asignadas a variables, como lo haríamos con cualquier valor.
Las URLs pueden tener tantos segmentos (partes entre las barras) como quieras. Puedes usarlo para
construir una jerarquía en el sitio.
Considera la siguiente estructura:
Route::get('/', function() {});
// Rutas para la sección de libros
Route::get('/libros', function() {});
Route::get('/libros/ficcion', function() {});
Route::get('/libros/ciencia', function() {});
Route::get('/libros/romance', function() {});
// Rutas para la sección de revistas
Route::get('/revistas', function() {});
Route::get('/revistas/celebridades', function() {});
Route::get('/revistas/tecnologia', function() {});
Parámetros de las rutas
Los parámetros de las rutas pueden ser utilziados para introducir valores de relleno en tus
definiciones de ruta. Esto creará un patrón sobre el cual podamos recoger segmentos de la URI y
pasarlos al gestor de la lógica de la aplicación.
Esto puede sonar un poco confuso, pero cuando lo veas en acción todo tendrá sentido. Allá vamos.
<?php
// app/routes.php
// routes for the books section
Route::get('/libros', function()
{
return 'Índice de libros.';
});
Route::get('/libros/{genero}', function($genero)
{
return "Libros en la categoría {$genero}.";
})
Directorio de aplicacion en laravel
El directorio de la aplicación
Aquí es donde tu aplicación toma forma. Es el directorio en el cual pasarás la mayor parte de tu
tiempo. Por este motivo, ¿por qué no os conocéis mejor?
commands
Este directorio contiene cualquier comando personalizado de Artisan que pueda necesitar tu
aplicación. Como verás, Artisan no solo ofrece funcionalidad por defecto para ayudarte a construir
tu proyecto, si no que también te ofrece la oportunidad de crear tus propios comandos para hacer
cosas.
config
La configuración tanto para el framework como para tu aplicación se mantiene en este directorio.
La configuración de Laravel existe como un conjunto de archivos PHP que contienen matrices clave-valor. Este directorio también contiene sub-directorios que permiten distintas configuraciones
cargadas en diferentes entornos.
controllers
Como el nombre sugiere, este directorio contendrá tus controladores. Los controladores pueden ser
usados para facilitar lógica a la aplicación, y hacer de pegamento entre las partes separadas de tu
aplicación. Este directorio ha sido añadido al archivo composer.json por defecto para la auto carga
de clases.
database
Si escoges una base de datos como método para guardar cosas a largo plazo, este directorio sera
usado para contener los archivos que crearán el esquema de tu base de datos, y los métodos para
completarla con datos de ejemplo. La base de datos por defecto en SQLite también está ubicada en
este directorio.
lang
El directorio lang contiene archivos PHP con matrices de cadenas que pueden ser usados para dar
soporte de traducción a tu aplicación. Se pueden crear sub carpetas por región para que tengas
distintos ficheros para múltiples idiomas.
models
Este directorio contendrá tus modelos. ¿Sorprendido? Los modelos son usados para representar el
modelo de negocio o facilitar interacción con el almacenamiento. ¿Confundido? No te preocupes,
cubriremos los modelos con más detalle en un capítulo posterior. Debes saber que hay un modelo
User para ofrecerte autenticación en la aplicación por defecto. Al igual que el directorio controllers ,
este ha sido añadido a la sección de carga automática del archivo composer.json por defecto.
start
Mientras que el directorio bootstrap contiene los procedimientos de arranque que pertenecen al
framework, el directorio start contiene procedimientos de arranque que pertenecen a tu aplicación.
Como siempre, se ofrecen algunos por defecto.
storage
Cuando Laravel necesita escribir algo en el disco, lo hace en el directorio storage . Por este motivo
tu servidor web debe poder escribir en esta ubicación.
tests
El directorio tests contiene todas las pruebas unitarias y de aceptación para tu aplicación. La
configuración por defecto de PHPUnit que ha sido incluida por Laravel buscará pruebas en este
directorio por defecto.
views
El directorio views es usado para contener las plantillas visuales de tu aplicación. Se facilita una
vista hello por defecto para tu conveniencia.
filters.php
El archivo filters.php es usado para contener cualquier filtro de rutas de tu aplicación. Descubrirás
más sobre los filtros en un capítulo futuro.
routes.php
El archivo routes contiene todas las rutas de tu aplicación.
Aquí es donde tu aplicación toma forma. Es el directorio en el cual pasarás la mayor parte de tu
tiempo. Por este motivo, ¿por qué no os conocéis mejor?
- commands/
- config/
- controllers/
- database/
- lang/
- models/
- start/
- storage/
- tests/
- views/
- filters.php
- routes.php
commands
Este directorio contiene cualquier comando personalizado de Artisan que pueda necesitar tu
aplicación. Como verás, Artisan no solo ofrece funcionalidad por defecto para ayudarte a construir
tu proyecto, si no que también te ofrece la oportunidad de crear tus propios comandos para hacer
cosas.
config
La configuración tanto para el framework como para tu aplicación se mantiene en este directorio.
La configuración de Laravel existe como un conjunto de archivos PHP que contienen matrices clave-valor. Este directorio también contiene sub-directorios que permiten distintas configuraciones
cargadas en diferentes entornos.
controllers
Como el nombre sugiere, este directorio contendrá tus controladores. Los controladores pueden ser
usados para facilitar lógica a la aplicación, y hacer de pegamento entre las partes separadas de tu
aplicación. Este directorio ha sido añadido al archivo composer.json por defecto para la auto carga
de clases.
database
Si escoges una base de datos como método para guardar cosas a largo plazo, este directorio sera
usado para contener los archivos que crearán el esquema de tu base de datos, y los métodos para
completarla con datos de ejemplo. La base de datos por defecto en SQLite también está ubicada en
este directorio.
lang
El directorio lang contiene archivos PHP con matrices de cadenas que pueden ser usados para dar
soporte de traducción a tu aplicación. Se pueden crear sub carpetas por región para que tengas
distintos ficheros para múltiples idiomas.
models
Este directorio contendrá tus modelos. ¿Sorprendido? Los modelos son usados para representar el
modelo de negocio o facilitar interacción con el almacenamiento. ¿Confundido? No te preocupes,
cubriremos los modelos con más detalle en un capítulo posterior. Debes saber que hay un modelo
User para ofrecerte autenticación en la aplicación por defecto. Al igual que el directorio controllers ,
este ha sido añadido a la sección de carga automática del archivo composer.json por defecto.
start
Mientras que el directorio bootstrap contiene los procedimientos de arranque que pertenecen al
framework, el directorio start contiene procedimientos de arranque que pertenecen a tu aplicación.
Como siempre, se ofrecen algunos por defecto.
storage
Cuando Laravel necesita escribir algo en el disco, lo hace en el directorio storage . Por este motivo
tu servidor web debe poder escribir en esta ubicación.
tests
El directorio tests contiene todas las pruebas unitarias y de aceptación para tu aplicación. La
configuración por defecto de PHPUnit que ha sido incluida por Laravel buscará pruebas en este
directorio por defecto.
views
El directorio views es usado para contener las plantillas visuales de tu aplicación. Se facilita una
vista hello por defecto para tu conveniencia.
filters.php
El archivo filters.php es usado para contener cualquier filtro de rutas de tu aplicación. Descubrirás
más sobre los filtros en un capítulo futuro.
routes.php
El archivo routes contiene todas las rutas de tu aplicación.
miércoles, 22 de octubre de 2014
JSON
JSON significa JavaScript Object Notation o Notación de Objetos de JavaScript. Fue nombrado de
esta forma porque JavaScript fue el primer lenguaje en sacar provecho de este formato.
JSON Syntax
{"nombre":"Lushui","especie":"Panda","dieta":"Cosas verdes","edad":7,"colores":["\
red","marron","blanco"]}
Las cadenas JSON deben estar contenidas entre comillas dobles
JSON permite estos tipos de valores:
esta forma porque JavaScript fue el primer lenguaje en sacar provecho de este formato.
JSON Syntax
{"nombre":"Lushui","especie":"Panda","dieta":"Cosas verdes","edad":7,"colores":["\
red","marron","blanco"]}
Las cadenas JSON deben estar contenidas entre comillas dobles
JSON permite estos tipos de valores:
- Doble
- Flotante
- Cadena
- Booleano
- Matriz
- Objeto
- Null
Los valores numéricos se representan sin comillas dobles. Ten cuidado al escoger si entrecomillas
un valor o no. Por ejemplo, los códigos postales de Estados Unidos consisten en cinco números. No
obstante, si omitieras las comillas de un código postal, 07702 sería tomado como un entero y sería
truncado a 7702 . Este es un error que se ha cobrado la vida de muchos aventureros de la web.
Los booleanos son representados por las palabras true y false , ambos sin comillas al igual que
en PHP. Como dije antes, los valores de cadenas quedan dentro de comillas dobles y no comillas
simples.
El valor null funciona de forma similar a la que lo hace en PHP, y es representado por la palabra
null sin comillas. ¡Debería ser fácil de recordar!
Hemos visto objetos. Al igual que el objeto JSON principal en sí, están envueltos por llaves y pueden
contener toda variedad de tipos de valores.
Las matrices, lucen de manera muy similar a su contrapartida en JavaScript
// JavaScript
['rojo', 'marron', 'blanco']
["rojo", "marron", "blanco"]
JSON y PHP
Como mencioné antes, desde la versión 5.2.0, PHP ofrece soporte para serializar y deserializar datos
de y hacia el formato JSON. Vamos a ver cómo funciona eso en acción.
Serializando una matriz PHP a JSON
Para serializar un valor PHP solo necesitamos el método json_encode() . Tal que así:
1
<?php
2
3
4
$verdad = array('panda' => '¡Increible!');
echo json_encode($verdad);
El resultado de este fragmento de código será una cadena JSON que contenga el siguiente valor.
{"panda":"¡Increible!"}
¡Bien! Vamos a asegurarnos de que podemos convertir esto de vuelta al formato que pueda ser
entendido por PHP.
Deserializando una matriz PHP desde una cadena JSON
Para ello usaremos el método json_decode . Apuesto a que no lo viste venir.
<?php
2
3
4
$verdad = json_decode('{"panda":"¡Increible!"}');
echo $verdad['panda'];
¡Genial! Allá vam... espera, ¿qué?
1
Fatal error: Cannot use object of type stdClass as array in ...
Como ves, json_decode no devuelve nuestro JSON como matriz PHP; usa un objeto del tipo
stdClass para representar nuestros datos. En vez de ello vamos a acceder a la clave del objeto como
un atributo:
1
<?php
$verdad = json_decode('{"panda":"¡Increible!"}');
echo $verdad->panda;
// ¡Increible!
¡Genial! Eso es lo que queríamos. Si queríamos una matriz, PHP nos ofrece algunas formas de
convertir este objeto en una, pero por suerte, json_decode aun tiene un truco bajo la manga.
Si usas true como segundo parámetro a la función, recibiremos la matriz PHP como esperábamos.
¡Gracias json_decode !
1
<?php
$verdad = json_decode('{"panda":"¡Increible!”}', true);
echo $verdad['panda'];
// ¡Increible!
namespaces
En php no puedes tener dos clases que compartan el mismo nombre, para evitar esto se usan los espacios d enombre que empaquetan dichas clases:
definicion de namespace simple
<?
nameespace Stark;
class Eddard{
}
Podemos instanciar
$eddard = new Stark\Eddard();
o ponioiendo la directiva
<?php
nameespace Stark;
$eddard = new Eddard();
?>
Usando la setencia use, podemos traer una clase de otro espacio de nombre y usamos as como alias
use Tully\Bryden as PezNegro
$edmure = Pez Negro();
Y por medio de alias podemos llamar a clases hijas
use Dayle\Blog as Cms;
$post = new Cms\Content\Post;
$page = new Cms\Content\Page;
definicion de namespace simple
<?
nameespace Stark;
class Eddard{
}
Podemos instanciar
$eddard = new Stark\Eddard();
o ponioiendo la directiva
<?php
nameespace Stark;
$eddard = new Eddard();
?>
Usando la setencia use, podemos traer una clase de otro espacio de nombre y usamos as como alias
use Tully\Bryden as PezNegro
$edmure = Pez Negro();
Y por medio de alias podemos llamar a clases hijas
use Dayle\Blog as Cms;
$post = new Cms\Content\Post;
$page = new Cms\Content\Page;
Suscribirse a:
Entradas (Atom)