Как я могу оценить, насколько быстро функция javascript позволяет себе называться?

Ответ 1

Сначала вам нужно установить, хотите ли вы ограничить лимит, поскольку вы игнорируете все вызовы функций, которые выполняются в течение периода, когда вы ожидаете, или хотите просто запросить очереди в очереди, чтобы вы не делали больше, чем X запросов в секунду.

Если вы хотите использовать прежнее решение (не обращайте внимания на новые функциональные вызовы), вы должны посмотреть http://documentcloud.github.com/underscore/#throttle

Если вы хотите ограничить лимит, чтобы вы никогда не вызывали свою функцию более X раз в секунду, но не теряете эти вызовы функций, тогда вам нужно совершенно другое решение.

Я написал расширение подчёркивания https://gist.github.com/1084831 Вы можете увидеть рабочий пример в http://jsbin.com/upadif/8/edit#preview

Ответ 2

Это не позволит функции запускать, если прошло меньше 500 миллисекунд с момента последнего вызова.

(function(window, undefined){
    var canCall = true;
    window.funcName = function(){
        if (!canCall) 
            return;
        //Your function
        canCall = false;
        setTimeout(function(){
            canCall = true;
        }, 500);
    }
})(window);

Ответ 3

Вы можете создать флаг, который возникает при вызове функции и запуске таймера, и если этот флаг поднят, то вы не можете вызвать функцию, а затем через определенное время вызывается таймер и он отключает флаг, что позволяет снова вызвать функцию.

Флагом может быть что угодно, как bool или что-то в этом роде.

Ответ 4

Такие библиотеки, как " узкое место" и " ограничитель скорости узла", в значительной степени охватывают все варианты использования.

Ответ 5

Я недавно ответил на это в другом потоке:

Как оценивать лимит ajax-запросов?

Ответ 6

Вы также можете использовать функцию SugarJS "дроссель":

http://sugarjs.com/api/Function/throttle

Ответ 7

Это зависит от того, какую функциональность вы хотите. Вот ссылка на страницу с двумя замечательными функциями: https://remysharp.com/2010/07/21/throttling-function-calls

throttle: обработать первый вызов, затем активировать следующие вызовы на основе порога (первый и последний вызов будут обработаны, но между ними будет только пара)

debounce: не обрабатывать вызовы до тех пор, пока функция не будет вызвана для задержки (только один вызов будет вызван после вызова и довольно продолжительный период)

Ответ 8

Если ваша проблема связана с созданием слишком большого количества работы, используйте очередь:

const work_queue = [];

function queue(message) {
  work_queue.push(message)  
}


function run() {
  const work = work_queue.shift();
  if (work !== undefined) {
    scan_one(work);
  }
}

setInterval(run, 15);

Если ваша проблема связана с функцией, вызываемой слишком часто:

let last = +new Date();

function run() {
  const now = +new Date();
  if (now - last > 5000) { // 5 seconds
    last = now;
    run_once();
  }
}

Ответ 9

fooCanBeCalled = true;
function foo(){
   if(!fooCanBeCalled) return;
   //Whatever you want to do
   fooCanBeCalled = false;
   setTimeout(function(){
      {
         fooCanBecalled = true;
      }
   , delayInMilliseconds);
}

Ответ 10

Вы можете использовать функцию debounce

function debounce(func, wait, immediate) {
    var timeout;
    return function() {
        var context = this,
            args = arguments;
        var later = function() {
            timeout = null;
            if (!immediate) func.apply(context, args);
        };
        var callNow = immediate && !timeout;
        clearTimeout(timeout);
        timeout = setTimeout(later, wait);
        if (callNow) func.apply(context, args);
    };
};

var logging = debounce(function(){
    alert("Heavy task");
}, 5000);

setTimeout(logging, 100);//callback executed after 5 seconds

Дополнительная информация о том, как работает функция debounce http://qnimate.com/javascript-limit-function-call-rate/

Ответ 11

попробуйте setinterval ( "function()", 500)