Bloquear alteração do proxy no Firefox

Bloquear alteração do proxy no Firefox
Para impedir que usuários alterem a configuração do proxy vamos ao passo a passo:

Acesse a pasta “C:\Program Files\Mozilla Firefox”

Crie o arquivo “mozilla.txt”

Dentro do arquivo insira as seguintes linhas
lockPref(“network.proxy.backup.ftp”,”192.168.0.1″);
lockPref(“network.proxy.backup.ftp_port”,3128);
lockPref(“network.proxy.backup.socks”,”192.168.0.1″);
lockPref(“network.proxy.backup.socks_port”,3128);
lockPref(“network.proxy.backup.ssl”,”192.168.0.1″);
lockPref(“network.proxy.backup.ssl_port”,3128);
lockPref(“network.proxy.ftp”,”192.168.0.1″);
lockPref(“network.proxy.ftp_port”,3128);
lockPref(“network.proxy.http”,”192.168.0.1″);
lockPref(“network.proxy.http_port”,3128);
lockPref(“network.proxy.no_proxies_on”,”localhost, 127.0.0.1″);
lockPref(“network.proxy.share_proxy_settings”,true);
lockPref(“network.proxy.socks”,”192.168.0.1″);
lockPref(“network.proxy.socks_port”,3128);
lockPref(“network.proxy.ssl”,”192.168.0.1″);
lockPref(“network.proxy.ssl_port”,3128);
lockPref(“browser.startup.homepage”,”http://www.google.com.br/”);
lockPref(“network.proxy.type”,1);

Altere “192.168.0.1” para o endereço de seu proxy, mas mantenha as “”.
Altere “http://www.google.com.br/” para uma página padrão de sua preferencia mas mantenha as “”.

Agora que temos o .txt precisamos transforma-lo em .cfg, nas versões mais antigas do firefox era somente renomear as extensões e pronto, nos mais novos precisamos passa-lo por um conversor.

Para isso acesse http://www.alain.knaff.lu/howto/MozillaCustomization/cgi/byteshf.cgi, na segunda opção onde aparece “Upload mozilla.txt to get mozilla.cfg (byteshift 13)” clique em “Selecionar arquivo” e selecione o mozilla.txt que criamos e clique em “Convert mozilla.txt to mozilla.cfg”

Pronto agora temos o mozilla.cfg configurado.

Para finalizar temos que “obrigar” o navegador a usar essa configuração para todos os usúarios.

Abra a pasta “C:\Program Files\Mozilla Firefox\defaults\pref”, crie um arquivo chamado all.js edite ele e insira as seguintes informações:
pref(“general.config.filename”, “mozilla.cfg”);
pref(“general.config.obscure_value”, 13);

Em alguns casos precisei reiniciar a máquina para funcionar.

Pronto abra o navegador e você verá que o proxy esta configurado e não tem como alterar as configurações.

Lendo um HTML com php utilizando a biblioteca cURL

É um artigo simples onde explico como pegar o conteudo HTML de uma url qualquer e salvar em uma variavel com php.

Eu utilizei o modelo para gerar um pdf mas existem outras milhares de utilizacoes.


<?php

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, “http://www.gilix.com.br/”);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 1);
curl_setopt($ch,CURLOPT_USERAGENT,$_SERVER[‘HTTP_USER_AGENT’]);

$pagina =  curl_exec($ch);

?>

<textarea cols=”130″ rows=”60″><?php echo $pagina; ?></textarea>

Explicacoes:

CURLOPT_RETURNTRANSFER: TRUE para retornar a transferencia como uma string do valor de retorno de curl_exec () em vez de diretamente para a saída.

CURLOPT_HEADER: TRUE para incluir o cabeçalho na saída.

CURLOPT_USERAGENT: Envia o cabeçalho do seu browser para o site assim simulando que voce esta acessando a pagina do seu browser.

Abaixo um exemplo de uso do cURL para puxar os resultados de loteria da página da Folha de São Paulo.

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL,"http://www1.folha.uol.com.br/folha/loterias/loteria_federal.shtml");
curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);
$result=curl_exec ($ch);
curl_close ($ch);
$core = split('<!--LOTERIA_FEDERAL-->', $result);
$main = split('<!--/LOTERIA_FEDERAL-->', $core[1]);
echo $main[0];
?>

 

Fontes:

http://hk2.php.net/curl_setopt
http://md.php.net/curl_init

Recortando imagens com jCrop e PHP

Quando desenvolvemos um sistema com upload de fotos envolvendo miniaturas, é muito comum um cliente não gostar dos thumbnails gerados automaticamente pelo PHP, já que todos devem possuir o corte nas mesmas coordenadas X e Y. Existem duas maneiras de resolver o problema: uma é criar um novo campo de upload para que o cliente já mande a miniatura no tamanho certinho. A outra é desenvolver uma interface em javascript para o cliente selecionar, após o upload, a área da foto que ele deseja utilizar na miniatura.

O plugin jCrop que apresento neste artigo facilita a implementação da segunda solução. Além de desenvolver o frontend, vou também mostrar a parte em PHP que redimensiona e recorta a imagem – tudo isso utilizando nossa classe m2brimagem.

Configurações iniciais

Como se trata de um plugin jQuery precisamos da chamada para a biblioteca em algum lugar de nosso HTML. Além disso, vamos precisar também incluir o arquivo fonte do jCrop com sua folha de estilo e imagens necessárias. Clique aqui para fazer o download dos arquivos.

<link href="css/jquery.Jcrop.css" rel="stylesheet" type="text/css" />
<script src="js/jquery.min.js"></script>
<script src="js/jquery.Jcrop.js"></script>

Desse jeito já dá pra utilizar o jCrop em sua forma mais básica:

<img src="imagem.jpg" width="634" height="340" id="jcrop" />
<script type="text/javascript">
$(function(){ 
	$('#jcrop').Jcrop(); 
});
</script>

No exemplo acima, ‘#jcrop’ é o atributo ID da imagem alvo do crop. Você pode utilizar qualquer tipo de seletor do jQuery (classes, sub-elementos etc.), aplicando o frontend do crop em vários elementos img.

Muito legal, mas e pra salvar a imagem? O plugin funciona apenas no cliente, na interface da aplicação. O crop mesmo tem que ser feito no servidor.

Processando o crop com PHP

Primeiramente vamos entender como funciona o jCrop. Seu método de marcação na imagem retorna um array com as dimensões e o posicionamento do crop. Ele possui alguns eventos, aqui vamos utilizar os dois principais: onChange e onSelect. O onChange executa uma função qualquer no momento que a marcação é alterada e o onSelect executa uma função qualquer no momento que a seleção está em andamento.

Sendo assim, vamos utilizar, por enquanto, a função exibePreview em ambos os casos. O que ela faz é atualizar uma pré-visualização do resultado final do crop, além de armazenar as variáveis para envio e processamento no servidor.

function exibePreview( c )
{
	// c.x, c.y, c.x2, c.y2, c.w, c.h
};

A função recebe o array c, aquele com as dimensões e coordenadas do crop. Os valores do array são:

w largura (width) do crop
h altura (height) do crop
x1 e x2 posições horizontais do crop na imagem
y1 e y2 posições verticais do crop na imagem

Note que é aí que termina o trabalho do jCrop. Os valores devem ser processados no PHP. No nosso exemplo, conforme mencionei anteriormente, a função exibePreview vai registrar as posições em inputs do tipo hidden no formulário de envio.

function exibePreview( c )
{
	// campos hidden que armazenam os valores
	$('#x').val(c.x);
	$('#y').val(c.y);
	$('#x2').val(c.x2);
	$('#y2').val(c.y2);
	$('#w').val(c.w);
	$('#h').val(c.h);
};

Além disso ela deve atualizar a pré-visualização da imagem recortada. Pra isso vamos precisar do tamanho original da imagem. Se você está usando o mesmo formato de imagem, basta utilizar os mesmos valores sempre. No nosso caso, como a imagem é enviada via formulário, utilizamos a função getimagesize do php para retornar a largura (índice 0 do array de retorno) e a altura (índice 1). Elas são necessárias para calcular o posicionamento do crop. A idéia é criar um div com as dimensões do crop, mascarando a imagem original.

function exibePreview(c)
{
	var rx = 100 / c.w;
	var ry = 100 / c.h;

	// atualiza CSS do preview para refletir o tamanho da imagem enviada 
	// e o posicionamento do crop
	$('#preview').css({
		width: Math.round(rx * <?php echo $imagesize[0]; ?>) + 'px',
		height: Math.round(ry * <?php echo $imagesize[1]; ?>) + 'px',
		marginLeft: '-' + Math.round(rx * c.x) + 'px',
		marginTop: '-' + Math.round(ry * c.y) + 'px'
	});

	// campos hidden que armazenam os valores
	$('#x').val(c.x);
	$('#y').val(c.y);
	$('#x2').val(c.x2);
	$('#y2').val(c.y2);
	$('#w').val(c.w);
	$('#h').val(c.h);
}

Com a função exibePreview completa, podemos agora atualizar nossa chamada do jCrop:

$('#jcrop').Jcrop({
	onChange: exibePreview,
	onSelect: exibePreview,
	aspectRatio: 1
});

Note a propriedade aspectRatio, utilizada para amarrar largura e altura do crop, mantendo a proporção.

Tudo OK no frontend. Abaixo você confere o código do formulário de envio e o script para processamento da imagem pós-envio (validação e redimensionamento para evitar arquivos gigantes no crop).

<form name="frm-jcrop" id="frm-jcrop" method="post" action="index.php" enctype="multipart/form-data">
	<p>
		<label>Envie uma imagem:</label>
		<input type="file" name="imagem" id="imagem" />
		<input type="submit" value="Enviar" />
	</p>
</form>
// processa arquivo
$imagem		= isset( $_FILES['imagem'] ) ? $_FILES['imagem'] : NULL;
$img		= '';
// verifica se arquivo foi enviado para o servidor
if( $imagem['tmp_name'] )
{
	// move arquivo para o servidor
	if( move_uploaded_file( $imagem['tmp_name'], $imagem['name'] ) )
	{
		include( 'm2brimagem.class.php' );
		$oImg = new m2brimagem( $imagem['name'] );
		if( $oImg->valida() == 'OK' )
		{
			// redimensiona imagem para evitar arquivos grandes
			$oImg->redimensiona( '400', '', '' );
			$oImg->grava( $imagem['name'] );
			// retorna dimensões da imagem e configura variáveis para o jCrop
			$imagesize 	= getimagesize( $imagem['name'] );
			$img		= '<img src="'.$imagem['name'].'" id="jcrop" '.$imagesize[3].' />';
			$preview	= '<img src="'.$imagem['name'].'" id="preview" '.$imagesize[3].' />';
		}
		else
		{
			// imagem inválida, exclui do servidor
			unlink( $imagem['name'] );
		}
	}
}

Está quase pronto. Temos um formulário para envio da imagem, e todo o javascript que vai processar o crop e atualizar o nosso preview. Falta o código PHP que vai de fato recortar a imagem enviada. Para isso utilizaremos a classe m2brimagem (leia mais sobre ela aqui).

O processamento será feito via AJAX/post, apenas para agilizar o retorno ao usuário, mas nada impede você de fazer o crop em um novo envio do formulário.

$('#btn-crop').click(function(){
	$.post( 'crop.php', {
		img:img, 
		x: $('#x').val(), 
		y: $('#y').val(), 
		w: $('#w').val(), 
		h: $('#h').val()
	}, function(){
		$('#div-jcrop').html( '<img src="'+img+'?'+Math.random()+'" width ="'+$('#w').val()+'" height ="'+$('#h').val()+'" />' );
	});
	return false;
});

Uma vez processado, nosso formulário exibirá uma nova tela, com a opção de recortar e salvar um pedaço da imagem enviada. No exemplo você pode observar que, além da imagem e da interface para crop, exibimos também duas janelas adicionais: o preview, já comentado anteriormente; e um pequeno debug, exibindo as informações e coordenadas em tempo real (tudo isso atualizado via exibePreview).

Ao clicar no botão salvar, o usuário executa, via AJAX, o script abaixo, mais uma vez utilizando a classe m2brimagem para o processamento. O script recebe como parâmetro o ponto inicial X e Y do crop, além da largura e altura do mesmo, e cria a versão recortada da imagem original. Após a execução, nosso elemento img é atualizado. Como nesse caso a imagem final possui o mesmo nome da imagem original, utilizamos o “?” com um número randômico (Math.random()) para evitar cache (essa dica é bem legal para sistemas com upload de imagens).

if( $_SERVER['REQUEST_METHOD'] == 'POST' )
{
	include( 'm2brimagem.class.php' );
	$oImg = new m2brimagem( $_POST['img'] );
	if( $oImg->valida() == 'OK' )
	{
		$oImg->posicaoCrop( $_POST['x'], $_POST['y'] );
		$oImg->redimensiona( $_POST['w'], $_POST['h'], 'crop' );
		$oImg->grava( $_POST['img'] );
	}
}
exit;

Outras opções

Talvez tudo pareça um pouco confuso olhando os códigos assim de forma separada. Baixe os exemplos que você vai entender melhor. No site do plugin você encontra a documentação completa, em inglês, além de outros exemplos. Uma opção que utilizo bastante é especificar largura e altura fixas. Quando o usuário faz o upload de um avatar, por exemplo, vale a pena limitar o tamanho no jCrop (ou então fazer alguma coisa proporcional). As propriedades minSize e maxSize delimitam a área mínima e máxima do crop.

$('#jcrop').Jcrop({
	onChange: exibePreview,
	onSelect: exibePreview,
	minSize		: [ 200, 200 ], 
	maxSize		: [ 200, 200 ],
	allowResize	: false,
	addClass	: 'custom'
});

No exemplo acima o crop vai ter sempre 200×200 pixels de dimensão. Além disso configuramos a propriedade allowResize com false, para evitar o redimensionamento da seleção. Outra propriedade legal é a addClass, para definir um estilo personalizado na seleção. No exemplo abaixo a linha fica com uma borda sólida ao invés do pontilhado.

.custom .jcrop-vline, .custom .jcrop-hline {
	background: #FF3366;
}

Esse foi o jCrop, um bônus e tanto para a interface dos seus sistemas. Espero que tenham gostado da leitura e qualquer dúvida utilizem a área de comentários abaixo. Até a próxima!

 

Fonte: www.daviferreira.com

Webservice – Consulta de CEP diretamente ao site dos correios

Até pouco tempo, tinhamos um site onde podiamos fazer consultas via get, ou até baixar a base de dados utilizada de forma gratuita. Mas seu maior problema para todos que já utilizaram tal base era o fato desta ser muito antiga. Com isso surgia o problema de ruas e bairros com nomes errados ou até mesmo não existentes. O tempo passou, a base ficou ainda mais velha e o site passou a cobrar pelos serviços. Mas não tem problema, os correios que antes tinham um sistema que não permitia se aproveitar dos dados (gerava as respostas em imagens), hoje nos disponibiliza uma versão mobile que facilmente nos permite tratar as respostas.

Para criarmos nosso próprio webservice em PHP vamos simular o comportamento realizado pelo site através de requisições cURL.

Aqui incluimos biblioteca phpQuery (http://code.google.com/p/phpquery/) que permite manipular conteúdo html atrvés de seleções tipo jquery/css:

include('phpQuery-onefile.php');

Após criamos uma função para fazermos requisições via cURL, para depois tratarmos com o phpQuery.

function simple_curl($url,$post=array(),$get=array()){
$url = explode('?',$url,2);
if(count($url)===2){
$temp_get = array();
parse_str($url[1],$temp_get);
$get = array_merge($get,$temp_get);
}

$ch = curl_init($url[0].”?”.http_build_query($get));
curl_setopt ($ch, CURLOPT_POST, 1);
curl_setopt ($ch, CURLOPT_POSTFIELDS, http_build_query($post));
curl_setopt ($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
return curl_exec ($ch);
}

Depois de ambiente preparado, mãos as teclas. Aqui esta o cep a ser consultado:

$cep = $_GET['cep'];

Fazemos uma chamada POST direta aos correios http://m.correios.com.br/movel/buscaCepConfirma.do. Para entender, acesse a url pelo navegador e faça uma consulta, nosso webservice fará o mesmo, mas atráves do servidor.

Aqui é onde capturamos o HTML através da chamada cURL, enviando os parametros necessários.

$html = simple_curl('http://m.correios.com.br/movel/buscaCepConfirma.do',array(
'cepEntrada'=>$cep,
'tipoCep'=>'',
'cepTemp'=>'',
'metodo'=>'buscarCep'
));

Fazemos o phpQuery ler o HTML capturado:

phpQuery::newDocumentHTML($html, $charset = 'utf-8');

Aqui tratamos os dados com o phpQuery a função pq(), é equivalente ao $() do jQuery $(#id elemento.classe).html() em jQuery, e em PHP pq(#id elemento.classe)->html(). Então temos nosso logradouro, bairro, cidade/uf e cep:

$dados =
array(
'logradouro'=> trim(pq('.caixacampobranco .resposta:contains("Logradouro: ") + .respostadestaque:eq(0)')->html()),
'bairro'=> trim(pq('.caixacampobranco .resposta:contains("Bairro: ") + .respostadestaque:eq(0)')->html()),
'cidade/uf'=> trim(pq('.caixacampobranco .resposta:contains("Localidade / UF: ") + .respostadestaque:eq(0)')->html()),
'cep'=> trim(pq('.caixacampobranco .resposta:contains("CEP: ") + .respostadestaque:eq(0)')->html())
);

Como nem tudo é perfeito, temos que tratar as informações de cidade/uf que vem ‘grudadas’:

$dados['cidade/uf'] = explode('/',$dados['cidade/uf']);
$dados['cidade'] = trim($dados['cidade/uf'][0]);
$dados['uf'] = trim($dados['cidade/uf'][1]);
unset($dados['cidade/uf']);

Pronto, basta agora imprimir no formato json e começar a fazer as requisições via ajax:

die(json_encode($dados));

Ao invés do phpQuery, podiamos ter usado o YQL, porém teriamos dobrado o numero de requições, pois chamariamos o servidor do yahoo que por sua vez chamaria o servidor dos correios.

Em caso de erro de CEP não encontrado:

newDocumentHTML(self::$html, $charset = ‘utf-8′);
$errCEP= array(‘erro’=> trim(pq(‘.erro:eq(0)’)->html()));

if(empty($errCEP[“erro”])){

$dados =
array(
‘logradouro’=> trim(pq(‘.caixacampobranco .resposta:contains(“Logradouro: “) + .respostadestaque:eq(0)’)->html()),
‘bairro’=> trim(pq(‘.caixacampobranco .resposta:contains(“Bairro: “) + .respostadestaque:eq(0)’)->html()),
‘cidade/uf’=> trim(pq(‘.caixacampobranco .resposta:contains(“Localidade / UF: “) + .respostadestaque:eq(0)’)->html()),
‘cep’=> trim(pq(‘.caixacampobranco .resposta:contains(“CEP: “) + .respostadestaque:eq(0)’)->html())
);

}else{

echo “CEP não localizado!!!”;

}

Façaa aqui o download dos arquivos de exemplo.

 

Fonte: http://www.pinceladasdaweb.com.br

Iniciando com Jquery







Por onde começar com a jQuery

Este guia é uma introdução à biblioteca jQuery. Ter um conhecimento sobre javascript e modelo de objeto de documento (DOM) são requisitos necessários. Ele começa do básico e tenta explicar os detalhes quando necessário. Ele abordará um exemplo simples alô mundo, seletores e eventos básicos, AJAX, efeitos e o desenvolvimento de plugins.

Este guia não contém exemplos “prontos para clicar”. A intenção de prover apenas os “códigos para copiar” é um convite para que você mesmo faça os testes. Copie um exemplo, veja o que ele faz, e modifique-o.

Conteúdo

  1. Configuração
  2. Olá jQuery
  3. Me encontre: Usando seletores e eventos
  4. Me avalie: Usando AJAX
  5. Me anime: Usando Efeitos
  6. Me ordene: Usando o plugin tablesorter (ordenador de tabela)
  7. Me plugue: Escrevendo seus próprios plugins
  8. Próximos passos

Configuração

Para começar, nós precisamos de uma cópia da bliblioteca jQuery. Ainda que a versão mais recente possa ser encontrada aqui, este guia fornece um pacote básico que você poderá baixar.

Kit para começar com o jQuery

Faça o download deste arquivo e extraia o seu conteúdo. Abra o starterkit.html e o custom.js com o seu editor preferido e o starterkit.html com o navegador.

Agora nós temos tudo o que precisamos para inciar o notório exemplo do “Alô mundo”.

Links interessantes para este capítulo:

Olá jQuery

Como quase tudo o que fazemos quando estamos utilizando o jQuery lê ou manipula um modelo de objeto de documento (DOM), precisamos nos certificar que começamos adicionado eventos etc tão logo o DOM esteja pronto.

Para fazer isso, nós registramos o evento ready (pronto) para o documento.

$(document).ready(function() {
	// faça alguma coisa quando o DOM estiver pronto
});

Colocar um alert nesta função não faz muito sentido, pois o alert não requer que o DOM esteja carregado. Então vamos tentar algo mais sofisticado: Mostrar um alert quando clicarmos o link.

$(document).ready(function() {
	$("a").click(function() {
		alert("Olá mundo!");
	});
});

Dessa forma o alert será exibido assim que você clicar no link.

Vamos dar uma olhada no que estamos fazendo: $("a") é um seletor do jQuery, neste caso, ele seleciona todos os elementos a. O $ por si só é um alias para a “classe” jQuery, por outro lado o $() constrói um novo objeto jQuery. A função click() que chamamos depois é um método do objeto jQuery. Ele liga o evento clique a todos os elementos selecionados (neste caso, um único elemento a) e executa a função fornecida quando o evento ocorre.

Isto é similar ao seguinte código:

<a href="#" onclick="alert('Olá mundo')">Link</a>

A diferença é bem óbvia: Nós não precisamos escrever onclick para todo elemento. Nós temos uma separação clara de estrutura (HTML) e comportamento (JS), assim como separamos estrutura e formatação utilizando CSS.

Com isso em mente, exploramos seletores e eventos um pouco mais a fundo.

Links interessantes para este capítulo:

Me encontre: Usando seletores e eventos

O jQuery provê duas maneiras de selecionar elementos. A primeira utiliza uma combinação de seletores CSS e XPath
passados como uma string para o construtor do jQuery (ex. $("div > ul a")). A segunda utiliza vários métodos do objeto jQuery. Ambas podem ser combinadas.

Para testar alguns desses seletores, vamos selecionar e modificar a primeira lista ordenada no nosso kit para começar.

Primeiramente queremos selecionar a própria lista. A lista tem um ID “listaOrdenada”. No javascript clássico, você pode selecioná-la usando document.getElementById("listaOrdenada").
Com o jQuery, nós fazemos isso assim:

$(document).ready(function() {
	$("#listaOrdenada").addClass("vermelho");
});

O kit para começar fornece uma folha de estilos com a classe “vermelho” que simplesmente adiciona um fundo vermelho.
No entanto, quando você recarrega a página no seu navegador, você verá que a primeira lista tem o fundo vermelho. A segunda lista permanece inalterada.

Agora vamos adicionar mais classes para os elementos filhos desta lista.

$(document).ready(function() {
	$("#listaOrdenada > li").addClass("azul");
});

Isto seleciona todos os lis filhos do elemento com id listaOrdenada e adiciona a classe “azul”.

Agora alguma coisa mais sofisticada: Nós queremos adicionar e remover a classe quando o usuário passar o mouse sobre o elemento li, mas somente no último elemento da lista.

$(document).ready(function() {
	$("#listaOrdenada li:last").hover(function() {
		$(this).addClass("verde");
	}, function() {
		$(this).removeClass("verde");
	});
});

Existem diversos outros seletores similires à sintaxe CSS e XPath.
Mais exemplos e a lista de todas as expressões disponíveis podem ser encontrados aqui.

Para todo evento onxxx disponível, como onclick, onchange, onsubmit, existem um equivalente no jQuery. Alguns outros eventos, como ready e hover, são métodos convenientes para algumas tarefas.

Você pode encontrar uma lista completa com todos os eventos suportados no Visual
jQuery
, na seção de Events.

Com estes seletores e eventos você já pode fazer muita coisa, mas tem muito mais.

$(document).ready(function() {
        $("#listaOrdenada").find("li").each(function(i) {
            $(this).html( $(this).html() + " BAM! " + i );
        });
    });

O find() permite que você faça uma pesquisa mais a fundo nos descendentes dos elementos já selecionados, apesar de $("#listaOrdenada).find("li") ser praticamente o mesmo que $("#listaOrdenada
li")
. O each() faz a iteração sobre cada elemento e permite um processamento mais profundo. A maioria dos métodos, como o addClass(), utiliza o each() internamente. Neste exemplo, o html() é utilizado para recuperar o texto de cada elemento li, adicionar algum texto a ele e definí-lo como o texto do elemento.

Uma outra tarefa que você frequentemente terá que lidar é chamar métodos em elementos DOM que não são suportados pelo jQuery. Pense em um formulário que você gostaria de resetar depois que enviou com sucesso via AJAX.

$(document).ready(function() {
	// use isto para resetar um único formulário
	$("#reset").click(function() {
		$("#form")[0].reset();
	});
});

Este código seleciona o elemento com o ID “form” e chama o reset() no primeiro elemento selecionado. Caso exista mais de um form, você pode fazer dessa maneira:

$(document).ready(function() {
	// use isto para resetar todos os formulários de uma só vez
	$("#reset").click(function() {
		$("form").each(function() {
			this.reset();
		});
	});
});

Isto deve selecionar todos os formulários no seu documento, fazer a iteração sobre eles e chamar o reset() para cada um.

Outro problema que você pode encontrar é não selecionar alguns elementos. O jQuery provê o filter()
e o not() para isto. Enquanto o filter() reduz a seleção para os elementos que atendem à expressão de filtro, o not() faz exatamente o contrário, removendo todos os elementos que atendem a expressão. Imagine uma lista desordenada onde você quer selecionar todos os elementos li que não possuam um filho ul.

$(document).ready(function() {
	$("li").not("[ul]").css("border", "1px solid black");
});

Isto seleciona todos os elementos li e remove todos os elementos da seleção que possuam um elemento ul como filho. Sendo assim todos os elementos li ficarão com uma borda, com exceção daqueles que possuam um filho ul. A sintaxe [expressão] é vinda do XPath e pode ser utilizada para filtrar elementos e atributos filhos. Talvez você queira selecionar todas as âncoras que possuam o attributo name:

$(document).ready(function() {
	$("a[@name]").background("#eee");
});

Isto adiciona uma cor de fundo para todos os elementos âncora com o atributo name.

Mais comum que selecionar as âncoras pelo nome, você pode precisar selecionar as âncoras pelo atributo “href”. Isto pode ser um problema uma vez que os navegadores se comportam inconsistentemente quando retornam o que eles pensam que o valor do “href” é. Para selecionar apenas uma parte do value, podemos utilizar o seletor contém “*=” ao invés do igual (“=”):

$(document).ready(function() {
	$("a[@href*=/content/gallery]").click(function() {
		// faça alguma coisa com todos os links que apontam para algum lugar em /content/gallery
	});
});

Até agora, usamos todos os seletores para selecionar os filhos ou filtrar a seleção atual. Existem situações onde você irá precisar selecionar os anteriores ou próximos elementos, conhecidos como siblings (filhos do mesmo pai). Pense em uma página de um FAQ, onde todas as respostas estão escondidas em um primeiro momento e são exibidas quando a questão é clicada. O código do jQuery para isso:

$(document).ready(function() {
	$('#faq').find('dd').hide().end().find('dt').click(function() {
         var resposta = $(this).next();
         if (resposta.is(':visible')) {
             resposta.slideUp();
         } else {
             resposta.slideDown();
         }
     });
});

Aqui estamos usando um pouco de encadeamento para reduzir o tamanho do código e ganhar performance, uma vez que ‘#faq’ é selecionada apenas uma única vez. Usando o end(), o primeiro find() é desfeito, assim podemos começar a procurar com o próximo find() no nosso elemento #faq, ao invés de procurar no filho dd.

Com o acionamento do evento click, a função passada ao método click(), utilizamos $(this).next() para encontrar o próximo sibling a partir do dt atual. Isto nos permite selecionar rapidamente a resposta seguinte à questão clicada.

Além dos siblings, você também pode selecionar os elementos pais (também conhecidos como ancestrais para os mais familiarizados com o XPath). Talvez você pode querer realçar o parágrafo que é o pai do link que o usuário passar o mouse. Tente isso:

$(document).ready(function() {
        $("a").hover(function() {
            $(this).parents("p").addClass("realcar");
        }, function() {
            $(this).parents("p").removeClass("realcar");
        });
    });

Para todos os elementos âncoras que o usuário passar o mouse, o parágrafo pai é procurado e a classe “realcar” é adicionada e removida.

Vamos voltar um passo atrás de continuarmos: o jQuery faz com que o código fique menor e tornando-o mais fácil de ler e dar manutenção. O código seguinte é um atalho para a notação $(document).ready(callback):

$(function() {
	// código a ser executado quando DOM está pronto
});

Aplicado ao exemplo do Alô Mundo!, ficaria assim:

$(function() {
	$("a").click(function() {
		alert("Alô Mundo!");
	});
});

Agora com o básico em mãos, queremos explorar outros aspectos, começando com o AJAX.

Links interessantes para este capítulo:

Me avalie: Usando AJAX

Nesta parte nós escreveremos uma pequena aplicação AJAX que permite que o usuário avalie alguma coisa, assim como é feito no youtube.com.

Precisamos de um pouco de código do servidor para isso. Meu exemplo utiliza um arquivo php que lê o parâmetro “avaliacao” e retorna o número de avaliações e a média de avaliação. Dê uma olhada no rate.php para o código server-side.

Nós não queremos que este exemplo funcione sem AJAX, mesmo que isto seja possível, então nós geramos a marcação necessária com o jQuery e a adicionamos à div com o ID “avaliacao”.

$(document).ready(function() {
	// gera a marcação
	var ratingMarkup = ["Por favor avalie: "];
	for(var i=1; i <= 5; i++) {
		ratingMarkup[ratingMarkup.length] = "<a href='#'>" + i + "</a> ";
	}
	// adiciona a marcação ao container e aplica o acionador de click às âncoras
	$("#avaliacao").append( ratingMarkup.join('') ).container.find("a").click(function(e) {
		e.preventDefault();
		// envia a requisição
		$.post("rate.php", {avaliacao: $(this).html()}, function(xml) {
			// formata o resultado
			var resultado = [
				"Obrigado por avaliar, média atual: ",
				$("media", xml).text(),
				", número de votos: ",
				$("contador", xml).text()
			];
			// saída do resultado
			$("#avaliacao").html(resultado.join(''));
		} );
	});
});

Este pedaço de código gera cinco elementos âncoras adicionando-os ao elemento container com o id “avaliacao”. Depois disso, para cada âncora no container, um observador do click é adicionado. Quando a âncora é clicada, uma requisição post é enviada para o rate.php com o conteúdo da âncora como parâmetro. O resultado retornado como um XML é então adicionado ao container, substituindo as âncoras.

Se você não possui um servidor web com o PHP instalado em mãos, você pode dar uma olhada no exemplo on-line.

Para ver um exemplo muito bom de um sistema de avaliação que funciona até mesmo sem javascript, visite softonic.de e clique em “Kurz bewerten!”

Mais documentação sobre os métodos AJAX do jQuery pode ser encontrada aqui ou no Visual jQuery na categoria AJAX.

Um problema muito comum encontrado quando se carrega um conteúdo por AJAX é o seguinte: Quando se adiciona controladores de evento ao seu documento que deveriam ser aplicados também ao conteúdo carregado, você deve aplicar estes controladores depois que o conteúdo é carregado. Para prevenir a código duplicado, você pode delegar a uma função. Exemplo:

// Vamos usar o atalho
$(function() {
	var addClickHandlers = function() {
		$("a.cliqueParaCarregarConteudo").click(function() {
			$("#target").load(this.href, addClickHandlers);
		});
	};
	addClickHandlers();
});

Agora a função addClickHandlers é aplicada uma vez quando o DOM está pronto e depois toda vez que o usuário clicar um link com a classe cliqueParaCarregarConteudo e o conteúdo tiver terminado de ser carregado.

Por favor observe que a função “addClickHandlers” é definida como uma variável local, ao invés de uma função global (como function addClickHandlers() {...}). Procure seguir esta prática para prevenir conflito com outras variáveis ou funções globais.

Com AJAX podemos explorar muita coisa “Web 2.0”. Mas até agora estamos devendo efeitos bacanas.

Links interessantes para este capítulo:

Me anime: Usando Efeitos

Animações simples com o jQuery podem ser feitas com o show() e o hide()

$(document).ready(function() {
	$("a").toggle(function() {
		$(".algumacoisa").hide('slow');
	}, function() {
		$(".algumacoisa").show('fast');
	});
});

Você pode criar qualquer combinação das animações com o animate() como por exemplo um slide com fade:

$(document).ready(function() {
	$("a").toggle(function() {
		$(".algumacoisa").animate({
			height: 'hide',
			opacity: 'hide'
		}, 'slow');
	}, function() {
		$(".algumacoisa").animate({
			height: 'show',
			opacity: 'show'
		}, 'slow');
	});
});

Efeitos muito mais sofisticados podem ser feitos com a coleção de plugins Interface. No site você encontrará demonstrações e a documentação.

Além da coleção Interface, que está no topo da lista de plugins do jQuery, existem muitos outros. O próximo capítulo lhe mostrará como usar o plugin tablesorter.

Links interessantes para este capítulo:

Me ordene: Usando o plugin tablesorter

O plugin tablesorter permite que você ordene as tabelas no lado do cliente. Você inclui o jQuery e o pluguin e informa ao pluguin quais tabelas deseja ordernar.

Para experimentar este exemplo, adicione esta linha ao starterkit.html (abaixo da inclusão do jquery):

<script src="lib/jquery.tablesorter.js" type="text/javascript"></script>

Depois de incluir o plugin, você poderá chamá-lo assim:

$(document).ready(function() {
	$("#large").tableSorter();
});

Tente clicar nos cabeçalhos da tabela e veja se ela fica ordenada em ordem ascendente no primeiro clique e descendente no segundo.

A tabela deve utilizar algum realce nas linhas, podemos adicioná-los passando algumas opções:

$(document).ready(function() {
	$("#large").tableSorter({
		stripingRowClass: ['odd','even'],	// Nome da classe a ser utilizada para a divisão das linhas como um array.
		stripRowsOnStartUp: true		// Divide as linhas quando o tableSorter iniciar.
	});
});

Existem mais exemplos e documentação sobre as opções disponíveis no site do tablesorter.

A maioria dos plugins podem ser utilizados como este: Inclua o arquivo do pluguin e chame o método do plugin em alguns elementos, passando os parâmetros opcionais para customizar o plugin.

Uma lista atualizada dos plugins disponíveis pode ser encontrada no site do jQuery.

Quando você utilizar o jQuery com mais frequência, você perceberá que será melhor empacotar o seu próprio código como um plugin, seja para o reuso para você mesmo ou para a sua empresa, ou para compartilhá-lo com a comunidade. O próximo capítulo dá algumas dicas sobre como estruturar um plugin.

Links interessantes para este capítulo:

Me plugue: Escrevendo seus próprios plugins

Escrever seus próprios plugins para o jQuery é muito fácil. Se você seguir as regras abaixo, será fácil para outros integrarem o seu plugin também.

  1. Encontre um nome para o seu plugin, vamos chamar o nosso exemplo “foobar”.
  2. Crie um arquivo chamado jquery.[nomedoseuplugin].js, ex. jquery.foobar.js
  3. Crie um ou mais métodos no plugin extendendo o objeto jQuery, ex.:
    jQuery.fn.foobar = function() {
    	// faça alguma coisa
    };
  4. Opcional: Crie um objeto com funções de ajuda, ex.:
    jQuery.fooBar = {
    	height: 5,
    	calculateBar = function() { ... },
    	checkDependencies = function() { ... }
    };

    Você poderá então chamar essa função de ajuda pelo seu plugin:

    jQuery.fn.foobar = function() {
    	// faça alguma coisa
    	jQuery.foobar.checkDependencies(value);
    	// faça alguma outra coisa
    };
  5. Opcional: Crie configurações padrões que possam ser alteradas pelo usuário, ex.:
    jQuery.fn.foobar = function(options) {
    	var settings = {
    		value: 5,
    		name: "pete",
    		bar: 655
    	};
    	if(options) {
    		jQuery.extend(settings, options);
    	}
    };

    Você pode então chamar o plugin sem opções, usando as configurações padrões:

    $("...").foobar();

    Ou com algumas opções:

    $("...").foobar({
    	value: 123,
    	bar: 9
    });

Se você lançar o seu plugin, você deverá prover alguns exemplos e uma documentação. Existem diversos plugins disponíveis como ótimas referências.

Agora você já deve ter uma idéia básica de como escrever um plugin. Vamos utilizar este conhecimento e escrever nosso próprio plugin.

Uma coisa que muita gente, tentando manipular formulários com o jQuery, pede, é marcar e desmarcar radio buttons ou checkboxes. Eles acabam com um código como este:

$("input[@type='checkbox']").each(function() {
	this.checked = true;
	// ou, para desmarcar
	this.checked = false;
	// ou, para inverter
	this.checked = !this.checked;
});

Sempre que você possuir um each no seu código, você pode querer reescrever isto com um plugin, quase sem alterações:

$.fn.check = function() {
	return this.each(function() {
		this.checked = true;
	});
};

Este plugin agora pode ser utilizado:

$("input[@type='checkbox']").check();

Agova você pode escrever plugins para as duas funções uncheck() e toggleCheck() também. Mas ao contrário nós estendemos nosso plugin para aceitar algumas opções.

$.fn.check = function(modo) {
	var modo = modo || 'on'; // se modo não está definido, use 'on' como padrão
	return this.each(function() {
		switch(modo) {
		case 'on':
			this.checked = true;
			break;
		case 'off':
			this.checked = false;
			break;
		case 'toggle':
			this.checked = !this.checked;
			break;
		}
	});
};

Definindo um valor padrão para as opções, permite que o usuário omita a opção ou passe “on”, “off”, e “toggle”, ex.:

$("input[@type='checkbox']").check();
$("input[@type='checkbox']").check('on');
$("input[@type='checkbox']").check('off');
$("input[@type='checkbox']").check('toggle');

Com mais de uma configuração opcional, este método torna-se complicado, pois o usuário deverá passar valores nulos se quiser omitir o primeiro parâmetro e usar somente o segundo.

O uso do tablesorter no último capítulo demonstra o uso de um objeto literal também resolve este problema. O usuário omite todos os parâmetros ou passa um objeto com um par chave/valor para cada configuração que deseja sobrescrever.

Como um exercício, você poderia tentar reescrever o código do quarto capítulo como um plugin. O esqueleto do plugin deve ser similar a isto:

$.fn.rateMe = function(options) {
	var container = this; // ao invés de selecionar um container estático com  $("#rating"), nós agora utilizamos o contexto do jQuery
	
	var settings = {
		url: "rate.php"
		// coloque mais padrões aqui
		// lembre-se de colocar uma vírgula (",") depois de cada par, mas não depois do último!
	};
	
	if(options) { // verifica se as opções estão presentes antes de estender as configurações
		$.extend(settings, options);
	}
	
	// ...
	// resto do código
	// ...
	
	return this; // se possível, retorne "this" para não quebrar a corrente
});

Próximos passos

Se você tem interesse em desenvolver mais em javascript, você deve dar uma olhada numa extensão do Firefox chamada FireBug. Ela provê um console (ótimo para substituir os alerts), um debugger e outras coisas úteis para o seu desenvolvimento diário em javascript.

Se você tem problemas que não consegue resolver, idéias que gostaria de compartilhar ou apenas necessidade de expressar sua opinião sobre o jQuery, sinta-se à vontade para postar na lista de discussão do jQuery.

Consultando LDAP com PHP

<?php
// Variaveis Globais
$ldap_server = "seudominio.com.br"; 
/*Usamos o nome do dominio ou o nome do Servidor do dominio Casa 
seja 1 servidor Apenas*/
$dominio = "seudominio\\"; /*Aqui usaremos o nome Netbios do dominio*/

// Usuario para autenticacao na Base LDAP
$auth_user = "seudominio\usuario_de_consulta"; 
/*nome Netbios\usuario*/

$auth_pass = "senha_do_usuario"; 
/*Senha do usuario do dominio*/

// Caminho LDAP do Dominio
$base_dn = "OU=DOMINIO,DC=seudominio,DC=com,DC=br"; 
/*Nome do Dominio completo + OU principal*/

// Caminho LDAP do Grupo para consulta
$filter = "(&(objectClass=user)(memberOf=CN=grupo,OU=ou_do_grupo,
OU=ou_principal,DC=seudominio,DC=com,DC=br))";

//Funcao para conectar na base LDAP listar os usuarios de um grupo.

if (($connect=@ldap_connect($ldap_server))) {
 if (($bind=@ldap_bind($connect, $auth_user, $auth_pass))) {
 if (($search=@ldap_search($connect, $base_dn, $filter))){
 $number_returned = ldap_count_entries($connect,$search);
 $info = ldap_get_entries($connect, $search);

   for ($i=0; $i < $info["count"]; $i++){

     $user_pure = $info[$i]["samaccountname"][0];
     $user_up = strtoupper($user_pure);
     echo "Ususario - $user_up<br>";
   }

 }

 }

}
// Fecha a conexao LDAP.
ldap_close($connect);
?>

Fonte: www.revistaphp.com.br

Mais informações sobre AD:
http://www.learnthat.com/Software/learn/1295/Introduction-to-Active-Directory/

Abaixo uma breve descrição das variáveis:
$ldap_server -> essa variavel deve apontar para o servidor Active Directory, que pode ser preenchida com um nome FQDN ou o IP do servidor, ou seja, será a base onde consultaremos o(s) usuário(s).

$dominio -> essa variável deve conter o nome NETBIOS do domínio que é o nome curto do domínio do seu Active Directory. Suponhamos que seu domínio fosse phpldap.com.br , o nome curto(NETBIOS) para esse domínio seria phpldap que atribuímos a variável ‘$dominio’.

$auth_user -> esse variável deve conter o nome de um usuário existente na base do Active Diretory. Suponhamos que você tenha na sua base o usuário ‘teste’, nesse caso usando o exemplo acima com o nome do domínio phpldap a variável seria preenchida assim ‘phpldap\teste’. Esse usuário serva para se conectar a base de dados.
$auth_pass -> essa variável deve ser preenchida com a senha do usuário teste do Active Directory, conforme exemplo acima.

$base_dn -> usando o exemplo do domínio phpldap.com.br essa variável ficaria da seguinte forma ‘OU=phpldap,DC=phpldap,DC=com,DC=br’.

$filter -> deve ser preenchida com o caminho LDAP completo do grupo no qual você deseja pesquisar os usuários.

Obs: o código acima consulta usuários na base de dados de um servidor Active Directory, e também pode ser adaptado para consultar usuários em uma base de dados OPENLDAP.

Entendendo as Expressões Regulares


Prefácio

E o assunto hoje é Expressões Regulares!

Com algumas vasculhadas pela internet podemos encontrar inúmeras definições para expressões regulares, porém, vou ficar com a da Wikipédia de lingua portuguesa.

Uma expressão regular, na Informática, define um padrão a ser usado para procurar ou substituir palavras ou grupos de palavras. É um meio preciso de se fazer buscas de determinadas porções de texto.

Por exemplo, se o conjunto de palavras for {asa, carro, jardim, ovos, terra} e a expressão regular buscar por um padrão rr, obterá as palavras carro e terra.
Existem diferentes formatos para definir-se expressões regulares, porém com algumas noções gerais é possível entender boa parte das expressões.

Fonte: Wikipédia – Expressão Regular

Conceito

As Expressões Regulares (ER, Ereg ou RegEx – para os mais íntimos), então, são um método rápido e simples de manipulação e combinação avançada de strings.

Vamos partir do princípio! Uma expressão regular é essencialmente um padrão. É com base nesse padrão que a expressão em questão será avaliada. Primeiro vamos aprender a sintaxe das expressões para depois aprender como fazê-las funcionar…

Operador ^

Este é o primeiro operador que vamos aprender. O ^ indica que a expressão deve iniciar com a string dada.

^era

Esta sintaxe irá definir que a string dada deverá começar com ‘era’. No caso, “era uma vez” seria uma string concordante. Porém, se você tentar “Ele era triste”, não obterá sucesso.

Operador $

Já que temos o operador para definir o começo, temos que ter um para definir o final também! Com $ nós definimos a string que deverá conincidir com o final.

fim$

Esta sintaxe irá definir que a string dada deverá terminar com ‘fim’. Tentando validar a string “E nunca terá fim” obteremos sucesso, o que não acontecerá com a string “O fim está próximo”.

Caracteres em Branco e Caracteres de Escape

Assim como no PHP, em expressões regulares nós temos também que nos utilizar de caracteres de escape, a saber: barra invertida (\).

Segue, então, a lista com os caracteres de espaço em branco e alguns caracteres que necessitam de escape.

\t – Caracter de tabulação

\n – Nova linha
\f – Avanço de página
\r – Retorno de carro

\. – Qualquer caractere
\\ – Uma barra invertida literal
\- – Um hífen literal

… e com alguma garimpada pela rede você consegue encontrar uma lista mais completa!

Classes de Caracteres

Classes de caracteres são uma espécie de grupo que contêm todas as ocorrências que deverão (ou não deverão) constar em uma expressão…

Por exemplo… Para permitir apenas letras vogais, usaríamos:

[AaEeIiOoUu]

Então com este código teríamos um padrão que só permitirá que apenas vogais estejam na string dada.

Vamos agora aprender intervalo de caracteres

[a-z] – Qualquer letra minúscula
[A-Z] – Qualquer letra maiúscula
[a-zA-Z] – Qualquer letra maiúscula ou minúscula
[0-9] – Qualquer número

[0-9\.\-] – Qualquer número, ponto ou sinal de subtração

Bom… Tudo muito legal, muito simples… Mas isto serve apenas para combinação de UM caractere.

^[a-z][0-9]$

Neste caso teríamos uma expressão de apenas dois caracteres em que o primeiro tem necessariamente que ser uma letra minúscula e o segundo ser um número.

Agora vamos aprender outra função para o operador ^! Fora de uma classe de caracteres, ele serve para demonstrar o que deve haver no início, porém dentro, ele serve para mostrar o que não deve ocorrer.

^[^0-9][0-9]$

Aqui nós definimos que a expressão deve começar com um caractere que não seja um número e seja imediatamente seguido por um caractere que será um número!

Classes de Caracteres Pré-definidas

Para evitar chateação, foram criadas as classes de caracteres pré-definidas que já vêm junto com o interpretador de ER que você estiver utilizando (lembrando que estão presentes apenas no método POSIX).

[[:alpha:]] // Qualquer letra (alfabético)

[[:digit:]] // Qualquer número (dígito)
[[:alnum:]] // Qualquer letra ou número (alfanumérico)
[[:space:]] // Qualquer caractere de espaço
[[:upper:]] // Qualquer letra maíuscula
[[:lower:]] // Qualquer letra minúscula

[[:punct:]] // Qualquer caractere de pontuação
[[:xdigit:]] // Qualquer dígito hexadecimal (Equivalente a: [0-9a-fA-F])

Ocorrências Múltiplas

Agora vamos pra parte em que realmente começa a fazer sentido usar-se expressões regulares.

^[[:alpha:]]{3}$ // Qualquer palavra de três letras

^a{4}$ // Só fecha com a expressão ‘aaaa’
^a{2,4}$ // Fecha com ‘aa’, ‘aaa’ e ‘aaaa’
^a{2,}$ // Fecha com ‘aa’, ‘aaa’, ‘aaaa’, ‘aaaaa’ e assim por diante

Até aqui… Tudo tranquilo? Então vamos em frente!

Há outros modos de representar a repetição de caracteres!

? – Uma ocorrência ou nenhuma (Equivale a {0,1})
* – Nenhuma ocorrência, uma ocorrência, duas ocorrências e por aí vai (Equivale a {0,})
+ – Uma ou mais ocorrências (Equivale a {1,})

Se até aqui foi tudo tranqüilo, estamos muito bem! 🙂

Vamos então para o tópico final de expressões regulares

Alternação e Parênteses

A alternação se baseia no caractere de “pipe”, o famoso |. Ele é bem parecido com o operador lógico OR. Por exemplo…

r|s é equivalente a [rs]

Para caracteres simples é com certeza mais conveniente utilizar as classes. A alternação é basicamente útil para utilizar alternância de palavras.

João|Maria|José

Esta expressão só irá retornar verdadeiro se a string dada for “João” OU “Maria” OU “José”.

Agora vamos aos parênteses. Eles tem uma função muito importante.
Caso você utilize

feliz+

Somente fecharia com:
feliz

felizz
felizzz
felizzzz

Porém com os parênteses, temos um jeito mais interessante de interar com palavras repetidas.

(feliz)+

Irá fechar com:
feliz
felizfeliz
felizfelizfeliz

Quando utilizados em conjunto, obtemos bastante flexibilidade para nossas expressões regulares.

(fel|g|aprend)iz

Irá fechar com:
feliz
giz
aprendiz

———–
João|Maria$ – Fecha com ‘João’ em qualquer parte da string ou com ‘Maria’ no final

(João|Maria)$ – Fecha tanto com “João” quanto “Maria”, porém, no final da string
([ab])([xy]) – Fecha com ‘ax’, ‘ay’, ‘bx’ e ‘by’

E fim de papo!

Utilizando expressões regulares no PHP

Agora que já aprendemos essa porrada de regras, temos que saber como aplicá-las! (Lembrando que este é o método POSIX. Caso você vá utilizar ER em outra linguagem, pode ter de fazer algumas adaptações)

ereg() e eregi()

Vou ensinar apenas essas duas… Caso você queira se aprofundar mais, olhe no manual do php no capitulo de expressões regulares! 🙂

int ereg(string padrão, string fonte [, array registro]);

Esta função retorna TRUE se o padrão dado for encontrado na fonte e FALSE caso contrário.

<?php

$email

= 'mario@gmail.com';

$padrao = "^(.+)@(.+)\.(.+)$";

if (

ereg($padrao,$mail)) {

print

'Seu email passou na validacao';

}

else {

print 'Seu email nao passou na validacao';

}

?>

O que temos?
A string dada deverá começar com algum caractere qualquer em qualquer quantidade, seguido de uma arroba, seguido de mais qualquer caractere em qualquer quantidade, seguido de um ponto literal, seguido de mais qualquer sequência de caracteres, que deverão então finalizar a string.

A função eregi() se comporta de modo semelhante, porém não diferencia maiúsculas e minúsculas.

Conclusão

O mundo das expressões regulares é muito grande e abrangente. Com certeza não vai ser com essa passada de olho que você vai se tornar um expert em ER, mas serve pra dar uma noção do que elas são e para que servem!

Fonte: www.phphit.com.br

Formatação de números em PHP

Atendendo a vários pedidos mostrarei algumas maneiras de formatar
números

Vamos começar pelo básico
Verificando se o número é PAR
ou IMPAR

<?php
function verNumero($numero)

{ // Verificando o resto da divisão por 2

if($numero % 2 == 0)

{ // Se o resto for igual a zero é par

return "PAR";

}

else

{ // Caso não seja zero é impar

return "IMPAR";

}

}

$n = 654646570;

// Chamando a função e passando o parametro

echo verNumero($n);

?>

Trabalhando com potênciação

<?php

function calcula_potencia($base,$expoente){

$nuns = $base;

// For de 1 até o valor do expoente

for($c = 1;$c < $expoente;$c++){

$nuns = $nuns * $base;

}

$verifica = explode("E",$nuns);

if(count($verifica) > 1) {

$nuns = "Expoente muito elevado.";

}

return $nuns ;

}

// Chamando a função passando base 7 e
expoente 2

$potenciacao = calcula_potencia(7,2);

// Imprimindo na tela o resultado

echo $potenciacao;

?>

Verificando se um número é primo

<?php

$num = 1234567891;
if(nPrimo($num))
{
echo "$num é primo.";
}
else
{
echo "$num não é primo.";
}
function nPrimo($numero)
{ //com $numero > 2

$p = 2 ;
while($numero % $p != 0 && $p < sqrt($numero) ) $p+=1 ;

// 1 = Primo / 0 = ñ Primo

return ($numero%$p==0) ? 0 : 1 ;

}

?>

Trabalhando com Fatoração

< ?php

$num = 123456789;

$resposta = fatorarando($num);

echo "Seus fatores: ";

foreach($resposta as $aux) echo "$aux ";

function fatorarando($numero)

{

// $numero > 2

$x=2 ;

while($numero != 1)

{

if($numero % $x == 0)

{ // Vetor recebendo a variavel $x

$vet[] = $x;

$numero = $numero/$x;

}

else

{

$x++;

}

}

return $vet;

}

?>

Formatando moeda

< ?php

// Recebe o parametro $numero

// Existe outra maneira muito mais fácil

// Mas o objetivo e trabalhar seus conhecimentos

function formata($numero)

{

if(strpos($numero,’.’)!=”)

{

$var=explode(‘.’,$numero);

if(strlen($var[0])==4)

{

$parte1=substr($var[0],0,1);

$parte2=substr($var[0],1,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1].’0′;

}else

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1];

}

}

elseif(strlen($var[0])==5)

{

$parte1=substr($var[0],0,2);

$parte2=substr($var[0],2,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1].’0′;

}

else

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1];

}

}

elseif(strlen($var[0])==6)

{

$parte1=substr($var[0],0,3);

$parte2=substr($var[0],3,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1].’0′;

}

else

{

$formatado=$parte1.’.’.$parte2.’,’.$var[1];

}

}

elseif(strlen($var[0])==7)

{

$parte1=substr($var[0],0,1);

$parte2=substr($var[0],1,3);

$parte3=substr($var[0],4,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1].’0′;

}

else

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1];

}

}

elseif(strlen($var[0])==8)

{

$parte1=substr($var[0],0,2);

$parte2=substr($var[0],2,3);

$parte3=substr($var[0],5,3);

if(strlen($var[1])<2){

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1].’0′;

}else{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1];

}

}

elseif(strlen($var[0])==9)

{

$parte1=substr($var[0],0,3);

$parte2=substr($var[0],3,3);

$parte3=substr($var[0],6,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1].’0′;

}

else

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.$var[1];

}

}

elseif(strlen($var[0])==10)

{

$parte1=substr($var[0],0,1);

$parte2=substr($var[0],1,3);

$parte3=substr($var[0],4,3);

$parte4=substr($var[0],7,3);

if(strlen($var[1])<2)

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’.’.$parte4.’,’.$var[1].’0′;

}

else

{

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’.’.$parte4.’,’.$var[1];

}

}

else

{

if(strlen($var[1])<2)

{

$formatado=$var[0].’,’.$var[1].’0′;

}

else

{

$formatado=$var[0].’,’.$var[1];

}

}

}

else

{

$var=$numero;

if(strlen($var)==4)

{

$parte1=substr($var,0,1);

$parte2=substr($var,1,3);

$formatado=$parte1.’.’.$parte2.’,’.’00’;

}

elseif(strlen($var)==5)

{

$parte1=substr($var,0,2);

$parte2=substr($var,2,3);

$formatado=$parte1.’.’.$parte2.’,’.’00’;

}

elseif(strlen($var)==6)

{

$parte1=substr($var,0,3);

$parte2=substr($var,3,3);

$formatado=$parte1.’.’.$parte2.’,’.’00’;

}

elseif(strlen($var)==7)

{

$parte1=substr($var,0,1);

$parte2=substr($var,1,3);

$parte3=substr($var,4,3);

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.’00’;

}

elseif(strlen($var)==8)

{

$parte1=substr($var,0,2);

$parte2=substr($var,2,3);

$parte3=substr($var,5,3);

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.’00’;

}

elseif(strlen($var)==9)

{

$parte1=substr($var,0,3);

$parte2=substr($var,3,3);

$parte3=substr($var,6,3);

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’,’.’00’;

}

elseif(strlen($var)==10)

{

$parte1=substr($var,0,1);

$parte2=substr($var,1,3);

$parte3=substr($var,4,3);

$parte4=substr($var,7,3);

$formatado=$parte1.’.’.$parte2.’.’.$parte3.’.’.$parte4.’,’.’00’;

}

else

{

$formatado=$var.’,’.’00’;

}

}

return $formatado." Reais";

}

$num = 1234567890;

echo formata($num);

?>

Formatação para número inteiro

< ?php

// Formatação para numero inteiro

$number = "1234567890000000";

$number=number_format($number,0,’.’,’.’);

echo $number;

// resultado 1.234.567.890.000.000

?>

Formatação para número monetário

< ?php

// Formatação para numero monetário

$number = "1234567890000000";

$number=number_format($number,2,’,’,’.’);

echo $number;

// resultado 1.234.567.890.000.000,00

?>

Formatação para número inteiro com espaçamento
a cada 3 casas

< ?php

// Formatação para numero inteiro com espaçamento
a cada 3 casas

$number = "1234567890000000";

$number=number_format($number,0,’.’,chr(0xA0));

echo $number;

// resultado 1 234 567 890 000 000

?>

Formatação para número em reais com
decimal 99

< ?php

// Formatação para numero em reais com
decimal 99

$number = "2229346.99";

echo "R$" .number_format($number, 2, ‘,’, ‘.’);

// resultado R$2.229.346,99

?>

Formatação para número
em reais com decimal 00

< ?php

// Formatação para número em reais
com decimal 00

$number = "222934699";

echo "R$" .number_format($number, 2, ‘,’, ‘.’);

// resultado R$222.934.699,00

?>

Formatação para número
em reais sem decimal

< ?php

// Formatação para número em reais
sem decimal

$number = "222934699";

echo "R$" .number_format($number, 0, ‘,’, ‘.’);

// resultado R$222.934.699

?>

Formatação para número
colocando virgula a cada 3 casas

<?php

// Colocando virgula a cada 3 casas

// Recebendo o valor por parametro

function formatar($input)

{

if(strlen($input)<=3)

{ return $input; }

$length=substr($input,0,strlen($input)-3);

$formatted_input = formatar($length).",".substr($input,-3);

return $formatted_input;

}

// numero a ser passado por parametro

$num = 1234567;

// imprimindo o valor

echo formatar($num);

// resultado 1,234,567

?>

Formatação para número
colocando ponto a cada 3 casas

< ?php

// Colocando ponto a cada 3 casas

// Recebendo o valor por parametro

function formatando($input)

{

if(strlen($input)<=3)

{ return $input; }

$length=substr($input,0,strlen($input)-3);

$formatted_input = formatando($length).".".substr($input,-3);

return $formatted_input;

}

// numero a ser passado por parametro

$num = 1234567;

// imprimindo o valor

echo formatando($num);

// resultado 1.234.567

?>

Select Dinâmico De Estados E Cidades

Dando uma passeiada a net encontrei alguns artigos sobre scripts pronto do google e achei um esquema no Blog de um amigo, melhorei o esquema e agora em poucas linhas vc obtem uma cidade a partir de um estado utilizando um select, isso sem precisar de saber coodar em Ajax.

Codigo Fonte:

<html>
<head>
<title>Documento sem t&iacute;tulo</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1″>
<script type=”text/javascript” src=”http://cidades-estados-js.googlecode.com/files/cidades-estados-v0.2.js”></script>
<script>
window.onload = function()
{
new dgCidadesEstados(document.getElementById(‘estado’), document.getElementById(‘cidade’), true);
}
</script>
</head>
<body>
<select id=”estado” name=”estado”></select>
<select id=”cidade” name=”cidade”></select>
</body>
</html>

Escondendo e mostrando Div CSS+JS

Seguinte na função java script ele seta que se receber o parametro SIM ele liga com o style de nome aparece e se receber o parametro não ele liga com o style some, a sua consulta é simples porem é necessário utilizar da lógica exemplo ele recebe o valor sim ai liga com a classe aparece e logo depois modifica o parametro para não pq ai quando clicar novamente então ele vai mandar o valor não e a janela irá se fechar e assim o não ira modificar o parametro para SIM para quando clicar de novo ele mostrar e assim cria-se o laço.

<script language=”javascript”>
function mudaDiv(vlr) {

var div = document.getElementById(vlr);
var check = document.getElementById(“check”);
if (check.value == “sim”) {
div.className = “aparece”;
check.value = “nao”
} else {
div.className = “some”;
check.value = “sim”
}
}
</script>
<style>
.aparece {display: block;}
.some {display: none;}
</style>
<?php $i = 10 ?>

<input type=”submit” id=”Concluir” value=”Concluir” onclick=”mudaDiv(<?=$i ?>)”/>
<input type=”hidden” id=”check” value=”sim” />

<div id=”10″ class=”some”>
AQUI VEM SEUS RESULTADOS
</div>