IIFE stands for Immediately Invoked Function Expressions. The JavaScript parser reads function foo() (); as function foo() and ();, where the former is a function declaration and the latter (a pair of parentheses) is an attempt at calling a function but there is no name specified, hence it throws Uncaught SyntaxError: Unexpected token ).
Here are two ways to fix it that involves adding more parentheses: (function foo() )() and (function foo() ()). Statements that begin with function are considered to be function declarations; by wrapping this function within (), it becomes a function expression which can then be executed with the subsequent (). These functions are not exposed in the global scope and you can even omit its name if you do not need to reference itself within the body.
JavaScript function declaration ambiguity
This question is pretty vague. My best guess at its intention is that it is asking about constructors in JavaScript. Technically speaking, function Person() is just a normal function declaration. The convention is to use PascalCase for functions that are intended to be used as constructors.
Hoisting is a term used to explain the behavior of variable declarations in your code. Variables declared or initialized with the var keyword will have their declaration "moved" up to the top of their module/function-level scope, which we refer to as hoisting. However, only the declaration is hoisted, the assignment (if there is one), will stay where it is.
Variables declared via let and const are hoisted as well. However, unlike var and function, they are not initialized and accessing them before the declaration will result in a ReferenceError exception. The variable is in a "temporal dead zone" from the start of the block until the declaration is processed.
The former is a function declaration while the latter is a function expression. The key difference is that function declarations have its body hoisted but the bodies of function expressions are not (they have the same hoisting behavior as variables). For more explanation on hoisting, refer to the question above on hoisting. If you try to invoke a function expression before it is defined, you will get an Uncaught TypeError: XXX is not a function error.
Each variable declaration defines a scope for that variable,that is, the section(s) of the program in which this variable isdefined and usable. In the example above, the scope of the variable\(x\) is the body of the function. When the use of a variable, say\(x\), appears within the scope of a declaration of \(x\), wesay that the former is bound to the latter, and the latter isthe binding occurrence of the variable. So, in the exampleabove, the declaration of \(x\) in parentheses is the bindingoccurrence of this variable and the use \(x\) on the next line isbound to this binding occurrence. A variable that is not bound is saidto be free. In the example above, the occurrence of \(y\)is free in the body of the function, since this function does notcontain any binding occurrence (i.e., declaration) of \(y\).
Since there may be several declarations of a variable \(x\) insidea given program, there cannot be any ambiguity about which declarationof the variable each use of it is bound to. This is why eachprogramming language must define a binding scheme. The lambdacalculus, like JavaScript and most other modern programming languages,uses static binding (also known as "static scoping" or "lexicalbinding"; see ), which means thateach variable use is bound to the variable declaration by the samename in the smallest lambda abstraction that contains the variableuse.
This lambda expression is a lambda abstraction whose parameter is\(y\) and whose body is the application of the identity functionto the expression \((y\ x)\). Therefore, the \(y\) after the\(\lambda\) is the binding occurrence of the variable\(y\). The scope of this declaration is \((\lambda x.x\ (y\x))\), which implies that the rightmost occurrence of \(y\) isbound to the leftmost binding occurrence. In contrast, the scope of thebinding occurrence of \(x\) in \(\lambda x.x\) is just thesecond \(x\) in it (that is, as always, the body of the lambdaabstraction). As a result, the third, rightmost occurrence of \(x\)in the expression above is free: it is a use of \(x\) thatdoes not belong to the scope of any declarations of \(x\).
var declarations are scoped to the beginning of the nearest enclosingfunction, script or module, which can cause unexpected behavior, especially withfunction closures that reference var declarations inside of loops. Thefollowing code gives an example:
Even though var declarations are scoped to the beginning of the enclosingfunction, var declarations should be as close as possible to their first use,for readability purposes. However, do not put a var declaration inside a blockif that variable is referenced outside the block. For example:
While most JavaScript VMs implemented before ECMAScript 6 support functiondeclarations within blocks it was not standardized. Implementations wereinconsistent with each other and with the now-standard ECMAScript 6 behavior forblock scoped function declaration. ECMAScript 5 and prior only allow forfunction declarations in the root statement list of a script or function andexplicitly ban them in block scopes in strict mode.
Previously such functionality was available only to embeddings that used org.mozilla.javascript.ImporterTopLevel class as the top level scope. The class provides additional importPackage() and importClass() global functions for scripts but their extensive usage has tendency to pollute the global name space with names of Java classes and prevents loaded classes from garbage collection.
Programmers often used the words invocation and invoking when talking about function and method calls. The terms are synonymous with "call" and "calling" but more clearly distinguish between the noun and verb forms. Invocation is a noun while invoking (as well as invoke and invoked) are the verb forms. You invoke a function to call it or write a function invocation that will be called when the program runs. We also use these terms, especially when we need to avoid ambiguity.
In JavaScript, we call a function definition that looks like that a function declaration. A notable property of function declarations is that you can call the function before you declare it. We'll learn why that is in the Core Curriculum; all you need to know now is that you don't have to declare functions before calling them.
That might look a little strange, but it's JavaScript that you'll see often. Most of it seems like a standard function declaration. However, since we're saving it to a variable, it's a function expression instead. Function expressions have one key difference from a function declaration: you cannot invoke a function expression before it appears in your program.
Any function definition that doesn't have the word function at the very beginning of a statement is a function expression. Even wrapping what looks like a function declaration in parentheses creates a function expression:
There's a third kind of function in JavaScript called an arrow function. Syntactically, arrow functions look radically different from function declarations and expressions. Let's look at one:
Understanding variable scope is essential towards becoming fluent with JavaScript. Function composition is something you'll use often, and understanding mutation helps you catch and avoid an entire class of bugs. There are multiple ways to declare functions: function declarations, function expressions, and arrow functions.
For functions, if a library name is not provided, the invocation must refer to a locally defined function, or a CQL system function. Function resolution proceeds by attempting to match the signature of the invocation, i.e. the number and type of each argument, to a defined signature for the function. Because the CQL type system supports subtyping, generics, and implicit conversion and casting, it is possible for an invocation signature to match multiple defined signatures. In these cases, the least converting signature is chosen, meaning the signature with the fewest required conversions. If multiple signatures have the same number of required conversions, an ambiguous resolution error is thrown, and the author must provide an explicit cast or conversion to resolve the ambiguity.
When CoffeeScript was designed, var was intentionally omitted. This was to spare developers the mental housekeeping of needing to worry about variable declaration (var foo) as opposed to variable assignment (foo = 1). The CoffeeScript compiler automatically takes care of declaration for you, by generating var statements at the top of every function scope. This makes it impossible to accidentally declare a global variable.
let and const add a useful ability to JavaScript in that you can use them to declare variables within a block scope, for example within an if statement body or a for loop body, whereas var always declares variables in the scope of an entire function. When CoffeeScript 2 was designed, there was much discussion of whether this functionality was useful enough to outweigh the simplicity offered by never needing to consider variable declaration in CoffeeScript. In the end, it was decided that the simplicity was more valued. In CoffeeScript there remains only one type of variable.
Newcomers to CoffeeScript often wonder how to generate the JavaScript function foo() , as opposed to the foo = function() that CoffeeScript produces. The first form is a function declaration, and the second is a function expression. As stated above, in CoffeeScript everything is an expression, so naturally we favor the expression form. Supporting only one variant helps avoid confusing bugs that can arise from the subtle differences between the two forms.
This is to avoid grammatical ambiguity, since in CoffeeScript such a construct looks identical to a function call (e.g. get(function foo() )); and because there is an alternate syntax that is slightly more verbose but just as effective: 2ff7e9595c
Comments