本文是「鸿蒙 6.1 API 23 开发坑系列」第 12 篇（非 UI 系第 6 篇）。本篇讲 @ohos.curves namespace（API 7+，鸿蒙 6.1 API 23 基座）—— 动画曲线 curves.initCurve/curves.cubicBezierCurve/curves.springCurve/curves.stepsCurve/curves.customCurve 函数 + ICurve interface + Curve enum + InitCurveResult 类型。鸿蒙坑根因：① curves.init/curves.cubicBezier/curves.spring/curves.steps 是废弃函数返回 string（API 9~废弃，迁移到 curves.initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve 对象）；② ICurve 是 interface 不能 new ICurve()（用 curves.initCurve() 工厂造实例）；③ Curve enum 常量 Linear/Ease/EaseIn/EaseOut/EaseInOut/FastOutSlowIn 不是字符串 'Linear'（传字符串编译错）；④ curves.cubicBezierCurve(x1,y1,x2,y2) 四个参数都是 number（范围 [0,1]），不是 React cubic-bezier(0.25, 0.1, 0.25, 1.0) 字符串；⑤ curves.springCurve(velocity, mass, stiffness, damping) 四个参数都是 number，velocity 初始速度 / mass 质量 / stiffness 刚度 / damping 阻尼——damping 越大震动越小（过阻尼不震动）；⑥ curves.customCurve(interpolate) 接收 (fraction: number) => number 回调，fraction 范围 [0,1]，返回值必须 [0,1]（超范围动画错位）。

一、开篇：鸿蒙 curves 不是 CSS transition-timing-function，是「namespace 工厂函数 initCurve + ICurve interface」

你写 Web 前端时，动画曲线用 CSS transition-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1.0) 或 ease-in-out（字符串关键字，浏览器内置解析）：

/* Web：CSS transition-timing-function 用字符串关键字或 cubic-bezier 函数 */
.box {
  transition: width 300ms cubic-bezier(0.25, 0.1, 0.25, 1.0);  /* ✅ cubic-bezier 函数 */
  transition: width 300ms ease-in-out;  /* ✅ ease-in-out 字符串关键字 */
  transition: width 300ms steps(4, end);  /* ✅ steps 阶跃函数 */
}

你写鸿蒙 ArkTS 时，动画曲线用 curves.initCurve(curve?: Curve): ICurve 工厂函数造 ICurve 实例（Curve enum 常量不是字符串，ICurve interface 不能 new）：

// ArkTS curves.initCurve：namespace 工厂函数造 ICurve 实例，Curve enum 常量不是字符串
import curves from '@ohos.curves'  // ✅ default import（curves 是 namespace）

// ✅ initCurve 带 Curve enum 常量（不是字符串'Linear'，不是废弃的 curves.init）
const linearCurve: curves.ICurve = curves.initCurve(curves.Curve.Linear)  // ✅ Curve.Linear enum 常量
const easeCurve: curves.ICurve = curves.initCurve(curves.Curve.Ease)      // ✅ Curve.Ease enum 常量

// ✅ cubicBezierCurve 四个 number 参数（不是 React cubic-bezier 字符串）
const bezierCurve: curves.ICurve = curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0)

// ✅ springCurve 四个 number 参数（velocity / mass / stiffness / damping）
const springCurve: curves.ICurve = curves.springCurve(0, 1, 200, 15)
// 鸿蒙坑根因：init 废弃迁移 initCurve，ICurve interface 不能 new，Curve enum 不是字符串

Web vs 鸿蒙 curves 的区别：Web 把动画曲线当 CSS 字符串关键字（ease-in-out / linear / cubic-bezier(...) / steps(...)，浏览器内置解析），ArkTS 把动画曲线当 ICurve 对象（curves.initCurve() 工厂造实例，Curve enum 常量不是字符串）。根因不是字符串是 enum——鸿蒙 curves.init/cubicBezier/spring/steps 废弃返回 string（API 9~废弃），迁移到 curves.initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve 对象（API 9+，d.ts 里 @useinstead initCurve），ICurve 是 interface 不能 new ICurve()（用 curves.initCurve() 工厂造实例），Curve enum 常量 Linear/Ease/EaseIn/EaseOut/EaseInOut/FastOutSlowIn 不是字符串 'Linear'（传字符串触发 Type 'string' is not assignable to type 'Curve' 编译错，enum 值是数字 0/1/2/3/4/5 不是字符串）。

二、根因：鸿蒙 @ohos.curves 的六个绑定机制

鸿蒙 @ohos.curves namespace（API 7+）核心导出 curves.initCurve/cubicBezierCurve/springCurve/stepsCurve/customCurve 函数（返回 ICurve 对象）+ ICurve interface + Curve enum + InitCurveResult 类型。绑定机制来自六重根因。

机制 1：curves.init/cubicBezier/spring/steps 废弃返回 string——迁移到 initCurve 等返回 ICurve

鸿蒙坑根因：curves.init/curves.cubicBezier/curves.spring/curves.steps 是废弃函数返回 string，迁移到 curves.initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve 对象：

// ❌ 鸿蒙坑：curves.init/cubicBezier/spring/steps 废弃返回 string（API 9~废弃有 IDE 警告）
import curves from '@ohos.curves'

// ❌ 废弃 API（API 7~8）：curves.init 返回 string（IDE 警告 'init' has been deprecated）
const linearStr: string = curves.init(curves.Curve.Linear)  // ❌ 废弃返回 string
const bezierStr: string = curves.cubicBezier(0.25, 0.1, 0.25, 1.0)  // ❌ 废弃返回 string
const springStr: string = curves.spring(0, 1, 200, 15)  // ❌ 废弃返回 string
const stepsStr: string = curves.steps(4, true)  // ❌ 废弃返回 string

// ✅ 正确用法：initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve 对象（API 9+）
const linearCurve: curves.ICurve = curves.initCurve(curves.Curve.Linear)  // ✅ initCurve 返回 ICurve
const bezierCurve: curves.ICurve = curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0)  // ✅ cubicBezierCurve
const springCurve: curves.ICurve = curves.springCurve(0, 1, 200, 15)  // ✅ springCurve
const stepsCurve: curves.ICurve = curves.stepsCurve(4, true)  // ✅ stepsCurve
// 鸿蒙坑根因：init/cubicBezier/spring/steps 废弃返回 string，迁移到 initCurve 等返回 ICurve

curves.init 废弃返回 string 坑根因：鸿蒙 API 7~8 用 curves.init(curve?: Curve): string 返回字符串（内部把 Curve enum 转字符串），API 9 废弃迁移到 curves.initCurve(curve?: Curve): ICurve 返回 ICurve 对象（@useinstead initCurve）。鸿蒙坑：用废弃 curves.init 不会编译错（deprecated 不是 removed），但 IDE 警告 'init' has been deprecated. Use initCurve instead，且废弃的 curves.init 返回 string（不是 ICurve 对象），传给 animateTo({ curve: ... }) 时类型不匹配（animateTo 的 curve 参数要求 ICurve | Curve 不是 string）。新代码必须 curves.initCurve() 返回 ICurve 对象。React CSS transition-timing-function: ease-in-out 用字符串关键字（浏览器内置解析），鸿蒙 curves.init() 也返回字符串但废弃了——鸿蒙废弃字符串改用 ICurve 对象（类型安全，编译期检查）。

机制 2：ICurve 是 interface 不能 new ICurve()——用 curves.initCurve() 工厂造实例

鸿蒙坑根因：ICurve 是 interface 不能 new ICurve()（用 curves.initCurve() / cubicBezierCurve() / springCurve() / stepsCurve() / customCurve() 工厂函数造实例）：

// ❌ 鸿蒙坑：ICurve 是 interface 不能 new ICurve()（interface 没有 constructor）
import curves from '@ohos.curves'

// ❌ new ICurve() 编译错（ICurve 是 interface 不是 class，没有 constructor）
const curve1 = new curves.ICurve()  // ❌ 'ICurve' only refers to a type, but is being used as a value here

// ❌ ICurve 无 interpolate 字段直接赋值（ICurve 是 interface 不能实例化）
const curve2: curves.ICurve = { interpolate: (fraction: number) => fraction }  // ❌ 不能用对象字面量赋值

// ✅ 正确用法：curves.initCurve() 工厂函数造 ICurve 实例
const linearCurve: curves.ICurve = curves.initCurve(curves.Curve.Linear)  // ✅ initCurve 工厂造实例
const bezierCurve: curves.ICurve = curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0)  // ✅ cubicBezierCurve 工厂
const springCurve: curves.ICurve = curves.springCurve(0, 1, 200, 15)  // ✅ springCurve 工厂
const stepsCurve: curves.ICurve = curves.stepsCurve(4, true)  // ✅ stepsCurve 工厂
const customCurve: curves.ICurve = curves.customCurve((fraction: number) => fraction * fraction)  // ✅ customCurve
// 鸿蒙坑根因：ICurve interface 不能 new，用 curves.initCurve() 等工厂函数造实例

ICurve interface 不能 new 坑根因：鸿蒙 ICurve 是 interface（interface ICurve { interpolate: (fraction: number) => number }），不是 class，没有 constructor——new curves.ICurve() 触发 'ICurve' only refers to a type, but is being used as a value here 编译错。鸿蒙坑：前端开发者习惯 React new BezierEasing(...) 或 new Spring(...) 造曲线实例（class + constructor），鸿蒙 ICurve 是 interface 不能 new，必须用 curves.initCurve() / cubicBezierCurve() / springCurve() / stepsCurve() / customCurve() 五个工厂函数造实例（工厂模式，隐藏实现细节）。React CSS transition-timing-function: cubic-bezier(...) 直接用 CSS 函数（浏览器解析），鸿蒙 cubicBezierCurve(...) 是 TS 工厂函数造 ICurve 对象（编译期类型检查）。

机制 3：Curve enum 常量 Linear/Ease/EaseIn/EaseOut/EaseInOut/FastOutSlowIn 不是字符串’Linear’

鸿蒙坑根因：Curve enum 常量 Linear/Ease/EaseIn/EaseOut/EaseInOut/FastOutSlowIn 不是字符串 'Linear'（传字符串触发编译错）：

// ❌ 鸿蒙坑：Curve enum 常量不是字符串'Linear'（传字符串编译错）
import curves from '@ohos.curves'

// ❌ 传字符串'Linear'编译错（Curve enum 类型不是 string）
const curve1 = curves.initCurve('Linear')  // ❌ Type 'string' is not assignable to type 'Curve'
const curve2 = curves.initCurve('Ease')    // ❌ 传字符串编译错

// ❌ 用废弃的 curves.init 传字符串（废弃 API 也要求 Curve enum 不是字符串）
const curve3 = curves.init('Linear')  // ❌ 同样编译错（init 参数是 Curve enum 不是 string）

// ✅ 正确用法：Curve enum 常量（curves.Curve.Linear 不是字符串'Linear'）
const linearCurve: curves.ICurve = curves.initCurve(curves.Curve.Linear)      // ✅ Curve.Linear=0
const easeCurve: curves.ICurve = curves.initCurve(curves.Curve.Ease)          // ✅ Curve.Ease=1
const easeInCurve: curves.ICurve = curves.initCurve(curves.Curve.EaseIn)      // ✅ Curve.EaseIn=2
const easeOutCurve: curves.ICurve = curves.initCurve(curves.Curve.EaseOut)    // ✅ Curve.EaseOut=3
const easeInOutCurve: curves.ICurve = curves.initCurve(curves.Curve.EaseInOut) // ✅ Curve.EaseInOut=4
const fastOutSlowInCurve: curves.ICurve = curves.initCurve(curves.Curve.FastOutSlowIn) // ✅ Curve.FastOutSlowIn=5
// ✅ Curve enum 常量语义（对应 CSS transition-timing-function 关键字）：
// Linear=0：线性（CSS linear）
// Ease=1：先慢后快再慢（CSS ease，CubicBezier(0.25, 0.1, 0.25, 1.0)）
// EaseIn=2：先慢后快（CSS ease-in，CubicBezier(0.42, 0.0, 1.0, 1.0)）
// EaseOut=3：先快后慢（CSS ease-out，CubicBezier(0.0, 0.0, 0.58, 1.0)）
// EaseInOut=4：两端慢中间快（CSS ease-in-out，CubicBezier(0.42, 0.0, 0.58, 1.0)）
// FastOutSlowIn=5：标准曲线（CubicBezier(0.4, 0.0, 0.2, 1.0)）
// 鸿蒙坑根因：Curve enum 常量 Linear/Ease 等不是字符串，enum 值是数字 0/1/2/3/4/5

Curve enum 常量不是字符串坑根因：鸿蒙 Curve enum 的六个常量是 Linear=0（线性，CSS linear）/Ease=1（先慢后快再慢，CSS ease，CubicBezier(0.25, 0.1, 0.25, 1.0)）/EaseIn=2（先慢后快，CSS ease-in，CubicBezier(0.42, 0.0, 1.0, 1.0)）/EaseOut=3（先快后慢，CSS ease-out，CubicBezier(0.0, 0.0, 0.58, 1.0)）/EaseInOut=4（两端慢中间快，CSS ease-in-out，CubicBezier(0.42, 0.0, 0.58, 1.0)）/FastOutSlowIn=5（标准曲线，CubicBezier(0.4, 0.0, 0.2, 1.0)）。鸿蒙坑：传字符串 'Linear' 触发 Type 'string' is not assignable to type 'Curve' 编译错——必须传 curves.Curve.Linear enum 常量（enum 值是数字 0 不是字符串）。React CSS transition-timing-function: ease-in-out 用字符串关键字（浏览器内置解析），鸿蒙 curves.initCurve(curves.Curve.EaseInOut) 用 enum 常量（编译期类型检查，enum 值是数字）。

机制 4：cubicBezierCurve(x1,y1,x2,y2) 四个 number 不是 React cubic-bezier 字符串

鸿蒙坑根因：curves.cubicBezierCurve(x1, y1, x2, y2) 四个参数都是 number（范围 [0,1]），不是 React cubic-bezier(0.25, 0.1, 0.25, 1.0) 字符串：

// ❌ 鸿蒙坑：cubicBezierCurve 四个 number 参数（不是 React cubic-bezier 字符串）
import curves from '@ohos.curves'

// ❌ 传字符串'cubic-bezier(0.25, 0.1, 0.25, 1.0)'编译错（cubicBezierCurve 参数是 number 不是 string）
const curve1 = curves.cubicBezierCurve('cubic-bezier(0.25, 0.1, 0.25, 1.0)')  // ❌ 参数类型 number 不是 string

// ❌ 参数超范围 [0,1]（x1/y1/x2/y2 必须 [0,1]，超范围动画错位）
const curve2 = curves.cubicBezierCurve(1.5, 0.1, 0.25, 1.0)  // ❌ x1=1.5 超 [0,1] 范围

// ❌ 用废弃的 curves.cubicBezier（废弃返回 string 不是 ICurve）
const curve3Str: string = curves.cubicBezier(0.25, 0.1, 0.25, 1.0)  // ❌ 废弃返回 string

// ✅ 正确用法：cubicBezierCurve 四个 number 参数（范围 [0,1]），返回 ICurve 对象
const easeCurve: curves.ICurve = curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0)  // ✅ ease 曲线
const easeInCurve: curves.ICurve = curves.cubicBezierCurve(0.42, 0.0, 1.0, 1.0)  // ✅ ease-in 曲线
const easeOutCurve: curves.ICurve = curves.cubicBezierCurve(0.0, 0.0, 0.58, 1.0)  // ✅ ease-out 曲线
const customCurve: curves.ICurve = curves.cubicBezierCurve(0.68, -0.55, 0.27, 1.55)  // ✅ 自定义贝塞尔（可超 [0,1] 做回弹）
// 鸿蒙坑根因：cubicBezierCurve 四个 number 不是 cubic-bezier 字符串，参数范围 [0,1]

cubicBezierCurve 四个 number 坑根因：鸿蒙 curves.cubicBezierCurve(x1: number, y1: number, x2: number, y2: number): ICurve 的四个参数都是 number（三阶贝塞尔曲线的两个控制点 (x1,y1) 和 (x2,y2)），对应 React CSS cubic-bezier(x1, y1, x2, y2) 函数。鸿蒙坑：React CSS transition-timing-function: cubic-bezier(0.25, 0.1, 0.25, 1.0) 用 CSS 函数字符串（浏览器解析），鸿蒙 curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0) 用 TS 四个 number 参数（编译期类型检查）——传字符串 'cubic-bezier(...)' 触发 Type 'string' is not assignable to type 'number' 编译错。参数范围 x1/y1/x2/y2 建议 [0,1]（标准贝塞尔曲线），但 y1/y2 可超 [0,1] 做回弹效果（cubicBezierCurve(0.68, -0.55, 0.27, 1.55) 回弹动画），x1/x2 必须 [0,1]（时间轴不能超）。

机制 5：springCurve(velocity, mass, stiffness, damping) 四个 number——damping 越大震动越小

鸿蒙坑根因：curves.springCurve(velocity, mass, stiffness, damping) 四个参数都是 number，damping 阻尼越大震动越小（过阻尼 damping² > 4*mass*stiffness 不震动）：

// ❌ 鸿蒙坑：springCurve 四个 number 参数（不是 React spring 字符串，damping 越大震动越小）
import curves from '@ohos.curves'

// ❌ 用废弃的 curves.spring（废弃返回 string 不是 ICurve）
const springStr: string = curves.spring(0, 1, 200, 15)  // ❌ 废弃返回 string

// ❌ 参数单位搞错（velocity 初始速度，mass 质量，stiffness 刚度，damping 阻尼）
const curve1 = curves.springCurve(100, 1, 200, 15)  // ❌ velocity=100 太大（建议 0~10）

// ✅ 正确用法：springCurve 四个 number 参数，返回 ICurve 对象
// velocity：初始速度（外部因素施加给弹簧动画的初始速度，建议 0~10，0 表示无初速度）
// mass：质量（影响弹簧系统的惯性，质量越大弹簧拉伸越长，建议 1~10）
// stiffness：刚度（弹簧的刚度，刚度越大弹簧越硬反弹越快，建议 100~1000）
// damping：阻尼（弹簧系统的阻尼，阻尼越大震动越小，建议 10~50）
const underDamped: curves.ICurve = curves.springCurve(0, 1, 200, 15)  // ✅ 欠阻尼（震动衰减）
const overDamped: curves.ICurve = curves.springCurve(0, 1, 200, 100)  // ✅ 过阻尼（不震动，缓慢到位）
const criticalDamped: curves.ICurve = curves.springCurve(0, 1, 200, 28.28)  // ✅ 临界阻尼（最快无震动到位）
// ✅ 过阻尼条件：damping² > 4 * mass * stiffness（damping > 2 * sqrt(mass * stiffness)）
// ✅ 临界阻尼条件：damping² = 4 * mass * stiffness（damping = 2 * sqrt(mass * stiffness)）
// 鸿蒙坑根因：springCurve 四个 number，damping 越大震动越小，过阻尼不震动

springCurve 四个 number damping 坑根因：鸿蒙 curves.springCurve(velocity: number, mass: number, stiffness: number, damping: number): ICurve 的四个参数都是 number——velocity 初始速度（外部因素施加给弹簧动画的初始速度，建议 0~10，0 表示无初速度）/mass 质量（影响弹簧系统的惯性，质量越大弹簧拉伸越长，建议 1~10）/stiffness 刚度（弹簧的刚度，刚度越大弹簧越硬反弹越快，建议 100~1000）/damping 阻尼（弹簧系统的阻尼，阻尼越大震动越小，建议 10~50）。鸿蒙坑：React react-spring 用 { tension: 200, friction: 15 } 配置（tension = stiffness，friction = damping），鸿蒙 springCurve 用 (velocity, mass, stiffness, damping) 四个 number 参数（命名差异，stiffness 不是 tension，damping 不是 friction）。damping 越大震动越小——过阻尼 damping² > 4 * mass * stiffness（damping > 2 * sqrt(mass * stiffness)）不震动缓慢到位，临界阻尼 damping² = 4 * mass * stiffness（damping = 2 * sqrt(mass * stiffness)）最快无震动到位，欠阻尼 damping² < 4 * mass * stiffness 震动衰减。mass=1, stiffness=200 时临界阻尼 damping = 2 * sqrt(1 * 200) ≈ 28.28。

机制 6：customCurve(interpolate) 回调 fraction [0,1] 返回 [0,1]——超范围动画错位

鸿蒙坑根因：curves.customCurve(interpolate) 接收 (fraction: number) => number 回调，fraction 范围 [0,1]（动画进度），返回值必须 [0,1]（超范围动画错位）：

// ❌ 鸿蒙坑：customCurve 回调返回值超 [0,1] 动画错位（fraction 范围 [0,1] 返回必须 [0,1]）
import curves from '@ohos.curves'

// ❌ 返回值超 [0,1] 动画错位（超 1 值溢出目标，负值反向）
const curve1 = curves.customCurve((fraction: number) => {
  return fraction * 2  // ❌ 返回 fraction*2 超 [0,1]（fraction=0.6 时返回 1.2 超目标）
})

// ❌ 返回值负数反向动画（fraction=0.1 时返回 -0.1 反向）
const curve2 = curves.customCurve((fraction: number) => {
  return fraction - 0.5  // ❌ 返回负数（fraction=0.1 时返回 -0.4 反向动画）
})

// ❌ 回调参数名搞错（fraction 是动画进度 [0,1]，不是 t/x/time）
const curve3 = curves.customCurve((time: number) => {  // ❌ 参数名 time 不规范（应是 fraction）
  return time * time
})

// ✅ 正确用法：customCurve 回调 fraction [0,1] 返回 [0,1]（自定义插值函数）
const quadCurve: curves.ICurve = curves.customCurve((fraction: number) => {
  return fraction * fraction  // ✅ 二次方曲线（返回 [0,1] 内）
})
const cubicCurve: curves.ICurve = curves.customCurve((fraction: number) => {
  return fraction * fraction * fraction  // ✅ 三次方曲线（返回 [0,1] 内）
})
const bounceCurve: curves.ICurve = curves.customCurve((fraction: number) => {
  // ✅ 回弹曲线（fraction [0,1] 返回 [0,1] 内，可短暂超 1 做回弹但最终回归 1）
  if (fraction < 0.5) return fraction * 2  // 0~0.5 进度 0~1
  return 1 - (fraction - 0.5) * 0.2  // 0.5~1 进度 1~0.9（轻微回弹）
})
// 鸿蒙坑根因：customCurve 回调 fraction [0,1] 返回必须 [0,1]，超范围动画错位

customCurve 回调 fraction 返回值坑根因：鸿蒙 curves.customCurve(interpolate: (fraction: number) => number): ICurve 接收一个回调函数 interpolate，参数 fraction: number 是动画进度（范围 [0,1]，0 表示动画开始，1 表示动画结束），返回值是插值后的进度（必须 [0,1]，超范围动画错位——超 1 值溢出目标，负值反向动画）。鸿蒙坑：React easing.custom(t => t * t) 用 t 参数名（t 是动画进度 [0,1]，返回 [0,1]），鸿蒙 customCurve((fraction) => ...) 用 fraction 参数名（语义一致，fraction 是动画进度 [0,1] 返回 [0,1]）。回弹曲线可短暂超 1 做回弹（cubicBezierCurve(0.68, -0.55, 0.27, 1.55) 用贝塞尔超范围做回弹，customCurve 也可返回超 1 值做回弹），但最终必须回归 1（动画结束时进度 = 1）。

三、真机配图：鸿蒙 @ohos.curves 动画曲线坑——initCurve 废弃迁移 + ICurve interface 非 new + Curve enum 非字符串

真机配图展示鸿蒙 @ohos.curves 动画曲线坑：

• curves 初始态：鸿蒙 6.1 @ohos.curves 动画曲线坑标题，5 个验证按钮（① initCurve 废弃迁移 / ② Curve enum 常量非字符串 / ③ cubicBezierCurve 四 number / ④ springCurve damping 震动 / ⑤ customCurve fraction [0,1]），要点说明 7 条
• Curve enum 常量态：点击「② 验证 Curve enum 常量非字符串」按钮，显示「✅ Curve enum 常量 Linear=0/Ease=1/EaseIn=2/EaseOut=3/EaseInOut=4/FastOutSlowIn=5 不是字符串’Linear’」+ 6 个 enum 常量值——Curve enum 常量非字符串验证
• cubicBezierCurve 四 number 态：点击「③ 验证 cubicBezierCurve 四 number」按钮，显示「✅ cubicBezierCurve(x1,y1,x2,y2) 四个 number 不是 cubic-bezier 字符串，参数范围 [0,1]」+ 贝塞尔曲线动画——cubicBezierCurve 四 number 非 cubic-bezier 字符串验证
• springCurve damping 态：点击「④ 验证 springCurve damping 震动」按钮，显示「✅ springCurve(velocity, mass, stiffness, damping) 四 number，damping 越大震动越小，过阻尼不震动」+ 弹簧动画三种阻尼——springCurve damping 震动 + 过阻尼/临界阻尼/欠阻尼验证
• customCurve fraction 态：点击「⑤ 验证 customCurve fraction [0,1]」按钮，显示「✅ customCurve((fraction) => number) 回调，fraction [0,1] 返回必须 [0,1]，超范围动画错位」+ 自定义曲线动画——customCurve fraction [0,1] 返回 [0,1] 验证

四、真解法：鸿蒙 @ohos.curves 的四个场景

场景 1：curves.initCurve 带 Curve.EaseInOut enum 常量造 ICurve——90% 场景首选

基础动画曲线用 curves.initCurve(curves.Curve.EaseInOut) 工厂函数造 ICurve 实例：

// ✅ 场景 1：curves.initCurve 带 Curve.EaseInOut enum 常量造 ICurve（API 7，90% 场景首选）
import curves from '@ohos.curves'  // ✅ default import（curves 是 namespace）
import { animateTo } from '@kit.ArkUI'

@Entry
@Component
struct Index {
  @State btnWidth: number = 200

  animateBtn() {
    // ✅ initCurve 带 Curve enum 常量（不是字符串'EaseInOut'，不是废弃的 curves.init）
    const curve: curves.ICurve = curves.initCurve(curves.Curve.EaseInOut)  // ✅ Curve.EaseInOut enum 常量
    animateTo({ duration: 300, curve: curve, onFinish: () => {
      console.info('动画完成')
    } }, () => {
      this.btnWidth = this.btnWidth === 200 ? 300 : 200  // ✅ 修改 @State 触发动画
    })
  }

  build() {
    Column({ space: 8 }) {
      Button('点击动画').width(this.btnWidth).height(50).onClick(() => this.animateBtn())
    }
  }
}
// initCurve + Curve.EaseInOut enum + ICurve：90% 场景首选，animateTo 的 curve 参数用 ICurve

鸿蒙 @ohos.curves API 真名坑：import curves from '@ohos.curves'（default import，curves 是 namespace）；curves.initCurve(curve?: Curve): ICurve（工厂函数造 ICurve 实例，参数是 Curve enum 常量不是字符串）；curves.cubicBezierCurve(x1: number, y1: number, x2: number, y2: number): ICurve（三阶贝塞尔曲线，四个 number 参数范围 [0,1]）；curves.springCurve(velocity: number, mass: number, stiffness: number, damping: number): ICurve（弹簧曲线，四个 number 参数）；curves.stepsCurve(count: number, end: boolean): ICurve（阶跃曲线，count 步数 [1, +∞)，end 是否在每步结束跳变）；curves.customCurve(interpolate: (fraction: number) => number): ICurve（自定义曲线，回调 fraction [0,1] 返回 [0,1]）；ICurve interface 不能 new ICurve()（用工厂函数造实例）；Curve enum 常量 Linear=0/Ease=1/EaseIn=2/EaseOut=3/EaseInOut=4/FastOutSlowIn=5（不是字符串，enum 值是数字）；curves.init/cubicBezier/spring/steps 废弃返回 string（API 9~废弃，迁移到 initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve）；SysCap SystemCapability.ArkUI.ArkUI.Full；@atomicservice 原子化服务（API 11+）；@crossplatform 跨平台（API 10+）。

场景 2：curves.cubicBezierCurve 造自定义贝塞尔曲线——回弹动画

回弹动画用 curves.cubicBezierCurve(0.68, -0.55, 0.27, 1.55) 造自定义贝塞尔曲线（y1/y2 超 [0,1] 做回弹）：

// ✅ 场景 2：curves.cubicBezierCurve 造自定义贝塞尔曲线（回弹动画，y1/y2 超 [0,1]）
import curves from '@ohos.curves'
import { animateTo } from '@kit.ArkUI'

@Entry
@Component
struct Index {
  @State btnScale: number = 1

  bounceAnimation() {
    // ✅ cubicBezierCurve 四个 number 参数（不是 cubic-bezier 字符串）
    // ✅ y1=-0.55 / y2=1.55 超 [0,1] 做回弹效果（x1/x2 必须 [0,1] 时间轴不能超）
    const bounceCurve: curves.ICurve = curves.cubicBezierCurve(0.68, -0.55, 0.27, 1.55)
    animateTo({ duration: 500, curve: bounceCurve }, () => {
      this.btnScale = this.btnScale === 1 ? 1.2 : 1  // ✅ scale 放大回弹
    })
  }

  build() {
    Column({ space: 8 }) {
      Button('回弹动画').scale({ x: this.btnScale, y: this.btnScale }).onClick(() => this.bounceAnimation())
    }
  }
}
// cubicBezierCurve + 回弹 y1/y2 超 [0,1]：回弹动画，x1/x2 必须 [0,1] 时间轴

鸿蒙 cubicBezierCurve 回弹 API 真名坑：curves.cubicBezierCurve(x1, y1, x2, y2) 的 x1/x2 必须 [0,1]（时间轴不能超），y1/y2 可超 [0,1] 做回弹效果（y1=-0.55 负值反向回弹，y2=1.55 超 1 溢出目标回弹）；React CSS cubic-bezier(0.68, -0.55, 0.27, 1.55) 同样支持 y1/y2 超 [0,1] 做回弹（语义一致）；鸿蒙坑：React CSS transition-timing-function: cubic-bezier(...) 用 CSS 函数字符串（浏览器解析），鸿蒙 cubicBezierCurve(...) 用 TS 四个 number 参数（编译期类型检查）——传字符串触发编译错。

场景 3：curves.springCurve 造弹簧曲线——damping 阻尼控制震动

弹簧动画用 curves.springCurve(velocity, mass, stiffness, damping) 造弹簧曲线，damping 阻尼控制震动（过阻尼不震动，临界阻尼最快无震动，欠阻尼震动衰减）：

// ✅ 场景 3：curves.springCurve 造弹簧曲线（damping 阻尼控制震动，四种阻尼状态）
import curves from '@ohos.curves'
import { animateTo } from '@kit.ArkUI'

@Entry
@Component
struct Index {
  @State btnOffset: number = 0

  // ✅ 欠阻尼（damping² < 4*mass*stiffness）：震动衰减
  underDampedSpring() {
    const curve: curves.ICurve = curves.springCurve(0, 1, 200, 15)  // ✅ damping=15 < 28.28 欠阻尼震动
    animateTo({ duration: 1000, curve: curve }, () => {
      this.btnOffset = this.btnOffset === 0 ? 100 : 0
    })
  }

  // ✅ 临界阻尼（damping = 2*sqrt(mass*stiffness)）：最快无震动到位
  criticalDampedSpring() {
    const criticalDamping = 2 * Math.sqrt(1 * 200)  // ✅ damping ≈ 28.28 临界阻尼
    const curve: curves.ICurve = curves.springCurve(0, 1, 200, criticalDamping)
    animateTo({ duration: 1000, curve: curve }, () => {
      this.btnOffset = this.btnOffset === 0 ? 100 : 0
    })
  }

  // ✅ 过阻尼（damping² > 4*mass*stiffness）：不震动缓慢到位
  overDampedSpring() {
    const curve: curves.ICurve = curves.springCurve(0, 1, 200, 100)  // ✅ damping=100 > 28.28 过阻尼不震动
    animateTo({ duration: 1000, curve: curve }, () => {
      this.btnOffset = this.btnOffset === 0 ? 100 : 0
    })
  }

  build() {
    Column({ space: 8 }) {
      Button('欠阻尼震动').onClick(() => this.underDampedSpring())
      Button('临界阻尼无震动').onClick(() => this.criticalDampedSpring())
      Button('过阻尼缓慢').onClick(() => this.overDampedSpring())
      Button('弹簧按钮').position({ x: this.btnOffset, y: 200 })
    }
  }
}
// springCurve + damping 阻尼：欠阻尼震动，临界阻尼最快无震动，过阻尼缓慢不震动

鸿蒙 springCurve damping 阻尼 API 真名坑：curves.springCurve(velocity, mass, stiffness, damping) 的 damping 阻尼控制震动——过阻尼 damping > 2 * sqrt(mass * stiffness) 不震动缓慢到位（适合需要平稳无震动的场景），临界阻尼 damping = 2 * sqrt(mass * stiffness) 最快无震动到位（适合需要快速到位且无震动的场景），欠阻尼 damping < 2 * sqrt(mass * stiffness) 震动衰减（适合需要弹性回弹震动的场景）；mass=1, stiffness=200 时临界阻尼 damping = 2 * sqrt(1 * 200) ≈ 28.28；React react-spring 用 { tension: 200, friction: 15 } 配置（tension = stiffness，friction = damping），鸿蒙 springCurve 用 (velocity, mass, stiffness, damping) 四个 number 参数（命名差异，stiffness 不是 tension，damping 不是 friction）。

场景 4：curves.customCurve 造自定义插值曲线——fraction [0,1] 返回 [0,1]

自定义插值曲线用 curves.customCurve((fraction: number) => number) 造自定义曲线，回调 fraction [0,1] 返回必须 [0,1]（超范围动画错位）：

// ✅ 场景 4：curves.customCurve 造自定义插值曲线（fraction [0,1] 返回 [0,1]）
import curves from '@ohos.curves'
import { animateTo } from '@kit.ArkUI'

@Entry
@Component
struct Index {
  @State btnOpacity: number = 1

  customAnimation() {
    // ✅ customCurve 回调 fraction [0,1] 返回 [0,1]（自定义插值函数）
    const customCurve: curves.ICurve = curves.customCurve((fraction: number) => {
      // ✅ 二次方曲线（缓入缓出，返回 [0,1] 内）
      return fraction * fraction  // ✅ fraction=0.6 时返回 0.36（[0,1] 内）
    })
    animateTo({ duration: 500, curve: customCurve }, () => {
      this.btnOpacity = this.btnOpacity === 1 ? 0.3 : 1  // ✅ opacity 变化触发动画
    })
  }

  // ✅ 回弹 customCurve（可短暂超 1 做回弹但最终回归 1）
  bounceCustomAnimation() {
    const bounceCurve: curves.ICurve = curves.customCurve((fraction: number) => {
      // ✅ 回弹曲线（fraction [0,1] 返回 [0,1] 内，可短暂超 1 做回弹）
      if (fraction < 0.5) return fraction * 2  // ✅ 0~0.5 进度 0~1
      return 1 - (fraction - 0.5) * 0.2  // ✅ 0.5~1 进度 1~0.9（轻微回弹）
    })
    animateTo({ duration: 500, curve: bounceCurve }, () => {
      this.btnOpacity = this.btnOpacity === 1 ? 0.3 : 1
    })
  }

  build() {
    Column({ space: 8 }) {
      Button('自定义曲线').opacity(this.btnOpacity).onClick(() => this.customAnimation())
      Button('回弹曲线').opacity(this.btnOpacity).onClick(() => this.bounceCustomAnimation())
    }
  }
}
// customCurve + fraction [0,1] 返回 [0,1]：自定义插值曲线，超范围动画错位

鸿蒙 customCurve 回调 API 真名坑：curves.customCurve(interpolate: (fraction: number) => number): ICurve 接收回调函数 interpolate，参数 fraction: number 是动画进度（范围 [0,1]，0 表示动画开始，1 表示动画结束），返回值是插值后的进度（必须 [0,1]，超范围动画错位——超 1 值溢出目标，负值反向动画）；React easing.custom(t => t * t) 用 t 参数名（语义一致，t 是动画进度 [0,1] 返回 [0,1]），鸿蒙 customCurve((fraction) => ...) 用 fraction 参数名；回弹曲线可短暂超 1 做回弹（但最终必须回归 1，动画结束时进度 = 1）。

五、一句话哲学

写鸿蒙 ArkTS 记住：curves 不是 CSS transition-timing-function 字符串是「namespace 工厂函数 initCurve + ICurve interface」——鸿蒙 6.1 API 23 @ohos.curves namespace（API 7+，鸿蒙 6.1 API 23 基座，curves.initCurve/cubicBezierCurve/springCurve/stepsCurve/customCurve 工厂函数返回 ICurve 对象 + ICurve interface + Curve enum + InitCurveResult 类型，SysCap SystemCapability.ArkUI.ArkUI.Full，@atomicservice，@crossplatform）。根因不是字符串是 enum——curves.init/cubicBezier/spring/steps 废弃返回 string（API 9~废弃，d.ts 里 @useinstead initCurve 等），迁移到 curves.initCurve/cubicBezierCurve/springCurve/stepsCurve 返回 ICurve 对象（✅ const curve: curves.ICurve = curves.initCurve(curves.Curve.Linear) 返回 ICurve 对象，❌ curves.init(curves.Curve.Linear) 废弃返回 string，❌ animateTo({ curve: stringVal }) 类型不匹配 ICurve 不是 string），ICurve 是 interface 不能 new ICurve()（❌ new curves.ICurve() 触发 'ICurve' only refers to a type, but is being used as a value here 编译错，✅ 用 curves.initCurve() / cubicBezierCurve() / springCurve() / stepsCurve() / customCurve() 五个工厂函数造实例，工厂模式隐藏实现细节），Curve enum 常量 Linear=0/Ease=1/EaseIn=2/EaseOut=3/EaseInOut=4/FastOutSlowIn=5 不是字符串 'Linear'（❌ curves.initCurve('Linear') 触发 Type 'string' is not assignable to type 'Curve' 编译错，✅ curves.initCurve(curves.Curve.Linear) enum 常量，enum 值是数字 0/1/2/3/4/5 不是字符串，对应 CSS linear/ease/ease-in/ease-out/ease-in-out 关键字），cubicBezierCurve(x1, y1, x2, y2) 四个参数都是 number（❌ 传字符串 'cubic-bezier(0.25, 0.1, 0.25, 1.0)' 触发 Type 'string' is not assignable to type 'number' 编译错，✅ curves.cubicBezierCurve(0.25, 0.1, 0.25, 1.0) 四个 number，对应 React CSS cubic-bezier(x1, y1, x2, y2) 函数，x1/x2 必须 [0,1] 时间轴不能超，y1/y2 可超 [0,1] 做回弹效果 cubicBezierCurve(0.68, -0.55, 0.27, 1.55) 回弹动画），springCurve(velocity, mass, stiffness, damping) 四个参数都是 number（✅ velocity 初始速度 0~10 / mass 质量 1~10 / stiffness 刚度 100~1000 / damping 阻尼 10~50，damping 越大震动越小，过阻尼 damping > 2*sqrt(mass*stiffness) 不震动缓慢到位，临界阻尼 damping = 2*sqrt(mass*stiffness) 最快无震动到位，欠阻尼 damping < 2*sqrt(mass*stiffness) 震动衰减，mass=1, stiffness=200 时临界阻尼 damping ≈ 28.28，React react-spring 用 { tension, friction } 命名差异 tension = stiffness friction = damping），customCurve((fraction: number) => number) 接收回调函数（✅ fraction 参数名是动画进度 [0,1]，返回值必须 [0,1]，超范围动画错位——超 1 值溢出目标，负值反向动画，❌ (time: number) => time * 2 参数名 time 不规范 + 返回 time*2 超 [0,1]，React easing.custom(t => t * t) 用 t 参数名语义一致），stepsCurve(count: number, end: boolean): ICurve 阶跃曲线（count 步数 [1, +∞)，end 是否在每步结束跳变，对应 React CSS steps(count, end) 函数）。init/cubicBezier/spring/steps 废弃返回 string 迁移 initCurve 等返回 ICurve + ICurve interface 不能 new 用工厂函数造实例 + Curve enum 常量 Linear/Ease 等不是字符串 enum 值数字 + cubicBezierCurve 四 number 不是 cubic-bezier 字符串 + springCurve 四 number damping 越大震动越小 + customCurve 回调 fraction [0,1] 返回必须 [0,1] 是鸿蒙 6.1 @ohos.curves 动画曲线坑核心！

能力系列回链

• 鸿蒙 7.0 新特性篇 1~17（沉浸式毛玻璃/Component3D/智能体框架/方舟引擎/星盾安全/星河互联/空间音频/可变字体/游戏快启/分布式数据盾/LTPO 可变帧率/AI 文档识别/多形态服务窗口/AI 反诈/机密计算/空间计算/小艺全面进化）
• 鸿蒙 6.1 API 23 开发坑系列篇 1「ArkUI.modifier 装饰器坑」——attributeModifier + AttributeModifier 状态化节点修改器
• 鸿蒙 6.1 API 23 开发坑系列篇 2「arkui.componentSnapshot 组件截图坑」——get/getSync/createFromBuilder 返回 image.PixelMap 像素图
• 鸿蒙 6.1 API 23 开发坑系列篇 3「arkui.node 节点坑」——NodeController abstract class makeNode override + BuilderNode WrappedBuilder
• 鸿蒙 6.1 API 23 开发坑系列篇 4「arkui.UIContext UI 上下文坑」——runScopedTask 不是 runScopedOnUiThread + 11 个子管理器
• 鸿蒙 6.1 API 23 开发坑系列篇 5「arkui.observer UI 观察器坑」——uiObserver namespace 真名不是 observer + on type string literal
• 鸿蒙 6.1 API 23 开发坑系列篇 6「@ohos.animator 动画器坑」——import @kit.ArkUI 不是 @ohos.animator + onFrame 驼峰不是废弃 onframe + getUIContext().createAnimator 不是废弃 animator.create + 持引用 + aboutToDisappear cancel
• 鸿蒙 6.1 API 23 开发坑系列篇 7「@ohos.net.http HTTP 请求坑」——HttpDataType 常量是 STRING 不是 STRING_TYPE + HttpRequest 是 interface 不能 new + http.createHttp() 工厂造实例 + on/off 监听不是 addEventListener + header Record 不是 Headers + RequestMethod enum 不是字符串
• 鸿蒙 6.1 API 23 开发坑系列篇 8「@ohos.file.fs 文件管理坑」——writeSync/readSync 是 namespace 顶层函数不是 File 实例方法 + 第一参传 file.fd 文件描述符 + ReadOptions 无 encoding 读 ArrayBuffer 原字节 + WriteOptions 带 encoding 写字符串指定编码 + closeSync(file) 传 File 不是 fd + OpenMode enum 不是 flags 数字
• 鸿蒙 6.1 API 23 开发坑系列篇 9「@ohos.router 页面路由坑」——router.push/replace 废弃迁移 pushUrl/replaceUrl + RouterMode enum 常量 Standard/Single 不是字符串 + RouterOptions.url 绝对路径不是相对路径 + getParams 返回 Object 要 as Record 转型 + RouterState 真属性 index/name 不是 stackLength + getLength 返回 string 不是 number
• 鸿蒙 6.1 API 23 开发坑系列篇 10「@ohos.promptAction 弹窗坑」——showToast/showDialog/showActionMenu 废弃迁移 getPromptAction + ToastType enum 常量 Default/Bottom/Center/Top 不是字符串 + ShowToastOptions.duration 单位 10ms 不是 1ms + showDialog 回调 onAccept/onCancel 不是 onConfirm/onAbort + DialogButton.action 不是 onClick 无 bgColor + showActionMenu buttons 上限 6 不是无限
• 鸿蒙 6.1 API 23 开发坑系列篇 11「@ohos.measure 文本测量坑」——measureText 返回 number 不是 TextMetrics + measureTextSize 返回 SizeOptions 多行测量 + MeasureOptions 必填 textContent 不是 text + fontSize string 须带 fp/px 单位 + MeasureText static 废弃迁移 getMeasureUtils 实例方法
• 鸿蒙 6.1 API 23 开发坑系列篇 12「@ohos.curves 动画曲线坑」——init/cubicBezier/spring/steps 废弃返回 string 迁移 initCurve 等返回 ICurve + ICurve interface 不能 new 用工厂函数造实例 + Curve enum 常量 Linear/Ease 等不是字符串 enum 值数字 + cubicBezierCurve 四 number 不是 cubic-bezier 字符串 + springCurve 四 number damping 越大震动越小 + customCurve 回调 fraction [0,1] 返回必须 [0,1]（本文）