精华内容
下载资源
问答
  • 文章目录Scala的方法和函数有什么区别——反编译解析1. 方法-解析1.1 普通方法1.2 嵌套方法2. 函数-解析2.1 函数示例2.2 反编译结果2.3 函数反编译解析3. 为什么方法和函数可以相互转换?3.1 方法和函数混用示例3.2 ...

    Scala方法和函数的本质区别——反编译解析

    1. 方法-解析

    1.1 普通方法

    1. 普通方法,即平常在class、object中定义的方法,示例如下
       object Demo01 {
       
        def sum1(a:Int, b: Int) : Int = a + b
        
        def main(args: Array[String]): Unit = {
          println(sum1(1, 2))
        }
        
      }
      
    2. object中定义的方法和class中定义的方法稍有不同的是:object中的方法会多生成一个静态的方法
    3. 让我来看看上面代码的反编译结果:
    • Demo01.class
      import scala.reflect.ScalaSignature;
      	
      @ScalaSignature(bytes="\006\001U:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tAa];ncQ\031AdH\021\021\005Ei\022B\001\020\023\005\rIe\016\036\005\006Ae\001\r\001H\001\002C\")!%\007a\0019\005\t!\rC\003%\033\021\005Q%\001\003nC&tGC\001\024*!\t\tr%\003\002)%\t!QK\\5u\021\025Q3\0051\001,\003\021\t'oZ:\021\007Eac&\003\002.%\t)\021I\035:bsB\021qF\r\b\003#AJ!!\r\n\002\rA\023X\rZ3g\023\t\031DG\001\004TiJLgn\032\006\003cI\001")
      public final class Demo01 {
        public static void main(String[] paramArrayOfString) {
          Demo01..MODULE$.main(paramArrayOfString);
        }
        
        public static int sum1(int paramInt1, int paramInt2) {
          return Demo01..MODULE$.sum1(paramInt1, paramInt2);
        }
      }
      
    • Demo01$.class
      import scala.Predef.;
      import scala.runtime.BoxesRunTime;
      
      public final class Demo01$ {
          
          public static final  MODULE$;
      
          static {
              new ();
          }
      
          public int sum1(int a, int b) {
              return a + b;
          }
      
          public void main(String[] args) {
              Predef..MODULE$.println(BoxesRunTime.boxToInteger(sum1(1, 2)));
          }
      
          private Demo01$() {
              MODULE$ = this;
          }
      }
      
    1. Demo01.class是JVM真正调用的入口,由它再调用Demo01\$中的main。同时负责维护静态方法,经由此处的静态方法sum1调用Demo01\$中实际的方法sum1
    2. Demo01$.class负责维护实际使用的值、方法
    3. 可以看出Scala中的普通方法和Java中的方法区别不大,仅在object的静态编译处有细微区别

    1.2 嵌套方法

    1. 嵌套方法,即定义在方法中的方法,示例如下
      object Demo01 {
      	
        def main(args: Array[String]): Unit = {
          def sum2(a:Int, b: Int) : Int = a + b
      
          println(sum2(3, 4))
        }
      	
      }
      
    2. 嵌套方法也是方法,只是使用起来和普通方法的作用域不同,那么他们为什么会有不同的作用域呢?在本质上又有什么区别呢?
    3. 让我来看看上面代码的反编译结果:
    • Demo01.class
      import scala.reflect.ScalaSignature;
      
      @ScalaSignature(bytes="\006\001-:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tA!\\1j]R\021Ad\b\t\003#uI!A\b\n\003\tUs\027\016\036\005\006Ae\001\r!I\001\005CJ<7\017E\002\022E\021J!a\t\n\003\013\005\023(/Y=\021\005\025BcBA\t'\023\t9##\001\004Qe\026$WMZ\005\003S)\022aa\025;sS:<'BA\024\023\001")
      public final class Demo01 {
        public static void main(String[] paramArrayOfString) {
          Demo01..MODULE$.main(paramArrayOfString);
        }
      }
      
    • Demo01$.class
      import scala.Predef.;
      import scala.runtime.BoxesRunTime;
      
      public final class Demo01$ {
        public static final  MODULE$;
        
        private final int sum2$1(int a, int b) {
          return a + b;
        }
        
        public void main(String[] args) {
          Predef..MODULE$.println(BoxesRunTime.boxToInteger(sum2$1(3, 4)));
        }
        
        private Demo01$() {
          MODULE$ = this;
        }
        
        static {
          new ();
        }
      }
      
    1. Demo01.class是JVM真正调用的入口,由它再调用Demo01\$中的main。其中不存在sum2的静态方法
    2. Demo01$.class负责维护实际使用的值、方法。其中存在sum2的方法,同时被更名为sum2$1
    3. 由此看来,嵌套方法其实利用了更名的方式,保证不与同名的普通方法冲突,在外部调用sum2其实调用的是class、object中的普通方法sum2,无法调用sum2$1,从而做到了限制作用域。实际上,从Java的角度上来看,嵌套方法还是一个普通方法。

    2. 函数-解析

    2.1 函数示例

    object Demo01 {
    
      def main(args: Array[String]): Unit = {
        val max = (a: Int, b:Int) => if (a > b) a else b
    
        println(max(5, 6))
      }
    
    }
    

    2.2 反编译结果

    • Demo01.class
      import scala.reflect.ScalaSignature;
      
      @ScalaSignature(bytes="\006\001-:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tA!\\1j]R\021Ad\b\t\003#uI!A\b\n\003\tUs\027\016\036\005\006Ae\001\r!I\001\005CJ<7\017E\002\022E\021J!a\t\n\003\013\005\023(/Y=\021\005\025BcBA\t'\023\t9##\001\004Qe\026$WMZ\005\003S)\022aa\025;sS:<'BA\024\023\001")
      public final class Demo01 {
        public static void main(String[] paramArrayOfString) {
          Demo01..MODULE$.main(paramArrayOfString);
        }
      }
      
    • Demo01$.class
      import scala.Function2;
      import scala.Predef.;
      import scala.Serializable;
      import scala.runtime.AbstractFunction2.mcIII.sp;
      import scala.runtime.BoxesRunTime;
      
      public final class Demo01$ {
        public static final  MODULE$;
        
        static {
          new ();
        }
        
        public void main(String[] args) {
          Function2 max = new AbstractFunction2.mcIII.sp() {
            public static final long serialVersionUID = 0L;
            
            public int apply$mcIII$sp(int a, int b) {
              return a > b ? a : b;
            }
            
            public final int apply(int a, int b) {
              return apply$mcIII$sp(a, b);
            }
          };
          Predef..MODULE$.println(BoxesRunTime.boxToInteger(max.apply$mcIII$sp(5, 6)));
        }
        
        private Demo01$() {
          MODULE$ = this;
        }
      }
      

    2.3 函数反编译解析

    1. Demo01.class,这个没什么好说的,和之前一样
    2. Demo01$.class中多出来一个类型为scala.Function2max变量,其实它就是我们的函数。
    3. 查看scala源码可知scala.Function2是一个trait,同时对应的new AbstractFunction2是一个abstract class,这个class扩展了Function2。而函数对应的具体的功能其实是这个abstract class AbstractFunction2trait Function2的方法apply的具体实现。
    4. 到这里,其实可以明白了,scala中的函数其实就是定义的一个trait,并且拥有一个对应的抽象实现类来实现具体的函数功能
    5. 扩展:
      • scala中的元组其实也是对应的类,类名为Tuple,最多拥有22个参数,即Tuple22。这里示例中max函数对应的的Function2其实指的就是可以传2个参数,同时源码中定义了可以传22个参数的函数,叫Function22
      • 如果比较熟悉Java8的话,我们可以看看lambda表达式,通常情况下这个lambda表达式也是传一个接口的匿名实现类,例如new Thread(() -> System.out.println("Hello World!")).start();。同时,Java8中定义了FunctionConsumerSupplierPredicate几大接口用于Stream处理,正是和Scala函数相对应。
      • Scala中的trait经过反编译后,其实就是接口+抽象类。接口对应Java中的接口,抽象类用于实现trait自带的方法、变量等

    3. 为什么方法和函数可以相互转换?

    3.1 方法和函数混用示例

    object Demo01 {
    
      def main(args: Array[String]): Unit = {
        // 一些单词
        val words= List("java", "scala", "python", "rust", "go", "c", "c++")
        
        // 定义转换字母大写的函数
        val toUpperFunc = (word: String) => word.toUpperCase()
        // 定义转换字母大写的方法
        def toUpperMethod(word: String): String = word.toUpperCase()
        
        // 方法和函数混用
        // map方法在源码中明确标注,需要的参数的类型是函数A => B
        words.map(toUpperFunc).foreach(println)
        words.map(toUpperMethod).foreach(println)
        // 结果一样
      }
    
    }
    

    看完上面的示例可能让人有点困惑。毕竟我们前面已经说了,方法和函数在本质上是两个不同的东西,那么方法为什么可以传进入参类型为函数的方法中呢?

    3.2 方法与函数转换-解析

    1. 不急,让我们先看下面一个简单的示例(将方法转换为函数)
      object Demo01 {
        
        def sum2(a:Int, b: Int) : Int = a + b
      
        def main(args: Array[String]): Unit = {
          val func1: (Int, Int) => Int = sum2 _
          println(func1(9, 10))
          
      // 你还可以写成如下形式
      //    val func2: (Int, Int) => Int = sum2
      //    println(func2(9, 10))
      //
      //    val func3 = sum2 _
      //    println(func3(9, 10))
        }
      
      }
      
    2. 让我来看看上面代码的反编译结果:
    • Demo01.class(省略)
    • Demo01$.class
      import scala.Function2;
      import scala.Predef.;
      import scala.Serializable;
      import scala.runtime.AbstractFunction2.mcIII.sp;
      import scala.runtime.BoxesRunTime;
      
      public final class Demo01$ {
        public static final  MODULE$;
        
        static {
          new ();
        }
        
        public int sum2(int a, int b) {
          return a + b;
        }
        
        public void main(String[] args) {
          Function2 func1 = new AbstractFunction2.mcIII.sp() {
            public static final long serialVersionUID = 0L;
            
            public int apply$mcIII$sp(int a, int b) {
              return Demo01..MODULE$.sum2(a, b);
            }
            
            public final int apply(int a, int b) {
              return apply$mcIII$sp(a, b);
            }
          };
          Predef..MODULE$.println(BoxesRunTime.boxToInteger(func1.apply$mcIII$sp(9, 10)));
        }
        
        private Demo01$() {
          MODULE$ = this;
        }
      }
      
    1. 函数的生成还是和前面的说明一样,实例化了一个实现了Function2apply方法的抽象类AbstractFunction2对象。不过,注意,这里有一个微妙的区别,apply调用了apply\$mcIII\$sp方法,而apply\$mcIII\$sp方法又调用了sum2方法!!!没错,将方法转换为函数,其实函数并没有在内部重新实现该功能,而是直接调用了sum2方法!

    3.3 混用示例-解析

    1. 现在准备好了,请看前面“单词转大写”的混用示例的反编译结果:
    • Demo01.class(省略)
    • Demo01$.class
      import scala.Function1;
      import scala.Predef.;
      import scala.Serializable;
      import scala.collection.immutable.List;
      import scala.collection.immutable.List.;
      import scala.runtime.AbstractFunction1;
      import scala.runtime.BoxedUnit;
      
      public final class Demo01$ {
        public static final  MODULE$;
        
        public final String com$skey$test$mf$Demo01$$toUpperMethod$1(String word) {
          return word.toUpperCase();
        }
        
        public void main(String[] args) {
          List words = List..MODULE$.apply(Predef..MODULE$.wrapRefArray((Object[])new String[] { "java", "scala", "python", "rust", "go", "c", "c++" }));
          
          Function1 toUpperFunc = new AbstractFunction1() {
            public static final long serialVersionUID = 0L;
            
            public final String apply(String word) {
              return word.toUpperCase();
            }
          };
          ((List)words.map(toUpperFunc, List..MODULE$.canBuildFrom())).foreach(new AbstractFunction1() {
            public static final long serialVersionUID = 0L;
            
            public final void apply(Object x)
            {
              Predef..MODULE$.println(x);
            }
          });
          
          ((List)words.map(new AbstractFunction1()  {
            public static final long serialVersionUID = 0L;
            
            public final String apply(String word) {
              return Demo01..MODULE$.com$skey$test$mf$Demo01$$toUpperMethod$1(word);
            }
          }, List..MODULE$.canBuildFrom())).foreach(new AbstractFunction1() {
            public static final long serialVersionUID = 0L;
            
            public final void apply(Object x) {
              Predef..MODULE$.println(x);
            }
          });
        }
        
        private Demo01$() {
          MODULE$ = this;
        }
        
        static {
          new ();
        }
      }
      
    1. 首先正常定义的函数部分和我们想象的一样,符合规则,向map中被传入了toUpperFunc函数,最终调用foreach进行了打印
    2. 而我们向map中传入toUpperMethod方法的部分,其实是实例化了一个匿名函数(这个函数的apply调用了toUpperMethod方法,即前面的"方法转换为函数"),将这个函数传入了map中,最终调用foreach进行了打印
    3. 这下,我们知道了,words数据的map确实只接收类型为A=>B的函数,向map传入方法没产生错误的原因是由于toUpperMethod方法被转换为了函数
    4. 总之,方法转换为函数,其实就是新生成一个函数,然后由该函数调用该方法!
    展开全文
  • 方法和函数区别

    千次阅读 多人点赞 2019-01-20 19:59:11
    在日常的撸码中,很多朋友会对方法和函数这俩个概念有所混淆,在我看来,这俩个概念很有区别,今天就给大家详细讲解一下子。 1、方法是特殊的函数,可以说是函数的子集 2、方法平常往往是类有关的,是我们在...

    在日常的撸码中,有很多朋友会对方法和函数这俩个概念有所混淆,在我看来,这俩个概念很有区别,今天就给大家详细讲解一下子。

    1、方法是特殊的函数,可以说是函数的子集
    2、方法平常往往是和类有关的,是我们在面向对象语言中会提到,用到的。
    3、函数是一一映射的关系,给定一个变量,则会出现一个确定的值。 是指一段可以直接被其名称调用的代码块,它可以传入一些参数进行处理并返回一些数据,所有传入函数的数据都是被明确定义。
    在C语言中,不存在方法这一说,因为C语言是面向过程的语言;而在Java中,却是只有方法这一说,因为Java是纯粹的面向对象的编程语言,是类定义的,属性和方法组成类成员;在python中,既有面向过程,又有面向对象,所以在python既有函数,又有方法。

    看到这块,大家有没有对这俩个概念清晰了呢,那就点个赞吧~

    展开全文
  • 回调函数和普通函数有什么区别

    千次阅读 2019-08-06 10:07:11
    普通函数与回调函数主要是在调用方式上有区别: 1、对普通函数的调用: 调用程序发出对普通函数的调用后,程序执行立即转向被调用函数执行,直到被调用函数执行完毕后,再返回调用程序继续执行。从发出调用的程序的...

    普通函数与回调函数主要是在调用方式上有区别:

    1、对普通函数的调用:
    调用程序发出对普通函数的调用后,程序执行立即转向被调用函数执行,直到被调用函数执行完毕后,再返回调用程序继续执行。从发出调用的程序的角度看,这个过程为“调用–>等待被调用函数执行完毕–>继续执行”。

    2、对回调函数调用:
    调用程序发出对回调函数的调用后,不等函数执行完毕,立即返回并继续执行。
    这样,调用程序执和被调用函数同时在执行。当被调函数执行完毕后,被调函数会反过来调用某个事先指定函数,以通知调用程序:函数调用结束。这个过程称为回调(Callback),这正是回调函数名称的由来。

    在这里插入图片描述

    扩展资料

    一般函数(General function)是相对于比较特殊,比较少见的函数而言的,在任一学科内,指的是作用能力比较基层,使用比较普遍的函数,但同时它也是构成某整个作用域中不可缺少的元素。列如:c语言中的printf(),scanf()函数就是c语言中的一般函数,它们用于各类数据输出和输入,是很常用的的库函数,基础但很重要。

    展开全文
  • 方法和函数区别函数式编程语言中,函数是“头等公民”,它可以像任何其他数据类型一样被传递操作 案例:首先定义一个方法,再定义一个函数,然后将函数传递到方法里面 package cn.toto.scala/** * Created...

    1. 定义方法和函数

    1.1. 定义方法

    这里写图片描述
    方法的返回值类型可以不写,编译器可以自动推断出来,但是对于递归函数,必须指定返回类型

    1.2. 定义函数

    这里写图片描述

    1.3.方法和函数的区别

    在函数式编程语言中,函数是“头等公民”,它可以像任何其他数据类型一样被传递和操作
    案例:首先定义一个方法,再定义一个函数,然后将函数传递到方法里面
    这里写图片描述

    package cn.toto.scala
    
    /**
      * Created by toto on 2017/6/27.
      */
    object MethodAndFunctionDemo {
      //定义一个方法
      //方法m2参数要求是一个函数,函数的参数必须是两个Int类型
      //返回值类型也是Int类型
      def m1(f:(Int,Int) => Int) : Int = {
        f(2,6)
      }
    
      //定义一个函数f1,参数是两个Int类型,返回值是一个Int类型
      val f1 = (x:Int,y:Int) => x + y
      //再定义一个函数f2
      val f2 = (m:Int,n:Int) => m * n
    
      //main方法
      def main(args: Array[String]): Unit = {
        //调用m1方法,并传入f1函数
        val r1 = m1(f1)
    
        println(r1)
    
        //调用m1方法,并传入f2函数
        val r2 = m1(f2)
        println(r2)
      }
    }

    运行结果:

    8
    12

    1.2. 将方法转换成函数(神奇的下划线)
    这里写图片描述
    代码如下:

    package cn.toto.scala
    
    /**
      * Created by toto on 2017/6/27.
      */
    object TestMap {
    
      def ttt(f:Int => Int):Unit = {
        val r = f(10)
        println(r)
      }
    
      val f0 = (x : Int) => x * x
    
      //定义了一个方法
      def m0(x:Int) : Int = {
        //传递进来的参数乘以10
        x * 10
      }
    
      //将方法转换成函数,利用了神奇的下滑线
      val f1 = m0 _
    
      def main(args: Array[String]): Unit = {
        ttt(f0)
    
        //通过m0 _将方法转化成函数
        ttt(m0 _);
    
        //如果直接传递的是方法名称,scala相当于是把方法转成了函数
        ttt(m0)
    
        //通过x => m0(x)的方式将方法转化成函数,这个函数是一个匿名函数,等价:(x:Int) => m0(x)
        ttt(x => m0(x))
      }
    }
    展开全文
  • 最近在使用headfirstpython一书,书中一个语法也没讲,刚刚学了c语言,所以我不是很清楚方法和函数区别
  • Scala方法和函数区别

    千次阅读 2017-12-20 16:46:08
    Scala中既有函数有方法,大多数情况下我们都可以不去理会他们之间的区别。但是时候我们必须要了解他们之间的不同。   Scala中的方法跟Java的方法一样,方法是组成类的一部分。方法有名字、类型签名,...
  • java中方法和函数区别与联系是什么,是不是叫法不同而已,比如构造方法即是构造函数
  • Python中函数和方法区别

    万次阅读 多人点赞 2018-09-27 18:59:17
    在Python中函数和方法有区别的。 区别一所处的位置:函数是直接写文件中而不是class中,方法是只能写在class中。 区别二定义的方式: 1.函数定义的方式 def关键字 然后接函数名 再是括号 括号里面写形参也可以...
  • java中方法和函数区别

    千次阅读 多人点赞 2018-09-11 22:36:04
    一句话告诉你如何区分函数方法函数是大家的函数方法是类的方法。 如何区分一个ITer是设计师还是码工。 看看他是在调别人的库,还是自己写出JAR包跟别人分享。 感觉差的不是一个级别而已啊。 一个东西,用对象...
  • 函数和方法区别

    千次阅读 2018-09-07 15:35:04
    以python为例: 一片文章来解决长久以来众说纷纭,争论不休的函数和方法之争 ...这两个类型来区别函数和方法 当然你也可以用 type 函数区别 第一种测试: 我们先来一个类,里面三类方法,分别...
  • scala中方法和函数区别

    千次阅读 2018-06-28 23:03:51
    在Scala中函数和方法有什么区别如下:1、方法可以作为表达式的一部分出现,无参方法可以作为最终表达式出现;但函数可以作为最终表达式出现方法可以作为一个表达式的一部分出现(调用函数并传参),但带参方法不...
  • 1.背景介绍 函数声明 ...函数名在自身作用域父作用域内是可获取的。   函数表达式 函数表达式将函数定义为表达式语句(通常是变量赋值)的一部分。通过函数表达式定义的函数可以是命名的,也可...
  • Scala中方法和函数区别

    万次阅读 2016-12-02 13:24:24
    在Scala中函数和方法有什么区别 方法可以作为一个表达式的一部分出现(调用函数并传参),但是方法(带参方法)不能作为最终的表达式, 但是函数可以作为最终的表达式出现: scala> //定义一个方法 scala>...
  • 在JavaScript中,对象是由构造函数生成的,且函数本身属性和方法,所以为了区分函数方法和对象的方法,才函数和方法两个概念,在其他很多语言中,函数就等于方法,而JavaScript完全不一样! 例子: ...
  • scala 中方法和函数区别

    千次阅读 2017-02-21 14:53:35
    定义函数类型:形式为(T1,…, Tn) => U,其实是FunctionN trait的简写形式,匿名函数和方法值具有这种类型(其实可以作为方法类型的一部分) 方法类型:一个非值类型(non-value type),里边是没有值的,一个方法值具有...
  • scala方法和函数

    千次阅读 2018-08-05 12:40:14
    方法和函数的相互转换 方法的定义 以下几点需要注意: 所有参数必须制定类型; 递归方法,不能省略返回值类型,其他情况下可以忽略(方法可以通过=右侧的函数主体推断出返回值类型) 单行方法主体,可以与...
  • 函数和纯虚函数到底有什么区别

    千次阅读 2018-04-10 11:14:51
    文章转自:点击打开链接从理论上来说...在写面向过程的代码的时候,根本不管什么函数重载覆盖,想到要什么功能就变得法子的换个函数名字,心里想想:反正函数重载本质也就是入栈了两个不同的函数。知道后来我才慢...
  • 函数和抽象函数有什么区别

    千次阅读 2006-05-29 17:09:00
    函数代码的并明确允许子类去覆盖,但子类也可不覆盖,就是说可以直接用,不用重写 抽象函数是没有代码,子类继承后一定要重写 ******************************************************************在一个类...
  • golang 函数以及函数和方法区别

    万次阅读 多人点赞 2016-12-11 20:12:54
    在接触到go之前,我认为函数和方法只是同一个东西的两个名字而已(在我熟悉的c/c++,python,java中没有明显的区别),但是在golang中者完全是两个不同过的东西。 官方的解释是,方法是包含了接收者的函数。到底什么...
  • Python函数和方法区别

    千次阅读 2017-10-16 21:49:18
     Python函数和方法区别方法是一种特殊的函数 属于某个类的的函数方法 不属于某个类的函数函数
  • JavaScript中函数和方法区别

    千次阅读 2018-11-28 17:05:43
    其中我觉得最必要提到的是JS中函数方法的差异。 早期的JS中并没有真正意义上的方法的概念,所谓的方法只是用JS通过this对上下文做出特定的操作而实现的伪方法。 JavaScript方法(函数)中的this指向的并非是实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,212,537
精华内容 485,014
关键字:

方法和函数有什么区别