Splat-Operatoren in JavaScript, äquivalent zu *args und **kwargs in Python?

Ich benutze Python viel und ich lerne gerade schnell JavaScript (oder sollte ich sagen, ich lerne neu). Also wollte ich fragen, was das Äquivalent von ist *args und **kwargs in Javascript?

Die nächste Redewendung für *args wäre

function func (a, b /*, *args*/) {
    var star_args = Array.prototype.slice.call (arguments, func.length);
    /* now star_args[0] is the first undeclared argument */
}

die Tatsache ausnutzen, dass Function.length ist die Anzahl der in der Funktionsdefinition angegebenen Argumente.

Sie könnten dies in eine kleine Hilfsroutine wie z

function get_star_args (func, args) {
    return Array.prototype.slice.call (args, func.length);
}

und dann tun

function func (a, b /*, *args*/) {
    var star_args = get_star_args (func, arguments);
    /* now star_args[0] is the first undeclared argument */
}

Wenn Sie Lust auf syntaktischen Zucker haben, schreiben Sie eine Funktion, die eine Funktion in eine andere umwandelt, die mit erforderlichen und optionalen Argumenten aufgerufen wird, und die erforderlichen Argumente mit allen zusätzlichen optionalen Argumenten als Array an der Endposition weitergibt:

function argsify(fn){
    return function(){
        var args_in   = Array.prototype.slice.call (arguments); //args called with
        var required  = args_in.slice (0,fn.length-1);     //take first n   
        var optional  = args_in.slice (fn.length-1);       //take remaining optional
        var args_out  = required;                          //args to call with
        args_out.push (optional);                          //with optionals as array
        return fn.apply (0, args_out);
    };
}

Verwenden Sie diese wie folgt:

// original function
function myfunc (a, b, star_args) {
     console.log (a, b, star_args[0]); // will display 1, 2, 3
}

// argsify it
var argsified_myfunc = argsify (myfunc);

// call argsified function
argsified_myfunc (1, 2, 3);

Andererseits könnten Sie diesen ganzen Hokuspokus einfach überspringen, wenn Sie bereit sind, den Aufrufer zu bitten, die optionalen Argumente zunächst als Array zu übergeben:

myfunc (1, 2, [3]);

Es gibt wirklich keine analoge Lösung für **kwargs, da JS keine Schlüsselwortargumente hat. Bitten Sie den Aufrufer stattdessen einfach, die optionalen Argumente als Objekt zu übergeben:

function myfunc (a, b, starstar_kwargs) {
    console.log (a, b, starstar_kwargs.x);
}

myfunc (1, 2, {x:3});

ES6-Update

Lassen Sie mich der Vollständigkeit halber hinzufügen, dass ES6 dieses Problem mit der Restparameterfunktion löst. Siehe Javascript – ‘…’ Bedeutung

ES6 hat JavaScript einen Spread-Operator hinzugefügt.

function choose(choice, ...availableChoices) {
    return availableChoices[choice];
}

choose(2, "one", "two", "three", "four");
// returns "three"

Ich habe hier eine gute Lösung gefunden:
http://readystate4.com/2008/08/17/javascript-argument-unpacking-converting-an-array-into-a-list-of-arguments/

Grundsätzlich verwenden function.apply(obj, [args]) Anstatt von function.call. apply nimmt ein Array als 2. Argument und ‘splats’ es für Sie.

Das nächste Äquivalent ist die arguments Pseudo-Array.

ECMAScript 6 haben Ruhe Parameter die dasselbe tun wie der Splat-Operator.

Für diejenigen, die etwas verwirrt über die magischen Variablen *args und **kwargs sind, lesen Sie http://book.pythontips.com/en/latest/args_and_kwargs.html

Zusammenfassung: *args und **kwargs sind nur herkömmliche Arten, die magischen Variablen zu schreiben. Sie könnten einfach * und ** oder *var und **vars sagen. Lassen Sie uns jedoch über das JavaScript-Äquivalent im Jahr 2019 sprechen.

*args in Python stellt ein JavaScript-Array dar, z [“one”, “two”, “three”] Um dies an eine Python-Funktion zu übergeben, würden Sie die Funktion einfach als def function_name(*args) definieren: Dies bedeutet, dass diese Funktion “arrays” oder “list if you wish” zum Aufrufen akzeptiert, dass Sie einfach die Funktion function_name( verwenden würden.[“one”, “two”, “three”]):

Dasselbe kann in JavaScript mit getan werden:

function func(x,y,z){
  ...
}
let args = ["one", "two", "three"];

func(...args)

**or more dynamically as**

 function func(inputs<T>:Array){

   for(index in inputs){

      console.log(inputs[index]);
   }
}
let args = ["one", "two", "three"];

func(args)

Schau mal rein https://codeburst.io/a-simple-guide-to-destructuring-and-es6-spread-operator-e02212af5831

** kwargs hingegen stellen nur ein Array von Schlüsselwertpaaren (Objekten) dar, das war’s. So ist zB **kwargs [{“length”: 1, “height”: 2}, {“length”:3, “height”: 4}]

Um in Python eine Funktion zu definieren, die ein Array von Objekten akzeptiert, sagen Sie einfach def function_name(**kwargs): dann können Sie zum Aufrufen function_name( [{“length”: 1, “height”: 2}, {“length”:3, “height”: 4}]):

ähnlich in JS

const kwargs = [{"length": 1, "height": 2}, {"length":3, "height": 4}]

function func(obj1, obj2){
  ...
}

func(...kwargs);

**or more dynamically as:**

const kwargs = [{"length": 1, "height": 2}, {"length":3, "height": 4}]

function func(obj){
  for(const [key, value] of Object.entries(obj)){
    console.log(key, ": ", value)
 }

func(kwargs);