js基础（对象，原型，call，apply，继承，命名空间，对象枚举，this）

观看渡一教学视频做的笔记，加强基础知识。

1. 对象

var a = {
	name:'123',
	number: 12,
	health: function () {
		// a.number -- ;
		this.number -- ;
		console.log('iii')
	}
}

增，删，改，查
增：a.wife = ‘xiaoliu’;
删：delete a.name
改：a.name = ‘234’;
查：a.name；a.abc//undefined,没有这个属性就是undefined

对象的创建方法：
1.var obj = {}; plainObject 对象字面量/对象直接量
2.构造函数
（1）系统自带的构造函数 Object (像个工厂) var obj = new Object();
（2）自定义(大驼峰式的命名规则，与函数区别开)

	function Person(name){
		// var this = {}; new之后会生成一个隐式的this空对象{AO:{this:{name:''...}}}
		this.name = name,
		this.age = 23,
		this.run = function () {
			this.age -- ;
		}
		// return this;
		return 123//返回原始值系统会自动忽略的
	}
	var person1 = new Person('haha');
	person1.name= '123';

2. 包装类

5个原始值不能有对象和方法，但是对象可以有属性方法；
var num = new Number(123);
var str = new String(‘abcd’);
var boolean = new Boolean(true);
undefinde 和 null 没有属性和方法；

var num = 4;
num.len = 3; // new Number(4).len = 3; delete
num.len //new Number(4).len 结果为undefined ；与上边的new 是两个对象所以没有len属性

var arr = [1,2,3,4];
arr.length = 2;
console.log(arr); //结果为[1,2]

var str = ‘abcd’;
str.length = 2; // new String(‘abcd’).length = 2; delete
console.log(str) // abcd
console.log(str.length) // 4 new String(‘abcd’).length 字符串直接有length属性

3. 原型

定义：原型是function对象的一个属性，它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对象，可以继承该原型的属性和方法。原型也是对象。

// Person.prototype //原型
// Person.prototype = {} //祖先
Person.prototype.name = '123';
function Person() {
	this.name = '234'
}
var person = new Person();
var person1 = new Person();

利用原型的特点和概念，可以提取公有的属性；
Person.prototype下面有粉色的__prop__ 和 constructor

	Person.prototype.name = 'xiao';	
	function Person(){
		// var this = {__proto__:person.prototype};都会生成一个__proto__指向它的原型
		// this.name = 'haha',	
		// return this;		
	}
	var obj = {
		name: 'da'
	}
	var person1 = new Person();
	person1.__proto__ = obj;
	person1.name //结果为da

第23节课
创建对象的方法：var obj1 = Object.create(原型)
var obj = {name:‘123’};
var obj1 = Object.create(obj)

绝大多数的对象最终都会继承自Object.prototype
Object.create(null) 这样构造出的对象就没有原型
Object.toString = function () {
console.log(‘111’)
}
document.write(Object) // 结果为111

var obj = {}
obj.toString() //’[object Object]’

Object.prototype.toString.call(123); //让123调用Object原型的toString方法，结果为‘[object Number]’

var num = 123;
//var num = new Number（123）转成包装类
num.toString() //‘123’

js精度不准 0.14100 = 14.000000000000002
所以Math.floor(Math.random100) 先乘再取整

4. call，apply

call需要把实参按照形参的个数传进去
apply 后面传数组，需要传一个arguments
改变this指向，传参列表不同

5. 继承

1.传统模式：原型链（爷父子的例子）过多的继承了没用的属性
2.借用构造函数 call,apply
缺点：不能继承借用构造函数的原型
每次构造函数都要多走一个函数
3.共享原型

下边 var son1 = new Son();
// 先继承 再执行
这样写不行的原因是son和father指向了相同的原型，如果son加个自己的属性，father也会拥有此属性，不能生成单独的自己的属性

4.圣杯模式

生成f的中间函数
24节课40分钟讲闭包的另外两种应用

闭包的第3点应用：变量私有化，perpareWife 可以操作这个变量，但是却不是Deng的属性

6. 命名空间

闭包的第4点应用：模块化开发
用闭包私有化自己的变量（name），避免命名重复；

7. 对象的枚举

就是对象的遍历
1.for in

直接obj.找的是.后的字符串属性；所以不能写obj.prop应该是obj[prop]

2.hasOwnProperty

判断是不是对象自己身上的属性，能过滤掉对象身上的原型链属性（你自己设置的原型链上的属性，对象自己本身下面的__prop__是过滤不掉的）；

3. in
   ‘height’ in obj //obj里是不是有height属性

4.instanceof

person instanceof Person // true
例：var arr = [] || {}; // arr可能是数组或者是对象，怎么判断，用typeof 两个都是object

	//[] instanceof Array 是true
	//var obj = {};obj instanceof Array 是false

{} == {} //结果是false 引用值比较的是地址，两个对象两个地址，不相等
var obj = {};
var obj1 = obj;
obj1 === obj //true 指向一个房间了 所以绝对相等

8. this

1.函数预编译过程this指向window
2.全局作用域里this指向window
3.call和apply可以改变函数运行时this的指向
4.obj.func();func()里面的this指向obj

8. arguments.callee

arguments.callee 调用函数自己本身；算100的阶层，立即执行函数没有名字，没办法做递归，所以用arguments.callee调用函数自身