[array-buffer]消除告警

uni_modules/uts-tests/utssdk/TFloat32Array.js

@@ -81,7 +81,7 @@ export class TFloat32Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Float32Array): boolean => currentValue < 40;    
-    let result = new Float32Array([12, 5, 8, 130, 44]).every((value: number, index: number, array: Float32Array):
+    let result = new Float32Array([12, 5, 8, 130, 44]).every((value: number, _: number, _: Float32Array):
       boolean => value < 40); // 
     expect(result).toEqual(false);
   }
@@ -106,29 +106,29 @@ export class TFloat32Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Float32Array([12, 5, 8, 44]).filter((value: number, index: number, array: Float32Array):
+    let float32 = new Float32Array([12, 5, 8, 44]).filter((value: number, _: number, _: Float32Array):
       boolean => value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Float32Array([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Float32Array): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Float32Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Float32Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Float32Array): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Float32Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Float32Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Float32Array): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Float32Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Float32Array([0, 1, 2, 3]).forEach((value: number, index: number, array: Float32Array) => {
+    new Float32Array([0, 1, 2, 3]).forEach((value: number,index: number, _: Float32Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -194,31 +194,31 @@ export class TFloat32Array {
 
   map() {
     let numbers = new Float32Array([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Float32Array): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Float32Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Float32Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Float32Array):
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _: Float32Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Float32Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Float32Array):
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Float32Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Float32Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array:
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _:
       Float32Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Float32Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Float32Array):
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Float32Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }

uni_modules/uts-tests/utssdk/TFloat64Array.js

@@ -75,7 +75,7 @@ export class TFloat64Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Float64Array): boolean => currentValue < 40;    
-    let result = new Float64Array([-10, -20, -30, -40, -50]).every((value: number, index: number, array:
+    let result = new Float64Array([-10, -20, -30, -40, -50]).every((value: number, _: number, _:
       Float64Array): boolean => value < 0); // 
     expect(result).toEqual(true);
   }
@@ -100,29 +100,29 @@ export class TFloat64Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Float64Array([12, 5, 8, 44]).filter((value: number, index: number, array: Float64Array):
+    let float32 = new Float64Array([12, 5, 8, 44]).filter((value: number, _: number, _: Float64Array):
       boolean => value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Float64Array([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Float64Array): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Float64Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Float64Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Float64Array): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Float64Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Float64Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Float64Array): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Float64Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Float64Array([0, 1, 2, 3]).forEach((value: number, index: number, array: Float64Array) => {
+    new Float64Array([0, 1, 2, 3]).forEach((value: number, index: number, _: Float64Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -189,31 +189,31 @@ export class TFloat64Array {
 
   map() {
     let numbers = new Float64Array([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Float64Array): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Float64Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Float64Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Float64Array):
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _: Float64Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Float64Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Float64Array):
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Float64Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Float64Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array:
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _:
       Float64Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Float64Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Float64Array):
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Float64Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }

uni_modules/uts-tests/utssdk/TInt16Array.js

@@ -59,7 +59,7 @@ export class TInt16Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Int16Array): boolean => currentValue < 40;    
-    let result = new Int16Array([12, 5, 8, 130, 44]).every((value:number,index : number, array : Int16Array): boolean => value< 40); // 
+    let result = new Int16Array([12, 5, 8, 130, 44]).every((value:number,_ : number, _ : Int16Array): boolean => value< 40); // 
     expect(result).toEqual(false);
   }
 
@@ -83,28 +83,28 @@ export class TInt16Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
       
-    let float32 = new Int16Array([12, 5, 8, 44]).filter((value : number, index : number, array : Int16Array): boolean => value>= 10);
+    let float32 = new Int16Array([12, 5, 8, 44]).filter((value : number, _ : number, _ : Int16Array): boolean => value>= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Int16Array([4, 5, 8, 12]);
-    let res = float32.find((value : number, index : number, obj : Int16Array): boolean => value > 5);
+    let res = float32.find((value : number, _ : number, _ : Int16Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Int16Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value : number, index : number, obj : Int16Array): boolean => value > 100);
+    let res = float32.findIndex((value : number, _ : number, _ : Int16Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Int16Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value : number, index : number, obj : Int16Array): boolean => value > 100);
+    res = ufloat32.findIndex((value : number, _ : number, _ : Int16Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Int16Array([0, 1, 2, 3]).forEach((value : number, index : number, array : Int16Array) => {
+    new Int16Array([0, 1, 2, 3]).forEach((value : number, index : number, _ : Int16Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -169,28 +169,28 @@ export class TInt16Array {
 
   map() {
     let numbers = new Int16Array([1, 4, 9]);
-    let doubles = numbers.map((value : number, index : number, array : Int16Array): number => value * 2);
+    let doubles = numbers.map((value : number, _ : number, _ : Int16Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Int16Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Int16Array): number => accumulator + currentValue);
+    let res = total.reduce((accumulator : number, currentValue : number, _  : number, _  : Int16Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int16Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Int16Array): number => accumulator + currentValue, 8);
+    res = total.reduce((accumulator : number, currentValue : number, _ : number, _  : Int16Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Int16Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Int16Array): number => accumulator + currentValue);
+    let res = total.reduceRight((accumulator: number, currentValue : number, _  : number, _  : Int16Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int16Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Int16Array): number => accumulator + currentValue, 8);
+    res = total.reduceRight((accumulator: number, currentValue : number, _  : number, _  : Int16Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 

uni_modules/uts-tests/utssdk/TInt32Array.js

@@ -78,7 +78,7 @@ export class TInt32Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Int32Array): boolean => currentValue < 40;    
-    let result = new Int32Array([12, 5, 8, 130, 44]).every((value:number,index : number, array : Int32Array): boolean => value< 40); // 
+    let result = new Int32Array([12, 5, 8, 130, 44]).every((value:number,_ : number, _ : Int32Array): boolean => value< 40); // 
     expect(result).toEqual(false);
   }
 
@@ -102,28 +102,28 @@ export class TInt32Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
       
-    let float32 = new Int32Array([12, 5, 8, 44]).filter((value : number, index : number, array : Int32Array): boolean => value>= 10);
+    let float32 = new Int32Array([12, 5, 8, 44]).filter((value : number, _ : number, _ : Int32Array): boolean => value>= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Int32Array([4, 5, 8, 12]);
-    let res = float32.find((value : number, index : number, obj : Int32Array): boolean => value > 5);
+    let res = float32.find((value : number, _ : number, _ : Int32Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Int32Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value : number, index : number, obj : Int32Array): boolean => value > 100);
+    let res = float32.findIndex((value : number, _ : number, _ : Int32Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Int32Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value : number, index : number, obj : Int32Array): boolean => value > 100);
+    res = ufloat32.findIndex((value : number, _ : number, _ : Int32Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Int32Array([0, 1, 2, 3]).forEach((value : number, index : number, array : Int32Array) => {
+    new Int32Array([0, 1, 2, 3]).forEach((value : number, index : number, _ : Int32Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -185,28 +185,28 @@ export class TInt32Array {
 
   map() {
     let numbers = new Int32Array([1, 4, 9]);
-    let doubles = numbers.map((value : number, index : number, array : Int32Array): number => value * 2);
+    let doubles = numbers.map((value : number, _ : number, _ : Int32Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Int32Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Int32Array): number => accumulator + currentValue);
+    let res = total.reduce((accumulator : number, currentValue : number, _ : number, _ : Int32Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int32Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Int32Array): number => accumulator + currentValue, 8);
+    res = total.reduce((accumulator : number, currentValue : number, _ : number, _ : Int32Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Int32Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Int32Array): number => accumulator + currentValue);
+    let res = total.reduceRight((accumulator: number, currentValue : number, _ : number, _ : Int32Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int32Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Int32Array): number => accumulator + currentValue, 8);
+    res = total.reduceRight((accumulator: number, currentValue : number, _ : number, _ : Int32Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 

uni_modules/uts-tests/utssdk/TInt8Array.js

@@ -60,7 +60,7 @@ export class TInt8Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Int8Array): boolean => currentValue < 40;    
-    let result = new Int8Array([12, 5, 8, 130, 44]).every((value: number, index: number, array: Int8Array): boolean =>
+    let result = new Int8Array([12, 5, 8, 130, 44]).every((value: number, _: number, _: Int8Array): boolean =>
       value < 40); // 
     expect(result).toEqual(false);
   }
@@ -85,29 +85,29 @@ export class TInt8Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Int8Array([12, 5, 8, 44]).filter((value: number, index: number, array: Int8Array): boolean =>
+    let float32 = new Int8Array([12, 5, 8, 44]).filter((value: number, _: number, _: Int8Array): boolean =>
       value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Int8Array([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Int8Array): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Int8Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Int8Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Int8Array): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Int8Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Int8Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Int8Array): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Int8Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Int8Array([0, 1, 2, 3]).forEach((value: number, index: number, array: Int8Array) => {
+    new Int8Array([0, 1, 2, 3]).forEach((value: number, index: number, _: Int8Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -173,31 +173,31 @@ export class TInt8Array {
 
   map() {
     let numbers = new Int8Array([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Int8Array): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Int8Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Int8Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Int8Array):
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _: Int8Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int8Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Int8Array): number =>
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Int8Array): number =>
       accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Int8Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Int8Array):
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Int8Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Int8Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Int8Array):
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Int8Array):
       number => accumulator + currentValue, 8);
    
     expect(res).toEqual(14);

uni_modules/uts-tests/utssdk/TUInt8Array.js

@@ -64,7 +64,7 @@ export class TUint8Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Uint8Array): boolean => currentValue < 40;    
-    let result = new Uint8Array([12, 5, 8, 130, 44]).every((value:number,index : number, array : Uint8Array): boolean => value< 40); // 
+    let result = new Uint8Array([12, 5, 8, 130, 44]).every((value:number,_ : number, _ : Uint8Array): boolean => value< 40); // 
     expect(result).toEqual(false);
   }
 
@@ -88,28 +88,28 @@ export class TUint8Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
       
-    let float32 = new Uint8Array([12, 5, 8, 44]).filter((value : number, index : number, array : Uint8Array): boolean => value>= 10);
+    let float32 = new Uint8Array([12, 5, 8, 44]).filter((value : number, _ : number, _ : Uint8Array): boolean => value>= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Uint8Array([4, 5, 8, 12]);
-    let res = float32.find((value : number, index : number, obj : Uint8Array): boolean => value > 5);
+    let res = float32.find((value : number, _ : number, _ : Uint8Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Uint8Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value : number, index : number, obj : Uint8Array): boolean => value > 100);
+    let res = float32.findIndex((value : number, _ : number, _ : Uint8Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Uint8Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value : number, index : number, obj : Uint8Array): boolean => value > 100);
+    res = ufloat32.findIndex((value : number, _ : number, _ : Uint8Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Uint8Array([0, 1, 2, 3]).forEach((value : number, index : number, array : Uint8Array) => {
+    new Uint8Array([0, 1, 2, 3]).forEach((value : number, index : number, _ : Uint8Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -171,28 +171,28 @@ export class TUint8Array {
 
   map() {
     let numbers = new Uint8Array([1, 4, 9]);
-    let doubles = numbers.map((value : number, index : number, array : Uint8Array): number => value * 2);
+    let doubles = numbers.map((value : number, _ : number, _ : Uint8Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Uint8Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Uint8Array): number => accumulator + currentValue);
+    let res = total.reduce((accumulator : number, currentValue : number, _ : number, _ : Uint8Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint8Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator : number, currentValue : number, currentIndex : number, array : Uint8Array): number => accumulator + currentValue, 8);
+    res = total.reduce((accumulator : number, currentValue : number, _ : number, _ : Uint8Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Uint8Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Uint8Array): number => accumulator + currentValue);
+    let res = total.reduceRight((accumulator: number, currentValue : number, _ : number, _ : Uint8Array): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint8Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue : number, currentIndex : number, array : Uint8Array): number => accumulator + currentValue, 8);
+    res = total.reduceRight((accumulator: number, currentValue : number, _ : number, _ : Uint8Array): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 

uni_modules/uts-tests/utssdk/TUInt8ClampedArray.js

@@ -64,7 +64,7 @@ export class TUint8ClampedArray {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Uint8ClampedArray): boolean => currentValue < 40;    
-    let result = new Uint8ClampedArray([12, 5, 8, 130, 44]).every((value: number, index: number, array:
+    let result = new Uint8ClampedArray([12, 5, 8, 130, 44]).every((value: number, _: number, _:
       Uint8ClampedArray): boolean => value < 40); // 
     expect(result).toEqual(false);
   }
@@ -89,29 +89,29 @@ export class TUint8ClampedArray {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Uint8ClampedArray([12, 5, 8, 44]).filter((value: number, index: number, array:
+    let float32 = new Uint8ClampedArray([12, 5, 8, 44]).filter((value: number, _: number, _:
       Uint8ClampedArray): boolean => value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Uint8ClampedArray([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Uint8ClampedArray): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Uint8ClampedArray): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Uint8ClampedArray([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Uint8ClampedArray): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Uint8ClampedArray): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Uint8ClampedArray([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Uint8ClampedArray): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Uint8ClampedArray): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Uint8ClampedArray([0, 1, 2, 3]).forEach((value: number, index: number, array: Uint8ClampedArray) => {
+    new Uint8ClampedArray([0, 1, 2, 3]).forEach((value: number, index: number, _: Uint8ClampedArray) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -173,31 +173,31 @@ export class TUint8ClampedArray {
 
   map() {
     let numbers = new Uint8ClampedArray([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Uint8ClampedArray): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Uint8ClampedArray): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Uint8ClampedArray([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array:
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _:
       Uint8ClampedArray): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint8ClampedArray([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Uint8ClampedArray):
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Uint8ClampedArray):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Uint8ClampedArray([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array:
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _:
       Uint8ClampedArray): number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint8ClampedArray([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array:
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _:
       Uint8ClampedArray): number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }

uni_modules/uts-tests/utssdk/TUint16Array.js

@@ -78,7 +78,7 @@ export class TUint16Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Uint16Array): boolean => currentValue < 40;    
-    let result = new Uint16Array([12, 5, 8, 130, 44]).every((value: number, index: number, array: Uint16Array):
+    let result = new Uint16Array([12, 5, 8, 130, 44]).every((value: number, _: number, _: Uint16Array):
       boolean => value < 40); // 
     expect(result).toEqual(false);
   }
@@ -103,29 +103,29 @@ export class TUint16Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Uint16Array([12, 5, 8, 44]).filter((value: number, index: number, array: Uint16Array):
+    let float32 = new Uint16Array([12, 5, 8, 44]).filter((value: number, _: number, _: Uint16Array):
       boolean => value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Uint16Array([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Uint16Array): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Uint16Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Uint16Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Uint16Array): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Uint16Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Uint16Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Uint16Array): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Uint16Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Uint16Array([0, 1, 2, 3]).forEach((value: number, index: number, array: Uint16Array) => {
+    new Uint16Array([0, 1, 2, 3]).forEach((value: number, index: number, _: Uint16Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -187,31 +187,31 @@ export class TUint16Array {
 
   map() {
     let numbers = new Uint16Array([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Uint16Array): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Uint16Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Uint16Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Uint16Array):
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _: Uint16Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint16Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Uint16Array):
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Uint16Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Uint16Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Uint16Array):
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Uint16Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint16Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Uint16Array):
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Uint16Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }

uni_modules/uts-tests/utssdk/TUint32Array.js

@@ -78,7 +78,7 @@ export class TUint32Array {
 
   testEvery() {
     // const isBelowThreshold = (currentValue: number, index: number, array:Uint32Array): boolean => currentValue < 40;    
-    let result = new Uint32Array([12, 5, 8, 130, 44]).every((value: number, index: number, array: Uint32Array):
+    let result = new Uint32Array([12, 5, 8, 130, 44]).every((value: number, _: number, _: Uint32Array):
       boolean => value < 40); // 
     expect(result).toEqual(false);
   }
@@ -103,29 +103,29 @@ export class TUint32Array {
   testFilter() {
     // const isBelowThreshold = (currentValue: number, index: number, _): boolean => currentValue >= 10;
 
-    let float32 = new Uint32Array([12, 5, 8, 44]).filter((value: number, index: number, array: Uint32Array):
+    let float32 = new Uint32Array([12, 5, 8, 44]).filter((value: number, _: number, _: Uint32Array):
       boolean => value >= 10);
     expect(float32.toString()).toEqual("12,44");
   }
 
   find() {
     let float32 = new Uint32Array([4, 5, 8, 12]);
-    let res = float32.find((value: number, index: number, obj: Uint32Array): boolean => value > 5);
+    let res = float32.find((value: number, _: number, _: Uint32Array): boolean => value > 5);
     expect(res).toEqual(8);
   }
 
   findIndex() {
     let float32 = new Uint32Array([4, 6, 8, 12]);
-    let res = float32.findIndex((value: number, index: number, obj: Uint32Array): boolean => value > 100);
+    let res = float32.findIndex((value: number, _: number, _: Uint32Array): boolean => value > 100);
     expect(res).toEqual(-1);
 
     let ufloat32 = new Uint32Array([4, 6, 7, 120]);
-    res = ufloat32.findIndex((value: number, index: number, obj: Uint32Array): boolean => value > 100);
+    res = ufloat32.findIndex((value: number, _: number, _: Uint32Array): boolean => value > 100);
     expect(res).toEqual(3);
   }
 
   foreach() {
-    new Uint32Array([0, 1, 2, 3]).forEach((value: number, index: number, array: Uint32Array) => {
+    new Uint32Array([0, 1, 2, 3]).forEach((value: number, index: number, _: Uint32Array) => {
       console.log(`a[${index}] = ${value}`);
     });
   }
@@ -187,31 +187,31 @@ export class TUint32Array {
 
   map() {
     let numbers = new Uint32Array([1, 4, 9]);
-    let doubles = numbers.map((value: number, index: number, array: Uint32Array): number => value * 2);
+    let doubles = numbers.map((value: number, _: number, _: Uint32Array): number => value * 2);
     expect(numbers.toString()).toEqual("1,4,9");
     expect(doubles.toString()).toEqual("2,8,18");
   }
 
   reduce() {
     let total = new Uint32Array([0, 1, 2, 3]);
-    let res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Uint32Array):
+    let res = total.reduce((accumulator: number, currentValue: number, _: number, _: Uint32Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint32Array([0, 1, 2, 3]);
-    res = total.reduce((accumulator: number, currentValue: number, currentIndex: number, array: Uint32Array):
+    res = total.reduce((accumulator: number, currentValue: number, _: number, _: Uint32Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }
 
   reduceRight() {
     let total = new Uint32Array([0, 1, 2, 3]);
-    let res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Uint32Array):
+    let res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Uint32Array):
       number => accumulator + currentValue);
     expect(res).toEqual(6);
 
     total = new Uint32Array([0, 1, 2, 3]);
-    res = total.reduceRight((accumulator: number, currentValue: number, currentIndex: number, array: Uint32Array):
+    res = total.reduceRight((accumulator: number, currentValue: number, _: number, _: Uint32Array):
       number => accumulator + currentValue, 8);
     expect(res).toEqual(14);
   }