Harmony-(2)-ArkTs

1.以下代码片段哪几处违反了 ArkTs 语法规范(ABC)

//1.以下代码片段哪几处违反了 ArkTs 语法规范(ABC)
class Point{
	public x:number
	public y:number
	constructor(x:number,y:number) 
	{
		this.x=x
		this.y=y
	}
}
let p=new Point(1.0,1.0)
delete p.x;
p.z=2.0;
p.x='hello';

Ap.x='hello';
Bdelete p.x;
Cp.z=2.0;
D. let p=new Point(1.0,1.0)

//1.public x:number 和 public y:number 的声明应该使用冒号（:）而不是等号（=），这是 TypeScript 类属性声明的正确方式。所以这里违反了语法规范。
//2.delete p.x; 尝试删除类实例 p 的 x 属性。在 TypeScript 或者 JavaScript 中，通常不建议删除对象的属性，因此这不是最佳实践，但并不是严格的语法错误。
//3.p.z=2.0; 尝试给 p 添加一个 z 属性。在 TypeScript 中，应该先定义类 Point 的 z 属性，否则会导致类型推断错误。
//4.p.x='hello'; 尝试将 p 的 x 属性赋值为字符串 'hello'。这是有效的，但可能会导致类型不匹配的问题，具体取决于你的类型定义。

2.在 ArkTS 中，以下哪些声明类的方式是正确的。(AB)

 

class C1 
{
   value: number = 0; //正确的。在类 C1 中，属性 value 被直接初始化为 0，这在 TypeScript 中是允许的，并且是一种常见的初始化方式
}
class C2 
{
  value: number;     //正确的。类 C2 中声明了一个属性 value，并在构造函数中接受一个参数 value，并将其赋值给类的属性。
  constructor(value: number) 
  {
    this.value = value;
  }
}
class C3 
{
	constructor(value: number)
	{
		this.value = value;  //错误 构造函数中未声明 value 属性
	}
}
class C4 
{
	value: number;    //正确 构造函数中未声明 这种方式允许在后续的代码中通过构造函数或者直接赋值来初始化 value 属性。
}
A.C2
B.C1
C.C4

3.以下数据类型中，哪些是 Sendable 数据(ABC)

import { lang } from '@kit.ArkTS';
class C {}
interface I extends lang.ISendable {}
A.interface I
B.number
C.string
D.class C
 

1. A. interface I: 如果 lang.ISendable 接口定义了 Sendable 数据类型，并且接口 I 继承自 lang.ISendable，那么 I 可能是 Sendable 数据类型。

2. B. number: 数字类型通常可以被视为 Sendable 数据，因为它们可以轻松地在网络中传输。

3. C. string: 字符串同样是常见的 Sendable 数据类型，因为它们也可以在网络中进行传输。

4. D. class C: 类 C 的 Sendable 属性取决于它是否实现了 lang.ISendable 接口或者在定义中被标记为 Sendable。在给出的信息中，无法明确确定类 C 是否符合这些条件。

综上所述，根据常规情况推断，可能的 Sendable 数据类型是：

• A. interface I
• B. number
• C. string

Sendable 数据类型指的是可以在网络中传输或发送的数据类型。

4.依次点击 A、B、C、D 四个按钮，其中不会触发 UI 刷新的是：（AC）->(B)

@Entry
@Component
struct Index {
	@State count: number = 0;  //  this.count 是 @State 装饰的状态变量
	@State @Watch('onValueChange') value: number = 50;
	onValueChange() 
	{
		this.count = this.value;
	}
build() {
		Column() {
			Text(`${this.count}`)
				Button("A")
				.onClick(() => {
				this.count = 0;
				})   //会将 this.count 设置为 0  会立即更新 UI
				
				Button("B")
				.onClick(() => 
				{
					for (let i = 0; i < 1000; i++)
					{
						this.count = i;
					}
					for (let i = 1000; i > 0; i--) 
					{
						this.count = i;
					}
					this.count--;
				})
				
				Button("C")
				.onClick(() => 
				{
				  this.value = 100;
				})
				
				Button("D")
				.onClick(() => 
				{
					setInterval(()=>{
					this.count++;
					}, 1000)
				})
				}
		}
}

 

按钮 A: 点击按钮 A 会将 this.count 设置为 0，这是直接赋值操作，会立即更新 UI，因为 this.count 是 @State 装饰的状态变量，任何改变都会触发 UI 刷新。

按钮 B: 点击按钮 B 会进行一个循环操作，但是在 JavaScript 中，事件处理函数是同步执行的。在循环结束之前，UI 不会刷新，只有当循环结束并且事件处理函数退出后，才会触发 UI 的刷新。因此，虽然有多次赋值操作，但只有最后一次赋值会影响 UI，其他的赋值操作在 UI 刷新之前都会被覆盖。

按钮 C: 点击按钮 C 会将 this.value 设置为 100，由于 this.value 是 @State 装饰的状态变量，并且有 @Watch('onValueChange') 监听器，当值发生变化时会触发 onValueChange 方法。在这个方法内部，this.count 被赋值为 this.value，因此会触发 UI 刷新。

按钮 D: 点击按钮 D 会启动一个 setInterval 定时器，每隔 1 秒将 this.count 自增 1。在 JavaScript 中，setInterval 是异步操作，UI 不会在每次计时器触发时立即刷新，而是在整个事件处理函数执行结束后才会考虑 UI 的刷新。因此，虽然 this.count 的值在变化，但 UI 不会实时更新，而是在处理函数结束后才更新。

5.出于安全因素考虑，ArkTS 不支持以下哪些语法(ABC)

A. with()
B. eval()
C. new Function('a', 'b', 'return a + b')
D. Object.entries()

6. 处于安全因素考虑，ArkTS不支持以下哪些语法（CD）

A. Object.entries()

B. new Function('a, 'b', return a * b)

C. with()

D. eval()

7.napi 代码有问题的选(A) 
 

//1.头文件和结构定义
#include <uv.h>
#include <node_api.h>
//uv.h 是 libuv 库的头文件，提供了跨平台的异步 I/O 支持和事件循环机制。
//node_api.h 是 Node.js C++ 插件开发的头文件，提供了与 Node.js API 交互的接口。

struct CallbackContext {
    napi_env env = nullptr;      // Node.js 环境指针
    napi_ref callbackRef = nullptr; // 回调函数引用
    int32_t retData = 0;         // 用于存储返回数据
};

//CallbackContext 结构体用于传递回调函数和环境相关的信息：
//env 存储了 Node.js 的环境指针，用于后续在 Node.js 环境中调用 API。
//callbackRef 是回调函数的引用，通过它可以获取回调函数的 JavaScript 对象。
//retData 是一个示例的返回数据，用于演示在异步操作完成后向 JavaScript 回调传递数据。

//2.callbackTest 函数是一个示例的异步函数，它使用 libuv 提供的 uv_queue_work 函数来在后台线程中执行任务，并在任务完成后回到主线程调用 JavaScript 回调函数。
void callbackTest(CallbackContext *context) {
    uv_loop_t *loop = nullptr;
    napi_get_uv_event_loop(context->env, &loop);
    
    uv_work_t *work = new uv_work_t;
    if (!work) {
        // Handle memory allocation failure
        delete context;
        return;
    }

    context->retData = 1;
    work->data = (void *)context;

    uv_queue_work(loop, work,
        [](uv_work_t *work) {
            // This lambda runs in a separate thread
            // You can perform background work here if needed
        },
        [](uv_work_t *work, int status) {
            // This lambda runs back in the main thread

            CallbackContext *context = (CallbackContext *)work->data;

            // Retrieve the callback function
            napi_value callback = nullptr;
            napi_get_reference_value(context->env, context->callbackRef, &callback);

            // Create the return argument
            napi_value retArg;
            napi_create_int32(context->env, context->retData, &retArg);

            // Call the JavaScript callback function
            napi_value ret;
            napi_call_function(context->env, nullptr, callback, 1, &retArg, &ret);

            // Delete the callback reference
            napi_delete_reference(context->env, context->callbackRef);

            // Clean up allocated resources
            delete work;
            delete context;
        }
    );
}

解释具体步骤：

1. 获取事件循环：

   • napi_get_uv_event_loop 函数用于获取当前 Node.js 环境的 libuv 事件循环。

2. 创建工作对象：

   • 使用 new 创建一个 uv_work_t 结构体对象 work，用于表示一个异步工作任务。

3. 设置任务数据：

   • 将 context 结构体作为任务的数据 (work->data)，以便在异步操作完成后可以访问到 context 中存储的数据。

4. 执行后台任务：

   • 调用 uv_queue_work 将工作任务加入 libuv 的工作队列中。第一个 Lambda 表达式定义了后台任务，此处示例中未做具体操作。

5. 主线程回调：

   • 第二个 Lambda 表达式定义了主线程中的回调函数。在此回调函数中进行以下操作：
     • 从 work 结构体中获取 context 数据。
     • 通过 napi_get_reference_value 获取回调函数的 JavaScript 对象。
     • 使用 napi_create_int32 创建一个返回给 JavaScript 的参数对象。
     • 调用 napi_call_function 执行 JavaScript 中的回调函数，并传递参数。
     • 使用 napi_delete_reference 删除回调函数的引用，释放资源。
     • 最后，删除 work 和 context 对象，释放相应的内存。
        

以上代码示例展示了如何在 C++ 中使用 libuv 和 Node.js API 开发一个简单的异步操作，涉及到后台线程的任务处理和主线程中的回调操作。这种模式适用于需要在后台执行计算密集型或 I/O 操作的情况，并且需要将结果返回给 Node.js 的应用场景。

8.以下关于 ArkTS 线程实例间传输实现方式描述正确的是（AD）
 

//1.导入模块和装饰器 
//@kit.ArkTS 是一个模块或库，提供了任务池 (taskpool) 和工作线程 (worker) 的功能。
import { taskpool, worker } from '@kit.ArkTS';


//2.类定义和装饰器
//@Sendable 装饰器可能是库中定义的一个装饰器，用于标记类 A，使其可以被序列化或者在不同线程之间共享。
@Sendable
class A {}
let a: A = new A();


//3.并发函数定义
@Concurrent 装饰器用于标记函数 foo，表示这是一个并发执行的函数，可能会被放入任务池中执行。
@Concurrent
function foo(a: A) {}

//4.创建任务对象
let task: taskpool.Task = new taskpool.Task(foo, a)

//5.创建工作线程对象
let w = new worker.ThreadWorker("entry/ets/workers/Worker.ets")

//6.执行任务池中的任务
taskpool.execute(task).then(() => {});

//7.向工作线程发送消息
w.postMessageWithSharedSendable(a);

//8.设置任务的克隆列表
task.setCloneList([a]);

//9.再次执行任务池中的任务
taskpool.execute(task).then(() => {});
//10.向工作线程发送消息（第二次）
w.postMessage(a)

这段代码展示了使用 @kit.ArkTS 框架进行任务池管理和工作线程管理的操作流程。通过装饰器 @Sendable 和 @Concurrent，标记了类和函数的特性，使其在异步和并发环境中能够正常工作。使用任务池来管理并发执行的任务，并通过工作线程对象向后台线程发送数据和执行指定的代码逻辑。

import { taskpool, worker } from '@kit.ArkTS';

@Sendable

class A {}

let a: A = new A();

@Concurrent

function foo(a: A) {}

let task: taskpool.Task = new taskpool.Task(foo, a)

let w = new worker.ThreadWorker("entry/ets/workers/Worker.ets")

taskpool.execute(task).then(() => {});

w.postMessageWithSharedSendable(a);

task.setCloneList([a]);

taskpool.execute(task).then(() => {});

w.postMessage(a);

A.

taskpool.execute(task).then(() => {}); ， TaskPool 共享传输实现方式

B.

task.setCloneList([a]);

taskpool.execute(task).then(() => {}); ， TaskPool 共享传输实现方式

C.

w.postMessage(a); ， Worker 共享传输实现方式

D.w.postMessageWithSharedSendable(a); ， Worker 共享传输实现方式

9.mage 组件以下哪些方式可显示图片？(ABCD)
 

A.
@Entry
@Component
struct ImageExample {
  build()
 {
    Column({ space: 10 }) 
   {
     Image($r('app.media.earth'))
     .width(100)
     .height(100)
   }
  }
}

1.这段代码是使用了某种声明式组件框架（可能是类似于React或Vue的框架）。@Entry 和 @Component 可能是用来标识这是一个入口点和组件的装饰器。
2.Image($r('app.media.earth')) 表示使用了一个名为 earth 的媒体资源来作为图片的来源。
3..width(100) 和 .height(100) 是对图片进行设置宽度和高度的操作。

B
@Entry
@Component
struct ImageExample {
    build() {
        Column({ space: 10 }) {
            Image("https://www.example.com/xxx.png")
            .width(100)
            .height(100)
        }
    }
}

Image("https://www.example.com/xxx.png") 表示使用了远程 URL https://www.example.com/xxx.png 的图片资源。

C
import image from '@ohos.multimedia.image'

@Entry
@Component
struct ImageExample {
    @State imagePixelMap: image.PixelMap | undefined = undefined

    async aboutToAppear() {
        this.imagePixelMap = await this.getPixmapFromMedia($r('app.media.app_icon'))
    }

    build() {
        Column() {
            Image(this.imagePixelMap)
            .width(200)
            .height(200)
        }
    }

    private async getPixmapFromMedia(resource: Resource) {
        let unit8Array = await getContext(this)?.resourceManager?.getMediaContent({
            bundleName: resource.bundleName,
            moduleName: resource.moduleName,
            id: resource.id
        })
        let imageSource = image.createImageSource(unit8Array.buffer.slice(0, unit8Array.buffer.byteLength))
        let createPixelMap: image.PixelMap = await imageSource.createPixelMap({
            desiredPixelFormat: image.PixelMapFormat.RGBA_8888
        })
        await imageSource.release()
        return createPixelMap
    }
}


//这段代码使用了 @ohos.multimedia.image 模块来处理图像资源。
//aboutToAppear() 是一个异步函数，用来在组件即将显示时加载图像资源。
//build() 方法中的 Image(this.imagePixelMap) 显示了通过 imagePixelMap 变量中存储的 PixelMap 数据来展示图片。
//getPixmapFromMedia() 是一个私有方法，用于从媒体资源中获取图像的 PixelMap 数据，并进行格式化处理。

D
import { DrawableDescriptor } from '@ohos.arkui.drawableDescriptor'

@Entry
@Component
struct ImageExample {
    private resManager = getContext().resourceManager

    build() {
        Row() {
            Column() {
                Image((this.resManager.getDrawableDescriptor($r('app.media.drawable').id) as DrawableDescriptor))
            }.height('50%')
        }.width('50%')
    }
}

这段代码使用了 @ohos.arkui.drawableDescriptor 模块来处理可绘制的描述符。
private resManager = getContext().resourceManager 定义了一个私有变量 resManager，用于获取上下文中的资源管理器。
build() 方法中，通过 resManager.getDrawableDescriptor() 方法获取到可绘制的描述符，然后将其作为参数传递给 Image 组件。
.height('50%') 和 .width('50%') 是设置 Image 组件高度和宽度的操作，使用了相对于父元素的百分比。

10.

在基于 Stage 模型开发的应用项目代码下，都存在一个 app.json5 配置文件，用于配置应用

的全局信息，以下 app.json5 配置文件错误的是(AD)

A.

{

"app": {

"bundleName": "com.example.myapplication",

"vendor": "example",

"versionCode": 1000000,

"versionName": "1.0.2",

"icon": "$media:app_icon",

"label": "app_name",

"bundleType": "app"

}

}

B.

{

"app": {

"bundleName": "com.example.myapplication",

"vendor": "example",

"versionCode": 1000000,

"versionName": "1.0.2",

"icon": "$media:app_icon",

"label": "$string:app_name",

"bundleType": "app"

}

}

C.

{

"app": {

"bundleName": "com.example.myapplication",

"vendor": "example",

"versionCode": 1000000,

"versionName": "1.0.2",

"icon": "$media:app_icon",

"label": "$string:app_name"

} }

D.

{

"app": {

"bundleName": "com.example.myapplication",

"vendor": "example", "versionCode": 1000000,

"icon": "$media:app_icon",

"label": "$string:app_name",

"bundleType": "app"

}

}

11通过如下 openLink 的接口启动，如下哪些配置的 UIAbility 不可能被拉起(BCD)
 

//1.导入模块说明
import { hilog } from '@kit.PerformanceAnalysisKit';
import { UIAbility, common, OpenLinkOptions } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';

hilog: 从 @kit.PerformanceAnalysisKit 模块中导入 hilog，用于日志记录和性能分析。
UIAbility, common, OpenLinkOptions: 从 @kit.AbilityKit 模块中导入 UIAbility 类、common 模块中的工具和常量、以及 OpenLinkOptions 类型。
BusinessError: 从 @kit.BasicServicesKit 模块中导入 BusinessError 类，用于处理业务逻辑中的错误。


//2.类定义
export default class MyAbility extends UIAbility {
    onForeground() {
        // 方法体
    }
}
MyAbility 类继承自 UIAbility，这意味着它可能是一个用户界面能力（UIAbility），用于处理应用程序在前台运行时的行为和交互。


//3.onForeground() 方法
onForeground() {
    let link: string = "https://www.example.com";
    let openLinkOptions: OpenLinkOptions = {
        appLinkingOnly: true,
        parameters: { demo_key: "demo_value" }
    };

    try {
        this.context.openLink(
            link,
            openLinkOptions,
            (err, result) => {
                hilog.error(DOMAIN, TAG, 'openLink callback error.code:' + JSON.stringify(err));
            }
        ).then(() => {
            hilog.info(DOMAIN, TAG, 'open link success.');
        }).catch((err: BusinessError) => {
            hilog.error(DOMAIN, TAG, 'open link failed, errCode ' + JSON.stringify(err.code));
        });
    } catch (e) {
        hilog.error(DOMAIN, TAG, 'exception occured, errCode ' + JSON.stringify(e.code));
    }
}

//onForeground() 方法是 UIAbility 类的一个生命周期方法，在应用程序切换到前台时调用。

代码逻辑解析：
定义变量:

link: 定义了一个字符串变量，表示要打开的链接地址。
openLinkOptions: 定义了一个 OpenLinkOptions 对象，配置了打开链接时的选项，包括是否仅允许应用内跳转和一些参数。
尝试打开链接:

使用 this.context.openLink() 方法来打开链接，传入链接地址 link 和选项 openLinkOptions。
使用回调函数 (err, result) 处理打开链接后的结果，如果有错误发生，则记录错误日志。
使用 Promise 的 .then() 方法处理打开链接成功后的日志记录。
使用 .catch() 方法处理可能抛出的 BusinessError 错误，记录错误日志。
异常处理:

使用 try-catch 块捕获可能发生的异常，如链接打开过程中的错误或其他运行时错误，然后记录相应的错误日志。

这段代码主要实现了在应用程序前台运行时，打开指定链接并处理可能的异常情况。它利用了异步操作和异常处理机制，以确保在链接打开过程中能够及时记录日志并处理错误。

import { hilog } from '@kit.PerformanceAnalysisKit';

import { UIAbility, common, OpenLinkOptions } from '@kit.AbilityKit';

import { BusinessError } from '@kit.BasicServicesKit';

export default class MyAbility extends UIAbility {

onForeground() {

let link: string = "https://www.example.com"

let openLinkOptions: OpenLinkOptions = {

appLinkingOnly: true,

parameters: {demo_key: "demo_value"}

};

try {

this.context.openLink( link,

openLinkOptions,

(err, result) => {

hilog.error(DOMAIN, TAG, 'openLink callback error.code:' + JSON.stringify(err));

}

).then(()=>{

hilog.info(DOMAIN, TAG, 'open link success.');

}).catch((err: BusinessError)=>{

hilog.error(DOMAIN, TAG, 'open link failed, errCode ' + JSON.stringify(err.code));

})

}

catch (e) {

hilog.error(DOMAIN, TAG, 'exception occured, errCode ' + JSON.stringify(e.code));

}

}

}

A

{
  "name": "TargetAbility",
  "skills": [
    {
      "actions": [
        "ohos.want.action.viewData" 
      ],
      "entities": [
        "entity.system.browsable"
      ],
      "uris": [
        {
          "scheme": "https",
          "host": "www.test.com",
          "port": "8080",
          "path": "path",
          "autoVerify": true
        }
      ]
    }
  ]
}


actions:描述: 定义了该技能支持的操作行为，这里指定了一个动作 "ohos.want.action.viewData"，表示能力可以执行查看数据的操作。

entities:描述: 指定了技能涉及的实体类型，这里指定了一个实体类型 "entity.system.browsable"，表示能力可以浏览可浏览的系统实体。
uris:描述: 包含了能力的URI配置，用于指定如何处理特定的URI请求。

配置文件 A 定义了一个名为 "TargetAbility" 的能力，该能力支持查看数据的操作，并且能够处理特定的 HTTPS URI 请求，其中包含了主机地址、端口、路径等信息，并且配置了自动验证功能。这种配置通常用于定义应用程序的能力和对外服务的接口规范。


不能被拉起的原因：

1.autoVerify 属性设置错误：

在配置文件 A 中，"autoVerify": ture 应该是一个拼写错误，应该是 "autoVerify": true。
如果 autoVerify 属性被错误地设置为 true，但实际情况下该能力不支持自动验证或者系统环境不支持此设置，可能导致拉起失败。
HTTPS URI 的目标地址问题：

2.虽然配置了 HTTPS 协议的 URI，但实际目标地址可能与 "www.test.com:8080/path" 不匹配。如果目标地址不可访问或者无效，启动可能会失败。
动作和实体类型匹配问题：

3.如果配置文件中指定的动作或实体类型与实际能力不匹配，也会导致拉起失败。例如，如果实际能力不支持 "ohos.want.action.viewData" 动作，或者不是一个浏览系统实体的能力，就会出现问题。

B

{
  "name": "TargetAbility",
  "skills": [
    {
      "actions": [
        "ohos.want.action.sendData"
      ],
      "entities": [
        "entity.system.browsable"
      ],
      "uris": [
        {
          "scheme": "https",
          "host": "www.test.com",
          "port": "8080",
          "path": "path",
          "autoVerify": true
        }
      ]
    }
  ]
}
actions: 包含一个动作 "ohos.want.action.sendData"，表示该能力支持发送数据的操作。
entities: 包含一个实体类型 "entity.system.browsable"，表示能力可以浏览可浏览的系统实体。
uris: 包含一个 HTTPS URI 配置，指定了主机地址为 "www.test.com"，端口为 "8080"，路径为 "/path"，并且设置了自动验证 (autoVerify) 为 true。

C

{
  "name": "TargetAbility",
  "skills": [
    {
      "actions": [
        "ohos.want.action.vieData"
      ],
      "entities": [
        "entity.system.browsable"
      ],
      "uris": [
        {
          "scheme": "http",
          "host": "www.test.com",
          "port": "8080",
          "path": "path"
        }
      ]
    }
  ]
}
actions: 包含一个动作 "ohos.want.action.vieData"，这里可能是一个笔误，应为 "ohos.want.action.viewData"。
entities: 包含一个实体类型 "entity.system.browsable"，表示能力可以浏览可浏览的系统实体。
uris: 包含一个 HTTP URI 配置，指定了主机地址为 "www.test.com"，端口为 "8080"，路径为 "/path"。

D

{
  "name": "TargetAbility",
  "skills": [
    {
      "actions": [
        "ohos.want.action.sendData"
      ],
      "entities": [
        "entity.system.browsable"
      ],
      "uris": [
        {
          "scheme": "http",
          "host": "www.test.com",
          "port": "8080",
          "path": "path",
          "autoVerify": true
        }
      ]
    }
  ]
}
actions: 包含一个动作 "ohos.want.action.sendData"，表示该能力支持发送数据的操作。
entities: 包含一个实体类型 "entity.system.browsable"，表示能力可以浏览可浏览的系统实体。
uris: 包含一个 HTTP URI 配置，指定了主机地址为 "www.test.com"，端口为 "8080"，路径为 "/path"，并且设置了自动验证 (autoVerify) 为 true。

12.下面代码符合 ArkTS 编程规范的是（ABC）

A.

if (flag) {

//...

}else {

//...

}

B. function fight(): void {

console.log('Swooosh!');

}

C.

const arr = [1, 2, 3];

D.

if(isJedi) {

fight();

}

13.Text 组件不支持以下哪种使用方式?(C)->(B)

 

A
@Entry
@Component
struct TextExample {
build(){
Column({ space:8}){
Text('textShadow').fontsize(9),fontcolor(0xcccccc).margin(15).width('90%')
}
    }
}

build() 方法是一个可能用于渲染界面的函数，但其内部的代码逻辑写法存在错误，比如逗号应该被替换为点号或分号。
明显语法错误

B
@Entry
@Component
struct styledStringDemo t
scroll: Scroller-new Scroller();mutableStyledString: Mutablestyledstring = new 
Mutablestyledstring("test hello i
start: 0
length: 5.
styledKey: styledstringKey.FONT,
styledValue: new Textstyle({ fontcolor:color.Pink })
}1);
controllerl: Textcontroller=new Textcontroller();
async onPageShow(){
this.controllerl.setstyledstring(this.mutableStyledstring)
build(){
Column(){Text(undefined, { controller: this.controller1 })}.width('100 号')


这段代码存在严重的语法错误和不完整的结构体声明。
struct styledStringDemo t 不是有效的 TypeScript 语法。应该使用 class 或 interface 来定义类或接口。
后续的代码混乱，括号和分号的位置不正确，导致代码无法正确解析。
async onPageShow() 和 build() 方法中的代码也没有正确的 TypeScript 语法结构。
这段代码不能被 TypeScript 正确解析和编译。

C
struct styledStringDemo {
    scroll: Scroller = new Scroller();
    layout: TextLayoutManager = new TextLayoutManager();
    controller1: TextController = new TextController();

    async onPageShow() {
        this.controller1.setLayout(this.layout);
    }

    build() {
        Column() {
            Text(undefined, { controller: this.controller1 }).width('100%');
        }
    }
}

这段代码看起来更接近 TypeScript 的语法。
使用了 struct 来定义 styledStringDemo，不过在 TypeScript 中一般使用 class 或 interface 更为常见。
定义了几个成员变量：scroll、layout 和 controller1，分别是 Scroller、TextLayoutManager 和 TextController 类的实例。
async onPageShow() 方法是一个异步方法，用于在页面展示时设置 controller1 的布局。
build() 方法用于构建界面，包括一个 Column 布局和一个 Text 组件，使用了 controller1。

D
struct SpanExample {
    build() {
        Flex({
            direction: FlexDirection.Column,
            alignItems: ItemAlign.Start,
            justifyoText() {
                Span('In Line');
                Span(' Component');
                Span('!');
            }
        }).width('100%').height(250).padding({ left: 35, right: 35, top: 35 });
    }
}
这段代码看起来也是类似 TypeScript 的语法。
使用了 struct 来定义 SpanExample，同样，应该使用 class 或 interface 更为合适。
build() 方法用于构建界面，使用了 Flex 布局，并嵌套了三个 Span 组件。
Flex 组件设置了方向为竖直列（Column），对齐方式为起始位置，内部使用了 Span 组件来渲染文本。
最后，设置了 Flex 组件的宽度、高度和内边距。

14

想要提前预览下所编写的组件的效果，下述哪个组件可以使用 DevEco Studio Previewer 正常预览?(C)

B
@Preview
@Component
struct ConsumeSample {
    @Consume name: string;

    build() {
        Text(this.name);
    }
}

@Consume name: string; 的语法不太清晰，可能需要进一步的修正。
缺少 import 语句导入 @Consume。

C
@Preview
@Component
struct TitleSample {
    @StorageProp('title') title: string = 'PlaceHolder';

    build() {
        Text(this.title);
    }
}

使用了 @Preview 注解标记为预览组件。
使用了 @StorageProp('title') 注解来声明一个存储属性。
build() 方法中使用了 Text(this.title); 来显示文本内容。
结论:

选项 C 正确使用了 @Preview 和 @StorageProp 注解，可以作为预览组件使用

@Preview
@Component
struct LinkSample {
    @Link message: string;

    build() {
        Text(this.message);
    }
}

@Link message: string; 的语法不太清晰，可能需要进一步的修正。
缺少 import 语句导入 @Link。

15HSP 支持导出 ArkUI 组件、接口，供应用内的其他 HAP/HSP 引用，下面正确的是
（ABC）
 

A
// library/src/main/ets/utils/test.ts
export class Log {
    static info(msg: string): void {
        console.info(msg);
    }
}

export function add(a: number, b: number): number {
    return a + b;
}

export function minus(a: number, b: number): number {
    return a - b;
}

这段代码导出了一个 Log 类和两个函数 add 和 minus。
在 index.ets 中通过 export { Log, add, minus } from './src/main/ets/utils/test'; 导出这些类和函数，使其可以在其他地方引用和使用。

B
// library/src/main/ets/utils/nativeTest.ts
import native from 'liblibrary.so';

export function nativeMulti(a: number, b: number): number {
    let result: number = native.multi(a, b);
    return result;
}
这段代码展示了如何在 HSP 中调用 liblibrary.so 中的本地方法 multi。
在 index.ets 中通过 export { nativeMulti } from './src/main/ets/utils/nativeTest'; 导出 nativeMulti 函数，使其在其他地方可以调用。

C
// library/src/main/ets/components/MyTitleBar.ets
@Component
export struct MyTitleBar {
    build() {
        Row() {
            Text($r('app.string.library_title'))
                .id('library')
                .fontFamily('HarmonyHeiTi')
                .fontWeight(FontWeight.Bold)
                .fontSize(32)
                .fontColor($r('app.color.text_color'));
        }
        .width('100%');
    }
}

这段代码定义了一个名为 MyTitleBar 的 ArkUI 组件。
使用 @Component 注解标记这是一个组件。
在 index.ets 中通过 export { MyTitleBar } from './src/main/ets/components/MyTitleBar'; 导出 MyTitleBar 组件，使其在其他地方可以被引用和使用。

总结解释:

• 选项 A 展示了如何导出 TypeScript 类和函数，适合在 HSP 中使用纯 TypeScript 编写的工具类和函数。
• 选项 B 展示了如何在 HSP 中调用包含本地方法的 .so 文件，并导出这些方法供其他组件或应用使用。
• 选项 C 展示了如何在 HSP 中定义并导出 ArkUI 组件，使其可以在其他地方作为 UI 组件被引用和渲染。

因此，正确的选项是 A、B、C，它们分别展示了不同类型的导出方法：纯 TypeScript 类和函数、包含本地方法的 .so 文件调用，以及 ArkUI 组件的导出。