Attribution de valeur à l'intérieur de la boucle forcée de Scala

Quelle est la différence entre ce code:

    for(term <- term_array) {
        val list = hashmap.get(term)
        ...
    }

et:

    for(term <- term_array; val list = hashmap.get(term)) {
        ...
    }

À l'intérieur de la boucle que je vais changer la table de hachage avec quelque chose comme ça

hashmap.put(term, string :: list)

Lors de la vérification de la tête de list il semble être obsolète d'une certaine manière lors de l'utilisation de la deuxième extrait de code.

source d'informationauteur Felipe Hummel

  1. 9

    De l'instanciation des variables à l'intérieur des boucles de sens que si vous voulez utiliser cette variable dans la for déclaration, comme:

    for (i <- is; a = something; if (a)) {
   ...
}

    Et la raison pour laquelle votre liste est obsolète, c'est que cela se traduit par une foreach de l'appel, tel que:

    term_array.foreach {
   term => val list= hashmap.get(term)
} foreach {
  ...
}

    Ainsi, lorsque vous atteignez ..., votre table de hachage a déjà été changé. L'autre exemple se traduit par:

    term_array.foreach {
   term => val list= hashmap.get(term)
   ...
}
  2. 19

    La différence entre les deux est que la première est une définition qui est créé par le filtrage et la seconde est une valeur à l'intérieur d'une fonction littérale. Voir La programmation Scala, de l'Article 23.1 Pour les Expressions:

      for {
    p <- persons              //a generator
    n = p.name                //a definition
    if (n startsWith "To")    //a filter
  } yield n

    Vous voyez une vraie différence lorsque vous compilez les sources avec scalac -Xprint:typer <filename>.scala:

    object X {
  val x1 = for (i <- (1 to 5); x = i*2) yield x
  val x2 = for (i <- (1 to 5)) yield { val x = i*2; x }
}

    Après le code de la transformation par le compilateur, vous obtiendrez quelque chose comme ceci:

    private[this] val x1: scala.collection.immutable.IndexedSeq[Int] =
  scala.this.Predef.intWrapper(1).to(5).map[(Int, Int), scala.collection.immutable.IndexedSeq[(Int, Int)]](((i: Int) => {
    val x: Int = i.*(2);
    scala.Tuple2.apply[Int, Int](i, x)
  }))(immutable.this.IndexedSeq.canBuildFrom[(Int, Int)]).map[Int, scala.collection.immutable.IndexedSeq[Int]]((
    (x$1: (Int, Int)) => (x$1: (Int, Int) @unchecked) match {
      case (_1: Int, _2: Int)(Int, Int)((i @ _), (x @ _)) => x
    }))(immutable.this.IndexedSeq.canBuildFrom[Int]);

private[this] val x2: scala.collection.immutable.IndexedSeq[Int] =
  scala.this.Predef.intWrapper(1).to(5).map[Int, scala.collection.immutable.IndexedSeq[Int]](((i: Int) => {
    val x: Int = i.*(2);
    x
  }))(immutable.this.IndexedSeq.canBuildFrom[Int]);