defineProperty

defineProperty

这个是定义一个原型。

let p = {}
Object.definePrototype(p, 'name', {
    value: function(){console.log('i am name')}
})

这个是定义一个name属性。

注意：defineProperty定义的属性，属性特性(writable, configurable, enumerable)是false, 而字面量创建的对象，默认是true. Property Descriptors

defineProperties

这个是在原型上定义多个属性

let person = {}
Object.defineProperties(person, {
    names: {
        value: 'name'
    },
    age: {
        value: 'age'
    }
})

defineProperties和defineProperty定义的数据属性，若不指定，默认的内部属性为false

{} 这种是属于字面量创建了，默认的内部属性都是true.
- 数据属性(Configurable, Enumerable, Writeable)默认都是true, Value是undefined.
- 访问器属性(Configurable, Enumerable, Get, Set)中前两个默认为true, 后两个默认为undefined
Object.getPrototypeOf(obj)

这个是获取一个原型

Object.setPrototypeOf(original, newer)

这个是设置新的原型,在es6中出.

obj.hasOwnProperty 这里是可以判断是否在实例上存在对应的属性。
```
let P = function(){}
P.prototype.name = 'xhs'
let p = new P
p.hasOwnProperty("name") // false
P.hasOwnProperty('name') // true
```
只是在对应的目标对象上发生作用。
constructor

这个东西比较容易搞混淆。constuctor并不是说函数是一个constructor,而是说被new关键字调用的函数才是构造函数。

constructor介绍

所以可以看出一些区别来。

function Foo() {this.name = 'foo-name'}
function Bar() {this.name = 'bar-name'}

针对于上面这点，我们来继承。

Foo.prototype = Bar.prototype //1
Foo.prototype = new Bar //2
Foo.prototype = Object.create(Bar.prototype) //3

//3在es6中的写法

//1的情况他是直接继承自Bar的原型的对象，Foo原型上有任何更改，都会作用于Bar的原型.

const f = new Foo
b = new Bar
Foo.prototype.friends = ['john', 'issac']
console.log(Bar.prototype.friends) //['john', 'issac']
console.log(b.friends) // ['john', 'issac']

//2的情况他是作为一个构造函数去继承，这样会产生副作用,他会继承Bar的构造函数。

function Person() {
this.name = 'person name'
this.age = 18
this.friends = []
}

function Child() {
this.name = 'child name'
}

Child.prototype = new Person // new Person is: {name: "person name", age: 18, friends: Array(0)}
Child.prototype //Person {name: "person name", age: 18, friends: Array(0)}
let c = new Child
c.age // 18
c.friends.push('c')
let c2 = new Child
c2.friends // ['c'],这样就会出现副作用(因为把Person的构造函数对象放在了Child的原型上，导致在原型上直接操作)

//3的情况这个就只是单纯的继承，不会出现副作用。

function Person() {
this.name = 'person name'
this.age = 18
}

function Child() {
this.name = 'child name'
}

Person.prototype.friends = []

Child.prototype = Object.create( Person.prototype ) // Object.create(Person.prototype)不会创建实例方法，只会继承prototype方法，但是如果直接操作也会有问题

Child.prototype //Person {}
let c = new Child
c.age // undefined, 这里说明不会继承构造函数对象(因为压根就没有使用构造函数~.~)
c.friends.push('c')
(new Child).friends // ['c'], 可以发现，这也也是有问题的。这点不难理解吧，因为Object.create( Person.prototype )把Person的原型方法给了Child的prototye,导致直接操作原型的本身了。

//3 和 //2的区别就是 //2可以获得原型及实例的方法，但是//3只会获得原型链上的方法，不会获得实例上的方法。

这几种不能单纯的说好或者不好，毕竟每种都有他应用的场景。

具体可以参考(Prototypal) Inheritance

Previousprototype-example Nextunderstanding-es6

Last updated 5 years ago