对象 原型和原型链

全局对象 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() 也会成功