Aprende a dominar los operadores en Bash con un enfoque práctico y claro. Aquí verás cómo crear y documentar un script, trabajar con variables y aplicar operadores aritméticos, relacionales y de asignación, además de consejos de edición para agilizar tu trabajo en Ubuntu.
Operadores en Bash: aritméticos, relacionales y de asignación en un script práctico
¿Qué operadores existen en Bash y cuándo usarlos?
Los tipos clave son: aritméticos, relacionales, condicionales, lógicos y bitways (para trabajar con bits). En este recorrido se aplican tres: aritméticos, relacionales y de asignación. Los lógicos y bitways se usan en otros contextos del desarrollo.
Aritméticos: suma, resta, multiplicación, división y residuo.
Relacionales: mayor que, menor que, mayor o igual, menor o igual, igual, diferente.
Asignación: formas cortas como +=, -=, *=, %= para actualizar valores.
Buenas prácticas: documentar autor, fecha y objetivo; pensar en el equipo que mantendrá el script.
Variables base: se emplean dos números, A=10 y B=4, para mostrar las operaciones.
¿Cómo preparar y documentar el script en Ubuntu?
Trabaja desde tu directorio Home y dentro de la carpeta de curso, por ejemplo Shell Course. Crea un archivo con extensión .sh y añade un encabezado que identifique el propósito y la autoría.
¿Cómo crear el archivo y el encabezado?
#!/bin/bash# Programa: revisar tipos de operadores# Descripción: muestra operadores aritméticos, relacionales y de asignación.# Autor: Tu nombre# Fecha: AAAA-MM-DD# Contacto: @martosperA=10B=4
¿Qué buenas prácticas y atajos aceleran el trabajo?
Usa extensión .sh para tus scripts.
Documenta propósito, autor, fecha y contacto.
Piensa en otros desarrolladores que mantendrán el código.
Primero imprime valores para tener contexto. Luego realiza las operaciones con expansión aritmética y muestra resultados. Finalmente, enumera comparaciones relacionales y aplica formas abreviadas de asignación.
Es un profesor ecuatoriano y esa es la forma de hablar de la gente en la sierra de Ecuador. Platzi es una plataforma multicultural y muchas de las formas de hablar de algunos paises pueden causar ruido para otros...
Falto explicar un operador aritmetico al profesor, el de potenciación. Me hizo falta no verlo en los operadores y probando con el script descubrí que el operador de potenciación es:
8**2=64
No fue tan dificil ya que es el mismo que el de Python
La expresión "$variable" realiza que se imprima el contenido de la variable como si fuera un tipo de dato String aunque ,como en el caso del ejemplo del profesor, son enteros.
.
Ahora, los primeros paréntesis o paréntesis externos de la expresión "$((A+B))" indican el limite a que refiere la expresión, es decir su alcance de impresión. Lo que contiene lo paréntesis internos es un calculo o una operación que se realiza con su tipo de variable "nativo", es decir, como enteros. Es por ello, que las operaciones de relaciones y asignación no tienen inconvenientes en resolverse al igual que los aritméticos.
.
Mas si se usará la expresión "$(A+B)", en la consola nos saldría un error.
Para los que usan alguna distribución de linux les recomiendo usar la terminal de Tilix :)
Permite tener varias terminales al mismo tiempo y está mas elegante ;)
Para entender mejor ++lo que realmente sucede en la parte de Operadores de Asignacion++ podemos fijarnos que el valor de A ha sido modificado en cada operacion. Podemos visualizar esto agregando la linea de codigo:
echo "E A = $numA"
debajo de cada operacion.
El codigo para esa parte quedaria asi:
echo -e "\nOperadores de asignacion"echo "Numeros: A=$numA y B=$numB"echo "Sumar A += B"$((numA += numB))echo "NUEVO VALOR de A = $numA"echo "Restar A -= B"$((numA -= numB))echo "NUEVO VALOR de A = $numA"echo "Multiplicar A *= B"$((numA *= numB))echo "NUEVO VALOR de A = $numA"echo "Dividir A /= B"$((numA /= numB))echo "NUEVO VALOR de A = $numA"echo "Residuo A %= B"$((numA %= numB))echo "NUEVO VALOR de A = $numA"
Al comparar comparar estos resultados con los de Operadores Aritmeticos pareceran bastante similares y esto se da ya que estamos haciendo la operacion una operacion y seguido su operacion inversa, asi que en Operacores de asignacion el valor de A vuelve a como estaba y sobrevive hasta la operacion de asignacion con Residuo para dar el mismo resultado
Muy bien explicado el tema de los operadores. Despejando las dudas hasta ahora con el curso. Mi ejercicio queda asi:
#!/usr/bin/env bash# lec_3.sh file
# !/bin/bash // it is used in the course# Author: name - @name
#operators
A=10B=4echo "BASIC ARITHMETIC OPERATORS"echo -e "inputs: A=$A , B=$B\n"echo "Addition operator: A+B="$((A+B))echo "Subtraction operator: A-B="$((A-B))echo "Multiplication operator: A*B="$((A*B))echo "Division operator: A/B="$((A/B))echo "Module operator: A%B="$((A%B))echo -e "\n------------------------------------------"# use -e to support especial characters
x=10y=4echo -e "\n"echo -e "BASIC RELATIONAL OPERATORS"echo -e "inputs: x=$x , y=$y\n"echo "x > y , x is greater than y :"$((x > y))echo "x ≥ y , x is greater (than) or equal to y :"$(( x>= y))echo "x < y , x is smaller than y :"$((x < y))echo "x ≤ y , x is smaller (than) or equal to y :"$((x <= y))echo "x > 0 , x is positive :"$((x >0))echo "x ≥ 0 , x is positive or zero; x is non-negative :"$((x >= y))echo "x < 0 x is negative :"$((x <0))echo "x ≤ 0 x is negative or zero :"$((x <= y))echo -e "\n------------------------------------------"echo -e "\nBASIC ASSIGNATION OPERATORS"echo -e "inputs: x=$x , y=$y\n"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 ))
$() se utiliza para ejecutar un comando y obtener su salida.
files=$(ls)# Contenido del directorio de trabajo
$(()) se utiliza para evaluar expresiones numéricas en el dominio de los números enteros.
result=$((1+1))# 2
Por lo tanto, al intentar evaluar $( 1 + 1) daría un error porque no es un comando válido.
El script utilizando printf en lugar de echo.
Es un poco más complejo printf, pero se supone que es más amigable con los scripts de bash, porque no tiene problemas de interoperatibilidad como echo, ya que no todos los os tienen la misma versión, por lo que echo -e podría funcionar en un servidor y no en otro.
#!/bin/bash#Programa para revisar los tipos de operadores
# En printf %s indica string %i indica integer %% imprime %# \n es para indicar newline \t para indicar tabulación
numA=10numB=4printf "Operadores aritméticos\n"printf "Números: A=%i y B=%i\n" $numA $numB
printf "Sumar A + B =%i\n"$((numA + numB))printf "Restar A - B =%i\n"$((numA - numB))printf "Multiplicar A * B =%i\n"$((numA * numB))printf "Dividir A / B =%i\n"$((numA / numB))printf "Residuo A %% B =%i\n\n"$((numA % numB))printf "Operadores relacionales\n"printf "Números: A=%i y B=%i\n" $numA $numB
printf "A > B =%s\n"$((numA > numB))printf "A < B =%s\n"$((numA < numB))printf "A >= B =%s\n"$((numA >= numB))printf "A <= B =%s\n"$((numA <= numB))printf "A == B =%s\n"$((numA == numB))printf "A != B =%s\n\n"$((numA != numB))printf "Operadores de asignación\nConsiderar que A va cambiando por la asignación, por lo que A - B no es 6\n"printf "Números: A=%i y B=%i\n" $numA $numB
printf "Sumar A += B =%s\n"$((numA += numB))printf "Restar A -= B =%s\n"$((numA -= numB))printf "Mulitiplicar A *= B =%s\n"$((numA *= numB))printf "Dividir A /= B =%s\n"$((numA /= numB))printf "Residuo A %%= B =%i\n\n"$((numA %= numB))
Hola
Les comparto el 3_tipoOperadores.sh realizado en clase.
# !/bin/bash
# Programa para revisar los tipos de operadores
numA=10numB=4echo "Operadores Aritméticos"echo "Números: A=$numA y B=$numB"echo "Sumar A + B = "$((numA + numB))echo "Restar A - B = "$((numA - numB))echo "Multiplicar A * B = "$((numA * numB))echo "Dividir A / B = "$((numA / numB))echo "Residuo A % B = "$((numA % numB))echo -e "\nOperadores Relacionales"echo "Números: A=$numA y B=$numB"echo "A > B = "$((numA > numB))echo "A < B = "$((numA < numB))echo "A >= B = "$((numA >= numB))echo "A <= B = "$((numA <= numB))echo "A == B = "$((numA == numB))echo "A != B = "$((numA != numB))echo -e "\nOperadores de Asignacion"echo "Números: A=$numA y B=$numB"echo "Sumar A += B = "$((numA += numB))echo "Restar A -= B = "$((numA -= numB))echo "Multiplicar A *= B = "$((numA *= numB))echo "Dividir A /= B = "$((numA /= numB))echo "Residuo A %= B = "$((numA %= numB))
Saludos
Corrijo la linea de codigo que podemos agregar:
echo "NUEVO VALOR de A = $numA"
Porque la anterior al "A -= B" hubo una suma cuyo resultado queda almacenado en A.
1.-A=10,B=42.-Suma y asignación
A+=B → A=A+B → A=10+4 → A=14"A" ya no vale 10, vale 143.-Resta y asignación
A-=B → A=A-B → A=14-4 → A=10"A" ya no vale 14, ahora vale 10
En esencia, el resultado de la operación que realicemos queda almacenado en la variable del lado izquierdo del =.