“method”是“function”的面向对象的词。这几乎就是它的全部内容（即，没有真正的区别）。

不幸的是，我认为这里的很多答案都在延续或推进存在一些复杂而有意义的差异的想法。

真的 - 它没有那么多，只是同一件事的不同词。

[后期添加]

事实上，正如Brian Neal在对这个问题的评论中指出的那样，C++标准在引用成员函数时从未使用过术语“方法”。有些人可能会认为这表明 C++ 并不是真正的面向对象语言;然而，我更愿意把它看作是一个迹象，表明一群非常聪明的人认为没有特别充分的理由使用不同的术语。

方法位于对象上或在类中是静态的。
函数独立于任何对象（并且位于任何类之外）。

对于 Java 和 C#，只有方法。
对于 C，只有函数。

对于 C++ 和 Python，这取决于你是否在一个班级中。 但在基本的英语中
：

• 功能：独立特性或功能。
• 方法：一种做某事的方法，它有不同的方法或方法，但与同一方面相关（又名类）。

方法是类的函数。用普通的行话来说，人们到处交换方法和功能。基本上，您可以将它们视为同一事物（不确定全局函数是否称为方法）。

http://en.wikipedia.org/wiki/Method_（computer_science）

根据我的理解，方法是可以对类执行的任何操作。它是编程中使用的通用术语。

在许多语言中，方法由函数和子例程表示。大多数语言用于这些的主要区别是，函数可能会将值返回给调用方，而子例程可能不会。然而，许多现代语言只有函数，但这些函数可以选择不返回任何值。

例如，假设你想描述一只猫，你希望它能够打哈欠。您将使用 Yawn 方法创建一个 Cat 类，该类很可能是一个没有任何返回值的函数。

假设一个函数是一个代码块（通常有自己的作用域，有时有自己的闭包），它可能会接收一些参数，也可能返回一个结果。

方法是由对象拥有的函数（在某些面向对象的系统中，更正确地说它由类拥有）。被对象/类“拥有”意味着你通过对象/类引用该方法;例如，在 Java 中，如果要调用对象 “door” 拥有的方法 “open（）”，则需要编写 “door.open（）”。

通常，方法还会获得一些额外的属性来描述它们在对象/类中的行为，例如：可见性（与面向对象的封装概念相关），它定义了可以从哪些对象（或类）调用方法。

在许多面向对象的语言中，所有的“函数”都属于某个对象（或类），因此在这些语言中，没有不是方法的函数。

在OO世界中，两者通常用于表示同一事物。

从纯数学和 CS 的角度来看，当使用相同的参数 （ f（x，y） = （x + y） ） 调用函数时，函数将始终返回相同的结果。另一方面，方法通常与类的实例相关联。不过，大多数现代面向对象语言在大部分情况下不再使用术语“函数”。许多静态方法可能与函数非常相似，因为它们通常没有状态（并不总是如此）。

类上的方法作用于类的实例，称为对象。

class Example
{
   public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".

   public void UpdateData() // .. and manipulates it (This is a method by the way)
   {
      data = data + 1;
   }

   public void PrintData() // This is also a method
   {
      Console.WriteLine(data);
   }
}

class Program
{
   public static void Main()
   {
       Example exampleObject1 = new Example();
       Example exampleObject2 = new Example();

       exampleObject1.UpdateData();
       exampleObject1.UpdateData();

       exampleObject2.UpdateData();

       exampleObject1.PrintData(); // Prints "2"
       exampleObject2.PrintData(); // Prints "1"
   }
}

在对象Pascal或C++等OO语言中，“方法”是与对象关联的函数。因此，例如，“Dog”对象可能具有“bark”函数，这将被视为“Method”。相比之下，“StrLen”函数是独立的（它提供作为参数提供的字符串的长度）。因此，它只是一个“功能”。Javascript在技术上也是面向对象的，但与C++，C#或Pascal等成熟的语言相比，面临着许多限制。尽管如此，这种区别仍然应该成立。

另外几个事实：C#是完全面向对象的，所以你不能创建独立的“函数”。在 C# 中，每个函数都绑定到一个对象，因此从技术上讲，它是一个“方法”。有趣的是，在 C# 中，很少有人将它们称为“方法”——他们只是使用术语“函数”，因为没有任何真正的区别。

最后，为了让任何 Pascal 大师不会在这里跳到我身上，Pascal 还区分了“函数”（返回值）和不返回值的“过程”。 C# 没有明确区分，尽管您当然可以选择返回或不返回值。

对于一阶近似，方法（C++ 样式 OO）是成员函数的另一个词，成员函数是类的一部分。

在像 C/C++ 这样的语言中，你可以拥有不是类成员的函数;不要调用与类 A 方法无关的函数。

函数是按名称调用的一段代码。它可以传递要操作的数据（即参数），并且可以选择返回数据（返回值）。传递给函数的所有数据都是显式传递的。

方法是一段代码，由与对象关联的名称调用。在大多数方面，它与函数相同，除了两个关键区别：

1. 方法隐式传递调用它的对象。
2. 方法能够对包含在类中的数据进行操作（记住对象是类的实例 - 类是定义，对象是该数据的实例）。

（这是一个简化的解释，忽略了范围等问题）

面向对象范式背后的思想是“对待”软件由以下部分组成。好吧，“对象”。现实世界中的对象具有属性，例如，如果您有一个员工，则该员工具有姓名、员工 ID、职位、他属于某个部门等。

该对象还知道如何处理其属性并对其执行一些操作。比方说，如果我们想知道一个员工现在在做什么，我们会问他。

employe whatAreYouDoing.

“whatAreYouDoing”是发送到对象的“消息”。对象知道如何回答这个问题，据说它有一种解决问题的“方法”。

因此，对象必须公开其行为的方式称为方法。因此，工件对象必须“做”某事的方法。

其他可能的方法是

employee whatIsYourName
employee whatIsYourDepartmentsName

等。

另一方面，函数是编程语言计算某些数据的方式，例如，您可能有返回 16 的函数 addValues（ 8 ， 8 ）

// pseudo-code
function addValues( int x, int y )  return x + y 
// call it 
result = addValues( 8,8 )
print result // output is 16...

由于第一种流行的编程语言（如fortran、c、pascal）没有涵盖OO范式，因此它们只调用这些工件“函数”。

例如，C 语言中的前一个函数是：

int addValues( int x, int y ) 
{
   return x + y;
}

说一个对象有一个“函数”来执行某些操作是不“自然”的，因为函数与数学内容更相关，而 Employee 几乎没有数学知识，但你可以拥有与函数完全相同的方法，例如在 Java 中，这将是等效的 addValues 函数。

public static int addValues( int x, int y ) {
    return x + y;
}

看起来很眼熟？这是因为 Java 植根于 C++，而 C++ 植根于 C。

最后只是一个概念，在实现中它们可能看起来是一样的，但在 OO 文档中，这些被称为方法。

下面是 Java 中以前的 Employee 对象的示例。

public class Employee {

    Department department;
    String name;

    public String whatsYourName(){
        return this.name;
    }
    public String whatsYourDeparmentsName(){
         return this.department.name();
    }
    public String whatAreYouDoing(){
        return "nothing";
    } 
    // Ignore the following, only set here for completness
    public Employee( String name ) {
        this.name = name;
    }

}

// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John

// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();

// Print the info to the console.

 System.out.printf("Employee %s is doing: %s", name, doingWhat );

Output:
Employee John is doing nothing.

那么，区别在于应用它的“域”。

AppleScript有“自然语言”matphor的想法，在某个时候OO也有。例如，Smalltalk。我希望在阅读本文后，您可以更容易地理解对象中的方法。

注意：该代码不进行编译，仅用作示例。随意修改帖子并添加 Python 示例。

一般来说：方法是属于类的函数，函数可以位于代码的任何其他作用域上，因此您可以声明所有方法都是函数，但不是所有函数都是方法：

以以下 python 为例：

class Door:
  def open(self):
    print 'hello stranger'

def knock_door():
  a_door = Door()
  Door.open(a_door)

knock_door()

给出的示例向您展示了一个名为“Door”的类，该类具有一个名为“open”的方法或操作，它之所以被称为方法，是因为它是在类中声明的。下面还有另一部分带有“def”的代码，它定义了一个函数，它是一个函数，因为它没有在类中声明，这个函数调用了我们在类中定义的方法，如你所见，最后该函数被自己调用。

正如你所看到的，你可以在任何地方调用一个函数，但是如果你想调用一个方法，你必须传递一个与该方法声明的类类型相同的新对象（Class.method（object）），或者你必须在对象（object.Method（）），至少在 python 中是这样。

将方法视为只有一个实体可以做的事情，所以如果你有一个 Dog 类，那么只在该类中有一个 bark 函数是有意义的，这将是一个方法，如果你还有一个 Person 类，那么编写一个函数“feed”是有意义的，因为它不属于任何类，因为人类和狗都可以被喂食，你可以将其称为函数，因为它不属于任何特定的类。

函数是一个数学概念。例如：

f(x,y) = sin(x) + cos(y)

表示函数 f（） 将返回第一个参数的 sin，并将其添加到第二个参数的余弦中。这只是数学。碰巧的是，sin（） 和 cos（） 也是函数。函数还有另一个属性：对具有相同参数的函数的所有调用都应返回相同的结果。

另一方面，方法是与面向对象语言中的对象相关的函数。它有一个隐式参数：作的对象（及其状态）。

因此，如果你有一个对象 Z 的方法为 g（x），你可能会看到以下内容：

Z.g(x) = sin(x) + cos(Z.y)

在本例中，将传入参数 x，与前面的函数示例相同。但是，cos（） 的参数是位于对象 Z 内部的值，Z 和位于其中的数据 （Z.y） 是 Z 的 g（） 方法的隐式参数。

既然您提到了 Python，那么在大多数现代面向对象语言中，以下可能是方法和对象之间关系的有用说明。简而言之，他们所谓的“方法”只是一个传递额外参数的函数（正如其他答案所指出的那样），但 Python 比大多数语言更明确。

# perfectly normal function
def hello(greetee):
  print "Hello", greetee

# generalise a bit (still a function though)
def greet(greeting, greetee):
  print greeting, greetee

# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
  print greeter.greeting, greetee

# very simple class we can pass to greet_with_greeter
class Greeter(object):
  def __init__(self, greeting):
    self.greeting = greeting

  # while we're at it, here's a method that uses self.greeting...
  def greet(self, greetee):
    print self.greeting, greetee

# save an object of class Greeter for later
hello_greeter = Greeter("Hello")

# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")

现在比较函数和方法：唯一的区别是第一个参数的名称（在函数中我称之为“greeter”，在方法中我称之为“self”）。因此，我可以像使用函数一样使用该方法（使用“点”语法来获取它，因为我在类中定义了它）：greet_with_greetergreetgreetgreet_with_greeter

Greeter.greet(hello_greeter, "World")

因此，我有效地将方法转换为函数。我可以将函数转换为方法吗？好吧，由于 Python 允许您在定义类后弄乱它们，让我们尝试一下：

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

是的，该函数现在也称为 方法 。这显示了方法和函数之间唯一真正的区别：当您通过调用 “在”对象上调用方法时，语言会神奇地将其转换为 。greet_with_greetergreet2object.method(args)method(object, args)

（OO纯粹主义者可能会争辩说，方法与函数是不同的东西，如果你进入高级Python或Ruby，或者Smalltalk！，你就会开始明白他们的观点。此外，某些语言还为方法提供了对对象位的特殊访问权限。但主要的概念差异仍然是隐藏的额外参数。

函数是一组可用于操作数据的逻辑。

而 Method 是用于操作其所属对象数据的函数。 因此，从技术上讲，如果你有一个函数与你的类不完全相关，但在类中声明，它就不是一个方法;这被称为糟糕的设计。

给我的： 如果我同意，方法和函数的功能是相同的：

• 函数可以返回一个值
• 可能期望参数

就像任何一段代码一样，你可能有你放入的对象，你可能有一个结果的对象。在这样做的过程中，它们可能会改变对象的状态，但这不会改变它们的基本功能。

在调用对象或其他代码的函数时，可能存在定义差异。但这难道不是语言差异的东西吗，这就是人们交换它们的原因吗？提到的计算示例我会小心。因为我雇用员工来做我的计算：

new Employer().calculateSum( 8, 8 );

通过这样做，我可以依靠雇主负责计算。如果他想要更多的钱，我会释放他，让碳水化合物收集员处理未使用的员工的职能完成剩下的工作，然后找一个新员工。

即使认为一个方法是对象函数，而一个函数是不相连的计算，也无济于事。函数描述符本身，理想情况下，函数的文档将告诉我它需要什么以及它可能返回什么。其余的，比如操纵某个物体的状态，对我来说并不是真正透明的。我确实希望函数和方法都能提供和操作它们声称的东西，而不需要详细了解它们是如何做到的。 即使是纯计算函数也可能会更改控制台的状态或附加到日志文件。

我不是专家，但这是我所知道的：

1. 函数是 C 语言术语，它指的是一段代码，函数名称将是使用此函数的标识符。

2. Method 是 OO 术语，通常它在函数参数中有一个 this 指针。你不能像 C 一样调用这段代码，你需要使用 object 来调用它。

3. invoke 方法也不同。这里调用意义来查找这段代码的地址。C/C++，链接时间将使用函数符号进行定位。

4. Objecive-C 则不同。调用一个 C 函数，以使用数据结构来查找地址。这意味着在运行时一切都是已知的。

函数或方法是一段命名的可调用代码，它执行一些操作并选择性地返回一个值。

在 C 语言中，使用术语函数。Java 和 C# 的人会说它是一种方法（在这种情况下，函数是在类/对象中定义的）。

C++程序员可能会称其为函数，有时也称为方法（取决于他们是编写过程样式的C++代码还是采用面向对象的C++方式，也只有C / C++的程序员可能会将其称为函数，因为术语“方法”在C / C++文献中很少使用）。

你只需调用一个函数的名称，就像这样，

result = mySum(num1, num2);

你可以通过首先引用它的对象来调用一个方法，比如，

result = MyCalc.mySum(num1,num2);

函数和方法之间主要区别的一个非常一般的定义：

函数在类外部定义，而方法在类内部和类的一部分定义。

恕我直言，人们只是想发明一个新词，以便在程序员想要引用对象内部的函数时更容易进行交流。

如果你说的是方法，你指的是类中的函数。 如果你说的是函数，你的意思只是类之外的函数。

事实是，这两个词都用于描述功能。即使你用错了，也不会发生任何错误。这两个词都很好地描述了您希望在代码中实现的目标。

函数是必须扮演某事角色（函数）的代码。 方法是解决问题的方法。

它做同样的事情。这是一回事。如果你想超级精确并遵循约定，你可以调用方法作为对象内部的函数。

函数是主要属于面向过程编程的概念，其中函数是一个可以处理数据并返回值的实体

方法是面向对象编程的概念，其中方法是类的成员，该类主要对类成员进行处理。

从历史上看，“方法”是不返回值的东西，而“函数”是返回值的东西，而“函数”是返回值的东西。每种语言都有自己的具有特殊含义的术语词典。

在“C”中，“函数”一词表示程序例程。

在 Java 中，术语“函数”没有任何特殊含义。而“方法”是指构成类实现的例程之一。

在 C# 中，这将翻译为：

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

但实际上，我重申这两个概念确实没有区别。 如果你在关于 Java 的非正式讨论中使用“函数”一词，人们会认为你的意思是“方法”并继续。不要在有关 Java 的适当文档或演示文稿中使用它，否则你会看起来很傻。

我知道许多其他人已经回答了，但我发现下面是一个简单而有效的单行答案。虽然它看起来并不比这里的其他答案好多少，但如果你仔细阅读它，它包含你需要知道的关于方法与函数的一切。

方法是具有定义接收器的函数，在 OOP 术语中，方法是对象实例上的函数。

在 C++ 中，有时，方法用于反映类的成员函数的概念。但是，最近我在《C++ 编程语言第 4 版》一书的第 586 页“派生类”中发现了一个声明

虚函数有时称为方法。

这有点令人困惑，但他说有时，所以这大致是有道理的，C++ 创建者倾向于将方法视为可以在对象上调用的函数并且可以表现为多态。

以下是使用 JavaScript 示例的方法与函数的一些解释：

测试（20， 50）;是函数定义，用于运行一些步骤或返回可以在某处存储/使用的东西。

可以重用代码：定义一次代码，然后多次使用。

您可以多次使用具有不同参数的相同代码，以产生不同的结果。

var x = myFunction(4, 3);   // Function is called, return value will end up in x

function myFunction(a, b) {
    return a * b;          // Function returns the product of a and b
}

var 测试 = something.test（）;这里 test（） 可以是某个对象的方法，也可以是自定义内置对象的原型，这里是更多解释：

JavaScript 方法是可以对对象执行的操作。

JavaScript 方法是包含函数定义的属性。

javascript 中字符串的内置属性/方法：

var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!

自定义示例：

function person(firstName, lastName, age, eyeColor) {
    this.firstName = firstName;  
    this.lastName = lastName;
    this.age = age;
    this.eyeColor = eyeColor;
    this.changeName = function (name) {
        this.lastName = name;
    };
}

something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'

例如，您还可以定义 String、Array 等的属性

String.prototype.distance = function (char) {
    var index = this.indexOf(char);

    if (index === -1) {
        console.log(char + " does not appear in " + this);
    } else {
        console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
    }
};

var something = "ThisIsSomeString"

// now use distance like this, run and check console log

something.distance("m");

一些参考资料：Javascript 对象方法、函数、有关原型的更多信息

简单的记忆方法：

• F unction → Free（Free 意味着它可以在任何地方，无需在对象或类中）
• M ethod → Member （对象或类的成员）

让我们不要把应该是一个非常简单的答案过于复杂化。方法和函数是一回事。当函数位于类外部时，将函数称为函数，当函数编写在类中时，将函数称为方法。

方法与函数的区别

从阅读有关 Microsoft 的此文档

包含可执行代码的成员统称为类的函数成员。上一节介绍了方法，这些方法主要是函数成员。本部分介绍 C# 支持的其他类型的函数成员：构造函数、属性、索引器、事件、运算符和终结器。

因此，方法是函数的子集。每个方法都是一个函数，但不是每个函数都是一个方法，例如，不能说是方法，但它是函数。constructor

类是一些数据和函数的集合，可以选择使用构造函数。

在创建该特定类的实例（复制、复制）时，构造函数初始化该类并返回一个对象。

现在类变为对象（不带构造函数） & 函数在对象上下文中称为方法。

所以基本上

类 <==new==>Object

函数 <==new==>Method

在java中，它通常被告知构造函数名称与类名相同，但实际上该构造函数类似于实例块和静态块，但具有用户定义的返回类型（即类类型）

虽然该类可以有静态块、实例块、构造函数、函数 对象通常只有数据和方法。

函数 - 独立代码段中的函数，其中包含一些逻辑，必须独立调用并在类之外定义。

方法 - 方法是一段独立的代码，它引用某个对象调用，并在类中定义。

它们通常是可以互换的，但方法通常是指类内部的子例程，而函数通常是指类外部的子例程。 例如，在 Ruby 中：

# function
def putSqr(a)
   puts a ** 2
end


class Math2
   # method
   def putSqr(a)
      puts a ** 2
   end
end

在 Java 中，所有内容（除了 package 和 import 语句）都必须在类中，人们几乎总是将它们称为“方法”。

TL;博士

函数是一段要运行的代码。
方法是对象内部的函数。

函数示例：

function sum(){
  console.log("sum")l
}

方法示例：

const obj = {
a:1,
b:2,
sum(){
  }
}

这就是为什么我们说函数中的“this”关键字不是很有用，除非我们将它与 call、apply 或 bind 一起使用。因为 call、apply、bind 会将该函数作为 Object == 中的方法调用>基本上它将函数转换为方法

用两个词来概括：非静态（“instance”）方法采用一个指向“this”（作为它们的第一个参数）的隐藏指针，这是您调用该方法的对象。

这是与常规独立功能的唯一区别，尽管是动态调度。

如果您有兴趣，请阅读以下详细信息。

我将尽量简短，并以 C++ 为例，尽管我所说的几乎可以应用于所有语言。

• 对于 CPU，函数和方法都只是代码片段。 时期。
• 因此，当调用函数/方法时，它们可以采取 参数

好吧，我说没有实际区别。让我们更深入地挖掘一下：

• 方法有两种类型：静态和非静态
• 静态方法类似于常规函数，但在类中声明，该类的作用类似于命名空间
• 非静态（“instance”）方法采用指向“this”的隐藏指针。这是与常规独立函数的唯一区别。

撇开动态调度不谈，这意味着它就这么简单：

class User {
    public string name; // I made it public intentionally

    // Each instance method takes a hidden reference to "this"
    public void printName(/*User & this*/) {
        cout << this.name << endl;
    }
};

相当于

public getName(User & user) {
    // No syntactic sugar, passing a reference explicitly
    cout << user.name << endl;
}

所以，从本质上讲，只是句法糖。user->printName()getName(user)

如果不使用动态调度，仅此而已。如果它被使用，那么它就会更复杂一些，但编译器仍然会发出看起来像一个函数作为第一个参数的东西。this

函数和方法看起来非常相似。它们还具有输入和返回输出。区别在于方法在类内部，而函数在类外部。

方法和功能之间有明显的区别，如下所示：

函数是一段独立的代码，你可以通过用给定的参数提及它的名称来在任何地方调用它，就像在大多数过程语言中一样，例如 C++ 和 python。而

方法与对象特别关联，这意味着你只能通过使用 dot（.） 表示法在它之前提及它的对象来调用方法，就像在 C# 和 java 等纯面向对象的语言中一样。

一般的答案是：

method具有对象上下文（this 或类实例引用），

function没有上下文（null、全局或静态）。

但问题的答案取决于你使用的语言术语。

1. 在 JavaScript （ES 6） 中，您可以根据需要自由自定义函数上下文 （this），这通常必须链接到 （this） 对象实例上下文。

2. 在 Java 世界中，你总是听到“只有 OOP 类/对象，没有函数”，但如果你仔细观察 Java 中，它们实际上是在全局/空上下文（或类的上下文中，没有实例化），所以只是函数没有对象。Java 老师可以告诉你，但他们会告诉你，是为了简化历史并避免新手不必要的问题。如果你在 Java 7 版本之后看到，你可以找到许多纯函数编程的元素（甚至不是来自 C，而是来自 1988 年更早的 Lisp）来简化并行计算，它不是 OOP 类风格。static methodsfunctions were rudiment of C in C++ and dropped in Java

3. 在 C++ 和 D 世界中，事物更强大，并且您使用方法和字段将函数和对象分开。但在实践中，您再次看到函数和方法（具有对象上下文）。without thiswhith this

4. 在FreePascal/Lazarus和Borland Pascal/Delphi中，关于函数和对象（变量和字段）的分离项通常类似于C++。

5. Objective-C 来自 C 世界，因此您必须使用方法插件将 C 函数和 Objective-C 对象分开。

6. C#与Java非常相似，但具有许多C++优点。

A 是任何对象或类的成员。 A 是独立的。methodfunction

但在 Javascript 的情况下，并且是可以互换的。functionmethod

使用 C# 术语时，函数和方法之间是有区别的。术语函数成员不仅包括方法，还包括其他非数据成员，如索引器、运算符、构造函数、析构函数和属性，这些成员都包含可执行代码。

reference => Professional C# 和 .NET 2021 版 - 由 Christina Nagel 编写

方法和函数有什么区别？

Python 的官方文档是这样定义的（感谢 Bundy 在这里@Kelly！

功能

向调用方返回一些值的一系列语句。它也可以传递零个或多个参数，这些参数可用于执行正文。另请参阅参数、方法和函数定义部分

方法

在类体中定义的函数。如果作为该类实例的属性调用，该方法将获取实例对象作为其第一个参数（通常称为）。请参阅函数和嵌套作用域。self

正方形是矩形，但并非所有矩形都是正方形。我解释世界的方式，方法就是函数，但并不是所有的函数都是方法。方法的独特之处在于它是一种特殊类型的函数，它也与类相关联，并且可以访问类成员变量。

另请参阅：

1. [我的回答]hasattr 被称为方法，但它看起来像一个函数

• OOP 是一种设计理念。 在这种情况下，“方法”是“动作”，是对象的“行为”，是“操作”，是对象所做的事情。右键单击鼠标对象是一种操作。在几种语言中，实现 OOP 设计的这种操作或行为称为“方法”。

• “函数”只与 C 和 Pascal 等过程语言有关，与 OOP 哲学无关，甚至在技术上实现与方法相似。“函数”是过程语言（如 C）中的代码块，具有定义的目的、隔离和定义的功能，也可以返回结果。“Procedure”也是一个不返回结果的函数，但这只是技术上的区别。

函数是一组用于执行特定任务的指令或过程。它可用于将代码拆分为易于理解的部分，这些部分也可以调用或重用。

方法是可以对对象执行的操作。它也称为存储为对象属性的函数。

主要区别：函数不需要任何对象并且是独立的，而方法是函数，它与任何对象链接。

//firstName() is the function

function firstName(){
 cosole.log('John');
}

firstName() //Invoked without any object

const person = {
  firstName: "John",
  lastName: "Doe",
  id: 5566,
};

//person.name is the method
person.name = function() {
  return this.firstName + " " + this.lastName;
};

document.getElementById("demo").innerHTML =
"My father is " + person.name() //performs action on object; 

• 函数是可以调用的独立代码块 独立地，方法是与对象或 类并在该对象或类中使用。

• 方法可以使用 类，而函数通常对其输入和返回进行操作 结果。

• 方法通常用于确定对象的行为，而 函数用于模块化代码并促进可重用性

• 方法使用点表示法 （object.method （）） 命名，并且 函数附加其名称 （functionName （））。