对象 原型和原型链

全局对象 global (浏 window)

global.parseInt()
global.parsefloat()

window的属性

window可以省略

ECMAScript规定 私有(Chrome/Firefox)
parseInt alert(弹窗)
parsefloat prompt(弹框提示)
Number() confirm(确认)
String() console(开发者)
Boolean() document(文档) DOM
Object() history(浏览器)BOM

MDN window 可以查到window所有属性

四个全局函数 Number()、String()、Boolean()、Object()

简单类型和对象的区别

Number()创建一个number类型的对象
1.Number('1')
2.var n = new Number(1)

普通的数字1和对象1 的区别


image.png

但是js有黑魔法,使得普通数字1也能使用对象1中的方法

var n1 =1;
n1.toString()
n1.valueOf()


临时创建了一个temp变量
temp = new Number(n1)
temp.toString()
然后再把temp干掉

image.png

String()

跟Number()对象类似

s2.charAt(0) // 获取对应位置的字符
"a"
s2.charCodeAt(0) // 获取对应位置的字符的编码
97

trim() 删除两端的空格
concat() 连接两个字符串
slice(0,2) 切片截取

Boolean()

image.png

千年老坑

falsey值只有 0 NaN '' null undefined 和false
对象都是true
f就是简单的false
f2 是一个false对象

Object()

var o1 = {}
var o2 = new Object()

Number String Boolean Object

谷内定理:
1.7中数据类型
2.5个falsy
3.内存图


原型和原型链

_ _ proto _ _

image.png

数据结构

var n1 = Number(1)
o1._ proto _ = Number.prototype
o1._ proto . _ proto_ _ = Object.prototype

String.prototype 是 String 的公用属性的引用
s._ proto _ 是String的公用属性的引用

image.png
image.png

对象的_ _ proto _ _ === 函数.prototype
共同指向公用属性

  1. _ proto _ _ = Number.prototype
    '1'. _ _ proto
    _ = String.prototype

重中之重 记住一个公式:对象的_ _ proto _ _ === 函数.prototype

var obj = 函数.prototype
obj._ _ proto _ _ === Object.prototype
函数.prototype._ _ proto _ _ ===Object.prototype

var obj2 = 函数
obj2. _ _proto _ _ === Function.prototype

特殊 Function._ _ proto _ _ === Function.prototype

Function.prototype. _ _ proto _ _ === Object.prototype

注意 Object. _ _ prototype_ _ === Function.prototype

Object.prototype. _ _ proto _ _ === null

高程上的原型对象:
无论什么时候,只要创建了一个新函数,就会根据一组特定的规则为该函数创建一个 prototype属性,这个属性指向函数的原型对象。在默认情况下,所有原型对象都会自动获得一个 constructor(构造函数)属性,这个属性包含一个指向 prototype 属性所在函数的指针。

高程原型链:
利用原型让一个引用类型继承另一个引用类型的属性和方法。简单回顾一下构造函数、原型和实例的关系:每个构造函数都有一个原型对象,原型对象都包含一个指向构造函数的指针,而实例都包含一个指向原型
对象的内部指针。那么,假如我们让原型对象等于另一个类型的实例,结果会怎么样呢?显然,此时的原型对象将包含一个指向另一个原型的指针,相应地,另一个原型中也包含着一个指向另一个构造函数的指针。假如另一个原型又是另一个类型的实例,那么上述关系依然成立,如此层层递进,就构成了实例与原型的链条。这就是所谓原型链的基本概念

实现原型链有一种基本模式,其代码大致如下。
function SuperType(){
this.property = true;
}

SuperType.prototype.getSuperValue = function(){
return this.property;
};
function SubType(){
this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function (){
return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue()); //true

SuperType 和 SubType。每个类型分别有一个属性和一个方法。它们
的主要区别是 SubType 继承了 SuperType,而继承是通过创建 SuperType 的实例,并将该实例赋给SubType.prototype 实现的。实现的本质是重写原型对象,代之以一个新类型的实例。换句话说,原来存在于 SuperType 的实例中的所有属性和方法,现在也存在SubType.prototype 中了。在确立了继承关系之后,我们给 SubType.prototype 添加了一个方法,这样就在继承了 SuperType 的属性和方法的基础上又添加了一个新方法。这个例子中的实例以及构造函数和原型之间的关系如图 6-4 所示。

构造函数里的方法存放在原型对象中,属性放在实例中

image.png

1.toString() 错误
1..toString()正常
为什么呢? 因为浏览器无法判断那个点是小数点还是一个对象调用方法的点,所以第一个会错误,而第二个式子一个给小数点,一个给属性自然会成功,只要让浏览器知道这个点的作用
同理:1. toString() 也会成功

你可能感兴趣的:(对象 原型和原型链)