Spamless said:
While it is not a function (nor is "if") one can use parenthesis
and the white space between the word and the parenthesis does
not matter.
if (x==4)
or
if(x==4)
Generally javascript will allow any amount of white space to appear
between language tokens of any sort. There are some restrictions on the
contexts in which white space that is also a line terminator may appear,
But you could write your - if - statement as:-
if
(
x
==
4
)
{
...
}
- without causing any issues to the language interpreter (humans on the
other hand would tend to be unhappy to be asked to read it).
seem to work with no problems as does:
function square(x) {
return x*x OR
return (x*x) OR
return(x*x) OR
}
But return is not a function (as was pointed out).
The parentheses are not part of "return" (as they are in
a function's syntax, myfunction())
There is not really any "function's syntax, myfunction()". That is a
CallExpression, which is made up of two parts; a MemberExpression (or
another CallExpression) followed by an Arguments expression, where
Arguments are parentheses surrounding a possibly empty ArgumentsList.
This parenthesised Arguments expression can be regarded as an operator
that acts upon the MemberExpression as its operand; resolving the
MemberExpression as a function and calling it (passing any contained
arguments on to the call).
but simply delimiters for the expression returned.
Those parenthesise are not delimiters. They are actually an Expression
in their own right; a PrimaryExpression consisting of the parenthesise
sounding another Expression. This primary expression is evaluated at run
time, evaluating to the value of the result of the evaluation of the
Expression contained in the parenthesise. (Interpreter optimisations
should allow many parenthesised expressions to be silently removed and
replaced with the contained Expression, so they will not actually be
evaluated at run-time.)
If you use them it forces Javascript to evaluate that
expression.
The expression would be evaluated anyway. The parenthesise allow the
precise order of evaluation of a larger expression to be controlled, and
can be used to express the expected order of evaluation in the source
code (for clarity), or even to allow white-space free source code to be
unambiguously tokenised.
The only javascript production that allows that as an expression is
Arguments. It can only be interpreted as an attempt to call a
left-hand-side that is a function. The Expression in -
PrimaryExpression: ( Expression ) - is not optional.
(what does that evaluate to?) results in an error and
the default (unless you use try/catch to trap errors)
is to stop at an error.
Try-catch will not help at all in this context as Arguments following
the - return - keyword is a syntax error (return is not a
MemberExpression or a CallExpression). Syntax errors are triggered prior
to code execution and try-catch can only catch runtime errors (only the
use of - eval - or the Function constructor could produce a syntax error
at runtime and so be caught with try-catch).
Richard.
