blocks|key|288641|text|最接近的等价物是arguments+pseudo-array。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|288642|entityMap|0|LINK|mutability|MUTABLE|url|http://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/^0|8|9|8|M|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

The nearest equivalent is the <a href="http://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/" rel="noreferrer"><code>arguments</code> pseudo-array</a>.

blocks|key|288724|text|与*args最接近的习惯用法是|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|288725|function+func+(a,+b+/*,+*args*/)+{
++++var+star_args+=+Array.prototype.slice.call+(arguments,+func.length);
++++/*+now+star_args[0]+is+the+first+undeclared+argument+*/
}|code-block|syntax|javascript|288726|利用Function.length是函数定义中给定的参数数量这一事实。|288727|您可以将其打包成一个小的助手例程，如下所示|288728|function+get_star_args+(func,+args)+{
++++return+Array.prototype.slice.call+(args,+func.length);
}|288729|然后做|288730|function+func+(a,+b+/*,+*args*/)+{
++++var+star_args+=+get_star_args+(func,+arguments);
++++/*+now+star_args[0]+is+the+first+undeclared+argument+*/
}|288731|如果你想要语法糖，可以编写一个函数，将一个函数转换为另一个函数，该函数使用必需的和可选的参数进行调用，并传递所需的参数，以及任何附加的可选参数作为最终位置的数组：|288732|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);
++++};
}|288733|如下所示使用它：|288734|//+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);|288735|同样，如果您愿意要求调用者以数组的形式传递可选参数，那么您可以跳过所有这些胡言乱语：|288736|myfunc+(1,+2,+[3]);|288737|**kwargs实际上没有类似的解决方案，因为JS没有关键字参数。相反，只需要求调用者将可选参数作为对象传递：|288738|function+myfunc+(a,+b,+starstar_kwargs)+{
++++console.log+(a,+b,+starstar_kwargs.x);
}

myfunc+(1,+2,+{x:3});|288739|ES6更新|288740|为了完整起见，让我补充一句，ES6使用rest参数特性解决了这个问题。请参阅Javascript+-+'...'+meaning|288741|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/28421404/javascript-meaning/28421548^0|1|5|0|0|2|F|0|0|0|0|0|0|0|0|0|0|0|0|8|0|0|0|12|Q|0|0^^$0|@$1|2|3|4|5|6|7|1M|8|@$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1Q|8|@$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1T|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1V|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1W|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1X|8|@]|D|@]|E|$]]|$1|W|3|X|5|H|7|1Y|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|20|8|@]|D|@]|E|$I|J]]|$1|12|3|13|5|6|7|21|8|@]|D|@]|E|$]]|$1|14|3|15|5|H|7|22|8|@]|D|@]|E|$I|J]]|$1|16|3|17|5|6|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|18|3|19|5|H|7|26|8|@]|D|@]|E|$I|J]]|$1|1A|3|1B|5|6|7|27|8|@]|D|@]|E|$]]|$1|1C|3|1D|5|6|7|28|8|@]|D|@$9|29|A|2A|1|2B]]|E|$]]|$1|1E|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|1F|$1G|$5|1H|1I|1J|E|$1K|1L]]]]

The closest idiom for <code>*args</code> would be

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

taking advantage of the fact that <code>Function.length</code> is the number of arguments given in the function definition.

You could package this up in a little helper routine like

<pre><code>function get_star_args (func, args) {
 return Array.prototype.slice.call (args, func.length);
}
</code></pre>

and then do

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

If you're in the mood for syntactic sugar, write a function which transforms one function into another one which is called with required and optional arguments, and passes the required arguments along, with any additional optional arguments as an array in final position:

<pre><code>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);
 };
}
</code></pre>

Use this as follows:

<pre><code>// 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);
</code></pre>

Then again, you could just skip all this mumbo jumbo if you are willing to ask the caller to pass the optional arguments as an array to start with:

<pre><code>myfunc (1, 2, [3]);
</code></pre>

There is really no analogous solution for <code>**kwargs</code>, since JS has no keyword arguments. Instead, just ask the caller to pass the optional arguments in as an object:

<pre><code>function myfunc (a, b, starstar_kwargs) {
 console.log (a, b, starstar_kwargs.x);
}

myfunc (1, 2, {x:3});
</code></pre>

<h2>ES6 Update</h2>

For completeness, let me add that ES6 solves this problem with the rest parameter feature. See <a href="https://stackoverflow.com/questions/28421404/javascript-meaning/28421548">Javascript - &#39;...&#39; meaning</a>

blocks|key|71418|text|我在这里找到了一个很好的解决方案：http://readystate4.com/2008/08/17/javascript-argument-unpacking-converting-an-array-into-a-list-of-arguments/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|71419|基本上，使用function.apply(obj,+[args])而不是function.call。apply接受一个数组作为第二个参数，并为你“拆分”它。|style|CODE|71420|entityMap|0|LINK|mutability|MUTABLE|url|http://readystate4.com/2008/08/17/javascript-argument-unpacking-converting-an-array-into-a-list-of-arguments/^0|H|31|0|0|6|R|10|D|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]|$A|W|B|X|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

I found a good solution here:
<a href="http://readystate4.com/2008/08/17/javascript-argument-unpacking-converting-an-array-into-a-list-of-arguments/">http://readystate4.com/2008/08/17/javascript-argument-unpacking-converting-an-array-into-a-list-of-arguments/</a>

Basically, use <code>function.apply(obj, [args])</code> instead of <code>function.call</code>. apply takes an array as the 2nd arg and 'splats' it for you.

blocks|key|288806|text|ECMAScript+6将会有rest+parameters，它和splat操作符做同样的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|288807|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters^0|F|F|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

ECMAScript 6 will have <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters" rel="nofollow">rest parameters</a> which do the same thing as the splat operator.

blocks|key|288827|text|ES6向JavaScript添加了一个扩散运算符。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|288828|function+choose(choice,+...availableChoices)+{
++++return+availableChoices[choice];
}

choose(2,+"one",+"two",+"three",+"four");
//+returns+"three"|code-block|syntax|javascript|288829|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

ES6 added a spread operator to JavaScript.

<pre><code>function choose(choice, ...availableChoices) {
 return availableChoices[choice];
}

choose(2, "one", "two", "three", "four");
// returns "three"
</code></pre>

blocks|key|288849|text|对于那些可能对*args和**kwargs魔法变量有点迷惑的人，请阅读http://book.pythontips.com/en/latest/args_and_kwargs.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|288850|摘要：*args和**kwargs只是编写魔术变量的传统方法。你可以只说*和**或者*var和**vars。也就是说，让我们在2019年讨论一下JavaScript的等价物。|288851|*+python中的args表示一个JavaScript数组，例如“one”、“two”、"three“要将其传递给python函数，您只需将该函数定义为def+function_name(+*args+)：这意味着此函数接受”args“或"list+(如果您愿意)”来调用您只需使用函数function_name("one"，"two"，"three")：|288852|在JavaScript中，同样的事情可以通过使用以下命令来完成：|288853|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)|code-block|syntax|javascript|288854|看一看https://codeburst.io/a-simple-guide-to-destructuring-and-es6-spread-operator-e02212af5831|288855|**kwargs在另一方面只表示键值对(对象)的数组，仅此而已。因此**kwargs例如是{"length"：1，"height"：2}，{"length":3，"height"：4}|288856|在python中，要定义一个接受对象数组的函数，您只需说def+function_name(+**function_name)：然后调用您可以执行的长度(+{"length"：1，"height"：2}，{"length":3，"height"：4})：|288857|在JS中也类似|288858|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);|288859|entityMap|0|LINK|mutability|MUTABLE|url|http://book.pythontips.com/en/latest/args_and_kwargs.html|1|https://codeburst.io/a-simple-guide-to-destructuring-and-es6-spread-operator-e02212af5831^0|Z|1L|0|0|0|0|0|0|3|2H|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1E|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1F|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|Q|3|R|5|6|7|1K|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1L|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1M|8|@]|9|@]|C|$]]|$1|W|3|X|5|L|7|1N|8|@]|9|@]|C|$M|N]]|$1|Y|3|-4|5|6|7|1O|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]|16|$5|11|12|13|C|$14|17]]]]

For those who might be slightly lost about *args and **kwargs magic variables read <a href="http://book.pythontips.com/en/latest/args_and_kwargs.html" rel="nofollow noreferrer">http://book.pythontips.com/en/latest/args_and_kwargs.html</a>
Summary:
*args and **kwargs are just conventional ways of writing the magic variables. You could just say * and ** or *var and **vars. That said lets talk about the JavaScript equivalent in 2019.
*args in python represents a JavaScript Array e.g. [&quot;one&quot;, &quot;two&quot;, &quot;three&quot;] to pass that into a python function you would just define the function as def function_name(*args): meaning this function accepts &quot;arrays&quot; or &quot;list if you wish&quot; to call that you would simply use function function_name([&quot;one&quot;, &quot;two&quot;, &quot;three&quot;]):
same thing in JavaScript can be done by using :
<pre><code>function func(x,y,z){
 ...
}
let args = [&quot;one&quot;, &quot;two&quot;, &quot;three&quot;];

func(...args)

**or more dynamically as**

 function func(inputs&lt;T&gt;:Array){

 for(index in inputs){

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

func(args)
</code></pre>
Have a look at <a href="https://codeburst.io/a-simple-guide-to-destructuring-and-es6-spread-operator-e02212af5831" rel="nofollow noreferrer">https://codeburst.io/a-simple-guide-to-destructuring-and-es6-spread-operator-e02212af5831</a>
**kwargs on the other hand represent just an array of key value pairs(objects) that's it. Thus
**kwargs e.g is [{&quot;length&quot;: 1, &quot;height&quot;: 2}, {&quot;length&quot;:3, &quot;height&quot;: 4}]
in python to define a function accepting array of objects you just say def function_name(**kwargs): then to call that you can do function_name( [{&quot;length&quot;: 1, &quot;height&quot;: 2}, {&quot;length&quot;:3, &quot;height&quot;: 4}]):
similarly in JS
<pre><code>const kwargs = [{&quot;length&quot;: 1, &quot;height&quot;: 2}, {&quot;length&quot;:3, &quot;height&quot;: 4}]

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

func(...kwargs);

**or more dynamically as:**

const kwargs = [{&quot;length&quot;: 1, &quot;height&quot;: 2}, {&quot;length&quot;:3, &quot;height&quot;: 4}]

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

func(kwargs);
</code></pre>

I use Python a lot, and I am just quickly learning JavaScript right now (or should I say re-learning). So, I wanted to ask, what is the equivalent of <code>*args</code> and <code>**kwargs</code> in JavaScript?

Splat operators in JavaScript, equivalent to *args and **kwargs in Python?

Python

我经常使用Python，现在我只是在快速学习JavaScript (或者应该说是重新学习)。所以，我想问，在JavaScript中，*args和**kwargs的等价物是什么？

问JavaScript中的Splat运算符，相当于Python中的*args和**kwargs？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的Splat运算符，相当于Python中的*args和**kwargs？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的Splat运算符，相当于Python中的*args和**kwargs？
EN