클래스(class)

- class는 객체를 생성하기 위한 템플릿이다.

- 클래스는 데이터와 이를 조작하는 코드를 하나로 추상화한다.

- ES 2015(ECMAScript 6) 이전까지는 비슷한 종류의 객체를 만들어내기 위해 생성자를 사용했다.

- ES 2015(ECMAScript 6) 에서 도입된 클래스는 생성자의 기능을 대체한다. class 표현식을 사용하면, 생성자와 같은 기능을 하는 함수를 훨씬 더 깔끔한 문법으로 정의할 수 있다.

 

개요

- class는 "특별한 함수"이다.

- 함수를 함수 표현식과 함수 선언으로 정의할 수 있듯이, class도 class 표현식과 class 선언 두 가지 방법을 이용하여 정의할 수 있다.

- 클래스는 함수로 호출될 수 없다.

- 클래스 선언은 let과 const처럼 블록 스코프에 선언한다.

- 클래스의 메소드 안에서 super 키워드를 사용할 수 있다.

- 함수 선언과 클래스 선언의 중요한 차이점은 함수 선언의 경우 호이스팅이 일어나지만, 클래스 선언은 호이스팅이 일어나지 않는다.

 

※ 클래스는 함수, 객체가 아니다.

class Person {
	console.log('hello');
}

위 결과는 에러 : Unexpected token

 

class Person {
	prop1:1,
	prop2:2
}

위 결과는 에러 : Unexpected token

 

클래스 몸체

- 클래스 body는 중괄호 {}로 묶여 있는 안쪽 부분으로 메소드나 constructor와 같은 class 멤버를 정의한다.

- 클래스의 본문(body)은 strict mode에서 실행된다. 즉, 여기에 적힌 코드는 성능 향상을 위해 더 엄격한 문법이 적용된다.

 

Constructor(생성자)

- constructor 메소드는 class로 생성된 객체를 생성하고 초기화하기 위한 특수한 메소드이다.

- "constructor"라는 이름을 가진 특수한 메소드는 클래스 안에 한 개만 존재할 수 있다. 클래스에 여러 개의 constructor메소드가 존재하면 SyntaxError가 발생한다.

- constructor는 부모 클래스의 constructor를 호출하기 위해 super 키워드를 사용할 수 있다.

 

클래스 정의 : class 표현식

- class 표현식은 class를 정의하는 또 다른 방법이다.

- class 표현식은 이름을 가질 수도 있고, 갖지 않을 수도 있다.

- 이름을 가진 class표현식의 이름은 클래스 body의 loval scope에 한해 유효하다. 

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// 클래스
class User {
	// 생성자 : 생성자는 클래스안에서 constructor 라는 이름으로 정의한다.
	constructor({name, age}) {
		this.name = name;
		this.age = age;
	}
	
	// 메소드를 만드는 문법 그대로 사용하면 메소드가 자동으로 User.prototype 에 저장된다.
	msg() {
		return '안녕하세요. 제 이름은 ' + this.name + '입니다.';
	}
}

const obj = new User({name:'호호호', age:20});
console.log( obj.msg() );

console.log( typeof User) // function
console.log( typeof User.prototype.constructor ); // function
console.log( typeof User.prototype.msg ); // function
console.log( obj instanceof User ); // true

</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">
class User {
	add(x, y) {
		return x+y; // 프로퍼티가 없으므로 this를 쓰면 안된다.
	}
	
	subtract(x, y) {
		return x-y;
	}
}

const obj = new User();
console.log( obj.add(10, 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">
const methodName = 'sayName';

class User {
	constructor(name, age) {
		this.name = name;
		this.age = age;
	}
	
	// 임의의 표현식을 []로 둘러쌓아 메소드 이름으로 사용	
	[methodName]() {
		return `안녕 나는 ${this.name}이야. `; // 템플릿 리터널
	}	
}

const obj = new User('나나나', 10);
console.log( obj.sayName() );
</script>

</head>
<body>

<h3>클래스</h3>

</body>
</html>

 

클래스의 getter 혹은 setter를 정의하고 싶을 때는 메소드 이름 앞에 get 또는 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">
class User {
	constructor() {
		this._name = "";
	}
	get name() {
		return this._name;
	}
	
	set name(newName) {
		this._name = newName;
	}
}

const obj = new User();
obj.name = '홍길동'; // 속성처럼 부름. 메소드를 프로퍼티처럼 사용
console.log( obj.name );


</script>

</head>
<body>

<h3>클래스 - getter, setter</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">
class Rect {
	constructor(height, width) {
		this.height = height;
		this.width = width;
	}
	
	// getter
	get area() {
		return this.calc();
	}
	
	// 메소드
	calc() {
		return this.height * this.width;
	}
}

var obj = new Rect(10, 5);
console.log( obj.area );
console.log( obj.calc() ); // 괄호가 있어야지 해당 메소드를 호출 



</script>

</head>
<body>

<h3>클래스</h3>

</body>
</html>

 

 

ex19 클래스 예제

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
/*
class Rect {
	// 생성자
	constructor(h, w) {
		this.height = h;
		this.width = w;
	}
}

var obj = new Rect(10, 5);
console.log(obj.height, obj.width);
*/

class Rect {
	// 메소드
	area(h, w) {
		this.height = h;
		this.width = w;
		return this.height * this.width; // 생성자뿐만 아니라 메소드에서도 속성 추가 가능
	}
}

var obj = new Rect();
var a = obj.area(5, 7);
console.log(a);
console.log(obj.height, obj.width);
console.log(obj);

</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">
class Car {
	constructor(name) {
		this.name = name;
	}
	
	speed() {
		console.log(`${this.name}은 시속 80 입니다.`);
	}
	
	color() {
		console.log(this.name +'은 검정색입니다.')
	}
}

class Taxi extends Car {
	constructor(name) {
		super(name); // 상위 클래스의 생성자 호출
	}
	
	speed() { // 자바에서 override
		super.speed(); // 상위 클래스의 메소드 호출
		console.log(this.name+'은 시속 100 입니다.')
	}
}

var obj = new Taxi('그랜저');
console.log(obj.name);
obj.speed();
obj.color();

</script>
</head>
<body>

<h3>클래스 - 상속</h3>

</body>
</html>

 

프로토타입(prototype) 객체란 ?

- 자바스크립트의 모든 객체는 자신의 부모 역할을 담당하는 객체와 연결되어 있으며, 객체 지향의 상속 개념과 같이 부모 객체의 프로퍼티 또는 메소드를 상속받아 사용할 수 있게 한다. 이러한 부모 객체를 프로토타입 객체 또는 프로토타입이라 한다.

- 프로토타입 객체는 생성자 함수에 의해 생성된 각각의 객체에 공유 프로퍼티를 제공하기 위해 사용한다.

 · 프로토타입은 어떤 객체의 상위(부모) 객체의 역할을 하는 객체로서 다른 객체에 공유 프로퍼티(메소드 포함)를 제공한다.

 · 프로토타입을 상속받은 하위(자식) 객체는 상위 객체의 프로퍼티를 자신의 프로퍼티처럼 자유롭게 사용할 수 있다.

- 자바스크립트는 프로토타입을 기반으로 상속을 구현하여 불필요한 중복을 제거한다.

 

_proto_ 접근자 프로퍼티

- 자바스크립트의 모든 객체는 은닉(private) 속성의 [ [Prototype] ] 이라는 내부 슬롯(internal slot)을 가진다.

- 객체가 생성될 때 객체 생성 방식에 따라 프로토타입이 결정되고 [ [Prototype] ]에 저장된다. 

- [ [Prototype] ]은 자신의 프로토타입이 되는 상위 객체를 가리킨다.

- [ [Prototype] ]은 _proto_속성이 참조하는 숨은 링크로 모든 객체는_proto_ 접근자 프로퍼티를 통해 자신의 프로토타입, 즉 [ [Prototype] ] 내부 슬롯에 간접적(직접 접근 불가)으로 접근할 수 있다.

- 접근자 프로퍼티(accessor property) : 자체적으로는 값을 갖지 않고 다른 데이터 프로퍼티의 값을 읽거나 저장할 때 사용하는 접근자 함수, 즉 [[Get] ], [ [Set] ]프로퍼티 어트리뷰트로 구성된 프로퍼티이다.

- Object.prototype의 접근자 프로퍼티인 _proto_는 getter/setter 함수라고 부르는 접근자 함수를 통해 프로토타입을 취득하거나 할당한다.

- _proto_ 접근자 프로퍼티는 상속을 통해 사용된다. (_proto_ 프로퍼티는 자신의 부모 객체(프로토타입 객체)이다.

- _proto_ 접근자 프로퍼티를 코드 내에서 직접 사용하는 것은 권장하지 않는다. 

 

프로토 타입

더보기
<!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:'홍길동',
	score:90
};

console.log(obj.valueOf()); // obj 에는 valueOf가 없지만 동작함. valueOf()는 상위 객체에서 물려 받음
console.dir(obj);

console.log(obj.__proto__ === Object.prototype);
// __proto__ : 객체의 부모를 나타내는 프로토타입으로 부모에게 물려 받은 정보를 가지고 있음
// prototype : 자신의 프로토 타입 객체로 하위로 물려줄 프로토 타입 정보를 가지고 있음

// --------------------------------
function User(name) {
	this.name = name;
}

var u = new User('이자바'); // 객체를 생성

console.dir(User);
console.dir(u);

</script>

</head>
<body>

<h3>프로토 타입</h3>

</body>
</html>

 

 

객체에 프로퍼티나 메소드 추가. prototype 이용

더보기
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
<link rel="icon" href="data:;base64,iVBORw0KGgo=">
<script type="text/javascript">
// prototype 프로퍼티 : 생성자에 존재. 생성자로 생성되는 객체에 물려줄 프로퍼티와 메소드를 가지고 있음.

function User(name, age) {
	this.name = name;
	this.age = age
}

User.prototype.score = 80;
User.prototype.state = function() {
	return this.age>=19 ? '성인':'미성년자';
};

var obj = new User('자바', 20);
console.log(obj.name, obj.score, obj.state() ); // 자바 80 성인

var obj2 = new User('스프링', 17);
console.log(obj2.name, obj2.score, obj2.state() ); // 스프링 80 미성년자

// Date 내장객체에 weekday 라는 메소드를 추가하여 요일 출력
Date.prototype.weekday = function() {
	let week = ['일', '월', '화', '수', '목', '금', '토'];
	return week[this.getDay()];
}

var now = new Date();
console.log( now.weekday() ); // 시스템 요일

</script>
</head>
<body>

<h3>객체에 프로퍼티나 메소드 추가. prototype 이용</h3>

</body>
</html>

 

객체(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>

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>

 

+ Recent posts