【十月十号新题高级】HarmonyOS应用开发者高级题库

2401_84044640

于 2024-10-12 10:35:50 发布

阅读量1.3k

点赞数 8

文章标签： harmonyos 华为

本文链接：https://blog.csdn.net/2401_84044640/article/details/142871817

版权

HarmonyOS应用开发高级认证
1. 以下哪些赋值语句在ArkTS中是合法。
TypeScript
class A {
v: number = 0;
}
class B extends A {
u: string = '';
}
class C {
v: number = 0;
}

let a1: A = new C();
let a2: A = new B();
let a3: B = new A();
let a4: C = new B();
A.a4
B.a1
C.a2
D.a3

+++ 2.在方舟字节码的函数调用规范中，前三个参数表示的含义分别是
A.函数对象本身、new.Target、this
B.this、函数对象本身、new.Target
C.new.Target、函数对象本身、this
D.new.Target、this、函数对象本身

3.ArkTS支持以下哪些函数
A.Object.getOwnPropertySymbols();
B.Object.isPrototypeOf();
C.Object.isExtensible();
D.Object.keys();

4.下面关于方舟字节码格式PREF_IMM16_V8_V8描述正确的是
A.8位操作码，8位立即数，16位id，8位寄存器
B.16位前缀操作码，16位立即数，8位寄存器
C.16位前缀操作码，16位立即数，2个8位寄存器
D.8位操作码，8位立即数，2个8位寄存器

5.以下哪个装饰器用来表示并发共享对象。
A.@Sendable
B.@State
C.@Shared
D.@Style

6.使用promptAction.showToast如何设置显示在其他应用之上？
A.ToastShowMode.TOP_MOAST
B.ToastShowMode.SYSTEM_TOP_MOST
C.无需配置，默认显示在其他应用之上
D.ToastShowMode.DEFAULT

7.下面哪种转场效果在入场动画时，表现为从透明度为0、相对于组件正常显示位置x方向平移100vp的状态，到默认的透明度为1、相对于组件不平移的状态，且透明度动画和平移动画的动画时长均为2000ms
A.TransitionEffect.OPACITY.animation({duration: 2000}).combine(TransitionEffect.translate({x:100}))
B.TransitionEffect.OPACITY.combine(TransitionEffect.translate({x:100}).animation({duration: 2000}))
C.TransitionEffect.translate({x:100}).combine(TransitionEffect.OPACITY.animation({duration: 2000}))
D.TransitionEffect.asymmetric(TransitionEffect.OPACITY.animation({duration:2000}), TransitionEffect.translate({x:100}).animation({duration: 2000}))

8.如果想让outer button响应事件，hitTestBehavior该怎么配
Plain Text
import promptAction from '@ohos.promptAction';
// xxx.ets
@Entry
@Component
struct HitTestBehaviorExample {
build() {
// outer stack
Stack() {
Button('outer button')
.onClick((event) => {
promptAction.showToast({ message: click事件触发------++++2 });
})
// inner stack
Stack() {
Button('inner button')
.onTouch((event) => {
promptAction.showToast({ message: click事件触发------1 });
})
}
.width("100%").height("100%")
.hitTestBehavior(？)
.onTouch((event) => {
console.info('stack touched type: ' + (event as TouchEvent).type)
})

}.width(300).height(300)
}
}
A.HitTestMode.None
B.HitTestMode.Default
C.HitTestMode.Transparent
D.HitTestMode.Block

9.以下关于ArkUI NavDestination组件的生命周期执行顺序中正确的是
A.onWillappear->onAppear->onWillShow->onShow->onWillHide->onHidden->onWillDisappear->onDisappear
B.onWillappear->onWillShow->onShow->onAppear->onWillHide->onHidden->onWillDisappear->onDisappear
C.onWillappear->onAppear->onWillShow->onShow->onWillDisappear->onWillHide->onHidden->onDisappear
D.onWillappear->onAppear->onWillShow->onShow->onWillHide->onWillDisappear->onHidden->onDisappear

10.为了使isShow参数值与半模态界面的状态同步，可以使用下列那种方式双向绑定isShow参数？（选A）
A.// xxx.ets
@Entry
@Component
struct SheetTransitionExample {
@State isShow:boolean = false
@State isShow2:boolean = false
@State sheetHeight:number = 300;

@Builder myBuilder() {
Column() {
Button("change height")
.margin(10)
.fontSize(20)
.onClick(()=>{
this.sheetHeight = 500;
})
}
.width('100%')
.height('100%')
}

build() {
Column() {
Button("transition modal 1")
.onClick(() => {
this.isShow = true
})
.fontSize(20)
.margin(10)
.bindSheet($$this.isShow, this.myBuilder(), {
height: this.sheetHeight,
})
}
.justifyContent(FlexAlign.Center)
.width('100%')
.height('100%')
}
}
B.// xxx.ets
@Entry
@Component
struct SheetTransitionExample {
@State isShow:boolean = false
@State isShow2:boolean = false
@State sheetHeight:number = 300;

@Builder myBuilder() {
Column() {
Button("change height")
.margin(10)
.fontSize(20)
.onClick(()=>{
this.sheetHeight = 500;
})
}
.width('100%')
.height('100%')
}

build() {
Column() {
Button("transition modal 1")
.onClick(() => {
this.isShow = true
})
.fontSize(20)
.margin(10)
.bindSheet(@@this.isShow, this.myBuilder(), {
height: this.sheetHeight,
})
}
.justifyContent(FlexAlign.Center)
.width('100%')
.height('100%')
}
}

C.// xxx.ets
@Entry
@Component
struct SheetTransitionExample {
@State isShow:boolean = false
@State isShow2:boolean = false
@State sheetHeight:number = 300;

@Builder myBuilder() {
Column() {
Button("change height")
.margin(10)
.fontSize(20)
.onClick(()=>{
this.sheetHeight = 500;
})
}
.width('100%')
.height('100%')
}

build() {
Column() {
Button("transition modal 1")
.onClick(() => {
this.isShow = true
})
.fontSize(20)
.margin(10)
.bindSheet(this.isShow, this.myBuilder(), {
height: this.sheetHeight,
})
}
.justifyContent(FlexAlign.Center)
.width('100%')
.height('100%')
}
}
D.// xxx.ets
@Entry
@Component
struct SheetTransitionExample {
@State isShow:boolean = false
@State isShow2:boolean = false
@State sheetHeight:number = 300;

@Builder myBuilder() {
Column() {
Button("change height")
.margin(10)
.fontSize(20)
.onClick(()=>{
this.sheetHeight = 500;
})
}
.width('100%')
.height('100%')
}

build() {
Column() {
Button("transition modal 1")
.onClick(() => {
this.isShow = true
})
.fontSize(20)
.margin(10)
.bindSheet(&&this.isShow, this.myBuilder(), {
height: this.sheetHeight,
})
}
.justifyContent(FlexAlign.Center)
.width('100%')
.height('100%')
}
}

+++11.从桌面冷启动如下应用，点击Change按钮5次，整个过程中，代码中的2条log依次出现的次数，最初和最后画面上显示的【num = ?】的数字是
TypeScript
// PageOne.ets
@Component
export struct PageOneTmp {
@Consume('pageInfos') pageInfos: NavPathStack;

build() {
NavDestination() {
Column() {
Button('toPageTwo', { stateEffect: true, type: ButtonType.Capsule })
.width('80%')
.height(40)
.margin(20)
.onClick(() => {
this.pageInfos.pushPathByName('pageTwo',"")
})
Button('get', { stateEffect: true, type: ButtonType.Capsule })
.width('80%')
.height(40)
.margin(20)
.onClick(() => {
console.log('获取全部名为name的NavDestination页面的位置索引', JSON.stringify(this.pageInfos.getIndexByName('pageOne')))
})
}.width('100%').height('100%')
}.title('pageOne')
.onBackPressed(() => {
const popDestinationInfo = this.pageInfos.pop()
console.log('pop' + '返回值' + JSON.stringify(popDestinationInfo))
return true
})
}
}

// PageTwo.ets
export class Pages {
names: string = ""
values: NavPathStack | null = null
}

@Builder
export function pageTwoTmp(info: Pages) {
NavDestination() {
Column() {
Button('toPageOne', { stateEffect: true, type: ButtonType.Capsule })
.width('80%')
.height(40)
.margin(20)
.onClick(() => {
(info.values as NavPathStack).pushPathByName('pageOne', null)
})
}.width('100%').height('100%')
}.title('pageTwo')
.onBackPressed(() => {
(info.values as NavPathStack).pop()
return true
})
}

A.2,4,1,6
B.1,5,1,6
C.0,6,1,6
D.2,4,1,2

12.以下哪份代码可以实现下图Grid布局

A.通过设置GridItem的columnStart和columnEnd
// xxx.ets
@Entry
@Component
struct GridExample3 {
numbers: String[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
scroller: Scroller = new Scroller()

build() {
Column({ space: 5 }) {
Grid(this.scroller) {
ForEach(this.numbers, (day: string) => {
if (day === '0' || day === '5') {
GridItem() {
Text(day)
.fontSize(16)
.backgroundColor(0xF9CF93)
.width('100%')
.height(80)
.textAlign(TextAlign.Center)
}.columnStart(1).columnEnd(4)
} else {
GridItem() {
Text(day)
.fontSize(16)
.backgroundColor(0xF9CF93)
.width('100%')
.height(80)
.textAlign(TextAlign.Center)
}
}
}, (day: string) => day)
}
.columnsTemplate('1fr 1fr 1fr 1fr')
.columnsGap(10)
.rowsGap(10)
.scrollBar(BarState.Off)
.width('100%')
.backgroundColor(0xFAEEE0)
.height(350)
}
}
}
B.通过设置不同GridItem的宽度
// xxx.ets
@Entry
@Component
struct GridExample3 {
numbers: String[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
scroller: Scroller = new Scroller()
columnGap: number = 10
gridItemWidth: number = 80

build() {
Column({ space: 5 }) {
Grid(this.scroller) {
ForEach(this.numbers, (day: string) => {
if (day === '0' || day === '5') {
GridItem() {
Text(day)
.fontSize(16)
.backgroundColor(0xF9CF93)
.width(this.gridItemWidth * 4 + this.columnGap * 3)
.height(80)
.textAlign(TextAlign.Center)
}
} else {
GridItem() {
Text(day)
.fontSize(16)
.backgroundColor(0xF9CF93)
.width(this.gridItemWidth)
.height(80)
.textAlign(TextAlign.Center)
}
}
}, (day: string) => day)
}
.columnsTemplate('1fr 1fr 1fr 1fr')
.columnsGap(this.columnGap)
.rowsGap(10)
.scrollBar(BarState.Off)
.width('100%')
.backgroundColor(0xFAEEE0)
.height(350)
}
}
}
C.通过GridLayoutOptions
@Entry
@Component
struct GridExample3 {
numbers: String[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8','9']
scroller: Scroller = new Scroller()
layoutOptions1: GridLayoutOptions = {
regularSize: [1, 1],
irregularIndexes: [0, 5],
}

build() {
Column({ space: 5 }) {
Grid(this.scroller, this.layoutOptions1) {
ForEach(this.numbers, (day: string) => {
GridItem() {
Text(day)
.fontSize(16)
.backgroundColor(0xF9CF93)
.width('100%')
.height(80)
.textAlign(TextAlign.Center)
}
}, (day: string) => day)
}
.columnsTemplate('1fr 1fr 1fr 1fr')
.columnsGap(10)
.rowsGap(10)
.scrollBar(BarState.Off)
.width('100%')
.backgroundColor(0xFAEEE0)
.height(350)
}.align(Alignment.Center)
}
}

13.如果要实现Row组件内的子元素均匀排列，且第一个元素与行首对齐，最后一个元素与行尾对齐，需要使用justifyContent的哪个枚举值
A.End
B.SpaceEvenly
C.Start
D.SpaceBetween

14.开发者小张正在使用DevEco Studio开发一款HarmonyOS应用，他遇到了一个仅在应用实际运行环境中出现的问题，需要调试已部署在设备上的应用以定位问题根源，为了能够在应用已经运行的情况下介入调试，小张应该采用哪种调试方法
A.Attach Debugger to Process，这允许他连接到正在运行的应用进程进行调试。
B.使用Debug功能，将应用重新推包运行调试
C.使用“Profile”功能，因为这同样能提供对运行时应用的监控与调试能力。
D.Run without Debugging，先让应用自由运行，随后手动附加调试器。

15.开发者在编写ArkUI代码时，想要提前预览下所编写的组件的效果，下述哪个组件可以使用DevEco Studio Previewer正常预览？
A.@Preview @Component struct ConsumeSample { @Consume name: string; build() { Text(this.name) } }
B.@Preview @Component struct TitleSample { @StorageProp('title') title: string = 'PlaceHolder'; build() { Text(this.title) } }
C.@Preview @Component struct LinkSample { @Link message: string; build() { Text(this.message) } }
D.import { add } from 'libnative.so'; @Preview @Component struct NativeSample { count: number = add(1, 2); build() { Text(current count is ${this.count}) } }

16.使用DevEco Studio进行复杂的跨设备功能开发与调试工作，期间频繁依赖本地模拟器来模拟多样化的设备环境。在这样的背景下，以下关于DevEco Studio本地模拟器所支持的规格与功能，哪一项描述是准确的
A.本地模拟器和真机的能力没有任何差异，真机上可以支持的能力在模拟器上都可以
B.本地模拟器当前不支持单元测试框架和UI测试框架的运行
C.本地模拟器当前不支持查看HiLog以及FaultLog
D.本地模拟器上运行的应用无需进行签名，简化了调试过程。

17.张工在使用DevEco Studio开发HarmonyOS应用时，遇到了代码编译警告和错误。为了提高开发效率，哪一项正确描述了张工如何利用DevEco Studio的Quick Fix功能来有效管理和修复代码中的问题？
A.张工通过双击Shift键打开搜索框，输入"problems"打开问题工具面板，双击具体告警条目可直接跳转到问题代码行。接着，将光标置于告警位置，利用弹出的悬浮窗选择合适的修复建议或点击“More actions”以查看更多修复选项。
B.张工只需在代码编辑界面按下F1键，DevEco Studio会自动识别当前光标所在行的错误并直接修复。
C.张工应该首先使用Ctrl + Shift + F快捷键全局搜索问题，然后手动在搜索结果中找出代码警告和错误的原因及位置。
D.张工在代码编辑界面看到红色波浪线标记的错误时，直接右键点击错误代码，选择“Delete Line”以移除错误代码行，从而“修复”问题。

18.项目需要同时进行应用和元服务的开发，并针对当前项目工程中的代码可以分别构建出应用和元服务的包，如何在DevEco Studio中设置不同的构建配置，达成这个目的
A.修改工程级别的AppScope/app.json5中的bundleType值为app
B.在模块级别build-profile.json5定义两个target，将两个target的bundleType分别设置成app和atomicService
C.修改工程级别的AppScope/app.json5中的bundleType值为atomicService
D.在工程级别build-profile.json5定义两个product，将两个product的bundleType分别设置成app和atomicService

+++ 19.在使用DevEco Studio进行混合语言开发时，开发者小李通过Napi引用了Native 接口的文件（例如d.ts文件）。他想要直接从这些接口跳转到其对应的C/C++函数实现处进行代码审查。请从以下选项中选择最合适的操作步骤来帮助小李实现这一目标
A.为了查看C/C++函数实现，小李必须先切换到DevEco Studio的C/C++开发环境视图，之后在项目的资源管理器中找到对应的C/C++源文件手动打开，才能查看函数代码
B.在声明或引用了Native接口的文件中，比如d.ts文件，小李可以直接选中接口名称，右键点击并在弹出的菜单中选择“Go To > Implementation(s)”（转到> 实现）。还可以使用快捷键Ctrl+Alt+B；如果是macOS用户，则使用Command+Option+B，直接跳转到对应的C/C++函数实现位置。
C.小李可以将鼠标光标置于想要查看实现的接口名称上，按下鼠标右键，在出现的上下文菜单中寻找并点击“Find Usages”（查找用法），在结果中筛选出C/C++的实现。
D.小李应该打开包含TypeScript接口声明的文件，然后手动在项目中搜索相应的C/C++源文件，逐个检查以找到匹配的函数实现。

+++20.在HarmonyOS应用开发中，当开发者遇到需要分析Release版本应用的崩溃或异常堆栈信息时，为了准确地将堆栈追踪信息对应到源代码的具体位置，以下哪个描述是正确的做法或理解
A.DevEco Studio提供的Release应用堆栈解析功能，要求开发者在遇到问题时，需上传构建产物中的特定文件（如so、source map、nameCache等）到指定工具或界面，借助这些文件辅助解析堆栈信息，实现从Release堆栈到源码的映射，便于快速定位问题
B.DevEco Studio通过集成的Release应用堆栈解析功能，自动利用构建时产生的so文件、source map文件、nameCache文件等，无需额外操作即可直接在Release应用中提供详细的源码级堆栈追踪信息
C.开发者需手动将Release构建生成的so文件与源代码进行映射，配合第三方工具进行堆栈信息还原，虽然过程繁琐，但最终能定位到问题代码位置
D.因为Release应用经过优化和去除Debug信息，直接从堆栈跟踪到源代码行号是不可能的，开发者只能依靠日志信息手工推测问题所在

+++ 21.小华正在使用DevEco Studio开发一款基于HarmonyOS的ArkUI应用，该应用需要实现一个功能，即当用户点击按钮时，通过ArkTS/JS API调用系统的分享功能。小华对具体的API调用细节不太熟悉，如何通过DevEco Studio快速查阅相关的API文档。
A.小华应该先停止编码工作，打开浏览器，手动搜索关键词“HarmonyOS ArkUI 分享API”，在官方网站的文档页面中寻找相关API的使用方法。
B.小华将鼠标悬停在编辑器中已经键入或打算键入的API调用（例如 @system.router.push）上，等待编辑器自动弹出悬浮提示框，显示该API的简要信息和不同版本参数说明。随后，点击提示框右下角的“Show in API Reference”链接，直接跳转到详尽的API参考文档页面。
C.小华右键点击代码编辑区，选择“Find Usages”选项，试图从其他地方引用该API的实例中学习如何使用分享功能。
D.小华在代码编辑区直接键入分享功能相关的API调用代码，如 arkui.getShare()，然后按F1键，期望编辑器能自动跳转到该API的文档页面。

22.应用开发中使用的各类资源文件，需要放入特定子目录中存储管理，以下关于资源说法错误的是
A.stage模型多工程情况下，共有的资源文件放到AppScope下的resources目录。
B.rawfile目录，支持创建多层子目录，子目录名称可以自定义，文件夹内可以自由放置各类资源文件。目录中的资源文件会被编译成二进制文件，并赋予资源文件ID。
C.resfile目录，应用安装后，resfile资源会被解压到应用沙箱路径，通过Context属性resourceDir获取到resfile资源目录后，可通过文件路径访问。
D.base目录是默认存在的目录，二级子目录element用于存放字符串、颜色、布尔值等基础元素，media、profile存放媒体、动画、布局等资源文件。

+++ 23.HAR（Harmony Archive）是HarmonyOS提供的共享包，以下关于HAR的描述错误的是
A.HAR不支持使用page页面。
B.HAR不支持在设备上单独安装/运行，只能作为应用模块的依赖项被引用。
C.HAR不支持引用AppScope目录中的资源。在编译构建时，AppScope中的内容不会打包到HAR中，因此会导致HAR资源引用失败。
D.HAR可以作为二方库和三方库提供给其他应用使用，如果需要对代码资产进行保护时，建议开启混淆能力。

+++ 24.want参数的entities匹配规则错误的是
A.调用方传入的want参数的entities为空，待匹配应用组件的skills配置中的entities不为空，则entities匹配失败。
B.调用方传入的want参数的entities为空，待匹配应用组件的skills配置中的entities为空，则entities匹配成功。
C.调用方传入的want参数的entities不为空，待匹配应用组件的skills配置中的entities为空，则entities匹配失败。
D.调用方传入的want参数的entities不为空，待匹配应用组件的skills配置中的entities不为空且包含调用方传入的want参数的entities，则entities匹配成功。

+++ 25.HarmonyOS提供了多种包结构，每种包编译后的产物都不同，下面说法错误的是
A.hsp包编译后的产物是.hsp文件。
B.hap包编译后的产物是.hap文件。
C.app包编译后的产物是.app文件。
D.har包编译后的产物是.har文件。

+++ 26.一个应用的一个UIAblity，其exported字段配置为false，以下哪个场景可以拉起这个UIAbility。
A.caller应用在后台，有START_ABILITY_FROM_BACKGROUND权限;
B.caller应用在后台，申请了长时任务，有START_INVISIBLE_ABILITY权限;
C.caller应用在后台，有START_INVISIBLE_ABILITY权限;
D.caller应用在后台，申请了长时任务，有START_ABILITY_FROM_BACKGROUND权限;

+++ 27.一个应用有2个UIAbility组件，其module.json中abilities标签的配置如下方代码。
在手机设备上，执行如下操作后：
1.启动UIAbility1，然后back键返回销毁UIAbility1;
2.启动UIAbility2, 然后back键返回销毁UIAbility2;
3.启动UIAbility2, 然后back键返回销毁UIAbility2;

进入多任务列表，能看看到该应用的几个任务视图：
"abilities": [
{
"name": "UIAbility1",
"srcEntry": "./ets/entryability/Ability1.ets",
"description": "$string:EntryAbility_desc",
"icon": "$media:icon",
"label": "$string:Ability1_label",
"startWindowIcon": "$media:icon",
"startWindowBackground": "$color:start_window_background",
"exported": true,
"launchType": multiton
},
{
"name": "UIAbility2",
"srcEntry": "./ets/entryability/Ability2.ets",
"description": "$string:Ability2_desc",
"icon": "$media:icon",
"label": "$string:Ability2_label",
"startWindowIcon": "$media:icon",
"startWindowBackground": "$color:start_window_background",
"exported": true,
"launchType": singleton,
"removeMissionAfterTerminate":true
}
]

A.0个
B.3个
C.2个
D.1个

+++ 28.开发者开发了一个应用，该应用只有一个hap包，其module.json5中abilities的配置如下
所示，包含1个UIAbility(无Web组件)、1个FormExtensionAbility组件、

1个WorkSchedulerExtensionAbility组件，那么该应用在运行过程中，

最多会存在几个应用进程：
"abilities": [

{
"name" : "EntryAbility",
"srcEntry" : "./etc/entryability/EntryAbility.ts",
"description" : "$string:EntryAbility_desc",
"exported" : ture
}
],

"extensionAbilities": [

{
"name": "ClockFormExtensionAbility",
"srcEntrance": "./ets/form/ClockFormExtensionAbility.ts",
"type": "form"
},

{
"name": "TipWorkSchedulerExtensionAbility",
"srcEntrance": "./ets/service/TipWorkSchedulerExtensionAbility.ts",
"type": "workScheduler"
}
]

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

29 1.在UIAbility的onCreate生命周期中通过EventHub的on注册"event1"和"event2"事件。
TypeScript
import { hilog } from '@kit.PerformanceAnalysisKit';
import { UIAbility, Want, AbilityConstant } from '@kit.AbilityKit';
const DOMAIN_NUMBER: number = 0xFF00;
const TAG: string = '[EventAbility]';
export default class EntryAbility extends UIAbility {
onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
// 获取UIAbility实例的上下文
let context = this.context;

// 获取eventHub
let eventhub = this.context.eventHub;

// 执行订阅操作
eventhub.on('event1', this.eventFunc);
eventhub.on('event2', this.eventFunc);
hilog.info(DOMAIN_NUMBER, TAG, '%{public}s', 'Ability onCreate');
}
// ...
eventFunc(argOne: Context, argTwo: Context): void {
hilog.info(DOMAIN_NUMBER, TAG, 'receive. ' + ${argOne}, ${argTwo});
return;
}
}

2.在UI组件的click处理事件中调用如下的eventHubFunc，连续点击2次该控件后，运行日志输出是什么：
TypeScript
import common from '@kit.AbilityKit';;
import { promptAction } from '@kit.ArkUI';
@Entry
@Component
struct Page_EventHub {
private context = getContext(this) as common.UIAbilityContext;
eventHubFunc() : void {
this.context.eventHub.emit('event1');
this.context.eventHub.emit('event2', 2, 'test2');
this.context.eventHub.off('event1');

}

build() {
Column() {
// ...
List({ initialIndex: 0 }) {
ListItem() {
Row() {
// ...
}
.onClick(() => {
this.eventHubFunc();
promptAction.showToast({
message: $r('app.string.EventHubFuncA')
});
})
}
}
// ...
}
// ...
}
}

A.[Example].[Entry].[EntryAbility] receive. []
[Example].[Entry].[EntryAbility] receive. [2,"test2"]
[Example].[Entry].[EntryAbility] receive. []

B.[Example].[Entry].[EntryAbility] receive. []
[Example].[Entry].[EntryAbility] receive. [2,"test2"]

C.[Example].[Entry].[EntryAbility] receive. []
[Example].[Entry].[EntryAbility] receive. [2,"test2"]
[Example].[Entry].[EntryAbility] receive. []
[Example].[Entry].[EntryAbility] receive. [2,"test2"]

D.[Example].[Entry].[EntryAbility] receive. []
[Example].[Entry].[EntryAbility] receive. [2,"test2"]
[Example].[Entry].[EntryAbility] receive. [2,"test2"]

+++ 30.hiAppEvent提供的Watcher接口，需要订阅到OS的崩溃事件，正确的实现方式（）
A.hiAppEvent.addWatcher({
name: "watcher",
appEventFilters: [
{
domain: hiAppEvent.domain.OS,
names: [hiAppEvent.event.APP_CRASH]
}
]
})

B.hiAppEvent.addWatcher({
name: "watcher",
onReceive: (domain: string, appEventGroups: Array<hiAppEvent.AppEventGroup>) => {
}
})

C.hiAppEvent.addWatcher({
name: "watcher",
appEventFilters: [
{
domain: hiAppEvent.domain.OS,
names: [hiAppEvent.event.APP_CRASH]
}
],
onReceive: (domain: string, appEventGroups: Array<hiAppEvent.AppEventGroup>) => {
}
})

D.hiAppEvent.addWatcher({
name: "watcher",
appEventFilters: [
{
names: [hiAppEvent.event.APP_FREEZE]
}
],
onReceive: (domain: string, appEventGroups: Array<hiAppEvent.AppEventGroup>) => {
}
})

+++ 31.应用发生崩溃，（）接口可以获取到崩溃时调用栈
A.hiDebug
B.hiAppEvent
C.hiLog
D.hiTraceMeter

+++ 32.关于ArkUI的ForEach和LazyForEach，下列说法错误的是？
A.当在滚动容器中使用了LazyForEach，框架会根据滚动容器可视区域按需创建组件，当组件滑出可视区域外时，框架会进行组件销毁回收以降低内存占用。
B.LazyForEach需要配合cachedCount和组件复用一起使用，以达到性能的最优表现。
C.长列表滚动场景，优先使用ForEach。
D.ForEach和LazyForEach会根据定义的键值生成规则为数据源的每个数组项生成唯一键值，并创建相应的组件。

+++ 33.当使用状态变量进行ArkUI组件间数据通信的时候，如果两个组件间没有直接的嵌套关系（非父子和祖孙关系组件），但是他们又属于同一页面，最佳的装饰器应该选用哪个？
A.LocalStorage
B.@Provide+@Consume
C.@State+@Link
D.AppStorage

+++ 34.为了提高性能，所以List组件支持懒加载，可以通过配置cachedCount属性设置缓存列表项的数量。当我们不设置List的属性cachedCount时，该属性的默认值是？
A.0
B.3
C.1
D.2

+++ 35.关于静态检查描述错误的是：
A.HarmonyOS应用可以采用ARKTS静态检查工具Codelinter或者CodeArts工具来做静态代码分析。
B.静态检查可以检测代码中的语法错误和潜在的逻辑错误，也支持检测代码在运行时现的错误，因此静态检查可以替代动态测试。
C.静态分析工具也在不断改进和升级。使用高级的静态分析工具可以提高代码检测的准确性和效率。例如，一些静态分析工具可以检测代码中的内存泄漏、死锁问题，从而提高代码的质量和可靠性。
D.静态检查是指使用静态代码分析工具对软件的“静态”(不运行的) 代码进行分析的一种方法，找出代码中潜在的漏洞。静态代码分析器检查源代码，找出特定的漏洞，并检查代码是否符合各种编码标准。

+++ 36.以下关于动态import说法正确的是（）
A.动态import支持懒加载，所以不能用于提升页面的加载速度。
B.动态import和静态import相比，灵活性更好，性能更好。
C.动态import不支持导入SDK的API，如@ohos.*
D.动态import支持加载HSP模块、HAR模块、OHPM包、Native库

+++ 37.以下对系统兼容性的理解正确的是
A.系统能力都会保持绝对的兼容性，不能因为任何非兼容性的修改而导致开发者成本上升
B.应用不需要关注系统的兼容性变化，那都是系统开发人员需要关注的事情
C.安全法律法规等不可控因素会导致系统非兼容性变更，开发者需要积极适配
D.已发布的系统能力有可能会发生非兼容性变更，比如新增特性或修改问题导致的行为不兼容，这种情况下应用需要关注changelog并进行适配。

+++ 38.以下关于应用架构技术选型说法不正确的是（）
A.元服务和应用可以共用一个代码工程，采用多目标产物构建方式，构建出应用和元服务两个产物，用于上架。
B.随着业务的发展，应用功能会越来越多，某些功能可以做成动态加载，动态加载的模块采用HAR工程来构建，方便复用和共享。
C.对于初始版本的应用，功能比较简单，可以考虑采用单HAP加上多个HAR工程构建代码工程。
D.一些应用的扩展能力，比如备份、服务卡片，可以采用ExtensionAbility做成单独的feature HAP包，独立分发。

+++ 39.一个应用项目工程中，模块依赖关系如下图所示，那么在最终编译结果.app文件中，存在的编译产物是：

A.A.hap + D.hsp + C.har
B.A.hap + D.hsp
C.A.hap + B.har + C.har + D.hsp
D.A.hap + B.har + D.hsp

+++ 40.关于长时任务开发使用的接口是
A.使用requestSuspendDelay申请任务，使用getRemainingDelayTime获取任务剩余时间
B.使用startWork申请任务，使用stopWork取消任务，使用getWorkStatus获取任务状态
C.使用publishReminder发布一个提醒类通知，使用cancelReminder取消一个指定的提醒类通知
D.使用startBackgroundRunning申请任务，使用stopBackgroundRunning取消任务

41.ArkTS支持以下哪个函数。
A.Object.getOwnPropertyDescriptors();
B.Object.values();
C.Object.hasOwnProperty();
D.Object.getOwnPropertyDescriptor();

42.ArkTS支持以下哪个函数？
A.Object.getOwnPropertyDescriptor();
B.Object.values();
C.Object.hasOwnProperty();
D.Object.getOwnPropertyDescriptors();

43.以下关于Taskpool和Worker的描述正确的是
A.开发者需要自行管理taskpool的数量及生命周期
B.TaskPool和Worker的任务执行时长上限都是无限制
C.Worker自行管理生命周期，开发者无需关心任务负载高低
D.TaskPool支持任务延时执行

44.下面关于方舟字节码格式IMM16_ID16_IMM8描述正确的是
A.8位操作码，16位立即数，16位id，8位立即数
B.8位操作码，16位立即数，16位id，8位寄存器
C.16位前缀操作码，16位立即数，8位寄存器
D.8位操作码，16位立即数，2个8位寄存器

45.Text组件不支持以下哪种使用方式？
A.
TypeScript
@Entry
@Component
struct SpanExample {
build() {
Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Start, justifyContent: FlexAlign.SpaceBetween }) {
Text() {
Span('In Line')
Span(' Component')
Span(' !')
}
}.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })
}
}
B.
TypeScript
@Entry
@Component
struct styledStringDemo {
scroll: Scroller = new Scroller();
layout: TextLayoutManager = new TextLayoutManager()
controller1: TextController = new TextController();

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

build() {
Column() {
Text(undefined, { controller: this.controller1 })
}.width('100%')
}
}
C.
Plain Text
@Entry
@Component
struct styledStringDemo {
scroll: Scroller = new Scroller();
mutableStyledString: MutableStyledString = new MutableStyledString("test hello world", [{
start: 0,
length: 5,
styledKey: StyledStringKey.FONT,
styledValue: new TextStyle({ fontColor: Color.Pink })
}]);
controller1: TextController = new TextController();

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

build() {
Column() {
Text(undefined, { controller: this.controller1 })
}.width('100%')
}
}
D.
TypeScript
@Entry
@Component
struct TextExample {
build() {
Column({ space: 8 }) {
Text('textShadow').fontSize(9).fontColor(0xCCCCCC).margin(15).width('90%')
}
}
}

46.根据上面代码，以下解释正确的是
TypeScript
enum Mode {
fullScreen,
halfScreen
}

@Entry
@Component
struct Page {
@State title: string = "";
@State mode: Mode = Mode.fullScreen;

isShownTitle(): boolean {
if (this.mode == Mode.fullScreen) {
this.title = "Title";

return true;
} else {
this.title= "Section";
return false;
}
}

build() {
Column() {
if (this.isShownTitle()) {
Text(`${this.title}`)
} else {
Text(`${this.title}`)
}
ChangeMode({ mode: this.mode})

}
}
}

@Component
struct ChangeMode {
@Prop mode: Mode;
build() {
Row({space: 20}) {
Button('full screen').onClick(() => {
this.mode = Mode.fullScreen;
})
Button('half screen').onClick(() => {
this.mode = Mode.halfScreen;
})
}
}
}

A.在ChangeMode里改变mode的值，会触发其父组件Page的Title内容的切换。
B.在自定义组件Page的build方法里改变状态变量是非法操作，可能导致未定义的异常UI行为。
C.本例子可以运行起来，所以代码没有问题。
D.为了避免@Prop的拷贝，可以优化使用@Link，在该例子中行为和@Prop一样。

+++ 47.依次点击A、B、C、D四个按钮，其中不会触发UI刷新的是：
TypeScript
class Info {
name: string;

constructor(name: string) {
this.name = name;
}
}
@Entry
@Component
struct Index {
@State nameList: Info= [new Info("Tom"), new Info("Bob"), new Info("John")]

build() {
Column() {
ForEach(this.nameList, (item: Info) => {
Text(`${item.name}`)
})
Button("A")
.onClick(() => {
this.nameList.push(new Info("Lucy"));
})
Button("B")
.onClick(() => {
this.nameList[0] = new Info("Eric");

})
Button("C")
.onClick(() => {
this.nameList[0].name = "Jim";
})
Button("D")
.onClick(() => {
this.nameList = [new Info("Barry"), new Info("Cindy"), new Info("David")];
})
}
}
}

A.A
B.D
C.B
D.C

48.在一个包含多个模块（如entry、feature、har、hsp等）的大型HarmonyOS应用项目中，如果要对某个静态共享模块构建出静态构建包产物，如何通过DevEco Studio进行构建

A.选中har模块，点击build菜单栏build hap（s）
B.选中har模块，点击build菜单栏make module ‘har’
C.选中hap模块，点击通过菜单栏make module ‘hap’
D.选中hsp模块，点击通过菜单栏make module ‘hsp’

+++ 49.已知下列代码PageOne页面为navigation中的某一子页面，依次点击PageOne页面中toPageTwo按钮，PageTwo页面中toPageOne按钮，此时获取当前页面的路由栈数量为多少
TypeScript
// PageOne.ets
@Component
export struct PageOneTmp {
@Consume('pageInfos') pageInfos: NavPathStack;

build() {
NavDestination() {
Column() {
Button('toPageTwo', { stateEffect: true, type: ButtonType.Capsule })
.width('80%')
.height(40)
.margin(20)
.onClick(() => {
this.pageInfos.pushPathByName('pageTwo',"")
})
}.width('100%').height('100%')
}.title('pageOne')
.onBackPressed(() => {
const popDestinationInfo = this.pageInfos.pop()
console.log('pop' + '返回值' + JSON.stringify(popDestinationInfo))
return true
})
}
}

// PageTwo.ets
export class Pages {
names: string = ""
values: NavPathStack | null = null
}

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

+++ 50.在使用DevEco Studio的Profiler进行HarmonyOS应用性能优化的流程中，以下哪个步骤最恰当地描述了开发者利用Profiler工具进行性能问题识别、定位、优化及验证的完整过程

A.利用“Realtime Monitor”初步识别性能瓶颈，创建深度分析任务定位根因，根据分析结果优化代码，再用“Realtime Monitor”验证优化效果
B.首先使用“Realtime Monitor”实时监控，观察应用资源消耗，一旦发现CPU或内存异常，直接修改代码并重新编译
C.仅通过创建深度分析任务，利用perf数据详细分析性能瓶颈，修改代码后，不需再进行验证直接发布应用
D.在发现应用性能不佳时，直接查看代码逻辑，凭经验修改后，利用Profiler的“Realtime Monitor”确认资源消耗是否降低

51.DevEco Studio提供HarmonyOS应用/服务的UI预览界面与源代码文件间的双向预览功能，支持ets文件与预览器界面的双向预览。关于双向预览，下列选项说法错误的是？

A.选中预览器UI界面中的组件，则组件树上对应的组件将被选中，同时代码编辑器中的布局文件中对应的代码块高亮显示。
B.双向预览不支持通过组件的属性面板实时修改属性或样式。
C.选中布局文件中的代码块，则在UI界面会高亮显示，组件树上的组件节点也会呈现被选中的状态。
D.选中组件树中的组件，则对应的代码块和UI界面也会高亮显示。

52.在开发HarmonyOS应用工程时，随着业务的发展，现在需要创建一个模块，关于在DevEco Studio中创建Module，下列选项哪种方式是错误的？

A.鼠标移到工程目录顶部，单击鼠标右键，选择New > Module...，开始创建新的Module，此时该module将创建在工程根目录下。
B.选中工程目录中任意文件，然后在菜单栏选择File > New > Module...，开始创建新的Module，此时该module将创建在工程根目录下。
C.在工程根目录下创建一个新的Directory，可在该目录下单击鼠标右键，选择New > Module...，创建新的Module，此时module将创建在该文件目录下。
D.在hvigor目录下，单击鼠标右键，选择New > Module...，创建新的Module，此时module将创建在该文件目录下。

53.下面的配置存在有几处错误（）

module.json5配置文件：
{
"module": {
"name": "entry",
// ...
"abilities": [
{
"name": "EntryAbility",
"srcEntry": "./ets/entryability/EntryAbility.ets",
// ...
"skills": [
{
"entities": [
"entity.system.home"
],
"actions": [
"ohos.want.action.home"
]
}
],
"metadata": [
{
"name": "ohos.entry.shortcuts",
"resource": "$profile:shortcuts_config"
}
]
}
]
}
}
在/resources/base/profile/目录下配置shortcuts_config.json配置文件：
{
"shortcuts": [
{
"shortcutId": "id_test1",
"label": "shortcutLabel",
"icon": "$media:shortcutIcon",
"wants": [
{
"bundleName": "com.ohos.hello",
"moduleName": "entry",
"abilityName": "EntryAbility"
}
]
}
]
}

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

+++ 54.在组件中，经常需要使用字符串、图片等资源。HSP中的组件需要使用资源时，一般将其所用资源放在HSP包内，而非放在HSP的使用方处，以符合高内聚低耦合的原则。下面访问HSP资源错误的是

A.通过$r访问HSP中的资源。 Image($r('app.media.example')) .id('example') .borderRadius('48px')
B.使用相对路径的方式，访问HSP中的资源。 Image("../../resources/base/media/example.png") .id('example') .borderRadius('48px')
C.跨包访问HSP内资源时，推荐实现一个资源管理类，以封装对外导出的资源。
将需要对外提供的资源封装为一个资源管理类：
// library/src/main/ets/ResManager.ets
export class ResManager{
static getPic(): Resource{
return $r('app.media.pic');
}
static getDesc(): Resource{
return $r('app.string.shared_desc');
}
}
对外暴露的接口，需要在入口文件index.ets中声明：
// library/index.ets
export { ResManager } from './src/main/ets/ResManager';

+++ 55.某个应用开发了一个UIAbilityA，其启动模式是specified，并且对应的AbilityStage的实现如下：
Plain Text
import AbilityStage from '@ohos.app.ability.AbilityStage';

import type Want from '@ohos.app.ability.Want';

export default class MyAbilityStage extends AbilityStage {

this.instanceIndex = 0;

onAcceptWant(want: Want): string {

if (want.abilityName === 'UIAbilityA') {

if (want.parameters && want.parameters.instanceKey === 'test') {

return test_instance_ + this.instanceIndex++;

} else {

return 'test_instance';

}

return 'MyAbilityStage';

}

依次调用如下方法4次启动UIAbilityA，value分别是"test" "test" "testA" "testA"，则当前运行期UIAbility实例有几个

function testSpecified(context, value) {

let want: Want = {

deviceId: '',

bundleName: 'com.samples.stagemodelabilitydevelop',

abilityName: 'UIAbilityA',

moduleName: 'entry',

parameters: {

instanceKey: value

}

};

context.startAbility(want).then(() => {

hilog.info(DOMAIN_NUMBER, TAG, 'Succeeded in starting UIAbilityA.');

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

hilog.error(DOMAIN_NUMBER, TAG, `Failed to start UIAbilityA. Code is ${err.code}, message is ${err.message}`);

})

}

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

+++ 56.singleton模式的UIAbility，在冷启动时生命周期的执行顺序是：

A.onCreate->onBackground->onWindowStageCreate
B.onCreate->onWindowStageCreate->onForeground
C.onCreate->onBackground->onForeground
D.onCreate->onForeground->onWindowStageCreate

+++ 57.作为应用开发者，你使用hiAppEvent订阅了崩溃事件。应用崩溃后，从onReceive接口返回的AppEventInfo中（）属性可以获取崩溃调用栈信息。

A.eventType
B.domain
C.name
D.params

+++ 58.当标记了@Reuseable的自定义组件实现了组件复用后，这个组件的复用范围是什么？

A.标记了@Reuseable的自定义组件的外层容器节点范围内
B.整个应用内都可以复用
C.整个页面都可以复用
D.标记了@Reuseable的自定义组件的父组件范围内

+++ 59.我们需要避免在逐帧调用的接口中执行耗时操作，下面哪个选项不属于上述的接口？

A.onTouch
B.aboutToReuse
C.onAreaChange
D.onScroll

+++ 60.下面持续集成描述哪项是错误的：

A.Martin Fowler说过，”持续集成并不能消除Bug，而是让它们非常容易发现和改正。”
B.持续集成(CI, Continuous Intergation): 指频繁的，一天多次将代码集成到主干。
C.持续集成就是持续编译，二者异曲同工
D.持续集成在大型项目（有几十个项目组）也能应用，即便是项目组开发进度不统一也没问题

+++ 62.某App有A、B、C、D四个团队分别负责ModuleA、ModuleB、ModuleC和ModuleD四个业务模块，随着业务的发展，ModuleA需要跳转到ModuleB、ModuleC的页面，ModuleB需要跳转到ModuleC、ModuleD的界面，ModuleC需要跳转到ModuleA的界面，ModuleD需要跳转到ModuleB和ModuleC的界面。由于复杂的依赖关系，导致一旦有变化就需要知会各个团队，所以该团队的架构师想要解耦各个业务模块，以下哪些做法是不推荐的（）

A.采用RouterModule作为中介者并用动态import解耦各个业务模块。
B.采用静态import方式引入对应跳转的页面。
C.可以采用Navigation作为页面导航根容器，将其放在entry中，其他Module的页面作为Navigation的子页面。
D.在RouterModule中采用路由表方式解耦各个业务模块。

+++ 63.某App依赖了3个ohpm库，这3个库占用的体积都比较大。在App的技术架构中，有多个hap和多个hsp均依赖这3个库，为了减少app的首包大小，以下哪些做法是无效的？

A.将这3个ohpm库封装到har包中，并对外提供必要的接口。
B.将某些特性做成按需加载模块，若这3个ohpm仅在按需加载模块里面使用，则将其打包在按需加载模块中。
C.将3个ohpm库分别封装成3个hsp，并对外提供必要的接口。
D.将3个ohpm库封装成1个hsp，并对外提供必要的接口。

+++ 64.在moduleA（HAP类型）中有一个图片名为image.png，在moduleB（HAR类型）也存在一个图片名为image.png，而moduleA依赖于moduleB，那么在moduleA的编译产物hap包中，image.png存在情况是：

A.两者都不存在
B.仅存在moduleA的image.png
C.两者都存在
D.仅存在moduleB的image.png

65.如何实现类似下图布局

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

66.以下示例代码中可以进行动画的属性有哪些？
TypeScript
@Component
struct MyComponent {
@State compWidth: number = 100;
@State compHeight: number = 100;
@State compRadius: number = 32;
build() {
Column() {
}
.width(this.compWidth) // 1
.height(this.compHeight) // 2
.animation({ curve: Curve.Ease, duration: 200 })
.borderRadius(this.compRadius) // 3
.onClick(() => {
this.compWidth += 10;
this.compHeight += 10;
this.compRadius += 4;
})
}
}

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

67.现有一个宽高分别为200px的XComponent组件，其绑定了一个XComponentController(xcController)，依次进行如下操作：
(1) xcController.setXComponentSurfaceRect( {surfaceWidth: 150, surfaceHeight: 500} )
(2) 设置XComponent组件的padding为{ top: 5px, left: 10px, bottom: 15px, right: 20px }
(3) 将XComponent组件大小改为300px×300px
(4) 给XComponent组件设置一个宽度为2px的边框
(5) xcController.setXComponentSurfaceRect( { offsetX: -20, offsetY: 50, surfaceWidth: 200, surfaceHeight: -100 } )
之后，调用xcController.getXComponentSurfaceRect()的返回值为

A.{ offsetX: 75, offsetY: -100, surfaceWidth: 150, surfaceHeight: 500 }
B.{ offsetX: 81, offsetY: -89, surfaceWidth: 150, surfaceHeight: 500 }
C.{ offsetX: 81, offsetY: -89, surfaceWidth: 200, surfaceHeight: 0 }
D.{ offsetX: -20, offsetY: 50, surfaceWidth: 200, surfaceHeight: 500 }

68.一个复杂的项目，该项目不仅包含主入口模块（Entry Module），还有多个特性的功能模块（Feature Modules/HSP），并且这些模块间存在着相互调用关系。为了确保在调试过程中能够完整地测试所有交互逻辑，需要将涉及到的所有模块的HAP包都部署到目标设备上。请从以下选项中选择正确的操作步骤来配置DevEco Studio，以便一次性部署和调试项目中的多个模块

A.进入“Run > Edit Configurations”菜单，在“Deploy Multi Hap”选项卡下，勾选“Deploy Multi Hap Packages”，随后在列表中选择需要部署的模块。
B.在项目结构界面手动选择每个模块，单独编译并逐一将生成的HAP包通过HDC命令推送到设备上。
C.无需特殊配置，DevEco Studio会自动检测到项目中的所有模块依赖，并在每次调试运行时自动部署所有相关HAP包。
D.直接点击运行按钮，DevEco Studio会弹出对话框询问需要部署哪些模块，从中选择需要的模块后开始调试。

69.当您开始开发一个应用/服务时，首先需要根据工程创建向导，创建一个新的工程，工具会自动生成对应的代码和资源模板。关于新建工程，下列选项说法正确的是？

A.Compatible SDK是兼容的最低API Version。
B.工程文件本地存储路径（Save location）允许包含中文字符。
C.应用包名（Bundle name）必须为以点号（.）分隔的字符串，且至少包含三段，每段中仅允许使用英文字母、数字，如“com.example.myapplication ”。
D.创建用于Lite Wearable设备的工程，可以选择Native C++工程模板。

70.开发者张工想要高效地管理HarmonyOS设备中的文件，包括查看文件列表、进行文件搜索、新建及删除操作，以及在设备与PC间传输文件，而无需使用命令行工具。以下哪个选项最能准确概括张工能通过哪个工具直接在DevEco Studio界面完成上述所有操作

A.DevEco Studio的Project Explorer
B.DevEco Studio的Terminal面板
C.DevEco Studio的Device File Browser
D.DevEco Studio的Log面板

+++ 71.在一个包含多个模块（如entry、feature、service、library等）的大型HarmonyOS应用项目中，如果某个模块feature对另外一个公共库模块library有依赖，如何通过DevEco Studio正确配置项目依赖关系

A.在library的oh-package.json5文件的dependencies字段中配置feature的依赖
B.无需配置，直接在代码中编写import xxx from ‘library’
C.在feature的oh-package.json5文件的dependencies字段中配置library的依赖
D.在feature的build-profile.json5文件的dependencies字段中配置library的依赖

+++72.张工正在使用DevEco Studio进行一个复杂项目的开发工作，项目中包含了成千上万行代码且涉及众多模块。在重构代码的过程中，他意识到需要对一个核心类名进行更改，考虑到这个类在整个项目中被广泛引用，手动修改不仅耗时且容易出错。
基于DevEco Studio提供的代码编辑功能，以下哪个描述最准确地概述了张工如何高效且安全地完成对类名的更改，同时确保整个项目中所有相关引用同步更新？

A.张工需打开项目搜索功能，输入旧类名找到所有匹配项，逐一进行替换，完成更名操作。
B.张工只需简单选中需要更名的类名，按下Delete键删除后直接输入新名称，DevEco Studio会自动识别并更新所有引用。
C.张工选中需要更名的类名，使用快捷键Shift+F6或右键菜单Refactor -> Rename，在弹出框中输入新名称并选择替换范围后，点击“Refactor”完成更名操作，确保所有相关引用自动更新。
D.张工在代码编辑器中右键点击该类名，选择“Find Usage”，手动浏览所有引用位置并逐一修改为新名称。

73.开发者小李遇到了一个复杂的问题，该问题仅在特定的代码执行路径上出现，且难以复现。他使用的是C++进行核心算法开发，代码的逻辑密集且对性能要求极高，DevEco Studio为C/C++开发者提供的高级调试能力，以下哪个能力可以帮助小李查看代码历史执行路径，回溯到关键的变量状态

A.传统调试模式：仅允许在当前断点暂停代码执行，查看调用堆栈和当前变量信息，但无法追溯历史执行状态
B.代码静态分析：提供静态代码检查工具，通过语法和逻辑分析帮助预防潜在错误，但不涉及运行时问题定位
C.实时代码修改与运行时效果查看：支持在调试过程中修改代码并立即查看修改效果，适用于快速迭代，但不聚焦于问题追溯
D.反向调试能力：允许开发者在调试过程中回退回到之前的代码行或断点，不仅查看过去的堆栈信息，还能重现历史的全局、静态和局部变量状态，帮助深入理解代码历史行为，特别是对于复杂逻辑和难以复现的bug定位至关重要

+++74.在编译构建HAP时，会从HAP模块及依赖的模块中收集资源文件，如果不同模块下的资源文件出现重名冲突时，会按照优先级进行覆盖，现在有一个HAP依赖了两个HAR，依赖配置如下所示：
// oh-package.json5
{
"dependencies": {
"dayjs": "^1.10.4",
"lottie": "^2.0.0"
}
}
在资源覆盖时，以下优先级排序正确的是（）

A.AppScope>HAP包自身模块>lottie模块>dayjs模块
B.HAP包自身模块>lottie模块>dayjs模块>AppScope
C.HAP包自身模块>dayjs模块>lottie模块>AppScope
D.AppScope>HAP包自身模块>dayjs模块>lottie模块

75.应用程序开发调试过程中，经常需要安装新应用进行调测，下面安装应用操作错误的是

A.bm install -p /data/app/
B.bm install -p ohosapp.hap
C.bm install -p ohosapp.hap -r
D.hdc install -p ohosapp.hap

+++ 76.可以通过下面那个接口拉起导航类的垂域面板

A.startAbilityByCall
B.startAbilityByType
C.startAbility
D.startAbilityForResult

+++ 77.hiAppEvent提供的Watcher接口，（）属性不配置，会导致编译报错，产生"ArkTS Compiler Error".

A.triggerCondition
B.onTrigger
C.onReceive
D.name

+++ 78.关于自动化测试描述正确的是：
A.XTS子系统是认证测试套件的集合，当前包括acts（application compatibility test suite）应用兼容性测试套件，后续会拓展dcts（device compatibility test suite）设备兼容性测试套件等。
B.自动化测试因提高效率，减少重复工作的特性而被广泛采用；自动化测可以替代手动测试在处理复杂、难以预测的用户交互或特殊边界条件。
C.DT(开发者测试)就是UT，可看护的范围包括边界值问题、空指针或赋值错误，内部业务逻辑问题等等。
D.Fuzz测试就是通过构造不规则的输入，从而触发程序的某种bug；Fuzz测试属于白盒测试。Fuzz测试也叫做模糊测试，通过输入非法字段，并观察软件是否异常来实现。一方面可以通过向软件输入非法字段，另一方面也可以通过向网络服务发送异常报文。

+++ 79.某业务团队的架构师发现某个特性用的频率比较少，但是这个特性占用空间资源还是比较大的。为了减少首包下载体积，准备将该特性解耦出来，并对外提供API方便主模块调用。以下说法正确的是（）

A.将该特性做成动态加载的har包，暴露接口给主模块使用。
B.将该特性做成按需加载的hsp包，暴露接口给主模块使用。
C.将该特性做成hap包，通过Ability组件暴露出来给主app使用。
D.将该特性做成H5模块，通过web组件加载远程资源使用。

+++ 80.关于延迟任务开发使用的接口是

A.使用startWork申请任务，使用stopWork取消任务，使用getWorkStatus获取任务状态
B.使用startBackgroundRunning申请任务，使用stopBackgroundRunning取消任务
C.使用publishReminder发布一个提醒类通知，使用cancelReminder取消一个指定的提醒类通知
D.使用requestSuspendDelay申请任务，使用getRemainingDelayTime获取任务剩余时间

+++81.开发者小林正在使用DevEco Studio开发一款HarmonyOS应用，并在真机上进行调试。他在运行应用的过程中突然发现一处UI布局需要微调，希望在不中断当前应用运行的情况下看到调整效果，基于DevEco Studio提供的Hot Reload（热重载）能力，以下哪一种做法能让小林最有效地实现他的需求

A.继续运行应用，手动重启应用后检查布局是否符合预期
B.使用模拟器替代真机进行调试，因为Hot Reload仅在模拟器上支持代码改动的即时生效
C.在不关闭应用的情况下，直接修改代码并保存，借助Hot Reload功能在真机上实时查看布局调整的效果
D.立即停止应用，修改代码后重新编译并部署到真机上

82.在使用DevEco Studio的Profiler进行HarmonyOS应用或服务性能分析时，面对应用出现卡顿、加载慢等性能瓶颈问题，以下哪个描述最贴切地说明了“Time场景分析任务”的功能及其对开发者优化流程的帮助

A.Time场景分析任务专注于内存管理，帮助开发者监控应用内存泄漏，但对解决卡顿和加载耗时问题帮助有限
B.Time场景分析任务在应用运行时，通过显示所有函数执行的耗时排序列表，辅助开发者手动对比寻找耗时最短的函数进行优化
C.Time场景分析任务展示热点区域内的CPU和进程级调用栈耗时情况，支持代码跳转，助力开发者快速定位并优化耗时较长的代码段
D.Time场景分析任务仅提供应用/服务运行时的CPU使用率概览，帮助开发者粗略判断性能瓶颈，但不提供深入分析

83.当前您在开发一个ArkTS、Stage模型的HarmonyOS工程，关于当前ArkTS工程目录结构，下列选项说法错误的是？

A.AppScope > app.json5：应用的全局配置信息。
B.entry > src > main > module.json5：Stage模型模块配置文件，主要包含HAP的配置信息、应用在具体设备上的配置信息以及应用的全局配置信息。
C.build-profile.json5：应用级编译构建任务脚本。
D.oh-package.json5：描述依赖配置，如：依赖覆盖（overrides）、依赖关系重写（overrideDependencyMap）和参数化配置（parameterFile）等。

+++ 84.小李正在使用DevEco Studio进行HarmonyOS应用的开发工作，他需要对一个频繁被调用的函数calculateData()进行重构，为了帮助小李高效地找到calculateData()函数的所有引用位置，并确保重构时考虑周全，以下哪个步骤是正确的使用DevEco Studio的“Find Usages”功能的操作方法

A.小李应该在菜单栏中选择“Navigate” > “Class”来打开类浏览器，从中找到calculateData()函数，并在此界面中手动检查所有引用。
B.小李只需将光标定位在calculateData()函数名上，右键点击并选择“Find Usages”，或者直接使用快捷键Alt + F7（macOS为Option + F7），DevEco Studio会自动列出该函数在项目中的所有引用位置。
C.小李应将光标置于calculateData()函数的名称上，按下Ctrl + Shift + F（macOS为Command + Shift + F）全局搜索该函数名，然后在搜索结果中筛选出真正的调用位置。
D.小李应当在项目目录树中找到calculateData()函数所在的文件，直接双击打开文件，然后逐行扫描代码以手动查找该函数的所有调用位置。

+++ 85.作为一个应用开发者，想搭建运维平台，想在应用内定时读取当前的内存信息，可以通过（）接口来实现。
A.hiAppEvent
B.hiLog
C.hiDebug
D.hiChecker

+++ 86.关于代码门禁理解正确的是：
A.代码门禁是一项代码质量保障措施。目的是要求开发人员提交的代码必须满足一些要求才能合入代码仓库。门禁必须强制要求包括编译通过、单元测试覆盖率达标、代码静态检查无告警、全量功能测试用例、DFX专项测试都通过。
B.代码门禁则是在代码合并之前就验证代码来保护主干分支的完整性。通过这种方式，可以保护主分支代码避免因合码导致的构建中断，以确保 master 分支代码始终是可部署的，并且不会因明显的错误而影响到你正在并行开发的同事工作。
C.门禁级检查的范围和版本级检查的范围保持一致，尽可能多的在MR门禁阶段就拦截防护住问题，保障问题可以及时清理掉。
D.标准 CI 构建是在代码合并后检查已提交代码的功能完整性，这种方法会导致代码合并到master后编译失败导致没有可用版本部署。通过提高滚动构建的频度就可以代替代码门禁，保障代码主干及时发现并解决问题。

+++ 87.已知下列代码PageOne页面为navigation中的某一子页面，依次点击PageOne页面中toPageTwo按钮，PageTwo页面中toPageOne按钮，此时点击get按钮获取全部名为name的NavDestination页面的位置索引为
TypeScript
// PageOne.ets
@Component
export struct PageOneTmp {
@Consume('pageInfos') pageInfos: NavPathStack;

// PageTwo.ets
export class Pages {
names: string = ""
values: NavPathStack | null = null
}

A.[0,2]
B.[1,2]
C.[2,1]
D.[0,1]

？？88.项目中涉及多个类的继承与重写。为了快速实现子类对父类方法的重写，小华想利用DevEco Studio提供的便捷功能来提高开发效率。他了解到，通过一个特定的操作流程，可以直接依据父类的模板生成子类中需要重写的方法代码，而无需手动编写完整方法体，在DevEco Studio中，如何正确使用Override Methods功能来快速生成子类需要重写的方法代码

A.通过菜单栏File > Settings，配置Override Methods快捷方式，之后在代码中仅需选中父类方法名，即可自动在子类中生成重写代码。
B.在项目结构视图中找到目标子类，双击打开后直接在代码编辑区输入重写方法的签名，DevEco Studio将自动完成剩余代码。
C.将光标定位到子类的定义处，按下Ctrl+O（或右键单击选择Generate... > Override Methods），在弹出的对话框中选择要重写的方法，点击OK完成生成。
D.将光标放置于任何代码行，按下Ctrl+B，然后在弹出菜单中选择Override Methods，之后勾选需要重写的方法并确认。

89.HarmonyOS应用开发团队正着手优化一款面向全球市场的在线教育应用，该应用在特定课程直播环节出现了性能波动和响应延迟的问题，严重影响用户体验。打算利用DevEco Profiler来进行性能优化。DevEco Profiler其设计核心和主要优势是什么

A.DevEco Profiler采用Bottom-Up设计原则，从底层代码细节开始逐步构建性能模型
B.DevEco Profiler主要是一个自动化修复工具，能自动检测并解决所有HarmonyOS应用的性能问题
C.DevEco Profiler专注于用户界面设计的美化，使开发者操作更为直观
D.DevEco Profiler依据Top-Down设计理念，通过高度整合的数据展示范式，提供从宏观到微观的性能数据分析，加速开发者定位和解决问题的过程

90.小李正在使用DevEco Studio进行HarmonyOS应用的开发工作，他需要对一个频繁被调用的函数calculateData()进行重构，为了帮助小李高效地找到calculateData()函数的所有引用位置，并确保重构时考虑周全，以下哪个步骤是正确的使用DevEco Studio

A.小李只需将光标定位在calculateData()函数名上，右键点击并选择“Find Usages”，或者直接使用快捷键Alt + F7（macOS为Option + F7），DevEco Studio会自动列出该函数在项目中的所有引用位置。
B.小李应当在项目目录树中找到calculateData()函数所在的文件，直接双击打开文件，然后逐行扫描代码以手动查找该函数的所有调用位置。
C.小李应将光标置于calculateData()函数的名称上，按下Ctrl + Shift + F（macOS为Command + Shift + F）全局搜索该函数名，然后在搜索结果中筛选出真正的调用位置。
D.小李应该在菜单栏中选择“Navigate” > “Class”来打开类浏览器，从中找到calculateData()函数，并在此界面中手动检查所有引用。

91.一个应用有2个UIAbility组件，其module.json中abilities标签的配置如下方代码。
在手机设备上，执行如下操作后：
1.启动UIAbility1，然后back键返回销毁UIAbility1;
2.启动UIAbility2, 然后back键返回销毁UIAbility2;
3.启动UIAbility2, 然后back键返回销毁UIAbility2;
进入多任务列表，能看看到该应用的几个任务视图：
TypeScript
"abilities": [
{
"name": "UIAbility1",
"srcEntry": "./ets/entryability/Ability1.ets",
"description": "$string:EntryAbility_desc",
"icon": "$media:icon",
"label": "$string:Ability1_label",
"startWindowIcon": "$media:icon",
"startWindowBackground": "$color:start_window_background",
"exported": true,
"launchType": multiton
},
{
"name": "UIAbility2",
"srcEntry": "./ets/entryability/Ability2.ets",
"description": "$string:Ability2_desc",
"icon": "$media:icon",
"label": "$string:Ability2_label",
"startWindowIcon": "$media:icon",
"startWindowBackground": "$color:start_window_background",
"exported": true,
"launchType": singleton,
"removeMissionAfterTerminate":true
}
]

A.1个
B.3个
C.0个
D.2个

+++ 92.ArkUI组件复用的作用机制是减少了什么时间从而降低了丢帧率？

A.组件节点渲染时间
B.组件销毁时间
C.数据挂载时间
D.组件节点和对象的创建时间

+++ 93.以下关于HAP（Harmony Ability Package）说法正确的是（）

A.应用工程如果包含多个Module，在应用市场上架时，会将多个.hap文件打包成一个.app文件。
B.应用工程编出的app文件中，只能包含一个hap文件。
C.DevEco Studio会在编译构建时，不需要对HAP进行一致性校验。
D.HAP是应用安装和运行的基本单位，在DevEco Studio工程目录中，一个HAP对应一个Module。应用打包时，所有的Module都只能生成.hap文件。

+++ 94.关于代理提醒开发使用的接口是
A.使用startBackgroundRunning申请任务，使用stopBackgroundRunning取消任务
B.使用startWork申请任务，使用stopWork取消任务，使用getWorkStatus获取任务状态
C.使用requestSuspendDelay申请任务，使用getRemainingDelayTime获取任务剩余时间
D.使用publishReminder发布一个提醒类通知，使用cancelReminder取消一个指定的提醒类通知

+++ 95.以下哪些赋值语句在ArkTS中是合法。
Plain Text
class C {}

let value1: number = null;
let value2: string | null = null;
let value3: string | undefined = null;
let value4: C = null

A.value2
B.value3
C.value1
D.value4

+++ 96.在使用DevEco Studio的Profiler进行HarmonyOS应用或服务内存管理优化时，以下哪个描述最准确地概述了“Allocation Insight”功能在识别和解决内存问题中的作用

A.Allocation Insight通过分析应用服务运行时的内存分配及使用情况，辅助定位内存泄漏、内存抖动和溢出问题，支持优化内存使用
B.Allocation Insight仅提供内存分配总量的概览，帮助开发者宏观了解内存使用趋势，但对于具体泄漏或抖动问题无能为力
C.Allocation Insight主要关注于内存碎片整理，减少内存分配的不连续性问题，对内存泄漏和溢出问题的检测不是其主要功能
D.Allocation Insight详细展示应用运行时的每条语句柄分配记录，便于开发者逐一检查内存使用，但不提供内存泄漏的自动识别功能

+++ 97.通过aa工具拉起com.example.test的EntryAbility，并传参给EntryAbility，具体参数是number类型的[key1, 1] [key2,2] 和string类型的[key3, testString] [key4,''],
那边下面那个aa 命令是正确的：

A.aa start -b com.example.test -a EntryAbility --pi key1 1 key2 2 --ps key3 testString --psn key4
B.aa start -b com.example.test -a EntryAbility --pi key1 1 --pi key2 2 --ps key3 testString --psn key4
C.aa start -b com.example.test -a EntryAbility --pi key1 1 --pi key2 2 --ps key3 testString --ps key4
D.aa start -b com.example.test -a EntryAbility --pi key1 1 --pi key2 2 --ps key3 testString --psn key4 ''

+++ 98.关于短时任务开发使用的接口是
A.使用publishReminder发布一个提醒类通知，使用cancelReminder取消一个指定的提醒类通知
B.使用startWork申请任务，使用stopWork取消任务，使用getWorkStatus获取任务状态
C.使用startBackgroundRunning申请任务，使用stopBackgroundRunning取消任务
D.使用requestSuspendDelay申请任务，使用getRemainingDelayTime获取任务剩余时间

99.已知下列代码PageOne页面为navigation中的某一子页面，依次点击PageOne页面中toPageTwo按钮，PageTwo页面中toPageOne按钮，此时点击get按钮获取全部名为name的NavDestination页面的位置索引为
TypeScript
// PageOne.ets
@Component
export struct PageOneTmp {
@Consume('pageInfos') pageInfos: NavPathStack;

// PageTwo.ets
export class Pages {
names: string = ""
values: NavPathStack | null = null
}

A.[0,2]
B.[0,1]
C.[1,2]
D.[2,1]

100.开发者开发了一个应用，该应用只有一个hap包，其module.json5中abilities的配置如下所示，包含1个UIAbility(无Web组件)、1个FormExtensionAbility组件、1个WorkSchedulerExtensionAbility组件，那么该应用在运行过程中，最多会存在几个应用进程：
Plain Text
"abilities": [
{
"name" : "EntryAbility",
"srcEntry" : "./etc/entryability/EntryAbility.ts",
"description" : "$string:EntryAbility_desc",
"exported" : ture
}
],

"extensionAbilities": [
{
"name": "ClockFormExtensionAbility",
"srcEntrance": "./ets/form/ClockFormExtensionAbility.ts",
"type": "form"
},

{
"name": "TipWorkSchedulerExtensionAbility",
"srcEntrance": "./ets/service/TipWorkSchedulerExtensionAbility.ts",
"type": "workScheduler"
}
]

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

+++ 101.下面持续交付&持续部署描述哪个是正确的：
A.持续交付(CD, Continuous Delivery): 指的是，频繁的将软件的新版本，交付给质量团队或者用户，以供评审。如果评审通过，代码就进入生产阶段。它强调的是，不管怎么更新，软件是随时随地可以交付的。
B.在持续交付实践中，要考虑处理故障回滚和紧急修复，以确保系统在出现问题时能够快速恢复和修复。
C.持续部署是将代码库中的任何更改都应该自动且快速地投入生产环境。持续部署等同于持续交付。
D.持续交付可以随时随地部署到生产环境

+++ 102.WebSocket连接开发步骤描述错误的是
A.使用完WebSocket连接之后，主动断开连接
B.导入需要的webSocket模块
C.(可选）订阅WebSocket的打开、消息接收、关闭、Error事件
D.调用Session.start方法开启metadata数据输出
E.创建一个WebSocket连接，返回一个WebSocket对象
F.根据URL地址，发起WebSocket连接

+++ 103.从桌面冷启动如下应用代码，点击Change按钮5次，整个过程中，代码中的2条log依次出现的次数是：
TypeScript
class Data {
num: number
type: string

constructor(num: number, type: string) {
this.num = num;
this.type = type;
}
}

@Reusable
@Component
struct Item {
@State data: Data | undefined = undefined;

aboutToAppear(): void {
console.log("Demo log1");
}

aboutToReuse(params: ESObject): void {
console.log("Demo log2");
this.data = params.data
}

build() {
Text("num = " + this.data?.num + ", type = " + this.data?.type)
}
}

@Entry
@Component
struct Index {
data1: Data = new Data(1, "type1");
data2: Data = new Data(2, "type2");
@State data: Data = this.data1

build() {
Column() {
if (this.data.type == "type1") {
Item({ data: this.data }).reuseId(this.data.type)
} else {
Item({ data: this.data }).reuseId(this.data.type)
}
Button('Change').onClick(() => {
if (this.data === this.data1) {
this.data = this.data2
} else {
this.data = this.data1
}
})
}
}
}

A.1,5
B.1,0
C.2,4
D.6,0

104.项目中包含多个模块和数千行代码。随着开发的深入，项目中的ArkTS源代码文件逐渐积累了大量import语句，其中不乏未使用的import以及不规范的排序情况，关于DevEco Studio的编辑器的“Optimize Imports”，以下说法正确的是

A.在DevEco Studio中，没有直接的“Optimize Imports”功能，需要安装第三方插件来实现这个需求。
B.为了快速清理未使用的import，可以选中项目根目录，按下快捷键Ctrl+Alt+O（在macOS上为Control+Option+O），让DevEco Studio自动识别并移除所有未使用的import，并自动按照预设规则排序和合并import。
C.可以在菜单栏中依次点击“Code” > “Reformat Code”来达到优化import的目的，因为“Optimize Imports”功能已整合进“Reformat Code”中。
D.应该手动遍历每个ArkTS文件，逐一检查并删除未使用的import语句，然后按照字母顺序手动排序剩余的import。

105.以下关于垂直滚动Grid组件使用cachedCount属性的说明正确的是
A.设置cachedCount为1，则Grid在显示范围下方缓存1个GridItem
B.设置cachedCount为1，则Grid在显示范围上下各缓存1个GridItem
C.设置cachedCount为1，则Grid在显示范围上下各缓存1行GridItem
D.设置cachedCount为1，则Grid在显示范围下方缓存1行GridItem

！106.项目需要为不同的设备形态（如手机、智能手表）提供定制化构建。请说明如何在DevEco Studio中设置不同的构建配置，以生成针对不同设备的hap包？

A.在模块级别build-profile.json5定义多个target，在每个target的config/deviceType中定义不同的设备类型
B.在工程级别build-profile.json5定义多个product，在每个product的config/distributionFilter中定义不同的设备类型
C.在工程级别build-profile.json5定义多个product，在每个product的config/deviceType中定义不同的设备类型
D.在模块级别build-profile.json5定义多个target，在每个target的config/distributionFilter中定义不同的设备类型

+++107.下面的配置存在有几处错误（）
app.json5配置文件：
Plaintext
{
"app": {
"bundleName": "com.example.myapplication",
"vendor": "example",
"versionCode": 1000000,
"versionName": "1.0.2",
"icon": "$media:app_icon",
"label": "$string:app_name",
"bundleType": "app"
}
}
module.json5配置文件：
TypeScript
{
"module": {
"name": "feature",

// ...

"atomicService": {
"preloads":[
{
"moduleName":"feature"
}
]
}
}
}
A.1
B.3
C.4
D.2

多选题

+++ 1.哪些是持续集成最佳实践？
A.通常项目上会有一个专职 Ops，在项目可以发布的时候手动触发部署流程，或者需要传递很多参数，让 Pipeline 运行起来。
B.全面的测试套件：包括单元测试、集成测试、功能测试等，以提高代码质量。
C.自动化构建：确保构建过程是完全自动化的，减少人为错误。
D.代码审查：在集成前进行代码审查，及时发现潜在问题。
E.快速反馈机制：让开发人员能迅速得知集成结果和测试状态。
F.频繁提交代码：鼓励开发人员经常提交小的代码更改，以便更快地发现问题。
G.构建相同代码的 Pipeline 运行多次，得到结果不同。比如，基于同一代码基线，一条 Pipeline 构建了 5 次，只要最后一次通过即可。

！2.hiAppEvent提供的Watcher接口，订阅到的系统事件，哪些包含HiLog日志？
A.启动耗时事件
B.CPU高负载事件
C.崩溃事件
D.卡死事件

+++ 3.以下哪些方式可以实现ArkWeb同层渲染能力（）
A.Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("native", "test")
<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>
B.Web(...).enableNativeEmbedMode(true)
<object id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>
C.Web(...).enableNativeEmbedMode(true).registerNativeEmbedRule("object", "test")
<object id="view" type="test/contents" width="100%" height="100%" style="background-color:red"/>
D.Web(...).enableNativeEmbedMode(true)
<embed id="view" type="native/contents" width="100%" height="100%" style="background-color:red"/>

+ 4.在ArkTS中，以下哪些属性的声明是正确的。
TypeScript
class C {
value1: number = 0;
value2?: number = null;
value3: number | undefined = undefined;
value4?: number;
}
A.value2
B.value3
C.value1
D.value4

+++ 5.ArkTS是鸿蒙生态的应用开发语言。下列说法正确的是
A.ArkTS提供了声明式UI范式、状态管理支持等相应的能力，让开发者可以以更简洁、更自然的方式开发应用。
B.针对JavaScript（简称JS）/TS并发能力支持有限的问题，ArkTS对并发编程API和能力进行了增强。
C.TS/JS代码支持import ArkTS代码。
D.ArkTS在保持TypeScript（简称TS）基本语法风格的基础上，进一步通过规范强化静态检查和分析，使得在程序运行之前的开发期能检测更多错误，提升代码健壮性，并实现更好的运行性能。

+++ 6.下面关于方舟字节码指令含义说明正确的是
A.假设寄存器v0存放了对象A, 累加器(acc)存放了对象B，那么执行指令"lda v0"后，v0存放对象A，acc存放对象A
B.假设寄存器v0存放了对象A, 累加器(acc)存放了对象B，那么执行指令"lda v0"后，v0存放对象B，acc存放对象B
C.假设寄存器v0存放了对象A, 寄存器v1存放了对象B，那么执行指令"mov v0, v1"后，v0存放对象B, v1存放对象B
D.假设寄存器v0存放了对象A, 寄存器v1存放了对象B，那么执行指令"mov v0, v1"后，v0存放对象A, v1存放对象A

+++ 7.下面关于动态import描述正确的是
A.动态导入import()是个异步接口，调用后将返回一个promise
B.HAR模块间只有变量动态import时可以进行模块解耦
C.常量动态import也必须配置runtimeOnly选项
D.动态import根据入参是否为常量字符串分为常量动态import和变量动态import两种

+++ 8.以下数据类型中，哪些是Sendable数据。
import { lang } from '@kit.ArkTS';
class C {}
interface I extends lang.ISendable {}

A.number
B.class C
C.string
D.interface I

+++ 9.下面代码符合Node-API开发规范的是
A.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;
}

B.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.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;
}

D.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;
}

+++ 10.以下代码片段哪几处违反了ArkTS语法规范。
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.p.z = 2.0;
C.delete p.x;
D.p.x = 'Hello!';

+++ 11.处于安全因素考虑，ArkTS不支持以下哪些语法。
A.with()
B.new Function('a', 'b', 'return a + b')
C.eval()
D.Object.entries()

！12.以下哪些是可以在Navigation中使用pushPathByName接口传递的params的参数类型
A.map<string,string>
B.string
C.record<string,string>
D.arrayBuffer

+++ 13.依次点击A、B、C、D四个按钮，其中不会触发UI刷新的是：（AC）
TypeScript
@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.B
D.C

+++ 14.如下ABC 3处手势，有机会执行的是哪几处？
TypeScript
@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())
})
)以下napi代码有问题的是
}.width('100%').height('100%').backgroundColor(0xDCDCDC)
}
}

A.C
B.B
C.A
D.NA

+++ 15.如下哪些方式可实现图片动态播放？(BCD)
A.
TypeScript
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;
}
}

B.
TypeScript
@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.
TypeScript
@Entry
@Component
struct ImageExample {
build() {
Column({ space: 10 }) {
Image($r('app.media.earth')) //对应资源图片名后缀为gif
.width(100)
.height(100)
}
}
}

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

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

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

+++ 16.在开发过程中，我们可以将每个功能模块作为一个独立的Module进行开发。关于Module，下列选项说法正确的是？
A.entry类型的Module：应用的主模块，包含应用的入口界面、入口图标和主功能特性，编译后生成entry类型的HAP。每一个应用分发到同一类型的设备上的应用程序包，可以包含一个或多个entry类型的HAP。
B.HAR类型的Module：静态共享库。HAR中的代码和资源跟随使用方编译，如果有多个使用方，它们的编译产物中会存在多份相同拷贝。
C.Shared类型的Module：动态共享库。HSP中的代码和资源可以独立编译，运行时在一个进程中代码也只会存在一份。
D.feature类型的Module：应用的动态特性模块，编译后生成feature类型的HAP。一个应用中可以包含一个或多个feature类型的HAP，也可以不包含。

+++ 17.在基于Stage模型开发的应用项目代码下，都存在一个app.json5配置文件，用于配置应用的全局信息，以下app.json5配置文件错误的是（选择BD）
A.{
"app": {
"bundleName": "com.example.myapplication",
"vendor": "example",
"versionCode": 1000000,
"versionName": "1.0.2",
"icon": "$media:app_icon",
"label": "$string:app_name",
"bundleType": "app"
}
}

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

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

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

+++ 18.通过如下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.vieData",
],
"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": "https",
"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": "http",
"host": "www.test.com",
"port": "8080",
"path": "path",
"autoVerify": ture
}
]
}
]
}

+++ 19.使用如下的代码去启动一个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",
"pathStartWith" : "query/books",
"type" : "text/*" }
]
}
]

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

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

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

+++ 20.以下关于LocalStorage的说法正确有哪些？（答案：BCD）
A.LocalStorage中的所有属性都是不可变的。
B.组件树的根节点，即被@Entry装饰的@Component，可以被分配一个LocalStorage实例，此组件的所有子组件实例将自动获得对该LocalStorage实例的访问权限。
C.被@Component装饰的组件最多可以访问一个LocalStorage实例和AppStorage，未被@Entry装饰的组件不可被独立分配LocalStorage实例，只能接受父组件的LocalStorage实例。
D.应用程序可以创建多个LocalStorage实例，LocalStorage实例可以在页面内共享，也可以通过GetShared接口，获取在UIAbility里创建的GetShared，实现跨页面、UIAbility内共享。

+++ 21.Navigation组件是路由导航的根视图容器，一般作为Page页面的根容器使用，以下关于Navigation组件说法正确的是(CD)

A.Navigation子页面的根容器可以采用如Column、Row这些容器组件。
B.Navigation只能在entry类型的Module中使用
C.Navigation的子页面可以来自不同的Module
D.Navigation的页面显示模式有单页面、分栏和自适应三种显示模式

+++ 22.以下关于ArkTS线程实例间传输实现方式描述正确的是
TypeScript
import { taskpool, worker } from '@kit.ArkTS';

@Sendable
class A {}

let a: A = new A();

@Concurrent
function foo(a: A) {}

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

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

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

w.postMessageWithSharedSendable(a);

task.setCloneList([a]);
taskpool.execute(task).then(() => {});

w.postMessage(a);

A.taskpool.execute(task).then(() => {});，TaskPool 共享传输实现方式
B.w.postMessageWithSharedSendable(a);，Worker 共享传输实现方式
C.task.setCloneList([a]); taskpool.execute(task).then(() => {});，TaskPool 共享传输实现方式
D.w.postMessage(a);，Worker 共享传输实现方式

+++ 23.下面关于混淆规则描述正确的是
A.-keep-global-name [,identifiers,...]：指定想保留的属性名
B.-print-namecache filepath：将名称缓存保存到指定的文件路径。
C.-keep-property-name [,identifiers,...]：指定要保留的顶层作用域的名称
D.-keep-file-name [,identifiers,...]：指定要保留的文件/文件夹的名称

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

A.当静态导入的模块很明显的占用了大量的系统内存且被使用的可能性很低。
B.当被导入的模块说明符，需要动态构建。
C.当被导入的模块，在加载时并不存在，需要异步获取。
D.当静态导入的模块很明显的降低了代码的加载速度且被使用的可能性很低，或者并不需要马上使用它。

+++ 25.下面关于ArkTS中import用法，正确的是
A.import defaultExport from "ets file name"
B.import { export1 as alias1 } from "ets file name";
C.import * as name from "ets file name"
D.import { export1 } from "ets file name";

！26.项目组开发的HarmonyOS应用工程，为了保护hap代码资产，如何在DevEco Studio中启用混淆的功能，并设置相应的混淆规则
A.在混淆规则配置文件consumer-rules.txt中进行混淆规则的配置
B.release模式下将buildOption/arkOptions/ruleOptions/enable设置为false
C.release模式下将buildOption/arkOptions/ruleOptions/enable设置为true
D.在混淆规则配置文件obfuscation-rules.txt中进行混淆规则的配置

+++ 27.HSP支持导出ArkUI组件、接口，供应用内的其他HAP/HSP引用，下面正确的是（选项ABC）
A.
导出ts类和方法
Plain Text
// 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';
B.
导出ArkUI组件
Plain Text
// 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';
C.
导出native方法，在HSP中也可以包含C++编写的so。对于so中的native方法，HSP通过间接的方式导出，以导出liblibrary.so的乘法接口multi为例：
Plain Text
// 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';

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

A.
Plain Text
{
"module": {
"name": "aName",
"type": "har",
"deviceTypes": [
"default", "tablet" ]
}
}
B.
Plain Text
{
"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
}
]
}
}
C.
Plain Text
{
"module": {
"name": "bName",
"type": "shared",
"deviceTypes": [
"default",
"tablet"
],
"deliveryWithInstall": true,
"pages": "$profile:main_pages"
}
}
D.
Plain Text
{
"module": {
"name": "cName",
"type": "hsp",
"description": "$string:desc",
"deviceTypes": [
"default",
"tablet"
],
"deliveryWithInstall": true,
"pages": "$profile:main_pages"

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

A.createPurchase请求返回1001860051-由于已经拥有该商品，购买失败时
B.应用启动时
C.finishPurchase请求返回1001860052-由于未拥有该商品，发货失败时
D.createPurchase请求返回1001860001-内部错误时

+++ 30.使用ArkUI组件复用之后，还是没有显著提升列表滑动场景的性能，属于组件复用未生效可能的原因有？
A.复用的自定义组件中使用if等条件渲染语句导致结构不相同，未使用reuseId标记。
B.在aboutToReuse回调函数中更新了冗余的状态变量
C.页面嵌套了过多自定义组件。
D.没有在aboutToReuse更新关联的状态变量数据。

+ 31.以下代码片段哪几个函数违反了ArkTS语法规范。
TypeScript
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.foo3
C.foo1
D.foo2

+++ 32.以下napi代码有问题的是（ABD）
A.
Plain Text
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;
}
);
}
B.
Plain Text
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;
}
C.
Plain Text
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;
}
D.
Plain Text
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;
}

+++ 33.当前动态import支持导入的模块类型有哪些？
A.动态import支持加载OHPM模块
B.动态import支持加载本地HAR模块
C.动态import支持加载远程HAR模块
D.动态import支持加载HSP模块

+ 34.下面代码符合ArkTS编程规范的是（CD）
A.
JavaScript
for (let idx = 0; idx < 5; ++idx)
console.log(idx);
B.
JavaScript
let maxCount = 10, isCompleted = false;
let pointX, pointY;
pointX = 10; pointY = 0;
C.
JavaScript
if (condition) {
console.log('success');
}
D.
JavaScript
let maxCount = 10;
let isCompleted = false;
let pointX = 0;
let pointY = 0;

+++ 35.下面关于混淆的描述正确的是
A.API 10及以上版本的Stage模型、编译模式为release时，默认开启代码混淆功能；默认的混淆功能仅会混淆函数参数和局部变量的名称。
B.混淆支持ArkTS/TS/JS文件的混淆
C.代码混淆已经被集成了到SDK中，可以在DevEco Studio中方便地使用。
D.针对工程源码的混淆可以降低工程被破解攻击的风险，缩短函数名、类名和属性名，减小应用的大小。

+++ 36.以下哪些实现方式可实现文本字号20的效果（ABD）
A.
Plain Text
// 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 })
}
}
B.
Plain Text
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%')
}
}
C.
Plain Text
// 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.
Plain Text
@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 })
}
}

+++ 37.List组件onScrollIndex事件触发时机是
A.List组件首次加载完成时触发
B.List组件滚动停止时触发
C.List组件显示区域内第一个子组件或最后一个子组件或中间位置子组件索引值变化时触发
D.List组件列表滚动时每帧触发

+++ 38.开发者小李正在使用DevEco Studio开发一款面向HarmonyOS的应用，该应用需要在多种设备上表现出一致的稳定性和优秀的用户体验。为了确保高质量的发布，小李意识到需要实施一套全面的测试策略，覆盖代码的自动化测试和手动测试，还需要衡量代码的测试覆盖率，以确定测试的充分性。在DevEco Studio的测试框架下，以下描述中，哪些是正确的
A.无论选择Instrument Test还是Local Test，DevEco Studio均内置了详尽的测试报告功能，实时显示测试进度，且直接在IDE中可查看代码覆盖率报告，无需外部工具。
B.Instrument Test：测试用例存储于项目的ohosTest目录，要求在HarmonyOS设备或模拟器上执行，兼容ArkTS与JS语言编写。
C.DevEco Studio的测试框架提供测试用例执行能力，包含基础接口以编写和输出测试结果，鼓励用户创建易于维护的自动化测试脚本，并且统计代码覆盖率。
D.Local Test：测试用例位于test目录，无需设备或模拟器环境，直接在本地执行，专注于ArkTS语言，推荐适用于API版本11及以上的Hvigor工程，目前特别限于Stage模型，并不涵盖C/C++方法。

+++ 39.在大型软件工程中，一般会伴随着多团队开发，各团队开发自己的业务模块，最后再由集成交付团队集成到一起，下面哪些是大型应用模块化开发最佳实践
A.一次上架多端部署。
B.避免用户首次下载应用耗时过长，及过多占用用户空间，不常用功能做成按需加载。
C.若多个模块依赖了不同版本的HAR，使用OHPM的overrides机制配置指定使用哪个版本的HAR，以减少包大小。
D.使用路由表进行模块间解耦。

+++ 40.某业务团队发现用户对他们App的某个特性使用率并不高，为了节省用户首次下载安装包的体积，考虑将该特性做成按需加载，那么推荐该特性使用的工程模块类型是？
A.hap
B.hsp
C.app
D.har

+++ 41.以下关于Taskpool和Worker的描述正确的是
A.TaskPool支持设置任务的优先级
B.Worker支持取消已发起的任务
C.Worker的任务执行时长上限是无限制
D.TaskPool不支持线程复用

+++ 42.ArkTS中不能使用以下哪些类型。
A.union type
B.unknown
C.any
D.tuple type

+++ 43.ArkTS对并发编程API和能力进行了增强，以下描述正确的是
A.默认情况下，Sendable数据在ArkTS并发实例间（包括主线程、TaskPool&Worker工作线程）传递的行为是拷贝传递。
B.在并发API的形式上，目前主要有两种：Worker和TaskPool。
C.单次I/O任务的开发场景中，必须使用TaskPool进行开发。
D.CPU密集型任务场景中，当任务不需要长时间（3分钟）占据后台线程，而是一个个独立的任务时，推荐使用TaskPool进行开发。

+ 44.以下代码片段哪几处违反了ArkTS语法规范。
Plain Text
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, 3);
D.foo(1, 2);

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

A.ArkTS不支持null-satety特性。
B.通过规范强化静态检查和分析，减少运行时的类型检查，从而降低了运行时负载，提升执行性能。
C.通过规范强化静态检查和分析，使得许多错误在编译时可以被检测出来，降低代码运行错误的风险。
D.ArkTS保留了TS大部分的语法特性，帮助开发者更容易上手ArkTS。

+++ 46.Image组件以下哪些方式可显示图片？（ABCD）
A.
Plain Text
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
}
}
B.
Plain Text
@Entry
@Component
struct ImageExample {
build() {
Column({ space: 10 }) {
Image("https://www.example.com/xxx.png")
.width(100)
.height(100)
}
}
}
C.
Plain Text
@Entry
@Component
struct ImageExample {
build() {
Column({ space: 10 }) {
Image($r('app.media.earth'))
.width(100)
.height(100)
}
}
}
D.
Plain Text
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%')
}
}

47.在使用DevEco Studio进行HarmonyOS应用开发和调试过程中，开发者小张遇到应用运行时意外终止的情况，他需要快速定位并解决导致应用崩溃的问题。以下哪些做法可以帮助小张有效分析和处理这些问题
A.查看DevEco Studio log工具栏输出的错误日志，根据日志提示分析应用崩溃的具体原因及代码位置
B.若遇到App运行卡顿或系统整体无响应（App Freeze, System Freeze）的情况，可以通过性能分析工具中的Frame Insight和Allocation Insight功能，分析应用的资源消耗情况，寻找可能的瓶颈
C.利用系统自动生成的FaultLog，包括App Freeze、CPP Crash、JS Crash、System Freeze和ASan报告，这些报告会详细记录故障发生时的环境、堆栈信息和可能的故障原因，是排查问题的重要参考
D.当怀疑问题是由于C++代码中的内存错误（如数组越界、内存泄露、重复释放内存）引起时，进入“Run/Debug Configurations”设置界面，勾选启用Address Sanitizer (ASan)，然后重新部署应用进行测试以获取更详细的内存问题报告

+++ 48.某个应用的启动框架配置文件详细信息如下，以下说法正确的是：
Plain Text
{
"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_003会在StartupTask_004之后执行
C.StartupTask_006会在AbilityStage的onCreate前初始化完成
D.StartupTask_001会在StartupTask_004之后执行;

+++49.
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)
})
)
如果想让grid上的捏合手势手势生效，而不跟grid上的滚动手势形成冲突，.xxxx?手势接口应该怎么配置?

A.GesureGroup
B.priorityGesture
C.gesture
D.parallelGesture

+++ 50.下面关于ArkTS中export用法，正确的是
A.export { export1 } from "ets file name";
B.export * as name from "ets file name"
C.export * from "ets file name"
D.export { export1 as alias1 } from "ets file name";

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

A.mac计算机配置方面，为了确保本地模拟器的稳定运行，推荐至少配备8GB RAM。
B.为了保证流畅的运行和调试体验，本地模拟器推荐macOS系统版本至少为12.5以上。
C.开发者需要注意的是，DevEco Studio的本地模拟器可以在虚拟机内部进一步运行，以节省硬件资源。
D.DevEco Studio的本地模拟器允许开发者在个人电脑上模拟HarmonyOS环境，便于应用或服务的运行与调试。

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

A.feature类型的Module，应用的动态特性模块，一个应用中可以包含一个或多个feature类型的模块，也可以不包
B.Ability类型的Module，用于实现应用的功能和特性，有两种类型，分别为entry和feature。
C.entry类型的Module，是应用的主模块，一个应用只能包含唯一一个entry类型的HAP。
D.Library类型的Module，用于实现代码和资源的共享，有两种类型，分别为Static Library和Shared Library两种类型。

+++ 53.如何实现类似下图布局（多选）(AC)

A.
TypeScript
@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 })
}
}
B.
TypeScript
@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])

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)
}
}
C.
Plain Text
@Entry
@Component
struct Demo {
// 忽略其他辅助代码
dataSource: ItemDataSource = new ItemDataSource(100)
itemHeightArray: number= []
colors: number= [0xFFC0CB, 0xDA70D6, 0x6B8E23, 0x6A5ACD, 0x00FFFF, 0x00FF7F]
scroller: Scroller = new Scroller()

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

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

A.选中需要重构的代码块，右键点击选择“Refactor”，然后选择“Extract Method”来将代码块转换为一个新的函数/方法
B.如果小华识别到一组相关的对象字面值可以抽象为一个接口，他可以直接通过“Refactor”菜单中的“Extract Interface”功能实现
C.若需要将局部变量提升为类成员变量，小华只需简单选中变量名，右键选择“Refactor” -> “Promote Local Variable”
D.为了简化复杂类型的多次书写，小华可以选择特定类型字面量，通过“Refactor”菜单下的“Extract Type Alias”来创建类型别名

+ 55.以下代码片段哪几个class/interface违反了ArkTS语法规范。
Plain Text
class Person {}

class Student extends Person {}

class Instructor implements Person {}

interface Shape {}

interface Circle implements Shape {}

class Square implements Shape {}

A.Square
B.Student
C.Circle
D.Instructor

+++ 56.下面关于Node-API数据类型描述正确的是

A.napi_threadsafe_function_call_mode：该枚举类型定义了两个常量，用于指定在何时释放线程安全函数的回调函数
B.napi_threadsafe_function_release_mode：该枚举类型定义了两个常量，用于指定线程安全函数的调用模式
C.napi_status：是一个枚举数据类型，表示Node-API接口返回的状态信息
D.napi_env：用于表示Node-API执行时的上下文

+++ 57.下面关于方舟字节码文件格式描述正确的是
A.方舟字节码文件中数据类型uint16_t表示16-bit无符号整数，采用小端字节序
B.方舟字节码文件是ArkTS/TS/JS编译后的二进制产物
C.方舟字节码文件中数据类型uint32_t表示32-bit无符号整数，采用大端字节序
D.方舟字节码文件中不包含字节码文件内容的adler32校验和

+++ 58.为了加快构建速度，提高开发效率，可以如何调整hvigor配置，从而优化构建速度
A.启用hvigor的parallel，在增量场景下进行并行编译处理
B.启用hvigor的typeCheck，在增量场景下进行对hvigorfile.ts进行类型检查
C.启动hvigor的daemon模式，在增量场景下复用缓存
D.启用hvigor的incremental，在增量场景下检查任务是否可以跳过

+++ 59.哪些是持续部署最佳实践？
A.开发完成之后再向类生产环境部署：当软件被第一次部署到类生产环境(比如试运行环境)时，就是大部分开发工作完成时，至少是开发团队认为“该软件开发完成了”。
B.灰度发布：先在小部分用户或区域进行部署，观察没问题后再全面推广。
C.自动化部署流程：从代码提交到部署的整个流程应尽可能自动化。
D.监控和回滚机制：实时监控部署后的应用状态，如有问题及时回滚。
E.手工配置管理：
1、直接修改生产环境上的配置来改变系统配置；
2、集群中各节点的行为有所不同；
3、靠人手工恢复环境。手动记载配置包括操作系统、应用服务器、关系型数据库管理系统、Web服务器或其他基础设施设置。
F.手工部署：持续部署可以采用手工部署的方式发布软件：
1、有一份非常详尽的文档，该文档描述了执行步骤及每个步骤中易出错的地方；
2、以手工测试来确认该应用程序是否运行正确；
3、在发布时，常常会修正一些在发布过程中发现的问题。
G.环境一致性：保持开发、测试、生产等环境的高度一致性。

+++ 60.以下代码片段哪几处违反了ArkTS语法规范。
Plain Text
function foo(value: number) {
return value;
}

foo('');
foo(0);
foo(undefined);
foo(null);
A.foo(null);
B.foo(undefined);
C.foo(0);
D.foo('');

+++ 61.下面关于混淆规则描述正确的是
A.-disable-obfuscation：关闭所有混淆
B.-enable-toplevel-obfuscation：开启属性混淆
C.-enable-property-obfuscation：开启顶层作用域名称混淆
D.-enable-export-obfuscation：开启直接导入或导出的类或对象的名称和属性名混淆

+ 62.在ArkTS中，以下代码片段正确的是（CD）
A.
JavaScript
function fn(x: string | number): void {
console.log('value: ' + x);
}

type funcType = (ns: string | number) => string;
let func: funcType = fn;
B.
JavaScript
function fn(x: string): string {
return x;
}

type funcType = (ns: string | number) => string;
let func: funcType = fn;
C.
JavaScript
function fn(x: string | number): string {
return 'value: ' + x;
}

type funcType = (ns: string) => string;
let func: funcType = fn;
D.
JavaScript
function fn(x: string | number): string {
return 'value: ' + x;
}

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

+++ 63.Code Linter针对ArkTS/TS代码进行最佳实践/编程规范方面的检查，最佳实践/编程规范方面的检查规则可以配置，针对codelinter的配置项一下哪些说法是正确的
A.files：配置待检查的文件名单，如未指定目录，规则适用于所有文件，例如：[“**/*.ets”,”**/*.js”,”**/*.ts”]。B.rules：可以基于ruleSet配置的规则集，新增额外规则项，但是无法修改ruleSet中规则默认配置
C.ignore：配置无需检查的文件目录，其指定的目录或文件需使用相对路径格式，相对于code-linter.json5所在工程根目录，例如：build/**/*。
D.ruleSet：配置检查使用的规则集，规则集支持一次导入多条规则。

+++ 64.下面关于混淆的描述正确的是
A.修改应用混淆配置，新配置需要重新全量编译应用才能生效
B.在工程build-profile.json5中的obfuscation.ruleOptions.files字段中配置该工程的混淆配置，该配置仅在编译该工程时生效。
C.支持顶层作用域名称、属性名称、文件名称等多种混淆功能
D.可以在HAR模块工程的build-profile.json5中的obfuscation.consumerFiles字段中配置导出的混淆配置，该配置仅在编译依赖该HAR的模块时生效。

+++ 65.下面代码符合ArkTS编程规范的是（AD）
A.
TypeScript
const arr = [1, 2, 3];
B.
TypeScript
if(isJedi) {
fight();
}
C.
TypeScript
if (flag) {
//...
}else {
//...
}
D.
TypeScript
function fight(): void {
console.log('Swooosh!');
}

+ 66.在ArkTS中，以下哪些声明类的方式是正确的。
Plaintext
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.C4
C.C2
D.C1

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

A.性能监控：提供详细的UI渲染性能指标，帮助开发者识别布局瓶颈和渲染效率问题，从而优化应用性能
B.交互式组件选择：用户既可以在组件树视图中选择组件，使UI界面上对应组件高亮显示并展示其属性详情；也可以直接在UI布局显示界面上点击选择组件
C.UI效果查看：开发者能够查看连接真机上运行的应用程序的UI显示效果，页面组件树结构，以及选中组件的属性信息
D.UI快照管理：支持导出应用的UI界面为快照图片，并允许这些快照被导入回ArkUI Inspector中，便于离线分析或分享讨论UI设计方案

+++68：在开发过程中，我们可以将每个功能模块作为一个独立的Module进行开发。关于Module，下列选项说法正确的是？
A.entry类型的Module：应用的主模块，包含应用的入口界面、入口图标和主功能特性，编译后生成entry类型的HAP。每一个应用分发到同一类型的设备上的应用程序包，可以包含一个或多个entry类型的HAP。
B.Shared Library：动态共享库。HSP中的代码和资源可以独立编译，运行时在一个进程中代码也只会存在一份。
C.Static Library：静态共享库。HAR中的代码和资源跟随使用方编译，如果有多个使用方，它们的编译产物中会存在多份相同拷贝。
D.feature类型的Module：应用的动态特性模块，编译后生成feature类型的HAP。一个应用中可以包含一个或多个feature类型的HAP，也可以不包含。

————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.csdn.net/2401_84044640/article/details/141137006