blocks|key|853112|text|参数是方法定义中的变量。调用方法时，参数是传递给方法参数的数据。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|853113|public+void+MyMethod(string+myParam)+{+}

...

string+myArg1+=+"this+is+my+argument";
myClass.MyMethod(myArg1);|code-block|syntax|javascript|853114|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|$]]

A parameter is a variable in a method definition. When a method is called, the arguments are the data you pass into the method's parameters.

<pre><code>public void MyMethod(string myParam) { }

...

string myArg1 = "this is my argument";
myClass.MyMethod(myArg1);
</code></pre>

blocks|key|853080|text|参数是函数声明中的变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|853081|参数是传递给函数的这个变量的实际值。|853082|entityMap^0|0|2|0|0|2|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Parameter is the variable in the declaration of the function.
Argument is the actual value of this variable that gets passed to the function.

blocks|key|857584|text|简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857585|PARAMETER→PLACEHOLDER+(这意味着占位符属于函数命名并在函数体中使用)|unordered-list-item|offset|length|style|BOLD|857586|ARGUMENT→ACTUAL值(这意味着通过函数调用传递的实际值)|857587|entityMap^0|0|0|1|A|1|0|0|1|9|1|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@$E|O|F|P|G|H]|$E|Q|F|R|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@$E|T|F|U|G|H]|$E|V|F|W|G|H]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$]]

Simple:

<ul>
<li>PARAMETER → PLACEHOLDER (This means a placeholder belongs to the function naming and be used in the function body)</li>
<li>ARGUMENT → ACTUAL VALUE (This means an actual value which is passed by the function calling)</li>
</ul>

blocks|key|181977|text|参数是函数声明中的一个变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|181978|参数是传递给函数的变量的实际值。|181979|​|181980|📷|atomic|181981|181982|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/4f6c1eab6fcc4dabc65bcbd3a80b55a1.png|imageAlt^0|0|2|0|0|2|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|12|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|M|3|I|5|6|7|17|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U|V|-4]]]]

A parameter is a variable in the declaration of the function.
An argument is the actual value of the variable that gets passed to the function.
<a href="https://i.stack.imgur.com/9lg1H.png" rel="noreferrer"><img src="https://i.stack.imgur.com/9lg1H.png" alt="Image of a code sample. Function sum takes parameters param1 and param2. It returns param1 plus param2. The function sum is called with the arguments 5 and 6. The image points out that param1 and param2 are parameters, whereas 5 and 6 are arguments." /></a>

blocks|key|1180188|text|在这个主题上已经有一个维基百科条目(参见参数，它定义和区分术语、参数和参数。简而言之，参数是函数/过程/方法签名的一部分，参数是在运行时和/或调用站点为参数提供的实际值。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1180189|维基百科的文章还指出，这两个术语经常被用作同义词(特别是在非正式地对代码进行推理时)：|1180190|虽然参数通常也被称为参数，但在运行时调用子例程时，参数被更恰当地看作是分配给参数变量的实际值或引用。|blockquote|1180191|给定C中添加两个整数的以下示例函数，x和y将被称为其参数：|style|CODE|1180192|int+add(int+x,+int+y)+{
++++return+x+%2B+y;
}|code-block|syntax|javascript|1180193|在使用add的调用站点上，如下面所示，123和456将被称为调用的参数。|1180194|int+result+=+add(123,+456);|1180195|另外，一些语言规范(或正式文档)选择只使用参数或参数，并使用像形式和实际这样的形容词来消除这两种情况之间的歧义。例如，C/C%2B%2B文档通常将函数参数称为形式参数，将函数调用参数称为实际参数。有关示例，请参见可视化C%2B%2B语言参考中的“可视化C%2B%2B语言参考”。|1180196|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Parameter_(computer_science%2529)|1|http://msdn.microsoft.com/en-us/library/3bstk3k5.aspx|2^0|K|2|0|0|0|0|I|1|K|1|0|0|3|3|0|0|2U|A|1|37|A|2|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|H|7|1D|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|1E|8|@$A|1F|B|1G|K|L]|$A|1H|B|1I|K|L]]|9|@]|C|$]]|$1|M|3|N|5|O|7|1J|8|@]|9|@]|C|$P|Q]]|$1|R|3|S|5|6|7|1K|8|@$A|1L|B|1M|K|L]]|9|@]|C|$]]|$1|T|3|U|5|O|7|1N|8|@]|9|@]|C|$P|Q]]|$1|V|3|W|5|6|7|1O|8|@]|9|@$A|1P|B|1Q|1|1R]|$A|1S|B|1T|1|1U]]|C|$]]|$1|X|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]]|Y|$Z|$5|10|11|12|C|$13|14]]|15|$5|10|11|12|C|$13|16]]|17|$5|10|11|12|C|$13|16]]]]

There is already a Wikipedia entry on the subject (see <a href="http://en.wikipedia.org/wiki/Parameter_(computer_science)" rel="noreferrer">Parameter</a>) that defines and distinguishes the terms parameter and argument. In short, a parameter is part of the function/procedure/method signature and an argument is the actual value supplied at run-time and/or call-site for the parameter. 

The Wikipedia article also states that the two terms are often used synonymously (especially when reasoning about code informally):

<blockquote>
 Although parameters are also commonly
 referred to as arguments, arguments
 are more properly thought of as the
 actual values or references assigned
 to the parameter variables when the
 subroutine is called at runtime.
</blockquote>

Given the following example function in C that adds two integers, <code>x</code> and <code>y</code> would be referred to as its parameters:

<pre><code>int add(int x, int y) {
 return x + y;
}
</code></pre>

At a call-site using <code>add</code>, such as the example shown below, 123 and 456 would be referred to as the arguments of the call.

<pre><code>int result = add(123, 456);
</code></pre>

Also, some language specifications (or formal documentation) choose to use parameter or argument exclusively and use adjectives like formal and actual instead to disambiguate between the two cases. For example, C/C++ documentation often refers to function parameters as formal arguments and function call arguments as actual arguments. For an example, see “<a href="http://msdn.microsoft.com/en-us/library/f81cdka5.aspx" rel="noreferrer">Formal and Actual Arguments</a>” in the <a href="http://msdn.microsoft.com/en-us/library/3bstk3k5.aspx" rel="noreferrer">Visual C++ Language Reference</a>.

blocks|key|1180103|text|参数是在调用函数时必须填写的内容。你所提出的就是论点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180104|简单设置:参数进入参数，参数是参数的值。|1180105|更多关于：参数的信息|offset|length|1180106|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments^0|0|0|5|2|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

A parameter is something you have to fill in when you call a function. What you put in it is the argument. 

Simply set: the argument goes into the parameter, an argument is the value of the parameter.

A bit more info on:
<a href="http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments" rel="noreferrer">http://en.wikipedia.org/wiki/Parameter_(computer_science)#Parameters_and_arguments</a>

blocks|key|853235|text|假设你是一家航空公司。你造了架飞机。你在里面装座位。然后，你把飞机上满是乘客，然后把它送到某个地方。乘客们下船了。第二天，你重复使用相同的飞机和相同的座位，但这次不同的乘客。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|853236|飞机是你的功用。|853237|参数是座位。|853238|争论的焦点是坐在这些座位上的乘客。|853239|function+fly(seat1,+seat2)+{
++++seat1.sayMyName();
++++//+Estraven
++++seat2.sayMyName();

++++etc.
}

var+passenger1+=+"Estraven";
var+passenger2+=+"Genly+Ai";

fly(passenger1,+passenger2);+|code-block|syntax|javascript|853240|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Let's say you're an airline. You build an airplane. You install seats in it. Then, you fill the plane up with passengers and send it somewhere. The passengers disembark. Next day, you re-use the same plane, and same seats, but with different passengers this time.
The plane is your function.
The parameters are the seats.
The arguments are the passengers that go in those seats.
<pre><code>function fly(seat1, seat2) {
 seat1.sayMyName();
 // Estraven
 seat2.sayMyName();

 etc.
}

var passenger1 = &quot;Estraven&quot;;
var passenger2 = &quot;Genly Ai&quot;;

fly(passenger1, passenger2); 
</code></pre>

blocks|key|181394|text|术语、参数和参数的使用在程序员甚至作者中间被误用了。在处理方法时，术语参数用于标识方法签名中的占位符，而术语参数是传递给方法的实际值。|type|blockquote|depth|inlineStyleRanges|entityRanges|data|181395|(考试70-483)+C#编程，第一版，Wrox，2013年|unstyled|181396|真实案例场景|offset|length|style|BOLD|181397|//+Define+a+method+with+two+parameters
int+Sum(int+num1,+int+num2)
{
+++return+num1+%2B+num2;
}

//+Call+the+method+using+two+arguments
var+ret+=+Sum(2,+3);|code-block|syntax|javascript|181398|entityMap^0|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|T|8|@$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|M|7|W|8|@]|9|@]|A|$N|O]]|$1|P|3|-4|5|D|7|X|8|@]|9|@]|A|$]]]|Q|$]]

<blockquote>
 The use of the terms parameters and arguments have been misused
 somewhat among programmers and even authors. When dealing with
 methods, the term parameter is used to identify the placeholders in
 the method signature, whereas the term arguments are the actual
 values that you pass in to the method.
</blockquote>

MCSD Cerfification Toolkit (Exam 70-483) Programming in C#, 1st edition, Wrox, 2013

Real-world case scenario

<pre><code>// Define a method with two parameters
int Sum(int num1, int num2)
{
 return num1 + num2;
}

// Call the method using two arguments
var ret = Sum(2, 3);
</code></pre>

blocks|key|1181058|text|一般来说，术语参数和参数可以互换地用来表示传递到函数中的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1181059|然而，从一个函数的角度来看：|1181060|参数是函数定义中括号中列出的变量。|unordered-list-item|offset|length|style|BOLD|1181061|参数是在调用函数时发送给函数的值。|1181062|entityMap^0|0|0|0|2|0|0|2|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@$G|R|H|S|I|J]]|9|@]|A|$]]|$1|K|3|L|5|F|7|T|8|@$G|U|H|V|I|J]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|N|$]]

Generally speaking, the terms parameter and argument are used interchangeably to mean information that is passed into a function.

Yet, from a function's perspective:

<ul>
<li>A parameter is the variable listed inside the parentheses in the function definition.</li>
<li>An argument is the value that is sent to the function when it is called.</li>
</ul>

blocks|key|181741|text|请永远记住：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181742|在接收参数时传递参数。|181743|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Always Remember that: 
Arguments are passed while parameters are received.

blocks|key|1180339|text|或者，在方法的可选参数的情况下，这样的记忆可能更简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180340|public+void+Method(string+parameter+=+"argument")+
{

}|code-block|syntax|javascript|1180341|parameter是参数，它的值，"argument"是参数:)|offset|length|style|CODE|1180342|entityMap^0|0|0|0|9|H|A|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Or maybe it's even simpler to remember like this, in case of optional arguments for a method:
<pre><code>public void Method(string parameter = &quot;argument&quot;) 
{

}
</code></pre>
<code>parameter</code> is the parameter, its value, <code>&quot;argument&quot;</code> is the argument :)

blocks|key|181325|text|在编辑过程中，人们往往会忘记:结构语言是以自然语言为基础的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181326|用英语|181327|“参数”是占位符。他们用口语设定了反应方式。根据定义，它是呼叫的一方，限制了响应。|181328|“论点”是一种正在考虑的立场。你在辩论你的观点:你考虑一个论点。|181329|主要差异|181330|论点的主题性角色是主体。参数的主题角色是接收者。|181331|交互作用|181332|把争论看作是男性的部分，把参数变成女性的部分。参数进入参数。|181333|用法|181334|定义中通常使用参数。参数通常用于调用。|181335|问题|181336|完成这个句子，使其不那么不和谐。|offset|length|style|BOLD|181337|(A)就定义而言：|181338|将使用什么论据？|ordered-list-item|181339|这个参数会是什么？|181340|(B)谈到援引：|181341|你将使用什么参数，[]？|181342|这个参数是什么？|181343|答案|181344|(A)|181345|打开/输入/反对/使用此参数|181346|争论..。拿走|181347|(B)|181348|什么是示例参数？|181349|争论..。用于/在/反对/与|181350|重叠|181351|正如你所能想象的，在回答之后:在口语中，这些词有时会产生相同的反应！|181352|因此，作为一项规则：|181353|通常，如果某人想要参数信息，他们想知道更多关于类型、变量名称等的信息。如果您只给出示例参数，他们可能会感到困惑。|unordered-list-item|181354|-+Usually+if+someone+wants+argument+information,+they+want+to+know+what+value+you+passed+to+a+function+or+its+parameter(s).|code-block|syntax|javascript|181355|​|181356|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|G|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2B|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|2C|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|2D|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|2E|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|2F|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|2G|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|2H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|2I|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|2J|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|2K|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2L|8|@$X|2M|Y|2N|Z|10]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2O|8|@]|9|@]|A|$]]|$1|13|3|14|5|15|7|2P|8|@]|9|@]|A|$]]|$1|16|3|17|5|15|7|2Q|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2R|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|15|7|2S|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|15|7|2T|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|2U|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|2V|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|15|7|2W|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|15|7|2X|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|15|7|2Z|8|@]|9|@]|A|$]]|$1|1Q|3|1R|5|15|7|30|8|@]|9|@]|A|$]]|$1|1S|3|1T|5|6|7|31|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|6|7|32|8|@]|9|@]|A|$]]|$1|1W|3|1X|5|6|7|33|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|20|7|34|8|@]|9|@]|A|$]]|$1|21|3|22|5|23|7|35|8|@]|9|@]|A|$24|25]]|$1|26|3|27|5|6|7|36|8|@]|9|@]|A|$]]|$1|28|3|-4|5|6|7|37|8|@]|9|@]|A|$]]]|29|$]]

In editing, I'm often put off at how people forget: structure languages are based on natural languages. 

<h2>In English</h2>

A "parameter" is a placeholder. They set the response format, in spoken language. By definition, it's party to the call, limiting the response.

An "argument" is a position that is being considered. You argue your opinion: you consider an argument. 

<h2>Main difference</h2>

The thematic role of an argument is agent. The thematic role of parameter is recipient. 

<h2>Interactions</h2>

Think of the argument as the male part, making the parameter the female part. The argument goes into the parameter. 

<h2>Usage</h2>

A parameter is usually used in definitions. An argument is usually used in invocations. 

<h2>Questions</h2>

Finish the sentence to make it less dissonant.

(A) Speaking of a definition:

<ol>
<li>What argument will be used []?</li>
<li>What [] will this parameter []?</li>
</ol>

(B) Speaking of an invocation:

<ol>
<li>What parameter will you use, []?</li>
<li>What [] will be [] this parameter? </li>
</ol>

<h2>Answers</h2>

(A) 

<ol>
<li>on/in/against/with this parameter</li>
<li>argument(s) ... take </li>
</ol>

(B) 

<ol>
<li>and what are some example arguments</li>
<li>argument(s) ... used on/in/against/with</li>
</ol>

<h2>Overlaps</h2>

As you can imagine, after answering: in spoken language, these words will sometimes produce identical responses! 

So, as a rule: 

<ul>
<li>Usually if someone wants parameter information, they want to know more about the type, the variable name, etc. They may become confused if you only give example arguments. 

<ul>
<li>Usually if someone wants argument information, they want to know what value you passed to a function or its parameter(s).</li>
</ul></li>
</ul>

blocks|key|181113|text|函数/方法的参数向您描述用于计算其结果的值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|181114|函数的参数是在函数/方法的特定调用过程中分配给这些参数的值。|181115|entityMap^0|6|2|0|3|2|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The parameters of a function/method describe to you the values that it uses to calculate its result.

The arguments of a function are the values assigned to these parameters during a particular call of the function/method.

blocks|key|857381|text|这个例子可能会有帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857382|int+main+()+{
+++int+x+=+5;+
+++int+y+=+4;

+++sum(x,+y);+//+**x+and+y+are+arguments**
}

int+sum(int+one,+int+two)+{+//+**one+and+two+are+parameters**
+++return+one+%2B+two;
}|code-block|syntax|javascript|857383|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|$]]

This example might help.

<pre><code>int main () {
 int x = 5; 
 int y = 4;

 sum(x, y); // **x and y are arguments**
}

int sum(int one, int two) { // **one and two are parameters**
 return one + two;
}
</code></pre>

blocks|key|1180640|text|参数和参数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180641|与参数和参数相关的所有不同术语都可能令人困惑。但是，如果您记住一些简单的要点，您将能够轻松地处理这些术语。|blockquote|1180642|函数的形式参数列在函数声明中，并在函数定义的正文中使用。形式参数(任何类型的)是一种空白或占位符，在调用该函数时会填充一些内容。|ordered-list-item|1180643|参数是用来填充形式参数的东西。在写入函数调用时，参数列在函数名称后面的括号中。在执行函数调用时，会插入参数作为形式参数。|1180644|术语“按值调用”和“按引用调用”是指插入过程中使用的机制.在按值调用方法中，只使用参数的值。在这种按值调用的机制中，形式参数是一个局部变量，它被初始化为相应参数的值。在按引用调用机制中，参数是一个变量，并使用整个变量。在按引用调用机制中，参数变量被替换为形式参数，因此对形式参数的任何更改实际上都是对参数变量的更改。|1180645|资料来源:绝对C%2B%2B，沃尔特·萨维奇|1180646|那是,|1180647|​|1180648|📷|atomic|offset|length|1180649|1180650|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/3ae4508a19639fd6e28f6bcd276042f8.jpg|imageAlt^0|0|0|0|0|0|0|0|0|0|1|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|18|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|19|8|@]|9|@]|A|$]]|$1|J|3|K|5|G|7|1A|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1B|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|T|7|1E|8|@]|9|@$U|1F|V|1G|1|1H]]|A|$]]|$1|W|3|Q|5|6|7|1I|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|Y|$Z|$5|10|11|12|A|$13|14|15|-4]]]]

Parameters and Arguments

<blockquote>
 All the different terms that have to do with parameters and arguments
 can be confusing. However, if you keep a few simple points in mind,
 you will be able to easily handle these terms.
 
 <ol>
 <li>The formal parameters for a function are listed in the function declaration and are used in the body of the function definition. A
 formal parameter (of any sort) is a kind of blank or placeholder that
 is filled in with something when the function is called.</li>
 <li>An argument is something that is used to fill in a formal parameter.
 When you write down a function call, the arguments are listed in
 parentheses after the function name. When the function call is
 executed, the arguments are plugged in for the formal parameters.</li>
 <li>The terms call-by-value and call-by-reference refer to the mechanism
 that is used in the plugging-in process. In the call-by-value method
 only the value of the argument is used. In this call-by-value
 mechanism, the formal parameter is a local variable that is
 initialized to the value of the corresponding argument. In the
 call-by-reference mechanism the argument is a variable and the
 entire variable is used. In the call- by-reference mechanism the
 argument variable is substituted for the formal parameter so that
 any change that is made to the formal parameter is actually made to
 the argument variable.</li>
 </ol>
</blockquote>

Source: Absolute C++, Walter Savitch

That is,

<a href="https://i.stack.imgur.com/ZohYJ.jpg" rel="noreferrer"><img src="https://i.stack.imgur.com/ZohYJ.jpg" alt="enter image description here"></a>

blocks|key|181173|text|这些术语在某种程度上可以互换。其他答案中描述的区别用函数正文中使用的名称的形式参数和在调用站点提供的值的参数(形式参数和参数也是常见的)来更恰当地表示。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181174|还请注意，在数学中，参数这个术语更常见，参数通常意味着完全不同的东西(尽管参数方程中的参数本质上是两个或多个函数的参数)。|181175|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The terms are somewhat interchangeable. The distinction described in other answers is more properly expressed with the terms formal parameter for the name used inside the body of the function and parameter for the value supplied at the call site (formal argument and argument are also common).

Also note that, in mathematics, the term argument is far more common and parameter usually means something quite different (though the parameter in a parametric equation is essentially the argument to two or more functions).

blocks|key|1180429|text|参数是参数的实例化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180430|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

An argument is an instantiation of a parameter.

blocks|key|181411|text|没有代码的简单解释|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181412|“参数”是一个非常笼统、宽泛的东西，但一个“论证”：是一个非常具体、具体的东西。这一点最好通过日常的例子来说明：|181413|示例1:自动售货机--货币是参数，$2.00是参数|181414|大多数机器接受输入并返回输出。例如，自动售货机作为输入:钱，返回:汽水作为输出。在这种情况下，它接受一个参数:货币。|181415|那麽，这是甚麽论据呢？如果我把$2.00放入机器，那么参数是：$2.00+--这是使用的非常具体的输入。|181416|例2:汽车-汽油是参数|181417|让我们考虑一辆汽车:他们接受汽油(无铅汽油)作为投入。可以说，这些机器接受参数的类型:汽油。这个论点将是我在我的车里投入的准确而具体的投入。就我而言，论点是:+40升无铅汽油/汽油。|offset|length|style|BOLD|181418|示例3-阐述论点|181419|参数是输入的一个特殊和具体的例子。假设我的机器以一个人作为输入，并将他们变成一个不是骗子的人。|181420|那麽，甚麽是争论呢？争论的对象将是真正被投入机器的人。如果科林·鲍威尔被送进机器，那么争论的焦点将是科林·鲍威尔。|181421|因此，参数将是person作为一个抽象的概念，但是参数始终是一个特定的person，它有一个特定的名称，它被放入机器中。这个论点是具体而具体的。|181422|这就是区别所在。很简单。|181423|迷惑了？|181424|发表评论，我会整理一下解释。|181425|entityMap^0|0|0|0|0|0|0|11|3|0|0|0|0|W|9|1A|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|18|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|19|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1A|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1B|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1C|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1D|8|@$N|1E|O|1F|P|Q]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1G|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1H|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1I|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1J|8|@$N|1K|O|1L|P|Q]|$N|1M|O|1N|P|Q]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1O|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1P|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|15|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|16|$]]

<h1>Simple Explanations without code</h1>

A "parameter" is a very general, broad thing, but an "argument: is a very specific, concrete thing. This is best illustrated via everyday examples:

<h3>Example 1: Vending Machines - Money is the parameter, $2.00 is the argument</h3>

Most machines take an input and return an output. For example a vending machine takes as an input: money, and returns: fizzy drinks as the output. In that particular case, it accepts as a parameter: money. 

What then is the argument? Well if I put $2.00 into the machine, then the argument is: $2.00 - it is the very specific input used.

<h3>Example 2: Cars - Petrol is the parameter</h3>

Let's consider a car: they accept petrol (unleaded gasoline) as an input. It can be said that these machines accept parameters of type: petrol. The argument would be the exact and concrete input I put into my car. e.g. In my case, the argument would be: 40 litres of unleaded petrol/gasoline.

<h3>Example 3 - Elaboration on Arguments</h3>

An argument is a particular and specific example of an input. Suppose my machine takes a person as an input and turns them into someone who isn't a liar.

What then is an argument? The argument will be the particular person who is actually put into the machine. e.g. if Colin Powell is put into the machine then the argument would be Colin Powell. 

So the parameter would be a person as an abstract concept, but the argument would always be a particular person with a particular name who is put into the machine. The argument is specific and concrete.

That's the difference. Simple.

<h3>Confused?</h3>

Post a comment and I'll fix up the explanation.

blocks|key|181702|text|是!参数和参数有不同的含义，可以很容易地解释如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181703|函数参数是函数定义中列出的名称。|offset|length|style|BOLD|181704|函数参数是传递给(并由)函数接收的实际值。|181705|entityMap^0|0|2|2|0|2|2|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

Yes! Parameters and Arguments have different meanings, which can be easily explained as follows:

Function Parameters are the names listed in the function definition.

Function Arguments are the real values passed to (and received by) the function.

blocks|key|857385|text|它们在C中的用法没有太大的差别，这两个术语都是在实践中使用的。大多数情况下，参数通常与函数一起使用。函数调用语句传递的值称为参数，参数将是在函数定义中复制值的变量(称为形式参数)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857386|int+main+()
{
+++/*+local+variable+definition+*/
+++int+a+=+100;
+++int+b+=+200;
+++int+ret;

+++/*+calling+a+function+to+get+max+value+*/
+++ret+=+max(a,+b);

+++printf(+"Max+value+is+:+%25d\n",+ret+);

+++return+0;
}

/*+function+returning+the+max+between+two+numbers+*/
int+max(int+num1,+int+num2)+
{
+++/*+local+variable+declaration+*/
+++int+result;

+++if+(num1+>+num2)
++++++result+=+num1;
+++else
++++++result+=+num2;

+++return+result;+
}|code-block|syntax|javascript|857387|在上面的代码中，num1和num2是形式参数，a和b是实际参数。|offset|length|style|CODE|857388|entityMap^0|0|0|8|4|D|4|N|1|P|1|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|N|$]]

They both dont have much difference in usage in C, both the terms are used
in practice.
 Mostly arguments are often used with functions. The value passed with the function calling statement is called the argument, And the parameter would be the variable which copies the value in the function definition (called as formal parameter). 

<pre><code>int main ()
{
 /* local variable definition */
 int a = 100;
 int b = 200;
 int ret;

 /* calling a function to get max value */
 ret = max(a, b);

 printf( "Max value is : %d\n", ret );

 return 0;
}

/* function returning the max between two numbers */
int max(int num1, int num2) 
{
 /* local variable declaration */
 int result;

 if (num1 &gt; num2)
 result = num1;
 else
 result = num2;

 return result; 
}
</code></pre>

In the above code <code>num1</code> and <code>num2</code> are formal parameters and <code>a</code> and <code>b</code> are actual arguments.

blocks|key|1180551|text|Oracle的Java教程定义了这种区别：“参数是指方法声明中的变量列表。参数是在调用方法时传入的实际值。在调用方法时，所使用的参数必须按类型和顺序匹配声明的参数。”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180552|参数和参数的更详细讨论：https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html|offset|length|1180553|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html^0|0|C|1U|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Oracle's Java tutorials define this distinction thusly:
"Parameters refers to the list of variables in a method declaration. Arguments are the actual values that are passed in when the method is invoked. When you invoke a method, the arguments used must match the declaration's parameters in type and order."

A more detailed discussion of parameters and arguments: 
<a href="https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html" rel="nofollow">https://docs.oracle.com/javase/tutorial/java/javaOO/arguments.html</a>

blocks|key|853421|text|从逻辑上讲，我们实际上是在谈论同样的事情。但我认为一个简单的比喻将有助于解决这一困境。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|853422|如果隐喻可以被称为各种连接点，我们可以将它们等同于将点插在墙上。在这种情况下，我们可以考虑参数和参数如下；|853423|参数是即插即用点的插座，它可能具有不同的形状.但只有某些类型的插头适合他们。|offset|length|style|BOLD|853424|参数将是插入到插头点/插座以激活某些设备的实际插头。|853425|entityMap^0|0|0|0|2|0|0|2|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

Logically speaking,we're actually talking about the same thing.
But I think a simple metaphor would be helpful to solve this dilemma. 

If the metaphors can be called various connection point we can equate them to plug points on a wall.
In this case we can consider parameters and arguments as follows;

Parameters are the sockets of the plug-point which may take various different shapes. But only certain types of plugs fit them. 
Arguments will be the actual plugs that would be plugged into the plug points/sockets to activate certain equipments.

blocks|key|182005|text|参数是函数定义中的变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|182006|参数是参数的值。|182007|<?php

++++/*+define+function+*/
++++function+myFunction($parameter1,+$parameter2)
++++{
++++++++echo+"This+is+value+of+paramater+1:+{$parameter1}+<br+/>";
++++++++echo+"This+is+value+of+paramater+2:+{$parameter2}+<br+/>";
++++}

++++/*+call+function+with+arguments*/
++++myFunction(1,+2);

?>|code-block|syntax|javascript|182008|entityMap^0|9|2|0|6|1|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|U|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Parameter is a variable in a function definition 
Argument is a value of parameter

<pre><code>&lt;?php

 /* define function */
 function myFunction($parameter1, $parameter2)
 {
 echo "This is value of paramater 1: {$parameter1} &lt;br /&gt;";
 echo "This is value of paramater 2: {$parameter2} &lt;br /&gt;";
 }

 /* call function with arguments*/
 myFunction(1, 2);

?&gt;
</code></pre>

blocks|key|857845|text|我还是不满意所有这些答案。他们都开始谈论“函数声明”，而我的猴子大脑已经离开，开始思考独角兽。这一点也帮不了我，这只是定义而已。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857846|我想要的东西，我可以立即和永远保持在我的脑海。|857847|我很快了解到的只回答这里是：|offset|length|857848|“A薪酬是传递给它的概念值”。|blockquote|style|BOLD|857849|参数更容易定义，只要你知道它们是什么，你就知道参数是另一个参数。|857850|我能想到的另一种方式是：|857851|参数是函数外部的变量|unordered-list-item|857852|参数是函数中的变量。|857853|简化为：|857854|外部参数，内部参数|857855|如果有人不同意我的意见，你可以把你的论点放在外面，把你的参数带进来;)|857856|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/156778/327074^0|0|0|7|5|0|0|1|1|0|0|0|0|2|0|0|5|9|1|0|0|4|0|0|9|0|0|Z|0^^$0|@$1|2|3|4|5|6|7|19|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1A|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1B|8|@]|9|@$F|1C|G|1D|1|1E]]|A|$]]|$1|H|3|I|5|J|7|1F|8|@$F|1G|G|1H|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1I|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1K|8|@$F|1L|G|1M|K|L]]|9|@]|A|$]]|$1|T|3|U|5|S|7|1N|8|@$F|1O|G|1P|K|L]|$F|1Q|G|1R|K|L]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1S|8|@$F|1T|G|1U|K|L]]|9|@]|A|$]]|$1|X|3|Y|5|J|7|1V|8|@$F|1W|G|1X|K|L]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1Y|8|@$F|1Z|G|20|K|L]]|9|@]|A|$]]|$1|11|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|12|$13|$5|14|15|16|A|$17|18]]]]

I'm still not happy with all these answers. They all start talking about 'function declarations' and my monkey brain has already wandered off and started thinking about unicorns. That doesn't help me remember at all, it's just the definition.
I want something that I can immediately and forever hold in my head.
The <a href="https://stackoverflow.com/a/156778/327074">only answer here</a> that I quickly understand is:
<blockquote>
&quot;Arguments are actual values that are passed in&quot;.
</blockquote>
Arguments are easier to define and as long as you know what they are then you know parameters are the other.
The other way I can think of it is:
<ul>
<li>Arguments are the variables outside the function</li>
<li>Parameters are the variables inside the function</li>
</ul>
Simplified down to:
<blockquote>
Arguments outside, parameters inside
</blockquote>
If any one wants to disagree with me, you can leave your arguments outside and bring your parameters in ;)

blocks|key|181486|text|当我们用Java创建方法(函数)时，这样的方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181487|data-type+name+of+the+method+(data-type+variable-name)|offset|length|style|CODE|181488|在括号中，这些是参数，当我们调用方法(函数)时，我们传递这个参数的值，这个值被称为参数。|181489|entityMap^0|0|0|1I|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

When we create the method (function) in Java, the method like this..

<code>data-type name of the method (data-type variable-name)</code>

In the parenthesis, these are the parameters, and when we call the method (function) we pass the value of this parameter, which are called the arguments.

blocks|key|181836|text|根据约瑟夫的“亚拉巴哈里”一书“简略的C#”(C#+7.0，第49页)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|181837|static+void+Foo+(int+x)
{
++++x+=+x+%2B+1;+//+When+you're+talking+in+context+of+this+method+x+is+parameter
++++Console.WriteLine+(x);
}
static+void+Main()
{
++++Foo+(8);+//+an+argument+of+8.+
+++++++++++++//+When+you're+talking+from+the+outer+scope+point+of+view
}|code-block|syntax|javascript|181838|在一些人类语言(afaik，意大利语，俄语)中，这些术语被广泛使用。|181839|参数=形式参数|unordered-list-item|offset|length|style|BOLD|181840|参数=实际参数|181841|在我的大学里，教授们都用这两种名字。|181842|entityMap^0|0|0|0|0|2|3|4|0|0|2|3|4|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|Y|8|@$L|Z|M|10|N|O]|$L|11|M|12|N|O]]|9|@]|A|$]]|$1|P|3|Q|5|K|7|13|8|@$L|14|M|15|N|O]|$L|16|M|17|N|O]]|9|@]|A|$]]|$1|R|3|S|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|U|$]]

According to Joseph's Alabahari book "C# in a Nutshell" (C# 7.0, p. 49) :

<pre><code>static void Foo (int x)
{
 x = x + 1; // When you're talking in context of this method x is parameter
 Console.WriteLine (x);
}
static void Main()
{
 Foo (8); // an argument of 8. 
 // When you're talking from the outer scope point of view
}
</code></pre>

In some human languages (afaik Italian, Russian) synonyms are widely used for these terms.

<ul>
<li>parameter = formal parameter</li>
<li>argument = actual parameter</li>
</ul>

In my university professors use both kind of names.

blocks|key|1180251|text|或者更简单..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180252|参数in+!|offset|length|style|BOLD|1180253|参数输出!|1180254|entityMap^0|0|0|6|0|0|5|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

Or even simpler...

Arguments in !

Parameters out !

blocks|key|1180803|text|我想了想，意识到我以前的回答是错误的。这里有一个更好的定义|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1180804|{想象一盒鸡蛋:一包香肠链接:和一个女佣}这些代表一个函数的元素所需的准备称为：(使用任何名称:让我们说烹饪是我的函数的名称)。|1180805|少女是一种方法。|1180806|(您必须使用__call_或要求此方法来制作早餐)(制作早餐的行为是一个名为Cooking)_的函数。|1180807|鸡蛋和香肠是参数：|1180808|(因为你想吃的鸡蛋和香肠的数量是__variable_+.)_。|1180809|你的决定是一个论点：|1180810|它表示您正在烹饪的鸡蛋和/或香肠数量的__Value_，._。|1180811|{Mnemonic}|1180812|当你打电话给女佣要她做早餐的时候，她和你一起__argues_关于你应该吃多少鸡蛋和香肠，她担心你的胆固醇“__|1180813|(因此，参数是已声明并决定传递给函数的参数组合的值)|1180814|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Y|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|13|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|14|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|15|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|16|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

I thought it through and realized my previous answer was wrong. Here's a much better definition

{Imagine a carton of eggs: A pack of sausage links: And a maid } These represent elements of a Function needed for preparation called : (use any name: Lets say Cooking is the name of my function). 

A Maid is a method . 

( You must __call_ or ask this method to make breakfast)(The act of making breakfast is a Function called Cooking)_

Eggs and sausages are Parameters :

(because the number of eggs and the number of sausages you want to eat is __variable_ .)_

Your decision is an Argument : 

It represents the __Value_ of the chosen number of eggs and/or sausages you are Cooking ._

{Mnemonic}

_" When you call the maid and ask her to make breakfast, she __argues_ with you about how many eggs and sausages you should eating. She's concerned about your cholesterol" __

( Arguments , then, are the values for the combination of Parameters you have declared and decided to pass to your Function )

blocks|key|1180942|text|它在参数(计算机编程)-+Wikipedia中解释得很完美|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1180943|松散地说，参数是类型，参数是实例。|1180944|在函数定义f(x)+=+x*x中，变量x是一个参数；在函数调用f(2)中，值2是函数的参数。|style|CODE|1180945|和参数-+Wikipedia|1180946|在计算机程序设计中，参数的两个概念被普遍使用，并被称为参数和参数(https://en.wikipedia.org/wiki/Parameter_(computer_programming%2529#Parameters_and_arguments)—or更正式地称为形式参数和实际参数。|BOLD|1180947|例如，在函数的定义中，例如|1180948|y+=+f(x)+=+x+%2B+2,|1180949|X是定义函数的形式参数(参数)。|1180950|当为给定值计算函数时，如|1180951|f(3):+or,+y+=+f(3)+=+3+%2B+2+=+5,|1180952|由定义的函数求值的实际参数(参数)；它是一个给定的值(实际值)，用于替换定义函数的形式参数。(在普通用法中，术语参数和参数可能在不经意间被互换，因此使用不当。)|1180953|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Parameter_(computer_programming)#Parameters_and_arguments|1|https://en.wikipedia.org/wiki/Parameter|2|https://en.wikipedia.org/wiki/Computer_programming|3|https://en.wikipedia.org/wiki/Parameter_(computer_programming)|4|https://en.wikipedia.org/wiki/Parameter_(computer_programming%2529#Parameters_and_arguments)%25E2%2580%2594or^0|2|K|0|0|0|5|A|J|1|V|4|0|1|D|1|0|3O|4|3T|4|1|7|2|A|2|3|X|2L|4|0|0|0|H|0|0|0|0|V|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@$A|1H|B|1I|1|1J]]|C|$]]|$1|D|3|E|5|6|7|1K|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1L|8|@$A|1M|B|1N|H|I]|$A|1O|B|1P|H|I]|$A|1Q|B|1R|H|I]]|9|@]|C|$]]|$1|J|3|K|5|6|7|1S|8|@]|9|@$A|1T|B|1U|1|1V]]|C|$]]|$1|L|3|M|5|6|7|1W|8|@$A|1X|B|1Y|H|N]|$A|1Z|B|20|H|N]]|9|@$A|21|B|22|1|23]|$A|24|B|25|1|26]|$A|27|B|28|1|29]]|C|$]]|$1|O|3|P|5|6|7|2A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|2B|8|@$A|2C|B|2D|H|I]]|9|@]|C|$]]|$1|S|3|T|5|6|7|2E|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|2F|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|2G|8|@$A|2H|B|2I|H|I]]|9|@]|C|$]]|$1|Y|3|Z|5|6|7|2J|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|2K|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]|18|$5|13|14|15|C|$16|19]]|1A|$5|13|14|15|C|$16|1B]]|1C|$5|13|14|15|C|$16|1D]]|1E|$5|13|14|15|C|$16|1F]]]]

It's explained perfectly in <a href="https://en.wikipedia.org/wiki/Parameter_(computer_programming)#Parameters_and_arguments" rel="nofollow noreferrer">Parameter (computer programming) - Wikipedia</a>

Loosely, a parameter is a type, and an argument is an instance.

In the function definition <code>f(x) = x*x</code> the variable <code>x</code> is a parameter; in the function call <code>f(2)</code> the value ``2 is the argument of the function. 

And <a href="https://en.wikipedia.org/wiki/Parameter" rel="nofollow noreferrer">Parameter - Wikipedia</a>

In <a href="https://en.wikipedia.org/wiki/Computer_programming" rel="nofollow noreferrer">computer programming</a>, two notions of <a href="https://en.wikipedia.org/wiki/Parameter_(computer_programming)" rel="nofollow noreferrer">parameter</a> are commonly used, and are referred to as <a href="https://en.wikipedia.org/wiki/Parameter_(computer_programming)#Parameters_and_arguments" rel="nofollow noreferrer">parameters and arguments</a>—or more formally as a formal parameter and an actual parameter.

For example, in the definition of a function such as

<code>y = f(x) = x + 2,</code>

x is the formal parameter (the parameter) of the defined function.

When the function is evaluated for a given value, as in

<code>f(3): or, y = f(3) = 3 + 2 = 5,</code>

is the actual parameter (the argument) for evaluation by the defined function; it is a given value (actual value) that is substituted for the formal parameter of the defined function. (In casual usage the terms parameter and argument might inadvertently be interchanged, and thereby used incorrectly.)

blocks|key|182022|text|由于我的背景和主要环境是C，我将从实际的C标准和一本重要的参考书中提供一些关于这个主题的声明/引用，这也是C的开发人员之一，它经常被引用并被视为C的第一个非官方标准：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|182023|C编程语言(第二版)，Brian+W.+Kernighan和Dennis+M.+Ritchie+(1988年4月)：|182024|第25页第1.7节-职能
我们通常对函数定义中括号大小的列表中的变量使用参数，并为函数调用中使用的值使用参数。形式论证和实际论证这两个术语有时用于同样的区别。|blockquote|182025|ISO/IEC+9899:2018+(C18)：|182026|3.3
参数
实际论证
不推荐的:实际参数
以函数调用表达式中的括号为界的逗号分隔列表中的表达式，或以类似函数的宏调用中的括号为界的逗号分隔列表中的预处理标记序列。|offset|length|style|BOLD|182027|3.16
参数
形式参数
被反对的:正式的论点
对象声明为函数声明或定义的一部分，该函数在函数输入时获取值，或从逗号分隔的列表中获取标识符，在类似函数的宏定义中紧接宏名称后面的括号包围。|182028|entityMap^0|0|0|0|0|4|2|0|5|2|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|W|8|@$K|X|L|Y|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|R|$]]

As my background and main environment is C, I will provide some statements/citations to that topic from the actual C standard and an important reference book, from also one of the developers of C, which is often cited and common treated as the first unofficial standard of C:
<hr />
The C Programming Language (2nd Edition) by Brian W. Kernighan and Dennis M. Ritchie (April 1988):
<blockquote>
Page 25, Section 1.7 - Functions
We will generally use parameter for a variable named in the parenthesized list in a function definition, and argument for the value used in the call of the function. The terms formal argument and actual argument are sometimes used for the same distinction.
</blockquote>
ISO/IEC 9899:2018 (C18):
<blockquote>
3.3
argument
actual argument
DEPRECATED: actual parameter
expression in the comma-separated list bounded by the parentheses in a function call expression, or a sequence of preprocessing tokens in the comma-separated list bounded by the parentheses in a function-like macro invocation.
</blockquote>
<hr />
<blockquote>
3.16
parameter
formal parameter
DEPRECATED: formal argument
object declared as part of a function declaration or definition that acquires a value on entry to the function, or an identifier from the comma-separated list bounded by the parentheses immediately following the macro name in a function-like macro definition.
</blockquote>

blocks|key|853326|text|参数是function.Hence接收到的变量，它们在函数declaration.They中是可见的，包含变量名及其数据类型。参数是传递给另一个函数的实际值。这就是为什么我们可以在函数调用中看到它们。它们只是没有数据类型的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|853327|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Parameters are the variables received by a function.Hence they are visible in function declaration.They contain the variable name with their data type.
Arguments are actual values which are passed to another function. thats why we can see them in function call. They are just values without their datatype

blocks|key|853480|text|函数的形式参数列在函数声明中，并在函数定义的正文中使用。正式的参数(任何类型的)是一种空白或占位符，在调用函数时填充了一些内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|853481|参数是用来填充形式参数的东西。在写入函数调用时，参数列在函数名称后面的括号中。在执行函数调用时，会插入参数作为形式参数。|853482|术语按值调用和指的是插入过程中使用的机制。在按值调用方法中，只使用参数的值。在这种按值调用的机制中，形式参数是一个局部变量，它被初始化为相应参数的值。在按引用调用机制中，参数是一个变量，并使用整个变量。在按引用调用机制中，参数变量被替换为形式参数，因此对形式参数的任何更改实际上都是对参数变量的更改。|853483|entityMap^0|V|2|0|0|2|0|2|4|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|K|$]]

The formal parameters for a function are listed in the function declaration and are used in the body of the function definition. A formal parameter (of any sort) is a kind of blank or placeholder that is filled in with something when the function is called.

An argument is something that is used to fill in a formal parameter. When you write down a function call, the arguments are listed in parentheses after the function name. When the function call is executed, the arguments are plugged in for the formal parameters.

The terms call-by-value and call-by-reference refer to the mechanism that is used in the plugging-in process. In the call-by-value method only the value of the argument is used. In this call-by-value mechanism, the formal parameter is a local variable that is initialized to the value of the corresponding argument. In the call-by-reference mechanism the argument is a variable and the entire variable is used. In the call- by-reference mechanism the argument variable is substituted for the formal parameter so that any change that is made to the formal parameter is actually made to the argument variable.

blocks|key|853495|text|参数是用于存储传递给函数使用的数据的变量。参数是在调用函数时传递给函数的实际数据：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|853496|//+x+and+y+are+parameters+in+this+function+declaration
function+add(x,+y)+{
++//+function+body
++var+sum+=+x+%2B+y;
++return+sum;+//+return+statement
}

//+1+and+2+are+passed+into+the+function+as+arguments
var+sum+=+add(1,+2);|code-block|syntax|javascript|853497|entityMap^0|0|2|L|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Parameters are variables that are used to store the data that's passed into a function for the function to use. Arguments are the actual data that's passed into a function when it is invoked:

<pre><code>// x and y are parameters in this function declaration
function add(x, y) {
 // function body
 var sum = x + y;
 return sum; // return statement
}

// 1 and 2 are passed into the function as arguments
var sum = add(1, 2);
</code></pre>

blocks|key|853601|text|您需要回到basics.Both构造函数和方法有参数，而arguments.Many人甚至调用构造函数，特殊类型的methods.This是如何声明方法的，参数是如何使用的|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|853602|++++++type+name(parameters){
+++++++++++//body+of+method
++++++++++}|code-block|syntax|javascript|853603|这就是如何声明构造函数，参数是如何使用的。|853604|classname(parameters){
//body
}|853605|现在让我们看一个示例代码，我们使用它来计算多维数据集的体积：|853606|public+class+cuboid+{
++++double+width;
++++double+height;
++++double+depth;

++++++cuboid(double+w,double+h,double+d)+{+
++++++//Here+w,h+and+d+are+parameters+of+constructor
+++++++this.width=w;
+++++++this.height=h;
+++++++this.depth=d;
+++++++}

++++++++public+double+volume()+{
++++++++double+v;
++++++++v=width*height*depth;
++++++++return+v;
++++++++}
++++++++public+static+void+main(String+args[]){
+++++++++++cuboid+c1=new+cuboid(10,20,30);
+++++++++++//Here+10,20+and+30+are+arguments+of+a+constructor
+++++++++++double+vol;
+++++++++++vol=c1.volume();
+++++++++++System.out.println("Volume+is:"%2Bvol);

+++++++++++}
++++}|853607|现在您知道了，当我们在代码后面的某个地方调用对象上的构造函数/方法时，我们传递参数而不是parameters.Hence参数仅限于定义逻辑对象的位置，但是当实际创建物理对象时会使用参数。|853608|entityMap^0|26|7|0|0|C|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

You need to get back to basics.Both constructors and methods have parameters and arguments.Many people even call constructors special kind of methods.This is how a method is declared parameters are used:

<pre><code> type name(parameters){
 //body of method
 }
</code></pre>

And this is how a constructor is declared parameters are used:

<pre><code>classname(parameters){
//body
}
</code></pre>

Now lets see an example code using which we calculate the volume of a cube:

<pre><code>public class cuboid {
 double width;
 double height;
 double depth;

 cuboid(double w,double h,double d) { 
 //Here w,h and d are parameters of constructor
 this.width=w;
 this.height=h;
 this.depth=d;
 }

 public double volume() {
 double v;
 v=width*height*depth;
 return v;
 }
 public static void main(String args[]){
 cuboid c1=new cuboid(10,20,30);
 //Here 10,20 and 30 are arguments of a constructor
 double vol;
 vol=c1.volume();
 System.out.println("Volume is:"+vol);

 }
 }
</code></pre>

So now you understand that when we call a constructor/method on an object at some place later in the code we pass arguments and not parameters.Hence parameters are limited to the place where the logical object is defined but arguments come into play when a physical object gets actually created.

blocks|key|1181087|text|参数：|type|unordered-list-item|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1181088|一个已经“内置”到函数中的值。|1181089|参数可以更改，以便该函数可用于其他事情。|1181090|unstyled|1181091|1181092|函数的输入|1181093|影响函数结果的变量。|1181094|1181095|来源|1181096|entityMap|0|LINK|mutability|MUTABLE|url|https://www.mathsisfun.com/definitions/parameter.html^0|0|2|1|1|1|0|0|2|1|1|1|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|-4|5|K|7|16|8|@]|D|@]|E|$]]|$1|L|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1B|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|K|7|1C|8|@]|D|@]|E|$]]|$1|R|3|S|5|K|7|1D|8|@]|D|@$9|1E|A|1F|1|1G]]|E|$]]|$1|T|3|-4|5|K|7|1H|8|@]|D|@]|E|$]]]|U|$V|$5|W|X|Y|E|$Z|10]]]]

<ul>
<li>Parameter:
<ul>
<li>A value that is already &quot;built in&quot; to a function.</li>
<li>Parameters can be changed so that the function can be used for other things.</li>
</ul>
</li>
<li>Argument:
<ul>
<li>An input to a function</li>
<li>A variable that affects a functions result.</li>
</ul>
</li>
</ul>
<a href="https://www.mathsisfun.com/definitions/parameter.html" rel="nofollow noreferrer">Source</a>

blocks|key|857825|text|请考虑下面的java代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|857826|public+class+Test{
+++public+String+hello(String+name){
++++++return+"Hello+Mr."%2Bname;
+++}

++public+static+void+main(String+args[]){
+++++Test+test+=+new+Test();
+++++String+myName+=+"James+Bond";
+++++test.hello(myName);
++}
}|code-block|syntax|javascript|857827|hello(String+)的方法定义声明了一个名为的字符串参数。在主方法中，我们通过传递参数+myName来调用hello方法。|offset|length|style|BOLD|857828|因此，参数是占位符，其中as参数是方法的实际值。|857829|entityMap^0|0|0|Q|4|19|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

Consider the below java code.
<pre><code>public class Test{
 public String hello(String name){
 return &quot;Hello Mr.&quot;+name;
 }

 public static void main(String args[]){
 Test test = new Test();
 String myName = &quot;James Bond&quot;;
 test.hello(myName);
 }
}
</code></pre>
The method definition of hello(String name) declares a String parameter called name.
In the main method we are calling the hello method by passing the argument myName.
So parameter is the placeholder where as argument is the actual value for a method.

blocks|key|182145|text|这是一个键:值问题..。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|182146|参数是|182147|182148|*|182149|示例：|182150|姓名："Peter“|182151|/*|182152|设printName+=+(name)+=>+=>|182153|printName("Peter")|182154|182155|在本例中，参数为"name"，参数为"Peter“。|182156|entityMap^0|4|3|0|0|2|0|0|2|0|0|0|0|0|E|4|0|A|7|0|0|5|2|F|2|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|G|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|I|3|J|5|6|7|18|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|19|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|1B|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1C|8|@$9|1D|A|1E|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|U|3|P|5|6|7|1I|8|@]|D|@]|E|$]]|$1|V|3|W|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1O|8|@]|D|@]|E|$]]]|Y|$]]

This is a key:value issue...
The parameter is the key
The argument is the value
/****************************************/
Example:
name: &quot;Peter&quot;
/********/
let printName = (name) =&gt; console.log(name)
printName(&quot;Peter&quot;)
/********/
In this case, the parameter is &quot;name&quot;, the argument is &quot;Peter&quot;

When verbally talking about methods, I'm never sure whether to use the word argument or parameter or something else. Either way the other people know what I mean, but what's correct, and what's the history of the terms?

I'm a C# programmer, but I also wonder whether people use different terms in different languages.

For the record I'm self-taught without a background in Computer Science. (Please don't tell me to read <a href="http://www.amazon.co.uk/Code-Complete-Practical-Handbook-Construction/dp/0735619670/" rel="noreferrer">Code Complete</a> because I'm asking this for the benefit of other people who don't already have a copy of <a href="http://www.stevemcconnell.com/" rel="noreferrer">Steve McConnell</a>'s marvellous book.)

<h3>Summary</h3>

The general consensus seems to be that it's OK to use these terms interchangeably in a team environment. Except perhaps when you're defining the precise terminology; then you can also use "formal argument/parameter" and "actual argument/parameter" to disambiguate.

What's the difference between an argument and a parameter?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在口头上谈论方法时，我从来不确定是使用参数、参数还是其他什么。不管是哪种方式，其他人都知道我的意思，但什么是正确的，以及这些术语的历史呢？我是一个C#程序员，但我也想知道人们是否在不同的语言中使用不同的术语。说句公道话，我是自学的，没有计算机科学背景。(请不要让我读，因为我这样问是为了帮助那些还没有那本绝妙的书的人。)摘要一般的共识是，在团队环境中交替使用这些术语是可以的。除非您正在定义精确的术语

问参数和参数有什么区别？
EN

回答 37

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问参数和参数有什么区别？EN

回答 37

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问参数和参数有什么区别？
EN