惯用的方法是使用一个锁变量，可以通过闭包隐藏。最简单的例子是：

var done = false;
function callOnce(lastPosition) {
  if (lastPosition == 0 && !done) {
    done = true;
    callSomeMethod(lastPosition);
  }
}

要 * 产生 * 只能被调用一次的函数，你可以使用闭包和 Package ：

function wrapOnce(fn) {
  var done = false;
  return function (...args) {
    if (!done) {
      done = true;
      return fn.apply(this, args);
    }
  }
}

(the ...args语法可能在旧版浏览器中不起作用，应该用代码来验证arguments并将其传递下去，为了简洁起见，我省略了这一点）
这是像lodash曾经的助手的基础。
由于JS只允许单个线程访问变量，因此这本质上是线程安全的（例如它适用），并且如果多个回调尝试使用once-ified方法，则不会中断。

添加一个标志来跟踪函数是否被调用过：

var wasCalled = false;

// ...

if (lastPosition == 0) {
  if(!wasCalled) {
    wasCalled = true;
    callsomemethod(param);
  }
}

更高级的是，利用闭包来 Package 整个事情：

var callsomemethod = (function(){
  var wasCalled = false;
  return function(param){
    if(wasCalled){
      return;
    }
    else {
      wasCalled = true;
    }
    // callsomemethod()'s inner code goes here
  };
})();

声明一个全局变量var ran=false，在callsomethingmethod中将其设置为true，并扩展你的if：

if(lastposition==0 && ran==false)
{
callsomemethod(param);
}

你可以有一个名为called的布尔值，当你第一次调用这个方法时，它被设置为true：

var called = false;
if (lastPosition == 0) {
  if(!called){
    callsomemethod(param);
    called = true;
  }
}

这里是另一种方法，但类似于以前的响应。您可以使用 Function prototype来添加调用一次行为。在下面的代码中，只有第一次调用才会打印结果。

function callSomeMethod(param){
  console.log('called...'+param);
};

Function.prototype.onlyOnce = function(param){
  if(!this.wasCalled && this == callSomeMethod){
    this(param);
    this.wasCalled = true;
  }
};

function outerMethod(){
  callSomeMethod.onlyOnce('foo');
  callSomeMethod.onlyOnce('bar');
}

outerMethod();

在我react native中，有一个函数（函数名为submitData()）连续运行runs every 10 seconds。我希望在我的submitData（）函数中有另一个函数（函数名为callOnlyOnce()），但这里我只运行了第一次。
所以我用了

let myResult;

  var callOnlyOnce =(function(){
    return function(){
      if (!opop){
        // console.log(`checking value`,executed)
        opop = true
        // console.log(`checking new log value`,executed)
        const x =1
        const y =3
        myResult = x+y
        console.log(`Log inside the function`,myResult,opop)
      }
    }
  })()  
  callOnlyOnce()

opop在main函数之上定义

import * as React from 'react';
let opop = false