search

Home  >  Article  >  Backend Development  >  Compress php code of multiple CSS and JS files

Compress php code of multiple CSS and JS files

WBOY
WBOYOriginal
2016-07-25 09:04:421014browse
  2. header('Content-type: text/css');
  3. ob_start("compress");
  4. function compress($buffer) {
  5. /* remove comments */
  6. $buffer = preg_replace('!/*[^*]**+([^/][^*]**+)*/!', '', $buffer);
  7. /* remove tabs, spaces, newlines, etc. */
  8. $buffer = str_replace(array("rn", "r", "n", "t", ' ', ' ', ' '), '', $buffer);
  9. return $buffer;
  10. }
  12. /* your css files */
  13. include('galleria.css');
  14. include('articles.css');
  16. ob_end_flush();
  17. ?>
Copy code

Instantiation: test.php

  3. test
Copy the code

2. Compress js Using jsmin class Source: http://code.google.com/p/minify/ compress.php

  2. header('Content-type: text/javascript');
  3. require 'jsmin.php';
  4. echo JSMin::minify(file_get_contents('common.js') . file_get_contents( 'common2.js'));
  5. ?>
Copy code

common.js alert('first js');

common.js alert('second js');

jsmin.php

  2. /**
  3. * jsmin.php - extended PHP implementation of Douglas Crockford's JSMin.
  4. *
  5. * </li> <li> * $minifiedJs = JSMin::minify($js); </li> <li> *
  6. *
  7. * This is a direct port of jsmin.c to PHP with a few PHP performance tweaks and
  8. * modifications to preserve some comments (see below). Also, rather than using
  9. * stdin/stdout, JSMin::minify() accepts a string as input and returns another
  10. * string as output.
  11. *
  12. * Comments containing IE conditional compilation are preserved, as are multi-line
  13. * comments that begin with "/*!" (for documentation purposes). In the latter case
  14. * newlines are inserted around the comment to enhance readability.
  15. *
  16. * PHP 5 or higher is required.
  17. *
  18. * Permission is hereby granted to use this version of the library under the
  19. * same terms as jsmin.c, which has the following license:
  20. *
  21. * --
  22. * Copyright (c) 2002 Douglas Crockford (www.crockford.com)
  23. *
  24. * Permission is hereby granted, free of charge, to any person obtaining a copy of
  25. * this software and associated documentation files (the "Software"), to deal in
  26. * the Software without restriction, including without limitation the rights to
  27. * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  28. * of the Software, and to permit persons to whom the Software is furnished to do
  29. * so, subject to the following conditions:
  30. *
  31. * The above copyright notice and this permission notice shall be included in all
  32. * copies or substantial portions of the Software.
  33. *
  34. * The Software shall be used for Good, not Evil.
  35. *
  36. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  37. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  38. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  39. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  40. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  41. * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  42. * SOFTWARE.
  43. * --
  44. *
  45. * @package JSMin
  46. * @author Ryan Grove (PHP port)
  47. * @author Steve Clay (modifications + cleanup)
  48. * @author Andrea Giammarchi (spaceBeforeRegExp)
  49. * @copyright 2002 Douglas Crockford (jsmin.c)
  50. * @copyright 2008 Ryan Grove (PHP port)
  51. * @license http://opensource.org/licenses/mit-license.php MIT License
  52. * @link http://code.google.com/p/jsmin-php/
  53. */
  55. class JSMin {
  56. const ORD_LF = 10;
  57. const ORD_SPACE = 32;
  58. const ACTION_KEEP_A = 1;
  59. const ACTION_DELETE_A = 2;
  60. const ACTION_DELETE_A_B = 3;
  62. protected $a = "n";
  63. protected $b = '';
  64. protected $input = '';
  65. protected $inputIndex = 0;
  66. protected $inputLength = 0;
  67. protected $lookAhead = null;
  68. protected $output = '';
  70. /**
  71. * Minify Javascript
  72. *
  73. * @param string $js Javascript to be minified
  74. * @return string
  75. */
  76. public static function minify($js)
  77. {
  78. // look out for syntax like "++ +" and "- ++"
  79. $p = '\+';
  80. $m = '\-';
  81. if (preg_match("/([$p$m])(?:\1 [$p$m]| (?:$p$p|$m$m))/", $js)) {
  82. // likely pre-minified and would be broken by JSMin
  83. return $js;
  84. }
  85. $jsmin = new JSMin($js);
  86. return $jsmin->min();
  87. }
  89. /*
  90. * Don't create a JSMin instance, instead use the static function minify,
  91. * which checks for mb_string function overloading and avoids errors
  92. * trying to re-minify the output of Closure Compiler
  93. *
  94. * @private
  95. */
  96. public function __construct($input)
  97. {
  98. $this->input = $input;
  99. }
  101. /**
  102. * Perform minification, return result
  103. */
  104. public function min()
  105. {
  106. if ($this->output !== '') { // min already run
  107. return $this->output;
  108. }
  110. $mbIntEnc = null;
  111. if (function_exists('mb_strlen') && ((int)ini_get('mbstring.func_overload') & 2)) {
  112. $mbIntEnc = mb_internal_encoding();
  113. mb_internal_encoding('8bit');
  114. }
  115. $this->input = str_replace("rn", "n", $this->input);
  116. $this->inputLength = strlen($this->input);
  118. $this->action(self::ACTION_DELETE_A_B);
  120. while ($this->a !== null) {
  121. // determine next command
  122. $command = self::ACTION_KEEP_A; // default
  123. if ($this->a === ' ') {
  124. if (! $this->isAlphaNum($this->b)) {
  125. $command = self::ACTION_DELETE_A;
  126. }
  127. } elseif ($this->a === "n") {
  128. if ($this->b === ' ') {
  129. $command = self::ACTION_DELETE_A_B;
  130. // in case of mbstring.func_overload & 2, must check for null b,
  131. // otherwise mb_strpos will give WARNING
  132. } elseif ($this->b === null
  133. || (false === strpos('{[(+-', $this->b)
  134. && ! $this->isAlphaNum($this->b))) {
  135. $command = self::ACTION_DELETE_A;
  136. }
  137. } elseif (! $this->isAlphaNum($this->a)) {
  138. if ($this->b === ' '
  139. || ($this->b === "n"
  140. && (false === strpos('}])+-"'', $this->a)))) {
  141. $command = self::ACTION_DELETE_A_B;
  142. }
  143. }
  144. $this->action($command);
  145. }
  146. $this->output = trim($this->output);
  148. if ($mbIntEnc !== null) {
  149. mb_internal_encoding($mbIntEnc);
  150. }
  151. return $this->output;
  152. }
  154. /**
  155. * ACTION_KEEP_A = Output A. Copy B to A. Get the next B.
  156. * ACTION_DELETE_A = Copy B to A. Get the next B.
  157. * ACTION_DELETE_A_B = Get the next B.
  158. */
  159. protected function action($command)
  160. {
  161. switch ($command) {
  162. case self::ACTION_KEEP_A:
  163. $this->output .= $this->a;
  164. // fallthrough
  165. case self::ACTION_DELETE_A:
  166. $this->a = $this->b;
  167. if ($this->a === "'" || $this->a === '"') { // string literal
  168. $str = $this->a; // in case needed for exception
  169. while (true) {
  170. $this->output .= $this->a;
  171. $this->a = $this->get();
  172. if ($this->a === $this->b) { // end quote
  173. break;
  174. }
  175. if (ord($this->a) <= self::ORD_LF) {
  176. throw new JSMin_UnterminatedStringException(
  177. "JSMin: Unterminated String at byte "
  178. . $this->inputIndex . ": {$str}");
  179. }
  180. $str .= $this->a;
  181. if ($this->a === '\') {
  182. $this->output .= $this->a;
  183. $this->a = $this->get();
  184. $str .= $this->a;
  185. }
  186. }
  187. }
  188. // fallthrough
  189. case self::ACTION_DELETE_A_B:
  190. $this->b = $this->next();
  191. if ($this->b === '/' && $this->isRegexpLiteral()) { // RegExp literal
  192. $this->output .= $this->a . $this->b;
  193. $pattern = '/'; // in case needed for exception
  194. while (true) {
  195. $this->a = $this->get();
  196. $pattern .= $this->a;
  197. if ($this->a === '/') { // end pattern
  198. break; // while (true)
  199. } elseif ($this->a === '\') {
  200. $this->output .= $this->a;
  201. $this->a = $this->get();
  202. $pattern .= $this->a;
  203. } elseif (ord($this->a) <= self::ORD_LF) {
  204. throw new JSMin_UnterminatedRegExpException(
  205. "JSMin: Unterminated RegExp at byte "
  206. . $this->inputIndex .": {$pattern}");
  207. }
  208. $this->output .= $this->a;
  209. }
  210. $this->b = $this->next();
  211. }
  212. // end case ACTION_DELETE_A_B
  213. }
  214. }
  216. protected function isRegexpLiteral()
  217. {
  218. if (false !== strpos("n{;(,=:[!&|?", $this->a)) { // we aren't dividing
  219. return true;
  220. }
  221. if (' ' === $this->a) {
  222. $length = strlen($this->output);
  223. if ($length < 2) { // weird edge case
  224. return true;
  225. }
  226. // you can't divide a keyword
  227. if (preg_match('/(?:case|else|in|return|typeof)$/', $this->output, $m)) {
  228. if ($this->output === $m[0]) { // odd but could happen
  229. return true;
  230. }
  231. // make sure it's a keyword, not end of an identifier
  232. $charBeforeKeyword = substr($this->output, $length - strlen($m[0]) - 1, 1);
  233. if (! $this->isAlphaNum($charBeforeKeyword)) {
  234. return true;
  235. }
  236. }
  237. }
  238. return false;
  239. }
  241. /**
  242. * Get next char. Convert ctrl char to space.
  243. */
  244. protected function get()
  245. {
  246. $c = $this->lookAhead;
  247. $this->lookAhead = null;
  248. if ($c === null) {
  249. if ($this->inputIndex < $this->inputLength) {
  250. $c = $this->input[$this->inputIndex];
  251. $this->inputIndex += 1;
  252. } else {
  253. return null;
  254. }
  255. }
  256. if ($c === "r" || $c === "n") {
  257. return "n";
  258. }
  259. if (ord($c) < self::ORD_SPACE) { // control char
  260. return ' ';
  261. }
  262. return $c;
  263. }
  265. /**
  266. * Get next char. If is ctrl character, translate to a space or newline.
  267. */
  268. protected function peek()
  269. {
  270. $this->lookAhead = $this->get();
  271. return $this->lookAhead;
  272. }
  274. /**
  275. * Is $c a letter, digit, underscore, dollar sign, escape, or non-ASCII?
  276. */
  277. protected function isAlphaNum($c)
  278. {
  279. return (preg_match('/^[0-9a-zA-Z_\$\\]$/', $c) || ord($c) > 126);
  280. }
  282. protected function singleLineComment()
  283. {
  284. $comment = '';
  285. while (true) {
  286. $get = $this->get();
  287. $comment .= $get;
  288. if (ord($get) <= self::ORD_LF) { // EOL reached
  289. // if IE conditional comment
  290. if (preg_match('/^\/@(?:cc_on|if|elif|else|end)\b/', $comment)) {
  291. return "/{$comment}";
  292. }
  293. return $get;
  294. }
  295. }
  296. }
  298. protected function multipleLineComment()
  299. {
  300. $this->get();
  301. $comment = '';
  302. while (true) {
  303. $get = $this->get();
  304. if ($get === '*') {
  305. if ($this->peek() === '/') { // end of comment reached
  306. $this->get();
  307. // if comment preserved by YUI Compressor
  308. if (0 === strpos($comment, '!')) {
  309. return "n/*" . substr($comment, 1) . "*/n";
  310. }
  311. // if IE conditional comment
  312. if (preg_match('/^@(?:cc_on|if|elif|else|end)\b/', $comment)) {
  313. return "/*{$comment}*/";
  314. }
  315. return ' ';
  316. }
  317. } elseif ($get === null) {
  318. throw new JSMin_UnterminatedCommentException(
  319. "JSMin: Unterminated comment at byte "
  320. . $this->inputIndex . ": /*{$comment}");
  321. }
  322. $comment .= $get;
  323. }
  324. }
  326. /**
  327. * Get the next character, skipping over comments.
  328. * Some comments may be preserved.
  329. */
  330. protected function next()
  331. {
  332. $get = $this->get();
  333. if ($get !== '/') {
  334. return $get;
  335. }
  336. switch ($this->peek()) {
  337. case '/': return $this->singleLineComment();
  338. case '*': return $this->multipleLineComment();
  339. default: return $get;
  340. }
  341. }
  342. }
  344. class JSMin_UnterminatedStringException extends Exception {}
  345. class JSMin_UnterminatedCommentException extends Exception {}
  346. class JSMin_UnterminatedRegExpException extends Exception {}
  347. ?>
复制代码

调用示例：

复制代码


Statement：
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Previous article：PHP code to capture email addresses in web pagesNext article：PHP code to capture email addresses in web pages

Related articles

See more