eco
v1.7.11
Eco ist ein PHP -Framework für PHP 5.5+
Beispiel installieren:
# wget shayanderson.com/eco.zip
# unzip ./eco.zip
Grundlegende Routen können beispielsweise in app/com/route.php eingerichtet werden:
// set routes
return [
// class method
' / ' => ' IndexController->home ' ,
// namespace
' login ' => ' AccountUserController->login ' ,
// callable
' logout ' => function () { /* do something */ },
// more routes
]; Die Anforderung / würde die Methode im IndexController in der Datei app/mod/IndexController.php home .
In der Anforderung /login wird die Methode login in der Klasse AccountUserController in Datei app/mod/Account/UserController.php aufgerufen.
Spezifische HTTP -Methoden können für Routen verwendet werden:
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 */ });Diese HTTP -Methoden werden unterstützt:
DELETE,GET,HEAD,PATCH,POST,PUT
Routen -Rückrufe können ein Anrufname oder ein Anruf sein (das erste Array -Element muss der Controller/die Aktion sein):
function auth () { /* do something */ }
eco:: route ( ' account/secure ' ,
[ ' AccountController->secure ' , ' auth ' , function () { /* invoked */ }]);WARNUNG: Routenrufe funktionieren nicht mit dynamischer Routeneinstellung
Dynamische Routensetzer können für größere Anwendungen mit vielen Routen (faule Lastrouten) verwendet werden, z. B.:
eco:: route ( ' account* ' , ' AccountController::getRoutes() ' ); Jetzt lädt alle Anfragen, die mit /account beginnen, die Routen mithilfe der Methode:
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 '
];
}
}Dynamische Routeneinstellung (faule Lastrouten) können auch direkt als Array festgelegt werden, Beispiel:
eco:: route ( ' account* ' , [
' AccountController ' , // the class name must be first (index:0)
' account/login ' => ' login ' ,
' account/logout ' => ' logout '
]);Das CLI -Routing ist einfach zu bedienen, zum Beispiel:
eco: route ( ' bin/test/:id ' , function ( $ id ) {
echo ' CLI test, id: ' . $ id ;
});Jetzt kann ein CLI -Befehl ausgestellt werden:
$ php index.php bin/test/5
Bin test: 5
Die obige Route würde auch in einem Webbrowser funktionieren. Um eine CLI -Route zu erstellen (funktioniert nicht im Webbrowser), fügen Sie dem Beginn der Route ein
$hinzu, zum Beispiel:
// 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 ;
});Benannte Routenparameter:
eco:: route ( ' user/:id ' , ' UserController->view ' ); Der :id -Wert wird an die Callable- oder Klassenmethode übergeben:
class UserController
{
public function view ( $ id )
{
// do something
}
}Optionale Parameter können verwendet werden:
eco:: route ( ' page/:id/:title? ' , function ( $ id , $ title = null ) {});Wildcard -Parameter Beispiel:
eco:: route ( ' product/:info+ ' , function ( $ info ) {
// if request is '/product/1/abc/x'
// $info is an array: ['1', 'abc', 'x']
});Routenparameter -Rückrufe können auf verschiedene Arten verwendet werden:
eco:: route ( ' page/:title:strtoupper ' , ' PageController->view ' );Oder Parameter -Rückrufe in Array festlegen (das erste Array -Element muss die Klassenmethode / Callable sein):
eco:: route ( ' page/:title ' , [ ' PageController->view ' , [ ' title ' => ' strtoupper ' ]]);Außerdem können globale Routenparameter -Rückrufe festgelegt werden, beispielsweise:
// 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 ) { });Routenrufe können auch mit Routenparameter -Rückrufen verwendet werden:
eco:: route ( ' page/:title ' , [
' PageController->view ' ,
' route_callback ' ,
function () { /* route callback */ },
// route param callback
[ ' title ' => ' strtoupper ' ]
]);Der Routenparameter regelmäßige Ausdrücke können verwendet werden, wenn das Match fehlschlägt, dass die Route nicht aufgerufen wird:
eco:: route ( ' user/:id@[0-9]+ ' , ...);Die Reihenfolge der Syntax ist bei der Verwendung verschiedener Parametertypen und/oder der Kombination von Rückrufen und regulären Ausdrücken die richtige Syntax:
// 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]+ ' , ...);Das Ansichtsobjekt kann in Routenaktionen verwendet werden:
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
]);
}
}Auf Routenparameter können auch mit Methoden der
Routerzugegriffen werden.
Das Beispiel app/tpl/page/view.tpl -Datei Beispiel:
<?php include PATH_TEMPLATE_GLOBAL . ' header.tpl ' ; ?>
<h1> <?= $ title ?> </h1>
<p>Author: <?= $ author ?> </p>
<?= $ content ?>
<?php include PATH_TEMPLATE_GLOBAL . ' footer.tpl ' ; ?> Beispiel für Protokollierungsnachrichten:
eco:: log ()-> error ( ' Bad error / fatal ' );
eco:: log ()-> warning ( ' Warning conditions ' );
eco:: log ()-> notice ( ' Notice message ' );
eco:: log ()-> debug ( ' File has loaded ' );Kategorien können verwendet werden, wenn eine Nachricht angemeldet wird:
// category 'payment'
eco:: log ()-> error ( ' Failed to access payment gateway ' , ' payment ' );Debugging -Informationen können auch hinzugefügt werden:
eco:: log ()-> warning ( ' Request failed ' , /* category optional */ null ,
[ ' request ' => ' x ' , ' client ' => ' y ' ]);Holen Sie sich das gesamte Protokoll:
$ log = eco:: log ()-> get ();Setzen Sie benutzerdefinierte Protokoll -Handler -Beispiel: Beispiel:
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
});Wenn der benutzerdefinierte Protokollhandler nicht
truezurückgibt, wird der interne Logger normal fortgesetzt
Beispiele für Triggerfehler:
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 ); Die letzte Fehlermeldung (und die Fehlerkategorie), die an die Funktion eco::error() gesendet wurde, kann mit:
$ error_message = eco:: errorGetLast ();
$ error_category = eco:: errorGetLastCategory ();Ein 404 -Rückruf kann verwendet werden, um den 404 zu verarbeiten, bevor ein Fehler aufgerufen wird
Hooks können verwendet werden, um Dateien zu laden oder Rückrufe während der Ausführung zu verwenden, Beispiele:
// 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 */ });Anwendungs- und Öko -Konfigurationseinstellungen werden separat behandelt.
Die Eco -Konfigurationseinstellungsdatei befindet sich unter app/com/conf/eco.conf.php und enthält alle Framework -Einstellungen. Alle Dokumentationen für ECO -Konfigurationseinstellungen finden Sie in der Datei.
Anwendungskonfigurationseinstellungen können von ECO gespeichert werden, Beispiel:
// 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 ; Die Konfigurationsdateien müssen ein Array zurückgeben, app.conf.php Beispiel:
return [
' app ' => [
' username ' => ' x ' ,
' password ' => ' y '
],
' core ' => [ /* more */ ]
];Konfigurationseinstellungen können bei der Verwendung mehrerer Dateien nicht überschrieben werden, sodass die primären Array -Tasten auch in verschiedenen Dateien eindeutig sein müssen. Verwenden Sie niemals den primären Array -Schlüssel
_eco, der von Eco für interne Framework -Einstellungen verwendet wird.
Konfigurationseinstellungen können auch getrennt von ECO verwendet werden, z. B.:
// do not store internally
$ conf = eco:: conf ( PATH_CONF . ' app.conf.php ' , false );
// use config settings
$ app_username = $ conf -> app -> username ;Eco bietet die folgenden Methoden an:
eco::autoload($paths) - Klasse Autoloadereco::breadcrumb() - Zugriff auf Breadcrumb -Klasse ( breadcrumb() Helfer -Funktion verfügbar)eco::clear($key) - Globale Variable Clear Cleareco::conf($file_path, $store) - registrieren / laden Anwendungskonfigurationseinstellungen Datei ( conf() Helfer -Funktion verfügbar)eco::db($connection_id) - Zugriff auf Datenbankklasse ( db() Helfer -Funktion verfügbar)eco::error($message, $code, $category, $http_response_code) - Auslösen Sie einen Fehler (Fehler ( error() Helfer -Funktion verfügbar)eco::filter() - Zugriff auf Datenfilterklasse ( filter() Helfer -Funktion verfügbar)eco::flash() - Zugriff auf Sitzungsklasse ( flash() Helfer -Funktion verfügbar)eco::format() - Zugriff auf Datenformatklasse ( format() Helfer -Funktion verfügbar)eco::get($key) - Holen Sie sich eine globale Variableeco::has($key) - Überprüfen Sie, ob eine globale Variable existierteco::hook($name, $callback) - Fügen Sie einen Haken hinzueco::log() - Zugriff auf Protokollklasse ( logger() Helfer -Funktion verfügbar)eco::model() - Modellklassenlader ( model() Helfer -Funktion verfügbar)eco::param($id, $callback) - Map Route Parameter Rückruf ( param() Helfer -Funktion verfügbar)eco::request() - Zugriffsanforderungsklasse ( request() Helfer -Funktion verfügbar)eco::response() - Zugriffsklasse ( response() Helfer -Funktion verfügbar)eco::route($route, $action) - Kartenrouteeco::router() - Zugriff auf die Kern -Router -Klasseeco::run() - Führen Sie die Anwendung auseco::service() - Service Class Loader ( service() Helfer -Funktion verfügbar)eco::session() - Zugriff auf Sitzungsklasse ( session() Helfer -Funktion verfügbar)eco::set($key, $value) - Legen Sie eine globale Variable festeco::stop() - Stop die Anwendung ( stop() Helfer -Funktion verfügbar)eco::validate() - Zugriff auf Daten validieren ( validate() Helferfunktion verfügbar)eco::view($template, $view_params) - Vorlagendatei anzeigen und zugreifen Ansicht Klasse ( view() Helfer -Funktion verfügbar) Kernklassen können verwendet werden, um allgemeine Anwendungsaufgaben zu vereinfachen:
EcoCache - serverseitiger Cache -KernklasseEcoDatabase - DatenbankkernklasseEcoForm - HTML Form Core ClassEcoHttp - http anfordern KernklasseEcoModel - Datenbankmodell KernklasseEcoTable - HTML -Tabelle Kernklasse Diese Helferklassen sind verfügbar:
EcoBenchmark - Benchmarking -HelferEcoSystemBreadcrumb - Zugang mit eco::breadcrumb() oder breadcrumb() HelferfunktionEcoSystemFilter - Zugriff mit eco::filter() oder filter() HelferfunktionEcoSystemSessionFlash - Zugriff mit eco::flash() oder flash() HelferfunktionEcoSystemFormat - Zugriff mit eco::format() oder format() HelferfunktionEcoSystemRequest - Zugriff mit eco::request() oder request() Helfer -FunktionEcoSystemRegistryService - Zugriff mit eco::service() oder service() HelferfunktionEcoSystemSession - Zugriff mit eco::session() oder session() Helfer -FunktionEcoSocketClient und EcoSocketServer - Erstellen von Sockets -HelfernEcoSystemValidate - ERGANG MIT eco::validate() oder validate() Helferfunktion Helferfunktionen können verwendet werden, um schnell auf ECO -Kernmethoden oder andere nützliche Funktionen zuzugreifen. Finden Sie Helferfunktionen Dokumentation hier.
ECO kann erweitert werden, indem die Kern EcoSystem erweitert wird. Dies ist zunächst in der Datei der app/com/bootstrap.php eingerichtet:
// set Eco access class
class eco extends Eco System {} Die Erweiterungsklasse kann verwendet werden, um Methoden hinzuzufügen oder EcoSystem -überschriebene Methoden zu überschreiben.
^ Zurück nach oben
