que - Objetos y funciones en javascript

javascript cheat sheet pdf

Question

Posible duplicado:
Javascript: ¿Necesito poner this.var para cada variable en un objeto?

Estoy luchando para entender las funciones y objetos en javascript. Se dice que también las funciones son objetos y los objetos son una especie de "matrices asociativas", es decir, colecciones de pares clave-valor. Entiendo que si escribo

function myFunction() {
    var value = 0;
}
alert(myFunction.value); //then this gives me "undefined"

Porque las variables tienen función de alcance. Pero si escribo

function myFunction() {
    this.value = 0;
}
alert(myFunction.value); //then this gives me "undefined" too.

Pero finalmente, si escribo.

function myFunction() {
    this.value = 0;
}
myFunction.value = 0;
alert(myFunction.value); //then this gives me 0

Así que puedo dar a mi propiedad de Función "valor" pero desde "afuera". ¿Alguien puede explicar qué está pasando y por qué esto.valor = 0; no crea propiedad "valor".

Answer 1

En javascript, cualquier función es también un objeto, son objetos de Function , como Number, Object, Array

Una cosa difícil es la new palabra, luego prefija a una función, crea un nuevo objeto y hace que la palabra clave apunte a ese nuevo objeto (una más, asigna ese prototipo de función al nuevo objeto __ proto __).
En función,

this.value = 0;

crearía un nuevo value propiedad para el nuevo objeto y le asignaría un 0.

Si no hay una función new antes, es llamada de función, y this apuntará al objeto de Ventana .

Trate de console.dir(this); En la función, verás la diferencia.

myFunction.value = 0;

crearía un value propiedad para myFunction y le asignaría un 0. Porque myFunction es solo un objeto (de Function ).

Answer 2

Necesitas crear una instance usando la nueva palabra clave.

function myFunction() {
    this.value = 0;
}

var inst1 = new myFunction();

alert(inst1.value);  // this works

Ahora esto corresponde al objeto actual, y obtiene el valor correspondiente de la propiedad.

Compruebe Fiddle

Al final del día, las funciones aún son objetos . Por lo tanto, no se queja cuando asigna myFunction.value = 0 Puede ser confuso ya que está utilizando el valor (clave) tanto dentro como fuera de la función. Reemplazar esto con

myFunction.abc = ''Hello'' 
alert(myFunction.abc) still works

Pero no se reflejará dentro de mi función real, ya que aún no ha llamado a la función.

Answer 3

No estoy seguro de poder aclararte todos los matices, pero esto puede arrojar algo de luz:

function myFunction() {
    this.value = 0;
}
alert( (new myFunction).value);

El uso de la new palabra clave crea una nueva ''instancia'' de myFunction permitiendo que se use para asignar un valor desde dentro de la función.

Answer 4

Usted malentendió los conceptos de prototipo / objeto javascript.

Para el primer ejemplo que tiene razón, la variable tiene un alcance de función

El segundo ejemplo es incorrecto. Si desea utilizar una función como ''clase'', debe crear un objeto a partir de ella.

function myFunction() { this.value = 0; }
var test = new myFunction;

Sólo entonces puede acceder a la propiedad ''valor'' de la misma. para cada declaración ''nueva'' se crea un nuevo objeto.

En el tercer ejemplo, agrega una propiedad estática a la función a la que se puede acceder sin crear un objeto. Técnica diferente que es

Espero que haya ayudado

Answer 5

Veamos los tres casos individualmente:

function myFunction()
{
    var value = 0;
}

Aquí, estás declarando una variable en el alcance de la función. Cada vez que se llama a la función, se creará la variable (y se asignará memoria). Cuando la función regresa, la variable queda fuera del alcance: el value la variable se marca y se marcará con la referencia de GC. No se puede acceder al alcance desde un alcance "superior" al alcance de esta función ... si esta función define una función dentro de su alcance, esa función tendrá acceso al value la variable (consulte los cierres para obtener más detalles). Línea inferior: la variable solo existe como cuando se llama a la función, y no existirá después de que la función regrese.

function myFunction()
{
    this.value = 0;
}

Aquí, está definiendo una función que podría ser un constructor, un método, un controlador de eventos o una combinación de todo lo anterior. this es una referencia que apuntará al contexto en el que se llama la función. Este contexto se determina "ad hoc" y puede variar:

myFunction();// global scope, this points to window
var anObject = {method: myFunction};
anObject.method();//called in the object''s context, this points to object
console.log(abObject.value);//logs 0
var instance = new myFunction();//as constructor
console.log(instance.value);//logs 0
document.getElementById(''anInputField'').onclick = myFunction;//on click, value will be set to 0

En el último caso:

function myFunction()
{
    this.value = 0;
}
myFunction.value = 0;

No habría hecho ninguna diferencia si hubieras escrito esto:

function myFunction()
{}
myFunction.value = 0;

Porque, como expliqué anteriormente: this referencia al contexto en el momento en que se llama a la función. Esto no tiene que ser mi myFunction , de hecho: la mayoría de las veces no será:

var anObject = {method: myFunction};
myFunction.value = 101;//myFunction.value is changed
anObject.method();
console.log(anObject.value);//0 -> the function still sets the value property to 0

Si desea acceder a las propiedades de una función dentro de esa función, la forma más sencilla es hacer referencia a esa función como cualquier otro objeto:

function myFunction()
{
    this.value = myFunction.value;
}
myFunction.value = 101;

Precaución:
Solo una advertencia amistosa: no es muy seguro usar this en funciones sin verificar los indicadores globales ... Si se llama a una función sin un contexto explícito, JS usa el objeto global ( window ) de forma predeterminada . Esto significa que cada línea que asigna una propiedad a cualquier objeto que esté apuntando también establecerá una variable global:

function myFunction()
{
    this.foo = ''bar'';
}
myFunction();
console.log(window.foo);//logs bar EVIL GLOBAL

Algunas formas de evitar que el objeto global se llene de objetos globales:

function mySafeFunction()
{
    ''use strict'';//throws errors, check MDN
    //this defaults to null, instead of window
    impliedGlobal = ''Error'';//doesn''t work
    this.onGlobal = ''Error'';//null.property doesn''t work
}
//same goes for constructors, but a more precise check can be used, too (and works on older browsers)
function SafeConstructor()
{
    if (!(this instanceof SafeConstructor))
    {//this doesn''t point to SafeConstructor if new keyword wasn''t used
        throw new Error(''Constructor wasn/'t called with new keyword'');
        //or "correct" the error:
        return new SafeConstructor();
    }
    console.log(this);// will always point to the SafeConstructor object
}

Answer 6

myFunction es un objeto de función . Puede pasarlo, asignarlo a variables, asignarle propiedades y puede llamarlo .

Asignar propiedades funciona como con cualquier otro objeto:

myFunction.value = 0;

Pero tenga en cuenta que en este punto, aún no ha llamado a la función, por lo que el código dentro de la función ( var value = 0; o this.value = 0; ) ni siquiera se ejecutó todavía. Considera esto:

function someFunction() {
    window.foo = ''foo''; // create a global variable
}

someFunction.bar = ''bar'';

console.log(someFunction.bar); // ''bar''
console.log(window.foo); // undefined

someFunction(); // execute the function

console.log(someFunction.bar); // ''bar''
console.log(window.foo); // ''foo''

Cuando ejecuta la función con myFunction() , solo entonces se crea la variable local / se establece una propiedad en this . A lo que se refiere this depende de cómo se llame a la función y se explica bien en la documentación de MDN . this nunca se refiere a la función en sí, a menos que la establezca explícitamente .