01.변수 : 데이터 불러오기


변수는 프로그래밍에서 데이터를 저장하고 참조하는데 사용되며, 값은 언제든지 변경될 수 있습니다.
변수를 선언할 때는 보통 데이터의 타입과 함께 이름을 지정하고 값을 할당합니다.
변수는 프로그램에서 재사용되며, 데이터를 보다 효율적으로 다루고 조작하는 데 도움이 됩니다.
JavaScript에서는 변수를 선언할 때 let, const, var 등의 키워드를 사용합니다.

{
    let x = 100, y = 200, z = "javascript";

    console.log(x, y, z);
}
결과 확인하기
100
200
javascript

02.상수 : 데이터 불러오기


상수는 값을 한 번 할당하면 변경할 수 없는 변수와 유사한 개념입니다.
JavaScript에서는 const 키워드를 사용하여 상수를 선언합니다.
한 번 정해진 값을 다시 변경할 수 없으므로 코드의 안정성과 가독성을 높이는 데 활용됩니다.
주로 프로그램에서 변하지 않는 값들을 상수로 정의하여 사용합니다.

{               
    const x = 100, y = 200, z = "javascript";

    console.log(x, y, z);         
}
결과 확인하기
100
200
javascript

03.배열 : 데이터 불러오기


배열은 데이터의 집합이라고 생각할 수 있습니다. 이 집합 안에는 여러 가지 항목들이 들어 있으며, 각 항목은 순서에 따라 정렬되어 있습니다.
JavaScript에서는 대괄호 []로 배열을 만들고, 각 항목은 쉼표로 구분됩니다.
배열은 데이터를 구조화하고, 배열의 요소에는 인덱스를 통해 접근할 수 있습니다.
이를 통해 프로그램에서 데이터를 효율적으로 관리하고 다룰 수 있습니다.

{
    const arr = [100, 200, "javascript"];

    console.log(arr[0], arr[1], arr[2]);
}
결과 확인하기
100
200
javascript

04.배열 : 데이터 불러오기 : 갯수


배열의 "갯수"는 배열에 포함된 요소의 총 개수를 나타냅니다.
JavaScript에서는 배열의 길이를 알아보기 위해 배열의 length 속성을 사용합니다.
이 속성을 통해 배열의 갯수를 쉽게 확인할 수 있습니다.
배열의 갯수를 알면 배열 안의 데이터를 효율적으로 관리하고 조작할 수 있습니다.

{
    const arr = [100, 200, "javascript"];

    console.log(arr.length);
}
결과 확인하기
100
200
javascript

05.배열 : 데이터 불러오기 : for()문


for()문은 반복 작업을 수행하는 제어 구조로, 초기값, 조건식, 증감식을 이용하여 반복의 시작과 종료를 결정하고, 각 반복마다 실행할 코드를 지정합니다.
초기값은 반복 시작을 정하고, 조건식은 반복을 계속할지 결정하며, 증감식은 반복마다 변수의 값을 변경합니다.
이를 통해 반복 작업을 효율적으로 처리할 수 있습니다.

{
    const arr = [100, 200, 300, 400, 500, 600, 700, 800, 900];

    for (let i = 0; i < arr.length; i++) {              // 초깃값; 조건식; 증감값;
        console.log(arr[i]);
    }
}
결과 확인하기
100
200
300
400
500
600
700
800
900

06.배열 : 데이터 불러오기 : forEach()


forEach() 메서드는 배열의 각 요소에 대해 순차적으로 작업을 수행할 때 사용되는 배열 메서드입니다.
이 메서드는 주어진 배열을 처음부터 끝까지 순회하며 각 요소에 대해 지정된 작업(콜백 함수)을 실행합니다.
콜백 함수는 배열의 요소 값과 인덱스를 인자로 받아 사용하며, 배열 자체도 인자로 전달됩니다.
forEach() 메서드를 사용하면 반복문을 대체하여 코드를 더 간결하게 작성할 수 있습니다.
이를 통해 배열을 순회하고 처리할 때 반복문을 사용하는 것보다 코드가 더욱 명확하고 읽기 쉬워집니다.

{
    // 배열을 선언하고 초기화합니다.
    const arr = [100, 200, 300, 400, 500];

    // 01.
    arr.forEach(function (element) {    // 배열의 각 요소를 element 매개변수로 받아 순회하며 출력합니다.
        console.log(element);
    });

    // 02. 
    arr.forEach(function (element, index) {     // 배열의 각 요소와 해당 요소의 인덱스를 받아 순회하며 출력합니다.
        console.log(index);
    });

    // 03.
    arr.forEach(function (element, index, array) {  // 배열의 각 요소, 해당 요소의 인덱스, 그리고 배열 자체를 받아 순회하며 출력합니다.
        console.log(array);
    });

    // 화살표 함수로 작성한 forEach() 예제들:

    // 01.
    arr.forEach((e) => {    // 화살표 함수로 각 요소를 받아 순회하며 출력합니다.
        console.log(e);
    });

    // 02. 
    arr.forEach(e => {    // 화살표 함수로 각 요소를 받아 순회하며 출력합니다.
        console.log(e);
    });

    // 03.
    arr.forEach(e => console.log(e));    // 화살표 함수로 각 요소를 받아 출력합니다.
}
결과 확인하기
100
200
300
400
500
0
1
2
3
4
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
100
200
300
400
500
100
200
300
400
500
100
200
300
400
500

07.배열 : 데이터 불러오기 : for of


for...of 반복문은 배열의 각 항목을 하나씩 순서대로 가져와서 사용할 때 쓰는 도구입니다.
배열에 있는 요소들을 한 번에 하나씩 가져와서 사용할 수 있습니다.
이 반복문은 반복할 때마다 배열의 다음 요소를 가져오기 때문에 따로 인덱스를 신경쓰지 않아도 됩니다.
즉, 배열을 편하게 순회하고 요소를 활용할 수 있습니다.

{
    const arr = [100, 200, 300, 400, 500, 600, 700, 800, 900];

    for (let element of arr) {
        console.log(element);
    }
}
결과 확인하기
100
200
300
400
500
600
700
800
900

08.배열 : 데이터 불러오기


배열은 데이터를 저장하고 관리하는데 사용되는 자료구조입니다.
먼저 배열을 선언할 때는 어떤 종류의 데이터를 다룰 것인지 결정하고, 그 크기를 지정합니다.
그 후에는 각 요소에 해당하는 위치를 인덱스로 지정하여 데이터를 저장하거나 불러옵니다.
배열을 사용함으로써 데이터를 효율적으로 정리하고 접근할 수 있습니다.

*for in 반복문은 배열의 인덱스를 순회하는 것이 아니라, 객체의 속성을 순회합니다. 때문에 배열의 요소를 순회하기 위해선 일반적으로 for of 반복문을 사용하는 것이 좋습니다

{
    const arr = [100, 200, 300, 400, 500, 600, 700, 800, 900];

    for (let element in arr) {
        console.log(arr[element]);
    }
}
결과 확인하기
100
200
300
400
500
600
700
800
900

09.배열 : 데이터 불러오기 : map()


map() 함수는 파이썬의 내장 함수 중 하나로, 반복 가능한 객체의 각 요소에 사용자가 제공한 함수를 적용하여 새로운 데이터를 생성합니다.
이때 원본 데이터를 변경하지 않고 새로운 데이터를 반환합니다.
map() 함수를 사용할 때는 함수와 함께 반복 가능한 객체를 인자로 제공하여야 합니다.
그리고 map 객체를 리스트 등 다른 자료형으로 변환하여 최종 결과를 얻을 수 있습니다.

{
        // 배열을 선언하고 초기화합니다.
        const arr = [100, 200, 300, 400, 500, 600, 700, 800, 900];
    
        // 배열의 각 요소를 출력하는 예제들:
    
        // 첫 번째 예제: 배열의 각 요소를 출력합니다.
        arr.map(function (element) {
            console.log(element); // 각 요소가 개별적으로 출력됩니다.
        });
    
        // 두 번째 예제: 배열 전체가 배열로 출력됩니다.
        arr.map(function (element) {
            console.log(element); // 배열 전체가 하나의 요소로 출력됩니다.
        });
    
        // 세 번째 예제: 배열의 각 요소의 인덱스를 출력합니다.
        arr.map(function (element, index) {
            console.log(index); // 각 요소의 인덱스가 출력됩니다.
        });
    
        // 네 번째 예제: 배열 자체가 여러 번 출력됩니다.
        arr.map(function (element, index, array) {
            console.log(array); // 배열 자체가 여러 번 출력됩니다.
        });
}
결과 확인하기
100
200
300
400
500
0
1
2
3
4
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]

10.배열 : 데이터 불러오기 : filter()


filter() 메서드는 배열에서 주어진 조건에 맞는 요소들로 이루어진 새로운 배열을 생성합니다.
각 요소에 대해 조건을 확인하고, 조건을 만족하는 요소만을 선택하여 반환합니다.
이를 통해 배열을 필터링하여 원하는 요소들을 추출할 수 있습니다.
최종적으로 반환되는 배열은 원본 배열의 순서를 유지하며, 조건에 맞는 요소들로만 구성됩니다.

{          
    const num = [1, 2, 3, 4, 5, 6, 7, 8, 9];

    num.filter(function (element) {
        console.log(element);   // filter() 메서드를 사용하여 배열 num의 각 요소를 순회하며 함수를 실행합니다.
    });

    num.filter(function (element, index) {  // 배열 num을 순회하면서 각 요소와 인덱스에 대해 함수 실행
        console.log(index);
    });

    num.filter(function (element, index, array) {   //배열 num을 순회하면서 각 요소, 인덱스, 배열 자체에 대해 함수 실행
        console.log(array)
    });

    const arr = num.filter(function (element) {
        return element > 5;     // 조건: 각 요소가 5보다 큰지 확인
    });
    console.log(arr)    // 6,7,8,9 출력

    console.log("화살표")
    const arr1 = num.filter((element) => {      // 화살표 함수를 사용하여 동일한 작업 수행  
        return element > 5;
    });
    console.log(arr)    // 6,7,8,9 출력

    console.log("괄호생략")
    const arr2 = num.filter(element => {        //화살표 함수에서 괄호를 생략하여 작업 수행
        return element > 5;
    });
    console.log(arr)    // 6,7,8,9 출력

    console.log("리턴생략")
    const arr3 = num.filter(e => e > 5);        // 화살표 함수에서 중괄호와 return 생략하여 작업 수행
 
    console.log(arr)    // 6,7,8,9 출력                 
}
결과 확인하기
100
200
300
400
500
0
1
2
3
4
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[100, 200, 300, 400, 500]
[400, 500]
[400, 500]
[400, 500]
[400, 500]
[400, 500]
[400, 500]
[400, 500]
[400, 500]

11. 배열 : 데이터 불러오기 : 배열 구조 분해 할당


배열 구조 분해 할당은 JavaScript에서 매우 유용한 기능으로, 배열을 해체하여 각 요소를 개별 변수에 할당하는 방법입니다.
이를 통해 배열의 각 요소에 쉽게 접근할 수 있습니다.
구조 분해 할당은 변수 할당의 편리성과 가독성을 높여주며, 반복적이고 장황한 코드를 줄여줍니다.
또한, 배열에서 필요한 요소만 선택하여 할당할 수 있어서 코드를 더욱 유연하게 작성할 수 있습니다.
이는 배열의 요소 위치에 따라 각 변수에 값을 할당할 때 유용하게 사용됩니다.

{
    // 기본 변수 할당
    const arr = [100, 200, "javascript"];
    const [a, b, c] = arr;

    console.log(a);     // 100
    console.log(b);     // 200
    console.log(c);     // javascript
}
{
    // 선언에서 분리한 할당
    const [a, b, c] = [100, 200, "javascript"];

    console.log(a);     // 100
    console.log(b);     // 200
    console.log(c);     // javascript
    {
        // 기본 값 설정
        const [a, b, c = "javascript"] = [100, 200];

        console.log(a);     // 100
        console.log(b);     // 200
        console.log(c);     // javascript
    }
    {
        // 배열 일부 요소 무시
        const [a, , c] = [100, 200, "javascript"];

        console.log(a);     // 100
        console.log(c);     // javascript
    }
    {
        // 나머지 값 할당
        const [a, b, ...rest] = [100, 200, "javascript", "jquery"];

        console.log(a);             // 100
        console.log(b);             // 200
        console.log(...rest);       // javascript jquery
    }
    {
        // 변수 값 교환
        let a = 100, b = 200;
        [a, b] = [b, a];

        console.log(a);
        console.log(b);
    }
    {
        // 다차원 배열 펼침연산자
        const [a, [b, c]] = [1, [2, "javascript"]];

        console.log(a);
        console.log(b);
        console.log(c);
    }
}
결과 확인하기
100
200
javascript

100
200
javascript

100
200
javascript

100
javascript

100
200
javascript
jquery

200
100

1
2
javascript

12. 배열 : 데이터 불러오기 : 배열 펼침 연산자(Spread Operator)


배열 펼침 연산자는 JavaScript에서 배열을 다룰 때 유용한 기능 중 하나입니다.
이 연산자는 ...으로 표현되며, 배열을 해체하거나 다른 배열에 병합하는 데 사용됩니다.
예를 들어, [...arr] 형태로 사용하면 배열 arr의 요소를 개별적으로 분해하여 새로운 배열에 할당할 수 있습니다. 또한, 배열을 병합할 때도 사용됩니다.
[...arr1,...arr2] 형태로 사용하면 두 배열의 모든 요소가 하나의 배열로 합쳐집니다.
이러한 특성은 배열을 다룰 때 코드를 간결하고 가독성 있게 작성할 수 있도록 도와줍니다.

{
    {
        // 배열 복사
        const arr = [100, 200, "javascript"];   // 기존 배열 정의
        const copy = [...arr];   // 배열 펼침 연산자를 사용하여 새로운 배열을 생성하여 기존 배열의 요소들을 복사함

        console.log(arr) // [100, 200, "javascript"]    // 기존 배열 출력
        console.log(...arr) // 100 200 "javascript"     // 배열의 요소를 개별적으로 출력
        console.log(copy) // [100, 200, "javascript"]   // 복사된 배열 출력
    }
    {
        // 배열 합치기
        const arr1 = [100, 200];
        const arr2 = [300, 400];
        const merged1 = [...arr1, ...arr2];     // 두 배열을 합쳐 새로운 배열을 생성함
        const merged2 = [...arr1, "javascript", ...arr2, "jquery"];     // 다양한 요소를 포함하여 배열을 합침

        console.log(arr1.concat(arr2)); //[100, 200 ,300, 400]      // concat() 메서드를 사용하여 두 배열을 합친 결과 출력
        console.log(merged1);   //[100, 200, 300, 400]      // 첫 번째와 두 번째 배열을 합친 결과 출력
        console.log(merged2);   //[100, 200, javascript, 300, 400, jquery]  // 첫 번째와 두 번째 배열 사이에 새로운 요소를 추가하여 합친 결과 출력
    }
    {
        // 함수 인자로 사용하기
        function numbers(a, b, c) {     // 세 개의 인자를 받아들이는 함수 정의
            return a + b + c;   // 받아들인 세 개의 인자를 더하여 반환
        }
        const nums = [100, 200, 300];   // 배열 정의
        console.log(numbers(...nums));      // 배열 요소를 함수의 인자로 전달하여 함수를 호출하고 결과 출력
    }
    {
        // 문자열 배열로 변환하기
        const text1 = "javascript";     // 문자열 정의
        const text2 = [...text1];   // 문자열을 배열로 변환하여 각 문자를 배열의 요소로 할당함

        console.log(text1);     // 원래 문자열 출력
        console.log(text2);     // 문자열을 배열로 변환한 결과 출력
    }
}
결과 확인하기
[100, 200, "javascript"]
100 200 "javascript"
[100, 200, "javascript"]

[100, 200, 300, 400]
[100, 200, 300, 400]
[100, 200, javascript, 300, 400, jquery]

600
javascript
['j', 'a', 'v', 'a', 's', 'c', 'r', 'i', 'p', 't']

13.객체 : 데이터 불러오기 : 기본


객체를 사용하여 데이터를 불러오는 것은 JavaScript에서 일반적입니다.
객체는 키-값 쌍의 모음이며, 키를 사용하여 값을 참조합니다.
보통 데이터를 객체로 구성하고, 이를 통해 필요한 정보를 가져옵니다.
객체를 사용하면 서버에서 데이터를 가져오는 데 자주 활용됩니다. 이를 통해 응답된 데이터를 객체로 변환하고, 필요한 정보를 추출하여 웹 페이지에 표시할 수 있습니다.
이러한 방식은 JavaScript에서 매우 일반적이며 다양한 응용 프로그램에서 사용됩니다.

{
    const obj = {
        a: 100,
        b: 200,
        c: "javascript"
    }

    console.log(obj.a);
    console.log(obj.b);
    console.log(obj.c);

    console.log(obj["a"]);  
    console.log(obj["b"]);
    console.log(obj["c"]);

    //가끔 쓰는 방법
}
결과 확인하기
100
200
javascript

100
200
javascript

14.객체 : 데이터 불러오기 : Obhect.key()


Object.keys() 메서드는 객체의 모든 열거 가능한 속성의 이름을 배열로 반환합니다.
이를 통해 객체의 속성에 쉽게 접근하고 조작할 수 있습니다.
반환된 배열의 순서는 객체 속성의 정의된 순서와 동일합니다.
이 메서드는 객체의 속성 이름을 배열로 추출하여 유용한 정보를 제공합니다.

{            
    // 객체를 선언하고 초기화합니다.
    const obj = {
        a: 100,         // 'a' 속성을 100으로 설정합니다.
        b: 200,         // 'b' 속성을 200으로 설정합니다.
        c: "javascript" // 'c' 속성을 문자열 "javascript"로 설정합니다.
    }

    // Object.values() 함수를 사용하여 객체의 속성 값들을 배열로 반환하고 이를 출력합니다.
    console.log(Object.values(obj)); // obj 객체의 속성 값들을 배열로 반환하여 출력합니다.   
}
결과 확인하기
[a, b, c]
a
b
c

15.객체 : 데이터 불러오기 : Obhect.values()


Object.values() 메서드는 객체의 열거 가능한 속성 값들을 배열로 반환합니다.
이를 통해 객체의 값에 쉽게 접근하고 조작할 수 있습니다.
반환된 배열의 순서는 객체 속성의 정의된 순서와 일치합니다.
이 메서드는 객체의 속성 값들을 배열로 추출하여 유용한 정보를 제공합니다.

{                  
    const obj = {
        a: 100,
        b: 200,
        c: "javascript"
    }
    console.log(Object.values(obj))               
}
결과 확인하기
[100, 200, javascript]

16.객체 : 데이터 불러오기 : Obhect.enteries()


Object.values() 메서드는 객체의 열거 가능한 속성 값들을 배열로 반환합니다.
이를 통해 객체의 값에 쉽게 접근하고 조작할 수 있습니다.
반환된 배열의 순서는 객체 속성의 정의된 순서와 일치합니다.
이 메서드는 객체의 속성 값들을 배열로 추출하여 유용한 정보를 제공합니다.

{                                
    // 객체를 선언하고 초기화합니다.
    const obj = {
        a: 100,         // 'a' 속성을 100으로 설정합니다.
        b: 200,         // 'b' 속성을 200으로 설정합니다.
        c: "javascript" // 'c' 속성을 문자열 "javascript"로 설정합니다.
    }

    // Object.entries() 함수를 사용하여 객체의 [키, 값] 쌍을 담은 배열을 반환하고 이를 출력합니다.
    console.log(Object.entries(obj)); // obj 객체의 [키, 값] 쌍을 담은 배열을 반환하여 출력합니다. 
}
결과 확인하기
[["a", 100], ["b", 200], ["c", "javascript"]]

17.객체 : 데이터 불러오기 : Object.assign()


Object.assign() 메서드는 자바스크립트에서 여러 객체를 합쳐서 하나의 새로운 객체를 만드는 기능을 합니다.
예를 들어, 여러 개의 속성과 값을 가진 객체를 가지고 있다면, 이 메서드를 사용하여 이들을 하나의 객체로 합칠 수 있습니다.
이렇게 합쳐진 새로운 객체는 각 원본 객체의 속성과 값을 가지고 있게 됩니다.
이때, Object.assign()을 사용하면 기존 객체들을 변경하지 않고 새로운 객체를 만들 수 있습니다.
이 메서드는 자주 사용되며, 객체를 다룰 때 유용한 기능 중 하나입니다.

{
    {
        const obj1 = {
            a: 100,
            b: 200,
        }
        const obj2 = {
            c: 300,
            d: 400,
        }

        // Object.assign() 메서드를 사용하여 두 객체를 병합하여 새로운 객체를 생성합니다.
        const obj3 = Object.assign(obj1, obj2);

        console.log(obj3);      // 새로 생성된 객체 obj3를 콘솔에 출력합니다.
    }       
}
결과 확인하기
{a: 100, b: 200, c: 300, d: 400}

18.객체 : 데이터 불러오기 : hasOwnproperty()


hasOwnProperty() 메서드는 객체의 속성 중에서 직접 소유한 속성인지를 판별합니다.
이 메서드를 사용하면 상속된 속성을 확인하지 않고, 객체 자체에서 정의된 속성만을 확인할 수 있습니다.
객체의 속성을 반복하면서 해당 속성이 객체 자체에서 정의되었는지를 확인하는 경우에 유용하게 사용됩니다.
만약 속성이 객체의 프로토타입 체인을 통해 상속된 것이라면 hasOwnProperty()는 false를 반환합니다.
따라서 이 메서드를 사용하여 속성을 확인할 때는 주의가 필요합니다.

{
    const obj = {
        a: 100,
        b: 200,
        c: "javascript"
    }
   
    console.log(obj.hasOwnProperty("a"));       // 내가 원하는 데이터가 있는지 확인 
    console.log(obj.hasOwnProperty("b"));       // true     
    console.log(obj.hasOwnProperty("c"));       //true
    console.log(obj.hasOwnProperty("d"));       // false / d는 없기 때문에 결과값이 나오지 않는다.

    // in 연산자
    console.log("a" in obj);    //true (최신 방식)
    console.log("b" in obj);    //true
    console.log("c" in obj);    //true
    console.log("d" in obj);    //false
}
결과 확인하기
true
true
true
false

true
true
true
false

19.객체 : 데이터 불러오기 : for in()


for...in 루프는 JavaScript에서 객체의 속성을 반복하는 반복문입니다.
이를 사용하면 객체의 모든 열거 가능한 속성에 대해 반복할 수 있으며, 각 반복에서는 속성의 이름(키)이 변수에 할당되어 해당 속성에 접근할 수 있습니다.
그러나 주의해야 할 점은 for...in 루프는 상속된 속성도 반복하기 때문에, 객체 자체에 정의된 속성만을 반복하려면 추가적인 확인이 필요합니다.

{
    const obj = {
        a: 100,
        b: 200,
        c: "javascript"
    }
    for (let el in obj) {
        console.log(el + " : " + obj[el]);
    }
}
결과 확인하기
a : 100
b : 200
c : javascript

20.객체 : 데이터 불러오기 : 객체 구조 분해 할당


객체 구조 분해 할당은 JavaScript에서 객체의 속성들을 추출하여 변수에 할당하는 기능입니다.
중괄호 {}를 사용하여 추출할 속성을 지정하고, 해당 속성들의 값을 변수에 저장합니다.
기본값을 지정할 수 있으며, 변수명을 변경하여 할당할 수도 있습니다.
중첩된 객체의 속성도 추출할 수 있습니다. 이를 통해 코드를 간결하게 작성하고 가독성을 높일 수 있습니다.

{
        // 객체 분해 할당: obj 객체에서 a, b, c 속성을 추출하여 변수에 할당
        const obj = {
            a: 100,
            b: 200,
            c: "javascript"
        };

        const { a, b, c } = obj; // obj 객체의 속성을 변수에 분해하여 할당합니다.

        console.log(a); // 변수 a의 값을 출력합니다. (결과: 100)
        console.log(b); // 변수 b의 값을 출력합니다. (결과: 200)
        console.log(c); // 변수 c의 값을 출력합니다. (결과: "javascript")
    }

    {
        // 기본 값 할당
        // obj 객체에 c 속성이 없으므로 c의 기본값으로 "javascript"을 할당하여 분해할당
        const obj = {
            a: 100,
            b: 200
        }
        
        const { a, b, c = "javascript" } = obj; // obj 객체의 속성을 변수에 분해하여 할당하되, c 속성이 없으면 "javascript"를 기본값으로 할당합니다.

        console.log(a); // 변수 a의 값을 출력합니다. (결과: 100)
        console.log(b); // 변수 b의 값을 출력합니다. (결과: 200)
        console.log(c); // 변수 c의 값을 출력합니다. (결과: "javascript")
    }

    {
        // 새로운 이름으로 변경
        const obj = {
            a: 100,
            b: 200,
            c: "javascript"
        }
        // 속성 a, b, c를 x, y, z로 변수명 변경하여 분해할당
        const { a: x, b: y, c: z } = obj; // obj 객체의 속성을 변수에 분해하여 할당하되, 변수명을 변경하여 할당합니다.

        console.log(x); // 변수 x의 값을 출력합니다. (결과: 100)
        console.log(y); // 변수 y의 값을 출력합니다. (결과: 200)
        console.log(z); // 변수 z의 값을 출력합니다. (결과: "javascript")
    }

    {
        const obj = {
            a: 100,
            b: { c: 200, d: "javascript" },
        }
        // 객체 obj에서 a, b의 c, d 속성 값을 분해할당하여 변수에 할당
        const { a, b: { c, d } } = obj; // obj 객체의 속성을 변수에 분해하여 할당하되, 중첩된 객체의 속성도 분해하여 할당합니다.

        console.log(a); // 변수 a의 값을 출력합니다. (결과: 100)
        console.log(c); // 변수 c의 값을 출력합니다. (결과: 200)
        console.log(d); // 변수 d의 값을 출력합니다. (결과: "javascript")
}
결과 확인하기
100
200
javascript

100
200
javascript

100
200
javascript

100
200
javascript

21.객체 : 데이터 불러오기 : 객체 펼침 연산자


객체 펼침 연산자는 JavaScript에서 배열과 객체를 다룰 때 사용되며, 세 개의 점 ...으로 표현됩니다.
이 연산자를 사용하면 배열을 확장하여 요소를 개별적으로 전개하거나, 객체를 확장하여 속성을 개별적으로 전개할 수 있습니다.
예를 들어, 여러 배열을 병합하거나, 객체에 새로운 속성을 추가하는 등의 작업에서 유용하게 사용됩니다.
이를 통해 코드를 간결하게 작성할 수 있고, 가독성을 높일 수 있습니다.

{
    const obj1 = { a: 100, b: 200 }
    const obj2 = { c: 300, d: 400 }
    const merge1 = { ...obj1, ...obj2 }
    const merge2 = { ...obj1, x: "javascript", ...obj2, y: "jquery" }
    
    console.log(obj1)
    console.log(obj2)
    console.log(merge1)
    console.log(merge2)
}
결과 확인하기
a: 100
b: 200

a: 100
b: 200
c: 300
d: 400

a: 100
b: 200
c: 300
d: 400
x: "javascript" y: "jquery"

22. 서버 데이터 불러오기 : XMLHttpRequest


XMLHttpRequest는 JavaScript에서 제공하는 객체로, 웹 서버와 상호작용하여 데이터를 비동기적으로 가져오는데 사용됩니다.
요청을 준비하고 보내고, 요청 상태를 모니터링하여 응답을 처리합니다.
이를 통해 웹 애플리케이션에서 동적인 데이터를 효과적으로 처리할 수 있습니다.

{
    // XMLHttpRequest 객체 생성
    var xhr = new XMLHttpRequest();
    
    // GET 요청 설정: 원격 서버에 대한 GET 요청을 설정합니다.
    xhr.open("GET", "https://webstoryboy.github.io/webs2024/json/gineungsaJC2011_05.json", true);
    
    // onreadystatechange 이벤트 핸들러 설정: readyState가 변경될 때마다 이벤트 핸들러가 호출됩니다.
    xhr.onreadystatechange = function () {
        // readyState가 4이고, status가 200인 경우: 요청이 완료되고 성공적으로 데이터를 받아온 상태입니다.
        if (xhr.readyState === 4 && xhr.status === 200) {
            // 받아온 데이터를 처리합니다.
            var responseData = xhr.responseText; // 응답 데이터를 변수에 저장합니다.
            var jsonData = JSON.parse(responseData); // JSON 형식의 문자열을 JavaScript 객체로 변환합니다.
    
            console.log(jsonData); // 변환된 데이터를 콘솔에 출력합니다.
        } 
        // readyState가 4이지만 status가 200이 아닌 경우: 요청은 완료되었지만 실패한 상태입니다.
        else if (xhr.readyState === 4) {
            console.error("데이터 불러오기 오류: " + xhr.status); // 오류 메시지를 콘솔에 출력합니다.
        }
    };
    
    // send() 메서드 호출: 요청을 서버로 보냅니다.
    xhr.send();
}
결과 확인하기
[{…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}]


이 코드는 두 개의 객체(obj1과 obj2)를 펼침 연산자(...)를 사용하여 합칩니다.
이렇게 합쳐진 새로운 객체들(merge1과 merge2)을 생성하여 콘솔에 출력합니다.
펼침 연산자를 사용하여 객체를 합칠 때, 중복된 속성명이 있다면 뒤에 위치한 객체의 속성값이 최종적으로 남게 됩니다.

23. 서버 데이터 불러오기 : fetch API


요청 생성:

fetch() 함수를 사용하여 네트워크 요청을 생성합니다. 이때 요청할 URL을 인자로 전달합니다.

옵션 설정:

fetch() 함수의 두 번째 인자로 옵션 객체를 전달하여 요청을 설정할 수 있습니다. 이 옵션 객체에는 메서드(GET, POST 등), 헤더, 요청 본문 등을 지정할 수 있습니다.

요청 보내기:

설정된 요청을 서버에 보냅니다. 이때 fetch() 함수는 Promise를 반환하며, 이를 통해 비동기적으로 응답을 처리할 수 있습니다.

응답 처리:

fetch() 함수가 반환한 Promise를 사용하여 응답을 처리합니다. 이때 then() 메서드를 사용하여 응답 객체를 받고, 응답 객체의 메서드를 사용하여 응답 데이터를 처리합니다.

에러 처리: 요청이 실패하거나 응답이 에러 상태 코드를 반환하는 경우, catch() 메서드를 사용하여 에러를 처리할 수 있습니다.

Fetch API를 사용하면 간단하고 강력한 네트워크 요청을 생성하고 처리할 수 있으며, Promise 기반의 비동기 코드를 작성할 수 있어서 코드의 가독성과 유지보수성을 높일 수 있습니다.

{
    // fetch 함수를 사용하여 네트워크 요청을 생성합니다. 이때 인자로는 가져올 데이터의 URL을 전달합니다.
    fetch("https://webstoryboy.github.io/webs2024/json/gineungsaJC2011_05.json")
    // then 메서드를 사용하여 Promise 체인을 생성합니다. 응답(response)을 매개변수로 받는 함수를 전달합니다.
    .then(response => {
        // 응답 데이터를 JSON 형식으로 변환하여 반환합니다.
        return response.json();
    })
    // then 메서드를 사용하여 Promise 체인을 이어갑니다. 변환된 데이터(data)를 매개변수로 받는 함수를 전달합니다.
    .then(data => {
        console.log(data);
    })
    // catch 메서드를 사용하여 Promise 체인 중에 발생한 에러를 처리합니다. 에러(error)를 매개변수로 받는 함수를 전달합니다.
    .catch(error => {
        // 에러 메시지를 콘솔에 출력합니다.
        console.error("데이터 불러오기 오류:", error);
    })
}
결과 확인하기
[{…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}, {…}]