JavaScript use of `use strict`, setInterval, clearInterval(), setTimeout, Object.freeze(), Object.seal(), Object.isSealed(), async keyword, await keyword

 // Global scope 
'use strict';

function myFunction() {
  x = 3.14;   // Error: x is not declared 
}

 // Or in a function only 
function strictFunc() {
  'use strict';
  y = 5;   // Error: y is not declared 
}

'use strict';

 // 1. Variables must be declared 
x = 10;   // ❌ Error 

 // 2. Can't delete variables or functions 
let name = "John";
delete name;   // ❌ Error 

 // 3. Function parameters must be unique 
function sum(a, a, c) {   // ❌ Syntax error 
  return a + a + c;
}

 // 4. `eval()` doesn't create variables in local scope 
eval("let z = 10");
console.log(z);   // ❌ ReferenceError 

 // 5. `this` is undefined in functions 
function test() {
  console.log(this);   // undefined (not global object) 
}
test();

setTimeout(function, delay, arg1, arg2, ...);

setTimeout(() => {
  console.log("This runs after 2 seconds");
}, 2000);

console.log("This runs first");
 // Output: 
 // This runs first 
 // (after 2 seconds) This runs after 2 seconds 

function greet(name, age) {
  console.log(`Hello ${name}, you are ${age} years old`);
}

setTimeout(greet, 1000, "Alice", 25);
// After 1 second: Hello Alice, you are 25 years old

const timerId = setTimeout(() => {
  console.log("Never runs");
}, 2000);

clearTimeout(timerId);  // Cancel the timeout
console.log("Timeout cancelled");

const intervalId = setInterval(function, interval, arg1, arg2, ...);
clearInterval(intervalId);

let count = 0;

const intervalId = setInterval(() => {
  count++;
  console.log("Count: " + count);
}, 1000);

 // After 5 seconds, clear the interval 
setTimeout(() => {
  clearInterval(intervalId);
  console.log("Interval stopped");
}, 5000);

 // Output: 
 // Count: 1 
 // Count: 2 
 // Count: 3 
 // Count: 4 
 // Count: 5 
 // Interval stopped 

let seconds = 10;

const countdown = setInterval(() => {
  console.log(seconds + " seconds remaining");
  seconds--;
  
  if (seconds < 0) {
    clearInterval(countdown);
    console.log("Time's up!");
  }
}, 1000);

let time = 0;

const timer = setInterval(() => {
  time++;
  document.getElementById("timer").innerText = time;
}, 1000);

// Stop after button click
document.getElementById("stopBtn").addEventListener("click", () => {
  clearInterval(timer);
});

Object.freeze(obj);

const person = { name: "John", age: 30 };
Object.freeze(person);

person.name = "Jane";         // ❌ Fails silently (or throws error in strict mode) 
person.email = "john@test.com";   // ❌ No effect 
delete person.age;            // ❌ No effect 

console.log(person);   // { name: "John", age: 30 } (unchanged) 

const obj = { id: 1 };
Object.freeze(obj);

console.log(Object.isFrozen(obj));  // true

const config = {
  database: { host: "localhost", port: 5432 },
  debug: true
};

Object.freeze(config);
config.database.host = "remote.com";   // ✅ Still works! (shallow freeze) 

console.log(config);   // { database: { host: "remote.com" }, debug: true } 

 // Solution: Deep freeze 
function deepFreeze(obj) {
  Object.freeze(obj);
  Object.values(obj).forEach(value => {
    if (typeof value === "object" && value !== null) {
      deepFreeze(value);
    }
  });
  return obj;
}

const config2 = {
  database: { host: "localhost", port: 5432 }
};

deepFreeze(config2);
config2.database.host = "remote.com";   // ❌ No effect now 
console.log(config2.database.host);   // "localhost" 

Object.seal(obj);

const user = { name: "Alice", age: 25 };
Object.seal(user);

 // ✅ Modify existing properties 
user.name = "Bob";
user.age = 30;

 // ❌ Add new property 
user.email = "bob@test.com";   // No effect 

 // ❌ Delete property 
delete user.age;   // No effect 

console.log(user);   // { name: "Bob", age: 30 } 

const obj1 = { x: 1 };
const obj2 = { x: 1 };

Object.freeze(obj1);
Object.seal(obj2);

obj1.x = 2;   // ❌ Can't modify (frozen) 
obj2.x = 2;   // ✅ Can modify (sealed) 

obj1.y = 3;   // ❌ Can't add (frozen) 
obj2.y = 3;   // ❌ Can't add (sealed) 

console.log(obj1);   // { x: 1 } 
console.log(obj2);   // { x: 2 } 

Object.isSealed(obj);

const product = { name: "Laptop", price: 1000 };

console.log(Object.isSealed(product));   // false 

Object.seal(product);

console.log(Object.isSealed(product));   // true 

 // Related methods 
console.log(Object.isFrozen(product));   // false 
console.log(Object.isExtensible(product));   // false 

async function functionName() {
    // code
}

async function sayHello() {
  return "Hello!";
}

sayHello().then(result => {
  console.log(result);   // "Hello!" 
});

 // or with await 
(async () => {
  const result = await sayHello();
  console.log(result);   // "Hello!" 
})();

function fetchUser(id) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({ id, name: "John" });
    }, 2000);
  });
}

async function getUser() {
  console.log("Fetching user...");
  const user = await fetchUser(1);
  console.log("User:", user);
  return user;
}

getUser();
 // Output: 
 // Fetching user... 
 // (after 2 seconds) User: { id: 1, name: "John" } 

const result = await promise;

async function getUserPosts(userId) {
   // Sequential execution 
  const user = await fetchUser(userId);      // Wait 1 sec 
  const posts = await fetchPosts(userId);    // Wait 1 sec 
  
  console.log(user, posts);
  return { user, posts };
}

 // Total time: ~2 seconds 

async function getUserData(userId) {
   // Parallel execution 
  const [user, posts, comments] = await Promise.all([
    fetchUser(userId),
    fetchPosts(userId),
    fetchComments(userId)
  ]);
  
  return { user, posts, comments };
}

 // Total time: ~1 second (all execute simultaneously) 

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

getData();

async function fetchUserData(userId) {
  try {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${userId}`);
    
    if (!response.ok) {
      throw new Error("User not found");
    }
    
    const user = await response.json();
    console.log("User:", user);
    return user;
  } catch (error) {
    console.error("Error fetching user:", error);
  }
}

fetchUserData(1);

'use strict';

 // API call with async/await 
async function fetchAndDisplayUsers() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users');
    const users = await response.json();
    
     // Seal the users array to prevent modifications 
    const userList = Object.seal([...users]);
    
     // Display users with interval 
    let index = 0;
    const intervalId = setInterval(() => {
      if (index < userList.length) {
        console.log(userList[index]);
        index++;
      } else {
        clearInterval(intervalId);
      }
    }, 1000);
    
  } catch (error) {
    console.error('Error:', error);
  }
}

fetchAndDisplayUsers();

 // Freeze configuration 
const CONFIG = {
  API_URL: 'https://api.example.com',
  TIMEOUT: 5000
};

Object.freeze(CONFIG);
 // CONFIG.TIMEOUT = 10000;  // ❌ No effect