O desenvolvimento web em WordPress é excelente! O CMS já vem com diversas funções e funcionalidades para facilitar a vida de desenvolvedores e, até mesmo, de pessoas que não tem o mínimo conhecimento em programação (um dos objetivos é esse, mesmo).

Mas muitos desenvolvedores, principalmente os ainda incipientes, esquecem que o WordPress nada mais é do que PHP! Claro, o WP é nada mais, nada menos, que um sistema feito em PHP, como você e eu poderíamos ter feito. Mas, por motivos que me fogem ao conhecimento, as pessoas esquecem isso… Talvez o nível de abstração em programação que o CMS proporcione seja o “culpado”, mas, sinceramente, não tenho certeza.

Então, se você tiver a curiosidade de vasculhar os arquivos PHP que fazem do WordPress o que ele é, vai ter uma grata surpresa e encontrar uma rica fonte de scripts, funções e funcionalidades que você sempre quis implementar e não sabia como!  :-D

URLs amigáves à WordPress

Por exemplo, muitos querem implementar uma estrutura de URLs amigáves (gerar os famosos “slugs”) em sistemas desenvolvidos do zero  – seja através de frameworks ou em PHPU (“PHP Unha”) -, mas não sabem como. Ora, se sabemos que o WordPress possui um ótimo sistema de geração de slugs e temos acesso a seu código-fonte, tudo o que é preciso é vasculhar o código-fonte e encontrar as funções certas.

Seguindo o exemplo de gerar slugs, procurando um pouco, é possível saber que as funções necessárias se encontram em /wp-includes/formatting.php. E, como era de se esperar, as funções estão devidamente documentadas com seu escopo, parâmetros e retorno. Precisa de mais?

Para gerar URLs amigáveis à WordPress, são necessárias 4 funções. 3 “preliminares” que são:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

/**
 * Converts all accent characters to ASCII characters.
 *
 * If there are no accent characters, then the string given is just returned.
 *
 * @since 1.2.1
 *
 * @param string $string Text that might have accent characters
 * @return string Filtered string with replaced "nice" characters.
 */
function remove_accents($string) {
	if ( !preg_match('/[\x80-\xff]/', $string) )
		return $string;
 
	if (seems_utf8($string)) {
		$chars = array(
		// Decompositions for Latin-1 Supplement
		chr(195).chr(128) => 'A', chr(195).chr(129) => 'A',
		chr(195).chr(130) => 'A', chr(195).chr(131) => 'A',
		chr(195).chr(132) => 'A', chr(195).chr(133) => 'A',
		chr(195).chr(135) => 'C', chr(195).chr(136) => 'E',
		chr(195).chr(137) => 'E', chr(195).chr(138) => 'E',
		chr(195).chr(139) => 'E', chr(195).chr(140) => 'I',
		chr(195).chr(141) => 'I', chr(195).chr(142) => 'I',
		chr(195).chr(143) => 'I', chr(195).chr(145) => 'N',
		chr(195).chr(146) => 'O', chr(195).chr(147) => 'O',
		chr(195).chr(148) => 'O', chr(195).chr(149) => 'O',
		chr(195).chr(150) => 'O', chr(195).chr(153) => 'U',
		chr(195).chr(154) => 'U', chr(195).chr(155) => 'U',
		chr(195).chr(156) => 'U', chr(195).chr(157) => 'Y',
		chr(195).chr(159) => 's', chr(195).chr(160) => 'a',
		chr(195).chr(161) => 'a', chr(195).chr(162) => 'a',
		chr(195).chr(163) => 'a', chr(195).chr(164) => 'a',
		chr(195).chr(165) => 'a', chr(195).chr(167) => 'c',
		chr(195).chr(168) => 'e', chr(195).chr(169) => 'e',
		chr(195).chr(170) => 'e', chr(195).chr(171) => 'e',
		chr(195).chr(172) => 'i', chr(195).chr(173) => 'i',
		chr(195).chr(174) => 'i', chr(195).chr(175) => 'i',
		chr(195).chr(177) => 'n', chr(195).chr(178) => 'o',
		chr(195).chr(179) => 'o', chr(195).chr(180) => 'o',
		chr(195).chr(181) => 'o', chr(195).chr(182) => 'o',
		chr(195).chr(182) => 'o', chr(195).chr(185) => 'u',
		chr(195).chr(186) => 'u', chr(195).chr(187) => 'u',
		chr(195).chr(188) => 'u', chr(195).chr(189) => 'y',
		chr(195).chr(191) => 'y',
		// Decompositions for Latin Extended-A
		chr(196).chr(128) => 'A', chr(196).chr(129) => 'a',
		chr(196).chr(130) => 'A', chr(196).chr(131) => 'a',
		chr(196).chr(132) => 'A', chr(196).chr(133) => 'a',
		chr(196).chr(134) => 'C', chr(196).chr(135) => 'c',
		chr(196).chr(136) => 'C', chr(196).chr(137) => 'c',
		chr(196).chr(138) => 'C', chr(196).chr(139) => 'c',
		chr(196).chr(140) => 'C', chr(196).chr(141) => 'c',
		chr(196).chr(142) => 'D', chr(196).chr(143) => 'd',
		chr(196).chr(144) => 'D', chr(196).chr(145) => 'd',
		chr(196).chr(146) => 'E', chr(196).chr(147) => 'e',
		chr(196).chr(148) => 'E', chr(196).chr(149) => 'e',
		chr(196).chr(150) => 'E', chr(196).chr(151) => 'e',
		chr(196).chr(152) => 'E', chr(196).chr(153) => 'e',
		chr(196).chr(154) => 'E', chr(196).chr(155) => 'e',
		chr(196).chr(156) => 'G', chr(196).chr(157) => 'g',
		chr(196).chr(158) => 'G', chr(196).chr(159) => 'g',
		chr(196).chr(160) => 'G', chr(196).chr(161) => 'g',
		chr(196).chr(162) => 'G', chr(196).chr(163) => 'g',
		chr(196).chr(164) => 'H', chr(196).chr(165) => 'h',
		chr(196).chr(166) => 'H', chr(196).chr(167) => 'h',
		chr(196).chr(168) => 'I', chr(196).chr(169) => 'i',
		chr(196).chr(170) => 'I', chr(196).chr(171) => 'i',
		chr(196).chr(172) => 'I', chr(196).chr(173) => 'i',
		chr(196).chr(174) => 'I', chr(196).chr(175) => 'i',
		chr(196).chr(176) => 'I', chr(196).chr(177) => 'i',
		chr(196).chr(178) => 'IJ',chr(196).chr(179) => 'ij',
		chr(196).chr(180) => 'J', chr(196).chr(181) => 'j',
		chr(196).chr(182) => 'K', chr(196).chr(183) => 'k',
		chr(196).chr(184) => 'k', chr(196).chr(185) => 'L',
		chr(196).chr(186) => 'l', chr(196).chr(187) => 'L',
		chr(196).chr(188) => 'l', chr(196).chr(189) => 'L',
		chr(196).chr(190) => 'l', chr(196).chr(191) => 'L',
		chr(197).chr(128) => 'l', chr(197).chr(129) => 'L',
		chr(197).chr(130) => 'l', chr(197).chr(131) => 'N',
		chr(197).chr(132) => 'n', chr(197).chr(133) => 'N',
		chr(197).chr(134) => 'n', chr(197).chr(135) => 'N',
		chr(197).chr(136) => 'n', chr(197).chr(137) => 'N',
		chr(197).chr(138) => 'n', chr(197).chr(139) => 'N',
		chr(197).chr(140) => 'O', chr(197).chr(141) => 'o',
		chr(197).chr(142) => 'O', chr(197).chr(143) => 'o',
		chr(197).chr(144) => 'O', chr(197).chr(145) => 'o',
		chr(197).chr(146) => 'OE',chr(197).chr(147) => 'oe',
		chr(197).chr(148) => 'R',chr(197).chr(149) => 'r',
		chr(197).chr(150) => 'R',chr(197).chr(151) => 'r',
		chr(197).chr(152) => 'R',chr(197).chr(153) => 'r',
		chr(197).chr(154) => 'S',chr(197).chr(155) => 's',
		chr(197).chr(156) => 'S',chr(197).chr(157) => 's',
		chr(197).chr(158) => 'S',chr(197).chr(159) => 's',
		chr(197).chr(160) => 'S', chr(197).chr(161) => 's',
		chr(197).chr(162) => 'T', chr(197).chr(163) => 't',
		chr(197).chr(164) => 'T', chr(197).chr(165) => 't',
		chr(197).chr(166) => 'T', chr(197).chr(167) => 't',
		chr(197).chr(168) => 'U', chr(197).chr(169) => 'u',
		chr(197).chr(170) => 'U', chr(197).chr(171) => 'u',
		chr(197).chr(172) => 'U', chr(197).chr(173) => 'u',
		chr(197).chr(174) => 'U', chr(197).chr(175) => 'u',
		chr(197).chr(176) => 'U', chr(197).chr(177) => 'u',
		chr(197).chr(178) => 'U', chr(197).chr(179) => 'u',
		chr(197).chr(180) => 'W', chr(197).chr(181) => 'w',
		chr(197).chr(182) => 'Y', chr(197).chr(183) => 'y',
		chr(197).chr(184) => 'Y', chr(197).chr(185) => 'Z',
		chr(197).chr(186) => 'z', chr(197).chr(187) => 'Z',
		chr(197).chr(188) => 'z', chr(197).chr(189) => 'Z',
		chr(197).chr(190) => 'z', chr(197).chr(191) => 's',
		// Euro Sign
		chr(226).chr(130).chr(172) => 'E',
		// GBP (Pound) Sign
		chr(194).chr(163) => '');
 
		$string = strtr($string, $chars);
	} else {
		// Assume ISO-8859-1 if not UTF-8
		$chars['in'] = chr(128).chr(131).chr(138).chr(142).chr(154).chr(158)
			.chr(159).chr(162).chr(165).chr(181).chr(192).chr(193).chr(194)
			.chr(195).chr(196).chr(197).chr(199).chr(200).chr(201).chr(202)
			.chr(203).chr(204).chr(205).chr(206).chr(207).chr(209).chr(210)
			.chr(211).chr(212).chr(213).chr(214).chr(216).chr(217).chr(218)
			.chr(219).chr(220).chr(221).chr(224).chr(225).chr(226).chr(227)
			.chr(228).chr(229).chr(231).chr(232).chr(233).chr(234).chr(235)
			.chr(236).chr(237).chr(238).chr(239).chr(241).chr(242).chr(243)
			.chr(244).chr(245).chr(246).chr(248).chr(249).chr(250).chr(251)
			.chr(252).chr(253).chr(255);
 
		$chars['out'] = "EfSZszYcYuAAAAAACEEEEIIIINOOOOOOUUUUYaaaaaaceeeeiiiinoooooouuuuyy";
 
		$string = strtr($string, $chars['in'], $chars['out']);
		$double_chars['in'] = array(chr(140), chr(156), chr(198), chr(208), chr(222), chr(223), chr(230), chr(240), chr(254));
		$double_chars['out'] = array('OE', 'oe', 'AE', 'DH', 'TH', 'ss', 'ae', 'dh', 'th');
		$string = str_replace($double_chars['in'], $double_chars['out'], $string);
	}
 
	return $string;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * Checks to see if a string is utf8 encoded.
 *
 * NOTE: This function checks for 5-Byte sequences, UTF8
 *       has Bytes Sequences with a maximum length of 4.
 *
 * @author bmorel at ssi dot fr (modified)
 * @since 1.2.1
 *
 * @param string $str The string to be checked
 * @return bool True if $str fits a UTF-8 model, false otherwise.
 */
function seems_utf8($str) {
	$length = strlen($str);
	for ($i=0; $i < $length; $i++) {
		$c = ord($str[$i]);
		if ($c < 0x80) $n = 0; # 0bbbbbbb
		elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb
		elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb
		elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb
		elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb
		elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b
		else return false; # Does not match any model
		for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?
			if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))
				return false;
		}
	}
	return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/**
 * Encode the Unicode values to be used in the URI.
 *
 * @since 1.5.0
 *
 * @param string $utf8_string
 * @param int $length Max length of the string
 * @return string String with Unicode encoded for URI.
 */
function utf8_uri_encode( $utf8_string, $length = 0 ) {
	$unicode = '';
	$values = array();
	$num_octets = 1;
	$unicode_length = 0;
 
	$string_length = strlen( $utf8_string );
	for ($i = 0; $i < $string_length; $i++ ) {
 
		$value = ord( $utf8_string[ $i ] );
 
		if ( $value < 128 ) {
			if ( $length && ( $unicode_length >= $length ) )
				break;
			$unicode .= chr($value);
			$unicode_length++;
		} else {
			if ( count( $values ) == 0 ) $num_octets = ( $value < 224 ) ? 2 : 3;
 
			$values[] = $value;
 
			if ( $length && ( $unicode_length + ($num_octets * 3) ) > $length )
				break;
			if ( count( $values ) == $num_octets ) {
				if ($num_octets == 3) {
					$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]) . '%' . dechex($values[2]);
					$unicode_length += 9;
				} else {
					$unicode .= '%' . dechex($values[0]) . '%' . dechex($values[1]);
					$unicode_length += 6;
				}
 
				$values = array();
				$num_octets = 1;
			}
		}
	}
 
	return $unicode;
}

E, com essas funções devidamente estabelecidas, a função que gera os slugs, propriamente dita:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 * Sanitizes title, replacing whitespace with dashes.
 *
 * Limits the output to alphanumeric characters, underscore (_) and dash (-).
 * Whitespace becomes a dash.
 *
 * @since 1.2.0
 *
 * @param string $title The title to be sanitized.
 * @return string The sanitized title.
 */
function sanitize_title_with_dashes($title) {
	$title = strip_tags($title);
	// Preserve escaped octets.
	$title = preg_replace('|%([a-fA-F0-9][a-fA-F0-9])|', '---$1---', $title);
	// Remove percent signs that are not part of an octet.
	$title = str_replace('%', '', $title);
	// Restore octets.
	$title = preg_replace('|---([a-fA-F0-9][a-fA-F0-9])---|', '%$1', $title);
 
	$title = remove_accents($title);
	if (seems_utf8($title)) {
		if (function_exists('mb_strtolower')) {
			$title = mb_strtolower($title, 'UTF-8');
		}
		$title = utf8_uri_encode($title, 200);
	}
 
	$title = strtolower($title);
	$title = preg_replace('/&.+?;/', '', $title); // kill entities
	$title = str_replace('.', '-', $title);
	$title = preg_replace('/[^%a-z0-9 _-]/', '', $title);
	$title = preg_replace('/\s+/', '-', $title);
	$title = preg_replace('|-+|', '-', $title);
	$title = trim($title, '-');
 
	return $title;
}

Então, para gerar um slug em seu próprio sistema depois de implementar as funções mostradas, basta escrever:

1

sanitize_title_with_dashes($var);

Achou o nome da função grande ou feio? Você tem o código, altere como bem entender!

Considerações finais

O WordPress é software livre (registrado sob a licença GPL), então você pode pegar essas 4 funções e implementar em seu site/sistema/softwares sem o medo de receber uma cartinha do advogado da equipe WordPress amanhã ou depois.

Fica uma pergunta: você tem um software livre à disposição e fica quebrando a cabeça em busca de soluções de código que já existem e estão implementadas nele? Vasculhe todo o código fonte (veja alguns recursos que ajudam no artigo sobre ferramentas e recursos para desenvolvimento web) e procure por aquilo que vai lhe ser útil!

Não seja tímido! ;-)

Artigos Relacionados

• Jetpack: explorando novas maneiras de ampliar e personalizar a web
• Dicas para otimizar códigos PHP
• Como montar um portfolio sem ter clientes
• Swift Mailer: solução PHP para envio de e-mails
• Como pegar parte do conteúdo (dados) de outro site com PHP
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• 8 dicas para fazer códigos melhores com jQuery
• Truques de configuração do WordPress
• Sobre parcerias de trabalhos em desenvolvimento web
• Como criar sumários dinamicamente com o TOC (Table of Contents) jQuery plugin

Mas esta liberdade toda, se mal utilizada, pode prejudicar a performance e qualidade de um projeto. Através de más práticas de programação PHP alguém pode fazer o desempenho de um sistema inteiro ficar aquém de suas potencialidades, caso este tivesse sido programado de maneira “adequada”. Existem algumas pequenas dicas que são fáceis de seguir – não interferem em nada a lógica do programa e modus operandi do progamador PHP – e surtem bons resultados, rumo à otimização e ganho de desempenho e performance de seus scripts.

Otimização de saída de dados

O PHP permite o processamento server side das soliticações feitas no lado do cliente. É muito importante, então, uma boa performance ao exibir o resultado deste processamento feito no lado do servidor, já que o front-end de uma aplicação ou sistema deve ser fácil de usar e rápido ao responder requisições.

Use “echo” ao invés de “print”

Dentre as duas funções que permitem a exibição de informações – o “tal” processamento server-side -, as funções echo e print são as mais conhecidas. Entretanto, usar a função echo é melhor, já que, apesar de ambas servirem e realizarem a mesma coisa – exibir saídas e informações – o desempenho de echo é melhor.

Portanto, prefira utilizar echo()!

Aspas simples e aspas duplas

Para exibir em tela o conteúdo de uma variável, é possível utiliza as duplas (“) e escrever a variável juntamente com o restante da exibição; ou utilizar aspas simples (‘) e concatenar as variáveis (.) com o restante da saída, de certa forma “isolando” as variáveis do restante da exibição em tela.

É melhor usar aspas simples com “isolamento” das variáveis ao invés de aspas duplas com as variáveis juntamente ao restante do conteúdo. Portanto, prefira usar:

// maneira menos eficiente
echo "Esta é uma maneira menos eficiente de exibir uma $var!";
 
// maneira mais eficiente
echo 'Esta é uma maneira mais eficiente de exibir uma ' . $var . '!';

E há ainda uma maneira ainda rápida e com melhor performance no PHP. Apesar de ser um pouco estranha esta sintaxe – pelo menos para mim -, os resultados em passar múltiplos parâmetros à função ao invés de realizar concatenação são mais satisfatórios:

// maneira muito eficiente (com sintaxe estranha...)
echo 'Maneira muito mais eficiente de exibir uma', $var, '!';

Otimização de loops

Não há que se falar em fazer um web site ou sistema em PHP sem falar em loops. E já que são tão utilizados – justamente por serem tão indispensáveis -, é mais do que importante fazer loops PHP de ótima performance.

Especifique previamente uma variável para loops “for”

Uma coisa muito comum de se fazer quando se está programando em PHP é pegar a quantidade de “qualquer coisa” e, com ela, realizar um loop for para realizar outra “qualquer coisa”. E são muitos os programadores que, por falta de conhecimento ou preguiça, fazem isso:

for ($i = 0; $i <= mysql_num_rows($resultado); $i++) {
    [codigo]
}

Quando, na verdade, isso acarreta em um processamento extra para cada iteração. Especificando previamente e colocando numa variável quantas vezes o looping vai acontercer, a carga de processamento fica menor e, consequentemente, seu código fica otimizado:

$total = mysql_num_rows($resultado);
for ($i = 0; $i <= $total; $i++) {
    [codigo]
}

Otimização de variáveis e funções

Desnecessário comentar sobre a importância de variáveis e funções em um script PHP, por mais simples que seja. Otimizar funções e variáveis é mais que necessário, caso se esteja buscando um desempenho excelente. Essas são dicas rápidas e eficientes:

• Utilizar require ao invés de require_once;
• Usar caminhos absolutos ao invés de relativos em “includes”, “requires” e afins é melhor (embora possa gerar algum inconveniente futuro, por razões óbvias);
• “else / if” é mais rápido que “switch / case “;
• Incrementar uma variável local é quase 100% mais lento quando não se a especifica previamente.

Mais sobre otimização de códigos PHP

É de se imaginar que, pela “tradição” que tem o PHP e a extensão que lhe é característica, estas dicas rápidas não encerram o assunto. Para muitas outras dicas de como otimizar seus códigos em PHP, considere ler os seguintes artigos (em inglês):

• PHP Optimization Tips;
• 50+ PHP optimisation tips revisited;
• 40 Tips for optimizing your php code;
• A HOWTO on Optimizing PHP;
• 10 things you (probably) didn’t know about PHP.

E você, tem alguma dica para otimizar seu código PHP?

Artigos Relacionados

• URLs amigáveis (slug) à WordPress
• 8 maneiras de melhorar a performance de um site
• User Interface em dicas rápidas
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• 8 dicas para fazer códigos melhores com jQuery
• Jetpack: explorando novas maneiras de ampliar e personalizar a web
• Pergunte-se a si mesmo: questões para desenvolver um bom site
• Swift Mailer: solução PHP para envio de e-mails
• Como pegar parte do conteúdo (dados) de outro site com PHP
• Erros comuns em desenvolvimento web para campanhas de SEO

Para melhorar o tempo do projeto e agilidade e performance da aplicação, por vezes é vantajoso optar por uma solução pronta para envio de e-mails, o que poupa enorme investimento de tempo (custo de oportunidade) e permite desfrutar de uma solução eficiente para envio de mensagens através de e-mail, uma biblioteca idealizada e feita visando tal objetivo.

Swift Mailer

Swift Mailer é uma biblioteca PHP – orientado a objeto – que tem por finalidade facilitar, agilizar e servir como ferramenta útil e eficaz para envio de e-mails em web sites e aplicações online, em geral. Enviar e-mails de forma fácil com PHP é o que é possível quando se utiliza Swift Mailer.

Características do Swift Mailer

O Swift Mailer não é simplesmente uma biblioteca PHP para tornar fácil de se usar a função mail(), nativa do PHP. Ele provê muito mais recursos e possibilidades – como citado, Swift Mailer é uma biblioteca PHP para envio de e-mails e, como tal, possui diversas caracteristicas para isso; características essas que o tornam uma solução completa em PHP para enviar e-mails.

As características principais do Swift Mailer são:

• Envio de e-mail usando o protocolo SMTP ou MTA, o que tem performance superior que usar a função nativa mail();
• Controle de cabeçalho com RFC 2822;
• Internacionalização (i18n);
• Suporte SSL & TLS (para servidores GMail);
• Inclusão de arquivos anexos e imagens diretamente no corpo das mensagens;
• Controle de prioridade de mensagens;
• Monitoramente de gasto de banda;
• E-mails com CC e CCo;
• Envio de newsletters;
• Dentre outras características.

Enfim, devido a estas características listadas – e olha que tem muito mais! -, é possível perceber que o Swift Mailer é uma maneira fácil de enviar e-mails (com arquivos anexos, imagens no corpo da mensagem, etc) de forma rápida, automatizada e, consequentemente, bem fácil.

Como usar o Swift Mailer

No próprio site oficial do Swift Mailer há uma série de documentos, tutoriais e exemplos para quem ainda não usa a biblioteca, passar a usá-la e não sentir dificuldades em conhecer seu funcionamento.

Através de explicações sobre a API do Swift Mailer, manual de instalação, configuração e uso, dicas e truques, perguntas mais frequentes, fórum e outros tipos de textos de ajuda e explicação sobre Swift Mailer, é possível conhecer e estudar mais a fundo esta aplicação PHP para envio de e-mails.

Baixe logo o Swift Mailer!

Pessoalmente, como “sofredor” de alguns projetos que exigiram um pouco mais de recursos para envio de mensagens, posso afirmar que uma solução completa para envio de mensagens por e-mail como o Swift Mailer é realmente uma valiosa aquisição para se ter na biblioteca particular de scripts – todo programador tem uma! :-D

Com Swift Mailer é realmente muito simples rápido o envio de mensagem por e-mails, em web sites, aplicações online e sistemas virtuais de qualquer porte; desde um simples formulário de contato ao envio de newsletters. Com a biblioteca Swift Mailer certamente os problemas relacionados ao envio de emails estão com os dias contados e sua produtividade e despreocupação com esta parte do desenvolvimento para web, também.

Artigos Relacionados

• URLs amigáveis (slug) à WordPress
• Dicas para otimizar códigos PHP
• Como pegar parte do conteúdo (dados) de outro site com PHP
• 8 dicas para fazer códigos melhores com jQuery
• Jetpack: explorando novas maneiras de ampliar e personalizar a web
• Como criar sumários dinamicamente com o TOC (Table of Contents) jQuery plugin

A missão: pegar parte do conteúdo de um site

Hoje, no trabalho, tive a missão de “puxar” alguns dados de um site para “enxertar” num trecho de um web site que estou ajudando a desenvolver. Quando a tarefa me foi passada, logo lembrei de uma ocasião em que um amigo fez a mesma coisa (e, na época, ele me explicou, mais ou menos, com o fez). Pensei que seria muito fácil realizar a tarefa, mas, na hora, “lembrei” que não sou tão bom quanto o Gevã… rsrs

A solução: funções nativas do PHP e expressões regulares

Passei para pesquisas na web, procurando desesperadamente material de referência sobre expressões regulares (que, como verão, é um dos pilares para se conseguir pegar parte do conteúdo de outro site). Procura daqui, procura de lá, até bate-papo com o Gevã rolou para eu tentar entender melhor as tais expressões regulares. Até que, utilizando um pouco de “gambiarra”, consegui realizar meu objetivo.

A primeira coisa a se fazer, é pegar o conteúdo da página inteira que se quer “manipular”. Para tal, usa-se, por exemplo, a função file_get_contents(). Jogando o conteúdo do site numa variável, ficaria assim (vou fazer o exemplo com o mesmo site que tive que mexer):

1

$url = file_get_contents('http://www.bcb.gov.br/');

Pronto, agora a variável $url contém, em string, todo o conteúdo da página inicial do BCB.

Expressões regulares

Até aqui foi fácil; o difícil foi pegar somente o trecho da página que eu queria… Para isso, é preciso usar expressões regulares!

Caso você não saiba o que são expressões regulares, aí vai uma sucinta (e incompleta…) explicação de o que são expressões regulares, da Wikipédia:

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.

Com as expressões regulares é possível identificar trechos de palavras ou grupos de palavras que correspondem (“match“) a um determinado padrão (“pattern“), que é “regular”.

O PHP tem várias funções nativas para trabalhar com expressões regulares. Basta saber para o que cada uma serve e usar da meneira correta.

Bem, o próximo passo para resolução do problema é identificar o padrão que se quer extrair do site. No caso, eu precisei de uma tabela com algumas taxas cambiais (encontra-se à direita, no site do BCB). Observando o código fonte, vi que as informações estão em uma tabela (abordagem semanticamente correta!); além disso, esta tabela está envolta entre os comentários HTML “<!- – INICIO INDICADORES – ->” e “<!- – FIMINDICADORES – ->”. Isso é uma coisa boa, já que facilita bastante a “identificação do padrão”.

Explicando melhor: o padrão procurado, no caso, é tudo o que está entre os comentários HTML “<!- – INICIO INDICADORES – ->” e “<!- – FIMINDICADORES – ->”. Toda a tabela está aí, para a minha felicidade! :-)

Então, tudo o que é preciso fazer é utilizar uma função PHP (para o caso, escolhi a preg_match_all()) para procurar uma expressão regular dentro da variável $url, que contém toda a primeira página do site em que está a tabela.

Depois de muito tempo testando vááárias expressões regulares, cheguei à conclusão que faria uma pequena mutreta. Mas, antes, deixe-me mostrar como está o código até agora.

1
2

$url = file_get_contents('http://www.bcb.gov.br/');
preg_match_all('/ORES--&gt;(.+)<!--/s', $url, $conteudo);

Explicando: o primeiro argumento da função, é o padrão que quero procurar; o segundo, é onde vou procurar; o terceiro, guarda em um array todas as ocorrências da expressão procurada. Para a maioria dos casos, talvez já estivesse bom, por aqui; entretanto, no problema que tive, ainda é preciso mais algumas linhas de código.

No momento, a variável $conteudo contém um array com as ocorrências encontradas. Usando um print_r(), descobri em qual posição, exatamente, o que eu procurava estava: $conteudo[0][0].

Fazendo uma “mutreta”

Para fazer a tal “mutreta”, jogo o conteúdo desta posição da matriz para uma outra variável (para facilitar a manipulação).

1
2
3

$url = file_get_contents('http://www.bcb.gov.br/');
preg_match_all('/ORES-->(.+)<!--/s', $url, $conteudo);
$exibir = $conteudo[0][0];

Havia trechos do que me foi retornado (ou seja, da tabela com as taxas cambiais) que eu não queria que aparecessem no site (como alguns links). Então, resolvi retirá-los através da função str_replace(), que substitui trechos de strings. É possível, como argumento, passar um array. Então, por enquanto e quase no fim, o código está assim:

1
2
3
4
5

$url = file_get_contents('http://www.bcb.gov.br/');
preg_match_all('/ORES-->(.+)<!--/s', $url, $conteudo);
$exibir = $conteudo[0][0];
$retirar = array('mais moedas','atas Copom','mais detalhes','ORES-->','<!--');
$exibir = str_replace($retirar, '', $exibir);

Ou seja: sempre que aparecer alguns dos itens do array $retirar em $exibir, será substituído por “” (nada…). Perceba que os últimos dois elementos do array são “poluições” desnecessárias, que vieram devido à minha preguiça de fazer uma expressão regular mais elaborada. :-)

Finalizando…

Depois disso, basta mandar exibir na tela o que “sobrou” do conteúdo retira da página inicial do site do BCB.

1
2
3
4
5
6

$url = file_get_contents('http://www.bcb.gov.br/');
preg_match_all('/ORES-->(.+)<!--/s', $url, $conteudo);
$exibir = $conteudo[0][0]</span>;
$retirar = array('mais moedas','atas Copom','mais detalhes','ORES-->','<!--');
$exibir = str_replace($retirar, '', $exibir);
echo $exibir;

E se o servidor não permite a função file_get_contents() ?

Há muitos servidores que, por motivos diversos (principalmente "segurança"), não permitem que se utilize a função file_get_contents(). Para esses casos, é possível colocar numa variável alguma página externa utilizando o seguinte código (depois você procura as explicações no manual oficial do PHP):

1
2
3
4
5
6
7

$ch = curl_init();
$timeout = 0;
curl_setopt($ch, CURLOPT_URL, 'O_SITE_QUE_VOCE_QUER');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, $timeout);
$conteudo = curl_exec ($ch);
curl_close($ch);

Então, o conteúdo da página "O_SITE_QUE_VOCE_QUER" estará na variável $conteudo.

Conclusão

Então, pessoal, para se retirar uma parte do conteúdo de um web site (utilizando PHP), os passos são:

• Saber em qual página está o conteúdo que se precisa;
• Jogar o conteúdo do site em uma variável;
• Extrair o trecho que se quer utilizando expressões regulares;
• Se preciso, cortar mais algumas coisas do resultado da ER;
• Exibir em tela o resultado final.

O grande pulo do gato, neste caso, é saber mexer com expressões regulares; coisa que, sinto informar, só se aprende fazendo! E fazendo muito! Leia as referências no fim deste artigo e procure na internet mais material a respeito.

Uma outra coisa importante é o seguinte: tenha sempre em mente que, como você está pegando o conteúdo de um site, caso este altere sua estrutura, muito provavelmente será preciso alterar a expressão regular, também.

Fique ciente de uma coisa: se você, desenvolvedor web, ainda não precisou usar expressões regulares, pode ter certeza de que sua hora vai chegar!

Artigos Relacionados

• URLs amigáveis (slug) à WordPress
• Dicas para otimizar códigos PHP
• Swift Mailer: solução PHP para envio de e-mails
• 6 mitos de SEO que você deve evitar
• 8 dicas para fazer códigos melhores com jQuery
• Jetpack: explorando novas maneiras de ampliar e personalizar a web
• Como criar sumários dinamicamente com o TOC (Table of Contents) jQuery plugin
• Como tirar screenshot de um web site inteiro e obter uma imagem completa
• Aprenda a escolher as melhores palavras-chave para a otimização de seu site
• As melhores práticas de SEO para seu site ou blog melhorar o posicionamento nos mecanismos de busca