blocks|key|890291|text|绝对不是。下面的函数调用如何：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|890292|+function(a,+b+-+c);|code-block|syntax|javascript|890293|使用空格而不是逗号会是什么样子？|890294|+function(a+b+-+c);|890295|这是指function(a,+b+-+c);还是function(a,+b,+-c);？逗号的用法可能来自数学，几个世纪以来，逗号一直被用来分隔函数参数。|offset|length|style|CODE|890296|entityMap^0|0|0|0|0|3|J|O|J|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Absolutely not. What about this function call:

<pre><code> function(a, b - c);
</code></pre>

How would that look with a space instead of the comma?

<pre><code> function(a b - c);
</code></pre>

Does that mean <code>function(a, b - c);</code> or <code>function(a, b, -c);</code>? The use of the comma presumably comes from mathematics, where commas have been used to separate function parameters for centuries.

blocks|key|888205|text|类Lisp语言使用：(f+arg1+arg2+arg3)，这实际上就是您所要求的。类ML语言使用连接来应用curried参数，因此您可以编写f+arg1+arg2+arg3。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|888206|entityMap^0|A|I|1Y|G|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Lisp-like languages use: <code>(f arg1 arg2 arg3)</code> which is essentially what you're asking for.
ML-like languages use concatenation to apply curried arguments, so you would write <code>f arg1 arg2 arg3</code>.

blocks|key|1633281|text|首先，你的前提是错误的。有些语言使用空格作为分隔符(lisp、ML、haskell，可能还有其他语言)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633282|大多数语言不这样做的原因可能是:+a)+f(x,y)是大多数人习惯的数学符号，b)使用空格会导致大量的嵌套括号(也称为“lisp效应”)。|offset|length|style|CODE|1633283|entityMap^0|0|K|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

First of all, your premise is false. There are languages that use space as a separator (lisp, ML, haskell, possibly others).

The reason that most languages don't is probably that a) <code>f(x,y)</code> is the notation most people are used to from mathematics and b) using spaces leads to lots of nested parentheses (also called "the lisp effect").

blocks|key|2743222|text|这不是真的。有些语言不使用逗号。在编程构造之前，函数一直是数学概念，因此一些语言保留了旧的表示法。比大多数较新的语言都受到C语言的启发(Javascript，Java，C#，PHP也是如此，它们共享一些正式的规则，比如逗号)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2743223|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|$]]

This is not true. Some languages don't use commas. Functions have been Maths concepts before programming constructs, so some languages keep the old notation. Than most of the newer has been inspired by C (Javascript, Java, C#, PHP too, they share some formal rules like comma).

blocks|key|1637049|text|你不需要比我们的大多数自然语言看得更远，就会发现逗号用于列表中的分隔项。因此，对于第一次学习编程语言的人来说，使用逗号以外的任何东西来枚举参数都是意想不到的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1637050|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|$]]

You don't have to look further than most of our natural languages to see that comma is used for separation items in lists. So, using anything other than comma for enumerating parameters would be unexpected for anyone learning a programming language for the first time.

blocks|key|2743296|text|Tcl使用空格作为传递给命令的单词之间的分隔符。如果它有一个复合参数，则必须用括号括起来或以其他方式引用。请注意，即使在那里，您也会发现使用逗号作为分隔符-仅在表达式语法中-但这是因为这种表示法在编程之外是常见的。数学已经用这种方式编写n元函数应用程序很长一段时间了；计算(特别是Fortran)只是借用。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2743297|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tcl.tk/^0|0|3|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]]]]

<a href="http://www.tcl.tk/" rel="nofollow noreferrer">Tcl</a> uses space as a separator between words passed to commands. Where it has a composite argument, that has to be bracketed or otherwise quoted. Mind you, even there you will find the use of commas as separators – in expression syntax only – but that's because the notation is in common use outside of programming. Mathematics has written n-ary function applications that way for a very long time; computing (notably Fortran) just borrowed.

blocks|key|4151447|text|这可能听起来有点明智，但我猜这与大多数地球上的语言(英语、法语和其他为数不多的语言)使用它的原因相同;-)而且，它对大多数人来说都是直观的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4151448|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|$]]

This may sound a bit wise but I gather for the same reason why most earth-planet languages use it (english, french, and those few others ;-) Also, it is intuitive to most.

blocks|key|890491|text|已经指出了许多历史原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|890492|此外，这是因为在,充当分隔符的大多数语言中，空格序列在很大程度上被忽略了，或者更准确地说，尽管它们可以分隔tokens，但它们本身并不充当标记。这对于所有从C派生语法的语言来说都是如此。空格序列很像空词，用空词来分隔任何东西可能不是最好的想法。|offset|length|style|CODE|890493|此外，我认为它更清晰，更容易阅读。为什么要让空格作为真正有意义的分隔符呢?空格是看不见的字符，本质上除了格式化之外什么也没有。它只会引入歧义。一个例子是由Carl提供的。|890494|第二个是f(a+(b+%2B+c))。现在是f(a(b%2Bc))还是f(a,+b%2Bc)|890495|JavaScript的创建者有一个非常有用的想法，类似于你的想法，它产生了同样的问题。这个想法是，如果语句完整，ENTER也可以充当;。请注意：|890496|function+a()+{
++++return+"some+really+long+string+or+expression+or+whatsoever";
}

function+b()+{
++++return+
++++++++++"some+really+long+string+or+expression+or+whatsoever";
}
alert(a());//"some+really+long+string+or+expression+or+whatsoever"
alert(b());//"undefined"+or+"null"+or+whatever,+because+'return;'+is+a+valid+statement|code-block|syntax|javascript|890497|事实上，我有时倾向于在没有这种“特性”的语言中使用后一种表示法。JavaScript强迫我使用一种方法来格式化我的代码，因为有人有一个很酷的想法，使用ENTER而不是;。|890498|我认为，有些语言是这样的，有很多很好的原因。特别是在动态语言(如PHP)中，没有编译时检查，编译器可能会警告您，上面给出的解决多义性的方法与您想要进行的调用的签名不匹配。你会有很多奇怪的运行时错误，生活也会很艰难。|890499|有一些语言允许这样做，但是有很多原因，为什么他们这样做。首先，也是最重要的，因为一群非常聪明的人坐下来，花了相当多的时间设计一门语言，然后发现，它的语法在大部分时间里让,过时了，因此决定取消它。|890500|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Token_%2528parser%2529#Token^0|0|8|1|1H|6|0|0|0|4|C|K|9|V|9|0|1U|1|0|0|2B|1|0|0|2C|1|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|H|3|I|5|6|7|1D|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1E|8|@$D|1F|E|1G|F|G]|$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|1L|8|@$D|1M|E|1N|F|G]]|9|@]|A|$]]|$1|N|3|O|5|P|7|1O|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1P|8|@$D|1Q|E|1R|F|G]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1S|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1T|8|@$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1W|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

There's a number of historical reasons already pointed out.

Also, it's because in most languages, where <code>,</code> serves as separator, whitespace sequences are largely ignored, or to be more exact, although they may separate <a href="http://en.wikipedia.org/wiki/Token_%28parser%29#Token" rel="noreferrer">tokens</a>, they do not act as tokens themselves. This is moreless true for all languages deriving their syntax from C. A sequence of whitespaces is much like the empty word and having the empty word delimit anything probably is not the best of ideas.

Also, I think it is clearer and easier to read. Why have whitespaces, which are invisible characters, and essentially serve nothing but the purpose of formatting, as really meaningful delimiters. It only introduces ambiguity. One example is that provided by Carl.

A second would <code>f(a (b + c))</code>. Now is that <code>f(a(b+c))</code> or <code>f(a, b+c)</code>?

The creators of JavaScript had a very useful idea, similar to yours, which yields just the same problems. The idea was, that ENTER could also serve as <code>;</code>, if the statement was complete. Observe:

<pre><code>function a() {
 return "some really long string or expression or whatsoever";
}

function b() {
 return 
 "some really long string or expression or whatsoever";
}
alert(a());//"some really long string or expression or whatsoever"
alert(b());//"undefined" or "null" or whatever, because 'return;' is a valid statement
</code></pre>

As a matter of fact, I sometimes tend to use the latter notation in languages, that do not have this 'feature'. JavaScript forces a way to format my code upon me, because someone had the cool idea, of using ENTER instead of <code>;</code>.

I think, there is a number of good reasons why some languages are the way they are. Especially in dynamic languages (as PHP), where there's no compile time check, where the compiler could warn you, that the way it resolved an ambiguity as given above, doesn't match the signature of the call you want to make. You'd have a lot of weird runtime errors and a really hard life.

There are languages, which allow this, but there's a number of reasons, why they do so. First and foremost, because a bunch of very clever people sat down and spent quite some time designing a language and then discovered, that its syntax makes the <code>,</code> obsolete most of the time, and thus took the decision to eliminate it.

blocks|key|888421|text|虽然有些语言确实使用空格，但使用逗号可以避免不需要括号的歧义情况。一个更有趣的问题可能是，为什么C使用与"a+then+b“操作符相同的字符作为分隔符；后一个问题在某些方面更有趣，因为C字符集还有另外三个没有出现在任何上下文中的字符(美元符号、商业-+at和grave，我知道其中至少有一个(美元符号)可以追溯到40个字符的穿孔卡集。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|888422|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|$]]

While some languages do use spaces, using a comma avoids ambiguous situations without the need for parentheses. A more interesting question might be why C uses the same character as a separator as is used for the "a then b" operator; the latter question is in some ways more interesting given that the C character set has at three other characters that do not appear in any context (dollar sign, commercial-at, and grave, and I know at least one of those (the dollar sign) dates back to the 40-character punchcard set.

blocks|key|2743566|text|Haskell不使用逗号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2743567|示例|2743568|multList+::+[Int]+->+Int+->+[Int]
multList+(x+:+xs)+y+=+(x+*+y)+:+(multList+xs+y)+
multList+[]+_+=+[]|code-block|syntax|javascript|2743569|在C/C%2B%2B中使用逗号的原因是，如果没有逗号，读取没有分隔符的长参数列表可能会很困难|2743570|试着阅读这篇文章|2743571|void+foo(void+*+ptr+point+&+*+big+list<pointers<point>+>+*+t)|2743572|逗号和空格一样有用。在拉丁语中，没有写空格、句号或小写字母的东西。|2743573|2743574|2743575|它主要是用来帮助你阅读的。|2743576|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|11|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|L|5|6|7|13|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|15|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|V|$]]

Haskell doesn't use commas.

Example

<pre><code>multList :: [Int] -&gt; Int -&gt; [Int]
multList (x : xs) y = (x * y) : (multList xs y) 
multList [] _ = []
</code></pre>

The reason for using commas in C/C++ is that reading a long argument list without a separator can be difficult without commas

Try reading this

<pre><code>void foo(void * ptr point &amp; * big list&lt;pointers&lt;point&gt; &gt; * t)
</code></pre>

commas are useful like spaces are. In Latin nothing was written with spaces, periods, or lower case letters.

Try reading this

IAMTHEVERYMODELOFAWHATDOYOUWANTNOTHATSMYBUCKET

it's primarily to help you read things.

blocks|key|2743641|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2743642|似乎所有的编程语言都使用逗号(，)来分隔函数参数。|blockquote|2743643|2743644|2743645|在脚本中包含逗号的自然语言中，该字符用于分隔事物。例如，如果你在哪里枚举水果，你应该写："lemon,+orange,+strawberry,+grape"，也就是，使用逗号。|offset|length|style|CODE|2743646|因此，使用逗号分隔函数中的参数比使用其他字符(%7C例如)更自然|2743647|考虑一下：|2743648|someFunction(+name,+age,+location+)+|code-block|syntax|javascript|2743649|与|2743650|someFunction(名称%7C年龄%7C位置)|2743651|2743652|为什么他们不只使用空格呢？|2743653|2743654|2743655|这是可能的。Lisp可以做到这一点。|2743656|主要原因是，空格已经被用来分隔令牌，并且不分配额外的功能更容易。|2743657|entityMap^0|0|0|0|0|18|Y|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|19|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1A|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1B|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1C|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1D|7|@$H|1E|I|1F|J|K]]|8|@]|9|$]]|$1|L|3|M|4|5|6|1G|7|@]|8|@]|9|$]]|$1|N|3|O|4|5|6|1H|7|@]|8|@]|9|$]]|$1|P|3|Q|4|R|6|1I|7|@]|8|@]|9|$S|T]]|$1|U|3|V|4|5|6|1J|7|@]|8|@]|9|$]]|$1|W|3|X|4|5|6|1K|7|@]|8|@]|9|$]]|$1|Y|3|-4|4|5|6|1L|7|@]|8|@]|9|$]]|$1|Z|3|10|4|C|6|1M|7|@]|8|@]|9|$]]|$1|11|3|-4|4|5|6|1N|7|@]|8|@]|9|$]]|$1|12|3|-4|4|5|6|1O|7|@]|8|@]|9|$]]|$1|13|3|14|4|5|6|1P|7|@]|8|@]|9|$]]|$1|15|3|16|4|5|6|1Q|7|@]|8|@]|9|$]]|$1|17|3|-4|4|5|6|1R|7|@]|8|@]|9|$]]]|18|$]]

<blockquote>
 It seems like all programming languages use commas (,) to separate function parameters.
</blockquote>

In natural languages that include comma in their script, that character is used to separate things. For instance, if you where to enumerate fruits, you'd write: <code>"lemon, orange, strawberry, grape"</code> That is, using comma. 

Hence, using comma to separate parameters in a function is more natural that using other character ( | for instance ) 

Consider: 

<pre><code>someFunction( name, age, location ) 
</code></pre>

vs. 

someFunction( name|age|location ) 

<blockquote>
 Why don't they use just spaces instead?
</blockquote>

Thats possible. Lisp does it. 

The main reason is, space, is already used to separate tokens, and it's easier not to assign an extra functionality.

blocks|key|1633575|text|我已经用相当多的语言编写过程序，虽然逗号并不是最高的，但它肯定在前面。逗号很好用，因为它是一个可见字符，因此可以通过删除空格来压缩脚本，而不会破坏内容。如果你有空间，那么你可以有标签，这可能是一个痛苦的…换行符和行尾的空格有问题。任何时候给我一个逗号，你都可以看到它，你知道它是做什么的。空格(通常)用于可读性，逗号是语法的一部分。请注意，有很多需要空格或需要空格的例外情况。我也喜欢花括号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1633576|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|$]]

I have programmed in quite a few languages and while the comma does not rule supreme it is certainly in front. The comma is good because it is a visible character so that script can be compressed by removing spaces without breaking things. If you have space then you can have tabs and that can be a pain in the ... There are issues with new-lines and spaces at the end of a line. Give me a comma any day, you can see it and you know what it does. Spaces are for readability (generally) and commas are part of syntax. Mind you there are plenty of exceptions where a space is required or de rigueur. I also like curly brackets.

blocks|key|4151811|text|这可能是传统。如果它们使用空格，则不能将表达式作为参数传递，例如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4151812|f(a-b+c)|code-block|syntax|javascript|4151813|将会与|4151814|f(a+-b+c)|4151815|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It is probably tradition. If they used space they could not pass expression as param e.g.

<pre><code>f(a-b c)
</code></pre>

would be very different from 

<pre><code>f(a -b c)
</code></pre>

blocks|key|888556|text|一些语言，如Boo，允许您指定或省略参数类型，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|888557|def+MyFunction(obj1,+obj2,+title+as+String,+count+as+Int):+++++++
++++...do+stuff...|code-block|syntax|javascript|888558|含义:+obj1和obj2可以是任何类型(继承自object)，其中as+title和count必须分别为String和Int类型。使用空格作为分隔符很难做到这一点。|888559|entityMap|0|LINK|mutability|MUTABLE|url|http://boo.codehaus.org/^0|6|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

Some languages, like <a href="http://boo.codehaus.org/" rel="nofollow">Boo</a>, allow you to specify the type of parameters or leave it out, like so:

<pre><code>def MyFunction(obj1, obj2, title as String, count as Int): 
 ...do stuff...
</code></pre>

Meaning: obj1 and obj2 can be of any type (inherited from object), where as title and count must be of type String and Int respectively. This would be hard to do using spaces as separators.

It seems like all programming languages use commas (,) to separate function parameters.

Why don't they use just spaces instead?

Why do programming languages use commas to separate function parameters?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

似乎所有的编程语言都使用逗号(，)来分隔函数参数。为什么他们不只使用空格呢？

问为什么编程语言使用逗号来分隔函数参数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么编程语言使用逗号来分隔函数参数？EN