Fat-Free Framework passo a passo


Então vamos a mais um passo a passo, basicamente irei explicar como instalar, testar e usar Fat-Free Framework que descobri recentemente graças ao Stack Overflow devido a não encontrar nada muito claro em Português decidir criar esse post que certamente irá ajudar a todos nos.

Instalação

Para instalar será inicialmente necessário baixar o F3 (Fat-Free Framework) e seguir alguns requisitos, então vamos lá!

Download


Basta realizar o download e extrair em algum diretório do seu servidor web, a princípio ele irá ter um exemplo e vários arquivos dentro da diretório:

O diretório lib é onde está o Framework e seus componentes, o diretório ui são apenas para o exemplo que já vem e a documentação.

Podemos apagar tudo menos o .htaccess e o diretório ui.




Requerimentos

Para utilizar o F3 é necessário que o módulo rewrite esteja ativo e a ativação dele varia de servidor para servidor, caso tenha dúvida comente que eu ajudarei para cada caso especifico. Para facilitar estou disponibilizando um script para verificar se o módulo está ativo ou não:


.htaccess

Também é necessário que no diretório onde está o index.php tenha um .htaccess para reescrever as URL do apache, seu conteúdo deve conter os seguintes parâmetros:

Seguindo esses requerimentos seu servidor já está pronto para usar o F3!.

Para fazer a requisição do f3 basta realizar um $f3=require('dir ond ele está/base.php'); com isso já faz a requisição e já a declara a classe na variável $f3.

Entendendo o F3

Fat-Free Framework facilita a construção de sites inteiros em um instante. Com o mesmo poder e brevidade que os modernos toolkits e bibliotecas Java script, o F3 ajuda você a criar aplicações em PHP de aparência melhor e mais confiáveis. Com apenas um olhar para o seu código-fonte PHP e qualquer um vai achar fácil de entender, o quanto você pode realizar em apenas algumas linhas de código e quão poderoso os resultados são.

Um designer sabe que ele conseguiu a perfeição não quando não há nada a acrescentar, mas quando não há nada para tirar.

- Antoine de Saint-Exupéry

Exemplos e explicações

Em posse do F3 vamos ao primeiro exemplo:

// 01-Hello World

Esse exemplo basicamente irá quando for realizado a requisição do diretório / (homepage) irá carregar a função e imprime o "hello Word" assim que executar o comando $f3->run();

// 02-About

Esse exemplo carrega pega 3 paginas, home (exemplo 01) , about, e aboutObject, o diferencial aqui é o aboutObject o qual mapeamos da classe webPage. já o hello/@name é basicamente igual hello/name=$var, isso é quando passado o valor /hello/esseValorAqui o texto "esseValorAqui" será atribuído a variável name que por sua vez será passado para a função greet. Os outros basicamente executa a função a qual exibe uma mensagem na tela.

// 03-Routes_and_Tokens

Aqui já começamos a trabalhar com valores, brevemente explicado no exemplo 02;
GET /brew/@count; é similar a utilizar variáveis em linha, por exemplo: quando a URL conter /brew/35 seria a mesma coisa que a URL conter /brew?count=35, notem que é visualmente muito mais amigável de se ver, e para recuperamos esses valores temos 2 modos, o primeiro dele é através do método $f3->get('PARAMS.count'), onde count é a variável recebida, a segunda maneira é através do meio padrão $params['count'] onde count é o nome da variável. E caso o que não vier após o /brew/ não seja relevante pode ser utilizar o '*' (asterisco), com isso será aceito qualquer coisa após o asterisco.
OBS. não utilize o /* juntamente do /@name, utilize um ou outro.

Funções

Com o f3 temo enumeras funções a disposição irei colocar a maioria delas aqui explicando o que fazem e suas funções, certamente não irei colocar todas pois pretendo ir atualizando, conforme for dominando o Framework, então vamos as funções, lembrando que todas os exemplos que fizer aqui irei disponibilizar no GitHub para nossa alegria.

01-set.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
#mixed set (String $key, mixed $val [, int $ttl = 0])

// Trabalhando com o set;

// Exmeplos variados de variaveis 

$f3->set('a',123); // a variavel a  = 123
$f3->set('b','c'); // a variavel b ='c'  (string)
$f3->set('c','qualqer coisa'); // a variavel c = 'qualquer coisa' (string)

// Imprimindo saidas 
echo "
";
echo "set 'a' saida=> ";
var_dump($f3->get('a'));
echo "set 'b' saida=> ";
var_dump($f3->get('b'));
echo "set 'c' saida=> ";
var_dump($f3->get('c'));
echo "
"; // Exemplos de vetores $f3->set('hash',array ('x'=> 1, 'y'=> 2, 'z'=> 3)); //Támbém é possivel usar o ponto para criação de vetores $f3->set('vetor.x',1); $f3->set('vetor.y',2); $f3->set('vetor.x',3); // Imprimindo saidas echo "
";
echo "set 'hash' saida=> ";
var_dump($f3->get('hash'));
echo "set 'vetor' saida => ";
var_dump($f3->get('vetor'));
echo "
"; // Exemplo de configração de propriedade de objeto $f3->set('a', new\stdClass); $f3->set('a->hello','Word'); echo $f3->get('a')->hello; // imprimie Word // Imprimindo saidas echo "
";
echo "set 'a' <= 'new\stsClass' ";
var_dump($f3->get('a'));
echo "
"; // Modo curto de uso. /* Cuidado para não definir nomes de de funções nativas do sistema. */ $f3->LANGUAGE = 'en'; $f3->foo = 1234; $f3['bar']= "huehueBr"; // Imprimindo saidas echo "
";
echo "set '$f3->LANGUAGE' saida=> ";
var_dump($f3->LANGUAGE);
echo "set '$f3->foo' saida=> ";
var_dump($f3->foo);
echo 'set $f3[\'bar\'] saida=> ';
var_dump($f3['bar']);
echo "
";
Basicamente a função do set é definir uma um ponto de memória para uma variável, objeto, classe ou vetor, como podemos ver no exemplo.

02-set_ttl.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

// por padrão o cache fica desativado, entamos precisamos Ativar o/
$f3->set('CACHE',TRUE);

# lógica:
#mixed set (String $key, mixed $val [, int $ttl = 0])

// Trabalhando com o set;

// Exmeplos variados de variaveis :)
$f3->set('a',123, 3600); // a variavel a  = 123, salvas no cache por 1 hora
$f3->set('b','c', 60); // a variavel b ='c'  (string), salvas no cache por 60 segundos
$f3->set('c','qualqer coisa', 3); // a variavel c = 'qualquer coisa' (string), salvas no cache por 3 segundos

// Imprimindo saídas 
echo "
";
echo "set 'a' saida=> ";
var_dump($f3->get('a'));
echo "set 'b' saida=> ";
var_dump($f3->get('b'));
echo "set 'c' saida=>: \n";
var_dump($f3->get('c'));
echo "
"; // Exemplos de vetores $f3->set('hash',array ('x'=> 1, 'y'=> 2, 'z'=> 3), 3600); // Variável armazenada em cache por 1 hora // Imprimindo saídas echo "
";
echo "set 'hash' saida=> ";
var_dump($f3->get('hash'));
echo "
";
Com a função $f3->set(); podemos também definir caches para as variáveis em questão, para isso basta adicionar um terceiro parâmetro o qual define o tempo de armazenamento do Cache. Por padrão os caches ficam desativados, para ativar basta definir o seguinte parâmetro no início do código:
$f3->set('CACHE',TRUE);
Onde TRUE está ativo o cache e FALSE desativa o cache.

03-get.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
#mixed get ( string $key [, string|array $args = NULL ] )

// Trabalhando com o get;

// Exmeplos variados de variaveis 
echo "
";
$f3->set('myVar','Olá Mundo 
');
echo "f3-> get('myVar'): ";
echo  $f3->get('myVar'); // imprime Olá Mundo

$local_var = $f3->get('myVar');
echo "\$local_var: ";
echo $local_var;
echo "
"; $timestamp1=strtotime('28-03-2017'); $timestamp2=strtotime('29-03-2017'); $timestamp3=strtotime('01-04-2017'); echo "
";
$f3->set('var1','Data Atual: {0,date} - Hora Atual: {0,time} 
');
echo "\$f3->set('var1','Data Atual: {0,date} - Hora Atual: {0,time}: 
');";
echo $f3->get('var1', time()); // Forma abreviada de $f3->format($f3->get('var1'),time());
echo "

";

$f3->set('var2','Saída: {0,date} - Chegada: {1, date} e uma outra data qualquer {2, date} 
');
echo "\$f3->set('var2','Saída: {0,date} - Chegada: {1, date} e uma outra data qualquer {2, date}'); ";
echo $f3->get('var2', array($timestamp1, $timestamp2, $timestamp3)); // Forma abreviada de $f3->format($f3->get('var2'),$timestamp1,$timestamp2);
echo "
Forma abreviada de \$f3->format($f3->get('var2'),\$timestamp1,\$timestamp2, \$timestamp3);
";
echo $f3->format($f3->get('var2'),$timestamp1,$timestamp2, $timestamp3);
echo "
"; // Vetores: $f3->set('myarray', array( 0=> 'valor_0', 1=> 'valor_1', 'baz'=> 112233, 'foo'=> 'eu to com fome!', 'bar'=> 7.55, ) ); echo "
";
echo " 
\$f3->get('myarray[0]'): ";
echo $f3->get('myarray[0]'); // value_0
echo " 
\$f3->get('myarray.1'): ";
echo $f3->get('myarray.1'); // value_1
echo " 
\$f3->get('myarray.bar'): ";
echo $f3->get('myarray.bar'); // 123
echo " 
\$f3->get('myarray[\"foo\"]'): ";
echo $f3->get('myarray["foo"]'); // Eu to com fome!
echo " 
\$f3->get('myarray[baz]'): ";
echo $f3->get('myarray[baz]'); // 4.56, Aviso uso alternativo simples e sem aspas duplas;
echo " 
\$f3->myarray['foo']: ";
echo $f3->myarray['foo']; 
echo " 
\$f3['myarray']['baz']: ";
echo $f3['myarray']['baz'];
echo "
";
A Função $f3->get(); tem basicamente a função de pegar os valores armazenados através do $F3->set();.
O get() pode fazer uso de espaços reservados delimitados entre {} (chaves) o qual é passado através do segundo parâmetro, exemplificado no código acima.

04-ref.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
#mixed &ref ( string $key [, bool $add = true ] )

// Trabalhando com o ref;
$f3->set('nome','Bulfaitelo'); // Declaro em nome a palavra Bulfaitelo
$a = &$f3->ref('nome'); // gero a referencia do nome a variável $a
$a = 'Fat-Free Framework'; // declaro atraves da referencia $a o novo valor da chave 'nome'
echo $f3->get('nome'); // ira imprimir Fat-Free Framework
echo "
";
echo "
";

// Seguno exemplo
$new = &$f3->ref('newVar'); // Criando a nova variavel 'newVar' e sua referencia ($new). 
$new = 'Olá Mundo';
echo $f3->get('newVar');
echo "
";

// Terceiro Exemplo (trabalhando com Objetos);
$newObject = &$f3->ref('newObj->name');
$newObject = "
 Bull Project";
echo $f3->get('newObj')->name; // Bull Project
echo $f3->get('newObj->name'); // Bull Project
echo $f3->get("newObj.name"); // Bull Project
echo "
";
echo "
";
// outras fromas de trabalhar o ref()
$a = &$f3->ref('hero.name');
$a = "Goku";
echo $f3->get('hero')['name']; // Goku
echo "
";
echo $f3->get('hero.name'); // Goku 
echo "
";
// ou 
$b = &$f3->ref('hero'); // variavel
$b['name'] = "Saitama"; // criando o vetor e a posição 'name' dentro da variavel hero
$myArray = $f3->get('hero');

echo $myArray['name']; // Saitama
A função $f3->ref(); Cria uma referencia direta a variável, por exemplo $a = &$f3->ref('bala'); se declarar um valor na variável $a estará declarando diretamente na chave 'bala' isso vale para objetos, vetores e etc...

05-exists.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# bool exists ( string $key [, mixed &$val=NULL] )

// verificando se uma variavel existe.
$f3->set('foo','value');

var_dump($f3->exists('foo')); // true
var_dump($f3->exists('bar')); // false, porque a variavel não foi definida)

// para funcionar tem que usar a função $f3->sync(); para sincronizar as as globais
var_dump($f3->exists('COOKIE.userid')); 
var_dump($f3->exists('SESSION.login')); 
var_dump($f3->exists('POST.submit')); 
// todas retornam false, não foram definidas antes.
Existis verifica se a variável existe, basicamente tem a mesma f unção do isset(); retorna true para caso a variável exista e false para caso não exista, os exemplos COOKIE, SESSION, POST, Não foram definidas, existe possibilidade de sincronizar automaticamente com uso da função $f3->sync();

06-devoid.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# bool devoid ( string $key )

$f3->set('foo',''); // null
$f3->set('bar',array()); // null
$f3->set('baz',array(),10); // em chache porem null

var_dump($f3->devoid('foo')); // true
var_dump($f3->devoid('bar')); // true
var_dump($f3->devoid('baz')); // true
var_dump($f3->devoid('bazzz')); // true
Verifica se uma variável está vazia, similar ao empty(); retorna true quando for vazia ou não instanciada, retorna false para caso esteja em cache.

07-clear.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# void clear ( string $key )

// remove a chave completamente da memória. 

$f3->set('foobar','VALOR valorzãum');
var_dump($f3->get('foobar')); // imprime VALOR valorzãum
$f3->clear('foobar');
var_dump($f3->get('foobar')); // NULL

$f3->set('myArray', array(0 => 'abc', 1 => 'def'));
var_dump($f3->get('myArray')); // array(2) { [0]=> string(3) "abc" [1]=> string(3) "def" } 
$f3->clear('myArray.0');
var_dump($f3->get('myArray')); // array(1) { [1]=> string(3) "def" } 

// Casos especiais 
$f3->clear('SESSION'); // Destroi a SESSION do usuario
$f3->clear('COOKIE.foobar'); // Remove o 'foobar' do COOKIE
$f3->clear('CACHE'); // Limpa todos os caches 
Apaga da memória completamente a chave e seu valor, também elimina os caches caso existam.

08-mset.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# void mset ( array $vars [, string $prefix = '' [, integer $ttl = 0 ]] )

// Atribuição de múltiplas variáveis usando matriz associativa
$f3->mset(array(
  'var1'=> 'Valor1',
  'var2'=> 'Valor2',
  'var3'=> 'Valor3'
 )
);

var_dump($f3->get('var1'));
var_dump($f3->get('var2'));
var_dump($f3->get('var3'));

// Atribuição de múltiplas variáveis usando matriz associativa com prefixo
$f3->mset(array(
  'var1'=> 'Valor1',
  'var2'=> 'Valor2',
  'var3'=> 'Valor3'
 ),
 'pre_'
);

var_dump($f3->get('pre_var1'));
var_dump($f3->get('pre_var2'));
var_dump($f3->get('pre_var3'));
Cria múltiplas variáveis usando matriz associativa, também podemos utilizar um prefixo (segundo exemplo).

09-hive.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# array hive ()
printf ("A Busy Hive: 
%s
", var_export( $f3->hive(), true ) );
Esse aqui eu não sei bem como dizer o que faz, ele retorna muitas informações do servidor, até mais informações do que o $_SERVER[] muito bom para criar debugs.

10-copy.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed copy ( string $src, string $dst )
$f3->set('foo','123');
$f3->set('bar','Barbar');
$bar = $f3->copy('foo','bar'); // bar = '123'

$bar = 456;
$f3->set('foo','789');

var_export($f3->get('bar')); // '123'
var_export($f3->get('foo')); // '789'
A função $f3->copy(); basicamente copia um valor de uma chave para outra, copia o valor da primeira chave para a segunda, vaso já tenha valor ela reescreve, e caso não tenha sido criada ela a cria a chave com o valor passado pelo primeiro parâmetro.

11-concat.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string concat ( string $key, string $val )

// Retornar um resultado concatenado. 

$f3->set('count',99);
$f3->set('item', 'chocolate');

$text = $f3->concat('count', ' Barras de '. $f3->get('item'));
$text.= ' na minha geladeira';

$f3->concat('wall', $f3->get('count')); // a chave wall foi criada 
echo $f3->get('wall');
echo "
";
echo $text;
A função $f3->concat(); tem a função de concatenar e salvar o valor na chave, e caso a chave ainda não tenha sido criada, ela e criada, o primeiro parâmetro é a chave e o segundo e o valor a ser concatenado.

12-flip.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# array flip ( string $key )

$f3->set('vetor', array(
 'foo1'=>'bar1',
 'foo2'=>'bar2',
 'foo3'=>'bar3',
));
echo "
Antes do flip:
";
var_export($f3->get('vetor'));
echo "
"; $f3->flip('vetor'); echo "
Depois  do flip 
";
var_export($f3->get('vetor'));
echo "
"; /*Antes do flip: array ( 'foo1' => 'bar1', 'foo2' => 'bar2', 'foo3' => 'bar3', ) Depois do flip array ( 'bar1' => 'foo1', 'bar2' => 'foo2', 'bar3' => 'foo3', )*/
A função $f3->flip();  manipula vetores e troca os valores das chaves pelas suas chaves e o valor da chave se torna a nova chave, em suma ele inverte as posições, caso o valor da chave se repita ele pega o último valor existente no vetor

13-push.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed push ( string $key, mixed $val )

$f3->set('frutas', array(
 'Tomate', // tomate e fruta u.u
 'banana', 
 'maçã'
));

$f3->push('frutas','maracuja');

echo "
";
var_export($f3->get('frutas'));
echo "
"; /*array ( 0 => 'Tomate', 1 => 'banana', 2 => 'maçã', 3 => 'maracuja', )*/
A Função $f3->push(); basicamente insere automaticamente um novo valor na ultima posição do vetor, criando a próxima chave automaticamente. Obs.: se as chaves forem personalizadas ele não irá segui-las e sim criar um novo valor 0.

14-pop.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed pop ( string $key )

$f3->set('frutas', array(
 'Tomate', // tomate e fruta u.u
 'banana', 
 'maçã'
));

$f3->pop('frutas');
echo "
";
var_export($f3->get('frutas'));
echo "
"; /*array ( 0 => 'Tomate', 1 => 'banana', )*/
A função $f3->pop(); remove o último elemento do vetor.

15-unshift.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed unshift ( string $key, string $val )

$f3->set('frutas', array(
 'Tomate', // tomate e fruta u.u
 'banana', 
 'maçã'
));

$f3->unshift('frutas', 'Laranja');
echo "
";
var_export($f3->get('frutas'));
echo "
"; /*array ( 0 => 'Laranja', 1 => 'Tomate', 2 => 'banana', 3 => 'maçã', )*/
A função $f3->unshift(); adiciona um novo elemento no início do vetor e reordenando as demais chaves.

16-shift.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed unshift ( string $key, string $val )

$f3->set('frutas',array(
 'cemente'=>'Maçã',
 '11'=> 'Bananas',
 '6'=> 'Kiwi',
 'branca' => 'Pera'
));

$f3->shift('frutas');
echo "
";
var_export($f3->get('frutas'));
echo "
"; /*array ( 0 => 'Bananas', 1 => 'Kiwi', 'branca' => 'Pera', )*/
A função $f3->shift(); remove o primeiro elemento do vetor, ela faz uso da função array_shift(), que ao ser usada reordena todo o vetor para começar da chave 0.

17-merge.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# array merge ( string $key, array $src )

$f3->set('vetor', array('azul', 'verde'));

$bar = $f3->merge('vetor', array('amarelo', 'vermelho'));

echo "
";
var_export($bar);
echo "
"; /*array ( 0 => 'azul', 1 => 'verde', 2 => 'amarelo', 3 => 'vermelho', )*/
A função $f3->merge(); retorna a fusão do primeiro argumento com o segundo, note que ele não muda os valores do primeiro argumento somente a saída dele que é a fusão.

Codificação e Conversão

Agora vamos trabalhar diretamente com as funções de codificação e conversão de caracteres.

01-fixslashes.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string fixslashes ( string $str )

$old_file_path = __FILE__;
echo "
";
var_export($old_file_path); // \www\meusite\meu_arquivo.txt
echo "
"; $new_file_path = $f3->fixslashes($old_file_path); echo "
";
var_export($new_file_path); // /www/meusite/meu_arquivo.txt
echo "
";
A Função $f3->fixslashes(); transforma as barras invertida em contra barra.

02-split.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# array split ( string $str [, $noempty = TRUE ] )

$dados = 'valor1, valor2 ; valor3 | valor4';

echo "
";
var_export($f3->split($dados));
echo "
"; /*array ( 0 => 'valor1', 1 => 'valor2', 2 => 'valor3', 3 => 'valor4', )*/
A função $f3->split();  e similar a função explode, com a vantagem que já divide os valores separados por: "," (virgula),";" (ponto e vírgula), "|" (barra vertical), por padrão é removido os espaços, para que isso não ocorra coloque um segundo parâmetro como true.

03-stringify.php

# lógica:
# string stringify ( mixed $arg [, array $stack = NULL ] )

$elementos = array('agua', 'terra', 'vento', 'fogo');
$fireworks = array($elementos, shuffle($elementos), array_flip($elementos));
echo "
";
echo ($f3->csv($fireworks)); //['agua','terra','vento','fogo'],true,['vento'=>0,'fogo'=>1,'terra'=>2,'agua'=>3]
echo "
"; $carro = new stdClass(); $carro->cor = 'verde'; $carro->posicao = array('35.360496', '138.727798'); echo "
";
echo $f3->stringify($carro); //stdClass::__set_state(['cor'=>'verde','posicao'=>['35.360496','138.727798']])
echo "
";
A função $f3->stringify(); converte o qualquer objeto vetor em uma sequencia de caracteres compactado e exportavel.

04-csv.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string csv ( array $args )

$elementos = array('agua', 'terra', 'vento', 'fogo');
echo "
";
echo ($f3->csv($elementos)); //'agua','terra','vento','fogo'
echo "
";
A fução $f3->csv(); retorna o vetor recebido no formato CSV (Comma-separated values) ou Valores Separados Por Vírgula.

05-camelcase.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string camelcase ( string $str )
echo "
";
echo $str_com_underline = "string_underline"; //string_underline
echo "
";
echo $f3->camelcase($str_com_underline); //stringUnderline
echo "
";
A função $f3->camelcase(); transforma textos separados por "_" (underline) pela letra posterior em caixa alta.

06-snakecase.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string snakecase ( string $str )
echo "
";
echo $strSemUnderline = "stringSemUnderline"; //stringSemUnderline
echo "
";
echo $f3->snakecase($strSemUnderline); //string_sem_underline
echo "
";
A função $f3->snakecase(); faz o inverso da $f3->camelcase();, isso é, ela transforma textos separados por letas em caixa alta por textos separados por underline.

07-sign.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# int sign ( mixed $num )

echo "
"; 
echo $f3->sign(-5); // -1
echo "
"; 
echo $f3->sign(0); //  0
echo "
"; 
echo $f3->sign(6); //  1
echo "
";
A função $f3->sign(); analisa e verifica se o número é maior que zero e retorna "1", se for igual a zero retorna "0" ou se for menor que zero retorna "-1", seu funcionamento é parecido com uma das novas funções do PHP 7.0 o operador Spaceship();.

08-hash.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string hash ( string $str )

echo $f3->hash('Bulfaitelo'); //dyl3n4glpxrj
A função $f3->hash(); gera um hash 64 bits / base 36 com base no valor recebido. OBS.: na documentação oficial o hash retornaria uma string de 11 caracteres, porem nos meus testes esse valor teve uma variação de 11 a 13 caracteres, o PHP utilizado foi o 7.

09-base64.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string base64 ( string $data, string $mime )

echo $saida = $f3->base64(' Stronnnng! ','text/html'); //data:text/html;base64,PGI+IFN0cm9ubm5uZyEgPC9iPg==
echo "
";

echo base64_decode('PGI+IFN0cm9ubm5uZyEgPC9iPg=='); //  Stronnnng! 
A função $f3->base64(); retorna o valor codificado em base 64.

10-encode-decode.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string encode ( string $str )
# string decode ( string $str )

echo $encoded = $f3->encode("Aqui será  Codificado "); // Aqui será <b> Codificado </b&gt
echo "
";
echo $f3->decode($encoded);  // Aqui será Codificado (codificado em strong)
As funções $f3->encode(); e $f3->decode(); encode converte os caracteres especiais "<" e ">" em entidades HTML no padrão UTF-8 e o encode converte as entidades HTML em caracteres especiais.

11-clean.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string clean ( mixed $var [, string $tags = NULL ] )

$text = "O rato do Rei de Roma Fez alguma  alert('Que não Lembro')  "; // O rato do Rei de Roma Fez alguma alert('Que não Lembro') (escrevi errado intencionalmente Blogger...)
//echo $text; // texto com alert.

echo $f3->clean($text); // removendo HTML tags
echo "
";
echo $f3->clean($text, 'i,b'); // O rato do Rei de Roma Fez alguma  alert('Que não Lembro')
A função $f3->clean(); remove todos ou algumas tags em HTML, bastando passa no segundo parâmetro os HTML permitidos. 

12-scrub.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string scrub ( mixed &$var [, string $tags = NULL ] )

$text = "Um elefante incomoda Muita gente, dois....";

$textScoobyDoo = $f3->scrub($text, 'b,u');

echo $text; // Um elefante incomoda Muita gente, dois....
A função $f3->scrub(); é similar a função $f3->clean(); porem o valor recebido é o valor de referência, realizando a função diretamente na variável recebida.

Localização

Aqui vamos ver a funções destinada a localização da aplicação, como idiomas e traduções formato de data.

01-format.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');
header('Content-Type: text/html; charset=utf-8');
# lógica:
# string format( string $format [, mixed $arg0 [, mixed $arg1...]] )

// Formatando Numeros e textos:
echo "
";
echo $f3->format("Nome: {0} - Idate: {1} \n", 'Bull', '28'); // Nome: Bull - Idate: 28 
echo $f3->format("Data Atual: {0, date} - Hora atual: {0, time}\n", time()); // Data Atual: 01/04/2017 - Hora atual: 14:33:59
echo $f3->format("Criado em: {0, date, custon, %A, Semana: %V}\n", time()); // Criado em: sábado, Semana: 13 (dia do teste)
echo $f3->format("{0} é exibido um numero decimal, enquanto {0,number,integer} é um numero arredondado\n", 12.54); // 12,54 é exibido um numero decimal enquanto 12,54 é um numero arredondado
echo $f3->format("Preço: {0, number, currency}\n", 29.90); // Preço: R$ 29,90
echo $f3->format("Porcentagem: {0,number, percent}\n", 0.175); // Porcentagem: 18%
echo $f3->format("Numero Decimal: {0, number, decimal,2}\n", 0.171232235); // Numero Decimal: 0,17
echo $f3->format("Numero Decimal: {0, number}\n", 1235488); // Numero Decimal: 1.235.488,00

echo "\n";
// Dialogos:
$lista_dialogo ='{0, plural,'.
  'zero {Seu carrinho está vazio.},'.
  'one {Um (#) item em seu carrinho.},'.
  'two {Um par de itens em seu carrinho.},'.
  'other {Você tem # itens en seu carrinho.}
}';

echo $f3->format($lista_dialogo."\n",0); // Seu carrinho está vazio.
echo $f3->format($lista_dialogo."\n",1); // Um (1) item em seu carrinho.
echo $f3->format($lista_dialogo."\n",2); // Um par de itens em seu carrinho.
echo $f3->format($lista_dialogo."\n",6); // Você tem 6 itens en seu carrinho.

echo "\n";
// Dialogos Segundo Exemplo: (GET)
$f3->set('os_livros',
 '{0, plural,'.
  'zero  {Não a livros s#bre a mesa},'.
  'one  {O livro está sobre a mesa},'.
  'two  {Dois (#) livros sobre a mesa},'.
  'other  {Existem # livros sobre a mesa (que mesa grande não?)},'.
 '}'
);

echo $f3->get('os_livros', 0)."\n"; // Não a livros s0bre a mesa
echo $f3->get('os_livros', 1)."\n"; // O livro está sobre a mesa
echo $f3->get('os_livros', 2)."\n"; // Dois (2) livros sobre a mesa
echo $f3->get('os_livros', 5)."\n"; // Existem 5 livros sobre a mesa (que mesa grande não?)
echo $f3->get('os_livros', 30)."\n"; // Existem 30 livros sobre a mesa (que mesa grande não?)
echo "
";
A função $f3->format(); tem enumeras funções, até então umas das mais praticas funções que tive o contato, o format, tem semelhanças com a função do php printf(); o qual podemos escrever o texto e variáveis não diretamente na string e sim como um segundo parâmetro, no caso do format utilizamos as "{}" chaves a qual determina o que será impresso e como será impresso, podemos já tratar o numero diretamente em sua impressão, o format consegue moldar as seguintes saídas de dados:
  • date
  • date,short
  • date,long
  • date,custom,{exp}
  • time
  • time,short
  • time,custom,{exp}
  • number,integer
  • number,currency
  • number,currency,int
  • number,currency,{char}
  • number,percent
  • number,decimal,{int}
  • plural,{exp}
Os quais foram explicados no código acima. 

Outra propriedade incrível é a opção de criarmos vetores com textos predefinidos para tornar mensagens padrões mais dinâmicas, para utilizar basta criar uma variável ou armazena-los no $f3->set(); seguindo os padrões descritos no código de exemplo 01-format.php.

Roteamento

Aqui vamos entrar na parte que me fez utilizar esse framework, o qual dispõe de muitas ferramentas para tornar a URL mais amigável para os usuários que estão acessando sua aplicação, além de tornar um pouco mais seguro pois o usuário não vai ter acesso diretamente as arquivos e diretórios pois são todos virtuais.

01-alias.php

// FRAMEWORK F3
$f3 = require('../../lib/base.php');

# lógica:
# string alias ( string $name [, array|string $params = array() ] )

$f3->route('GET @complex:/resize/@format/*/sep/*','App->nowhere');
$f3->alias('complex','format=20x20,2=foo/bar,3=baz.gif');
$f3->alias('complex',array('format'=>'20x20',2=>'foo/bar',3=>'baz.gif'));
// Ambos os exemplos retornariam '/resize/20x20/foo/bar/sep/baz.gif'
A função $f3->alias(); cria um apelido para o $f3->route();  criada anteriormente, realmente ainda não entendi como ela funciona corretamente assim que entender irei atualizar.

02-build.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# string build ( string $url [, array $params = array() ] )

$f3->set('PARAMS.canal','Bullboladao');

echo "
";
echo $f3->build('@canal'); // exibe 'Bullboladao'
echo "
";
echo $f3->build('/get-it/now/@canal'); // exibe '/get-it/now/Bullboladao'
echo "
";
echo $f3->build('/subscribe/@canal');  // exibe '/subscribe/Bullboladao'
echo "
";
echo  $f3->build('/resize/@format/*/sep/*', array(
 'format'=>'100x100',
 2  =>'foo/bar',
 3  =>'baz.gif'
 ));

echo $f3->build('/resize/@format/*/sep/*',array(
  'format'=>'200x200',// 1=>'200x200' também deferia funcionar. 
  2=>'foo/bar',
  3=>'baz.gif'
));
A função $f3->build(); substitui os valores passados pelos os valores recebidos pelo segundo parâmetro. OBS.: quando utilizo o @nome_variavel ele receber pelo mesmo nome sem problema, porem quando utilizo do "/*/" estranhamente o valor determinado não está funcionando.

03-mock.php

// FRAMEWORK F3
$f3 = require('../lib/base.php');

# lógica:
# mixed mock ( string $pattern [, array $args = NULL [, array $headers = NULL [, string $body = NULL ]]] )

//$f3->mock('GET /pagina/view [ajax]'); // exemplo basico de uso. 

$f3->route('GET @grub:/food/@nome',
    function($f3) {
        echo 'Olá, '.$f3->get('PARAMS.nome') ;
    }
);
$f3->mock('GET @grub(@nome=Bull)');

var_dump($f3->get('PARAMS')); // verificando que o nome recebei o valor Bull.
A função $f3->mock(); simula requisições http, ainda está bem vago sua funcionalidade comparado com as funções mais especifica, mas como esse post já está enorme irei atualizando conforme for aprendendo mais.

Links:

http://fatfreeframework.com/
https://github.com/bulfaitelo/Fat-Free-Framework-Examples

Conclusão 

Mesmo sem concluir toda a documentação do Fat-Free Framework tive alguns empecilhos com a utilização do microframework, consequentemente pretendo migrar para outro o Laravel. mas para não desperdiçar o tempo gasto e o conteúdo produzido que certamente ira ajudar alguém eu estou disponibilizando aqui e o exemplos no GitHub.


Se vocês gostaram desse Post não deixe de compartilhar com seus amigos!!!
E para não perder nenhuma novidade nos sigam nas redes sociais:
Twitter: @Bulfaitelo
Facebook: Bulfaitelo Project
Blogger: Bulfaitelo Project
Share on Google Plus

About Thiago Rodrigues

Formado em Sistema de Informação pela Faculdade Paraíso
O que falar de mim? Não á muito, mas garanto que meu objetivo aqui é somente ajudar!
Atualmente desenvolvendo o projeto do QiEstudo.

Comentários
0 Comentários

0 comentários:

Postar um comentário