variable de classe en Javascript

JavaScript n'ayant pas de classes, comme d'autres l'ont dit. L'héritage est résolu par le biais de prototypage qui par essence ne fait rien de plus que de créer non supprimables références de propriété sur un objet nouvellement créé. JavaScript a aussi des alternatives pour de simples objets de données, à savoir l'objet de littéraux.

La variation d'une "Classe" en JavaScript doit être définie en tant que telle:

//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 this de référence indique toujours le propriétaire de la function. Si vous appelez Person sans new exploitant, le propriétaire sera la portée globale (fenêtre). Si vous n'utilisez pas cette référence à attribuer des propriétés à votre exemple, les propriétés seront tout simplement être déclarés comme des variables. Si vous n'utilisez pas le var déclaration, ces déclarations vont créer des variables globales qui sont mauvais!

plus sur ce

À l'aide de la this référence à une fonction constructeur est extrêmement important si vous souhaitez ajouter des propriétés à l'instance en cours. Sans l'aide de this, vous ne créez une variable (ce qui n'est pas le même que d'un bien) et comme mentionné, si vous n'utilisez pas l'instruction var soit, vous créer des 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!

D'utiliser cette!

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

Remarque, rien attribuée à une instance par le biais de la fonction constructeur NE peut pas ÊTRE HÉRITÉE, à moins que vous l'affectez à le prototype et l'écraser à nouveau dans la fonction constructeur pour en faire une propriété.

Lorsque vous créez une nouvelle instance d'une fonction doublement en tant que constructeur, en fait, la suite se passe.

pseudo code:

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

En fait, c'est ce qui se passe dans chaque langue classique lorsque vous créez une instance d'une classe. Mais la principale différence en JavaScript, c'est qu'il n'est pas encapsulé dans une belle déclaration de Classe. À l'origine, le JavaScript n'ai même pas de fonction des constructeurs, mais a été ajouté plus tard, parce que le SOLEIL a exigé qu'ils voulaient JavaScript pour être plus comme Java.

Objet littéraux

L'alternative pour fonction de constructeurs pour des objets qui portent seulement intrinsèque des données et pas de méthodes sont des littéraux d'objet.

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

Qui est le préféré façon de déclarer des objets intrinsèques plutôt:

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

Avec des littéraux d'objet dans l'ensemble de vos compétences, vous pouvez créer un modèle de fabrique pour les données intrinsèques des objets à l'aide de la motif de module (qui est en général pour les singletons).

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

Cela permet d'obtenir certains à l'aise d'encapsulation, mais ne peut être utilisé pour les données intrinsèques des objets.

Une autre chose que vous pouvez faire avec les Objets littéraux et JavaScript est la délégation, qui doit être privilégié.

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!"'

Pourquoi faudrait-il privilégier? Parce qu'il garde vos objets minutes et lisible, même prototype de références de prendre de la mémoire et lors de l'utilisation de l'héritage et de "sous-classement' vous vous retrouvez avec les instances enfant qui a beaucoup de inutilisés méthode de référence. Délégation est toujours la meilleure.

Il est important de comprendre qu'il n'y a pas une telle chose comme des classes en JavaScript. Il y a quelques cadres qui simulent un classique de motif d'héritage, mais techniquement, cela revient à constructeur de fonctions et de prototypes.

Donc, vous voudrez peut-être faire quelque chose comme

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

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

Maintenant, connectez le constructeur pour le prototype:

Person.prototype = PersonProto;

Et, voilà:

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

3 façons de définir des variables de classe JavaScript:

1)Pour définir les propriétés créées à l'aide de la fonction(), vous pouvez utiliser le 'ce' mot-clé

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

À instancier un objet de la Pomme de classe, de définir certaines propriétés, vous pouvez effectuer les opérations suivantes:

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

2) À L'Aide De La Notation Littérale

var apple = {

type: "macintosh",

la couleur: "rouge"

}

Dans ce cas, vous n'avez pas besoin (et ne peut) pas de créer une instance de la classe, elle existe déjà.

apple.color = "reddish";

3) Singleton à l'aide d'une fonction

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

Donc, vous voyez que c'est très proche de 1 décrit ci-dessus, mais de la manière d'utiliser l'objet est exactement comme en 2.

apple.color = "reddish";