mozilla

Functions and function scope

Questa traduzione è incompleta. Collabora alla traduzione di questo articolo dall’originale in lingua inglese.

Parlando in termini generici, una funzione è un "sottopogramma" che può essere chiamato da un codice esterno (o interno nel caso di ricorsione) alla funzione stessa. Come il programma stesso, una funzione è composta da una sequenza di istruzioni chiamate corpo della funzione. Ad una funzione possono essere passati valori, e la funzione può restituire un valore.

In JavaScript, le funzioni sono oggetti di prima classe, ovvero loro stesse sono oggetti e possono essere manipolate e passate proprio come qualsiasi altro oggetto. In particolare, le funzioni sono oggetti di tipo Function.

Per maggiori esempi e spiegazioni, vedere anche JavaScript la guida sulle funzioni.

Descrizione

Ogni funzione in JavaScript è un oggetto di tipo Function. Guarda Function per informazioni su proprietà e metodi dell'oggetto Function.

Le funzioni non sono come le procedure. Una funzione restituisce sempre un valore, mentre una procedura può o no restituire un valore.

Per restituire un valore specifico differente da quello di default, una fuzione deve avere un istruzione return che specifica il valore di ritorno. Una funzione senza un istruzione di ritorno restituirà il valore di  default. Nel caso di un costruttore invocato con la parola chiave new, il valore di default è il valore del suo parametro this. Per tutte le altre funzioni, il valore di ritorno di default è undefined.

I parametri di una chiamata di funzione sono gli argomenti della funzione. Gli argomenti sono passati alla funzione per valore. Se la funzione cambia il valore di un argomento, questo cambiamento non si riflette globalmente o nella funzione chiamante. Sebbene anche i riferimenti a oggetti siano valori, essi sono speciali: se una funzione cambia le proprietà di un oggetto a cui riferisce, quel cambiamento è visibile anche al di fuori della funzione, come dimostrato nel seguente esempio:

/* Dichiarazione dela funzione 'myFunc' */
function myFunc(theObject) {
   theObject.brand = "Toyota";
 }
 
 /*
  * Dichiarazione della variabile 'mycar';
  * creazione e inizializzazione di un nuovo Object;
  * associazione alla riferimento 'mycar'
  */
 var mycar = {
   brand: "Honda",
   model: "Accord",
   year: 1998
 };

 /* Logs 'Honda' */
 console.log(mycar.brand);

 /* Passaggio del riferimento dell'oggetto alla funzione */
 myFunc(mycar);

 /*
  * Logs 'Toyota' come il valore della proprietà 'brand'
  * dellàoggetto, come è stato cambiato dalla funzione.
  */
 console.log(mycar.brand);

La parola chiave this non fa riferimento alla funzione attualmente in esecuzione, per questo motivo si deve far riferimento ad oggetti Function  per nome, anche quando all'interno del corpo della funzione stessa.

Definizione di funzioni

Ci sono diversi modi per definire le funzioni:

La dichiarazione di funzione (istruzione function)

C'è una speciale sintassi per la dichiarazione di funzioni (per dettagli guarda function statement):

function name([param[, param[, ... param]]]) {
   statements
}
name
Il nome della funzione
param
Il nome di un argomento da passare alla funzione. Una funzione può avere fino a 255 argomenti.
statements
Le istruzioni comprese nel corpo della funzione.

L'espressione di funzione (espressione function)

Una espressione di funzione è simile ed ha la stessa sintassi della dichiarazione di funzione (per dettagli guarda function expression):

function [name]([param] [, param] [..., param]) {
   statements
}
name
Il nome della funzione. Può essere omesso, in qual caso la funzione è nota come funzione anonima.
param
Il nome di un argomento da passare alla funzione. Una funzione può avere fino a 255 argomenti.
statements
Le istruzioni comprese nel corpo della funzione.

La dichiarazione di funzione generatrice (espressione function*)

Note: Le funzioni generatrici sono un tecnologia sperimentale, parte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportate dai browsers.

C'è una sintassi speciale per le funzioni generatrici (per dettagli vedere function* statement):

function* name([param[, param[, ... param]]]) {
   statements
}
name
Nome della funzione.
param
Nome dell'argomento da passare alla funzione. Una funzione può avere fino a 255 agromenti.
statements
Le istruzioni comprese nel corpo della funzione.

L'espressione di funzione generatrice (espressione function*)

Note: Le funzioni generatrici sono una tecnologia sperimentale, parte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportamente dai browsers.

Una espressione di funzione generatrice è similare ed ha la stessa sintassi di una dichiarazione di funzione generatrice (per dettagli vedere function* expression):

function* [name]([param] [, param] [..., param]) {
   statements
}
name
Nome della funzione. Può essere omesso, nel qual caso è nota come funzione anonima.
param
Nome dell'argomento da passare alla funzione. Una funzione può avere fino a 255 agromenti.
statements
Le istruzioni comprese nel corpo della funzione.

L'espressione di funzione a freccia (=>)

Note: L'espressione di funzione a freccia sono una tecnologia sperimentareparte della proposta di specifica ECMAScript 6, e non sono ancora ampiamente supportate dai browsers.

Un' espressione di funzione a freccia ha una sintaassi ridotta e lessicalmnete associa il proprio valore this (per dettagli vedere arrow functions ):

([param] [, param]) => {
   statements
}

param => expression
param
Il nome di un parametro. È necessario indicare l'assenza di parametri con (). Le parentesi non sono richieste nel caso in cui ci sia solo un parametro (come foo => 1).
statements or expression
Molteplici istruzioni devono essere racchiuse tra virgolette. Una singola espressione non necessita di parantesi. L'espressione è anche l'impricita resituzione del valore delle funzione.

La Funzione costruttore

Note: Using the Function constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

As all other objects, Function objects can be created using the new operator:

new Function (arg1, arg2, ... argN, functionBody)
arg1, arg2, ... argN
Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "x", "theValue", or "a,b".
functionBody
A string containing the JavaScript statements comprising the function definition.

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

The GeneratorFunction constructor

Note: Arrow function expressions are an experimental technology, part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.

Note: GeneratorFunction is not a global object, but could be obtained from generator function instance (see GeneratorFunction for more detail).

Note: Using the GeneratorFunction constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.

As all other objects, GeneratorFunction objects can be created using the new operator:

new GeneratorFunction (arg1, arg2, ... argN, functionBody)
arg1, arg2, ... argN
Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "x", "theValue", or "a,b".
functionBody
A string containing the JavaScript statements comprising the function definition.

Invoking the Function constructor as a function (without using the new operator) has the same effect as invoking it as a constructor.

Function parameters

Note: Default and rest parameters are experimental technology, part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.

Default parameters

Default function parameters allow formal parameters to be initialized with default values if no value or undefined is passed. For more details, see default parameters.

Rest parameters

The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see rest parameters.

The arguments object

You can refer to a function's arguments within the function by using the arguments object. See arguments.

  • arguments: An array-like object containing the arguments passed to the currently executing function.
  • arguments.callee : The currently executing function.
  • arguments.caller : The function that invoked the currently executing function.
  • arguments.length: The number of arguments passed to the function.

Defining method functions

Getter and setter functions

You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.

get

Binds an object property to a function that will be called when that property is looked up.

set
Binds an object property to a function to be called when there is an attempt to set that property.

Method definition syntax

Note: Method definitions are experimental technology, part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.

Starting with ECMAScript 6, you are able to define own methods in a shorter syntax, similar to the getters and setters. See method definitions for more information.

var obj = {
  foo() {},
  bar() {}
};

Function constructor vs. function declaration vs. function expression

Compare the following:

A function defined with the Function constructor assigned to the variable multiply

function multiply(x, y) {
   return x * y;
}

A function expression of an anonymous function assigned to the variable multiply

var multiply = function(x, y) {
   return x * y;
};

A function expression of a function named func_name assigned to the variable multiply

var multiply = function func_name(x, y) {
   return x * y;
};

Differences

All do approximately the same thing, with a few subtle differences:

There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or undefined if the function name was previously declared via a var statement). For example:

var y = function x() {};
alert(x); // throws an error

The function name also appears when the function is serialized via Function's toString method.

On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope where the function is declared in.

As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other.A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:

A function defined by 'new Function' does not have a function name. However, in the SpiderMonkey JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, alert(new Function()) outputs:

function anonymous() {
}

Since the function actually does not have a name, anonymous is not a variable that can be accessed within the function. For example, the following would result in an error:

var foo = new Function("alert(anonymous);");
foo();

Unlike functions defined by function expressions or by the Function constructor, a function defined by a function declaration can be used before the function declaration itself. For example:

foo(); // alerts FOO!
function foo() {
   alert('FOO!');
}

A function defined by a function expression inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a Function constructor does not inherit any scope other than the global scope (which all functions inherit).

Functions defined by function expressions and function declarations are parsed only once, while those defined by the Function constructor are not. That is, the function body string passed to the Function constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "new Function(...)". Therefore the Function constructor should generally be avoided whenever possible.

It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a Function constructor 's string aren't parsed repeatedly. For example:

var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.

A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:

  • becomes part of an expression
  • is no longer a "source element" of a function or the script itself. A "source element" is a non-nested statement in the script or a function body:
var x = 0;               // source element
if (x == 0) {            // source element
   x = 10;               // not a source element
   function boo() {}     // not a source element
}
function foo() {         // source element
   var y = 20;           // source element
   function bar() {}     // source element
   while (y == 10) {     // source element
      function blah() {} // not a source element
      y++;               // not a source element
   }
}

Examples

// function declaration
function foo() {}

// function expression
(function bar() {})

// function expression
x = function hello() {}


if (x) {
   // function expression
   function world() {}
}


// function declaration
function a() {
   // function declaration
   function b() {}
   if (0) {
      // function expression
      function c() {}
   }
}

Conditionally defining a function

Functions can be conditionally defined using either //function statements// (an allowed extension to the ECMA-262 Edition 3 standard) or the Function constructor. Please note that such function statements are no longer allowed in ES5 strict. Additionally, this feature does not work consistently cross-browser, so you should not rely on it.

In the following script, the zero function is never defined and cannot be invoked, because 'if (0)' evaluates its condition to false:

if (0) {
   function zero() {
      document.writeln("This is zero.");
   }
}

If the script is changed so that the condition becomes 'if (1)', function zero is defined.

Note: Although this kind of function looks like a function declaration, it is actually an expression (or statement), since it is nested within another statement. See differences between function declarations and function expressions.

Note: Some JavaScript engines, not including SpiderMonkey, incorrectly treat any function expression with a name as a function definition. This would lead to zero being defined, even with the always-false if condition. A safer way to define functions conditionally is to define the function anonymously and assign it to a variable:

if (0) {
   var zero = function() {
      document.writeln("This is zero.");
   }
}

Examples

Returning a formatted number

The following function returns a string containing the formatted representation of a number padded with leading zeros.

// This function returns a string padded with leading zeros
function padZeros(num, totalLen) {
   var numStr = num.toString();             // Initialize return value as string
   var numZeros = totalLen - numStr.length; // Calculate no. of zeros
   for (var i = 1; i <= numZeros; i++) {
      numStr = "0" + numStr;
   }
   return numStr;
}

The following statements call the padZeros function.

var result;
result = padZeros(42,4); // returns "0042"
result = padZeros(42,2); // returns "42"
result = padZeros(5,4);  // returns "0005" 

Determining whether a function exists

You can determine whether a function exists by using the typeof operator. In the following example, a test is peformed to determine if the window object has a property called noFunc that is a function. If so, it is used; otherwise some other action is taken.

 if ('function' == typeof window.noFunc) {
   // use noFunc()
 } else {
   // do something else
 }

Note that in the if test, a reference to noFunc is used—there are no brackets "()" after the function name so the actual function is not called.

Specifications

Specification Status Comment
ECMAScript 1st Edition. Standard Initial definition. Implemented in JavaScript 1.0
ECMAScript 5.1 (ECMA-262)
The definition of 'Function Definition' in that specification.
Standard  
ECMAScript 6 (ECMA-262)
The definition of 'Function definitions' in that specification.
Release Candidate New: Arrow functions, Generator functions, default parameters, rest parameters
ECMAScript 6 (ECMA-262)
The definition of 'function*' in that specification.
Release Candidate Initial definition.
ECMAScript 6 (ECMA-262)
The definition of 'Arrow Function Definitions' in that specification.
Release Candidate Initial definition.

Browser compatibility

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Yes) (Yes) (Yes) (Yes) (Yes)
Generator function 39 26.0 (26.0) ? 26 ?
Arrow function Not supported 22.0 (22.0) Not supported Not supported Not supported
Feature Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Generator function ? 39 26.0 (26.0) ? 26 ?
Arrow function Not supported Not supported 22.0 (22.0) Not supported Not supported Not supported

See also

Etichette del documento e nomi di chi ha collaborato alla sua stesura

Contributors to this page: teoli, Salvo1402, ungarida
Ultima modifica di: ungarida,
Nascondi barra laterale