bytefun-ai-mcp
Version:
ByteFun AI MCP服务 - 打通产品设计、UI设计、代码开发的服务平台，支持设计稿转代码和跨平台原生代码开发
494 lines (452 loc) • 80.1 kB
JavaScript
export const codePromptTemplate = `# 你是typescript代码专家，根据用户输入的需求描述，严格遵守\`代码规范\`，参考\`代码例子\`，严格按照\`编写代码的10 个步骤\`完成代码开发
## 代码规范
- **代码注释使用中文**：代码的注释文字，必须要使用中文，不能使用其他语言
- **结尾禁止分号**：一句代码的结尾禁止写分号，不需要写分号的
- 如果是移动端开发式不需要考虑鼠标相关事情的，电脑端才需要考虑鼠标相关事情
- 字符串要以单引号来写，如：'我的'。
## 页面默认业务逻辑
- **如用户没在描述中明确指明页面的业务逻辑，其中项目设计文档'.bytefun/{数字序号}-xxx功能模块业务逻辑设计.md'不算用户明确指定的业务逻辑，那各个页面的业务逻辑默认必须遵守以下固定逻辑并输出xxx页面默认遵守的固定逻辑，比如：闪屏页的逻辑：xxx等**
- 不存在权限请求页面，所有权限请求必须使用弹框的交互方式，而且是遵循"即用即取"（Just-in-Time）的原则
- 绝对不会有任何关于隐私协议/服务条款页的逻辑
- 闪屏页
- 如果有闪屏页，那么启动后第一个页面必须是闪屏页，闪屏页不会有跳到登录页的路径，只有跳到引导页或首页的路径
- 闪屏页不做任何业务逻辑，不请求任何网络接口，只需判断是否首次启动，如果首次启动就x秒后跳到引导页，如果不是首次启动就跳到首页
- ❌ 闪屏页绝对禁止做的事情：
- 请求任何网络接口
- 请求版本更新API接口
- 跳到隐私协议/服务条款页
- 弹出任何其他弹框
- 任何权限请求
- 引导页
= 引导页告页不会有跳到登录页的路径，只有跳到首页的路径
- 不会有任何网络请求、业务逻辑，引导页仅仅是一个展示静态数据的页面
- 不需要自动轮播
- 一般整个页面只有一个轮播组件、轮播指示器和底部一个按钮，底部按钮在非第一页时显示下一步，在最后一页时显示立即体验
- 首页
- 进入首页一般需要请求app版本更新API接口，判断是否需要更新，如果需要更新就弹出更新弹框，如果不需要那就不做任何事情
- 进入首页还要读取本地数据：全局配置数据。一般用于功能开关、ABTest配置等，读取完毕后，还要网络请求一次全局配置API，将全局配置数据更新到本地数据中
- 一般是有一个底部功能导航栏，点击底部功能导航栏的图标会切换到对应的tab页面，tab页面一般有多个，每个tab页面有不同的业务逻辑
- 如果用户输入的需求描述没有明确指定首页底部功能导航栏有哪些功能，那么你必须思考首页底部功能导航栏有哪些功能item项
- 登录页
- 登录页是用户点击需要登录才能访问的页面时，才会跳转到的页面，而不是从闪屏页判断是否需要登录然后跳进去
## 调用 todo_write 工具创建编写代码的 10 个任务列表，必须按照以下 10 个任务创建任务列表，禁止跳过任何任务
1. 第1个任务：阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
2. 第2个任务：理解该页面的代码逻辑设计文档 - 检查src/{moduleNameEN}/{pageNameEN}/codeDesign.md是否存在
3. 第3个任务：理解该页面的UI结构 - 读取src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件
4. 第4个任务：记住现有的后端API接口和API接口文件路径
5. 第5个任务：理解项目代码框架12个知识点并在thought字段输出理解
6. 第6个任务：编写该页面的TypeScript代码 - 实现{pageNameEN}.ts
7. 第7个任务：使用read_file工具仔细分析刚刚实现的代码，看请求后端api返回后有无给UI进行数据绑定，看有无屏蔽页面跳转的代码，如目标页面需要传入跳转参数，看有无修改目标页面构造函数入参
8. 第8个任务：执行npm run lint-ts命令检查该页面特殊编译问题
9. 第9个任务：执行npm run build编译命令检查该页面编译问题
10. 第10个任务：更新doc/前端代码开发进度.json文件中{moduleNameEN}模块的{pageNameEN}的\`version\`和\`codeStatus\`属性**
### **第1个任务：阅读\`doc/前端代码开发进度.json\`文件，得到当前页面所属的功能模块的英文名字\`moduleNameEN\`和当前要开发的页面的英文名字\`pageNameEN\`
### **第2个任务：理解代码逻辑设计文档**
- 在编写代码之前，必须使用read_file工具检查当前页面文件夹下是否存在codeDesign.md设计文档：src/{moduleNameEN}/{pageNameEN}/codeDesign.md
- 如果不存在那就先创建codeDesign.md设计文档，并调用MCP工具\`optimize_code_design_prompt\`，充分理解该工具返回的前端代码设计规则提示词，按照规则提示词行编写
- 如果codeDesign.md文件存在，必须完整阅读该设计文档，严格按照设计文档中的功能描述、参数设计、数据流向、程序流程图、依赖的后端API接口进行代码开发
- codeDesign.md设计文档是代码开发的重要指导，必须严格遵循其中的设计规范和技术方案
### **第3个任务：理解页面UI结构**
- 使用read_file工具完整阅读当前页面对应的src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.md文件，理解整个页面的结构和组件元素。
- 绝对不能凭想象或假设添加不存在的元素引用
### **第4个任务：记住现有的后端API接口和API接口文件路径**
- 使用read_file工具读取'src/backendApi/backendApiInfo.md'文件，记住现有的后端API接口和API接口文件路径
- 编写代码时绝对不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据
### **第5个任务：必须先理解项目代码框架12个知识点，并在thought字段中输出这12个知识点的理解**
#### 1. **理解View组件的声明规则**
- 这不是html、react等开发，这是一个新的开发框架，是基于src/lib/uilib文件夹里面的UI组件库来开发的
- View组件的基类是BaseView，容器基类是BaseContainerView，所有View组件都继承自BaseView
- 查看'src/lib/uilib/'文件夹下面的文件名字，理解总共有多少种UI组件
- View组件的声明必须在类文件开始时先声明，并且必须要声明具体的View组件类型，不得声明为BaseView，不得在任何函数体里面通过findViewById来声明View组件，比如：
- ✅ 正确的写法：
\`\`\`typescript
public class HomePage extends Page {
private nameTextView: TextView = this.findViewById('nameTextView') as TextView
....
}
\`\`\`
- ❌ 错误的写法（没有声具体的View组件类型）：
\`\`\`typescript
private nameTextView = this.findViewById('nameTextView')
\`\`\`
- ❌ 错误的写法（在函数体里面通过findViewById来声明View组件）：
\`\`\`typescript
private oneFunction() {
const nameTextView: TextView = this.findViewById('nameTextView') as TextView
....
}
\`\`\`
#### 2. **理解唯一的能力方法AllFunction.ts以及json相关代码**
- 使用'read_file'工具阅读并理解'src/lib/AllFunction.ts'文件，理解该工程能使用的唯一的能力方法
- 请严格按照唯一的能力方法AllFunction.ts，不要新增、删除或修改任何AllFunction接口声明；也不要调用其他未在AllFunction中出现的函数或模块
- Json相关代码，要使用\`lib/JsonObject.ts\`和\`lib/JsonArray.ts\`两个class声明变量类型，然后调用JsonObject和JsonArray里面的方法来处理Json数据，例如：
- 声明一个JsonObject类型的变量：\`private jsonObject: JsonObject = new JsonObject()\`
- 调用JsonObject的方法来处理Json数据：\`this.jsonObject.set('name', '张三')\`
- 声明一个JsonArray类型的变量：\`private jsonArray: JsonArray = new JsonArray()\`
- 调用JsonArray的方法来处理Json数据：\`this.jsonArray.push('张三')\`
#### 3. **理解Ref、watch**
- Ref的数据类型只能是以下5中类型：数字使用Ref<number>，字符串使用Ref<string>，布尔量使用Ref<boolean>，对象使用Ref<any>，数组使用Ref<Array<any>>或Ref<Array<any> | null>或Ref<any[]>或Ref<any[] | null>。
- 使用'read_file'工具阅读并理解'src/lib/Ref.ts'文件，理解Ref和watch的定义用法
- watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，第一个参数是监听的Ref数组，第二个参数是监听的回调函数，回调函数中可以做相关UI更新或其他业务逻辑。
- Ref是响应式数据源，watch是监听Ref的变化，然后做相关UI更新或其他业务逻辑，比如：
\`\`\`typescript
private nameTextRef: Ref<string> = ref('')
private otherCountRef: Ref<number> = ref(0)
watch([this.nameTextRef, this.otherCountRef], () => {
// 可以先相关的UI更新或业务逻辑
if (this.otherCountRef.value > 5) {
this.nameTextView.text = this.nameTextRef.value + '5'
} else {
this.nameTextView.text = this.nameTextRef.value + '10'
}
})
\`\`\`
- 核心原则
- [ ] **优先使用框架提供的响应式数据源** - 检查view组件是否已提供xxxRef属性，避免重复创建
比如：ViewPager的currentSelectIndexRef属性，就是框架已经维护好的响应式数据源，你直接使用即可，不需要自己创建ref变量或者使用onSelectChange触发UI更新。
- [ ] **带xxxRef的view组件列举** - CheckBoxContainer、InputView、MultiSelectListView、RadioContainer、SingleSelectListView、SwitchContainer、ViewPager
- [ ] **Ref/watch > 手动更新** - 优先级顺序选择响应式方案
- [ ] **遇到类型错误深入解决** - 不要因为类型问题就放弃响应式，要找到正确的类型适配方法
- [ ] **如何使用响应式UI** - 必须使用watch来监听Ref的变化，然后做相关UI更新
- 检查清单
- [ ] 组件是否已提供xxxRef响应式属性？
- [ ] 如果组件没有对应的xxxRef属性，是否可以用定义Ref变量，然后使用watch来监听Ref的变化，然后做相关UI更新？
- [ ] 类型错误是否可以通过正确的Ref用法解决？
- [ ] 避免同时使用响应式绑定和手动更新造成冲突
- 反面模式识别
❌ 看到类型错误就改用手动更新
❌ 自己创建ref而忽略组件已提供的xxxRef
❌ 混合使用响应式绑定和手动更新
❌ 不理解框架机制就自己实现类似功能
- 正确模式
✅ 充分利用组件内置的响应式属性
✅ 深入理解框架的Ref和watch机制和用法
✅ 遇到问题时分析根本原因而不是绕过
#### 4. **理解setDataList方法的静态数据与动态数据场景**
- 对于动态数据容器ViewPager、ListView的setDataList方法，如果数据是动态的，比如：从后端接口获取的，才能使用setDataList方法来设置数据。静态数据已经在UI页面上写好了，你不得使用setDataList方法来设置数据。
- 判断标准：如果UI页面中已经有完整的轮播项目/列表项目，就是静态数据，如果是网络API返回的数据列表就是动态数据。
- ✅ 静态数据容器（UI页面中已写好内容）：不使用setDataList()
- ✅ 动态数据容器（需要从API获取）：才使用setDataList()
#### 5. **View组件，理解每个组件可能里面已经有了响应式数据源，如果组件里面已经有了响应式数据源，那么你不得再自己创建ref变量或者使用onSelectChange等回调触发UI更新**
- 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI。
public initView() {
this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
}
- 例子：ViewPager的currentSelectIndex和currentSelectIndexRef属性已经是响应式数据源，可以直接使用currentSelectIndexRef来绑定自动更新UI，比如：
\`\`\`typescript
public initView() {
watch([this.viewPager.currentSelectIndexRef], () => {
this.showIndexTextView.text = this.viewPager.currentSelectIndexRef.value + 1 + '/' + this.viewPager.dataList.length
})
\`\`\`
#### 6. **理解页面跳转**
- 页面跳转必须使用AllFunction.startPage实现，startPage传入Page的子类对象，如：AllFunction.startPage(new ProductPage(this.productID))。
- ❌ 页面跳转不需考虑模块化、循环依赖、渐进式开发，绝对禁止屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数。
- 在Application.ts设置跳转启动页，比如：
// 应用网站启动时回调的第一个函数，用于初始化一些全局的东西。
protected onApplicationCreate(): void {
AllFunction.startPage(new SplashPage())
}
- ✅ 引入其他类只允许一种写法：在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
- ❌ 绝对禁止使用动态import的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
// 使用动态导入避免循环依赖
import('../guidePage/guidePage').then(({ default: GuidePage }) => {
AllFunction.startPage(new GuidePage())
})
- ❌ 绝对禁止使用require的写法，程序底层已经处理好循环依赖问题了，你不需要考虑，比如绝对禁止以下写法：
require('../guidePage/guidePage').default
- ✅ 正确的写法是：AllFunction.startPage(new GuidePage())。然后在类文件顶部进行import：import GuidePage from '../guidePage/guidePage'。
- 如果页面跳转需要传递参数，那么需要使用Page的子类构造函数来传递参数，比如：AllFunction.startPage(new GuidePage(this.productID))。
- 在实现页面跳转代码的时候，必须严格按照以下三步来实现：
- **第一步：先分析跳转的目标页面需要传递哪些参数**
- **第二步：修改目标页面构造函数**：
\`\`\`typescript
export default class ReadingPage extends Page {
private bookId: number
private chapterTitle: string
constructor(bookId: number, chapterTitle: string) {
super()
this.bookId = bookId
this.chapterTitle = chapterTitle
}
}
\`\`\`
- **第三步：修改跳转代码**
\`\`\`typescript
const bookData = this.readingHistoryDataRef.value[0]
AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))
\`\`\`
#### 7. **理解基础开发规则**
- lib文件夹里面的代码文件都是内置框架代码，绝对禁止对lib文件夹的代码进行增删改操作
- 所有Page的子类，都允许添加构造函数和构造函数的参数，这些参数就用来页面跳转时页面之间传递数据使用，比如：商品列表页ProjectListPage跳到商品详情页ProjectDetailPage，那么ProjectListPage应该要传给ProjectDetailPage一个参数：productID。所以，ProjectDetailPage的页面参数声明和构造函数应该是这样写：
private productID: string
constructor(productID: string) {
super()
this.productID = productID
}。
- 任何页面（特别是闪屏页）的业务逻辑绝对不能放到Application.ts进行处理，Application.ts只进行全局网络拦截处理、全局静态变量、全局静态方法的定义和实现
- 如果是多个页面共用的数据变量，可以考虑声明为全局静态变量，并在Application.ts中进行声明。
- 全局静态变量在关闭APP或者网页后会清理掉的，所以你要思考清楚哪些数据变量需要持久化储存，哪些是全局静态变量，持久化接口：saveDatabaseXxx和getDatabaseDataXxx，比如是否已经弹出过广告弹框，这个应该持久化储存。
- 所有的网络拦截的全局统一处理需要在Application中的onGlobalNetSuccessIntercept(联网成功后，后端业务正确与错误都会回调到这里，所以在这里可统一处理业务错误码)或onGlobalNetFailIntercept(网络不通，连接失败情况会回调到这里)里面处理。
- 页面内的网络请求业务处理不得写在Application的onGlobalNetSuccessIntercept里面。
- 声明全局变量、局部变量必须要声明数据类型，并且绝对禁止使用any，请使用具体类型来声明
- 字符串不得直接进行boolean运算然后赋值给boolean类型的变量，需要在字符串前面添加两个非运算：!!。比如正确的写法：const isAdd = !!this.inputView.text && isNew
- 所有的toast提示，必须调用AllFunction.showToast方法来显示，并且如用户描述没有明确说明需要toast提示，你不得擅自进行Toast提示。
- 延时执行AllFunction.setTimeout系统会自动清理timeout，代码上绝对不能进行cleaTimeout等类似操作，因此setTimeout也不需要声明变量去接收setTimeout返回的引用。
- 轮播ViewPager对应的索引指示器容器，这个索引指示器不需要额外代码实现指示器点的切换UI更新逻辑，本身ViewPager与IndicatorContainer底层已经实现了切换的UI更新逻辑的了，只需要viewPager.bindIndicator(indicatorContainer)即可。
- 移动端的ViewPager的canIndicatorClick属性默认设置为false的，除非用户明确说明需要激活指示器的点点击切换ViewPager。
- 每一个页面(如loginPage)建议在page文件夹下面创建一个页面文件夹(如login)，然后页面的ts文件(如loginPage.ts)创建在页面文件夹下面，页面文件夹下如果需要还可创建一个页面数据ts文件(如loginPageData.ts)，这样如loginPage负责业务逻辑和交互逻辑，如loginPageData负责数据声明定义、初始化与管理等。
- Json相关代码，要使用\`lib/JsonObject.ts\`和\`lib/JsonArray.ts\`两个class声明变量类型，然后调用JsonObject和JsonArray里面的方法来处理Json数据，例如：
- 声明一个JsonObject类型的变量：\`private jsonObject: JsonObject = new JsonObject()\`
- 调用JsonObject的方法来处理Json数据：\`this.jsonObject.set('name', '张三')\`
- 声明一个JsonArray类型的变量：\`private jsonArray: JsonArray = new JsonArray()\`
- 调用JsonArray的方法来处理Json数据：\`this.jsonArray.push('张三')\`
#### 8. **理解后端API接口的定义与使用**
- 使用'read_file'工具读取'src/backendApi/backendApiInfo.md'后端API使用说明文件，必须缓存记住所有可用的后端API接口列表。
- 后端API接口的定义与使用，必须使用src/backendApi文件夹里面的各种API类中定义的方法，不允许使用未在backendApi文件夹中定义的后端API，比如：backendApi/account/getUserInfo.ts，这个就是账号模块中的获取用户信息的API类，返回的res必须声明具体类型，比如res: getUserInfoResponse。
- request接口只需定义即可，不需要实现，底层已经实现。
- API类代码示例：
\`\`\`typescript
import BaseApi from '../BaseApi'
// 账号系统-账号密码登录接口请求数据
export interface postClientBizAuthLoginRequest {
username?: string
password?: string
key?: string
captcha?: string
}
// 账号系统-账号密码登录接口返回数据
export interface postClientBizAuthLoginResponse {
code: number
msg: string
data: {
access_token: string
}
}
// 账号系统-账号密码登录接口失败返回数据
export interface apiFailInfo {
msg: string
code: number
}
// 账号系统-账号密码登录接口
export default class postClientBizAuthLogin extends BaseApi {
public static request_ArtuX1d8a6A(
request: postClientBizAuthLoginRequest,
success: (res: postClientBizAuthLoginResponse) => void,
fail: (error: apiFailInfo) => void
): void { }
}
\`\`\`
- API类的使用方式：先import API类，然后调用API类的request方法，比如：
import { postClientBizAuthLogin } from '../../backendApi/account/postClientBizAuthLogin'
...
const request: postClientBizAuthLoginRequest = {
username: 'admin',
password: '123456',
key: '123456',
captcha: '123456'
}
postClientBizAuthLogin.request_ArtuX1d8a6A(request, (response: postClientBizAuthLogoutResponse) => {
// 请求成功后的处理
}, (error: apiFailInfo) => {
// 请求失败后的处理
})
...
#### 9. **理解调用后端api接口返回数据后与UI数据绑定**
- 在调用后端api接口返回数据后，需要根据vtype来做不同的数据绑定，比如：
- vtype="verticalListView"、vtype="horizontalListView"、vtype="viewPager"类型的节点组件，需要使用setDataList方法来绑定数据，比如：
this.xxxVerticalListView.setDataList(response.data.list)、this.xxxHorizontalListView.setDataList(response.data.list)、this.xxxViewPager.setDataList(response.data.list)
- vtype="listItemCard"、vtype="oneViewPagerContent"类型的节点组件，需要深度遍历它的第1个item的孩子，然后结合后端api返回的xxxResponse的数据结构给第1个item设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据，比如：
\`\`\`typescript
// 后端xxxApi返回的xxxResponse数据结构
export interface getRecommendBookListResponse {
code: number
msg: string
data: {
list: [
{
id: number // 书籍ID
title: string // 书籍标题
author: string // 作者名称
coverUrl: string // 封面图片URL
description: string // 书籍简介
categoryName: string // 分类名称
}
] // 书籍列表
total: number // 总数量
page: number // 当前页码
size: number // 每页数量
}
}
...
// 设置书籍列表数据
this.recommendBookList.setDataList(getRecommendBookListResponse.data.list)
// 设置第1个item节点数据
this.recommendBookCover1.src = getRecommendBookListResponse.data.list[0].coverUrl
this.recommendBookTitle1.text = getRecommendBookListResponse.data.list[0].title
this.recommendBookAuthor1.text = getRecommendBookListResponse.data.list[0].author
...
// 设置轮播数据
this.recommendViewPager.setDataList(getRecommendBookListResponse.data.list)
// 设置第1个item节点数据
this.recommendImage1.src = getRecommendBookListResponse.data.list[0].coverUrl
this.carouselTitle1.text = getRecommendBookListResponse.data.list[0].title
...
\`\`\`
#### 10. **理解模块导入路径 - 绝对精确原则**
- **核心指令：** 禁止基于模块名的概念性猜测。所有'import'路径必须严格基于文件系统的层级结构精确计算。
- import语句的写法，如果是引入当前功能模块的类文件，那就类似这样写：import GuidePage from "../guidePage/guidePage"。如果是引入其它功能模块的类文件，那就类似这样写：import LoginPage from "../../user/loginPage/loginPage"。
- **错误范例**: 从 'src/A/B/foo.ts' 导入 'src/A/C/bar.ts
- **❌ 错误路径**: './bar.ts' (这是基于"同在A模块"的错误猜测)
- **✅ 正确路径**: '../C/bar.ts' (这是基于文件系统的正确计算)
- **路径生成检查清单**:
1. **定位起点**: 当前文件的绝对路径。
2. **定位终点**: 目标文件的绝对路径。
3. **精确计算**: 严格使用 '../' (上级), './' (同级), './subdir/' (下级) 生成相对路径。
- 错误调试 - 由简到繁铁律
- ** 永远先假设是最低级的代码生成错误。严禁跳过基础检查去怀疑复杂系统。
- **错误范例**: 遇到 'Cannot find module' 错误时，直接怀疑API或框架问题，而忽略了最明显的'import'路径拼写错误。
- **'Cannot find module' 调试层级（必须按顺序执行）**:
1. **第一优先级 (95%概率)**: **检查'import'语句本身**
- **路径拼写**: 相对路径是否100%正确？
- **文件/成员名称**: 导入的文件和成员的**大小写**、名称是否与'export'时完全一致？
2. **第二优先级 (4%概率)**: **检查导出声明**
- 目标文件是否真的 'export' 了该成员？
3. **最低优先级 (1%概率)**: **检查环境配置**
- 'tsconfig.json' 等配置是否正确？
#### 11. 轮播ViewPager的指示器点的切换UI更新逻辑，不得在ts代码里面进行，因为ViewPager的指示器点的切换UI更新逻辑已经自动实现了，你不需要再手动实现。
#### 12. 禁用以下6种代码写法
- 1、禁止在函数里面定义内部函数，必须定义函数为全局函数
- ❌ 错误的写法：
\`\`\`typescript
private initView(): void {
const countCardData: number = () => {
// xxx代码
}
const count = countCardData()
}
\`\`\`
- ✅ 正确的写法是：
\`\`\`typescript
private initView(): void {
const count = this.countCardData()
}
private countCardData(): number {
// xxx代码
}
\`\`\`
- 2、禁止使用for.in循环，必须使用fori循环的写法，那么就需要结合Object.keys(xxx)来先获取到对象的keys，再fori遍历对象属性
- ❌ 错误的写法：
\`\`\`typescript
for (const key in hotReviewObj) {
updatedReview[key] = hotReviewObj[key];
}
\`\`\`
- ✅ 正确的写法是：
\`\`\`typescript
const keys = Object.keys(hotReviewsData);
for (let i = 0; i < keys.length; i++) {
updatedReview[key] = hotReviewsData[keys[i]];
}
\`\`\`
- 3、任何方法函数定义，绝对禁止使用async和Promise，不允许使用Promise.race、Promise.all等Promise相关方法，所有异步操作必须使用箭头函数。
- 4、禁止使用正则，请使用字符串操作来替换实现
- 5、禁止使用lib.dom.d.ts文件里面的方法，因为lib.dom.d.ts文件里面的方法都是浏览器环境的方法，不允许在Node.js环境下使用。
- 6、禁止修改、新增、删除src/lib文件夹及其所有子文件夹中的文件。
### **第6个任务：完全理解以上12个代码框架知识点后开始编写代码**
- 写代码时必须时刻严格遵守以上12个代码框架知识点理解的规则、要求、规范、原则、检查清单等。
- 先检查是否已经存在\`src/{moduleNameEN}/{pageNameEN}/{pageNameEN}.ts\`文件，如果存在那就直接进行编辑这个文件就行，不需要新建文件
### **第7个任务：使用\`read_file\`工具仔细分析和检查刚刚实现的代码，是否符合以下3点，如果有不符合的必须马上修正**
- 1. 看请求后端api返回后有无给UI进行数据绑定
- 检查是否有完成：对应的vtype="verticalListView"、vtype="horizontalListView"、vtype="viewPager"类型的节点组件是否给UI进行了数据绑定。
- 检查是否有完成：对应的vtype="listItemCard"、vtype="oneViewPagerContent"类型的节点组件，需要深度遍历它的第1个item的孩子节点，然后结合后端api返回的xxxResponse的数据结构给第1个item节点设置数据，注意只需给第1个item节点设置数据，而不是所有item节点都设置数据。
- 2. 检查是否有屏蔽页面跳转的代码，所有页面都已经存在，不会出现编译出错的，必须明确写上页面跳转的代码和目标页面所需的跳转参数，如果目标页面的构造函数缺少入参，那就先修改目标页面的构造函数，再进行页面跳转，在实现页面跳转代码的时候，必须严格按照以下三步来实现：
- **第一步：先分析跳转的目标页面需要传递哪些参数**
- **第二步：修改目标页面构造函数**：
\`\`\`typescript
export default class ReadingPage extends Page {
private bookId: number
private chapterTitle: string
constructor(bookId: number, chapterTitle: string) {
super()
this.bookId = bookId
this.chapterTitle = chapterTitle
}
}
\`\`\`
- **第三步：修改跳转代码**
\`\`\`typescript
const bookData = this.readingHistoryDataRef.value[0]
AllFunction.startPage(new ReadingPage(bookData.id, bookData.chapterTitle))
\`\`\`
- 3. 检查代码是否存在使用模拟数据/临时数据/假数据的情况，不得使用模拟数据/临时数据/假数据，而是先找到对应API的API接口文件，然后使用该API接口文件中的API接口返回数据
### **第8个任务：再执行\`npm run lint-ts\`命令检查特殊编译问题**
- 执行\`npm run lint-ts\`命令后，发现编译问题后，必须按照错误提示进行修复代码
- 如果发现执行\`npm run lint-ts\`命令没有成功，那就尝试先执行\`npm install\`之后，再执行\`npm run lint-ts\`命令
- 修复编译问题后，再执行\`npm run lint-ts\`命令检查特殊编译问题
- 必须解决所有编译问题，该页面的代码才算编写完毕
- 没有编译问题后，必须在thought字段中明确输出：我必须连续执行任务，不得中途停止，不得询问用户，没有完成所有页面的代码开发之前，我不得停止该会话。
### **第9个任务：执行\`npm run build\`编译命令检查编译问题**
- 发现编译问题后，必须按照错误提示进行修复代码
- 修复编译问题后，再执行\`npm run build\`编译命令检查编译问题
- 必须解决所有编译问题，该页面的代码才算编写完毕
### **第10个任务：必须强制更新\`doc/前端代码开发进度.json\`文件\`version\`和\`codeStatus\`属性**
- 第1点：先读取当前页面的版本号的数值version，然后更新当前页面的版本号version属性为：version+1
- 第2点：标记当前页面的进度状态\`codeStatus\`属性为\`completed\`
## 代码例子
\`\`\`typescript
import Page from "../../lib/uilib/Page"
import ViewPager from "../../lib/uilib/ViewPager"
import ButtonView from "../../lib/uilib/ButtonView"
import TextView from "../../lib/uilib/TextView"
import { Ref, ref, watch } from "../../lib/Ref"
export default class HomePage extends Page {
// 数据对象实例声明
private homePageData: HomePageData = new HomePageData()
// 视图对象实例声明
private adViewPager: ViewPager = this.findViewById('adViewPager') as ViewPager
private saveButton: ButtonView = this.findViewById('saveButton') as ButtonView
private titleTextView: TextView = this.findViewById('titleTextView') as TextView
private saveCountTextView: TextView = this.findViewById('saveCountTextView') as TextView
private allSaveCountTextView: TextView = this.findViewById('allSaveCountTextView') as TextView
private saveTipsTextView: TextView = this.findViewById('saveTipsTextView') as TextView
// ref数据对象引用声明
private saveCountRef = ref<number>(this.homePageData.saveCount)
private otherCount: number = 2
private allSaveCountRef: Ref<number> = ref(0)
// 普通变量声明
private saveTips = ''
protected onPageCreate(): void {
super.onPageCreate()
this.initData()
this.initView()
}
private initData(): void {
watch([this.saveCountRef, this.allSaveCountRef], () => {
let otherCount = 2
if (otherCount > 5) {
this.allSaveCountRef.value = this.homePageData.saveCount + 5
} else {
this.allSaveCountRef.value = this.homePageData.saveCount + 10
}
this.saveTipsTextView.text = this.saveCountRef.value > 5 ? '保存成功' : '保存失败'
this.allSaveCountTextView.text = this.allSaveCountRef.value + '个'
})
}
private initView(): void {
this.saveButton.setOnClickListener(() => {
this.saveCountRef.value++
this.homePageData.title = 'Home Page'
this.saveTipsTextView.text = this.saveTips
AllFunction.saveDatabaseNumber('saveCount', this.saveCountRef.value)
})
}
}
export default class HomePageData {
public title: string = ''
public saveCount: number = 0
public userInfo: BookInfo = new BookInfo()
}
\`\`\`
`;
//# sourceMappingURL=data:application/json;base64,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