尝试解决使用 setTimeOut、setInterval 和回调发送和接收消息的练习问题

Question

I'm working on a practice problem using setTimeOut and callbacks for the first time. This is the situation:

You receive a JavaScript object 'recordMap' of the following

            type: { [recordName: string]: Client }

Client is an interface allowing to a) send a text message, b) receive a text message by registering a callback function.

    interface Client {

    sendMessage: (message: string) => void;

    //to send messages to the Client

    onMessage: (callback: (message: string) => void) => 
              void; // a callback for receiving messages from the 
              Client

    }

Public method 'initialize' will initialize the tracking of active Clients.

The goal is to make sure that no records in 'recordMap' are kept for inactive Clients.

//to register Send a 'ping' message to all Clients every 10 seconds. Register a callback function to receive messages from Clients.

Sending and receiving messages is an asynchronous form of communication - give Clients 3 seconds to reply to your message.

For every Client who hasn't replied with a 'pong' message, remove his record from 'recordMap'.

           type RecordMap = { [recordName: string]: Client };

           class RecordTracker {

             constructor (private recordMap: RecordMap) {}

             public initialize (): void {

             ...?

             }

             public getRecordMap (): RecordMap {

               return { ...this.recordMap };
             }
           }

---

I feel like I need to use setInterval for a message every 10 seconds and setTimeOut to send and receive the message, but not sure where to go from there.

I'm not really sure where to go with this one. Do I need to create some dummy clients to call? This is what I have so far:

```
interface Client {
  sendMessage: (message: string) => void;
  onMessage: (callback: (message: string) => void) => void;
}

type RecordMap = { [recordName: string]: Client };

class RecordTracker {
  constructor (private recordMap: RecordMap) {}
  public initialize (): void {
    setInterval(() => {
      const sendMessage = (message) => {
        //????
      }
    }, 10000)
  }
  public getRecordMap (): RecordMap {
    return { ...this.recordMap };
  }
}```

Answer 1

I would start by designing a function that accepts a Client and checks to see whether it's still active. Once you've ironed out that part, it should be straightforward to wire it into some kind of regular testing regime.

Since sending a message is asynchronous, our function is async. And, since we want to forcibly resolve it, we'll explicitly create a Promise so that we can resolve it after a timeout.

Here's a sketch of what I have in mind:

async function getIsClientActive( client, timeoutMs ) {
    return new Promise(resolve => {
        // set up the timeout
        setTimeout(() => resolve(false), timeoutMs)

        // set up handler to listen for pong
        const pongReceiver = ( msg ) => {
            if(msg === 'pong') resolve(true)
        }

        client.onMessage = pongReceiver

        // send the ping
        client.sendMessage('ping')
    })
}

One big caveat: my getIsClientActive assumes it's safe to hijack each client's onMessage handler. If that's not safe, you could either temporarily store the current handler in RAM during the ping operation (simpler), or set up an EventEmitter for each Client that fires "message" events and which the ping operation could temporarily subscribe to (more robust)

---

One thing I want to stress: it will make your job easier if this client-probing operation can remain ignorant of the data structures your program uses to track all known clients.