variable de classe en Javascript

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

La variation d'une "Classe" en JavaScript doit être définie comme suit:

// 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 la référence renvoie toujours au propriétaire du 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 pour attribuer des propriétés à votre instance, alors les propriétés seront simplement déclarées comme variables. Si vous n'utilisez pas l' var déclaration, ces déclarations vont créer des variables globales qui sont mauvais!

en savoir plus sur ce

this la référence dans une fonction de constructeur est extrêmement importante si vous voulez ajouter les propriétés de l'instance en cours. Sans l'aide de this, vous créez seulement une variable (qui n'est pas la même qu'une propriété) et comme mentionné, si vous n'utilisez pas la déclaration var non plus, vous créez 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!

utilisez ceci!

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

Note, Tout ce qui est assigné à une instance par l'intermédiaire du constructeur de fonctions ne peut pas être hérité à moins que vous ne l'assigniez au prototype et le réécriviez dans le constructeur de fonctions pour en faire une propriété propriété.

quand vous créez une nouvelle instance de via un doublage de fonction en tant que constructeur, en fait ce qui suit se produit.

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 dans JavaScript est qu'il n'est pas encapsulé dans une déclaration de classe agréable. À l'origine, JavaScript n'avait même pas de constructeur de fonctions, mais a été ajouté plus tard parce que SUN a demandé Qu'ils voulaient JavaScript pour sois plutôt comme Java.

Objet littéraux

l'alternative pour les constructeurs de fonctions pour les objets qui ne portent que des données intrinsèques et aucune méthode ne sont des objets littéraux.

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

qui est la façon préférée de déclarer des objets intrinsèques plutôt que:

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

avec des objets littéraux dans votre jeu de compétences, vous pouvez créer un modèle d'usine pour les objets de données intrinsèques en utilisant le motif de module (qui est généralement pour les singletons).

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

cela permet une encapsulation confortable, mais ne peut être utilisé que pour des objets de données intrinsèques.

une autre chose que vous pouvez faire avec la littéralité des objets et le JavaScript est la délégation, qui devrait être préférée.

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 cela devrait-il être préféré? Parce qu'il garde vos objets infimes et lisibles, même les références prototypiques prennent de la mémoire et lorsque vous utilisez l'héritage et le "sous-classement" vous vous retrouvez avec enfant les instances qui ont beaucoup de références de méthode inutilisées. La délégation est toujours meilleure.

la façon dont vous avez mentionné est comment définir les variables de classe, l'autre façon (à l'intérieur de function Person) est de définir les propriétés de l'occurrence.

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.

il est important de comprendre qu'il n'existe pas de classes dans JavaScript. Il y a quelques cadres là-bas qui simulent un modèle d'héritage classique, mais techniquement tout se résume à fonctions du constructeur et prototypes.

alors, vous pourriez vouloir faire quelque chose comme

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

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

maintenant, connectez le constructeur au prototype:

Person.prototype = PersonProto;

Et voilà:

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

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"

Je ne vois pas de meilleur exemple.

3 façons de définir une variable à la classe JavaScript:

1) pour définir les propriétés créées en utilisant function (), vous utilisez le mot-clé 'this'

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) En Utilisant La Notation Littérale

var apple = {

type: "macintosh",

la couleur: "rouge"

}

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

apple.color = "reddish";

3) Singleton utilisant une fonction

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

donc vous voyez que c'est très similaire à 1 discuté ci-dessus, mais la façon d'utiliser l'objet est exactement comme en 2.

apple.color = "reddish";

Vous pouvez aussi essayer cette approche:

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

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