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

WBOY
リリース: 2016-07-13 17:07:10
オリジナル
698 人が閲覧しました

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

ソース:php.cn
このウェブサイトの声明
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
最新の問題
人気のチュートリアル
詳細>
最新のダウンロード
詳細>
ウェブエフェクト
公式サイト
サイト素材
フロントエンドテンプレート