jsファイルを自動的に圧縮するために使用されるPHPコード

 /* 2008 年 4 月 9 日。バージョン 1.1
 *
 * これは、Dean Edwards JavaScript の Packer の php バージョンです
 * ベース:
 *
 * ParseMaster、バージョン 1.0.2 ( 2005-08-19) Copyright 2005, Dean Edwards
 * マルチパターン パーサー。
 * 既知のバグ: 置換でescapeCharを使用すると誤った動作
 * 関数である値
 *
 * パッカー、バージョン 2.0.2 (2005-08-19) 著作権 2004-2005、Dean Edwards
 *
 * ライセンス: http://creativecommons.org/licenses/LGPL/2.1/
 *
 * Nicolas Martin によって PHP に移植されました。
 *
 * ---------------------------------------------- ------------------------
 * 変更履歴:
 * 1.1 : バグを修正。パックされた後にアンパックされた「/0」が「/」になる。
 * ------------------------------------------------ ----------------------
 *
 * 使用例:
 * $myPacker = new JavaScriptPacker($script, 62, true, false);
 * $packed = $myPacker->pack();
 *
 * または
 *
 * $myPacker = new JavaScriptPacker($script, 'Normal', true, false);
 * $packed = $myPacker->pack();
 *
 * または (デフォルト値)
 *
 * $myPacker = new JavaScriptPacker($script);
 * $packed = $myPacker->pack();
 *
 *
 * コンストラクターのパラメータ:
 * $script: パックする JavaScript、文字列。
 * $encoding: エンコーディングのレベル、int または string :
 * 0、10、62、95 または 'None'、'Numeric'、'Normal'、'High ASCII'。
 * デフォルト: 62。
 * $fastDecode: パックされた結果 (ブール値) に高速デコーダーを含めます。
 * デフォルト: true。
 * $specialChars: スクリプト内でプライベート変数とローカル変数にフラグが設定されている場合
 *、ブール値。
 * デフォルト: false。
 *
 * Pack() メソッドは、圧縮された JavaScript を文字列として返します。
 *
 * 詳細については、http://dean.edwards.name/packer/usage/ を参照してください。
 *
 * 注:
 * # PHP 5 が必要です。 PHP 5.1.2、5.1.3、5.1.4、5.2.3 でテスト済み
 *
 * # パックされた結果は Dean Edwards
 * バージョンとは異なる場合がありますが、長さは同じです。その理由は、配列をソートするための PHP
 * 関数 usort が
 * 2 つの等しいメンバーの元の順序を必ずしも保持しないためです。 Javascript の並べ替え関数
 * は実際にこの順序を保持します (ただし、これは
 * ECMAScript 標準では必須ではありません)。したがって、エンコードされたキーワードの順序は
 * 2 つの結果で異なる可能性があります。
 *
 * # ファイル内で
 * UTF-8 を使用する場合は、'High ASCII' レベルのエンコーディングに注意してください...
 */

 class JavaScriptPacker {
 // 定数
 const IGNORE = '$1';
 // パラメータを検証します
 private $_script = '';
 プライベート $_encoding = 62;
 プライベート $_fastDecode = true;
 プライベート $_specialChars = false;

 private $LITERAL_ENCODING = array(
 'None' => 0,
 'Numeric' => 10,
 'Normal' => 62,
 'High ASCII' => 95
 );

 パブリック関数 __construct($_script, $_encoding = 62, $_fastDecode = true, $_specialChars = false)
 {
 $this->_script = $_script 。 "/n";
 if (array_key_exists($_encoding, $this->LITERAL_ENCODING))
 $_encoding = $this->LITERAL_ENCODING[$_encoding];
 $this->_encoding = min((int)$_encoding, 95);
 $this->_fastDecode = $_fastDecode;
 $this->_specialChars = $_specialChars;
 }

 public function Pack() {
 $this->_addParser('_basicCompression');
 if ($this->_specialChars)
 $this->_addParser('_encodeSpecialChars');
 if ($this->_encoding)
 $this->_addParser('_encodeKeywords');

 // 行きます！
 return $this->_pack($this->_script);
 }

 // すべての解析ルーチンを適用します
 private function _pack($script) {
 for ($i = 0; isset($this->_parsers[$i]); $i++) {
 $script = call_user_func (array(&$this,$this->_parsers[$i]), $script);
 }
 $script を返します。
 }

 // 解析関数のリストを保持し、それらは一度にすべて実行されます
 private $_parsers = array();
 プライベート関数 _addParser($parser) {
 $this->_parsers[] = $parser;
 }

 // ゼロエンコーディング - 空白とコメントの削除のみ
 private function _basicCompression($script) {
 $parser = new ParseMaster();
 // 安全にする
 $parser->escapeChar = '//';
 // 文字列を保護する
 $parser->add('//'[^/'//n//r]*/'/', self::IGNORE);
 $parser->add('/"[^"//n//r]*"/', self::IGNORE);
 // コメントを削除します
 $parser->add('//// ///[^//n//r]*[//n//r]/', ' ')
 $parser->add('//////*[^*]*/ /*+([^///][^*]*//*+)*////', ' ');
 // 正規表現を保護する
 $parser->add('///s+ (///[^/////n//r//*][^/////n//r]*///g?i?)/', '$2');無視
 $parser->add('/[^//w//x24////'"*)//?:]///[^/////n//r//*] [^/////n//r]*///g?i?/', self::IGNORE);
 // 削除: ;;; doSomething();
 if ($this->_specialChars) $parser->add('/;;;[^//n//r]+[//n//r]/');
 // 冗長なセミコロンを削除します
 $parser->add('///(;;//)/', self::IGNORE); // (;;) ループを保護します
 $parser->add('/;+//s*([};])/', '$2');
 // 上記を適用します
 $script = $parser->exec($script);
 // 空白を削除します
 $parser->add('/(//b|//x24)//s+(//b|//x24)/', '$2 $3');
 $parser->add('/([+//-])//s+([+//-])/', '$2 $3');
 $parser->add('///s+/', '');
 // 完了
 return $parser->exec($script);
 }

 プライベート関数 _encodeSpecialChars($script) {
 $parser = new ParseMaster();
 // 置換: $name -> n, $$name -> na
 $parser->add('/((//x24+)([a-zA-Z$_]+))(//d*)/',
 array('fn' => '_replace_name】 ')
);
 // 置換: _name -> _0、二重アンダースコア (__name) は無視されます
 $regexp = '///b_[A-Za-z//d]//w*/';
 // 単語リストを作成します
 $keywords = $this->_analyze($script, $regexp, '_encodePrivate');
 // 簡単な参照
 $encoded = $keywords['encoded'];

 $parser->add($regexp,
 array(
 'fn' => '_replace_encoded',
 'data' => $encoded
 )
 );
 return $parser->exec($script);
 }

 private function _encodeKeywords($script) {
 // すでにスクリプト内 (つまり文字列内) にある上位 ASCII 値をエスケープします
 if ($this->_encoding > 62)
 $script = $this-> ;_escape95($script);
 // パーサーを作成します
 $parser = new ParseMaster();
 $encode = $this->_getEncoder($this->_encoding);
 // 高 ASCII の場合、単一文字の低 ASCII をエンコードしません
 $regexp = ($this->_encoding > 62) ? '///w//w+/' : '///w+/';
 // 単語リストを作成します
 $keywords = $this->_analyze($script, $regexp, $encode);
 $encoded = $keywords['encoded'];

 // エンコード
 $parser->add($regexp,
 array(
 'fn' => '_replace_encoded',
 'data' => $encoded
 )
 );
 if (emptyempty($script)) $script を返します。
 else {
 //$res = $parser->exec($script);
 //$res = $this->_bootStrap($res, $keywords);
 // $res を返します;
 return $this->_bootStrap($parser->exec($script), $keywords);
 }
 }

 private function _analyze($script, $regexp, $encode) {
 // 分析
 // スクリプト内のすべての単語を取得します
 $all = array();
 preg_match_all($regexp, $script, $all);
 $_sorted = array(); // 頻度順にソートされた単語のリスト
 $_encoded = array(); // 単語の辞書 > エンコーディング
 $_protected = array(); // 「保護された」単語のインスタンス
 $all = $all[0]; // グローバル一致の JavaScript コンポーネントをシミュレートします
 if (!emptyempty($all)) {
 $unsorted = array(); // 同じリスト、ソートされていない
 $protected = array(); // 「保護された」単語 (単語の辞書->「単語」)
 $value = array(); // charCode->エンコーディングの辞書 (例: 256->ff)
 $this->_count = array(); // 単語->カウント
 $i = count($all); $j = 0; //$word = null;
 // 出現回数をカウントします - 後で並べ替えるために使用されます
 do {
 --$i;
 $word = '$' 。 $all[$i];
 if (!isset($this->_count[$word])) {
 $this->_count[$word] = 0;
 $unsorted[$j] = $word;
 // このスクリプト内のすべての保護された単語の辞書を作成します
 // これらはエンコードと間違われる可能性のある単語です
 //if (is_string($encode) && Method_exists($this, $encode))
 $values [$j] = call_user_func(array(&$this, $encode), $j);
 $protected['$' . $values[$j]] = $j++;
 }
 // 単語カウンターをインクリメントします
 $this->_count[$word]++;
 } while ($i > 0);
 // 単語リストを並べ替える準備をします。まず、コードとしても使用される単語を保護する必要があります。
 // 単語。単語自体に相当するコード
 // を割り当てます。
 // 例: "do" がエンコード範囲内にある場合
 // キーワードを格納します["do"] = "do";
 // これにより、デコード時の問題が回避されます
 $i = count($unsorted);
 do {
 $word = $unsorted[--$i];
 if (isset($protected[$word]) /*!= null*/) {
 $_sorted[$protected[$word]] = substr($word, 1);
 $_protected[$protected[$word]] = true;
 $this->_count[$word] = 0;
 }
 } while ($i);

 // 単語を頻度で並べ替えます
 // 注: javascript と php のバージョンの sort は異なる場合があります :
 // php マニュアルでは、usort :
 // " 2 つのメンバーが等しいと比較した場合、
 // それらの順序ソートされた配列内の値は未定義です。」
 // したがって、最終的にパックされたスクリプトは学部長の JavaScript バージョンとは異なります
 // しかし同等です。
 // ECMAscript 標準はこの動作を保証しません。
 // したがって、すべてのブラウザ (例:
 // 少なくとも 2003 年まで遡る Mozilla バージョン) がこれを尊重するわけではありません。
 usort($unsorted, array(&$this, '_sortWords'));
 $j = 0;
 // リストに「保護された」単語があるため
 // 並べ替えられた単語をその周囲に追加する必要があります
 do {
 if (!isset($_sorted[$i]))
 $_sorted[$i] = substr ($unsorted[$j++], 1);
 $_encoded[$_sorted[$i]] = $values[$i];
 } while (++$i  }
 return array(
 'sorted' => $_sorted,
 'encoded' => $_encoded,
 'protected' => $_protected);
 }

 プライベート $_count = array();
 プライベート関数 _sortWords($match1, $match2) {
 return $this->_count[$match2] - $this->_count[$match1];
 }

 // ロードとデコードに使用されるブート関数を構築します
 private function _bootStrap($packed, $keywords) {
 $ENCODE = $this->_safeRegExp('$encode//($count//)');
 // $packed: パックされたスクリプト
 $packed = "'" 。 $this->_escape($packed) 。 "";
 // $ascii: エンコードのベース
 $ascii = min(count($keywords['sorted']), $this->_encoding);
 if ($ascii == 0) $ascii = 1;
 // $count: スクリプトに含まれる単語の数
 $count = count($keywords['sorted']);
 // $keywords: スクリプトに含まれる単語のリスト
 foreach ($keywords['protected'] as $i=>$value) {
 $keywords['sorted'][$i] = '';
 }
 // 文字列から配列に変換します
 ksort($keywords['sorted']);
 $keywords = "'" 。 implode('|',$keywords['sorted']) 。 "'.split('|')";
 $encode = ($this->_encoding > 62) ? '_encode95' : $this->_getEncoder($ascii);
 $encode = $this->_getJSFunction($encode);
 $encode = preg_replace('/_encoding/','$ascii', $encode);
 $encode = preg_replace('/arguments//.callee/','$encode', $encode);
 $inline = '//$count' 。 ($ascii > 10 ? '.toString(//$ascii)' : '');
 // $decode: デコードを高速化するコード スニペット
 if ($this->_fastDecode) {
 // デコーダーを作成します
 $decode = $this->_getJSFunction('_decodeBody');
 if ($this->_encoding > 62)
 $decode = preg_replace('/////w/', '[//xa1-//xff]', $decode);
 // 下位 ASCII 値のエンコードをインラインで実行します
 elseif ($ascii < 36)
 $decode = preg_replace($ENCODE, $inline, $decode);
 // 特殊なケース: $count==0 の場合、キーワードはありません。
 // アンパック関数の基本的な形状を維持したいので、コードをフリグします...
 if ($count == 0)
 $decode = preg_replace($this->_safeRegExp('($count )//s*=//s*1'), '$1=0', $decode, 1);
 }
 // ブート関数
 $unpack = $this->_getJSFunction('_unpack');
 if ($this->_fastDecode) {
 // デコーダを挿入します
 $this->buffer = $decode;
 $unpack = preg_replace_callback('///{/', array(&$this, '_insertFastDecode'), $unpack, 1);
 }
 $unpack = preg_replace('/"/', "'", $unpack);
 if ($this->_encoding > 62) { // high-ascii
 // 単語を削除します-正規表現一致の境界
 $unpack = preg_replace('//'////////b/'/s*//+|//+/s*/'////////b/ '/', '', $unpack);
 }
 if ($ascii > 36 || $this->_encoding > 62 || $this->_fastDecode) {
 // エンコード関数を挿入します
 $this->buffer = $encode;
 $unpack = preg_replace_callback('///', array(&$this, '_insertFastEncode'), $unpack, 1); } else {
 //インラインエンコード
 $unpack = preg_replace($ENCODE, $inline, $unpack);
 }
 // ブート関数もパックします
 $unpackPacker = new JavaScriptPacker($unpack, 0, false, true); unpackPacker->pack();

 // 引数
 $params = array($packed, $ascii, $count, $keywords);
 if ($this->_fastDecode) {
 $params[] = 0;
 $params[] = '{}';
 }
 $params = implode(',', $params);

 // 全体
 return 'eval(' . $unpack . '(' . $params . "))/n";
 }

 プライベート $buffer;
 プライベート関数 _insertFastDecode($match) {
 '{' を返します。 $this->バッファ 。 ';';
 }
 プライベート関数 _insertFastEncode($match) {
 '{$encode=' を返します。 $this->バッファ 。 ';';
 }

 // うーん.. ..どれが必要ですか??
プライベート関数 _getEncoder($ascii) {
 return $ascii > 10? $アスキー> 36? $アスキー> 62?
 '_encode95' : '_encode62' : '_encode36' : '_encode10';
 }

 // ゼロエンコーディング
 // 文字: 0123456789
 private function _encode10($charCode) {
 return $charCode;
 }

 // 固有のbase36サポート
 // 文字: 0123456789abcdefghijklmnopqrstuvwxyz
 private function _encode36($charCode) {
 returnbase_convert($charCode, 10, 36);
 }

 // Base36 に乗り、大文字の英字を追加します
 // 文字: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
 private function _encode62($charCode) {
 $res = '';
 if ($charCode >= $this->_encoding) {
 $res = $this->_encode62((int)($charCode / $this->_encoding));
 }
 $charCode = $charCode % $this->_encoding;

 if ($charCode > 35)
 $res を返します。 chr($charCode + 29);
 else
 return $res 。 Base_convert($charCode, 10, 36);
 }

 // high-ascii 値を使用します
 // 文字: ?￠￡¤￥|§¨?a??-?ˉ°±23′μ?·?1o?????àá???? ??èéê?ìí??D?òó???×?ùú?üYT?àáa?????èéê?ìí??e?òó???÷?ùú?üyt
プライベート関数 _encode95($charCode) {
 $res = '';
 if ($charCode >= $this->_encoding)
 $res = $this->_encode95($charCode / $this->_encoding);

 $res を返します。 chr(($charCode % $this->_encoding) + 161);
 }

 プライベート関数 _safeRegExp($string) {
 return '/'.preg_replace('//$/', '///$', $string).'/';
 }

 プライベート関数 _encodePrivate($charCode) {
 return "_" 。 $charCode;
 }

 // パーサーによって使用される文字を保護
 private function _escape($script) {
 return preg_replace('/([/////'])/', '///$1', $script) ;
 }

 // すでにスクリプト内にあるハイアスキー文字を保護します
 private function _escape95($script) {
 return preg_replace_callback(
 '/[//xa1-//xff]/',
 array(&$this, '_escape95Bis')、
 $script
 );
 }
 プライベート関数 _escape95Bis($match) {
 return '/x'.((string)dechex(ord($match)));
 }


 プライベート関数 _getJSFunction($aName) {
 if (define('self::JSFUNCTION'.$aName))
 return constant('self::JSFUNCTION'.$aName);
 else
 return '';
 }

 // JavaScript 関数が使用されます。
 // 注 : Dean のバージョンでは、これらの関数は
 // 'String(aFunctionName);' で変換されます。
 // この内部変換により元のコードが完成します。例:
 // 'while (aBool) anAction();'は
 // 'while (aBool) { anAction(); に変換されます。 }'。
 // 以下のJavaScript関数を修正しました。

 // アンパッキング関数 - これはブートストラップ関数です
 // このパッキング ルーチンから抽出されたデータは、
 // ターゲットでデコードされるときにこの関数に渡されます
 // 注意 ! : 「;」なし最後の。
 const JSFUNCTION_unpack =
 'function($packed, $ascii, $count, $keywords, $encode, $decode) {
 while ($count--) {
 if ($keywords[$count]) {
 $packed = $packed.replace(new RegExp(/'////b/' + $encode($count) + /'////b/', /'g/'), $keywords[$count]) ;
 }
 }
 $packed を返します。
 }';
 /*
 'function($packed, $ascii, $count, $keywords, $encode, $decode) {
 while ($count--)
 if ($keywords[$count])
 $packed = $packed .replace(new RegExp(/'////b/' + $encode($count) + /'////b/', /'g/'), $keywords[$count]);
 $packed を返す;
 }';
 */

 // デコードを高速化するためにアンパッカーにコード スニペットが挿入されます
 const JSFUNCTION_decodeBody =
 //_decode = function() {
 // ブラウザは String.replace をサポートしますか?
 // 置換値は関数？
 ' if (!/'/'.replace(/^/, String)) {
 // 必要な値をすべてデコードします
 while ($count--) {
 $decode[$encode($count)] = $keywords[$count] || $encode($count);
 }
 // グローバル置換関数
 $keywords = [function ($encoded) {return $decode[$encoded]}];
 // 一般的な一致
 $encode = function () {return /'////w+/'};
 // ループカウンターをリセットします - 今、グローバル置換を行っています
 $count = 1;
 }
 ';
 //};
 /*
 ' if (!/'/'.replace(/^/, String)) {
 // 必要な値をすべてデコードします
 while ($count--) $decode[$encode($count)] = $キーワード[$カウント] || $encode($count);
 // グローバル置換関数
 $keywords = [function ($encoded) {return $decode[$encoded]}];
 // 一般的な一致
 $encode = function () {return/'////w+/'};
 // ループカウンターをリセットします - 今、グローバル置換を行っています
 $count = 1;
 }';
 */

 // ゼロエンコーディング
 // 文字: 0123456789
 const JSFUNCTION_encode10 =
 'function($charCode) {
 return $charCode;
 }';//;';

 // 固有の Base36 サポート
 // 文字: 0123456789abcdefghijklmnopqrstuvwxyz
 const JSFUNCTION_encode36 =
 'function($charCode) {
 return $charCode.toString(36);
 }';//;';

 // Base36 に乗り、大文字の英字を追加します
 // 文字: 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
 const JSFUNCTION_encode62 =
 'function($charCode) {
 return ($charCode) < _encoding ? /'/' : 引数。 callee(parseInt($charCode / _encoding))) +
 (($charCode = $charCode % _encoding) > 35 ? String.fromCharCode($charCode + 29) : $charCode.toString(36));
 }';

 // high-ASCII 値を使用します
 // 文字: ?￠￡¤￥|§¨?a??-?ˉ°±23'μ?·?1o?????àá?????? èéê?ìí??D?òó???×?ùú?üYT?àáa?????èéê?ìí??e?òó???÷?ùú?üyt
 const JSFUNCTION_encode95 =
 'function($charCode) {
 return ($charCode < _encoding ? /'/' : argument.callee($charCode / _encoding)) +
 String.fromCharCode($charCode % _encoding + 161);
 }';

 }

 class ParseMaster {
 public $ignoreCase = false;
 public $escapeChar = '';

 // 定数
 const EXPRESSION = 0;
 const REPLACEMENT = 1;
 const LENGTH = 2;

 // ネストレベルの決定に使用されます
 private $GROUPS = '///(/';//g
 private $SUB_REPLACE = '///$//d/';
 private $INDEXED = '/^/ /$//d+$/';
 プライベート $TRIM = '/([/'"])//1//.(.*)//.//1//1$/';
 プライベート $ESCAPE = '////./';//g
プライベート $QUOTE = '//'/';
プライベート $DELETED = '///x01[^//x01]*//x01/';// g

 public function add($expression, $replacement = '') {
 // 部分式の数をカウントします
 // - 各パターン自体が部分式であるため、1 つ追加します
 $length = 1 + preg_match_all( $this->GROUPS, $this->internalEscape((string)$expression), $out);

 // 文字列のみを扱います $replacement
 if (is_string($replacement)) {
 // パターンを実行します部分式を処理しますか?
 if (preg_match($this->SUB_REPLACE, $replacement)) {
 // 単純な検索 (例: "$2")
 if (preg_match($this->INDEXED, $replacement) )) {
 // インデックスを保存します (一致した文字列を高速に取得するために使用されます)
 $replacement = (int)(substr($replacement, 1)) - 1;
 } else { // 複雑な検索 (例: "Hello $2 $1")
 // ルックアップを実行する関数を構築します
 $quote = preg_match($this->QUOTE, $this->_internalEscape($replacement) ）
？ '"' : "'";
 $replacement = array(
 'fn' => '_backReferences',
 'data' => array(
 'replacement' => $replacement,
 'length' => ; $length,
 'quote' => $quote
 )
 );
 // 変更された引数を渡します
 if (!emptyempty($expression)) $this->_add($expression, $replacement, $length);
 else $this->_add('/^$/', $replacement, $length);
 }

 public function exec($string) {
 // グローバル置換を実行します
 $this->_escaped = array();

 // Dean の _patterns.toSTring をシミュレートします
 $regexp = '/';
 foreach ($this->_patterns as $reg) {
 $regexp .= '(' . substr($reg[self::EXPRESSION], 1, -1) . ')|';
 }
 $regexp = substr($regexp, 0, -1) 。 '/';
 $regexp .= ($this->ignoreCase) ? '私' ： '';

 $string = $this->_escape($string, $this->escapeChar);
 $string = preg_replace_callback(
 $regexp,
 array(
 &$this,
 '_replacement'
 ),
 $string
 );
 $string = $this->_unescape($string, $this->escapeChar);

 return preg_replace($this->DELETED, '', $string);
 }

 public function restart() {
 // このオブジェクトが再利用できるようにパターン コレクションをクリアします
 $this->_patterns = array();
 }
 // プライベート
 プライベート $_escaped = array();  // エスケープ文字
 private $_patterns = array(); // インデックスによって保存されるパターン

 // 新しいパターンを作成してパターン コレクションに追加します
 private function _add() {
 $arguments = func_get_args();
 $this->_patterns[] = $arguments;
 }

 // これはグローバル置換関数です (非常に複雑です)
 private function _replacement($arguments) {
 if (emptyempty($arguments)) return '';

 $i = 1; $j = 0;
 // パターンをループします
 while (isset($this->_patterns[$j])) {
 $pattern = $this->_patterns[$j++];
 // 結果はありますか?
 if (isset($arguments[$i]) && ($arguments[$i] != '')) {
 $replacement = $pattern[self::REPLACEMENT];

 if (is_array($replacement) && isset($replacement['fn'])) {

 if (isset($replacement['data'])) $this->buffer = $replacement['data' ];
 return call_user_func(array(&$this, $replacement['fn']), $arguments, $i);

 } elseif (is_int($replacement)) {
 return $arguments[$replacement + $i];

 }
 $delete = ($this->escapeChar == '' ||
 strpos($arguments[$i], $this->escapeChar) === false)
 ? '' : "/x01" 。 $arguments[$i] 。 "/x01";
 $delete を返します。 $置換;

 // 部分式への参照をスキップします
 } else {
 $i += $pattern[self::LENGTH];
 }
 }
 }

 private function _backReferences($match, $offset) {
 $replacement = $this->buffer['replacement'];
 $quote = $this->buffer['quote'];
 $i = $this->buffer['length'];
 while ($i) {
 $replacement = str_replace('$'.$i--, $match[$offset + $i], $replacement);
 }
 $replacement を返します。
 }

 プライベート関数 _replace_name($match, $offset){
 $length = strlen($match[$offset + 2]);
 $start = $length - max($length - strlen($match[$offset + 3]), 0);
 substr($match[$offset + 1], $start, $length) を返します。 $match[$offset + 4];
 }

 private function _replace_encoded($match, $offset) {
 return $this->buffer[$match[$offset]];
 }


 // php : preg_replace_callback に追加データを渡すことはできません。
 // そして、create_function で &$this を使用することはできないので、下位レベルに行きましょう
 private $buffer;

 // エスケープ文字をエンコードします
 private function _escape($string, $escapeChar) {
 if ($escapeChar) {
 $this->buffer = $escapeChar;
 return preg_replace_callback(
 '///' . $escapeChar . '(.)' .'/',
 array(&$this, '_escapeBis'),
 $string
 );

 } else {
 $string を返します。
 }
 }
 プライベート関数 _escapeBis($match) {
 $this->_escaped[] = $match[1];
 $this->buffer を返す;
 }

 // エスケープされた文字をデコードする
 private function _unescape($string, $escapeChar) {
 if ($escapeChar) {
 $regexp = '/'.'//'.$escapeChar.'/';
 $this->buffer = array('escapeChar'=> $escapeChar, 'i' => 0);
 return preg_replace_callback
 (
 $regexp,
 array(&$this, '_unescapeBis'),
 $string
 );

 } else {
 $string を返します。
 }
 }
 プライベート関数 _unescapeBis() {
 if (isset($this->_escaped[$this->buffer['i']]])
 && $this->_escaped[$this->バッファ['i']] != '')
 {
 $temp = $this->_escaped[$this->buffer['i']];
 } else {
 $temp = '';
 }
 $this->buffer['i']++;
 $this->buffer['escapeChar'] を返します。 $temp;
 }

 プライベート関数 _internalEscape($string) {
 return preg_replace($this->ESCAPE, '', $string);
 }
 }
 ?>

2、実行圧縮のPHPファイルpack_js_file.php

 require 'tom-class.JavaScriptPacker.php';
 $t1 = マイクロタイム(true);
 $source_dir = realpath(dirname(__FILE__)."/..")."/common/script_unpacked";
 $out_dir = realpath(dirname(__FILE__)."/..")."/common/script";
 $d = dir( $source_dir );
 //エコー "ハンドル: " . $d->ハンドル 。 "/n";
 //エコー "パス: " . $d->パス 。 "/n";
 while (false !== ($entry = $d->read())) {
 if($entry=='.') continue;
 if($entry=='..') 続行;
 if($entry=='.svn') 続行;
 echo $entry."/n";
 $script = file_get_contents($source_dir. '/'. $entry);
 $packer = new JavaScriptPacker($script, 'Normal', true, false);
 $packed = $packer->pack();
 file_put_contents($out_dir. '/'. $entry, $packed);
 }
 $d->close();
 $t2 = マイクロタイム(true);
 $time = sprintf('%.4f', ($t2 - $t1) );
 echo 'script in ', $time, ' s.', "/n";
死ぬ;
?>

3、自動実行のbatファイルを作成します。 文中に次のような内容を入力します： /usr/local/php/bin/php Pack_js_file.php

总结： 只要充填好相对路または绝对路、一键加密JS完了、那は相当な方便です！！