객체(Object)란 ?

- 객체는 JavaScript 언어만이 가지고 있는 특징을 기초로 이루는 자료형으로, 데이터를 저장하고 있는 프로퍼티(property) 및 프로퍼티에 저장된 데이터에 조작을 가할 수 있는 method의 집합으로 구성된다.

- 객체는 '이름(key) : 값(value)' 형태의 프로퍼티들을 저장하는 컨테이너이다. 기본 타입은 하나의 값만을 가지지만 참조 타입인 객체는 여러 개의 프로퍼ㅣ들을 포함할 수 있으며, 이러한 객체의 프로퍼티들은 기본 타입의 값을 포함하거나 다른 객체를 가리킬 수 있다. 

- null 과 undefined 를 제외한 모든 원시 타입도 객체로 취급된다. 이러한 원시 타입들에도 프로퍼티가 추가될 수 있고, 모두 객체로서의 특징을 갖는다. (숫자, 문자열, 배열, 함수, 정규 표현식 등)

- 객체를 사용할 때는 속성 (property) 이름을 이용해서 속성 값을 읽거나 쓸 수 있다.

- 자바스크립트에선, 실행 시점에 특정 객체에 속성을 추가하거나 제거할 수 있다.

 

프로토타입(prototype) 기반 언어

- 자바스크립트는 클래스 기반이 아닌 프로토타입(prototype)을 기반으로 하는 객체 기반 언어이다.

- 프로토타입 기반 언어는 프로토타입 객체라는 개념이 있으며, 새로운 객체의 초기 속성을 가져오는 템플릿(template)으로 사용되는 객체이다. 객체 원형인 프로토타입을 이용하여 새로운 객체를 만들며, 생성된 객체는 또 다른 객체의 원혀이 될 수 있다.

- 프로토타입 언어는 클래스 없이(Class-less)객체를 생성할 수 있다. ECMAScript 6에서 클래스가 추가 되었다.

- 모든 객체는 객체를 만들거나 런타임에 고유한 속성을 지정할 수 있다.

- 모든 객체를 다른 객체의 프로토타입으로 연결하여 두 번째 객체가 첫 번째 객체의 속성을 공유할 수 있다.

- 프로토 타입 객체를 참조하는 prototype 속성과 객체 멤버인 _proto_ 속성이 참조하는 숨은 링크가 있다.

_proto_ : 상위에서 물려 받은 객체의 프로토타입에 대한 정보(prototype link)

prototype : 자신의 프로토타입 객체로, 하위로 물려줄 프로토 타입의 정보(prototype object)

 

특징

- 모든 객체는 다른 객체로부터 상속을 받는다.

- 생성자 함수를 이용하여 객체 세트를 정의하고 생성할 수 있다.

- class와 마찬가지로 new 연산자로 하나의 객체(인스턴스)를 생성할 수 있다. 

- 하나의 객체를 생성자 함수와 결합된 프로토타입에 할당함으로써 객체의 계층구조를 생성한다.

- 프로토타입 체인에 따라 속성을 상속받는다.

- 생성자 함수 혹은 포로토타입은 초기 속성들을 명시한다. 개별 객체 혹은 전체 객체 세트에 동적으로 속성을 추가, 삭제할 수 있다.

 

 

객체생성 - 객체 리터널을 이용한 객체 생성

더보기

객체 리터널(이니셜라이저)를 이용한 객체 생성

<!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 obj = {name:'홍길동', age:20}; // 프로퍼티이름:값, 프로퍼티명은 문자열만 가능
// var obj = {'name':'홍길동', 'age':20}; // 가능

console.log( typeof obj ); // "object"
console.log( obj );
console.dir( obj );

// 객체 속성 값 확인
console.log( obj.name ); // 홍길동

// 객체 속성 값 변경
obj.name = '김자바';
console.log( obj.name ); // 김자바

var s;
s = obj.age >= 19 ? obj.name +"님은 성인 입니다." : obj.name+"님은 성인이 아닙니다.";
console.log( s );

obj.Age = 22; // 대소문자가 다르면 에러가 나오지 않고 새로운 속성이 추가된다.
console.log( obj.age ); // 20

console.dir( obj );

// 객체 리터널(이니셜라이저)를 이용한 객체 생성 - 2
var obj2 = { }; // 빈 객체
console.log( typeof obj2 ); // object

// 실행시 동적으로 속성 추가
obj2.subject = "자바";
console.log( obj2 );
console.log( obj2.subject );

// 객체 리터널(이니셜라이저)를 이용한 객체 생성 - 3
var obj3 = {
	name : '홍길동',
	age : 20,
	state : function() {
		return this.age >= 19 ? '성인' : '미성년자'; // this 생략불가
	},
	msg : function() {
		var s = `${this.name}님은 ${this.state()} 입니다.`; // 템플릿 리터널
		console.log(s);
	}
};

console.log( obj3 );
obj3.msg();

</script>

</head>
<body>

<h3>객체 만들기</h3>

</body>
</html>

 

객체 이니셜라이저(object initializer) 를 이용한 객체 생성

- 객체 이니셜라이저를 이용하여 객체를 생성할 수 있으며, 리터럴 표기에 의한 객체(literal notation, 객체 리터널) 생성이라고도 한다.

- 객체 이니셜라이저는 여러 가지 프로퍼티를 가진 객체를 쉽게 정의할 수 있도록 디자인된 표기법이다.

- 중괄호 { } 를 이용해서 객체를 생성하며, 중괄호 { } 안에 아무것도 적지 않은 경우는 빈 객체가 된다.

- 중괄호 { } 안에 '프로퍼티 이름:프로퍼티 값' 형태로 표기하면, 해당 프로퍼티가 추가된 객체를 생성할 수 있다.

- 객체의 프로퍼티들이 객체의 특징을 규정한다. 

 

 

생성자 함수를 이용한 객체 생성

더보기
<!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 User(name, age) {
	this.name = name;
	this.age = age;
	
	this.state = function() {
		return this.age >= 19 ? "성인":"미성년자";
	}
	
	this.msg = function() {
		var s = this.name + "님은 " +this.state()+"입니다.";
		console.log(s);
	}
}
// 생성자 함수를 이용한 객체 생성
var obj = new User('홍길동', 20);
console.log(obj.name);
obj.msg();

// Object.create()메소드를 이용한 객체 생성
var Book = {
	subject:'자바',
	msg: function() {
		return '좋아하는 과목은 '+this.subject+'입니다.';
	}
};

var b1 = Object.create(Book);
var b2 = Object.create(Book);
b1.subject = 'HTML';
b2.subject = 'CSS';

console.log(Book.msg());
console.log(b1.msg());
console.log(b2.msg());


</script>
</head>
<body>

<h3>객체 생성</h3>

</body>
</html>

생성자 함수를 이용한 객체 생성 특징

- 객체 타입을 정의하는 생성자 함수명의 첫 글자는 일반적으로 대문자로 시작한다.

- 생성자에 매개변수가 없으면 생성자를 호출할 때 전달인자 목록과 괄호를 생략할 수 있다.  var o = new Object;

- 생성자를 호출하면 생성자의 프로토타입 속성을 상속받은 새로운 빈 객체가 생성된다.  생성자 함수는 객체를 초기화하고 새로 생성된 이 객체는 호출 컨텍스트로 사용된다.

- 생성자는 새로 생성된 객체를 this 키워드로 참조할 수 있다.

- 생성자 함수는 보통 return 키워드를 사용하지 않는다. 일반적으로 생성자 함수는 새 객체를 초기화하고 생성자 함수 몸체의 끝에 이르면 암시적으로 그 객체를 반환한다. 

- 만약 생성자가 return 문을 사용하여 명시적으로 어떤 객체를 반환하면, 반환된 객체가 생성자 호출 표현식의 값이 되며, 생성자가 반환 값 없이 return 구문만을 사용하거나 원시 형식 값을 반환하면, 그 반환 값은 무시되고 새로 생성된 객체가 호출 표현식 값으로 사용된다. 

 

this 키워드

- 자바스크립트에서 함수를 호출할 때 기존 매개변수로 전달되는 인자 값에 더해 arguments 객체 및 this 인자가 함수 내부로 암시적으로 전달된다. 

- 현재 객체를 참조할 때 this키워드 사용하며, 일반적으로 this는 메소드에서 호출하는 객체를 참조한다.

- 객체의 프로퍼티는 점(.)이나 괄호([])로 접근할 수 있다.

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

<script type="text/javascript">
// 객체의 메소드를 호출할 때 메소드 내부 코드에서 사용한 this : 해당 메소드를 호출한 객체
var obj = { // 객체 생성. 일회성. 주로 속성값 보존을 위해 사용
		name : '김자바',
		msg : function() {
			console.dir(this);
			console.log(this.name); // this는 msg() 메소드를 호출한 객체
		}
};

obj.msg();

// 생성자 함수를 호출할 때의 this : 새로 생성되는 객체
function Test(arg) {
	this.name = arg;
	this.getName = function() {
		return this.name;
	};
}

var obj2 = new Test('자바');
console.log( obj2.getName() );

// 함수를 호출할 때의 this
var userName = '스프링'; // 전역 변수. 전역변수는 자동으로 window의 속성이 된다.
// console.log(userName); // 스프링
console.log(window.userName); // 스프링

// sayUser()를 호출할 때 this는 전역 객체(window)에 바인딩
var sayUser = function() {
	console.log( this.userName, userName, window.userName );
}
sayUser();

</script>


</head>
<body>

<h3>객체- this</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">
// 객체의 메소드를 호출할 때 메소드 내부 코드에서 사용한 this : 해당 메소드를 호출한 객체
var obj = { // 객체 생성. 일회성. 주로 속성값 보존을 위해 사용
		name : '김자바',
		msg : function() {
			console.dir(this);
			console.log(this.name); // this는 msg() 메소드를 호출한 객체
		}
};

obj.msg();

// 생성자 함수를 호출할 때의 this : 새로 생성되는 객체
function Test(arg) {
	this.name = arg;
	this.getName = function() {
		return this.name;
	};
}

var obj2 = new Test('자바');
console.log( obj2.getName() );

// 함수를 호출할 때의 this
var userName = '스프링'; // 전역 변수. 전역변수는 자동으로 window의 속성이 된다.
// console.log(userName); // 스프링
console.log(window.userName); // 스프링

// sayUser()를 호출할 때 this는 전역 객체(window)에 바인딩
var sayUser = function() {
	console.log( this.userName, userName, window.userName );
}
sayUser();

</script>


</head>
<body>

<h3>객체- this</h3>

</body>
</html>

 

 

 

- this 바인딩

 · 객체의 메소드를 호출할 때 this : 해당 메소드를 호출한 객체

 · 함수를 호출할 때 this : 전역 객체

 · 생성자 함수를 호출할 때 this : 새로 생성되는 객체

 

 

form 요소의 이벤트 핸들러에서의 this : 이벤트를 발생시킨 객체

더보기
<!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 send() { // document 는 body라고 생각하면 됨
	var f = document.myForm;
	var name = f.name.value;
	var kor = f.kor.value;
	var eng = f.eng.value;
	var mat = f.mat.value;
	
	alert(name + ":" + kor + ":" + eng + ":" + mat);
}

function validate(obj) {
/*	
	if(! /^(\d){1,3}$/.test(obj.value) ) {
		obj.focus;
		return;
	}
*/
	if(isNaN(obj.value) || parseInt(obj.value) < 0 || parseInt(obj.value) > 100) {
		alert("점수는 0~100 사이만 가능합니다.");
		obj.focus();
		return;
	}
}

</script>

</head>
<body>

<h3>form 요소의 이벤트 핸들러에서의 this : 이벤트를 발생시킨 객체 자기 자신</h3>
<form name="myForm">
	<p> 이름 : <input type="text" name="name"></p>
	<p> 국어 : <input type="text" name="kor" onchange="validate(this);"></p>
	<p> 영어 : <input type="text" name="eng" onchange="validate(this);"></p>
	<p> 수학 : <input type="text" name="mat" onchange="validate(this);"></p>
	<p>
		<button type="button" onclick="send()">확인</button>
	</p>
</form>

</body>
</html>

 

form 요소의 안에서의 this.form : 현재 객체의 부모 form을 나타냄

더보기
<!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 send(f) { // f는 document.myForm 을 말함
	var name = f.name.value;
	var kor = f.kor.value;
	var eng = f.eng.value;
	var mat = f.mat.value;
	
	alert(name + ":" + kor + ":" + eng + ":" + mat);
}


</script>

</head>
<body>

<h3>form 요소의 안에서의 this.form : 현재 객체의 부모 form을 나타냄</h3>
<form name="myForm">
	<p> 이름 : <input type="text" name="name"></p>
	<p> 국어 : <input type="text" name="kor"></p>
	<p> 영어 : <input type="text" name="eng"></p>
	<p> 수학 : <input type="text" name="mat"></p>
	<p>
		<button type="button" onclick="send(this.form)">확인</button>
	</p>
</form>

</body>
</html>

 

객체 프로퍼티

- 객체의 프로퍼티는 객체의 특징을 규정한다.

- 프로퍼티 이름은 유효한 자바스크립트 문자열이거나 문자열로 변환이 가능한 어떤 것 또는 빈 문자열도 가능하다.

- 자바스크립트 식별자(identifier)로 적합하지 않으면(하이픈, 빈칸을 포함, 숫자로 시작하는 이름 등), 대괄호를 이용한 표기법으로만 접근이 가능하다.

- 프로퍼티에 접근해서 객체의 기존 프로퍼티 값을 갱신할 수 있다.

- 객체가 생성된 후에도 동적으로 프로퍼티를 생성해서 해당 객체에 추가가 가능하다.

- 상속 받지 않은 객체의 프로퍼티는 delete 연산자를 이용해 삭제하며, 삭제된 속성은 undefined로 설정한다.

delete objectName.propertyName;

- 객체 프로퍼티 접근은 도트 표기법, 대괄호 표기법이 있다.

ec) objectName.propertyName, objectName["propertyName"]

 

객체 - 프로퍼티 동적 추가

더보기
<!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 obj = {
	name:'자바',
	city:'서울'
};

console.log(obj.name);
console.log(obj.city);
console.log(obj.age); // 없는 속성은 undefined. 에러가 아님

// 동적 속성 추가
obj.age = 10;
console.log(obj.age);

// 속성 제거
delete obj.city;
console.log(obj.city);

</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 obj = {
	name:'이자바',
	age:20,
	msg: function() {
		return this.age>=19? '성인':'미성년자';
	}
};

// 객체 속성 접근
console.log(obj.name); // 도트 표기법 접근
console.log(obj['name']); // 대괄호 표기법으로 접근

// 메소드 접근
console.log(obj.msg());

// 객체의 프로퍼티 나열
for(var ob in obj) { // ob : 프로퍼티이름
	console.log(ob, obj[ob]);
}

console.log('name' in obj); // true. 객체에 속성이 존재하는지 확인
console.log('subject' in obj); // false

// console.log(obj.name);
// 간단한 표현
with(obj) {
	console.log(name);
	console.log(age);
}

</script>
</head>
<body>

<h3>객체 - 프로퍼티 접근 및 나열</h3>

</body>
</html>

 

정적 메소드(static method)

- 생성자의 속성에 직접 지정된 메소드를 정적 메소드(static method)라고 한다.

- Number.isNaN, Object.getPropertyOf 등의 함수들은 모두 정적 메소드이다.

- 정적 메소드는 특정 인스턴스에 대한 작업이 아닌, 해당 생성자와 관련된 일반적인 작업을 정의할 때 사용된다. 

 

생성자 함수에 추가하는 프로퍼티나 메소드

더보기
<!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 User(name) {
	this.name = name;
	this.age = 20; // 기본값을 가질 수 있음
	this.state = function() {
		return this.age >= 19 ? '성인':'미성년자';
	};
}

console.dir(User);

var obj = new User('홍길동');
console.log(obj.name, obj.state() );

</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">
// 정적 메소드 : 생성자에 직접 지정된 메소드
function User(name) {
	this.name=name;
	this.getName = function() {
		return this.name;
	};
}

// 클래스 안에 정적 메소드 추가
// 정적 메소드
User.state = function(age) {
	return age>=19? '성인':'미성년자'; 
	// this가 있을 수 없음. 객체 생성과 상관 없음. this는 정적메소드와 상관없음
};

console.log(User.state(30));
// console.log(User.getName()); // 에러. 정적 메소드가 아님. 객체를 생성해서 호출해야함

var obj = new User('하하하'); // 메모리할당
console.log(obj.getName());

</script>


</head>
<body>

<h3>정적 메소드</h3>

</body>
</html>

 

JSON 객체

- JSON 객체는 JavaScript Object Notation(JSON)을 분석하거나 값을 JSON으로 변환하는 정적 메소드를 가지고 있다.

- JSON을 직접 호출하거나 인스턴스를 생성할 수 없다.

 

정적 메소드

- JSON.parse()

- JSON 문자열의 구문을 분석하고, 그 결과에서 JavaScript 값이나 객체를 생성한다.

(JSON 문자열을 JSON 객체로 변환 한다.)

 

- JSON.stringify()

- JavaScript 값이나 객체를 JSON 문자열로 변환( JSON 객체를 JSON 문자열로 변환한다.)

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// JSON 문자열을 자바스크립트 객체로 변환
var s = '{"name":"홍길동","subject":"자바","score":95}'; // JSON 문자열
// 어떤 브라우저는 JSON property 를 홑따옴표로 하면 못 읽는 곳이 있음. 
// 따라서 위처럼 홑따옴표를 먼저 쓰고 프로퍼티는 쌍따옴표를 쓸 것!
var obj = JSON.parse(s); // JSON 문자열을 분석하여 자바스크립트 객체 생성
console.log(obj.name, obj.subject, obj.score );
// 숫자, true, false는 쌍따옴표로 안감싸도 됨
// 자바스크립트 객체를 JSON 문자열로 변환
var obj2 = {
	name:'김자바', 
	age:20, 
	subject:'HTML'
};

var s2 = JSON.stringify(obj2); // 자바스크립트 객체를 JSON 문자열로 변환
console.log(s2);

</script>

</head>
<body>

<h3>JSON</h3>

</body>
</html>

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>

 

 

+ Recent posts