问题描述

页面下拉刷新无响应，拉不动

原因

The edgeEffect value must be EdgeEffect.None


文档链接：https://ohpm.openharmony.cn/#/cn/detail/@ohos%2Fpulltorefresh
另外关联的scroller也需要设置

2.lottie name不能相同

问题描述

从首页跳转到租约页，首页loading消失前，切换到租约页，租约页loading会提前消失。

原因

KeLoadingDialog传入Lottie的name是写死的，从A页面切换到B页面时，A的lottie destroy会导致B的lottie也destroy，提前消失了
解决方案
lottie name随机

3.HTTPS图片连代理加载不出来

装证书或不连代理

鸿蒙端安装证书地址： charlesproxy.com/getssl

4.CustomDialog作为临时变量内部无法关闭

问题描述

CustomDialogController作为临时变量，在弹窗内部无法关闭，controller为undefined

解决方案

dialog作为组件的成员变量
private dialogController: CustomDialogController | null = null;

推荐不依赖UI组件的弹窗方式，类似RPLoadingUtil

5.类型转换不能使用as

问题描述

接口下发的某字段text有时是number类型，有时是string类型
某个方法的入参是string类型，用 text as string 断言为string
运行时 number 会报TypeError crash

原因

解决方案
String(text)

6.关闭H5白名单校验

问题描述

未加过白名单的链接无法打开

解决方案

摇一摇-调试选项-取消使用Web白名单

7.List组件不设置高度滑动不到底

解决方案

layoutWeight(1)可以自适应占满剩余空间父容器尺寸

8.merge分支后changeid为空

git merge –no-f dev-1215 自动生成一个changeid

9.切换分支后清理缓存

ohpm clean
sh lj-clean
ohpm install

10.字号、色值使用常量类

好处:

• 色值：主题色统一修改
• 字号：字号统一修改单位

11.真机调试

需要登录账号 自动签名：https://developer.huawei.com/consumer/cn/doc/harmonyos-guides-V5/ide-signing-V5#section18815157237

12.环境配置

问题描述

1
2
3
4
5
6
7

ERR_PNPM_FETCH_404
Installing dependencies...
 ERR_PNPM_FETCH_404  GET https://repo.huaweicloud.com/repository/npm/@ke%2Frouter-plugin: Not Found - 404
This error happened while installing a direct dependency of /Users/lichang/.hvigor/project_caches/b8db3eae16304d1d8731239702645cb2/workspace
@ke/router-plugin is not in the npm registry, or you have no permission to fetch it.
No authorization header was set for the request.
Error: /Users/lichang/.hvigor/wrapper/tools/node_modules/.bin/pnpm install execute failed.See above for details.

解决方案

配置npm
将下面配置添加到~/.npmrc中，邮箱地址替换为自己的邮箱，//部分保持原样，不要删除

1
2
3
4
5
6
7
8
9

@ke:registry=http://artifactory.intra.ke.com/artifactory/api/npm/npm-mobile-release/
@ohos:registry=https://repo.harmonyos.com/npm/
registry=https://registry.npmmirror.com/
//artifactory.intra.ke.com/artifactory/api/npm/npm-mobile-release/:_password="bW9iaWxlZnVsbDEyMzQ1Ng=="
//artifactory.intra.ke.com/artifactory/api/npm/npm-mobile-release/:username=mobilefull
//artifactory.intra.ke.com/artifactory/api/npm/npm-mobile-release/:email=邮箱地址
//artifactory.intra.ke.com/artifactory/api/npm/npm-mobile-release/:always-auth=true
loglevel=info
strict-ssl=false

参考链接：鸿蒙路由2.0的使用与原理

13.富文本

问题描述

1.Text包裹Span
（1）Span不支持margin、padding、width、height，左右间距只能通过空格来处理，不精准
（2）标签不居中，需求里标签字号比第一个文本字号小，所以高度小，不居中，尝试设置lineHeight（高度不变）和baselineOffset不行（会文字挪上去了，背景不动）
（3)标签无法设置上下间距
2.RichText支持的html标签有限，实现不了

解决方案

标签使用图片，ImageSpan

14.弹窗弹起键盘后，存在空隙

问题描述

CustomDialog中有TextArea，输入时，软键盘顶起CustomDialog，此时，软键盘与CustomDialog之间存在一些空隙。

原因

系统特性：弹窗避让软键盘时，与软键盘之间存在16vp的安全间距。

文档链接：自定义弹窗 (CustomDialog)
参考链接：HarmonyOS CustomDialog弹窗被软键盘顶起后，存在空隙

解决方案

.offset({ y: 16 })

15.Tab里的页面出现不走onShown

问题描述

首页或租约页设置了keNavDestinationLifecycleCallback后，不生效。

原因

走了Tab的keNavDestinationLifecycleCallback

解决方案

方案一：Tab传参给对应页面
方案二：页面根组件onVisibleAreaChange

1
2
3
4
5

.onVisibleAreaChange([0.0, 1], (isVisible: boolean, currentRatio: number) => {
  if (isVisible && currentRatio >= 1.0) {
    this.pageColumnFullyVisible();
  }
})

16.跨页面传值

问题描述

租约页->合同详情-隐藏原因弹窗，隐藏租约后，租约页置空请求入参

解决方案

使用eventHub
租约页订阅事件：
const uiContext = appConfig.appContext.appContext;
// 订阅隐藏租约成功事件
uiContext.eventHub.on(RPLeaseEvent.HIDE_LEASE_SUCCESS, this.hideLeaseSuccessHandler.bind(this));
不用箭头函数时注意this指向
隐藏成功发送事件：
// 隐藏成功
const uiContext = appConfig.appContext.appContext;
uiContext.eventHub.emit(RPLeaseEvent.HIDE_LEASE_SUCCESS, this.order?.orderId ?? ‘’);

17.调试技巧

18.子孙组件传值

可以使用@provider、consumer，极其优雅

19.禁用 fast-forward 合并

问题描述

开发分支有提交记录，相比master有改动，为了合并开发分支上的提交
报错：
! [remote rejected] HEAD -> refs/for/master (no new changes)
error: failed to push some refs to ‘ssh://gerrit.lianjia.com:29418/mobile_harmony/beike_rentplat_module’

解决方案

git merge –no-ff feature-branch
即使可以 fast-forward 合并，也要生成一个合并提交。

20.超出父容器

问题描述

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Column() {
  // 姓名
  Text(agent.name)
    .fontSize($r('app.float.font_size_13'))
    .fontWeight(FontWeight.Medium)
    .maxLines(1)
    .textOverflow({ overflow: TextOverflow.Ellipsis })
    .margin({ top: 1 })

  // 描述
  Text(agent.agentDesc)
    .fontSize($r('app.float.font_size_11'))
    .fontColor($r('app.color.999999'))
    .maxLines(1)
    .textOverflow({ overflow: TextOverflow.Ellipsis })
    .margin({ top: 5 })
}
.alignItems(HorizontalAlign.Start)
.justifyContent(FlexAlign.Start)
.margin({ left: 6 })
.layoutWeight(1)

确保父级 Row() 或 Column() 的子项可以收缩/限制宽度

1

.layoutWeight(1)

让 Column 可被压缩

飞书链接：https://quira9nj56.feishu.cn/docx/KVVfdgUiToMYYdxsz4vcni1mnsc

1.下载安装Ollama

https://ollama.com/download

2.下载运行deepseek-r1

https://ollama.com/library/deepseek-r1:1.5b

1

ollama run deepseek-r1:1.5b

3.局域网访问API

（1）修改监听地址 ~/.zshrc

1
2

# 设置Ollama监听所有网络接口（0.0.0.0表示允许所有IP访问）
export OLLAMA_HOST=0.0.0.0:11434

（2）立即生效

1

source ~/.zshrc

（3）不生效可以用下面这个

1

OLLAMA_HOST=0.0.0.0 ollama serve

可以访问了：http://10.33.158.12:11434/api/tags

意图识别

实现方式

本地部署 DeepSeek 后，要让它能够进行意图识别（例如把“这个房子的租金是多少”映射到“查租金”），有以下几种方式：

1.通过 system 提示词 (Prompt) 设定规则

你可以在 system 提示词中提供指导，告诉 DeepSeek 需要按照你的要求进行意图分类，例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

你是一个经验丰富的专业租赁经纪人，负责识别用户的意图，并返回 JSON 格式的结果。  
你只需要返回 JSON，不要输出其他内容。  

返回格式如下：
{
  "command": "意图名称",
  "text": "简短的回应"
}

意图类别：
- "查租金"：如果用户询问房屋租金、价格或费用相关信息
- "发放优惠券": 如果用户询问房源优惠信息
- "看厨房": 我想看看厨房
- "预约实地带看": 如果用户希望安排看房，想实地看看
- "线上签约": 如果用户想在线签约
- "推荐房源"：如果用户询问还有别的房子可以看吗？有其他推荐吗？

示例：
用户：这个房子的租金是多少？
你应该回复：
{
  "command": "查租金",
  "text": "好的，帮你查一下租金"
}

用户：附近有什么房子出租？
你应该回复：
{
  "command": "推荐房源",
  "text": "我来帮你找附近的房源"
}

用户：我想预约看房
你应该回复：
{
  "command": "预约实地带看",
  "text": "好的，帮你预约看房"
}

用户：有优惠吗？
你应该回复：
{
  "command": "发放优惠券",
  "text": "好的，帮你查看优惠信息"
}

请严格按照 JSON 格式返回，不要输出其他内容。

然后，你在调用 DeepSeek 的时候，把这个 system 提示词加入 messages 参数中，让模型按此规则识别意图。

2.微调 (Fine-tuning)

如果你的需求很稳定，并且你有较多的训练数据（比如用户问题和对应意图的标注数据），可以微调 DeepSeek，让它专门适应你的任务。例如，你可以用类似这样的标注数据：

1
2
3

{"input": "这个房子的租金是多少？", "output": "查租金"}
{"input": "附近有什么房子出租？", "output": "查房源"}
{"input": "我想预约看房", "output": "预约看房"}

然后对 DeepSeek 进行微调，让它更精准地匹配你的业务场景。

3. 使用向量检索（Embedding + 检索）

如果你的意图库是固定的，你可以使用 DeepSeek 的 embedding 模型，把所有的意图示例转换成向量，并存入向量数据库（如 FAISS、Milvus 等）。当用户输入查询时，把它的向量与已有意图的向量匹配，找最相似的意图。

4. 结合规则（正则/关键词匹配）+ LLM

如果意图识别的需求比较简单，你可以先用关键词匹配或正则表达式筛选出明显的意图，再用 LLM 处理复杂情况。例如：
●如果输入中包含“租金”、“价格”，直接返回“查租金”；
●否则，调用 DeepSeek 进行意图识别。

这种方法可以减少 LLM 处理的请求量，提高效率。

选型建议：

如果意图较少，规则清晰 → system 提示词就够了，简单高效。
如果数据多，想优化效果 → 适合微调模型，让它更精准。
如果意图较多，且经常更新 → 适合向量检索方案，灵活扩展。

本地部署DeepSeek-R1 1.5B 效果：

耗时3.84s，结果不稳定。
curl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

curl -X POST "http://10.33.158.12:11434/api/chat" \
     -H "Content-Type: application/json" \
     -d '{
           "model": "deepseek-r1:1.5b",
           "messages": [
             {
               "role": "system",
               "content": "你是一个经验丰富的专业租赁经纪人，负责识别用户的意图，并返回 JSON 格式的结果。\n你只需要返回 JSON，不要输出其他内容。\n\n返回格式如下：\n{\n  \"command\": \"意图名称\",\n  \"text\": \"简短的回应\"\n}\n\n意图类别：\n- \"查租金\"：如果用户询问房屋租金、价格或费用相关信息\n- \"发放优惠券\": 如果用户询问房源优惠信息\n- \"看厨房\": 我想看看厨房\n- \"预约实地带看\": 如果用户希望安排看房，想实地看看\n- \"线上签约\": 如果用户想在线签约\n- \"推荐房源\"：如果用户询问还有别的房子可以看吗？有其他推荐吗？\n\n示例：\n用户：这个房子的租金是多少？\n你应该回复：\n{\n  \"command\": \"查租金\",\n  \"text\": \"好的，帮你查一下租金\"\n}\n\n用户：附近有什么房子出租？\n你应该回复：\n{\n  \"command\": \"推荐房源\",\n  \"text\": \"我来帮你找附近的房源\"\n}\n\n用户：我想预约看房\n你应该回复：\n{\n  \"command\": \"预约实地带看\",\n  \"text\": \"好的，帮你预约看房\"\n}\n\n用户：有优惠吗？\n你应该回复：\n{\n  \"command\": \"发放优惠券\",\n  \"text\": \"好的，帮你查看优惠信息\"\n}\n\n请严格按照 JSON 格式返回，不要输出其他内容。"
             },
             {
               "role": "user",
               "content": "能便宜吗？"
             }
           ],
           "temperature": 0,
           "stream": false,
           "max_tokens": 100
         }'

DeepSeek官网API效果：

耗时9.45s，结果稳定
curl：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

curl -L -X POST 'https://api.deepseek.com/chat/completions' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-H 'Authorization: Bearer sk-e856b3fef50d4da1902b2a41de3c1a10' \
--data-raw '{
  "messages": [
    {
               "role": "system",
               "content": "你是一个经验丰富的专业租赁经纪人，负责识别用户的意图，并返回 JSON 格式的结果。\n你只需要返回 JSON，不要输出其他内容。\n\n返回格式如下：\n{\n  \"command\": \"意图名称\",\n  \"text\": \"简短的回应\"\n}\n\n意图类别：\n- \"查租金\"：如果用户询问房屋租金、价格或费用相关信息\n- \"发放优惠券\": 如果用户询问房源优惠信息\n- \"看厨房\": 我想看看厨房\n- \"预约实地带看\": 如果用户希望安排看房，想实地看看\n- \"线上签约\": 如果用户想在线签约\n- \"推荐房源\"：如果用户询问还有别的房子可以看吗？有其他推荐吗？\n\n示例：\n用户：这个房子的租金是多少？\n你应该回复：\n{\n  \"command\": \"查租金\",\n  \"text\": \"好的，帮你查一下租金\"\n}\n\n用户：附近有什么房子出租？\n你应该回复：\n{\n  \"command\": \"推荐房源\",\n  \"text\": \"我来帮你找附近的房源\"\n}\n\n用户：我想预约看房\n你应该回复：\n{\n  \"command\": \"预约实地带看\",\n  \"text\": \"好的，帮你预约看房\"\n}\n\n用户：有优惠吗？\n你应该回复：\n{\n  \"command\": \"发放优惠券\",\n  \"text\": \"好的，帮你查看优惠信息\"\n}\n\n请严格按照 JSON 格式返回，不要输出其他内容。"
             },
    {
      "content": "能便宜吗？",
      "role": "user"
    }
  ],
  "model": "deepseek-chat",
  "frequency_penalty": 0,
  "max_tokens": 2048,
  "presence_penalty": 0,
  "response_format": {
    "type": "text"
  },
  "stop": null,
  "stream": false,
  "stream_options": null,
  "temperature": 1,
  "top_p": 1,
  "tools": null,
  "tool_choice": "none",
  "logprobs": false,
  "top_logprobs": null
}'

本地部署支持的接口：

1.文本生成接口：

请求方式：POST /api/generate
功能：根据提供的提示词（prompt）生成文本。
请求参数：
●model（必需）：模型名称，例如 deepseek-r1:1.5b。
●prompt（必需）：要生成响应的提示词。
●stream（可选）：是否以流式方式返回响应。

curl示例：

1
2
3
4
5
6
7

curl -X POST http://10.33.158.12:11434/api/generate \
-H "Content-Type: application/json" \
-d '{
  "model": "deepseek-r1:1.5b",
  "prompt": "请用专业经纪人给客户介绍房源的口吻帮我润色下：这是厨房",
  "stream": false
}'

效果：

2.对话接口：

请求方式：POST /api/chat
功能：与模型进行多轮对话。
请求参数：
●model（必需）：模型名称。
●messages（必需）：一个包含对话历史的列表，每个消息包含 role（角色，如 user 或 assistant）和 content（内容）。
●stream（可选）：是否以流式方式返回响应。

curl示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

curl -X POST "http://10.33.158.12:11434/api/chat" \
     -H "Content-Type: application/json" \
     -d '{
           "model": "deepseek-r1:1.5b",
           "messages": [
             {
               "role": "system",
               "content": "你是一个经验丰富的专业租赁经纪人，负责识别用户的意图，并返回 JSON 格式的结果。\n你只需要返回 JSON，不要输出其他内容。\n\n返回格式如下：\n{\n  \"command\": \"意图名称\",\n  \"text\": \"简短的回应\"\n}\n\n意图类别：\n- \"查租金\"：如果用户询问房屋租金、价格或费用相关信息\n- \"发放优惠券\": 如果用户询问房源优惠信息\n- \"看厨房\": 我想看看厨房\n- \"预约实地带看\": 如果用户希望安排看房，想实地看看\n- \"线上签约\": 如果用户想在线签约\n- \"推荐房源\"：如果用户询问还有别的房子可以看吗？有其他推荐吗？\n\n示例：\n用户：这个房子的租金是多少？\n你应该回复：\n{\n  \"command\": \"查租金\",\n  \"text\": \"好的，帮你查一下租金\"\n}\n\n用户：附近有什么房子出租？\n你应该回复：\n{\n  \"command\": \"推荐房源\",\n  \"text\": \"我来帮你找附近的房源\"\n}\n\n用户：我想预约看房\n你应该回复：\n{\n  \"command\": \"预约实地带看\",\n  \"text\": \"好的，帮你预约看房\"\n}\n\n用户：有优惠吗？\n你应该回复：\n{\n  \"command\": \"发放优惠券\",\n  \"text\": \"好的，帮你查看优惠信息\"\n}\n\n请严格按照 JSON 格式返回，不要输出其他内容。"
             },
             {
               "role": "user",
               "content": "能便宜吗？"
             }
           ],
           "temperature": 0,
           "stream": false,
           "max_tokens": 100
         }'

效果：

结果不稳定

3.列出模型

http://10.33.158.12:11434/api/tags
效果：

DeepSeek官网API支持的接口：

https://api-docs.deepseek.com/zh-cn/api/create-chat-completion
https://api-docs.deepseek.com/zh-cn/api/create-completion
https://api-docs.deepseek.com/zh-cn/api/list-models

带上下文的意图

多轮对话放在messages里

1
2
3
4
5
6

messages: [
    {"role": "system", "content": "你是一位乐于助人的助手"},
    {"role": "user", "content": "中国的首都是哪里？"},
    {"role": "assistant", "content": "中国的首都是北京。"},
    {"role": "user", "content": "美国的首都是哪里？"}
]

https://api-docs.deepseek.com/zh-cn/guides/multi_round_chat

响应速度

通常在几秒内返回

Function Calling

Function Calling 让模型能够调用外部工具，来增强自身能力。
示例流程：
●用户：询问现在的天气
●模型：返回 function get_weather({location: ‘Hangzhou’})
●用户：调用 function get_weather({location: ‘Hangzhou’})，并传给模型。
●模型：返回自然语言，”The current temperature in Hangzhou is 24°C.”

注：上述代码中 get_weather 函数功能需由用户提供，模型本身不执行具体函数。
https://api-docs.deepseek.com/zh-cn/guides/function_calling

1
2
3
4
5

<script src="https://cdn.bootcss.com/vConsole/3.2.2/vconsole.min.js"></script>
<script>
    var vConsole = new VConsole();
    console.log('hello world');
</script>

https://www.npmjs.com/package/vconsole

2.iOS上使用display: -webkit-box;子元素之间有间距

1
2

display: -webkit-box;
font-size: 0; /* 消除间隙 */

父元素设置font-size: 0; 子视图重新设置font-size

3.div 包含的文字不展示

1

<div>test</div>

需要设置 font-size

4.iOS 圆角不生效

1
2
3
4
5

overflow: hidden;
border-radius: 12px;
// 兼容iOS圆角不生效
transform: rotate(0deg);
-webkit-transform: rotate(0deg);

5.小程序引入三方库，旧版编译器报错

更换引入方式，使用 import

1
2
3
4

// 原
const SpyClient = require('spy-client/dist/spy-client-basic');
// 新
import SpyClient from 'spy-client/dist/spy-client-basic.esm.js';

6.去掉 iOS 自带的点击效果

1

-webkit-tap-highlight-color: rgba(0, 0, 0, 0);

ios点击出现灰色背景_ios 点击元素出现 背景-CSDN博客

7.Vant 组件缺少样式

vant 版本为2.x.x

按需手动导入样式文件，以 List 为例：

1

import 'vant/lib/list/style';

https://vant-ui.github.io/vant/v2/#/zh-CN/list

8.使用了 pxtorem，判断条件里的 px 也被转换成了 rem

postcss-pxtorem

可以在不期望转换的px后紧跟/* ignore */

1
2
3

@media screen and (min-width 640px/* ignore */) {
   width: 90%;
}

9.z-index 收敛

弹窗、提示等 z-index 收敛到一个文件里方便维护

10.flex 子元素超出父容器

父视图不想设置宽度（写死宽度不太聪明的样子），可以设置 min-width: 0;或 width: 0;

flex弹性布局 子元素内容超出盒子容器宽度问题_flex布局子元素超过页面-CSDN博客

11.设置margin-top为负数，元素遮挡部分背景颜色不生效

需要设置 position: relative

1
2

margin-top: -40px;
position: relative;

12.使用小程序 API 注意最低版本

使用小程序 API 时注意判断版本，例如隐藏页面左上角返回按钮 backButtonHide 最低版本 3.660.1

13.小程序中调试H5

控制台输入命令等

1
2
3

location.reload()
location.href
window.pageData

nvm可以管理node版本，使用homebrew安装nvm后，nvm -v查看版本提示

zsh: command not found: nvm

解决方案

1.使用homebrew安装nvm

1

brew install nvm

2.如果~/.nvm不存在，创建文件夹

1

mkdir ~/.nvm

3.配置环境变量

1
2
3
4

vim ~/.zshrc
export NVM_DIR="$HOME/.nvm"
[ -s "/opt/homebrew/opt/nvm/nvm.sh" ] && \. "/opt/homebrew/opt/nvm/nvm.sh"# This loads nvm
[ -s "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm" ] && \. "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm"# This loads nvm bash_completion

注意：通过homebrew安装的nvm，环境变量里配置的路径跟别的不太一样。

1

source ~/.zshrc

附：终端提示的操作方法

1.跨平台框架如何选型？

1.提升人效

2.抹平差异

跨端框架的技术方向

方向1：偏前端

基于WebView的增强

1.ionic

2.CORDOVA Hybrid框架

3.SONIC 客户端预加载WebView资源

4.小程序（WebView）

5.离线包方案App厂商对Web做的离线包方案

特点：

1.基于WebView渲染，补充了一些原生能力的增强

2.开发生态基于 Web 前端生态

3.想方设法增强Web的用户体验

方向2：偏客户端

基于DSL的Native增强

(DSL:Domain-specific language 领域特定语言是专门针对特定应用程序领域的计算机语言)

1.DinamicX 手淘无障碍框架

2.Tangram 阿里七巧板

3.Jasonette

4.DreamBox

5.MTFlexbox 美团

MTFlexbox首先定义一份跨平台统一的DSL布局描述文件，前端通过“所见即所得”的编辑器编辑产生布局，客户端下载布局文件后，根据布局中的描述绑定JSON数据，并最终完成视图的渲染。

特点：

1.开发生态基于Native，框架设计参考WebView的一些特性

2.自定义DSL来实现跨端与动态化

设计的像React Native

方向3：代码共享 Kotlin Multiplatform

KKM Kotlin Multiplatform Mobile 代码共享

跨端代码 Shared module

壳工程 Android/iOS App

方向4：大终端

基于GPL的Native增强

(GPL: General Public License 通用公共许可证)

1.Native Widget 原生渲染组件

React Native / Hippy 1.0 / Weex 1.0

2.自绘引擎 Flutter

3.基于Flutter的自绘框架

1

webF`，`Kraken`, `Kun`, `Skyline

4.基于系统图形库（Skia(Google出的图形处理引擎) / OpenGL(开放图形库) / Vulkan / Metal）的自绘框架

TDF(Tencent Dynamic Framework), Hippy 3.0, Weex 2.0, MagicBrash, Waft(WebAssembly Framework for Things)

Waft(WebAssembly Framework for Things)

AloT的尝试

1.Android App: 运存太低，性能受限

2.Waft

Waft构成：

1.脚本引擎：WebAssembly

2.渲染引擎：Skia封装

跨端框架的技术要点

应用场景

1.动态化

• 基于WebView的增强
• 基于DSL的Native增强
• 基于GPL的Native增强
• 插件化（Android）
• 利用OC运行时动态化特性（iOS）

2.loT

3.Desktop

4.车机

技术要点

1.脚本引擎

• JS引擎：双引擎（JSCore + V8）、单引擎（Hermes）、单引擎（QuickJS）、单引擎（自研JS引擎）
• DartVM：利用Flutter Engine
• WARM：需要设计DSL和实现渲染引擎

2.渲染引擎

• 基于 Flutter Engine
• 基于系统图形库 Skia / OpenGL / Vulkun / Metal

3. 调试器

Debugger：一种可以让 JavaScript Runtime 进行中断，并可以实时查看内部运行状态的应用

调试协议：

• CDP: Chrome DevTools Protocol
• DAP: Debug Adapter Protocol
• 自建协议：微信小程序早期

4.工程化

• 资源加载方案
• 降级处理
• 版本管理
• 研发模式

2.跨平台框架的共性问题

3.UTS: 纯原生跨平台框架

UTS官方文档：https://uniapp.dcloud.net.cn/tutorial/syntax-uts.html

变量

switch语句

类、函数

框架设计就是追求取舍平衡的过程

uts是对ts的定制，有删有增有重定义

运行时

4.云端一体，跨端之上的最佳实践

改善前后端协同，赋能前端，加速业务

协作模式

协作模式改变，更少代码，更高效率

代码生成

业务抽象schema，一键生成前后端代码

SSR

组件支持SSR，降低SSR门槛

什么是SSR

SSR：Server Side Render 是一种将服务端渲染和客户端渲染结合起来的技术，它可以在服务端生成HTML代码，并将其发送到浏览器端。

SPA：Single Page Application 单页面应用，一般也成为客户端渲染 CSR（Client Side Render）

SPA存在的问题：

• 首屏加载满，加载大量的JavaScript和CSS文件
• SEO不友好，搜索引擎无法直接抓取页面内容
• 内存占用高，会在内存中缓存大量数据

SSR优点：

• 性能好，首屏加载速度快
• 更好的SEO
• 更好的用户体验
• 更易于维护

轮子生态

云端一体轮子，聚焦业务

发起请求增加参数

1

baiduCORS: true,

原因：web化需要开启直连请求，目前只有线上域名开启了直连，测试环境也需要开启，否则可能会报跨域错误

2.生成web化需要改成http

操作步骤：预览-Web态预览-在浏览器中预览，然后在浏览器中的链接把https改为http

原因：线下环境是http的，网址也需要是http，否则会报mix-content错误

3.链接域名需要是*.smartapps.baidu.com 而非*.smartapps.cn

示例：

正确：https://i0wpll.smartapps.baidu.com/sub-others/pages/course-agreement/course-agreement

错误：https://i0wpll.smartapps.cn/sub-others/pages/course-agreement/course-agreement

原因：*.smartapps.cn webmapp/api/v1/check_session 获取登录状态异常，会提示用户未登录

4.链接里的&_swebfr=1需要去掉

链接里的&_swebfr=1需要去掉或改成&_swebfr=22，控制是否带

示例：

正确：https://i0wpll.smartapps.baidu.com/sub-others/pages/course-agreement/course-agreement

错误：https://i0wpll.smartapps.baidu.com/sub-others/pages/course-agreement/course-agreement?_swebfr=0

原因：_swebfr=1会带“在百度APP内打开”回流按钮，如果改为_swebfr=0，跳转链接会跳不过去，UI也可能异常

点击右上角三个点-点击“开发调试”，即可访问域名不支持https 带端口号的线下环境

问题2 体验版怎么查看日志，清除缓存

打开“开发调试”后，点击vConsole，可以查看log，清除storage等

问题3 怎么找页面路径

问题4 子视图的margin-top不生效，变成了父视图的margin-top

1.父视图需要设置overflow: hidden; 子视图margin-top才生效

2.text标签不生效，需要换成view

参考链接：https://developers.weixin.qq.com/community/develop/article/doc/0008860a8a4370fff76c5147656c13

• include 导入的文件能否引用其他组件，生命周期等在哪儿
• 如何强制命中实验，命中不了实验是什么原因
• 扫预览码提示网络问题，请稍后再试
• 展现怎么打点？日志平台实时校验无数据
• 获取嵌套的组件元素rect获取不到
• 组件里设置的文本样式被父组件统一设置的文本样式覆盖
• 滚动到某一位置 滑动后不准确
• 如何实现计算属性
• 首次编译报错 Page is not found in path，刷新后不报错
• 一些规范

问题1：include 导入的文件能否引用其他组件，生命周期等在哪儿

解决方案

可以引入Component，相关属性及方法在父组件上。

问题2：如何强制命中实验，接口命中不了实验是什么原因

可以在页面拼参数 eg：hitEid=11245

命中不了实验可能是获取实验的接口 cookie里的baiduid为空

解决方案

退出登录/重新登录，清缓存，重启IDE

问题3：扫预览码提示网络问题，请稍后再试

解决方案

项目信息-本地配置-校验域名 取消勾选

问题4：展现怎么打点？日志平台实时校验无数据

组件进入可视区域展现打点

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

val: {
    observerList: []
},

attached() {
    this.startObserve();
},

detached() {
    this.stopObserve();
},
methods: {
    /**
     * 开启曝光监听
     */
     startObserve() {
        const isIphoneX = util.getSystemInfoSync().isIphoneX;
        const observer = swan.createIntersectionObserver();
        observer.relativeToViewport({
            bottom: -(isIphoneX ? 34 : 0) - 58
        }).observe(`#question-tag-id`, res => {
            if (res.intersectionRatio > 0) {
                log.send({
                    area: 'emotion-label',
                    action: 'show',
                    'log_version': '2.0',
                    serverId: 16268
                });
                observer.disconnect();
            }
        });
        this.val.observerList.push(observer);
    },

    /**
     * 断开曝光监听
     */
    stopObserve() {
        this.val.observerList.forEach(item => {
            item && item.disconnect();
        });
    },
},

问题5：获取嵌套的组件元素rect获取不到

解决方案

加上.in(this)

1
2
3
4
5
6
7
8
9
10

// 获取标签rect
getRect() {
    let that = this;
    swan.createSelectorQuery().in(this)
    .select(".tag-container")
    .boundingClientRect(function(rect) {
        that.triggerEvent('tagRectChanged', rect);
    })
    .exec();
}

问题6：组件里设置的文本样式被父组件统一设置的文本样式覆盖

解决方案

提高权重

1
2
3

/* 提高权重 */
#question-tag-id .tag-text {
}

问题7：滚动到某一位置 滑动后落点不准确

解决方案

需要监听onPageScroll方法，计算上已滑动的距离 currentScrollTop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

scrollToRelatedContent(){
    const {statusBarHeight, titleBarHeight = 44} = util.getSystemInfoSync();
    const navHeight = statusBarHeight + titleBarHeight;
    let currentScrollTop = this.data.currentScrollTop;
    swan.createSelectorQuery()
    .select(".swan-security-padding-bottom")
    .boundingClientRect(function(rect) {
        swan.pageScrollTo({
            scrollTop: rect.top - navHeight + currentScrollTop,
            duration: 300,
            success: res => {
            },
            fail: err => {
            }
        });
    })
    .exec();
}

问题8：计算属性

解决方案

给属性增加observer，发生改变时调用方法更新其他属性

问题9：首次编译报错 Page is not found in path，刷新后不报错

忽略就行

问题10：一些规范

色值使用小写

建议：color: #3b6fff;

不建议：color: #3B6FFF;

裸眼3D

2.CMMotionManager 概述

用于启动和管理运动服务的对象。

1

class CMMotionManager : NSObject

使用CMMotionManager对象启动报告设备板载传感器检测到的运动的服务。使用此对象接收四种类型的运动数据：

• 加速度计数据，表示设备在三维空间的瞬时加速度。
• 陀螺仪数据，表示围绕设备三个主轴的瞬时旋转。
• 磁力计数据，指示设备相对于地球磁场的方向。
• 设备运动数据，指示与运动相关的关键属性，例如设备的用户启动加速度、其姿态、旋转速率、相对于校准磁场的方向以及相对于重力的方向。该数据由 Core Motion 的传感器融合算法提供。

处理后的设备运动数据给出了设备的姿态、旋转速率、校准磁场、重力方向以及用户赋予设备的加速度。

只为您的应用创建一个 CMMotionManager 对象。此类的多个实例会影响从加速度计和陀螺仪接收数据的速率。

您可以按指定的更新间隔接收实时传感器数据，也可以让传感器收集数据并将其存储以供以后检索。使用这两种方法，当您不再需要数据时调用适当的停止方法 (stopAccelerometerUpdates(), stopGyroUpdates(), stopMagnetometerUpdates(),和 stopDeviceMotionUpdates()) 。

以指定的间隔处理运动更新

为了在特定的时间间隔接收运动数据，app 调用一个“start”方法，该方法采用一个操作队列（OperationQueue的实例）和一个特定类型的block handler 来处理这些更新。运动数据被传递到block handler 中。更新频率由“interval”属性的值决定。

• 加速度计。设置accelerometerUpdateInterval属性以指定更新间隔。调用startAccelerometerUpdates(to:withHandler:) 该方法，传入一个CMAccelerometerHandler类型的block。加速度计数据作为CMAccelerometerData对象传递到block中。
• 陀螺仪。设置gyroUpdateInterval属性以指定更新间隔。调用startGyroUpdates(to:withHandler:) 该方法，传入一个CMGyroHandler类型的块。旋转速率数据作为CMGyroData对象传递到block中。
• 磁力计。设置magnetometerUpdateInterval属性以指定更新间隔。调用 startMagnetometerUpdates(to:withHandler:) 该方法，传递一个CMMagnetometerHandler类型的block。磁场数据作为CMMagnetometerData对象传递到block中。
• 设备运动。设置属性deviceMotionUpdateInterval以指定更新间隔。调用startDeviceMotionUpdates(using:) 或startDeviceMotionUpdates(using:to:withHandler:) 或 startDeviceMotionUpdates(to:withHandler:) 方法，传入一个CMDeviceMotionHandler类型的块。旋转速率数据作为CMDeviceMotion对象传递到block中。

1
2
3
4

CMMotionManager *motionManager = [[CMMotionManager alloc] init];
[motionManager startDeviceMotionUpdatesToQueue:[NSOperationQueue currentQueue] withHandler:^(CMDeviceMotion * _Nullable motion, NSError * _Nullable error) {
    
}];

运动数据的定期采样

为了通过周期性采样来处理运动数据，应用程序调用一个不带参数的“start”方法，并周期性地访问给定类型运动数据的属性所保存的运动数据。这种方法是游戏等应用程序的推荐方法。在一个block中处理加速度计数据会带来额外的开销，并且大多数游戏应用程序只对渲染帧时的最新运动数据样本感兴趣。

• 加速度计。调用startAccelerometerUpdates() 以开始更新并通过读取accelerometerData 属性定期访问CMAccelerometerData 对象。
• 陀螺仪。 调用startGyroUpdates() 以开始更新并通过读取gyroData 属性定期访问CMGyroData 对象。
• 磁力计。调用startMagnetometerUpdates() 以开始更新并通过读取magnetometerData 属性定期访问CMMagnetometerData对象。
• 设备运动。 调用startDeviceMotionUpdates(using:)或startDeviceMotionUpdates()方法开始更新并通过读取deviceMotion属性定期访问CMDeviceMotion对象。该方法（iOS 5.0 中的新方法）允许您指定用于姿态估计的参考框架。

1
2
3
4
5
6
7
8
9

CMMotionManager *motionManager = [[CMMotionManager alloc] init];
motionManager.deviceMotionUpdateInterval = 1/15.0;
if (motionManager.deviceMotionAvailable) {
    [motionManager startDeviceMotionUpdates];
    double x = motionManager.deviceMotion.gravity.x;
    double y = motionManager.deviceMotion.gravity.y;
    double z = motionManager.deviceMotion.gravity.z;
    NSLog(@"x:%f, y:%f, z:%f", x, y, z);
}

CMDeviceMotion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@interface CMDeviceMotion : CMLogItem
// attitude 用于标识空间位置的欧拉角（roll、yaw、pitch）和四元数（quaternion）
@property(readonly, nonatomic) CMAttitude *attitude;
// rotationRate 标识设备旋转速率
@property(readonly, nonatomic) CMRotationRate rotationRate;
// gravity 用于标识重力在设备各个方向的分量，具体值的变化遵循如下规律：重力方向始终指向地球，而在设备的三个方向上有不同分量，最大可达 1.0，最小是 0.0
@property(readonly, nonatomic) CMAcceleration gravity;
// userAcceleration 用于标识设备各个方向上的加速度，可以标识当前设备正在当前方向上减速 or 加速
@property(readonly, nonatomic) CMAcceleration userAcceleration;
// magneticField 用于标识设备周围的磁场范围和精度
@property(readonly, nonatomic) CMCalibratedMagneticField magneticField COREMOTION_EXPORT API_AVAILABLE(ios(5.0));
// heading 用于标识北极方向
@property(readonly, nonatomic) double heading COREMOTION_EXPORT API_AVAILABLE(ios(11.0));
// 传感器位置
@property(readonly, nonatomic) CMDeviceMotionSensorLocation sensorLocation COREMOTION_EXPORT API_AVAILABLE(ios(14.0));
@end

硬件可用性和状态

如果某个硬件功能（例如陀螺仪）在设备上不可用，则调用与该功能相关的启动方法无效。您可以通过检查相应的属性来了解硬件功能是否可用或处于活动状态；例如，对于陀螺仪数据，您可以检查isGyroAvailable或isGyroActive属性的值。

3.实现方式

• 图片分层
• 通过传感器获取偏移角度
• 计算偏移量，更新图片位置

4.核心代码

iOS 实现

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

#import <CoreMotion/CoreMotion.h>
@property (nonatomic, strong) CMMotionManager *motionManager;
static const CGFloat CRMotionDeviceMotionMinimumTreshold = 0.f;
// 采样频率
static const CGFloat CRMotionDeviceMotionUpdateInterval = 0.02;
// 往左偏移角度 45°
static const CGFloat CRMotionDeviceMotionXLFactor = 1.0/(M_PI_4/M_PI_2);
// 往右偏移角度 45°
static const CGFloat CRMotionDeviceMotionXRFactor = 1.0/(M_PI_4/M_PI_2);
// 往下偏移角度 60°
static const CGFloat CRMotionDeviceMotionYBFactor = 1.0/(M_PI/3/M_PI_2);
// 往上偏移角度 45°
static const CGFloat CRMotionDeviceMotionYTFactor = 1.0/(M_PI_4/M_PI_2);
// 左、右偏移位移
static const CGFloat CRMotionDeviceMotionXLimit = 20.0f;
// 上、下偏移位移
static const CGFloat CRMotionDeviceMotionYLimit = 12.0f;

- (void)setData {
    if (self.imgURLs.count > 0) {
        [self startMonitor];
    } else {
        // 停止更新
        [self.motionManager stopDeviceMotionUpdates];
    }
}

- (void)startMonitor {
    if (!_motionManager) {
        _motionManager = [[CMMotionManager alloc] init];
        // 采样频率
        _motionManager.deviceMotionUpdateInterval = CRMotionDeviceMotionUpdateInterval;
    }
    
    // 往左偏移角度 45°
    CGFloat xl = CRMotionDeviceMotionXLFactor;
    // 往右偏移角度 45°
    CGFloat xr = CRMotionDeviceMotionXRFactor;
    // 往上偏移角度 45°
    CGFloat yt = CRMotionDeviceMotionYTFactor;
    // 往下偏移角度 60°
    CGFloat yb = CRMotionDeviceMotionYBFactor;
    CGFloat oy = (M_PI_2/3)/M_PI_2*1.0;
    CGFloat ox = 0*1.0;
    // deviceMotionAvailable:检测硬件是否正常，deviceMotionActive:检测当前 CMMotionManager 是否正在提供数据更新
    if (![_motionManager isDeviceMotionActive] && [_motionManager isDeviceMotionAvailable]) {
        @weakify(self);
        [_motionManager startDeviceMotionUpdatesToQueue:[NSOperationQueue currentQueue]
                                                        withHandler:^(CMDeviceMotion * _Nullable motion,
                                                                      NSError * _Nullable error) {
            @strongify(self);
            double gravityX = motion.gravity.x+ox;
            double gravityY = motion.gravity.y+oy;
            
            // 上、下偏移位移
            CGFloat maximumYOffset = CRMotionDeviceMotionYLimit;
            CGFloat minimumYOffset = -CRMotionDeviceMotionYLimit;
            
            // 左、右偏移位移
            CGFloat maximumXOffset = CRMotionDeviceMotionXLimit;
            CGFloat minimumXOffset = -CRMotionDeviceMotionXLimit;

            if (fabs(gravityX) >= CRMotionDeviceMotionMinimumTreshold) {
                // 计算偏移量
                CGFloat fOffsetX = CRMotionDeviceMotionXLimit*gravityX*xr;
                if (gravityX<=0) {
                    fOffsetX = CRMotionDeviceMotionXLimit*gravityX*xl;
                }
                CGFloat fOffsetY = -CRMotionDeviceMotionYLimit*gravityY*yt;
                if (gravityY<=0) {
                    fOffsetY = -CRMotionDeviceMotionYLimit*gravityY*yb;
                }
                
                if (fOffsetX > maximumXOffset) {
                    fOffsetX = maximumXOffset;
                } else if (fOffsetX < minimumXOffset) {
                    fOffsetX = minimumXOffset;
                }
                if (fOffsetY > maximumYOffset) {
                    fOffsetY = maximumYOffset;
                } else if (fOffsetY < minimumYOffset) {
                    fOffsetY = minimumYOffset;
                }
                
                CGFloat bOffsetX = -fOffsetX;
                CGFloat bOffsetY = -fOffsetY;
                
                if (self.bannerView.scrollView.transform.tx != fOffsetX || self.bannerView.scrollView.transform.ty != fOffsetY) {
                    self.bannerView.scrollView.transform = CGAffineTransformMakeTranslation(fOffsetX, fOffsetY);
                    self.backImageView.transform = CGAffineTransformMakeTranslation(bOffsetX, bOffsetY);
                    self.frontImageView.transform = CGAffineTransformMakeTranslation(bOffsetX,bOffsetY);
                }
            }
        }];
    } else {
        self.bannerView.scrollView.transform = CGAffineTransformMakeTranslation(0, 0);
        self.backImageView.transform = CGAffineTransformMakeTranslation(0, 0);
        self.frontImageView.transform = CGAffineTransformMakeTranslation(0,0);
    }
}

Android 实现

1.注册对应的传感器

1
2
3
4
5
6
7
8

mSensorManager = (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);
// 重力传感器
mAcceleSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
// 地磁场传感器
mMagneticSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

mSensorManager.registerListener(this, mAcceleSensor, SensorManager.SENSOR_DELAY_GAME);
mSensorManager.registerListener(this, mMagneticSensor, SensorManager.SENSOR_DELAY_GAME);

2.通过重力传感器和地磁场传感器，获取设备的偏转角度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
    mAcceleValues = event.values;
}
if (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
    mMageneticValues = event.values;
}

float[] values = new float[3];
float[] R = new float[9];
SensorManager.getRotationMatrix(R, null, mAcceleValues, mMageneticValues);
SensorManager.getOrientation(R, values);
// x轴的偏转角度
values[1] = (float) Math.toDegrees(values[1]);
// y轴的偏转角度
values[2] = (float) Math.toDegrees(values[2]);

3.根据偏转角度执行滑动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

if (mDegreeY <= 0 && mDegreeY > mDegreeYMin) {
    hasChangeX = true;
    scrollX = (int) (mDegreeY / Math.abs(mDegreeYMin) * mXMoveDistance*mDirection);
} else if (mDegreeY > 0 && mDegreeY < mDegreeYMax) {
    hasChangeX = true;
    scrollX = (int) (mDegreeY / Math.abs(mDegreeYMax) * mXMoveDistance*mDirection);
}
// mDegreeX:偏转角度 mDegreeXMin和mDegreeXMax为X轴可发生偏转位移的角度最大值和最小值
if (mDegreeX <= 0 && mDegreeX > mDegreeXMin) {
    hasChangeY = true;
    // mYMoveDistance: Y轴上的最大偏移距离
    scrollY = (int) (mDegreeX / Math.abs(mDegreeXMin) * mYMoveDistance*mDirection);
} else if (mDegreeX > 0 && mDegreeX < mDegreeXMax) {
    hasChangeY = true;
    scrollY = (int) (mDegreeX / Math.abs(mDegreeXMax) * mYMoveDistance*mDirection);
}
smoothScrollTo(hasChangeX ? scrollX : mScroller.getFinalX(), hasChangeY ? scrollY : mScroller.getFinalY());

Android Studio 下载地址：https://developer.android.google.cn/studio
Flutter SDK 下载地址：https://flutter.dev/docs/get-started/install/macos

配置Flutter SDK

添加用户环境变量
打开终端，输入vim ~/.bash_profile,回车，编辑/.bash_profile文件。

1

vim ~/.bash_profile

点击i进入编辑模式。
将如下环境变量加入到用户环境变量中：

1
2
3

export PATH=`pwd`/flutter/bin:$PATH
export PUB_HOSTED_URL=https://pub.flutter-io.cn
export FLUTTER_STORAGE_BASE_URL=https://storage.flutter-io.cn

编辑完成，点击“Esc键，退出insert模式”, 然后输入“:wq”,回车，保存成功。
输入source ~/.bash_profile，让环境变量生效。

输入echo $PATH,查看环境变量，发现添加成功。

输入flutter-h查看是否配置成功。

运行flutter doctor检测环境。

Android Studio 3.6.1 Android sdkmanager tool not found 的问题

问题描述：

执行flutter doctor后提示 Android license status unknown.
执行 flutter doctor --android-licenses后提示
Android sdkmanager tool not found

问题原因：

Android Studio 3.6.1版本没有tools文件夹。sdkmanager是在Android/sdk/cmdline-tools/latest/bin/sdkmanager路径下。

解决办法

找到偏好设置里Android SDK下的隐藏废弃包取消掉，下载废弃的Android SDK Tools（Obsolete）。
Preferences-Appearance & Behavior-System Settings-Android SDK-SDK Tools
把 Hide Obsolete Packages 前边的对勾取消掉。这时候会显示出隐藏的废弃包Android SDK Tools（Obsolete）。勾选上后，点击Apply下载Android SDK Tools。下载完成后问题得以解决。

参考链接：入门: 在macOS上搭建Flutter开发环境 - Flutter中文网

1. 入口方法、变量、常量

1.1 入口方法main方法

1
2
3

void main() {

}

1.2 常量变量

• var 变量
• const 常量
• final 常量

const 与 final区别

final 可以开始不赋值，只能赋值一次；而final不仅有const的编译时常量的特性，最重要的它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化。

2. 数据类型

2.1 字符串类型 String

字符串定义可以用单引号，“” 也可以用‘双引号’，成对出现。

String str1 = ‘this is str1’;

三个单引号（双引号） 可以定义多行字符串

字符串的拼接

1
2
3

print($str1 $str2);

print(str1 + str2);

2.2 数值类型 int double

int

1
2
3
4
5

int a = 123

double b = 23.5

print(a);

double既可以是整型 也可以是浮点型

2.3 布尔类型 bool

1
2
3
4
5

bool flag1 = true;

var l1 = ['aaa','bbb','ccc'];

print(l1.length);

2.4 集合类型 List

1
2
3
4
5
6
7
8
9
10
11
12

var l2 = new List();

l2.add('张三');

print(l2[0]);

var l3 = new List<String>();

l3.add('张三');

print(l3);

2.5 Map类型 Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var person = {

"name":"张三",

"age":20,

"work":["程序员","快递员"]

}

print(person["name"]);

var p = new Map();

p["name"] = "李四";

2.6 类型判断

is 关键字判断类型

3. 算数运算符

3.1 算数运算符

1
2

+ - * / 
~/ 取整

3.2 关系运算符

关系运算符 == != > < >= <=

3.3 逻辑运算符

逻辑运算符 ! && ||

3.4 赋值运算符

赋值运算符 == ??= 从右向左

1
2
3
4
5
6

int b;

b ??= 23; //如果b为空 把23赋值给b

//+= -= *=  /=  ~/=
a += 3;  a = a+3;

3.5 条件表达式

条件表达式 if else switch case

1
2
3
4
5

if() {

}else {

}

三目运算符 ? :

?? 运算符

3.6 类型转换

数值类型转换成String toString()

String转换成int int.parse()

try catch

其他类型转换布尔类型

isEmpty：判断字符串是否为空

NaN not a number isNaN 是否是数值

自增自减 ++ – 在赋值运算中，如果++在前边，先运算后赋值。如果++在后边，先赋值后运算。

1
2
3
4
5
6
7
8
9
10
11

a++;  //a=a+1;

a--; //a = a-1;

var a = 10;

var b = a++;

print(a); //11

print(b)://10

4. 循环语句

4.1 for循环

1
2
3
4
5
6
7

for(int i =1;i<=10;i++) {

 print(i);

}

//先执行print(i) 再执行i++

4.2 while do…while

while(){

}

do{

}while()

4.3 break continue 用法区别

break 跳出当前循环，只能跳出一层循环

continue 跳过当次循环，循环还会继续执行

5. List Set Map

5.1 List

属性

• length
• isEmpty
• isNotEmpty
• reversed 对列表倒序排序

方法

• add(‘桃子’) 增加元素

• addAll() 增加数组里的元素

• indexOf(‘苹果’) 查找数据 查找不到返回-1 找到返回index

• remove(‘西瓜’)

• fillRange 修改

• insert 插入

• insertAll 插入多个

• myList.join(‘’) //list转换成字符串

• str.split(‘-‘) 字符串转换成list

5.2 Set

Set 集合 去重

5.3 Map

常用属性

• keys

• values

• isEmpty

• isNotEmpty

常用方法

• addAll

• remove

• containsValue

5.4 forEach map where any every

1
2
3

myList.forEach((value) {
print("%value");
});

map

1
2
3
4
5

List myList = [1,3,4];
var newList = myList.map((value){
  return value*2;
});
print(newList.toList());//[2,6,8]

where

1
2
3
4
5

List myList = [1,3,4,5,7,8,9];
var newList = myList.where((value){
  return value>5;
});
print(newList.toList());//[7,8,9]

any

1
2
3
4
5

List myList = [1,3,4,5,7,8,9];
var f = myList.any((value){ //只要集合里面有满足条件的就返回true
  return value>5;
});
print(f);//true

every

1
2
3
4
5

List myList = [1,3,4,5,7,8,9];
var f = myList.every((value){ //每一个都满足条件返回true，否则返回false
  return value>5;
});
print(f);//false

6. 函数

方法定义

返回类型 方法名称（参数1，参数2，…） {
方法体
return 返回值；
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void printInfo(){
print('我是一个自定义方法');
}

int getNum() {
var myNum = 123;
return myNum;
}

void main() {
print('');
}

var n = getNum();
print(n);

List getList() {
  return ['111','222','333'];
}

可选参数，默认参数

1
2
3
4
5
6
7
8

//可选参数
String printUserInfo(String username,[String sex = '男',int age]) {//[可选参数]
  if (age != null) {
    return "姓名：$username---年龄：$age";
  }
  return "姓名：$username---年龄保密";
}
print(printUserInfo("张三",20));

命名参数

1
2
3
4
5
6
7

String printUserInfo(String username,{String sex = '男',int age}) {
  if (age != null) {
    return "姓名：$username---年龄：$age";
  }
  return "姓名：$username---年龄保密";
}
print(printUserInfo("张三",age:20));

方法当做参数

1
2
3
4
5
6
7
8
9
10
11
12

var fn = (){
  print('我是一个匿名方法');
}
fn();

fn1() {
  print('fn1');
}
fn2(fn) {
  fn();
}
fn2(fn1);

箭头函数(只能写一行)

1
2
3
4
5
6
7

List list = ['苹果','香蕉','西瓜'];
//常规写法
list.forEach((value){
print(value);
});
//箭头函数
list.for((value)=>print(value));

1
2
3
4
5
6
7
8
9
10
11

List list = [4,1,2,3,4];
//常规写法
var newList = list.map((value){
  if (value > 2) {
    return value*2;
  }
  return value;
});
//箭头函数
var newList = list.map((value)=>value>2?value*2:value);
print(newList.toList());

匿名方法

1
2
3
4

var printNum = (){
  print(123);
};
printNum();

自执行方法

1
2
3
4

((int n){
print(n);
print('我是自执行方法');
})();

方法的递归

1
2
3
4
5
6
7
8
9
10

var sum = 1;
fn(n) {
  sum *= n;
  if (n==1) {
    return;
  }
  fn(n-1);
}
fn(5);
print(sum);

闭包

常驻内存，不污染全局

1.全局变量特点：全局变量常驻内存、全局变量污染全局

2.局部变量特点：不常住内存会被垃圾机制回收、不会污染全局

1
2
3
4
5
6
7
8
9
10
11

fn() {
  var a = 123; /*不会污染全局 常驻内存*/
  return() {
    a++;
    print(a);
  };
}
var b = fn();
b(); //124
b(); //125
b(); //126

7. 类

默认构造函数 命名构造函数

默认构造函数只能定义一个
命名构造函数可以定义多个

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class Person{
String name;
int age;
  //默认构造函数
  Person(String name,int age) {
    this.name = name;
    this.age = age;
    print('这是构造函数里面的内容，这个方法在实例化的时候触发');
  }
  //默认构造函数简写 Person(this.name,this.age);
  Person.now(){
    print('我是命名构造函数');
  }
void getInfo() {
print("$name---$age");
print("${this.name}---${this.age}");
}
  void setInfo(int age) {
    this.age = age;
  }
}
void main() {
  var p1 = new person('张三',20);
  print(p1.name);
  p1.setInfo(28);
}

私有属性、私有方法

使用_把一个属性或者方法定义成私有。需要把类抽离成一个文件

getter setter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Rect {
  num height;
  num width;
  Rect(this.height,this.width);
  get area{
    return this.height*this.width;
  }
  set areaHeight(value) {
    this.height = value;
  }
}
void main(){
  Rect r = new Rect(10,4);
  r.areaHeight = 6;
  print("面积:${r.area}");
}

类的初始化列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Rect {
  int height;
  int width;
  Rect():height=2,width=10 {
    print("${this.height}---${this.width}");
  };
  get area{
    return this.height*this.width;
  }
  set areaHeight(value) {
    this.height = value;
  }
}
void main(){
  Rect r = new Rect();
  print("面积:${r.area}");
}

类中的静态成员

1.使用static关键字来实现类级别的变量和函数

2.静态方法不能访问非静态成员，非静态方法可以访问静态成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Person {
  static String name = '张三';
  int age = 20;
  static void show() {
    print(name);
  }
  void printInfo() { /*非静态方法可以访问静态成员以及非静态成员*/
    print(name); //访问静态属性
    print(this.age); //访问非静态属性
    show();//调用静态方法
  }
  static void printUserInfo() {//静态方法
    print(name);//静态属性
    show();//静态方法
    
  }
}
main() {
  print(Person.name);
  Person.show();
}

对象操作符

? 条件运算符

as 类型转换

is 类型判断

.. 级联操作（连缀）

? 条件运算符

1
2
3
4
5
6
7
8
9
10
11
12

class Person {
  String name;
  num age;
  Person(this.name,this.age);
  void printInfo() {
    print("${this.name}---${this.age}");
  }
}
main() {
  Person p;
  p?.printInfo();
}

as 类型转换

1
2
3
4

var p1;
p1 = '';
p1 = new Person('张三',20);
(p1 as Person).printInfo();

.. 级联操作

1
2
3
4
5

Person p1 = new pERSON('张三',20);
p1.printInfo();
p1..name = "李四"
  ..age = 30
  ..printInfo();

继承 extends

1
2
3
4
5
6
7
8
9
10
11

class Web extends Person {
  String sex;
Web(String name,num age,String sex) : super(name, age) {
    this.sex = sex;
  }
  //覆写父类的方法
  @override
  void printInfo() {
    print("姓名:${this.name}---年龄:${this.age}");
  }
}

抽象类

抽象类：主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口。

抽象方法 没有方法体的方法

• 子类必须实现
• 抽象类不能被实例化

1
2
3
4
5
6
7
8
9
10

//抽象类
abstract class Animal {
  eat(); //抽象方法
}
class Dog extends Animal {
  @override
  eat() {
    return null;
  }
}

多态

允许将子类类型的指针赋值给父类类型的指针，同一个函数调用会有不同的执行结果。

子类的实例赋值给父类的引用。

多态就是父类定义一个方法不去实现，让继承他的子类去实现，每个子类有不同的表现。

1
2
3
4

Animal d = new Dog();
d.eat();
Animal c = new Cat();
c.eat();

接口

使用抽象类定义接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

abstract class Db { //当做接口 接口：就是约定、规范
  String uri;
  add();
  save();
  delete();
}
class Mysql implements Db {
  @override
  String uri;
  @override
  add() {
    
  }
  @override
  delete() {
    
  }
  @override
  save() {
    
  }
}

extends抽象类和implements的区别：

1.如果要复用抽象类里面的方法，并且要用抽象方法约束子类的话就用extends继承抽象类。

2.如果只是把抽象类当做标准的话就用implements实现抽象类。

一个类实现多个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

abstract class A {
  String name;
  printA();
}
abstract class B {
  printB();
}
class C implements A,B {
  @override
  String name;
  @override
  printA() {
    
  }
  @override
  printB() {
    
  }
}

mixins实现类似多继承的功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class A {
void printA() {
    String info = "this is A";
print("A");
}
}
class B {
void printB() {
print("B");
}
}
class C extends Person with A,B {
  
}

void main() {
  var c = new C();
  c.printA();
  C.printB();
  print(c.info);
}

8. 泛型

解决类 接口 方法的复用性、以及对不特定数据类型的支持（类型校验）

1
2
3
4
5
6
7
8
9
10

//泛型方法
T getData<T>(T value) {
  return value;
}
void main() {
  getData<String>('你好');
  print(getData<int>(12));
}
//泛型类
List list = new List<String>();

树（Tree）是 n（n≥0）个结点的有限集。n=0 时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当 n>1 时，其余结点可分为 m（m>0）个互不相交的有限集 T₁、T₂、……、T_m，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。

树的定义

树（Tree）是 n（n≥0）个结点的有限集。n=0 时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当 n>1 时，其余结点可分为 m（m>0）个互不相交的有限集 T₁、T₂、……、T_m，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。

结点分类

树的结点包含一个数据元素及若干指向其子树的分支。

结点拥有的子树数称为结点的度（Degree）。度为 0 的结点称为叶结点（Leaf）或终端结点；度不为 0 的结点称为非终端结点或分支结点。除根结点之外，分支结点也称为内部结点。树的度是树内各结点的度的最大值。

结点间关系

结点的子树的根称为该结点的孩子（Child），相应的，该结点称为孩子的双亲（Parent）。同一个双亲的孩子之前互称兄弟（Sibling）。结点的祖先是从根到该结点所经分支上的所有结点。反之，以某结点为根的子树中的任一结点都称为该结点的子孙。

树的其他相关概念

结点的层次（Level）从根开始定义起，根为第一层，根的孩子为第二层。若某结点在第 1 层，则其子树的根就在第 i+1 层。其双亲在同一层的结点互为堂兄弟。树中结点的最大层次称为树的深度（Depth）或高度。

如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。

森林（Forest）是 m（m≥0）棵互不相交的树的集合。

线性表与树结构

树的抽象数据类型

ADT 树（tree）

Data

树是由一个根结点和若干子树构成。树中结点具有相同数据类型及层次关系。

Operation

InitTree(*T):构造空树 T。

DestroyTree(*T):销毁树 T。

CreateTree(*T, definition):按 definition 中给出树的定义来构造树。

ClearTree(*T):若树 T 存在，则将树 T 清为空树。

TreeEmpty(*T):若 T 为空树，返回 true，否则返回 false。

TreeDepth(T):返回 T 的深度。

Root(T):返回树的根结点。

Value(T, cur_e):cur_e 是树 T 中一个结点，返回此结点的值。

Assign(T, cur_e,value):给树 T 的结点 cur_e 赋值为 value。

Parent(T, cur_e):若 cur_e 是树 T 的非根结点，则返回它的双亲，否则返回空。

LeftChild(T, cur_e):若 cur_e 是树 T 的非叶结点，则返回它的最左孩子，否则返回空。

RightSibling(T, cur_e):若 cur_e 有右兄弟，则返回它的右兄弟，否则返回空。

InsertChild(T, p, i, c):其中 p 指向树 T 的某个结点，i 为所指结点 p 的度加上1，非空树 c 与 T 不相交，操作结果为插入 c 为树 T 中 p 指结点的第 i 棵子树。

DeleteChild(T, p, i):其中 p 指向树 T 的某个结点，i 为所指结点 p 的度，操作结果为删除 T 中 p 所指结点的第 i 棵子树。

endADT

树的存储结构

双亲表示法

我们假设以一组连续空间存储树的结点，同时在每个结点中，附设一个指示器表示其双亲结点在数组中的位置。也就是说，每个结点除了知道自己是谁以外，还知道它的双亲在哪里。

以下是我们的双亲表示法的结点结构定义代码。

1
2
3
4
5
6
7
8
9
10
11
12
13

/* 树的双亲表示法结点结构定义 */
#define MAX_TREE_SIZE 100
typedef int TElemType; /* 树结点的数据类型，目前暂定为整型 */
typedef struct PTNode /* 结点结构 */
{
  TElemType data; /* 结点数据 */
  int parent; /* 双亲位置 */
} PTNode;
typedef struct  /* 树结构 */
{
  PTNode nodes[MAX_TREE_SIZE]; /* 结点数组 */
  int r,n;  /* 根的位置和结点数 */
} PTree

存储结构的设计是一个非常灵活的过程。一个存储结构设计的是否合理，取决于基于该存储结构的运算是否合适、是否方便，时间复杂度好不好等。

孩子表示法

由于树中每个结点可能有多棵子树，可以考虑用多重链表，即每个结点有多个指针域，其中每个指针指向一棵子树的根结点，我们把这种方法叫做多重链表表示法。

孩子表示法。把每个结点的孩子结点排列起来，以单链表作存储结构，则 n 个结点有 n 个孩子链表，如果是叶子结点则此单链表为空。然后 n 个头指针又组成一个线性表，采用顺序存储结构，放进一个一维数组中。

以下是我们的孩子表示法的结构定义代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

/* 树的孩子表示法结构定义 */
#define MAX_TREE_SIZE 100
typedef struct CTNode /* 孩子结点 */
{
  int child;
  struct CTNode *next;
} *ChildPtr;
typedef struct /* 表头结构 */
{
  TElemType data;
  ChildPtr firstchild;
} CTBox;
typedef struct /* 树结构 */
{
  CTBox nodes[MAX_TREE_SIZE]; /* 结点数组 */
  int r,n; /* 根的位置和结点数 */
} CTree;

孩子兄弟表示法

任意一棵树，它的结点的第一个孩子如果存在就是唯一的，它的右兄弟如果存在也是唯一的。因此，我们设置两个指针，分别指向该结点的第一个孩子和此结点的右兄弟。

结构定义代码如下。

1
2
3
4
5
6

/* 树的孩子兄弟表示法结构定义 */
typedef struct CSNode
{
  TElemType data;
  struct CSNode *fistchild,*rightsib;
} CSNode, *CSTree;

二叉树的定义

二叉树（Binary Tree）是 n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。

二叉树特点

二叉树的特点有：

• 每个结点最多有两棵子树，所以二叉树中不存在度大于 2 的结点。注意不是只有两棵子树，而是最多有。没有子树或者一棵子树都是可以的。
• 左子树和右子树是有顺序的，次序不能任意颠倒。
• 即使树中某个结点只有一棵子树，也要区分它是左子树还是右子树。

二叉树具有五种基本形态：

1. 空二叉树。
2. 只有一个根结点。
3. 根结点只有左子树。
4. 根结点只有右子树。
5. 根结点既有左子树又有右子树。

特殊二叉树

1. 斜树

所有的结点都只有左子树的二叉树叫左斜树。所有结点都是只有右子树的二叉树叫右斜树。这两者统称为斜树。

2. 满二叉树

在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层，这样的二叉树称为满二叉树。

满二叉树的特点有：

（1）叶子只能出现在最下一层。

（2）非叶子结点的度一定是 2。

（3）在同样深度的二叉树中，满二叉树的结点个数最多，叶子树最多。

3. 完全二叉树

对一棵具有 n 个结点的二叉树按层序编号，如果编号为 i（1≤i≤n）的结点与同样深度的满二叉树中编号为 i 的结点在二叉树中位置完全相同，则这棵二叉树称为完全二叉树。

完全二叉树的特点：

（1）叶子结点只能出现在最下两层。

（2）最下层的叶子一定集中在左部连续位置。

（3）倒数二层，若有叶子结点，一定都在右部连续位置。

（4）如果结点度为1，则该结点只有左孩子，即不存在只有右子树的情况。

（5）同样结点的二叉树，完全二叉树的深度最小。

判断某个二叉树是否是完全二叉树的办法，就是看着树的示意图，心中默默给每个结点按照满二叉树的结构逐层顺序编号，如果编号出现空挡，就说明不是完全二叉树，否则就是。

二叉树的性质

二叉树的性质1

性质1：在二叉树的第 i 层上至多有 2^i-1 个结点（i≥1）。

二叉树的性质2

性质2：深度为 k 的二叉树至多有 2^k-1 个结点（k≥1）。

二叉树的性质3

性质3：对任何一棵二叉树 T，如果其终端结点数为 n₀，度为 2 的结点数为 n₂，则 n₀=n₂+1。

二叉树的性质4

性质4：具有 n 个结点的完全二叉树的深度为 ⎣log₂n⎦+1 ( ⎣x⎦表示不大于 x 的最大整数)。

注：⎣⎦ 向下取整运算。

二叉树的性质5

性质5：如果对于一棵有 n 个结点的完全二叉树（其深度为 ⎣log₂n⎦+1）的结点按层序编号（从第 1 层到第 ⎣log₂n⎦+1 层），每层从左到右，对任一结点 i （1≤i≤n）有：

1. 如果 i = 1，则结点 i 是二叉树的根，无双亲；如果 i>1，则其双亲是结点 ⎣i/2⎦。
2. 如果 2i>n，则结点 i 无左孩子（结点 i 为叶子结点）；否则其左孩子是结点 2i。
3. 如果 2i+1>n，则结点 i 无右孩子；否则其右孩子是结点 2i+1。

二叉树的存储结构

二叉树顺序存储结构

顺序存储结构一般只用于完全二叉树。

二叉链表

二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。

以下是我们的二叉链表的结点结构定义代码。

1
2
3
4
5
6

/* 二叉树的二叉链表结点结构定义 */
typedef struct BitNode /* 结点结构 */
{
  TElemType data; /* 结点数据 */
  struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
} BiTNode, *BiTree;

遍历二叉树

二叉树遍历原理

二叉树的遍历（traversing biary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。

二叉树遍历方法

1. 前序遍历

规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树。

2. 中序遍历

规则是若树为空，则空操作返回，否则从根结点开始（注意不是先访问根结点），中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树。

3. 后序遍历

规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。

4. 层序遍历

规则是若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。

前序遍历算法

1
2
3
4
5
6
7
8
9

/* 二叉树的前序遍历递归算法 */
void PreOrderTraverse (BiTree T)
{
  if (T==NULL)
    return;
  printf("%c",T->data); /* 显示结点数据，可以更改为其他对结点操作 */
  PreOrderTraverse (T->lchild); /* 再先序遍历左子树 */
  PreOrderTraverse (T->rchild); /* 最后先序遍历右子树 */
}

中序遍历算法

1
2
3
4
5
6
7
8
9

/* 二叉树的中序遍历递归算法 */
void InOrderTraverse (BiTree T)
{
  if (T==NULL)
    return;
  InOrderTraverse (T->lchild); /* 中序遍历左子树 */
  printf("%c",T->data); /* 显示结点数据，可以更改为其他对结点操作 */
  InOrderTraverse (T->rchild); /* 最后中序遍历右子树 */
}

后序遍历算法

1
2
3
4
5
6
7
8
9

/* 二叉树的后序遍历递归算法 */
void PostOrderTraverse (BiTree T)
{
  if (T==NULL)
    return;
  PostOrderTraverse (T->lchild); /* 先后序遍历左子树 */
  PostOrderTraverse (T->rchild); /* 再后序遍历右子树 */
  printf("%c",T->data); /* 显示结点数据，可以更改为其他对结点操作 */
}

推导遍历结果

• 已知前序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
• 已知后序遍历序列和中序遍历序列，可以唯一确定一棵二叉树。
• 已知前序和后序遍历，是不能唯一确定一棵二叉树的。

二叉树的建立

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/* 按前序输入二叉树中结点的值（一个字符） */
/* #表示空树，构造二叉链表表示二叉树 T。 */
void CreateBiTree (BiTree *T)
{
  TElemType ch;
  scanf("%c",&ch);
  if (ch=='#')
    *T=NULL;
  else
  {
    *T=(BiTree)malloc(sizeof(BiTNode));
    if (!*T)
      exit (OVERFLOW);
    (*T)->data=ch; /* 生成根结点 */
    CreateBiTree(&(*T)->lchild); /* 构造左子树 */
    CreateBiTree(&(*T)->rchild); /* 构造右子树 */
  }
}

线索二叉树

线索二叉树原理

指向前驱和后继的指针称为线索，加上线索的二叉链表称为线索链表，相应的二叉树就称为线索二叉树（Threaded Binary Tree）。

对二叉树以某种次序遍历使其变为线索二叉树的过程叫做是线索化。

线索二叉树结构实现

1
2
3
4
5
6
7
8
9

/* 二叉树的二叉线索存储结构定义 */
typedef enum (Link, Thread) PointerTag; /* Link==0 表示指向左右孩子指针 Thread==1 表示指向前驱或后继的线索 */
typedef struct BiThrNode /* 二叉线索存储结点结构 */
{
  TElemType data; /* 结点数据 */
  struct BiThrNode *lchild, *rchild; /* 左右孩子指针 */
  PointerTag LTag;
  PointerTag RTag; /* 左右标志 */
} BiThrNode, *BiThrTree;

线索化的过程就是在遍历的过程中修改空指针的过程。

如果所用的二叉树需经常遍历或查找结点时需要某种遍历序列中的前驱和后继，那么采用线索二叉链表的存储结构就是非常不错的选择。

树、森林与二叉树的转换

树转换为二叉树

将树转换为二叉树的步骤如下

1. 加线。在所有兄弟结点之间加一条连线。
2. 去线。对树中每个结点，只保留它与第一个孩子结点的连线，删除它与其他孩子结点之间的连线。
3. 层次调整。以树的根结点为轴心，将整棵树顺时针旋转一定的角度，使之结构层次分明。注意第一个孩子是二叉树结点的左孩子，兄弟转换过来的孩子是结点的右孩子。

森林转换为二叉树

步骤如下：

1. 将每个树转换为二叉树。
2. 第一棵二叉树不动，从第二棵二叉树开始，依次把后一棵二叉树的根结点作为前一棵二叉树的根结点的右孩子，用线连接起来。当所有的二叉树连接起来后就得到了由森林转换来的二叉树。

二叉树转换为树

1. 加线。
2. 去线。
3. 层次调整。

二叉树转换为森林

1. 从根结点开始，若右孩子存在，则把右孩子结点的连线删除，再查看分离后的二叉树，若右孩子存在，则连线删除……，直到所有右孩子连线都删除为止，得到分离的二叉树。
2. 再将每棵分离的二叉树转换为树即可。

树与森林的遍历

树的遍历分为两种方式。

1. 一种是先根遍历树，即先访问树的根结点，然后依次先根遍历根的每棵子树。
2. 另一种是后根遍历，即先依次后根遍历每棵子树，然后再访问根结点。

森林的遍历也分为两种方式：

1. 前序遍历
2. 后序遍历

赫夫曼树及其应用

赫夫曼树定义与原理

从树中一个结点到另一个结点之间的分支构成两个结点之间的路径，路径上的分支数目称做路径长度。

树的路径长度就是从树根到每一个结点的路径长度之和。

带权路径长度 WPL 最小的二叉树称做赫夫曼树。

赫夫曼编码

一般地，设需要编码的字符集为{d₁,d₂,…,d_n}，各个字符在电文中出现的次数或频率集合为 {w₁,w₂,…,w_n}，以 d₁,d₂,…,d_n 作为叶子结点，以 w₁,w₂,…,w_n 作为相应叶子结点的权值来构造一棵赫夫曼树。规定赫夫曼树的左分支代表 0，右分支代表 1，则从根结点到叶子结点所经过的路径分支组成的 0 和 1 的序列便为该结点对应字符的编码，这就是赫夫曼编码。

串（string）是由零个或多个字符组成的有限序列，又名叫字符串。

串的定义

串（string）是由零个或多个字符组成的有限序列，又名叫字符串。

串的比较

给定两个串：s= “a₁a₂……a_n“, t= “b₁b₂……b_m“, 当满足以下条件之一时，s<t。

1. n<m，且a_i=b_i（i=1, 2, ……, n）。
2. 存在某个k<min(m, n), 使得a_i=b_i（i=1，2，……，k-1）a_k<b_k

串的抽象数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

ADT 串（string）
Data
  串中元素仅由一个字符组成，相邻元素具有前驱和后继关系。
Operation
  StrAssign(T,*chars):生成一个其值等于字符串常量chars的串T。
  StrCopy(T,S):串S存在，由串复制得串T。
  ClearString(S):串S存在，将串清空。
  StringEmpty(S):若串为空，返回true，否则返回false。
  StrLength(S):返回串S的元素个数，即串的长度。
  StrCompare(S,T):若S>T，返回值>0,若S=T，返回0，若S<T，返回值<0.
  Concat(T,S1,S2):用T返回由S1和S2联接而成的新串。
  SubString(Sub,S,pos,len):串S存在，1<=pos<=StrLength(S)，且0<=len<=StrLength(S)-pos+1,用Sub返回串S的第pos个字符长度为len的子串。
  Index(S,T,pos):串S和T存在，T是非空串，1<=pos<=StrLength(S)。若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。
  Replace(S,T,V):串S、T和V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串。
  StrInsert(S,pos,T):串S和T存在，1<=pos<=StrLength(S)+1。在串S的第pos个字符之前插入串T。
  StrDelete(S,pos,len):串S存在，1<=pos<=StrLength(S)-len+1。从串S中删除第pos个字符起长度为len的子串。
endADT

Index 的实现算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/* T为非空串。若主串S中第pos个字符之后存在与T相等的子串，则返回第一个这样的子串在S中的位置，否则返回0 */
int Index(String S, String T, int pos)
{
  int n,m,i;
  String sub;
  if (pos > 0)
  {
    n = StrLength(S);
    m = StrLength(T);
    i = pos;
    while ( i <= n-m+1)
    {
      SubString(sub,S,i,m); /* 取主串第i个位置 长度与T相等子串给sub */
      if (StrCompare(sub,T) != 0)  /* 如果两串不相等 */
        ++i;
      else  /* 如果两串相等 */
        return i;
    }
  }
  return 0; /* 若无子串与T相等，返回0 */
}

当中用到了 StrLength、SubString、StrCompare 等基本操作来实现。

串的存储结构

串的顺序存储结构

串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区。一般使用定长数组来定义。

串的链式存储结构

对于串的链式存储结构，与线性表是相似的，但由于串结构的特殊性，结构中的每个元素数据是一个字符，如果也简单的应用链表存储串值，一个结点对应一个字符，就会存在很大的空间浪费。因此，一个结点可以存放一个字符，也可以考虑存放多个字符，最后一个结点若是未被占满时，可以用“#”或其他非串值字符补全。

串的链式存储结构除了在链接串与串操作时有一定方便外，总的来说不如顺序存储灵活，性能也不如顺序存储结构好。

朴素的模式匹配算法

子串的定位操作通常称做串的模式匹配。
假设我们要从下面的主串S=“goodgoogle”中，找到T=“google这个子串的位置”。
简单的来说，就是对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做T的长度的小循环，直到匹配成功或全部遍历完成为止。
最好的情况，时间复杂度为O(1)。
稍差一些的情况，时间复杂度为O(n+m)，其中n为主串长度，m为要匹配的子串长度。
根据等概率原则，平均是(n+m)/2次查找，时间复杂度为O(n+m)。

KMP模式匹配算法

D.E.Knuth、J.H.Morris 和 V.R.Pratt 发表一个模式匹配算法，可以大大避免重复遍历的情况，我们把它称之为克努特-莫里斯-普拉特算法，简称 KMP 算法。

App1:

优化前：37.8MB 优化后：15.7MB

1. 移除重复图片，多余图片，压缩大的图片，去掉用不到的类。包大小变为35.1MB，减少了2.7MB。
2. 把环信含音视频的 SDK 换成不含音视频的 SDK。包大小变为28MB，减少了7.1MB。
3. 移除 armv7，不再支持 iPhone 4、iPhone 4s。包大小变为20.4MB，减少了7.6MB。
4. 移除百度地图 SDK (项目里只用到了百度定位 SDK )。包大小变为16.6MB，减少了3.8MB。
5. 移除环信 UI 中的兔斯基 GIF 图。包大小变为16MB，减少了0.6MB。
6. 启动图替换为压缩后的启动图。包大小变为15.7MB，减少了0.3MB。

App2：

优化前：27.7MB 优化后：9.2MB

1. 移除环信音视频 SDK，包大小变为20.3MB，减少了7.4MB。
2. 移除百度地图 SDK，包大小变为14.8MB，减少了5.5MB。
3. 移除 armv7，包大小变为9.8MB，减少了5MB。
4. 移除环信 UI 中的兔斯基 GIF 图。包大小变为9.2MB，减少了0.6MB。

小提示

• AppStore 上 App 信息中的展示的大小指的是安装大小，并非下载大小。所以要比打出来的 ipa 包大很多。
• 在各个机型上面的大小也不尽相同。

总结

通过这次实践，我发现影响包大小的主要因素是某些较大的第三方库及库里的图片，以及支持iPhone 4、4s 的 armv7。对于用不到的类、图片等资源文件要及时清理，使用被蓝湖等工具压缩过的图片等方式来改善安装包大小。

栈是限定仅在表尾进行插入和删除操作的线性表。
队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。

栈的定义

栈（stack）是限定仅在表尾进行插入和删除操作的线性表。

我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称 LIFO 结构。

栈的插入操作，叫做进栈，也称压栈、入栈。
栈的删除操作，叫做出栈，也有的叫弹栈。

进栈出栈的变化形式

元素数量多个，出栈次序会有很多种可能。

栈的抽象数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13

ADT 栈
Data
  同线性表。元素具有相同的类型，相邻元素具有前驱和后继关系。
Operation
  InitStack(*S):初始化操作，建立一个空栈S。
  DestroyStack(*S):若栈存在，则销毁它。
  ClearStack(*S):将栈清空。
  StackEmpty(S):若栈为空，返回 true ，否则返回 false。
  GetTop(S,*e):若栈存在且非空，用e返回S的栈顶元素。
  Push(*S,e):若栈S存在，插入新元素e到栈S中并成为栈顶元素。
  Pop(*S,e):删除栈S中的栈顶元素，并用e返回其值。
  StackLength(S):返回栈S的元素个数。
endADT

栈的顺序存储结构及实现

栈的顺序存储结构

栈的结构定义

1
2
3
4
5
6

typedef init SElemType;
typedef struct
{
  SElemType data[MAXSIZE]
  int top;     /* 用于栈顶指针 */
}SqStack;

栈的顺序存储结构——进栈操作

进栈操作 push，其代码如下：

1
2
3
4
5
6
7
8
9
10

Status Push (SqStack *S, SElemType e)
{
  if (S->top == MAXSIZE - 1) /* 栈满 */
  {
    return ERROR;
  }
  S->top++;   /* 栈顶指针增加一 */
  S->data[S->top]=e;   /* 将新插入元素赋值给栈顶空间 */
  return OK;
}

栈的顺序存储结构——出栈操作

出栈操作 pop，其代码如下：

1
2
3
4
5
6
7
8

Status Pop (SqStack *S, SElemType *e)
{
  if(S->top==-1)
    return ERROR;
  *e=S->data[S->top]; /* 将要删除的栈顶元素赋值给e */
  S->top--;   /* 栈顶指针减一 */
  return OK;
}

进栈和出栈没有涉及到任何循环语句，因此时间复杂度均是 O(1)。

两栈共享空间

使用这样的数据结构，通常都是当两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况。

栈的链式存储结构及实现

栈的链式存储结构

栈的链式存储结构，简称为链栈。
链栈的结构代码如下：

1
2
3
4
5
6
7
8
9
10
11

typedef struct StackNode
{
  SElemType data;
  struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack
{
  LinkStackPtr top;
  int count;
}

栈的链式存储结构——进栈操作

1
2
3
4
5
6
7
8
9
10

/* 插入元素 e 为新的栈顶元素 */
Status Push (LinkStack *S, SElemType e)
{
  LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode));
  s->data = e;
  s->next = s->top;  /* 把当前的栈顶元素赋值给新结点的直接后继 */
  S->top = s;  /* 将新的结点s赋值给栈顶指针 */
  S->count++;
  return OK;
}

栈的链式存储结构——出栈操作

假设变量 p 用来存储要删除的栈顶结点，将栈顶指针下移一位，最后释放 p 即可。

1
2
3
4
5
6
7
8
9
10
11
12

Status Pop (LinkStack *S, SElemType *e)
{
  LinkStackPtr p;
  if (StackEmpty(*S))
    return ERROR;
  *e = S->top->data;
  p=S->top;  /* 将栈顶结点赋值给p */
  S->top=S->top->next;  /* 使得栈顶指针下移一位，指向后一结点 */
  free(p);  /* 释放结点 p */
  S->count--;
  return OK;
}

链栈的进栈 push 和出栈 pop 操作没有任何循环操作，时间复杂度均为O(1)。
如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。

栈的作用

栈的引入简化了程序设计的问题，划分了不同关注层次，使得思考范围缩小，更加聚焦于我们要解决的问题核心。

栈的应用——递归

斐波那切数列实现

1
2
3
4
5
6
7
8
9
10
11
12
13

int Fbi (int i)
{
  if (i < 2)
    return i == 0 ? 0 : 1;
  return Fbi(i-1) + Fbi(i-2);
}
int main()
{
  int i;
  for (int i = 0;i < 40; i++)
    printf("%d ", Fbi(i));
  return 0;
}

递归定义

在高级语言中，调用自己和其他函数并没有本质的不同。我们把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
每个递归定义必须至少有一个条件，满足递归不再进行，即不再引用自身而是返回值退出。

栈的应用——四则运算表达式求值

1. 将中缀表达式转化为后缀表达式（栈用来进出运算的符号）。

2. 将后缀表达式进行运算得出结果（栈用来进出运算的数字）。

队列的定义

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

队列的抽象数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ADT 队列（Queue）

Data
  同线性表。元素具有相同的类型，相邻元素具有前缀和后继关系。
Operation
  InitQueue(*Q):初始化操作，建立一个空队列Q。
  DestroyQueue(*Q):若队列Q存在，则销毁它。
  ClearQueue(*Q):将队列Q清空。
  QueueEmpty(*Q):若队列Q为空，返回 true，否则返回 false。
  GetHead(Q,*e):若队列Q存在且非空，用e返回队列Q的队头元素。
  EnQueue(*Q,e):若队列Q存在，插入新元素e到队列Q中并成为队尾元素。
  DeQueue(*Q,*e):删除队列Q中队头元素，并用e返回其值。
  QueueLength(Q):返回队列Q的元素个数。
endADT

循环队列

循环队列定义

我们把队列的这种头尾相接的顺序存储结构称为循环队列。

队列的链式存储结构及实现

队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
链队列的结构为：

1
2
3
4
5
6
7
8
9
10
11
12