1.  글자 조작하기

속성 이름 설명
문서 객체.textContent 입력된 문자열을 그대로 넣음
문서 객체.innerHTML 인력된 문자열을 HTML 형식으로 넣음

 

<head>
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const a = document.getElementById('a');
            const b = document.querySelector('#b'); // 아이디 선택자 사용.

            a.textContent = '<h1>textContent 속성</h1>';
            b.innerHTML = '<h1>innerHTML 속성</h1>';
        })
    </script>
</head>
<body>
    <div id="a"></div>
    <div id="b"></div>
</body>


2.  스타일 조작하기

 

👩🏻‍💻  자바스크립트의 style 속성들의 이름이 CSS에서 사용할 때와 차이가 없음
👩🏻‍💻  자바스크립트에서는 -가 연산자이고, 식별자에 사용할 수 없어서 두 단어의 조합은 캐멀 케이스로 표현

CSS 속성 이름 자바스크립트 style 속성 이름
background-color backgroundColor
text-align textAlign
font-size fontSize

 

💡  스타일을 조정하는 방법
       h1.style.backgroundColor      ▶️ 이 형태를 가장 많이 사용
        h1.style['backgroundColor']
        h1.style['background-color'

 

<head>
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const divs = document.querySelectorAll('body > div');

            divs.forEach((div, index) => { // div 개수 만큼 반복 출력.
                console.log(div, index);
                const val = index * 10; // index는 0부터 24까지 반복.
                div.style.height = `10px`; // 크기를 지정할 때는 반드시 단위를 붙여줘야 함.
                div.style.backgroundColor = `rgba(${val}, ${val}, ${val})`;
            })
        });
    </script>
</head>
<body>
    <!-- div 태그 25개 -->
    <div></div><div></div><div></div><div></div><div></div>
    <div></div><div></div><div></div><div></div><div></div>
    <div></div><div></div><div></div><div></div><div></div>
    <div></div><div></div><div></div><div></div><div></div>
    <div></div><div></div><div></div><div></div><div></div>
</body>

 


3.  속성 조작하기

👩🏻‍💻  문서 객체의 속성을 조작할 때는 다음과 같은 메소드를 사용

메소드 이름 설명
문서 객체.setAttribute(속성 이름, 값) 특정 속성에 값을 지정
문서 객체.getAttribute(속성 이름) 특정 속성을 추출

 

<head>    
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const rects = document.querySelectorAll('.rect'); // 클래스 선택자 이용.

           // for (let i = 0; i < rects.length; i++) {
           //     const width = (i + 1) * 100; // 100, 200, 300, 400의 너비를 가짐.
           //     const src = `http://placebear.com/${width}/250`;
           //     rects[i].setAttribute('src', src); // src 속성에 값을 지정.
           // }

           // foreach() 메서드로 동일한 작업
           rects.forEach((item, index) => {
               const width = (index + 1) * 100;
               const src = `http://placebear.com/${width}/250`;
               item.setAttribute('src', src); // src 속성에 값을 지정.
           })

        })
    </script>
</head>
<body>
    <img class="rect" alt="" src="">
    <img class="rect" alt="" src="">
    <img class="rect" alt="" src="">
    <img class="rect" alt="" src="">
</body>


예제
<head>
    <script>
        /*
        버튼을 클릭하면 버튼에 있는 색상으로 과일 목록이 글자색이 변하도록
         */
        document.addEventListener('DOMContentLoaded', () => {
            const btns = document.querySelectorAll('div button');
            const fruits = document.querySelectorAll('ul li');
            const colors = ['red', 'orange', 'yellow'];

            btns.forEach((item, index) => {
                item.addEventListener('click', () => {
                    fruits.forEach((item) => {
                        item.style.color = colors[index];
                    })
                })
            })

        })
    </script>
</head>
<body>
    <ul>
        <li id="apple">Apple</li>
        <li id="banana">Banana</li>
        <li id="orange">Orange</li>
    </ul>
    <div>
        <button>red</button>
        <button>orange</button>
        <button>yellow</button>
    </div>
</body>

 


4.  문서 객체 생성하기

document.createElement(문서 객체 이름)
부모 객체.appendChild(자식 객체)

    

📌  createElement()
    

    -  body 태그 내부에 있는 특정 문서 객체를 읽어들이고 조작하는 것도 가능하나 문서 객체를 생성하는 것도 가능
    -  문서 객체를 생성하고 싶을 때는 document.createElement() 메소드를 사용

📌  appendChild()


   -  문서 객체를 만든 후에는 '문서 객체를 추가'해야 함
   -  appendChild() 메소드를 활용하면 부모 객체 아래에 자식 객체를 추가할 수 있음
    

<script>
    // createElement() 메소드로 h1 태그를 생성하고, appendChild()를 사용하여 객체를 추가.
    document.addEventListener('DOMContentLoaded', () => {
        // 문서 객체 생성하기
        const header = document.createElement('h1');

        // 생성한 태그 조작하기
        header.textContent = '문서 객체 동적으로 생성하기';
        header.setAttribute('data-custom', '사용자 정의 속성');
        header.style.color = 'white';
        header.style.backgroundColor = 'black';
        console.log(header);

        // h1 태그를 body 태그 아래에 추가하기
        document.body.appendChild(header);
    })
</script>

 


5.  문서 객체 이동하기

👩🏻‍💻  appendChild() 메소드를 사용하면 문서 객체를 이동할 수도 있음
        ▶️  문서 객체를 다른 문서 객체에 추가하면 문서 객체가 이동

<head>
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            // 문서 객체 읽어들이고 생성하기
            const divA = document.querySelector('#first'); // id 속성이 first인 태그를 반환
            const divB = document.getElementById('second'); // id 속성이 second인 태그를 반환

            const h1 = document.createElement('h1'); // h1 태그를 생성
            h1.textContent = '이동하는 h1 태그';

            // 서로 번갈아가면서 실행하는 함수를 구현
            const toFirst = () => {
                divA.appendChild(h1); // h1을 divA에 추가
                setTimeout(toSecond, 1000); // 1초 후에 toSecond() 함수를 실행
            }
            const toSecond = () => {
                divB.appendChild(h1); // h1을 divB에 추가
                setTimeout(toFirst, 1000);
            }
            toFirst();
        });
    </script>
</head>
<body>
    <div id="first">
        <h1>첫 번째 div 태그 내부</h1>
    </div>
    <hr>
    <div id="second">
        <h1>두 번째 div 태그 내부</h1>
    </div>

</body>

 


6.  문서 객체 제거하기

👩🏻‍💻  문서 객체를 제거할 때는 removeChild() 메소드를 사용

부모 객체.removeChild(자식 객체);

 

👩🏻‍💻  appendChild() 메소드 등으로 부모 객체와 이미 연결이 완료된 문서 객체의 경우 parentNode 속성으로
      부모 객체에 접근할 수 있으므로, 일반적으로 어떤 문서 객체를 제거할 때는 다음과 같은 형태의 코드 사용

 문서 객체.parentNode.removeChild(문서 객체);

 

<head>
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            setTimeout(() => {
                const h1 = document.querySelector('h1');
                h1.parentNode.removeChild(h1);
            }, 3000);
        })
    </script>
</head>
<body>
   <hr>
   <h1>제거 대상 문서 객체</h1>
   <hr>
</body>


예제

 

<head>
    <style>
        * {
            margin: 0;
            padding: 0;
            list-style: none;
        }
    </style>
    <script>
        /*
        1. 버튼을 클릭하면 무지개색 li가 추가
        2. 같은 색깔의 li는 2개가 될 수 없음
         */
        document.addEventListener('DOMContentLoaded', () => {
            const btn = document.querySelector('button');
            const ulTag = document.querySelector('ul');
            const colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet'];

            let cnt = 0;
            btn.addEventListener('click', function () {
                const liTag = document.createElement('li');

                liTag.textContent = colors[cnt % colors.length];
                liTag.style.backgroundColor = colors[cnt++ % colors.length];
                liTag.style.color = 'white';

                if (cnt > colors.length) {
                    const firstLi = document.querySelector('ul li:nth-child(1)');
                    firstLi.parentNode.removeChild(firstLi);
                }
                ulTag.appendChild(liTag);
            });
        });
    </script>
</head>
<body>
    <button>무지개색 추가</button>
    <ul>

    </ul>
</body>

 

 

 

 

[ 내용참고 : IT 학원 강의 및 책 '혼자 공부하는 자바스크립트' ]


1.  재귀 함수

🐰  함수 정의문 내에서 작성한 코드로 함수를 다시 호출하는 것

<script>
    let num = 0;
    function testFnc() {
        // 재귀 함수 호출을 적용하여 1부터 10까지의 값을 출력
        num++;
        document.write(num, '<br>');

        if(num === 10) return; // num 값이 10이면 종료

        console.log(`${num} 번째 호출`); // 10번째는 출력 안됨
        testFnc(); // 재귀 함수 호출
    }
    testFnc();
</script>


2.  콜백 함수  callback function

🐰  매개 변수로 전달하는 함수. 자바 스크립트는 함수도 하나의 자료형이므로 매개변수로 전달 할 수 있음

🐰  매개변수를 통해 함수를 받고, 그 함수를 통해 결과값을 호출함

<script>
    function callThreeTimes (callback) { // 함수를 선언
        for (let i = 0; i < 3; i++) {
            callback(i);
        }
    }

    function print(i) {
        console.log(`${i}번째 함수 호출`);
    }

    // 함수를 호출.
    callThreeTimes(print); // 매개변수로 함수를 전달. 함수를 매개변수로 사용할 경우 ()는 제외
    /* 0번째 함수 호출
    1번째 함수 호출
    2번째 함수 호출
     */
</script>

 


 콜백함수와 익명함수 
<script>
    function callThreeTimes (callback) { // 함수를 선언
        for (let i = 0; i < 3; i++) {
            callback(i);
        }
    }

    // 함수를 호출. 다른 언어에서는 낯선 방법이나 자바 스크립트나 코틀린 같은 이벤트 기반을 프로그래밍에서는 자주 사용.
    callThreeTimes(function (i) {
        console.log(`${i}번째 함수 호출`);
    });
</script>

 


콜백함수를 활용하는 함수 : forEach() 메서드


    🥕  배열이 갖고 있는 함수(메서드)로써 단순하게 배열 내부 요소를 사용해서 콜백함수를 호출

/* 콜백함수 기본형 */
function (value, index, array) { } //  매개 변수가 다 필요하지 않음.
<script>
    const numbers = [273, 52, 103, 32, 57];

    numbers.forEach(function (value, index, array) {
        // 매개변수로 value, index, array를 갖는 콜백함수를 사용
        console.log(`${index}번째 요소 : ${value}`);
    });

    // 함수 선언한 후에 매개 변수로 넘겨도 됨
    const call = function (value, index, array) {
        // 매개변수로 value, index, array를 갖는 콜백함수를 사용
        console.log(`${index}번째 요소 : ${value}`);
    }
    numbers.forEach(call);

    numbers.forEach(function (v, i) { // 매개변수로 v, i만 사용
        console.log(`${i}번째 요소 : ${v}`);
    })

    numbers.forEach(function(item) { // 매개변수로 v만 사용
        console.log(`${item}`)
    })
</script>

 


콜백함수를 활용하는 함수 : map() 메서드

 

   🥕  콜백함수에서 리턴한 값들을 기반으로 새로운 배열을 만들고 리턴

<script>
    // 배열을 선언
    let numbers = [273, 52, 103, 32, 57];

    // 배열의 모든 값을 제곱
    let numbers2 = numbers.map(function (value, index, array) {
        return value * value;
    });
    console.log(numbers2); // (5) [74529, 2704, 10609, 1024, 3249]

    // 출력
    numbers2.forEach(console.log); // value, index, array 순서대로 출력
    /*
    74529 0 (5) [74529, 2704, 10609, 1024, 3249]
    2704 1 (5) [74529, 2704, 10609, 1024, 3249]
    10609 2 (5) [74529, 2704, 10609, 1024, 3249]
    1024 3 (5) [74529, 2704, 10609, 1024, 3249]
    3249 4 (5) [74529, 2704, 10609, 1024, 3249]
     */

    // for문을 이용해서 제곱 배열 생성
    let numbers3 = [];
    for (const item of numbers) {
        numbers3.push(item * item);
    }
    console.log(numbers3); // (5) [74529, 2704, 10609, 1024, 3249]
</script>

 


콜백함수를 활용하는 함수: filter()


    🥕  콜백함수에서 리턴하는 값이 true인 것들만 모아서 새로운 배열을 만듦
           ➡️  콜백함수의 리턴 타입이 불 형 이어야 함

<script>
    const numbers = [11, 12, 13, 14, 15, 16];
    
    // 짝수만 추출
    const evenNumbers = numbers.filter(function (value) {
        return value % 2 === 0;
    });

    // 인덱스가 짝수만 추출
    const evenIndexs = numbers.filter(function (value, index) {
       return index % 2 === 0;
    });

    console.log(`원래 배열: ${numbers}`); // 원래 배열: 11,12,13,14,15,16
    console.log(`값이 짝수만 추출: ${evenNumbers}`); // 값이 짝수만 추출: 12,14,16
    console.log(`인덱스가 짝수만 추출: ${evenIndexs}`);  // 인덱스가 짝수만 추출: 11,13,15

    // 1의 자리가 3의 배수인 경우만 추출
    const evenNumbers2 = numbers.filter(function (value) {
        return (value % 10) % 3 === 0;
    });

    console.log(`1의 자리가 3의 배수: ${evenNumbers2}`); // 1의 자리가 3의 배수: 13,16
</script>

 


3.  화살표 함수  Arrow function


🐰  ES6에 추가된 내용으로 '=>'를 이용하여 함수를 간결하게 표현할 때 사용

    1) function 키워드를 생략
    2) 부등호 '='과 '>'를 합쳐서 코딩
    3) 항상 익명함수 형식으로 표현
    4) 단일 명령문일 경우 함수의 중괄호 {}와 return을 생략

 

 

Arrow function expressions - JavaScript | MDN

An arrow function expression is a compact alternative to a traditional function expression, with some semantic differences and deliberate limitations in usage:

developer.mozilla.org

<script>
    const doAddition1 = function (s1, s2) {
        return (s1 + s2) / 2;
    }
    console.log(doAddition1(2, 5)); // 3.5

    const doAddition2 = (s1, s2) => {
        return (s1 + s2) / 2;
    }
    console.log(doAddition2(2, 5)); // 3.5

    const doAddition3 = (s1, s2) => (s1 + s2) / 2;
    console.log(doAddition3(2, 5)); // 3.5
</script>


🐰  map(), filter() 함수처럼 단순한 형태의 콜백 함수를 쉽게 입력
🐰  function 키워드 대신 화살표(=>)를 사용

/* 기본형 */ 
(매개변수) => { }

 

💡  메소드 체이닝 : 메소드가 리턴하는 값을 기반으로 해서 메서드를 줄줄이 사용하는 것
<script>
    // 배열 선언
    let numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

    // numbers에서 2의 배수만 추출한 후, 제곱을 한 후에 로그에 출력.

    // 배열의 메소드를 연속적으로 사용. 메소드 체이닝.
    numbers.filter((value) => value % 2 === 0) // 2의 배수만 추출 / [0, 2, 4, 6, 8]
        .map((value) => value * value) // 제곱 추출 / [0 , 4, 6, 16, 36, 64]
        .forEach((value) => console.log(value)); // [0, 4, 16, 36, 64]
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 ]

 


1.  나머지 매개변수  rest parameter

👩🏻‍💻  가변 매개변수 함수 : 호출할 때 매개변수의 갯수가 고정적이지 않은 함수
👩🏻‍💻  자바스크립트에서는 이러한 함수를 구현할 때 '나머지 매개 변수'를 사용
👩🏻‍💻  함수의 매개변수 앞에 마침표 3개(...)를 입력하면 매개변수가 배열로 들어옴

/* 기본형 */
function 함수명 (...items) {}
<script>
    function sample(...items) {
        console.log(items);
    }

    sample(1, 2); // [1, 2]
    sample(1, 2, 3); // [1, 2, 3]
    sample(1, 2, 3, 4); // [1, 2, 3, 4]

    function sample2nd(items) {
        console.log(items);
    }
    sample2nd([1,2]); // [1,2]
    sample2nd([1,2, 3]); // [1,2,3]
    sample2nd([1,2, 3, 4]); // [1,2,3,4]
</script>

 


  (1)  나머지 매개 변수와 일반 매개변수 조합하기

/* 기본형 */
function 함수명 (매개변수, 매개변수, ...나머지 매개변수) {}
<script>
    function sample(a, b, ...c) {
        console.log(a, b, c);
    }

    // 매개변수 a, b가 먼저 들어가고, 남은 것은 모두 c에 배열 형태로 들어감
    sample(1, 2); // 1 2 []
    sample(1, 2, 3); // 1 2 [3]
    sample(1, 2, 3, 4); // 1 2 [3, 4]
</script>

 

 

매개변수의 자료형에 따라 다르게 작동하는 함수 만들기

  <조건>
    1)  min(배열) : 매개 변수에 배열을 넣으면 배열 내부에서 최솟값을 찾아주는 함수
    2) min(숫자, 숫자) : 매개변수에 숫자를 넣으면 숫자들 중 최솟값을 찾아주는 함수
<script>
    function min(first, ...rests) {
        /*
        min(배열) 방식의 호출인 경우 first에는 배열이, ...rest에는 아무 값도 넘어오지 않음
        min(숫자, 숫자) 방식의 호출인 경우 first에는 첫번째 인수가, ...rests에는 두번째 인수부터 나머지가 배열로 들어옴.
         */

        // 변수 선언하기
        let min; // 최솟값을 저장할 공간
        let items; // 배열

        // 매개변수의 자료형에 따라 조건 분리하기
        if (Array.isArray(first)) { // first에 있는 변수가 배열인지 확인. 배열이면 나머지 매개변수가 없음
            min = first[0];
            items = first; // [52, 273, 32, 103, 275, 24, 57]
        } else if (typeof(first) === 'number') {
            min = first; // 52
            items = rests; // [273, 32, 103, 275, 24, 57]
        }


        // 최솟값 구하는 공식
        for (const item of items) {
            if (min > item) {
                min = item;
            }
        }
        return min;
    }

    console.log(`min(배열): ${min(52, 273, 32, 103, 275, 24, 57)}`); // 24
    console.log(`min(숫자, ...): ${min(52, 273, 32, 103, 275, 24, 57)}`); // 24
</script>

 


2.  전개 연산자  spread operator

👩🏻‍💻  배열을 전개해서 함수의 매개 변수로 전달  ▶️  배열 안의 요소 하나 하나 출력함  
👩🏻‍💻  전개 연산자는 일반적으로 함수 호출시 배열 앞에 마침표 3개(...)를 붙이는 형태로 사용

/* 기본형: 함수 호출시 */
함수이름(...배열)

 

 

(1)  기본적인 전개 연산자 사용법

인수로 전달
<script>
    'use strict';

    const array = [1, 2, 3, 4];

    function sample1st(a, b, c, d) {
        console.log('sample1st() 실행');
        console.log(a, b, c, d);
    }
    // 전개 연산자를 이용해서 배열을 인수로 전달.
    // 배열은 개개로 전개해서 전달한 것과 결과가 같음
    sample1st(...array);
    sample1st(array[0], array[1], array[2], array[3]);
</script>


함수의 리턴 값 배열로 하고 결과 값을 전개 할당
<script>
    function sample2nd() {
        console.log('sample2nd() 실행');
        let array = [1, 2, 3, 4];
        return array;
    }

    console.log(sample2nd()); // [1, 2, 3, 4]. 결과값은 배열
    // sample2nd() 호출 결과를 각각 변수에 저장하려면?
    //let arrayNew = sample2nd();
    //let a = arrayNew[0];
    //let b = arrayNew[1];
    //let c = arrayNew[2];
    //let d = arrayNew[3];
    let [a, b, c, d] = sample2nd(); // 배열을 각 변수에 할당
    console.log(a); // 1
</script>

 


(2)  나머지 매개 변수와 함께 사용하는 경우

<script>
    const array = [1, 2, 3, 4];
    
    function sample3rd(...items) { // 단순하게 매개변수를 모두 출력하는 함수
        document.write('<br>sample3rd() 실행<br>');
        document.write(items, '<br>');
        for (const item of items) {
            document.write(item, '<br>');
        }
    }

    console.log('# 전개 연산자를 사용하지 않은 경우');
    sample3rd(array); // 배열의 요소로 배열을 가진 매개변수가 됨. [[1,2,3,4]]
    console.log('# 전개 연산자를 사용한 경우');
    sample3rd(...array); // 숫자 하나하나가 전개되어서 들어옴. 배열의 요소가 4개인 매개변수가 됨.
    // [1,2,3,4]
</script>


(3)  일반 매개 변수에 전개 연산자 사용

<script>
    const array = [1, 2, 3, 4];

    function sample4th(items) {
        document.write('<br>sample4th() 실행<br>');
        document.write(items, '<br>');
        for (const item of items) {
            document.write(item, '<br>');
        }
    }
    // 전개 되어서 전달이 됨. sample4th(1, 2, 3, 4)과 동일한 결과.
    // items에 1만 전달이 되고, 배열이 아니기 때문에 for문으로 순회가 안됨
    sample4th(array);
    sample4th(...array); 
    // 1. Uncaught TypeError: items is not iterable at sample4th()
    sample4th(array[0], array[1], array[2], array[3]);
    // 1. Uncaught TypeError: items is not iterable at sample4th()
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 ]

 


1.  윤년 확인하기

📌  윤년을 확인하는 함수
    윤년의 조건 :
    1)  4로 나누어 떨어지는 해는 윤년.
    2) 하지만 100으로 나누어 떨어지는 해는 윤년이 아님
    3) 하지만 400으로 나누어 떨어지는 해는 윤년.

<script>
    // 윤년을 확인하는 함수를 정의 - 정수 연도를 입력받아서 윤년의 여부를 불린형으로 반환.
    const isLeapYear = function (year) { // 반환값이 bool형인 함수의 이름은 is로 시작하게 만듦.
        const isLeapYear = (year % 4 === 0) && (year % 100 !== 0) || (year % 400 === 0);
        return isLeapYear;
    }

    console.log(`2020년은 윤년일까? === ${isLeapYear(2020)}`); // true. 4의 배수
    // true && true || false
    console.log(`2010년은 윤년일까? === ${isLeapYear(2010)}`); // false.
    // false && true || false
    console.log(`2000년은 윤년일까? === ${isLeapYear(2000)}`); // true.
    // true && false || true
    console.log(`1900년은 윤년일까? === ${isLeapYear(1900)}`); // false.
    // true && false || false
</script>

 


2.  a부터 b까지 더하는 함수

📌  a부터 b까지 더하는 함수
    1. 익명 함수로 작업. 합계를 저장할 변수는 함수 안에 지정할 것
    2. 1 + 2 + ... + 99 + 100 이니 for문 사용
    3. 매개 변수를 2개, 반환값이 있어야 함
<script>
    const sumAll = function (start, end) {
        let sum = 0;
        for ( let i = start; i <= end; i++) {
            sum += i;
        }
        return sum;
    }

    console.log(`1부터 100까지의 합: ${sumAll(1, 100)}`); // 5050
    console.log(`1부터 500까지의 합: ${sumAll(1, 500)}`); // 125250
</script>

 


3.  최솟값 구하기

<script>
    const min = function(array) {
        let minimum = array[0];
        for (let i = 1; i < array.length; i++) {
            if (minimum > array[i]) {
                minimum = array[i];
            }
        }
        return minimum;
    }

    const testArray = [52, 273, 32, 103, 275, 24, 57];
    console.log(`${testArray}중에서`);
    console.log(`최솟값 = ${min(testArray)}`); // 24

</script>

 


4. 배경색 바꾸기

📌  배열에 저장된 값으로 배경색 바꾸기
       ➡️  배열의 마지막이면 처음으로 가도록 수정
<head>
    <script>
        let i = 0;
        let changeColor = function() {
            const color = ['white', 'yellow', 'aqua', 'purple']; // 배열 선언

            const bodyTag = document.querySelector('body'); // body 태그를 불러옴.
            bodyTag.style.backgroundColor = color[++i % color.length]; 
            // body 태그의 background-color 변경
        }
    </script>
</head>
<body>
    <!-- 버튼을 클릭하면 changeColor() 함수 호출 -->
    <button onclick="changeColor();">배경색 바꾸기</button>
</body>

 

 

 

 

[ 내용 참고 : IT 학원 강의 ]

 


1. var 를 사용한 변수 특징

 

var를 이용한 변수 선언의 문제점 


    기존의 자바스크립트에서는 var를 이용해 변수를 선언
    그러나 var로 변수를 선언하는 것은 몇 가지 문제점이 있어서 모던 자바스크립트 개발에서는 거의 이용되지 않는다.
    문제점은 1) 변수를 덮어 쓸 수 있다는 점과 2) 다시 선언 (재선언) 할 수 있다는 점

<script>
    // var로 선언한 변수를 덮어 쓰거나 재선언하는 예.
    var val1 = 'var 변수';
    console.log(val1); // var 변수

    // var 변수는 덮어쓰기 가능
    val1 = 'var 변수 덮어 쓰기';
    console.log(val1); // var 변수 덮어 쓰기

    // var 변수는 재선언 가능
    var val1 = 'var 변수를 재선언';
    console.log(val1); // var 변수를 재선언
</script>

 

📌  덮어 쓰기 ▶️ 한 번 정의한 변수에 다른 값을 대입할 수 있음
📌  재선언  ▶️ 완전히 같은 변수명을 여러 위치에서 변수로 정의할 수 있음

✔️  변수 선언에 var만 사용하는 경우 프로젝트 규모가 커짐에 따라 의도치 않은 시점에 변수를 덮어 쓰거나 재선언하는 등의 문제가 발생

✔️  ES2015에서는 새로운 변수 선언 방법으로 const(덮어쓰는 것이 불가능한 변수)와 let(덮어쓰는 것이 가능한 변수)이 추가 


2.  let과 const

(1) let을 사용한 변수 특징


🐰  let은 재선언 ❌  덮어 쓰기 ⭕️

🐰  함수 {} 안에 선언할 시 블록({})을 벗어나면 사용할 수 없다.

<script>
  // let으로 변수 덮어 쓰기
  let val2 = 'let 변수';
  console.log(val2);

  val2 = 'let 변수 덮어 쓰기';
  console.log(val2);

  // 재선언 실행
  let val3 = 'let 변수';
  console.log(val3);

  // let은 재선언 불가능
  let val3 = 'let 변수 재선언'; // 에러
  // Uncaught SyntaxError: Identifier 'val3' has already been declared
  // '이미 선언되어 재선언 할 수 없다'는 메시지

  // 이렇게 let은 var를 이용했을 때 문제가 되었던 재선언을 개선한 변수 정의 방법.
  // 덮어 쓰기를 허가할 변수는 let을 이용해야 함.
  console.log(val3);
</script>

 


(2) const 를 사용한 변수 특징

 

🐰  const는 재선언, 덮어쓰기가 모두 불가능한 가장 엄격한 변수 선언 방법 < 상수 변수 constant variable >
🐰  const를 이용한 변수 선언은 덮어 쓰기를 사전에 감지해서 알려줌
🐰  let와 마찬가지로 재선언을 해도 에러가 발생

💡 변수 종류에 따라 const로 정의해도 변수값을 변경할 수 있는 경우가 있으므로 주의

<script>
    /* 다음은 const로 정의한 변수를 덮어 쓰려고 할 경우 */
    const val1 = 'const 변수';
    console.log(val1);

    // const 변수를 덮어 쓰기 불가능
    val1 = 'const 변수 덮어 쓰기';
    // Uncaught TypeError: Assignment to constant variable.
</script>

 

 


(3) const로 정의한 변수를 변경할 수 있는 예

 

🐰  문자열이나 수치 등 primitive type 이라 불리는 종류의 데이터는 const를 이용해 정의한 경우 덮어 쓸 수 없음
🐰  하지만 객체나 배열 등 object type 이라 불리는 데이터들은 const로 정의해도 도중에 값을 변경할 수 있음

 

🌻  pirmitive type
      논리값 Boolean : true / false
      수치 Number : 1, 2.5
      문자열 String
      undefined : 미정의
      null : 값 없음
      Symbol : 유일하면 바꿀 수 없는 값

🌻  object type
      객체
      배열
      함수 등 primitive type 이외의 것

 

<script>
    // const를 이용해 정의한 객체의 속성값을 변경, 추가 하는 예
    // 객체 정의
    const obj1 = {
        name: '길동',
        age: 24
    };
    console.log(obj1);

    // 속성값 변경
    obj1.name = 'tom';
    console.log(obj1);

    // 속성 추가
    obj1.address = 'daegu';
    console.log(obj1);
    // const로 정의해도 객체 내용은 자유롭게 변경할 수 있음
    // 즉, 객체를 정의할 때는 기본적으로 const를 이용.

    // 재할당은 에러가 남.
    //obj1 = {
    //    name: '길동',
    //    age: 24
    //}

    // const를 이용해 정의한 배열 값을 변경, 추가하는 예
    // 배열 정의
    const arr1 = ['dog', 'cat'];
    console.log(arr1);

    // 값 변경
    arr1[0] = 'bird';
    console.log(arr1);

    // 값 추가
    arr1.push('monkey');
    console.log(arr1);
    // 배열도 const를 이용해 정의했어도 값은 자유롭게 변경할 수 있음
    // 따라서 배열 역시 기본적으로 const를 이용해 정의

</script>

 

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

 


 

1.  변수  variable

👩🏻‍🚀  변수란 프로그램을 실행하는 동안 값이 여러 번 달라질 수 있는 데이터를 가리킴

👩🏻‍🚀  상수 constant 는 값을 한 번 지정하면 바뀌지 않는 데이터

 

1) 변수 선언 규칙

①  변수 이름은 일반적으로 라틴 문자(0-9, a-z, A-Z)와 밑줄 문자(_)를 사용
         - 띄어쓰기 허용 x, 숫자, 밑줄(_)은 첫번째 문자 x

②  영어 대소문자를 구별하며 예약어는 변수 이름으로 쓸 수 x
         - varfunctionletfor와 같은 단어

③  lower camel case 표기를 사용
④  변수 이름은 의미있게 작성 ( 이름만 보고도 대충 어떤 값인지 추측할 수 있어야 함 )

 

<script>
    var name = 10; // var : 변수 선언을 의미
    var str = 'javascript';
    var temp = true;
    // num, str, temp : 변수를 구분하는 이름(변수명)
    // 10, 'javascript', true : 변수에 저장 되는 데이터(값)
    document.write(num + '<br>' + str + '<br>' + temp + '<br><br>');

    // 여러 개의 변수를 선언할 경우 다음과 같은 방법으로 선언할 수 있다.
    var num, str, temp;
    num = 20;
    str = 'ECMAscript'
    temp = false;

    document.write(`${num}<br> ${str}<br> ${temp}<br><br>`);

    var num = 30, str = 'jquery', temp = true;
    document.write(num + '<br>' + str + '<br>' + temp + '<br><br>');

    // 변수는 새로운 데이터가 저장되면 기존 데이터는 사라진다.
    var num = 0;
    num = 10;
    document.write(`${num} <br>`); // 10

    num2 = 1
    document.write(nm2);
</script>

 


 

2.  자료형

👩🏻‍🚀  자료 data란 프로그래밍에서 프로그램이 처리할 수 있는 모든 것

👩🏻‍🚀  자료형 data type이란 컴퓨터가 처리할 수 있는 자료의 형태

👩🏻‍🚀  자바스크립트 자료형

       - 기본 자료형 : 숫자, 문자열, 논리형

       - 복합 자료형 : 배열, 객체

       - 특수 자료형 : undefined, null

종류 설명 예시
기본 자료형 숫자형 따옴표 없이 숫자로만 표기 var birthYear = 1995;
문자열 따옴표("" or '')로 묶어서 표기
숫자를 따옴표로 묶으면 문자로 인식
var greeting = 'Hello';
var birthYear = '1995';
논리형 참과 거짓이라는 2가지 값만 있는 유형
true, false 소문자로 표시
var isEmpty = true;
복합 자료형 배열 하나의 변수안에 여러 개의 값을 저장 var seasons = ['봄', '여름', '가을', '겨울']
객체 함수와 속성을 함께 포함 var date = new Date();
특수 자료형 undefined 자료형이 지정되지 않은 경우
  ex. 변수 선언만 하고 값을 할당하지 않은 변수
null 값이 유효하지 않은 경우

 



1) 기본 자료형 : 문자열 string


✏️  문자와 문자열을 구분하는 언어도 있으나 자바 스크립트는 문자열로 통일
✏️  문자열 자료형을 만드는 방법 : 작은 따옴표나 큰 따옴표로 감쌈

 

<script>
    console.log("안녕하세요");
    console.log('안녕하세요');

    //console.log("안녕하세요'); // 따옴표 시작과 끝은 같아야 함

    // 혼용하는 것도 가능
    console.log('this is "string"');
    console.log("this is 'string'");

    // 이스케이프 문자 사용 : 따옴표를 문자 그대로 사용하고 싶을 때
    console.log('this is \'string\'');
    console.log("this is \"string\"");

    /* 이스케이프 문자 사용 예
    \n : 줄바꿈
    \t : 탭문자
    \\ : 역슬래시(\) 자체
     */
    console.log("this is 'string' \nthis is 'string' ") // 줄 바꿈
    console.log("this is 'string' \tthis is 'string' ") // 탭 문자
</script>

콘솔 창 결과


 

💡  문자열 연산

문자열에 적용할 수 있는 처리 
  1. 문자열 연결 연산 : 문자열 + 문자열
  2. 문자 선택 연산 : 문자열[인덱스] -> 문자 하나
  3. 문자열 길이 : 문자열.length -> 문자 갯수
<script>
    console.log('안녕하세요.' + '자바 스크립트 입니다.');  // 안녕하세요.자바 스크립트 입니다.
    let greet = '안녕하세요.'; 
    console.log(greet + '자바 스크립트 입니다.'); // 안녕하세요.자바 스크립트 입니다.

    // 문자 선택 연산. 인덱스는 0부터 시작하는 정수로 이루어짐
    console.log('안녕하세요.'[0]); // 안
    console.log('안녕하세요.'[1]); // 녕
    console.log(greet[0]); // 안
    console.log(greet[1]); // 녕

    // 문자열의 길이
    console.log("안녕하세요.".length); // 6
    console.log(greet.length); // 6

    let name = prompt('이름을 입력');
    alert('이름은 '+name.length+'자 입니다.')

    let name2 = prompt('한글로 이름을 입력');
    alert('당신의 성은 '+ name2[0] +'입니다.');
</script>

 


💡 템플릿 문자열
문자열 결합 연산자를 사용하지 않고, 문자열 안에 바로 표현식을 사용할 수 있음

쌍따옴표나 홑따옴표 대신 백틱(`)을 사용 
<script>
    // 일반적인 방법 : 믄자열 결합 연산자 사용
    console.log('표현식은 273 + 52의 값은 ' + (273 + 52) + '입니다.');

    // 템플릿 문자열 사용
    console.log(`표현식은 273 + 52의 값은 ${273 + 52}입니다.`); // 백틱(`)을 사용

    let name = prompt('한글로 이름을 입력');
    alert(`당신의 성은 ${name[0]} 입니다.`);
</script>

 


 

2) 기본 자료형 : 숫자형 number

 

✏️  자바 스크립트는 정수와 실수의 구분이 없음
✏️  따옴표 없이 사용, 숫자에 따옴표를 붙이면 문자열 자료형이 됨

✏️  실수를 2진수로 변환해서 계산하는데, 이 때 자릿수가 많은 소수로 변환되어 계산되기 때문에 정확하지 x

    <script>
        console.log(100);
        console.log(123.456);

        // 숫자 관련 연산을 사용
        console.log(200 + 100); // 300
        console.log(200 - 100); // 100
        console.log(200 * 100); // 20000
        console.log(200 / 100); // 2

        // 프로그래밍에서는 나머지 연산이 자주 사용됨
        console.log(200 % 100); // 0
        console.log(200 % 99); // 2

        // 실수 사용시에 정확한 계산은 힘들다
        console.log(0.2 + 0.1); // 0.30000000000000004

        console.log(200 + 100); // 300
        console.log('200' + '100'); // 200100
    </script>

 

3) 기본 자료형: 논리형 boolean

 

✏️  참(True)과 거짓(False) 두 가지 값만 가지는 자료형

 

💡 비교 연산자 
    === : 양쪽이 같다.
    !==  : 양쪽이 다르다.
    >      : 왼쪽이 더 크다.
        : 오른쪽이 더 크다.
    >=    : 왼쪽이 더 크거나 같다.
    <=    : 오른쪽이 더 크거나 같다.

 

<script>
    console.log(1 === 2); // false 양쪽이 같다.
    console.log(1 !== 2); // true 양쪽이 다르다.
    console.log(1 > 2); // false 왼쪽이 크다.
    console.log(1 < 2); // true 오른쪽이 크다.
    console.log(1 >= 2); // false 왼쪽이 크거나 같다.
    console.log(1 <= 2); // true 오른쪽이 크거나 같다.

    // 문자열에도 비교 연산자 사용 가능. 내림차순 값이 크다.
    console.log('강아지' > '냐옹이'); // false

    // 논리 부정 연산자 (!)
    // 값을 반대로 바꿈
    console.log(!true); // false
    console.log(!false); // true
</script>

 


4) undefined와 null 자료형

 

✏️  undefined : 상수와 변수로 선언하지 않거나 변수를 선언하면서 값을 지정하지 않은 경우
✏️  상수는 선언할 때 반드시 값을 지정해야 하므로 값이 없는 상수는 존재하지 않음

✏️  null : ' 데이터 값이 유효하지 않은 상태 '

<script>
    'use strict'; // 엄격 모드

    console.log(typeof(a)); // undefined

    let b;
    console.log(typeof(b)); // undefined

    c = 100;
    console.log(typeof(c)); // number(엄격모드 지정 안할 시)
</script>

 


 

3. 자료형 검사  typeof

👩🏻‍🚀  자료형 확인할 때 'typeof' 사용

<script>
    let num = 10;
    console.log(num);
    num ='하이';

    // typeof 연산자 사용 : typeof(자료)
    console.log(typeof('안녕하세요')); // string
    console.log(typeof(100)); // number
    console.log(typeof(true)); // boolean

    // 괄호가 없어도 됨 : typeof가 연산자라서 가능
    console.log(typeof '안녕하세요'); // string
    console.log(typeof 100); // number
    console.log(typeof true); // boolean

    console.log(typeof "안녕하세요" === "string"); // true. "안녕하세요"의 자료형이 string
    console.log(typeof ("안녕하세요") === "string"); // true. "안녕하세요"의 자료형이 string
    console.log(typeof ("안녕하세요" === "string")); // boolean. "안녕하세요" === "string"의 결과값은 false

    // 자바 스크립트에서는 변수에 함수를 할당하는 것이 가능.
    // 즉, 함수도 하나의 자료형임.
    let fun = function() {
        console.log('hello');
    }
    fun(); // hello
    console.log(typeof fun); // function
</script>

 


4.  자료형 변환

 

 숫자 자료형으로 변환할 때는 Number() 함수를 사용
<script>
    // prompt로 입력 받으면 기본형이 문자열
    const rawInput = prompt("inch 단위의 숫자를 입력해주세요."); // 숫자를 입력.
    console.log(typeof rawInput); // String

    // 입력받은 데이터를 숫자형으로 변경하고 cm 단위로 변경.
    const inch = Number(rawInput);
    console.log(typeof inch); // Number
    const cm = inch * 2.54;

    // 출력
    alert(inch + 'inch는 ' + cm + 'cm 입니다.');
    alert(`${inch}inchsms ${cm}cm 입니다.`);
</script>

 

문자 자료형으로 변환할 때  String() 함수 사용
<script>
    var number = 100;
    console.log(typeof(number)); // number

    number = String(number); 
    console.log(typeof(number)); // string
    console.log(number); // 100
</script>

 

불 자료형으로 변환할 때 Boolean() 함수 사용
<script>
    // 숫자를 불린으로 형변환. 0은 false 나머지는 true
    var number = 200; 
    console.log(typeof(number)); // number
    console.log(number); // 200

    number = Boolean(number);
    console.log(typeof(number)); // boolean
    console.log(number); // true

    let num = 0;
    console.log(typeof(num)); // number
    console.log(num); // 0

    num = Boolean(num);
    console.log(typeof(num)); // boolean
    console.log(num); // false. 0은 false로 변환.

    // 문자열을 불린으로 형변환. 빈 문자열은 false, 나머지는 true.
    let string2 = 'hello';
    console.log(typeof(string2)); // string

    string2 = Boolean(string2);
    console.log(typeof(string2)); // boolean
    console.log(string2); // true

    let string3 = '';
    console.log(typeof(string3)); // string

    string3 = Boolean(string3);
    console.log(typeof(string3)); // boolean
    console.log(string3); // false
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

+ Recent posts