Inicio>código fuente PHP>Otras categorias
Descargar

Enrutador @ minasrouter

el

minasrouter es simple, rápido y extremadamente legible para rutas. Crea y gestiona tus rutas en tan solo unos pocos pasos.

Sencillo, rápido y MUY funcional. minasrouter es un componente de rutas PHP para proyectos MVC. Fue creado para abstraer los verbos RESTfull (GET, POST, PUT, PATCH, DELETE) y renderizarlos de una manera sencilla y fácil en el controlador de la aplicación.

minasrouter trabaja y procesa toda la información de forma aislada, facilitando el proceso al desarrollador y acelerando el desarrollo/progreso del proyecto.

Sencillo, rápido y MUY funcional. minasrouter es un componente de rutas PHP para proyectos MVC. Está diseñado para abstraer los verbos RESTfull (GET, POST, PUT, PATCH, DELETE) y representarlos de forma sencilla y sencilla en el controlador de la aplicación.

minasrouter trabaja y procesa toda la información de forma aislada, facilitando el proceso al desarrollador y acelerando el desarrollo/progreso del proyecto.

Destacados @ minasrouter

  • En unos minutos puedes crear rutas para tu aplicación o api (Yes, it really is a few minutes)
  • Sistema de middleware rápido y sencillo
  • Respeta los verbos RESTfull y dispone de estupendas funciones para tratarlos
  • Personalización de rutas, expresiones regulares en parámetros dinámicos y parámetros opcionales.
  • Spoofing para verbalización y control de datos (FormSpoofing)
  • Lleva parámetros dinámicos a los argumentos del controlador.
  • Grupos de enrutamiento sencillos y creación rápida
  • Tiene una Clase de Solicitud para controlar y trabajar con datos de ruta.

¡Con dos líneas empiezas a utilizar rutas!

Ejemplo de aplicación

Tal vez seas una persona que aprende mirando, puedes acceder a la carpeta de ejemplo, que contiene un ejemplo de arquitectura de carpetas de cómo usamos minasrouter .

Pruebas

Puedes consultar todas las pruebas realizadas aquí. ¡Disfrutar!

Instalación

minasrouter está disponible a través de Composer require :

minasrouter": "^1.0" }">
 " require " {
    "nicollassilva/ minasrouter " : " ^1.0 "
}

o ejecutar en la terminal : 

composer require nicollassilva/ minasrouter

Documentación

1.Configuración

  • Redirigir a carpeta pública
  • Configuración de carpeta pública
  • apache
  • nginx

2. Rutas

  • mi primera ruta
  • Verbos REST completos
  • Personalización
  • Rutas con nombre
  • Parámetros dinámicos (requeridos y opcionales)
  • Validar un parámetro dinámico
  • software intermedio
  • Establecer middlewares globales
  • Adjuntar en una ruta
  • Eliminar el middleware
  • Grupos de rutas
  • Todos los métodos
  • Grupo nombrado
  • Grupo prefijado
  • Grupo de espacio de nombres predeterminado
  • Grupo de middleware predeterminado
  • Métodos de grupos anidados
  • Otros
  • Redireccionamiento de ruta
  • Ruta con Middleware Individual en Grupo
  • Ruta con nombre diferente en grupo
  • Rutas alternativas

3. Solicitar ruta

  • Introducción
  • Métodos
  • Ruta de solicitud
  • Solicitar URL
  • Encabezados de solicitud
  • Solicitar dirección IP
  • Recuperar datos
  • Método de solicitud

Introducción

Para comenzar a utilizar minasrouter , toda la gestión de navegación debe redirigirse al archivo de ruta predeterminado de su sistema, el cual realizará todo el proceso de procesamiento de la ruta y devolverá lo configurado por defecto. Configure según los ejemplos siguientes y según su servidor.

Para comenzar a utilizar minasrouter , toda la gestión de navegación debe redirigirse al archivo de ruta predeterminado de su sistema, que hará todo el proceso de manejo de ruta y devolverá lo que estaba configurado de forma predeterminada. Configure según los ejemplos siguientes y según su servidor.

Redirigir a carpeta pública 

 RewriteEngine on
Options All -Indexes

RewriteCond %{HTTPS} on
RewriteCond %{HTTP_HOST} (www.)?localhost
RewriteRule (.*) https:// %{HTTP_HOST} [L,R=301]

RewriteCond %{REQUEST_URI} !public/
RewriteRule (.*) /public/$1 [L]

apache 

 RewriteEngine On
# Options All -Indexes

# Handle Authorization Header
RewriteCond %{HTTP:Authorization} .
RewriteRule .* - [E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]

# URL Rewrite
RewriteCond %{SCRIPT_FILENAME} !-f
RewriteCond %{SCRIPT_FILENAME} !-d
RewriteRule ^(.*)$ index.php?route=/$1 [L,QSA]

# ## Do not use the settings below if you are using developing in a local environment, use only in production.

# # WWW Redirect
# RewriteCond %{HTTP_HOST} !^www. [NC]
# RewriteRule ^ https://www.%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

# # HTTPS Redirect
# RewriteCond %{HTTP:X-Forwarded-Proto} !https
# RewriteCond %{HTTPS} off
# RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]

nginx 

 location / {
  if ( $script_filename !~ "-f" ){
    rewrite ^(.*)$ /index.php?route=/ $1 break;
  }
}

la primera ruta

Para iniciar los componentes:

minasrouterRouterRoute; // The second argument is optional. It separates the Controller and Method from the string // Example: "Controller@method" Route::start("http://yourdomain.com", "@"); Route::get("/", function() { // ... }); // ... all routes here // You will put all your routes before this function Route::execute();">
 <?php
    require __DIR__ . " /../vendor/autoload.php " ;
    
use minasrouter  Router  Route ;

// The second argument is optional. It separates the Controller and Method from the string
// Example: "Controller@method"
Route:: start ( " http://yourdomain.com " , " @ " );

Route:: get ( " / " , function () {
    // ...
});

// ... all routes here

// You will put all your routes before this function
Route:: execute ();

Verbos REST completos

Métodos:

Función Parámetro Parámetro Parámetro
conseguir Cadena $uri $devolución de llamada
correo Cadena $uri $devolución de llamada
poner Cadena $uri $devolución de llamada
parche Cadena $uri $devolución de llamada
borrar Cadena $uri $devolución de llamada
fósforo Matriz $httpVerbs Cadena $uri $devolución de llamada
cualquier Cadena $uri $devolución de llamada

Ejemplo: 

Route:: get ( ' /users ' , [ App  Controllers User::class, ' index ' ]);
Route:: post ( ' /users ' , [ App  Controllers User::class, ' store ' ]);
Route:: put ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: patch ( ' /users/{id} ' , [ App  Controllers User::class, ' update ' ]);
Route:: delete ( ' /users/{id} ' , [ App  Controllers User::class, ' delete ' ]);

// The router allows you to register routes that respond to any HTTP verb:
Route:: any ( ' / ' , function () {
    // ...
});

// Sometimes you may need to register a route that responds to multiple HTTP verbs:
Route:: match ([ " GET " , " POST " ], " / " , function () {
    // ...
});

Rutas con nombre

Métodos:

Función Parámetro
nombre Cadena $nombre
hacia Cadena $nombre

Ejemplo: 

Route:: get ( " /users/create " , function () {
    // ...
})-> name ( " user.create " );

Route:: get ( " /users/2 " , function () {
    // ...
})-> as ( " user.show " );

Parámetros dinámicos (requeridos y opcionales) 

Route:: get ( " / " , function () {
    // ...
})-> name ( " web.index " );

Route:: get ( " /user/{id} " , function ( $ id ) {
    echo $ id ;
})-> name ( " user.show " );

Route:: get ( " /post/{id?} " , function ( $ id ) {
    if (! $ id ) {
        // ...
    }
    
    // ...
})-> name ( " post.show " );

Validar un parámetro dinámico

Métodos:

Función Parámetro Parámetro
dónde matriz $parametros
dondeParam Cadena $param Cadena $ expresión regular
dondeNúmero Cadena $param
dondeAlfa Cadena $param
dondeAlfanumérico Cadena $param
dondeUuid Cadena $param

Ejemplo: 

Route:: get ( " /user/{id} " , [ App  Controllers UserController::class, " show " ])
    -> name ( " user.show " )
    -> where ([ " id " => " [0-9]+ " ]);

// whereParam is alias of where method
Route:: get ( " /profile/{slug} " , [ App  Controllers UserController::class, " profile " ])
    -> name ( " user.profile " )
    -> whereParam ( " id " , " [0-9]+ " );

Route:: get ( " /book/{id} " , [ App  Controllers BookController::class, " show " ])
    -> name ( " book.show " )
    -> whereNumber ( " id " );

software intermedio

Trabajar con middlewares por aquí es bastante fácil, solo necesitamos pasar los nombres completos de las clases o configurarlas como globales y, a partir de ahí, usamos su alias.

Establecer middlewares globales

NOTA: Es importante que coloques todas las rutas a continuación. Las rutas por encima de esta clase no tendrán estos middlewares como globales. 

Route:: globalMiddlewares ([
    ' isLogged ' =>  App  Middlewares isLogged::class,
    ' isAdmin ' =>  App  Middlewares isAdmin::class
]);

// ... all routes

Adjuntar en una ruta

Puede utilizar el método middleware para asignar middleware a una ruta. 

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " isLogged " );

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ([ " isLogged " ]);

Puede asignar varios middleware a la ruta pasando una serie de nombres de middleware al método de middleware. 

Route:: get ( " /musics " , function () {
    // ...
})-> middleware ( " first, second " );

Route:: get ( " /movies " , function () {
    // ...
})-> middleware ([ " first " , " second " ]);

Al asignar middleware, también puede pasar el nombre de clase completo: 

 use App  Middlewares  VerifyCsrfToken ;

Route:: get ( " /series " , function () {
    // ...
})-> middleware (VerifyCsrfToken::class);

Route:: get ( " /series " , function () {
    // ...
})-> middleware ( App  Middlewares VerifyCsrfToken::class);

Eliminar el middleware

A veces creas un grupo de rutas con middleware, pero quieres que solo una o algunas rutas no tengan un middleware específico, puedes hacerlo. 

Route:: middleware ([ ' auth ' , ' api ' ])-> group ( function () {
    Route:: get ( ' / ' , function () {
        // All middlewares will works in this route
    });
    
    Route:: get ( ' /no-api ' , function () {
        // Only the auth middleware works here
    })-> withoutMiddleware ( ' api ' );
});

Grupos de rutas

Todos los métodos:

Función Parámetro ::función ->función
espacio de nombres Cadena $ espacio de nombres Sí Sí
prefijo Cadena $prefijo Sí Sí
nombre Cadena $nombre Sí Sí
software intermedio Cadena $middlewares Sí Sí

Los métodos de grupo se pueden llamar de forma estática o normal, no olvide llamar a un grupo de funciones para insertarlo como rutas dentro del cierre.

Ejemplos:

grupo nombrado 

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " / " , function () {
        // admin.index
    })-> name ( " index " );
});

grupo prefijado 

Route:: prefix ( " admin/ " )-> group ( function () {
    Route:: get ( " /index " , function () {
        // http://localhost/admin/index
    })-> name ( " index " );
});

Grupo de espacio de nombres predeterminado 

Route:: namespace ( " AppControllers " )-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
    // AppControllersUser
});

Grupo de middleware predeterminado 

Route:: middleware ( App  Middlewares isLogged::class)-> group ( function () {
    Route:: get ( " /user/{id} " , [ " User " , " show " ])-> name ( " show " );
});

Métodos de grupo anidados 

Route:: namespace ( " AppControllersAdmin " )
    -> middleware ([ " isLogged " , " isAdmin " ])
    -> name ( " admin. " )
    -> prefix ( " admin " )
    -> group ( function () {
    // ...
});

Otros

Ruta con Middleware Individual en grupo

Puede utilizar rutas con middlewares individuales dentro de un grupo de rutas. 

Route:: namespace ( " isLogged " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // ...
    })-> middleware ( " isAdmin " );
    
    // ...
});

Ruta con nombre diferente en grupo

Tal vez quieras una ruta en la que ignores el nombre del grupo, puedes usar el segundo parámetro del método de nombre para eso. 

Route:: name ( " admin. " )-> group ( function () {
    Route:: get ( " /posts " , function () {
        // name: app.posts
    })-> name ( " app.posts " , true );
});

Redirección de ruta

Métodos:

Función Parámetro Parámetro Parámetro
redirigir Cadena $uri Cadena $redireccionamiento Int $ código de estado = 302
redirección permanente Cadena $uri Cadena $redireccionamiento

Ejemplo: 

 // Returns 302 status code by default.
Route:: redirect ( " /here " , " /there " );

Route:: redirect ( " /here " , " /there " , 301 );

// permanentRedirect always returns 301
Route:: permanentRedirect ( " /here " , " /there " );

// You can return an existing route
Route:: redirect ( " /index " , " web.index " );

Rutas alternativas

La ruta alternativa es responsable cuando no hay ninguna ruta registrada con esa dirección URL. Siempre que no haya una ruta solicitada por el usuario, se llamará a la ruta alternativa. 

Route:: fallback ( function () {
    echo ' Route error! ' ;
    // ...
});

NOTA: Tenga cuidado si desea redirigir a una ruta existente, si contiene argumentos dinámicos, devolverá la expresión regular completa y provocará un error.

Tenga cuidado al redirigir a una ruta existente, porque si tiene argumentos dinámicos, devolverá la expresión regular completa y devolverá el error.

Solicitar ruta

Cada vez que se llama a la ruta y se llama al método de Cierre o controlador, tendrás como parámetro una instancia de minasrouter HttpRequest. Si la ruta tiene parámetros dinámicos (obligatorios u opcionales), deben pasarse antes de recibir la instancia de Solicitud.

Función Parámetro Parámetro
obtener parámetros
camino
URL
URL completa
encabezamiento cadena $encabezado Cadena $predeterminada
tiene encabezado cadena $encabezado
IP
consulta ?Cadena $consulta ?Cadena $predeterminado
todo ?Cadena $excepto
obtener método
esMétodo Cadena $ método esperado

Los parámetros dinámicos de la ruta se pasan directamente en el método junto con una instancia de Solicitud.

Ejemplo:

minasrouterHttpRequest; Route::get("/", function(Request $request)) { // ... }); Route::get("/user/{id}", function($id, Request $request)) { // ... }); Route::get("/posts/{slug?}", function($slug, Request $request)) { // ... }); Route::get("/book/{slug}", function($slug, Request $request) { // Retrieving all dynamic parameters print_r($request->getParams()); }); ">
 use  minasrouter  Http  Request ;

Route:: get ( " / " , function ( Request $ request )) {
   // ... 
});

Route:: get ( " /user/{id} " , function ( $ id , Request $ request )) {
   // ... 
});

Route:: get ( " /posts/{slug?} " , function ( $ slug , Request $ request )) {
   // ... 
});

Route:: get ( " /book/{slug} " , function ( $ slug , Request $ request ) {
    // Retrieving all dynamic parameters
    print_r ( $ request -> getParams ());
});

El método de solicitud es el método que tiene todos los datos del formulario, los parámetros de consulta, los parámetros de ruta dinámica y el encabezado de solicitud completo.

Métodos de solicitud

Recuperar la ruta de solicitud

El método de ruta devuelve la información de la ruta de la solicitud. Entonces, si la solicitud entrante está dirigida a http://localhost/foo/bar , el método de ruta devolverá foo/bar : 

 $ uri = $ request -> path ();

Recuperar la URL de solicitud

Para recuperar la URL completa de la solicitud entrante, puede utilizar los métodos url o fullUrl . El método url devolverá la URL sin la cadena de consulta, mientras que el método fullUrl incluye la cadena de consulta: 

 $ url = $ request -> url ();

$ urlWithQueryString = $ request -> fullUrl ();

Encabezados de solicitud

Puede recuperar un encabezado de solicitud de la instancia minasrouter HttpRequest utilizando el método de encabezado. Si el encabezado no está presente en la solicitud, se devolverá nulo. Sin embargo, el método del encabezado acepta un segundo argumento opcional que se devolverá si el encabezado no está presente en la solicitud: 

 $ value = $ request -> header ( " Header-Name " );

$ value = $ request -> header ( " Header-Name " , " default " );

El método hasHeader se puede utilizar para determinar si la solicitud contiene un encabezado determinado: 

 if ( $ request -> hasHeader ( " Header-Name " )) {
    // ...
}

El método BearerToken se puede utilizar para recuperar un token de portador del encabezado de Autorización. Si no existe dicho encabezado, se devolverá nulo. 

 $ token = $ request -> bearerToken ();

Solicitar dirección IP

El método ip se puede utilizar para recuperar la dirección IP del cliente que realizó la solicitud a su sitio web: 

 $ ipAddress = $ request -> ip ();

Recuperar datos

El método de consulta solo recuperará valores de la cadena de consulta: 

 $ id = $ request -> query ( " id " );

Si los datos del valor de la cadena de consulta solicitada no están presentes, se devolverá el segundo argumento de este método: 

 $ developer = $ request -> query ( " developer " , " Nicollas " );

Puede llamar al método de consulta sin ningún argumento para recuperar todos los valores de la cadena de consulta. 

 $ query = $ request -> query ();

Puede acceder a los datos de entrada y de queryString directamente, como las propiedades de la clase Solicitud.

minasrouter"> $title = $request->title;">
 // http://localhost/?foo=bar

$ foo = $ request -> foo ;

// <input type="text" name="title" value=" minasrouter ">

$ title = $ request -> title ;

Puede recuperar todos los datos de entrada de la solicitud entrante como una matriz utilizando el método all. Este método se puede utilizar independientemente de si la solicitud entrante proviene de un formulario HTML o es una solicitud XHR. Si desea anular algunos datos, puede pasarlos como segundo parámetro. 

 $ data = $ request -> all ();

// all, except csrf_token, page
$ data = $ request -> all ( " csrf_token, page " );

Recuperar el método de solicitud

El método getMethod devolverá el verbo HTTP de la solicitud. Puede utilizar el método isMethod para verificar que el verbo HTTP coincida con una cadena determinada: 

 $ httpMethod = $ request -> getMethod ();

if ( $ request -> isMethod ( ' POST ' )) {
    // ...
}
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo