【多选题分数占比高，多选高分，单选稍微做下就能考试通过！】

【多选题分数占比高，多选高分，单选稍微做下就能考试通过！】

【多选题分数占比高，多选高分，单选稍微做下就能考试通过！】

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

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

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

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

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

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

​ A、hap

​ B、app

​ C、hsp

​ D、har

3、哪些是持续部署最佳实践？（ABDG）

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

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

​ C、手工部署：持续部署可以采用手工部署的方式发布软件：

​                1、有一份非常详尽的文档，该文档描述了执行步骤及每个步骤中易出错的地方；

​                  2、以手工测试来确认该应用程序是否运行正确；

​                  3、在发布时，常常会修正一些在发布过程中发现的问题。

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

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

​ F、手工配置管理：

​         1、直接修改生产环境上的配置来改变系统配置；

​                  2、集群中各节点的行为有所不同；

​                  3、靠人手工恢复环境。手动记载配置包括操作系统、应用服务器、关系型数据库管理系统、Web服务器或其他基础设施设置。

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

4、以下代码片段哪几处违反了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!';

5、以下napi代码有问题的是（AB）

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.

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;

}

D.

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;

        }

    );

}

​ A、A

​ B、B

​ C、C

​ D、D

6、下面关于混淆的描述正确的是 （ACD）？？？ABCD

​ A、代码混淆已经被集成了到SDK中，可以在DevEco Studio中方便地使用。

​ B、针对工程源码的混淆可以降低工程被破解攻击的风险，缩短函数名、类名和属性名，减小应用的大小。[正确是：缩短代码的类与成员的名称]

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

​ D、混淆支持ArkTS/TS/JS文件的混淆

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

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

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

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

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

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

​ A、import { export1 as alias1 } from "ets file name";

​ B、import defaultExport from "ets file name"

​ C、import * as name from "ets file name"

​ D、import { export1 } from "ets file name";

9、以下关于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")

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

w.postMessageWithSharedSendable(a);

task.setCloneList([a]);

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

w.postMessage(a);

​ A、task.setCloneList([a]); taskpool.execute(task).then() => {});，TaskPool 共享传输实现方式 [正确的是：TaskPool拷贝传输实现方式]

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

​ C、w.postMessage(a);， Worker共享传输实现方式 [正确的是：Worker 拷贝传输实现方式]

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

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

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, ...arrary: number[]) {

     return value;

}

function foo4( ...arrary: number[], value: number) {

     return value;

}

​ A、foo1

​ B、foo2

​ C、foo3

​ D、foo4

11、在ArkTS中，以下哪些属性的声明是正确的。

class C {

  value1: number = 0;

  value2?: number = null;

  value3: number | undefined = undefined;

  value4?: number;

}

​ A、value1

​ B、value2

​ C、value3

​ D、value4

12、如下ABC 3处手势，有机会执行的是哪几处?（BD）

@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: 0xFFFFF,

            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)

          })

      )*/

      //  C

      /*.parallelGesture(

        PanGesture({PanDirection.Vertical})

          .onActionUpdate((event: GestureEvent)=>{

            console.log("zcb onActionUpdate event offsetY " + event.offsetY + "this.lastOffset " + this.lastOffset)

          })

      )*/

    }.width('100%').height('100%').backgroundColor(0xDCDCDC)

  }

}

A、NA

​   B、A

​   C、B

​   D、C

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

// A

@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) //这个单独使用不起作用，要和maxFontSize一起才有效

    }.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })

  }

}

// B

@Entry

@Component

struct SpanExample {

  build() {

    Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Start, justifyContent: FlexAlign.SpaceBetween }) {

      Text() {             //span的属性会覆盖父组件TEXT的属性

        Span('span letter spacing')

          .letterSpacing(3)

          .fontSize(20)

      }.fontSize(30)

    }.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })

  }

}

// C

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

  }

}

// D  --vp是虚拟像素大小

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

  }

}

1. A
2. B
3. C
4. D

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

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

        })

    }

  }

}

1. A
2. B
3. C
4. D

15、如何实现类似下图布局 （BC）

//       A   --Grid方式不对

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

  }

}

//       B

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

  }

}

//       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() {

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

  }

}

A、A

B、B

C、C

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

​ A、rules：可以基于ruleSet配置的规则集，新增额外规则项，但是无法修改ruleSet中规则默认配置 [正确的应该是可以修改]

​ B、files：配置待检查的文件名单，如未指定目录，规则适用于所有文件，例如: [“**/*.ets”,“**/*.js”,“**/*.ts”]。

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

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

E、overrides：针对工程根目录下部分特定目录或文件，可配置定制化检查的规则。

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

​ A、Library类型的Module，用于实现代码和资源的共享，有两种类型，分别为Static Library和Shared Library两种类型。

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

​ C、Ability类型的Module，用于实现应用的功能和特性，有两种类型，分别为entry和feature。

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

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

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

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

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

​ D、一次上架多端部署。

19、通过如下openLink的接口启动，如下哪些配置的UIAbility不可能被拉起（不确定，把所有选项列出）  （ACD）

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": "http",

                    "host": "www.test.com",

                    "port": "8080",

                    "path": "path"

                }                     

            ]

       }

         ]

}

//       B

{

         "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

                }                     

            ]

       }

         ]

}

//       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.SendData",

            ],

            "entities": [

                "entity.system.browsable",

            ],

            "uris": [

                {

                    "scheme": "https",

                    "host": "www.test.com",

                    "port": "8080",

                    "path": "path",

                     "autoVerify": ture

                }                     

            ]

       }

         ]

}

A、A

B、B

C、C

D、D

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

{

    "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_005会在主线程执行

B、StartupTask_006会在AbilityStage的onCreate前初始化完成

C、StartupTask_001会在StartupTask_004之后执行；

D、StartupTask_003会在StartupTask_004之后执行

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

1. Web(...).enableNativeEmbedMode(true)//.registerNativeEmbedRule("embed", "native")

<embed id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

1. Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("object", "test")

<object id="view" type="test/contents" width="100%" height="100%" style="background-color:red"/>

1. Web(...).enableNativeEmbedMode(true)//.registerNativeEmbedRule("embed", "native")

<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

1. Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("native", "test")

<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

​  A、A

​  B、B

1. C
2. D

22、用户购买商品后，你需要及时发放相关权益。但实际应用场景中，若出现异常将导致应用无法知道用户实际是否支付成功，从而无法及时发放权益，即出现掉单情况。为了确保权益发放，你需要在以下哪些场景检查用户是否存在己购未发货的商品：（ABC）

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

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

​ C、应用启动时

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

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

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

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

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

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

24、ArkTS中不能使用以下哪些类型。（AD）

​ A、any

​ B、union type

​ C、tuple type

​ D、unknown

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

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

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

​ C、当被导入的模块说明符, 需要动态构建。

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

E、当被导入的模块有副作用（这里的副作用，可以理解为模块中会直接运行的代码），这些副作用只有在触发了某些条件才被需要时

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

class Person {}

class Student extends Person {}

class Instructor implements Person {}

interface Shape {}

interface Circle implements Shape {}

class Square implements Shape {}

​ A、Instructor

​ B、Square

​ C、Circle

​ D、Student

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

//      A - Demo3

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

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 ;

}

//      C - Demo2

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;

}

//      D - Demo1

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 ;

}

​ A、A == Demo3

​ B、B

​ C、C == Demo2

​ D、D

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

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

​ B、TS/JS代码支持import ArkTS代码。

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

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

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

//      A

@Entry

@Component

struct ImageExample {

  build() {

    Column({ space: 10 }) {

      Image("https://www.example.com/xxx.png")

        .width(100)

        .height(100)

    }

  }

}

//      B

@Entry

@Component

struct ImageExample {

  build() {

    Column({ space: 10 }) {

      Image($r('app.media.earth'))

        .width(100)

        .height(100)

    }

  }

}

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

  }

}

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

  }

}

​ A、A

​ B、B

​ C、C

​ D、D

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

​ A、-disable-obfuscation：关闭所有混淆

​ B、-enable-property-obfuscation：开启顶层作用域名称混淆[开启属性混淆]

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

​ D、-enable-toplevel-obfuscation：开启属性混淆[开启顶层作用域名称混淆]

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

1.function fn(x: string | number): string {

  return  'value: ' + x;

}

type funcType = (ns: string) => string;

let func: funcType = fn;

2.function fn(x: string | number): string {

  return 'value:' + x;

}

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

let func: funcType = fn;

3.function fn(x: string): string {

  return x;

}

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

let func: funcType = fn;

4.function fn(x: string | number): void {

  console.log('value: ' + x);

}

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

let func: funcType = fn;

A、1

B、2

C、3

D、4

35、以下代码片段哪几处违反了ArkTS语法规范

function foo(value1: number, value2: number) {

    return value1 + value2;

}

A、foo();

B、foo(1, 2);

C、foo(1, 2, 3);

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

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

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

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

​ C、TaskPool不支持线程复用

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

37、List组件onScrollIndex事件触发时机是（AB）

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

​ B、List组件首次加载完成时触发

​ C、List组件滚动停止时触发

​ D、List组件列表滚动时每帧触发

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

A、Gesture

B、GesureGroup

C、parallelGesture

D、priorityGesture

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

【bundleName，icon，label，versionCode，versionName不可缺省】

// A

{

  "app": {

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

    "vendor": "example",

    "versionCode": 1000000,

    "versionName" : "1.0.2",

    "icon": "$media:app_icon",

    //   ==========================    【label】字段的值需要引用[要用$string:app_name ]

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

    "icon": "$media:app_icon",

    "label": "$string:app_name",

    "bundleType": "app",

  }

}

// D

{

  "app": {

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

    "vendor": "example",

    "versionCode": 1000000,

    "versionName": "1.0.2",

    "icon": "$media:app_icon",

    "label": "$string:app_name"

  }

}

40、使用如下的代码去启动一个ability时，哪种skills定义的组件能够被匹配到（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",

                                     "host": "www.test.com",

                                     "type": "text/plain"

                            }

                  ]

    }

]

//      B

"skills": [

         {

                   "uris":[

                            {

                                     "scheme": "https",

                                     "host": "www.test.com",

                                     "pathStartWith": "query/books",

                                     "type" : "text/plain"

                            }

    ]

         }

]

//      C

"skills": [

    {

                   "uris":[

                            {

                                     "scheme": "https",

                                     "host": "www.test.com",

                                     "pathStartwith" :"query/books",

                                     "type" : "text/*"

                            }

    ]

    }

]

//      D

"skills":[

    {

                   "uris":[

                            {

                                     "scheme": "https",

                                     "type": "text/*"

                            }

                   ]

    }

]

41、以下关于Localstorage的说法正确有哪些？BCD

​ A、LocalStorage中的所有属性都是不可变的。[正确答案：都是可变的]

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

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

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

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

[name,type,deviceTypes,deliveryWithInstall,installationFree 不可缺省，pages在有UIAbility时不可缺省]

//      A                ==     缺少字段【installationFree】

{

         "module": {

                   "name": "bName",

                   "type":" shared",

                   "deviceTypes": [

                            "default",

                            "tablet"

                   ],

                   "deliveryWithInstall": true,

                   "pages": "$profile:main_pages"

    }

}

//      B       ==     缺少字段【deliveryWithInstall，installationFree】

{

         "module": {

                   "name": "aName",

                   "type": "har"

                   "deviceTypes": [

                   "default", "tablet" ]

         }

}

//      C       ==     【type】字段不支持【hsp】，缺少字段【installationFree】

{

         "module": {

    "name": "cName",

                   "type": "hsp",

                   "description": "$string:desc",

                   "deviceTypes": [

                            "default",

                            "tablet"

                   ],

                   "deliveryWithInstal1": true,

                   "pages": "$profile:main_pages"

    }

}

//      D

{

         "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

                            }

                   ]

    }

}

1. A
2. B
3. C
4. D

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

​ A、CPU高负载事件

​ B、启动耗时事件

​ C、卡死事件

​ D、崩溃事件

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

​ A、动态import支持加载OHPM模块

​ B、动态import支持加载本地HAR模块

​ C、动态import支持加载HSP模块

​ D、动态import支持加载远程HAR模块

45、ArkTS是鸿蒙生态的应用开发语言。以下哪些选项是ArkTS的设计理念。(ABD)

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

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

​ C、ArkTS不支持null-satety特性 。

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

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

function foo(value: number) {

  return value;

}

foo('');

foo(0);

foo(undefined);

foo(null);

A. foo(null);

​   B. foo(undefined);

​   C. foo(");

​  D.foo(0);

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

​ A、arrayBuffer

​ B、map<string,string>

​ C、record<string,string>

​ D、string

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

//   A

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

//   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;

}

//  对外暴露的接口，需要在入口文件index.ets中声明:

//  library/index.ets

export { nativeMulti } from './ src/main/ets/utils/nativeTest';

//  C

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

A、导出ArkUI组件

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

​ C、导出ts类和方法

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

​ A、方舟字节码文件中数据类型uint32_t表示32-bit无符号整数，采用大端字节序[正确是：采用小端字节序]

​ B、方舟字节码文件中不包含字节码文件内容的adler32校验和[Header结构中存在checksum：字节码文件除文件头魔数和本校验字段之外的内容的adler32校验和]

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

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

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

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

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

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

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

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

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

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

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

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

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

A.

@Entry

@Component

struct ImageExample {

  build() {

    Column({ space: 10 }) {

      Image("https://www.example.com/xxx.png")

        .width(100)

        .height(100)

    }

  }

}

B.

@Entry

@Component

struct ImageExample {

  build() {

    Column({ space: 10 }) {

      Image($r('app.media.earth'))

        .width(100)

        .height(100)

    }

  }

}

C.

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

  }

}

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

  }

}

53、以下数据类型中，哪些是Sendable数据？（BCD）

import { lang } from '@kit.ArkTS';

class C {}

interface I extends lang.ISendable {}

A.class C

B.string

C.number

D.interface I

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

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

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

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

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

55、哪些是持续集成最佳实践？（ABCDE）

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

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

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

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

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

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

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

56、Navigation组件是路由导航的根视图容器，一般作为Page页面的根容器使用，以下关于Navigation组件说法正确的是 （BC）

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

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

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

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

57、处于安全因素考虑，ArkTS不支持以下哪些语法。（BCD）BCD

A.Object.entries()

B.eval()

C.with()

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

58、如下哪些方式可实现图片动态播放？（ACD）

A.

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;

  }

}

B.

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

  }

}

C.

@Entry

@Component

struct ImageExample {

  build() {

    Column({ space: 10 }) {

      Image($r('app.media.earth')) //对应资源图片名后缀为gif

        .width(100)

        .height(100)

    }

  }

}

D.

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

  }

}

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

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

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

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

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

60、在使用DevEco Studio进行HarmonyOS应用开发和调试过程中，开发者小张遇到应用运行时意外终止的情况，他需要快速定位并解决导致应用崩溃的问题。以下哪些做法可以帮助小张有效分析和处理这些问题？（ABCD）

A. 利用系统自动生成的FaultLog，包括App Freeze、CPP Crash、JS Crash、System Freeze和ASan报告，这些报告会详细记录故障发生时的环境、堆栈信息和可能的故障原因，是排查问题的重要参考

B. 当怀疑问题是由于C++代码中的内存错误（如数组越界、内存泄露、重复释放内存）引起时，进入“Run/Debug Configurations”设置界面，勾选启用Address Sanitizer（ASan），然后重新部署应用进行测试以获取更详细的内存问题报告

C. 查看DevEco Studio log工具栏输出的错误日志，根据日志提示分析应用崩溃的具体原因及代码位置

D. 若遇到App运行卡顿或系统整体无响应（App Freeze、System Freeze）的情况，可以通过性能分析工具中的Frame Insights和Allocation Insights功能，分析应用的资源消耗情况，寻找可能的瓶颈

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

A. -print-namecache filepath: 将名称缓存保存到指定的文件路径。

B. -keep-property-name [,identifiers,..]:指定要保留的顶层作用域的名称[指定想保留的属性名，支持使用名称类通配符]

C. -keep-file-name [,identifiers...]:指定要保留的文件/文件夹的名称，支持使用名称类通配符

D. -keep-global-name [,identifiers....]:指定想保留的属性名[指定要保留的顶层作用域的名称，支持使用名称类通配符]

E. -keep-comments [,identifiers,...]保留声明文件中元素上方的JsDoc注释，支持使用名称类通配符。

F. -keep-dts filepath保留指定路径的.d.ts文件中的名称。

G. -keep path保留指定路径中的所有名称（例如变量名、类名、属性名等）不被混淆。

62、以下数据类型中，哪些是Sendable数据？（BCD）

Import { lang }  from  ‘@kit.ArkTS’;

class C {}

Interface I extends lang.ISendable {}

1. class C
2. number
3. Interface I
4. String

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

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

​ B、export * from "ets file name"

​ C、export * as name from "ets file name"

​ D、export { export1 } from "ets file name";

64、Row父容器宽度100，其中子组件X设置了layoutWeight(3)和width('20%')，子组件Y设置了layoutWeight(2)和width('30%')，会出现什么样的效果？ （C）[按照权重3:2分配，自适应占满空间]

A. 子组件X宽度20，子组件Y宽度30

B. 子组件X宽度40，子组件Y宽度60

C. 子组件X宽度60，子组件Y宽度40

D. 子组件X宽度30，子组件Y宽度20

65、以下哪个是系统资源的引用方式？（A）

A. 使用$r('sys.type.resource_id')

B. 使用$r('app.type.name')

C. 使用$sys('type.resource_id')

D. 使用$app('type.name')

66、下面代码符合ArkTS编程规范的是: （CD）

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

console.log(idx)

B.  let maxCount =10,isCompleted =false;

let pointx,pointy;

pointx=10;pointy=0;

C. If(condition){ console.log(‘success’) }

D.  let maxCount =10;

let isCompleted = false;

let pointx =0;

let pointy =0;

67、Harmonyos应用开发者小张，正在利用DevEcostudio进行一款复杂应用的UI界面调试。小张了解到ArkUI Inspector是DevEco studio内置的一项强大工具，能够显著提升UI调试效率。

基于ArkUIInspector的特性描述，下列哪些描述是正确的？(ACD)

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

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

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

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

68、下面关于Node-API数据类型描述正确的是？(AC)

A napi_env:用于表示Node-API执行时的上下文

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

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

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

69、出于安全因素考虑，ArkTs不支持以下哪些语法？(ACD)

A.new Function('a' , 'b', 'return a + b')

B.Object.entries()

C.eval()

D.with()

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

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

B、release模式下将buildOption/arkOptions/ruleOptions/enable设置为false

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

D、release模式下将buildOption/arkOptions/ruleOptions/enable设置为true

71、在ArkTS中,以下哪些声明类的方式是正确的(AB)

A. class C1{ value: number =0;}

B. class C2{

        value:number;

constructor(value:number){

this.value=value;

}

}

C. class C3{

constructor(value:number){

this.value=value;

}

D. class C4{ value:number; }