Question

我是Golang的新手，我对int width = 120; int height= 120; Bitmap resizedBitmap = Bitmap.createScaledBitmap(myBitmap, width, height, false);的输出顺序感到困惑，这是我的代码

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中添加更多print语句：

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
}

为什么输出是那个？谢谢！

Answer 1

由于函数调用的顺序，这种情况正在发生。调用函数时，在实际函数调用之前计算其所有参数。

所以在这里，在下面的电话中：

var express = require('express');
var app = express();

var redis = require("redis"),
client = redis.createClient(6379,"10.96.82.175");

app.get('/', function (req, res) {


          res.send("HEY  Nodejs runnning on 10.96.82.175:4000");

});
app.put('/set/:arg1/:arg2', function (req, res) {

      client.set( req.params.arg1,req.params.arg2,function (err, reply) {
        if (reply==null)
        {
          res.send("null");
        }
        else {
          res.send(reply.toString());
        }

      });
});


app.get('/get/:arg1', function (req, res) {
      client.get( req.params.arg1,function (err, reply) {

        if (reply==null)
        {
          res.send("null");
        }
        else {
          res.send(reply.toString());
        }

      });
});






app.get('/incr/:arg1', function (req, res) {
      client.incr(req.params.arg1, function (err, reply) {
        if (reply==null)
        {
          res.send("null");
        }
        else {
          res.send(reply.toString());
        }

          //console.log(reply.toString());
      });
});





app.put('/lpush/:arg1/:arg2', function (req, res) {
  client.lpush(req.params.arg1,req.params.arg2, function (err, reply) {
    if (reply==null)
    {
      res.send("null");
    }
    else {
      res.send(reply.toString());
    }

          //console.log(reply.toString());
      });
});



app.get('/lpop/:arg1', function (req, res) {
  client.lpop(req.params.arg1, function (err, reply) {

    if (reply==null)
    {
      res.send("null");
    }
    else {
      res.send(reply.toString());
    }
      });
});



app.put('/sadd/:arg1/:arg2', function (req, res) {
  client.sadd(req.params.arg1,req.params.arg2, function (err, reply) {
    if (reply==null)
    {
      res.send("null");
    }
    else {
      res.send(reply.toString());
    }
          //console.log(reply.toString());
      });
});




app.get('/spop/:arg1', function (req, res) {
  client.spop(req.params.arg1,1, function (err, reply) {

    if (reply==null)
    {
      res.send("null");
    }
    else {
      res.send(reply.toString());
    }
          //console.log(reply.toString());
      });
});


app.put('/zadd/:arg1/:arg2/:arg3', function (req, res) {
  client.zadd(req.params.arg1,req.params.arg2,req.params.arg3,function (err, reply) {
    if (reply==null)
    {
      res.send("null");
    }
    else {
      res.send(reply.toString());
    }
          //console.log(reply.toString());
      });
});





app.put('/hset/:arg1/:arg2/:arg3', function (req, res) {
      client.hset(req.params.arg1,req.params.arg2,req.params.arg3,function (err, reply) {
        if (reply==null)
        {
          res.send("null");
        }
        else {
          res.send(reply.toString());
        }
          //console.log(reply.toString());
      });
});




app.get('/hget/:arg1/:arg2', function (req, res) {

      client.hget(req.params.arg1,req.params.arg2,function (err, reply) {

        if (reply==null)
        {
          res.send("null");
        }
        else {
          res.send(reply.toString());
        }
          //console.log(reply);
      });
});





app.listen(4000, function () {

  console.log('Example app listening on port 4000!');
});

在调用

fmt.Println(
    pow(3, 2, 10),
    pow(3, 3, 20),
)

之前，

pow(3, 2, 10)和pow(3, 3, 20)都会被评估（调用）。因此，println的输出（通过第二次调用printf依次调用）会在pow(3, 3, 20)输出println的返回值之前显示。

Answer 2

Order of evaluation：

在包级别，初始化依赖性确定评估   变量中各个初始化表达式的顺序   声明。否则，在评估一个操作数时   表达式，赋值或返回语句，所有函数调用，   方法调用和通信操作在词法中进行评估   从左到右的顺序。

例如，在（函数 - 本地）赋值
中
y[f()], ok = g(h(), i()+x[j()], <-c), k()
函数调用和通信以f（），h（）的顺序发生， i（），j（），＆lt; -c，g（）和k（）。但是，那些事件的顺序与x的评估和索引以及y的评估相比较未指定。
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
在包级别，初始化依赖性会覆盖各个初始化表达式的从左到右的规则，但不是对于每个表达式中的操作数：
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
函数调用按顺序u（），sqr（），v（），f（），v（）和   克（）。

评估单个表达式中的浮点运算   根据运营商的相关性。明确的括号   通过覆盖默认关联性来影响评估。在里面   表达式x +（y + z）在添加之前执行加法y + z   X

如果您需要：

9
27 >= 20
20

首先调用pow(3, 2, 10)和Print结果，例如此工作示例代码：

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))
}

输出：

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

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

为什么fmt.Println（）的输出不是我需要的

2 个答案: