update containers doc test cases

Signed-off-by: Nliu-ganlin <liuganlin@huawei.com>

zh-cn/application-dev/reference/apis/js-apis-arraylist.md

@@ -96,9 +96,10 @@ add(element: T): boolean
   let b = [1, 2, 3];
   let result2 = arrayList.add(b);
   let c = {name: "Dylon", age: "13"};
-  let result3 = arrayList.add(false);
+  let result3 = arrayList.add(c);
+  let result4 = arrayList.add(false);
   try {
-    arraylist.add.bind({}, "b")();
+    arraylist.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
   } catch(err) {
     console.log(`${err.code} - ${err.name} - ${err.message}`);
   }
@@ -136,17 +137,17 @@ arrayList.insert("A", 0);
 arrayList.insert(0, 1);
 arrayList.insert(true, 2);
 try {
-  arraylist.insert.bind({}, 1, 2)();
+  arraylist.insert.bind({}, 1, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  let res = arrayList.insert(8, 11);
+  let res = arrayList.insert(8, 11); // 测试越界异常
 } catch (err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  let res = arrayList.insert("a", "b");
+  let res = arrayList.insert("a", "b"); // 测试类型异常
 } catch (err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -188,7 +189,7 @@ let result = arrayList.has("squirrel");
 arrayList.add("squirrel");
 let result1 = arrayList.has("squirrel");
 try {
-  arraylist.has.bind({}, "squirrel")();
+  arraylist.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -235,7 +236,7 @@ arrayList.add(2);
 arrayList.add(4);
 let result = arrayList.getIndexOf(2);
 try {
-  arraylist.getIndexOf.bind({}, 2)();
+  arraylist.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -282,7 +283,7 @@ arrayList.add(2);
 arrayList.add(4);
 let result = arrayList.getLastIndexOf(2);
 try {
-  arraylist.getLastIndexOf.bind({}, 2)();
+  arraylist.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -328,17 +329,17 @@ arrayList.add(2);
 arrayList.add(4);
 let result = arrayList.removeByIndex(2);
 try {
-  arraylist.removeByIndex.bind({}, 2)();
+  arraylist.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  arraylist.removeByIndex("a");
+  arraylist.removeByIndex("a"); // 测试类型异常
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  arraylist.removeByIndex(8);
+  arraylist.removeByIndex(8); // 测试越界异常
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -382,7 +383,7 @@ arrayList.add(5);
 arrayList.add(4);
 let result = arrayList.remove(2);
 try {
-  arraylist.remove.bind({}, 2)();
+  arraylist.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -424,12 +425,12 @@ arrayList.removeByRange(2, 4);
 arrayList.removeByRange(4, 3);
 arrayList.removeByRange(2, 6);
 try {
-  arraylist.removeByRange.bind({}, 2, 4)();
+  arraylist.removeByRange.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  arraylist.removeByRange(8, 4);
+  arraylist.removeByRange(8, 4); // 测试越界异常
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -484,7 +485,7 @@ arrayList.replaceAllElements((value: number, index: number) => {
 try {
   arraylist.replaceAllElements.bind({}, (value: number, index: number)=> {
     return value = 2 * value;
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -536,7 +537,7 @@ arrayList.forEach((value, index) => {
 try {
   arraylist.forEach.bind({}, (value, index) => {
     console.log(`value:${value}`, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -583,7 +584,7 @@ arrayList.sort((a: number, b: number) => a - b);
 arrayList.sort((a: number, b: number) => b - a);
 arrayList.sort();
 try {
-  arraylist.sort.bind({})();
+  arraylist.sort.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -631,7 +632,7 @@ let result1 = arrayList.subArrayList(2, 4);
 let result2 = arrayList.subArrayList(4, 3);
 let result3 = arrayList.subArrayList(2, 6);
 try {
-  arraylist.subArrayList.bind({}, 2, 4)();
+  arraylist.subArrayList.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -668,7 +669,7 @@ arrayList.add(5);
 arrayList.add(4);
 arrayList.clear();
 try {
-  arraylist.clear.bind({})();
+  arraylist.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -707,7 +708,7 @@ arrayList.add(5);
 arrayList.add(4);
 let result = arrayList.clone();
 try {
-  arraylist.clone.bind({})();
+  arraylist.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -745,7 +746,7 @@ arrayList.add(5);
 arrayList.add(4);
 let result = arrayList.getCapacity();
 try {
-  arraylist.getCapacity.bind({})();
+  arraylist.getCapacity.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -783,7 +784,7 @@ arrayList.add(5);
 arrayList.add(4);
 let result = arrayList.convertToArray();
 try {
-  arraylist.convertToArray.bind({})();
+  arraylist.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -821,7 +822,7 @@ arrayList.add(5);
 arrayList.add(4);
 let result = arrayList.isEmpty();
 try {
-  arraylist.isEmpty.bind({})();
+  arraylist.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -860,7 +861,7 @@ arrayList.add(4);
 arrayList.increaseCapacityTo(2);
 arrayList.increaseCapacityTo(8);
 try {
-  arraylist.increaseCapacityTo.bind({}, 5)();
+  arraylist.increaseCapacityTo.bind({}, 5)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -892,7 +893,7 @@ arrayList.add(5);
 arrayList.add(4);
 arrayList.trimToCurrentLength();
 try {
-  arraylist.trimToCurrentLength.bind({})();
+  arraylist.trimToCurrentLength.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -942,7 +943,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  arraylist[Symbol.iterator].bind({})();
+  arraylist[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-deque.md

@@ -88,9 +88,10 @@ deque.insertFront(1);
 let b = [1, 2, 3];
 deque.insertFront(b);
 let c = {name : "Dylon", age : "13"};
+deque.insertFront(c);
 deque.insertFront(false);
 try {
-  deque.insertFront.bind({}, "b")();
+  deque.insertFront.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -127,9 +128,10 @@ deque.insertEnd(1);
 let b = [1, 2, 3];
 deque.insertEnd(b);
 let c = {name : "Dylon", age : "13"};
+deque.insertEnd(c);
 deque.insertEnd(false);
 try {
-  deque.insertEnd.bind({}, "b")();
+  deque.insertEnd.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -171,7 +173,7 @@ let result = deque.has("squirrel");
 deque.insertFront("squirrel");
 let result1 = deque.has("squirrel");
 try {
-  deque.has.bind({}, "b")();
+  deque.has.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -210,7 +212,7 @@ deque.insertFront(2);
 deque.insertFront(4);
 let result = deque.popFirst();
 try {
-  deque.popFirst.bind({})();
+  deque.popFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -249,7 +251,7 @@ deque.insertFront(2);
 deque.insertFront(4);
 let result = deque.popLast();
 try {
-  deque.popLast.bind({})();
+  deque.popLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -301,7 +303,7 @@ deque.forEach((value, index) => {
 try {
   deque.forEach.bind({}, (value, index) => {
     console.log("value:" + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -339,7 +341,7 @@ deque.insertFront(5);
 deque.insertFront(4);
 let result = deque.getFirst();
 try {
-  deque.getFirst.bind({})();
+  deque.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -377,7 +379,7 @@ deque.insertFront(5);
 deque.insertFront(4);
 let result = deque.getLast();
 try {
-  deque.getLast.bind({})();
+  deque.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -426,7 +428,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  deque[Symbol.iterator].bind({})();
+  deque[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-hashmap.md

@@ -88,7 +88,7 @@ isEmpty(): boolean
 const hashMap = new HashMap();
 let result = hashMap.isEmpty();
 try {
-  hashMap.isEmpty.bind({})();
+  hashMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -131,7 +131,7 @@ let result = hashMap.hasKey("squirrel");
 hashMap.set("squirrel", 123);
 let result1 = hashMap.hasKey("squirrel");
 try {
-  hashMap.hasKey.bind({}, "squirrel")();
+  hashMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -174,7 +174,7 @@ let result = hashMap.hasValue(123);
 hashMap.set("squirrel", 123);
 let result1 = hashMap.hasValue(123);
 try {
-  hashMap.hasValue.bind({}, 123)();
+  hashMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -217,7 +217,7 @@ hashMap.set("squirrel", 123);
 hashMap.set("sparrow", 356);
 let result = hashMap.get("sparrow");
 try {
-  hashMap.get.bind({}, "sparrow")();
+  hashMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -255,7 +255,7 @@ hashMap.set("sparrow", 356);
 let newHashMap = new HashMap();
 hashMap.setAll(newHashMap);
 try {
-  hashMap.setAll.bind({}, newHashMap)();
+  hashMap.setAll.bind({}, newHashMap)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -297,7 +297,7 @@ set(key: K, value: V): Object
 let hashMap = new HashMap();
 let result = hashMap.set("squirrel", 123);
 try {
-  hashMap.set.bind({}, "squirrel", 123)();
+  hashMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -340,7 +340,7 @@ hashMap.set("squirrel", 123);
 hashMap.set("sparrow", 356);
 let result = hashMap.remove("sparrow");
 try {
-  hashMap.remove.bind({}, "sparrow")();
+  hashMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -371,7 +371,7 @@ hashMap.set("squirrel", 123);
 hashMap.set("sparrow", 356);
 hashMap.clear();
 try {
-  hashMap.clear.bind({})();
+  hashMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -413,7 +413,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashMap.keys.bind({})();
+  hashMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -455,7 +455,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashMap.values.bind({})();
+  hashMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -498,7 +498,7 @@ let hashMap = new HashMap();
 hashMap.set("sparrow", 123);
 let result = hashMap.replace("sparrow", 357);
 try {
-  hashMap.replace.bind({}, "sparrow", 357)();
+  hashMap.replace.bind({}, "sparrow", 357)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -547,7 +547,7 @@ hashMap.forEach((value, key) => {
 try {
   hashMap.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -590,7 +590,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashMap.entries.bind({})();
+  hashMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -640,7 +640,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashMap[Symbol.iterator].bind({})();
+  hashMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-hashset.md

@@ -96,7 +96,7 @@ isEmpty(): boolean
 const hashSet = new HashSet();
 let result = hashSet.isEmpty();
 try {
-  hashSet.isEmpty.bind({})();
+  hashSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -139,7 +139,7 @@ let result = hashSet.has("squirrel");
 hashSet.add("squirrel");
 let result1 = hashSet.has("squirrel");
 try {
-  hashSet.has.bind({}, "squirrel")();
+  hashSet.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -180,7 +180,7 @@ add(value: T): boolean
 let hashSet = new HashSet();
 let result = hashSet.add("squirrel");
 try {
-  hashSet.add.bind({}, "squirrel")();
+  hashSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -223,7 +223,7 @@ hashSet.add("squirrel");
 hashSet.add("sparrow");
 let result = hashSet.remove("sparrow");
 try {
-  hashSet.remove.bind({}, "sparrow")();
+  hashSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -254,7 +254,7 @@ hashSet.add("squirrel");
 hashSet.add("sparrow");
 hashSet.clear();
 try {
-  hashSet.remove.bind({})();
+  hashSet.remove.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -296,7 +296,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashSet.values.bind({})();
+  hashSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -345,7 +345,7 @@ hashSet.forEach((value, key) => {
 try {
   hashSet.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -387,7 +387,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashSet.entries.bind({})();
+  hashSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -436,7 +436,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  hashSet[Symbol.iterator].bind({})();
+  hashSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-lightweightmap.md

@@ -91,7 +91,7 @@ isEmpty(): boolean
 const lightWeightMap = new LightWeightMap();
 let result = lightWeightMap.isEmpty();
 try {
-  lightWeightMap.isEmpty.bind({})();
+  lightWeightMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -136,7 +136,7 @@ let map = new LightWeightMap();
 map.set("sparrow", 356);
 let result = lightWeightMap.hasAll(map);
 try {
-  lightWeightMap.hasAll.bind({}, map)();
+  lightWeightMap.hasAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -180,7 +180,7 @@ lightWeightMap.hasKey("squirrel");
 lightWeightMap.set("squirrel", 123);
 let result1 = lightWeightMap.hasKey("squirrel");
 try {
-  lightWeightMap.hasKey.bind({}, "squirrel")();
+  lightWeightMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -223,7 +223,7 @@ let result = lightWeightMap.hasValue(123);
 lightWeightMap.set("squirrel", 123);
 let result1 = lightWeightMap.hasValue(123);
 try {
-  lightWeightMap.hasValue.bind({}, 123)();
+  lightWeightMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -258,7 +258,7 @@ increaseCapacityTo(minimumCapacity: number): void
 let lightWeightMap = new LightWeightMap();
 lightWeightMap.increaseCapacityTo(10);
 try {
-  lightWeightMap.increaseCapacityTo.bind({}, 10)();
+  lightWeightMap.increaseCapacityTo.bind({}, 10)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -301,7 +301,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.get("sparrow");
 try {
-  lightWeightMap.get.bind({}, "sparrow")();
+  lightWeightMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -344,7 +344,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.getIndexOfKey("sparrow");
 try {
-  lightWeightMap.getIndexOfKey.bind({}, "sparrow")();
+  lightWeightMap.getIndexOfKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -387,7 +387,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.getIndexOfValue(123);
 try {
-  lightWeightMap.getIndexOfValue.bind({}, 123)();
+  lightWeightMap.getIndexOfValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -431,12 +431,12 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.getKeyAt(1);
 try {
-  lightWeightMap.getKeyAt.bind({}, 1)();
+  lightWeightMap.getKeyAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
 try {
-  lightWeightMap.getKeyAt(6)();
+  lightWeightMap.getKeyAt(6)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -474,7 +474,7 @@ lightWeightMap.set("sparrow", 356);
 let map = new LightWeightMap();
 lightWeightMap.setAll(map);
 try {
-  lightWeightMap.setAll.bind({}, map)();
+  lightWeightMap.setAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -515,7 +515,7 @@ set(key: K, value: V): Object
 let lightWeightMap = new LightWeightMap();
 let result = lightWeightMap.set("squirrel", 123);
 try {
-  lightWeightMap.set.bind({}, "squirrel", 123)();
+  lightWeightMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -558,7 +558,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 lightWeightMap.remove("sparrow");
 try {
-  lightWeightMap.remove.bind({}, "sparrow")();
+  lightWeightMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -601,7 +601,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.removeAt(1);
 try {
-  lightWeightMap.removeAt.bind({}, 1)();
+  lightWeightMap.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -646,7 +646,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 lightWeightMap.setValueAt(1, 3546);
 try {
-  lightWeightMap.setValueAt.bind({}, 1, 3546)();
+  lightWeightMap.setValueAt.bind({}, 1, 3546)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -695,7 +695,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let result = lightWeightMap.getValueAt(1);
 try {
-  lightWeightMap.getValueAt.bind({}, 1)();
+  lightWeightMap.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -731,7 +731,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 lightWeightMap.clear();
 try {
-  lightWeightMap.clear.bind({})();
+  lightWeightMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -773,7 +773,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  lightWeightMap.keys.bind({})();
+  lightWeightMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -815,7 +815,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  lightWeightMap.values.bind({})();
+  lightWeightMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -864,7 +864,7 @@ lightWeightMap.forEach((value, key) => {
 try {
   lightWeightMap.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -907,7 +907,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  lightWeightMap.entries.bind({})();
+  lightWeightMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -943,7 +943,7 @@ lightWeightMap.set("squirrel", 123);
 lightWeightMap.set("sparrow", 356);
 let iter = lightWeightMap.toString();
 try {
-  lightWeightMap.toString.bind({})();
+  lightWeightMap.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -993,7 +993,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  lightWeightMap[Symbol.iterator].bind({})();
+  lightWeightMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-lightweightset.md

@@ -91,7 +91,7 @@ isEmpty(): boolean
 const lightWeightSet = new LightWeightSet();
 let result = lightWeightSet.isEmpty();
 try {
-  lightWeightSet.isEmpty.bind({})();
+  lightWeightSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -131,7 +131,7 @@ add(obj: T): boolean
 let lightWeightSet = new LightWeightSet();
 let result = lightWeightSet.add("squirrel");
 try {
-  lightWeightSet.add.bind({}, "squirrel")();
+  lightWeightSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -170,7 +170,7 @@ let set = new LightWeightSet();
 set.add("gull");
 let result = lightWeightSet.addAll(set);
 try {
-  lightWeightSet.addAll.bind({}, set)();
+  lightWeightSet.addAll.bind({}, set)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -215,7 +215,7 @@ let set = new LightWeightSet();
 set.add("sparrow");
 let result = lightWeightSet.hasAll(set);
 try {
-  lightWeightSet.hasAll.bind({}, set)();
+  lightWeightSet.hasAll.bind({}, set)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -258,7 +258,7 @@ let result = lightWeightSet.has(123);
 lightWeightSet.add(123);
 result = lightWeightSet.has(123);
 try {
-  lightWeightSet.has.bind({}, 123)();
+  lightWeightSet.has.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -302,7 +302,7 @@ lightWeightSet.add("sparrow");
 let obj = ["squirrel", "sparrow"];
 let result = lightWeightSet.equal(obj);
 try {
-  lightWeightSet.equal.bind({}, obj)();
+  lightWeightSet.equal.bind({}, obj)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -338,7 +338,7 @@ increaseCapacityTo(minimumCapacity: number): void
 let lightWeightSet = new LightWeightSet();
 lightWeightSet.increaseCapacityTo(10);
 try {
-  lightWeightSet.increaseCapacityTo.bind({}, 10)();
+  lightWeightSet.increaseCapacityTo.bind({}, 10)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -386,7 +386,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.getIndexOf("sparrow");
 try {
-  lightWeightSet.getIndexOf.bind({}, "sparrow")();
+  lightWeightSet.getIndexOf.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -429,7 +429,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.remove("sparrow");
 try {
-  lightWeightSet.remove.bind({}, "sparrow")();
+  lightWeightSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -472,7 +472,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.removeAt(1);
 try {
-  lightWeightSet.removeAt.bind({}, 1)();
+  lightWeightSet.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -515,7 +515,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.getValueAt(1);
 try {
-  lightWeightSet.getValueAt.bind({}, 1)();
+  lightWeightSet.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -546,7 +546,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 lightWeightSet.clear();
 try {
-  lightWeightSet.clear.bind({})();
+  lightWeightSet.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -583,7 +583,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.toString();
 try {
-  lightWeightSet.toString.bind({})();
+  lightWeightSet.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -620,7 +620,7 @@ lightWeightSet.add("squirrel");
 lightWeightSet.add("sparrow");
 let result = lightWeightSet.toArray();
 try {
-  lightWeightSet.toArray.bind({})();
+  lightWeightSet.toArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -662,7 +662,7 @@ while(index < lightWeightSet.length) {
   index++;
 }
 try {
-  lightWeightSet.values.bind({})();
+  lightWeightSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -711,7 +711,7 @@ lightWeightSet.forEach((value, key) => {
 try {
   lightWeightSet.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -753,7 +753,7 @@ while(index < lightWeightSet.length) {
   index++;
 }
 try {
-  lightWeightSet.entries.bind({})();
+  lightWeightSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -802,7 +802,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  lightWeightSet[Symbol.iterator].bind({})();
+  lightWeightSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-linkedlist.md

@@ -98,11 +98,12 @@ let linkedList = new LinkedList();
 let result = linkedList.add("a");
 let result1 = linkedList.add(1);
 let b = [1, 2, 3];
-linkedList.add(b);
+let result2 = linkedList.add(b);
 let c = {name : "Dylon", age : "13"};
-let result3 = linkedList.add(false);
+let result3 = linkedList.add(c);
+let result4 = linkedList.add(false);
 try {
-  linkedList.add.bind({}, "b")();
+  linkedList.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -139,9 +140,10 @@ linkedList.addFirst(1);
 let b = [1, 2, 3];
 linkedList.addFirst(b);
 let c = {name : "Dylon", age : "13"};
+linkedList.addFirst(c);
 linkedList.addFirst(false);
 try {
-  linkedList.addFirst.bind({}, "b")();
+  linkedList.addFirst.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -179,7 +181,7 @@ linkedList.insert(0, "A");
 linkedList.insert(1, 0);
 linkedList.insert(2, true);
 try {
-  linkedList.insert.bind({}, 3, "b")();
+  linkedList.insert.bind({}, 3, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -226,7 +228,7 @@ let result1 = linkedList.has("squirrel");
 linkedList.add("squirrel");
 let result = linkedList.has("squirrel");
 try {
-  linkedList.has.bind({}, "squirrel")();
+  linkedList.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -273,7 +275,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.get(2);
 try {
-  linkedList.get.bind({}, 2)();
+  linkedList.get.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -320,7 +322,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.getLastIndexOf(2);
 try {
-  linkedList.getLastIndexOf.bind({}, 2)();
+  linkedList.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -367,7 +369,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.getIndexOf(2);
 try {
-  linkedList.getIndexOf.bind({}, 2)();
+  linkedList.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -413,7 +415,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.removeByIndex(2);
 try {
-  linkedList.removeByIndex.bind({}, 2)();
+  linkedList.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -463,7 +465,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.removeFirst();
 try {
-  linkedList.removeFirst.bind({})();
+  linkedList.removeFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -508,7 +510,7 @@ linkedList.add(2);
 linkedList.add(4);
 let result = linkedList.removeLast();
 try {
-  linkedList.removeLast.bind({})();
+  linkedList.removeLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -552,7 +554,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.remove(2);
 try {
-  linkedList.remove.bind({}, 2)();
+  linkedList.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -602,7 +604,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.removeFirstFound(4);
 try {
-  linkedList.removeFirstFound.bind({}, 2)();
+  linkedList.removeFirstFound.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -652,7 +654,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.removeLastFound(4);
 try {
-  linkedList.removeLastFound.bind({}, 4)();
+  linkedList.removeLastFound.bind({}, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -690,7 +692,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.clone();
 try {
-  linkedList.clone.bind({})();
+  linkedList.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -742,7 +744,7 @@ linkedList.forEach((value, index) => {
 try {
   linkedList.forEach.bind({}, (value, index) => {
     console.log("value:" + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -774,7 +776,7 @@ linkedList.add(5);
 linkedList.add(4);
 linkedList.clear();
 try {
-  linkedList.clear.bind({})();
+  linkedList.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -820,7 +822,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.set(2, "b");
 try {
-  linkedList.set.bind({}, 2, "b")();
+  linkedList.set.bind({}, 2, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -862,7 +864,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.convertToArray();
 try {
-  linkedList.convertToArray.bind({})();
+  linkedList.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -900,7 +902,7 @@ linkedList.add(5);
 linkedList.add(4);
 let result = linkedList.getFirst();
 try {
-  linkedList.getFirst.bind({})();
+  linkedList.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -938,7 +940,7 @@ linkedList.add(5);
 linkedList.add(4);
 linkedList.getLast();
 try {
-  linkedList.getLast.bind({})();
+  linkedList.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -988,7 +990,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  linkedList[Symbol.iterator].bind({})();
+  linkedList[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-list.md

@@ -90,14 +90,15 @@ add(element: T): boolean
 
 ```ts
 let list = new List();
-let result = list.add("a");
-let result1 = list.add(1);
+let result1 = list.add("a");
+let result2 = list.add(1);
 let b = [1, 2, 3];
-list.add(b);
+let result3 = list.add(b);
 let c = {name : "Dylon", age : "13"};
-let result3 = list.add(false);
+let result4 = list.add(c);
+let result5 = list.add(false);
 try {
-  list.add.bind({}, "b")();
+  list.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -135,7 +136,7 @@ list.insert("A", 0);
 list.insert(0, 1);
 list.insert(true, 2);
 try {
-  list.insert.bind({}, "b", 3)();
+  list.insert.bind({}, "b", 3)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -182,7 +183,7 @@ let result = list.has("squirrel");
 list.add("squirrel");
 let result1 = list.has("squirrel");
 try {
-  list.has.bind({}, "squirrel")();
+  list.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -229,7 +230,7 @@ list.add(2);
 list.add(4);
 let result = list.get(2);
 try {
-  list.get.bind({}, 2)();
+  list.get.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -276,7 +277,7 @@ list.add(2);
 list.add(4);
 let result = list.getLastIndexOf(2);
 try {
-  list.getLastIndexOf.bind({}, 2)();
+  list.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -324,7 +325,7 @@ list.add(4);
 list.getIndexOf(2);
 let result = list.getIndexOf(2);
 try {
-  list.getIndexOf.bind({}, 2)();
+  list.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -374,7 +375,7 @@ list.equal(obj1);
 let obj2 = {name : "Dylon", age : "13"};
 let result = list.equal(obj2);
 try {
-  list.equal.bind({}, obj2)();
+  list.equal.bind({}, obj2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -420,7 +421,7 @@ list.add(2);
 list.add(4);
 let result = list.removeByIndex(2);
 try {
-  list.removeByIndex.bind({}, 2)();
+  list.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -469,7 +470,7 @@ list.add(5);
 list.add(4);
 let result = list.remove(2);
 try {
-  list.remove.bind({}, 2)();
+  list.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -524,7 +525,7 @@ list.replaceAllElements((value: number, index: number) => {
 try {
   list.replaceAllElements.bind({}, (value: number, index: number) => {
     return value = 2 * value;
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -576,7 +577,7 @@ list.forEach((value, index) => {
 try {
   list.forEach.bind({}, (value, index) => {
     console.log("value: " + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -623,7 +624,7 @@ list.add(4);
 list.sort((a: number, b: number) => a - b);
 list.sort((a: number, b: number) => b - a);
 try {
-  list.sort.bind({}, (a: number, b: number) => b - a)();
+  list.sort.bind({}, (a: number, b: number) => b - a)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -671,7 +672,7 @@ let result = list.getSubList(2, 4);
 let result1 = list.getSubList(4, 3);
 let result2 = list.getSubList(2, 6);
 try {
-  list.getSubList.bind({}, 2, 4)();
+  list.getSubList.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -708,7 +709,7 @@ list.add(5);
 list.add(4);
 list.clear();
 try {
-  list.clear.bind({})();
+  list.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -754,7 +755,7 @@ list.add(5);
 list.add(4);
 list.set(2, "b");
 try {
-  list.set.bind({}, 3, "b")();
+  list.set.bind({}, 3, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -797,7 +798,7 @@ list.add(5);
 list.add(4);
 let result = list.convertToArray();
 try {
-  list.convertToArray.bind({})();
+  list.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -835,7 +836,7 @@ list.add(5);
 list.add(4);
 let result = list.isEmpty();
 try {
-  list.isEmpty.bind({})();
+  list.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -873,7 +874,7 @@ list.add(5);
 list.add(4);
 let result = list.getFirst();
 try {
-  list.getFirst.bind({})();
+  list.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -911,7 +912,7 @@ list.add(5);
 list.add(4);
 let result = list.getLast();
 try {
-  list.getLast.bind({})();
+  list.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -961,7 +962,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  list[Symbol.iterator].bind({})();
+  list[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-plainarray.md

@@ -89,7 +89,7 @@ isEmpty(): boolean
 const plainArray = new PlainArray();
 let result = plainArray.isEmpty();
 try {
-  plainArray.isEmpty.bind({})();
+  plainArray.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -132,7 +132,7 @@ plainArray.has(1);
 plainArray.add(1, "squirrel");
 let result1 = plainArray.has(1);
 try {
-  plainArray.has.bind({}, 1)();
+  plainArray.has.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -175,7 +175,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.get(1);
 try {
-  plainArray.get.bind({}, 1)();
+  plainArray.get.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -218,7 +218,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.getIndexOfKey(2);
 try {
-  plainArray.getIndexOfKey.bind({}, 2)();
+  plainArray.getIndexOfKey.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -261,7 +261,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.getIndexOfValue("squirrel");
 try {
-  plainArray.getIndexOfValue.bind({}, "squirrel")();
+  plainArray.getIndexOfValue.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -304,7 +304,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.getKeyAt(1);
 try {
-  plainArray.getKeyAt.bind({}, 1)();
+  plainArray.getKeyAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -347,7 +347,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.getValueAt(1);
 try {
-  plainArray.getValueAt.bind({}, 1)();
+  plainArray.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -388,7 +388,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let newPlainArray = plainArray.clone();
 try {
-  plainArray.clone.bind({})();
+  plainArray.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -424,7 +424,7 @@ add(key: number, value: T): void
 let plainArray = new PlainArray();
 plainArray.add(1, "squirrel");
 try {
-  plainArray.add.bind({}, "squirrel")();
+  plainArray.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -468,7 +468,7 @@ plainArray.add(2, "sparrow");
 plainArray.remove(2);
 let result = plainArray.remove(2);
 try {
-  plainArray.remove.bind({}, 2)();
+  plainArray.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -512,7 +512,7 @@ plainArray.add(2, "sparrow");
 plainArray.removeAt(1);
 let result = plainArray.removeAt(1);
 try {
-  plainArray.removeAt.bind({}, 1)();
+  plainArray.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -557,7 +557,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.removeRangeFrom(1, 3);
 try {
-  plainArray.removeRangeFrom.bind({}, 1, 3)();
+  plainArray.removeRangeFrom.bind({}, 1, 3)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -601,7 +601,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 plainArray.setValueAt(1, 3546);
 try {
-  plainArray.setValueAt.bind({}, 1, 3546)();
+  plainArray.setValueAt.bind({}, 1, 3546)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -643,7 +643,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 let result = plainArray.toString();
 try {
-  plainArray.toString.bind({})();
+  plainArray.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -674,7 +674,7 @@ plainArray.add(1, "squirrel");
 plainArray.add(2, "sparrow");
 plainArray.clear();
 try {
-  plainArray.clear.bind({})();
+  plainArray.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -723,7 +723,7 @@ plainArray.forEach((value, index) => {
 try {
   plainArray.forEach.bind({}, (value, index) => {
     console.log("value:" + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -774,7 +774,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  plainArray[Symbol.iterator].bind({})();
+  plainArray[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-queue.md

@@ -92,13 +92,12 @@ add(element: T): boolean
 let queue = new Queue();
 let result = queue.add("a");
 let result1 = queue.add(1);
-queue.add(1);
 let b = [1, 2, 3];
-queue.add(b);
+let result2 = queue.add(b);
 let c = {name : "Dylon", age : "13"};
 let result3 = queue.add(c);
 try {
-  queue.add.bind({}, "b")();
+  queue.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -137,7 +136,7 @@ queue.add(2);
 queue.add(4);
 let result = queue.pop();
 try {
-  queue.pop.bind({})();
+  queue.pop.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -175,7 +174,7 @@ queue.add(5);
 queue.add(2);
 let result = queue.getFirst();
 try {
-  queue.getFirst.bind({})();
+  queue.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -227,7 +226,7 @@ queue.forEach((value, index) => {
 try {
   queue.forEach.bind({}, (value, index) => {
     console.log("value:" + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -276,7 +275,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  queue[Symbol.iterator].bind({})();
+  queue[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-stack.md

@@ -95,11 +95,11 @@ let stack = new Stack();
 let result = stack.push("a");
 let result1 = stack.push(1);
 let b = [1, 2, 3];
-stack.push(b);
+let result2 = stack.push(b);
 let c = {name : "Dylon", age : "13"};
 let result3 = stack.push(c);
 try {
-  stack.push.bind({}, "b")();
+  stack.push.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -138,7 +138,7 @@ stack.push(2);
 stack.push(4);
 let result = stack.pop();
 try {
-  stack.pop.bind({})();
+  stack.pop.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -176,7 +176,7 @@ stack.push(5);
 stack.push(2);
 let result = stack.peek();
 try {
-  stack.peek.bind({})();
+  stack.peek.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -220,7 +220,7 @@ stack.push(5);
 stack.push(2);
 let result = stack.locate(2);
 try {
-  stack.locate.bind({}, 2)();
+  stack.locate.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -272,7 +272,7 @@ stack.forEach((value, index) => {
 try {
   stack.forEach.bind({}, (value, index) => {
     console.log("value:" + value, index);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -310,7 +310,7 @@ stack.push(5);
 stack.push(4);
 let result = stack.isEmpty();
 try {
-  stack.isEmpty.bind({})();
+  stack.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -359,7 +359,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  stack[Symbol.iterator].bind({})();
+  stack[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-treemap.md

@@ -94,7 +94,7 @@ isEmpty(): boolean
 const treeMap = new TreeMap();
 let result = treeMap.isEmpty();
 try {
-  treeMap.isEmpty.bind({})();
+  treeMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -137,7 +137,7 @@ let result = treeMap.hasKey("squirrel");
 treeMap.set("squirrel", 123);
 let result1 = treeMap.hasKey("squirrel");
 try {
-  treeMap.hasKey.bind({}, "squirrel")();
+  treeMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -180,7 +180,7 @@ let result = treeMap.hasValue(123);
 treeMap.set("squirrel", 123);
 let result1 = treeMap.hasValue(123);
 try {
-  treeMap.hasValue.bind({}, 123)();
+  treeMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -223,7 +223,7 @@ treeMap.set("squirrel", 123);
 treeMap.set("sparrow", 356);
 let result = treeMap.get("sparrow");
 try {
-  treeMap.get.bind({}, "sparrow")();
+  treeMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -260,7 +260,7 @@ treeMap.set("squirrel", 123);
 treeMap.set("sparrow", 356);
 let result = treeMap.getFirstKey();
 try {
-  treeMap.getFirstKey.bind({})();
+  treeMap.getFirstKey.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -297,7 +297,7 @@ treeMap.set("squirrel", 123);
 treeMap.set("sparrow", 356);
 let result = treeMap.getLastKey();
 try {
-  treeMap.getLastKey.bind({})();
+  treeMap.getLastKey.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -335,7 +335,7 @@ treeMap.set("sparrow", 356);
 let map = new TreeMap();
 treeMap.setAll(map);
 try {
-  treeMap.setAll.bind({}, map)();
+  treeMap.setAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -377,7 +377,7 @@ set(key: K, value: V): Object
 let treeMap = new TreeMap();
 treeMap.set("squirrel", 123);
 try {
-  treeMap.set.bind({}, "squirrel", 123)();
+  treeMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -420,7 +420,7 @@ treeMap.set("squirrel", 123);
 treeMap.set("sparrow", 356);
 treeMap.remove("sparrow");
 try {
-  treeMap.remove.bind({}, "sparrow")();
+  treeMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -464,7 +464,7 @@ treeMap.set("sparrow", 356);
 treeMap.set("gander", 356);
 let result = treeMap.getLowerKey("sparrow");
 try {
-  treeMap.getLowerKey.bind({}, "sparrow")();
+  treeMap.getLowerKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -508,7 +508,7 @@ treeMap.set("sparrow", 356);
 treeMap.set("gander", 356);
 let result = treeMap.getHigherKey("sparrow");
 try {
-  treeMap.getHigherKey.bind({}, "sparrow")();
+  treeMap.getHigherKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -550,7 +550,7 @@ let treeMap = new TreeMap();
 treeMap.set("sparrow", 123);
 let result = treeMap.replace("sparrow", 357);
 try {
-  treeMap.replace.bind({}, "sparrow", 357)();
+  treeMap.replace.bind({}, "sparrow", 357)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -581,7 +581,7 @@ treeMap.set("squirrel", 123);
 treeMap.set("sparrow", 356);
 treeMap.clear();
 try {
-  treeMap.clear.bind({})();
+  treeMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -623,7 +623,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeMap.keys.bind({})();
+  treeMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -665,7 +665,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeMap.values.bind({})();
+  treeMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -714,7 +714,7 @@ treeMap.forEach((value, key) => {
 try {
   treeMap.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key);
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -757,7 +757,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeMap.entries.bind({})();
+  treeMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -807,7 +807,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeMap[Symbol.iterator].bind({})();
+  treeMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-treeset.md

@@ -83,7 +83,7 @@ isEmpty(): boolean
 const treeSet = new TreeSet();
 let result = treeSet.isEmpty();
 try {
-  treeSet.isEmpty.bind({})();
+  treeSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -118,7 +118,7 @@ treeSet.has(123);
 treeSet.add(123);
 let result1 = treeSet.has(123);
 try {
-  treeSet.has.bind({}, 123)();
+  treeSet.has.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -147,7 +147,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 let result = treeSet.getFirstValue();
 try {
-  treeSet.getFirstValue.bind({})();
+  treeSet.getFirstValue.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -176,7 +176,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 let result = treeSet.getLastValue();
 try {
-  treeSet.getLastValue.bind({})();
+  treeSet.getLastValue.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -209,7 +209,7 @@ add(value: T): boolean
 let treeSet = new TreeSet();
 let result = treeSet.add("squirrel");
 try {
-  treeSet.add.bind({}, "squirrel")();
+  treeSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -244,7 +244,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 let result = treeSet.remove("sparrow");
 try {
-  treeSet.remove.bind({}, "sparrow")();
+  treeSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -280,7 +280,7 @@ treeSet.add("sparrow");
 treeSet.add("gander");
 let result = treeSet.getLowerValue("sparrow");
 try {
-  treeSet.getLowerValue.bind({}, "sparrow")();
+  treeSet.getLowerValue.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -316,7 +316,7 @@ treeSet.add("sparrow");
 treeSet.add("gander");
 let result = treeSet.getHigherValue("sparrow");
 try {
-  treeSet.getHigherValue.bind({}, "sparrow")();
+  treeSet.getHigherValue.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -345,7 +345,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 let result = treeSet.popFirst();
 try {
-  treeSet.popFirst.bind({})();
+  treeSet.popFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -374,7 +374,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 let result = treeSet.popLast();
 try {
-  treeSet.popLast.bind({})();
+  treeSet.popLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -397,7 +397,7 @@ treeSet.add("squirrel");
 treeSet.add("sparrow");
 treeSet.clear();
 try {
-  treeSet.clear.bind({})();
+  treeSet.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -431,7 +431,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeSet.values.bind({})();
+  treeSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -472,7 +472,7 @@ treeSet.forEach((value, key) => {
 try {
   treeSet.forEach.bind({}, (value, key) => {
     console.log("value:" + value, key)
-  })();
+  })(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -507,7 +507,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeSet.entries.bind({})();
+  treeSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }
@@ -548,7 +548,7 @@ while(temp != undefined) {
   temp = iter.next().value;
 }
 try {
-  treeSet[Symbol.iterator].bind({})();
+  treeSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
 } catch(err) {
   console.log(`${err.code} - ${err.name} - ${err.message}`);
 }

zh-cn/application-dev/reference/apis/js-apis-vector.md

@@ -72,7 +72,7 @@ let vector = new Vector();
 let result = vector.add("a");
 let result1 = vector.add(1);
 let b = [1, 2, 3];
-vector.add(b);
+let result2 = vector.add(b);
 let c = {name : "Dylon", age : "13"};
 let result3 = vector.add(c);
 ```
@@ -285,7 +285,6 @@ vector.add(4);
 vector.add(5);
 vector.add(4);
 vector.removeByRange(2,4);
-vector.removeByRange(4,3);
 vector.removeByRange(2,6);
 ```
 
@@ -430,9 +429,10 @@ vector.add(2);
 vector.add(4);
 vector.add(5);
 vector.add(4);
-let result = vector.subVector(2,4);
-let result1 = vector.subVector(4,3);
-let result2 = vector.subVector(2,6);
+vector.add(6);
+vector.add(8);
+let result = vector.subVector(0,4);
+let result1 = vector.subVector(2,4);
 
 ```