刚接触Golang，对fmt.println()的输出顺序很迷惑，这是我的代码

package main

import (
    "fmt"
    "math"
)

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    return lim
}

func main() {
    fmt.Println(
        pow(3, 2, 10),
        pow(3, 3, 20),
    )
    //fmt.Println(pow(3, 2, 10))
    //fmt.Println(pow(3, 3, 20))
}

输出是

27 >= 20
9 20

而我想要的是

9
27 >= 20
20

并在pow()中添加更多打印语句:

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        fmt.Println("___1___")
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    fmt.Println("___2___")
    return lim
}

输出是

___1___
27 >= 20
___2___
9 20

为什么输出是这样的？谢谢!

最佳答案

Order of evaluation :

At package level, initialization dependencies determine the evaluation order of individual initialization expressions in variable declarations. Otherwise, when evaluating the operands of an expression, assignment, or return statement, all function calls, method calls, and communication operations are evaluated in lexical left-to-right order.

For example, in the (function-local) assignment

y[f()], ok = g(h(), i()+x[j()], <-c), k()

the function calls and communication happen in the order f(), h(), i(), j(), <-c, g(), and k(). However, the order of those events compared to the evaluation and indexing of x and the evaluation of y is not specified.

a := 1
f := func() int { a++; return a }
x := []int{a, f()}            // x may be [1, 2] or [2, 2]: evaluation order between a and f() is not specified
m := map[int]int{a: 1, a: 2}  // m may be {2: 1} or {2: 2}: evaluation order between the two map assignments is not specified
n := map[int]int{a: f()}      // n may be {2: 3} or {3: 3}: evaluation order between the key and the value is not specified

At package level, initialization dependencies override the left-to-right rule for individual initialization expressions, but not for operands within each expression:

var a, b, c = f() + v(), g(), sqr(u()) + v()

func f() int        { return c }
func g() int        { return a }
func sqr(x int) int { return x*x }

// functions u and v are independent of all other variables and functions

The function calls happen in the order u(), sqr(), v(), f(), v(), and g().

Floating-point operations within a single expression are evaluated according to the associativity of the operators. Explicit parentheses affect the evaluation by overriding the default associativity. In the expression x + (y + z) the addition y + z is performed before adding x.

如果你需要:

9
27 >= 20
20

首先调用pow(3, 2, 10) 并打印 结果，就像这个工作示例代码:

package main

import "fmt"
import "math"

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    return lim
}

func main() {
    fmt.Println(pow(3, 2, 10))
    fmt.Println()

    fmt.Println(pow(3, 3, 20))
}

输出:

9

27 >= 20
20

查看此工作示例代码中函数调用的顺序:

package main

import "fmt"

func pow(n float64) float64 {
    fmt.Println("order:", n)
    return n
}

func main() {
    fmt.Println(pow(1), pow(2), pow(3))
}

输出:

order: 1
order: 2
order: 3
1 2 3

和:

package main

import "fmt"

func pow(n int) int {
    fmt.Println("order:", n)
    return n
}

func main() {
    a, b, c := pow(1), pow(2), pow(3)
    fmt.Println("Order 4")
    fmt.Println(a, b, c)
}

输出:

order: 1
order: 2
order: 3
Order 4
1 2 3

package main

import "fmt"

func pow(n int) int {
    fmt.Println("order:", n)
    return n
}

func main() {
    a := pow(1)
    b := pow(2)
    c := pow(3)
    fmt.Println("Order 4")
    fmt.Println(a, b, c)
}

输出:

order: 1
order: 2
order: 3
Order 4
1 2 3

关于go - 为什么 fmt.Println() 的输出不是我需要的，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/39010416/