原文链接http://www.cnblogs.com/wangfupeng1988/p/3977924.html
对象是属性的鸠合。
function show(x) {
console.log(typeof(x)); // undefined
console.log(typeof(10)); // number
console.log(typeof('abc')); // string
console.log(typeof(true)); // boolean
console.log(typeof(function () { })); //function
console.log(typeof([1, 'a', true])); //object
console.log(typeof ({ a: 10, b: 20 })); //object
console.log(typeof (null)); //object
console.log(typeof (new Number(10))); //object
}
show();
以上代码列出了typeof输出的集合范例标识,个中上面的四种(undefined, number, string, boolean)属于简朴的值范例,不是对象。剩下的几种状况——函数、数组、对象、null、new Number(10)都是对象。他们都是援用范例。
推断一个变量是否是对象异常简朴。值范例的范例推断用typeof,援用范例的范例推断用instanceof。
对象都是经由过程函数来建立的
函数就是对象的一种,由于经由过程instanceof函数能够推断。
var fn = function () { };
console.log(fn instanceof Object); // true
var obj = { a: 10, b: 20 };
var arr = [5, 'x', true];
这是种语法糖,是一种快捷方式。实在代码是:
//var obj = { a: 10, b: 20 };
//var arr = [5, 'x', true];
var obj = new Object();
obj.a = 10;
obj.b = 20;
var arr = new Array();
arr[0] = 5;
arr[1] = 'x';
arr[2] = true;
而个中的 Object 和 Array 都是函数。申明统统对象都是由函数建立的。
对象是函数建立的,而函数却又是一种对象
typeof(Array)//"function"
typeof([1,2])//"object",[1,2]实际上是new Array();
typeof(function() {})//"function"
prototype原型
函数有prototype属性,对象有_proto_属性。
每一个函数都有一个属性叫做prototype。这个prototype的属性值是一个对象(属性的鸠合,再次强调!),默许的只要一个叫做constructor的属性,指向这个函数自身。
如上图,SuperType是是一个函数,右边的方框就是它的原型。
接着往下说,你也能够在本身自定义的要领的prototype中新增本身的属性
function Fn() { }
Fn.prototype.name = '王福朋';
Fn.prototype.getYear = function () {
return 1988;
};
另有一种很轻易被殽杂的定义函数要领:
var func = function() {}
func.prototype.name = "prototype test";
func.prototype.protoFunc = function() {console.log("protoFunc")};
func.a = function() {console.log("定义对象的属性")}
func.a();//func是个对象,func是个援用。
var funcObject = new func();
console.log(new func(), "new func()");//function() {}
console.log(funcObject, "funcObject");//function() {}
funcObject.name;
funcObject.protoFunc();
funcObject.a();//funcObject.a is not a function(…),
////////////////////
//func是个对象,有a这个属性,
//funcObject是个对象,然则a不是funcObject的属性。func的一切prototype的属性就是funcObject的属性。
function Fn() {};
Fn.prototype.protoFunc = function() {return "aa";console.log("protoFunc")};
Fn.a = function() {}
var fn= new Fn();
fn.protoFunc() //"aa"
fn.a();//FnObject 不是Fn对象,所以a()要领没定义。
即,Fn是一个函数,fn对象是从Fn函数new出来的,如许fn对象就能够挪用Fn.prototype中的属性。
由于每一个对象都有一个隐蔽的属性——“__proto__”,这个属性援用了建立这个对象的函数的prototype。即:fn.__proto__ === Fn.prototype.这里的”__proto__”成为“隐式原型”
继续(原型链)
function Foo() {}
var f1= new Foo();
f1.a = 10
Foo.prototype.a = 100;
Foo.prototype.b = 200;
console.log(f1.a)//10
console.log(f1.b)//200
f1是Foo函数new出来的对象,f1.a是f1对象的基础属性,f1.b是怎样来的呢?——从Foo.prototype得来,由于f1.__proto__指向的是Foo.prototype
接见一个对象的属性时,先在基础属性中查找,假如没有,再沿着__proto__这条链向上找,这就是原型链。
天真的原型链
假如你要增加内置要领的原型属性,最好做一步推断,假如该属性不存在,则增加。假如本来就存在,就没必要再增加了。
继续–原型链
明白这张图有以下几点:
1.统统皆对象,所以每一个对象都有_proto_属性,_proto_属性指向建立该对象的函数的prototype。
2.prototype的属性值是一个对象(默许的只要一个叫做constructor的属性,指向这个函数自身)。所以各函数的prototype也有_proto_属性。
3.Object函数的_proto_只想null。
4.var Foo = new Function();则Foo._proto_指向Function.prototype.
5.function Function(){}是有它本身制造的,一切Function._proto_指向Function.prototype.
实行上下文
在“预备事情”中完成了哪些事情:
console.log(a)//a is not defined
console.log(a)//undefined
var a;
console.log(a)//undefined
var a = 10;
console.log(a)//function a() {}函数声明
function a() {}
console.log(a)//undefined 函数表达式
var a = function(){}
console.log(this)//Window {external: Object, chrome: Object, document: document, lock: Object, SF: Object…}
//this在恣意环境下都有值
变量、函数表达式–变量声明,默许赋值为undefined;
this——赋值
函数声明——赋值;
这三种数据的预备状况我们称之为“实行上下文”或许“实行上下文环境”。
给实行上下文环境下一个浅显的定义——在实行代码之前,把将要用到的一切的变量都事前拿出来,有的直接赋值了,有的先用undefined占个空。
this
在函数中this究竟取何值,是在函数真正被挪用实行的时刻肯定的,函数定义的时刻肯定不了。由于this的取值是实行上下文环境的一部分,每次挪用函数,都邑发生一个新的实行上下文环境。
状况1:组织函数
所谓组织函数就是用来new对象的函数。实在严格来说,一切的函数都能够new一个对象,然则有些函数的定义是为了new一个对象,而有些函数则不是。别的注重,组织函数的函数名第一个字母大写(划定规矩商定)。比方:Object、Array、Function等。
function Foo() {
this.name = "name";
this.year = "year";
console.log(this);
}
var f1 = new Foo();//Foo {name: "name", year: "year"}
Foo();//Window {external: Object, chrome: Object, document: document, lock: Object, SF: Object…}
假如函数作为组织函数用,那末个中的this就代表它行将new出来的对象。
假如直接挪用Foo函数,而不是new Foo(),这类状况下this是window。
状况2:函数作为对象的一个属性
var obj = {
x:10,
fn:function(){
console.log(this);
console.log(this.x);
}
}
var fn1 = obj.fn;
fn1();//Window {external: Object, chrome: Object, document: document, lock: Object, SF: Object…} undefined
obj.fn();//Object {x: 10} 10
fn不仅作为一个对象的一个属性,而且的确是作为对象的一个属性被挪用。效果this就是obj对象。
注重,假如fn函数不作为obj的一个属性被挪用。如上代码,假如fn函数被赋值到了另一个变量中,并没有作为obj的一个属性被挪用,那末this的值就是window,this.x为undefined。
状况3:函数用call或许apply挪用
当一个函数被call和apply挪用时,this的值就取传入的对象的值。
var obj = {
x : 1
}
var fn = function() {
console.log(this);
console.log(this.x);
}
fn.call(obj);//Object {x: 1} 1
状况4:挪用一般函数
var obj = {
x:10,
fn:function(){
console.log(this); //Object {x: 10}
console.log(this.x); //10
function f() {
console.log(this); // Window {external: Object, chrome: Object, document: document, lock: Object, SF: Object…}
console.log(this.x);//undefined
}
f();
}
}
obj.fn();
函数f虽然是在obj.fn内部定义的,然则它依然是一个一般的函数,this依然指向window。
简介【作用域】
你光晓得“javascript没有块级作用域”是完整不够的,你须要晓得的是——javascript除了全局作用域以外,只要函数能够建立的作用域。
所以,我们在声明变量时,全局代码要在代码前端声明,函数中要在函数体一最先就声明好。除了这两个处所,其他处所都不要涌现变量声明。而且发起用“单var”情势。
jQuery源码的最外层是一个自动实行的匿名函数:
为何要如许做呢?
缘由就是在jQuery源码中,声清楚明了大批的变量,这些变量将经由过程一个函数被限定在一个自力的作用域中,而不会与全局作用域或许其他函数作用域的同名变量发生争执。
全球的开发者都在用jQuery,假如不如许做,极可能致使jQuery源码中的变量与外部javascript代码中的变量重名,从而发生争执。
闭包
然则你只须要晓得运用的两种状况即可——函数作为返回值,函数作为参数通报。
function fn(){
var max = 10;
return function bar(x){
if(x > max) {
console.log(x);
}
};
}
var f1 = fn();
f1(15);//15
如上代码,bar函数作为返回值,赋值给f1变量。实行f1(15)时,用到了fn作用域下的max变量的值。
第二,函数作为参数被通报
var max = 10;
fn = function(x){
if(x > max) {
console.log(x);
}
};
(function(f) {
var max = 100;
f(15);//15
})(fn);
如上代码中,fn函数作为一个参数被通报进入另一个函数,赋值给f参数。实行f(15)时,max变量的取值是10,而不是100。
自在变量跨作用域取值时,要去建立这个函数的作用域取值,而不是“父作用域”。
当一个函数被挪用完成以后,实在行上下文环境将被烧毁,个中的变量也会被同时烧毁。然则有些状况下,函数挪用完成以后,实在行上下文环境不会接着被烧毁。这就是须要明白闭包的核心内容。
关于这个例子
function fn(){
var max = 10;
return function bar(x){
if(x > max) {
console.log(x);
}
};
}
var f1 = fn();
max = 100;
f1(15);//15
fn()挪用完成。按理说应当烧毁掉fn()的实行上下文环境,然则这里不能这么做。注重,重点来了:由于实行fn()时,返回的是一个函数。函数的特别之处在于能够建立一个自力的作用域。而正偶合的是,返回的这个函数体中,另有一个自在变量max要援用fn作用域下的fn()上下文环境中的max。因而,这个max不能被烧毁,烧毁了以后bar函数中的max就找不到值了。
总结:随着大牛的文章,随着明白,随着写代码,终究把闭包明白了。然则,理论是学到了,真正用的时刻还得要多思索。这类逻辑的碰撞就是程序员向前最大的勉励。感谢大牛。
写给本身的话:过早地最先关注细节,你极可能错失上下文或团体信息。固然,错失了细节,也会让你的明白仅仅停留在一些事物的外表。