Classes para Condições

Qual a dúvida ... ?

Pra que isso, senhor?

Agora eu vi de tudo mesmo... uma classe FOR --'...

Amigo, na boa, larga mão disso...

Certo .. você editou o conteúdo do seu post e eu nem vi .. agora .. qual a relevância disso ? objetivo .. ?

Isso aí pra mim está nesse sentido ..

<?php
class R {

 static public $repeated ;

 public function __call( $method , $args ) {
 self::$repeated += 1 ;
 printf( '%s.............: %d <br />' , $method , self::$repeated );
 return $this;
 }
}

$R = new R();

Saída:

repetir.............: 1
repetindo.............: 2
recursivo.............: 3
repetindoNovamente.............: 4
repetirNovamente.............: 5
irEmUmLugarSemDestino.............: 6
andarPraTras.............: 7
caminhar.............: 8
naoFazerNada.............: 9
vagabundar.............: 10
oi.............: 11
velox.............: 12
gvt.............: 13
ipad.............: 14

:P

>
Pra que isso, senhor?

Agora eu vi de tudo mesmo... uma classe FOR --'...

Amigo, na boa, larga mão disso...

Em primeiro lugar

Se não quer ajudar então não atrapalha <_<

Em segundo lugar, isso é apenas para ter uma base do que eu quero fazer...

Mas com isso eu posso criar templates implementando o código php em paginas html...

Bom, na verdade da par criar sem isso, mas eu quero implementar condições e loops no template, e até agora, é o unico jeito possivel.

E para quem não sabe, sim, é possivel fazer isso, isso faz com que o site fique mais rápido e mais ORGANIZADO na hora de de manutenções..

>
Se não quer ajudar então não atrapalha <_<

Hey !! .. ele não está atrapalhando .. faço das minhas palavra às dele .. se você explicar o que você quer fazer, teremos um curso .. se não, fica difícil imaginar algo inimaginável .. você disse quer quer ter uma 'base' .. como vamos te dar uma base se não temos nem o objetivo do que desejastes fazer ! ..

>
Hey !! .. ele não está atrapalhando .. faço das minhas palavra às dele .. se você explicar o que você quer fazer, teremos um curso .. se não, fica difícil imaginar algo inimaginável ..

Ook ^^

mas então, deu para entender onde eu quero chegar?

Ta legal, vou editar explicando melhor

Certo .. você quer fazer um getter ?

<?php
class Product {

 private $Product ;

 public function __construct(){
 $this->Product = new stdClass();
 $this->Product->titulo = 'Título' ;
 $this->Product->codigo = '0006' ;
 }

 public function repetir(){
 return $this->Product ;
 }

}

$Product = new Product();
echo $Product->repetir()->titulo ;

aa desculpas, nem li direito o seu post

Um amigo me passou um script aqui no msn para dar uma estudada

mas viria a ser mais sou menos assim:

Teria duas páginas que estariam "ligadas"

a pagina index.php e a página index.html

Na página index.php, ele definiria os valores e criaria "tags" html que chamariam o valor na página html, ou seja, seria mais ou menos assim

index.php

$Produto->trocar('teste', 'Este é apenas um teste');

e isso

index.html

<div>{teste}</div>

Resultaria nisso no navegador:

Este é apenas um teste

Eu não estava conseguindo colocar os loops, pois, caso eu fizesse isto:

index.php

while(produto = mysql_fetch_assoc($sqlQuery)){

$Produto = trocar('teste', 'Este é apenas um teste');
}

e isso:

index.html

{teste}

Seria inutil, pois o loop seria ignorado.

mas agora um amigo ja me passou um script para mim dar uma estudada...

Vlw a tds ^^

Aaa Andrey, teria como fazer um curso desse aqui no site?

Seria interessante, se não entendeu o que eu quero fazer, me adiciona no msn: marcelo.rafal@hotmail.com.br

que eu te explico direito...

Para mim, parece que você quer um sistema de templates.

Já viu o Smarty?

@braços e fique com Deus!

>
Para mim, parece que você quer um sistema de templates.

Já viu o Smarty?

@braços e fique com Deus!

^^

Exato

básicamente é isso^^

só que eu não estou conseguindo colocar as condições no template

e para isso eu preciso criar um método que faça essas repetições para mim poder passar para o template

Mas porque você não usa o Smarty ou outro parecido?

Qual a razão de você querer implementar o seu próprio?

Há alguma coisa nos existentes que faça você querer criar um outro?

@braços e fique com Deus!

A Smarty não trabalha desse jeito.

Em linhas gerais, ela pega o arquivo TPL que você criou e analisa-o sintaticamente em busca das tags "especiais" dela, caracterizadas por algum texto entre os delimitadores definidos (por padrão, as chaves).

Então ela procura por um parser associado à essa tag. Esse parser pode ser um modificador, um bloco ou uma função, todos sob o aspecto de plugin.

Se não encontrar, dispara um erro alertando o elemento não reconhecido. Se encontra, instancia a classe OU invoca a função, passando os argumentos obtidos na análise, se houverem.

Com isso, o plugin analisa os parâmetros, buscando pelos seus requeridos e trabalha com os opcionais, preparando o retorno.

A classe principal, por sua vez, vai compilando o template final (arquivo PHP) com aquilo que cada parser foi retornando.

Depois gera o cache (se definido) e ecoa o template compilado.

:huh:

Gostei da explicação :clap: :clap: :clap: :clap:

>
Em primeiro lugar

Se não quer ajudar então não atrapalha <_<

Estou exatamente te ajudando, lhe dizendo que o que deseja fazer não tem sentido algum.

se nao me engano, o smarty tem manual em portugues...

Hum, acho que não soube explicar o motivo pelo qual sugeri Smarty.

Trabalhei muito com este Template Engine na versão 2.

Não sei como está na versão 3.

Porém, o ponto é: no meu ver, o que ele está pedindo, é somente uma forma de poder "parametrizar" o que vai ser exibido/usado no template, como é feito com Smarty.

Pelo menos, os códigos que ele postou me mostram isso...

Pegando estes blocos que ele postou:

// arquivo "fonte"
$Prd = new Produtos();

$Prd->Listar()

$Prd->CreateRepeticao('repetir->Produtos');

while($row = $Prd->getProdutos()){

$Prd->repetir();

$Prd->EnterRepeticao()->trocar('titulo.Produto', $row->titulo->idioma());
$Prd->EnterRepeticao()->trocar('image.Produto', $row->getImagem());
$Prd->EnterRepeticao()->trocar('valor.Produto', $row->getValor());
$Prd->EnterRepeticao()->trocar('url.Produto', $row->getUrl());
}

// arquivo de template
<a href="{url.Produto}">
{repetir->Produtos}

<div id="Produtos">
<div id="ImagemProduto">{image.Produto}</div>
<div id="TituloProduto">{titulo.Produto}</div>
<div id="ValoProduto">{valor.Produto}</div>
</div>

Seria praticamente a mesma coisa com Smarty:

// index.php

<?php
$arr = array('red', 'green', 'blue');
$smarty->assign('myColors', $arr);
?>

// index.tpl
<ul>
{foreach $myColors as $color}
<li>{$color}</li>
{/foreach}
</ul>

Também poderia ser feito com matriz associativa, exemplo {$produto.nome}, {$produto.cor}, etc.

Sacou o que quis dizer? Pra mim, parece que ele está querendo trabalhar com MVC implementando seu próprio "Template Engine".

Não consigo encontrar um motivo pelo qual ele quer fazer um Template Engine sendo que existem outros (por isso perguntei em um post anterior se era mesmo um template engine que estava tentando fazer, para ver se o que eu tinha entendido era o que ele precisava, e no post seguinte, ele confirma que é um template engine que ele precisa).

>
Exato

básicamente é isso^^

só que eu não estou conseguindo colocar as condições no template

e para isso eu preciso criar um método que faça essas repetições para mim poder passar para o template

Caso seja performance, padronização, etc, seria legal ele explicar isso também. Se não, acho que o Smarty seria uma boa para ele, pois ela já possui um padrão de desenvolvimento (entenda-se marcação de template, tags especializadas) e vários métodos auxiliares para trabalhar com este tipo de operação. Em resumo, "não precisaria reinventar a roda" :).

@braços e fique com Deus!

>
Estou ... lhe dizendo que o que deseja fazer não tem sentido algum.

Bom,

Não vou perder meu tempo dizendo novamente que isso não tem sentido algum, pois já foi dito diversas vezes neste tópico. (opz, acabei de dizer ¬¬)

>
Se não, acho que o Smarty seria uma boa para ele, pois ela já possui um padrão de desenvolvimento (entenda-se marcação de template, tags especializadas) e vários métodos auxiliares para trabalhar com este tipo de operação. Em resumo, "não precisaria reinventar a roda".

Como o @hufersil disse bem, não é preciso reinventar a roda. Mas também é verdade que conhecer o funcionamento da roda é bem divertido.

O ponto é que a base de um motor de templates é um analisador de expressões. Não é possível construir um sistema de templates sem conhecer o funcionamento de um analisador de expressões.

A análise de expressões, sozinha, é um tema extenso, complexo e (ponto de vista pessoal) muito interessante. Junto à análise de expressões, existe a representação da estrutura léxica e suas ramificações, que também não é nada simples.

Mesmo que você desenvolva um novo sistema de templates, você estará muito aquém de um sistema como Smarty que já possui uma comunidade ativa e todo um know how.

Vou tentar ilustrar aqui um analisador simples, utilizando um analisador sintático descendente recursivo para a criação da árvore sintática abstrata e um design pattern chamado Interpreter para representar essa árvore.

Interpreter Design Pattern:

O Interpreter design pattern pode ser adequadamente utilizado nesse exemplo pois, independentemente da estrutura léxica escolhida, a gramática do sistema de templates será simples e as expressões podem ser expressadas como nós (compostos ou não) de uma árvore abstrata.

A estrutura do Interpreter é bem simples:

/applications/core/interface/imageproxy/imageproxy.php?img=http://forum.imasters.com.br/uploads//1314458547/gallery_94216_25_420.png&key=3b0c5d9835a600958854398c95f2ed5eab36f9fee47e07bb720cf26bf25a073c" alt="gallery_94216_25_420.png">

Um ponto importante a se notar no Interpreter Design Pattern é que desempenho não deve ser um ponto crítico. As expressões não serão interpretadas diretamente, elas serão analisadas, traduzidas para um conjunto de objetos e, então, interpretadas.

Os participantes do Interpreter são:

AbstractExpression:

AbstractExpression declara a interface comum para todos os nós da árvore abstrata. O Client usa essa interface para iniciar a interpretação sem precisar conhecer um nó específico.

TerminalExpression:

Um TerminalExpression é um nó final, uma expressão literal, símbolo, etc...

NonterminalExpression:

Um NonterminalExpression é, obviamente, o oposto de um TerminalExpression. Condicionais, loops, alternativas, operações matemáticas, etc...

Context:

O Context é onde as informações estão armazenadas. O interpretador pode ter um Context global, onde informações que são compartilhadas por toda a árvore são armazenadas e, em alguns casos, um Context local, onde funções podem ter seu próprio Context.

Client:

O Client é o cara que pucha o gatilho, mas é também o cara que monta toda a árvore (algumas vezes ele a recebe pronta também).

No caso do sistema de templatas, carinhosamente chamado de brazuca, o Interpreter se parecerá com o seguinte:

/applications/core/interface/imageproxy/imageproxy.php?img=http://forum.imasters.com.br/uploads//1314458547/gallery_94216_5_18036.png&key=1152eb5790614399047410a8884cca50e19ec6f17ebc7716b0659e437d095f4d" alt="gallery_94216_5_18036.png">

Como podemos ver, mesmo simples, é bastante complexo. Essa complexabilidade tende a crescer conforme operações vão sendo agregadas à árvore. Se for muito comum a adição de novos participantes, então pode ser mais interessante utilizar um outro padrão chamado Visitor, também comportamental.

Análise de Expressões:

O Interpreter sozinho não é nada, se não soubermos como utilizá-lo.

O trabalho de um analisador sintático é, na forma de um algorítimo, reconhecer uma entrada representada por um conjunto de caracteres (código) e transformá-la em um conjunto de símbolos (tokens) que podem ser manipulados.

Existem várias formas de se implementar um analisador mas, por mera questão de escolha, vou ilustrar um analisador LL, top-down, descendente recursivo.

A expressão abaixo:

1 + 2

O analisador pegará o primeiro token:

:seta: 1

Esse token é terminal, seu valor é simplesmente 1. O analisador removerá o token da fila e o colocará na pilha de valores para, então, verificar a existência de um próximo token.

:seta: +

O sinal + nesse caso é um operador binário, ou seja, ele requer que o lado esquerdo seja somado com o resultado do lado direito. Precisamos pegar o próximo token.

:seta: 2

Novamente outro token terminal, o analisador pegará o valor que está na pilha, aplicará a regra adequada ao operador + e teremos o resultado.

Um analisador LL fará esse processo, repetidamente, até que a expressão chegue ao fim, ou caso algum erro seja encontrado.

O legal do Interpreter é que conseguimos essa mesma estrutura:

<?php
abstract class AbstractExpression {

public abstract function parse();
}

class NumericExpression extends AbstractExpression {

private $number;

public function __construct( $number ) {
	$this->number = $number;
}

public function parse() {
	return $this->number;
}
}

class SumExpression extends AbstractExpression {

private $lside;
private $rside;

public function __construct( $lside , $rside ) {
	$this->lside = $lside;
	$this->rside = $rside;
}

public function parse() {
	return $this->lside->parse() + $this->rside->parse();
}
}

A mesma expressão:

<?php
$um = new NumericExpression( 1 ); //TerminalExpression
$dois = new NumericExpression( 2 ); //TerminalExpression

$soma = new SumExpression( $um , $dois ); // //NonterminalExpression

echo $soma->parse();

Saída:

>
3

Porém, o sistema de templates possui mais do que apenas uma soma, existirão atribuições, repetições e outras estruturas mais complexas, por exemplo:

a = 2
b = 0

enquanto a > 0 {
b = b + 1
a = a - 1
}

mostra b

Nesse caso, o interpretador fará todo aquele processo:

1. a = 2

1.1. a é um identificador, pega o próximo token

1.2. = é um sinal de atribuição, pega o próximo token

1.2. 10 é um token terminal, atribui-se 2 ao identificador a

2. b = 0

2.1. b é um identificador, pega o próximo token

2.2. = é um sinal de atribuição, pega o próximo token

2.3. 0 é um token terminal, atribui-se 0 ao identificador b

3. enquanto a > 0 { ... }

3.1. enquanto é uma palavra-chave para repetição de bloco, pega o próximo token

3.2. a é um identificador, pegamos o valor dele: 2

3.3. > é um operador de comparação, pega o próximo token

3.4. 0 é um token terminal, verifica se 2 é maior que 0

Como 2 é maior que 0, entra no bloco de repetição.

3.4.1. b = b + 1

3.4.1.1. b é um identificador, pega o próximo token

3.4.1.2. = é um sinal de atribuição, pega o próximo token

3.4.1.3. b é um identificador, pega o valor dele: 0

3.4.1.4. + é um operador de soma, pega o próximo token

3.4.1.5. 1 é um token terminal, soma 0 com 1.

3.4.1.6. atribui-se o valor 1 ao identificador b.

3.4.2. a = a - 1

3.4.2.1. a é um identificador, pega o próximo token

3.4.2.2. = é um sinal de atribuição, pega o próximo token

3.4.2.3. a é um identificador, pega o valor dele: 2

3.4.2.4. - é um operador de subtração, pega o próximo token

3.4.2.5. 1 é um token terminal, subtrai 1 de 2.

3.4.2.6. atribui-se o valor 1 ao identificador a.

3.4.3. Volta ao item 3.2 (lembrando que o valor do identificador a agora é diferente).

3.5. Como o valor do identificador a não é maior que 0, pula o bloco de repetição.

3.6. mostra b

3.6.1. mostra é uma palavra-chave para exibir um conteúdo, pega o próximo token.

3.6.2. b é um identificador, pega o valor dele: 2

3.6.3. joga 2 na saída.

3.7. Como não existe mais nada para analisar, terminamos o trabalho.

Um Interpreter para essa situação ficaria assim:

<?php
/**
* contexto do interpretador
*/
class Context {

private $data = array();

public function get( $identifier ) {
	if ( isset( $this->data[ $identifier ] ) ) {
 return $this->data[ $identifier ];
	} else {
 throw new Exception( 'Identificador não definido.' );
	}
}

public function set( $identifier , $value ) {
	$this->data[ $identifier ] = $value;
}
}

/**
* representação de um nó da árvore
*/
abstract class AbstractExpression {

public abstract function parse( Context $context );
}

/**
* número
*/
class NumericExpression extends AbstractExpression {

private $number;

public function __construct( $number ) {
	$this->number = $number;
}

public function parse( Context $context ) {
	return $this->number;
}
}

/**
* operação binária (lado esquerdo OPERADOR lado direito)
*/
abstract class BinaryExpression extends AbstractExpression {

protected $lside;
protected $rside;

public function __construct( $lside , $rside ) {
	$this->lside = $lside;
	$this->rside = $rside;
}
}

/**
* operação de soma +
*/
class SumExpression extends BinaryExpression {

public function parse( Context $context ) {
	return $this->lside->parse( $context ) + $this->rside->parse( $context );
}
}

/**
* operação de subtração -
*/
class DifferenceExpression extends BinaryExpression {

public function parse( Context $context ) {
	return $this->lside->parse( $context ) - $this->rside->parse( $context );
}
}

/**
* identificador
*/
class IdentifierExpression extends AbstractExpression {

private $name;

public function __construct( $name ) {
	$this->name = $name;
}

public function getName() {
	return $this->name;
}

public function parse( Context $context ) {
	return $context->get( $this->name );
}
}

/**
* operação de atribuição =
*/
class AssignmentExpression extends BinaryExpression {

public function __construct( IdentifierExpression $lside , AbstractExpression $rside ) {
	parent::__construct( $lside , $rside );
}

public function parse( Context $context ) {
	$context->set( $this->lside->getName() , $this->rside->parse( $context ) );
}
}

/**
* bloco com 1 ou mais linhas de código
*/
class CodeExpression extends AbstractExpression {

protected $lines = array();

public function addLine( AbstractExpression $abstractExpression ) {
	$this->lines[] = $abstractExpression;
}

public function parse( Context $context ) {
	foreach ( $this->lines as $line ) {
 $line->parse( $context );
	}
}
}

/**
* repetição de bloco
*/
class WhileExpression extends AbstractExpression {

private $condition;
private $block;

public function __construct( AbstractExpression $condition , CodeExpression $blockExpression ) {
	$this->condition = $condition;
	$this->block = $blockExpression;
}

public function parse( Context $context ) {
	while ( $this->condition->parse( $context ) ) {
 $this->block->parse( $context );
	}
}
}

/**
* Operação >
*/
class GTExpression extends BinaryExpression {

public function parse( Context $context ) {
	return $this->lside->parse( $context ) > $this->rside->parse( $context );
}
}

/**
* mostra conteúdo
*/
class PrintExpression extends AbstractExpression {

private $expression;

public function __construct( AbstractExpression $abstractExpression ) {
	$this->expression = $abstractExpression;
}

public function parse( Context $context ) {
	print $this->expression->parse( $context );
}
}

Usando:

<?php
//Código que será interpretado
$code = new CodeExpression();

//a = 2

$a = new IdentifierExpression( 'a' );
$aAssign = new AssignmentExpression( $a , new NumericExpression( 2 ) );
$code->addLine( $aAssign );

//b = 0

$b = new IdentifierExpression( 'b' );
$bAssign = new AssignmentExpression( $b , new NumericExpression( 0 ) );
$code->addLine( $bAssign );

//bloco while
$whileBlock = new CodeExpression();

//b = b + 1
$whileBlock->addLine(

new AssignmentExpression( $b , new SumExpression( $b , new NumericExpression( 1 ) ) )
);

//a = a - 1
$whileBlock->addLine(

new AssignmentExpression( $a , new DifferenceExpression( $a , new NumericExpression( 1 ) ) )
);

//while a > 0

$while = new WhileExpression( new GTExpression( $a , new NumericExpression( 0 ) ) , $whileBlock );
$code->addLine( $while );

//print b

$code->addLine( new PrintExpression( $b ) );
$code->parse( new Context() ); //interpreta o código

Saída:

>
2

Não vou escrever o código completo do analisador recursivo porque acho que, se você for usar isso em um ambiente de produção, você precisará estudar muito a estrutura léxica que deseja analisar e, somente então, escrever o analisador.

Mas a ilustração acima serve como ponto de partida para os estudos e, quem sabe, para a criação de um novo motor de templates. Um ponto muito interessante desse tipo de implementação é que o PHP possui uma interface Serializable. Com ela podemos "compilar" todo o template e armazená-lo compilado, eliminando uma nova interpretação, o código usado no último exemplo, depois de compilado, ficaria assim:

$code = unserialize( 'C:14:"CodeExpression":936:{a:4:{i:0;C:20:"AssignmentExpression":87:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"a";}i:1;C:17:"NumericExpression":4:{i:2;}}}i:1;C:20:"AssignmentExpression":87:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"b";}i:1;C:17:"NumericExpression":4:{i:0;}}}i:2;C:15:"WhileExpression":577:{a:2:{i:0;C:12:"GTExpression":87:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"a";}i:1;C:17:"NumericExpression":4:{i:0;}}}i:1;C:14:"CodeExpression":423:{a:2:{i:0;C:20:"AssignmentExpression":167:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"b";}i:1;C:13:"SumExpression":87:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"b";}i:1;C:17:"NumericExpression":4:{i:1;}}}}}i:1;C:20:"AssignmentExpression":174:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"a";}i:1;C:20:"DifferenceExpression":87:{a:2:{i:0;C:20:"IdentifierExpression":8:{s:1:"a";}i:1;C:17:"NumericExpression":4:{i:1;}}}}}}}}}i:3;C:15:"PrintExpression":40:{C:20:"IdentifierExpression":8:{s:1:"b";}}}}' );

echo $code->parse( new Context() );

Saída:

>
2

:D

Mas também é verdade que conhecer o funcionamento da roda é bem divertido

Exatamente isto :)

Ao invés de tentar fazer um do zero, no caso dele, acho que compensaria mais utilizar o Smarty e estudar como ele funciona.

Assim, ele aprende mais, a partir de uma biblioteca madura e não reinventa a roda :D

A propósito, muita legal sua explicação ;)

@braços e fique com Deus!

>
Ao invés de tentar fazer um do zero, no caso dele, acho que compensaria mais utilizar o Smarty e estudar como ele funciona.

Assim, ele aprende mais, a partir de uma biblioteca madura e não reinventa a roda

Verdade, principalmente por ter uma comunidade já ativa de desenvolvedores. Quanto maior a comunidade, maior o número de fóruns, grupos, documentações.

:seta: É muito mais produtivo partir por essa linha (usar Smarty).

>
A propósito, muita legal sua explicação

tkz, foi "meia explicação" na verdade. Não teria espaço suficiente para uma explicação completa e, mesmo que tivesse, acredito que ficaria tão complexo que nem eu leria tudo depois de escrever.

hehehhe :P

Muito bom o post #18 do nosso colega JBN.

Na faculdade estou tendo uma matéria chamada Linguagens Formais e Autômatos, que serve exatamente de base para a construção de linguagens e interpretadores, e futuramente, em outra matéria, compiladores.

Vendo esse exemplo 'simples', podemos ter a idéia da complexidade envolvendo a criação de um sistema interpretado de templates. Em exercícios na sala de aula, costumamos brincar com linguagens simples, cujo alfabeto é composto normalmente por 'a' e 'b', isso mesmo: 2 símbolos terminais, umas 2 ou 3 regras de produção, e muitas vezes construir um autômato para interpretar uma linguagem assim não é tão trivial quanto parece.

Tendo em mente que construir um autômato é muito mais simples que programar um interpretador, imagine a complexidade do interpretador de um sistema de templates funcional, vou além, imagine os interpretadores de linguagens como PHP, Javascript ou LISP.

Por isso que 'reinventar a roda' neste caso é deveras complicado. Gostaria de ter mais tempo para estudar isso mais a fundo e quem sabe brincar com algumas coisinhas, mas jamais tentaria utilizar um interpretador criado por mim para fins mais 'sérios'.

o.O

:o

PARABÉÉÉÉNNSSS CARA :joia: :clap:

Gostei da explicação (post #18)...

Bom, agora só me resta estudar isso ^^

bom, ainda tenho 15 anos, até os 40 eu consigo aprender isso uahshusahuashuahsu

vlw

Dedicação e vontade e interesse, te garanto que em 2 meses você aprende tudo que foi feito.

:lol: