Sebagai contoh, penyemak imbas yang berbeza mempunyai nama API yang berbeza, dan jika anda ingin merangkum antara muka bersatu, kod anda akan kelihatan seperti ini

function fn(){
    if(chrome){
        fn = function(){};
    }else if(firefox){
        fn = function(){};
    }
    fn();
}

Membezakan keadaan Boolean tanpa menggunakan pembolehubah tambahan dan tanpa menggunakan if-else.
Sebagai contoh, sesetengah gelagat mempunyai logik yang berbeza dalam situasi yang dimulakan dan yang tidak dimulakan, maka anda boleh menulis seperti ini:

var initiated = false
function action () {
    if (initiated) {
        // action 1
    } else {
        // action 2
        initiated = true
    }
}

Perkara buruk di sini ialah pembolehubah global diperkenalkan Kemudian pembolehubah ini boleh dikapsulkan ke dalam keadaan dalaman, yang boleh ditulis seperti ini:

class Action {
    constructor () {
        this.initiated = false
        this._init()
    }
    _init () {
        // action 2
        this.initiated = true
    }
    action () {
        // action 1
    }
}

var myAction = new Action()
myAction.action()

Jika anda menggunakan kaedah yang disebut oleh penanya:

function action () {
    // action 2
    return function () {
        // action 1
    }
}

var myAction = action()
myAction()

Selain itu, cara penulisan ini terasa sangat berfungsi (saya tidak tahu banyak tentang ungkapan berfungsi, jadi saya tidak berani bersikap mutlak). Jadi inilah masalah paradigma pengaturcaraan.
Rasakan tiga cara penulisan yang berbeza berikut:

Berorientasikan proses:

function logger (type, content) {
    var now = new Date()
    if (type === 'debug') {
        console.log('DEBUG::' + now + ' ' + content)
    } else if (type === 'info') {
        console.log('INFO::' + now + ' ' + content)
    }
}

logger('debug', 'xxx')
logger('info', 'xxx')

Berorientasikan objek:

class Logger {
    _now () {
        return new Date()
    }
    debug (content) {
        console.log('DEBUG::' + this._now() + ' ' + content)
    }
    info (content) {
        var now = new Date()
        console.log('INFO::' + this._now() + ' ' + content)
    }
}

var logger = new Logger()
logger.debug('xxx')
logger.info('xxx')

Ungkapan berfungsi:

function logger (type) {
    var prefix = ''
    if (type === 'debug') {
        prefix = 'DEBUG'
    } else if (type === 'info') {
        prefix = 'INFO'
    }
    
    return function (content) {
        var now = new Date()
        console.log(prefix + '::' + now + ' ' + content)
    }
}

var debugLogger = logger('debug')
var infoLogger = logger('info')

debugLogger('xxxx')
infoLogger('xxxx')

Kaedah berfungsi mempunyai banyak kelebihan Anda perlu memahami pengaturcaraan berfungsi untuk ini.

Contoh API penyemak imbas di tingkat atas ialah contoh yang baik Secara umumnya, penulisan semula fungsi lebih kepada mengelakkan operasi yang tidak perlu untuk mengoptimumkan prestasi kod

//就比如说我们经常要通过addEventListener来绑定事件，但是在某些老版本浏览器可能用的是attachEvent和on，这时我们可以：
var bindEvent = function(target,event,handle){
    //下面就是针对性的重写
    if(target.addEventListener){
        bindEvent = function(target,event,handle){
            target.addEventListener(event,handle,false);
        };
    } else if( target.attachEvent ){
        bindEvent = function(target,event,handle){
            target.attachEvent("on"+event,handle);
        };
    } else {
        bindEvent = function(target,event,handle){
            target["on"+event] = handle;
        };
    }
    bindEvent(target,event,handle);
};

Ringkasnya

Kali pertama anda menjalankan fungsi, amaran('A') dilaksanakan dan kali kedua ia dilaksanakan, amaran('B').

Ia bukanlah untuk mengelak daripada mengulangi operasi yang tidak perlu tetapi untuk melakukan operasi tambahan. Apabila ia dijalankan buat kali pertama, ia melakukan perkara A, dan apabila ia dijalankan kemudian, ia melakukan perkara B.