pourquoi le prototype est indéfini

J'ai connu ce qui a été posé des centaines de fois, cependant, je n'arrive pas à saisir le concept de prototype

Voici mon exemple de script

var config = {
  writable: true,
  enumerable: true,
  configurable: true
};

var defineProperty = function(obj, name, value) {
  config.value = value;
  Object.defineProperty(obj, name, config);
}


var man= Object.create(null);
defineProperty(man, 'sex', "male");

var person = Object.create(man);
person.greet = function (person) {
    return this.name + ': Why, hello there, ' + person + '.'
}
var p=Object.getPrototypeOf(person);
alert(p.sex);//shows male
person.prototype.age=13;//why there is a error said the prototype is undefined? I thought it supposed be man object...

var child=function(){}
child.prototype.color="red";//why this line doesn't show error? both child and person are an object . 

alert(child.prototype.color);//shows red

var ch=Object.getPrototypeOf(child);

alert(ch.color);//why it is undefined? it is supposed red.

Espère que vous pouvez me donner un aide... merci.

Mise à jour:

Grâce à vos gars de bien vouloir l'aider, Basé sur Elclanrs réponse, voici ce que j'ai appris.

Function est celui de la construction des objets en javascript. le format 3 création de la fonction de l'objet sont égales.

var function_name = new Function(arg1, arg2, ..., argN, function_body)
function function_name(arg1, arg2, ..., argN)
{
...
}
var function_name=function(arg1, arg2, ..., argN)
{
...
}

C'est donc pourquoi créer un prototype de la chaîne, nous avons créer une fonction et ensuite l'appeler avec le mot clé new .

Function.prototype est la référence pour Toutes les fonctions de l'objet prototype.

Acclamations

source d'informationauteur Joe.wang

  1. 8

    Je pense que vous pourriez être un mélange de concepts. Essayez de saisir le concept de prototypes avec la classique héritage de prototype d'abord, puis vous pouvez obtenir dans tous les nouveaux Object choses.

    En JavaScript, chaque objet (nombres, chaînes, les objets, les fonctions, les tableaux, les regex, dates...) a un prototype que vous pouvez considérer comme un ensemble de méthodes (fonctions) qui sont communs à tous actuelles et futures instances de cet objet.

    Pour créer un prototype de chaîne, vous devez créer une fonction et l'appeler avec la new mot-clé pour spécifier que c'est un constructeur. Vous pouvez penser à des constructeurs comme la fonction principale qui prend les paramètres nécessaires à la construction de nouvelles instances de votre objet.

    Ayant ceci à l'esprit, vous pouvez étendre les objets natifs ou créer votre propre nouveau prototype de chaînes. Ceci est similaire à la notion de classes, mais beaucoup plus puissant dans la pratique.

    Similaire à votre exemple, vous pourriez écrire un prototype de chaîne comme ceci:

    //Very basic helper to extend prototypes of objects
//I'm attaching this method to the Function prototype
//so it'll be available for every function
Function.prototype.inherits = function(parent) {
  this.prototype = Object.create(parent.prototype);
}

//Person constructor
function Person(name, age, sex) {
  //Common to all Persons
  this.name = name;
  this.age = age;
  this.sex = sex;
}

Person.prototype = {
  //common to all Persons
  say: function(words) {
    return this.name +'says: '+ words;
  }
};

//Student constructor   
function Student(name, age, sex, school) {
  //Set the variables on the parent object Person
  //using Student as a context.
  //This is similar to what other laguanges call 'super'
  Person.call(this, name, age, sex);
  this.school = school; //unique to Student
}

Student.inherits(Person); //inherit the prototype of Person

var mike = new Student('Mike', 25, 'male', 'Downtown'); //create new student

console.log(mike.say('hello world')); //=> "Mike says: hello world"

    Dans une version plus récente de JavaScript (lire EcmaScript), ils ont ajouté de nouvelles façons de composer avec les objets et de les étendre. Mais le concept, c'est un peu différente de la classique héritage de prototype, cela semble plus compliqué, et un peu plus de connaissances sur la façon JS fonctionne sous aiderait vraiment comprendre comment il fonctionne, de plus il ne fonctionne pas dans les navigateurs plus anciens. C'est pourquoi je vous suggère de commencer avec le classique motif pour lequel vous trouverez précis et abondant de l'information sur internet.

  2. 11

    La prototype propriété n'existe que sur les fonctions, et person n'est pas une fonction. C'est un object.

    Voici ce qui se passe:

    var man = Object.create(null);         //man (object) -> null
man.sex = "male";

var person = Object.create(man);       //person (object) -> man (object) -> null
person.greet = function () { ... };

var p = Object.getPrototypeOf(person); //man (object) -> null
alert(p.sex);                          //p is the same object as man

person.prototype.age = 13;             //person doesn't have a prototype

var child = function () {};            //child (function) -> Function.prototype
                                       //-> Object.prototype -> null
child.prototype.color = "red";         //child has a prototype

var ch = Object.getPrototypeOf(child); //Function.prototype

alert(ch.color);                       //ch is not the same as color.prototype
                                       //ch is Function.prototype

    Pour plus d'informations, je vous suggère de lire cette réponse: https://stackoverflow.com/a/8096017/783743

    Edit: Pour expliquer ce qui se passe en aussi peu de mots que possible:

    1. Tout en JavaScript est un objet à l'exception des valeurs primitives (les booléens, les nombres et chaînes de caractères), et null et undefined.

    2. Tous les objets ont une propriété appelée [[proto]] qui n'est pas accessible pour le programmeur. Cependant, la plupart des moteurs de cet établissement est accessible que __proto__.

    3. Lorsque vous créez un objet comme var o = { a: false, b: "something", ... } puis o.__proto__ est Object.prototype.

    4. Lorsque vous créez un objet comme var o = Object.create(something) puis o.__proto__ est something.

    5. Lorsque vous créez un objet comme var o = new f(a, b, ...) puis o.__proto__ est f.prototype.

    6. Quand le JavaScript ne peut pas trouver un bien sur o il recherche le bien sur o.__proto__ et puis o.__proto__.__proto__ etc jusqu'à ce qu'il trouve la propriété ou le proto de la chaîne se termine dans null (dans ce cas, la propriété est undefined).

    7. Enfin, Object.getPrototypeOf(o) retourne o.__proto__ et pas o.prototype - __proto__ existe sur tous les objets, y compris des fonctions mais prototype n'existe que sur les fonctions.