What would happen if an error happened and my golang app didn't handle it?

I'm currently using gorm and gin framework. I wonder what would happen if an error happened and my app didn't handle it?

Example:

if err := db.Where("name = ?", "jinzhu").First(&user).Error; err != nil {
    // error handling...
}

In the above example, the error is being handled.

if db.Model(&user).Related(&credit_card).RecordNotFound() {
    // no credit card found error handling
}

In the next example above, only the RecordNotFound() error is being handled, but what if it throws a different error? what will happen?

Will my app automatically respond with a 500 server internal error and will the app keep on running properly?

> In the next example above, only the RecordNotFound() error is being handled, but what if it throws a different error?

If you won't catch the error it will continue on the code. Error is not a special type it's a simple struct

err := FunctionThatReturnsError()  
if err == myError.RecordNotFound() { // if err is not RecordNotFound then it won't enter the if simple as that. 
    // Do something.  
}  

// continue code.  

> Will my app automatically respond with a 500 server internal error and will the app keep on running properly?

There will be no response if the go routine doesn't panic or you return a response. If you want to handle it you can do:

err := FunctionThatReturnsError()  
if err == myError.RecordNotFound() {
      panic("RecordNotFound")
} 

or

err := FunctionThatReturnsError()  
if err == myError.RecordNotFound() {
      c.JSON(500, "Record not found"}
} 

I don't recommend the panic method. If you're curious google why.

Go doesn't have exceptions. Instead of catching exceptions, you get errors via return values from functions. So there's no throwing or anything special going on behind the scenes, just a function that returns an error value, and like any other return value - you can discard it.

I wouldn't recommend discarding errors though. If you feel lazy or lost about what to do with an error - just log it:

log.Error(err)

You never know if an error you discarded is causing this mysterious bug you can swear is coming from anywhere but your own code.

> I wonder what would happen if an error happened and my app didn't handle it?

Then the state of the app is undefined. If you don't check error values your app will be using values which are undefined (probably nil for pointers and "zeros" for values) or assuming that side effect occurred but it might not.

Let's say you have a function with signature func CreateStruct() (T, err)
and call it like that t, _ := CreateStruct() (not checking for error) you should not expect t variable to have a proper value set.
If you have function like func Update() err and you call it without error checking then you can't know whether update was performed or not.

Of course everything depends on API and implementation. But you get the idea.

> but what if it throws a different error?

It's impossible. There is not throwing error mechanism in Go. Error can only be returned as a normal value.

You should never be lazy with handling errors. It's very important part of programming and Go makes it easier to realize.