Delay HTTP-Requests with RxJS operators












0















I have an Observable myObservable which gets some items emitted with different time intervals. For example the time interval between the first and the second item could be 1 second and for the second and third item this could be 3 seconds.
For each item a HTTP request is send with the method this.sendMessage().



The problem is that the time interval between the request should be at least two second. Delay all request for two seconds is not the best solution. For example for the first request I don't want a delay. I don't want a delay too when the time difference between two emitted items is more than two seconds.



This is a working solution which does what I want. But I wonder if there is a more rxjs-like solution? I play with delay() and delayWhen() but I didn't find a way to get this working.
Does anyone has a solution?



let lastSendTimestamp = null;

myObservable.pipe(
concatMap(async body => {

// Calculate delay time
let delayTime = 0;
if (!lastSendTimestamp) {
delayTime = 0;
} else if (Date.now() - lastSendTimestamp > 2000) {
delayTime = 0;
} else {
delayTime = 2000 - (Date.now() - lastSendTimestamp);
}

// Wait until delay is over
await new Promise(resolve => setTimeout(resolve, delayTime));

lastSendTimestamp = Date.now();

return await this.sendMessage(body);
}),
).subscribe(result => {
});









share|improve this question



























    0















    I have an Observable myObservable which gets some items emitted with different time intervals. For example the time interval between the first and the second item could be 1 second and for the second and third item this could be 3 seconds.
    For each item a HTTP request is send with the method this.sendMessage().



    The problem is that the time interval between the request should be at least two second. Delay all request for two seconds is not the best solution. For example for the first request I don't want a delay. I don't want a delay too when the time difference between two emitted items is more than two seconds.



    This is a working solution which does what I want. But I wonder if there is a more rxjs-like solution? I play with delay() and delayWhen() but I didn't find a way to get this working.
    Does anyone has a solution?



    let lastSendTimestamp = null;

    myObservable.pipe(
    concatMap(async body => {

    // Calculate delay time
    let delayTime = 0;
    if (!lastSendTimestamp) {
    delayTime = 0;
    } else if (Date.now() - lastSendTimestamp > 2000) {
    delayTime = 0;
    } else {
    delayTime = 2000 - (Date.now() - lastSendTimestamp);
    }

    // Wait until delay is over
    await new Promise(resolve => setTimeout(resolve, delayTime));

    lastSendTimestamp = Date.now();

    return await this.sendMessage(body);
    }),
    ).subscribe(result => {
    });









    share|improve this question

























      0












      0








      0








      I have an Observable myObservable which gets some items emitted with different time intervals. For example the time interval between the first and the second item could be 1 second and for the second and third item this could be 3 seconds.
      For each item a HTTP request is send with the method this.sendMessage().



      The problem is that the time interval between the request should be at least two second. Delay all request for two seconds is not the best solution. For example for the first request I don't want a delay. I don't want a delay too when the time difference between two emitted items is more than two seconds.



      This is a working solution which does what I want. But I wonder if there is a more rxjs-like solution? I play with delay() and delayWhen() but I didn't find a way to get this working.
      Does anyone has a solution?



      let lastSendTimestamp = null;

      myObservable.pipe(
      concatMap(async body => {

      // Calculate delay time
      let delayTime = 0;
      if (!lastSendTimestamp) {
      delayTime = 0;
      } else if (Date.now() - lastSendTimestamp > 2000) {
      delayTime = 0;
      } else {
      delayTime = 2000 - (Date.now() - lastSendTimestamp);
      }

      // Wait until delay is over
      await new Promise(resolve => setTimeout(resolve, delayTime));

      lastSendTimestamp = Date.now();

      return await this.sendMessage(body);
      }),
      ).subscribe(result => {
      });









      share|improve this question














      I have an Observable myObservable which gets some items emitted with different time intervals. For example the time interval between the first and the second item could be 1 second and for the second and third item this could be 3 seconds.
      For each item a HTTP request is send with the method this.sendMessage().



      The problem is that the time interval between the request should be at least two second. Delay all request for two seconds is not the best solution. For example for the first request I don't want a delay. I don't want a delay too when the time difference between two emitted items is more than two seconds.



      This is a working solution which does what I want. But I wonder if there is a more rxjs-like solution? I play with delay() and delayWhen() but I didn't find a way to get this working.
      Does anyone has a solution?



      let lastSendTimestamp = null;

      myObservable.pipe(
      concatMap(async body => {

      // Calculate delay time
      let delayTime = 0;
      if (!lastSendTimestamp) {
      delayTime = 0;
      } else if (Date.now() - lastSendTimestamp > 2000) {
      delayTime = 0;
      } else {
      delayTime = 2000 - (Date.now() - lastSendTimestamp);
      }

      // Wait until delay is over
      await new Promise(resolve => setTimeout(resolve, delayTime));

      lastSendTimestamp = Date.now();

      return await this.sendMessage(body);
      }),
      ).subscribe(result => {
      });






      javascript rxjs delay






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked Nov 26 '18 at 12:07









      Rose NettoyeurRose Nettoyeur

      406619




      406619
























          1 Answer
          1






          active

          oldest

          votes


















          0














          You can use timer instead and chain with the async request. There's no need for promise



          let lastSendTimestamp = null;

          myObservable.pipe(
          concatMap(body => {

          // Calculate delay time
          let delayTime = 0;
          if (!lastSendTimestamp) {
          delayTime = 0;
          } else if (Date.now() - lastSendTimestamp > 2000) {
          delayTime = 0;
          } else {
          delayTime = 2000 - (Date.now() - lastSendTimestamp);
          }
          lastSendTimestamp = Date.now();
          return timer(delayTime).pipe(concatMap(res=>this.sendMessage(body)));
          }),
          ).





          share|improve this answer
























            Your Answer






            StackExchange.ifUsing("editor", function () {
            StackExchange.using("externalEditor", function () {
            StackExchange.using("snippets", function () {
            StackExchange.snippets.init();
            });
            });
            }, "code-snippets");

            StackExchange.ready(function() {
            var channelOptions = {
            tags: "".split(" "),
            id: "1"
            };
            initTagRenderer("".split(" "), "".split(" "), channelOptions);

            StackExchange.using("externalEditor", function() {
            // Have to fire editor after snippets, if snippets enabled
            if (StackExchange.settings.snippets.snippetsEnabled) {
            StackExchange.using("snippets", function() {
            createEditor();
            });
            }
            else {
            createEditor();
            }
            });

            function createEditor() {
            StackExchange.prepareEditor({
            heartbeatType: 'answer',
            autoActivateHeartbeat: false,
            convertImagesToLinks: true,
            noModals: true,
            showLowRepImageUploadWarning: true,
            reputationToPostImages: 10,
            bindNavPrevention: true,
            postfix: "",
            imageUploader: {
            brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
            contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
            allowUrls: true
            },
            onDemand: true,
            discardSelector: ".discard-answer"
            ,immediatelyShowMarkdownHelp:true
            });


            }
            });














            draft saved

            draft discarded


















            StackExchange.ready(
            function () {
            StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53480789%2fdelay-http-requests-with-rxjs-operators%23new-answer', 'question_page');
            }
            );

            Post as a guest















            Required, but never shown

























            1 Answer
            1






            active

            oldest

            votes








            1 Answer
            1






            active

            oldest

            votes









            active

            oldest

            votes






            active

            oldest

            votes









            0














            You can use timer instead and chain with the async request. There's no need for promise



            let lastSendTimestamp = null;

            myObservable.pipe(
            concatMap(body => {

            // Calculate delay time
            let delayTime = 0;
            if (!lastSendTimestamp) {
            delayTime = 0;
            } else if (Date.now() - lastSendTimestamp > 2000) {
            delayTime = 0;
            } else {
            delayTime = 2000 - (Date.now() - lastSendTimestamp);
            }
            lastSendTimestamp = Date.now();
            return timer(delayTime).pipe(concatMap(res=>this.sendMessage(body)));
            }),
            ).





            share|improve this answer




























              0














              You can use timer instead and chain with the async request. There's no need for promise



              let lastSendTimestamp = null;

              myObservable.pipe(
              concatMap(body => {

              // Calculate delay time
              let delayTime = 0;
              if (!lastSendTimestamp) {
              delayTime = 0;
              } else if (Date.now() - lastSendTimestamp > 2000) {
              delayTime = 0;
              } else {
              delayTime = 2000 - (Date.now() - lastSendTimestamp);
              }
              lastSendTimestamp = Date.now();
              return timer(delayTime).pipe(concatMap(res=>this.sendMessage(body)));
              }),
              ).





              share|improve this answer


























                0












                0








                0







                You can use timer instead and chain with the async request. There's no need for promise



                let lastSendTimestamp = null;

                myObservable.pipe(
                concatMap(body => {

                // Calculate delay time
                let delayTime = 0;
                if (!lastSendTimestamp) {
                delayTime = 0;
                } else if (Date.now() - lastSendTimestamp > 2000) {
                delayTime = 0;
                } else {
                delayTime = 2000 - (Date.now() - lastSendTimestamp);
                }
                lastSendTimestamp = Date.now();
                return timer(delayTime).pipe(concatMap(res=>this.sendMessage(body)));
                }),
                ).





                share|improve this answer













                You can use timer instead and chain with the async request. There's no need for promise



                let lastSendTimestamp = null;

                myObservable.pipe(
                concatMap(body => {

                // Calculate delay time
                let delayTime = 0;
                if (!lastSendTimestamp) {
                delayTime = 0;
                } else if (Date.now() - lastSendTimestamp > 2000) {
                delayTime = 0;
                } else {
                delayTime = 2000 - (Date.now() - lastSendTimestamp);
                }
                lastSendTimestamp = Date.now();
                return timer(delayTime).pipe(concatMap(res=>this.sendMessage(body)));
                }),
                ).






                share|improve this answer












                share|improve this answer



                share|improve this answer










                answered Nov 26 '18 at 16:45









                Fan CheungFan Cheung

                2,9541420




                2,9541420
































                    draft saved

                    draft discarded




















































                    Thanks for contributing an answer to Stack Overflow!


                    • Please be sure to answer the question. Provide details and share your research!

                    But avoid



                    • Asking for help, clarification, or responding to other answers.

                    • Making statements based on opinion; back them up with references or personal experience.


                    To learn more, see our tips on writing great answers.




                    draft saved


                    draft discarded














                    StackExchange.ready(
                    function () {
                    StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53480789%2fdelay-http-requests-with-rxjs-operators%23new-answer', 'question_page');
                    }
                    );

                    Post as a guest















                    Required, but never shown





















































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown

































                    Required, but never shown














                    Required, but never shown












                    Required, but never shown







                    Required, but never shown







                    Popular posts from this blog

                    Wiesbaden

                    Marschland

                    Dieringhausen