duixaing jicheng 2

// 相同函数名的重写：

 // Object.prototype.toString = function() {
 // }; 


 Person.prototype = {
 	toString : function() {
 		return 123;
 	}						这种和原型链终端一样的方法但实现不同功能的东西
 									叫做方法的 重写 
 }
 function Person() {

 }
 var person = new Person();

call()

可以改变 this 的指向;
demo:

<script>
	function Person(name, age) {
		this.name = name;
		this.age = age;
	}
	var person = new Person('zhang', 19);
	var obj = {
	}
	Person.call(obj,'wenqiang', 20);
</script>

这串代码中的Person.call()执行和 单个的 Person()没什么区别；
但是Person.call()中可以加改变this指向的参数 比如上面这串代码 它执行完的结果就是 obj里面有了值（不是一个空对象）此时obj={ name = 'wenqiang'; age = '20' ;}

call();需要把实参按照形参的个数传进去

apply();需要传一个 arguments（第一个参数都一样 ，后面必须传数组）

传参列表不同;

再看一个：

function Wheel(style, wheelSize) {
	this.style = style;
	this.wheelSize = wheelSize;
}
function Sit(c, sitColor) {
	this.c = c;
	this.sitColor = sitColor;
}
function Model(height, width, len) {
	this.height = height;
	this.width = width;
	this.len = len;
}
function Car(style, wheelSize, c , sitColor, height, width, len) {
	Wheel.call(this, style, wheelSize);
	Sit.call(this, c ,sitColor);
	Model.call(this, height, width, len);
}
var car = new Car('花里胡哨', '150', '舒适', 'black', '1000', '2000', '3000');

运行完 car ={ c: "舒适" height: "1000" len: "3000" sitColor: "black" style: "花里胡哨" wheelSize: "150" width: "2000"}

继承

现在要修改son和father 构造函数的 原始值相等：

Father.prototype.lastName = "Zhang";
function Father() {

}
function Son() {

}
// Son.prototype = Father.prototype;
// // var son = new Son();
// // var father = new Father();
function inherit(Target, Origin) {
	Target.prototype = Origin.prototype;

}
inherit(Son, Father);                 //先继承+
Son.prototype.sex = "male";
var son = new Son();

虽然以上代码已经让：son and father 继承同一个原型，但上面这串代码存在不足：此时修改 son 的原型 father 的原型也会跟着改变。但是儿子是不能改变父亲的。。。

改进后：

function inherit(Target, Origin) {
	function F() {};
	F.prototype = Origin.prototype;
	Target.prototype = new F();
} //此时修改son的原型 father的原型不会跟着改变；
Father.prototype.lastName = "Zhang";
function Father() {

}
function Son() {

}
inherit(Son, Father);
var son = new Son();
var father = new Father();

wanshan：

function inherit(Target, Origin) {
	function F() {};
	F.prototype = Origin.prototype;  //在 new 之前该原型;
	Target.prototype = new F();
	Target.prototype.constuctor = Target;   //让son的constutor指向自己本身;
	Target.prototype.uber = Origin.prototype;//让son的最终指向需要指向的地方;
}
Father.prototype.lastName = "Zhang";
function Father() {

}
function Son() {

}
inherit(Son, Father);
var son = new Son();
var father = new Father();
//这样的继承称为  圣杯模式;

命名空间

var org = {
	department1 : {
		jicheng : {
			name : "abc",
			age : 19
		},
		xuming : {
		}
		}
	department2 : {
			zhangsan : {
			},
			lisi : {
			}
		}
}

在用的时候 org.department1.jicheng.name;
也可以用 div deng = org.department1.dengmou;
				div zhang = org.department.zhangsan;

(webpack)

有关命名空间

闭包使变量私有化：

<script>
	var name = heheh;
	var init = (function() {
		var name = abc;
		function callName() {
			console.log(name);
		}
		return function () {
			callName();
		} 
	}())
	var initZhang = (function(){
		var name = 123;
		function callName() {
			console.log(name);
		}
		return function() {
			callName();
		}
	}())
</script>

通过写一个立即执行函数加上闭包return一个函数的写法 让变量私有化 ，

虽然全局和 init 和 initZhang 里面都有 name 这个 变量，但是它们互不影响。

连续调用函数

var wang = {
		smoke : function() {
			console.log('Smoking!');
			return this;
		},
		drink : function () {
			console.log('Drinking');
			return this;
		},
		perm : function() {
			console.log('cool!');
			return this;
		}
}
wang.smoke().drink().perm();

每个函数里面加上 return this;就可以连续调用了

obj.name 执行时内部隐式转换成 -----> obj[‘name’]

javascript 小知识

**document.write();  使用的时候一定会调用 toSting() 方法然后输出他的返回值；


 Math.ceil(123.123); 向上取整 输出为 124
 Math.floor(123.789);向下取整 输出为 123
 Math.random() 产生一个随机数在(0, 1)之间
 toFixed(2) 保留两位小数



 可正常己算的范围  小数点前16位 后16位**