Closing Channels in JavaScript

// In this example we'll use a `jobs` array to simulate
// a channel for communicating work to be done from the
// main function to a worker function. When we have no
// more jobs for the worker, we'll use a flag to indicate
// completion.

function main() {
    const jobs = [];
    let done = false;

    // Here's the worker function. It repeatedly checks
    // for new jobs in the `jobs` array. If there are jobs,
    // it processes them. If `done` is set to true and there
    // are no more jobs, it exits the loop.
    function worker() {
        setInterval(() => {
            if (jobs.length > 0) {
                const j = jobs.shift();
                console.log("received job", j);
            } else if (done) {
                console.log("received all jobs");
                clearInterval(this);
            }
        }, 100);
    }

    // Start the worker
    worker();

    // This sends 3 jobs to the worker by adding them
    // to the `jobs` array, then sets `done` to true.
    for (let j = 1; j <= 3; j++) {
        jobs.push(j);
        console.log("sent job", j);
    }
    console.log("sent all jobs");
    done = true;

    // In JavaScript, we don't need to explicitly wait for
    // the worker to finish, as it runs asynchronously.

    // To simulate reading from a closed channel, we can
    // check if there are any jobs left after a delay.
    setTimeout(() => {
        console.log("received more jobs:", jobs.length > 0);
    }, 1000);
}

main();

This JavaScript code simulates the behavior of the original Go program. Here are the key differences and adaptations:

Instead of channels, we use an array (jobs) to pass jobs to the worker.
The done variable is used as a flag to indicate when all jobs have been sent.
The worker function uses setInterval to repeatedly check for new jobs, simulating the behavior of a goroutine.
We use setTimeout at the end to simulate checking a closed channel after all jobs have been processed.

To run this program, you would save it as a .js file and run it using Node.js:

$ node closing-channels.js
sent job 1
sent job 2
sent job 3
sent all jobs
received job 1
received job 2
received job 3
received all jobs
received more jobs: false

This example demonstrates how to simulate channel-like behavior in JavaScript using arrays and asynchronous functions. While JavaScript doesn’t have built-in constructs exactly like Go’s channels, we can achieve similar functionality using these techniques.

Non Blocking Channel Operations in JavaScript

Range Over Channels in JavaScript

Learn X By Example

Title here

Closing Channels in JavaScript