这道题有点‘君生我未生，我生君已老’的意思吧。
你大可以在后面再生成一个Man的实例，查看它的name属性

function Man(name,age,job,mustache){
    // 当执行 m = new Man(); 的时候，`this.__proto__ = Man.prototype`
    // 是在这里执行的，所以下面改变Man.prototype并没有什么效果。
    this.mustache = mustache;
    Man.prototype = new Person(name,age,job);
}
var m = new Man('anthony1',29,'PE');
m.name; // "undefined"
var b=new Man()
b.name//27

在生成m实例的时候，Man.prototype还不是一个Man的实例。其后再生成一个Man实例时，Man.prototype已经变成你前面设置的样子。

new操作符在为新对象设置原型继承 (将新对象的__proto__设为构造函数的prototype) 之后 才会调用构造函数。所以

function Man(name,age,job,mustache){
    this.mustache = mustache;
    Man.prototype = new Person(name,age,job);
    // 这个地方把Man.prototype换成一个新的对象，不会影响 *这一个* new Man()得到的对象的原型（会影响下一个
}

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.job = job;
}

function Man(name,age,job,mustache){
    this.mustache = mustache;
    // 改成这句话
    Person.call(this, name,age,job)
    Man.prototype = new Person();
}

var m = new Man('Anthony',27,'PE');
m.name;// Anthony

关于委托或者继承，可以用

Man.prototype = Object.create(Person.prototype);

既然是继承，子类向父类传递参数是什么鬼？

function Person(name,age,job){
    this.name = name;
    this.age = age;
    this.ob = job;
}

function Man(name,age,job,mustache){
    this.mustache = mustache;
    Man.prototype = new Person(name,age,job);
}

var m = new Man('Anthony',27,'PE');
m.name;//undefined

当通过new操作符创建一个Man对象实例m时,JS引擎会首先创见一个对象，this关键字指向这个对象，并且其原型对象为函数的默认原型对象A;
在函数Man的执行过程中其原型对象发生变化，指向了Person的实例对象B，但是这个并不能改变当前this关键字指向的对象及其原型对象A
当Man函数执行结束后，this关键字指向的对象赋值给m，那么m的__proto__指向的原型对象为Man的默认原型对象A
而Man函数的原型对象变更为B

导致的结果为
第1次执行new Man后，Man的prototype被改变为B，但是创建的实例的指向的原型对象A并不发生变化，也就是实例的__proto__执行不发生变化。
第2次执行new Man后，Man的prototype被改变为C,创建的实例的指向的原型对象B并不发生变化,也就是实例的__proto__执行B。
第2次执行new Man后，Man的prototype被改变为D,创建的实例的指向的原型对象C并不发生变化,也就是实例的__proto__执行C。

其根本还是变量赋值的问题，如下

var obj1={
    name:"XXXX"
};
var testObject={};

testObject.obj1=obj1;

//obj1重新赋值，但并不影响testObject.obj1执行的对象，虽然一开始的时候2者时相同的
obj1={
    name:"YYYY"
};

console.log(testObject.obj1.name);//XXXX
console.log(obj1.name);//YYYY