Fonction en JavaScript qui ne peut être appelée qu'une seule fois

J'ai besoin de créer une fonction qui ne peut être exécutée qu'une seule fois, à chaque fois après la première, elle ne sera pas exécutée. Je connais de C ++ et Java les variables statiques qui peuvent faire le travail mais j'aimerais savoir s'il existe une manière plus élégante de le faire?

Si par "ne sera pas exécuté" vous voulez dire "ne fera rien s'il est appelé plus d'une fois", vous pouvez créer une fermeture:

var something = (function() {
    var executed = false;
    return function() {
        if (!executed) {
            executed = true;
            // do something
        }
    };
})();

something(); // "do something" happens
something(); // nothing happens

En réponse à un commentaire de @Vladloffe (maintenant supprimé): Avec une variable globale, un autre code pourrait réinitialiser la valeur de l'indicateur "exécuté" (quel que soit le nom que vous choisissez). Avec une fermeture, un autre code n'a aucun moyen de le faire, que ce soit accidentellement ou délibérément.

Comme d'autres réponses le soulignent ici, plusieurs bibliothèques (telles que Underscore et Ramda ) ont une petite fonction utilitaire (généralement nommée once()^[*] ) qui accepte une fonction comme argument et renvoie une autre fonction qui appelle la fonction fournie exactement une fois, quelle que soit la manière dont plusieurs fois, la fonction retournée est appelée. La fonction retournée met également en cache la valeur renvoyée en premier par la fonction fournie et la renvoie lors des appels suivants.

Cependant, si vous n'utilisez pas une telle bibliothèque tierce, mais que vous voulez toujours une telle fonction utilitaire (plutôt que la solution nonce que j'ai proposée ci-dessus), elle est assez facile à implémenter. La plus belle version que j'ai vue est celle publiée par David Walsh :

function once(fn, context) { 
    var result;
    return function() { 
        if (fn) {
            result = fn.apply(context || this, arguments);
            fn = null;
        }
        return result;
    };
}

Je serais enclin à changer fn = null;pour fn = context = null;. Il n'y a aucune raison pour que la fermeture maintienne une référence à contextune fois fna été appelée.

^[*] _{Sachez cependant que d'autres bibliothèques, telles que cette extension Drupal de jQuery , peuvent avoir une fonction nommée once()qui fait quelque chose de très différent.}

Remplacez-le par une fonction NOOP réutilisable (sans opération) .

// this function does nothing
function noop() {};

function foo() {
    foo = noop; // swap the functions

    // do your thing
}

function bar() {
    bar = noop; // swap the functions

    // do your thing
}

Pointez sur une fonction vide une fois qu'elle a été appelée:

function myFunc(){
     myFunc = function(){}; // kill it as soon as it was called
     console.log('call once and never again!'); // your stuff here
};

<button onClick=myFunc()>Call myFunc()</button>

Ou, comme ça:

var myFunc = function func(){
     if( myFunc.fired ) return;
     myFunc.fired = true;
     console.log('called once and never again!'); // your stuff here
};

// even if referenced & "renamed"
((refToMyfunc)=>{
  setInterval(refToMyfunc, 1000);
})(myFunc)

UnderscoreJs a une fonction qui fait cela, underscorejs.org/#once

  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
      memo = func.apply(this, arguments);
      func = null;
      return memo;
    };
  };

En parlant de variables statiques, c'est un peu comme la variante de fermeture:

var once = function() {
    if(once.done) return;
    console.log('Doing this once!');
    once.done = true;
};

once(); once(); 

Vous pouvez alors réinitialiser une fonction si vous le souhaitez:

once.done = false;

var quit = false;

function something() {
    if(quit) {
       return;
    } 
    quit = true;
    ... other code....
}

Vous pourriez simplement avoir la fonction "se supprimer"

​function Once(){
    console.log("run");

    Once = undefined;
}

Once();  // run
Once();  // Uncaught TypeError: undefined is not a function 

Mais ce n'est peut-être pas la meilleure réponse si vous ne voulez pas avaler des erreurs.

Vous pouvez également faire ceci:

function Once(){
    console.log("run");

    Once = function(){};
}

Once(); // run
Once(); // nothing happens

J'en ai besoin pour fonctionner comme un pointeur intelligent, s'il n'y a pas d'éléments de type A, il peut être exécuté, s'il y a un ou plusieurs éléments A, la fonction ne peut pas être exécutée.

function Conditional(){
    if (!<no elements from type A>) return;

    // do stuff
}

essaye ça

var fun = (function() {
  var called = false;
  return function() {
    if (!called) {
      console.log("I  called");
      called = true;
    }
  }
})()

D'un mec nommé Crockford ... :)

function once(func) {
    return function () {
        var f = func;
        func = null;
        return f.apply(
            this,
            arguments
        );
    };
}

invalidateFonction réutilisable qui fonctionne avec setInterval:

var myFunc = function (){
  if (invalidate(arguments)) return;
  console.log('called once and never again!'); // your stuff here
};

const invalidate = function(a) {
  var fired = a.callee.fired;
  a.callee.fired = true;
  return fired;
}

setInterval(myFunc, 1000);

Essayez-le sur JSBin: https://jsbin.com/vicipar/edit?js,console

Variation de réponse de Bunyk

Voici un exemple JSFiddle - http://jsfiddle.net/6yL6t/

Et le code:

function hashCode(str) {
    var hash = 0, i, chr, len;
    if (str.length == 0) return hash;
    for (i = 0, len = str.length; i < len; i++) {
        chr   = str.charCodeAt(i);
        hash  = ((hash << 5) - hash) + chr;
        hash |= 0; // Convert to 32bit integer
    }
    return hash;
}

var onceHashes = {};

function once(func) {
    var unique = hashCode(func.toString().match(/function[^{]+\{([\s\S]*)\}$/)[1]);

    if (!onceHashes[unique]) {
        onceHashes[unique] = true;
        func();
    }
}

Vous pourriez faire:

for (var i=0; i<10; i++) {
    once(function() {
        alert(i);
    });
}

Et il ne fonctionnera qu'une seule fois :)

La configuration initiale:

var once = function( once_fn ) {
    var ret, is_called;
    // return new function which is our control function 
    // to make sure once_fn is only called once:
    return function(arg1, arg2, arg3) {
        if ( is_called ) return ret;
        is_called = true;
        // return the result from once_fn and store to so we can return it multiply times:
        // you might wanna look at Function.prototype.apply:
        ret = once_fn(arg1, arg2, arg3);
        return ret;
    };
}

Si vous utilisez Node.js ou que vous écrivez du JavaScript avec browserify, considérez le module npm "une fois" :

var once = require('once')

function load (file, cb) {
  cb = once(cb)
  loader.load('file')
  loader.once('load', cb)
  loader.once('error', cb)
}

Si vous voulez pouvoir réutiliser la fonction à l'avenir, cela fonctionne bien sur la base du code d'ed Hopp ci-dessus (je me rends compte que la question d'origine n'appelait pas cette fonctionnalité supplémentaire!):

   var something = (function() {
   var executed = false;              
    return function(value) {
        // if an argument is not present then
        if(arguments.length == 0) {               
            if (!executed) {
            executed = true;
            //Do stuff here only once unless reset
            console.log("Hello World!");
            }
            else return;

        } else {
            // otherwise allow the function to fire again
            executed = value;
            return;
        }       
    }
})();

something();//Hello World!
something();
something();
console.log("Reset"); //Reset
something(false);
something();//Hello World!
something();
something();

La sortie ressemble à:

Hello World!
Reset
Hello World!

décorateur simple et facile à écrire quand vous en avez besoin

function one(func) {
  return function () {
     func && func.apply(this, arguments);
     func = null;
  }
}

en utilisant:

var initializer= one( _ =>{
      console.log('initializing')
  })

initializer() // 'initializing'
initializer() // nop
initializer() // nop

Essayer d'utiliser la fonction de soulignement "une fois":

var initialize = _.once(createApplication);
initialize();
initialize();
// Application is only created once.

http://underscorejs.org/#once

var init = function() {
    console.log("logges only once");
    init = false;
}; 

if(init) { init(); }

/* next time executing init() will cause error because now init is 
   -equal to false, thus typing init will return false; */

Si vous utilisez Ramda, vous pouvez utiliser la fonction "une fois" .

Une citation de la documentation:

once Fonction (a… → b) → (a… → b) PARAMÈTRES Ajouté dans la v0.1.0

Accepte une fonction fn et retourne une fonction qui protège l'invocation de fn de telle sorte que fn ne puisse être appelée qu'une seule fois, quel que soit le nombre de fois où la fonction retournée est appelée. La première valeur calculée est renvoyée dans les appels suivants.

var addOneOnce = R.once(x => x + 1);
addOneOnce(10); //=> 11
addOneOnce(addOneOnce(50)); //=> 11

restez aussi simple que possible

function sree(){
  console.log('hey');
  window.sree = _=>{};
}

Vous pouvez voir le résultat

JQuery permet d'appeler la fonction une seule fois en utilisant la méthode one () :

let func = function() {
  console.log('Calling just once!');
}
  
let elem = $('#example');
  
elem.one('click', func);

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
  <p>Function that can be called only once</p>
  <button id="example" >JQuery one()</button>
</div>

Implémentation à l'aide de la méthode JQuery sur () :

let func = function(e) {
  console.log('Calling just once!');
  $(e.target).off(e.type, func)
}
  
let elem = $('#example');
  
elem.on('click', func);

<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
  <p>Function that can be called only once</p>
  <button id="example" >JQuery on()</button>
</div>

Implémentation à l'aide de JS natif:

let func = function(e) {
  console.log('Calling just once!');
  e.target.removeEventListener(e.type, func);
}
  
let elem = document.getElementById('example');
  
elem.addEventListener('click', func);

<div>
  <p>Functions that can be called only once</p>
  <button id="example" >ECMAScript addEventListener</button>
</div>

if (!window.doesThisOnce){
  function myFunction() {
    // do something
    window.doesThisOnce = true;
  };
};

Celui-ci est utile pour éviter les boucles infinies (en utilisant jQuery):

<script>
var doIt = true;
if(doIt){
  // do stuff
  $('body').html(String($('body').html()).replace("var doIt = true;", 
                                                  "var doIt = false;"));
} 
</script>

Si vous vous inquiétez de la pollution de l'espace de noms, remplacez une longue chaîne aléatoire par "doIt".

Cela aide à éviter une exécution collante

var done = false;

function doItOnce(func){
  if(!done){
    done = true;
    func()
  }
  setTimeout(function(){
    done = false;
  },1000)
}