A extensão do DOM permite trabalhar com documentos XML através do API DOM do PHP 5.

DOMDocument class

Representa um html inteiro ou documento xml, seu construtor recebe 2 parametros que são: versão do documento e codificação do documento, exemplo:

<?php
$dom = new DOMDocument('1.0', 'iso-8859-1');

Método LOAD:

Tem função de carregar o arquivo XML, exemplo:

<?php
$dom = new DOMDOcument();
$dom->load("library.xml");
$dom->loadXML($xml);

DomDocument::loadHtmlFile() and DomDocument::loadHTML()

O método loadHTML carrega o html de uma string e o método loadHtmlFile carrega o html de um arquivo.

DomDocument::save() (para um arquivo).

Salva a arvore do documento XML interna de volta no arquivo.

DomDocument::saveHTML() (para uma string).

Retorna o documento interno em uma string de html formatada, exemplo:

<?php
$doc = new DOMDocument('1.0');

$root = $doc->createElement('html');
$root = $doc->appendChild($root);

$head = $doc->createElement('head');
$head = $root->appendChild($head);

$title = $doc->createElement('title');
$title = $head->appendChild($title);

$text = $doc->createTextNode('This is the title');
$text = $title->appendChild($text);

echo $doc->saveHTML();

DomDocument::saveXML().

Retorna uma string XML em vez de um arquivo HTML ou string HTML.

DomDocument::saveHTMLFile().

Salva o documento ja em formato html.

XPath Queries

Uma das partes mais poderosas da extensão do DOM, é sua integração com XPath de fato, DOM XPath é muito mais poderoso do que o equivalente SimpleXML.

<?php
$dom = new DomDocument();
$dom->load("library.xml");
$xpath = new DomXPath($dom);
$xpath->registerNamespace("lib", "http://exemple.org/library");
$results = $xpath->query("//lib:title/text()");
foreach ($results as $book){
      echo $book->data;
}

Uma chamada para DomXpath::query() retornará um objecto DomNodeList; você pode descobrir quantos itens ele contém usando o comprimento da propriedade, e então acessar qualquer um deles com o metodo item(). você também pode iterar através da coleção inteira usando um laço foreach();

DOMNODE:

O elemento dom possui elementos(nós), os chamados nodes, esses nodes são de certa forma “as tags”. No html temos tags definidas e não criamos essas tags, pois ja existem documentadas, porem em XML definimos nossas proprias tags e essas são os nós.

DOMDocument::createElement().

Cria um novo elemento

DOMDocument::createElementNS()

Cria um novo elemento com um namespace associado

DOMDocument::createTextNode().

Adiciona texto dentro de um node, porem o texto somente será exibido caso o node seja criado.

<?php
$dom = new DOMDocument();
$dom->load("library.xml");
$book = $dom->createElement("book");
$book->setAttribute("meta:isbn", "0973589825");
$title = $dom->createElement("title");
$text = $dom->createTextNode("php|architect's Guide to PHP Design Patterns");
$title->appendChild($text);
$book->appendChild($text);
$author = $dom->createElement("pub:publisher", "Marco Tabini & Associates, Inc.");
$book->appendChild($publisher);
$dom->documentElement->appendChild($book);

DomNode::appendChild()

Cria um elemento filho. O elemento filho é aquele que ficará dentro de outro elemento, exemplo:

<?php
$doc = new DOMDocument();

$foo = $doc->createElement("foo");
$doc->appendChild($foo);

$bar = $doc->createElement("bar");
$foo->appendChild($bar);

$bazz = $doc->createElement("bazz");
$foo->appendChild($bazz);

echo $doc->saveXML();

é o mesmo que

<foo>
<bar></bar>
<bazz></bazz>
</foo>

DomNode::insertBefore()

Insere um elemento antes de um outro elemento.

DomNode::appendChild() end DomNode::insertBefore() moverá o nó para a nova localização.

Se você desejar duplicar um nó, utilize “DomNode::cloneNode()”.

Modificando Dados

<?php
$xml = <<
algum texto aqui

XML;
$dom = new DOMDocument();
$dom->loadXML($xml);
$xpath = new DomXpath($dom);
$node->data = ucwords($node->data);
echo $dom->saveXML();

Removendo Dados

Existe três tipos de dados que você pode querer remover de um documento XML: atributos, elementos e CDATA. O DOM fornece diferentes métodos para cada uma dessas tarefas:

DomNode::removeAttribute().

Remove o atributo do elemento (node).

DomNode::removeChild().

Remove o elemento filho do node especificado.

DomCharacterData::deleteData().

Remove um intervalo de caracteres de um node, esse método recebe 2 parametros:

Offset – o primeiro caractere a ser removido.

Count – o numero de caracteres que serão removidos.

Trabalhando com Namespaces:

DOM é mais do que capaz de lidar com namespaces próprios e, tipicamente, você pode, pela maior parte, ignorai-lo e passar atributos e nome de elementos com o prefix apropriado diretamente para a maioria das funções DOM.

<?php
$dom = new DOMDocument();
$node = $dom->createElement(’ns1:somenode’);
$node->setAttribute(’ns2:someattribute’, ’somevalue’);
$node2 = $dom->createElement(’ns3:anothernode’);
$node->appendChild($node2);
// Set xmlns:* attributes
$node->setAttribute(’xmlns:ns1’, ’http://example.org/ns1’);
$node->setAttribute(’xmlns:ns2’, ’http://example.org/ns2’);
$node->setAttribute(’xmlns:ns3’, ’http://example.org/ns3’);
$dom->appendChild($node);
echo $dom->saveXML();

Nos podemos tentar simplificar o uso de namespaces um pouco usando o os métodos DomDocument::createElementNS() e DomNode::setAttributeNS()

<?php
$dom = new DOMDocument();
$node = $dom->createElementNS(’http://example.org/ns1’, ’ns1:somenode’);
$node->setAttributeNS(’http://example.org/ns2’, ’ns2:someattribute’, ’somevalue’);
$node2 = $dom->createElementNS(’http://example.org/ns3’, ’ns3:anothernode’);
$node3 = $dom->createElementNS(’http://example.org/ns1’, ’ns1:someothernode’);
$node->appendChild($node2);
$node->appendChild($node3);
$dom->appendChild($node);
echo $dom->saveXML();

Interagindo com SimpleXml

Você pode importar objetos SimpleXML para usar com o DOM usando o dom_import_simplexml();

<?php
$sxml = simplexml_load_file(’library.xml’);
$node = dom_import_simplexml($sxml);
$dom = new DomDocument();
$dom->importNode($node, true);
$dom->appendChild($node);

O oposto também é possível, usando a função propriamente chamada simplexml_import_dom();

<?php
$dom = new DOMDocument();
$dom->load(’library.xml’);
$sxe = simplexml_import_dom($dom);
echo $sxe->book[0]->title;

O padrão Decorator é um padrão de projeto estrutural, que nos permite adicionar um novo comportamento ou adicionais a um objeto durante a execução, dependendo da situação.

Objetivo do Decorator

Tem como objetivo tornar flexivel aplicações mais complexas onde é necessario acrescentar comportamentos e funcionalidades nos objetos e entre outras.

A ideia é substituir herença por composição.

Exemplo:

Imagina que você foi a uma lanchonete, comprou um x-burger e adiciou mostarda, ja seu amigo pediu um x-burger com catchup extra.

O objeto é o x-burger e recebeu adicionais,  então:

Usando Herança teriamos “xBurger” (classe pai), “xBurgerMostarda” (classe filha) e “xBurgerCatchup” (classe filha).  // Desculpa os exemplos, mas são apenas para compreensão

Agora imagina se necessitassemos de criar outros adicionais (cebola, alface e etc)…vamos piorar a situação, imagina que podemos adicionar 2, 3, 4 complementos ao mesmo tempo.

Como fariamos com a herança?
Criariamos a horrivel sub-classe “xBurgerMostardaCatchupCebola” ?

Seu sistema ficaria enorme, com varias classes, duplicação de códigos, acoplado e assim vai…

Por isso o Decorator propoem usar, para casos mais complexos, composição ao invés de herança.
Exemplo:

<?php
abstract class behavior {
	abstract function preparo();
}

class hanburger extends behavior
{
	private $burger ='carne';
	private $pao = 'frances';
	public function preparo() {
		return "Pão {$this->pao} com {$this->burger}";
	}

}

abstract class decorator extends behavior {
	protected $add;
	public function __construct(behavior $add){
		$this->add = $add;
	}
}

class mostarda extends decorator {
	public function preparo(){
		$add = $this->add->preparo();
		return "{$add} mais mostarda";
	}
}

class catchup extends decorator {
	public function preparo(){
		$add = $this->add->preparo();
		return "{$add} mais catchup";
	}
}

Vou criar um Pão com carne mais catchup:

<?php
$hanburger = new catchup(new hanburger());
echo $hanburger->preparo();

Imprimirá:
Pão frances com carne mais catchup

Vou criar um Pão com carne mais mostarda mais catchup:

<?php
$hanburger = new catchup(new mostarda(new hanburger()));
echo $hanburger->preparo();

Imprimirá:
Pão frances com carne mais mostarda mais catchup.

Outro exemplo é o editor de texto html (WYSIWYG), através dele podemos ‘decorar’ um texto, adicionar cor, tamanho e borda ao texto e entre outras.

Seguindo essa ideia, criei um simples Decorator apenas para compreensão, porem deixo claro que é apenas um exemplo simples e, neste caso, o uso do Decorator é desnecessário em produção.

<?php
abstract class Node
{
abstract function tag();
}

class Paragrafo extends Node {
private $txt;
public function __construct($txt){
$this->txt = $txt;
}
public function tag(){
return "<p>". $this->txt ."</p>";
}

}

abstract class UnionNode extends Node {
protected $node;
public function __construct(Node $node){
$this->node = $node;
}
}

class Header extends UnionNode {

public function tag(){
echo "<h1>". $this->node->tag() ."</h1>";
}

}

$html = new Header(new Paragrafo(abc));
print_r($html->tag());

Pros:

• Promove flexibilidade
• Evita a duplicação de código
• facilita a manutenção (eliminação, adição e alteração de funcionalidade)

Contras:

• Conforme a complexibilidade pode se tornar confuso
• Código extenso

OBS:
Os exemplos mostrados, são apenas para compreensão do conceito Decorator, assim como, os códigos criados servem apenas para entender como funciona na prática. Aconselho o uso do Decorator quando sua aplicação necessitar de combinação, adição de coisas ou funcionabilidades em tempo de execução e o nivel de complexibilidade e flexibilidade exigidos sejam tão altos que torna-se penoso fazer através da herança.

Is_ref:

É a quantidade de referências na memória, possue o número default representado por 0, a cada referência na memória é acrescentado +1 a esse valor, ou seja, se referenciarmos uma variavel o valor de is_ref torna-se 1, se referenciarmos outra variavel o valor de is_ref torna-se 2.

refcount:

É a quantidade de variáveis no programa, possue o número default representado por 1, a cada variável criada é somado +1 na contagem de ‘refcount’, assim, se criarmos 2 variáveis teremos refcount igual a 2, e assim por diante.

Na Prática:

 <?php
$a = 'string';
xdebug_debug_zval('a');
?>

irá imprimir:

a: (refcount=1, is_ref=0)='string'

 <?php
$a = "new string";
$b = $a;
xdebug_debug_zval( 'a' );
?>

Irá imprimir:

a: (refcount=2, is_ref=0)='string'

<?php
$a = "string";
$c = $b = $a;
xdebug_debug_zval( 'a' );
unset( $b, $c );
xdebug_debug_zval( 'a' );
?> 

irá imprimir:

a: (refcount=3, is_ref=0)='string'
a: (refcount=1, is_ref=0)='string'

 <?php
$a = array( 'meaning' => 'life', 'number' => 42 );
xdebug_debug_zval( 'a' );
?> 

irá imprimir:

a: (refcount=1, is_ref=0)=array (
   'meaning' => (refcount=1, is_ref=0)='life',
   'number' => (refcount=1, is_ref=0)=42
)

<?php
$a = array( 'meaning' => 'life', 'number' => 42 );
$a['life'] = $a['meaning'];
xdebug_debug_zval( 'a' );
?> 

irá imprimir:

a: (refcount=1, is_ref=0)=array (
   'meaning' => (refcount=2, is_ref=0)='life',
   'number' => (refcount=1, is_ref=0)=42,
   'life' => (refcount=2, is_ref=0)='life'
)

<?php
$a = 'string';
$b =&$a;
xdebug_debug_zval( 'a' );
?> 

irá imprimir:

a: (refcount=2, is_ref=1)='string'

OBS: estou usando o xdebug para debugar, caso utilize o comando xdebug_debug_zval( ); e não funcione, certifique-se de instalar o xdebug, ou verifique se sua IDE possui xdebug.
Para instalar visite o site oficial: site oficial xdebug

O safe mode é um parametro que está no php.ini sua função é checar em tempo de execução quem é o proprietário do arquivo que está sendo executado, ele verifica se os diretórios ou arquivos que estão trabalhando pertencem ao mesmo proprietário, reconhecido pelo sistema como UID.

Essa opção é muito utilizada em servidores compartilhados, para evitar que outros usuarios interfiram em arquivos ou diretórios de outro proporietário.

Funcões Desabilitadas:

dbase_open() abre um banco de dados dBase com o modo de acesso dado.
exec() executa um comando dado, um programa externo.
fopen() abre um arquivo ou uma url
mkdir() cria um diretório.
chdir() muda de diretório.
rmdir() remove um diretório.
rename() renomeia um arquivo ou diretório.
copy() copia um arquivo.
chgrp() modifica o grupo de arquivo.
chown() modifica o dono do arquivo.
chmod() modifica a permissão do arquivo.
set_time_limit() limita o tempo de execução do script

Outro erro é usar o apache com permissão administrador (root), isso deixa o sistema inteiro funerável.

Solução:

Existe uma solução simples que consiste em usar a diretiva open_basedir e especificar um diretório, assim,  somente tentativas de acesso vindas desse diretório será permitida, a diretiva open_basedir está no httpd.conf.

Esta diretiva vai limitar os arquivos que podem ser acessados e somente aceitará tentativas de acesso de arquivos que estão dentro dos diretórios especificados em open_basedir.

Imagine que algum script malicioso que usa fopen() ou gzopen() que vem de outro host, tenta acessar o arquivo, caso tenha configurado a diretiva open_basedir, essa tentativa de acesso será verificada e barrada.

Para configurar a diretiva open_basedir:

Vá em httpd.conf, localize a diretiva open_basedir, logo depois, atribua os diretorios que serão aceitos.

Para restringir acesso a apenas um diretório comece com barra e termine com barra, exemplo:

“open_basedir = /dir/incl/”

Terá acesso apenas ao diretório “incl”

caso queira restringir acesso ao diretório e subdiretórios comece com barra, espeficique o diretorio,  mas não termine com barra, exemplo:

“open_basedir = /dir”

Assim, será reconhecidos todos os subdiretorios que estão em ‘dir’.

É um recurso que possibilita agrupar suas classes e até referenciar outros namespaces, formando uma especie de lib , quando incluimos um namespace podemos chamar as classes, métodos, variáveis e até outros namespaces que estão agrupados no namespace que incluimos, é um local dentro do programa onde são localizadas as classes, métodos e etc.

A grande vantagem disso é que evitaremos conflitos entre nomes de classes, variáveis e métodos, além de deixar o código mais limpo.

Como o Namespace Atua

Todas as classes e métodos recebem automaticamente o nome do namespace como prefixo, sendo que dentro do namespace as classes locais terão procedencia sobre as globais.

Como usa-lo:

Após algumas discuções foi adotado a barra ‘\’ como operador desse recurso do php. Deve-se sempre incluir o namespace como primeira instrução no código, somente a instrução ‘declare’ pode ser feita antes.

Exemplo de inlcusão:

<?php
/* Declarando o Namespace */
namespace teste;

Class teste
{
public function teste ()
{
echo "teste";
}
}

/* Chamei a função teste dentro do namespace teste */
teste\teste();
?>

Observe como é o comportamento com 2 namespace delcarados:

<?php
/* Declarando o Namespace */
namespace teste;

Class teste
{
public function teste ()
{
echo "teste";
}
}

/* Chamei a função teste dentro do namespace teste */
teste\teste();

/* Declarando o Namespace */
namespace teste\outro;

Class teste
{
public function teste ()
{
echo "teste";
}
}

/* Chamei a função teste dentro do namespace teste/outro */
teste\outro\teste();
?>

Como podemos notar, o namespace criou um especie de hierarquia é isso que diferencia e evita conflitos, alem de facilitar nossa organização.

Consiste em separar o código em partes lógicas criando códigos isólados com o intuíto de proteger os dados trabalhados, exemplo:

Para dirigir um carro, o motorista não precisa conhecer o funcionamento do motor, apenas saber a técnica de dirigir, seguindo essa lógica, o programador esconde tudo o que o usuário não necessita saber. Isso protege a lógica empregada no sistema dificultando tentativas de burlar seu código.

Além de proteger seu sistema, o encapsulamento torna-o mais flexível e apto para adicionar, alterar e excluir funcionalidades em seu código.

Formas de Encapsulamento:

• Modificadores de Acesso
• Herança
• Interface
• Polimorfismo

Modificadores de Acesso:

São estados de variáveis ou de métodos que modificam as permissões de acesso a visualização de variáveis ou métodos. São atribuidas pelas palavras reservadas: public, protected, private.  Exemplo:

private $varivavel = '';
protected $variavel ='';
public $variavel ='';

Herança:

É uma forma de criar uma nova classe através de outra que ja existe, com isso, a classe que foi criada herdará métodos e atributos da classe pai. Em resumo, a classe pai é uma classe generalizada, com métodos genericos, já a classe filha é mais especifica, com métodos especificos.

Interface:

É uma classe, porém não possui implementações ela apenas indica o que deve ser implementado, é basicamente um espellho com apenas as interfaces do programa, sendo que as classses que implementam-a assumem uma especie de contrato e são obrigadas a implementarem as interfaces especificadas.

Polimorfismo:

É a capacidade de mudar de forma, uma instancia pode assumar outros formas:
Comparando com a lingua portuguesa temos o seguinte exemplo:
Ontem sai para dançar com uns amigos, mas acabamos dançando
porque não conseguimos encontrar um lugar que nos agradasse.

Observe que o verbo dançar teve uma variação.

Programadores experiêntes viveram em épocas em que não havia um padrão documentado para resolver problemas frequentes no desenvolvimento de software, era necessário criar do ‘zero’ uma solução.

Christopher Alexander, Arquiteto da Informação, criou o primeiro conceito de padrões de projetos na dêcada de 70.

Primeiros Conceitos de Padrões de Projetos:

• Encapsulamento:
• Generalidade:
• Equilíbrio
• Abstração
• Abertura
• Combinatoriedade

O que é Design Patterns

São soluções para problemas frequentes de desenvolvimento de software. Em geral, pode ser adaptado e utilizado em qualquer linguagem de programação que tenha suporte a orientação a objetos.

Para simplificar, imagine que você precisa instanciar uma classe apenas uma vez e essa instancia precisa ter acesso global…logo, pensamos em ‘variaveis globais’, porém não é uma boa ideia, pois poderá causar problemas maiores no futuro, então, foi estabelecido um padrão chamado ‘singleton’. Com o padrão singleton teremos uma unica instancia e garantiremos um ponto global de acesso.

Design Patterns são soluções testadas e flexíveis com o intuíto de reutilização de códigos, porém não se trata de uma receita com formulas prontas, pois cada aplicação possui suas particularidades e dependendo necessitará de adaptações na estrutura do padrão. Também não é aconselhável seu uso em excesso ou para coisas simples.

Melhor do que decorar todos os padrões é conhecer os principios dos padrões. Todos os padrões visam a ‘flexibilidade’ e ‘reutilizaçao’, principios como: “encapsule o conceito que varia” ou “programe para uma interface e nao para uma implementação” podem fazer a diferença.