quarta-feira, 8 de maio de 2019

Shell Script: tratamento de argumentos e opções

às maio 08, 2019 0 comentários
Na grande maioria das vezes, a linguagem shell script é usada para criar uma sequência de comandos que automatizam uma tarefa. Nisso, ela é extremamente eficiente e rápida. Combinar comandos é uma grande vantagem que o jeito UNIX de ser nos trouxe: várias ferramentas que fazem tarefas básicas, especializadas, e que quando se juntam realizam grandes feitos trabalhando juntas. Mas isso nunca impediu que se criasse também programas completos em shell script.
Uma característica para deixar um shell-script mais robusto e menos “sequencial/batch-mode” é o tratamento de argumentos. No meu clássico tutorial Programando em Shell-Script, o tópico Variáveis Especiais nos traz os primeiros itens que devemos aprender para o tratamento de argumentos. Existem variáveis especiais que tratam os argumentos passados para um programa ou uma função. Estes são:
  • $0 – Retorna o nome do script que foi executado
  • $N – Onde N é um número, corresponde ao argumento passado (1 = primeiro argumento, 2 = segundo argumento, 3 = terceiro argumento, etc)
  • $* – Retorna todos os argumentos de uma vez.
  • $# – Retorna a quantidade de argumentos passado para o script. (argc)
Vejamos agora um shell-script exempo que faz uso de todos esses argumentos:
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
#!/bin/bash
 
if [ $# -lt 1 ]; then
   echo "Faltou utilizar pelo menos um argumento!"
   exit 1
fi
 
echo "Numero de argumentos: $#"
 
COUNT=0
for ARG in $*; do
   COUNT=`expr $COUNT + 1`
   echo "Argumento $COUNT: $ARG"
done
As linhas 3 a 6 verificam se a quantidade de argumentos ($#) é menor (-lt – less than) que 1. Ou seja, se o usuário não chamou o programa com nenhum argumento, ele imprime um erro e sai do programa com status 1.
A linha 8 mostra quantos argumentos foram utilizados, usando novamente o $#.
O resto das linhas, 10 a 14, usam o $* com um laço for e um contador para mostrar quais foram os argumentos.
Executando agora este script sem argumentos:
$ ./tmp.sh
Faltou utilizar pelo menos um argumento!
Agora executando com dois argumentos:
$ ./tmp.sh naosei testando
Numero de argumentos: 2
Argumento 1: naosei
Argumento 2: testando
E agora com 4 argumentos:
$ ./tmp.sh a b c d
Numero de argumentos: 4
Argumento 1: a
Argumento 2: b
Argumento 3: c
Argumento 4: d
Bem simples né?

Argumentos como opções e seus valores

Algo comum que vemos nos programas são opções. Opções não deixam de ser argumentos para um programa, mas eles tem um significado especial. Do tipo: Se a opção -d existir, ativar durante o programa o modo de depuração. Se houver um -h, então mostre uma ajuda e não faça mais nada. Se houver um -v mostre a versão, e por aí vai.
Exemplo:
?
01
02
03
04
05
06
07
08
09
10
11
#!/bin/bash
 
case $1 in
   "-h") echo "Isto seria uma ajuda... Mas fiquei com preguiça de escrevê-la."
         ;;
   "-v") echo "Versão 666."
         ;;
   *) echo "Opção inválida!"
      exit 1
      ;;
esac
Exemplos do uso do script:
$ ./tmp.sh -h
Isto seria uma ajuda... Mas fiquei com preguiça de escrevela.
 
$ ./tmp.sh -v
Versão 666.
 
$ ./tmp.sh -O
Opção inválida!
 
$ ./tmp.sh
Opcao invalida!
Com isso a gente resolve um problema e cria mais outros dois…
  • E se o usuário colocar as duas opções? Só uma funcionaria.
  • E se uma das opções precisasse de um valor? Estilo “-f arquivo.log” gravaria um arquivo de log com as operações.
Poderíamos escrever vários algoritmos que verificassem cada um de todos os argumentos, testasse se fosse um ou outro, utilizasse as opções… Mas felizmente não precisamos fazer nada disso! O bash conta com uma função interna que trata os argumentos: o famoso getopts.

Utilizando o getopts para tratar tratar argumentos e opções

Seguindo a mesma linha de raciocínio, vamos logo para um exemplo de programa. Supondo que queiramos um shell-script que faça isso:
  • Caso a opção -h seja usada, mostra a ajuda e sai do programa.
  • Caso a opção -v seja usada, mostra a versão e sai do programa.
  • Caso a opção -o seja usada, grava um arquivo de log com as operações efetuadas e resultados.
  • Caso a opção -u seja usada, mostra o resultado do comando “uname -a”
  • Caso a opção -m seja usada, mostra o resultado do comando “free -m”
  • Caso a opção -s seja usada, mostra o resultado do comando “swap -s”
Note que apenas as opções -h e -v saem do programa após a execução. Agora vamos ao código:
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#!/bin/bash
 
function PrintUsage() {
   echo "Uso: `basename $0` <-umsf> [-ohv]"
   exit 1
}
 
while getopts "hvo:umsf" OPTION
do
   case $OPTION in
      h) PrintUsage
         ;;
      v) echo "`basename $0` versao 666."
         exit
         ;;
      o) ARQUIVO_LOG=$OPTARG
         ;;
      u) DO_UNAME=1
         ;;
      m) DO_FREE=1
         ;;
      s) DO_SWAPON=1
         ;;
      ?) PrintUsage
         ;;
   esac
done
shift $((OPTIND-1))
 
if [ -z "$DO_UNAME" ] && [ -z "$DO_FREE" ] && [ -z "$DO_SWAPON" ] && [ -z "$DO_FDISK" ]; then
   PrintUsage
fi
 
if [ "$ARQUIVO_LOG" ]; then   echo "Execucao iniciada em `date`." >> $ARQUIVO_LOG
 
   if [ "$DO_UNAME" == 1 ]; then
      uname -a >> $ARQUIVO_LOG
   fi
 
   if [ "$DO_FREE" == 1 ]; then
      free -m >> $ARQUIVO_LOG
   fi
 
   if [ "$DO_SWAPON" == 1 ]; then
      swapon -s >> $ARQUIVO_LOG
   fi
else
   echo "Execucao iniciada em `date`."
   if [ "$DO_UNAME" == 1 ]; then
      uname -a
   fi
 
   if [ "$DO_FREE" == 1 ]; then
      free -m
   fi
 
   if [ "$DO_SWAPON" == 1 ]; then
      swapon -s
   fi
fi
O interessante para nós são as linhas 8 a 28. O laço while getopts começa a tratar todos os argumentos. A cada iteração do laço, ele coloca a letra da opção na variável $OPTION.
Note que para cada opção que precisamos, colocamos uma letra no primeiro argumento do getopts:
?
1
while getopts "hvo:umsf" OPTION
Note também que depois da letra o temos um dois pontos (:). Esse dois pontos significa que logo após a opção -o, o usuário precisa fornecer um valor. Este valor é automaticamente armazenado na variável $OPTARG.
Dessa maneira, podemos executar esse programa de diversas formas:
./tmp.sh -o arquivo.log -u
(executa o "uname -a" e grava no arquivo arquivo.log)
 
./tmp.sh -um
(executa os comandos "uname -a" e "free -m")
 
./tmp.sh -m -s -u
(executa os comandos "free -m", "swapon -s" e "uname -a")
Ou seja, não importa a ordem, o getopts vai reconhecer e executar as ações de acordo com a opção especificada.
E se você colocar uma opção que não está contemplatada… O “?” do case irá ser executado, por exemplo:
$ ./tmp.sh -a
./tmp.sh: illegal option -- a
Uso: tmp.sh <-umsf> [-ohv]
E dessa forma fica bem fácil de entender e usar o getopts :) Depois que o laço é todo feito e executado em todos os argumentos (no meu caso, preferi apenas configurar variáveis para cada opção e tratá-las depois), ele executa o comando que está na linha 28:
?
1
shift $((OPTIND-1))
Este comando faz com que os argumentos de opções sejam “comidos“, até que não sobre nenhuma opção. Em outras palavras, os argumentos representados pelas variáveis $N só serão aqueles que não pertençam a nenhuma opção. Exemplo:
./tmp.sh -u -o arquivo.log -m argumento1 argumento2
Nesse caso, o $1 seria o argumento1 e o $2 seria o argumento2, quando na verdade, sem o shift, eles seriam respectivamente o $5 e $6.
Como nem tudo é perfeito, a função getopts do bash não aceita opções longas (–nome-da-opcao), ou seja, voce só pode utilizar uma letra como opção. Represente bem suas opções com as letras! :)

Argumentos dentro de funções

Se dentro de um shell-script temos uma função, essa função é enxergada pela shell como se fosse um comando. Nesse sentido, dentro de uma função as variáveis $N definidas pelo programa não funcionarão. Exemplo:
?
01
02
03
04
05
06
07
08
09
10
11
12
13
#!/bin/bash
 
function Dummy() {
   echo "Numero de argumentos: $#"
 
   COUNT=0
   for ARG in $*; do
      COUNT=`expr $COUNT + 1`
      echo "Argumento $COUNT: $ARG"
   done
}
 
Dummy
Não importa o que você executar com o script acima, a saída será sempre a mesma: 0 números de argumentos, como mostrado a seguir.
$ ./tmp.sh
Numero de argumentos: 0
 
$ ./tmp.sh naosei temporario
Numero de argumentos: 0
 
$ ./tmp.sh a b c d e f g
Numero de argumentos: 0
Para a função Dummy, as variáveis especiais dos argumentos funcionam apenas para a função e não para o programa inteiro. É como se as variáveis fossem locais, e não globais. Vamos então substituir a linha da chamada da função Dummy (linha 13) por:
?
1
Dummy a b c d
E tentar executar novamente:
$ ./tmp.sh
Numero de argumentos: 4
Argumento 1: a
Argumento 2: b
Argumento 3: c
Argumento 4: d
Sabendo disso, não se percam na hora de usar os argumentos dentro das funções e lembrem-se que isto pode ser útil na hora de implementar diversas funções dentro de um script. Um bom exemplo disso é implementar a função PrintUsage que usamos anteriormente para, além de mostrar uma mensagem de uso, mostrar também uma mensagem de erro personalizada:
?
1
2
3
4
5
function PrintUsage() {
   [ "$1" ] && echo -ne "Erro: $1\n"
   echo "Uso: $(basename $0)  <-umsf> [-ohv]"
   exit 1
}
Agora é so chamar a função como…
PrintUsage "Faltando parâmetros."
PrintUsage "Opção inválida."
PrintUsage "No donut for you."
Use a criatividade de um programador (afinal, programação é arte) e comece a aprimorar suas ferramentas bash! :)

Fonte: http://www.devin.com.br/shell-script-tratamento-de-argumentos-e-opcoes/
Continue reading →
quinta-feira, 2 de maio de 2019

SSH – Conexão sem senha: Windows

às maio 02, 2019 0 comentários
No post anterior, ensinei como acessar um servidor SSH no Linux sem ter que digitar senha, neste ensinarei a fazer a mesma coisa, porém utilizando uma ferramenta Windows, o meu grande amigo Putty (Cliente para conexões SSH e muito mais) e como na dica anterior usaremos o usuário joao_servidor para teste.
Nesta dica, vamos utilizar duas ferramentas bem leves, o Putty (Para fazer a conexão) e o PuttyGen (Para gerar as chaves).
O primeiro passo, é gerar as nossas chaves usando o PuttyGen, quando executa-lo, será apresentado uma janela semelhante a esta:

Clique em Generate para iniciar a geração da chave e depois fiquei movimentando o mouse sobre o campo Key, pois a criação da chave será baseada na posição dele:
Após gerar a chave, em Key Comment você pode adicionar um cometário, geralmente coloco o meu Email e em Key passfrase você pode adicionar uma senha a sua chave, porém toda vez que for se conectar ao servidor será necessário digitar esta senha.
Para salvar a chave publica, você pode clicar em Save public key, mas eu prefiro copiar o código gerado em Public key for pasting into OpenSSH authorized_keys file e colar em um novo documento de texto, assim quando precisar da chave, basta copiar o código novamente.
Para salvar a chave privada, clique em Save private key, escolha o local e o nome do arquivo e clique em Salvar, lembrando que este arquivo deve ficar muito bem guardado para que ninguem tenha acesso, pois quem tiver acesso a este arquivo poderá logar no servidor tranquilamente.
Obs: Caso não tenha digitado nenhuma passphrase, você será questionado se realmente deseja salvar a chave sem nenhuma proteção, basta clicar em Sim.


Pronto, agora que temos o par de chaves, vamos configurar o servidor:
Acesse o servidor normalmente via ssh e já conectado vamos verificar se o diretório .ssh (o ” . ” indica que é um diretório oculto) ja existe, caso não, basta cria-la com o seguinte comando:
# mkdir /home/joao_servidor/.ssh
Agora vamos entrar no diretório:
# cd /home/joao_servidor/.ssh
E editar o aquivo authorized_keys:
Obs: Caso não exista, basta criar.
# pico authorized_keys
Obs: Certifique-se que o arquivo está no diretório /home/joao_servidor/.ssh
Devemos adicionar a chave que copiamos do PuttyGen ao final do arquivo. Depois de adicionar, basta salvar e sair, agora você pode desconectar do servidor.
O ultimo passo é editarmos o putty para que o mesmo consiga trocar as chaves com o servidor, para isso abra o putty, será exibido uma janela semelhante a essa:
No campo Host Name digite o nome do servidor ou o IP e em Port digite a porta usada pelo SSH (Padrão 22). Preencha o campo Saved Sessions com o nome que queira dar ao seu servidor e clique em Save. Note que abaixo de Default Settings ficou o seu servidor.
Depois, em Category clique em Data e no campo Auto-login username digite o usuário que deseja utilizar para login.
Logo abaixo clique em SSH, depois em Auth. No campo Private key file for authentication clique em Browse e selecione sua chave Privada.
Volte ao menu Session e clique novamente em Save para salvar as configurações e depois clique em Open.






  Pronto, agora todas as vezes que quiser conectar ao servidor, basta abrir o putty e clicar duas vezes sobre o nome do seu servidor que você conectará a ele sem ter que digitar senha.
Como disse no post passado, devemos tomar muito cuidado com qual usuário conectamos, pois acessos errados a pessoas erradas podem causar muita dor de cabeça. NUNCA utilize esse método de autenticação com o usuário root, pois se alguém mal intencionado tiver acesso a chave privada, você estará “lascado”.
Uma boa dica de segurança, é depois de testar a autenticação por chaves, desabilitar o acesso de root via SSH e desabilitar também o acesso com senha, assim você somente conseguirá acessar o servidor com a sua chave.
Testado no Windows 7 / Putty
 
Precisa de Suporte Técnico ou Consultoria? www.revolutech.com.br
Gostou? Compartilhe, deixe seu comentário. Receba o conteúdo do blog em seu Email clicando aqui.
Achou algum erro? Precisa de ajuda? Criticas?  Deixe seu comentário.
Obrigado!
 
Fonte: https://vidadeti.com/ssh-conexao-sem-senha-windows/
Continue reading →
quarta-feira, 1 de maio de 2019

Como descobrir as versões do .NET Framework instaladas

às maio 01, 2019 0 comentários

Como descobrir as versões do .NET Framework instaladas

Escrito por  - Arquivado em Tutoriais - Última atualização: 
Publicidade
Vários programas exigem versões específicas do .NET Framework para rodarem e infelizmente a Microsoft não oferece uma maneira fácil de você verificar quais versões do .NET Framework estão instaladas no PC.
Nesse tutorial vamos mostrar quatro maneiras diferentes de você verificar rapidamente quais as versões do .NET Framework você tem instaladas em seu computador com Windows 7, Windows 8/ 8.1 e Windows 10.
Publicidade

Opção 1 – Windows Explorer

Uma forma simples de descobrir as versões do .NET Framework instaladas é através do Windows Explorer.
1. Pressione “Win+R” para abrir o Executar, digite o comando abaixo e pressione “Enter” ou simplesmente abra uma nova janela do Windows Explorer e navegue até a pasta C:\Windows\Microsoft.NET\Framework.
%windir%\Microsoft.NET\Framework\
2. Nesse local você verá pastas com as versões do .NET Framework instaladas no Windows.
3. Você também pode verificar a pasta abaixo se estiver usando a versão de 64 bits do Windows.
C:\Windows\Microsoft.NET\Framework64

Opção 2 – Linha de comando

Outra maneira muito prática de você descobrir quais versões do .NET Framework estão instaladas em seu computador é através de um comando, executado no PowerShell ou no Prompt de Comando do Windows.
1. Pesquise por PowerShell no menu iniciar e abra o “Windows Powershell”
2. Copie o comando abaixo, cole no Powershell e pressione “Enter”.
wmic product get description | findstr /C:.NET
3. Aguarde um pouco e ele retornará a lista de versões do .NET Framework instaladas em seu computador.
4. É possível também usar o Prompt de Comando, basta digitar o comando abaixo no Prompt e aguardar.
wmic product where "Name like 'Microsoft .Net%'" get Name, Version
Continue reading →
sexta-feira, 26 de abril de 2019

Como criar pacotes .deb

às abril 26, 2019 0 comentários
Pacotes .deb facilitam a instalação de aplicativos, aqui no blog tem dois Posts que demonstram como “Instalar o Eclipse Galileo e o Aptana”, mas tudo poderia ser desprezado, se eu criasse um pacote .deb e disponibilizasse pra download, mas essa não é a idéia desse blog.
Os pacotes podem ser instalado em Debian e Debian-Likes (Ubuntu, Linux Mint, Backtrack 5…), que possuem o mesmo caminho para os diretórios dos aplicativos.
É bem simples criar pacotes .deb, vamos começar então
  • 1 - crie uma pasta onde você desejar que será o nome do programa, aqui eu vou criar a pasta terminalroot dentro da minha Área de Trabalho.
  • 2 - Depois crie dentro da sua pasta uma pasta em maiúsculo, com o nome DEBIAN
  • 3 - dentro da pasta DEBIAN, crie um arquivo com o nome de control, sem extensão.
  • 4 - abra esse arquivo com seu editor de texto(gEdit por exemplo) e preencha com o código abaixo

Package:terminalroot
Version: 0.1
Priority:
Architecture: all
Essential:
Depends:
Pre-depends:
Suggests:
Installed-Size:
Maintainer: Marcos da B. M. Oliveira
Conflicts:
Replaces:
Provides:
Description: Acesse o blog terminalroot.com.br e descubra como criar pacotes .deb
No código acima, as linhas que são obrigatórias, estão preenchidas, porém algumas linhas como Depends, por exemplo, se você preencher com pacotes necessários para o funcionamento do programa o GDebi-Installer não instalará se não houver estas dependências, porém com os campos acima mencionados já podemos instalar o programa pelo GDebi-Installer.
Agora vamos ao programa, se você baixou um tarball e não quer perder o tempo copiando arquivos pra dentro de pastas…você pode criar um .deb e executá-lo, ou até mesmo, dar dois cliques nele, se o pacote foi criado com o root, ele pedirá a senha de root.
  • 5 - Dentro da pasta que você criou que aqui estou chamando de terminalroot, crie as diretivas que você deseja, por exemplo, crie uma pasta com o nome “usr”, dentro de “usr”, crie uma pasta com o nome “bin” e dentro de “bin“(ISSO SERÁ O MESMO DE VOCÊ INFORMAR QUAIS OS CAMINHOS NO SEU COMPUTADOR QUE DESEJA PARA ONDE OS ARQUIVOS SEJAM COPIADOS) coloque um arquivo, sem extensão com esse código abaixo por exemplo

#!/bin/sh
echo "Acesse: terminalroot.com.br e descubra uma pá de coisa!"
E salve com o nome terminalroot, lembrando que logo após isso dê permissão de execução pra esse arquivo

chmod +x terminalroot
No diretório que será criado o .deb, vc também pode criar as pastas e sub-pastas pelo terminal, assim

mkdir -p usr/bin
O “usr” não pode ter “/” na frente e você deve estar dentro do diretório terminalroot, pois se se fizer /usr , será criado, se houver permissão, dentro do “usr” do seu computador.Você também pode criar um ícone no painel do Gnome, é só criar a pasta que ficará a imagem no seu computador e a imagem, exemplo

mkdir opt/
cp imagem.jpg terminalroot/opt
E depois criar o icone que aparecerá no painel, exemplo, terminalroot.desktop, dae teria essa configuração dentro do arquivo

[Desktop Entry]
Name=Marcos Pinguim
Icon=/opt/terminalroot.jpg
Type=Application
Categories=GNOME;GTK;Utility;TextEditor;
Exec=terminalroot
StartupNotify=false
Terminal=false
Para isso é necessário haver o carregamento do gtk na execução do programa, que não será esse caso, somente se você digitar no terminal “terminalroot”, obterá o texto do salvo no arquivo usr/bin/terminalroot, e salvará esse arquivo terminalroot.desktop dentro da pasta que será criado o pacote .deb

mkdir -p

  • 6 - depois de criar a pasta DEBIAN; o arquivo control; as pasta na raiz da pasta que será copiado os arquivos, e pôr os arquivos que serão copiados dentro das suas respectivas páginas, basta agora “compactar” em .deb

dpkg-deb -b terminalroot/ terminalroot.0.1.deb
E o pacotes será criado.Agora instale-o, ou dando dois cliques(ou abrindo com o Gdebi-installer), ou pelo terminal

dpkg -i terminalroot.0.1.deb
Todas as tarefas restantes serão feitas automaticamente, e o pacote será instalado.Agora vá ao terminal e digite “terminalroot”, terá o texto pré-configurado para responder, se fosse um software seria executado, se houve Gtk pre-configurada abriria a janela, até mesmo pelo ícone pre-programado, se você for no painel
Aplicativos > Acessórios
Verá a imagem lá, entre as opções dos aplicativos, porém se clicar não fará nada.Para remover, basta

apt-get remove terminalroot
Todos os arquivos copiados serão remvidos, inclusive as imagens.
Pronto, é só isso, espero que gostem e comentem.
Continue reading →

Busca CEP com Shell Script

às abril 26, 2019 0 comentários
Pesquisando CEP via Shell Script 

Script simples para saber o Estado, Cidade, Bairro e Logradouro de um determinado CEP, explicações segue nos comentários do código.

http://cep.republicavirtual.com.br/web_cep.php?cep=06765000&formato=xml 



 
#!/bin/bash
# --------------------------------------
# ./cep.sh
#
# Pesquisando CEP via Shell Script
#
# Uso: ./cep.sh [CEP]
#
# Ex.: ./cep.sh 41630635
#
# Autor: Marcos da B. M. Oliveira , www.terminalroot.com.br
# Desde: Dom 25 Ago 2013 13:11:36 BRT
# Licença: GPL
# --------------------------------------
# se não informa o CEP o script pára aqui
[ -z $1 ] &amp;&amp; echo -e '\e[40;31;1mÉ necessário informar o CEP\033[m' &amp;&amp; exit 1

#url da pesquisa
url='http://cep.republicavirtual.com.br/web_cep.php?cep'

# baixa o código fonte do xml e grava no arquivo cep.txt
lynx -source $url=$1 > cep.txt

# converte o arquivo para utf-8
iconv -f=iso_8859-1 -t=utf-8 cep.txt > cep2.txt

# limpa todas as tags XML
sed 's/]*>//g' cep2.txt > cep.txt

# remove o arquivo da transformação do encode
rm -rf cep2.txt

# apaga da linha 1 à 4 , pois são desnecessárias
sed -i '1,4d' cep.txt

# apaga todas as linhas em branco
sed -i '/^$/d' cep.txt

# imprime(com cores) os dados do arquivo gerado pelo dump, personalizado.
echo -e "\e[40;37;1m CIDADE-UF:\033[m \e[40;33;1m"$(sed -n '2p' cep.txt) $(sed -n '1p' cep.txt) "\033[m"
echo -e "\e[40;37;1m BAIRRO:\033[m \e[40;33;1m"$(sed -n '3p' cep.txt) "\033[m"
echo -e "\e[40;37;1m LOGRADOURO:\033[m \e[40;33;1m"$(sed -n '4p' cep.txt) $(sed -n '5p' cep.txt) "\033[m"

# remove o arquivo
rm -rf cep.txt

 Fonte: http://www.terminalroot.com.br/2013/08/pesquisando-cep-via-shell-script.html
Continue reading →
quinta-feira, 18 de abril de 2019

Shell Script: repetição e função

às abril 18, 2019 0 comentários
Uma estrutura de repetição, também conhecida como loop ou laço, é uma estrutura de desvio do fluxo de controle presente em linguagens de programação que realiza e/ou repete diferentes algoritmos/ações dependendo se uma condição é verdadeira ou falsa. Vejamos os comandos while, until e for.
While
Os comandos são executados enquanto a condição for verdadeira. No exemplo a seguir, enquanto o contador for diferente (“ne” significa “not equal”) de 4, será imprimida na tela uma mensagem, será aguardado 1 segundo e atualizado o contador:
For
O laço for executa uma ação até que uma condição seja atendida. No exemplo abaixo, cada linha do arquivo subs.csv é lida (através do comando “cat” e impressa usando “echo”) até o final do arquivo e as letras maiúsculas são substituídas por minúsculas, mandando a saída para o arquivo subestacoes.csv:
Veja esse outro exemplo, onde o for serve para varrer todos os arquivos com extensão “.csv” e pega partes do nome do arquivo para criar pastas e mover os arquivos para esses novos diretórios:
Funções
Uma forma de repetir comandos é através do uso de funções. A função é um bloco de código que pode ser invocado pelo resto do script apenas escrevendo o nome da função. Ela deve ser escrita antes da rotina principal (ou escreva a rotina principal dentro de outra função e chame-a depois). A função não recebe parâmetros de entrada, assim a função deve ser chamada e em seguida incluir a variável (ou variáveis) a ser utilizada na função, enquanto que na função deve-se usar “$1” para receber essa variável (ou $2, $3.. para mais variáveis). Veja esse exemplo:
Um exemplo integrando tudo. O separador de campo é alterado para quebra de linha (e restaurado no final do script). Para todas as linhas do arquivo, são extraídos em diferentes variáveis os campos ano, mês, dia… cidade, incluído o zero na frente do número (caso tenha apenas 1 dígito, através do while), e impressos no arquivo de saída conforme a variável “novalinha”:
Fonte: https://www.monolitonimbus.com.br/shell-script-repeticao-e-funcao/
Continue reading →
Assinar: Postagens (Atom)
 
Contact us if you have any question or anything else

Tutoriais para uso no Raspberry Pi 3 B © 2011 DheTemplate.com. Supported by Tips for Life and Blogging Tips