eco
v1.7.11
Eco est un cadre PHP pour PHP 5.5+
Installer l'exemple:
# wget shayanderson.com/eco.zip
# unzip ./eco.zip
Les itinéraires de base peuvent être configurés dans app/com/route.php , par exemple:
// set routes
return [
// class method
' / ' => ' IndexController->home ' ,
// namespace
' login ' => ' AccountUserController->login ' ,
// callable
' logout ' => function () { /* do something */ },
// more routes
]; La demande / appellerait la méthode home dans la classe IndexController dans Fichier app/mod/IndexController.php .
La demande /login appellerait la login la méthode dans la classe AccountUserController dans le fichier app/mod/Account/UserController.php .
Des méthodes HTTP spécifiques peuvent être utilisées pour les itinéraires:
eco:: route ( ' GET@api/user/:id ' , function ( $ id ) { /* GET method */ });
eco:: route ( ' DELETE@api/user/:id ' , function ( $ id ) { /* DELETE method */ });
eco:: route ( ' POST@api/user/:id? ' , function ( $ id = null ) { /* POST method */ });
// or handle multiple HTTP methods
eco:: route ( ' POST|PUT@api/user/:id? ' , function ( $ id = null ) { /* POST or PUT method */ });Ces méthodes HTTP sont prises en charge:
DELETE,GET,HEAD,PATCH,POST,PUT
Les rappels d'itinéraire peuvent être un nom appelable ou appelable (le premier élément de tableau doit être le contrôleur / l'action):
function auth () { /* do something */ }
eco:: route ( ' account/secure ' ,
[ ' AccountController->secure ' , ' auth ' , function () { /* invoked */ }]);AVERTISSEMENT: les rappels d'itinéraire ne fonctionnent pas avec le paramètre d'itinéraire dynamique
Les réseaux de routes dynamiques peuvent être utilisés pour des applications plus grandes qui ont de nombreuses itinéraires (routes de chargement paresseuses), par exemple:
eco:: route ( ' account* ' , ' AccountController::getRoutes() ' ); Désormais, toutes les demandes qui commencent par /account chargeront les itinéraires à l'aide de la méthode:
class AccountController
{
public static function getRoutes ()
{
return [
' account/login ' => ' AccountController->login ' ,
// do not have to use class name if in same class:
' account/logout ' => ' logout '
];
}
}Le réglage de l'itinéraire dynamique (routes de chargement paresseux) peut également être défini directement sous forme de tableau, exemple:
eco:: route ( ' account* ' , [
' AccountController ' , // the class name must be first (index:0)
' account/login ' => ' login ' ,
' account/logout ' => ' logout '
]);Le routage CLI est simple à utiliser, par exemple:
eco: route ( ' bin/test/:id ' , function ( $ id ) {
echo ' CLI test, id: ' . $ id ;
});Maintenant, une commande CLI peut être émise:
$ php index.php bin/test/5
Bin test: 5
L'itinéraire ci-dessus fonctionnerait également dans un navigateur Web. Pour créer une route CLI uniquement (ne fonctionnera pas dans le navigateur Web), ajoutez un
$au début de l'itinéraire, par exemple:
// this route will only work as CLI command
// the request '/bin/test/5' in a Web browser would result in a 404 error
eco: route ( ' $bin/test/:id ' , function ( $ id ) {
echo ' CLI test, id: ' . $ id ;
});Paramètres de route nommés:
eco:: route ( ' user/:id ' , ' UserController->view ' ); La valeur :id sera transmise à la méthode callable ou de classe:
class UserController
{
public function view ( $ id )
{
// do something
}
}Les paramètres facultatifs peuvent être utilisés:
eco:: route ( ' page/:id/:title? ' , function ( $ id , $ title = null ) {});Exemple de paramètres génériques:
eco:: route ( ' product/:info+ ' , function ( $ info ) {
// if request is '/product/1/abc/x'
// $info is an array: ['1', 'abc', 'x']
});Les rappels de paramètres d'itinéraire peuvent être utilisés de plusieurs manières différentes:
eco:: route ( ' page/:title:strtoupper ' , ' PageController->view ' );Ou définir des rappels de paramètres dans le tableau (le premier élément de tableau doit être la méthode de classe / callable):
eco:: route ( ' page/:title ' , [ ' PageController->view ' , [ ' title ' => ' strtoupper ' ]]);De plus, les rappels de paramètres de route globale peuvent être définis, par exemple:
// globally set route param callback
// now every ':id' param will use this callback
// global param callbacks are overwritten by local ones
eco:: param ( ' id ' , function ( $ id ) { return strtoupper ( $ id ); });
// or use multiple param names:
eco:: param ([ ' x ' , ' y ' , ' z ' ], function ( $ val ) { });Les rappels d'itinéraire peuvent également être utilisés avec les rappels de paramètres d'itinéraire:
eco:: route ( ' page/:title ' , [
' PageController->view ' ,
' route_callback ' ,
function () { /* route callback */ },
// route param callback
[ ' title ' => ' strtoupper ' ]
]);Paramètre d'itinéraire Des expressions régulières peuvent être utilisées, si le match échoue, l'itinéraire ne sera pas invoqué:
eco:: route ( ' user/:id@[0-9]+ ' , ...);L'ordre de syntaxe est important lorsque vous utilisez différents types de paramètres et / ou combinant des rappels et des expressions régulières, voici la syntaxe correcte:
// when using callback with regular expression
// the callback must come first:
eco:: route ( ' user/:id:strtoupper@[0-9]+ ' , ...);
// use optional param and callback:
eco:: route ( ' user/:id/:name?:strtoupper ' , ...);
// use optional param and regular expression:
eco:: route ( ' user/:id/:name?@[a-z]+ ' , ...);
// use optional param, callback and regular expression:
eco:: route ( ' user/:id/:name?:strtoupper@[a-z]+ ' , ...);
// use wildcard param and callback:
eco:: route ( ' user/:params+:strtoupper ' , ...);
// use wildcard param and regular expression:
eco:: route ( ' user/:params+@[a-z]+ ' , ...);
// use wildcard param, callback and regular expression:
eco:: route ( ' user/:params+:strtoupper@[a-z]+ ' , ...);L'objet View peut être utilisé dans une voie d'itinéraire:
class PageController
{
public function get ( $ id )
{
$ page = PageModel:: get ( $ id );
// set view param
eco:: view ()-> set ( ' title ' , $ page -> title );
// or use view() helper function
// view()->set('title', $page->title);
// or like this:
view ()-> author = $ page -> author ;
// load template file 'page/view'
// and can also set view param 'content'
view ( ' page/view ' , [
' content ' => $ page -> content
]);
}
}Les paramètres de route sont également accessibles à l'aide de méthodes de classe
Router.
Exemple de fichier app/tpl/page/view.tpl :
<?php include PATH_TEMPLATE_GLOBAL . ' header.tpl ' ; ?>
<h1> <?= $ title ?> </h1>
<p>Author: <?= $ author ?> </p>
<?= $ content ?>
<?php include PATH_TEMPLATE_GLOBAL . ' footer.tpl ' ; ?> Exemple de messages de journalisation:
eco:: log ()-> error ( ' Bad error / fatal ' );
eco:: log ()-> warning ( ' Warning conditions ' );
eco:: log ()-> notice ( ' Notice message ' );
eco:: log ()-> debug ( ' File has loaded ' );Les catégories peuvent être utilisées lors de la connexion d'un message:
// category 'payment'
eco:: log ()-> error ( ' Failed to access payment gateway ' , ' payment ' );Les informations de débogage peuvent également être ajoutées:
eco:: log ()-> warning ( ' Request failed ' , /* category optional */ null ,
[ ' request ' => ' x ' , ' client ' => ' y ' ]);Obtenez un journal entier:
$ log = eco:: log ()-> get ();Configuration Exemple de gestionnaire de journaux personnalisés:
eco:: log ()-> setHandler ( function ( $ message , $ level , $ category , $ info ){
// if sending message to database
// do no send if database connection error, example:
// if(substr($message, 0, 17) == 'SQLSTATE[HY000] [')
// {
// return false;
// }
// handle custom logging
return true ; // handled
});Si le gestionnaire de journaux personnalisé appelle ne renvoie pas
truele journal interne se poursuivra comme normal
Exemples d'erreur de déclenchement:
eco:: error ( ' Error message ' );
// or use helper function
error ( ' Something bad ' );
// custom error code
error ( ' Page not found ' , 404 );
// add log category
error ( ' Failed to load user ' , null , ' account ' );
// by default the HTTP error response code is sent
// to not send HTTP code use:
error ( ' Page not found ' , 404 , ' category ' false ); Le dernier message d'erreur (et catégorie d'erreur) envoyés à la fonction eco::error() est accessible en utilisant:
$ error_message = eco:: errorGetLast ();
$ error_category = eco:: errorGetLastCategory ();Un rappel 404 peut être utilisé pour gérer le 404 avant qu'une erreur ne soit appelée
Les crochets peuvent être utilisés pour charger des fichiers ou utiliser des rappels pendant l'exécution, exemples:
// called before routing starts
eco:: hook (eco:: HOOK_BEFORE , function () { /* do something */ });
// called before the route callable or class method is called
// include a file example:
eco:: hook (eco:: HOOK_MIDDLE , PATH_LIB . ' hook/middle.php ' );
// called after dispatching
eco:: hook (eco:: HOOK_AFTER , function () { /* do something */ });Les paramètres de configuration de l'application et de l'écos sont gérés séparément.
Le fichier de paramètres de configuration ECO est situé sur app/com/conf/eco.conf.php et contient tous les paramètres du framework. Toutes les documents pour les paramètres de configuration ECO peuvent être trouvés dans le fichier.
Les paramètres de configuration de l'application peuvent être stockés par ECO, exemple:
// load config file(s) using path
eco:: conf ( PATH_CONF . ' app.conf.php ' );
eco:: conf ( PATH_CONF . ' api.conf.php ' );
// or load config settings using array
eco:: conf ([ ' local ' => [ ' path ' => ' x ' , ' filename ' => ' y ' ]]);
// use config settings
$ app_username = eco:: conf ()-> app -> username ;
$ local_path = eco:: conf ()-> local -> path ; Les fichiers de configuration doivent renvoyer un tableau, app.conf.php Exemple:
return [
' app ' => [
' username ' => ' x ' ,
' password ' => ' y '
],
' core ' => [ /* more */ ]
];Les paramètres de configuration ne peuvent pas être écrasés lors de l'utilisation de plusieurs fichiers, de sorte que les clés de tableau principales doivent être uniques même dans différents fichiers. N'utilisez jamais la clé de tableau principale
_ecoqui est utilisée par ECO pour les paramètres du cadre interne.
Les paramètres de configuration peuvent également être utilisés séparément de l'éco, par exemple:
// do not store internally
$ conf = eco:: conf ( PATH_CONF . ' app.conf.php ' , false );
// use config settings
$ app_username = $ conf -> app -> username ;ECO propose les méthodes suivantes:
eco::autoload($paths) - Class Autoloadereco::breadcrumb() - Accès à la classe d'aide à An Breadcrumb ( breadcrumb() Helper disponible)eco::clear($key) - variable globale claireeco::conf($file_path, $store) - enregistrer / charger les paramètres de configuration des applications fichier (Fonction d'assistance conf() disponible)eco::db($connection_id) - Classe de base de données d'accès ( db() Fonction d'assistance disponible)eco::error($message, $code, $category, $http_response_code) - déclenchez une fonction d'assistance error ( error() disponible)eco::filter() - Access Data Filter Class ( filter() Fonction d'assistance disponible)eco::flash() - Session d'accès Classe Flash ( flash() Fonction d'assistance disponible)eco::format() - Access Data Format Class ( format() Fonction d'assistance disponible)eco::get($key) - Obtenez une variable globaleeco::has($key) - Vérifiez si une variable globale existeeco::hook($name, $callback) - Ajouter un crocheteco::log() - Access Log Class ( logger() Fonction d'assistance disponible)eco::model() - Fonction d'assistance de classe de modèle de modèle ( model() d'aide disponible)eco::param($id, $callback) - Fonction d'assistance paramètre de route map ( param() disponible)eco::request() - Classe d'accès à la demande ( request() Fonction d'assistance disponible)eco::response() - Access Response Class ( response() Fonction d'assistance disponible)eco::route($route, $action) - Map Routeeco::router() - Access Core Router Classeco::run() - exécuter l'applicationeco::service() - Fonction d'assistance de classe de service ( service() disponible)eco::session() - Access Session Class ( session() Fonction d'assistance disponible)eco::set($key, $value) - Définir une variable globaleeco::stop() - Arrêtez gracieusement la fonction d'assistance application ( stop() disponible)eco::validate() - accéder aux données Valider Class ( validate() Fonction d'assistance disponible)eco::view($template, $view_params) - Chargez le fichier de modèle de vue et accédez à la classe Affichage ( view() Fonction d'assistance disponible) Les classes de base peuvent être utilisées pour simplifier les tâches d'application courantes:
EcoCache - CLASSE DE CORE CACHE côté serveurEcoDatabase - Classe de base de la base de donnéesEcoForm - HTML Form Core ClassEcoHttp - Classe de base de demande HTTPEcoModel - Classe de base du modèle de base de donnéesEcoTable - Classe de base de la table HTML Ces cours d'assistance sont disponibles:
EcoBenchmark - Aide à l'analyse comparativeEcoSystemBreadcrumb - Accès avec eco::breadcrumb() ou breadcrumb() Fonction d'assistanceEcoSystemFilter - Accès avec eco::filter() ou filter() Fonction d'assistanceEcoSystemSessionFlash - Accès avec eco::flash() ou flash() Fonction d'assistanceEcoSystemFormat - Accès avec eco::format() ou format() Fonction d'assistanceEcoSystemRequest - Accès avec eco::request() ou request() Fonction d'assistanceEcoSystemRegistryService - Accès avec eco::service() ou service() Fonction d'assistanceEcoSystemSession - Accès avec eco::session() ou session() Fonction d'assistanceEcoSocketClient et EcoSocketServer - Création d'aideurs de socketsEcoSystemValidate - Access avec eco::validate() ou validate() fonction d'assistance Les fonctions d'assistance peuvent être utilisées pour accéder rapidement aux méthodes ECO Core ou à d'autres fonctionnalités utiles. Trouvez la documentation des fonctions d'assistance ici.
L'ECO peut être étendu en étendant la classe EcoSystem de base. Initialement, cela est configuré dans le fichier app/com/bootstrap.php :
// set Eco access class
class eco extends Eco System {} La classe d'extension peut être utilisée pour ajouter des méthodes ou remplacer les méthodes de remplacement EcoSystem .
^ Retour en haut
