Bash scripting

01 de fevereiro de 2023

Bash scripting

Pasta com scripts

Este caderno foi traduzido automaticamente para torná-lo acessível a mais pessoas, por favor me avise se você vir algum erro de digitação..

Para fazer este post, vamos criar uma pasta onde vamos salvar todos os scripts.

	
		!mkdir scripts_bash

Primeiro roteiro

Especificação do binário de execução

No linux você pode indicar com qual programa executar um arquivo colocando na primeira linha #!<binary path>, por exemplo, se criarmos um .py podemos indicar que ele deve ser executado com python colocando na primeira linha #!/usr/bin/python3. Em nosso caso, como estamos fazendo um script terminal, colocamos na primeira linha #!/bin/bash.

Agora, se o arquivo receber permissões de execução, ele pode ser executado diretamente sem especificar o programa com o qual ele deve ser executado. Ou seja, o .py' não precisa mais ser executado via.py.py', mas pode ser executado via .script.py'. Em nosso caso, em vez de executar o arquivo viabash script.sh, podemos executá-lo via./script.sh`.

Comentários em scripts bash

Se você quiser entrar um comentário, basta iniciar a linha com `#``.

"bash

Este é um comentário de uma linha


      Se quisermos entrar em várias linhas de comentários, temos que começar com `: `` e terminar com ```.
      
      "bash
      : '
      Este é um comentário de várias linhas
      que se estende por várias linhas.
      '

Imprimir na tela com o comando `echo

Se quisermos imprimir na tela, utilizamos o comando echo seguido pelo que queremos imprimir.

	
		!mkdir scripts_bash
%%writefile scripts_bash/01_primerScript.sh
#!/bin/bash
# Comentario de una sola linea
: '
Comentario de varias
lineas
'
echo "Hola mundo"

	
		Writing scripts_bash/01_primerScript.sh

Nós damos permissões de execução e executamos o roteiro

	
		!chmod +x scripts_bash/01_primerScript.sh && ./scripts_bash/01_primerScript.sh

	
		Hola mundo

Declaração variável

Há dois tipos de variáveis, "variáveis de usuário" e "variáveis ambientais".

Para criar uma variável basta declará-la inserindo o nome desejado, seguido por `=`` e o valor

Para imprimir o valor de uma variável com echo, é necessário referenciá-la com `$<nome variável>.

"bash echo "Variável = $<nome variável>" echo "Variável = $<nome variável>" echo "Variável = $<nome variável>" echo "Variável = $<nome variável>" echo "Variável = $<nome variável>

	
		%%writefile scripts_bash/02_variables.sh
#!/bin/bash
opcion=1
nombre="Juan"
echo "Opcion: $opcion"
echo "Nombre: $nombre"

	
		Writing scripts_bash/02_variables.sh

	
		!chmod +x scripts_bash/02_variables.sh && ./scripts_bash/02_variables.sh

	
		Opcion: 1
Nombre: Juan

Âmbito das variáveis

As variáveis criadas são acessíveis apenas de dentro do roteiro, ou seja, seu escopo está dentro do roteiro.

Exportação de variáveis

Podemos exportar variáveis para que possam ser acessadas por outros scripts, para isso primeiro exportamos a variável utilizando o comando "exportar" e executamos chamada, dentro do script, o segundo script para o qual queremos passar a variável

	
		%%writefile scripts_bash/02_variables.sh
#!/bin/bash
opcion=1
nombre="Juan"
echo "Opcion: $opcion"
echo "Nombre: $nombre"
# Exportar variable nombre
echo "export nombre=$nombre"
export nombre
# Ejecutar script de importacion
echo ""
echo "Ejecutando script de importacion"
./scripts_bash/02_variables_importacion.sh

	
		Overwriting scripts_bash/02_variables.sh

	
		%%writefile scripts_bash/02_variables_importacion.sh
#!/bin/bash
echo "Nombre importado: $nombre"

	
		Writing scripts_bash/02_variables_importacion.sh

	
		!chmod +x scripts_bash/02_variables.sh && chmod +x scripts_bash/02_variables_importacion.sh && ./scripts_bash/02_variables.sh

	
		Opcion: 1
Nombre: Juan
export nombre=Juan
Ejecutando script de importacion
Nombre importado: Juan

Você tem que executar o segundo roteiro dentro do primeiro roteiro. Se agora rodarmos o segundo script, não temos a variável

	
		!chmod +x scripts_bash/02_variables_importacion.sh && ./scripts_bash/02_variables_importacion.sh

	
		Nombre importado:

Se quisermos que ela seja acessível a partir de qualquer segundo script, sem ter que executá-la dentro do primeiro script, temos que exportar a variável para uma variável de ambiente

Tipos de operadores

Todos os operadores possíveis são mostrados abaixo

	
		%%writefile scripts_bash/03_operadores.sh
#!/bin/bash
# Asignación de variables
x=10
y=20
echo "x = $x"
echo "y = $y"
# Operadores aritméticos
echo ""
echo "Operadores aritméticos"
echo "x + y = $((x + y))"
echo "x - y = $((x - y))"
echo "x * y = $((x * y))"
echo "x / y = $((x / y))"
echo "x % y = $((x % y))"
# Operadores de comparación
echo ""
echo "Operadores de comparación"
if [ "$x" -eq "$y" ]; then
  echo "x es igual a y"
else
  echo "x no es igual a y"
fi
if [ "$x" -ne "$y" ]; then
  echo "x no es igual a y"
else
  echo "x es igual a y"
fi
if [ "$x" -lt "$y" ]; then
  echo "x es menor que y"
else
  echo "x no es menor que y"
fi
if [ "$x" -gt "$y" ]; then
  echo "x es mayor que y"
else
  echo "x no es mayor que y"
fi
# Operadores de cadena
echo ""
echo "Operadores de cadena"
if [ "$a" = "$b" ]; then
  echo "a es igual a b"
else
  echo "a no es igual a b"
fi
if [ "$a" != "$b" ]; then
  echo "a no es igual a b"
else
  echo "a es igual a b"
fi
if [ -z "$a" ]; then
  echo "a es una cadena vacía"
else
  echo "a no es una cadena vacía"
fi
if [ -n "$a" ]; then
  echo "a no es una cadena vacía"
else
  echo "a es una cadena vacía"
fi
# Operadores de archivo
echo ""
echo "Operadores de archivo"
if [ -e "/path/to/file" ]; then
  echo "El archivo existe"
else
  echo "El archivo no existe"
fi
if [ -f "/path/to/file" ]; then
  echo "Es un archivo regular"
else
  echo "No es un archivo regular"
fi
if [ -d "/path/to/dir" ]; then
  echo "Es un directorio"
else
  echo "No es un directorio"
fi

	
		Overwriting scripts_bash/03_operadores.sh

	
		!chmod +x scripts_bash/03_operadores.sh && ./scripts_bash/03_operadores.sh

	
		x = 10
y = 20
Operadores aritméticos
x + y = 30
x - y = -10
x * y = 200
x / y = 0
x % y = 10
Operadores de comparación
x no es igual a y
x no es igual a y
x es menor que y
x no es mayor que y
Operadores de cadena
a es igual a b
a es igual a b
a es una cadena vacía
a es una cadena vacía
Operadores de archivo
El archivo no existe
No es un archivo regular
No es un directorio

Etapa da argumentação

Os argumentos podem ser passados aos roteiros, uma vez dentro do roteiro podemos fazer uso deles da seguinte forma

Por número de argumento: neste caso serão nomeados como $1, $2, etc. Mas caso o número de argumentos seja superior a 9, ou seja, são necessários mais de 2 dígitos para nomeá-lo, neste caso o número será identificado entre chaves, $1, $2, ..., $10, $11, etc.
Se o argumento de $0 for chamado, estamos recebendo o nome do arquivo
Se quisermos todos os argumentos, o faremos com $*.
Se o que queremos é o número de argumentos que temos, o conseguimos por $#.
Se quisermos sanear a saída do último comando, podemos descobrir por `$?``.
Se quisermos saber o PID do roteiro, podemos descobri-lo por $$.
Podemos substituir o valor de uma string em um argumento por ${<índice do documento>/ string a ser substituída/nova string}, ou seja, se tivermos ${1/hello/hello} substituirá a palavra hello pela palavra hello no argumento 1.
Entretanto, se utilizarmos ${< índice do documento>/# string a ser substituído/nova string}, ele só substituirá a string no argumento se o argumento começar com essa string.

	
		%%writefile scripts_bash/04_argumentos.sh
#!/bin/bash
# Pasos de argumentos simples
echo "Primer argumento: $1"
echo "Segundo argumento: $2"
echo "Tercer argumento: $3"
# Accediendo a todos los argumentos
echo "Todos los argumentos: $*"
# Accediendo al número de argumentos
echo "Número de argumentos: $#"
# Accediendo al nombre del script
echo "Nombre del script: $0"
# Accediendo al código de salida del último comando ejecutado
echo "Código de salida del último comando: $?"
# Accediendo al PID del script
echo "PID del script: $$"
# Accediendo a los argumentos con índices
echo "Argumento 3: ${3}"
echo "Argumento 2: ${2}"
# Accediendo a los argumentos con índices y longitud máxima
echo "Argumento 3 con longitud máxima de 2 caracteres: ${3:0:2}"
echo "Argumento 2 con longitud máxima de 3 caracteres: ${2:0:3}"
# Reemplazando argumentos con índices y longitud máxima
echo "Reemplazando argumento 3: ${3/arg/ARG}"
echo "Reemplazando argumento 2: $                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   {2/arg/ARG}"
# Accediendo a los argumentos con índices y patrones de reemplazo
echo "Reemplazando patrón en argumento 3: ${3/#tercer/TERCER}"
echo "Reemplazando patrón en argumento 2: ${2/#arg/ARG}"

	
		Overwriting scripts_bash/04_argumentos.sh

	
		!arg1="primer argumento" && arg2="segundo argumento" && arg3="tercer argumento" && chmod +x scripts_bash/04_argumentos.sh && ./scripts_bash/04_argumentos.sh "$arg1" "$arg2" "$arg3"

	
		Primer argumento: primer argumento
Segundo argumento: segundo argumento
Tercer argumento: tercer argumento
Todos los argumentos: primer argumento segundo argumento tercer argumento
Número de argumentos: 3
Nombre del script: ./scripts_bash/04_argumentos.sh
Código de salida del último comando: 0
PID del script: 11644
Argumento 3: tercer argumento
Argumento 2: segundo argumento
Argumento 3 con longitud máxima de 2 caracteres: te
Argumento 2 con longitud máxima de 3 caracteres: seg
Reemplazando argumento 3: tercer ARGumento
Reemplazando argumento 2: segundo ARGumento
Reemplazando patrón en argumento 3: tercer argumento
Reemplazando patrón en argumento 2: segundo argumento

Executar comandos e armazená-los em uma variável

Temos duas maneiras de executar um comando e salvar sua saída em uma variável

Por variável=comando
Através de variable=$(comando).

	
		%%writefile scripts_bash/05_variables_comandos.sh
#!/bin/bash
path=$(pwd)
infokernel=`uname -a`
echo "El directorio actual es: $path"
echo "La información del kernel es: $infokernel"

	
		Overwriting scripts_bash/05_variables_comandos.sh

	
		!chmod +x scripts_bash/05_variables_comandos.sh && ./scripts_bash/05_variables_comandos.sh

	
		El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Depuração

Há duas maneiras de ser capaz de depurar no bash scripting

Utilizando `-v': Execução detalhada linha por linha do script
Utilizando -x: Exibição de informações do roteiro

	
		!bash -v scripts_bash/05_variables_comandos.sh

	
		#!/bin/bash
path=$(pwd)
infokernel=`uname -a`
echo "El directorio actual es: $path"
El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
echo "La información del kernel es: $infokernel"
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

	
		!bash -x scripts_bash/05_variables_comandos.sh

	
		++ pwd
+ path=/home/wallabot/Documentos/web/portafolio/posts
++ uname -a
+ infokernel='Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
+ echo 'El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts'
El directorio actual es: /home/wallabot/Documentos/web/portafolio/posts
+ echo 'La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux'
La información del kernel es: Linux wallabot 5.15.0-57-generic #63~20.04.1-Ubuntu SMP Wed Nov 30 13:40:16 UTC 2022 x86_64 x86_64 x86_64 GNU/Linux

Obter informações do usuário

Obter informações utilizando os comandos `echo` e `read`.

Temos duas formas de obter informações do usuário

com o comando echo -n. Com a bandeira -n indicamos que não queremos que uma quebra de linha seja impressa no final do echo. Por exemplo, `echo -n "Insira dados:", com este comando pedimos dados e o cursor ficará na mesma linha, não haverá quebra de linha.
utilizando o comando "ler". Com este comando, o programa esperará que o usuário insira os dados, terminando com uma quebra de linha. O que foi inserido será armazenado na variável REPLY. Se você quiser que a variável onde os dados inseridos pelo usuário são salvos tenha outro nome, você deve inserir read [variável], por exemplo o comando read myVariable, salvará os dados do usuário na variável myVariable.
utilizando o comando $REPLY ou $[variável], acessamos os dados inseridos pelo usuário.

	
		%%writefile scripts_bash/06_leer_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read
option=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read backupName
echo ""
echo "Opción: $option, backupName: $backupName"

	
		Overwriting scripts_bash/06_leer_informacion.sh

Como não posso inserir os dados em um caderno jupyter como ele pede, coloquei-o em um cano ``` de antemão.

	
		!chmod +x scripts_bash/06_leer_informacion.sh && echo "1
nombreprueba" | ./scripts_bash/06_leer_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1, backupName: nombreprueba

Obter informações somente através do comando "ler

Outra forma de obter informações é utilizar apenas o comando "ler", a sintaxe seria

"bash leia -p "Mensagem imediata:" [variável].


      A bandeira `-p' indica que a mensagem ``Ponto de alerta:` será exibida antes de aguardar a entrada do usuário. Se nenhum nome de variável for especificado, os dados serão armazenados na variável `REPLY`.

	
		%%writefile scripts_bash/06_leer_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
echo "Opción: $option1-$option2, backupName: $backupName"

	
		Overwriting scripts_bash/06_leer_informacion.sh

	
		!chmod +x scripts_bash/06_leer_informacion.sh && echo "1
nombreprueba
2" | ./scripts_bash/06_leer_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: nombreprueba

Validar informações do usuário

Para validar as informações do usuário a melhor maneira seria usar expressões regulares, aqui está um post onde eu as explico

Também podemos especificar o número de caracteres que queremos que o usuário entre ao utilizar o "ler", para isso utilizamos a bandeira "não", que, se não for seguida por um número, esperará até que o usuário entre uma quebra de linha, e se for seguida por um número, esperará até que o usuário entre esse número de caracteres.

	
		%%writefile scripts_bash/07_validar_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read -n1
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read -n4 backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
echo "Opción: $option1-$option2, backupName: $backupName"

	
		Writing scripts_bash/07_validar_informacion.sh

	
		!chmod +x scripts_bash/07_validar_informacion.sh && echo "1back2" | ./scripts_bash/07_validar_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: back

Se quisermos que o usuário digite um valor confidencial, como uma senha, colocamos a bandeira -s (segurança). Desta forma, quando o usuário insere os dados, eles não serão impressos no console.

	
		%%writefile scripts_bash/07_validar_informacion.sh
#!/bin/bash
option=0
backupName=""
echo "Programa de utilidades"
echo -n "Ingresar una opción: "
read -n1
option1=$REPLY
echo ""
echo -n "Ingresar un nombre: "
read -n4 backupName
echo ""
read -p "Ingresar otra opción: " option2
echo ""
read -s -p "Password: " password
echo ""
echo "Opción: $option1-$option2, backupName: $backupName, password: $password"

	
		Overwriting scripts_bash/07_validar_informacion.sh

	
		!chmod +x scripts_bash/07_validar_informacion.sh && echo "1back2
1234" | ./scripts_bash/07_validar_informacion.sh

	
		Programa de utilidades
Ingresar una opción: 
Ingresar un nombre: 
Opción: 1-2, backupName: back, password: 1234

Se mais

A maneira de escrever os condicionamentos "se" e "e" é:

"bash se [[condição]]; então declaração elif [[condição]]; então declaração senão declaração fi


      É importante observar que as condições têm que estar entre parênteses rectos `[[]]`.

	
		%%writefile scripts_bash/08_if_else.sh
#!/bin/bash
if [[ 1 > 2 ]]; then
    echo "Verdadero"
elif [[ 1 > 3 ]]; then
    echo "Verdadero"
else
    echo "Falso"
fi

	
		Overwriting scripts_bash/08_if_else.sh

	
		!chmod +x scripts_bash/08_if_else.sh && ./scripts_bash/08_if_else.sh

	
		Falso

Vamos ver como criar "se" aninhados

	
		%%writefile scripts_bash/08_if_else.sh
#!/bin/bash
if [[ 1 > 2 ]]; then
    echo "Verdadero"
elif [[ 1 > 3 ]]; then
    echo "Verdadero"
else
    if [[ 1 > 4 ]]; then
        echo "Verdadero pero falso"
    else
        echo "Totalmente falso"
    fi
fi

	
		Overwriting scripts_bash/08_if_else.sh

	
		!chmod +x scripts_bash/08_if_else.sh && ./scripts_bash/08_if_else.sh

	
		Totalmente falso

Expressões condicionais

Já vimos como criar 'se', mas é necessário explicar como criar expressões condicionais.

Se formos fazer comparações entre cordas ou cordas

operação	comando
->>>``		[[[[[[ string1 > string2 ] ]]`			>>>
	``		[[[[[ string1 < string2 ]]`			sem mais de
	==`		[[[[ string1 == string2 ]]`				= string2
==``````[[[[ string1 = string2 ]]`				[[[[ string2

fio vazio|-z||[[ -z fio ]]|||||``````````````````````[ -z fio |n````[[ -n string ]||||n ||||[[[[ string ]]`||||

Se o que vamos fazer é fazer comparações entre os números

operação	comando	exemplo
-grande do que	``-gt`	`[[[[ número1 -gt número2 ]]`
-grande ou igual a	`-ge`			[[[[ número1 - número da idade2 ]]
-lt``			[[[ número1 -lt número2 ]]
-le`				[[[ número1 -le número2 ]]	-le

Igual a |-eq||[[[ número1 -eq número2 ]]|||||- |-diferente do que|-ne|[[[ número1 -ne número2 ]]`|| ``

Se quisermos verificar arquivos ou diretórios

operação	comando	exemplo
é um diretório?	`-d`		`[[ -d <dir> ]]`
é um arquivo?	`-f`		`[[ -f <file> ]]`
existe?	`-e`		`[[ -e <file> ]]` ou `[[ -e <dir> ]]`
é legível?	`-r`		`[[ -r <file> ]]`	-
é escrevível?	`-w`		`[[ -w <file> ]]`
é executável?	`-x`		`[[ -x <file> ]]`	É executável?	`-x`		[[ -x ]]`
é um link?	`-L`	`[[ -L <file> ]]`
es tem conteúdo?	`-s`		`[[ -s <file> ]]`			s
					é propriedade do usuário?	`-O`		[[[ -O ]]`	-
é propriedade do grupo?	`-G`		`[[ -G <file> ]]`
foi modificado?	`-N`	`[[[ -N <file> ]]`	``
file1 é mais novo que file2?	```-nt`		`[[[ <file1> -nt <file2> ]]`
file1 é mais antigo que file2?	`-ot`		`[[[ <file1> -ot <file2> ]]`
file1 é o mesmo arquivo que file2?	`-ef`		`[[[ <file1> -ef <file2> ]]`
file1 é o mesmo arquivo que file2?	`-ef`		`[[[ <file1> -ef <file2> ]]`

Se quisermos comparar as condições conjuntas com "e", "ou" e "não".

operação	comando	exemplo
	&&&&``````[[[ <condição1> &&&&&&&&&``````					&&&&&`````[[[ <condição1> &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
			``			```[[[ <condição1>		<condição2> ]]`

Se quisermos negar as condições

operação	comando	exemplo
não	`!`			[[[ ! <condição> ]]`

	
		%%writefile scripts_bash/09_condicionales.sh
#!/bin/bash
echo "Comparando strings"
string1="hola"
string2="hola"
string3="chao"
string4=""
if [[ $string1 > $string3 ]]; then
    echo "$string1 es mayor que $string3"
fi
if [[ $string3 < $string1 ]]; then
    echo "$string3 es menor que $string1"
fi
if [[ $string1 == $string2 ]]; then
    echo "$string1 es igual que $string2"
fi
if [[ $string1 != $string3 ]]; then
    echo "$string1 es diferente que $string3"
fi
if [[ -z $string4 ]]; then
    echo "$string4 es una cadena vacía"
fi
if [[ -n $string3 ]]; then
    echo "$string3 es una cadena no vacía"
fi
if [[ $string3 ]]; then
    echo "$string3 es una cadena no vacía"
fi
echo -e "\nComparando números"
number1=10
number2=10
number3=20
if [[ $number3 -gt $number1 ]]; then
    echo "$number3 es mayor que $number1"
fi
if [[ $number3 -ge $number2 ]]; then
    echo "$number3 es mayor o igual que $number2"
fi
if [[ $number1 -lt $number3 ]]; then
    echo "$number1 es menor que $number3"
fi
if [[ $number1 -le $number2 ]]; then
    echo "$number1 es menor o igual que $number2"
fi
if [[ $number1 -eq $number2 ]]; then
    echo "$number1 es igual que $number2"
fi
if [[ $number1 -ne $number3 ]]; then
    echo "$number1 es diferente que $number3"
fi
echo -e "\nComparando archivos"
file1="$PWD/2021-02-11-Introduccion-a-Python.ipynb"
file2="$PWD/scripts_bash"
file3="$PWD/mi_paquete_de_python"
if [[ -d $file2 ]]; then
    echo "$file2 es un directorio"
fi
if [[ -f $file1 ]]; then
    echo "$file1 es un archivo"
fi
if [[ -e $file1 ]]; then
    echo "$file1 existe"
fi
if [[ -r $file1 ]]; then
    echo "$file1 es legible"
fi
if [[ -w $file1 ]]; then
    echo "$file1 es escribible"
fi
if [[ -x $file1 ]]; then
    echo "$file1 es ejecutable"
fi
if [[ -L $file1 ]]; then
    echo "$file1 es un link"
fi
if [[ -s $file1 ]]; then
    echo "$file1 tiene contenido"
fi
if [[ -O $file1 ]]; then
    echo "$file1 es propiedad del usuario"
fi
if [[ -G $file1 ]]; then
    echo "$file1 es propiedad del grupo"
fi
if [[ -N $file1 ]]; then
    echo "$file1 fue modificado"
fi
if [[ $file1 -nt $file2 ]]; then
    echo "$file1 es más nuevo que $file2"
fi
if [[ $file1 -ot $file2 ]]; then
    echo "$file1 es más viejo que $file2"
fi
if [[ $file1 -ef $file1 ]]; then
    echo "$file1 es el mismo archivo que $file2"
fi
echo -e "\nComparando expresiones con AND"
if [[ 2 > 1 && 3 > 1 ]]; then
    echo "2 > 1 y 3 > 1"
fi
echo -e "\nComparando expresiones con OR"
if [[ 2 > 1 || 1 > 2 ]]; then
    echo "2 > 1 o 1 > 2"
fi
echo -e "\nComparando expresiones con NOT"
if [[ ! 1 > 2 ]]; then
    echo "1 > 2 no es cierto"
fi

	
		Overwriting scripts_bash/09_condicionales.sh

	
		!chmod +x scripts_bash/09_condicionales.sh && ./scripts_bash/09_condicionales.sh

	
		Comparando strings
hola es mayor que chao
chao es menor que hola
hola es igual que hola
hola es diferente que chao
 es una cadena vacía
chao es una cadena no vacía
chao es una cadena no vacía
Comparando números
20 es mayor que 10
20 es mayor o igual que 10
10 es menor que 20
10 es menor o igual que 10
10 es igual que 10
10 es diferente que 20
Comparando archivos
/home/wallabot/Documentos/web/portafolio/posts/scripts_bash es un directorio
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es un archivo
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb existe
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es legible
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es escribible
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb tiene contenido
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es propiedad del usuario
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es propiedad del grupo
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es más viejo que /home/wallabot/Documentos/web/portafolio/posts/scripts_bash
/home/wallabot/Documentos/web/portafolio/posts/2021-02-11-Introduccion-a-Python.ipynb es el mismo archivo que /home/wallabot/Documentos/web/portafolio/posts/scripts_bash
Comparando expresiones con AND
2 > 1 y 3 > 1
Comparando expresiones con OR
2 > 1 o 1 > 2
Comparando expresiones con NOT
1 > 2 no es cierto

Declaração de "caixa

A seguir veremos como escrever o típico "caso de troca", mas neste caso basta utilizar o "caso".

"bash caso $variavel em ) <sentença1>;; ) <sentença2>;; ) <sentença3>;; ... (*) <sentença que não satisfaça nenhuma das frases acima>. esac

	
		%%writefile scripts_bash/10_case.sh
#!/bin/bash
variable="amarillo"
case $variable in
    "rojo") echo "Color rojo";;
    "verde") echo "Color verde";;
    "azul") echo "Color azul";;
    *) echo "Color desconocido";;
esac

	
		Writing scripts_bash/10_case.sh

	
		!chmod +x scripts_bash/10_case.sh && ./scripts_bash/10_case.sh

	
		Color desconocido

Arrays

Vamos ver como as arrays se comportam no bash scripting

	
		%%writefile scripts_bash/11_arrays.sh
#!/bin/bash
arrayNumeros=(1 2 3 4 5)
arrayStrings=("hola" "chao" "adios")
arrayMixto=(1 "hola" 2 "chao" 3 "adios")
arrayVacio=()
arrayRango=({A..Z})
echo "Arrays"
echo "Array de números: ${arrayNumeros[*]}"
echo "Array de strings: ${arrayStrings[*]}"
echo "Array mixto: ${arrayMixto[*]}"
echo "Array vacío: ${arrayVacio[*]}"
echo "Array de rango: ${arrayRango[*]}"
echo -e "\nAccediendo a elementos"
echo "Primer elemento del array de números: ${arrayNumeros[0]}"
echo "Segundo elemento del array de strings: ${arrayStrings[1]}"
echo "Último elemento del array de números: ${arrayNumeros[-1]}"
echo "Penúltimo elemento del array de strings: ${arrayStrings[-2]}"
echo -e "\nLongitud de arrays"
echo "Longitud del array de números: ${#arrayNumeros[*]}"
echo "Longitud del array de strings: ${#arrayStrings[*]}"
echo "Longitud del array mixto: ${#arrayMixto[*]}"
echo "Longitud del array vacío: ${#arrayVacio[*]}"
echo "Longitud del array de rango: ${#arrayRango[*]}"
echo -e "\nAñadiendo y eliminando elementos"
arrayNumeros[5]=6
echo "Añadiendo elemento al array de números: ${arrayNumeros[*]}"
unset arrayStrings[1]
echo "Eliminando elemento del array de strings: ${arrayStrings[*]}"

	
		Overwriting scripts_bash/11_arrays.sh

	
		!chmod +x scripts_bash/11_arrays.sh && ./scripts_bash/11_arrays.sh

	
		Arrays
Array de números: 1 2 3 4 5
Array de strings: hola chao adios
Array mixto: 1 hola 2 chao 3 adios
Array vacío: 
Array de rango: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Accediendo a elementos
Primer elemento del array de números: 1
Segundo elemento del array de strings: chao
Último elemento del array de números: 5
Penúltimo elemento del array de strings: chao
Longitud de arrays
Longitud del array de números: 5
Longitud del array de strings: 3
Longitud del array mixto: 6
Longitud del array vacío: 0
Longitud del array de rango: 26
Añadiendo y eliminando elementos
Añadiendo elemento al array de números: 1 2 3 4 5 6
Eliminando elemento del array de strings: hola adios

Loop `for`

Para utilizar o laço "para", a seguinte sintaxe deve ser utilizada

"bash para <variável> em do sentença feito


      Vejamos um exemplo

	
		%%writefile scripts_bash/12_for.sh
#!/bin/bash
arrayNumeros=(1 2 3 4 5)
arrayStrings=("hola" "chao" "adios")
echo "Iterar a través de un array de numeros"
for numero in ${arrayNumeros[*]}
do
    echo "Número: $numero"
done
echo -e "\nIterar a través de un array de strings"
for string in ${arrayStrings[*]}
do
    echo "String: $string"
done
echo -e "\nIterar a través de un array no declarado"
for string in "Manolo" "Juan" "Pedro"
do
    echo "String: $string"
done
echo -e "\nIterar a través de un rango"
for i in {1..10}
do
    echo "Número: $i"
done
echo -e "\nIterar a través de un rango de manera clásica"
for (( i=1; i<=10; i++ ))
do
    echo "Número: $i"
done
echo -e "\nIterar a través de un comando"
for file in $(ls)
do
    echo "Archivo: $file"
done
echo -e "\nIterar a través de un directorio"
for file in *
do
    echo "Archivo: $file"
done

	
		Overwriting scripts_bash/12_for.sh

	
		!chmod +x scripts_bash/12_for.sh && ./scripts_bash/12_for.sh

	
		Iterar a través de un array de numeros
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Iterar a través de un array de strings
String: hola
String: chao
String: adios
Iterar a través de un array no declarado
String: Manolo
String: Juan
String: Pedro
Iterar a través de un rango
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Número: 6
Número: 7
Número: 8
Número: 9
Número: 10
Iterar a través de un rango de manera clásica
Número: 1
Número: 2
Número: 3
Número: 4
Número: 5
Número: 6
Número: 7
Número: 8
Número: 9
Número: 10
Iterar a través de un comando
Archivo: 2021-02-11-Introduccion-a-Python.ipynb
Archivo: 2021-04-23-Calculo-matricial-con-Numpy.ipynb
Archivo: 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
Archivo: 2022-09-12-Introduccion-a-la-terminal.ipynb
Archivo: 2023-01-22-Docker.ipynb
Archivo: 2023-XX-XX-Bash-scripting.ipynb
Archivo: california_housing_train.csv
Archivo: command-line-cheat-sheet.pdf
Archivo: CSS.ipynb
Archivo: Expresiones
Archivo: regulares.ipynb
Archivo: html_files
Archivo: html.ipynb
Archivo: introduccion_python
Archivo: mi_paquete_de_python
Archivo: movies.csv
Archivo: movies.dat
Archivo: notebooks_translated
Archivo: __pycache__
Archivo: scripts_bash
Archivo: ssh.ipynb
Archivo: test.ipynb
Iterar a través de un directorio
Archivo: 2021-02-11-Introduccion-a-Python.ipynb
Archivo: 2021-04-23-Calculo-matricial-con-Numpy.ipynb
Archivo: 2021-06-15-Manejo-de-datos-con-Pandas.ipynb
Archivo: 2022-09-12-Introduccion-a-la-terminal.ipynb
Archivo: 2023-01-22-Docker.ipynb
Archivo: 2023-XX-XX-Bash-scripting.ipynb
Archivo: california_housing_train.csv
Archivo: command-line-cheat-sheet.pdf
Archivo: CSS.ipynb
Archivo: Expresiones regulares.ipynb
Archivo: html_files
Archivo: html.ipynb
Archivo: introduccion_python
Archivo: mi_paquete_de_python
Archivo: movies.csv
Archivo: movies.dat
Archivo: notebooks_translated
Archivo: __pycache__
Archivo: scripts_bash
Archivo: ssh.ipynb
Archivo: test.ipynb

`while` loop

Para utilizar o laço "entretanto", utilize a seguinte sintaxe

"bash enquanto <condição> do sentença feito


      Vejamos um exemplo

	
		%%writefile scripts_bash/13_while.sh
#!/bin/bash
numero=1
while [ $numero -ne 5 ]
do
    echo "Número: $numero"
    numero=$(( numero + 1 ))
done

	
		Overwriting scripts_bash/13_while.sh

	
		!chmod +x scripts_bash/13_while.sh && ./scripts_bash/13_while.sh

	
		Número: 1
Número: 2
Número: 3
Número: 4

Controle de fluxo com `quebrar` e `continuar`.

Podemos controlar o fluxo de um loop utilizando as palavras "quebrar" e "continuar", aqui está um exemplo

	
		%%writefile scripts_bash/14_control_de_flujo.sh
#!/bin/bash
numero=1
while [ $numero -ne 10 ]
do
    if [ $numero -eq 5 ]; then
        numero=$(( numero + 1 ))
        echo "Saltando el número 5"
        continue
    elif
        [ $numero -eq 8 ]; then
        echo "Terminando el bucle"
        break
    fi 
    echo "Número: $numero"
    numero=$(( numero + 1 ))
done

	
		Overwriting scripts_bash/14_control_de_flujo.sh

	
		!chmod +x scripts_bash/14_control_de_flujo.sh && ./scripts_bash/14_control_de_flujo.sh

	
		Número: 1
Número: 2
Número: 3
Número: 4
Saltando el número 5
Número: 6
Número: 7
Terminando el bucle

Funções

A sintaxe das funções de escrita é

<nombre de funcion> (){
            sentencias
        }

Aqui está um exemplo

	
		%%writefile scripts_bash/15_funciones.sh
#!/bin/bash
funcion () {
    echo "Soy una función"
}
funcoionConParametros () {
    echo "Soy una función con parámetros"
    echo "Parámetro 1: $1"
    echo "Parámetro 2: $2"
}
funcion
funcoionConParametros "Hola" "Adiós"

	
		Writing scripts_bash/15_funciones.sh

	
		!chmod +x scripts_bash/15_funciones.sh && ./scripts_bash/15_funciones.sh

	
		Soy una función
Soy una función con parámetros
Parámetro 1: Hola
Parámetro 2: Adiós

Continuar lendo

Fundamentos de RAG

Esqueça o Ctrl+F! 🤯 Com RAG, seus documentos responderão às suas perguntas diretamente. 😎 Tutorial passo a passo com Hugging Face e ChromaDB. Liberte o poder da IA (e impressione seus amigos)! 💪

Conventional commits

😠 Seus commits parecem escritos em uma língua alienígena? 👽 Junte-se ao clube! 😅 Aprenda Conventional Commits em Python e pare de tortura sua equipe com mensagens enigmáticas. git-changelog e commitizen serão seus novos melhores amigos. 🤝

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

Você já conversou com um LLM e ele lhe respondeu algo que parece ter bebido café de máquina a noite toda? 😂 Isso é o que chamamos de alucinação no mundo dos LLMs! Mas não se preocupe, pois não é que seu modelo de linguagem esteja louco (embora às vezes possa parecer isso 🤪). A verdade é que os LLMs podem ser um pouco... criativos quando se trata de gerar texto. Mas graças ao DoLa, um método que usa camadas de contraste para melhorar a viabilidade dos LLMs, podemos evitar que nossos modelos de linguagem se transformem em escritores de ficção científica 😂. Nesta publicação, explicarei como o DoLa funciona e mostrarei um exemplo de código para que você possa entender melhor como tornar seus LLMs mais confiáveis e menos propensos a inventar histórias. Vamos salvar nossos LLMs da loucura e torná-los mais úteis! 🚀

Últimos posts -->

Você viu esses projetos?

Subtify

GPU monitor

Alfred

Ver todos os projetos -->

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

Memory Calculator

Espaço para calcular a memória necessária para executar um modelo

Formatador de código Black

Seu colega Filipao está escrevendo código que é difícil de ler? Compartilhe com ele este formatador de código que eu mostro neste post! Venha e aprenda a formatar o código para torná-lo mais compreensível. Não vamos resolver os problemas de Filipao, mas pelo menos você não sofrerá ao lê-lo

Declare redes neurais de forma clara

Declare redes neurais de forma clara no Pytorch

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.

token_hmr

tooncrafter

marker_api

Ver todos os contêineres -->

Quer aplicar IA no seu projeto? Entre em contato!

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

Dataset com piadas em inglês

opus100

Dataset com traduções de inglês para espanhol

netflix_titles

Dataset com filmes e séries da Netflix

Ver mais datasets -->

Bash scripting

Pasta com scripts

Primeiro roteiro

Especificação do binário de execução

Comentários em scripts bash

Este é um comentário de uma linha

Imprimir na tela com o comando `echo

Declaração variável

Âmbito das variáveis

Exportação de variáveis

Tipos de operadores

Etapa da argumentação

Executar comandos e armazená-los em uma variável

Depuração

Obter informações do usuário

Obter informações utilizando os comandos echo e read.

Obter informações somente através do comando "ler

Validar informações do usuário

Se mais

Expressões condicionais

Declaração de "caixa

Arrays

Loop for

while loop

Controle de fluxo com quebrar e continuar.

Funções

Continuar lendo

Fundamentos de RAG

Conventional commits

DoLa – Decoding by Contrasting Layers Improves Factuality in Large Language Models

Você viu esses projetos?

Quer aplicar IA no seu projeto? Entre em contato!

Quer melhorar com essas dicas?

Memory Calculator

Formatador de código Black

Declare redes neurais de forma clara

Use isso localmente

Quer aplicar IA no seu projeto? Entre em contato!

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

opus100

netflix_titles

Obter informações utilizando os comandos `echo` e `read`.

Loop `for`

`while` loop

Controle de fluxo com `quebrar` e `continuar`.