Scala 3 — Book

Scala for JavaScript Developers

Info: JavaScript is currently disabled, code tabs will still work, but preferences will not be remembered.

此页面提供了 JavaScript 和 Scala 编程语言之间的比较。它适用于了解 JavaScript 并希望了解 Scala 的程序员，特别是通过查看 JavaScript 语言功能与 Scala 比较的示例。

概述

本节对以下各节进行了相对简短的介绍和总结。它从高层次上介绍了 JavaScript 和 Scala 之间的异同，然后介绍了您在每天编写代码时会遇到的差异。

高层次的相似性

在高层次上，Scala 与 JavaScript 有以下相似之处：

两者都被认为是高级编程语言，您不必关心指针和手动内存管理等低级概念
两者都有一个相对简单、简洁的语法
两者都支持 C/C++/Java 风格的花括号语法，用于编写方法和其他代码块
两者都包括面向对象编程 (OOP) 的特性（如类）
两者都包含用于函数式编程 (FP) 的（如 lambda）
JavaScript 在浏览器和 Node.js 等其他环境中运行。 Scala 的 Scala.js 风格以 JavaScript 为目标，因此 Scala 程序可以在相同的环境中运行。
开发人员使用 Node.js 在 JavaScript 和 Scala 中编写服务器端应用程序； Play Framework 之类的项目也可以让您在 Scala 中编写服务器端应用程序
两种语言都有相似的 if 语句、while 循环和 for 循环
从在这个 Scala.js 页面开始，您会发现许多支持 React、Angular、jQuery 和许多其他 JavaScript 和Scala 库
JavaScript 对象是可变的；以命令式风格编写时，Scala 对象_可以_是可变的
JavaScript 和 Scala 都支持 promises 作为处理异步计算结果的一种方式（Scala concurrency 使用期货和承诺）

高层次差异

同样在高层次上，JavaScript 和 Scala 之间的一些区别是：

JavaScript 是动态类型的，Scala 是静态类型的
- 尽管 Scala 是静态类型的，但类型推断之类的特性让它感觉像是一种动态语言（正如您将在下面的示例中看到的那样）
Scala 惯用语默认支持不变性：鼓励您使用不可变变量和不可变集合
Scala 语法简洁易读；我们称之为_表现力_
Scala 是一种纯 OOP 语言，因此每个对象都是类的一个实例，而像运算符一样的符号 + 和 += 是真正的方法；这意味着您可以创建自己的方法作为运算符
作为一种纯 OOP 语言和纯 FP 语言，Scala 鼓励 OOP 和 FP 的融合，具有用于逻辑的函数和用于模块化的不可变对象
Scala 拥有最先进的第三方开源函数式编程库
Scala 中的一切都是一个_表达式_：像 if 语句、for 循环、match 表达式，甚至 try/catch 表达式都有返回值
Scala Native 项目让您可以编写“系统”级代码，也可以编译为本机可执行文件

编程层次差异

在较低的层次上，这些是您在编写代码时每天都会看到的一些差异：

Scala 变量和参数使用 val（不可变，如 JavaScript const）或 var（可变，如 JavaScript var 或 let）定义
Scala 不在行尾使用分号
Scala 是静态类型的，尽管在许多情况下您不需要声明类型
Scala 使用 trait 作为接口并创建_混搭_
除了简单的 for 循环之外，Scala 还具有强大的 for comprehensions，可以根据您的算法产生结果
模式匹配和 match 表达式将改变你编写代码的方式
Scala 的 Scala 的上下文抽象和 术语推导 提供了一系列特性：
- 扩展方法允许您在不破坏模块化的情况下向封闭类添加新功能，方法是仅在特定范围内可用（与猴子补丁相反，它会污染代码的其他区域）
- 给实例让您定义编译器可以用来为您合成代码的术语
- 类型安全和多元等式让您将相等比较——在编译时——仅限于那些有意义的比较
由于名称参数、中缀符号、可选括号、扩展方法和高阶函数等功能，您可以创建自己的“控制结构”和 DSL
您可以在本书中阅读到许多其他好东西：样例类、伴生类和对象、宏、[联合][union-type]和交集类型、多参数列表、命名参数等

变量和类型

注释

//
        
/* ... */
        
/** ... */

//
        
/* ... */
        
/** ... */

可变变量

let   // now preferred for mutable
        
var   // old mutable style

var // used for mutable variables

不可变变量

const

val

Scala 的经验法则是使用 val 声明变量，除非有特定原因需要可变变量。

命名标准

JavaScript 和 Scala 通常使用相同的 CamelCase 命名标准。变量命名为 myVariableName，方法命名为 lastIndexOf，类和对象命名为 Animal 和 PrintedBook 。

字符串

JavaScript 和 Scala 中字符串的许多用法相似，但 Scala 仅对简单字符串使用双引号，对多行字符串使用三引号。

字符串基础

// use single- or double-quotes
        
let msg = 'Hello, world';
        
let msg = "Hello, world";

// use only double-quotes
        
val msg = "Hello, world"

插入

let name = 'Joe';
        

        
// JavaScript uses backticks
        
let msg = `Hello, ${name}`;

val name = "Joe"
        
val age = 42
        
val weight = 180.5
        

        
// use `s` before a string for simple interpolation
        
println(s"Hi, $name")   // "Hi, Joe"
        
println(s"${1 + 1}")    // "2"
        

        
// `f` before a string allows printf-style formatting.
        
// this example prints:
        
// "Joe is 42 years old, and weighs"
        
// "180.5 pounds."
        
println(f"$name is $age years old, and weighs $weight%.1f pounds.")

带插入的多行字符串

let name = "joe";
        
let str = `
        
Hello, ${name}.
        
This is a multiline string.
        
`;

val name = "Martin Odersky"
        

        
val quote = s"""
        
  |$name says
        
  |Scala is a fusion of
        
  |OOP and FP.
        
""".stripMargin.replaceAll("\n", " ").trim
        

        
// result:
        
// "Martin Odersky says Scala is a fusion of OOP and FP."

JavaScript 和 Scala 也有类似的处理字符串的方法，包括 charAt、concat、indexOf 等等。 \n、\f、\t 等转义字符在两种语言中也是相同的。

数字和算术

JavaScript 和 Scala 之间的数字运算符很相似。最大的不同是 Scala 不提供 ++ 和 -- 运算符。

数字运算符：

let x = 1;
        
let y = 2.0;
        
 
        
let a = 1 + 1;
        
let b = 2 - 1;
        
let c = 2 * 2;
        
let d = 4 / 2;
        
let e = 5 % 2;

val x = 1
        
val y = 2.0
        
 
        
val a = 1 + 1
        
val b = 2 - 1
        
val c = 2 * 2
        
val d = 4 / 2
        
val e = 5 % 2

自增和自减：

i++;
        
i += 1;
        

        
i--;
        
i -= 1;

i += 1;
        
i -= 1;

或许最大的区别在于像+和-这样的“操作符”在Scala中实际上是_方法_，而不是操作符。 Scala 数字也有这些相关的方法：

var a = 2
a *= 2      // 4
a /= 2      // 2

Scala 的 Double 类型最接近于 JavaScript 的默认 number 类型， Int 表示有符号的 32 位整数值，而 BigInt 对应于 JavaScript 的 bigint。

这些是 Scala Int 和 Double 值。请注意，类型不必显式声明：

val i = 1     // Int
val d = 1.1   // Double

你可以按需要使用其它数字类型：

val a: Byte = 0    // Byte = 0
val a: Double = 0  // Double = 0.0
val a: Float = 0   // Float = 0.0
val a: Int = 0     // Int = 0
val a: Long = 0    // Long = 0
val a: Short = 0   // Short = 0

val x = BigInt(1_234_456_789)
val y = BigDecimal(1_234_456.890)

布尔值

两个语言都在布尔值中用 true 和 false。

let a = true;
        
let b = false;

val a = true
        
val b = false

日期

日期是两种语言中另一种常用的类型。

获取当前日期：

let d = new Date();

        
// result:
        
// Sun Nov 29 2020 18:47:57 GMT-0700 (Mountain Standard Time)

// different ways to get the current date and time
        
import java.time.*
        

        
val a = LocalDate.now
        
    // 2020-11-29
        
val b = LocalTime.now
        
    // 18:46:38.563737
        
val c = LocalDateTime.now
        
    // 2020-11-29T18:46:38.563750
        
val d = Instant.now
        
    // 2020-11-30T01:46:38.563759Z

指定不同的日期：

let d = Date(2020, 1, 21, 1, 0, 0, 0);
        
let d = Date(2020, 1, 21, 1, 0, 0);
        
let d = Date(2020, 1, 21, 1, 0);
        
let d = Date(2020, 1, 21, 1);
        
let d = Date(2020, 1, 21);

val d = LocalDate.of(2020, 1, 21)
        
val d = LocalDate.of(2020, Month.JANUARY, 21)
        
val d = LocalDate.of(2020, 1, 1).plusDays(20)

在这种情况下，Scala 使用 Java 附带的日期和时间类。 JavaScript 和 Scala 之间的许多日期/时间方法是相似的。有关详细信息，请参阅 java.time 包。

函数

在 JavaScript 和 Scala 中，函数都是对象，因此它们的功能相似，但它们的语法和术语略有不同。

命名函数，一行：

function add(a, b) {
        
  return a + b;
        
}
        
add(2, 2);   // 4

// technically this is a method, not a function
        
def add(a: Int, b: Int) = a + b
        
add(2, 2)   // 4

命名函数，多行：

function addAndDouble(a, b) {
        
  // imagine this requires
        
  // multiple lines
        
  return (a + b) * 2
        
}

def addAndDouble(a: Int, b: Int): Int =
        
  // imagine this requires
        
  // multiple lines
        
  (a + b) * 2

在 Scala 中，显示 Int 返回类型是可选的。它_不_显示在 add 示例中，而_是_显示在 addAndDouble 示例中，因此您可以看到这两种方法。

匿名函数

JavaScript 和 Scala 都允许您定义匿名函数，您可以将其传递给其他函数和方法。

箭头和匿名函数

// arrow function
        
let log = (s) => console.log(s)
        

        
// anonymous function
        
let log = function(s) {
        
  console.log(s);
        
}
        

        
// use either of those functions here
        
function printA(a, log) {
        
  log(a);
        
}

// a function (an anonymous function assigned to a variable)
        
val log = (s: String) => console.log(s)
        

        
// a scala method. methods tend to be used much more often,
        
// probably because they’re easier to read.
        
def log(a: Any) = console.log(a)
        

        
// a function or a method can be passed into another
        
// function or method
        
def printA(a: Any, f: log: Any => Unit) = log(a)

在 Scala 中，您很少使用所示的第一种语法来定义函数。相反，您经常在使用点定义匿名函数。许多集合方法是高阶函数并接受函数参数，因此您编写如下代码：

// map method, long form
List(1,2,3).map(i => i * 10)   // List(10,20,30)

// map, short form (which is more commonly used)
List(1,2,3).map(_ * 10)        // List(10,20,30)

// filter, short form
List(1,2,3).filter(_ < 3)      // List(1,2)

// filter and then map
List(1,2,3,4,5).filter(_ < 3).map(_ * 10)   // List(10, 20)

类

Scala 既有类也有样例类。类与 JavaScript 类相似，通常用于 OOP 风格应用程序（尽管它们也可以在 FP 代码中使用），并且 _样例类_有附加的特性，这让它在 FP 风格应用中很有用。

下面的例子展示了如何创建几个类型作为枚举，然后定义一个 OOP 风格的 Pizza 类。最后，创建并使用了一个 Pizza 实例：

// create some enumerations that the Pizza class will use
enum CrustSize:
  case Small, Medium, Large

enum CrustType:
  case Thin, Thick, Regular

enum Topping:
  case Cheese, Pepperoni, BlackOlives, GreenOlives, Onions

// import those enumerations and the ArrayBuffer,
// so the Pizza class can use them
import CrustSize.*
import CrustType.*
import Topping.*
import scala.collection.mutable.ArrayBuffer

// define an OOP style Pizza class
class Pizza(
  var crustSize: CrustSize,
  var crustType: CrustType
):

  private val toppings = ArrayBuffer[Topping]()

  def addTopping(t: Topping): Unit =
    toppings += t

  def removeTopping(t: Topping): Unit =
    toppings -= t

  def removeAllToppings(): Unit =
    toppings.clear()

  override def toString(): String =
    s"""
      |Pizza:
      |  Crust Size: ${crustSize}
      |  Crust Type: ${crustType}
      |  Toppings:   ${toppings}
    """.stripMargin

end Pizza

// create a Pizza instance
val p = Pizza(Small, Thin)

// change the crust
p.crustSize = Large
p.crustType = Thick

// add and remove toppings
p.addTopping(Cheese)
p.addTopping(Pepperoni)
p.addTopping(BlackOlives)
p.removeTopping(Pepperoni)

// print the pizza, which uses its `toString` method
println(p)

接口、trait 和继承

Scala 使用 trait 作为接口，也可以创建混搭。 trait 可以有抽象和具体的成员，包括方法和字段。

这个例子展示了如何定义两个 traits，创建一个扩展和实现这些 traits 的类，然后创建和使用该类的一个实例：

trait HasLegs:
  def numLegs: Int
  def walk(): Unit
  def stop() = println("Stopped walking")

trait HasTail:
  def wagTail(): Unit
  def stopTail(): Unit

class Dog(var name: String) extends HasLegs, HasTail:
  val numLegs = 4
  def walk() = println("I’m walking")
  def wagTail() = println("⎞⎜⎛  ⎞⎜⎛")
  def stopTail() = println("Tail is stopped")
  override def toString = s"$name is a Dog"

// create a Dog instance
val d = Dog("Rover")

// use the class’s attributes and behaviors
println(d.numLegs)   // 4
d.wagTail()          // "⎞⎜⎛  ⎞⎜⎛"
d.walk()             // "I’m walking"

控制结构

除了在 JavaScript 中使用 === 和 !== 之外，比较和逻辑运算符在 JavaScript 和 Scala 中几乎相同。

比较运算符

JavaScript	Scala
`==`	`==`
`===`	`==`
`!=`	`!=`
`!==`	`!=`
`>`	`>`
`<`	`<`
`>=`	`>=`
`<=`	`<=`

逻辑运算符

JavaScript	Scala
`&& \|\| !`	`&& \|\| !`

if/then/else 表达式

JavaScript和 Scala if/then/else 语句相似。在 Scala 2 中它们几乎相同，但在 Scala 3 中，花括号不再是必需的（尽管它们仍然可以使用）。

`if` 语句，单行：

if (x == 1) { console.log(1); }

if x == 1 then println(x)

`if` 语句，多行：

if (x == 1) {
        
  console.log("x is 1, as you can see:")
        
  console.log(x)
        
}

if x == 1 then
        
  println("x is 1, as you can see:")
        
  println(x)

if, else if, else:

if (x < 0) {
        
  console.log("negative")
        
} else if (x == 0) {
        
  console.log("zero")
        
} else {
        
  console.log("positive")
        
}

if x < 0 then
        
  println("negative")
        
else if x == 0
        
  println("zero")
        
else
        
  println("positive")

从 `if` 返回值：

JavaScript 使用三元运算符，Scala 像往常一样使用它的 if 表达式：

let minVal = a < b ? a : b;

val minValue = if a < b then a else b

`if` 作为方法体：

Scala 方法往往很短，您可以轻松地使用 if 作为方法体：

function min(a, b) {
        
  return (a < b) ? a : b;
        
}

def min(a: Int, b: Int): Int =
        
  if a < b then a else b

在 Scala 3 中，如果您愿意，您仍然可以使用“花括号”样式。例如，您可以像这样编写 if/else-if/else 表达式：

if (i == 0) {
  println(0)
} else if (i == 1) {
  println(1)
} else {
  println("other")
}

循环

JavaScript 和 Scala 都有 while 循环和 for 循环。 Scala 曾经有 do/while 循环，但它们已从语言中删除。

`while` 循环：

let i = 0;
        
while (i < 3) {
        
  console.log(i);
        
  i++;
        
}

var i = 0;
        
while i < 3 do
        
  println(i)
        
  i += 1

如果你愿意，Scala 代码也可以写成这样：

var i = 0
while (i < 3) {
  println(i)
  i += 1
}

以下示例展示了 JavaScript 和 Scala 中的“for”循环。他们假设您可以使用这些集合：

// JavaScript
let nums = [1, 2, 3];

// Scala
val nums = List(1, 2, 3)

`for` 循环，单行：

// newer syntax
        
for (let i of nums) {
        
  console.log(i);
        
}
        

        
// older
        
for (i=0; i<nums.length; i++) {
        
  console.log(nums[i]);
        
}

// preferred
        
for i <- ints do println(i)
        

        
// also available
        
for (i <- ints) println(i)

`for` 循环，在循环体内多行

// preferred
        
for (let i of nums) {
        
  let j = i * 2;
        
  console.log(j);
        
}
        

        
// also available
        
for (i=0; i<nums.length; i++) {
        
  let j = nums[i] * 2;
        
  console.log(j);
        
}

// preferred
        
for i <- ints do
        
  val i = i * 2
        
  println(j)
        

        
// also available
        
for (i <- nums) {
        
  val j = i * 2
        
  println(j)
        
}

在 `for` 循环中有多个生成器

let str = "ab";
        
for (let i = 1; i < 3; i++) {
        
  for (var j = 0; j < str.length; j++) {
        
    for (let k = 1; k < 11; k++) {
        
      let c = str.charAt(j);
        
      console.log(`i: ${i} j: ${c} k: ${k}`);
        
    }
        
  }
        
}

for
        
  i <- 1 to 2
        
  j <- 'a' to 'b'
        
  k <- 1 to 10 by 5
        
do
        
  println(s"i: $i, j: $j, k: $k")

带守卫的生成器

_守卫_是 for 表达式中的 if 表达式的名称。

for (let i = 0; i < 10; i++) {
        
  if (i % 2 == 0 && i < 5) {
        
    console.log(i);
        
  }
        
}

for
        
  i <- 1 to 10
        
  if i % 2 == 0
        
  if i < 5
        
do
        
  println(i)

`for` comprehension

for comprehension 是一个 for 循环，它使用 yield 返回（产生）一个值。它们经常在 Scala 中使用。

N/A

val list =
        
  for
        
    i <- 1 to 3
        
  yield
        
    i * 10
        
// result: Vector(10, 20, 30)

switch & match

JavaScript 有 switch 语句，Scala 有 match 表达式。就像 Scala 中的所有其他东西一样，这些确实是_表达式_，这意味着它们返回一个结果：

val day = 1

// later in the code ...
val monthAsString = day match
  case 1 => "January"
  case 2 => "February"
  case _ => "Other"

match 表达式可以在每个 case 语句中处理多个匹配项：

val numAsString = i match
  case 1 | 3 | 5 | 7 | 9 => "odd"
  case 2 | 4 | 6 | 8 | 10 => "even"
  case _ => "too big"

它们也可以用于方法体：

def isTruthy(a: Matchable) = a match
  case 0 | "" => false
  case _ => true

def isPerson(x: Matchable): Boolean = x match
  case p: Person => true
  case _ => false

match 表达式有许多其他模式匹配选项。

集合类

Scala 有不同的集合类来满足不同的需求。

常见的_不可变_序列是：

List
Vector

常见的_可变_序列是：

Array
ArrayBuffer

Scala 还有可变和不可变的 Map 和 Set。

这是创建常见 Scala 集合类型的方式：

val strings = List("a", "b", "c")
val strings = Vector("a", "b", "c")
val strings = ArrayBuffer("a", "b", "c")

val set = Set("a", "b", "a") // result: Set("a", "b")
val map = Map(
  "a" -> 1,
  "b" -> 2,
  "c" -> 3
)

集合上的方法

以下示例展示了使用 Scala 集合的许多不同方法。

填充列表：

// to, until
(1 to 5).toList                   // List(1, 2, 3, 4, 5)
(1 until 5).toList                // List(1, 2, 3, 4)

(1 to 10 by 2).toList             // List(1, 3, 5, 7, 9)
(1 until 10 by 2).toList          // List(1, 3, 5, 7, 9)
(1 to 10).by(2).toList            // List(1, 3, 5, 7, 9)

('d' to 'h').toList               // List(d, e, f, g, h)
('d' until 'h').toList            // List(d, e, f, g)
('a' to 'f').by(2).toList         // List(a, c, e)

// range method
List.range(1, 3)                  // List(1, 2)
List.range(1, 6, 2)               // List(1, 3, 5)

List.fill(3)("foo")               // List(foo, foo, foo)
List.tabulate(3)(n => n * n)      // List(0, 1, 4)
List.tabulate(4)(n => n * n)      // List(0, 1, 4, 9)

序列上的函数式方法：

// these examples use a List, but they’re the same with Vector
val a = List(10, 20, 30, 40, 10)      // List(10, 20, 30, 40, 10)
a.contains(20)                        // true
a.distinct                            // List(10, 20, 30, 40)
a.drop(2)                             // List(30, 40, 10)
a.dropRight(2)                        // List(10, 20, 30)
a.dropWhile(_ < 25)                   // List(30, 40, 10)
a.filter(_ < 25)                      // List(10, 20, 10)
a.filter(_ > 100)                     // List()
a.find(_ > 20)                        // Some(30)
a.head                                // 10
a.headOption                          // Some(10)
a.init                                // List(10, 20, 30, 40)
a.last                                // 10
a.lastOption                          // Some(10)
a.slice(2,4)                          // List(30, 40)
a.tail                                // List(20, 30, 40, 10)
a.take(3)                             // List(10, 20, 30)
a.takeRight(2)                        // List(40, 10)
a.takeWhile(_ < 30)                   // List(10, 20)

// map, flatMap
val fruits = List("apple", "pear")
fruits.map(_.toUpperCase)             // List(APPLE, PEAR)
fruits.flatMap(_.toUpperCase)         // List(A, P, P, L, E, P, E, A, R)

val nums = List(10, 5, 8, 1, 7)
nums.sorted                           // List(1, 5, 7, 8, 10)
nums.sortWith(_ < _)                  // List(1, 5, 7, 8, 10)
nums.sortWith(_ > _)                  // List(10, 8, 7, 5, 1)

List(1,2,3).updated(0,10)             // List(10, 2, 3)
List(2,4).union(List(1,3))            // List(2, 4, 1, 3)

// zip
val women = List("Wilma", "Betty")    // List(Wilma, Betty)
val men = List("Fred", "Barney")      // List(Fred, Barney)
val couples = women.zip(men)          // List((Wilma,Fred), (Betty,Barney))

Scala 有_很多_更多可供您使用的方法。所有这些方法的好处是：

您不必编写自定义的 for 循环来解决问题
当你阅读别人的代码时，你不必阅读他们自定义的 for 循环；你只会找到像这样的常用方法，因此更容易阅读来自不同项目的代码

元组

当您想将多个数据类型放在同一个列表中时，JavaScript 允许您这样做：

stuff = ["Joe", 42, 1.0];

在 Scala 中你这样做：

val a = ("eleven")
val b = ("eleven", 11)
val c = ("eleven", 11, 11.0)
val d = ("eleven", 11, 11.0, Person("Eleven"))

在 Scala 中，这些类型称为元组，如图所示，它们可以包含一个或多个元素，并且元素可以具有不同的类型。访问它们的元素就像访问 List、Vector 或 Array 的元素一样：

d(0)   // "eleven"
d(1)   // 11

枚举

JavaScript 没有枚举，但你可以这样做：

let Color = {
  RED: 1,
  GREEN: 2,
  BLUE: 3
};
Object.freeze(Color);

在 Scala 3 中，您可以使用枚举做很多事情。您可以创建该代码的等效代码：

enum Color:
  case Red, Green, Blue

你可以创建带参数的枚举：

enum Color(val rgb: Int):
  case Red   extends Color(0xFF0000)
  case Green extends Color(0x00FF00)
  case Blue  extends Color(0x0000FF)

你也可以创建用户自定义的枚举成员：

enum Planet(mass: Double, radius: Double):
  case Mercury extends Planet(3.303e+23, 2.4397e6)
  case Venus   extends Planet(4.869e+24,6.0518e6)
  case Earth   extends Planet(5.976e+24,6.37814e6)
  // more planets here ...

  private final val G = 6.67300E-11
  def surfaceGravity = G * mass / (radius * radius)
  def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity

Scala.js DOM 代码

Scala.js 允许您编写 Scala 代码，这些代码编译为 JavaScript 代码，然后可以在浏览器中使用。该方法类似于 TypeScript、ReScript 和其他编译为 JavaScript 的语言。

包含必要的库并在项目中导入必要的包后，编写 Scala.js 代码看起来与编写 JavaScript 代码非常相似：

// show an alert dialog on a button click
jQuery("#hello-button").click{() =>
  dom.window.alert("Hello, world")
}

// define a button and what should happen when it’s clicked
val btn = button(
  "Click me",
  onclick := { () =>
    dom.window.alert("Hello, world")
  })

// create two divs with css classes, an h2 element, and the button
val content =
  div(cls := "foo",
    div(cls := "bar",
      h2("Hello"),
      btn
    )
  )

// add the content to the DOM
val root = dom.document.getElementById("root")
root.innerHTML = ""
root.appendChild(content.render)

请注意，尽管 Scala 是一种类型安全的语言，但在上面的代码中没有声明任何类型。 Scala 强大的类型推断能力通常使 Scala 代码看起来像是动态类型的。但它是类型安全的，因此您可以在开发周期的早期捕获许多类错误。

其他 Scala.js 资源

Scala.js 网站为对使用 Scala.js 感兴趣的 JavaScript 开发人员提供了极好的教程集。以下是他们的一些初始教程：

Scala 独有的概念

Scala 中还有其他一些概念目前在 JavaScript 中没有等效的概念：

几乎所有与上下文抽象相关的东西
方法特性：
- 多个参数列表
- 调用方法时使用命名参数
使用 trait 作为接口
样例类
伴生类和对象
创建自己的控制结构和 DSL 的能力
match 表达式和模式匹配的高级功能
for comprehension
中缀方法
宏和元编程
更多的 …

← previous next →

Contributors to this page:

Problem with this page?
Please help us fix it!