inside - variable de clase en Javascript

javascript class w3schools

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 usar este enfoque.

function Person(){

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

Answer 1

3 formas de definir una variable para la clase de JavaScript:

1) Para definir las propiedades creadas usando la función (), use la palabra clave ''this''

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

Para crear una instancia de un objeto de la clase Apple, establezca algunas propiedades, puede hacer lo siguiente:

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

2) Usando la notación literal

var manzana = {
tipo: "macintosh",
color rojo"

}

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

apple.color = "reddish";

3) Singleton usando una función

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

Entonces ves que esto es muy similar al 1 descrito anteriormente, pero la forma de usar el objeto es exactamente como en 2.

apple.color = "reddish";

Answer 2

Es importante comprender que no existe tal cosa como las clases en JavaScript. Existen algunos marcos que simulan un patrón de herencia clásico, pero técnicamente todo se reduce a funciones y prototipos de constructores .

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, conecta el constructor al prototipo:

Person.prototype = PersonProto;

Y voilá:

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

Answer 3

JavaScript no tiene clases como otras han dicho. La herencia se resuelve mediante la creación de prototipos que, en esencia, no hace más que crear referencias de propiedad que no se pueden eliminar 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 debe 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!"''

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

más sobre esto

Usar this referencia en una función de constructor es extremadamente importante si desea agregar propiedades a la instancia actual. Sin usar this , solo creas una variable (que no es lo mismo que una propiedad) y como se mencionó, si tampoco usas la declaración var, creas 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!

¡Utilizar esta!

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

Tenga en cuenta que todo lo asignado a una instancia a través del constructor de funciones NO PUEDE SER HEREDADO a menos que lo asigne al prototipo y lo sobrescriba nuevamente en el constructor de funciones para convertirlo en una propiedad de su propiedad.

Cuando crea una nueva instancia de a través de una función que se duplica 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 cada lenguaje clásico cuando creas una instancia de una clase. Pero la principal diferencia en JavaScript es que no está encapsulado dentro de una declaración de clase agradable. Originalmente, JavaScript ni siquiera tenía constructores de funciones, pero se agregó más tarde porque SUN exigió que quisieran que JavaScript se pareciera más a Java.

Literales de objeto

La alternativa para los constructores de funciones para objetos que solo llevan datos intrínsecos y ningún método son literales de objetos.

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 los literales de objetos en su conjunto de habilidades, puede crear un patrón de fábrica para objetos de datos intrínsecos usando el patrón de módulo (que generalmente es 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 utilizar 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 preferirse.

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 preferirse esto? Debido a que mantiene sus objetos minuciosos y legibles, incluso las referencias prototípicas ocupan memoria y, al utilizar la herencia y las "subclases", obtiene instancias secundarias que tienen muchas referencias de métodos no utilizados. La delegación siempre es mejor.

Answer 4

La forma en que mencionó es cómo definir las variables de clase, la otra forma (dentro de la function Person ) es definir las propiedades de la 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 5

También puedes 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");

Answer 6

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 puedo pensar en un mejor ejemplo.