Run code after a delay:

1. Use `setTimeout` to log "Hello" after 3 seconds.
2. Write the callback as an arrow function.

setTimeout(() => {
    console.log("Hello");
}, 3000);

Create a counter:

1. Use `setInterval` to log an increasing number every second (1, 2, 3...).
2. Stop the counter (clearInterval) when it reaches 5.

let count = 0;
const intervalId = setInterval(() => {
    count++;
    console.log(count);
    if (count === 5) {
        clearInterval(intervalId);
    }
}, 1000);

Create a simple promise:

1. Create a `Promise` that checks a `success` variable.
2. If `true`, resolve with "Success".
3. If `false`, reject with "Failure".
4. Use `.then()` and `.catch()` to handle the result.

const myPromise = new Promise((resolve, reject) => {
    const success = true;
    if (success) {
        resolve("Success");
    } else {
        reject("Failure");
    }
});

myPromise
    .then(msg => console.log(msg))
    .catch(err => console.error(err));

Work with JSON data:

1. You have JSON text: `'{"name": "Ali", "age": 25}'`.
2. Convert it to a JavaScript object using `JSON.parse()`.
3. Log the `name` property.

const jsonString = '{"name": "Ali", "age": 25}';
const user = JSON.parse(jsonString);

console.log(user.name); // Ali

Convert an object to JSON:

1. You have `product = { id: 1, title: "Phone" }`.
2. Convert it to a JSON string using `JSON.stringify()`.
3. Log the result.

const product = { id: 1, title: "Phone" };
const jsonString = JSON.stringify(product);

console.log(jsonString); // '{"id":1,"title":"Phone"}'

Fetch data from a placeholder URL:

1. Use `fetch` to get data from `https://api.example.com/data`.
2. Convert the response to JSON.
3. Log the data to the console.

fetch('https://api.example.com/data')
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error(error));

Rewrite the Fetch code using Async/Await:

1. Create an async function `async function getData()`.
2. Use `await` for the fetch and JSON conversion.
3. Wrap the code in `try...catch` to handle errors.

async function getData() {
    try {
        const response = await fetch('https://api.example.com/data');
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error(error);
    }
}

getData();

Send data to a server:

1. Use `fetch` to send a `POST` request to `https://api.example.com/users`.
2. Set the `method` and `headers` (Content-Type: application/json).
3. Send the body as JSON: `{ name: "Ali" }`.

fetch('https://api.example.com/users', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({ name: "Ali" })
})
.then(res => res.json())
.then(data => console.log(data));

Run multiple promises in parallel:

1. You have two promises `p1` and `p2`.
2. Use `Promise.all([p1, p2])` to wait for both.
3. Log the results when done.

const p1 = Promise.resolve("First");
const p2 = Promise.resolve("Second");

Promise.all([p1, p2]).then(results => {
    console.log(results); // ["First", "Second"]
});

Store data in the browser:

1. Save the value "dark" under the key "theme" using `localStorage.setItem`.
2. Read the saved value using `localStorage.getItem` and log it.

localStorage.setItem("theme", "dark");

const theme = localStorage.getItem("theme");
console.log(theme); // dark