Function
========

Cada función de JavaScript en realidad es un objeto `Function`. Esto se puede ver con el código `(function() {}).constructor === Function`, que devuelve `true`.

Constructor
-----------

Function()

Crea un nuevo objeto `Function`. Llamar al constructor directamente puede crear funciones dinámicamente, pero tiene problemas de seguridad y de rendimiento similares (pero mucho menos importantes) para `eval` (en-US). Sin embargo, a diferencia de `eval`, el constructor `Function` crea funciones que solo se ejecutan en el ámbito global.

Propiedades de la instancia
---------------------------

`Function.arguments`

 Un arreglo que corresponde a los argumentos pasados a una función.
 Esto está obsoleto como propiedad de `Function`. En su lugar, utiliza el objeto arguments (disponible dentro de la función).


`Function.caller`

 Especifica la función que invocó a la función que se está ejecutando actualmente.
 Esta propiedad está obsoleta, y solo es funcional para algunas funciones no estrictas.


`Function.displayName`

El nombre a mostrar de la función.

`Function.length`

Especifica el número de argumentos que espera la función.

`Function.name`

El nombre de la función.

Métodos de instancia
--------------------

`Function.prototype.apply(thisArg [, argsArray])`

Llama a una función y establece su `this` en el `thisArg` proporcionado. Los argumentos se pueden pasar como un objeto `Array`.

`Function.prototype.bind(thisArg[, arg1[, arg2[, ...argN]]])`

Crea una nueva función que, cuando se llama, tiene su `this` configurado en el `thisArg`. Opcionalmente, una determinada secuencia de argumentos se antepondrá a los argumentos siempre que se llame a la función recién invocada.

`Function.prototype.call(thisArg[, arg1, arg2, ...argN])`

Llama a una función y establece su `this` en el valor proporcionado. Los argumentos se pueden pasar tal cual.

`Function.prototype.toString()`

 Devuelve una cadena que representa el código fuente de la función.
 Redefine el método `Object.prototype.toString()`.


Ejemplos
--------

### Diferencia entre el constructor Function y la declaración function

Las funciones creadas con el constructor `Function` no crean cierres para sus contextos de creación; siempre se crean en el ámbito global. Al ejecutarlos, solo podrán acceder a sus propias variables locales y globales, no a las del ámbito en el que se creó el constructor `Function`. Esto es diferente de usar `eval` (en-US) con código para una expresión de función.


```js
var x = 10;

function createFunction1() {
  var x = 20;
  return new Function("return x;"); // esta |x| se refiere a la |x| global
}

function createFunction2() {
  var x = 20;
  function f() {
    return x; // esta |x| se refiere a la |x| local
  }
  return f;
}

var f1 = createFunction1();
console.log(f1()); // 10
var f2 = createFunction2();
console.log(f2()); // 20
```


Si bien este código funciona en los navegadores web, `f1()` producirá un `ReferenceError` en Node.js, ya que no encontrará a `x`. Esto se debe a que el ámbito de nivel superior en Node no es el ámbito global, y `x` será local para el módulo.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-function-objects |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ve también
----------

* Funciones y ámbito de la función
* Declaración `function`
* Expresión `function`
* Declaración `function*`
* Expresión `function*`
* Función asíncrona
* Función generadora (en-US)