Módulo 08

[Fabyo 66]

Curso de PHP online

 

Modulo 8

 

Introdução

 

o O que é XML?

o Usando PHP com XML

o O que é um parser DOM?

o Funções de Memória Compartilhada

 

O que é XML?

 

XML (Extension Markup Language) é uma linguagem de marcação de documentos e permite que você crie seus próprios conjuntos de elementos de marcação.

A XML faz o que seria a verdadeira função de uma linguagem de marcação, que é descrever um documento,e não

como ele deve ser exibido.Com marcação personalizada da XML torna-se possivel a estruturação de dados , que

posteriormente poderão ser recuperados facilmente e utilizados de varias maneiras.

XML é um padrão definido pela The World Wide Web consortium (W3C). Informações sobre XML e tecnologias relacionadas pode, ser encontradas em

http://www.w3.org/xml/

 

exemplo de um documento XML:

<?xml version="1.0"?>
<livraria>
<livro>
 <titulo>Aprenda PHP</titulo>
 <preco>R$ 40.00</preco>
 <autor>Jose da Silva</autor>
</livro>

<livro>
 <titulo>Aprenda ASP</titulo>
 <preco>R$ 50.00</preco>
 <autor>Manuel</autor>
</livro>

<livro>
 <titulo>Aprenda JAVA</titulo>
 <preco>R$ 80.00</preco>
 <autor>Francisco</autor>
</livro>	
</livraria>

 

Usando PHP com XML

 

xml_set_element_handler() = Eventos elementares são emitidos toda vez que o analisador XML o início ou o fim das tags. Há manipuladores (handlers)

separadores para tags de início e tags de fim.

 

xml_set_character_data_handler() = Dados de caractere são aproximadamente todo o conteúdo de documentos XML, incluindo espaços em branco

entre as tags. Note que o analisador XML não adiciona ou remove qualquer espaço em branco, ele está pronto para a aplicação se você decidir que

espaços em branco são significativos.

 

xml_set_processing_instruction_handler() = Programadores de PHP já estariam familiarizados com instruções de processo (PIs). <?php ?> é uma

instrução de processo, onde php é chamada de o "PI target". O tratamento destes são application-specific, exceto que todos os PI targets iniciados com "XML"

estão reservados.

 

xml_set_default_handler() = O que não vai para outro manipulador vai para o manipulador padrão. Você conseguirá coisas como o XML e declarações do tipo

de documento no manipulador padrão.

 

xml_set_unparsed_entity_decl_handler() = Este manipulador será chamado por uma declaração de um entity não analisada (NDATA).

xml_set_notation_decl_handler() = Este manipulador é chamado pela declaração de uma nota.

xml_set_external_entity_ref_handler() = Este manipulador é chamado quando o analisador XML encontra uma referência para uma entity geral analizada

externamente. Isto pode ser uma referência para um arquivo ou URL, por examplo. Veja Um exemplo de entity externa para uma demonstração.

 

Codificação de Caracter

 

A Extensão XML do PHP suporta o caracter Unicode definido por character encodings (codificação de caracteres) diferentes. Há dois tipos de codificação de caracteres,

source encoding e target encoding. A apresentação interna do PHP do documento é sempre codificada com UTF-8.

Source encoding é feita quando um documento XML é analisado. Em criando um analisador XML, um source encoding pode ser especificado (Esta codificação não poderá ser

mudada após o tempo de vida do analisador XML). As codificações suportadas são ISO-8859-1, US-ASCII e UTF-8. O segundo são codificações single-byte, que significa que

cada caractere é representado por um byte simples. UTF-8 pode codificar caracteres compostos por um número de bits variável (acima de 21) em um de seus 4 bytes. O source

encoding padrão utilizado pelo PHP é ISO-8859-1.

Target encoding é feito quando o PHP passa dados para as funções do analisador XML. Quando um analisador XML é criado, o target encoding é definido igual ao source encoding,

mas este pode ser mudado em qualquer ponto. O target encoding afetará dados de caracter tão bem como nome de tags e processando alvos da instrução.

Se o analisador XML encontra caracteres de fora da linha que seu source encoding é capaz de detalhar, ele retornará um erro.

Se PHP encontra caracteres no documento XML analisado que não podem ser detalhados selecionados com target encoding, os caracteres com problema serão "demoted". Atualmente, isto

significa que tais caracteres serão substituidos por um sinal de interrogação.

 

 

Listando o conteudo de um documento XML:

 

exemplo:

<html>
<head>
<title>Livros</title>
</head>
<body>
<h3>Livros</h3>
<?

function tag_inicial($parser, $elemento)
{
if($elemento != "LIVRARIA")
{
 if($elemento == "LIVRO")
 {
  echo "<ul>";
 }
 else
 {
  echo "<li>$elemento : ";
 }
}
}	

function tag_final($parser, $elemento)
{
if($elemento != "LIVRARIA")
{
 if($elemento == "LIVRO")
 {	
  echo "</ul>";
 }
 else
 {
  echo "</li>";
 }
}	
}

function trata_caracter($parser, $dados)
{
echo $dados;
}

$xml_parser = xml_parser_create();
xml_set_element_handler($xml_parser, "tag_inicial", "tag_final");
xml_set_character_data_handler($xml_parser, "trata_caracter");  

if(file_exists("livros.xml"))
{
$fp = fopen("livros.xml", "r");

while($dados = fread($fp, 4096))
{
 xml_parse($xml_parser, $dados, feof($fp));  
}
xml_parser_free($xml_parser);
}
?>
</body>
</html>

 

exemplo2

manual do php:

 

<?php
$file = "livros.xml";

function startElement($parser, $name, $attribs) {
echo "<<font color=\"#0000cc\">$name</font>";
if (sizeof($attribs)) {
	while (list($k, $v) = each($attribs)) {
		echo " <font color=\"#009900\">$k</font>=\"<font 
			   color=\"#990000\">$v</font>\"";
	}
}
echo ">";
}

function endElement($parser, $name) {
echo "</<font color=\"#0000cc\">$name</font>>";
}

function characterData($parser, $data) {
echo "<b>$data</b>";
}

function PIHandler($parser, $target, $data) {
switch (strtolower($target)) {
	case "php":
		global $parser_file;
		if (trustedFile($parser_file[$parser])) {
			eval($data);
		} else {
			printf("Untrusted PHP code: <i>%s</i>", 
					htmlspecialchars($data));
		}
		break;
}
}

function defaultHandler($parser, $data) {
if (substr($data, 0, 1) == "&" && substr($data, -1, 1) == ";") {
	printf('<font color="#aa00aa">%s</font>', 
			htmlspecialchars($data));
} else {
	printf('<font size="-1">%s</font>', 
			htmlspecialchars($data));
}
}

function externalEntityRefHandler($parser, $openEntityNames, $base, $systemId,
							  $publicId) {
if ($systemId) {
	if (!list($parser, $fp) = new_xml_parser($systemId)) {
		printf("Could not open entity %s at %s\n", $openEntityNames,
			   $systemId);
		return false;
	}
	while ($data = fread($fp, 4096)) {
		if (!xml_parse($parser, $data, feof($fp))) {
			printf("XML error: %s at line %d while parsing entity %s\n",
				   xml_error_string(xml_get_error_code($parser)),
				   xml_get_current_line_number($parser), $openEntityNames);
			xml_parser_free($parser);
			return false;
		}
	}
	xml_parser_free($parser);
	return true;
}
return false;
}

function new_xml_parser($file) {
global $parser_file;

$xml_parser = xml_parser_create();
xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
xml_set_element_handler($xml_parser, "startElement", "endElement");
xml_set_character_data_handler($xml_parser, "characterData");
xml_set_processing_instruction_handler($xml_parser, "PIHandler");
xml_set_default_handler($xml_parser, "defaultHandler");
xml_set_external_entity_ref_handler($xml_parser, "externalEntityRefHandler");

if (!($fp = @fopen($file, "r"))) {
	return false;
}
if (!is_array($parser_file)) {
	settype($parser_file, "array");
}
$parser_file[$xml_parser] = $file;
return array($xml_parser, $fp);
}

if (!(list($xml_parser, $fp) = new_xml_parser($file))) {
die("could not open XML input");
}

echo "<pre>";
while ($data = fread($fp, 4096)) {
if (!xml_parse($xml_parser, $data, feof($fp))) {
	die(sprintf("XML error: %s at line %d\n",
				xml_error_string(xml_get_error_code($xml_parser)),
				xml_get_current_line_number($xml_parser)));
}
}
echo "</pre>";
xml_parser_free($xml_parser);

?>

 

xml_error_string -- Obtém uma string de erro do analisador XML

xml_get_current_byte_index -- Obtém o índice do byte atual para um analisador XML

xml_get_current_column_number -- Obtém o número da coluna atual para um analisador XML

xml_get_current_line_number -- Obtém o número da linha para um analisador XML

xml_get_error_code -- Obtém um código de erro do analisador XML

xml_parse_into_struct -- Analisa dados XML dentro de uma estrutura de array

xml_parse -- Inicia a análise em um documento XML

xml_parser_create_ns -- Cria um analisador XML com suporte a namespace (uma estrutura do XML)

xml_parser_create -- cria um analisador XML

xml_parser_free -- Free an XML parser

xml_parser_get_option -- Get options from an XML parser

xml_parser_set_option -- Set options in an XML parser

xml_set_character_data_handler -- Set up character data handler

xml_set_default_handler -- Set up default handler

xml_set_element_handler -- Set up start and end element handlers

xml_set_end_namespace_decl_handler -- Set up end namespace declaration handler

xml_set_external_entity_ref_handler -- Set up external entity reference handler

xml_set_notation_decl_handler -- Set up notation declaration handler

xml_set_object -- Use XML Parser within an object

xml_set_processing_instruction_handler -- Set up processing instruction (PI) handler

xml_set_start_namespace_decl_handler -- Set up start namespace declaration handler

xml_set_unparsed_entity_decl_handler -- Set up unparsed entity declaration handler

 

O que é um parser DOM?

 

Existe 2 formas de criar um parser para analisar documentos XML, a primeira você ja viu acima

e se chama SAX, a outra auternativa é utilizando o modelo DOM(Document Object Model) nesse modelo é criado

uma estrutura de representação em árvore, permitindo que programas e scripts auterem dinamicamente seu conteudo

mais informações em www.w3c.org/dom

 

Usando o SAX ou DOM você obterá o mesmo resultado, a diferença está apenas na questão de desempenhoe acessibilidade.

Em relação a velocidade o SAX apresenta um melhor desempenho, visto que o parser DOM precisa criar uma árvore completoa com todos

os dados do documento XML

Mas por outro lado o parser DOM tem a vantagem de ser mais flexivel no que diz respeito acessibilidade de dados

 

parser DOM é um modulo experimental, mais detalhes www.php.net/ref.domxml.html

 

Funções de Memória Compartilhada

 

Shmop é um fácil caminho para usar funções que permitem o PHP ler, escrever, criar e deletar segmentos de memória compartilhada UNIX.

Note que versões do Windows anteriores ao Windows 2000 não suportam memória compartilhada.

obs: precisa descomentar a linha extension=php_shmop.dll no php.ini

 

exemplo:

 

<?php

// Cria 100 byte num pedaço da memoria
$memoria_id = shmop_open(0xff3, "c", 0644, 100);
if(!$memoria_id) {
echo "Não foi possivel criar a repartição da memoria\n";
}

// Pega pedaço da memoria criada
$memoria_size = shmop_size($memoria_id);
echo "Foi criado: $memoria_size bytes na memoria com sucesso<br>";

// Escrever frase na memoria
$grava_memoria = shmop_write($memoria_id, "meu teste de memoria", 0);
//Testa se nao tiver escrito o texto na memoria
if($grava_memoria != strlen("meu teste de memoria")) {
echo "Nao foi possivel gravar na memoria\n";
}

// Ler frase na memoria
$meu_texto = shmop_read($memoria_id, 0, $memoria_size);
if(!$meu_texto) {
echo "Nao foi possivel ler da memoria\n";
}
echo "Minha frase gravada na memoria é : $meu_texto";

//Agora apago da memoria
if(!shmop_delete($memoria_id)) {
echo "Apagado com sucesso.";
}
shmop_close($memoria_id);

?>

[Minoru 0]

Fabyo muito bom seus crusos explicando o php fica mais facil de entender ..Parabens

[rodrigo_medeiros 0]

Me da uma ajuda quando eu tento conectar ao mysql dá esse erro:Warning: mysql_connect(): Can't connect to local MySQL server through socket '/tmp/mysql.sock'Já verifiquei e o mysql.sock tá na pasta /var/lib/mysql/mysql.sock...O que devo fazer parq conseguir que o programa ache o sock??????

[Zig 0]

Muito bom esses tutoriais, muito show agora o PHP vai se entendido melhor

[thiagocodu 0]

Valeu!!!deu para pegar uma noção inicial, agora é só desenvolver!!! ;)

[luis-restart 0]

Fala fabyo(master) =D,otimo esse modulo, soh tenho uma duvida, qnto a utilizacao de memoria pelo php, voce tem algum exemplo pra mostrar o uso disso?, pois eu nao achei nada assim que usasse ainda...[]sluis

[Fabyo 66]

olha nao vejo muita utilidade para uso em servidores, onde pode consumir muita memoria do servidor usando em escala

 

mas pra usar no micro de casa eu ate fiz um sistema de login que mantem o usuario logado pela memoria

dai em vez de eu usar session ou cookie eu usei a memoria dai testo se ta logado ou nao etc...

 

mas como falei tem uma pequena utilidade usando pra sistema pequenos ou intranet