diff --git a/docs/number.md b/docs/number.md
index 23fe543..b861132 100644
--- a/docs/number.md
+++ b/docs/number.md
@@ -2,18 +2,33 @@
 
 ## 二进制和八进制表示法
 
-ES6提供了二进制和八进制数值的新的写法，分别用前缀`0b`和`0o`表示。
+ES6提供了二进制和八进制数值的新的写法，分别用前缀`0b`（或`0B`）和`0o`（或`0O`）表示。
 
 ```javascript
 0b111110111 === 503 // true
 0o767 === 503 // true
 ```
 
-八进制不再允许使用前缀0表示，而改为使用前缀`0o`。
+从ES5开始，在严格模式之中，八进制就不再允许使用前缀`0`表示，ES6进一步明确，要使用前缀`0o`表示。
 
 ```javascript
-011 === 9 // 不正确
-0o11 === 9 // 正确
+// 非严格模式
+(function(){
+  console.log(0o11 === 011);
+})() // true
+
+// 严格模式
+(function(){
+  'use strict';
+  console.log(0o11 === 011);
+})() // Uncaught SyntaxError: Octal literals are not allowed in strict mode.
+```
+
+如果要将`0b`和`0x`前缀的字符串数值转为十进制，要使用`Number`方法。
+
+```javascript
+Number('0b111')  // 7
+Number('0o10')  // 8
 ```
 
 ## Number.isFinite(), Number.isNaN()
@@ -189,11 +204,25 @@ withinErrorMargin(0.2 + 0.2, 0.3)
 // false
 ```
 
-上面的代码部署了一个误差检查函数。
+上面的代码为浮点数运算，部署了一个误差检查函数。
 
 ## 安全整数和Number.isSafeInteger()
 
-JavaScript能够准确表示的整数范围在`-2^53`到`2^53`之间（不含两个端点）。ES6引入了`Number.MAX_SAFE_INTEGER`和`Number.MIN_SAFE_INTEGER`这两个常量，用来表示这个范围的上下限。
+JavaScript能够准确表示的整数范围在`-2^53`到`2^53`之间（不含两个端点），超过这个范围，无法精确表示这个值。
+
+```javascript
+Math.pow(2, 53) // 9007199254740992
+
+9007199254740992  // 9007199254740992
+9007199254740993  // 9007199254740992
+
+Math.pow(2, 53) === Math.pow(2, 53) + 1
+// true
+```
+
+上面代码中，超出2的53次方之后，一个数就不精确了。
+
+ES6引入了`Number.MAX_SAFE_INTEGER`和`Number.MIN_SAFE_INTEGER`这两个常量，用来表示这个范围的上下限。
 
 ```javascript
 Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
@@ -215,10 +244,14 @@ Number.isSafeInteger(null) // false
 Number.isSafeInteger(NaN) // false
 Number.isSafeInteger(Infinity) // false
 Number.isSafeInteger(-Infinity) // false
+
+Number.isSafeInteger(3) // true
+Number.isSafeInteger(1.2) // false
+Number.isSafeInteger(9007199254740990) // true
+Number.isSafeInteger(9007199254740992) // false
+
 Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1) // false
 Number.isSafeInteger(Number.MIN_SAFE_INTEGER) // true
-Number.isSafeInteger(1) // true
-Number.isSafeInteger(1.2) // false
 Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true
 Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1) // false
 ```
@@ -373,6 +406,8 @@ JavaScript的整数使用32位二进制形式表示，`Math.clz32`方法返回
 Math.clz32(0) // 32
 Math.clz32(1) // 31
 Math.clz32(1000) // 22
+Math.clz32(0b01000000000000000000000000000000) // 1
+Math.clz32(0b00100000000000000000000000000000) // 2
 ```
 
 上面代码中，0的二进制形式全为0，所以有32个前导0；1的二进制形式是`0b1`，只占1位，所以32位之中有31个前导0；1000的二进制形式是`0b1111101000`，一共有10位，所以32位之中有22个前导0。
@@ -419,7 +454,7 @@ Math.imul(-1, 8);         // -8
 Math.imul(-2, -2);        // 4
 ```
 
-如果只考虑最后32位（含第一个整数位），大多数情况下，`Math.imul(a, b)`与`a * b`的结果是相同的，即该方法等同于`(a * b)|0`的效果（超过32位的部分溢出）。之所以需要部署这个方法，是因为JavaScript有精度限制，超过2的53次方的值无法精确表示。这就是说，对于那些很大的数的乘法，低位数值往往都是不精确的，`Math.imul`方法可以返回正确的低位数值。
+如果只考虑最后32位，大多数情况下，`Math.imul(a, b)`与`a * b`的结果是相同的，即该方法等同于`(a * b)|0`的效果（超过32位的部分溢出）。之所以需要部署这个方法，是因为JavaScript有精度限制，超过2的53次方的值无法精确表示。这就是说，对于那些很大的数的乘法，低位数值往往都是不精确的，`Math.imul`方法可以返回正确的低位数值。
 
 ```javascript
 (0x7fffffff * 0x7fffffff)|0 // 0
@@ -443,7 +478,7 @@ Math.fround(1.5);   // 1.5
 Math.fround(NaN);   // NaN
 ```
 
-对于整数来说，Math.fround方法返回结果不会有任何不同，区别主要是那些无法用64个二进制位精确表示的小数。这时，Math.fround方法会返回最接近这个小数的单精度浮点数。
+对于整数来说，`Math.fround`方法返回结果不会有任何不同，区别主要是那些无法用64个二进制位精确表示的小数。这时，`Math.fround`方法会返回最接近这个小数的单精度浮点数。
 
 对于没有部署这个方法的环境，可以用下面的代码模拟。
 
@@ -477,7 +512,7 @@ ES6新增了4个对数相关方法。
 
 **（1） Math.expm1()**
 
-`Math.expm1(x)`返回e<sub>x</sub> - 1。
+`Math.expm1(x)`返回e<sub>x</sub> - 1，即`Math.exp(x) - 1`。
 
 ```javascript
 Math.expm1(-1); // -0.6321205588285577
@@ -495,7 +530,7 @@ Math.expm1 = Math.expm1 || function(x) {
 
 **（2）Math.log1p()**
 
-`Math.log1p(x)`方法返回`1 + x`的自然对数。如果`x`小于-1，返回`NaN`。
+`Math.log1p(x)`方法返回`1 + x`的自然对数，即`Math.log(1 + x)`。如果`x`小于-1，返回`NaN`。
 
 ```javascript
 Math.log1p(1);  // 0.6931471805599453