¿Qué significa "Object.call"?

Question

function bb_graphics_GraphicsContext(){ 
    Object.call(this); 
    this.bbdevice=null; 
    this.bbmatrixSp=0; 
    this.bbix=1.000000; 
    this.bbiy=0; 
    this.bbjx=0; 
    this.bbjy=1.000000; 
    this.bbtx=0; 
    this.bbty=0; 
    this.bbtformed=0; 
    this.bbmatDirty=0; 
    this.bbcolor_r=0; 
    this.bbcolor_g=0; 
    this.bbcolor_b=0; 
    this.bbalpha=0; 
    this.bbblend=0; 
    this.bbscissor_x=0; 
    this.bbscissor_y=0; 
    this.bbscissor_width=0; 
    this.bbscissor_height=0; 
    this.bbmatrixStack=new_number_array(192); 
} 

¿Qué significa Object.call(this)?

Answer 1

Cada función de JavaScript tiene un toString(), call() y apply().

Lea más sobre ellos en this odetocode.com article

Answer 2

Funciones en JavaScript son objetos de pleno derecho. También, cuando se pasan como argumento para otra función, no retienen su alcance. Así, en el siguiente código ...

var obj1 = { 
    property1: "blah", 
    method1: function() { 
     alert(this.property1); 
     // do stuff 
    } 
}; 

function func1 (passedFunction) { 
    passedFunction(); 
    // do other stuff 
} 

func1(obj1.method1); 

... func1 llamarán obj1.method1, pero no va a alert el valor de obj1 's property1, porque todo lo que hemos hecho es pasar el objeto función, no es su contexto this. Ahí es donde entran call y apply. Permiten inyectar alcance, decirle a la función cuál será el significado de this. El siguiente ejemplo funciona:

var obj1 = { 
    property1: "blah", 
    method1: function() { 
     alert(this.property1); 
     // do stuff 
    } 
}; 

function func1 (passedObject, passedFunction) { 
    passedFunction.call(passedObject); 
    // do other stuff 
} 

func1(ob1, obj1.method1); 

Ahora, hemos forzado o dice explícitamente obj1.method1 lo hará su contexto invocando call, y pasándole el objeto es para su uso como this.

call y apply son casi idénticos, excepto por cómo manejan argumentos adicionales a la función invocada. Consulte estos artículos en MDN para obtener más información: call, apply y Function.

Dicho todo esto, bb_graphics_GraphicsContext es un constructor. (Que probablemente haya adivinado). Invoquelo utilizando la palabra clave new, var obj1 = new bb_graphics_GraphicsContext();. Cuando alcanza la línea 1 de la función, toma el objeto this y llama al constructor genérico Object, que inyecta explícitamente el nuevo objeto this (en el constructor bb_graphics_GraphicsContext) como this del constructor Object. Supongo que el escritor de esta función/constructor estaba haciendo esto para asegurarse de que el objeto recién creado en bb_graphics_GraphicsContext obtenía todos los métodos básicos de la base Object. Pero no sé por qué sería necesario, como si llamara al bb_graphics_GraphicsContext con la palabra clave new, captará todas estas propiedades de forma natural.

Answer 3

Object.call ejecutará una determinada función en el contexto proporcionado, se puede usar para llamar funciones de un objeto a otro.

La red Mozilla dev proporciona una muy buena explicación

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/call

Answer 4

Esto va a hacer absolutamente nada más que perder la asignación de recursos y la memoria.

Si el Object.call (este) habrá sido asignado a una variable o propiedad de la función constructora bb_graphics_GraphicsContext

this.myObject = Objeto.llame al (este)

La única cosa que se ponga en esa instancia es un objeto vacío "QUE NO MANTENER el contexto que ofrece"

function MyConstructor(){ 
    this.test01 = 0; 
    var b = Object.call(this); // similar to b = {}; or b = new Object() 
    console.log(b); // log object 
    console.log(b.test); // log undefined 
    this.test = 1; 
} 

var myObject = new MyConstructor(); 

console.log(myObject, window.test01) 

Answer 5

Aunque Object.call probablemente no hará nada como se expresa aquí, el concepto puede ser importante. Básicamente, el ejemplo que usted verá en herencia en el Node.js es documentation:

const util = require('util'); 
const EventEmitter = require('events'); 

function MyStream() { 
    EventEmitter.call(this); 
} 

util.inherits(MyStream, EventEmitter); 

El util.inherits hará una nueva MyStream hereda (tiene el mismo prototipo) EventEmmiter. Esto podría ser suficiente si estamos interesados ​​en que MyStream tenga acceso a las funciones heredadas a través del prototipo EventEmmiter. Pero, ¿y si hay variables pasadas en la construcción? ¿Qué pasa si tenemos:

function MyObject() { 
    this.code = "2nV_ahR"; 
} 

En este caso, la variable code se pasa el tiempo de ejecución cuando MyObject consigue instanciado. Por lo tanto, una subclase tiene que pasar:

function MySubObject() { 
    MyObject.call(this); 
} 

Con el fin de heredar la variable code. Lo que call acepta un parámetro que establece la variable this. Así que cuando lo haga ... var o = new MySubObject(), la this interior de MySubObject se refiere a o, que se pasa a continuación al método call, de modo que cuando MyObject hace this.code = ... en realidad está pasando el code a o!