小惠珠哦

这个屌丝很懒，什么也没留下！

热门标签

HarmonyOS应用开发者高级认证，Next版本发布后最新题库 - 多选题序号1_下面关于方舟字节码指令含义说明正确的是

作者：小惠珠哦 | 2024-08-14 02:09:50

踩

下面关于方舟字节码指令含义说明正确的是

基础认证题库请移步：HarmonyOS应用开发者基础认证题库

注：有读者反馈，题库的代码块比较多，打开文章时会卡死。所以笔者将题库拆分，以20道题为一组，题库目录如下，读者可以按需跳转。如果对您的阅读产生不便，笔者在这里向大家说声抱歉，请各位读者原谅。该题库已整理完毕，笔者不再更新。笔者连续考了三次，都过了，所以答案应该没什么太大问题。有需要题库文档的可以自取。祝各位读者好运(๑¯ω¯๑)。如果各位读者有什么内推的工作机会，也可以悄悄告诉笔者，笔者不胜受恩感激

序号目录：

题库文档链接（自取）：https://pan.baidu.com/s/153tDk4dVv_MmLEyzOqW9hQ?pwd=xkgr

注：题目是乱序，每次考试，选项的顺序都不同

多选题题库 - 序号1

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

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

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

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

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

应用程序包概述-应用程序包基础知识-开发基础知识-基础入门 | 华为开发者联盟 (huawei.com)

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

A、hap

B、app

C、hsp

D、har

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

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

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

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

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

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

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

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

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

F、手工配置管理：

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

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

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

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

4、以下代码片段哪几处违反了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!';
1
2
3
4
5
6
7
8
9
10
11
12
13

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

B、delete p.x;

C、p.z = 2.0;

D、p.x = 'Hello!';

5、以下napi代码有问题的是（不确定，把所有选项列出）

//	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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

//	B
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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

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

            napi_value callback = nullptr;
            napi_get_reference_value(context->env, context->callbackRef, &callback);
            napi_value retArg;
            napi_create_int32(context->env, context->retData, &retArg);
            napi_value ret;
            napi_call_function(context->env, nullptr, callback, 1, &retArg, &ret);
            napi_delete_reference(context->env, context->callbackRef);
            if (work != nullptr) {
                delete work;
            }
            delete context;
        }
    );
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

//	D
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

A、A

B、B

C、C

D、D

6、下面关于混淆的描述正确的是

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

B、针对工程源码的混淆可以降低工程被破解攻击的风险，缩短函数名、类名和属性名，减小应用的大小。

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

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

代码混淆-ArkTS（方舟编程语言）-应用框架 | 华为开发者联盟 (huawei.com)

代码混淆-加固构建-编译构建-DevEco Studio | 华为开发者联盟 (huawei.com)

7、下面关于方舟字节码指令含义说明正确的是（不确定，把所有选项列出）

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用法，正确的是

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线程实例间传输实现方式描述正确的是（不确定，把所有选项列出）

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

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

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

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

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

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;
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

A、foo1

B、foo2

C、foo3

D、foo4

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

class C {

  value1: number = 0;

  value2?: number = null;

  value3: number | undefined = undefined;

  value4?: number;
  
}
1
2
3
4
5
6
7
8
9
10
11

A、value1

B、value2

C、value3

D、value4

12、如下ABC 3处手势，有机会执行的是哪几处?（不确定，把所有选项列出）

@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)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

A、NA

B、A

C、B

D、C

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

// 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)
    }.width('100%').height(250).padding({ left: 35, right: 35, top: 35 })
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// B
@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 })
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

// 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 })
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// D
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

A、A

B、B

C、C

D、D

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

@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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

A、A

B、B

C、C

D、D

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

在这里插入图片描述

//	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)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

//	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%')
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

//	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 })
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

A、A === Grid

B、B === WaterFlow

C、C === List

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

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

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

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

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

代码Code Linter检查-代码检查-代码编辑-DevEco Studio | 华为开发者联盟 (huawei.com)

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

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

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

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

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

应用程序包概述-应用程序包基础知识-开发基础知识-基础入门 | 华为开发者联盟 (huawei.com)

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

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

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

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

D、一次上架多端部署。

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

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));
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// A
{
	"name": "TargetAbility",
	"skills": [
		{
            "actions": [
            	"ohos.want.action.vieData",
            ],
            "entities": [
                "entity.system.browsable",
            ],
            "uris": [
                {
                    "scheme": "http",
                    "host": "www.test.com",
                    "port": "8080",
                    "path": "path"
                }			
            ]
    	}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//	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
                }			
            ]
    	}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//	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
                }			
            ]
    	}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//	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
                }			
            ]
    	}
	]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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"
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

A、StartupTask_005会在主线程执行

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

C、StartupTask_001会在StartupTask_004之后执行；

D、StartupTask_003会在StartupTask_004之后执行

应用启动框架AppStartup-Stage模型应用组件-Stage模型开发指导-Ability Kit（程序框架服务）-应用框架 | 华为开发者联盟 (huawei.com)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小惠珠哦/article/detail/977509