### **简介**

- 在本教程中，我对课堂上讲解的汇率转换Demo进行复现和代码微调。
- 本Demo基于 HarmonyOS 和 TypeScript。应用程序通过一个在线汇率 API，实时查询美元（USD）兑换人民币（CNY）的汇率，用户可以输入金额并获得对应兑换值。

![1111.png](http://reeshiram.site/static/img/207fcc28bf5904203f5a822c96591218.1111.webp)

![22222.png](http://reeshiram.site/static/img/1602ebaacdcb64916c987a106b6f87f6.22222.webp)

### **开发环境**

- DevEco Studio 最新版
- HarmonyOS 3.0+ 支持的设备或模拟器
- 熟悉 TypeScript 基础

### **1. 项目结构**

以下是项目的基本文件结构：
代码拆分为四个模块，分别为主界面逻辑（`index.ets`）、API 服务类（`apiService.ets`）、数据模型（`exchange.ets`）以及模块配置（`module.json5`）。

```js
Demo1125/
├── entry/
│   ├── src/
│   │   ├── main/
│   │   │   ├── ets/
│   │   │   │   ├── pages/
│   │   │   │   │   ├── index.ets        # 主界面逻辑
│   │   │   │   │   ├── apiService.ets   # API 服务类
│   │   │   │   │   ├── exchange.ets     # 数据模型
│   │   │   │   │
│   │   │   │   ├── module.json5         # 模块配置
│   │   │   ├── resources/
│   │   │   │   ├── base/
│   │   │   │   ├── en/
│   │   │   │   ├── zh/
├── .hvigor/
├── .idea/
├── build/

```

### **2. 功能描述**

- **主页面（index.ets）：** 用户输入美元金额后，点击或自动触发查询按钮，将调用在线汇率 API 查询并返回实时结果。

- **API 服务（apiService.ets）：** 提供与 API 后端交互的逻辑，负责发送请求并返回结果。

- **数据模型（exchange.ets）：** 处理 API 返回的 JSON 数据，转化为可用的对象数据。

- **模块配置（module.json5）：** 包含权限申请、页面路径配置等基础信息。

### **3. 代码实现**

#### 3.1 主页面代码（index.ets）

```js
import { ApiService } from './apiService';
import { ExchangeResponse, ExchangeData } from './exchange';

@Entry
@Component
export struct Index {
  @State value: number = 0; // 用户输入的美元金额
  @State exchangeRate: string = "等待输入..."; // 显示兑换结果
  @State updateTime: string = "暂无数据"; // 汇率更新时间
  @State errorMessage: string = ""; // 错误提示信息

  private apiService = new ApiService();

  // 获取汇率逻辑
  getExchangeRate(amount: number): void {
    this.apiService.getExchangeData("USD", "CNY", (response, error) => {
      if (response && response.code === 200 && response.data) {
        const exchangeData: ExchangeData = response.data as ExchangeData;
        this.exchangeRate = ((exchangeData.exchange ?? 0) * amount).toFixed(2);
        this.updateTime = exchangeData.update_time ?? "未知时间";
        this.errorMessage = "";
      } else {
        this.errorMessage = error || "API请求失败";
      }
    });
  }

  // 输入防抖逻辑
  handleInput(value: string): void {
    const inputValue = parseFloat(value);
    if (!isNaN(inputValue) && inputValue > 0) {
      this.value = inputValue;
      this.getExchangeRate(inputValue);
    } else {
      this.errorMessage = "请输入有效金额";
    }
  }

  build() {
    Column() {
      Text("汇率转换器")
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .margin(20);

      TextInput({
        placeholder: "请输入兑换的美元金额",
        text: this.value.toString(),
      })
        .type(InputType.Number)
        .onChange((e: string) => {
          this.handleInput(e);
        })
        .padding({ left: 20, right: 20 })
        .backgroundColor("#f0f0f0")
        .borderRadius(8);

      if (this.errorMessage) {
        Text(this.errorMessage)
          .fontColor("#FF0000")
          .margin(10);
      } else {
        Text(`兑换金额: ${this.exchangeRate} 人民币`).margin(10);
        Text(`更新时间: ${this.updateTime}`).margin(10);
      }
    }
    .height("100%")
    .width("100%")
    .backgroundColor("#FFFFFF");
  }
}
```

**对于index的修改：**

- **用户输入验证**：添加防抖机制，避免用户连续输入触发过多请求：

```js
private debounceTimeout: number | null = null;

handleInput(value: string): void {
  if (this.debounceTimeout) {
    clearTimeout(this.debounceTimeout);
  }
  this.debounceTimeout = setTimeout(() => {
    const inputValue = parseFloat(value);
    if (!isNaN(inputValue) && inputValue > 0) {
      this.value = inputValue;
      this.getExchangeRate(inputValue);
    } else {
      this.errorMessage = "请输入有效的金额";
    }
  }, 500); // 防抖延迟 500 毫秒
}
```

- **错误提示友好**：
  - 输入无效金额时提示：请输入有效金额
  - API 请求失败时提示：网络请求失败 或 API返回错误。
- **UI 样式优化**：
  - TextInput 添加圆角、背景色。
  - 错误信息采用红色字体，醒目且易区分。

#### 3.2 API 服务类（apiService.ets）

```js
import http from '@ohos.net.http';
import { ExchangeResponse } from './exchange';

export class ApiService {
  private readonly API_URL = "https://v2.alapi.cn/api/exchange";
  private readonly API_KEY = "4YxBbmkhGAWA9BcW";

  public getExchangeData(
    from: string,
    to: string,
    callback: (response: ExchangeResponse | null, error: string | null) => void
  ): void {
    const httpRequest = http.createHttp();
    httpRequest.request(
      this.API_URL,
      {
        method: http.RequestMethod.POST,
        header: { 'Content-Type': 'application/json' },
        extraData: {
          token: this.API_KEY,
          from: from,
          to: to,
          money: 1,
        },
        expectDataType: http.HttpDataType.STRING,
      },
      (err, data) => {
        if (!err) {
          try {
            const response: ExchangeResponse = JSON.parse(data.result.toString());
            callback(response, null);
          } catch (parseError) {
            callback(null, "数据解析错误");
          }
        } else {
          callback(null, "网络请求失败");
        }
        httpRequest.destroy();
      }
    );
  }
}
```

**对于apiService.ets的修改：**

- **服务类封装**：将网络请求逻辑封装到 apiService.ets 中，主页面只需要调用接口。
- **数据解析安全性**：增加了对 API 返回值的类型检查和错误捕获，防止意外崩溃。

```js
try {
  const response: ExchangeResponse = JSON.parse(data.result.toString());
  if (response.code === 200 && response.data) {
    // 确保数据是字符串或 JSON 对象
    if (typeof response.data === "string") {
      response.data = JSON.parse(response.data) as ExchangeData;
    }
    callback(response, null);
  } else {
    callback(null, response.msg || "API返回错误");
  }
} catch (parseError) {
  callback(null, "数据解析错误");
}
```

#### 3.3 数据模型（exchange.ets）

```js
export class ExchangeResponse {
  code: number = 0; // 状态码
  msg: string = ""; // 返回消息
  data?: string | ExchangeData = undefined; // 返回的数据
}

export class ExchangeData {
  exchange?: number = 0; // 汇率
  update_time?: string = ""; // 更新时间
}

```

#### 3.4 模块配置（module.json5）

```js
{
  "module": {
    "name": "entry",
    "type": "entry",
    "description": "$string:module_desc",
    "mainElement": "EntryAbility",
    "deviceTypes": ["phone", "tablet", "2in1"],
    "requestPermissions": [
      { "name": "ohos.permission.INTERNET" }
    ],
    "pages": [
      { "srcEntry": "./ets/pages/index.ets", "name": "Index" }
    ]
  }
}
```

### **4. 项目总结**

- 构建一个简单的 HarmonyOS 应用。
- 通过对一个现有Demo进行复现和微调，提升自身编码能力。
- 使用网络请求和 API 数据解析。
- 组织和管理代码文件。

HarmonyOS 汇率转换应用Demo练习

**Several steps：**



1、Research Background and Motivation: Explain the context and reasons behind the study, including existing gaps or issues the research addresses.



2、Objectives and Research Questions: Identify the study's goals and the questions it seeks to answer.



3、Theoretical Framework and Literature Review: Summarize the relevant theories and prior studies that support the thesis.



4、Methodology: Describe the research methods, including data collection, analysis techniques, and any tools or models used



5、Results and Findings: Outline the primary outcomes and key insights derived from the study.



6、Discussion and Interpretation: Discuss how the findings relate to the research questions and their broader implications.



7、Limitations and Future Directions: Mention any limitations in the study and suggest possible areas for future research.



8、Conclusion: Summarize the overall findings and the contribution of the thesis to the field.

Interpret A Thesis

![屏幕截图 2024-11-05 213554.png](http://reeshiram.site/static/img/be9ade4a93eaf16c6dedca87f1db3eff.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202024-11-05%20213554.webp)




总结一下别人的经验：

1、文章1：


Source:



https://zhuanlan.zhihu.com/p/551134354


Content节选:

现在多数的同学在读论文的时候，真的就是在“读”论文。他们非常认真地，把英文论文翻译成了中文。然后一行行，像阅读皇上圣旨一样，去阅读论文。把论文里面写的内容，当成了真理。把论文里面每一章节的内容，按照论文中的顺序，总结出来形成了一个ppt。他们真的太“听话”了。听老师的话，也听网上一些错误经验中所谓的“精读”和“泛读”。



我让学生去读论文，不是真的只停留在“读”，而是要思考。我期待的不是学生告诉我这篇论文做了什么，这篇本论文是怎么做的。我真正期待的是，学生能告诉我，这篇论文为什么就能成功，他的局限性是什么，它的极限能做到什么样?



我真的不想知道这个论文中每一行代码都是什么，我也不想知道每一个公式都是怎样计算的。我想知道是什么原因让论文的作者能够设计出这个论文中的方法？是他们发现了什么新的信息，新的insight才使得他们能够克服论文中所描述的困难？



然而，大多数学生在没有经过良好的科研训练的时候，都顶多停留在翻译别人论文的层面上。这些学生，会认认真真地去推导论文中的公式，会认认真真翻译每一句英文。但是，这些远远不够。


一个正确的思路应该是，在介绍完论文中描述的困难以后，应该告诉我想要解决这些困难，需要核心解决问题是什么？然后再告诉我，论文的作者发现了什么新的信息或者insight，能够使得他们一定可以把这个核心的问题给解决掉。当把这两点都讲清楚以后，至于作者设计出来的方法是什么，其实都不重要了。


因为，作者发现的新的insight，才是我们以后可能用到的，可能再扩展的。而且一篇论文里面的方法的局限性，其实也是被这些insight给决定了的。


因为，作者发现的新的insight，才是我们以后可能用到的，可能再扩展的。而且一篇论文里面的方法的局限性，其实也是被这些insight给决定了的。

给大家举个例子，现在有一篇论文设计了一款酒精温度计。作者的insight是：酒精热胀冷缩的现象特别明显。于是作者把酒精在不同温度下的状态测量了一下，之后根据酒精的状态，就可以知道温度了。如果这是一篇论文的话，给我们最大的启发就是作者的这个insight。

这个insight其实限制了这个温度计的能力。因为酒精热胀冷缩的范围太小了，也就是零下十几度，到零上几十度。要是我们拿酒精温度计去测量火焰的温度，显然是不可能的。如果我们不知道这个论文的insight，我们就很难意识到这一点。

那么在这个insight的基础上，我们是不是可以利用其它材料的热胀冷缩也制造出新的温度计？比如说，我们拿热胀冷缩的范围更大的材料，比如说某些熔点低一些的金属，是不是就可以大大扩展温度计的测量范围了呢？如果我们能够更加深入研究这个insight背后的原理，我们也许可以发现是什么更加深入的原因导致了热胀冷缩的现象。如果我们把那个原理弄清楚了，我们也许可以摆脱热胀冷缩的局限性，我们也许可以设计出不需要依靠热胀冷缩就能测量温度的高科技温度计。

在没有告诉我，作者发现了什么新的insight的情况下，直接给我讲论文中的方法和步骤，那我是没法听得下去的。因为这种讲解，没有任何意义。我们阅读论文的目的，不是读英文作文，而是要思考，要深入思考，要在这些论文的基础上扩展和创新。所以，一篇论文里面所描述的方法真的不关键。更加关键的是，作者为什么能够想到这个方法？作者凭什么可以解决那些困难？至于在有了新的insight以后，作者设计出来的方法本身，真的不重要。


然而，再怎么难也要尽力去做，决不要堕落到像刚才我介绍的那个错误例子里面一样念一个没有任何信息量的ppt。老师是不会批评一个努力但是没有做好的学生，但是会讨厌一个敷衍的学生。

How should you present the research papers you have read during a meeting?

# About Software Testing:

## 1、Speed and Performance of Parserless and Unsupervised Anomaly Detection Methods on Software Logs

**Type:**
Paper

**Abstract:**
Software log analysis can be laborious and time consuming. Time and labeled data are usually lacking in industrial settings. This paper studies unsupervised and time efficient methods for anomaly detection. We study two custom and two established models. The custom models are: an OOV (Out-Of-Vocabulary) detector, which counts the terms in the test data that are not present in the training data, and the Rarity Model (RM), which calculates a rarity score for terms based on their infrequency. The established models are KMeans and Isolation Forest. The models are evaluated on four public datasets (BGL, Thunderbird, Hadoop, HDFS) with three different representation techniques for the log messages (Words, character Trigrams, Parsed events). For training, we used both normal-only data, which is free of all anomalies, and unfiltered data, which contains both normal and anomalous instances. We used primarily the AUC-ROC metric for evaluation due to challenges in setting a threshold but we also include F1-scores for further insight. Different configurations are advised based on specific requirements. When training data is unfiltered, includes both normal and anomalous instances, the most effective combination is the Isolation Forest with event representation, achieving an AUC-ROC of 0.829. If it's possible to create a normal-only training dataset, combining the Out-Of-Vocabulary (OOV) detector with trigram representation yields the highest AUC-ROC of 0.846. For speed considerations, the OOV detector is optimal for filtered data, while the Rarity Model is the best choice for unfiltered data.

Source:
https://cs.paperswithcode.com/paper/efficiency-of-unsupervised-anomaly-detection

GitHub:
https://github.com/evotestops/loglead


## 2、A K-Means Based Clustering Approach for Finding Faulty Modules in Open Source Software Systems

**Type:**
Paper

**Abstract:**

Prediction of fault-prone modules provides one way to support software quality engineering. Clustering is used to determine the intrinsic grouping in a set of unlabeled data. Among various clustering techniques available in literature K-Means clustering approach is most widely being used. This paper introduces K-Means based Clustering approach for software finding the fault proneness of the Object-Oriented systems. The contribution of this paper is that it has used Metric values of JEdit open source software for generation of the rules for the categorization of software modules in the categories of Faulty and non faulty modules and thereafter empirically validation is performed. The results are measured in terms of accuracy of prediction, probability of Detection and Probability of False Alarms.

Source:

https://publications.waset.org/13348/a-k-means-based-clustering-approach-for-finding-faulty-modules-in-open-source-software-systems


**My understanding：**



1)Purpose: The method aims to predict fault-prone modules by clustering based on code metrics such as coupling, cohesion, depth of inheritance, and number of children. These metrics serve as indicators of structural quality and help in pinpointing potentially problematic sections within software modules.

目的：该方法旨在通过基于代码指标（如耦合、内聚、继承深度和子级数量）的聚类来预测易出错的模块。这些指标作为结构质量的指标，有助于查明软件模块中可能存在问题的部分。

2)Data Source: JEdit, an open-source Java-based text editor, serves as the dataset for this study. By clustering modules from JEdit, the researchers seek to create fault detection models applicable to other open-source systems.

数据来源：JEdit 是一个基于 Java 的开源文本编辑器，是本研究的数据集。通过对 JEdit 的模块进行聚类，研究人员试图创建适用于其他开源系统的故障检测模型。

3)Methodology: After computing the selected metrics, the dataset undergoes feature selection to isolate the most predictive attributes. Then, clustering is performed using K-means with both Euclidean and Manhattan distances. The two distances help in comparing centroid calculations—Manhattan distance using median instead of mean minimizes sensitivity to outliers.

方法论：计算所选量度后，数据集将进行特征选择，以隔离最具预测性的属性。然后，使用具有欧几里得距离和曼哈顿距离的 K-means 执行聚类分析。这两个距离有助于比较质心计算 - 使用中位数而不是平均值的曼哈顿距离可最大程度地降低对异常值的敏感度。



4)Evaluation: The study employs a confusion matrix to assess the classification accuracy of the clustering method. It evaluates the model's effectiveness based on the detection probability (specificity) and false alarm rate (incorrectly identifying fault-free modules as faulty).

评估：该研究采用混淆矩阵来评估聚类方法的分类准确性。它根据检测概率（特异性）和误报率（错误地将无故障模块识别为故障）来评估模型的有效性。

5)Conclusion: Results indicate the K-means clustering method is a feasible approach for identifying fault-prone modules, with reasonable accuracy, and is adaptable to object-oriented systems.

结论：结果表明，K-means 聚类方法是识别易故障模块的可行方法，具有合理的准确性，并且适用于面向对象的系统。


















## 3、Test Case Prioritization Using Requirements-Based Clustering

**Type:**
Paper

**Abstract:**
The importance of using requirements information in the testing phase has been well recognized by the requirements engineering community, but to date, a vast majority of regression testing techniques have primarily relied on software code information. Incorporating requirements information into the current testing practice could help software engineers identify the source of defects more easily, validate the product against requirements, and maintain software products in a holistic way. In this paper, we investigate whether the requirements-based clustering approach that incorporates traditional code analysis information can improve the effectiveness of test case prioritization techniques. To investigate the effectiveness of our approach, we performed an empirical study using two Java programs with multiple versions and requirements documents. Our results indicate that the use of requirements information during the test case prioritization process can be beneficial.

Source:
https://ieeexplore.ieee.org/abstract/document/6569743


## 4、Software Fault Prediction Using Quad Tree-Based K-Means Clustering Algorithm

**Type:**
Paper

**Abstract:**
Unsupervised techniques like clustering may be used for fault prediction in software modules, more so in those cases where fault labels are not available. In this paper a Quad Tree-based K-Means algorithm has been applied for predicting faults in program modules. The aims of this paper are twofold. First, Quad Trees are applied for finding the initial cluster centers to be input to the A'-Means Algorithm. An input threshold parameter δ governs the number of initial cluster centers and by varying δ the user can generate desired initial cluster centers. The concept of clustering gain has been used to determine the quality of clusters for evaluation of the Quad Tree-based initialization algorithm as compared to other initialization techniques. The clusters obtained by Quad Tree-based algorithm were found to have maximum gain values. Second, the Quad Tree- based algorithm is applied for predicting faults in program modules. The overall error rates of this prediction approach are compared to other existing algorithms and are found to be better in most of the cases.

Source:
https://ieeexplore.ieee.org/abstract/document/5963674



**My understanding：**


1)Research Background and Motivation:

本研究解决了在没有标签故障数据的情况下预测程序模块中的软件故障的难题。传统的故障预测方法通常需要有标签的数据来进行监督学习。本文提出了使用无监督学习下的Kmeans算法来克服这一限制。


2)Objectives and Research Questions：

（1）开发一种基于四叉树的K-Means聚类初始化方法，为聚类分配合适的初始中心。
![image.png](http://reeshiram.site/static/img/f557425c3bdedbacd67f1bb4558ffe2b.image.webp)

（2）应用此方法进行程序模块的软件故障预测。该方法允许用户通过调整阈值参数控制初始聚类中心的数量，以实现高效聚类并减少错误。

3)Theoretical Framework and Literature Review

之前的研究使用聚类技术和基于专业人员的方法来将软件模块标记为易出错。然而，这些方法严重依赖于人类专家的能力，而这并非总是可行的。本文通过使用四叉树自动化K-Means聚类的初始化阶段，进一步改进了先前的研究，旨在提高聚类精度并减少对专业人员的依赖

4)Methodology

基于四叉树的K-Means算法通过递归地将数据空间分成四个象限来初始化聚类中心，从而分配反映数据分布的初始中心。此方法减少了异常值的影响，并降低了K-Means算法对噪声的敏感性。实验评估将该方法与其他初始化技术进行了比较，评估了错误率、聚类增益和预测准确性。

5)Results and Findings

实验结果表明，基于四叉树的K-Means算法在故障预测方面优于传统方法，在大多数数据集中实现了较低的错误率。该算法还表现出较高的聚类增益值，表明聚类质量较高。四叉树初始化提高了K-Means聚类在故障预测中的鲁棒性和准确性。

6)Discussion and Interpretation

研究结果表明，基于四叉树的初始化方法在没有标签数据的故障预测场景中有效。通过自动化初始聚类分配，该方法解决了K-Means算法的挑战，例如对初始中心和噪声的敏感性，使其成为无监督故障预测的可行替代方案。

7)Limitations and Future Directions

该研究指出了潜在的局限性，包括对阈值参数的依赖性，这会影响聚类结果。未来的研究可以探索优化此参数，并在更多样化的软件数据集中应用该方法，以评估其通用性。

8)Conclusion

本文提出了一种新颖的基于四叉树的K-Means聚类算法，增强了无监督的软件故障预测。研究表明，该方法能够有效地根据故障可能性对程序模块进行聚类，成为在缺乏标签数据的场景中监督故障预测模型的替代方案。

Seeing the World from the Shoulders of Giants

![00510-3927661606.png](http://reeshiram.site/static/img/8eab74c2331b586fc94d9c1b20150deb.00510-3927661606.webp)

![屏幕截图 2024-10-31 193345.png](http://reeshiram.site/static/img/8769375069c9f7e0d5c35224320332a8.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202024-10-31%20193345.webp)

![图1.png](http://reeshiram.site/static/img/f905ebc6f3f22d5653b095c0fdd8111a.%C3%A5%C2%9B%C2%BE1.webp)

![屏幕截图 2024-10-31 193408.png](http://reeshiram.site/static/img/896d215d001205c3951ec94a7e8bdf3b.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202024-10-31%20193408.webp)