Recentemente comprei uma TV Full HD. Obviamente, usarei a TV como monitor para meu Desktop e para meu MacBook Pro. Ao ligar a saída de vídeo do MacBook na TV, eu não obtinha 1080p; em vez disso, ficavam duas faixas pretas laterais, como se não houvesse 1920 pixels de largura. Isso ocorria apenas no modo espelho; no modo estendido, a tela da TV era totalmente preenchida.

Uma solução que encontrei, buscando na Internet, foi manter a tampa do MacBook fechada e usar mouse e teclado externos, via USB ou Bluetooh. Dois problemas: 1) há risco de super aquecimento; 2) eu não podia usar o teclado nativo, nem o trackpad nativo (que acho um dos pontos mais fortes do MacBook, por ser multitouch), além de prejudicar o som dos alto-falantes e do microfone.

A solução que encontrei foi enganar o Mac, fazendo com que ele pense que a tampa está fechada. O truque é simples: imãs.

Antes de detalhar o truque, vale ressaltar que essa gambiarra é para usuários do Lion (Mac Os X 10.7). Quem usa o Snow Leopard (10.6) não precisa disso, pois, ao abrir a tampa do MacBook, estando com um monitor externo ligado, o monitor do MacBook continua desligado.

O Truque

O MacBook é cheio de imãs, alguns para “trancar” a tampa, impedindo que ela se abra sozinha, mas há um especial, responsável por detectar se a tampa está aberta ou fechada. No meu caso (MacBook Pro 13″ de 2011), esse imã está localizado do lado esquerdo e um pouco abaixo da tecla “fn”. Essa localização pode variar conforme o modelo do MacBook.

A gambiarra é colocar o imã sobre a localização citada acima e aguardar a tela do MacBook se desligar. Após isso, basta pressionar a tecla Power e a imagem sairá apenas no monitor externo. Após isso, pode retirar o imã, que tudo continua funcionando, inclusive o teclado e o trackpad do MacBook.

Este vídeo ilustra a ideia:

Essa técnica às vezes falha comigo, mas em poucas vezes. Creio que seja só uma questão de “pegar o jeito”. Ainda estou me especializando nessa técnica… :P

Espero que a dica seja útil a vocês! :)

Abraços 

Inicialmente, eu separaria este texto em vários módulos. Porém, optei por faer algo mais sucinto e criar apenas este módulo – que complementa o Módulo #0, sobre os comandos básicos do Linux.

Neste módulo, serão abordados vários temas da programação em Shell (Bash), desde variáveis e funções, até expansões, expressões regulares etc.

Sem mais delongas, vamos ao que interessa! :)

Sumário

0. Scripts Shell
1. Variáveis
1.1 Variáveis de Ambiente
1.2. Variáveis Especiais
2. Controle de Fluxo
2.1. Condicionais
2.1.1. if
2.1.2. case
2.1.3. select
2.2. Estruturas de Repetição (Loops)
2.2.1. for
2.2.2. while
2.2.3. until…do
2.2.4. break
2.2.5. continue
3. Padrão C/C++ em Expressões “(())”
4. Entrada/Saída
4.1. Redirecionamento
4.2. Usando Pipelines
5. Expansões
5.1. Expansão de Variáveis
6. Parâmetros de linha de comando
7. Definindo Funções
7.1. Retorno de Funções
8. Expressões Regulares em Bash
9. Expressões Matemáticas
10. O Arquivo .bashrc
11. Aliases (Apelidos)
12. Referências

0. Scripts Shell

Antes de mostrar os recursos do shell, vamos dar uma olhada na maneira como devemos criar scripts shell. Isso facilitará a compreensão do restante do artigo.

Todo arquivo com códigos shell deve ter, na primeira linha, o identificador do interpretador a ser utilizado. A “linha mágica” que chama o interpretado bash é:

#!/bin/bash

O mesmo vale para outras linguagens interpretadas, como PHP, Python, Ruby, Perl etc.

Tendo essa linha no início do arquivo, o segundo passo é dar permissão de execução ao arquivo:

$ chmod +x script.sh
<pre>
 
Feito isso, basta executar o script:
 
<pre lang="bash">
$ ./script.sh

Também é possível executar o script usando o comando bash:

$ bash script.sh

Assim não é necessário haver a “linha mágica” no início do script. Também não é preciso dar permissão de execução ao arquivo.

1. Variáveis

O Bash, assim como muitas outras linguagens, possui o conceito de variável. Para definir uma variável:

nome_da_variavel="valor da variável"

É importante ressaltar que não deve haver espaços entre o símbolo de atribuição, o nome da variável e seu valor, para que o bash interprete o comando como atribuição, não chamada de comandos.

Para exibir o valor de uma variável, basta usar echo da seguinte forma:

echo $nome_da_variavel

1.1 Variáveis de Ambiente

As variáveis de ambiente são aquelas conhecidas pelos demais processos (programas em execução). Exemplos destas variáveis são: HOME, PATH, EDITOR, etc.

Para entender o seu uso, vejamos um exemplo: editores de texto, como Vi, possuem diferentes interfaces para os modos texto e gráfico e necessitam saber qual o tipo de terminal o usuário está usando. A variável de ambiente TERM é o modo pelo qual isto pode ser determinado. Outro exemplo são os programas de e-mail que permitem ao usuário editar mensagens com o editor de textos de sua preferência. Como estes programas sabem qual editor usar? É através da variável EDITOR ou VISUAL.

Qualquer variável pode se tornar uma variável de ambiente. Para isto, ela deve ser “exportada”, com o comando export:

export <variável>

Também podemos exportar e atribuir valores a uma variável numa única linha de comando:

export <variável>=<valor>

Podemos verificar quais são as variáveis de ambiente já definidas e seus respectivos valores usando o comando abaixo:

export -p

Para visualizar todas as variáveis basta usar set ou env. Uma importante variável de ambiente é PATH que ajuda o shell a encontrar os comandos que o usuário executa. Todo comando executado é, na realidade, um arquivo. Estes arquivos são chamados executáveis e estão armazenados em vários diretórios como /bin ou /usr/bin. O valor da variável PATH é uma lista de diretórios em que o shell procura toda vez que executamos um comando cujo arquivo não é encontrado no diretório corrente. Assim, não precisamos alterar o diretório de trabalho todas vez que necessitamos executar um comando que se encontra em outro diretório. Basta acrescentar o diretório que contém tal comando à variável PATH. Os nomes dos diretórios na variável são separados pelo caractere dois-pontos (:).

Caso o usuário joao queira adicionar um outro diretório, digamos /home/joao/bin à variável PATH, deve proceder como mostrado a seguir:

$ export PATH=$PATH:/home/joao/bin   # adiciona o diretório
$ echo $PATH                         # verifica
/bin:/usr/bin:/usr/local/bin:/home/joao/bin

O primeiro comando faz com que a variável receba o seu valor atual, concatenado com o nome do diretório a ser acrescentado. Observe que existe um “:” antes do nome do diretório. O segundo comando é utilizado apenas para visualizarmos o resultado do primeiro.

1.2. Variáveis Especiais

Existem algumas variáveis especiais, normalmente utilizadas em script shell, para verificação de parâmetros, valores de retorno de comandos e funções etc.

2. Controle de Fluxo

Controle de fluxo permite interromper, continuar e deslocar o fluxo de execução do script. Isso envolve controles de decisão (condicionais) e estruturas de repetição (loops).

2.1. Condicionais

2.1.1. if

Sintaxe:

if <condicao>
then
    comandos
elif <condicao_2>
    comandos 
else
    comandos 
fi

O if, ao contrário do que ocorre em muitas outras linguagens, testa o retorno de um comando, não uma expressão.

Por exemplo:

if test 5 -lt 7
then
    echo '5 é menor que 7'
fi

Porém, é possível posicionar a expressão entre colchetes, de forma a tornar o if mais parecido com o que acontece em outras linguagens:

if [ 5 -lt 7 ]
then
    echo '5 é menor que 7'
fi

O “-lt” significa “less than“, ou seja, “menor que“, equivalendo ao operador “<".

Outros possíveis operadores são:

Comparação Numérica
-lt: É menor que (LessThan)
-gt: É maior que (GreaterThan)
-le: É menor igual (LessEqual)
-ge: É maior igual (GreaterEqual)
-eq: É igual (EQual)
-ne: É diferente (NotEqual)

Comparação de Strings
=: É igual
!=: É diferente
-n: É não nula (não vazia)
-z: É nula (vazia)

Operadores Lógicos
!: NÃO lógico (NOT)
-a: E lógico (AND)
-o: OU lógico (OR)

Testes em arquivos
-b: É um dispositivo de bloco
-c: É um dispositivo de caractere
-d: É um diretório
-e: O arquivo existe
-f: É um arquivo normal
-g: O bit SGID está ativado
-G: O grupo do arquivo é o do usuário atual
-k: O sticky-bit está ativado
-L: O arquivo é um link simbólico
-O: O dono do arquivo é o usuário atual
-p: O arquivo é um named pipe
-r: O arquivo tem permissão de leitura
-s: O tamanho do arquivo é maior que zero
-S: O arquivo é um socket
-t: O descritor de arquivos N é um terminal
-u: O bit SUID está ativado
-w: O arquivo tem permissão de escrita
-x: O arquivo tem permissão de execução
-nt: O arquivo é mais recente (NewerThan)
-ot: O arquivo é mais antigo (OlderThan)
-ef: O arquivo é o mesmo (EqualFile)

2.1.2. case

Sintaxe:

case <string> in
    opcao1)
        comandos 
        ;;
    opcao2)
        comandos 
        ;;
    *)
        operação padrão
esac

Exemplo:

echo "Digite um número"
read x
 
case "$x" in 
    1)
        echo "Você digitou o número 1"
        ;;
    2)
        echo "Você digitou o número 2"
        ;;
    *)
        echo "Você digitou outro número"
esac

2.1.3. select

Sintaxe:

select <variavel> in <opcao1> <opcao2> ...
do 
    comandos 
done

O comando select é pouco utilizado, mas pode ser muito útil para montar menus. Esse comando exibe um menu, associando cada opção a um número. Quando o usuário seleciona o número da opção, o seu valor é associado à .

Exemplo:

select i in lista_arquivos lista_arquivos_tree
do
    case "$i" in 
        lista_arquivos)
            ls
            ;;
        lista_arquivos_tree)
            ls -R
            ;;
    esac
done

2.2. Estruturas de Repetição (Loops)

Loops são estruturas que permitem fazer iterações sobre algum dado.

2.2.1. for

Sintaxe:

for <var> in <lista>
do
    <comandos>
done

“var” é o nome da variável a ser usada no bloco de repetição. “lista” pode ser uma lista de dados, fixa ou retornada por outro comando (como o ls), uma sequência de números etc.

Exemplos:

Exibe uma sequência de números:

for i in 1 2 3 4 5
do
    echo $i
done

Lista os diretórios e arquivos da raiz do sistema de arquivos:

for i in $(ls /)
do
    echo $i
done

for i in $(seq 1 10)
do
    echo $i
done

for i in $(cat /etc/passwd)
do
    echo $i
done

2.2.2. while

Sintaxe:

while <condicao>
do
    <comandos>
done

Exemplos:

Exibe a sequência de 1 a 10:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Loop infinito que exibe “bash” na tela:

while true
do
    echo 'bash'
done

Lendo strings da entrada padrão:

while read i
do
    echo 'Voce digitou a string: ' $i
done

Exibe as linhas de um arquivo:

cat 'arquivo.txt' | while read i
do
    echo $i
done

Esse exemplo facilita o trabalho com arquivos de texto, cujas linhas possuem espaços. Se fosse usado um loop for nesse caso, seria necessário alterar a variável de ambiente IFS, definindo o separador para quebra de linha (\n).

Uma variação do exemplo anterior é esta:

while read i
do
    echo $i
done < arquivo.txt

A principal diferença entre estes dois últimos exemplos é que, no primeiro, o loop while é executado num subshell, devido ao uso do pipe (|). No segundo exemplo, o while é executado no shell corrente.

Para ilustrar o problema, crie um arquivo chamado “arq.txt” com algumas linhas de texto. Crie este script e execute-o:

#!/bin/bash
 
FILE='arq.txt'
 
total=0
cat $FILE | while read i
do
	total=$((total+1))
done
echo 'Total de linhas: ' $total
 
total=0
while read i
do
	total=$((total+1))
done < $FILE
echo 'Total de linhas: ' $total

O primeiro loop é executado num subshell, fazendo com que a variável “total”, usada no corpo do loop, existe apenas nesse subshell. No segundo caso, isso não ocorre. Isso pode gerar grandes dores de cabeça… (como já ocorreu comigo)

2.2.3. until…do

Sintaxe:

until <condicao>
do
    <comandos>
done

Nesse loop, a condição é oposta à usada no while. Por exemplo:

Com while:

i=0
while [ $i -lt 10 ]
do
    echo $i
    i=$((i+1))
done

Com unitl:

i=0
until [ $i -ge 10 ]
do
    echo $i
    i=$((i+1))
done

Para fazer a mesma coisa, tivemos que usar expressões diferentes na condição do loop.

2.2.4. break

O comando break encerra um loop imediatamente.

Exemplos:

i=0
while true
do
    if [ $i -ge 10 ]
    then
        break
    fi
    i=$((i+1))
done

while read i
do
    if [ $i -eq 0 ]
    then
        break
    fi
done

2.2.5. continue

O comando continue para a execução da iteração corrente e vai para a próxima iteração, mesmo que haja mais comandos no bloco de repetição.

3. Padrão C/C++ em Expressões “(())”

É possível usar o padrão C em expressões do shell, como em condicionais de estruturas de controle. Para isso, basta colocar a expressão entre dois parênteses.

Exemplos;

i=0
while (( i < 10 ))
do
    echo $i
    ((i++))
done

É possível, inclusive, usar o padrão do loop for do C:

for ((i = 0; i < 10; i++)
do
    echo $i
done

4. Entrada/Saída

Existem três dispositivos principais, que sempre estão abertos, que merecem destaque:

stdin (standard input): entrada padrão. Corresponde, em geral, ao teclado;
stdout (standard output): saída padrão. Corresponde, em geral, à tela do terminal;
stderr (standard error): saída padrão de erros. Corresponde, em geral, à tela do terminal, também.

Esses três dispositivos estão em /dev e estão sempre disponíveis. Quem programa em C, sabe muito bem disso, pois já deve ter usado stdin, stdout e stderr junto com fprintf, fread, fwrite e semelhantes; esses três dispositivos comportam-se como arquivos comuns, sempre abertos e que não devem ser fechados.
É possível brincar com eles no próprio shell. Experimentem dar um cat em /dev/stdin para ver o que acontece. :)

4.1. Redirecionamento

A entrada de um programa consiste nos dados que lhe são passados inicialmente, os quais são necessários para a execução do programa. A entrada de um programa pode vir do teclado ou de um arquivo, por exemplo. Argumentos passados à comandos constituem a sua entrada.
A saída é constituída pelas informações geradas pelo programa, ou seja, o resultado de sua execução. A saída pode ser mostrada na tela ou gravada em um arquivo de registro.

Muitos comandos do Linux têm sua entrada configurada para a entrada padrão e sua saída para a saída padrão. A entrada padrão é o teclado e a saída padrão é o monitor. Vejamos um exemplo usando o comando cat, que lê dados de todos os arquivos passados como parâmetros e os envia diretamente para a saída padrão. Usando o comando abaixo, veremos o conteúdo do arquivo “arq1″ seguido pelo conteúdo de “arq2″.

$ cat arq1 arq2

Entretanto, se nenhum nome de arquivo for dado como parâmetro, o comando cat lê dados da entrada padrão e os envia para a saída padrão. Para interromper, deve-se pressionar as teclas ctrl e d simultaneamente (ctrl+d).

$ cat 
Ola! Tem alguem ai?  # usuário 
Ola! Tem alguem ai?  # eco do sistema 
Ate mais!            # usuário 
Ate mais!            # eco do sistema
              # usuário pressiona ctrl+d

Como podemos ver, cada linha que o usuário digita é imediatamente ecoada pelo comando cat. Aqui um outro exemplo: o comando sort lê dados da entrada padrão – a menos que algum arquivo seja dado como parâmetro – e ordena os dados, enviando-os para a saída padrão:

$ sort 
bananas     # usuário
peras       # usuário
goiabas     # usuário
            # ctrl+d
bananas     # eco do sistema
goiabas     # eco do sistema
peras       # eco do sistema

Digamos que queremos enviar a saída do comando sort para um arquivo, gravando os dados digitados anteriormente. O shell nos permite redirecionar a saída para um arquivo usando o símbolo “>”.

$ sort > lista
bananas  # usuário
peras    # usuário
goiabas  # usuário
         # ctrl+d

Como se pode ver, o resultado do comando sort não é mostrado imediatamente após o se digitar ctrl+d. Ao invés disso, é salvo em um arquivo chamado “lista”. Vejamos o conteúdo desse arquivo:

$ cat lista
bananas
goiabas
peras

Com o redirecionamento de saída, temos uma maneira simples de criar arquivos de texto. Para isso, utilizamos o comando cat para ler a entrada padrão (teclado) e redirecionamos sua saída para um arquivo.

Ao usar “>” para redirecionar a saída para um arquivo, estamos realizando um redirecionamento destrutivo, ou seja, o comando “ls > lista” sobrescreve o conteúdo do arquivo “lista”. Isto é equivalente a dizer que todo o conteúdo anterior de “lista” é apagado.
Se, ao invés disso, redirecionarmos usando “>>”, a saída será concatenada ao final do arquivo e o conteúdo (se houver) de “lista” será preservado. Para melhor entender isso, experimente executar a seguinte seqüência de comandos:

ls >> listagem
ls >> listagem
less listagem

O redirecionamento neste exemplo, diferentemente do exemplo anterior, é denominado redirecionamento não-destrutivo.

4.2. Usando Pipelines

Nos exemplos para o filtro sort, os dados de entrada eram digitados pelo usuário ou estavam gravados em um arquivo. O que aconteceria se quiséssemos ordenar dados vindos do saída de outro comando ? Para listar os arquivos do diretório corrente em ordem alfabética invertida devemos fazer com que a saída do comando ls seja ordenada pelo comando sort. Usando a opção “-r”, este comando ordena os dados na ordem inversa.

$ ls
historia  notas     tese      testes 
$ ls > lista 
$ sort -r lista 
testes
tese
notas
lista                             # observe esse nome de arquivo
historia

Aqui, salvamos a saída do comando ls em um arquivo (lista) e usamos sort com a opção “-r”. Porém, isso faz com que tenhamos um arquivo temporário para armazenar os dados. Assim, toda vez que fizermos isso, teremos que, em seguida, remover o arquivo lista. A solução é usar o que chamamos de pipeline, outro recurso do shell que nos permite conectar vários comandos usando um pipe, onde a saída do primeiro comando é enviada diretamente à entrada do segundo e assim por diante no caso de haver mais de dois comandos conectados por pipes.

No nosso caso, queremos enviar a saída do comando ls para a entrada do comando sort. O símbolo “|” (barra vertical) é usado para criar um pipe:

$ ls | sort -r 
testes
tese
notas
historia

Note que neste exemplo, nenhum nome de arquivo é usado na linha de comando, diferentemente do exemplo anterior que fazia o uso do arquivo intermediário lista. Outra diferença é que o nome desse arquivo intermediário aparece no resultado do penúltimo exemplo, mas não neste último. O comando é mais curto, mais fácil de digitar e o resultado é mais adequado pois não inclui nomes de arquivos intermediários.

É importante observar que o redirecionamento e o uso de pipes são características do shell e não dos comandos em si. É o shell quem provê a sintaxe dos símbolos “>”, “<" e "|". Logo, se você criar um programa que utilize entrada de dados via stdin, poderá usar redirecionamento para especificar uma entrada para o seu programa.

5. Expansões

Expansões são caracteres, ou uma sequência deles, que expressa outro significado. O intuito disso é facilitar e padronizar comandos.

~: path à home do usuário corrente
~user: path à home do usuário “user”
{a,b,c}: presença do caractere “a”, “b” ou “c”. Podem ser usadas strings em vez de simplesmente caracteres.

Exemplos:

ls ~

ls ~root

ls /dev/std{in,out,err}

5.1. Expansão de Variáveis

6. Parâmetros de linha de comando

Assim como em outras linguagens, é possível passar parâmetros para scripts shell. Para isso, usam-se as variáveis $1, $2, … A variável $0 contém o comando chamado via linha de comando.

Exemplo:

Crie um arquivo “test.sh” com este conteúdo:

#!/bin/bash
 
echo '$0 = '$0
echo '$1 = '$1
echo '$2 = '$2

Veja as saídas das execuções abaixo:

$ ./test.sh 
$0 = ./test.sh
$1 = 
$2 = 
$ ./test.sh um
$0 = ./test.sh
$1 = um
$2 = 
$ ./test.sh um dois
$0 = ./test.sh
$1 = um
$2 = dois

7. Definindo Funções

Sintaxe:

function nome_da_funcao()
{
     <comandos>
}

Para chamar a função:

nome_da_funcao
 
# caso haja parâmetros
nome_da_funcao param1 param2 ...

Exemplo:

#!/bin/bash
 
function imprime()
{
	echo "Sou a função '${0}'"
	echo "Param 1: ${1}"
	echo "Param 2: ${2}"
	echo "Lista de parâmetros: ${*}"
}
 
imprime um dois tres quatro

Da mesma forma como foram usados $0, $1 etc anteriormente, aqui essas variáveis são usadas para retornar os parâmetros da função. Logo, percebe-se que, dentro de funções, não é possível acessar parâmetros de script, a menos que eles sejam passados por parâmetro para a função.

7.1. Retorno de Funções

Antes de tudo, é preciso diferenciar retorno de função e saída de função. Por exemplo, ao se executar o comando “cat /etc/passwd”, a saída é o conteúdo do arquivo; o retorno é 0 (ou outro valor, caso ocorra erro). O retorno de uma função shell é um valor inteiro, normalmente utilizado para definir o status da função, ou seja, se ocorreu algum erro ou e ela foi executada corretamente.

Para obter o valor de retorno de uma função, usa-se a variável “$?”. Ela exibe o retorno do último comando executado. Por exemplo:

$ cat /etc/passwd
echo $?

Para retornar valor (status) numa função, usa-se o comando return.

Exemplo:

#!/bin/bash
 
function retorna()
{
    echo "sou um valor"
    return 42
}
 
valor=$(retorna)
echo $?
echo $valor

Ao se executar a função, sua saída será “sou um valor”; seu retorno será 42.

Em shell, considera-se o valor 0 como execução bem sucedida. Qualquer outro valor representa erro. É por isso que recomenda-se que toda função main de um programa em C retorne o valor 0, desde que não ocorra algum erro.

8. Expressões Regulares em Bash

Expressões regulares em shell podem ser usadas em comparações (if’s), por exemplo. Em if’s, usa-se o operador “=~” para realizar comparações usando ER’s:

s="bash"
if [[ "$s" =~ ^b ]]
then
    echo 'começa com b'
fi

9. Expressões Matemáticas

O bash não trabalha com expressões matemáticas tão facilmente. Existe o comando “let”, que permite realizar expressões matemáticas, mas é mais comum se usar a sintaxe semelhante ao C, utilizando dois parênteses:

$ a=$((1 + 1))
$ ((i++))
$ x=$((x*2))
...

10. O Arquivo .bashrc

Na home dos usuários (~), é comum haver o arquivo .bashrc (o ponto no início indica que o arquivo é oculto). Esse arquivo é sempre executado quando se abre um shell. Nele, constam diversas configurações, como definição de variáveis de ambientes, definição de aliases etc. Você pode editar esse arquivo (ou criá-lo, caso não exista):

$ vim ~/.bashrc

É possível usar outros editores, não apenas o vim.

11. Aliases (Apelidos)

Algumas vezes usamos comandos que necessitam de várias opções e argumentos. Para amenizar o trabalho de digitarmos repetidamente estes comandos o bash oferece um recurso chamado alias com o qual podemos definir sinônimos ou “apelidos” para um comando. Um alias pode ser definido na linha de comando da seguinte forma:

alias <nome>=<comando>

Observe que não pode haver espaços em branco antes ou depois do “=”.

Esta sintaxe indica que nome é um “alias” (apelido) para comando. Toda vez que digitarmos o comando “nome”, o bash o substituirá por “comando”.

Exemplo:

$ alias lf='ls -F'

Isso fará o shell executar “ls -F” toda vez que usarmos “lf” na linha de comando. Ou seja, o que o alias faz na verdade é substituir a palavra “lf” por “ls -F”. Observe neste exemplo, existe um espaço em branco entre ls e -F. Sempre que houver espaços em branco na definição de um campo, todo o campo deve ser digitado entre aspas simples (‘) ou duplas (“).

É possível definir aliases em seu .bashrc, para que eles estejam sempre disponíveis na sua sessão.

12. Referências

Linux Básico:
http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico/ ou http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxBasico.pdf

Linux Avançado

http://www.inf.ufpr.br/nicolui/Docs/Livros/LinuxAvancado.pdf

Canivete Suiço do Shell (Bash)

http://aurelio.net/shell/canivete/

Livro Shell Script Profissional (Livro físico):

http://www.shellscript.com.br/

Pretendo mostrar o básico sobre o Git, como criar repositórios, fazer commits, voltar para versão anterior (reverter). Além disso, citarei alguns links interessantes com mais conteúdo sobre Git.

É muito comum trabalhar com repositórios remotos, hospedados em servidores como o GitHub. Outra forma é trabalhar com um repositório local, quando estamos fazendo um trabalho de faculdade, desenvolvendo um software etc.

Vou mostrar como criar repositórios locais. Tutoriais sobre GitHub já existem aos montes pela Internet. O próprio site do GitHub já mostra como proceder para usar repositórios remotos.

Para iniciar um repositório local:

$ git init

Esse comando inicia um repositório no diretório corrente. Um diretório oculto, chamado .git, será criado com as informações do repositório.

A qualquer momento é possível executar o comando abaixo, que exibe o status do repositório, ou seja, mostra se há arquivos modificados, arquivos prontos para serem “commitados” etc:

$ git status

Para ver o log de commits, usa-se o comando:

$ git log

Para adicionar arquivos ao controle de versão:

$ git add arquivo1.txt arquivo2.txt [...]

Outra possibilidade é adicionar todos os arquivos do diretório atual:

$ git add .

Após adicionar um arquivo ao controle de versão, é necessário fazer o commit dele:

$ git commit -m "mensagem do commit" arquivo1.txt arquivo2.txt [...]

Também é possível usar a opção -a, que faz o commit de todos os arquivos que foram modificados em relação ao último commit:

$ git commit -a -m "mensagem do commit"

O Git é um sistema de controle de versão. Logo, é evidente que é possível desfazer mudanças. Se você percebeu que cometeu um erro em um arquivo commitado (ou um cliente odiou a última modificação que você fez no site dele :P ), é possível reverter o repositório para a versão anterior. Para isso, usa-se o comando:

$ git revert HEAD

Esse comando cria um novo commit, que ignora o último commit realizado, voltando o repositório à versão anterior ao commit problemático.

Para remover um arquivo do controle de versão:

$ git rm arquivo1.txt arquivo2.txt [...]

Lembrando que sempre é necessário fazer commit após adição ou remoção de arquivos do controle de versão:

Caso você tenha modificado um arquivo – sem dar commit nele – e deseja voltar à versão dele para a versão do commit mais recente, execute:

$ git reset --hard

Isso também vale para quando se remove um diretório e se deseja obtê-lo novamente do repositório.

Abaixo estão alguns links muito bons sobre Git, que me auxiliaram bastante quando comecei a mexer com esse sistema de controle de versão.

Git by examples
http://sysmonblog.co.uk/misc/git_by_example

Video-aula sobre git
http://vimeo.com/20299469

Git para quem conhece SVN
https://git.wiki.kernel.org/index.php/GitSvnCrashCourse

Documentação e Tutorial oficial do Git:
http://git-scm.com/documentation

E para aqueles que insistem em usar um “Sistema Operacional” de segunda linha… :P

Git no Windows
http://nathanj.github.com/gitguide/tour.html

Não adianta querer programar usando Shell sem conhecer os comandos básicos do Linux. Por isso o primeiro módulo do “curso” abordará os comandos básicos do Linux, que são fundamentais para a construção dos scripts.

Vamos analisar apenas alguns comandos, os mais conhecidos e usados, juntamente com algumas de suas opções. A maioria dos comandos permitem o uso de inúmeras opções, não sendo possível abordar todos elas neste texto.

Antes de iniciarmos, vale lembrar que os manuais de todos os comandos podem ser lidos usando o comando man nome_do_comando, por exemplo:

$ man echo

A maioria dos comandos também têm a opção -h, ou –help, que lista os parâmetros aceitos pelo programa.

Os comandos estão ordenados alfabeticamente, sem levar em consideração relevância ou complexidade de utilização.

Sumário

awk
cat
cd
chmod
cut
date
diff
echo
find
grep
head
kill
ls
printf
rev
scp
sed
seq
sort
ssh
tac
tail
top

awk

O AWK é uma linguagem de programação para processamento de textos. Ao lado do comando SED, é capaz de realizar muitos truques.

Um post exclusivo sobre AWK pode ser visto aqui:

http://www.rberaldo.com.br/blog/tutorial-awk

cat

Exibe o conteúdo de um arquivo.

Opções:
-n : numera as linhas

Exemplos:

$ cat /etc/hostname 
orion

$ cat -n /etc/hostname 
     1	orion

cd

Muda o diretório de trabalho, ou seja, entra em um determinado diretório.

Exemplo:

$ cd /tmp

$ cd ~

chmod

O chmod (change mode) muda as permissões de um arquivo ou diretório. O sistema de permissões em sistemas Unix-Like, como Linux ou Mac OS, é um dos pontos fortes desses sistemas. Porém, infelizmente, poucos usuários realmente sabem usá-lo.

Um post exclusivo ao chmod pode ser lido aqui:

http://www.rberaldo.com.br/blog/chmod-permissoes-em-sistemas-linux-e-unix-like

cut

Separa trechos ou campos de uma linha, por meio de um delimitador. Também trunca textos, exibindo apenas um número específico de caracteres.

Opções
-d : define o delimitador
-f : define o(s) campo(s) a ser(em) exibido(s)
-c : número do caractere a ser exibido ou intervalo de caracteres

Exemplos:

$ echo "um:dois:tres:quatro" | cut -d: -f 2
dois

$ echo "um:dois:tres:quatro" | cut -d: -f 2,3
dois:tres

Também é possível definir intervalo de valores para a opção -f:

$ echo "um:dois:tres:quatro" | cut -d: -f 1-3
um:dois:tres

$ echo "um:dois:tres:quatro" | cut -d: -f 2-
dois:tres:quatro

$ echo "1234567890" | cut -c 7
7

$ echo "1234567890" | cut -c 1,3,5
135

beraldo@orion:~$ echo "1234567890" | cut -c 1-7
1234567

$ echo "1234567890" | cut -c 8-
890

beraldo@orion:~$ echo "1234567890" | cut -c -5
12345

date

Mostra a data atual ou uma data específica, com diversas opções para formatação da data.

Opções:
-d : especifica a data (Ex: tomorrow, 5 days ago)
+%? : define o padrão de formatação da data. A lista de opções pode ser lida no manual do comando (man date).

Exemplos:

$ date
Dom Mai  1 20:05:47 BRT 2011

$ date -d "yesterday"
Sáb Abr 30 20:05:59 BRT 2011

$ date -d "2 days ago"
Sex Abr 29 20:06:10 BRT 2011

beraldo@orion:~$ date -d "2 days"
Ter Mai  3 20:06:13 BRT 2011

$ date +"%d/%m/%Y"
01/05/2011

$ date -d "30 days" +"Daqui 30 dias será %d/%m/%Y"
Daqui 30 dias será 31/05/2011

diff

Exibe as diferenças entre dois arquivos.

Opções:
-i : case-insensitive (indiferente a maiúsculas e minúsculas)
-y : exibe as diferenças lado a lado
-E : ignora diferenças no tamanho do TAB
-B : ignora linhas vazias
-b : ignora quantidade de espaços

Outros comandos semelhantes muito úteis: vimdiff e diff3

O comando diff é muito útil para encontrar cópias de trabalhos de faculdade, por exemplo. :P

echo

Exibe um texto na saída padrão.

Opções:
-n : não pula linha no final do texto
-e : interpreta caracteres de escape

Exemplos:

$ echo "sou \n um \n texto"
sou \n um \n texto

$ echo -e "sou \n um \n texto"
sou 
 um 
 texto

find

Localiza arquivos no sistema de arquivos.

Esse comando possui diversas opções e truques. Por isso, merece um post específico para ele. Um post muito bom sobre o find pode ser encontrado aqui:

http://gerencievocemesmo.com.br/site/?p=56

grep

Localiza padrões dentro de um ou mais arquivos. A busca é feita usando Expressões Regulares.

Opções:
-i : case-insensitive
-v : inverte o critério de busca
-r : recursivo, busca em subdiretórios também
-n : mostra, também, o número da linha
-c : conta o número de linhas que casaram com o padrão
-l : exibe só o nome do arquivo onde o padrão foi encontrado
-A N : mostra N linhas após a linha onde o padrão foi encontrado
-B N : mostra N linhas antes da linha onde o padrão foi encontrado
-C N : mostra N linhas antes e depois da linha onde o padrão foi encontrado

$ seq 10 | grep -A2 -B3 "5"
2
3
4
5
6
7

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep "^[a-z]"
olá
sou
teste
para
grep

$ echo -e "olá\nsou\n1\nteste\npara\ngrep" | grep -v "^[a-z]"
1

Para usar todos os recursos das Expressões Regulares, use egrep em vez de grep, o que permite usar grupos, quantificadores “+” e “{quantificador}”.

head

Mostra o início de um arquivo. O limite pode ser estabelecido em número de linhas ou caracteres. É o inverso do comando tail.

Opções:
-n N : exibe as N primeiras linhas
-c N : exibe os N primeiros caracteres

Exemplos:

$ echo -e "olá, sou\num teste\npara o\ncomando head" | head -n 2
olá, sou
um teste

$ echo -e "ola, sou\num teste\npara o\ncomando head" | head -c 7
ola, so

kill

O comando kill “mata” processos, ou seja, encerra, ou força o encerramento, de um programa.

Opções:
-9 : força o encerramento da execução de um processo
-1 : mata todos os processos que o usuário pode matar

Exemplos:

Força o encerramento do processo 1234:

$ kill -9 1234

Encerra a sessão do usuário, ou seja, força o encerramento de todos os seus processos:

$ kill -1 -9

Os IDs dos processos (PID – Process ID) podem ser encontrados usando o comando ps, que é o gerenciador de processos. Com as opções “ux”, listam-se os processos do usuário. Com grep podemos filtrar a saída pelo processo desejado:

$ ps ux | grep skype
beraldo   2267  1.0  2.0 281508 82968 ?        Sl   09:58   0:41 skype
beraldo   5672  0.0  0.0  10128   848 pts/0    S+   11:04   0:00 grep --color=auto skype

O skype é o processo 2267. Para forçar seu encerramento, fazemos:

$ kill -9 2267

Como lição de casa, vale ler os manuais dos comandos killall e pkill. :)

ls

Lista o conteúdo de um diretório.

Opções:
-a : lista arquivos e diretórios ocultos
-l : mostra diversos atributos dos arquivos e diretórios, como data de criação, dono, permissões etc
-R : lista o conteúdo recursivamente

Exemplos:

$ ls

$ ls -a

$ ls -l

$ ls -la

$ ls -laR

printf

Exibe um texto na tela, com várias opções de formatação, semelhante à função printf(), da linguagem C.

As opções de formatação são praticamente as mesmas da linguagem C. A lista completa pode ser vista no manual (man printf).

Exemplos:

$ printf "%x\n" 15
f

$ printf "%o\n" 7
7

$ printf "%o\n" 8
10

$ printf "%05d\n" 70
00070

$ printf "%.2f\n" 70
70,00

rev

Esse comando inverte uma string.

Exemplos:

$ echo "texto" | rev
otxet

$ echo "duh" | rev
hud

scp

Copia arquivos e diretórios via ssh, ou seja, cópia segura entre máquinas remotas.

Opções:
-r : cópia recursiva

Sintaxe:

$ scp [opções] maquina:origem destino
$ scp [opções] origem maquina:destino

Exemplos:

$ scp 192.168.0.100:~/arquivo.txt .

$ scp arquivo.txt 192.168.0.102:~

sed

Linguagem para edição de arquivos e textos. Veja um post exclusivo a ela aqui:

http://www.rberaldo.com.br/blog/o-comando-sed-do-linux/

seq

Exibe uma sequência de números.

Opções:
-s : separador (padrão “\n”)
-f : formato (padrão “%g”)

Exemplos:

$ seq 3
1
2
3

$ seq 3 5
3
4
5

$ seq 3 2 10
3
5
7
9

$ seq 10 -2 0
10
8
6
4
2
0

$ seq -s, 10 -2 0
10,8,6,4,2,0

$ seq -s, -f"%04g" 10 -2 0
0010,0008,0006,0004,0002,0000

sort

Ordena linhas de um texto, alfabética ou numericamente.

Opções:
-n : ordena numericamente
-r : ordena inversamente (de Z para A e de 9 para 1)
-f : case-insensitive
-k N : ordena pela coluna N do texto
-t : separador de coluna para a opção -k (padrão TAB)
-o : define um arquivo para a saída do comando

Exemplos:

$ echo -e "um\ndois\ntres\nquatro" | sort
dois
quatro
tres
um

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2
um	dois
tres	quatro

$ echo -e "um\tdois\ntres\tquatro" | sort -k 2 -r
tres	quatro
um	dois

$ echo -e "1\n10\n100\n2\n20\n200" | sort 
1
10
100
2
20
200

$ echo -e "1\n10\n100\n2\n20\n200" | sort -n
1
2
10
20
100
200

ssh

O SSH (Secure Shell) realiza acesso remoto a outras máquinas Linux. Um post exclusivo a SSH pode ser lido aqui:

http://www.rberaldo.com.br/blog/usando-o-ssh

tac

Inverso do comando cat. Exibe o conteúdo de um arquivo do fim para o início.

tail

Exibe o fim de um texto, exatamente o oposto do comando head

Opções:
-n N : número de linhas a exibir
-c N : número de caracteres a exibir

Exemplos semelhantes ao do comando head.

top

O comando top exibe os processos atualmente em execução. É semelhante ao ps, citado na seção do comando kill, mas atualiza-se automaticamente, além de possuir várias opções de ordenação.

Exemplo:

$ top

O comando “htop” é mais completo e user-friendly, mas normalmente não vem instalado nas distros Linux. É possível instalá-lo via gerenciador de pacotes. Por exemplo, em sistemas baseados em Debian:

# apt-get install htop

O Python possui bibliotecas para implementação de servidores WEB simples. Há versão de apenas uma thread (atende uma requisição por vez) ou multi-thread (atende diversas requisições simultaneamente).

Os exemplos abaixo apenas enviam al cliente uma mensagem “INICIO”, esperam 2 segundos, e enviam outra mensagem, “FIM”. A espera por 2 segundos será útil apenas para enfatizar a diferença entre as versões monothread e multi-thread.

Os códigos funcionam em qualquer Sistema Operacional com Python instalado, mas os exemplos de execução que mostrarei são voltados para Linux ou Mac OS, onde há um terminal com suporte a bash e curl. Porém, nada impede que os testes sejam feitos em navegadores.

Versão simples, com apenas uma thread, ou seja, atende apenas uma requisição por vez:

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

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import BaseHTTPRequestHandler
import urlparse
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class GetHandler(BaseHTTPRequestHandler):
 
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write( "INICIO\n" )
        time.sleep( 2 )
        self.wfile.write( "FIM\n" )
 
if __name__ == '__main__':
    from BaseHTTPServer import HTTPServer
    server = HTTPServer(('localhost', PORT), GetHandler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

Para executar:

$ python monothread.py

Ou, caso você dê permissão de execução ao script:

$ ./monothread.py

Para enviar solicitações ao servidor, sugiro este comando:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Você verá que cada requisição será atendida de cada vez. Ou seja, ao terminar a requisição 1, inicia-se o atendimento à requisição 2, mesmo que todas as 5 requisições tenham sido feitas “ao mesmo tempo” (note o & indicando que o cURL rodará em background).
Você verá que cada par “INICIO” e “FIM” aparecerão sequencialmente, mostrando que cada requisição é atendida individualmente.

Versão multi-thread, ou seja, atende várias requisições simultaneamente:

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

#!/usr/bin/env python
# coding: utf-8
 
from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
from SocketServer import ThreadingMixIn
import threading
import time
 
# Porta onde o servidor rodará
PORT = 8888
 
class Handler(BaseHTTPRequestHandler):
 
    def do_GET(self):
 
        self.send_response(200)
        self.end_headers()
        self.wfile.write('INICIO\n')
        time.sleep( 2 )
        self.wfile.write('FIM!\n')
        return
 
class ThreadedHTTPServer(ThreadingMixIn, HTTPServer):
    """Handle requests in a separate thread."""
 
if __name__ == '__main__':
    server = ThreadedHTTPServer(('localhost', PORT), Handler)
    print 'Starting server, use <Ctrl-C> to stop'
    server.serve_forever()

O procedimento para execução é o mesmo do anterior. Para testar, vamos usar o mesmo loop de requisições:

$ for (( i = 0; i < 5; i++ )) ; do curl http://localhost:8888 & done;

Dessa vez, todas as requisições serão atendidas ao mesmo tempo. A palavra “INICIO” aparecerá 5 vezes de uma só vez, e os logs de requisição do servidor aparecerão os 5 de uma só vez.

Os códigos acima foram adaptados deste link:
http://blog.doughellmann.com/2007/12/pymotw-basehttpserver.html

Em Linux, há programas gráficos para isso, mas a linha de comando é interessante pois permite converter vários arquivos de uma só vez, automaticamente. Por isso mostrarei como executar essa ação via Terminal. Além disso postarei um Shell Script completo para isso.

É necessário ter instalados os pacotes mplayer e mencoder para executar os comandos.

Supondo que queremos converter o arquivo video.avi em video.mp4, executaremos:

mencoder video.avi -o video.mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

E este é um Shell Script para facilitar a tarefa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#!/bin/bash
#
# Converte arquivos AVI em MP4
#
# Sintaxe: avi2mp4.sh arquivo.avi
#
# Ao fim da execução, será gerado o arquivo arquivo.mp4
 
if [ $# -ne 1 ]
then
	echo "Erro de sintaxe."
	echo "Uso: avi2mp4.sh <video.avi>"
fi
 
FILE=$1
BASENAME=${FILE%.*}
 
mencoder "${FILE}" -o "${BASENAME}".mp4 -oac copy -ovc lavc -lavcopts vcodec=mpeg1video -of mpeg

A extensão MySQLi necessita do servidor MySQL 4.1 ou superior.

Vale lembrar que há boatos de que a extensão MySQL deixe de existir no PHP 6. Logo, seja isso verdade ou não, é preferível usar MySQLi.

Vou mostrar aqui a forma de se trabalhar com a extensão MySQLi.

Para realizar a conexão com a base de dados, basta isto:

$MySQLi = new mysqli( 'servidor', 'usuario', 'senha', 'nome_da_db' );

Por exemplo:

$MySQLi = new mysqli( 'localhost', 'root', 'passwd', 'test' );

Se a conexão for bem sucedida, $MySQLi será um objeto, que será usado para consultas posteriores e outras ações com a base de dados.

Para realizar uma consulta, por exemplo, basta usar o método query() e percorrer com fetch_assoc(), muito semelhante ao que se faz usando a extensão mysql:

$exec = $MySQLi->query( 'select dados from tabela' );
 
while ( $f = $exec->fetch_assoc() )
{
    print_r( $f );
}

A lista completa de propriedades e métodos da classe MySQLi pode ser encontrada no link abaixo:

http://php.net/manual/pt_BR/book.mysqli.php

Por exemplo: em vez de executar:

INSERT INTO tabela(numero) VALUES (1);
INSERT INTO tabela(numero) VALUES (2);
...

Poderíamos executar:

INSERT INTO tabela(numero) VALUES (1), (2);

Vou mostrar uma maneira simples de se fazer isso dinamicamente, com quantidade indeterminada informações, que podem vir de qualquer tipo de fonte de dados.

Vamos considerar um array com números inteiros, de 1 a 10:

$valores = range( 1 , 10 );

Para inserir isso num banco de dados, muitos fariam isto:

$valores = range( 1 , 10 );
for ( $i = 0; $i < count( $valores ); $i++ )
{
    $DB->query( 'INSERT INTO tabela(numero) VALUES(' . $valores[ $i ] . ')' );
}

Isso funciona. Mas é lento e sobrecarrega o servidor. Imaginem um array com 100 mil valores.

O correto é gerar a string SQL com todos os valores a serem inseridos, separados por vírgula, de forma a executar a consulta apenas uma vez. Logo, podemos fazer isto:

$valores = range( 1 , 10 );
$sql = sprintf( 'INSERT INTO tabela(numero) VALUES (%s)', implode( '), (' , $valores ) );
$DB->query( $sql );

Se dermos um echo em $sql, teremos como saída:

INSERT INTO tabela(numero) VALUES (1), (2), (3), (4), (5), (6), (7), (8), (9), (10)

Dessa forma só se executa a SQL uma vez, tornando a execução bem mais rápida.

Normalmente são usados em sistemas desktop, mas é possível usá-lo para qualqquer tipo de aplicação. O PHP possui uma função nativa destinada ao processamento desse tipo de arquivo.

Antes de tudo, é bom entender a formatação de um arquivo INI. O artigo sobre arquivos INI da Wikipedia explica muito bem essa formatação. Além disso, se você está lendo este post é porque tem familiaridade com o PHP e, consequentemente, com o arquivo php.ini, o arquivo de configuração do PHP, que é um arquivo INI.

Vamos considerar o arquivo INI abaixo, nomeado como config.ini.

; comentário da seção 1
[section 1]
config1 = "valor 1"

; comentário da seção 2
[section 2]
config2 = "valor 2"

Usaremos a função parse_ini_file, do PHP, para processarmos esse arquivo.

O protótipo da função é:

array parse_ini_file ( string $filename [, bool $process_sections = false]);

O primeiro parâmetro é o nome do arquivo a ser processado. O segundo, opcional, define se devem ser processadas as seções dos arquivos. O padrão é false. Caso passe-se o valor true, o array de retorno será multidimensional, sendo cada dimensão correspondente a cada seção do arquivo .ini.

Isso ficará mais claro ao rodarmos este script:

1
2
3
4
5

$config = parse_ini_file( 'config.ini' );
print_r( $config );
 
$configWithSections = parse_ini_file( 'config.ini', true );
print_r( $configWithSections );

A saída é:

Array
(
    [config1] => valor 1
    [config2] => valor 2
)
Array
(
    [section 1] => Array
        (
            [config1] => valor 1
        )

    [section 2] => Array
        (
            [config2] => valor 2
        )

)

O primeiro print_r exibe o array unidimensional, com todas as seções numa única dimensão do array. O segundo print_r exibe o array multidimensional, resultante do processamento que leva em conta as seções do arquivo .ini.

Com isso fica simples criar arquivos de inicialização que buscam configurações básicas em arquivos .ini.

Porém, tome cuidado ao usar arquivos .ini com informações sensíveis, como configurações de acesso a bancos de dados. Arquivos .ini podem ser acessados via URL, sendo possível visualizar seu conteúdo pelo navegador. Logo, opte por manter um arquivo ini fora do diretório público de sua aplicação (geralmente o public_html).

O setlist foi muito bom, mas sempre pensamos “Bem que poderia ter tocado aquela…“. História longa, discografia extensa. Difícil agradar a todos.

Sem mais delongas, eis o setlist:

1. Satellite 15… The Final Frontier
2. El Dorado
3. 2 Minutes to Midnight
4. Coming Home
5. Dance of Death
6. The Trooper
7. The Wicker Man
8. Blood Brothers
9. When the Wild Wind Blows
10. The Evil That Men Do
11. The Talisman
12. Fear of the Dark
13. Iron Maiden

Encore:
14. The Number of the Beast
15. Hallowed Be Thy Name
16. Running Free

Dia 05 de abril será dia de nós, curitibanos, natos ou não, conferirmos o show do grande Iron Maiden, no Expotrade!

Vejo vocês lá! =)

Se ainda não comprou ingresso, corra!
http://www.ingressorapido.com.br/Evento.aspx?ID=13239

Fonte: Setlist.fm

É uma coisa extremamente simples, mas tem gente que não sabia (eu, por exemplo :P)

Basta pressionar simultaneamente as teclas de Repouso e Início. O som da câmera será emitido e a foto estará dispoinível no álbum de fotos.

Fonte
http://blogdoiphone.com/2010/10/print-screen

fonte:
http://nerdson.com/blog/mangled-packet

Não somente usuários Linux devem conhecer o sistema de permissões. Desenvolvedores que programam sistemas que rodarão em plataforma Linux devem conhecer o sistema de permissões também. É muito comum vermos programadores PHP falando “dê chmod 777, que resolve o problema de permissão”. Isso não é solução, é apenas o começo de um possível problema – e grave – futuro.

Sumário

Dono, Grupo e Outros
Divisão dos bits da permissão
Leitura, Escrita e Execução
Os riscos da permissão 777

Dono, Grupo e Outros

As permissões estão divididas em três níveis: permissões para o dono do arquivo, permissões para o grupo ao qual pertence o dono do arquivo e permissões para os outros usuários.

É por isso que sempre são mostrados três números, como 755, 644 ou três grupos de letras, como rwxr-xr-x ou rw-r–r–. Cada grupo corresponde a um nível de permissão.

O primeiro conjunto corresponde às permissões do dono do arquivo. O segundo, do grupo ao qual pertence o dono do arquivo. E o terceiro, ao outros usuários.

Divisão dos bits da permissão

Cada conjunto citado acima corresponde a três bits. Com três bits, é possível formar oito combinações:

000 = 0
001 = 1
010 = 2
011 = 3
100 = 4
101 = 5
110 = 6
111 = 7

O primeiro bits corresponde a permissão de leitura (read). O segundo corresponde à permissão de escrita (write). O terceiro, à de execução (execution). Sendo assim, podemos reescrever as combinações acima da seguinte forma:

000 = --- = 0 = nenhuma permissão
001 = --x = 1 = somente permissão de execução
010 = -w- = 2 = somente permissão de escrita
011 = -wx = 3 = somente permissões de escrita e execução
100 = r-- = 4 = somente permissão de leitura
101 = r-x = 5 = somente permissões de leitura e execução
110 = rw- = 6 = somente permissões de leitura e escrita
111 = rwx = 7 = permissões de leitura, escrita e execução (acesso total)

Leitura, Escrita e Execução

Vamos esclarecer o que significa ter permissão de leitura, escrita e execução em arquivos e diretórios.

Arquivos

Permissão de escrita em arquivo significa poder modificar o conteúdo do arquivo.
Permissão de leitura de arquivo significa poder acessar (ler) o conteúdo do arquivo.
Permissão de execução de arquivo significa poder executar o arquivo no terminal de comandos (shell).

Diretórios

Permissão de escrita em diretórios significa poder criar arquivos no diretório. Além disso, permissão de escrita possibilita a remoção de arquivos existentes, assim como a modificação das permissões dos arquivos desse diretório.
Permissão de leitura de diretórios significa poder acessar (ler) o conteúdo do diretório, ou seja, fazer a listagem do conteúdo do diretório.
Permissão de execução em diretórios significa poder entrar no diretório, seja por meio do comando cd ou acessando via URL no navegador.

Os riscos da permissão 777

Permissão 777 significa acesso total. Se um diretório tem permissão 777, qualquer uduário pode mexer naquele diretório, inserindo ou removendo arquivos, além de poder mudar as permissões deles. Qualquer usuário pode inserir um script ou programa executável malicioso, dar permissão de execução e executá-lo quando quiser. Imagine isso ocorrendo em um servidor de hospedagem! É um risco enorme! É por isso que sempre insisto: nunca use permissão 777.

É muito comum vermos “programadores” PHP postando dúvidas em fóruns falando que estão recebendo mensagem de erro de permissão. Aí alguém responde “dá chmod 777″. Nunca façam isso!

O correto é verificar o dono do arquivo e definir as permissões adequadas. Normalmente usa-se 755 para diretórios e 644 para arquivos não executáveis, como é o caso do PHP rodando em servidores WEB.

Mais detalhes no link abaixo:

http://www.debian.org/News/2011/20110205a

Roubei daqui:
http://piadasnerds.com/2010/12/07/um-caso-de-amor-matematico

www.idadeinterior.com.br

O site disse que sou 4 anos mais velho.

Que algoritmo será que eles usam…? =P

http://www.1stwebdesigner.com/css/38-jquery-and-css-drop-down-multi-level-menu-solutions

Creio que deva ser útil para alguém =)

Link para ouvir a narração em streaming
Link para download do arquivo MP3 da narração

SONETO DA FIDELIDADE
Vinícius de Moraes

De tudo, meu amor serei atento
Antes, e com tal zêlo, e sempre, e tanto
Que mesmo em face do maior encanto
Dele se encante mais meu pensamento.
Quero vivê-lo em cada vão momento
E em seu louvor hei de espalhar meu canto
E rir meu riso e derramar meu pranto
Ao seu pesar ou seu contentamento.
E assim, quando mais tarde me procure
Quem sabe a morte, angústia de quem vive
Quem sabe a solidão, fim de quem ama
Eu possa me dizer do amor ( que tive ) :
Que não seja imortal, posto que é chama
Mas que seja infinito enquanto dure.

Porém, poucos programadores iniciantes analisam essas mensagens, seja por falta de conhecimento ou preguiça mesmo. Ou até medo…

Vou mostrar aqui as mensagens de erro mais frequentes do PHP, junto com suas principais causas e soluções.

Sumário

Habilitando todas as mensagens de erro
Retirar o Operador de Controle de Erros
Parse Error
Undefined Index
Undefined Variable
Cannot modify header information
Call to undefined function
Class not found
Call to undefined method
Call to a member function on a non-object
supplied argument is not a valid MySQL result resource
Invalid argument supplied for foreach()
Conclusão

Habilitando todas as mensagens de erro

Antes de tudo, é bom saber que o PHP é muito personalizável – o que às vezes pode ser um problema. É possível desabilitar todas as mensagens de erro, ou limitar somente a alguns níveis de erro. Não vou explicar os níveis de erro do PHP, pois não é o foco do texto. Porém deixarei links para referência.

Para habilitar todas as mensagens de erro do PHP, basta inserir este trecho no início do script:

1
2

ini_set( 'display_errors', 1 );
error_reporting( E_ALL | E_STRICT );

Documentação da função ini_set
Documentação da função error_reporting
Funções para manipulação de erros
Descrição da diretiva error_reporting do php.ini
Descrição da diretiva display_errors do php.ini

Retirar o Operador de Controle de Erros

Outro ponto a ser observado é que é possível omitir erros no pHP usando o Operador de Controle de Erros, o famoso arroba (@). Esse operador existe para ser usado, mas use-o com cautela, quando for realmente necessário.

Entenda quando usar o Operador de Controle de Erros (arroba – @)
Documentação do Operador de Controle de Erros

Parse Error

Parse Errors ocorrem quando seu código possui erros de formatação, como caractere faltando ou em excesso.

Por exemplo:

1
2
3

<?php
phpinfo);
?>

Retornará o erro:

Parse error:  syntax error, unexpected ')' in teste.php on line 2

A correção é sempre muito simples: analisar a linha onde o erro ocorre e procurar o acarctere indicado pelo erro. Pode estar faltando algo ou sobrando alguma coisa. Note que o erro pode não estra na linha indicada pela mensagem de erro. Pode estar na anterior. Por exemplo:

1
2
3
4

<?php
echo 'oi'
echo 'oi de novo';
?>

Mensagem de erro:

Parse error:  syntax error, unexpected T_ECHO, expecting ',' or ';' in teste.php on line 3

A mensagem diz que há erro na linha 3, mas é a linha 2 que gera problema, devido à falta do ponto-e-vírgula no final do echo.

Undefined Index

Esse erro ocorre quando tenta-se acessar um índice inexistente de um array. Esse erro é muito comum com iniciantes usando Query String. O famoso exemplo:

1
2
3

<?php
$pag = $_GET['pag'];
?>

Se não existe a variável “pag” na URL, dará este erro:

PHP Notice:  Undefined index: pag in teste.php on line 2

Para evitar esse erro, sempre verifique se o índice existe. A função isset resolve facilmente esse problema:

1
2
3
4
5
6
7
8

if ( isset( $_GET['pag'] ) )
{
    $pag = $_GET['pag'];
}
else
{
    $pag = 'valor padrão';
}

O código pode ser reescrito sda seguinte forma, usando o Operador Condicional Ternário:

1

$pag = isset( $_GET['pag'] ) ? $_GET['pag'] : 'valor_padrao';

Mais sobre o Operador Ternário aqui:
http://www.php.net/manual/pt_BR/language.operators.comparison.php

Undefined Variable

Como o erro mostra claramente, isso ocorre quando se tenta usar uma variável não declarada (ou definida, no caso do PHP).

1
2
3

<?php
echo $var;
?>

Erro:

PHP Notice:  Undefined variable: var in teste.php on line 2

A solução não poderia der outra: criar a variável antes de usá-la.
Logicamente, o erro pode ter ocorrido por um erro de digitação do nome da variável.

Cannot modify header information

Essa mensagem de erro está ligada a envio de cabeçalhos HTTP, o que envolve sessions, cookies, a própria função header, do PHP.

O envio de cabeçalhos HTTP devem ser realizados sempre antes de qualquer saída ao navegador, ou seja, sempre antes de códigos HTML e funções que exibam dados, como echo, print, print_r etc. Também não pode haver espaços vazios no código, antes da tag <?.

O membro hinom, do iMasters Fóruns, escreveu um excelente tutorial sobre isso, que pode ser visto no link abaixo:
http://forum.imasters.com.br/index.php?/topic/342563-dicas-para-uso-de-variaveis-de-sessao

Call to undefined function

Novamente, o erro é claro: foi feita uma chamada a uma função não definida.

1
2
3

<?php
beraldo();
?>

Erro:

Fatal error:  Call to undefined function beraldo() in teste.php on line 2

Para corrigir, defina a função. Pode ter havido erro de digitação do nome da função ou falta de inclusão do arquivo que a define.

Class not found

Ocorre quando o PHP não encontra a classe que se deseja instanciar.

<?php
$b = new Beraldo();
?>

Erro:

Fatal error:  Class 'beraldo' not found in teste.php on line 2

Como no erro anterior, a solução é declarar a classe, além de verificar se não houve erro de digitação ou falta de inclusão de arquivo.

Call to undefined method

Ocorre quando se chama um método inexistente de uma classe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
 
class Beraldo
{
	public function darOi()
	{
		echo "oi";
	}
}
 
$Beraldo = new Beraldo();
$Beraldo->darTchau();
 
?>

Erro:

Fatal error:  Call to undefined method Beraldo::darTchau() in teste.php on line 12

Deve-se criar o método ou verificar se não houve erro de digitação do nome do método.

Call to a member function on a non-object

Isso ocorre quando se chama um método em uma variável que não é uma instância de um objeto.

1
2
3
4

<?php
$var = 'oi, sou uma string';
$var->metodo();
?>

Erro:

Fatal error:  Call to a member function metodo() on a non-object in teste.php on line 3

Para solucionar o erro, verifique se não usou a variável errada ou se não modificou o valor original da variável, de forma a ter perdido a instância do objeto.

supplied argument is not a valid MySQL result resource

Esse erro ocorre quando uma função espera, como parâmetro, um resource retornado por outra função do MySQL. O mais comum é ocorrer erro na linha onde há a função mysql_fetch_assoc(), mysql_fetch_array() e semlhantes. Isso quer dizer que o parâmetro passado não é um resource retornado por mysql_query(), o que indica que a consulta falhiou e mysql_query() retornou FALSE.

Mensagem de erro:

Warning: mysql_fetch_array(): supplied argument is not a valid MySQL result resource in ...

A solução é corrigir a query executada. Muitas vezes o erro é simples, apenas nome de tabela ou campo errados, ou erro de sintaxe. Para visualizar o erro retornado pelo MySQL, pode-se usar a função mysql_error(). Logo, deve-se executar a consulta desta maneira:

1

$exec = mysql_query( $sua_consulta_aqui ) or exit( mysql_error() );

Caso a consulta falhe, ou seja, mysql_query retorne FALSE, a função exit() finalizará a execução do script, mostrando o erro do MySQL, devido à função mysql_error(). Ler a mensagem de erro ajuda a encontrar o erro na consulta SQL.

OBS: Mostrei exemplo usando MySQL, mas recomendo fortemente que seja usada a extensão MySQLi, que é bem mais completa, além de prover recuersos novos do MySQL 4.1.

Invalid argument supplied for foreach()

Esse erro ocorre quando o argumento passado para o loop foreach não é um array.

1
2
3
4
5
6
7

<?php
$var = '';
foreach ( $var as $k )
{
	echo $k;
}
?>

Erro:

Warning:  Invalid argument supplied for foreach() in teste.php on line 3

Como $var é uma string, foi gerado o erro. Para corrigir, basta verificar se o parâmetro está correto ou se ele não foi modificado durante a execução do script, deixando de ser um array.

Conclusão

As mensagens de erros geralmente são muito claras. Portanto, leia-as atentamente antes de perguntar para alguém ou criar um tópico em um fórum só para isso. Muitas vezes os erros são de fácil correção, bastando ler com cuidado das mensagens de erro.