Set

- 값들의 집합

- 입력된 순서에 따라 지정된 요소를 반복 처리할 수 있.

- Set은 중복 값을 허용하지 않는다.

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
/*
 - Set
   값들의 집합
   입력된 순서에 따라 지정된 요소를 반복 처리할 수 있다.
   Set은 중복 값을 허용하지 않는다.
 */
 
var set = new Set();
set.add(100);
set.add("java");
set.add("oracle");
set.add("html");
set.add("css");
set.add("oracle");

// 요소의 수
console.log( set.size ); // 5

// item 존재 여부
console.log( set.has('java') ); // true. 배열의 indexOf보다 빠름

// 특정 요소 삭제
set.delete('css');
console.log( set.size ); // 4

// 처음부터 순회
for(let item of set) { // 블록 변수 let
	console.log(item);
}
console.log('----------------');

// forEach로 순회
set.forEach(function(value) {
	console.log(value);
});

// Set을 배열로 반환
var arr = Array.from(set);
console.log( arr.join() ); // 100,java,oracle,html

// []를 이용한 Set 객체 생성
var set2 = new Set([10,20,30]);
console.log(set2); // Set(3) {10, 20, 30}

// Set 객체의 모든 요소 제거
set2.clear();
console.log( set2.size ); // 

var set3 = new Set();
var obj = { subject:'java', score:100 }; // 객체
console.log( obj.subject, obj.score ); // java 100

set3.add( obj ); // 객체는 주소가 저장됨
set3.add( { subject:'java', score:100 } ); // 속성 및 값은 같지만 obj와는 다른 객체
set3.add( { subject:'java', score:100 } ); // 위와는 다른 객체
set3.add( obj );
console.log( set3.size ); // 3

set3.forEach(function(item){
	console.log(item.subject + ":" + item.score);
});
</script>

</head>
<body>

<h3>내장객체 - Set</h3>

</body>
</html>

 

Map

- 키와 값을 서로 매핑시켜 저장하며, 저장된 순서대로 각 요소들을 반복적으로 접근할 수 있다.

- 키가 같으면 덮어 쓴다.

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">

/*
 - Map 객체
   키와 값을 서로 매핑 시켜 저장하며, 저장된 순서대로 각 요소들을 반복적으로 접근할 수 있다.
   키가 같으면 덮어 쓴다.
 */
 
var map = new Map();
map.set("java", 100);
map.set("oracle", 90);
map.set("html", 100);
map.set("spring", 90);
map.set("oracle", 80);

console.log( map.size );

console.log( map.has('css') ); // false. 키 존재 여부
console.log( map.get('css') ); // 키에 대한 값 반환. 없으면 undefined
console.log( map.get('oracle') ); // 80
map.delete('spring'); // 삭제
console.log(map);
console.log('--------------');

// 처음부터 순회
for(var [key, value]of map) {
	console.log(key+":"+value);
}
console.log('--------------');

map.forEach(function(value, key) {
	console.log(key+","+value);
});
console.log('--------------');

map.forEach( (value, key) => console.log(key+","+value) );
console.log('--------------');

// 모든 엔트리 삭제
map.clear();
console.log( map.size );

// 대괄호(배열)을 이용한 Map 객체 만들기
var map2 = new Map(
	[
		['java', 100],
		['html', 95],
		['oracle', 90]
	]
);

for(var [key, value] of map2) {
	console.log( key+ ":" + value );
}

</script>

</head>
<body>

<h3>내장객체 - Map</h3>

</body>
</html>

Array 객체

- Array 객체는 일련의 값들을 저장할 수 있는 배열을 생성할 때 사용하는 리스트 형태의 고수준 객체이다.

- 배열의 각 요소는 배열의 이름과 인덱스로 접근하여 사용하며, 인덱스는 0부터 시작한다.

- 자바 스크립트 배열의 특징

1. 타입이 고정적이지 않다. 즉, 같은 배열에 있는 원소의 타입이 서로 다를 수 있다.

2. 32비트 인덱스를 사용한다.

3. 크기가 동적이다.

4. 배열을 생성하거나 크기가 변경되어 다시 할당을 하더라도 배열 크기를 다시 선언할 필요가 없다.

5. 모든 배열은 객체이다. 즉, 배열은 객체 프로토타입으로부터 속성들을 상속받은 객체이다.

6. 배열 리터럴에서 빠진 부분이 존재할 경우, 해당 부분의 원소 값은 undefined가 된다.

 

배열 리터럴을 이용한 1차원 배열 생성, 생성자를 이용한 배열 생성

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
// 배열 리터널을 이용한 1차원 배열 생성
var a1 = []; // 빈 배열
var a2 = [10, 20, 30]; // 크기가 3인 배열
var a3 = [10,20,30,];
var a4 = [10,20,,30];

console.log( a1.length ); // length : 배열 요소의 수
console.log( a2.length ); // 3
console.log( a3.length ); // 3. 마지막의 ,는 무시
console.log( a4.length ); // 4
	// 10,20,undefined,30 (,다음에 값이 없으면 undefined)
	
console.log( a2[0] ); // 10 , 첨자는 0부터 시작
console.log( a2[2] ); // 30 
console.log( a2[4] ); // undefined. 전체요소-1 보다 첨자가 크면 undefined

// Array() 생성자를 이용한 배열 만들기
var b1 = new Array(); // 빈 배열
var b2 = new Array(5); // 크기가 5인 배열. 생성자의 인자가 하나인 경우 요소 수를 나타냄.
					   // 요소의 값은 모두 undefined
var b3 = new Array(10,20); // 생성자의 인수가 2개 이상이면 요소의 초기값

console.log( b1.length ); // 0
console.log( b2.length ); // 5
console.log( b3.length ); // 2

console.log( b2[1] ); // undefined
console.log( b3[1] ); // 20


</script>

</head>
<body>

<h3>내장객체 - Array</h3>

</body>
</html>

 

배열 리터럴을 이용한 2차원 배열 생성, 생성자를 이용한 배열 생성

★ a[0].length : a배열 0행의 열수.

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
// Array() 생성자를 이용한 2차원 배열 만들기
var a1 = new Array(2); // 행수
a1[0] = new Array(3); // 0행의 열수
a1[1] = new Array(3); 

console.log( a1.length ); // 행수
console.log( a1[1].length ); // 1행의 열수

// 배열 리터널을 이용한 2차원 배열 만들기
var a2 = [[1,2,3], [4,5,6]];
console.log( a2.length ); // 행수
console.log( a2[0].length ); // 0행의 열수
console.log( a2[1][2] ); // 6

</script>

</head>
<body>

<h3>내장객체 - Array : 2차원 배열</h3>

</body>
</html>

 

배열 순회

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var arr = [10,20, ,30, 0];

// 배열의 요소를 처음부터 끝까지 순회
for(var i=0; i<arr.length; i++){
	console.log(arr[i]);
}
console.log('--------------');

for(var i=0; i<arr.length; i++){
	if(arr[i]) { // undefined, NaN, null, 0, 빈문자''는 거짓
		console.log(arr[i]); // 10 20 30
	}
}
console.log('--------------');

var arr2 = [10,20,30];
for(var n of arr2) { // EX6에 추가된 컬렉션
	console.log(n); // 10 20 30
}
console.log('--------------');

for(var idx in arr2) { // 첨자만 출력
	console.log(idx); // 0 1 2
}
console.log('--------------');

for(var idx in arr2) { // 첨자만 출력
	console.log(arr2[idx]); // 10 20 30
}


</script>
</head>
<body>

<h3>배열 - 순회</h3>

</body>
</html>

for( var n of 배열명) 배열의 값을 꺼내올 때 유용함.

 

배열 요소 추가

더보기

1. 첨자를 이용해서 추가

2. push() 가장 뒤에 새로운 요소 추가

3. unshift() 가장 앞에 새로운 요소 추가

4. splice(start, deleteCount, 추가할요소...) 를 이용해 추가

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var arr1 = [10,20];

console.log( arr1.length ); // 2
console.log( arr1 ); // [10,20]

// 뒤에 하나의 요소를 추가
arr1[2] = 30;
console.log( arr1.length ); // 3
console.log( arr1 ); // [10,20,30]

arr1[4] = 50;
console.log( arr1.length ); // 5
console.log( arr1 ); // [10,20,30,empty,50], 콘솔에서는 undefined는 empty로 표시
console.log( arr1[3] ); // undefined

arr1[arr1.length] = 60; // 가장 뒤에 요소 추가
console.log(arr1.join());  // join() : 배열의 모든 요소를 연결 하나의 문자열로 만듦
				// 10,20,30,,50,60
				
arr1[3] = 30; // 특정 요소의 값 변경
console.log(arr1.join());

// push() : 가장 뒤에 새로운 요소 추가
var arr2 = [10,20];
arr2.push(30); // 뒤에 새로운 요소를 하나 이상 추가하고 길이 반환
console.log(arr2.join()); // 10,20,30

arr2.push(40, 50); 
console.log(arr2.join()); // 10,20,30,40,50

// unshift() : 가장 앞에 새로운 요소 추가
var arr3 = [30,40];
var len = arr3.unshift(10, 20); // 맨 앞에 새로운 요소를 하나 이상 추가하고 길이 반환
console.log("길이:" + len);
console.log(arr3.join());


</script>

</head>
<body>

<h3>배열 - 요소 추가(가장 앞, 가장 뒤)</h3>

</body>
</html>

 

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var arr1 = [10,20,30];
/*
	- splice(start [, deleteCount[, item1, item2]])
		start : 변경을 시작할 배열 위치
		deleteCount : start 부터 deleteCount 개수만큼 원소 삭제
		item1, item2, ... : start 인덱스에 item을 추가
*/

// 가장 앞에 추가
arr1.splice(0, 0, 'a', 'b');
console.log(arr1.join()); // a,b,10,20,30

// 뒤에 추가
var arr2 = [10,20,30];
arr2.splice(arr2.length, 0, 'a', 'b'); 
console.log(arr2.join()); // 10,20,30,a,b

// 중간에 추가
var arr3 = [10,20,30];
arr3.splice(1, 0, 'a', 'b'); 
console.log(arr3.join()); // 10,a,b,20,30

// 삭제하고 추가
var arr4 = [10,20,30,40,50];
arr4.splice(1, 2, 'a', 'b'); 
console.log(arr4.join()); // 10,a,b,40,50


</script>

</head>
<body>

<h3>배열 : 요소 추가(중간)</h3>

</body>
</html>

 

배열에 들어있는 요소 삭제

더보기

1. pop() : 맨 뒤에 있는 요소 삭제 후 요소 반환. 배열의 길이 줄어듦.

2. shift() 처음 요소를 삭제하고 삭제된 요소를 반환. 길이도 줄어듦

3. delete() 첨자에 해당되는 요소를 삭제하고, 그 첨자에 공간에는 undefined를 할당. 길이는 줄어들지 않는다.

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var arr1 = [10,20,30,40,50];
console.log(arr1.join());

// length 속성을 이용한 마지막 요소 삭제
arr1.length = arr1.length - 1;
console.log(arr1.join());

//length 속성을 이용한 모든 요소 삭제
arr1.length = 0;
console.log(arr1.length);
console.log(arr1.join());


// pop() 메소드를 이용한 마지막 요소 삭제
var arr2 = [10,20,30,40,50];
var a = arr2.pop(); // 마지막 요소를 삭제하고 삭제된 요소를 반환 길이도 줄어듬
console.log(arr2.length); // 4
console.log(arr2.join()); // 10,20,30,40
console.log(a); // 50

// shift() 메소드를 이용한 처음 요소 삭제
var arr3 = [10,20,30,40,50];
var b = arr3.shift(); // 처음 요소를 삭제하고 삭제된 요소를 반환. 길이도 줄어듬
console.log( arr3.length ); // 4
console.log( arr3.join() ); // 20, 30, 40,50
console.log(b); // 10

// delete() 메소드를 이용한 요소 값 없애기
var arr4 = [10,20,30,40,50];
delete(arr4[1]); // arr4[1]의 요소의 값을 없애고 undefined를 할당. 배열의 길이는 줄지 않음
console.log(arr4.length);
console.log(arr4[1]); // undefined
</script>

</head>
<body>

<h3>배열 - 삭제</h3>

</body>
</html>

 

배열 메소드

더보기

1. indexOf (): 배열에서 요소를 검색해 인덱스를 반환한다. 없으면 -1 반환.

2. join() - 배열의 요소를 연결해 하나의 문자열로 만든다.

3. reverse() - 배열의 순서를 반전 시킨다.

 

주요 정적 메소드

isArray() 인자가 Array인지 판별

of() 인자의 수나 유형에 관계없이 가변 인자를 갖는 새로운 Array 인스턴스를만든다.

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var arr1 = [10,20,30,20,40];
var n;

n = arr1.indexOf(20);
console.log('20의 인덱스 : ' + n); // 1

n = arr1.lastIndexOf(20);
console.log('뒤에서 부터 검색한 20의 인덱스 : ' + n); // 3

n = arr1.indexOf(50);
console.log("50의 인덱스 : " + n); // 없으면 -1

// join() : 배열의 요소를 연결해 하나의 문자열로 만든다.
n = arr1.join();
console.log(n);

var arr2 = [10,20,30,40,50];
var a = arr2.reverse(); // 배열의순서를 반전 시킴
console.log( arr2.join() ); // 50 40 30 20 10
console.log( a.join() ); // 50 40 30 20 10

</script>

</head>
<body>

<h3>배열 - 메소드</h3>

</body>
</html>

 

배열 - 정렬

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
// sort() : 기본적으로 문자의 유니코드 코드포인터값에 따라 정렬함
var arr1 = ["BBA", "BC", "CC", "ABC"];
arr1.sort(); // 유니코드 값의 사전식 배열
console.log(arr1.join()); // ABC,BBA,BC,CC

var arr2 = [55, 7 ,10, 35 ,40];
arr2.sort(); // 유니코드 값의 사전식 배열
console.log(arr2.join()); // 10,35,40,55,7

var arr3 = ["BBA", "BC", "CC", "ABC"];
arr3.sort(function(a, b){ // 오름차순 정렬 : 문자열은 arr3.sort(); 만 해도 오름차순 정렬
	if(a>b) return 1;
	else if(a<b) return -1;
	else return 0;
});
console.log(arr3.join()); // ABC,BBA,BC,CC

var arr4 = ["BBA", "BC", "CC", "ABC"];
arr4.sort(function(a, b){ // 내림차순 정렬
	if(a>b) return -1;
	else if(a<b) return 1;
	else return 0;
});
console.log( arr4.join() ); // CC,BC,BBA,ABC

var arr5 = [55, 7 ,10, 35 ,40];
arr5.sort(function(a,b){ // 오름차순
	return a-b; // 정렬하는 기준 점을 찹아줌
});
console.log( arr5.join() ); // 7,10,35,40,55

var arr6 = [55, 7 ,10, 35 ,40];
arr6.sort(function(a,b){ // 내림차순
	return -(a-b);
});
console.log( arr6.join() ); // 55,40,35,10,7

</script>

</head>
<body>

<h3>배열 : 정렬</h3>

</body>
</html>

 

forEach

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var arr = [1,2,3,4,5];
var s = 0;

arr.forEach(function(item){ // 순서대로 가져옴
	s += item;
});
console.log(s);

var arr2 = [10,20,30,40,50];
arr2.forEach(function(item, index){ // item:각요소값, index:첨자
	console.log(index+":"+item);
});

</script>

</head>
<body>

<h3>forEach</h3>


</body>
</html>

 

map, filter

더보기

filter() : 조건에 만족한 요소만으로 새로운 배열 작성

map() : 배열의 각 요소에 대하여 순차적으로 주어진 함수를 실행한 반환 값으로  새로운 배열을 반환

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var arr = [1,2,3,4,5,6,7,8,9,10];

// arr의 배열 내용중 홀수 값을 갖는 새로운 배열 작성
var arr2 = []; // 빈 배열 선언
/*
for(var i=0; i<arr.length; i++){
	if(arr[i] % 2){ // 짝수일 때는 거짓
		arr2.push(arr[i]);
	}
}
*/
arr.forEach(function(item){ // forEach를 쓰는 습관 갖기
	if(item % 2){
		arr2.push(item);
	}	
});
console.log(arr2);

// filter() : 조건에 만족한 요소만으로 새로운 배열 작성 - 홀수
var arr3 = arr.filter(function(item,index){
	return item%2; // 조건이 참인 경우에만 해당 item을 배열에 추가
});
console.log(arr3);

// 인덱스가 5이상인 요소만 arr4라는 이름의 배열에 추가
var arr4 = arr.filter(function(item, index) {
	return index >= 5
});
console.log(arr4);
console.log('------------------');

// map() : 배열의 각 요소에 대하여 순차적으로 주어진 함수를 실행한 반환 값으로 새로운 배열을 반환
var a = [1,2,3,4,5];
var a2 = [];
for(let i = 0; i<a.length; i++) {
	a2.push(a[i] * 2);
}
console.log( a2.join() ); // 2,4,6,8,10

var a3 = a.map(function(item){
	return item * 2;
});
console.log( a3.join() ); // 2,4,6,8,10

var a4 = a.map((item) => item * 2 );
console.log( a4.join() ); // 2,4,6,8,10

var a5 = a.map((item, index) => index%2==0 ? item : item * 2 );
console.log( a5.join() ); // 1 4 3 8 5


</script>

</head>
<body>

<h3>map, filter</h3>

</body>
</html>

Date 객체

- 날짜와 시간을 다루는 데 사용되는 객체로 new 연산자를 사용하여 객체 타입을 만든다.

- Date 객체는 1970년 1월 1일UTC(국제표준시) 00:00으로부터 지난 시간을 밀리초로 나타낸다.

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var now = new Date();

var y = now.getFullYear(); // 년도
var m = now.getMonth() + 1; // 월(getMonth() : 0~11)
var d = now.getDate(); // 일자
var w = now.getDay(); // 요일(0(일)~6(토))

var hr = now.getHours();
var mn = now.getMinutes();
var sc = now.getSeconds();

var ms = now.getTime(); // 1970-01-01 00:00:00 부터 경과 시간 (단위 : ms)

var s = y + '-' + m + '-' + d + '   ' + hr + ":" + mn + ":" + sc;

console.log(s, w);
console.log(ms);

</script>

</head>
<body>

<h3>내장객체 - Date</h3>

</body>
</html>

 

매개변수 생성자를 이용한 객체 생성 - 입력한 날로 객체생성

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var y, m, d, s;
var date;

// 2021-12-25 로 Date() 객체 생성
// date = new Date(); // 현재 컴퓨터시스템의 날짜로 객체 생성
date = new Date(2021, 12-1, 25);
y = date.getFullYear(); 
m = date.getMonth() + 1; 
d = date.getDate();
s = y + "-" + m + "-" + d;
console.log(s);

// 2021-09-31 로 Date() 객체 생성 - 9월 31일은 10월 1일로 설정
date = new Date(2021, 9-1, 31);
y = date.getFullYear(); 
m = date.getMonth() + 1; 
d = date.getDate();
s = y + "-" + m + "-" + d;
console.log(s);

// 날짜를 50일로 설정
date.setDate(50);
y = date.getFullYear(); 
m = date.getMonth() + 1; 
d = date.getDate();
s = y + "-" + m + "-" + d; // 2021-11-19
console.log(s);
</script>

</head>
<body>

<h3>내장객체 - Date</h3>

</body>
</html>

 

활용 시스템의 현재 시간 확인

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<link rel="stylesheet" href="style.css?v=1" type="text/css">

<script type="text/javascript">
function showClock() {
	var now = new Date();
	var y = now.getFullYear();
	var m = now.getMonth()+1;
	var d = now.getDate();
	if(m < 10) m = "0" + m;
	if(d < 10) d = "0" + d;
	
	var hr = now.getHours();
	var mn = now.getMinutes();
	var sc = now.getSeconds();
	if(hr < 10) hr = "0" + hr;
	if(mn < 10) mn = "0" + mn;
	if(sc < 10) sc = "0" + sc;
	
	var s = y + "-" + m + "-" + d + "  " + hr + ":" + mn + ":" + sc;
	document.getElementById("nowDate").value = s;
	
	setTimeout("showClock()", 1000);
}

window.onload = () => showClock();

</script>

</head>
<body>

<div style="margin: 30px auto; width: 200px; text-align: center;">
	<h3>시스템 현재 시간</h3>
	<input type="text" id="nowDate" readonly="readonly" style="border: none;">
</div>

</body>
</html>

 

 

활용 - 날짜 형식 검사 (정규식 활용)

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
// 날짜 형식 검사
function isValidDateFormat(date) {
	if(date.length !=8 && date.length != 10) return false;
	
	var p = /(\.)|(\-)|(\/)/g;
	date = date.replace(p, "");
	
	var format = /^[12][0-9]{7}$/;
	if(! format.test(date) ) return false;
	// test : 정규식에 올바르면 true, 올바르지않으면 false를 반환하는 함수 
	
	var y = parseInt( date.substr(0, 4) );
	var m = parseInt( date.substr(4, 2) );
	var d = parseInt( date.substr(6) );
	
	if(m<1 || m>12) return false;
	
	var lastDay = (new Date(y,m,0)).getDate();
	if(d<1 || d>lastDay) return false;
	
	return true;
}


function result() {
	var s = document.getElementById("inputs").value;
	
	if(! isValidDateFormat(s)){
		alert("날짜를 정확히 입력 하세요");
		document.getElementById("inputs").focus();
		return;
	}
	
	alert(s + " : 날짜 형식을 올바르게 입력 했습니다.");
}
</script>

</head>
<body>

<p>
	날짜 : <input type="text" id="inputs">
	<button type="button" onclick="result();">확인</button>
</p>


</body>
</html>

2021-02-30을 입력하면 뜨는 창

 

활용 - 달력 만들기 (1)

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<style type="text/css">
* {
	margin: 0; padding: 0;
	box-sizing: border-box;
}

body {
	font-size: 14px;
	font-family: '맑은 고딕', 나눔고딕, 돋움, sans-serif;
}

#calendarLayout {
	width: 280px;
	margin: 30px auto;
}

#calendarLayout .subject {
	height: 37px;
	line-height: 37px;
	text-align: center;
	font-weight: 600;
}

#calendarLayout table {
	width: 100%;
	border-collapse: collapse;
	border-spacing: 0;
}

#calendarLayout table td {
	padding: 10px;
	text-align: center;
	border: 1px solid #ccc;
}

#calendarLayout table td:nth-child(7n+1) {
	color: red;
}

#calendarLayout table td:nth-child(7n) {
	color: blue;
}

#calendarLayout table td.gray {
	background: #ccc;
}

#calendarLayout table td.today {
	background: #e6ffff;
}

.subject span {
	cursor: pointer;
}

.subject span:hover {
	color: tomato;
}

</style>

<script type="text/javascript">
function calendar(y, m) {
	var date = new Date(y, m-1, 1);
	y = date.getFullYear();
	m = date.getMonth()+1;
	
	var w = date.getDay(); // 요일:0~6
	var week = ["일","월","화","수","목","금","토"]; // 배열
	
	// 시스템 오늘 날짜
	var now = new Date();
	var ny = now.getFullYear();
	var nm = now.getMonth()+1;
	var nd = now.getDate();
	
	var out = "<div class='subject'>";
	out+= "<span onclick='calendar("+y+","+(m-1)+")'>&lt;</span>&nbsp;&nbsp;";
	out+= "<label>"+y+"년 "+m+"월 </label>";
	out+="&nbsp;&nbsp;<span onclick='calendar("+y+","+(m+1)+")'>&gt;</span>";
	out+="</div>";
	
	out+="<table>";
	out+="<tr>";
	for(var i=0; i<week.length;i++){
		out+="<td>"+week[i]+"</td>";
	}
	out+="</tr>";
	
	// 1일 앞부분
	out+="<tr>";
	for(var i =0; i<w;i++){
		out+="<td>&nbsp;</td>";
	}
	
	// 2021년 10월의 마지막 일자는 ? (new Date(2021, 10, 0)).getDate(); 11월 0일(10월 31일)
	var lastDay = (new Date(y, m, 0)).getDate();
	var cls;
	for(var i=1; i<=lastDay; i++) {
		cls = "";
		if(y=ny&&m==nm&&i==nd) cls =" today ";
		
		out +="<td class = '"+cls+"'>"+i+"</td>";
		if(i != lastDay && ++w%7==0) {
			out+="</tr><tr>";
		}
	}
	
	// 마지막 날짜 부분
	for(var i=w%7; i<6; i++) {
		out+="<td>&nbsp;</td>";
	}		
	out+="</tr>";		
	
	out+="</table>";
	
	document.getElementById("calendarLayout").innerHTML = out;
}

window.onload = function(){
	var now = new Date();
	var y = now.getFullYear();
	var m = now.getMonth()+1;
	calendar(y, m);
}


</script>

</head>
<body>

<div id="calendarLayout"></div>

</body>
</html>

 

활용 - 달력 만들기(2) 이전달과 다음달의 일자도 표시

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<style type="text/css">
* {
	margin: 0; padding: 0;
	box-sizing: border-box;
}

body {
	font-size: 14px;
	font-family: '맑은 고딕', 나눔고딕, 돋움, sans-serif;
}

#calendarLayout {
	width: 280px;
	margin: 30px auto;
}

#calendarLayout .subject {
	height: 37px;
	line-height: 37px;
	text-align: center;
	font-weight: 600;
}

#calendarLayout table {
	width: 100%;
	border-collapse: collapse;
	border-spacing: 0;
}

#calendarLayout table td {
	padding: 10px;
	text-align: center;
	border: 1px solid #ccc;
}

#calendarLayout table td:nth-child(7n+1) {
	color: red;
}

#calendarLayout table td:nth-child(7n) {
	color: blue;
}

#calendarLayout table td.gray {
	color: #ccc;
}

#calendarLayout table td.today {
	background: #e6ffff;
}

.subject>span, .footer>span {
	cursor: pointer;
}

.subject>span:hover, .footer>span:hover {
	color: tomato;
}

.footer {
	height: 25px; line-height: 25px;
	text-align: right;
	font-size: 12px;

	padding-right: 3px;
}

</style>

<script type="text/javascript">
function calendar(y, m) {
	var date = new Date(y, m-1, 1);
	y = date.getFullYear();
	m = date.getMonth()+1;
	
	var w = date.getDay(); // 요일:0~6
	var week = ["일","월","화","수","목","금","토"]; // 배열
	
	// 시스템 오늘 날짜
	var now = new Date();
	var ny = now.getFullYear();
	var nm = now.getMonth()+1;
	var nd = now.getDate();
	
	var out = "<div class='subject'>";
	out+= "<span onclick='calendar("+y+","+(m-1)+")'>&lt;</span>&nbsp;&nbsp;";
	out+= "<label>"+y+"년 "+m+"월 </label>";
	out+="&nbsp;&nbsp;<span onclick='calendar("+y+","+(m+1)+")'>&gt;</span>";
	out+="</div>";
	
	out+="<table>";
	out+="<tr>";
	for(var i=0; i<week.length;i++){
		out+="<td>"+week[i]+"</td>";
	}
	out+="</tr>";
	
	// 1일 앞부분 : 이전달
	var preDate = new Date(y, m-1, 0); // 이전달의 마지막 날짜로 Date 객체 생성
	// var preYear = preDate.getFullYear();
	// var preMonth = preDate.getMonth()+1;
	
	var preLastDay = preDate.getDate();
	var preDay = preLastDay - w + 1;
	
	out+="<tr>";
	for(var i =0; i<w;i++){
		out+="<td class='gray'>"+(preDay+i)+"</td>"; // ++preday도 가능
	}
	
	// 2021년 10월의 마지막 일자는 ? (new Date(2021, 10, 0)).getDate(); 11월 0일(10월 31일)
	var lastDay = (new Date(y, m, 0)).getDate();
	var cls;
	for(var i=1; i<=lastDay; i++) {
		cls = "";
		if(y=ny&&m==nm&&i==nd) cls =" today ";
		
		out +="<td class = '"+cls+"'>"+i+"</td>";
		if(i != lastDay && ++w%7==0) {
			out+="</tr><tr>";
		}
	}
	
	// 마지막 날짜 부분
	var nextDay = 0;
	for(var i=w%7; i<6; i++) {
		out+="<td class='gray'>"+ (++nextDay) +"</td>";
	}		
	out+="</tr>";		
	
	out+="</table>";
	
	out+="<div class='footer'><span onclick='calendar("+ny+","+nm+")'>오늘날짜로</span></div>";
	
	document.getElementById("calendarLayout").innerHTML = out;
}

window.onload = function(){
	var now = new Date();
	var y = now.getFullYear();
	var m = now.getMonth()+1;
	calendar(y, m);
}


</script>

</head>
<body>

<div id="calendarLayout"></div>

</body>
</html>

String 객체

- 문자열을 처리하기 위한 프로퍼티 및 메소드를 제공한다.

- 일반적인 문자열(string primitives)과 String 오브젝트는 다르게 취급된다.

- 일반적인 문자열과 String 오브젝트는 eval()을 사용할 때 다른 결과를 제공한다.

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var s1 = "java"; // 문자 리터널
var s2 = new String("java"); // 객체

console.log(typeof s1); // "String"
console.log(typeof s2); // "object"

console.log(s1 === "java"); // true
console.log(s2 === "java"); // false

console.log(s1 == s2); // true
console.log(s1 === s2); // false

console.log(s2.valueOf()); // "java"
console.log(s2.valueOf() === "java"); // true

s1 = "2+2";
s2 = new String("2+2");
console.log( eval(s1) ); // 4
console.log( eval(s2) ); // ▶String {'2+2'}
console.log( eval(s2.valueOf() ) ); // 4

</script>
</head>
<body>

<h3>내장객체 - String</h3>

</body>
</html>

 

주요 속성 및 메소드

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var s1, s2;

s1 = "seoul korea";
s2 = s1.length; // 문자열의 길이
console.log(s2); // 11

s2 = s1.charAt(6); // 문자열에서 index위치의 문자 반환. index는 0부터 시작
console.log(s2); // 'k'

s2 = s1.substring(6, 9); // s 인덱스에서 e-1인덱스까지의 문자열
console.log(s2); // 'kor'

s2 = s1.substring(6); // s 인덱스에서 끝까지의 문자열
console.log(s2); // 'korea'

s2 = s1.substr(6, 3); // s 인덱스에서 3개만 추출
console.log(s2); // 'kor'

s2 = s1.substr(6) // s 인덱스에서 끝까지의 문자열
console.log(s2); // 'korea'

s2 = s1.indexOf("o"); // 문자열의 인덱스 반환. 없으면 -1을 반환.
console.log(s2); // 2

s2 = s1.lastIndexOf("o"); // 문자열을 뒤에서 부터 찾아 인덱스 반환. 없으면 -1을 반환.
console.log(s2); // 7

s2 = s1.indexOf("java"); // 없으면 -1을 반환.
console.log(s2); // -1

s2 = s1.toUpperCase(); // 모든 영문자를 대문자로
console.log(s2);

s2 = s2.toLowerCase(); // 모든 영문자를 소문자로
console.log(s2);

console.log( s1 ==="seoul" ); // false
console.log( s1.startsWith("seoul") ); // true
console.log( s1.startsWith("korea") ); // false
console.log( s1.startsWith("korea", 6) ); // true
console.log( s1.endsWith("korea") ); // true

s1 = "      자      바       ";
s2 = ":" + s1 + ":";
console.log(s2);

s2 = ":" + s1.trim() + ":"; // 왼쪽과 오른쪽의 공백 제거
console.log(s2);

s1 = "javascript,HTML,CSS";
s2 = s1.split(","); // 문자열을 구분자로 분류한 부분 문자열을 담은 배열을 반환
for (var n = 0; n < s2.length; n++) {
	console.log(s2[n]);
}

s1 = "대한 우리대한 한국 대한";
s2 = s1.replace(/대한/g, '大韓'); // [/대한/g 정규식]을 大韓으로 치환
console.log(s2);

</script>
</head>
<body>

<h3>내장객체 - String</h3>

</body>
</html>

 

예외처리 ?

- Javascript에는 코드 실행 중에 예기치 못한 에러가 발생했을 때, 이로부터 코드의 실행 흐름을 복구할 수 있는 기능이 내장되어 있다. 이런 기능을 일러 예외처리(exception handling)라고 한다.

 

예외처리의 장점

- 예외 발생시 비정상적인 프로그램 종료를 막고 프로그램 실행 상태를 유지할 수 있다.

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
/*
	console.log(x); // ReferenceError: x is not defined
	console.log('윗줄에서 에러가 발생하면 실행되지 않는다.'); // 실행되지 않는다.
*/

/*
	// 예외처리
	try {
		console.log(x);
		console.log('윗줄에서 에러가 발생하면 실행되지 않는다.');
	} catch (e) {
		console.log("예외 발생 : " + e);
	}
	console.log("실행된다.");
*/

/*
	try {
		console.log(x);
		console.log('윗줄에서 에러가 발생하면 실행되지 않는다.');
	} catch (e) {
		console.log("예외 발생 : " + e);
	} finally {
		console.log("예외 발생 여부와 상관 없이 실행...");
	}
	console.log("실행된다.");
*/

	var n = 5;
	var s = 0;
	try {
		if( n < 10 ) {
			throw "10이상만 가능합니다.";
		}
		for(var a = 1; a <= n; a++) {
			s += a;
		}
		console.log("결과:"+s);
		
	} catch (e) {
		console.log(e);
	}

</script>
</head>
<body>

<h3>예외처리</h3>

</body>
</html>

 

화살표 함수 표현(Arrow function expression)

- 화살표 함수 표현은 function표현에 비해 구문이 짧다.

- 자신의 this, arguments, super 또는 new.target을 바인딩 하지 않으며, 화살표 함수는 항상 익명이다.

- ES 2015 스펙에 추가

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
var sub1 = function(args) {
	return args.length;
}
console.log( sub1("seoul") ); // 문자열길이 : 5

// 화살표 함수(arrow function) -> 자바의 람다식과 유사
var sub2 = (args) => { return args.length; };
console.log( sub2("seoul") ); // 5

// 파라미터가 하나만 있을 경우 주변 괄호를 생략 할 수 있다.
var sub3 = args => { return args.length; };
console.log( sub3("seoul") ); // 5

// 화살표 함수의 유일한 문장이 'return' 일 때 'return'과 중괄호({})를 생략할 수 있다.
var sub4 = args => args.length;
console.log( sub4("seoul") ); // 5

/*
window.onload = function() {
	alert("방가...");
};
*/
// window.onload = () => alert("방가...");

/*
setTimeout(function() {
	alert('안녕하세요!');
}, 1000);
*/

/*
setTimeout(() {
	alert('안녕하세요!');
}, 1000);
*/

setTimeout (()=> alert('안녕하세요!'), 1000);



</script>

</head>
<body>

<h3>함수 - arrow function</h3>

</body>
</html>

 

 

함수만들기

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// ---------------------------
// 함수 선언문 방식으로 함수 만들기
function sub1(x, y) {
	var s = x + y;
	return s;
}

// 함수 호출
var result;
result = sub1(10, 5);
console.log(result);

//---------------------------
// 함수 표현식 방법으로 함수 만들기
var sub2 = function(x, y) { // 익명 함수
	return x * y;
}

var multiply = sub2;
result = sub2(10, 5);
console.log(result);

result = multiply(3, 5);
console.log(result);

//---------------------------
// 기명 함수 표현식 방법으로 함수 만들기
var sub3 = function add(x, y) {
	return x + y;
};

console.log(sub3(15, 5));
// console.log(add(15, 5)); // Error -> add is not defined
		// 함수 표현식에서 사용한 함수 이름은 외부 코드에서 접근 불가

// 기명 함수 표현식을 이용한 재귀호출
var sub4 = function sum(n) {
	return n > 1 ? n+ sum(n-1) : n;
}

console.log(sub4(10)); // 55

//---------------------------
// Function() 생성자를 이용한 함수 만들기
var sub5 = new Function('x', 'y', 'return x+y;');
console.log( sub5(7,8) ); //15

//---------------------------
// 즉시 실행 함수 - 정의함과 동시에 함수를 바로 실행
var a = (function(a, b) {
	return a+b;
})(5, 7);
console.log(a);

(function(a, b){
	var c = a + b;
	console.log(c);
})(3, 5);

</script>
</head>
<body>

<h3> 함수</h3>

</body>
</html>

 

함수 표현식에서의 함수 호이스팅은 불가

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// --------------------------------
// 함수 선언문에서의 함수 호이스팅(선언전 호출)
console.log( sub1(5, 10) );

function sub1(a, b) {
	return a+b;
}

//--------------------------------
// 함수 표현식에서의 함수 호이스팅은 불가능하다.
// console.log( sub2(3, 5) ); // 에러 - Uncaught TypeError: sub2 is not a function

var sub2 = function (a, b) {
	return a+b;
}
console.log( sub2(3, 5) );

// 페이지 실행시 호출하는 콜백 함수
window.onload = function() {
	alert("반가워요...");
};
</script>
</head>
<body>

<h3>함수</h3>

</body>
</html>

 

함수의 매개변수

- 매개변수는 함수를 호출한 곳에서 함수에 값을 전달 할 때 사용한다.

- 매개 변수를 선언할 때 var 키워드는 사용하지 않는다.

- 자바 스크립트 함수를 정의할 때 매개 변수의 데이터 유형을 지정하지 않으며, 전달된 인수에 대하여 유형 검사를 하지 않는다.

- 자바 스크립트는 넘겨 받은 매개 변수의 수를 확인하지 않는다.

- 함수에서 값 전달 방식은 passing by value방식이다. 즉, 함수가 인수의 값을 변경해도 매개 변수의 원래 값은 변경되지 않는다. 

- 자바 스크립트는 디폴트 매개변수와 Rest 매개 변수 등을 지원한다.

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">

<script type="text/javascript">
function sub1(a, b) {
	console.log(a, b);
}
sub1(); // undefined undefined
sub1(1); // 1 undefined
sub1(1, 2); // 1 2
sub1(1, 2, 3); // 1 2
console.log("-----------------");

function sub2() {
	for(var i = 0; i < sub2.arguments.length; i++) {
		console.log(sub2.arguments[i]);
	}
}

sub2("홍길동", "자바", 100);

console.log("-----------------");
function sub3(name) {
	console.log("name:" + name);
	for(var i = 1; i < sub3.arguments.length; i++) {
		console.log(sub3.arguments[i]);
	}
}
sub3("김자바", "스프링", 95);

</script>

</head>
<body>

<h3>함수 - 매개변수</h3>

</body>
</html>

arguments 객체

- arguments 객체는 함수를 호출할 때 전달된 인자 값을 나타내며, 첫 번째 인자는 arguments[0]으로 나타낸다.

- arguments.length는 함수에 실제로 넘겨받은 인수의 개수를 반환한다.

- arguments는 배열과 유사하게 인덱스로 접근할 수 있지만 배열은 아니며, 배열을 다루는 메소드가 없다.

 

디폴트 매개 변수(default parameters)

- 자바스크립트에서 함수의 매개변수는 undefined가 기본으로 설정된다.

- 자바스크립트에서 함수의 매개변수에 디폴트 매개 변수 값을 설정 할 수 있다.

- ES 2015 스펙에 추가

 

Rest 매개 변수

- Rest 파라미터 구문은 정해지지 않은 수의 인수를 배열로 나타낼 수 있다.

- 함수의 마지막 파라미터의 앞에 ...를 붙여 모든 나머지 인수를 "표준"자바스크립트 배열로 대체한다.

- 마지막 파라미터만 "Rest 파라미터"가 될 수 있다.

- argumnets 객체는 실제 배열이 아니지만, Rest 파라미터는 Array 인스턴스로, sort, map, forEach 또는 pop 같은 메소드가 바로 인스턴스에 적용될 수 있다.

- ES 2015 스펙에 추가

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// 디폴트 매개 변수

function add1(a, b) {
	return a + b;
}
console.log( add1(10) ); // 10 + undefined => NaN

function add2(a, b) {
	b = typeof b !== 'undefined' ? b : 0;
	return a + b;
}
console.log( add2(10) ); // 10

// 디폴트 매개 변수(ES 2015)
function add3(a, b = 0) {
	return a + b;
}
console.log( add3(10) ); 

function sub(x = 1, y) {
	console.log(x, y);
}
sub(); // 1 undefined

// Rest 매개 변수(부정 인수) 마지막 파라미터만 Rest 매개변수가 가능
// Rest 매개 변수는 배열로 나타낼 수 있다.
function add4(...args) {
	var s = 0;
	for(var n = 0; n < args.length; n++) {
		s += args[n];
	}
	return s;
}
console.log( add4(1,2,3,4,5)); // 15

</script>


</head>
<body>

<h3>함수 - 매개변수</h3>


</body>
</html>

 

클로저(Closures)

- 함수 내부에 함수를 작성할 때마다 클로저를 생성한다. 즉, 함수 내부에 작성된 함수가 바로 클로저이다.

- 내부함수는 외부함수 안에서 정의된 모든 변수와 함수를 접근 할 수 있다.

- 내부함수는 외부함수의 명령문에서만 접근할 수 있다.

- 외부함수는 내부함수 안에서 정의된 변수와 함수들에 접근 할 수 없다. 이는 내부함수의 변수에 대한 일종의 캡슐화를 제공한다.

- 내부함수는 외부함수의 지역변수에 접근 할 수 있는데 외부함수의 실행이 끝나서 외부함수가 소멸된 이후에도 내부함수가 외부함수의 변수에 접근 할 수 있다. 이러한 메커니즘을 클로저 라고 한다. 

 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
function fun(x) { // 외부함수
	var n = 10;
	
	// 내부함수(closure)
	function sub(y) {
		return n+x+y; // 외부 함수의 변수나 인수 접근 가능
	}
	
	return sub(3); // 외부 함수에서 내부 함수 접근 
}

console.log( fun(2)); // 15

// ------------------------
function fun2(x) {
	function sub2(y) {
		return x + y;
	}
	
	return sub2;
}

var f = fun2(2); // 함수 객체를 반환
var n = f(3);
console.log(n); // 5

n = fun2(10)(5);
console.log(n); // 15

</script>
</head>
<body>

<h3>함수 - closures : 함수 내부에 작성된 함수</h3>

</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var seq = function() {
	var n = 0;
	return function() {
		return ++n;
	}
}

var fn = seq();
console.log( fn() ); // 1
console.log( fn() ); // 2
console.log( fn() ); // 3

</script>
</head>
<body>

<h3>함수 - closures : 함수 내부에 작성된 함수</h3>

</body>
</html>

 

DOM(Document Object Model)을 포함한 브라우저의 창을 나타내는 객체는 window 객체이며, document 속성은 브라우저 창에 로드된 DOM 문서를 나타낸다.

window 객체는 브라우저 기반 자바스크립트의 최상위 객체이다.

window 객체는 전역 객체(Global Object)라고도 불리며, 전역 객체는 그 객체의 프로퍼티나 메소드를 사용할 때 그 이름을 명시할 필요가 없다.

window 객체에는 타이머, 자바스크립트 경고 창 및 입력 대화상자를 위한 메소드가 정의되어 있다.


타이머 함수 - 특정한 시간에 특정한 함수를 실행하는 함수로 window 객체에 정의되어 있다.

setTimeout(function, millisecond) - 일정 시간 후 함수를 한 번 실행

setInterval(function, millisecond) - 일정 시간마다 함수를 반복 실행

clearTimeout(id) - 일정 시간 후 함수를 한 번 실행하는 것을 중지

clearInterval(id) - 일정 시간마다 함수를 반복하는 것을 중단

 

타이머함수예제

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">document.write("<h3>타이머 함수 예제</h3>");

function sub() {
	document.write("<p>자바 스크립트</p>");
}

setTimeout("alert('환영합니다. !!!')", 3000); // 3초 후에 한번 실행

setInterval("sub();", 2000); // 2초에 한번씩 무한 반복</script>
</head>
<body>


</body>
</html>

실행하면 3초후에 alert이 나타난다.

2초마다 자바스크립트를 화면에 출력하는 것을 무한 반복한다.

 

타이머 종료

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
var n = 0;

function sub() {
	n++;
	document.write("<p>숫자 : " + n + "</p>");
}

var timer = setInterval("sub();", 1000); // 1초에 한번씩 무한반 복

setTimeout(function() {
	clearInterval(timer); // 타이머 종료 // 익명 함수 1회성
}, 10000); // 10초 후 한번 실행 


</script>
</head>
<body>

<h3>타이머 - 타이머 종료</h3>

</body>
</html>

1초에 한번씩 숫자가 화면에 출력되고 

10초 후에 타이머가 종료된다.

 

+ Recent posts