js类型和对象的学习

一、js类型和数组的遍历

1、typeof能得到的那些类型

2、何时使用===何时使用==

if (obj.a == null) {
    // 相当于obj.a === null || obj.b === undefined，jquery源码推荐
}

除了这个，其余都用===

3、js中有那些内置函数

4、js变量按照存储方式区分为那些类型

（1）值类型：参考浅拷贝

（2）引用类型：数组、对象、函数 参考深拷贝

5、如何理解json和一种数据格式

JSON：是JS中的一个对象

JSON.stringify({a;10, b:20})          // json变字符串
JSON.parse('{"a":10, "b":20}')        // 字符串变json

6、日期

7、数组遍历

（1）forEach的使用

var arr = [1, 2, 3];
arr.forEach(function (item, index) {
    console.log(item, index)
} )

（2）every的使用

（3）sort

（4）map

（5）filter

二、js对象学习

1、预处理阶段和执行阶段

（1）练习题一

console.log(f);           // 会输出函数形式，在预处理阶段，函数与函数重名会覆盖前面的，变量与函数重名忽略变量
var f = 11;
function f () 
{
	console.log(11);
}
console.log(f);         // 输出11，执行阶段，变量会覆盖函数

上面相当于：

var f = function () {}
var f;
f = 11;

而变量和函数重名会忽略变量，所以就等于

var f = function () {}
f = 11;

（2）练习题二：先声明参数，在声明内部函数，最后声明内部参数；

function sum (a, b)
{
	console.log(a);        // 输出 function a() {}  参数a赋值后被函数a覆盖
	console.log(b);        // 输出2  此时内部变量b还没赋值
	var b = 100;
	console.log(b);        // 输出100
	function a () 
	{
		console.log(a);
	}
	a();                  // 输出f function a() {}
}
sum(1, 2);

2、对象属性的创建

（1）Object.defineProperty

var o = {
	name: 'xueer',
	sex: 'boy'
};
Object.defineProperty(o, "age", {                 // 第一个参数是对象名，第二个是对象属性名，第三个是个对象，设置值和不可写，默认也是不可写
	value: 18,
	writable: false
});

（2）Object.defineProperties：可以设置get,set,writable,enuerable(可枚举，==false不能用for循环遍历出来),configurable（可配置==false，不可删除）,value

Object.defineProperties(o, {                // 两个参数，第一个为对象，第二个为值
	"age": {
		value: 20,
		writable: false
	},
	"weight": {
		value: 100
	},
	"height": {
		get: function () {
			return 180
		},
		set: function (val) {
			console.log(val)
		}
	}
})

3、对象属性特性

Object.keys(o)     // 获取所有属性

判断有没有某个属性

"name" in o
true
o.hasOwnProperty("name")
true

delete p.name    // 删除属性

查看特性

Object.getOwnPropertyDescriptor(o, 'name')     // （对象名，属性名）
{value: "xueer", writable: true, enumerable: true, configurable: true}

4、call()和apply()：改变执行上下文

var obj1 = {
	name: 'xueer',
	value: 0,
	add: function(a, b, c) {
		this.value = a+b+c;
		console.log(this.value);
	},
	get: function() {
		console.log(this.name, this.value);
	}
};
var obj2 = {
	name: 'obj2',
	value: 0
};
// obj2.obj1.add(1, 2, 4)   就是把obj1中的add方法，给了obj2，即obj1的add方法中的this是obj2
obj1.add.call(obj2, 1, 2, 4);
obj1.get.call(obj2);

apply()用法和call()相同，不过obj1.apply(obj2, [1, 2, 3]); 后一个参数是数组

（1）实现new的功能

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

function New (f) 
{
	return function () {
		var o = { '__proto__': f.prototype };         // 给对象加原型，这个要是放在return之外，就会形成闭包，一个实例对象改变另一个也会改变
		f.apply(o, arguments);                       // == o.f(arguemnts)
		return o;
	}
}
var p = New(Person)('xueer', 11);

5、浅拷贝和深拷贝

（1）浅拷贝：对于对象或数组来说，当一个变量赋值给另一个变量时，其共用一个地址，一个改变另一个也会改变

（2）深拷贝：有着不同的地址

var obj1 = {                                 // 实现深拷贝
	name: 'xueer',
	age: 12,
	lang: {
		like: 'html',
		dislike: 'css'
	}
};
var obj2 = {
	sex: 'boy'
};

function clone (p, s)
{
	var s = s || {};             // s若不存在就为空对象
	for (var item in p) {
		if (typeof p[item] == 'object') {               // 若是p[item]为对象时，就递归，
			s[item] = (p[item].constructor === Array)?[]:{};    // 数组和对象的typeof都是object，所以要判断是数组还是对象
			clone(p[item], s[item]);                 // 递归
		} else {
			s[item] = p[item];
		}
	}
	return s;
}
clone(obj1, obj2);

6、arguments

function demo (a, b)
{
	console.log(demo.length);          // ==2形参的个数，
	console.log(arguments.length);     // ==3实际形参个数
	console.log(arguments);            // 类似数组的对象 arguments[0] == a,
}

demo(1, 2, 3)