Scala.js 与 Scala Native：跨平台编译、互操作与工程实践

JVM 平台    → 编译为字节码，跑在 JVM（后端服务/大数据）
JS 平台     → 编译为 JavaScript（浏览器/Node）
Native 平台 → 编译为机器码，无运行时（CLI/嵌入式/低延迟）

- 标准库子集：js/native 平台比 JVM 平台库少（无 java.* 全量）
- 反射：Native 无完整反射，JS 有限
- 并发：JVM 线程、JS 事件循环、Native 原生线程

// project/plugins.sbt
addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.16.0")

// build.sbt
enablePlugins(ScalaJSPlugin)
scalaJSUseMainModuleInitializer := true

import org.scalajs.dom
import org.scalajs.dom.document

object Main {
  def main(args: Array[String]): Unit = {
    val p = document.createElement("p")
    p.textContent = "Hello from Scala.js"
    document.body.appendChild(p)
  }
}

sbt ~fastLinkJS    # 开发：快速链接（.js 增量）
sbt fullLinkJS     # 生产：全量优化（.js 压缩）
sbt run            # 或直接跑（配合 scalajs-bundler）

import org.scalajs.dom.window
window.addEventListener("click", e => dom.console.log("clicked"))

① scalajs-react：React 的 Scala 类型安全封装
② Laminar：响应式声明式 UI（fp 风格）
③ 直接 DOM：轻量场景手写

import com.raquo.laminar.api.L._

val count = Var(0)
val app = div(
  span(child.text <-- count.signal),
  button("+1", onClick --> (_ => count.update(_ + 1)))
)

- 团队熟悉 React → scalajs-react
- 想要纯函数式响应式 → Laminar
- 需要与既有 JS 组件大量互操作 → 直接 JS 封装（见第 4 节）

import scala.scalajs.js
val lib = js.Dynamic.global.someLib
lib.doThing("arg")          // 动态调用，无类型检查

@js.native
trait Window extends js.Object {
  def innerWidth: Int
  def fetch(url: String): js.Promise[js.Object]
}

object Api {
  @JSExportTopLevel("scalaApi")
  def greet(name: String): String = s"Hello $name"
}
// JS 里直接调用 window.scalaApi.greet("world")

□ 边界用原生类型（String/Int/Boolean/Array）传值
□ 复杂结构用 js.Object / js.Array，避免 Scala 类型直穿
□ 异步用 js.Promise / Future 互转
□ js.Dynamic 是逃生门，用了就失去类型安全

import scala.concurrent.{Future, Promise}
import scala.scalajs.js.JSConverters._
val f: Future[Int] = jsPromise.toFuture   // js → scala
val jp: js.Promise[Int] = future.toJSPromise  // scala → js

// project/plugins.sbt
addSbtPlugin("org.scala-native" % "sbt-scala-native" % "0.5.4")

// build.sbt
enablePlugins(ScalaNativePlugin)

object Main {
  def main(args: Array[String]): Unit =
    println("Hello, native world!")
}

sbt nativeLink    # 生成可执行二进制（target/scala-3.x/xxx-out）
sbt run           # 直接运行

- 命令行工具（秒启，无需 JVM）
- 边缘/嵌入式设备
- 需要低内存与快速启动的服务

import scala.scalanative.unsafe._

@extern
object libc {
  def malloc(size: CSize): Ptr[Byte] = extern
  def free(ptr: Ptr[Byte]): Unit     = extern
}

// Ptr（指针）、CSize、CString、CInt 等映射 C 类型
def cstr(s: String): CString = toCString(s)
val p: Ptr[Int] = stackalloc[Int](4)   // 栈分配

□ malloc 必配 free / Resource 作用域
□ 用 Zone/Resource 自动释放
□ 指针离开作用域小心悬垂
□ toCString 需要显式生命周期

import scala.scalanative.unsafe.Zone
Zone.acquire { implicit zone =>
  val s = toCString("hello")   // 随 Zone 自动释放
  libc.printf(s)
}

lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)
  .in(file("core"))
  .settings(sharedSettings)      // 公共设置

lazy val coreJVM    = core.jvm
lazy val coreJS     = core.js
lazy val coreNative = core.native

core/
  shared/src/main/scala/   ← 三平台共享的纯逻辑
  jvm/src/main/scala/      ← JVM 特定实现
  js/src/main/scala/       ← JS 特定实现
  native/src/main/scala/   ← Native 特定实现

// shared：定义接口
trait Platform {
  def currentTimeMillis: Long
}

// 各平台各自实现
// jvm: object Platform extends Platform { def currentTimeMillis = System.currentTimeMillis() }
// js:  object Platform extends Platform { def currentTimeMillis = js.Date.now() }

启动速度：Native（毫秒） >> JVM（秒级） > JS（依运行时）
峰值性能：JVM ≥ Native ≥ JS（高度优化后）
内存开销：Native < JVM（GC 差异）≈ JS
预热：Native 无预热、JVM 需 JIT 预热

JVM 平台   → fat jar / Docker / sbt-assembly
JS 平台    → npm 包 / 静态资源 / 配合 Vite/webpack
Native 平台 → 独立二进制 / 系统包 / Docker（scratch 镜像）

// build.sbt
Compile / npmPackage := ...   // scalajs-bundler 出 npm 包

sbt nativeLink → 拷贝二进制到 /usr/local/bin
或用 sbt-native-packager 打 deb/rpm 包

# Native 二进制跑在精简镜像
FROM scratch
COPY mytool /usr/local/bin/mytool
ENTRYPOINT ["mytool"]