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.  함수 function

🐰  자바스크립트 프로그램은 단순히 동작 하나만 실행되는게 아니라 여러 가지 동작이 연결된다

🐰  이렇게 동작해야 할 목적대로 묶은 명령을 함수 function (= 코드의 집합) 이라 함

🐰  함수를 사용하면 각 명령의 시작과 끝을 명확하게 구별할 수 있고,

      묶은 기능에 이름을 붙여 필요할 때마다 호출하여 반복적으로 사용 가능

 

💡  함수를 사용하면 좋은 점
    1. 반복되는 코드를 한 번만 정리해놓고 필요할 때마다 호출하므로 반복 작업을 피할 수 있다
    2. 긴 프로그램을 기능별로 나눠 여러 함수로 나누어 작성하면 모듈화로 전체 코드의 가독성이 좋아진다.
    3. 기능별(함수별)로 수정이 가능하므로 유지보수가 쉽다.

💡  용어 정리
    ·  함수 정의 : 함수를 만든 것
    ·  함수 호출 : 함수를 사용하는 것
    ·  인수 : 함수를 호출할 때 괄호 내부에 여러가지 자료를 넣는 것
    ·  매개변수 : 함수를 정의할 때 전달받을 인수를 정의하는 것
    ·  리턴 값 : 함수를 호출해서 최종적으로 나오는 결과

1)  매개변수와 리턴값

 

🍯  매개변수와 리턴값은 함수의 필수 요소가 아니고, 필요할 때만 사용

/* 기본형 */
function 함수명 (매개변수1, 매개변수2, ... 매개변수n) {
    문장;
    문장;
    return 리턴값;
}
<script>
    const f = function (x) {
        return x * x;
    }

    // 함수를 호출
    console.log(f(3)); // 9. 매개변수 x에 전달되는 인수가 3이고 리턴값이 9.
    console.log(f()); // NaN
</script>

 

자바스크립트는 인수와 매개변수의 개수가 달라도 에러가 나지 않음 
<script>
    const test1st = function (a) {
        console.log(a);
    }
    
    test1st(); // undefined
    test1st(1); // 1
    test1st(1, 2); // 1
    test1st(1, 2, 3); // 1
</script>

 

매개 변수가 있는 함수 정의문
<script>
    const myFunc = function (name, area) {
        document.write('안녕하세요. ' + name + '입니다.', '<br>');
        document.write('사는곳은 ' + area + '입니다.', '<br><br>');
    };
    myFunc('홍당무', '서울');
    myFunc('깍두기', '부산');
</script>


2)  return 문


🍯  데이터를 반환하고 강제 종료
🍯  return의 역할  1) 데이터를 반환   2) 함수의 강제 종료 (반환값이 없어도 됨)

 

데이터 반환
<script>
    const getAvg = function (arrData) {
        let sum = 0;
        for(let i = 0; i < arrData.length; i++) {
            sum += Number(prompt(`${arrData[i]} 점수는 ?`, `0`));
        }

        const avg = sum / arrData.length;
        return avg;
        //alert(avg); // return 이후의 코드라서 실행이 안됨. (Unreachable code)
    }

    const arrSubject = ['국어', '수학', '영어'];
    const result = getAvg(arrSubject);

    document.write(`평균 점수는 ${result}점 입니다.`);
</script>

강제 종료
<head>
<style>
        * {
            padding: 0;
            margin: 0;
        }

        #galleryZone {
            text-align: center;
        }
</style>
<script>

    let num = 1;
    const showGallery = function (direction) {
    /*
    다음을 클릭한 경우 pic_1.jpg -> pic_2.jpg : 번호가 증가
    이전을 클릭한 경우 pic_9.jpg -> pic_8.jpg : 번호가 감소
    */
    if  (direction === 1) { // 다음을 클릭한 경우
        if (num === 9) {
            alert('마지막 이미지입니다');
            return; // 이미지가 9개인 경우 num이 9인 경우 함수 종료
        }
         num++;
    } else { // 이전을 클릭한 경우
        if (num === 1) {
            alert('첫 이미지입니다.');
            return; // 첫 이미지가 1번이어서 종료
         }
         num--;
    }
    const imgTag = document.getElementById('photo'); // id 값이 photo인 요소를 가져옴
    imgTag.setAttribute('src', 'images/pic_' + num + '.jpg'); // id 값이 photo인 요소의 src 속성을 변경
    }
</script>
</head>
<body>
    <div id ="galleryZone">
        <p><img src="./images/pic_1.jpg" id="photo" alt=""></p>
        <p>
            <button onclick="showGallery(0)">이전</button>
            <button onclick="showGallery(1)">다음</button>
        </p>
    </div>
</body>

 

 


2.  익명 함수 선언하기

 🐰  익명 함수 anonymous function : 이름이 없는 함수

 🐰  익명함수는 변수 선언(함수 정의) 후 호출 가능
 🐰  익명함수는 동일한 이름으로 재선언 불가능. let과 const의 특징

기본형 : function () {}
<!-- 변수 할당 --> 
let 변수 = function () {
    실행문;
}

 

<script>
    // 변수를 선언해서 함수를 할당.
    const func = function () {
        console.log('함수 내부의 코드입니다 ... 1');
        console.log('함수 내부의 코드입니다 ... 2');
        console.log('함수 내부의 코드입니다 ... 3');
        console.log('');
    }

    // 함수를 호출
    func();
    func();

    // 출력
    console.log(typeof func); // function. 함수의 자료형 확인
    console.log(func); // 함수 자체도 단순한 자료이므로 출력할 수 있음.
</script>

 

<script>
    /* 선언 전 호출시 */
    compute(); // Uncaught ReferenceError: Cannot access 'compute' before initialization
    let compute = function() {
        let x = 10;
        let y = 100;
        let result = x * y;
        console.log(result);
    };
    compute(); // 1000
</script>
<script>
    /* 재선언 시 */
    let compute = function() {
        let x = 10;
        let y = 100;
        let result = x * y;
        console.log(result);
    }; // Uncaught SyntaxError: Identifier 'compute' has already been declared 
</script>

 


3.  선언적 함수 

🐰  선언적 함수 : 이름이 있는 함수

🐰  선언적 함수는 재정의 가능

 기본형 : function 함수 이름 () {}


   ✏️  대부분의 프로그램은 선언적 함수만 사용하거나(C),

         선언적 함수를 주로 사용하고 익명함수를 보조적인 수단(C++, 자바의 람다)으로 사용
   ✏️  자바스크립트는 함수지향 프로그램(ECMA script 6 이후)이라서 변수에 함수 할당하거나,
         익명함수를 주로 사용하고 선언적 함수를 보조적인 수단으로 사용하는 것을 지향함.

 

<script>
    // 함수를 생성
    function func1st () {
        console.log('함수 내부의 코드입니다 ... 1');
        console.log('함수 내부의 코드입니다 ... 2');
        console.log('함수 내부의 코드입니다 ... 3');
        console.log('');
    }

    // 함수를 호출
    func1st();
    func1st();

    // 출력
    console.log(typeof func1st); // function
    console.log(func1st);
</script>


동일한 이름의 함수가 존재하는 경우
 -  선언적 함수의 경우 동일한 이름의 함수가 존재하면 뒤에 선언된 함수가 실행이 됨
<script>
    let num = 100;
    function menu() {
        num += 100;
        document.write(num, ": 앞의 함수 실행<br>");
    }
    menu(); // 100: 뒤의 함수 실행

    function menu() {
        document.write(num, ": 뒤의 함수 실행<br>");
    }
</script>

 

💡  선언적 함수를 변수에 할당하는 방법 
      1. 변수에 할당하면서 선언적 함수 선언
            ➡️  변수에 할당하면서 선언적 함수를 선언하면 익명함수로 처리
      2. 선언적 함수를 선언 후에 변수에 할당

 

<script>
    // 1. 변수에 할당하면서 선언적 함수 선언
    const func2nd = function namedFunc2nd() { // 변수를 선언해서 함수를 할당
        console.log('namedFunc2nd() 함수 내부의 코드입니다 ...');
        console.log('');
    }

    // 호출
    func2nd(); // 변수를 통해 함수를 호출.
    // namedFunction(); // Uncaught ReferenceError: namedFunction is not defined\
    console.log(typeof func2nd); // function. 함수의 자료형 확인

    // 2. 선언적 함수를 선언 후에 변수에 할당
    function namedFunc() {
        console.log('namedFunc() 함수 내부의 코드입니다 ...');
        console.log('');
    }
    const func1st = namedFunc; // 선언적 함수를 변수에 할당.

    func1st(); // 변수를 통해 함수 호출
    namedFunc(); // 함수를 호출
    console.log(typeof func1st); // function. 자료형 확인
</script>

 


4.  호이스팅  Hoisting

🐰  var로 선언한 변수 or 선언적 함수변수나 함수 이전에 호출하여도 에러를 발생하지 않음
🐰  자바스크립트 해석기는 소스를 훑고 var를 사용한 변수는 실행하기전에 기억해 두기 때문에 선언한 것과 같은 효과가 있다

<script>
    compute(); // 110. 선언적 함수는 함수 정의 전에 사용가능.
    function compute() {
        let x = 10;
        let y = 100;
        let result = x + y;
        console.log(result);
    }
    compute(); // 110
</script>

 

 

 

 

 

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


1.  배열 Array

배열명["값1", "값2", ...]
배열명[] // 빈 배열 선언

 

✏️  여러 자료를 하나로 묶어서 사용할 수 있는 특수한 자료형
✏️  배열은 대괄호[...]를 사용해 생성하고 내부의 값을 쉼표(,)로 구분해 입력
✏️  배열 내부에 들어있는 값을 요소 element 라고 함

        📁  하나의 배열에 여러가지 타입의 자료형이 요소가 될 수 있음
        📁  컴파일 계통의 언어(C, C++, JAVA)등은 하나의 배열이 동일한 타입의 자료형만 요소가 될 수 있음

✏️  자바의 배열 보다는 파이썬의 리스트에 가까움

 

    1. 자바 배열의 특징
    동일한 데이터 타입을 미리 지정된 개수 만큼 저장. 중괄호 사용.
    2. 파이썬 리스트의 특징
    다른 데이터 타입을 동적으로 추가 삭제 가능. 대괄호 사용.

 

  📌  요소에 접근하고 싶은 경우에는 인덱스를 사용
  📌  순서대로 0부터 시작해서 1씩 증가하는 정수를 라벨링

  📌  [ 배열이름.length ] 자바 스크립트에서 기본으로 제공하는 기능으로, 배열의 개수를 자동으로 반환

<script>
    let scores = [90, 80, 70, 60, 50];
    console.log(scores[1]); // 80

    /* 문자열도 문자의 배열 */
    const str = '안녕하세요';

    console.log(str[2]); // 하
    console.log(str.length); // 5
    console.log(str[str.length - 1]); // 요

    // 숫자 자료형, 문자열 자료형, 불린 자료형, 함수, 객체, 배열
    const array = [273, 'String', true, function () {}, {}, [273, 103]];
    console.log(array);
    // 0: 273 1: "String" 2: true 3: ƒ () 4: {} 5: (2) [273, 103]

</script>

 


2. 배열 요소 추가

배열 뒷 부분에 요소 추가 ; push() 메소드 사용
배열.push(요소)
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    console.log(todos); // (3) ['우유구매', '업무 메일 확인하기', '필라테스 수업']

    todos.push('저녁 식사 준비하기');
    todos.push('피아노 연습하기');

    // 배열의 뒷부분에 요소 2개가 추가됨
    console.log(todos); // (5) ['우유구매', '업무 메일 확인하기', '필라테스 수업', '저녁 식사 준비하기', '피아노 연습하기']

    // 배열은 참조변수라서 const 라도 값 변경이 가능.
    const fruitsA = ['사과', '배', '바나나'];
    fruitsA.push('망고');
    console.log(fruitsA); // (4) ['사과', '배', '바나나', '망고']

    // 재할당은 불가
    // fruitsA = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    // Uncaught TypeError: Assignment to constant variable;
</script>

 


배열 뒷 부분에 요소 추가 ; 인덱스 사용

 

  📌  배열의 길이는 고정이 아니기 때문에 인덱스 번호를 사용해서 강제로 요소를 추가할 수 있음

<script>
    const fruitsA = ['사과', '배', '바나나'];
    fruitsA[10] = '귤'; // 배열의 길이는 3개, 마지막 요소의 인덱스는 2번인데 10번 인덱스를 강제로 입력.

    // 4 ~ 10 번째 요소는 아무것도 없음
    console.log(fruitsA); // (11) ['사과', '배', '바나나', 비어 있음 x 7, '귤']

    const fruitsB = ['사과', '배', '바나나'];

    // length 속성 사용
    fruitsB[fruitsB.length] = '귤';

    console.log(fruitsB); // ['사과', '배', '바나나', '귤']
</script>

 


배열의 특정 위치에 요소 추가 ; splice() 메소드 사용 
배열.splice(인덱스, 제거할 요소의 수, 요소);

 

  📌  1번째 매개변수인 인덱스는 필수이고 제거할 요소의 수와 삽입할 요소는 생략 가능

  📌  2번째 매개변수인 제거할 요소의 수: 배열 안의 인덱스 요소부터 삭제 ▶️ 생략시 끝까지 삭제

         ⚡️ 2번째 매개변수에 0을 입력하면 splice() 메소드가 요소를 삭제하지는 않고, 3번째 매개변수에 있는 요소를 추가함

  📌  3번째 매개변수인 요소는 추가할 값을 입력

<script>
    const items = ['사과', '귤', '바나나', '오렌지'];
    console.log(items); // (4) ['사과', '귤', '바나나', '오렌지']

    items.splice(1, 0, '양파'); // 1번 인덱스에 요소를 추가.
    console.log(items); // (5) ['사과', '양파', '귤', '바나나', '오렌지']

    // 요소를 변경하고 싶은 경우
    items[1] = '키위';
    console.log(items); // (5) ['사과', '키위', '귤', '바나나', '오렌지']
</script>

 


3.  배열 요소 제거

 인덱스 기반으로 제거


    📌  배열의 특정 인덱스에 있은 요소를 제거할 때는 splice() 메소드를 사용

배열.splice(인덱스, 제거할 요소의 개수)
<script>
    const fruitsA = ['사과', '배', '바나나'];
    console.log(fruitsA); // (3) ['사과', '배', '바나나']

    fruitsA.splice(2, 1); // 배열의 2번째 인덱스로 부터 1개 요소를 제거
    console.log(fruitsA); // (2) ['사과', '배']
</script>

 


 값으로 요소 제거


    📌  배열 내부에서 특정 값의 위치를 찾는 indexOf() 메소드를 사용해서 값의 위치를 추출한 후,
          splice() 메소드를 사용해서 제거

    📌  indexOf() 매개변수에 배열에 없는 요소를 넣은 경우 -1을 반환

const 인덱스 = 배열.indexOf(요소);
배열.splice(인덱스, 1);
<script>
    const fruits = ['사과', '배', '바나나'];

    const index = fruits.indexOf('바나나'); // 바나나를 값으로 가지는 인덱스 구함.
    console.log(index); // 2

    fruits.splice(index, 1);
    console.log(fruits); // (2) ['사과', '배']

    console.log(fruits.indexOf('바나나')); // 배열에 없는 경우 -1을 출력
    if (fruits.indexOf('바나나') >= 0) {
        fruits.splice()
    }
</script>

 

 

 

 

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


1.  for 반복문

👩🏻‍🚀  반복문 : 반복작업을 할 때 사용

자바스크립트 반복문 특징

    -  while문 자바와 거의 동일
    -  삼항 for문 존재
    -  for in, for of

 

(1) for 반복문

    

  ✏️  특정 횟수 만큼 반복하고 싶을 때 사용

<!-- 기본 형식 -->    
for(초기값, 조건식, 증감식) // 초기값에는 const 대신 let 사용
for (let i = 0; i < 반복 횟수; i++) {
    문장
}
<script>
    /* for 반복문 기본 */
    for (let i = 0; i < 5; i++) { // 0 부터 5미만 까지 반복
        console.log(`${i}번째 반복입니다.`);
    }

    /* 1부터 N까지 더하기 */
    let output = 0; // 합계에 사용할 변수. 복합 대입 연산자에 사용해야 되서 반드시 초기화.
    for (let i = 1; i <= 100; i++) {
        output += i; // 1부터 100까지 더함.
    }
    //console.log(i); // i is not defined -> 변수i가 효력을 가지는 범위는 for문 안쪽.
    console.log(`1~100까지 숫자를 모두 더하면 ${output}입니다.`);
</script>

 

for 반복문과 배열
  📁  배열을 출력할 경우 배열.length 사용 
<script>
    const todos = ['우유 구매', '업무 메일 확인하기', '필라테스 수업'];

    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    /* for 반복문으로 배열을 반대로 출력하기 */
    /* 2번째 할 일: 필라테스 수업
       1번째 할 일: 업무 메일 확인하기
       0번째 할 일: 우유 구매  */

    for (let i = todos.length-1; i >= 0; i--) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    for (const i in todos) { // i는 인덱스 번호를 가져옴
        const ii = todos.length - i - 1;
        console.log(`${ii}번째 할 일: ${todos[ii]}`); // 인덱스번호를 이용해 값에 접근.
    }

 


(2) for 요소 in 반복문

 

✏️  인덱스 기반으로 출력 배열 요소를 하나하나 꺼내서 특정 문장을 실행할 때 사용

<!-- 기본 형식 -->
for(const 반복변수(인덱스) in 배열 또는 객체) { 문장 }
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    const times = ['8시', '3시', '12시'];

    // 배열 출력을 위한 전통적인 방법
    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번 째 할 일: ${todos[i]}`);
        console.log(typeof i); // number
    }

    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${todos[i]}`); // 인덱스 번호를 이용해 값에 접근.
        console.log(i); // 0 1 2
        console.log(typeof i); // string -> 인덱스 값이 문자열
    }

    // 시간과 같이 출력
    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${times[i]} : ${todos[i]}`);
    }
</script>

 


(3) for of 반복문

 

✏️  반복문 내부의 반복변수에 인덱스 대신 요소의 값이 들어감
✏️  자바의 foreach, 파이썬의 for in과 유사

for(const 반복변수 of 배열 또는 객체) {
    문장
}
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    for (const todo of todos) { // todo에 요소의 값이 들어감
        console.log(`오늘의 할 일: ${todo}`);
    }
</script>

 


(4) 중첩 for문

 

✏️  for문 안에 다른 for문을 넣어 사용

✏️  안쪽 for문을 모두 실행한 후 바깥쪽 for문을 실행

<script>
    /* for문으로 5번 반복 */
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');

    /* 중첩 for문으로 5번 반복 */
    for (let k = 0; k < 5; k++) {
        for (let i = 0; i < 30; i++) {
            document.write('*');
        }
        document.write('<br>');
    }
</script>

구구단 출력
<head>
    <style>
        div {
            display:inline-block;
            padding:0 20px 30px 20px;
            margin:15px;
            border:1px solid #ccc;
            line-height:2;
        }
        div h3 {
            text-align:center;
            font-weight:bold;
        }
    </style>
</head>
<body>
    <h1>구구단</h1>
    <script>
     for(let i = 2; i <= 9; i++) {
         document.write('<div>');
         document.write('<h3>' + i + '단</h3>');
         for (let j = 2; j <= 9; j++) {
             document.write(`${i} X ${j} = ${i * j} <br>`);
         }
         document.write('</div>');
     }
    </script>
</body>


2.  while 문

🐰  if 조건문과 형태가 비슷하지만 문장을 한 번만 실행하고 끝내는 것이 아니라 

      불 표현식이 ture이면 계속해서 문장을 실행한다는 점이 다르다.
🐰  while 반복문의 경우 조건이 변하지 않는다면 무한히 반복 실행하므로 조건을 거짓으로 만들 수 있는 문장이 있어야 함
🐰  반복문이 무한 반복 되는 것을 무한 루프 infinite loop

<!-- 기본형식 -->
while (불 표현식) {
    문장
}
<script>
    /* while 반복문 기본 */
    let i = 1;
    // confirm() : 사용자가 [확인] 버튼을 클릭하면 true 반환. [취소]를 클릭하면 false 반환.
    while (confirm('계속 진행하시갰습니까?')) {
        alert(`${i}번째 반복입니다.`);
        i = i + 1;
    }
</script>

 

while 문으로 배열 출력하기
while 반복문과 for 반복문은 서로 대체해서 사용할 수 있음
보통 특정 횟수 반복할 때 for, 조건에 큰 비중이 있을 때는 while.
  예) 특정 시간동안 어떤 데이터를 받을 때 까지
<script>
    const array = [1, 2, 3, 4, 5];

    for(let i = 0; i < array.length; i++){
        console.log(`${i} : ${array[i]}`);
    }

    // 1. 인덱스 번호가 필요 : 0 ~ 4
    // 2. 반복문은 5번 반복
    let i = 0;
    while(i < array.length) {
        console.log(`${i} : ${array[i]}`);
        i++;
    }
</script>

 


3.  break 문

🐰  switch문이나 반복문을 벗어날 때 사용하는 키워드

while(true) {
    if(조건식) {
        break;
    }
}
<script>
    for (let i = 0; true; i++) { // 조건문이 true라서 무한 반복.
        alert(i + '번째 반복문입니다.');

        // 진행 여부를 물어봄
        const isContinue = confirm('계속하시겠습니까?'); // confirm()에서 취소를 누르면 반복을 종료.
        if(!isContinue) { // 취소를 누르면 false가 반환이 되므로 not연산자를 사용해서 true로 변경.
            break;
        }
    }
    alert('프로그램 종료'); // 프로그램의 종료를 확인.
</script>

 


4.  continue 문

🐰  반복문 안의 반복을 멈추고 반복문의 처음으로 돌아가 다음 반복 작업을 진행

<script>
    // alert() 명령문 위에 continue 키워드가 있어서 실행되지 않음.
    for(let i = 0; i < 5; i++) {
        console.log(i);
        // 현재 반복 작업을 중지하고 다음 반복 작업을 수행
        continue;
        alert(i); // 경고창이 출력되지 않음
    }
</script>

 

 

 

 

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


1.  if 문과 if-else 문

👩🏻‍💻  if문이나 if-else문을 사용하면 스크립트 안에서 조건 체크 가능


들어가기 전
 const number = prompt('숫자를 입력하세요!');

     

    💡  위 코드는 형변환을 하지 않아도 프로그램 실행에는 문제가 없음
            ▶️ 조건식에서 0과 비교를 할 때 자동으로 형변환이 되어서 계산이 되기 때문
            ▶️ but! 자바 스크립트로 프로그램을 짤 때 문제가 되는 경우가 있어서 가급적 형변환을 하는 것을 추천


if 문
<!--if조건문 기본형-->
if (불 값이 나오는 표현식) {
    불 값이 참일 때 실행할 문장
}
<script>
    if(273 < 100) { // 표현식 273 < 100이 참일 때 실행
        alert('273 < 100 => true')
    }

    let str = ' ';
    if (!str) { // 조건문 안에서 자동으로 형변환. 공백도 글자로 취급
        alert('빈 문자열입니다.'); // false라서 실행 안됨.
    }

    str = ' '; 
    if (!str.trim()) { // 조건문 안에서 자동으로 형변환.
        alert('빈 문자열입니다.') // trim()은 공백제거 함수. true라서 실행됨.
    }

    str = '값입력';
    if (str) { // 조건문 안에서 자동으로 형변환
        alert('빈 문자열이 아닙니다.'); // true라서 실행됨.
    }
</script>

if-else문
<!-- if-else 조건문 기본형 -->
if (불 값이 나오는 표현식) {
    불 값이 참일 때 실행할 문장
} else {
    불 값이 거짓일 때 실행할 문장
}
<script>
    // 오전과 오후 구분하기
    const date = new Date(); // 현재 날짜와 시간을 갖는 객체 생성
    const hour = date.getHours();

    if (hour < 12) {
        alert('오전입니다.');
    } else {
        alert('오후입니다.');
    }
    // if-else문을 삼항연산자로 변경
    console.log((hour < 12 ? '오전입니다.' : '오후입니다.'))
</script>

 


중첩 조건문 : 조건문 안에 조건문을 중첩해서 사용하는 것
<script>
    // 변수를 선언
    const date = new Date(); // 현재 날짜와 시간을 갖는 객체생성.
    const hour = date.getHours(); // 현재시간을 0 ~ 23 사이의 값으로 출력하는 메소드.

    // if-else 문
    if (hour < 11) { //표현식 hour < 11가 참일 때
        alert("아침 먹을 시간입니다.")
    } else { // 표현식 hour < 11가 거짓일 때 실행
        if (hour < 15) { // 표현식 hour < 15가 참일 때 실행.
            alert("점심 먹을 시간입니다.");
        } else { // 표현식 hour < 15가 거짓일 때 실행.
            alert("저녁 먹을 시간입니다.")
        }
    }
    // else-if 문
    if (hour < 11) { //표현식 hour < 11가 참일 때
            alert("아침 먹을 시간입니다.")
        } else if (hour < 15) { // 표현식 hour < 15가 참일 때 실행.
                alert("점심 먹을 시간입니다.");
        } else { // 표현식 hour < 15가 거짓일 때 실행.
                alert("저녁 먹을 시간입니다.")
        }
</script>

2.  switch 문

🐰  switch 조건문의 괄호 안에 비교할 값을 입력  ▶️  이때 입력한 값을 기준으로 특정 코드를 실행

      🥕  처리할 명령이 많을 때 주로 사용

      🥕  switch 문의 조건은 case 문의 값과 일대일로 일치해야 함

🐰  일반적으로 case 뒤에는 정수나 문자열이 오는 것으로 사용
🐰  break 키워드는 switch 조건문이나 반복문을 빠져나가기 위해 사용하는 키워드
        ▶️  코드를 읽다가 break 키워드를 만나면 break 키워드를 감싼 switch 조건문이나 반복문을 완전히 빠져 나감

<!-- 기본형 -->
switch (조건문) {
    case 조건A :
        조건이 A일 때 실행할 명령문;
        break;
    case 조건B :
        조건이 B일 때 실행할 명령문;
        break;
    default :
        break;
}
<script>
    // 변수를 선언
    const input = Number(prompt('숫자를 입력하세요.', '숫자'));

    // 조건문
    switch (input % 2) { // 나머지 연산자를 이용해서 홀수와 짝수를 구분
        case 0:
            alert('짝수입니다.');
            break;
        case 1:
            alert('홀수입니다.');
            break;
        default:
            alert('숫자가 아닙니다.'); // 숫자가 아닌걸 입력해도 에러가 나지 않음.
            break;
    }
</script>
<script>
    /* 사용자에게 월을 입력받아서 switch 이용해 계절을 출력.
       다만 1~12만 입력된다고 가정. */

    const month = Number(prompt("월을 입력하세요. (숫자 1~12 중 선택)"));

    switch (month) {
        case 12: case 1: case 2:
            document.write(`${month}월은 겨울 입니다.`);
            break;
        case 3: case 4: case 5:
            document.write(`${month}월은 봄 입니다.`);
            break;
        case 6: case 7: case 8:
            document.write(`${month}월은 여름 입니다.`);
            break;
        case 9: case 10: case 11:
            document.write(`${month}월은 가을 입니다.`)
            break;
    }
</script>

 

 

 

 

 

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

+ Recent posts