thiscodeWorks - Saving, organizing & sharing the best of code online

✅ Prerequisites

1. Sign up at https://openweathermap.org/api and get your API key.
2. Use the Current Weather Data API and 5 Day / 3 Hour Forecast API.
3. Include Chart.js via CDN in your HTML.

---

🔧 HTML Structure

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Weather Dashboard</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      padding: 8px;
    }
    #weather-table, #forecast-table {
      margin: 20px 0;
    }
  </style>
</head>
<body>
  <h2>Weather Information</h2>
  <input type="text" id="city" placeholder="Enter City Name">
  <button onclick="getWeather()">Get Weather</button>

  <div id="weather-table"></div>
  <div id="forecast-table"></div>
  <canvas id="forecastChart" width="600" height="300"></canvas>

  <script src="script.js"></script>
</body>
</html>

---

✏️ JavaScript (script.js)

const apiKey = 'YOUR_API_KEY'; // Replace with your OpenWeatherMap API key

async function getWeather() {
  const city = document.getElementById('city').value;
  if (!city) return alert('Please enter a city');

  await getCurrentWeather(city);
  await getWeatherForecast(city);
}

async function getCurrentWeather(city) {
  const response = await fetch(
    `https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}&units=metric`
  );
  const data = await response.json();

  const html = `
    <table>
      <tr><th>City</th><th>Min Temp (°C)</th><th>Max Temp (°C)</th><th>Humidity (%)</th></tr>
      <tr>
        <td>${data.name}</td>
        <td>${data.main.temp_min}</td>
        <td>${data.main.temp_max}</td>
        <td>${data.main.humidity}</td>
      </tr>
    </table>
  `;
  document.getElementById('weather-table').innerHTML = html;
}

async function getWeatherForecast(city) {
  const response = await fetch(
    `https://api.openweathermap.org/data/2.5/forecast?q=${city}&appid=${apiKey}&units=metric`
  );
  const data = await response.json();

  // Extract date and temperature every 8 entries (~24 hours)
  const forecasts = data.list.filter((_, index) => index % 8 === 0);

  const tableRows = forecasts.map(forecast => `
    <tr>
      <td>${forecast.dt_txt.split(' ')[0]}</td>
      <td>${forecast.main.temp}</td>
    </tr>
  `).join('');

  const table = `
    <h3>5-Day Forecast</h3>
    <table>
      <tr><th>Date</th><th>Temperature (°C)</th></tr>
      ${tableRows}
    </table>
  `;
  document.getElementById('forecast-table').innerHTML = table;

  // Plot chart
  const labels = forecasts.map(f => f.dt_txt.split(' ')[0]);
  const temperatures = forecasts.map(f => f.main.temp);
  drawChart(labels, temperatures);
}

function drawChart(labels, data) {
  const ctx = document.getElementById('forecastChart').getContext('2d');
  new Chart(ctx, {
    type: 'bar',
    data: {
      labels: labels,
      datasets: [{
        label: 'Temperature (°C)',
        data: data,
        backgroundColor: 'rgba(54, 162, 235, 0.6)',
        borderColor: 'blue',
        borderWidth: 1
      }]
    },
    options: {
      responsive: true,
      scales: {
        y: {
          beginAtZero: false
        }
      }
    }
  });
}

task 3

@cciot

1. Working with Higher-Order Functions in JavaScript
A higher-order function is a function that either takes another function as an argument or returns a function.

// Higher-order function
function greetUser(greetFn) {
    const name = "Alice";
    greetFn(name);
}
// Function to be passed
function sayHello(name) {
    console.log(`Hello, ${name}!`);
}
greetUser(sayHello);

2. Callback and Callback Hell
A callback is a function passed to another function to be executed later.

Example with Callback Hell:
function step1(callback) {
    setTimeout(() => {
        console.log("Step 1 completed");
        callback();
    }, 1000);
}

function step2(callback) {
    setTimeout(() => {
        console.log("Step 2 completed");
        callback();
    }, 1000);
}

function step3(callback) {
    setTimeout(() => {
        console.log("Step 3 completed");
        callback();
    }, 1000);
}

// Callback Hell
step1(() => {
    step2(() => {
        step3(() => {
            console.log("All steps completed (callback hell)");
        });
    });
});

3. Working with XHR (XMLHttpRequest)

const xhr = new XMLHttpRequest();
xhr.open("GET", "https://jsonplaceholder.typicode.com/posts/1");
xhr.onreadystatechange = function () {
    if (xhr.readyState === 4 && xhr.status === 200) {
        console.log("XHR Response:", JSON.parse(xhr.responseText));
    }
};
xhr.send();

4. Using Promises to Deal with Callback Hell
Promises provide a cleaner alternative to callbacks for handling async tasks.

function stepPromise(stepName) {
    return new Promise((resolve) => {
        setTimeout(() => {
            console.log(`${stepName} completed`);
            resolve();
        }, 1000);
    });
}
// Promise chaining to avoid callback hell
stepPromise("Step 1")
    .then(() => stepPromise("Step 2"))
    .then(() => stepPromise("Step 3"))
    .then(() => console.log("All steps completed (with Promise)"));

5. Promise Chaining and async/await

Promise Chaining (already shown above)

Using async/await (cleanest syntax)

async function executeSteps() {
    await stepPromise("Step 1");
    await stepPromise("Step 2");
    await stepPromise("Step 3");
    console.log("All steps completed (with async/await)");
}

executeSteps();

task 2

@cciot

1. Prototypal Inheritance and Classes

a. Prototypal Inheritance (old way):
function Animal(name) {
  this.name = name;
}
Animal.prototype.speak = function () {
  console.log(`${this.name} makes a sound.`);
};

function Dog(name, breed) {
  Animal.call(this, name);
  this.breed = breed;
}
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.speak = function () {
  console.log(`${this.name} barks.`);
};

const dog = new Dog("Buddy", "Golden Retriever");
dog.speak(); // Buddy barks.

b. ES6 Classes (modern way):
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog2 = new Dog("Max", "Labrador");
dog2.speak(); // Max barks.

2. Object and Array Destructuring
// Object destructuring
const user = {
  id: 1,
  name: "Alice",
  contact: {
    email: "alice@example.com",
    phone: "123-4567"
  }
};

const { name, contact: { email } } = user;
console.log(name);  // Alice
console.log(email); // alice@example.com

// Array destructuring
const fruits = ["apple", "banana", "cherry"];
const [firstFruit, , thirdFruit] = fruits;
console.log(firstFruit);  // apple
console.log(thirdFruit);  // cherry

3. Working with Modules
a. Exporting from a module (file: mathUtils.js)
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;

b. Importing in another file
import { add, subtract } from './mathUtils.js';
console.log(add(5, 3));      // 8
console.log(subtract(5, 3)); // 2

> ⚠️ Note: You need to run this in a module-supporting environment (e.g., browser with type="module" or Node with .mjs or appropriate config).

4. Function Generators and Symbols
a. Generator Function
function* numberGenerator() {
  yield 1;
  yield 2;
  yield 3;
}
const gen = numberGenerator();
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3

b. Symbols

const ID = Symbol("id");
const person = {
  name: "Bob",
  [ID]: 1234
};
console.log(person);           // { name: 'Bob', [Symbol(id)]: 1234 }
console.log(person[ID]);       // 1234

5. Working with Closures
function outerFunction(outerVariable) {
  return function innerFunction(innerVariable) {
    console.log(`Outer: ${outerVariable}, Inner: ${innerVariable}`);
  };
}

const closureExample = outerFunction("outside");
closureExample("inside"); // Outer: outside, Inner: inside

task 1

@cciot

1. Create a Git Repository Locally

🛠 Steps:

1. Create a simple web app with 5 HTML pages:

mkdir my-web-app
cd my-web-app
touch index.html about.html contact.html services.html portfolio.html

2. Initialize Git:
git init

3. Stage and commit the files:
git add .
git commit -m "Initial commit with 5 HTML pages"

2. Push to GitHub and Explore Remote Options
🛠 Steps:
1. Go to GitHub and create a new repository (e.g., my-web-app).

2. Connect local repo to GitHub:
git remote add origin https://github.com/your-username/my-web-app.git

3. Push to GitHub:
git push -u origin main  # or master, depending on your default branch

🔍 Explore:
Push updates:
git push origin main

Pull latest changes from remote:
git pull origin main

Fetch updates (without merging):
git fetch origin

3. Clone, Modify, and Push Back
🛠 Steps:
1. Clone the repo in another folder:
git clone https://github.com/your-username/my-web-app.git

2. Modify a file (e.g., edit about.html), then:
git add about.html
git commit -m "Updated about page content"
git push origin main

4. Create Branches and Merge
🛠 Steps:
1. Create and switch to new branches:
git checkout -b feature-header
# make changes
git add .
git commit -m "Added header"

git checkout -b feature-footer
# make changes
git add .
git commit -m "Added footer"

2. Merge into main:
git checkout main
git merge feature-header
git merge feature-footer
git commit -m "Merged header and footer features"

5. Publish with GitHub Pages

🛠 Steps:

1. Push all content to the main branch.
2. Go to your GitHub repository > Settings > Pages.
3. Under Source, choose main branch and root folder /.
4. GitHub will provide a URL like:
https://your-username.github.io/my-web-app/

Write script to read and write the streaming data using readable and writable streams.

@signup

const fs = require('fs');

// Create a readable stream (reading from input.txt)
const readStream = fs.createReadStream('input.txt');

// Create a writable stream (writing to output.txt)
const writeStream = fs.createWriteStream('output.txt');

// Pipe the read stream into the write stream
readStream.pipe(writeStream);

console.log("Streaming data from input.txt to output.txt...");

Use the fs module for creating directories and files of different formats.

@signup

const fs = require('fs');

// Create a folder
fs.mkdirSync('myFolder');

// Create a text file
fs.writeFileSync('myFolder/info.txt', 'Hello from Node.js');

// Create a JSON file
fs.writeFileSync('myFolder/data.json', '{"name": "Amit"}');

// Create an HTML file
fs.writeFileSync('myFolder/index.html', '<h1>Welcome</h1>');

Explore the Functionality of os, path, util, and events Modules

@signup

✅ 1. os Module – System Info
const os = require('os');
console.log("Operating System:", os.type());
console.log("Free Memory:", os.freemem());
console.log("Home Directory:", os.homedir());




✅ 2. path Module – File & Directory Paths
const path = require('path');
const filePath = "/users/admin/project/index.js";
console.log("Directory Name:", path.dirname(filePath));  // /users/admin/project
console.log("Base Name:", path.basename(filePath));      // index.js
console.log("Extension:", path.extname(filePath)); // .js



✅ 3. util Module – Utility Functions
const util = require('util');
const greet = util.format("Hello %s, your score is %d", "Anita", 95);
console.log(greet); // Hello Anita, your score is 95





✅ 4. events Module – Event Emitter
const EventEmitter = require('events');
const emitter = new EventEmitter();
// Registering an event
emitter.on('greet', (name) => {
    console.log(`Hello, ${name}!`);
});
// Emitting the event
emitter.emit('greet', 'Rahul'); // Output: Hello, Rahul!

Create custom / local modules and export them using various module patterns.

@signup

🧩 1. ES6 Module Pattern (using export / import)
                          
📁 mathUtils.js
export const add = (a, b) => a + b;
export const multiply = (a, b) => a * b;



📁 main.js
import { add, multiply } from './mathUtils.js';

console.log(add(2, 3));       // 5
console.log(multiply(2, 3));  // 6





🧱 2. CommonJS Module Pattern (Node.js style)

📁 mathUtils.js
function add(a, b) {
    return a + b;
}

function multiply(a, b) {
    return a * b;
}
module.exports = { add, multiply };


📁 main.js
const { add, multiply } = require('./mathUtils');

console.log(add(4, 5));       // 9
console.log(multiply(4, 5));  // 20

Dealing with Promise chaining and async / await.

@signup

async function executeSteps() {
    await stepPromise("Step 1");
    await stepPromise("Step 2");
    await stepPromise("Step 3");
    console.log("All steps completed (with async/await)");
}

executeSteps();

Dealing with the Callback Hell situation using Promise. Exploring the different ways of creating and using promise in executing the asynchronous task.

@signup

function stepPromise(stepName) {
    return new Promise((resolve) => {
        setTimeout(() => {
            console.log(`${stepName} completed`);
            resolve();
        }, 1000);
    });
}

// Promise chaining to avoid callback hell
stepPromise("Step 1")
    .then(() => stepPromise("Step 2"))
    .then(() => stepPromise("Step 3"))
    .then(() => console.log("All steps completed (with Promise)"));

Working with XHR: response

@signup

const xhr = new XMLHttpRequest();
xhr.open("GET", "https://jsonplaceholder.typicode.com/posts/1");
xhr.onreadystatechange = function () {
    if (xhr.readyState === 4 && xhr.status === 200) {
        console.log("XHR Response:", JSON.parse(xhr.responseText));
    }
};
xhr.send();

Using Callback and creating a Callback Hell situation to understand the drawbacks.

@signup

function task1(callback) {
  setTimeout(() => {
    console.log("Task 1 completed");
    callback();
  }, 1000);
}

function task2(callback) {
  setTimeout(() => {
    console.log("Task 2 completed");
    callback();
  }, 1000);
}

function task3(callback) {
  setTimeout(() => {
    console.log("Task 3 completed");
    callback();
  }, 1000);
}

function task4(callback) {
  setTimeout(() => {
    console.log("Task 4 completed");
    callback();
  }, 1000);
}

// This is where callback hell starts
task1(() => {
  task2(() => {
    task3(() => {
      task4(() => {
        console.log("All tasks done!");
      });
    });
  });
});

Working with Higher-Order Functions in JavaScript

@signup

// Higher-order function
function greetUser(greetFn) {
    const name = "Alice";
    greetFn(name);
}

// Function to be passed
function sayHello(name) {
    console.log(`Hello, ${name}!`);
}

greetUser(sayHello);

TASK -1 GIT

@signup

https://chatgpt.com/share/6803c2a0-b0b0-800e-a3ae-22019667f464

TASK 9: Working with Express & Mongo DB

@signup

https://chatgpt.com/share/6806f131-1ca0-800e-98cc-208108aa0113


Create express server that has endpoints connecting to Users collection present in Mongo DB 
database using mongoose library and perform CRUD operation on that.

TASK 4: Fetching server state using JavaScript (fetch)

@signup

https://chatgpt.com/share/6806edc3-be74-800e-b64e-d107384cf470

API:KEY-->https://api.openweathermap.org/data/2.5/weather?q=Hyderabad&appid=bb5d6d56c0d5dbe246c95ed802b759fe

25b5d51f0221767ca7aad908df540fdd

1. Use fetch function to access remote data using the given api and display the data in the form of a 
table. 
2. Use fetch function to read the weather details from openweathermap.org and display the details 
like city, min-temp, max-temp, humidity on the webpage for a given city. 
3. From the same website read the weather forecast details for a given city and display the details 
like date – temperature in a table. 
4. Plot a bar chart for the above implementation using date and temperature along X and Y axis 
respectively.  Use ChartJS library. 


API:KEY-->https://api.openweathermap.org/data/2.5/weather?q=Hyderabad&appid=bb5d6d56c0d5dbe246c95ed802b759fe

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <title>Weather Dashboard</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    table, th, td {
      border: 1px solid black;
      border-collapse: collapse;
      padding: 8px;
    }
    #weather-table, #forecast-table {
      margin: 20px 0;
    }
  </style>
</head>
<body>
  <h2>Weather Information</h2>
  <input type="text" id="city" placeholder="Enter City Name">
  <button onclick="getWeather()">Get Weather</button>

  <div id="weather-table"></div>
  <div id="forecast-table"></div>
  <canvas id="forecastChart" width="600" height="300"></canvas>

  <script src="script.js"></script>
</body>
</html>





//script.js
const apiKey = 'YOUR_API_KEY'; // Replace with your OpenWeatherMap API key

async function getWeather() {
  const city = document.getElementById('city').value;
  if (!city) return alert('Please enter a city');

  await getCurrentWeather(city);
  await getWeatherForecast(city);
}

async function getCurrentWeather(city) {
  const response = await fetch(
    `https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}&units=metric`
  );
  const data = await response.json();

  const html = `
    <table>
      <tr><th>City</th><th>Min Temp (°C)</th><th>Max Temp (°C)</th><th>Humidity (%)</th></tr>
      <tr>
        <td>${data.name}</td>
        <td>${data.main.temp_min}</td>
        <td>${data.main.temp_max}</td>
        <td>${data.main.humidity}</td>
      </tr>
    </table>
  `;
  document.getElementById('weather-table').innerHTML = html;
}

async function getWeatherForecast(city) {
  const response = await fetch(
    `https://api.openweathermap.org/data/2.5/forecast?q=${city}&appid=${apiKey}&units=metric`
  );
  const data = await response.json();

  // Extract date and temperature every 8 entries (~24 hours)
  const forecasts = data.list.filter((_, index) => index % 8 === 0);

  const tableRows = forecasts.map(forecast => `
    <tr>
      <td>${forecast.dt_txt.split(' ')[0]}</td>
      <td>${forecast.main.temp}</td>
    </tr>
  `).join('');

  const table = `
    <h3>5-Day Forecast</h3>
    <table>
      <tr><th>Date</th><th>Temperature (°C)</th></tr>
      ${tableRows}
    </table>
  `;
  document.getElementById('forecast-table').innerHTML = table;

  // Plot chart
  const labels = forecasts.map(f => f.dt_txt.split(' ')[0]);
  const temperatures = forecasts.map(f => f.main.temp);
  drawChart(labels, temperatures);
}

function drawChart(labels, data) {
  const ctx = document.getElementById('forecastChart').getContext('2d');
  new Chart(ctx, {
    type: 'bar',
    data: {
      labels: labels,
      datasets: [{
        label: 'Temperature (°C)',
        data: data,
        backgroundColor: 'rgba(54, 162, 235, 0.6)',
        borderColor: 'blue',
        borderWidth: 1
      }]
    },
    options: {
      responsive: true,
      scales: {
        y: {
          beginAtZero: false
        }
      }
    }
  });
}

TASK 8: Working with model (MongoDB & Firebase)

@signup

//Create a user database and a user document and perform crud Shell commands using mongodb 



1. Open MongoDB Shell

mongosh
2. Create or Switch to a Database

use userDB
3. Create a Collection (Optional)
MongoDB creates it automatically when inserting the first document, but you can explicitly create one:


db.createCollection("users")
4. Insert a Document (Create)

db.users.insertOne({
  username: "john_doe",
  email: "john@example.com",
  age: 28,
  address: {
    city: "New York",
    zip: "10001"
  }
})
5. Read Documents (Read)
Find all users:


db.users.find()
Find a specific user:


db.users.findOne({ username: "john_doe" })
6. Update a Document (Update)
Update a field:


db.users.updateOne(
  { username: "john_doe" },
  { $set: { age: 29 } }
)
Add a new field:


db.users.updateOne(
  { username: "john_doe" },
  { $set: { phone: "123-456-7890" } }
)
7. Delete a Document (Delete)
Delete one user:

db.users.deleteOne({ username: "john_doe" })
Delete all users (use with caution):


db.users.deleteMany({})





//Create a real time database in firebase for the student management system and explore the features of Firebase Real Time Database.  Perform CRUD operations on the Real Time Database. 


npm install firebase


import { initializeApp } from 'firebase/app';
import { getDatabase, ref, set, get, update, remove } from 'firebase/database';

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_PROJECT_ID.firebaseapp.com",
  databaseURL: "https://YOUR_PROJECT_ID-default-rtdb.firebaseio.com",
  projectId: "YOUR_PROJECT_ID",
  // ...rest config
};

const app = initializeApp(firebaseConfig);
const db = getDatabase(app);

// CREATE
set(ref(db, 'students/1'), {
  name: "John Doe",
  course: "Computer Science",
  age: 21
});

// READ
get(ref(db, 'students/1')).then(snapshot => {
  if (snapshot.exists()) {
    console.log(snapshot.val());
  } else {
    console.log("No data available");
  }
});

// UPDATE
update(ref(db, 'students/1'), {
  age: 22
});

// DELETE
remove(ref(db, 'students/1'));

Working with Closures

@signup

function outerFunction(outerVariable) {
  return function innerFunction(innerVariable) {
    console.log(`Outer: ${outerVariable}, Inner: ${innerVariable}`);
  };
}

const closureExample = outerFunction("outside");
closureExample("inside"); // Outer: outside, Inner: inside

Function Generator and Symbols

@signup

// Generator function using function* syntax
function* numberGenerator() {
    yield 1;
    yield 2;
    yield 3;
}

const gen = numberGenerator();

console.log(gen.next().value); // 1
console.log(gen.next().value); // 2
console.log(gen.next().value); // 3




// Creating unique Symbols
const id1 = Symbol("id");
const id2 = Symbol("id");

console.log(id1 === id2); // false (Symbols are always unique)

// Using Symbol as an object key
const user = {
    name: "Amit",
    [id1]: 101
};

console.log(user.name);  // Amit
console.log(user[id1]);  // 101

Working with Modules

@signup

🔹 a. Exporting from a module
📁 File: mathUtils.js


// mathUtils.js
export const add = (a, b) => a + b;
export const subtract = (a, b) => a - b;



🔹 b. Importing in another file
📁 File: main.js


// main.js
import { add, subtract } from './mathUtils.js';

console.log(add(5, 3));      // 8
console.log(subtract(5, 3)); // 2

Object and Array Destructuring

@signup

// 🌟 Object Destructuring
const student = {
    name: "Rahul",
    roll: 101,
    class: "10th"
};

const { name, roll } = student;

console.log("Name:", name);   // Rahul
console.log("Roll No:", roll); // 101

// 🌈 Array Destructuring
const fruits = ["apple", "banana", "mango"];

const [fruit1, fruit2] = fruits;

console.log("First Fruit:", fruit1);  // apple
console.log("Second Fruit:", fruit2); // banana

Prototypal Inheritance and Classes.

@signup

Prototypal Inheritance (Old Way)

function Animal(name) {
    this.name = name;
}

Animal.prototype.sayHello = function() {
    console.log("Hello, I'm " + this.name);
};

let dog = new Animal("Dog");
dog.sayHello(); // Output: Hello, I'm Dog




 Classes (New Way – ES6)

class Animal {
    constructor(name) {
        this.name = name;
    }

    sayHello() {
        console.log(`Hello, I'm ${this.name}`);
    }
}

let cat = new Animal("Cat");
cat.sayHello(); // Output: Hello, I'm Cat

TASK 7: Working with Express

@signup

//1. Create a custom API for Users data and add different endpoints in express server to perform CRUD  operations on the API.  Test the endpoints using POSTMAN. 
//2. Use EJS view-engine to display the dynamic response. Display the data read from REST API in the form of a table in EJS. 




const express=require("express");
const app=express();

app.use(express.json());
app.set("view engine","ejs");

let users=[
    
    {id:1,name:"Abhi",email:"abhi@gmail.com"},
       { id:2,name:"Vars",email:"Vars@gmail.com"}

    
]


app.get("/users",(req,res)=>{
    res.render('users',{users});
})

app.get("/users/:id",(req,res)=>{
    const user=users.find(u=>u.id===parseInt(req.params.id));
    if(!user) return res.json({message:"No user"});
    res.json(user);
})

app.post("/users",(req,res)=>{
    const {name,email}=req.body;
    const newUser={
        id:users.length+1,
        name:name,
        email:email
    };
    users.push(newUser);
    res.render('users',{users});
});

app.put("/users/:id",(req,res)=>{
    const user=users.find(u=>u.id===parseInt(req.params.id));
    if(!user) return res.json({message:"No user"});
    user.name=req.body.name;
    user.email=req.body.email;
    res.json(user);
})

app.delete("/users/:id",(req,res)=>{
    users = users.filter(u => u.id != req.params.id);
    res.render('users',{users});
})

app.listen(3000,()=>{
    console.log("Server listening");
})





<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <h2>Table</h2>
    <table>
        <thead>
            <tr>
                <th>ID</th>
                <th>name</th>
                <th>email</th>
            </tr>
        </thead>
       <tbody>
        <%users.forEach(user=>{ %>
            <tr>
                <td><%=user.id %></td>
                <td><%=user.name %></td>
                <td><%=user.email %></td>
            </tr>
        <% }) %>
       </tbody>
    </table>
</body>
</html>

TASK 6: Working with http

@signup

https://chatgpt.com/share/6806ee63-d908-800e-96ea-a6b4640389c6


//1. Create a http server listening request at port 3000. Process the request to provide different type of resources as response. (HTML, TEXT, JSON, etc.).

//server.js


javascript
Copy
Edit
const http = require('http');

const server = http.createServer((req, res) => {
    if (req.url === '/') {
        res.writeHead(200, { 'Content-Type': 'text/html' });
        res.end('<h1>Welcome to the Home Page</h1>');
    } else if (req.url === '/text') {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('This is plain text.');
    } else if (req.url === '/json') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ name: 'Node.js', type: 'runtime' }));
    } else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('404 - Page Not Found');
    }
});

server.listen(3000, () => {
    console.log('Server running at http://localhost:3000');
});




//2. Create express server listening request at port 3000. Add different endpoints to provide access to the resources.

//app.js


javascript
Copy
Edit
const express = require('express');
const app = express();

// HTML response
app.get('/', (req, res) => {
    res.send('<h1>Welcome to Express Server</h1>');
});

// Plain text response
app.get('/text', (req, res) => {
    res.type('text').send('This is a plain text response.');
});

// JSON response
app.get('/json', (req, res) => {
    res.json({ language: 'JavaScript', framework: 'Express' });
});

// Start server
app.listen(3000, () => {
    console.log('Express server running at http://localhost:3000');
});

Create a custom API for Users data and add different endpoints in express server to perform CRUD operations on the API. Test the endpoints using POSTMAN.

@fsd

const express = require('express');
const app = express();
const port = 3000;

// Middleware to parse JSON bodies
app.use(express.json());

// In-memory storage for users (as a mock database)
let users = [
  { id: 1, name: 'Alice', age: 30, email: 'alice@example.com' },
  { id: 2, name: 'Bob', age: 25, email: 'bob@example.com' }
];

// GET all users
app.get('/users', (req, res) => {
  res.json(users);
});

// GET user by ID
app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).send('User not found');
  res.json(user);
});

// POST a new user
app.post('/users', (req, res) => {
  const { name, age, email } = req.body;

  // Simple validation
  if (!name || !age || !email) {
    return res.status(400).send('Please provide name, age, and email');
  }

  const newUser = {
    id: users.length + 1,
    name,
    age,
    email
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

// PUT update user by ID
app.put('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).send('User not found');

  const { name, age, email } = req.body;

  // Update user fields
  user.name = name || user.name;
  user.age = age || user.age;
  user.email = email || user.email;

  res.json(user);
});

// DELETE user by ID
app.delete('/users/:id', (req, res) => {
  const userIndex = users.findIndex(u => u.id === parseInt(req.params.id));
  if (userIndex === -1) return res.status(404).send('User not found');

  const deletedUser = users.splice(userIndex, 1);
  res.json(deletedUser[0]);
});

// Start the server
app.listen(port, () => {
  console.log(`Server running at http://localhost:${port}`);
});


index.js
----------
const express = require('express');
const fetch = require('node-fetch');
const app = express();
const port = 3000;

app.set('view engine', 'ejs');
app.set('views', __dirname + '/views');

// Route to fetch users and render table
app.get('/users', async (req, res) => {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users');
    const users = await response.json();
    res.render('users', { users });
  } catch (err) {
    res.status(500).send('Failed to fetch data');
  }
});

app.listen(port, () => {
  console.log(`Server is running on http://localhost:${port}`);
});

Create a http server listening request at port 3000. Process the request to provide different type of resources as response. (HTML, TEXT, JSON, etc.).

@fsd

const express = require('express');
const app = express();

// Middleware to parse JSON bodies
app.use(express.json());

// Home route
app.get('/', (req, res) => {
  res.send('Welcome to the Home Page!');
});

// About route
app.get('/about', (req, res) => {
  res.send('<h2>This is the About Page</h2>');
});

// JSON Data route
app.get('/data', (req, res) => {
  const data = {
    name: 'Dev',
    course: 'Full Stack',
    status: 'Learning Express'
  };
  res.json(data);
});

// POST route
app.post('/submit', (req, res) => {
  const userData = req.body;
  res.send(`Data received: ${JSON.stringify(userData)}`);
});

// 404 for other routes
app.use((req, res) => {
  res.status(404).send('404 - Page not found');
});

// Start server
app.listen(3000, () => {
  console.log('Server running at http://localhost:3000');
});

Create a http server listening request at port 3000. Process the request to provide different type of resources as response. (HTML, TEXT, JSON, etc.).

@fsd

const http = require('http');

const server = http.createServer((req, res) => {
  const url = req.url;

  if (url === '/') {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Welcome to the Home Page');
  } else if (url === '/about') {
    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.end('<h1>About Us</h1><p>This is the about page.</p>');
  } else if (url === '/data') {
    const jsonData = {
      name: 'Dev',
      course: 'Node.js',
      status: 'Learning'
    };
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify(jsonData));
  } else {
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

// Start server on port 3000
server.listen(3000, () => {
  console.log('Server is listening on http://localhost:3000');
});

Write script to read and write the streaming data using readable and writable streams.

@fsd

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('input.txt', 'utf8');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream into the writable stream
readableStream.pipe(writableStream);

// Optional: Log when done
readableStream.on('end', () => {
  console.log('Streaming complete. Data written to output.txt');
});

Use the fs module for creating directories and files of different formats

@fsd

const fs = require('fs');
const path = require('path');

// Create directory
fs.mkdirSync(path.join(__dirname, 'output'), { recursive: true });

// Create text file
fs.writeFileSync(path.join(__dirname, 'output', 'note.txt'), 'This is a text file.');

// Create JSON file
const data = { name: 'Node', type: 'runtime' };
fs.writeFileSync(path.join(__dirname, 'output', 'data.json'), JSON.stringify(data, null, 2));

Explore the functionality of os, path, util and events modules.

@fsd

const os = require('os');

console.log(os.platform());
console.log(os.cpus());
console.log(os.freemem());


const path = require('path');

console.log(path.basename(__filename));
console.log(path.join(__dirname, 'files', 'test.txt'));


const util = require('util');

const wait = util.promisify(setTimeout);
wait(1000).then(() => console.log('1 second passed'));



const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {
  console.log(`Hello, ${name}`);
});

emitter.emit('greet', 'Alice');

Create custom / local modules and export them using various module patterns.

@fsd

const math = require('./mathUtils');
console.log(math.add(5, 3));        // 8
console.log(math.subtract(9, 4));   // 5

Use fetch function to read the weather details from openweathermap.org and display the details like city, min-temp, max-temp, humidity on the webpage for a given city

@fsd

async function getWeather(){

    let city=document.getElementById('city').value;
    
const response= await fetch(`https://api.openweathermap.org/data/2.5/forecast?q=${city}&appid=6a86468ac81fa36a5565acaaa9f651b5`)
const data = await response.json()

const {list}=data
var temparray=new Array()
for(let i=0;i<list.length;i=i+8){
    const {dt_txt,main:{temp,temp_min,temp_max}}=list[i]

    
    temparray.push(temp);
   console.log(`Date:${dt_txt},Temperature:${temp},Minimum_temp:${temp_min},Max_temp:${temp_max}`)




}
}

Use fetch function to access remote data using the given api and display the data in the form of a table.

@fsd

<!DOCTYPE html>
<html>
<head>
  <title>Fetch API Table</title>
  <style>
    
    th, td {
      border: 1px solid #999;
      padding: 8px 12px;
      text-align: left;
    }
    th {
      background-color: #f2f2f2;
    }
  </style>
</head>
<body>

<h2 style="text-align:center;">User Data Table</h2>

<table id="userTable">
  <thead>
    <tr>
      <th>ID</th>
      <th>Name</th>
      <th>Email</th>
      <th>City</th>
    </tr>
  </thead>
  <tbody>
    <!-- Data will be inserted here -->
  </tbody>
</table>

<script>
  fetch("https://jsonplaceholder.typicode.com/users")
    .then(response => response.json())
    .then(data => {
      const tableBody = document.querySelector("#userTable tbody");

      data.forEach(user => {
        const row = document.createElement("tr");
        row.innerHTML = `
          <td>${user.id}</td>
          <td>${user.name}</td>
          <td>${user.email}</td>
          <td>${user.address.city}</td>
        `;
        tableBody.appendChild(row);
      });
    })
    .catch(error => {
      console.error("Error fetching data:", error);
    });
</script>

</body>
</html>

Dealing with Promise chaining and async / await.

@fsd

function task(message, delay) {
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log(message);
        resolve();
      }, delay);
    });
  }
  
  task("Task 1", 1000)
    .then(() => task("Task 2", 1000))
    .then(() => task("Task 3", 1000))
    .then(() => console.log("All tasks done (Promise Chaining)"));
    function task(message, delay) {
        return new Promise((resolve) => {
          setTimeout(() => {
            console.log(message);
            resolve();
          }, delay);
        });
      }
      
      async function runTasks() {
        await task("Task 1", 1000);
        await task("Task 2", 1000);
        await task("Task 3", 1000);
        console.log("All tasks done (Async/Await)");
      }
      
      runTasks();

ealing with the Callback Hell situation using Promise. Exploring the different ways of creating and using promise in executing the asynchronous task.

@fsd

function task1() {
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log("Task 1 done");
        resolve();
      }, 1000);
    });
  }
  
  function task2() {
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log("Task 2 done");
        resolve();
      }, 1000);
    });
  }
  
  task1()
    .then(() => task2())
    .then(() => {
      console.log("All tasks completed");
    });

. Dealing with the Callback Hell situation using Promise. Exploring the different ways of

@fsd

function task1() {
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log("Task 1 done");
        resolve();
      }, 1000);
    });
  }
  
  function task2() {
    return new Promise((resolve) => {
      setTimeout(() => {
        console.log("Task 2 done");
        resolve();
      }, 1000);
    });
  }
  
  task1()
    .then(() => task2())
    .then(() => {
      console.log("All tasks completed");
    });

Working with XHR: response.

@fsd

<!DOCTYPE html>
<html>
<head>
  <title>XHR Test</title>
</head>
<body>
  <script>
    var xhr = new XMLHttpRequest();
    xhr.open('GET', 'https://jsonplaceholder.typicode.com/posts/1', true);
    xhr.onload = function () {
      if (xhr.status === 200) {
        var data = JSON.parse(xhr.responseText);
        console.log("Response Data:", data); // This should show the post object
        // Optional: shows a popup so you know it worked
        
      } else {
        console.error("Error: " + xhr.status);
      }
    };
    xhr.onerror = function () {
      console.error("Network error");
    };
    xhr.send();
  </script>
</body>
</html>

Using Callback and creating a Callback Hell situation to understand the drawbacks.

@fsd

function mul(num,callback){
    callback(num*2);
}

function sub(num,callback){
   callback(num-3);
}

function add(num,callback){
   callback(num+10);
}

mul(2,(res)=>{
   sub(res,(sres)=>{
       add(sres,(ares)=>{
      console.log(ares) })
   })
})

. Working with higher order function in JavaScript.

@fsd

// Higher-order function: takes a function as an argument
function greet(name, greetingFunction) {
    console.log(greetingFunction(name));
  }
  
  // Function passed as an argument
  function sayHello(name) {
    return `Hello, ${name}!`;
  }
  
  // Calling the higher-order function with a function as an argument
  greet('Alice', sayHello);  // Output: Hello, Alice!

  
  // Higher-order function that returns a function
function multiplier(factor) {
    return function(number) {
      return number * factor;
    };
  }
  
  // Using the higher-order function to create a new function
  const double = multiplier(2);  // A function that doubles the input
  const triple = multiplier(3);  // A function that triples the input
  
  console.log(double(5));  // Output: 10
  console.log(triple(5));  // Output: 15
  
  const numbers1 = [1, 2, 3, 4];

// map() takes a function and applies it to each element in the array
const doubled = numbers1.map(number => number * 2);

console.log(doubled);  // Output: [2, 4, 6, 8]

const numbers = [1, 2, 3, 4, 5];

// filter() takes a function and returns an array of elements that pass the condition
const evenNumbers = numbers.filter(number => number % 2 === 0);

console.log(evenNumbers);  // Output: [2, 4]

Working with Closure.

@fsd

// Create a symbol
const uniqueSymbol = Symbol('unique');

// Using a symbol as a key for an object
const obj = {
  [uniqueSymbol]: 'This is a unique value'
};

console.log(obj[uniqueSymbol]);  // Output: This is a unique value

// Symbols are guaranteed to be unique
const anotherSymbol = Symbol('unique');
console.log(uniqueSymbol === anotherSymbol);  // Output: false

Working with Function Generators and Symbols.

@fsd

// Generator function
function* countUpTo(max) {
    let count = 1;
    while (count <= max) {
      yield count;  // Pause and return the current count
      count++;
    }
  }
  
  // Using the generator
  const counter = countUpTo(3);
  console.log(counter.next().value);  // Output: 1
  console.log(counter.next().value);  // Output: 2
  console.log(counter.next().value);  // Output: 3
  console.log(counter.next().value);  // Output: undefined (no more values)

Working with Modules.

@fsd

// Importing specific functions from math.js
import { add, subtract, PI } from './math.js';

console.log(add(2, 3));       // Output: 5
console.log(subtract(5, 3));  // Output: 2
console.log(PI);              // Output: 3.14159

Working with Object and Array Destructuring.

@fsd

const colors = ["red", "green", "blue"];
const [first, second] = colors;

console.log(first);  // Output: red
console.log(second); // Output: green


const person = { name: "Alice", age: 25 };
const { name, age } = person;

console.log(name); // Output: Alice
console.log(age);  // Output: 25

#appticz #olaclone

Ola clone app

@davidscott

https://appticz.com/ola-clone

Custom Post Type Permalink

@Bh@e_LoG

// Register Custom Post Type
function custom_ourproducts_post_type() {
    $labels = array(
        'name'                  => _x( 'Our Products', 'Post Type General Name', 'text_domain' ),
        'singular_name'         => _x( 'Our Product', 'Post Type Singular Name', 'text_domain' ),
        'menu_name'             => __( 'Our Products', 'text_domain' ),
        'name_admin_bar'        => __( 'Our Product', 'text_domain' ),
        'archives'              => __( 'Our Product Archives', 'text_domain' ),
        'attributes'            => __( 'Our Product Attributes', 'text_domain' ),
        'parent_item_colon'     => __( 'Parent Product:', 'text_domain' ),
        'all_items'             => __( 'All Products', 'text_domain' ),
        'add_new_item'          => __( 'Add New Product', 'text_domain' ),
        'add_new'               => __( 'Add New', 'text_domain' ),
        'new_item'              => __( 'New Product', 'text_domain' ),
        'edit_item'             => __( 'Edit Product', 'text_domain' ),
        'update_item'           => __( 'Update Product', 'text_domain' ),
        'view_item'             => __( 'View Product', 'text_domain' ),
        'view_items'            => __( 'View Products', 'text_domain' ),
        'search_items'          => __( 'Search Product', 'text_domain' ),
        'not_found'             => __( 'Not found', 'text_domain' ),
        'not_found_in_trash'    => __( 'Not found in Trash', 'text_domain' ),
        'featured_image'        => __( 'Featured Image', 'text_domain' ),
        'set_featured_image'    => __( 'Set featured image', 'text_domain' ),
        'remove_featured_image' => __( 'Remove featured image', 'text_domain' ),
        'use_featured_image'    => __( 'Use as featured image', 'text_domain' ),
        'insert_into_item'      => __( 'Insert into product', 'text_domain' ),
        'uploaded_to_this_item' => __( 'Uploaded to this product', 'text_domain' ),
        'items_list'            => __( 'Products list', 'text_domain' ),
        'items_list_navigation' => __( 'Products list navigation', 'text_domain' ),
        'filter_items_list'     => __( 'Filter products list', 'text_domain' ),
    );
    $args = array(
        'label'                 => __( 'Our Product', 'text_domain' ),
        'description'           => __( 'Custom post type for our products', 'text_domain' ),
        'labels'                => $labels,
        'supports'              => array( 'title', 'editor', 'thumbnail' ),
        'taxonomies'            => array( 'product_category' ),
        'hierarchical'          => false,
        'public'                => true,
        'show_ui'               => true,
        'show_in_menu'          => true,
        'menu_position'         => 15,
        'menu_icon'             => 'dashicons-cart',
        'show_in_admin_bar'     => true,
        'show_in_nav_menus'     => true,
        'can_export'            => true,
        'has_archive'           => true,
        'exclude_from_search'   => false,
        'publicly_queryable'    => true,
        'capability_type'       => 'post',
        'rewrite' => array(
            'slug' => '%product_category%',
            'with_front' => false
        ),
    );
    register_post_type( 'ourproducts', $args );
}
add_action( 'init', 'custom_ourproducts_post_type', 0 );

// Register Custom Taxonomy
function custom_product_taxonomy() {
    $labels = array(
        'name'                       => _x( 'Product Categories', 'Taxonomy General Name', 'text_domain' ),
        'singular_name'              => _x( 'Product Category', 'Taxonomy Singular Name', 'text_domain' ),
        'menu_name'                  => __( 'Product Categories', 'text_domain' ),
        'all_items'                  => __( 'All Categories', 'text_domain' ),
        'parent_item'                => __( 'Parent Category', 'text_domain' ),
        'parent_item_colon'          => __( 'Parent Category:', 'text_domain' ),
        'new_item_name'              => __( 'New Category Name', 'text_domain' ),
        'add_new_item'               => __( 'Add New Category', 'text_domain' ),
        'edit_item'                  => __( 'Edit Category', 'text_domain' ),
        'update_item'                => __( 'Update Category', 'text_domain' ),
        'view_item'                  => __( 'View Category', 'text_domain' ),
        'separate_items_with_commas' => __( 'Separate categories with commas', 'text_domain' ),
        'add_or_remove_items'        => __( 'Add or remove categories', 'text_domain' ),
        'choose_from_most_used'      => __( 'Choose from the most used', 'text_domain' ),
        'popular_items'              => __( 'Popular Categories', 'text_domain' ),
        'search_items'               => __( 'Search Categories', 'text_domain' ),
        'not_found'                  => __( 'Not Found', 'text_domain' ),
        'no_terms'                   => __( 'No categories', 'text_domain' ),
        'items_list'                 => __( 'Categories list', 'text_domain' ),
        'items_list_navigation'      => __( 'Categories list navigation', 'text_domain' ),
    );
    $args = array(
        'labels' => $labels,
        'hierarchical' => true,
        'public' => true,
        'show_ui' => true,
        'show_admin_column' => true,
        'show_in_nav_menus' => true,
        'show_tagcloud' => true,
        'rewrite' => array(
            'slug' => 'category',
            'with_front' => false,
            'hierarchical' => true
        )
    );
    register_taxonomy( 'product_category', array( 'ourproducts' ), $args );
}
add_action( 'init', 'custom_product_taxonomy', 0 );

// Filter the permalink to include taxonomy slug
function filter_ourproducts_permalink($post_link, $post) {
    if ( $post->post_type === 'ourproducts' ) {
        $terms = wp_get_post_terms($post->ID, 'product_category');
        if ( ! empty($terms) && ! is_wp_error($terms) ) {
            return str_replace('%product_category%', $terms[0]->slug, $post_link);
        } else {
            return str_replace('%product_category%', 'uncategorized', $post_link);
        }
    }
    return $post_link;
}
add_filter( 'post_type_link', 'filter_ourproducts_permalink', 10, 2 );

##marketmakingsoftware ##cryptotradingtools ##cryptoliquidity ##cryptoexchangesoftware

How Crypto Market Making Software Can Level Up Your Exchange Game

@CharleenStewar

https://www.coinsclone.com/cryptocurrency-market-making-software/

Erpnext Apps Installation

@Taimoor

//Insights Insallation
bench get-app insights //*For Latest Version
Or
bench get-app insights --branch version-3
bench --site site1.local install-app insights


//Print Designer Installation
bench get-app print_designer
bench --site site1.local install-app print_designer

//Studio Installation
bench get-app studio
bench --site site1.local install-app studio

//OR//
//Studio
bench get-app studio
bench new-site studio.localhost --install-app studio
bench browse studio.localhost --user Administrator

//Webshop Installation
bench get-app webshop
bench --site site1.local install-app webshop

//Builder Installation
bench get-app builder
bench --site site1.local install-app builder

//HRM Installation
bench get-app hrms --branch version-15
bench --site site1.local install-app hrms


//Install Payment Module//
bench get-app payments
bench --site site1.local install-app payments


//Chat Installation
bench get-app chat
bench --site site1.local install-app chat

Diaspora Signup Student

@IfedayoAwe

SELECT 
  u.id AS student_id,
  u.firstname AS student_firstname,
  u.lastname AS student_lastname,
  u.phone AS student_phone,

  parent_user.id AS parent_id,
  parent_user.firstname AS parent_firstname,
  parent_user.lastname AS parent_lastname,
  parent_user.phone AS parent_phone,
  parent_profile.country AS parent_country,

  p.status AS relationship_status,
  u.created_at AS student_signup_unix
FROM user u
INNER JOIN parents p ON p.student_id = u.id
INNER JOIN user parent_user ON parent_user.id = p.parent_id
INNER JOIN user_profile parent_profile ON parent_profile.user_id = p.parent_id
WHERE u.type = 'student'
  AND u.created_at BETWEEN 1748818800 AND 1750460400
  AND (
    (
      NOT (
        parent_user.phone LIKE '234%' OR 
        parent_user.phone LIKE '080%' OR 
        parent_user.phone LIKE '081%' OR 
        parent_user.phone LIKE '070%' OR 
        parent_user.phone LIKE '090%' OR 
        parent_user.phone LIKE '091%'
      )
    )
    AND (
      LOWER(parent_profile.country) NOT IN ('nigeria') OR parent_profile.country IS NULL
    )
  );

Ethereum Solidity Contract Source Code Verification - Bytecode - ABI (Version 2)

@mathewmerlin72

0000000000000000000000000cbb3d0cdca75fd140c2dfacaf0658b08658b109000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000107b2273756363657373223a747275657d00000000000000000000000000000000

Ethereum Solidity Contract Source Code Verification - Bytecode - ABI (Version 2)

@mathewmerlin72

JusdtHook

task 4

task 3

task 2

task 1

Write script to read and write the streaming data using readable and writable streams.

Use the fs module for creating directories and files of different formats.

Explore the Functionality of os, path, util, and events Modules

Create custom / local modules and export them using various module patterns.

Dealing with Promise chaining and async / await.

Dealing with the Callback Hell situation using Promise. Exploring the different ways of creating and using promise in executing the asynchronous task.

Working with XHR: response

Using Callback and creating a Callback Hell situation to understand the drawbacks.

Working with Higher-Order Functions in JavaScript

TASK -1 GIT

TASK 9: Working with Express & Mongo DB

TASK 4: Fetching server state using JavaScript (fetch)

TASK 8: Working with model (MongoDB & Firebase)

Working with Closures

Function Generator and Symbols

Working with Modules

Object and Array Destructuring

Prototypal Inheritance and Classes.

TASK 7: Working with Express

TASK 6: Working with http

Create a custom API for Users data and add different endpoints in express server to perform CRUD operations on the API. Test the endpoints using POSTMAN.

Create a http server listening request at port 3000. Process the request to provide different type of resources as response. (HTML, TEXT, JSON, etc.).

Create a http server listening request at port 3000. Process the request to provide different type of resources as response. (HTML, TEXT, JSON, etc.).

Write script to read and write the streaming data using readable and writable streams.

Use the fs module for creating directories and files of different formats

Explore the functionality of os, path, util and events modules.

Create custom / local modules and export them using various module patterns.

Use fetch function to read the weather details from openweathermap.org and display the details like city, min-temp, max-temp, humidity on the webpage for a given city

Use fetch function to access remote data using the given api and display the data in the form of a table.

Dealing with Promise chaining and async / await.

ealing with the Callback Hell situation using Promise. Exploring the different ways of creating and using promise in executing the asynchronous task.

. Dealing with the Callback Hell situation using Promise. Exploring the different ways of

Working with XHR: response.

Using Callback and creating a Callback Hell situation to understand the drawbacks.

. Working with higher order function in JavaScript.

Working with Closure.

Working with Function Generators and Symbols.

Working with Modules.

Working with Object and Array Destructuring.

Ola clone app

Custom Post Type Permalink

How Crypto Market Making Software Can Level Up Your Exchange Game

Erpnext Apps Installation

Diaspora Signup Student

Ethereum Solidity Contract Source Code Verification - Bytecode - ABI (Version 2)

Ethereum Solidity Contract Source Code Verification - Bytecode - ABI (Version 2)

Save snippets that work with our extensions