JAVASCRIPT

nodejs promise async

// server.js
 
function square(x) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(Math.pow(x, 2));
    }, 2000);
  });
}
 
async function layer(x)
{
  const value = await square(x);
  console.log(value);
}
 
layer(10);

async and await

// In JavaScript, An async function is a function declared with the async keyword, and the await keyword can then be permitted within it.
// Example;
function resolveAfter2Seconds() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('resolved');
    }, 2000);
  });
}

async function asyncCall() {
  console.log('calling');
  const result = await resolveAfter2Seconds();
  console.log(result);
  // expected output: "resolved"
}

asyncCall();
// The asnycCall function when run will wait for the await block which calls  resolveAfter2Seconds() before it logs the output to the console.
// We can also use the then method to wait for an async call before running another block of code.
// Example;
async function resolveAfter2Seconds() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve('resolved');
    }, 2000);
  });
}

resolveAfter2Seconds().then(
  function(result){console.log(result)}  	
  function(error){console.log(result)}  	
);

// There are so many other ways of writing asychronous functions in javascript.
// Javascript is itself an asychronous language.

async await

// example using promise
const user = () => {
	fetch("https://randomuser.me/api/?results=1")
    .then((data) => {
         console.log(data); // here you recive data
    }).catch((err)=>{
         console.log(err); // here error
    });
}

// example using async/await

const user = async () => {
  	// you must have use async keyword before use await
	const data = await fetch("https://randomuser.me/api/?results=1");
  	console.log(data); // if error occured it will be null or empty
}

async await in javascript

 const showPosts = async () => {
 const response = await fetch('https://jsonplaceholder.typicode.com/posts');
 const posts = await response.json();
 console.log(posts);
}

showPosts();

async await

//used in node.js
const fetch = require('node-fetch');
async function Showuser() {
  const result = await fetch('https://jsonplaceholder.typicode.com/todos/1');
  const date = await result.json();
  console.log(date);
}

Showuser();

async await

// ASYNC will always returns promises
// NOTE : AWAIT should be kept only inside ASYNC function
// AWAIT can't be used in regular function
/* TIPS : Js is single threaded & synchronous in nature BUT, we can
          make it as asyncronous by using (ASYNC/AWAIT)*/

//(Example 1 : fetching Random Image)
async function RandomImage(){  //remember async and await is powerful for async operations, always await should be inside of async only.

  try {
    const raw_response = await fetch("https://www.themealdb.com/api/json/v1/1/random.php");
      if (!raw_response.ok) { // check for the 404 errors
          throw new Error(raw_response.status);
      }
    const json_data = await raw_response.json();  //AWAIT
    let data = json_data.meals[0];

    console.log(data);
  }
  catch (error) { // catch block for network errors
      console.log(error); 
  }
}
RandomImage();


//(Example 2 : returning another promise)
console.log("1 is working");
console.log("2 is working");
  var AsyncFunction = async() => {
    var x = new Promise((resolve,reject) => {
        setTimeout(() => resolve("3 is working"), 3000);
    });
    var result = await x;
    return result;
  }
AsyncFunction().then(resolved => console.log(resolved));
console.log("3 is working");

async await for promise nodejs

<script>
  const helperPromise = function () {
    const promise = new Promise(function (resolve, reject) {
      const x = "geeksforgeeks";
      const y = "geeksforgeeks";
      if (x === y) {
        resolve("Strings are same");
      } else {
        reject("Strings are not same");
      }
    });
 
    return promise;
  };
 
  async function demoPromise() {
    try {
      let message = await helperPromise();
      console.log(message);
    } catch (error) {
      console.log("Error: " + error);
    }
  }
 
  demoPromise();
</script>

async await

async function showAvatar() {
	// read
  	await setTimeout(resolve, 3000);
    // read next 3s
}

showAvatar();

async and await

function delayResult() {
 return new Promise(resolve => {
   setTimeout(() => {
     resolve(‘Done’);
   }, 5000)
 })
}
async function getResult() {
 let result = await delayResult();
 return result;
}
getResult();

async promise javascript

await new Promise(resolve => setTimeout(resolve, 1000))

async await

async function f() {

  try {
    let response = await fetch('/no-user-here');
    let user = await response.json();
  } catch(err) {
    // catches errors both in fetch and response.json
    alert(err);
  }
}

f();

Async/Await

async function run () {
  const user = await getUser()
  const tweets = await getTweets(user)
  return [user, tweets]
}
 
 

async await

async function () {
  const fetchAPI = fetch(`https://bn-hadith-api.herokuapp.com/hadiths/0`);
  const response = await fetchAPI;
  const data = await response.json();
  console.log(data);
}

example of promise and async in javascript

// example of promise and async in javascript
// 1) promise: we need to write new keyword to create promise
function withConstructor(num){
  return new Promise((resolve, reject) => {
    if (num === 0){
      resolve('zero');
    } else {
      resolve('not zero');
    }
  });
}

withConstructor(0)
  .then((resolveValue) => {
  console.log(` withConstructor(0) returned a promise which resolved to: ${resolveValue}.`);
});
// Output: withConstructor(0) returned a promise which resolved to: zero.

// 2) async:  we don't need to write new keyword to create promise
async function withAsync(num){
  if (num === 0) {
    return 'zero';
  } else {
    return 'not zero';
  }
}

withAsync(100)
  .then((resolveValue) => {
  console.log(` withAsync(100) returned a promise which resolved to: ${resolveValue}.`);
})

// Output: withAsync(100) returned a promise which resolved to: not zero.

promise async await

async function myFetch() {
  let response = await fetch('coffee.jpg');
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.blob();

}

myFetch().then((blob) => {
  let objectURL = URL.createObjectURL(blob);
  let image = document.createElement('img');
  image.src = objectURL;
  document.body.appendChild(image);
}).catch(e => console.log(e));

javascript promise async

await new Promise(resolve => setTimeout(resolve, 5000));

Javascript async await & Promise

we can only use await keyword before a function that

returns either a promise or is itself async.

Note: we can use async function or function returning
a Promise with .then()

async await

async function abc() {
    console.log("1");
    const response = await fetch("https://jsonplaceholder.typicode.com/users");
    console.log("4");
    const users = await response.json();
    console.log("5");
    return users;
  }
  
  const a = abc();
  
  a.then((e) => {
    console.log(e);
  });
  console.log("2");
  console.log(a);
  console.log("3");

async/await

async function handler (req, res) {
  let response;
  try {
    response = await request('https://user-handler-service')  ;
  } catch (err) {
    logger.error('Http error', err);
    return res.status(500).send();
  }

  let document;
  try {
    document = await Mongo.findOne({ user: response.body.user });
  } catch (err) {
    logger.error('Mongo error', err);
    return res.status(500).send();
  }

  executeLogic(document, req, res);
}

async await js

fetch('coffee.jpg')
.then(response => {
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  } else {
    return response.blob();
  }
})
.then(myBlob => {
  let objectURL = URL.createObjectURL(myBlob);
  let image = document.createElement('img');
  image.src = objectURL;
  document.body.appendChild(image);
})
.catch(e => {
  console.log('There has been a problem with your fetch operation: ' + e.message);
});

await async

function afterPrintSave() {
    Xrm.Page.data.save().then(
        function () {
            resolve();
        },
        function (err) {
            resolve(alert(err.message));
        }
    );
}

nodejs promise async

// Normal Function
function add(a,b){
  return a + b;
}
// Async Function
async function add(a,b){
  return a + b;
}