variable de clase en Javascript

Question

Cómo declaro las variables de clase en Javascript.

function Person(){ 
    fname = "thisfname"; //What needs to be put here 
} 
alert(Person.fname) //It should alert "thisFrame" 

No quiero utilizar este enfoque.

function Person(){ 

} 
Person.fname = "thisfname"; 
alert(Person.fname) //alerts "thisframe" 

Answer 1

La forma en que usted ha mencionado es cómo definir las variables de clase, a la inversa (en el interior function Person) es definir las propiedades de instancia.

function Person(name){ 
    this.name = name; 
} 
Person.specie = "Human"; 

alert(Person.specie) //alerts "Human", a class variable. 

var john = new Person('John'); 
alert(john.name); //alerts "John", an object property. 

Answer 2

function Person(){ 
    this.fname = null; 
    this.lname = null; 
    this.set_fname = set_fname; 
    this.set_lname = set_lname; 
    this.get_name = get_name; 
} 
/* Another way 
function Person(fname, lname){ 
    this.fname = fname; 
    this.lname = lname; 
    this.get_name = get_name; 
}*/ 
function set_fname(fname){ 
    this.fname = fname; 
} 
function set_lname(y){ 
    this.lname = lname; 
} 
function get_name(){ 
    with (this) { 
     return fname + ' ' + lname; 
    } 
} 

person_obj = new Person(); 
person_obj.set_fname('Foo'); 
person_obj.set_lname('Bar'); 

// person_obj = new Person('Foo', 'Bar'); 

person_obj = get_name(); // returns "Foo Bar" 

No se puede pensar en un mejor ejemplo.

Answer 3

3 maneras de definir unas variables en clase de JavaScript:

1) Para definir las propiedades creadas mediante una función(), se utiliza el 'esto' palabra clave

function Apple (type) { 
    this.type = type; 
    this.color = "red"; 
} 

Para crear una instancia de un objeto de la manzana clase, establecer algunas propiedades que puede hacer lo siguiente:

var apple = new Apple('macintosh'); 
apple.color = "reddish"; 

2) Utilizando notación literal de

var manzana = {
tipo: "Macintosh",
de color: "rojo"

}

En este caso no es necesario (y no puede) crear una instancia de la clase, ya existe.

apple.color = "reddish"; 

3) Singleton utilizando una función

var apple = new function() { 
    this.type = "macintosh"; 
    this.color = "red"; 
} 

por lo que ver que esto es muy similar a la 1 se discutió anteriormente, pero la manera de utilizar el objeto es exactamente como en 2.

apple.color = "reddish"; 

Answer 4

Es importante entender que no existen las clases en JavaScript. Hay algunos marcos que simulan un patrón de herencia clásico, pero técnicamente todo se reduce a constructor functions and prototypes.

Por lo tanto, es posible que desee hacer algo como

PersonProto = { // the "class", or prototype 
    fname: "thisfname" 
}; 

function Person() { // the constructor function 
    this.instanceVar = 'foo'; 
} 

Ahora, conecte el constructor para el prototipo:

Person.prototype = PersonProto; 

Y voilà:

var a = new Person(); 
alert(a.fname); 

Answer 5

JavaScript no hace tener clases como otros han dicho. La herencia se resuelve a través de la creación de prototipos que, en esencia, no hace más que crear referencias de propiedades no eliminables en un objeto recién creado. JavaScript también tiene alternativas para objetos de datos simples, a saber, literales de objetos.

la variación de una 'clase' en JavaScript debería definirse como tal:

// I use function statements over variable declaration 
// when a constructor is involved. 
function Person(name) { 
    this.name = name; 
} 

// All instances of Person create reference methods to it's prototype. 
// These references are not deletable (but they can be overwritten). 
Person.prototype = { 
    speak: function(){ 
     alert(this.name + ' says: "Hello world!"'); 
    } 
}; 

var Mary = new Person('Mary'); 
Mary.speak(); // alerts 'Mary says: "Hello world!"' 

La referencia this siempre apunta a la titular de la function. Si llama al Person sin el operador new, el propietario será el alcance global (ventana). Si no utiliza esta referencia para asignar propiedades a su instancia, entonces las propiedades simplemente se declararán como variables. Si no usa la instrucción var, esas declaraciones crearán variables globales que son malas.

más sobre este

Utilizando la referencia this en una función constructora es muy importante si desea agregar propiedades a la instancia actual. Sin usar this, solo crea una variable (que no es lo mismo que una propiedad) y como se mencionó, si no usa la instrucción var tampoco, crea variables globales.

function Person(){ 
    name = 'Mary' 
} 
var p = new Person(); 
alert(p.name); // undefined, did not use 'this' to assign it to the instance. 
alert(name); // 'Mary', boo, it created a global variable! 

¡Utilice esto!

function Person(){ 
    this.name = 'Mary' 
} 
var p = new Person(); 
alert(p.name); // 'Mary', yay! 
alert(name); // undefined, yay! 

Nota, nada asignado a una instancia a través del constructor función no se puede heredar menos que la asigne al prototipo y sobrescribir de nuevo en el constructor de la función para que sea una propiedad de propiedad.

Cuando crea una nueva instancia a través de una función que se dobla como un constructor, en realidad sucede lo siguiente.

pseudo code: 

    copy Person.prototype as person 
    invoke Person function on person 
    return person 

En realidad, esto es lo que sucede en todos los lenguajes clásicos cuando se crea una instancia de una clase. Pero la principal diferencia en JavaScript es que no está encapsulado dentro de una buena declaración de clase. Originalmente, JavaScript ni siquiera tenía constructores de funciones, pero se agregó más tarde porque SUN exigía que desearan que JavaScript se pareciese más a Java.

literales de objetos

La alternativa para los constructores de función para los objetos que llevan sólo los datos intrínsecos y no hay métodos son objetos literales.

var Mary = { 
    firstName: 'Mary', 
    lastName: 'Littlelamb' 
}; 

Cuál es la forma preferida de declarar objetos intrínsecos en lugar de:

// do not ever do this! 
var Mary = new Object(); 
Mary.firstName = 'Mary'; 
Mary.lastName = 'Littlelamb'; 

con literales de objetos en el conjunto de habilidades, puede crear un patrón de fábrica para los objetos de datos intrínsecos utilizando el module pattern (que es generalmente para singletons).

var createPerson = function(firstName, lastName){ 
    return { 
     firstName: firstName, 
     lastName: lastName 
    } 
} 
var Mary = createPerson('Mary', 'Littlelamb'); 

Esto logra una encapsulación cómoda, pero solo se puede usar para objetos de datos intrínsecos.

Otra cosa que puedes hacer con los literales de objetos y JavaScript es la delegación, que debería ser la preferida.

var personMethods = { 
    speak: function(){ 
     alert(this.firstName + ' says: "Hello world!"'); 
    } 
}; 

var Mary = { 
    firstName: "Mary", 
    lastName: "Littlelamb" 
}; 

var Peter = { 
    firstName: "Peter", 
    lastName: "Crieswolf" 
}; 

personMethods.speak.apply(Mary); // alerts 'Mary says: "Hello world!"' 
personMethods.speak.apply(Peter); // alerts 'Peter says: "Hello world!"' 

¿Por qué debería ser esto preferido?Debido a que mantiene sus objetos al minuto y legibles, incluso las referencias prototípicas ocupan memoria y al usar herencia y 'subclases' terminan con instancias hijo que tienen muchas referencias de métodos no utilizados. La delegación siempre es mejor.

Answer 6

También puede probar este enfoque:

 function name(){ 
      this.name; 
      this.lastname; 
     } 
     name.prototype.firstName=function(name){ 
      this.name = name; 
      alert(this.name); 

     } 
     var x = new name(); 
     x.firstName("Kartikeya");