华为鸿蒙高级认证考试（2024-07）/ 多选题

1、用户购买商品后，开发者需要及时发放相关权益。但实际应用场景中，若出现异常（网络错误、进程被中止等）将导致应用无法知道用户实际是否支付成功，从而无法及时发放权益，即出现掉单情况。为了确保权益发放，需要在以下场景检查用户是否存在已购未发货的商品：（ABD）

A、应用启动时

B、createPurchase 请求返回1001860051-由于已经拥有该商品，购买失败时

C、finishPurchase 请求返回1001860052-由于未拥有该商品，发货失败时

D、createPurchase 请求返回1001860001-内部错误时

2、某业务团队发现用户对他们App的某个特性使用率并不高，为了节省用户首次下载安装包的体积，考虑将该特性做成按需加载，那么推荐该特性使用的工程模块类型是？（BC）

A.app

B.hsp

C.hap

D.har

3、arkts 中不能使用以下哪些类型（AD）

A、any

B、tuple type

C、union type

D、unknown

4、下面关于混淆规则描述正确的是（BC）

A、 -keep-property-name [,identifiers,...]: 指定要保留的顶层作用域的名称

B、 -keep-file-name [,identifiers,...]: 指定要保留的文件/文件夹的名称

C、-print-namecache filepath: 将名称缓存保存到指定的文件路径

D、-keep-global-name [,identifiers,...]: 指定想保留的属性名

5、下面关于混淆规则描述正确的是（CD）

A、 -enable-property-obfuscation: 开启顶层作用域的名称混淆

B、 -enable-toplevel-obfuscation: 开启属性混淆

C、-enable-export-obfuscation: 开启直接导入或导出的类或对象的名称和属性名混淆

D、-disable-obfuscation: 关闭所有混淆

6、以下关于 Taskpool 和 Worker 描述正确的是（CD）

A、Worker 支持取消已发起的任务

B、Taskpool 不支持线程复用

C、Worker 的任务执行时长上限是无限制

D、Taskpool 支持设置任务的优先级

7、以下代码片段哪几处违反了ArkTs语法规范（BCD）

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!';

A、let p = new Point(1.0,1.0);

B、delete p.x;

C、p.z = 2.0;

D、p.x = 'hello!';

8、在ArkTs中，以下哪些属性的声明是正确的。（ACD）

class C {
  value1: number = 0;
  value2?: number=null;
  value3: number | undefined = undefined;
  value4?: number;
}

A、value1

B、value2

C、value3

D、value4

9、下面关于方舟字节码指令含义说明正确的是（CD）

A.假设寄存器v0存放了对象A, 寄存器v1存放了对象B，那么执行指令"mov v0, v1"后，v0存放对象A, v1存放对象A

B.假设寄存器v0存放了对象A, 累加器(acc)存放了对象B，那么执行指令"lda v0"后，v0存放对象B，acc存放对象B

C.假设寄存器v0存放了对象A, 累加器(acc)存放了对象B，那么执行指令"lda v0"后，v0存放对象A，acc存放对象A

D.假设寄存器v0存放了对象A, 寄存器v1存放了对象B，那么执行指令"mov v0, v1"后，v0存放对象B, v1存放对象B

10、下面关于ArkTS中export用法，正确的是（ABCD）

A.export { export1 as alias1 } from "ets file name";

B.export { export1 } from "ets file name";

C.export * as name from "ets file name"

D.export * from "ets file name"

11、Code Linter针对ArkTS/TS代码进行最佳实践/编程规范方面的检查，最佳实践/编程规范方面的检查规则可以配置，针对codelinter的配置项一下哪些说法是正确的（ABD）

A.ruleSet：配置检查使用的规则集，规则集支持一次导入多条规则。

B.ignore：配置无需检查的文件目录，其指定的目录或文件需使用相对路径格式，相对于code-linter.json5所在工程根目录，例如：build/**/*。

C.rules：可以基于ruleSet配置的规则集，新增额外规则项，但是无法修改ruleSet中规则默认配置
  
D.files：配置待检查的文件名单，如未指定目录，规则适用于所有文件，例如：[“**/*.ets”,”**/*.js”,”**/*.ts”]。

12、下面代码符合Node-API开发规范的是（AB）

A.

static napi_value Demo3(napi_env env, napi_callback_info info)
{
    size_t argc = 2;
    napi_value argv[2] = {nullptr};

    napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);
    // 业务代码
    return nullptr;
}

B.

static napi_value Demo2(napi_env env, napi_callback_info info)
{
    size_t argc = 0;

    napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr);

    if (argc == 0) {
        return nullptr;
    }

    napi_value* argv = new napi_value[argc];
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    // 业务代码
    delete argv;
    return nullptr;
}

C.

static napi_value Demo4(napi_env env, napi_callback_info info)
{
    size_t argc = 5;
    napi_value argv[3] = {nullptr};
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    return nullptr;
}

D.

static napi_value Demo1(napi_env env, napi_callback_info info)
{
    size_t argc;
    napi_value argv[10] = {nullptr};
    napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr);
    return nullptr;
}

13、在基于Stage模型开发的应用项目代码下，都存在一个app.json5配置文件，用于配制应用的全局信息，以下app.json5配置文件错误的是（CD）

A、

{
  "app": {
    "bundleName": "com.example.myapplication2",
    "vendor": "example",
    "versionCode": 1000000,
    "versionName": "1.0.2",
    "icon": "$media:app_icon",
    "label": "$string:app_name"
  }
}

B、

{
  "app": {
    "bundleName": "com.example.myapplication2",
    "vendor": "example",
    "versionCode": 1000000,
    "versionName": "1.0.2",
    "icon": "$media:app_icon",
    "label": "$string:app_name",
    "bundleType": "app"
  }
}

C、

{
  "app": {
    "bundleName": "com.example.myapplication2",
    "vendor": "example",
    "versionCode": 1000000,
    "versionName": "1.0.2",
    "icon": "$media:app_icon",
    "label": "app_name",
     "bundleType": "app"
  }
}

D、

{
  "app": {
    "bundleName": "com.example.myapplication2",
    "vendor": "example",
    "versionCode": 1000000,
    "icon": "$media:app_icon",
    "label": "$string:app_name",
    "bundleType": "app"
  }
}

14、以下哪些方式可以实现ArkWeb同层渲染能力 （AC）

A
Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("object", "test")
<object id="view" type="test/contents" width="100%" height="100%" style="background-color:red"/>

B
Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("native", "test")
<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

C
Web(...).enableNativeEmbedMode(true)
<embed id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

D
Web(...).enableNativeEmbedMode(true)
<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

15、以下关于LocalStorage 的说法正确有哪些（ABD）

A、应用程序可以创建多个LocalStorage实例，LocalStorage实例可以在页面内共享，也可以通过GetShared接口，实现跨页面、UIAbility实例内共享。

B、组件树的根节点，即被@Entry装饰的@Component，可以被分配一个LocalStorage实例，此组件的所有子组件实例将自动获得对该LocalStorage实例的访问权限。

C、LocalStorage中的所有属性都是不可变的。

D、被@Component装饰的组件最多可以访问一个LocalStorage实例和AppStorage，未被@Entry装饰的组件不可被独立分配LocalStorage实例，只能接受父组件通过@Entry传递来的LocalStorage实例。一个LocalStorage实例在组件树上可以被分配给多个组件。

16、ArkTS对并发编程API和能力进行了增强，以下描述正确的是（AB）

A.CPU密集型任务场景中，当任务不需要长时间（3分钟）占据后台线程，而是一个个独立的任务时，推荐使用TaskPool进行开发。

B.在并发API的形式上，目前主要有两种：Worker和TaskPool。

C.默认情况下，Sendable数据在ArkTS并发实例间（包括主线程、TaskPool&Worker工作线程）传递的行为是拷贝传递。

D.单次I/O任务的开发场景中，必须使用TaskPool进行开发。

17、以下关于ArkTS线程实例间传输实现方式描述正确的是（BD）

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")

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

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

// 3. TaskPool 拷贝传输实现方式
task.setCloneList([a]);
taskpool.execute(task).then(() => {});

// 4. Worker 拷贝传输实现方式
w.postMessage(a);

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

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

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

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

18、在开发HarmonyOS应用的多元化测试环境中，DevEco Studio引入了本地模拟器（Local Emulator）作为重要工具，旨在帮助开发者在个人开发机器上高效模拟HarmonyOS环境，进行应用或服务的快速运行与细致调试。请根据本地模拟器的实际应用场景与系统要求，选出所有正确的描述选项（ABD）

A.为了保证流畅的运行和调试体验，本地模拟器推荐macOS系统版本至少为12.5以上。

B.mac计算机配置方面，为了确保本地模拟器的稳定运行，推荐至少配备8GB RAM。

C.开发者需要注意的是，DevEco Studio的本地模拟器可以在虚拟机内部进一步运行，以节省硬件资源。

D.DevEco Studio的本地模拟器允许开发者在个人电脑上模拟HarmonyOS环境，便于应用或服务的运行与调试。

19、在基于Stage模型开发的应用项目代码下，每个模块都存在一个module.json5配置文件，用于配置模块的基本信息，以下module.json5配置文件正确的是（ACD）

A.

{
  "module": {
    "name": "bName",
    "type": "shared",
    "deviceTypes": [
      "default",
      "tablet"
    ],
    "deliveryWithInstall": true,
    "pages": "$profile:main_pages"
  }
}

B.

{
  "module": {
    "name": "cName",
    "type": "hsp",
    "description": "$string:desc",
    "deviceTypes": [
      "default",
      "tablet"
    ],
    "deliveryWithInstall": true,
    "pages": "$profile:main_pages"
  }
}

C.

{
  "module": {
    "name": "application",
    "type": "feature",
    "description": "$string:module_desc",
    "mainElement": "ApplicationAbility",
    "deviceTypes": [
      "default",
      "tablet"
    ],
    "deliveryWithInstall": true,
    "installationFree": false,
    "pages": "$profile:main_pages",
    "abilities": [
      {
        "name": "ApplicationAbility",
        "srcEntry": "./ets/applicationability/ApplicationAbility.ets",
        "description": "$string:ApplicationAbility_desc",
        "icon": "$media:icon",
        "label": "$string:ApplicationAbility_label",
        "startWindowIcon": "$media:startIcon",
        "startWindowBackground": "$color:start_window_background",
        "exported": true
      }
    ]
  }
}

D.

{ 
  "module": { 
    "name": "aName", 
    "type": "har", 
    "deviceTypes": [ 
    "default", "tablet" ]
    }
}

20、小华正在使用DevEco Studio开发一个复杂的HarmonyOS应用，他意识到代码中有一段逻辑被多次重复使用，为了优化代码结构和减少冗余，他决定将这段逻辑提取出来作为一个独立的方法。同时，他也注意到有些常用的硬编码值可以抽象为常量，以提高代码的可读性和维护性。小华希望利用DevEco Studio的代码重构功能来高效完成这些任务，通过以下哪些操作来实现代码重构，以提升编码效率（ABCD）

A、为了简化复杂类型的多次书写，小华可以选择特定类型字面量，通过“Refactor”菜单下的“Extract Type Alias”来创建类型别名

B、若需要将局部变量提升为类成员变量，小华只需简单选中变量名，右键选择“Refactor” -> “Promote Local Variable”

C、选中需要重构的代码块，右键点击选择“Refactor”，然后选择“Extract Method”来将代码块转换为一个新的函数/方法

D、如果小华识别到一组相关的对象字面值可以抽象为一个接口，他可以直接通过“Refactor”菜单中的“Extract Interface”功能实现

21、在大型软件工程中，一般会伴随着多团队开发，各团队开发自己的业务模块，最后再由集成交付团队集成到一起，下面哪些事大型应用模块开发最佳实践（ABCD）

A、避免用户首次下载应用耗时过长，及时多占用用户空间，不常用功能做成按需加载。

B、若多个模块依赖了不同版本的HAR，使用OHPM的overrides机制配置指定使用哪个版本的HAR，以减少包大小

C、使用路由表进行模块间解耦

D、一次上架多端部署

22、ArkTS是鸿蒙生态的应用开发语言。下列说法正确的是（ABD）

A.ArkTS在保持TypeScript（简称TS）基本语法风格的基础上，进一步通过规范强化静态检查和分析，使得在程序运行之前的开发期能检测更多错误，提升代码健壮性，并实现更好的运行性能。

B.针对JavaScript（简称JS）/TS并发能力支持有限的问题，ArkTS对并发编程API和能力进行了增强。

C.TS/JS代码支持import ArkTS代码。

D.ArkTS提供了声明式UI范式、状态管理支持等相应的能力，让开发者可以以更简洁、更自然的方式开发应用。

23、下面关于动态import描述正确的是（ACD）

A.动态import根据入参是否为常量字符串分为常量动态import和变量动态import两种

B.常量动态import也必须配置runtimeOnly选项

C.动态导入import()是个异步接口，调用后将返回一个promise

D.HAR模块间只有变量动态import时可以进行模块解耦

24、依次点击A、B、C、D四个按钮，其中不会触发UI刷新的是（AD）

Entry
@Component
struct Index {
  @State count: number = 0;
  @State @Watch('onValueChange') value: number = 50;

  onValueChange() {
    this.count = this.value;
  }
  build() {
    Column() {
      Text(`${this.count}`)
      Button("A")
        .onClick(() => {
          this.count = 0;
        })
      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

B.D

C.C

D.B

25、通过如下openLink的接口启动，如下哪些配置的UIAbility不可能被拉起（BCD）

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": ture
          }
        ]
      }
    ]
}

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": ture
          }
        ]
      }
    ]
}

C

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

D

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

26、下面代码符合ArkTS编程规范的是（BC）

A.

for (let idx = 0; idx < 5; ++idx)
  console.log(idx);

B.

let maxCount = 10;
let isCompleted = false;
let pointX = 0;
let pointY = 0;

C.

if (condition) {
  console.log('success');
}

D.

let maxCount = 10, isCompleted = false;
let pointX, pointY;
pointX = 10; pointY = 0;

27、在ArkTS中，以下代码片段正确的是（AC）

A.

function fn(x: string | number): string {
  return 'value: ' + x;
}

type funcType = (ns: string | number) => string;
let func: funcType = fn;

B.

function fn(x: string | number): void {
  console.log('value: ' + x);
}

type funcType = (ns: string | number) => string;
let func: funcType = fn;

C.

function fn(x: string | number): string {
  return 'value: ' + x;
}

type funcType = (ns: string) => string;
let func: funcType = fn;

D.

function fn(x: string): string {
  return x;
}

type funcType = (ns: string | number) => string;
let func: funcType = fn;

28、Image组件以下哪些方式可显示图片？（ABCD）

A.

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

B.

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%')
  }
}

C.

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

D.

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
  }
}

29、如下ABC 3处手势，有机会执行的是哪几处？（AC）

@Entry
@Component
struct ListTest {
  scroller: Scroller = new Scroller()
  scroller2: Scroller = new Scroller()
  scroller3: Scroller = new Scroller()
  private arr: number[] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  private childRecognizer: GestureRecognizer = new GestureRecognizer()
  private currentRecognizer: GestureRecognizer = new GestureRecognizer()
  private lastOffset: number = 0


  build() {
    Stack({ alignContent: Alignment.TopStart }) {
      Scroll(this.scroller) {
        Column() {
          Text("Scroll Area")
            .width('90%')
            .height(150)
            .backgroundColor(0xFFFFFF)
            .borderRadius(15)
            .fontSize(16)
            .textAlign(TextAlign.Center)
            .margin({ top: 10 })
          List({ space: 20, initialIndex: 0 }) {
            ForEach(this.arr, (item: number) => {
              ListItem() {
                Text('' + item)
                  .width('100%').height(100).fontSize(16)
                  .backgroundColor(Color.Blue)
                  .textAlign(TextAlign.Center).borderRadius(10)
              }
            }, (item: string) => item)
          }
          .listDirection(Axis.Vertical) // 排列方向
          .scrollBar(BarState.Off)
          .friction(0.6)
          .divider({ strokeWidth: 2, color: 0xFFFFFF, startMargin: 20, endMargin: 20 }) // 每行之间的分界线
          .edgeEffect(EdgeEffect.None) // 边缘效果设置为Spring
          .height(1000)
          .width('90%')
          .id("inner")
        }.width('100%')
      }
      .id("outer")
      .height(600)
      .scrollable(ScrollDirection.Vertical) // 滚动方向纵向
      .scrollBar(BarState.On) // 滚动条常驻显示
      .scrollBarColor(Color.Gray) // 滚动条颜色
      .scrollBarWidth(10) // 滚动条宽度
      .edgeEffect(EdgeEffect.None)
      .onScroll((xOffset: number, yOffset: number) => {
        console.info(xOffset + ' ' + yOffset)
      })
      .onScrollEdge((side: Edge) => {
        console.info('To the edge')
      })
      .onScrollStop(() => {
        console.info('Scroll Stop')
      })
 A   .gesture(
        TapGesture({ count: 2 })
          .onAction((event: GestureEvent) => {
            if (event) {
              this.value = JSON.stringify(event.fingerList[0])
            }
          })
        )
 B   .gesture(
        PanGesture({PanDirection.Vertical})
          .onActionUpdate((event: GestureEvent)=>{
            console.log("zcb onActionUpdate event offsetY " + event.offsetY + " this.lastOffset " + this.lastOffset + " this.childRecognizer.getGestureState() " + this.childRecognizer.getState())
          })
      )
C   .parallelGesture(
        PanGesture({PanDirection.Vertical})
          .onActionUpdate((event: GestureEvent)=>{
            console.log("zcb onActionUpdate event offsetY " + event.offsetY + " this.lastOffset " + this.lastOffset + " this.childRecognizer.getGestureState() " + this.childRecognizer.getState())
          })
      )
    }.width('100%').height('100%').backgroundColor(0xDCDCDC)
  }
}

A.A

B.NA

C.C

D.B

30、下面代码符合ArkTS编程规范的是（ABCD）

A.

if (flag) {
  //...
}else {
  //...
}

B.

function fight(): void {
  console.log('Swooosh!');
}

C.

if(isJedi) {
  fight();
}

D.

const arr = [1, 2, 3]

31、哪些是持续集成最佳实践（ACEFG）

A.全面的测试套件：包括单元测试、集成测试、功能测试等，以提高代码质量。

B.构建相同代码的 Pipeline 运行多次，得到结果不同。比如，基于同一代码基线，一条 Pipeline 构建了 5 次，只要最后一次通过即可。

C.频繁提交代码：鼓励开发人员经常提交小的代码更改，以便更快地发现问题。

D.通常项目上会有一个专职 Ops，在项目可以发布的时候手动触发部署流程，或者需要传递很多参数，让 Pipeline 运行起来。

E.快速反馈机制：让开发人员能迅速得知集成结果和测试状态。

F.自动化构建：确保构建过程是完全自动化的，减少人为错误。

G.代码审查：在集成前进行代码审查，及时发现潜在问题。

32、如果想让grid上的捏合手势手势生效，而不跟grid上的滚动手势形成冲突，.xxxx?手势接口应该怎么配置?（BCD）

Grid() {
        ForEach(this.numbers, (day: string) => {
          ForEach(this.numbers, (day: string) => {
            GridItem() {
              Text(day)
                .fontSize(16)
                .backgroundColor(0xF9CF93)
                .width('100%')
                .height(80)
                .textAlign(TextAlign.Center)
            }
          }, (day: string) => day)
        }, (day: string) => day)
      }
      .columnsTemplate('1fr '.repeat(this.columns))
      .columnsGap(10)
      .rowsGap(10)
      .width('90%')
      .scrollBar(BarState.Off)
      .backgroundColor(0xFAEEE0)
      .height('100%')
      .cachedCount(3)
      // 切换列数item位置重排动画
      .animation({
        duration: 300,
        curve: Curve.Smooth
      })
      .xxxx?(
        PinchGesture()
          .onActionEnd((event: GestureEvent) => {
            console.info('end scale:' + event.scale)
            // 手指分开，减少列数以放大Item，触发阈值可以自定义，示例为2
            if (event.scale > 2) {
              this.columns--
            } else if (event.scale < 0.6) {
              this.columns++
            }
            // 可以根据设备屏幕宽度设定最大和最小列数，此处以最小1列最大4列为例
            this.columns = Math.min(4, Math.max(1, this.columns));
            AppStorage.setOrCreate('columnsCount', this.columns)
          })
      )

A.GesureGroup

B.gesture

C.priorityGesture

D.parallelGesture

33、以下哪些是可以在Navigation中使用pushPathByName接口传递的params的参数类型（BCD）

A、map<string,string>

B、arrayBuffer

C、string

D、record<string,string>

34、使用ArkUI组件复用之后，还是没有显著提升列表滑动场景的性能，属于组件复用未生效可能的原因有？（ABC）

A.复用的自定义组件中使用if等条件渲染语句导致结构不相同，未使用reuseId标记。

B.在aboutToReuse回调函数中更新了冗余的状态变量

C.页面嵌套了过多自定义组件。

D.没有在aboutToReuse更新关联的状态变量数据。

35、如何实现类似下图布局（AB）

A.

@Entry
@Component
struct Demo {
  // 忽略其他辅助代码
  dataSource: ItemDataSource = new ItemDataSource(100)
  itemHeightArray: number[] = []
  colors: number[] = [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F]
  scroller: Scroller = new Scroller()

  @State sections: WaterFlowSections = new WaterFlowSections()
  sectionMargin: Margin = { top: 10, left: 5, bottom: 10, right: 5 }
  oneColumnSection: SectionOptions = {
    itemsCount: 3,
    crossCount: 1,
    rowsGap: 10,
    margin: this.sectionMargin,
    onGetItemMainSizeByIndex: (index: number) => {
      return this.itemHeightArray[index % 100]
    }
  }

  lastSection: SectionOptions = {
    itemsCount: 97,
    crossCount: 2,
    margin: this.sectionMargin,
    onGetItemMainSizeByIndex: (index: number) => {
      return this.itemHeightArray[index % 100]
    }
  }

  aboutToAppear() {
    this.setItemSizeArray()
    // 初始化瀑布流分组信息
    let sectionOptions: SectionOptions[] = []
    sectionOptions.push(this.oneColumnSection)
    sectionOptions.push(this.lastSection)
    this.sections.splice(0, 0, sectionOptions)
  }

  build() {
      WaterFlow({ scroller: this.scroller, sections: this.sections }) {
        LazyForEach(this.dataSource, (item: number) => {
          FlowItem() {
            ReusableFlowItem({ item: item })
          }
          .width('100%')
          .backgroundColor(this.colors[item % 5])
        }, (item: string) => item)
      }
      .columnsGap(10)
      .rowsGap(5)
      .backgroundColor(0xFAEEE0)
      .width('100%')
      .height('100%')
  }
}

B.

@Entry
@Component
struct Demo {
  // 忽略其他辅助代码
  dataSource: ItemDataSource = new ItemDataSource(100)
  itemHeightArray: number[] = []
  colors: number[] = [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F]
  scroller: Scroller = new Scroller()

  aboutToAppear() {
    this.getItemSizeArray()
  }

  build() {
    Column() {
      List({ scroller: this.scroller, space: 10 }) {
        ListItem() {
          Grid() {
            GridItem() {
              Text('GoodsTypeList')
            }.backgroundColor(this.colors[0])

            GridItem() {
              Text('AppletService')
            }.backgroundColor(this.colors[1])

            GridItem() {
              Text('ReloadData')
            }.backgroundColor(this.colors[2])
          }
          .rowsGap(10)
          .columnsTemplate('1fr')
          .rowsTemplate('1fr 1fr 1fr')
          .width('100%')
          .height(100)
        }

        ListItem() {
          WaterFlow() {
            LazyForEach(this.datasource, (item: number, index: number) => {
              FlowItem() {
                // 使用可复用自定义组件
                ReusableItem({ item: item + index })
              }
              .width('100%')
              .height(this.itemHeightArray[item % 100])
              .backgroundColor(this.colors[item % 5])
            }, (item: number) => '' + item + this.itemHeightArray[item % 100])
          }
          .id('waterflow')
          .columnsTemplate("1fr 1fr")
          .columnsGap(10)
          .rowsGap(5)
          .width('100%')
          .height('100%')
          .nestedScroll({
            scrollForward: NestedScrollMode.PARENT_FIRST,
            scrollBackward: NestedScrollMode.SELF_FIRST
          })
        }
      }
      .scrollBar(BarState.Off)
      .edgeEffect(EdgeEffect.None)
    }
    .width('100%')
    .padding({ left: 10, right: 10 })
  }
}

C.

@Entry
@Component
struct Demo {
  // 忽略其他辅助代码
  dataSource: ItemDataSource = new ItemDataSource(100)
  itemHeightArray: number[] = []
  colors: number[] = [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F]
  scroller: Scroller = new Scroller()
  
  aboutToAppear() {
    this.getItemSizeArray()
  }

  build() {
    Scroll() {
      Column() {
        Grid() {
          GridItem() {
            Text('GoodsTypeList')
          }
          .backgroundColor(this.colors[0])

          GridItem() {
            Text('AppletService')
          }
          .backgroundColor(this.colors[1])

          GridItem() {
            Text('ReloadData')
          }
          .backgroundColor(this.colors[2])
        }
        .rowsGap(10)
        .columnsTemplate('1fr')
        .rowsTemplate('1fr 1fr 1fr')
        .width('100%')
        .height(100)
        .margin({
          top: 10,
          left: 5,
          bottom: 10,
          right: 5
        })

        Grid() {
          LazyForEach(this.datasource, (item: number) => {
            GridItem() {
              // 使用可复用自定义组件
              ReusableItem({ item: item })
            }
            .width('100%')
            .height(this.itemHeightArray[item % 100])
            .backgroundColor(this.colors[item % 5])
          }, (item: number) => '' + item + this.itemHeightArray[item % 100])
        }
        .columnsTemplate("1fr 1fr")
        .columnsGap(10)
        .rowsGap(5)
        .width('100%')
        .nestedScroll({
          scrollForward: NestedScrollMode.PARENT_FIRST,
          scrollBackward: NestedScrollMode.SELF_FIRST
        })
      }
    }
    .scrollBar(BarState.Off)
    .edgeEffect(EdgeEffect.None)
  }
}

36、某个应用的启动框架配置文件详细信息如下，以下说法正确的是（ABD）

{

  "startupTasks": [

    {

      "name": "StartupTask_001",

      "srcEntry": "./ets/startup/StartupTask_001.ets",

      "dependencies": [

        "StartupTask_002",

        "StartupTask_003"

      ],

      "runOnThread": "taskpool",

      "waitOnMainThread": false

    },

    {

      "name": "StartupTask_002",

      "srcEntry": "./ets/startup/StartupTask_002.ets",

      "dependencies": [

        "StartupTask_004"

      ],

      "runOnThread": "taskpool",

      "waitOnMainThread": false

    },

    {

      "name": "StartupTask_003",

      "srcEntry": "./ets/startup/StartupTask_003.ets",

      "runOnThread": "taskpool",

      "waitOnMainThread": false

    },

    {

      "name": "StartupTask_004",

      "srcEntry": "./ets/startup/StartupTask_004.ets",

      "runOnThread": "taskpool",

      "waitOnMainThread": false

    },

    {

      "name": "StartupTask_005",

      "srcEntry": "./ets/startup/StartupTask_005.ets",

      "runOnThread": "mainThread",

      "waitOnMainThread": true

    },

    {

      "name": "StartupTask_006",

      "srcEntry": "./ets/startup/StartupTask_006.ets",

      "runOnThread": "mainThread",

      "waitOnMainThread": false,

      "excludeFromAutoStart": true

    }

  ],

  "configEntry": "./ets/startup/StartupConfig.ets"

}

A.StartupTask_001会在StartupTask_004之后执行;

B.StartupTask_005会在主线程执行

C.StartupTask_003会在StartupTask_004之后执行

D.StartupTask_006会在AbilityStage的onCreate前初始化完成

37、为了加快构建速度，提高开发效率，可以如何调整hvigor配置，从而优化构建速度（BCD）

A.启用hvigor的typeCheck，在增量场景下进行对hvigorfile.ts进行类型检查

B.启用hvigor的parallel，在增量场景下进行并行编译处理

C.启用hvigor的incremental，在增量场景下检查任务是否可以跳过

D.启动hvigor的daemon模式，在增量场景下复用缓存

38、以下哪些实现方式可实现文本字号20的效果（ABD）

A.

import { LengthMetrics, LengthUnit } from '@ohos.arkui.node'

@Entry
@Component
struct Index {
  fontStyleAttr: TextStyle = new TextStyle({fontSize:LengthMetrics.vp(20)});
  mutableStyledString: MutableStyledString = new MutableStyledString("hello", [{
    start: 0,
    length: 5,
    styledKey: StyledStringKey.FONT,
    styledValue: this.fontStyleAttr
  }]);
  controller: TextController = new TextController();

  async onPageShow() {
    this.controller.setStyledString(this.mutableStyledString)
  }

  build() {
    Column() {
      // 显示属性字符串
      Text(undefined, { controller: this.controller })
    }.width('100%')
  }
}

B.

// xxx.ets
@Entry
@Component
struct Index {
  build() {
    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Start, justifyContent: FlexAlign.SpaceBetween }) {
      // 文本水平方向对齐方式设置
      // 单行文本
      Text('TextAlign set to Center.')
        .textAlign(TextAlign.Center)
        .fontSize(20)
        .border({ width: 1 })
        .padding(10)
        .width('100%')
    }.height(600).width(350).padding({ left: 35, right: 35, top: 35 })
  }
}

C.

// xxx.ets
@Entry
@Component
struct Index {
  build() {
    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Start, justifyContent: FlexAlign.SpaceBetween }) {
      Text('This is the text with the height adaptive policy set')
        .width('80%')
        .height(90)
        .minFontSize(20)
    }.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })
  }
}

D.

@Entry
@Component
struct SpanExample {
  build() {
    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Start, justifyContent: FlexAlign.SpaceBetween }) {
      Text() {
        Span('span letter spacing')
          .letterSpacing(3)
          .fontSize(20)
      }.fontSize(30)
    }.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })
  }
}

39、以下代码片段哪几处违反了ArkTS语法规范。（ABD）

function foo(value1: number, value2: number) {
  return value1 + value2;
}

foo();
foo(1, 2);
foo(1, 2, 3);
foo(1, 2, 3, 4);

A.foo();

B.foo(1, 2, 3, 4);

C.foo(1, 2);

D.foo(1, 2, 3);

40、以下代码片段哪几个函数违反了ArkTS语法规范。（AC）

function foo1(value1?: number, value2: number) {
  if(value1 == undefined){
    return value2;
  }
    return value1 + value2;
}

function foo2(value1: number, value2?: number) {
  if (value2 == undefined) {
    return value1;
  }
  return value1 + value2;
}

function foo3(value: number, ...array: number[]) {
  return value;
}

function foo4( ...array: number[], value: number) {
  return value;
}

A.foo4

B.foo2

C.foo1

D.foo3

41、下面关于Node-API数据类型描述正确的是（BD）

A.napi_threadsafe_function_call_mode：该枚举类型定义了两个常量，用于指定在何时释放线程安全函数的回调函数

B.napi_env：用于表示Node-API执行时的上下文

C.napi_threadsafe_function_release_mode：该枚举类型定义了两个常量，用于指定线程安全函数的调用模式

D.napi_status：是一个枚举数据类型，表示Node-API接口返回的状态信息

42、以下代码片段哪几个class/interface违反了ArkTS语法规范。（AB）

class Person {}
class Student extends Person {} 
class Instructor implements Person {}
interface Shape {}
interface Circle implements Shape {}
class Square implements Shape {}

A.Circle

B.Instructor

C.Student

D.Square

43、哪些是持续部署最佳实践？（AEFG）

A.监控和回滚机制：实时监控部署后的应用状态，如有问题及时回滚。

B.开发完成之后再向类生产环境部署：当软件被第一次部署到类生产环境(比如试运行环境)时，就是大部分开发工作完成时，至少是开发团队认为“该软件开发完成了”。

C.手工配置管理：
1、直接修改生产环境上的配置来改变系统配置；
2、集群中各节点的行为有所不同；
3、靠人手工恢复环境。手动记载配置包括操作系统、应用服务器、关系型数据库管理系统、Web服务器或其他基础设施设置。

D.
手工部署：持续部署可以采用手工部署的方式发布软件：
1、有一份非常详尽的文档，该文档描述了执行步骤及每个步骤中易出错的地方；
2、以手工测试来确认该应用程序是否运行正确；
3、在发布时，常常会修正一些在发布过程中发现的问题。

E.自动化部署流程：从代码提交到部署的整个流程应尽可能自动化。

F.环境一致性：保持开发、测试、生产等环境的高度一致性。

G.灰度发布：先在小部分用户或区域进行部署，观察没问题后再全面推广。

44、hiAppEvent提供的Watcher接口，订阅到的系统事件，哪些包含HiLog日志：（AB）

A、卡死事件

B、崩溃事件

C、启动耗时事件

D、CPU高负载事件

====================

45、处于安全因素考虑，arkts 不支持以下哪些语法（AB）

A、eval()

B、with()

C、Object.entries()

D、new Function('a','b', 'return a+b')

46、下面关于混淆的描述正确的是（ABC）D 存在争议，建议别选

A、针对工程源码的混淆可以降低工程被破解攻击的风险，缩短代码的类与成员的名称，减小应用的大小。
 
B、混淆支持ArkTs/TS/JS文件混淆

C、代码混淆已经集成到sdk中，可以在devEco studio中方便使用

D、API 10及以上版本的Stage模型、编译模式为release时，默认开启代码混淆功能；默认的混淆功能仅会混淆函数参数和局部变了的名称

47、List组件onScrollIndex事件触发时机是（CD）B存在争议，建议别选

A.List组件滚动停止时触发

B.List组件列表滚动时每帧触发

C.List组件首次加载完成时触发

D.List组件显示区域内第一个子组件或最后一个子组件或中间位置子组件索引值变化时触发

48、使用如下的代码去启动一个ability时，哪种skills定义的组件能够被匹配到：（ABC）别人答案是ABCD，建议用我的

let want = {
  "uri" : "https://www.test.com:8080/query/books",
  "type" : "text/plain"
}

context.startAbility(want).then((data))=> {
  console.log(TAG + "startAbility success");
}).catch((err))=> {
  console.log(TAG + "startAbility failed.");
}

A.

"skills": [
  {
    "uris":[
      {
        "scheme": "https",
        "type" : "text/*"        
      }
    ]
  }
]

B.

"skills": [
  {
    "uris":[
      {
        "scheme": "https",
        "host": "www.test.com",
        "pathStartWith" : "query/books",
        "type" : "text/*"        
      }
    ]
  }
]

C.

"skills": [
  {
    "uris":[
      {
        "scheme": "https",
        "host": "www.test.com",
        "type" : "text/plain"        
      }
    ]
  }
]

D.

"skills": [
  {
    "uris":[
      {
        "scheme": "https",
        "host": "www.test.com",
        "pathStartWith" : "query/books",
        "type" : "text/plain"        
      }
    ]
  }
]

49、一个应用通常会包含多种功能，将不同的功能特性按模块来划分和管理是一种良好的设计方式。在开发过程中，我们可以将每个功能模块作为一个独立的Module进行开发，下面关于Module的说法正确的是（ABCD）别人答案是BCD，建议用我的答案

A、entry类型的Module，是应用的主模块，一个应用智能包含唯一一个entry类型的HAP。

B、Aability类型的Module，用于实现应用的功能和特性，有两种类型，分类为entry和feature

C、feature类型的Module，应用的动态特性模块，一个应用中可以包含一个或多个feature类型的模块，也可以不包

D、Llibrary类型的Module，用户实现代码和资源的共享，有两种类型，分别为Stattic Library和 Shared Library 两种类型。

50、当前动态import支持导入的模块类型有哪些？（ABCD）

A.动态import支持加载本地HAR模块

B.动态import支持加载远程HAR模块

C.动态import支持加载OHPM模块（OHPM包）

D.动态import支持加载HSP模块

51、Navigation组件是路由导航的根视图容器，一般作为Page页面的根容器使用，以下关于Navigation组件说法正确的是（BC）别人答案是BD，建议选BD

A.Navigation只能在entry类型的Module中使用

B.Navigation的子页面可以来自不同的Module

C.Navigation子页面的根容器可以采用如Column、Row这些容器组件。

D.Navigation的页面显示模式有单页面、分栏和自适应三种显示模式

52、如下哪些方式可实现图片动态播放（BCD）参考了别人答案

A.

mport {AnimationOptions, AnimatedDrawableDescriptor} from '@ohos.arkui.drawableDescriptor'
import image from '@ohos.multimedia.image'

@Entry
@Component
struct ImageExample {
  pixelmaps: Array<PixelMap>  = [];
  options: AnimationOptions = {duration:2000, iterations:1};
  @State animated: AnimatedDrawableDescriptor | undefined = undefined;

  async aboutToAppear() {
    this.pixelmaps = await this.getPixelMaps();
    this.animated = new AnimatedDrawableDescriptor(this.pixelmaps, this.options);
  }

  build() {
    Column() {
      Row() {
        Image(this.animated)
          .width('500px').height('280px')
      }.height('50%')
      Row() {
        Button('once').width(100).padding(5).onClick(() => {
          this.options = {duration:2000, iterations:1};
          this.animated = new AnimatedDrawableDescriptor(this.pixelmaps, this.options);
        }).margin(5)
      }
    }.width('50%')
  }

  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
  }

  private async getPixelMaps() {
    Mypixelmaps.push(await this.getPixmapFromMedia($r('app.media.icon'))) //对应资源图片名后缀为png
    return Mypixelmaps;
  }
}

B.

@Entry
@Component
struct ImageAnimatorExample {
  @State iterations: number = 1

  build() {
    Column({ space: 10 }) {
      ImageAnimator()
        .images([
          {
            src: $r('app.media.img1')
          },
          {
            src: $r('app.media.img2')
          },
          {
            src: $r('app.media.img3')
          },
          {
            src: $r('app.media.img4')
          }
        ])
        .duration(2000)
        .fillMode(FillMode.None).iterations(this.iterations).width(340).height(240)
        .margin({ top: 100 })
    }.width('100%').height('100%')
  }
}

C.

import {AnimationOptions, AnimatedDrawableDescriptor} from '@ohos.arkui.drawableDescriptor'
import image from '@ohos.multimedia.image'

@Entry
@Component
struct ImageExample {
  pixelmaps: Array<PixelMap>  = [];
  options: AnimationOptions = {duration:2000, iterations:1};
  @State animated: AnimatedDrawableDescriptor | undefined = undefined;

  async aboutToAppear() {
    this.pixelmaps = await this.getPixelMaps();
    this.animated = new AnimatedDrawableDescriptor(this.pixelmaps, this.options);
  }

  build() {
    Column() {
      Row() {
        Image(this.animated)
          .width('500px').height('280px')
      }.height('50%')
      Row() {
        Button('once').width(100).padding(5).onClick(() => {
          this.options = {duration:2000, iterations:1};
          this.animated = new AnimatedDrawableDescriptor(this.pixelmaps, this.options);
        }).margin(5)
      }
    }.width('50%')
  }

  private async getPixmapListFromMedia(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: Array<image.PixelMap> = await imageSource.createPixelMapList({
      desiredPixelFormat: image.PixelMapFormat.RGBA_8888
    })
    await imageSource.release()
    return createPixelMap
  }

  private async getPixelMaps() {
    let Mypixelmaps:Array<PixelMap> = await this.getPixmapListFromMedia($r('app.media.icon'))//对应资源图片名后缀为gif
    return Mypixelmaps;
  }
}

D.

@Entry
@Component
struct ImageExample {
  build() {
    Column({ space: 10 }) {
      Image($r('app.media.earth')) //对应资源图片名后缀为gif
        .width(100)
        .height(100)
    }
  }
}

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

A.
导出native方法，在HSP中也可以包含C++编写的so。对于so中的native方法，HSP通过间接的方式导出，以导出liblibrary.so的乘法接口multi为例：

// 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;
}
对外暴露的接口，需要在入口文件index.ets中声明：
// library/index.ets
export { nativeMulti } from './src/main/ets/utils/nativeTest';

B.
导出ts类和方法

// 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;
}
对外暴露的接口，需要在入口文件index.ets中声明：
// library/index.ets
export { Log, add, minus } from './src/main/ets/utils/test';

C.
导出ArkUI组件

// 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%')
  }
}
对外暴露的接口，需要在入口文件index.ets中声明：
// library/index.ets
export { MyTitleBar } from './src/main/ets/components/MyTitleBar';

54、下面关于方舟字节码文件格式描述正确的是（CD）

A.方舟字节码文件中不包含字节码文件内容的adler32校验和

B.方舟字节码文件中数据类型uint32_t表示32-bit无符号整数，采用大端字节序

C.方舟字节码文件中数据类型uint16_t表示16-bit无符号整数，采用小端字节序

D.方舟字节码文件是ArkTS/TS/JS编译后的二进制产物

55、应用开发的有些场景中，如果希望根据条件导入模块或者按需导入模块，可以使用动态导入代替静态导入，下面导入场景中适合使用动态import的是（ABCD）

A.当静态导入的模块很明显的占用了大量的系统内存且被使用的可能性很低。

B.当被导入的模块，在加载时并不存在，需要异步获取。

C.当被导入的模块说明符，需要动态构建。

D.当静态导入的模块很明显的降低了代码的加载速度且被使用的可能性很低，或者并不需要马上使用它。

56、下面关于混淆的描述正确的是（AB）

A.支持顶层作用域名称、属性名称、文件名称等多种混淆功能

B.修改应用混淆配置，新配置需要重新全量编译应用才能生效

C.在工程build-profile.json5中的obfuscation.ruleOptions.files字段中配置该工程的混淆配置，该配置仅在编译该工程时生效。

D.可以在HAR模块工程的build-profile.json5中的obfuscation.consumerFiles字段中配置导出的混淆配置，该配置仅在编译依赖该HAR的模块时生效。

57、以下代码片段哪几处违反了ArkTS语法规范。（BCD）

function foo(value: number) {
  return value;
}

foo('');
foo(0);
foo(undefined);
foo(null);

A.foo(0);

B.foo('');

C.foo(null);

D.foo(undefined);

58、在ArkTS中，以下哪些声明类的方式是正确的（BD）

class C1 {
  value: number = 0;
}

class C2 {
  value: number;
  constructor(value: number) {
    this.value = value;
  }
}

class C3 {
  constructor(value: number) {
    this.value = value;
  }
}

class C4 {
  value: number;
}

A.C3

B.C2

C.C4

D.C1

59、HarmonyOS应用开发者小张，正在利用DevEco Studio进行一款复杂应用的UI界面调试。小张了解到ArkUI Inspector是DevEco Studio内置的一项强大工具，能够显著提升UI调试效率。基于ArkUI Inspector的特性描述，下列哪些描述是正确的 （AB）

A.UI快照管理：支持导出应用的UI界面为快照图片，并允许这些快照被导入回ArkUI Inspector中，便于离线分析或分享讨论UI设计方案

B.UI效果查看：开发者能够查看连接真机上运行的应用程序的UI显示效果，页面组件树结构，以及选中组件的属性信息

C.性能监控：提供详细的UI渲染性能指标，帮助开发者识别布局瓶颈和渲染效率问题，从而优化应用性能

D.交互式组件选择：用户既可以在组件树视图中选择组件，使UI界面上对应组件高亮显示并展示其属性详情；也可以直接在UI布局显示界面上点击选择组件

60、在开发过程中，我们可以将每个功能模块作为一个独立的Module进行开发。关于Module，下列选项说法正确的是？（ABC）

A.feature类型的Module：应用的动态特性模块，编译后生成feature类型的HAP。一个应用中可以包含一个或多个feature类型的HAP，也可以不包含。

B.Static Library：静态共享库。HAR中的代码和资源跟随使用方编译，如果有多个使用方，它们的编译产物中会存在多份相同拷贝。

C.Shared Library：动态共享库。HSP中的代码和资源可以独立编译，运行时在一个进程中代码也只会存在一份。

D.entry类型的Module：应用的主模块，包含应用的入口界面、入口图标和主功能特性，编译后生成entry类型的HAP。每一个应用分发到同一类型的设备上的应用程序包，可以包含一个或多个entry类型的HAP。

61、开发者小李正在使用DevEco Studio开发一款面向HarmonyOS的应用，该应用需要在多种设备上表现出一致的稳定性和优秀的用户体验。为了确保高质量的发布，小李意识到需要实施一套全面的测试策略，覆盖代码的自动化测试和手动测试，还需要衡量代码的测试覆盖率，以确定测试的充分性。在DevEco Studio的测试框架下，以下描述中，哪些是正确的 （BCD）

A.Local Test：测试用例位于test目录，无需设备或模拟器环境，直接在本地执行，专注于ArkTS语言，推荐适用于API版本11及以上的Hvigor工程，目前特别限于Stage模型，并不涵盖C/C++方法。

B.DevEco Studio的测试框架提供测试用例执行能力，包含基础接口以编写和输出测试结果，鼓励用户创建易于维护的自动化测试脚本，并且统计代码覆盖率。

C.Instrument Test：测试用例存储于项目的ohosTest目录，要求在HarmonyOS设备或模拟器上执行，兼容ArkTS与JS语言编写。

D.无论选择Instrument Test还是Local Test，DevEco Studio均内置了详尽的测试报告功能，实时显示测试进度，且直接在IDE中可查看代码覆盖率报告，无需外部工具。

62、以下napi代码有问题的是 （CD）答案未确定
A.

static napi_value Demo(napi_env env, napi_callback_info info)
{
    constexpr size_t arrSize = 1000;
    napi_value arrBuffer = nullptr;
    void *data = nullptr;

    napi_create_arraybuffer(env, arrSize * sizeof(int32_t), &data, &arrBuffer);
    int32_t *i32Buffer = reinterpret_cast<int32_t *>(data);
    for (int i = 0; i < arrSize; i++) {
        i32Buffer[i] = i;
    }

    return arrBuffer;
}

B.

static napi_value Demo(napi_env env, napi_callback_info info)
{
    size_t argc = 1;
    napi_value args[1] = {nullptr};

    napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
    napi_value sizeObj = nullptr;
    
    napi_handle_scope scope = nullptr;
    napi_open_handle_scope(env, &scope);
    napi_call_function(env, nullptr, args[0], 0, nullptr, &sizeObj);
    napi_close_handle_scope(env, scope);
    
    int64_t width = 0;
    napi_value result = nullptr;
    napi_get_element(env, sizeObj, 0, &result);
    napi_get_value_int64(env, result, &width);
    return result;
}

C.

struct CallbackContext {
    napi_env env = nullptr;
    napi_ref callbackRef = nullptr;
    int32_t retData = 0;
};

void callbackTest(CallbackContext *context)
{
    uv_loop_s *loop = nullptr;
    napi_get_uv_event_loop(context->env, &loop);
    uv_work_t *work = new uv_work_t;
    context->retData = 1;
    work->data = (void *)context;
    uv_queue_work(
        loop, work, [](uv_work_t *work) {},
        // using callback function back to JS thread
        [](uv_work_t *work, int status)
        {
            CallbackContext *context = (CallbackContext *)work->data;

            napi_value callback = nullptr;
            napi_get_reference_value(context->env, context->callbackRef, &callback);
            napi_value retArg;
            napi_create_int32(context->env, context->retData, &retArg);
            napi_value ret;
            napi_call_function(context->env, nullptr, callback, 1, &retArg, &ret);
            napi_delete_reference(context->env, context->callbackRef);
            if (work != nullptr) {
                delete work;
            }
            delete context;
        }
    );
}

D.

napi_ref g_ref = nullptr;

/***** excute in main thread *****/
static napi_value DemoInMainThread(napi_env env, napi_callback_info info)
{
    napi_value string = nullptr;
    napi_create_string_utf8(env, "bar", NAPI_AUTO_LENGTH, &string);
    napi_create_reference(env, string, 1, &g_ref);
    return string;
}

/***** excute in worker thread *****/
static napi_value DemoInWorkerThread(napi_env env, napi_callback_info info)
{
    napi_value string = nullptr;
    napi_get_reference_value(env, g_ref, &string);
    
    napi_value object = nullptr;
    napi_create_object(env, &object);
    
    napi_set_named_property(env, object, "foo", string);
    return object;
}

63、ArkTS是鸿蒙生态的应用开发语言。以下哪些选项是ArkTS的设计理念。（ABC）

A.ArkTS保留了TS大部分的语法特性，帮助开发者更容易上手ArkTS。

B.通过规范强化静态检查和分析，减少运行时的类型检查，从而降低了运行时负载，提升执行性能。

C.通过规范强化静态检查和分析，使得许多错误在编译时可以被检测出来，降低代码运行错误的风险。

D.ArkTS不支持null-satety特性。

64、项目组开发的HarmonyOS应用工程，为了保护hap代码资产，如何在DevEco Studio中启用混淆的功能，并设置相应的混淆规则（BC）

A.release模式下将buildOption/arkOptions/ruleOptions/enable设置为false

B.release模式下将buildOption/arkOptions/ruleOptions/enable设置为true

C.在混淆规则配置文件obfuscation-rules.txt中进行混淆规则的配置

D.在混淆规则配置文件consumer-rules.txt中进行混淆规则的配置