In Javascript there are several built in functions that allow you to wait to execute code or run the code over and over. These functions are

setTimeout()
setInterval()

Both functions require you to give a callback function. Inside the callback function you will put the code you want to run. Like so:

function callbackFunction() {
// code you want to run
}
setTimeout(callbackFunction)

Not only do these built in functions require a callback function, but they also need a second parameter. This second parameter is the time till execution in milliseconds. Like so:

function callbackFunction() {
// code you want to run
}
setTimeout(callbackFunction, 1000)

The difference between setTimeout and setInterval is rather miniscule. Let's take this as an example:

setTimeout(callbackFunction, 1000);
setInterval(callbackFunction, 1000);

setTimeout will execute the code only after the 1000 milliseconds are up, while setInterval will run over and over again with a 1000 milliseconds in between each execution.

Please let me know if this helped?

*1000 milliseconds = 1 second

After some trial and error, I figured out what is wrong with this. However, the solution involves working around some of Khan Academy's functionality, and taking away a lot of the 'user friendliness' of Khan Academy. I highly recommend finding a more practical way to solve your problem, like exploring the loop() and noLoop() functions.

CodeDoctor is correct, there are two functions built into JavaScript called setTimeout and setInterval, which both allow you to delay code execution. But to understand the problem here, there are a few things you must know:

A library is a function of commands that users can utilize to make their life in programming easier. Think of it like having a calculator while doing your homework. You could do the math yourself (write a function yourself), or you could just use the calculator (library).

Processing.js is a specific library built for the language JavaScript, and a library that KA (Khan Academy) uses. Unfortunately for anyone who wants to use delay() in their program, Processing.js doesn't support it. That means that anywhere you try to code something with anything that uses Processing, you can't run delay().

Okay, so what about setTimeout and setInterval? Well, there is more bad news: The creators of the KA programming sandbox decided to remove and add some functions to improve the quality of the sandbox. setTimeout and setInterval fall into this category; Oh Noes just claims that the functions don't exist (they actually do exist, and there is code for them in KA, but Oh Noes stops it from being run).

The solution is to get rid of Oh Noes. Oh Noes uses a program called JsHint to find problems in your code and help you fix them. Fortunately for us, there is some code that we can run to stop him from realizing that he should flag setTimeout and setInterval.

// jshint ignore:start

This is a line of code that you can run at the beginning of your program to stop JsHint from telling Oh Noes what to flag. Yes, it is in a comment, but that is how it is supposed to be formatted. After you do this, there are a lot of options opened up to you. Now, the method mentioned by CodeDoctor using setTimeout and setInterval works.

Of course, this comes with some problems. I don't know why, but as soon as you run any setInterval function, the code inside the function will always run at the interval (even if you delete the function itself!!!). The only way to fix this that I found is to reload the page. 

// jshint ignore:start
function callBackFunction(){
    println("Hello, World!");
}
setInterval(callBackFunction, 1000);

Which prints out "Hello, World" every second. And never stops printing it every second, even if you delete everything in the code sandbox, until the page is refreshed.

(Again, there are much better ways to make your program 'wait' without using anything similar to delay(), setTimeout(), or setInterval(). You could and should try methods using loop() and noLoop(), which work with the default KA sandbox).

Hope one of these methods works,

Daniel Eppley

Synchronous JS has no methods for pausing code execution (except `alert()` and `prompt()`), but `async` functions have the `await` keyword, which pauses that function's execution until a promise is resolved. This will only work in the HTML environment (not PJS), but here's an example of using it to pause the program for `n` milliseconds.

<script type="application/javascript">
// Returns a promise that resolves after `ms` milliseconds
var pause = ms => new Promise(resolve => setTimeout(resolve, ms))
async function example() {
    console.log(new Date().toJSON())
    await pause(3000)
    console.log(new Date().toJSON())
}

console.log("Before")
example()
console.log("After")
</script>

This will log the date, wait 3 seconds, then log the date again. It's worth noting, however, that `example()` will return a Promise after the first console.log, as soon as it reaches the `await`. So the output will be something like

Before
2023-04-19T14:59:25.000Z
After
2023-04-19T14:59:28.000Z

So if that's an issue for you, you'll have to call it like `await example()` inside another async function. This makes it ideal for performing long-running tasks without freezing the page. For example, if you were generating things while the player runs around, you could do something like this to keep the game running smoothly.

async function generateThings() {
    if (generating || thingsToGenerate.length === 0) return
    generating = true
    for (let i = 0; thingsToGenerate.length; i++) {
        generateThing()
        if (i % 1000 === 999) await pause(4)
    }
    generating = false
}

So even if it takes a literal eternity to finish generating the things, the game won't freeze. The only downside to this is that `setTimeout` has a minimum wait time of 4ms, so this could only run about 4 times per frame max (assuming 60 FPS).

// jshint ignore:start 

Won't start for some reason does anyone know why?

Maybe try reloading your browser and if that didn't work check your formatting.