nodejs通过函数名进行静态方法调用出现类型错误，为啥？

Posted 2023-04-12

在node.js环境下
下面这段代码：
function Myfunc()
var myvar="somevalue";
this.myMethod=function()
return myvar;



//下面这一句报错 TypeError：Myfunc.myMethod is not a function
Myfunc.myMethod();

//这样是没问题的

var myfunc=new Myfunc();

myfunc.myMethod();

但是我需要使用Myfunc.myMethod(); 的形式实现静态调用，不要new的实例。请问问题出在哪里啦？？？

在JS里，一切都是对象，所谓的class并不是传统语言上的定义或者声明，而是直接创建出来了（已分配内存）。
Myfunc是个构造函数（constructor），所有在构造函数中创建的变量和方法都是prototype的。
因此
function Myfunc()
this.myMethod=function()


和
function Myfunc()

Myfunc.prototype.myMethod=function()

是等效的。
所以调用前必须new一下。
而下面这段是可以的，因为直接给Myfunc对象加了一个方法myMethod。恩只是写法和用法像静态而已。
function Myfunc()

Myfunc.myMethod=function()
参考技术A

Myfunc默认只是一个函数，因此函数默认并没有myMethod这个成员方法。即便你函数内部定义了一个myMethod也是没用的，原因是：

Myfunc并没有运行过，因此内部没有执行的代码对外部是不会产生任何影响的。

this指向不明，即便你运行了Myfunc，但是this指向那个对象是动态判断的。

至于下面你使用了new就可以用实例对象调用myMethod方法。那是因为当一个函数通过new关键字调用时，这个函数就不再是一个普通的函数，而是变成了一个对象模板函数（即构造函数），此时函数内部的this指向的是new出来的对象，此时调用myMethod就显得顺理成章了。

方法重载

方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。

 

在java语言中，是怎么进行方法区分的呢？
 首先java编译器会通过方法名进行区分，但是Java语言允许方法名相同的情况出现，如果方法名相同的情况下，编译器会通过方法的形式参数列表进行方法的区分。

 

什么时候考虑使用方法重载？

在同一个类中，如果“功能1”和“功能2”它们的功能是相似的，那么可以考虑将他们的方法名一致，这样代码既美观，又便于后面的维护

 

什么时候代码会发生方法重载？
 条件1：在同一个类当中
 条件2：方法名相同
 条件3：参数列表不同
     参数的个数不同算不同
     参数的类型不同算不同
     参数的顺序不同算不同
 只要同时满足以上三个条件，就可以认定方法和方法之间发生了重载机制

注意：不管代码怎么写，最终一定能让java编译器很好的区分开这两个方法--看方法名和参数列表，就是你调用的时候方法名一样表达式不一样就是重载

 

//以下代码没有使用重载
public class OverloadTest01{
    public static void main(String[] args){
        int i=sumInt(10,20);
        System.out.println(i);
        
        long l=sumLong(10,20);
        System.out.println(l);
        
        double d=sumLong(10,20);
        System.out.println(d);
    }
    public static int sumInt(int a,int b){
        return a+b;
    }
    public static long sumLong(long a,long b){
        return a+b;
    }
    public static double sumDouble(double a,double b){
        return a+b;
    }
}


//使用方法重载机制
public class OverloadTest02{
    public static void main(String[] args){
        System.out.println(sum(10,20));
        System.out.println(sum(10L,20L));
        System.out.println(sum(10.0,20.0));
    }
    public static int sum(int a,int b){
        System.out.println("int类型求和");
        return a+b;
    }
    public static long sum(long a,long b){
        System.out.println("long类型求和");
        return a+b;
    }
    public static double sum(double a,double b){
        System.out.println("double类型求和");
        return a+b;
    }
}

 

public class OverloadTest03{
    public static void main(String[] args){
        m1();
        m1(100);
        
        m2(10,3.14);
        m2(3.14,10);
        
        m3(100);
        m3(3.17);
    }
    //m1方法是参数个数不同
    public static void m1(){
        System.out.println("m1无参数的执行！");
    }
    public static void m1(int a){
        System.out.println("m1有一个int参数执行！");
    }
    
    //m2方法是参数的顺序不同
    public static void m2(int x,double y){
        System.out.println("m2(int x,double y)");
    }
    public static void m2(double y,int x){
        System.out.println("m2(double y,int x)");
    }
    
    //m3方法是参数的类型不同
    public static void m3(int x){
        System.out.println("m3(int x)");
    }
    public static void m3(double x){
        System.out.println("m3(double x)");
    }
    
    //m4方法重复了，编译会报错
    public static void m4(int x,int y){
        System.out.println("m4(int x)");
    }
    public static void m4(int a,int b){
        System.out.println("m4(int a)");
    }
    
    //m5方法虽然返回值类型不同，但是在方法调用的时候，返回值可以接收也可以不接收
    //如 就调用时就写 m5(),这时编译会报错，无法区分这两个方法
    //所以方法重载与返回值类型无关
    public static int m5(){
        return;
    }
    public static double m5(){
        return 1.0;
    }
    
    //m6 方法重复了，重载与修饰符列表无关
    void m6(){
        
    }
    public static void m6(){
        
    }
}

方法重载使用总结：同一个类中，方法名相同，形式参数类表不同，和返回值类型，修饰符列表无关