文档开发者中心
我的
|

ArkUI (方舟UI框架)

HarmonyOS中Button在折叠屏展开后如何避免文字换行错位?

在折叠屏从折叠态切换到展开态后,Button里的文字会出现换行或错位,尤其是长文案和图标按钮。我尝试过固定宽度、弹性布局和文本截断,但都难以兼顾不同屏幕形态。请问有什么布局或自适应方案能避免文字换行错位?

点赞
收藏
回复
6
分享
举报
浏览16 发布于1小时前广西
全部评论
最多点赞
最新发布
最早发布

你好,折叠屏展开后 Button 文字换行/错位,核心思路是:不要用固定宽度,让 Button 宽度自适应,再对文本做自适应字号 + 单行控制,最后用断点区分不同形态。

关键做法:

  1. Button 宽度用 auto 或约束最大/最小宽度(constraintSize({ minWidth, maxWidth })),不要写死 width(180) 这类固定值
  2. 长文案建议用 Button 包含 Text 子组件的方式,对 Text 设置 minFontSize / maxFontSize + maxLines(1) + heightAdaptivePolicy(TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST),让文本在可用空间内先缩字号再截断,而不是换行
  3. 图标按钮建议 Button() 内放 Row { Image(); Text() },用固定间距和图标尺寸,文字用自适应策略,避免外层 Row 因宽度变化挤压图标
  4. 如果展开/折叠是结构性布局差异(比如按钮组横竖排列变化、按钮数量显示策略变化),用断点(sm/md/lg)或 GridRow 做响应式布局,而不是在单个 Button 上试图兼容所有形态
收起
自动换行
深色代码主题
复制
@Entry
@ComponentV2
struct AdaptiveButtonDemo {
  @Local label: string = '这是一段较长的按钮文字内容';

  build() {
    Row({ space: 12 }) {
      Button() {
        Text(this.label)
          .maxLines(1)
          .textOverflow({ overflow: TextOverflow.Ellipsis })
          .minFontSize(12)
          .maxFontSize(18)
          .heightAdaptivePolicy(TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST)
      }
      .type(ButtonType.Capsule)
      .constraintSize({ minWidth: 96, maxWidth: 220 })
      .padding({ left: 16, right: 16 })

      Button() {
        Row({ space: 8 }) {
          Image($r('app.media.icon_add'))
            .width(18)
            .height(18)
            .objectFit(ImageFit.Contain)
          Text('添加')
            .maxLines(1)
            .minFontSize(12)
            .maxFontSize(18)
            .heightAdaptivePolicy(TextHeightAdaptivePolicy.LAYOUT_CONSTRAINT_FIRST)
        }
      }
      .type(ButtonType.Capsule)
      .constraintSize({ minWidth: 80, maxWidth: 180 })
      .padding({ left: 12, right: 12 })
    }
  }
}

官方文档参考:

 
展开全部
2楼回复于55分钟前 来自湖南
固定宽度就是根因,去掉它。方案一句话:按钮宽度随内容自适应 + 文本强制单行截断兜底 + 断点响应式布局,三层叠加即可,你试过的固定宽度、弹性拉伸恰好都是反例。
原因
折叠展开后窗口宽度变化,按钮若设了固定 width 或让文字区参与弹性拉伸,文字可用宽度被压缩/重排,必然换行错位。正确姿势是按钮本体宽度始终由内容决定,超长靠省略号截断,形态差异交给外层栅格处理。
代码
收起
自动换行
深色代码主题
复制
import { display } from '@kit.ArkUI'
import { Callback } from '@kit.BasicServicesKit'

@Component
struct IconTextButton {
  @Prop label: string = ''
    @Prop icon: Resource = $r('sys.media.ohos_ic_public_voice')
      @Prop textMaxWidth: number = 120
        onButtonClick: () => void = () => {}

          build() {
              Button() { // 带子组件时不能再传 label 参数,否则编译报错
                    Flex({ alignItems: ItemAlign.Center }) {
                            Image(this.icon).width(16).height(16)
                                    Text(this.label)
                                              .margin({ left: 6 })
                                                        .fontSize(14)
                                                                  .maxLines(1) // 强制单行,杜绝换行
                                                                            .textOverflow({ overflow: TextOverflow.Ellipsis })
                                                                                      .constraintSize({ maxWidth: this.textMaxWidth })
                                                                                            }
                                                                                                  .padding({ left: 16, right: 16 })
                                                                                                        .height(40)
                                                                                                            }
                                                                                                                .width('auto') // 关键:宽度随内容自适应,不设固定值
                                                                                                                    .constraintSize({ maxWidth: '100%' }) // 不超出父容器
                                                                                                                        .onClick(() => this.onButtonClick())
                                                                                                                          }
                                                                                                                          }

                                                                                                                          @Entry
                                                                                                                          @Component
                                                                                                                          struct FoldableButtonPage {
                                                                                                                            @State textMaxWidth: number = 120
                                                                                                                              // 回调必须对象传递,匿名函数反复注册会内存泄漏
                                                                                                                                private foldCallback: Callback<display.FoldStatus> = (status: display.FoldStatus) => {
                                                                                                                                    // 展开态放宽文本上限,折叠态收紧
                                                                                                                                        this.textMaxWidth = status === display.FoldStatus.FOLD_STATUS_EXPANDED ? 200 : 120
                                                                                                                                          }

                                                                                                                                            aboutToAppear(): void {
                                                                                                                                                // 先取当前状态,再注册监听
                                                                                                                                                    this.textMaxWidth =
                                                                                                                                                          display.getFoldStatus() === display.FoldStatus.FOLD_STATUS_EXPANDED ? 200 : 120
                                                                                                                                                              display.on('foldStatusChange', this.foldCallback)
                                                                                                                                                                }

                                                                                                                                                                  aboutToDisappear(): void {
                                                                                                                                                                      display.off('foldStatusChange', this.foldCallback)
                                                                                                                                                                        }

                                                                                                                                                                          build() {
                                                                                                                                                                              Column({ space: 12 }) {
                                                                                                                                                                                    // 断点响应式:折叠态(xs/sm)占整行,展开态(md/lg)占半行
                                                                                                                                                                                          GridRow({
                                                                                                                                                                                                  columns: 2,
                                                                                                                                                                                                          gutter: { x: 12 },
                                                                                                                                                                                                                  breakpoints: { value: ['400vp', '600vp', '800vp'], reference: BreakpointsReference.WindowSize }
                                                                                                                                                                                                                        }) {
                                                                                                                                                                                                                                GridCol({ span: { xs: 2, sm: 2, md: 1, lg: 1 } }) {
                                                                                                                                                                                                                                          IconTextButton({ label: '短文案按钮' })
                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                          GridCol({ span: { xs: 2, sm: 2, md: 1, lg: 1 } }) {
                                                                                                                                                                                                                                                                    IconTextButton({
                                                                                                                                                                                                                                                                                label: '这是一个非常长的按钮文案用于验证截断效果',
                                                                                                                                                                                                                                                                                            textMaxWidth: this.textMaxWidth
                                                                                                                                                                                                                                                                                                      })
                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                          .width('100%')
                                                                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                                                                                  .padding(16)
                                                                                                                                                                                                                                                                                                                                      .width('100%')
                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                        

坑点

Button 带子组件时不能再传 label 参数,否则编译报错 10905202。

foldStatusChange 回调必须用对象传递并在 aboutToDisappear 中 off 同一对象,匿名函数注册会内存泄漏

foldStatusChange 监听的是物理折叠状态;要区分内容显示在内屏还是外屏,用 display.on('foldDisplayModeChange')

展开态不要拉伸按钮本身,按钮尺寸保持不变、间距横向变宽即可,否则文字重排问题会回来。

展开全部
6楼回复于19分钟前 来自陕西

折叠屏展开后 Button 文字换行错位,根因是按钮宽度用固定值,展开后可用空间变了但按钮没跟着变,文字要么换行要么溢出。解决思路就两个:让按钮宽度自适应容器 + 让文字在按钮内自适应字号和截断。

1. 用 labelStyle 做字号自适应 + 超长截断

Button 从 API 10 开始支持 labelStyle,可以设置 minFontSize / maxFontSize / maxLines / overflow,文字会先在字号范围内缩放,缩到最小还放不下再截断。这是最直接的方案,不用监听断点。

收起
自动换行
深色代码主题
复制
Button('确认提交订单')
  .constraintSize({ minWidth: 120, maxWidth: '80%' })
  .labelStyle({
    overflow: TextOverflow.Ellipsis,
    maxLines: 1,
    minFontSize: 12,
    maxFontSize: 16
  })

constraintSize 比 width 固定值更合适——给了弹性范围,折叠态窄屏不会撑爆,展开态宽屏能自动变宽。labelStyle 的 minFontSize 必须 > 0 才生效,需要配合 maxFontSize 和 maxLines 一起用。

相关文档:Button、Button组件无法设置字体最大最小值

2. 图标+文字按钮用子组件方式

带图标的 Button,用 Button(){ Row(){ Image() + Text() } } 的子组件写法,比纯 label 更灵活。Text 组件本身支持 minFontSize / maxFontSize / textOverflow,可以单独控制文字行为,图标不受影响。

收起
自动换行
深色代码主题
复制
Button() {
  Row({ space: 4 }) {
    Image($r('app.media.ic_share')).width(16).height(16)
    Text('分享给好友一起看')
      .maxFontSize(16)
      .minFontSize(12)
      .maxLines(1)
      .textOverflow({ overflow: TextOverflow.Ellipsis })
      .constraintSize({ maxWidth: 120 })
  }
}
.constraintSize({ minWidth: 80, maxWidth: '60%' })

3. 响应式断点动态调整样式

如果不同屏幕形态下按钮需要差异化表现(比如展开态显示完整文案、折叠态显示短文案或仅图标),用断点监听。官方断点定义:sm < 600vp、md [600, 840)、lg >= 840vp,折叠屏展开态通常落入 md 或 lg。

收起
自动换行
深色代码主题
复制
import { window } from '@kit.ArkUI'

@Entry
@Component
struct FoldableButtonPage {
  @State currentBp: string = 'sm'

  aboutToAppear(): void {
    const win = window.findWindow('MainWindow')
    const updateBp = (w: number): void => {
      this.currentBp = w < 600 ? 'sm' : (w < 840 ? 'md' : 'lg')
    }
    updateBp(win.getWindowProperties().windowRect.width)
    win.on('windowSizeChange', (size: window.Size) => { updateBp(size.width) })
  }

  build() {
    Column() {
      if (this.currentBp === 'sm') {
        Button('提交')
          .labelStyle({ overflow: TextOverflow.Ellipsis, maxLines: 1, minFontSize: 12, maxFontSize: 14 })
      } else {
        Button('确认提交当前订单')
          .labelStyle({ overflow: TextOverflow.Ellipsis, maxLines: 1, minFontSize: 14, maxFontSize: 18 })
      }
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

相关文档:响应式布局-断点、自适应布局

完整最小 Demo

收起
自动换行
深色代码主题
复制
@Entry
@Component
struct FoldableButtonDemo {
  build() {
    Scroll() {
      Column({ space: 20 }) {
        Text('方案1: labelStyle字号自适应').fontSize(14).fontColor('#999')

        Button('确认提交当前选中订单信息')
          .constraintSize({ minWidth: 120, maxWidth: '80%' })
          .labelStyle({
            overflow: TextOverflow.Ellipsis,
            maxLines: 1,
            minFontSize: 12,
            maxFontSize: 16
          })

        Text('方案2: 图标+文字子组件').fontSize(14).fontColor('#999')

        Button() {
          Row({ space: 6 }) {
            Image($r('sys.symbol.Share')).width(16).height(16).fillColor(Color.White)
            Text('分享给好友一起查看详情')
              .maxFontSize(16)
              .minFontSize(12)
              .maxLines(1)
              .textOverflow({ overflow: TextOverflow.Ellipsis })
              .constraintSize({ maxWidth: 140 })
              .fontColor(Color.White)
          }
        }
        .constraintSize({ minWidth: 80, maxWidth: '60%' })

        Text('方案3: 占比布局').fontSize(14).fontColor('#999')

        Row({ space: 12 }) {
          Button('取消')
            .layoutWeight(1)
            .labelStyle({ overflow: TextOverflow.Ellipsis, maxLines: 1, minFontSize: 12, maxFontSize: 14 })
          Button('确认提交')
            .layoutWeight(1)
            .labelStyle({ overflow: TextOverflow.Ellipsis, maxLines: 1, minFontSize: 12, maxFontSize: 14 })
        }
        .width('90%')
      }
      .width('100%')
      .padding(24)
    }
    .width('100%')
    .height('100%')
  }
}

核心就三点:别用固定 width、用 constraintSize 给弹性范围、用 labelStyle 或 Text 的 minFontSize/maxFontSize 让字号自动适配。固定宽度是折叠屏适配最常见的坑,换成占比(layoutWeight)或约束尺寸基本能解决大部分场景。断点监听是锦上添花,不同形态下展示不同文案时才需要。

展开全部
5楼回复于50分钟前 来自四川
补充一个现有断点示例中的逻辑问题:

if (vpWidth >= 600) { bp = 'md' }
else if (vpWidth >= 840) { bp = 'lg' }

第二个分支永远到不了,因为 840 以上已被第一个条件接走。应先判断 >=840,再判断 >=600;否则你以为展开后进入了 lg 布局,实际一直是 md。这里的 600/840 只是该示例的阈值,不应等同于所有折叠屏的物理形态。

另外建议先把按钮分成两类核对:

• Button('文案'):用 Button 的 labelStyle 管理内部 label,官方 maxLines 默认就是 1,不能笼统认定所有 Button 默认都会多行换行。它的 minFontSize/maxFontSize 需要结合行数或布局约束生效。
• Button() { Row { Image; Text } }:实际文字是你自己放入的 Text,需要在这个 Text 上管理行数、字号和可分配宽度,不能只给外层 labelStyle 期待它约束所有子组件。

针对图标按钮,可用这个宽度账本排查:文字可用宽度 = 按钮实际内容宽度 − 左右内边距 − 图标宽度 − 图文间距。先记录折叠、展开、分屏时按钮与内部 Row 的实际尺寸;如果文字拿到的约束仍是旧值,应先修正父布局/缓存尺寸,而不是反复调截断属性。仅设置一个固定 maxWidth,也不保证多个按钮之和能装进父容器。

按钮组变窄时可整组改为纵排或减少同排数量;如果选择两行文案,就允许按钮高度随内容变化,不要同时固定为只够一行的高度。大字模式下也建议优先给布局空间,再决定可接受的字号下限,不能靠无限缩字换取不换行。

最后用最长中英文文案、系统大字、展开/收起连续切换和分屏拖动一起验证,观察按钮高度、图标中心与文本边界。尚无最小复现时,无法把问题直接归因于折叠屏或 Button 的某个系统缺陷。

官方依据:Button 的 labelStyle 和 LabelStyle 对象说明(maxLines 默认 1、字号自适应的配合条件):
https://developer.huawei.com/consumer/cn/doc/harmonyos-references/ts-basic-components-button/
以上为代码逻辑核对及排查建议,未在你的工程运行。
展开全部
4楼回复于52分钟前 来自湖北

根因是 Button 宽度在屏幕形态切换时没有正确适配——折叠态下按钮刚好够放文字,展开后容器变宽但内部布局没跟上,导致文字换行或错位。解决思路就两条:限制文字不换行 + 让按钮宽度响应屏幕变化。

方案一:labelStyle 控制文字单行 + 字号自适应

Button 的 labelStyle 属性支持 maxLines、overflow、minFontSize、maxFontSize,可以让文字在单行内自动缩放,缩到最小仍放不下才截断。这是最直接的方案。

收起
自动换行
深色代码主题
复制
Button('确认提交订单')
  .width('80%')
  .labelStyle({
    overflow: TextOverflow.Ellipsis,
    maxLines: 1,
    minFontSize: 12,
    maxFontSize: 16,
    font: { size: 16, weight: FontWeight.Medium }
  })

方案二:监听断点,不同屏幕形态用不同宽度

用 windowSizeChange 监听窗口变化,按断点给 Button 不同宽度百分比,展开态给更大空间:

收起
自动换行
深色代码主题
复制
import { display, window } from '@kit.ArkUI';

@Entry
@Component
struct FoldButtonPage {
  @StorageLink('breakPoint') breakPoint: string = 'sm';

  build() {
    Column() {
      Button('确认提交订单')
        .width(this.breakPoint === 'sm' ? '70%' : '50%')
        .labelStyle({
          overflow: TextOverflow.Ellipsis,
          maxLines: 1,
          minFontSize: 12,
          maxFontSize: 16,
          font: { size: 16, weight: FontWeight.Medium }
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

EntryAbility 里设断点:

收起
自动换行
深色代码主题
复制
import { display, window } from '@kit.ArkUI';

onWindowStageCreate(windowStage: window.WindowStage): void {
  windowStage.getMainWindow().then((win: window.Window) => {
    this.updateBreakpoint(win.getWindowProperties().windowRect.width);
    win.on('windowSizeChange', (size: window.Size) => {
      this.updateBreakpoint(size.width);
    });
  });
  windowStage.loadContent('pages/Index');
}

private updateBreakpoint(windowWidth: number): void {
  let vpWidth: number = windowWidth / display.getDefaultDisplaySync().densityPixels;
  let bp: string = 'sm';
  if (vpWidth >= 600) {
    bp = 'md';
  } else if (vpWidth >= 840) {
    bp = 'lg';
  }
  AppStorage.setOrCreate('breakPoint', bp);
}

方案三:图标+文字按钮,用容器模式构建

带图标的 Button 如果用 Button(label) 形式,文字一换行图标也跟着错位。改用容器模式,图标和文字放 Row 里,文字用 constraintSize 约束最大宽度:

收起
自动换行
深色代码主题
复制
Button() {
  Row({ space: 6 }) {
    Image($r('sys.media.ohos_ic_public_download'))
      .width(16)
      .height(16)
    Text('下载附件并保存到本地')
      .fontSize(14)
      .maxLines(1)
      .textOverflow({ overflow: TextOverflow.Ellipsis })
      .constraintSize({ maxWidth: 160 })
  }
}
.type(ButtonType.Capsule)

三种方案可以叠加使用:labelStyle 保底不换行,断点控制宽度适配,容器模式处理图标场景。固定宽度确实不行——折叠屏两种状态屏幕差一倍,写死宽度必然有一个状态会出问题。

展开全部
3楼回复于54分钟前 来自四川
AI 生成内容,仅供参考

折叠屏展开后 Button 文字换行错位,根本原因在于折叠态与展开态之间窗口宽度发生了量级跳变(折叠态通常处于 sm 断点 320–600vp,展开态往往直接跨入 md/lg 断点),而固定宽度、写死的布局约束没有第二套规则兜底。Button 内部的文本默认是允许自动换行的,当父容器约束的宽度小于文本实际宽度时就会折行;一旦折行,按钮高度随之变化,图标与文字的相对位置就会错位。因此正确的思路是:让按钮宽度由内容自适应、对文本强制单行并截断、再结合断点在不同屏幕形态下切换按钮的展示形态(如折叠态仅显示图标、展开态显示图标加文字)。

解决思路

  1. 按钮本体使用 width('auto') 让宽度跟随内容,同时用 constraintSize({ maxWidth }) 限制上限,超长时配合 maxLines(1) 与 textOverflow({ overflow: TextOverflow.Ellipsis }) 单行截断,杜绝换行。
  2. 布局变化由窗口宽度断点驱动,而不是监听折叠状态。官方明确不建议用折叠状态监听接口做响应式布局,因为分屏、旋转、自由窗口等场景下折叠状态不变但窗口尺寸已变化;推荐通过媒体查询或断点 API 感知窗口宽度变化。
  3. 图标按钮内部用 Flex(width('auto'))组织图标与文本,保证图标固定、文本自适应,避免错位。

示例代码

以下代码适用于 API version 12 及以上版本:

收起
自动换行
深色代码主题
复制
// AdaptiveButton.ets
import { mediaquery } from '@kit.ArkUI';

@Component
struct AdaptiveButton {
  @Prop label: string = '';
  @Prop icon: Resource = $r('sys.media.ohos_ic_public_voice');
  // 是否处于展开态(窗口宽度 >= 600vp,即进入 md/lg 断点)
  @State isExpanded: boolean = false;
  private mediaQueryListener?: mediaquery.MediaQueryListener;

  aboutToAppear(): void {
    // 折叠态对应 sm 断点(320-600vp),展开态通常进入 md/lg 断点
    // 以 600vp 为分界,通过媒体查询感知窗口宽度变化(覆盖折叠开合、分屏、旋转等场景)
    this.mediaQueryListener = this.getUIContext().getMediaQuery()
      .matchMediaSync('(min-width: 600vp)');
    this.isExpanded = this.mediaQueryListener.matches;
    this.mediaQueryListener.on('change', (result: mediaquery.MediaQueryResult) => {
      // 窗口尺寸变化时自动更新按钮形态,无需监听折叠状态
      this.isExpanded = result.matches;
    });
  }

  aboutToDisappear(): void {
    // 组件销毁时取消监听,避免内存泄漏
    this.mediaQueryListener?.off('change');
  }

  build() {
    Button() {
      Flex() {
        // 图标固定尺寸,不参与伸缩
        Image(this.icon)
          .width(16)
          .height(16)
        // 展开态才显示文字,折叠态仅保留图标,从源头避免长文案换行
        if (this.isExpanded) {
          Text(this.label)
            .margin({ left: 6, right: 6 })
            .fontSize(14)
            .maxLines(1) // 强制单行,禁止换行
            .textOverflow({ overflow: TextOverflow.Ellipsis }) // 超长时省略号截断
        }
      }
      .width('auto') // Flex 宽度自适应内容
    }
    .height(36)
    .padding({ left: 16, right: 16 })
    .constraintSize({ maxWidth: 200 }) // 限制按钮最大宽度,防止撑破父容器
    .width('auto') // 按钮宽度跟随内容,不同断点下自然过渡
  }
}

@Entry
@Component
struct Index {
  build() {
    Column({ space: 12 }) {
      AdaptiveButton({ label: '开始录音' })
      AdaptiveButton({ label: '这是一个非常长的按钮文案用于验证截断效果' })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

补充说明

关于几个关键点的说明:

  • width('auto') 与 constraintSize({ maxWidth }) 组合是官方推荐的自适应按钮写法:内容不足时按钮收缩贴合内容,内容超长时在 maxWidth 处截断,两种屏幕形态下都不会换行。maxWidth 的取值应结合页面中按钮所在行的可用空间设置。
  • maxLines(1) 是防止换行的核心,务必与 textOverflow 配合使用,否则超长文本会被直接裁切,观感更差。
  • 断点驱动布局优于折叠状态驱动。若需要更精细的多档适配,可使用 UIContext.getWindowWidthBreakpoint() 获取 xs/sm/md/lg/xl 五档横向断点,或在整体页面布局中引入 GridRow/GridCol 组件,让按钮所在栅格列在不同断点下自动分配宽度。
  • 若希望文字在空间不足时优先缩小字号而非截断,可对文本设置 minFontSize 与 maxFontSize,并配合 heightAdaptivePolicy(TextHeightAdaptivePolicy.MIN_FONT_SIZE_FIRST) 实现"先缩小再截断"的效果,适合对文案完整性要求较高的场景。
  • 若页面中存在多个按钮并排,建议外层使用 Flex 的 wrap 能力或 GridRow 栅格布局,让按钮组在展开态下获得更充裕的排布空间,而不是给每个按钮写死宽度。

按上述方案改造后,折叠态下按钮收缩为图标或短文案形态,展开态下完整展示图标加文字,切换过程中文本始终保持单行,不会再出现换行或图标错位的问题。

展开全部
1楼回复于1小时前 来自广东
写回答
新增插入模板功能
一键使用模板,快速填写内容,轻松发帖~
知道了
  • 为了保障您的信息安全,请勿上传您的敏感个人信息(如您的密码等信息)和您的敏感资产信息(如关键源代码、签名私钥、调试安装包、业务日志等信息),且您需自行承担由此产生的信息泄露等安全风险。
  • 如您发布的内容为转载内容,请注明内容来源。

我要提问题

了解社区公约,与您携手共创和谐专业的开发者社区。