From a55b575e8089ee6cab7c5c262a7e6db55d0e34d6 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:46:50 +0100 Subject: unslug es: move --- .../global_objects/function/apply/index.html | 233 ++++++++++++++++ .../global_objects/function/arguments/index.html | 44 ++++ .../global_objects/function/bind/index.html | 293 +++++++++++++++++++++ .../global_objects/function/call/index.html | 113 ++++++++ .../global_objects/function/caller/index.html | 128 +++++++++ .../global_objects/function/displayname/index.html | 77 ++++++ .../global_objects/function/function/index.html | 92 +++++++ .../reference/global_objects/function/index.html | 118 +++++++++ .../global_objects/function/length/index.html | 151 +++++++++++ .../global_objects/function/name/index.html | 223 ++++++++++++++++ .../global_objects/function/tosource/index.html | 97 +++++++ .../global_objects/function/tostring/index.html | 130 +++++++++ 12 files changed, 1699 insertions(+) create mode 100644 files/es/web/javascript/reference/global_objects/function/apply/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/arguments/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/bind/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/call/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/caller/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/displayname/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/function/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/length/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/name/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/tosource/index.html create mode 100644 files/es/web/javascript/reference/global_objects/function/tostring/index.html (limited to 'files/es/web/javascript/reference/global_objects/function') diff --git a/files/es/web/javascript/reference/global_objects/function/apply/index.html b/files/es/web/javascript/reference/global_objects/function/apply/index.html new file mode 100644 index 0000000000..07f47b42f2 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/apply/index.html @@ -0,0 +1,233 @@ +--- +title: Function.prototype.apply() +slug: Web/JavaScript/Referencia/Objetos_globales/Function/apply +tags: + - Function + - JavaScript + - Method + - función + - metodo +translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply +--- +
{{JSRef("Objetos_globales", "Function")}}
+ +

Resumen

+ +

El método apply() invoca una determinada función asignando explícitamente el objeto this y un array o similar (array like object) como parámetros (argumentos) para dicha función.

+ +
NOTA: Aunque la sintaxis de esta función es casi idéntica a {{jsxref("Function.call", "call()")}}, la diferencia fundamental es que call() acepta una lista de argumentos, mientras que apply() acepta un simple array con los argumentos.
+ +

Sintaxis

+ +
fun.apply(thisArg[, argsArray])
+ +

Parámetros

+ +
+
thisArg
+
El valor del objeto this a utilizar dentro de la llamada a fun. Cabe mencionar que éste puede no ser el valor visto por el método: si el método es una función del tipo {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}}, {{jsxref("Global_Objects/null", "null")}} o {{jsxref("Global_Objects/undefined", "undefined")}} será reemplazado por el objeto global, y los valores primitivos serán encapsulados.
+
argsArray
+
Un objeto similar a un array (array like object), que contiene los parámetros con los que será llamada fun, o null o {{jsxref("undefined")}} si ningún argumento es estipulado. Desde la versión 5 de ECMAScript estos parámetros pueden estar en un objeto similar a un array en lugar de un array. Véase {{anch("Browser_compatibility", "browser compatibility")}} para mayor información.
+
+

Valor de retorno

+ +

El resultado de llamar a la función con el valor dado this y argumentos.

+
+
+ +

Descripción

+ +

Puede estipularse un objeto this diferente al llamar una función. this se refiere al objeto actual, el objeto haciendo la llamada. Con apply, puede escribirse un método una vez y heredarlo a otro objeto, sin necesidad de reescribir el método para adecuarlo al nuevo objeto.

+ +

apply es muy similar a {{jsxref("Function.call", "call()")}}, excepto por el tipo de argumentos que soporta. Puede utilizarse un arreglo de parámetros en lugar de un conjunto de pares nombre-valor. Con apply, puede utilizarse un arreglo literal, por ejemplo, fun.apply(this, ['eat', 'bananas']), o un objeto Array, por ejemplo, fun.apply(this, new Array('eat', 'bananas')).

+ +

Puede también utilizarse {{jsxref("Funciones/arguments", "arguments")}} como parámetro argsArray. arguments es una variable local a la función. Puede utilizarse para acceder a todos los argumentos no específicados en la llamada al objeto. Por lo tanto, no se requiere conocer todos los argumentos del objeto invocado cuando se utiliza el método apply. Puede utilizarse arguments para pasar los argumentos al objeto invocado. El objeto invocado es entonces responsable por el manejo de los argumentos.

+ +

Desde la 5ta edición de ECMAScript se puede utilizar también cualquier tipo de objeto similar a un arreglo, que en términos prácticos significa que tendrá una propiedad length y propiedades integer en el rango (0...length). Por ejemplo, ahora puede utilizarse un {{domxref("NodeList")}} o un objeto personalizado como: {'length': 2, '0': 'eat', '1': 'bananas'}.

+ +
{{ note("La mayoría de los navegadores, incluidos Chrome 14 e Internet Explorer 9, aún no soportan el uso de objetos similares a un array y arrojarán una excepción.") }}
+ +
 
+ +

Ejemplos

+ +

Utilizando apply para encadenar constructores

+ +

Puedes utilizar apply para encadenar {{jsxref("Operadores/new", "constructors")}} para un objeto, similar a Java. En el ejemplo siguiente se crea un método global a {{jsxref("Function")}} llamado construct, en cual posibilita el uso de un objeto similar a un arreglo en un constructor en lugar de una lista de argumentos.

+ +
Function.prototype.construct = function (aArgs) {
+    var fConstructor = this, fNewConstr = function () { fConstructor.apply(this, aArgs); };
+    fNewConstr.prototype = fConstructor.prototype;
+    return new fNewConstr();
+};
+ +

Ejemplo de uso:

+ +
function MyConstructor () {
+    for (var nProp = 0; nProp < arguments.length; nProp++) {
+        this["property" + nProp] = arguments[nProp];
+    }
+}
+
+var myArray = [4, "Hello world!", false];
+var myInstance = MyConstructor.construct(myArray);
+
+alert(myInstance.property1); // alerts "Hello world!"
+alert(myInstance instanceof MyConstructor); // alerts "true"
+alert(myInstance.constructor); // alerts "MyConstructor"
+ +
Nota: El método Function.construct no nativo no funcionará con algunos constructores nativos (como {{jsxref("Date")}}, por ejemplo). En estos casos se deberá utilizar el método {{jsxref("Function.bind")}} (por ejemplo, supóngase un arreglo como el siguiente para utilizar con el constructor Date: [2012, 11, 4]; en este caso se tendría que escribir algo como: new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() – de cualquier manera, ésta no es la mejor manera de hacerlo y probablemente no debería utilizarse en ningún entorno en producción).
+ +

apply y funciones built-in

+ +

El uso inteligente de apply permite utilizar funciones built-in para algunas tareas que, de otra manera, habrían sido escritas recorriendo los valores del arreglo dentro de un bucle. Como ejemplo, vamos a utilizar Math.max/Math.min para encontrar el máximo/mínimo valor en un arreglo.

+ +
/* min/max number in an array */
+var numbers = [5, 6, 2, 3, 7];
+
+/* using Math.min/Math.max apply */
+var max = Math.max.apply(null, numbers); /* This about equal to Math.max(numbers[0], ...) or Math.max(5, 6, ..) */
+var min = Math.min.apply(null, numbers);
+
+/* vs. simple loop based algorithm */
+max = -Infinity, min = +Infinity;
+
+for (var i = 0; i < numbers.length; i++) {
+  if (numbers[i] > max)
+    max = numbers[i];
+  if (numbers[i] < min)
+    min = numbers[i];
+}
+ +

Pero cuidado: utilizando apply de esta manera estás corriendo el riesgo de exceder el límite de argumentos permitido por el motor de JavaScript. Las consecuencias de aplicar una función con demasiados argumentos (imagínate más de decenas de miles de argumentos) varían entre los distintos motores (JavaScriptCore tiene un límite de argumentos fijo de 65536), porque el límite (de hecho, incluso el comportamiento de cualquier pila excesivamente larga) no está especificado. Algunos motores lanzarán una excepción. Más perniciosamente, otros limitarán de manera arbitraria el número de argumentos que se están pasando en realidad a la función. (Para ilustrar este último caso: si un motor tuviera un límite de cuatro argumentos [por supuesto, los límites reales son significamente mayores], sería como si los argumentos 5, 6, 2 y 3 hubieran sido pasados a apply en los ejemplos anteriores, en lugar del arreglo completo). Si el valor de tu arreglo pudiera crecer en decenas de miles, utiliza una estrategia híbrida: aplica a tu función trozos del array a la vez:

+ +
function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i < len; i += QUANTUM) {
+    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
+    min = Math.min(submin, min);
+  }
+
+  return min;
+}
+
+var min = minOfArray([5, 6, 2, 3, 7]);
+ +

Utilizando apply en "monkey-patching" 

+ +

(Reemplazando de manera dinámica los argumentos en tiempo de ejecución)

+ +

apply puede ser la mejor manera de reemplazar dinámicamente una función 'built-in' de Firefox, o de una librería de JavaScript. Dada una función someobject.foo, puedes modificar la función de una forma 'hacker', como ésta:

+ +
var originalfoo = someobject.foo;
+someobject.foo = function() {
+  // Haz algo antes de llamar a la función
+  console.log(arguments);
+  // Llama a la función como la hubieras llamado normalmente
+  originalfoo.apply(this, arguments);
+  // Aquí, ejecuta algo después
+}
+ +

Este método es especialmente útil cuando quieres depurar eventos, o interfaces con algún elemento que no tiene API, al igual que los diversos .on (eventos [event]..., como los que se usan en el Devtools Inspector)

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
{{SpecName('ES3')}}{{Spec2('ES3')}}Definición Inicial. Implementada in JavaScript 1.3.
{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-function.prototype.apply', 'Function.prototype.apply')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad entre navegadores

+ +

{{CompatibilityTable}}

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}{{CompatUnknown}}{{CompatGeckoDesktop("2.0")}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+ + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
ES 5.1 generic array-like object as {{jsxref("Functions/arguments", "arguments")}}{{CompatUnknown}}
+ +

Véase también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/arguments/index.html b/files/es/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..f0f8f6ca90 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,44 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Referencia/Objetos_globales/Function/arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +
{{JSRef("Objetos_globales", "Function")}} {{deprecated_header}}
+ +

Resumen

+ +

Un objeto de tipo arreglo correspondiente a los argumentos pasados a la función.

+ +

Descripción

+ +

Use el objeto arguments disponible dentro de las funciones en vez de Function.arguments.

+ +

Notas

+ +

En caso de recursividad, es decir, si la función f aparece varias veces en la pila de llamada, el valor de f.arguments representa los argumentos correspondientes a la invocación más reciente de la función.

+ +

Ejemplo

+ +
function f(n) { g(n-1) }
+function g(n) {
+  print("antes: " + g.arguments[0]);
+  if(n>0)
+    f(n);
+  print("después: " + g.arguments[0]);
+}
+f(2)
+
+ +

resultados:

+ +
antes: 1
+antes: 0
+después: 0
+después: 1
+
+ +

 

+ +
 
+ +

{{ languages( { "en": "en/Core_JavaScript_1.5_Reference/Global_Objects/Function/arguments", "pl": "pl/Dokumentacja_j\u0119zyka_JavaScript_1.5/Obiekty/Function/arguments" } ) }}

diff --git a/files/es/web/javascript/reference/global_objects/function/bind/index.html b/files/es/web/javascript/reference/global_objects/function/bind/index.html new file mode 100644 index 0000000000..bdc7b5b73c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/bind/index.html @@ -0,0 +1,293 @@ +--- +title: Function.prototype.bind() +slug: Web/JavaScript/Referencia/Objetos_globales/Function/bind +translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind +--- +
{{JSRef("Global_Objects", "Function")}}
+ +

Resumen

+ +

El método bind() crea una nueva función, que cuando es llamada, asigna a su operador  this el valor entregado, con una secuencia de argumentos dados precediendo a cualquiera entregados cuando la función es llamada. 

+ +

El valor de this es ignorado cuando la función es llamada con el operador new.

+ +

Sintaxis

+ +
fun.bind(thisArg[, arg1[, arg2[, ...]]])
+ +

Parametros

+ +
+
thisArg
+
Es un valor que será enviado a la función destino cuando se llame a la función de enlace. Este valor será ignorado si la función de enlace es construida usando el operador {{jsxref("Operators/new", "new")}}.
+
arg1, arg2, ...
+
Son los argumentos que se enviarán además de los provistos a la función de enlace cuando se invoque la función destino.
+
+ +

Valor de retorno

+ +

Una copia de la función entregada con el valor especificado this y los argumentos iniciales.

+ +

Descripción

+ +

La función bind() crea una nueva función (función ligada) con el mismo cuerpo (propiedad interna {{jsxref("Function.prototype.call", "call")}} en términos de ECMAScript 5) como la función que será llamada (la función objetivo de la función ligada) con la referencia this asociada al primer argumento de bind(), el cual no podrá ser sobreescrito. bind() también acepta parámetros predeterminados que antecederán al resto de los parámetros específicos cuando la función objetivo sea llamada. Una función ligada también puede ser construída utilizando el operador {{jsxref("Operators/new", "new")}}: al hacerlo, actuará como si en su lugar hubiera sido construída la función objetivo.

+ +

En este último caso, el parámetro correspondiente para this será ignorado, aunque los parámetros predeterminados que antecederán al resto sí serán provistos para la función emulada.

+ +

Ejemplos

+ +

Ejemplo: Crear una función ligada

+ +

El uso más simple de bind() es hacer que una función que, sin importar cómo es llamada, siempre apunte al mismo objeto con la referencia this. Un error común para nuevos programadores de JavaScript es que obtienen una referencia a un método de un objeto, posteriormente ejecutan ese método desde la referencia externa y esperan que la referencia de this siga apuntando al objeto original de donde se obtuvo el método (v.g. cuando se usa ese método en un callback). Sin el debido cuidado, el objeto original es comúnmente perdido. Creando una función ligada desde la función  empleando el objeto original, resuelve limpiamente este problema:

+ +
this.x = 9;
+var module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX(); // 81
+
+var getX = module.getX;
+getX(); // 9, porque en este caso, "this" apunta al objeto global
+
+// Crear una nueva función con 'this' asociado al objeto original 'module'
+var boundGetX = getX.bind(module);
+boundGetX(); // 81
+ +

Ejemplo: Funciones Parciales

+ +

El siguiente uso simple de bind() es definir una función con argumentos predeterminados que precederán a los argumentos finales de la función ligada. Estos argumentos iniciales (en caso de haberlos) se definen a continuación de lo que será la referencia de this y son entonces enviados como argumentos de la función objetivo, seguidos por los argumentos enviados a la función ligada cada vez que dicha función sea llamada.

+ +
function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+// Crear funcion (sin referencia this) con argumento inicial predeterminado
+var leadingThirtysevenList = list.bind(undefined, 37);
+
+var list2 = leadingThirtysevenList(); // [37]
+var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]
+
+ +

Ejemplo: Con setTimeout

+ +

De manera predeterminada, dentro de {{ domxref("window.setTimeout()") }}, la palabra reservada this será setteada al objeto {{ domxref("window") }} (o a global). Cuando se esté trabajando con métodos de clase que requieran que this se refiera a instancias de clase, usted puede explícitamente ligar this a la función callback para mantener la referencia de la instancia.

+ +
function LateBloomer() {
+  this.petalCount = Math.ceil(Math.random() * 12) + 1;
+}
+
+// Declare bloom after a delay of 1 second
+LateBloomer.prototype.bloom = function() {
+  window.setTimeout(this.declare.bind(this), 1000);
+};
+
+LateBloomer.prototype.declare = function() {
+  console.log('I am a beautiful flower with ' +
+    this.petalCount + ' petals!');
+};
+
+ +

Ejemplo: Funciones ligadas usadas como constructores

+ +
+

Advetencia: Esta sección demuestra las capacidades de JavaScript y documenta algunos usos extremos del método bind(). Los métodos mostrados a continuación no son la mejor forma de hacer las cosas y probablemente no deberían ser utilizados en ningún ambiente productivo.

+
+ +

Las funciones ligadas son automáticamente adecuadas para usarse con el operador {{jsxref("Operators/new", "new")}} para construir nuevas instancias creadas por la función objetivo. Cuando una función ligada es utilizada para construir un valor, el parámetro enviado para reemplazar la referencia this es ignorado. De cualquier forma, los argumentos iniciales sí son tomados en consideración y antecederán a los parámetros que se envíen al constructor:

+ +
function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return this.x + ',' + this.y;
+};
+
+var p = new Point(1, 2);
+p.toString(); // '1,2'
+
+
+var emptyObj = {};
+var YAxisPoint = Point.bind(emptyObj, 0/*x*/);
+// not supported in the polyfill below,
+// works fine with native bind:
+var YAxisPoint = Point.bind(null, 0/*x*/);
+
+var axisPoint = new YAxisPoint(5);
+axisPoint.toString(); // '0,5'
+
+axisPoint instanceof Point; // true
+axisPoint instanceof YAxisPoint; // true
+new Point(17, 42) instanceof YAxisPoint; // true
+
+ +

Note que no necesita hacer nada especial para crear una función ligada para usarse con {{jsxref("Operators/new", "new")}}. El razonamiento es que usted no necesita hacer nada especial para crear una función ligada para ser llamada planamente, aún si usted prefiriera requerir que la función ligada sea llamada únicamente utilizando {{jsxref("Operators/new", "new")}}.

+ +
// Ejemplo que puede ser ejecutado directamente en tu consola JavaScript
+// ...continúa de arriba
+
+// Aún puede ser invocada como una función normal
+// (aunque es usualmente indeseable)
+YAxisPoint(13);
+
+emptyObj.x + ',' + emptyObj.y;
+// >  '0,13'
+
+ +

Si desea utilizar una función ligada únicamente usando {{jsxref("Operators/new", "new")}}, o únicamente mediante una llamada directa, la función objetivo debe forzar esa restricción.

+ +

Ejemplo: Crear atajos

+ +

bind() también es útil en casos en los que desea crear un atajo para una función que requiere una referencia específica para this.

+ +

Tomando {{jsxref("Array.prototype.slice")}}, por ejemplo, el cual se desearía utilizar para convertir un objeto tipo array a un arreglo real. Podría crear un atajo como el siguiente:

+ +
var slice = Array.prototype.slice;
+
+// ...
+
+slice.call(arguments);
+
+ +

Con bind(), esto puede ser simplificado. En el siguiente fragmento de código, slice es una función ligada a la función {{jsxref("Function.prototype.call()", "call()")}} de {{jsxref("Function.prototype")}}, con la referencia this setteada a la función {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Esto significa que llamadas adicionales a call() pueden omitirse:

+ +
// same as "slice" in the previous example
+var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.call.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+
+ +

Polyfill

+ +

La función bind() fue añadida a la especificación ECMA-262, 5a edición; por lo tanto podría no estar presente en todos los navegadores. Usted puede parcialmente simularla al insertar el siguiente código al inicio de sus scripts, permitiendo emplear muchas de las funcionalidades de bind() en implementaciones que no la soportan nativamente.

+ +
if (!Function.prototype.bind) {
+  Function.prototype.bind = function(oThis) {
+    if (typeof this !== 'function') {
+      // closest thing possible to the ECMAScript 5
+      // internal IsCallable function
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+
+    var aArgs   = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP    = function() {},
+        fBound  = function() {
+          return fToBind.apply(this instanceof fNOP && oThis
+                 ? this
+                 : oThis,
+                 aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+
+ +

Algunas de las muchas diferencias (bien podría haber otras, en tanto la siguiente lista no intenta ser exhaustiva) entre este algoritmo y el algoritmo de la especificación son:

+ + + +

Si elige usar esta implementación parcial, no debe de utilizarla en los casos en los que el comportamiento es distinto al de la especificación ECMA-262, 5th edition! Con un poco de cuidado, de cualquier manera (y tal vez con algunas modificaciones adicionales para adecuarse a sus necesidades específicas), esta implementación parcial podría ser un puente razonable al momento en que bind() sea ampliamente implementada acorde a a la especificación.

+ +

Por favor checa https://github.com/Raynos/function-bind para ver una solución más profunda.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentarios
{{SpecName('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}{{Spec2('ES5.1')}}Definición inicial. Implementado en JavaScript 1.8.5.
{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}{{Spec2('ES6')}} 
+ +

Compatibilidad de navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatChrome("7")}}{{CompatGeckoDesktop("2")}}{{CompatIE("9")}}{{CompatOpera("11.60")}}{{CompatSafari("5.1.4")}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatAndroid("4.0")}}{{CompatChrome("0.16")}}{{CompatGeckoMobile("2")}}{{CompatUnknown}}{{CompatOperaMobile("11.50")}}{{CompatSafari("6.0")}}
+
+ +

Basado en Kangax's compat tables.

+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/call/index.html b/files/es/web/javascript/reference/global_objects/function/call/index.html new file mode 100644 index 0000000000..4200c5d2a5 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/call/index.html @@ -0,0 +1,113 @@ +--- +title: Function.prototype.call() +slug: Web/JavaScript/Referencia/Objetos_globales/Function/call +tags: + - Function + - JavaScript + - Method +translation_of: Web/JavaScript/Reference/Global_Objects/Function/call +--- +
{{JSRef("Objetos_globales", "Function")}}
+ +

Resumen

+ +

El método call() llama a una función con un valor dado this y con argumentos provistos individualmente.

+ +

Sintaxis

+ +
function.call(thisArg[, arg1[, arg2[, ...]]])
+ +

Parametros

+ +
+
thisArg {{optional_inline}}
+
El valor a usar como this cuando se llama a function.
+
+
+

Cuidado: En ciertos casos, thisArg puede no ser el valor actual visto por el método.

+ +

Si el método es una función en {{jsxref("Strict_mode", "non-strict mode", "", 1)}}, {{jsxref("Global_Objects/null", "null")}} y {{jsxref("Global_Objects/undefined", "undefined")}} serán reemplazados con el objeto global, y valores primitivos serán convertidos a objetos.

+
+
+
arg1, arg2, ...
+
Argumentos para el objeto.
+
+

Valor de retorno

+
+
El resultado de llamar a la función con el this especificado y los argumentos.
+
+ +

Descripción

+ +

call() permite que una función/método que pertenece a un objeto, ser asignada y llamada para un objeto diferente.

+ +

call() provee un nuevo valor de this a la función/método. Con call(), puedes escribir un método ona vez y heredarlo a otro objeto, sin tener que reescribir el método en el nuevo objeto.

+ +
Nota: Mientras la sintaxis de esta función es casi identica a la función {{jsxref("Function.apply", "apply()")}}, la diferencia fundamental es que call() acepta una lista de argumentos, mientras apply() accepta un arreglo sencillo de argumentos.
+ +

Ejemplos

+ +

Usando call para encadenar constructores para un objeto

+ +

Puede usar call para encadenar constructores para un objeto (similar a Java).

+ +

En el siguiente ejemplo, el constructor para el objeto Producto es definido con dos parametros, nombre y precio.

+ +

Otras dos funciones Comida y Juguete invocan a Producto, pasándo this, nombre y precio. Producto inicializa las propiedades nombre y precio, ambas funciones especializadas definen la categoria.

+ +
function Producto(nombre, precio) {
+  this.nombre = nombre;
+  this.precio = precio;
+
+  if (precio < 0)
+    throw RangeError('No se puede crear el producto "' + nombre + '" con un precio negativo');
+  return this;
+}
+
+function Comida(nombre, precio) {
+  Producto.call(this, nombre, precio);
+  this.categoria = 'comida';
+}
+Comida.prototype = new Producto();
+
+function Juguete(nombre, precio) {
+  Producto.call(this, nombre, precio);
+  this.categoria = 'juguete';
+}
+Juguete.prototype = new Producto();
+
+var queso = new Comida('feta', 5);
+var diversion = new Juguete('robot', 40);
+
+ +

Usando call para invocar una función anónima

+ +

En este ejemplo, creamos una función anónima y usamos call para invocarla en cada objeto en un arreglo.

+ +

El propósito principal de la función anónima aquí es agregar una función print  a cada objeto, el cual puede imprimir el índice correcto en el arreglo.

+ +
+

Pasar el objeto como valor this no es estrictamente necesario, pero se hace con propósito explicativo.

+
+ +
var animales = [
+  {especie: 'Leon', nombre: 'Rey'},
+  {especie: 'Whale', nombre: 'Fail'}
+];
+
+for (var i = 0; i < animales.length; i++) {
+  (function (i) {
+    this.imprimir = function () {
+      console.log('#' + i  + ' ' + this.especie + ': ' + this.nombre);
+    }
+    this.imprimir();
+  }).call(animales[i], i);
+}
+
+ +

See also

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/caller/index.html b/files/es/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..942df69a68 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,128 @@ +--- +title: Function.caller +slug: Web/JavaScript/Referencia/Objetos_globales/Function/caller +tags: + - Función Javascript No-standard Propiedad +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +
{{JSRef("Global_Objects", "Function")}} {{non-standard_header}}
+ +

Resumen

+ +

La propiedad function.caller retorna la función que llamó a la función especificada.

+ +

Descripción

+ +

Si la función f fue llamada por desde nivel raiz (top level code), el valor de f.caller es {{jsxref("Global_Objects/null", "null")}}, de lo contrario se retorna la función que llamó a f.

+ +

Esta propiedad reemplaza a la propiedad obsoleta {{jsxref("Functions_and_function_scope/arguments/caller", "arguments.caller")}} del objeto {{jsxref("Funciones/arguments", "arguments")}}.

+ +

la propiedad especial __caller__, la cual retornaba el objeto de activación del llamador y permitía reconstruir la pila de llamadas, ha sido removida por motivos de seguridad.

+ +

Notas

+ +

En caso de recursión se puede reconstruir la pila de llamada utilizando esta propiedad, tal como se muestra a continuación:

+ +
function f(n) { g(n - 1); }
+function g(n) { if (n > 0) { f(n); } else { stop(); } }
+f(2);
+
+ +

Al momento de ejecutar stop() este se llama con la siguiente pila de llamadas:

+ +
f(2) -> g(1) -> f(1) -> g(0) -> stop()
+
+ +

Siendo verdadero la siguiente consideración:

+ +
stop.caller === g && f.caller === g && g.caller === f
+
+ +

Por lo tanto si se intenta obtener el rastro de llamadas (stack trace) de la función stop() como se muestra a continuación:

+ +
var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+
+ +

se provocará una bucle que nunca termina.

+ +

Ejemplos

+ +

Ejemplo: Verificar el valor de la propiedad caller de una función

+ +

El siguiente código verifica el valor de la propiedad caller de una función.

+ +
function myFunc() {
+  if (myFunc.caller == null) {
+    return 'The function was called from the top!';
+  } else {
+    return 'This function\'s caller was ' + myFunc.caller;
+  }
+}
+
+ +

Especificación

+ +

No es parte de ninguna especificación. Se implementa en JavaScript 1.5.

+ +

Compatiblilidad de Navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte Básico{{CompatVersionUnknown}}{{CompatGeckoDesktop("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte Básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatGeckoMobile("1.0")}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Véase también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/displayname/index.html b/files/es/web/javascript/reference/global_objects/function/displayname/index.html new file mode 100644 index 0000000000..d464266838 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/displayname/index.html @@ -0,0 +1,77 @@ +--- +title: Function.displayName +slug: Web/JavaScript/Referencia/Objetos_globales/Function/displayName +translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName +--- +
{{JSRef}} {{non-standard_header}}
+ +

The function.displayName property returns the display name of the function.

+ +

Description

+ +

Cuando se define la propiedad displayName , retorna un mensaje con el nombre para mostrar en una función:

+ +
function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Show Popup';
+
+console.log(popup.displayName); // "Show Popup"
+
+ +

Tu puedes definir una funcion con un nombre a mostrar en un {{jsxref("Functions", "function expression", "", 1)}}:

+ +
var object = {
+  someMethod: function() {}
+};
+
+object.someMethod.displayName = 'someMethod';
+
+console.log(object.someMethod.displayName); // logs "someMethod"
+
+try { someMethod } catch(e) { console.log(e); }
+// ReferenceError: someMethod is not defined
+
+ +

Puedes cambiar dinámicamente el displayName de una función:

+ +
var object = {
+  // anonymous
+  someMethod: function(value) {
+    arguments.callee.displayName = 'someMethod (' + value + ')';
+  }
+};
+
+console.log(object.someMethod.displayName); // "undefined"
+
+object.someMethod('123')
+console.log(object.someMethod.displayName); // "someMethod (123)"
+
+ +

Ejemplos

+ +

Normalmente, se prefiere por consolas y profilers sobre {{jsxref("Function.name", "func.name")}} a mostrar el nombre de una función.

+ +

Al ingresar lo siguiente en una consola, debería mostrarse como algo así como "function My Function()":

+ +
var a = function() {};
+a.displayName = 'My Function';
+
+a; // "function My Function()"
+ +

Specifications

+ +

Not part of any specification.

+ +

Browser compatibility

+ +
+ + +

{{Compat("javascript.builtins.Function.displayName")}}

+
+ +
 
diff --git a/files/es/web/javascript/reference/global_objects/function/function/index.html b/files/es/web/javascript/reference/global_objects/function/function/index.html new file mode 100644 index 0000000000..af4dff0361 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/function/index.html @@ -0,0 +1,92 @@ +--- +title: Function() constructor +slug: Web/JavaScript/Referencia/Objetos_globales/Function/Función +tags: + - Constructor + - Function + - JavaScript + - Referencia + - función +translation_of: Web/JavaScript/Reference/Global_Objects/Function/Function +--- +
{{JSRef("Objetos_globales", "Function")}}
+ +

El 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 {{jsxref("eval")}}. Sin embargo, a diferencia de eval, el constructor Function crea funciones que solo se ejecutan en el ámbito global.

+ +
{{EmbedInteractiveExample("pages/js/function-constructor.html","shorter")}}
+ + + +

Sintaxis

+ +
new Function([arg1 [, arg2 [, ...argN]] ,] functionBody)
+ +

Parámetros

+ +
+
arg1, arg2, ... argN
+
Nombres que utilizará la función como nombres de argumentos formales. Cada uno debe ser una cadena que corresponda a un identificador JavaScript válido, o una lista de dichas cadenas separadas por una coma. Por ejemplo: "x", "theValue" —o "x,theValue".
+
functionBody
+
Una cadena que contiene las declaraciones de JavaScript que comprenden la definición de función.
+
+ +

Descripción

+ +

Los objetos Function creados con el constructor Function se procesan cuando se crea la función. Esto es menos eficiente que declarar una función con una {{jsxref("Operators/function", "expresión de función")}} o {{jsxref("Statements/function", "declaración de función")}} y llamarla dentro de tu código porque tales funciones se procesan con el resto del código.

+ +

Todos los argumentos pasados a la función se tratan como los nombres de los identificadores de los parámetros en la función que se va a crear, en el orden en que se pasan. Omitir un argumento dará como resultado que el valor de ese parámetro sea undefined.

+ +

Invocar el constructor Function como función (sin usar el operador new) tiene el mismo efecto que invocarlo como constructor.

+ +

Ejemplos

+ +

Especificar argumentos con el constructor Function

+ +

El siguiente código crea un objeto Function que toma dos argumentos.

+ +
// El ejemplo se puede ejecutar directamente en tu consola JavaScript
+
+// Crea una función que toma dos argumentos y devuelve la suma de esos argumentos
+const adder = new Function('a', 'b', 'return a + b');
+
+// Llama a la función
+adder(2, 6);
+// 8
+
+ +

Los argumentos "a" y "b" son nombres de argumentos formales que se utilizan en el cuerpo de la función, "return a + b".

+ +

Especificaciones

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-function-constructor', 'Constructor Function')}}
+ +

Compatibilidad del navegador

+ +
+ + +

{{Compat("javascript.builtins.Function.Function")}}

+
+ +

Ve también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/index.html b/files/es/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..5b586f3611 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,118 @@ +--- +title: Function +slug: Web/JavaScript/Referencia/Objetos_globales/Function +tags: + - Clase + - Class + - Declaración + - Expresión + - Function + - JavaScript + - función +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +
{{JSRef("Objetos_globales", "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

+ +
+
{{jsxref("Function/Function", "Function()", "", 1)}}
+
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 {{jsxref("eval")}}. Sin embargo, a diferencia de eval, el constructor Function crea funciones que solo se ejecutan en el ámbito global.
+
+ +

Propiedades de la instancia

+ +
+
{{jsxref("Function.arguments")}}
+
Un arreglo que corresponde a los argumentos pasados a una función.
+ Esto está obsoleto como propiedad de {{jsxref("Function")}}. En su lugar, utiliza el objeto {{jsxref("Functions/arguments", "arguments", "", 1)}} (disponible dentro de la función).
+
{{jsxref("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.
+
{{jsxref("Function.displayName")}}
+
El nombre a mostrar de la función.
+
{{jsxref("Function.length")}}
+
Especifica el número de argumentos que espera la función.
+
{{jsxref("Function.name")}}
+
El nombre de la función.
+
+ +

Métodos de instancia

+ +
+
{{jsxref("Function.prototype.apply()", "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 {{jsxref("Array")}}.
+
{{jsxref("Function.prototype.bind()", "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.
+
{{jsxref("Function.prototype.call()", "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.
+
{{jsxref("Function.prototype.toString()", "Function.prototype.toString()")}}
+
Devuelve una cadena que representa el código fuente de la función.
+ Redefine el método {{jsxref("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 {{jsxref("eval")}} con código para una expresión de función.

+ +
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

+ + + + + + + + + + + + +
Especificación
{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}
+ +

Compatibilidad del navegador

+ +
+ + +

{{Compat("javascript.builtins.Function")}}

+
+ +

Ve también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/length/index.html b/files/es/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..7638859bba --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,151 @@ +--- +title: Function.length +slug: Web/JavaScript/Referencia/Objetos_globales/Function/length +tags: + - JavaScript + - Propiedad + - función +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +
{{JSRef("Global_Objects", "Function")}}
+ +

Sumario

+ +

La propiedad length especifica el número de argumentos esperados por la función.

+ +
{{js_property_attributes(0,0,1)}}
+ +

Descripción

+ +

length es la propiedad de una función objeto, e indica el número de argumentos que una función requiere, por ejemplo, el número de parámetros formales. Este número no incluye {{jsxref("rest_parameters", "rest parameter", "", 1)}}. En cambio, {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} es local a una función y aporta el número de argumentos actuales pasados a una función.

+ +

Propiedades de la Función constructora

+ +

El {{jsxref("Global_Objects/Function", "Function")}} constructor en sí mismo es {{jsxref("Global_Objects/Function", "Function")}} un objeto. Sú propiedad length tiene el valor 1. Los atributos son: Grabable: false, Enumerable: false, Configurable: true.

+ +

Propiedad de la  Función prototype object

+ +

La propiedad length del {{jsxref("Global_Objects/Function", "Function")}} objeto prototype tiene el valor 0.

+ +

Ejemplos

+ +
console.log(Function.length); /* 1 */
+
+console.log((function()        {}).length); /* 0 */
+console.log((function(a)       {}).length); /* 1 */
+console.log((function(a, b)    {}).length); /* 2 etc. */
+console.log((function(...args) {}).length); /* 0, resto de parámetros no se contemplan */
+console.log((function(a, b = 1, c) {}).length); /* 1, solo parámetros antes del primero con un valor por defecto son contados */
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentario
ECMAScript 1st Edition.StandardDefinición inicial. Implementado en JavaScript 1.1.
length property of the {{jsxref("Global_Objects/Function", "Function")}} constructor:
+ {{SpecName('ES5.1', '#sec-15.3.3.2', 'Function.length')}}
+ length property of the {{jsxref("Global_Objects/Function", "Function")}} prototype object:
+ {{SpecName('ES5.1', '#sec-properties-of-the-function-prototype-object', 'Function.length')}}
+ length property of {{jsxref("Global_Objects/Function", "Function")}} instances:
+ {{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}		{{Spec2('ES5.1')}}
length property of the {{jsxref("Global_Objects/Function", "Function")}} constructor:
+ {{SpecName('ES6', '#sec-function.length', 'Function.length')}}
+ length property of the {{jsxref("Global_Objects/Function", "Function")}} prototype object:
+ {{SpecName('ES6', '#sec-15.3.4', 'Function.length')}}
+ length property of {{jsxref("Global_Objects/Function", "Function")}} instances:
+ {{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}		{{Spec2('ES6')}}El atributo configurable de esta propiedad ahora es true.
+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatUnknown}}{{CompatGeckoDesktop(37)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(37)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/name/index.html b/files/es/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..2440bd60f1 --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,223 @@ +--- +title: Function.name +slug: Web/JavaScript/Referencia/Objetos_globales/Function/name +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +
{{JSRef}}
+ +

La propiedad function.name retorna el nombre de la función o retorna "anonymous" por funciones creadas anónimamente.

+ +
{{js_property_attributes(0,0,1)}}
+ +
Nótese que en implementaciones no estándar previas a ES2015 el atributo configurable también era false.
+ +

Ejemplos

+ +

Nombre de una declaración de función

+ +

La propiedad name retorna el nombre de una declaración de función.

+ +
function doSomething() {}
+
+console.log(doSomething.name); // imprime en pantalla "doSomething"
+
+ +

Nombre de constructor de función

+ +

Las funciones creadas con la sintaxis new Function(...) o simplemente Function(...) tienen como propiedad name una cadena vacía. En los ejemplos a continuación se crean funciones anónimas, tales que su name retorna una cadena vacía:

+ +
var f = function() {};
+var object = {
+  someMethod: function() {}
+};
+
+console.log(f.name == ''); // true
+console.log(object.someMethod.name == ''); // también true
+
+ +

Nombres de función inferidos

+ +

Los navegadores que implementan funciones ES2015 pueden inferir el nombre de una función anónima de su posición sintáctica. Por ejemplo:

+ +
var f = function() {};
+console.log(f.name); // "f"
+ +

Se puede definir una función con un nombre en un {{jsxref("Operators/Function", "function expression", "", 1)}}:

+ +
var object = {
+  someMethod: function object_someMethod() {}
+};
+console.log(object.someMethod.name); // imprime "object_someMethod"
+
+try { object_someMethod } catch(e) { console.log(e); }
+// ReferenceError: object_someMethod is not defined
+
+ +

No se puede cambiar el nombre de una función, esta propiedad es de solo lectura:

+ +
var object = {
+  // anonymous
+  someMethod: function() {}
+};
+
+object.someMethod.name = 'someMethod';
+console.log(object.someMethod.name); // cadena vacía, someMethod es anónimo
+
+ +

Sin embargo, se puede usar {{jsxref("Object.defineProperty()")}} para cambiarlo.

+ +

Nombres de métodos

+ +
var o = {
+  foo(){}
+};
+o.foo.name; // "foo";
+ +

Nombres de funciones atadas (creadas con .bind())

+ +

{{jsxref("Function.bind()")}} produce una función cuyo nombre es igual a "bound " seguido del nombre de la función original.

+ +
function foo() {};
+foo.bind({}).name; // "bound foo"
+ +

Nombres de funciones getters y setters

+ +

Cuando se usan get y set, "get" y "set" aparecerán en el nombre de la función.

+ +
var o = {
+  get foo(){},
+  set foo(x){}
+};
+
+var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
+descriptor.get.name; // "get foo"
+descriptor.set.name; // "set foo";
+ +

Ejemplos

+ +

Se puede usar obj.constructor.name para saber cuál es la "clase" de un objeto:

+ +
function a() {}
+
+var b = new a();
+
+console.log(b.constructor.name); // imprime "a"
+
+ +

Polyfill

+ +

Para versiones de IE < 9, se puede usar fn._name() en su lugar. Para IE9 o posteriores se puede usar el siguiente polyfill.

+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoComentarios
{{SpecName('ES2015', '#sec-name', 'name')}}{{Spec2('ES2015')}}Definición inicial.
{{SpecName('ESDraft', '#sec-name', 'name')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatChrome(33.0)}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatChrome(43.0)}}{{CompatGeckoDesktop(38)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Nombres inferidos en funciones anónimas{{CompatChrome(51.0)}}{{CompatNo}} [1]{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CaracterísticaAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatNo}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
Configurable: true{{CompatUnknown}}{{CompatUnknown}}{{CompatGeckoMobile(38)}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
Nombres inferidos en funciones anónimas{{CompatNo}}{{CompatChrome(51.0)}}{{CompatNo}} [1]{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatChrome(51.0)}}
+
+ +

[1] See {{bug(883377)}}.

diff --git a/files/es/web/javascript/reference/global_objects/function/tosource/index.html b/files/es/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..3cee3c1d4c --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,97 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Referencia/Objetos_globales/Function/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +
{{JSRef}} {{non-standard_header}}
+ +

El método toSource() devuelve un string representando el código fuente del objeto.

+ +

Sintaxis

+ +
function.toSource();
+Function.toSource();
+
+ +

Parámetros

+ +

Ninguno.

+ +

Descripción

+ +

El método toSource devuelve los siguientes valores:

+ + + +

Éste método es usado de forma interna por JavaScript y no explicitamente desde el código. Puedes usar toSource mientras depuras para examinar el contenido de un objeto.

+ +

Especificaciones

+ +

No está reflejado en ningún estándar. Implementaso en JavaScript 1.3.

+ +

Browser compatibility

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support{{CompatNo}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Basic support{{CompatUnknown}}{{CompatUnknown}}{{CompatVersionUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +

Ver también

+ + diff --git a/files/es/web/javascript/reference/global_objects/function/tostring/index.html b/files/es/web/javascript/reference/global_objects/function/tostring/index.html new file mode 100644 index 0000000000..b5ee70147e --- /dev/null +++ b/files/es/web/javascript/reference/global_objects/function/tostring/index.html @@ -0,0 +1,130 @@ +--- +title: Function.prototype.toString() +slug: Web/JavaScript/Referencia/Objetos_globales/Function/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString +--- +
{{JSRef}}
+ +

El método toString() retorna una cadena representando el código fuente de la función.

+ +

Sintaxis

+ +
function.toString(indentation)
+ +

Parámetros

+ +
+
indentation {{non-standard_inline}} {{obsolete_inline(17)}}
+
La cantidad de espacios a indentar en la representación de cadena del código fuente. Si indentation es menor o igual a -1, la mayoría de los espacios innecesarios son eliminados.
+
+ +

Descripción

+ +

El objeto {{jsxref("Function")}} reconduce el método {{jsxref("Object.prototype.toString", "toString")}} heredado de  {{jsxref("Object")}}; no hereda {{jsxref("Object.prototype.toString")}}. Para objetos {{jsxref("Function")}}, el método toString retorna una representación de cadena del objeto en forma de declaración de función. Esto es, toString descompila la función y la cadena retornada incluye la palabra clave function, la lista de argumentos, llaves y el código fuente del cuerpo de la función.

+ +

JavaScript llama al método toString automáticamente cuando una {{jsxref("Function")}} va a ser representada como un valor de texto, p.e. cuando una función es concatenada con un valor de cadena (string).

+ +

El método toString() producirá una excepción {{jsxref("TypeError")}} ("Function.prototype.toString called on incompatible object"), si el valor de su objeto this no es un objeto Function. Esto también ocurrirá para objetos {{jsxref("Proxy")}}, por ejemplo:

+ +
Function.prototype.toString.call("foo"); // TypeError
+
+var proxy = new Proxy(function() {}, {});
+Function.prototype.toString.call(proxy); // TypeError
+
+ +

Especificaciones

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
EspecificaciónEstadoObservaciones
{{SpecName('ES1')}}{{Spec2('ES1')}}Definición inicial. Implementado en JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.3.4.2', 'Function.prototype.toString')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ES6')}}Añadidos requerimientos más específicos para la representación de cadena.
{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}{{Spec2('ESDraft')}} 
+ +

Compatibilidad con navegadores

+ +
{{CompatibilityTable}}
+ +
+ + + + + + + + + + + + + + + + + + + +
PrestaciónChromeFirefox (Gecko)Internet ExplorerOperaSafari
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +
PrestaciónAndroidChrome for AndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari Mobile
Soporte básico{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

Notas específicas para Gecko

+ + + +

Ver también

+ + -- cgit v1.2.3-54-g00ecf