No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

5D
2H
22M
3S
Curso de Programaci贸n en Bash Shell

Curso de Programaci贸n en Bash Shell

Marco Antonio Toscano Freire

Marco Antonio Toscano Freire

Tipos de Operadores

7/43
Recursos

Aportes 52

Preguntas 12

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥渆l tema de鈥 la muletilla.

Qu茅 lata con 鈥渆l 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.

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 馃槈

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

En vez de:

numA=10
numB=4

Intentar:

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

Tambien pueden obtener resultados de operaciones aritmeticas usando el comando expr

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

Ambos metodos retornan el mismo resultado.

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

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

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

#!/bin/bash

Operador de asignaci贸n

x=5
echo 鈥渪 = $x鈥

Operador de suma

y=10
z=$((x + y))
echo 鈥渪 + y = $z鈥

Operador de resta

z=$((x - y))
echo 鈥渪 - y = $z鈥

Operador de multiplicaci贸n

z=$((x * y))
echo 鈥渪 * y = $z鈥

Operador de divisi贸n

z=$((x / y))
echo 鈥渪 / y = $z鈥

Operador de m贸dulo

z=$((x % y))
echo 鈥渪 % y = $z鈥

Operador de exponenciaci贸n

z=$((x ** y))
echo 鈥渪 ** 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 鈥渪 << y = $z鈥

Operador de desplazamiento a la derecha

z=$((x >> y))
echo 鈥渪 >> y = $z鈥

Operador de AND

z=$((x & y))
echo 鈥渪 & y = $z鈥

Operador de OR

z=$((x | y))
echo 鈥渪 | y = $z鈥

Operador de XOR

z=$((x ^ y))
echo 鈥渪 ^ y = $z鈥

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.

Recursos para los trucos de vim

https://vim.rtorr.com/

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

! /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 鈥渞estar A -= B鈥 $((numA -= numB))
echo 鈥渕ultiplicar A * B鈥 $((numA *= numB))
echo 鈥渄ividir A /= B鈥 $((numA /= numB))
echo 鈥渞eciduo 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 鈥淣umeros: A=$numA y B=$numB鈥

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

Hacer esto me recuerda a programar en BASIC II

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

[email protected]:~/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 鈥淩esiduo 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 鈥淎 != 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 鈥淩esiduo 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 鈥淩esiduo 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 鈥淎 != 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 鈥淩esiduo 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 鈥淪umar A + B: $((numA + numB))鈥

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))```