语法高亮，滚动条美化，设置页面调整

docs/javascript/Reference/Functions/arguments/@@iterator.html

@@ -2,10 +2,10 @@
 <div></div>
 <p><code><strong>@@iterator</strong></code> 属性的初始值是和 <a href="Reference/Global_Objects/Array/values" title="values() 方法返回一个新的 Array Iterator 对象，该对象包含数组每个索引的值"><code>Array.prototype.values</code></a> 属性的初始值相同的对象。</p>
 <h2 id="语法">语法</h2>
-<pre class="syntaxbox"><var>arguments</var>[Symbol.iterator]()</pre>
+<pre><code class="language-javascript"><var>arguments</var>[Symbol.iterator]()</code></pre>
 <h2 id="实例">实例</h2>
 <h3 id="使用for...of循环的迭代">使用<code>for...of</code>循环的迭代</h3>
-<pre class="brush: js">function f() {
+<pre><code  class="language-javascript">function f() {
   // 你的浏览器必须支持 for..of 循环
   // 以及 for 循环中的 let 区域变量
   for (let letter of arguments) {
@@ -13,7 +13,7 @@
   }
 }
 f('w', 'y', 'k', 'o', 'p');
-</pre>
+</code></pre>
 <h2 id="规范">规范</h2>
 <table class="standard-table">
 <tbody>

docs/javascript/Reference/Functions/arguments/callee.html

@@ -8,21 +8,21 @@
 <p>(改编自 <a class="external" href="http://stackoverflow.com/a/235760/578288" rel="noopener" title="http://stackoverflow.com/a/235760/578288">a Stack Overflow answer by olliej</a>)</p>
 <p>早期版本的 JavaScript不允许使用命名函数表达式，出于这样的原因, 你不能创建一个递归函数表达式。</p>
 <p>例如，下边这个语法就是行的通的：</p>
-<pre class="brush: js">function factorial (n) {
+<pre><code  class="language-javascript">function factorial (n) {
     return !(n &gt; 1) ? 1 : factorial(n - 1) * n;
 }
 
-[1,2,3,4,5].map(factorial);</pre>
+[1,2,3,4,5].map(factorial);</code></pre>
 <p>但是:</p>
-<pre class="brush: js">[1,2,3,4,5].map(function (n) {
+<pre><code  class="language-javascript">[1,2,3,4,5].map(function (n) {
     return !(n &gt; 1) ? 1 : /* what goes here? */ (n - 1) * n;
-});</pre>
+});</code></pre>
 <p>这个不行。为了解决这个问题， <code>arguments.callee</code> 添加进来了。然后你可以这么做</p>
-<pre class="brush: js">[1,2,3,4,5].map(function (n) {
+<pre><code  class="language-javascript">[1,2,3,4,5].map(function (n) {
     return !(n &gt; 1) ? 1 : arguments.callee(n - 1) * n;
-});</pre>
+});</code></pre>
 <p>然而，这实际上是一个非常糟糕的解决方案，因为这 (以及其它的 <code>arguments</code>, <code>callee</code>, 和 <code>caller</code> 问题) 使得在通常的情况（你可以通过调试一些个别例子去实现它，但即使最好的代码是最理想的，你也没必要去检查调试它）不可能实现内联和尾递归。另外一个主要原因是递归调用会获取到一个不同的 <code>this</code> 值，例如：</p>
-<pre class="brush: js">var global = this;
+<pre><code  class="language-javascript">var global = this;
 
 var sillyFunction = function (recursed) {
     if (!recursed) { return arguments.callee(true); }
@@ -33,11 +33,11 @@ var sillyFunction = function (recursed) {
     }
 }
 
-sillyFunction();</pre>
+sillyFunction();</code></pre>
 <p>ECMAScript 3 通过允许命名函数表达式解决这些问题。例如：</p>
-<pre class="brush: js">[1,2,3,4,5].map(function factorial (n) {
+<pre><code  class="language-javascript">[1,2,3,4,5].map(function factorial (n) {
     return !(n &gt; 1) ? 1 : factorial(n-1)*n;
-});</pre>
+});</code></pre>
 <p>这有很多好处：</p>
 <ul>
 <li>该函数可以像代码内部的任何其他函数一样被调用</li>
@@ -45,13 +45,13 @@ sillyFunction();</pre>
 <li>它具有比访问arguments对象更好的性能</li>
 </ul>
 <p>另外一个被废弃的特性是 <code>arguments.callee.caller</code>，具体点说则是 <code>Function.caller。为什么</code>? 额，在任何一个时间点，你能在堆栈中找到任何函数的最深层的调用者，也正如我在上面提到的，在调用堆栈有一个单一重大影响：不可能做大量的优化，或者有更多更多的困难。比如，如果你不能保证一个函数 f 不会调用一个未知函数，它就绝不可能是内联函数 f。基本上这意味着内联代码中积累了大量防卫代码：</p>
-<pre class="brush: js">function f (a, b, c, d, e) { return a ? b * c : d * e; }</pre>
+<pre><code  class="language-javascript">function f (a, b, c, d, e) { return a ? b * c : d * e; }</code></pre>
 <p>如果 JavaScript 解释器不能保证所有提供的参数数量在被调用的时候都存在，那么它需要在行内代码插入检查，或者不能内联这个函数。现在在这个特殊例子里一个智能的解释器应该能重排检查而更优，并检查任何将不用到的值。然而在许多的情况里那是不可能的，也因此它不能够内联。 </p>
 <h2 id="Example.3A_Using_arguments.callee_in_an_anonymous_recursive_function" name="Example.3A_Using_arguments.callee_in_an_anonymous_recursive_function">例子</h2>
 <h3 id="Example.3A_Using_arguments.callee_in_an_anonymous_recursive_function" name="Example.3A_Using_arguments.callee_in_an_anonymous_recursive_function">在匿名递归函数中使用 <code>arguments.callee</code></h3>
 <p>递归函数必须能够引用它本身。很典型的，函数通过自己的名字调用自己。然而，匿名函数 (通过 <a href="/en-US/docs/JavaScript/Reference/Operators/function" title="JavaScript/Reference/Operators/Special/function">函数表达式</a> 或者 <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function" title="JavaScript/Reference/Global_Objects/Function">函数构造器 </a>创建</code>) 没有名称。因此如果没有可访问的变量指向该函数，唯一能引用它的方式就是通过 <code>arguments.callee</code>。</p>
 <p>下面的例子定义了一个函数，按流程，定义并返回了一个阶乘函数。该例并不是很实用，并且几乎都能够用 <a href="/en-US/docs/JavaScript/Reference/Operators/function" style="line-height: 1.5;" title="JavaScript/Reference/Operators/Special/function">命名函数表达式</a> <span style="line-height: 1.5;">实现同样结果的例子, and there are nearly no cases where the same result cannot be achieved with </span><span style="line-height: 1.5;">.</span></p>
-<pre class="brush: js">function create() {
+<pre><code  class="language-javascript">function create() {
    return function(n) {
       if (n &lt;= 1)
          return 1;
@@ -60,10 +60,10 @@ sillyFunction();</pre>
 }
 
 var result = create()(5); // returns 120 (5 * 4 * 3 * 2 * 1)
-</pre>
+</code></pre>
 <h3 id="没有替代方案的_arguments.callee">没有替代方案的 arguments.callee</h3>
 <p><span style="font-family: courier new,andale mono,monospace; line-height: 1.5;">当你必须要使用Function构造函数时，</span>下面的例子是没有可以替代 <span style="font-family: courier new,andale mono,monospace; line-height: 1.5;"><code>arguments.callee</code> 的方案的，因此</span><span style="line-height: 1.5;">弃用它时会产生一个BUG (参看 <a class="external" href="https://bugzilla.mozilla.org/show_bug.cgi?id=725398" rel="noopener" title="Deprecation of arguments.callee: how to deal with the case of instances of Function constructor?">bug 725398</a>):</span></p>
-<pre class="brush: js">function createPerson (sIdentity) {
+<pre><code  class="language-javascript">function createPerson (sIdentity) {
     var oPerson = new Function("alert(arguments.callee.identity);");
     oPerson.identity = sIdentity;
     return oPerson;
@@ -71,9 +71,9 @@ var result = create()(5); // returns 120 (5 * 4 * 3 * 2 * 1)
 
 var john = createPerson("John Smith");
 
-john();</pre>
+john();</code></pre>
 <p>译者注：利用命名函数表达式也可以实现上述例子的同样效果</p>
-<pre class="brush: js">function createPerson (identity) {
+<pre><code  class="language-javascript">function createPerson (identity) {
     function Person() {
         console.log(Person.identity);
     }
@@ -83,7 +83,7 @@ john();</pre>
 var john = createPerson("John Smith");
 
 john(); //John Smith
-</pre>
+</code></pre>
 <h2 id="Specifications">Specifications</h2>
 <table class=" standard-table">
 <tbody>

docs/javascript/Reference/Functions/arguments/caller.html

@@ -9,15 +9,15 @@
    else
       console.log(whoCalled.caller + ' called me!');
 }
-</pre>
+</code></pre>
 <h3 id="Examples" name="Examples">示例</h3>
 <p>下例演示了<code>arguments.caller</code>属性的作用.</p>
-<pre class="brush: js example-bad">function whoCalled() {
+<pre><code class="language-js example-bad">function whoCalled() {
    if (arguments.caller == null)
       console.log('该函数在全局作用域内被调用.');
    else
       console.log(arguments.caller + '调用了我!');
-}</pre>
+}</code></pre>
 <h2 id="规范">规范</h2>
 <p>无相关标准。JavaScript 1.1 实现，{{bug(7224)}} 移除 caller，因为潜在的不安全性。</p>
 <h2 id="浏览器支持">浏览器支持</h2>

docs/javascript/Reference/Functions/arguments/length.html

@@ -2,20 +2,20 @@
 <div></div>
 <p>本次函数调用时传入函数的实参数量.</p>
 <h2 id="Syntax">Syntax</h2>
-<pre class="syntaxbox">arguments.length</pre>
+<pre><code class="language-javascript">arguments.length</code></pre>
 <h2 id="Description" name="Description">描述</h2>
 <p>arguments.length表示的是实际上向函数传入了多少个参数,这个数字可以比形参数量大,也可以比形参数量小(形参数量的值可以通过<a href="/zh-CN/docs/JavaScript/Reference/Global_Objects/Function/length" title="JavaScript/Reference/Global Objects/Function/length">Function.length</a>获取到).</p>
 <h2 id="Examples" name="Examples">例子</h2>
 <h3 id="Example:_Using_arguments.length" name="Example:_Using_arguments.length">例子: 使用<code>arguments.length</code></h3>
 <p>这个例中,我们定义了一个可以相加任意个数字的函数.</p>
-<pre class="brush: js">function adder(base, /*, n2, ... */) {
+<pre><code  class="language-javascript">function adder(base, /*, n2, ... */) {
   base = Number(base);
   for (var i = 0; i &lt; arguments.length; i++) {
     base += Number(arguments[i]);
   }
   return base;
 }
-</pre>
+</code></pre>
 <h2 id="Specifications">Specifications</h2>
 <table class="standard-table">
 <tbody>