728x90

`Promise.all()`은 여러 개의 프로미스 객체를 받아 이들이 모두 완료될 때까지 기다리는 JavaScript의 비동기 처리 메서드입니다. 다음은 `Promise.all()`의 장단점입니다:

장점:
1. 병렬 실행: `Promise.all()`은 여러 프로미스를 병렬로 실행하므로 여러 개의 비동기 작업을 동시에 처리할 수 있습니다. 이는 성능 향상에 도움이 됩니다.
2. 대기 시간 최소화: 모든 프로미스가 완료될 때까지 대기하므로, 모든 작업이 완료되는 데 가장 긴 시간을 기다리는 것만큼의 시간이 소요됩니다. 이는 대기 시간을 최소화하고 효율적인 처리를 가능하게 합니다. (장점이 아닌 것처럼 보일 수 있습니다만, 순서대로 실행시키고 기다리는 시간보다 병렬로 실행하면 가장 긴 시간과 가장 적은 시간의 호출을 동시에 시작하게 만들 수 있다는 뜻으로 보입니다) E.g. 1초가 걸리는 호출을 3번 호출하면 응답에 필요한 시간은 총 3초. 반면에 1초가 걸리는 호출을 병렬로 실행하면 응답에 필요한 시간은 총 1초

단점:
1. 하나의 프로미스 실패 시 실패: `Promise.all()`은 모든 프로미스가 성공적으로 완료되어야 전체가 성공으로 처리됩니다. 하나의 프로미스라도 실패하면 전체 `Promise.all()`이 실패합니다. 이것은 실패 처리 및 오류 복구가 어려울 수 있습니다.
2. 순서 보장 없음: `Promise.all()`은 프로미스의 순서를 보장하지 않습니다. 따라서 프로미스가 완료되는 순서에 의존하지 않아야 합니다.
3. 모든 프로미스 필요: 모든 프로미스가 필요하며, 일부만 완료되더라도 결과를 얻을 수 없습니다.

`Promise.all()`을 사용할 때는 이러한 장단점을 고려하여 프로젝트 요구사항에 맞게 적절하게 사용해야 합니다.

 

async function a() {
  return 'a';
}

async function b() {
  return 'b';
}

await Promise.all([a(), b()]);

 

출처: ChatGPT 3.0, OpenAI

728x90
// function makeArmy() {
// let shooters = [];
// let i = 0;
// while (i < 10) {
// const copyIndex = i;
// let shooter = function() { // create a shooter function,
// console.log( copyIndex ); // that should show its number
// };
// shooters.push(shooter); // and add it to the array
// i++;
// }
// // ...and return the array of shooters
// return shooters;
// }
function makeArmy() {
let shooters = [];
for(let i = 0; i < 10; i++) {
const shooter = function() {
console.log( i );
};
shooters.push(shooter);
}
return shooters;
}
let army = makeArmy();
army[0](); // 0
army[1](); // 1
army[2](); // 2
army[3](); // 3
army[4](); // 4
army[5](); // 5
army[6](); // 6
army[7](); // 7
army[8](); // 8
army[9](); // 9
728x90
// function byField(field) {
// return function(a, b) {
// return a[field] > b[field] ? 1 : -1;
// }
// }
function byField(field) {
return (a, b) => a[field] > b[field] ? 1 : -1;
}
const users = [
{ name: "John", age: 20, surname: "Johnson" },
{ name: "Pete", age: 18, surname: "Peterson" },
{ name: "Ann", age: 19, surname: "Hathaway" }
];
users.sort(byField('name'));
console.log('sort by name field', users);
users.sort(byField('age'));
console.log('sort by age field', users);
728x90
function inBetween(a, b) {
return function(x) {
return x >= a && x <= b;
}
}
function inArray(arr) {
return function(x) {
return arr.includes(x);
}
}
const arr = [1, 2, 3, 4, 5, 6, 7];
console.log( arr.filter(inBetween(3, 6)) ); // 3, 4, 5, 6
console.log( arr.filter(inArray([1, 2, 10])) ); // 1, 2
728x90
let x = 1;
function func() {
console.log(x); // ?
// dead zone
let x = 2;
}
func();
// Error
728x90
function sum(a) {
return function(b) {
return a + b; // takes "a" from the outer lexical environment
}
}
// sum(1)(2) = 3
// sum(5)(-1) = 4
console.log(sum(1)(2));
console.log(sum(5)(-1));
728x90
"use strict"
let phrase = "Hello";
if (true) {
let user = "John";
function sayHi() {
console.log(`${phrase}, ${user}`);
}
}
sayHi();
// Answer: error
// sayHi function located in if block
728x90
function Counter() {
let count = 0;
this.up = function() {
return ++count;
};
this.down = function() {
return --count;
};
}
let counter = new Counter();
console.log( counter.up() ); // ?
console.log( counter.up() ); // ?
console.log( counter.down() ); // ?
// Answer: 1
// Answer: 2
// Answer: 1
// it has same lexical environment
728x90
function makeCounter() {
let count = 0;
return function() {
return count++;
};
}
let counter = makeCounter();
let counter2 = makeCounter();
console.log( counter() ); // 0
console.log( counter() ); // 1
console.log( counter2() ); // ?
console.log( counter2() ); // ?
// Answer: 0
// Answer: 1
// because it has different lexical environment
728x90
function makeWorker() {
let name = "Pete";
return function() {
console.log(name);
};
}
let name = "John";
// create a function
let work = makeWorker();
// call it
work(); // what will it show?
// Answer: Pete

+ Recent posts