#junecnol

“ROSE of all Roses, Rose of all the World! The tall thought-woven sails, that flap unfurled Above the tide of hours, trouble the air, And God’s bell buoyed to be the water’s care; While hushed from fear, or loud with hope, a band With blown, spray-dabbled hair gather at hand. Turn if you may from battles never done, I call, as they go by me one by one, Danger no refuge holds, and war no peace, For him who hears love sing and never cease, Beside her clean-swept hearth, her quiet shade: But gather all for whom no love hath made A woven silence, or but came to cast A song into the air, and singing past To smile on the pale dawn; and gather you Who have sought more than is in rain or dew Or in the sun and moon, or on the earth, Or sighs amid the wandering starry mirth, Or comes in laughter from the sea’s sad lips; And wage God’s battles in the long grey ships. The sad, the lonely, the insatiable, To these Old Night shall all her mystery tell; God’s bell has claimed them by the little cry Of their sad hearts, that may not live nor die.

Rose of all Roses, Rose of all the World! You, too, have come where the dim tides are hurled Upon the wharves of sorrow, and heard ring The bell that calls us on; the sweet far thing. Beauty grown sad with its eternity Made you of us, and of the dim grey sea. Our long ships loose thought-woven sails and wait, For God has bid them share an equal fate; And when at last defeated in His wars, They have gone down under the same white stars, We shall no longer hear the little cry Of our sad hearts, that may not live nor die.

http://nefariousdesigns.co.uk/object-oriented-javascript.html 에서 참조

Object-Oriented Javascript

Posted Wednesday 24th May, 2006

Update October 2010: I’m currently following up this article with some notes about development method, and then again with a more in-depth look at current practices for object-oriented JavaScript. Hopefully, this should serve to correct some of my errors in this older article. Once you’ve finished reading this article, please read the following:

Object-Oriented JavaScript Follow-Up Part 1: Method

Object-Oriented JavaScript Follow-Up Part 2: Technical

Following on from my earlier post, ”Object-Oriented Concepts,” it’s time we started to have a look at some examples of execution. I’m going to start with Javascript because I believe this to have widest appeal - PHP, as a server-side language, is probably of interest to fewer developers so I’ll cover it later.

So without further ado, here’s how to objectify your javascript…

Objects in Javascript

Although Javascript shouldn’t be classed as an object-oriented language, pretty much everything within it is object based; from DOM scripting (Document Object Model) through to specific built-in objects such as Image and Date. This basically means that we can adopt some OOP concepts but not all.

Javascript handles objects in a number of ways; a developer can define an object and then instantiate with the new operator, a developer can declare an object on the fly using the object literal or a developer can extend an existing object (either built-in or user-defined) using its prototype.

In fact, even data-types that can be declared literally, such as arrays and strings, can also be declared as objects. This is mainly so that object methods can be applied to literal values when needed. Javascript does this by temporarily converting your literal into an object. A good example would be the String.lengthmethod.

Sounding complicated? Don’t worry, it’s really very easy. Let’s start getting our hands dirty…

The Object Literal

In programmer-speak, a “literal” is any value declared literally. Good examples would be string literals, array literals and boolean literals - the literal is the part after the “=” assignment operator:

// String literal var my_string = "2468 This is a string"; // Array literal var my_array = ['element1', 'element2', 'elephant']; // Boolean literal var my_boolean = true;

As a developer, you probably use these methods day-in, day-out; it still amazes me, however, how many programmers I speak to that don’t know the correct terminology!

In Javascript, we can also declare objects as a literal:

function getArea(radius) { // return the radius of our circle using the // PI attribute of the built-in Math object return (radius * radius) * Math.PI; } var circle = { radius : 9, getArea : getArea(this.radius) };

Here we’ve defined an object, circle, with a radius of 9. If we wanted to obtain the area of our circle, we could use the following line of code:

var my_radius = circle.getArea();

Fantastic! We’ve got ourselves a circle; but what happens when we want to declare more circles, all with varying radii?

Imagine we want to create lots of circle objects using our object as a base - if we’ve declared using the object literal, we’re not able to do that! To a certain extent, that’s the difference between objects and classes(see my earlier post); if we want our object to behave more like a class (which, unfortunately, aren’t really supported in Javascript even though we can mimic the behaviour), we need to use objects that utilise the new operator.

Note: For more information on the object literal, I recommend reading Chris Heilmann’s ”Show Love to The Object Literal,” and Dustin Diaz’s ”JSON for the Masses.”

The new Operator

The new operator creates an instance of any built-in or user-defined object - basically allowing us to re-use a user-defined obect (much like the behaviour of a class). Here are a couple of examples using built-inobjects:

// Create a date object var obj_today = new Date(); // Preload an image using the Image object var obj_supper = new Image(); obj_supper.src = 'thelastsupper.jpg';

Take note that Javascript’s built-in objects do not always use a proper class interface - ie. you can set attributes without using a method. In most OOP languages this is considered bad practice and you can often prevent it with the use of access modifiers (public, private, protected). Even though Javascript lets us get away with this method, when using its built-in objects, I personally tend to write a proper interface for my own objects.

Ok, so that’s how you declare using the built-in objects, but what about something user-defined?

When using the new keyword to declare user-defined objects, the objects require a constructor. Object structure (including an object’s constructor) is handled somewhat differently to most languages in Javascript. Here’s the syntax for defining this type of object:

function circle(radius) { this.radius = radius; this.getArea = getArea; // Don't forget that a constructor should // always retain a valid state - so it should // always return true return true; } function getArea() { // return the radius of our circle using the // PI attribute of the built-in Math object return (this.radius * this.radius) * Math.PI; }

In the example above, you’ll notice that the syntax is almost completely identical to declaring a function. This function is the constructor of our object and attributes and methods are declared within it, using the this keyword.

Notice the Math object doesn’t need to be instantiated before we can use it - this is simply because it’s special and is always available for use.

We can now instantiate our object using the new operator as before:

var obj_pizza = new circle(9);

And we can work out the area of our circle using the following line of code:

var flt_area = obj_pizza.getArea();

Encapsulation

There is one problem with the above definitions of an object, however, and that’s the lack of encapsulation. If we were to include another piece of code that used a getArea() function (for instance a triangle object), our circle object’s getArea() method would be over-written. To better encapsulate our methods, we can define our objects either literally like so:

var circle = { radius : 9, getArea : function() { return (this.radius * this.radius) * Math.PI; } };

Or non-literally like so:

function circle(radius) { this.radius = radius; this.getArea = function() { return (this.radius * this.radius) * Math.PI; }; return true; }

In both cases this limits the scope of each getArea() method to each circle object.

Inheritance and prototype

The prototype property is a useful feature in Javascript - it basically allows us to add attributes or methods to an object. This is a form of inheritance.

As a quick example of prototype in use, let’s add a function to work out circumference:

function circle(radius) { this.radius = radius; this.getArea = function() { return (this.radius * this.radius) * Math.PI; }; return true; } // Add our new method circle.prototype.getCircumference = function() { return this.radius * Math.PI * 2; } // Instantiate our object var my_pizza = new circle(9); // Call our new method var flt_pizza_circ = my_pizza.getCircumference();

“But wait, ” I hear you cry, “what if we want to inherit an entire object?”

Not a problem, prototype can handle this like so:

// Declare two objects - we're going to want Lion to // inherit from cat function cat() { this.eyes = 2; this.legs = 4; this.diet = 'carnivore'; return true; } function lion() { this.mane = true; this.origin = 'Africa'; return true; } // Now comes the inheritance lion.prototype = new cat(); // We can now obtain lion.diet var simba = new lion(); var simba_diet = simba.diet;

Ok, so now that we understand inheritance (you do understand, right?), let’s take a look composition.

Composition

Association

Association, in Javascript, is pretty straight forward. Here’s an example:

// Define an object function brick() { return true; } // Define an object function wall() { this.brick1 = new brick(); this.brick2 = new brick(); this.brick3 = new brick(); return true; }

Just like the pseudo-code example in my earlier post, we can see that the object “wall” now contains three instances of the “brick” object. This is association - the wall object “has” three bricks.

Now let’s take a look at aggregation.

Aggregation

Aggregation, as a relationship, is reliant on the ability to pass object and function parameters by reference. This basically means that a parameter represents a pointer to the actual object passed and not just a copy. Thankfully, Javascript handles all parameters in this way - which makes our aggregation relationship nice and easy:

function person { return true; } function car(driver) { this.driver = driver; return true; } var me = new person(); var myMotor = new car(me);

This relationship allows us to “use” the “me” object within our “myMotor” object. We could also use the “me” object in any other objects that require it - and we’d only need that single instantiation. This is immensely helpful when we’re using objects that control behaviours such as XmlHttpRequest.

Update: Thanks to Jonathan Snook, I’ve recently discovered that Javascript doesn’t pass all parameters by reference - in fact working out how Javascript has handled your parameter can be quite confusing. In our particular case, the parameter is passed by reference because it is an object. When we’re not working with objects, this might not be the case. For more detailed information, please take a look at Jonathan’s excellent article, ”Javascript: Passing by Value or by Reference.”

Update 2: Stefan Van Reeth’s fantastic comment, below, looks at references in a little more detail. I definitely recommend reading it as his explanation and examples may clear up confusion.

Polymorphism

Due to its object-based nature, Javascript handles polymorphism very well. Take a look at the following example:

function Person() { //... this.Speak = function() { // ... } } function Employee() { // ... this.Speak = function() { // ... } } AND (!!!) Employee.prototype = new Person(); // inheritance user emp = new Employee(); emp.Speak();

Employee inherits from Person and, as a result, already has a Speak() method. Because we want the Speak() method in Employee to do something different, we overload it with a new method definition. This is polymorphism in action.

Update: My original example for Polymorphism was entirely incorrect. Thanks go to “Joe is all you need to know” for pointing out my error and supplying this correct example.

Summary

So that’s a brief guide to adopting OOP practices in Javascript; I think you’ll agree that it adds real power when dealing with complicated scripts. However, that raises a common issue with OOP - you shouldn’t just use it for the sake of it. In fact, I often find that developers who are using these practices for everything are often the same developers who don’t understand the concepts fully.

http://www.clearboth.org/45_objects_in_javascript/ 에서 참조

소개

이전 글 에서 함수의 컨셉에 대해 소개했다. 함수를 사용함으로서 프로그램들을 논리적인 덩어리들로 쪼개서 당신의 코드를 좀더 잘 조직화하고, 쉽게 재사용할 수 있었다. 이제 당신이 자바스크립트 프로그래밍의 핵심적인 개념들을 거부감 없이 받아들일 수 있게 되었으므로, 객체 에 대해 소개함으로서 활용의 폭을 더욱 넓혀보고자 한다. 객체를 사용함으로서 함수로 정의한 기능성들을 하나로 묶을 수 있고, 또한 그것을 이곳저곳으로 전달하며 또한 참조할 수 있다. 이러한 능력은 당신이 앞으로 작성할 코드에 상당히 실질적인 의미를 갖게 될 것이다 – 비록 지금 이 순간에는 다소 모호하게 들리겠지만 말이다.

눈치채지 못했을수도 있지만, 당신은 이 시리즈를 따라 오면서 암묵적으로 객체들을 사용해 왔다. 이제 이것에 대해 좀 더 명시적인 설명을 함으로서 자바스크립트에서 객체가 어떻게 동작하는지, 그리고 객체를 통해 당신의 프로그램을 좀 더 명확하게 하고 재사용하기 쉽도록 하는 방법을 알려주겠다.

이 글의 구조는 다음과 같다:

왜 객체를 사용하는가?

익숙한 영역

객체 생성하기

자가 참조

연관 배열로서의 객체

객체 리터럴

요약 – 배울것이 더 많이 있다

읽어볼것들

연습문제

다운로드하거나 직접 실행해볼 수 있는 예제가 준비되어 있다. 이것은 삼각형의 면적을 계산하는 코드를 포함하고 있는데, 객체를 사용한 것과 사용하지 않은 것이 있다. 이 코드는 아래에서 설명하는 예제들로 만들어져 있다. 삼각형 객체 예제를 실행해보라.

왜 객체를 사용하는가?

객체에 대해 주의를 기울이는 단 하나 가장 중요한 이유는, 객체를 사용함으로서 당신의 코드에서 데이터와 처리과정을 더 잘 표현할 수 있기 때문이다. 익숙한 예제로서, 당신이 삼각형에 관한 뭔가를 코딩한다고 가정하자. 삼각형은 3개의 변 을 가지고 있다는 것을 알고 있으므로, 특정한 삼각형에 대해 다루려면 당연히 3개의 변수를 만들어야 할 것이다:

// This is a triangle.

var sideA = 3;

var sideB = 4;

var sideC = 5;

자, 삼각형이 준비되었다. 하지만 아직 명확하지는 않다. 따로따로 추적해야 할 세개의 변수를 이제 만들었고, 당신이 이것을 가지고 무엇을 어떻게 하려고 했었나를 떠올리게 해 줄 주석이 있다. 이것은 그다지 명확하거나, 사용할만하다고 할 수는 없다. 어쨌든, 계속해보자. 이 “삼각형”에 대해 어떤 계산을 할 수 있을까? 면적을 알기 위해서, 다음과 같은 함수를 사용할 수 있을 것이다:

function getArea( a, b, c ) {

// Heron의 공식을 이용해서 삼각형의 면적을 계산한다.

var semiperimeter = (a + b + c) / 2;

var calculation = semiperimeter * (semiperimeter - a) * (semiperimeter - b) * (semiperimeter - c);

return Math.sqrt( calculation );

}

alert( getArea( sideA, sideB, sideC ) );

뭔가 계산을 하기 위해서는 삼각형에 대한 모든 정보를 전달해주어야 한다는 것을 깨달았을 것이다. 삼각형과 관련된 활동(계산)은 삼각형의 데이터로부터 완전히 분리되어 있는데, 이러한 고립에는 그다지 의미가 있어 보이지 않는다.

좀 더 보자. 나는 이 함수와 변수들에 대해 상당히 범용적인 이름을 정해주었다: getArea, sideA 와 같이 말이다. 다음주에, 직사각형에 대해서 동작하도록 프로그램을 확장해야 함을 깨달았다면 어떻게 할 것인가? 아마도, 사각형에 사용하기 위해 sideA 와 sideB 같은 변수를 사용하려고 하겠지만, 이러한 변수는 이미 사용되었다. side1 과 side2 를 사용할수도 있겠지만, 이런 변수를 사용함으로서 혼동과 재난을 초래할 것이 분명함을, 당신도 이미 짐작할 것이라고 생각한다. 아마도, rectangleSideA, rectangleSideB 같은 변수들을 시도해 보다가 모순 속에 빠져들게 될 것 같다. 삼각형에 대해 이미 만들어 둔 코드를 다시 수정해서 triangleSideA 같은 것을 쓰게끔 하다가, 필경 에러를 만들어 낼 것이다. 이러한 수작업과 오류는 물론 함수의 이름에도 계속된다 – 두개의 다각형에 대해서, 그 계산이 개념적으로는 같은 것이기 때문에, 똑같이 getArea 라는 이름을 사용하고 싶지만, 그렇게 할 수 없다. 데이터를 표현할 수 있는 더 좋은 방법이 있을것이다.

몇개의 명령어들을 묶어서 단일한, 적당한 이름을 가진 활동(함수)을 만들어 내는 것이 이치에 맞는다. 마찬가지로, 몇가지 “것” 들을 하나의 단위로 묶어서 객체를 만들어내는 것이 이치에 맞는다. 자바스크립트에서 미리 정의된 기초적 데이터 타입(문자열, 상수, 불린 등)에 제한받는 대신, 객체를 만들어 사용함으로서 당신만의 데이터 타입 연결을 만들어 낼 수 있다. 객체에 사용되는 변수들은 숫자나 타입의 제한을 받지 않는다. 이렇게, 형식에 얽매이지 않는 유연함은, 프로그램을 작성할 때 당신이 다루려고 하는 것을 직접적으로 다루는 구조를 만들어낼 수 있게 하며, 또한 그것들을 자바스크립트에 내장된 기초적인것들과 마찬가지로 사용할 수 있게 해준다. 이제 삼각형과 직사각형 객체를 만들 것인데, 각각의 객체는 그 모양을 다루기 위해 필요한 모든 데이터들을 포함할 것이며, 또한 그 데이터들을 가지고 수행하려고 하는 모든 행동들도 함께 포함할 것이다. 이러한 목적을 염두에 두고, 문법을 보도록 하자.

익숙한 영역

이전 글의 마지막 실습을 보면, 다음과 같은 코드가 포함되어 있다:

var obj = document.getElementById( elementID );

그리고:

obj.style.background = 'rgb('+red+','+green+','+blue')';

자, 객체가 무엇인지 몰랐지만 이미 객체를 사용하고 있었다. 이 두개의 조각을 좀 더 자세히 분석해서 자바스크립트의 객체 문법에 대해 살펴보도록 하자.

var obj = document.getElementById( elementID ) 이 코드는 익숙해 보인다. 명령어 마지막에 포함되어 있는 괄호는 뭔가가 실행될 것이라는 의미이고, 이 실행의 결과가 obj 라는 변수에 저장될 것이라고 짐작할 수 있다. 여기에서 새로운 것은 딱 하나, 중간에 있는 점 이다. 이러한 점 표기법은 자바스크립트가 객체 안에 저장된 데이터에 접근하기 위해 사용하는 방법이다. 점 은 + 나 – 와 마찬가지로, 피연산자 사이에 있는 연산자이다.

관습적으로, 객체 안에 저장되고 점 연산자를 통해 접근하는 데이터를 property 라고 부른다. 프로퍼티는 함수가 될 수 있는데, 이 경우 method 라 부른다. 이러한 단어에 특별한 의미는 없다 – 메서드는 함수일 뿐이고, 프로퍼티는 변수일 뿐이다.

점 연산자의 왼쪽에는 객체가, 오른쪽에는 프로퍼티가 놓인다. 위의 코드에 이러한 규칙을 적용해 본다면, 자바스크립트에 내장되어 있는 document 객체의 getElementById 메서드에 접근한다고 말할 수 있을 것이다. 이것에 관해 더 자세한 내용은 이어질 DOM 여행 글에서 확인할 수 있다.

다음 코드는 조금 더 흥미롭다: 이것은 점을 두개 가지고 있다. 자바스크립트의 객체 지원 중에서 정말로 흥미로운 것 중 하나는, 점 연산자 체인을 통해 복잡한 구조 속으로 들어간다는 것이다. 짧게 말해서, 이러한 체인은 마치 var x = 2 + 3 + 4 + 5; 를 계산하고 값으로 14를 기대하는 것과 같다. 객체 참조는 자신을 반환하고, 이러한 체인이 왼쪽에서 오른쪽으로 계속 이어진다(친구들에게 이것을 설명하면서 자바스크립트가 점 연산자를 “좌측 연결 삽입 연산자” 로 사용한다고 표현해서 깊은 인상을 줄 수 있을 것이다) 이 경우, obj.style 이 먼저 평가되고, 이것을 해석하면 그것의 background 프로퍼티에 접근하는 객체가 된다. 당신이 원한다면, 괄호를 사용해서 이것을 좀 더 명시적으로 표현할 수 있다: (obj.style).background.

객체 생성

삼각형 객체를 만들기 위해, 다음의 문법을 사용해서 명시적으로 생성할 것이다:

var triangle = new Object();

triangle 는 이제 비어있는 기초이며 무언가를 그 위에 쌓아올려야 한다. 점 연산자를 통해 프로퍼티들을 추가함으로서 그렇게 할 수 있다:

triangle.sideA = 3;

triangle.sideB = 4;

triangle.sideC = 5;

객체에 새로운 프로퍼티를 생성하기 위해서 다른 특별한 일을 할 필요는 없다. 자바스크립트가 점 연산자를 평가할 때, 이것은 대단히 관대한 방법을 사용한다. 존재하지 않는 프로퍼티에 접근하려고 시도한다면, 자바스크립트는 그것을 새로 만들어낸다. 존재하지 않는 프로퍼티를 읽으려 한다면 자바스크립트는 “undefined” 값을 반환한다. 이것은 편리하지만, 주의깊게 사용하지 않는다면 에러를 만들어 낸다. 따라서 오타에 주의하도록 하자.

메서드를 추가하는 것 역시 비슷하다 – 예제를 보자:

triangle.getArea = function ( a, b, c ) {

// Return the area of a triangle using Heron's formula

var semiperimeter = (a + b + c) / 2;

var calculation = semiperimeter * (semiperimeter - a) *

(semiperimeter - b) * (semiperimeter - c);

return Math.sqrt( calculation );

}; // 이 줄에 사용된 세미콜론을 눈여겨 보기 바란다. 이것은 규칙의 일부이다.

이것이 함수 선언과 무척 비슷하다고 생각한다면, 제대로 보고 있는 것이다. 그저 함수 이름이 빠졌을 뿐이다. 자바스크립트는 익명 함수라는 개념을 갖고 있는데, 함수는 이름을 가지는 대신 다른 값들과 마찬가지로 변수에 저장된다. 이 코드에서, 나는 익명 함수를 만들어내고 그것을 triangle 객체의 getArea 프로퍼티에 저장했다. 이제 객체는 데이터와 함께 함수를 데리고 다닌다.

자가 참조

삼각형 객체를 만들어 낸 목적 중 하나는, 삼각형의 데이터와, 그 데이터를 가지고 할 계산 사이의 관계를 만들어 내는 일이었는데, 아직 그것을 완성하지 못했다. triangle.getArea 메서드가 여전히 각 변의 길이를 필요로 하고 있음을 알 수 있을 것이다. 따라서 이런 식으로 명령해야 하는데:

triangle.getArea( triangle.sideA, triangle.sideB, triangle.sideC );

이것이 처음에 했던 코드보다는 나은데, 왜냐하면 이것은 데이터와 계산 사이의 관계를 명확하게 표현하고 있기 때문이다. 하지만, 그 관계는, 메서드에게 어떤 값을 가지고 계산할지를 매번 알려줄 필요가 없는 것이어야 한다. 메서드는 자신을 포함하고 있는 객체 안에서 데이터를 수집할 수 있어야 하고, 사용자에게 값을 입력할 것을 요구하지 않고 그 데이터를 사용해야 한다.

메서드가 자신을 포함한 객체 안에서 데이터를 수집할 수 있게 하는 비결은 this 키워드 안에 있다. 메서드를 정의할 때 이 키워드를 사용함으로서, 메서드가 실행될 때 같은 객체 내의 다른 프로퍼티나 메서드를 참조하도록 지정할 수 있다. this 를 사용하도록 getArea 를 다시 수정하면 다음과 같다:

triangle.getArea = function () {

// Return the area of a triangle using Heron's formula

var semiperimeter = (this.sideA + this.sideB + this.sideC) / 2;

var calculation = semiperimeter * (semiperimeter - this.sideA) * (semiperimeter - this.sideB) * (semiperimeter - this.sideC);

return Math.sqrt( calculation );

}; // Note the semi-colon here, it's mandatory.

여기서 보는 바와 같이, this 키워드는 거울과 비슷하게 동작한다. getArea 메서드가 실행될 때, 메서드는 객체 내부에서 sideA, sideB, sideC 프로퍼티를 검색하게 된다. 객체 내부에 프로퍼티가 이미 정의되어 있으므로, 외부에서 입력하는 값에 의존하지 않고 계산을 할 수 있다.

이것은 조금 과하게 단순화시킨 표현이다. this 키워드가 언제나 메서드를 포함하는 객체를 참조하는 것은 아니다 – 사실 이 키워드는 자신을 호출하는 문맥에 기반해서 동작한다. 모호함에 대해 사과드린다. 하지만, 이것을 다루는 것은 이 글의 초점을 벗어나는 일이 될 것이다. 아무튼, 이 글에서는, this 키워드는 항상 triangle 객체를 참조할 것이다.

연관된 배열로서의 객체

객체의 프로퍼티와 메서드에 접근하는 방법에는 점 연산자만이 있는것은 아니다. 이미 다루었던 글, 배열에 대하여를 통해서 충분히 익숙해져 있을, 대괄호 표기법script notation을 사용해서 더 효율적으로 접근할 수 있다. 짧게 말해, 당신은 객체를 연관된 – 일반적인 배열이, 값에 숫자를 할당하는 것과는 대조적으로 값에 문자열을 할당하는 – 배열이라고 생각해도 무방하다는 것이다. 이러한 표기법을 사용해서, triangle 객체를 다른 방법으로 작성할 수 있다:

var triangle = new Object();

triangle['sideA'] = 3;

triangle['sideB'] = 4;

triangle['sideC'] = 5;

triangle['getArea'] = function ( a, b, c ) {

// Return the area of a triangle using Heron's formula

var semiperimeter = (a + b + c) / 2;

var calculation = semiperimeter * (semiperimeter - a) * (semiperimeter - b) * (semiperimeter - c);

return Math.sqrt( calculation );

}; // Note the semi-colon here, it's mandatory.

언뜻 보기에는, 이것은 불필요하게 길게 쓴 것으로 보일 수 있다. 왜 간단한 점 연산자를 사용하지 않는가? 이러한 새로운 문법의 장점은, 프로퍼티의 이름이 프로그램 안에서 완전하게 정의될 필요가 없다는 것이다. 프로퍼티의 이름을 명시하기 위해 변수를 사용할 수 있고, 이러한 것을 허용함으로서 프로그램은 참으로 유연해질 수 있다 – 문맥에 기초해서 다양한 동작을 수행할 수 있다는 뜻이다. 예를 들어, 두개의 객체가 하나의 프로퍼티를 공유하는지 비교해 볼 수 있는 함수를 작성할 수 있다:

function isPropertyShared( objectA, objectB, propertyName ) {

if (

typeof objectA[ propertyName ] !== undefined

&&

typeof objectB[ propertyName ] !== undefined

) {

alert("Both objects have a property named " + propertyName + "!");

}

}

이러한 함수는, 점 표기법을 사용해서는 절대 만들어 낼 수 없는데, 점 연산자 뒤에는 프로퍼티의 이름을 명시적으로 적어주어야만 하기 때문이다. 당신은 이 문법을 아주 많이 사용하게 될 것이다.

참고 : 연관된 배열은 Perl 언어에서는 해쉬 라고 부르며, C# 에서는 해쉬테이블, C++ 에서는 맵, 자바 에서는 해쉬맵, Python 언어에서는 딕셔너리, 이렇게 다양하게 표현된다. 이것은 아주 강력하면서도 기초적인 프로그래밍 기법이고, 이것의 다른 이름을 이미 알고 있었을 수도 있다.

객체 리터럴

아주 친숙한 코드를 좀 더 자세히 들여다보도록 하자:

alert(“Hello world”);

alert는 함수이고, “Hello world” 라는 문자열을 인수로 가지고 호출되고 있다는 것을 알 수 있다. 여기에서 강조하고자 하는 것은, 이렇게 쓸 필요가 없다는 것인데:

var temporaryString = "Hello world";

alert(temporaryString);

자바스크립트는, 따옴표(” ”)로 둘러싸인 모든 것은 문자열로 취급되어야 한다고 이해하며, 그것이 어디에 쓰였든 간에 올바르게 처리할 수 있는 필요한 모든 일을 백그라운드로 처리한다. 문자열이 만들어지고, 그것이 함수의 인수로 전달되는 과정이 한번에 이루어졌다. 정형적으로는, “Hello world” 이것은 문자열 리터럴 을 참조한다: 문자열을 생성하기 위해 필요한 모든 것을 완전하게 입력한 것이다.

자바스크립트는, “객체 리터럴” 에 대해서도 비슷한 문법을 가지고 있으며 이것을 통해 문법적인 제약에 지나치게 구애받지 않고 객체를 생성할 수 있다. 객체 리터럴을 가지고, 위에서 만들어 낸 객체를 다시 작성해 보자:

var triangle = {

sideA: 3,

sideB: 4,

sideC: 5,

getArea: function ( a, b, c ) {

// Return the area of a triangle using Heron's formula

var semiperimeter = (a + b + c) / 2;

var calculation = semiperimeter * (semiperimeter - a) * (semiperimeter - b) * (semiperimeter - c);

return Math.sqrt( calculation );

}

};

역주 : 이러한 표기법을 JavaScript Object Notation – 자바스크립트 객체 표기법 – JSON 이라고 부른다.

이러한 문법은 명확하다: 객체 리터럴은 객체의 시작과 끝을 중괄호로 둘러싸며, 중괄호 안에는 프로퍼티 이름 : 프로퍼티 값 쌍이 콤마로 구분되어 나열된다. 이러한 문법을 사용함으로서, 프로그램의 매 행마다 객체 이름을 반복하는 지루한 작업에서 해방되어 쉽게 프로그램을 구조화할 수 있다.

한가지 조심할 것이 있다 : 객체 리터럴의 프로퍼티 리스트 중 마지막 것(여기에서는, getArea) 뒤에 쉼표를 넣는 실수를 아주 흔하게 범한다. 쉼표는 프로퍼티 사이 에만 넣어야 한다 – 마지막에 넣어진 필요없는 쉼표는 에러를 만든다. 특히, 코드를 이후에 수정하면서 프로퍼티를 추가하거나 지울 때 이런 실수를 범하기 쉬우므로, 쉼표가 정확한 위치에 있도록 주의를 기울일 필요가 있다.

요약 – 배울 것이 더 많이 있다

이 글은, 자바스크립트에서 객체가 갖는 가능성과 한계에 대해서 정말로 수박 겉핧기 정도밖에는 되지 않는다. 이 글을 완전히 읽었다면, 스스로 객체를 생성하여 프로퍼티와 메서드를 추가하고 그것을 자가참조의 형태로 사용하는데에는 익숙해 질 것이다. 이것 외에도 정말로 많은 것들이 있지만, 그중 어떤것도 필수적 이지는 않다. 이 글은 긴 여행의 출발점으로서 기획되었으며, 이후 당신이 길을 헤쳐나가는데 필요로 할 도구를 제공하는 목적으로 작성되었다.

읽어볼 것들

Object Oriented JavaScript: 자바스크립트의 객체지향 컨셉에 대한 더욱 상세한 소개.

Private Members in JavaScript: 더글러스 크록포드의, 자바스크립트에서의 캡슐화 기법을 다루는 세미나 형식 토의. 1

Scope in JavaScript: 다양한 문맥에서 사용되는 this 키워드의 복잡함에 대한 좀 더 상세한 토의.

연습문제

객체의 프로퍼티를 참조하기 위해 점 표기법 대신 대괄호 표기법을 사용해야 할 때는 어떤 경우인가?

객체는 어떻게 자신을 참조하는가? 왜 이것이 중요한가?

객체 리터럴이란 무엇인가? 객체 리터럴을 생성할때, 쉼표를 어디에 사용해야 하는가?

http://www.phpied.com/3-ways-to-define-a-javascript-class/ 에서 참조

Introduction

JavaScript is a very flexible object-oriented language when it comes to syntax. In this article you can find three ways of defining and instantiating an object. Even if you have already picked your favorite way of doing it, it helps to know some alternatives in order to read other people's code.

It's important to note that there are no classes in JavaScript. Functions can be used to somewhat simulate classes, but in general JavaScript is a class-less language. Everything is an object. And when it comes to inheritance, objects inherit from objects, not classes from classes as in the "class"-ical languages.

1. Using a function

This is probably one of the most common ways. You define a normal JavaScript function and then create an object by using the new keyword. To define properties and methods for an object created usingfunction(), you use the this keyword, as seen in the following example.

function Apple (type) { this.type = type; this.color = "red"; this.getInfo = getAppleInfo; } // anti-pattern! keep reading... function getAppleInfo() { return this.color + ' ' + this.type + ' apple'; }

To instantiate an object using the Apple constructor function, set some properties and call methods you can do the following:

var apple = new Apple('macintosh'); apple.color = "reddish"; alert(apple.getInfo());

1.1. Methods defined internally

In the example above you see that the method getInfo() of the Apple "class" was defined in a separate function getAppleInfo(). While this works fine, it has one drawback – you may end up defining a lot of these functions and they are all in the "global namespece". This means you may have naming conflicts if you (or another library you are using) decide to create another function with the same name. The way to prevent pollution of the global namespace, you can define your methods within the constructor function, like this:

function Apple (type) { this.type = type; this.color = "red"; this.getInfo = function() { return this.color + ' ' + this.type + ' apple'; }; }

Using this syntax changes nothing in the way you instantiate the object and use its properties and methods.

1.2. Methods added to the prototype

A drawback of 1.1. is that the method getInfo() is recreated every time you create a new object. Sometimes that may be what you want, but it's rare. A more inexpensive way is to add getInfo() to the prototype of the constructor function.

function Apple (type) { this.type = type; this.color = "red"; } Apple.prototype.getInfo = function() { return this.color + ' ' + this.type + ' apple'; };

Again, you can use the new objects exactly the same way as in 1. and 1.1.

2. Using object literals

Literals are shorter way to define objects and arrays in JavaScript. To create an empty object using you can do: var o = {}; instead of the "normal" way: var o = new Object(); For arrays you can do: var a = []; instead of: var a = new Array(); So you can skip the class-like stuff and create an instance (object) immediately. Here's the same functionality as described in the previous examples, but using object literal syntax this time:

var apple = { type: "macintosh", color: "red", getInfo: function () { return this.color + ' ' + this.type + ' apple'; } }

In this case you don't need to (and cannot) create an instance of the class, it already exists. So you simply start using this instance.

apple.color = "reddish"; alert(apple.getInfo());

Such an object is also sometimes called singleton. It "classical" languages such as Java, singleton means that you can have only one single instance of this class at any time, you cannot create more objects of the same class. In JavaScript (no classes, remember?) this concept makes no sense anymore since all objects are singletons to begin with.

3. Singleton using a function

Again with the singleton, eh? 

The third way presented in this article is a combination of the other two you already saw. You can use a function to define a singleton object. Here's the syntax:

var apple = new function() { this.type = "macintosh"; this.color = "red"; this.getInfo = function () { return this.color + ' ' + this.type + ' apple'; }; }

So you see that this is very similar to 1.1. discussed above, but the way to use the object is exactly like in 2.

apple.color = "reddish"; alert(apple.getInfo());

new function(){...} does two things at the same time: define a function (an anonymous constructor function) and invoke it with new. It might look a bit confusing if you're not used to it and it's not too common, but hey, it's an option, when you really want a constructor function that you'll use only once and there's no sense of giving it a name.

Summary

http://www.tuxradar.com/practicalphp/9/3/18 에서 참조

Advanced text searching using full-text indexes

Creating an index of large text fields is not practical in its default state - text fields have certain characteristics that warrant their own form of indexing. For example, many simple words ("at", "the", etc) are unimportant, and therefore aren't stored in FULLTEXT indexes. Furthermore, MySQL has an infamous "50% rule", whereby it will not bother indexing words that appear in the more than 50% of records simply because it will not be of use.

Creating a full text index is done after creating your table, using the following command: ALTER TABLE some_table ADD FULLTEXT (some_field). Here is an example:

ALTER TABLE usertable ADD FULLTEXT(FirstName);

Once we have a FULLTEXT index on our table, it opens up a whole new world of pattern matching, which, as of MySQL 4, allows us to do boolean matching with little fuss. FULLTEXT queries look a little more complicated that normal SELECT queries, but are much more powerful - they can even be used to return "match quality", as you will soon see. To properly demonstrate FULLTEXT indexes, we need a table with lots of text in:

CREATE TABLE opinions (Opinion CHAR(100)); INSERT INTO opinions VALUES ('MySQL is a very fast database'); INSERT INTO opinions VALUES ('Green is everyone\'s favourite colour'); INSERT INTO opinions VALUES ('Databases are helpful for storing data'); INSERT INTO opinions VALUES ('PHP is a very nice language'); INSERT INTO opinions VALUES ('Spain is a nice country to visit'); INSERT INTO opinions VALUES ('Perl isn\'t as nice a language as PHP'); INSERT INTO opinions VALUES ('This is a blank row to avoid the 50% rule'); ALTER TABLE opinions ADD FULLTEXT (Opinion);

That gives us a very basic table with a FULLTEXT index on the opinion text. From there, we can jump in with a very basic SELECT query to match all rows with "nice" in:

SELECT * FROM opinions WHERE MATCH(Opinion) AGAINST ('nice');

That query generates the following output:

+---------------------------------------+ | Opinion                               | +---------------------------------------+ | PHP is a very nice language           | | Spain is a nice country to visit      | | Perl is not as nice a language as PHP | +---------------------------------------+

As you can see, the query has indeed matched the three rows that contain the string "nice". One important thing to note is that the minimum size of word that MySQL will index is, by default, four characters - anything smaller than that is rarely worthwhile.

Now consider this second query:

SELECT * FROM opinions WHERE MATCH(Opinion) AGAINST ('nice language');

What do you think it will output? If you thought it would output just one row, you would be wrong - MySQL uses OR by default when matching words, meaning it will return any row that matches "nice" or matches "language" - this is where boolean mode searches come in.

Boolean mode searching has long been popular with internet search engines - they allow you to proceed words with a + or a - to force it to either be present (+) or not present (-). You can switch to boolean mode searching using FULLTEXT indexes by adding "IN BOOLEAN MODE" to the query, like this:

SELECT * FROM opinions WHERE MATCH(Opinion) AGAINST ('nice -language' IN BOOLEAN MODE);

Note that the "IN BOOLEAN MODE" modifier comes inside the AGAINST brackets. This time the query returns just one result - "Spain is a nice country to visit". This is because "-language" means that MySQL will not return any rows that match "language", even if they match "nice". Searching in MySQL has a number of other ways it can be used - for example, putting double quotes around groups of words allow phrase searching. That is, to match precisely "nice language", we would use the following query:

SELECT * FROM opinions WHERE Match(Opinion) AGAINST ('"nice language"' IN BOOLEAN MODE);

That matches rows that have "nice language" just like that - no words in between, not one or the other. As such, only "PHP is a very nice language" is matched.

There are other boolean operators, although they get more complicated. For example, > and < mark that the following word has a higher or lower relevance respectively than other words. The tilde symbol, ~, means that the following word should contribute negatively to the relevance of the row - this is not the same as <, which marks a word as being less relevant but still relevant nonetheless, and -, which excludes a word altogether. The asterisk symbol, *, allows wildcard matching. Finally, you can use parentheses, ( and ), to group words into subexpressions.

So, all of these examples are possible boolean queries: 

+nice +language

Match both nice and language

+nice -language

Match nice but not language

+nice ~language

Match nice, but mark down as less relevant rows that contain language

+nice*

Match nice, nicely, nicety, nice language, etc

"nice language"

Match the exact term "nice language"

+nice +(language country)

Match either "nice language" or "nice country"

+nice +(>language <country)

Match either "nice language" or "nice country", with rows matching "nice language" being considered more relevant

Before we take a look at how these effect queries in practical use, I'd first like to introduce the topic of relevance. Result relevant, often known as match quality or score, is a number returned by MySQL that allows you to rank how much of a query a row matched. To get relevance from a query, simply copy the full-text WHERE clause into the fields you want to select, like this:

SELECT Opinion, MATCH(Opinion) AGAINST('nice language' IN BOOLEAN MODE) AS Score FROM opinions WHERE MATCH(Opinion) AGAINST ('nice language' IN BOOLEAN MODE);

Do not worry about using MATCH() twice - the two matches are identical, and the MySQL optimizer will pick up on this and only execute it once. However, it does give us a new field, Score, to play with. So, the query above says "Select all opinions and their relevance where the row has either "nice" or "language". Here is what the above query outputs:

+---------------------------------------+-------+ | Opinion                               | Score | +---------------------------------------+-------+ | PHP is a very nice language           |     2 | | Spain is a nice country to visit      |     1 | | Perl is not as nice a language as PHP |     2 | +---------------------------------------+-------+

Naturally it would be best to sort by Score descending to get the matches in order of most relevant first, however note that the Score of the two fields with "nice" and language in is 2, whereas the field with just "nice" in is 1. Now we get to play with the extended boolean mode operators - for example, if we wanted to match "nice language" or "nice country", we could use this query:

SELECT Opinion, MATCH(Opinion) AGAINST('+nice +(language country)' IN BOOLEAN MODE) AS Score FROM opinions WHERE MATCH(Opinion) AGAINST ('+nice +(language country)' IN BOOLEAN MODE);

The pluses are in there to make sure that both nice and either language or country are included in the result. This time Score is 2 for all three fields, as all three match nice and all three have either language or country. We can give more relevancy information to MySQL by saying that country is more important to match than language by using >, like this:

SELECT Opinion, MATCH(Opinion) AGAINST('+nice +(language >country)' IN BOOLEAN MODE) AS Score FROM opinions WHERE MATCH(Opinion) AGAINST ('+nice +(language >country)' IN BOOLEAN MODE);

This time we get 1 for the two "nice language" matches and 1.25 for "nice country" - MySQL has increased the score for "country" by 0.25. We can push this further by decreasing the score for "language" at the same time, like this:

SELECT Opinion, MATCH(Opinion) AGAINST('+nice +(<language >country)' IN BOOLEAN MODE) AS Score FROM opinions WHERE MATCH(Opinion) AGAINST ('+nice +(<language >country)' IN BOOLEAN MODE);

The output for that query is shown below - as you can see, the nice language matches have moved down another notch.

+---------------------------------------+------------------+ | Opinion                               |            Score | +---------------------------------------+------------------+ | PHP is a very nice language           | 0.83333337306976 | | Spain is a nice country to visit      |             1.25 | | Perl is not as nice a language as PHP | 0.83333337306976 | +---------------------------------------+------------------+

The exact numbers in the score are usually irrelevant - it is the ranking that counts. Therefore, we could have achieved the same effect by using the negation operator, ~, which would subtract points from the word language if we used this query:

SELECT Opinion, MATCH(Opinion) AGAINST('+nice ~language)' IN BOOLEAN MODE) AS Score FROM opinions WHERE MATCH(Opinion) AGAINST ('+nice ~language)' IN BOOLEAN MODE);