Avantages des fonctions prioritaires ?

Question

function a(){
    alert('A');
    a = function(){
        alert('B');
    };
}

function a(){
    alert('A');
    return function(){
        alert('B');
    };
}

Cette fonction se réécrit après avoir été appelée pour la première fois, évitant ainsi une répétition inutile des opérations à chaque appel. Comment comprendre cela concrètement ? Le thread d'exécution de la fonction n'est-il pas le même avant et après la réécriture de la fonction ?

Answer 1

Par exemple, différents navigateurs ont des noms d'API différents, et si vous souhaitez encapsuler une interface unifiée, votre code ressemblera à ceci

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

Answer 2

Différencie un état booléen sans utiliser de variables supplémentaires et sans utiliser if-else.
Par exemple, certains comportements ont une logique différente dans des situations initialisées et non initialisées, alors vous pouvez écrire comme ceci :

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

Le problème ici est qu'une variable globale est introduite. Ensuite, cette variable peut être encapsulée dans un état interne, qui peut s'écrire comme ceci :

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

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

Si vous utilisez la méthode mentionnée par la personne qui a posé la question :

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

var myAction = action()
myAction()

De plus, cette façon d’écrire semble très fonctionnelle (je ne connais pas grand-chose aux expressions fonctionnelles, donc je n’ose pas être absolu). Voici donc le problème du paradigme de programmation.
Ressentez les trois manières différentes d'écrire suivantes :

Orienté processus :

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')

Orienté objet :

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')

Expression fonctionnelle :

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')

La méthode fonctionnelle présente de nombreux avantages. Pour cela, vous devez comprendre la programmation fonctionnelle.

Answer 3

L'exemple d'API du navigateur ci-dessus est un bon exemple. De manière générale, la réécriture de fonctions consiste davantage à éviter certaines opérations inutiles afin d'optimiser les performances du code.

//就比如说我们经常要通过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);
};

Answer 4

En termes simples

La première fois que vous exécutez une fonction, alert('A') est exécutée, et la deuxième fois qu'elle est exécutée, alert('B').

Il ne s'agit pas tant d'éviter de répéter des opérations inutiles que d'effectuer des opérations supplémentaires. Lorsqu’il est exécuté pour la première fois, il effectue l’opération A, et lorsqu’il s’exécute plus tard, il effectue l’opération B.