정규 표현식은 특정 키워드를 이용해서 문자열의 데이터를 검사해준다.


대표적인 예로는 웹사이트 가입 시 Id 를 올바르게 입력했는지 이름은 잘 입력했는지 검사해준다.


regExp라는 키워드를 사용한다.


var regExp = new regExp('규칙내용');


이나 간단하게


var regExp = /규칙내용/;


위와 같이 선언하여


메소드 test, exec


그리고 String 메소드와 함께 match, replace, search, split 등이 있다.


test() : 규칙에 해당하면 true 반환


exec() : 실행




이 외에도 해당 글자를 바꾸는 대체문자와 검사 범위를 설정하는 플래그 문자


그리고 문자열의 앞과 뒤를 구분하는 표현식, 특정 문자를 검출하는 메타문자, 수량문자 등이 있다.


다음 예를 통해 쓰임을 확인해보자



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style>
	.area {
		border:1px solid black;
		height:150px;
		background:lightgray;
	}
</style>
</head>
<body>
	<h1>정규표현식</h1>
	<h3>정규표현식 객체 생성</h3>
	<button onclick="test1()">확인하기</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function test1() {
			// 정규표현식은 일반적으로 회원가입 시 암호가 간단하지 않고 적절한지 판별할 때 사용
			// 정규식 변수를 선언한다.
			// var regExp = new RegExp("script");
			var regExp = /script/; // 이와같이 간단하게 사용 가능
			var str = "javascript jquery ajax";
			
			// 메소드를 사용한다.
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "test()함수 사용 : " + regExp.test(str) + "<br>";
			area1.innerHTML += "exec()함수 사용 : " + regExp.exec(str) + "<br>";
			
			// String 메소드 사용도 많이 한다.
			area1.innerHTML += "match()함수 사용 : " + str.match(regExp) + "<br>";
			// 해당 글자를 바꿔줌
			area1.innerHTML += "replace()함수 사용 : " + str.replace(regExp, "스크립트") + "<br>";
			// 글자가 몇번째에 존재하는지
			area1.innerHTML += "search()함수 사용 : " + str.search(regExp) + "<br>";
			// 우리에게 익숙한 split
			area1.innerHTML += "split()함수 사용 : " + str.split(regExp) + "<br>";
			
			
		}
	</script>
	
	<hr>
	
	<h3>대체문자</h3>
	
	<p>정규표현식을 사용하면 문자열 객체의 replace()메소드를 사용할 때
	대체문자를 사용할 수 있다.</p>
	<button onclick="test2()">실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function test2() {
			var regExp = /a/;
			
			var str = "javascript jquery ajax";
			
			//일치하는 문자열
			//var output = str.replace(regExp, '($&)');
			
			//일치하는 부분의 앞부분 문자열
			//var output = str.replace(regExp, '($`)');
			
			//일치하는 부분의 뒷 부분 문자열
			var output = str.replace(regExp, "($')");
			
			alert(output);
			
			
		}
	</script>
	
	<h3>플래그 문자</h3>
	<p>
	g(global) : 전역 비교를 수행한다.<br>
	i(ignoreCase) : 대소문자를 가리지 않고 비교한다.<br>
	m(multiLine) : 여러줄의 검사를 수행한다.<br>
	</p>
	
	<button onclick="test3()">실행확인</button>
	<div id="area3" class="area"></div>
	
	<script type="text/javascript">
		function test3() {
			var regExp = /a/ig;
			var str = "JavaScript JQuery Ajax";
			
			var area3 = document.getElementById("area3");
			
			area3.innerHTML += str.replace(regExp, "($&)");
			
		}
	</script>
	
	<h3>앵커문자</h3>
	<p>문자열의 앞과 뒤를 구분해주는 정규표션식 기호</p>
	<button onclick="test4()">실행확인</button>
	<div id="area4" class="area"></div>
	
	<script type="text/javascript">
		function test4() {
			// '^'표시는 ~~로 시작하는 의 의미
			var regExp = /^j/gim;
			
			var str = "JavaScript\nJQuery\nAjax";
			
			var area4 = document.getElementById("area4");
			
			area4.innerHTML += "^ABC : " + str.replace(regExp, '($&)') + "<br>";
			
			var regExp2 = /ipt&/gim;
			
			area4.innerHTML += "ABC$ : " + str.replace(regExp, '($&)') + "<br>";
			
		}
	</script>
	
	<h3>메타문자</h3>
	
	<p>자바스크립트 정규 표현식 객체가 갖는 가장 유용한 기능이다.</p>
	<button onclick="test5();">실행확인</button>
	<div id="area5" class="area"></div>
	<script type="text/javascript">
		function test5() {
			var regExp1 = /[aj]/ig;
			var regExp2 = /[^aj]/ig;
			var regExp3 = /[a-z]/ig; // 알파벳인지
			
			var str = "JavaScript JQuery Ajax";
			
			var area5 = document.getElementById("area5");
			
			area5.innerHTML += "[aj] : " + str.replace(regExp1, "($&)") + "<br>";
			
			area5.innerHTML += "[^aj] : " + str.replace(regExp2, "($&)") + "<br>";
			
			area5.innerHTML += "[a-z] : " + str.replace(regExp3, "($&)") + "<br>";
		
			var regExp4 = /[0-9]/g; // 숫자인지
			var regExp5 = /[가-힣]/g; // 한글인지
			
			var str2 = "123JavaScript안녕하세요"
			
			area5.innerHTML += "[0-9] : " + str2.replace(regExp4, "($&)") + "<br>";

			area5.innerHTML += "[가-힣] : " + str2.replace(regExp5, "($&)") + "<br>";
			
		}
	</script>
	
	<hr>
	
	<h3>메타문자를 이용한 주민번호 확인</h3>
	<label>주민번호 입력 : </label>
	<input type="text" id="pno">
	<button onclick="test6();">실행확인</button>
	<div id="area6" class="aera"></div>
	
	<script type="text/javascript">
		function test6() {
			var regExp = /......-......./; // 점은 자리를 의미, 해당 열은 6번째 이후 '-'가 들어오나 안오나를 체크
			// 만약 . 점을 구분하고 싶을 땐 \를 사용 아래에서 설명
			var pno = document.getElementById("pno").value;
			
			if (regExp.test(pno)) {
				alert("정상입력");
			}else {
				alert("잘못입력");
			}
			
		}
	</script>
	
	<hr>
	
	<h3>추가 메타 문자</h3>
	<p>\d : 숫자<br>
	\w : 아무 단어<br>
	\s : 공백문자(탭, 띄어쓰기, 줄바꿈)<br>
	\D : 숫자 아님<br>
	\W : 아무 단어 아님<br>
	\S : 공백문자가 아님</p>
	
	<label>주민번호 입력 : </label>
	<input type="text" id="pno2">
	<button onclick="test7()">실행확인</button>
	<div id="area7" class="area"></div>
	
	<script type="text/javascript">
		function test7() {
			var regExp = /\d\d\d\d\d\d-[1234]\d\d\d\d\d\d/; // 앞 6자리는 숫자, 뒷자리 맨 앞에는 1234 안에서 입력하고 뒷 6자리 숫자 한다.
			
			var pno = document.getElementById("pno2").value;
			
			if (regExp.test(pno)) {
				alert("정상입력");
			}else {
				alert("잘못입력");
			}
			
		}
	</script>
	
	<h3>수량문자</h3>
	<p>
	a+ : a가 적어도 1개 이상<br>
	a* : a가 0개 또는 여러개<br>
	a? : a가 0개 또는 1개<br>
	a{5} : a가 5개<br>
	a{2,5} : a가 2~5개<br>
	a{2,} : a가 2개 이상<br>
	a{,5} : a가 5개 이하<br>
	</p>
	
	<label>주민번호 입력 : </label>
	<input type="text" id="pno3">
	<button onclick="test8();">실행확인</button>
	<div id="area8" class="area"></div>
	
	<script type="text/javascript">
		function test8() {
			var regExp = /\d{2}(0[1-9]|1[0-2])(0[1-9]|[1-2][0-9]|3[01])-[1234]\d{6}/; // | 는 or 연산
			// 숫자는 2자리가 온다, 첫번째 ()의 의미는 01~12까지 올 수 있다이고, 두번째 ()는 01~31까지 올 수 있다는 표현
			// 뒤의 [1234]\d{6}은 주민번호 뒷자리를 의미
			
			var pno = document.getElementById("pno3").value;
			
			if (regExp.test(pno)) {
				alert("정상입력");
			}else {
				alert("잘못입력");
			}
			
			
		}
	</script>
</body>
</html>




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h1>회원가입 유효성 체크</h1>
       
    <form action="" method="post" onsubmit="return validate();">       <!-- 제출시 행동 -->
    	<label for="userid">* 유저아이디</label>
    	<input type="text" name="userid" id="userid"><br>
    	<label for="pass">* 비밀번호</label>
    	<input type="password" name="pass" id="pass"><br>
    	<label for="pass1">* 확인</label>
    	<input type="password" name="pass1" id="pass1"><br>
    	<label for="name">* 이름</label>
    	<input type="text" name="name" id="name"><br>
    	<label for="email">* 이메일</label>
    	<input type="text" name="email" id="email"><br>
    	<label for="tel1">전화번호</label>
    	<input type="text" name="tel1" id="tel1" size="3" maxlength="3">-
    	<input type="text" name="tel2" id="tel2" size="3" maxlength="4">-
    	<input type="text" name="tel3" id="tel3" size="3" maxlength="4">
    	<br><br>
    	<label for="job">직업</label>
    	<select name="job" id="job">
    		<option>개발자</option>
    		<option>프로그래머</option>
    		<option>자영업자</option>
    	</select><br>
    	<label>성별</label>
    	<input type="radio" name="gender" value="m"> 남
    	<input type="radio" name="gender" value="f"> 여<br>
    	<label for="hobby">취미</label>
    	<input type="checkbox" name="hobby" value="reading"> 독서
    	<input type="checkbox" name="hobby" value="drama"> 드라마보기
    	<input type="checkbox" name="hobby" value="soccer"> 축구<br>
    	<input type="checkbox" name="hobby" value="movie"> 영화보기
    	<input type="checkbox" name="hobby" value="basket"> 드라마보기
    	<input type="checkbox" name="hobby" value="game"> 게임<br>
    	<input type="reset" value="리셋">
    	<input type="submit" value="완료">
       
    </form>
    <script>
    	var userId = document.getElementById("userid");
    	var pass = document.getElementById("pass");
    	var pass1 = document.getElementById("pass1");
    	var name1 = document.getElementById("name");
    	var email = document.getElementById("email");
    	var tel1 = document.getElementById("tel1");
    	var tel2 = document.getElementById("tel2");
    	var tel3 = document.getElementById("tel3");
    	var job = document.getElementById("job");
    	var gender = document.getElementsByName("gender");
    	var hobby = document.getElementsByName("hobby");

    	function validate() {
    		var regExp;
    		//이메일 검사(adfg@dfds.dsf)
    		//4글자 이상이 나오고 
    		//@가 나오고 1글자 이상 주소 . 글자 1~3
    		regExp = /@/;
    		console.log(email.value)
    		if(regExp.test(email.value)){
    			console.log("@포함");
    			var emailTemp = email.value.split('@');
    			console.log(emailTemp[0].length)
    			if(emailTemp[0].length >= 4){
        			console.log("이메일id 4글자 이상 체크");
        			var emailCheck = emailTemp[1].split('.');
        			console.log(emailCheck[0].length)
        			if(emailCheck[0].length >= 1){
            			console.log("이메일 주소 1글자 이상 체크");
            			console.log(emailCheck[1].length)
            			if(emailCheck[1].length <= 3 && emailCheck[1].length >= 1){
                			console.log("이메일 주소.뒤 1~3 체크 \n이메일 체크");
                		}else {
                			alert("E-mail을 확인하세요!");
                			email.select();
            				return false;
            			}
            		}else {
            			alert("E-mail을 확인하세요!");
            			email.select();
        				return false;
        			}
        		}else {
        			alert("E-mail을 확인하세요!");
        			email.select();
    				return false;
    			}
    		}else {
    			alert("E-mail을 확인하세요!");
    			email.select();
				return false;
			}
    		
    		
    		//아이디 검사
    		//첫글자는 반드시 영문 소문자, 총 4~12자로 이루어지고
    		//숫자가 반드시 하나 이상 포함되어야 함
    		//영문 소문자와 숫자로 이루어져야 한다.
			
    		regExp = /[a-z]/;
    		var regExp2 = /[0-9]/;
    		console.log(regExp.test(userId.value.charAt(0)));
			if(regExp.test(userId.value.charAt(0))){
    			console.log("첫글자 소문자");
    			console.log(userId.value.length >= 4 && userId.value.length <= 12);
    			if(userId.value.length >= 4 && userId.value.length <= 12){
					console.log("4~12자 체크")
					console.log(regExp2.test(userId.value));
        			if(regExp2.test(userId.value)){
						console.log("숫자 하나 체크");
						var idtemp = userId.value.replace(regExp2, ""); // 숫자 필터
						console.log(idtemp);
						regExp = /[A-Z]/;
            			if(regExp.test(idtemp)){
            				alert("ID에 대문자는 사용 할 수 없어요!");
                			userId.select();
            				return false;
                		}else {
            				console.log("소문자 체크");
            				console.log("ID 체크");
            			}
            		}else {
            			alert("숫자를 꼭 포함한 ID이어야 합니다.");
            			userId.select();
        				return false;
        			}
        		}else {
        			alert("ID는 4~12자 이내로 입력해주세요.");
        			userId.select();
    				return false;
    			}
    		}else {
    			alert("첫 글자는 소문자이어야 합니다.");
    			userId.select();
				return false;
			}
			//비밀번호 확인 검사
			//비밀번호와 비밀번호 확인 값이 일치
			
			
    		
			if(pass.value == pass1.value){
    			console.log("비밀번호 확인을 올바르게 했습니다!");
    		}else {
    			alert("비밀번호를 다시 한번 확인해 주세요.");
				return false;
			}
			
			//이름 검사
			//2글자 이상, 한글만
			console.log(name1.value);
			console.log(name1.value.length);
			if(name1.value.length >= 2){
				console.log("두 글자 이상 확인");
				var korCheck = true;
				regExp = /^[가-힣]+$/;
				for (var i = 0; i < name1.value.length; i++) {
					if(regExp.test(name1.value.charAt(i))){ }
					else{
						alert(regExp.test(name1.value.charAt(i)));
						korCheck = false;
					}
				}
				if (korCheck) {
					console.log("한글 확인");
				}else {
					alert("이름은 한글만 입력해주세요!");
					return false;
				}
    		}else {
    			alert("이름은 두 글자 이상이어야 합니다!");
				return false;
			}


			//전화번호 검사
			//전화번호 앞자리는 2~3자리 숫자
			//두번째자리는 3~4자리 숫자
			//세번째 자리는 4자리 숫자
			console.log("전화번호 체크");
			regExp = /[0-9]{2,3}/;
			console.log(regExp.test(tel1.value));
			if(regExp.test(tel1.value)){
				console.log("첫째 자리 체크");
				regExp = /[0-9]{3,4}/;
				if(regExp.test(tel2.value)){
					console.log("첫째 자리 체크");
					regExp = /[0-9]{4}/;
					if(regExp.test(tel3.value)){
						console.log("셋째 자리 체크");
						console.log("전화번호 정상");
		    		}else {
		    			alert("전화번호 셋째 자리 오류!");
						return false;
					}
	    		}else {
	    			alert("전화번호 둘째 자리 오류!");
					return false;
				}
    		}else {
    			alert("전화번호 첫째 자리 오류!");
				return false;
			}
			
			alert("가입을 환영합니다!");

		}
	  	
		
		
    </script>
</body>
</html>



-  Object 객체


Java Script의 기본 자료형인 객체이다.


모든 타입을 받을 수 있는 특징이 있고 생성자 함수를 통해 만들 수 있다.




-  Object 메소드


hasOwnProperty : 생성한 객체가 어떤 속성을 가지고 있는지 알 수 있다.


propertyIsEnumerable : 이 메소드는 Enumerable와 Nonenumerable과 관련이 있다.


Enumerable와 Nonenumerable는 열거 가능 여부를 의미하는데 이는 반복문에 영향을 끼치기 때문에


반복문 실행 가능 여부라고 생각하면 된다.




-  toString


해당 객체의 속성들을 String으로 나열해준다. 보통 임의로 만들어 사용한다.




-  Constructor


typeof는 new Number 객체 같은 클래스로 선언한 것은 비교할 수 없는데


Constructor은 이 문제를 해결해준다.





-  Number(toFixed)


Number 클래스의 메소드인 toFixed는 숫자의 반올림 기능을 가지고 있다.


괄호 () 안에 숫자를 입력받아 자릿수를 정한다.


단, 반환된 반올림 값은 String 형으로 주의를 해야한다.





-  HTML 관련 String 메소드


anchor : a태그로 포장, 감싸준다.


big : big 태그로 포장한다.


bold : 글씨 굵게


fontcolor : 폰트 색깔 변경


fontsize : 폰트 크기 변경


italics : 글자 기울여서 표현


link : 글씨에 링크달기


small : 글씨 작게


strike : 글씨 취소선(중간에 사선)


sub : 아래 첨자


sup : 위 첨자




-  Date 객체


날짜 데이터를 관리 할 수 있는 객체




-  Date 메소드


전부 현재 기준


getFullYear : 년도 반환


getMonth : 월 반환


getDate : 일 반환


getDay : 요일 반환()


getHours : 시간 반환


getMinutes : 분 반환


getSeconds : 초 반환


getMilliseconds : 밀리초 반환


getTimezoneOffset : GMT 시간 기준 현재 지역이 몇 시간 차이나는지 반환


getTime : 1970년 1월 1일 0시 0분 00초 기준으로 지난 밀리세컨 단위의 시간을 리턴



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		height: 150px;
		background: lightgray;
		border: 1px solid black;
	}
	.area-big{
		height: 400px;
		background: lightgray;
		border: 1px solid black;
	}
</style>
</head>
<body>
	<h1>내장객체</h1>
	<h3>object 객체</h3>
	<p>자바스크립트의 가장 기본적인 내장 객체이다.<br>
	Object 생성자 함수를 통해 만들어진 인스턴스이다.</p>
	<button onclick="test1();">실행확인</button>
	
	<script type="text/javascript">
		function test1() {
			var obj1 = {};
			var obj2 = new Object();
			
			console.log(obj1 instanceof Object);
			console.log(obj2 instanceof Object);
		}
	</script>
	
	<br>
	
	<h3>Object 객체의 기본 메소드</h3>
	<h4>hasOwnProperty()와 propertyIsEnumerable()메소드</h4>
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function test1() {
			var object = {age:20};
			
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "name속성을 가지고 있니? : " + object.hasOwnProperty('name') + "<br>";
			area1.innerHTML += "age속성을 가지고 있니? : " + object.hasOwnProperty('age') + "<br>";
			
			area1.innerHTML += "반복문을 사용할 수 있니? : " + object.propertyIsEnumerable('age') + "<br>";
			area1.innerHTML += "반복문을 사용할 수 있니? : " + object.propertyIsEnumerable('name') + "<br>";
			
		}
	</script>
	
	<br>
	
	<h4>toString() 메소드</h4>
	<button onclick="test3();"> 실행확인</button>
	<div id="area2" class="area"></div>
	<script type="text/javascript">
		function test3() {
			var student = {
					name:'이르므',
					age:20,
					toString:function(){
						return "name : " + this.name + "\nage : " + 20;
					}
			}
			
			//alert(student.toString());
			alert(student);
		}
	</script>
	
	<hr>
	
	<h4>constructor 속성</h4>
	<p>자료형 검사할 때 유용하게 사용할 수 있다.</p>
	<button onclick="test4();">실행확인</button>
	<div id="area3" class="area"></div>
	<script type="text/javascript">
		function test4() {
			var num1 = 120;
			var num2 = new Number(120);
			
			console.log("num1의 자료형 : " + typeof(num1));
			console.log("num2의 자료형 : " + typeof(num2));
			console.log("num1 + num2 : " + (num1 + num2));
			
			console.log(num2);
			
			var area3 = document.getElementById("area3");
			
			if(typeof(num1) == 'number'){
				area3.innerHTML += "num1은 숫자입니다.<br>";
			}else {
				area3.innerHTML += "num1은 숫자가 아닙니다.<br>";
			}
			
			if(typeof(num2) == 'number'){
				area3.innerHTML += "num2은 숫자입니다.<br>";
			}else {
				area3.innerHTML += "num2은 숫자가 아닙니다.<br>";
			}
			
			if(num1.constructor == Number){
				area3.innerHTML += "다시 봐도 num1은 숫자입니다.<br>";
			}else {
				area3.innerHTML += "아무리 봐도 num1은 숫자가 아닙니다.<br>";
			}
			
			if(num2.constructor == Number){
				area3.innerHTML += "다시 보니 num2은 숫자입니다.<br>";
			}else {
				area3.innerHTML += "아무리 봐도 num2은 숫자가 아닙니다.<br>";
			}
		}
	</script>
	
	<hr>
	
	<h3>Number 객체</h3>
	<button onclick="test5();">실행확인</button>
	<p>toFixed() 테스트</p>
	<div id="area6" class="area"></div>
	
	<script type="text/javascript">
		function test5() {
			var num1 = 123.456789;
			var num2 = 123;
			
			var area6 = document.getElementById("area6");
			
			area6.innerHTML += "num1의 기본값 : " + num1 + "<br>";
			area6.innerHTML += "num2의 기본값 : " + num2 + "<br>";
			
			area6.innerHTML += "num1.toFixed(1) : " + num1.toFixed(1) + "<br>";
			area6.innerHTML += "num1.toFixed(4) : " + num1.toFixed(4) + "<br>";
			
			area6.innerHTML += "num2.toFixed(4) : " + num2.toFixed(4) + "<br>";
			area6.innerHTML += "num1.toFixed(4) + num2.toFixed(4) : " + (num1.toFixed(4) + num2.toFixed(4)) + "<br>";
			
			// toFixed는 대상을 지정한 자리수 기준으로 반올림 해준다.
			// 단, toFixed의 return 자료형은 string임을 주의하자
			area6.innerHTML += "그럼 자료형은? : " + typeof(num1.toFixed(1)) + "<br>";
			
		}
	</script>
	
	<hr>
	
	<h3>String 객체의 HTML 관련 메소드</h3>
	<p>String 객체의 메소드는 크게 기본메소드와 HTML 관련 메소드로 구분할 수 있다.</p>
	<button onclick="test6();">실행확인</button>
	<div id="area7" class="area-big"></div>
	<script type="text/javascript">
		function test6() {
			var str = "javascript";
			
			var area7 = document.getElementById("area7");
			
			area7.innerHTML += "기본값 : " + str + "<br>";
			
			// anchor() : a태그로 포장해줌
			area7.innerHTML += "anchor() : " + str.anchor() + "<br>";
			// big() : big태그로 포장해줌
			area7.innerHTML += "big() : " + str.big() + "<br>";
			// bold() : bold 글자 굵게, b태그
			area7.innerHTML += "bold() : " + str.bold() + "<br>";
			// fontcolor() : 글자 색깔 변경
			area7.innerHTML += "fontcolor() : " + str.fontcolor("red") + "<br>";
			// fontsize() : 글자 크기 변경
			area7.innerHTML += "fontsize() : " + str.fontsize(20) + "<br>";
			// italics() : 글씨 기울게
			area7.innerHTML += "italics() : " + str.italics() + "<br>";
			// link() : 글씨에 링크달기
			area7.innerHTML += "link() : " + str.link("https://www.naver.com") + "<br>";
			// small() : 글씨 작게
			area7.innerHTML += "small() : " + str.small() + "<br>";
			// strike() : 글씨 취소선
			area7.innerHTML += "strike() : " + str.strike() + "<br>";
			// sub() : 아래 첨자
			area7.innerHTML += "sub() : " + str.sub() + "<br>";
			// sup() : 위 첨자
			area7.innerHTML += "sup() : " + str.sup() + "<br>";
			
			
		}
	</script>
	
	<hr>
	
	<h3>Date 객체</h3>
	<p>날짜를 관리하는 객체</p>
	<button onclick="test7();">실행확인</button>
	<div id="area8" class="area"></div>
	
	<script type="text/javascript">
		function test7(){
			var area8 = document.getElementById("area8");
			
			//GMT 시간, 런던 기준의 그리니치 시간
			var date1 = new Date();
			var date2 = new Date('November 14');
			var date3 = new Date('November 14, 2018');
			var date4 = new Date('November 14, 2018, 14:41:30');
			
			area8.innerHTML += "date1 : " + date1 + "<br>";
			area8.innerHTML += "date2 : " + date2 + "<br>";
			area8.innerHTML += "date3 : " + date3 + "<br>";
			area8.innerHTML += "date4 : " + date4 + "<br>";
			
			//UTC 시간
			var date5 = new Date(2018, 10, 14);
			var date6 = new Date(2018, 10, 14, 14, 46, 45);
			var date7 = new Date(2018, 10, 14, 14, 46, 45, 1);
			
			area8.innerHTML += "date5 : " + date5 + "<br>";
			area8.innerHTML += "date6 : " + date6 + "<br>";
			area8.innerHTML += "date7 : " + date7 + "<br>";
		}
	</script>
	
	<hr>
	
	<h3>Date 객체의 메소드</h3>
	<button onclick="test8();">실행확인</button>
	<div id="area9" class="area-big"></div>
	
	<script type="text/javascript">
		function test8() {
			var area9 = document.getElementById("area9");
			
			var date = new Date();
			
			area9.innerHTML += "getFullYear() : " + date.getFullYear() + "<br>";
			area9.innerHTML += "getMonth() : " + (date.getMonth() + 1) + "<br>";
			area9.innerHTML += "getDate() : " + date.getDate() + "<br>";
			area9.innerHTML += "getDay() : " + date.getDay() + "<br>";
			area9.innerHTML += "getHours() : " + date.getHours() + "<br>";
			area9.innerHTML += "getMinutes() : " + date.getMinutes() + "<br>";
			area9.innerHTML += "getSeconds() : " + date.getSeconds() + "<br>";
			area9.innerHTML += "getMilliseconds() : " + date.getMilliseconds() + "<br>";
			area9.innerHTML += "getTimezoneOffset() : " + date.getTimezoneOffset() + "<br>";
			
			// 1970년 1월 1일 0시 0분 00초 기준으로 지난 밀리세컨 단위의 시간을 리턴한다.
			area9.innerHTML += "getTime() : " + date.getTime() + "<br>";
			
			var date2 = new Date(new Date(2018, 10, 14, 15, 10, 00, 99).getTime());
			
			console.log(date2);
			
			// 날짜 사이의 간격 구하기
			var now = new Date();
			var start = new Date('August 13, 2018');
			
			var interval = now.getTime() - start.getTime();
			
			interval = Math.floor(interval / (1000 * 60 * 60 * 24));
			
			alert("간격은 " + interval + "일!");
			
			// 2019년 3월 14일 까지 남은 날짜는?
			now = new Date('March 14, 2019');
			start = new Date();
			
			interval = now.getTime() - start.getTime();
			
			interval = Math.floor(interval / (1000 * 60 * 60 * 24));
			
			alert("간격은 " + interval + "일!");
		}
		
		
	</script>
</body>
</html>



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area {
		background:lightgray;
		border:1px solid black;
		width:300px;
		height:100px;
		font-size:40px;
		color:red;
	}
	.area-big {
		background:lightgray;
		border:1px solid black;
		height:300px;
	}
</style>
</head>
<body>
	<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>
	
	<h3>window 객체</h3>
	<p>브라우저 창에 대한 설정을 하는 객체<br>
	window 키워드는 전에 말했듯이 생략이 가능하다.</p>
	<button onclick="test1();">네이버</button>
	<button onclick="test2();">다음</button>
	
	<script type="text/javascript">
		function test1() {
			// window.open(); 새 탭 띄어주기
			
			// window.open('팝업 주소', '팝업 이름', '팝업 설정');
			
			window.open("http://www.naver.com", "네이버", "location=0, resizeable=no, menubar=no, status=no, toolbar=no");
			// 크롬 브라우져에선 대부분 지원하지 않음, 열기 기능만 됨, ie는 거의 지원
			// w3schools 에서 확인해볼것
		}
		function test2() {
			window.open("http://www.daum.net", "", "width=500, height=300");
		}
	</script>
	
	<br>
	
	<h3>window객체의 timer 메소드</h3>
	
	<h4>setTimeout()</h4>
	<button onclick="test3();">실행확인</button>
	
	<script type="text/javascript">
		function test3() {
			var myWindow = window.open();
			
			myWindow.alert("3초 뒤에 이 페이지는 종료됩니다.");
			
			window.setTimeout(function() {
				myWindow.close();
			}, 3000);
			
			// 3000 밀리 초 후에 지정한 함수가 작동함
		}
	</script>
	
	<br>
	
	<h4>setInterval() : 지정한 시간마다 반복될 함수, ex) 시계</h4>
	
	<button onclick="test4();">실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function test4() {
			var area1 = document.getElementById("area1");
			window.setInterval(function() {
				var date = new Date();
				
				area1.innerHTML = date.getHours() + " : " + date.getMinutes() + " : " + date.getSeconds();
			}, 1000);
		}
	</script>
	
	<br>
	<h4>clearInterval() : setInterval()을 종료함</h4>
	<button onclick="test5();">실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function test5() {
			var area2 = document.getElementById("area2");
			
			var count = 10;
			
			var intervalId = window.setInterval(function() {
				area2.innerHTML = "countDown : " + count--;
				
				setTimeout(function() {
					clearInterval(intervalId);
					area2.innerHTML = "종료!";
				}, 10000);
			}, 1000);
			
		}
	</script>
	
	<hr>
	
	<h3>screen 객체</h3>
	<p>웹 브라우저 화면이 아닌 운영체제 화면의 속성을 가지는 객체이다.</p>
	<button onclick="test6();">실행확인</button>
	
	<script type="text/javascript">
		function test6() {
			var width = screen.width;
			var height = screen.height;
			
			child = window.open("", "", "width=800, height=500");
			
			// 윈도우 절대 크기 조절
			child.resizeTo(width, height);
			
			setInterval(function() {
				// 윈도우 상대 크기 조절
				child.resizeBy(-20, -20);
				// 윈도우 상대 위치 조절
				child.moveBy(10, 10);
			}, 10);
			
			console.log("화면 너비 : " + width);
			console.log("화면 높이 : " + height);
			console.log("실제 화면에서 사용 가능한 너비 : " + screen.availWidth);
			console.log("실제 화면에서 사용 가능한 높이 : " + screen.availHeight);
			console.log("사용 가능한 색상 수 : " + screen.colorDepth);
			console.log("한 픽셀당 비트 수 : " + screen.pixelDepth);
		}
	</script>
	
	<hr>
	
	<h3>location 객체</h3>
	<p>브라우저 주소 표시줄과 관련된 객체이다.<br>
	현재 창의 주소같은 여러가지 정보를 담고 있으며 속성을 변경하면<br>
	어떤 링크를 눌렀을 때 새로운 창으로 여는것이<br>
	아닌 현재 창에서 여는것이 가능하다</p>
	<button onclick="test7();">실행확인</button>
	<div id="area3" class="area-big"></div>
	
	<script type="text/javascript">
		function test7() {
			var area3 = document.getElementById("area3");
			
			for (var key in location) {
				area3.innerHTML += key + " : " + location[key] + "<br>";
			}
		}
	</script>
	
	<button onclick="location.href='http://www.naver.com'">네이버로 이동</button>
	<button onclick="location='http://www.naver.com'">네이버로 이동</button>
	<!-- href는 정말 많이 쓰는 기능으로 생략을 허용한다. -->
	
	<br><br>
	<!-- 자기 자신을 붙이면 새로고침이 된다, 완전 새로 로드하기 때문에 기존의 스크롤 위치나 정보는 날아간다. -->
	<button onclick="location.href=location.href">새로고침</button>
	<button onclick="location=location">새로고침</button>
	
	<!-- reload는 스크롤 위치를 그대로 유지하고 새로고침이 된다. -->
	<button onclick="location.reload()">새로고침</button>
	
	<br><br>
	
	<button onclick="location.assign('http://google.com')">구글로 이동</button>
	
	<!-- replace는 뒤로가기를 할 수 없다. -->
	<button onclick="location.replace('http://google.com')">구글로 이동</button>
	
	<!-- 자주 쓰이므로 중요한 기능들이다. -->
	
	<hr>
	
	<h3>navigator 객체</h3>
	<p>웹 페이지를 실행하고 있는 브라우저에 대한 정보를 가진 객체</p>
	<button onclick="test8();">실행확인</button>
	<div id="area8" class="area-big"></div>
	
	<script type="text/javascript">
		function test8() {
			var str = "";
			
			for (var key in navigator) {
				str += key + " : " + navigator[key] + "\n";
			}
			
			alert(str);
			
			var area8 = document.getElementById("area8");
			
			area8.innerHTML += "브라우저의 코드명 : " + navigator.appCodeName + "<br>";
			area8.innerHTML += "브라우저의 이름 : " + navigator.appName + "<br>";
			area8.innerHTML += "브라우저 전체 정보 : " + navigator.userAgent + "<br>";
			area8.innerHTML += "브라우저 언어 : " + navigator.language + "<br>";
			area8.innerHTML += "사용중인 운영체제 : " + navigator.platform + "<br>";
		}
	</script>
	
	
</body>
</html>


이벤트란 어떤 행동을 했을 때 벌어지는 일이라고 이해하면 되는데


여태껏 사용했던 기능으로 Button 태그에 기능을 부여하는, 클릭(행동)했을 때 작동할 함수를 정해주는 일을 이벤트라고 한다.


다음과 같은 종류가 있다.




고전 이벤트 모델 : 과거에는 button 속성에 onclick="함수명"과 같이 안쓰고 스크립트에서 


태그ID.onclick = function(){}과 같이 사용했던 방법을 말한다.


옛날에 사용했던 방법이라고 지금 안 쓰는 것은 아니고 자주 쓰이는 편이다.





이벤트 발생 객체 : 발생한 이벤트에 대한 정보를 담고 있는 객체이다.


예를들어 클릭했을 경우 클릭의 위치는 어디인가? 언제 눌렀나와 같은 잡다할 수 도 있고 유용할 수 있는 정보들이다.





인라인 이벤트 모델 : 여태껏 사용했던 이벤트 선언 방법으로 보통 이 방법을 사용함


태그 속성에 해당하는 이벤트 모델을 선언하고 함수를 부여한다.


그리고 script에 함수에 대한 정보를 입력한다.





표준 이벤트 모델 : 스크립트에서 태그 변수를 불러와 이벤트를 직접 지정하는 방법이다.


보통 태그변수.addEvent*****('이벤트 명', function() {})와 같이 사용한다.






이벤트 중지 : 이벤트는 기본적으로 return 값이 따로 있다. true & false를 리턴하며 true는 정상적으로 끝냈음을


의미하고 false는 실패를 의미.


다음 예에서 쓰이는 방법은 form 태그로 둘러서 submit 버튼을 누르면 이벤트가 끝날 시 정보들을 서버에 전달하는데


return에 false를 주면 전달을 막을 수 있다.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		background: lightgray;
		border: 1px solid black;
		height: 100px;
	}
</style>
</head>
<body>
	<h1>이벤트</h1>
	
	<h3>고전 이벤트 모델</h3>
	<button id="test1">test1() 실행확인</button>
	<button id="test2">test2() 실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		var test1 = document.getElementById("test1");
		var test2 = document.getElementById("test2");
		
		test1.onclick = function() {
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "test1()이 실행되었습니다.<br>";
		}
		test2.onclick = function() {
			var area1 = document.getElementById("area1");
			
			area1.innerHTML = "test2()가 실행되면서 test1() 이벤트 제거<br>";
			test1.onclick = null;
		}
	</script>
	
	<hr>
	
	<h3>이벤트 발생 객체</h3>
	<button id="test3">test3() 실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		var test3 = document.getElementById("test3");
		
		test3.onclick = function(e) {
			// 매개변수를 위와같이 아무거나 입력하면 이벤트 발생 정보가 인자로 들어옴
			
			// this는 이벤트가 발생한 노드를 말함
			this.style.color = "white";
			this.style.background = "red";
			
			// 넘어오는 값이 있으면 앞의 값, e가 대입
			// 없으면 window.event 값을 대입한다.
			// IE에서는 e 값이 안넘어온다.
			var event = e || window.event;
			
			var area2 = document.getElementById("area2");
			
			for ( var key in event) {
				area2.innerHTML += key + " : " + event[key] + "<br>";
			}
			// 이벤트 요소는 출력과 같이 많이 나오지만 왠만한건 클릭으로 끝나서 쓸 일이 없다.
		}
	</script>
	
	<hr>
	
	<h3>인라인 이벤트 모델</h3>
	<button onclick="test4();">실행확인</button>
	<div id="area3" class="area"></div>
	<script type="text/javascript">
		function test4() {
			alert("test4() 실행확인!");
		}
	</script>
	
	<!-- 아예 바로 button에 js를 선언하는 방법도 있다. 이것을 인라인 이벤트라고 함 -->
	<!-- '' "" 쓰임에 주의 -->
	<button onclick="var test='안녕하세요'; alert(test);">실행확인</button>
	
	<hr>
	
	<h3>표준 이벤트 모델</h3>
	<p>한 번에 여러가지 이벤트 핸들러를 추가할 수 있다.<br>
	익스플로러 9버전부터 지원한다.</p>
	<button id="btn">실행확인</button>
	<script type="text/javascript">
		window.onload = function() {
			var btn = document.getElementById("btn");
			
			btn.addEventListener('click', function() {
				alert("표준 이벤트")
				
			});
			
			btn.addEventListener('mouseenter', function() {
			btn.style.background = 'red';
				
			})
		}
	</script>
	
	<hr>
	
	<h3>기본 이벤트의 제거</h3>
	<p>a태그 클릭하면 다른페이지로 이동한다<br>
	submit버튼이나 form안에 일반 버튼을 누르면 자동으로 입력 양식을 제출하고 새로고침한다.</p>
	<form>
		<label>이름 : </label>
		<input type="text" name="name" id="name">
		<br>
		<label>아이디 : </label>
		<input type="text" name="userId" id="userId">
		<br>
		<label>비밀번호 : </label>
		<input type="password" name="password" id="password">
		<br>
		<label>비밀번호 확인 : </label>
		<input type="password" name="password2" id="password2">
		<br>
		<input type="submit" value="제출" onclick="return test5();">
	</form>
	<script>
		function test5(){
			var name = document.getElementById("name").value;
			var userId = document.getElementById("userId").value;
			var password = document.getElementById("password").value;
			var password2 = document.getElementById("password2").value;
			
			console.log("name : " + name);
			console.log("userId : " + userId);
			console.log("password : " + password);
			console.log("password : " + password2);
			
			//비밀번호가 같은지 확인
			if(password == password2){
				alert("비밀번호가 일치합니다");
			}else{
				alert("비밀번호가 틀립니다");
				// 해당 노드에 포커싱을 주는 select
				document.getElementById("password2").select();

				// 리턴값을 false라고 주면 서버에 폼 데이터를 전송하지 않음
				return false;
			}
			
			return true;
		}
	</script>
	
</body>
</html>


부모 자식 노드 관계에서 만약 이름이 같은 이벤트가 각각 있다면 ( 아래와 같이 )



<div onclick="test1('1번 div')" class="div-test div1">

<div onclick="test1('2번 div')" class="div-test div2">

<div onclick="test1('3번 div')" class="div-test div3">

<div onclick="test1('4번 div')" class="div-test div4">

</div>

</div>

</div>

</div>


이와 같이 되어있다면 제일 바깥의 div를 클릭하면 이벤트가 한번 일어나지만


제일 안쪽의 div를 누르면 4번 3번 2번 1번 순으로 전부 실행되어 버린다


이와 같은 현상을 버블링이라고 하고


이를 방지하는 방법을 알아보자.


stopPropagation, cancelBubble 키워드를 사용하고 상위 이벤트 작동을 차단한다.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style>
	.div-test {
		border:1px solid black;
		padding:20px;
	}
	.div1 {background:red;}
	.div2 {background:orange;}
	.div3 {background:yellow;}
	.div4 {background:green;}
</style>
</head>
<body>
	<h1>이벤트 전달</h1>
	<h3>이벤트 버블링</h3>
	<p>자식 노드에서 부모 노드로 이벤트가 전달된다.</p>
	<div onclick="test1('1번 div')" class="div-test div1">
		<div onclick="test1('2번 div')" class="div-test div2">
			<div onclick="test1('3번 div')" class="div-test div3">
				<div onclick="test1('4번 div')" class="div-test div4">
				</div>
			</div>
		</div>
	</div>
	
	<script type="text/javascript">
		function test1(msg) {
			alert(msg);
		}
		// 자식의 노드를 클릭하면 부모 노드의 이벤트도 전부 실행된다.
	</script>
	
	<hr>
	
	<h3>이벤트 버블링 막기</h3>
	
	<div onclick="test2('1번 div')" class="div-test div1">
		<div onclick="test2('2번 div')" class="div-test div2">
			<div onclick="test2('3번 div')" class="div-test div3">
				<div onclick="test2('4번 div')" class="div-test div4">
				</div>
			</div>
		</div>
	</div>
	<script type="text/javascript">
		function test2(msg, e) {
			var event = e || window.event;
			
			alert(msg);
			
			// IE 제외
			if(event.stopPropagation()){
				event.stopPropagation();
			}
			
			// IE 전용
			event.cancelBubble = true;
		}
	</script>
	
</body>
</html>


먼저 이 HTML 문서에서 노드란 Body 부분의 각각의 요소들을 의미한다.


다른 이름으로는 태그, 요소 등등...


그리고    <h1>

<h2>

</h2>

</h1>


이와 같이 h1 아래에 h2가 위치하는 순차적으로 내려가는 구조로 짜여지는데


이와 같은 관계를 부모 자식관계 - 부모 노드, 자식 노드라고 한다.


그리고 javaScript에서 노드에 관련된 기능을 DOM, Document Object Model 라고 한다.


여태껏 태그들의 id나 클래스 등을 불러올 때 document.getElementBy**** 을 썻는데


이 키워드도 DOM에 포함된다.


다음으로는 자주 쓰이는 키워드들 몇가지를 소개한다.


getElement(s)ById(TagName, 등등) : 태그의 지정 속성을 기준으로 해당 태그를 불러온다.


createElement : 노드를 만들어 담아 놓을 때 사용


createTextNode : 노드 내부의 HTML문을 만들어 담아 놓을 때 사용, 노드 또한 가능


appendChild : 자식관계로 노드를 추가


속성 지정 및 추가 : getElement나 createElement로 노드 변수를 만들어 변수.******을 통해 속성 변경이나 기능을 활용


querySelector : <h1 id="id"> 와 같이 있을 때 h2를 불러오고 싶다면 '#id > h2'와 같이 입력하면 h2가 불러와진다.

<h2>

</h2>

   </h1>




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		background: lightgray;
		border: 1px solid black;
		height: 100px;
	}
</style>
</head>
<body>
	<h1>DOM(Document Object Model)</h1>
	<!-- 태그를 노드, 요소(엘리먼트)라고 표현 하기도 한다, 자식노드 부모노드 -->
	<!-- h1은 body의 자식 노드이다. -->
	<h3>텍스트 노드가 있는 노드 생성</h3>
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function test1() {
			// Element(노드) 생성
			var title = document.createElement("h3");
			
			// textnode 생성(내부 HTML 문)
			var textNode = document.createTextNode("안녕? 난 텍스트노드야!");
			
			// elemenet의 node 연결
			title.appendChild(textNode);
			
			// appendChild - 자식노드로 추가하는 메소드
			document.getElementById("area1").appendChild(title);
		}
	</script>
	
	<hr>
	
	<h3>텍스트노드가 없는 노드 생성</h3>
	<button onclick="test2();">실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function test2() {
			// img 태그 생성
			var imgTest = document.createElement("img");
			
			// 속성 지정(이미지 링크, 가로 세로 등등)
			imgTest.src = "https://www.fmkorea.com/files/attach/new/20171106/486616/416138940/828275155/4564da7307fbec289d6029377e4eb4bc.jpg";
			
			imgTest.width = "150";
			imgTest.height = "100";
			
			// 없는 속성 추가
			imgTest.myProperty = "123";
			// 없는 속성을 추가하기 위해서는 setAttribute() 사용해야 함
			imgTest.setAttribute("myProperty", "123");
			document.getElementById("area2").appendChild(imgTest);
		}
	</script>
	
	<hr>
	
	<h3>innerHTML</h3>
	<button onclick="test3()">실행확인</button>
	<div id="area3" class="area">
		<table id="board">
			<tr>
				<th>글번호</th>
				<th>글제목</th>
				<th>작성자</th>
				<th>조회수</th>
				<th>작성일자</th>
			</tr>
		</table>
	</div>
	
	<script>
		function test3(){
			// var board = document.getElementById("board");
			// alert(board.innerHTML);
			
			// css선택자를 자식 노드 선택하는 방법(board의 자식인 tbody를 지목)
			var board = document.querySelector('#board > tbody');
			
			
			var num = 1;
			var title = "제목입니다";
			var user = "user01";
			var count = 1;
			var date = new Date();
			
			board.innerHTML += "<tr><td>" + num
			+ "</td><td>" + title
			+ "</td><td>" + user
			+ "</td><td>" + count
			+ "</td><td>" + date.getFullYear()
			+ "-"
			+ (date.getMonth() + 1)
			+ "-"
			+ date.getDate()
			+ "</td></tr>";
		}
	</script>
		
	<hr>
	
	<h3>스타일 지정</h3>
	<button onclick="test4();">실행확인</button>
	<div id="area4" class="area"></div>
	
	<script>
		function test4(){
			var area4 = document.getElementById("area4");
			
			area4.style.backgroundColor = "orangered";
			area4.style.borderRadius = "50px";
			area4.style.transition = "all 2s";
			
			// transition은 자연스럽게 스타일이 바뀌게 하는 키워드, 위의 예는 2초동안 바뀜
		}
	</script>
	
	<h3>노드 삭제</h3>
	
	<button onclick="test5();">실행확인</button>
	<div id="area5" class="area"></div>
	<script type="text/javascript">
		function test5() {
			var area5 = document.getElementById("area5");
			
			area5.remove();
		}
	</script>
	
</body>
</html>


지오 로케이션은 페이지에서 현재 디바이스(pc나 스마트폰 등)의 위치를 알아내는 방법이다.


값은 위도와 경도 값으로 반환된다.



navigator.geolocation.getCurrentPosition(function(position) {

사용할 위치 관련 내용

});


예를 통해 position키워드를 어떻게 쓰는지 알아보자



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h1>지오 로케이션</h1>
	<h5>현재 위치 가져오기</h5>
	<p>getCurrentPosition()을 호출하여 사용자의 현재 위치를 가져온다.<br>
	응답은 빠르지만 정확도는 낮다.</p>
	
	<button onclick="test1();">실행확인</button>
	<script type="text/javascript">
		function test1() {
			navigator.geolocation.getCurrentPosition(function(position) {
				alert("위도 : " + position.coords.latitude + "\n" + "경도 : " + position.coords.longitude);
				
				var lat = position.coords.latitude;
				var lon = position.coords.longitude;
				
				// 다음 지도와 연결되고 위치정보를 전달하여 현재 위치를 지도에 띄운다.
				// 정확도가 떨어진다.
				location.href="http://map.daum.net/link/map/나의위치," + lat + "," + lon;
			});
			
		}
	</script>
</body>
</html>


캡슐화는 객체의 요소들을 숨기는 기능으로


getter와 setter로 값을 불러온다.


또한 js에서 상속하는 방법은


this.base 참조를 통해서 본인에게 다른 클래스를 상속하는 방법을


다음 예제로 확인해보자


<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		height: 150px;
		background: lightgray;
		border: 1px solid black;
	}
</style>
</head>
<body>
	<h1>캡슐화와 상속</h1>
	<h3>캡슐화</h3>
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function GirlGroup(gn, mc, m) {
			// 속성 초기화
			var groupName = gn;
			var memberCount = mc;
			var members = m;
			
			// setter getter
			this.getGroupName = function() {
				return groupName;
			}
			this.getMemberCount = function() {
				return memberCount;
			}
			this.getMembers = function() {
				return members;
			}
			
			this.setGroupName = function(gn) {
				this.groupName = gn;
			}
			this.setMemberCount = function(mc) {
				if(members.length != mc){
					throw "멤버 수가 틀립니다. 다시 확인하세요!";
				}else {
					memberCount = mc;
				}
			}
			this.setMembers = function(m) {
				this.members = m;
			}
			
		}
		
		function test1() {
			var gn = "소녀시대";
			var mc = 9;
			var m = ["윤아", "써니", "태연", "서현", "티파니", "효연", "유리", "제시카", "수영"];
			
			var girlsGeneration = new GirlGroup(gn, mc, m);
			
			console.log(girlsGeneration);
			
			console.log(girlsGeneration.groupName);
			
			girlsGeneration.groupName = "방탄소년단";
			
			console.log(girlsGeneration.groupName);
			
			console.log(girlsGeneration.getGroupName());
			
			//girlsGeneration.setMemberCount(8);
			
			var area1 = document.getElementById("area1");
			
			with(girlsGeneration){
				area1.innerHTML += "그룹 : " + getGroupName() + "<br>";
				area1.innerHTML += "멤버수 : " + getMemberCount() + "<br>";
				area1.innerHTML += "멤버 : " + getMembers() + "<br>";
			}
		}
	</script>
	
	<hr>
	
	<h3>상속</h3>
	<button onclick="test2();">실행확인</button>
	<script type="text/javascript">
		function Book(t, p, dr) {
			var title = t;
			var price = p;
			var discountRate = dr;
			
			this.getTitle = function() {
				return title;
			}
			this.getPrice = function() {
				return price;
			}
			this.getDiscountRate = function() {
				return discountRate;
			}
			
			this.setTitle = function(t) {
				title = t;
			}
			this.setPrice = function(p) {
				if (p < 0) {
					throw "가격이 어떻게 마이너스냐? 사면 돈주냐?";
				}else {
					price = p;
				}
			}
			this.setDiscountRate = function(dr) {
				if (t < 0) {
					throw "할인율이 마이너스면 말이 되냐?";
				} else {
					discountRate = dr;
				}
			}
		}
		
		// 객체들이 공유하는 prototype에 판매 가격을 구하는 메소드 추가
		Book.prototype.getSellPrice = function() {
			return this.getPrice() - (this.getPrice() * this.getDiscountRate());
		}
		
		function test2() {
			var book1 = new Book('자바의 정석', 35000, 0.15);
			
			alert("title : " + book1.getTitle() + "\n"
					+ "sellPrice : " + book1.getSellPrice())
		}
	</script>
	
	<br>
	
	<button onclick="test3();">상속 확인</button>
	<div id="area2" class="area"></div>
	<script type="text/javascript">
		function Novel(t, p, dr, tp) {
			this.base = Book;
			this.base(t, p, dr);
			// Book을 상속, 생성자 전달
			var type = tp;
			
			this.getType = function() {
				return type;
			}
			this.setType = function(tp) {
				type = tp;
			}
		}
		
		Novel.prototype = Book.prototype;
		
		function test3() {
			var novel = new Novel("나무", 30000, 0.2, '소설');
			
			alert("title : " + novel.getTitle() + "\n"
					+ "sellPrice : " + novel.getSellPrice());
			
			var area2 = document.getElementById("area2");
			
			area2.innerHTML += "novel instanceof Novel : " + (novel instanceof Novel) + "<br>";
			area2.innerHTML += "novel instanceof Book : " + (novel instanceof Book) + "<br>";
			
			console.log(novel);
		}
	</script>
	
	
</body>
</html>


instanceof는 과거 java에서 다형성에서 객체의 관계를 구분할 때 사용 했는데


JS역시 같은 방식으로 사용한다.


그리고 new를 통해서 객체를 생성했을 때와 { }괄호를 사용 했을 때는 차이가 있는데


new를 사용하면 클래스를 지역변수로 생성하고


{ }괄호를 사용하면 window에 전역변수로 생성된다.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		height: 100px;
		background: lightgray;
		border: 1px solid black;
	}
</style>
</head>
<body>
	<h1>객체 관련 키워드</h1>
	<h3>instanceof 키워드</h3>
	<p>해당 객체가 어떠한 생성자 함수를 통해 생성되었는지 확인할 때 쓴다.</p>
	<button onclick="test1();">실행 확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function Dog(name) {
			this.name = name;
		}
		function test1() {
			var myDog = new Dog('까미');
			
			var yourDog = {name:'까미'};
			
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "myDog instanceof Dog : " + (myDog instanceof Dog) + "<br>";
			area1.innerHTML += "yourDog instanceof Dog : " + (yourDog instanceof Dog) + "<br>";
		}
	</script>
	
	<hr>
	
	<h3>new 키워드</h3>
	
	<button onclick="test2();">new 확인하기</button>
	<div id="area2" class="area"></div>
	<script type="text/javascript">
		function Duck(firstName, lastName) {
			this.firstName = firstName;
			this.lastName = lastName;
		}
		function test2() {
			var duck1 = new Duck("Mc", "Donald");
			console.log(duck1);
			
			var area2 = document.getElementById("area2");
			
			area2.innerHTML += "첫 번째 오리의 full Name은 " + duck1.firstName + duck1.lastName + "입니다. 꽥꽥! <br>";
			
			var duck2 = Duck("Donald", "Dorump");
			
			
			
			//area2.innerHTML += "두 번째 오리의 full Name은 " + duck2.firstName + duck2.lastName + "입니다. 꽥꽥! <br>"; 
		
			console.log(duck2);
			
			area2.innerHTML += "두 번째 오리의 full Name은 " + window.firstName + this.lastName + "입니다. 꽥꽥! <br>"; 
			
			// 두번째 오리의 주석처리된 출력문을 왜 못찾냐 하면
			// new를 붙여 생성하지 않고 생성자를 통해 생성하면 전역변수로 생성된다.
			// new로 호출하면 Duck의 this는 클래스 내부를 의미하고
			// 호출하지 않으면 window를 가리키는 this가 된다.
		}
	</script>
</body>
</html>


JS에선 객체 또한 하나의 변수처럼 취급할 수 있다고 이해했다.


그런 이유로 배열을 생성하고 값을 집어넣을 때


객체를 넣을 수 있다는 말이다.


그리고 여지껏 값을 직접 입력했는데 생성자를 통해서 값을 설정 할 수 있다.


new 키워드를 사용한다.


예제를 통해 배열에 어떻게 집어넣는지 생성자를 어떻게 쓰는지 확인해보자


<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		height: 250px; 
		border: 1px solid black;
		background: lightgray;
	}
</style>
</head>
<body>
	<h1>객체 배열</h1>
	<h3>객체와 배열을 사용한 데이터 관리</h3>
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function test1() {
			var student0 = {
					name:'이르음',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student1 = {
					name:'이르음1',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student2 = {
					name:'이르음2',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student3 = {
					name:'이르음3',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student4 = {
					name:'이르음4',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student5 = {
					name:'이르음5',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student6 = {
					name:'이르음6',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student7 = {
					name:'이르음7',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student8 = {
					name:'이르음8',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			var student9 = {
					name:'이르음9',
					java:Math.floor(Math.random() * 100) + 1,
					oracle:Math.floor(Math.random() * 100) + 1,
					HTML5:Math.floor(Math.random() * 100) + 1,
					CSS3:Math.floor(Math.random() * 100) + 1,
					javaScript:Math.floor(Math.random() * 100) + 1
			}
			
			
			// 배열 선언
			var students = [];

			students.push(student0);
			students.push(student1);
			students.push(student2);
			students.push(student3);
			students.push(student4);
			students.push(student5);
			students.push(student6);
			students.push(student7);
			students.push(student8);
			students.push(student9);
			
			console.log(students);
			
			// 각 객체별 메소드 추가
			for(var i = 0; i < students.length; i++){
				students[i].getSum = function() {
					return this.java + this.oracle + this.HTML5 + this.CSS3 + this.javaScript;
				}
				
				students[i].getAvg = function() {
					return students[i].getSum() / 5;
				}
			}
			
			// 모든 학생의 정보가 담긴 배열의 메소드를 통해 총점과 평균 출력
			for(var i in students){
				with(students[i]){
					document.getElementById("area1").innerHTML += "이름 : " + name + ", 총점 : " + getSum() + ", 평균 : " + getAvg() + "<br>";
				}
			}
		}
	</script>
	
	<hr>
	
	<h3>생성자 함수</h3>
	<p>new 키워드를 사용해서 객체를 생성할 수 있는 함수를 의미한다.</p>
	<button onclick="test2();">실행 확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function Student(name, java, oracle, html5, css3, javascript) {
			// 속성 정의
			this.name = name;
			this.java = java;
			this.oracle = oracle;
			this.html5 = html5;
			this.css3 = css3;
			this.javascript = javascript;
			
			// 메소드 정의
			this.getSum = function(){
				return this.java + this.oracle + this.html5 + this.css3 + this.javascript;
			}
			this.getAvg = function(){
				return this.getSum() / 5;
			}
			this.toString = function() {
				return "이름 : " + this.name + ", 총점 : " + this.getSum() + ", 평균 : " + this.getAvg() + "<br>";
			}
			
		}
	
		function test2(){
			var student = new Student(prompt('이름을 입력하세요.'),
					parseInt(prompt('자바 점수를 입력하세요.')),
					parseInt(prompt('오라클 점수를 입력하세요.')),
					parseInt(prompt('html5 점수를 입력하세요.')),
					parseInt(prompt('css3 점수를 입력하세요.')),
					parseInt(prompt('javascript 점수를 입력하세요.')))
			var area2 = document.getElementById("area2")
			
			area2.innerHTML += student;
			
		}
	</script>

	
</body>
</html>


+ Recent posts