Procesamiento de Datos con Operadores en Golang

GolangBeginner
Practicar Ahora

Introducción

Una vez que los datos se guardan en variables dentro de un lenguaje de programación, ¿cómo debemos procesarlos?

Es aquí cuando necesitamos los operadores para realizar cálculos sobre los datos almacenados. En esta sección, aprenderemos lo siguiente:

Puntos de conocimiento:

  • Operadores Aritméticos
  • Operadores Relacionales
  • Operadores Lógicos
  • Operadores de Asignación
Este es un Laboratorio Guiado, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y ganar experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 96%. Ha recibido una tasa de valoraciones positivas del 100% por parte de los alumnos.

Formas Básicas

Los operadores aritméticos son los más fundamentales, ya que representan los métodos de cálculo básicos.

Operador Función
+ Suma
- Resta
* Multiplicación
/ División
% Módulo (Residuo)

Crea un archivo llamado opePractice.go en el directorio home/project/:

cd ~/project
touch opePractice.go

Escribe el siguiente código en él:

package main

import "fmt"

func main() {
    a := 10
    b := 3
    fmt.Println("a =", a, "b =", b)
    fmt.Println("-----")

    // Suma, resta y multiplicación
    fmt.Println("a + b =", a+b)
    fmt.Println("a - b =", a-b)
    fmt.Println("b - a =", b-a)
    fmt.Println("a * b =", a*b)

    // División
    // En Go, si se divide un entero, el resultado se redondea hacia abajo.
    fmt.Println("a / b =", a/b)
    // Pero si se divide un número de punto flotante, no habrá tal problema.
    fmt.Println("10.0 / 3 =", 10.0/3)

    // Cálculo de módulo: forma general
    fmt.Println("a % b =", a%b)
    // Cálculo de módulo con números negativos
    // Método de cálculo: residuo = dividendo - (dividendo / divisor) * divisor
    fmt.Println("10 % -3 =", 10%-3)
    fmt.Println("-10 % 3 =", -10%3)
    fmt.Println("-10 % -3 =", -10%-3)
}

Ejecuta el código y presta especial atención a cómo se calcula el residuo negativo.

cd ~/project
go run opePractice.go
a = 10 b = 3
-----
a + b = 13
a - b = 7
b - a = -7
a * b = 30
a / b = 3
10.0 / 3 = 3.3333333333333335
a % b = 1
10 % -3 = 1
-10 % 3 = -1
-10 % -3 = -1

Operadores de Incremento y Decremento

En Go, ++ (incremento) y -- (decremento) son sentencias independientes y solo pueden usarse de forma autónoma; no funcionan como operadores dentro de una expresión.

El siguiente código es incorrecto:

var a int = 5
var i int = 0
a = i++ // Uso incorrecto, el incremento solo puede usarse de forma independiente
a = i-- // Uso incorrecto, el decremento solo puede usarse de forma independiente
a = ++i // Uso incorrecto, Go no tiene pre-incremento
a = --i // Uso incorrecto, Go no tiene pre-decremento

La sintaxis adecuada es:

var i = 0
i++
i++
fmt.Println(i)

Escribe el siguiente código en opePractice.go:

Completa el código. Cambia el valor de la variable i utilizando el operador de incremento, de modo que el valor de la variable a se convierta en 16:

package main

import "fmt"

func main() {
    var a int = 15
    var i int = 0
    /* Escribe el código debajo */

    a = a + i
    fmt.Println(a)
    // Completa el código para que la salida de a sea igual a 16
}
✨ Revisar Solución y Practicar

Operadores Relacionales

¿Qué son los operadores relacionales?

Los operadores relacionales son una forma de comparación que describe la relación entre dos valores. Determinan si dos valores son iguales, o si uno es mayor o menor que el otro.

Operador Relación
== Igual a
!= Diferente de
> Mayor que
>= Mayor o igual que
< Menor que
<= Menor o igual que

Los operadores anteriores devuelven true si la condición se cumple y false en caso contrario.

Escribe el siguiente código en opePractice.go:

package main

import "fmt"

func main() {
    // Uso de operadores relacionales
    var a int = 7
    var b int = 6
    // Comprobar si son iguales
    fmt.Println(a == b)  //false
    // Comprobar si son diferentes
    fmt.Println(a != b)  //true
    // Comprobar si a es mayor que b
    fmt.Println(a > b)   //true
    // Comprobar si a es mayor o igual que b
    fmt.Println(a >= b)  //true
    // Comprobar si a es menor que b
    fmt.Println(a < b)   //false
    // Comprobar si a es menor o igual que b
    fmt.Println(a <= b)  //false
    // Comprobar si 1 es igual a 1
    judgeValue := 1 == 1 //true
    fmt.Println(judgeValue)
}

Ejecuta el código:

cd ~/project
go run opePractice.go

En el código anterior, realizamos comparaciones relacionales basadas en las variables a y b.

Puedes modificar los valores de las variables para cambiar los resultados de la comparación y comprender mejor los operadores relacionales.

Operadores Lógicos

¿Qué son los operadores lógicos?

Los operadores lógicos son una forma avanzada de los operadores relacionales. Se utilizan principalmente para combinar operadores relacionales y realizar evaluaciones más complejas.

Operador Relación Explicación
&& Y (AND) Si ambos operandos son true, el resultado es true
|| O (OR) Si cualquiera de los operandos es true, el resultado es true
! No (NOT) Si la condición es false, el resultado es true

Escribe el siguiente código en opePractice.go:

package main

import (
    "fmt"
)

func main() {
    // Demostración del operador lógico AND &&
    var age int = 18
    if age > 15 && age < 30 {
        fmt.Println("La edad está entre 15 y 30")
    }
    if age > 30 && age < 80 {
        fmt.Println("La edad está entre 30 y 80")
    }
    // Demostración del operador lógico OR ||
    if age > 15 || age < 30 {
        fmt.Println("La edad es mayor de 15 o menor de 30")
    }
    if age > 30 || age < 40 {
        fmt.Println("La edad es mayor de 30 o menor de 40")
    }
    // Demostración del operador lógico NOT !
    if age > 30 {
        fmt.Println("La edad es mayor de 30")
    }
    if !(age > 30) {
        fmt.Println("La edad no es mayor de 30")
    }
}

En el código anterior, realizamos una serie de evaluaciones lógicas basadas en el valor de la variable age, que es 18.

Ejecuta el código:

cd ~/project
go run opePractice.go

Puedes modificar el valor de la variable de edad y ejecutar el código para observar los cambios en la salida.

Orden de Ejecución de los Operadores Lógicos

Al usar los operadores lógicos AND y OR, Go necesita determinar los valores booleanos en ambos lados del operador. Pero, ¿qué lado se evalúa primero?

Explorémoslo juntos.

Escribe el siguiente código en opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("¡Se llama a la función izquierda!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("¡Se llama a la función derecha!")
    return true
}

func main() {
    if leftFunc(true) && rightFunc(true) {
        fmt.Println("La evaluación se ha completado")
    }
}

Ejecuta el código:

cd ~/project
go run opePractice.go
¡Se llama a la función izquierda!
¡Se llama a la función derecha!
La evaluación se ha completado

No es difícil notar que en la operación lógica AND, primero se evalúa el operando de la izquierda y luego el de la derecha.

¿Qué sucede con la operación lógica OR? Escribe el siguiente código en opePractice.go:

package main

import "fmt"

func leftFunc(flag bool) bool {
    fmt.Println("¡Se llama a la función izquierda!")
    return flag
}

func rightFunc(flag bool) bool {
    fmt.Println("¡Se llama a la función derecha!")
    return true
}

func main() {
    if leftFunc(true) || rightFunc(true) {
        fmt.Println("La evaluación lógica OR se ha completado")
    }
}

Ejecuta el código:

cd ~/project
go run opePractice.go
¡Se llama a la función izquierda!
La evaluación lógica OR se ha completado

El orden de evaluación tanto para el AND lógico como para el OR lógico es de izquierda a derecha.

Sin embargo, en la operación lógica OR, si el operando de la izquierda es verdadero, el operando de la derecha no se evalúa (esto se conoce como cortocircuito).

Por lo tanto, en el desarrollo real, debemos colocar las condiciones que tienen más probabilidades de ser verdaderas en el lado izquierdo del operador lógico OR, reduciendo así el tiempo de ejecución del programa.

Operadores de Asignación

En laboratorios anteriores, hemos utilizado frecuentemente los operadores de asignación. La función principal de estos operadores es asignar el valor de una expresión a un operando situado a la izquierda.

Operando de mano izquierda: La expresión o variable a la izquierda del operador de asignación (=) en la que se puede escribir.

En el desarrollo real, a menudo necesitamos sumar o restar un valor a una variable existente.

Basándonos en lo que hemos aprendido, podríamos escribir código como este:

x = x + 1

Pero como este tipo de código es muy común, se proporciona una forma abreviada para ello:

x += 1

De manera similar, los operadores de asignación comúnmente utilizados incluyen:

Operador Descripción
= Operador de asignación básico
+= Sumar y asignar
-= Restar y asignar
*= Multiplicar y asignar
/= Dividir y asignar
%= Módulo y asignar (residuo)

Escribe el siguiente código en opePractice.go:

package main

import "fmt"

func main() {
    x := 11
    fmt.Println("Valor inicial de x:", x)
    x += 5 // x = x + 5
    fmt.Println("Valor después de x += 5:", x)
    x -= 5 // x = x - 5
    fmt.Println("Valor después de x -= 5:", x)
    x *= 5 // x = x * 5
    fmt.Println("Valor después de x *= 5:", x)
    x /= 5
    fmt.Println("Valor después de x /= 5:", x)
    x %= 3
    fmt.Println("Valor después de x %= 3:", x)
}

En el código anterior, asignamos un valor inicial de 11 a la variable x y realizamos operaciones aritméticas básicas (suma, resta, multiplicación), división y cálculos de módulo.

Ejecuta el código:

cd ~/project
go run opePractice.go

Puedes modificar el valor de la variable para ver cómo funcionan los operadores de asignación.

Resumen

Repasemos lo que hemos aprendido en este laboratorio:

  • El uso de operadores aritméticos
  • El uso de operadores relacionales
  • El uso de operadores lógicos
  • El uso de operadores de asignación

En este laboratorio, hemos analizado cómo utilizar los operadores en Go. Hemos demostrado varios operadores y sus formas de uso.