accesseurs de propriété javascript

En Javascript, il semble que l'aide d'accesseurs de propriété n'est pas du tout commun (contrairement à d'autres langages à objets comme Java par exemple).

Si j'ai un Person objet avec un nom, définie comme

function Person(name) {
   this.name = name;
}

Le nom d'une personne ne va pas changer, mais je ne veux pas être en mesure d'accéder en cas de besoin, afin que je puisse faire quelque chose comme:

function Person(name) {
   var name = name;
   this.getName = function() {
      return name;
   }
}

Même dans un langage dynamique, je pense que les principes de l'utilisation des getters et setters s'appliquent de la même manière qu'aux langages à objets à typage statique (par exemple, l'encapsulation, l'ajout d'une validation, en limitant l'accès, etc)

Cette question peut se ferment, comme subjectif, mais je suis curieux de savoir pourquoi ce problème n'apparaît pas plus souvent (par exemple, les développeurs Java deviendrais folle si tout était public).

Est-il un "standard" de la façon de le faire en javascript? J'ai vu Object.definePropertymais pas tous les navigateurs.

source d'informationauteur Jeff Storey

accessor javascript

15

Javascript a intercept-mesure accesseurs de propriété:

http://ejohn.org/blog/javascript-getters-and-setters/

À mon humble avis c'est une bien meilleure solution pour faire respecter l'Uniforme Principe de l'Accès aux que Java est plus stricte explicite les méthodes de lecture, mais c'est aussi la simplicité et le manque de souplesse de la langue (Groovy, par exemple, permet de semblable interception).
7

Je connais mes pensées sur le sujet.

Getters et les setters sont mal.

Attendre! Vraiment! Ours avec moi un instant et laissez-moi vous expliquer.

Simplement à l'aide d'une méthode pour obtenir et définir une valeur est .. bien .. un peu inutile. Elle ne protège pas, pas vraiment, et ce que vous mettez dans ce que vous faites.

D'autre part, je suis plutôt friand des méthodes qui mettent l'information, puis obtenir des informations en retour. MAIS ici, c'est la magie de la partie! Ce n'est pas la même information. Non, pas directement.
```
function Person(name) {
  this.getFullName = function() {return this.firstName + " " + this.lastName;};
  this.setBirthday = function(date) { this.birthday = date; };

  this.getAge = function() { /* Return age based on the birthday */ };
  this.isOfLegalDrinkingAge function() { /* do your math here too */ };
}
```
Mais la plupart du temps, je suis juste en train de bousculer les données statiques et d'obtenir des données statiques. Quel est le point de les cacher derrière des getters et setters?

Comme une raison secondaire, relations avec les DOM et la plupart des objets hôte, vous définissez des propriétés. Vous ne jouez pas avec les getters et les setters. Ne les utilisez pas, s'intègre au reste de la le "goût" de ce que JS codeurs à faire.
3

Je pense que la réponse est que l'émulation des classes en javascript n'est pas la pratique courante, parce que la langue est en fait prototypes.

Bien qu'il est possible de créer une classe comme des structures (comme dans votre exemple), ils ne sont pas vraiment comme les classes java, et en tant que programmeur, vous finissent par se battre avec les nuances.

Cependant, si vous embrassez les prototypes de la nature de javascript, vous êtes récompensé par une autre, mais cohérent, et la structure simple de la langue.

Il n'est pas nécessaire d'utiliser des getters et des setters prototypes de la structure, vous pouvez simplement définir un objet par, eh bien, le mettre en valeur, et d'obtenir, en l'appelant comme une valeur.

Javascript ne pas vous forcer à écrire de code structuré, et ne vous empêche pas de le faire. Je pense que la culture qui a grandi autour de javascript a développé un bon style de codage, qui est parfaitement valide, et différente de toute autre langue que j'utilise.

Je sais que cette réponse n'est pas définitive et concluante, mais heureusement, il y a quelques idées qui vous aideront à trouver la anser vous êtes à la recherche pour.

C'est ce que j'ai utilisé pour les champs locaux:

TYPE_DEFAULT_VALUE= {
number: 0,
string: "",
array: [],
object: {},
};
typeOf = function (object) {
if (typeof object === "number" && isNaN(object))
return NaN;
try {
return Object.prototype.toString.call(object).slice(8, -1).toLowerCase();
}
catch(ex) {
return "N/A";
};
};
getAccessor = function(obj, key, type, defaultValue) {
if (defaultValue === undefined) 
defaultValue =  TYPE_DEFAULT_VALUE[type] === undefined ? null : TYPE_DEFAULT_VALUE[type];
return {
enumerable: true,
configurable: true,
get: function () {
if (obj[key] === undefined) 
obj[key] = defaultValue;
return obj[key];
},
set: function (value) {
if (typeOf(value) === type)
obj[key] = value;
},
};
}
LocalFields = function (fields, object) {
/**
* field properties
* { 
*   type: [ required ] ( number | string | array | object | ... ),
*   defaultValue: [ optional ]
* }
*/
if (! fields)
throw "Too few parameters ...";
if (! object) 
object = this;
var obj = this;
var fieldsAccessor = {};
for(key in fields){
field = fields[key];
fieldHandler = key[0].toUpperCase() + key.substr(1);
if(! field.type)
throw "Type not set for field: " + key;
fieldsAccessor[fieldHandler] = getAccessor(obj, fieldHandler, field.type, field.defaultValue)
}
Object.defineProperties(object, fieldsAccessor);
}

Maintenant, pour chaque Classe, je peux juste appeler quelque chose comme:

Person = function(){
new LocalFields({
id:     { type: "number" },
name:   { type: "string" },
}, this);
}

Et puis comme VS getter et setter vous pourrez appeler:

var alex = new Person();
alex.Name = "Alex Ramsi";
console.clear();
console.info(alex.Name);

0

Je m'excuse si je ne comprends pas correctement à la question, mais l'exécution de fonctions sont un moyen de rendre les membres du public/privé
```
var Person = function(){
var _name = "Roger",
self = { getName : function (){ return _name; }};
return self;
}()
```
Vous pouvez ensuite accéder à la Personne.getName() à partir de n'importe où , mais pas ensemble _name.

Vous devez vous connecter pour publier un commentaire.