- Rutas báscias
- Rutas con parámetros
- Rutas con filtros
- Rutas con nombre
- Grupos de rutas
- Rutas con subdominios
- Rutas con prefijos
- Rutas con modelos de Eloquent
- Generando errores 404
- Rutas con controladores
La mayoría de las rutas para tu aplicación serán definidias en el archivo app/routes.php. La definición de una ruta de Laravel más simple consiste en una URI y una retrollamada a una Clausura.
Route::get('/', function()
{
return 'Hello World';
});
Route::post('foo/bar', function()
{
return 'Hello World';
});
Route::match(array('GET', 'POST'), '/', function()
{
return 'Hello World';
});
Route::any('foo', function()
{
return 'Hello World';
});
Route::get('foo', array('https', function()
{
return 'Must be over HTTPS';
}));
Con frecuencia, necesitará generar URLs para tus rutas, lo puedes hacer usando el método: URL::to.
$url = URL::to('foo');
Route::get('user/{id}', function($id)
{
return 'User '.$id;
});
Route::get('user/{name?}', function($name = null)
{
return $name;
});
Route::get('user/{name?}', function($name = 'John')
{
return $name;
});
Route::get('user/{name}', function($name)
{
//
})
->where('name', '[A-Za-z]+');
Route::get('user/{id}', function($id)
{
//
})
->where('id', '[0-9]+');
Por supuesto, puedes pasar un arreglo de restricciones cuando sea necesario:
Route::get('user/{id}/{name}', function($id, $name)
{
//
})
->where(array('id' => '[0-9]+', 'name' => '[a-z]+'))
Si deseas que el parámetro de una ruta siempre sea restrictiva por una expresión regular, puedes usar el método pattern:
Route::pattern('id', '[0-9]+');
Route::get('user/{id}', function($id)
{
// Only called if {id} is numeric.
});
Si necesitas obtener el valor de algún parámetro de una ruta fuera de la ruta, puedes usar el método Route::input:
Route::filter('foo', function()
{
if (Route::input('id') == 1)
{
//
}
});
Filtros en rutas proveen una manera conveniente para limitar el acceso a la ruta dada, muy útil para definir áreas en tu aplicación que requieren autentificación.
Laravel incluye varios filtros: filtro auth, filtro auth.basic, filtro guest, filtro csrf, los cuales están definidos en el archivo app/filters.php.
Route::filter('old', function()
{
if (Input::get('age') < 200)
{
return Redirect::to('home');
}
});
Si el filtro retorna una respuesta, esa respuesta será considerada la respuesta de la petición y la ruta no será ejecutada. Cualquier filtro después de la ruta tampoco serán ejecutados.
Route::get('user', array('before' => 'old', function()
{
return 'You are over 200 years old!';
}));
Route::get('user', array('before' => 'old', 'uses' => 'UserController@showProfile'));
Route::get('user', array('before' => 'auth|old', function()
{
return 'You are authenticated and over 200 years old!';
}));
Route::get('user', array('before' => array('auth', 'old'), function()
{
return 'You are authenticated and over 200 years old!';
}));
Route::filter('age', function($route, $request, $value)
{
//
});
Route::get('user', array('before' => 'age:200', function()
{
return 'Hello World';
}));
Filtros que se ejecutan después de una ruta tienen disponible un $response como tercer parámetro:
Route::filter('log', function($route, $request, $response)
{
//
});
Puedes también espeficiar que un filtro se ejecute a un conjunto completo de rutas basado en sus URIs.
Route::filter('admin', function()
{
//
});
Route::when('admin/*', 'admin');
En el ejemplo anterior, el filtro admin se aplicará a todas las rutas que empiezen con admin/. El asterisco es usado como un comodín y coincidará cualquier combinación de carácteres.
También puedes restringir la ejecución de filtros basados en patrones por verbos HTTPs.
Route::when('admin/*', 'admin', array('post'));
Para filtros avanzados, tal vez desees usar una clase en vez de una Clausura. Como las clases para filtros son resueltas fuera del contenedor IoC de la aplicación, podrás utilizar inyección de dependencias en estos filtros para mejorar la capacidad de pruebas.
Route::filter('foo', 'FooFilter');
De forma predeterminada, el método filter en la clase FooFilter será ejecutado:
class FooFilter {
public function filter()
{
// Filter logic...
}
}
Si no desea usar el método filter, simplemente específica otro:
Route::filter('foo', 'FooFilter@foo');
Rutas con nombre hacen que la referencia a rutas cuando se generan redirecciones o URLs sea mucho más conveniente.
Route::get('user/profile', array('as' => 'profile', function()
{
//
}));
También puedes especificar nombres de rutas para acciones en controladores
Route::get('user/profile', array('as' => 'profile', 'uses' => 'UserController@showProfile'));
Ahora, puedes usar el nombre de la ruta cuando generes URLs o redirecciones:
$url = URL::route('profile');
$redirect = Redirect::route('profile');
Puedes acceder al nombre de una ruta que se está ejecutando a través del método currentRouteName
$name = Route::currentRouteName();
Algunas veces podrías necesitar aplicar un filtro a un grupo de rutas. En vez de especificarlos para cada ruta, puedes hacer para un grupo de rutas:
Route::group(array('before' => 'auth'), function()
{
Route::get('/', function()
{
// Has Auth Filter
});
Route::get('user/profile', function()
{
// Has Auth Filter
});
});
Puedes usar el parámetro namespace en el arreglo de la definición del grupo de rutas para especificar que todos los controladores dentro del grupo pertenecen al mismo namespace:
Route::group(array('namespace' => 'Admin'), function()
{
//
});
Las rutas en Laravel son capaces de manejar comódines en sub-dominios y definir parámetros de comódines desde el dominio principal:
Route::group(array('domain' => '{account}.myapp.com'), function()
{
Route::get('user/{id}', function($account, $id)
{
//
});
});
Un grupo de rutas pueden usar la opción prefix en el arreglo de sus atributos para definir un prefijo a todo el grupo:
Route::group(array('prefix' => 'admin'), function()
{
Route::get('user', function()
{
//
});
});
Vincular modelos provee una manera conveniente para inyectar instancias del modelo en las rutas. Por ejemplo, en vez de inyectar el ID de un usuario, puedes inyectar el modelo Usuario completo que concuerde con un ID dado. Primero, usa el método Route::model() para especificar el modelo que será usado para un parámetro dado:
Route::model('user', 'User');
A continuación, defina una ruta que contenga el parámetro {user}:
Route::get('profile/{user}', function(User $user)
{
//
});
Como hemos vinculado el parámetro {user} al modelo User, una instancia User será inyectado a la ruta. Así, por ejemplo, una petición a profile/1 inyectará una instancia con el ID igual a 1.
Note: Si una instancia del modelo no se encuentra en la base de datos, se ejecutará un error 404.
Si deseas especificar tu propia implementación de un modelo no encontrado, puedes pasar una Clausura como tercer parámetro del método model:
Route::model('user', 'User', function()
{
throw new NotFoundException;
});
Algunas veces deseas usar tu propia forma de resolver los parámetros de las rutas. Simplemente usa el método Route::bing:
Route::bind('user', function($value, $route)
{
return User::where('name', $value)->first();
});
Existen dos formas de ejecutar un error 404 desde una ruta. Primero, puedes usar el método App::abort:
App::abort(404);
Segundo, ejecutar una instancia de Symfony\Component\HttpKernel\Exception\NotFoundHttpException.
Más información acerca del manejo de excepciones 404 y utilizar respuestas personalizadas para estos errores puede ser encontrada en la sección de errores de la documentación.
Laravel permite no solo definir rutas con Clausuras, sino también con clases de Controladores, incluso permite la creación de controladores de recursos.
Consulta la documentación en Controladores para más detalles.