diff --git a/solution/0700-0799/0704.Binary Search/README.md b/solution/0700-0799/0704.Binary Search/README.md
index 6dcbef5abfeb6..15b289eaf7ef0 100644
--- a/solution/0700-0799/0704.Binary Search/README.md	
+++ b/solution/0700-0799/0704.Binary Search/README.md	
@@ -52,16 +52,16 @@ tags:
 
 ### 方法一：二分查找
 
-我们定义二分查找的左边界 $left=0$，右边界 $right=n-1$。
+我们定义二分查找的左边界 $l=0$，右边界 $r=n-1$。
 
-每一次循环，我们计算中间位置 $mid=(left+right)/2$，然后判断 $nums[mid]$ 和 $target$ 的大小关系：
+每一次循环，我们计算中间位置 $\text{mid}=(l+r)/2$，然后比较 $\text{nums}[\text{mid}]$ 和 $\text{target}$ 的大小。
 
--   如果 $nums[mid] \geq target$，则说明 $target$ 在 $[left, mid]$ 之间，我们将 $right$ 更新为 $mid$；
--   否则，说明 $target$ 在 $[mid+1, right]$ 之间，我们将 $left$ 更新为 $mid+1$。
+-   如果 $\text{nums}[\text{mid}] \geq \text{target}$，说明 $\text{target}$ 在左半部分，我们将右边界 $r$ 移动到 $\text{mid}$；
+-   否则，说明 $\text{target}$ 在右半部分，我们将左边界 $l$ 移动到 $\text{mid}+1$。
 
-当 $left \geq right$ 时，我们判断 $nums[left]$ 是否等于 $target$，如果等于则返回 $left$，否则返回 $-1$。
+循环结束的条件是 $l<r$，此时 $\text{nums}[l]$ 就是我们要找的目标值，如果 $\text{nums}[l]=\text{target}$，返回 $l$，否则返回 $-1$。
 
-时间复杂度 $O(\log n)$，其中 $n$ 是数组 $nums$ 的长度。空间复杂度 $O(1)$。
+时间复杂度 $O(\log n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -70,14 +70,14 @@ tags:
 ```python
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
-        left, right = 0, len(nums) - 1
-        while left < right:
-            mid = (left + right) >> 1
+        l, r = 0, len(nums) - 1
+        while l < r:
+            mid = (l + r) >> 1
             if nums[mid] >= target:
-                right = mid
+                r = mid
             else:
-                left = mid + 1
-        return left if nums[left] == target else -1
+                l = mid + 1
+        return l if nums[l] == target else -1
 ```
 
 #### Java
@@ -85,16 +85,16 @@ class Solution:
 ```java
 class Solution {
     public int search(int[] nums, int target) {
-        int left = 0, right = nums.length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```
@@ -105,15 +105,16 @@ class Solution {
 class Solution {
 public:
     int search(vector<int>& nums, int target) {
-        int left = 0, right = nums.size() - 1;
-        while (left < right) {
-            int mid = left + right >> 1;
-            if (nums[mid] >= target)
-                right = mid;
-            else
-                left = mid + 1;
+        int l = 0, r = nums.size() - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] >= target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 };
 ```
@@ -122,46 +123,59 @@ public:
 
 ```go
 func search(nums []int, target int) int {
-	left, right := 0, len(nums)-1
-	for left < right {
-		mid := (left + right) >> 1
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
 		if nums[mid] >= target {
-			right = mid
+			r = mid
 		} else {
-			left = mid + 1
+			l = mid + 1
 		}
 	}
-	if nums[left] == target {
-		return left
+	if nums[l] == target {
+		return l
 	}
 	return -1
 }
 ```
 
+#### TypeScript
+
+```ts
+function search(nums: number[], target: number): number {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] >= target) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return nums[l] === target ? l : -1;
+}
+```
+
 #### Rust
 
 ```rust
-use std::cmp::Ordering;
-
 impl Solution {
     pub fn search(nums: Vec<i32>, target: i32) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len();
+        let mut l: usize = 0;
+        let mut r: usize = nums.len() - 1;
         while l < r {
             let mid = (l + r) >> 1;
-            match nums[mid].cmp(&target) {
-                Ordering::Less => {
-                    l = mid + 1;
-                }
-                Ordering::Greater => {
-                    r = mid;
-                }
-                Ordering::Equal => {
-                    return mid as i32;
-                }
+            if nums[mid] >= target {
+                r = mid;
+            } else {
+                l = mid + 1;
             }
         }
-        -1
+        if nums[l] == target {
+            l as i32
+        } else {
+            -1
+        }
     }
 }
 ```
@@ -175,17 +189,16 @@ impl Solution {
  * @return {number}
  */
 var search = function (nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-    while (left < right) {
-        const mid = (left + right) >> 1;
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
         if (nums[mid] >= target) {
-            right = mid;
+            r = mid;
         } else {
-            left = mid + 1;
+            l = mid + 1;
         }
     }
-    return nums[left] == target ? left : -1;
+    return nums[l] === target ? l : -1;
 };
 ```
 
@@ -194,16 +207,16 @@ var search = function (nums, target) {
 ```cs
 public class Solution {
     public int Search(int[] nums, int target) {
-        int left = 0, right = nums.Length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.Length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```
diff --git a/solution/0700-0799/0704.Binary Search/README_EN.md b/solution/0700-0799/0704.Binary Search/README_EN.md
index 603270896d0b5..1fa800eee3eb6 100644
--- a/solution/0700-0799/0704.Binary Search/README_EN.md	
+++ b/solution/0700-0799/0704.Binary Search/README_EN.md	
@@ -56,16 +56,16 @@ tags:
 
 ### Solution 1: Binary Search
 
-We define the left boundary of the binary search as $left=0$, and the right boundary as $right=n-1$.
+We define the left boundary $l=0$ and the right boundary $r=n-1$ for binary search.
 
-In each iteration, we calculate the middle position $mid=(left+right)/2$, and then compare the size of $nums[mid]$ and $target$:
+In each iteration, we calculate the middle position $\text{mid}=(l+r)/2$, then compare the size of $\text{nums}[\text{mid}]$ and $\text{target}$.
 
--   If $nums[mid] \geq target$, it means that $target$ is in the interval $[left, mid]$, so we update $right$ to $mid$;
--   Otherwise, $target$ is in the interval $[mid+1, right]$, so we update $left$ to $mid+1$.
+-   If $\text{nums}[\text{mid}] \geq \text{target}$, it means $\text{target}$ is in the left half, so we move the right boundary $r$ to $\text{mid}$;
+-   Otherwise, it means $\text{target}$ is in the right half, so we move the left boundary $l$ to $\text{mid}+1$.
 
-When $left \geq right$, we check if $nums[left]$ equals $target$. If it does, we return $left$, otherwise, we return $-1$.
+The loop ends when $l<r$, at this point $\text{nums}[l]$ is the target value we are looking for. If $\text{nums}[l]=\text{target}$, return $l$; otherwise, return $-1$.
 
-The time complexity is $O(\log n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+The time complexity is $O(\log n)$, where $n$ is the length of the array $\text{nums}$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -74,14 +74,14 @@ The time complexity is $O(\log n)$, where $n$ is the length of the array $nums$.
 ```python
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
-        left, right = 0, len(nums) - 1
-        while left < right:
-            mid = (left + right) >> 1
+        l, r = 0, len(nums) - 1
+        while l < r:
+            mid = (l + r) >> 1
             if nums[mid] >= target:
-                right = mid
+                r = mid
             else:
-                left = mid + 1
-        return left if nums[left] == target else -1
+                l = mid + 1
+        return l if nums[l] == target else -1
 ```
 
 #### Java
@@ -89,16 +89,16 @@ class Solution:
 ```java
 class Solution {
     public int search(int[] nums, int target) {
-        int left = 0, right = nums.length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```
@@ -109,15 +109,16 @@ class Solution {
 class Solution {
 public:
     int search(vector<int>& nums, int target) {
-        int left = 0, right = nums.size() - 1;
-        while (left < right) {
-            int mid = left + right >> 1;
-            if (nums[mid] >= target)
-                right = mid;
-            else
-                left = mid + 1;
+        int l = 0, r = nums.size() - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] >= target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 };
 ```
@@ -126,46 +127,59 @@ public:
 
 ```go
 func search(nums []int, target int) int {
-	left, right := 0, len(nums)-1
-	for left < right {
-		mid := (left + right) >> 1
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
 		if nums[mid] >= target {
-			right = mid
+			r = mid
 		} else {
-			left = mid + 1
+			l = mid + 1
 		}
 	}
-	if nums[left] == target {
-		return left
+	if nums[l] == target {
+		return l
 	}
 	return -1
 }
 ```
 
+#### TypeScript
+
+```ts
+function search(nums: number[], target: number): number {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] >= target) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return nums[l] === target ? l : -1;
+}
+```
+
 #### Rust
 
 ```rust
-use std::cmp::Ordering;
-
 impl Solution {
     pub fn search(nums: Vec<i32>, target: i32) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len();
+        let mut l: usize = 0;
+        let mut r: usize = nums.len() - 1;
         while l < r {
             let mid = (l + r) >> 1;
-            match nums[mid].cmp(&target) {
-                Ordering::Less => {
-                    l = mid + 1;
-                }
-                Ordering::Greater => {
-                    r = mid;
-                }
-                Ordering::Equal => {
-                    return mid as i32;
-                }
+            if nums[mid] >= target {
+                r = mid;
+            } else {
+                l = mid + 1;
             }
         }
-        -1
+        if nums[l] == target {
+            l as i32
+        } else {
+            -1
+        }
     }
 }
 ```
@@ -179,17 +193,16 @@ impl Solution {
  * @return {number}
  */
 var search = function (nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-    while (left < right) {
-        const mid = (left + right) >> 1;
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
         if (nums[mid] >= target) {
-            right = mid;
+            r = mid;
         } else {
-            left = mid + 1;
+            l = mid + 1;
         }
     }
-    return nums[left] == target ? left : -1;
+    return nums[l] === target ? l : -1;
 };
 ```
 
@@ -198,16 +211,16 @@ var search = function (nums, target) {
 ```cs
 public class Solution {
     public int Search(int[] nums, int target) {
-        int left = 0, right = nums.Length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.Length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
 }
 ```
diff --git a/solution/0700-0799/0704.Binary Search/Solution.cpp b/solution/0700-0799/0704.Binary Search/Solution.cpp
index f319e60837348..38ecbf1bdacaa 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.cpp	
+++ b/solution/0700-0799/0704.Binary Search/Solution.cpp	
@@ -1,14 +1,15 @@
 class Solution {
 public:
     int search(vector<int>& nums, int target) {
-        int left = 0, right = nums.size() - 1;
-        while (left < right) {
-            int mid = left + right >> 1;
-            if (nums[mid] >= target)
-                right = mid;
-            else
-                left = mid + 1;
+        int l = 0, r = nums.size() - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
+            if (nums[mid] >= target) {
+                r = mid;
+            } else {
+                l = mid + 1;
+            }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
-};
\ No newline at end of file
+};
diff --git a/solution/0700-0799/0704.Binary Search/Solution.cs b/solution/0700-0799/0704.Binary Search/Solution.cs
index 92142c5230c27..c017dc8a000a4 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.cs	
+++ b/solution/0700-0799/0704.Binary Search/Solution.cs	
@@ -1,14 +1,14 @@
 public class Solution {
     public int Search(int[] nums, int target) {
-        int left = 0, right = nums.Length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.Length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0704.Binary Search/Solution.go b/solution/0700-0799/0704.Binary Search/Solution.go
index cae350d992ba5..bbb9b401d7199 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.go	
+++ b/solution/0700-0799/0704.Binary Search/Solution.go	
@@ -1,15 +1,15 @@
 func search(nums []int, target int) int {
-	left, right := 0, len(nums)-1
-	for left < right {
-		mid := (left + right) >> 1
+	l, r := 0, len(nums)-1
+	for l < r {
+		mid := (l + r) >> 1
 		if nums[mid] >= target {
-			right = mid
+			r = mid
 		} else {
-			left = mid + 1
+			l = mid + 1
 		}
 	}
-	if nums[left] == target {
-		return left
+	if nums[l] == target {
+		return l
 	}
 	return -1
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0704.Binary Search/Solution.java b/solution/0700-0799/0704.Binary Search/Solution.java
index 15ff2b2233f4f..afed21c7979ab 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.java	
+++ b/solution/0700-0799/0704.Binary Search/Solution.java	
@@ -1,14 +1,14 @@
 class Solution {
     public int search(int[] nums, int target) {
-        int left = 0, right = nums.length - 1;
-        while (left < right) {
-            int mid = (left + right) >> 1;
+        int l = 0, r = nums.length - 1;
+        while (l < r) {
+            int mid = (l + r) >> 1;
             if (nums[mid] >= target) {
-                right = mid;
+                r = mid;
             } else {
-                left = mid + 1;
+                l = mid + 1;
             }
         }
-        return nums[left] == target ? left : -1;
+        return nums[l] == target ? l : -1;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/0700-0799/0704.Binary Search/Solution.js b/solution/0700-0799/0704.Binary Search/Solution.js
index a52f3e9f6ba56..9fc8c5b8e22d9 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.js	
+++ b/solution/0700-0799/0704.Binary Search/Solution.js	
@@ -4,15 +4,14 @@
  * @return {number}
  */
 var search = function (nums, target) {
-    let left = 0;
-    let right = nums.length - 1;
-    while (left < right) {
-        const mid = (left + right) >> 1;
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
         if (nums[mid] >= target) {
-            right = mid;
+            r = mid;
         } else {
-            left = mid + 1;
+            l = mid + 1;
         }
     }
-    return nums[left] == target ? left : -1;
+    return nums[l] === target ? l : -1;
 };
diff --git a/solution/0700-0799/0704.Binary Search/Solution.py b/solution/0700-0799/0704.Binary Search/Solution.py
index c25495cd56b5b..79adf426c4cfc 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.py	
+++ b/solution/0700-0799/0704.Binary Search/Solution.py	
@@ -1,10 +1,10 @@
 class Solution:
     def search(self, nums: List[int], target: int) -> int:
-        left, right = 0, len(nums) - 1
-        while left < right:
-            mid = (left + right) >> 1
+        l, r = 0, len(nums) - 1
+        while l < r:
+            mid = (l + r) >> 1
             if nums[mid] >= target:
-                right = mid
+                r = mid
             else:
-                left = mid + 1
-        return left if nums[left] == target else -1
+                l = mid + 1
+        return l if nums[l] == target else -1
diff --git a/solution/0700-0799/0704.Binary Search/Solution.rs b/solution/0700-0799/0704.Binary Search/Solution.rs
index 6dba2beb26b30..4bfc740f16401 100644
--- a/solution/0700-0799/0704.Binary Search/Solution.rs	
+++ b/solution/0700-0799/0704.Binary Search/Solution.rs	
@@ -1,23 +1,19 @@
-use std::cmp::Ordering;
-
 impl Solution {
     pub fn search(nums: Vec<i32>, target: i32) -> i32 {
-        let mut l = 0;
-        let mut r = nums.len();
+        let mut l: usize = 0;
+        let mut r: usize = nums.len() - 1;
         while l < r {
             let mid = (l + r) >> 1;
-            match nums[mid].cmp(&target) {
-                Ordering::Less => {
-                    l = mid + 1;
-                }
-                Ordering::Greater => {
-                    r = mid;
-                }
-                Ordering::Equal => {
-                    return mid as i32;
-                }
+            if nums[mid] >= target {
+                r = mid;
+            } else {
+                l = mid + 1;
             }
         }
-        -1
+        if nums[l] == target {
+            l as i32
+        } else {
+            -1
+        }
     }
 }
diff --git a/solution/0700-0799/0704.Binary Search/Solution.ts b/solution/0700-0799/0704.Binary Search/Solution.ts
new file mode 100644
index 0000000000000..f05e271832004
--- /dev/null
+++ b/solution/0700-0799/0704.Binary Search/Solution.ts	
@@ -0,0 +1,12 @@
+function search(nums: number[], target: number): number {
+    let [l, r] = [0, nums.length - 1];
+    while (l < r) {
+        const mid = (l + r) >> 1;
+        if (nums[mid] >= target) {
+            r = mid;
+        } else {
+            l = mid + 1;
+        }
+    }
+    return nums[l] === target ? l : -1;
+}