Technócil

Arquivo do mês 12/2008

Leitura de XML – Parte 2 SimpleXML

Postado por João Vagner em 24.12.2008 10:00 Desenvolvimento web, Destaques, Internet, php

Olá Pessoal,

Primeiramente, post de dia 24 de Dezembro, desejos a todos um Feliz Natal, que estejam todos ai junto a amigos e familiares curtindo uma data especial.

Bom, demorei um pouco, mas chegou, a segunta parte de Leitura de XML usando SimpleXML, dessa vez vou usar alguns modelos, ao invez de trabalhar com o nosso Feed de RSS, vamos trabalhar com valores de cambio e pesquisa de CEP. Tudo simples e em poucas linhas.

Primeiramente precisamos de algum XML que seja atualizado, com os valores que temos que trabalhar. Para isso existe esse endereço: http://www.republicavirtual.com.br/cotacao/exemplos.php

Não posso garantir 100% de uptime do link, pois não sei se algo vai mudar ok? Mas iremos trabalhar em cima dos retornos desse xml, ok?

Simple XML

O objetivo é fornecer acesso aos documentos XML usando propriedades de objetos e iterators, não é uma extensão complicada (são poucos métodos) mas é bastante flexível.

Exemplo Básico

Importando o XML da URL:

1	$file = simplexml_load_file('http://cotacao.republicavirtual.com.br/web_cotacao.php?formato=xml');

Iniciando o trabalho

Aqui vamos pegar o valor do dolar comercial para compras:

// importando o arquivo
$file = simplexml_load_file('http://cotacao.republicavirtual.com.br/web_cotacao.php?formato=xml');
// pegando a tag dolar_commercial_compra
echo $file->dolar_comercial_compra;

As tags que podemos trabalhar podem ser encontrada nesse XML

<webservicecotacao>
	<dolar_comercial_compra>2,1260</dolar_comercial_compra>
	<dolar_comercial_venda>2,1280</dolar_comercial_venda>
	<dolar_paralelo_compra>2,2200</dolar_paralelo_compra>
	<dolar_paralelo_venda>2,3000</dolar_paralelo_venda>
	<euro_dolar_compra>1,2410</euro_dolar_compra>
	<euro_dolar_venda>1,2410</euro_dolar_venda>
	<euro_real_compra>2,6384</euro_real_compra>
	<euro_real_venda>2,6408</euro_real_venda>
</webservicecotacao>

Viram como é simples trabalhar com o SimpleXML? Agora vamos trabalhar para achar endereços de CEP ;) O XML que iremos trabalhar emcima é desse modelo:

Trabalhando com CEP

Código:

<?xml version="1.0" encoding="iso-8859-1" ?>
<webservicecep>
<resultado>1</resultado>
<resultado_txt>sucesso - cep completo</resultado_txt>
<uf>SP</uf>
<cidade>São Paulo</cidade>
<bairro>Santana</bairro>
<tipo_logradouro>Rua</tipo_logradouro>
<logradouro>Duarte de Azevedo</logradouro>
</webservicecep>

A URL que iremos importar as consultas é: http://cep.republicavirtual.com.br/web_cep.php?cep=02036021&formato=xml

Vamos ao Código:

$file = simplexml_load_file('http://cep.republicavirtual.com.br/web_cep.php?cep=02036021&formato=xml');
 
echo "UF: " .$file->uf;
echo "<br />Cidade: " .$file->cidade;
echo "<br />Bairro: " .$file->bairro;
echo "<br />Tipo de Logradouro: " .$file->tipo_logradouro;
echo "<br />Endereço: " .$file->logradouro;

Não recomendo que essa aplicação rode atravez da url de pesquisa, a base de dados pode ser baixada nesse endereço: Download

É isso, viram como é simples integrar uma pesquisa de CEP pra completar formulários de cadastros e tudo mais? Agora é com vocês ;)

Tags: Desenvolvimento web, php, simplexml, xml

OOP no PHP: Reaproveitamento, Sobrescrevendo métodos

Postado por Tobias em 17.12.2008 07:09 Desenvolvimento web, Destaques, OOP, php

E ae blz?

Chegamos numa das partes interessantes da nossa série de posts, é onde começo a falar das ~~gambiarras~~ técnicas usadas por nós programadores para salvar horas de trabalho no desenvolvimento.

Para ilustrar o post de hoje vou usar um caso que aconteceu comigo a algum tempo. Na empresa onde trabalho, fizemos um sistema publicador de sites, um CMS próprio desenvolvido aqui, e que um belo dia recebi um pedido para incluir nele uma espécie de lixeira.

Bom para implementar essa feature a solução sugerida foi criar uma coluna em cada tabela com o nome de trash e que teria valor default 0 e quando um item fosse deletado esse valor seria alterado para 1.

Tendo isso em mente comecei a implementação, alterar o banco foi moleza, agora eu precisava implementar essa condição no sistema. Foi quando me deparei com a seguinte situação, teria que alterar cada uma das chamadas do método findAll() em todo o sistema, pensei,… pensei,… e quando já não via mais solução pra isso um amigo sugeriu “pow, sobrescreve findAll() que tu evita esse trabalhão“, e assim foi feito :).

Agora que vocês já sabem o problema vou mostrar a solução que eu usei nessa situação.

Eu tinha em em mãos as classes Model, AppModel e uma classe pra cada um dos models específicos (sim, usamos CakePHP).

A classe Model é a base de toda interação com o banco, é uma classe do core do framework extendida pela classe AppModel.

A AppModel é uma classe feita exatamente para esse fim, ela inicialmente é vazio e só extende a classe Model do framework e é extendida pelos models da aplicação, ou seja, é usada por todos os models do sistema e ainda herda o método que eu preciso sobrescrever, tudo que eu precisava.

O método findAll original dentro da classe Model é tem essa estrutura de parâmetros:

A método sobrescrito na AppModel ficou assim:

findInTrash)
			$new_conditions += array($this->name.'.trash' => '0');

		return parent::findAll($new_conditions, $fields, $order, $limit, $page, $recursive);
	}
	...
}
?>

Antes de mais nada vou avisar o óbvio, só coloquei aqui os códigos necessários para explicar o post as classes são bem maiores que isso ;).

Notem também que eu não mudei os parametros usados no método mas poderia faze-lo se fosse necessário, esse método recebe todos os paramêtros possíveis no findAll original, altera as condições necessárias e chama o método findAll da classe pai usando o parent::.

Nesse caso em particular eu só precisava sobrescrever o método para adicionar uma condição específica, mas dependendo do caso talvez você precise que um mesmo método seja chamado de formas diferentes ou com uma quantidade de parâmetros diferentes, o que também poderia ser feito, mas isso já é assunto para um próximo post.

Dúvidas? sugestões? puxões de orelha? comentários tão ai pra isso.

Um abraço e até o próximo post.

OOP no PHP: Heranças e Interfaces, extendendo e implementando classes

Postado por Tobias em 15.12.2008 12:00 Desenvolvimento web, Destaques, OOP, php

E ae blz?

Bom gente depois de um alguns dias atrasado devido a problemas pessoais aqui vai o segundo post da série OOP no PHP, nossos assuntos agora são Heranças e Interfaces, e aproveitando o assunto eu preparei uma classe de acesso ao banco de dados que ilustra perfeitamente o nosso assunto de hoje e também usa as definições do post anterior.

Vamos começar com a teoria:

extends – Essa palavra chave indica que uma classe extende outra classe, ou seja, herda todos os métodos e atributos da classe pai.

Exemplos simples:

<?php
 
class Pai {
	public function pai() {
		echo “Função da classe pai”;
	}
}
 
class Filha extends Pai {
	private function $filha;
 
	public function chamaPai(){
		$this->pai();
	}
 
	public function responde() {
		echo 'Sou uma classe filha';
	}
}
 
?>

No exemplo acima estão disponívels na classe filha todos os métodos/atributos públicos e protegidos (quando existerem) da classe pai.

implements – Essa aqui é um pouco diferente, ela define que uma determinada classe implemente uma interface, que nada mais é uma que uma definição de nomes e parametros de cada método da classe, porém, a real utilidade das interfaces é mais conceitual no mundo OOP e na maioria das vezes é deixada de lado.

vamos a um exemplo:

<?php
 
interface iFilha {
	public function chamaPai();
	public function responde();
}
 
class Pai {
	public function pai() {
		echo “Função da classe pai”;
	}
}
 
class Filha extends Pai implements iFilha {
	private function $filha;
 
	public function chamaPai(){
		$this->pai();
	}
 
	public function responde() {
		echo 'Sou uma classe filha';
	}
}
 
?>

Algumas considerações interessantes sobre interfaces:

Somente métodos públicos aparecem nas interfaces;
Uma classe pode implementar mais de uma interface;
Uma classe não pode implementar duas interfaces com métodos de nomes iguais;
Interfaces podem ser herdadas assim como classes, basta usar extends.

Bom acho que deu pra entender como funcionam essas coisas, então vamos pra um exemplo de uso nessa classe de acesso ao banco que eu fiz pra ajudar o nosso entendimento.

config.php

<?php
 
class Config {
	const DB_HOST 	= 'localhost';
	const DB_USER 	= 'root';
	const DB_PASS 	= 'root';
	const DB_SCHEMA = 'technocil';
	const DB_ENCODING = 'UTF8';
}
 
?>

dbo_mysql.php

<?php
 
require 'config.php';
 
interface iDBOMysql {
 
	public function __construct();
 
	public function connect();
 
	public function insert($table,$fields);
 
	public function update($table,$fields);
 
	public function delete($table,$conditions);
 
	public function select($table,$fields='*',$conditions=null,$order=null,$limit=null);
 
}
 
class DBOMysql extends Config implements iDBOMysql {
 
	private $connection;
	private $result;
 
	/**
	 * Construtor chama os métodos necessários quando a classe é instanciada
	 */
	public function __construct() {
		$this->connect();
	}
 
	/**
	 * Conecta com o banco de dados utilizando os dados das constantes de configuração
	 */
	public function connect() {
		$this->connection = mysql_connect(parent::DB_HOST,parent::DB_USER,parent::DB_PASS) or die (mysql_error());
		if (mysql_select_db(parent::DB_SCHEMA, $this->connection)) {
			$this->setEnconding();
		}
	}
 
	private function setEnconding() {
		$this->query('SET NAMES '' . parent::DB_ENCODING.''');		
	}
 
	private function query($sql) {
		return mysql_query($sql,$this->connection);
	}
 
	/**
	 * Executa uma query de inserção no banco de dados
	 *
	 * @param string $table nome da tabela
	 * @param array $fields array com os campos e valores a serem inseridos
	 */
	public function insert($table,$fields) {
 
		$columns = $values = array();		
		foreach ($fields as $column => $value) {
			$columns[] = mysql_real_escape_string($column);
			$values[] = mysql_real_escape_string($value);
		}
 
		$sql  = 'INSERT INTO '.mysql_real_escape_string($table).' ';
		$sql .= '('.join(',',$columns).') ';
		$sql .= 'VALUES (''.join("','",$values).'')';
 
		return $this->query($sql);
 
	}
 
	/**
	 * Executa uma query de atualização no banco de dados
	 *
	 * @param string $table nome da tabela
	 * @param array $fields array com os campos e valores a serem inseridos
	 */
	public function update($table,$fields,$conditions=null) {
 
		$columns = $values = array();		
		foreach ($fields as $column => $value) {
			$itens[] = mysql_real_escape_string($column).'=''.mysql_real_escape_string($value).''';
		}
 
		$sql  = 'UPDATE '.mysql_real_escape_string($table).' ';
		$sql .= 'SET '.join(',',$itens).' ';
 
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		return $this->query($sql);	
 
	}
 
	/**
	 * Executa uma query para excluir registros do banco
	 *
	 * @param string $table nome da table
	 * @param string $conditions condições de exclusão (opcional)
	 */
	public function delete($table,$conditions) {
 
		$sql  = 'DELETE FROM '.mysql_real_escape_string($table).' ';
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		return $this->query($sql);
 
	}
 
	/**
	 * Executa uma query para selecionar registros no banco de dados
	 *
	 * @param string $table 
	 * @param array $fields 
	 * @param string $conditions 
	 * @param string $order
	 * @param string $limit
	 */
	public function select($table,$fields='*',$conditions=null,$order=null,$limit=null) {
 
		$sql  = 'SELECT ';
		$sql .= (is_array($fields)) ? join(',',$fields) : $fields;
		$sql .= ' FROM '.mysql_real_escape_string($table).' ';
 
		if ($conditions != null)
			$sql .= 'WHERE '.mysql_real_escape_string($conditions);
 
		if ($order != null)
			$sql .= 'ORDER BY '.mysql_real_escape_string($order);
 
		if ($limit != null)
			$sql .= mysql_real_escape_string($limit);
 
		$results = $this->query($sql);
 
		$fetch = array();
		while ( $loop = mysql_fetch_assoc($results) ) {
			$fetch[] = $loop;
		}
 
		return $fetch;
 
	}
}
 
?>

Só uma rápida explicação:
A classe Config é uma classe que contem as constantes de configuração de acesso ao banco, a classe DBOMysql é a classe que implementa a interface iDBOMysql e extend a classe Config, vocês podem notar também o uso de public em private nos atributos, essa classe mostra o uso extends e implements, só gostaria de lembrar que como a classe os métodos private da classe não aparecem na interface, e que nesse caso a interface não é algo essencial.

Bom gente por enquanto é isso, quero me desculpar pelo atraso do post, a última semana foi meio corrida e o fim de semana foi de comemoração por que terminei a faculdade.

Abraços e até a próxima, onde nossos assuntos vão ficar cada vez mais interessantes.

Tags: extends, herança, implements, interfaces, OOP, php

OOP no PHP: Visibilidade, definições de public, protected, private e static

Postado por Tobias em 11.12.2008 12:52 Desenvolvimento web, OOP, php

E ae blz?

Bom inaugurando a minha participação aqui no blog resolvi começar com uma série de artigos sobre OOP e PHP, no primeiro post eu vou explicar o que significam as palavrinhas public, protected, private e static, o que significam e a função de cada uma delas em nossas classes.

Só pra constar essa série inicial terá 5 posts com os seguintes assuntos.

Visibilidade, definições de public, protected, private e static
Heranças e Interfaces, extendendo e implementando classes
Reaproveitamento, Sobrescrevendo métodos
Overloading, utilizando os métodos mágicos do PHP
Improviso, simulando a sobrecarga de métodos no PHP

Bom já que estamos com tudo resolvido vamos começar a brincadeira.

As definições de escopo são bem simples e não há necessidade de se extender falando delas.

public é a liberal das definições de escopo, todo método ou atributo de uma classe definido como
public pode ser acessado de qualquer lugar.

protected é um pouco mais contida só pode ser acessada de dentro da classe e de suas classes filhas.

private como o nome já diz é totalmente restrita e só pode ser acessada de dentro da classe.

Exemplo abaixo:

<?php
 
class Exemplo {
 
  public $publicInfo = 'Sou uma informação pública';
  protected $protectedInfo = 'Sou uma informação protegida';
  private $privateInfo = 'Sou uma informação restrita';
 
  public function getPublicInfo() {
    echo $this->publicInfo;
  }
 
  protected function getProtectedInfo() {
    echo $this->protectedInfo;
  }
 
  private function getPrivateInfo() {
    echo $this->privateInfo;
  }
 
}
 
$exemplo = new Exemplo;
 
//Imprime Sou uma informação pública
$exemplo->getPublicInfo();
 
//Retorna Fatal error: Call to protected method Exemplo::getProtectedInfo() from context
$exemplo->getProtectedInfo();
 
//Retorna Fatal error: Call to private method Exemplo::getPrivateInfo() from context
$exemplo->getPrivateInfo();
 
?>

Tudo bem aparentemente, então vamos pra função de static.

static permite que algum método ou atributo de uma classe seja chamado sem a necessidade de instanciar a classe. O método/atributo é chamado da seguinte forma:

NomeDaClasse::NomeDoMetodo() ou
NomeDaClasse::$NomeDoAtributo

Exemplo:

<?php
 
class ExemploStatic {
	public static $atributo = 'Eu tenho alguma informação';
 
	public static function fazAlgumaCoisa() {
		echo 'Eu faço alguma coisa';
	}
}
 
//Imprime Eu tenho alguma informação
echo ExemploStatic::$atributo;
 
//Imprime Eu faço alguma coisa
ExemploStatic::fazAlgumaCoisa();
 
?>

É por hora acho que já ta de bom tamanho, você pode encontrar mais informações sobre public, private e protected e também sobre a static na documentação oficial do php.

Ainda ficou com alguma dúvida? sim? bom os comentários tão aqui pra isso, mas se você não ficou com dúvidas e quer dar um puxão de orelha no menino aqui, os comentários também server pra isso.

Um abraço e até o próximo post.

Tags: escopo, OOP, php, private, protected, public, static

Leitura de XML – Parte 1 DOM XML

Postado por João Vagner em 09.12.2008 12:49 Desenvolvimento web, Internet, php

Já precisaram ler algum XML, de algum lugar, trabalhar com esses valores? Se ainda não precisaram, podem ter a absoluta convicção que esse dia chegará.

Alguns aplicativos ja usam o XML como transmissão de informações, ou recepção de informações. Importar ou exportar um arquivo XML é simples, fácil e rápido, basta manter um padrão para ler dentro de suas tags ou escrever dentro das mesmas.

Alguns sistemas, blogs, entre outros dispostivos, ja estão trabalhando totalmente ou parcialmente com XML, cada um usando formatações diferentes, porém a estrutura do arquivo sempre o mesmo com a marcação de tags, exemplo de um XML comum de RSS do nosso proprio blog TECHNÓCIL:

Nosso XML:

<?xml version="1.0" encoding="UTF-8"?>
 
<rss version="2.0" 
 
    xmlns:content="http://purl.org/rss/1.0/modules/content/" 
 
    xmlns:wfw="http://wellformedweb.org/CommentAPI/" 
 
    xmlns:dc="http://purl.org/dc/elements/1.1/" 
 
    xmlns:atom="http://www.w3.org/2005/Atom" 
 
    > 
 
<channel>
 
    <title>technocil.com</title> 
 
    <atom:link href="http://technocil.com/feed/" rel="self" type="application/rss+xml" /> 
 
    <link>http://technocil.com</link> 
 
    <description></description> 
 
    <pubDate>Tue, 09 Dec 2008 14:30:28 +0000</pubDate> 
 
    <generator>http://wordpress.org/?v=2.6.5</generator> 
 
    <language>en</language> 
 
            <item> 
 
        <title>Primeiro post, Apresentação&#8230;</title> 
 
        <link>http://technocil.com/2008/12/09/primeiro-post-apresentacao/</link> 
 
        <comments>http://technocil.com/2008/12/09/primeiro-post-apresentacao/#comments</comments> 
 
        <pubDate>Tue, 09 Dec 2008 14:29:10 +0000</pubDate> 
 
        <dc:creator>Tobias</dc:creator> 
 
        <category><![CDATA[Geral]]></category> 
 
        <category><![CDATA[Apresentacao]]></category> 
 
        <category><![CDATA[Technócil]]></category> 
 
        <guid isPermaLink="false">http://technocil.com/?p=121</guid> 
 
        <description><![CDATA[nossa descrição do post [...]]]></description> 
 
            <content:encoded><![CDATA[<p>Todo Conteudo do post</p> 
 
<p>Segundo paragrafo</p>]]></content:encoded> 
 
            <wfw:commentRss>http://technocil.com/2008/12/09/primeiro-post-apresentacao/feed/</wfw:commentRss> 
 
        </item> 
 
    </channel> 
 
</rss>

Um tanto quanto grande nosso XML né? Porém ele é ótimo para o exemplo devido aos niveis de title, e description, que irá nos exemplos abaixo.

Agora imaginem como ler ou obter os dados desse nosso RSS (XML). Para isso existem várias maneiras, algumas são usando algumas funções do PHP como a file_get_contents. Exemplo:

<?php 
 
$conteudo = file_get_contents('http://technocil.com/feed/');
 
echo $conteudo;
 
?>

Dependendo do seu navegador, o que será impresso é RSS(XML) do nosso blog, ou abrindo o código fonte do que for impresso, verá todo o XML impresso. No meu caso que uso o Opera, precisarei abrir o código fonte para ver o XML Impresso lá. Agora depois trabalhar com esses dados podem ser por expressão regular, e por ai vai, é um trabalhão dessa maneira. O XML não é dinamico, não pode ser interpretado pelo servidor, pode somente ser lido. Para escrever um XML com valores dinamicos sim, se usa usa PHP, e definindo no header o tipo de documento XML, porém ainda não chegamos ao ponto de escrever nenhum XML.

Então para fugir do trabalho duro e chato qual a maneira mais fácil e rápida de trabalhar com XML e seus valores?

São as mais conhecidas duas, usando uma extensão do php chamada DOM XML, que foi revisada no PHP 4.3.0 para trabalhar corretamente com o Padrão DOM, e segunda opção é a SimpleXML.

Instalação do DOM XML

A instalação é simples, basta descomentar a linha do php.ini que possui a extensão domxml.dll ou .so:

extension=php_domxml.dll

No meu caso, como uso o XAMPP 1.6.7, eu comentei a linha, pois a mesma apresentava um erro ao tentar utilizar, e eu apenas comentei e ela voltou a funcionar, no site do PHP Consta alguns avisos de versões, dependendo da sua versão do php, elas são válidas ou não:

Nota: Esta extensão foi movida para o repositório » PECL e não é mais distribuida em conjunto com o PHP a partir do PHP 5.0.0.

Nota: Esta extensão não está mais marcada como experimental. Ele será, contudo, nunca liberada com PHP 5, e irá somente ser distribuida com PHP 4. Se você precisa de suporte a DOM XML com PHP 5, você pode usar a extensão DOM. Esta extensão domxml não é compatível com a extensão DOM.

Alguns servidores web, porém tem dificuldade em trabalhar com essa biblioteca, um exemplo é a Locaweb (não vo divulgar o nome do cliente), que sofreu para que pudessem colocar esse componente tão simples no servidor. Mas isso vai de cliente a cliente. Eu aproveitando o gancho vou divulgar a IW² onde possui SVN (controle de versão), SSH e bibliotecas desses e outros usos liberadas, que hospeda aqui o TECHNOCIL.

Vamos aos códigos do DOM XML:

//aqui iniciamos o trabalho com o DOM, definindo o cabeçalho como versão do XML 1.0, e trabalhando com o charset em UTF-8;
$doc = new DOMDocument('1.0?', 'UTF-8?'); 
// aqui fazemos o load de todo o conteúdo do XML 
$doc->load('http://technocil.com/feed/');

Primeira fase completa, ja pegamos todo o conteudo do XML, ja iniciamos a extensão do DOM, e ja podemos usar os seus componentes:

1
2
3

//exibe o titulo : technocil.com; pegando da tag title na raiz do XML:     <title>technocil.com</title>
$titulo        =    $doc->getElementsByTagName("title")->item(0)->nodeValue;
echo $titulo ;

Caso eu queira o titulo do post eu tenho que entrar dentro dos niveis do XML:

1
2
3

// observe o item(1); Estamos trabalhando com niveis, parecidos com array, onde temos [0], [1], ['titulo'];
$tituloPost        =    $doc->getElementsByTagName("title")->item(1)->nodeValue; 
echo $tituloPost ;

Agora vamos pegar a descrição do Post:

1
2
3

// observe que estamos ainda usando o item(1), ainda estamos em um segundo nivel das marcações
$DescricaoPost        =    $doc->getElementsByTagName("description")->item(1)->nodeValue; 
echo $DescricaoPost ;

Para ler esse conteudo dinamicamente, pode se trabalhar com foreach, listando nos ->item($i) um valor de listagem contando quantos posts possuem no XML. Agora é só brincarem ;)

Na parte dois, posto um exemplo de como pegar e trabalhar com os dados de Frete dos Correios, usando o XML de resposta das consultas por URL, e na parte 3, como trabalhar com o SimpleXML, no qual eu considero mais trabalhoso e chato.

Até mais!

Tags: dom, php, xml

Primeiro post, Apresentação…

Postado por Tobias em 09.12.2008 11:29 Geral

Era uma vez… wtf?

Dois malucos conversam sobre php via gtalk e um deles fala, “o vagabundo, to precisando de gente pra escrever num blog comigo, ta afim?”… é meus caros, foi assim que nasceu o Technócil, que é uma mistura das palavras tecnologia e imbecil (algo que combina bem com a nossa personalidade).

Os dois de quem vós falo são Tobias (Buda) e João Vagner (Girafa) dois nerds programadores que iniciaram a carreira com PHP, mas que depois foram passando por vários outros caminhos obscuros. Depois dessa descrição da pra perceber que o Technócil se propõe a ser um blog de tecnológia e afins, mas sempre vagabundo preguiçoso bem humorado, e assim começamos mais uma quest tragetória, falando bobagem o que pensamos e compartilhando nerdisses conhecimentos.

3… 2… 1… Round 1… FIGHT!

Tags: Apresentacao, Technócil

Posts Recentes

Comentários Recentes

Thiago:Só uma ressalva, quando info q
Villas:O post é velho mas acho que re
Tobias:Pescoço gostei do post... pena
Tobias:hahahaha, o João provavelmente
João Vagner:Fernanda minha querida Fernada
Fernanda:Agora que vc inventou um exemp
Rafael Almeida:Só pra informação: é possível
Bruno Sotto:Obrigado, seu artigo me ajudou
Danilo:Quando vai ocorrer o II Encont
Joao Vagner:Esta um tanto que desatualizad

Arquivo do mês 12/2008

Leitura de XML – Parte 2 SimpleXML

Simple XML

Exemplo Básico

Iniciando o trabalho

Trabalhando com CEP

Vamos ao Código:

OOP no PHP: Reaproveitamento, Sobrescrevendo métodos

OOP no PHP: Heranças e Interfaces, extendendo e implementando classes

OOP no PHP: Visibilidade, definições de public, protected, private e static

Leitura de XML – Parte 1 DOM XML

Primeiro post, Apresentação…

Posts Recentes

Comentários Recentes

Arquivo

Categorias

Links

Meta