Page d'accueil>Code source PHP>Autres catégories
Télécharger

Routeur @ minasrouter

le

minasrouter est simple, rapide et extrêmement lisible pour les itinéraires. Créez et gérez vos itinéraires en quelques étapes seulement.

Simple, rapide et TRÈS fonctionnel. minasrouter est un composant de routes PHP pour les projets MVC ! Il a été conçu pour extraire les verbes RESTfull (GET, POST, PUT, PATCH, DELETE) et les restituer de manière simple et conviviale dans le contrôleur d'application.

minasrouter fonctionne et traite toutes les informations de manière isolée, ce qui facilite le processus pour le développeur et accélère le développement/la progression du projet.

Simple, rapide et TRÈS fonctionnel. minasrouter est un composant de routes PHP pour les projets MVC ! Il est conçu pour extraire les verbes RESTfull (GET, POST, PUT, PATCH, DELETE) et les restituer simplement et facilement dans le contrôleur d'application.

minasrouter fonctionne et traite toutes les informations de manière isolée, facilitant le processus pour le développeur et accélérant le développement/l'avancement du projet.

Faits saillants minasrouter

  • En quelques minutes, vous pouvez créer des routes pour votre application ou API (Yes, it really is a few minutes)
  • Système middleware rapide et facile
  • Respectez les verbes RESTfull et disposez d'excellentes fonctions pour les gérer
  • Personnalisation de l'itinéraire, regex dans les paramètres dynamiques et paramètres facultatifs
  • Spoofing pour la verbalisation et le contrôle des données (FormSpoofing)
  • Transporte des paramètres dynamiques aux arguments du contrôleur
  • Groupes de routage faciles et création rapide
  • Il dispose d'une classe de requête pour contrôler et travailler avec les données d'itinéraire

Avec deux lignes, vous commencez à utiliser des itinéraires !

Exemple d'application

Peut-être que vous êtes une personne qui apprend en regardant, vous pouvez accéder au dossier d'exemple, qui contient un exemple d'architecture de dossiers sur la façon dont nous utilisons minasrouter .

Essais

Vous pouvez vérifier tous les tests effectués ici. Apprécier!

Installation

minasrouter est disponible via Composer require :

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

ou exécutez dans le terminal : 

composer require nicollassilva/ minasrouter

Documentation

1.Configuration

  • Redirection vers un dossier public
  • Configuration des dossiers publics
  • Apache
  • Nginx

2. Itinéraires

  • Mon premier itinéraire
  • Verbes complets REST
  • Personnalisation
  • Itinéraires nommés
  • Paramètres dynamiques (obligatoires et facultatifs)
  • Validation d'un paramètre dynamique
  • Intergiciel
  • Définir des middlewares mondiaux
  • Attacher dans un itinéraire
  • Supprimer le middleware
  • Groupes de routes
  • Toutes les méthodes
  • Groupe nommé
  • Groupe préfixé
  • Groupe d'espaces de noms par défaut
  • Groupe de middleware par défaut
  • Méthodes de groupes imbriqués
  • Autres
  • Redirection d'itinéraire
  • Itinéraire avec middleware individuel dans le groupe
  • Itinéraire avec un nom différent dans le groupe
  • Itinéraires de secours

3. Demander un itinéraire

  • Introduction
  • Méthodes
  • Chemin de requête
  • URL de la demande
  • En-têtes de demande
  • Demander une adresse IP
  • Récupération de données
  • Méthode de demande

Introduction

Pour commencer à utiliser minasrouter , toute la gestion de la navigation doit être redirigée vers le fichier d'itinéraire par défaut de votre système, qui effectuera tout le processus de traitement de l'itinéraire et renverra ce qui a été configuré par défaut. Configurez selon les exemples ci-dessous et selon votre serveur.

Pour commencer à utiliser minasrouter , toute la gestion de la navigation doit être redirigée vers le fichier d'itinéraire par défaut de votre système, qui effectuera l'intégralité du processus de gestion de l'itinéraire et renverra ce qui a été configuré par défaut. Configurez selon les exemples ci-dessous et selon votre serveur.

Redirection vers un dossier public 

 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;
  }
}

Le premier itinéraire

Pour démarrer les composants :

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 ();

Verbes complets REST

Méthodes :

Fonction Paramètre Paramètre Paramètre
obtenir Chaîne $uri $rappel
poste Chaîne $uri $rappel
mettre Chaîne $uri $rappel
correctif Chaîne $uri $rappel
supprimer Chaîne $uri $rappel
correspondre Tableau $httpVerbes Chaîne $uri $rappel
n'importe lequel Chaîne $uri $rappel

Exemple: 

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 () {
    // ...
});

Itinéraires nommés

Méthodes :

Fonction Paramètre
nom Chaîne $nom
au Chaîne $nom

Exemple: 

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

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

Paramètres dynamiques (obligatoires et facultatifs) 

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 " );

Valider un paramètre dynamique

Méthodes :

Fonction Paramètre Paramètre
où Tableau $params
oùParam Chaîne $param Chaîne $regex
oùNuméro Chaîne $param
oùAlpha Chaîne $param
oùAlphaNumérique Chaîne $param
oùUuid Chaîne $param

Exemple: 

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 " );

Intergiciel

Travailler avec des middlewares ici est assez simple, il suffit de transmettre les noms complets des classes ou de les définir comme globaux, et à partir de là, nous utilisons leur alias.

Définir des middlewares mondiaux

REMARQUE : Il est important de placer tous les itinéraires ci-dessous. Les routes au-dessus de cette classe n'auront pas ces middlewares comme globaux. 

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

// ... all routes

Attacher dans un itinéraire

Vous pouvez utiliser la méthode middleware pour attribuer un middleware à une route. 

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

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

Vous pouvez attribuer plusieurs middlewares à la route en transmettant un tableau de noms de middlewares à la méthode middleware. 

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

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

Lors de l'attribution d'un middleware, vous pouvez également transmettre le nom de classe complet : 

 use App  Middlewares  VerifyCsrfToken ;

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

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

Supprimer le middleware

Parfois, vous créez un groupe de routes avec un middleware, mais vous souhaitez qu'une ou quelques routes seulement soient sans middleware spécifique, vous pouvez le faire. 

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 ' );
});

Groupes de routes

Toutes les méthodes :

Fonction Paramètre ::fonction ->fonction
espace de noms Chaîne $espace de noms Oui Oui
préfixe Chaîne $préfixe Oui Oui
nom Chaîne $nom Oui Oui
intergiciel Chaîne $ middlewares Oui Oui

Les méthodes de groupe peuvent être appelées de manière statique ou normale, n'oubliez pas d'appeler un groupe de fonctions à insérer comme routes à l'intérieur de la fermeture.

Exemples :

groupe nommé 

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

groupe préfixé 

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

Groupe d'espaces de noms par défaut 

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

Groupe Middleware par défaut 

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

Méthodes de groupes imbriqués 

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

Autres

Itinéraire avec middleware individuel dans le groupe

Vous pouvez utiliser des routes avec des middlewares individuels au sein d'un groupe de routes. 

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

Itinéraire avec un nom différent dans le groupe

Peut-être souhaitez-vous un itinéraire dans lequel vous ignorez le nom du groupe, vous pouvez utiliser le deuxième paramètre de la méthode name pour cela. 

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

Redirection d'itinéraire

Méthodes :

Fonction Paramètre Paramètre Paramètre
réorienter Chaîne $uri Chaîne $redirection Int $statutCode = 302
redirection permanente Chaîne $uri Chaîne $redirection

Exemple: 

 // 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 " );

Itinéraires de secours

La route de secours est responsable lorsqu'aucune route n'est enregistrée avec cette adresse URL. Chaque fois qu'aucune route n'a été demandée par l'utilisateur, la route de secours sera appelée. 

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

REMARQUE : Soyez prudent si vous souhaitez rediriger vers une route existante, si elle contient des arguments dynamiques, elle renverra l'intégralité de l'expression régulière et provoquera une erreur.

Faites attention lorsque vous redirigez vers une route existante, car si elle a des arguments dynamiques, elle renverra l'intégralité de l'expression régulière et l'erreur sera renvoyée.

Demander un itinéraire

A chaque fois que la route est appelée et que la méthode Closure ou contrôleur est appelée, vous aurez en paramètre une instance de minasrouter HttpRequest. Si la route possède des paramètres dynamiques (obligatoires ou facultatifs), ils doivent être transmis avant de recevoir l'instance Request.

Fonction Paramètre Paramètre
getParams
chemin
URL
URL complète
en-tête Chaîne $en-tête Chaîne $par défaut
hasHeader Chaîne $en-tête
adresse IP
requête ?Chaîne $requête ?Chaîne $par défaut
tous ?Chaîne $sauf
getMéthode
estMéthode Chaîne $expectedMethod

Les paramètres dynamiques de la route sont directement transmis dans la méthode avec une instance de Request.

Exemple:

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 ());
});

La méthode Request est la méthode qui contient toutes vos données de formulaire, vos paramètres de requête, vos paramètres d'itinéraire dynamique et l'intégralité de l'en-tête de la demande.

Méthodes de demande

Récupération du chemin de la requête

La méthode path renvoie les informations de chemin de la requête. Ainsi, si la requête entrante cible http://localhost/foo/bar , la méthode path renverra foo/bar : 

 $ uri = $ request -> path ();

Récupération de l'URL de la demande

Pour récupérer l'URL complète de la demande entrante, vous pouvez utiliser les méthodes url ou fullUrl . La méthode url renverra l'URL sans la chaîne de requête, tandis que la méthode fullUrl inclut la chaîne de requête : 

 $ url = $ request -> url ();

$ urlWithQueryString = $ request -> fullUrl ();

En-têtes de demande

Vous pouvez récupérer un en-tête de requête depuis l'instance minasrouter HttpRequest en utilisant la méthode header. Si l'en-tête n'est pas présent sur la requête, null sera renvoyé. Cependant, la méthode header accepte un deuxième argument facultatif qui sera renvoyé si l'en-tête n'est pas présent sur la requête : 

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

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

La méthode hasHeader peut être utilisée pour déterminer si la requête contient un en-tête donné : 

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

La méthode BearerToken peut être utilisée pour récupérer un jeton de porteur à partir de l'en-tête Authorization. Si aucun en-tête de ce type n’est présent, null sera renvoyé. 

 $ token = $ request -> bearerToken ();

Demander une adresse IP

La méthode ip peut être utilisée pour récupérer l'adresse IP du client qui a fait la requête sur votre site Web : 

 $ ipAddress = $ request -> ip ();

Récupération de données

La méthode de requête récupérera uniquement les valeurs de la chaîne de requête : 

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

Si les données de valeur de chaîne de requête demandées ne sont pas présentes, le deuxième argument de cette méthode sera renvoyé : 

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

Vous pouvez appeler la méthode de requête sans aucun argument afin de récupérer toutes les valeurs de la chaîne de requête. 

 $ query = $ request -> query ();

Vous pouvez accéder directement aux queryString et aux données d'entrée, ainsi qu'aux propriétés de la classe Request.

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

$ foo = $ request -> foo ;

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

$ title = $ request -> title ;

Vous pouvez récupérer toutes les données d'entrée de la requête entrante sous forme de tableau en utilisant la méthode all. Cette méthode peut être utilisée indépendamment du fait que la demande entrante provienne d'un formulaire HTML ou d'une demande XHR. Si vous souhaitez annuler certaines données, vous pouvez les transmettre comme deuxième paramètre. 

 $ data = $ request -> all ();

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

Récupération de la méthode de requête

La méthode getMethod renverra le verbe HTTP pour la requête. Vous pouvez utiliser la méthode isMethod pour vérifier que le verbe HTTP correspond à une chaîne donnée : 

 $ httpMethod = $ request -> getMethod ();

if ( $ request -> isMethod ( ' POST ' )) {
    // ...
}
Développer
Informations supplémentaires
Applications connexes
Recommandé pour vous
Actualités connexes Tout