노드 생성과 삽입 메소드


 

노드 생성 메소드

 

 

 

노드 삽입 메소드

 

 

 

노드 삭제 메소드

 

 

 

 

 

 

▼ 코드 예시 보기 ▼
    <h1>문서 수정</h1>
    <h3>노드 생성</h3>
    <p>
        document.createElement(tag) : 태그 이름을 사용해 새로운 요소를 만든다.<br>
        document.createTextNode(value) : 텍스트 노드를 만든다. (잘 쓰이지 않음) <br>
        element.cloneNode(deep) : 요소를 복제함. deep == true 일 경우 모든 자손 요소도 복제한다.
    </p>
    
    <h3>노드 삽입, 삭제</h3>
    <p>
        node.append(노드나 문자열) : node 끝에 노드나 문자열을 삽입<br>
        node.prepend(노드나 문자열) : node 맨 앞에 노드나 문자열을 삽입<br>
        node.before(노드나 문자열) : node 이전에 노드나 문자열을 삽입<br>
        node.after(노드나 문자열) : node 이후에 노드나 문자열을 삽입<br>
        node.replaceWith(노드나 문자열) : node를 노드나 문자열로 대체<br>
        node.remove() : node를 제거
    </p>

 

    <h3>li(텍스트 노드가 있는) 노드 생성</h3>
    <button onclick="test1();">실행확인</button>
    <ul id="list">
        <li>기존 목록1</li>
        <li>기존 목록2</li>
        <li>기존 목록3</li>
    </ul>
    <script>
        function test1(){
            let list = document.getElementById("list");

            // list의 앞 뒤에 문자열 삽입
            list.before("before");
            list.after("after");

            // li 노드 생성
            let newList1 = document.createElement("li");
            let newList2 = document.createElement("li");

            // 각 노드의 내부 텍스트 설정
            let text = document.createTextNode("새로운 목록1");
            newList1.append(text);  //<li>새로운 목록1</li>
            newList2.innerHTML = "새로운 목록2";

            // list의 마지막 항목/첫 항목으로 삽입
            list.append(newList1);
            list.prepend(newList2);
        }
    </script>

 

 

 

 

 

 

    <h3>이미지(텍스트 노드가 없는) 노드 생성</h3>
    <button onclick="test2();">실행확인</button>
    <div id="area2" class="area"></div>
    <script>
        function test2(){
            // img 노드 생성
            let imgTest = document.createElement('img');

            // 속성 지정
            imgTest.src = "https://www.iei.or.kr/resources/images/main/main_renewal/top_logo.jpg";
            imgTest.width = "200";
            imgTest.height = "100";
            document.getElementById('area2').append(imgTest);
        }
  </script>

 

    <style>
        .area {
            background : lightgray;
            border : 1px solid black;
            min-height: 100px;
        }

        .div-test {
            border : 1px solid black;
            padding : 20px;
        }

        .div1 { background : mistyrose; }
        .div2 { background : ivory; }
        .div3 { background : honeydew; }
        .div4 { background : aliceblue; }

        
    </style>

 

 

 

 

 

    <h3>노드 삭제</h3>
    <button onclick="test3();">맨 앞 이미지 삭제</button>
    <script>
        function test3(){
            // 삭제 할 img 노드 찾기 (img 노드 중 첫 번째 리턴)
            let img = document.querySelector('img');

            // 존재할 경우 (null이 아닌 경우) 삭제
            if(img != null)
                img.remove();
        }
    </script>

 

 

 

 

    <h3>노드 복제</h3>
    <button onclick="test4();">실행 확인</button><br>
    <ul class="copy">
        ul 영역
        <li>li 영역</li>
    </ul>
    <script>
        function test4(){
            let ul = document.querySelector(".copy");

            let cloneFalse = ul.cloneNode(false);
            let cloneTrue = ul.cloneNode(true);

            ul.before(cloneFalse);
            ul.after(cloneTrue);
        }
    </script>

 

 

 

 

    <h3>노드 대체</h3>
    <button onclick="test5();">실행확인</button>
    <script>
        function test5(){
            // 대체할 노드 찾기 (img 태그 중 첫 번째 리턴)
            let img = document.querySelector("img");

            // 존재할 경우(null이 아닌 경우) 대체
            if(img != null)
                img.replaceWith("<b>이미지가 있던 곳</b>");
                // => 태그가 아닌 문자열로 인식
        }
    </script>

 

 

 

 

 

 

 

 

 

 

추가 HTML 삽입 메소드


 

element.insertAdjacentHTML(where, html)

where은 element 기준 상대 위치를 나타내며, html은 문자열로 태그 포함한 문자열은 이스 케이프 처리 없이 태그로 기능함

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>insertAdjacentHTML</h3>
    <p>
        element.insertAdjacentHTML(where, html)
        : where은 element 기준 상대 위치, html은 문자열.
        태그 포함한 문자열은 이스케이프 처리 없으 태그로 기능한다.<br>
        beforebegin : element의 바로 앞에 html 삽입<br>
        afterbegin : element의 첫 번째 자식 요소 바로 앞에 html 삽입<br>
        beforeend : element의 마지막 자식 요소 바로 다음에 html 삽입<br>
        afterend : element의 바로 다음에 html 삽입
    </p>

 

    <h3>노드 대체 수정</h3>
    <button onclick="test6();">실행확인</button>
    <script>
        function test6(){
            // 대체할 노드 찾기
            let img = document.querySelector("img");

            // 존재할 경우(null이 아닌 경우) 대체
            if(img != null){
                img.insertAdjacentHTML('afterend', '<b>이미지가 있던 곳</b>');
                img.remove();
            }
        }
    </script>

 

 

 

 

    <h3>요소 위치 바꾸기</h3>
    <div class="first">first</div>
    <div class="second">second</div>
    <p>
        모든 노드 삽입 메소드는 자동으로 기존에 있던
        노드를 삭제하고 새로운 곳으로 노드를 옮기기 때문에
        요소 노드를 다른 곳으로 옮길 때 기존에 있던 노드를
        지울 필요가 없음
    </p>
    <button onclick="test7();">실행확인</button>
    <script>
        function test7(){
            let first = document.querySelector(".first");
            let second = document.querySelector('.second');
            // second 뒤에 first 삽입
            second.after(first);
        }
    </script>

 

 

 

 

 

 

 

 

 

 

 

문서 스타일 수정


  •  style객체를 이용하여 문서의 스타일을 변경
  • 자바 스크립트에서 식별자에 ‘-’를 쓰지 못하기 때문에 속성명이 css에서 쓰는 것과 다른 부분이 있다. 
  • 예) background-color -> backgroundColor
element.style.속성명 = 속성값;



 

  • Class를 변경하거나 추가하여 반영되는 CSS 속성 수정
className : class 속성에 대응하며 대입 시 클래스 문자열 전체가 변경
classList : 클래스 하나만 조작할 수 있는 add, remove, toggle 메소드가 존재함

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>스타일 지정</h3>
    <p>
        프로퍼티 style은 속성 style에 쓰인 값에 대응 되는 객체<br>
        여러 단어를 이어서 만든 프로퍼티는 카멜 표기법을 사용해서 이름 지어짐<br>
        Ex. background-color => backgroundColor,
        border-radius => borderRadius<br>
        style을 수정하는 방법에는 class를 변경/추가하여 수정하는 방법도 있음<br>
        className : class 속성에 대응. 대입 시 클래스 문자열 전체가 바뀜<br>
        classList : 클래스 하나만 조작할 수 있는 add/remove/toggle 메소드가 있음
    </p>

 

    <button onclick="test8();">style 수정</button>
    <button onclick="test9();">class 수정</button>
    <div id="area4" class="area"></div>
    <script>
        function test8(){
            let area4 = document.querySelector('#area4');

            area4.style.width = '200px';
            area4.style.backgroundColor = 'yellow';
            area4.style.borderRadius = '50%';
        }
        function test9(){
            let area4 = document.querySelector("#area4");
            // 전체 클래스명이 circle로 변경 되어 area 클래스로 가지고 있던
            // 속성도 제거 됨(높이 값이 없어 보이지 않음)
            // area4.className = 'circle';
            // 기존 area 클래스에 circle 클래스 추가
            area4.classList.add('circle');
        }
    </script>

 

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

10. 이벤트  (0) 2022.02.21
9. BOM(Brower Object Model)  (0) 2022.02.21
7. 요소 검색  (0) 2022.02.18
6. DOM(Document Object Model)  (0) 2022.02.18
5. 숫자/문자/날짜 다루기  (0) 2022.02.18

 

 

 

 

 

요소 검색 메소드


 

 

 

 

 

▼ 코드 예시 보기 ▼
    <h1>원하는 요소 노드에 접근하기</h1>
    <h3>document.getElementById</h3>
    <p>
        요소에 id 속성이 있으면 위치에 상관 없이
        (부모, 자식, 형제 등의 상대적 위치와 관계 없이)
        document.getElementById(id) 메소드를 통해 접근할 수 있다.<br>
        id 속성 값을 그대로 딴 전역 변수를 이용한 접근도 가능하지만
        해당 id 값과 동일한 변수가 생기는 이름 충돌 가능성이 있어
        지양하는 것이 좋다.<br>
        문서 내의 id 속성 값을 중복 되어서는 안되며 중복 된다면
        document.getElementById 메소드 동작에 문제가 발생한다.
    </p>

 

    <style>
        .area {
            width : 500px;
            height: 200px;
            border : 1px solid black;
        }
    </style>
    
    
        <div id="area1" class="area">
        div 영역
        <p id="area2">p 영역</p>
    </div>
    <!-- id는 고유 값이므로 아래 태그는 배경색이 변경 되지 않는다 -->
    <!-- <div id="area1" class="area">
        div 영역
    </div> -->
    <script>
        // 요소 접근
        let elem = document.getElementById('area1');
        // 요소의 스타일 속성을 이용하여 배경색 변경
        elem.style.backgroundColor = 'skyblue';

        //let area2 = 10;
        area2.style.backgroundColor = 'blue';
    </script>
    <div id="area3" class="area"></div>
    <button onclick="accessId();">클릭 할 때 마다 색상 변경</button>


<script>
        function accessId(){
            let area3 = document.getElementById('area3');
            let bgColor = area3.style.backgroundColor;
            console.log(bgColor);

            if(bgColor == 'red') {
                area3.style.backgroundColor = 'yellow';
            } else {
                area3.style.backgroundColor = 'red';
            }
        }
    </script>

 

 

 

 

    <h3>getElementsByTagName(tag),
        getElementsByClassName(className),
        getElementsByName(name)
    </h3>
    <p>
        getElementsByTagName('태그명')
        : 주어진 태그에 해당하는 요소들의 컬렉션을 반환<br>
        getElementsByClassName('클래스명')
        : 주어진 클래스 속성 값에 해당하는 요소들의 컬렉션을 반환<br>
        getElementsByName('name명')
        : 주어진 name 속성 값에 해당하는 요소들의 컬렉션을 반환
    </p>

    <h3>태그명으로 접근</h3>
    <ol>
        <li><a href="#">목록 1</a></li>
        <li><a href="#">목록 2</a></li>
        <li><a href="#">목록 3</a></li>
        <li><a href="#">목록 4</a></li>
        <li><a href="#">목록 5</a></li>
    </ol>
    <button onclick="accessTagName();">태그명으로 접근</button>
    <script>
        function accessTagName(){
            let links = document.getElementsByTagName("a");
            console.log("전달 받은 a 태그의 갯수 : " + links.length);
            let changeColor = 50;
            for(let i = 0; i < links.length; i++) {
                console.log(links[i]);
                links[i].style.backgroundColor = "rgb(130,220," + changeColor + ")";
                changeColor += 50;
            }
        }
    </script>

 

 

 

 

 

    <h3>class로 접근</h3>
    <script>
        console.log(document.getElementsByClassName("area"));
    </script>

 

 

    <h3>name으로 접근</h3>
    <form>
        <fieldset>
            <legend>취미</legend>
            <table>
                <tr>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="game" id="game">
                        <label for="game">game</label>
                    </td>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="music" id="music">
                        <label for="music">music</label>
                    </td>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="movie" id="movie">
                        <label for="movie">movie</label>
                    </td>
                </tr>
                <tr>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="book" id="book">
                        <label for="book">book</label>
                    </td>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="travle" id="travle">
                        <label for="travle">travle</label>
                    </td>
                    <td>
                        <input type="checkbox" name="hobby" 
                        value="exercise" id="exercise">
                        <label for="exercise">exercise</label>
                    </td>
                </tr>
            </table>
        </fieldset>
    </form>
    <button onclick="accessName();">name으로 접근</button>
    <script>
        function accessName(){
            let hobby = document.getElementsByName("hobby");
            console.log(hobby);
            let checkItem = '';
            hobby.forEach(function(item){
                console.log(item);
                if(item.checked){
                    checkItem += item.value + " 선택함\n";
                }
            });
            alert(checkItem);
        }
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>querySelector</h3>
    <p>
        document.querySelector('선택자') : 
        제공한 선택자와 일치하는 문서 내 첫 번째 element를 반환<br>
        document.querySelectorAll('선택자') :
        제공한 선택자와 일치하는 문서 내 모든 element를 반환
    </p>
    <div class="test">
        <h1>first</h1>
    </div>
    <div class="test">
        <h1>second</h1>
    </div>
    <script>
        let myDiv = document.querySelector(".test");
        console.log(myDiv);
        let myDivs = document.querySelectorAll(".test");
        console.log(myDivs);
        myDivs[0].style.color = 'red';
        myDivs[1].style.color = 'green';
    </script>

 

 

    <p>
        element.querySelector('선택자') :
        제공한 선택자와 일치하는 element 내의 첫 번째 element를 반환<br>
        element.querySelectorAll('선택자') :
        제공한 선택자와 일치하는 element 내의 모든 element들을 반환
    </p>
    <div class="first">
        <div class="second">
            <ul>
                <li>test1</li>
                <li>test2</li>
                <li>test3</li>
                <li>test4</li>
            </ul>
        </div>
    </div>
    <script>
        let first = document.querySelector(".first");
        let myLi = first.querySelector(".second li:nth-child(3)");
        let myLis = first.querySelectorAll("li");
        console.log(myLi);
        console.log(myLis);
        myLi.style.color = 'red';
        myLis[0].style.backgroundColor = 'gray';
    </script>

 

    <h3>closest</h3>
    <p>
        element.closest('선택자')
        : element 자기 자신을 포함하여 제공한 선택자와 일치하는
        가장 가까운 조상 요소를 반환 
    </p>
    <div class="area">
        <ul class="korean-food">
            <li class="menu">제육볶음</li>
            <li class="menu">된장찌개</li>
            <li class="menu">김치찌개</li>
        </ul>
    </div>
    <script>
        let menu = document.querySelector('.menu');
        console.log(menu);
        console.log(menu.closest('.korean-food'));
        console.log(menu.closest('.area'));
        // null -> h3은 li의 조상 요소가 아니므로
        console.log(menu.closest('h3'));
    </script>

 

 

 

    <h3>matches</h3>
    <p>
        element.matches('선택자')
        : element가 선택자와 일치하는지 여부 반환<br>
        요소가 담겨있는 배열 등을 순회해 원하는 요소만 걸러내고자 
        할 때 유용하게 사용할 수 있다.<br>
    </p>
    <script>
        for(let elem of document.body.children) {
            if(elem.matches('.area')){
                console.log(elem);
            }
        }
    </script>

 

 

 

    <h1>각 메소드의 반환값의 차이</h1>
    <script>
        // Element 1개
        let test1 = document.getElementById('area1');
        // Element 1개
        let test2 = document.querySelector("#area1");
        // NodeList
        let test3 = document.querySelectorAll(".area");
        // HTMLCollection
        let test4 = document.getElementsByTagName("a");
        // HTMLCollection
        let test5 = document.getElementsByClassName("area");
        // NodeList
        let test6 = document.getElementsByName("hobby");
    </script>

 

 

 

 

 

 

주요 노드 프로퍼티


 

 

 

 

▼ 코드 예시 보기 
<body>
    <h1>주요 노드 프로퍼티</h1>
    <h3>innerHTML</h3>
    <p>
        요소 안 HTML을 문자열 형태로 받아올 수 있음<br>
        요소 안 HTML을 수정하는 것도 가능함
    </p>
    <script>
        // 내용 읽기
        console.log(document.body.innerHTML);
        // 내용 변경
        //document.body.innerHTML = '새로운 BODY!';
    </script>

 

    <h3>innerHTML로 요소의 내용 변경하기</h3>
    <div id="area1">
        자바스크립트에서 태그 엘리먼트의 값을 읽거나,
        변경할 때 innerHTML 속성을 사용함
    </div>
    <button onclick="checkValue();">innerHTML 확인</button>
    <script>
        function checkValue(){
            // 아이디를 이용하여 요소 접근
            let divEl = document.getElementById('area1');

            // 읽어온 요소가 가지는 값 alert 출력
            alert(divEl.innerHTML);

            // 값 변경하기
            divEl.innerHTML = "innerHTML 속성으로 값 변경함";
        }
    </script>

 

    <h3>outerHTML</h3>
    <p>
        outerHTML 속성에는 요소 전체 HTML이 담김<br>
        outerHTML은 innerHTML에 요소 자체를 더한 것<br>
        innerHTML은 요소 값을 수정하지만 outerHTML은
        요소 값을 수정하지 않음
    </p>
    <div id="area2">
        area2 영역입니다.
    </div>
    <script>
        let area2 = document.querySelector("#area2");
        console.log(area2.outerHTML);
    </script>

 

    <h3>textContent</h3>
    <p>
        요소 내의 텍스트에 접근할 수 있으며
        태그는 제외하고 오로지 텍스트만 추출함<br>
        사용자의 입력 값을 받아 처리해야 하는 경우
        사용자가 입력한 예상치 못한 HTML이 침투하는 것을
        막기 위해 사용함
    </p>
    <div id="area3">
        <p>area3 영역입니다</p>
        <p>문단을 나누어봅니다</p>
    </div>
    <div id="area4"></div>
    <div id="area5"></div>
    <script>
        // 태그 제외하고 텍스트만 추출
        let area3 = document.getElementById('area3');
        console.log(area3.textContent);

        let input = prompt("값을 입력하세요", "<p><b>강조할거에요</b></p>");
        let area4 = document.querySelector("#area4");
        let area5 = document.querySelector("#area5");
        area4.innerHTML = input;
        area5.textContent = input;
    </script>

 

 

    <h3>hidden</h3>
    <p>
        hidden은 요소를 보여줄지 말지 지정할 때 사용함<br>
        HTML 안에 쓸 수도 있고 자바스크립트에서도 쓸 수 있음<br>
        기술적으로 style="display:none"과 동일함
    </p>
    <div hidden>숨겨진 div</div>
    <div id="area6">area6 영역도 숨기기</div>
    <script>
        let area6 = document.getElementById('area6');
        area6.hidden = true;
    </script>

 

 

    <h3>value</h3>
    <p>
        input, select, textarea 의 값이 저장되는 속성
    </p>
    <form>
        이름 : <input type="text" name="username" id="username">
        <input type="button" onclick="readValue();"
        value="input 값 확인">
    </form>
    <div id="area7" class="area"></div>
    <script>
        function readValue(){
            let input = document.querySelector('#username');
            if(input.value == ''){
                alert('이름을 입력하세요');
                input.focus();
            }else{
                document.querySelector("#area7").innerHTML 
                = input.value + "라고 입력되었습니다.";
            }
        }
    </script>

 

 

 

 

 

 

 

 

DOM 프로퍼티와 HTML 속성


  • 브라우저는 HTML을 파싱해서 DOM 객체를 만들 때 HTML 표준 속성을 인식하고, 이 표준 속성
    을 사용해 DOM 프로퍼티를 만듦. 
  • 하지만 비표준 속성은 DOM 프로퍼티로 전환되지 않는데 비표준 속성에도 활용할 수 있는 메소드를 통해 프로퍼티 설정이 가능함.

 

 

    <h3>DOM 프로퍼티와 HTML 속성</h3>
    <p>
        HTML에서 태그는 복수의 속성을 가질 수 있다.<br>
        브라우저는 HTML을 파싱해 DOM 객체를 만들 때 HTML 표준 속성을 인식하고,
        이 표준 속성을 사용해 DOM 프로퍼티를 만든다.<br>
        비표준 속성은 DOM 프로퍼티로 전환되지 않는다.<br>
        비표준 속성에게도 활용할 수 있는 메소드<br>
        element.hasAttribute(name) : 속성 존재 여부 확인<br>
        element.getAttribute(name) : 속성 값을 가져옴<br>
        element.setAttribute(name, value) : 속성 값을 변경함<br>
        element.removeAttribute(name) : 속성 값을 지움
    </p>
    <div id="area8" something="non-standard"></div>
    <script>
        let area8 = document.querySelector("#area8");
        console.log(area8.id);
        // 비표준 속성은 DOM 속성으로 전환되지 않아 undefined
        console.log(area8.something);
        console.log(area8.hasAttribute('something'));
        console.log(area8.getAttribute('something'));
        area8.setAttribute('something', 'modify');
        console.log(area8.getAttribute('something'));
        area8.removeAttribute('something');
        console.log(area8.hasAttribute('something'));
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

9. BOM(Brower Object Model)  (0) 2022.02.21
8. 문서 수정  (0) 2022.02.21
6. DOM(Document Object Model)  (0) 2022.02.18
5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17

 

 

 

 

 

 

DOM(Document Object Model)

 

 

 

 

 

 

 

 

문서객체


  • HTML에 있는 태그를 객체화하여 자바스크립트에서 다룰 수 있게 한 것
  • 모든 노드객체에 접근할 수 있는 요소와 메소드를 제공

 

 

 


노드


HTML에 있는 태그를 구조화(트리)하였을 때 각각의 태그가 노드

 

 

 

 

 


요소노드(elements node)와 텍스트노드(textnode)


  • 요소노드 : 태그 그 자체를 의미
  • 텍스트노드 : 태그에 기록되어 있는 문자
    -> 텍스트 노드를 가지는 태그(h?,p 등)와 가지지않는 태그(img등)가 있다.

 

 

 

 

 

 

 

 

 

DOM 탐색하기(1)


DOM 탐색 프로퍼티

 

 

 

 

 

▼ 코드 예시 보기 ▼
    <h1>DOM(Document Object Model)</h1>
    <p>
        HTML에 있는 태그를 객체화하여 자바스크립트에서 다룰 수 있게 한 것<br>
        모든 노드 객체에 접근할 수 있는 요소와 메소드를 제공한다.<br>
        HTML에 있는 태그를 구조화(트리) 했을 때 각각의 태그가 노드이다.<br>
        - 요소 노드(Elements Node) : 태그 그 자체를 의미한다.<br>
        - 텍스트 노드(Text Node) : 태그에 기록 되어 있는 문자를 의미한다<br>
        * 텍스트 노드를 가지는 태그(h?, p)와 가지지 않는 태그(img 등)가 있음
    </p>
    
    <h1>DOM 탐색하기</h1>
    <h3>documentElement, head, body</h3>
    <script>
        function test1(){
            console.log("===== HTML =====");
            console.log(document.documentElement);
            console.log("===== HEAD =====");
            console.log(document.head);
            console.log("===== BODY =====");
            console.log(document.body);
        }
        test1();
    </script>

 

 

 

자식 노드 탐색


 

 

 

▼ 코드 예시 보기 
    <h3>자식 노드 탐색 : childNodes, firstChild, lastChild</h3>
    <p>
        자식 노드(child node)는 바로 아래 자식 요소를 나타냄<br>
        후손 노드(descendants)는 중첩 관계에 있는 모든 요소를 나타냄
    </p>
    <ul>
        <li><a href="#">링크1</a></li>
        <li><a href="#">링크2</a></li>
        <li><a href="#">링크3</a></li>
    </ul>
    <script>
        function test2(){
            console.log("===== body의 자식 노드들(childNodes) =====");
            console.log(document.body.childNodes);
            console.log("==================================");
            for(let i = 0; i < document.body.childNodes.length; i++) {
                console.log(document.body.childNodes[i]);
            }
            //ul 태그 노드에 접근
            console.log(document.body.childNodes[15].childNodes);
            console.log(document.body.childNodes[15].firstChild);
            console.log(document.body.childNodes[15].lastChild);
        }
        test2();
    </script>

 

 

 

 

 

 

 

 

 

 

형제 노드 탐색


 

 

 

▼ 코드 예시 보기 
    <h3>DOM 컬렉션</h3>
    <p>
        NodeList는 마치 배열 같아 보이지만 배열이 아닌 반복 가능한
        (iterable) 유사 배열 객체인 컬렉션(collection)<br>
        for of 반복문은 사용 가능하지만 배열 메소드는 쓸 수 없다.<br>
        DOM 컬렉션을 읽는 것만 가능하며 childNodes[i] = 값; 을 이용해서
        자식 노드를 교체하는 것이 불가능하다.<br>
        자식 노드 변경을 위해서는 별도의 메소드가 필요하다.
    </p>
    <script>
        // for of 반복문을 사용한 반복
        // for(let node of document.body.childNodes){
        //     console.log(node);
        // }

        // 배열 메소드 사용 불가
        //console.log(document.body.childNodes.pop());
    </script>

    <h3>형제 노드 탐색 : nextSibling, previousSibling</h3>
    <p>
        nextSibling : 다음 형제 노드에 대한 정보<br>
        previousSibling : 이전 형제 노드에 대한 정보
    </p>

 

 

 

 

 

 

 

 

부모 노드 탐색


 

 

 

 

▼ 코드 예시 보기 
    <h3>부모 노드 탐색 : parentNode</h3>
    <script>
        function test3(){
            // head / body 태그의 부모는 html
            console.log(document.head.parentNode);
            console.log(document.body.parentNode);
            // head와 body 사이 개행이 없을 시(text node가 없을 시)
            // 서로가 다음 형제, 이전 형제가 됨
            console.log(document.head.nextSibling);
            console.log(document.body.previousSibling);
        }
        test3();
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

DOM 탐색하기(2)

 

    <h1>요소 간 이동</h1>
    <h3>
        부모 요소 : parentElement<br>
        자식 요소 : children, firstElementChild, lastElementChild<br>
        형제 요소 : nextElementSibling, previousElementSibling
    </h3>
    <p>
        위에서 알아본 탐색 관련 프로퍼티는 모든 종류의 노드(텍스트, 요소)를
        참조하지만 대부분은 요소 노드를 조작하는 작업이므로
        요소 노드만 탐색하는 작업이 필요하다.
    </p>

 

 

 


자식 요소 탐색


 

 

 

형제 요소 탐색


 

 

 

부모 요소 탐색


 

 

 

 

 

 

▼ 코드 예시 보기 
    <script>
        function test4(){
            for(let elem of document.body.children) {
                console.log(elem);
            }
            console.log("======================================");
            console.log(document.body.children);
            console.log(document.body.children[7].firstElementChild);
            console.log(document.body.children[7].lastElementChild);
            console.log(document.body.children[7].firstElementChild.nextElementSibling);
            console.log(document.body.children[7].lastElementChild.previousElementSibling);

        }
        test4();
    </script>

 

 

 

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

8. 문서 수정  (0) 2022.02.21
7. 요소 검색  (0) 2022.02.18
5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17
3. 배열  (0) 2022.02.17

 

 

 

 

 

 

Number객체


 

 

 

 

▼ 코드 예시 보기 ▼
    <h1>숫자 문자 날짜 다루기</h1>
    <h3>숫자 관련 메소드</h3>
    <p>
        isNaN(value) : 인수를 숫자로 변환한 다음 NaN(Not a Number : 에러를 나타내는 값)
        인지 테스트한다.<br> isFinite(value) : 인수를 숫자로 변환하고 변환한 숫자가 
        NaN/Infinity/-Infinity가 아닌 일반 숫자인 경우 true를 반환한다.
    </p>
    <script>
        function test1(){
            console.log("isNaN(NaN) : " + isNaN(NaN));
            console.log("isNaN('abc') : " + isNaN('abc'));
            console.log("isNaN('1') : " + isNaN('1'));
            console.log("isNaN(2.8) : " + isNaN(2.8));

            console.log("isFinite('1') : " + isFinite('1'));
            console.log("isFinite('abc') : " + isFinite('abc'));
            console.log("isFinite(1/0) : " + isFinite(1/0));
            console.log("isFinite(Infinity) : " + isFinite(Infinity));
            console.log("isFinite(-Infinity) : " + isFinite(-Infinity));
        }
        test1();
    </script>

 

 

 

    <p>
        Number()는 문자열 앞 뒤 공백 제외하고
        다른 문자가 섞여 있으면 형변환이 불가능 하다.<br>
        하지만 parseInt/parseFloat를 사용하면
        문자열에서 숫자만 읽고, 읽은 숫자를 에러가 발생하기 전에
        반환해주는 형변환을 사용할 수 있다.<br>
        Ex. "300px", "16pt"
    </p>
    <script>
        function test2(){
            let intNum = "3";
            let floatNum = "1.234";
            let stringNum = "300px";

            console.log("Number(intNum) : " + Number(intNum));
            console.log("Number(floatNum) : " + Number(floatNum));
            console.log("Number(stringNum) : " + Number(stringNum));

            console.log("parseInt(intNum) : " + parseInt(intNum));
            console.log("parseInt(floatNum) : " + parseInt(floatNum));
            console.log("parseInt(stringNum) : " + parseInt(stringNum));

            console.log("parseFloat(intNum) : " + parseFloat(intNum));
            console.log("parseFloat(floatNum) : " + parseFloat(floatNum));
            console.log("parseFloat(stringNum) : " + parseFloat(stringNum));

        }
        test2();
    </script>

 

 

 

 

 

 

 

Math 객체


 

 

 

 

 

 

 

String 객체


 

 

 

 

▼ 코드 예시 보기 
    <h3>문자 관련 메소드</h3>
    <p>
        문자형의 경우 작은 따옴표와 큰 따옴표 모두 사용 가능하며
        또 한 가지는 backtick(`)을 사용할 수 있다.<br>
        백틱은 문자열을 여러줄에 걸쳐 쓸 수 있게 해주고 문자열 중간에
        ${}를 사용해 표현식을 넣을 수 있다.<br>
        문자열 내의 글자를 하나 얻으려면 문자열[위치인덱스]를 사용한다.
    </p>
    <script>
        function test3(){
            // 백틱 사용 시 문자열 여러 줄에 걸쳐 작성 가능하다
            let str = `My
            Name
            is
            Sooyeon`;

            //문자열 중간에 ${}를 사용한 표현식
            console.log('`${str}` : ' + `${str}`);
            console.log("앞의 문장 " + str + " 중간 문장 " + str + " 끝 문장");
            console.log(`앞의 문장 ${str} 중간 문장 ${str} 끝 문장`);

            let num = '0123456789';

            // 문자열 내 글자 하나 추출 : 문자열[인덱스]
            console.log('num[0] : ' + num[0]);
            console.log('num[5] : ' + num[5]);

            // 부분 문자열 얻기
            // substr(start, length)
            console.log('num.substr(5, 5) : ' + num.substr(5, 5));
            // substring(start, end)
            console.log('num.substring(0, 2) : ' + num.substring(0, 2));
            // slice(start, end)
            console.log('num.slice(0, 2) : ' + num.slice(0, 2));

            // 부분 문자열의 위치/여부 알기
            // indexOf : 인덱스의 위치 반환. 없으면 -1 반환
            console.log('num.indexOf(\'9\') : ' + num.indexOf('9')); 
            console.log('num.indexOf(\'a\') : ' + num.indexOf('a')); 

            // includes : 포함 여부 반환. true or false 반환.
            console.log('num.includes(\'9\') : ' + num.includes('9')); 
            console.log('num.includes(\'a\') : ' + num.includes('a')); 

            // startsWith, endsWith : 해당 문자열로 시작하는지/끝나는지 여부 반환.
            // true or false 반환.
            console.log('num.startsWith(\'012\') : ' + num.startsWith('012'));
            console.log('num.startsWith(\'abc\') : ' + num.startsWith('abc'));
            console.log('num.endsWith(\'789\') : ' + num.endsWith('789'));
            console.log('num.endsWith(\'xyz\') : ' + num.endsWith('xyz'));


        }
        //test3();
    </script>

 

 

 

 

 

 

 

Date객체


날짜를 관리하는 객체

 

생성
let date = new Date();
// 현재 날짜 시간

let date = new Date(1234567890);
// milliseconds

let date = new Date(‘2015-05-01‘);
// datestring

let date = new Date(2015, 5-1, 1, 0, 0, 0, 0);
// year, month, date, hours, minute, seconds, ms

 

 

 

 

 

 

Date객체


 

 

 

 

▼ 코드 예시 보기 
    <h3>Date 객체</h3>
    <p>
        날짜와 시간을 나타내는 객체로 월은 0부터 시작하며 
        요일은 0(일요일) ~ 6(토요일)을 나타낸다.<br>
        날짜끼리의 연산도 가능한데 이는 Date가 숫자형으로 바뀔 때 타임스탬프가
        반환 되기 때문이다.<br>
        (타임스탬프 : 1970년의 첫 날을 기준으로 흘러간 밀리초를 나타내는 정수)
    </p>
    <script>
        function test4(){
            // new Date() : 현재 날짜 반환
            let now = new Date();
            console.log(now);

            // new Date(milliseconds)
            // 1970년 1월 1일 0시 0분 0초 기준
            let start = new Date(0);
            console.log(start);
            // 밀리세컨 기준이므로 일*시*분*초*밀리초 => 1년 뒤
            let when = new Date(365 * 24 * 60 * 60 * 1000);
            console.log(when);

            // new Date(datestring)
            let startDate = new Date('2021-12-15');
            console.log(startDate);

            // new Date(year, month, date, hours, minutes, seconds, ms)
            let today = new Date(2022, 2-1, 18);
            let today2 = new Date(2022, 2-1, 18, 10, 28, 50, 100);

            console.log(today);
            console.log(today2);

 

 

            // 년월일시분초 얻기
            console.log(now.getFullYear());         //년
            console.log(now.getMonth() + 1);        //월
            console.log(now.getDate());             //일
            console.log(now.getDay());              //요일
            console.log(now.getHours());            //시
            console.log(now.getMinutes());          //분
            console.log(now.getSeconds());          //초
            console.log(now.getMilliseconds());     //밀리초

 

            // 년월일시분초 설정하기
            let endDate = new Date();
            endDate.setFullYear(2022);
            endDate.setMonth(5-1);
            endDate.setDate(25);
            endDate.setHours(17);
            endDate.setMinutes(50);
            endDate.setSeconds(0);
            endDate.setMilliseconds(0);
            console.log(endDate);

 

            // 날짜 간의 차이 계산
            console.log(endDate - startDate);
            console.log(endDate - now);
            alert("종강일까지 " + (endDate - now)/(24 * 60 * 60 * 1000) + "일 남았습니다ㅠㅠ");

        }
        test4();
    </script>

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

7. 요소 검색  (0) 2022.02.18
6. DOM(Document Object Model)  (0) 2022.02.18
4. 객체  (0) 2022.02.17
3. 배열  (0) 2022.02.17
2. 함수  (0) 2022.02.16

객체

 

 

 

 

객체 선언 / 호출


  • 객체는 키 값을 사용하여 속성(멤버 변수) 식별
  • 중괄호를 사용하여 객체 생성
  •  ‘[ ](대괄호)’ 또는 ‘.’(점)으로 요소의 값에 접근
  • 속성에 모든 자료형이 올 수 있다. 그 중 함수 자료형인 요소:메소드
  • 객체 내에서 자신의 속성을 호출 할 때 반드시 this키워드를 사용
  • 객체의 모든 속성을 출력하려면 for in문을 사용해야 한다.
    -> 단순 for문이나 while문으로 출력 불가
  • 식별자로 사용할 수 없는 문자(띄어쓰기, 특수문자)를 속성으로 사용할 경우 ‘ ‘로 묶어서
    선언하고, 접근 시에는 [ ]만 가능

 

 

 

 

 

 

 

선언하는 방법


    let 변수명(객체명) = {
            속성(키값) : 값,
            속성(키값) : 값,
            속성(키값) : 값
    };



 

 

 


속성값 접근


    변수명(객체명)[‘요소명(키값)’];
    변수명(객체명)[‘요소명(키값)’];
    	또는
    변수명(객체명).요소명(키값);
    변수명(객체명).요소명(키값);

 

 

 

 

▼ 코드 예시 보기 ▼ 
    <h1>객체</h1>
    <p>
        다른 자료형은 오직 하나의 데이터만 담을 수 있는 원시형(primitive type)이지만
        객체는 다양한 데이터를 담을 수 있다.
    </p>
    <h3>객체 선언 및 호출</h3>
    <p>
        객체는 프로퍼티(키-값 쌍)를 저장하며
        키 값을 사용하여 속성을 식별한다.<br>
        키는 문자열이며 속성에는 모든 자료형이 올 수 있다.<br>
        객체 생성자 또는 중괄호 {} 를 사용하여 객체를 생성한다.
    </p>

 

    <script>
        function test1(){
            // 객체 생성자 호출
            let obj = new Object();
            // 객체 리터럴 선언
            let obj2 = {};

            let product = {
                // 키-값 쌍으로 구성 된 프로퍼티
                pName : 'Dry Mango',
                origin : 'Philippines',
                price : 10000,
                ingredient : ['mango', 'sugar']
            };

            console.log("===== product =====");
            console.log(product);

            console.log('객체명.속성명으로 접근');
            console.log('product.pName : ' + product.pName);
            console.log('product.origin : ' + product.origin);
            console.log('product.price : ' + product.price);
            console.log('product.ingredient : ' + product.ingredient);
            console.log('product.ingredient[0] : ' + product.ingredient[0]);
            console.log('product.ingredient[1] : ' + product.ingredient[1]);

            console.log("객체명['속성명']으로 접근");
            console.log("product['pName'] : " + product['pName']);
            console.log("product['origin'] : " + product['origin']);
            console.log("product['price'] : " + product['price']);
            console.log("product['ingredient'] : " + product['ingredient']);
            console.log("product['ingredient'][0] : " + product['ingredient'][0]);
            console.log("product['ingredient'][1] : " + product['ingredient'][1]);
        }
        //test1();
    </script>

 

 

    <h3>객체의 키 식별자 테스트</h3>
    <p>
        객체의 키는 모든 문자열을 사용할 수 있다.<br>
        단, 식별자로 사용할 수 없는 단어를 키로 사용하거나
        변수를 키로 사용하는 경우 무조건 대괄호를 사용해야 객체의 요소에
        접근할 수 있다.
    </p>
    <script>
        function test2(){
            let objTest = {
                'hello world' : 'Hello World!!!',
                '!@#$%^&*()' : 1234567890,
                test : true
            };

            // 변수에 담긴 key 값
            let key = "test";

            console.log("===== objTest =====");
            console.log(objTest);

            console.log("객체명.속성명 접근 불가");
            //console.log(objTest.'hello world');
            //console.log(objTest.'!@#$%^&*()');
            console.log(objTest.key);

            console.log("객체명['속성명']으로 접근 가능");
            console.log(objTest['hello world']);
            console.log(objTest['!@#$%^&*()']);
            console.log(objTest[key]);
        }
        test2();
    </script>

 

 

    <h3>상수 객체는 수정 가능</h3>
    <p>
        상수 배열/객체의 속성은 변경 가능하나
        상수 배열/객체를 다시 할당할 수는 없다.
    </p>
    <script>
        function test3(){
            const student = {name: '배산임수', age : 20};
            console.log(student);
            // 해당 객체에서 속성 값 변경은 가능하다
            student.age = 30;
            console.log(student);

            // 새로운 객체 재할당은 불가능하다
            student = {name : '배산임수', age : 40};
        }
        test3();
    </script>

// 새로운 객체 재할당은 불가능하다

 

 

 

 

 

 

 

 

 

 

 

 

 

객체 속성 추가 및 삭제


속성 및 메소드를 동적으로 추가 및 삭제 가능

 

 

추가
변수명(객체명).속성명 = ‘값’;
변수명(객체명).속성명 = ‘값’;
변수명(객체명).속성명 = function(){
    메소드 로직;
    [return [리턴값]];
    };

 

삭제
delete(변수명(객체명).속성명);

 

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>객체의 속성 추가와 제거</h3>
    <p>
        처음으로 객체 생성한 이후 속성을 추가하거나 제거하는 것을
        동적으로 속성을 추가한다 혹은 제거한다 라고 한다.
    </p>
    <script>
        function test4(){
            // 빈 객체 선언
            let student = {};
            console.log(student);

            // 객체에 속성을 추가
            student.name = "유관순";
            student.hobby = '게임';
            student.strength = '프로그래밍';
            student.dream = '개발자';

            console.log(student);

            // 객체 속성 제거
            delete(student.hobby);
            console.log(student);
        }
        //test4();
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

함수 활용 객체 생성


함수의 매개변수에 필요한 속성값을 다 받아서 객체를 생성 후 리턴

 

// 함수 활용 객체 생성


    function 함수명(value1, value2, value3, ....){
    	let 변수명(객체명) = {
                속성명:‘value1’,
                속성명:‘value2’,
                ....
     		   }
       			 return 변수명(객체명);
      			  }

 

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>함수 활용한 객체 생성</h3>
    <script>
        // function makeStudent(name, score){
        //     let student = {
        //         name : name,
        //         score : score
        //     };
        //     return student;
        // }

        function makeStudent(name, score){
            return {
                // 단축 프로퍼티
                name,   // name : name
                score   // score : score
            };
        }

        console.log(makeStudent('배산임수', 100));
    </script>

 

 

 

 

 

 

 

 

 

 

 

in with 키워드 / for in 문


 

 in

객체 내부에 해당 속성이 있는지 확인하는 키워드

속성명 in 변수명(객체명)   // 있으면 true, 없으면 false

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>in 키워드</h3>
    <p>
        in : 객체 내부에 해당 속성이 있는지 확인하는 키워드
    </p>
    <script>
        function test5(){
            let student = {
                name : '우별림',
                kor : 100,
                eng : 80,
                math : 90,
                test : undefined
            };

            console.log('student 객체에 name 속성이 있는지 확인 : ' + ('name' in student));
            console.log('student 객체에 kor 속성이 있는지 확인 : ' + ('kor' in student));
            console.log('student 객체에 eng 속성이 있는지 확인 : ' + ('eng' in student));
            console.log('student 객체에 math 속성이 있는지 확인 : ' + ('math' in student));
            console.log('student 객체에 sum 속성이 있는지 확인 : ' + ('sum' in student));
            console.log('student 객체에 test 속성이 있는지 확인 : ' + ('test' in student));

            // 값이 undefined인 속성은 in 연산자로 확인하는 것이 정확하다
            console.log('student.name : ' + student.name);
            console.log('student.sum : ' + student.sum);
            console.log('student.test : ' + student.test);

        }
        test5();
    </script>

 

 

 

 

 

 

 

for in문 

객체의 속성에 순차적으로 접근하는 반복문

for(let key in 객체명) {
     // key : 속성 키, 객체명[key] : 속성 값
     }

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>객체와 반복문</h3>
    <p>
        객체의 속성을 살펴볼 때에는 단순 for문으로는 사용 불가능하고
        for in문을 사용해야 한다.
    </p>
    <script>
        function test6(){
            let game = {
                title : 'DIABLO 3',
                price : 35000,
                language : '한국어지원',
                supportOS : 'windows 32/64',
                service : true
            };

            console.log(game);
            console.log("===== 반복문 동작 ======");

            for(let key in game){
                console.log(key + " : " + game[key]);
            }



        }
        test6();
    </script>

 

 

 

 

 

 

 

 

 

 

 

객체의 메소드 속성


  • 객체의 속성에 저장 된 함수를 메소드라고 하며 객체명.메소드()와 같은 형식으로 사용한다.
  • 메소드는 this로 객체를 참조한다.
let 객체명 = {
    속성명 : function(){
        // this.속성명으로 참조
        },
  	  속성명(){} // 단축해서 사용 가능
    }
    
    객체명.속성명 = function(){};
    // 동적 추가
    객체명.속성명 = 선언 된 함수;
    // 선언 된 함수 추가도 가능

 

 

 

 

▼ 코드 예시 보기 ▼ 
<h3>객체의 메소드 속성</h3>
<p>
    객체의 속성에 저장 된 함수를 메소드라고 하며
    객체명.메소드() 와 같은 형식으로 사용된다.<br>
    메소드는 this로 객체를 참조한다.
</p>
<script>
    function test7(){
        let name = "뽀삐";
        let dog = { name : "박카스" };

        // 함수 표현식으로 함수를 만들고 객체 속성 dog.eat에 할당
        // => 메소드로 등록한다
        dog.eat = function(food){
            console.log(name + "가 " + food + "를 먹고 있네요.");
            // 객체 내에서 자신의 속성을 호출할 때는 반드시 this를 사용
            console.log(this.name + "가 " + food + "를 먹고 있네요.");
        };

        // 메소드 호출
        dog.eat("고구마");

        // 선언 된 함수 메소드로 등록
        dog.walk = walk;

        // 메소드 호출
        dog.walk("테헤란로");


        let human = {
            name : '배산임수',
            //eat : function(){}
            // 메소드 단축 구문
            eat(food){
                console.log(this.name + "이 " + food + "를 먹고 있어요.");
                
                // this를 사용하지 않고 외부 변수를 참조해서 객체에 접근
                // 가능하기는 하지만 변수명이 변경 되는 상황 등이 있을 수
                // 있으므로 항상 this로 참조하자
                //console.log(human.name + "이 " + food + "를 먹고 있어요.");
            }
        };

        human.eat("짬뽕");

        // 외부 변수 참조 시 발생할 수 있는 문제
        let person = human;
        human = null;
        person.eat('닭가슴살 샐러드');

    }

    // 선언 된 함수
    function walk (place) {
        console.log(this.name + "가 " + place + "를 산책하고 있네요.");
    }

    //test7();
</script>

 

 

 

 

 

 

 

 

 

 

 

생성자 함수


  • this키워드를 사용하여 속성을 생성하는 함수
  • new라는 키워드를 사용하여 객체 생성
  • 생성자명의 첫 글자는 대문자로 시작

 

function 생성자명(value1, value2, value3, ....){
            this.속성명=‘value1’,
            this.속성명=‘value2’,
            ....
            }
        }

 

 

 

 

 

 

 

객체 배열 활용


생성된 객체를 배열에 넣어 활용 가능

 

let 변수명 = [ ]; //배열 생성

 

데이터 대입
    변수명.push({속성명:’값’,속성명:’값’ ,속성명:’값‘,…});
    변수명.push({속성명:’값’,속성명:’값’ ,속성명:’값‘,…});
    변수명.push({속성명:’값’,속성명:’값’ ,속성명:’값‘,…});

 

 

 

 

▼ 코드 예시 보기 ▼ 
<h3>생성자 함수</h3>
<p>
    유사한 객체를 여러 개 만들어야 할 때 생성자 함수를 사용한다.<br>
    생성자 함수와 일반 함수는 기술적으로 다르지 않지만
    함수 이름의 첫 글자는 대문자로 시작하고 new 연산자를 붙여
    실행한다는 규칙이 있다.
</p>
<script>
    // 생성자 함수 정의
    function Student(name, java, oracle, html, css, javascript){
        // new 연산자와 함께 호출했을 경우
        // this = {}; => 빈 객체가 암시적으로 만들어짐

        // 속성 정의
        this.name = name;
        this.java = java;
        this.oracle = oracle;
        this.html = html;
        this.css = css;
        this.javascript = javascript;

        // 메소드 정의
        // 성적 합계 리턴 메소드
        this.getSum = () => this.java + this.oracle + this.html + this.css + this.javascript; 

        // 성적 평균 리턴 메소드
        this.getAvg = () => this.getSum() / 5;

        // new 연산자와 함께 호출했을 경우
        // return this; => this가 암시적으로 반환 됨
    }

    function test8() {
        // 생성자 함수 호출하여 객체 생성
        let student1 = new Student("홍길동", 100, 90, 80, 70, 60);
        console.log(student1);
        console.log("student1 점수 합계 : " + student1.getSum());
        console.log("student1 점수 평균 : " + student1.getAvg());

        let student2 = new Student(prompt("이름 입력"),
                                   Number(prompt('java 점수 입력')),
                                   Number(prompt('oracle 점수 입력')),
                                   Number(prompt('html 점수 입력')),
                                   Number(prompt('css 점수 입력')),
                                   Number(prompt('javascript 점수 입력')));

        console.log(student2);
        console.log("student2 점수 합계 : " + student2.getSum());
        console.log("student2 점수 평균 : " + student2.getAvg());
    
        // 배열 선언
        let students = [];

        // 배열에 객체 담기
        students.push(student1, student2);

        // 객체 배열 출력
        console.log(students);
    
    }
    //test8();
</script>

 

 

 

 

<h3>find와 findIndex</h3>
<p>
    객체 배열을 대상으로 특정 조건이 부합하는 객체를
    배열 내에서 검색할 수 있다.<br>
    배열 요소를 대상으로 함수가 순차적으로 호출 된다.<br> 

    let 변수 = 배열.find/findIndex(function(item, index, array){ <br>
        // true가 반환 되면 반복이 멈추고 해당 요소를 반환/해당 요소의 인덱스 반환<br>
        // 조건에 해당하는 요소가 없으면 undefined를 반환 <br>
    });
</p>
<h3>filter</h3>
<p>
    find/findIndex는 처음 true가 반환 된 하나의 요소만 반환 가능하므로
    조건을 충족시키는 요소가 여러 개라면 filter 메소드를 사용한다.<br>
    문법은 유사하지만 조건에 맞는 요소 전체를 담은 배열을 반환한다.
</p>
<script>
    function test9(){
        let students = [ new Student("수지", 100, 90, 95, 85, 80),
                         new Student("제니", 70, 80, 90, 75, 60),
                         new Student("유아", 80, 65, 55, 90, 90)];
    
        // 제니라는 이름을 가진 학생 찾기
        let jennie = students.find(item => item.name == '제니');
        console.log(jennie);

        // 별림이라는 이름을 가진 학생 찾기
        let byeollim = students.find(item => item.name == '별림');
        console.log(byeollim);

        // java 점수가 90점 이상인 학생의 인덱스 찾기
        let java = students.findIndex(item => item.java >= 90);
        console.log(java);

        // oracle 점수가 60점 미만인 학생의 인덱스 찾기
        let oracle = students.findIndex(item => item.oracle < 60);
        console.log(oracle);

        // 평균 점수가 70점대인 학생 인덱스 찾기
        // 조건에 해당하는 학생은 2명이지만 처음 true가 반환 된
        // 요소만 반환하므로 고유값에 사용하는 것이 적절
        //let avg70 = students.findIndex(item => item.getAvg() >= 70 && item.getAvg() < 80);
        
        // filter를 사용해서 수정
        let avg70 = students.filter(item => item.getAvg() >= 70 && item.getAvg() < 80);
        console.log(avg70);

        
    }
    test9();
</script>

 

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

6. DOM(Document Object Model)  (0) 2022.02.18
5. 숫자/문자/날짜 다루기  (0) 2022.02.18
3. 배열  (0) 2022.02.17
2. 함수  (0) 2022.02.16
1. 기본 문법  (0) 2022.02.15

 

 

배열

 

 

 

 

 

 

배열이란


  •  다양한 타입의 데이터를 보관하는 변수의 모음
  • ‘[ ]’(대괄호)를 통해 생성과 초기화를 동시에 처리 가능
  • 자료형 지정이 없어 모든 자료형(숫자, 문자열, 함수, Boolean, undefined, 객체)이다. 데이터로 저장가능(자바의 컬렉션과 비슷)
let 변수명 = [ 값1(숫자), 값2(문자), 값3(객체), 함수 … ] ;

 

 

 

▼ 코드 예시 보기 ▼ 
    <h1>배열</h1>
    <h3>배열이란?</h3>

    <p>
         자바 스크립트에서는 "모든 자료형"을 보관하는 변수의 모음을 배열로 처리한다. <br>
         자바에서의 컬렉션과 유사하다.
    </p>

    <script>
        function test1() {
            let arr = ['홍길동', 20, true, [1, 2, 3, 4]];

            // 배열출력
            console.log(arr);

            // 문자열과 더해지면서 toString()호출하여
            // "," 기준으로 합쳐진 문자열이 반환됨
            console.log('arr : ' + arr);
            console.log(arr.length);

            //인덱스로 접근
            console.log(arr[0]);
            console.log(arr[1]);
            console.log(arr[2]);
            console.log(arr[3]);
            

            // 배열 안의 배열 인덱스 접근
            console.log(arr[3][0]);
            console.log(arr[3][1]);
            console.log(arr[3][2]);
            console.log(arr[3][3]);

        }

       // test1();
        
    </script>

 

 

 

 

 

 

 

 

 

 

 

배열 선언


  • new연산자와 Array객체를 통한 배열 선언
  • 배열 크기 정하지 않고 선언 / 배열 크기를 정하는 선언

 

배열의 크기를 정하지 않는 배열 선언
let 변수명 = new Array();



배열의 크기를 정한 배열 선언
let 변수명 = new Array(개수);



 

 

▼ 코드 예시 보기 ▼ 
    <h3>배열의 선언</h3>

    <p>
        배열 선언 시 배열의 크기를 정하거나,
        정하지 않고 선언할 수 있다. 
    </p>

    <script>

        function test2() {
            //new Array()로 배열생성
            let arr1 = new Array();
            let arr2 = new Array(3);

            // 배열 출력
            console.log(arr1);
            console.log(arr2);

            // 배열 길이 출력
            console.log(arr1.length);
            console.log(arr2.length);

            // 배열길이가 101이 된다.
            // length는 요소 내 개수가 아니라 가장 큰 인덱스에
            // 1을 더한 값이 된다.
            // 즉 마지막 배열 + 1 = length
            arr2[100] = '테스트';
            console.log(arr2);
            console.log(arr2.length);

            // length에 0을 기록하면 값 삭제도 가능하다.
            arr2.length = 0;
            console.log(arr2);


            // 배열에 값 대입
            arr1[0] = '바나나';
            arr1[1] = '복숭아';
            arr1[2] = '키위';

            console.log(arr1);

            // new 연산자 활용한 초기화
            let arr3 = new Array('홍길동', '임꺽정', '신사임당');
            console.log(arr3);

            // 대괄호를 활용한 초기화
            let arr4 = ['java', 'oracle', 'html5', 'css3'];
            console.log(arr4);



        }

        test2();

    </script>

 

 

 

 

 

 

 

 

 

 

 

배열 초기화


  • new연산자를 활용한 초기화

 

  • ‘[ ]’를 활용한 초기화

 

 

 

 

 

 

 

 

배열에 값 대입


  • 값을 입력 시에 index번호 활용
  • 번호 범위 : 0 ~ (지정한 크기-1)

 

배열에 값 대입

 

변수에 배열 값 대입

 

 

 

 

 

 

배열 순회


 

  • 일반 for문

 

  • for of문

 

 

 

 

▼ 코드 예시 보기 ▼ 
<h3>배열 순회</h3>
<p>
    일반 for문, for of문 등을 사용할 수 있다. 
</p>

<script>

    function test3() {
        let arr = ['java', 'oracle', 'html5', 'css3', 'javascript'];

        //for문 이용
        for (let i = 0; i < arr.length; i++) {
            console.log(arr[i]);
        }

        // for of 문 이용 - 자바에서의 향상 for
        for(let subject of arr) {
            console.log(subject);
        }



    }

    test3();
</script>

 

 

 

 

 

 

 

 

 

 

Array객체 메소드


  • 요소 추가/제거

 

 

 

 

 

▼ 코드 예시 보기 ▼ 

<h3>배열 객체의 메소드</h3>
<p>
    배열도 하나의 객체이기 때문에 
    배열에서 활용할 수 있는 메소드들이 있다.
</p>

<h3>요소 추가/제거</h3>
<h4>push : 배열의 맨 뒤에 요소 추가
    , pop : 배열의 맨 뒤에 요소 제거</h4>
<script>
    function test4 () {
        let arr = ['짜장면', '짬뽕', '우동'];

        console.log('push 전 arr : ' + arr);

        //arr.push('탕수육');
        //arr.push('양장피');
        arr.push('탕수육', '양장피');

        console.log('push 후 arr : ' + arr);

        console.log('arr.pop() : ' + arr.pop());
        console.log('arr.pop() : ' + arr.pop());
        console.log('arr.pop() : ' + arr.pop());

        console.log('pop 후 arr : ' + arr);
    }
    //test4();
</script>

 

<h4>shift : 배열의 맨 앞 요소 제거 후 반환,
    unshift : 배열의 맨 앞에 요소 추가
</h4>
<script>
    function test5 () {
        let arr = ['양념치킨', '후라이드', '파닭'];

        console.log('unshift 전 arr : ' + arr);

        //arr.unshift('간장치킨');
        //arr.unshift('마늘치킨');
        arr.unshift('간장치킨', '마늘치킨');

        console.log('unshift 후 arr : ' + arr);

        console.log('arr.shift() : ' + arr.shift());
        console.log('arr.shift() : ' + arr.shift());
        console.log('arr.shift() : ' + arr.shift());

        console.log('shift 후 arr : ' + arr);
    }

    //test5();

 

<h4>slice : 배열의 요소 선택 잘라내기,
    splice : 배열의 index 위치의 요소 제거 및 추가
</h4>
<script>
    function test6(){
        let arr = ['Java', 'HTML', 'CSS', 'JavaScript'];
        console.log('arr : ' + arr);
    
        // slice(시작 인덱스, 종료 인덱스)
        // 원본 배열에 영향을 미치지 않음
        console.log('arr.slice(2, 4) : ' + arr.slice(2, 4));
        console.log('arr : ' + arr);

        // splice(index, 제거수, 추가값1, 추가값2, ...)
        // 제거 된 값을 리턴하며 원본 배열에 영향을 미침
        console.log('arr.splice(2, 1, "Servlet") : ' + arr.splice(2, 1, "Servlet"));
        console.log('arr : ' + arr);
    }

    test6();
</script>

 

 

 

<h4>concat : 두 개 이상의 배열을 결합</h4>
<script>
    function test7 () {
        let arr1 = ['아이유', '블랙핑크', '오마이걸'];
        let arr2 = ['트와이스', '에스파'];

        // 배열명.concat(배열명1, 배열명2, ...)
        let arr3 = arr1.concat(arr2);
        let arr4 = arr2.concat(arr1, arr3);

        console.log('arr1 : ' + arr1);
        console.log('arr2 : ' + arr2);
        console.log('arr1 기준으로 arr2 배열을 합친 arr3 : ' + arr3);
        console.log('arr2 기준으로 arr1, arr3 배열을 합친 arr4 : ' + arr4);
    }

    test7();
</script>

 

 

 

 

 

 

 

 

 

 

 

forEach() 메소드


 

-> 배열변수.forEach(function(item, index, array){
    // 배열 요소 각각에 실행할 기능 작성
    });

 

  • item : 처리할 현재 요소
  • index: 처리할 현재 요소의 인덱스
  • array: forEach()를 호출한 배열

 

 

 

▼ 코드 예시 보기 ▼ 
<h3>배열 forEach</h3>
<p>
    배열.forEach(function(item, index, array){
        // 배열 요소 각각에 실행할 기능 작성
    });
</p>
<script>
    function test8 () {
        let arr = [1, 2, 3, 4, 5];

        arr.forEach(function(item, index, array){
            console.log(item + " " + index + " " + array);
        });

        // 각 요소 별로 * 10 한 값을 콘솔에 출력
        arr.forEach(item => console.log(item * 10));

    }
    test8();
</script>

 

 

 

 

 

 

 

 

 

 

 

 

 

Array객체 메소드


  • 배열 탐색/배열 변형

 

 

 

 

▼ 코드 예시 보기 ▼ 
<h3>배열 탐색</h3>
<h4>indexOf : 배열에서 요소가 위치한 인덱스를 리턴,
    lastIndexOf : 배열의 요소가 위치한 마지막 인덱스를 리턴,
    includes : 배열에 해당 요소 포함 여부 리턴
</h4>
<script>
    function test9 () {
        let arr = ['물회', '삼계탕', '냉면', '수박', '물회'];

        console.log("arr.indexOf('물회') : " + arr.indexOf('물회'));
        console.log("arr.indexOf('물회', 1) : " + arr.indexOf('물회', 1));
        console.log("arr.indexOf('삼겹살') : " + arr.indexOf('삼겹살'));

        console.log("arr.lastIndexOf('물회') : " + arr.lastIndexOf('물회'));
        console.log("arr.lastIndexOf('삼겹살') : " + arr.lastIndexOf('삼겹살'));

        console.log("arr.includes('물회') : " + arr.includes('물회'));
        console.log("arr.includes('삼겹살') : " + arr.includes('삼겹살'));
    }
    test9();
</script>

 

 

<h3>배열 변형</h3>
<p>
    map : 배열 요소 전체를 대상으로 함수 호출 후 결과 배열로 반환
</p>
<p>
    배열.map(function(item, index, array){
        // 배열 요소 각각에 반환할 새로운 값
    });
</p>
<script>
    function test10(){
        let types = [true, 1, 'text'].map(item => typeof item);
        console.log(types);

        let lengths = ['apple', 'banana', 'cat', 'dog', 'egg'].map(item => item.length);
        console.log(lengths);
    }
    test10();
</script>

 

 

<h4>sort : 배열을 정렬 기준으로 정렬, reverse : 배열의 순서를 뒤집음</h4>
<p>
    * sort, reverse 수행 시 원본 데이터의 순서 자체가 변함
</p>
<script>
    function test11 () {
        let arr = [];

        for(let i = 0; i < 10; i++) {
            arr[i] = Math.floor(Math.random() * 100) + 1;
        }

        console.log('정렬 전 arr : ' + arr);

        // 오름차순 정렬이 기본이며 정렬 후 정렬 순서를 유지함
        // 배열은 기본적으로 문자열 정렬이 되므로 한자리수, 세자리수가
        // 올바르지 않게 정렬 되는 모습을 확인할 수 있음
        // => 다른 정렬 기준을 사용하려면 매개변수로 compare 함수 전달
        arr.sort();
        console.log('정렬 후 arr : ' + arr);

        // 숫자 오름차순 정렬
        arr.sort(compare);
        console.log('매개변수로 compare 함수 전달하여 숫자 오름차순 정렬');
        console.log(arr);

        // 숫자 내림차순 정렬
        // arr.sort(function(a, b){
        //     return b - a;
        // });
        arr.sort((a, b) => b - a);

        console.log('숫자 내림차순 정렬');
        console.log(arr);

        arr.reverse();
        console.log('reverse 호출 후 arr : ' + arr);

    }

    function compare(a, b) {
        if(a > b) return 1; // a와 b 순서 바꿈
        if(a == b) return 0;
        if(a < b) return -1; // a와 b 순서 안바꿈
    }

    //test11();
</script>

 

 

 

<h4>split : 문자열 구분자로 잘라 배열로 반환,
    join : 배열을 구분자로 결합하여 문자열로 반환
</h4>
<script>
    function test12(){

        let arr = ['사탕', '초콜렛', '껌', '과자'];
        console.log(arr);
        console.log('arr.join() : ' + arr.join());
        console.log('arr.join("/") : ' + arr.join("/"));

        let str = arr.join("*");
        console.log(str);
        console.log('str.split("*") : ' + str.split("*"));
        console.log(str.split("*"));

    }

    test12();
</script>

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17
2. 함수  (0) 2022.02.16
1. 기본 문법  (0) 2022.02.15
0. 개요  (0) 2022.02.15

 

 

함수

 

 

 

 

 

 

함수(function)란


  • 소스코드의 집합으로 메소드, 모듈, 기능, 프로시져 등을 말한다.
  • 자바스크립트에서는 function 자료형이다
  • 함수는 인자/매개변수, 리턴 값을 가질 수 있다.

 

 

 

 

 

 

 

함수 선언


  • 반환 값 선언 없이 function 키워드만 이용하여 사용
  • function키워드에 함수 명을 작성하여 사용하는 방법(함수 선언문)과 function에 함수 명 작
    성하지 않고 변수에 대입하는 방법(함수 표현식)이 있음

 

 

 

 

function에 함수명 작성 방법(함수 선언문)
        function 함수명([매개변수]){
            처리 로직
            [return 되돌려줄 값;]
        }

 

 

function에 함수명 작성하지 않고 변수에 대입(함수 표현식)
    let f1=function([매개변수]){
        처리 로직
        [return 되돌려줄 값]
        }

 

 

 

 

▼ 코드 예시보기 ▼
    <h1> 함수(Function) </h1>
    <h3> 함수선언 (Function Declaration)과 호출 </h3>
    <p>
    메소드도 함수이기는 하지만 그 중 클래스에 정의된 것을 메소드라고 한다.
    </p>

    <script>
        // function키워드 + 변수명 + (매개변수) + {중괄호}
        function test1() {}

        //다음과같이 선언
        // function 키워드 선언후 반환형은 기재하지않는다.
        function test1() {
            //함수 본문 작성
            alert('test1 함수실행!');
        }

        //선언된 함수 호출하는 법
        test1();

    </script>

 

 

<h3> 변수 범위 </h3>

    <script>
    function test2 () {
        let local='local';
    }

    //Uncaught ReferenceError: local is not defined
    // => 지역변수는 함수 외부에서 접근 불가
    //console.log('test2 밖의 local : ' + local);


    // 외부에서 지역변수로의 접근은 불가능하지만
    // 지역변수에서 외부인 전역변수로의 접근은 가능하다.
    // 즉, 밖에서 안을 참조할 수는 없지만 안에서 밖은 가능하다.
    let outer = 'outer';

    function test3 () {
        console.log('test3 안의 outer : ' + outer);
        outer = 'changed outer';
    }

    test3();
    // test3 안의 outer : outer

    // 접근 뿐 아니라 수정도 가능
    console.log('test3 호출 후 outer : ' + outer);
    // test3 호출 후 outer : changed outer

    // 같은 이름을 가진 지역 변수와 외부 변수가 있을 경우
    // 우선순위는 지역 변수가 높다.
    let test = 'outer';

    function test4(){
        let test = 'local';
        console.log('test4 안의 test : ' + test);
    }

    test4();
    // test4 안의 test : local
    console.log('test4 밖의 test : ' + test)
    // test4 밖의 test : outer
    
    </script>

 

 

 

 

 

 

 

 

 

함수 호출


  • 함수는 반드시 선언(정의)가 되어야 만 실행가능
  • 원하는 기능에 대한 함수를 호출하는 것 -> 함수 실행
  • return값이 있으면 리턴 값을 받을 변수가 있어야 한다.

 

return값이 없는 경우
함수명(); / 함수명(인자값1,인자값2 ...);

 

 

return 값이 있는 경우
let 변수명 = 함수명();
let 변수명 = 함수명(인자값1,인자값2 ...);

 

 

 

 

 

 

 

 

매개변수(전달인자)


  • 호출하는 코드와 호출되는 함수를 연결해주는 변수는 매개 변수라 한다.
  • 지정된 매개변수보다 많은 개수 선언하고 호출하는 것을 허용
    -> 초과되는 매개변수는 무시
  • 지정된 매개변수보다 적게 선언하고 호출하는 것도 허용
    -> 선언이 안된 매개변수는 undefined로 자동 설정 된다.

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>함수의 매개변수</h3>
    <script>
        function test5(value = "no value") {
            /* 자바스크립트 함수는 타입을 지정하지않고
            변수명만 작성하는 것에 유의한다. */
            console.log('입력 된 메세지 : ' + value);
        }

        // 호출
        test5(prompt("메세지를 입력하세요"));
        입력 된 메세지 : 123456

        // 지정된 매개변수보다 많은 개수를 전달하여서
        // 호출하는 것도 가능하다. 단, 초과 된 전달인자는 무시된다.
        // test5('안녕하세요', '반갑습니다');


        // 값을 전달하지않았을때 = 값을 정의하지않음 = undefined
        // 지정된 매개변수보다 적은 개수를 전달하며 호출하는 것도
        // 가능하다. 단, 전달 되지않은 값은 undefined로 자동 설정
        test5();
        // 입력 된 메세지 : undefined (디폴트 x)
        // 입력 된 메세지 : no value (디폴트 o)

        // (value = "no value") 는 아무값도 입력되지않았을때를 대비한
        // 디폴트값이다. 즉 매개변수 선언 시 기본값 설정도 가능하다.

    </script>

 

 

 

 

 

 

 

 

 


return [되돌려줄 값]


  • return은 함수를 호출한 위치로 돌아가라는 의미
  • return값(되돌려줄 값)을 지정하지 않으면 undefined 자료형으로 반환된다.

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>함수의 반환형</h3>
    <script>

        // return 문이 없거나
        // return 지시자만 있는 함수는 undefined를 반환

        // 1~100 사이의 랜덤 값을 반환하는 함수
        function returnFunction(){
            return Math.floor(Math.random() * 100) + 1;
        }

        function test6(){
            for(let i = 1; i <= 10; i++) {
                let random = returnFunction();
                console.log('random' + i + " : " + random);
            }
        }

        test6();
    </script>

 

 

 

 

 

 

 

 

 

 

 

콜백함수(매개변수 함수)


  • 다른 함수에게 매개변수로 넘겨준 함수
  • 함수도 하나의 자료형으로 매개변수로 전달 가능

 

    function 함수명(매개변수명){
        매개변수명(); //호출;
        }

 

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>함수 표현식(Function Expression)</h3>
    <script>
        // 함수를 생성하고 변수에 값을 할당하는
        // 것처럼 함수가 변수에 할당
        let test7 = function () {
            alert('함수 표현식!');
        };

        // 자바스크립트에서 함수는 값
        console.log(test7);

        // 함수 호출 시 변수명에 () 붙여서 호출
        //test7();

        // 함수 복사
        let copy = test7;
        // 복사한 함수 실행
        //copy();
    </script>

    <h3>콜백 함수</h3>
    <script>
        function test8(func1, func2){
            let name = func1();
            let age = func2();

            console.log('이름 : ' + name + ", 나이 : " + age);
        }

        function question1(){
            return prompt("당신의 이름은 무엇입니까?");
        }

        function question2(){
            return prompt("당신의 나이는 몇 살입니까?");
        }

        // 함수 question1과 question2를 test8 함수로 전달
        // test8(question1, question2);

        // 함수 표현식으로 작성한다면
        //test8(function(){return prompt("당신의 이름은 무엇입니까?")},
        //function(){return prompt("당신의 나이는 몇 살입니까?")});

    </script>

 

 

 

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>함수 선언문과 함수 표현식의 차이</h3>
    <script>

        // 선언문 위에서도 호출 가능
        // 전역 함수는 스크립트 실행 전 초기화 단계에서 생성 되고
        // 실행문은 함수 선언문이 모두 처리 된 후에 실행되므로
        // 스크립트 내 어디에서든 호출 가능함
        //test9();

        // 함수 선언문
        function test9 (){
            alert('함수 선언문으로 선언 된 함수!');
        }

        // 함수 표현식으로 선언 된 함수는 스크립트 실행
        // 흐름이 진행 될 때 생성 되므로 아직 생성 되지 않아
        // 호출할 수 없음
        //test10();

        // 함수 표현식
        let test10 = function () {
            alert('함수 표현식으로 생성 된 함수!');
        }
    </script>

함수 표현식으로 선언 된 함수는 흐름이 진행 될 때 생성 되므로 아직 생성 되지 않아호출할 수 없음

 

 

 

 

 

 

 

 

 

 

화살표 함수


function 키워드, return 키워드중괄호를 생략한 함수 표현식 작성을 위한 짧은 구문을 허용하는 함수

 

함수명 = (매개변수) => 실행문;

 

 

 

▼ 코드 예시 보기 ▼ 
    <h3>화살표 함수</h3>
    <p>
        화살표 함수는 function 키워드, return 키워드 및 중괄호를
        생략한 함수 표현식 작성을 위한 짧은 구문을 허용한다.
    </p>
    <script>
        let hello;

        // 기존 function 정의
        hello = function () {
            return "Hello World!";
        };

        console.log(hello());

        // function 키워드 생략
        hello = () => {
            return "Hello World!";
        };

        console.log(hello());

        // return 키워드, 중괄호 생략
        // (단, 명령문이 하나만 있는 경우)
        hello = () => "Hello World!";

        console.log(hello());

        // 매개변수가 있을 경우
        hello = (val1, val2) => "Hello " + val1 + val2;

        console.log(hello('World', '!!!!'));

        // 매개변수가 하나면 소괄호 생략 가능
        hello = val => "Hello " + val;

        console.log(hello('World!!!'));
    </script>

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17
3. 배열  (0) 2022.02.17
1. 기본 문법  (0) 2022.02.15
0. 개요  (0) 2022.02.15

 

개발자모드 단축키 : CTRL + SHIFT + J

 

 

 

 

 

주석처리 방법


 

 

    <!----> <!--html 내 주석-->
    <script>
        // html 주석을 사용할 수 없다.

        // JavaScript 한줄 주석

        /*
            JavaScript
            여러줄 주석
            줄 바꿈이 있다면 세미콜론 자동 삽입
        */

 

 

 

 

 

 

 

 

변수 선언/할당


 

 

 

    <h1>변수와 자료형</h1>
    <h3>변수 선언과 대입</h3>
    <script>
        //변수선언, 타입을 따로 작성하지않는다.
        let str; //let은 선언 str은 변수명
        //대입
        str = '변수'; //홑따옴표, 쌍따옴표 둘다 가능
        //alert로 출력
        // alert(str);

        //선언과 대입을 동시에
        // let str = '이름';
        // SyntaxError: Identifier 'str' has already been declared
        // 같은 이름의 변수 재선언 불가

        let name = '이름';
        console.log(name);



    </script>

 

 

 

 

 

 

 

 

 

 

 

변수 명명규칙


  • 영어 대/소문자, 숫자 , _ , $ 사용가능
  • 첫 글자 숫자 사용 불가
  • 공백을 포함한 특수문자 사용 불가
  • 이름에 의미있는 단어의 조합을 권장
  • 예약어를 이름으로 사용 불가
  • 두 단어 이상 결합 시 Camel표기법 권장
  • 한글 이름 사용가능
  • 생성자 함수의 이름은 항상 대문자로 시작
  • 변수, 인스턴스, 함수, 메소드 이름은 항상 소문자로 시작

 

 

 

▼ 변수 명명 규칙 코드 예시 ▼
        <h3>변수 명명 규칙</h3>
        <ul>
            <li>문자, 숫자, '$', '_' 사용가능</li>
            <li>첫 글자는 숫자가 될 수 없다.</li>
            <li>예약어 사용불가</li>
            <li>카멜 표기법을 사용</li>
            <li>한글 변수명은 권장하지않음</li>
        </ul>

        <script>
            //유효한 변수명
            let userName;
            let number1;
            let number_2;
            let number$3;


            // 유효하지 않은 변수명
            // let 1number;  첫글자 숫자사용 불가
            // let number#4; 다른 특수문자 사용불가

            // 유효하나 권장하지 않음
            // 되도록 영어로 네이밍 규칙을 지켜 작성
            let 변수 = '변수입니다';
            console.log(변수);
        </script>
        
        
                <h3>상수 선언과 대입</h3>
        <script>
            //const는 재할당 할 수 없다.
            const PI = 3.141592; //상수라는 의미를 담아서 선언
            // PI = 3.14;
            // Uncaught TypeError: Assignment to constant variable.
            // 재할당시 오류발생

            console.log(PI);


            // const는 선언과 동시에 할당해야 한다. 분리 선언 불가
            //Uncaught SyntaxError: Missing initializer in const declaration
            // const NUM;
            // NUM = 123;

            

        </script>

 

 

 

 

 

 

 

 

 

 

 

자료형


자바스크립트는 느슨한 타입 언어, 동적 언어로 변수의 타입을 미리 선언할 필요가 없으며 타입은 프로그램이 처리되는 과정에서 자동으로 파악됨

 

 

 

 

▼ 기본 자료형 코드 예시 ▼
        <h4>원시 자료형 (primitive type)</h4>
        <p>
            기본자료형. 원시 자료형이 할당 될 때에는 변수에 값(value) 자체가 담긴다.
        </p>
        <ul>
            <li>number</li>
            <li>string</li>
            <li>boolean</li>
            <li>null</li>
            <li>undefined</li>
        </ul>


        <script>
            //숫자 : 정수 및 실수
            let age = 20;
            let height = 171.5;

            console.log(age);
            console.log(height);


            // Infinity : 무한대 -> 출력됨
            // 아래 두줄은 같은 결과이다.
            console.log(1/0);
            console.log(Infinity);


            // NaN : not a number 출력, 숫자와 숫자끼리의 연산이 아닌경우
            // 아래 두줄은 같은 결과이다.
            console.log('문자'/2);
            console.log(NaN);


            // 문자열 : 따옴표로 묶음
            // 문자 자료형은 따로 ㅇ벗음
            let str2 = 'single';
            let str3 = 'double';

            console.log(str2);
            console.log(str3);


            // 논리값
            let bool = true;
            let bool2 = 1 == 2; // false

            console.log(bool);
            console.log(bool2);

            // null
            // 의도적 부여, 존재하지 않는 값, 알 수 없는 값, 비어있는 값
            // 의도적으로 빈값이라고 표현하는 상태
            let nullValue = null;

            console.log(nullValue);

            // undefined
            // 값이 할당 되지 않은 상태
            let undef;
            console.log(undef);

            // 명시적 undefined
            let undef2 = undefined;
            console.log(undef2);

        </script>

 

 

 

 

▼ 참조 자료형 코드 예시 ▼
        <h4>참조 자료형 (reference type) </h4>
        <p>
            원시자료형이 아닌것 <br>
            참조자료형이 할당 될 때는 
            보관함의 주소 (reference) 가 담긴다.
        </p>
        <ul>
            <li>Array</li>
            <li>Object</li>
            <li>function</li>
        </ul>

        <script>
            //배열
            let arr = [1, 2, 3, 4 ,5];
            console.log(arr);

            //객체
            let user = {
                name : "홍길동",
                age : 30,
                id : "user01"
            };
            console.log(user);
            console.log(user.name);
            console.log(user.age);
            console.log(user.id);


        </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

데이터 출력방법


 

 

 

 

▼ 데이터 출력 코드예시 ▼
    <h1>간단한 데이터 입출력</h1>
    <h3>console.log()로 개발자 도구 콘솔 화면에 출력하기</h3>
    <p>
        개발자 도구 콘솔 화면에 출력을 하고자 할 때 사용하며,
        주로 디버깅 시 사용된다.
    </p>
    <script>
        console.log('콘솔 화면에 출력하기');
    </script>


    <h3>alert()로 메세지 출력하기</h3>
    <p>
        사용자가 확인 버튼을 누를 때까지
        메세지를 보여주기 위해 사용한다. 
    </p>
    
    <script>
    
        alert('alert에 메시지 출력하기');

    </script>

 

    <h3>confirm()을 이용한 데이터 입력</h3>
    <p>
        어떤 질문에 예/아니오의 결과를 
        얻을 때 사용한다.<br>
        확인버튼과 취소버튼이 나타나며
        확인 버튼 클릭시 true,
        취소 버튼 클릭스 또는 ESC 키를 누를 시
        false를 리턴한다.
    </p>
    <script>
        //let result = confirm('배고프면 확인, 아니면 취소를 누르세요.');
        //console.log('result : ' + result);
    </script>

 

 

  
    <h3>prompt()을 이용한 데이터 입력</h3>
    <p>
        텍스트 필드와 확인/취소 버튼이 있는 대화상자를 출력하고
        입력한 메세지 내용을 리턴값으로 돌려 받는다. <br>
        취소 버튼 클릭시 null 을 리턴하며, 두 번째 인자로 default 값
        설정도 가능하다.
    </p>

    <script>
        let userName = prompt("당신의 이름은 무엇인가요?");
        console.log('userName :' + userName);

        // 두번 째 인자로 default 값 설정
        let age = prompt('당신의 나이는 몇 살인가요?', 20);
        console.log("age : " + age);

    </script>

    <p>
        alert, confirm, prompt가 띄운 창이 떠 있는 동안은
        스크립트 동작이 일시 정지하며 사용자가 창을 닫기 전까지는
        나머지 페이지와 상호작용이 불가능하다. <br>
        해당 창들은 브라우저 마다 다른 모양을 가지며
        개발자가 수정 불가능한 요소이다.
    </p>

 

 

 

 

 

 

 

 

 

 

 

 

형변환 : typeof()


  • 값의 자료형을 확인하는 연산자
  • 선언 시 자료형을 지정하지 않아 변수명을 보고 데이터를 확인불가, 자료형 확인 시 자주 사용

 

typeof(“문자열값”) 또는 typeof(‘문자열값‘) string
typeof(숫자) number
typeof(참/거짓) Boolean
typeof(객체) object
typeof(초기값이 없는 변수) undefined
typeof(function) function

 

 

 

 

 

 

 

데이터 형변환

 


문자형변환


  • 숫자와 문자를 +연산하게 되면 문자가 우선되어 숫자를 문자로 변환
  • 강제 형변환 : String() 함수 이용

 

 

 

▼ 문자형변환 코드 예시 ▼
   <h3>문자형변환</h3>
    <p>
        자동형변환 : 
        alert 메소드의 매개변수는 문자형이므로 
        alert(value)에서 value가 다른 타입이면 문자형으로 자동 변환된다. <br>
        또한 String(value) 함수 호출로 변환할 수도 있다.
    </p>

    <script>
        console.log("===============문자형 변환================");
        let str = false;
        console.log(str);

        // typeof 연산자를 통해 타입을 확인할 수 있음
        console.log('typeof str : ' + typeof str); // 타입 확인
        str = String(str); // 타입을 String으로 변환 (강제형변환)
        console.log('typeof str : ' + typeof str); // String으로 변환된것 확인
    </script>

 

 

 

 

 

 

 

숫자형변환


  • 수학과 관련 된 함수와 표현식에서 자동으로 변환
  • 강제 형변환 : Number() 함수 이용

 

 

 

▼숫자형 변환 코드 예시 ▼
    <h3>숫자형변환</h3>
        <p>
            숫자형변환 : 
            수학과 관련 된 함수와 표현식에서 자동으로 변환된다. <br>
            또한 Number(value) 함수 호출로 변환할 수도 있다.
        </p>
        <script>
            console.log("===============숫자형 변환================");
            console.log(' "10 / 2" : ' + "10" / "2"); 
            //콘솔창에 ""을 출력하고 싶다면 ''로 구분해 감싸준다.

            let number = "100";
            console.log(number);
            console.log('typeof number : ' + typeof number);


            //숫자로 강제 형 변환 Number(변수);
            number = Number(number);
            console.log(number);
            console.log('typeof number : ' + typeof number);


            //공백 자동 제거 후 숫자 형변환도 가능하다.
            console.log('Number("       100         ") : ' + Number("       100         "));
            
            // NaN 이뜸 왜냐? 문자가 포함되어있기 때문에 숫자형변환 불가
            console.log(' Number("123a") : ' + Number("123a"));

            // boolean 형변환 가능, true는 1 false는 0으로 취급될 수 있다.
            console.log(Number(true)); // 1
            console.log(Number(false)); // 0

            //null은 0으로 숫자취급하지만 undefined는 숫자취급하지않는다.
            console.log(Number(null)); //0
            console.log(Number(undefined));  // NaN


        </script>

 

<h3>문자열과 숫자의 + 연산</h3>
<p>
    문자열 + 숫자 = 문자열 <br>
    숫자 + 숫자 + 문자열 = 숫자가 먼저 계산 되고 뒤의 문자열과 합쳐진다.
</p>
<script>
    let test1 = 7 + 7;
    let test2 = "7" + "7";
    let test3 = "7" + 7;
    let test4 = 7 + 7 + "7";

    // +"7"와 같이 '+'를 이항 연산자가 아닌 단항연산자로 사용시 
    // 숫자형이 아닌 피연산자는 숫자형으로 변화한다.
    let test5 = 7 + 7 + +"7";

    console.log("=======문자열과 숫자의 '+' 연산=========")
    console.log('7 + 7 : ' + test1); //14
    console.log('"7" + "7" : ' + test2); //77
    console.log('"7" + 7 : ' + test3); //77
    console.log(' 7 + 7 + "7" : ' + test4); //147
    console.log('7 + 7 + +"7" : ' + test5); //21

</script>

 

 

 

 

 

 

 

 

 

 

논리형변환


  • 논리 연산 수행 시 발생
  • 강제 형변환 : Boolean() 함수 이용

 

 

 

▼논리형변환 코드 예시 ▼
<h3>논리형변환</h3>
<p>
    논리연산 수행시 발생한다. <br>
    또한 Boolean(value) 함수 호출로 변환할 수도 있다.
</p>
<script>
    console.log("===============논리형 변환================");

    // 1과 0은 각각 true와 false의 값을 갖는다. 
    console.log('Boolean(1) : ' + Boolean(1)); //true
    console.log('Boolean(0) : ' + Boolean(0)); // false


    // 값이 있는 문자열 : true 
    console.log('Boolean("str") : ' + Boolean("str"));
   

    // 값이 없는 문자열, null, undefinde -> false
    console.log('Boolean("") : ' + Boolean(""));
    console.log('Boolean(null) : ' + Boolean(null));
    console.log('Boolean(undefined)' + Boolean(undefined));



</script>

 

 

 

 

 

 

 

연산자 : 연산자의 종류


  • 연산자 우선순위
최우선 > 단항 > 산술 > 관계 > 논리 > 삼항 > 대입

 

 

 

 

 

 

 

 

 

비교 연산자를 통한 문자열 비교


  • 비교 연산자로 문자열을 비교할 수 있음
  • 사전 순(유니코드 순)으로 뒤쪽의 문자열은 앞쪽의 문자열보다 큼

 

 

 

▼ 비교연산자 코드 예시 ▼
    <h3>비교 연산자를 통한 문자열 비교</h3>
    <p>
        비교 연산자로 문자열을 비교할 수 있다.
        사전순 (유니코드순)으로 뒤쪽의 문자열은 앞쪽의 문자열보다 크다.
    </p>
    <script>
        console.log("======문자열 비교 연산자 사용======");
        console.log("'hello' == 'hello' : " + ('hello' == 'hello')); //true
        console.log("'hello' != 'hello' : " + ('hello' != 'hello')); // false

        // 유니코드 순으로 더 위에있는 b가 크다는 물음에 true 반환
        console.log("'apple' < 'banana' : " + ('apple' < 'banana')); // true
        console.log("'apple' > 'banana' : " + ('apple' > 'banana')); // false

        // 유니코드 순 대문자가 더 앞에있으므로 상대적으로 뒤에있는 소문자가 더 크다.
        console.log("'cat' <= 'Zoo' : " + ('cat' <= 'Zoo')); // true
        console.log("'cat' >= 'Zoo' : " + ('cat' >= 'Zoo')); // false

    </script>

 

 

 

 

 

 

 

 

 

동등 연산자와 일치 연산자


  • 동등 연산자(== , !=)
자료형에 상관 없이 값이 일치하면 true, 아니면 false

 

  • 일치 연산자(=== , !==)
자료형과 값이 모두 일치하면 true, 아니면 false

 

 

 

 

 

▼ 연산자 코드 예시 ▼
    <h3>==, != 연산자와 ===, !== 연산자</h3>

    <h4> 동등연산자 (==, !=) </h4>
    <p>
        자료형에 상관없이 값이 일치하면 true, 아니면 false
    </p>

    <h4> 일치연산자 (===, !==) </h4>
    <p>
        자료형과 값이 모두 일치하면 true, 아니면 false
    </p>

    <script>
        console.log("===== 동등/일치 연산자 테스트 =====");

        //동등연산자
        console.log('1 == "1" : ' + ( 1 == "1")); //true
        console.log('1 == true : ' + ( 1 == true)); //true
        console.log('1 == "true" : ' + ( 1 == "true")); //false

        //일치 연산자 : 자료형이 모두 다른 비교
        console.log('1 === "1" : ' + ( 1 === "1")); //false
        console.log('1 === true : ' + ( 1 === true)); //false
        console.log('1 === "true" : ' + ( 1 === "true")); //false


        //동등연산자
        console.log('0 == "0" : ' + ( 0 == "0")); //true
        console.log('0 == "" : ' + ( 0 == "")); //true
        console.log('"0" == "" : ' + ( "0" == "")); //false
        // 분명 다른연산자지만 값이 같으면 같은 동등연산자이므로 //true  
        console.log('null == undefined : ' + ( null == undefined )); //true

        //일치연산자
        console.log('0 === "0" : ' + ( 0 === "0"));  //false
        console.log('0 === "" : ' + ( 0 === ""));  //false
        console.log('"0" === "" : ' + ( "0" === "")); //false
        console.log('null === undefined : ' + ( null === undefined ));  //false

    </script>

 

 

 

 

    <p>
        그 외 삼항 연산자,
        조건문 (if, if-else, if-else if else, switch문 ),
        반복목 (for, while, do-while문) 등의 사용방법 모두 
        Java에서 학습한 방법과 동일하다.
    </p>

    <h3> 논리연산자를 이용한 짧은 조건문 </h3>
    <p>
        prompt로 숫자를 입력 받고 해당 값이 홀수이면 "홀수입니다."
        라고 alert 창으로 출력하고, 해당 값이 짝수이면 "짝수입니다."
        라고 alert창으로 출력한다. 
        (*if 문이 아니라 논리연산자 &&, || 의 특징 활용해서 작성)
    </p>

    <script>

        /*
        나의 작성답안
        let Num = prompt("0이상의 숫자를 입력하세요.");
        console.log('Num :' + Num);

        if (Num % 2 == 0 && Num > 0) {
            alert('짝수입니다.')
        } alert ('홀수입니다.');
        */


        let input = prompt("숫자를 입력하세요");

        input % 2 == 0 || alert("홀수입니다.");
        input % 2 == 0 && alert("짝수입니다.");

    </script>

 

 

 

 

 

 

 

 

제어문


 

  • 조건문
if, if ~ else, if ~ else ~if, switch문, 짧은 조건문(||, &&)

 

  • 반복문
for, while, do~while, for in문

 

 

  • 분기문
continue, break문

 

 

 

 

 

 

 

 

 

▼ var과 let의 차이 코드예시 보기 ▼
        <h1>ECMAScript 6</h1>
        <p>
            ES6 및 EXMAScript 2015 라고도 하며
            JavaScript의 두번째 주요 개정판 (2015년)을 말함
        </p>

        <h3>let, const</h3>
        <p>
            ES5 까지는 모든 변수를 var 라는 예약어로 선언했으나
            ES6 문법에서는 let 과 const를 사용한다. <br>
            ES5까지는 "전역 범위"와 "함수 범위"라는 
            두 가지 유형의 범위만 있었지만
            ES6에서는 "블록범위" 변수 (및 상수)를 제공한다. <br>
            즉 차이는 어디서부터 어디까지 유효한지의 "범위(scope)"이다.
        </p>

        <script>
            //선언 범위 테스트
            var x = 1;
            let y = 2;
            console.log('블럭 밖 x = ' + x);
            console.log('블럭 밖 y = ' + y);
            // script 바로 밑에선언한 변수는 전역변수
            {
                // script 바로 밑에선언한 변수는 지역변수
                var x = 3;
                let y = 4;
                console.log('블럭 안 x = ' + x);
                console.log('블럭 안 y = ' + y);

            }

            console.log('블럭 밖 x = ' + x);
            console.log('블럭 밖 y = ' + y);

            /* 
            var는 블록 범위를 가질 수 없고 
            let은 블록 범위를 가질 수 있다.
            var는 블록 내부의 변수를 다시 선언하면
            블록 외부의 변수도 다시 선언되는 문제가 있으니
            let은 블록 내부의 변수를 다시 선언해도
            블록 외부의 변수는 다시 선언되지않는다. 
            */



            /* loop 블록 안의 변수로 사용했을때 차이가 더 드러난다.
            let의 경우 loop 블록 범위와 전역 범위가 구분되지만
            var의 경우 loop 블록 범위와 전역범위가 구분되지않는다. */
            var i = 5;
            for (var i = 0; i < 10; i++) {}
            console.log("i = " + i);


            let j = 5;
            for (let j = 0; j < 10; j++) {}
            console.log("j = " + j)

        </script>

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17
3. 배열  (0) 2022.02.17
2. 함수  (0) 2022.02.16
0. 개요  (0) 2022.02.15

 

 

 

 

개요

 

 

 

 

 

 

클라이언트-서버 구조


프로토콜

  • HTTP : 하이퍼텍스트 전송규약(웹 통신)
  • FTP : 대량의 파일을 전송/수신하기 위한 파일 전송규약
  • TELNET : 원격지에서 서버컴퓨터를 원격제어하기 위한 규약

 

 

 

 

 

 

클라이언트 주요언어


  • HTML : 하이퍼텍스트를 구현하기 위한 뼈대가 되는 핵심적인 기술인 마크업 언어
  • CSS : HTML은 뼈대이고, 자바스크립트가 기능이라면, CSS는 꾸미기 위한 옷의 기능이라고 할 수 있다.
  • 자바스크립트(JavaScript) : 로컬의 브라우저에서 실행되는 인터프리터 방식의 프로그래밍 언어
  • jQuery : 자바스크립트의 코드가 길어지면 사용하기 복잡해지는 단점을 파격적으로 개선한,
    존 레식(John Resig)이 창안한 자바스크립트 기반의 라이브러리 중 하나이다.

 

 

 

 

 

 

서버 주요언어


  • JSP : 운영체제의 구애를 받지 않으며 실행된다.
  • 톰갯(Tomcat) 컨테이너 위에서 자바 기반의 언어를 사용한다.
  • ASP : 윈도우 기반의 IIS 서버에서만 동작한다. MS-SQL DBMS와 연동된다.
  • PHP : 리눅스 기반에 아파치(Apache)서버에서 동작한다.
  • 기존에 제로보드나 그누보드와 같은 사이트 빌더에서 기본적으로 사용되는 언어이다.
  • Node.js : 흔히 “노드제이에스” 또는 “노드”라고 하는 자바스크립트 라이브러리로서, 소켓을
    이용하여 쉽게 실시간 서버를 구축 가능하도록 한다.

 

 

 

 

 

JavaScript란


  • 자바스크립트(JavaScript)는 웹 브라우저에서 많이 사용하는 인터프리터 방식의 객체지향 프로그래밍
    언어이다.
  • 자바스크립트는 ECMA스크립트 표준을 따르는 대표적인 웹 기술이다.
  • ECMA(European Computer Manufacturers Association) : 표준화 기구

 

 

	<h1>JavaScript란?</h1>
    <p>
        HTML이 웹 문서의 뼈대 역할,  CSS가 그 뼈대를 꾸며주는 역할이라면
        <b>자바스크립트는 생동감을 불어넣기 위해</b> 만들어진 프로그래밍 언어이다. <br>
        자바스크립트로 작성한 프로그램을 스크립트(script)라고 부르고,
        스크립트는 웹 페이지의 HTML 안에 작성가능하며 웹페이지 로드시 자동으로 실행된다 <br>
        <script></script>로 작성하며 기본적인 위치는 head 안, body 안이다.
        브라우저에는 '자바스크립트 가상 머신' 이라 불리는 엔진이 내장되어 있다
    </p>




    <h1>JavaScript의 실행 방식</h1>
    <p>
        엔진이 스크립트를 읽고(파싱) 읽어들인 스크립트를 기계어로 전환(컴파일) 하면
        기계어로 전환 된 코드가 실행된다. <br>
        전체를 해석해 놓은 컴파일 언어와는 차이가 있다. <br>
    </p>
    
        <h3>JavaScript로 수행할 수 있는 기능</h3>
    <ul>
        <li>페이지에 새로운 HTML 추가</li>
        <li>기존 HTML과 스타일 수정</li>
        <LI>마우스 클릭 및 이동, 키보드 키 누름등의 사용자 행동에 반응</LI>
        <li>네트워크를 통해 원격 서버에 요청(Ajax기술 등)</li>
        <li>쿠키 (Cookie) 사용</li>
        <li>클라이언트 측에 데이터 저장(Local Storage)</li>
    </ul>




    <h3>JavaScript를 사용하는 이유</h3>
    <p>
        HTML/CSS와 완전히 통합할 수 있으며 모든 주요 브라우저에서 지원하고,
        기본 언어로 사용되기 때문이다. <br>
        오늘날 자바스크립트는 브라우저 환경에서 가장 널리 사용되는 언어이며
        지금은 서버단 등 다양한 환경에서도 사용된다. 
    </p>




    <h3>개발자 도구</h3>
    <p>
        브라우저별로 개발자 도구 (Developer Tools)를 제공하는데 크롬의 경우
        F12 키를 눌러 실행한다. <br> 브라우저 창에서 원하는 부분을 확인하고 싶으면 원하는
        위치에 우클릭 후 검사를 누른다. <br>
        자바스크립트 소스 코드 중 console.log()는 브라우저에서 출력하는 것이 아니라 
        개발자 도구의 console 패널에서 출력하고 스크립트 구문을 디버깅할때 자주 사용한다.
    </p>

 

 

 

 

 

 

 

 

스크립트 언어란


  • 매우 빠르게 배우고 작성하기 위해 고안되었고 짧은 소스코드파일이나 REPL(Read Eval Print Loop)로
    상호작용
  • 기본 프로그램의 동작을 사용자의 요구에 맞게 수행되도록 해주는 용도로 주로 사용

 

 

 

 

 

 

클라이언트 사이드 스크립트


  • 클라이언트, 즉 사용자 컴퓨터에서 처리되는 스크립트
  • 종류 : JavaScript, VBscript, Jscript

 

 

 

서버 사이드 스크립트


  • 정보를 제공하는 서버쪽 컴퓨터에서 처리되는 스크립트
  • 종류 : ASP, PHP, JSP, Perl, 파이썬, Node.js 등

 

 

 

 

 

 

 

 

 

 

 

작성 및 실행

 

 

 

 

 

 

브라우저 개발자 도구

 


  • 브라우저별 개발자 도구(Develop Tools)가 있음
  • 크롬/ IE 브라우저 F12키 눌러서 실행
  • 브라우저 창에서 원하는 코드를 확인하고 싶으면 원하는 위치에서 우 클릭 후 해당메뉴선택 (크롬 : 검사 / IE : 요소검사)
  • 자바스크립트 소스코드 중 console.log()는 브라우저에 출력하는 것이 아니라 개발자 도구의 console패널에서 출력
  • 스크립트 구문을 디버깅할 때 자주 사용

 

 

개발자&amp;nbsp;도구의&amp;nbsp;console패널

 

 

 

 

 

 

 

 

자바스크립트 선언


  • <SCRIPT></SCRIPT> 태그 사이에 자바스크립트 코드 문장을 작성하면 된다.
  • HTML에서 제공하는 <script></script>태그를 사용하여, 자바 스크립트 작성영역을 설정
  • type속성 브라우저 호환성을 위해 사용되나 default값으로 생략이 가능

 

    <script type=“text/javascript”>
    	자바스크립트 내용
    </script>
  • language속성과 charset속성이 있었지만 language속성은 폐기 되고 charset속성은 meta태그가 적용되기 때문에 사용할 필요가 없음.

 

 

 

 

 

 

자바스크립트 위치


  • <SCRIPT></SCRIPT> 는 <head>,<body> 안 어느 영역에나 작성 가능
  • html태그 영역 밖에 작성가능,
    하지만 웹 표준과 웹 접근성을 고려해서 <head>나 <body>에 작성
	<script>자바스크립트 내용</script>
        <html>
            <head><script>자바스크립트 내용</script></head>
            <body><script>자바스크립트 내용</script></body>
        </html>
	<script>자바스크립트 내용</script>

 

 

 

 

 

 

자바스크립트 작성 방식


  • inline 방식 : 자바스크립트 양이 한두 줄 정도로 소량일 때 사용
태그에 이벤트 핸들러 속성을 이용하여 직접 실행 코드 작성

 

  • internal 방식 : 가장 일반적인 방식, html파일 내 자바스크립트 소스를 작성
<head>, <body> 내 작성

 

  • external 방식 : 자바스크립트의 양이 많은 경우 자바스크립트 코드 부분을 외부 파일로 저장하여 작성
<script src=“경로”>태그를 이용하여 내용을 삽입 후 사용

 

 

    <h3>자바스크립트 작성방법</h3>
    <h3>1. internal 방식</h3>
    <p>
        script 태그 영역에 작성해서 실행되게 하는 방법으로 
        head 태그, body 태그 내에서 작성 가능하다. <br>
        type="text.javascript" 는 HTML4 에서는 필수였으나 지금은 필수가 아니다. <br>
        language 속성은 자바스크립트가 기본 언어이므로 작성할 필요가 없다.
    </p>



    <!----> <!--html 내 주석-->
    <script>
        // html 주석을 사용할 수 없다.

        // JavaScript 한줄 주석

        /*
            JavaScript
            여러줄 주석
            줄 바꿈이 있다면 세미콜론 자동 삽입
        */

        console.log('Hello!'); console.log('JavaScript!');
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

inline 방식


html 태그의 on이벤트 속성을 이용하여 내장 메소드를 호출하거나 개발자가 선언한 사용자정의 함수를 호출할 때 사용

<태그명 on이벤트 = “함수명();”>

 

    <h3>3. inline 방식</h3>
    <p>
        태그에 직접 소스 코드를 작성해서 실행되게 하는 방법
    </p>
    <button onclick="alert('버튼 클릭 확인');">경고창 출력</button>
    <button onclick="console.log('버튼 클릭 확인');">콘솔창 출력</button>

 

 

 

 

 

 


internal 방식


자바스크립트코드를 작성, 함수 단위로 소스코드를 작성하고 html태그에서 이벤트 핸들러를 통해 함수를 실행시키는 방식

    <script>
    	실행할 소스코드 작성
    </script>

 

 

 

 

 

 

 

external 방식


  • 외부에 별도의 자바스크립트 소스파일(*.js)을 작성하고 html에서 <script src=“경로.js”>태그를 이용하여 해당파일을 불러와 사용하는 방식
  • 여러 개 html파일에서 공통적으로 사용하는 기능일 경우 사용
<script src=“경로”></script>

 

    <h3>2. external 방식</h3>
    <p>
        별도의 js 파일로 작성해서 가져다 사용하는 방법<br>
        스크립트가 길어지면 별도의 js 파일로 작성하는 것이 좋은데 
        이는 브라우저의 캐싱으로 다시 다운 받을 필요가 없어지기 때문이다.
    </p>

    <script src="../resources/js/sample.js"></script>

 

 

 

 

 

 

 

<noscript>태그


자바 스크립트가 지원되지 않는 브라우저를 대비 지원하지 않는 경우 <noscript>에 작성된 내용이 출력

 

    <noscript>
    	지원하지 않을 경우 출력문구
    </noscript>

 

 

 

 

 

 

 

자바스크립트 실행방식


  • 웹 브라우저에 내장되어 있는 자바스크립트 파서가 소스 코드를 한 줄씩 읽고 해석한다는 점에서 인터프리터 방식으로 소스를 해석하기 때문에 전체를 해석해 놓은 컴파일 언어와는 차이가 있다.
  • 자바스크립트 실행은, 작성된 html문서를 브라우저에서 읽어 들이면 바로 실행을 확인할 수 있다는 것이다.

 

 

 

 

 

 

 

 

 

'Programming > JavaScript' 카테고리의 다른 글

5. 숫자/문자/날짜 다루기  (0) 2022.02.18
4. 객체  (0) 2022.02.17
3. 배열  (0) 2022.02.17
2. 함수  (0) 2022.02.16
1. 기본 문법  (0) 2022.02.15

+ Recent posts