重构进阶语法测试

pages/SyntaxCase/index.vue

@@ -40,6 +40,12 @@
         <view>测试return：{{ format(testUtsClassAsyncResult.return) }}</view>
         <view>测试success：{{ format(testUtsClassAsyncResult.success) }}</view>
         <view>测试complete：{{ format(testUtsClassAsyncResult.complete) }}</view>
+        <button @click="testUtsClassInstance">点击测试uts方法返回类实例</button>
+        <view>测试prop：{{ format(testUtsClassInstanceResult.prop) }}</view>
+        <view>测试return：{{ format(testUtsClassInstanceResult.return) }}</view>
+        <view>测试success：{{ format(testUtsClassInstanceResult.success) }}</view>
+        <view>测试complete：{{ format(testUtsClassInstanceResult.complete) }}</view>
+        <view>测试callback：{{ format(testUtsClassInstanceResult.callback) }}</view>
         <button @click="testAll">点击测试所有</button>
     </view>
 </template>
@@ -50,6 +56,7 @@
         testSyncWithCallback,
         testAsync,
         Test,
+        request,
     } from "../../uni_modules/uts-syntaxcase";
 
     let test
@@ -98,6 +105,14 @@
                     success: null,
                     fail: null,
                     complete: null,
+                },
+                testUtsClassInstanceResult: {
+                    prop: null,
+                    return: null,
+                    success: null,
+                    fail: null,
+                    complete: null,
+                    callback: null
                 }
             }
         },
@@ -116,6 +131,7 @@
                 this.testUtsClassProp();
                 this.testUtsClassSyncWithCallback();
                 this.testUtsClassAsync();
+                this.testUtsClassInstance();
             },
             testUtsSync() {
                 this.testUtsSyncResult = false;
@@ -257,7 +273,6 @@
                     this.testUtsClassPropResult = true
                 }
             },
-
             testUtsClassSyncWithCallback() {
                 if (!test) {
                     this.testUtsClassConstructor()
@@ -288,7 +303,6 @@
                     }
                 } catch (e) {}
             },
-
             async testUtsClassAsync() {
                 if (!test) {
                     this.testUtsClassConstructor()
@@ -312,10 +326,47 @@
                             this.testUtsClassAsyncResult.complete = true;
                         },
                     });
+                    console.log('res', res)
                     if (res.name === "testAsync") {
                         this.testUtsClassAsyncResult.return = true;
                     }
-        } catch (e) {}
+                } catch (e) {
+                    console.error(e)
+                }
+            },
+            testUtsClassInstance() {
+                this.testUtsClassInstanceResult.prop = false;
+                this.testUtsClassInstanceResult.return = false;
+                this.testUtsClassInstanceResult.success = false;
+                // testUtsClassAsyncResult.fail = false;
+                this.testUtsClassInstanceResult.complete = false;
+                this.testUtsClassInstanceResult.callback = false;
+                const url = 'https://dcloud.io/'
+                const task = request(url)
+                if (task.url === url && task.abort().url === url) {
+                    this.testUtsClassInstanceResult.prop = true;
+                }
+                task.onCallback((res) => {
+                    if (res === 'onCallback') {
+                        this.testUtsClassInstanceResult.callback = true;
+                    }
+                })
+                const res = task.sync({
+                    success: (res) => {
+                        console.log("task.sync.success.callback", res);
+                        this.testUtsClassInstanceResult.success = true;
+                    },
+                    fail: (res) => {
+                        console.log("task.sync.fail.callback", res);
+                    },
+                    complete: (res) => {
+                        console.log("task.sync.complete.callback", res);
+                        this.testUtsClassInstanceResult.complete = true;
+                    },
+                })
+                if (res === 'sync') {
+                    this.testUtsClassInstanceResult.return = true;
+                }
             }
         }
     }

uni_modules/uts-syntaxcase/index.uts

-type AsyncOptions = {
-  type: string;
-  success: (res: string) => void;
-  fail: (res: string) => void;
-  complete: (res: string) => void;
-};
-
-type SyntaxResult = {
-	name: string
-};
-
-type SyncResult = {
-	msg: string
-}
-
-
-/**
- * 导出一个属性
- */
-export const MAX = 100;
-
-/**
- * 导出一个同步方法
- * @returns
- */
-export function testSync(msg: string): SyncResult {
-  console.log("log test");
-  const res: SyncResult = {
-	  msg: `hello ${msg}`
-  }
-  return res
-}
-/**
- * 导出一个同步方法（触发了数组越界异常）
- */
-export function testSyncError() {
-  const arr: string[] = [];
-  console.log(arr[1]);
-}
-/**
- * 导出一个带callback的同步方法
- * @param opts
- */
-export function testSyncWithCallback(opts: AsyncOptions) {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  
-  const res: SyntaxResult = {
-	  name: "testSyncWithCallback"
-  }
-  return res
-}
-/**
- * 导出一个异步方法
- * @returns
- */
-export async function testAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  
-  const res: SyntaxResult = {
-  	  name: "testAsync"
-  }
-  return res
-}
-
-type TestOptions = {
-  name: string;
-  callback: (res: string) => void;
-};
-
-export class Test {
-  id: number;
-  name: string;
-  static type: string = "Test";
-  constructor(id: number, options: TestOptions) {
-    this.id = id;
-    this.name = options.name;
-    options.callback("Test.constructor");
-  }
-  static testClassStaticSyncWithCallback(opts: AsyncOptions): SyntaxResult {
-    return testSyncWithCallback(opts);
-  }
-  static async testClassStaticAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-    const res = await testAsync(opts);
-    return res;
-  }
-  testClassSyncWithCallback(opts: AsyncOptions): SyntaxResult {
-    return testSyncWithCallback(opts);
-  }
-  async testClassAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-    const res = await testAsync(opts);
-    return res;
-  }
-}

uni_modules/uts-syntaxcase/utssdk/app-android/index.uts

-import { log } from "./utils.uts";
-type AsyncOptions = {
-  type: string;
-  success: (res: string) => void;
-  fail: (res: string) => void;
-  complete: (res: string) => void;
-};
-/**
- * 导出一个属性
- */
-export const MAX = 100;
-
-/**
- * 导出一个同步方法
- * @returns
- */
-export function testSync(msg: string) {
-  console.log("log test");
-  log("log test1");
-  return {
-    msg: `hello ${msg}`,
-  };
-}
-/**
- * 导出一个同步方法（触发了数组越界异常）
- */
-export function testSyncError() {
-  const arr: string[] = [];
-  console.log(arr[1]);
-}
-/**
- * 导出一个带callback的同步方法
- * @param opts
- */
-export function testSyncWithCallback(opts: AsyncOptions) {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  return { name: "testSyncWithCallback" };
-}
-/**
- * 导出一个异步方法
- * @returns
- */
-export async function testAsync(opts: AsyncOptions) {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  return { name: "testAsync" };
-}
-
-type TestOptions = {
-  name: string;
-  callback: (res: string) => void;
-};
-
-export class Test {
-  id: number;
-  name: string;
-  static type: string = "Test";
-  constructor(id: number, options: TestOptions) {
-    this.id = id;
-    this.name = options.name;
-    options.callback("Test.constructor");
-  }
-  static testClassStaticSyncWithCallback(opts: AsyncOptions): UTSJSONObject {
-    return testSyncWithCallback(opts);
-  }
-  static async testClassStaticAsync(opts: AsyncOptions): Promise<UTSJSONObject> {
-    const res = await testAsync(opts);
-    return res;
-  }
-  testClassSyncWithCallback(opts: AsyncOptions): UTSJSONObject {
-    return testSyncWithCallback(opts);
-  }
-  async testClassAsync(opts: AsyncOptions): Promise<UTSJSONObject> {
-    const res = await testAsync(opts);
-    return res;
-  }
-}

uni_modules/uts-syntaxcase/utssdk/app-ios/index.uts

-import { log } from "./utils.uts";
-type AsyncOptions = {
-  type: string;
-  success: (res: string) => void;
-  fail: (res: string) => void;
-  complete: (res: string) => void;
-};
-
-type SyntaxResult = {
-	name: string
-};
-
-type SyncResult = {
-	msg: string
-}
-
-/**
- * 导出一个属性
- */
-export const MAX = 100;
-
-/**
- * 导出一个同步方法
- * @returns
- */
-export function testSync(msg: string): SyncResult {
-  console.log("log test");
-  log("log test1");
-  
-  const res: SyncResult = {
-	  msg: `hello ${msg}`
-  }
-  return res
-  // return {
-  //   msg: `hello ${msg}`,
-  // };
-}
-/**
- * 导出一个同步方法（触发了数组越界异常）
- */
-export function testSyncError() {
-  const arr: string[] = [];
-  console.log(arr[1]);
-}
-/**
- * 导出一个带callback的同步方法
- * @param opts
- */
-export function testSyncWithCallback(opts: AsyncOptions): SyntaxResult {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  
-  const res: SyntaxResult = {
-	  name: "testSyncWithCallback"
-  }
-  return res;
-  // return { name: "testSyncWithCallback" };
-}
-/**
- * 导出一个异步方法
- * @returns
- */
-export async function testAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-  if (opts.type == "success") {
-    opts.success("success");
-  } else {
-    opts.fail("fail");
-  }
-  opts.complete("complete");
-  
-  const res: SyntaxResult = {
-  	  name: "testAsync"
-  }
-  return res;
-  // return { name: "testAsync" };
-}
-
-type TestOptions = {
-  name: string;
-  callback: (res: string) => void;
-};
-
-export class Test {
-  id: number;
-  name: string;
-  static type: string = "Test";
-  constructor(id: number, options: TestOptions) {
-    this.id = id;
-    this.name = options.name;
-    options.callback("Test.constructor");
-  }
-  static testClassStaticSyncWithCallback(opts: AsyncOptions): SyntaxResult {
-    return testSyncWithCallback(opts);
-  }
-  static async testClassStaticAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-    const res = await testAsync(opts);
-    return res;
-  }
-  testClassSyncWithCallback(opts: AsyncOptions): SyntaxResult {
-    return testSyncWithCallback(opts);
-  }
-  async testClassAsync(opts: AsyncOptions): Promise<SyntaxResult> {
-    const res = await testAsync(opts);
-    return res;
-  }
-}

uni_modules/uts-syntaxcase/utssdk/app-ios/utils.uts

-export function log(msg: string) {
-  console.log(msg);
-}

uni_modules/uts-syntaxcase/utssdk/index.uts

+import { RequestTask, SyncOptions } from "./interface.uts";
+import { log } from "./utils.uts";
+type AsyncOptions = {
+    type : string;
+    success : (res : string) => void;
+    fail : (res : string) => void;
+    complete : (res : string) => void;
+};
+
+type SyntaxResult = {
+    name : string
+};
+
+type SyncResult = {
+    msg : string
+}
+
+/**
+ * 导出一个属性
+ */
+export const MAX = 100;
+
+/**
+ * 导出一个同步方法
+ * @returns
+ */
+export function testSync(msg : string) : SyncResult {
+    console.log("log test");
+    log("log test1");
+
+    const res : SyncResult = {
+        msg: `hello ${msg}`
+    }
+    return res
+    // return {
+    //   msg: `hello ${msg}`,
+    // };
+}
+/**
+ * 导出一个同步方法（触发了数组越界异常）
+ */
+export function testSyncError() {
+    const arr : string[] = [];
+    console.log(arr[1]);
+}
+/**
+ * 导出一个带callback的同步方法
+ * @param opts
+ */
+export function testSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
+    if (opts.type == "success") {
+        opts.success("success");
+    } else {
+        opts.fail("fail");
+    }
+    opts.complete("complete");
+
+    const res : SyntaxResult = {
+        name: "testSyncWithCallback"
+    }
+    return res;
+    // return { name: "testSyncWithCallback" };
+}
+/**
+ * 导出一个异步方法
+ * @returns
+ */
+export async function testAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
+    if (opts.type == "success") {
+        opts.success("success");
+    } else {
+        opts.fail("fail");
+    }
+    opts.complete("complete");
+
+    const res : SyntaxResult = {
+        name: "testAsync"
+    }
+    return res;
+    // return { name: "testAsync" };
+}
+
+type TestOptions = {
+    name : string;
+    callback : (res : string) => void;
+};
+
+export class Test {
+    id : number;
+    name : string;
+    static type : string = "Test";
+    constructor(id : number, options : TestOptions) {
+        this.id = id;
+        this.name = options.name;
+        options.callback("Test.constructor");
+    }
+    static testClassStaticSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
+        return testSyncWithCallback(opts);
+    }
+    static async testClassStaticAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
+        const res = await testAsync(opts);
+        return res;
+    }
+    testClassSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
+        return testSyncWithCallback(opts);
+    }
+    async testClassAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
+        const res = await testAsync(opts);
+        return res;
+    }
+}
+
+class RequestTaskImpl implements RequestTask {
+    url : string
+    constructor(url : string) {
+        this.url = url
+    }
+    abort() : RequestTask {
+        return this
+    }
+    onCallback(callback : (res : string) => void) {
+        callback("onCallback")
+    }
+    sync(options : SyncOptions) : string {
+        options.success?.("success")
+        options.complete?.("success")
+        return "sync"
+    }
+}
+
+export function request(url : string) : RequestTask {
+    return new RequestTaskImpl(url)
+}
\ No newline at end of file

uni_modules/uts-syntaxcase/utssdk/interface.uts

+export type SyncOptions = {
+    success ?: (res : string) => void
+    fail ?: (res : string) => void
+    complete ?: (res : string) => void
+}
+export interface RequestTask {
+    url : string
+    abort() : RequestTask
+    onCallback(callback : (res : string) => void) : void
+    sync(options : SyncOptions) : string
+}
\ No newline at end of file