mirror of https://github.com/xfarrow/blink.git
removing tutorials meant only to learn
This commit is contained in:
xfarrow
parent
7f4747ef4c
commit
3b6aac56ae
|
|
@ -1,45 +0,0 @@
|
|||
// https://javascript.info/callbacks
|
||||
|
||||
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'));
|
||||
}
|
||||
}
|
||||
|
||||
function entryPoint () {
|
||||
/* ===== Begin Simple callback ===== */
|
||||
|
||||
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 started here!');
|
||||
/*
|
||||
Ciò è utile se ad esempio execute_action fa operazioni lente (ad esempio
|
||||
scrittura su database, connessioni HTTP ecc..) ma abbiamo bisogno
|
||||
del suo valore di ritorno per continuare una determinata operazione
|
||||
(in questo caso la data di completamento dell'esecuzione),
|
||||
senza però bloccare le altre operazioni che non hanno bisogno di tale
|
||||
valore, in questo caso console.log("I started here!");
|
||||
|
||||
Questo però è solo un esempio in quanto le istruzioni verranno
|
||||
eseguite in maniera sincrona, ma che ci permette di
|
||||
comprendere le basi di questo meccanismo.
|
||||
*/
|
||||
|
||||
/* ===== End Simple Callback ===== */
|
||||
}
|
||||
|
||||
entryPoint();
|
||||
|
||||
// callbacks usually indicate that the
|
||||
// execution of their code will continue
|
||||
// asynchronously.
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
// https://javascript.info/promise-basics
|
||||
|
||||
/*
|
||||
The function passed to Promise is called "executor". When Promise gets
|
||||
created, the executor gets executed.
|
||||
When the Promise ends, it 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.
|
||||
|
||||
Remember that Promises are not intrensically asyncronous
|
||||
*/
|
||||
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.
|
||||
*/
|
||||
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')
|
||||
);
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
// 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);
|
||||
});
|
||||
|
|
@ -1,64 +0,0 @@
|
|||
// https://javascript.info/async-await
|
||||
|
||||
// A async function always returns a promise. Other values are wrapped in a resolved promise automatically.
|
||||
// Async e Await sono solo "sintassi zuccherina" per rendere l'utilizzo delle Promise più semplice
|
||||
|
||||
async function f1 () {
|
||||
return 1;
|
||||
}
|
||||
|
||||
f1().then(console.log); // 1
|
||||
|
||||
// The keyword await makes JavaScript wait until that promise settles and returns its result.
|
||||
// It can be used in async functions only
|
||||
// Let’s emphasize: await literally suspends the function execution until the promise settles,
|
||||
// and then resumes it with the promise result.
|
||||
async function f2 () {
|
||||
const promise = new Promise((resolve, reject) => {
|
||||
setTimeout(() => resolve('done!'), 1000);
|
||||
});
|
||||
|
||||
const result = await promise; // wait until the promise resolves (*)
|
||||
|
||||
console.log(result); // "done!"
|
||||
}
|
||||
|
||||
f2();
|
||||
|
||||
// Tutto il codice nella stessa funzione (o nello stesso blocco di codice)
|
||||
// dopo "await" è da considerarsi nel "then()" di una promessa. Pertanto dopo
|
||||
// await (ma prima del completamento della Promise),
|
||||
// il flusso di esecuzione va fuori a quel blocco di codice. Ad esempio considera
|
||||
// il seguente esempio:
|
||||
async function exampleAsyncFunction () {
|
||||
console.log('Before await');
|
||||
await new Promise(function (resolve, reject) {
|
||||
setTimeout(() => resolve('done'), 500);
|
||||
}); // Pauses execution here until the promise resolves.
|
||||
console.log('After await');
|
||||
}
|
||||
|
||||
console.log('Start');
|
||||
exampleAsyncFunction();
|
||||
console.log('End');
|
||||
|
||||
// Il risultato sarà:
|
||||
// Start, Before Await, End, After await
|
||||
// Viene prima "End" e poi "After Await", perché
|
||||
// dopo await, il flusso di esecuzione ritorna al
|
||||
// chiamante
|
||||
|
||||
// Domande
|
||||
//
|
||||
// Why await only works in async function in javascript?
|
||||
// https://stackoverflow.com/questions/49640647/why-await-only-works-in-async-function-in-javascript
|
||||
//
|
||||
// Why using async-await
|
||||
// https://stackoverflow.com/questions/42624647/why-use-async-when-i-have-to-use-await
|
||||
//
|
||||
// Si faccia presente che non è possibile creare da zero una funzione asincrona (come
|
||||
// setInterval o fetch)
|
||||
// https://stackoverflow.com/questions/61857274/how-to-create-custom-asynchronous-function-in-javascript
|
||||
//
|
||||
// Altra domanda interessante
|
||||
// https://stackoverflow.com/questions/42624647/why-use-async-when-i-have-to-use-await
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
/*
|
||||
The built-in function setTimeout uses callbacks. Create a promise-based alternative.
|
||||
The function delay(ms) should return a promise. That promise should resolve after ms milliseconds, so that we can add .then to it, like this:
|
||||
*/
|
||||
|
||||
function delay (ms) {
|
||||
return new Promise(resolve => {
|
||||
setTimeout(resolve, ms);
|
||||
});
|
||||
}
|
||||
|
||||
delay(1000).then(() => console.log('Hello world!'));
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
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 (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.
|
||||
|
||||
Loading…
Reference in New Issue