Initial Commit

async-await/0_callbacks.js

@@ -0,0 +1,45 @@
+// https://javascript.info/callbacks
+
+entryPoint();
+
+function entryPoint () {
+  
+    execute_action('something', function (error, time_of_completion) {
+      if (error) {
+        console.log('Something happened');
+      } else {
+        console.log('Time of completion: ' + new Date(time_of_completion).toDateString());
+      }
+    });
+    console.log("I don't need execute_action's value");
+  }
+
+  function execute_action (param, callback) {
+    if (param == 'something') {
+      console.log('Executing action: ' + param);
+      callback(null, Date.now());
+    } else {
+      // We can call callback with one argument even if
+      // the signature states two parameters.
+      callback(new Error('Invalid parameter'));
+    }
+  }
+
+  /*
+    This is useful when, for example, execute_action performs slow operations
+    (such as I/O, HTTP requests etc) and we need its result to continue a
+    specific operation (in this case the date of completion), without blocking
+    other portions of code that do not need such value, in this case
+    "console.log("I don't need execute_action's value");"
+
+    But please note that this is only an example. In this code all
+    operations will be executed synchronously, but this allows us
+    to understand the basics of this mechanism.
+
+    Output:
+        Executing action: something
+        Time of completion: Sun Jun 30 2024
+        I don't need execute_action's value
+    
+  */
+  

async-await/1_promises.js

@@ -0,0 +1,47 @@
+// https://javascript.info/promise-basics
+
+/*
+    The function passed to Promise is called "executor".
+    and gets executed the moment the Promise is created.
+    When the Promise ends, the callback function should 
+    either call the "resolve" or "reject" callbacks:
+    resolve(value) — if the job is finished successfully, with result value.
+    reject(error) — if an error has occurred, error is the error object.
+*/
+const promise = new Promise(function (resolve, reject) {
+    setTimeout(() => resolve('done'), 500);
+  });
+  
+  /*
+      The first argument of .then is a function that runs when the promise is resolved and receives the result.
+      The second argument of .then is a function that runs when the promise is rejected and receives the error.
+      The function passed to "then()" is put in the event loop queue!
+  */
+  promise.then(
+    result => console.log('The operation was successful. It returned ' + result),
+    error => console.log('The operation was not successful: ' + error)
+  );
+  
+  /*
+      Or we can pass only one argument if we're interested only in a positive result
+  */
+  promise.then(
+    result => console.log('The operation was successful. It returned ' + result)
+  );
+  
+  /*
+      Or we can pass only one argument to the method "catch" if we're interested
+      in negative results only.
+  
+      promise.catch internally just calls promise.then(null, f)
+  */
+  promise.catch(
+    error => console.log(error)
+  );
+  
+  /*
+      finally gets always called
+  */
+  promise.finally(
+    () => console.log('The execution has terminated. Bye')
+  );

async-await/3_promise-chaining.js

@@ -0,0 +1,48 @@
+// https://javascript.info/promise-chaining
+
+// .then() returns a new Promise when you do "return",
+// internally calling resolve().
+
+new Promise(function (resolve, reject) {
+    setTimeout(() => resolve(1), 1);
+  }).then(function (result) {
+    console.log(result);
+    return result * 2;
+  }).then(function (result) {
+    console.log(result);
+    return result * 2;
+  }).then(function (result) {
+    console.log(result);
+    return result * 2;
+  });
+  
+  /*
+      It will print
+      1
+      2
+      4
+  */
+  
+  /*
+    It means that "then" is internally implemented roughly as follows:
+  
+    function then(f){
+      return new Promise(function(resolve, reject) {
+          resolve(f());
+      })
+    }
+  */
+  
+  // Another example:
+  
+  fetch('http://www.fsf.org')
+    // .then below runs when the remote server responds
+    .then(function (response) {
+      // response.text() returns a new promise that resolves with the full response text
+      // when it loads
+      return response.text();
+    })
+    .then(function (text) {
+      // ...and here's the content of the remote file
+      console.log(text);
+    });

async-await/sincrono_vs_asincrono.txt

@@ -0,0 +1,31 @@
+Link utili:
+https://stackoverflow.com/questions/748175/asynchronous-vs-synchronous-execution-what-is-the-difference
+https://stackoverflow.com/questions/7131991/asynchronous-and-synchronous-terms
+
+La parola "sincrono" in contesto informatico vuol dire "sincronizzato", ovvero
+il chiamante deve aspettare la risposta del chiamato, mentre
+"async" vuol dire "non sincronizzato". 
+Ciò vuol dire sincronizzato (o NON sincronizzato) con altre porzioni di codice.
+La definizione da dizionario invece differisce. 
+Per Treccani: "Sincrono: Che avviene nello stesso momento",
+mentre sappiamo che un'operazione sincrona rispetto ad un'altra
+non avviene allo stesso tempo.
+In informatica dire "un metodo è (a)sincrono" deve
+sempre accompagnate da "rispetto a chi" è (a)sincrono.
+
+Possiamo anche pensarla così: (https://stackoverflow.com/a/32052611/18371893)
+
+In a nutshell, synchronization refers to two or more processes' start and end points, NOT their executions. 
+In this example, Process A's endpoint is synchronized with Process B's start point:
+
+SYNCHRONOUS
+   |--------A--------|
+                     |--------B--------|
+
+Asynchronous processes, on the other hand, do not have their start and endpoints synchronized:
+
+ASYNCHRONOUS
+   |--------A--------|
+         |--------B--------|
+
+Where Process A overlaps Process B, they're running concurrently or synchronously (dictionary definition), hence the confusion.