1

値渡しされる変数の違いを知りたいのですが、怠惰であり、Scala で変数を名前で渡します。

見せようとしてこの例を書きましたが、そうではありません。どうすればよいですか?

def callByValue(x : Unit) = {
x
x
}

def callByName(x : => Unit) = {
    x
    x
}

lazy val j = {println("initializing lazy"); 0}
var i = {println("initializing"); 0}

callByName(i = i + 1)
print(i + "\n")  // "5"

callByValue(j)
print(j + "\n")  // "1"
4

2 に答える 2

2

「5」というのは、2 みたいな意味ですよね？そして、「1」は0を意味しますか？

これは、Google のインタビューの質問の 1 つですか?

これは、関数によって 2 回評価されたクロージャを示しています。

scala> callByName {
     | println("calling")
     | i += 1
     | }
calling
calling

その後

scala> println(i)
4

2になった後です。

HTH。

于 2013-06-13T05:03:32.597 に答える
2

これが役立つかどうかを確認してください。

  • val定義時に実行される
  • lazy val一度だけ実行されますが、最初の参照時に実行されます

  • :=>名前による受け渡しは、定義時ではなく参照時に毎回実行されます (関数のように考えてください。関数は、関数を定義するときではなく、呼び出し/参照時に実行されます)。

    def callByValue(x : Unit) = {
    x  
    x 
}

def callByName(x : => Unit) = {
    x 
    x 
}


    val i = {println("i"); 0}//print should  happen now at time of declaration. i is 0.
    lazy val j = {println("j"); 0} //no print because {...} will get executed when j is referenced, not at time of definition.
    val k = {println("k"); 0} //same as case of i, print should happen now. K should be 0

    //no special case. A val being passed like a regular function
    println("k test. K is val")
    callByValue (k) //no prints as K block is already evaluated.

//passing a val to a function by name. The behavior will be same as K because i is already evaluated at time of definition. basically we are passing 0
    println("i test. i is val but passed by Name.");
    callByName(i);//I is passed by name. Thus the block will be executed everytime it is referenced 

    println("j test. It is passed lazy. It will be executed only once when referenced for 1st time")
    callByValue(j) //prints j once, assigns value 0 to j inside callByValue function. Note that because j is lazy, it the block {print j;0} is evaluated once when j was referenced for first time. It is not executed everytime j was referenced.

    println("test l")
    callByName({println("l");0});//l is passed by name. Thus the block will be executed everytime it is referenced

    println("test l again") callByValue({println("l");0});//l は値で渡されます。したがって、ブロックは一度実行されます

出力

i <- when i was defined. val i = {println("i"); 0}
k <- when k was defined. {println("k"); 0}
k test. K is val <- no further prints of 'k' as the {println("k"); 0} has already been evaluated
i test. i is val but passed by Name. <- no furhter prints of 'i' as {println("i"); 0} is already evaluated
j test. It is passed lazy. It will be executed only once when referenced for 1st time
j <- note j is printed now instead of time of definition

test l
l <- we passed {print(l);0}. It will get executed everytime l is referenced. Thus two prints corresponding to {x;x} code of call by name
l
test l again
l <- only one print when {print(l);0} was passed by value
于 2017-09-22T15:41:48.107 に答える