Exemplos:

// cria um momento para 1
timer(1);

sleep(3);

// cria um momento para 2
timer(1);

for ($i=0; $i < 100000000; $i++);

// mostra o tempo de execução para 2
echo timer(2);

// cria um momento para 3
timer(3);

file_get_contents('http://www.alejandromoraga.com.br/');

// mostra o templo de execução para 3
echo timer(3);

// mostra como seria voltar para 2
echo timer(2);

// mostra o tempo de 1, todas as execuções
echo timer(1);

Resultados

9.24874997139 (momento 2 - laço de 100000000 repetições)
0.300006866455 (momento 3 - requisição)
9.54882502556 (momento 2 - acresc)
12.5501468182 (somatória, incluíndo os 3 segundos iniciais)

A primeira tarefa é criar o HTML. Nada muito complicado, abas em li e o conteúdo em div. Tudo mantido dentro de uma div principal que usaremos para executar o jQuery.

<div class="tabs">
	<ul>
		<li class="in">Item 1</li>
		<li>Item 2</li>
		<li>Item 3</li>
		<li>Item 4</li>
	</ul>
	<div style="display:block">
		Conteúdo do item 1
	</div>
	<div>
		Conteúdo do item 2
	</div>
	<div>
		Conteúdo do item 3
	</div>
	<div>
		Conteúdo do item 4
	</div>
</div>

Na aba que decidir iniciar o conteúdo coloque class="in" e na div corresponde style="display:block". Pode ser na primeira aba, segunda, terceira ou qualquer outra.

A próxima tarefa é o CSS. A partir do CSS básico mostrado aqui, faça suas implementações, mude cores, fundos, bordas, etc.

.tabs > ul {
	bottom: -1px;
	color: #606060;
	margin: 0;
	padding: 0;
	position: relative;
	overflow: hidden;
}

.tabs > ul li {
	background: #d2d6d9;
	color: #858f98;
	cursor: pointer;
	display: block;
	font-weight: bold;
	float: left;
	margin-right: 3px;
	padding: 3px 5px;
	position: relative;
}

.tabs .in {
	border-color: #ccc;
	border-style: solid;
	border-width: 1px 1px 0;
	color: #666;
	cursor: default;
	z-index: 1;
}

.tabs > div {
	border: 1px solid #ccc;
	display: none;
	padding: 10px;
	overflow: hidden;
}

.tabs .in, .tabs > div {
	background-color: #f5f5f5;
}

Agora vem o Javascript. Leia os comentários no código para entender melhor o funcionamento do plugin.

<script type="text/javascript">
(function($) {
	$.fn.extend({
		tabs: function(options) {
			options = $.extend({
				// velocidade de troca das abas
				transition: 'normal',
				// ativa ou desativa a mundança automática
				autotab: false,
				// tempo de permencia em cada aba
				delay: 5000,
			}, options);

			return this.each(function() {
				var self = $(this), tabs = self.children('ul').children(), divs = self.children('div'), i = 0, timer = null;

				// adiciona um evento para que no clique as abas sejam trocadas
				tabs.click(function() {
					tabs.removeClass('in');
					$(this).addClass('in');
					divs.hide();
					// encontra a posição da aba clicada
					i = tabs.index(this);
					$(divs[i]).fadeIn(options.transition);
					// se a mudança automática estiver ativa, o temporizador é reiniciado
					if (options.autotab)
						resetTimer();
				});

				// executa a inicialização do temporizador
				if (options.autotab)
					startTimer();

				// função para iniciar o temporizador
				function startTimer() {
					timer = window.setInterval(showNext, options.delay);
				}

				// função para reiniciar o temporizador
				function resetTimer() {
					window.clearTimeout(timer);
					startTimer();
				}

				// função para mostrar a próxima aba
				function showNext() {
					// encontra a aba que deverá ser exibida
					if (tabs.length > i + 1)
						i++;
					else
						i = 0;

					tabs.removeClass('in');
					$(tabs[i]).addClass('in');

					divs.hide();
					$(divs[i]).fadeIn(options.transition);
				}
			});
		}
	});
})(jQuery);
</script>

Configuração

Podemos configurar a duração do efeito de transição, troca automática de abas e o intervalo de exibição de cada aba.

Configuração padrão:

{
	transition: 'normal',
	autotab: false,
	delay: 5000
}

Duração do efeito de transição

O efeito de transição é o aparecer e desparecer da aba e do conteúdo. Aceita os valores: slow, normal, fast e o tempo milisegundos.

Troca automática

Por padrão as abas ficam fixas, somente são trocadas quando o usuário clica sobre uma aba. Ao definir o valor como true as abas se alternam conforme o tempo configurado no item abaixo.

Intervalo de exibição de cada aba

É o tempo que leva para de uma aba passar para outra. Modifique de acordo com o conteúdo exibido em suas abas.

A linguagem de programação Java te força a programar em classes. Desde o primeiro contato até o último você estará programando em classe, mas nem por isso é orientado a objetos. Objetos precisam se assemelhar aos objetos da vida real. Não é preciso ter dez objetos interagindo entre sí para ser orientado a objetos. Um objeto já é o suficiente. Por exemplo, um objeto ser humano teria os atributos: nome, altura, peso, cor, data de nascimento, estado e os métodos: andar, correr, saltar, dormir. Executar o método andar ou durmir mudaria o estado do objeto.

Outros objetos poderiam fazer parte desse mundo e interagir. Um objeto ônibus, por exemplo, receberia objetos seres humanos variando entre: motorista e passageiros. Quando o ônibus tivesse um motorista e o número mínimo de passegeiros poderia se desclocar para outros lugares. No deslocamento haveria outros veículos e objetos, como faróis e faixas de pedestre. Cada objeto com suas limitações exercendo sua função.

• Atributos e propriedades são a mesma coisa.
• bjeto é uma instância de uma classe. Classe é uma fábrica de objetos.

Pilares da programação orientada a objetos

A programação orientada a objetos é fundamentada em três pilares: herança, encapsulamento e polimorfismo. Para dominar a programação orientada a objetos você terá que dominar esses três pilares.

Primeiro pilar: Herança

Na herança um objeto herda as propriedades e métodos de outro objeto. O objeto herdado é o objeto pai o objeto que herda é o objeto filho – relação pai e filho.

A herança deve ser feita com cautela. Para um objeto poder herdar outro deve haver uma forte relação entre eles. Num E-commerce temos a classe Produto. Essa classe poderia ter os herdeiros CD de áudio, Filme, Livro, Roupa. O que esses objetos têm em comum é que todos são produtos, podem ser adicionados no carrinho e portanto comprados. Todos tem preço, peso e dimensões. Mas cada um tem suas especialidades, senão não justificaria sua existência. O CD de áudio tem autor, formato, faixas. O Filme tem formato, áudio e legenda, duração. O Livro tem autor, editora, páginas.

Quando um objeto herda outro objeto o herdeiro passa a ter o tipo do objeto herdado. Isso significa que todos os herdeiros de uma mesma classe compartilham ao menos um tipo em comum. O método adicionar produto de um Carrinho de compras estabelece que aceita somente objetos produtos. Mas pra ele não importa se esses produtos forem CD de aúdio ou Filme. Ambos são Produtos porque herdaram a classe Produto. Essa é a importância do tipo dos objetos. Eu demorei um pouco pra entender o que isso significava e onde era utilizado.

Se ainda não entendeu o que é tipo, pense em um restaurante que somente aceite pessoas descendentes de sua avó. Sua mãe e você poderão entrar, mas seu pai e eu não, a menos que sejamos parentes, minha mãe seja irmã de sua mãe ou filha ou outro grau de parentesco que envolva a descendência de sua avó.

Onde entra o Produto herdar a classe de banco de dados? Não entra, não há relação nisso! Muitos programadores cometem esse erro por acharem que estão facilitando o trabalho, outros por não saberem o que a herança significa na programação. Se você cometeu esse erro, tudo bem, mas não comenta mais. Objetos na vida real herdam objetos quando há uma relação entre eles, faça o mesmo na programação.

Até a próxima!

Is_cnpj é uma função em PHP que valida CNPJ. Se a string de entrada for um CNPJ ela é retornada sem formatação (14 caracteres) ou então é retornado falso.

• Aceita com ou sem formatação xxx.xxx.xxx/xxxx-xx ou xxxxxxxxxxxxxxx
• Variações de 14, 15, 18 ou 19 caracteres xxxxxxxxxxxxxx (14)
  xxxxxxxxxxxxxxx (15)
  
  xx.xxx.xxx/xxxx-xx (18)
  
  xxx.xxx.xxx/xxxx-xx (19)
• Retorna o CNPJ sem formatação com 14 caracteres xxxxxxxxxxxxxx

function is_cnpj($str) {
	if (!preg_match('|^(\d{2,3})\.?(\d{3})\.?(\d{3})\/?(\d{4})\-?(\d{2})$|', $str, $matches))
		return false;

	array_shift($matches);

	$str = implode('', $matches);
	if (strlen($str) > 14)
		$str = substr($str, 1);

	$sum1 = 0;
	$sum2 = 0;
	$sum3 = 0;
	$calc1 = 5;
	$calc2 = 6;

	for ($i=0; $i <= 12; $i++) {
		$calc1 = $calc1 < 2 ? 9 : $calc1;
		$calc2 = $calc2 < 2 ? 9 : $calc2;

		if ($i <= 11)
			$sum1 += $str[$i] * $calc1;

		$sum2 += $str[$i] * $calc2;
		$sum3 += $str[$i];
		$calc1--;
		$calc2--;
	}

	$sum1 %= 11;
	$sum2 %= 11;

	return ($sum3 && $str[12] == ($sum1 < 2 ? 0 : 11 - $sum1) && $str[13] == ($sum2 < 2 ? 0 : 11 - $sum2)) ? $str : false;
}

Exemplos:

if (is_cnpj($cnpj)) {
	// CNPJ válido
}
else {
	// CNPJ inválido
}

// Se verdadeiro, a função retorna o CNPJ sem formatação com 14 caracteres
$cnpj = '10.530.985/0001-10';

if ($cnpj = is_cnpj($cnpj)) { // atribuição e comparação
	// CNPJ válido
	echo $cnpj; // 10530985000110
}

// Erro comum de outros algoritmos - validar cadeia de zeros
if (is_cnpj('00.000.000/0000-00')) {
	// ...
}

// CNPJ com 19 caracteres
if (is_cnpj('010.530.985/0001-10')) {
	echo 'cnpj válido';
}

// CNPJ sem formatação
if (is_cnpj(10530985000110)) {
	echo 'cnpj válido';
}

substr('Programa transforma celulares comuns em smartphone', 0, 25);
>> Programa transforma celula

De “celulares” passou a ser “celula”. A frase teve um novo significado.

Sushiman

function truncate($str, $len, $etc='') {
	$end = array(' ', '.', ',', ';', ':', '!', '?');

	if (strlen($str) <= $len)
		return $str;

	if (!in_array($str{$len - 1}, $end) && !in_array($str{$len}, $end))
		while (--$len && !in_array($str{$len - 1}, $end));

	return rtrim(substr($str, 0, $len)).$etc;
}

Truncate corta strings tomando cuidado para não separar palavras ao meio ou em qualquer outra parte. É muito possível que o valor retornado tenha menos caracteres que o solicidado, mas temos a certeza que nenhuma palavra será quebrada.

Exemplos:

$str = 'Estrelas pequenas e com pouco brilho, conhecidas como anãs vermelhas, são muito mais comuns do que se imaginava.';
substr($str, 0, 50);
>> Estrelas pequenas e com pouco brilho, conhecidas co

truncate($str, 50);
>> Estrelas pequenas e com pouco brilho, conhecidas

truncate($str, 50, '...');
>> Estrelas pequenas e com pouco brilho, conhecidas...

([A-Za-z]+)

• Parênteses delimitam um bloco que quando encontrado deve ser retornado;
• A-Z representa as letras maiúsculas;
• a-z representa as letras minúscula; e
• “+” indica que deve existir ao menos uma letra e pode haver outras inúmeras (uma ou mais).

Vamos testar a expressão regular em algumas palavras:

Como era de se esperar, funcionou para “Casa” e “sapato”. Mas não funcionou para “Ação” e “Árvores” porque A-Za-z não inclui diacríticos, sinais gráficos colocados sobre, sob ou através de algumas letras, como a cecedilha “ç” de “Ação” e o acento agudo no “Á” de “Árvore”.

É necessário acrescentar na expressão regular algo que represente essas letras “modificadas”. Não convém colocar uma a uma dentro dos colchetes porque existem várias combinações e há grande chance de esquecer algumas, sem falar no trabalho que vai dar.

Expressões Regulares e Acentuação

[A-ZÀ-Úa-zà-ú]

A solução mais simples e elegante é usar À-Ú para letras maiúsculas com acentução e à-ú para letras minúsculas.

Vamos testar nossa expressão regular modificada:

Um novo problema: palavras compostas ou “palavras dentro de palavras”. Palavras ligadas por hífen. Temos, por exemplo: cabeça-dura, feijão-preto, físico-químico.

Expressões Regulares e Palavras compostas

O hífen não pode ser simplesmente incluído entre os colchetes pois aceitaria combinações como: “-palavra”, “palavra-” e “-palavra-”. É necessário que, caso exista hífen tenha pelo menos uma letra antes e depois.

([A-ZÀ-Úa-zà-ú]+(?:-[A-ZÀ-Úa-zà-ú]+)?)

O padrão para letras foi duplicado a direta e um hífen foi acrescentado no meio. Se tiver um hífen necessariamente deve existir pelo menoss uma letra a direita desse hífen. O sinal de interrogação no final da expressão, (?:-[A-ZÀ-Úa-zà-ú]+)?, significa que o bloco é opcional. Não queremos que a expressão encontre apenas palavras compostas.

O que significa (?:expressão)? Quando fazemos uso de parênteses sem escape (“\(” ou “\)”) numa expressão regular estamos dizendo que é para retornar o valor que estiver entre eles. Então, se deixarmos esses parênteses sem nenhum tratamento vamos ter resultados a mais do que o esperado: a palavra inteira e a parte com hífen. O uso de ?: logo após o parêntese de abre evita que esse bloco seja retornado.

A expressão regular está boa, mas ainda não está completa. Existem palavras que possuem mais de um hífen, como: cana-de-açucar. O sinal de interrogação “?” diz que pode ter, sim ou não. Substituir o sinal de interrogação por asterisco “*” significa que poderá existir nenhum ou vários.

([A-ZÀ-Úa-zà-ú]+(?:-[A-ZÀ-Úa-zà-ú]+)*)

Testes:

Agora a expressão caça todos os tipos de palavras: simples, acentuação, cecidilha e palavras compostas. A expressão regular está quase finalizada, a não ser por um detalhe.

Modificadores

Use o modificador i (PCRE_CASELESS) para combinar tanto letras maiúsculas como minúsculas.

Final

#([a-zà-ú]+(?:-[a-zà-ú]+)*)#i

Por exemplo, a URL:

http://exemplo.com?nome=Alejandro&pais=Brasil&regiao=Sudeste

Tem as variáveis:

print_r($_GET);

array
(
	nome => Alejandro,
	pais => Brasil,
	regiao => Sudeste
)

Acessamos esses valores usando seus índices no array $_GET.

echo $_GET['pais']; // exibe Brasil
echo $_GET['regiao']; // exibe Sudeste

Converter array em variáveis de URL

Não existe uma função nativa do PHP que converta array em variáveis de URL. Então vamos construir nossa função:

function arrtourl($arr, $entity=true, $prefix='') {
	$params = array();
	foreach ($arr as $k => $v)
		if ($v)
			$params[] = is_array($v) ? arrtourl($v, $entity, $prefix ? $prefix.'['.$k.']' : $k) : sprintf($prefix ? $prefix.'[%s]' : '%s', urlencode($k)).'='.urlencode($v);
	return implode($entity ? '&' : '&', $params);
}

Arrtourl faz a conversão para nós. Entre seus parâmetros, apenas os dois primeiros são importantes. O terceiro parâmetro é usado na recursão quando há matrizes.

O parâmetro $arr é o array para ser convertido e $entity define se as variáveis serão unidas com & ou apenas &. Por quê? Porque na maioria das vezes vamos usar essa função para criar links dentro de páginas HTML e como & é um caractere especial do HTML (XML), precisamos usar sua entidade para não gerar erros no documento.

Exemplos:

Simples:

$arr = array(
	'id' => 968,
	'cat' => 'php'
);

echo arrtourl($arr);

>> id=968&cat=php

Matriz:

$mat = array(
	'teste' => array(
		'id' => 968,
		'cat' => php
	),
	'status' => 1,
	'seq' => array(
		1,
		2,
		3
	)
);

echo arrtourl($mat);

>> teste[id]=968&teste[cat]=php&status=1&seq[0]=1&seq[1]=2&seq[2]=3

Muitas dimensões:

$arr = array(
	'valor' => array(
		array(
			array(
				'teste'
			)
		)
	)
);

echo arrtourl($arr);

>> valor[0][0][0]=teste

Sem conversão de &

$arr = array(
	'id' => 968,
	'cat' => 'php',
);

// id=968&cat=php
$url = arrtourl($arr, false);

header('Location: pagina?'.$url);

Prefixo

Você pode usar o terceiro parâmetro para embutir tudo num array.

$arr = array(
	'id' => 968,
	'cat' => 'php'
);

echo arrtourl($arr, false, 'post');

>> post[id]=968&post[cat]=php

<input type="text" placeholder="Digite seu nome aqui!" />

Alguns navegadores, como o Firefox até pelo menos a versão 3.6, não tem suporte a esse atributo.

O código abaixo é uma extensão (plugin) para jQuery que simula a funcionalidade do placeholder do HTML5.

(function($) {
	$.fn.extend({
		placeholder: function() {
			return this.each(function() {
				$('[placeholder]', this)
					.focus(function() {
						if ($(this).val() == $(this).attr('placeholder'))
							$(this).val('').css('color', '#000');
					})
					.blur(function() {
						if (!$(this).val() || $(this).val() == $(this).attr('placeholder'))
							$(this).val(function() { return $(this).attr('placeholder') }).css('color', '#ccc');
					})
					.filter(':not([value])').val(function() { return $(this).attr('placeholder') }).css('color', '#ccc')
					.parents('form')
						.bind('submit', function() {
							$('[placeholder]', this).val(function() { return $(this).val() != $(this).attr('placeholder') ? $(this).val() : '' });
						});
			});
		}
	});
})(jQuery);

Para usar é muito simples. Adicione normalmente o atributos placeholder. Feito isso, no elemento pai execute:

$('pai').placeholder();

E todos os elementos filhos desse elemento terão a funcionalidade placeholder, mesmo que o navegador não suporte.

Site oficial: http://labs.securitycompass.com/index.php/exploit-me/

Add-ons for Firefox

XSS

Cross-site scripting é um tipo de vulnerabilidade do sistema de segurança de um computador, encontrado normalmente em aplicações web que activam ataques maliciosos ao injectarem client-side script dentro das páginas web vistas por outros usuários. Através de um XSS, o Cracker injeta codigos JavaScript em um campo texto de uma página já existente e este JavaScript é apresentado para outros usuários.

SQL Injection

A Injeção de SQL, mais conhecida através do termo americano SQL Injection, é um tipo de ameaça de segurança que se aproveita de falhas em sistemas que interagem com bases de dados via SQL. A injeção de SQL ocorre quando o atacante consegue inserir uma série de instruções SQL dentro de uma consulta (query) através da manipulação das entrada de dados de uma aplicação.

def rem_acentuacao(str):
	from unicodedata import normalize
	return normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')

Exemplos:

>>> rem_acentuacao('não faça')
nao faca