在Golang中使用另一个函数返回值?

在Go中,是否可以仅使用函数返回?</ p>

例如,我要检查错误,而不是重复if语句,而是要调用诸如 checkErrors(err)</ code>之类的函数。</ p>

此处 是一个示例( goplayground )</ p>

  func  foob​​ar(str字符串)err {
_,err:= ioutil.ReadAll(resp.Body)
checkError(err)//如果错误!= nil则foobar将返回err
/ *如果err!= nil {
return err
} * /
}

func checkError(err error){
if err!= nil {
//然后使函数在返回err中被调用。
}
}
</ code> </ pre>
</ div>

展开原文

原文

In Go, is it possible to return using a function only?

For example, I want to check for errors and instead of repeating an if statement, I want to just call a function such as checkErrors(err).

Here is an example (goplayground)

func foobar(str string) err {
    _, err := ioutil.ReadAll(resp.Body)
    checkError(err) // If error != nil then foobar will return the err
    /*if err != nil {
        return err
    }*/
}

func checkError(err error) {
    if err != nil {
        // Then make the function this is being called within return the err.
    }
}

douao8353
douao8353 拉姆齐,这不是问题所要解决的。
4 年多之前 回复
duan6832168
duan6832168 可能是此问题的正确标题是:使用Golang使用另一个函数检查错误值?
4 年多之前 回复
doucong4535
doucong4535 在显式处理错误时进行一些重复可以使代码更易于推理。
4 年多之前 回复
du718589
du718589 也许您应该阅读以下内容:blog.golang.org/error-handling-and-go
4 年多之前 回复
dongwei3866
dongwei3866 我正在教我的导师说不要重复代码,而我正在编写一个长函数,该函数一直在检查错误。我只是希望有一种方法可以最大程度地减少代码重复。
4 年多之前 回复
dongqiao3833
dongqiao3833 如果我正确理解了这个问题,那是不可能的
4 年多之前 回复

2个回答



您的导师是正确的:不要重复代码。 它称为 DRY主体。</ p>

但是Go的作者在设计语言时采取了不同的方向。 它破坏了开发社区,引起了战争,扭曲了空间和时间。 </ p>

这些指示之一是接受一点点复制,以使代码更易于阅读。</ em>您已经注意到,错误处理就是这样的一种 区域。 它邀请了一些重复的模式来检查整个应用中的nil,而不是抽象出(并且很容易忽略)您应该执行的真正错误处理。</ p>

Rob Pike解决了这个问题 在GoLang演讲的设计(和哲学)中:</ p>

http ://talks.golang.org/2012/splash.article </ p>


如果错误使用特殊的控制结构,则错误处理会扭曲程序的控制流程 处理错误。 类似Java的try-catch-finally块样式交错了以复杂方式交互的多个重叠控制流。 尽管相比之下,Go使检查错误变得更加冗长,但显式设计使控制流保持直截了当-从字面上看。</ p>
</ blockquote>

并非所有人都同意,这就是开战的原因 。 </ p>

但是,这些决定改变了行业标准,如果开发人员负担沉重,正是这些决定正是他们这样做的原因:您被迫提前处理每个错误, 中心,每次。 您不能无视或让其他人来处理它。</ p>

并非所有人都同意。</ p>

我强烈建议您和您的Tutur阅读有关该产品设计的文章。 走。 然后,您两个可以决定是否使用Go是去</ em>的方式。</ p>
</ div>

展开原文

原文

Your tutor is correct: don't repeat code. It is called the DRY principal.

But the authors of Go have taken a different direction when designing the language. And it has fractured the development community, it has caused wars, it has warped space and time.

One of these directions is to accept a little bit of copying, to make the code easier to read. Error handling, as you have noticed, is one such area. It invites a little repetitous pattern of checking for nil all over your app instead of abstracting away (and easily able to ignore) the true error handling you should be doing.

Rob Pike addressed this direction in his Design (and Philosophy) of GoLang talk:

http://talks.golang.org/2012/splash.article

If errors use special control structures, error handling distorts the control flow for a program that handles errors. The Java-like style of try-catch-finally blocks interlaces multiple overlapping flows of control that interact in complex ways. Although in contrast Go makes it more verbose to check errors, the explicit design keeps the flow of control straightforward—literally.

Not everyone agrees and it's why wars are started.

But, these decisions to shake up the industry standards that has put so much if a burden on developers is exactly why they are doing it: you are forced to deal with each error up front and center, every time. You cannot ignore or let something else handle it.

Not everyone agrees.

I highly suggestion you and your Tutur read that post about the design of Go. Then you two can make the decision of rather Go is the way to Go or not.

doufei16736
doufei16736 答案很具描述性,非常感谢您提供的所有内容。 我将继续进行重复的错误检查。
4 年多之前 回复
dsfds656545
dsfds656545 现在,我全神贯注于Go,在见光之后就离开了Java和MS。 我试图保持答案是纯净的,而不是基于意见。
4 年多之前 回复



只需添加到已经很不错的答案中,您就可以使您的 checkError </ code>函数更加自定义,这样您就可以 仍然可以预先处理错误,同时仍保持DRY:</ p>

  func checkError(err error,handler func(e error)){
if err!= nil {

handler(err)
}
}
</ code> </ pre>

这样,您就可以传递要与每个错误一起使用的处理程序函数,而不会忘记 保存两行重复的错误处理代码。</ p>

  handler1 = func(e error){
panic(e)
}

handler2 = func(e error ){
log.Fatal(e)
}

func foobar(str string)err {
_,err:= ioutil.ReadAll(resp.Body)
checkError(err,handler2)
}

</ code> </ pre>
</ div>

展开原文

原文

Just to add to the already great answer, you can make your checkError function more customized, so you get to still deal with the error up front while still keeping it DRY:

func checkError(err error, handler func(e error)) {
    if err != nil {
        handler(err)
    }
}

This way you can pass in the handler function you want to use with each error without forgetting the responsibility while saving two lines of repetitive error-handling code.

handler1 = func(e error) { 
        panic(e) 
}

handler2 = func(e error) {
        log.Fatal(e)
}

func foobar(str string) err {
    _, err := ioutil.ReadAll(resp.Body)
    checkError(err, handler2)
}

douqiao3453
douqiao3453 我以前没有这样看过。 消除重复的好方法。
4 年多之前 回复
Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问