Ils vous demandent de créer une fonction constructeur appelé Circle qui crée des objets qui auront get_area, set_radius et toString fonctions qui se comportent de la manière indiquée. (toString est ce qui sera utilisé dans la déclaration finale, où vous produisez la valeur de l'instance circle.) Ils s'attendent probablement à ce que vous donniez ces objets via le prototype Circle (voir ci-dessous).
Circle est une fonction constructeur car il crée de nouveaux objets (bien, techniquement juste les remplit, ils sont créés par l'opérateur new). Parfois, les gens appellent ces classes , mais ce ne sont pas vraiment des classes dans la véritable OOP basée sur les classes (ce sont des fonctions constructeurs à la manière OOP basée sur le prototype authentique utilisée par JavaScript).
Il y a quelques façons de le faire, mais encore une fois, vous auriez généralement une fonction Circle qui définit les propriétés d'une instance sur this, puis attribuer des fonctions aux Circle.prototype, que tous les objets créés par new Circle seront hériter. Je donnerais un exemple, mais j'ai l'impression que c'est un exercice d'apprentissage, alors il vaut mieux le laisser au lecteur. Mais il y a quelques conseils:
- Dans la fonction constructeur, vous pouvez vous référer à l'objet créé par l'opérateur
new en utilisant le mot-clé this.
- La fonction de constructeur l'objet aura une propriété appelée
prototype. Si vous affectez des propriétés à ce prototype, elles seront héritées par des instances créées avec votre fonction constructeur (héritées par quelque chose appelé la chaîne de prototypes ). Donc, si j'ai une fonction constructeur Foo, je peux définir une propriété (disons, bar) sur Foo.prototype (Foo.prototype.bar = /* whatever */;) et toutes les instances créées via new Foo() auront une propriété bar avec cette valeur.
- Les fonctions en JavaScript sont des objets de première classe. Vous pouvez vous référer à eux tout comme vous pouvez vous référer à des chaînes ou des chiffres.Si j'ai
function foo() { /* ... */ }, je peux définir une variable x pour y faire référence (var x = foo;), puis l'appeler via cette variable (x();).
- Tout comme
x peut faire référence à une fonction, la propriété bar que j'ai mentionnée ci-dessus peut faire référence à une fonction.
Espérons que cela vous met sur la bonne voie sans donner le jeu entièrement.
Re vos commentaires sur les références pour en apprendre plus sur JavaScript:
- J'ai trouvé le livre JavaScript: The Definitive Guide être très bon par David Flanagan (O'Reilly). C'est peut-être un peu daté, la cinquième édition a maintenant plusieurs années.
- Il ya un tas d'articles du gourou JavaScript bien respecté Douglas Crockford au http://javascript.crockford.com, mais je vous préviens que Crockford est laconique. :-) Intelligent et informé, même si l'on n'est pas toujours d'accord avec ses conclusions.
- Je n'aime pas se référer à mon blog [parce que A) est SO pas sur l'auto-promotion, et B) « anémique » n'a pas la moitié dit qu'il] mais il y a a couple de posts there que je pense might help.
Re mon commentaire ci-dessous: Vraiment je ne peux pas laisser ceci sans un exemple, parce que c'est juste inutile de le faire. Voici donc un exemple d'une fonction constructeur et certaines fonctions qui lui sont associées:
// A constructor function called `Person`
function Person(fname, lname) {
// Within the constructor, we can refer to the new instance via `this`.
// Let's remember the names we were given.
this.firstName = fname;
this.lastName = lname;
// Now, the instance that is returned from `new Person(...)` will have
// those properties on it.
}
// Let's give the Person prototype a function that returns the person's
// full name.
Person.prototype.getFullName = function() {
return this.firstName + " " + this.lastName;
};
// Okay, let's see `Person` in action:
var p = new Person("John", "Doe");
console.log(p.firstName); // "John" -- this is referencing the property we set in the constructor
console.log(p.getFullName()); // "John Doe" -- this calls the function we get from the prototype
// `p` has the `getFullName` function because it inherits it from the
// `Person.prototype` object.
// Let's see what happens if I try to output the instance itself:
console.log(p); // Most like you get "[object Object]" or similar -- not useful!
// In that sort of situation, JavaScript will use a function called `toString`
// to get a string equivalent of the instance. (It's more complicated than that,
// but you don't want me to go into the details here.) So let's give
// `Person.prototype` a `toString` function that does something useful:
Person.prototype.toString = function() {
return this.getFullName();
};
// Note there that we're using `this` again. When a function is called through
// an object property (e.g., `p.toString()`), within the function call `this`
// refers to the object instance. `this` is an important and flexible concept
// in JavaScript and very much unlike its counterpart in (say) Java or C++,
// even though in simple situations (like this) it looks similar.
// Now let's try it:
console.log(p); // "John Doe", because the interpreter implicitly calls `toString` for you
// "Hey, wait a minute!" I hear you saying, "You didn't make a new `p`! How did it
// get the new function?!" The answer is it got it the same way it got `getFullName`:
// from `Person.prototype`. The `p` instance *refers* to the `Person.prototype`, it
// doesn't have a *copy* of it. So changes to `Person.prototype` show up in `p`
// (unless `p` overrides them, which we aren't doing in this example).
(Cet exemple utilise des fonctions anonymes, que je suis not a fan of, mais je ne voulais pas entrer dans toute discussion des fonctions nommées . ici)
(OT: Être pointilleux, la personne qui pose cette question vous devriez vraiment avoir déclaré la variable circle au début: var circle; Notez également que console.log ne peut pas exister dans toutes les implémentations JavaScript - c'est mieux connu de Firefox + Firebug.)
Re votre code posté, voir ma réponse à votre commentaire sur ma réponse. –