jQuery는 DOM 객체를 탐색, 접근하는 여러가지 방법을 제공한다.
실무에서 많이 사용하는 메서드 위주로 요약해서 작성하였으며 모든 메서드나 정확한 정보들을 확인하고 싶다면 jQuery 공식 사이트를 참조하면 된다.

 

parent 

선택자의 바로 상위 요소만을 탐색해서 일치하는 요소를 가져온다.
단일 레벨만 탐색하는 것을 제외하면 parents와 유사하다.

// Html
<div id="wrap">
<div id="inner">
<div id="box"></div>
</div>
</div>

// jQuery
$('#box').parent(); // #inner 반환

 

parents

선택자의 상위 요소들을 탐색해서 일치하는 요소를 가져온다.
가까운 요소부터 외부 요소 순서로 반환된다.

// Html
<div id="wrap">
<div id="inner">
<div id="box"></div>
</div>
</div>

// jQuery
$('#box').parents(); // #inner, #wrap, body, html 순서로 반환
$('#box').parents('div'); // #inner, #wrap 순서로 반환

 

children

선택자의 자식 요소를 가져온다.
텍스트 노드를 가져오는 것만 제외하면 contents 메서드와 유사하다.

// Html
<div id="box">
<div>요소</div>
텍스트를 입력해주세요.
</div>

// jQuery
$('#box').children(); // #box의 자식인 div 엘리먼트를 가져온다.

 

siblings

선택자의 모든 형제자매 요소를 탐색해서 일치하는 요소를 가져온다.

// Html
<div>
<div class="siblings1"></div>
<div id="box"></div>
<div class="siblings2"></div>
<div class="siblings3"></div>
</div>

// jQuery
$('#box').siblings(); // siblings 1~3까지 모두 반환

 

first

선택자를 포함하여 형제자매 요소를 탐색하며 첫번째 요소를 가져온다.

// Html
<div class="box">
1번
<div>1-1번</div>
<div>1-2번</div>
</div>
<ul class="box">
<li>2-1번</li>
<li>2-2번</li>
</ul>

// jQuery
$('#box').first(); // 1번 div.box 반환

 

last

선택자를 포함하여 형제자매 요소를 탐색하며 마지막 요소를 가져온다.

// Html
<div class="box">
1번
<div>1-1번</div>
<div>1-2번</div>
</div>
<ul class="box">
<li>2-1번</li>
<li>2-2번</li>
</ul>

// jQuery
$('#box').last(); // ul.box 반환

 

prev

선택자를 포함하여 요소의 바로 이전 형제를 가져온다.

// Html
<div id="box">
<div class="prev"></div>
<div class="target"></div>
<div class="next"></div>
</div>

// jQuery
$('#box .target').prev(); // div.prev 반환

 

prevAll

선택자를 포함하여 요소의 바로 이전 형제자매 요소를 가져온다.
가까운 순서대로 반환한다.

// Html
<div id="box">
<div class="prev1"></div>
<div class="prev2"></div>
<div class="target"></div>
<div class="next"></div>
</div>

// jQuery
$('#box .target').prevAll(); // div.prev2, div.prev1순으로 반환

 

next

선택자를 포함하여 요소의 바로 다음 형제자매 요소를 가져온다.

// Html
<div id="box">
<div class="prev"></div>
<div class="target"></div>
<div class="next"></div>
</div>

// jQuery
$('#box .target').next(); // div.next 반환

 

nextAll

선택자를 포함하여 요소의 바로 다음 형제자매 요소를 가져온다.
가까운 순서대로 반환한다.

// Html
<div id="box">
<div class="prev"></div>
<div class="target"></div>
<div class="next1"></div>
<div class="next2"></div>
</div>

// jQuery
$('#box .target').nextAll(); // div.next1, div.next2순으로 반환

 

eq

선택자를 포함하여 형제자매 요소를 탐색하며 index는 0부터 시작한다.
index에 해당하는 순번의 요소를 가져온다.
음수를 넣을 경우 끝에서부터 시작한다.

// Html
<ul id="box">
<li>1-1번</li>
<li>1-2번</li>
<li>1-3번</li>
<li>1-4번</li>
</ul>

// jQuery
$('#box li').eq(0); // 1-1번 li 반환
$('#box li').eq(-2); // 1-3번 li 반환

 

get

index가 없을 경우 해당하는 모든 요소를 배열로 가져온다.
index를 지정하면 단일 요소를 검색하며 index는 0부터 시작한다.
음수를 넣을 경우 끝에서부터 시작한다.

// Html
<ul id="box">
<li>1번</li>
<li>2번</li>
<li>3번</li>
</ul>

// jQuery
$('#box li').get(); // 1~3번까지 배열로 반환
$('#box li').get(1); // 2번 반환
$('#box li').eq(-2); // 2번 반환

 

has

선택자를 포함하여 하위 요소들을 탐색하여 일치하는 요소를 포함하고있는 요소를 가져온다.

// Html
<ul id="box">
<li>1번</li>
<li>2번</li>
<li>3번</li>
</ul>

// jQuery
$('#box').has('li'); // #box 반환

 

contents

자식 엘리먼트와 텍스트 노드를 가져온다.
텍스트 노드를 가져오는 것만 제외하면 children 메서드와 유사하다.
iframe의 document에 접근할 수 있다.

// Html
<div id="box">
<div>요소</div>
텍스트를 입력해주세요.
</div>

<iframe id="page" src="../sub/page.html" width="500px" height="500px"></iframe>

// jQuery
$('#box').contents(); // #box의 자식인 div 엘리먼트와 함께 text node를 가져온다.
$('#page').contents(); // page.html의 document를 가져온다.

contents, children 차이

// Html
<div id="box">텍스트를 입력해주세요.</div>

// jQuery
$('#box').contents(); // Text node를 가져오며 data에서 "텍스트를 입력해주세요." 확인 가능
$('#box').children(); // 빈 값

Text Node란? - DOM에서 공백이나 텍스트 문자는 Text Node로 표현된다.

 

find

여러 레벨의 하위 요소들을 탐색하여 해당하는 요소를 가져온다.

// Html
<div id="box">
<p>1번</p>
<div>
<p>2번</p>
</div>
</div>

// jQuery
$('#box').find('p'); // #box의 하위 요소 중에 p를 모두 가져온다.(1번, 2번)

 

closest

선택자를 포함하여 상위 요소를 순차적으로 탐색하여 해당하는 요소를 찾는다.
일치하는 요소를 찾는 순간 탐색은 중단하고 해당 요소를 가져온다.
parents 메서드와 유사하나 선택자의 포함여부, 검색 트리의 이동등의 차이점이 존재한다.

// Html
<ul class="closest">
<li class="closest">
<span id="box"></span>
</li>
</ul>

// jQuery
$('#box').closest('.closest'); // 상위 요소에서 li.closest를 찾은 후 탐색을 중단하고 li.closest 반환

 

filter

선택자를 포함하여 하위 요소를 탐색하여 일치하는 모든 요소를 가져온다.
함수 형식으로 사용할 수 있다.

// Html
<ul id="box">
<li>1번</li>
<li class="items">2번</li>
<li class="items">3번</li>
<li>4번</li>
</ul>

// jQuery
$('#box li').filter('.items'); // 2번, 3번 li.items 반환
$('#box li').filter(function(i, o){
return i > 1 && o;
}); // i가 1보다 크다면 o를 반환하는 함수로 3번, 4번 li를 반환

 

not

선택자의 하위 요소에서 입력한 값과 일치하지 않는 요소를 가져온다.
함수 형식으로 사용할 수 있다.

// Html
<ul id="box">
<li>1번</li>
<li class="items">2번</li>
<li class="items">3번</li>
<li>4번</li>
</ul>

// jQuery
$('#box li').not('.items'); // 1번, 4번 li 반환
$('#box li').not(function(i, o){
return i > 1 && o;
}); // i가 1보다 크다면 o를 not으로 반환하기때문에 1보다 작은 1번, 2번 li를 반환

 

is

선택자가 입력한 값과 관련되는 상태를 확인 후 일치하는 결과에 따라 true, false로 반환한다.
선택자의 결과나 태그를 확인할때 유용하다.
함수 형식으로 사용할 수 있다.

// Html
<ul id="box" data-type="list">
<li>1번</li>
<li>2번</li>
</ul>

// jQuery
$('#box').is('[data-type="list"]'); // true 반환
$('#box').on('click', function(e){
console.log($(e.target).is('li')); // #box 클릭 시 li가 포함되어 있기 때문에 true 반환
});

그 외 입력한 값이 해당 타입인지 판별하는 메서드들도 있다. 

(isArray, isFunction, isNumeric, isPlainObject, isWindow, isXMLDoc)

 

end

메소드체이닝에서 메소드를 호출하고 나서 이전 엘리먼트로 돌아가는데 사용한다.
객체를 반환하는 메소드 뒤에 이어서 사용할 수 있다.

// Html
<div id="box">
<div>1번</div>
<div>2번</div>
</div>

// jQuery
$('#box').children().end(); // #box 반환

메소드체이닝 페이지가 만들어지면 사용하고 아니면 간략하게 적어주자

 

scrollTop

세로스크롤의 위치 값을 설정하거나 가져올 수 있습니다.

// CSS
#box{ overflow:scroll; height:500px; }
#child{ height:1000px; }
// Html
<div id="box">
<div id="child"></div>
</div>

// jQuery
$('#box').scrollTop(50); // 50px 내려간 위치로 설정

 

 

 

Javascript VS jQuery

Javscript API에 비해 jQuery는 선택자를 사용하여 DOM(Document Object Model) 요소에 쉽고 편리하게 접근할 수 있다.

// Javascript
document.getElementById('container');
document.querySelector('#container');

// jQuery
$('#container')

 

아래는 기초적인 선택자만 작성하였으므로 모든 선택자를 확인하려면 jQuery 사이트 참조

 

 

직접 선택자

아이디 (#) 

id는 페이지내에서 유일해야한다.

// Html
<div id="container">
    <div class="nav"></div>
</div>
 
// jQuery
$('#container')

 

클래스 (.)

동일한 클래스를 가진 복수의 요소가 될 수 있다.

// Html
<div class="box">
    <div class="items">
    <div class="items">
</div>
 
// jQuery
$('.box')
$('.items') // 복수의 요소가 됨

 

태그

동일한 태그를 가진 복수의 요소가 될 수 있다.

// Html
<div id="container"></div>
<div class="footer">
    <a href=".."></a>
</div>
 
// jQuery
$('div') // 복수의 요소가 됨
$('a')

 

속성 ([])

동일한 태그의 속성에 접근 할 경우 복수의 요소가 될 수 있다.

// Html
<div data-type="number">
    <a href="./main/index.html"></a>
</div>
 
// jQuery
$('a[href]')
$('div[data-type]')

 

속성 일치 (=)

// Html
<form>
    <input type="tel" name="phoneNumber">
    <input type="text" data-type="desc">
</form>
 
// jQuery
$('input[name="phoneNumber"]')
$('input[data-type"desc"]')

 

속성 불일치 (!)

// Html
<form>
    <input type="tel" name="phoneNumber">
</form>
 
// jQuery
$('input[name!="phoneNumber"]')

 

속성 선택 값으로 시작 (^)

// Html
<form>
    <input type="tel" name="phoneNumber">
</form>
 
// jQuery
$('input[name^="phone"]')

 

속성 선택 값으로 종료 ($)

// Html 
<form> 
    <input type="tel" name="phoneNumber"> 
    <input type="tel" name="userNumber"> 
</form> 
  
// jQuery 
$('input[name$="Number"]')

 

속성 선택 값과 일치하거나 선택 값 뒤에 '-'를 붙여 시작하는 값 (|)

// Html
<form>
    <input type="tel" name="phone-number">
    <input type="tel" name="phone-type">
</form>
 
// jQuery
$('input[name|="phone"]') // 복수의 요소가 됨

 

속성 선택 값을 포함하고 있음 (*)

// Html
<img src="./assets/image/@sample.png">
<img src="../@today.png">
 
// jQuery
$('img[src*="@"]') // 복수의 요소가 됨

 

속성 선택 값 중에 일치하는 단어가 있음 (~)

// Html
<div class="header nav"></div>
<div class="footer nav last_container"></div>
 
// jQuery
$('div[class~="nav"]') // 복수의 요소가 됨

 

복수 속성

// Html
<input type="text" data-value="C0808" name="userID">
<input type="text" data-value="C0824" name="userID">
 
// jQuery
$('input[data-value][name="userID"]') // 복수의 요소가 됨

 

 

인접관계 

선택자자식 선택자 (>)

// Html
<div id="header">
    <div>
        <ul>
            <li></li>
            <li></li>
        </ul>
    </div>
</div>
 
// jQuery
$('#header > div')
$('ul > li') // 복수의 요소가 됨

 

자식, 후손 선택자

해당하는 태그 아래 일치하는 모든 태그

// Html
<div id="header">
    <div>
        <div>
            <div></div>
        </div>
    </div>
</div>
 
// jQuery
$('#header div') // 복수의 요소가 됨

 

형제자매 선택자 (+, ~)

선택자 + 선택자 : 다음에 오는 하나의 태그

선택자 ~ 선택자 : 형제 자매 중 일치하는 모든 것

// Html
<div>
    <div class="box"></div>
    <div></div>
    <div></div>
</div>
 
// jQuery
$('.box + div')
$('.box ~ div') // 복수의 요소가 됨

 

가상선택자(pseudo selector) (:)

input type

// Html
<input type="input">
<input type="button">
<input type="image">
<input type="radio">
<input type="checkbox">
 
// jQuery
$(':input')
$(':button')
$(':image')
$(':radio')
$(':checkbox')

 

순서(형제, 자매, 부모)

구문

$(':odd') // 홀수 (index의 시작 = 0)
$('.box > :even') // 짝수 (index의 시작 = 0)
$(':gt(인덱스)') // 해당하는 인덱스 초과 (index의 시작 = 0)
$(':lt(인덱스)') // 해당하는 인덱스 미만 (index의 시작 = 0)
$(':eq(인덱스)') // 해당 인덱스에 맞는 번째 (index의 시작 = 0)
$(':first') // 선택자를 기준으로 첫번째
$(':last') // 선택자를 기준으로 마지막
$(':first-child') // 첫번째*
$(':last-child') // 마지막*
$(':nth-child(인덱스)') // 해당 인덱스에 맞는 번째* (index의 시작 = 1)
$(':nth-of-type(인덱스)') // 해당 인덱스에 맞는 번째 (index의 시작 = 1)

*표시는 형제, 자매 태그들이 순서 기준에 영향을 줌을 뜻하므로 예제 참고

 

예제

// Html
<div class="box">
    <div>
        1번
        <div>1-1번</div>
        <div>1-2번</div>
    </div>   
    <p>p다</p>
    <div>2번</div>
    <div>
        3번
        <div>3-1번</div>
        <div>3-2번</div>
    </div>
</div>
 
// jQuery
$('.box > div:odd') // 2번
$('.box > div:even') // 1번, 3번
$('.box > div:gt(1)') // 3번
$('.box > div:lt(1)') // 1번
$('.box div:eq(1)') // 1-1번
$('.box > div:eq(1)') // 2번
 
$('.box div:first') // 1번
$('.box div:last') // 3-2번
 
$('.box > div:first-child') // 1번
$('.box div:first-child') // 1번, 1-1번, 3-1번
 
$('.box > div:last-child') // 3번
$('.box div:last-child') // 1-2번, 3번, 3-2번
 
$('.box div:nth-child(1)') // 1번, 1-1번, 3-1번
$('.box div:nth-child(2)') // 1-2번, 3-2번
$('.box div:nth-child(3)') // 2번
 
$('.box div:nth-of-type(1)') // 1번, 1-1번, 3-1번
$('.box div:nth-of-type(2)') // 1-2번, 2번, 3-2번
$('.box div:nth-of-type(3)') // 3번

 

그외

// jQuery
$(':selected') // select박스 선택
$(':checked') // check박스 선택
 
$(':has(선택자)')
$(':contains(텍스트)')
 
$(':focus') // 포커스
$(':visible') // 투명상태가 아닌
$(':enabled') $(':disabled') // 활성화, 비활성화
$(':hidden') // 감춰진 상태

 

조합 예시

$('#header ul[class~="nav"] li')
$('.box .items > button:focus')
$('.box + .box')
$('section#container > .slide:nth-of-type(3)')

 

Load 이벤트

  • DOM(Document Object Model)의 Standard 이벤트

  • 화면에 필요한 모든 요소화면에 필요한 모든 요소(*Html, Css, Js, Image, Iframe등)가 브라우저 메모리에 올라간 경우 실행된다. 

  • 요소에 문제가 생길 경우 딜레이가 발생할 수 있다.

  • 중복 선언 시 하나만 실행되므로 주의해야한다.

$(window).load(function(){
	// 코드 작성
});

 

 

Ready 이벤트

  • 리소스 상관없이 브라우저가 DOM Tree를 생성한 직후에 실행된다.

  • load 이벤트보다 빨리 실행되며 중복 선언이 가능하며 선언 순서에 따라 실행된다.

$(document).ready(function(){
	// 코드 작성
});

 

 

Load VS Ready

두 이벤트의 차이를 이해하기 위해서 브라우저의 흐름을 알아보자

 

전체 흐름

 

 

[사용자 페이지 접속]

→ HTML 파일 서버로부터 전달 받음 


→ HTML 파싱 후 DOM(Document Object Model) Tree 생성

 

DOM Tree

 

 

→ CSS 파싱 후 Style Rules 생성

Style Rules

 

 

→  DOM Tree, Style Rules 결합 Render Tree 생성

DOM Tree + Style Rules = Render Tree

 

 

→ [사용자 페이지 확인]

 

 

간단하게 흐름 확인

사용자 방문

브라우저 시작

문서 파싱

DOM 생성(Ready 실행)

리소스 로드

페이지 로딩 완료(Load 실행)

 

load 이벤트,  ready 이벤트 차이는 '호출시점'의 차이 (ready → load 순)

 

*window > document

document 객체는 window 객체의 자식객체이며 html의 요소들이나 속성에 접근할 때 사용한다.

 

Shorhand(줄여쓰기)

$(function(){
	// 코드 작성
});

 

몇일 전에 크레인인형뽑기 문제를 풀고 난 후에 다른 사람의 코드에서 reduce 메서드를 사용하는 것을 확인했고 궁금해져서 메서드에 대해 공부해봤습니다.

 

reduce

reduce 구문

arr.reduce(callback(acc, cur, curIndex, arr), initVal]);

 

reduce 인자

누적 값(acc)

현재 값(cur)

현재 인덱스 (curIndex)

원본 배열(arr)

 

그리고 initialValue라는 callback의 최초 acc에 제공하는 누적 값의 초기 값.

만약 초기 값이 없다면 자동으로 누적 값은 원본배열(arr)의 0번째 인덱스 값으로 지정됩니다.

 

간단한 예제를 보겠습니다.

// 초기 값이 없을때
[1,2,3,4,5].reduce((acc, cur, curIndex, arr) => {
	// acc는 초기값이 없으므로 [1,2,3,4,5]에서 첫번째 인덱스의 값인 1이 됩니다.
    
    // cur는 acc가 초기 값을 사용했으므로 [1,2,3,4,5]에서 그 다음 인덱스의 값인 2가 됩니다.

	// curIndex는 cur값이 2이므로 2의 인덱스인 1이 됩니다.
    
    // arr는 원본 배열인 [1,2,3,4,5]가 됩니다.
});

// 초기 값이 있을때
[1,2,3,4,5].reduce((acc, cur, curIndex, arr) => {
	// acc는 초기값이 있으므로 0이 됩니다.
    
    // cur는 [1,2,3,4,5]에서 1이 됩니다.

	// curIndex는 cur값이 1이므로 1의 인덱스인 0이 됩니다.
    
    // arr는 원본 배열인 [1,2,3,4,5]가 됩니다.
}, [0]);

이때 빈 배열에서 초기 값 없이 reduce를 호출하면 오류가 발생합니다.

 

 

초기 값이 없는 경우의 예제를 보겠습니다.

반복문의 첫번째라고 가정해보겠습니다.

var arr = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){

  // 초기 값이 없기에 배열의 첫번째 인자값이 된다 = 0
  console.log(acc);

  // 첫번째 배열이 초기값이 되어서 cur값은 그 다음 값인 1이 된다. 
  console.log(cur);

  // cur이 1인 값을 가졌으니 1의 값의 index가 찍힌다 = arr의 1은 1번째 인덱스에 있다.
  console.log(curIndex);

  // arr은 현재 호출된 배열이므로 [0,1,2,3,4]가 찍힌다.
  console.log(arr);
});

두번째라고 가정해보겠습니다.

var arr = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){

  // 리턴 값이 없기 때문에 undefined가 된다.
  console.log(acc);

  // 이전의 값은 1이었으니 그 다음 값이 현재 값이 되므로 2가 찍힌다. 
  console.log(cur);

  // cur이 2인 값을 가졌으니 2의 값의 index가 찍힌다 = arr의 2는 2번째 인덱스에 있다.
  console.log(curIndex);

  // arr은 현재 호출된 배열이므로 [0,1,2,3,4]가 찍힌다.
  console.log(arr);
});

이런식으로 반복이되며 배열의 길이-1 만큼 반복을 합니다.

 

 

초기 값이 있는 경우의 예제를 보겠습니다.

반복문의 첫번째라고 가정해보겠습니다.

var arr = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){

  // 초기 값이 1이 있기 때문에 acc는 1이다.
  console.log(acc);

  // 초기값이 있었기 때문에 acc가 원본 배열의 첫번째 인덱스의 값을 가져가지 않았기 때문에 cur은 0이 된다. 
  console.log(cur);

  // cur이 0인 값을 가졌으니 0의 값의 index가 찍힌다 = arr의 0은 0번째 인덱스에 있다.
  console.log(curIndex);

  // arr은 현재 호출된 배열이므로 [0,1,2,3,4]가 찍힌다.
  console.log(arr);
}, 1);

두번째라고 가정해보겠습니다.

var arr = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){

  // 리턴 값이 없기 때문에 undefined가 된다.
  console.log(acc);

  // 이전의 값은 0이었으니 그 다음 값이 현재 값이 되므로 1가 찍힌다. 
  console.log(cur);

  // cur이 1인 값을 가졌으니 1의 값의 index가 찍힌다 = arr의 1은 1번째 인덱스에 있다.
  console.log(curIndex);

  // arr은 현재 호출된 배열이므로 [0,1,2,3,4]가 찍힌다.
  console.log(arr);
}, 1);

 

만약 첫번째 두번째 반복에서 return이 있다면 결과가 어떻게될까?

return 값이 있는 예제를 보겠습니다.

두번째라고 가정해보겠습니다.

var arr = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){

  // 첫번째 반복에서 acc는 1이었고 cur는 0이었다. 
  // return 1 + 0이 현재의 acc값이므로 acc는 1이다.
  console.log(acc);

  // 이전의 값은 0이었으니 그 다음 값이 현재 값이 되므로 1이 찍힌다. 
  console.log(cur);

  // cur이 1인 값을 가졌으니 1의 값의 index가 찍힌다 = arr의 1은 1번째 인덱스에 있다.
  console.log(curIndex);

  // arr은 현재 호출된 배열이므로 [0,1,2,3,4]가 찍힌다.
  console.log(arr);
  
  // acc는 1이고 cur도 1이다. 1+1로 return 2가 된다.
  return acc + cur;
}, 1);

 

이런식으로 return을 통한 인수의 총 값을 구하는 것도 가능하다.

var array = [0,1,2,3,4];

arr.reduce(function(acc, cur, curIndex, arr){
	return acc + cur;
});

 

좀 더 심화되는 코드로 배열에 중복되지 않는 숫자를 추가하는 예제를 확인해보자.

var arr = [0,1,0,2];

arr.reduce(function(acc, cur){

  // 초기값은 빈배열이다.
  // 초기값이 있기 때문에 cur은 0부터 시작한다.
  // 배열에서 cur값을 indexOf 메서드를 통해 찾는다.
  if(acc.indexOf(cur)< 0 ) 

  // acc에 cur 값을 push한다.
  acc.push(cur);

  // acc 값을 리턴한다.
  return acc;
}, []);

 

비동기 프로그래밍에서도 유용하게 쓸 수 있습니다.

const timeArr = [1000, 2000, 3000, 4000, 5000];

const factory = (time) => {
    return new Promise((resolve, reject) =. {
        setTimeout(resolve, time);
    }
};

timeArr.reduce((acc, cur) => {

  // 이전에 리턴받은 결과가 then되고나서 현재 값 전달
  return acc.then(() => factory(cur));

  // 초기값
}, Promise.resolve());

 

 


참고
https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

 

 

 

+ Recent posts