php ajaxページネーションthree_PHPチュートリアル

ajax ページネーション php ajax ページネーション java ajax ページネーション asp.net ajax ページネーション jquery ajax ページネーション jsp ajax 更新なしのページネーション asp ajax ページネーション Ajax ページネーションの問題 ajax pエイジング ajax JSP ページング
では、prototype.js ファイルを見てみましょう。

/* プロトタイプ JavaScript フレームワーク、バージョン 1.5.0
* (c) 2005-2007 サム・スティーブンソン
*
* プロトタイプは、MIT スタイルのライセンス条件に基づいて自由に配布できます。
※詳しくはプロトタイプWebサイト http://prototype.conio.net/
をご覧ください。 *
/*------------------------------------------------ ------------------------*/

var プロトタイプ = {
バージョン: '1.5.0'、
ブラウザの機能: {
XPath: !!document.evaluate
}、

ScriptFragment: '(?:)((n|r|.)*?)(?:)',
emptyFunction: function() {},
K: function(x) { return x }
}

varクラス = {
作成: function() {
戻り関数() {
this.initialize.apply(this, 引数);
}
}
}

var Abstract = 新しいオブジェクト();

Object.extend = 関数(宛先, ソース) {
for (ソース内の var プロパティ) {
宛先[プロパティ] = ソース[プロパティ];
}
返却先;
}

Object.extend(オブジェクト, {
検査: 関数(オブジェクト) {
{
を試してください if (オブジェクト === 未定義) '未定義' を返します;
If (object === null) 'null' を返します;
object.inspect を返しますか? object.inspect() : object.toString();
} キャッチ (e) {
If (RangeError のインスタンス) '...' を返す;
投げてください;
}
}、

キー: 関数(オブジェクト) {
var キー = [];
for (オブジェクトの var プロパティ)
key.push(プロパティ);
キーを返す;
}、

値: 関数(オブジェクト) {
var 値 = [];
for (オブジェクトの var プロパティ)
値.push(オブジェクト[プロパティ]);
戻り値;
}、

クローン:関数(オブジェクト){
戻り値 Object.extend({}, object);
}
});

Function.prototype.bind = function() {
var __method = this、args = $A(arguments)、object = args.shift();
戻り関数() {
Return __method.apply(object, args.concat($A(arguments)));
}
}

Function.prototype.bindAsEventListener = function(object) {
var __method = this、args = $A(arguments)、object = args.shift();
戻り関数(イベント) {
Return __method.apply(object, [(event || window.event)].concat(args).concat($A(arguments)));
}
}

Object.extend(Number.prototype, {
toColorPart: function() {
var 数字 = this.toString(16);
If (this 数字を返します;
}、

成功: function() {
これ + 1 を返します;
}、

回: 関数(反復子) {
$R(0, this, true).each(イテレータ);
これを返してください
}
});

var Try = {
これら: function() {
var returnValue;

for (var i = 0, length = argument.length; i var lambda = 引数[i];
{
を試してください returnValue = lambda();
休憩;
} キャッチ (e) {}
}

戻り値 returnValue;
}
}

/*----------------------------------------------- --- --------------------------*/

var PeriodicalExecuter = Class.create();
PeriodicalExecuter.prototype = {
  初期化: 関数(コールバック, 周波数) {
    this.callback = コールバック;
    this.frequency = 周波数;
    this.currentlyExecuting = false;

this.registerCallback();
  }、

registerCallback: function() {
    this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
  }、

stop: function() {
    if (!this.timer) return;
    clearInterval(this.timer);
    this.timer = null;
  }、

onTimerEvent: function() {
    if (!this.currentlyExecuting) {
      試してみてください{
        this.currentlyExecuting = true;
        this.callback(this);
      }ついに{
        this.currentlyExecuting = false;
      }
    }
  }
}
String.interpret = 関数(値){
  戻り値 == null ? '' : 文字列(値);
}

Object.extend(String.prototype, {
  gsub: 関数(パターン、置換) {
    var result = ''、source = this、一致;
    replace = argument.callee.prepareReplacement(replacement);

while (source.length > 0) {
      if (match = source.match(pattern)) {
        結果 += ソース.スライス(0, match.index);
        result += String.interpret(replacement(match));
        ソース = source.slice(match.index + match[0].length);
      } その他 {
        結果 += ソース、ソース = '';
      }
    }
    結果を返します;
  }、

sub: function(パターン、置換、カウント) {
    置換 = this.gsub.prepareReplacement(置換);
    カウント = カウント === 未定義 ? 1 : 数える;

return this.gsub(pattern, function(match) {
      if (--count       返品交換(一致);
    });
  }、

scan: function(pattern, iterator) {
    this.gsub(パターン、イテレータ);
    これを返してください;
  }、

truncate: function(length, truncation) {
    長さ = 長さ || 30;
    切り捨て = 切り捨て === 未定義 ? '...' : 切り捨て;
    この長さを返します >長さ?
      this.slice(0, length - truncation.length) + 切り捨て : this;
  }、

ストリップ: function() {
    return this.replace(/^s+/, '').replace(/s+$/, '');
  }、

stripTags: function() {
    return this.replace(/]+>/gi, '');
  }、

ストリップスクリプト: function() {
    return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
  }、

extractScripts: function() {
    var matchAll = new RegExp(Prototype.ScriptFragment, 'img');
    var matchOne = new RegExp(Prototype.ScriptFragment, 'im');
    return (this.match(matchAll) || []).map(function(scriptTag) {
      return (scriptTag.match(matchOne) || ['', ''])[1];
    });
  }、

evalScripts: function() {
    return this.extractScripts().map(function(script) { return eval(script) });
  }、

escapeHTML: function() {
    var div = document.createElement('div');
    var text = document.createTextNode(this);
    div.appendChild(テキスト);
    div.innerHTML を返します;
  }、

unescapeHTML: function() {
    var div = document.createElement('div');
    div.innerHTML = this.stripTags();
    div.childNodes[0] を返しますか? (div.childNodes.length > 1 ?
      $A(div.childNodes).inject('',function(memo,node){ return memo+node.nodeValue }) :
      div.childNodes[0].nodeValue) : '';
  }、

toQueryParams: function(separator) {
    var match = this.strip().match(/([^?#]*)(#.*)?$/);
    if (!match) return {};

return match[1].split(separator || '&').inject({}, function(hash, ペア) {
      if ((pair = ペア.split('='))[0]) {
        var name = decodeURIComponent(pair[0]);
        var 値 = ペア[1] ? decodeURIComponent(pair[1]) : 未定義;

if (ハッシュ[名前] !== 未定義) {
          if (ハッシュ[名前].constructor != 配列)
            ハッシュ[名前] = [ハッシュ[名前]];
          if (値) ハッシュ[名前].push(値);
        }
        else ハッシュ[名前] = 値;
      }
      ハッシュを返します;
    });
  }、

toArray: function() {
    return this.split('');
  }、

成功: function() {
    this.slice(0, this.length - 1) +
を返す       String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
  }、

キャメル化: function() {
    var Parts = this.split('-')、len = Parts.length;
    if (len == 1) パーツ[0]を返します;

var Camelized = this.charAt(0) == '-'
      ? Parts[0].charAt(0).toUpperCase() + Parts[0].substring(1)
      : パーツ[0];

for (var i = 1; i < len; i++)
      ラクダ化 += Parts[i].charAt(0).toUpperCase() + Parts[i].substring(1);

ラクダ化して返します;
  }、

大文字: function(){
    return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
  }、

アンダースコア: function() {
    return this.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'#{1}_#{2}').gsub(/ ([a-zd])([A-Z])/,'#{1}_#{2}').gsub(/-/,'_').toLowerCase();
  }、

ダッシャライズ: function() {
    return this.gsub(/_/,'-');
  }、

検査: function(useDoubleQuotes) {
    varscapeString = this.replace(/\/g, '\\');
    if (DoubleQuotes を使用)
      return '"' +エスケープString.replace(/"/g, '\"') + '"';
    それ以外
      return "'" +エスケープString.replace(/'/g, '\'') + "'";
  }
});

String.prototype.gsub.prepareReplacement = 関数(置換) {
  if (typeof replace == 'function') return replace ;
  var template = 新しいテンプレート(置換);
  return function(match) { return template.evaluate(match) };
}

String.prototype.parseQuery = String.prototype.toQueryParams;

var Template = Class.create();
Template.Pattern = /(^|.|r|n)(#{(.*?)})/;
Template.prototype = {
  初期化: 関数(テンプレート、パターン) {
    this.template = template.toString();
    this.pattern = パターン ||テンプレート.パターン;
  }、

評価: function(object) {
    return this.template.gsub(this.pattern, function(match) {
      var before = match[1];
      if (== '\' の前) return match[2];
      return before + String.interpret(object[match[3]]);
    });
  }
}

var $break = 新しいオブジェクト();
var $Continue = 新しいオブジェクト();

var 列挙可能 = {
  each: 関数(イテレータ) {
    変数インデックス = 0;
    試してみてください{
      this._each(関数(値) {
        試してみてください{
          イテレータ(値, インデックス++);
        } キャッチ (e) {
          if (e != $ continue) throw e;
        }
      });
    } キャッチ (e) {
      if (e != $break) throw e;
    }
    これを返してください;
  }、

eachSlice: function(number, iterator) {
    var インデックス = -number、スライス = []、配列 = this.toArray();
    while ((インデックス += 数値) <配列.長さ)
      スライス.push(array.slice(インデックス, インデックス+数値));
    スライスを返す.map(イテレータ);
  }、

all: function(iterator) {
    var result = true;
    this.each(関数(値, インデックス) {
      result = result && !!(イテレータ || Prototype.K)(値, インデックス);
      if (!result) throw $break;
    });
    結果を返します;
  }、

任意: function(iterator) {
    var result = false;
    this.each(関数(値, インデックス) {
      if (結果 = !!(イテレータ || Prototype.K)(値, インデックス))
        $break をスローします;
    });
    結果を返します;
  }、

collect: function(iterator) {
    var 結果 = [];
    this.each(関数(値, インデックス) {
      results.push((イテレータ || Prototype.K)(値, インデックス));
    });
    結果を返す;
  }、

検出: function(iterator) {
    var 結果;
    this.each(関数(値, インデックス) {
      if (イテレータ(値, インデックス)) {
        結果 = 値;
        $break をスローします;
      }
    });
    結果を返します;
  }、

findAll: function(iterator) {
    var 結果 = [];
    this.each(関数(値, インデックス) {
      if (イテレータ(値, インデックス))
        results.push(value);
    });
    結果を返す;
  }、

grep: function(pattern, iterator) {
    var 結果 = [];
    this.each(関数(値, インデックス) {
      var stringValue = value.toString();
      if (stringValue.match(pattern))
        results.push((イテレータ || Prototype.K)(値, インデックス));
    })
    結果を返す;
  }、

インクルード: function(object) {
    見つかった変数 = false;
    this.each(関数(値) {
      if (値 == オブジェクト) {
        見つかった = true;
        $break をスローします;
      }
    });
    戻りが見つかりました;
  }、

inGroupsOf: function(number, fillWith) {
    fillWith = fillWith === 未定義 ? null : fillWith;
    return this.eachSlice(number, function(slice) {
      while(スライス.長さ < 数値) スライス.プッシュ(fillWith);
      スライスを返します;
    });
  }、

inject: function(memo, iterator) {
    this.each(関数(値, インデックス) {
      memo = イテレータ(メモ, 値, インデックス);
    });
    メモを返す;
  }、

invoke: function(method) {
    var args = $A(引数).slice(1);
    return this.map(関数(値) {
      戻り値[メソッド].apply(値, 引数);
    });
  }、

max: function(iterator) {
    var 結果;
    this.each(関数(値, インデックス) {
      値 = (反復子 || Prototype.K)(値, インデックス);
      if (結果 == 未定義 || 値 >= 結果)
        結果 = 値;
    });
    結果を返します;
  }、

min: function(iterator) {
    var 結果;
    this.each(関数(値, インデックス) {
      値 = (反復子 || Prototype.K)(値, インデックス);
      if (結果 == 未定義 || 値 < 結果)
        結果 = 値;
    });
    結果を返します;
  }、

パーティション: function(iterator) {
    var true = []、false = [];
    this.each(関数(値, インデックス) {
      ((イテレータ || Prototype.K)(値, インデックス) ?
        true : false).push(値);
    });
    return [true, false];
  }、

摘む: function(property) {
    var 結果 = [];
    this.each(関数(値, インデックス) {
      results.push(値[プロパティ]);
    });
    結果を返す;
  }、

拒否: function(iterator) {
    var 結果 = [];
    this.each(関数(値, インデックス) {
      if (!iterator(値, インデックス))
        results.push(value);
    });
    結果を返す;
  }、

sortBy: function(iterator) {
    return this.map(関数(値, インデックス) {
      return {値: 値, 条件: イテレータ(値, インデックス)};
    }).sort(関数(左, 右) {
      var a = left.criteria、b = right.criteria;
      <を返します。 b ? -1 : a > b ? 1:0;
    }).pluck('値');
  }、

toArray: function() {
    return this.map();
  }、

zip: function() {
    var iterator = Prototype.K、args = $A(arguments);
    if (typeof args.last() == '関数')
      イテレータ = args.pop();

var collections = [this].concat(args).m​​ap($A);
    return this.map(関数(値, インデックス) {
      return iterator(collections.pluck(index));
    });
  }、

サイズ: function() {
    return this.toArray().length;
  }、

検査: function() {
    return '#';
  }
}

Object.extend(Enumerable, {
  マップ: Enumerable.collect,
  find: Enumerable.detect,
  select: Enumerable.findAll,
  メンバー: Enumerable.include,
  エントリ: Enumerable.toArray
});
var $A = Array.from = function(iterable) {
  if (!iterable) return [];
  if (iterable.toArray) {
    return iterable.toArray();
  } その他 {
    var 結果 = [];
    for (var i = 0, length = iterable.length; i       results.push(iterable[i]);
    結果を返す;
  }
}

Object.extend(Array.prototype, Enumerable);

if (!Array.prototype._reverse)
  Array.prototype._reverse = Array.prototype.reverse;

Object.extend(Array.prototype, {
  _each: 関数(反復子) {
    for (var i = 0, length = this.length; i       イテレータ(this[i]);
  }、

クリア: function() {
    this.length = 0;
    これを返してください;
  }、

最初: function() {
    これを返します[0];
  }、

最後: function() {
    これを返す[this.length - 1];
  }、

コンパクト: function() {
    return this.select(function(value) {
      戻り値 != null;
    });
  }、

フラット化: function() {
    return this.inject([], function(array, value) {
      return array.concat(value && value.constructor == Array ?
        value. flatten() : [値]);
    });
  }、

なし: function() {
    var 値 = $A(引数);
    return this.select(function(value) {
      return !values.include(value);
    });
  }、

indexOf: function(object) {
    for (var i = 0, length = this.length; i       if (this[i] == オブジェクト) return i;
    -1 を返します;
  }、

逆: 関数(インライン) {
    return (inline !== false ? this : this.toArray())._reverse();
  }、

reduce: function() {
    この長さを返します > 1?これ: これ[0];
  }、

uniq: function() {
    return this.inject([], function(array, value) {
      戻り値 array.include(value) ?配列 : array.concat([値]);
    });
  }、

クローン: function() {
    return [].concat(this);
  }、

サイズ: function() {
    this.length を返します;
  }、

検査: function() {
    return '[' + this.map(Object.inspect).join(', ') + ']';
  }
});

Array.prototype.toArray = Array.prototype.clone;

関数 $w(文字列){
  文字列 = string.strip();
  文字列を返しますか? string.split(/s+/) : [];
}

if(ウィンドウ.オペラ){
  Array.prototype.concat = function(){
    var 配列 = [];
    for(var i = 0, length = this.length; i     for(var i = 0, length = argument.length; i       if(arguments[i].constructor == Array) {
        for(var j = 0, arrayLength = argument[i].length; j           array.push(引数[i][j]);
      } その他 {
        array.push(arguments[i]);
      }
    }
    配列を返します;
  }
}
var ハッシュ = function(obj) {
  Object.extend(this, obj || {});
};

Object.extend(ハッシュ, {
  toQueryString: function(obj) {
    var 部分 = [];

this.prototype._each.call(obj, function(pair) {
      if (!pair.key) return;

if (pair.value && par.value.constructor == Array) {
        var 値 = ペア.値.コンパクト();
        if (values.length         他に{
         key = encodeURIComponent(pair.key);
          値.each(関数(値) {
            値 = 値 != 未定義 ? encodeURIComponent(値) : '';
            Parts.push(key + '=' + encodeURIComponent(value));
          });
          戻ります;
        }
      }
      if (pair.value == 未定義) ペア[1] = '';
      Parts.push(pair.map(encodeURIComponent).join('='));
   });

return Parts.join('&');
  }
});

Object.extend(Hash.prototype, Enumerable);
Object.extend(Hash.prototype, {
  _each: 関数(反復子) {
    for (この中の var キー) {
      var value = this[key];
      if (値 && 値 == Hash.prototype[key]) 続行;

var ペア = [キー, 値];
      ペア.キー = キー;
      ペア.値 = 値;
      イテレータ(ペア);
    }
  }、

キー: function() {
    return this.pluck('key');
  }、

値: function() {
    return this.pluck('value');
  }、

マージ: function(hash) {
    return $H(hash).inject(this, function(mergedHash, ペア) {
      マージされたハッシュ[ペア.キー] = ペア.値;
      マージされたハッシュを返します;
    });
  }、

削除: function() {
    var 結果;
    for(var i = 0, length = argument.length; i       var value = this[arguments[i]];
      if (値 !== 未定義){
        if (結果 === 未定義) 結果 = 値;
        他に{
          if (result.constructor != Array) result = [結果];
          result.push(値)
        }
      }
      これを削除[引数[i]];
    }
    結果を返します;
  }、

toQueryString: function() {
    return Hash.toQueryString(this);
  }、

検査: function() {
    return '#<ハッシュ:{' + this.map(function(pair) {
      戻りpair.map(Object.inspect).join(':');
    }).join(', ') + '}>';
  }
});

関数 $H(オブジェクト) {
  if (オブジェクト && object.constructor == ハッシュ) return object;
  新しいハッシュ(オブジェクト)を返します;
};
ObjectRange = Class.create();
Object.extend(ObjectRange.prototype, Enumerable);
Object.extend(ObjectRange.prototype, {
  初期化: 関数(開始、終了、排他) {
    this.start = スタート;
    this.end = 終了;
    this.exclusive = 排他的;
  }、

_each: 関数(イテレータ) {
    var value = this.start;
    while (this.include(value)) {
      イテレータ(値);
      値 = 値.succ();
    }
  }、

含まれるもの: function(value) {
    if (値 < this.start)
      false を返します;
    if (this.exclusive)
      戻り値 <;これで終わり;
    戻り値 <= this.end;
  }
});

var $R = 関数(開始、終了、排他) {
  新しい ObjectRange(開始、終了、排他) を返します;
}

var Ajax = {
  getTransport: function() {
    Try.these(
      function() {return new XMLHttpRequest()},
      function() {return new ActiveXObject('Msxml2.XMLHTTP')},
      function() {return new ActiveXObject('Microsoft.XMLHTTP')}
    ) || false;
  }、

activeRequestCount: 0
}

Ajax.Responders = {
  回答者: []、

_each: 関数(イテレータ) {
    this.responders._each(イテレータ);
  }、

register: function(responder) {
    if (!this.include(レスポンダー))
      this.responders.push(レスポンダー);
  }、

登録解除: function(responder) {
    this.responders = this.responders.without(レスポンダー);
  }、

ディスパッチ: function(コールバック、リクエスト、トランスポート、json) {
    this.each(関数(レスポンダー) {
      if (レスポンダのタイプ[コールバック] == '関数') {
        試してみてください{
          レスポンダー[コールバック].apply(レスポンダー, [リクエスト, トランスポート, json]);
        } キャッチ (e) {}
      }
    });
  }
};

Object.extend(Ajax.Responders, Enumerable);

Ajax.Responders.register({
  onCreate: function() {
    Ajax.activeRequestCount++;
  }、
  onComplete: function() {
    Ajax.activeRequestCount--;
  }
});

Ajax.Base = function() {};
Ajax.Base.prototype = {
  setOptions: 関数(オプション) {
    this.options = {
      メソッド: '投稿',
      非同期: true、
      contentType: 'application/x-www-form-urlencoded',
      エンコード: 'UTF-8',
      パラメータ: ''
    }
    Object.extend(this.options, options || {});

this.options.method = this.options.method.toLowerCase();
    if (typeof this.options.parameters == 'string')
      this.options.parameters = this.options.parameters.toQueryParams();
  }
}

Ajax.Request = Class.create();
Ajax.Request.Events =
  ['未初期化'、'読み込み中'、'読み込み済み'、'インタラクティブ'、'完了'];

Ajax.Request.prototype = Object.extend(new Ajax.Base(), {
  _complete: false、

初期化: function(url, options) {
    this.transport = Ajax.getTransport();
    this.setOptions(オプション);
    this.request(url);
  }、

リクエスト: function(url) {
    this.url = URL;
    this.method = this.options.method;
    var params = this.options.parameters;

if (!['get', 'post'].include(this.method)) {
      // post 上で他の動詞をシミュレートします
      params['_method'] = this.method;
      this.method = '投稿';
    }

params = Hash.toQueryString(params);
    if (params && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) params += '&_='

// GET 時に URL にパラメータを追加します
    if (this.method == 'get' && params)
      this.url += (this.url.indexOf('?') > -1 ? '&' : '?') + params;

試してみましょう {
      Ajax.Responders.dispatch('onCreate', this, this.transport);

this.transport.open(this.method.toUpperCase(), this.url,
        this.options.asynchronous);

if (this.options.asynchronous)
        setTimeout(function() { this.respondToReadyState(1) }.bind(this), 10);

this.transport.onreadystatechange = this.onStateChange.bind(this);
      this.setRequestHeaders();

var body = this.method == 'post' ? (this.options.postBody || params) : null;

this.transport.send(body);

/* Firefox に同期リクエストの準備完了状態 4 を強制的に処理させる */
      if (!this.options.asynchronous && this.transport.overrideMimeType)
        this.onStateChange();

}
    キャッチ (e) {
      this.dispatchException(e);
    }
  }、

onStateChange: function() {
    varreadyState = this.transport.readyState;
    if (readyState > 1 && !((readyState == 4) && this._complete))
      this.respondToReadyState(this.transport.readyState);
  }、

setRequestHeaders: function() {
    var ヘッダー = {
      'X-Requested-With': 'XMLHttpRequest',
      'X-プロトタイプ-バージョン': プロトタイプ.バージョン,
      '受け入れる': 'text/javascript、text/html、application/xml、text/xml、*/*'
    };

if (this.method == 'post') {
      headers['Content-type'] = this.options.contentType +
        (this.options.encoding ? '; charset=' + this.options.encoding : '');

/* 古い Mozilla ブラウザが機能するように「接続: 閉じる」を強制します
       * XMLHttpRequest が間違ったメッセージを送信するバグについて
       * コンテンツ長ヘッダー。 Mozilla Bugzilla #246651 を参照してください。
       */
      if (this.transport.overrideMimeType &&
          (navigator.userAgent.match(/Gecko/(d{​​4})/) || [0,2005])[1]             headers['Connection'] = 'close';
    }

// ユーザー定義のヘッダー
    if (typeof this.options.requestHeaders == 'オブジェクト') {
      var extras = this.options.requestHeaders;

if (typeof extras.push == '関数')
        for (var i = 0, length = extras.length; i           ヘッダー[エクストラ[i]] = エクストラ[i+1];
      それ以外
        $H(extras).each(function(pair) { headers[pair.key] = ペア.値 });
    }

(ヘッダーの変数名) の場合
      this.transport.setRequestHeader(名前, ヘッダー[名前]);
  }、

成功: function() {
    !this.transport.status を返します
        || (this.transport.status >= 200 && this.transport.status   }、

responseToReadyState: function(readyState) {
    var state = Ajax.Request.Events[readyState];
    var Transport = this.transport、json = this.evalJSON();

if (state == '完了') {
      試してみてください{
        this._complete = true;
        (this.options['on' + this.transport.status]
         || this.options['on' + (this.success() ? '成功' : '失敗')]
         || Prototype.emptyFunction)(トランスポート、json);
      } キャッチ (e) {
        this.dispatchException(e);
      }

if ((this.getHeader('Content-type') || 'text/javascript').strip().
        match(/^(text|application)/(x-)?(java|ecma)script(;.*)?$/i))
          this.evalResponse();
    }

試してみましょう {
      (this.options['on' + state] || Prototype.emptyFunction)(transport, json);
      Ajax.Responders.dispatch('on' + 状態、this、トランスポート、json);
    } キャッチ (e) {
      this.dispatchException(e);
    }

if (state == '完了') {
      // MSIE でのメモリ リークを回避: クリーンアップします
      this.transport.onreadystatechange = Prototype.emptyFunction;
    }
  }、

getHeader: function(name) {
    試してみてください{
      return this.transport.getResponseHeader(name);
    } catch (e) { null を返す }
  }、

evalJSON: function() {
    試してみてください{
      var json = this.getHeader('X-JSON');
      jsonを返す？ eval('(' + json + ')') : null;
    } catch (e) { null を返す }
  }、

evalResponse: function() {
    試してみてください{
      return eval(this.transport.responseText);
    } キャッチ (e) {
      this.dispatchException(e);
    }
  }、

dispatchException: function(例外) {
    (this.options.onException || Prototype.emptyFunction)(this, 例外);
    Ajax.Responders.dispatch('onException', this, 例外);
  }
});

Ajax.Updater = Class.create();

Object.extend(Object.extend(Ajax.Updater.prototype, Ajax.Request.prototype), {
  初期化: 関数(コンテナ、URL、オプション) {
    this.container = {
      成功: (container.success || コンテナ),
      失敗: (container.failure || (container.success ? null : コンテナ))
    }

this.transport = Ajax.getTransport();
    this.setOptions(オプション);

var onComplete = this.options.onComplete ||プロトタイプ.emptyFunction;
    this.options.onComplete = (function(transport, param) {
      this.updateContent();
      onComplete(transport, param);
    }).bind(this);

this.request(url);
  }、

updateContent: function() {
    var レシーバー = this.container[this.success() ? 「成功」:「失敗」];
    var 応答 = this.transport.responseText;

if (!this.options.evalScripts) response = response.stripScripts();

if (受信者 = $(受信者)) {
      if (this.options.insertion)
        新しい this.options.insertion(受信者, 応答);
      それ以外
        受信者.更新(応答);
    }

if (this.success()) {
      if (this.onComplete)
        setTimeout(this.onComplete.bind(this), 10);
    }
  }
});

Ajax.PeriodicalUpdater = Class.create();
Ajax.PeriodicalUpdater.prototype = Object.extend(new Ajax.Base(), {
  初期化: 関数(コンテナ、URL、オプション) {
    this.setOptions(オプション);
    this.onComplete = this.options.onComplete;

this.frequency = (this.options.frequency || 2);
    this.decay = (this.options.decay || 1);

this.updater = {};
    this.container = コンテナ;
    this.url = URL;

this.start();
  }、

開始: function() {
    this.options.onComplete = this.updateComplete.bind(this);
    this.onTimerEvent();
  }、

stop: function() {
    this.updater.options.onComplete = 未定義;
    clearTimeout(this.timer);
    (this.onComplete || Prototype.emptyFunction).apply(this, argument);
  }、

updateComplete: function(request) {
    if (this.options.decay) {
      this.decay = (request.responseText == this.lastText ?
        this.decay * this.options.decay : 1);

this.lastText = request.responseText;
    }
    this.timer = setTimeout(this.onTimerEvent.bind(this),
      this.decay * this.frequency * 1000);
  }、

onTimerEvent: function() {
    this.updater = new Ajax.Updater(this.container, this.url, this.options);
  }
});
関数 $(要素) {
  if (arguments.length > 1) {
    for (var i = 0, elements = [], length = argument.length; i       elements.push($(arguments[i]));
    要素を返す;
  }
  if (要素の種類 == '文字列')
    要素 = document.getElementById(要素);
  return Element.extend(element);
}

if (Prototype.Browser features.XPath) {
  document._getElementsByXPath = function(expression,parentElement) {
    var 結果 = [];
    var query = document.evaluate(expression, $(parentElement) || document,
      null、XPathResult.ORDERED_NODE_SNAPSHOT_TYPE、null);
    for (var i = 0, length = query.snapshotLength; i       results.push(query.snapshotItem(i));
    結果を返す;
  };
}

document.getElementsByClassName = function(className,parentElement) {
  if (Prototype.BrowserFeature.XPath) {
    var q = ".//*[contains(concat(' ', @class, ' '), ' " + className + " ')]";
    return document._getElementsByXPath(q,parentElement);
  } その他 {
    var Children = ($(parentElement) || document.body).getElementsByTagName('*');
    var 要素 = [], 子;
    for (var i = 0, length = Children.length; i       child = 子供[i];
      if (Element.hasClassName(child, className))
        elements.push(Element.extend(child));
    }
    要素を返す;
  }
};

/*----------------------------------------------- -------------------------*/

if (!window.Element)
  var 要素 = 新しいオブジェクト();

Element.extend = 関数(要素) {
  if (!element || _nativeExtensions || element.nodeType == 3) return element;

if (!element._extended && element.tagName && element != window) {
    var メソッド = Object.clone(Element.Methods)、キャッシュ = Element.extend.cache;

if (element.tagName == 'FORM')
      Object.extend(methods, Form.Methods);
    if (['INPUT', 'TEXTAREA', 'SELECT'].include(element.tagName))
      Object.extend(メソッド, Form.Element.Methods);

Object.extend(methods, Element.Methods.Simulated);

for (メソッドの var プロパティ) {
      var value = メソッド[プロパティ];
      if (値の型 == '関数' && !(要素内のプロパティ))
        要素[プロパティ] = キャッシュ.findOrStore(値);
    }
  }

element._extended = true;
  戻り要素;
};

Element.extend.cache = {
  findOrStore: 関数(値) {
    || この[値] = この[値]を返します ||関数() {
      戻り値.apply(null, [this].concat($A(arguments)));
    }
  }
};

Element.Methods = {
  表示可能: 関数(要素) {
    return $(element).style.display != 'none';
  }、

トグル: function(element) {
    要素 = $(要素);
    要素[要素.visible(要素) ? '非表示' : '表示'](要素);
    戻り要素;
  }、

非表示: function(element) {
    $(要素).style.display = 'なし';
    戻り要素;
  }、

show: function(element) {
    $(要素).style.display = '';
    戻り要素;
  }、

削除: function(element) {
    要素 = $(要素);
    element.parentNode.removeChild(要素);
    戻り要素;
  }、

更新: function(element, html) {
    html = typeof html == '未定義' ? '' : html.toString();
    $(要素).innerHTML = html.stripScripts();
    setTimeout(function() {html.evalScripts()}, 10);
    戻り要素;
  }、

replace: function(element, html) {
    要素 = $(要素);
    html = typeof html == '未定義' ? '' : html.toString();
    if (element.outerHTML) {
      element.outerHTML = html.stripScripts();
    } その他 {
      var range = element.ownerDocument.createRange();
      range.selectNodeContents(要素);
      element.parentNode.replaceChild(
        range.createContextualFragment(html.stripScripts()), element);
    }
    setTimeout(function() {html.evalScripts()}, 10);
    戻り要素;
  }、

検査: function(element) {
    要素 = $(要素);
    var result = '<' + element.tagName.toLowerCase();
    $H({'id': 'id', 'className': 'class'}).each(function(pair) {
      var プロパティ = ペア.ファースト()、属性 = ペア.ラスト();
      var value = (要素[プロパティ] || '').toString();
      if (値) 結果 += ' ' + 属性 + '=' + value.inspect(true);
    });
    結果を返す + '>';
  }、

再帰的に収集: function(element, property) {
    要素 = $(要素);
    var 要素 = [];
    while (要素 = 要素[プロパティ])
      if (element.nodeType == 1)
        elements.push(Element.extend(要素));
    要素を返す;
  }、

先祖: function(element) {
    return $(element).recursivelyCollect('parentNode');
  }、

子孫: function(element) {
    return $A($(element).getElementsByTagName('*'));
  }、

immediateDescendants: function(element) {
    if (!(element = $(element).firstChild)) return [];
    while (要素 && element.nodeType != 1) 要素 = element.nextSibling;
    if (要素) return [要素].concat($(要素).nextSiblings());
    [] を返す;
  }、

PreviousSiblings: function(element) {
    return $(element).recursivelyCollect('previousSibling');
  }、

nextSiblings: function(element) {
    return $(element).recursivelyCollect('nextSibling');
  }、

兄弟: function(element) {
    要素 = $(要素);
    return element.previousSiblings().reverse().concat(element.nextSiblings());
  }、

match: function(element, selector) {
    if (セレクターのタイプ == '文字列')
      selector = 新しいセレクター(セレクター);
    return selector.match($(要素));
  }、

up: function(要素、式、インデックス) {
    return Selector.findElement($(element).ancestors(),expression,index);
  }、

down: function(要素, 式, インデックス) {
    return Selector.findElement($(element).descendants(),expression,index);
  }、

前: function(要素, 式, インデックス) {
    return Selector.findElement($(element).previousSiblings(),expression,index);
  }、

次: function(要素, 式, インデックス) {
    return Selector.findElement($(element).nextSiblings(),expression,index);
  }、

getElementsBySelector: function() {
    var args = $A(arguments)、要素 = $(args.shift());
    return Selector.findChildElements(要素, 引数);
  }、

getElementsByClassName: function(element, className) {
    return document.getElementsByClassName(className, element);
  }、

readAttribute: function(要素, 名前) {
    要素 = $(要素);
    if (document.all && !window.opera) {
      var t = Element._attributeTranslations;
      if (t.values[名前]) return t.values[名前](要素, 名前);
      if (t.names[名前]) name = t.names[名前];
      var 属性 = element.attributes[名前];
      if(属性) 戻り属性.nodeValue;
    }
    return element.getAttribute(name);
  }、

getHeight: function(element) {
    $(要素).getDimensions().height;を返します
  }、

getWidth: function(element) {
    return $(element).getDimensions().width;
  }、

classNames: function(element) {
    新しい Element.ClassNames(要素) を返します;
  }、

hasClassName: function(element, className) {
    if (!(要素 = $(要素))) return;
    var elementClassName = element.className;
    if (elementClassName.length == 0) return false;
    if (要素クラス名 == クラス名 ||
        elementClassName.match(new RegExp("(^|\s)" + className + "(\s|$)")))
      true を返します;
    false を返します;
  }、

addClassName: function(element, className) {
    if (!(要素 = $(要素))) return;
    Element.classNames(要素).add(クラス名);
    戻り要素;
  }、

removeClassName: function(element, className) {
    if (!(要素 = $(要素))) return;
    Element.classNames(要素).remove(クラス名);
    戻り要素;
  }、

toggleClassName: function(element, className) {
    if (!(要素 = $(要素))) return;
    Element.classNames(element)[element.hasClassName(className) ? '削除' : '追加'](クラス名);
    戻り要素;
  }、

観察: function() {
    Event.observe.apply(イベント, 引数);
    return $A(arguments).first();
  }、

stopObserving: function() {
    Event.stopObserving.apply(イベント, 引数);
    return $A(arguments).first();
  }、

// ホワイトスペースのみのテキストノードの子を削除します
  cleanWhitespace: function(element) {
    要素 = $(要素);
    var ノード = element.firstChild;
    while (ノード) {
      var nextNode = node.nextSibling;
      if (node.nodeType == 3 && !/S/.test(node.nodeValue))
        element.removeChild(node);
      ノード = nextNode;
    }
    戻り要素;
  }、

空: function(element) {
    return $(element).innerHTML.match(/^s*$/);
  }、

子孫Of: function(要素, 祖先) {
    要素 = $(要素)、祖先 = $(祖先);
    while (要素 = element.parentNode)
      if (要素 == 祖先) true を返します;
    false を返します;
  }、

scrollTo: function(element) {
    要素 = $(要素);
    var pos = Position.cumulativeOffset(要素);
    window.scrollTo(pos[0], pos[1]);
    戻り要素;
  }、

getStyle: function(element, style) {
    要素 = $(要素);
    if (['float','cssFloat'].include(style))
      style = (要素のタイプ.style.styleFloat != '未定義' ? 'styleFloat' : 'cssFloat');
    style = style.camelize();
    var value = element.style[スタイル];
    if (!value) {
      if (document.defaultView && document.defaultView.getComputedStyle) {
        var css = document.defaultView.getComputedStyle(element, null);
        値 = css ? css[スタイル] : null;
      else if (element.currentStyle) {
        値 = element.currentStyle[スタイル];
      }
    }

if((value == 'auto') && ['width','height'].include(style) && (element.getStyle('display') != 'none'))
      値 = 要素['オフセット'+style.capitalize()] + 'px';

if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
      if (Element.getStyle(element, 'position') == 'static') value = 'auto';
    if(style == '不透明') {
      if(value) return parseFloat(value);
      if(value = (element.getStyle('filter') || '').match(/alpha(opacity=(.*))/))
        if(value[1]) return parseFloat(value[1]) / 100;
      1.0 を返します;
    }
    戻り値 == '自動' ? null : 値;
  }、

setStyle: function(element, style) {
    要素 = $(要素);
    for (スタイルの変数名) {
      var value = スタイル[名前];
      if(名前 == '不透明') {
        if (値 == 1) {
          値 = (/Gecko/.test(navigator.userAgent) &&
            !/Konqueror|Safari|KHTML/.test(navigator.userAgent)) ? 0.999999 : 1.0;
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha([^)]*)/gi,'');
        } else if(値 === '') {
          if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha([^)]*)/gi,'');
        } その他 {
          if(値           if(/MSIE/.test(navigator.userAgent) && !window.opera)
            element.style.filter = element.getStyle('filter').replace(/alpha([^)]*)/gi,'') +
              'alpha(opacity='+value*100+')';
        }
      else if(['float','cssFloat'].include(name)) name = (typeof element.style.styleFloat != 'unknown') ? 'styleFloat' : 'cssFloat';
      element.style[name.camelize()] = 値;
    }
    戻り要素;
  }、

getDimensions: function(element) {
    要素 = $(要素);
    var display = $(element).getStyle('display');
    if (display != 'none' && display != null) // Safari のバグ
      return {幅: element.offsetWidth, 高さ: element.offsetHeight};

// すべての *Width および *Height プロパティは、表示なしの要素に 0 を与えます。
    // そのため、要素を一時的に有効にします
    var els = element.style;
    varoriginalVisibility = els.visibility;
    varoriginalPosition = els.position;
    varoriginalDisplay = els.display;
    els.visibility = '非表示';
    els.position = '絶対';
    els.display = 'ブロック';
    varoriginalWidth = element.clientWidth;
    varoriginalHeight = element.clientHeight;
    els.display = オリジナルディスプレイ;
    els.position = オリジナル位置;
    els.visibility = OriginalVisibility;
    return {幅:originalWidth,高さ:originalHeight};
  }、

makePositioned: function(element) {
    要素 = $(要素);
    var pos = Element.getStyle(要素, '位置');
    if (pos == 'static' || !pos) {
      element._madePositioned = true;
 &nbs