reactjs der Versand versprechen kontinuierlich nach bestimmten Zeit

Question

In meiner reagieren Komponente I eine Aktion in ComponentDidMount() wie dies nenne:

componentDidMount() { 
     const { actions } = this.props 

     function save_project_continiously() { 
      console.log("inside") 
      actions.save_project().then(save_project_continiously) 
     } 

     save_project_continiously() 
    } 

Hier habe ich eine Aktion kontinuierlich nenne .. Meine Handlungen ist wie:

export function save_project() { 
    return (dispatch, getState) => { 

     setTimeout(() => { 
      return dispatch(manage_data()).then(response => { 
       console.log("Hellooww world") 
       return response 
      }) 
     }, 3000) 
    } 
} 

Wenn ich das tue es gibt mir Fehlermeldung, dass .then() in ComponentDidMount() keine Funktion ..

Wenn ich

tun

export function save_project() { 
     return (dispatch, getState) => { 

      return dispatch(manage_data()).then(response => { 
       console.log("Hellooww world") 
       return response 
      }) 
     } 
    } 

Es wird ständig aufgerufen, aber ich möchte es nach bestimmter Zeit kontinuierlich aufgerufen werden.

Ich versuchte dies:

export function save_project() { 
     return (dispatch, getState) => { 
      return new Promise((resolve, reject) => { 
       setTimeout(() => { 
        return dispatch(manage_data()).then(response => { 
         console.log("Hellooww world") 
         return response 
        }) 
       }, 3000) 
      }) 
     } 
    } 

Aber es wird nur einmal aufgerufen .. Hat einen Fehler nicht geben, aber es ruft nur einmal ..

Was ich will, ist, ich will continuosly eine Aktionen aufrufen nach einer bestimmten Zeit nach Abschluss der Aktion.

Hier möchte ich save_project anrufen und es nach Abschluss möchte ich es wieder nach 3 Sekunden anrufen und kontinuierlich weitergehen ..

Wie kann ich es passieren ??

Irgendwelche Vorschläge ??

Vielen Dank im Voraus

Answer 1

, sind Sie versprechen in Versprechen Einwickeln, aber was Sie wirklich tun möchte, ist diesen Code ausführen wieder auf erfolgreiche Versprechen lösen.

export function save_project() { 
    // So this code does return callback, so it does not return promise 
    // in your first example. 
    return (dispatch, getState) => { 
     // Then this code returns promise, but it never gets resolved. 
     return new Promise((resolve, reject) => { 
      setTimeout(() => { 
       // Then you return promise from set timeout, but it 
       // is doubtful as well 
       return dispatch(manage_data()).then(response => { 
        console.log("Hellooww world") 
        return response 
       }) 
      }, 3000) 
     }) 
    } 
} 

Was Sie wirklich tun möchte, ist:

// Just return promise of dispatch instead of wrapping it in 
// a callback. 
export function save_project() { 
    return dispatch(manage_data()); 
} 

// Then use set timeout here 
function save_project_continiously() { 
    console.log("inside") 
    actions.save_project().then(() => { 
     setTimeout(save_project_continiously, 3000); 
    }); 
} 

Oder wenn Sie wirklich einen Rückruf in save_project wollen, müssen Sie es richtig mit der richtigen Argumente zu nennen, wie in Ihrem Beispiel sind sie undefined sowieso .

Answer 2

Versuchen Sie in diesem Code setInterval()

export function save_project() { 
    return new Promise((resolve, reject) => { 
    setTimeout(() => { 
     dispatch(manage_data()).then(response => { 
     resolve(response); 
     }, error => { 
     reject(response); 
     }) 
    }, 3000) 
    }); 
}