Ich schiebe diesen Eintrag schon zu lange vor mir her… Heute möchte ich euch also das Fat Free Framework (F3) vorstellen – Dabei handelt es sich um ein großartiges Mikro-Framework, das alle wichtigen Features abdeckt und viele viele Module/Plugins mitbringt!

Das F3 ist quasi das Mikro-Framework unter den Mikro-Frameworks 😉 Und wieso? Weil der komplette Kern in einer einzigen Datei ausgeliefert wird. Diese beinhaltet etwa 2300 Zeilen und bringt 55 KB auf die Waage. Dadurch, dass das Framework in einer einzigen Datei ausgeliefert wird, gibt es keine vorgegebene Ordnerstruktur oder ähnliches – es bleibt alles euch überlassen!
F3 ist für PHP 5.3 konzipiert, läuft aber wohl auch Problemlos unter 5.4.x und 5.5.x! Alles was über den Kern hinaus geht (Datenbankanbindung, Sessions, Testing, Logging, …) wird in separaten Dateien und Klassen behandelt.

Hallo Welt, Fat Free Framework!

Das Fat Free Framework bietet -auch wenn ein paar Bereiche aktuell noch fehlen- eine solide und gute Dokumentation mit vielen Beispielen inklusive dem Lieblings-Skript aller Entwickler „Hallo Welt!“.

// "Hallo Welt" example from the 'UserGuide'.
$f3 = require('path/to/base.php');
$f3->route('GET /', function() {
   echo 'Hello, world!';
});
$f3->run();

Kurz und Schmerzlos. Leider finde ich keine aktuellen Benchmarks, doch F3 soll wahnsinnig flink unterwegs sein!

Routing

Als kleine Erweiterung zum „Hallo Welt“ Beispiel möchte ich kurz auf das Routing eingehen: Das F3 Routing wurde von Anfang an ReSTful aufgebaut. Das bedeutet, es ist ohne Probleme möglich auf GET, POST, PUT und DELETE Requests zu reagieren!
Das Routing funktioniert nicht nur mit Lambda-Funktionen, sondern auch mit anderen Callback-Varianten:

// OOP routing
class Page 
{
   public function start()
   {
      echo 'Startseite!';
   }
}

$f3->route('GET /oop','Page->start');

// Static class
class StaticPage 
{
   public static function start()
   {
      echo 'Startseite!';
   }
}

$f3->route('GET /static','StaticPage::start');

Darüber hinaus unterstützt das Routing auch Parameter und verschiedene Möglichkeiten, diese auszulesen:

// "Routing" example from the 'UserGuide'
$f3->route('GET /brew/@count', function($f3) {
   echo $f3->get('PARAMS.count') . ' bottles of beer on the wall.';
});

$f3->route('GET /brew/@count', function($f3, $params) {
   echo $params['count'] . ' bottles of beer on the wall.';
});

Natürlich gibt es noch einige weitere Features, wie z.B. dynamische Route-Handler, doch ich möchte mich nicht zu sehr darin vertiefen.

Template Engine

Mit an Board ist ein selbstentwickeltes und sehr simples Templating System:

// Backend:
$f3 = require('lib/base.php');
$f3->route('GET /', function($f3) {
   // Assigning a simple variable
   $f3->set('name','world');

   // Assigning a callback function
   $f3->set('headline', function($a,$b) {
      return '<h1>' . $a .' ' . $b . '</h1>';
   });

   // Assigning a boolean value for "IF-condition"
   $f3->set('loggedin', true);

   // Assigning an array
   $f3->set('fruits', array('apple', 'orange ', ' banana'));

   $template = new Template;

   echo $template->render('template.htm');
   // Alternative:
   // echo Template::instance()->render('template.htm');
});
$f3->run();

Sinn des ganzen ist es auf nervigen Code wie <?php echo $variable; ?> bzw. <?=$variable ?> verzichten zu können und gleichzeitig die PHP Logik von den Templates fern zu halten.

<!-- HTML Template -->
<h1>Hello {{ @name }}</h1>

<!-- or... -->
{{ @headline('Hello', 'World') }}

<!-- IF-condition -->
<check if="{{ @loggedin }}">
   <p>HTML chunk to be included if condition is true</p>
</check>

<!-- Foreach-loops -->
<repeat group="{{ @fruits }}" value="{{ @fruit }}">
   <p>{{ trim(@fruit) }}</p>
</repeat>

Weitere Plug-Ins

Zusätzlich zum F3 Core bekommt ihr im Download-Paket wie anfangs geschrieben viele weitere Dateien, welche euch für viele Situationen die nötigen Funktionalitäten liefern. Angefangen bei Authorisierungs-Klassen (auth), über Datenbank-Abstraktionen (SQL, Jig + jeweilige ORM Mapper), Bildbearbeitung (Image) und viele mehr… F3 ist außerdem sehr umgänglich im Bereich der Fremd-Bibliotheken!

Kritik?

Eine Sache am F3 gefällt mir ehrlich gesagt nicht so sehr – In vielen Bereichen wird mit Strings gearbeitet: z.B. beim Routing „GET /brew/@count„, oder auslesen von Parametern „PARAMS.count„. Diese müssen wiederum im Framework verarbeitet werden… Und das bedeutet es wird an mehreren Stellen hin- und her formatiert bis das Framework weiß, was zutun ist…
Ich sehe hier zwei Nachteile:

  1. Man kann nicht mit Autovervollständigung arbeiten (wie es z.B. bei Methoden-Namen oder Konstanten möglich wäre)
  2. Die Zeit/Resourcen, die für das formatieren verbraucht wird, könnte eingespart werden.

Aber wie gesagt, das ist nur meine eigene Meinung… Wirkliche „Kritik“ habe ich ansonsten keine.

Eher im Gegenteil! Wenn man sich mal das github Repo anschaut fällt auf, das es nur sehr wenige (jetzt grade 3) offene Probleme gibt, die aber bereits diskutiert werden… Das bedeutet (bei aktuell 391 geschlossenen Problemen) dass das F3 nicht viel zu meckern übrig lässt 😉 Vielleicht kann ich F3 in einem meiner nächsten Projekte benutzen – Dann könnte ich bestimmt einige reale Vor- und Nachteile beschreiben!

Bis dahin wünsche ich euch eine angenehme Woche und natürlich „Happy Coding„!

4 comments on “Vorstellung: Fat Free Framework – F3

    • Hallo Fox,
      viele Frameworks arbeiten mit extra Methoden zum auslesen von Parametern.
      Kohana z.B. bietet im Controller Kontext stehts ein Request-Objekt zur Verfügung, aus welchem man bequem die Parameter auslesen kann.

      Was das Routing angeht, so gibt es auch wieder diverse Frameworks die eher mit Methoden und Parametern arbeiten, wie z.B. das „slim“ Framework: http://web-developer-blog.com/2012/10/das-eigene-kleine-portfolio-mit-dem-slim-framework-raintpl-co.html Das Framework liefert für die verschiedenen HTTP-Methoden (GET, POST, PUT und DELETE) eigene Methoden.

      Aber wie bereits im Beitrag geschrieben – das ist nur meine persönliche Meinung 😉

      Viele Grüße
      Leo

  • Hallo, also ich habe keine Probleme mit der Auto-Vervollständigung in meinem IDE (benutze PHPStorm)

    also Sachen wie $f3 = \Base::instance(); funktionieren bei einwandfrei..,
    und sollte irgendein Objekt, welches mal aus einer Variable kommt, nicht von der IDE erkannt werden, hilft PhpDoc casting alá

    /** @var \DB\SQL $db */
    $db = $f3->get('SQLDB');
    $db->exec(...) // und autocomlete läuft ;)
    • Hallo Ikkez,
      vielen Dank für deine Antwort! Ich fürchte ich habe mich im Posting missverständlich ausgedrückt:
      Die Klassen, Methoden und Parameter werden natürlich ordentlich von der IDE vorgeschlagen und vervollständigt (Ich nutze auch PHPStorm)… Meine Kritik galt eher den Strings mit denen Request-Parameter ausgelesen oder Routen erstellt werden wie z.B.

      $f3->route('GET|HEAD /obsoletepage', ...)
      // Oder...
      $f3->route('GET /example [ajax]', ...);

      Hier muss man wissen, was F3 anbietet und wie die Syntax lautet. Andere Frameworks wie Kohana oder Slim arbeiten hier allerdings mit Methoden oder fordern eigene Logik im Code:

      // [...] Innerhalb eines Kohana Controller:
      if (Request::$current->method() == HTTP_Request::POST) 
      { 
         /* ... */ 
      }
      // [...]
      // Slim arbeitet ähnlich wie F3, allerdings mehr Methoden-orientiert.
      $app = new \Slim\Slim();
      $app->get('/', /* ... */ );
      $app->post('/', /* ... */ );

      Natürlich ist F3 durch sein einfaches Routing schneller einsatzbereit, nur muss man eben genau wissen was Sache ist.

      Wie gesagt, es ist auch weniger „reale Kritik“ als eine persönliche Abneigung.

      Viele Grüße aus Düsseldorf
      Leo

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.