JS笔记:方法两次调用,执行不同分支(公共变量,闭包,类三种方法实现)

好家伙,

 

当我们对一个方法进行两次调用,我们希望第一次执行A分支,第二次执行B分支,该怎么做?

这意味着在连续的两次调用中，方法的执行逻辑会交替执行不同的分支。

方法一:公共变量

let flag = 1;

function myMethod() {
    if (flag === 1) {
        // 执行A分支的逻辑
        console.log("执行A分支");
        flag = 2;
    } else if (flag === 2) {
        // 执行B分支的逻辑
        console.log("执行B分支");
        flag = 1;
    }
}

// 第一次调用
myMethod(); // 输出：执行A分支

// 第二次调用
myMethod(); // 输出：执行B分支

 

 

• 优点：
  • 简单直接，能直接想到
• 缺点：
  • 全局变量容易被污染
  • 不利于模块化和封装，容易造成代码耦合度高，难以维护和扩展。

 

方法二:闭包

function createMethodCaller() {
    let flag = 1;

    return function() {
        if (flag === 1) {
            // 执行A分支的逻辑
            console.log("执行A分支");
            flag = 2;
        } else if (flag === 2) {
            // 执行B分支的逻辑
            console.log("执行B分支");
            flag = 1;
        }
    };
}

const myMethod = createMethodCaller();

// 第一次调用
myMethod(); // 输出：执行A分支

// 第二次调用
myMethod(); // 输出：执行B分支

• 

• 优点：
  • 使用闭包可以隐藏变量，避免全局变量污染。
  • 可以模拟私有变量，提高代码的封装性和安全性。
• 缺点：
  • 闭包会增加内存消耗，可能导致内存泄漏问题。
  • 对闭包的理解和使用需要一定的经验，容易出现作用域和内存管理的问题。

 

 

方法三:类

class MethodCaller {
    constructor() {
        this.callCount = 0;
    }

    callMethod() {
        if (this.callCount === 0) {
            // 执行A分支的逻辑
            console.log("执行A分支");
            this.callCount++;
        } else {
            // 执行B分支的逻辑
            console.log("执行B分支");
            this.callCount = 0;
        }
    }
}

const myMethodCaller = new MethodCaller();

// 第一次调用
myMethodCaller.callMethod(); // 输出：执行A分支

// 第二次调用
myMethodCaller.callMethod(); // 输出：执行B分支

 

 

• 优点：
  • 类提供了面向对象的编程方式，有利于封装数据和行为，提高代码的可维护性和可读性。
  • 可以通过类的实例化来管理对象状态，更好地组织和管理代码。
• 缺点：
  • 不容易想到,并且引入类会增加代码的复杂度，不适用于简单的逻辑处理