Manejo de errores y uso de If

Clase 8 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Avelino Sánchez

student•

El manejo de errores dentro de go es un tanto más simple que en otros lenguajes de programación dado que las funciones pueden regresar varios valores. La norma dentro de Go es que las funciones regresen 2 valores usualmente: el valor esperado y un error. Esto quiere decir que si fue exitoso el valor esperado se recibe normalmente y un error con un valor de nil. En el caso opuesto de si hubo un error el valor esperado se recibe como nil y se recibe también el error con su valor correspondiente.

val, err := foo.Func(args) 
if err != nil {
	fmt.Println(&quot;Hubo un error&quot;)
}

// Continúa la ejecución ...

Enrique Montes Trejo

student•

Excelente aporte. Gracias

Cesar Augusto Barco de Gouveia

student•

Puedes imprimir.

fmt.Println(error.Error())

Usuario anónimo

user•

Genial :) una pena que no tenga try

Sebastián Melo

student•

Regresa un error.

Juan Diego Forero Granados

student•

¿Por qué se llama nill en vez de la convención null ?

Roger Carlos Ariel Alba

student•

Hola,

Aquí puedes leer una explicación.

Saludos

Emilio Castro

student•

Hola @rednux, Además de la explicación muy buena de qué es nil que compartió CarlosAlba, aquí y aquí hay dos buenas explicaciones detalladas sobre el uso de null y nil en diferentes lenguajes.

nil y null se usan en distintos lenguajes para representar conceptos similares a alto nivel pero diferentes en su implementación. Por ejemplo, el NIL de Lisp, el nil de Ruby y el nil de Go son diferentes.

En general, por su implementación en lenguajes como C, C# o Java, null tiene una connotación relacionada a la noción de null pointer o null reference. En cambio nil no la tiene. De hecho como dice el artículo que compartió Carlos, en Go nil es el valor cero para punteros, interfaces, mapas, slices, canales y funciones.

PD: también está el None de Python jaja.

Henrry Bourgeot

student•

Aquí tengo un ejemplo del código utilizando una función, así aprovechamos el manejo de errores sin repetir tantas lineas

Pilar Mass

student•

Se puede concatenar mensajes en el Println ? Es decir porque sale error si trato de hacer lo siguiente: fmt.Println("Ocurrió un error" + err1). Espero que alguien me resuleva la duda , gracis

Jonatan Camilo Bonilla Malaver

student•

Hola Pilar, claro que sí si son del mismo tipo. Si son de diferente tipo puedes usar otra función del paquete fmt que es Printf donde puedes concatenar datos de diferente tipo. Ej:

fmt.Printf(&quot;Un string %s y un entero %d&quot;, valores[0], operador1)

Puedes leer mas en la documentación de go sobre el paquete fmt https://golang.org/pkg/fmt/

Jonatan Camilo Bonilla Malaver

student•

En el caso del error sería:

fmt.Printf(&quot;Ocurrió un error %s&quot;, err1)

Carlos Javier Bazan Huaman

student•

el manejo del error es muy interesante.

William Rodriguez

student•

Interesante es similar a como se reciben datos de una promesa en Javascript. Me parece una manera bastante elegante de hacerlo en go .

Jean Nuñez

student•

Golang cuando consigue un error te regresa pero cuando no te regresa un valor nill

William Rodriguez

student•

Tendriamos Try catch en Go o el manejo de errores es siempre como el visto en esta clase?

Julio Cesar Estrada Marcial

student•

De momento no, la única forma es la vista en el curso.

Al principio el profesor menciona que los creadores del lenguaje decidieron no incluir "try/catch" perse por ser un suceso extraordinario.

Saludos.

Nestor Escoto

teacher•

Hola William, tal como menciona @yulio_94 no hay mecanismo de try/catch en el lenguaje así que esa es la forma la tradicional en que se manejan los errores en Go, por eso es muy importante utilizar funciones que devuelven multiples valores y revisar si los errores no son valores nulos.

Luis Albarenga

student•

Consulta: Supongamos que tenemos una función compleja, que puede tener otros errores, es mejor pasarlos esos errores a la ultima función que lo llama o como se procedería en ese caso?

Daniel Barros Garces

student•

Una forma de aprovechar los if

Derek Samuel Paúl Peña

student•

Si solo van a sumar, y no quieren hacer multiples manejadores de errores les dejo este code de practica, espero les sirva:


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin) // input's terminal getting
	fmt.Println("I/")
	scanner.Scan()
	operation := scanner.Text() // asignar al scaner, y se obtiene como text ya que es un buffer
	fmt.Println(operation)
	fmt.Println("/O")

	values := strings.Split(operation, "+") // parte al texto
	fmt.Println(values)

	result := 0

	for i, val := range values {
		value, errorResult := strconv.Atoi(val)

		if errorResult != nil {
			fmt.Println("[error]:", errorResult)
			break
		}

		result = result + value

		if (i + 1) == len(values) {
			fmt.Println("[result OK]:", result)
		}
	}
}

Guillermo Rafael Pagan Diaz del Valle

student•

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	operacion := scanner.Text()
	fmt.Println("Esto fue lo ingresado:  " + operacion)

	valores := strings.Split(operacion, "+")

	fmt.Println(valores)

	fmt.Println(valores[0] + valores[1])

	operador1, err1 := strconv.Atoi(valores[0])
	if err1 != nil {
		fmt.Println(err1)
	} else {
		fmt.Println(operador1)
	}

	operador2, err2 := strconv.Atoi(valores[1])
	if err1 != nil {
		fmt.Println(err2)
	} else {
		fmt.Println(operador2)
	}

	fmt.Println(operador1 + operador2)

}

Luis Hernando Sendoya Serrato

student•

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {

	scan := bufio.NewScanner(os.Stdin)
	scan.Scan()

	value := scan.Text()
	value1 := strings.Split(value, ".")
	fmt.Printf("%+v\n", value)
	fmt.Printf("%+v\n", value1)
	var suma int
	for _, v := range value1 {

		num, err := strconv.Atoi(v)
		if err != nil {
			fmt.Println(err)
		}
		fmt.Printf("err: %v\n", err)
		suma += num

	}
	fmt.Printf("suma: %v\n", suma)

}

Victor Hugo Cruz Carballo

student•

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	fmt.Println("Por favor introduzca la operacion a realizar")
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	valores := strings.Split(operacion, "+")
	fmt.Println(valores)

	operador1, error1 := strconv.Atoi(valores[0])
	operador2, _ := strconv.Atoi(valores[1])

	if error1 != nil {
		fmt.Println(error1)
	} else {
		fmt.Println(operador1)
	}
	resultado := operador1 + operador2
	fmt.Println(resultado)
}

Juan José González Ramírez

student•

La clase es simple pero tan reveladora. Al desarrollador novato no se le ocurre que alguna vez puede fallar su solución, estas cosas nos ayudan a tener soluciones robustas.

Juan Gonzalo Quiroz Cadavid

student•

Algo brutal que me acabo de dar cuenta es que un puede pasar una funcion como argumento de otra funcion!

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()
	operacion := scanner.Text()
	fmt.Println(operacion)
	operacion = strings.ReplaceAll(operacion, " ", "")
	valores := strings.Split(operacion, "+")
	fmt.Println(valores)
	operandoOne, err := strconv.Atoi(valores[0])

	if err != nil {
		fmt.Println("Number", operandoOne, "Error", err)
	} else {
		fmt.Println("Soo god")
	}

	operandoTwo, _ := strconv.Atoi(valores[1])
	performOperator(operandoOne, operandoTwo, plusOpetator)
}

func performOperator(x int, y int, f func(int, int) int) {
	fmt.Println(f(x, y))
}

func plusOpetator(x int, y int) int {
	return x + y
}

Oscar Jaramillo

student•

Interesante

Luis Boivar

student•

Manejo de errores y uso de If

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos