Tipos de Operadores

Agregue algunos saltos de linea para dar un poco de formato.

#!/usr/bin/env bash
# lec_3.sh file
# ! /bin/bash  // it is used in the course
# Author: name - @name

#operators
A=10
B=4
echo "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=10
y=4
echo -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 ))

Si quieren hacerlo mas interactivo pueden usar el comando read para leer los inputs desde la consola, como en el siguiente ejemplo

#!/bin/sh
echo "Please give a random number"
read num1
echo "Please give me another one"
read num2
echo "The sum is $((num1+num2))"

Recomiendo mejorar “el tema de” la muletilla.

Qué lata con “el tema” de la muletilla 🥴

este tipo de clases en donde el procesor te va explicando y además vas practicando son geniales y hacen que aprendas mejor y no pierdas en el interes.

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

Los shortcuts que da el profe para los que usamos vim son oro puro

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 😉

En vez de:

numA=10
numB=4

Intentar:

read numA numB <<<$(echo 10 4)

Hola

Les comparto el 3_tipoOperadores.sh realizado en clase.

# ! /bin/bash
# Programa para revisar los tipos de operadores

numA=10
numB=4

echo "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

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=10
numB=4

printf "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))

Tambien pueden obtener resultados de operaciones aritmeticas usando el comando expr

expr 5 + 10
echo $((5 + 10))

Ambos metodos retornan el mismo resultado.

Sobre los Operadores de Asignacion…

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

Recursos para los trucos de vim

https://vim.rtorr.com/

La verdad el curso me parece muy malo, el contraste de video es muy feo, no se distingue claramente, una pena y gran perdida de tiempo

#!/bin/bash

Operador de asignación

x=5
echo “x = $x”

Operador de suma

y=10
z=$((x + y))
echo “x + y = $z”

Operador de resta

z=$((x - y))
echo “x - y = $z”

Operador de multiplicación

z=$((x * y))
echo “x * y = $z”

Operador de división

z=$((x / y))
echo “x / y = $z”

Operador de módulo

z=$((x % y))
echo “x % y = $z”

Operador de exponenciación

z=$((x ** y))
echo “x ** y = $z”

Operador de negación

z=$((!x))
echo “!x = $z”

Operador de complemento

z=$((~x))
echo “~x = $z”

Operador de desplazamiento a la izquierda

z=$((x << y))
echo “x << y = $z”

Operador de desplazamiento a la derecha

z=$((x >> y))
echo “x >> y = $z”

Operador de AND

z=$((x & y))
echo “x & y = $z”

Operador de OR

z=$((x | y))
echo “x | y = $z”

Operador de XOR

z=$((x ^ y))
echo “x ^ y = $z”

Muy bien explicado el tema de los operadores. Despejando las dudas hasta ahora con el curso. Mi ejercicio queda asi:

como hago para cambiar ese color de azul como comentarios en el # alguien que me pueda ayudar porfa?

LAgo interesante es que en las relacionales en vez del un true o false devuelve un numero binario de 1 = true y 0 = false

En el ejercicio del profesor, en la sección “Operadores Asignación”, ¿no deberían ser los resultados 6 y 2 en las líneas de restar y dividir respectivamente? Muestra el 10 en ambos casos.

Codigo

# !/bin/bash
# Programa para revisar los tipos de operadores
# Author: Nelson Sanchez @anthony_snk

numA=10
numB=4

echo -e "\nOperadores Aritmeticos"
echo -e "Numeros: A= $numA Y B= $numB"
echo -e "Sumar A+B = "$((numA + numB))
echo -e "Restar A-B = "$((numA - numB))
echo -e "Multiplicar A*B = "$((numA * numB))
echo -e "Dividir A/B = "$((numA / numB))
echo -e "Residuo A%B = "$((numA % numB))

echo -e "\nOperadores Relacionales"
echo -e "Numeros: A= $numA Y B= $numB"
echo -e "A>B = "$((numA > numB))
echo -e "A<B = "$((numA < numB))
echo -e "A>=B = "$((numA >= numB))
echo -e "A<=B = "$((numA <= numB))
echo -e "A==B = "$((numA == numB))
echo -e "A!=B = "$((numA != numB))


echo -e "\nOperadores Asignacion"
echo -e "Numeros: A= $numA Y B= $numB"
echo -e "Sumar A+=B = "$((numA += numB))
echo -e "Restar A-=B = "$((numA -= numB))
echo -e "Multiplicar A*=B = "$((numA*= numB))
echo -e "Dividir A/=B = "$((numA/= numB))
echo -e "Residuo A%=B = "$((numA %= numB))

#! /bin/bash

num_a=10
num_b=4

echo "Basic arithmetic operators"
echo "Numbers: a=$num_a and b=$num_b"
echo "Sum a + b = " $((num_a + num_b))
echo "Subtract a - b = " $((num_a - num_b))
echo "Multiply a * b = " $((num_a * num_b))
echo "Divide a / b = " $((num_a / num_b))
echo "Residue a % b = " $((num_a % num_b))

echo -e "\nBasic relational operators"
echo "Numbers: a=$num_a and b=$num_b"
echo "a > b = " $((num_a > num_b))
echo "a < b = " $((num_a < num_b))
echo "a >= b = " $((num_a >= num_b))
echo "a <= b = " $((num_a <= num_b))
echo "a == b = " $((num_a == num_b))
echo "a != b = " $((num_a != num_b))

echo -e "\nBasic asignation operators"
echo "Numbers: a=$num_a and b=$num_b"
echo "Sum a += b = " $((num_a += num_b))
echo "Subtract a -= b = " $((num_a -= num_b))
echo "Multiply a *= b = " $((num_a *= num_b))
echo "Divide a /= b = " $((num_a /= num_b))
echo "Residue a %= b = " $((num_a %= num_b))

Arithmetic Operators:

Addition: +
Subtraction: -
Multiplication: *
Division: /
Modulo (remainder): %
Increment: ++
Decrement: –
.
.

a=5
b=3

sum=$((a + b))
difference=$((a - b))
product=$((a * b))
quotient=$((a / b))
remainder=$((a % b))
((a++))
((b--))

echo "Sum: $sum"
echo "Difference: $difference"
echo "Product: $product"
echo "Quotient: $quotient"
echo "Remainder: $remainder"
echo "Incremented a: $a"
echo "Decremented b: $b"

! /bin/bash

#programa para revisar el tipo de operadores

numA=10
numB=4

echo "operadores aritmeticos"
echo "Numero: 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 "reciduo A % B = " $((numA % numB))

echo -e "\n"
echo -e "operadores relacionales"
echo "Numero: 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))

-e te permite instertar caracteres especiales

echo -e "\n"
echo -e "operadores de asignacion"
echo "Numero: 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 “reciduo A %= B” $((numA %= numB))

Pero curiosamente

35 echo -ne "\tA < B =" && ( ((NumA<NumB)) && echo "cierto" || echo "falso")

también funciona bien.

La comparación de enteros para usarla como condicional , es con -lt, -le, -gt, -ge, -ne, -eq, como queda reflejada en este ejercicio.

#!/bin/bash
  2 # Autor JRPF, DIC -22   
  3 # Programa los tipos de operadores
  4 
  5 NumA=20
  6 NumB=12
  7 
  8 echo -e "\tOperadores Relacionales"
  9 # y si el valor es 1 es cierto, 0 es falso, al igual que en C
 10 # la opcion -n anula el salto de línea tras el echo
 11 # la comparación de enteros se realiza con -lt, -le, -gt, -ge, -ne, -eq
 12 # menor que, menor igual, mayor que, mayor igual, no igual, igual
 13 echo -e "\tA < B =" $((NumA<NumB))
 14 echo -ne "\tA < B =" && ([ "$NumA" -lt "$NumB" ] && echo "cierto" || echo "falso")
 15 echo -e "\tA > B =" $((NumA>NumB))
 16 echo -ne "\tA > B =" && ([ "$NumA" -gt "$NumB" ] && echo "cierto" || echo "falso")
 17 echo -e "\tA <= B =" $((NumA<=NumB))
 18 echo -ne "\tA <= B =" && ([ "$NumA" -le "$NumB" ] && echo "cierto" || echo "falso")
 19 echo -e "\tA >= B =" $((NumA>=NumB))
 20 echo -ne "\tA >= B =" && ([ "$NumA" -ge "$NumB" ] && echo "cierto" || echo "falso")
 21 echo -e "\tA == B =" $((NumA==NumB))
 22 echo -ne "\tA == B =" && ([ "$NumA" -eq "$NumB" ] && echo "cierto" || echo "falso")
 23 echo -e "\tA != B =" $((NumA!=NumB))
 24 echo -ne "\tA != B =" && ([ "$NumA" -ne "$NumB" ] && echo "cierto" || echo "falso")

Código

#!/bin/bash
# Program to check the operators types
# Author: Cristian Camilo - Cristianco9

numA=10
numB=4

echo "Arithmetic operators"
echo "Numbers: A=$numA and B=$numB"
echo -e "\nAdd A + B=" $((numA + numB))
echo "Subtract A - B=" $((numA - numB))
echo "Multiply A * B=" $((numA * numB))
echo "Divide A / B=" $((numA / numB))
echo "Residue A % B=" $((numA % numB))

echo -e "\nRelational operators"
echo "Numbers: A=$numA and B=$numB"
echo -e "\nA > 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 "\nAssignment operators"
echo "Numbers: A=$numA and B=$numB"
echo -e "\nAdd A += B =" $((numA += numB))
echo "Subtract A -= B =" $((numA -= numB))
echo "Multiply A *= B =" $((numA *= numB))
echo "Divide A /= B =" $((numA /= numB))
echo "Residue A %= B =" $((numA %= numB))

Terminal

tambien puedes definir entre comillas las variables a ejecutar sin sacarlas de la comilla por si te parece mas sencillo, algo asi:
#varaibles
numA=10
numB=4
echo “Numeros: A=$numA y B=$numB”

Shortchuts para VIM:
https://vim.rtorr.com

xney@ubunto:~/shellcourse$ bash 3_tipoOperadores.sh
operadores arimeticos
numeros: A=10 y B=4
sumar A + B = 14
resta A - B = 6
multiplicar A * B = 40
dividir A / B = 2
residuo A % B = 2

< operadores relacionales >

    \   ^__^
     \  (oo)\_______
        (__)\       )\/\
            ||----w |
            ||     ||

numeros: A=10 y B=4
A > B = 1
A < B = 0
A >= B = 1
A <= B = 0
A == B = 0
A != B = 1

< operadores asignacion >

.–.
|o_o |
|:_/ |
// \
(| | )
/’_ /`
_)=(/

A += B = 14
A -= B = 10
A *= B = 40
A /= B = 10
A %= B = 2

#!/bin/bash
#Operadores

numA=10
numB=4

echo "Operadores Aritmeticos"
echo -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nSumar 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 -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nA > 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 -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nSumar 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))”

Asi quedaria el codigo con algo de espacios extras para que se vea mejor en la ejecucion.

Tambien está el codigo para que lo puedas copiar y pegar sin problemas
#!/bin/bash
#Operadores

numA=10
numB=4

echo "Operadores Aritmeticos"
echo -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nSumar 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 -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nA > 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 -e "\nNumeros: A=$numA y B=$numB"
echo -e "\nSumar 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))”

Aqui el resultado de la ejecucion del Script

Cuando no tienes GUI lo mejor en terminal para mi es usar VIM. Ademas si configuras multiples pantallas te queda genial

Muy buena clase sobre los tipos de operadores, lo mas esencial para los que apenas van iniciando en este mundo de la CLI.

También pueden escribir la expresiónn de la suma dentro de los “”

echo “Sumar A + B: $((numA + numB))”

Código de la clase:

Muy buena la clase.

Si desean pueden hacer el curso desde Visual Code sin lio, igual todo se ejecuta en la consola, e incluso se pueden conectar al servidor por SSH con un pluging

Alguien me explica porque tengo esos resultados con los operadores de asignacion

Perfecto! Aún compila mi shell. 😄

Hola, quiero compartir mis apuntes.

https://www.instagram.com/p/CFI9IMqnEIV/?igshid=tmbqou5fs5vp

Saludos

genial

Entendido

clase entendida!

a

a

Se sigue el standard de la mayoría de lenguajes en cuanto a los operadores aritméticos

# ! /bin/bash
# Programa para revisar los tipos de operadores
# Autor: Marco Toscano - @martosfre

numA=10
numB=4

echo "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 Relaciones"
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 Asignación"
echo "Números: A=$numA y B=$numB"
echo "Sumar A += B" $((numA += numB))
echo "Restar A -= B" $((numA -= numB))
echo "Multiplicación A *= B" $((numA *= numB))
echo "Dividir A /= B" $((numA /= numB))
echo "Residuo A %= B" $((numA %= numB))```