Que signifient tous les opérateurs symboliques de Scala?

une (bonne, IMO) différence entre Scala et d'autres langues est qu'il vous permet de nommer vos méthodes avec presque n'importe quel caractère.

ce que vous énumérez n'est pas une" ponctuation " mais des méthodes simples et simples, et en tant que telles leur comportement varie d'un objet à l'Autre (bien qu'il y ait quelques conventions).

par exemple, vérifiez la documentation Scaladoc pour la liste , et vous verrez certaines des méthodes que vous avez mentionnées ici.

Certaines choses à garder à l'esprit:

• la plupart du temps , la combinaison A operator+equal B se traduit par A = A operator B , comme dans les exemples ||= ou ++= .

• les méthodes qui se terminent par : sont associatives, ce qui signifie que A :: B est en fait B.::(A) .

vous trouverez la plupart des réponses par parcourir la documentation Scala. Conserver une référence ici ferait double emploi avec les efforts et prendrait rapidement du retard :)

vous pouvez les regrouper d'abord selon certains critères. Dans ce post, je vais juste expliquer le caractère de soulignement et la flèche droite.

_._ contient une période. Une période en Scala indique toujours un appel de méthode . Donc à gauche de la période que vous avez le récepteur, et à droite le message (nom de la méthode). Maintenant _ est un symbole spécial en Scala. Il y a plusieurs billets à ce sujet, par exemple cette entrée de blog tous les cas d'utilisation. Ici c'est un fonction anonyme short cut , qui est un raccourci pour une fonction qui prend un argument et appelle la méthode _ . Maintenant _ n'est pas une méthode valide, donc très certainement vous avez vu _._1 ou quelque chose de similaire, c'est-à-dire, invoquer la méthode _._1 sur l'argument de la fonction. _1 à _22 sont les méthodes de tuples qui extraient un particulier élément d'un tuple. Exemple:

val tup = ("Hallo", 33)
tup._1 // extracts "Hallo"
tup._2 // extracts 33

laisse maintenant supposer un cas d'utilisation pour la fonction raccourci d'application. Donné une carte qui correspond à des entiers à des chaînes de caractères:

val coll = Map(1 -> "Eins", 2 -> "Zwei", 3 -> "Drei")

Wooop, il y a déjà une autre occurrence d'une étrange ponctuation. Le trait d'Union et les caractères plus grands que, qui ressemblent à un flèche droite , est un opérateur qui produit un Tuple2 . Donc, il n'y a pas de différence dans le résultat de l'écriture soit (1, "Eins") ou 1 -> "Eins" , seulement que ce dernier est plus facile à lire, en particulier dans une liste de tuples comme l'exemple de carte. Le -> n'est pas magique, il est, comme quelques autres opérateurs, disponible parce que vous avez tous implicite conversions dans l'objet scala.Predef dans la portée. La conversion qui a lieu ici est

implicit def any2ArrowAssoc [A] (x: A): ArrowAssoc[A] 

où ArrowAssoc a le -> méthode qui crée le Tuple2 . Ainsi 1 -> "Eins" est l'appel réel Predef.any2ArrowAssoc(1).->("Eins") . OK. Maintenant, retour à la question originale avec le caractère de soulignement:

// lets create a sequence from the map by returning the
// values in reverse.
coll.map(_._2.reverse) // yields List(sniE, iewZ, ierD)

le soulignement raccourcit ici le code équivalent suivant:

coll.map(tup => tup._2.reverse)

notez que la méthode map d'une Map passe dans le tuple de la clé et de la valeur à l'argument de fonction. Comme nous ne sommes intéressés que par les valeurs (les chaînes), nous les extraire avec la méthode _2 sur le tuple.

comme un ajout aux réponses brillantes de Daniel et 0__ , Je dois dire que Scala comprend Unicode analogues pour certains des symboles, donc au lieu de

for (n <- 1 to 10) n % 2 match {
  case 0 => println("even")
  case 1 => println("odd")
}

on peut écrire

for (n ← 1 to 10) n % 2 match {
  case 0 ⇒ println("even")
  case 1 ⇒ println("odd")
}

<= est exactement comme vous le" liriez": "inférieur ou égal". Donc c'est un opérateur mathématique, dans la liste de < (c'est moins que?), > (est plus grand que?), == (égale?), != (n'est pas égal?), <= (est égal ou inférieur?), et >= (est supérieure ou égale?).

cela ne doit pas être confondu avec => qui est une sorte de double main droite Flèche , utilisée pour séparer la liste d'arguments du corps d'une fonction et pour séparer la condition de test dans la correspondance de motif (un case bloc) du corps Exécuté quand une correspondance se produit. Vous pouvez en voir l'exemple dans mes deux réponses précédentes. Tout d'abord, la fonction utiliser:

coll.map(tup => tup._2.reverse)

qui est déjà abrégé car les types sont omis. La fonction suivante serait

// function arguments         function body
(tup: Tuple2[Int, String]) => tup._2.reverse

et l'utilisation du motif correspondant:

def extract2(l: List[Int]) = l match {
   // if l matches Nil    return "empty"
   case Nil            => "empty"
   // etc.
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   // etc.
   case ::(head, tail) => "more than one element"
}

Concernant :: il y a un autre Stackoverflow "151990920 entrée" qui couvre les :: . En bref, il est utilisé pour construire Lists par consing " un élément de tête et une liste de queue. C'est à la fois une classe qui représente une liste cons'ED et qui peut être utilisé comme un extracteur, mais le plus souvent c'est une méthode sur une liste. Comme Pablo Fernandez points, puisqu'il se termine par une virgule, c'est droit associatif , ce qui signifie que le récepteur de l'appel de méthode est à droite, et l'argument de la gauche de l'opérateur. De cette façon, vous pouvez exprimer élégamment le consing comme en préprogrammant un nouvel élément de tête à une liste existante:

val x = 2 :: 3 :: Nil  // same result as List(2, 3)
val y = 1 :: x         // yields List(1, 2, 3)

c'est l'équivalent de

val x = Nil.::(3).::(2) // successively prepend 3 and 2 to an empty list
val y = x.::(1)         // then prepend 1

l'utilisation comme extracteur est la suivante:

def extract(l: List[Int]) = l match {
   case Nil          => "empty"
   case head :: Nil  => "exactly one element (" + head + ")"
   case head :: tail => "more than one element"
}

extract(Nil)          // yields "empty"
extract(List(1))      // yields "exactly one element (33)"
extract(List(2, 3))   // yields "more than one element"

cela ressemble à un opérateur ici, mais c'est vraiment juste une autre (plus lisible) façon d'écrire

def extract2(l: List[Int]) = l match {
   case Nil            => "empty"
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   case ::(head, tail) => "more than one element"
}

vous pouvez en savoir plus sur les extracteurs dans ce post .

je considère qu'un IDE moderne est critique pour comprendre les grands projets scala. Puisque ces opérateurs sont aussi des méthodes, dans intellij idea je contrôle-click ou contrôle-b dans les définitions.

vous pouvez contrôler-cliquer droit dans un opérateur cons (::) et finir à la Scala javadoc dire" ajoute un élément au début de cette liste."Dans les opérateurs définis par l'utilisateur, cela devient encore plus critique, car ils pourraient être définis dans des implicits difficiles à trouver... votre IDE sait où l'implicite a été défini.

Scala hérite le plus de les opérateurs arithmétiques de Java . Cela comprend bitwise-ou | (caractère de pipe simple), bitwise-et & , bitwise-exclusive-ou ^ , ainsi que logique (booléen) ou || (deux caractères de pipe) et logique-et && . Il est intéressant de noter que vous pouvez utiliser les opérateurs à caractère unique sur boolean , de sorte que les opérateurs logiques java sont totalement redondants:

true && true   // valid
true & true    // valid as well

3 & 4          // bitwise-and (011 & 100 yields 000)
3 && 4         // not valid

Comme indiqué dans un autre post, les appels se terminant par un signe égal = , sont résolus (si une méthode de même nom n'existe pas!) par une réaffectation:

var x = 3
x += 1         // `+=` is not a method in `int`, Scala makes it `x = x + 1`

ce "double-check" permet d'échanger facilement un mutable contre une collection immuable:

val m = collection.mutable.Set("Hallo")   // `m` a val, but holds mutable coll
var i = collection.immutable.Set("Hallo") // `i` is a var, but holds immutable coll

m += "Welt" // destructive call m.+=("Welt")
i += "Welt" // re-assignment i = i + "Welt" (creates a new immutable Set)

ajoute juste aux autres excellentes réponses. Scala propose deux opérateurs symboliques souvent critiqués, /: ( foldLeft ) et :\ ( foldRight ), le premier étant de droite-associatif. Ainsi, les trois énoncés suivants sont l'équivalent:

( 1 to 100 ).foldLeft( 0, _+_ )
( 1 to 100 )./:( 0 )( _+_ )
( 0 /: ( 1 to 100 ) )( _+_ )

comme ces trois-là:

( 1 to 100 ).foldRight( 0, _+_ )
( 1 to 100 ).:\( 0 )( _+_ )
( ( 1 to 100 ) :\ 0 )( _+_ )