Skip to content

D
Docs

(_灬幸福相伴 / Docs
与 Fork 源项目一致

Fork自 OpenHarmony / Docs

通知 1
Star 1
Fork 0
D
Docs

体验新版 GitCode，发现更多精彩内容 >>

未验证 提交 6a34fa72 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!11950 delete container and buffer exception cases 

Merge pull request !11950 from 刘甘霖/master
上级 fa9e8009 65734762
展开全部 隐藏空白更改
内联 并排
Showing with 39 addition and 1739 deletion
zh-cn/application-dev/reference/apis/js-apis-arraylist.md
浏览文件 @ 6a34fa72
......@@ -51,11 +51,6 @@ ArrayList的构造函数。
```ts
let arrayList = new ArrayList();
try {
let arrayList2 = ArrayList();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -89,21 +84,16 @@ add(element: T): boolean
**示例：**
```ts
let arrayList = new ArrayList();
let result = arrayList.add("a");
let result1 = arrayList.add(1);
let b = [1, 2, 3];
let result2 = arrayList.add(b);
let c = {name: "Dylon", age: "13"};
let result3 = arrayList.add(c);
let result4 = arrayList.add(false);
try {
arrayList.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
```ts
let arrayList = new ArrayList();
let result = arrayList.add("a");
let result1 = arrayList.add(1);
let b = [1, 2, 3];
let result2 = arrayList.add(b);
let c = {name: "Dylon", age: "13"};
let result3 = arrayList.add(c);
let result4 = arrayList.add(false);
```
### insert
......@@ -136,21 +126,6 @@ let arrayList = new ArrayList();
arrayList.insert("A", 0);
arrayList.insert(0, 1);
arrayList.insert(true, 2);
try {
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); // 测试越界异常
} catch (err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
let res = arrayList.insert("a", "b"); // 测试类型异常
} catch (err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### has
......@@ -188,11 +163,6 @@ let arrayList = new ArrayList();
let result = arrayList.has("squirrel");
arrayList.add("squirrel");
let result1 = arrayList.has("squirrel");
try {
arrayList.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getIndexOf
......@@ -235,11 +205,6 @@ arrayList.add(1);
arrayList.add(2);
arrayList.add(4);
let result = arrayList.getIndexOf(2);
try {
arrayList.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLastIndexOf
......@@ -282,11 +247,6 @@ arrayList.add(1);
arrayList.add(2);
arrayList.add(4);
let result = arrayList.getLastIndexOf(2);
try {
arrayList.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeByIndex
......@@ -328,21 +288,6 @@ arrayList.add(5);
arrayList.add(2);
arrayList.add(4);
let result = arrayList.removeByIndex(2);
try {
arrayList.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
arrayList.removeByIndex("a"); // 测试类型异常
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
arrayList.removeByIndex(8); // 测试越界异常
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### remove
......@@ -382,11 +327,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
let result = arrayList.remove(2);
try {
arrayList.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeByRange
......@@ -422,16 +362,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
arrayList.removeByRange(2, 4);
try {
arrayList.removeByRange.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
arrayList.removeByRange(8, 4); // 测试越界异常
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### replaceAllElements
......@@ -480,13 +410,6 @@ arrayList.replaceAllElements((value: number, index: number)=> {
arrayList.replaceAllElements((value: number, index: number) => {
return value = value - 2;
});
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}`);
}
```
### forEach
......@@ -532,13 +455,6 @@ arrayList.add(4);
arrayList.forEach((value, index) => {
console.log(`value:${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}`);
}
```
### sort
......@@ -581,11 +497,6 @@ arrayList.add(4);
arrayList.sort((a: number, b: number) => a - b);
arrayList.sort((a: number, b: number) => b - a);
arrayList.sort();
try {
arrayList.sort.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### subArrayList
......@@ -629,16 +540,6 @@ arrayList.add(4);
let result1 = arrayList.subArrayList(2, 4);
let result2 = arrayList.subArrayList(4, 3);
let result3 = arrayList.subArrayList(2, 6);
try {
arrayList.subArrayList.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
arrayList.subArrayList(6, 4);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### clear
......@@ -666,11 +567,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
arrayList.clear();
try {
arrayList.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### clone
......@@ -705,11 +601,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
let result = arrayList.clone();
try {
arrayList.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getCapacity
......@@ -743,11 +634,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
let result = arrayList.getCapacity();
try {
arrayList.getCapacity.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### convertToArray
......@@ -781,11 +667,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
let result = arrayList.convertToArray();
try {
arrayList.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### isEmpty
......@@ -819,11 +700,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
let result = arrayList.isEmpty();
try {
arrayList.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### increaseCapacityTo
......@@ -858,11 +734,6 @@ arrayList.add(5);
arrayList.add(4);
arrayList.increaseCapacityTo(2);
arrayList.increaseCapacityTo(8);
try {
arrayList.increaseCapacityTo.bind({}, 5)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### trimToCurrentLength
......@@ -890,11 +761,6 @@ arrayList.add(4);
arrayList.add(5);
arrayList.add(4);
arrayList.trimToCurrentLength();
try {
arrayList.trimToCurrentLength.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -940,9 +806,4 @@ while(temp != undefined) {
console.log(`value:${temp}`);
temp = iter.next().value;
}
try {
arrayList[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-deque.md
浏览文件 @ 6a34fa72
......@@ -50,11 +50,6 @@ Deque的构造函数。
```ts
let deque = new Deque();
try {
let deque2 = Deque();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### insertFront
......@@ -90,11 +85,6 @@ deque.insertFront(b);
let c = {name : "Dylon", age : "13"};
deque.insertFront(c);
deque.insertFront(false);
try {
deque.insertFront.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### insertEnd
......@@ -130,11 +120,6 @@ deque.insertEnd(b);
let c = {name : "Dylon", age : "13"};
deque.insertEnd(c);
deque.insertEnd(false);
try {
deque.insertEnd.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### has
......@@ -172,11 +157,6 @@ let deque = new Deque();
let result = deque.has("squirrel");
deque.insertFront("squirrel");
let result1 = deque.has("squirrel");
try {
deque.has.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### popFirst
......@@ -211,11 +191,6 @@ deque.insertEnd(5);
deque.insertFront(2);
deque.insertFront(4);
let result = deque.popFirst();
try {
deque.popFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### popLast
......@@ -250,11 +225,6 @@ deque.insertFront(5);
deque.insertFront(2);
deque.insertFront(4);
let result = deque.popLast();
try {
deque.popLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### forEach
......@@ -300,13 +270,6 @@ deque.insertEnd(4);
deque.forEach((value, index) => {
console.log("value:" + 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}`);
}
```
### getFirst
......@@ -340,11 +303,6 @@ deque.insertEnd(4);
deque.insertFront(5);
deque.insertFront(4);
let result = deque.getFirst();
try {
deque.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLast
......@@ -378,11 +336,6 @@ deque.insertFront(4);
deque.insertFront(5);
deque.insertFront(4);
let result = deque.getLast();
try {
deque.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -427,9 +380,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
deque[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-hashmap.md
浏览文件 @ 6a34fa72
......@@ -52,11 +52,6 @@ HashMap的构造函数。
```ts
let hashMap = new HashMap();
try {
let hashMap2 = HashMap();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -87,11 +82,6 @@ isEmpty(): boolean
```ts
const hashMap = new HashMap();
let result = hashMap.isEmpty();
try {
hashMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -130,11 +120,6 @@ let hashMap = new HashMap();
let result = hashMap.hasKey("squirrel");
hashMap.set("squirrel", 123);
let result1 = hashMap.hasKey("squirrel");
try {
hashMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -173,11 +158,6 @@ let hashMap = new HashMap();
let result = hashMap.hasValue(123);
hashMap.set("squirrel", 123);
let result1 = hashMap.hasValue(123);
try {
hashMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -216,11 +196,6 @@ let hashMap = new HashMap();
hashMap.set("squirrel", 123);
hashMap.set("sparrow", 356);
let result = hashMap.get("sparrow");
try {
hashMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -254,11 +229,6 @@ hashMap.set("squirrel", 123);
hashMap.set("sparrow", 356);
let newHashMap = new HashMap();
hashMap.setAll(newHashMap);
try {
hashMap.setAll.bind({}, newHashMap)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -296,11 +266,6 @@ set(key: K, value: V): Object
```ts
let hashMap = new HashMap();
let result = hashMap.set("squirrel", 123);
try {
hashMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -339,11 +304,6 @@ let hashMap = new HashMap();
hashMap.set("squirrel", 123);
hashMap.set("sparrow", 356);
let result = hashMap.remove("sparrow");
try {
hashMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -370,11 +330,6 @@ let hashMap = new HashMap();
hashMap.set("squirrel", 123);
hashMap.set("sparrow", 356);
hashMap.clear();
try {
hashMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -412,11 +367,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
hashMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -454,11 +404,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
hashMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -497,11 +442,6 @@ replace(key: K, newValue: V): boolean
let hashMap = new HashMap();
hashMap.set("sparrow", 123);
let result = hashMap.replace("sparrow", 357);
try {
hashMap.replace.bind({}, "sparrow", 357)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -544,13 +484,6 @@ hashMap.set("gull", 357);
hashMap.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -589,11 +522,6 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
hashMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -639,9 +567,4 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
hashMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-hashset.md
浏览文件 @ 6a34fa72
......@@ -60,11 +60,6 @@ HashSet的构造函数。
```ts
let hashSet = new HashSet();
try {
let hashSet2 = HashSet();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -95,11 +90,6 @@ isEmpty(): boolean
```ts
const hashSet = new HashSet();
let result = hashSet.isEmpty();
try {
hashSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -138,11 +128,6 @@ let hashSet = new HashSet();
let result = hashSet.has("squirrel");
hashSet.add("squirrel");
let result1 = hashSet.has("squirrel");
try {
hashSet.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -179,11 +164,6 @@ add(value: T): boolean
```ts
let hashSet = new HashSet();
let result = hashSet.add("squirrel");
try {
hashSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -222,11 +202,6 @@ let hashSet = new HashSet();
hashSet.add("squirrel");
hashSet.add("sparrow");
let result = hashSet.remove("sparrow");
try {
hashSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -253,11 +228,6 @@ let hashSet = new HashSet();
hashSet.add("squirrel");
hashSet.add("sparrow");
hashSet.clear();
try {
hashSet.remove.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -295,11 +265,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
hashSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -342,13 +307,6 @@ hashSet.add("squirrel");
hashSet.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -386,11 +344,6 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
hashSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -435,9 +388,4 @@ while(temp != undefined) {
console.log("value: " + temp);
temp = iter.next().value;
}
try {
hashSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-lightweightmap.md
浏览文件 @ 6a34fa72
......@@ -21,8 +21,6 @@ LightWeightMap和[HashMap](js-apis-hashmap.md)都是用来存储键值对的集
import LightWeightMap from '@ohos.util.LightWeightMap';
```
## LightWeightMap
### 属性
......@@ -55,11 +53,6 @@ LightWeightMap的构造函数。
```ts
let lightWeightMap = new LightWeightMap();
try {
let lightWeightMap2 = LightWeightMap();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -90,11 +83,6 @@ isEmpty(): boolean
```ts
const lightWeightMap = new LightWeightMap();
let result = lightWeightMap.isEmpty();
try {
lightWeightMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -135,11 +123,6 @@ lightWeightMap.set("sparrow", 356);
let map = new LightWeightMap();
map.set("sparrow", 356);
let result = lightWeightMap.hasAll(map);
try {
lightWeightMap.hasAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -179,11 +162,6 @@ let result = lightWeightMap.hasKey;
lightWeightMap.hasKey("squirrel");
lightWeightMap.set("squirrel", 123);
let result1 = lightWeightMap.hasKey("squirrel");
try {
lightWeightMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -222,11 +200,6 @@ let lightWeightMap = new LightWeightMap();
let result = lightWeightMap.hasValue(123);
lightWeightMap.set("squirrel", 123);
let result1 = lightWeightMap.hasValue(123);
try {
lightWeightMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -257,11 +230,6 @@ increaseCapacityTo(minimumCapacity: number): void
```ts
let lightWeightMap = new LightWeightMap();
lightWeightMap.increaseCapacityTo(10);
try {
lightWeightMap.increaseCapacityTo.bind({}, 10)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -300,11 +268,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.get("sparrow");
try {
lightWeightMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -343,11 +306,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.getIndexOfKey("sparrow");
try {
lightWeightMap.getIndexOfKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -386,11 +344,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.getIndexOfValue(123);
try {
lightWeightMap.getIndexOfValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -430,16 +383,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.getKeyAt(1);
try {
lightWeightMap.getKeyAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
lightWeightMap.getKeyAt(6)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -473,11 +416,6 @@ lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let map = new LightWeightMap();
lightWeightMap.setAll(map);
try {
lightWeightMap.setAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -514,11 +452,6 @@ set(key: K, value: V): Object
```ts
let lightWeightMap = new LightWeightMap();
let result = lightWeightMap.set("squirrel", 123);
try {
lightWeightMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -557,11 +490,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
lightWeightMap.remove("sparrow");
try {
lightWeightMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -600,11 +528,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.removeAt(1);
try {
lightWeightMap.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -645,16 +568,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
lightWeightMap.setValueAt(1, 3546);
try {
lightWeightMap.setValueAt.bind({}, 1, 3546)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
lightWeightMap.setValueAt(6, 3546);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -694,16 +607,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let result = lightWeightMap.getValueAt(1);
try {
lightWeightMap.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
lightWeightMap.getValueAt(6);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -730,11 +633,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
lightWeightMap.clear();
try {
lightWeightMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -772,11 +670,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
lightWeightMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -814,11 +707,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
lightWeightMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -861,13 +749,6 @@ lightWeightMap.set("gull", 357);
lightWeightMap.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -906,11 +787,6 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
lightWeightMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### toString
......@@ -942,11 +818,6 @@ let lightWeightMap = new LightWeightMap();
lightWeightMap.set("squirrel", 123);
lightWeightMap.set("sparrow", 356);
let iter = lightWeightMap.toString();
try {
lightWeightMap.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -992,9 +863,4 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
lightWeightMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-lightweightset.md
浏览文件 @ 6a34fa72
......@@ -22,8 +22,6 @@ LightWeightSet和[HashSet](js-apis-hashset.md)都是用来存储键值的集合
import LightWeightSet from '@ohos.util.LightWeightSet';
```
## LightWeightSet
### 属性
......@@ -55,11 +53,6 @@ LightWeightSet的构造函数。
```ts
let lightWeightSet = new LightWeightSet();
try {
let lightWeightSet2 = LightWeightSet();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -90,11 +83,6 @@ isEmpty(): boolean
```ts
const lightWeightSet = new LightWeightSet();
let result = lightWeightSet.isEmpty();
try {
lightWeightSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### add
......@@ -130,11 +118,6 @@ add(obj: T): boolean
```ts
let lightWeightSet = new LightWeightSet();
let result = lightWeightSet.add("squirrel");
try {
lightWeightSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -169,11 +152,6 @@ lightWeightSet.add("sparrow");
let set = new LightWeightSet();
set.add("gull");
let result = lightWeightSet.addAll(set);
try {
lightWeightSet.addAll.bind({}, set)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -214,11 +192,6 @@ lightWeightSet.add("sparrow");
let set = new LightWeightSet();
set.add("sparrow");
let result = lightWeightSet.hasAll(set);
try {
lightWeightSet.hasAll.bind({}, set)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -257,11 +230,6 @@ let lightWeightSet = new LightWeightSet();
let result = lightWeightSet.has(123);
lightWeightSet.add(123);
result = lightWeightSet.has(123);
try {
lightWeightSet.has.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -301,11 +269,6 @@ lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let obj = ["squirrel", "sparrow"];
let result = lightWeightSet.equal(obj);
try {
lightWeightSet.equal.bind({}, obj)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -337,16 +300,6 @@ increaseCapacityTo(minimumCapacity: number): void
```ts
let lightWeightSet = new LightWeightSet();
lightWeightSet.increaseCapacityTo(10);
try {
lightWeightSet.increaseCapacityTo.bind({}, 10)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
lightWeightSet.increaseCapacityTo(2);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -385,11 +338,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.getIndexOf("sparrow");
try {
lightWeightSet.getIndexOf.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -428,11 +376,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.remove("sparrow");
try {
lightWeightSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -471,11 +414,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.removeAt(1);
try {
lightWeightSet.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -514,11 +452,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.getValueAt(1);
try {
lightWeightSet.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -545,11 +478,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
lightWeightSet.clear();
try {
lightWeightSet.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -582,11 +510,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.toString();
try {
lightWeightSet.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -619,11 +542,6 @@ let lightWeightSet = new LightWeightSet();
lightWeightSet.add("squirrel");
lightWeightSet.add("sparrow");
let result = lightWeightSet.toArray();
try {
lightWeightSet.toArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -661,11 +579,6 @@ while(index < lightWeightSet.length) {
console.log(JSON.stringify(iter.next().value));
index++;
}
try {
lightWeightSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -708,13 +621,6 @@ lightWeightSet.add("gull");
lightWeightSet.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -752,11 +658,6 @@ while(index < lightWeightSet.length) {
console.log(JSON.stringify(iter.next().value));
index++;
}
try {
lightWeightSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -801,9 +702,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
lightWeightSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-linkedlist.md
浏览文件 @ 6a34fa72
......@@ -20,9 +20,6 @@ LinkedList和[ArrayList](js-apis-arraylist.md)相比，存取数据的效率不
import LinkedList from '@ohos.util.LinkedList';
```
## LinkedList
### 属性
......@@ -55,11 +52,6 @@ LinkedList的构造函数。
```ts
let linkedList = new LinkedList();
try {
let linkedList2 = LinkedList();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -102,11 +94,6 @@ let result2 = linkedList.add(b);
let c = {name : "Dylon", age : "13"};
let result3 = linkedList.add(c);
let result4 = linkedList.add(false);
try {
linkedList.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### addFirst
......@@ -142,11 +129,6 @@ linkedList.addFirst(b);
let c = {name : "Dylon", age : "13"};
linkedList.addFirst(c);
linkedList.addFirst(false);
try {
linkedList.addFirst.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### insert
......@@ -180,16 +162,6 @@ let linkedList = new LinkedList();
linkedList.insert(0, "A");
linkedList.insert(1, 0);
linkedList.insert(2, true);
try {
linkedList.insert.bind({}, 3, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
linkedList.insert(6, "b");
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### has
......@@ -227,11 +199,6 @@ let linkedList = new LinkedList();
let result1 = linkedList.has("squirrel");
linkedList.add("squirrel");
let result = linkedList.has("squirrel");
try {
linkedList.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### get
......@@ -274,11 +241,6 @@ linkedList.add(1);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.get(2);
try {
linkedList.get.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLastIndexOf
......@@ -321,11 +283,6 @@ linkedList.add(1);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.getLastIndexOf(2);
try {
linkedList.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getIndexOf
......@@ -368,11 +325,6 @@ linkedList.add(1);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.getIndexOf(2);
try {
linkedList.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeByIndex
......@@ -414,16 +366,6 @@ linkedList.add(5);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.removeByIndex(2);
try {
linkedList.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
linkedList.removeByIndex(8);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeFirst
......@@ -453,22 +395,12 @@ removeFirst(): T
```ts
let linkedList = new LinkedList();
try {
linkedList.removeFirst();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
linkedList.add(2);
linkedList.add(4);
linkedList.add(5);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.removeFirst();
try {
linkedList.removeFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeLast
......@@ -498,22 +430,12 @@ removeLast(): T
```ts
let linkedList = new LinkedList();
try {
linkedList.removeLast();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
linkedList.add(2);
linkedList.add(4);
linkedList.add(5);
linkedList.add(2);
linkedList.add(4);
let result = linkedList.removeLast();
try {
linkedList.removeLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### remove
......@@ -553,11 +475,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.remove(2);
try {
linkedList.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeFirstFound
......@@ -593,21 +510,11 @@ removeFirstFound(element: T): boolean
```ts
let linkedList = new LinkedList();
try {
linkedList.removeFirstFound(4);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
linkedList.add(2);
linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.removeFirstFound(4);
try {
linkedList.removeFirstFound.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeLastFound
......@@ -643,21 +550,11 @@ removeLastFound(element: T): boolean
```ts
let linkedList = new LinkedList();
try {
linkedList.removeLastFound();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
linkedList.add(2);
linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.removeLastFound(4);
try {
linkedList.removeLastFound.bind({}, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### clone
......@@ -691,11 +588,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.clone();
try {
linkedList.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### forEach
......@@ -741,13 +633,6 @@ linkedList.add(4);
linkedList.forEach((value, index) => {
console.log("value:" + 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}`);
}
```
### clear
......@@ -775,11 +660,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
linkedList.clear();
try {
linkedList.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### set
......@@ -821,16 +701,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.set(2, "b");
try {
linkedList.set.bind({}, 2, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
linkedList.set(8, "b");
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### convertToArray
......@@ -863,11 +733,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.convertToArray();
try {
linkedList.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getFirst
......@@ -901,11 +766,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
let result = linkedList.getFirst();
try {
linkedList.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLast
......@@ -939,11 +799,6 @@ linkedList.add(4);
linkedList.add(5);
linkedList.add(4);
linkedList.getLast();
try {
linkedList.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -989,9 +844,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
linkedList[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-list.md
浏览文件 @ 6a34fa72
......@@ -50,11 +50,6 @@ List的构造函数。
```ts
let list = new List();
try {
let list2 = List();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -97,11 +92,6 @@ let result3 = list.add(b);
let c = {name : "Dylon", age : "13"};
let result4 = list.add(c);
let result5 = list.add(false);
try {
list.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### insert
......@@ -135,16 +125,6 @@ let list = new List();
list.insert("A", 0);
list.insert(0, 1);
list.insert(true, 2);
try {
list.insert.bind({}, "b", 3)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
list.insert("b", 6);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### has
......@@ -182,11 +162,6 @@ let list = new List();
let result = list.has("squirrel");
list.add("squirrel");
let result1 = list.has("squirrel");
try {
list.has.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### get
......@@ -229,11 +204,6 @@ list.add(1);
list.add(2);
list.add(4);
let result = list.get(2);
try {
list.get.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLastIndexOf
......@@ -276,11 +246,6 @@ list.add(1);
list.add(2);
list.add(4);
let result = list.getLastIndexOf(2);
try {
list.getLastIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getIndexOf
......@@ -324,11 +289,6 @@ list.add(2);
list.add(4);
list.getIndexOf(2);
let result = list.getIndexOf(2);
try {
list.getIndexOf.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### equal
......@@ -374,11 +334,6 @@ obj1.add(5);
list.equal(obj1);
let obj2 = {name : "Dylon", age : "13"};
let result = list.equal(obj2);
try {
list.equal.bind({}, obj2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### removeByIndex
......@@ -420,16 +375,6 @@ list.add(5);
list.add(2);
list.add(4);
let result = list.removeByIndex(2);
try {
list.removeByIndex.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
list.removeByIndex(8);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### remove
......@@ -469,11 +414,6 @@ list.add(4);
list.add(5);
list.add(4);
let result = list.remove(2);
try {
list.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### replaceAllElements
......@@ -522,13 +462,6 @@ list.replaceAllElements((value: number, index: number) => {
list.replaceAllElements((value: number, index: number) => {
return value = value - 2;
});
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}`);
}
```
### forEach
......@@ -574,14 +507,6 @@ list.add(4);
list.forEach((value, index) => {
console.log("value: " + 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}`);
}
```
### sort
......@@ -623,11 +548,6 @@ list.add(5);
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)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getSubList
......@@ -671,16 +591,6 @@ list.add(4);
let result = list.getSubList(2, 4);
let result1 = list.getSubList(4, 3);
let result2 = list.getSubList(2, 6);
try {
list.getSubList.bind({}, 2, 4)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
list.getSubList(2, 10);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### clear
......@@ -708,11 +618,6 @@ list.add(4);
list.add(5);
list.add(4);
list.clear();
try {
list.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### set
......@@ -754,16 +659,6 @@ list.add(4);
list.add(5);
list.add(4);
list.set(2, "b");
try {
list.set.bind({}, 3, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
list.set(8, "b");
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### convertToArray
......@@ -797,11 +692,6 @@ list.add(4);
list.add(5);
list.add(4);
let result = list.convertToArray();
try {
list.convertToArray.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### isEmpty
......@@ -835,11 +725,6 @@ list.add(4);
list.add(5);
list.add(4);
let result = list.isEmpty();
try {
list.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getFirst
......@@ -873,11 +758,6 @@ list.add(4);
list.add(5);
list.add(4);
let result = list.getFirst();
try {
list.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getLast
......@@ -911,11 +791,6 @@ list.add(4);
list.add(5);
list.add(4);
let result = list.getLast();
try {
list.getLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -961,9 +836,4 @@ while(temp != undefined) {
console.log("value: " + temp);
temp = iter.next().value;
}
try {
list[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-plainarray.md
浏览文件 @ 6a34fa72
......@@ -53,11 +53,6 @@ PlainArray的构造函数。
```ts
let plainArray = new PlainArray();
try {
let plainArray2 = PlainArray();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -88,11 +83,6 @@ isEmpty(): boolean
```ts
const plainArray = new PlainArray();
let result = plainArray.isEmpty();
try {
plainArray.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -131,11 +121,6 @@ let plainArray = new PlainArray();
plainArray.has(1);
plainArray.add(1, "squirrel");
let result1 = plainArray.has(1);
try {
plainArray.has.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -174,11 +159,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.get(1);
try {
plainArray.get.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -217,11 +197,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.getIndexOfKey(2);
try {
plainArray.getIndexOfKey.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -260,11 +235,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.getIndexOfValue("squirrel");
try {
plainArray.getIndexOfValue.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -303,11 +273,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.getKeyAt(1);
try {
plainArray.getKeyAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getValueAt
......@@ -346,16 +311,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.getValueAt(1);
try {
plainArray.getValueAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
plainArray.getValueAt(10);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### clone
......@@ -387,11 +342,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let newPlainArray = plainArray.clone();
try {
plainArray.clone.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -423,11 +373,6 @@ add(key: number, value: T): void
```ts
let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
try {
plainArray.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -466,11 +411,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.remove(2);
try {
plainArray.remove.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -509,11 +449,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.removeAt(1);
try {
plainArray.removeAt.bind({}, 1)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -554,16 +489,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.removeRangeFrom(1, 3);
try {
plainArray.removeRangeFrom.bind({}, 1, 3)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
plainArray.removeRangeFrom(10, 3);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -598,16 +523,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
plainArray.setValueAt(1, 3546);
try {
plainArray.setValueAt.bind({}, 1, 3546)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
try {
plainArray.setValueAt(10, 3);
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -640,11 +555,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
let result = plainArray.toString();
try {
plainArray.toString.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -671,11 +581,6 @@ let plainArray = new PlainArray();
plainArray.add(1, "squirrel");
plainArray.add(2, "sparrow");
plainArray.clear();
try {
plainArray.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -718,13 +623,6 @@ plainArray.add(2, "sparrow");
plainArray.forEach((value, index) => {
console.log("value:" + 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}`);
}
```
......@@ -771,9 +669,4 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
plainArray[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-queue.md
浏览文件 @ 6a34fa72
......@@ -50,11 +50,6 @@ Queue的构造函数。
```ts
let queue = new Queue();
try {
let queue2 = Queue();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -96,11 +91,6 @@ let b = [1, 2, 3];
let result2 = queue.add(b);
let c = {name : "Dylon", age : "13"};
let result3 = queue.add(c);
try {
queue.add.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### pop
......@@ -135,11 +125,6 @@ queue.add(5);
queue.add(2);
queue.add(4);
let result = queue.pop();
try {
queue.pop.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### getFirst
......@@ -173,11 +158,6 @@ queue.add(4);
queue.add(5);
queue.add(2);
let result = queue.getFirst();
try {
queue.getFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### forEach
......@@ -223,13 +203,6 @@ queue.add(4);
queue.forEach((value, index) => {
console.log("value:" + 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}`);
}
```
### [Symbol.iterator]
......@@ -274,9 +247,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
queue[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-stack.md
浏览文件 @ 6a34fa72
......@@ -18,9 +18,6 @@ Stack和[Queue](js-apis-queue.md)相比，Queue基于循环队列实现，只能
import Stack from '@ohos.util.Stack';
```
## Stack
### 属性
......@@ -52,11 +49,6 @@ Stack的构造函数。
```ts
let stack = new Stack();
try {
let stack2 = Stack();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -98,11 +90,6 @@ let b = [1, 2, 3];
let result2 = stack.push(b);
let c = {name : "Dylon", age : "13"};
let result3 = stack.push(c);
try {
stack.push.bind({}, "b")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### pop
......@@ -137,11 +124,6 @@ stack.push(5);
stack.push(2);
stack.push(4);
let result = stack.pop();
try {
stack.pop.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### peek
......@@ -175,11 +157,6 @@ stack.push(4);
stack.push(5);
stack.push(2);
let result = stack.peek();
try {
stack.peek.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### locate
......@@ -219,11 +196,6 @@ stack.push(4);
stack.push(5);
stack.push(2);
let result = stack.locate(2);
try {
stack.locate.bind({}, 2)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### forEach
......@@ -269,13 +241,6 @@ stack.push(4);
stack.forEach((value, index) => {
console.log("value:" + 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}`);
}
```
### isEmpty
......@@ -309,11 +274,6 @@ stack.push(4);
stack.push(5);
stack.push(4);
let result = stack.isEmpty();
try {
stack.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### [Symbol.iterator]
......@@ -358,9 +318,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
stack[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-treemap.md
浏览文件 @ 6a34fa72
......@@ -58,11 +58,6 @@ TreeMap的构造函数。
```ts
let treeMap = new TreeMap();
try {
let treeMap2 = TreeMap();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -93,11 +88,6 @@ isEmpty(): boolean
```ts
const treeMap = new TreeMap();
let result = treeMap.isEmpty();
try {
treeMap.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -136,11 +126,6 @@ let treeMap = new TreeMap();
let result = treeMap.hasKey("squirrel");
treeMap.set("squirrel", 123);
let result1 = treeMap.hasKey("squirrel");
try {
treeMap.hasKey.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -179,11 +164,6 @@ let treeMap = new TreeMap();
let result = treeMap.hasValue(123);
treeMap.set("squirrel", 123);
let result1 = treeMap.hasValue(123);
try {
treeMap.hasValue.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -222,11 +202,6 @@ let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
let result = treeMap.get("sparrow");
try {
treeMap.get.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -259,11 +234,6 @@ let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
let result = treeMap.getFirstKey();
try {
treeMap.getFirstKey.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -296,11 +266,6 @@ let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
let result = treeMap.getLastKey();
try {
treeMap.getLastKey.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -334,11 +299,6 @@ treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
let map = new TreeMap();
treeMap.setAll(map);
try {
treeMap.setAll.bind({}, map)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -376,11 +336,6 @@ set(key: K, value: V): Object
```ts
let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
try {
treeMap.set.bind({}, "squirrel", 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -419,11 +374,6 @@ let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
treeMap.remove("sparrow");
try {
treeMap.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -463,11 +413,6 @@ treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
treeMap.set("gander", 356);
let result = treeMap.getLowerKey("sparrow");
try {
treeMap.getLowerKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -507,11 +452,6 @@ treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
treeMap.set("gander", 356);
let result = treeMap.getHigherKey("sparrow");
try {
treeMap.getHigherKey.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
### replace
......@@ -549,11 +489,6 @@ replace(key: K, newValue: V): boolean
let treeMap = new TreeMap();
treeMap.set("sparrow", 123);
let result = treeMap.replace("sparrow", 357);
try {
treeMap.replace.bind({}, "sparrow", 357)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -580,11 +515,6 @@ let treeMap = new TreeMap();
treeMap.set("squirrel", 123);
treeMap.set("sparrow", 356);
treeMap.clear();
try {
treeMap.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -622,11 +552,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
treeMap.keys.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -664,11 +589,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
treeMap.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -711,13 +631,6 @@ treeMap.set("gull", 357);
treeMap.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -756,11 +669,6 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
treeMap.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -806,9 +714,4 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
treeMap[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
zh-cn/application-dev/reference/apis/js-apis-treeset.md
浏览文件 @ 6a34fa72
......@@ -55,11 +55,6 @@ TreeSet的构造函数。
```ts
let treeSet = new TreeSet();
try {
let treeSet2 = TreeSet();
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -90,11 +85,6 @@ isEmpty(): boolean
```ts
const treeSet = new TreeSet();
let result = treeSet.isEmpty();
try {
treeSet.isEmpty.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -133,11 +123,6 @@ let treeSet = new TreeSet();
treeSet.has(123);
treeSet.add(123);
let result1 = treeSet.has(123);
try {
treeSet.has.bind({}, 123)(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -170,11 +155,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
let result = treeSet.getFirstValue();
try {
treeSet.getFirstValue.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -207,11 +187,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
let result = treeSet.getLastValue();
try {
treeSet.getLastValue.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -248,11 +223,6 @@ add(value: T): boolean
```ts
let treeSet = new TreeSet();
let result = treeSet.add("squirrel");
try {
treeSet.add.bind({}, "squirrel")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -291,11 +261,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
let result = treeSet.remove("sparrow");
try {
treeSet.remove.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -335,11 +300,6 @@ treeSet.add("squirrel");
treeSet.add("sparrow");
treeSet.add("gander");
let result = treeSet.getLowerValue("sparrow");
try {
treeSet.getLowerValue.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -379,11 +339,6 @@ treeSet.add("squirrel");
treeSet.add("sparrow");
treeSet.add("gander");
let result = treeSet.getHigherValue("sparrow");
try {
treeSet.getHigherValue.bind({}, "sparrow")(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -416,11 +371,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
let result = treeSet.popFirst();
try {
treeSet.popFirst.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -453,11 +403,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
let result = treeSet.popLast();
try {
treeSet.popLast.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -484,11 +429,6 @@ let treeSet = new TreeSet();
treeSet.add("squirrel");
treeSet.add("sparrow");
treeSet.clear();
try {
treeSet.clear.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -526,11 +466,6 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
treeSet.values.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -573,13 +508,6 @@ treeSet.add("gull");
treeSet.forEach((value, key) => {
console.log("value:" + 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}`);
}
```
......@@ -618,11 +546,6 @@ while(temp != undefined) {
console.log("value:" + temp[1]);
temp = iter.next().value;
}
try {
treeSet.entries.bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
......@@ -667,9 +590,4 @@ while(temp != undefined) {
console.log("value:" + temp);
temp = iter.next().value;
}
try {
treeSet[Symbol.iterator].bind({})(); // bind为JS标准内置对象Function的方法，用于改变this的指向，测试异常捕获
} catch(err) {
console.log(`${err.code} - ${err.name} - ${err.message}`);
}
```
\ No newline at end of file
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或