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>


자바에서 유용하게 쓰던 문자열 메소드와 수학 메소드를 소개한다.


- String 메소드 -




toUpperCase : 해당 문자열을 전부 대문자로 치환


toLowerCase : 해당 문자열을 전부 소문자로 치환


length : 문자열의 길이를 반환


indexOf : 어떤 문자를 받아 그 문자가 문자열의 앞에서 몇번째에 위치 하는 문자인지 검색


lastIndexOf : 어떤 문자를 받아 그 문자가 문자열의 뒤에서 몇번째에 위치 하는 문자인지 검색


charAt : 문자열의 n번째 문자를 리턴하는 메소드


substring : 문자열을 n1번째 부터 n2 -1 번째 까지 잘라서 보여주는 메소드


split : 문자열을 특정 기준을 잡아 잘라서 배열로 반환 (ex   가, 나, 다, 라,    ", " 기준으로 split ->  배열[가, 나, 다, 라])





- Math 메소드 -




abs : 해당 값을 절대값으로 반환


random : 랜덤값 발생


round : 소수 반올림


floor : 소수 버림


ceil : 소수 올림





예제를 직접 하나하나씩 써보고 결과를 확인해보자




<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style type="text/css">
	.area1{
		border: 1px solid red;
		height:450px;
	}
	.area2 {
		border:1px solid red;
		height:150px;
		
	}
</style>
</head>
<body>
	<h1>String과 Math</h1>
	<h3>String</h3>
	<p>"" 혹은 ''로 묶여 있는 리터럴이다.<br>
	자바스크립트의 내장객체로 String 객체의 기본적인 메소드가 있다.</p>
	<button onclick="showStringMethod();">문자열 처리 메소드</button>
	<div id="area1" class="area1"></div>
	<script type="text/javascript">
		function showStringMethod() {
			var str1 = "Apple Iphone";
			
			var area1 = document.getElementById("area1");
			
			// 대문자, 소문자로 변경해주는 메소드
			area1.innerHTML += "toUpperCase() : " + str1.toUpperCase() + "<br>";
			area1.innerHTML += "toLowerCase() : " + str1.toLowerCase() + "<br>";
			
			// 문자열의 길이를 리턴하는 속성
			area1.innerHTML += "length : " + str1.length + "<br>";
			
			// 문자열에 n번째 위치 찾는 메소드 (0번부터 시작하므로 1을 더하면 편함)
			area1.innerHTML += "문자열에서 e의 위치 : " + (str1.indexOf('e') + 1) + "<br>";
			area1.innerHTML += "뒤에서부터 e의 위치 : " + (str1.lastIndexOf('e') + 1) + "<br>";
			
			// 문자열에서 n번째 인덱스에 해당하는 문자를 리턴하는 메소드
			for(var i = 0; i < str1.length; i++){
				area1.innerHTML += i + "번째 인덱스 : " + str1.charAt(i) + "<br>";
			}
			// 문자 하나도 문자열이라고 생각
			
			// 문자열의 일부만 리턴하는 메소드 (8부터 10 전까지 자른다.)
			area1.innerHTML += "문자열 일부만 리턴 : " + str1.substring(8, 10) + "<br>";
			
			// 문자열을 분리하여 배열로 리턴하는 메소드
			var str2 = "사과, 바나나, 복숭아, 키위, 파인애플";
			
			var fruits = str2.split(", ");
			
			area1.innerHTML += "str2 : " + str2 + "<br>";
			area1.innerHTML += "fruits : " + fruits + "<br>";
			
			console.log(str2);
			console.log(fruits);
		}
	</script>
	
	<h3>Math</h3>
	<button onclick="showMathMethod();">숫자 처리 메소드</button>
	<div id="area2" class="area2"></div>
	<script type="text/javascript">
		function showMathMethod() {
			var num1 = -123;
			
			var area2 = document.getElementById("area2");
			
			area2.innerHTML += "절대값 : " + Math.abs(num1) + "<br>";
			
			area2.innerHTML += "임의의 난수 발생 : " + Math.random() + "<br>";
			
			area2.innerHTML += "반올림 : " + (Math.round(123.456 * 100) / 100) + "<br>";
			
			area2.innerHTML += "내림 : " + (Math.floor(123.456 * 100) / 100) + "<br>";
			
			area2.innerHTML += "올림 : " + (Math.ceil(123.456 * 100) / 100) + "<br>";
		}
	</script>
</body>
</html>


자바 스크립트는 변수형이 전부 var로 선언된다.


이는 자바에서 Object 타입으로 생각하면 된다.


문자열, 숫자, 논리, 배열, 객체, 함수, 정의되지 않은 변수와 같이 있고


변수에 넣은 값에 따라서 자료형이 동적으로 바뀐다.


예제를 확인해보자


typeof는 변수와 함께 쓰여 변수가 어떤 자료형인지 출력한다.



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<script type="text/javascript">
	// 전역변수의 선언
	
	// 자동으로 window 객체의 필드가 됨
	str = "전역변수";
	// 브라우져 개발자 모드에서 조회 가능
	
	// 함수 외부에 선언한 변수는 var를 붙여도 전역변수이다.
	var str2 = "var전역변수";
	
	// window 객체가 로드 될 때 (페이지 로딩 시) 동작할 이벤트
	// 참고로 window 객체는 js의 최상의 객체로 페이지 로딩 시 같이 로드 된다. 
	window.onload = function(){
		// 지역변수 선언
		// 지역변수 선언시 반드시 var를 붙여야 한다.
		var str = "지역변수";
		
		// 지역변수가 우선권을 가진다.
		console.log(str);
		
		// window를 붙여 전역변수 호출
		console.log(window.str);
		console.log(this.str);
		// this는 여러가지 의미가 있지만 그 중 하나로 window 객체를 의미
		
		// 함수 내에서 작성되어도 var 키워드를 사용하지 않으면 전역변수가 된다.
		str3 = "난 뭘까요?";
		
		console.log(str3);
		console.log(window.str3);
		console.log(this.str3);
		
		what = "전역변수인지 확인"
		showwhat();
	}
	function showwhat() {
		console.log(what);
	}
</script>
<style>
	.area{
		border: 1px solid black;
		height: 150px;
	}
</style>
</head>
<body>
	<h1>변수와 자료형</h1>
	<h3>변수 선언</h3>
	<p>함수 내부에서 var 변수명; 으로 선언하면 지역변수가 된다.<br>
	함수 내부에서 변수명; 으로  선언하거나, 함수 밖에서 변수명; 혹은 var 변수명;으로
	선언하면 전역변수가 된다.<br>
	지역변수와 전역변수가 동일한 이름인 경우 함수 내부에서 변수명을 호출하면
	지역변수가 우선권을 가지기 때문에<br>
	전역변수 사용시 window.변수명 혹은 this.변수명으로 표현하여
	지역변수와 구분한다.<br>
	전역변수는 해당 window 내에서 어디든 사용할 수 있으며,
	지역변수는 해당 함수 내에서만 사용 가능하다.</p>
	
	<hr>
	
	<h3>자료형</h3>
	<p>자바스크립트에서는 자료형별로 변수 타입이 지정되지 않고
	리터럴에 의해서 동적으로 자료형이 결정된다.</p>
	<button onclick="testType()">자료형 테스트</button>
	
	<br><br>
	
	<div id="area1" class="area"></div>
	
	<script type="text/javascript">
		function testType() {
			// 문자열 변수
			var name = 'abcd';
			
			// 숫자 변수
			var age = 20;
			
			// 논리 변수
			var check = true;
			
			// 배열 변수
			var hobby = ["축구", "농구", "야구"];
			
			// 객체 변수
			var user = {name:"abcd", age:20, id:"user01"};
			
			// 함수 변수
			var testFunction = function testFunction(num1, num2){
									var sum = num1 + num2;
									
								}
			// 정의되지 않은 변수
			var apple;
			
			console.log(typeof(name) + " : " + name);
			console.log(typeof(age) + " : " + age);
			console.log(typeof(check) + " : " + check);
			console.log(typeof(hobby) + " : " + hobby);
			console.log(hobby);
			console.log(typeof(user) + " : " + user);
			console.log(user);
			console.log(typeof(testFunction) + " : " + testFunction);
			
			var area1 = document.getElementById("area1");
			
			area1.innerHTML += "배열 : " + hobby + "<br>";
			area1.innerHTML += "배열 인덱스[0] : " + hobby[0] + "<br>";
			area1.innerHTML += "배열 인덱스[1] : " + hobby[1] + "<br>";
			area1.innerHTML += "배열 인덱스[2] : " + hobby[2] + "<br>";
			area1.innerHTML += "객체 : " + user + "<br>";
			area1.innerHTML += "객체 속성 : " + user.name + ", " + user.age + ", " + user.id + "<br>";
			area1.innerHTML += "함수 : " + testFunction + "<br>"
			area1.innerHTML += "정의되지 않은 변수 : " + apple + "<br>"
			
			
		}
	</script>
	
	<hr>
	
	<h3>동적 타입 테스트</h3>
	<p>자바스크립트에서 변수는 타입이 지정되는 것이 아닌, 동적으로 타입이 결정된다.</p>
	<button onclick="testDynamicType();">실행확인</button>
	<div id="area2"></div>
	<script type="text/javascript">
		function testDynamicType() {
			// 들어온 값에 따른 type의 변화를 살펴보자
			var testVariable = 123;
			
			console.log(typeof(testVariable) + " : " + testVariable);
			
			testVariable = "안녕하세요";
			
			console.log(typeof(testVariable) + " : " + testVariable);
			
			testVariable = [0, 1, 2, 3];
			
			console.log(typeof(testVariable) + " : " + testVariable);
		}
	</script>
	
	
</body>
</html>


보통 태그에 접근하여 그 값을 사용하거나 속성을 변경할 때 이 방법을 이용하는데


변수를 선언하여 document.getElement~~~~ 와 같이 document의 메소드를 이용한다.



Id의 경우는                     var 변수 이름 = document.getElementById("지정한 Id");


태그를 이용할 땐              var 변수 이름 = document.getElementsByTagName("태그 명");


name을 이용할 땐            var 변수 이름 = document.getElementsByName("지정한 name 명");



태그를 이용하여 불러오면 그 태그를 사용하는 모든 항목들이 배열 형태로 변수에 입력된다.


이 변수를 출력하면 태그가 어떤 속성들을 가지고 있는지 확인할 수 있고


속성은 매우 많기 때문에 암기하여 쓰기 보다는 이 기능을 통해서 원하는 속성을 불러오거나 변경하면 된다.



다음 예제를 확인해보자



<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<style>
	.area {
		border:1px solid red;
		height:100px;
	}
</style>
</head>
<body>
	<h1>HTML 태그에 접근하기</h1>
	<h3>아이디로 접근</h3>
	<div id="area1" class="area"></div>
	<!-- 보통 개발자가 id, 퍼블리셔가 class를 쓴다. -->
	<!-- id는 개발자들 끼리의 암묵적 약속으로 고유하게 단 하나의 대상만 가르킴 -->
	<button onclick="accessId();">아이디로 접근</button>
	<script>
		function accessId() {
			var area1 = document.getElementById("area1");

			area1.style.backgroundColor = "yellow";
			
			area1.innerHTML += "아이디로 접근 성공!<br>"
		}
	</script>
	
	<h3>태그명으로 접근</h3>
	<ul>
		<li>목록1</li>
		<li>목록2</li>
		<li>목록3</li>
		<li>목록4</li>
		<li>목록5</li>
	</ul>
	<button onclick="accessTagName();">태그명으로 접근</button>
	<script type="text/javascript">
		function accessTagName() {
			var list = document.getElementsByTagName("li");
			// li 태그는 여러개이기 때문에 getElements, s를 써서 복수형
			console.log(list);
			// F12의 브라우져 관리자 모드로 콘솔에 태그명 하나하나의 속성들을 확인하고
			// 이용해보자
			
			var changeColor = 50;
			
			/*
			for(var i in list){
				list[i].style.backgroundColor = "rgb(130, 220, " + changeColor + " )";
				changeColor += 50;
				
				// 이 반복을 사용하면 list 배열의 0~4번방의 li 값 뿐만 아니라  length라는 속성도 저장되어 있기 때문에
				// 마지막에 접근하려 하면 오류가 발생한다.
			}
			*/
			
			// 그러므로 일반 for문을 사용하여 해결해야 한다.
			for(var i = 0; i< list.length; i++){
				list[i].style.backgroundColor = "rgb(130, 220, " + changeColor + " )";
				changeColor += 50;
			}
		}
	</script>
	
	<hr>
	
	<h3>name으로 접근</h3>
	<form>
		<fieldset>
			<legend>취미</legend>
			<table>
				<tr>
					<td>
						<input type="checkbox" name="hobby" value="game" id="game">
						<label for="game">게임</label>
						<!-- for 속성을 맞춰서 설정하면 체크박스를 누르지 않고 글자를 눌러도 선택이 된다. -->
					</td>
					<td>
						<input type="checkbox" name="hobby" value="music" id="music">
						<label for="music">음악</label>
					</td>
					<td>
						<input type="checkbox" name="hobby" value="movie" id="movie">
						<label for="movie">영화</label>
					</td>
				</tr>
				<tr>
					<td>
						<input type="checkbox" name="hobby" value="money" id="money">
						<label for="money">돈벌기</label>
					</td>
					<td>
						<input type="checkbox" name="hobby" value="running" id="running">
						<label for="running">뛰기</label>
					</td>
					<td>
						<input type="checkbox" name="hobby" value="walk" id="walk">
						<label for="walk">걷기</label>
					</td>
				</tr>
			</table>
		</fieldset>
	</form>
	<div id="area2" class="area"></div>
	<button onclick="accessName();">name으로 접근</button>
	<script type="text/javascript">
		function accessName() {
			var hobby = document.getElementsByName("hobby");
			
			console.log(hobby);
			// 출력한 배열 값의 속성 중 checked가 현재 체크가 되어있는지 상태를 알려줌
			
			var checkItem = "";
			for(var i = 0; i < hobby.length; i++){
				if (hobby[i].checked == true) {
					checkItem += hobby[i].value + "선택함<br>";
				}
			}
			
			document.getElementById("area2").innerHTML = checkItem;
		}
	</script>
</body>
</html>


+ Recent posts