기대치 이상의 릴리즈라고 보여집니다.
 1. Event API의 향상들...
    + Event.observe나 Element#observe를 통해서 등록된 이벤트 핸들러는 모든 브라우저에서
      자동적으로 이벤트가 발생한 엘리먼트에 묶여집니다.
    + Event 오브젝트는 다양한 메서드들과 함께 확장되었습니다.
    + 이벤트 네임과 핸들러 아규먼트는 Event.stropObserving 와 Element#stopObserving에
      서 선택적으로 되었습니다.
    + 사용자 함수도 지원됩니다.

 2. Function API의 향상들...

 3. Class API 향상들...
    + 이번 버젼의 Class.create 는 세 가지의 선택적 형식을 제공합니다. 여러분은 클래스에
      상속받고, 익명 오브젝트를 새로운 클래스 프로토타입에 섞거나 혹은 둘다 할 수 있습니다.
    + Object.extend 처럼 Class.extend 도 이용할 수 있습니다. 그러나 원본의 오브젝트가
       해당 클래스의 원형에 섞인다.
    + 만약 여러분이 부모 클래스로부터 오버라이딩한 메서드라면 이번 버젼에서는 여러분은
      슈퍼 클래스의 메서드를 오버라이딩 함수의 첫번째 아규먼트인 $super이란 이름을 통하여
      엑세스 할 수 있습니다. 이것은 Function#wrap 처럼 작동한다.
      (사실 이것은  Function#wrap을 내부적으로 사용한다)
    + 이번 버젼 클래스들은 좀더 강력한 상속 계층의 내부 구조를 위한  생성자, 슈퍼클래스
       그리고 서브클래스 프로퍼티들을 갖고 있습니다.

  4. AJAX API의 향상들...
     + 이번 버젼에서 여러분은 JSON 응답을 JavaScript objects 처럼 transport 오브젝트의
       responseJSON 프로퍼티를 이용하여 접근할 수 있습니다.  (JSON 응답은
       application/json를 Content-type의 헤더로 갖어야만 합니다.)

  5. DOM API의 향상들..
     + 여기는 볼것도 없습니다.. ㅠ.ㅠ DOM 빌더가 생겼답니다.. 그것도 크로스 브라우징이
       되도록.. 소스를 보면 참 기특합니다.. ㅠ.ㅠ  DOM 빌더의 초석을 다져놨으니 이젠.
       릴리즈 될때마다 놀랄것 같습니다.
     + 기존의 Insertion과 Postion이 조금씩 변했습니다.  Element 안으로 Insertion의 메서드가
       생성되었습니다.
     + 그외에 몇가지의 메서드들이 추가되었습니다. 그건 좀더 번역을 해보구요...

  6. Template API의 향상들..
     + 많은 좀더 세부적인 JSON 으로 템플릿에 적용이 가능합니다. {key : value } 의 형식만
       지원했었다면 Array 형식도 지원합니다. 형식은 릴리즈 노트를 참고하시면 쉽게 알 수
       있습니다.

  그외 확장된 grep 의미론..
    프로토타입 1.6.0에는 Enumerable#grep에 첫번째 아규먼트를 위한 새로운 컨밴션이
    소개되었습니다. 그 아규먼트는 match 라는 이름의 메서드를 갖는 오브젝트여야만 합니다.
    Enumerable안에서 각각의 엘리먼트를 호출하기 위한 grep입니다. 만약에 그 메서드가
    true를 반환한다면 그 엘리먼트는 grep를 통해서 array를 반환하여 표현할 것입니다. 
    이것은 무슨말이냐면은 여러분들은 grep를 갖고 array를 필터링 할 수 있습니다.

Javascript 1.6과 WAHTWG 1.0 표준을 위한 향상된 서포팅!!
 


Prototype 1.6.0 release candidate

by Sam Stephenson | August 15th, 2007

The first release candidate of Prototype 1.6.0 has arrived! The core team is continuing its tradition of bringing thoughtful incremental upgrades to the core APIs in addition to performance improvements and bug fixes. Keep reading for some of the highlights of this major release, or download it now for instant
gratification.

1.6.0으로 릴리즈 되었네요. 많은 부분에서 업그레이드가 되었고 핵심 API들은 퍼포먼스 향상과 버그가 수정되었습니다. 아래 내용 중 하이라이트 된 부분을 더 자세히 읽어보면 됩니다.


Event API Enhancements

We dubbed 1.6.0 the “event overhaul” release internally, and it shows—one of our worst APIs has become one of our best, overnight. Here’s what’s changed:

  • Event handlers registered with Event.observe or Element#observe are now automatically bound to the event’s target element in all browsers. This means that by default, this in an event handler refers to the element that fired the event. You can override this behavior by passing a bound function to observe.
  • Event.observe 혹은 Element#observe 로 등록되어진 이벤트 핸들러들은 모든 브라우저에서 자동적으로 이벤트 발생한 해당 엘리먼트를 취하고 있습니다. 이 말은 이벤트 핸들러 안의 this는 이벤트가 해제된 엘리먼트를 참조하는게 기본이 된다는 말입니다. 여러분은 this습성을 observe에 bound 기능을 통해서 오버라이드 할 수 있습니다.

  • Event objects are now extended with a collection of instance methods. This means you can now write event.stop() instead of Event.stop(event). Furthermore, the event object is normalized with W3C-standard property names in all browsers, so you can now write event.target instead of Event.element(event).
  • Event 오브젝트들은 현재 인스턴스 메서드들을 갖으며 확장되었습니다.  이 말인 즉 여러분이 event.stop()으로 Event.stop(event)를 한것 처럼 쓸 수 있게 되었습니다.  더욱이 이벤트 오브젝트는 W3C 표준 프로퍼티 네임을 모든 부라우저에서 일반화 되어졌고, 그래서 여러분들은 event.target을 Event.element(event)대신에 쓸 수 있다.
  • The event name and handler arguments to Event.stopObserving and Element#stopObserving are now optional, so for a given element, you can now quickly unregister all its handlers, or unregister all handlers for a single event.
  • 이벤트 네임과 핸들러 아규먼트는 Event.stropObserving 와 Element#stopObserving에서 선택적으로 되었습니다,  여러분은 빠르게 그것들의 핸들러를 모두 해제 시킬 수 있고 싱글 이벤트 핸들러를 해제할 수도 있게 되었습니다.
  • References to observed elements are no longer stored in an internal cache, to prevent leaks.
  • 이벤트가 할당된 엘리먼트의 참조는 이제 누수 방지를 위해 내부 캐시에 저장되지 않습니다.
  • Prototype now has support for custom events. Fire them on DOM elements by calling Element#fire with an event name and optional memo object. Internally, Prototype piggybacks your custom events on real DOM events, so they bubble up the document just like click events. This means custom event observers can respond to events fired from child elements. You can observe and fire on the document object for global events.
  • 이번 버젼에서는 사용자 이벤트들를 제공합니다.  이벤트 네임과 선택적 메모 오브젝트를 갖는 Element#fire에 의해서 호출된 DOM 엘리먼트들에 그것들을 발생시키세요.
    내부적으로 프로토타입 기능은 실제 DOM 이벤트들을 여러분의 사용자 함수로 편승(변경)되어집니다.
    그래서 클릭 이벤트와 같이 document의 위쪽으로만 발생합니다.
    이 말은 사용자 이벤트 옵져버들은 child 엘리먼트에서 발생된 이벤트들에 응답할 수 있다라는 의미이다.
    여러분은 전역 이벤트를 위한 document오브젝트에 관찰하고 발생시킬 수 있습니다.


    <div id="container">
      <h1><span id="title">Release notes</span></h1>
      ...
    </div>
  • $("container").observe("titleChanged", function(event) { 
      this.highlight({ duration: 0.5 });
    });

    이부분은 사용자 이벤트 리스너를 통하여 스크립트 아큘러스의 highlight 기능과 연결한 부분입니다.
    이렇게 사용자가 정의한 이벤트 시스템의 예제를 보여줍니다.
    전역적으로 활용되는 이벤트 핸들러를 정의해서 사용하면 좋을 듯 싶네요..

  • $("title").fire("titleChanged");
  • We’ve built in cross-browser support for the DOMContentLoaded event using our custom event system, so you can now be notified as soon as the document is fully loaded:
  • 우리는 크로스브라우저에서 제공되는 DOMcontentLoaded event를 맏늘어 놨다. 우리의 사용자 이벤트 시스템을 이용하여, 그래서 여러분들은 document가 모두 불러지자마자 통재할 수 있다.
    document.observe("contentloaded", function() { ... })

Function API Enhancements

We’ve added several methods on Function.prototype to better support functional and aspect-oriented programming techniques.

  • Function#wrap distills the essence of aspect-oriented programming into a single method, letting you easily build on existing functions by specifying before and after behavior, transforming the return value, or even preventing the original function from being called. Here’s an example of using wrap to add behavior to an existing Prototype String method:
  • Function#wrap 는 영역 지향 프로그램의 기초를 단일 메서드 안에 다졌습니다. 여러분은 before & after 속성을 갖는 존재한 function들을 쉽게 만들 수 있습니다.
    아래 wrap를 사용한 예제는 Prototype에 존재하는 메서드에 add 속성을 주었다.
  • aspect-oriented programming : 프로그램의 영역이 수행 프로그램 컴파일 방법을 결정하는 프로그래밍 방법 객체 지향 프로그래밍 OOP 과 함께 사용되며 영역이란 프로그램의 성격을 나타내는 서브 프로그램으로 영역이 변함에 따라 전체 프로그램이 변하는 aspect weaver 영역 직조형 컴파일러 라는 일종의 컴파일러 역할을 한다  
    String.prototype.capitalize = String.prototype.capitalize.wrap( 
      function(proceed, eachWord) {
        if (eachWord && this.include(" ")) {
          // capitalize each word in the string
    return this.split(" ").invoke("capitalize").join(" ");
        } else {
          // proceed using the original function
    return proceed();
        }
      });


    "hello world".capitalize() // "Hello world"
    "hello world".capitalize(true) // "Hello World"
    For a less-contrived example, see how you can add jQuery-style element collection methods ($$(“div.widget”).show().highlight()) in under 40 lines of code by wrapping $$ and Element.addMethods.
  • Function#curry allows for partial function application, like Function#bind, but leaves the function’s scope unmodified.
  • Function#curry는 Function#bind 같은 부분적 기능 어플리케이션을 허락합니다. 그러나 function의 스코프  
    function sum(a, b) { 
      return a + b;
    }


    sum(10, 5) // 15
    var addTen = sum.curry(10);
    addTen(5) // 15
  • Function#methodize encapsulates the pattern of converting a function’s first argument into its this value. 
  • Function#methodize는 변환 패턴을 캡슐화 합니다. 이 기능의 첫번째 아규먼트는 this value를 갖습니다.





    function
    addBorder(element, color) {
      return $(element).setStyle({
        border: "3px solid " + (color || "red")
      });
    }


    addBorder("sidebar", "#ddd");
    $("sidebar").addBorder = addBorder.methodize();
    $("sidebar").addBorder("#888");
    Prototype makes heavy use of methodize internally; for example, many Math methods are added to Number instances:
    $w("abs round ceil floor").each(function(method) { 
      Number.prototype[method] = Math[method].methodize();
    });
  • Function#argumentNames returns an array of strings representing the function’s named arguments, as extracted from the function’s toString() value.
  • Function#argumentNames는 function의 명명된 아규먼트들을 문자열로 표현해 배열로 반환합니다.
  • Function#delay provides a convenient wrapper around window.setTimeout, and Function#defer is delay with a 10ms timeout.
  • Function#delay는 편리한 window.setTimeout을 감싼 것을 제공합니다.
    // add class "busy" after one second 
    (function() { $("form").addClassName("busy") }).delay(1);
    // fire the "requestSent" event asynchronously
    (function() { $("form").fire("requestSent") }).defer();

Class API Enhancements

This release marks the first change to Prototype’s class API since version 1.0, and adds true support for inheritance and superclass methods. It’s backwards-compatible with the existing API.

  • Class.create now supports three alternate forms of invocation: you can now pass a class to inherit from, an anonymous object to mix into the new class’s prototype, or both.
  • 이번 버젼의 Class.create 는 세 가지의 선택적 형식을 제공합니다. 여러분은 클래스에 상속받고, 익명 오브젝트를 새로운 클래스 프로토타입에 섞거나 혹은 둘다 할 수 있습니다.
  • The new Class.extend method works like Object.extend, but mixes the source object into the destination class’s prototype.
  • Object.extend 처럼 Class.extend 도 이용할 수 있습니다. 그러나 원본의 오브젝트가 해당 클래스의 원형에 섞인다.
  • If you’re overriding a method from a parent class, you can now access the superclass method by naming the overriding function’s first argument $super. It works just like Function#wrap (in fact, it uses Function#wrap internally).
  • 만약 여러분이 부모 클래스로부터 오버라이딩한 메서드라면 이번 버젼에서는 여러분은 슈퍼 클래스의 메서드를 오버라이딩 함수의 첫번째 아규먼트인 $super이란 이름을 통하여 엑세스 할 수 있습니다. 이것은 Function#wrap 처럼 작동한다. (사실 이것은 Function#wrap을 내부적으로 사용한다)




    var
    Animal = Class.create({
      initialize: function(name) {
        this.name = name;
      },
      eat: function() {
        return this.say("Yum!");
      },
      say: function(message) {
        return this.name + ": " + message;
      }
    });


// subclass that augments a method
var Cat = Class.create(Animal, {
  eat: function($super, food) {
    if (food instanceof Mouse) return $super();
    else return this.say("Yuk! I only eat mice.");
  }
});
  • Classes now have constructor, superclass, and subclasses properties for powerful introspection of the inheritance hierarchy.
  • 이번 버젼 클래스들은 좀더 강력한 상속 계층의 내부 구조를 위한  생성자, 슈퍼클래스 그리고 서브클래스 프로퍼티들을 갖고 있습니다.

Ajax API Enhancements

Ajax.Request JSON support has been considerably improved in Prototype 1.6.0:

  • You can now access JSON response bodies as JavaScript objects using the transport object’s responseJSON property. (JSON responses must have a Content-type header of application/json.)
  • 이번 버젼에서 여러분은 JSON 응답을 JavaScript objects 처럼 transport 오브젝트의 responseJSON 프로퍼티를 이용하여 접근할 수 있습니다.  (JSON 응답은 application/json를 Content-type의 헤더로 갖어야만 합니다.
new Ajax.Request("/people/5.json", { // >> GET /people/5.json HTTP/1.1 
onSuccess: function(transport) { // << Content-type: application/json
var person = transport.responseJSON; // << { id: 5, name: "Tobie Langel",
person.city // "Geneva" // << city: "Geneva", ... }
...
  }, method: "get"
});
  • The transport object itself is now wrapped by Prototype in an Ajax.Response instance so it can be extended with properties like responseJSON in all browsers. Ajax.Response also features two new, error-proof methods to access headers, getHeader and getAllHeaders; easy access to the transport and request object themselves, with the request and transport properties; and direct access to all the other properties and methods of the transport object for full compatibility.
  • transport 오브젝트는 현재 an Ajax.Response 인스턴스 Prototype에 의해 감싸져 있었다 그래서 모든 브라우저에서 responseJOSN과 같은 프로퍼티와 함께 확장할 수 있었다.  Ajax.Response는 또한  
The following new options are available to Ajax.Request:
  • sanitizeJSON (true by default) checks the string for possible malicious fragments and prevents evaluation if any are detected.
  • sanitizeJSON
  • evalJSON (true by default) auto-evaluates JSON data if the response’s Content-type is application/json and makes it available as the responseJSON property of the response object.
  • evalJS (true by default) auto-evaluates JavaScript if the response’s Content-type is text/javascript or equivalent.

DOM API Enhancements

  • Prototype now boasts a new cross-browser DOM Builder :
    이번 버젼에는 크로스 브라우저 DOM 빌더가 생겨따 ㅠ.ㅠ 미치거따
new Element("input", { name: "user", disabled: true }); 
//-> <input name="user" disabled="disabled" />

Internally the DOM builder uses Element#writeAttribute, another new addition to the DOM API which facilitates setting element attribute values in a cross-browser fashion.
내부적으로 DOM 빌더는 Element#writeAttribute를 사용하고 크로스 브라우저 형태의 엘리먼트 속성 값을 셋하는  DOM API가 새롭게 추가되었다.

  • We’ve deprecated the Insertion object and Position namespace in this release, and replaced them with methods on Element instead. Element#insert accepts multiple forms of content (DOM elements, HTML, simple text, or any object):
    우리는 이번 릴리즈를 통해 Insertion 오브젝트와 Position 네임 스페이스에서 업신여겻다. 그리고 그것들을 Element로 변경해버렸다. Element#insert로 내용을 다양한 형태로 시도할 수 있게 되었다.

$("items").insert({ after: new Element("p") });
$("items").insert({ top: "<li>an item</li>" });
$("items").insert("<li>another item</li>"); // defaults to bottom

If an object passed to insert contains a toHTML or a toElement method, that method will be used to produce an HTML string or DOM element for insertion.


var Calendar = Class.create({
  // ...,
toElement: function() {
    var container = new Element("div");
    // ...
return container;
  }
});


$("sidebar").insert(new Calendar());
// same as $("sidebar").insert({ bottom: new Calendar() }) or
// $("sidebar").insert({ bottom: new Calendar().toElement() })
  • Element#update and Element#replace also both now accept DOM elements or objects with a toHTML or atoElement defined. We’ve also smoothed over issues with <table>- and <select>-related elements in IE and Opera 9.
  • Element#setStyle now accepts either a string of CSS rules (new in this version) or a hash of style/value pairs.

$("header").setStyle("font-size: 12px; float: left; opacity: 0.5");

Note that for performance reasons, we’ve deprecated the use of uncamelized style property names when setting styles using a hash. So If you have code that looks like this:


$("header").setStyle({ "font-size": "12px" });

You need to replace it with either of the following:


$("header").setStyle({ fontSize: "12px" });
$("header").setStyle("font-size: 12px");
  • Element#identify is a new method which returns the element’s ID if one exists, or sets and returns a unique, auto-generated ID (of the form “anonymous_element_” + auto-incremented digit) otherwise:

<div id="my_div">
  <p>some content</p>
</div>

$("my_div").identify();
// -> "my_div"
$("my_div").down().identify();
// -> "anonymous_element_1"

<div id="my_div">
  <p id="anonymous_element_1">some content</p>
</div>
  • Element#wrap is a convenient and flexible way to wrap DOM elements:

<img id="my_img" />
<span id="my_span">a picture</span>

$("my_img").wrap();
$("my_span").wrap('p', { className: "caption" });

<div><img id="my_img" /></div>
<p class="caption"><span id="my_span">a picture</span></p>

The new document.viewport object lets you calculate the dimensions and position of the browser’s viewport:


document.viewport.getDimensions() // { width: 1149, height: 923 }
document.viewport.getWidth() // 1149
document.viewport.getHeight() // 923
document.viewport.getScrollOffsets() // { left: 0, top: 1592 }

Template API Enhancements

  • You can now perform one-off template replacements with String#interpolate, instead of having to first create a Template object and then call evaluate.
    "#{last}, #{first}".interpolate({ first: "Andrew", last: "Dupont" }) 
    // "Dupont, Andrew"
  • If you pass String#interpolate or Template#evaluate an object with a toTemplateReplacements method, the return value of that method will be used as the replacement object.
  • You can now substitute properties of template replacement values in template strings, using dot or bracket notation (or both).
    "#{name.last}, #{name.first[0]}. (#{location})".interpolate({ 
      name: { first: "Christophe", last: "Porteneuve" }, location: "Paris"
    }) // "Porteneuve, C. (Paris)"

Extended grep semantics

Prototype 1.6.0 introduces a new convention for the first argument to Enumerable#grep: the argument must be an object with a method named match, which method grep will call for each element in the Enumerable; if the method returns true, the element will be present in the array returned by grep. What this means is that you can now filter arrays with grep by passing it any object that has a match method. For example, you can now easily pare down an array of DOM elements to only those elements matching a particular CSS selector:
프로토 타입 1.6.0에는 Enumerable#grep에 첫번째 아규먼트를 위한 새로운 컨밴션이 소개되었습니다. 그 아규먼트는 match 라는 이름의 메서드를 갖는 오브젝트여야만 합니다. Enumerable안에서 각각의 엘리먼트를 호출하기 위한 grep입니다. 만약에 그 메서드가 true를 반환한다면 그 엘리먼트는 grep를 통해서 array를 반환하여 표현할 것입니다.  이것은 무슨말이냐면은 여러분들은 grep를 갖고 array를 필터링 할 수 있습니다.


elements.grep(new Selector("div.widget:first-child"))

Prototype aliases RegExp#test to RegExp#match, so existing code that e.g. greps string arrays using a regular expression will still work as expected. The match method convention is inspired by Ruby’s triple-equal (===) operator.

Improved support for JavaScript 1.6 and WHATWG 1.0 standards

We’ve emphasized our commitment to web standards in this release with improved support for JavaScript 1.6 and the WHATWG Web Applications 1.0 specification.

  • Array#indexOf no longer overrides the native method if present.
  • Array#indexOf 는 더이상 javascript native에 오버라이드 되지 않습니다. 만약 존재한다면...
  • Enumerable now uses the native Array#forEach instead of Array#_each when possible.
  • Enumerable는 Array#forEach native를 Array#_each 대신해서 가능한한
  • Enumerable now has aliases for the JavaScript 1.6 Array methods filter, entries, every, and
    some
    , which map to findAll, toArray, all, and any, respectively.
  • Enumerable는 Javascript 1.6의 배열 메서드의 알리아스를 갖습니다. filter, entries, evey 그리고 some map, findAll, toArray, all, 그리고 any
  • All Enumerable methods now have an additional parameter, context, which, if present, specifies the object to which the iterators’ this is bound, for compatibility with JavaScript 1.6 Array methods.
  • 모든 Enumerable 메서드는 context 라는 추가된 파라미터를 갖습니다.
  • Element#getElementsByClassName now supports multiple class names given as a whitespace-separated string, as specified by WHATWG and implemented by Firefox 3. The native version of getElementsByClassName is used in browsers that support it.
  • Element#getELementByClassName 는 다양한 클래스 네임이 주어집니다. 띄어쓰기 같은 문자열로

...And a whole lot more

These are just the highlights; see the CHANGELOG for the full story. We think the numerous small improvements to Prototype in this release have resulted in a supremely cohesive and intuitive API. So please give it a shot, let us know what you think on the mailing lists, and report any bugs you encounter (preferably with tested patches).

A note about this release candidate

We intend for Prototype 1.6.0_rc0 to be feature-complete, but we reserve the right to make adjustments to our new APIs and add or remove features before the final version is released.

신고
Posted by Rhio.kim