diff --git a/problems/0059.螺旋矩阵II.md b/problems/0059.螺旋矩阵II.md
index 9a7dc850..733ec749 100644
--- a/problems/0059.螺旋矩阵II.md
+++ b/problems/0059.螺旋矩阵II.md
@@ -239,45 +239,54 @@ class Solution:
 
 javaScript
 
-```js
+```javascript
 
 /**
  * @param {number} n
  * @return {number[][]}
  */
 var generateMatrix = function(n) {
-    // new Array(n).fill(new Array(n))
-    // 使用fill --> 填充的是同一个数组地址
-    const res = Array.from({length: n}).map(() => new Array(n));
-    let loop = n >> 1, i = 0, //循环次数
-        count = 1,
-        startX = startY = 0; // 起始位置 
-    while(++i <= loop) {
-        // 定义行列
-        let row = startX, column = startY;
-        // [ startY, n - i)
-        while(column < n - i) {
-            res[row][column++] = count++;
+    let startX = startY = 0;   // 起始位置
+    let loop = Math.floor(n/2);   // 旋转圈数
+    let mid = Math.floor(n/2);    // 中间位置
+    let offset = 1;    // 控制每一层填充元素个数
+    let count = 1;     // 更新填充数字
+    let res = new Array(n).fill(0).map(() => new Array(n).fill(0));
+
+    while (loop--) {
+        let row = startX, col = startY;
+        // 上行从左到右（左闭右开）
+        for (; col < startY + n - offset; col++) {
+            res[row][col] = count++;
         }
-        // [ startX, n - i)
-        while(row < n - i) {
-            res[row++][column] = count++;
+        // 右列从上到下（左闭右开）
+        for (; row < startX + n - offset; row++) {
+            res[row][col] = count++;
         }
-        // [n - i ,  startY)
-        while(column > startY) {
-            res[row][column--] = count++; 
+        // 下行从右到左（左闭右开）
+        for (; col > startX; col--) {
+            res[row][col] = count++;
         }
-        // [n - i ,  startX)
-        while(row > startX) {
-            res[row--][column] = count++;
+        // 左列做下到上（左闭右开）
+        for (; row > startY; row--) {
+            res[row][col] = count++;
         }
-        startX = ++startY;
+
+        // 更新起始位置
+        startX++;
+        startY++;
+
+        // 更新offset
+        offset += 2;
     }
-    if(n & 1) {
-        res[startX][startY] = count;
+    // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
+    if (n % 2 === 1) {
+        res[mid][mid] = count;
     }
     return res;
 };
+  
+
 ```
 
 Go:
diff --git a/problems/0202.快乐数.md b/problems/0202.快乐数.md
index 02db507a..43c9d753 100644
--- a/problems/0202.快乐数.md
+++ b/problems/0202.快乐数.md
@@ -191,6 +191,30 @@ var isHappy = function(n) {
     }
     return b === 1 || getN(b) === 1 ;
 };
+
+// 方法三：使用Set()更简洁
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+
+var getSum = function (n) {
+    let sum = 0;
+    while (n) {
+        sum += (n % 10) ** 2;
+        n =  Math.floor(n/10);
+    }
+    return sum;
+}
+var isHappy = function(n) {
+    let set = new Set();   // Set() 里的数是惟一的
+    // 如果在循环中某个值重复出现，说明此时陷入死循环，也就说明这个值不是快乐数
+    while (n !== 1 && !set.has(n)) {
+        set.add(n);
+        n = getSum(n);
+    }
+    return n === 1;
+};
 ```
 
 Swift：
diff --git a/problems/0704.二分查找.md b/problems/0704.二分查找.md
index f358d2be..67809000 100644
--- a/problems/0704.二分查找.md
+++ b/problems/0704.二分查找.md
@@ -283,31 +283,46 @@ func search(nums []int, target int) int {
 
 // （版本一）左闭右闭区间
 
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
 var search = function(nums, target) {
-    let l = 0, r = nums.length - 1;
-    // 区间 [l, r]
-    while(l <= r) {
-        let mid = (l + r) >> 1;
-        if(nums[mid] === target) return mid;
-        let isSmall = nums[mid] < target;
-        l = isSmall ? mid + 1 : l;
-        r = isSmall ? r : mid - 1;
+    let left = 0, right = nums.length;
+    // 使用左闭右开区间 [left, right)
+    while (left < right) {
+        let mid = left + Math.floor((right - left)/2);
+        if (nums[mid] > target) {
+            right = mid;  // 去左区间寻找
+        } else if (nums[mid] < target) {
+            left = mid + 1;   // 去右区间寻找
+        } else {
+            return mid;
+        }
     }
     return -1;
 };
 
 // （版本二）左闭右开区间
 
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
 var search = function(nums, target) {
-    let l = 0, r = nums.length;
-    // 区间 [l, r）
-    while(l < r) {
-        let mid = (l + r) >> 1;
-        if(nums[mid] === target) return mid;
-        let isSmall = nums[mid] < target;
-        l = isSmall ? mid + 1 : l;
-        // 所以 mid 不会被取到
-        r = isSmall ? r : mid;
+    let left = 0, right = nums.length;
+    // 使用左闭右开区间 [left, right)
+    while (left < right) {
+        let mid = left + Math.floor((right - left)/2);
+        if (nums[mid] > target) {
+            right = mid;  // 去左区间寻找
+        } else if (nums[mid] < target) {
+            left = mid + 1;   // 去右区间寻找
+        } else {
+            return mid;
+        }
     }
     return -1;
 };