html - Setting a timer in javascript [duplicate] - javascript
I’ve got a search field. Right now it searches for every keyup. So if someone types “Windows”, it will make a search with AJAX for every keyup: “W”, “Wi”, “Win”, “Wind”, “Windo”, “Window”, “Windows”.
I want to have a delay, so it only searches when the user stops typing for 200 ms.
There is no option for this in the keyup function, and I have tried setTimeout, but it didn’t work.
How can I do that?
I use this small function for the same purpose, executing a function after the user has stopped typing for a specified amount of time or in events that fire at a high rate, like resize:
function delay(callback, ms) {
var timer = 0;
return function() {
var context = this, args = arguments;
clearTimeout(timer);
timer = setTimeout(function () {
callback.apply(context, args);
}, ms || 0);
};
}
// Example usage:
$('#input').keyup(delay(function (e) {
console.log('Time elapsed!', this.value);
}, 500));
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<label for="input">Try it:
<input id="input" type="text" placeholder="Type something here..."/>
</label>
How it works:
The delay function will return a wrapped function that internally handles an individual timer, in each execution the timer is restarted with the time delay provided, if multiple executions occur before this time passes, the timer will just reset and start again.
When the timer finally ends, the callback function is executed, passing the original context and arguments (in this example, the jQuery's event object, and the DOM element as this).
UPDATE 2019-05-16
I have re-implemented the function using ES5 and ES6 features for modern environments:
function delay(fn, ms) {
let timer = 0
return function(...args) {
clearTimeout(timer)
timer = setTimeout(fn.bind(this, ...args), ms || 0)
}
}
The implementation is covered with a set of tests.
For something more sophisticated, give a look to the jQuery Typewatch plugin.
If you want to search after the type is done use a global variable to hold the timeout returned from your setTimout call and cancel it with a clearTimeout if it hasn't yet happend so that it won't fire the timeout except on the last keyup event
var globalTimeout = null;
$('#id').keyup(function(){
if(globalTimeout != null) clearTimeout(globalTimeout);
globalTimeout =setTimeout(SearchFunc,200);
}
function SearchFunc(){
globalTimeout = null;
//ajax code
}
Or with an anonymous function :
var globalTimeout = null;
$('#id').keyup(function() {
if (globalTimeout != null) {
clearTimeout(globalTimeout);
}
globalTimeout = setTimeout(function() {
globalTimeout = null;
//ajax code
}, 200);
}
Another slight enhancement on CMS's answer. To easily allow for separate delays, you can use the following:
function makeDelay(ms) {
var timer = 0;
return function(callback){
clearTimeout (timer);
timer = setTimeout(callback, ms);
};
};
If you want to reuse the same delay, just do
var delay = makeDelay(250);
$(selector1).on('keyup', function() {delay(someCallback);});
$(selector2).on('keyup', function() {delay(someCallback);});
If you want separate delays, you can do
$(selector1).on('keyup', function() {makeDelay(250)(someCallback);});
$(selector2).on('keyup', function() {makeDelay(250)(someCallback);});
You could also look at underscore.js, which provides utility methods like debounce:
var lazyLayout = _.debounce(calculateLayout, 300);
$(window).resize(lazyLayout);
Explanation
Use a variable to store the timeout function. Then use clearTimeout() to clear this variable of any active timeout functions, and then use setTimeout() to set the active timeout function again. We run clearTimeout() first, because if a user is typing "hello", we want our function to run shortly after the user presses the "o" key (and not once for each letter).
Working Demo
Super simple approach, designed to run a function after a user has finished typing in a text field...
$(document).ready(function(e) {
var timeout;
var delay = 2000; // 2 seconds
$('.text-input').keyup(function(e) {
$('#status').html("User started typing!");
if(timeout) {
clearTimeout(timeout);
}
timeout = setTimeout(function() {
myFunction();
}, delay);
});
function myFunction() {
$('#status').html("Executing function for user!");
}
});
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
Status: <span id="status">Default Status</span><br>
<textarea name="text-input" class="text-input"></textarea>
Based on the answer of CMS, I made this :
Put the code below after include jQuery :
/*
* delayKeyup
* http://code.azerti.net/javascript/jquery/delaykeyup.htm
* Inspired by CMS in this post : http://stackoverflow.com/questions/1909441/jquery-keyup-delay
* Written by Gaten
* Exemple : $("#input").delayKeyup(function(){ alert("5 secondes passed from the last event keyup."); }, 5000);
*/
(function ($) {
$.fn.delayKeyup = function(callback, ms){
var timer = 0;
$(this).keyup(function(){
clearTimeout (timer);
timer = setTimeout(callback, ms);
});
return $(this);
};
})(jQuery);
And simply use like this :
$('#input').delayKeyup(function(){ alert("5 secondes passed from the last event keyup."); }, 5000);
Careful : the $(this) variable in the function passed as a parameter does not match input
jQuery:
var timeout = null;
$('#input').keyup(function() {
clearTimeout(timeout);
timeout = setTimeout(() => {
console.log($(this).val());
}, 1000);
});
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.2.4/jquery.min.js"></script>
<input type="text" id="input" placeholder="Type here..."/>
Pure Javascript:
let input = document.getElementById('input');
let timeout = null;
input.addEventListener('keyup', function (e) {
clearTimeout(timeout);
timeout = setTimeout(function () {
console.log('Value:', input.value);
}, 1000);
});
<input type="text" id="input" placeholder="Type here..."/>
Delay Multi Function Calls using Labels
This is the solution i work with. It will delay the execution on ANY function you want. It can be the keydown search query, maybe the quick click on previous or next buttons ( that would otherwise send multiple request if quickly clicked continuously , and be not used after all). This uses a global object that stores each execution time, and compares it with the most current request.
So the result is that only that last click / action will actually be called, because those requests are stored in a queue, that after the X milliseconds is called if no other request with the same label exists in the queue!
function delay_method(label,callback,time){
if(typeof window.delayed_methods=="undefined"){window.delayed_methods={};}
delayed_methods[label]=Date.now();
var t=delayed_methods[label];
setTimeout(function(){ if(delayed_methods[label]!=t){return;}else{ delayed_methods[label]=""; callback();}}, time||500);
}
You can set your own delay time ( its optional, defaults to 500ms). And send your function arguments in a "closure fashion".
For example if you want to call the bellow function:
function send_ajax(id){console.log(id);}
To prevent multiple send_ajax requests, you delay them using:
delay_method( "check date", function(){ send_ajax(2); } ,600);
Every request that uses the label "check date" will only be triggered if no other request is made in the 600 miliseconds timeframe. This argument is optional
Label independency (calling the same target function) but run both:
delay_method("check date parallel", function(){send_ajax(2);});
delay_method("check date", function(){send_ajax(2);});
Results in calling the same function but delay them independently because of their labels being different
If someone like to delay the same function, and without external variable he can use the next script:
function MyFunction() {
//Delaying the function execute
if (this.timer) {
window.clearTimeout(this.timer);
}
this.timer = window.setTimeout(function() {
//Execute the function code here...
}, 500);
}
This function extends the function from Gaten's answer a bit in order to get the element back:
$.fn.delayKeyup = function(callback, ms){
var timer = 0;
var el = $(this);
$(this).keyup(function(){
clearTimeout (timer);
timer = setTimeout(function(){
callback(el)
}, ms);
});
return $(this);
};
$('#input').delayKeyup(function(el){
//alert(el.val());
// Here I need the input element (value for ajax call) for further process
},1000);
http://jsfiddle.net/Us9bu/2/
I'm surprised that nobody mention the problem with multiple input in CMS's very nice snipped.
Basically, you would have to define delay variable individually for each input. Otherwise if sb put text to first input and quickly jump to other input and start typing, callback for the first one WON'T be called!
See the code below I came with based on other answers:
(function($) {
/**
* KeyUp with delay event setup
*
* #link http://stackoverflow.com/questions/1909441/jquery-keyup-delay#answer-12581187
* #param function callback
* #param int ms
*/
$.fn.delayKeyup = function(callback, ms){
$(this).keyup(function( event ){
var srcEl = event.currentTarget;
if( srcEl.delayTimer )
clearTimeout (srcEl.delayTimer );
srcEl.delayTimer = setTimeout(function(){ callback( $(srcEl) ); }, ms);
});
return $(this);
};
})(jQuery);
This solution keeps setTimeout reference within input's delayTimer variable. It also passes reference of element to callback as fazzyx suggested.
Tested in IE6, 8(comp - 7), 8 and Opera 12.11.
This worked for me where I delay the search logic operation and make a check if the value is same as entered in text field. If value is same then I go ahead and perform the operation for the data related to search value.
$('#searchText').on('keyup',function () {
var searchValue = $(this).val();
setTimeout(function(){
if(searchValue == $('#searchText').val() && searchValue != null && searchValue != "") {
// logic to fetch data based on searchValue
}
else if(searchValue == ''){
// logic to load all the data
}
},300);
});
Delay function to call up on every keyup.
jQuery 1.7.1 or up required
jQuery.fn.keyupDelay = function( cb, delay ){
if(delay == null){
delay = 400;
}
var timer = 0;
return $(this).on('keyup',function(){
clearTimeout(timer);
timer = setTimeout( cb , delay );
});
}
Usage: $('#searchBox').keyupDelay( cb );
From ES6, one can use arrow function syntax as well.
In this example, the code delays keyup event for 400ms after users finish typeing before calling searchFunc make a query request.
const searchbar = document.getElementById('searchBar');
const searchFunc = // any function
// wait ms (milliseconds) after user stops typing to execute func
const delayKeyUp = (() => {
let timer = null;
const delay = (func, ms) => {
timer ? clearTimeout(timer): null
timer = setTimeout(func, ms)
}
return delay
})();
searchbar.addEventListener('keyup', (e) => {
const query = e.target.value;
delayKeyUp(() => {searchFunc(query)}, 400);
})
Updated Typescript version:
const delayKeyUp = (() => {
let timer: NodeJS.Timeout;
return (func: Function, ms: number) => {
timer ? clearTimeout(timer) : null;
timer = setTimeout(() => func(), ms);
};
})();
This is a solution along the lines of CMS's, but solves a few key issues for me:
Supports multiple inputs, delays can run concurrently.
Ignores key events that didn't changed the value (like Ctrl, Alt+Tab).
Solves a race condition (when the callback is executed and the value already changed).
var delay = (function() {
var timer = {}
, values = {}
return function(el) {
var id = el.form.id + '.' + el.name
return {
enqueue: function(ms, cb) {
if (values[id] == el.value) return
if (!el.value) return
var original = values[id] = el.value
clearTimeout(timer[id])
timer[id] = setTimeout(function() {
if (original != el.value) return // solves race condition
cb.apply(el)
}, ms)
}
}
}
}())
Usage:
signup.key.addEventListener('keyup', function() {
delay(this).enqueue(300, function() {
console.log(this.value)
})
})
The code is written in a style I enjoy, you may need to add a bunch of semicolons.
Things to keep in mind:
A unique id is generated based on the form id and input name, so they must be defined and unique, or you could adjust it to your situation.
delay returns an object that's easy to extend for your own needs.
The original element used for delay is bound to the callback, so this works as expected (like in the example).
Empty value is ignored in the second validation.
Watch out for enqueue, it expects milliseconds first, I prefer that, but you may want to switch the parameters to match setTimeout.
The solution I use adds another level of complexity, allowing you to cancel execution, for example, but this is a good base to build on.
Combining CMS answer with Miguel's one yields a robust solution allowing concurrent delays.
var delay = (function(){
var timers = {};
return function (callback, ms, label) {
label = label || 'defaultTimer';
clearTimeout(timers[label] || 0);
timers[label] = setTimeout(callback, ms);
};
})();
When you need to delay different actions independently, use the third argument.
$('input.group1').keyup(function() {
delay(function(){
alert('Time elapsed!');
}, 1000, 'firstAction');
});
$('input.group2').keyup(function() {
delay(function(){
alert('Time elapsed!');
}, 1000, '2ndAction');
});
Building upon CMS's answer here's new delay method which preserves 'this' in its usage:
var delay = (function(){
var timer = 0;
return function(callback, ms, that){
clearTimeout (timer);
timer = setTimeout(callback.bind(that), ms);
};
})();
Usage:
$('input').keyup(function() {
delay(function(){
alert('Time elapsed!');
}, 1000, this);
});
If you want to do something after a period of time and reset that timer after a specific event like keyup, the best solution is made with clearTimeout and setTimeout methods:
// declare the timeout variable out of the event listener or in the global scope
var timeout = null;
$(".some-class-or-selector-to-bind-event").keyup(function() {
clearTimeout(timout); // this will clear the recursive unneccessary calls
timeout = setTimeout(() => {
// do something: send an ajax or call a function here
}, 2000);
// wait two seconds
});
Use
mytimeout = setTimeout( expression, timeout );
where expression is the script to run and timeout is the time to wait in milliseconds before it runs - this does NOT hault the script, but simply delays execution of that part until the timeout is done.
clearTimeout(mytimeout);
will reset/clear the timeout so it does not run the script in expression (like a cancel) as long as it has not yet been executed.
Based on the answer of CMS, it just ignores the key events that doesn't change value.
var delay = (function(){
var timer = 0;
return function(callback, ms){
clearTimeout (timer);
timer = setTimeout(callback, ms);
};
})();
var duplicateFilter=(function(){
var lastContent;
return function(content,callback){
content=$.trim(content);
if(content!=lastContent){
callback(content);
}
lastContent=content;
};
})();
$("#some-input").on("keyup",function(ev){
var self=this;
delay(function(){
duplicateFilter($(self).val(),function(c){
//do sth...
console.log(c);
});
}, 1000 );
})
User lodash javascript library and use _.debounce function
changeName: _.debounce(function (val) {
console.log(val)
}, 1000)
Use the bindWithDelay jQuery plugin:
element.bindWithDelay(eventType, [ eventData ], handler(eventObject), timeout, throttle)
var globalTimeout = null;
$('#search').keyup(function(){
if(globalTimeout != null) clearTimeout(globalTimeout);
globalTimeout =setTimeout(SearchFunc,200);
});
function SearchFunc(){
globalTimeout = null;
console.log('Search: '+$('#search').val());
//ajax code
};
Here is a suggestion I have written that takes care of multiple input in your form.
This function gets the Object of the input field, put in your code
function fieldKeyup(obj){
// what you want this to do
} // fieldKeyup
This is the actual delayCall function, takes care of multiple input fields
function delayCall(obj,ms,fn){
return $(obj).each(function(){
if ( typeof this.timer == 'undefined' ) {
// Define an array to keep track of all fields needed delays
// This is in order to make this a multiple delay handling
function
this.timer = new Array();
}
var obj = this;
if (this.timer[obj.id]){
clearTimeout(this.timer[obj.id]);
delete(this.timer[obj.id]);
}
this.timer[obj.id] = setTimeout(function(){
fn(obj);}, ms);
});
}; // delayCall
Usage:
$("#username").on("keyup",function(){
delayCall($(this),500,fieldKeyup);
});
Take a look at the autocomplete plugin. I know that it allows you to specify a delay or a minimum number of characters. Even if you don't end up using the plugin, looking through the code will give you some ideas on how to implement it yourself.
Well, i also made a piece of code for limit high frequency ajax request cause by Keyup / Keydown. Check this out:
https://github.com/raincious/jQueue
Do your query like this:
var q = new jQueue(function(type, name, callback) {
return $.post("/api/account/user_existed/", {Method: type, Value: name}).done(callback);
}, 'Flush', 1500); // Make sure use Flush mode.
And bind event like this:
$('#field-username').keyup(function() {
q.run('Username', this.val(), function() { /* calling back */ });
});
Saw this today a little late but just want to put this here in case someone else needed. just separate the function to make it reusable. the code below will wait 1/2 second after typing stop.
var timeOutVar
$(selector).on('keyup', function() {
clearTimeout(timeOutVar);
timeOutVar= setTimeout(function(){ console.log("Hello"); }, 500);
});
// Get an global variable isApiCallingInProgress
// check isApiCallingInProgress
if (!isApiCallingInProgress) {
// set it to isApiCallingInProgress true
isApiCallingInProgress = true;
// set timeout
setTimeout(() => {
// Api call will go here
// then set variable again as false
isApiCallingInProgress = false;
}, 1000);
}
Related
How to send data with delay vue js?
every time when i use input , my function send data to server and i get response, but if i want to write in field 'name' - Thomas Edison , i will send letter by letter i try to put setTimeout function and if user still writing a string nothing will be send , but i does not work #input="throttledSave" throttledSave (e) { let eva = e let DELAY = 2000; if(e.target.value){ return this.throttle(this.setDataFinalJSON, DELAY, eva); } }, throttle: function (callback, limit,eva) { var wait = false; var typingTimer; return function (callback, limit,eva) { clearTimeout(typingTimer) if (!wait) { callback(eva); wait = true; typingTimer = setTimeout(function () { console.log('oh again') wait = false; }, limit); } } } every time it is work until DELAY , i don't know why, maybe clearTimeout does not work , i got stuck. I don't know why if i write some text so fast i got console.log('oh again')
You could do this with lodash debounce (https://lodash.com/docs/4.17.15#debounce) method: Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a cancel method to cancel delayed func invocations and a flush method to immediately invoke them. Provide options to indicate whether func should be invoked on the leading and/or trailing edge of the wait timeout. The func is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last func invocation. _.debounce(func, [wait=0], [options={}]) Example: methods: { throttledMethod: _.debounce(() => { console.log('I only get fired once every two seconds, max!') }, 2000) } Best to use the vue variant of lodash: https://www.npmjs.com/package/vue-lodash
Timeout just delays each input event (so that each one causes the request, just after some time) which is not what you want. The basic idea of implementing this is simple: store the time of the last input event in the model, and on input, send your requests only when timeout has passed, something like: data () { return { ... lastInputTime: null, inputTimeout: 1000 // ms } }, ... methods: { throttledSave (e) { const attemptTime = new Date(); if(this.lastInputTime && attemptTime - this.lastInputTime > this.inputTimeout) { // get value, send request etc } this.lastInputTime = attemptTime; } Well, this is exactly what is called debounce, dreijntjens suggests a similar thing but using a library which allows to decorate your function. PS Actually, such decorating is a better approach (unless you are planning to change inputTimeout in runtime) since you don't clutter your model with extra stuff specific to debouncing; you can make your own "decorator" (not in the strict sence, decorators are supposed to have special syntax, rather than being a function that gets your function and returns a modified one) if your project doesn't tree-shake libraries properly. Something like this: function debounce(func, timeout) { let lastTime = null; return function() { const attemptTime = new Date(); if(lastTime && attemptTime - lastTime > timeout) { func.apply(this, arguments); } lastTime = attemptTime; } } lodash's implementation is much more sophisticated since it supports several options.
How about using the lazy input model modifier? VueJS prototype for delayed (lazy) input Vue.prototype.lazyInput = function(e, delay) { const self = this; if (typeof delay == 'undefined') { delay = 500; } const target = e.target; if (self.lazyTimer) { clearTimeout(self.lazyTimer); self.lazyTimer = null; } self.lazyTimer = setTimeout(function(){ target.dispatchEvent(new Event('change')); }, delay); } Usage: <input v-model.lazy="{variableName}" #input="lazyInput($event)">
You can always use the native setTimeout() methods: { search: function (event) { clearTimeout(this.timeout) this.timeout = setTimeout(() => { ... XMLHttpRequest ... }, 2000) every 2000 msec sending request if no new data.
How to add delay to filter function on keyup event in Primefaces? [duplicate]
I’ve got a search field. Right now it searches for every keyup. So if someone types “Windows”, it will make a search with AJAX for every keyup: “W”, “Wi”, “Win”, “Wind”, “Windo”, “Window”, “Windows”. I want to have a delay, so it only searches when the user stops typing for 200 ms. There is no option for this in the keyup function, and I have tried setTimeout, but it didn’t work. How can I do that?
I use this small function for the same purpose, executing a function after the user has stopped typing for a specified amount of time or in events that fire at a high rate, like resize: function delay(callback, ms) { var timer = 0; return function() { var context = this, args = arguments; clearTimeout(timer); timer = setTimeout(function () { callback.apply(context, args); }, ms || 0); }; } // Example usage: $('#input').keyup(delay(function (e) { console.log('Time elapsed!', this.value); }, 500)); <script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <label for="input">Try it: <input id="input" type="text" placeholder="Type something here..."/> </label> How it works: The delay function will return a wrapped function that internally handles an individual timer, in each execution the timer is restarted with the time delay provided, if multiple executions occur before this time passes, the timer will just reset and start again. When the timer finally ends, the callback function is executed, passing the original context and arguments (in this example, the jQuery's event object, and the DOM element as this). UPDATE 2019-05-16 I have re-implemented the function using ES5 and ES6 features for modern environments: function delay(fn, ms) { let timer = 0 return function(...args) { clearTimeout(timer) timer = setTimeout(fn.bind(this, ...args), ms || 0) } } The implementation is covered with a set of tests. For something more sophisticated, give a look to the jQuery Typewatch plugin.
If you want to search after the type is done use a global variable to hold the timeout returned from your setTimout call and cancel it with a clearTimeout if it hasn't yet happend so that it won't fire the timeout except on the last keyup event var globalTimeout = null; $('#id').keyup(function(){ if(globalTimeout != null) clearTimeout(globalTimeout); globalTimeout =setTimeout(SearchFunc,200); } function SearchFunc(){ globalTimeout = null; //ajax code } Or with an anonymous function : var globalTimeout = null; $('#id').keyup(function() { if (globalTimeout != null) { clearTimeout(globalTimeout); } globalTimeout = setTimeout(function() { globalTimeout = null; //ajax code }, 200); }
Another slight enhancement on CMS's answer. To easily allow for separate delays, you can use the following: function makeDelay(ms) { var timer = 0; return function(callback){ clearTimeout (timer); timer = setTimeout(callback, ms); }; }; If you want to reuse the same delay, just do var delay = makeDelay(250); $(selector1).on('keyup', function() {delay(someCallback);}); $(selector2).on('keyup', function() {delay(someCallback);}); If you want separate delays, you can do $(selector1).on('keyup', function() {makeDelay(250)(someCallback);}); $(selector2).on('keyup', function() {makeDelay(250)(someCallback);});
You could also look at underscore.js, which provides utility methods like debounce: var lazyLayout = _.debounce(calculateLayout, 300); $(window).resize(lazyLayout);
Explanation Use a variable to store the timeout function. Then use clearTimeout() to clear this variable of any active timeout functions, and then use setTimeout() to set the active timeout function again. We run clearTimeout() first, because if a user is typing "hello", we want our function to run shortly after the user presses the "o" key (and not once for each letter). Working Demo Super simple approach, designed to run a function after a user has finished typing in a text field... $(document).ready(function(e) { var timeout; var delay = 2000; // 2 seconds $('.text-input').keyup(function(e) { $('#status').html("User started typing!"); if(timeout) { clearTimeout(timeout); } timeout = setTimeout(function() { myFunction(); }, delay); }); function myFunction() { $('#status').html("Executing function for user!"); } }); <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script> Status: <span id="status">Default Status</span><br> <textarea name="text-input" class="text-input"></textarea>
Based on the answer of CMS, I made this : Put the code below after include jQuery : /* * delayKeyup * http://code.azerti.net/javascript/jquery/delaykeyup.htm * Inspired by CMS in this post : http://stackoverflow.com/questions/1909441/jquery-keyup-delay * Written by Gaten * Exemple : $("#input").delayKeyup(function(){ alert("5 secondes passed from the last event keyup."); }, 5000); */ (function ($) { $.fn.delayKeyup = function(callback, ms){ var timer = 0; $(this).keyup(function(){ clearTimeout (timer); timer = setTimeout(callback, ms); }); return $(this); }; })(jQuery); And simply use like this : $('#input').delayKeyup(function(){ alert("5 secondes passed from the last event keyup."); }, 5000); Careful : the $(this) variable in the function passed as a parameter does not match input
jQuery: var timeout = null; $('#input').keyup(function() { clearTimeout(timeout); timeout = setTimeout(() => { console.log($(this).val()); }, 1000); }); <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.2.4/jquery.min.js"></script> <input type="text" id="input" placeholder="Type here..."/> Pure Javascript: let input = document.getElementById('input'); let timeout = null; input.addEventListener('keyup', function (e) { clearTimeout(timeout); timeout = setTimeout(function () { console.log('Value:', input.value); }, 1000); }); <input type="text" id="input" placeholder="Type here..."/>
Delay Multi Function Calls using Labels This is the solution i work with. It will delay the execution on ANY function you want. It can be the keydown search query, maybe the quick click on previous or next buttons ( that would otherwise send multiple request if quickly clicked continuously , and be not used after all). This uses a global object that stores each execution time, and compares it with the most current request. So the result is that only that last click / action will actually be called, because those requests are stored in a queue, that after the X milliseconds is called if no other request with the same label exists in the queue! function delay_method(label,callback,time){ if(typeof window.delayed_methods=="undefined"){window.delayed_methods={};} delayed_methods[label]=Date.now(); var t=delayed_methods[label]; setTimeout(function(){ if(delayed_methods[label]!=t){return;}else{ delayed_methods[label]=""; callback();}}, time||500); } You can set your own delay time ( its optional, defaults to 500ms). And send your function arguments in a "closure fashion". For example if you want to call the bellow function: function send_ajax(id){console.log(id);} To prevent multiple send_ajax requests, you delay them using: delay_method( "check date", function(){ send_ajax(2); } ,600); Every request that uses the label "check date" will only be triggered if no other request is made in the 600 miliseconds timeframe. This argument is optional Label independency (calling the same target function) but run both: delay_method("check date parallel", function(){send_ajax(2);}); delay_method("check date", function(){send_ajax(2);}); Results in calling the same function but delay them independently because of their labels being different
If someone like to delay the same function, and without external variable he can use the next script: function MyFunction() { //Delaying the function execute if (this.timer) { window.clearTimeout(this.timer); } this.timer = window.setTimeout(function() { //Execute the function code here... }, 500); }
This function extends the function from Gaten's answer a bit in order to get the element back: $.fn.delayKeyup = function(callback, ms){ var timer = 0; var el = $(this); $(this).keyup(function(){ clearTimeout (timer); timer = setTimeout(function(){ callback(el) }, ms); }); return $(this); }; $('#input').delayKeyup(function(el){ //alert(el.val()); // Here I need the input element (value for ajax call) for further process },1000); http://jsfiddle.net/Us9bu/2/
I'm surprised that nobody mention the problem with multiple input in CMS's very nice snipped. Basically, you would have to define delay variable individually for each input. Otherwise if sb put text to first input and quickly jump to other input and start typing, callback for the first one WON'T be called! See the code below I came with based on other answers: (function($) { /** * KeyUp with delay event setup * * #link http://stackoverflow.com/questions/1909441/jquery-keyup-delay#answer-12581187 * #param function callback * #param int ms */ $.fn.delayKeyup = function(callback, ms){ $(this).keyup(function( event ){ var srcEl = event.currentTarget; if( srcEl.delayTimer ) clearTimeout (srcEl.delayTimer ); srcEl.delayTimer = setTimeout(function(){ callback( $(srcEl) ); }, ms); }); return $(this); }; })(jQuery); This solution keeps setTimeout reference within input's delayTimer variable. It also passes reference of element to callback as fazzyx suggested. Tested in IE6, 8(comp - 7), 8 and Opera 12.11.
This worked for me where I delay the search logic operation and make a check if the value is same as entered in text field. If value is same then I go ahead and perform the operation for the data related to search value. $('#searchText').on('keyup',function () { var searchValue = $(this).val(); setTimeout(function(){ if(searchValue == $('#searchText').val() && searchValue != null && searchValue != "") { // logic to fetch data based on searchValue } else if(searchValue == ''){ // logic to load all the data } },300); });
Delay function to call up on every keyup. jQuery 1.7.1 or up required jQuery.fn.keyupDelay = function( cb, delay ){ if(delay == null){ delay = 400; } var timer = 0; return $(this).on('keyup',function(){ clearTimeout(timer); timer = setTimeout( cb , delay ); }); } Usage: $('#searchBox').keyupDelay( cb );
From ES6, one can use arrow function syntax as well. In this example, the code delays keyup event for 400ms after users finish typeing before calling searchFunc make a query request. const searchbar = document.getElementById('searchBar'); const searchFunc = // any function // wait ms (milliseconds) after user stops typing to execute func const delayKeyUp = (() => { let timer = null; const delay = (func, ms) => { timer ? clearTimeout(timer): null timer = setTimeout(func, ms) } return delay })(); searchbar.addEventListener('keyup', (e) => { const query = e.target.value; delayKeyUp(() => {searchFunc(query)}, 400); }) Updated Typescript version: const delayKeyUp = (() => { let timer: NodeJS.Timeout; return (func: Function, ms: number) => { timer ? clearTimeout(timer) : null; timer = setTimeout(() => func(), ms); }; })();
This is a solution along the lines of CMS's, but solves a few key issues for me: Supports multiple inputs, delays can run concurrently. Ignores key events that didn't changed the value (like Ctrl, Alt+Tab). Solves a race condition (when the callback is executed and the value already changed). var delay = (function() { var timer = {} , values = {} return function(el) { var id = el.form.id + '.' + el.name return { enqueue: function(ms, cb) { if (values[id] == el.value) return if (!el.value) return var original = values[id] = el.value clearTimeout(timer[id]) timer[id] = setTimeout(function() { if (original != el.value) return // solves race condition cb.apply(el) }, ms) } } } }()) Usage: signup.key.addEventListener('keyup', function() { delay(this).enqueue(300, function() { console.log(this.value) }) }) The code is written in a style I enjoy, you may need to add a bunch of semicolons. Things to keep in mind: A unique id is generated based on the form id and input name, so they must be defined and unique, or you could adjust it to your situation. delay returns an object that's easy to extend for your own needs. The original element used for delay is bound to the callback, so this works as expected (like in the example). Empty value is ignored in the second validation. Watch out for enqueue, it expects milliseconds first, I prefer that, but you may want to switch the parameters to match setTimeout. The solution I use adds another level of complexity, allowing you to cancel execution, for example, but this is a good base to build on.
Combining CMS answer with Miguel's one yields a robust solution allowing concurrent delays. var delay = (function(){ var timers = {}; return function (callback, ms, label) { label = label || 'defaultTimer'; clearTimeout(timers[label] || 0); timers[label] = setTimeout(callback, ms); }; })(); When you need to delay different actions independently, use the third argument. $('input.group1').keyup(function() { delay(function(){ alert('Time elapsed!'); }, 1000, 'firstAction'); }); $('input.group2').keyup(function() { delay(function(){ alert('Time elapsed!'); }, 1000, '2ndAction'); });
Building upon CMS's answer here's new delay method which preserves 'this' in its usage: var delay = (function(){ var timer = 0; return function(callback, ms, that){ clearTimeout (timer); timer = setTimeout(callback.bind(that), ms); }; })(); Usage: $('input').keyup(function() { delay(function(){ alert('Time elapsed!'); }, 1000, this); });
If you want to do something after a period of time and reset that timer after a specific event like keyup, the best solution is made with clearTimeout and setTimeout methods: // declare the timeout variable out of the event listener or in the global scope var timeout = null; $(".some-class-or-selector-to-bind-event").keyup(function() { clearTimeout(timout); // this will clear the recursive unneccessary calls timeout = setTimeout(() => { // do something: send an ajax or call a function here }, 2000); // wait two seconds });
Use mytimeout = setTimeout( expression, timeout ); where expression is the script to run and timeout is the time to wait in milliseconds before it runs - this does NOT hault the script, but simply delays execution of that part until the timeout is done. clearTimeout(mytimeout); will reset/clear the timeout so it does not run the script in expression (like a cancel) as long as it has not yet been executed.
Based on the answer of CMS, it just ignores the key events that doesn't change value. var delay = (function(){ var timer = 0; return function(callback, ms){ clearTimeout (timer); timer = setTimeout(callback, ms); }; })(); var duplicateFilter=(function(){ var lastContent; return function(content,callback){ content=$.trim(content); if(content!=lastContent){ callback(content); } lastContent=content; }; })(); $("#some-input").on("keyup",function(ev){ var self=this; delay(function(){ duplicateFilter($(self).val(),function(c){ //do sth... console.log(c); }); }, 1000 ); })
User lodash javascript library and use _.debounce function changeName: _.debounce(function (val) { console.log(val) }, 1000)
Use the bindWithDelay jQuery plugin: element.bindWithDelay(eventType, [ eventData ], handler(eventObject), timeout, throttle)
var globalTimeout = null; $('#search').keyup(function(){ if(globalTimeout != null) clearTimeout(globalTimeout); globalTimeout =setTimeout(SearchFunc,200); }); function SearchFunc(){ globalTimeout = null; console.log('Search: '+$('#search').val()); //ajax code };
Here is a suggestion I have written that takes care of multiple input in your form. This function gets the Object of the input field, put in your code function fieldKeyup(obj){ // what you want this to do } // fieldKeyup This is the actual delayCall function, takes care of multiple input fields function delayCall(obj,ms,fn){ return $(obj).each(function(){ if ( typeof this.timer == 'undefined' ) { // Define an array to keep track of all fields needed delays // This is in order to make this a multiple delay handling function this.timer = new Array(); } var obj = this; if (this.timer[obj.id]){ clearTimeout(this.timer[obj.id]); delete(this.timer[obj.id]); } this.timer[obj.id] = setTimeout(function(){ fn(obj);}, ms); }); }; // delayCall Usage: $("#username").on("keyup",function(){ delayCall($(this),500,fieldKeyup); });
Take a look at the autocomplete plugin. I know that it allows you to specify a delay or a minimum number of characters. Even if you don't end up using the plugin, looking through the code will give you some ideas on how to implement it yourself.
Well, i also made a piece of code for limit high frequency ajax request cause by Keyup / Keydown. Check this out: https://github.com/raincious/jQueue Do your query like this: var q = new jQueue(function(type, name, callback) { return $.post("/api/account/user_existed/", {Method: type, Value: name}).done(callback); }, 'Flush', 1500); // Make sure use Flush mode. And bind event like this: $('#field-username').keyup(function() { q.run('Username', this.val(), function() { /* calling back */ }); });
Saw this today a little late but just want to put this here in case someone else needed. just separate the function to make it reusable. the code below will wait 1/2 second after typing stop. var timeOutVar $(selector).on('keyup', function() { clearTimeout(timeOutVar); timeOutVar= setTimeout(function(){ console.log("Hello"); }, 500); });
// Get an global variable isApiCallingInProgress // check isApiCallingInProgress if (!isApiCallingInProgress) { // set it to isApiCallingInProgress true isApiCallingInProgress = true; // set timeout setTimeout(() => { // Api call will go here // then set variable again as false isApiCallingInProgress = false; }, 1000); }
Wait before a javascript function can be called again
I've looked at many different solutions to this, none of which worked. I know it has something to do with setTimeout, but I don't know how to implement it properly. function myfunction() { //the function //wait for 1 second before it can be ran again } To clarify: I don't want to call the function at a regular interval, I want to be able to enforce a delay before the function can be called again.
var lastTime = 0; function myFunction() { var now = new Date().getTime(); // Time in milliseconds if (now - lasttime < 1000) { return; } else { lastTime = now; } // rest of function }
You don't need to use setTimeout at all. The following is similar to other answers, but uses a closure to remember the last time the function ran rather than a global variable. var myFunction = function() { var lastTime = new Date(); return function() { var now = new Date(); if ((now - lastTime) < 1000) return; lastTime = now; /* do stuff */ }; }());
I think the easiest solution would be to hold a boolean variable and reset it to true after a given delay. fiddle HTML <button id="clickme">click me!</button> JavaScript var canGo = true, delay = 1000; // one second var myFunction = function () { if (canGo) { canGo = false; // do whatever you want alert("Hi!"); setTimeout(function () { canGo = true; }, delay) } else { alert("Can't go!"); } } $("#clickme").click(function(){ myFunction(); }) With this, you hold a boolean, canGo, and set it to true. If the function is run, it sets canGo to false and sets a setTimeout() for a time period of delay, in milliseconds. If you try to run the function again, it won't run and will, instead, alert("Can't go!"). This was just for demonstrative purposes; you don't need that part. After delay, canGo will be set to true, and you will be able to once more run the function.
var lastRan = 0; var myFunction = function() { var now = Date.now(); if(now-lastRan < 1000) { return; } lastRan = now; //rest of function };
You may want to use throttle or debounce from underscore.js http://underscorejs.org/#throttle throttle_.throttle(function, wait, [options]) Creates and returns a new, throttled version of the passed function, that, when invoked repeatedly, will only actually call the original function at most once per every wait milliseconds. Useful for rate-limiting events that occur faster than you can keep up with. By default, throttle will execute the function as soon as you call it for the first time, and, if you call it again any number of times during the wait period, as soon as that period is over. If you'd like to disable the leading-edge call, pass {leading: false}, and if you'd like to disable the execution on the trailing-edge, pass {trailing: false}. var throttled = _.throttle(updatePosition, 100); $(window).scroll(throttled); http://underscorejs.org/#debounce debounce_.debounce(function, wait, [immediate]) Creates and returns a new debounced version of the passed function which will postpone its execution until after wait milliseconds have elapsed since the last time it was invoked. Useful for implementing behavior that should only happen after the input has stopped arriving. For example: rendering a preview of a Markdown comment, recalculating a layout after the window has stopped being resized, and so on. Pass true for the immediate parameter to cause debounce to trigger the function on the leading instead of the trailing edge of the wait interval. Useful in circumstances like preventing accidental double-clicks on a "submit" button from firing a second time. var lazyLayout = _.debounce(calculateLayout, 300); $(window).resize(lazyLayout);
If you just want to run your function again after a set time, you can use setTimeout and pass it the function to run and the delay period in milliseconds. function myfunction() { //the function //run again in one second setTimeout(myfunction, 1000); } Edited based on poster's comments: var waiting = false; var myfunction = function() { if (!waiting) { //Run some code waiting = setTimeout(function() { waiting = false; }, 1000); } };
Add a timeout to "setInterval()"?
I have a setInterval function like below on a Divbox so if I leave a divbox, this setInterval is triggered: setInterval("playthis()", 1000); What I want it to do: If I leave the divbox and lets say within the next 2 second rehover it, the setInterval should not triggered. Is this possible?
You can use cousins setTimeout and clearTimeout to set a function callback that invokes your setInterval only after 2 uninterrupted seconds: var handle = null; function yourDivboxLeaveHandler() { handle = setTimeout(startPlay, 2000); } function yourDivboxHoverHandler() { if (handle !== null) { clearTimeout(handle); handle = null; } } function startPlay() { setInterval(playthis, 1000); // use function references please, not eval handle = null; } You will want much better variable/function names than this though.
Yes. Just make some creative use of clearInterval(). In other words, no, such a feature doesn't come out-of-the-box, but you can build it yourself by calling clearInterval() if the mouse re-enters the divbox before the interval is triggered. For example: var divBox = document.getElementById('MyDivBox'); var TimeoutHandle = null; divBox.onmouseover = function() { if ( TimeoutHandle != null ) { clearTimeout(TimeoutHandle); } } divBox.onmouseout = function() { TimeoutHandle = setTimeout(function() { TimeoutHandle = null; setInterval(playthis, 1000); }, 2000); }
First of all is a bad practice to have the code evalued in a setInterval so you should avid double quotes. Then you can clear the interval like this: var int = setInterval(playthis, 1000); clearInterval(int)
JavaScript getTimeout?
The window.setTimeout (and related setInterval) function in Javascript allows you to schedule a function to be executed sometime in the future: id = setTimeout(function, delay); where "delay" is the number of milliseconds into the future at which you want to have the function called. Before this time elapses, you can cancel the timer using: clearTimeout(id); What I want is to update the timer. I want to be able to advance or retard a timer so that the function gets called x milliseconds sooner or later than originally scheduled. If there were a getTimeout method, you could do something like: originally_scheduled_time = getTimeout(id); updateTimeout(id, originally_schedule_time + new_delay); // change the time but as far as I can tell there's nothing like getTimeout or any way to update an existing timer. Is there a way to access the list of scheduled alarms and modify them? Is there a better approach? thanks!
If you really want this sort of functionality, you're going to need to write it yourself. You could create a wrapper for the setTimeout call, that will return an object you can use to "postpone" the timer: function setAdvancedTimer(f, delay) { var obj = { firetime: delay + (+new Date()), // the extra + turns the date into an int called: false, canceled: false, callback: f }; // this function will set obj.called, and then call the function whenever // the timeout eventually fires. var callfunc = function() { obj.called = true; f(); }; // calling .extend(1000) will add 1000ms to the time and reset the timeout. // also, calling .extend(-1000) will remove 1000ms, setting timer to 0ms if needed obj.extend = function(ms) { // break early if it already fired if (obj.called || obj.canceled) return false; // clear old timer, calculate new timer clearTimeout(obj.timeout); obj.firetime += ms; var newDelay = obj.firetime - new Date(); // figure out new ms if (newDelay < 0) newDelay = 0; obj.timeout = setTimeout(callfunc, newDelay); return obj; }; // Cancel the timer... obj.cancel = function() { obj.canceled = true; clearTimeout(obj.timeout); }; // call the initial timer... obj.timeout = setTimeout(callfunc, delay); // return our object with the helper functions.... return obj; } var d = +new Date(); var timer = setAdvancedTimer(function() { alert('test'+ (+new Date() - d)); }, 1000); timer.extend(1000); // should alert about 2000ms later
I believe not. A better approach might be to write your own wrapper which stores your timers (func-ref, delay, and timestamp). That way you can pretend to update a timer by clearing it and calculate a copy with an updated delay.
Another wrapper: function SpecialTimeout(fn, ms) { this.ms = ms; this.fn = fn; this.timer = null; this.init(); } SpecialTimeout.prototype.init = function() { this.cancel(); this.timer = setTimeout(this.fn, this.ms); return this; }; SpecialTimeout.prototype.change = function(ms) { this.ms += ms; this.init(); return this; }; SpecialTimeout.prototype.cancel = function() { if ( this.timer !== null ) { clearTimeout(this.timer); this.timer = null; } return this; }; Usage: var myTimer = new SpecialTimeout(function(){/*...*/}, 10000); myTimer.change(-5000); // Retard by five seconds myTimer.change(5000); // Extend by five seconds myTimer.cancel(); // Cancel myTimer.init(); // Restart myTimer.change(1000).init(); // Chain!
It may be not exactly what you want, but take a look anyway, maybe you can use it to your benefit. There is a great solution written by my ex-coworker that can create special handler functions that can stop and start timeouts when required. It is most widely used when you need to create a small delay for hover events. Like when you want to hide a mouseover menu not exactly at the time when a mouse leaves it, but a few milliseconds later. But if a mouse comes back, you need to cancel the timeout. The solution is a function called getDelayedHandlers. For example you have a function that shows and hides a menu function handleMenu(show) { if (show) { // This part shows the menu } else { // This part hides the menu } } You can then create delayed handlers for it by doing so: var handlers = handleMenu.getDelayedHandlers({ in: 200, // 'in' timeout out: 300, // 'out' timeout }); handlers becomes an object that contains two handler functions that when being called cancel the other one's timeout. var element = $('menu_element'); element.observe('mouseover', handlers.over); element.observe('mouseout', handlers.out); P.S. For this solution to work you need to extend the Function object with the curry function, which is automatically done in Prototype.
One possibility can be like this: if (this condition true) { setTimeout(function, 5000); } elseif (this condition true) { setTimeout(function, 10000); } else { setTimeout(function, 1000); } It's up to your how you construct your conditions or the logic. thanks