Make function wait until element exists - javascript
I'm trying to add a canvas over another canvas – how can I make this function wait to start until the first canvas is created?
function PaintObject(brush) {
this.started = false;
// get handle of the main canvas, as a DOM object, not as a jQuery Object. Context is unfortunately not yet
// available in jquery canvas wrapper object.
var mainCanvas = $("#" + brush).get(0);
// Check if everything is ok
if (!mainCanvas) {alert("canvas undefined, does not seem to be supported by your browser");}
if (!mainCanvas.getContext) {alert('Error: canvas.getContext() undefined !');}
// Get the context for drawing in the canvas
var mainContext = mainCanvas.getContext('2d');
if (!mainContext) {alert("could not get the context for the main canvas");}
this.getMainCanvas = function () {
return mainCanvas;
}
this.getMainContext = function () {
return mainContext;
}
// Prepare a second canvas on top of the previous one, kind of second "layer" that we will use
// in order to draw elastic objects like a line, a rectangle or an ellipse we adjust using the mouse
// and that follows mouse movements
var frontCanvas = document.createElement('canvas');
frontCanvas.id = 'canvasFront';
// Add the temporary canvas as a second child of the mainCanvas parent.
mainCanvas.parentNode.appendChild(frontCanvas);
if (!frontCanvas) {
alert("frontCanvas null");
}
if (!frontCanvas.getContext) {
alert('Error: no frontCanvas.getContext!');
}
var frontContext = frontCanvas.getContext('2d');
if (!frontContext) {
alert("no TempContext null");
}
this.getFrontCanvas = function () {
return frontCanvas;
}
this.getFrontContext = function () {
return frontContext;
}
If you have access to the code that creates the canvas - simply call the function right there after the canvas is created.
If you have no access to that code (eg. If it is a 3rd party code such as google maps) then what you could do is test for the existence in an interval:
var checkExist = setInterval(function() {
if ($('#the-canvas').length) {
console.log("Exists!");
clearInterval(checkExist);
}
}, 100); // check every 100ms
But note - many times 3rd party code has an option to activate your code (by callback or event triggering) when it finishes to load. That may be where you can put your function. The interval solution is really a bad solution and should be used only if nothing else works.
Depending on which browser you need to support, there's the option of MutationObserver.
EDIT: All major browsers support MutationObserver now.
Something along the lines of this should do the trick:
// callback executed when canvas was found
function handleCanvas(canvas) { ... }
// set up the mutation observer
var observer = new MutationObserver(function (mutations, me) {
// `mutations` is an array of mutations that occurred
// `me` is the MutationObserver instance
var canvas = document.getElementById('my-canvas');
if (canvas) {
handleCanvas(canvas);
me.disconnect(); // stop observing
return;
}
});
// start observing
observer.observe(document, {
childList: true,
subtree: true
});
N.B. I haven't tested this code myself, but that's the general idea.
You can easily extend this to only search the part of the DOM that changed. For that, use the mutations argument, it's an array of MutationRecord objects.
This will only work with modern browsers but I find it easier to just use a then so please test first but:
ES5
function rafAsync() {
return new Promise(resolve => {
requestAnimationFrame(resolve); //faster than set time out
});
}
function checkElement(selector) {
if (document.querySelector(selector) === null) {
return rafAsync().then(() => checkElement(selector));
} else {
return Promise.resolve(true);
}
}
ES6
async function checkElement(selector) {
const querySelector = null;
while (querySelector === null) {
await rafAsync();
querySelector = document.querySelector(selector);
}
return querySelector;
}
Usage
checkElement('body') //use whichever selector you want
.then((element) => {
console.info(element);
//Do whatever you want now the element is there
});
A more modern approach to waiting for elements:
while(!document.querySelector(".my-selector")) {
await new Promise(r => setTimeout(r, 500));
}
// now the element is loaded
Note that this code would need to be wrapped in an async function.
Here's a minor improvement over Jamie Hutber's answer
const checkElement = async selector => {
while ( document.querySelector(selector) === null) {
await new Promise( resolve => requestAnimationFrame(resolve) )
}
return document.querySelector(selector);
};
To use:
checkElement('.myElement').then((selector) => {
console.log(selector);
});
If you want a generic solution using MutationObserver you can use this function
// MIT Licensed
// Author: jwilson8767
/**
* Waits for an element satisfying selector to exist, then resolves promise with the element.
* Useful for resolving race conditions.
*
* #param selector
* #returns {Promise}
*/
export function elementReady(selector) {
return new Promise((resolve, reject) => {
const el = document.querySelector(selector);
if (el) {resolve(el);}
new MutationObserver((mutationRecords, observer) => {
// Query for elements matching the specified selector
Array.from(document.querySelectorAll(selector)).forEach((element) => {
resolve(element);
//Once we have resolved we don't need the observer anymore.
observer.disconnect();
});
})
.observe(document.documentElement, {
childList: true,
subtree: true
});
});
}
Source: https://gist.github.com/jwilson8767/db379026efcbd932f64382db4b02853e
Example how to use it
elementReady('#someWidget').then((someWidget)=>{someWidget.remove();});
Note: MutationObserver has a great browser support; https://caniuse.com/#feat=mutationobserver
Et voilà ! :)
Is better to relay in requestAnimationFrame than in a setTimeout. this is my solution in es6 modules and using Promises.
es6, modules and promises:
// onElementReady.js
const onElementReady = $element => (
new Promise((resolve) => {
const waitForElement = () => {
if ($element) {
resolve($element);
} else {
window.requestAnimationFrame(waitForElement);
}
};
waitForElement();
})
);
export default onElementReady;
// in your app
import onElementReady from './onElementReady';
const $someElement = document.querySelector('.some-className');
onElementReady($someElement)
.then(() => {
// your element is ready
}
plain js and promises:
var onElementReady = function($element) {
return new Promise((resolve) => {
var waitForElement = function() {
if ($element) {
resolve($element);
} else {
window.requestAnimationFrame(waitForElement);
}
};
waitForElement();
})
};
var $someElement = document.querySelector('.some-className');
onElementReady($someElement)
.then(() => {
// your element is ready
});
Here is a solution using observables.
waitForElementToAppear(elementId) {
return Observable.create(function(observer) {
var el_ref;
var f = () => {
el_ref = document.getElementById(elementId);
if (el_ref) {
observer.next(el_ref);
observer.complete();
return;
}
window.requestAnimationFrame(f);
};
f();
});
}
Now you can write
waitForElementToAppear(elementId).subscribe(el_ref => doSomethingWith(el_ref);
You can check if the dom already exists by setting a timeout until it is already rendered in the dom.
var panelMainWrapper = document.getElementById('panelMainWrapper');
setTimeout(function waitPanelMainWrapper() {
if (document.body.contains(panelMainWrapper)) {
$("#panelMainWrapper").html(data).fadeIn("fast");
} else {
setTimeout(waitPanelMainWrapper, 10);
}
}, 10);
Another variation of Iftah
var counter = 10;
var checkExist = setInterval(function() {
console.log(counter);
counter--
if ($('#the-canvas').length || counter === 0) {
console.log("by bye!");
clearInterval(checkExist);
}
}, 200);
Just in case the element is never shown, so we don't check infinitely.
A pure promise based JavaScript approach, you can tell for many milliseconds to wait.
const waitElementFor = function(query, ms = 3000) { // 3000 === 3 seconds
return new Promise((resolve) => {
var waited = 0;
var el = null;
var wi = setInterval(function() {
el = document.querySelector(query);
if (waited >= ms || el) {
clearInterval(wi);
if(el) {
resolve(el);
} else {
resolve(null);
}
}
waited += 10;
}, 10);
});
}
To use the function, simply use the following code in an asynchronous function.
var element = await waitElementFor('#elementID');
Snippet:
const waitElementFor = function(query, ms = 3000) { // 3000 === 3 seconds
return new Promise((resolve) => {
var waited = 0;
var el = null;
var wi = setInterval(function() {
el = document.querySelector(query);
if (waited >= ms || el) {
clearInterval(wi);
if(el) {
resolve(el);
} else {
resolve(null);
}
}
waited += 10;
}, 10);
});
}
async function snippetTestAyncFunction(){
var element = await waitElementFor('#elementID');
console.log(element);
}
snippetTestAyncFunction();
Maybe I'm a little bit late :), but here is a nice and brief solution by chrisjhoughton, which allows to perform a callback function when the wait is over.
https://gist.github.com/chrisjhoughton/7890303
var waitForEl = function(selector, callback) {
if (jQuery(selector).length) {
callback();
} else {
setTimeout(function() {
waitForEl(selector, callback);
}, 100);
}
};
waitForEl(selector, function() {
// work the magic
});
If you need to pass parameters to a callback function, you can use it this way:
waitForEl("#" + elDomId, () => callbackFunction(param1, param2));
But be careful! This solution by default can fall into a trap of an infinite loop.
Several improvements of the topicstarter's suggestion are also provided in The GitHub thread.
Enjoy!
This is for those of you who are running code in the Chrome console and not just hard-coded into the html.
user993683 above offered code that will work in your console code. His/her code is as follows:
while(!document.querySelector(".my-selector")) {
await new Promise(r => setTimeout(r, 500));
}
// now the element is loaded
He/she added that it "needs to be inside an async function." And if you are using code in Chrome's console then in fact you DON'T need to wrap it in a function. It will work just as written. You only need to place it in your code at the place right before you try to access the element to make sure it exists.
The only caveat is that it won't work on elements that are only sometimes present under other circumstances. Otherwise it will loop indefinitely if the element never downloads and you'll have to close the browser to stop the wait. Only use it for elements which you are certain will be present.
My company's form page has a dozen or more fields to fill out for each case number. And I have hundreds of case numbers in the script array every day. The elements do not all load simultaneously when changing the iFrame SRC and "onload" does not work in Chrome console scripts. So this method is a god-send to me and it saves me at least 45 minutes every day over the old generic async wait 10 seconds here or 30 seconds there due to fluctuating load times.
The only change I made is "getElementById" instead of the general "querySelector" because all of the elements I need have ID's.
while(!document.getElementById("myFrame").contentWindow.document.getElementById('someDocID')) {
await new Promise(r => setTimeout(r, 500));
}
// After completing the wait above it is now safe to access the element
document.getElementById("myFrame").contentWindow.document.getElementById('someDocID'
).innerText = "Smith, John R";
// and now click the submit button then change the SRC to a fresh form, and use
//*emphasized text* the code again to wait for it to fully load
I apologize to the monitors, but I added this as an answer because after several months of research on console scripts and waiting for elements to load, user993683's remark about a function finally made me realize that console scripts do not require a function for this code. My goal here is only to save other consoler script users the same learning curve that I went through.
Just use setTimeOut with recursion:
waitUntilElementIsPresent(callback: () => void): void {
if (!this.methodToCheckIfElementIsPresent()) {
setTimeout(() => this.waitUntilElementIsPresent(callback), 500);
return;
}
callback();
}
Usage:
this.waitUntilElementIsPresent(() => console.log('Element is present!'));
You can limit amount of attempts, so an error will be thrown when the element is not present after the limit:
waitUntilElementIsPresent(callback: () => void, attempt: number = 0): void {
const maxAttempts = 10;
if (!this.methodToCheckIfElementIsPresent()) {
attempt++;
setTimeout(() => this.waitUntilElementIsPresent(callback, attempt), 500);
return;
} else if (attempt >= maxAttempts) {
return;
}
callback();
}
Related
Access and modify website variables using Javascript [duplicate]
I have a click event that is triggered from another place automatically for the first time. My problem is that it runs too soon, since the required variables are still being defined by Flash and web services. So right now I have: (function ($) { $(window).load(function(){ setTimeout(function(){ $('a.play').trigger("click"); }, 5000); }); })(jQuery); The problem is that 5 seconds for a person with a slow internet connection could be too fast and vice versa, for a person with a fast internet connection, it's too slow. So how should I do the delay or timeout until someVariable is defined?
The following will keep looking for someVariable until it is found. It checks every 0.25 seconds. function waitForElement(){ if(typeof someVariable !== "undefined"){ //variable exists, do what you want } else{ setTimeout(waitForElement, 250); } }
async, await implementation, improvement over #Toprak's answer (async() => { console.log("waiting for variable"); while(!window.hasOwnProperty("myVar")) // define the condition as you like await new Promise(resolve => setTimeout(resolve, 1000)); console.log("variable is defined"); })(); console.log("above code doesn't block main function stack"); After revisiting the OP's question. There is actually a better way to implement what was intended: "variable set callback". Although the below code only works if the desired variable is encapsulated by an object (or window) instead of declared by let or var (I left the first answer because I was just doing improvement over existing answers without actually reading the original question): let obj = encapsulatedObject || window; Object.defineProperty(obj, "myVar", { configurable: true, set(v){ Object.defineProperty(obj, "myVar", { configurable: true, enumerable: true, writable: true, value: v }); console.log("window.myVar is defined"); } }); see Object.defineProperty or use es6 proxy (which is probably overkill) If you are looking for more: /** * combining the two as suggested by #Emmanuel Mahuni, * and showing an alternative to handle defineProperty setter and getter */ let obj = {} || window; (async() => { let _foo = await new Promise(res => { Object.defineProperty(obj, "foo", { set: res }); }); console.log("obj.foo is defined with value:", _foo); })(); /* IMPORTANT: note that obj.foo is still undefined the reason is out of scope of this question/answer take a research of Object.defineProperty to see more */ // TEST CODE console.log("test start"); setTimeout(async () => { console.log("about to assign obj.foo"); obj.foo = "Hello World!"; // try uncomment the following line and compare the output // await new Promise(res => setTimeout(res)); console.log("finished assigning obj.foo"); console.log("value of obj.foo:", obj.foo); // undefined // console: obj.foo is defined with value: Hello World! }, 2000);
I would prefer this code: function checkVariable() { if (variableLoaded == true) { // Here is your next action } } setTimeout(checkVariable, 1000);
I prefer something simple like this: function waitFor(variable, callback) { var interval = setInterval(function() { if (window[variable]) { clearInterval(interval); callback(); } }, 200); } And then to use it with your example variable of someVariable: waitFor('someVariable', function() { // do something here now that someVariable is defined }); Note that there are various tweaks you can do. In the above setInterval call, I've passed 200 as how often the interval function should run. There is also an inherent delay of that amount of time (~200ms) before the variable is checked for -- in some cases, it's nice to check for it right away so there is no delay.
With Ecma Script 2017 You can use async-await and while together to do that And while will not crash or lock the program even variable never be true //First define some delay function which is called from async function function __delay__(timer) { return new Promise(resolve => { timer = timer || 2000; setTimeout(function () { resolve(); }, timer); }); }; //Then Declare Some Variable Global or In Scope //Depends on you let Variable = false; //And define what ever you want with async fuction async function some() { while (!Variable) await __delay__(1000); //...code here because when Variable = true this function will }; //////////////////////////////////////////////////////////// //In Your Case //1.Define Global Variable For Check Statement //2.Convert function to async like below var isContinue = false; setTimeout(async function () { //STOPT THE FUNCTION UNTIL CONDITION IS CORRECT while (!isContinue) await __delay__(1000); //WHEN CONDITION IS CORRECT THEN TRIGGER WILL CLICKED $('a.play').trigger("click"); }, 1); ///////////////////////////////////////////////////////////// Also you don't have to use setTimeout in this case just make ready function asynchronous...
You can use this: var refreshIntervalId = null; refreshIntervalId = setInterval(checkIfVariableIsSet, 1000); var checkIfVariableIsSet = function() { if(typeof someVariable !== 'undefined'){ $('a.play').trigger("click"); clearInterval(refreshIntervalId); } };
Here's an example where all the logic for waiting until the variable is set gets deferred to a function which then invokes a callback that does everything else the program needs to do - if you need to load variables before doing anything else, this feels like a neat-ish way to do it, so you're separating the variable loading from everything else, while still ensuring 'everything else' is essentially a callback. var loadUser = function(everythingElse){ var interval = setInterval(function(){ if(typeof CurrentUser.name !== 'undefined'){ $scope.username = CurrentUser.name; clearInterval(interval); everythingElse(); } },1); }; loadUser(function(){ //everything else });
Instead of using the windows load event use the ready event on the document. $(document).ready(function(){[...]}); This should fire when everything in the DOM is ready to go, including media content fully loaded.
Shorter way: var queue = function (args){ typeof variableToCheck !== "undefined"? doSomething(args) : setTimeout(function () {queue(args)}, 2000); }; You can also pass arguments
I have upvoted #dnuttle's answer, but ended up using the following strategy: // On doc ready for modern browsers document.addEventListener('DOMContentLoaded', (e) => { // Scope all logic related to what you want to achieve by using a function const waitForMyFunction = () => { // Use a timeout id to identify your process and purge it when it's no longer needed let timeoutID; // Check if your function is defined, in this case by checking its type if (typeof myFunction === 'function') { // We no longer need to wait, purge the timeout id window.clearTimeout(timeoutID); // 'myFunction' is defined, invoke it with parameters, if any myFunction('param1', 'param2'); } else { // 'myFunction' is undefined, try again in 0.25 secs timeoutID = window.setTimeout(waitForMyFunction, 250); } }; // Initialize waitForMyFunction(); }); It is tested and working! ;) Gist: https://gist.github.com/dreamyguy/f319f0b2bffb1f812cf8b7cae4abb47c
Object.defineProperty(window, 'propertyName', { set: value => { this._value = value; // someAction(); }, get: () => this._value }); or even if you just want this property to be passed as an argument to a function and don't need it to be defined on a global object: Object.defineProperty(window, 'propertyName', { set: value => someAction(value) }) However, since in your example you seem to want to perform an action upon creation of a node, I would suggest you take a look at MutationObservers.
I have an adaptation of the answer by #dnuttle that I would suggest using. The advantage of using a try-catch block is that if any part of the code you are trying to execute fails, the whole block fails. I find this useful because it gives you a kind of transaction; everything or nothing gets done. You should never write code that could end up in an endless loop due to external factors. This is exactly what would happen if you were waiting for a response from an ajax request and the server doesn't respond. I think it's good practice to have a timeout for any questionable loops. let time = 0; // Used to keep track of how long the loop runs function waitForElement() { try { // I'm testing for an element, but this condition can be // any reasonable condition if (document.getElementById('test') === null) { throw 'error'; } // This is where you can do something with your variable // document.getElementById('test').addEventListener.... // or call a function that uses your value } catch (error) { // Loop stops executing if not successful within about 5 seconds if (time > 5000) { // I return false on failure so I can easily check for failure return false; } else { // Increment the time and call the function again time += 250; setTimeout(waitForElement, 250); } } } // Call the function after the definition, ensures that time is set waitForElement();
You could have Flash call the function when it's done. I'm not sure what you mean by web services. I assume you have JavaScript code calling web services via Ajax, in which case you would know when they terminate. In the worst case, you could do a looping setTimeout that would check every 100 ms or so. And the check for whether or not a variable is defined can be just if (myVariable) or safer: if(typeof myVariable == "undefined")
Very late to the party but I want to supply a more modern solution to any future developers looking at this question. It's based off of Toprak's answer but simplified to make it clearer as to what is happening. <div>Result: <span id="result"></span></div> <script> var output = null; // Define an asynchronous function which will not block where it is called. async function test(){ // Create a promise with the await operator which instructs the async function to wait for the promise to complete. await new Promise(function(resolve, reject){ // Execute the code that needs to be completed. // In this case it is a timeout that takes 2 seconds before returning a result. setTimeout(function(){ // Just call resolve() with the result wherever the code completes. resolve("success output"); }, 2000); // Just for reference, an 'error' has been included. // It has a chance to occur before resolve() is called in this case, but normally it would only be used when your code fails. setTimeout(function(){ // Use reject() if your code isn't successful. reject("error output"); }, Math.random() * 4000); }) .then(function(result){ // The result variable comes from the first argument of resolve(). output = result; }) .catch(function(error){ // The error variable comes from the first argument of reject(). // Catch will also catch any unexpected errors that occur during execution. // In this case, the output variable will be set to either of those results. if (error) output = error; }); // Set the content of the result span to output after the promise returns. document.querySelector("#result").innerHTML = output; } // Execute the test async function. test(); // Executes immediately after test is called. document.querySelector("#result").innerHTML = "nothing yet"; </script> Here's the code without comments for easy visual understanding. var output = null; async function test(){ await new Promise(function(resolve, reject){ setTimeout(function(){ resolve("success output"); }, 2000); setTimeout(function(){ reject("error output"); }, Math.random() * 4000); }) .then(function(result){ output = result; }) .catch(function(error){ if (error) output = error; }); document.querySelector("#result").innerHTML = output; } test(); document.querySelector("#result").innerHTML = "nothing yet"; On a final note, according to MDN, Promises are supported on all modern browsers with Internet Explorer being the only exception. This compatibility information is also supported by caniuse. However with Bootstrap 5 dropping support for Internet Explorer, and the new Edge based on webkit, it is unlikely to be an issue for most developers.
while (typeof myVar == void(0)) { if ( typeof myVar != void(0)) { console.log(myVar); } } This makes use of the typeof operator which only returns undefined if variable is not declared yet. Should be applicable in every type of javascript.
Using JS Promise as an interrupt
I wanted to directly call a function (like interrupt handler) when a certain condition is met. I didn't want to using "polling" for that as it increases time complexity. count = 1 p = new Promise((resolve, reject)=>{ if(count == 2){ resolve("hello") } }); p.then((msg)=>{ console.log(msg) }) console.log("1 now"); count = 2; I expected console.log(msg) to run when count=2 but this is not the case. It turned out that the promise is still "pending". What is the reason this happens? And how do I implement my question.
You can use a Proxy to listen variable changes. const count = new Proxy({ value: 0 }, { set(target, prop, val) { // set value target[prop] = val; console.log(`count is ${val}`); // stop condition if (val == 2) { console.log(`count is 2(trigger stop condition)`); } } }); // wait 2 seconds and change count.value to 1 setTimeout(() => count.value = 1, 2000); // wait 2 seconds and change count.value to 2 // it triggers the stop condition setTimeout(() => count.value = 2, 2000); console.log("Waiting for changes ..."); reference: Listen to js variable change
Proxy is one of the solutions for this. But I post another approach for your case. You can define a custom class or object, and work with that class. Also you register your custom listener for it, and do whatever. This is a sample of my code. Maybe it will give you some ideas for your solution. class MyObject { constructor(value, func) { this._value = value; this._listener = func; } get value() { return this._value; } set value(newValue) { this._listener(newValue); this._value = newValue; } } function customListener(changedValue) { console.log(`New Value Detected: ${changedValue}`); } const count = new MyObject(1, customListener); count.value = 2;
The issue you're having is that the code inside the Promise resolves synchronously. It seems like you are assuming Promises are by default async, but that is a common async misconception. So, the code if(count == 2){ resolve("hello") } resolves synchronously (that is, right after you declare count to be 1) so the Promise will never be resolved. If you want to asynchronously check for a condition without using libraries, you can use setInterval: function checkForCondition(count, time){ return new Promise(resolve => { const interval = setInterval(() => { if (count == 2){ resolve("The count is 2!"); } } , time); }); } If you call this function, the callback inside setInterval will be placed on the event loop every x ms, where x is equal to the time parameter.
javascript async and setInterval for polling
I want most understandable syntax for polling a flag and return when it is true, my code snippet below doesn't work I know, what's the syntax that would make it work if you get my idea ? async function watch(flag) { let id = setInterval(function(){ if (flag === true) { clearInterval(id); } }, 1000); return flag; }
If you want to poll a variable where the value is a primative, then you need to define it outside the function, otherwise it can't change. If you want to have a promise resolve when that condition is done, then you have to create it explicitly. async and await are tools for managing existing promises. let flag = false; function watchFlag() { return new Promise(resolve => { let i = setInterval(() => { console.log("Polling…"); if (flag) { resolve(); clearInterval(i); } }, 500); }); } setTimeout(() => { flag = true; }, 1500); console.log("Watching the flag"); watchFlag().then(() => { console.log("The flag has changed"); });
If you don't know when the flag is going to change (in 10 seconds or in 10 minutes), you can use a setter instead. Probably an anti-pattern, but again your question doesn't really show us how you would be using this flag in your code. const flagsObject = { set flag(stat) { this._flag = stat; if (stat) { // call the function you need to call when flag is true // you could add additional condition if you only want to run the function // when the flag is switched doSomething() } }, get flag() { return this._flag; } }; flagsObject.flag = true; // doSomething() will be called
Intersection Observer: Call a function only once per element
I'm using the Intersection Observer API to track the visibility of multiple element on a web page. When an element becomes visible, a function callback() should be executed. The restriction: For each element, the function may only be executed once. Here is my current implementation for a web analytics project: const elements = document.querySelectorAll('[data-observable]'); const callback = str => { console.log(str); }; const observer = new IntersectionObserver(handleIntersection); elements.forEach(obs => { observer.observe(obs); }); function handleIntersection(entries, observer){ entries.forEach(entry => { if (entry.intersectionRatio > 0) { // Call this function only once per element, without modifying entry object callback('observer-' + entry.target.getAttribute('data-observable')); } }); } I'm struggeling to find a solution that does not modify existing elements, the IntersectionObserver or the IntersectionObserverEntries. Usually I would use a closure to ensure that a function gets only executed once: function once(func) { let executed = false; return function() { if (!executed) { executed = true; return func.apply(this, arguments); } }; } But in this case I have difficulties applying the function because IntersectionObserver uses a weird callback iterator logic that get's executed everytime any element changes (instead of using a event-driven model). Any ideas, how to implement a once per element function call that does not mutate other elements or objects?
As James pointed out in the comments, the easiest solution to this problem is unobserving the element once it has become visible and the callback has been invoked. const elements = document.querySelectorAll('[data-observable]'); const callback = str => { console.log(str); }; const observer = new IntersectionObserver(handleIntersection); elements.forEach(obs => { observer.observe(obs); }); function handleIntersection(entries, observer){ entries.forEach(entry => { if (entry.intersectionRatio > 0) { callback('observer-' + entry.target.getAttribute('data-observable')); observer.unobserve(entry.target); } }); } I didn't find any viable solution to use a closure to control how often a function can be called.
How to do a "for" loop with asynchronous condition in Javascript?
I have this function: waitForFreeAccnt.prototype.isMemberFree = function () { var self = this; self.api.getMemberInfo(function () { var accType = self.api.connect.accountType; console.log(accType); if (accType === 'FREE') { console.log('it is free'); return true; } else { console.log('it is not free'); return false; } }); }; I would like to wait till the account is free for up to 10 seconds with something like that: var test = function () { for (var start = 1; start < 10; start++) { var result = self.isMemberFree(); console.log(result); if (result) { break; } else { self.api.pause(1000); console.log('waiting'); } } }; But it doesn't work because self.api.getMemberInfo is asynch call. This is super frustrating with Javascript. Any other language it would be so simple to do. How do I force the for loop to wait for self.isMemberFree() to finish executing before proceeding with the loop? Also to note, this is not in browser execution so I don't care about anything hanging.
When dealing with asynchronous code, you need to make use of callbacks. That is, if you want to do a() and b() in order but a() does something asynchronously, then you need to call b() from within a() once a() has a result. So not: a(); // does something asynchronously b(); // tries to use a()'s result but it isn't available yet ... but rather a(b); // pass b to a() and a() will call it when ready function a(callback) { triggerAsyncFunction(function(result) { if (result === something) callback("a just finished"); }); } Note that a() doesn't refer to b() by name, it just calls whatever function is passed in as an argument. So applying that to your code, maybe something like this: waitForFreeAccnt.prototype.isMemberFree = function (cbf) { var self = this; self.api.getMemberInfo(function () { cbf(self.api.connect.accountType === 'FREE'); }); }; waitForFreeAccnt.prototype.testMemberXTimes = function(maxAttempts, callback) { var attempts = 0; var self = this; (function attempt() { self.isMemberFree(function(free) { if (free) callback(true); else if (++attempts < maxAttempts) setTimeout(attempt, 1000); else callback(false); }); )(); }; this.testMemberXTimes(10, function(isFree) { // the next part of your code here, or called from here // because at this point we know we've tested up to // ten times and isFree tells us the result }); Note that the way I coded getMemberInfo() it is basically doing the same thing yours was, but instead of returning a boolean it is calling the callback function and passing the same boolean value that you were returning. (I've removed the console.log()s to make the code shorter.) Note also that you could structure the above to use promises, but the end result will be the same.
You could return a Promise waitForFreeAccnt.prototype.isMemberFree = function () { return new Promise((reject, resolve)=> // set a timeout if api call takes too long var timeout = setTimeout(()=> reject(Error('API timeout')), 10000); // make api call this.api.getMemberInfo(()=> { clearTimeout(timeout); resolve(this.api.connect.accountType === 'FREE'); }); ); }; Then use it like this whatever.isMemberFree().then(isFree=> { if (isFree) console.log('it is free'); else console.log('it is not free'); }) // handle timeout or other errors .catch(err=> { console.log(err.message); });
Building on naomik's answer, if you do it that way you can pretty easily use a for loop with it, using the (most likely) upcoming async/await feature - though it's not part of ES2015. // Note "async" here! That will make "await" work. It makes the function // return a promise, which you'll be able to either "await" or // "test().then" later. var test = async function () { for (var start = 1; start < 10; start++) { // Right here we're using "await" - it makes JavaScript *wait* for // the promise that comes from self.isMemberFree() to be finished. // It's really handy because you can use it in loops like "for" and // "while" without changing the flow of your program! var result = await self.isMemberFree(); console.log(result); if (result) { break; } else { self.api.pause(1000); console.log('waiting'); } } }; For now you'll need to use a transpiler like Babel or Traceur before you can really use async/await, though. It's only supported in Microsoft Edge 14 right now. And a big emphasis that what is returned from test() isn't whatever you directly return from inside it. If I do this: var test = async function() { return 15; }; var result = test(); I'm not going to get 15 - I'll get a promise that will resolve as 15: result.then(function(res) { console.log(res); // 15 }); // or, use an async function again: var main = async function() { console.log(await res); // 15 }; main();
I don't have my work laptop today because it is Sunday, I'm coding this on sublime. Apologise if the syntax is a bit off. To solve your problem I would recommend changing isMemberFree() to take in a callback function. This is because isMemberFree is async, and you will need a way to report the result after it has done the work. Then change test function to use setTimeout API to wait a second. Wrap the function call for isMemberFree() to be in a nested function and call it recursively, that way you'll have synchronize control over the async calls. Look at the coding example: waitForFreeAccnt.prototype.isMemberFree = function (done) { var self = this; self.api.getMemberInfo(function () { var accType = self.api.connect.accountType; console.log(accType); if (accType === 'FREE') { console.log('it is free'); return done(null, true); } else { console.log('it is not free'); return done(null, false); } }); }; var test = function () { var testMembership = function(waitAttempt, isFree) { if (isFree) { return; } else if (waitAttempt > 10) { // wait exceeded, do something. return; } setTimeout(function() { self.isMemberFree(function(err, isFree) { testMembership(waitAttempt+=1, isFree); }); }, /*total milliseconds in 1sec=*/1000); } testMembership(/*WaitAttempts=*/0, /*isFree=*/false); }; What the above code does is that, presumably something has already been done to the member's account and now test function is called. So it waits for 1 second, then call isMemberFree function, this happens recursively until either isMemberFree() returns true OR the 10 seconds wait has been exceeded.