How can I wait a few milliseconds before I continue executing my code?

Question

I want to avoid that a player can call server.UpdateUserInternalData very frequently. Therefore I want to save the timestamp of the last server.UpdateUserInternalData call in UserInternalData.

I just want to update "PlayerData1": newdata if the last server.UpdateUserInternalData call was at least 4000 milliseconds before the current time(currenttimeinmilliseconds). But I don't know what I should do if the last update call was not at least 4000 milliseconds before the current time(currenttimeinmilliseconds).

Is it possible to wait in Function1 until ((Number(playertimestamp) + 4000) < Number(currenttimeinmilliseconds)) is true and then continue normally with updating "PlayerData1": newdata ? I don't want that the line return issuccessful; is executed before "PlayerData1": newdata is executed.

How can I do that? How can I wait in Function1?

function Function1(string newdata)
{
  var issuccessful = "";
  var playertimestamp = GetTimestampInternalData();
  var currenttimeinmilliseconds = getServerTimestamp();

  if ((Number(playertimestamp) + 4000) < Number(currenttimeinmilliseconds))
  {
    server.UpdateUserInternalData({
       PlayFabId: currentPlayerId,
       Data: {
           "PlayerData1": newdata
       },
       Permission: UserDataPermission.Private
    });

    issuccessful = true;

    var timestampinmilliseconds = getServerTimestamp();      
    CreateTimestampInternalData(timestampinmilliseconds);
  }

  return issuccessful;
}

function GetTimestampInternalData()
{
  var resultdata = server.GetUserInternalData({PlayFabId: currentPlayerId, Keys: "InternalDataTimestamp"});
  var currenttimestamp = "";
  if ((resultdata.Data.hasOwnProperty("InternalDataTimestamp")) && (resultdata.Data.InternalDataTimestamp.Value != null) && (resultdata.Data.InternalDataTimestamp.Value != ""))
    currenttimestamp = resultdata.Data.InternalDataTimestamp.Value;
  else
    currenttimestamp = 0;

  return currenttimestamp;
}

function CreateTimestampInternalData(currenttime)
{
  server.UpdateUserInternalData({
       PlayFabId: currentPlayerId,
       Data: {
           "InternalDataTimestamp": currenttime.toString()
       },
       Permission: UserDataPermission.Private
    });   
}

function getServerTimestamp()
{
  var now = new Date();
  var time = now.getTime();
  return time;
}

EDIT: The function sleep(milliseconds) in this article(Bringing Sleep to Native JavaScript) works for me if I just want to wait a few seconds before the next line of code is executed: https://www.sitepoint.com/delay-sleep-pause-wait/

Answer 1

You can use a debounce function from lodash for example.

A debounce function delays invoking your function until after X milliseconds have elapsed since the last time the debounced function was invoked.

usage :

_.debounce(Function1, 4000);

This will run your function only if 4000 ms have elapsed since the last time.

Answer 2

use setTimeout() in your code it will works

setTimeout(function(){ alert("Your function here"); }, 4000); //4000 is 4 seconds

For Eg:

function onLoadFunction() {
  setTimeout(function(){ 
     yourfunction();
 }, 4000);
}

Answer 3

You can use setTimeout() in your Function1() in order to execute it after 4 seconds

For Example:

 function Function1(string newdata){
   var issuccessful = "";
   var playertimestamp = GetTimestampInternalData();
   var currenttimeinmilliseconds = getServerTimestamp();

  setTimeout(function(){ 
   server.UpdateUserInternalData({
   PlayFabId: currentPlayerId,
   Data: {
       "PlayerData1": newdata
   },
   Permission: UserDataPermission.Private
});

issuccessful = true;

var timestampinmilliseconds = getServerTimestamp();      
CreateTimestampInternalData(timestampinmilliseconds);
   }, 4000);

  }

There is no need to compare your previous timestamp with current timestamp for 4 secs, once your Function1() is called setTimeout() will get triggered after a given time(which is 4 secs in this case).

Answer 4

You can implement a debounce function that ensures your function1 is not called more frequently than once every 4000 milliseconds using the following function:

let scheduled = null;
let fist_bounce = true;
/* causes function1 to be executed only once every ms milliseconds */
function debounce(newdate, ms)
{
    if (first_bounce) { // don't wait for first call
        first_bounce = false;
        function1(newdate);
    }
    else if (!scheduled) {
        scheduled = setTimeout(() => {
            function1(newdate);
            scheduled = null;
        }, ms);
    }
}

Demo:

function function1(newdate)
{
    console.log('function1 called: ' + newdate);
}

let scheduled = null;
let first_debounce = true;
/* causes function1 to be executed only once every ms milliseconds */
function debounce(newdate, ms)
{
    if (first_debounce) { // don't wait the first time
        first_debounce = false;
        function1(-1);
    }
    else if (!scheduled) {
        scheduled = setTimeout(() => {
            function1(newdate);
            scheduled = null;
        }, ms);
    }
}

/* test debounce: */

let i = 0;
let interval = setInterval(() => {
    ++i;
    debounce(i, 2000); // execute function1 once every two seconds
    if (i == 40) {
        clearInterval(interval);
    }
}, 200); // call debounce every 200ms

To make a multiple "debouncers" usable for multiple functions, we rely on a closure:

function make_debouncer(fn, ms)
{
    let first_debounce = true;
    let scheduled = null;
    function debounce()
    {
        let args = Array.prototype.slice.call(arguments);
        if (first_debounce) {  // don't wait for first call
            first_debounce = false;
            fn.apply(null, args);
        }
        else if (!scheduled) {
            scheduled = this.setTimeout(function() {
                fn.apply(null, args);
                scheduled = null;
            }, ms);
        }
    }

    return debounce;
}


/* test debounce: */

function Function1(newdate) {
    console.log(newdate);
}
    
// let debounce = make_debouncer(Function1, 2000); // call once every 2 seconds
// better yet, let's redefine Function1:
Function1 = make_debouncer(Function1, 2000); // call once every 2 seconds

let i = 0;
let interval = setInterval(function() {
    ++i;
    Function1(i); // call Function1 passing i as an argument
    if (i == 40) {
        clearInterval(interval);
    }
}, 200); // call debounce every 200ms

Answer 5

Lie.

Return issuccessful as true even though you did nothing.

Why wait? You updated less than four seconds ago. Waiting around for 3.9 seconds, or delaying the update for the future, is extra complexity.

The only real problem with this solution is the “final save” just before quitting the app/page. You will want a different method that does the save regardless of when the last save was.

You could pass a “noTimeout” option to this function, but then people will get into the habit of passing true.