关于javascript：方法与功能，以及其他问题


Method vs Functions, and other questions

至于JS，两者有什么区别？我知道方法与对象相关联，但是我很困惑函数的用途是什么？它们的语法有什么不同？

另外，这两种语法有什么区别：

1
2
3
var myFirstFunc = function(param) {
    //Do something
};

和

1
2
3
function myFirstFunc(param) {
    //Do something
};

另外，我在某个地方看到，在使用函数之前，我们需要做类似的事情：

1
2
obj.myFirstFunc = myFirstFunc;
obj.myFirstFunc("param");

为什么需要第一行，它做什么？

抱歉，如果这些是基本问题，但是我从JS开始，并感到困惑。

编辑：对于最后一点代码，这就是我要说的：

1
2
3
4
5
6
7
8
9
// here we define our method using"this", before we even introduce bob
var setAge = function (newAge) {
  this.age = newAge;
};
// now we make bob
var bob = new Object();
bob.age = 30;
// and down here we just use the method we already made
bob.setAge = setAge;
相关讨论

回答你的题目问题，"函数"和"方法"的区别是什么。

它是语义学的，与你想要表达的内容有关。

在javascript中，每个函数都是一个对象。对象是key:value对的集合。如果值是基元(整数、字符串、布尔值)或其他对象，则该值被视为属性。如果值是函数，则称为"方法"。

在对象的范围内，函数被称为该对象的方法。它是从对象命名空间"myobj.themethod()"调用的。因为我们说一个函数是一个对象，所以函数中的一个函数被认为是该函数的一种方法。你可以说我将使用对象的save方法。或者可以说，"save方法接受函数作为参数"。但一般不会说函数接受一个方法作为参数。

顺便说一句，StoyanStefanov的书javascript模式详细介绍了您的问题，如果您真的想了解该语言，我强烈建议您这样做。这是这本书对这个问题的引述。

So it could happen that a function A, being an object, has properties and methods, one
of which happens to be another function B. Then B can accept a function C as an
argument and, when executed, can return another function D.

相关讨论

有点不同-

方法：当对象与其关联时，方法是一个函数。

1
2
3
4
5
var obj = {
name :"John snow",
work : function someFun(paramA, paramB) {
    // some code..
}

函数：当没有对象与之关联时，它就进入函数。

1
2
3
function fun(param1, param2){
// some code...
}

方法是值为函数的对象的属性。方法按以下格式对对象调用：object.method()。

//这是一个名为developer的对象

1
2
3
4
5
6
7
8
9
 const developer = {
  name: 'Andrew',
  sayHello: function () {
    console.log('Hi there!');
  },
  favoriteLanguage: function (language) {
    console.log(`My favorite programming language is ${language}`);
  }
};

//FavoriteLanguage:和SayHello:和Name:都是名为Developer的对象中的专有项

现在假设您需要调用FavoriteLanguageProprityWitch，它是对象内部的一个函数。

你这样称呼它

1
2
3
developer.favoriteLanguage('JavaScript');

// My favorite programming language is JavaScript'

所以我们把它命名为：developer.favoriteLanguage('javascript')；它不是一个函数，它不是一个对象？那是什么？它的一种方法

第一行是创建一个引用函数的对象。您可以这样引用它：

1
myFirstFunc(param);

但您可以将其传递给另一个函数，因为它将返回如下函数：

1
2
function mySecondFunction(func_param){}
mySecondFunction(myFirstFunc);

第二行只创建了一个名为myFirstFunc的函数，它的引用方式如下：

1
myFirstFunc(param);

并且在范围上受到限制，这取决于声明的位置，如果声明超出了任何其他功能，则它属于全局范围。但是，您可以在另一个函数中声明一个函数。然后，该函数的范围仅限于其内部声明的函数。

1
2
3
function functionOne(){
    function functionTwo(){}; //only accessed via the functionOne scope!
}

最后的示例是创建函数的实例，然后通过对象参数引用这些实例。因此：

1
2
3
4
5
6
function myFirstFunc(param){};

obj.myFirst = myFirstFunc(); //not right!
obj.myFirst = new myFirstFunc(); //right!

obj.myFirst('something here'); //now calling the function

表示您有一个引用函数实例的对象。这里的关键是，如果函数改变了您存储在obj.myFirst中的引用，则不会改变。

虽然@kevin基本上是正确的，但是在JS中只有函数可以创建更像方法的函数，而不是函数，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function player(){

    this.stats = {
        health: 0,
        mana: 0,

        get : function(){
            return this;
        },

        set : function( stats ){
            this.health = stats.health;
            this.mana = stats.mana;
        }  
}

然后你可以打电话给player.stats.get()，它会把heath和mana的价值还给你。因此，在本例中，我认为get和set是player.stats对象的方法。

相关讨论

许多答案都是这样说的：当一个函数在一个对象上定义时，方法就是它被调用的东西。

虽然人们通常在谈论JavaScript或面向对象编程时使用这个词的方式(见此处)，但值得注意的是，在ES6中，术语method具有非常具体的含义(见第14.3节规范的方法定义)。

方法定义

方法(严格意义上)是通过对象文本中的简明方法语法或类声明/表达式中的类方法定义的函数：

1
2
3
4
5
6
7
8
9
// In object literals:
const obj = {
    method() {}
};

// In class declarations:
class MyClass {
    method() {}
}

方法特异性

这个答案对方法的特殊性(严格意义上)给出了很好的概述，即：

  • 方法被分配一个内部的[[HomeObject]]属性，该属性允许它们使用super。
  • 方法不是用prototype属性创建的，也没有内部[[Construct]]方法，这意味着不能用new调用它们。
  • 方法的名称不会成为方法作用域中的绑定。

    • 以下是一些示例，说明了方法(严格意义上)与通过函数表达式在对象上定义的函数之间的区别：

    例1

    1
    2
    3
    4
    5
    6
    7
    8
    const obj = {
        method() {
            super.test;         // All good!
        },
        ordinaryFunction: function ordinaryFunction() {
            super.test;         // SyntaxError: 'super' keyword unexpected here
        }
    };

    例2

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    const obj = {
        method() {},
        ordinaryFunction: function ordinaryFunction() {}
    };

    console.log( obj.ordinaryFunction.hasOwnProperty( 'prototype' ) );  // true
    console.log( obj.method.hasOwnProperty( 'prototype' ) );            // false

    new obj.ordinaryFunction();     // All good !
    new obj.method();               // TypeError: obj.method is not a constructor

    例3

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    const obj = {
        method() {
            console.log( method );
        },
        ordinaryFunction: function ordinaryFunction() {
            console.log( ordinaryFunction );
        }
    };

    obj.ordinaryFunction()  // All good!
    obj.method()            // ReferenceError: method is not defined

    函数执行语句列表示例：

    1
    2
    3
    4
    5
    6
     function add() {
         var a = 2;
         var b = 3;
         var c = a + b;
         return c;
     }

    1)方法是应用于对象示例的函数：

    1
    2
     var message ="Hello world!";
     var x = message.toUpperCase(); // .toUpperCase() is a built in function

    2)使用对象构造函数创建方法。一旦方法属于对象，您就可以将其应用于该对象。例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    function Person(first, last, age, eyecolor) {
        this.firstName = first;
        this.lastName = last;
        this.age = age;
        this.eyeColor = eyecolor;
        this.name = function() {return this.firstName +"" + this.lastName;};
    }

    document.getElementById("demo").innerHTML = person.fullName(); // using the
    method

    方法的定义：方法是作为函数的对象的属性。方法的定义方式与普通函数的定义方式相同，只是必须将它们指定为对象的属性。

    1
    2
    3
    var myFirstFunc = function(param) {
        //Do something
    };

    和

    1
    2
    3
    function myFirstFunc(param) {
        //Do something
    };

    几乎完全相同。第二种(通常)只是速记。但是，正如这个jsfiddle(http://jsfiddle.net/cu2sy/)所显示的那样，function myFirstFunc将在输入封闭范围后立即定义函数，而myFirstFunc = function将仅在执行到达该行时创建函数。

    至于方法，他们有一个this参数，这是当前的对象，所以：

    1
    2
    3
    4
    5
    6
    7
    8
    var obj = {};
    obj.func = function( ) {
        // here,"this" is obj
        this.test = 2;
    }
    console.log( obj.test ); // undefined
    obj.func( );
    console.log( obj.test ); // 2

    您显示的确切语法是因为您也可以这样做：

    1
    2
    3
    4
    5
    6
    function abc( ) {
        this.test = 2;
    }
    var obj = {};
    obj.func = abc;
    obj.func( ); // sets obj.test to 2

    但你不应该没有充分的理由。

    相关讨论