目录

1. 概述
2. 功能设计
3. Kotlin 实现代码（KMP）
4. JavaScript 调用示例
5. ArkTS 页面集成与调用
6. 数据输入与交互体验
7. 编译与自动复制流程
8. 总结

---

概述

本案例在 Kotlin Multiplatform (KMP) 工程中实现了一个 娱乐工具 - 电影评分推荐系统：

• 输入：用户的电影信息（电影名称、类型、评分、年份），使用空格分隔，例如：Inception action 8.8 2010。
• 输出：
  • 电影信息分析：电影名称、类型、评分、年份等基本信息
  • 评分评估：评分等级、推荐指数、热度评分
  • 推荐理由：根据电影信息生成的详细推荐理由
  • 观看建议：根据电影类型和评分给出的观看建议
  • 相似电影推荐：根据电影类型推荐相似的电影
• 技术路径：Kotlin → Kotlin/JS → JavaScript 模块 → ArkTS 页面调用。

这个案例展示了 KMP 跨端开发在娱乐推荐领域的应用：

把电影推荐逻辑写在 Kotlin 里，一次实现，多端复用；把推荐界面写在 ArkTS 里，专注 UI 和体验。

Kotlin 侧负责解析电影数据、计算推荐指数、生成推荐理由和相似电影建议；ArkTS 侧只需要把输入字符串传给 Kotlin 函数，并把返回结果原样展示出来即可。借助 KMP 的 Kotlin/JS 能力，这个电影评分推荐系统可以在 Node.js、Web 前端以及 OpenHarmony 中复用相同的代码逻辑。

---

功能设计

输入数据格式

电影评分推荐系统采用简单直观的输入格式：

• 使用 空格分隔 各个参数。
• 第一个参数是电影名称（字符串，可包含下划线）。
• 第二个参数是电影类型（action/comedy/drama/horror/romance/sci-fi/thriller）。
• 第三个参数是评分（浮点数，范围 0-10）。
• 第四个参数是年份（整数，范围 1900-2100）。
• 输入示例：

Inception action 8.8 2010

这可以理解为：

• 电影名称：Inception
• 电影类型：动作片
• 评分：8.8 分
• 年份：2010 年

工具会基于这些数据计算出：

• 评分等级：杰作/优秀/良好/一般/及格/不及格
• 推荐指数：0-100 的综合推荐指数
• 热度评分：根据年份和评分计算的热度
• 推荐理由：根据评分和类型的详细推荐理由
• 相似电影：根据类型推荐相似的电影

输出信息结构

为了便于在 ArkTS 页面以及终端中直接展示，Kotlin 函数返回的是一段结构化的多行文本，划分为几个分区：

1. 标题区：例如"🎬 电影评分推荐"，一眼看出工具用途。
2. 电影信息：电影名称、类型、评分、年份等基本信息。
3. 评分评估：评分等级、推荐指数、热度评分。
4. 推荐理由：根据电影信息的详细推荐理由。
5. 观看建议：根据电影类型和评分的观看建议。
6. 相似电影：根据电影类型推荐的相似电影。

这样的输出结构使得：

• 在 ArkTS 中可以直接把整段文本绑定到 Text 组件，配合 monospace 字体，阅读体验类似终端报告。
• 如果将来想把结果保存到日志或者后端，直接保存字符串即可。
• 需要更精细的 UI 时，也可以在前端根据分隔符进行拆分，再按块展示。

---

Kotlin 实现代码（KMP）

核心代码在 src/jsMain/kotlin/App.kt 中，通过 @JsExport 导出。以下是完整的 Kotlin 实现：

@OptIn(ExperimentalJsExport::class)
@JsExport
fun movieRecommendationSystem(inputData: String = "Inception action 8.8 2010"): String {
    // 输入格式: 电影名称 类型 评分 年份
    val parts = inputData.trim().split(" ").filter { it.isNotEmpty() }

    if (parts.size < 4) {
        return "❌ 错误: 请输入完整的信息，格式: 电影名称 类型 评分 年份\n例如: Inception action 8.8 2010"
    }

    val movieName = parts[0]
    val genre = parts[1].lowercase()
    val rating = parts[2].toDoubleOrNull() ?: return "❌ 错误: 评分必须是数字"
    val year = parts[3].toIntOrNull() ?: return "❌ 错误: 年份必须是整数"

    if (rating < 0 || rating > 10) {
        return "❌ 错误: 评分必须在 0-10 之间"
    }

    if (year < 1900 || year > 2100) {
        return "❌ 错误: 年份必须在 1900-2100 之间"
    }

    val validGenres = listOf("action", "comedy", "drama", "horror", "romance", "sci-fi", "thriller")
    if (genre !in validGenres) {
        return "❌ 错误: 电影类型必须是以下之一: ${validGenres.joinToString(", ")}"
    }

    // 判断评分等级
    val ratingLevel = when {
        rating >= 9.0 -> "🌟 杰作"
        rating >= 8.0 -> "⭐ 优秀"
        rating >= 7.0 -> "👍 良好"
        rating >= 6.0 -> "😊 一般"
        rating >= 5.0 -> "😐 及格"
        else -> "👎 不及格"
    }

    // 计算推荐指数
    var recommendationScore = (rating * 10).toInt()
    
    // 根据年份调整推荐指数（新电影加分）
    val currentYear = 2024
    val yearDifference = currentYear - year
    recommendationScore += when {
        yearDifference <= 2 -> 10
        yearDifference <= 5 -> 5
        yearDifference <= 10 -> 0
        yearDifference <= 20 -> -5
        else -> -10
    }

    recommendationScore = maxOf(0, minOf(100, recommendationScore))

    // 计算热度评分
    val trendScore = when {
        yearDifference <= 1 -> 95
        yearDifference <= 3 -> 85
        yearDifference <= 5 -> 75
        yearDifference <= 10 -> 65
        yearDifference <= 20 -> 50
        else -> 30
    }

    // 生成推荐理由
    val recommendationReason = when {
        rating >= 9.0 -> "这是一部杰作级别的电影，无论从剧情、表演还是制作都堪称完美。强烈推荐所有喜欢${genre}类型的观众观看。"
        rating >= 8.0 -> "这是一部优秀的电影，具有出色的故事情节和精湛的表演。如果你喜欢${genre}类型的电影，这部作品绝对不容错过。"
        rating >= 7.0 -> "这是一部不错的电影，具有良好的娱乐价值和观赏性。推荐给喜欢${genre}类型的观众。"
        rating >= 6.0 -> "这是一部一般的电影，有一些亮点但也存在不足。如果你对${genre}类型感兴趣，可以尝试观看。"
        rating >= 5.0 -> "这部电影评分一般，可能有一些不足之处。建议先了解更多信息后再决定是否观看。"
        else -> "这部电影评分较低，可能不太值得观看。建议选择其他评分更高的电影。"
    }

    // 生成观看建议
    val viewingAdvice = when (genre) {
        "action" -> "适合喜欢刺激、冒险和视觉效果的观众。建议在大屏幕上观看以获得最佳体验。"
        "comedy" -> "适合想要放松和娱乐的观众。可以和朋友一起观看，增加欢乐气氛。"
        "drama" -> "适合喜欢深度故事和情感表达的观众。建议在安静的环境中观看以充分体验情感。"
        "horror" -> "适合喜欢刺激和惊悚的观众。建议在晚上观看以获得最佳的恐怖效果。"
        "romance" -> "适合喜欢爱情故事的观众。建议和伴侣一起观看以增加浪漫气氛。"
        "sci-fi" -> "适合喜欢科幻和想象力的观众。建议在高清屏幕上观看以欣赏视觉效果。"
        "thriller" -> "适合喜欢悬念和刺激的观众。建议在不被打扰的环境中观看以充分体验紧张气氛。"
        else -> "根据电影类型选择合适的观看环境。"
    }

    // 推荐相似电影
    val similarMovies = when (genre) {
        "action" -> "推荐相似电影: Mad Max, John Wick, Mission Impossible, Fast & Furious"
        "comedy" -> "推荐相似电影: Superbad, The Hangover, Bridesmaids, Tropic Thunder"
        "drama" -> "推荐相似电影: The Shawshank Redemption, Forrest Gump, The Green Mile, Schindler's List"
        "horror" -> "推荐相似电影: The Ring, Insidious, Conjuring, Hereditary"
        "romance" -> "推荐相似电影: Titanic, The Notebook, Pride and Prejudice, La La Land"
        "sci-fi" -> "推荐相似电影: Interstellar, The Matrix, Blade Runner, Dune"
        "thriller" -> "推荐相似电影: Se7en, Silence of the Lambs, Zodiac, Gone Girl"
        else -> "推荐相似电影: 根据类型选择"
    }

    // 观众评价
    val audienceReview = when {
        rating >= 8.5 -> "观众普遍好评，认为这是一部值得多次观看的佳作。"
        rating >= 7.5 -> "观众评价较好，大多数人认为这是一部不错的电影。"
        rating >= 6.5 -> "观众评价一般，有人喜欢有人认为一般。"
        rating >= 5.5 -> "观众评价不一，有正面评价也有负面评价。"
        else -> "观众评价较差，大多数人认为这部电影有较多不足。"
    }

    // 观看时长建议
    val viewingDuration = when (genre) {
        "action" -> "建议观看时长: 90-150 分钟"
        "comedy" -> "建议观看时长: 80-120 分钟"
        "drama" -> "建议观看时长: 100-180 分钟"
        "horror" -> "建议观看时长: 80-120 分钟"
        "romance" -> "建议观看时长: 100-140 分钟"
        "sci-fi" -> "建议观看时长: 120-180 分钟"
        "thriller" -> "建议观看时长: 100-150 分钟"
        else -> "建议观看时长: 根据类型调整"
    }

    // 构建输出文本
    val result = StringBuilder()
    result.append("🎬 电影评分推荐系统\n")
    result.append("═".repeat(60)).append("\n\n")
    
    result.append("📽️ 电影信息\n")
    result.append("─".repeat(60)).append("\n")
    result.append("电影名称: ${movieName}\n")
    result.append("电影类型: ${genre.uppercase()}\n")
    result.append("评分: ${String.format("%.1f", rating)}/10\n")
    result.append("年份: ${year} 年\n")
    result.append("距今: ${yearDifference} 年\n\n")

    result.append("⭐ 评分评估\n")
    result.append("─".repeat(60)).append("\n")
    result.append("评分等级: ${ratingLevel}\n")
    result.append("推荐指数: ${recommendationScore}/100\n")
    result.append("热度评分: ${trendScore}/100\n\n")

    result.append("💬 推荐理由\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${recommendationReason}\n\n")

    result.append("👁️ 观看建议\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${viewingAdvice}\n\n")

    result.append("🎥 相似电影推荐\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${similarMovies}\n\n")

    result.append("👥 观众评价\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${audienceReview}\n\n")

    result.append("⏱️ 观看时长\n")
    result.append("─".repeat(60)).append("\n")
    result.append("${viewingDuration}\n\n")

    result.append("📋 电影类型说明\n")
    result.append("─".repeat(60)).append("\n")
    result.append("• 动作片(Action): 充满刺激、冒险和视觉效果的电影\n")
    result.append("• 喜剧片(Comedy): 以幽默和娱乐为主的电影\n")
    result.append("• 剧情片(Drama): 以深度故事和情感表达为主的电影\n")
    result.append("• 恐怖片(Horror): 以恐怖和惊悚为主的电影\n")
    result.append("• 爱情片(Romance): 以爱情故事为主的电影\n")
    result.append("• 科幻片(Sci-Fi): 以科幻和想象力为主的电影\n")
    result.append("• 悬念片(Thriller): 以悬念和刺激为主的电影\n\n")

    result.append("🎯 观影建议\n")
    result.append("─".repeat(60)).append("\n")
    result.append("1. 根据推荐指数选择观看优先级\n")
    result.append("2. 根据热度评分了解电影的当前热度\n")
    result.append("3. 根据观看建议选择合适的观看环境\n")
    result.append("4. 根据相似电影推荐发现更多好电影\n")
    result.append("5. 根据观众评价了解其他观众的看法\n")
    result.append("6. 根据观看时长安排合适的观看时间\n")
    result.append("7. 不要被评分完全左右，选择自己喜欢的类型\n")
    result.append("8. 多看不同类型的电影，拓宽视野\n")
    result.append("9. 观看后可以分享自己的评价和感受\n")
    result.append("10. 定期更新观看列表，不断发现新电影\n")

    return result.toString()
}

代码说明

这段 Kotlin 代码实现了完整的电影评分推荐和评估功能。让我详细解释关键部分：

数据验证：首先验证输入的电影名称、类型、评分和年份是否有效，确保数据在合理范围内。

评分等级判断：根据评分将电影分为六个等级，从杰作到不及格，帮助用户快速了解电影质量。

推荐指数计算：基于评分和年份计算推荐指数，新电影会获得加分，使得推荐更加合理。

热度评分计算：根据电影的年份计算热度评分，反映电影的当前热度和关注度。

推荐理由生成：根据评分等级生成相应的推荐理由，帮助用户了解为什么推荐这部电影。

观看建议：根据电影类型提供相应的观看建议，包括观看环境和观看方式。

相似电影推荐：根据电影类型推荐相似的电影，帮助用户发现更多好电影。

---

JavaScript 调用示例

编译后的 JavaScript 代码可以在 Node.js 或浏览器中直接调用。以下是 JavaScript 的使用示例：

// 导入编译后的 Kotlin/JS 模块
const { movieRecommendationSystem } = require('./hellokjs.js');

// 示例 1：杰作级动作片
const result1 = movieRecommendationSystem("Inception action 8.8 2010");
console.log("示例 1 - 杰作级动作片:");
console.log(result1);
console.log("\n");

// 示例 2：优秀喜剧片
const result2 = movieRecommendationSystem("Superbad comedy 7.6 2007");
console.log("示例 2 - 优秀喜剧片:");
console.log(result2);
console.log("\n");

// 示例 3：经典剧情片
const result3 = movieRecommendationSystem("Forrest_Gump drama 8.8 1994");
console.log("示例 3 - 经典剧情片:");
console.log(result3);
console.log("\n");

// 示例 4：恐怖片
const result4 = movieRecommendationSystem("The_Ring horror 7.1 2002");
console.log("示例 4 - 恐怖片:");
console.log(result4);
console.log("\n");

// 示例 5：爱情片
const result5 = movieRecommendationSystem("Titanic romance 7.8 1997");
console.log("示例 5 - 爱情片:");
console.log(result5);
console.log("\n");

// 示例 6：使用默认参数
const result6 = movieRecommendationSystem();
console.log("示例 6 - 使用默认参数:");
console.log(result6);

// 实际应用场景：从用户输入获取数据
function getMovieRecommendation(userInput) {
    try {
        const result = movieRecommendationSystem(userInput);
        return {
            success: true,
            data: result
        };
    } catch (error) {
        return {
            success: false,
            error: error.message
        };
    }
}

// 测试实际应用
const userInput = "Interstellar sci-fi 8.6 2014";
const recommendation = getMovieRecommendation(userInput);
if (recommendation.success) {
    console.log("电影推荐结果:");
    console.log(recommendation.data);
} else {
    console.log("推荐失败:", recommendation.error);
}

// 电影推荐列表应用示例
function getMovieRecommendationList(movies) {
    console.log("\n电影推荐列表:");
    console.log("═".repeat(60));
    
    const results = movies.map((movie, index) => {
        const recommendation = movieRecommendationSystem(movie);
        return {
            number: index + 1,
            movie,
            recommendation
        };
    });

    results.forEach(result => {
        console.log(`\n第 ${result.number} 部 (${result.movie}):`);
        console.log(result.recommendation);
    });

    return results;
}

// 测试电影推荐列表
const movies = [
    "Inception action 8.8 2010",
    "Forrest_Gump drama 8.8 1994",
    "The_Shawshank_Redemption drama 9.3 1994",
    "Interstellar sci-fi 8.6 2014",
    "Titanic romance 7.8 1997"
];

getMovieRecommendationList(movies);

// 电影评分分析
function analyzeMovieRatings(movies) {
    const ratings = movies.map(movie => {
        const parts = movie.split(' ');
        return parseFloat(parts[2]);
    });

    const avgRating = ratings.reduce((a, b) => a + b, 0) / ratings.length;
    const maxRating = Math.max(...ratings);
    const minRating = Math.min(...ratings);

    console.log("\n电影评分分析:");
    console.log(`平均评分: ${avgRating.toFixed(1)}/10`);
    console.log(`最高评分: ${maxRating.toFixed(1)}/10`);
    console.log(`最低评分: ${minRating.toFixed(1)}/10`);
    console.log(`评分跨度: ${(maxRating - minRating).toFixed(1)}`);
}

analyzeMovieRatings(movies);

JavaScript 代码说明

这段 JavaScript 代码展示了如何在 Node.js 环境中调用编译后的 Kotlin 函数。关键点包括：

模块导入：使用 require 导入编译后的 JavaScript 模块，获取导出的 movieRecommendationSystem 函数。

多个示例：展示了不同类型和评分的电影调用方式。

错误处理：在实际应用中，使用 try-catch 块来处理可能的错误，确保程序的稳定性。

电影推荐列表：getMovieRecommendationList 函数展示了如何处理多部电影的推荐，这在实际的电影应用中很常见。

评分分析：analyzeMovieRatings 函数演示了如何进行电影评分的统计分析。

---

ArkTS 页面集成与调用

在 OpenHarmony 的 ArkTS 页面中集成这个电影评分推荐系统。以下是完整的 ArkTS 实现代码：

import { movieRecommendationSystem } from './hellokjs';

@Entry
@Component
struct MovieRecommendationPage {
  @State movieName: string = "Inception";
  @State genre: string = "action";
  @State rating: string = "8.8";
  @State year: string = "2010";
  @State recommendationResult: string = "";
  @State isLoading: boolean = false;

  private genres = ["action", "comedy", "drama", "horror", "romance", "sci-fi", "thriller"];

  build() {
    Column() {
      // 顶部栏
      Row() {
        Text("🎬 电影推荐系统")
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
          .fontColor(Color.White)
      }
      .width("100%")
      .height(60)
      .backgroundColor("#E91E63")
      .justifyContent(FlexAlign.Center)
      .padding({ top: 10, bottom: 10 })

      // 主容器
      Scroll() {
        Column() {
          // 电影名称输入
          Text("电影名称")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ top: 20, left: 15 })

          TextInput({
            placeholder: "例如: Inception",
            text: this.movieName
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#F8BBD0")
            .border({ width: 1, color: "#E91E63" })
            .onChange((value: string) => {
              this.movieName = value;
            })

          // 电影类型选择
          Text("电影类型")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          Select(this.genres)
            .value(this.genre)
            .onSelect((index: number, value?: string) => {
              this.genre = value || this.genres[index];
            })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .backgroundColor("#F8BBD0")
            .border({ width: 1, color: "#E91E63" })

          // 评分输入
          Text("评分 (0-10)")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          TextInput({
            placeholder: "例如: 8.8",
            text: this.rating
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#F8BBD0")
            .border({ width: 1, color: "#E91E63" })
            .onChange((value: string) => {
              this.rating = value;
            })

          // 年份输入
          Text("年份")
            .fontSize(14)
            .fontColor("#333333")
            .margin({ left: 15 })

          TextInput({
            placeholder: "例如: 2010",
            text: this.year
          })
            .width("90%")
            .height(45)
            .margin({ top: 8, bottom: 15, left: 15, right: 15 })
            .padding({ left: 10, right: 10 })
            .backgroundColor("#F8BBD0")
            .border({ width: 1, color: "#E91E63" })
            .onChange((value: string) => {
              this.year = value;
            })

          // 按钮区域
          Row() {
            Button("🎥 获取推荐")
              .width("45%")
              .height(45)
              .backgroundColor("#E91E63")
              .fontColor(Color.White)
              .fontSize(16)
              .fontWeight(FontWeight.Bold)
              .onClick(() => {
                this.isLoading = true;
                setTimeout(() => {
                  const input = `${this.movieName} ${this.genre} ${this.rating} ${this.year}`;
                  this.recommendationResult = movieRecommendationSystem(input);
                  this.isLoading = false;
                }, 300);
              })

            Blank()

            Button("🔄 重置")
              .width("45%")
              .height(45)
              .backgroundColor("#2196F3")
              .fontColor(Color.White)
              .fontSize(16)
              .fontWeight(FontWeight.Bold)
              .onClick(() => {
                this.movieName = "Inception";
                this.genre = "action";
                this.rating = "8.8";
                this.year = "2010";
                this.recommendationResult = "";
                this.isLoading = false;
              })
          }
          .width("90%")
          .margin({ top: 10, bottom: 20, left: 15, right: 15 })
          .justifyContent(FlexAlign.SpaceBetween)

          // 加载指示器
          if (this.isLoading) {
            Row() {
              LoadingProgress()
                .width(40)
                .height(40)
                .color("#E91E63")
              Text("  正在生成推荐中...")
                .fontSize(14)
                .fontColor("#666666")
            }
            .width("90%")
            .height(50)
            .margin({ bottom: 15, left: 15, right: 15 })
            .justifyContent(FlexAlign.Center)
            .backgroundColor("#F8BBD0")
            .borderRadius(8)
          }

          // 结果显示区域
          if (this.recommendationResult.length > 0) {
            Column() {
              Text("📋 推荐结果")
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor("#E91E63")
                .margin({ bottom: 10 })

              Text(this.recommendationResult)
                .width("100%")
                .fontSize(12)
                .fontFamily("monospace")
                .fontColor("#333333")
                .lineHeight(1.6)
                .padding(10)
                .backgroundColor("#FAFAFA")
                .border({ width: 1, color: "#E0E0E0" })
                .borderRadius(8)
            }
            .width("90%")
            .margin({ top: 20, bottom: 30, left: 15, right: 15 })
            .padding(15)
            .backgroundColor("#F8BBD0")
            .borderRadius(8)
            .border({ width: 1, color: "#E91E63" })
          }
        }
        .width("100%")
      }
      .layoutWeight(1)
      .backgroundColor("#FFFFFF")
    }
    .width("100%")
    .height("100%")
    .backgroundColor("#F5F5F5")
  }
}

ArkTS 代码说明

这段 ArkTS 代码实现了完整的用户界面和交互逻辑。关键点包括：

导入函数：从编译后的 JavaScript 模块中导入 movieRecommendationSystem 函数。

状态管理：使用 @State 装饰器管理六个状态：电影名称、电影类型、评分、年份、推荐结果和加载状态。

UI 布局：包含顶部栏、电影名称输入框、电影类型下拉选择、评分输入框、年份输入框、获取推荐和重置按钮、加载指示器和结果显示区域。

交互逻辑：用户输入电影信息后，点击获取推荐按钮。应用会调用 Kotlin 函数生成推荐，显示加载动画，最后展示详细的推荐结果。

样式设计：使用粉红色主题，与娱乐和电影相关的主题相符。所有输入框、按钮和结果显示区域都有相应的样式设置，提供清晰的视觉层次。

---

数据输入与交互体验

输入数据格式规范

为了确保工具能够正确处理用户输入，用户应该遵循以下规范：

1. 电影名称：字符串，可包含下划线（用下划线代替空格）。
2. 电影类型：action、comedy、drama、horror、romance、sci-fi、thriller 之一。
3. 评分：浮点数，范围 0-10。
4. 年份：整数，范围 1900-2100。
5. 分隔符：使用空格分隔各个参数。

示例输入

• 杰作级动作片：Inception action 8.8 2010
• 优秀喜剧片：Superbad comedy 7.6 2007
• 经典剧情片：Forrest_Gump drama 8.8 1994
• 恐怖片：The_Ring horror 7.1 2002
• 爱情片：Titanic romance 7.8 1997

交互流程

1. 用户打开应用，看到输入框和默认数据
2. 用户输入电影名称、选择类型、输入评分和年份
3. 点击"获取推荐"按钮，应用调用 Kotlin 函数生成推荐
4. 应用显示加载动画，表示正在处理
5. 生成完成后，显示详细的推荐结果，包括评分评估、推荐理由、观看建议、相似电影推荐等
6. 用户可以点击"重置"按钮清空数据，重新开始

---

编译与自动复制流程

编译步骤

1. 编译 Kotlin 代码：

   ./gradlew build
   

2. 生成 JavaScript 文件：
   编译过程会自动生成 hellokjs.d.ts 和 hellokjs.js 文件。

3. 复制到 ArkTS 项目：
   使用提供的脚本自动复制生成的文件到 ArkTS 项目的 pages 目录：

   ./build-and-copy.bat
   

文件结构

编译完成后，项目结构如下：

kmp_openharmony/
├── src/
│   └── jsMain/
│       └── kotlin/
│           └── App.kt (包含 movieRecommendationSystem 函数)
├── build/
│   └── js/
│       └── packages/
│           └── hellokjs/
│               ├── hellokjs.d.ts
│               └── hellokjs.js
└── kmp_ceshiapp/
    └── entry/
        └── src/
            └── main/
                └── ets/
                    └── pages/
                        ├── hellokjs.d.ts (复制后)
                        ├── hellokjs.js (复制后)
                        └── Index.ets (ArkTS 页面)

---

总结

这个案例展示了如何使用 Kotlin Multiplatform 技术实现一个跨端的娱乐工具 - 电影评分推荐系统。通过将核心逻辑写在 Kotlin 中，然后编译为 JavaScript，最后在 ArkTS 中调用，我们实现了代码的一次编写、多端复用。

核心优势

1. 代码复用：Kotlin 代码可以在 JVM、JavaScript 和其他平台上运行，避免重复开发。
2. 类型安全：Kotlin 的类型系统确保了代码的安全性和可维护性。
3. 性能优化：Kotlin 编译为 JavaScript 后，性能与手写 JavaScript 相当。
4. 易于维护：集中管理业务逻辑，使得维护和更新变得更加容易。
5. 用户体验：通过 ArkTS 提供的丰富 UI 组件，可以创建美观、易用的用户界面。

扩展方向

1. 数据持久化：将用户的电影观看记录和评分保存到本地存储或云端。
2. 数据可视化：使用图表库展示电影评分分布和类型统计。
3. 个性化推荐：根据用户的观看历史和偏好提供个性化推荐。
4. 社交功能：允许用户分享评价和相互推荐电影。
5. 集成电影数据库：连接 IMDb、豆瓣等电影数据库获取更多信息。
6. AI 优化：使用机器学习根据用户反馈优化推荐算法。
7. 评论系统：允许用户发表评论和查看其他用户的评价。
8. 观影提醒：提醒用户新电影上映和推荐的电影。

通过这个案例，开发者可以学到如何在 KMP 项目中实现复杂的电影推荐逻辑，以及如何在 OpenHarmony 平台上构建高效的跨端应用。这个电影评分推荐系统可以作为电影应用、娱乐平台或推荐系统的核心模块。