Quand l'opérateur virgule est-il utile ?

Question

Je lis este question sur l'"opérateur virgule" dans les expressions ( , ) et le Documents MDN à ce sujet, mais je ne peux pas penser à un scénario où il est utile.

Alors, quand l'opérateur virgule est-il utile ?

Answer 1

Disons que vous avez un tableau :

arr = [];

Quand vous push sur ce tableau, vous êtes rarement intéressé par push La valeur de retour de l'utilisateur, à savoir la nouvelle longueur du tableau, mais plutôt le tableau lui-même :

arr.push('foo')  // ['foo'] seems more interesting than 1

En utilisant l'opérateur virgule, nous pouvons pousser sur le tableau, spécifier le tableau comme le dernier opérande à virgule, et ensuite utiliser le résultat -- le tableau lui-même -- pour un appel de méthode de tableau ultérieur, une sorte de chaînage :

(arr.push('bar'), arr.push('baz'), arr).sort(); // [ 'bar', 'baz', 'foo' ]

Answer 2

Je suis tombé dessus aujourd'hui en regardant les propositions de proposition d'exploitant de pipeline et de demande partielle...

• ( https://github.com/tc39/proposal-pipeline-operator
• ( https://github.com/tc39/proposal-partial-application#hack-style-pipelines )

En outre, les pipelines de type Hack sont déjà réalisables sans introduire de nouvelle syntaxe aujourd'hui :

let $; // Hack-style topic variable
let result = (
  $= books,
  $= filter($, _ => _.title = "..."),
  $= map($, _ => _.author),
  $);

L'utilisation d'expressions à virgule ici peut en quelque sorte simuler l'opérateur pipeline qui n'existe pas encore dans le langage.

Éliminer l'espace entre $= simule la sensation d'un bon jeton de pipe, |> . Notez que la variable "topic", $ peut être n'importe quoi ici et que c'est juste un raccourci pour écraser de façon répétée la variable. Donc quelque chose de plus proche de ...

// blocking inside an IIFE
let result = (() => {
  let $;
  $ = books;
  $ = filter($, _ => _.title = "..."),
  $ = map($, _ => _.author),
  return $;
})()

La version "virgule" réussit à éliminer une partie du bruit, vous rapprochant ainsi de ce que serait la proposition :

let result = books
  |> filter($, _ => _.title = "..."
  |> map($, _ => _.author)

Voici un autre exemple qui l'utilise pour composer des fonctions :

const double = (x) => 2 * x;
const add = (x, y) => x + y;
const boundScore = (min, max, score) => Math.max(min, Math.min(max, score));

const calculateScore = ($) => (
  $= double($),
  $= add($, 20),
  $= boundScore(0, 100, $),
  (console.log($), $)
)

const score = calculateScore(28)

Answer 3

Cela vous évite d'utiliser return dans les conditionnelles imbriquées et c'est très pratique, surtout avec l'opérateur ternaire. Par exemple ;

function insert(v){
  return this.node > v ? this.left.size < this.right.size ? ( this.left.insert(v)
                                                            , this
                                                            )
                                                          : ( this.left.insert(this.node)
                                                            , this.node = this.right.popmin()
                                                            , this.insert(v)
                                                            , this
                                                            )
                       : this.left.size < this.right.size ? ( this.right.insert(this.node)
                                                            , this.node = this.left.popmax()
                                                            , this.insert(v)
                                                            , this
                                                            )
                                                          : ( this.right.insert(v)
                                                            , this
                                                            )
}

Answer 4

L'opérateur virgule (,) évalue chacun de ses opérandes (de gauche à droite) et renvoie la valeur du dernier opérande. Cela vous permet de créer une expression composée dans laquelle plusieurs expressions sont évaluées, la valeur finale de l'expression composée étant la valeur de l'expression membre la plus à droite. Cette méthode est généralement utilisée pour fournir plusieurs paramètres à une boucle for.

Soit x = 1 ;

x = (x++, x) ;

console.log(x) ; // sortie attendue : 2

x = (2, 3) ;

console.log(x) ; // sortie attendue : 3

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

Answer 5

Un autre domaine dans lequel l'opérateur virgule peut être utilisé est le suivant Obfuscation du code .

Disons qu'un développeur écrit un code comme celui-ci :

var foo = 'bar';

Maintenant, elle décide d'obfusquer le code. L'outil utilisé peut modifier le code comme ceci :

var Z0b=(45,87)>(195,3)?'bar':(54,65)>(1,0)?'':'baz';// Z0b == 'bar'

Démonstration : http://jsfiddle.net/uvDuE/