Flight ir ātrs, vienkāršs, paplašināms PHP ietvars. Tas ir diezgan daudzpusīgs un var tikt izmantots, lai izveidotu jebkāda veida tīmekļa lietotni. Tas ir izstrādāts, ņemot vērā vienkāršību, un ir rakstīts tā, lai būtu viegli saprotams un izmantojams.
Šeit ir īss raksts par to, kāpēc jums vajadzētu izmantot ietvaru. Pirms sākat izmantot ietvaru, ir laba ideja saprast priekšrocības, ko tas dod.
Papildus ir izveidots lielisks pamācības materiāls @lubiana. Lai arī tas nepiedāvā detalizētu Flight aprakstu, šī vadlīnija palīdzēs jums saprast galvenos jēdzienus, kas saistīti ar ietvaru, un kāpēc to izmantošana ir noderīga. Jūs varat atrast pamācību šeit.
Uzziniet, kā automātiski ielādēt savas klases savā lietotnē.
Uzziniet, kā pārvaldīt maršrutus savai tīmekļa lietotnei. Tas ietver arī maršrutu grupēšanu, maršruta parametrus un starpjoslas programmatūru.
Uzziniet, kā izmantot starpjoslu programmatūru, lai filtrētu pieprasījumus un atbildes savai lietotnei.
Uzziniet, kā apstrādāt pieprasījumus un atbildes savai lietotnei.
Uzziniet, kā nosūtīt atbildes savai lietotājiem.
Uzziniet, kā izmantot iebūvēto skata dzinēju, lai renderētu savas HTML veidnes.
Uzziniet, kā nodrošināt savu lietotni pret bieži sastopamām drošības draudēm.
Uzziniet, kā konfigurēt ietvaru savai lietotnei.
Uzziniet, kā paplašināt ietvaru, pievienojot savas metodes un klases.
Uzziniet, kā izmantot notikumu sistēmu, lai pievienotu āķus jūsu metodēm un iekšējiem ietvara metodēm.
Uzziniet, kā izmantot atkarību ievades konteinerus (DIC), lai pārvaldītu savas lietotnes atkarības.
Uzziniet par ietvara galvenajām metodēm.
Atpakaļējā saderība galvenokārt ir saglabāta, bet ir dažas izmaiņas, par kurām jums jābūt informētiem, pārejot no v2 uz v3.
Ir daži bieži sastopami jautājumi, kurus jūs varat saskarties, lietojot Flight. Šī lapa jums palīdzēs novērst šos jautājumus.
Jūs varat apturēt pamatstruktūru jebkurā brīdī, izsaucot halt metodi:
halt
Flight::halt();
Jūs arī varat norādīt neobligātu HTTP statusa kodu un ziņojumu:
HTTP
Flight::halt(200, 'Jau drīz atgriezīšos...');
Izsaukot halt, tiks atcelts jebkāds atbildes saturs līdz tam brīdim. Ja vēlaties apturēt pamatstruktūru un izvadīt pašreizējo atbildi, izmantojiet stop metodi:
stop
Flight::stop();
Visas kļūdas un izņēmumi tiek noķerti ar Flight un padoti error metodei. Pēc noklusējuma uzvedība ir nosūtīt vispārēju HTTP 500 Iekšēja servera kļūda atbildi ar kādu kļūdas informāciju.
error
HTTP 500 Iekšēja servera kļūda
Jūs varat pārrakstīt šo uzvedību savām vajadzībām:
Flight::map('error', function (Throwable $error) { // Apstrādāt kļūdu echo $error->getTraceAsString(); });
Pēc noklusējuma kļūdas netiek reģistrētas tīmekļa serverī. Jūs varat to iespējot, mainot konfigurāciju:
Flight::set('flight.log_errors', true);
Kad URL nav atrodams, Flight izsauc notFound metodi. Noklusējuma uzvedība ir nosūtīt HTTP 404 Nav atrasts atbildi ar vienkāršu ziņojumu.
notFound
HTTP 404 Nav atrasts
Flight::map('notFound', function () { // Apstrādāt nav atrasts });
Atkārtotā saderība lielākoties ir saglabāta, bet ir veiktas dažas izmaiņas, par kurām ir jābūt informētam, migrējot no v2 uz v3.
Izvades buferēšana ir process, kur izveidotā PHP skripta izvade tiek saglabāta buferī (iekšējā PHP) pirms tā tiek nosūtīta klientam. Tas ļauj jums modificēt izvadi pirms tā tiek nosūtīta klientam.
MVC lietotnē Kontrolieris ir "vadītājs" un tas vadīs skatu darbības. Izvades ģenerēšana ārpus kontroliera (vai Flight gadījumā dažreiz anonīmā funkcija) pārkāpj MVC modeli. Šī izmaiņa ir paredzēta, lai labāk iekļautos MVC modelī un padarītu struktūru paredzamāku un vieglāk lietojamu.
v2 versijā izvades buferēšana tika apstrādāta veidā, kurā tā neatbilda vienmērīgi savam paša izvades buferim, kas padarīja vienības testēšanu un strāvošanu sarežģītāku. Lielai daļai lietotāju šī izmaiņa varētu nemainīt jūsu darbības. Tomēr, ja jūs izmantojat "echo" saturu ārpus izsaukamiem un kontrolieriem (piemēram, āķī), iespējams, ka jums radīsies problēmas. Satura izvadīšana āķos un pirms struktūra patiešām izpilda šo darbību, varēja darboties iepriekš, bet tas nedarbosies turpmāk.
// index.php require 'vendor/autoload.php'; // tikai piemērs define('START_TIME', microtime(true)); function hello() { echo 'Sveika, pasaule'; } Flight::map('hello', 'hello'); Flight::after('hello', function(){ // tas faktiski ir kārtībā echo '<p>Šis Sveika, pasaule teksts jums sniegts ar burtni "S"</p>'; }); Flight::before('start', function(){ // šīs lietas izraisīs kļūdu echo '<html><head><title>Mana lapas nosaukums</title></head><body>'; }); Flight::route('/', function(){ // tas faktiski ir kārtībā echo 'Sveika, pasaule'; // Tas arī vajadzētu būt kārtībā Flight::hello(); }); Flight::after('start', function(){ // tas izraisīs kļūdu echo '<div>Jūsu lapa ielādējās '.(microtime(true) - START_TIME).' sekundēs</div></body></html>'; });
Vai jūs vēl varat saglabāt savu veco kodu tādā formā, neveicot pārrakstīšanu, lai tas darbotos ar v3? Jā, var! Jūs varat ieslēgt v2 izstrādes uzvedību, iestatot flight.v2.output_buffering konfigurācijas opciju uz true. Tas ļaus jums turpināt izmantot veco izstrādes uzvedību, bet ieteicams to labot turpmāk. V4 versijā struktūrā tas tiks noņemts.
flight.v2.output_buffering
true
// index.php require 'vendor/autoload.php'; Flight::set('flight.v2.output_buffering', true); Flight::before('start', function(){ // Tagad tas būs kārtībā echo '<html><head><title>Mana lapas nosaukums</title></head><body>'; }); // vairāk koda
Ja jūs tieši esat izsaukuši statiskās metodes "Dispatcher", piemēram, Dispatcher::invokeMethod(), Dispatcher::execute(), uc., jums būs jāatjauno jūsu kodu, lai šīs metodes netiktu tieši izsauktas. Dispatcher ir pārveidots, lai būtu vairāk objektu orientēts, lai atkarību ievietošanas konteineri varētu tikt izmantoti vieglāk. Ja jums ir nepieciešams izsaukt metodi līdzīgu tam, kā to darīja Dispečers, jūs varat manuāli izmantot kaut ko tādu kā $result = $class->$method(...$params); vai call_user_func_array() vietā.
Dispatcher::invokeMethod()
Dispatcher::execute()
Dispatcher
$result = $class->$method(...$params);
call_user_func_array()
Jūs varat pielāgot noteiktus Flight uzvedības veidus, iestatot konfigurācijas vērtības, izmantojot set metodi.
set
Zemāk ir saraksts ar visiem pieejamajiem konfigurācijas iestatījumiem:
?string
bool
string
Saturs-Garums
Flight ļauj saglabāt mainīgos, lai tos varētu izmantot jebkur aplikācijā.
// Saglabājiet savu mainīgo Flight::set('id', 123); // Citur jūsu aplikācijā $id = Flight::get('id');
Lai pārbaudītu, vai mainīgais ir iestatīts, varat izdarīt šādi:
if (Flight::has('id')) { // Dariet kaut ko }
Jūs varat notīrīt mainīgo, izmantojot šo:
// Notīra id mainīgo Flight::clear('id'); // Notīrīt visus mainīgos Flight::clear();
Flight izmanto mainīgos arī konfigurācijas nolūkiem.
Visas kļūdas un izņēmumi tiek noķerti ar Flight un nodoti error metodē. Noklusējuma rīcība ir nosūtīt vispārēju HTTP 500 Iekšēja servera kļūda atbildi ar kādu kļūdas informāciju.
Jūs varat atjaunot šo rīcību saviem mērķiem:
Noklusējuma rīcība ir nelogot kļūdas web serverī. Jūs varat iespējot to, mainot konfigurāciju:
Kad URL nevar atrast, Flight izsauc notFound metodi. Noklusējuma rīcība ir nosūtīt HTTP 404 Nav Atrasts atbildi ar vienkāršu ziņojumu.
HTTP 404 Nav Atrasts
Drošība ir liela lieta, kad runa ir par tīmekļa lietojumprogrammām. Jums ir jāpārliecinās, ka jūsu lietojumprogramma ir droša un jūsu lietotāju dati ir drošībā. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt savas tīmekļa lietojumprogrammas.
HTTP galvenes ir viens no vieglākajiem veidiem, kā nodrošināt savas tīmekļa lietojumprogrammas. Jūs varat izmantot galvenes, lai novērstu klikšķu izviltības, XSS un citas uzbrukumus. Ir vairāki veidi, kā pievienot šīs galvenes savai lietojumprogrammai.
Divas lieliskas vietnes, kur pārbaudīt savu galvenu drošību, ir securityheaders.com un observatory.mozilla.org.
Varat manuāli pievienot šīs galvenes, izmantojot header metodi Flight\Response objektam.
header
Flight\Response
// Iestatiet X-Frame-Options galveni, lai novērstu klikšķu izviltības Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); // Iestatiet Content-Security-Policy galveni, lai novērstu XSS // Piezīme: šī galvene var kļūt ļoti sarežģīta, tāpēc jums būs // jākonsultējas ar piemēriem internetā savai lietojumprogrammai Flight::response()->header("Content-Security-Policy", "default-src 'self'"); // Iestatiet X-XSS-Protection galveni, lai novērstu XSS Flight::response()->header('X-XSS-Protection', '1; mode=block'); // Iestatiet X-Content-Type-Options galveni, lai novērstu MIME sīkdatņu izjaukšanu Flight::response()->header('X-Content-Type-Options', 'nosniff'); // Iestatiet Referrer-Policy galveni, lai kontrolētu, cik daudz atsauces informācijas ir nosūtīts Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); // Iestatiet Strict-Transport-Security galveni, lai piespiestu HTTPS Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); // Iestatiet Permissions-Policy galveni, lai kontrolētu, kādas funkcijas un API var izmantot Flight::response()->header('Permissions-Policy', 'geolocation=()');
Šīs var pievienot augšpusē jūsu bootstrap.php vai index.php failos.
bootstrap.php
index.php
To var pievienot arī kā filtru/iekārtu šādi:
// Pievienojiet galvenes filtrā Flight::before('start', function() { Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); Flight::response()->header("Content-Security-Policy", "default-src 'self'"); Flight::response()->header('X-XSS-Protection', '1; mode=block'); Flight::response()->header('X-Content-Type-Options', 'nosniff'); Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); Flight::response()->header('Permissions-Policy', 'geolocation=()'); });
To var pievienot arī kā starpprogrammu klasi. Tas ir labs veids, kā saglabāt jūsu kodu tīru un organizētu.
// app/middleware/SecurityHeadersMiddleware.php namespace app\middleware; class SecurityHeadersMiddleware { public function before(array $params): void { Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); Flight::response()->header("Content-Security-Policy", "default-src 'self'"); Flight::response()->header('X-XSS-Protection', '1; mode=block'); Flight::response()->header('X-Content-Type-Options', 'nosniff'); Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); Flight::response()->header('Permissions-Policy', 'geolocation=()'); } } // index.php vai kur vien ir jūsu maršruti // FYI, šī tukšā virkne grupas darbojas kā globāla starpprogramma visiem maršrutiem. Protams, jūs varētu darīt to pašu un tikai pievienot to noteiktām maršrutām. Flight::group('', function(Router $router) { $router->get('/lietotāji', [ 'UserController', 'getUsers' ]); // vairāki maršruti }, [ new SecurityHeadersMiddleware() ]); ## Pārkrāpšana ar krustu vietu pieprasījumu (CSRF) Pārkrāpšana ar krustu vietu pieprasījumu (CSRF) ir uzbrukuma veids, kur ļaunprātīga vietne var likt lietotāja pārlūkam nosūtīt pieprasījumu uz jūsu vietni. To var izmantot, lai veiktu darbības jūsu vietnē bez lietotāja zināšanām. Flight nenodrošina iebūvētu CSRF aizsardzības mehānismu, bet jūs varat viegli ieviest savu, izmantojot starpprogrammu. ### Iestatīšana Vispirms jums ir jāģenerē CSRF žetons un jāsaglabā tas lietotāja sesijā. Tad jūs varat izmantot šo žetonu savos veidlapās un pārbaudīt to, kad forma tiek iesniegta. ```php // Ģenerējiet CSRF žetonu un saglabājiet to lietotāja sesijā // (pieņemot, ka esat izveidojis sesijas objektu un piesaistījis to Flight) // Jums ir jāģenerē tikai viens žetons uz sesiju (tāpēc tas darbojas // vairākos cilnēs un pieprasījumos vienam lietotājam) if(Flight::session()->get('csrf_token') === null) { Flight::session()->set('csrf_token', bin2hex(random_bytes(32)) ); }
<!-- Izmantojiet CSRF žetonu savā formā --> <form method="post"> <input type="hidden" name="csrf_token" value="<?= Flight::session()->get('csrf_token') ?>"> <!-- citi veidlapas lauki --> </form>
Jūs varat arī iestatīt pielāgotu funkciju, lai izvadītu CSRF žetonu savos Latte veidņos.
// Iestatiet pielāgoto funkciju, lai izvadītu CSRF žetonu // Piezīme: Skats ir konfigurēts, lai Latte būtu skata dzinējs Flight::view()->addFunction('csrf', function() { $csrfToken = Flight::session()->get('csrf_token'); return new \Latte\Runtime\Html('<input type="hidden" name="csrf_token" value="' . $csrfToken . '">'); });
Un tagad savos Latte veidnēs varat izmantot csrf() funkciju, lai izvadītu CSRF žetonu.
csrf()
<form method="post"> {csrf()} <!-- citi veidlapas lauki --> </form>
Īss un vienkāršs, vai ne?
Jūs varat pārbaudīt CSRF žetonu, izmantojot notikumu filtrus:
// Šī starpprogramma pārbauda, vai pieprasījums ir POST pieprasījums un ja ir, tā pārbauda, vai CSRF žetons ir derīgs Flight::before('start', function() { if(Flight::request()->method == 'POST') { // uzņemiet CSRF žetonu no formas vērtībām $token = Flight::request()->data->csrf_token; if($token !== Flight::session()->get('csrf_token')) { Flight::halt(403, 'Nederīgs CSRF žetons'); } } });
Vai arī jūs varat izmantot starpprogrammu klasi:
// app/middleware/CsrfMiddleware.php namespace app\middleware; class CsrfMiddleware { public function before(array $params): void { if(Flight::request()->method == 'POST') { $token = Flight::request()->data->csrf_token; if($token !== Flight::session()->get('csrf_token')) { Flight::halt(403, 'Nederīgs CSRF žetons'); } } } } // index.php vai kur vien ir jūsu maršruti Flight::group('', function(Router $router) { $router->get('/lietotāji', [ 'UserController', 'getUsers' ]); // citas maršruti }, [ new CsrfMiddleware() ]); ## Krusta vietu skriptēšana (XSS) Krusta vietu skriptēšana (XSS) ir uzbrukuma veids, kur ļaunprātīga vietne var ievietot kodu jūsu vietnē. Lielākā daļa šādu iespēju nāk no veidlapas vērtībām, ko aizpilda jūsu gala lietotāji. Jums **nekad** nevajadzētu uzticēties jūsu lietotāju izvadei! Vienmēr pieņemiet, ka visi viņi ir labākie hakkeri pasaulē. Viņi var ievietot ļaunprātīgu JavaScript vai HTML jūsu lapā. Šo kodu var izmantot, lai nozagtu informāciju no jūsu lietotājiem vai veiktu darbības jūsu vietnē. Izmantojot Flight skata klasi, jūs varat viegli izvairīties no izvades, lai novērstu XSS uzbrukumus. ```php // Pieņemsim, ka lietotājs ir prasmīgs un mēģina izmantot to kā savu vārdu $vārds = '<script>alert("XSS")</script>'; // Tas izvairīsies no izvades Flight::view()->set('vārds', $vārds); // Tas izvadīs: <script>alert("XSS")</script> // Ja izmantojat kaut ko līdzīgu Latte kā jūsu skata klasi, tas arī automātiski iekļaus šo Flight::view()->render('veidne', ['vārds' => $vārds]);
SQL ieiešana ir uzbrukuma veids, kur ļaunprātīgs lietotājs var ievietot SQL kodu jūsu datu bāzē. To var izmantot, lai nozagtu informāciju no jūsu datu bāzes vai veiktu darbības jūsu datu bāzē. Atkal jums nekad nevajadzētu uzticēties jūsu lietotāju ievadei! Vienmēr pieņemiet, ka viņi ir aizsardzībā. Jūs varat izmantot sagatavotus teikumus savos PDO objektos, lai novērstu SQL ieiešanu.
PDO
// Pieņemot, ka jums ir Flight::db() reģistrēts kā jūsu PDO objekts $teikums = Flight::db()->prepare('IZVĒLĒT * NO lietotāji KUR lietotājvārds = :lietotājvārds'); $teikums->execute([':lietotājvārds' => $lietotājvārds]); $lietotāji = $teikums->fetchAll(); // Ja izmantojat PdoWrapper klasi, to var viegli izdarīt vienā rindiņā $lietotāji = Flight::db()->fetchAll('IZVĒLĒT * NO lietotāji, KUR lietotājvārds = :lietotājvārds', [ 'lietotājvārds' => $lietotājvārds ]); // To var izdarīt arī ar PDO objektu, izmantojot ? aizvietotājzīmes $teikums = Flight::db()->fetchAll('IZVĒLĒT * NO lietotāji KUR lietotājvārds = ?', [ $lietotājvārds ]); // Tāpēc, soliet, ka nekad NĒDARĪS kaut ko līdzīgu tam... $lietotāji = Flight::db()->fetchAll("IZVĒLĒT * NO lietotāji KUR lietotājvārds = '{$lietotājvārds}' LIMITS 5"); // jo ja $lietotājmaksas = "' VAI 1=1; -- "; // Pēc tam, kad izveidots vaicājums, tas izskatās šādi // IZVĒLĒT * NO lietotāji KUR lietotājvārds = '' VAI 1=1; -- LIMITS 5 // Tas izskatās dīvaini, bet tas ir derīgs vaicājums, kas darbosies. Patiesībā, // tas ir ļoti izplatīts SQL ieiešanas uzbrukums, kas atgriezīs visus lietotājus.
Pārkāpšanas izcelsmes resursu kopīgošana (CORS) ir mehānisms, kas ļauj daudziem resursiem (piemēram, fontiem, JavaScript utt.) tīmekļa lapā tikt pieprasītiem no citas domēna, kas neatrodas no domēna, no kura resurss nāk. Flight nepiedāvā iebūvētu funkcionalitāti, bet šo var viegli apstrādāt ar āķi, kas darbojas pirms tiek izsaukts Flight::start() metodes.
Flight::start()
// app/utils/CorsUtil.php namespace app\utils; class CorsUtil { public function set(array $params): void { $request = Flight::request(); $response = Flight::response(); if ($request->getVar('HTTP_ORIGIN') !== '') { $this->allowOrigins(); $response->header('Access-Control-Allow-Credentials', 'true'); $response->header('Access-Control-Max-Age', '86400'); } if ($request->method === 'OPTIONS') { if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_METHOD') !== '') { $response->header( 'Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD' ); } if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') !== '') { $response->header( "Access-Control-Allow-Headers", $request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') ); } $response->status(200); $response->send(); exit; } } private function allowOrigins(): void { // pielāgojiet savus atļautos saiturus šeit. $allowed = [ # Drošība Drošība ir liela lieta, kad runa ir par tīmekļa lietojumprogrammām. Jums ir jāpārliecinās, ka jūsu lietojumprogramma ir droša un jūsu lietotāju dati ir drošībā. Flight nodrošina vairākas funkcijas, lai palīdzētu jums nodrošināt savas tīmekļa lietojumprogrammas. ## Galvenes HTTP galvenes ir viens no vieglākajiem veidiem, kā nodrošināt savas tīmekļa lietojumprogrammas. Jūs varat izmantot galvenes, lai novērstu klikšķu izviltības, XSS un citas uzbrukumus. Ir vairāki veidi, kā pievienot šīs galvenes savai lietojumprogrammai. Divas lieliskas vietnes, kur pārbaudīt savu galvenu drošību, ir [securityheaders.com](https://securityheaders.com/) un [observatory.mozilla.org](https://observatory.mozilla.org/). ### Pievienot manuāli Varat manuāli pievienot šīs galvenes, izmantojot `header` metodi `Flight\Response` objektam. ```php // Iestatiet X-Frame-Options galveni, lai novērstu klikšķu izviltības Flight::response()->header('X-Frame-Options', 'SAMEORIGIN'); // Iestatiet Content-Security-Policy galveni, lai novērstu XSS // Piezīme: šī galvene var kļūt ļoti sarežģīta, tāpēc jums būs // jākonsultējas ar piemēriem internetā savai lietojumprogrammai Flight::response()->header("Content-Security-Policy", "default-src 'self'"); // Iestatiet X-XSS-Protection galveni, lai novērstu XSS Flight::response()->header('X-XSS-Protection', '1; mode=block'); // Iestatiet X-Content-Type-Options galveni, lai novērstu MIME sīkdatņu izjaukšanu Flight::response()->header('X-Content-Type-Options', 'nosniff'); // Iestatiet Referrer-Policy galveni, lai kontrolētu, cik daudz atsauces informācijas ir nosūtīts Flight::response()->header('Referrer-Policy', 'no-referrer-when-downgrade'); // Iestatiet Strict-Transport-Security galveni, lai piespiestu HTTPS Flight::response()->header('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload'); // Iestatiet Permissions-Policy galveni, lai kontrolētu, kādas funkcijas un API var izmantot Flight::response()->header('Permissions-Policy', 'geolocation=()');
// Pieņemot, ka jums ir Flight::db() reģistrēts kā jūsu PDO objekts $teikums = Flight::db()->prepare('IZVĒLĒT * NO lietotāji KUR lietotājvārds = :lietotājvārds'); $teikums->execute([':lietotājvārds' => $lietotājvārds]); $lietotāji = $teikums->fetchAll(); // Ja izmantojat PdoWrapper klasi, to var viegli izdarīt vienā rindiņā $lietotāji = Flight::db()->fetchAll('IZVĒLĒT * NO lietotāji, KUR lietotājvārds = :lietotājvārds', [ 'lietotājvārds' => $lietotājvārds ]); // To var izdarīt arī ar PDO objektu, izmantojot ? aizvietotājzīmes $teikums = Flight::db()->fetchAll('IZVĒLĒT * NO lietotāji KUR lietotājvārds = ?', [ $lietotājvārds ]); // Just promise you will never EVER do something like this... $lietotāji = Flight::db()->fetchAll("IZVĒLĒT * NO lietotāji KUR lietotājvārds = '{$lietotājvārds}' LIMITS 5"); // because what if $username = "' OR 1=1; -- "; // After the query is build it looks like this // SELECT * FROM users WHERE username = '' OR 1=1; -- LIMIT 5 // It looks strange, but it's a valid query that will work. In fact, // it's a very common SQL injection attack that will return all users.
// app/utils/CorsUtil.php namespace app\utils; class CorsUtil { public function set(array $params): void { $request = Flight::request(); $response = Flight::response(); if ($request->getVar('HTTP_ORIGIN') !== '') { $this->allowOrigins(); $response->header('Access-Control-Allow-Credentials', 'true'); $response->header('Access-Control-Max-Age', '86400'); } if ($request->method === 'OPTIONS') { if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_METHOD') !== '') { $response->header( 'Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD' ); } if ($request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') !== '') { $response->header( "Access-Control-Allow-Headers", $request->getVar('HTTP_ACCESS_CONTROL_REQUEST_HEADERS') ); } $response->status(200); $response->send(); exit; } } private function allowOrigins(): void { // pielāgojiet savus atļautos saiturus šeit. $allowed = [ 'capacitor://localhost', 'ionic://localhost', 'http://localhost', 'http://localhost:4200', 'http://localhost:8080', 'http://localhost:8100', ]; $request = Flight::request(); if (in_array($request->getVar('HTTP_ORIGIN'), $allowed, true) === true) { $response = Flight::response(); $response->header("Access-Control-Allow-Origin", $request->getVar('HTTP_ORIGIN')); } } } // index.php or wherever you have your routes $CorsUtil = new CorsUtil(); Flight::before('start', [ $CorsUtil, 'setupCors' ]);
Flight ļauj jums pārrakstīt tās noklusējuma funkcionalitāti, lai pielāgotu to savām vajadzībām, neiesaistoties tajā nekādā veidā.
Piemēram, kad Flight nevar sakrist ar URL adresi maršrutam, tas izsauc notFound metodi, kas nosūta vispārēju HTTP 404 atbildi. Jūs varat pārrakstīt šo darbību izmantojot map metodi:
HTTP 404
map
Flight::map('notFound', function() { // Parādīt pielāgoto 404. lapu include 'errors/404.html'; });
Flight arī ļauj jums aizstāt pamata framework komponentes. Piemēram, jūs varat aizstāt noklusējuma Router klasi ar savu pielāgoto klasi:
// Reģistrējiet savu pielāgoto klasi Flight::register('router', MyRouter::class); // Kad Flight ielādē Router instanci, tā ielādēs jūsu klasi $myrouter = Flight::router();
Framework metodēm, piemēram, map un register, tomēr nevar pārrakstīt. Jums iegūsiet kļūdu, ja mēģināsiet to izdarīt.
register
Piezīme: Vai vēlaties uzzināt vairāk par maršrutēšanu? Aplūkojiet "kāpēc izmantot ietvaru?" lapu, lai saņemtu detalizētāku skaidrojumu.
Pamata maršrutēšanu "Flight" veic, salīdzinot URL šablonu ar atsauces funkciju vai klases un metodes masīvu.
Flight::route('/', function(){ echo 'sveika pasaule!'; });
Maršruti tiek sakrāti saskaņā ar to definēšanas secību. Pirmajam sakrāto maršrutēšanai tiks izsaukts.
Atsauces var būt jebkāds objekts, kurš ir izsaukams. Tāpēc varat izmantot parasto funkciju:
function hello(){ echo 'sveika pasaule!'; } Flight::route('/', 'hello');
Jūs varat izmantot arī klases statisko metodi:
class Greeting { public static function hello() { echo 'sveika pasaule!'; } } Flight::route('/', [ 'Greeting','hello' ]);
Vai arī, izveidojot vispirms objektu un tad izsaukot metodi:
// Greeting.php class Greeting { public function __construct() { $this->name = 'Jānis Bērziņš'; } public function hello() { echo "Sveiki, {$this->name}!"; } } // index.php $greeting = new Greeting(); Flight::route('/', [ $greeting, 'hello' ]); // To varat izdarīt arī bez objekta izveides // Piezīme: konstruktorā netiks ievadīti argumenti Flight::route('/', [ 'Greeting', 'hello' ]);
Ja vēlaties izmantot atkarības iegūšanu izmantojot konteineri (PSR-11, PHP-DI, Dice, utt.), tikai vienīgais veids, kā tas ir iespējams izmantojot maršrutus, ir vai nu tieši izveidojot objektu pats un izmantojot konteineri, lai izveidotu savu objektu, vai arī izmantojot virknes, lai definētu klasi un metodi, kuru izsaukt. Varat doties uz Atkarības Iegūšana lapu, lai iegūtu vairāk informācijas.
Šeit ir īss piemērs:
lietot flight\databāze\PdoWrapper; // Greeting.php class Greeting { protected PdoWrapper $pdoWrapper; public function __construct(PdoWrapper $pdoWrapper) { $this->pdoWrapper = $pdoWrapper; } public function hello(int $id) { // darīt kaut ko ar $this->pdoWrapper $vārds = $this->pdoWrapper->fetchField("SELECT vārds FROM lietotāji WHERE id = ?", [ $id ]); echo "Sveiki, pasaule! Mani sauc {$vārds}!"; } } // index.php // Izveidojiet konteineru ar nepieciešamajiem parametriem // Skatiet Atkarības Iegūšana lapu, lai iegūtu vairāk informācijas par PSR-11 $dice = new \Dice\Dice(); // Neaizmirstiet atkārtoti piešķirt mainīgo ar '$dice = '!!!!! $dice = $dice->addRule('flight\databāze\PdoWrapper', [ 'koplietojams' => true, 'constructParams' => [ 'mysql:host=localhost;dbname=test', 'root', 'parole' ] ]); // Reģistrējiet konteineru apstrādes elementu Flight::registerContainerHandler(function($klase, $parametri) use ($dice) { return $dice->create($klase, $parametri); }); // Maršruti kā parasti Flight::route('/sveiki/@id', [ 'Greeting', 'hello' ]); // vai Flight::route('/sveiki/@id', 'Greeting->hello'); // vai Flight::route('/sveiki/@id', 'Greeting::hello'); Flight::start();
# Mainīgie Flight ļauj saglabāt mainīgos, lai tos varētu izmantot jebkur aplikācijā. ```php // Saglabā savu mainīgo Flight::set('id', 123); // Citur aplikācijā $id = Flight::get('id');
Lai pārbaudītu, vai mainīgais ir iestatīts, varat izdarīt:
if (Flight::has('id')) { // Izdarīt kaut ko }
Mainīgo var notīrīt:
// Notīra id mainīgo Flight::clear('id'); // Notīra visus mainīgos Flight::clear();
Flight izmanto mainīgos arī konfigurācijas nolūkos.
Atkarību injekcijas konteiners (DIC) ir spēcīgs rīks, kas ļauj jums pārvaldīt jūsu lietojumprogrammas atkarības. Tas ir galvenais koncepts mūsdienu PHP ietvaros un tiek izmantots, lai pārvaldītu objektu instancēšanu un konfigurāciju. Veidi, kādi DIC bibliotēkas ir: Dice, Pimple, PHP-DI, un league/container.
DIC ir greznā veidā teikt, ka tas ļauj jums izveidot un pārvaldīt jūsu klases centrālizētā vietā. Tas ir noderīgi, ja jums ir nepieciešams nodot to pašu objektu vairākām klasēm (piemēram, jūsu kontrolieriem). Viegls piemērs varētu palīdzēt šo padarīt skaidrāku.
Vecais veids, kā darīt lietas, varētu izskatīties šādi:
require 'vendor/autoload.php'; // klase, lai pārvaldītu lietotājus no datu bāzes class UserController { protected PDO $pdo; public function __construct(PDO $pdo) { $this->pdo = $pdo; } public function view(int $id) { $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id'); $stmt->execute(['id' => $id]); print_r($stmt->fetch()); } } $User = new UserController(new PDO('mysql:host=localhost;dbname=test', 'lietotājvārds', 'parole')); Flight::route('/lietotājs/@id', [ $UserController, 'view' ]); Flight::start();
Jūs varat redzēt no augstāk minētā koda, ka mēs izveidojam jaunu PDO objektu un nododam to mūsu UserController klasei. Tas ir labi mazai lietojumprogrammai, bet kad jūsu lietojumprogramma aug, jūs atklāsiet, ka izveidojat to pašu PDO objektu vairākos vietās. Tieši šeit noder DIC.
UserController
Šeit ir tas pats piemērs, izmantojot DIC (izmantojot Dice):
require 'vendor/autoload.php'; // tāda pati klase kā iepriekš. Nav nekā mainījies class UserController { protected PDO $pdo; public function __construct(PDO $pdo) { $this->pdo = $pdo; } public function view(int $id) { $stmt = $this->pdo->prepare('SELECT * FROM users WHERE id = :id'); $stmt->execute(['id' => $id]); print_r($stmt->fetch()); } } // izveidot jaunu konteineri $container = new \Dice\Dice; // neaizmirstiet atkārtoti piešķirt to sev tāpat kā zemāk! $container = $container->addRule('PDO', [ // shared nozīmē, ka tiks atgriezts tas pats objekts katru reizi 'shared' => true, 'constructParams' => ['mysql:host=localhost;dbname=test', 'lietotājvārds', 'parole' ] ]); // Tas reģistrē konteineru apstrādātāju, lai Flight zinātu, ka to izmantot. Flight::registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); // tagad mēs varam izmantot konteineri, lai izveidotu mūsu UserController Flight::route('/lietotājs/@id', [ 'UserController', 'view' ]); // vai arī alternatīvi varat definēt maršrutu šādi Flight::route('/lietotājs/@id', 'UserController->view'); // vai Flight::route('/lietotājs/@id', 'UserController::view'); Flight::start();
Es uzdrīkotos iedomāties, ka jūs domājāt, ka piemēram tika pievienots daudz papildu koda. Maģija rodas, kad jums ir cita kontroliera, kuram nepieciešams PDO objekts.
// Ja visi jūsu kontrolieri ir konstruktoru, kuram nepieciešams PDO objekts // katram zemāk esošajam maršrutam automātiski tiks injicēts !!! Flight::route('/uzņēmums/@id', 'CompanyController->view'); Flight::route('/organizācija/@id', 'OrganizationController->view'); Flight::route('/kategorija/@id', 'CategoryController->view'); Flight::route('/uzstādījumi', 'SettingsController->view');
Pievienotais bonuss, izmantojot DIC, ir tas, ka vienības testēšana kļūst daudz vienkāršāka. Jūs varat izveidot nepatiesu objektu un nodot to savai klasei. Tas ir milzīgs ieguvums, rakstot tests jūsu lietojumprogrammai!
Flight var izmantot jebkuru PSR-11 atbilstošu konteineri. Tas nozīmē, ka jūs varat izmantot jebkuru konteineri, kas īsteno PSR-11 interfeisu. Šeit ir piemērs, izmantojot League's PSR-11 konteineri:
require 'vendor/autoload.php'; // tāda pati UserController klase kā iepriekš $container = new \League\Container\Container(); $container->add(UserController::class)->addArgument(PdoWrapper::class); $container->add(PdoWrapper::class) ->addArgument('mysql:host=localhost;dbname=test') ->addArgument('lietotājvārds') ->addArgument('parole'); Flight::registerContainerHandler($container); Flight::route('/lietotājs', [ 'UserController', 'view' ]); Flight::start();
Lai gan tas var būt nedaudz izsmeļošāks nekā iepriekšējais Dice piemērs, tas joprojām izdara darbu ar tādām pašām priekšrocībām!
Jūs varat arī izveidot savu DIC apstrādātāju. Tas ir noderīgi, ja jums ir pielāgots konteiners, ko jūs vēlaties izmantot, kas nav PSR-11 (Dice). Skatiet pamata piemēru, kā to izdarīt.
Papildus tam ir dažas noderīgas noklusējuma vērtības, kas atvieglos jūsu dzīvi, izmantojot Flight.
Ja izmantojat Engine instanci savos kontrolieros/starpprogrammatūrā, šeit ir, kā jūs to konfigurētu:
Engine
// Kaut kur jūsu sākotnējās datnes $dzinējs = Flight::app(); $container = new \Dice\Dice; $container = $container->addRule('*', [ 'substitutions' => [ // Šeit jūs padodat instanci Engine::class => $dzinējs ] ]); $dzinējs->registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); // Tagad jūs varat izmantot Dzinēja instanci savos kontrolieros/starpprogrammatūrā class MyController { public function __construct(Engine $lietojumprogramma) { $this->lietojumprogramma = $lietojumprogramma; } public function index() { Šī->lietojumprogramma->render('indekss'); } }
Ja jums ir citas klases, ko vēlaties pievienot konteinerim, ar Dice tas ir viegli, jo tās automātiski tiks atrisinātas ar konteineri. Šeit ir piemērs:
$container = new \Dice\Dice; // Ja jums nav jāievēro nekāda savas klases // jums nav nepieciešams neko definēt! Flight::registerContainerHandler(function($class, $params) use ($container) { return $container->create($class, $params); }); class MansPielāgotaisKlase { public function analizējietLietu() { atgriezt 'lieta'; } } class UserController { protected MyCustomClass $MansPielāgotaisKlase; public function __construct(MyCustomClass $MansPielāgotaisKlase) { Šī->MansPielāgotaisKlase = $MansPielāgotaisKlase; } public function index() { echo $this->MansPielāgotaisKlase->parseThing(); } } Flight::route('/lietotājs', 'UserController->index');
Flight atbalsta maršruta un grupas maršruta starpniekus. Starpnieks ir funkcija, kas tiek izpildīta pirms (vai pēc) maršruta atzvana. Tas ir lielisks veids, kā pievienot API autentifikācijas pārbaudes jūsu kodā vai pārbaudīt, vai lietotājam ir atļauja piekļūt maršrutam.
Šeit ir pamata piemērs:
// Ja nodrošināt tikai anonīmu funkciju, tā tiks izpildīta pirms maršruta atzvana. // nav "pēc" starpnieku funkciju, izņemot klases (skatīt zemāk) Flight::route('/ceļš', function() { echo ' Šeit esmu!'; })->addMiddleware(function() { echo 'Pirmkods starpnieks!'; }); Flight::start(); // Tas izvadīs "Pirmkods starpnieks! Šeit esmu!"
Ir daži ļoti svarīgi piezīmju punkti par starpniekiem, par kuriem jums vajadzētu zināt, pirms tos izmantojat:
Flight::redirect()
function($params) { ... }
public function before($params) {}
flight\Engine
__construct()
Starpnieks var tikt reģistrēts arī kā klase. Ja jums ir nepieciešama "pēc" funkcionalitāte, jums jā izmanto klase.
class MansStarpnieks { public function before($params) { echo 'Pirmkods starpnieks!'; } public function after($params) { echo 'Pēckods starpnieks!'; } } $MansStarpnieks = new MansStarpnieks(); Flight::route('/ceļš', function() { echo ' Šeit esmu! '; })->addMiddleware($MansStarpnieks); // arī ->addMiddleware([ $MansStarpnieks, $MansStarpnieks2 ]); Flight::start(); // Tas izvadīs "Pirmkods starpnieks! Šeit esmu! Pēckods starpnieks!"
Tēlojiet, ka jums ir autentifikācijas starpnieks, un ja lietotājs nav autentificējies, jūs vēlaties novirzīt lietotāju uz pieteikšanās lapu. Jums ir vairākas opcijas:
Šeit ir vienkāršs atgriešanās false; piemērs:
class MansStarpnieks { public function before($params) { if (isset($_SESSION['user']) === false) { return false; } // jo tas ir patiess, viss turpina iet savu ceļu } }
Šeit ir piemērs, kā novirzīt lietotāju uz pieteikšanās lapu:
class MansStarpnieks { public function before($params) { if (isset($_SESSION['user']) === false) { Flight::redirect('/pieteikties'); exit; } } }
Tēlojiet, ka jums ir jāizvada JSON kļūda, jo jūs izstrādājat API. To var izdarīt šādi:
class MansStarpnieks { public function before($params) { $autentifikācija = Flight::request()->headers['Authorization']; if(empty($autentifikācija)) { Flight::json(['error' => 'Jums jābūt pierakstījušies, lai piekļūtu šai lapai.'], 403); exit; // vai Flight::halt(403, json_encode(['error' => 'Jums jābūt pierakstījušies, lai piekļūtu šai lapai.']); } } }
Jūs varat pievienot maršruta grupu un tad katram maršrutam šajā grupā būs tāds pats starpnieks. Tas ir noderīgi, ja jums ir jāgrupē vairāki maršruti, piemēram, pēc Autentifikācijas starpnieka, lai pārbaudītu API atslēgu galvenē.
// pievienots grupas metodei Flight::group('/api', function() { // Šis "tukšais" izskatās tikai grupa atbilst /api Flight::route('', function() { echo 'api'; }, false, 'api'); Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotāji'); Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotājs_skats'); }, [ jauns ApiAutentifikācijasMiddleware() ]);
Ja vēlaties piemērot globālo starpnieku visiem saviem maršrutiem, varat pievienot "tukšu" grupu:
// pievienots grupas metodei Flight::group('', function() { Flight::route('/lietotāji', function() { echo 'lietotāji'; }, false, 'lietotāji'); Flight::route('/lietotāji/@id', function($id) { echo 'lietotājs:'.$id; }, false, 'lietotājs_skats'); }, [ jauns ApiAutentifikācijasMiddleware() ]);
Lidojums ļauj jums filtrēt metodes pirms un pēc to izsaukšanas. Nav iepriekš definētu āķu, ko jums vajadzētu iemācīties atmiņā. Jūs varat filtrēt jebkuru noklusējuma ietvaru metodi, kā arī jebkuras pielāgotas metodes, ko esat atainojis.
Filtrēšanas funkcija izskatās šādi:
function (array &$params, string &$output): bool { // Filtrēšanas kods }
Izmantojot padotos mainīgos, jūs varat manipulēt ievades parametrus un/vai izvadi.
Jūs varat ļaut filtram darboties pirms metodes, izmantojot:
Flight::before('start', function (array &$params, string &$output): bool { // Darīt kaut ko });
Jūs varat ļaut filtram darboties pēc metodes, izmantojot:
Flight::after('start', function (array &$params, string &$output): bool { // Darīt kaut ko });
Jūs varat pievienot tik daudz filtrus, cik vēlaties, jebkurai metodai. Tie tiks izsaukti tādā secībā, kādā tie ir deklarēti.
Šeit ir piemērs par filtrēšanas procesu:
// Atainot pielāgotu metodi Flight::map('hello', function (string $name) { return "Sveiki, $name!"; }); // Pievienot pirms filtru Flight::before('hello', function (array &$params, string &$output): bool { // Manipulēt parametru $params[0] = 'Jānis'; return true; }); // Pievienot pēc filtra Flight::after('hello', function (array &$params, string &$output): bool { // Manipulēt izvadi $output .= " Jums laimīgu dienu!"; return true; }); // Izsaukt pielāgoto metodi echo Flight::hello('Roberts');
Tas vajadzētu parādīt:
Sveiki Jānis! Jums laimīgu dienu!
Ja esat definējis vairākus filtrus, jūs varat pārtraukt ķēdi, atgriežot false jebkurā no jūsu filtra funkcijām:
false
Flight::before('start', function (array &$params, string &$output): bool { echo 'viens'; return true; }); Flight::before('start', function (array &$params, string &$output): bool { echo 'divi'; // Tas pārtrauks ķēdi return false; }); // Tas netiks izsaukts Flight::before('start', function (array &$params, string &$output): bool { echo 'trīs'; return true; });
Piezīme, pamata metodes, piemēram, map un register, nevar būt filtri, jo tos izsauc tieši, nevis dinamiski.
Flight ietver HTTP pieprasījumu vienā objektā, kuram var piekļūt, veicot:
$request = Flight::request();
Pieprasījuma objekts nodrošina šādas īpašības:
Jūs varat piekļūt query, data, cookies un files īpašībām kā masīviem vai objektiem.
query
data
cookies
files
Tātad, lai iegūtu pieprasījuma virknes parametru, jūs varat izdarīt:
$id = Flight::request()->query['id'];
Vai arī varat izdarīt:
$id = Flight::request()->query->id;
Lai iegūtu neapstrādātu HTTP pieprasījuma ķermeni, piemēram, darbojoties ar PUT pieprasījumiem, jūs varat izdarīt:
$body = Flight::request()->getBody();
Ja nosūtāt pieprasījumu ar tipu application/json un datiem {"id": 123} tas būs pieejams no data īpašības:
application/json
{"id": 123}
$id = Flight::request()->data->id;
$_SERVER
Ir ātrgaita pieejama, lai piekļūtu $_SERVER masīvam, izmantojot getVar() metodi:
getVar()
$host = Flight::request()->getVar['HTTP_HOST'];
Jūs varat piekļūt pieprasījuma galvenumiem, izmantojot getHeader() vai getHeaders() metodi:
getHeader()
getHeaders()
// Varbūt jums nepieciešams Autentifikācijas galvenums $host = Flight::request()->getHeader('Authorization'); // Ja vēlaties iegūt visus galvenumus $headers = Flight::request()->getHeaders();
Flight ir izstrādāts, lai būtu viegli lietojams un saprotams. Zemāk ir pilns metožu kopums ietvariem. Tas sastāv no pamatmetodēm, kas ir parastie statiskie metodes, un paplašināmās metodes, kas ir kartētas metodes, kurām var piemērot filtrus vai pārrakstīt.
Flight::map(virkne $nosaukums, callable $atgriezamā_virziena_funkcija, bool $ietekme_uz_marsrutu = false) // Izveido pielāgotu ietvaru metodi. Flight::register(virkne $nosaukums, string $klase, masīvs $parametri = [], ?callable $atgriezamā_virziena_funkcija = null) // Reģistrē klasi ietvaru metodē. Flight::before(virkne $nosaukums, callable $atgriezamā_virziena_funkcija) // Pievieno filtru pirms ietvaru metodes. Flight::after(virkne $nosaukums, callable $atgriezamā_virziena_funkcija) // Pievieno filtru pēc ietvaru metodes. Flight::path(virkne $ceļš) // Pievieno ceļu automātiskai klasielu ielādei. Flight::get(virkne $atslēga) // Iegūst mainīgo. Flight::set(virkne $atslēga, mixed $vertība) // Iestata mainīgo. Flight::has(virkne $atslēga) // Pārbauda, vai mainīgais ir iestatīts. Flight::clear(masīvs|virkne $atslēga = []) // Nodzēš mainīgo. Flight::init() // Inicializē ietvaru tās noklusētajos iestatījumos. Flight::app() // Iegūst aplikācijas objekta instanci
Flight::start() // Sāk ietvaru. Flight::stop() // Aptur ietvaru un nosūta atbildi. Flight::halt(int $kods = 200, virkne $ziņojums = '') // Aptur ietvaru ar neobligātu statusa kodu un ziņojumu. Flight::route(virkne $parauga, callable $atgriezamā_virziena_funkcija, bool $ietekme_uz_marsrutu = false) // Kartē URL paraugu atpakaļsaukumam. Flight::group(virkne $parauga, callable $atgriezamā_virziena_funkcija) // Izveido grupēšanu URL, paraugs ir jābūt virknei. Flight::redirect(virkne $url, int $kods) // Novirza uz citu URL. Flight::render(virkne $fails, masīvs $datus, ?string $atslēga = null) // Atveido veidnes failu. Flight::error(Throwable $kļūda) // Nosūta HTTP 500 atbildi. Flight::notFound() // Nosūta HTTP 404 atbildi. Flight::etag(virkne $id, virkne $tips = 'string') // Veic ETag HTTP kešošanu. Flight::lastModified(int $laiks) // Veic pēdējo modificēto HTTP kešošanu. Flight::json(mixed $datus, int $kods = 200, bool $kodēt = true, virkne $kodēšanas_kopa = 'utf8', int $opcija) // Nosūta JSON atbildi. Flight::jsonp(mixed $datus, virkne $param = 'jsonp', int $kods = 200, bool $kodēt = true, virkne $kodēšanas_kopa = 'utf8', int $opcija) // Nosūta JSONP atbildi.
Jebkuras pielāgotas metodes, kas pievienotas ar map un register, var arī tikt filtrētas.
Flight ir izstrādāts, lai būtu viegli lietojams un saprotams. Zemāk ir pilns struktūras metožu kopums. Tas sastāv no pamatmetodēm, kas ir parastas statiskas metodes, un paplašināmajām metodēm, kas ir pievienotas metodes, kuras var filtrēt vai pārrakstīt.
Šīs metodes ir būtiskas struktūrai un tās nevar pārrakstīt.
Flight::map(virkne $name, izsaukums $callback, booleāns $pass_route = false) // Izveido pielāgotu struktūras metodi. Flight::register(virkne $name, virkne $class, masīvs $params = [], ?izsaukums $callback = null) // Reģistrē klasi struktūras metodē. Flight::unregister(virkne $name) // Atceļ klasi no struktūras metodes. Flight::before(virkne $name, izsaukums $callback) // Pievieno filtru pirms struktūras metodes. Flight::after(virkne $name, izsaukums $callback) // Pievieno filtru pēc struktūras metodes. Flight::path(virkne $path) // Pievieno ceļu, lai automātiski ielādētu klases. Flight::get(virkne $key) // Iegūst mainīgo vērtību. Flight::set(virkne $key, mixed $value) // Iestata mainīgo vērtību. Flight::has(virkne $key) // Pārbauda, vai mainīgais ir iestatīts. Flight::clear(masīvs|virkne $key = []) // Notīra mainīgo. Flight::init() // Inicializē struktūru pēc noklusējuma iestatījumiem. Flight::app() // Iegūst lietojumprogrammas objekta instanci. Flight::request() // Iegūst pieprasījuma objekta instanci. Flight::response() // Iegūst atbildes objekta instanci. Flight::router() // Iegūst maršrutētāja objekta instanci. Flight::view() // Iegūst skata objekta instanci.
Flight::start() // Sāk struktūru. Flight::stop() // Aptur struktūru un nosūta atbildi. Flight::halt(int $code = 200, virkne $message = '') // Aptur struktūru ar iespējamo statusa kodu un ziņojumu. Flight::route(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē URL paraugu pieprasījumam. Flight::post(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē POST pieprasījuma URL paraugu pieprasījumam. Flight::put(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē PUT pieprasījuma URL paraugu pieprasījumam. Flight::patch(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē PATCH pieprasījuma URL paraugu pieprasījumam. Flight::delete(virkne $pattern, izsaukums $callback, booleāns $pass_route = false, virkne $alias = '') // Kartē DELETE pieprasījuma URL paraugu pieprasījumam. Flight::group(virkne $pattern, izsaukums $callback) // Izveido grupēšanu URL adresēm, paraugam jābūt virknei. Flight::getUrl(virkne $name, masīvs $params = []) // Ģenerē URL, balstoties uz maršruta aliasu. Flight::redirect(virkne $url, int $code) // Novirza uz citu URL adresi. Flight::render(virkne $file, masīvs $data, ?virkne $key = null) // Atveido veidni failā. Flight::error(Throwable $error) // Sūta HTTP 500 atbildi. Flight::notFound() // Sūta HTTP 404 atbildi. Flight::etag(virkne $id, virkne $type = 'string') // Veic ETag HTTP kešošanu. Flight::lastModified(int $time) // Veic pēdējo modificēto HTTP kešošanu. Flight::json(mixed $data, int $code = 200, booleāns $encode = true, virkne $charset = 'utf8', int $option) // Sūta JSON atbildi. Flight::jsonp(mixed $data, virkne $param = 'jsonp', int $code = 200, booleāns $encode = true, virkne $charset = 'utf8', int $option) // Sūta JSONP atbildi.
Jebkuras pielāgotas metodes, kas pievienotas ar map un register, var tikt filtrētas.
Daži programmētāji kategoriski iebilst pret ietvaru izmantošanu. Viņi argumentē, ka ietvari ir pārbāzti, lēni un grūti uzsākt. Viņi saka, ka ietvari nav nepieciešami un ka jūs varat rakstīt labāku kodu bez tiem. Noteikti ir daži argumenti, kas varētu tikt izvirzīti par ietvaru izmantošanas trūkumiem. Tomēr ir arī daudz priekšrocību, izmantojot ietvarus.
Šeit ir daži iemesli, kāpēc jūs varētu vēlēties izvērtēt ietvaru izmantošanu:
Flight ir mikro-ietvars. Tas nozīmē, ka tas ir neliels un viegls. Tas nenodrošina tik daudz funkciju kā lielāki ietvari, piemēram, Laravel vai Symfony. Tomēr tas nodrošina daudz funkciju, kas jums ir nepieciešamas, lai veidotu tīmekļa lietojumprogrammas. Tas ir arī viegli uzzināt un izmantot. Tas padara to par labu izvēli, lai viegli un ātri veidotu tīmekļa lietojumprogrammas. Ja esat jauns ietvaru lietotājs, Flight ir lielisks ietvars iesācējiem, ar kuru sākt. Tas palīdzēs jums uzzināt par ietvaru izmantošanas priekšrocībām, neapslīpējoties ar pārāk lielu sarežģītību. Kad jums ir nedaudz pieredzes ar Flight, būs vieglāk pāriet uz sarežģītākiem ietvariem, piemēram, Laravel vai Symfony, tomēr Flight joprojām var veiksmīgi izveidot izturīgu lietojumprogrammu.
Maršrutēšana ir Flight ietvara pamats, bet ko tā īsti nozīmē? Maršrutēšana ir process, kas ņem URL un saskaņo to ar konkrētu funkciju jūsu kodā. Tādējādi jūs varat padarīt savu tīmekļa vietni dažāda veida pamatojoties uz pieprasīto URL. Piemēram, jūs varētu vēlēties parādīt lietotāja profilu, kad tie apmeklē /lietotājs/1234, bet rādīt visu lietotāju sarakstu, kad viņi apmeklē /lietotāji. Tas viss tiek darīts, izmantojot maršrutēšanu.
/lietotājs/1234
/lietotāji
Varētu darboties kaut kas tāds:
http://piemērs.com/lietotājs/1234
Flight::route('/lietotājs/@id', [ 'UserController', 'skatītLietotājaProfilu' ]);
skatītLietotājaProfilu($id)
1234
$id
skatītLietotājaProfilu()
Pareizi centralizēta maršrutēšanas sistēma faktiski var ievērojami atvieglot jūsu dzīvi! Pirmajā reizē to var būt grūti saprast. Šeit ir daži iemesli, kāpēc:
lietotājs_skats
id
/administrators/lietotājs/1234
Esmu pārliecināts, ka jūs esat iepazinies ar skriptu pa skriptam veidu, kā izveidot tīmekļa vietni. Jums varētu būt fails, ko sauc par index.php, kurā ir daudz if izteiksmes, lai pārbaudītu URL un pēc tam palaistu konkrētu funkciju, pamatojoties uz URL. Tas ir veida maršrutēšana, bet tas nav ļoti organizēts un tas ātri var izvirtuļoties no kontroles. Flight maršrutēšanas sistēma ir daudz labāk organizēta un spēcīgāka maršrutēšanas veids.
if
Šis?
// /lietotājs/skatīt_profila.php?id=1234 if ($_GET['id']) { $id = $_GET['id']; skatītLietotājaProfilu($id); } // /lietotājs/rediģēt_profila.php?id=1234 if ($_GET['id']) { $id = $_GET['id']; rediģētLietotājaProfilu($id); } // utt...
Vai šis?
// index.php Flight::route('/lietotājs/@id', [ 'UserController', 'skatītLietotājaProfilu' ]); Flight::route('/lietotājs/@id/rediģēt', [ 'UserController', 'rediģētLietotājaProfilu' ]); // Iespējams, jūsu app/controllers/UserController.php class UserController { public function skatītLietotājaProfilu($id) { // dari kaut ko } public function rediģētLietotājaProfilu($id) { // dari kaut ko } }
Cerams, jūs varat sākt izprast priekšrocības izmantojot centralizētu maršrutēšanas sistēmu. Tā ir daudz ērtāk pārvaldāma un saprotamā nākotnē!
Flight nodrošina vienkāršu un vieglu veidu, kā apstrādāt pieprasījumus un atbildes. Tas ir tīmekļa ietvara kodols. Tas ievieš pieprasījumu no lietotāja pārlūka, apstrādā to un pēc tam nosūta atbildi. Šis ir veids, kā jūs varat veidot tīmekļa lietojumprogrammas, kas darbojas tā, kā parāda lietotāja profilu, ļauj lietotājam ienākt, vai ļauj lietotājam izveidot jaunu bloga ierakstu.
Pieprasījums ir tas, ko lietotāja pārlūks sūta uz jūsu serveri, kad viņi apmeklē jūsu tīmekļa vietni. Šis pieprasījums satur informāciju par to, ko lietotājs vēlas darīt. Piemēram, tas var saturēt informāciju par to, kādu URL lietotājs vēlas apmeklēt, kādus datus lietotājs vēlas nosūtīt uz jūsu serveri vai kādu veidu datus lietotājs vēlas saņemt no jūsu servera. Svarīgi ir zināt, ka pieprasījums ir tikai lasījams. Jūs nevarat mainīt pieprasījumu, bet varat to lasīt.
Ar Flight ir vienkārši piekļūt informācijai par pieprasījumu. Jūs varat piekļūt informācijai par pieprasījumu, izmantojot metodi Flight::request(). Šī metode atgriež Request objektu, kas satur informāciju par pieprasījumu. Jūs varat izmantot šo objektu, lai piekļūtu informācijai par pieprasījumu, piemēram, URL, metodi vai datiem, ko lietotājs nosūtījis uz jūsu serveri.
Flight::request()
Request
Atbilde ir tas, ko jūsu serveris nosūta atpakaļ uz lietotāja pārlūku, kad viņi apmeklē jūsu tīmekļa vietni. Šī atbilde satur informāciju par to, ko jūsu serveris vēlas darīt. Piemēram, tā var saturēt informāciju par to, kāda veida datus jūsu serveris vēlas nosūtīt lietotājam, kāda veida datus jūsu serveris vēlas saņemt no lietotāja vai kāda veida datus jūsu serveris vēlas saglabāt uz lietotāja datora.
Ar Flight ir vienkārši nosūtīt atbildi uz lietotāja pārlūku. Jūs varat nosūtīt atbildi, izmantojot metodi Flight::response(). Šī metode ņem Response objektu kā argumentu un nosūta atbildi lietotāja pārlūkam. Jūs varat izmantot šo objektu, lai nosūtītu atbildi lietotāja pārlūkam, piemēram, HTML, JSON vai failu. Flight palīdz jums automātiski ģenerēt dažas atbildes daļas, lai padarītu lietas vieglas, bet, galu galā, jums ir kontrole par to, ko atgriezt lietotājam.
Flight::response()
Response
Flight nodrošina iebūvētu atbalstu HTTP līmeņa kešošanai. Ja kešošanas nosacījums ir izpildīts, Flight atgriezīs HTTP 304 Nav modificēts atbildi. Nākamajā reizē, kad klienta pieprasīs to pašu resursu, viņiem tiks ierosināts izmantot vietējo kešotu versiju.
304 Nav modificēts
Jūs varat izmantot lastModified metodi un padot UNIX laikrādi, lai iestatītu datumu un laiku, kad lapas tika pēdējo reizi modificētas. Klients turpinās izmantot savu kešu līdz pēdējais modificēšanas vērtība tiks mainīta.
lastModified
Flight::route('/jaunumi', function () { Flight::lastModified(1234567890); echo 'Šis saturs tiks kešots.'; });
ETag kešošana ir līdzīga Last-Modified, izņemot to, ka jūs varat norādīt jebkādu id, ko vēlaties izmantot resursam:
ETag
Last-Modified
Flight::route('/jaunumi', function () { Flight::etag('mans-unikālais-id'); echo 'Šis saturs tiks kešots.'; });
Ņemiet vērā, ka saucot gan lastModified, gan etag, tiks gan iestatīta, gan pārbaudīta kešu vērtība. Ja kešu vērtība ir vienāda starp pieprasījumiem, Flight nekavējoties nosūtīs HTTP 304 atbildi un pārtrauks apstrādi.
etag
HTTP 304
Flight palīdz ģenerēt daļu no atbildes galvenēm jums, bet jūs turat lielāko kontroli pār to, ko nosūtāt atpakaļ lietotājam. Dažreiz jūs varat piekļūt Response objektam tieši, bet lielāko laiku jūs izmantosiet Flight instanci, lai nosūtītu atbildi.
Flight
Flight izmanto ob_start() lai buferētu izvadi. Tas nozīmē, ka jūs varat izmantot echo vai print, lai nosūtītu atbildi lietotājam un Flight to uztverēs un atsūtīs atpakaļ lietotājam ar atbilstošajām galvenēm.
ob_start()
echo
print
// Tas nosūtīs "Sveika, Pasaule!" uz lietotāja pārlūku Flight::route('/', function() { echo "Sveika, Pasaule!"; }); // HTTP/1.1 200 OK // Content-Type: text/html // // Sveika, Pasaule!
Kā alternatīvu, jūs varat izsaukt write() metodi, lai pievienotu arī ķermenim.
write()
// Tas nosūtīs "Sveika, Pasaule!" uz lietotāja pārlūku Flight::route('/', function() { // izsmeļ, bet darbojas dažreiz, kad tas ir nepieciešams Flight::response()->write("Sveika, Pasaule!"); // ja vēlaties iegūt ķermeni, ko esat uzstādījis šajā punktā // varat izdarīt to šādi $body = Flight::response()->getBody(); });
Jūs varat iestatīt atbildes statusa kodu, izmantojot status metodi:
status
Flight::route('/@id', function($id) { if($id == 123) { Flight::response()->status(200); echo "Sveika, Pasaule!"; } else { Flight::response()->status(403); echo "Liegs piekļuvi"; } });
Ja vēlaties iegūt pašreizējo statusa kodu, varat izmantot status metodi bez argumentiem:
Flight::response()->status(); // 200
Jūs varat izpildīt atsauksmi uz atbildes ķermeni, izmantojot addResponseBodyCallback metodi:
addResponseBodyCallback
Flight::route('/lietotāji', function() { $db = Flight::db(); $users = $db->fetchAll("SELECT * FROM users"); Flight::render('users_table', ['users' => $users]); }); // Tas saspiest visus atbilžu ceļus jebkuram maršrutam Flight::response()->addResponseBodyCallback(function($body) { return gzencode($body, 9); });
Jūs varat pievienot vairākas atsauksmes, un tās tiks izpildītas secībā, kādā tās tika pievienotas. Tā kā tas var pieņemt jebkuru izsaucamo, tas var pieņemt klases masīvu [ $class, 'method' ], slēgumu $strReplace = function($body) { str_replace('hi', 'there', $body); };, vai funkcijas nosaukumu 'minify', ja jums būtu funkcija, lai samazinātu savu html kodu, piemēram.
[ $class, 'method' ]
$strReplace = function($body) { str_replace('hi', 'there', $body); };
'minify'
Piezīme: Maršrutu atsauksmes nedarbosies, ja izmantojat flight.v2.output_buffering konfigurācijas opciju.
Ja vēlaties, lai tas attiektos tikai uz konkrētu maršrutu, jūs varētu pievienot atsauksmi maršrutā pati:
Flight::route('/lietotāji', function() { $db = Flight::db(); $users = $db->fetchAll("SELECT * FROM users"); Flight::render('users_table', ['users' => $users]); // Tiks saspiesta tikai atbilde šim maršrutam Flight::response()->addResponseBodyCallback(function($body) { return gzencode($body, 9); }); });
Jūs arī varat izmantot vidējumu, lai piemērotu atsauksmi visiem maršrutiem, izmantojot vidēji:
// MinifyMiddleware.php class MinifyMiddleware { public function before() { Flight::response()->addResponseBodyCallback(function($body) { // Tā ir return $this->minify($body); }); } protected function minify(string $body): string { // sarīkot ķermeni return $body; } } // index.php Flight::group('/lietotāji', function() { Flight::route('', function() { /* ... */ }); Flight::route('/@id', function($id) { /* ... */ }); }, [ new MinifyMiddleware() ]);
Jūs varat iestatīt galveni, piemēram, atbildes veidu, izmantojot header metodi:
// Tas nosūtīs "Sveika, Pasaule!" uz lietotāja pārlūku kā vienkāršu tekstu Flight::route('/', function() { Flight::response()->header('Content-Type', 'text/plain'); echo "Sveika, Pasaule!"; });
Flight nodrošina atbalstu JSON un JSONP atbilžu nosūtīšanai. Lai nosūtītu JSON atbildi, jums jānosūta dati, kas jāpārvērš JSON formātā:
Flight::json(['id' => 123]);
Jūs arī varat nosūtīt statusa kodu kā otro argumentu:
Flight::json(['id' => 123], 201);
Jūs arī varat nosūtīt argumentu uz pēdējo pozīciju, lai iespējotu skaistu izdrukāšanu:
Flight::json(['id' => 123], 200, true, 'utf-8', JSON_PRETTY_PRINT);
Ja maināt opcijas, kas nosūtītas Flight::json() un vēlaties vienkāršāku sintaksi, vienkārši atkarto JSON metodi:
Flight::json()
Flight::map('json', function($data, $code = 200, $options = 0) { Flight::_json($data, $code, true, 'utf-8', $options); } // Tagad to var izmantot šādi Flight::json(['id' => 123], 200, JSON_PRETTY_PRINT);
Ja vēlaties nosūtīt JSON atbildi un apturēt izpildi, varat izmantot jsonHalt metodi. Tas ir noderīgi gadījumos, kad pārbaudāt iespējamo autorizāciju un ja lietotājam nav atļaujas, jūs varat uzreiz nosūtīt JSON atbildi un notīrīt esošo ķermeni saturs un apturēt izpildi.
jsonHalt
Flight::route('/lietotāji', function() { $authorized = someAuthorizationCheck(); // Pārbaudiet, vai lietotājam ir atļauts if($authorized === false) { Flight::jsonHalt(['kļūda' => 'Neatļauts'], 401); } // Turpiniet ar maršruta pārējo daļu });
JSONP pieprasījumiem jūs varat izvēlēties padot vaicājuma parametra nosaukumu, ko izmanto, lai definētu jūsu atsauces funkciju:
Flight::jsonp(['id' => 123], 'q');
Tādējādi, veicot GET pieprasījumu, izmantojot ?q=my_func, jums vajadzētu saņemt izvadi:
?q=my_func
my_func({"id":123});
Ja nepievienojat vaicājuma parametra nosaukumu, tas pēc noklusējuma būs jsonp.
jsonp
Jūs varat pāradresēt pašreizējo pieprasījumu, izmantojot redirect() metodi un padodot jaunu URL:
redirect()
Flight::redirect('/jauns/atrašanās/vieta');
Pēc noklusējuma Flight nosūta HTTP 303 ("Redzēt citu") statusa kodu. Jūs varat pēc izvēles iestatīt pielāgotu kodu:
Flight::redirect('/jauns/atrašanās/vieta', 401);
Jūs varat apturēt ietvaru jebkurā punktā, izsaucot halt metodi:
Jūs varat arī norādīt neobligātu HTTP statusa kodu un ziņojumu:
Flight::halt(200, 'Atgriezies pēc brīža...');
Izsaukšana halt nodzēš jebkuru atbildes saturu līdz šim brīdim. Ja vēlaties apturēt ietvaru un izvadīt pašreizējo atbildi, izmantojiet stop metodi:
Flight nodrošina iebūvētu atbalstu HTTP līmeņa kešošanai. Ja tiek izpildīta kešošanas nosacījumi būs atbilstoši, Flight atgriezīs HTTP 304 Nav Modificēts atbildi. Nākamreiz, kad klients pieprasa to pašu resursu, viņiem tiks ieteikts izmantot lokāli kešēto versiju.
304 Nav Modificēts
Ja vēlaties kešot visu savu atbildi, jūs varat izmantot cache() metodi un nosūtīt laiku, lai kešotu.
cache()
// Tas kešos atbildi uz 5 minūtēm Flight::route('/jaunumi', function () { Flight::response()->cache(time() + 300); echo 'Šis saturs tiks kešots.'; }); // Kā alternatīvu, jūs varat izmantot virkni, kuru nosūtat // uz strtotime() metodēm Flight::route('/jaunumi', function () { Flight::response()->cache('+5 minūtes'); echo 'Šis saturs tiks kešots.'; });
Jūs varat izmantot lastModified metodi un nosūtīt UNIX laika zīmi, lai iestatītu datumu un laiku, kad lapa pēdējo reizi tika modificēta. Klients turpinās izmantot savu kešu līdz pēdējais modificēšanas laiks tiek mainīts.
ETag kešošana ir līdzīga Pēdējais Modificēts, izņemot to, jūs varat norādīt jebkuru gribēto identifikatoru resursam:
Pēdējais Modificēts
Flight::route('/jaunumi', function () { Flight::etag('man-īpašais-id'); echo 'Šis saturs tiks kešots.'; });
Jāatceras, ka lastModified vai etag izsaukšana gan iestata, gan pārbauda keša vērtību. Ja keša vērtība starp pieprasījumiem ir vienāda, Flight uzreiz nosūtīs HTTP 304 atbildi un pārtrauks apstrādi.
Vietā zīmēt Flight kā globālu statisku klasi, Jūs varat izpildespienākumu palaižot kā objekta instanci.
require 'flight/autoload.php'; $app = Flight::app(); $app->route('/', function () { echo 'sveika, pasaule!'; }); $app->start();
Tātad vietā, lai izsauktu statisko metodi, Jūs izsauktu instances metodi ar tādu pašu nosaukumu uz Dzinēja objektu.
Jūs varat pāradresēt pašreizējo pieprasījumu, izmantojot redirect metodi un padodot jaunu URL:
redirect
Flight::redirect('/jauna/vietas');
Pēc noklusējuma Flight nosūta HTTP 303 statusa kodu. Jūs varat izvēlēties iestatīt pielāgotu kodu:
Flight::redirect('/jauna/vietas', 401);
Flight nodrošina pamata templēšanas funkcionalitāti pēc noklusējuma. Lai parādītu skata templātu, izsauciet render metodi ar templāta faila nosaukumu un opcijas templātu datiem:
render
Flight::render('hello.php', ['name' => 'Bob']);
Datubāzi, ko jūs nododat iekšā, automātiski ievada templātā un var būt atsauce kā lokāls mainīgais. Templāta faili ir vienkārši PHP faili. Ja hello.php templāta faila saturs ir:
hello.php
Sveiki, <?= $name ?>!
Izvade būtu:
Sveiki, Bob!
Jūs arī varat manuāli iestatīt skata mainīgos, izmantojot set metodi:
Flight::view()->set('name', 'Bob');
Mainīgais name tagad ir pieejams visos jūsu skatos. Tātad vienkārši varat darīt:
name
Flight::render('hello');
Ņemiet vērā, ka norādot templāta nosaukumu render metodē, jūs varat izlaist .php paplašinājumu.
.php
Pēc noklusējuma Flight meklēs views direktoriju templātu failiem. Jūs varat iestatīt alternatīvu ceļu saviem templātiem, iestatot šādu konfigurāciju:
views
Flight::set('flight.views.path', '/ceļš/līdz/views');
Ir parasts, ka tīmekļa vietnēm ir viens izkārtojuma templāta fails, kurā mainās saturs. Lai attēlotu saturu, kas jāizmanto izkārtojumā, jūs varat nodot opcijas parametru render metodē.
Flight::render('header', ['heading' => 'Sveiki'], 'headerContent'); Flight::render('body', ['body' => 'Pasaulē'], 'bodyContent');
Jūsu skatam tad būs saglabāti mainīgie ar nosaukumiem headerContent un bodyContent. Tad jūs varat attēlot savu izkārtojumu, darot:
headerContent
bodyContent
Flight::render('layout', ['title' => 'Mājas lapā']);
Ja templātu faili izskatās šādi:
header.php:
header.php
<h1><?= $heading ?></h1>
body.php:
body.php
<div><?= $body ?></div>
layout.php:
layout.php
<html> <head> <title><?= $title ?></title> </head> <body> <?= $headerContent ?> <?= $bodyContent ?> </body> </html>
<html> <head> <title>Mājas lapā</title> </head> <body> <h1>Sveiki</h1> <div>Pasaulē</div> </body> </html>
Flight ļauj nomainīt noklusējuma skata dzinēju, vienkārši reģistrējot savu skata klasi. Šeit ir, kā jūs izmantotu Smarty templāta dzinēju savām skatam:
// Ielādēt Smarty bibliotēku require './Smarty/libs/Smarty.class.php'; // Reģistrējiet Smarty kā skata klasi // Iepriekš padodot atsauces funkciju, lai konfigurētu Smarty, ielādējot Flight::register('view', Smarty::class, [], function (Smarty $smarty) { $smarty->setTemplateDir('./templates/'); $smarty->setCompileDir('./templates_c/'); $smarty->setConfigDir('./config/'); $smarty->setCacheDir('./cache/'); }); // Piešķiriet templāta datus Flight::view()->assign('name', 'Bob'); // Rādīt templātu Flight::view()->display('hello.tpl');
Lai būtu pilnīgs, jums vajadzētu arī pārrakstīt Flight noklusējuma render metodi:
Flight::map('render', function(string $template, array $data): void { Flight::view()->assign($data); Flight::view()->display($template); });
# Skati Flight pēc noklusējuma nodrošina dažas pamata veidnes funkcijas. Ja jums ir nepieciešamas sarežģītākas veidņu prasības, skatiet Smarty un Latte piemērus sadaļā [Pielāgoti skati](#custom-views). Lai parādītu skata veidni, izsauciet `render` metodi ar veidnes faila nosaukumu un neobligātu veidnes datu: ```php Flight::render('hello.php', ['name' => 'Bob']);
Veidnes dati, ko jūs nododat, tiek automātiski injicēti veidnē un var tikt atsaukti kā lokāla mainīgā. Veidnes faili vienkārši ir PHP faili. Ja hello.php veidnes faila saturs ir:
Izvade būs:
Tagad mainīgais name ir pieejams visos jūsu skatos. Tāpēc jūs vienkārši varat:
Ņemiet vērā, ka, nosakot veidnes nosaukumu render metodē, jūs varat izlaist .php paplašinājumu.
Pēc noklusējuma Flight meklē views katalogu veidņu failiem. Jūs varat norādīt alternatīvu ceļu savām veidnēm, iestatot sekojošo konfigurāciju:
Flight::set('flight.views.path', '/ceļš/līdz/veidnēm');
Ir parasts, ka vietnēm ir viens izkārtojuma veidne ar mainīgu saturu. Lai renderētu saturu, kas tiks izmantots izkārtojumā, jūs varat nodot neobligātu parametru render metodē.
Flight::render('header', ['heading' => 'Sveiki'], 'headerContent'); Flight::render('body', ['body' => 'Pasaule'], 'bodyContent');
Tad jūsu skatījumā būs saglabāti mainīgie, ko sauc par headerContent un bodyContent. Tad jūs varēsiet renderēt savu izkārtojumu, darot:
Flight::render('layout', ['title' => 'Sākumlapa']);
Ja veidne faili izskatās šādi:
<html> <head> <title>Sākumlapa</title> </head> <body> <h1>Sveiki</h1> <div>Pasaule</div> </body> </html>
Flight ļauj jums mainīt noklusējuma skata dzinēju vienkārši, reģistrējot savu skata klasi.
Šeit ir, kā jūs varētu izmantot Smarty veidnes dzinēju savos skatos:
// Ielādēt Smarty bibliotēku require './Smarty/libs/Smarty.class.php'; // Reģistrēt Smarty kā skata klasi // Tāpat nododot atsauces funkciju, lai konfigurētu Smarty ielādes laikā Flight::register('view', Smarty::class, [], function (Smarty $smarty) { $smarty->setTemplateDir('./templates/'); $smarty->setCompileDir('./templates_c/'); $smarty->setConfigDir('./config/'); $smarty->setCacheDir('./cache/'); }); // Piešķirt veidnes datus Flight::view()->assign('name', 'Bob'); // Parādīt veidni Flight::view()->display('hello.tpl');
Pilnīgumam, jums arī vajadzētu pārkārtot Flight noklusējuma render metodi:
Šeit ir, kā jūs varētu izmantot Latte veidnes dzinēju savos skatos:
// Reģistrēt Latte kā skata klasi // Tāpat nododot atsauces funkciju, lai konfigurētu Latte ielādes laikā Flight::register('view', Latte\Engine::class, [], function (Latte\Engine $latte) { // Šeit Latte saglabās jūsu veidnes, lai paātrinātu procesu // Viena lieliska lieta par Latte ir tā, ka tas automātiski atsvaidzinās jūsu // kešatmiņu, kad jūs veicat izmaiņas šablonos! $latte->setTempDirectory(__DIR__ . '/../cache/'); // Pateikiet Latte, kur būs jūsu skatu saknes katalogs. $latte->setLoader(new \Latte\Loaders\FileLoader(__DIR__ . '/../views/')); }); // Un iesaiņojiet to, lai jūs varat pareizi izmantot Flight::render() Flight::map('render', function(string $template, array $data): void { // Tas ir līdzīgi kā $latte_engine->render($template, $data); echo Flight::view()->render($template, $data); });
Flight ir izstrādāts, lai būtu paplašināmais ietvars. Ietvars ir iekļauts ar noteiktu kopu noklusējuma metodēm un komponentēm, bet tas ļauj jums atkartot jūsu pašu metodes, reģistrēt savas klases vai pat pārrakstīt esošās klases un metodes.
Ja jums ir nepieciešams DIC (Atkarību ievades konteiners), pāriet uz Dependency Injection Container lapu.
Lai atkārtotu savu vienkāršo pielāgoto metodi, jums ir jāizmanto map funkcija:
// Atkartot savu metodi Flight::map('hello', function (string $name) { echo "sveiki $name!"; }); // Izsauciet savu pielāgoto metodi Flight::hello('Bob');
Šis tiek izmantots vairāk, kad jums ir nepieciešams padot mainīgos savā metodē, lai iegūtu paredzēto vērtību. Lai iegūtu konfigurāciju un tad izsauktu jūsu iepriekš konfigurēto klasi, ir labāk izmantot register() metodi tālāk.
register()
Lai reģistrētu savu klasi un konfigurētu to, jums ir jāizmanto register funkcija:
// Reģistrējiet savu klasi Flight::register('user', User::class); // Iegūstiet savas klases instanci $user = Flight::user();
Reģistrēšanas metode ļauj jums arī padot parametrus savai klases konstruktoram. Tāpēc, kad jūs ielādējat savu pielāgoto klasi, tā būs iepriekš inicializēta. Jūs varat noteikt konstruktoru parametrus, padodot papildu masīvu. Šeit ir piemērs dabas savienojuma ielādei:
// Reģistrējiet klasi ar konstruktora parametriem Flight::register('db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass']); // Iegūstiet savas klases instanci // Tas izveidos objektu ar definētajiem parametriem // // new PDO('mysql:host=localhost;dbname=test','user','pass'); // $db = Flight::db(); // un ja jums to vēlāk vajadzētu savā kodā, jūs vienkārši atkārtoti izsaucat to pašu metodi class SomeController { public function __construct() { $this->db = Flight::db(); } }
Ja jūs padodat papildu atsauces parametru, tas tiks īstenots tūlīt pēc klases konstruēšanas. Tas ļauj jums veikt jebkādus iestatīšanas procedūras savam jaunajam objektam. Atsauces funkcija pieņem vienu parametru, jaunu objekta piemēru.
// Atsauces funkcijai tiks padots konstruētais objekts Flight::register( 'db', PDO::class, ['mysql:host=localhost;dbname=test', 'user', 'pass'], function (PDO $db) { $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); } );
Pēc noklusējuma, ikreiz, kad ielādējat savu klasi, jūs saņemsiet kopīgu instanci. Lai iegūtu jaunu klases instanci, vienkārši padodiet false kā parametru:
// Kopīga klases instance $shared = Flight::db(); // Jauna klases instance $new = Flight::db(false);
Jāņem vērā, ka atkārtotajām metodēm ir priekšrocība pāri reģistrētajām klasēm. Ja jūs deklarējat abus, izmantojot to pašu nosaukumu, tiks izsaukta tikai atkārtotā metode.
Flight ļauj jums pārrakstīt tā noklusējuma funkcionalitāti, lai atbilstu jūsu vajadzībām, neizmainot nevienu kodu.
Piemēram, kad Flight nevar sakrist URL ar maršrutu, tas izsauc notFound metodi, kas nosūta vispārīgu HTTP 404 atbildi. Jūs varat pārrakstīt šo uzvedību izmantojot map metodi:
Flight::map('notFound', function() { // Parādīt pielāgoto 404 lapu include 'errors/404.html'; });
Flight ļauj arī aizstāt ietvara galvenās komponentes. Piemēram, jūs varat aizstāt noklusējuma Maršruta klasi ar savu pielāgoto klasi:
// Reģistrējiet savu pielāgoto klasi Flight::register('router', MyRouter::class); // Kad Flight ielādē Maršruta instanci, tas ielādēs jūsu klasi $myrouter = Flight::router();
Tomēr ietvara metodes, piemēram, map un register, nevar būt pārrakstītas. Jūs iegūsit kļūdu, ja mēģināsiet to darīt.
Flight nodrošina atbalstu JSON un JSONP atbildēm. Lai nosūtītu JSON atbildi, jums ir jāpadod dati, kas tiks pārveidoti par JSON formātu:
JSONP pieprasījumiem jūs varam papildus norādīt vietrādi parametra nosaukumu, kuru izmantojat, lai definētu savu atsauces funkciju:
Tātad, veicot GET pieprasījumu, izmantojot ?q=my_func, jums vajadzētu saņemt izvadi:
Ja neesat norādījis vietrādi parametra nosaukumu, tas pēc noklusējuma būs jsonp.
Automašīnīšana ir koncepts PHP valodā, kur norāda direktoriju vai direktorijas, no kurienes ielādēt klases. Tas ir daudz izdevīgāk nekā izmantojot require vai include, lai ielādētu klases. Tas arī ir prasība, lai izmantotu Composer pakotnes.
require
include
Pēc noklusējuma jebkura Flight klase tiek automātiski ielādēta pateicībā composer. Taču, ja vēlaties ielādēt savas klases automātiski, varat izmantot Flight::path metodi, lai norādītu direktoriju, no kuras ielādēt klases.
Flight::path
Pieņemsim, ka mums ir direktoriju koks kā tas sekojoši:
# Piemēra ceļš /mājas/lietotājs/projekts/mans-flight-projekts/ ├── lietotne │ ├── kešatmiņa │ ├── konfigurācija │ ├── vadītāji - satur šī projekta vadītājus │ ├── tulkojumi │ ├── UTILS - satur klases tikai šai lietojumprogrammai (tas visi lielas burtos nolūkā, kā vēlāk piemēram) │ └── skati └── publisks └── css └── js └── index.php
Jūs varat norādīt katru no direktorijām, no kurienes ielādēt šādi:
/** * public/index.php */ // Pievienot ceļu automātiski ielādētājam Flight::path(__DIR__.'/../lietotne/vadītāji/'); Flight::path(__DIR__.'/../lietotne/utils/'); /** * lietotne/vadītāji/ManaisVadītājs.php */ // nav vajadzīgs nosaukuma telpojums // Visas automātiski ielādētās klases ir ieteicams rakstīt ar Pascal Lielajiem burtiem (katrs vārds lietots lielais burtos, bez atstarpēm) // Sākot ar 3.7.2 versiju, varat izmantot Pascal_Snake_Case saviem klases nosaukumiem, palaižot Loader::setV2ClassLoading(false); class ManaisVadītājs { public function index() { // dari kaut ko } }
Ja jums ir nosaukumu telpas, patiesībā tas kļūst ļoti viegli ieviest. Jums vajadzētu izmantot Flight::path() metodi, lai norādītu saknes direktoriju (nevis dokumenta saknes vai public/ mapes) jūsu lietojumprogrammai.
Flight::path()
public/
/** * public/index.php */ // Pievienot ceļu automātiski ielādētājam Flight::path(__DIR__.'/../');
Tagad šis ir kā varētu izskatīties jūsu vadītājs. Apskatiet zemāk esošo piemēru, bet pievērsiet uzmanību komentāriem par svarīgu informāciju.
/** * lietotne/vadītāji/ManaisVadītājs.php */ // nosaukumu telpas ir prasītas // nosaukumu telpas ir tādas pašas kā direktoriju struktūra // nosaukumu telpu ir jāievēro tāda pati lietu struktūra // nosaukumu telpām un direktorijām nedrīkst būt nekādu apakšsvītru (ja nav iestatīts Loader::setV2ClassLoading(false)) namespace app\vadītāji; // Visas automātiski ielādētās klases ir ieteicams rakstīt ar Pascal Lielajiem burtiem (katrs vārds lietots lielais burtos, bez atstarpēm) // Sākot ar 3.7.2 versiju, varat izmantot Pascal_Snake_Case saviem klases nosaukumiem, palaižot Loader::setV2ClassLoading(false); class ManaisVadītājs { public function index() { // dari kaut ko } }
Un ja vēlējāties automātiski ielādēt klasi savā UTILS direktorijā, jūs darītu būtiski to pašu:
/** * lietotne/UTILS/ArrayHelperUtil.php */ // nosaukuma telpai jāsaskan ar direktorijas struktūru un gadījumu (ņemot vērā UTILS direktoriju ir visas lielās burts // kā failu koks augstāk) namespace app\UTILS; class ArrayHelperUtil { public function changeArrayCase(array $array) { // dari kaut ko } }
Sākot ar 3.7.2 versiju, jūs varat izmantot Pascal_Snake_Case saviem klases nosaukumiem, palaižot Loader::setV2ClassLoading(false);. Tas ļaus jums izmantot pasvītras savos klases nosaukumos. Tas nav ieteicams, bet tas ir pieejams tiem, kuriem tas ir nepieciešams.
Loader::setV2ClassLoading(false);
/** * public/index.php */ // Pievienot ceļu automātiski ielādētājam Flight::path(__DIR__.'/../lietotne/vadītāji/'); Flight::path(__DIR__.'/../lietotne/utils/'); Loader::setV2ClassLoading(false); /** * apdraudējumi/Manais_Apdraudējums.php */ // nav vajadzīgs nosaukuma telpojums class Manais_Apdraudējums { public function index() { // dari kaut ko } }
Šī lapā jums palīdzēs novērst bieži sastopamos jautājumus, ar kuriem varat saskarties, izmantojot Flight.
Ja redzat kļūdu 404 nav atrasts (bet jūs zvērējat par savu dzīvību, ka tas tur tiešām ir un tas nav tikai kļūda) tas faktiski varētu būt problēma, ka atgriežat vērtību savā maršruta beigu punktā, nevis vienkārši to izvadot. Iemesls tam ir nodomāts, bet tas varētu izslīdēt no roku dažiem izstrādātājiem.
Flight::route('/hello', function(){ // Tas var izraisīt kļūdu 404 nav atrasts return 'Sveika, pasaule!'; }); // To, ko jūs visticamāk vēlaties Flight::route('/hello', function(){ echo 'Sveika, pasaule!'; });
Iemesls tam ir speciāla mehānisma iebūvēšana maršrutētājā, kas apstrādā atgriezenošanās izvadi kā vienīgu "doties uz nākamo maršrutu". Jūs varat redzēt šādu uzvedību dokumentētu sadaļā Maršrutēšana.
Ja izmantojat Composer, varat izpildīt sekojošo komandu:
composer require flightphp/core
VAI arī varat lejupielādēt failus tieši un izvilkt tos savā tīmekļa direktorijā.
Lai Apache, rediģējiet savu .htaccess failu ar šādu informāciju:
.htaccess
RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-f RewriteCond %{REQUEST_FILENAME} !-d RewriteRule ^(.*)$ index.php [QSA,L]
Piezīme: Ja jums ir nepieciešams izmantot Flight apakškatalogu, pievienojiet rindu RewriteBase /apakskatalogs/ tieši pēc RewriteEngine On. Piezīme: Ja vēlaties aizsargāt visus servera failus, piemēram, db vai env failu. Ievietojiet šo savā .htaccess failā:
Piezīme: Ja jums ir nepieciešams izmantot Flight apakškatalogu, pievienojiet rindu RewriteBase /apakskatalogs/ tieši pēc RewriteEngine On.
RewriteBase /apakskatalogs/
RewriteEngine On
Piezīme: Ja vēlaties aizsargāt visus servera failus, piemēram, db vai env failu. Ievietojiet šo savā .htaccess failā:
RewriteEngine On RewriteRule ^(.*)$ index.php
Lai Nginx, pievienojiet sekojošo savā servera deklarācijā:
server { location / { try_files $uri $uri/ /index.php; } }
<?php // Ja izmantojat Composer, pieprasiet autovadītāju. require 'vendor/autoload.php'; // ja neizmantojat Composer, ielādējiet pamatni tieši // require 'flight/Flight.php'; // Tad definējiet maršrutu un piešķiriet funkciju, lai apstrādātu pieprasījumu. Flight::route('/', function () { echo 'sveika pasaule!'; }); // Visbeidzot, startējiet pamatni. Flight::start();
MIT License (MIT) ================= Autortiesības © `2023` `@mikecao, @n0nag0n` Atļauja tiek piešķirta bez maksas jebkurai personai, kas iegūst šīs programmatūras kopiju un saistītos dokumentus (turpmāk - “Programmatūra”), lai varētu izmantot Programmatūru bez ierobežojumiem, ieskaitot, bet neaprobežojoties ar, tiesības izmantot, kopēt, modificēt, apvienot, publicēt, izplatīt, sublicencēt un/vai pārdot Programmatūras kopijas, kā arī atļaut personām, kurām Programmatūra tiek nodrošināta, to darīt, ievērojot sekojošos nosacījumus: Piemērotie autortiesību paziņojumi un šī atļauja paziņojums obligāti jāiekļauj visos kopiju vai īpaši lielos Programmatūras daļās. Programmatūra tiek nodrošināta “kā ir”, bez jebkādām garantijām, izteiktām vai pieļaujamām, ieskaitot, bet neaprobežojoties ar, komerciālo kvalitāti, piemērotību konkrētai vajadzībai un nepārkāpšanu. Autori vai autortiesību turētāji nav atbildīgi par nekādiem prasījumiem, zaudējumiem vai citiem pienākumiem, vai nu, līgumtiesiski, deliktiski vai citādi, ko rada, izriet no vai saistīti ar Programmatūru vai tās izmantošanu vai citiem darījumiem ar Programmatūru.
Flight ir ātrs, vienkāršs, paplašināms PHP ietvars. Tas ir diezgan daudzveidīgs un var tikt izmantots, lai izveidotu jebkura veida tīmekļa lietojumprogrammu. Tas ir izveidots, ņemot vērā vienkāršību, un rakstīts tā, lai būtu viegli saprotams un izmantojams.
Flight ir lielisks iesācējiem paredzēts ietvars tiem, kuriem PHP ir jaunums un kuri vēlas uzzināt, kā veidot tīmekļa lietojumprogrammas. Tas ir arī lielisks ietvars pieredzējušiem izstrādātājiem, kuri vēlas vairāk kontroles pār savām tīmekļa lietojumprogrammām. Tas ir izstrādāts tā, lai viegli varētu izveidot RESTful API, vienkāršu tīmekļa lietojumprogrammu vai sarežģītu tīmekļa lietojumprogrammu.
<?php // ja instalēts ar komponistu require 'vendor/autoload.php'; // vai ja instalēts manuāli ar zip failu // require 'flight/Flight.php'; Flight::route('/', function() { echo 'sveika, pasaule!'; }); Flight::route('/json', function() { Flight::json(['sveika' => 'pasaule']); }); Flight::start();
Diezgan vienkārši, vai ne? Uzzini vairāk par Flight dokumentācijā!
Ir piemēra lietojumprogramma, kas var palīdzēt jums sākt darbu ar Flight ietvaru. Dodieties uz flightphp/skeleton, lai saņemtu instrukcijas, kā sākt darbu! Vai arī apmeklējiet piemēru lapu, lai iedvesmotu jūs par dažām lietām, ko varat darīt ar Flight.
Mēs esam Matrix! Sarunājieties ar mums vietnē #flight-php-framework:matrix.org.
Ir divi veidi, kā jūs varat piedalīties projektā Flight:
Flight prasa PHP 7.4 vai jaunāku versiju.
Piezīme: PHP 7.4 tiek atbalstīts, jo rakstīšanas brīdī (2024. gadā) PHP 7.4 ir noklusējuma versija dažiem LTS Linux izplatījumiem. Pāreja uz PHP >8 liktu lielu galvassāpi šo lietotāju. Ietvars atbalsta arī PHP >8.
Flight ir izdotss pēc MIT licences.
overclokk/cookie ir vienkārša bibliotēka sīkfailu pārvaldībai jūsu lietotnē.
Instalēšana ir vienkārša ar komponistu.
composer require overclokk/cookie
Lietošana ir tik vienkārša kā jaunas metodes reģistrēšana Flight klases.
use Overclokk\Cookie\Cookie; /* * Iestatiet savā palaišanas vai public/index.php failā */ Flight::register('cookie', Cookie::class); /** * ExampleController.php */ class ExampleController { public function login() { // Iestatiet sīkfailu // jums vajadzētu, lai tas būtu false, tādēļ, lai jūs saņemtu jaunu instanci // izmantojiet zemāk esošo komentāru, ja vēlaties autovērstjanu /** @var \Overclokk\Cookie\Cookie $cookie */ $cookie = Flight::cookie(false); $cookie->set( 'stay_logged_in', // sīkfaila nosaukums '1', // vērtība, kuru vēlaties iestatīt 86400, // cik sekundes sīkfailam būtu jāpastāv '/', // ceļš, kurā būs pieejams sīkfails 'example.com', // domēns, kurā būs pieejams sīkfails true, // sīkfails tiks pārraidīts tikai pār šifrētu HTTPS savienojumu true // sīkfails būs pieejams tikai caur HTTP protokolu ); // pēc izvēles, ja vēlaties saglabāt noklusējuma vērtības // un ātri iestatīt sīkfailu ilgu laiku $cookie->forever('stay_logged_in', '1'); } public function home() { // Pārbaudiet, vai jums ir sīkfails if (Flight::cookie()->has('stay_logged_in')) { // ielieciet tos piemēram, informācijas panelī. Flight::redirect('/dashboard'); } } }
defuse/php-encryption ir bibliotēka, kas var tikt izmantota datu šifrēšanai un atšifrēšanai. Uzsākšana ir diezgan vienkārša, lai sāktu šifrēt un atšifrēt datus. Viņiem ir lielisks rokasgrāmata, kas palīdz izskaidrot pamatus par to, kā izmantot bibliotēku, kā arī svarīgu drošības aspektu, kas saistīti ar šifrēšanu.
composer require defuse/php-encryption
Pēc tam jums būs jāģenerē šifrēšanas atslēga.
vendor/bin/generate-defuse-key
Tas izvadīs atslēgu, ko būsiet jāsargā. Jūs varētu saglabāt atslēgu savā app/config/config.php failā masīvā faila apakšdaļā. Lai gan tas nav ideāla vieta, tas vismaz ir kaut kas.
app/config/config.php
Tagad, kad jums ir bibliotēka un šifrēšanas atslēga, varat sākt šifrēt un atšifrēt datus.
use Defuse\Crypto\Crypto; use Defuse\Crypto\Key; /* * Uzstādiet savā bootstrap vai public/index.php failā */ // Šifrēšanas metode Flight::map('encrypt', function($sastāvs_dati) { $šifrēšanas_atslēga = /* $config['encryption_key'] vai file_get_contents no vietas, kur likāt atslēgu */; return Crypto::encrypt($sastāvs_dati, Key::loadFromAsciiSafeString($šifrēšanas_atslēga)); }); // Atšifrēšanas metode Flight::map('decrypt', function($šifrētie_dati) { $šifrēšanas_atslēga = /* $config['encryption_key'] vai file_get_contents no vietas, kur likāt atslēgu */; try { $sastāvs_dati = Crypto::decrypt($šifrētie_dati, Key::loadFromAsciiSafeString($šifrēšanas_atslēga)); } catch (Defuse\Crypto\Exception\WrongKeyOrModifiedCiphertextException $ex) { // Uzbrukums! Vai nu tika ielādēta nepareizā atslēga, vai arī šifrētais teksts ir mainījies, kopš tas tika izveidots - vai nu sabojājies datu bāzē vai nodomāti modificējis Eva, mēģinot veikt uzbrukumu. // ... apstrādājiet šo gadījumu tādā veidā, kas ir piemērots jūsu lietojumprogrammai ... } return $sastāvs_dati; }); Flight::route('/encrypt', function() { $šifrētie_dati = Flight::encrypt('Šis ir noslēpums'); echo $šifrētie_dati; }); Flight::route('/decrypt', function() { $šifrētie_dati = '...'; // Iegūstiet šifrētos datus no kaut kurienes $atšifrētie_dati = Flight::decrypt($šifrētie_dati); echo $atšifrētie_dati; });
Viegla, vienkārša un autonomas PHP faila kešatmiņas klase
Izdevības
Uzstādīt, izmantojot komponistu:
composer require wruczek/php-file-cache
Lietošana ir diezgan vienkārša.
use Wruczek\PhpFileCache\PhpFileCache; $app = Flight::app(); // Jūs padodat katalogu, kurā kešatmiņa tiks saglabāta, konstruktorā $app->register('cache', PhpFileCache::class, [ __DIR__ . '/../cache/' ], function(PhpFileCache $cache) { // Tas nodrošina, ka kešatmiņa tiek izmantota tikai tad, ja tā ir produktīvā režīmā // ENVIRONMENT ir konstante, kas iestatīta jūsu ielādes failā vai citur jūsu lietotnē $cache->setDevMode(ENVIRONMENT === 'development'); });
Tad to varat izmantot savā kodā šādi:
// Iegūt kešatmiņas instanci $cache = Flight::cache(); $data = $cache->refreshIfExpired('simple-cache-test', function () { return date("H:i:s"); // atgriezt dati, kas jākešo }, 10); // 10 sekundes // vai $data = $cache->retrieve('simple-cache-test'); if(empty($data)) { $data = date("H:i:s"); $cache->store('simple-cache-test', $data, 10); // 10 sekundes }
Apmeklējiet https://github.com/Wruczek/PHP-File-Cache pilnai dokumentācijai un pārliecinieties, ka redzat examples mapi.
Flight ir ļoti paplašināms. Ir daudz spraudņu, kas var tikt izmantoti, lai pievienotu funkcionalitāti jūsu Flight lietojumprogrammai. Daži no tiem oficiāli tiek atbalstīti no Flight komandas, savukārt citi ir mikro/lite bibliotēkas, lai palīdzētu jums sākt.
Kešošana ir lieliska veids, kā paātrināt jūsu lietojumprogrammu. Ir daudz kešošanas bibliotēku, kas var tikt izmantotas ar Flight.
Dīversija ir būtiska, kad jūs izstrādājat savā lokālajā vide. Ir daži spraudņi, kas var uzlabot jūsu dīversijas pieredzi.
Datubāzes ir vairumam lietojumprogrammu pamats. Tā ir veids, kā saglabāt un atgūt datus. Dažas datubāzu bibliotēkas vienkārši ir wrapperi, lai rakstītu vaicājumus, bet dažas ir pilnvērtīgi ORM.
Sesijas nav īsti noderīgas API, bet, lai izveidotu tīmekļa lietojumprogrammu, sesijas var būt būtiskas, lai saglabātu stāvokli un pieteikšanās informāciju.
Templēšana ir būtiska jebkurai tīmekļa lietojumprogrammai ar lietotāja saskarni. Ir daudz templēšanas dzinēju, kas var tikt izmantoti ar Flight.
Vai jums ir spraudnis, ko vēlaties koplietot? Iesniedziet pieprasījumu pull, lai to pievienotu sarakstam!
Flight ir palīgklase PDO. Tas ļauj viegli vaicāt savu datu bāzi ar visu sagatavoto/izpildīto/fetchAll() šaubību. Tas ievērojami vienkāršo, kā jūs varat vaicāt savu datu bāzi. Katra rindas rezultāts tiek atgriezts kā "Flight Collection" klase, kas ļauj piekļūt datiem, izmantojot masīva sintaksi vai objekta sintaksi.
// Reģistrējiet PDO palīgklasi Flight::register('db', \flight\database\PdoWrapper::class, ['mysql:host=localhost;dbname=cool_db_name', 'user', 'pass', [ PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES \'utf8mb4\'', PDO::ATTR_EMULATE_PREPARES => false, PDO::ATTR_STRINGIFY_FETCHES => false, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC ] ]);
Šis objekts paplašina PDO, tāpēc visi normālie PDO metodēs ir pieejami. Tika pievienotas šādas metodes, lai atvieglotu datu bāzes vaicājumu veikšanu:
runQuery(string $sql, array $params = []): PDOStatement
Izmantojiet šo INSERTS, UPDATE vai ja plānojat izmantot SELECT cilpas iekšā
$db = Flight::db(); $statement = $db->runQuery("SELECT * FROM table WHERE something = ?", [ $something ]); while($row = $statement->fetch()) { // ... } // Vai ierakstiet datubāzē $db->runQuery("INSERT INTO table (name) VALUES (?)", [ $name ]); $db->runQuery("UPDATE table SET name = ? WHERE id = ?", [ $name, $id ]);
fetchField(string $sql, array $params = []): mixed
Izvelk pirmo lauku no vaicājuma
$db = Flight::db(); $count = $db->fetchField("SELECT COUNT(*) FROM table WHERE something = ?", [ $something ]);
fetchRow(string $sql, array $params = []): array
Izvelk vienu rindu no vaicājuma
$db = Flight::db(); $row = $db->fetchRow("SELECT id, name FROM table WHERE id = ?", [ $id ]); echo $row['name']; // vai echo $row->name;
fetchAll(string $sql, array $params = []): array
Izvelk visus rindas no vaicājuma
$db = Flight::db(); $rows = $db->fetchAll("SELECT id, name FROM table WHERE something = ?", [ $something ]); foreach($rows as $row) { echo $row['name']; // vai echo $row->name; }
IN()
Tai ir noderīga aploksne IN() apgalvojumiem. Vienu jautājuma zīmi vienkārši varat padot kā vietotni IN() un pēc tam masīvu ar vērtībām. Šeit ir piemērs, kā tas varētu izskatīties:
$db = Flight::db(); $name = 'Bob'; $company_ids = [1,2,3,4,5]; $rows = $db->fetchAll("SELECT id, name FROM table WHERE name = ? AND company_id IN (?)", [ $name, $company_ids ]);
// Piemēra maršruts un kā jūs izmantotu šo apvalku Flight::route('/users', function () { // Iegūt visus lietotājus $users = Flight::db()->fetchAll('SELECT * FROM users'); // Plūsmas visi lietotāji $statement = Flight::db()->runQuery('SELECT * FROM users'); while ($user = $statement->fetch()) { echo $user['name']; // vai echo $user->name; } // Iegūt vienu lietotāju $user = Flight::db()->fetchRow('SELECT * FROM users WHERE id = ?', [123]); // Iegūt vienu vērtību $count = Flight::db()->fetchField('SELECT COUNT(*) FROM users'); // Speciālā IN() sintakse, lai palīdzētu (pārliecinieties, ka IN ir lieli burti) $users = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [[1,2,3,4,5]]); // jūs varētu arī darīt šo $users = Flight::db()->fetchAll('SELECT * FROM users WHERE id IN (?)', [ '1,2,3,4,5']); // Ievietot jaunu lietotāju Flight::db()->runQuery("INSERT INTO users (name, email) VALUES (?, ?)", ['Bob', 'bob@example.com']); $insert_id = Flight::db()->lastInsertId(); // Atjaunināt lietotāju Flight::db()->runQuery("UPDATE users SET name = ? WHERE id = ?", ['Bob', 123]); // Dzēst lietotāju Flight::db()->runQuery("DELETE FROM users WHERE id = ?", [123]); // Iegūt ietekmēto rindu skaitu $statement = Flight::db()->runQuery("UPDATE users SET name = ? WHERE name = ?", ['Bob', 'Sally']); $affected_rows = $statement->rowCount(); });
PHP sesiju pārvaldnieks (nenorobežojošs, uzrejamā, segmentēšana, sesiju šifrēšana). Izmanto PHP open_ssl, lai pēc nepieciešamības šifrētu/deshifrētu sesiju datus. Atbalsta Failu, MySQL, Redis un Memcached.
Instalē ar komponistu.
composer require ghostff/session
Jums nav obligāti jāpārsniedz nekas, lai izmantotu noklusējuma iestatījumus ar savu sesiju. Par papildu iestatījumiem varat lasīt Github Readme.
izmantojiet Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); $app->registret('sesija', Session::class); // viena lieta, ko atcerēties, ir tā, ka jums katru lapu ielādējot ir jāizpilda sesiju // vai jums jāpalaiž auto_commit jūsu konfigurācijā.
Šeit ir vienkāršs piemērs, kā jūs varētu to izmantot.
Flight::route('POST /login', function() { $session = Flight::session(); // šeit veiciet savu ielogošanās loģiku // validējiet paroli, utt. // ja ieraksts veiksmīgs $session->set('ir_iebūvēts', true); $session->set('lietotājs', $lietotājs); // jebkurā laikā, kad ierakstāt sesijā, to jāiepilda apzināti. $session->commit(); }); // šis pārbaudījums varētu būt ierobežotas lapas loģikā vai ietīts ar starpniekprogrammu. Flight::route('/daža-ierobežota-lapa', function() { $session = Flight::session(); if(!$session->get('ir_iebūvēts')) { Flight::redirect('/ielogoties'); } // šeit veiciet savu ierobežotas lapas loģiku }); // starpniekprogrammu versija Flight::route('/daža-ierobežota-lapa', function() { // regulārās lapas loģika })->addMiddleware(function() { $session = Flight::session(); if(!$session->get('ir_iebūvēts')) { Flight::redirect('/ielogoties'); } });
Šeit ir lielāks piemērs, kā jūs varētu to izmantot.
izmantojiet Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); // iestatiet pielāgotu ceļu līdz jūsu sesiju konfigurācijas failam un norādiet gadījuma rindas simbolu sesijas ID $app->registret('sesija', Session::class, [ 'ceļš/uz/sesijas_konfigurācijas.php', bin2hex(nejauši_ģenerētas_baitu_virknes(32)) ], function(Session $sesija) { // vai arī manuāli pārrakstiet konfigurācijas opcijas $session->updateConfiguration([ // ja vēlaties saglabāt sesijas datus datu bāzē (laba izvēle, ja vēlaties kaut ko līdzīgu kā "izlogot visus ierīces" funkciju) Session::CONFIG_DRIVER => Ghostff\Session\Drivers\MySql::class, Session::CONFIG_ENCRYPT_DATA => true, Session::CONFIG_SALT_KEY => hash('sha256', 'mans-super-S3CR3T-salt'), // lūdzu, mainiet to uz kaut ko citu Session::CONFIG_AUTO_COMMIT => true, // izpildiet tikai tad, ja tas ir nepieciešams un/vai ir grūti izpildīt jūsu sesijas komandu. // papildus varat izpildīt Flight::after('start', function() { Flight::session()->commit(); }); Session::CONFIG_MYSQL_DS => [ 'driver' => 'mysql', # Datu bāzes draiveris PDO dns piemērs(mysql:host=...;dbname=...) 'host' => '127.0.0.1', # Datu bāzes resurss 'db_name' => 'mana_lietotnes_datubāze', # Datu bāzes nosaukums 'db_table' => 'sesijas', # Datu bāzes tabula 'db_user' => 'root', # Datu bāzes lietotājvārds 'db_pass' => '', # Datu bāzes parole 'persistent_conn'=> false, # Ietaupot resursus, izveidojot jaunu savienojumu katru reizi, kad skripts ir savienojums ar datu bāzi, rezultātā ātrāka tīmekļa lietojumprogramma. ATRAST JŪS PAŠI ] ]); } );
Vai jūs iestatāt savus sesijas datus un tie nepastāv starp pieprasījumiem? Varbūt aizmirsi komitēt savus sesijas datus. To var izdarīt, zvanot $sesija->commit() pēc sesijas datu iestatīšanas.
$sesija->commit()
Flight::route('POST /login', function() { $session = Flight::session(); // šeit veiciet savu ielogošanās loģiku // validējiet paroli, utt. // ja ieraksts veiksmīgs $session->set('ir_iebūvēts', true); $session->set('lietotājs', $lietotājs); // jebkurā laikā, kad ierakstāt sesijā, to jāiepilda apzināti. $session->commit(); });
Otrais veids, kā to izdarīt, ir, kad iestatāt savu sesiju servisu, jums jāiestata auto_commit uz true savā konfigurācijā. Tas automātiski komitēs jūsu sesijas datus pēc katra pieprasījuma.
auto_commit
$app->registret('sesija', Session::class, [ 'ceļš/uz/sesijas_konfigurācijas.php', bin2hex(nejauši_ģenerētas_baitu_virknes(32)) ], function(Session $sesija) { $sesija->updateConfiguration([ Session::CONFIG_AUTO_COMMIT => true, ]); } );
Papildus tam jūs varat darīt Flight::after('start', function() { Flight::session()->commit(); }); lai komitētu savus sesijas datus pēc katra pieprasījuma.
Flight::after('start', function() { Flight::session()->commit(); });
Apmeklējiet Github Readme, lai iegūtu pilnu dokumentāciju. Konfigurācijas opcijas ir labi dokumentētas default_config.php failā patiess. Kods ir viegli saprotams, ja vēlaties pārskatīt šo pakotni pats.
Pacēlums ir CLI lietotne, kas palīdz pārvaldīt jūsu Flight lietotnes. Tas var ģenerēt kontrolerus, parādīt visas maršrutu celtnes un vēl daudz ko citu. Tas balstās uz lielisko adhocore/php-cli bibliotēku.
Instalējiet ar komponistu.
composer require flightphp/runway
Pirmo reizi palaistot Pacēlumu, tas izpildīs jūs cauri iestatīšanas procesam un izveidos .runway.json konfigurācijas failu jūsu projekta saknē. Šajā failā būs dažas nepieciešamās konfigurācijas, lai Pacēlums varētu pareizi darboties.
.runway.json
Pacēlumam ir vairākas komandas, kuras varat izmantot, lai pārvaldītu savu Flight lietotni. Ir divi vienkārši veidi, kā izmantot Pacēlumu.
php runway [komanda]
vendor/bin/runway [komanda]
Jebkurai komandai varat padot --help karodziņu, lai iegūtu vairāk informācijas par to, kā izmantot komandu.
--help
php runway routes --help
Šeit ir daži piemēri:
Balstoties uz konfigurāciju jūsu .runway.json failā, pēc noklusējuma atrašanās vieta ģenerēs jums kontroleri app/controllers/ mapē.
app/controllers/
php runway make:controller MyController
Balstoties uz konfigurāciju jūsu .runway.json failā, pēc noklusējuma atrašanās vieta ģenerēs jums kontrolieri app/records/ mapē.
app/records/
php runway make:record users
Ja, piemēram, jums ir users tabula ar sekojošo shēmu: id, name, email, created_at, updated_at, faila līdzīga tālāk redzamajai tiks izveidota app/records/UserRecord.php failā:
users
email
created_at
updated_at
app/records/UserRecord.php
<?php declare(strict_types=1); namespace app\records; /** * ActiveRecord klase lietotāju tabulai. * @link https://docs.flightphp.com/awesome-plugins/active-record * * @property int $id * @property string $name * @property string $email * @property string $created_at * @property string $updated_at */ class UserRecord extends \flight\ActiveRecord { /** * @var array $relations Iestata attiecības modelim * https://docs.flightphp.com/awesome-plugins/active-record#relationships */ protected array $relations = []; /** * Konstruktors * @param mixed $databaseConnection Datu bāzes savienojums */ public function __construct($databaseConnection) { parent::__construct($databaseConnection, 'users'); } }
Tiks parādīti visi maršruti, kas pašlaik ir reģistrēti ar Flight.
php runway routes
Ja vēlaties skatīt tikai konkrētus maršrutus, varat padot karodziņu, lai filtrētu maršrutus.
# Parādīt tikai GET maršrutus php runway routes --get # Parādīt tikai POST maršrutus php runway routes --post # u.t.t.
Ja jūs veidojat pakotni Flight, vai vēlaties pievienot savas pielāgotas komandas savā projektā, to varat izdarīt, izveidojot src/commands/, flight/commands/, app/commands/ vai commands/ direktoriju savam projektam/pakotnei.
src/commands/
flight/commands/
app/commands/
commands/
Lai izveidotu komandu, vienkārši paplašiniet AbstractBaseCommand klasi un implementējiet vismaz __construct metodi un execute metodi.
AbstractBaseCommand
__construct
execute
<?php declare(strict_types=1); namespace flight\commands; class ExampleCommand extends AbstractBaseCommand { /** * Konstruktors * * @param array<string,mixed> $config JSON konfigurācija no .runway-config.json */ public function __construct(array $config) { parent::__construct('make:example', 'Izveidot piemēru dokumentācijai', $config); $this->argument('<funny-gif>', 'Smaidojošā gif attēla nosaukums'); } /** * Izpilda funkciju * * @return void */ public function execute(string $controller) { $io = $this->app()->io(); $io->info('Izveido piemēru...'); // Darīt kaut ko šeit $io->ok('Piemērs izveidots!'); } }
Skatiet adhocore/php-cli dokumentāciju papildinformācijai par to, kā izveidot savas pielāgotas komandas savā Flight lietotnē!
Šis ir paplašinājumu kopums, kas padara darbu ar Flight nedaudz bagātāku.
$_GET
$_POST
$_FILES
$_SESSION
Šis ir Panelis
Un katrs panelis parāda ļoti noderīgu informāciju par jūsu lietojumprogrammu!
Izpildiet composer require flightphp/tracy-extensions --dev un esat gatavs!
composer require flightphp/tracy-extensions --dev
Jums nav nepieciešama daudz konfigurēšana, lai sāktu. Jums būs jāinicē Tracy atkļūdošanas rīks pirms izmantojat to https://tracy.nette.org/en/guide:
<?php use Tracy\Debugger; use flight\debug\tracy\TracyExtensionLoader; // uzsaistes kods require __DIR__ . '/vendor/autoload.php'; Debugger::enable(); // Varat būt nepieciešams norādīt savu vidi ar Debugger::enable(Debugger::DEVELOPMENT) // ja izmantojat datu bāzes savienojumus savā lietotnē, tur ir // nepieciešams PDO apvalks, ko izmanto TIKAI IZSTRĀDĒ (lūdzu, neizmantojiet ražošanai!) // Tas ir vienādi ar ierasta PDO savienojuma parametriem $pdo = new PdoQueryCapture('sqlite:test.db', 'lietotājvārds', 'parole'); // vai, ja piesaistāt to Flight ietvarā Flight::register('db', PdoQueryCapture::class, ['sqlite:test.db', 'lietotājvārds', 'parole']); // tagad, kad veicat vaicājumu, tas uztverts laiku, vaicājumu un parametrus // Tas savieno punktus if(Debugger::$showBar === true) { // Tas jābūt nepatiesam, vai Tracy patiešām nevar renderēt :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app()); } // vairāk koda Flight::start();
Ja jums ir pielāgots sesiju apstrādātājs (piemēram, ghostff/session), jūs varat nodot jebkuru sesiju datu masīvu Tracy un tas automātiski to izvadīs jums. Jūs to nododat ar session_data atslēgu TracyExtensionLoader konstruktorā.
session_data
TracyExtensionLoader
lietot Ghostff\Session\Session; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('session', Session::class); if(Debugger::$showBar === true) { // Tas jābūt nepatiesam, vai Tracy patiešām nevar renderēt :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app(), [ 'session_data' => Flight::session()->getAll() ]); } // maršruti un citas lietas... Flight::start();
Ja jums ir Latte instalēts jūsu projektā, jūs varat izmantot Latte paneli, lai analizētu savus veidnes. Jūs varat nodot Latte instanci TracyExtensionLoader konstruktorā, izmantojot atslēgu latte otrajā parametrā.
latte
lietot Latte\Engine; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('latte', Engine::class, [], funkcija($latte) { $latte->setTempDirectory(__DIR__ . '/temp'); // šeit jūs pievienojat Latte Paneli Tracy $latte->addExtension(new Latte\Bridges\Tracy\TracyExtension); }); if(Debugger::$showBar === true) { // Tas jābūt nepatiesam, vai Tracy patiešām nevar renderēt :( Flight::set('flight.content_length', false); new TracyExtensionLoader(Flight::app()); }
Tracy ir fantastisks kļūdu apstrādātājs, ko var izmantot ar Flight. Tam ir vairākas panelis, kas var palīdzēt jums atkļūdot jūsu lietojumprogrammu. Ir ļoti viegli paplašināt un pievienot savus paneļus. Flight komanda ir izveidojusi dažus paneļus speciāli Flight projektam, izmantojot flightphp/tracy-extensions spraudni.
Instalējiet ar komponistu. Un jums faktiski vajadzēs instalēt to bez izstrādes versijas, jo Tracy tiek piegādāts ar ražošanas kļūdu apstrādes komponentu.
composer require tracy/tracy
Ir dažas pamata konfigurācijas opcijas, lai sāktu. Par tām varat lasīt vairāk Tracy dokumentācijā.
require 'vendor/autoload.php'; use Tracy\Debugger; // Iespējot Tracy Debugger::enable(); // Debugger::enable(Debugger::DEVELOPMENT) // dažreiz ir jābūt skaidrai (arī Debugger::PRODUCTION) // Debugger::enable('23.75.345.200'); // varat norādīt arī IP adreses masīvu // Šeit tiks reģistrēti kļūdas un izņēmumi. Pārliecinieties, ka šis katalogs pastāv un ir rakstāms. Debugger::$logDirectory = __DIR__ . '/../log/'; Debugger::$strictMode = true; // rādīt visas kļūdas // Debugger::$strictMode = E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED; // visas kļūdas, izņemot novecojušus paziņojumus if (Debugger::$showBar) { $app->set('flight.content_length', false); // ja Tracy josla ir redzama, tad Flight nevar iestatīt satura garumu // Tas ir specifisks Tracy paplašinājumam Flight, ja jūs to esat iekļāvuši // pretējā gadījumā komentējiet to. new TracyExtensionLoader($app); }
Kad jūs atkļūvojat savu kodu, ir dažas ļoti noderīgas funkcijas, lai izvadītu datus jums.
bdump($var)
dumpe($var)
Aktīvā ieraksta ir datu bāzes vienības atveidojums PHP objektā. Vienkārši sakot, ja jums ir lietotāju tabula jūsu datu bāzē, jūs varat "pārvērst" rindu šajā tabulā par User klasi un $user objektu jūsu koda bāzē. Skatiet pamata piemēru.
User
$user
Pieņemsim, ka jums ir šāda tabula:
CREATE TABLE users ( id INTEGER PRIMARY KEY, name TEXT, password TEXT );
Tagad jūs varat iestatīt jaunu klasi, lai pārstāvētu šo tabulu:
/** * Aktīvā ieraksta klase parasti ir vienskaitlis * * Ļoti ieteicams pievienot tabulas īpašības kā komentārus šeit * * @property int $id * @property string $name * @property string $password */ class User extends flight\ActiveRecord { public function __construct($datubāzes_savienojums) { // varat iestatīt šādi parent::__construct($datubāzes_savienojums, 'users'); // vai arī šādi parent::__construct($datubāzes_savienojums, null, [ 'table' => 'users']); } }
Tagad vērojiet maģiju notieko!
// priekš sqlite $datubāzes_savienojums = new PDO('sqlite:test.db'); // šis ir tikai piemēram, visticamāk izmantotu reālu datu bāzes savienojumu // priekš mysql $datubāzes_savienojums = new PDO('mysql:host=localhost;dbname=test_db&charset=utf8bm4', 'lietotājvārds', 'parole'); // vai mysqli $datubāzes_savienojums = new mysqli('localhost', 'lietotājvārds', 'parole', 'test_db'); // vai mysqli, izmantojot ne objektu pamatni $datubāzes_savienojums = mysqli_connect('localhost', 'lietotājvārds', 'parole', 'test_db'); $user = new User($datubāzes_savienojums); $user->name = 'Bobby Tables'; $user->password = password_hash('daža liela parole'); $user->insert(); // vai $user->save(); echo $user->id; // 1 $user->name = 'Joseph Mamma'; $user->password = password_hash('vēl viena forša parole!!!'); $user->insert(); // šeit nevarat izmantot $user->save(), jo tas domās, ka tas ir atjaunināšana! echo $user->id; // 2
Un tik viegli bija pievienot jaunu lietotāju! Tagad, kad datu bāzē ir lietotāja rinda, kā jūs to izvelkat?
Kafija ir pilnībā funkciju bagātota veidne, kas ir ļoti viegli lietojama un jūtas tuvāka PHP sintaksei nekā Twig vai Smarty. Turklāt to ir ļoti viegli paplašināt un pievienot savus filtrus un funkcijas.
composer require latte/latte
Ir dažas pamata konfigurācijas opcijas, lai sāktu darbu. Par tām variet lasīt vairāk Kafijas Dokumentācijā.
use Latte\Engine as LatteEngine; require 'vendor/autoload.php'; $app = Flight::app(); $app->register('latte', LatteEngine::class, [], function(LatteEngine $latte) use ($app) { // Šeit Kafija saglabās jūsu veidnes, lai ātrinātu lietošanu // Viena jauka lieta par Kafiju ir tā, ka tā automātiski atjaunina jūsu // kešatmiņu, kad veicat izmaiņas veidnēs! $latte->setTempDirectory(__DIR__ . '/../cache/'); // Paziņojiet Kafijai, kur būs jūsu skatu saknes direktorija. $latte->setLoader(new \Latte\Loaders\FileLoader($app->get('flight.views.path'))); });
Šeit ir vienkāršs piemērs izkārtojuma failam. Šis fails tiks izmantots, lai iesaiņotu visus pārējos skatus.
<!-- app/views/layout.latte --> <!doctype html> <html lang="lv"> <head> <title>{$title ? $title . ' - '}Mana Viedokļu Uzstādība</title> <link rel="stylesheet" href="style.css"> </head> <body> <header> <nav> <!-- jūsu navigācijas elementi šeit --> </nav> </header> <div id="content"> <!-- Šeit ir burvība --> {block content}{/block} </div> <div id="footer"> © Autortiesības </div> </body> </html>
Un tagad mums ir jūsu fails, kas tiks atveidots iekšējā šī satura blokā:
<!-- app/views/home.latte --> <!-- Tas paziņo Kafijai, ka šis fails ir "iekšpus" layout.latte faila --> {extends layout.latte} <!-- Šis ir saturs, kas tiks atveidots izkārtojumā iekšienē satura blokā --> {block content} <h1>Mājas Lapaspuse</h1> <p>Sveicināti manā aplikācijā!</p> {/block}
Tad, kad jūs dodies atveidot to iekš savas funkcijas vai kontrolierā, jūs darītu kaut ko līdzīgu tam:
// vienkāršs maršruts Flight::route('/', function () { Flight::latte()->render('home.latte', [ 'title' => 'Mājas Lapaspuse' ]); }); // vai, ja izmantojat kontroleri Flight::route('/', [HomeController::class, 'index']); // HomeController.php class HomeController { public function index() { Flight::latte()->render('home.latte', [ 'title' => 'Mājas Lapaspuse' ]); } }
Skatiet vairāk informācijas par to, kā izmantot Kafiju tā pilnīgākai potenciāla izmantošanai Kafijas Dokumentācijā!
Flight ir neaprakstāmi paplašināms. Ir daudz spraudņu, kas var tikt izmantoti, lai pievienotu funkcionalitāti jūsu Flight lietojumprogrammai. Daži no tiem ir oficiāli atbalstīti ar Flight komandas palīdzību, bet citi ir mikro/lite bibliotēkas, lai jums palīdzētu uzsākt darbu.
Kešatmiņa ir lielisks veids, kā paātrināt jūsu lietojumprogrammu. Ir daudz kešatmiņas bibliotēku, kas var tikt izmantotas kopā ar Flight.
CLI lietojumprogrammas ir lielisks veids, kā mijiedarboties ar jūsu lietojumprogrammu. Ar tām varat izveidot kontrolierus, parādīt visus maršrutus un citus darbus.
Sīkfaili ir lielisks veids, kā saglabāt nelielas datu daļiņas klienta pusē. Tos var izmantot, lai saglabātu lietotāja preferences, lietojumprogrammas iestatījumus un citus darbus.
Atkļūdošana ir būtiska, kad jūs strādājat savā lokālajā vides. Ir daži spraudņi, kas var uzlabot jūsu atkļūdošanas pieredzi.
Datubāzes ir pamats lielākajai daļai lietojumprogrammu. Tā ir veids, kā uzglabāt un iegūt datus. Dažas datubāzu bibliotēkas ir vienkārši aploksnes, lai rakstītu vaicājumus, un dažas ir pilnīga ORMs.
Šifrēšana ir būtiska jebkurai lietojumprogrammai, kas uzglabā jutīgus datus. Datus šifrēt un dešifrēt nav ļoti grūti, bet pareizi uzglabāt šifrēšanas atslēgu var būt grūti. Visbiežāk svarīgākais ir nekad nelikt jūsu šifrēšanas atslēgu publiskajā direktorijā vai to neiekļaut jūsu kodola krātuvē.
Sesijas nav īsti noderīgas API, bet, lai izveidotu tīmekļa lietojumprogrammu, sesijas var būt būtiskas, lai uzturētu stāvokli un pieteikšanās informāciju.
Veidne ir būtiska jebkurai tīmekļa lietojumprogrammai ar lietotāja saskarni. Ir daudz veidņu dzinēju, kas var tikt izmantoti ar Flight.
Vai ir spraudnis, ko vēlaties koplietot? iesniedziet Pull pieprasījumu, lai to pievienotu sarakstam!
Jums ir divas iespējas sākt darbu ar Flight:
Lai gan šie piemēri nav oficiāli atbalstīti no Flight komandas, tie jums var sniegt idejas par to, kā strukturēt savus projektus, kas izveidoti ar Flight!
Ja jums ir projekts, kuru vēlaties dalīties, lūdzu iesniedziet "pull request", lai to pievienotu šajā sarakstā!