<?php
$sql = 'INSERT INTO `artigos` (`id`, `titulo`, `corpo`) 
VALUES (NULL, \'php 6\', \'PHP 6 promote grandes novidades \'),

1. GtkMenuBar
2. GtkMenu
3. GtkMenuItem

a programação de aplicativos Web usando o PHP terá mais sucesso do que teve o Java

1. É uma camada de abstracção rápida e simples de utilizar
2. suporte à portabilidade
3. fácil de aprender a nível de programação
4. tecnologia madura e robusta , com uma enorme comunidade de utilizadores
5. é uma tecnologia livre de usar e compilar


Posta a apresentação, vamos passar à prática.
Mas antes , entenda-se porque é importante usar uma camada de abstracção. Imaginemos que escrevemos a nossa aplicação e que a gestão de dados por entre milhares de linhas de código que utilizámos foi o ODBC, em Windows. Agora, passado uns tempos, alguém que usa um sistema UNIX , deseja utilizar a aplicação, mas o sistema operativo não lhe dá suporte ao ODBC e deseja utilizar MySQL, seja qual for a razão. Pois é, o problema está identificado! Agora é necessário no meio de milhares de linhas de código alterar tudo , de forma a usar-se apenas MySQL. Eis o principal factor porque se deve utilizar uma camada de abstracção em aplicações consideráveis.
Vamos então começar por fazer o download em ADOdb onde poderá ler mais informação sobre este assunto.
No download tenha atenção à versão do PHP que utiliza, pois são disponibilizadas versões para PHP5 ou ambas (PHP4 e PHP5).
A distribuição é bastante pequena (cerca de 600Kb). Após fazer o download, descompacte (na pasta adodb5 por exemplo) do seu servidor local, de forma a podermos fazer os testes que vou apresentar ao longo deste artigo.
Agora sempre que quisermos utilizar a camada de abstracção utilizaremos o seguinte código php.

<?php
//inclusão da camada de abstracção

require_once("adodb5/adodb.inc.php");
//credenciais ao servidor
$host   = "localhost";
$user   = "root";
$pass   = "";
$table  = "membros";
$db     = "revistaphp_net";
$conn   = "mysql";  // driver de dados selecionado

$DBmySQL =& NewADOConnection($conn);
$DBmySQL->Connect($host,$user,$pass,$db);
$DBmySQL->debug=true;//activa do debug 

// vammos criar uma tabela temporaria
$sqlT = "CREATE TEMPORARY TABLE `$table` (
                `id` int(10) unsigned NOT NULL auto_increment,
                `nome` varchar(100) NOT NULL default '',
                `email` varchar(100) NOT NULL default '',
                 PRIMARY KEY  (`id`)) ENGINE=MyISAM;";
    
$DBmySQL->Execute($sqlT);             
                 


  //agora é fácil entender a seguinte claúsla de inserção dos dados
$sql = "INSERT INTO {$table} (nome, email) VALUES('Revista PHP', 'revistaphp@gmail.com')";
        $DBmySQL->Execute($sql);
    

//executa a claúsula SQL
$rs1     = $DBmySQL->Execute("SELECT * FROM {$table}");
  
  if(!$rs1){  //obtém eventuais erros
    $DBmySQL->ErrorMsg();
    exit;
   }
   
       //obtendo os resultados
      $Thtml  = "<table bgcolor=\"#999999\" border=\"1\">\n";
      while (!$rs1->EOF) {
      
      $Thtml .="<tr>\n"; 
      $Thtml .="<td> Nome: </td><td>" .$rs1->fields[1]."</td>\n";
      $Thtml .= "</tr>\n<tr>\n";
      $Thtml .="<td> Email: </td><td>".$rs1->fields[2]."</td>\n";
      $Thtml .= "</tr>\n";
      //obtém a próxima linha
      $rs1-> MoveNext(); 
      }
      
      $Thtml .="</table>\n";
       echo  $Thtml; 

?>

]]> http://www.revista-php.net/artigos.php?pagina=33 aquí , e logo no momento dos testes fiquei convencido, embora já tivesse estudado um processo similar ,no site da IBM , com queries em dados XML.

No LINQ , a sintaxe utilizada nas consultas (queries) , é muito parecida ao SQL. E ao que parece a afirmação de Maarten é mesmo verdade “se começarmos a usar esta forma de aceder aos dados, não vamos querer mudar mais” - o que na minha opinião é perigoso e já vão saber porquê. Baseado nos exemplos que este autor apresenta decidi criar alguns scripts por minha autoria e fazer os meus testes. O conceito é muito simples.
Primeiro vamos criar listas onde a informação é armazenada. No primeiro exemplo vamos usar uma lista simples.

<?php 

// algumas cidades portuguesas 
$cidades = array("Guarda","Viseu", 
                 "Covilhã","Castelo Branco", 
                 "Meda","Braga"); 

/************************************************* 
 Imagine-se que desejamos obter a cidades cujo  
 tamaho de caracteres e inferior ou igual  a 4 
 Rapidamente identificamos que é Meda 
 Em PHP stardard teriamos 
 *************************************************/ 
foreach($cidades as $cidade){ 
        if(strlen($cidade)<=4){ 
           echo $cidade."<br />"; 
           } 
        } 
         
/**************************************************** 
 Imaginemos agora que desejamos verificar se existe um  
 elemento repetido no array (a olho vemos que não) , 
 mas em listas carregadas de forma dinâmica no sistema  
 esse conceito de visualização não se aplica), então 
 vamos adicinar um elemento já existente 
 *****************************************************/ 

 array_push($cidades,"Guarda"); 

foreach ($cidades as $cidade){ 
  if($cidade=="Guarda"){ 
   $search[] = $cidade; 
   } 
} 

echo "Existem " .sizeof($search). 
" cidades com o mesmo nome no array"; 


/***************************************** 
 ... se quisesse obter as cidades de forma 
  distinta (sem repetição) 
         
 ******************************************/ 
 echo "<pre>"; 
 print_r(array_unique($cidades)); 
 echo "<pre />"; 

/******************************************* 
 Toda esta forma de lidar com arrays podia  
 dar lugar a uma nova função 
*******************************************/ 

 function OperaArray($arr,$str=NULL,$op){  

   switch($op){ 
   case 'unico': 
   return array_unique($arr); 
   break; 
   case 'rep': 
    
    foreach ($arr as $s){ 
           if($s==$str){ 
            $narr[] = $s; 
            } 
      } 
    return $narr;  
    break; 
    case 'eval': 
     foreach($arr as $s){ 
           if(strlen($s) <= $str){ 
           echo $s."<br />"; 
          } 
        } 
    break; 
    default: 
    return false; 
   } 
 } 
 // exemplo de uso 
print_r( OperaArray($cidades,'','unico')); 


?> 


Posto isto vamos utilizar alguns exemplos no LINQ no PHP , usando um array unidimensional

<?php 
/******************************************* 
 Onidesk Labs ::LINQ 4 PHP tests 
 ******************************************/ 

require("PHPLinq.php"); 
$cidades = array(); 
$cidades[] = "Guarda"; 
$cidades[] = "Meda"; 
$cidades[] = "Castelo Branco"; 
$cidades[] = "Viseu"; 



$result = from('$cidade')->in($cidades) 
            ->where('$cidade => substr($cidade,0,1)=="M"') 
            ->select('$cidade');  

             
        #print_r($result); 
             
             
/********************************************** 
O mesmo objectivo com  foreach no PHP  
 *********************************************/ 
 foreach($cidades as $cidade){ 
    if(substr($cidade,-6,1)=="M"){ 
      echo $cidade."<br />"; 
      } 
    } 
             
             
     

?> 


Resultado Array ( [0] => Meda )



O PHPLinq, permite facilmente aceder a objectos instanciados e armazenados num array.

<?php
 require("PHPLinq.php");

 $Cidades = array( 
 new Cidade('Guarda','44 264', '38.694085', '-9.162598', 'Portugal'),
 new Cidade('Meda', '6 239', '40.950863', '-7.261963', 'Portugal'),
 new Cidade ('Castelo Branco','54 574','39.829632','-7.531128','Portugal'),
 new Cidade ('Viseu','98 167','40.653555','-7.921143','Portugal'));
    
                   
    $cidade = "";               
 $result = from('$cidade')->in($Cidades)
    ->where('$cidade => substr($cidade->cidade,0,1) == "G"')
    ->orderBy('$cidade => $cidade->cidade')
    ->thenByDescending('$cidade => $cidade->cidade')
      ->select('$cidade');

    
 //imprimindo os resultados
            echo "<pre>";
            print_r($result);
            echo "</pre>";
                                     

?>

Resultado


Array
(
    [0] => Cidade Object
        (
            [cidade] => Guarda
            [habitantes] => 44 264
            [latitude] => 38.694085
            [longitude] => -9.162598
            [pais] => Portugal
        )

)





Novas funcionalidades

Segundo o autor, na próxima versão do PHPlinq (ainda não lançada), esta contará com a funcionalidade de JOIN.
Segue-se um exemplo , enviado gentilmente pelo autor , propositadamente para este artigo.No exemplo que segue demonstra-se com combinar empregados ($employee) com departamentos ($departments)

<?php
$result = from('$cidade')->in($cidades)
            ->where('$cidade => substr($cidade,-6,1)=="M"')
            ->select('$cidade'); 
            
            print_r($result);
            
            $result = from('$employee')->in($employees)
   ->join('$department')->in($departments)
   ->on('$employee, $department => $employee->DepartmentId == $department->Id')
   ->join('$manager')
   ->in($employees)
   ->on('$employee, $manager => $employee->ManagerId > 0 
   && $employee->ManagerId == $manager->Id')
   ->select('$employee = null, $department = null, $manager = null => new {
       "Name" => $employee->Name,
       "Email" => $employee->Email,
       "Department" => $department,
       "Manager" => $manager
       }');
?>
                    

Observações finais
É certo que o LINQ é extremamente útil e facilita muito o tratamento de dados. Em arrays simples, não fará muito sentido, pois para isso temos as funções nativas do PHP. Em arrays multidimensionais pode constituir uma tarefa interessante, assim como no acesso a Base de Dados como MySQL ou outras Sem querer parecer céptico, penso que este não deve ser trocado pelas cláusulas disponíveis a partir do SQL que conhecemos, embora a facilidade que transparece na utilização do LINQ no PHP, o torne a apetecível. Não só porque é uma tecnologia mais explorada e fiável, para a qual já existe orientada toda uma plataforma de desenvolvimento, mas também porque está acessível a partir de quase todas as linguagens. Além disso como o autor do LINQ para PHP reconhece, o LINQ pode torna-se viciante, e menosprezar a forma correcta (na minha maneira de ver), forma de acessar aos dados. Veja-se que obter os dados dum arrays desta forma exigirá muito mais do sistema, que sim simples foreach nativo. ]]> http://www.revista-php.net/artigos.php?pagina=34 No PHP é possível manipular esses standards, de forma a trocar informações entre as aplicações para que estas se entendam (protocolo), num formato que tem se ser reconhecido por ambas.
Isto verifica-se sempre mesmo que as aplicações tenham sido desenvolvidas em sistemas díspares, como por exemplo Unix e Windows.
De forma muito simplista um Web Service e pode ser visto como página Web (que integra o protocolo HTTP), acessível para qualquer lugar da Internet.
Recebe a informação no formato XML, “interpreta” o pedido solicitado e responde utilizando o mesmo standard de resposta (XML)
Os Web Services , não se intimidam pelo uso de firewalls ou servidores proxy, pois , funcionam mesmo na presença destes.
Como são independentes da plataforma de desenvolvimento, passaram a constituir a forma generalizada das aplicações de comunicarem, cuja interacção não depende de intervenção humana.
Estas características fazem com a integração das aplicações seja muito menos dispendiosa. De forma sintética um Web Service caracteriza-se:
1. fornecer serviços mediante a Internet utilizando o protocolo HTTP
2. o formato usado na descrição é o WSDL
- acedem ao servidor utilizando mensagens SOAP
3. a veiculação da informação usa XML
- o servidor é o repositório onde constam os dados
4. o cliente é visto como a funcionalidade que interroga o servidor
5. A segmentação cliente – servidor complementa o serviço, no utilizador apenas interage com o cliente, visualizando os dados, já formatados.

Pese o facto de o PHP já contar com Web Services de forma nativa a partir da versão PHP5, este artigo não tenciona apresentar essa vertente.
Para desenvolvimento de Web Services PHP,temos à disposição uma distribuição muito conhecida, o NuSOAP , cuja primeira versão foi lançada em Maio de 2004.
À data que escrevia este artigo o NuSOAP conta com a 0.7.1, datada de Julho 2007.

O NuSOAP conta apenas num conjunto de classes escritas em PHP e não tem qualquer dependência das extensões do PHP. Para fazer o download desta funcionalidade aceda aquí
Além da distribuição que contém o NuSoap poderá fazer o download da documentação, que contém a hierarquia das classes, métodos e atributos e respectiva escolaridade. Após fazer o download do NuSOAP , descomprima para o seu directório, e por uma questão de organização organize o seu directório na seguinte estrutura
www\NuSOAP
       /lib
       /samples
A pasta lib , contém o módulo NuSOAP entre outras funcionalidade, e a pasta sample contém alguns exemplos que deve estudar de forma a aprender como utilizar e criar Web Services à posteriori.
Agora que temos os requisitos necessários vamos criar exemplo dum Web Service básico. Isso implica que tenhamos de criar duas aplicações, uma a funcionar como cliente e a outra como servidor.

<?php
/************************************************
 Autor : José Franco
 Data  : 24 Abril 2008
 Distro: NuSOAP Case Study : servidor.php 
 ************************************************/

// carrega o módulo NuSOAP a partir da sua localização
require_once($_SERVER['DOCUMENT_ROOT']."./NuSoap/lib/nusoap.php");
//instância um objecto tipo servidor
$Servidor = new soap_server;
// regista a função de define o serviço
$Servidor->register('MembroValido');


/* função que generaliza o serviço
   Esta função tem como parâmetro uma string 
   que é o nome do membro que deseja aceder 
   ao serviço. Se o nome constar no vector de membros
   (simula a Base de Dados), o serviço é efectuado
   com sucesso. Doutra forma ocorre um erro especifico
   enviado ao cleinte

*/
function MembroValido($nome){
$membros = array("Guto123","Pedro777","Berto003");
$rs = array_search($nome,$membros);
    
if($nome==""){
    return new soap_fault('Erro no cliente','','Indique o nome do membro');
    }
if(is_integer($rs) AND $membros[$rs]==$nome){
    return $membros[$rs];
}if(!is_integer($rs)){
return new soap_fault('Erro no cliente','', 'O membro informado não existe');
}    
   else{
   return new soap_fault('Erro fatal no cliente','', 'Erro desconhecido');
   }
}

// processa a informação e invoca a função 
$Servidor->service($HTTP_RAW_POST_DATA);
?>


Agora vamos criar o ficheiro que funcionará como cliente, programado as funcionalidades necessárias. Neste exemplo de modo a facilitar a abordagem , criei a interface HTML , juntamente integrada no ficheiro que contém o Web Service do lado do cliente.

<?php
/************************************************
 Autor : José Franco
 Data  : 24 Abril 2008
 Distro: NuSOAP Case Study : cliente.php 
 ************************************************/

// permite visdualizar erros ocorridos
error_reporting(E_ALL);

// carrega o módulo NuSOAP a partir da sua localização
require_once($_SERVER['DOCUMENT_ROOT']."./NuSoap/lib/nusoap.php");

// ao requisitar o serviço
if(isset($_POST["enviar"])){

// obtém o nome enviado pelo formulário
$nome = $_REQUEST["nome"];

// define a localização do servidor
$Service = "http://localhost/servidor.php";


// parametros a enviar ao servidor
$parametros = array('nome' => $nome);
// instancia ao objecto do tipo Cliente
$Cliente =& new soapclient($Service);
// activa uma ligação persitente ao servidor
$Cliente->useHTTPPersistentConnection();
// faz a requisção do serviço , identificado
// pela função de chamada e respectivos parâmetros
$rs =  $Cliente->call('MembroValido',$parametros);
     
  // ao ocrrer erro
  if($erro = $Cliente->getError()){
  #print_r($Cliente->request); 
  // obtém a resposta enviada
   echo "<erro> <strong><font color=\"red\">$erro</font></strong><br>";
   echo "<xmp>".$Cliente->response."</xmp>";
   }else{
   // ok .. resultado do serviço
   echo "Benvindo ao sistema <strong>".$rs."</strong>";
   }
// impede que o formulário seja visualizado
exit();
}

?>


<?PHP
 # Template de interação com o utilizador
?>
<html>
<head>
<title>Revista PHP :: NuSoap case study</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>

<body>
<?php 
# PHP_SELF aponta para a página actual após clicar no botão
?>
<form action="<?php $_SERVER['PHP_SELF']?>" method="post">
<label for="nome">Indique o nome de utilizador</label><br>
<input type="text" name="nome" size="40"><br>
<input type="submit" name="enviar" value="Login">
</form>
</body>
</html>


Resultado em caso de erro



Sucesso no Web Service

Benvindo ao sistema Guto123]]> http://www.revista-php.net/artigos.php?pagina=35 Mas antes de passarmos a essa parte vamos a uma breve apresentação.
A PRADO é uma aplicação baseada em componentes e eventos (vulgarmente conhecida por Framework), para criar aplicativos Web a funcionar na plataforma PHP5, de forma a facilitar o processo de criação , aumentando a performance das aplicações recorrendo a técnicas de estrutura de dados avançadas.
O objectivo desta Framework é a utilizar a programação orientada a objectos, assentando no RAD (Rapid Application Development), e no princípio MVC (modelagem, visão e controlo), numa arquitectura de camadas.
Propõe-se a melhorar o desempenho das aplicações Web, nomeadamente em processos complexos, como no acesso a Base de Dados, operações sob ficheiros, e limitações impostas pela largura de banda. Para aumentar este desempenho, a PRADO utiliza uma técnica comum neste tipo de Frameworks, que é o processo de caching , que guarda os templates e os reutiliza, caso estes sejam invocados em fases posteriores. Este processo é permitido pela activação do TTemplateManager, que permite além De outras funcionalidades, permitir carregar a página uma única vez.
Uma das pretensões do criador da PRADO (Qiang Xue), é aproximar a criação de aplicações Web, aproximando o seu desenvolvimento do ASP.NET.
Apesar da Framework ter sido criado com tecnologias e ferramentas pagas, como é o caso do Borland Delphi e ASP.NET, esta é distribuída de forma gratuita (sob licença BSD), em código aberto, numa distribuição com cerca de 17 Mb, que pode baixar aquí
À data em que escrevia este artigo a PRADO está na versão v3.1.2 e conta entre muitas outras as seguintes funcionalidades
Permite usar praticamente todo os conjunto de
Base de Dados
Web Services
Transformações com XML
Ajax
Data Controls (TPanel, TDataGrid, TDataList …)
Componentes para gestão de template (Form, Button, Form, Validation ...)
Gestão automatizada de erros no código

Um dos requisitos necessários é possuir a extensão SimpleXML, que vem de forma nativa juntamente com o PHP5.
Após fazer o download, descomprima o conteúdo na raiz do seu servidor (www no caso do EasyPHP ou htdocs no caso do Apache)
No meu caso optei por criar uma nova pasta “PRADO”, e descomprimi para lá toda a estrutura de directórios:


Este processo de instalação pode ser feito a partir da linha de comandos, por exemplo:
caminho/para/prado-cli.php –c olamundo no directório onde deseja criar o projecto olamundo.
O módulo PRADO (o chamado PRADO core), necessário a ser carregado “prado.php”, encontra-se na pasta Framework. Na pasta demos, existem alguns exemplos que convém editar e estudar.

Surgem na PRADO dois novos conceitos para quem nunca trabalhou com Frameworks, as extensões *.spec e *.tpl O ficheiro com a extensão *.spec define as especificações da aplicação e o ficheiro com a extensão *.tpl (ou ainda *.page) contém o template (parte visual) da aplicação. Nas aplicações criadas com PRADO, é obrigatório criar um ficheiro que conterá as especificações da aplicação, que conterá mencionado o caminho para o ficheiro da aplicação.

Isto pode parecer novo para quem programa apenas com PHP, mas quem desenvolve em ASP.NET, ser-lhe-á muito familiar.
Junto com a distribuição existe uma pasta chamada demos e dentro dessa uma pasta helloworld, comece por analisar estrutura dessa aplicação. Nos projectos que acompanham a distribuição reparará que é comum encontrar algumas pastas com o mesmo nome:
assets – directório onde são guardadas os ficheiros privados para publicação. Este directório deve estar em modo de escrita para processos no servidor.
protected – caminho por defeito onde é guardada a informação da aplicação. Este directório deve ser configurado de modo a ficar inacessível aos utilizadores finais
runtime – pasta onde são guardados os dados de estado da aplicação, como estado, informação em cache… Este directório deve também possuir as permissões de escrita activas pelo servidor.
pages – caminho para as páginas PRADO

Os ficheiros que definem o template da página, pode constituir mais uma novidades para programadores PHP, e aos quais os de ASP.NET já devem estar familiarizados. Esre tipo de ficheiro utiliza um processo de rendering de alguns componentes, pelo que é muito mais rápido criar componentes HTML. Veja por exemplo como criar um formulário standard

<form id="formulario" method="post" enctype="multipart/form-data"></form>



Rendering :: primeiro contacto

Usando rendering em Prado , bastaria
<com:TForm ID="formulario">
</com:TForm>
Em que TForm é o Data Control que generaliza o formulário
Vamos então proceder à criação dum projecto exemplo.
Crie uma pasta "projecto" e dentro dela crie as pastas "assets" e "protected" , dentro desta crie as pastas "pages" e "runtime" Agora observe o seguinte script , que será a página inicial, contudo ainda não está totalmente completo, pois ainda não definimos nada para a aplicação. Guarde o código seguinte e salve como index.php na pasta projecto.

<?php
#caminho para a pasta do projecto
$CaminhoServidor = dirname(__FILE__);

#localização da framework Prado
$caminhoFramework = $CaminhoServidor.'/../../framework/prado.php';

# directório que guarda as páginas privadas publicadas
$PagPublicadas = $CaminhoServidor.'/assets';


# caminho onde são guardados os dados da aplicação e 
# os ficheiros com código privado
$DadosAplicacao = $CaminhoServidor.'/protected/runtime';


#fazendo validações à existência do ficheiro e permissões de escrita

if(!is_file($caminhoFramework)){
die("A framework prado não foi encontrada em ".$caminhoFramework);
}

if(!is_dir($PagPublicadas)){
die("Garanta as permissões de escrita para a pasta ".$PagPublicadas);
}

if(!is_writable($DadosAplicacao)){
die("Garanta as permissões de escrita para a pasta ".$DadosAplicacao);
}
#carrega  a framework
require_once($caminhoFramework);

#instancia a aplicação
$Aplicacao=new TApplication;
# mostra o conteúdo da aplicação
$Aplicacao->run();

?>

Para que possamos correr uma aplicação simples basta-nos definir o template da mesma e correr o script anterior. É isso que vamos fazer a seguir .

O passo seguinte é criar a interface da aplicação, utilizando os seguintes Data Controls
TForm, TLabel, TTextBox, TButton
<com:TForm>
<fieldset>
<legend>Login no sistema</legend>
<div class="campo-utilizador">
<com:TLabel ForControl="login" Text="Utilizador:" />
<com:TTextBox ID="login" />
</div>
<div class="campo-password">
<com:TLabel ForControl="password" Text="Password:" />
<com:TTextBox ID="password" TextMode="Password" />
</div>
<div class="botao-login">
<com:TButton Text="Login" OnClick="fazerLogin" />
</div>
</fieldset>
</com:TForm>
Depois de criarmos a interface, guarda-se na pasta "pages" com e nomeia-se de home.page Se correr o script index.php, reparará que essa interface já pode ser mostrada.


Fazer a ligação do botão

O que me deixou maravilhado nesta framework foi precisamente este facto tão simples e prático de fazer a gestão de eventos. A interface que define o formulário faz parte da classe TPage assim para ligar o botão basta estender essa classe à classe HOME ,criando uma nova classe para fazer o tratamento dos dados que provêm do formulário.
Repare que o botão será ligado se na propriedade OnClick passar o nome da função onde os dados são tratados na nova classe.
Esta classe é guardada na pasta "pages", com o mesmo nome do ficheiro que define a interface neste caso Home.php

<?PHP
# permite aceder às propriedades dos Data Controls
Prado::using('System.Web.UI.ActiveControls.*');

#classe que permite tratar os dados do formulário
class Home extends TPage
{
     #callback do botão login
    public function fazerLogin($sender, $param)
    {       #obtem os dados nos campos do formulário
            $login = $this->login->Text;
            $pass  = $this->password->Text;
        
           # mensagem output
            echo htmlentities("Olá ".$login." , a sua password é ".$pass);
            exit;
    
    }
}
?>

Noutra altura tratarei de ensinar como fazer a gestão dos dados numa Base de Dados e confrontar essas informações com os dados do formulário. ]]> http://www.revista-php.net/artigos.php?pagina=37 Ajax vem de Asynchronous Javascript + XML
O principal componente, o XMLHttpRequest foi desenvolvido pela Microsoft para a versão do Internet Explorer 5 em 1997 , em forma de objecto ActiveX.
Não é uma nova tecnologia, mas corresponde à integração de algumas tecnologias existentes:


1.   Javascript que compreende o XMLHttpRequest + Listener
2.   DHTML e/ou DOM para actualização da interface (User Interface) com o utilizador
3.   XML para formatar os dados enviados


A API XMLHttpRequest, compreende um conjunto de métodos responsáveis por vários métodos na construção de pedidos inerentes ao AJAX


open ()

– estabelece um novo pedido ao servidor


Parâmetros

open (tipo-pedido,url,async, utilizador , password)
O tipo de pedido pode ser usado utilizando os métodos GET, POST …
Por defeito async está activo (true)


send()

envia o pedido ao servidor

Parâmetros

send ( conteúdo-a-enviar) conteúdo-a-enviar – corresponde à informação indicada através do método POST , ou nulo para GET (estes parâmetros são codificados na url) . Aqui pode entrar o Json posteriormente para fazer a descodificação dos dados.
A API comporta um conjunto de propriedades , que se utilizam para detectar o estado da informação a cada momento , visto que este tipo de funcionalidade é extremamente dinâmica.


readyState

– informa o estado actual do pedido . Devolve valores entre 0 (antes do método open())e 4 (completo , a resposta do servidor existe)


onreadestatechange

– especiifca o método de chamada (callback)
O método de callback é chamado sempre que estado pronto do http (correspondente ao pedido), varie.


status

: códigos de estado http (200 significa que correu tudo bem)


responseText

– o servidor responde em formado de texto plano (Plain Text)


responseXML

– o servidor responde em formado XML (objecto)

Em seguida segue-se o esqueleto fundamental para possa utilizar o Ajax nas suas aplicações


var pedido = null;
try {
// habilita o javascript para pedidos HTTP assincronos
 //também cobre versão Firefox, Opera , Safari
  pedido = new XMLHttpRequest();
} catch (trymicrosoft) {
  try {
   // versões novas do IE
    pedido = new ActiveXObject("Msxml2.XMLHTTP");
  } catch (othermicrosoft) {
    try {
    // versões antigas do IE
      pedido = new ActiveXObject("Microsoft.XMLHTTP");
      }catch (falha) {
      pedido = null;
     
    }
  }
}

if (pedido == null)
  alert("Não foi possível criar o objecto !");




No código javascript que escrevermos , eis como temos acesso às propriedades:
//verifica o estado de prontidão
if (pedido.readyState == 4) {
// faz alguma coisa
//verifica o estado da requisição
if (pedido.status == 200) {
// faz alguma coisa ....]]> http://www.revista-php.net/artigos.php?pagina=38 É um protocolo independente do tipo de hardware ou do sistema operativo, e é utilizado para transferência de ficheiros, apenas sujado pelas restrições e propriedades de cada sistema ou aplicação.
Tal como em outras operações que já vimos, como por exemplo os Web Services, a transferência de arquivos também envolve um cliente (o que solicita o pedido de transferência de dados), a par dum servidor (o que recebe o pedido para a transferência). Neste artigo iremos verificar de forma prática a forma de seleccionar e processar o envio de ficheiros via FTP.

Vulgarmente o FTP utiliza o porto 21 como canal de comunicação. Se num dado servidor existirem restrições, é necessários que saibamos as credenciais de acesso, de forma a processar o serviço. O acesso a servidores via FTP pode ser feito de duas formas distintas, ou através de interface (que é o objectivo deste artigo), ou por meio de linha de comandos, que constitui um processo mais complexo de realizar esta tarefa.
Segue-se o código fonte que permite processar o envio de ficheiros via FTP, programado através de funções disponíveis no PHP , para esta tarefa.

<?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : FTP no PHP
    ***************************************/

    // definição do modo passivo
    define("PASV",true);
    // define o tempo de 30 seg para processameto da aplicação
    set_time_limit(0);
    
    $Utilizador = "utilizador";
    $Password   = "password";
    $Servidor   = "ftp.o-seu-site.com";
    $Caminho    = "/httpdocs";
    $Porto      = 21;

if(isset($_POST["upload"])):

    // ligação ao endereço FTP
    $conn = @ftp_connect($Servidor,$Porto) or die("Erro de ligação ao servidor FTP ".$Servidor);
    ftp_pasv($conn,true);
    // processo de login
    ftp_login($conn, $Utilizador, $Password) or die ("Erro a processar  o login no endereço FTP");
    // caminho relativo para o ficheiro a ser envaido
    $ficheiro  = dirname($Caminho.$_FILES['ftp_file']['name']);
    
    // localização do upload  local
    $tmpFich = $_FILES['ftp_file']['tmp_name'];

// processa  o upload via frp
if(@ftp_put($conn,$ficheiro,$tmpFich,FTP_BINARY){
    echo "O ficheiro ".$_FILES['ftp_file']['name']. " foi enviado sem erros";
    }else{
      echo "Erro na tentativa de  envio do ficheiro via FTP";
      }
      // fecha  a ligação ao servidor
    ftp_quit($conn);

?>
<?php
else:
?>
        <form action="<?php $_SERVER['PHP_SELF'];?>" method="post" enctype="multipart/form-data">
        <input type="file" name="ftp_file" size="40">
        <br>
        <hr>
        <input type="submit" name="upload" value="Enviar">
        
        </form>

<?php
endif;
?> ]]> http://www.revista-php.net/artigos.php?pagina=39 date() cuja sintaxe de utilização é :
String date(formato, data_ts)
em que data_ts é um parâmetro opcional e se informado utiliza a data no formato timestamp
Para a conversão da data em português podemos utilizar o seguinte script
 <?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Datas em português no PHP
    ***************************************/

 // obter o ano
 $ano = date("Y");
 // dia do mês em inglês
 $mes = date("M");
 // numero do dia
 $dia = date("d");
 // dia da semana em inglês               
$ndia = date("D");
 // array  para  a converção dos dias da semana
 $ptDia =array("Mon"  => "Segunda-feira", 
               "Tue"  => "Terça-feira",
               "Wed"  => "Quarta-feira",
               "Thu"  => "Quinta-feira",
               "Fri"  => "Sexta-feira",
               "Sat"  => "Sábado",
               "Sun"  => "Domingo");
 // array  para  a converção dos meses               
 $ptMes = array("Jan"   => "Janeiro",
                 "Feb"   => "Fevereiro",
                "Mar"   => "Março",
                "Apr"   => "Abril",
                "May"   => "Maio",
                "Jun"   => "Junho",
                "Jul"   => "Julho",
                "Aug"   => "Agosto",
                "Sep"   => "Setembro",
                "Oct"   => "Outubro",
                "Nov"   => "Novembro",
                "Dec"   => "Dezembro");               


                
 echo "Hoje é  ".$ptDia[$ndia]." , dia ".$dia." de ".$ptMes[$mes]." de ".$ano;

?> ]]> http://www.revista-php.net/artigos.php?pagina=40 Para isso recorri às funções nativas do PHP, disk_free_space e disk_total_space, com base na diferença entre os dois é então possível obter o espaço usado.

 <?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Operações com espaço em disco
    ***************************************/
  
  // valor unitario (bytes) de 1 kb
  $kb = 1024;
   // valor unitario (bytes)de 1 Mb
  $mb = pow($kb,2);
  // valor unitario (bytes)de 1 Gb
  $gb = pow($kb,3);
  $Disco = "D:";
  
 $EspOnDisco = disk_free_space($Disco);

 echo "<h4>". ($EspOnDisco < $kb 
?  "Espaço Livre " . $EspOnDisco." Bytes" : ($EspOnDisco < $mb 
?  "Espaço Livre " .round($EspOnDisco/$kb,2)." KBytes" : ($EspOnDisco < $gb
?  "Espaço Livre " .round($EspOnDisco/$mb,2)." MBytes" 
: ("Espaço Livre " .round($EspOnDisco/$gb,2)." GBytes"))))."</h4>";
                         
$TotalOnDisco = disk_total_space($Disco);

 echo "<h4>".($TotalOnDisco < $kb 
?  "Espaço Total em disco " . $TotalOnDisco." Bytes" : ($TotalOnDisco < $mb 
?  "Espaço Total em disco " .round($TotalOnDisco/$kb,2)." KBytes" : ($TotalOnDisco < $gb
?  "Espaço Total em disco " .round($TotalOnDisco/$mb,2)." MBytes" 
: ("Espaço Total em disco " .round($TotalOnDisco/$gb,2)." GBytes"))))."</h4>";                         
                         
$EspacoUsado =     $TotalOnDisco -     $EspOnDisco;

 echo "<h4>".($EspacoUsado < $kb 
?  "Espaço usado em disco " . $EspacoUsado." Bytes" : ($EspacoUsado < $mb 
?  "Espaço usado em disco " .round($EspacoUsado/$kb,2)." KBytes" : ($EspacoUsado < $gb
?  "Espaço usado em disco " .round($EspacoUsado/$mb,2)." MBytes" 
: ("Espaço usado em disco " .round($EspacoUsado/$gb,2)." GBytes"))))."</h4>";            
                      


?>
]]> http://www.revista-php.net/artigos.php?pagina=41 O objectivo deste artigo é complementar a teoria do artigo que escrevi antes

"Compreenda como funciona o Ajax"

disponível aqui , o qual deverá ler com bastante atenção de forma a compreender o que foi aqui feito.
Muitos programadores optam por chamar a livraria Ajax , a partir dum ficheiro *.js. No meu caso como a livraria é muito reduzida optei por por incluí-la na página , onde o pedido é solicitado.
Basicamente o processo é muito simples a página "ajax.php" contém a interface e o processamento dos dados com Ajax. A pagina "resultado.php" , recebe o parâmetro enviado por url , com a função send do Ajax , via GET.
Poder-se ia fazer algo muito mais complexo , mas eu optei apenas por simplificar a tarefa de forma a que quem nunca usou Ajax compreenda com essa funcionalidade é implementada.

Ficheiro "ajax.php"

<html>
<head>
<title>Processar dados com Ajax e PHP</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<script language="JavaScript" type="text/javascript">
var pedido = null;
function myAjax(pagina)
{
try {

 //cobre versão Firefox, Opera , Safari
  pedido = new XMLHttpRequest();
  pedido.onreadystatechange = pedidoStatus;
  pedido.open("GET",pagina,true);
  pedido.send(null);
  
} catch (tentaIEversaoNova) {
  try {
   // versões novas do IE
    pedido = new ActiveXObject("Msxml2.XMLHTTP");
    pedido.onreadystatechange = pedidoStatus;
    pedido.open("GET",pagina,true);
    pedido.send();
    
  } catch (tentaIEversaoAntiga) {
    try {
    // versões antigas do IE
      pedido = new ActiveXObject("Microsoft.XMLHTTP");
      pedido.onreadystatechange = pedidoStatus;
      pedido.open("GET",pagina,true);
      pedido.send();
      }catch (falha) {
      pedido = null;
     
    }
  }
} 
  if (pedido == null)
  alert("Não foi possível criar o objecto !"); 
}

function pedidoStatus()
{
  // completou o pedido ...
if (pedido.readyState == 4)
{
 // e o correu tudo bem no servidor
if (pedido.status ==200)
{

// o servidor responde em formado de texto plano no div  conm id 'resultado'
document.getElementById('resultado').innerHTML = pedido.responseText;
}
else
{
// em caso de erro mostra mensagem
document.getElementById('resultado').innerHTML = 
"<font color='red'><strong>Erro ao processar o pedido<strong></font>";
}
}
}
</script>

<script language="JavaScript" type="text/javascript">
var pagina;

function Pesquisa(str){
 pagina = "resultado.php?tag="+str;
 myAjax(pagina);
}
</script>


</head>

<body>


<form action="<?php $_SERVER['PHP_SELF'];?>" method="post" >
<label for="termo"><strong>Termo para pesquisa :</strong></label>
<input type="text" size="40" onKeyUp="Pesquisa(this.value)">
<br>
</form>
<!-- o RESULTADO SERá MOSTRADO NA DIV SEGUINTE-->
<div id="resultado"></div>
</body>
</html>




Ficheiro "resultado.php"

<?php
// se o parametro 'tag' existe é impreimido
if(isset($_GET['tag'])){
echo htmlentities("A tag é ".$_GET['tag']);
 }
?>
Espero ter ajudado ;)
Abraço
José Franco]]> http://www.revista-php.net/artigos.php?pagina=42 Este tipo de funcionalidade, pode ser útil por exemplo para gerar código personalizado de acordo com as configurações do sistema, por exemplo , gerar código somente para windows , de forma a garantir a cobertura de certas necessidades nesse Sistema Operativo.
Pode ainda ser utilizado para criar um ficheiro de instalação automatizado, por exemplo em fóruns ou outras aplicações.


 <?php
    /**************************************
    Autor    : José Franco
    Data     : 26 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Gerar código PHP
    ***************************************/
  
$dados = array("nome","email","morada","telefone"); 

// inicio da concatenação para geração do código
$str  = '<'."?php\n";
$str .= '$conn = mysql_connect("localhost","root","") or die("Erro na ligação ao servidor");'."\n\n";
$str .= 'if(isset($_POST["enviar"])):'."\n\n";

foreach ($dados as $campo){

$str .= 'if(empty($_POST["'.$campo.'"])){'."\n\n";
$str .= "echo \"<script>alert('O campo $campo está vazio !')<script>\";\n\n";
$str .= "}";
} 
$str .= "else{\n\n";

$campos = implode(" ,", $dados);
$insere = implode("' , '$",$dados); 

$str.= '$rs = mysql_query("INSERT INTO clientes ('.$campos.') 
VALUES('."'$".$insere."'".')",$conn);'."\n\n";

$str .="}\n\n\n";
$str .= "?>\n\n";
$str .= '<?php'."\n\n";
$str.="else:\n\n";
$str .="?>\n";
$str .= '<'."?php\n\n";
$str .= "# aquí fica o formulário\n\n\n";

$str .="?>\n\n";

$str .= '<'."?php\n\n";
$str .= "endif;\n\n";
$str .= "?>";

  // gravando o código
  $fp = fopen("pagina.php","w+");
  fwrite($fp,$str);
  fclose($fp);
                 


?>
]]> http://www.revista-php.net/artigos.php?pagina=44 aquí . Esta funcionalidade permite tratar imagens existentes, enviá-las directamente para o browser , sem que seja guardada (trabalha directamente com a memória).
Permite ainda recorrer à manipulação de texto directamente do sistema e manipular junto com as imagens.
O código seguinte é um exemplo muito simples , mas bastante prático , que demonstra uma das formas de criar gráficos no PHP.

<?php
/**************************************
  Autor    : José Franco
  Data     : 28 Abril 2008
  Lisenca  : Creative Commons 
  Distro   : Griar gráficos com PHP e GD
***************************************/ 

#informa o tipo de imagem a usar
header("Content-type: image/png");


$altura  = 300; #altura
$largura = 300; #largura

# cria a imagem
$imagem = imagecreate($altura,$largura);

# definimos as cores
$branco   = imagecolorallocate($imagem,255,255,255);
$preto    = imagecolorallocate($imagem,0,0,0);
$cinza    = imagecolorallocate($imagem,192,192,192);
$vermelho = imagecolorallocate($imagem,255,0,0);
# criamos as rectas
imageline($imagem,0,0,0,300,$preto);
imageline($imagem,0,0,300,0,$preto);
imageline($imagem,299,0,299,299,$preto);
imageline($imagem,0,299,299,299,$preto);
#titulo do gráfico
$titulo = imagestring($imagem,30,30,20,
"Estatísticas Revista PHP",$vermelho);
#valores a adicionar ao gráfico
$ValoresOnGrafico = array(0,200,55,14,17,
                          228,45,105,145,22,44);
#legenda  no eixo dos xx
$textoOnGrafico   = array("J","F","M","A","M","J",
                           "J","A","S","O","N","D");


   # traça o gráfico de acordo com os valores
  for($i=0;$i<sizeof($ValoresOnGrafico)-1;$i++){
  imageline($imagem,$i*30,(300-$ValoresOnGrafico[$i]),
  ($i+1)*30,300-$ValoresOnGrafico[$i+1],$vermelho);
  }
  # coloca  a legenda no eixo xx
  for($j=0;$j<sizeof($textoOnGrafico);$j++){
   imagestring($imagem,10,($j+0.3)*25,285,
   $textoOnGrafico[$j],$preto);
   }

# mostra a imagem 
imagepng($imagem);
# apaga da memória
imagedestroy($imagem);



?>


Resultado

]]> http://www.revista-php.net/artigos.php?pagina=46 Foram introduzidos conceitos como herança, gestão de excepções, conceitos como public , protected e private , abstracção, extensão de classes entre um sem número de outras funcionalidades que garantem uma estrutura melhorada na forma de programar , usando PHP.
Para interiorizar uma forma clássica de generalizar um objecto , segue uma simples classe exemplo, de forma a que quem nunca programou utilizando classes , passe a perceber melhor o conceito.
Na classe seguinte, o objectivo é generalizar um objecto do tipo Pessoa.
Isto quer dizer que usando esta classe poderemos vários objectos distintos , que se encaixam no perfil do mesmo objecto.
Para criar uma classe em PHP , é necessário utilizar a seguinte notação:
class Nome da classe
No nosso exemplo temos
class Pessoa.
Em seguida informamos que tipos de atributos o nosso objecto possui (os dados que a classe possuí). No nosso exemplo os atributos são cinco ($nome, $profissao,$morada, $carro, $salario), nos quais antecede a palavra reservada public, o que significa que temos acesso a eles fora da classe.
Por sua vez protected , apenas acessíveis pela classe que os criou e pelas suas subclasses, mas que não podem ser usados fora desta.
Também private , significa que são apenas visíveis pela classe que os criou, e assim não podem ser usados nem fora da classe, nem nas subclasses.
Assim no nosso exemplo o atributo taxa , só pode ser usado e manipulado dentro do contexto da classe Pessoa.
Logo abaixo o método __construct é executado sempre que é criado um novo objecto.
Neste exemplo o método é informado com os 5 argumentos que fazem referencia aos atributos da classe sempre que um novo objecto é criado.

<?php
/**************************************
    Autor    : José Franco
    Data     : 30 Abril 2008
    Licensa  : Creative Commons 
    Distro   : Utilizando POO no PHP
    ****************************************/  

class Pessoa{
// atributos publicos da classe
public $nome;
public $profissao;
public $morada;
public $carro;
public $salario;

// atributo privado na classe
private $taxa = array("Lisboa" => "19%",
                      "Guarda" => "21%",
                      "Viseu"  => "16%");

/**********************************************************
 método constructor , que possuí 5 argumentos
 repare que à excpção do argumento $s que é flaot 
 tdos os outros   são do tipo string, no entanto
 se não instância informar outro tipo o PHP encarega-se 
 da conversão    , pelo que se quisermos garantir que os tipos
 se mantenham devemos fazer uma validação em cada caso   
 exemplo
 if(!is_float($s)) return false;                                       
***************************************************************/
public function __construct($n='', $p='', $m='', $c='', $s=0.0){
// referencia dos atrubutos aos argumentos do constructor
/******************************************************
 a variável especial $this permite fazer referencia a
  cada atributo ($this->nome) ou método ($this->obtemome())
 ******************************************************/
       $this->nome      = $n;
       $this->profissao = $p;
       $this->morada    = $m;
       $this->carro     = $c;
       $this->salario   = $s;     
       }
       
// método que permite obter o nome        
public function obtemNome(){
        // devolve o nome informado 
       return $this->nome;
       }
// método que permite obter a profissao       
public function obtemProfissao(){
 // devolve a profissao informada 
       return $this->profissao;
       }

// método que permite obter a morada        
public function obtemMorada(){
 // devolve a morada
       return $this->morada;
       }
     
// método que permite obter o carro            
public function obtemCarro(){
//  devolve o carro
       return $this->carro;
       }
// método que permite obter o salário 
public function obtemSalario(){
// devolve o salário 
       return $this->salario;
       }

// método que permite a taxa de acordo com a cidade            
public function obtemTaxa(){
// taxa aplicada de acordo com a cidade 
  return $this->taxa[$this->morada];
   }
}
/************************************************************
  Para criar um novo objecto (instanciar) usar-se a instrução
  new  

  cria um objecto do tipo Pessoa
  a variável $P guarda a instancia do objecto, ou seja é do tipo
  objecto, e é ela que nos permitirá fazer referência aos 
  métodos declarados na classe
 **********************************************************/ 
 
$P  = new Pessoa("José","Médico","Guarda","Audi",3000.34);

/************************************************************
 Para aceder a cada propriedade do novo objecto
 Repare-se que a seta  -> permite acder aos métodos da classe
 Para isso coloca-se a seta -> e indica-se  afunção que queremos
 utilizar, a qual deve existir no seio da classe
 ************************************************************/
echo "O cliente ".$P->obtemNome()." é ".$P->obtemProfissao()."<br>";
echo "Vive na ".$P->obtemMorada()." , e tem um ".$P->obtemCarro()."<br>";
echo "Embora pague ".$P->obtemTaxa()." de taxas ao estado, o seu ordenado";
echo " de " .$P->obtemSalario()." € , permite-lhe viver bem na Europa";

/********************************************************************
  Repare que os atributos da classe sõa publicos pelo que podemos
   alterá-los fora da classe
 *********************************************************************/
$P->nome = "Manuel";

echo "<br>Houve troca de nome , afinal o cliente chama-se ".$P->obtemNome();

/***************************************************************************
 Sem alterar nada na classe podemo criar um novo objecto, no entando
 devemos ter atenção que devemos guardar a instancia numa nova variável
 ***************************************************************************/
 
 $P2  = new Pessoa("Maria","Cozinheira","Meda","Ford","1600");

 echo "<br>"; // quebra linha
 echo "Olá D. ".$P2->obtemNome().", o que vai ser hoje o almoço ??";

?> ]]> http://www.revista-php.net/artigos.php?pagina=48
Para usarmos as funcionalidades do Paypal é necessário estar registado no site . Para isso aceda ao site em https://www.paypal.com/ e crie uma conta, não necessita de usá-la no futuro e além disso é totalmente gratuito.

Após criar conta aceda ao url https://www.paypal.com/cgi-bin/webscr?cmd=_cart-factory e faça login. Nessa página ser-lhe-á mostrado um formulário com a requisição dos dados de forma a que possa criar os botões paypal a integrar no nosso sistema.

Vamos primeiramente criar um produto exemplo e depois numa fase posterior flexibilizar o sistema utilizando PHP.
Após preencher os campos do formulário, e seleccionar as opções, como estilo do botão , forma de envio, imposto carregue no botão "criar botão agora" Repare que o sistema criou o código HTML de dois botões, o botão "Adicionar ao carrinho" e o botão "Ver carinho".

Copie esse código e cole num editor de HTML, de forma a poder analisar com mais facilidade.

Partindo do principio que queremos dinamizar o sistema, no exemplo do botões "Adicionar ao carrinho", será importante modificar, o nome do produto (item_name) e o preço (amount) Visto que cada produto contém uma imagem, e uma descrição, vamos criar a seguinte base de dados, para gerir a informação relativa a cada um deles.



Criação da Tabela com MySQL



CREATE TABLE `loja` (
`id` INT( 11 ) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`produto` VARCHAR( 200 ) NOT NULL ,
`descricao` VARCHAR( 600 ) NOT NULL ,
`imagem` VARCHAR( 600 ) NOT NULL ,
`preco` VARCHAR( 11 ) NOT NULL 

) ENGINE = MYISAM ;



Criada a tabela vamos criar o ficheiro de configuração do acesso ao servidor. Esse ficheiro será incluído nas páginas do script sempre que haja manipulação de dados com MySQL.

<?php

/*************************************
 Constantes de configuração do sistema
 *************************************/
define("HOST","localhost");
define("USER","root");
define("PASS","");
define("DB","revistaphp_net");
define("TABLE","loja");
?>
Salve o ficheiro como config.php
Agora crie um ficheiro loja.php , e inclua o código seguinte para carregar as configurações
<?php
/******************************************************************
  carrega o ficheiro com as configurações
 *****************************************************************/
 require_once("config.php");
 ?>
Após isso vamos fazer a ligação o servidor MySQL
 <?php
/******************************************************************
  cria a ligação ao servivor MySQL e seleciona a BD
 *****************************************************************/
$conn = mysql_connect(HOST,USER,PASS) or die(mysql_error());
mysql_select_db(DB,$conn);
?>

Para obtermos a referência a cada produto, vamos utilizar uma variável que permite armazenar o número de cada registo e relacioná-lo com o id na tabela , permitindo obter cada produto ao clicar-se nos diferentes links do menu de navegação.
<?php
/********************************************************************
 Na primeira vez que entramos na página o item corresponde ao
 primeiro produto na BD, após isso o produto será cada id indicado no item
 ********************************************************************/
(!isset($_GET["item"])) ? ($item = 1) :  ($item = $_GET["item"]);
?>

Para criar o menu de navegação entre cada registo, vamos obter o número de registos total a partir da tabela.
<?php
/********************************************************************
 Número de produtos total existente na BD
 ********************************************************************/
$rs1 = mysql_query("SELECT * FROM ".TABLE."");
$total = mysql_num_rows($rs1);
?>

Ao clicar em cada link de navegação, e variável correspondente a cada produto é tranasportada por url e igualada à chave "item", de forma poder ser obtido sem seguida com o método $_GET Esta técnica permite que a cláusula SQL , mude sempre que se clica em diferentes links.

<?php
$rs2 = mysql_query("SELECT * FROM ".TABLE." WHERE id='$item'")or die(mysql_error());
?>

O resultado da execução desse pedido irá ser guardado num array , recorrendo à função mysql_fetch_array, na variável $linha É recorrendo a esta variável que vamos dinamizar as consultas e obter cada linha a partir da tabela.

<?php
$linha = mysql_fetch_array($rs2);
?>

Baseado no número total de registos , guardado na variável $total, vamos construir o menu de links, para cada produto.

<?php
for($i=1;$i<=$total;++$i){
    echo "<a href='".$_SERVER['PHP_SELF']."?item=$i"."'> $i </a>";
   }
echo "<br />";
?>

Em seguida vamos então permitir com que o sistema apresente o produto, a imagem desse, e o seu preço. Os produtos mudam de forma dinâmica ao clicar em cada link da forma já descrita antes.

<?php
echo "<table border=\"0\">
          <tr><td><h2>"          .$linha["produto"]."</h2></td></tr>
          <tr><td><img src="     .$linha["imagem"]. "></td></tr>
          <tr><td> <b>Preço </b>".$linha["preco"].  " € (euros)</td></tr>
</table>";
?>

No formulário que obtivemos a partir do Paypal é tambem necessário dinamizar o nome do produto e o preço , de forma a que ao clicar no botão "Adicionar ao carrinho", seja enviada a informação correspondente a cada um deles.Para isso basta mudar apenas duas linhas no formulário .


<input type="hidden" name="item_name" value="<?php echo $linha["produto"];?>">
<input type="hidden" name="amount" value="<?php echo $linha["preco"];?>">


E o nosso sistema está completo. Tudo funciona correctamente desde que possua alguns produtos na Base de Dados e as imagens na pasta que configurou na linha imagem da tabela .

<?php
/**************************************
    Autor    : José Franco
    Data     : 02 Maio 2008
    Licensa  : Creative Commons 
    Distro   : Loja online com PHP e PayPal
    ****************************************/   


/*************************************
 Constantes de configuração do sistema
 Nota :Configure à medida do seu sistema
 *************************************/
define("HOST","localhost"); 
define("USER","root");
define("PASS","");
define("DB","revistaphp_net");
define("TABLE","loja");

 /******************************************************************
  cria a ligação ao servivor MySQL e seleciona a BD
 *****************************************************************/
$conn = mysql_connect(HOST,USER,PASS) or die(mysql_error());
mysql_select_db(DB,$conn);

/********************************************************************
 Na primeira vez que entramos na página o item corresponde ao
 primeiro produto na BD, após isso o produto será cada id indicado no item
 ********************************************************************/
(!isset($_GET["item"])) ? ($item = 1) :  ($item = $_GET["item"]);

/********************************************************************
 Número de produtos total existente na BD
 ********************************************************************/
$rs1 = mysql_query("SELECT * FROM ".TABLE."");
$total = mysql_num_rows($rs1);

/********************************************************************
 Obtem cada produto de forma distinta a partir da tabela
 ********************************************************************/
$rs2 = mysql_query("SELECT * FROM ".TABLE." WHERE id='$item'")or die(mysql_error());

/********************************************************************
 Constrói o menu de links
 ********************************************************************/
$linha = mysql_fetch_array($rs2);
for($i=1;$i<=$total;++$i){
    echo "<a href='".$_SERVER['PHP_SELF']."?item=$i"."'> $i </a>";
    
    }
    echo "<br />";

/********************************************************************
 Mostra a referecias de cada produto : nome, imagem e preço
 ********************************************************************/
    
    echo "<table border=\"0\">
          <tr><td><h2>"          .$linha["produto"]."</h2></td></tr>
          <tr><td><img src="     .$linha["imagem"]. "></td></tr>
          <tr><td> <b>Preço </b>".$linha["preco"].  " € (euros)</td></tr>
          </table>";

?>


<!--  Mostra o botão Paypal -->

<form target="paypal" action="https://www.paypal.com/cgi-bin/webscr" method="post">
<input type="image" src="img/botao.jpg" border="0" name="submit">
<input type="hidden" name="add" value="1">
<input type="hidden" name="cmd" value="_cart">
<input type="hidden" name="business" value="agentegt@gmail.com">
<input type="hidden" name="item_name" value="<?php echo $linha["produto"];?>">
<input type="hidden" name="amount" value="<?php echo $linha["preco"];?>">
<input type="hidden" name="no_shipping" value="0">
<input type="hidden" name="no_note" value="1">
<input type="hidden" name="currency_code" value="EUR">
<input type="hidden" name="lc" value="PT">
<input type="hidden" name="bn" value="PP-ShopCartBF">
</form>
]]> http://www.revista-php.net/artigos.php?pagina=49 Nota de redacção Esta entrevista foi cedida gentilmente por Manuel Lemos , via email em 07-10-2006, ao qual agradecemos pela sua disponibilidade e respostas claras. Como não poderia deixar de ser , a entrevista foca o projecto PHPClasses, que tem merecido uma enorme aceitação junto da comunidade de programadores PHP, contribuindo de forma activa para que a linguagem tenha tido tanta criatividade e avanço, muito dele proporcionado pelo trabalho árduo do seu criador .





José Franco > O site PHPClasses é um sucesso a nível mundial.
Como e com que intuito surgiu o site ?

Manuel Lemos > O site surgiu por uma necessidade pessoal de divulgar componentes
prontos em PHP que desenvolvo para satisfazer necessidades dos meus
projectos.

Como esses componentes também satisfazem necessidades de outros, achei
interessante divulgar como Open Source. Isso permitiria que outros
testassem os componentes, e eventualmente reportassem bugs ou sugerissem
novas capacidades interessantes.

Esse retorno dos utilizadores dos meus componentes é uma coisa que
acontece regularmente. É bastante proveitosa para mim porque me ajuda a
melhorar os meus componentes em beneficio dos projectos nos quais os uso.

Porém, nem todos utilizadores dão retorno. Por isso sempre me empenhei
em divulgar os componentes o mais que podia, para assim maximizar o
número de utilizadores que dão retorno útil, quer dizer reportam bugs ou
sugerem novas capacidades interessantes.

No principio eu usava as listas de discussão de PHP para divulgar os
meus componentes. Sempre que alguém surgia com uma necessidade que podia
ser satisfeita com uma dos meus componentes, eu oferecia-me para lhe
enviar uma cópia do componente por e-mail.

Esse contacto directo por e-mail permitia-me manter uma lista de
utilizadores interessados. Assim podia notificá-los mais tarde
quando eu tivesse novas versões com bugs corrigidos ou novas capacidades.

Porém, com o aumento de interesse pelos meus componentes, logo se tornou
inviável manter esse contacto por e-mail, dado que me exigiria muito tempo.

Nessa altura procurei por sites que pudessem alojar os componentes e
mantivessem de alguma forma a lista de utilizadores interessados. Vi um
site chamado PX (PHP code exchange) que podia satisfazer parcialmente as
minhas necessidades.

Porém, como não dava a possibilidade de registar e notificar os
utilizadores interessados nos meus componentes, contactei o autor para
sugerir melhorias nesse sentido. Ele não se interessou, nem mesmo quando
eu me ofereci para desenvolver o código necessário para implementar
essas melhorias.

Foi então que decidi criar o site PHP Classes. No principio era apenas
para divulgar os meus componentes. Logo depois pensei que seria
interessante permitir que outros também usassem o site para divulgar os
seus componentes.

É sempre bom ter acesso a soluções disponibilizadas por outros para
problemas comuns, mesmo quando essas soluções podem ser de certa forma
concorrentes das que já disponibilizamos. Mesmo que não queiramos usar
as soluções dos outros, sempre podemos aprender algo com novas ideias ou
diferentes abordagens estudando o código dos componentes de outros.

Isto foi em meados de 1999. A partir daí o site não parou de crescer. O
resto é história.


José Franco > Os componentes (código fonte) publicados no site, são disponibilizados
de forma gratuíta.
De que forma se torna viável um projecto deste tipo, e que meios
utilizas para rentabilizá-lo ?
Manuel Lemos > No principio o site não tinha fins lucrativos. Para mim, divulgar os
meus componentes e obter retorno dos utilizadores já era um grande
beneficio.

No entanto, em 2001, quando muitos de nós foram mandados embora de
empresas que não aguentar o fim da bolha .com , tive de repensar a
minha vida, e principalmente o que queria dela.

Depois de tanto ter trabalhado em empresas com as quais não concordava
como abordavam o mercado e as oportunidades que a Internet oferecia,
achei que seria melhor investir em negócio próprio e pôr em pratica o
que achava ser o certo. Foi nessa altura que vi o site PHP Classes como
uma oportunidade para me estabelecer por conta própria.

Infelizmente nessa altura o mercado de publicidade na Internet estava
desacreditado por causa do fiasco da bolha .com . Eu até podia tentar
angariar anunciantes directos, mas isso exigia o esforço duma eventual
equipa de vendas dedicada, para a qual eu não tinha orçamento para
sustentar.

Eu continuei a desenvolver o site a tempo inteiro, adicionando cada vez
mais recursos para atrair mais utilizadores de forma viral. Mas eu
precisava de ter uma fonte de receita para continuar a trabalhar a tempo
inteiro.

Em meados de 2002 comuniquei aos cerca de 50,000 utilizadores inscritos
que o site precisava de se sustentar para não fechar. Anunciei que
pretendia vender um pacote de serviços pagos através duma assinatura
mensal de valor baixo. Esses serviços seriam exclusivos para quem se
dispusesse a pagar.

A questão era determinar que serviços seriam esses pelos quais os
utilizadores pagariam? Fiz uma sondagem propondo vários tipos de
serviços de acordo com sugestões vindas dos próprios utilizadores.

A sondagem mostrou que cerca de 3,000 utilizadores mostraram interesse
nos serviços. Fiquei convencido que esse era o caminho, mas agora
faltava por os serviços em prática. O trabalho que isso ia exigir não
era pouco e ia demorar bastante tempo para implementar os serviços.

Nessa altura, decidi fazer aquilo que por vezes chamo "dar um passo
atrás agora, para dar dois ou mais passos à frente depois".

Investi no desenvolvimento duma ferramenta de geração de código que faz
aquilo que se chama "mapeamento objecto-relacional" (ORM -
Object-Relational Mapping). Essa ferramenta gera código eficiente para
guardar e obter informação armazenada na base de dados como objectos de
negócio.

A ferramenta chama-se Metastorage e está disponível como Open Source aqui:

http://www.metastorage.net/

Em poucos meses tinha a ferramenta pronta. O benefício em termos de
produtividade do desenvolvimento de novos recursos para o site
começou-se logo a notar.

Passei a gastar muito menos tempo na parte de escrita de código de
acesso a bases de dados. Isso permitiu-me focar mais os meus esforços
nas partes que implementam as regras de negócio, que são determinantes
no sucesso das iniciativas comerciais do projecto.

Tudo isso ia muito bem, mas restou um problema crítico para implementar
os serviços de assinaturas pagas: a cobrança. Os serviços poderiam ser
cobrados por cartão de crédito, mas na altura era difícil para pequenos
negócios terem acesso às redes de cartões de crédito para cobrar
serviços pela Internet.

Já existia o Paypal, mas na altura não fornecia um meio para eu receber
os pagamentos onde vivo. Era necessário ter uma conta num banco nos
Estados Unidos. Para ter essa conta, precisava ter residência lá, que
não era o caso. O plano A ficou adiado indefinidamente.

Felizmente no fim de 2002 o mercado publicitário da Internet começou a
recuperar a credibilidade. Consegui que o site fosse aceite na rede da
TribalFusion. Era e continua a ser uma rede que paga valores elevados de
publicidade por impressão (CPM), mas na altura estava restrita a sites
com conteúdo em inglês com pelo menos 1000 visitas diárias, que já era o
caso do site PHP Classes.

Mais tarde em meados de 2003 o Google lançou publicamente o programa
AdSense. É um programa que permite colocar anúncios pagos de texto com
links, em que essencialmente o anunciante paga por clique nesses links.

Mal soube do AdSense, inscrevi logo o site PHP Classes. Deve ter sido um
dos primeiros sites no mundo a entrar no AdSense desde que esse programa
foi aberto publicamente para sites com conteúdo em inglês. Os espaços
publicitários passaram a ser dividido entre TribalFusion e Google AdSense.

A partir daí passei a investir cada vez mais em iniciativas que
trouxessem mais visitantes ao site, para assim conseguir maximizar a
receita. Iniciativas como o prémio de inovação em programação em PHP
tiveram e continuam a ter um efeito tremendo no crescimento do interesse
do site todos os meses:

http://www.phpclasses.org/award/innovation/

No entretanto, em 2005, o Paypal passou a proporcionar um meio de
receber valores retirados da conta Paypal através de cheque em dólares
ou transferência bancária internacional em alguns países.

Esse facto permitiu-me voltar ao plano A: as assinaturas de serviços
pagos. Depois de mais de 14 meses em desenvolvimento, finalmente essas
assinaturas foram lançadas em Julho de 2007.

A partir daqui vão ser lançados mais serviços que agregam valor para os
assinantes. No momento em que estou a escrever ainda não posso revelar o
que vai ser lançado, mas posso adiantar que o site vai proporcionar
melhores oportunidades de trabalho e negócio para toda a linha de
profissionais que trabalham com PHP, desde consultores, Web designers,
empresas de formação, hospedagem de sites, etc..

Estou bastante entusiasmado com futuro do site. Os interessados que se
mantenham atentos para os desenvolvimentos futuros que vou anunciando
no blog do site:

http://www.phpclasses.org/blog/





José Franco > O teu sucesso no meio é indiscutível. Destes entrevistas na TV, na radio,
nos jornais e escreveste um livro.
Foste convidado para conferências internacionais, nomeadamente no Brasil.
Sentes que Portugal te dá o reconhecimento necessário ?
Manuel Lemos > Hoje em dia, vivo no Brasil. Mudei-me em 1998 por motivos pessoais.
Portanto, não mudei por motivos profissionais ou por alguma eventual
deficiência do mercado português. O que eu faço, poderia fazer em
qualquer parte do mundo porque tudo funciona através da Internet.

Quanto a reconhecimento pessoal, felizmente não tem sido necessário. O
que mais tem influenciado é o valor proporcionado a outros pelo meu
trabalho no site.

Se o site proporciona valor aos utilizadores, eles vêem ao site.
Consequentemente, os utilizadores proporcionam retorno em relação aos
componentes que publico, e também receita gerada sob a forma de
publicidade paga por anunciantes, ou assinaturas de serviços pagas pelos
utilizadores.

Em relação a Portugal, como não tenho estado no país, talvez não esteja
em posição de comentar a situação hoje em dia. Mas enquanto vivi em
Portugal, notava um certo pessimismo e desencorajamento dos portugueses
em relação às iniciativas doutros portugueses. Lamentavelmente, eu mesmo
tinha essa atitude para com outros portugueses.

Hoje em dia, tenho uma visão de Portugal de fora para dentro. Vejo que
Portugal está muito bem numas coisas e menos bem noutras, mas em geral
evoluiu muito, especialmente depois que entrou na comunidade europeia.
Isso é bom, mas parece que quem vive em Portugal sempre tem algo com que
se queixar.

A impressão que tenho é que os portugueses em geral são muito
desconfiados em relação a tudo que se anuncia, mas ainda não está feito.
Portanto, penso que para alguém obter reconhecimento, tem de falar menos
e mostrar mais obra feita. Com obra feita vem o reconhecimento e a
credibilidade.





José Franco > Um projecto desta dimensão comporta um trabalho árduo de gestão .
Quantos elementos compõem a equipa e de que forma é feita a gestão do
sistema?
Manuel Lemos > Na verdade, no momento este ainda é um projecto tipo "tudo eu". Apesar
de ter criado uma empresa para gerir o negócio do site, eu desenvolvi e
montei tudo. Apenas a parte de contabilidade e alojamento do site é
sub-contratada.

Este também foi um factor critico para viabilizar o site. Não ter
funcionários não é algo normal numa empresa, mas foi algo necessário.

Decidi não buscar qualquer tipo de financiamento ou aceitar
investimentos de terceiros, não só porque o site está focado num mercado
nicho, como também não pretendo perder o controle das operações .

A forma de manter o site em funcionamento sem necessitar de funcionários
foi de investir no desenvolvimento de ferramentas e processos
inteligentes que tratam de tudo, ou quase tudo, de forma automática,
minimizando assim a necessidade de intervenção humana.

Uma das ferramentas que desenvolvi foi o Metastorage, que mencionei
acima, mas existem outros recursos automáticos postos em pratica.

Assim sobra mais tempo para as tarefas que realmente necessitam de
tratamento pessoal, como moderação de conteúdo, dar apoio técnico aos
utilizadores, negociar com patrocinadores e anunciantes directos, etc...


José Franco > Apesar de estarmos na cauda da Europa em todos os dominios,
como estamos no dominio tecnolologico e inovação ?
Manuel Lemos > A impressão que tenho é, como mencionei antes, que Portugal está bem
numas coisas e menos bem noutras. Mas no geral, tem evoluido bastante ao
longo do tempo.

Penso também que existe um certo exagero dado na relevância de noticias
que mostram que Portugal está na cauda da Europa. É verdade que em
termos comparativos com outros países Europeus, de acordo com alguns
estudos, Portugal não está bem classificado dentre todos países europeus.

Acredito também que existem outros estudos que mostram que Portugal está
bem noutros aspectos, mas talvez pelo tal pessimismo e desconfiança
típica do português que mencionei antes, esses estudos não são
divulgados com a devida relevância pelos meios de comunicação social.

Penso que talvez fizesse falta uma campanha para aumentar a auto-estima
dos portugueses e a maneira como olham para as iniciativas de
portugueses que investem em Portugal. Os maiores beneficiados são os
próprios portugueses que vivem em Portugal.


José Franco > Embora o PHP seja uma tecnologia robusta, fiável e gratuita, porque razão
as empresas contiuam a usar tecnologias pagas ?
Manuel Lemos > Penso que muitas empresas não têm poder de decisão sobre as tecnologias
que usam porque a área de TI não é o seu forte. Acabam por sub-contratar
outras empresas e por isso adoptam as tecnologias que as empresas
sub-contratadas entenderem.

Essas empresas sub-contratadas ganham comissões na revenda de licenças
de tecnologias e produtos comerciais. Por isso têm mais interesse em
empurrar esses produtos comerciais, mesmo que não sejam o que melhor
atende os seus clientes.

Acredito que PHP e tecnologias Open Source em geral tem maior
penetração em empresas que têm áreas de desenvolvimento e TI próprias.
Com competências internas em produtos Open Source, as empresas podem
economizar muito em licenças e investir mais em tornar os seus produtos
mais competitivos em Portugal e no resto do mundo.

Isso é verdade com empresas de todos tamanhos. Veja-se por exemplo o
caso do Google que usa exclusivamente Linux em dezenas de milhares de
servidores espalhados pelo mundo para disponibilizar os seus serviços
pela Internet. Se tivessem que pagar licenças de sistemas operativos
comerciais, a conta seria bem mais amarga.

Em vez disso, O Google aposta na contratação e qualificação de
engenheiros capacitados no domínio de Linux e outras tecnologias Open
Source, permitindo focarem-se mais em produtos e serviços que maximizam
o seu lucro, e não o lucro de empresas sub-contratadas ou que vendem
licenças de software comercial.


José Franco > Que desafios enfrenta a linguagem nos próximos tempos, na tua opinião ?
Manuel Lemos >Neste momento existe uma grande dificuldade na adopção do PHP 5. Mesmo
apesar de se ter anunciando o fim de novos desenvolvimentos do PHP 4
este ano, após de 3 anos do seu lançamento, a adopção do PHP 5
situa-se nos 23% contra 76% do PHP 4. A adopção do PHP 5 cresce apenas
ao ritmo de 1% ao mês, que muito provavelmente é inferior ao ritmo de
crescimento do uso de PHP no mundo.

Esta situação atrasa a migração de projectos antigos e o desenvolvimento
de novos projectos novos em PHP 5, dado que limita a disponibilidade de
servidores de mais baixo custo para alojamento de aplicações em PHP 5.
Consequentemente, muitos projectos acabam por não migrar para PHP 5.

O custo do alojamento com PHP 5 talvez seja um problema menor. Penso que
o problema maior é o receio de quebra de compatibilidade de aplicações
com PHP 5. Se uma aplicação precisa ser muito alterada para funcionar em
PHP 5, isso impõe um custo de migração que os donos de sites não querem ter.

Para além disso, o PHP 6 que deverá ser lançado muito provavelmente em
2008, vai introduzir o Unicode como forma padronizada de representar
texto.

Ainda não se sabe o impacto que isso vai ter na migração de
aplicações que usam versões actuais. Se o PHP 6 exigir mudanças no
código das aplicações para as tornar compatíveis, isso pode agravar o
problema da adopção do PHP 6, talvez mais do que no PHP 5.


José Franco > Que conselhos deixas aos programadores portugueses ?
Manuel Lemos > Resumidamente, recomendo que se foquem na sua capacitação o mais cedo
possível, não só em PHP, mas em engenharia informática em geral.

Para além disso recomendo que façam desde o inicio das suas carreiras
uma escolha muito importante, que é se querem viver o resto da vida a
trabalhar nas empresas de outros, ou por outro lado, pretendem um dia
estabelecerem-se por conta próprio no seu negócio.

Para os que pretendem trabalhar para outros, terão menos riscos, mas
precisaram de focar as suas carreiras a construir um currículo sólido
que seja valorizado no mercado que pretendem trabalhar. Busquem e
aproveitem as oportunidades todas que conseguirem para ir fazer, cursos,
estágios ou mesmo empregos fora do país. Não esperem terminar os seus
cursos superiores para buscar essas oportunidades.

Para os que têm espírito mais empreendedor, recomendo que comecem cedo,
mas de preferência com os pés no chão. Mesmo fazendo cursos superiores
em áreas tecnológicas, tentem complementar a sua formação e experiência
em áreas administrativas.

Não foquem os seus esforços somente nas possibilidades de obter de
grandes lucros. Normalmente aliado a grandes lucros, vêem grandes
riscos. Negócios associados a grandes riscos têm maior probabilidade de
falhar e assim levar a grandes prejuízos.

Por vezes é mais prudente começar a focar-se em pequenos nichos que não
precisam de grandes investimentos nem de capital de terceiros.

Em qualquer dos casos, penso que qualquer profissional deve focar-se em
satisfazer necessidades de outros. Só assim outros se motivam a pagar
pelo valor que os seus produtos e serviços podem agregar aos seus
patrões ou clientes.


]]> http://www.revista-php.net/artigos.php?pagina=50 O código seguinte é uma exemplo muito simples de verificar se um campo está vazio apresentando a respectiva mensagem de erro ao utilizador.
<?php
    
   /********************************************
    Autor    : José Franco
    Data     : 04 Maio de 2008
    Lisenca  : Creative Commons 
    Distro   : Verificar campos vazios no PHP-GTK2
    ***********************************************/ 
    //cria a janela
    $Janela = new GtkWindow;
    $Janela->set_title("Validando campos no PHP-GTK");
    $Janela->set_position(Gtk::WIN_POS_CENTER);
    $Janela->connect_simple('destroy', array(Gtk,  'main_quit'));
    // container
    $CaixaV = new GtkVBox();
    //caixa de texto
    $CaixaT  = new GtkEntry;
    
    //botao
    $Botao = new GtkButton("Guardar");
    /*******************************************************
     * liga o botao àfuncção OnSalvar e envia o parametro
     * do tipo objecto onde o texto foi escrito (GtkEntry)
     *******************************************************/
    $Botao->connect_simple('clicked', 'onSalvar',$CaixaT);
    
    // coloca os objectos no container
    $CaixaV->pack_start($CaixaT,0,0);
    $CaixaV->pack_start($Botao,0,0);
    $Janela->add($CaixaV);
    // mostra o conteúdo na janela
    $Janela->show_all();

  /*******************************************
  * A função OnSalvar obtem a string digitada
  * na caixa de texto e invoca a mensagem de erro
  * no caso do campo estar vazio
  *********************************************/
  function onSalvar(&$caixa){
  $str = $caixa->get_text();
   if(empty($str)) alerta("Indique o nome do cliente !");
  
  }
  
  
   /***************************************************
   *   Cria a janela de alerta 
   *  A fução usa o construtor GtkDialo que mostra uma
   *  pequena janela e permite adicionar mensagens nesta
   * O botão usado é instanciado dos GTK::STOCK buttons
   * que generalizam botões previamente tratados , com uma
   * imagem neste, sendo mais facil ttar com os sinais que 
   * emitem (RESPONSE_XX)
   ****************************************************/
   function alerta($info){
    $popup = new GtkDialog(
    "Alerta",
    NULL,
    Gtk::DIALOG_MODAL,array(Gtk::STOCK_OK, Gtk::RESPONSE_OK));
    $popup->set_size_request(150,100);
    $msg = new GtkLabel($info);
    $topArea = $popup->vbox;
    $topArea->add($msg);       
   
    $popup->show_all();
    $rs = $popup->run();
   if($rs ===Gtk::RESPONSE_OK){
      $popup->destroy();
      }
   }
  //loop de eventos na aplicação
  Gtk::main();


?> ]]> http://www.revista-php.net/artigos.php?pagina=51 A partir da versão do PHP3 , este deixou de ser apenas um módulo funcional do Apache , para dar lugar a interpretador que nos permite executar aplicações em modo gráfico como é o caso do PHP-GTK ou em modo texto , com no exemplo apresentado neste artigo.
Se é utilizador de Windows uma das formas de testar este script é usando o PHP-GTK, a partir da linha de comandos, embora possa usar o Gnope, que também é utilizado para executar aplicações no PHP-gtk com mais facilidade.
No Linux corra o script normalmente pela bash. Para lermos dos dados do buffer do teclado vamos utilizar a função fgets, que aguarda a entrada de dados através duma opção válida.

<?php

   /********************************************
    Autor    : José Franco
    Data     : 04 Maio de 2008
    Lisenca  : Creative Commons 
    Distro   : Calculadora PHP na linha de comandos
    ***********************************************/ 

$fp = fopen("php://stdin","r");

$ecra  = "|-------------------------------------------------|\n";
$ecra .= "|         CALCULADORA NA LINHA DE COMANDOS        |\n";
$ecra .= "|                                                 |\n";
$ecra .= "|       ESCREVA A OPERAÇÃO QUE DESEJA EFECTUAR    |\n";
$ecra .= "|                                                 |\n";
$ecra .= "|       OPCAO   -----------------  OPERACAO       |\n";
$ecra .= "|         1     --------------->  SOMA            |\n";
$ecra .= "|         2     --------------->  SUBTRACCAO      |\n";
$ecra .= "|         3     --------------->  MULTIPLICACAO   |\n";
$ecra .= "|         4     --------------->  DIVISAO         |\n";
$ecra .= "|                                                 |\n";
$ecra .= "|-------------------------------------------------|\n\n";
print $ecra;
$opcao  = fgets($fp,10);

printf("Digite o primeiro numero ?\n");
$num1 = fgets($fp,100);

printf("Digite o segundo numero ?\n");
$num2 = fgets($fp,100);

($opcao==1 ? $rs = $num1+$num2 : 
($opcao==2 ? $rs = $num1-$num2 :
($opcao==3 ? $rs = $num1*$num2 :
($opcao==4 ? $rs = $num1/$num2 :  exit()))));

print "Resultado da operacao : ". $rs; 


?> ]]> http://www.revista-php.net/artigos.php?pagina=52
Neste artigo iremos apreender como criar um formulário de envio de dados utilizado o Ajax, PHP e MySQL.

Para que perceba o que iremos criar é conveniente que leia este artigo que explica de forma simplificada a forma como são processados os pedidos via XMLHttpRequest no Ajax. Mas antes de passarmos à construção do formulário leia e teste o script que está neste artigo, que explica como processar dados com PHP e Ajax. Agora sim , vamos então passar à construção do script. Vamos guardar o código Ajax num ficheiro do tipo *.js e invocar o código da seguinte forma:



<script language="JavaScript1.1" src="ajax.js"></script>



.

Ficheiro ajax.js


// JavaScript Document

var pedido = null;
function myAjax(pagina)
{
try {

 //cobre versão Firefox, Opera , Safari
  pedido = new XMLHttpRequest();
  pedido.onreadystatechange = pedidoStatus;
  pedido.open("GET",pagina,true);
  pedido.send(null);

  
} catch (tentaIEversaoNova) {
  try {
   // versões novas do IE
    pedido = new ActiveXObject("Msxml2.XMLHTTP");
    pedido.onreadystatechange = pedidoStatus;
    pedido.open("GET",pagina,true);
    pedido.send();
    
  } catch (tentaIEversaoAntiga) {
    try {
    // versões antigas do IE
      pedido = new ActiveXObject("Microsoft.XMLHTTP");
      pedido.onreadystatechange = pedidoStatus;
      pedido.open("GET",pagina,true);
      pedido.send();
      }catch (falha) {
      pedido = null;
     
    }
  }
} 
  if (pedido == null)
  alert("Não foi possível criar o objecto !"); 
}

function pedidoStatus()
{
  // completou o pedido ...
if (pedido.readyState == 4)
{
 // e o correu tudo bem no servidor
if (pedido.status ==200)
{

// o servidor responde em formado de texto plano no div  conm id 'resultado'
document.getElementById('resultado').innerHTML = pedido.responseText;
}
else
{
// em caso de erro mostra mensagem
document.getElementById('resultado').innerHTML = 
"<font color='red'><strong>Erro ao processar o pedido<strong></font>";
}
}
}





Formulário para login (index.html)

<form>
<div align="center"><span class="formtexto">Utilizador</span> 
<input  name="login" type="text" class="formtexto" value="">
<br>
<span class="formtexto">Password</span> 
<input class="formtexto" type="password" name="password"  value="">
<input name="submit" type="button" onClick="Login(this.form)" class="formbotao" value="Entrar">
<input  type="reset" class="formbotao" value="Limpar">
<br>
</div>
</form>

Nesta página vamos empregar o mesmo método para receber as mensagen do processamento no Ajax. Para isso coloque o seguinte código HTML numa zona da sua página antes ou depois do formulário , entre as tags body desta página

 <div id="resultado"></div>

Repare que ao carregar no botão enviar este está ligado à função "Login" , que tem como parâmetro o objecto formulário (this.form) A função "Login" , deve ser colocada na zona onde invocamos o ficheiro do ajax, e tem a seguinte declaração.



<script language="JavaScript" type="text/javascript">
var pagina;
function Login(f){
  login = f.login.value;
  pass = f.password.value;
  if(login==''){
     alert('Indique o seu login');
  }
   else if(pass==''){
    alert('Indique a sua password');
  }
  else{
   pagina = "form.php?login="+login+"&pass="+pass;
   myAjax(pagina);
   }
 }
</script> 




Esta função recebe os dados do formulário e verifica se existem campos vazio, alertando nesse caso o utilizador para proceder ao seu preenchimento. Se tudo estiver ok , a password e o login são enviados via Ajax è página onde desejamos obter esses dados, no meu exemplo à página form.php e leva como parâmetros de url a password e o login. A página form.php , recebe esses dados e faz os procedimentos de ligação à base de dados para verificar se o utilizador quer tenta fazer login está registado no sistema.

Ficheiro form.php

<?php
// instancia  a uma classe que liga  ao servidor de dados
$db = new mysql();

/*************************************
  Login no sistema
 ************************************/ 
 // obtem os dados via ajax
 if(isset($_GET["login"]) AND isset($_GET["pass"])){
   
    // evita inserções indejadas (código malicioso)
    $login = stripslashes($_GET["login"]);
    $pass  = stripslashes($_GET["pass"]);
    // executa o pedido para verificar se o utilizador
    // está registado no sistema
    $rs = $db->query("SELECT * FROM login WHERE login='"
    .$login."' AND password='".md5($pass)."'");
    // o utilizador existe
    if($db->rows($rs)>0){
    // inicia a sessão
    session_start();
    // regista a variável de sessão
    $_SESSION["login"]= $login;
    // esta mensagem será o resultado do pedido via 
    //Ajax e logo será mostrada ente a div 'resultado'
    echo "<div class=\"formtext\">Bemvindo "
    .ucfirst($login)." , clique <a href=\"admin.php\" target=\"_self\">aqu&iacute; 
    </a>para aceder &agrave; zona adminstrativa</div>";

}else{
  // ... bem como esta se a condição se verificar
  echo alerta("Parceiro n&atilde;o registado no sistema");
  }

}


?>

Para fazer a ligação vai necessitar de criar um pequeno recurso de ligação. No meu exemplo eu criei uma pequena classe (compativel com PHP4), para fazer a gestão dos pedidos ao servidor MySQL.



Ficheiro mysql.php

<?php


class mysql{
   var $conn;
  
   function mysql(){
   $this->conn = mysql_connect(HOST,USER,PASS) or die(mysql_error());
        mysql_select_db(DB,$this->conn) or die(mysql_error());
   }
   
   function query($rs){
   return mysql_query($rs,$this->conn);
   }
   

   
   function rows($rs){
   return mysql_num_rows($rs);
   }
}


?>

Separadamente criei ficheiro com as configurações , de forma a ficar mais fácil alterar sempre que haja necessidade de fazer alterações. Esse ficheiro deve ser invocado antes de fazer a instância à classe mysql . Pode inclui-lo no ficheiro "form.php", assim require_once("configs.php");
Faça da mesma forma para o ficheiro mysql.php, de forma a poder instanciar a classe.


Ficheiro configs.php

<?php
// o seu servidor
define("HOST","localhost");
//utilzador 
define("USER","root");
// password
define("PASS","");
// a base de dados
define("DB","teste");

?>

Não se limite a copiar e aplicar , estude a improvise novas formas de utilizar o código. Dúvidas e sugestões comentem abaixo.]]> http://www.revista-php.net/artigos.php?pagina=53 Afim de evitar o envio de SPAM criei esta função que é de muita utilidade na hora de utilizadores sem escrúpulos enviarem as suas mensagens.

Espero que tenha utilidade,e se tiverem alguma ideia para tornar a função mais robusta não hesitem em comentar. ]]> http://www.revista-php.net/artigos.php?pagina=54
O php.ini é o ficheiro onde são definidas as configurações de ambito geral no PHP (similar o global.asa do ASP). Imagine-se por exemplo que configuramos as extensões no directório c:\pasta1\ext.

Contudo no acto da instalação o utilizador decide por instalar a aplicação num outro qualquer directório , por qualquer razão.

Um dos primeiros problemas seria logo no acto de carregamento das extensões.

Por esta e por outras razões , torna-se útil criar o ficheiro php.ini de forma automatizada , aproximado-se o mais possível da configuração pessoal de cada sistema.

Este problema surgiu-me, quando um destes dias necessitei de desenvolver um aplicativo de base de dados MS SQL, cujo problema da configuração personalizada do php.ini imediatamente se levantou.

A construção do ficheiro não é nada de complexo, apenas bastando obter o caminho do directório para o ficheiro , com a função dirname() e concatenado todo o texto com instruções válidas e necessários à configuração da nossa aplicação.

Em seguida segue-se um exemplo muito simples e funcional da forma como conseguir a criação do ficheiro. Note que poderia criar o php.ini com as directivas que desejar , desde que válidas e reconhecidas pelo Apache.



]]> http://www.revista-php.net/artigos.php?pagina=55 <?php
/************************************
* www.revista-php.net 
* José Franco
* 11 de Junho de 2008
************************************/
//usa a definções locais de data e hora
setlocale(LC_TIME, NULL);
// faz a formatações de acordo com as definições locais
echo strftime("%A, %d de %B de %Y");

?>

Resultado :
quarta-feira,11 de Junho de 2008]]> http://www.revista-php.net/artigos.php?pagina=56
Os sites em cujo alojamento é gratuito muitas vezes não conferem esse suporte. Mesmo por muitas outras razões é útil construir a base de dados a partir dum único ficheiro
Neste artigo vamos apreender como criar as tão vulgares base de dados designadas CVS(Comma Separated Values )
O primeiro passo é então construir a base de dados. Abra um editor de texto , e coloque e valores separados por vírgula da seguinte forma.

Guto,30, Portugal
Helena,26,USA

Em seguida guarde o ficheiro com o nome bd.txt.
Agora vamos então criar o mecanismo de aceder ao ficheiro de texto e manipular os dados que aí se encontram.

Segue-se a programação do sistema para aceder ao ficheiro , com as instruções comentadas junto com o código.

<?php
/**********************************
 José Franco
 16 de Junho 2008
 REVISTA PHP :: www.revista-php.net
 Under Creative Commons
 *********************************/


// nome do ficheiro
$db ="bd.txt"; 

// a variável $fp contem o recurso de ligação
if(!$fp = fopen($db,"r")){
// no caso de occrer erro de leitura
echo "Erro ao tentar aceder à base de dados";

}else{

$c =0; // permite contar o numero de linhas no ficheiro 
       // pode ser visto como uma espécie de ponteiro
$arr = file($db); // obtem toda a informação no ficheiro

// percorremos os dados
foreach($arr as $str){
// e obtém o acesso a eles por intermédio 
// da função list em paralelo com explode, que
// separa os valores considerando a virgula como dividor
// Cada um desses dados é colocado em  3 novas variáveis do tipo
// array às quais acedenos por intermédio do ponteiro (contador $c)
list($Tnome,$Tidade,$Tcidade) = explode(",",$str);
     $nome[$c]    =  $Tnome;
     $idade[$c]   =  $Tidade;
     $cidade[$c]  =  $Tcidade;
   $c++;
}
// némero de registos 
echo "<b>Existem ".$c." registos na BD</b>";
// aceder aos elementos da primeira linha
echo "<hr><br>";
echo "O cliente ".$nome[0]." , vive em ".$cidade[0]. " e tem ".$idade[0]." anos";
   
 }

?> ]]> http://www.revista-php.net/artigos.php?pagina=57 Muitos de nós gostariam de possuir um site multi língua, pois alé de alargarmos o domínio ao número de visitantes ao site, confere uma aparência mais profissional.
Para construção desta funcionalidade vamos utilizar a opão de tradução para duas línguas.
O primeiro passo é criar o ficheiro pt.php e este deve ser nomeado exactamente como o nome acima. Nesse ficheiro vamos armazenar o texto que queremos mostrar na página onde a tradução é invocada. No meu exemplo eu recorri ao uso de constantes

<?php
// constante que contem o texto a ser invocado para tradução
define("HELLO","Bemvindo ao site da Revista PHP");

/***********************************************************
Ou por opção poder-se-ia utilizar variáveis

$texto ="Bemvindo ao site da Revista PHP";
***********************************************************/


?>



Salve como "pt.php" e proceda da mesma forma para o ficheiro "en.php" adicionando o seguinte código.

<?php
define("HELLO","Welcome to the  Revista PHP website");
?>


Agora vamos criar o ficheiro teste.php, onde vamos construir o procedimento para fazer a alteração na opção de linguagem.

Aí vamos criar os links e o mecanismo como as os ficheiros são carregados.

Segue o código comentado ]]> http://www.revista-php.net/artigos.php?pagina=1 # Transacções atómicas, consistentes, isoladas, e duráveis (ACID) mesmo até quando o sistemas falha devido a quebra de energia.
Nenhuma configuração - não necessita instalação ou pianel de controlo
Implementa a maioria das normas padrão SQL92.
Uma base d eaddos completa é armazenada num simples ficheiro
As base de dados podem ser partilhadas ente máquinas com diferente ordem de bits
Suporta base d edados acima dos 2 tebibytes (241 bytes) em tamanho
Strings e BLOBs acima dos 2 gibibytes (231 bytes) em tamanho
# Arquitectura base necessária bastante reduzida 400Kib
Mais rápido face aos sistemas de base dados cliente/servidor na maioria das operações
# API de fácil uso
# Implementações TCL incluídas As implementações para as várias linguagens estão disponiveis de forma separada.
Código bem comentado e testado com cobertura d etestes superior a 95%
# Sem dependências
Código fonte de dominio público. Pode usá-lo para o que quiser.

O prestigio reconhecido a esta tecnologia atinguí o apogeu quando o seu criador Richard Hipp, foi reconhecido com o prémio atribuido pela Google e pela colossal editora O´REILLY com o prémio "Open Source Award Winner" em 2005.
Este feito foi o projectar para que muitos utilizadores passasem a pelo menos testar e verifcar as funcionalidades que a tecnologia proporcionava, e o certo é que muitos passaram a utilizá-la com frequência, não só devido à facilidade de gestão mas à sua rápidez e portabilidade.
om o surgimento do PHP- GTK (a livraria que permite criar aplicações gráficas), o SQLite, teve junto dos programadores PHP o merecido reconhecimento e passou a ser utilizado em massa.
]]> 28 Março 2007 http://www.revista-php.net/artigos.php?pagina=2 As dúvidas surgem logo no patamar da implementação, cujo requesíto passa por um conhecimento genérico da linguagem XML. A classe seguinte permite fazer o teste ao ficheiro xml gerado.Tendo como exemplo um qualquer programa de facturação, o processo seria utilizar este parser para fazer a validação do XML, "cuspido", pelo programa.
Por exemplo no caso do SAFT-PT, se usarmos o ficheiro XSD fornecido no site da ASSOFT , para fazer a validação basta informar o nome do ficheiro XML e o nome do ficheiro XSD, se ocorrerem erros o parser abaixo mostrará no browser os Warnings correspondentes aos erros ocorridos .

O suporte da revista PHP, tem à sua disposição um serviço de consultoria que lhe permite adaptar as suas aplicações de facturação e contabilidade a funcionar em base de dados access ou mysql , dum módulo simples para exportação da informação , gerando um SAF-T válido.
Não hesite em contactar-nos.]]> 26-10-2007 http://www.revista-php.net/artigos.php?pagina=3 feed e pode ser guardado em alguns formatos como .xml, .rss ou .rdf (é possível que existam outras extensões).

Para ler os conteúdos de qualquer feed pode utilizar uma ferramenta de leitura de feeds, conhecidos como RSS Readers. Existem em versão online ou ambiente gráfico. Eu aconselho o Google Reader, que pela sua simplicidade , é muito prático e robusto. A classe que eu criei a seguir permite criar ficheiros rss , sem a necessidade de ter que apreender XML. A classe é distribuída com licença GPL, podendo usá-la de forma gratuita. Apenas deixe os créditos atribuídos ao autor . O código foi devidamente comentado, para que entenda o que o código faz em cada passo.]]> 28 Outubro 2007 http://www.revista-php.net/artigos.php?pagina=4 aquí ]]> 28 Outubro 2007 http://www.revista-php.net/artigos.php?pagina=5 Seguem-se algumas operações básicas com PHP no código abaixo. Se está interessado em testar estes códigos deixo uma recomendação. Instale o EasyPHP disponível em aquí. Num outro artigo ensinarei como instalá-lo e fazer algumas configurações básicas. Primeiramente vamos criar uma base de dados e uma tabela simples sob a qual iremos operar. Para testar o resultado deste código clique aquí ]]> 21 Novembro 2007 http://www.revista-php.net/artigos.php?pagina=6

Utility	Consistency	Examples
Good (87.5%)	Good (93.8%)	Good (81.3%)

Tabela 1 : Votação atribuída pelos utilizadores do site PHPClasses ]]> 23 Novembro 2007 http://www.revista-php.net/artigos.php?pagina=7 O código abaixo está devidamente comentado , para que possa compreender cada passo no código. Para testar o sistema clique aquí]]> 26 Novembro de 2007 http://www.revista-php.net/artigos.php?pagina=8 02 Dezembro http://www.revista-php.net/artigos.php?pagina=9 Cuidado com as validações Alguns ataques têm como alvo o sistema de login ou formulários onde os dados são submetidos, e no caso onde a segurança é inválida ou deficiente, o atacante pode processar código malicioso - SQLinjection - e aceder a áreas supostamente protegidas, apoderando-se de informações confidenciais.
Utilizando o Google e digitando
allinurl:admin/login.asp ou (*.php)
é possivel encontrar sites vulneráveis, e com os códigos sql
' or '1 ou 'or'.11'='.11
é possível que se aceda a zonas que por norma não de deveria aceder. Neste caso a explicação desta falha é muito simples. Analizemos um exemplo, no qual o processar do código processa o estado de autentificarão para um utilizador que enviou os seus dados pelaárea de login. Assim no php teríamos algo como
$sql = " SELECT login, passw, status FROM membros WHERE login='".$_POST["login"]."' AND password = '".$_POST["passw"]."' ";
Suponhamos que o comando era mais extenso
$sql = " SELECT * FROM membros WHERE login='".$_POST["login"]."' AND password = '".$_POST["passw"]."', AND cidade='".$_POST["cidade"]."' ";
Se o atacando enviar o código SQL acima e este for processado directamente no pedido sql, este vai criar um efeito de travão válido do pedido, pois mesmo que essa consulta tenha mais comandos ela ignora-os e devolvo o pedido como válido.
Ao executar o pedido $sql, temos que 1=1 o que é verdade , e o comando -- , não deixará que o restante pedido seja processado. Ao processar como login válido, o atacante entraria no site sem sequer nunca ter feito registo e faria o que quisesse, pois numa área administrativa , isto dá-lhe o totaldos privilégios.
Para evitar que seja feito sql no seu site , o php dispõem de funções permitem implementar métodos de segurança. No nosso exemplo iremos usar a directiva get_magic_quotes_gpc() , que analisa o estado das barras , activo ou desactivo. Ao detectarmos o seu estado podemos depois escapar com barras, ao código malicioso, tornando-o inofensivo. Para escapar escapar a esse código utilizaríamos a função addslashes(), que no caso anterior ficaria \' or \'1 , o que não dava qualquer efeito ao comando e o pedido seria uma condição falsa. Juntando tudo, imaginemos que temos os dados seguintes enviados como o método POST num formulário qualquer
O video abaixo mostra como aplicar esta técnica
Com isto teríamos um código mais protegido evitando possíveis ameaças. ]]> 4 Dezembro 2007 http://www.revista-php.net/artigos.php?pagina=11
Guardar HTML numa variável
$html = "<form name='form1' action='{$_SERVER['PHP_SELF']}' method='post'>
<input type='submit' name='enviar' value='Enviar'>
</form>";
echo $html;
ou por concatenação, assim
Concatenar código HTML
$html = "<form name='form1' action='{$_SERVER['PHP_SELF']}' method='post'>";
$html .= "<input type='submit' name='enviar' value='Enviar'>";
$html .= "</form>";
echo $html;

Contudo, na igualdade , como na concatenação, o código exige que tenhamos alguns cuidados com as plicas em ambos, e com o"parsing" das variáveis na concatenação,visto que em 10 linhas o trabalho não é significativo, mas em 200 linhas de código já constituí uma tarefa com algum trabalho e tempo necessário. Para a maioria dos programadores , que tal como eu utilizam o Dreamweaver sabe que o código html é facilmente gerado, visto que esta ferramenta gera de forma automática o início e o fim da tag html. Esta funcionalidade do programa, juntamente com a propriedade HEREDOC que temos disponível no PHP, juntas fazem maravilhas, quando queremos embeber e guardar código html numa variável php. Isto deve-se porque a propriedade HEREDOC, dispensa o inicio e fecho de aspas e deste modo estamos dispensados de formatar o código no caso do HTML puro. Vamos construir um pequeno formulário de modo a exemplificar: O primeiro passo seria construir o formulário com uma ferramenta IDE, por exemplo o Dreamweaver. O código HTML puro criado no Dreamweaver seria por exemplo este:]]> 20 Dezembro 2007 http://www.revista-php.net/artigos.php?pagina=13 17-01-2008 http://www.revista-php.net/artigos.php?pagina=17 Após a instalação do servidor, uma das primeiras dificuldades que surgiram, foi como fazer a alteração das permissões associadas aos ficheiros ou directórios.
Após alguma pesquisa no Google, encontrei uma vasto conjunto de informação relativa ao comando chmode (CHANGE MODE), o comando Unix/Linux que permite fazer a gestão das permissões de leitura e escrita e executa as permissões para um directório ou ficheiro.
Como iniciantes temos sempre a ajuda associada a cada comando. Assim para invocar a ajuda bastaria chmode --help ler com atenção a forma como prodemos utilizar cada uma das sintaxes permitidas.
A sintaxe genérica do comando é dada por chmode [permissões] arquivo (como prefiro chamar-lhe devido à ambientação com Linux)
Este comando pode ser invocado e associado a um conjunto de opções, como:
* -r afecta também as subdirectorias
* -v mostra cada ficheiro a ser processado
* -c mostra apenas os ficheiros que sofreram alterações

Para entendermos como este comando pode ser utilizado será melhor percebermos como as permissões são atribuídas a cada ficheiro ou directório.

A permissão Read tem o valor 4 , a Write o valor 2 e O Execute o valor é 1.
A permissão total do arquivo é obtida somando esses 3 números Um ficheiro com permissão de leitura (Read) assume o valor 4.A permissão de escrita (Write) assume o valor 2, A permissão Execute assume o valor 1. Vejam-se alguns dos exemplos mais comuns
chmode 777 (nome_ficheiro) - neste exemplo quer o proprietário, para o grupo, como os restantes utilizadores têm permissões quer de leitura (Read) , quer de gravação (Write), como de execução (Execute) chmode 755 (nome_ficheiro) - aquí o prorietário têm todas as permissões, mas o grupo e os outros utilizadores apenas têm permissão de leitura e execução. chmode 666 (nome_ficheiro) - Dá permissões de gravação e leitura a todos os utilizadores chmode 644 (nome_ficheiro) - atribuí leitura e gravação para o proprietário e apenas leitura para o grupo e restantes utilizadores
Vejamos então se o proprietário quiser todas as permissões, ficaria
Read + Write + Execute (4+2+1) Read + Execute (4+1) para o grupo (para ser Write teria de ser 4+2) e Execute para os restantes teriamos a seguinte exemplo chmode 751 (nome_ficheiro)

O chmode permite actuar sobre 3 grupos bem distintos, que são : 'u' - utilizador (user) 'g' - grupo (group) 'o' - outros (others)

Isto significa que podemos ou usar as letras (u , g, o) , ou o modo octal explicado antes. Estas letras são conjugas com as restantes r (read), w (write) x (execução)
Veja-se o seguintes exemplos:

chmode go=*
Remover todas as permissões ao grupo e outros utilizadores
chmode a=x *
dá permissões de execução a todos os utilizadores]]> 07 Fevereiro 2008 http://www.revista-php.net/artigos.php?pagina=18 Embora varie a sintaxe e declaração em cada uma , todas elas comportam mais ou menos os mesmos problemas; e quando surge uma inovação para uma, rapidamente os programadores arranjam formas de adaptar essa funcionalidade a cada uma delas, criando extensões, ou adaptando o código na mesma linguagem
.
Todas têm no entanto em comum o mesmo tipo de problemas. A maior parte das vezes a forma de resolver um problema numa determinada área passa por pesquisar se existe uma solução similar com problemas idênticos.
Foi o que se passou pela adopção dos Design Patterns, vulgarmente conhecidos na língua portuguesa como Padrões de Desenho ( ou modelagem) de Software.

Esta técnica consiste em “pegar” em soluções previamente testadas, e adoptá-las a problemas que ocorrem frequentemente em determinadas áreas e fases específicas, no processo de modelagem.
Embora exista muita bibliografia sobre o assunto, a filosofia das Design Patterns - como eu prefiro chamar-lhe – deve-se aos trabalhos pioneiros do Engº Cívil Chistopher Alexander, professor na Universidade da Califórnia, com os apontamentos periódicos que tirava, de problemas comuns ramo da construção em geral , e dos cerca de 200 edifícios que construiu em todos os continentes. Estas anotações foram adoptadas ao domínio da informática, pelos famosos grupo GOF (do inglês Gang of Four), devido ao facto de serem quatro os autores, com o livro “Design Patterns: Elements of Reusable Object-Oriented Software”, considerado a obra recomendada nesta matéria.

Actualmente as Design Patterns , são uma solução viável ao desenvolvimento de software , e existe muitíssima documentação e empregabilidade nas áreas Java e .NET, mas adoptados à maioria das linguagens de programação existentes, e o PHP não é excepção.
Neste artigo iremos demonstrar algumas técnicas de como utilizar os Design Patterns, concretamente à linguagem PHP, através da análise, debate e resolução dum problema concreto.
O requisito fundamental à construção das Design Patterns , passa essencialmente por possuir bons conhecimentos e experiência suficiente na programação orientada a objectos (em inglês Object Oriented Programming - OOP).
Características como herança, polimorfismo, agregação, abstraccionismo etc…, devem ser termos como os quais temos de estar familiarizados.

Seguindo as premissas relatadas no livro dos GOF , qualquer solução deve ser totalmente explicada , incluindo o pseudo-código, bem como UML respectivo se apropriado.

Existem sete problemas emergentes à construção das Design Patterns, e aos quais os GOF procuraram responder:

Estrutura do documento, Formatação, Flexibilidade da Interface, Suportar grafismos distintos, Suportar um sistema de múltiplas janelas, Operações do Utilizador, Verificar e hifenização de soletração.
As Design Patterns podem englobar-se genericamente em três categorias distintas:
Padrões de criação (em inglês Creational Patterns) .
são criados a partir da instanciação de classes , que podem ser devidos à criação dos padrões das próprias classes ou dos padrões à criação de objectos.

Neste artigo iremos centrar-nos neste tipo de Design Patterns, nomedamente os mais usados ;
o Singleton,
a Fabrica Abstracta de Objectos (Abstract Factory),
Protótipos ,
o Constructor (Builder)
e a
Fabrica de Métodos (Factory Method).
À medida que estudarmos cada um deles, descrever-se-á cada um deles e para que serve.
Padrões de estructura (Structural patterns)
Estes padrões abarcam a composição dos objectos e classes.
Existem padrões deste tipo bastante utilizados, como o Facade, Proxy, Bridge …etc.
Padrões de comportamento (Behavioral patterns)
Descrevem ou generalizam a forma como os objectos comunicam entre si.
Existe uma quantidade razoável de padrões de comportamento, mas alguns deles são bastantes conhecidos, como o Command , Interpreter, Iterator…etc

A possibilidade de programar com orientação a objecto , é possível desde a versão PHP5. Vamos agora estudar na prática a forma de desenvolver Design Patterns e de que forma podem ser utilizados e como facilitam o desenvolvimento de aplicações. No primeiro exemplo vamos estudar a utilidade do padrão Factory, cuja utilização permite adicionar funcionalidades à mesma e interface, podendo à posteriori criar instancias dinâmicas de acordo com as configurações ou requisitos do sistema. ]]> 09 Fevereiro 2008 http://www.revista-php.net/artigos.php?pagina=19 Ou é o utilizador que escolhe os dados de login no processo de registo no sistema, ou são atribuidos pelo administrador do sistema, ou ainda atribuídos pelo próprio sistema de forma automatizada.
Embora um sistema de login seja bastante mais complexo, (tendo em conta a segurança total do sistema), neste artigo vou ensinar como criar um sistema simples de login, utilizando Mysql para salvar as informações do utilizador e PHP para a programação do sistema. O primeiro passo é criar uma pequena base de dados uma tabela muito genérica. Segue-se um exemplo em SQL


CREATE TABLE `login` ( `id` INT( 11 ) UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY , `login` VARCHAR( 20 ) NOT NULL , `password` VARCHAR( 20 ) NOT NULL ) ENGINE = MYISAM ;


como neste artigo , o objectivo não é ensinar o processo de registo de utilizadores , vamos inserir um utilizador manualmente. ( *)
Agora o passo seguinte é construir o formulário para indicação dos dados, como o exemplo seguinte:
<blockquote><blockquote> <table border="0"> <tr><td> <fieldset> <legend><b>[ Login no sistema ]</b></legend> <form action="<?php echo $_SERVER['PHP_SELF'];?>" method="post"> <label for="login"> Utilizador </label><br> <input type="text" name="login"><br> <label for="login"> Password</label><br> <input type="password" name="password"><br> <input type="submit" name="entrar" value="Entrar no sistema"><input type="reset" value="Limpar"><br> </form> </fieldset> </td></tr><tr><td> <center><font color="red" size="2"> * Indique ambos os campos</font></center></td></tr> </table> </blockquote></blockquote>

A fase seguinte consiste em estabelecer uma ligação com a base dados, requisitando na tabela se os dados introduzidos coincidem com aqueles que dão acesso ao sistema. A primeira etapa desta fase é aguardar que se carregue no botão do formulário, que reserva a acção 'entrar'. if (isset($_POST["entrar"])), poderá então ser traduzido em linguagem formal, por: "Se o utilizador prime o botão << Entrar no sistema>>" . E o que acontece é :
obter os dados do formulário empregando o método post que é informado no formulário ( 1º passo)
Em seguida estabelece-se a ligação ao servidor MySQL e cria-se um pedido sql que 'varre' todos os registos da base de dados. Deve-se notar que a ligação ao servidor foi feita num ficheiro à parte. Carreguei apenas o ficheiro que contém definida essa ligação, armazenado o recurso de ligação na varável $conn. ( 2º passo)

No meu caso eu apenas tenho os dados de login referentes a um único utilizador, e assim sendo vou utilizar a função do mysql que permite afectar a cada coluna da tabela - a função mysql_fetch_object(), que devolve o valor referente ao objecto que estou a afectar em cada momento. Se por exemplo quiséssemos obter todos os dados da tabela, o melhor seria utilizar a função mysql_fecth_array(), e utilizar um while para varrer toda a tabela. ( 3º passo) Posto isto, vamos agora validar se os dados do formulário coincidem com que os que estão na base de dados (4 º passo) Repare a utilização de algumas funções que garantem a integridade dos dados. A função trim retira espaços antes e depois na string , a função strtolower coloca possíveis maiúsculas para minúsculas e a função md5 encripta a string utilizando a algoritmo md5 .

Se os dados estiverem correctos vamos criar uma sessão ( 5º passo). Isto pode ser útil para reconhecer o utilizador , ou saber que esteve activo num determinado período de tempo, ou ainda para facilitar o processo de logout do sistema (destruindo essa sessão). Repare que se os dados estiverem correctos podemos encaminhar o utilizador para outra página e já com a sessão iniciada. Por outro lado se os dados estiverem incorrectos, o sistema morre ou encaminha o utilizador para uma página de erro. (6º passo)
* Repare que eu introduzi manualmente na base de dados um utilizador com a password encriptada utilizado md5.]]> 09 Fevereiro http://www.revista-php.net/artigos.php?pagina=20 Vamos então afectar a linha id começando por mostra o primeiro registo da tabela na base de dados.
Seguidamente colocam-se as questões possíveis. Estamos no primeiro registo ? Então apenas faz sentido mostra um botão próximo.
De seguida prevêm-se as situações para as quais a navegação atinga o primeiro e último registo , incrementando ou decrementando o id , de acordo com cada situação. O código abaixo elucida bem estes conceitos.Recomendo apenas que não faça copy+paste , mas sim estude o código de forma a perceber o que faz cada linha. ]]> j24 Fevereiro 2008 http://www.revista-php.net/artigos.php?pagina=30 Os processos do padrão Singleton caracterizam-se por duas características gerais

- O construtor da classe por defeito não pode chamado, que irá ser chamado através de classe designada de método de manutenção, que assegura que apenas uma única instanciação seja feita num determinado período.

- Um membro da classe estática que assegura a referência para o identificador de recurso da classe existente.
Na classe que garante que a instancia única os método e atributos, são declarados como estáticos a fim de ser acessível fora do contexto do objecto. Isto significa que não é necessário instanciar a classe para referenciar o atributo ou o método dessa classe. Como os atributos e métodos estáticos não estão acessíveis através duma instância da classe, isto implica que a variável especial $this não pode ser utilizada e assim em seu lugar usa-se a variável reservada self.
A utilidade deste padrão reflecte-se em sistemas, cujas classes apenas necessitam de ser instanciadas uma única vez, como é o caso de estabelecer ligações à base de dados que trago neste exemplo. Já que manifestamente o intuito deste conceito de padrão de software procurar gerar código de alta qualidade/ rentabilidade (é aqui que entra a Engenharia de Software), o Singleton usa-se juntamente com o padrão Factory, evitando rescrever código em separado, e que com pequenas alterações no Factory , implementa a mesma funcionalidade.

O código seguinte apresenta um exemplo simples daquilo que pode ser uma classe que usa o Singleton. Repare que a classe não foi instanciada da forma tradicional, através do new - (exemplo 1.0) , e podemos mesmo assim fazer a respectiva instancia aos métodos fora do contexto dessa classe, como é apresentado no exemplo 1.1
]]> 19-04-2008 http://www.revista-php.net/artigos.php?pagina=31 Veja-se um exemplo simples
<?php 
include_once("mySQL.inc.php"); 
include_once("class_registo.php"); 
include_once("class_validacao.php"); 
require_once("class_calcula.php"); 
require_once("class_login.php"); 
include_once("class_sendEmail.php"); 
include_once("class_comentarios.php"); 
 /********* ..psssss que trabalheira   *******/
?>

Felizmente a partir da versão PHP5 , este problema deixou de existir, através da utilização __autoload() Para percebermos o uso da função criei duas classes que são guardadas em pastas distintas, onde coloquei cada uma delas.

<?php

class Teste1{

function __construct(){
   echo "Classe ".__CLASS__." diz olá <br />";
   }
   
   }
?>

<?php
class Teste2{

function __construct(){
   echo "Classe  ".__CLASS__." diz olá tambem ;)<br />";
   }
   
   }
?>

A função __autoload que proponho avalia se a classe informada existe nas pastas, e carrega-a a respectiva classe apenas quando é necessário, ou seja , quando é instanciada

<?php


  function __autoload($classe){
  $pastas = array("pasta1","classe1","classe2");
  
    foreach($pastas as $pasta){
      if(file_exists($pasta."\\".$classe.".php")){
          require_once($pasta."\\".$classe.".php");
          }
      }
   }
  
  
  new Teste1;
  
  new Teste2;

?> ]]> 19-04-2008 http://www.revista-php.net/artigos.php?pagina=36
<?PHP
 /*****************************************
  Autor   : José Franco
  Data    : 26 Abril 2008
  Licença : Creative Commons
  Distro  : Paginação com PHP
  Web     : www.revista-php.net
  *****************************************/

     $conn = mysql_connect("localhost","root","");
     mysql_select_db("revistaphp_net",$conn);
     
     $rs = mysql_query("SELECT * FROM  artigos", $conn);
     // total de artigos na Base  de Dados
    $nTotal = mysql_num_rows($rs);
    
    //fazendo as configurações de página 
    (!isset($_GET['pagina'])) ? ($pagina = 1) :($pagina = $_GET['pagina']); 
    
    
    // se o utilizador tentar nudar para um id inexistente
    if(@$_GET["pagina"] > $nTotal OR ! is_numeric($_GET['pagina'])){
    echo "<script>javascript:history.go(-1)</script>";
    }
    
    
    
    // numero de artigos por página
    $npp = 1;
    
    // pagina onde a paginação é aplicável
    $file = basename(__FILE__);
    
    // obtendo os artigos da Base de Dados
    $res = mysql_query("SELECT  titulo, corpo , autor FROM artigos ORDER BY id ASC LIMIT $pagina,$npp");
    
    // mostra os artigos a partir do id 
    while($linha = mysql_fetch_object($res)){
    echo "<h3>".$linha->titulo."</h3>";
    //echo  "".$linha->corpo."";
    echo "<br />";
    
    }
    /*******************************
     É permitido clicar 'Anterior' 
     enquanto a id da página for
     maior do que 1, caso contrário 
     estamos na 1ª secção dos artigos
     *********************************/
    if((int) @$_GET['pagina'] > 1 ){
    $antes =  ($_GET['pagina']-1);
    }else{
    $antes = 0;
    }
    

    
    
    /*****************************************
     Imprime o número de links de acordo
     com o numero total de artigos , tendo como
     critério a chave primária (id) da tabela
     ********************************************/
     // link para seguinte
    echo "<a   href=\"{$file}?pagina=".$antes."\"> Anterior <a>";
    for($i=1;$i<$nTotal;$i++){
   // aplicando estilo aos liks activos
    if(@$_GET['pagina']==$i){
    $style = "background:#FFCC00; text-decoration: none";
    }else{
    $style = "text-decoration:none;";
    }
    // cria todos os links
    echo "<a style=\"{$style}\" href=\"{$file}?pagina=".$i."\"> ".$i." </a>";
    }
    
    /*******************************************
     É permitido clicar 'Seguinte' 
     enquanto a id da página for
     mmenor do que o total de artigos, caso contrário 
     estamos na última secção dos artigos
     ***********************************************/
    if((int) @$_GET['pagina'] < $nTotal-1 ){
    $depois =  (@$_GET['pagina']+1);
    }else{
    $depois = $nTotal;
    }
    
    // link para seguinte
    echo "<a   href=\"{$file}?pagina=".$depois."\"> Seguinte <a>";
    

?>
]]> 26 Abril 2008 http://www.revista-php.net/artigos.php?pagina=43 Com o objectivo de facilitar essa tarefa criei este artigo, facilitando a forma de perceber como usar vectores (arrays) no PHP. Num outro artigo explicarei o tipo de arrays, e que diferenças existem entre eles.

<?php
    /**************************************
    Autor    : José Franco
    Data     : 27 Abril 2008
    Lisenca  : Creative Commons 
    Distro   : Operações com arrays no PHP
    ***************************************/ 
echo "<h2><font color='red'>
Carregar e aceder aos elementos dum vector(array)</font></h2>";
// carregando o array
$cidades = array("Lisboa","Porto","Coimbra","Guarda","Meda");

// aceder aos elementos do array
echo "<h4>Usando indice do vector</h4>";
echo $cidades[0]."<br>". // Lisboa
$cidades[1]."<br>". //Porto
$cidades[4]."<br />"; //Meda

// aceder usando ciclo for
echo "<h4>Usando ciclo for</h4>";
for($i=0;$i<sizeof($cidades);$i++){
echo $cidades[$i]."<br />";
}

// aceder usando ciclo com foreach
echo "<h4>Usando foreach simples</h4>";
foreach($cidades as $cidade){
echo $cidade."<br />"; 
}
// com foreach podemos facilmente aos indices dum array
echo "<h4>Usando foreach para obter indices e valores</h4>";
foreach($cidades as $chave => $cidade){
echo "Indice  - ".$chave." Valor - ". $cidade."<br />"; 
}
echo "<h2><font color='red'>
Adicionar novos elementos ao array</font></h2>";   
// essa tarefa fica simplificada com  função array_push

array_push($cidades,"Braga","Viseu","Castelo Branco");

// para imprimir o conteudo dum array podemos fazer da seguinte forma
echo "<pre>";
print_r($cidades);
echo "</pre>";

echo "<h2><font color='red'>Pesquisar um elemento no array</font></h2>"; 
// essa tarefa pode ser feita recorrendo a array_search
$rs = array_search("Meda",$cidades);  
if(is_numeric($rs))
echo "O elemento existe ";
else "Sem resultados";

echo "<h2><font color='red'>
Ordenar baseado no tamanho dos elementos no array</font></h2>"; 

function compara($i,$j){
return strlen($i)- strlen($j);
}


usort($cidades,"compara");
echo "<pre>";
print_r($cidades);
echo "</pre>";
echo "<h2><font color='red'>
Ordenar alfabéticamente elementos no array</font></h2>";     

/*****************************************************
USO: sort(array, sort_type);
* SORT_REGULAR - Default. Treat values as they are (don't change types)
* SORT_NUMERIC - Treat values numerically
* SORT_STRING - Treat values as strings
* SORT_LOCALE_STRING - Treat values as strings, based on local settings

*****************************************************/    

sort($cidades);

echo "<pre>";
print_r($cidades);
echo "</pre>";   


echo "<h2><font color='red'>
Combinar elementos de dois arrays</font></h2>"; 
// atenção ambos os arrays devem conter o mesmo nº de elementos 
$aldeias = array("Bom Jesus","Mata","Cernache","Rapoula",
                 "Caparica","Aveloso","Miragaia","Casteição");
$rs = array_combine($cidades,$aldeias); 
echo "<pre>";
print_r($rs);
echo "</pre>";
?> ]]> 27 Abril 2008 http://www.revista-php.net/artigos.php?pagina=45 Uma das formas de garantir que um email é 100% válido consiste em verificar os registos DNS correspondente a um determinado domínio ou ip.
Neste exemplo apenas vamos fazer a validação do domínio, mas poder-se-ia fazer a query de forma a garantir que também o utilizador do email existe para esse domínio. O facto é que o PHP apenas possuí essa solução de forma nativa para Linux através da utilização da função checkdnsrr(), que não está disponível para Windows.
A nível de alojamento isso não é muito importante, uma vez que a maioria dos Web sites são alojados em servidores Linux, que lhe dá suporte, como já mencionei. Contudo para programadores que desenvolvem as suas aplicações em ambiente local Windows, esse processo torna-se muitas vezes necessário.
Para dar resposta a esse requisito , a função seguinte , baseada em alguma documentação que li no site php.net, permite dar resposta a esse requisito .

<?php
  /**************************************
    Autor    : José Franco
    Data     : 29 Abril 2008
    Licensa  : Creative Commons 
    Distro   : Validar email via registos MX
    ****************************************/ 


$email = "um-email-valido@gmail.com";

// verifica a existência da funcção checkdnsrr

     if(!function_exists('checkdnsrr')){
// não existe , vamos criar uma 


/******************************************
 $dominio 
  endereço ip na notação 
  dotted-quad (exemplo 161.53.4.28) 
  ou nome servidor

 $tipo  pode ser: A, MX, NS, SOA, PTR, CNAME,
       AAAA, A6, SRV, NAPTR, TXT or ANY.
       Por defeito é MX.
 ******************************************/     
     
     function checkdnsrr($dominio,$tipo){
      $res = false;
      // faz a query no Windows pelo nslookup
      @exec("nslookup -type=$tipo $dominio", $rs);
      do{
         list($lixo,$linha)  = each($rs);
         // percorre os registo e verifica se existe
           if(ereg("^$dominio",$linha))
            $res = true; // existe
         }while($res===false);
         return $res; // resultado true - encontrou
       
       }
     
     }


    $str = str_split($email,1);
    // verifica se existe o @ na stirng
    if(!is_numeric(array_search("@",$str))){return false;}
     // separa dominio string anres e depois do @
    list($utilizador,$dominio) = explode("@",$email);
    // validação (versão Windows e Linux)
    if(checkdnsrr($dominio,"MX")) 
       echo "O email existe";
       else 
       echo "O email não existe";
       
       
       

?>
]]> 29 Abril 2008 http://www.revista-php.net/artigos.php?pagina=47 Utilizando POO no PHP ,iremos aprender um novo conceito também introduzido no PHP5, a herança Através desta funcionalidade inerente à programação orientada a objectos (POO), o programador tem a capacidade de fazer com que as sua classes possam herdar atributos ou métodos de uma outra classe.
No nosso exemplo vamos criar uma nova classe Empregado e estendê-la à classe Pessoa previamente criada.
A nova classe possuirá dois novos atributos, um deles privado ($funcao) e o outro publico ($ano_serv).


Como estender uma classe ?

No PHP a forma de a estender uma nova classe (chamada de subclasse ), à classe a partir da qual desejamos utilizar os seus atributos e métodos (designada de superclasse), é através da utilização da palavra reservada extends A subclasse permite-nos usar todos os métodos e atributos pertencentes,à superclasse, sobrescrever os seus métodos , e criar tantos novos atributos e métodos quanto necessário.
Na chamada a um método , o PHP verifica se este existe na subclasse, e no caso de não ser encontrado , segue a procura na classe mãe, (superclasse).
Se na subclasse é escrito um método com o mesmo nome doutro que exista na superclasse, passa a vigorar o método sobrescrito na subclasse, sendo que o outro é ignorado.


Como aceder ao métodos e/ou atributos da superclasse

Para aceder aos métodos ou atributos da utiliza-se a palavra reservada parent e em seguida ::
No nosso exemplo se desejássemos ao método obtemMorada() da superclasse , a forma de o fazer é parent::obtemMorada() Veja o código que exemplifica muito facilmente a teoria apresentada
<?php
/**************************************
    Autor    : José Franco
    Data     : 01 Maio 2008
    Licensa  : Creative Commons 
    Distro   : Utilizando POO :: Herança 
    ****************************************/   
/***************************************
  Para usar herança utiliza-se 
  Superclasse extends subclasse
 **************************************/
 
 
 
// ficheiro que contém a superclasse 
include_once("class_pessoa.php");

class Empregado extends Pessoa{

// novos atributos  na subclasse
protected $funcao;
public $ano_serv;

// método constutor, que conterá dois novos atributos
function __construct($n, $p, $m, $c, $s, $f, $a){
      /*************************************************
       permite criar o objecto generalizado na superclasse,
       isto porque as subclasses não executam o constructor
       da superpeclasse de forma automática pelo que é necessário
       invocá-lo para que o objecto seja generalizado
       ****************************************************/
      parent::__construct($n, $p, $m, $c, $s);
  
     }
     
/**************************************
         métodos de interface
              
 **************************************/
public function indicaFuncao($funcao){
       $this->funcao = $funcao;
       }
       
public function indicaAnosServico($anos){
       $this->anos_serv = $anos;
       }     
     
public function obtemFuncao(){
       return $this->funcao;
       }
       
public function obtemAnosServico(){
       return $this->ano_serv;
       }


// declaração dum método de interface genérico       
public function obtemEmpregado(){
      echo "<b>Nome :        </b>".$this->obtemNome()       ."<br>".
           "<b>Profissão :   </b>".$this->obtemProfissao()  ."<br>".
           "<b>Morada :      </b>".$this->obtemMorada()     ."<br>".
           "<b>Viatura :     </b>".$this->obtemCarro()      ."<br>".
           "<b>Salário :     </b>".$this->obtemSalario()    ."<br>".
           "<b>Imposto :     </b>".$this->obtemTaxa()       ."<br>".
           "<b>Cargo :       </b>".$this->obtemFuncao()     ."<br>".
           "<b>Anos Serviço: </b>".$this->obtemAnosServico()."<br>";
           
       }
       /***************************************
        Este novo conceito , serve para destruir 
        o objecto, o que implica que o script que 
        utiliza  a classe termina quando este 
        é executado. 
        Nota : Não aceita parametros
        ****************************************/
       function __destruct(){
       echo "__FIM  ".(__class__)."__";
       }       


}

// cria um objecto do tipo Empregado e guarada na variável $Emp
$Emp = new Empregado("Pedro","Mecanico","Viseu","Opel Corsa","750","Bate Chapas",6);
/*
  Alterando o estado duma propriedade mediante o método abaixo
 Nota: se este método não existisse na subclasse e estivesse
 declarado na superclasse poderiamos aceder a ele também desta forma */
$Emp->indicaFuncao("Chefe Oficina");
// mostra as propriedades do empregado
$Emp->obtemEmpregado();
echo "<br />";
// Repare-se que a propriedade "Bate Chapas" nem sequer é mostrada pois alterou-se
// recorrendo ao método indicaFuncao() 
// Veja também que a função __destruct informa o final do script
?> ]]> 01 Maio 2007