ti-enxame.com

variável de classe em Javascript

Como faço para declarar variáveis ​​de classe em Javascript.

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

Eu não quero usar essa abordagem.

function Person(){

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

JavaScript não tem classes como outras pessoas disseram. A herança é resolvida por meio de protótipos que, em essência, nada mais fazem do que criar referências de propriedade não deletáveis ​​em um objeto recém-criado. O JavaScript também tem alternativas para objetos de dados simples, ou seja, literais de objeto.

A variação de uma 'Classe' em JavaScript deve ser definida 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!"'

A referência this sempre aponta para o dono da function. Se você chamar Person sem o operador new, o proprietário será o escopo global (janela). Se você não usar essa referência para atribuir propriedades à sua instância, as propriedades serão simplesmente declaradas como variáveis. Se você não usar a instrução var, essas declarações criarão variáveis ​​globais que são ruins!

mais sobre isso

Usar a referência this em uma função de construtor é extremamente importante se você quiser adicionar propriedades à instância atual. Sem usar this, você cria apenas uma variável (que não é o mesmo que uma propriedade) e, como mencionado, se você também não usa a instrução var, você cria variáveis ​​globais.

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!

Usa isto!

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

Note que qualquer coisa atribuída a uma instância através do construtor da função CANNOT BE INHERITED, a menos que você a atribua ao protótipo e sobrescreva-a novamente no construtor da função para torná-la uma propriedade de propriedade.

Quando você cria uma nova instância através de uma função que duplica como um construtor, na verdade acontece o seguinte.

pseudo code:

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

Na verdade, é isso que acontece em todos os idiomas clássicos quando você cria uma instância de uma classe. Mas a principal diferença no JavaScript é que ele não é encapsulado dentro de uma instrução de classe agradável. Originalmente, JavaScript nem sequer tinha construtores de função, mas foi adicionado mais tarde porque a Sun exigia que eles quisessem que o JavaScript fosse mais parecido com Java.

Objetos literais

A alternativa para construtores de função para objetos que transportam apenas dados intrínsecos e nenhum método são literais de objeto.

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

Qual é a maneira preferida de declarar objetos intrínsecos ao invés de:

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

Com os literais de objeto em seu conjunto de habilidades, você pode criar um padrão de fábrica para objetos de dados intrínsecos usando o padrão de módulo (que normalmente é para singletons).

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

Isso alcança algum encapsulamento confortável, mas só pode ser usado para objetos de dados intrínsecos.

Outra coisa que você pode fazer com objetos literais e JavaScript é delegação, que deve ser 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 que isso deveria ser preferido? Como ele mantém seus objetos minúsculos e legíveis, até mesmo referências prototípicas ocupam memória e, ao usar herança e 'subclassificação', você acaba tendo instâncias filho com muitas referências de métodos não utilizadas. Delegação é sempre melhor.

36
BGerrissen

A maneira que você mencionou é como definir variáveis ​​de classe, a outra maneira (dentro de function Person) é definir as propriedades da instância.

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.
9
aularon

É importante entender que não existem classes em JavaScript. Existem alguns frameworks que simulam um padrão de herança clássico, mas tecnicamente tudo se resume a funções construtoras e protótipos .

Então, você pode querer fazer algo como

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

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

Agora, conecte o construtor ao protótipo:

Person.prototype = PersonProto;

E voilà:

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

Você também pode tentar esta abordagem:

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

        }
        var x = new name();
        x.firstName("Kartikeya");
0
Kartikeya Sharma
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"

Não consigo pensar em melhor exemplo.

0
simplyharsh

3 maneiras de definir uma variável para a classe JavaScript:

1) Para definir propriedades criadas usando function (), use a palavra-chave 'this'

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

Para instanciar um objeto da classe Apple, defina algumas propriedades que você pode fazer o seguinte:

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

2) Usando Notação Literal

var Apple = {
tipo: "Macintosh",
cor vermelha"

}

Neste caso você não precisa (e não pode) criar uma instância da classe, ela já existe.

Apple.color = "reddish";

3) Singleton usando uma função

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

Então você vê que isso é muito semelhante ao discutido acima, mas a maneira de usar o objeto é exatamente como em 2.

Apple.color = "reddish";
0
sweets-BlingBling