你正在使用的浏览器版本过低，将不能正常浏览和使用知乎。3343人阅读
常用写法：
function add(a,b)
&&&& return&& a +
alert(add(1,2));&&&&&&& // 结果 3
当我们这么定义函数的时候，函数内容会被编译（但不会立即执行，除非我们去调用它）。而且，也许你不知道，当这个函数创建的时候有一个同名的对象也被创建。就我们的例子来说，我们现在有一个对象叫做“add”（要更深入了解，看底下函数：对象节。）
匿名函数：
我们也可以通过指派一个变量名给匿名函数的方式来定义它。
var& add = function(a,b)
&&&&& return&& a +
alert(add(1,2));&&&&&&& // 结果 3
这个代码和前一个例子做了同样的事情。也许语法看起来比较奇怪，但它应该更能让你感觉到函数是一个对象，而且我们只是为这个对象指派了一个名称。可以把它看做和 var myVar=[1,2,3]一样的语句。以这种方式声明的函数内容也一样会被编译。
当我们指派一个这样的函数的时候，我们并不一定要求必须是匿名函数。在这里，我作了和以上一样的事情，但我加了函数名“theAdd”，而且我可以通过调用函数名或者是那个变量来引用函数。
var& add = function theAdd(a,b)
&&&&& return a +
alert(add(1,2));&&&&&&&&&& // 结果 3
alert(theAdd(1,2));&&&&&&& // 结果也是 3
使用这种方式来定义函数在面向对象编程中是很有用的，因为我们能像底下这样使一个函数成为一个对象的属性。
var myObject = new Object();
myObject.add = function(a,b){return a+b};
// myObject 现在有一个叫做“add”的属性（或方法）”
// 而且我能够象下面这样使用它
myObject.add(1, 2);
函数：对象
函数是javascript中的一种特殊形式的对象。它是第一个[b〕类数据类型（classdata type）。这意味着我们能够给它增加属性。这里有一些需要注意的有趣观点
对象的创建
就像刚才提及的，当我们定义一个函数时，javascript实际上在后台为你创建了一个对象。这个对象的名称就是函数名本身。这个对象的类型是function。在下面的例子，我们也许不会意识到这一点，但我们实际上已经创建了一个对象：它叫做Ball。
function ball()&&&& // 也许看起来有点奇怪，但是这个声明
{&&&&&&&&&&&&&&&&&&&&&&&&& // 创建了一个叫做Ball的对象
&&&& i = 1;
alert(typeof ball);&&&& // 结果 &function&
我们甚至能将这个对象的内容打印出来而且它会输出这个函数的实际代码
alert(ball);&&
//结果为：
//function ball()
//&&&& i = 1;
属性的添加
我们能够给Object添加属性，包括对象function。因为定义一个函数的实质是创建一个对象。我们能够“暗地里”给函数添加属性。比如，我们这里定义了函数Ball，并添加属性callsign。
function Ball()&&&& // 也许看起来有点奇怪，但是这个声明创建了一个叫做Ball的对象，而且你能够引用它或者象下面那样给它增加属性
{&&&&&&&&&&&&&&&&&&&
ball.callsign=&The ball&; // 给Ball增加属性
alert(ball.callsign); // 输出 &The ball&
因为function是一个对象，我们能够为一个function分配一个指针。如下例，变量ptr指向了对象myFunction。
function myFunction(message)
alert(message);
var ptr=myF // ptr指向了myFunction
ptr(&hello&);&&&&&&&& // 这句会执行myFunction：输出&hello&
我们能够运行这个函数，就好像这个函数名已经被指针名代替了一样。所以在上面，这行ptr(&hello&); 和myFunction(&hello&);的意义是一样的。
指向函数的指针在面向对象编程中相当有用。例如：当我们有多个对象指向同一个函数的时候（如下）：
function sayName(name)
alert(name);
var object1=new Object();&&&&& // 创建三个对象
var object2=new Object();
var object3=new Object();
object1.sayMyName=sayN&&&&&& // 将这个函数指派给所有对象
object2.sayMyName=sayN
object3.sayMyName=sayN
object1.sayMyName(&object1&);&&& // 输出 &object1&
object2.sayMyName(&object2&);&&& // 输出 &object2&
object3.sayMyName(&object3&);&&& // 输出 &object3&
因为只有指针被保存（而不是函数本身），当我们改变函数对象自身的时候，所有指向那个函数的指针都会发生变化。我们能够在底下看到：
function myFunction()
alert(myFunction.message);
myFunction.message=&old&;
var ptr1=myF&&&&&&&&&&&&&&&& // ptr1 指向 myFunction
var ptr2=myF&&&&&&&&&&&&&&&& // ptr2 也指向 myFunction
ptr1();&&&&&&&&&&&&&&&&&&&& // 输出 &old&
ptr2();&&&&&&&&&&&&&&&&&&&&&&&&&&&&& // 输出 &old&
myFunction.message=&new&;
ptr1();&&&&&&&&&&&&&&&&&&&& // 输出 &new&
ptr2();&&&
指针的指向
我们能够在一个函数创建之后重新分配它，但是我们需要指向函数对象本身，而不是指向它的指针。在下例中，我将改变myfunction()的内容。
function myFunction()
alert(&Old&);
myFunction(); // 输出 &Old&
myFunction=function()
alert(&New&);
myFunction(); // 输出 &New&
旧函数哪里去了？？被抛弃了。
如果我们需要保留它，我们可以在改变它之前给它分配一个指针。
function myFunction()
alert(&Old&);
var savedFuncion=myF
myFunction=function()
alert(&New&);
myFunction();&&& // 输出 &New&
savedFuncion(); // 输出 &Old&
function& get(a,b,c)
&&&&& function cal(n)
&&&&&&&&&&& return& n/2;
&&&&& var result = “”;
&&&&& result+=cal(a)+” ”;
&&&&& result+=cal(b)+” ”;
&&&&& result+=cal(c);
var resultString = get(10,20,30);
alert(resultString);&&&& // 输出 &5 10 15&
你只能在内部调用嵌套的函数。就是说，你不能这么调用：
getHalfOf.calculate(10)，因为calculate只有当外部函数(getHalfOf())在运行的时候才会存在。这和我们前面的讨论一致（函数会被编译，但只有当你去调用它的时候才会执行）。
调用哪个函数？
你也许正在想命名冲突的问题。比如，下面哪一个叫做calculate的函数会被调用？
function calculate(number)
&&&&&&& return number/3;
function getHalfOf(num1, num2, num3)&&&&
&&&&&&& function calculate(number)
&&&&&&&&&&&& return number/2;
&&&&&&& var result=&&;
&&&&&&& result+=calculate(num1)+& &;
&&&&&&& result+=calculate(num2)+& &;
&&&&&&& result+=calculate(num3);
var resultString=getHalfOf(10,20,30);
alert(resultString);&&&&&&&& // 输出 &5 10 15&
在这个例子中，编译器会首先搜索局部内存地址，所以它会使用内嵌的calculate函数。如果我们删除了这个内嵌（局部）的calculate函数,这个代码会使用全局的calculate函数。
函数：数据类型及构造函数
让我们来看看函数的另一个特殊功能－－这让它和其它对象类型截然不同。一个函数能够用来作为一个数据类型的蓝图。这个特性通常被用在面向对象编程中来模拟用户自定义数据类型(user defined data type)。使用用户自定义数据类型创建的对象通常被成为用户自定义对象(user defined object)。
在定义了一个函数之后，我们也同时创建了一个新的数据类型。这个数据类型能够用来创建一个新对象。下例，我创建了一个叫做Ball的新数据类型。
function Ball()
var ball0=new Ball(); // ball0 现在指向一个新对象
alert(ball0);&&&&&&&& // 输出 &Object&，因为 ball0 现在是一个对象
这样看来，ball0=new Ball()作了什么？new关键字创建了一个类型是Object的新对象（叫做ball0）。然后它会执行Ball()，并将这个引用传给ball0（用于调用对象）。下面，你会看到这条消息：“creating new Ball”，如果Ball()实际上被运行的话。
function Ball(message)
alert(message);
var ball0=new Ball(&creating new Ball&); // 创建对象并输出消息
ball0.name=&ball-0&;&&&&&&&&&&&&&&&&&&&&& // ball0现在有一个属性：name
alert(ball0.name);&&&&&&&&&&&&&&&&&&&&&&& // 输出 &ball-0&
我们可以把上面这段代码的第6行看做是底下的代码6-8行的一个简写：
function Ball(message)
alert(message);
var ball0=new Object();
ball0.construct=B
ball0.construct(&creating new ball&); // 执行 ball0.Ball
(&creating..&);
ball0.name=&ball-0&;&&&&&&&&&&&&&&&&&&&&
alert(ball0.name);&
这行代码ball0.construct=Ball和以上中的ptr=myFunction语法一致。
当我们象上面那样使用关键字new创建一个对象的时候，一个新的Object被创建了。我们可以在创建之后给这个对象添加属性（就好像我在上面那样添加属性name。而接下来的问题就是如果我们创建了这个对象的另外一个实例，我们得象下面那样再次给这个新对象添加这个属性。）
function Ball()
var ball0=new Ball(); // ball0 现在指向了类型Ball的一个新实例
ball0.name=&ball-0&; // ball0 现在有一个属性&name&
var ball1=new Ball();
ball1.name=&ball-1&;
var ball2=new Ball();
alert(ball0.name);&&& // 输出 &ball-0&
alert(ball1.name);&&& // 输出 &ball-1&
alert(ball2.name);&&& // 哦，我忘记给ball2添加“name”了！
我忘记给ball2添加属性name了，如果在正式的程序中这也许会引发问题。有什么好办法可以自动增加属性呢？嗯，有一个：使用this关键字。this这个词在function中有特别的意义。它指向了调用函数的那个对象。让我们看看下面的另一个示例，这时候我们在构造函数中添加上这些属性：
function Ball(message, specifiedName)
alert(message);
this.name=specifiedN&&&&&&&&&&&&&&
var ball0=new Ball(&creating new Ball&, &Soccer Ball&);
alert(ball0.name);&&&&&&&&&&&&&&&&&& // prints &Soccer Ball&
请记住：是new关键字最终使得构造函数被执行。在这个例子中，它将会运行Ball(&creating new Ball&, &Soccer Ball&);而关键字this将指向ball0。
因此，这行：this.name=specifiedName变成了ball0.name=&Soccer Ball&。它主要是说：给ball0添加属性name，属性值是Soccer Ball。
我们现在只是添加了一个name属性给ball0，看起来和上一个例子中所做的很象，但却是一个更好更具扩展性的方法。现在，我们可以随心所欲的创建许多带有属性的ball而无需我们手动添加它们。而且，人们也希望创建的Ball对象能够清晰的看懂它的构造函数并且能够轻松找出Ball的所有属性。让我们添加更多属性到Ball里。
function Ball(color, specifiedName, owner, weight)
this.name=specifiedN&&&&&&&&&&&&&&
this.color=
this.owner=
this.weight=
var ball0=new Ball(&black/white&, &Soccer Ball&, &John&, 20);
var ball1=new Ball(&gray&, &Bowling Ball&, &John&, 30);
var ball2=new Ball(&yellow&, &Golf Ball&, &John&, 55);
var balloon=new Ball(&red&, &Balloon&, &Pete&, 10);
alert(ball0.name);&&&&&&&&&&&&&&&&&&&&&&& // 输出 &Soccer Ball&
alert(balloon.name);&&&&&&&&&&&&&&&&&&&&& // 输出 &Balloon&
alert(ball2.weight);&&&&&&&&&&&&&&&&&&&&& // 输出 &55&
嘿！使用面向对象术语，你能够说Ball是一个拥有如下属性的对象类型：name,color, owner, weight。
将对象赋给属性我们并没被限制只能添加形如字符串或者数字之类的简单数据类型作为属性。我们也能够将对象赋给属性。下面，supervisor是Employee的一个属性.
function Employee(name, salary, mySupervisor)
this.name=&&&&&&&&&&&&&&
this.salary=
this.supervisor=myS
var boss=new Employee(&John&, 200);
var manager=new Employee(&Joan&, 50, boss);
var teamLeader=new Employee(&Rose&, 50, boss);
alert(manager.supervisor.name+& is the supervisor of &+manager.name);
alert(manager.name+&\'s supervisor is &+manager.supervisor.name);
函数也是一个对象。所以你可以让一个函数作为一个对象的一个属性。下面，我将添加两个函数getSalary和addSalary。
function Employee(name, salary)
this.name=&&&&&&&&&&&&&&
this.salary=
this.addSalary=addSalaryF
this.getSalary=function()
&&&&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&& return this.
&&&&&&&&&&&&&&&& };
function addSalaryFunction(addition)
this.salary=this.salary+
var boss=new Employee(&John&, 200000);
boss.addSalary(10000);&&&&&&&&&&&&&&&&&&& // boss 长了 10K 工资……为什么老板工资可以长这么多:'(
alert(boss.getSalary());&&&&&&&&&&&&&&&&& // 输出 210K……为什么默认工资也那么高……:'(
addSalary和getSalary演示了几种将函数赋给属性的不同方法。
如前面数次提到的，一个函数声明的结果是一个对象 被创建。
function Employee(name, salary)
this.name=&&&&&&&&&&&&&&
this.salary=
this.addSalary=addSalaryF
this.getSalary=function()
&&&&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&& return this.
&&&&&&&&&&&&&&&& };
function addSalaryFunction(addition)
this.salary=this.salary+
var boss=new Employee(&John&, 200000);
var boss2=new Employee(&Joan&, 200000);
var boss3=new Employee(&Kim&, 200000);
当你创建这个对象的更多实例时(boss2和boss3),每一个实例都有一份getSalary代码的单独拷贝；而与此相反，addSalary则指向了同一个地方(即addSalaryFunction)。
看看下面的代码来理解一下上面所描述的内容。
function Employee(name, salary)
this.name=&&&&&&&&&&&&&&
this.salary=
this.addSalary=addSalaryF
this.getSalary=function()
&&&&&&&&&&&&&&&& {
&&&&&&&&&&&&&&&&&& return this.
&&&&&&&&&&&&&&&& };
function addSalaryFunction(addition)
this.salary=this.salary+
var boss1=new Employee(&John&, 200000);
var boss2=new Employee(&Joan&, 200000);
// 给getSalary函数对象添加属性
boss1.getSalary.owner=&boss1&;
boss2.getSalary.owner=&boss2&;
alert(boss1.getSalary.owner);&& // 输出 &boss1&
alert(boss2.getSalary.owner);&& // 输出 &boss2&
// 如果两个对象指向同一个函数对象，那么 上面两个输出都应该是“boss2”。
// 给addSalary函数对象添加属性
boss1.addSalary.owner=&boss1&;
boss1.addSalary.owner=&boss2&;
alert(boss1.addSalary.owner);&& // 输出 &boss2&
alert(boss2.addSalary.owner);&& // 输出 &boss2&
// 因为两个对象都指向同一个函数
// 当修改其中一个的时候，会影响所有的实例（所以两个都输出“boss2”）.
也许不是重要的事情，但这里有一些关于运行类似上面的getSalary的内嵌函数的结论：
1) 需要更多的存储空间来存储对象（因为每一个对象实例都会有它自己的getSalary代码拷贝）；
2) javascript需要更多时间来构造这个对象。
让我们重新写这个示例来让它更有效率些。
function Employee(name, salary)
this.name=&&&&&&&&&&&&&&
this.salary=
this.addSalary=addSalaryF
this.getSalary=getSalaryF
function getSalaryFunction()
return this.
function addSalaryFunction(addition)
this.salary=this.salary+
看这儿，两个函数都指向同一个地方，这将会节约空间和缩短构造时间（特别是当你有一大堆内嵌函数在一个构造函数的时候）。这里有另外一个函数的功能能够来提升这个设计，它叫做prototype，而我们将在下一节讨论它。
函数：原型
每一个构造函数都有一个属性叫做原型(prototype,下面都不再翻译，使用其原文)。这个属性非常有用：为一个特定类声明通用的变量或者函数。
prototype的定义
你不需要显式地声明一个prototype属性，因为在每一个构造函数中都有它的存在。你可以看看下面的例子：
function Test()
alert(Test.prototype); // 输出 &Object&
给prototype添加属性
就如你在上面所看到的，prototype是一个对象，因此，你能够给它添加属性。你添加给prototype的属性将会成为使用这个构造函数创建的对象的通用属性。
例如，我下面有一个数据类型Fish，我想让所有的鱼都有这些属性：
livesIn=&water&和price=20；为了实现这个，我可以给构造函数Fish的prototype添加那些属性。
function Fish(name, color)
this.name=
this.color=
Fish.prototype.livesIn=&water&;
Fish.prototype.price=20;
接下来让我们作几条鱼：
var fish1=new Fish(&mackarel&, &gray&);
var fish2=new Fish(&goldfish&, &orange&);
var fish3=new Fish(&salmon&, &white&);
再来看看鱼都有哪些属性：
for (int i=1; i&=3; i++)
var fish=eval(&fish&+i);&& // 我只是取得指向这条鱼的指针
alert(fish.name+&,&+fish.color+&,&+fish.livesIn+&,&+fish.price);
输出应该是：
&mackarel, gray, water, 20&
&goldfish, orange, water, 20&
&salmon, white water, 20&
你看到所有的鱼都有属性livesIn和price,我们甚至都没有为每一条不同的鱼特别声明这些属性。这时因为当一个对象被创建时，这个构造函数将会把它的属性prototype赋给新对象的内部属性__proto__。这个__proto__被这个对象用来查找它的属性。
你也可以通过prototype来给所有对象添加共用的函数。这有一个好处：你不需要每次在构造一个对象的时候创建并初始化这个函数。
用prototype给对象添加函数
function Employee(name, salary)
this.name=&&&&&&&&&&&&&&
this.salary=
Employee.prototype.getSalary=function getSalaryFunction()
return this.
Employee.prototype.addSalary=function addSalaryFunction(addition)
this.salary=this.salary+
我们可以象通常那样创建对象：
var boss1=new Employee(&Joan&, 200000);
var boss2=new Employee(&Kim&, 100000);
var boss3=new Employee(&Sam&, 150000);
并验证它：
alert(boss1.getSalary());&& // 输出 200000
alert(boss2.getSalary());&& // 输出 100000
alert(boss3.getSalary());&& // 输出 150000
这里有一个图示来说明prototype是如何工作的。这个对象的每一个实例(boss1,
boss2, boss3)都有一个内部属性叫做__proto__，这个属性指向了它的构造器
(Employee)的属性prototype。当你执行getSalary或者addSalary的时候，这个对
象会在它的__proto__找到并执行这个代码。
转载于：http://hail812./blog/static//
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：140889次
积分：1200
积分：1200
排名：千里之外
原创：11篇
转载：26篇
评论：27条
(1)(2)(1)(1)(1)(1)(1)(1)(1)(1)(1)(4)(2)(2)(1)(3)(2)(2)(1)(1)(2)(1)(3)(2)(1)(2)(2)问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
原来 JavaScript 中的函数与方法有区别的。
例如 Array 对象：
Array 对象的函数有：Array.isArray 函数。
Array 对象的方法有：concat()、join()、pop()、push() 等方法。
JS中的函数与方法怎么理解和区别？
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
你说的所谓函数是类的方法。
a = [1,2,3]
Array.isArray(a) #return true
isArray是类Array的方法
你说的所谓的方法就是类所生成对象的方法。
a = [1,2,3]
pop()是Array类所生成的对象a的方法
这里所谓的类指的是构造函数
之前写的关于函数的笔记，你可以作为个参考。
在JavaScript中，函数是Function类的具体实例。而且都与其它引用类型一样具有属性和方法。函数名实际上是指向函数对象的指针，函数可以作为参数参与到传参和返回值中。
//函数声明式定义
function foo(num1,num2){
return num1 + num2;
//函数表达式定义
var foo = function(num1,num2){
return num1 + num2;
//使用Function构造函数定义
var foo = new Function("num1","num2","return num1 + num2")；
//实际上创建一个Function实例并不一定要赋值给具体的指针，可以直接执行
(function(x,y){return x+y})(1,2);
//之所以用圆括号把function(){}括起来是因为js解释器会将function解释为函数声明，而函数声明不能直接跟着(x,y)，我们需要将其转换为函数表达式。
//(1,2)表示要传递跟函数的参数。
//上面的例子也可以写成：
function foo(x,y){
return x+y;
//函数声明的方式无法定义匿名函数，因此如果想使用匿名函数，则必须用函数表达式的定义方式。
函数的对象特性
因为函数是Function的实例，而函数名仅仅是该实例的一个引用地址。因此可以作为参数和返回值参与到函数的传参过程中。
function call_some_function(some_function, some_argument) {
return some_function(some_argument);
function add_10(num) {
return num + 10;
console.log(call_some_function(add_10,20)); //30
函数的内部属性
arguments | this
arguments对象中保存着传递给函数的参数
arguments.length返回传入参数的个数
Note: length属性表示函数定义时候默认接收的参数数量。arguments.length表示函数实际执行时接收的参数数量。
function test_arguments() {
if (arguments.length == 2) {
console.log(arguments.length);
console.log(arguments);
console.log(arguments.length);
console.log(arguments);
arguments.callee(4, 5);
}(1, 2, 3)
{ '0': 1, '1': 2, '2': 3 }
{ '0': 4, '1': 5 }
arguments.callee()主要用在递归函数中调用函数自身的情境中。js和别的语言不同在于函数名只是一个指针，可以随时变化，函数中利用函数名来调用自身属于高耦合，可能会出现问题，而arguments.callee()调用自身就会规避掉这个问题
function factorial(num) {
if (num &= 1) {
return num * factorial(num - 1);
function callee_f(num) {
if (num &= 1) {
return num * arguments.callee(num - 1);
factorial(10); //运行正常
factorial =
f(10); //error
callee_f(10); //运行正常
f = callee_f;
callee_f =
f(10); //运行正常
this主要用来帮助函数引用函数所处作用域中的对象。
var color = 'red';
function syaColor() {
console.log(this.color);
syaColor(); //red
var o = new Object();
o.color = 'blue';
o.sayColor = sayC
o.sayColor(); //blue
call()和apply()
call()和apply()是每个函数都包含的自有方法。之前已经提到了函数是定义的对象，那么调用函数时候，函数中的this是对当前与下变量的调用。而如果想改变函数执行所在域空间，则可以使用call()和apply()来实现。
color = 'red';
var o = {color: 'blue'};
function sayColor() {
console.log(this.color);
sayColor(); //red
sayColor.call(this); //red
sayColor.call(o); //blue
app()和call()的作用是相同的，区别主要在于传入参数的不同。
call(this,para1,prar2,prar3) 第一个参数是函数要执行的作用域，后面的参数是函数的输入参数，有多少个依次写多少个。
apply(this,[para1,para2,prara3])第一个参数也是函数要执行的作用域，后面是一个Array的数组对象。
使用call()/apply()来扩充作用域最大的好处是对象和方法的解耦。
Global对象可以理解成最外层的对象，所有的对象，以及不属于其它对象的属性和方法都被包含在Global对象中。
isNaN(x) 用来检查参数x是否为数字。如果为数字返回false，否则返回true
isFinite(x) 用来检查参数x是否为无穷大/小，如果是无穷大/小，则返回true
parseInt(x) 用来解析字符串并返回整数
parseFloat(x) 用来解析字符串并返回浮点数
encodeURI()和encodeURIComponent()会对字符串进行特殊的UTF-8编码，规避一些特殊字符来让浏览器能够读懂。他俩的区别主要在于encodeURI()不会对本身属于URI的特殊字符进行编码，而encodeURIComponent()会对其发现的所有非标准字符进行编码。
var uri = "/illegal value.htm#start";
///illegal%20value.htm#start
console.log(encodeURI(uri))
//http%3A%2F%%2Fillegal%20value.htm%23start
console.log(encodeURIComponent(uri))
对应的解码函数为decodeURI()和decodeURIComponent()
eval(script) 用来将script的内容在解释器中执行并返回对应的结果。非常强大！
Note:在浏览器中，windows对象封装了Global对象，并承担了很多额外的任务和功能。
Math对象为另一个内置对象。为JavaScript提供了数学计算功能。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
函数和方法是同一种东西。
面相对象叫“方法”，面相过程叫“函数”。C语言叫函数，Java叫方法。也就是习惯问题，你讲哪个，对方都能听懂。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
其实简单来说，你所说的函数可以认为是oo中的静态方法，一般来实现一些不指定某个具体对象的公用方法，其实没有啥区别，能用静态方式实现一定可以通过动态方式实现，仅仅是设计上的考虑。
剥离出公用方法或者静态方法以后，单个对象的占用的资源就少很多。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
其实方法和函数是一样的，只是叫法不一样而已。
Array其实是一个Function，是构造函数。而Function其实也是对象，所以可以在Array上添加方法（如isArray，相当于其他语言中类的静态方法）。
而concat等方法是在Array原型（可以参考汤姆大叔的）上的方法，其实例可以调用，如[].concat([1]);。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
不用分那么清，本质是一样的
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
对象的某个属性是函数时，称其为方法。When the value of a property is a function, we call it a method. To invoke the method m of an object o, we write o.m().牛书3.6节
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
可以去看一下Stack Overflow关于这个问题的讨论
简单来说：函数是一段代码，需要通过名字来进行调用。它能将一些数据（函数的参数）传递进去进行处理，然后返回一些数据（函数的返回值），也可以不返回数据。
所有传递给函数的数据都是显示传递的
方法也是一段代码，也需要通过名字来进行调用，不过方法跟一个对象相关联。方法和函数基本上是一样的，主要区别在于：
方法中的数据时隐式传递的（“ 方法在 C++ 中是被称为成员函数”。因此，在 C++ 中的“方法”和“函数”的区别，就是“成员函数”和“函数”的区别。此外，诸如 Java 一类的编程语言只有“方法”。所以这时候就是“静态方法”和“方法”直接的区别。）
方法可以操作类的内部数据（对象是类的实例化–类定义了一个数据类型，而对象是该数据类型的一个实例化）。方法可以操作已在类中声明的私有实例（成员）数据。
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
函数依附于某个对象后，就可以说成是一个对象的方法。
函数着重定义，方法强调执行。
假设有一个对象obj，他存在两个方法，fn1和fn2。
obj.fn1( obj.fn2 )
我们可以这样描述：调用obj下的fn1方法，并将传递obj中名为fn2的函数。我们在提到方法时，一般有执行的味道，方法执行的后果是有返回值。在此处代码中，obj.fn2的传递，并不表示obj.fn2被执行了，仅仅是一个函数的传递。 即：将函数作为某个方法的参数，这种用法在JS中非常常见，比如各种回调处理。
函数的宿命是被调用，被调用时一般称为执行对象的方法，当然你也可以说调用了对象的某个函数。
同步到新浪微博
分享到微博？
你好！看起来你挺喜欢这个内容，但是你还没有注册帐号。 当你创建了帐号，我们能准确地追踪你关注的问题，在有新答案或内容的时候收到网页和邮件通知。还能直接向作者咨询更多细节。如果上面的内容有帮助，记得点赞 (????)? 表示感谢。
明天提醒我
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
扫扫下载 App}