TypeScript: utilizza la versione corretta di setTimeout (nodo vs finestra)

Sto lavorando all'aggiornamento di un vecchio codice TypeScript per utilizzare l'ultima versione del compilatore e ho problemi con una chiamata a setTimeout. Il codice si aspetta di chiamare la setTimeoutfunzione del browser che restituisce un numero:

setTimeout(handler: (...args: any[]) => void, timeout: number): number;

Tuttavia, il compilatore risolve invece questo problema nell'implementazione del nodo, che restituisce un NodeJS.Timer:

setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;

Questo codice non viene eseguito nel nodo, ma le tipizzazioni del nodo vengono inserite come dipendenza da qualcos'altro (non so cosa).

Come posso istruire il compilatore a scegliere la versione setTimeoutche desidero?

Ecco il codice in questione:

let n: number;
n = setTimeout(function () { /* snip */  }, 500);

Questo produce l'errore del compilatore:

TS2322: il tipo "Timer" non è assegnabile al tipo "numero".

Un'altra soluzione alternativa che non influisce sulla dichiarazione delle variabili:

let n: number;
n = <any>setTimeout(function () { /* snip */  }, 500);

Inoltre, dovrebbe essere possibile utilizzare l' windowoggetto esplicitamente senza any:

let n: number;
n = window.setTimeout(function () { /* snip */  }, 500);

let timer: ReturnType<typeof setTimeout> = setTimeout(() => { ... });

clearTimeout(timer);

Usando ReturnType<fn>ottieni l'indipendenza dalla piattaforma. Non sarai costretto a usare anyné window.setTimeoutquale si interromperà se esegui il codice no nodeJS server (es. Pagina renderizzata lato server).

Buone notizie, anche questo è compatibile con Deno!

Immagino che dipenda da dove eseguirai il codice.

Se la destinazione del runtime è Node JS lato server, utilizza:

let timeout: NodeJS.Timeout;
global.clearTimeout(timeout);

Se la tua destinazione di runtime è un browser, utilizza:

let timeout: number;
window.clearTimeout(timeout);

Questo probabilmente funzionerà con le versioni precedenti, ma con la versione TypeScript ^3.5.3e la versione Node.js ^10.15.3, dovresti essere in grado di importare le funzioni specifiche del nodo dal modulo Timers , ovvero:

import { setTimeout } from 'timers';

Ciò restituirà un'istanza di Timeout di tipo a NodeJS.Timeoutcui puoi passare clearTimeout:

import { clearTimeout, setTimeout } from 'timers';

const timeout: NodeJS.Timeout = setTimeout(function () { /* snip */  }, 500);

clearTimeout(timeout);

Ho affrontato lo stesso problema e la soluzione alternativa che il nostro team ha deciso di utilizzare è stata quella di utilizzare "qualsiasi" per il tipo di timer. Per esempio:

let n: any;
n = setTimeout(function () { /* snip */  }, 500);

Funzionerà con entrambe le implementazioni dei metodi setTimeout / setInterval / clearTimeout / clearInterval.

• Se vuoi una vera soluzione per il dattiloscritto sui timer, eccoci qui:

  Il bug è nel tipo di ritorno "numero", non è Timer o altro.

  Questo è per la versione dei dattiloscritti ~> 2.7 soluzione:

export type Tick = null | number | NodeJS.Timer;

Ora abbiamo sistemato tutto, basta dichiarare in questo modo:

 import { Tick } from "../../globals/types";

 export enum TIMER {
    INTERVAL = "INTERVAL",
    TIMEOUT = "TIMEOUT", 
 };

 interface TimerStateI {
   timeInterval: number;
 }

 interface TimerI: TimerStateI {
   type: string;
   autoStart: boolean;
   isStarted () : bool;
 }

     class myTimer extends React.Component<TimerI, TimerStateI > {

          private myTimer: Tick = null;
          private myType: string = TIMER.INTERVAL;
          private started: boll = false;

          constructor(args){
             super(args);
             this.setState({timeInterval: args.timeInterval});

             if (args.autoStart === true){
               this.startTimer();
             }
          }

          private myTick = () => {
            console.log("Tick");
          }    

          private startTimer = () => {

            if (this.myType === TIMER.INTERVAL) {
              this.myTimer = setInterval(this.myTick, this.timeInterval);
              this.started = true;
            } else if (this.myType === TIMER.TIMEOUT) {
              this.myTimer = setTimeout(this.myTick, this.timeInterval);
              this.started = true;
            }

          }

         private isStarted () : bool {
           return this.started;
         }

     ...
     }