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


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>


JS도 역시 객체지향 언어이기 때문에 객체 기능을 지원한다.


선언 방법에는 다양한 방법이 존재하므로 예를 통해서 확인해보자.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area-big{
		height: 400px;
		background: lightgray;
		border: 1px solid black;
	}
	.area{
		background: lightgray;
		height: 200px;
		border:1px solid black;
	}
</style>
</head>
<body>
	<h1>객체</h1>
	<h3>객체의 선언 및 호출</h3>
	<p>객체는 키 값을 사용하여 속성을 식별한다.<br>
	중괄호{}를 사용해서 객체를 생성하고, 속성에는 모든 자료형이 올 수 있다.</p>
	
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area-big"></div>
	
	<script type="text/javascript">
		function test1() {
			var product = {
				pName: 'Dry Mango',
				type: 'Pickle',
				ingredient:['mango', 'sugar'],
				origin: 'Pilippines'
			};
			
			console.log(product);
			
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "product : " + product + "<br>";
			
			area1.innerHTML += "<b>객체명.속성명으로 접근하기</b><br>";
			area1.innerHTML += "product.pName : " + product.pName + "<br>";
			area1.innerHTML += "product.type : " + product.type + "<br>";
			area1.innerHTML += "product.ingredient : " + product.ingredient + "<br>";
			area1.innerHTML += "product.ingredient[0] : " + product.ingredient[0] + "<br>";
			area1.innerHTML += "product.ingredient[1] : " + product.ingredient[1] + "<br>";
			area1.innerHTML += "product.origin : " + product.origin + "<br>";
			
			
			area1.innerHTML += "<b>객체명['속성명']으로 접근하기</b><br>";
			area1.innerHTML += "product['pName'] : " + product['pName'] + "<br>";
			area1.innerHTML += "product['type'] : " + product['type'] + "<br>";
			area1.innerHTML += "product['ingredient'] : " + product['ingredient'] + "<br>";
			area1.innerHTML += "product['ingredient'][0] : " + product['ingredient'][0] + "<br>";
			area1.innerHTML += "product['ingredient'][1] : " + product['ingredient'][1] + "<br>";
			area1.innerHTML += "product['origin'] : " + product['origin'] + "<br>";
			
			
		}
	</script>
	
	<hr>
	
	<h3>객체의 키 식별자 테스트</h3>
	<button onclick="test2();">실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function test2() {
			var objTest = {
					'I love':'poo',
					'I hate !@#$%^%()':'asd'
			}
			
			var area2 = document.getElementById("area2");
			
			console.log(objTest);
			
			// 공백이나 특수문자가 key 값인 경우에는 이 방식으로 value를 가져올 수 없다.
/* 			area2.innerHTML += "I love : " + objTest.'I love' + "<br>";
			area2.innerHTML += "I hate !@#$%^%() : " + objTest.'I hate !@#$%^%()' + "<br>"; */
			
			area2.innerHTML += "I love : " + objTest['I love'] + "<br>";
			area2.innerHTML += "I hate !@#$%^%() : " + objTest['I hate !@#$%^%()'] + "<br>";
		}
	</script>
	
	<hr>
	
	<h3>객체의 메소드 속성</h3>
	<p>객체의 속성 중 함수 자료형인 속성을 메소드라고 부른다.</p>
	<button onclick="test3();">실행확인</button>
	<div id="area3" class="area"></div>
	
	<script type="text/javascript">
		function test3() {
			var area3 = document.getElementById("area3");
			
			var dog = {
					name: '까미',
					eat:function(food){
						// 객체 내에서 자신의 속성을 호출할 때는 반드시 this.을 사용해야 한다.
						area3.innerHTML += this.name + '가' + food + "을 먹고있네요~ 멍멍";
					}
			}
			
			dog.eat('밥');
		}
	</script>
	
	<hr>
	
	<h3>객체와 반복문</h3>
	<button onclick="test4();">실행확인</button>
	<p>객체의 속성을 살펴볼 때에는 단순 for문으로 사용이 불가능하고<br>
	for in 문을 사용해야 한다.</p>
	<div id="area4" class="area"></div>
	
	<script type="text/javascript">
		function test4() {
			var game = {
					title:'DIABLO 3',
					price:'35,000원',
					language:'한국어지원',
					supportOS:'window 32/64',
					service:true
			};
			
			var area4 = document.getElementById("area4");
			
			for(var key in game){
				area4.innerHTML += key + " : " + game[key] + "<br>";
			}
		}
	</script>
	
	<hr>
	
	<h3>in과 with 키워드</h3>
	<p>in : 객체 내부에 해당 속성이 있는지 확인하는 키워드<br>
	with : 코드를 줄여주는 키워드, 호출시 객체명 생략이 가능하다.</p>
	<label>이름 : </label>
	<input type="text" id="name"><br>
	<label>국어 : </label>
	<input type="text" id="kor"><br>
	<label>영어 : </label>
	<input type="text" id="eng"><br>
	<label>수학 : </label>
	<input type="text" id="math"><br>
	
	<button onclick="test5();">실행확인</button>
	<div id="area5" class="area-big"></div>
	<script type="text/javascript">
		function test5() {
			var name = document.getElementById("name").value;
			var kor = parseInt(document.getElementById("kor").value);
			var eng = parseInt(document.getElementById("eng").value);
			var math = parseInt(document.getElementById("math").value);
			
			var student = {
					name:name,
					kor:kor,
					eng:eng,
					math:math
			}
			
			var student2 = {
					name,
					kor,
					eng,
					math
					// 이와같이 key value 이름이 같으면 자동으로 넣어준다(최신버젼에서만 지원)
			}
			
			console.log(student);
			console.log(student2);
			
			var area5 = document.getElementById("area5");
			
			area5.innerHTML += "<b>in 키워드 테스트</b>";
			
			area5.innerHTML += "student 객체에 name이라는 속성이 있는지 확인 : " + ('name' in student) + "<br>";
			
			area5.innerHTML += "student 객체에 sum이라는 속성이 있는지 확인 : " + ('sum' in student) + "<br>";
			
			area5.innerHTML += "<b>그냥 출력</b><br>";
			
			area5.innerHTML += "학생이름 : " + student.name + "<br>";
			area5.innerHTML += "국어점수 : " + student.kor + "<br>";
			area5.innerHTML += "영어점수 : " + student.eng + "<br>";
			area5.innerHTML += "수학점수 : " + student.math + "<br>";
			area5.innerHTML += "총점 : " + (student.kor + student.eng + student.math) + "<br>";
			area5.innerHTML += "평균 : " + (student.kor + student.eng + student.math) / 3 + "<br>";
			
			area5.innerHTML += "<b>with 키워드 테스트</b><br>";
			
			with(student){
				area5.innerHTML += "학생이름 : " + name + "<br>";
				area5.innerHTML += "국어점수 : " + kor + "<br>";
				area5.innerHTML += "영어점수 : " + eng + "<br>";
				area5.innerHTML += "수학점수 : " + math + "<br>";
				area5.innerHTML += "총점 : " + (kor + eng + math) + "<br>";
				area5.innerHTML += "평균 : " + (kor + eng + math) / 3 + "<br>";
			}
			
		}
	</script>
	
	<hr>
	
	<h3>객체의 속성 추가와 제거</h3>
	<p>처음 객체 생성 이후 속성을 추가하거나 제거하는 것을 동적으로 속성을 추가한다 혹은
	제거한다라고 한다.</p>
	<button onclick="test6();">실행확인</button>
	<div id="area6" class="area"></div>
	<script type="text/javascript">
		function test6() {
			var student = {};
			
			// 객체에 속성을 추가
			student.name = "머키";
			student.hobby = "철거";
			student.strength = "아옳?";
			student.dream = "아옳옳!";
			
			console.log(student);
			
			student.toString = function() {
				var str = "";
				
				for(var key in this){
					if(key != 'toString'){
						str += key + " : " + this[key] + "<br>";
					}
				}
				return str;
			}
			
			var area6 = document.getElementById("area6");
			
			area6.innerHTML = student.toString();
			
			// 속성을 지울 때 delete
			delete(student.dream);
			
			area6.innerHTML = student;
		}
	</script>
	
	
</body>
</html>


아래의 함수는 인코딩과 디코딩에 관련된 함수이다.


가끔 인터넷 주소창을 복사하여 붙여넣기 했을 때 분명 한글로 된 문자가


%$4764$%&$% 와 같이 이상하게 표시되는 걸 본적이 있을 것이다.


이와 관련된 인코딩에 대해서 확인해보자



escape : 영문 알파벳, 숫자, 일부 특수문자(@, *, -, _, ., /)를 제외한 모든 문자를 인코딩한다.


encodeURI : escape에서 인터넷 주소에 사용되는 일부 특수문자 (:, ;, /, =, ?, &)는 변환하지 않는다.


encodeURIComponent : 알파벳과 숫자를 제외한 모든 문자를 인코딩한다.(UTF-8 방식)


unescape : escape()로 인코딩 된 문자를 디코딩한다.


decodeURI : encodeURI()로 인코딩된 문자를 디코딩한다.


decodeURIComponent : encodeURIComponent()로 인코딩된 문자를 디코딩한다.









eval은 입력받은 문자열을 스크립트 코드로 적용하는 것이다.


innerHTML의 스크립트 버젼이라고 이해하면 쉽다.


또한 계산 식 같은 경우도 쉽게 연산해주기 때문에


eval("(3 * 4) + 1 / 3 + 5"); 와 같이 사용하면 연산 값을 반환한다.








Infinity는 무한이란 의미로 숫자 값을 0으로 나누면 Infinity를 반환한다.


isFinite() 함수를 이용해서 유한한지 무한한지 알 수 있고 음의 무한과 양의 무한이 구분되어 있다.




NaN, Not a Number은 연산의 결과나 자바스크립트로 표현 할 수 없는 숫자일 때 표시되는 문구이다.








형변환


Number는 숫자형으로 형 변환하는 함수로 변환하지 못하면 NaN을 반환한다.


parse


parseInt는 정수형으로 변환하고


parseInt( 'XXX', XX)와 같이 인자를 두 개 넣어서 사용하면 16진수 10진수 8진수 2진수를 10진수로 변환이 가능하고


지정된 형식을 입력하면 자동으로 10진수로 변환해준다.


parseFloat는 java와 비슷한데 중간에 e라는 문자를 만나면 지수로 인식하여 연산 결과를 반환한다.







다음 예를 확인해보자



<!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: 150px;
	}
	.area-big{
		background: lightgray;
		border: 1px solid black;
		height: 350px;
	}
</style>
</head>
<body>
	<h1>JavaScript 내장함수</h1>
	<h3>인코딩과 디코딩에 관련된 내장함수</h3>
	
	<p>
	escape() : 영문 알파벳, 숫자, 일부 특수문자(@, *, -, _, ., /)를 제외한 모든 문자를 인코딩한다.<br>
	encodeURI() : escape에서 인터넷 주소에 사용되는 일부 특수문자
	(:, ;, /, =, ?, &)는 변환하지 않는다.<br>
	encodeURIComponent() : 알파벳과 숫자를 제외한 모든 문자를 인코딩한다.(UTF-8 방식)<br>
	<br>
	unescape() : escape()로 인코딩 된 문자를 디코딩한다.<br>
	decodeURI() : encodeURI()로 인코딩된 문자를 디코딩한다.<br>
	decodeURIComponent() : encodeURIComponent()로 인코딩된 문자를 디코딩한다.
	</p>
	
	<button onclick="test1();">실행확인</button>
	<div id="area1" class="area"></div>
	<script type="text/javascript">
		function test1() {
			var uri = "http://www.naver.com?test=한글입니다.";
			
			
			var esURI = escape(uri);
			var enURI = encodeURI(uri);
			var enURIC = encodeURIComponent(uri);
			
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "escape() : " + esURI + "<br>";
			area1.innerHTML += "encodeURI() : " + enURI + "<br>";
			area1.innerHTML += "encodeURIComponent() : " + enURIC + "<br>";
			
			area1.innerHTML += "unescape() : " + unescape(esURI) + "<br>";
			area1.innerHTML += "decodeURI() : " + decodeURI(enURI) + "<br>";
			area1.innerHTML += "decodeURIComponent() : " + decodeURIComponent(enURIC) + "<br>";
		}
		// ? test = 한글입니다. 라는 변수를 전달
	</script>
	
	<hr>
	
	<h3>eval() 함수</h3>
	<p>문자열을 자바스크립트 코드로 변환해 실행하는 함수이다.</p>
	<br>
	<label>숫자 1 입력</label>
	<input type="text" id="number1">
	<br>
	<label>숫자 2 입력</label>
	<input type="text" id="number2">
	<br>
	
	<button onclick="test2();">실행확인</button>
	<div id="area2" class="area"></div>
	
	<script type="text/javascript">
		function test2() {
			var testEval = "";
			testEval = "var number1 = parseInt(document.getElementById('number1').value);";
			testEval += "var number2 = parseInt(document.getElementById('number2').value);";
			testEval += "var sum = 0;";
			testEval += "sum = number1 + number2;";
			testEval += "document.getElementById('area2').innerHTML += number1 +'과 ' + number2 + '의 합은 ' + sum + '입니다.';";
			
			eval(testEval);
		}
	</script>
		
	<hr>
		
	<h3>infinity 와 NaN</h3>
	<p>대부분의 프로그래밍 언어는 0으로 숫자를 나누면 자동으로 오류가 발생하고
	프로그램이 종료된다<br>
	하지만 자바스크립트는 0으로 숫자를 나누면 infinity라는 값이 들어가게 되고<br>
	자바스크립트가 표현할 수 없는 숫자는 NaN(Not a Number)으로 표시된다.</p>
	<button onclick="test3();">실행확인</button>
	<div id="area3" class="area"></div>
	<script>
		function test3(){
			var num1 = 10 / 0;
			var num2 = 10 / 'a';
			
			var area3 = document.getElementById("area3");
			
			area3.innerHTML += "10 / 0 : " + num1 + "<br>";
			area3.innerHTML += "10 / 'a' : " + num2 + "<br>";
			area3.innerHTML += "isFinite() : " + isFinite(num1) + "<br>";
			area3.innerHTML += "num1 == Infinity : " + (num1 == Infinity) + "<br>";
			// Finite = 유한수
			
			var num3 = -10 / 0;
			
			area3.innerHTML += "num3 == -Infinity : " + (num3 == -Infinity) + "<br>";
			// 무한 대수는 양의 무한대수와 음의 무한대수가 있다.
			
			
			// NaN은 Infinity와 달리 비교연산자로 확인할 수 없다.
			if (num2 == NaN) {
				area3.innerHTML += "num2는 숫자가 아닙니다.<br>";
			}else {
				area3.innerHTML += "num2는 숫자입니다.<br>";
			}
			
			if (isNaN(num2)) {
				area3.innerHTML += "num2는 숫자가 아닙니다.<br>";
			}else {
				area3.innerHTML += "num2는 숫자입니다.<br>";
			}
			
			
		}
	</script>
	
	<hr>
	
	<h3>Number(), parse(), parseFloat()</h3>
	<p>Number() : 숫자로 바꿀 수 없으면 무조건 NaN을 리턴한다.<br>
	parseInt(), parseFloat() 숫자로 변환할 수 있는 부분까지는 모두 숫자로 변환한다.
	</p>
	
	<button onclick="test4();">실행확인</button>
	<div id="area4" class="area-big"></div>
	<script type="text/javascript">
		function test4() {
			var money = '1000원';
			var dollar = '1.5$';
			
			var area4 = document.getElementById("area4");
			
			area4.innerHTML += "Number(money) : " + Number(money) + "<br>";
			area4.innerHTML += "Number(dollar) : " + Number(dollar) + "<br>";
			
			// 앞에서부터 정수로 인식할 수 있는 부분까지 변환
			area4.innerHTML += "parseInt(money) : " + parseInt(money) + "<br>";
			area4.innerHTML += "parseInt(dollar) : " + parseInt(dollar) + "<br>";
			
			area4.innerHTML += "parseFloat(money) : " + parseFloat(money) + "<br>";
			area4.innerHTML += "parseFloat(dollar) : " + parseFloat(dollar) + "<br>";
			
			// 16진수도 10진수로 계산 가능
			area4.innerHTML += "parseInt(0X1234) : " + parseInt(0X1234) + "<br>";
			// 8진수(앞에 0이 붙음)도 10진수로 계산 가능
			// 그러므로 문자열로 입력받을 때 앞에 0을 입력하지 않게 주의
			area4.innerHTML += "parseInt(01234) : " + parseInt(01234) + "<br>";
			
			// 10진수 문자열을 10진수로 변환
			area4.innerHTML += "parseInt('1234') : " + parseInt('1234') + "<br>";
			
			// n진수 숫자를 10진수로 변환한다.
			area4.innerHTML += "parseInt('FF', 16) : " + parseInt('FF', 16) + "<br>";
			area4.innerHTML += "parseInt('52', 10) : " + parseInt('52', 10) + "<br>";
			area4.innerHTML += "parseInt('11', 8) : " + parseInt('11', 8) + "<br>";
			area4.innerHTML += "parseInt('10', 2) : " + parseInt('10', 2) + "<br>";
			
			// float에서 e는 지수로 인식
			// 중간데 e 전까지만 parsing 하는것이 아니고 제곱 처리를 한다.
			area4.innerHTML += "parseFloat('52.273e5') : " + parseFloat('52.273e5') + "<br>";
			
			
		}
	</script>
	
	
</body>
</html>


04-009 게시글에서 설명한 것 처럼 이번 내용은


함수가 변수처럼 선언하는 것이다. 하나의 자료형이다. 라는 내용이 기반이 된다.




인자에 함수 선언은 함수가 object 타입의 자료형으로


함수를 호출 할 때 인자 값으로 보낸다는 의미이다.


function 함수이름(var){

함수 내용

}


함수이름(function(){

전달할 함수 내용

});






함수를 매개변수로 전달은 위의 내용과 비슷한데


함수1(함수2)와 같이 이미 선언된 함수를 인자로 사용한다.


function 함수이름(var){


}


function 함수이름2(){


}


함수이름(함수이름2);


위와 같이 사용한다.







익명 함수를 리턴은 함수가 하나의 자료형이기 때문에 return 값에도 이용 할 수 있다.


단, 함수를 리턴 받았을 경우 리턴 받은 함수에는 (), 괄호가 안 붙어 있기 때문에 괄호를 한번 더 써 주어야 한다.


function 함수이름(){

var f = function(){


}

return f;

}


함수이름()();





다음의 예제로 확인해보자.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">

</style>
</head>
<body>
	<h1>함수2</h1>
	<h3>매개변수로 함수 전달</h3>
	<p>함수도 하나의 자료형이기 때문에 매개변수로도 전달 가능하다.</p>
	
	<h4>익명함수를 매개변수로 활용</h4>
	<div id="area1" class="area"></div>
	<script>
		function callFunctionTenTimes(otherFunction) {
			for(var i = 0; i < 10; i++){
				otherFunction(i);
			}
		}
		callFunctionTenTimes(function (i) {
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += (i + 1) + "번째 함수 호출<br>";
		})
	</script>
	
	<h4>선언적 함수를 매개변수로 전달</h4>
	<button onclick="callJustFunction(justFunction);">실행하기</button>
	<div id="area2" class="area"></div>
	<script type="text/javascript">
		function callJustFunction(otherFunction) {
			for(var i = 10; i > 0; i--){
				otherFunction(i);
			}
			alert("펑펑! 폭파되엇습니다!!")
		}
		function justFunction(i) {
			if(i > 5){
				alert(i + "번만 더 클릭하면 자동으로 폭발합니다.");
			}else if (i > 3) {
				alert("마지막 경고입니다! " + i + "번만 더 클릭하면 자동으로 폭발합니다.");
			}else if (i > 1) {
				alert("분명 경고했습니다! " + i + "번만 더 클릭하면 진짜 폭발합니다.");
			}else{
				alert("한번만 더 클릭하면 폭발합니다!!!!!!");
			}
		}
	</script>
	<!-- 함수를 하나의 자료형이라고 받아들여야 쉽게 이해할 수 있다. -->
	<h4>익명함수를 리턴하는 함수</h4>
	<input type="text" id="name">
	<button onclick="callFunction();">실행확인</button>
	<div id="area3" class="area"></div>
	<script type="text/javascript">
		function returnFunction() {
			var name = document.getElementById("name").value;
			
			var f = function() {
				alert(name + "님 환영합니다.");
			}
			
			return f;
		}
		function callFunction() {
			returnFunction()();
			// 괄호를 한번 더 해야한다. returnFunction() 자체가 함수 이름이라고 생각하면 된다.
		}
	</script>
</body>
</html>



JS에서의 함수의 쓰임에 대해 살펴보자



기본 선언은 여태까지 사용해왔던것 처럼


function 함수이름(매개변수){

실행 내용

}


위와 같은 기본 틀을 가진다.





익명 함수란 간단하게 함수를 변수처럼 선언하는 것을 말한다.


여기서 꼭 짚어두고 가야 할 부분은 js에서 함수는 하나의 변수라고 생각해야 한다.


변수처럼 사용한다. 라면 이해하기 어려울 수 있는데


java와 다르게 메소드를 선언한다. 가 아니고


변수를 하나 선언하여 그 방에 함수 내용을 적을 수 있다. 라고 이해하자.


변수명 = function(){

실행 내용

}


위와 같이 사용한다.






스스로 실행되는 함수는 말 그대로 페이지를 열자마자 자동적으로 실행되는 함수이다.


(function( ){


}) ( );


위와 같이 사용하며 괄호에 주의하자







인자 및 매개변수는 java와는 다르게 함수 선언 시 매개변수 타입을 지정하지 않는다.


기본적으로 object 타입으로 잡히고 인자를 입력 시에는 선언 된 매개변수보다 인자를 많이 입력해도


상관은 없지만 초과된 인자는 버려진다.


이와 반대로 적게 호출하는 것도 역시 가능하고 사용이 안된 매개변수는 undefined라고 입력된다.


function 함수 이름( a, b, c){


}


함수 이름(a, b, c, d, e);

함수 이름(a, b);









리턴처리는 java와 똑같아 설명을 생략한다.


function 함수 이름(){


return 0;

}







가변인자 함수는 처음 선언 시 매개변수를 비워놓고


사용 할 때 인자를 마음대로 넣는 것이다.


이와 같이 사용하고 함수 안에서는 arguments라는 키워드로 매개변수를 다룰 수 있다.


arguments는 object 타입의 배열 형태로 입력한 값을 가지게 된다.


기본 틀을 확인해보자


function 함수 이름(){

arguments.length;

}


함수 이름(a, b, c, d, e, f, g);








내부(중첩) 함수는 함수 안의 함수라고 생각하면 된다.


앞에서 설명한 것 처럼 함수는 변수 취급으로


지역변수처럼 함수 안에서 선언한 내부함수이기 때문에


바깥에서 사용할 수 없는 함수이다.


function 함수이름(){

function 내부함수이름(){


}


내부함수이름();

}


함수이름() --- 사용가능


내부함수이름() --- 사용불가








다음의 예제를 통해 앞서 설명한 기능들을 확인해보자




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	p {
		width: 500px;
		height: 100px;
		background: lightgray;
		border: 1px solid black;
	}
</style>
</head>
<body>
	<h1>함수(Function)</h1>
	<h3>function 함수명(){소스코드 작성} 로 작성해서 실행하는 방법</h3>
	<button onclick="test1();">실행확인</button>
	<p id="p1"></p>
	
	<script type="text/javascript">
		function test1() {
			var p1 = document.getElementById("p1");
			
			p1.innerHTML += "test1() 함수 실행됨"
		}
	</script>
	
	<h3>함수명 = function(){코드작성} : 익명함수(이벤트 핸들러 작성시 주로 사용)</h3>
	<p id="p2"></p>
	<button onclick="test2();">실행확인</button>
	<script>
		// 변수방에 함수를 담아 사용하는 것
		test2 = function(){
			var p2 = document.getElementById("p2");
			
			p2.innerHTML += "test2() 함수 실행 확인";
		}
	</script>
	
	<h3>스스로 실행하는 함수 : (function(){})()</h3>
	<p id="p3"></p>
	
	<script type="text/javascript">
		(function() {
			var p3 = document.getElementById("p3");
			
			p3.innerHTML += "자동으로 혼자 실행됨...";
		})();
	</script>
	
	<h3>함수의 전달 인자와 매개변수</h3>
	<button id="btn1">실행 확인</button>
	<p id="p4"></p>
	<script type="text/javascript">
		function test4(value) {
			var p4 = document.getElementById("p4");
			
			p4.innerHTML += value + "<br>";
		}
		
		document.getElementById("btn1").onclick = function name() {
			test4(window.prompt("메세지를 입력하세요"));
			// 지정된 매개변수보다 많은 갯수의 인자를 넣는 것을 허용한다.
			// 단, 초과된 인자는 무시된다.
			test4('안녕하세요', '반갑습니다');
			// 지정된 매개변수보다 적게 호출하는 것도 허용한다.
			// 단, 선언이 안된 매개변수는 undefined가 된다.
			test4();
		}
	</script>
	
	<h3>함수의 리턴처리</h3>
	<button onclick="test5();">실행확인</button>
	<p id="p5"></p>
	<script type="text/javascript">
		function returnFunction() {
			return Math.floor(Math.random() * 100) + 1;
		}
		function test5() {
			var p5 = document.getElementById("p5");
			
			var value = returnFunction();
			
			p5.innerHTML = value;
			
		}
	</script>
	
	<h3>가변인자 함수 테스트</h3>
	<button onclick="test6();">확인하기</button>
	<p id="p6"></p>
	
	<script type="text/javascript">
		function sumAll() {
			// arguments를 사용하면 매개변수를 사용하지 않아도 매개변수 값을 확인할 수 있다.
			console.log(arguments);
			console.log('arguments의 타입 : ' + typeof(arguments));
			console.log('arguments의 길이 : ' + arguments.length );
			
			var sum = 0;
			for(var i = 0; i < arguments.length; i++){
				sum += arguments[i];
			}
			
			document.getElementById("p6").innerHTML = '더하기 결과 : ' + sum;
		}
	
		function test6() {
			sumAll(11, 2, 33, 444, 5555, 66, 77, 8);
			sumAll(33, 44, 66, 22, 33, 11,22, 44, 44, 55, 66);
		}
	</script>
	
	<h3>내부(중첩된) 함수 테스트</h3>
	<label>삼각형 밑변 : </label>
	<input type="number" min="1" max="100" id="width" required>
	<br>
	<label>삼각형 높이 : </label>
	<input type="number" min="1" max="100" id="height" required>
	<br>
	<button onclick="test7();">실행 확인</button>
	<br>
	<p id="p7"></p>
	<script type="text/javascript">
		// 피타고라스의 정리
		// 모든 직각 삼각형에서 빗변의 제곱은 다른 두 변의 제곱의 합과 같다.
		function calc(w, h) {
			// 내부 함수는 지역변수처럼 여기서만 사용가능
			// 밖으로 나갈 수 없음
			function square(x) {
				return x * x;
			}
			return Math.sqrt(square(2) + square(h));
		}
		function test7() {
			var width = document.getElementById("width").value
			var height = document.getElementById("height").value
			
			document.getElementById("p7").innerHTML += '빗변의 길이 : ' + calc(width, height);
			
		}
	</script>
</body>
</html>





JS 에서 함수를 생성하고 그 안에서 생성한 변수는 지역변수가 되어 바깥에서는 사용 할 수 없다.


하지만 클로져 기능을 이용하면 함수 바깥으로 꺼내어 사용할 수 있다. (return 기능)


다음 예제를 확인해보자



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
	<h1>클로저</h1>
	
	<h3>지역변수의 스코프</h3>
	<p>함수 내부에 선언된 변수는 함수 밖에서 사용할 수 없다.</p>
	<button onclick="test1();">실행확인</button>
	<script type="text/javascript">
		function test1() {
			var name = "난이름";
			// alert(name);
			
		}
		// alert(name);
	</script>
	
	<hr>
	
	<h3>클로저</h3>
	<p>지역변수는 함수가 실행될 때 생성되고 함수가 종료될 때 사라진다<br>
	하지만 함수를 리턴하는 함수(클로저)를 이용하면 규칙을 위반할 수 있다.</p>
	<button onclick="callCloser();">실행확인</button>
	
	<script type="text/javascript">
		function test2(name) {
			var output = "hello " + name + "님!";
			
			// 함수를 리턴한다는 의미
			return function(){
				return output;
			}
		}
		function callCloser() {
			alert(test2(prompt())());
		}
	</script>
	
	<h3>여러 개의 클로저</h3>
	<button onclick="test4(this);" id="js">JavaScript</button>
	<button onclick="test4(this);" id="jq">JQuery</button>
	<script type="text/javascript">
		function test3(subject) {
			var out = "오늘 배울 내용은 " + subject + "입니다.";
			
			return function() {
				return out;
			}
		}
		
		function test4(button) {
			var btn1 = document.getElementById("js");
			var btn2 = document.getElementById("jq");
			
			if(button == btn1){
				btn1.style.display = "none";
				btn2.style.display = "block";
				alert(test3(btn1.innerHTML)());
			}else {
				btn2.style.display = "none";
				btn1.style.display = "block";
				alert(test3(btn2.innerHTML)());
			}
		}
	</script>
</body>
</html>


Java Script에서 배열은 java의 Array List <Object>와 비슷하다.


js의 배열은 제네릭 부분에 오브젝트로 설정되어있는 것처럼 어떤 값이든 받을 수 있는 배열이다.


선언 방법은 5가지로


var arr1 = new Array();

var arr2 = new Array(5);

var arr3 = [];

var arr4 = [1, 2, 3, 4, 5];


방의 크기를 지정하지 않는 방법


방의 크기만 지정하는 방법


방의 크기를 지정하지 않는 방법2


값을 바로 선언하는 방법


4가지가 된다.




배열에서 사용할 수 있는 메소드들은 아래와 같이 있다.


몰론 더 많이 있지만 자주 쓰이는거 위주로 모아놨다.



indexOf(문자열) : 인자로 받은 값이 배열에 어디 위치 했는지를 반환한다.


concat(배열) : 인자로 받은 배열을 합칠 때 사용한다.


join(구분자) : 배열의 값들을 '구분자'로 구분하여 합쳐서 값을 반환한다. (그냥 배열 자체를 출력 했을 때와 결과가 같지만 자료형은 String) (구분자 기본값은 ',' 이다.)


reverse() : 배열을 뒤집는다.


sort() : 배열을 정렬한다.(단, 숫자의 경우 456 이라면 맨 앞의 숫자 4를 기준으로 정렬, 문자열로 인식해서 정렬한다.)


push(Object) : 배열의 뒤에 값을 추가한다.


pop() : 배열의 맨 뒤의 값을 제거하고 그 값을 리턴


shift() : 배열의 맨 앞의 요소를 제거


unshift(Object) : 배열의 맨 앞에 값을 추가


slice(index1, index2) : index1부터 index2 - 1 범위의 배열 값을 반환한다.


splice(index, 갯수, 추가할 Object) : 배열의 index번째 부터 '갯수' 만큼 삭제하고 맨 뒤에 'Object'를 추가한다.


toString() : 배열의 값들을 ','로 구분하여 문자열로 반환한다, join과 비슷하지만 구분자를 지정 할 수 없다.




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area{
		border: 2px solid red;
		background-color: lightgray;
		height: 200px;
	}
</style>
</head>
<body>
	<h1>배열</h1>
	<h3>배열이란?</h3>
	<p>자바스크립트에서는 자료형 지정이 없기 때문에
	모든 자료형을 보관하는 변수의 모음을 배열로 처리한다.<br>
	자바에서의 arrayList와 비슷하다.</p>
	
	<div id="area1" class="area"></div>
	<button onclick="arrayTest();">확인하기</button>
	
	<script type="text/javascript">
		function arrayTest() {
			var area1 = document.getElementById("area1");
			
			//배열을 생성하는 4가지 방법
			var arr1 = new Array();
			var arr2 = new Array(5);
			var arr3 = [];
			var arr4 = [1, 2, 3, 4, 5];
			
			console.log(arr1);
			console.log(arr2);
			console.log(arr3);
			console.log(arr4);
			
			console.log(typeof(arr1));
			console.log(typeof(arr2));
			console.log(typeof(arr3));
			console.log(typeof(arr4));
			
			// 자바의 컬렉션처럼 모든 타입의 값을 배열 형태로 담을 수 있다.
			var arr5 = ['문자', 2, true, [1, 2, 3, 4]];
			console.log(arr5);
			
			area1.innerHTML += arr5 + "<br>";
			console.log(arr5);
			
			for(var i = 0; i < arr5.length; i++){
				area1.innerHTML += 'arr5[' + i + '] : ' + arr5[i] + "<br>";
			
				if(i == 3){
					for(var j = 0; j < arr5[i].length; j++){
						area1.innerHTML += 'arr5[' + i + '][' + j + '] : ' + arr5[i][j] + "<br>";
					}
				}
			}
		}
	</script>
	
	<hr>
	
	<h3>배열의 선언</h3>
	<p>배열 선언시 크기를 지정하지 않고 선언할 수도 있고,
	크기를 정하고 선언할 수도 있다.</p>
	
	<div id="area2" class="area"></div>
	<button onclick="arrayTest2();">확인하기</button>
	<script type="text/javascript">
		function arrayTest2() {
			var area2 = document.getElementById("area2");
			
			var arr1 = new Array();
			var arr2 = new Array(3);
			
			console.log(arr1);
			console.log(arr2);
			
			// 크기를 지정하지 않은 배열에 값 대입 add와 비슷
			arr1[0] = '바나나';
			arr1[1] = '복숭아';
			arr1[2] = '키위';
			arr1[3] = '딸기';
			
			console.log(arr1);
			// 하지만 콘솔에서 맨 처음 console.log(arr1);을 펼쳐보면 바나나 등등 데이터가 똑같이 들어가있다.
			// 콘솔은 최종의 데이터를 보여주는것을 꼭 생각해두자.
			
			// 크기를 지정한 배열에 값 대입
			arr2[0] = '자동차';
			arr2[1] = '비행기';
			arr2[2] = '도보';
			// 없는 인덱스에도 값 대입(동적으로 생성해준다.)
			arr2[3] = '기차';
			
			console.log(arr2);
			
			var arr3 = new Array('홍길동', '임꺽정', '신사임당');
			console.log(arr3);
			
			var arr4 = ['java', 'oracle', 'html5', 'css3', 'javascript'];
			console.log(arr4);
		}
	</script>
	
	<hr>
	
	<h3>Array 객체의 메소드</h3>
	<p>Array도 하나의 객체이기 때문에 배열에서 활용할 수 있는 메소드가 있다.</p>
	
	<h4>indexOf() : 배열에서 요소가 위치하는 인덱스를 리턴</h4>
	<div id="area3" class="area"></div>
	<button onclick="methodTest1();">확인하기</button>
	<script type="text/javascript">
		function methodTest1() {
			var area3 = document.getElementById("area3");
			// area3 같이 id로 지정하면 전역변수로 지정되기 때문에 이와같이 선언하지 않고
			// 그냥 써도 되지만 권장하지 않는 방법이다.
			
			var arr = ['사과', '딸기', '바나나', '복숭아', '키위', '파인애플', '토마토'];
			var str = prompt("찾는 과일 이름을 입력하세요");
			
			area3.innerHTML += "당신이 찾는 과일 " + str + "은" + arr.indexOf(str) 
								+ "번째 인덱스에 있습니다.";
			
		}
	</script>
	
	<br>
	
	<h4>concat(배열명) : 두 개 혹은 세 개의 배열을 결합할 때 사용한다.</h4>
	
	<div id="area4" class="area"></div>
	
	<button onclick="methodTest2();">확인하기</button>
	
	<script>
		function methodTest2() {
			var area4 = document.getElementById("area4");
			
			var arr1 = ['사과', '딸기', '바나나'];
			var arr2 = ['복숭아', '키위', '파인애플', '토마토'];
			var arr3 = arr1.concat(arr2);
			var arr4 = arr2.concat(arr1);
			
			
			area4.innerHTML += "arr1 : " + arr1 + "<br>";
			area4.innerHTML += "arr2 : " + arr2 + "<br>";
			
			area4.innerHTML += "arr1 기준으로 배열을 합침 : " + arr1.concat(arr2) + "<br>";
			area4.innerHTML += "arr2 기준으로 배열을 합침 : " + arr2.concat(arr1) + "<br>";
			
			// 원본 배열에 영향을 끼치지 않는 메소드이다.
			area4.innerHTML += "arr1 다시 출력 : " + arr1 + "<br>";
			area4.innerHTML += "arr2 다시 출력 : " + arr2 + "<br>";
			
			console.log(arr1);
			console.log(arr2);
			console.log(arr3);
			console.log(arr4);
		}
	</script>
	
	<h4>join() : 배열을 결합하여 문자열로 반환한다.</h4>
	<div id="area5" class="area"></div>
	<button onclick="methodTest3();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest3() {
			var area5 = document.getElementById("area5");
			
			var arr = ['소녀시대', '핑클', 'SES', '미쓰에이'];
			
			//,를 기준으로 문자열 합치기를 한 결과 문자
			var arrJoin = arr.join();
			
			area5.innerHTML += "arr : " + arr + "<br>";
			area5.innerHTML += "arrJoin : " + arrJoin + "<br>";
			area5.innerHTML += "arr의 자료형 : " + typeof(arr) + "<br>";
			area5.innerHTML += "arrJoin의 자료형 : " + typeof(arrJoin) + "<br>";
			
			console.log(arr);
			console.log(arrJoin);
			
			// String의 Split 키워드로 다시 원상복구가 가능하다.
		}
	</script>
	
	<br>
	
	<h4>reverse() : 배열의 순서을 뒤집는다.</h4>
	<div id="area6" class="area"></div>
	<button onclick="methodTest4();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest4() {
			var area6 = document.getElementById("area6");
			
			var arr = [1,2,3,4,5,6,7,8,9];
			
			//원본 배열에 영향을 끼치는 메소드이다.
			area6.innerHTML += "arr : " + arr + "<br>";
			area6.innerHTML += "arrReverse : " + arr.reverse() + "<br>";
			area6.innerHTML += "arr 다시 출력 : " + arr + "<br>";
			
		}
	</script>
	
	<br>
	
	<h4>sort() : 배열을 내림차순 혹은 오름차순으로 정렬한다.</h4>
	<div id="area7" class="area"></div>
	<button onclick="methodTest5();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest5() {
			var area7 = document.getElementById("area7");
			
			var arr = [10, 42, 324, 456, 984, 412];
			
			// 오름차순 정렬
			// 숫자 크기대로 정렬하는 것이 아님
			// 배열에 있는 내용을 문자열로 바꾸어 아스키코드 문자 순서로 정렬되니 주의해야 함
			// 또한 원본 배열에 영향을 끼치는 메소드이다.
			area7.innerHTML += "arr : " + arr + "<br>";
			area7.innerHTML += "arr.sort()의 값 : " + arr.sort() + "<br>";
			area7.innerHTML += "arr 다시 출력 : " + arr + "<br>";
			
			// 내림차순 정렬
			// 두 번째 인수가 더 큰 경우 양수값을 리턴하여 순서를 바꾼다.
			area7.innerHTML += "내림차순 정렬 : " + arr.sort(function(left, right){
															return right - left;
														}) + "<br>";
			area7.innerHTML += "arr 다시 출력: " + arr + "<br>";
														
		}
	</script>
	
	<br>
	
	<h4>push() : 배열의 맨 뒤에 요소를 추가<br>
	pop : 배열의 맨 뒤에 요소를 제어하고 리턴</h4>
	
	<div id="area8" class="area"></div>
	<button onclick="methodTest6();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest6() {
			var area8 = document.getElementById("area8");
			
			var arr = ['서초동', '방배동', '역삼동', '삼성동', '대치동'];
			
			area8.innerHTML += "arr의 기본값 : " + arr + "<br>";
			
			arr.push('남양주시');
			
			area8.innerHTML += "arr에 push : " + arr + "<br>";
			
			arr.sort();
			
			area8.innerHTML += "arr 정렬 : " + arr + "<br>";
			
			arr.push('잠실본동');
			arr.sort();
			
			area8.innerHTML += "arr에 push2 : " + arr + "<br>";
			
			area8.innerHTML += "arr에서 pop : " + arr.pop() + "<br>";
			
			area8.innerHTML += "arr에 pop 수행 후 : " + arr + "<br>";
			
			arr.pop();
			arr.pop();
			arr.pop();
			arr.pop();
			arr.pop();
			
			for(var i = 0; i < arr.length; i++){
				console.log(arr[i]);
			}
		}
	</script>
	
	<br>
	
	<h4>shift() : 배열의 맨 앞의 요소 제거<br>
	unshift() : 배열의 맨 앞의 요소 추가</h4>
	<div id="area9" class="area"></div>
	<button onclick="methodTest7();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest7() {
			var area9 = document.getElementById("area9");
			
			var arr = ['야구', "축구", "볼링", "탁구", "테니스"];
			
			area9.innerHTML += "arr의 기본값 : " + arr.shift() + "<br>";
			
			area9.innerHTML += "arr에 shift하면? : " + arr.shift() + "<br>";
			
			area9.innerHTML += "arr 다시 출력 : " + arr + "<br>";
			
			area9.innerHTML += "arr에 unshift하면? : " + arr.unshift("당구") + "<br>";
			
			area9.innerHTML += "arr 다시 출력 : " + arr + "<br>";
		}
	</script>
	
	<br>
	
	<h4>slice() : 배열의 요소 선택해서 잘라내기<br>
	splice() : 배열의 index위치의 요소 제거 및 추가</h4>
	<div id="area10" class="area"></div>
	<button onclick="methodTest8();">확인하기</button>
	
	<script type="text/javascript">
		function methodTest8() {
			var area10 = document.getElementById("area10");
			
			var arr = ["자바", "라클이", "html5", "css3", "javascript"];
			
			area10.innerHTML += "arr : " + arr + "<br>";
			// slice(시작인덱스, 종료인덱스 + 1)
			area10.innerHTML += "slice를 해보면 : " + arr.slice(2, 4) + "<br>";
			//원본에 영향을 끼치지 않는 메소드
			area10.innerHTML += "원본 arr : " + arr + "<br>";
			
			// splice(index, 제거수, 추가값)
			// 2번 인덱스부터 2개의 요소를 꺼내고, 추가값으로 대체한다.
			area10.innerHTML += "splice를 해보자 : " + arr.splice(2, 2, 'spring') + "<br>";
			
			area10.innerHTML += "원본을 다시 보면? : " + arr + "<br>";
		}
	</script>
	
	<br>
	
	<h4>toString() : 배열을 문자열로 반환한다.</h4>
	<div id="area11" class="area"></div>
	<button onclick="methodTest9();">확인하기</button>
	
	<script>
		function methodTest9(){
			var area11 = document.getElementById("area11");
			
			var arr = ["나는", "오늘", "부터", "다이어트를", "시작한다."];
			
			area11.innerHTML += "기본 arr 출력 : " + arr + "<br>";
			// 원본 배열에 영향을 끼치지 않고 문자열을 반환하는 함수이다.
			area11.innerHTML += "toString : " + arr.toString() + "<br>";
			
			area11.innerHTML += "arr의 자료형 : " + typeof(arr) + "<br>";
			
			area11.innerHTML += "arr의 자료형 : " + typeof(arr.toString()) + "<br>";
			
			area11.innerHTML += "join() : " + arr.join() + "<br>";
			
			area11.innerHTML += "join한 자료형 : " + typeof(arr) + "<br>";
			
			area11.innerHTML += "join에 구분자 지정하여 문자열 합치기 : " + arr.join('/') + "<br>";
			
		}
	</script>
</body>
</html>


짧게 말하면


==는 강제 형변환 하여 변수 안의 값이 같으면 true를 반환한다.


ex) "1" = 1 와 같이 문자열 1과 숫자 1을 같다고 인식한다.


반면에 === 3개는 값 + 자료형을 비교하여 true, false를 반환한다.


ex) "1" = 1 는 false가 된다.




switch는 아래와 같이 자바와 똑같다.


case default를 사용할 수 있다.



switch (조건) {

case 값 :

문구

break;

default:

문구

break;

}


그리고 조건에 true라고 설정하고


값 부분에 식을 넣을 수도 있다.


값에 true나 false를 반환하는 식을 넣으면 조건에 true라고 했을경우 true인 case가 실행이 된다.



예제를 확인해보자



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area1{
		border: 1px solid red;
		height: 200px;
	}
</style>
</head>
<body>
	<h1>자바와 다른 연산자</h1>
	<h3>=== 연산자와 !== 연산자</h3>
	<p>값과 자료형 둘 다 일치하는지 / 일치하지 않는지 확인할 때 사용한다.</p>
	
	<button onclick="testOp();">확인하기</button>
	
	<div id="area1" class="area"></div>
	
	<script>
		function testOp(){
			var area1 = document.getElementById("area1");
			
			var check1 = 1;
			var check2 = "1";
			
			// 등호 2개
			area1.innerHTML += "check1 == 1 : " + (check1 == 1) + "<br>";
			area1.innerHTML += 'check1 == "1" : ' + (check1 == "1") + "<br>";
			area1.innerHTML += 'check2 == 1 : ' + (check2 == 1) + "<br>";
			area1.innerHTML += 'check2 == "1" : ' + (check2 == "1") + "<br>";
			
			// 등호 3개(값 + 자료형 비교)
			area1.innerHTML += 'check1 === 1 : ' + (check1 === 1) + "<br>";
			area1.innerHTML += 'check1 == "1" : ' + (check1 === "1") + "<br>";
			
		}
	</script>
	
	<hr>
	
	<h3>연산자를 이용한 짧은 조건문 테스트</h3>
	<button onclick="checkLogic();">확인하기</button>
	<script>
		function checkLogic(){
			var input = Number(window.prompt("숫자를 입력하세요"));
			
			//짧은 조건문 : ||는 앞에 조건이 거짓이면 뒤에 연산을 실행함
			//          &&는 앞에 조건이 참이면 뒤에 연산을 실행함
			input % 2 == 0 || alert("홀수입니다.");
			input % 2 == 0 && alert("짝수입니다.");
		}
	</script>
	
	<hr>
	
	<h3>switch문 테스트</h3>
	<button onclick="switchTest();">실행확인</button>
	<script type="text/javascript">
		function switchTest() {
			var today = new Date();
			var hour = today.getHours();
			
			switch (true) {
			case hour == 12 :
				alert("점심시간입니다.");
				break;
			case hour > 12 :
				alert("수업시간입니다.");
				break;
			default:
				alert("기본값입니다.")
				break;
			}
		}
	</script>
</body>
</html>


+ Recent posts