O PHPMailer 6 foi lançado no final de agosto de 2017, trazendo inúmeras novidades e melhorias em relação à versão 5.

Neste artigo eu ensinei como utilizar essa biblioteca. Mas, com a nova versão 6, algumas coisas mudaram.

Vamos falar sobre elas neste artigo. Também vou apresentar um guia passo-a-passo sobre como migrar do PHPMailer 5 para a nova versão 6.

O PHPMailer 6 é uma versão que trouxe diversas melhorias e atualizações. A principal mudança está na forma de carregar a classe PHPMailer, que quebra a retrocompatibilidade com a versão anterior.

Porém, com poucas modificações, você consegue fazer a portabilidade dos seus scripts para usar o novo PHPMailer 6.

Principais mudanças do PHPMailer 6

Essa nova versão deixou de usar o arquivo PHPMailerAutoload.php. Agora a classe está em um namespace próprio e segue o padrão PSR-4, podendo ser carregada pelo Composer.

Além disso, não possui mais os arquivos class.phpmailer.php, class.smtp.php e class.pop3.php, que alguns programadores carregavam manualmente via include/require.

A lista completa de mudanças pode ser vista no Changelog do PHPMailer 6.0.

Instalando o PHPMailer 6

A melhor forma de instalar dependências no PHP é usando o Composer. Se você ainda não conhece o Composer, sugiro que leia este meu artigo e comece a usá-lo! Seu trabalho ficará muito mais fácil e rápido!

Para instalar o PHPMailer usando o Composer, execute este comando:

composer require phpmailer/phpmailer

Envio de Email com SMTP Autenticado usando o PHPMailer 6

Feita a instalação do PHPMailer, podemos fazer nosso primeiro envio de email.

Vou utilizar o Mailtrap como SMTP. Você pode utilizar qualquer outro, inclusive o Gmail. Apenas lembre-se de que, ao usar o Gmail, você precisa permitir o acesso de apps menos seguros à sua conta.

Vamos ao script.

<?php

// inclui as classes do PHPMailer
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

// inclui o autoloader do Composer
require 'vendor/autoload.php';

// inicia a classe PHPMailer habilitando o disparo de exceções
$mail = new PHPMailer(true);
try
{
    // habilita o debug
    // 0 = em mensagens de debug
    // 1 = mensagens do cliente SMTP
    // 2 = mensagens do cliente e do servidor SMTP
    // 3 = igual o 2, incluindo detalhes da conexão
    // 4 = igual o 3, inlcuindo mensagens de debug baixo-nível
    $mail->SMTPDebug = 2;
    
    // utilizar SMTP
    $mail->isSMTP();

    // habilita autenticação SMTP
    $mail->SMTPAuth = true;

    // servidor SMTP
    $mail->Host = 'smtp.mailtrap.io'; 

    // usuário, senha e porta do SMTP
    $mail->Username = 'username';
    $mail->Password = 'senha';
    $mail->Port = 465;
    
    // tipo de criptografia: "tls" ou "ssl"
    $mail->SMTPSecure = 'tls';
    
    // email e nome do remetente
    $mail->setFrom('beraldo@ultimatephp.com.br', 'Beraldo');
    
    // Email e nome do(s) destinatário(s)
    // você pode chamar addAddress quantas vezes quiser, para
    // incluir diversos destinatários
    $mail->addAddress('destinatario1@site.com', 'Destinatário 1');
    $mail->addAddress('destinatario2@site.com', 'Destinatário 2');
    
    // endereço que receberá as respostas
    $mail->addReplyTo('contato@ultimatephp.com.br', 'ULTIMATE PHP'); 
    
    // com cópia (CC) e com cópia oculta (BCC)
    $mail->addCC('copia@site.com');
    $mail->addBCC('copia_oculta@site.com');
    
    // anexa um arquivo
    $mail->addAttachment('composer.json');

    // define o formato como HTML
    $mail->isHTML(true);
    
    // codificação UTF-8
    $mail->Charset = 'UTF-8';
    
    // assunto do email
    $mail->Subject = 'Testando o PHPMailer 6';
    
    // corpo do email em HTML
    $mail->Body    = '
<h1>Testando o <em>PHPMailer 6</em></h1>

';
    
    // corpo do email em texto
    $mail->AltBody = 'Testando o PHPMailer 6';
    
    // envia o email
    $mail->send();
    
    echo 'Mensagem enviada com sucesso!' . PHP_EOL;
}
catch (Exception $e)
{
    echo 'Falha ao enviar email.' . PHP_EOL;
    echo 'Erro: ' . $mail->ErrorInfo . PHP_EOL;
}

De modo geral, o script é bem semelhante ao que apresentei no meu antigo post sobre PHPMailer (versão 5).

A principal diferença é a forma de carregar a classe principal, que agora segue o padrão PSR-4 e pode ser carregada pelo autoloader do Composer, o que facilita e organiza muito o nosso trabalho.

Atualizando a versão do PHPMailer no Composer

Caso você já utilize o PHPMailer 5, você não precisa mudar completamente seus scripts. Existe uma forma simples de atualizar para a versão 6.

Basta mudar a versão do pacote no composer.json e modificar a maneira como instanciamos a classe PHPMailer, seguindo o novo padrão.

Eu escrevi um guia gratuito passo-a-passo onde mostro exatamente como fazer a migração de forma simples e rápida.

Também mostro mais detalhes sobre o PHPMailer 6, explicando as principais mudanças e detalhando melhor o código.

Clique aqui e baixe gratuitamente o meu guia sobre o novo PHPMailer 6

Guia Grátis de Atualização Passo-a-Passo

Aprenda passo-a-passo como migrar de PHPMailer 5 para o PHPMailer 6

Novidades e mudanças da nova versão do PHPMailer

Baixe gratuitamente este guia e não fique com scripts obsoletos!

O post PHPMailer 6: Novidades e guia de migração passo-a-passo apareceu primeiro em Blog do Beraldo.

Hoje o recado é curto, mas muito importante!

Até preferi gravar um vídeo rápido, pra explicar melhor. Só não liguem a má qualidade. Vídeos não são meu forte. :P

A ideia é simples: se quiser trabalhar com Programação e se destacar da maioria, não tenha preguiça de ler!

É importante ler documentações manuais, referências… tudo isso ajuda a absorver conhecimentos, fazer as devidas ligações entre temas aparentemente distintos…

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post Não Tenha Preguiça de Ler! apareceu primeiro em Blog do Beraldo.

Atualizar para MySQLi não é apenas colocar um “i” a mais nas chamadas de funções como mysql_connect ou mysql_query, como muitos dizem.

Porém também não é nada muito complicado. Você apenas precisa tomar cuidado com os parâmetros de cada função.

Neste artigo vou mostrar como atualizar seus scripts PHP de MySQL para MySQLi.

O Motivo

Como eu comentei neste artigo, a biblioteca mysql está obsoleta.

Isso significa que você não deve usar funções como mysql_connect, mysql_query e semelhantes.

Em vez delas, você deve usar mysqli_connect e mysqli_query

Porém a diferença não está apenas no “i” a mais no nome da função. A lista de parâmetros geralmente também é um pouco diferente, por isso precisamos estar atentos a isso.

MySQLi ou PDO?

Particularmente, recomendo e prefiro PDO. Mas há um pequeno problema…

PDO requer um pouco de conhecimento sobre Orientação a Objetos (OOP). E eu sei que muitos iniciantes têm bastante dificuldade com isso.

Por isso vou mostrar aqui como usar mysqli da forma procedural, ou seja, como usá-lo com chamadas a funções, em vez de usar a classe mysqli e seus métodos e propriedades.

Por Que Não É Tão Simples Como Dizem

Tem muita gente por aí dizendo que é só colocar o “i” nas chamadas das funções e pronto.

Não é bem assim.

Várias funções do MySQLi possuem parâmetros a mais, ordem diferente etc.

As funções mysql_* não exigiam o parâmetro de identificação da conexão (valor retornado por mysql_connect). Elas sempre buscavam uma conexão ativa.

Com mysqli a coisa é diferente…

É fundamental informar o identificador da conexão.

Dessa forma, podemos ter diversas conexões no mesmo script, sem risco de conflitos ou funcionamento inesperado.

Esse é só um dos exemplos.

Veremos isso com mais detalhes, na prática, logo logo.

Banco de Dados de Exemplo

Vamos criar um simples banco de dados para nossos testes.

CREATE TABLE funcionarios(
    id INT UNSIGNED NOT NULL AUTO_INCREMENT,
    nome VARCHAR(50) NOT NULL,
    email VARCHAR(80) NOT NULL,
    salario DECIMAL(10,2) NOT NULL,
    nascimento DATE NOT NULL,
    PRIMARY KEY (id)
) COLLATE=utf8_unicode_ci;

Vamos inserir alguns dados:

INSERT INTO funcionarios(nome, email, salario, nascimento) VALUES
('Ana', 'ana@ana.com', 1400.00, '1993-10-16'),
('Daniela', 'dani@dani.com', 1380.50, '1996-05-15'),
('João', 'joao@joao.com', 1400.00, '1995-11-10'),
('Julia', 'julia@julia.com', 1200.95, '1997-03-22'),
('Sabrina', 'sabrina@sabrina.com', 1800.57, '1990-12-03'),
('Paulo', 'paulo@paulo.com', 1750.43, '1991-06-25');

Exibindo os Dados Usando MySQL

Vamos criar um simples script para exibir todos os dados, usando funções mysql_*.

// dados de conexão
$host = 'localhost';
$user = 'usuario';
$pass = 'senha';
$db   = 'nome_do_banco';

// conecta com o banco de dados
$con = mysql_connect($host, $user, $pass);

// seleciona o banco de dados
mysql_select_db($db);

// efetua a consulta
$sql = "SELECT * FROM funcionarios ORDER BY nome";
$res = mysql_query($sql);

// total de resultados
$total = mysql_num_rows($res);

echo "Total de Resultados: " . $total . "
";

// loop pelos resultados

while ($f = mysql_fetch_array($res))
{
    echo $f['nome'] . " | " . $f['email'] . " | " . $f['salario'] . " | " . date('d/m/Y', strtotime($f['nascimento'])) . "
";
}

// fecha a conexão
mysql_close();

O script é super simples. Apenas um SELECT que lista os registros da tabela, junto ao número total de registros.

Exibindo os Dados Usando MySQLi

Vamos ver agora como rescrever o script anterior usando MySQLi.

Vou colocar o código aqui e falo sobre os principais detalhes logo em seguida.

$host = 'localhost';
$user = 'usuario';
$pass = 'senha';
$db   = 'nome_do_banco';

// conexão e seleção do banco de dados
$con = mysqlI_connect($host, $user, $pass, $db);

// executa a consulta
$sql = "SELECT * FROM funcionarios ORDER BY nome";
$res = mysqli_query($con, $sql);

// conta o número de registros
$total = mysqli_num_rows($res);

echo "Total de Resultados: " . $total . "
";

// loop pelos registros
while ($f = mysqli_fetch_array($res))
{
    echo $f['nome'] . " | " . $f['email'] . " | " . $f['salario'] . " | " . date('d/m/Y', strtotime($f['nascimento'])) . "
";
}

// fecha a conexão
mysqli_close($con);

Podemos notar três diferenças principais:

1. mysqli_connect permite conectar ao MySQL e já selecionar o banco de dados. Nem é necessário usar a função mysqli_select_db;
2. O primeiro parâmetro de mysqli_query não é a consulta SQL, como era com mysql_query. Agora é necessário passar o identificador da conexão (retornado por mysqli_connect) e, depois, a string com a consulta SQL;
3. mysqli_close exige o parâmetro que identifica a conexão. Por outro lado, para mysql_close ele era opcional.

Como você pode ver, só colocar o “i” não resolve 100%. Algumas pequenas modificações ainda são necessárias.

As Listas de Parâmetros

Percebeu que existem algumas diferenças nesses scripts simples?

Essas diferenças aumentam um pouco, caso você esteja usando outras funções, como mysql_affected_rows, mysql_real_escape_string e algumas outras.

Recomendo que você olhe a documentação de cada uma delas e preste atenção à lista de parâmetros de cada uma.

Veja qual é a ordem deles, quais são obrigatórios ou não.

Vou deixar aqui os links para as documentações:

• Lista de Funções MySQL
• Lista de Funções MySQLi

Só pra você entender melhor, parâmetros entre colchetes são opcionais. resource é o tipo do retorno de mysql_connect e mysql_query. mysqli é o identificador da conexão, retornado por mysqli_connect e mysqli_result é o retorno de mysqli_query.

Com isso você entende melhor quais são os parâmetros que cada função exige.

Aprenda Com Mais Detalhes

Aqui eu mostrei a ideia geral, mostrando o básico sobre a migração.

Escrevi um guia completo sobre como atualizar de MySQL para MySQLi.

No guia eu entro em mais detalhes, mostro uma tabela comparativa entre cada umas das funções mysql e suas correspondentes no mysqli.

Também mostro como usar MySQLi Orientado a Objetos, para você economizar linhas de código, facilitando o trabalho.

O guia é 100% Gratuito!

CLIQUE AQUI Para Baixar o Guia Gratuitamente

Curso Completo de MySQLi

Se você procura um curso completo sobre MySQLi, abordando os principais comandos (CREATE TABLE, INSERT INTO, UPDATE, SELECT etc), clique aqui e aproveite a promoção especial do Curso de MySQLi.

Você vai aprender a realizar as principais operações com bancos de dados, de forma simples, organizada e otimizada.

Clique aqui e conheça o Curso de MySQLi

Guia Completo Passo-a-Passo

Aprenda passo-a-passo como migrar de MySQL para MySQLi

Equivalência entre funções com exemplos práticos de uso!

Baixe gratuitamente este guia e não fique com scripts obsoletos!

O post Como Atualizar Scripts PHP de MySQL Para MySQLi apareceu primeiro em Blog do Beraldo.

A partir do PHP 5.5, a biblioteca MySQL, do PHP, com funções como mysql_connect e mysql_query é considerada obsoleta. Falei sobre isso neste post. A alternativa mais recomendada é usar a extensão PDO.

Porém muitos programadores ainda não sabem como usar PDO. Vou mostrar neste post como é simples usar essa classe.

É muito importante usar PDO, por duas razões em especial:

1. Seu código fica mais limpo e moderno
2. É fácil migrar para outro SGBD, caso seja necessário futurament

Mas, se você leu este meu post, já deve saber disso.

O que é PDO

PDO significa PHP Data Objects (Objetos de Dados do PHP, em tradução livre). Ela é uma classe para gerenciar conexões com bancos de dados. Sim, bancos de dados. Ou seja, é possível usar PDO para conectar com diversos SGBDs, dentre eles MySQL, PostreSQL, SQLite, MS SQL Server, Oracle e outros.

PDO é Orientado a Objetos

PDO é uma classe. Ela segue o padrão da Orientação a Objetos. Caso você não conheça absoluutamente nada sobre Orientação a Objetos, recomendo estudar um pouco sobre isso antes de usar PDO.

Não precisa ir muito a fundo. Apenas entenda o que são classes, objetos e métodos. Veja como instanciar objetos e chamar seus métodos. Isso já é suficiente para trabalhar com PDO.

Recomendo ler estes links:

• Exemplo prático de Orientação a Objetos (php), diferenças e vantagens em relação à um código Estruturado
• Introdução à Orientação a Objetos em PHP

Tabela usada para este tutorial

Criei uma tabela chamada “programadores”, com ID, nome e site de cada um deles. Utilizei a seguinte SQL para gerar a tabela e seus dados

CREATE TABLE programadores(
    id int unsigned not null auto_increment,
    nome varchar(80) not null,
    site varchar(120) default null,
    PRIMARY KEY(id)
);

INSERT INTO programadores(nome, site) VALUES
('Beraldo', 'http://rberaldo.com.br'),
('João', NULL),
('Maria', 'http://mariaprogramadora.com.br'),
('José', 'http://joseprogramador.com.br'),
('Linus Torvalds', 'http://kernel.org'),
('Mark Zuckerberg', 'http://facebook.com'),
('Steve Wozniak', 'http://apple.com');

Conexão com MySQL usando PDO

Vamos definir constantes para armazenar os dados de conexão.

define( 'MYSQL_HOST', 'localhost' );
define( 'MYSQL_USER', 'root' );
define( 'MYSQL_PASSWORD', '' );
define( 'MYSQL_DB_NAME', 'pdo_tutorial' );

A conexão é feita pelo construtor da classe PDO. Ou seja, basta passarmos os dados de conexão como parâmetro, ao instanciarmos a classe PDO, desta forma:

$PDO = new PDO( 'mysql:host=' . MYSQL_HOST . ';dbname=' . MYSQL_DB_NAME, MYSQL_USER, MYSQL_PASSWORD );

Isso funciona. Mas, caso a conexão falhe, será disparada uma exceção e a execução será interrompida.

Para evitarmos isso, devemos colcoar esse trecho em um bloco try...catch e tratar a exceção PDOException. O código ficará assim:

try
{
    $PDO = new PDO( 'mysql:host=' . MYSQL_HOST . ';dbname=' . MYSQL_DB_NAME, MYSQL_USER, MYSQL_PASSWORD );
}
catch ( PDOException $e )
{
    echo 'Erro ao conectar com o MySQL: ' . $e->getMessage();
}

Definindo a Codificação UTF-8

Para definir a codificação UTF-8 (ou outra codificação, caso você ainda não esteja usando UTF-8), basta executar a query abaixo logo após abrir a conexão:

$PDO->exec("set names utf8");

Executando SELECT com PDO

Tendo a instância da classe PDO na variável $PDO, podemos realizar um simples SELECT desta forma:

$sql = "SELECT * FROM programadores";
$result = $PDO->query( $sql );
$rows = $result->fetchAll();

print_r( $rows );

O método query da classe PDO executa uma consulta e retorna, no caso do SELECT, um objeto do tipo PDOStatement. Esse objeto possui o método fetchAll, que é semelhante à função mysql_fetch_array, retornando um array com todos os registros. Usamos a função print_r para exibir esse array. A saída é a seguinte:

Array
(
    [0] => Array
        (
            [id] => 1
            [0] => 1
            [nome] => Beraldo
            [1] => Beraldo
            [site] => http://rberaldo.com.br
            [2] => http://rberaldo.com.br
        )

    [1] => Array
        (
            [id] => 2
            [0] => 2
            [nome] => João
            [1] => João
            [site] => 
            [2] => 
        )

    [2] => Array
        (
            [id] => 3
            [0] => 3
            [nome] => Maria
            [1] => Maria
            [site] => http://mariaprogramadora.com.br
            [2] => http://mariaprogramadora.com.br
        )

    [3] => Array
        (
            [id] => 4
            [0] => 4
            [nome] => José
            [1] => José
            [site] => http://joseprogramador.com.br
            [2] => http://joseprogramador.com.br
        )

    [4] => Array
        (
            [id] => 5
            [0] => 5
            [nome] => Linus Torvalds
            [1] => Linus Torvalds
            [site] => http://kernel.org
            [2] => http://kernel.org
        )

    [5] => Array
        (
            [id] => 6
            [0] => 6
            [nome] => Mark Zuckerberg
            [1] => Mark Zuckerberg
            [site] => http://facebook.com
            [2] => http://facebook.com
        )

    [6] => Array
        (
            [id] => 7
            [0] => 7
            [nome] => Steve Wozniak
            [1] => Steve Wozniak
            [site] => http://apple.com
            [2] => http://apple.com
        )

)

Note que, para cada registro, há valores repetidos. Eles aparecem em dois índices: um é o número do campo na tabela e o outro é o nom do campo. Isso ocupa o dobro da memória. Por isso é recomendado retornar apenas o registro com o nome do campo.

Para isso, basta passarmos o parâmetro PDO::FETCH_ASSOC para o método fetchAll. Dessa forma, esse método funcionará de forma semelhante à função mysql_fetch_assoc retornando apenas o array associativo com os nomes dos campos.

Vamos alterar apenas a linha que chama o método fetchAll. Ela ficará assim:

$rows = $result->fetchAll( PDO::FETCH_ASSOC );

O array exibido será este:

Array
(
    [0] => Array
        (
            [id] => 1
            [nome] => Beraldo
            [site] => http://rberaldo.com.br
        )

    [1] => Array
        (
            [id] => 2
            [nome] => João
            [site] => 
        )

    [2] => Array
        (
            [id] => 3
            [nome] => Maria
            [site] => http://mariaprogramadora.com.br
        )

    [3] => Array
        (
            [id] => 4
            [nome] => José
            [site] => http://joseprogramador.com.br
        )

    [4] => Array
        (
            [id] => 5
            [nome] => Linus Torvalds
            [site] => http://kernel.org
        )

    [5] => Array
        (
            [id] => 6
            [nome] => Mark Zuckerberg
            [site] => http://facebook.com
        )

    [6] => Array
        (
            [id] => 7
            [nome] => Steve Wozniak
            [site] => http://apple.com
        )

)

Filtrando consultas

Geralmente, nossos SELECTs possuem a cláusula WHERE, para filtrar os resultados.

Isso é muito fáicl de fazer usando PDO.

Vamos considerar a situação seguinte: vamos solicitar, por meio de um formulário, que o usuário defina uma string para usar no filtro do SELECT. A filtragem será feita pelo campo site da nossa tabela.

$search = $_GET['search'];
$sql = "SELECT * FROM programadores WHERE site LIKE '%" . $search . "%'";
$result = $PDO->query( $sql );
$rows = $result->fetchAll( PDO::FETCH_ASSOC );

Vamos supor que o usuário digitou a palavra “programador”. Logo, $_GET['search'] será a string “programador”.

O array $rows será este:

Array
(
    [0] => Array
        (
            [id] => 3
            [nome] => Maria
            [site] => http://mariaprogramadora.com.br
        )

    [1] => Array
        (
            [id] => 4
            [nome] => José
            [site] => http://joseprogramador.com.br
        )

)

Mas existe uma forma mais eficiente e segura de passar parâmetros para as consultas: usando Prepared Statements.

O que são Prepared Statements e como usá-los

Prepared Statements são úteis para executar uma mesma consulta diversas vezes, com parâmetros distintos, de forma eficiente.

Porém também há outra utilidade: filtragem nativa de consultas, a fim de evitar SQL Injection. Isso dá mais segurança ao seu sistema.

Nesse tipo de consulta, os parâmetros não são enviados diretamente na consulta. Eles são enviados em um “pacote” separado ao servidor MySQL. O servidor, por sua vez, é quem faz a associação entre string SQL e parâmetros.

Em outras palavras, não vamos colocar a variável $search diretamente na consulta.

Nosso código, usando Prepared Statements, ficará assim:

$search = $_GET['search'];
$search = '%' . $search . '%';
$sql = "SELECT * FROM programadores WHERE site LIKE :search";
$stmt = $PDO->prepare( $sql );
$stmt->bindParam( ':search', $search );
$result = $stmt->execute();

Veja que nossa query agora possui apenas o valor “:search” na cláusula WHERE. É assim que a consulta chegará para o MySQL. Com o método bindParam nós dizemos que queremos enviar o valor de $search, que será substituído em :search.

Como estamos usando o LIKE, tivemos que adicionar os sinais de percentual (%), na segunda linha, manualmente. Se estivéssemos buscando por strings exatas (com o operador =), não precisaríamos disso.

O array $row será o mesmo do código anterior.

Usando Prepared Statements, seu código estará muito mais seguro.

E é possível definir o tipo do dado, passando o terceiro parâmetro de bindParam. Os valores possíveis são:

• PDO::PARAM_BOOL
• PDO::PARAM_NULL
• PDO::PARAM_INT
• PDO::PARAM_STR (esse é o valor padrão)
• PDO::PARAM_LOB

Esses parâmetros dizem para o MySQL como cada valor deve ser tratado.

Por exemplo, strings devem receber aspas simples ao seu redor. Por outro lado, inteiros não. Por isso é importante passar esses parâmetros, quando o valor não for string.

INSERT, DELETE e UPDATE usando PDO

Esses três comandos serão tratados de forma semelhante.

Vejamos como fazer um INSERT.

$nome = 'Bill Gates';
$site = 'http://microsoft.com';
$sql = "INSERT INTO programadores(nome, site) VALUES(:nome, :site)";
$stmt = $PDO->prepare( $sql );
$stmt->bindParam( ':nome', $nome );
$stmt->bindParam( ':site', $site );

$result = $stmt->execute();

if ( ! $result )
{
    var_dump( $stmt->errorInfo() );
    exit;
}

echo $stmt->rowCount() . "linhas inseridas";

Vamos considerar que $none e site vêm de um formulário também. Por isso precisamos filtrar esses valores usando Prepared Statements.

Para o UPDATE, vamos considerar que desejamos alterar o valor de site para o nome “Bill Gates”. O código é o seguinte:

$nome = 'Bill Gates';
$site = 'http://ruindows.com.br';
$sql = "UPDATE programadores set site = :site WHERE nome = :nome";
$stmt = $PDO->prepare( $sql );
$stmt->bindParam( ':nome', $nome );
$stmt->bindParam( ':site', $site );

$result = $stmt->execute();

if ( ! $result )
{
    var_dump( $stmt->errorInfo() );
    exit;
}

echo $stmt->rowCount() . "linhas alteradas";

Já o DELETE ficará assim:

$nome = 'Bill Gates';
$sql = "DELETE FROM programadores WHERE nome = :nome";
$stmt = $PDO->prepare( $sql );
$stmt->bindParam( ':nome', $nome );

$result = $stmt->execute();

if ( ! $result )
{
    var_dump( $stmt->errorInfo() );
    exit;
}

echo $stmt->rowCount() . "linhas removidas";

Conclusão

Espero que tenha achado útil este tutorial. Há muitos outros recursos da extensão PDO. Você pode ler todos eles na Documentação Oficial da Extensão PDO.

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post Como usar PDO com banco de dados MySQL apareceu primeiro em Blog do Beraldo.

Você viu esta mensagem de erro?

PHP Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead

Aí você me pergunta…

MySQL obsoleto? Então não posso mais usá-lo?

Não é bem assim. Estamos falando apenas da extensão mysql. E eu vou te mostrar aqui exatamente o que fazer para resolver esse problema e evitar que seus scripts parem de funcionar com o PHP 7 (previsto para ser lançado até meados de dezembro de 2015).

O SGBD MySQL é um dos mais utilizados com a linguagem PHP. Grande parte dos sistemas populares feitos em PHP utilizam (ou pelo menos suportam) o SGBD MySQL.

Assim como o PHP, o MySQL também evolui bastante e ganhou novas funcionalidades nos úlitmos anos. Isso fez com que a equipe do PHP desenvolvesse uma nova biblioteca para trabalhar com essas novidades de forma mais efetiva. Essa nova biblioteca foi chamada de MySQLi (o “i” do final refere-se a “improved“, que significa “melhorada”).

MySQL obsoleto Vs Extensão MySQL Obsoleta

O MySQL é o SGBD em si. Não é dele exatamente que estou falando. Estou falando da extensão mysql (ou biblioteca mysql) do PHP.

A bibliteca MySQL, que conta com funções como mysql_connect, mysql_query e semelhantes, não permite utilizar recursos novos do MySQL, como triggers, stored procedures e outros. Esses recursos só estão disponíveis com o uso da biblioteca MySQLi.

A extensão MySQLi existe desde o PHP 5.0, que foi lançado em 13 de julho 2004. Desde então, já era recomendado usar MySQLi em vez de MySQL.

Porém muitos programadores continuaram usando, ainda usam até hoje, a biblioteca MySQL.

Para mudar esse cenário, a equipe do PHP tomou uma atitude um tanto drástica: removeram a biblioteca MySQL do PHP 7.

Mas calma! Não entre em desespero!

Extensão MySQL obsoleta

A partir do PHP 5.5, a biblioteca MySQL é considerada obsoleta, mas ainda funciona. Porém, é recomendado não utilizá-la mais, pois já foi removida do PHP 7, que deve ser lançada até o final de 2015.

Isso Foi Uma Atitude Drástica?

Muitos acham um absurdo a equipe do PHP ter ternado a biblioteca MySQL obsoleta no PHP 5.5. Mas vamos analisar melhor.

Como eu disse antes, a extensão MySQLi foi lançada junto com o PHP 5.0, em 13 de julho 2004. Desde então, a comunidade do PHP sugere utilizar essa biblioteca em vez do MySQL.

Poucos programadores aderiram à ideia.

Conclusão da equipe do PHP: vamos forçá-los a migrar para o MySQLi.

A versão 5.5.0 foi lançada em 20 de junho 2013, ou seja, NOVE ANOS após a publicação do PHP 5.0 e as recomendações do uso do MySQLi.

Estamos em 2015 (quando escrevo este artigo) e ainda tem gente usando MySQL.

Já se passaram ONZE ANOS! Por todo esse tempo a comunidade do PHP sugere usar MySQLi.

Ou seja, não acho nada drástica a iniciativa de tornar o MySQL obsoleto. Afinal, muitos só se mexem quando “a água bate na bunda”.

Então deixe a preguiça de lado e migre suas aplicações para MySQLi ou PDO agora mesmo!

E o que devo fazer, Beraldo??!!

[cta id=’1571′]

Alternativas à extensão MySQL

1. Usar a extensão MySQLi em vez da MySQL
2. Usar a extensão PDO (PHP Data Object)

E qual devo escolher, Beraldo?

A extendão MySQLi lhe dará tudo o que você já tem hoje com a extensão MySQL. Além disso, você terá acesso aos novos recursos do MySQL. Também estará usando uma bilioteca mais recente.

Mas a extensão PDO tem uma grande vantagem.

PDO é uma camada de abstração de banco de dados. O nome assusta, mas é simples: ela é um interface genérica para diveroso SGBDs. Ou seja, seu código escrito com PDO funcionará com MySQL, PostgreSQL, SQLite e diversos outros SGBDs.

A vantagem disso é que, se um dia precisar trocar o SGBD, terá de fazer pouquíssimas alterações no código.

Nunca se sabe o dia de amanhã. Talvez sua aplicação cresça muito e precise trocar o SGBD. Então, se o PHP já nos dá esse recurso de brinde, vale a pena utilizá-lo! :)

Veja aqui um tutorial sobre como usar PDO com MySQL.

Mas eu sei que muitos iniciantes têm dificuldade com Orientação a Objetos e por isso acham PDO difícil. Por isso eu criei este artigo, onde mostro como usar MySQLi sem precisar usar Orientação a Objetos.

Outras Novidades do PHP 7

O PHP 7 deve ser lançado oficialmente até o final de 2015. Mas a versão RC está disponível desde o final de agosto.

Então já podemos ter uma ideia do que está por vir.

Além do fim do MySQL, há diversas outras ótimas novidades, como sua incrível velocidade, sendo até NOVE vezes mais rápido que o PHP 5.6.

Para aprender todas as novidades, inscreva-se no meu curso 100% GRATUITO sobre o PHP 7.

CLIQUE AQUI Para Se Inscrever No Meu Curso Gratuito Sobre o PHP 7

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post MySQL obsoleto? Entenda Exatamente o Que Fazer apareceu primeiro em Blog do Beraldo.

O PHP 7 (sucessor do PHP 5.6) se demonstra muito mais rápido que suas versões anteriores. Em alguns casos, pode ser até 9 vezes (NOVE!!) mais rápido!

Veja aqui os resultados do testes que fiz comparando o PHP 5.6 e o PHP 7. Você vai se surpreender!

E também tenho uma surpresa, que vou revelar no final do artigo. Mas não vale ir direto pra lá, heim?! :P

O PHP 7

O PHP 7 é o sucessor do PHP 5. Não existiu versão pública do PHP 6 por alguns motivos.

Houve um PHP 6. Ou pelo menos uma tentativa dele. Porém o resultado não foi satisfatório e a versão não foi publicada oficialmente, mas existiram informações sobre essa versão. Logo poderia haver confusão se esta nova versão se chamasse PHP 6.

Outro motivo é que tinha muito charlatão por aí vendendo livros, cursos e aulas sobre o PHP 6, que nem sequer existia oficialmente.

Então, para evitar esses problemas, a equipe do PHP resolveu chamar a nova versão de PHP 7.

Se quiser ler os diversos motivos dessa escolha, leia o RFC oficial sobre a discussão sobre o nome da versão do PHP.

A versão Release Candidate (RC) do PHP 7 foi lançada no dia 21 de agosto. Por ser uma versão RC, é bem provável que haja pouquíssimas mudanças até a versão final. Apenas algumas correções de bugs.

Isso quer dizer que os resultados que obtivermos agora serão bem próximos (ou até iguais) aos que teremos com a versão final.

Critério de Comparação

Para comparar o desempenho, utilizei o script de benchmark que o próprio PHP traz. No código-fonte do PHP no GitHub, encontramos o arquivo Zend/bench.php, que é o script responsável por analisar o desempenho, executando algumas rotinas comuns.

Esse é o script que utilizarei para analisar o desempenho das versões do PHP.

Ao executar o script, você verá uma lista de execuções e seus respectivos tempos. No final, será exibido o tempo total. É esse tempo total que nos interessa aqui.

Veja um exemplo da execução:

php Zend/bench.php 
simple             0.395
simplecall         0.954
simpleucall        1.063
simpleudcall       1.073
mandel             1.027
mandel2            1.072
ackermann(7)       0.821
ary(50000)         0.041
ary2(50000)        0.029
ary3(2000)         0.563
fibo(30)           2.911
hash1(50000)       0.145
hash2(500)         0.049
heapsort(20000)    0.265
matrix(20)         0.245
nestedloop(12)     0.703
sieve(30)          0.244
strcat(200000)     0.035
------------------------
Total             11.635

Como o tempo de execução pode variar um pouco, o correto é executar algumas vezes e fazer a média.

Vou executar o script 15 vezes com cada versão do PHP.

Script Utilizado

Para agilizar a tarefa de executar 15 vezes e fazer a média, vou usar um pequeno Shell Script. Basicamente um loop e alguns echo’s. Vou dividir o comando em linhas para facilitar a visualização:

soma=0; \
for ((i = 0; i < 15; i++)) ; \
do \
    tempo=$(php Zend/bench.php | tail -n 1 | awk '{print $2}'); \
    echo "Tempo $i: $tempo"; \
    soma=$(echo "$soma + $tempo" | bc -l); \
done ; \
echo "Tempo total: $soma"; \
media=$(echo "scale=3; $soma / $i" | bc -l); \
echo "Tempo médio: $media"

O script Zend/bench.php será executado no próprio terminal. Caso você nunca tenha visto isso antes, recomendo ler este meu artigo, onde mostro as diferentes formas de execução do PHP.

Caso você queira entender melhor como os scripts Shell funcionam, veja este meu mini-curso gratuito de Shell Script.

Plataforma

Fiz os testes na seguinte plataforma:

• Processador: Intel Core i7 2,6 GHz
• Memória: 16 GB DDR3 1600 MHz
• Sistema operacional: Mac OS X 10.10.4 (Yosemite)

As versões do PHP usadas foram 5.6.12 e 7.0RC1.

Resultados

Na tabela abaixo mostro os resultados das 15 execuções e o tempo médio para cada versão do PHP.

Para visualizar melhor as diferenças de tempo, montei estes dois gráficos

Se dividirmos o tempo médio do PHP 5.6 pelo tempo médio do PHP 7, teremos:

11.822 / 1.239 = 9.541

Ou seja, o PHP 7 se saiu NOVE VEZES MAIS RÁPIDO!

Logicamente, esse número pode variar conforma o hardware e conforme a tarefa executada. Neste caso, analisei somente o benchmark sugerido pelo próprio PHP.

Conclusão

O PHP 7 é, de fato, muito mais rápido que o PHP 5.

Resta analisar em casos reais, como em frameworks, CMS etc. Mas apenas com esse teste já vemos que ele tem desempenho bem superior em relação às versões anteriores

Quer Aprender Mais Sobre o PHP 7?

Para aprender todas as novidades do PHP 7 e todos os fundamentos essenciais da linguagem, o Curso ULTIMATE PHP foi totalmente reformulado e atualizado. O resultado foi o ULTIMATE PHP 2.0, o primeiro curso do Brasil a abordar o PHP 7, logo em dezembro de 2015, quando a versão final do PHP 7 foi lançada.

No curso, você aprenderá desde o básico do PHP, vendo todos os conceitos e fundamentos da linguagem, até conceitos de nível intermediário. Alguns temas mais avançados são abordados, como Orientação a Objetos e Segurança.

Clique Aqui e Conheça o Curso ULTIMATE PHP

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post PHP 7: Até 9 Vezes Mais Rápido Que o PHP 5.6 apareceu primeiro em Blog do Beraldo.

Onde você armazena as configurações sensíveis do seu projeto PHP? Se as define diretamente em seu código, você pode estar correndo um enorme risco de Segurança.

Configurações como nomes de usuário de banco de dados, senhas de SMTP e outras informações sensíveis devem ficar em um local seguro. E o mais importante: fora do controle de versão do software (como Git, SVN e outros).

Neste artigo vou mostrar como utilizar o DotEnv de forma extremamente. Com duas linhas de código, todas as configurações importantes de seu projeto estarão disponíveis em variáveis de ambiente.

Essa é a ideia do projeto DotEnv. As configurações sensíveis ficam armazenadas em um arquivo chamado .env (o ponto caracteriza um arquivo oculto em sistemas Unix-Like).

Todas as variáveis definidas no .env são automaticamente carregadas para variáveis de ambiente. Ou seja, para buscar seus valores, podemos usar a função getenv() ou o array $_ENV.

Instalando o DotEnv

Para instalar o DotEnv, vou utilizar o Composer. Se você não utiliza Composer, o que está esperando? Veja este meu artigo com o básico do Composer. Se quiser ir mais além e aprender tudo sobre essa maravilhosa ferramenta, conheça o meu curso ULTIMATE COMPOSER.

Abra o terminal/prompt, no diretório-raiz da sua aplicação, e digite este comando:

composer require vlucas/phpdotenv

Depois de alguns segundos, o DotEnv terá sido completamente baixado e você verá esta saída:

Using version ^2.0 for vlucas/phpdotenv
./composer.json has been created
Loading composer repositories with package information
Updating dependencies (including require-dev)
  - Installing vlucas/phpdotenv (v2.0.1)
    Downloading: 100%         

Writing lock file
Generating autoload files

Criando o Arquivo .env

Você precisa criar, no diretório-raiz do projeto, um arquivo chamado .env, que vai armazenar as variáveis. É importante colocar o ponto no começo, pois isso caracteriza um arquivo oculto, assim como é o .htaccess, por exemplo.

No arquivo, basta definir as variáveis com esta sintaxe:

NOME_DA_VARIAVEL=VALOR_DA_VARIAVEL

Esse arquivo segue o mesmo padrão de um arquivo Shell Script. Inclusive, você pode inserir comentários, iniciando a linha com sustenido:

# Explicação sobre a variável
NOME_DA_VARIAVEL=VALOR_DA_VARIAVEL

Se você estiver usando controle de versão (como Git ou SVN), lembre-se de não versionar o arquivo .env, por razões de segurança. Coloque-o no .gitignore para garantir que seja ignorado.

É recomendável criar um arquivo chamado .env.example, com as mesmas variáveis do .env, mas com valores genéricos, apenas de exemplo. Dessa forma é fácil criar o arquivo real a partir do exemplo. Bastaria copiar o .env.example para .env e alterar os valores.

Carregando as Variáveis de Ambiente

Agora que já temos o DotEnv instalado e o arquivo .env criado, precisamos carregar as variáveis do arquivo para variáveis de ambiente.

E isso é extremamente fácil! Apenas duas linhas!

Crie o arquivo index.php com este conteúdo:

load();

Pronto! Todas as variáveis do arquivo .env agora estarão definidas como variáveis de ambiente.

Você pode confirmar isso desta forma:

print_r( $_ENV );

Você verá suas variáveis no array exibido.

Para buscar uma única variável, pode usar o array $_ENV ou a função getenv():

echo $_ENV['NOME_DA_VARIAVEL'];
// ou
echo getenv( 'NOME_DA_VARIAVEL' );

Conclusão

O DotEnv é a forma mais segura de armazenar as configurações sensíveis de seu projeto.

Você pode combinar essa técnica com um conceito de Bootstrapping, que explico neste artigo. Assim você terá um sistema seguro, rápido e confiável.

No meu Curso ULTIMATE PHP, explico diversas outras técnicas e dicas sobre PHP. Ensino desde o básico da linguagem, detalhando toda a teoria essencial, para criar sistemas robustos, confiáveis e seguros. Tudo de forma 100% prática, com exemplos. Clique Aqui e Conheça Melhor o Curso.

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post DotEnv: O Lugar Perfeito Para as Configurações do Seu Projeto PHP apareceu primeiro em Blog do Beraldo.

Você já sofreu criando regras malucas no seu .htaccess pra conseguir criar suas URLs Amigáveis?

Conhece pouco sobre Expressões Regulares e sempre apanha das regras de reescrita?

Já imaginou criar URLs Amigáveis sem essas dores de cabeça, tudo em PHP puro, sem .htaccess, de forma clara e objetiva?

E o melhor: em poucos segundos!

Há uma maneira muito simples de fazer isso. E a solução se chama Slim.

Continue lendo, que você vai ver como criar URLs Amigáveis pode ser uma tarefa ridiculamente simples e rápida.

Hoje eu quero solucionar um GRANDE problema:

Criar URLs Amigáveis Sem .htaccess

Isso é possível, sim. E o melhor: é extremamente simples!

Vamos usar um pequeno framework, chamado Slim.

O Que é o Slim

O Slim é um micro-framework. Ou seja, um conjunto pequeno (porém poderoso) de ferramentas para desenvolver aplicações.

Ele permite fazer diversas outras coisas, não apenas criar URLs Amigáveis, também chamadas de rotas. Dentre os principais recursos do Slim estão:

• Rotas (URLs Amigáveis)
• Gerenciamento de Requisições HTTP
• Gerenciamento de Sessões
• Cache
• Criptografia

O Slim é bem completo e faz várias coisas, porém hoje vou mostrar apenas a parte de Rotas.

Se vocês gostarem da ferramenta e comentarem aqui no post, farei outros artigos mostrando mais recursos do Slim. :)

URLs Amigáveis Usando o Slim

Que tal um desafio?

Vamos criar uma aplicação com URLs Amigáveis do zero em apenas poucos segundos?

Parece loucura? Impossível?

Não é!

Vou mostrar como é simples.

Para criarmos nosso projeto, vamos usar o Composer.

Lembrando que o Composer fica instalado na sua máquina local. Você pode instalá-lo no seu servidor, mas não precisa. Você usará o Composer em sua máquina para baixar o Slim. Depois basta fazer upload de tudo para o servidor (mesmo que o Composer não esteja instalado lá, tudo vai funcionar).

Com o Composer instalado, abra o terminal (prompt de comando, pra quem sofre usando Windows) e digite:

composer require slim/slim

O Composer vai baixar o Slim, além do seu próprio autoloader, que utilizaremos para carregar o Slim em nossa aplicação.

Agora você verá esta estrutura de arquivos

├── composer.json
├── composer.lock
└── vendor
    ├── autoload.php
    ├── composer
    └── slim

Só precisamos criar nosso arquivo index.php. Crie-o com este conteúdo:

 [
        'displayErrorDetails' => true
    ]
]);


/* ============
   Rotas da aplicação
   ============ */


$app->get('/', function ()
{
    echo "Página inicial";
});

$app->get('/contato', function ()
{
    echo "Fale conosco";
});

$app->run();

Pronto!

Agora basta iniciar o servidor do PHP:

php -S localhost:8000

Agora acesse as URLs abaixo:

• http://localhost:8000/
• http://localhost:8000/contato

Seu projeto com URLs Amigáveis já está funcionando!

Falei que seriam apenas alguns segundos!

Parâmetros de URL

Provavelmente você ainda não está satisfeito(a), né?

Aí você me diz:

E se eu quiser passar parâmetros dinâmicos na URL?

É tão simples quanto!

Vamos imaginar que temos um sistema de artigos e que precisamos permitir a exibição de artigos pelo seu ID. Por exemplo, para exibir o artigo de ID 7, usaremos a URL localhost:8000/artigos/7.

Nesse caso, o número 7 é a parte dinâmica da URL.

Para montar essa rota, vamos adicionar esta regra ao nosso arquivo index.php:

$app->get('/artigos/{id}', function ( $request )
{
    $id = $request->getAttribute('route')->getArgument('id');
    printf( "Exibindo artigo %d", $id );
});

Veja que a rota é artigos/{id}. As chaves entre o id diz que esse valor é um parâmetro, que será passado como parâmetro para a função que manipula essa rota.

Outros Métodos HTTP

Nos exemplos anteriores, usamos apenas o método GET para as rotas. Mas também é possível usar os outros métodos HTTP, como POST, PUT, DELETE e outros. Basta trocar o nome do método ao definir a rota:

$app->post('/enviar', function ()
{
    echo "método post";
});

$app->put('/alterar', function ()
{
    echo "método put";
});

$app->delete('/remover', function ()
{
    echo "método delete";
});

Logicamente, também é possível usar parâmetros nessas rotas.

Só Um Pouco de .htaccess…

Eu falei que não usaríamos .htaccess para criar as URLs Amigáveis, certo?

E realmente não usamos.

Mas pode ser necessário criar o .htaccess para que todas as requisições seja encaminhadas para o arquivo index.php. Isso garante que suas rotas funcionem adequadamente em qualquer servidor web.

Vamos criar o .htaccess com este conteúdo:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^ index.php [QSA,L]

Apenas dizemos para encaminhar as requisições sempre para nosso index.php.

Conclusão

Em apenas alguns segundos, usando o Slim e o Composer, conseguimos criar um sistema de rotas bem completo e fácil de manter.

Esse é só um dos inúmeros excelentes recursos do Slim. Veja algumas outras facilidades que ele possui:

• Criação de Rotas (URLs Amigáveis). Mostrei o básico aqui, mas há diversos outros recursos mais avançados;
• Rotas nomeadas, para facilitar a criação de links e navegação em seu sistema;
• Grupos de rotas, permitindo diversos métodos HTTP para a mesma rota;
• Middlewares, para garantir a Segurança e impedir acesso indevido por usuários não logados;
• Gerenciamento de Requisições HTTP, para desenvolver clientes de Web Service com facilidade;
• Gerenciamento de Sessões, para facilitar o desenvolvimento de sistemas de login;
• Cache, para acelerar o carregamento de sua aplicação;
• Criptografia, para garantir total Segurança para os dados de seus usuários;

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post URLs Amigáveis Sem htaccess Usando Slim apareceu primeiro em Blog do Beraldo.

O Composer é o gerenciador de dependências para PHP mais utilizado hoje em dia em todo o mundo. Ele permite que você defina bibliotecas externas usadas em seu projeto de forma simples. O próprio Composer se encarrega de baixar a biblioteca e carregá-la automaticamente em sua aplicação.

É ridiculamente fácil usar o Composer! E ele faz todo o trabalho pesado de gerenciar as bibliotecas, baixar as versões corretas e carregá-las em seu projeto.

Ou seja, se você ainda não o usa, com certeza está perdendo MUITO tempo e produtividade!

Continue lendo este artigo, que vou explicar como instalar e utilizar essa maravilhosa ferramenta.

Instalação do Composer

Há diferenças no processo de instalação em sistemas Windows e em Linux/Mac OS X. Vou abordá-las separadamente.

Instalação em Linux e Mac OS X

Em Linux e Mac, podemos usar as maravilhosas ferramentas de linha de comando, que facilitam muito o nosso dia-a-dia de programação.

Aliás, se você usa Linux ou Mac e não sabe como utilizar os comandos pra agilizar e automatizar suas tarefas, recomendo que dê uma olhada no meu curso Shell Script Para Programadores.

Abra o terminal e rode este comando:

curl -sS https://getcomposer.org/installer | php

O que o comando acima faz é baixar o instalador do Composer, usando curl, e executá-lo com o interpretador do PHP.

Caso você não tenha o curl instalado, o comando vai falhar. Você pode instalar o curl ou usar o comando abaixo, que também terá o mesmo resultado:

php -r "readfile('https://getcomposer.org/installer');" | php

Se você rodar o comando ls, verá que o arquivo composer.phar agora está no diretório.

Você poderá executar o comando abaixo para testar a instalação:

php composer.phar

Como você vai usar muito o Composer, em vários projetos, recomendo que, em vez de baixá-lo em todas aplicações, instale-o globalmente. Assim poderá executá-lo a partir de qualquer diretório, sem precisar baixá-lo de novo.

Para isso, vamos copiar o arquivo composer.phar para um diretório que esteja no PATH do nosso sistema. Pra facilitar, vamos renomeá-lo para composer apenas, sem extensão.

Vamos copiar o arquivo para o diretório /usr/local/bin/, com o comando mv:

sudo mv composer.phar /usr/local/bin/composer

Note que /usr/local/bin/ é um diretório protegido e você precisará de permissão de root para escrever nele. Por isso, executamos o comando usando sudo.

Pronto.

Agora o Composer está instalado globalmente. Basta digitar composer no terminal, em qualquer diretório e pode usá-lo onde quiser.

Instalação em Windows

A forma mais simples de instalar no Windows é usando o instalador. Também há a opção manual, se preferir.

Baixe o instalador clicando aqui. Depois execute-o e siga os passos. O instalador vai colocar o Composer no PATH do seu Windows, assim você poderá executar o comando de qualquer diretório.

Note que, se você estiver com uma janela do terminal (prompt de comando) aberta, deverá fechá-la e abri-la novamente. Isso é necessário para que a alteração no PATH seja carregada.

Se preferir seguir a instalação manual, clique aqui e execute os comandos descritos na documentação oficial.

[cta id=’1444′]

Instalando Dependências

Para instalar uma dependências, usaremos o comando composer require <vendor_name/project_name>. Um pacote é identificado por duas partes: vendor_name é o nome do responsável por ele e project_name é o nome do projeto propriamente dito.

Por exemplo, se quisermos instalar o Slim, vamos requerer o pacote slim/slim, desta forma:

composer require slim/slim

NOTA: caso você não conheça, o Slim é um Micro-framework, muito útil para gerenciar rotas usando URLs Amigáveis, sem a necessidade de criar regras complexas no arquivo .htaccess.

Após alguns segundos, o Slim terá sido baixado automaticamente.

Os arquivos composer.json e composer.lock são criados automaticamente. A biblioteca Slim (e todas as demais dependências) serão armazenadas no diretório vendor.

O arquivo composer.json é o arquivo de configuração principal. É nele que são armazenadas as dependências, nome do projeto etc.

O composer.lock é um arquivo manipulado pelo próprio Composer, para gerenciar as versões, saber de onde baixar as bibliotecas etc. Você não precisa (e nem deve) mexer nele.

O diretório vendor é onde fica o auto loader e todas as dependências de seu projeto.

Você pode alterar o arquivo composer.json manualmente, se preferir. Mas é bem mais rápido e prático usar o comando composer require para isso. Ele altera o arquivo e já baixa a biblioteca automaticamente.

Usando Dependências

Uma vez que você tenha declarado e baixado uma dependência, você poderá usá-la em todo o seu projeto. Basta que o autoloader do Composer tenha sido carregado.

Se você possui um arquivo de Bootstrapping, esse é o local perfeito para incluir o autoloader do Composer. Você pode ler mais sobre Arquivos de Inicialização e Bootstrapping neste meu artigo.

Vamos fazer um rápido teste usando o Slim, que já baixamos anteriormente.

No diretório atual (onde está o composer.json) crie um arquivo index.php. Nele, você precisa apenas incluir o arquivo vendor/autoload.php e você terá acesso a todas as dependências gerenciadas pelo Composer.

Vamos criar o index.php com este conteúdo:

get('/', function()
{
    echo "Funcionou!";
});

$app->run();

Você pode iniciar o servidor nativo do PHP e testar no navegador. Inicie o servidor na porta 8000:

php -S localhost:8000

Depois basta acessar a URL http://localhost:8000 em seu navegador e você verá a mensagem Funcionou!.

Pronto, viu como é simples? :)

Atualizando Dependências

Por ser um gerenciador, o Composer deve atualizar os pacotes baixados. Para isso, devemos usar o comando composer update. Esse comando verifica todas as dependências configuradas no arquivo composer.json e busca por atualizações. Dessa forma, elas estarão sempre atualizadas.

Obtendo Ajuda

Ao digitar apenas composer, sem parâmetros, será exibida a lista de comandos disponíveis. É possível atualizar a lista de repositórios (com selfupdate). Também é possível obter ajuda sobre um comando específico, usando a palavra help antes do comando, por exemplo composer help require.

Aprenda Tudo Sobre o Composer

Neste post mostrei apenas alguns recursos do Composer.

Se você quiser aprender todo o poder dessa ferramenta, conheça o meu curso Ultimate Composer.

No curso eu mostro outras configurações do Composer, a estrutura do arquivo de configuração composer.json e outros comandos disponíveis.

Também demonstro como usar o poderoso autoloader que ele fornece. Essa é um dos principais recursos do Composer e um dos melhores e mais práticos de usar!

Para fixar o conteúdo, vamos montar uma aplicação prática, usando o que aprendemos.

Aproveite a promoção por tempo limitado! O curso Ultimate Composer está custando apenas R$ 7,00! Mas é por pouco tempo!

Clique aqui e conheça o Curso Ultimate Composer!

Aprenda TUDO Sobre o Composer!

Gerencie as dependências da sua aplicação da forma mais eficiente possível!

Com um único comando você baixa todas as dependências necessárias

O mínimo de esforço com a máxima produtividade!

O post Composer: o gerenciador de dependências para PHP apareceu primeiro em Blog do Beraldo.

Você se importa com o Desempenho de suas aplicações? Então é fundamental que você entenda o que é o Problema do N + 1 e saiba como identificá-lo e corrigi-lo.

Essa é uma grande falha que muitos programadores iniciantes (e até intermediários) não conhecem, deixando as aplicações muito lentas e tendo uma grande perda de performance.

Continue lendo este artigo, que vou explicar em detalhes o que é o Problema do N + 1 e como solucioná-lo.

O Que é o Problema do N + 1

Para explicar o que é esse problema, vamos considerar um banco de dados com duas tabelas: uma tabela de usuários e uma tabela de posts, como mostrado na imagem a seguir.

Modelagem para exemplificar o Problema do N + 1

A tabela Usuários armazena os dados dos usuários, como nome, email, senha etc. A tabela de posts, além dos dados dos posts, como título e conteúdo, também possui o campo user_id, que referencia o ID do usuário que criou o post.

Até aí tudo bem. Modelagem bem simples.

Agora imagine que você precisa montar uma tela onde serão exibidos todos os usuários e os títulos de todos os posts de cada um deles.

O que muitos fariam é o seguinte:

1. Selecionar todos os usuários, com a consulta a seguir:

   SELECT id, nome FROM usuarios;
   

2. Em seguida, para cada usuário, seria feita a consulta a seguir:

   SELECT titulo FROM posts WHERE user_id = id_do_usuario;
   

Supondo que temos 100 usuários, serão executadas todas estas consultas:

SELECT id, nome FROM usuarios;;
SELECT titulo FROM posts WHERE user_id = 1;
SELECT titulo FROM posts WHERE user_id = 2;
SELECT titulo FROM posts WHERE user_id = 3;
...
SELECT titulo FROM posts WHERE user_id = 100;

Veja que seriam feitas 101 consultas. E é aqui que você vai entender o motivo do N + 1.

Considerando N o número de usuários, nosso N vale 100. E N + 1 é 101, que foi o total de consultas realizadas.

Consultas a bancos de dados tomam tempo. Muito tempo. Por isso devemos usar sempre o mínimo de consultas.

E 101, definitivamente, não é o mínimo para chegarmos ao resultado esperado.

Esse número é BEM MENOR que 101… MUTO MENOR MESMO!

Você vai entender logo logo.

Como Identificar o Problema do N + 1

É simples identificar esse problema. Sempre que houver uma consulta dentro de um loop, é bem provável que ali esteja ocorrendo esse problema.

Vamos a um simples exemplo, usando PHP:

$PDO = new PDO( "dados de conexão aqui" );
$sql = "SELECT id, nome FROM usuarios";
$stmt = $PDO->prepare( $sql );
$result = $stmt->execute();
$users = $stmt->fetchAll( PDO::FETCH_ASSOC );

foreach ( $users as $user )
{
    $sql = "SELECT titulo FROM posts WHERE user_id = :user_id";
    $stmt = $PDO->prepare( $sql );
    $stmt->bindParam( ':user_id', $user['id'] );
    $result = $stmt->execute();
    $posts = $stmt->fetchAll( PDO::FETCH_ASSOC );
}

NOTA: Caso você não conheça PDO, recomendo ler este artigo.

Veja que existe uma consulta dentro do loop. Ou seja, serão feitas N consultas, sendo N o total de elementos do array $users (100, no nosso caso).

Como Resolver o Problema do N + 1

Resolver esse problema é muito simples!

Vamos reduzir o números de consultas de N + 1 para APENAS 2!

Vamos usar SOMENTE DUAS CONSULTAS!

A primeira vai continuar sendo a mesma de antes, responsável por buscar todos os usuários:

SELECT id, nome FROM usuarios

Porém, a segunda vai usar os dados dessa consulta e trazer todos os posts de todos os usuários. Depois basta iterar sobre o array, dentro da programação.

A consulta usará a função IN() na cláusula WHERE, desta forma:

SELECT titulo FROM posts WHERE user_id IN(1,2,3,4,5,...,100);

Vou modificar o código anterior e mostrar como resolver o Problema do N + 1 para o caso que analisamos.

$PDO = new PDO( "sua conexão aqui" );
$sql = "SELECT id, nome FROM usuarios";
$stmt = $PDO->prepare( $sql );
$result = $stmt->execute();
$users = $stmt->fetchAll( PDO::FETCH_ASSOC );

$userIDs = array_column( $users, 'id' );
$sqlIDs = implode( ',', $userIDs );
$sql = sprintf( "SELECT titulo FROM posts WHERE user_id IN(%s)", $sqlIDs );
$stmt = $PDO->prepare( $sql );
$result = $stmt->execute();
$posts = $stmt->fetchAll( PDO::FETCH_ASSOC );

Voilà!

Note que, até a criação da variável $users, nada mudou. Depois disso é que apareceram as novidades. Vamos analisá-las com mais calma.

Criei a variável $userIDs, que é um array com todos os valores do campo id que estavam no array $users. Isso ficou fácil usando a função array_column.

Em seguida criei a variável $sqlIDs, usando a função implode. Essa variável é uma string com todos os IDs separados por vírgula, de forma que possa ser usada no parâmetro da função IN da SQL.

Depois criei a variável $sql, que vai buscar todos os posts com uma única consulta.

Analisando o Ganho de Desempenho

Vamos fazer um simples teste de desempenho, para comparar os dois códigos que vimos anteriormente.

A análise é simples: pegar a hora de início do script, a hora final e subtrair. Para isso, usarei a função microtime, para pegar o tempo atual em micro-segundos, e a função number_format, para formatar o tempo de maneira a ficar mais facilmente legível.

A ideia geral, em termos de código é a seguinte:

$inicio = microtime( true );

// código cujo desempenho queremos testar

$fim = microtime( true );
$diff = number_format( $fim - $inicio, 15, ',', '.' );

echo "Tempo total: " . $diff . PHP_EOL;

Para testar, criei 100 registros na tabela de usuários, com valores aleatórios. Criei 1000 registros, também aleatórios, na tabela de posts.

Vamos aos resultados…

O script contendo o Problema do N + 1 foi executado em 0,0198240280 segundos.

Já o script sem o problema foi executado em 0,0015311241 segundos. Ou seja, aproximadamente 13 vezes mais rápido.

13 VEZES MAIS RÁPIDO!

E olha que o exemplo tinha poucos dados. Um sistema real geralmente tem muito mais que 100 usuários e mais de 1000 registros relacionados a eles.

Por que não usei JOIN em vez do IN

É possível resolver esse problema com apenas uma consulta, usando JOIN em vez de IN, desta forma:

SELECT u.id, u.nome, p.titulo FROM usuarios u INNER JOIN posts p ON p.user_id = u.id

Mas isso não significa que será mais eficiente.

O foco aqui é Desempenho, não apenas menos consultas.

Se cada usuário tivesse apenas um post, poderia ser mais eficiente usar JOIN. Mas se, por exemplo, cada usuário tiver, em média, 100 posts, haverá milhares de dados repetidos trafegando entre o banco de dados e sua aplicação. E isso tomará tempo e memória.

Já que estamos fazendo testes práticos, vamos comparar os tempos de execução de dois scripts, um usando o IN (que é o mesmo código que mostrei anteriormente) e outro usando JOIN.

O código usando JOIN é este:

$PDO = new PDO( "conexão aqui" );
$sql = "SELECT u.id, u.nome, p.titulo FROM usuarios u INNER JOIN posts p ON p.user_id = u.id";
$stmt = $PDO->prepare( $sql );
$result = $stmt->execute();
$posts = $stmt->fetchAll( PDO::FETCH_ASSOC );

Vou mostrar os resultados para um conjunto de 100 usuários e 1000 posts. Em seguida, vou inserir mais 4000 posts, resultando em 100 usuários e 5000 posts.

Alguns resultados de execução para 100 usuários e 1000 posts:

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,002864837646484
  Tempo total com IN: 0,002188920974731

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,002944946289063
  Tempo total com IN: 0,001436948776245

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,003201961517334
  Tempo total com IN: 0,001392841339111

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,002935886383057
  Tempo total com IN: 0,001415014266968

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,002933025360107
  Tempo total com IN: 0,001442193984985

Agora vamos a alguns resultados usando 100 usuários e 5000 posts:

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,011201143264771
  Tempo total com IN: 0,002874851226807

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,010854005813599
  Tempo total com IN: 0,002540111541748

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,010561943054199
  Tempo total com IN: 0,002592086791992

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,010941982269287
  Tempo total com IN: 0,002531051635742

$ php select_join.php && php select_in.php
Tempo total com JOIN: 0,010515928268433
  Tempo total com IN: 0,002762794494629

Fiz cinco execuções de cada script para cada conjunto de dados.

De todos os 10 testes, 9 resultaram em desempenho superior na versão usando IN. O uso do JOIN ficou superior apenas na primeira execução com 1000 posts.

Não estou falando para abandonar o JOIN e usar só o IN. Tudo depende da sua modelagem e da quantidade de dados. Para poucos dados ou relação 1 Para 1, o JOIN será melhor. Mas em relação 1 Para Muitos, o IN tende a ter melhor desempenho.

Conclusão

Melhorias de desempenho são sempre muito bem-vindas. Qualquer ajuste que dê 5% de ganho já é válido.

E considerando que aqui tivemos 13 vezes mais (ou seja, 1300%), você definitivamente precisa saber identificar e resolver o Problema do N + 1 nas aplicações que você desenvolve ou dá manutenção.

É uma medida simples e que dá resultados fantásticos!

Otimizações Avançadas

Há inúmeras outras formas mais avançadas de otimizar seu banco de dados.

Para conhecer essas técnicas, recomendo o curso Tuning MySQL (curso em português), especialmente voltado para o MySQL, um dos mais usados do Mercado.

Você vai aprender passo-a-passo como instalar e configurar o MySQL da forma mais otimizada para a sua aplicação, conhecendo cada um dos arquivos de configuração e suas diretivas. Também vai descobrir como realizar análises de desempenho e testes de stress, para comparar o desempenho padrão e o desempenho obtido após o tuning.

Clique Aqui e conheço o Curso Tuning MySQL

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post O Problema do N + 1: como identificá-lo, corrigi-lo e ganhar desempenho em suas aplicações apareceu primeiro em Blog do Beraldo.

Neste meu antigo post eu mostrei como usar algumas técnicas de Captcha envolvendo imagens. O grande problema disso está no quesito acessibilidade. Leitores de tela não identificam as imagens, dificultando a navegação para deficientes visuais.

Outro problema é o incômodo para o usuário. Ele precisa identificar caracteres distorcidos em uma imagem, para provar que não é um robô. Isso é muito chato.

Há poucos meses, o Google anunciou uma nova forma de verificação anti-bot, para substituir o reCaptcha, propriedade da empresa. A abordagem é bem simplista, mas ainda envolve uma ação do usuário.

Neste post vou mostrar a técnica Honeypot, que eu uso há alguns anos e que tem dado resultados de praticamente 100% contra spam. E o melhor: não requer ação alguma do dos usuários.

Como Funciona Esse Captcha Honeypot

O “segredo” são campos ocultos. Só isso.

Explicando melhor: eu crio dois campos ocultos. Um deles é um campo input do tipo hidden (oculto). O outro é um input text (texto) oculto via CSS. Ambos possuem o valor vazio.

Ou seja, ambos os campos são invisíveis a usuários comuns. Consequentemente, não serão preenchidos por eles. Caso algum desses campos possua um valor não vazio, significa que o formulário foi enviado por um robô.

Exemplo do Captcha Honeypot em Ação

Para exemplificar, vamos criar este formulário:

Na página que recebe o formulário (aqui chamei de seu_script.php), faremos o seguinte:

O código HTML tem dois campos ocultos. Ambos com valor vazio. No script PHP, verificamos se ambos são vazios. Se algum deles tiver valor diferente de vazio, exibimos uma mensagem de alerta e interrompemos o script.

Pronto. Bem simples. :)

Conclusão

Para mim, essa abordagem tem eficácia de praticamente 100%. Pouquíssimos robôs passaram por essa verificação.

A melhor coisa dessa técnica é o não envolvimento do usuário. Ele não precisa identificar caracteres em imagens nem clicar em checkbox dizendo “Não sou um robô”.

A lógica aqui é assumir primeiro que o visitante não é um robô. Ao contrário das outras, que primeiro assumem que é um robô e, para provar o oposto, o usuário é forçado a tomar alguma ação.

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post Honeypot: Captcha Acessível Sem Utilização de Imagens apareceu primeiro em Blog do Beraldo.

Logs de execução são muito úteis para “catalogar” o ciclo de execução de um programa. Cada ação executada pelo software é registrada em um arquivo, juntamente com a data e a hora do ocorrido.

Muitos programadores enchem a tela de echo e var_dump, para descobrir o que está ocorrendo no código. Isso não é totalmente errado, mas há alternativas melhores. Aliás, já vi gente esquecer de tirar var_dump antes de mandar o sistema pro ar. Resultado: todo mundo vendo o debug ao acessar o site…

Neste artigo vou mostrar como criar um simples sistema de logs usando PHP.

Como Um Arquivo de Logs Deve Ser

Um simples exemplo de um registro em um arquivo de log é o seguinte:

[2015-03-31 00:00:00] INFO: Executando ação X...

Bem simples. Nada especial.

O arquivo nada mais é do que um conjunto de registros, um por linha, que indicam a data e a hora em que um determinado evento ocorreu.

No exemplo acima, incluí o nível do log, que é representado pela palavra INFO. Nesse caso, é um log de Informação. Poderíamos ter outros níveis, como Avisos (Warning) e erros (Error).

Função Para Gerar Logs

Vou mostrar uma simples função para criação de logs.

Vamos considerar os três tipos (aqui chamo de níveis) de logs que citei antes aqui no artigo.

Vou chamar a função de logMsg. Ela aceita três parâmetros, mas apenas o primeiro é obrigatório.

O primeiro parâmetro é a mensagem do log. O segundo é o nível do log (pode ser info, que é o valor padrão, warning ou error). O terceiro parâmetro é o nome do arquivo onde o log será escrito. Por padrão, será escrito no arquivo main.log.

Vamos ao código, com os deviso comentários.

function logMsg( $msg, $level = 'info', $file = 'main.log' )
{
    // variável que vai armazenar o nível do log (INFO, WARNING ou ERROR)
    $levelStr = '';

    // verifica o nível do log
    switch ( $level )
    {
        case 'info':
            // nível de informação
            $levelStr = 'INFO';
            break;

        case 'warning':
            // nível de aviso
            $levelStr = 'WARNING';
            break;

        case 'error':
            // nível de erro
            $levelStr = 'ERROR';
            break;
    }

    // data atual
    $date = date( 'Y-m-d H:i:s' );

    // formata a mensagem do log
    // 1o: data atual
    // 2o: nível da mensagem (INFO, WARNING ou ERROR)
    // 3o: a mensagem propriamente dita
    // 4o: uma quebra de linha
    $msg = sprintf( "[%s] [%s]: %s%s", $date, $levelStr, $msg, PHP_EOL );

    // escreve o log no arquivo
    // é necessário usar FILE_APPEND para que a mensagem seja escrita no final do arquivo, preservando o conteúdo antigo do arquivo
    file_put_contents( $file, $msg, FILE_APPEND );
}

Como Usar A Função de Geração de Logs

Para usar a função logMsg que criamos, basta chamá-la com, pelo menos, o primeiro parâmetro.

Vamos a alguns exemplos.

Geração de Log de Informação

Para gerar um simples log de informação, use o seguinte exemplo.

logMsg( "Executando a tarefa X..." );

Isso vai gerar a seguinte linha no arquivo de log

[2015-04-03 22:07:03] [INFO]: Executando a tarefa X...

Geração de Log de Aviso

Para gerar um log de aviso, use o seguinte exemplo.

logMsg( "Isto é um aviso.... a operação X pode falhar...", 'warning' );

Isso vai gerar a seguinte linha no arquivo de log

[2015-04-03 22:0703] [WARNING]: Isto é um aviso.... a operação X pode falhar...

Geração de Log de Erro

Para gerar um log de erro, use o seguinte exemplo.

logMsg( "Isto é um erro. A operação X falhou", 'error' );

Isso vai gerar a seguinte linha no arquivo de log

[2015-04-03 22:0703] [ERROR]: Isto é um erro. A operação X falhou

Por Que Não Usei a Função error_log do PHP

O PHP possui a função error_log. Você é livre para usá-la, se desejar.

Eu preferi não usá-la pois ela não permite usar as configurações a mais que acho úteis, como o nível de log. Ela é mais focada em erros, como o próprio nome da mensagem sugere.

Cuidado Com a Quantidade de Logs

Logs são muito úteis, claro. Mas existe um custo para o servidor.

Cada escrita no arquivo toma tempo da CPU e deixa sua aplicação um pouco mais lenta. É pouco perceptível quando há poucos logs.

Porém, se você configurar muitas gerações de logs, verá uma queda no desempenho. Principalmente se seu sistema receber muitos acessos simultâneos. Afinal, escrita em disco é uma das tarefas mais custosas para a CPU.

Por isso, use os logs com cautela. Gere logs apenas quando realmente necessário. Não crie logs inúteis. E, se gerar logs apenas para debug durante o desenvolvimento, lembre-se de removê-los antes de colocar a aplicação em produção.

Padrão PSR-3 de Logs

O grupo PHP-Fig criou, dentre outras recomendações, o PSR-3, que é uma recomendação de padronização para bibliotecas de geração de logs.

Se você já tem conhecimentos sobre Orientação a Objetos, recomendo analisar o PSR-3 e tentar aplicar em seus projetos. Se ainda não conhecer OOP, vá com calma. Use a função que mostrei nesse post e, depois, quando já tiver domínio de OOP, aplique os conceitos do PSR-3.

Aprenda Ainda Mais

Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional

Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

Baixe gratuitamente este guia com 15 Dicas de PHP

O post Como Gerar Logs de Execução com PHP apareceu primeiro em Blog do Beraldo.

O PHP é amplamente conhecido como uma linguagem para desenvolvimento de aplicações Web. Porém, nem só de Web vive o PHP. Existem outras formas de execução do PHP. É possível executá-lo em linha de comando também. Há, inclusive, uma forma de executar o PHP em um terminal interativo.

Execução do PHP em Servidor Web

Essa é a forma mais conhecida. É possível usar servidores como Apache, Nginx, IIS e outros, mas poucos conhecem o servidor interno do PHP, disponível a partir da versão 5.4

Crie um arquivo index.php, com este conteúdo:

Salva o arquivo. Abra o terminal (aliás, ele já deveria estar aberto :P) e entre no diretório onde salvou o index.php. Execute este comando:
php -S localhost:8000

Esse comando vai iniciar o servidor interno do PHP na porta 8000. É possível alterar a porta, se você já tiver outra aplicação rodando nessa porta ou simplesmente não goste do número 8000. :P
Será exibida esta saída:
PHP 5.6.6 Development Server started at Thu Mar 12 21:44:26 2015
Listening on http://localhost:8000
Document root is /private/tmp
Press Ctrl-C to quit.

Pronto. Seu servidor está ativo. Acess a URL  http://localhost:8000 e lá estará a mensagem "Usando o servidor interno do PHP". Para parar o servidor, digite "CTRL+C".
Não entrarei em detalhes sobre as formas de execução do PHP em outros servidores Web. Há diversos artigos específicos sobre isso. Só pesquisar no Google.
Execução do PHP em Linha de Comando
Ainda não fechou o terminal, né? Então, ainda no diretório onde está seu script index.php, execute este comando:
php index.php 

A mensagem "Usando o servidor interno do PHP" será exibida no terminal. Porém não há quebra de linha no final dela. Vamos editar o arquivo index.php, deixando-o assim:

A constante PHP_EOL corresponde ao "fim de linha" (End Of Line). Ela permite criar scripts portáveis, já que a quebra de linha em Linux e Mac OS X (e outros derivados de Unix) é "\n" e no Windows é "\r\n".
Ao executar novamente o comando php index.php, o seguinte resultado aparecerá no terminal:
Usando o PHP em linha de comando

Execução do PHP no Terminal Interativo
O PHP tem um terminal interativo. Ou seja, é um terminal onde, a cada comando digitado, ele é imediatamente executado. Por exemplo, ao executar um echo, a mensagem é exibida na tela.
Para iniciar o terminal interativo, digite o seguinte comando no terminal:
php -a

Pronto. Você está no terminal interativo. Pode digitar qualquer comando PHP, que ele será executado. O ponto-e-vírgula continua sendo obrigatório aqui. Lembre-se dele!
Vamos a alguns exemplos:
$ php -a
Interactive shell

php > echo "Hello World";
Hello World
php > $x = 2;
php > echo pow( $x, 10 );
1024
php > echo "sem ponto-e-virgula"
php > ;
sem ponto-e-virgula

Veja que, se você esquecer o ponto-e-vírgula, poderá colocá-lo na linha seguinte, sem gerar qualquer erro.
Esse terminal interativo é útil quando você quer testar alguma função, sem a necessidade de criar um script somente para isso.
 



Aprenda Ainda Mais


	



	
Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional
    
    
Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

	
Baixe gratuitamente este guia com 15 Dicas de PHP

	

    	
        	
        
    




	

O post As Diferentes Formas de Execução do PHP apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/diferentes-formas-execucao-php/feed/
			6
		
		
		1230	
		
		
		http://rberaldo.com.br/grep-como-buscar-em-arquivos-linux/?utm_source=rss&utm_medium=rss&utm_campaign=grep-como-buscar-em-arquivos-linux
					http://rberaldo.com.br/grep-como-buscar-em-arquivos-linux/#respond
		
		
		Wed, 14 Jan 2015 10:32:05 +0000
				
		
		
		
		
		
		
		
		
		http://rberaldo.com.br/?p=1070

					O comando grep é utilizado para buscar strings e padrões (usando Expressões Regulares) dentro de arquivos. O nome do comando significa global regular expression print, ou seja, ele imprime trechos de arquivos que correspondam a uma determinada expressão regular. Você pode usar apenas strings para realizar as buscas. Porém, o uso de Expressões Regulares abre um grande leque de […]

O post grep: como buscar em arquivos no Linux apareceu primeiro em Blog do Beraldo.
]]>
										

O comando grep é utilizado para buscar strings e padrões (usando Expressões Regulares) dentro de arquivos. O nome do comando significa global regular expression print, ou seja, ele imprime trechos de arquivos que correspondam a uma determinada expressão regular.
Você pode usar apenas strings para realizar as buscas. Porém, o uso de Expressões Regulares abre um grande leque de opções para buscas avançadas. Se você não conhece Expressões Regulares, sugiro que leia Expressões Regulares – Guia de Consulta Rápida, de Aurelio Marinho Jargas, disponível gratuitamente na Internet pelo próprio autor.

Nota: Este artigo é um a versão reduzida do artigo bônus do curso Shell Script Para Programadores. Para conhecer melhor o curso e fazer sua matrícula, clique aqui.
 
A sintaxe do comando grep é a seguinte:
$ grep [opcoes] arquivo

O comando grep funciona da seguinte forma: ele lê um arquivo linha a linha. Se a linha lida corresponder ao padrão (Expressão Regular) usada na filtragem, a linha é exibida na saída padrão. O comportamento da exibição pode ser modificado com as opções que veremos adiante, como exibir apenas o nome do arquivo, incluir número de linha, exibir só o texto que coincidiu com o padrão etc.
Em vez de abordar a fundo a parte teórica, vou ficar em exemplos práticos. Antes disso, precisamos ver as principais opções do comendo grep.
Principais Opções do Comando grep
Existem inúmeras opções que podem ser utilizadas com o comando grep. Vou falar apenas das mais comuns e principais. As opções mais usadas são:

-A NUM, --after-context=NUM: exibe NUM linhas após a linha onde o padrão foi encontrado;
-B NUM, --before-context=NUM: exibe NUM linhas antes da linha onde o padrão foi encontrado;
-C NUM, -NUM, --context=NUM exibe NUM linhas antes e NUM linhas depois da linha onde o padrão foi encontrado;
-c, --count: conta o total de linhas que coincidiram com o padrão;
--color, --colour: ativa a exibição de cores, destacando o trecho que coincide com o padrão;
-E, --extended-regexp: Interpreta as Expressões Regulares usando o modo POSIX (equivale a usar o comando egrep em vez do grep;
-i, --ignore-case: Modo case-insensitive. Não diferencia maiúsculas de minúsculas;
-l, --files-with-matches: em vez de exibir a saída normal, exibe apenas os nomes dos arquivos que coincidem com o padrão;
-n, --line-number: exibe o número da linha onde o padrão foi encontrado;
-o, --only-matching: exibe apenas o trecho da linha que coincide com o padrão;
-R, -r, --recursive: realiza busca recursiva;
-x, --line-regexp: filtra por linhas que coincidam exatamente com o padrão;
-v, --invert-match: Inverte o modo de assimilação. A busca é feita por linhas que não coincidam com o padrão;

Se você está habituado(a) a usar o padrão POSIX de Expressões Regulares (com os quantificadores +, {NUM} etc), é preferível usar o comando egrep em vez do grep. Isso poupa você de ter que usar a opção -E sempre que for usar esse padrão de Expressão Regular.
Arquivo Para os Exemplos
Para ilustrar os exemplos, será útil utilizar um arquivo de texto. Usarei um arquivo de dicionário, que possui milhares de palavras e nomes da Língua Portuguesa. Esse arquivo pode ser baixado aqui (está compactado em ZIP).
Exemplos de Uso
Como eu citei antes, se você estiver habituado(a) a usar Expressões Regulares (ERs) do padrão POSIX, será melhor usar egrep em vez de grep. Como eu sou uma dessas pessoas, vou usar egrep em todos os exemplos, mesmo quando não utilizar expressões regulares. É uma simples questão de hábito pessoal. :)
Filtrando linhas por uma string
$ egrep 'programador' wordlist-preao-20150102.txt
desprogramador
desprogramadora
desprogramadoras
desprogramadores
programador
programadora
programadoras
programadores
reprogramador
reprogramadora
reprogramadoras
reprogramadores

O comando exibe todas as linhas que contenham a palavra “programador”.
Contando as ocorrências de um padrão
Para exibir o total de ocorrências de um padrão em vez da saída padrão do grep, usamos a opção -c:
$ egrep -c 'programador' wordlist-preao-20150102.txt
12

Filtrando por linha exata
Se quisermos apenas a linha onde há a palavra “programador”, exatamente, usamos a opção -x:
$ egrep -x 'programador' wordlist-preao-20150102.txt
programador

Se quisermos buscar por “programador” ou “programadora”, basta utilizarmos o básico sobre ERs:
$ egrep -x 'programadora?' wordlist-preao-20150102.txt
programador
programadora

Exibindo o número da linha
Para exibir o número da linha, usamos a opção -n:
$ egrep -xn 'programadora?' wordlist-preao-20150102.txt
776176:programador
776177:programadora

Filtragem case-insensitive
Para fazer filtragem case-insensitive (ignorando diferenças entre maiúsuclas e minúsculas), usamos a opção -i:
$ egrep -i 'marcel' wordlist-preao-20150102.txt
Marcelino
Marcelismo
Marcelismos
Marcelista
Marcelistas
Marcelo

Buscamos por “marcel”, mas os resultados se iniciam por letras maiúsculas. Se retirarmos a opção -i, nenhum resultado será exibido.
Filtrando por linhas que não coincidem com o padrão
Para filtrar por linhas que NÃO coincidem com o padrão, usamos a opção -v:
$ egrep -v 'programador' wordlist-preao-20150102.txt

Esse comando exibe todas as linhas que não coincidam com o padrão “programador”. Não incluí a saída do comando, pois possui milhares de linhas.
Exibindo linhas anteriores a um padrão
Além de exibir apenas a linha que coincide com o padrão do filtro, podemos exibir as linhas imediatamente anteriores à linha que coincidiu com o padrão. Para isso, usamos a opção -B NUM (B de before), onde NUM é o número de linhas que devem ser exibidor.
$ egrep -nx -B 2 'programador' wordlist-preao-20150102.txt
776174-programadas
776175-programado
776176:programador

Nesse comando, filtro pela linha que contém exatamente a palavra “programador” (opção -x), exibindo, também, os números de linha (opção -n). Com a opção -B 2, são exibidas as duas linhas anteriores à linha onde há a palavra “programador”.
Exibindo linhas posteriores a um padrão
De forma semelhante ao que ocorre com a opção -B NUM, é possível exibir as linhas posteriores. Usa-se a opção -A NUM (A de after).
$ egrep -nx -A 2 'programador' wordlist-preao-20150102.txt
776176:programador
776177-programadora
776178-programadoras

Exibindo linhas anteriores e posteriores a um padrão
Podemos mostrar as linhas anteriores e posteriores, se juntarmos as opções -A e -B. Porém, há uma forma mais simples, usando a opção -C, desta forma:
$ egrep -nx -C 2 'programador' wordlist-preao-20150102.txt
776174-programadas
776175-programado
776176:programador
776177-programadora
776178-programadoras

Isso equivale a usar as opções -A e -B juntas, desta forma:
$ egrep -nx -A 2 -B 2 'programador' wordlist-preao-20150102.txt
776174-programadas
776175-programado
776176:programador
776177-programadora
776178-programadoras

Colorindo o trecho que coincide com o padrão
Usando a opção --color (ou --colour, no inglês britânico) é possível destacar os trechos que coincidiram com o padrão. Por exemplo:
$ egrep --color 'programador' wordlist-preao-20150102.txt
desprogramador
desprogramadora
desprogramadoras
desprogramadores
programador
programadora
programadoras
programadores
reprogramador
reprogramadora
reprogramadoras
reprogramadores

Você verá que todas as ocorrências de “programador” nessas strings estarão destacadas (em vermelho, provavelmente).
Busca recursiva
Para exemplificar a busca recursiva, vou duplicar o arquivo de dicionário, criando os arquivos wordlist-preao-20150102_2.txt e wordlist-preao-20150102_3.txt. Vou deixá-los no mesmo diretório. Mas, como a busca será recursiva, eles poderiam estar em qualquer nível abaixo do diretório corrente.
Para realizar buscas recursivas, usarmos a opção -r ou -R. Desta vez, não vamos informar um nome de arquivo. Em vez disso, passaremos o nome di um diretório. No exemplo abaixo, uso o diretório corrente (.).
$ egrep -rx 'programador' .
./wordlist-preao-20150102.txt:programador
./wordlist-preao-20150102_2.txt:programador
./wordlist-preao-20150102_3.txt:programador

Quando a busca é recursiva, antes da linha é sempre exibido o nome do arquivo onde o padrão foi encontrado.
Exibindo apenas o nome do arquivo onde o padrão foi encontrado
Com a busca recursiva, às vezes apenas queremos saber em qual arquivo existe um determinado padrão, sem exibir as linhas. Para isso, basta usar a opção -l, desta forma:
$ egrep -rl 'programador' .
./wordlist-preao-20150102.txt
./wordlist-preao-20150102_2.txt
./wordlist-preao-20150102_3.txt

Conclusão
A ferramenta grep é bem completa, permitindo fazer buscar bem complexas, usando Expressões Regulares.
É possível juntar várias opções (dentre as que mostrei e diversas outras do grep) e realizar buscas de forma rápida e ágil.
Dica para Programadores
Uma combinação de parâmetros que acho muito útil no dia-a-dia de programação é a -irn. Muitas vezes preciso procurar onde alguma string está presente e em quais arquivos. Por isso faço uma busca recursiva, case-insensitive, mostrando o número da linha onde o padrão foi encontrado. Por exemplo:
$ egrep -irn 'string' .

 
Para aprender mais sobre Comandos Linux e Shell Script, veja meu curso Shell Script Para Programadores.
O post grep: como buscar em arquivos no Linux apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/grep-como-buscar-em-arquivos-linux/feed/
			0
		
		
		1070	
		
		
		http://rberaldo.com.br/find-como-encontrar-arquivos-linux/?utm_source=rss&utm_medium=rss&utm_campaign=find-como-encontrar-arquivos-linux
					http://rberaldo.com.br/find-como-encontrar-arquivos-linux/#respond
		
		
		Sun, 11 Jan 2015 21:47:51 +0000
				
		
		
		
		
		
		
		
		http://rberaldo.com.br/?p=1068

					Buscar arquivos tem ficado cada vez mais fácil usando interface gráfica. Porém, há momentos em que os filtros oferecidos pelas interfaces não são suficientes. Além disso, caso você esteja gerenciando um servidor Linux via SSH, não terá interface gráfica e terá de usar o (muito) bom e velho comando find. O comando find permite buscar […]

O post find: como encontrar arquivos no Linux apareceu primeiro em Blog do Beraldo.
]]>
										

Buscar arquivos tem ficado cada vez mais fácil usando interface gráfica. Porém, há momentos em que os filtros oferecidos pelas interfaces não são suficientes. Além disso, caso você esteja gerenciando um servidor Linux via SSH, não terá interface gráfica e terá de usar o (muito) bom e velho comando find.
O comando find permite buscar arquivos filtrando por nome, tamanho, data, dono, grupo, permissões, tipo e outros. A busca é recursiva, por padrão, mas pode ser restringida a uma determinada profundidade. Em suma, o find é uma ferramenta bem completa e poderosa.

Nota: Este artigo é um a versão reduzida do artigo bônus do curso Shell Script Para Programadores. Para conhecer melhor o curso e fazer sua matrícula, clique aqui.
 
Uma nota importante. Vou falar muito em arquivos. Vale lembrar que, no Linux e em outros sistemas Unix-Like (como o Mac OS X), diretórios e links simbólicos também são tratados como arquivos. Logo, quando eu citar arquivo, isso também vai incluir diretórios e links.
Sintaxe do comando find
A sintaxe do comando find é a seguinte:
find local_da_busca criterios_da_busca acoes

Os arquivos encontrados são exibidos na saída padrão. Se nenhum arquivo for encontrado, nada é exibido.
Antes de mostrar exemplos práticos de uso, é importante listar as opções mais comuns do find.
Opções do comando find
Assim como diversas outras ferramentas e comandos do Linux, o possui inúmeras opções e parâmetros. Vou mostrar aqui as mais frequentemente utilizadas e conhecidas.

-maxdepth NUM: altera o nível da profundidade da busca;
-regextype TYPE: altera o tipo de expressão regular utilizada pelas opções -regex e -iregex;
-amin n: o arquivo foi acessado n minutos atrás;
-atime n: O arquivo foi acessado nos últimos n dias (n é multiplicado por 24 horas automaticamente);
-ctime n: O arquivo foi modificado nos últimos n dias (n é multiplicado por 24 horas automaticamente);
-empty: Arquivo ou diretório está vazio;
-gid n: Arquivo cujo número do grupo do dono é n;
-group gname: Arquivo pertence ao grupo gname;
-iname pattern: Igual a -name, porém é case-insensitive (não diferencia maiúsculas e minúsculas);
-iregex pattern: Igual a -regex, porém é case-insensitive (não diferencia maiúsculas e minúsculas);
-name pattern: Arquivos cujo nome contenha pattern;
-perm mode: As permissões do arquivo (em octal) correspondem a perm;
-perm -mode: As permissões do arquivo estão no padrão definido por -mode. É possível filtrar por -perm -g=w, por exemplo. Uma forma mais genérica e menos restrita que usar -perm perm;
-regex pattern: Nome do arquivo coincide com a expressão regular pattern;
-size n[UNIDADE]: O arquivo ocupa n unidades de armazenamento. As unidades incluem k para kilobyte, M para megabyte e G para gigabyte;
-type c: Arquivo é do tipo c. Dentre os tipos válidos estão f para arquivo, d para diretório e l para link simbólico;
-uid n: Arquivo cujo dono tem ID n;
-user username: Arquivo cujo dono é username;
Ações

Além de filtrar por nome, tipo, dono etc, é possível realizar ações com os arquivos encontrados. As principais são:

-delete: Remove o arquivo encontrado;
-exec command ;: executa uma ação (comando) com o arquivo;
-ok command ;: Semelhante a -exec command ;, mas pede permissão ao usuário antes de executar o comando;

Exemplos de Uso do Comando find
Agora que já vimos as principais opções e parâmetros, vamos a exemplos práticos.
O exemplo mais básico
O exemplo mais simples é o seguinte:
$ find .

Esse comendo lista todos os arquivos, de forma recursiva, a partir do diretório atual (.).
Filtrando por nome de arquivo, usando string
Para filtrar por nome de arquivo, usamos a opção -name. Para ignorar diferenças entre maiúsculas e minúsculas, usamos -iname.
$ find / -name "hosts"

Esse comando procura por arquivos com o nome “hosts” em todo o sistema de arquivos (/). Se você executar como usuário normal (sem ser root), verá vários erros como estes:
find: `/root': Permission denied
find: `/etc/ssl/private': Permission denied

Essas mensagens são enviadas para a saída de erro. Logo, podemos eliminá-las, redirecionando a saída de erros para /dev/null, desta forma:
$ find / -name "hosts" 2> /dev/null

Para realizar buscas case-insensitive, basta usar -iname, desta forma:
$ find / -iname "hosts" 2> /dev/null

Filtrando por extensão de arquivo
Também usaremos -name (ou -iname) para isso. Basta usar o asterisco, desta forma:
$ find / -name '*.conf'

Pordemos fazer um OR (OU) no comando find, usando a opção -o. Isso é válido para diversos outros parâmetros, não apenas o -name, desta forma:
$ find / -name '*.ini' -o -name '*.conf'

Filtrando por nome de arquivo, usando Expressões Regulares
É possível usar Expressões Regulares (ERs) para a filtragem. Se você não conhece Expressões Regulares, é bom agilizar e começar a ler o Expressões Regulares – Guia de Consulta Rápida, do Aurelio Marinho Jargas, disponibilizado online e gratuitamente pelo próprio autor.
A filtragem por ERs, ao contrário da filtragem por string, é feita em todo o caminho (path) do arquivo. Ou seja, se quiser encontrar o arquivo ./fubar3, você pode usar as ERs .*bar.' ou .*b.*3, porém não poderá usar f.*r3, pois ela não coincidirá com o padrão ./ no início do path.
Por exemplo, o seguinte comando não retornará saída alguma:
$ find / -regex "hosts" 2> /dev/null

Já o seguinte comando retornará resultados:
$ find / -regex ".*hosts" 2> /dev/null
/etc/hosts
/etc/avahi/hosts
/etc/exim4/conf.d/router/150_exim4-config_hubbed_hosts
/home/beraldo/.ssh/known_hosts

Alterando o Tipo das Expressões Regulares
O comando find suporta diversos tipos de Expressões Regulares (ERs). São eles: emacs (que é o tipo padrão), posix-awk, posix-basic, posix-egrep e posix-extended.
Para alterar o tipo das ERs, usamos a opção -regextype TIPO.
O tipo padrão (emacs) não suporta alguns recursos, como quantificadires. Para mostrar isso na prática, criei um arquivo chamado aaarquivo (com 3 letras “a”) no diretório atual. Vamos testar os seguintes comandos:
$ find . -regex ".*a{3}rquivo"

O comando acima não retorna resultados, pois os quantificadores não são interpretados. Porém, se mudarmos o tipo das ERs para posix-egrep, o resultado será exibido, conforme o comando abaixo.
$ find . -regextype posix-egrep -regex ".*a{3}rquivo"
./aaarquivo

Para mais detalhes sobre ERs e o padrão posix-egrep veja o meu post grep: como buscar em arquivos no Linux.
Filtrando por tipo de arquivo
É possível filtrar por tipo de arquivo (arquivo, diretório, link simbólico etc), usando a opção -type.
Filtrando apenas por arquivos
Para filtrar apenas por arquivos, usamos o opção -type f:
$ find /usr/bin -type f

Filtrando apenas por diretórios
Para filtrar apenas por diretórios, usamos o opção -type d:
$ find /usr -type d

Filtrando apenas por links simbólicos
Para filtrar apenas por links simbólicos, usamos o opção -type l:
$ find /usr/bin -type l

Há outros tipos disponíveis, porém pouco utilizados. Veja o manual (man find) para ver todas as possibilidades.
[cta id=’925′]
Filtrando por data
Para filtrar por data de modificação, usamos a opção -mtime. Vamos a alguns exemplos.
# arquivos modificados entre agora e 1 dia atrás (últimas 24 horas)
$ find . -mtime 0

# arquivos modificados a menos de um dia (últimas 24 horas, igual ao comando anterior)
$ find . -mtime -1 

# arquivos modificados entre 24 e 48 horas atrás
$ find . -mtime 1

# arquivos modificados há mais de 48 horas
$ find . -mtime +1

# Arquivos modificados entre 6 e 9 monutos atrás
$ find . -mmin +5 -mmin -10 

A mesma lógica é usada nos outros parâmetros de busca por data, como -atime.
Filtrando por nome de usuário
$ find /home/ -user beraldo

Filtranso por grupo
$ find / -group nome_do_grupo

Filtranso por tamanho de arquivo
O comando a seguir busca por arquivos com mais de 2 MB.
$ find . -size +2M

Este comando buscar por arquivos com, exatamente, 2MB:
$ find . -size 2M

Por fim, este busca por arquivos com menos de 2MB:
$ find . -size -2M

O comando a seguir lista arquivos maiores que 50MB e menores que 100MB.
$ find / -size +50M -size -100M

Filtrando por permissão
Filtrando por arquivos com permissão 644:
$ find . -perm 664

Este comando filtra por arquivos com permissão, no mínimo, 644. Ou seja, arquivos com mais permissões também serão exibidos (incluindo arquivos com permissão 777, por exemplo):
$ find . -perm -664

O comando a seguir filtra por arquivos que tenham permissão de escrita (número 2, em octal) para algum usuário (o próprio dono, o grupo ou outros usuários):
$ find . -perm /222

Os 3 comandos a seguir se comportam da mesma forma. São listados arquivos que possuam permissão de escrita pelo dono ou pelo grupo (OU não exclusivo).
$ find . -perm /220 
$ find . -perm /u+w,g+w 
$ find . -perm /u=w,g=w

Estes 2 comandos abaixo se comportam da mesma forma. Eles listam arquivos que possuam permissão de escrita pelo dono e pelo grupo:
$ find . -perm -220 
$ find . -perm -g+w,u+w

Os 2 comandos abaixo também se comportam da mesma forma. Ele lista arquivos que possam ser lidos por todos (-perm -444 ou -perm -a+r), possuem ao menos um bit de escrita, podendo ser escrito pelo dono, grupo ou outros (-perm /222 ou -perm /a+w), porém não pode ser executado por ninguém (! -perm /111 ou ! -perm /a+x).
$ find . -perm -444 -perm /222 ! -perm /111 
$ find . -perm -a+r -perm /a+w ! -perm /a+x

Para mais detalhes sobre permissões, veja o meu post CHMOD: Permissões em Sistemas Linux e Unix-Like.
Executando Ações Com os Arquivos Encontrados pelo find
É possível executar ações com os arquivos encontrados pelo comando find.
A sintaxe é a seguinte:
$ find diretorio opcoes -exec comando {} \;

Os caracteres {} serão trocados automaticamente pelo arquivo encontrado.
Por exemplo, para executarmos ls -ldh <arquivo> para cada arquivo encontrado no diretório atual, fazemos o seguinte:
$ find . -maxdepth 1 -type f -exec ls -lhd {} \;

Além do -exec, existe o -ok, que se comporta da mesma forma, porém, antes de executar o comando, pergunta ao usuário. É útil para prevenir a execução de comandos errados. Imagine que você executa um rm no arquivo errado…
$ find . -maxdepth 1 -type f -ok ls -lhd {} \;
< ls ... ./a > ? y
-rw-r--r-- 1 beraldo beraldo 0 Jan 17 14:41 ./a
< ls ... ./b > ? y
-rw-r--r-- 1 beraldo beraldo 0 Jan 17 14:41 ./b
< ls ... ./c > ? y
-rw-r--r-- 1 beraldo beraldo 0 Jan 17 14:41 ./c

Para confirmar a execução, digite y (de yes).
Removendo arquivos encontrados
Em vez de usar o comando rm no -exec, é possível usar diretamente a opção -delete, que remove os arquivos encontrados. Por exemplo:
$ find . -maxdepth 1 -type f -delete

Porém as remoções serão feitas sem a confirmação do usuário. Se desejar que seja perguntado, use -ok, como mostrado anteriormente.
Conclusão
O comando find faz buscas bem mais detalhadas que as buscas feitas pela interface gráfica. É um ferramenta muito versátil e poderosa.
Há diversas outras opções e parâmetros, além dos que mostrei aqui. Veja o manual (man find) para mais detalhes. Mostrei aqui apenas os mais utilizados no dia-a-dia.
Para aprender mais sobre Comandos Linux e Shell Script, veja meu curso Shell Script Para Programadores.
O post find: como encontrar arquivos no Linux apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/find-como-encontrar-arquivos-linux/feed/
			0
		
		
		1068	
		
		
		http://rberaldo.com.br/cache-com-php-usando-apc/?utm_source=rss&utm_medium=rss&utm_campaign=cache-com-php-usando-apc
					http://rberaldo.com.br/cache-com-php-usando-apc/#comments
		
		
		Sat, 10 Jan 2015 12:02:53 +0000
				
		
		
		
		
		
		http://rberaldo.com.br/?p=1059

					Desemepnho de aplicações é cada vez mais importante. A Web está mais cheia de conteúdo a cada dia. E, consequentemente, as páginas tendem a possuir mais dados. Se não tomarmos cuidado com o desempenho, nossos sistemas ficarão lentos. Uma forma de contornar esse problema é fazer cache de dados usados com frequência. Há várias maneiras […]

O post Cache com PHP usando APC apareceu primeiro em Blog do Beraldo.
]]>
										

Desemepnho de aplicações é cada vez mais importante. A Web está mais cheia de conteúdo a cada dia. E, consequentemente, as páginas tendem a possuir mais dados. Se não tomarmos cuidado com o desempenho, nossos sistemas ficarão lentos.
Uma forma de contornar esse problema é fazer cache de dados usados com frequência. Há várias maneiras de fazer cache com PHP. Neste artigo, vou falar do APC (Alternative PHP Cache), que é uma extensão do próprio PHP muito simples de usar.

O Que é Cache?
Segundo a Wikipedia, cache é “um dispositivo de acesso rápido, interno a um sistema, que serve de intermediário entre um operador de um processo e o dispositivo de armazenamento ao qual esse operador acede”. Ou seja, cache é um local de rápido acesso a informações que ficam salvas em um dispositovo cujo acesso é mais lento.
Por exemplo, um arquivo em disco pode ter seu conteúdo armazenado em cache na memória. O tempo de acesso à memória é muito mais rápido que o de acesso ao disco. Por isso é útil fazer cache em memória de arquivos acessados frequentemente.
O Que é o APC?
APC (Alternative PHP Cache) é uma extensão do PHP. Ela faz cache de dados em memória. Basta dizer qual será a “chave” (um identificador único para o dado salvo), qual é a informação a ser salva e por quanto tempo ela deve ser mantida em cache. O resto é tarefa do PHP.
A extensão APC não vem habilitada por padrão. É necessário habilitá-la em seu php.ini, ou instalar o pacote correspondente, caso tenha instalado o PHP a partir dos pacotes para Linux ou Mac OS X.
Como Usar o APC Para Fazer Cache com PHP
Existem algumas funções do APC, mas vou me ater às seguintes:

apc_add: adiciona um dado ao cache, caso ainda não esteja salvo;
apc_clear_cache: limpa o cache do APC;
apc_delete: remove um valor do cache;
apc_exists: verifica se uma determinada chave existe no cache;
apc_fetch: retorna um valor salvo no cache;
apc_store: salva um valor no cache, sobrescrevendo-o, caso já exista.

Adicionando um Valor ao Cache
Para adicionar um valor ao cache, é possível usar apc_add ou apc_store. A única diferença entre essas duas funções é que apc_add adiciona um dado ao cache apenas se ele ainda não existir. Já apc_store sempre adiciona o dado. Consequentemente, apc_store vai sobrescrever a informação, caso ela já tenha sido armazenada anteriormente.
A sintaxe de ambas as funções é a mesma, desta forma:
bool apc_add ( string $key , mixed $var [, int $ttl ] )
bool apc_store ( string $key , mixed $var [, int $ttl ] )

O parâmetro $key é a chave de identificação para a informação no cache. É esse valor que usaremos para buscar ou remover o dado do cache. O parâmetro $var é o valor a ser armazenado no cache. Ele pode ser uma simples variável, um array ou mesmo um objeto. E o parâmetro $ttl (Time To Live) é o tempo, em segundos, que o dado deve permanecer em cache. Se $ttl não for especificado (ou for 0), o dado será mantido em cache até que seja manualmente removido.
Para exemplificar, vamos inserir alguns dados no cache, todos com tempo de vida de 60 segundos:
$a = 'valor a';
apc_add( 'chave_a', $a, 60 );

$arr = [
    'a' => 1,
    'b' => 2
];
apc_add( 'meu_array', $arr, 60 );

$obj = new stdClass;
$obj->nome = 'Beraldo';
apc_add( 'meu_objeto', $obj, 60 );

Retornando Dados Salvos no Cache
Para retornar um dado salvo no cache, usamos a função apc_fetch. Basta passar como parâmetro a chave que utilizamos em apc_add ou em apc_store.
$a = apc_fetch( 'chave_a' );
var_dump( $a );

$arr = apc_fetch( 'meu_array' );
var_dump( $arr );

$obj = apc_fetch( 'meu_objeto' );
var_dump( $obj );

Se os dados estiverem em cache, var_dump os exibirá. Caso contrário, será retornado FALSE.
Verificando a Existência de um Dado no Cache
Antes de retornar o dado com apc_fetch, podemos usar apc_exists para verificar se a chave existe no cache. Assim, podemos alterar o trecho anterior pelo seguinte.
if ( apc_exists( 'chave_a' ) )
{
    $a = apc_fetch( 'chave_a' );
    var_dump( $a );
}
else
{
    echo "Chave chave_a não está no cache";
}


if ( apc_exists( 'meu_array' ) )
{
    $arr = apc_fetch( 'meu_array' );
    var_dump( $arr );
}
else
{
    echo "Chave meu_array não está no cache";
}

if ( apc_exists( 'meu_objeto' ) )
{
    $obj = apc_fetch( 'meu_objeto' );
    var_dump( $obj );
}
else
{
    echo "Chave meu_objeto não está no cache";
}

Removendo Um Dado do Cache
Para remover um dado específico, usamos apc_delete.Basta passar a chave por parâmetro, desta forma:
apc_delete( 'chave_a' );
apc_delete( 'meu_array' );
apc_delete( 'meu_objeto' );

Limpando Todo o Cache
Para limpar o cache completamente, basta usar a função  apc_clear_cache:
apc_clear_cache();

Dessa forma, todos os dados salvos em cache serão apagados.
Comparando Desempenho
Para mostrar a diferença de tempo entre acessar um dado em disco e outro dado em cache, vou mostrar uma comparação de desempenho entre ambos.
Para isso, usarei um arquivo .ini, que é geralmente utilizado para armazenar configurações do sistema. Caso você não saiba trabalhar com arquivos .ini usando o PHP, recomendo que leia este meu post, onde mostro como fazer isso.
Critério de Avaliação
Para avaliar o desempenho, usarei apenas o tempo de execução da tarefa em questão. Usarei a função microtime, que retorna a hora atual, em microssegundos. Tendo a hora de início e a hora de término, basta subtraí-las e teremos o tempo de execução total. Vou considerar apenas o tempo de acesso ao dispositivo (disco e cache), sem considerar o tempo para exibir o dado na tela. Para exibir o resultado, usarei number_format, pois, quando o tempo é muito pequeno, o número é exibido em notação científica (no formato 5.124E-10) e pode confundir quem não está habituado a visualizar números nesse formato.
Arquivo de Configuração
Primeiramente, crie um arquivo chamado config.ini, com o seguinte conteúdo:
[db]
host = "localhost"
user = "usuario"
pass = "senha"
dbname = "nome_do_banco"

Esse é um simples exemplo de um arquivo .ini, com configurações para acesso a um banco de dados.
Carregando Dados do Arquivo
Vaamos agora criar o script que carrega uma configuração diretamente do arquivo.
$configFile = 'config.ini';

$start = microtime( true );
$config = parse_ini_file( $configFile, true );
$host = $config[ 'db' ][ 'host' ];
$end = microtime( true );

var_dump( $host );
var_dump( number_format( $end - $start, 20 ) );

No meu computador, o tempo de execução exibido foi 0.00008392333984375000.
Carregando Dados do Cache
Nesse script, vamos carregar o conteúdo do arquivo .ini e salvá-lo no cache. Apenas depois disso vamos contabilizar o tempo. Afinal, estamos interessados apenas no tempo de acesso ao cache.
$configFile = 'config.ini';
$configArr = parse_ini_file( $configFile, true );

apc_store( 'config', $configArr, 5 );

$start = microtime( true );
$config = apc_fetch( 'config' );
$host = $config[ 'db' ][ 'host' ];
$end = microtime( true );

var_dump( $host );
var_dump( number_format( $end - $start, 20 ) );

O resultado retornado foi 0.00001096725463867188.
Comparando os Resultados
O tempo de execução do primeiro script foi de 0.00008392333984375000 segundos. O segundo levou 0.00001096725463867188. Se dividirmos ambos os números, veremos que o script que acessa o cache rodou, aproximadamente, 7.652174 vezes mais rápido!
Conclusão
O uso de cache acelera bastante a execução dos nossos sistemas.
O APC é apenas uma das opções de cache para PHP. Existem diversas outras. Não importa muito qual você usará, mas é importante que seja usado cache para armazenar informações que são acessadas com frequência, como dados de um arquivo de configuração, como usei no exemplo.
 



Aprenda Ainda Mais


	



	
Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional
    
    
Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

	
Baixe gratuitamente este guia com 15 Dicas de PHP

	

    	
        	
        
    




	

O post Cache com PHP usando APC apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/cache-com-php-usando-apc/feed/
			2
		
		
		1059	
		
		
		http://rberaldo.com.br/bootstrapping-php-arquivo-inicializacao/?utm_source=rss&utm_medium=rss&utm_campaign=bootstrapping-php-arquivo-inicializacao
					http://rberaldo.com.br/bootstrapping-php-arquivo-inicializacao/#comments
		
		
		Sat, 27 Dec 2014 23:11:04 +0000
				
		
		
		
		
		http://rberaldo.com.br/?p=949

					  Neste post vou lhe mostrar como fazer o bootstrapping (ou boot) de sua aplicação PHP. Vamos criar um arquivo de inicialização, que vai ser executado em todas as requisições. Isso vai garantir que a execução ocorra da forma correta, evitando erros. Essa prática é muito importante pois ela garante integridade ao seu sistema. Seguindo esse […]

O post Bootstrapping com PHP e Arquivo de Inicialização apareceu primeiro em Blog do Beraldo.
]]>
										

 
Neste post vou lhe mostrar como fazer o bootstrapping (ou boot) de sua aplicação PHP. Vamos criar um arquivo de inicialização, que vai ser executado em todas as requisições. Isso vai garantir que a execução ocorra da forma correta, evitando erros.
Essa prática é muito importante pois ela garante integridade ao seu sistema. Seguindo esse modelo, é possível centralizar as configurações do sistema. Assim, sempre que precisar alterar uma configuração, basta fazer isso em um único arquivo, e ela se refletirá em toda a aplicação.

Mas o que é Bootstrapping, afinal?
A palavra bootstraping significa um processo de inicialização. É comum falarmos sobre boot do Sistema Operacional. Porém também podemos fazer bootstrap (ou boot) de nossas aplicações, sejam elas em PHP ou em outras linguagens. Vou mostrar um exemplo usando PHP, mas a lógica é a mesma para qualquer outra linguagem.
 
Estrutura da Aplicação
É necessário que todas as requisições à sua aplicação sejam processadas por um único arquivo (geralmente index.php), que, conforme a URL, chama outros scripts ou métodos.
Essa é a abordagem usada nas URLs Amigáveis ou nas Query Strings.
Caso você ainda não use esta técnica, recomendo ler este meu artigo.
Exemplo de Arquivo de Bootstrapping
Vamos criar um script (init.php), que faz basicamente duas coisas:

Define configurações do PHP para toda a aplicação;
Cria constantes que serão usadas na aplicação.

Um simples exemplo é o seguinte:
 

O exemplo é simples. Porém mostra a ideia geral do bootstrapping.
Salve o script como init.php. Dê um require_once nele em seu index.php. Dessa forma, todas as requisições vão passar pelo init.php, garantindo a integridade da aplicação.
Também é possível separar o init.php em arquivos menores. Por exemplo, um para configurações do PHP, outro para configurações de acesso a bancos de dados, outro para SMTP e assim por diante. Apenas lembre-se de dar um require_once em todos eles no init.php.
Melhorando o Script de Bootstrapping
Vamos melhorar o script de bootstrapping, fazendo duas alterações principais:

Passar as configurações do PHP para outro arquivo;
Usar um arquivo .ini para guardar as configurações de banco de dados, SMTP etc

Arquivos .ini são muito usados para configurações. E o melhor: o PHP pode manipular arquivos .ini nativamente.
Crie o arquivo php-config.php (ou outro nome que preferir) com o seguinte conteúdo:

Nesse arquivo você poderá incluir outras configurações do PHP que forem necessárias para seu projeto.
Vamos também criar um arquivo chamado config.ini, com este conteúdo:
; Configurações de banco de dados
[db]
host = "localhost"
user = "usuario"
pass = "senha"
dbname = "nome_do_banco"


; Dados do SMTP
[smtp]
host = "smtp.servidor.com.br"
user = "usuario"
pass = "senha"

ATENÇÃO: O ideal é manter o config.ini fora da pasta pública (geralmente www ou public_html) do seu servidor. Assim não será possível acessar o arquivo pela URL e seus dados estarão seguros.
Precisaremos também de uma função para buscar os dados no arquivo ini. Para isso, vou usar a seguinte função:
function getConfig( $configName )
{
    $configFile = '../config.ini';

    $config = parse_ini_file( $configFile, true );

    list( $section, $param ) = explode( '.', $configName );

    if ( array_key_exists( $section, $config ) )
    {
        if ( array_key_exists( $param, $config[ $section ] ) )
        {
            return $config[ $section ][ $param ];
        }
    }

    return null;
}

A função recebe como parâmetro uma string no formato secao.configuracao e busca o valor correspondente no arquivo ini. Por exemplo, para buscar o valor do parâmetro host da seção db, basta executar getConfig( 'db.host' ).

Se o valor não existir, é retornado null
Para mais detalhes sobre como manipular arquivos ini com PHP, veja este post.
Nosso init.php ficará assim:

Otimização Usando Cache
Acesso a disco é uma tarefa muito lenta, que exige muito da CPU. O tempo de acesso a um dado em disco pode levar até 100.000 vezes mais tempo que um acesso à memória (veja o artigo The Pathologies of Big Data para mais detalhes). Esse número pode variar de diversas formas. Estou citando o pior caso.
É importante fazer cache da dados acessados frequentemente. Se você nunca trabalhou com cache em PHP, sugiro que leia este meu post, onde mostro como usar a biblioteca APC para fazer cache de dados.
Vou rescrever a função getConfig, usando cache. Usarei a técnica do "Carregamento Preguiçoso" (ou Lazy Load, em inglês), de forma que só vou carregar os dados no cache quando for necessário buscar uma informação pela primeira vez. Dessa forma, podemos economizar alguns milissegundos no carregamento da página, caso ela não precise, imediatamente, de algum dado do arquivo de configuração.
Vou incluir alguns dados de debug, para evidenciar a diferença no desempenho. Nosso arquivo index.php ficará assim:

Se você executar o arquivo index.php, verá uma saída parecida com a seguinte:
Buscando no arquivo... 
Tempo total: 0.00008201599121093750
string 'localhost' (length=9)

Buscando no cache... 
Tempo total: 0.00001502037048339844
string 'usuario' (length=7)

Se dividirmos os tempo de execução, veremos que o tempo de acesso ao dado em cache é mais de 5 vezes menor.
Testes feitos, cache aprovado. Vamos retirar os trechos de teste de desempenho e de debug. Nosso index.php ficará desta forma, pronto para ser usado em produção:

Dicas Avançadas
É possivel melhorar bastante esse arquivo de boostrapping, adicionando Autoload e Composer, por exemplo.
Não pretendo entrar em detalhes sobre isso, visto que este post tem o objetivo de mostrar algo simples, porém prático e útil.
Caso queira ver um exemplo mais completo, veja este link (em inglês), onde são usados Autoload e Composer no arquivo de Bootstrapping.
No Curso ULTIMATE PHP, no capítulo final, mostro passo-a-passo como montar uma aplicação utilizando, dentre outras técnicas, o conceito de Bootstrapping. Vou ensinar, em detalhes, como criar uma aplicação segura, estável e eficiente. Clique aqui para conhecer melhor o curso.
 



Aprenda Ainda Mais


	



	
Conheça Dicas FUNDAMENTAIS para programar em PHP de forma Profissional
    
    
Não se considere Programador PHP sem antes ler este guia e adotar estas práticas!

	
Baixe gratuitamente este guia com 15 Dicas de PHP

	

    	
        	
        
    




	

O post Bootstrapping com PHP e Arquivo de Inicialização apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/bootstrapping-php-arquivo-inicializacao/feed/
			4
		
		
		949	
		
		
		http://rberaldo.com.br/a-magia-dos-numeros-de-fibonacci/?utm_source=rss&utm_medium=rss&utm_campaign=a-magia-dos-numeros-de-fibonacci
					http://rberaldo.com.br/a-magia-dos-numeros-de-fibonacci/#respond
		
		
		Mon, 11 Nov 2013 11:18:32 +0000
				
		
		
		
		
		
		
		http://rberaldo.com.br/?p=776

					Na semana passada, foi publicado no Canal do TED Talk no Youtube, o vídeo The magic of Fibonacci numbers, no qual Arthur Benjamin mostra a Sequência de Fibonacci e a magia escondida nela. Se as escolas mostrassem esse lado da Matemática, muitas crianças poderiam se interessar mais por essa área do conhecimento. Vale a pena […]

O post A Magia dos números de Fibonacci apareceu primeiro em Blog do Beraldo.
]]>
										

Na semana passada, foi publicado no Canal do TED Talk no Youtube, o vídeo The magic of Fibonacci numbers, no qual Arthur Benjamin mostra a Sequência de Fibonacci e a magia escondida nela.

Se as escolas mostrassem esse lado da Matemática, muitas crianças poderiam se interessar mais por essa área do conhecimento.
Vale a pena assistir.

A Disney também já falou desse tema, em Pato Donald no País da Matemágica.

O post A Magia dos números de Fibonacci apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/a-magia-dos-numeros-de-fibonacci/feed/
			0
		
		
		776	
		
		
		http://rberaldo.com.br/cc-calculando-hash-md5-usando-a-biblioteca-do-openssl/?utm_source=rss&utm_medium=rss&utm_campaign=cc-calculando-hash-md5-usando-a-biblioteca-do-openssl
					http://rberaldo.com.br/cc-calculando-hash-md5-usando-a-biblioteca-do-openssl/#comments
		
		
		Thu, 29 Nov 2012 13:35:31 +0000
				
		
		
		
		
		
		
		
		
		
		http://rberaldo.com.br/?p=695

					Obter o hash MD5 de uma string é uma tarefa bem simples em algumas linguagens de mais alto nível, como Python, Ruby ou PHP. Porém, em C e C++ não é tão simples. Sem o auxílio de uma biblioteca externa, não podemos calcular hashes, como MD5 ou SHA-1 (exceto se você implementar esses algoritmos, é […]

O post C/C++: calculando hash MD5 usando a biblioteca do OpenSSL apareceu primeiro em Blog do Beraldo.
]]>
										

Obter o hash MD5 de uma string é uma tarefa bem simples em algumas linguagens de mais alto nível, como Python, Ruby ou PHP. Porém, em C e C++ não é tão simples. Sem o auxílio de uma biblioteca externa, não podemos calcular hashes, como MD5 ou SHA-1 (exceto se você implementar esses algoritmos, é claro).
Mostrarei adiante como calcular o hash MD5 de uma string, utilizando a biblioteca OpenSSL, disponível nos sistemas Linux e Unix-Like (em Mac OS X também funciona, apesar de aparecerem warnings dizendo que as funções da OpenSSL são obsoletas).

#include 
#include 
#include 

/**
 * Função que retorna o hash MD5 de uma string
 *
 * @param input String cujo MD5 queremos calcular
 * @param output String onde será escrito o MD5 (deve estar previamente alocada)
 */
char * md5FromString( char *input, char *output )
{
    EVP_MD_CTX mdctx;
    const EVP_MD *md;
    unsigned int output_len, i;
    unsigned char uOutput[EVP_MAX_MD_SIZE];

    /* Initialize digests table */
    OpenSSL_add_all_digests();

    /* You can pass the name of another algorithm supported by your version of OpenSSL here */
    /* For instance, MD2, MD4, SHA1, RIPEMD160 etc. Check the OpenSSL documentation for details */
    md = EVP_get_digestbyname( "MD5" );

    if ( ! md )
    {
        printf( "Unable to init MD5 digest\n" );
        exit( 1 );
    }

    EVP_MD_CTX_init( &mdctx );
    EVP_DigestInit_ex( &mdctx, md, NULL );
    EVP_DigestUpdate( &mdctx, input, strlen( input ) );

    EVP_DigestFinal_ex( &mdctx, uOutput, &output_len );
    EVP_MD_CTX_cleanup( &mdctx );

    // zera a string antes de começar a concatenação
    strcpy( output, "" );
    for(i = 0; i < output_len; i++)
    {
        sprintf( output, "%s%02x", output, uOutput[i] );
    }

    return output;
}


main(int argc, char *argv[])
{
    char output[33]; // 32 caracteres mais um para o \0

    if ( argc != 2 )
    {
        fprintf( stderr, "Erro. Uso: %s \n", argv[0] );
        exit( 1 );
    }

    printf( "MD5( '%s' ) = %s\n", argv[1], md5FromString( argv[1], output ) );

    return 0;
}

Esse código foi adaptado a partir deste post, once encontrei uma forma simples e objetiva de calcular o hash.
Para compilar, é necessário linkar com a biblioteca do OpenSSL, com a opção -lcrypto, conforme o exemplo abaixo:
gcc md5.cpp  -lcrypto -o md5

Para executar, passe como parâmetro a string cujo MD5 deseja-se calcular:
$ ./md5 "string a ser convertida em hash"

Espero que tenham gostado da dica. :)
Dicas de Livros
O livro escrito pelos criadores da linguagem C: C - a Linguagem de Programacao Padrao Ansi - Kernighan, Brian / Ritchie, Dennis M

C - Completo e Total - Schildt, Herbert 

C Como Programar 6 Edicao - Paul; Deitel Harvey Deitel 

Linguagem C - Luís Damas
O post C/C++: calculando hash MD5 usando a biblioteca do OpenSSL apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/cc-calculando-hash-md5-usando-a-biblioteca-do-openssl/feed/
			6
		
		
		695	
		
		
		http://rberaldo.com.br/git-criando-repositorios-remotos/?utm_source=rss&utm_medium=rss&utm_campaign=git-criando-repositorios-remotos
					http://rberaldo.com.br/git-criando-repositorios-remotos/#comments
		
		
		Fri, 23 Nov 2012 08:32:26 +0000
				
		
		
		
		
		
		
		
		
		
		
		http://rberaldo.com.br/?p=646

					Há um tempo, eu mostrei aqui como usar as funcionalidades básicas do Git para controlar versões de softwares. Hoje mostrarei como criar repositórios remotos via SSH. É possível usar repositórios remotos por meio do GitHub ou do Google Code, mas às vezes queremos ter um repositório remoto para uso próprio, que seja fechado, sem que […]

O post Git: criando repositórios remotos apareceu primeiro em Blog do Beraldo.
]]>
										

Há um tempo, eu mostrei aqui como usar as funcionalidades básicas do Git para controlar versões de softwares. Hoje mostrarei como criar repositórios remotos via SSH.
É possível usar repositórios remotos por meio do GitHub ou do Google Code, mas às vezes queremos ter um repositório remoto para uso próprio, que seja fechado, sem que ninguém mais possa ter acesso a ele.
Para isso, você precisará ter acesso a um servidor Linux (ou outro Unix-Like) com servidor SSH, o qual hospedará seus repositórios.






 Servidor Remoto para o repositório Git
Acesse seu servidor via SSH, escolha um diretório para armazenar seus repositórios e cria sub-diretórios para cada repositório. Para isso, faça o seguinte:
Suponha que você escolheu o diretório ~/git (diretório git na sua home) e que vamos criar um repositório chamado exemplo1. Logo, executaremos os seguintes comandos:
mkdir ~/git
cd ~/git
mkdir exemplo1.git
cd exemplo1.git
Com o diretório criado, devemos defini-lo como um repositório remoto, que apenas armazenará arquivos, sem diretório de trabalho (working directory):
git --bare init
Com isso, você já tem um repositório remoto, ao qual pode empurrar código (comando push) e de onde pode fazer clone.






Repositório Git Local
Na sua máquina local, você deve fazer o seguinte:
mkdir meu-repositorio
cd meu-repositorio
git init .
touch README
git add .
git commit -a -m "primeiro commit"
Até aqui nada que não sabíamos: apenas criamos um diretório para ser nosso repositório e o definimos como um repositório. Também criamos um arquivo README, colocando-o no repositório e fazendo um commit.
Agora é necessário especificar que será usado um repositório remoto, onde podemos fazer push dos arquivos. Para isso, usamos o seguinte comando:
git remote add origin ssh://usuario@servidor.com/~/git/examplo1.git
Altere o comando com seu nome de usuário e endereço do servidor. Caso tenha alterado o caminho ao arquivo exemplo1.git, altere-o nesse comando também.
Após isso, basta empurrar os arquivos ao servidor remoto:
git push origin master

A partir daí, você pode fazer alterações e commitá-las, sempre lembrando de fazer um push após os commits:
git push

Caso queira clonar o repositório em outra máquina, basta clonar o repositório, conforme abaixo:
git clone ssh://usuario@servidor/~/git/exemplo1.git

Simples, né? :)
Dicas de Livros
Seguem abaixo alguns links de bons livros sobre Linux:
Linux – Guia Prático – Carlos Morimoto

Certificação Linux Lpi – Nível 1 Exames 101 e 102 – Steven Pritchard, Bruno Pessanha

Certificação Linux Lpi: Nível 2 Exames 201 e 202 – Steven Pritchard, Bruno Gomes Pessanha, Nicolai Langfeldt

Comandos do Linux – Prático e Didático – Marco Agisander Lunardi

Programação Shell Linux – 5º Ed. 2005 – Julio Cezar Neves
O post Git: criando repositórios remotos apareceu primeiro em Blog do Beraldo.
]]>
					
					http://rberaldo.com.br/git-criando-repositorios-remotos/feed/
			12
		
		
		646