ToB企服应用市场:ToB评测及商务社交产业平台

标题: 鸿蒙UI（ArkUI-方舟UI框架）-开辟布局 [打印本页]
作者: 曹旭辉    时间: 2025-1-18 19:24
标题: 鸿蒙UI（ArkUI-方舟UI框架）-开辟布局
开辟布局

1、布局概述

1）布局布局


2）布局元素组成


3）怎样选择布局

声明式UI提供了以下10种常见布局，开辟者可根据实际应用场景选择合适的布局举行页面开辟。
布局应用场景线性布局（Row、Column）如果布局内子元素超过1个时，且可以或许以某种方式线性分列时优先考虑此布局层叠布局（Stack）组件必要有堆叠效果时优先考虑此布局。层叠布局的堆叠效果不会占用或影响其他同容器内子组件的布局空间。比方Panel作为子组件弹出时将其他组件覆盖更为公道，则优先考虑在外层利用堆叠布局。弹性布局（Flex）弹性布局是与线性布局类似的布局方式。区别在于弹性布局默认可以或许使子组件压缩或拉伸。在子组件必要计算拉伸或压缩比例时优先利用此布局，可使得多个容器内子组件能有更好的视觉上的填充效果。相对布局（RelativeContainer）相对布局是在二维空间中的布局方式，不必要依照线性布局的规则，布局方式更为自由。通过在子组件上设置锚点规则（AlignRules）使子组件可以或许将本身在横轴、纵轴中的位置与容器或容器内其他子组件的位置对齐。设置的锚点规则可以自然支持子元素压缩、拉伸、堆叠或形成多行效果。在页面元素分布复杂或通过线性布局会使容器嵌套层数过深时推荐利用。栅格布局（GridRow、GridCol）栅格是多设备场景下通用的辅助定位工具，可将空间分割为有规律的栅格。栅格不同于网格布局固定的空间划分，可以实现不同设备下不同的布局，空间划分更随心所欲，从而显著降低适配不同屏幕尺寸的设计及开辟本钱，使得团体设计和开辟流程更有秩序和节奏感，同时也保证多设备上应用显示的调和性和同等性，提升用户体验。推荐内容相同但布局不同时利用。媒体查询（@ohos.mediaquery）媒体查询可根据不同设备类型或同设备不同状态修改应用的样式。比方根据设备和应用的不同属性信息设计不同的布局，以及屏幕发生动态改变时更新应用的页面布局。列表（List）利用列表可以高效地显示布局化、可滚动的信息。在ArkUI中，列表具有垂直和水平布局能力和自适应交错轴方向上分列个数的布局能力，超出屏幕时可以滚动。列表得当用于呈现同类数据类型或数据类型集，比方图片和文本。网格（Grid）网格布局具有较强的页面均分能力、子元素占比控制能力。网格布局可以控制元素所占的网格数量、设置子元素横跨几行大概几列，当网格容器尺寸发生变化时，所有子元素以及间距等比例调整。推荐在必要按照固定比例大概均匀分配空间的布局场景下利用，比方计算器、相册、日历等。轮播（Swiper）轮播组件通常用于实现广告轮播、图片预览等。选项卡（Tabs）选项卡可以在一个页面内快速实现视图内容的切换，一方面提升查找信息的效率，另一方面精简用户单次获取到的信息量。 4）布局位置

position、offset等属性影响告终构容器相对于自身或其他组件的位置。
定位能力利用场景实现方法绝对定位对于不同尺寸的设备，利用绝对定位的适应性会比较差，在屏幕的适配上有缺陷利用position实现绝对定位，设置元素左上角相对于父容器左上角偏移位置。在布局容器中，设置该属性不影响父容器布局，仅在绘制时举行位置调整。相对定位相对定位不脱离文档流，即原位置依然保留，不影响元素本身的特性，仅相对于原位置举行偏移。利用offset可以实现相对定位，设置元素相对于自身的偏移量。设置该属性，不影响父容器布局，仅在绘制时举行位置调整。 5）对子元素的约束


2、构建布局

1）线性布局 (Row/Column)

概述

  1. 线性布局（LinearLayout）是开发中最常用的布局，通过线性容器Row和Column构建。线性布局是其他布局的基础，其子元素在线性方向上（水平方向和垂直方向）依次排列。线性布局的排列方向由所选容器组件决定，Column容器内子元素按照垂直方向排列，Row容器内子元素按照水平方向排列。根据不同的排列方向，开发者可选择使用Row或Column容器创建线性布局。
复制代码
图1 Column（列，竖着走）容器内子元素分列表示图

图2 Row（行，横着走）容器内子元素分列表示图

布局子元素在分列方向上的间距

在布局容器内，可以通过space属性设置分列方向上子元素的间距，使各子元素在分列方向上有等间距效果。

布局子元素在交错轴上的对齐方式(alignItems)

在布局容器内，可以通过alignItems属性设置子元素在交错轴（分列方向的垂直方向）上的对齐方式。
  1. Column({}) {
  2. }.width('100%').alignItems(HorizontalAlign.Start)
复制代码
其中，交错轴为垂直方向时，取值为VerticalAlign类型，水平方向取值为HorizontalAlign类型。
  1. Column({}) {
  2. }.width('100%').alignItems(VerticalAlign.Start)
复制代码





布局子元素在主轴上的分列方式(justifyContent)

在布局容器内，可以通过justifyContent属性设置子元素在容器主轴上的分列方式。
可以从主轴起始位置开始排布，也可以从主轴竣事位置开始排布，大概均匀分割主轴的空间。
1、Column容器内子元素在垂直方向上的分列






自适应拉伸

在线性布局下，常用空缺填充组件Blank，在容器主轴方向主动填充空缺空间，达到自适应拉伸效果。Row和Column作为容器，只必要添加宽高为百分比，当屏幕宽高发生变化时，会产生自适应效果。
  1. @Entry
  2. @Component
  3. struct BlankExample {
  4.   build() {
  5.     Column() {
  6.       Row() {
  7.         Text('Bluetooth').fontSize(18)
  8.         Blank()
  9.         Toggle({ type: ToggleType.Switch, isOn: true })
  10.       }.backgroundColor(0xFFFFFF).borderRadius(15).padding({ left: 12 }).width('100%')
  11.     }.backgroundColor(0xEFEFEF).padding(20).width('100%')
  12.   }
  13. }
复制代码
竖屏

横屏

自适应缩放

自适应缩放是指子元素随容器尺寸的变化而按照预设的比例主动调整尺寸，适应各种不同巨细的设备。在线性布局中，可以利用以下两种方法实现自适应缩放。

自适应延伸

自适应延伸是指在不同尺寸设备下，当页面的内容超出屏幕巨细而无法完全显示时，可以通过滚动条举行拖动展示。这种方法适用于线性布局中内容无法一屏展示的场景。通常有以下两种实现方式。

2）层叠布局 (Stack)

概述

层叠布局（StackLayout）用于在屏幕上预留一块区域来显示组件中的元素，提供元素可以重叠的布局。层叠布局通过Stack容器组件实现位置的固定定位与层叠，容器中的子元素依次入栈，后一个子元素覆盖前一个子元素，子元素可以叠加，也可以设置位置。
层叠布局具有较强的页面层叠、位置定位能力，其利用场景有广告、卡片层叠效果等。
开辟布局

Stack组件为容器组件，容器内可包含各种子元素。其中子元素默认举行居中堆叠。子元素被约束在Stack下，举行本身的样式定义以及分列。
  1. // xxx.ets
  2. let MTop:Record<string,number> = { 'top': 50 }
  4. @Entry
  5. @Component
  6. struct StackExample {
  7.   build() {
  8.     Column(){
  9.       Stack({ }) {
  10.         Column(){}.width('90%').height('100%').backgroundColor('#ff58b87c')
  11.         Text('text').width('60%').height('60%').backgroundColor('#ffc3f6aa')
  12.         Button('button').width('30%').height('30%').backgroundColor('#ff8ff3eb').fontColor('#000')
  13.       }.width('100%').height(150).margin(MTop)
  14.     }
  15.   }
  16. }
复制代码

对齐方式

Stack组件通过alignContent参数实现位置的相对移动。如图2所示，支持九种对齐方式。

  1. // xxx.ets
  2. @Entry
  3. @Component
  4. struct StackExample {
  5.   build() {
  6.     Stack({ alignContent: Alignment.TopStart }) {
  7.       Text('Stack').width('90%').height('100%').backgroundColor('#e1dede').align(Alignment.BottomEnd)
  8.       Text('Item 1').width('70%').height('80%').backgroundColor(0xd2cab3).align(Alignment.BottomEnd)
  9.       Text('Item 2').width('50%').height('60%').backgroundColor(0xc1cbac).align(Alignment.BottomEnd)
  10.     }.width('100%').height(150).margin({ top: 5 })
  11.   }
  12. }
复制代码
Z序控制

Stack容器中兄弟组件显示层级关系可以通过Z序控制的zIndex属性改变。zIndex值越大，显示层级越高，即zIndex值大的组件会覆盖在zIndex值小的组件上方。
  1. Stack({ alignContent: Alignment.BottomStart }) {
  2.   Column() {
  3.     Text('Stack子元素1').fontSize(20)
  4.   }.width(100).height(100).backgroundColor(0xffd306).zIndex(2)
  6.   Column() {
  7.     Text('Stack子元素2').fontSize(20)
  8.   }.width(150).height(150).backgroundColor(Color.Pink).zIndex(1)
  10.   Column() {
  11.     Text('Stack子元素3').fontSize(20)
  12.   }.width(200).height(200).backgroundColor(Color.Grey)
  13. }.width(350).height(350).backgroundColor(0xe0e0e0)
复制代码

场景实例

利用层叠布局快速搭建页面。
  1. @Entry
  2. @Component
  3. struct StackSample {
  4.   private arr: string[] = ['APP1', 'APP2', 'APP3', 'APP4', 'APP5', 'APP6', 'APP7', 'APP8'];
  6.   build() {
  7.     Stack({ alignContent: Alignment.Bottom }) {
  8.       Flex({ wrap: FlexWrap.Wrap }) {
  9.         ForEach(this.arr, (item:string) => {
  10.           Text(item)
  11.             .width(100)
  12.             .height(100)
  13.             .fontSize(16)
  14.             .margin(10)
  15.             .textAlign(TextAlign.Center)
  16.             .borderRadius(10)
  17.             .backgroundColor(0xFFFFFF)
  18.         }, (item:string):string => item)
  19.       }.width('100%').height('100%')
  21.       Flex({ justifyContent: FlexAlign.SpaceAround, alignItems: ItemAlign.Center }) {
  22.         Text('联系人').fontSize(16)
  23.         Text('设置').fontSize(16)
  24.         Text('短信').fontSize(16)
  25.       }
  26.       .width('50%')
  27.       .height(50)
  28.       .backgroundColor('#16302e2e')
  29.       .margin({ bottom: 15 })
  30.       .borderRadius(15)
  31.     }.width('100%').height('100%').backgroundColor('#CFD0CF')
  32.   }
  33. }
复制代码

3）弹性布局（Flex）

概述

弹性布局（Flex）提供更加有效的方式对容器中的子元素举行分列、对齐和分配剩余空间。常用于页面头部导航栏的均匀分布、页面框架的搭建、多行数据的分列等。
容器默认存在主轴与交错轴，子元素默认沿主轴分列，子元素在主轴方向的尺寸称为主轴尺寸，在交错轴方向的尺寸称为交错轴尺寸。

根本概念


布局方向

在弹性布局中，容器的子元素可以按照任意方向分列。通过设置参数direction，可以决定主轴的方向，从而控制子元素的分列方向。


布局换行

弹性布局分为单行布局和多行布局。默认情况下，Flex容器中的子元素都排在一条线（又称“轴线”）上。wrap属性控制当子元素主轴尺寸之和大于容器主轴尺寸时，Flex是单行布局还是多行布局。在多行布局时，通过交错轴方向，确认新行分列方向。


主轴对齐方式(justifyContent)

通过justifyContent参数设置子元素在主轴方向的对齐方式。

交错轴对齐方式（alignItems）

容器和子元素都可以设置交错轴对齐方式，且子元素设置的对齐方式优先级较高。

  1. let SWh:Record<string,number|string> = { 'width': '90%', 'height': 80 }
  2. Flex({ alignItems: ItemAlign.Stretch }) {  
  3.   Text('1').width('33%').backgroundColor(0xF5DEB3)  
  4.   Text('2').width('33%').backgroundColor(0xD2B48C)  
  5.   Text('3').width('33%').backgroundColor(0xF5DEB3)
  6. }
  7. .size(SWh)
  8. .padding(10)
  9. .backgroundColor(0xAFEEEE)
复制代码


自适应拉伸


4）相对布局 (RelativeContainer)

概述

RelativeContainer为采用相对布局的容器，支持容器内部的子元素设置相对位置关系，适用于界面复杂场景的情况，对多个子组件举行对齐和分列。子元素支持指定兄弟元素作为锚点，也支持指定父容器作为锚点，基于锚点做相对位置布局。下图是一个RelativeContainer的概念图，图中的虚线表示位置的依赖关系。

根本概念


设置依赖关系



多种组件的对其布局

Row、Column、Flex、Stack等多种布局组件，可按照RelativeContainer组件规则举行对齐排布。
  1. @Entry
  2. @Component
  3. struct Index {
  4. @State value: number = 0
  6. build() {
  7.   Row() {
  9.     RelativeContainer() {
  10.       Row()
  11.         .width(100)
  12.         .height(100)
  13.         .backgroundColor('#a3cf62')
  14.         .alignRules({
  15.           top: { anchor: "__container__", align: VerticalAlign.Top },
  16.           left: { anchor: "__container__", align: HorizontalAlign.Start }
  17.         })
  18.         .id("row1")
  20.       Column()
  21.         .width('50%')
  22.         .height(30)
  23.         .backgroundColor('#00ae9d')
  24.         .alignRules({
  25.           top: { anchor: "__container__", align: VerticalAlign.Top },
  26.           left: { anchor: "__container__", align: HorizontalAlign.Center }
  27.         })
  28.         .id("row2")
  30.       Flex({ direction: FlexDirection.Row }) {
  31.         Text('1').width('20%').height(50).backgroundColor('#0a59f7')
  32.         Text('2').width('20%').height(50).backgroundColor('#2ca9e0')
  33.         Text('3').width('20%').height(50).backgroundColor('#0a59f7')
  34.         Text('4').width('20%').height(50).backgroundColor('#2ca9e0')
  35.       }
  36.       .padding(10)
  37.       .backgroundColor('#30c9f7')
  38.       .alignRules({
  39.         top: { anchor: "row2", align: VerticalAlign.Bottom },
  40.         left: { anchor: "__container__", align: HorizontalAlign.Start },
  41.         bottom: { anchor: "__container__", align: VerticalAlign.Center },
  42.         right: { anchor: "row2", align: HorizontalAlign.Center }
  43.       })
  44.       .id("row3")
  46.       Stack({ alignContent: Alignment.Bottom }) {
  47.         Text('First child, show in bottom').width('90%').height('100%').backgroundColor('#a3cf62').align(Alignment.Top)
  48.         Text('Second child, show in top').width('70%').height('60%').backgroundColor('#00ae9d').align(Alignment.Top)
  49.       }
  50.       .margin({ top: 5 })
  51.       .alignRules({
  52.         top: { anchor: "row3", align: VerticalAlign.Bottom },
  53.         left: { anchor: "__container__", align: HorizontalAlign.Start },
  54.         bottom: { anchor: "__container__", align: VerticalAlign.Bottom },
  55.         right: { anchor: "row3", align: HorizontalAlign.End }
  56.       })
  57.       .id("row4")
  59.     }
  60.     .width(300).height(300)
  61.     .margin({ left: 50 })
  62.     .border({ width: 2, color: "#6699FF" })
  63.   }
  64.   .height('100%')
  65. }
  66. }
复制代码

组件尺寸

子组件尺寸巨细不会受到相对布局规则的影响。若子组件某个方向上设置两个或以上alignRules时最好不设置此方向尺寸巨细，否则对齐规则确定的组件尺寸与开辟者设置的尺寸大概产生冲突。
5）栅格布局 (GridRow/GridCol)

概述

栅格布局是一种通用的辅助定位工具，对移动设备的界面设计有较好的借鉴作用。主要优势包罗：
提供可循的规律：栅格布局可以为布局提供规律性的布局，办理多尺寸多设备的动态布局题目。通过将页面划分为等宽的列数和行数，可以方便地对页面元素举行定位和排版。
栅格容器GridRow

1）栅格系统断点
栅格系统以设备的水平宽度（屏幕密度像素值，单元vp）作为断点依据，定义设备的宽度类型，形成了一套断点规则。开辟者可根据需求在不同的断点区间实现不同的页面布局效果。
栅格系统默认断点将设备宽度分为xs、sm、md、lg四类，尺寸范围如下：
断点名称取值范围（vp）设备描述xs[0,320]最小宽度类型设备sm[320,520]小宽度类型设备md[520,840]中等宽度类型设备lg[840,+]大宽度类型设备
比方，利用栅格的默认列数12列，通过断点设置将应用宽度分成六个区间，在各区间中，每个栅格子元素占用的列数均不同:
  1. @State bgColors: ResourceColor[] =
  2.     ['rgb(213,213,213)', 'rgb(150,150,150)', 'rgb(0,74,175)', 'rgb(39,135,217)', 'rgb(61,157,180)', 'rgb(23,169,141)',
  3.       'rgb(255,192,0)', 'rgb(170,10,33)'];
  4. ...
  5. GridRow({
  6.   breakpoints: {
  7.     value: ['200vp', '300vp', '400vp', '500vp', '600vp'],
  8.     reference: BreakpointsReference.WindowSize
  9.   }
  10. }) {
  11.    ForEach(this.bgColors, (color:ResourceColor, index?:number|undefined) => {
  12.      GridCol({
  13.        span: {
  14.          xs: 2, // 在最小宽度类型设备上，栅格子组件占据的栅格容器2列。
  15.          sm: 3, // 在小宽度类型设备上，栅格子组件占据的栅格容器3列。
  16.          md: 4, // 在中等宽度类型设备上，栅格子组件占据的栅格容器4列。
  17.          lg: 6, // 在大宽度类型设备上，栅格子组件占据的栅格容器6列。
  18.          xl: 8, // 在特大宽度类型设备上，栅格子组件占据的栅格容器8列。
  19.          xxl: 12 // 在超大宽度类型设备上，栅格子组件占据的栅格容器12列。
  20.        }
  21.      }) {
  22.        Row() {
  23.          Text(`${index}`)
  24.        }.width("100%").height('50vp')
  25.      }.backgroundColor(color)
  26.    })
  27. }                                                                    
复制代码

2）布局的总列数
GridRow中通过columns设置栅格布局的总列数。

3）分列方向
栅格布局中，可以通过设置GridRow的direction属性来指定栅格子组件在栅格容器中的分列方向。该属性可以设置为GridRowDirection.Row（从左往右分列）或GridRowDirection.RowReverse（从右往左分列），以满足不同的布局需求。通过公道的direction属性设置，可以使得页面布局更加机动和符合设计要求。

4）子组件隔断
GridRow中通过gutter属性设置子元素在水平和垂直方向的间距。
  1. GridRow({ gutter: 10 }){}
复制代码


子组件GridCol

GridCol组件作为GridRow组件的子组件，通过给GridCol传参大概设置属性两种方式，设置span（占用列数），offset（偏移列数），order（元素序号）的值。

1）span
子组件占栅格布局的列数，决定了子组件的宽度，默认为1。

2）offset
栅格子组件相对于前一个子组件的偏移列数，默认为0。

3）order
栅格子组件的序号，决定子组件分列次序。当子组件不设置order大概设置相同的order, 子组件按照代码顺序展示。当子组件设置不同的order时，order较小的组件在前，较大的在后。
当子组件部分设置order，部分不设置order时，未设置order的子组件依次排序靠前，设置了order的子组件按照数值从小到大分列。

栅格组件的嵌套利用

栅格组件也可以嵌套利用，完成一些复杂的布局。
以下示例中，栅格把整个空间分为12份。第一层GridRow嵌套GridCol，分为中心大区域以及“footer”区域。第二层GridRow嵌套GridCol，分为“left”和“right”区域。子组件空间按照上一层父组件的空间划分，粉色的区域是屏幕空间的12列，绿色和蓝色的区域是父组件GridCol的12列，依次举行空间的划分。
  1. @Entry
  2. @Component
  3. struct GridRowExample {
  4.   build() {
  5.     GridRow() {
  6.       GridCol({ span: { sm: 12 } }) {
  7.         GridRow() {
  8.           GridCol({ span: { sm: 2 } }) {
  9.             Row() {
  10.               Text('left').fontSize(24)
  11.             }
  12.             .justifyContent(FlexAlign.Center)
  13.             .height('90%')
  14.           }.backgroundColor('#ff41dbaa')
  16.           GridCol({ span: { sm: 10 } }) {
  17.             Row() {
  18.               Text('right').fontSize(24)
  19.             }
  20.             .justifyContent(FlexAlign.Center)
  21.             .height('90%')
  22.           }.backgroundColor('#ff4168db')
  23.         }
  24.         .backgroundColor('#19000000')
  25.       }
  27.       GridCol({ span: { sm: 12 } }) {
  28.         Row() {
  29.           Text('footer').width('100%').textAlign(TextAlign.Center)
  30.         }.width('100%').height('10%').backgroundColor(Color.Pink)
  31.       }
  32.     }.width('100%').height(300)
  33.   }
  34. }
复制代码

6）媒体查询 (@ohos.mediaquery)

概述

引入和利用流程

媒体查询通过mediaquery模块接口，设置查询条件并绑定回调函数，任一媒体特性改变时，均会触发回调函数，返回匹配结果，根据返回值更改页面布局大概实现业务逻辑，实现页面的相应式设计。具体步调如下：
1）起首导入媒体查询模块：
  1. import { mediaquery } from '@kit.ArkUI';
复制代码
2）通过matchMediaSync接口设置媒体查询条件，保存返回的条件监听句柄listener。比方监听横屏事件：
  1. let listener: mediaquery.MediaQueryListener = this.getUIContext().getMediaQuery().matchMediaSync('(orientation: landscape)');
复制代码
3）给条件监听句柄listener绑定回调函数onPortrait，当listener检测设备状态变化时实行回调函数。在回调函数内，根据不同设备状态更改页面布局大概实现业务逻辑。
  1. onPortrait(mediaQueryResult: mediaquery.MediaQueryResult) {
  2.   if (mediaQueryResult.matches as boolean) {
  3.     // do something here
  4.   } else {
  5.     // do something here
  6.   }
  7. }
  9. listener.on('change', onPortrait);
复制代码
媒体查询条件

媒体查询条件由媒体类型、逻辑操作符、媒体特性组成，其中媒体类型可省略，逻辑操作符用于连接不同媒体类型与媒体特性，其中，媒体特性要利用“()”包裹且可以有多个。
7）创建列表 (List)

概述

列表是一种复杂的容器，当列表项达到肯定命量，内容超过屏幕巨细时，可以主动提供滚动功能。它得当用于呈现同类数据类型或数据类型集，比方图片和文本。在列表中显示数据集合是很多应用程序中的常见要求（如通讯录、音乐列表、购物清单等）。
利用列表可以轻松高效地显示布局化、可滚动的信息。通过在List组件中按垂直大概水平方向线性分列子组件ListItemGroup或ListItem，为列表中的行或列提供单个视图，或利用循环渲染迭代一组行或列，或混合任意数量的单个视图和ForEach布局，构建一个列表。List组件支持利用条件渲染、循环渲染、懒加载等渲染控制方式生成子组件。
布局与约束

列表作为一种容器，会主动按其滚动方向分列子组件，向列表中添加组件或从列表中移除组件会重新分列子组件。
如下图所示，在垂直列表中，List按垂直方向主动分列ListItemGroup或ListItem。
ListItemGroup用于列表数据的分组展示，其子组件也是ListItem。ListItem表示单个列表项，可以包含单个子组件。

1）布局
List除了提供垂直和水平布局能力、超出屏幕时可以滚动的自适应延伸能力之外，还提供了自适应交错轴方向上分列个数的布局能力。
利用垂直布局能力可以构建单列大概多列垂直滚动列表，如下图所示。

利用水平布局能力可以是构建单行或多行水平滚动列表，如下图所示。

2）约束
列表的主轴方向是指子组件列的分列方向，也是列表的滚动方向。垂直于主轴的轴称为交错轴，其方向与主轴方向相互垂直。
如下图所示，垂直列表的主轴是垂直方向，交错轴是水平方向；水平列表的主轴是水平方向，交错轴是垂直方向。

如下图所示，一个垂直列表B没有设置高度时，其父组件A高度为200vp，若其所有子组件C的高度总和为150vp，则此时列表B的高度为150vp。

如下图所示，同样是没有设置高度的垂直列表B，其父组件A高度为200vp，若其所有子组件C的高度总和为300vp，则此时列表B的高度为200vp。

开辟布局

1）设置主轴方向
List组件主轴默认是垂直方向，即默认情况下不必要手动设置List方向，就可以构建一个垂直滚动列表。
若是水平滚动列表场景，将List的listDirection属性设置为Axis.Horizontal即可实现。listDirection默认为Axis.Vertical，即主轴默认是垂直方向。
  1. List() {
  2.   // ...
  3. }
  4. .listDirection(Axis.Horizontal)
复制代码
2）设置交错轴布局
List组件的交错轴布局可以通过lanes和alignListItem属性举行设置。
lanes属性用于确定交错轴分列的列表项数量；
alignListItem用于设置子组件在交错轴方向的对齐方式。

在列表中显示数据

列表视图垂直或水平显示项目集合，在行或列超出屏幕时提供滚动功能，使其得当显示大型数据集合。在最简单的列表形式中，List静态地创建其列表项ListItem的内容。
  1. @Entry
  2. @Component
  3. struct CityList {
  4.   build() {
  5.     List() {
  6.       ListItem() {
  7.         Text('北京').fontSize(24)
  8.       }
  10.       ListItem() {
  11.         Text('杭州').fontSize(24)
  12.       }
  14.       ListItem() {
  15.         Text('上海').fontSize(24)
  16.       }
  17.     }
  18.     .backgroundColor('#FFF1F3F5')
  19.     .alignListItem(ListItemAlign.Center)
  20.   }
  21. }
复制代码

由于在ListItem中只能有一个根节点组件，不支持以平铺形式利用多个组件。因此，若列表项是由多个组件元素组成的，则必要将这多个元素组合到一个容器组件内或组成一个自定义组件。
接洽人列表的列表项中，每个接洽人都有头像和名称。此时，必要将Image和Text封装到一个Row容器内。
  1. List() {
  2.   ListItem() {
  3.     Row() {
  4.       Image($r('app.media.iconE'))
  5.         .width(40)
  6.         .height(40)
  7.         .margin(10)
  9.       Text('小明')
  10.         .fontSize(20)
  11.     }
  12.   }
  14.   ListItem() {
  15.     Row() {
  16.       Image($r('app.media.iconF'))
  17.         .width(40)
  18.         .height(40)
  19.         .margin(10)
  21.       Text('小红')
  22.         .fontSize(20)
  23.     }
  24.   }
  25. }
复制代码

迭代列表内容

应用通过数据集合动态地创建列表。利用循环渲染可从数据源中迭代获取数据，并在每次迭代过程中创建相应的组件，降低代码复杂度。 **比方：** ArkTS通过ForEach提供了组件的循环渲染能力。以简单形式的接洽人列表为例，将接洽人名称和头像数据以Contact类布局存储到contacts数组，利用ForEach中嵌套ListItem的形式来代替多个平铺的、内容相似的ListItem，从而淘汰重复代码。
  1. import { util } from '@kit.ArkTS'
  3. class Contact {
  4.   key: string = util.generateRandomUUID(true);
  5.   name: string;
  6.   icon: Resource;
  8.   constructor(name: string, icon: Resource) {
  9.     this.name = name;
  10.     this.icon = icon;
  11.   }
  12. }
  14. @Entry
  15. @Component
  16. struct SimpleContacts {
  17.   private contacts: Array<object> = [
  18.     new Contact('小明', $r("app.media.iconA")),
  19.     new Contact('小红', $r("app.media.iconB")),
  20.   ]
  22.   build() {
  23.     List() {
  24.       ForEach(this.contacts, (item: Contact) => {
  25.         ListItem() {
  26.           Row() {
  27.             Image(item.icon)
  28.               .width(40)
  29.               .height(40)
  30.               .margin(10)
  31.             Text(item.name).fontSize(20)
  32.           }
  33.           .width('100%')
  34.           .justifyContent(FlexAlign.Start)
  35.         }
  36.       }, (item: Contact) => JSON.stringify(item))
  37.     }
  38.     .width('100%')
  39.   }
  40. }
复制代码
在List组件中，ForEach除了可以用来循环渲染ListItem，也可以用来循环渲染ListItemGroup。ListItemGroup的循环渲染详细利用请参见支持分组列表。
自定义列表样式

1）设置内容间距
在初始化列表时，如需在列表项之间添加间距，可以利用space参数。比方，在每个列表项之间沿主轴方向添加10vp的间距：
  1. List({ space: 10 }) {
  2.   // ...
  3. }
复制代码
2）添加分割线
分隔线用来将界面元素隔开，使单个元素更加轻易辨认。如下图所示，当列表项左边有图标（如蓝牙图标），由于图标本身就能很好的区分，此时分隔线从图标之后开始显示即可。

List提供了divider属性用于给列表项之间添加分隔线。在设置divider属性时，可以通过strokeWidth和color属性设置分隔线的粗细和颜色。
startMargin和endMargin属性分别用于设置分隔线距离列表侧边起始端的距离和距离列表侧边竣事端的距离。
  1. class DividerTmp {
  2.   strokeWidth: Length = 1
  3.   startMargin: Length = 60
  4.   endMargin: Length = 10
  5.   color: ResourceColor = '#ffe9f0f0'
  7.   constructor(strokeWidth: Length, startMargin: Length, endMargin: Length, color: ResourceColor) {
  8.     this.strokeWidth = strokeWidth
  9.     this.startMargin = startMargin
  10.     this.endMargin = endMargin
  11.     this.color = color
  12.   }
  13. }
  14. @Entry
  15. @Component
  16. struct EgDivider {
  17.   @State egDivider: DividerTmp = new DividerTmp(1, 60, 10, '#ffe9f0f0')
  18.   build() {
  19.     List() {
  20.       // ...
  21.     }
  22.     .divider(this.egDivider)
  23.   }
  24. }
复制代码
此示例表示从距离列表侧边起始端60vp开始到距离竣事端10vp的位置，画一条粗细为1vp的分割线，可以实现上图设置列表分隔线的样式。
3）添加滚动条
当列表项高度（宽度）超出屏幕高度（宽度）时，列表可以沿垂直（水平)方向滚动。在页面内容很多时，若用户需快速定位，可拖拽滚动条，如下图所示。

在利用List组件时，可通过scrollBar属性控制列表滚动条的显示。scrollBar的取值类型为BarState，当取值为BarState.Auto表示按需显示滚动条。此时，当触摸到滚动条区域时显示控件，可上下拖拽滚动条快速浏览内容，拖拽时会变粗。若不举行任何操作，2秒后滚动条主动消散。
4）支持分组列表
在列表中支持数据的分组展示，可以使列表显示布局清晰，查找方便，从而进步利用效率。分组列表在实际应用中十分常见，如下图所示接洽人列表。

在List组件中可以直接利用一个大概多个ListItemGroup组件，ListItemGroup的宽度默认充满List组件。在初始化ListItemGroup时，可通过header参数设置列表分组的头部组件。
  1. @Entry
  2. @Component
  3. struct ContactsList {
  4.   
  5.   @Builder itemHead(text: string) {
  6.     // 列表分组的头部组件，对应联系人分组A、B等位置的组件
  7.     Text(text)
  8.       .fontSize(20)
  9.       .backgroundColor('#fff1f3f5')
  10.       .width('100%')
  11.       .padding(5)
  12.   }
  14.   build() {
  15.     List() {
  16.       ListItemGroup({ header: this.itemHead('A') }) {
  17.         // 循环渲染分组A的ListItem
  18.       }
  20.       ListItemGroup({ header: this.itemHead('B') }) {
  21.         // 循环渲染分组B的ListItem
  22.       }
  23.     }
  24.   }
  25. }
复制代码
如果多个ListItemGroup布局类似，可以将多个分组的数据组成数组，然后利用ForEach对多个分组举行循环渲染。比方在接洽人列表中，将每个分组的接洽人数据contacts（可参考迭代列表内容章节）和对应分组的标题title数据举行组合，定义为数组contactsGroups。然后在ForEach中对contactsGroups举行循环渲染，即可实现多个分组的接洽人列表。可参考添加粘性标题章节示例代码。
5）添加粘性标题
粘性标题是一种常见的标题模式，常用于定位字母列表的头部元素。如下图所示，在接洽人列表中滚动A部分时，B部分开始的头部元素始终处于A的下方。而在开始滚动B部分时，B的头部会固定在屏幕顶部，直到所有B的项均完成滚动后，才被后面的头部替代。
粘性标题不仅有助于阐明列表中数据的表示形式和用途，还可以帮助用户在大量信息中举行数据定位，从而避免用户在标题所在的表的顶部与感兴趣区域之间反复滚动。

List组件的sticky属性配合ListItemGroup组件利用，用于设置ListItemGroup中的头部组件是否呈现吸顶效果大概尾部组件是否呈现吸底效果。
通过给List组件设置sticky属性为StickyStyle.Header，即可实现列表的粘性标题效果。如果必要支持吸底效果，可以通过footer参数初始化ListItemGroup的底部组件，并将sticky属性设置为StickyStyle.Footer。
  1. import { util } from '@kit.ArkTS'
  2. class Contact {
  3.   key: string = util.generateRandomUUID(true);
  4.   name: string;
  5.   icon: Resource;
  7.   constructor(name: string, icon: Resource) {
  8.     this.name = name;
  9.     this.icon = icon;
  10.   }
  11. }
  12. class ContactsGroup {
  13.   title: string = ''
  14.   contacts: Array<object> | null = null
  15.   key: string = ""
  16. }
  17. export let contactsGroups: object[] = [
  18.   {
  19.     title: 'A',
  20.     contacts: [
  21.       new Contact('艾佳', $r('app.media.iconA')),
  22.       new Contact('安安', $r('app.media.iconB')),
  23.       new Contact('Angela', $r('app.media.iconC')),
  24.     ],
  25.     key: util.generateRandomUUID(true)
  26.   } as ContactsGroup,
  27.   {
  28.     title: 'B',
  29.     contacts: [
  30.       new Contact('白叶', $r('app.media.iconD')),
  31.       new Contact('伯明', $r('app.media.iconE')),
  32.     ],
  33.     key: util.generateRandomUUID(true)
  34.   } as ContactsGroup,
  35.   // ...
  36. ]
  37. @Entry
  38. @Component
  39. struct ContactsList {
  40.   // 定义分组联系人数据集合contactsGroups数组
  41.   @Builder itemHead(text: string) {
  42.     // 列表分组的头部组件，对应联系人分组A、B等位置的组件
  43.     Text(text)
  44.       .fontSize(20)
  45.       .backgroundColor('#fff1f3f5')
  46.       .width('100%')
  47.       .padding(5)
  48.   }
  49.   build() {
  50.     List() {
  51.       // 循环渲染ListItemGroup，contactsGroups为多个分组联系人contacts和标题title的数据集合
  52.       ForEach(contactsGroups, (itemGroup: ContactsGroup) => {
  53.         ListItemGroup({ header: this.itemHead(itemGroup.title) }) {
  54.           // 循环渲染ListItem
  55.           if (itemGroup.contacts) {
  56.             ForEach(itemGroup.contacts, (item: Contact) => {
  57.               ListItem() {
  58.                 // ...
  59.               }
  60.             }, (item: Contact) => JSON.stringify(item))
  61.           }
  62.         }
  63.       }, (itemGroup: ContactsGroup) => JSON.stringify(itemGroup))
  64.     }.sticky(StickyStyle.Header)  // 设置吸顶，实现粘性标题效果
  65.   }
  66. }
复制代码
6）控制滚动位置
控制滚动位置在实际应用中十分常见，比方当消息页列表项数量庞大，用户滚动列表到肯定位置时，希望快速滚动到列表底部或返回列表顶部。此时，可以通过控制滚动位置来实现列表的快速定位，如下图所示。

List组件初始化时，可以通过scroller参数绑定一个Scroller对象，举行列表的滚动控制。比方，用户在消息应用中，点击消息页面底部的返回顶部按钮时，就可以通过Scroller对象的scrollToIndex方法使列表滚动到指定的列表项索引位置。
起首，必要创建一个Scroller的对象listScroller。
  1. private listScroller: Scroller = new Scroller();
复制代码
然后，通过将listScroller用于初始化List组件的scroller参数，完成listScroller与列表的绑定。在必要跳转的位置指定scrollToIndex的参数为0，表示返回列表顶部。
  1. Stack({ alignContent: Alignment.Bottom }) {
  2.   // 将listScroller用于初始化List组件的scroller参数，完成listScroller与列表的绑定。
  3.   List({ space: 20, scroller: this.listScroller }) {
  4.     // ...
  5.   }
  7.   Button() {
  8.     // ...
  9.   }
  10.   .onClick(() => {
  11.     // 点击按钮时，指定跳转位置，返回列表顶部
  12.     this.listScroller.scrollToIndex(0)
  13.   })
  14. }
复制代码
7）相应滚动位置
很多应用必要监听列表的滚动位置变化并作出相应。比方，在接洽人列表滚动时，如果跨越了不同字母开头的分组，则侧边字母索引栏也必要更新到对应的字母位置。
除了字母索引之外，滚动列表团结多级分类索引在应用开辟过程中也很常见，比方购物应用的商品分类页面，多级分类也必要监听列表的滚动位置。

如上图所示，当接洽人列表从A滚动到B时，右侧索引栏也必要同步从选中A状态变成选中B状态。此场景可以通过监听List组件的onScrollIndex事件来实现，右侧索引栏必要利用字母表索引组件AlphabetIndexer。
在列表滚动时，根据列表此时所在的索引值位置firstIndex，重新计算字母索引栏对应字母的位置selectedIndex。由于AlphabetIndexer组件通过selected属性设置了选中项索引值，当selectedIndex变化时会触发AlphabetIndexer组件重新渲染，从而显示为选中对应字母的状态。
  1. const alphabets = ['#', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',  'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];@Entry@Componentstruct ContactsList {  @State selectedIndex: number = 0;  private listScroller: Scroller = new Scroller();
  2.   build() {    Stack({ alignContent: Alignment.End }) {      List({ scroller: this.listScroller }) {}      .onScrollIndex((firstIndex: number) => {        // 根据列表滚动到的索引值，重新计算对应接洽人索引栏的位置this.selectedIndex      })      // 字母表索引组件      AlphabetIndexer({ arrayValue: alphabets, selected: 0 })        .selected(this.selectedIndex)    }  }}
复制代码
说明
计算索引值时，ListItemGroup作为一个团体占一个索引值，不计算ListItemGroup内部ListItem的索引值。
8）相应列表项侧滑
侧滑菜单在很多应用中都很常见。比方，通讯类应用通常会给消息列表提供侧滑删除功能，即用户可以通过向左侧滑列表的某一项，再点击删除按钮删除消息，如下图所示。其中，列表项头像右上角标记设置参考给列表项添加标记。

ListItem的swipeAction属性可用于实现列表项的左右滑动功能。swipeAction属性方法初始化时有必填参数SwipeActionOptions，其中，start参数表示设置列表项右滑时起始端滑出的组件，end参数表示设置列表项左滑时尾端滑出的组件。
在消息列表中，end参数表示设置ListItem左滑时尾端划出自定义组件，即删除按钮。在初始化end方法时，将滑动列表项的索引传入删除按钮组件，当用户点击删除按钮时，可以根据索引值来删除列表项对应的数据，从而实现侧滑删除功能。
9）给列表项添加标记
添加标记是一种无干扰性且直观的方法，用于显示通知或将注意力会合到应用内的某个区域。比方，当消息列表吸收到新消息时，通常对应的接洽人头像的右上方会出现标记，提示有若干条未读消息，如下图所示。

在ListItem中利用Badge组件可实现给列表项添加标记功能。Badge是可以附加在单个组件上用于信息标记的容器组件。
在消息列表中，若希望在接洽人头像右上角添加标记，可在实现消息列表项ListItem的接洽人头像时，将头像Image组件作为Badge的子组件。
在Badge组件中，count和position参数用于设置必要展示的消息数量和提示点显示位置，还可以通过style参数机动设置标记的样式。
  1. ListItem() {
  2.   Badge({
  3.     count: 1,
  4.     position: BadgePosition.RightTop,
  5.     style: { badgeSize: 16, badgeColor: '#FA2A2D' }
  6.   }) {
  7.     // Image组件实现消息联系人头像
  8.     // ...
  9.   }
  10. }
复制代码
10）下拉刷新与上拉刷新
页面的下拉刷新与上拉加载功能在移动应用中十分常见，比方，消息页面的内容刷新和加载。这两种操作的原理都是通过相应用户的触摸事件，在顶部大概底部显示一个刷新或加载视图，完成后再将此视图隐蔽。
以下拉刷新为例，实在现主要分成三步：
下拉刷新与上拉加载的具体实现可参考消息数据加载。
11）编辑列表
列表的编辑模式用途十分广泛，常见于待服务项管理、文件管理、备忘录的记载管理等应用场景。在列表的编辑模式下，新增和删除列表项是最底子的功能，其核心是对列表项对应的数据集合举行数据添加和删除。
12）长列表的处理
循环渲染适用于短列表，当构建具有大量列表项的长列表时，如果直接采用循环渲染方式，会一次性加载所有的列表元素，会导致页面启动时间过长，影响用户体验。因此，推荐利用数据懒加载（LazyForEach）方式实现按需迭代加载数据，从而提升列表性能。
当利用懒加载方式渲染列表时，为了更好的列表滚动体验，淘汰列表滑动时出现白块，List组件提供了cachedCount参数用于设置列表项缓存数，只在懒加载LazyForEach中生效。
  1. List() {
  2.   // ...
  3. }.cachedCount(3)
复制代码
以垂直列表为例：

13）示范代码

创建网格 (Grid/GridItem)

概述

网格布局是由“行”和“列”分割的单元格所组成，通过指定“项目”所在的单元格做出各种各样的布局。网格布局具有较强的页面均分能力，子组件占比控制能力，是一种紧张自适应布局，其利用场景有九宫格图片展示、日历、计算器等。
约束与布局

Grid组件为网格容器，其中容器内各条目对应一个GridItem组件，如下图所示。

   说明
Grid的子组件必须是GridItem组件。
  网格布局是一种二维布局。Grid组件支持自定义行列数和每行每列尺寸占比、设置子组件横跨几行大概几列，同时提供了垂直和水平布局能力。当网格容器组件尺寸发生变化时，所有子组件以及间距会等比例调整，从而实现网格布局的自适应能力。根据Grid的这些布局能力，可以构建出不同样式的网格布局，如下图所示。

如果Grid组件设置了宽高属性，则其尺寸为设置值。如果没有设置宽高属性，Grid组件的尺寸默认适应其父组件的尺寸。
Grid组件根据行列数量与占比属性的设置，可以分为三种布局情况：

设置分列方式

设置行列数量与占比

通过设置行列数量与尺寸占比可以确定网格布局的团体分列方式。Grid组件提供了rowsTemplate和columnsTemplate属性用于设置网格布局行列数量与尺寸占比。
rowsTemplate和columnsTemplate属性值是一个由多个空格和’数字+fr’隔断拼接的字符串，fr的个数即网格布局的行或列数，fr前面的数值巨细，用于计算该行或列在网格布局宽度上的占比，终极决定该行或列宽度。

如上图所示，构建的是一个三行三列的网格布局，其在垂直方向上分为三等份，每行占一份；在水平方向上分为四等份，第一列占一份，第二列占两份，第三列占一份。
只要将rowsTemplate的值为’1fr 1fr 1fr’，同时将columnsTemplate的值为’1fr 2fr 1fr’，即可实现上述网格布局。
  1. Grid() {
  2.   ...
  3. }
  4. .rowsTemplate('1fr 1fr 1fr')
  5. .columnsTemplate('1fr 2fr 1fr')
复制代码
  说明
当Grid组件设置了rowsTemplate或columnsTemplate时，Grid的layoutDirection、maxCount、minCount、cellLength属性不生效，属性说明可参考Grid-属性。
  设置子组件所占行列数

除了巨细相同的等比例网格布局，由不同巨细的网格组成不均匀分布的网格布局场景在实际应用中十分常见，如下图所示。在Grid组件中，可以通过创建Grid时传入合适的GridLayoutOptions实现如图所示的单个网格横跨多行或多列的场景，其中，irregularIndexes和onGetIrregularSizeByIndex可对仅设置rowsTemplate或columnsTemplate的Grid利用；onGetRectByIndex可对同时设置rowsTemplate和columnsTemplate的Grid利用。

比方： 计算器的按键布局就是常见的不均匀网格布局场景。如下图，计算器中的按键“0”和“=”，按键“0”横跨第一、二两列，按键“=”横跨第五、六两行。利用Grid构建的网格布局，其行列标号从0开始，依次编号。

在网格中，可以通过onGetRectByIndex返回的**[rowStart,columnStart,rowSpan,columnSpan]**来实现跨行跨列布局，其中rowStart和columnStart属性表示指定当前元素起始行号和起始列号，rowSpan和columnSpan属性表示指定当前元素的占用行数和占用列数。
所以“0”按键横跨第一列和第二列，“=”按键横跨第五行和第六行，只要将
“0”对应onGetRectByIndex的rowStart和columnStart设为5和0，rowSpan和columnSpan设为1和2，将
“=”对应onGetRectByIndex的rowStart和columnStart设为4和3，rowSpan和columnSpan设为2和1即可。
  1. layoutOptions: GridLayoutOptions = {
  2.   regularSize: [1, 1],
  3.   onGetRectByIndex: (index: number) => {
  4.     if (index == key1) { // key1是“0”按键对应的index
  5.       return [5, 0, 1, 2]
  6.     } else if (index == key2) { // key2是“=”按键对应的index
  7.       return [4, 3, 2, 1]
  8.     }
  9.     // ...
  10.     // 这里需要根据具体布局返回其他item的位置
  11.   }
  12. }
  14. Grid(undefined, this.layoutOptions) {
  15.   // ...
  16. }
  17. .columnsTemplate('1fr 1fr 1fr 1fr')
  18. .rowsTemplate('2fr 1fr 1fr 1fr 1fr 1fr')
复制代码
设置主轴方向

利用Grid构建网格布局时，若没有设置行列数量与占比，可以通过layoutDirection设置网格布局的主轴方向，决定子组件的分列方式。此时可以团结minCount和maxCount属性来约束主轴方向上的网格数量。

当前layoutDirection设置为Row时，先从左到右分列，排满一行再排下一行。当前layoutDirection设置为Column时，先从上到下分列，排满一列再排下一列，如上图所示。此时，将maxCount属性设为3，表示主轴方向上最大显示的网格单元数量为3。
  1. Grid() {
  2.   ...
  3. }
  4. .maxCount(3)
  5. .layoutDirection(GridDirection.Row)
复制代码
  说明
layoutDirection属性仅在不设置rowsTemplate和columnsTemplate时生效，此时元素在layoutDirection方向上分列。
仅设置rowsTemplate时，Grid主轴为水平方向，交错轴为垂直方向。
仅设置columnsTemplate时，Grid主轴为垂直方向，交错轴为水平方向。
  在网格布局中显示数据

网格布局采用二维布局的方式组织其内部元素，如下图所示。

  1. Grid() {
  2.   GridItem() {
  3.     Text('会议')
  4.       ...
  5.   }
  7.   GridItem() {
  8.     Text('签到')
  9.       ...
  10.   }
  12.   GridItem() {
  13.     Text('投票')
  14.       ...
  15.   }
  17.   GridItem() {
  18.     Text('打印')
  19.       ...
  20.   }
  21. }
  22. .rowsTemplate('1fr 1fr')
  23. .columnsTemplate('1fr 1fr')
复制代码
对于内容布局相似的多个GridItem，通常更推荐利用ForEach语句中嵌套GridItem的形式，来淘汰重复代码。
  1. @Entry
  2. @Component
  3. struct OfficeService {
  4.   @State services: Array<string> = ['会议', '投票', '签到', '打印']
  6.   build() {
  7.     Column() {
  8.       Grid() {
  9.         ForEach(this.services, (service:string) => {
  10.           GridItem() {
  11.             Text(service)
  12.           }
  13.         }, (service:string):string => service)
  14.       }
  15.       .rowsTemplate(('1fr 1fr') as string)
  16.       .columnsTemplate(('1fr 1fr') as string)
  17.     }
  18.   }
  19. }
复制代码
设置行列间距

在两个网格单元之间的网格横向间距称为行间距，网格纵向间距称为列间距，如下图所示。

通过Grid的rowsGap和columnsGap可以设置网格布局的行列间距。在图5所示的计算器中，行间距为15vp，列间距为10vp。
  1. Grid() {
  2.   ...
  3. }
  4. .columnsGap(10)
  5. .rowsGap(15)
复制代码
构建可滚动的网格布局

可滚动的网格布局常用在文件管理、购物或视频列表等页面中，如下图所示。在设置Grid的行列数量与占比时，如果仅设置行、列数量与占比中的一个，即仅设置rowsTemplate或仅设置columnsTemplate属性，网格单元按照设置的方向分列，超出Grid显示区域后，Grid拥有可滚动能力。

如果设置的是columnsTemplate，Grid的滚动方向为垂直方向；如果设置的是rowsTemplate，Grid的滚动方向为水平方向。
如上图所示的横向可滚动网格布局，只要设置rowsTemplate属性的值且不设置columnsTemplate属性，当内容超出Grid组件宽度时，Grid可横向滚动举行内容展示。
  1. @Entry
  2. @Component
  3. struct Shopping {
  4.   @State services: Array<string> = ['直播', '进口']
  6.   build() {
  7.     Column({ space: 5 }) {
  8.       Grid() {
  9.         ForEach(this.services, (service: string, index) => {
  10.           GridItem() {
  11.           }
  12.           .width('25%')
  13.         }, (service:string):string => service)
  14.       }
  15.       .rowsTemplate('1fr 1fr') // 只设置rowsTemplate属性，当内容超出Grid区域时，可水平滚动。
  16.       .rowsGap(15)
  17.     }
  18.   }
  19. }
复制代码
控制滚动位置

与消息列表的返回顶部场景类似，控制滚动位置功能在网格布局中也很常用，比方下图所示日历的翻页功能。

Grid组件初始化时，可以绑定一个Scroller对象，用于举行滚动控制，比方通过Scroller对象的scrollPage方法举行翻页。
  1. private scroller: Scroller = new Scroller()
复制代码
在日历页面中，用户在点击“下一页”按钮时，应用相应点击事件，通过指定scrollPage方法的参数next为true，滚动到下一页。
  1. Column({ space: 5 }) {
  2.   Grid(this.scroller) {
  3.   }
  4.   .columnsTemplate('1fr 1fr 1fr 1fr 1fr 1fr 1fr')
  6.   Row({space: 20}) {
  7.     Button('上一页')
  8.       .onClick(() => {
  9.         this.scroller.scrollPage({
  10.           next: false
  11.         })
  12.       })
  14.     Button('下一页')
  15.       .onClick(() => {
  16.         this.scroller.scrollPage({
  17.           next: true
  18.         })
  19.       })
  20.   }
  21. }
复制代码
性能优化

与长列表的处理类似，循环渲染适用于数据量较小的布局场景，当构建具有大量网格项的可滚动网格布局时，推荐利用数据懒加载方式实现按需迭代加载数据，从而提升列表性能。
  1. Grid() {
  2.   LazyForEach(this.dataSource, () => {
  3.     GridItem() {
  4.     }
  5.   })
  6. }
  7. .cachedCount(3)
复制代码
创建轮播 (Swiper)

Swiper组件提供滑动轮播显示的能力。Swiper本身是一个容器组件，当设置了多个子组件后，可以对这些子组件举行轮播显示。通常，在一些应用首页显示推荐的内容时，必要用到轮播显示的能力。
布局与约束

Swiper作为一个容器组件，如果设置了自身尺寸属性，则在轮播显示过程中均以该尺寸生效。如果自身尺寸属性未被设置，则分两种情况：如果设置了prevMargin大概nextMargin属性，则Swiper自身尺寸会跟随其父组件；如果未设置prevMargin大概nextMargin属性，则会主动根据子组件的巨细设置自身的尺寸。
循环播放

通过loop属性控制是否循环播放，该属性默认值为true。
当loop为true时，在显示第一页或最后一页时，可以继承往前切换到前一页大概往后切换到后一页。如果loop为false，则在第一页或最后一页时，无法继承向前大概向后切换页面。

主动轮播

Swiper通过设置autoPlay属性，控制是否主动轮播子组件。该属性默认值为false。
autoPlay为true时，会主动切换播放子组件，子组件与子组件之间的播放隔断通过interval属性设置。interval属性默认值为3000，单元毫秒。
  1. Swiper() {
  2.   // ...
  3. }
  4. .loop(true)
  5. .autoPlay(true)
  6. .interval(1000)
复制代码

导航点样式

Swiper提供了默认的导航点样式和导航点箭头样式，导航点默认显示在Swiper下方居中位置，开辟者也可以通过indicator属性自定义导航点的位置和样式，导航点箭头默认不显示。
通过indicator属性，开辟者可以设置导航点相对于Swiper组件上下左右四个方位的位置，同时也可以设置每个导航点的尺寸、颜色、蒙层和被选中导航点的颜色。

Swiper通过设置displayArrow属性，可以控制导航点箭头的巨细、位置、颜色，底板的巨细及颜色，以及鼠标悬停时是否显示箭头。

页面切换方式

Swiper支持手指滑动、点击导航点和通过控制器三种方式切换页面，以下示例展示通过控制器切换页面的方法。
  1. @Entry
  2. @Component
  3. struct SwiperDemo {
  4.   private swiperController: SwiperController = new SwiperController();
  6.   build() {
  7.     Column({ space: 5 }) {
  8.       Swiper(this.swiperController) {
  9.         Text('0')
  10.           .width(250)
  11.           .height(250)
  12.           .backgroundColor(Color.Gray)
  13.           .textAlign(TextAlign.Center)
  14.           .fontSize(30)
  15.         Text('1')
  16.           .width(250)
  17.           .height(250)
  18.           .backgroundColor(Color.Green)
  19.           .textAlign(TextAlign.Center)
  20.           .fontSize(30)
  21.         Text('2')
  22.           .width(250)
  23.           .height(250)
  24.           .backgroundColor(Color.Pink)
  25.           .textAlign(TextAlign.Center)
  26.           .fontSize(30)
  27.       }
  28.       .indicator(true)
  30.       Row({ space: 12 }) {
  31.         Button('showNext')
  32.           .onClick(() => {
  33.             this.swiperController.showNext(); // 通过controller切换到后一页
  34.           })
  35.         Button('showPrevious')
  36.           .onClick(() => {
  37.             this.swiperController.showPrevious(); // 通过controller切换到前一页
  38.           })
  39.       }.margin(5)
  40.     }.width('100%')
  41.     .margin({ top: 5 })
  42.   }
  43. }
复制代码

轮播方向

Swiper支持水平和垂直方向上举行轮播，主要通过vertical属性控制。
当vertical为true时，表示在垂直方向上举行轮播；为false时，表示在水平方向上举行轮播。vertical默认值为false。

  1. Swiper() {
  2.   // ...
  3. }
  4. .indicator(true)
  5. .vertical(false)
复制代码


  1. Swiper() {
  2.   // ...
  3. }
  4. .indicator(true)
  5. .vertical(true)
复制代码

每页显示多个子页面

Swiper支持在一个页面内同时显示多个子组件，通过displayCount属性设置。
  1. Swiper() {
  2.   Text('0')
  3.     .width(250)
  4.     .height(250)
  5.     .backgroundColor(Color.Gray)
  6.     .textAlign(TextAlign.Center)
  7.     .fontSize(30)
  8.   Text('1')
  9.     .width(250)
  10.     .height(250)
  11.     .backgroundColor(Color.Green)
  12.     .textAlign(TextAlign.Center)
  13.     .fontSize(30)
  14.   Text('2')
  15.     .width(250)
  16.     .height(250)
  17.     .backgroundColor(Color.Pink)
  18.     .textAlign(TextAlign.Center)
  19.     .fontSize(30)
  20.   Text('3')
  21.     .width(250)
  22.     .height(250)
  23.     .backgroundColor(Color.Blue)
  24.     .textAlign(TextAlign.Center)
  25.     .fontSize(30)
  26. }
  27. .indicator(true)
  28. .displayCount(2)
复制代码

自定义切换动画

Swiper支持通过customContentTransition设置自定义切换动画，可以在回调中对视窗内所有页面逐帧设置透明度、缩放比例、位移、渲染层级等属性实现自定义切换动画。
  1. @Entry
  2. @Component
  3. struct SwiperCustomAnimationExample {
  4.   private DISPLAY_COUNT: number = 2
  5.   private MIN_SCALE: number = 0.75
  7.   @State backgroundColors: Color[] = [Color.Green, Color.Blue, Color.Yellow, Color.Pink, Color.Gray, Color.Orange]
  8.   @State opacityList: number[] = []
  9.   @State scaleList: number[] = []
  10.   @State translateList: number[] = []
  11.   @State zIndexList: number[] = []
  13.   aboutToAppear(): void {
  14.     for (let i = 0; i < this.backgroundColors.length; i++) {
  15.       this.opacityList.push(1.0)
  16.       this.scaleList.push(1.0)
  17.       this.translateList.push(0.0)
  18.       this.zIndexList.push(0)
  19.     }
  20.   }
  22.   build() {
  23.     Column() {
  24.       Swiper() {
  25.         ForEach(this.backgroundColors, (backgroundColor: Color, index: number) => {
  26.           Text(index.toString()).width('100%').height('100%').fontSize(50).textAlign(TextAlign.Center)
  27.             .backgroundColor(backgroundColor)
  28.             .opacity(this.opacityList[index])
  29.             .scale({ x: this.scaleList[index], y: this.scaleList[index] })
  30.             .translate({ x: this.translateList[index] })
  31.             .zIndex(this.zIndexList[index])
  32.         })
  33.       }
  34.       .height(300)
  35.       .indicator(false)
  36.       .displayCount(this.DISPLAY_COUNT, true)
  37.       .customContentTransition({
  38.         timeout: 1000,
  39.         transition: (proxy: SwiperContentTransitionProxy) => {
  40.           if (proxy.position <= proxy.index % this.DISPLAY_COUNT || proxy.position >= this.DISPLAY_COUNT + proxy.index % this.DISPLAY_COUNT) {
  41.             // 同组页面完全滑出视窗外时，重置属性值
  42.             this.opacityList[proxy.index] = 1.0
  43.             this.scaleList[proxy.index] = 1.0
  44.             this.translateList[proxy.index] = 0.0
  45.             this.zIndexList[proxy.index] = 0
  46.           } else {
  47.             // 同组页面未滑出视窗外时，对同组中左右两个页面，逐帧根据position修改属性值
  48.             if (proxy.index % this.DISPLAY_COUNT === 0) {
  49.               this.opacityList[proxy.index] = 1 - proxy.position / this.DISPLAY_COUNT
  50.               this.scaleList[proxy.index] = this.MIN_SCALE + (1 - this.MIN_SCALE) * (1 - proxy.position / this.DISPLAY_COUNT)
  51.               this.translateList[proxy.index] = - proxy.position * proxy.mainAxisLength + (1 - this.scaleList[proxy.index]) * proxy.mainAxisLength / 2.0
  52.             } else {
  53.               this.opacityList[proxy.index] = 1 - (proxy.position - 1) / this.DISPLAY_COUNT
  54.               this.scaleList[proxy.index] = this.MIN_SCALE + (1 - this.MIN_SCALE) * (1 - (proxy.position - 1) / this.DISPLAY_COUNT)
  55.               this.translateList[proxy.index] = - (proxy.position - 1) * proxy.mainAxisLength - (1 - this.scaleList[proxy.index]) * proxy.mainAxisLength / 2.0
  56.             }
  57.             this.zIndexList[proxy.index] = -1
  58.           }
  59.         }
  60.       })
  61.     }.width('100%')
  62.   }
  63. }
复制代码

示例代码

短视频切换
选项卡 (Tabs)

当页面信息较多时，为了让用户可以或许聚焦于当前显示的内容，必要对页面内容举行分类，进步页面空间利用率。Tabs组件可以在一个页面内快速实现视图内容的切换，一方面提升查找信息的效率，另一方面精简用户单次获取到的信息量。
根本布局

Tabs组件的页面组成包含两个部分，分别是TabContent和TabBar。TabContent是内容页，TabBar是导航页签栏，页面布局如下图所示，根据不同的导航类型，布局会有区别，可以分为底部导航、顶部导航、侧边导航，其导航栏分别位于底部、顶部和侧边。

   说明
TabContent组件不支持设置通用宽度属性，其宽度默认撑满Tabs父组件。
TabContent组件不支持设置通用高度属性，其高度由Tabs父组件高度与TabBar组件高度决定。
  每一个TabContent对应的内容必要有一个页签，可以通过TabContent的tabBar属性举行配置。在如下TabContent组件上设置tabBar属性，可以设置其对应页签中的内容，tabBar作为内容的页签。
  1. TabContent() {
  2.    Text('首页的内容').fontSize(30)
  3. }
  4. .tabBar('首页')
复制代码
设置多个内容时，需在Tabs内按照顺序放置。
  1. Tabs() {
  2.   TabContent() {
  3.     Text('首页的内容').fontSize(30)
  4.   }
  5.   .tabBar('首页')
  7.   TabContent() {
  8.     Text('推荐的内容').fontSize(30)
  9.   }
  10.   .tabBar('推荐')
  12.   TabContent() {
  13.     Text('发现的内容').fontSize(30)
  14.   }
  15.   .tabBar('发现')
  16.   
  17.   TabContent() {
  18.     Text('我的内容').fontSize(30)
  19.   }
  20.   .tabBar("我的")
  21. }
复制代码
底部导航

底部导航是应用中最常见的一种导航方式。底部导航位于应用一级页面的底部，用户打开应用，可以或许分清整个应用的功能分类，以及页签对应的内容，而且其位于底部更加方便用户单手操作。底部导航一般作为应用的主导航形式存在，其作用是将用户关心的内容按照功能举行分类，迎合用户利用风俗，方便在不同模块间的内容切换。

导航栏位置利用Tabs的barPosition参数举行设置。默认情况下，导航栏位于顶部，此时，barPosition为BarPosition.Start。设置为底部导航时，必要将barPosition设置为BarPosition.End。
  1. Tabs({ barPosition: BarPosition.End }) {
  2.   // TabContent的内容：首页、发现、推荐、我的
  3.   ...
  4. }
复制代码
顶部导航

当内容分类较多，用户对不同内容的浏览概率相差不大，必要经常快速切换时，一般采用顶部导航模式举行设计，作为对底部导航内容的进一步划分，常见一些资讯类应用对内容的分类为关注、视频、数码，大概主题应用中对主题举行进一步划分为图片、视频、字体等。

  1. Tabs({ barPosition: BarPosition.Start }) {
  2.   // TabContent的内容:关注、视频、游戏、数码、科技、体育、影视
  3.   ...
  4. }
复制代码
侧边导航

侧边导航是应用较为少见的一种导航模式，更多适用于横屏界面，用于对应用举行导航操作，由于用户的视觉风俗是从左到右，侧边导航栏默认为左侧侧边栏。

实现侧边导航栏必要将Tabs的vertical属性设置为true，vertical默认值为false，表明内容页和导航栏垂直方向分列。
  1. Tabs({ barPosition: BarPosition.Start }) {
  2.   // TabContent的内容:首页、发现、推荐、我的
  3.   ...
  4. }
  5. .vertical(true)
  6. .barWidth(100)
  7. .barHeight(200)
复制代码
  说明
vertical为false时，tabbar的宽度默认为撑满屏幕的宽度，必要设置barWidth为合适值。
vertical为true时，tabbar的高度默认为实际内容的高度，必要设置barHeight为合适值。
  限制导航栏的滑动切换

默认情况下，导航栏都支持滑动切换，在一些内容信息量必要举行多级分类的页面，如支持底部导航+顶部导航组合的情况下，底部导航栏的滑动效果与顶部导航出现冲突，此时必要限制底部导航的滑动，避免引起不好的用户体验。

控制滑动切换的属性为scrollable，默认值为true，表示可以滑动，若要限制滑动切换页签则必要设置为false。
  1. Tabs({ barPosition: BarPosition.End }) {
  2.   TabContent(){
  3.     Column(){
  4.       Tabs(){
  5.         // 顶部导航栏内容
  6.         ...
  7.       }
  8.     }
  9.     .backgroundColor('#ff08a8f1')
  10.     .width('100%')
  11.   }
  12.   .tabBar('首页')
  14.   // 其他TabContent内容：发现、推荐、我的
  15.   ...
  16. }
  17. .scrollable(false)
复制代码
固定导航栏

当内容分类较为固定且不具有拓展性时，比方底部导航内容分类一般固定，分类数量一般在3-5个，此时利用固定导航栏。固定导航栏不可滚动，无法被拖拽滚动，内容均分tabBar的宽度。
Tabs的barMode属性用于控制导航栏是否可以滚动，默认值为BarMode.Fixed。
  1. Tabs({ barPosition: BarPosition.End }) {
  2.   // TabContent的内容：首页、发现、推荐、我的
  3.   ...
  4. }
  5. .barMode(BarMode.Fixed)
复制代码
滚动导航栏

滚动导航栏必要设置Tabs组件的barMode属性，默认值为BarMode.Fixed表示为固定导航栏，BarMode.Scrollable表示可滚动导航栏。
  1. Tabs({ barPosition: BarPosition.Start }) {
  2.   // TabContent的内容：关注、视频、游戏、数码、科技、体育、影视、人文、艺术、自然、军事
  3.   ...
  4. }
  5. .barMode(BarMode.Scrollable)
复制代码
自定义导航栏

对于底部导航栏，一般作为应用主页面功能区分，为了更好的用户体验，会组合文字以及对应语义图标表示页签内容，这种情况下，必要自定义导航页签的样式。

设置自定义导航栏必要利用tabBar的参数，以其支持的CustomBuilder的方式传入自定义的函数组件样式。比方这里声明tabBuilder的自定义函数组件，传入参数包罗页签文字title，对应位置index，以及选中状态和未选中状态的图片资源。通过当前活泼的currentIndex和页签对应的targetIndex匹配与否，决定UI显示的样式。
  1. @Builder tabBuilder(title: string, targetIndex: number, selectedImg: Resource, normalImg: Resource) {
  2.   Column() {
  3.     Image(this.currentIndex === targetIndex ? selectedImg : normalImg)
  4.       .size({ width: 25, height: 25 })
  5.     Text(title)
  6.       .fontColor(this.currentIndex === targetIndex ? '#1698CE' : '#6B6B6B')
  7.   }
  8.   .width('100%')
  9.   .height(50)
  10.   .justifyContent(FlexAlign.Center)
  11. }
复制代码
在TabContent对应tabBar属性中传入自定义函数组件，并传递相应的参数。
  1. TabContent() {
  2.   Column(){
  3.     Text('我的内容')  
  4.   }
  5.   .width('100%')
  6.   .height('100%')
  7.   .backgroundColor('#007DFF')
  8. }
  9. .tabBar(this.tabBuilder('我的', 0, $r('app.media.mine_selected'), $r('app.media.mine_normal')))
复制代码
切换至指定页签

在不利用自定义导航栏时，默认的Tabs会实现切换逻辑。在利用了自定义导航栏后，默认的Tabs仅实现滑动内容页和点击页签时内容页的切换逻辑，页签切换逻辑必要自行实现。即用户滑动内容页和点击页签时，页签栏必要同步切换至内容页对应的页签。
内容页和页签不联动

此时必要利用Tabs提供的onChange事件方法，监听索引index的变化，并将当前活泼的index值传递给currentIndex，实现页签的切换。
  1. @Entry
  2. @Component
  3. struct TabsExample1 {
  4.   @State currentIndex: number = 2
  6.   @Builder tabBuilder(title: string, targetIndex: number) {
  7.     Column() {
  8.       Text(title)
  9.         .fontColor(this.currentIndex === targetIndex ? '#1698CE' : '#6B6B6B')
  10.     }
  11.   }
  13.   build() {
  14.     Column() {
  15.       Tabs({ barPosition: BarPosition.End }) {
  16.         TabContent() {
  17.           ...
  18.         }.tabBar(this.tabBuilder('首页', 0))
  20.         TabContent() {
  21.           ...
  22.         }.tabBar(this.tabBuilder('发现', 1))
  24.         TabContent() {
  25.           ...
  26.         }.tabBar(this.tabBuilder('推荐', 2))
  28.         TabContent() {
  29.           ...
  30.         }.tabBar(this.tabBuilder('我的', 3))
  31.       }
  32.       .animationDuration(0)
  33.       .backgroundColor('#F1F3F5')
  34.       .onChange((index: number) => {
  35.         this.currentIndex = index
  36.       })
  37.     }.width('100%')
  38.   }
  39. }
复制代码
开辟应用沉浸式效果

概述

典型应用全屏窗口UI元素包罗状态栏、应用界面和底部导航条，其中状态栏和导航条，通常在沉浸式布局下称为避让区；避让区之外的区域称为安全区。开辟应用沉浸式效果主要指通过调整状态栏、应用界面和导航条的显示效果来淘汰状态栏导航条等系统界面的突兀感，从而利用户获得最佳的UI体验。

开辟应用沉浸式效果主要要考虑如下几个设计要素：

针对上面的设计要求，可以通过如下两种方式实现应用沉浸式效果：

窗口全屏布局方案

窗口全屏布局方案主要涉及以下应用扩展布局，全屏显示，不隐蔽避让区和应用扩展布局，隐蔽避让区两个应用场景。
应用扩展布局，全屏显示，不隐蔽避让区

可以通过调用窗口强制全屏布局接口setWindowLayoutFullScreen() 实现界面元素延伸到状态栏和导航条；然后通过接口getWindowAvoidArea()和on(‘avoidAreaChange’) 获取并动态监听避让区域的变更信息，页面布局根据避让区域信息举行动态调整；设置状态栏或导航条的颜色等属性与界面元素举行匹配。
应用扩展布局，隐蔽避让区

组件安全区方案


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4