Arquivo para o ‘Programação’ Categoria

Criando Plugins no WordPress: O Básico

Última atualização terça-feira, 24 agosto 2010 09:49 Escrito por Agripino Duarte terça-feira, 24 agosto 2010 09:49

As duas últimas semanas de trabalho eu passei quase que exclusivamente dedicadas a criação de um plugin em WordPress que gerencia o conteúdo da página institucional da empresa onde eu trabalho, a Radig (www.radig.com.br). Depois de algumas limitações e uma série de ajustes o plugin ficou pronto e está quase perfeito, precisa de uns retoques e a correção de alguns bugs.

Criar plugins para o WordPress pode ser uma tarefa simples, mas algumas vezes pode ser algo que dê um certo trabalho. Na api do WordPress, as funções são membros isolados, quase sempre salvas em arquivos únicos, de nomes significativos em diretórios específicos. Não há orientação a objetos e de qualquer ponto de sua aplicação (seja um tema ou um plugin) é possível acessar funções que estejam presentes em qualquer diretório da aplicação.

Por isso o WordPress recomenda nomear funções novas (em plugins e temas) com nomes únicos, assim evita o conflito de nomes de função, já que quase sempre não há necessidade de se incluir arquivos ou definir escopos em funções. É importante também verificar se o nome do plugin que estamos criando já não existe no repositório do WordPress, pois se já existir pode haver conflitos em pesquisar um plugin ou atualizar o mesmo.

Criar plugins no WordPress é basicamente criar uma aplicação php, que se utiliza de funções do WordPress e algumas definidas pelo usuário. Um único arquivo php (de preferência com o nome do plugin), dentro de um diretório com o nome do plugin, já é o suficiente para a existência do plugin, mas é necessário ainda que esse arquivo php possua em seu cabeçalho o seguinte comentário:

/*
Plugin Name: Nome do Plugin
Plugin URI: http://website-do-plugin.com
Description: alguma descrição
Version: 0.1
Author: jose
*/

Basta apenas informar Plugin Name e Author para que o WordPress reconheça o seu plugin e o coloque na lista de plugins instalados.

Nesse arquivo php, ou em outros que forem inclusos, deverão declarar suas funções e utilizar de funções básicas do WordPress para realizarem a modificação do conteúdo que é exibido ou armazenamento e busca de dados no banco de dados do WordPress. Para que o plugin faça a modificação do conteúdo ou busca/armazenamento é necessário interceptar algumas funções básicas do WordPress, como the_content (retorna o conteudo de um post), wp_head (imprime o conteúdo da seção head de uma página), etc.

Essa interceptação e feita utilizando filtros , que podem substituir uma dessas funções básicas do WordPress pela nossa função. O código para isso e bem simples:

add_filter('the_content', 'my_content');
function my_content()
{
echo 'my content';
}
?>

A declaração acima faz com que o conteúdo de uma página ou post que seja buscado pela função the_content, seja substituído pela minha função my_content;

Uma extensa lista de filtros e ações permitem a manipulação do que será exibido e salvo na aplicação WordPress. Essa lista está na documentação do Wordpres.

Por ora o que tenho a dizer é isso. Postarei mais dicas de como fazer plugins em WordPress, mas se você não quer esperar e quer começar agora mesmo, leia a documentação oficial, pois apesar de deixar algumas coisas de fora, ajuda muito quem está começando.

http://codex.wordpress.org/Developer_Documentation

Funções para Manipulação de variáveis

Última atualização sábado, 3 julho 2010 02:45 Escrito por ffarias sábado, 3 julho 2010 02:45

Ao se trabalhar com javaScript ou qualquer outra linguagem de programação, muitas vezes é necessário saber o tipo da variável que estamos manipulando. Por exemplo: uma variável do tipo boolean pode representar dois valores lógicos (verdadeiro ou falso) e deve assumir somente um dos símbolos dessa faixa de valores.

Considere agora que no seu código existe uma variável qualquer, e em uma determinada condição seja necessário saber o tipo dessa variável.

Exemplificando:

Se tipoVariavel(estado) = ‘boolean’ Então { … }

No javaScript isso acaba se tornado um problema, apesar de pequeno, mas que pode se estender se você precisar saber em outras “várias” linhas de código se uma determinada variável é uma string, um número, um objeto e por aí vai…

O objetivo deste artigo é escrever um código em javaScript (uma pequena biblioteca) para resolver estes pequenos problemas do dia a dia.

^?View Code JAVASCRIPT

/**
 * Manipulação de Variáveis 1.0
 * @author: Felipe Lunardi Farias
 *
 * @class check
*/
var check = function(){
 
    return {
 
        /**
         *  Criamos um objeto (op) com a propriedade prototype para
         *  adicionar propriedades e/ou métodos a um determinado objeto
         */
        op : Object.prototype,
 
        /**
         * Determina se o objeto possui valor indefinido
         * @method is_undefined
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_undefined: function( o ) {
 
            try{
                return typeof o === 'undefined';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se é um array
         * @method is_array
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_array: function( o ){
 
            try{
                return this.op.toString.apply(o) === '[object Array]';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é do tipo string
         * @method is_string
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_string: function( o ) {
 
            try{
                return typeof o === 'string';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é do tipo número
         * @method is_number
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_number: function( o ) {
 
            try{
                return typeof o === 'number' &amp;&amp; isFinite(o);
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é uma função
         * @method is_function
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_function: function( o ) {
 
            try{
                return this.op.toString.apply(o) === '[object Function]';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto é um boleano
         * @method is_boolean
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_boolean: function( o ) {
 
            try{
                return typeof o === 'boolean';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },
 
        /**
         * Determina se o objeto possui valor nulo
         * @method is_null
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_null: function( o ) {
 
            try{
                return o === null;
            } catch(e){
                throw new Error( "Error: " + e );
            }
        },            
 
        /**
         * Determina se o objeto é do tipo objeto
         * @method is_object
         * @param {object} objeto em teste
         * @return {boolean} resultado
         */
        is_object: function( o ) {
 
            try{
                return typeof o === 'object';
            } catch(e){
                throw new Error( "Error: " + e );
            }
        }
    };
};

Dicas de Otimização: Alocação dinâmica de memória para uma Matriz

Última atualização quinta-feira, 1 julho 2010 08:49 Escrito por Patrick Shinzato terça-feira, 8 junho 2010 09:37

É normal no mundo da programação, não importa a linguagem, trabalharmos com matrizes de dados. A forma de alocação de memória pode ser estática ou dinâmica, depende da linguagem. Esta dica, mostrará como otimizar uma alocação dinâmica de memória para uma matriz na linguagem C.

Pode parecer idiota postar uma dica assim, mas se a velocidade de execução do seu programa importa então você deve otimizar as funções que fazem chamadas de sistema, como alocação de memória, no SO. Imagine por exemplo trabalhar com um vídeo, onde temos que processar 30 imagens por segundo e cada imagem é uma matriz de pixels por exemplo.

Um programa simples de alocação de uma matriz de (mxn) seria assim:

^?View Code C

// assuma que você já leu os valores dos inteiros <strong>m</strong> e <strong>n</strong>
// ALOCAÇÃO DA MEMÓRIA
 
int **matriz = (int**) malloc( m * sizeof ( int* ) );
 
for( int i=0; i&lt;m; i++) {
matriz[i] = (int*) malloc( m * sizeof(int) );
}
 
//LIBERAÇÃO DA MEMÓRIA
for( int i=0; i&lt;m; i++) {
free(matriz[i]);
}
 
free(matriz);

Isso não é muito eficiente!

Se pudermos eliminar algumas chamadas de sistema (free e malloc) e o laço (for), ganharemos um pouco de desempenho. Para isso, que tal alocarmos apenas 2 vezes e liberamos também apenas 2 vezes?

^?View Code C

// ALOCAÇÃO DA MEMÓRIA
 
int *buffer = (int*) malloc( m * n * sizeof( int ) );
 
int **matriz = (int**) malloc( m * sizeof( int* ) );
 
for( int i=0; i&lt;m; i++) {
matriz[i] = &amp;buffer[ i * m ];
}
 
//LIBERAÇÃO DA MEMÓRIA
 
free(buffer);
 
free(matriz);

Você pode achar que estamos gastando memória a mais, mas se você reparar bem, estamos usando apenas um ponteiro a mais.

Arquivo para o ‘Programação’ Categoria

Criando Plugins no WordPress: O Básico

Funções para Manipulação de variáveis

Dicas de Otimização: Alocação dinâmica de memória para uma Matriz

Menu Principal

Tags