정규 표현식


  • 특정한 규칙을 가진 문자열의 집합을 표현하는데 사용하는 형식 언어
  • 정규 표현식을 이용하면 입력 된 문자열에 대하여 특정 조건 검색, 치환 가능하다.
  • 복잡한 조건문 대신 간단하게 처리 가능하다.

 

 

 

 

 

정규 표현식(Regular Expressions)의 객체 생성


  • 자바스크립트에서는 RegExp 객체문자열 메소드를 조합해 정규 표현식을 사용한다.
  • 정규 표현식은 패턴(pattern)과 선택적으로 사용할 수 있는 플래그(flag)로 구성된다.

 

 

 

 

 

정규식 생성 문법 1


상황에 따라 동적으로 생성 된 문자열을 정규식으로 만들어야 하는 경우

 

let regExp = new RegExp('pattern', 'gmi');

 

 

정규식 생성 문법 2


코드 작성 시 이미 패턴을 알고 있을 경우 

 

regExp = /pattern/;
regExp = /pattern/gmi;

 

 

 

 

 

 

정규식 사용 메소드1 : 정규 표현식 메소드


test 문자열에서 정규식 변수의 값과 일치하는 값이 있으면 true, 없으면 false

 

 

 

 

정규식 사용 메소드2 : 문자열 메소드


match 문자열에서 정규식 변수의 값과 일치하는 모든 값 반환
replace 문자열에서 정규식 변수이 값과 일치하는 부분을 새로운 값을 변경
search 일치하는 부분의 시작 인덱스 반환
split 정규식 변수에 지정 된 값을 구분자로 하여 배열 생성

 

 

 

 

 

▼ 코드 예시 확인 ▼
    <button id="test1">확인하기</button>
    <div id="area1" class="area"></div>
    <script>
        document.querySelector("#test1").addEventListener('click', function(){
            // 검색 대상 문자열
            let str = 'javascript jquery ajax';

            // 정규식 변수(검색 조건으로 삼을 문자열)
            let regExp = /script/;

            // area에 표현할 html
            let html = '';

            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "match : " + str.match(regExp) + "<br>";
            html += "replace : " + str.replace(regExp, '스크립트') + "<br>";
            html += "search : " + str.search(regExp) + "<br>";
            html += "split : " + str.split(regExp) + "<br>";


            document.querySelector("#area1").innerHTML = html;
        });
    </script>

 

 

 

 

 

 

 

 

메타 문자를 이용한 문자 검색, 치환


 

^ 의미 텍스트의 시작
예시  /^a/ : 소문자 a로 시작하는 패턴
 [ ] 의미 범위 표현
예시 /[ab]/ : 소문자 a 또는 b, /[a-z]/ : 소문자, /[A-Z]/ : 대문자, /[A-Za-z]/ : 대소문자, /[0-9]/ : 숫자
$ 의미 텍스트의 끝
예시 /z$/ : 소문자 z로 끝나는 패턴
. 의미 어떤 문자가 오던 매칭
예시 /a.c/ : a와 c 사이에 아무 문자 하나가 있는 패턴
+ 의미 앞의 문자를 1개 이상 찾음
예시  /a+/ : a 또는 aa 또는 aaa ...

 

 

 

 

 

 

▼ 코드 예시 확인 
    <button id="test2">실행확인</button>
    <div id="area2" class="area"></div>
    <script>
        document.querySelector("#test2").addEventListener('click', function(){
            let str = 'javascript jquery ajax';
            let regExp = /a/;
            let html = '';

            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";

            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // ^ : 텍스트의 시작을 의미
            regExp = /^j/;
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // [] : [] 내의 문자 중 하나라도 존재할 경우
            regExp = /[ab]/;
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // j 또는 s로 시작
            regExp = /^[js]/;
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // $ : 텍스트의 끝을 의미
            regExp = /x$/;
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // . : 개행 문자를 제외한 모든 문자
            // + : 한 글자 이상
            // j로 시작해서 x로 끝나는 패턴 (중간에 최소 1개 이상의 문자는 있음)
            regExp = /^j.+x$/;
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // 숫자만(시작^ 부터 1글자 이상+ 끝$ 까지 [0-9]일때)
            regExp = /^[0-9]+$/;
            str = "1234567890";
            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // 영어 대문소문자 + 숫자만
            regExp = /^[a-zA-Z0-9]+$/;
            str = "JavaScript123";
            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";

            // 한글만
            regExp = /^[ㄱ-ㅎㅏ-ㅣ가-힣]+$/;
            str = "ㅎㅇ";
            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";
            html += "test : " + regExp.test(str) + "<br>";
            html += "replace : " + str.replace(regExp, '(***)') + "<br>";


            document.querySelector("#area2").innerHTML = html;
        });
    </script>

 

 

 

 

 

 

 

 

 

플래그 문자


  • g : 전역 비교를 수행
  • i : 대소문자를 가리지 않고 비교
  • m : 여러 줄의 검사 수행

 

 

 

▼ 코드 예시 확인 
    <button id="test3">실행확인</button>
    <div id="area3" class="area"></div>
    <script>
        document.querySelector("#test3").addEventListener('click', function(){
            let str = 'JavaScript JQuery Ajax';
            let regExp = /a/;
            let html = '';

            html += "str : " + str + "<br>";
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";
            // $& : 대체 문자열에 일치하는 전체 문자열의 복사본을 포함

            regExp = /a/g;
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";

            regExp = /a/gi;
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";

            str = "JavaScript\nJQuery\nAjax";
            regExp = /^j/gi;
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";

            regExp = /^j/gim;
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";

            regExp = /[^j]/gim;
            // 대괄호 안에서 ^는 부정
            html += "regExp : " + regExp + "<br>";
            html += "replace : " + str.replace(regExp, "($&)") + "<br>";

            document.querySelector("#area3").innerHTML = html;
        });
    </script>

 

 

 

 

 

 

 

 

 

 

추가 메타 문자


 

\d digit(숫자) 
\w word(알파벳 + 숫자 + _) 
\s space(공백문자 - 탭, 띄어쓰기, 줄바꿈)
\D non digit(숫자가 아닌 문자) 
\W non word(알파벳 + 숫자 + _가 아닌 문자) 
\S non space(공백 문자가 아닌 문자)

 

 

 

 

 

 

▼ 코드 예시 확인 
    <h3>주민등록번호 형식 확인</h3>
    <label>주민등록번호 입력 : </label>
    <input type="text" id="pno">
    <button id="test4">실행확인</button>
    <script>
        document.querySelector("#test4").addEventListener('click', function(){
            // 입력 값
            let pno = document.querySelector("#pno").value;
            // 자리수 맞춤
            let regExp = /^......-.......$/;
            // 자리수 + 숫자만 가능
            regExp = /^\d\d\d\d\d\d-[1234]\d\d\d\d\d\d$/;

            if(regExp.test(pno)) {
                alert('정상 입력!');
            } else {
                alert('잘못 된 입력!');
            }
        });
    </script>

 

 

 

 

 

 

 

 

수량 문자


a는 임의의 문자

a +  a가 적어도 1개 이상(반복 - 한 번 이상 반복)
a{ 5 } a가 5개
a{ 2 , 5 } a가 2~5개
a{ 2 , } a가 2개 이상
a{ , 2} a가 2개 이하

 

 

 

 

 

▼ 코드 예시 확인 
    <h3>주민등록번호 형식 확인</h3>
    <label>주민등록번호 입력 : </label>
    <input type="text" id="pno2">
    <button id="test5">실행확인</button>
    <script>
        document.querySelector("#test5").addEventListener('click', function(){
            // 입력 값
            let pno = document.querySelector("#pno2").value;
            // 수량 문자 적용
            let regExp = /^\d{6}-[1234]\d{6}$/;

            if(regExp.test(pno)) {
                alert('정상 입력!');
            } else {
                alert('잘못 된 입력!');
            }
        });
    </script>

 

 

 

 

    <h3>회원가입 유효성 체크</h3>
    <form name="memberJoin" method="post">
        <label for="userid">* 아이디</label>
        <input type="text" name="userid" id="userid" required><br>
        <label for="pass">* 비밀번호</label>
        <input type="password" name="pass" id="pass" required><br>
        <label for="name">* 이름</label>
        <input type="text" name="name" id="name" required><br>
        <label for="tel1">휴대폰 번호</label>
        <input type="text" name="tel1" id="tel1" maxlength="3">-
        <input type="text" name="tel2" id="tel2" maxlength="4">-
        <input type="text" name="tel3" id="tel3" maxlength="4"><br>
        <input type="reset" value="리셋">
        <input type="submit" value="완료">
    </form>

 

    <script>
        document.forms.memberJoin.onsubmit = function(){
            // 1. 아이디 검사
            // 첫 글자는 반드시 영문 소문자로 시작하고
            // 영문 대소문자와 숫자로만 이루어진 6~12자 사이의 값
            if(!check(/^[a-z][A-Za-z\d]{5,11}$/
            , document.getElementById('userid')
            , "아이디는 영문 소문자로 시작하여 영문과 숫자로만 6~12자 입력"))
            return false;   // onsubmit의 기본 동작 제거로 제출되지 않음

            
        };

        // 유효성 검사용 함수
        function check(regExp, input, msg){
            // 전달 받은 정규 표현식과 사용자 입력 양식의 값이 패턴 일치할 경우
            if(regExp.test(input.value)) 
                return true;
            
            // 전달 받은 정규 표현식과 사용자 입력 양식의 값이 패턴 일치하지 않을 경우
            alert(msg);
            input.value = '';
            input.focus();
            return false;
        }
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

14. 웹 스토리지  (0) 2022.02.24
13. cookie  (0) 2022.02.24
11. 이벤트 활용  (0) 2022.02.22
자바 스크립트 실습문제  (0) 2022.02.21
10. 이벤트  (0) 2022.02.21

 

 

 

 

마우스 이벤트


 

    <h1>마우스 이벤트</h1>
    <h3>마우스 이벤트 종류</h3>
    <ul>
        <li>mousedown/mouseup
            : 요소 위에서 마우스 버튼을 누를 때, 마우스 버튼을
            누르고 있다가 뗄 때
        </li>
        <li>
            mouseover/mouseout 
            : 마우스 커서가 요소 바깥에 있다가 요소 안으로 움직일 때,
            커서가 요소 위에 있다가 요소 밖으로 움직일 때
        </li>
        <li>
            mousemove : 마우스를 움직일 때
        </li>
        <li>
            click : 마우스 왼쪽 버튼을 사용해 동일한 요소 위에서 
            mousedown 이벤트와 mouseup 이벤트를 연달아 발생 시킬 때
        </li>
        <li>
            dblclick : 동일한 요소 위에서 마우스 왼쪽 버튼을
            빠르게 클릭할 때
        </li>
        <li>
            contextmenu : 마우스 오른쪽 버튼을 눌렀을 때
        </li>
    </ul>

 

    <h3>마우스 이벤트 테스트</h3>
    <button id="btn1">마우스 왼쪽이나 오른쪽 버튼을 사용해 클릭</button>
    <div id="area1" class="area"></div>
    <script>
        let btn1 = document.querySelector("#btn1");
        let area1 = document.querySelector("#area1");
        // event.button
        // 0 : 왼쪽, 1 : 가운데, 2 : 오른쪽
        btn1.onmousedown = (event) => area1.insertAdjacentHTML('beforeend', 'mousedown button=' + event.button + "<br>");
        btn1.onmouseup = (event) => area1.insertAdjacentHTML('beforeend', 'mouseup button=' + event.button + "<br>");
        btn1.onclick = (event) => area1.insertAdjacentHTML('beforeend', 'click button=' + event.button + "<br>");
        btn1.oncontextmenu = (event) => area1.insertAdjacentHTML('beforeend', 'contextmenu button=' + event.button + "<br>");
        btn1.ondblclick = (event) => area1.insertAdjacentHTML('beforeend', 'dblclick button=' + event.button + "<br>");
    </script>

 

 

 

    <h3>마우스 이벤트 좌표</h3>
    <p>
        클라이언트 좌표(clientX, clientY)<br>
        : 웹 문서를 기준으로 각각 왼쪽에서 얼마나 떨어져 있는지,
        위에서 얼마나 떨어져 있는지
    </p>

    <span>클라이언트 좌표</span>
    <span id="span1">마우스를 위에 올려보세요</span>
    <script>
        let span1 = document.querySelector("#span1");
        span1.onmouseover = () => span1.innerHTML = event.clientX + ":" + event.clientY;
    </script>

 

 

 

 

    <h3>선택 막기, 복사 막기</h3>
    <p>
        글씨 선택 막기
        : mousedown 이벤트가 발생할 때 나타나는
        브라우저 기본 동작 막기<br>
        글씨 복사 막기
        : oncopy 이벤트 기본 동작 막기
    </p>
    <span ondblclick="alert('클릭되었습니다');" onmousedown="return false;">
    이 영역은 더블 클릭해도 선택 되지 않도록 합니다
    </span>
    <div oncopy="alert('복사 불가능입니다!'); return false;">
        이 편지는 영국에서 최초로 시작되어 일년에 한 바퀴 돌면서
        받는 사람에게 행운을 주었고 지금은 당신에게로 옮겨진 이 편지는
        4일 안에 당신 곁을 떠나야 합니다. 이 편지를 포함해서 7통을
        행운이 필요한 사람에게 보내 주셔야 합니다. 복사는 안됩니다.
    </div>

 

 

 

 

 

 

 

키보드와 스크롤 이벤트


    <h1>키보드 이벤트</h1>
    <h3>키보드 이벤트 종류</h3>
    <ul>
        <li>keydown : 키를 누를 때</li>
        <li>keyup : 키를 놓을 때</li>
    </ul>

 

    <h3>키보드 이벤트 테스트</h3>
    <input type="text" id="content" placeholder="아무 키나 입력하세요">
    <p>
        event.key : 문자 <br>
        event.code : 물리적인 키 코드<br>
        Ex. 소문자 a를 입력하면 event.key=a event.code=KeyA<br>
        대문자 A를 입력하면 event.key=A event.code=KeyA
    </p>

 

    <div id="area1" class="area"></div>
    <script>
        let content = document.querySelector("#content");
        let area1 = document.querySelector("#area1");

        content.onkeydown = () => area1.insertAdjacentHTML('beforeend', 'keydown event.key=' + event.key + ", event.code=" + event.code + "<br>");
        content.onkeyup = () => area1.insertAdjacentHTML('beforeend', 'keyup event.key=' + event.key + ", event.code=" + event.code + "<br>");
    </script>

 

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

        .imageArea{
            margin : 20px;
            border : 2px solid lightgray;
            height : 200px;
            overflow-y : scroll;
        }
    </style>

 

 

 

 

 

 

 

전화번호 입력받기 


    <h3>전화번호 입력 받기</h3>
    <input type="tel" placeholder="전화번호를 입력하세요"
    onkeydown="return checkPhoneNumber(event.key)">
    <script>
        function checkPhoneNumber(key) {
            return (key >= '0' && key <= '9') || key == '-' ||
            key == 'ArrowLeft' || key == 'ArrowRight' || 
            key == 'Delete' || key == 'Backspace';
        }
    </script>

 

 

 

 

 

스크롤 이벤트


    <h1>스크롤 이벤트</h1>
    <p>
        마우스의 스크롤을 움직였을 때 발생하는 이벤트로 컨텐츠
        내용 더보기 등에 사용할 수 있음<br>
        element.scrollHeight : 요소 스크롤 뷰 높이<br>
        element.scrollTop : 요소 세로 스크롤 위치<br>
        element.scrollLeft : 요소 왼쪽 스크롤 위치<br>
        element.clientHeight : 요소 안쪽 높이
    </p>

 

    <div class="imageArea"></div>

    <script>
        // 추가할 이미지 목록
        let imageArr = ['pikachu.png', 'pikachu2.png', 'pikachu3.jpg'];
        // div 영역
        let imageArea = document.querySelector(".imageArea");
        let index = 0;

        // 문서 로드 시 이미지 추가
        addImage(imageArr[index]);

        // fileName 전달 받아 해당 이미지를 div에 추가하는 함수
        function addImage(fileName){
            let html = '';
            for(let i = 0; i < 36; i++){
                html += "<img src='../resources/images/" + fileName +"' width='100' height='100'>"
            }
            imageArea.innerHTML += html;
        }

        // 스크롤 이벤트
        imageArea.addEventListener('scroll', function(){
            console.log("imageArea 높이 : " + imageArea.clientHeight);
            console.log("imageArea 스크롤 위치 : " + imageArea.scrollTop);
            console.log("imageArea 스크롤 높이 : " + imageArea.scrollHeight);
            // 스크롤바를 가장 끝까지 내렸을 떄
            // 스크롤 위치 + 요소 높이 == 스크롤 높이
            if(imageArea.scrollTop + imageArea.clientHeight == imageArea.scrollHeight) {
                index = ++index < imageArr.length ? index : index - imageArr.length;
                addImage(imageArr[index]);
            }
        });
    </script>

 

 

 

 

 

 

 

폼 이벤트


 

    <h1>폼 이벤트</h1>
    <p>
        document.forms : 문서에 존재하는 form들을 반환<br>
        Ex. document.forms.memberJoin : name 속성이 memberJoin인 문서 내의 form<br>
        Ex. document.forms[0] : 문서 내의 가장 첫 번째 form<br>
        form.elements 
        : 해당 form 내의 name 속성이 일치하는 element 들을 반환<br>
        Ex. form.elements.userid : name 속성이 userid인 
        해당 form 내의 element<br>
        폼 요소 탐색에 쓰이는 프로퍼티는 태그 구조에 의존하지 않아
        태그 깊이와 무관하게 form.elements 사용해 접근<br>
        반대로 모든 요소는 element.form으로 폼에 접근 가능(역참조)
    </p>

 

 

 

 

    <h3>회원가입</h3>
    <form name="memberJoin" method="post" action="">
        <table>
            <tr>
                <td><label for="userid">아이디</label></td>
                <td><input type="text" name="userid" id="userid" required></td>
                <td><input type="button" value="중복확인"></td>
            </tr>
            <tr>
                <td><label for="pwd1">비밀번호</label></td>
                <td><input type="password" name="pwd1" id="pwd1" required></td>
                <td><span id="pwdresult"></span></td>
            </tr>
            <tr>
                <td><label for="pwd2">비밀번호확인</label></td>
                <td><input type="password" name="pwd2" id="pwd2" required></td>
                <td></td>
            </tr>
            <tr>
                <td>성별</td>
                <td>
                    <input type="radio" name="gender" id="male" value="m"><label for="male">남자</label>
                    <input type="radio" name="gender" id="female" value="f"><label for="female">여자</label>
                </td>
                <td></td>
            </tr>
            <tr>
                <td>나이</td>
                <td>
                    <select id="age" name="age">
                        <option value="10">10대 이하</option>
                        <option value="20">20대</option>
                        <option value="30">30대</option>
                        <option value="40">40대</option>
                        <option value="50">50대</option>
                        <option value="60">60대 이상</option>
                    </select>
                </td>
                <td></td>
            </tr>
            <tr>
                <td>자기소개</td>
                <td colspan="2"><textarea name="introduce" id="introduce" rows="5" cols="30"
                        style="resize:none;"></textarea></td>
            </tr>
            <tr>
                <td><label for="email">이메일</label></td>
                <td><input type="email" name="email" id="email" required></td>
                <td><span id="emailresult"></span></td>
            </tr>
            <tr>
                <td></td>
                <td>
                    <input type="reset" value="초기화">
                    <input type="submit" value="회원가입">
                    <input type="image" value="회원가입">
                </td>
                <td></td>
            </tr>
        </table>
    </form>

 

        // 폼 얻기
        console.log(document.forms);
        console.log(document.forms.memberJoin);
        console.log(document.forms[0]);
        // 요소 얻기
        let form = document.forms.memberJoin;
        console.log(form.elements);
        console.log(form.elements.userid);
        console.log(form.elements.gender);
        console.log(form.elements.gender[0]);
        console.log(form.elements.gender[1]);
        // 역참조 가능
        let email = form.elements.email;    // 폼 -> 요소
        console.log(email);
        console.log(email.form);    // 요소 -> 폼
        console.log("=================================");
    </script>

 

 

 

    <h3>폼 요소 값 다루기</h3>
    <p>
        input, textarea : input.value 또는 input.checked
        (checkbox 또는 radio)<br>
        select.options : option 하위 요소들을 담고 있는 컬렉션<br>
        select.value : 현재 선택 된 option 값<br>
        select.selectedIndex : 현재 선택 된 option의 번호(인덱스)
    </p>

 

    <button id="test1">input text</button>
    <button id="test2">input radio</button>
    <button id="test3">textarea</button>
    <button id="test4">select</button>
    <script>
        document.querySelector("#test1").addEventListener('click', function(){
            console.log("userid.value : " + userid.value);
            email.value = "email@email.com";
        });
        document.querySelector("#test2").addEventListener('click', function(){
            console.log('male.checked : ' + male.checked);
            female.checked = true;
        });
        document.querySelector("#test3").addEventListener('click', function(){
            console.log("introduce.innerHTML : " + introduce.innerHTML);
            console.log("introduce.value : " + introduce.value);
            introduce.value = "아이엠그라운드~자기소개하기~";
        });
        document.querySelector("#test4").addEventListener('click', function(){
            console.log(age.options);
            age.options[2].selected = true;
            age.selectedIndex = 3;
            age.value = '50';
            console.log("age.options[2].selected :" + age.options[2].selected);
            console.log("age.selectedIndex : " + age.selectedIndex);
            console.log("age.value : " + age.value);
        });
    </script>

 

 

 

 

 

 

focus, blur 이벤트


    <h3>focus, blur 이벤트</h3>
    <p>
        focus : 사용자가 폼 요소를 클릭하거나 tab 키를 눌러
        요소로 이동 했을 때<br>
        autofocus라는 HTML 속성을 사용해도 요소를 포커스 할
        수 있으며 이는 페이지가 로드 된 후 자동으로 포커싱<br>
        blur : 사용자가 다른 곳을 클릭하거나 tab 키를 눌러
        다음 폼 필드로 이동했을 때<br>
        또한 focus, blur 메소드로 요소에 포커스를 주거나
        제거할 수 있음
    </p>

 

    <button id="test5">userid focus</button>
    <button id="test6">userid blur</button>
    <script>
        test5.addEventListener('click', () => userid.focus());
        test6.addEventListener('click', () => userid.blur());

        email.onblur = function(){
            if(!this.value.includes('@')){
                emailresult.innerHTML = '올바른 이메일 주소를 입력하세요';
                this.classList.add('invalid');
            }
        };

        email.onfocus = function(){
            if(this.classList.contains('invalid')){
                this.classList.remove('invalid');
                emailresult.innerHTML = '';
            }
        }
    </script>

 

 

 

 

focusin, focusout 이벤트


 

    <h3>focusin, focusout 이벤트</h3>
    <p>
        focus 이벤트는 해당 입력 필드에서만 동작하고
        버블링 되지 않음<br>
        focusin, focusout은 버블링 적용 됨
    </p>
    <script>
        // 1. 폼 안에 포커스가 된 경우 클래스 추가해보기(X)
        // focus 이벤트는 버블링 되지 않음
        //form.onfocus = () => form.className = 'focused';
        // 2. focusin과 focusout을 사용하면 이벤트 버블링 적용
        form.addEventListener('focusin', () => form.classList.add('focused'));
        form.addEventListener('focusout', () => form.classList.remove('focused'));
    </script>

 

 

 

 

change 이벤트


 

    <h3>change 이벤트</h3>
    <p>
        change : 요소 변경이 끝나면 발생<br>
        텍스트 입력 요소인 경우 요소 변경이 끝날 때가 아니라
        포커스를 잃었을 때 이벤트 발생<br>
        select/checkbox/radio는 선택 값이 변경 된 직후 발생
    </p>
    <script>
        form.introduce.addEventListener('change', () => alert('introduce change!'));
        form.age.addEventListener('change', () => alert('age change!'));
    </script>

 

 

 

 

 

 

 

input 이벤트


 

    <h3>input 이벤트</h3>
    <p>
        input : 키보드 이벤트와 달리 어떤 방법으로든 값을
        변경할 때 발생<br>
        Ex. 마우스를 사용하여 글자를 붙여 넣거나
        음성 인식 기능을 사용해서 글자를 입력할 때도 반응
    </p>
    <script>
        pwd1.addEventListener('input', function(){
            if(pwd1.value != pwd2.value) {
                pwd1.classList.add('invalid');
                pwd2.classList.add('invalid');
                pwdresult.innerHTML = '비밀번호가 일치하지 않습니다';
            } else {
                pwd1.classList.remove('invalid');
                pwd2.classList.remove('invalid');
                pwdresult.innerHTML = '';
            }
        });

        pwd2.addEventListener('input', function(){
            if(pwd1.value != pwd2.value) {
                pwd1.classList.add('invalid');
                pwd2.classList.add('invalid');
                pwdresult.innerHTML = '비밀번호가 일치하지 않습니다';
            } else {
                pwd1.classList.remove('invalid');
                pwd2.classList.remove('invalid');
                pwdresult.innerHTML = '';
            }
        });
    </script>

 

 

 

 

 

 

 

 

submit 이벤트


 

    <h3>submit 이벤트</h3>
    <p>
        submit : 폼을 제출할 때<br>
        폼을 서버로 전송하기 전 내용을 검증하여 폼 전송을
        취소할 때 사용<br>
        폼을 전송하는 방법<br>
        (1) input type="submit" 또는 input type="image" 클릭<br>
        (2) input 필드에서 Enter 키 누르기<br>

        form.submit() 메소드는 자바스크립트만으로 폼 전송을 하고자 
        할 때 사용<br>
        동적으로 폼을 생성하고 서버에 보낼 수 있음<br>
        단, 이 때는 submit 이벤트가 생성 되지 는 않음
    </p>

 

    <button id="search">네이버 검색하기</button>
    <script>
        search.addEventListener('click', function(){
            let keyword = prompt('검색어를 입력해주세요');

            if(keyword){
                let newForm = document.createElement('form');
                newForm.action = 'https://search.naver.com/search.naver';
                newForm.method = 'GET';
                newForm.innerHTML = '<input type="text" name="query" value="' + keyword + '">';
                // 폼을 제출하려면 폼은 문서 내에 있어야 함
                document.body.append(newForm);
                newForm.submit();
            } else {
                alert('검색어를 입력하지 않으셨습니다!');
            }
        });
    </script>

 

 

 

 

 

 

 

 

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

13. cookie  (0) 2022.02.24
12. 정규 표현식  (0) 2022.02.22
자바 스크립트 실습문제  (0) 2022.02.21
10. 이벤트  (0) 2022.02.21
9. BOM(Brower Object Model)  (0) 2022.02.21

 

ㅁㄴㅇㅁㄴㅇ

 

 

 

 

 

 

 

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

12. 정규 표현식  (0) 2022.02.22
11. 이벤트 활용  (0) 2022.02.22
10. 이벤트  (0) 2022.02.21
9. BOM(Brower Object Model)  (0) 2022.02.21
8. 문서 수정  (0) 2022.02.21

 

 

 

이벤트

 

 

 

 

 

 

 

이벤트 활용


이벤트 속성과 이벤트 핸들러(함수)를 연동하여 이벤트 발생 시 특정 기능을 하도록 하는 것

 

 

    <h1>이벤트</h1>
    <ul>
        <li>마우스 이벤트(click, mouseover, mouseout, mousemove ...)</li>
        <li>폼 요소 이벤트(submit, focus)</li>
        <li>키보드 이벤트(keydown, keyup)</li>
        <li>문서 이벤트</li>
    </ul>
    등의 <b>DOM 이벤트</b> 들이 있는데 이러한 이벤트가 발생했을 경우
    실행되는 함수를 <b>이벤트 핸들러</b>라고 하며 핸들러를 할당하는
    방법은 다양하다.

 

 

 

 

 

 


이벤트 설정방법


  • HTML 속성
  • DOM 프로퍼티
  • addEventListener (표준 이벤트 모델)

 

 

 

 

 

 

HTML 속성


  • HTML 내부 속성에 이벤트를 작성하는 방법
  • 인라인 방식은 <script> 태그에 함수를 호출하는 방식을 선호
    예) 클릭 시 이벤트 설정
    <h1 onclick=‘처리로직’></h1>
    또는
    <h1 onclick=‘스크립트 내 함수 호출’></h1>

 

 

 

 

 

▼ 코드 예시 보기 ▼
    <h3>1. HTML 속성</h3>
    <p>
        HTML 안의 onevent 속성에 이벤트 핸들러 할당하는 방법<br>
        Ex. &lt;h1 onclick="실행코드"> 등<br>
        간단한 코드는 그냥 작성하기도 하지만 코드가 길다면
        별도의 함수를 만들고 이를 호출한다.
    </p>

    <button onclick="alert('클릭했네?');">클릭해보세요</button>
    <button onmouseover="mouseover(this);">마우스를 올려보세요</button>
    <script>
        function mouseover(elem){
            alert('마우스 올리지마세요!');
            // 핸들러 내부에 쓰인 this의 값은
            // 핸들러가 할당 된 요소 => 이벤트가 발생한 button
            console.log(elem);
            console.log(elem.innerHTML);
            elem.innerHTML = '마우스 올리지 마세요!';
        }
    </script>

 

 

 

 

 

 

 

 

 

 

DOM 프로퍼티


  • 요소 객체가 갖고 있는 이벤트 속성에 이벤트 핸들러를 연결하는 방법
  • 이벤트 객체를 제거할 땐 속성 값에 null을 넣어주면 됨
  • 이벤트 발생 객체는 핸들러 내부에서 this로 표현 매개 변수로 이벤트 정보 전달(event)
    예) 클릭 시 이벤트 설정
    let h=document.getElementById(‘id명’);
    h.onclick=function{
    수행 기능 설정;
    h(this).onclick=null; // 한 번만 실행
    };

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>2. DOM 프로퍼티</h3>
    <p>
        요소 객체가 가지고 있는 onevent 속성에 이벤트 핸들러를 연결
        하는 방법<br>
        Ex. element.onclick = 이벤트핸들러(함수);<br>
        해당 프로퍼티는 하나 밖에 없기 때문에 여러 개의 이벤트를
        할당할 수는 없다.<br>
        만약 이벤트 객체를 제거할 때에는 속성 값에 null을 넣어주면 된다.
    </p>

 

    <button id="test1">test1 실행 확인</button>
    <button id="test2">test2 실행 확인</button>
    <div id="area1" class="area"></div>
    <script>
        let test1 = document.getElementById('test1');
        let test2 = document.getElementById('test2');

        test1.onclick = function(){
            document.getElementById('area1').innerHTML 
            += 'test1이 실행되었습니다.<br>'; 
            // 핸들러 내부에 쓰인 this의 값은 핸들러가 할당 된 요소
            // => 이벤트가 발생한 버튼
            console.log(this);
            console.log(this.innerHTML);
        };

        // 이전 이벤트 핸들러는 무시된다 => 하나의 이벤트 밖에 연결 할 수 없음
        test1.onclick = () => alert('이벤트 덮어쓰기!');

        function removeEvent(){
            document.getElementById('area1').innerHTML 
            += "test2가 실행되면서 test1 이벤트 제거<br>";
            test1.onclick = null;
        }

        // 선언 되어 있는 함수를 핸들러에 할당함
        test2.onclick = removeEvent;

    </script>

 

 

 

 

 

 

 

 

 

 

addEventListener(표준 이벤트 모델)


  • w3에서 공식적으로 지정한 이벤트 모델
  • 한번에 여러가지 이벤트핸들러 설정 가능
  • this키워드가 이벤트 발생 객체를 의미

 

    예) 클릭 시 이벤트 설정
    let h=document.getElementById(‘id명’);
    h.addEventListener(‘click’,function(){
    수행 기능 설정;
    };

 

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>3. addEventListener</h3>
    <p>
        1, 2번 방식의 이벤트 핸들러 할당의 경우 복수의 핸들러 할당 불가<br>
        element.addEventListener(event, handler, [options])<br>
        element.removeEventListener(event, handler, [options])<br>
        위의 메소드로 핸들러를 추가/삭제하면서 복수의 핸들러를 할당할 수 있다.
    </p>

 

    <button id="btn">실행확인</button>
    <script>
        let btn = document.querySelector("#btn");
        // 복수의 이벤트 핸들러 할당 가능
        btn.addEventListener('click', () => alert('첫 번째 이벤트 동작!'));
        btn.addEventListener('click', () => btn.style.background = 'red');

        // 핸들러를 삭제하려면 핸들러 할당 시 사용한 함수를
        // 그대로 전달해야 하므로 위와 같은 경우는 삭제 불가
        // 함수 선언하여 핸들러 할당해서 삭제해보기
        function myFunction(){
            alert('곧 삭제될 친구!');
        }

        btn.addEventListener('mouseover', myFunction);

        // 삭제 테스트
        btn.removeEventListener('mouseover', myFunction);
    </script>

 

 

 

 

 

 

 

 

 

 

이벤트 전달


  • 버블링 방식 : 자식에서 부모 노드로 올라가면서 이벤트가 실행
  • 캡쳐링 방식 : 부모노드에서 자식 노드로 내려가면서 이벤트가 실행

 

 

 

 

▼ 코드 예시 보기 
    <button id="evtObj">이벤트 객체 확인</button>
    <!-- HTML 속성 안에서도 event 객체 사용 가능 -->
    <button onclick="console.log(event);">이벤트 객체 확인</button>
    <script>
        let evtObj = document.querySelector("#evtObj");
        evtObj.onclick = function(event){
            console.log(event);
            console.log(event.type + " 이벤트");
            console.log(event.currentTarget);
            console.log("에서 발생");
            console.log("이벤트가 발생한 곳의 좌표는 ");
            console.log(event.clientX + " : " + event.clientY);
        };
    </script>

 

    <h1>버블링과 캡쳐링</h1>
    <p>
        버블링이란 한 요소에 이벤트가 발생하면 할당 된 핸들러가 동작하고,
        이어서 부모 요소의 핸들러가 동작하는 것<br>
        가장 최상단의 조상 요소를 만날 때까지 이 과정이 반복 되면서
        요소 각각에 할당 된 핸들러가 동작한다.
    </p>

 

    <div onclick="alert('1번 div');" class="div-test div1">
        <div onclick="alert('2번 div');" class="div-test div2">
            <div onclick="alert('3번 div');" class="div-test div3">
                <div onclick="alert('4번 div');" class="div-test div4"></div>
            </div>
        </div>
    </div>

 

    <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>
    <p>
        event.target : 실제 이벤트가 시작 된 타깃 요소로
        버블링이 진행되어도 변함이 없음<br>
        event.currentTarget : 현재 실행 중인 핸들러가 할당 된 요소를
        의미<br>
        이벤트 객체의 메소드 event.stopPropagation()을 사용하면
        버블링 중단을 명령함
    </p>
    <div onclick="bubble(event);" class="div-test div1">
        <div onclick="bubble(event);" class="div-test div2">
            <div onclick="bubble(event);" class="div-test div3">
                <div onclick="bubble(event);" class="div-test div4"></div>
            </div>
        </div>
    </div>
    
    
        <script>
        function bubble(event){
            console.log("event.target");
            console.log(event.target);
            console.log("event.currentTarget");
            console.log(event.currentTarget);
            // 버블링 막기
            event.stopPropagation();
        }
    </script>

 

 

 

 

 

    <h3>이벤트 캡쳐링</h3>
    <p>
        캡처링 : 이벤트가 하위 요소로 전파<br>
        버블링 : 이벤트가 상위 요소로 전파<br>
        캡쳐링 단계에서 이벤트를 잡아내려면 addEventListener의 capture 옵션을 true로 설정
    </p>
    <div class="div-test div1 capture">
        <div class="div-test div2 capture">
            <div class="div-test div3 capture">
                <div class="div-test div4 capture"></div>
            </div>
        </div>
    </div>
    
        <script>
        let divs = document.querySelectorAll(".capture");
        console.log(divs);
        divs.forEach(function(item){
            console.log(item);
            item.addEventListener('click', () => alert('캡쳐링 : ' + item.className), true);
            item.addEventListener('click', () => alert('버블링 : ' + item.className));
        });
    </script>

 

 

 

 

 

 

 

기본 이벤트


기본 이벤트 : 태그 중 이벤트 핸들러를 기본적으로 가지고 있는 것

 

<a>, <input type=‘submit’> 입력양식에서 많이 사용

 

 

 

 

 

기본 이벤트 제거


  • 1. event.preventDefault() 호출
  • 2. onevent 통해 할당 된 이벤트 핸들러의 return 값을 false로 반환

 

 

 

 

 

▼ 코드 예시 보기 
    <h3>기본 이벤트의 제거</h3>
    <p>
        기본 이벤트란<br>
        - a 태그를 통한 페이지 이동<br>
        - submit 시 입력 양식 제출 후 페이지 갱신<br>
        등의 브라우저 기본 동작을 말함<br>

        태그에 기본적으로 설정 되어 있는 이벤트를 제거하는
        방법은 <br>
        1. event.preventDefault()<br>
        2. onevent를 통해 할당 된 이벤트 핸들러의 return
        값을 false로 반환
    </p>
    <a href="14_BOM.html" onclick="event.preventDefault()">클릭해도 절대 이동할 수 없는 a태그</a>

    <form onsubmit="return invalidate();">
        <label for="password">비밀번호 : </label>
        <input type="password" name="password" id="password" requried>
        <br>
        <label for="checkPwd">비밀번호 확인 : </label>
        <input type="password" name="checkPwd" id="checkPwd" required>
        <input type="submit" value="제출">
    </form>

    <script>
        function invalidate(){
            let pwd1 = document.getElementById('password').value;
            let pwd2 = document.getElementById('checkPwd').value;

            if(pwd1 == pwd2){
                alert('입력 비밀번호가 일치합니다');
            } else {
                alert('입력 비밀번호가 일치하지 않습니다');
                document.getElementById('checkPwd').select();
                return false;
            }
        }   
    </script>

 

 

 

 

 

 

 

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

11. 이벤트 활용  (0) 2022.02.22
자바 스크립트 실습문제  (0) 2022.02.21
9. BOM(Brower Object Model)  (0) 2022.02.21
8. 문서 수정  (0) 2022.02.21
7. 요소 검색  (0) 2022.02.18

 

 

 

 

BOM(Brower Object Model)


 

 

 

    <h1>window 객체</h1>
    <p>
        window 객체는 자바스크립트의 최상위 객체이며
        BOM과 DOM으로 나뉜다.
    </p>
    <p>
        BOM(Browser Object Model)
        : location 객체, navigator 객체, history 객체, screen 객체
    </p>
    <p>
        DOM(Document Object Model) : document 객체
    </p>

 

 

 

 

 

 

 

 

 

 

 

 

window 객체


  • 자바스크립트에서 최상위 객체 생성되는 모든 객체가 window객체 하위에 존재
  • 브라우저 창에 대한 설정하는 객체

 

생성
window.open(‘주소‘,‘이름 또는 open방식‘,’형태‘);

 

 

 

 

 

 

▼ 코드 예시 확인 ▼
    <h3>window 객체</h3>
    <p>
        브라우저 창에 대한 설정을 하는 객체
    </p>
    <button onclick="test1();">13_문서수정</button>
    <button onclick="test2();">네이버</button>
    <script>
        function test1(){
            //window.open('주소', '이름 또는 open 방식', '형태');
            window.open('13_문서수정.html', 'popup1', 'width=1080, height=800');
            // 창의 이름을 지정하면 동일한 이름으로 다시 open 했을 때 
            // 기존에 열린 창의 내용이 변경된다
            // window.open('12_주요노드프로퍼티.html', 'popup1', 'width=1080, height=800');
        }

        function test2(){
            window.open("https://www.naver.com", "_self");
            // _blank : 새 창으로 열림. 기본 값.
            // _self : 현재 페이지를 대체
        }
    </script>

 

 

 

 

 

window 객체 메소드


 

 

 

 

 

▼ 코드 예시 확인 
    <h3>window 객체의 timer 메소드</h3>
    <h4>setTimeout</h4>
    <button onclick="test3();">실행확인</button>
    <script>
        function test3(){
            // 새 창이 열린 뒤 3초 후 자동으로 닫기
            let myWindow = window.open();
            // setTimeout(func, delay)
            // func : 실행 함수, delay : 대기 시간 (밀리세컨단위)
            setTimeout(function(){
                myWindow.close();
            }, 3000);
        }
    </script>

 

 

 

 

    <h4>setInterval</h4>
    <button onclick="test4();">실행확인</button>
    <div id="area1" class="area"></div>
    <script>
        function test4(){
            let area1 = document.getElementById('area1');

            // setInterval(func, interval)
            // func : 실행 함수, interval : 반복할 시간(밀리세컨단위)
            setInterval(function(){
                let date = new Date();
                area1.innerHTML = date.getHours() + " : "
                                + date.getMinutes() + " : "
                                + date.getSeconds();
            }, 1000);
        }
    </script>

 

 

 

 

    <h4>clearInterval</h4>
    <button onclick="test5();">start</button>
    <button onclick="test5_2();">stop</button>
    <div id="area2" class="area"></div>
    <script>
        let timer;

        function test5(){
            let area2 = document.getElementById('area2');
            let count = 0;
            if(timer === undefined){
                timer = setInterval(function(){
                        area2.innerHTML = parseInt(count/100/60%60)
                                        + " : "
                                        + parseInt(count/100%60)
                                        + " : "
                                        + (count % 100);
                        count++;
                },10);
            }
        }
        function test5_2(){
            clearInterval(timer);
            timer = undefined;
        }
    </script>

 

 

 

 

 

 

 

 

 

window.onload속성


  • 윈도우 객체가 로드가 완료되면 자동으로 onload에 설정되어 있는 함수를 실행시키는 속성
  • 윈도우 객체 로드 완료 : 모든 태그가 화면에 나타날 때

 

생성
window.onload =function(){
        로직구성
        };


또는
작성된 함수 호출 ;



 

 

 

 

 

 

 

 

screen객체


client 운영체제 화면에 대한 속성값을 가지는 객체

 

 

 

 

 

▼ 코드 예시 확인 
    <h1>BOM(Browser Object Model)</h1>
    <h3>screen 객체</h3>
    <p>
        웹 브라우저 화면이 아닌 운영체제 화면의 속성을 가지는 객체
    </p>
    <button onclick="test6();">실행확인</button>
    <script>
        function test6(){

            let child = window.open("", "", "width=800, height=500");
            child.resizeTo(screen.width, screen.height);

            setInterval(function(){
                child.resizeBy(-20, -20);
                child.moveBy(10, 10);
            }, 500);

            console.log("화면 너비 : " + screen.width);
            console.log("화면 높이 : " + screen.height);
            console.log("실제 화면에서 사용 가능한 너비 : " + screen.availWidth);
            console.log("실제 화면에서 사용 가능한 높이 : " + screen.availHeight);
            console.log("사용 가능한 색상 수 : " + screen.colorDepth);
            console.log("한 픽셀 당 비트 수 : " + screen.pixelDepth);
        }
    </script>

 

 

 

 

 

 

 

 

location객체


  • 브라우저의 주소표시줄(URL)과 관련된 객체
  • 프로토콜 종류, 호스트 이름, 문서위치 등의 정보를 가진다.

 

 

 

 

 

▼ 코드 예시 확인 
    <h3>location 객체</h3>
    <p>
        브라우저 주소 표시줄과 관련 된 객체
    </p>
    <button onclick="test7();">실행확인</button>
    <div id="area3" class="area-big"></div>
    <script>
        function test7(){
            let area3 = document.getElementById('area3');
            let html;
            for(let key in location){
                html += (key + " : " + location[key] + "<br>");
            }
            area3.innerHTML = html;
        }
    </script>

 

 

    <!-- location.href : 현재 브라우저 창에 열린 문서의 url -->
    <button onclick="location.href = 'https://www.naver.com'">네이버로 이동</button>
    <button onclick="location = 'https://www.naver.com'">네이버로 이동</button>

    <br><br>

    <button onclick = "location = location">새로고침</button>
    <button onclick = "location.href = location.href">새로고침</button>
    <!-- reload는 현재 위치에서 새로고침을 한다 -->
    <button onclick="location.reload();">현 위치에서 새로고침</button>

    <br><br>
    <!-- replace는 뒤로 가기 사용할 수 없다 -->
    <button onclick="location.replace('https://google.com');">구글로 이동</button>

 

 

 

 

 

 

 

 

location 메소드


 

 

 

 

▼ 코드 예시 확인 
    <h3>navigator 객체</h3>
    <p>
        웹 페이지를 실행하고 있는 브라우저에 대한 정보를 가지는 객체
    </p>
    <button onclick="test8();">실행확인</button>
    <div id="area4" class="area-big"></div>
    <script>
        function test8(){
            let area4 = document.getElementById('area4');
            let html = '';
            html += '브라우저의 코드명 : ' + navigator.appCodeName + '<br>';
            html += '브라우저의 이름 : ' + navigator.appName + '<br>';
            html += '브라우저 전체 정보 : ' + navigator.userAgent + '<br>';
            html += '브라우저 언어 : ' + navigator.language + '<br>';
            html += '사용중인 운영체제 : ' + navigator.platform + '<br>';
            area4.innerHTML = html;

        }
    </script>

 

    <h3>history 객체</h3>
    <button onclick="test9();">실행확인</button>
    <div id="area5" class="area-big"></div>
    <script>
        function test9(){
            // 히스토리 객체의 길이 출력
            let area5 = document.getElementById('area5');
            area5.innerHTML = 'history.length : ' + history.length;
        
            // 뒤로 가기
            // history.back();
            // history.go(-2);

            // 앞으로 가기
            //history.forward();
            history.go(1);
        }
    </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

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

자바 스크립트 실습문제  (0) 2022.02.21
10. 이벤트  (0) 2022.02.21
8. 문서 수정  (0) 2022.02.21
7. 요소 검색  (0) 2022.02.18
6. DOM(Document Object Model)  (0) 2022.02.18

 

 

 

노드 생성과 삽입 메소드


 

노드 생성 메소드

 

 

 

노드 삽입 메소드

 

 

 

노드 삭제 메소드

 

 

 

 

 

 

▼ 코드 예시 보기 ▼
    <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

+ Recent posts