函数是JavaScript中很重要的一个语言元素，并且提供了一个function关键字和内置对象Function，下面是其可能的用法和它们之间的关系。
function使用方式
var foo01 = function() //或 function foo01() { var temp = 100; this.temp = 200; return temp + this.temp; } alert(typeof(foo01)); // function alert(foo01()); // 300
最普通的function使用方式，定一个JavaScript函数。两种写法表现出来的运行效果完全相同，唯一的却别是后一种写法有较高的初始化优先级。在大扩号内的变量作用域中，this指代foo01的所有者，即window对象。
new function()使用方式
var foo02 = new function() { var temp = 100; this.temp = 200; return temp + this.temp; } alert(typeof(foo02)); //object alert(foo02.constructor()); //300
//等价于
var temp = function() {
var temp = 100;
this.temp = 200;
return temp + this.temp;
}
var foo02 = new temp(); //没有形参，可以省略圆括号 var foo02 = new temp;
alert(typeof(foo02)); //object
alert(foo02.constructor()); //300
这是一个比较puzzle的function的使用方式，好像是定一个函数。但是实际上这是定一个JavaScript中的用户自定义对象，不过这里是个匿名类。这个用法和函数本身的使用基本没有任何关系，在大扩号中会构建一个变量作用域，this指代这个作用域本身。（理解为实例化匿名类）
new Function()使用方式
var foo3 = new Function('var temp = 100; this.temp = 200; return temp + this.temp;'); alert(typeof(foo3)); //object alert(foo3()); //300
使用系统内置函数对象来构建一个函数，这和方法一中的第一种方式在效果和初始化优先级上都完全相同，就是函数体以字符串形式给出。
Function()使用方式
var foo4 = Function('var temp = 100; this.temp = 200; return temp + this.temp;'); alert(typeof(foo4)); //function alert(foo4()); //300
这个方式是不常使用的，效果和方法三一样，不过不清楚不用new来生成有没有什么副作用，这也体现了JavaScript一个最大的特性：灵活！能省就省。（不推荐）
注：如果构造函数没有形参，javascript构造函数调用的语法是允许省略实参列表和圆括号的。凡是没有形参的构造函数调用都可以省略圆括号
var o = new Object(); //等价于 var o = new Object;
-------------华丽的分割线-------------
javascript在用到对象时，完全没有类的概念，但是编程的世界里，无奇不有，我们却可以通过function构造出一种假想的类，从而实现javascript中类的构造。
比如，我们通过下面的方法来构造一个类：
//java class Book { private String name; private double price; public Book(name,price) {this.name=name;this.price=price;} public void setName(String name) { this.name = name;} public void setPrice(double price) {this.price = price;} public String getInfo() {...} } Book book1 = new Book('java',13.3); //javascript function Book(name,price) { this.name = name; this.price = price; this.setName = function(name) {this.name = name;}; this.setPrice = function(price) {this.price = price}; this.getInfo = function() {return this.name + ' ' + this.price;}; } var book1 = new Book('java',13.3);
Function是由function关键字定义的函数对象的原型
在javascript中，多出了一个原型的概念。所谓原型，其实就是一个对象的本质，但复杂就复杂在，原型本身也是对象，因此，任何一个对象又可以作为其他对象的原型。Function就相当于一个系统原型，可以把它理解为一种“基本对象类型”，是“对象”这个概念范畴类的基本数据类型。除了Function之外，其实还有很多类似的首字母大写的对象原型，例如Object, Array, Image等等。有一种说法是：javascript中所有的一切都是对象（除了基本数据类型，其他的一切全是对象），所有的对象都是Object衍生出来的。
极其重要的prototype概念
prototype的概念在javascript中极其重要，它是javascript中完成上面说的“一切皆对象”的关键。有了prototype，才有了原型，有了原型，才有了javascript五彩缤纷的世界（当然，也有人说是杂乱的）。我们可以这样去理解prototype：世界上本没有javascript，上帝说要有Object，于是有了Object，可是要有Function怎么办？只需要对Object进行扩展，可是如何扩展？只需要用prototype……当然，这是乱扯的，不过在javascript中，只要是function，就一定会有一个prototype属性。实际上确实是这样
1 Function.prototype.show = function() {...}
在原型的基础上通过prototype新增属性或方法，则以该对象为原型的实例化对象中，必然存在新增的属性或方法，而且它的内容是静态不可重载的。原型之所以被称为原型，可能正是因为这种不可重载的特质。
比如上面的这段代码，会导致每一个实例化的function，都会具备一个show方法。而如果我们自己创建了一个类，则可以通过prototype将之转化为原型：
function Book(name,price) { this.name = name; this.price = price; this.setName = function(name) {this.name = name;}; this.setPrice = function(price) {this.price = price}; this.getInfo = function() {return this.name + ' ' + this.price;}; } Book.prototype.run = function(price) {console.log(this.price)}; var book1 = new Book('java',13.3); book1.run();
这时，对于book1而言，Book就是原型，而该原型拥有一个run的原始方法，所以无论实例化多少个Book，每一个实例化对象都有run方法，而且该方法是不能被重载的，通过book1.run = function(){}是无效的。
为了和其他语言的类的定义方法统一，我们可以将这种原型属性在定义类的时候，写在类的构造里面：
function Book(name,price) { this.name = name; this.price = price; this.setName = function(name) {this.name = name;}; this.setPrice = function(price) {this.price = price}; this.getInfo = function() {return this.name + ' ' + this.price;}; Book.prototype.run = function(price) {console.log(this.price)}; //写在类的构造里面 } //Book.prototype.run = function(price) {console.log(this.price)}; var book1 = new Book('java',13.3); book1.run();
new Function()是函数原型的一个实例化
在理解了Function原型的概念之后，再来看new Function()就显得很容易了。首先来看下我们是怎么使用这种奇特的写法的：
var log=new Function('log','console.log(log)'); log('hello javascript'); //hello javascript 其实等价于 function log(log){ console.log(log); } log('hello javascript');//hello javascript
new Function(参数1,参数2,…,参数n,函数体)，它的本意其实是通过实例化一个Function原型，得到一个数据类型为function的对象，也就是一个函数，而该变量(log)就是函数名(理解为：new Function实例化一个Function原型，得到 一个匿名函数 ，然后赋值给变量log)。
this在这类function中的指向
this在javascript中真的是无法让我们捉摸透彻。但是有一个小窍门，就是：一般情况下，this指向的是当前实例化对象，如果没有找到该对象，则是指向window。从使用上来讲，我们应该排除new Function的讨论，因为它和我们常用的函数声明是一致的。
普通的函数中this的指向
函数声明的时候，如果使用了this，那么就要看是把该函数当做一个对象加以返回，还是以仅执行函数体。普通函数执行时，我们完全没有引入对象、类这些概念，因此，this指向window。通过代码来看下：
var msg; function message(msg) { this.msg = msg; } message('ok'); alert(msg);
首先是声明一个函数message，在函数中this.msg实际上就是window.msg，也实际上就是代码开头的msg。因此，当执行完message(‘ok’)的时候，开头的全局变量msg也被赋值为ok。
通过function构造类时this的指向
如果function被构造为一个类，那么必然存在该类被实例化的一个过程，如果没有实例化，那么该类实际上并没有在程序中被使用。而一旦实例化，那么this将指向实例化的对象。
var age = 3; var cat1 = new function() { this.name = 'Tom'; this.age = 2; this.weight = function(age) { var age = age * 2; var _age = this.age * 2; return 'weight by age:' + age + '; weight by this.age:' + _age; }(this.age); this.eye = new function() { this.size = '1.5cm'; this.color = 'red'; }; this.catching = function(mouse) { return this.name + ' is catching ' + mouse; }; }; alert(cat1.weight); alert(cat1.eye.color); alert(cat1.catching('Jerry'));
上面代码中标记了4处红色的this的使用。根据我们的原则，this指向实例化对象，我们来对每一个this进行分解。
首先是cat1.weight，我使用了function(){}()，直接利用猫咪的年龄进行计算得出体重返回给weight属性。
第一个this.age出现在function(){}(this.age)，这个this.age实际上是一个传值过程，如果你对我之前分析function(){}()比较了解的话，应该知道，this.age实际上是和前面this.age = 2指同一个，这里的this.age的this，首先要去找它所在的function，然后看这个function是否被实例化，最后确认，确实被实例化为cat1，因此this=cat1。
第二个this.age出现在function(){this.age}()。同样，你先需要对function(){}()再次深入了解，实际上，function(){}()就是执行一个函数而已，我们前面提到了，普通函数执行中this=window，所以，这里的this.age实际上是var age = 3。
第三个this.color出现在new function(){this.color}，这里就比较好玩，由于有一个new，实际上也被实例化了，只不过是对匿名类的实例化，没有类名，而且实例化仅可能出现这一次。因此，this.color的this要去找new function的主人，也就是this.eye，而this.eye的this=cat1，所以cat1.eye.color=’red’。
第四个this.name出现在function(){this.name}，它出现在cacthing方法中，它既不是普通的函数执行，也不是实例化为对象，而是正常的类中的方法的声明，因此this指向要去找它所在的function被实例化的对象，也就是cat1。
小结
本文虽然讲了很多，但核心点实际上还是落在javascript的面向对象这个点上。javascript中虽然没有明确的class的概念，那是因为它首先基于type这样的基础概念，并强调一切皆对象的这种思想。如果从哲学上讲，javascript真正符合道生一，一生二，二生万物的原则。不过本文没有提到和继承相关的内容，所有解释也是我自己的一种理解方式，不代表真正的原理，读者请自己通过其他途径进行学习。
下篇转载自：https://www.cnblogs.com/pizitai/p/6427433.html