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

Para quem faz uso um pouco mais avançado do WordPress, especialmente quem trabalha desenvolvendo sites com a plataforma, é bem comum aparecerem situações um tanto complexas. Para estas questões, seguem 13 fantásticos comandos SQL para WordPress!

Uma maneira prática de executar comandos SQL é através do phpMyAdmin. Até a hospedagem mais básica dá acesso à ferramenta de banco de dados, então não há dificuldades nisso. Uma vez no sistema, você deve selecionar aba “SQL” e escrever/colar a instrução SQL que deseja executar.

Alterar siteurl e homeurl

WordPress armazena o caminho absoluto da URL do site (“siteurl”) e URL da home (“homeurl”) no banco de dados. Portanto, se você transferir o seu site WordPress do localhost para o servidor, por exemplo, o site não vai carregar! Isso ocorre porque o caminho absoluto ainda está apontando para o seu localhost. Você vai precisar executar um comando para resolver isso.

UPDATE wp_options
SET option_value = REPLACE(option_value, 'http://www.enderecoantigo.com', 'http://www.endereconovo.com')
WHERE option_name = 'home'
OR option_name = 'siteurl';

Alterar GUID

Depois de migrar seu blog a partir de, por exemplo, localhost, para o servidor ou de um outro domínio para um novo domínio, você terá que corrigir as URLs para o campo GUID na tabela wp_posts. Isto é crucial, porque GUID é usado para montar o slug de seu post do caminho absoluto do artigo correto.

UPDATE wp_posts
SET guid = REPLACE (guid, 'http://www.enderecoantigo.com', 'http://www.endereconovo.com');

Alterar URL no conteúdo

O WordPress utiliza caminhos absolutos no URL ao invés de um caminho relativo quando vai armazená-los no banco de dados. Dentro do conteúdo de cada registro de artigo, ele armazena todas as URLs antigas referenciando as fontes antigas. Portanto, você precisará alterar todas essas URLs com o endereço do novo domínio.

UPDATE wp_posts
SET post_content = REPLACE (post_content, 'http://www.enderecoantigo.com', 'http://www.endereconovo.com');

Alterar apenas o caminho das imagens

Caso seja preciso alterar o domínio das imagens inseridas nas páginas e artigos, esta solução vai ajudar você a fazer isso de forma simples.

UPDATE wp_posts
SET post_content = REPLACE (post_content, 'src="http://www.enderecoantigo.com', 'src="http://www.endereconovo.com');

Também é preciso atualizar o GUID para o tipo “attachment” com a seguinte instrução SQL:

UPDATE wp_posts
SET guid = REPLACE (guid, 'http://www.enderecoantigo.com', 'http://www.endereconovo.com') WHERE post_type = 'attachment';

Atualizar Post Meta

Atualizar Post Meta funciona quase da mesma maneira como atualizar a URL no conteúdo do post. Se você tiver dados extras para cada post, você pode usar a seguinte instrução para alterar todos eles.

UPDATE wp_postmeta
SET meta_value = REPLACE (meta_value, 'http://www.enderecoantigo.com','http://www.endereconovo.com');

Alterar o nome usuário padrão “admin”

Apesar de que na versão 3 do WordPress o usuário “admin” poderá ser alterado no momento da instalação, não custa deixar para a posteridade a dica de como alterar o nome do “admin”.

UPDATE wp_users
SET user_login = 'nomequevocequiser'
WHERE user_login = 'Admin';

Resetar password

Já quis resetar sua senha no WordPress mas, por algum motivo, não conseguiu usar a seção para resetar o password? Eis a solução:

UPDATE wp_users
SET user_pass = MD5('senha')
WHERE user_login = 'login';

Transferir artigos de um autor para outro

Para transferir os artigos de um autor para outro, você gasta um tempo enorme se fizer isso manualmente. Com o comando SQL a seguir, é possível fazer isso facilmente. Para a dica, é preciso saber o ID dos autores.

UPDATE wp_posts
SET post_author = 'id_novo_autor'
WHERE post_author = 'id_autor_antigo';

Apagar revisões

Quando se está editando um artigo no WordPress, é comum cópias de segurança serem feitas para garantir o trabalho feito. São as chamadas “revisões”. Com o tempo, o número de registros de revisões fica grande e isso pode comprometer a performance do banco de dados. Para apagar todas as revisões de artigos, dê o seguinte comando SQL:

DELETE a,b,c FROM wp_posts a
LEFT JOIN wp_term_relationships b ON (a.ID = b.object_id)
LEFT JOIN wp_postmeta c ON (a.ID = c.post_id)
WHERE a.post_type = 'revision'

Apagar post meta

Instalar e remover plugins é algo corriqueiro quando se trabalha com WordPress. Alguns plugins precisam de criar alguns post meta para funcionarem corretamente e, para esses casos, não é raro o acontecimento de, mesmo depois de o plugin ser desinstalado, algum “garbage meta” ficar enchendo o BD desnecessariamente. Uma limpeza em algum valor de post meta, às vezes, se faz necessária.

DELETE FROM wp_postmeta
WHERE meta_key = 'nome-chave-meta';

Exportar todos os e-mails de comentários

Quanto mais tempo seu blog/site fica no ar, é provável que mais comentários receba nos artigos publicados. Se, por algum motivo, for preciso uma listagem com e-mail de todas as pessoas que já comentaram até então, basta executar o seguinte comando:

SELECT DISTINCT comment_author_email
FROM wp_comments;

Uma vez que a listagem esteja concluída, exporte tudo através do phpMyAdmin.

Apagar todos pingbacks

A medida que o site/blog fica no ar – e se você tiver bom conteúdo a oferecer – o número de pingbacks começa a influenciar a qualidade do banco de dados. Para apagar todos pingbacks, proceda da seguinte maneira:

DELETE FROM wp_comments WHERE comment_type = 'pingback';

Apagar todos comentários de SPAM

Sem maiores explicações, eis a maneira de deletar todos os comentários marcados como SPAM:

DELETE FROM wp_comments
WHERE comment_approved = 'spam';

Identificar tags não usadas

Num banco de dados WordPress, se você executar alguma query SQL para apagar posts, as tags relacionadas não serão apagadas e continuarão aparecendo na nuvem de sugestão de tags e listagem de tags. Para identificar esse tipo de tag, execute a seguinte instrução SQL:

SELECT * FROM wp_terms wt
INNER JOIN wp_term_taxonomy wtt
ON wt.term_id=wtt.term_id
WHERE wtt.taxonomy='post_tag'
AND wtt.count=0;

Artigos Relacionados

• Textarea: dicas e truques que você sempre quis saber
• Como criar sumários dinamicamente com o TOC (Table of Contents) jQuery plugin
• Preciosas dicas de segurança e otimização para WordPress
• Erros comuns em desenvolvimento web para campanhas de SEO
• Melhorando a interação em formulários de busca
• 8 maneiras de melhorar a performance de um site
• Ferramentas para criação de wireframes
• Recursos de usabilidade grátis
• User Interface em dicas rápidas
• Otimização WordPress: aumente a performance e desempenho de seu blog / site

Há muitas dicas úteis na internet sobre como otimizar seu blog Wordpress. Algumas delas são boas, mas difíceis de serem implementadas pelo “usuário médio”. Da experiência advinda da blogagem é possível saber de dicas para tornar seu site mais rápido e com melhor desempenho e performance.

É interessante que um web designer/desenvolvedor tenha em sua máquina o Firebug e Web Developer Toolbar, duas das mais importantes ferramentas de depuração em desenvolvimento web. Também tenha em mente que este artigo é dedicado, principalmente, aos sem possibilidade de configurar o PHP e MySQL diretamente, devido a condicionalismos e/ou restrições de hospedagem.

Otimize seu código HTML dentro de seu template

Esta é uma etapa que, geralmente, não é considerada importante quando, na verdade, deveria estar no topo de sua lista! É muito importante que seu código HTML esteja validado e que você não tenha código redundante. Certifique-se que seu tema é escrito com uma quantidade mínima de código possível. Não faça uso abusivo de tags como div e span.

Comprima seu CSS

Para que seu site seja mais rápido e de melhor performance e desempenho, existem vários truques que você pode aplicar no CSS, dentre eles:

• Usar declarações únicas no CSS. Você pode usar declaração única para margin, padding, background, border, font e list-style.
• Usar nomes pequenos em classes e IDs. Cada letra conta para o tempo de resposta do site. Por isso, é útil para o tamanho do CSS usar nomes simples e mais curtos ao invés de longos e descritivos nomes.
• Evitar seletores complexos. Tente fazer com que seus seletores sejam eficientes utilizando a maneira mais simples que for possível.
• Comprimir seu CSS. Depois que seu arquivo CSS estiver pronto, você pode ganhar velocidade adicional usando um compressor de CSS online - lembre-se de sempre ter um arquivo de backup com o código original.

Utilize Sprites CSS

Ao invés de usar vários arquivos de imagem no seu site/blog, experimente reunir o maior número possível de elementos gráficos em uma única imagem. Então usando a propriedade CSS background, você pode exibir os elements que quiser – essa é a técnica de CSS Sprites.

No caso dos Sprites CSS, o tamanho do arquivo de uma imagem é um menor que o de várias e o número de requisições HTTP também diminui – e esse é um dos fatores-chave para a performance de um site, como será visto a seguir.

Faça poucas requisições HTTP

Ultimamente esse tem sido um grande tema em debates sobre otimização e performance de sites. Alguns especialistas pensam que este é o aspecto mais importante a respeito do carregamento de uma página. A ideia principal é ter menos elementos na página, como imagens, arquivos CSS, javascript, etc. Alguns dizem que o ideal é faze menos de 25 requisições, se possível.

Evite carregar elementos externos

Esse é um dos mais importantes aspectos referentes à performance de web sites porque, ultimamente, os sites estão cheios de código javascript e iframes de sites de terceiros. Portanto, tente manter seu site longe de conexões a desnecessárias a elementos externos. Alguns fazem isso somente para mostrar um widget sem grande importância ou um “selinho” sobre alguma coisa que não acrescenta a navegação do visitante. Encontre alternativas ou tente hospedar os widgets em seu próprio dominio.

Deixe o tamanho da página inicial menor que 150KB

Para realizar essa “tarefa” selecione, no Web Developer, Informações > Visualizar Tamanho do Documento. Isto irá mostrar o tamanho de sua página e os elementos que fazem parte dela, como arquivos CSS, imagens, scripts, etc. Tente manter todos esses componentes no valor máximo de 150KB.

Exiba o resumo ao invés do artigo completo

Outra forma de otimizar sua página inicial é mostrar apenas uma parte de seus artigos. Dessa forma você exibe menos caracteres e faz com que o tempo de carregamento seja menor.

Reduza o número de plugins

A maioria dos plugins tem seus próprios arquivos CSS e/ou imagens. Então, se possível, é melhor manter baixo o número de plugins instalados para baixo. Dessa forma, você irá reduzir o número de requisições HTTP.

Exiba no máximo 20 imagens na index

Isso vale também para o objetivo de diminuir o número de requisições HTTP. As imagens podem estender o tempo de carregamento do site e é indicado que você não utilize mais de 15-20 imagens na index, quando possível. Quanto a páginas de artigos artigo, o número máximo de imagens deve ser de 5. Dessa forma, você pode ter artigos mais limpos e um site WordPress melhor.

Limpe sua sidebar

Coisas como calendário ou blogroll não são adequados para todo e qualquer blog/site WordPress. E estes componentes também diminuem a velocidade de carregamento de seu site. Você pode desabilitá-los, removendo o código do seu tema WordPress.

Caminho absoluto para algumas template tags

Quando você conhece os caminhos para determinados elementos, você pode usar os caminhos absolutos ao invés de usar as template tags do WordPress. Com isso, você pode reduzir o tempo de carregamento de seu site.

Por exemplo, em vez de usar a template tag bloginfo(‘’stylesheet_url’), você pode colocar o caminho absoluto: http://www.seusite.com/wp-content/themes/seutema/style.css.

Outros exemplos são:

• bloginfo(‘name’)
• wp_title()
• bloginfo(’stylesheet_url’)
• bloginfo(‘pingback_url’)
• bloginfo(‘template_url’)
• bloginfo(‘version’)
• bloginfo(‘atom_url’)
• bloginfo(‘rss2_url’)
• bloginfo(‘url’)
• bloginfo(‘name’)
• bloginfo(‘html_type’)
• bloginfo(‘charset’)

Impulsione seu WordPress com .htaccess

Esta é uma outra maneira de você aumentar o desempenho e performance de seu site/blog WordPress. Com base nas configurações do site e workflow, você pode personalizar o seu .htaccess usando as informações de “Ultimate .htaccess Tutorial” (além de informações sobre .htaccess em outros lugares). Lá você pode encontrar informações sobre cache, cabeçalhos, compressão gzip, etc.

Conclusão sobre otimização WordPress

A razão para este artigo foi a quantidade de blogs e sites WordPress atualmente disponíveis na internet. Seu número está aumentando e a maioria dos blogs não tem uma hospedagem com um nível tão bom.

Essas hospedagens não são tão rápidas, mas com uma pequena ajuda noo HTML, CSS e WordPress, a velocidade de blogs WordPress pode aumentar. Certamente essas dicas irão ajudar se seu objetivo e aumentar o desempenho e performance de seu site ou blog WordPress.

Artigos Relacionados

• 8 maneiras de melhorar a performance de um site
• User Interface em dicas rápidas
• Jetpack: explorando novas maneiras de ampliar e personalizar a web
• Dicas para otimizar códigos PHP
• Mais de 450 extensões para WordPress
• Desenvolvimento para web 2.0
• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)
• 25 extensões para o Firefox para aumentar a produtividade no dia-a-dia na web
• Textarea: dicas e truques que você sempre quis saber
• URLs amigáveis (slug) à WordPress

Muitas pessoas que usam WordPress sabem que o arquivo wp-config.php é o arquivo-chave para as configurações de banco de dados. É nele que você define o nome do banco de dados, nome de usuário, senha e localização. Mas o que muitos não sabem é que o wp-config.php pode ser usado para especificar uma grande variedade de outras configurações; configurações essas que permitem melhorar as funcionalidades, desempenho e segurança do seu WordPress.

As dicas a seguir abordam o que consta sobre o assunto no WordPress Codex, bem como alguns truques que provavelmente você não viu antes. Se você souber de qualquer outra configuração, comente que eu acrescento ao artigo. ;-)

Endereço do Blog e Endereço do Site

Por padrão, essas duas constantes de configuração não estão incluídas no wp-config.php, mas eles devem ser adicionados para melhorar o desempenho. Estas duas definições foram introduzidas no WordPress 2.2 e servem para substituir os respectivos valores do banco de dados sem alterá-los, efetivamente.

A adição dessas constantes reduz o número de consultas ao banco de dados e, consequentemente, melhora o desempenho do site. Essas configurações devem coincidir com as especificadas no painel do WordPress (Configurações > Geral). Segue um exemplo (não inclua a barra no final da URL):

define('WP_HOME', 'http://digwp.com');
define('WP_SITEURL', 'http://digwp.com');

Um truque legal é definir esses valores dinamicamente usando a variável global do servidor:

define('WP_HOME', 'http://' . $_SERVER['HTTP_HOST'] . '/path/to/wordpress');
define('WP_SITEURL', 'http://' . $_SERVER['HTTP_HOST'] . '/path/to/wordpress');

“Template Path” e “Stylesheet Path”

Assim como o Endereço do Blog e Endereço do Site mostrados anteriormente, você também pode aumentar o desempenho do site eliminando as consultas ao BD para o “Template Path” e “Stylesheet Path” (que são, respectivamente, o caminho para o tema e o caminho para o estilo CSS). Aqui estão os valores padrão para essas duas definições:

define('TEMPLATEPATH', get_template_directory());
define('STYLESHEETPATH', get_stylesheet_directory());

Com isso, ainda há consultas ao banco de dados, mas é possível eliminar essas duas queries e colocar o caminho absoluto:

define('TEMPLATEPATH', '/absolute/path/to/wp-content/themes/active-theme');
define('STYLESHEETPATH', '/absolute/path/to/wp-content/themes/active-theme');

Desabilitar Cache e Expiração de Cache

Essas duas opções se aplicam a versões mais antigas do WordPress que ainda estão usando o esquema antigo de cache. A primeira permite habilitar ou desabilitar o cache, enquanto a segunda permite especificar o tempo de expiração de cache.

Habilitar o cache:

define('WP_CACHE', true); // habilita o cache
define('ENABLE_CACHE', true); // habilita o cache
define('CACHE_EXPIRATION_TIME', 3600); // em segundos

Desabilitar o cache:

define('WP_CACHE', false); // desabilita o cache
define('DISABLE_CACHE', true); // desabilita o cache

Especificar Domínio de Cookie (Cookie Domain)

Existem várias razões para especificar um domínio de cookie para o seu web site. Um exemplo comum envolve impedir que cookies sejam enviados com requisições de conteúdo estático em subdomínios. Neste caso, pode-se utilizar esta constante para dizer para o WordPress enviar cookies apenas para o seu domínio não-estático. Este poderia ser um ganho significativo de performance. Aqui estão alguns exemplos de definição de cookie domain:

define('COOKIE_DOMAIN', '.digwp.com'); // não omitir o '.'
define('COOKIEPATH', preg_replace('|https?://[^/]+|i', '', get_option('home').'/'));
define('SITECOOKIEPATH', preg_replace('|https?://[^/]+|i', '', get_option('siteurl').'/'));
define('PLUGINS_COOKIE_PATH', preg_replace('|https?://[^/]+|i', '', WP_PLUGIN_URL));
define('ADMIN_COOKIE_PATH', SITECOOKIEPATH.'wp-admin');

Substituir Permissões de Arquivo

Se as permissões do seu servidor são muito restritivas, inserir essas definições no seu arquivo de configuração do WordPress pode ajudar a resolver alguns problemas. Lembrando que não precisa colcoar aspas nos valores.

define('FS_CHMOD_FILE', 0755);
define('FS_CHMOD_DIR', 0755);

FTP/SSH

Essas constantes são para ajudar usuários a localizar e utilizar conexões FTP/SSH. Exemplos:

define('FS_METHOD', 'ftpext'); // força o método de sistema de arquivos : "direct", "ssh", "ftpext", or "ftpsockets"
define('FTP_BASE', '/path/to/wordpress/'); // caminho absoluto para a pasta raiz (de instalação)
define('FTP_CONTENT_DIR', '/path/to/wordpress/wp-content/'); // caminho absoluto para a pasta "wp-content"
define('FTP_PLUGIN_DIR ', '/path/to/wordpress/wp-content/plugins/'); // caminho absoluto para a pasta "wp-plugins"
define('FTP_PUBKEY', '/home/username/.ssh/id_rsa.pub'); // caminho absoluto para a pasta sua chave-pública SSH
define('FTP_PRIVKEY', '/home/username/.ssh/id_rsa'); // caminho absoluto para a pasta sua chave-privada SSH
define('FTP_USER', 'username'); // seu usuário de FTP ou SSH
define('FTP_PASS', 'password'); // senha do usuário especificado em FTP_USER
define('FTP_HOST', 'ftp.domain.tld:21'); // hostname (com especificação de porta) para o servidor SSH/FTP

Alterar a localização de “wp-content”

Desde a versão 2.6 do WordPress é possível alterar o local padrão da pasta wp-content. Há boas razões para fazer isso, incluindo o reforço da segurança das instalações e facilitação de atualizações via FTP. Aqui estão alguns exemplos:

// caminho completo para o diretório atual (sem a barra final)
define('WP_CONTENT_DIR', $_SERVER['DOCUMENT_ROOT'] . '/path/wp-content');
 
// URI completa para o diretório atual (sem a barra final)
define('WP_CONTENT_URL', 'http://domain.tld/path/wp-content');

Você também pode especificar um caminho personalizado para o wp-content. Isso pode ajudar com problemas de compatibilidade com certos plugins.

// caminho completo para o diretório atual (sem a barra final)
define('WP_PLUGIN_DIR', $_SERVER['DOCUMENT_ROOT'] . '/path/wp-content/plugins');
 
// URI completa para o diretório atual (sem a barra final)
define('WP_PLUGIN_URL', 'http://domain.tld/path/wp-content/plugins');

Revisões de Artigos (“Post Revisions”)

Já há algum tempo o WordPress fornecem um sistema de versões que permite aos utilizadores guardar versões diferentes de seus posts e até reverter para versões salvas anteriormente se necessário. Aqui estão algumas das definições de configurações que podem ser úteis.

Definir o número de versões salvas:

define('WP_POST_REVISIONS', 3);

Desabilitar a revisão de posts (se não for usar o recurso, utilize essa diretiva para poupar espaço no BD):

define('WP_POST_REVISIONS', false);

Tempo de Salvar Automaticamente (“Autosave”)

Assim como o controle de versões, o autosave é um recurso muito útil existente. Por padrão, o WordPress salva seu trabalho a cada 60 segundos, mas você pode modificar esta definição para o tempo que quiser. Cuidado com o que vai colocar para não “estressar” seu servidor!

define('AUTOSAVE_INTERVAL', 160); // em segundos

Debugging

Desde a versão 2.3.1 os usuários tem a opção de mostrar alguns erros e avisos para ajudar com a depuração do site. Desde a versão 2.5 do WordPress é possível elevar o nível de informação para E_ALL para ativar avisos para funções obsoletas. Por padrão (ou seja, se nenhuma definição é especificado no wp-config.php) o relatório de erros está desativado.

define('WP_DEBUG', true); // habilitar debugging mode
define('WP_DEBUG', false); // desabilitar debugging mode (padrão)

Relatório de Erros

Aqui está uma maneira fácil de habilitar um relatório básico de erros no WordPress. Crie um arquivo chamado php_error.log em uma pasta de sua escolhe e coloque permissão de escrita no arquivo (leia mais sobre permissões de arquivos). Em seguida, edite o caminho na terceira linha do código a seguir e coloque no seu “wp-config.php”:

@ini_set('log_errors','On');
@ini_set('display_errors','Off');
@ini_set('error_log','/home/path/domain/logs/php_error.log'); // complemento: http://br.php.net/getcwd

Aumentar memória do PHP

Se você estiver recebendo mensagens de erro como “Tamanho de memória permitido de X bytes esgotado”, esta dica pode ajudar a resolver o problema.

Desde o WordPress versão 2.5, a constante WP_MEMORY_LIMIT permite que você especifique a quantidade máxima de memória que pode ser usada pelo PHP. Por padrão, o WordPress irá automaticamente tentar alocar 32 MB – então você só vai precisar isso se quiser valores superiores a 32MB. Observe que alguns planos de hospedagem desativam sua capacidade de aumentar a memória do PHP; se for seu caso, você precisa pedir que eles aumente a memória pra você. Aqui estão alguns exemplos:

define('WP_MEMORY_LIMIT', '64M');
define('WP_MEMORY_LIMIT', '96M');
define('WP_MEMORY_LIMIT', '128M');

Salvar e exibir Queries do Banco de Dados para Análise

Esta técnica é perfeita para guardar as consultas de banco de dados e exibir as informações para análise posterior. O processo armazena cada consulta, sua função associada e seu tempo total de execução. Esta informação é guardada como um array e pode ser exibida em qualquer página do tema. Para fazer isso, primeiro adicione a seguinte diretiva no seu wp-config.php:

define('SAVEQUERIES', true);

Em seguida, no rodapé do tema ativo, coloque o seguinte:

if (current_user_can('level_10')) // se for administrador
{
    global $wpdb;
    print_r($wpdb->queries);
}

Controle de Acesso ao Proxy

Desde o WordPress 2.8 o arquivo de configuração pode ser usado para definir constantes envolvidas com o bloqueio, filtragem e permição de acesso a máquinas específicas de um servidor proxy. Por exemplo, se você hospedar seu site WordPress em uma intranet, você pode impedir o acesso a todos os hosts externos e só permitir visitas do localhost (usando a primeira definição abaixo).

Você também pode permitir o acesso de máquinas específicas com uma lista separada por vírgulas, uma verdadeira “lista branca” (como demonstrado na definição do terceiro abaixo). Necessariamente deve permitir o acesso de api.wordpress.org para garantir as funcionalidades de arquivos importantes e plugins.

define('WP_HTTP_BLOCK_EXTERNAL', true);  // bloqueia requisições externas
define('WP_HTTP_BLOCK_EXTERNAL', false); // permite requisições externas
define('WP_ACCESSIBLE_HOSTS', 'api.wordpress.org'); // "lista branca" de hosts

Artigos Relacionados

• Erros comuns em desenvolvimento web para campanhas de SEO
• URLs amigáveis (slug) à WordPress
• 7 ferramentas para web designs melhores
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• 6 mitos de SEO que você deve evitar
• Estatísticas sobre comportamento nas mídias sociais
• Pergunte-se a si mesmo: questões para desenvolver um bom site
• “WordPress como CMS”?
• Maneira simples de saber quem faz referências a seu blog WordPress
• Dicas para otimizar códigos PHP

Um dos grandes “apelos” da comunidade WordPress é sobre um bom plugin gratuito para newsletter. Quando se procura por “plugins de newsletter para WordPress” nos buscadores, resultados é o que não falta, mas, infelizmente, nem todos são satisfatórios e atendem realmente ao que prometem: propiciar um gratuito, prático e fácil sistema de newsletter para WordPress.

Bateria de testes

A necessidade surgiu devido a um projeto em que estava envolvido. Na idealização do layout, havia neste um espaço reservado para newsletters. Já há algum tempo tenho usado WordPress para fazer 95% dos trabalhos web e, pensando na simplicidade e facilidades que a plataforma oferece e tendo em vista que sempre que precisei utilizar WordPress como CMS tudo correu tranquilamente, parti em busca de uma boa extensão para newsletter no WordPress.

Testei vários plugins nesse meu “apanhado” para testes. Alguns prometeram “mundos e fundos” mas, infelizmente, não cumpriram o que ofertavam. Outros que se apresentaram mais “modestos” e, aparentemente, com cara de “simples” e “fácil”, tornaram-se verdadeiros contratempos e foram de encontro à filosofia do WordPress no que diz respeito a praticidade, simplicidade e rapidez.

Depois de um tempo encontrei o que, para o projeto em questão e, certamente, para futuros projetos WordPress que necessitem da funcionalidade de newsletter, considero ser o ideal (pelo menos dentre os que eu experimentei: o plugin wp-ajax-newsletter.

Sobre o wp-ajax-newsletter

Conforme consta no site, o wp-ajax-newsletter

é um plugin WordPress que permite aos utilizadores subscreverem e receberem newsletters contendo os últimos posts do blog.

Simples assim! Do jeito que eu gosto (e que, acredito eu, é o conveniente para todos)!

Ainda segundo consta no site do plugin (e será visto mais à frente), é possível estabelecer a periodicidade de envio das newsletters, configurar os textos, ter acesso a base de cadastrados, utilizar constantes de sistema para personalizar os conteúdos, dentre outros.

Como é de se esperar, o plugin conta com sistema automático de validação de e-mails (um e-mail de confirmação é enviado e a pessoa tem que clicar em um link para confirmar).

Mexendo no wp-ajax-newsletter

Quando você instala o plugin (nessa altura do campeonato não precisa explicar isso, né?), automaticamente aparece em seu painel de controle uma nova opção no menu: Configurações > Newsletter. Acessando, todas as configurações cabíveis ao plugin de newsletter do WordPress estarão aí, divididas em 3 grandes grupos: Enviar Newsletter, Configurações e Assinantes. No front-end, a inserção do formulário AJAX para cadastro de e-mails é simplesmente um código de chamadas para uma função do plugin (veja o código de inserção do formulário para se cadastrar na newsletter).

Vou explicar o funcionamento no back-end, começando pelas Configurações.

Configurações (Configuration)

Nas Configurações é possível especificar a periodicidade que valerá para a divulgação das newsletters. Existem as opções:

• Manual. Enviar newsletters manualmente, sem uma periodicidade automática.
• Weekly. Enviar newsletter 1 vez a cada semana.
• Monthly. Enviar newsletter 1 vez a cada mês.
• Every “x” posts. Enviar newsletters a cada “x” artigos publicados – número este especificado por quem configura a extensão WordPress.

Continuando as configurações, estas estão dispostas e funcionando, respectivamente, assim:

• From. E-mail que será o “enviador” de todas as newsletters; é o e-mail que aparece no campo “De:” do envio de e-mails e o que aparecerá quando alguém clicar em “Responder”.
• Subject. É o assunto do e-mail. Acredito eu que não deva se estender muito e ser bem simples como “Newsletter do site X”.
• Header. Caso queira algum cabeçalho para sua newsletter, este é o espaço dedicado a o colocar. Use com sabedoria. Lembre-se: o que não é necessário, não precisa estar lá.
• Template. É aqui o “corpo” do conteúdo da newsletter. Este campo mostra o que as pessoas que receberem a newsletter vão visualizar em suas caixas de e-mail (incluindo excerpt, que é o resumo do artigo). O próprio plugin mostra quais as constantes de sistema podem ser usadas. Crie uma mensagem personalizada utilizando o que achar conveniente e que seja útil para quem está lendo.
• Footer. Texto para o rodapé de cada newsletter, se você achar que vale a pena.

Como consta no próprio texto explicativo do plugin, todas as mensagens são enviadas em texto puro – o que, penso eu, é o aconselhável de ser feito quanto se trata de envio de newsletters.

Enviar Newsletter (Send Newsletter)

Aqui são mostradas algumas esatísticas sobre o número de artigos de seu site WordPress e quantas pessoas já se subscreveram para receber as newsletters. Também é aqui o local onde você vai escolher quantos artigos (ou resumo de artigos, se preferir) serão enviados para as pessoas que se subscreveram.

Como puderam notar, o plugin envia newsletters cujos conteúdos são os próprios artigos publicados no site/blog WordPress. Ele foi idealizado para isso e funciona muito bem, cumprindo seu papel sem complicações. Entretanto, algumas pessoas podem precisar/julgar que os assinantes da newsletter devam receber conteúdos “exclusivos”, diferentes daqueles que constam como artigos do site. Se você é uma destas pessoas, preste atenção.

O pulo do gato para quem precisa enviar newsletters com conteúdos exclusivos está neste passo-a-passo:

1. Especifique que o plugin deve enviar somente o último artigo (preencha com o número 1 o campo “Send only the last ‘X’ posts)”;
2. Nas configurações, marque a periodicidade de envio como Manual;
3. Escreva o conteúdo que quer enviar somente para os assinantes de newsletters e publique;
4. Rapidamente vá em Configurações > Newsletter e envie o conteúdo do artigo que acabou de escrever;
5. Apague de seu site/blog o artigo que acabou de ser despachado em forma de newsletter.

Fazendo esta “mutreta” você garante que conteúdos exclusivos serão enviados para os que dedicaram um pouco de seu tempo cadastrando seu e-mail para o recebimento de newsletters de seu site.

Minha opinião pessoal é que este recurso não é necessário para a maioria dos projetos. Genericamente falando, não vejo razões para limitar o acesso a conteúdos do site/blog a determinado grupo de pessoas. Vejo as newsletter como um incremento às possibilidades disponíveis (e cabíveis) para recebimento de atualizações de conteúdos; não faz diferença se por feeds ou por newsletters, o importante é a pessoa manter-se atualizada e saber sobre novos conteúdos.

Assinantes (Subscribers)

Nesta parte é possível obter informações sobre os assinantes da newsletter. Na tabela aparecem as informações:

• E-mail. O e-mail que a pessoa usou e que vai receber as newsletters.
• Username. Caso o e-mail cadastrado for de alguém com acesso ao painel administrativo do WordPress, o login vai aparecer aqui; do contrário (o que vai acontecer na maioria dos casos), aparecerá “not registered“.
• Since. É o dia e a hora em que o e-mail consta no sistema como recebedor de newsletters.
• Action. Quando a pessoa tiver clicado no link para confirmação de recebimento de newsletter, aqui vai constar “Active”; quando tiver recebido o e-mail, mas ainda não tiver confirmado, será um link “Activate”, dando a opção de você ativar um e-mail mesmo sem a pessoa ter confirmado (opção desnecessária, a meu ver).
• Delete. Para apagar o e-mail da lista dos que recebem as newsletters do site.

Conclusões sobre o Ajax Newsletter Plugin para WordPress

Como foi possível perceber pelo artigo, a dinâmica e funcionamento do plugin são bastante tranquilos e tudo é feito de forma bastante rápida e simples.

Reforçando o que já disse, sou da opinião de que enviar conteúdos exclusivos, na grande maioria dos casos, não é uma boa prática, dado que se deve ofertar várias possibilidades de recebimento de atualizações no site e, juntamente com as atualizações através de feeds, as newsletters são uma ótima pedida!

Creio ser o wp-ajax-newsletter o mais fácil plugin (grátis) para newsletters do WordPress disponível atualmente. Depois de instalado e configutado, basta caprichar na customização das opções (e, aconselho eu, dedicar um pouco de seu tempo para traduzir as mensagens em inglês nativas, editando os arquivos originais do plugin para o caso de ser um job nacional) e, mais importante, fazer valer a pena a subscrição dos assinantes, provendo um conteúdo de excelente qualidade!  ;-)

Artigos Relacionados

• 8 maneiras de melhorar a performance de um site
• User Interface em dicas rápidas
• Erros comuns em desenvolvimento web para campanhas de SEO
• Melhorando a interação em formulários de busca
• Textarea: dicas e truques que você sempre quis saber
• 15 fantásticos comandos SQL para WordPress
• Recursos de usabilidade grátis
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• 8 dicas para fazer códigos melhores com jQuery
• Como otimizar imagens para web – guia de otimização de imagens

O Wordpress é certamente um dos maiores – considerados por alguns o maior – gerenciador de blogs e web sites (Wordpress como CMS?) que existe atualmente. Sua facilidade de instalação, manutenção e uso, fazem desta plataforma uma das melhores de se mexer. Mas não é somente “instalar e pronto”; uma instalação básica de Wordpress, segundo o que penso, conta com configurações, usos, instalação de plugins e outras coisas necessárias para garantir a “infra estrutura básica” de funcionamento, já pensando na expansibilidade e uso contínuo da plataforma.

Pensando nestas coisas que julgo importantes e imprescindíveis, elaborei um check list de uma instalação básica de Wordpress eficiente, tanto para uso imediato, quanto pensando na manutenção e “duração” de um blog ou web site. Esse check list de uma instalção Wordpress vai ajudar você a conhecer certas coisas, relembrar de outras e não esquecer toda elas! ;-)

Pré-instalação do Wordpress

1. Tenha um domínio e um servidor de hospedagem com capacidade a PHP e MySQL e que tenha um espaço em disco e transferência mensal segundo as características do blog/site que você tem em mente (dependendo, eu posso fazer um plano legal para você, basta entrar em contato). Certifique-se que já tem um host e um banco de dados criados para a instalação do Wordpress.
2. Entre no site oficial do Wordpress e baixe a versão mais atual disponível (por motivos óbvios);
3. Envie os arquivos – descompactados – para seu servidor de hospedagem e acesse seu domínio (ou a pasta na qual jogou os arquivos) e faça o wizard de instalação do Wordpress. É muito facinho, mesmo, nem precisa comentar a respeito.

Pronto, é só isso! Você receberá uma senha aleatório para o usuário “admin” e já pode fazer login no Wordpress!

Pós-instação do Wordpress

1. Obtenha uma API Key do Wordpress para ativar o Akismet (que já vem por padrão no Wordpress) – geralmente fica em Plugins > Configuração do Akismet;
2. Fique ciente sobre preciosas dicas de segurança no Wordpress, com especial atenção à adquirir suas secret keys mais recentes;
3. Configure corretamente seus permalinks e tenha atenção quanto a outros aspectos de SEO, conforme as recomendações das melhores práticas de SEO que você pode adotar em seu blog ou site;
4. Faça cadastro em alguns serviços primordiais para quem tem blogs/sites:
   • FeedBurner;
   • Google Analytics;
   • WebMaster Tools.
5. Instale alguns plugins “básicos” para um bom funcionamento do seu blog/site:
   • Google XML Sitemaps;
   • Dagon Design Sitemap Generator;
   • FeedBurner FeedSmith;
   • Manageable;
   • Ozh’ Admin Drop Down Menu;
   • Ozh’ Better Feed;
   • Platinum SEO Pack;
   • Robots Meta;
   • Wordpress Automatic Upgrade;
   • Wordpress Database Backup.

Genericamente falando, configure corretamente e com cuidado as opções do Wordpress segundo seus objetivos. Considero que as opções de configuração nativas do Wordpress, apesar de não muito extensas, são muito boas; atendem a diversos tipos de blogs/sites e possibilitam um bom nível de configurações básicas.

Esse check list ainda pode ser complementado. O que você considera importante para uma instalação básica do Wordpress?

Artigos Relacionados

• Nenhum artigo relacionado...

É muito comum ler na web que alguém vai usar “Wordpress como CMS”; que “Wordpress é tão bom que pode ser usado como CMS”; “só faço sites com Wordpress como CMS”; e por aí vai… Há uma confusão quanto a esta expressão, “Wordpress como CMS“, que é usada de forma errônea pelas pessoas e, se assim continuar, vai acabar causando uma grande confusão na cebeça de quem está começando a desenvolver com Wordpress.

O que é um “CMS”?

Antes de mais nada, é importante saber o que significa “CMS”. Na Wikipédia, o texto mostra que

Um Sistema de Gerenciamento de Conteúdo – SGC, (em inglês Content Management Systems – CMS), é um sistema gerenciador de websites, portais e intranets que integra ferramentas necessárias para criar, gerenciar (editar e inserir) conteúdo em tempo real, sem a necessidade de programação de código, cujo objetivo é estruturar e facilitar a criação, administração, distribuição, publicação e disponibilidade da informação. Sua maior característica é a grande quantidade de funções presentes.

Quer dizer, um Sistema de Gerenciamento de Conteúdo é um sistema feito para que as pessoas possam alterar o conteúdo de web sites, intranets, sistemas interativos ou o que quer que seja, sem a necessidade de ter conhecimentos “técnicos”, como saber XHTML, CSS, Javascript, etc.

Através de um CMS, então, a pessoa “leiga” em tecnologias web tem a capacidade de alterar as informações – conteúdos – de alguma publicação e/ou sistema on line sem a necessidade de intervenção de um profissional/atuante da área de desenvolvimento web.

Por alto, o que é possível fazer com o Wordpress?

Com o Wordpress é possível, dentre outras coisas:

• Criar páginas “fixas”;
• Editar páginas fixas;
• Crirar artigos;
• Editar artigos;
• Inserir fotos, vídeos e outras mídias;
• Editar fotos vídeos e outras mídias que foram inseridos;
• Criar textos, links e interações;
• Editar textos, links, alterar as interações.
• Muitas outras coisas!

Qual o equívoco em dizer “Wordpress como CMS”?

Na verdade, não é equívoco algum quando alguém diz “Wordpress como CMS”; o equívoco está no contexto em que as pessoas falam isso. Comumente, quando alguém diz isso, está se referindo a criar um novo tema (ou modificar um já existente) do Wordpress para que ele ou alguma outra pessoa – um cliente, possivelmente – utilize a plataforma para gerenciar as informações de um site e não de um blog – sendo que um blog não deixa de ser um site.

Quando as pessoas dizem que usam Wordpress como CMS, estão querendo dizer que vão gerenciar um sistema on line “com cara de site” ao invés de “com cara de blog” – pois blog, apesar de ser um site, tem algumas características diferenciadas, como disposição segundo cronologia, atualização constante, alguns elementos constitutivos, dentre outras.

Então, minha gente, percebam que o Wordpress já é um CMS por padrão! Ele já é usado para criar e editar conteúdos, em geral, de maneira que quem o está usando não tenha a necessidade de ter conhecimentos técnicos na área de desenvolvimento web! Por padrão, o Wordpress já tem a capcidade de “estruturar e facilitar a criação, administração, distribuição, publicação e disponibilidade da informação”!

Entenderam, agora, quando digo que há um tremendo equívoco quando as pessoas dizem “Vou usar o Wordpress como CMS”? A plataforma Wordpress já é um CMS!

Quando você for utilizar o Wordpress que, por padrão, “tem cara de blog“, para algum trabalho que tenha “cara de site“, não precisa dizer “vou usar Wordpress como CMS”; simplesmente diga: “Vou usar Wordpress”.

Artigos Relacionados

• URLs amigáveis (slug) à WordPress
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• Truques de configuração do WordPress
• CushyCMS: CMS versátil, simples, rápido, fácil e gratuito
• Maneira simples de saber quem faz referências a seu blog WordPress
• WP-Syntax: destacar códigos fonte em artigos de blogs WordPress
• Mais de 450 extensões para WordPress
• Desenvolvimento para web 2.0
• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)

Existem diversas maneira de saber quando uma ligação foi feita a seu blog Wordpress, seja usando sistemas na web, realizando consultas “especiais” no Google, usando plugins, etc. Entretanto, a maneira mais prática, rápida e fácil de saber sobre as ligações que são feitas a seu web site ou blog – pelo menos no meu ponto de vista – é fornecida pelo próprio Wordpress.

Assinar o feed de ligações para seu blog Wordpress

Existe uma maneira de assinar um feed cujo conteúdo são as referência que são feitas para seu blog Wordpress! Este feed libera uma nova “notícia” cada vez que seu blog recebe um inbound link, informando o título, endereço, quem escreveu e um trecho do artigo.

Para mim, que sou vidrado em feeds e não fico sequer um dia sem conferir as novidades, saber, através de um feed de inbound links ao desenvolvimento para web, quem fez uma referência ao blog, é espetacular!

Como assinar o feed de referência a seu blog ou site Wordpress

É muito fácil assinar o feed de inbound links para seu site ou blog Wordpress. Na verdade, é uma opção que aparece na primeira página do painel administrativo, numa área de bastante visibilidade, mas que, não sei por que, a maioria dos que usam Wordpress desconhecem o recurso.

Basta você clicar na opção “RSS” que aparece à extrema direita da divisão “Links de Entrada“. O link que tem um iconezinho de Feed RSS.

Então, você simplesmente copia o endereço do Feed de referência a seu blog e o cadastra em seu agregador de Feeds – recomendo o Google Reader, por achar que é o melhor agregador de feeds.

Bem facinho, né? ;-)

Artigos Relacionados

• Desenvolvimento para web 2.0
• Mais de 450 extensões para WordPress
• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)
• 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
• URLs amigáveis (slug) à WordPress
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• Truques de configuração do WordPress
• Novo tema para o blog: dpw2009
• “WordPress como CMS”?

Com o lançamento da nova versão do Wordpress, Wordpress 2.6, muitos bugs foram corrijidos, muitos referentes à segurança da plataforma de blogging. Entretanto, algumas medidas extras podem e devem ser tomadas, a fim de garantir uma instalação segura e instável de seu blog, livre de surpresas desagradáveis, como exploits, invasões, perda das informações e outros.

Tenha sempre a última versão do Wordpress e dos plugins

Esta é a dica mais simples e fácil e, ao mesmo tempo, a mais intuitiva e que praticamente todos a seguem, sem ter que “pensar” muito. Como comentado no início do artigo, sempre que uma nova versão do Wordpress sai, além das inovações e funcionalidades, diversos erros de programação, bugs, e otimização nos códigos são feitos.

Por isso, é sempre bom ter instalada a última versão do Wordpress e seus respectivos plugins, pois estes também podem apresentar eventuais falhas que abrem brechas e, não raramente, comprometem a instabilidade, desempenho e segurança e funcionamento de uma instalação inteira de Wordpress!

Para manter o Wordpress atualizado é simples: sempre que sai uma nova versão, um aviso aparece na área administrativa. Com os plugins não é diferente, mas é preciso visitar frequentemente a página de extensões para receber os avisos de atualizações e fazer o upgrade automático, disponível desde duas versões anteriores do WP.

No caso da versão do Wordpress, em si, existem diversas maneiras de se atualizar:

• Baixar a versão mais atual do Wordpress no site oficial e fazer a atualização manual;
• Utilizar extensões do WP para se fazer upgrade (como Wordpress Automatic upgrade e outros);
• Alguns servidores de hospedagem contam com opção de atualização automática.

Lembrando sempre do “lema”: faça backup antes, faça backup sempre! ;-)

Use plugins para otimização e segurança de seu blog ou site Wordpress

Existem milhares de plugins disponíveis para Wordpress; plugins estes que servem para os mais diversos fins e propósitos, desde um simples enfeite em alguma área do blog, até funções que, pessoalmente, acredito que deveriam vir por padrão no WP como opções de otimização na parte de SEO (por falar nisso, ao contrário do que muitos pensam, o plugin All in One SEO Pack não foi descontinuado), segurança e outros.

Portanto, para suprir esta relativa “carência nativa” do Wordpress, é recomendado que se use, pelo menos, as seguintes extensões:

• Akismet. O popular e conhecido Akismet é um dos mais usados plugins Wordpress. Ele previne spams nos comentários e um possível ataque de mensagens em massa, na tentativa de sobrecarregamento e exposição/criação de vulnerabilidades. Utilizá-lo é obrigatório em blogs e sites baseados no Wordpress;
• WP Security Scan. Usar o WP Security Scan é importante pois, como sugere o próprio nome, o plugins faz uma bateria de testes em sua instação Wordpress para detectar alguma falha de segurança. Essa análise de segurança, além da verificação de vulnerabilidades, ainda sugere ações corretivas nas áreas de senhas, permissões de arquivos, segurança do banco de dados, ocultação de versões, dentre outros;
• Optimize DB. A extensão Optimize DB serve para melhorar o desempenho e implementar melhores e otimizações, em geral, nas tabelas do WP. Com apenas um clique a extensão analise como anda o banco de dados e faz as devidas melhorias, providenciando um bom aumento de performance;
• WP-DBManager. O WP-DBManager serve para tarefas estritamente relacionadas às bases de dados da instalação Wordpress, permitindo realizar várias atividades, como otimizar, fazer backups e restaurações do banco de dados, apagar e esvaziar dados e tabelas, realizar consultas personalizadas e mais;
• WordPress Database Backup. A extensão WordPress Database Backup faz backups das bases de dados da instação Wordpress padrão e também da tabelas que alguns plugins criam para funcionar corretamente. É possível fazer um backup individual, a hora que se quer, ou agendar backups automáticos, diários ou semanais, que são enviados para uma conta de e-mail escolhida.

Login Lockdown plugin

Fora os plugins citados acima, que considero indispensáveis para uma instalação segura de Wordpress, a instalação do plugin Login Lockdown pode ser igualmente útil. Este plugin Login Lockdown, depois de instalado, guarda o endereço IP e timestamp de todas as tentativas de login fracassadas no painel de controle. Depois de 3 falhas de autenticação no período de 5 minutos, o acesso àquele IP específico ao painel administrativo é travado por 1 hora.

Com isso, caso alguém tente descobrir a senha do painel de controle WP de forma manual ou através de uso de scripts que impregam a técnica de força bruta, este alguém terá pela frente mais uma camada de segurança e o acesso às áreas críticas de seu blog fica mais seguro.

Secret Key

Muitos desconhecem o fato de ser possível adquirir uma Secret Key para melhorar a segurança de uma instalação Wordpress, apesar de a própria equipe do CMS frequentemente alertar sobre a importância e necessidade de se ter uma.

Primeiramente, adquira uma secret key. Depois disso, acesse sua base de arquivos Wordpress e coloque para editar o arquivo wp-config.php, na raiz da instalação. Nele, simplesmente acrescente a linha de código da sua secret key.

Atenção para o fato de que a cada atualização da página é gerada uma secret key Wordpress única, sem repetições. Quer dizer, guarde-a com cuidado porque, caso você perca a sua, terá que pegar uma nova.

Você tem uma instação Wordpress segura?

Ter uma instação Wordpress segura deve ser preocupação de todo aquele que tem um blog ou site baseado na plataforma. Construir bases seguras e bem-feitas é o primeiro passo a se tomar na construção de um projeto de qualidade e longa duração.

Uma das primeiras coisas a se fazer quando se instala um Wordpress é fazer a seguinte checklist:

• Tenha a versão mais recente do Wordpress e sempre atualize a plataforma de blogging;
• Adquira uma secret key e implemente a linha de código no arquivo wp-config.php;
• Confira se a versão dos plugins usados é a mais recente e, se necessário, faça as devidas atualizações;
• Instale, configure e use corretamente os plugins citados para segurança e otimização do Wordpress;
• Visite frequentemente sua página de plugins para ver se saiu alguma versão nova e fazer as devidas atualizações.

Seguindo estas etapas é dar o primeiro passo para se ter uma boa instalação Wordpress, sólida, confiável e segura, livre de “azarões virtuais” e pessoas mal intencionadas.

O passo seguinte é se manter atualizado sobre o Wordpress, visitar blogs que tratam do CMS, listas de discussão, fóruns ou simplesmente pedindo a um amigo que entenda/goste mais para avisar sobre alguma mudança importante ou atualização de segurança do Wordpress.

Fazendo isso, certamente você poderá se focar naquilo que é o mais importante em seu blog: produzir conteúdos de qualidade e interagir com seus leitores, proporcionando uma melhor experiência e estabilidade de acesso àqueles que o prestigiam com a leitura de seus artigos.

Se tiver alguma outra dica, sugestão ou macete para se ter uma melhor segurança no Wordpress, não se acanhe em compartilhar conosco! ;-)

Artigos Relacionados

• Textarea: dicas e truques que você sempre quis saber
• 15 fantásticos comandos SQL para WordPress
• Como criar sumários dinamicamente com o TOC (Table of Contents) jQuery plugin
• Mais de 450 extensões para WordPress
• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)
• jQuery: mais 50 dos melhores tutoriais, apostilas e exemplos
• Como tirar screenshot de um web site inteiro e obter uma imagem completa
• 25 extensões para o Firefox para aumentar a produtividade no dia-a-dia na web
• Erros comuns em desenvolvimento web para campanhas de SEO
• Melhorando a interação em formulários de busca

Alguns criam regras CSS para utilizar em trechos dos códigos que apresentam, criando diversas classes, para estilizar diversas cores de texto com a propriedade “color”. Entretanto, a aplicação deste monte de classes em um código, além de ser demorada e sua implementação desgastante para o autor do post, apresenta o inconveniente de ser dificilmente manutenível.

Para apresentar diversos tipos de códigos em posts de blogs Wordpress, existe uma solução melhor, mais rápida, prática e que utiliza uma das principais vantagens desta plataforma: a extensibilidade de suas funções através de plugins.

Sobre o plugin WP-Syntax

WP-Syntax é um ótima extensão Wordpress para exibir códigos com sintaxe de fácil visualização e de forma inteligível. Quando se usa o plugin, é possível exibir códigos-fonte coloridos (coloração automática) com ou sem numeração das linhas. Para quem lê o artigo é excelente, já que ele provê uma sintaxe limpa e permite selecionar o código através do próprio navegador.

O sistema de highlighting do WP-Syntax é feito usando o GeSHi (Generic Syntax Highlighter), que já é conhecido entre alguns desenvolvedores web devido à sua facilidade de implementação e simplicidade de uso.

Funcionando do WP-Syntax

O uso do WP-Syntax é simples e seguro; ele evita conflitos com outros plugins de terceiros, executando “filtros” que garantem a compatibilidade geral com outras extensões, conferindo um resultado ótimo, que é a formatação dos códigos-fonte e exato destaque da forma como se quer e precisa.

Instalação e uso do WP-Syntax

Este plugin é todo fácil de usar, desde sua instalação ao momento de exibir códigos formatados nos posts.

Instalação

A instalação do WP-Syntax é feita da maneira “tradicional”:

1. Baixar o plugin;
2. Descompactar o conteúdo do arquivo zipado dentro da pasta padrão de plugins do Wordpress, o que irá resultar na seguinte hierarquia de diretórios: wp-content/plugins/wp-syntax/;
3. Ativar o plugin na área “Complementos” (Plugins) do painel de controle WP;
4. Começar a usar o WP-Syntax.

Como usar o WP-Syntax

Tirar proveito das funcionalidades do WP-Syntax é bastante simples. Enquanto escreve um artigo, vá até o modo de edição de código em seu tinyMCE – aba de nome “HTML” se você usa o modo de edição gráfica -  e englobe o código que você quer que fique estilizado entre tags pre. Para configurar o plugin in-line, é preciso informar:

• Qual linguagem será usada (necessário);
• Se haverá numeração de linhas (opcional).

Então, para colocar um trecho de código PHP com numeração de linhas, por exemplo, ficaria da seguinte maneira:

<pre lang=”php” line=”1″>

[...] código [...]

</pre>

Veja o plugin em funcionamento:

1
2
3

for ($i = 1; $i <= 11; $i++){
    echo $i . ', ';
}

Basta retirar o atributo “line” para o código iserido aparecer sem a numeração de linhas; caso se queira iniciar a contagem em número diferente, basta informar: line=”23″. Faça o teste e selecione o trecho de código acima; perceba que é possível fazer a seleção e colar onde se queira sem que a numeração também vá para a área de transferência.

Algumas das linguagens de programação e marcação que o WP-Syntax suporta são:

• ASP;
• C;
• D;
• CFM;
• CSS;
• HTML;
• Java;
• Javascript;
• mySQL;
• Oracle 8;
• Perl;
• PHP;
• Python;
• Ruby;
• E mais de 70 outras linguagens.

Um dos grandes benefício do WP-Syntax é que ele tem diversos “esquemas” de cores, um para cada linguagem de programação, estilo ou marcação escolhida, o que facilita a inserção de diversos trechos, de várias linguagens, em um só artigo, de modo a evidenciar a diferença entre todas, facilitando a leitura e entendimento do leitor.

Algo importante sobre o uso do WP-Syntax

Este aviso é somente para os que utilizam o editor gráfico para escrever artigos; os que utilizam somente o modo código, nem precisam ler este aviso.

Aconselho, ao usar o WP-Syntax para destacar códigos-fonte em seu artigos, a primeiro escrever as partes do post que são “texto comum”, como explicações, etc e, por último, passar ao modo HTML e inserir os códigos necessários.

E mais: ao editar um artigo já escrito com uso do WP-Syntax, vá até outro artigo qualquer, passe para o modo de edição HTML e, somente depois disso, edite o arquivo que usou o plugin.

O motivo para ambos é que o editor gráfico do Wordpress interpreta as tags existentes para as renderizar corretamente enquanto se escreve o post (negrito, itálico, etc). Então, como se está inserindo código “interpretável” por ele, é arriscado, dependendo da linguagem que se esteja usando no WP-Syntax, como HTML, por exemplo, de, no momento em que se passa para a edição em modo gráfico, o editor do Wordpress apagar as tags que você usou em seu artigo, com o WP-Syntax.

Nosso colega Rafael Biriba escreveu um excelente artigo sobre como utilizar os modos Visual e HTML com WP-Syntax sem strip tags.

Conclusão

Pessoalmente, quando ainda desconhecia a existência de um plugin que destaca códigos-fonte em artigos, como este, utilizava a “técnica” de criar diversas classes CSS para estilizar códigos que colocava nos posts. Posso garantir que não é a melhor das experiências, principalmente para o caso de ter que fazer manutenção no código…

O melhor, mesmo, para os casos de inserção de código diretamente em posts, para quem usa Wordpress, é utilizar o plugin WP-Syntax, que, primando pela simplicidade e facilidade de uso, além de possuir excelente suporte às mais de 70 linguagens de programação, estilo e marcação citadas, atende perfeitamente a finalidade para que foi criada, permitindo que o autor dos artigos mostre códigos a seus visitantes com uma sintaxe colorida, focando na facilidade de compreensão e entendimento dos códigos.

Artigos Relacionados

• URLs amigáveis (slug) à WordPress
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• Truques de configuração do WordPress
• “WordPress como CMS”?
• Maneira simples de saber quem faz referências a seu blog WordPress
• Mais de 450 extensões para WordPress
• Desenvolvimento para web 2.0
• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)

Wordpress é, sem dúvida alguma, o melhor CMS (“Content Management System” ou Sistema de Gerenciamento de Conteúdo) focado em blogs que existe atualmente. Obviamente que é possível, também, adaptar o Wordpress para montar web sites “tradicionais” mas, como disse, seu foco são os blogs.

Um dos motivos que tornam esta ferramenta tão útil e procurada por desenvolvedores web e/ou pessoas querendo montar/melhorar um blog é, sem dúvidas, a possibilidade de aumentar/incrementar suas funcionalidades através da instalação de extensões; extensões estas, ou plugins, desenvolvidas por terceiros, em sua quase totalidade gratuitas, com o objetivo principal de aumentar a capacidade e recursos que o CMS Wordpress oferece nativamente.

Existe uma seção especial no web site oficial do Wordpress, o Pugin Directory, que serve, na verdade, como uma base oficial de plugins que terceiros desenvolvem/atualizam pelo mundo. Aquele que desenvolve sua extensão a submete à base de dados ofical de plugins para Wordpress e, através de buscas por expressões e/ou acesso a categorias específicas, é possível encontrar os que foram cadastrados.

O fato de o Plugin Directory ser a base oficial de armazenamento de plugins para Wordpress não significa que seja o único. Procurando pela web, não é demorado encontrar compilações de extensões para a plataforma, diretórios não-oficiais, indicações de extensões, e muito material relacionado à expansão das funcionalidades e características do Wordpress.

Inclusive, já citei algumas aqui no desenvolvimento para web, que foram:

• Os melhores e mais usados plugins para Wordpress;
• Excelentes plugins para Wordpress, feitos por um brasuca.

Navegando pela web, recentemente descobri um diretório não-oficial de extensões muito interessante: “I want a WordPress Plugin to…“! Através de um sistema de tags, este diretório de plugins indica, de forma rápida e fácil, mais de 450 extensões diferentes para WP! Dentre as muitas tags que classificam todo o conteúdo do diretório, vejam o exemplo de algumas:

• Painel administrativo;
• Ajax;
• Blogroll;
• Downloads;
• E-commerce e monetização;
• SEO.

Enfim, para quem mexe com a plataforma Wordpress e sabe que a instalação e uso de extensões é realmente um catalizador de suas potencialidades, que aumenta e expande aquilo que, nativamente, o sistema é capaz de realizar, confira esta excelente lista de plugins que, certamente, vai ajudá-lo em algum projeto; seja para tirá-lo de um sufoco, ajudá-lo na otimização e performance ou, simplesmente, contribuir para que sua experiência como blogueiro (e, consequentemente, a dos visitantes de seu blog ou site) seja muito melhor!

Artigos Relacionados

• WassUp: plugin WordPress para ver estatísticas de acesso (em tempo real)
• Desenvolvimento para web 2.0
• 25 extensões para o Firefox para aumentar a produtividade no dia-a-dia na web
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• 30 extensões para Firefox que vão mudar sua vida na web (para melhor)
• Maneira simples de saber quem faz referências a seu blog WordPress
• Preciosas dicas de segurança e otimização para WordPress
• jQuery: mais 50 dos melhores tutoriais, apostilas e exemplos
• Como tirar screenshot de um web site inteiro e obter uma imagem completa
• Textarea: dicas e truques que você sempre quis saber

É de extrema importância mensurar, analisar e acompanhar acessos a web sites e blogs, por motivos vários. Só sobre para citar alguns, poderia comentar:

• Definir os melhores horários para publicar artigos;
• Saber quais as melhores horas para uma “promoção relâmpago”;
• Conhecer os hábitos de acesso do público-alvo (diurnos ou noturnos, por exemplo);
• Obter informações de acesso para criar campanhas de marketing segmentado;
• Definir estratégias de SEM;
• Dentre muitos outros.

Para tal, existe um extenso leque de possibilidades, pronto a se abrir para aqueles que querem e/ou precisam saber sobre as estatísticas de acesso em seu site ou blog. O mais comum para obter este tipo de informações sobre visitantes são sistemas específicos para saber mais sobre a origem de acesso, permanência e motivos de saída (tais como Google Analytics, Woopra, Yahoo Analytics e Microsoft adCenter Analytics) daqueles que visitam o espaço virtual. Mas as possibilidades não se encerram por aí.

Para aqueles que utilizam a plataforma Wordpress para criar e manter blogs ou personalizar o CMS para que fique no “estilo” web site, existem plugins de estatísticas bastante eficientes! Depois de testar alguns, optei por utilizar, “oficialmente”, o WassUp.

Instalar o plugin WassUp

Nenhum mistério para instalar a extensão. Basta baixar a versão mais recente, descompactar na pasta padrão de plugins (wp-content/plugins/), acessar o painel administrativo do Wordpress (com privilégios para acessar a aba “Plugins”) e ativar o Wassup, que já deve aparecer na listagem das extensões.

Diferentemente da maioria das extensões para Wordpress, as opções do Wassup não aparecem como um submenu da aba “Options“; ao invés disso, um novo item no menu principal aparece (“WassUp“). Nela, existem 4 opções: “Visitors Details”, “SPY Visitors”, “Current Visitors Online” e “Options”.

Visitors Details

Esta é a tela principal da extensão. Nela, é possível visualizar as estatísticas de acesso e várias opções de refinamento estão disponíveis.

As estatísticas de acesso dos visitantes e pageviews são exibidas através de números e graficamente (a linha contínua azul são visitas e a laranja pontilhada são pageviews). Além disso, numericamente é possível obter acesso à média de páginas acessadas por visita e porcentagem de visitas que, na verdade, eram SPAMs (esqueci de comentar que ele tem integração com o Akismet?). É possível, também, ajustar a visualização das estatísticas em 4 períodos diferentes: 24 horas, 7 dias, 1 mês e 1 ano.

Também existe a possibilidade de ajustar quantos detalhes de acesso serão exibidos por tela (10, 20, 50 ou 100) e ordená-los por uma série de opções (Spams, Bots, Usuários logados, membros, referência de links externos e mais).

O detalhamento das informações sobre os visitantes é incrível: IP, data, hora de visita em cada página, se veio por link de referência, sistema de busca (nesse caso, informa as palavras chave usadas) ou visita direta, país de origem (mostra bandeirinha), se é bot (identificando qual é), spam ou visitante humano (logado ou não). Ah, e se for preciso fazer uma busca nas estatísticas, isso também é possível!

SPY Visitors

Certamente, uma das features mais impressionantes do WassUp! É possível acompanhar em tempo real se há alguma atividade no blog; se houver, em qual página o(s) visitante(s) está(ão), se veio através de link de referência, sistema de busca ou se foi visita direta, e outras informações parecidas com as que são possíveis ter acesso em “Visitors Details”.

E quando digo “tempo real”, refiro-me a atualizar de 10 em 10 segundos as informações sobre atividades (via AJAX) para um acompanhamento ultra refinado e específico!

Current Visitors Online

Nesta tela é possível saber quantos visitantes estão no blog no momento (com detalhes das informações já citadas acima).

A meu ver, isso poderia ficar em “SPY Visitors“, como um informação complementar, e não figurar em uma opção independente do WassUp…

Options

Aqui ficam as opções da extensão. São tantas, que foi preciso dividí-las em “sub-abas”.

Primeiramente as Opções Gerais (“General Setup”), onde é possível configurar a largura (em pixels) do gráfico de acessos, se este gráfico vai aparecer na primeira página do painel administrativo do Wordpress, de quantos em quantos minutos o gráfico deve ser atualizado, quais informações dos visitantes serão mostradas, dentre muitas, muitas outras opções.

Na segunda sub-aba, “Statistics Recording”, constam as opções referentes à gravação de estatísticas. Dentre as muitas opções possíveis, é permitido vetar IPs e páginas do site de serem gravados.

Em “Manage Files & Database” ficam as opções que afetam o registro das estatísticas no banco de dados que o WassUp cria no Wordpress. É possível especificar a pasta onde informações temporárias serão armazenadas, visualizar o tamanho atual da base de dados, especificar períodos para que registros antigos sejam apagados automaticamente, e algumas outras coisas.

Por último, a sub-aba para desinstalar o plugin WassUp e remover tudo o que ele criou na instalação do Wordpress no momento em que foi ativado.

Conclusões sobre a utilização do WassUp

Dentre os não muitos plugins de estatísticas de acesso para Wordpress que eu utilizei, o que mais me agradou e atendeu a minhas necessidades foi o WassUp. Pelo que escrevi acima, é possível perceber que ele é bem completo, exibe bastantes informações e, digo por experiência própria, é bem rápido e não pesa em nada o carregamento do restante das opções no painel de administração do Wordpress.

A grande vantagem, a meu ver, é a possibilidade de acompanhar, “ao vivo”, o que os visitantes fizeram e estão fazendo no blog! É tudo bastente rápido e confiável (fiz testes de acesso com colegas meus), e possibilita a abertura de “novos horizontes” em se tratando de definir estratégias para o blog.

Como desvantagens, ou melhor, defasagens, cito que as estatísticas principais do WassUp poderiam ser bem mais completas, com direito a informações ainda mais específicas e afuniladas como o Google Analytics, por exemplo (que, inclusive, uso conjuntamente com o WassUp para registrar os acessos ).

Não é possível deixar de contar os próprios acessos ao blog bloqueando scripts, já que seu funcionamento se dá no server side. Para alguns isso pode ser vantagem, para outros, não…

Enfim, reafirmo que o WassUp é um plugin muito útil de se ter instalado; realmente vale à pena! Entretanto, não vejo razões para não o usar conjuntamente com outros tipos de serviços que têm a capacidade de mostrar informações mais detalhadas sobre acessos.

Vocês conhecem alguma boa alternativa?

Artigos Relacionados

• Mais de 450 extensões para WordPress
• Otimização WordPress: aumente a performance e desempenho de seu blog / site
• Maneira simples de saber quem faz referências a seu blog WordPress
• Preciosas dicas de segurança e otimização para WordPress
• Desenvolvimento para web 2.0
• jQuery: mais 50 dos melhores tutoriais, apostilas e exemplos
• Como tirar screenshot de um web site inteiro e obter uma imagem completa
• 25 extensões para o Firefox para aumentar a produtividade no dia-a-dia na web
• Textarea: dicas e truques que você sempre quis saber
• URLs amigáveis (slug) à WordPress