ts示例:
let isDone:boolean = false
kotlin示例:
val isDone: Boolean = false
ts示例:
let decLiteral: number = 2024
kotlin示例:
val int: Int = 123
val long: Long = 123L
val double: Double = 123.0
val float: Float = 123.0f
TypeScript: 有 string 类型,使用双引号 (“”) 或单引号 (‘’) 来包围字符串。TS中可以使用反引号来创建多行字符串;
Kotlin: 也有 String 类型,可以使用双引号 (“”) 包围字符串。此外,Kotlin 支持三引号 (“”") 创建多行字符串。
ts示例:
let name:string = "wangzhengyi"
kotlin示例:
val str: String = "Hello"
ts示例:
// 定义数组
let arr: number[] = [1, 2, 3];
// 增加元素
arr.push(4); // arr is now [1, 2, 3, 4]
// 删除元素
arr.pop(); // removes the last element, arr is now [1, 2, 3]
// 修改元素
arr[0] = 0; // arr is now [0, 2, 3]
// 检索元素
let firstElement = arr[0]; // firstElement is 0
// 遍历数组
arr.forEach((value, index) => {
console.log(`Element at index ${index} is ${value}`);
});
kotlin示例:
// 定义数组
val arr = mutableListOf(1, 2, 3)
// 增加元素
arr.add(4) // arr is now [1, 2, 3, 4]
// 删除元素
arr.removeAt(arr.size - 1) // removes the last element, arr is now [1, 2, 3]
// 修改元素
arr[0] = 0 // arr is now [0, 2, 3]
// 检索元素
val firstElement = arr[0] // firstElement is 0
// 遍历数组
for ((index, value) in arr.withIndex()) {
println("Element at index $index is $value")
}
ts示例:
// 定义 Pair
let pair: [number, string] = [1, "one"];
// 访问元素
let firstElement = pair[0]; // firstElement is 1
let secondElement = pair[1]; // secondElement is "one"
// 修改元素
pair[0] = 2; // pair is now [2, "one"]
pair[1] = "two"; // pair is now [2, "two"]
// 遍历 Pair
for (let value of pair) {
console.log(`Value is ${value}`);
}
// TypeScript 中的元组是固定长度的,所以不能直接添加或删除元素。如果需要改变元组的长度,需要创建一个新的元组。
kotlin示例:
// 定义 Pair
var pair = Pair(1, "one")
// 访问元素
val firstElement = pair.first // firstElement is 1
val secondElement = pair.second // secondElement is "one"
// 修改元素 - Kotlin 中的 Pair 是只读的,所以不能直接修改。如果需要改变 Pair 的值,需要创建一个新的 Pair。
pair = Pair(2, "two") // pair is now (2, "two")
// 遍历 Pair
for (value in pair.toList()) {
println("Value is $value")
}
enum类型是对JavaScript标准数据类型的一个补充,使用枚举类型可以为一组数值赋予友好的名字。
ts示例:
// 定义枚举
enum Color {
Red,
Green,
Blue
}
// 检索值
let color: Color = Color.Red; // color is Color.Red
// 修改值
color = Color.Blue; // color is Color.Blue
// TypeScript 中的枚举是不可变的,无法添加或删除成员
// 遍历枚举
for (let name in Color) {
if (typeof Color[name] === 'number') {
console.log(Color[name]); // 输出枚举值
}
}
kotlin:
// 定义枚举
enum class Color {
RED,
GREEN,
BLUE
}
// 检索值
var color: Color = Color.RED // color is Color.RED
// 修改值
color = Color.BLUE // color is Color.BLUE
// Kotlin 中的枚举是不可变的,无法添加或删除成员
// 遍历枚举
for (enumValue in Color.values()) {
println(enumValue.name) // 输出枚举名称
}
需要注意的是,TypeScript 和 Kotlin 中的枚举都是不可变的,一旦定义就不能添加或删除成员。这是因为枚举的设计就是为了定义一组固定的值,不应该在运行时改变这些值。
ts示例:
let a: number = null; // Ok
let b: string = undefined; // Ok
但是,如果在 TypeScript 中启用了 strictNullChecks 选项,那么 null 和 undefined 就只能赋值给它们自己的类型和 void 类型。
let a: number = null; // Error
let b: string = undefined; // Error
let c: void = undefined; // Ok
kotlin示例:
var a: String = null // Error
var b: String? = null // Ok
ts示例:
function warnUser(): void {
console.log("This is a warning message");
}
let unusable: void = undefined;
kotlin示例:
fun warnUser(): Unit {
println("This is a warning message")
}
ts示例:
let value: unknown;
value = "Hello"; // OK
value = 123; // OK
value = true; // OK
let valueString: string = value; // Error
value.length; // Error
if (typeof value === "string") {
valueString = value; // OK inside this block
console.log(value.length); // OK inside this block
}
kotlin示例:
var value: Any
value = "Hello" // OK
value = 123 // OK
value = true // OK
val valueString: String = value // Error, type mismatch
if (value is String) {
println(value.length) // OK inside this block
}
ts示例:
let value: string | number | boolean;
value = "Hello"; // OK
value = 123; // OK
value = true; // OK
if (typeof value === "string") {
console.log(value.substr(2)); // OK
}
kotlin示例:
// 使用sealed class
sealed class UnionType {
data class TypeString(val value: String) : UnionType()
data class TypeInt(val value: Int) : UnionType()
data class TypeBoolean(val value: Boolean) : UnionType()
}
var value: UnionType = UnionType.TypeString("Hello")
when (value) {
is UnionType.TypeString -> println(value.value.length)
is UnionType.TypeInt -> println(value.value + 1)
is UnionType.TypeBoolean -> println(!value.value)
}
// 使用Any
var value: Any = "Hello"
when (value) {
is String -> println(value.length)
is Int -> println(value + 1)
is Boolean -> println(!value)
}
TypeScript 和 Kotlin 都支持传统的条件语句,例如 if-else 和 switch-case,但是在某些方面,它们有一些相似和不同的地方。
在 TypeScript 和 Kotlin 中,if-else 语句的用法非常相似,都用于进行条件判断。
TypeScript 的 if-else 示例
let number = 5;
if (number > 0) {
console.log("Number is positive.");
} else {
console.log("Number is not positive.");
}
Kotlin 的 if-else 示例
val number = 5
if (number > 0) {
println("Number is positive.")
} else {
println("Number is not positive.")
}
但是,Kotlin 的 if-else 还可以作为表达式使用,返回一个值。这在 TypeScript 中是不可能的。
val number = 5
val result = if (number > 0) {
"Number is positive."
} else {
"Number is not positive."
}
println(result)
TypeScript 支持 switch-case 语句,而 Kotlin 使用 when 作为相应的替代。
TypeScript 的 switch-case 示例:
let fruit = "apple";
switch (fruit) {
case "banana":
console.log("I am a banana.");
break;
case "apple":
console.log("I am an apple.");
break;
default:
console.log("I am not a banana or an apple.");
break;
}
Kotlin 的 when 示例
val fruit = "apple"
when (fruit) {
"banana" -> println("I am a banana.")
"apple" -> println("I am an apple.")
else -> println("I am not a banana or an apple.")
}
Kotlin 的 when 表达式比 TypeScript 的 switch-case 更强大,它可以处理更复杂的条件,例如检查一个值是否在某个范围内,或者是否满足某个条件。
Kotlin 的 when 进阶示例:
val x = 10
when {
x in 1..10 -> println("x is in the range.")
x is Int -> println("x is an Int.")
else -> println("None of the above.")
}
在 TypeScript 和 Kotlin 中,函数的定义都包括函数名、参数列表和函数体。
TypeScript 函数定义示例
function add(x: number, y: number): number {
return x + y;
}
kotlin函数定义
fun add(x: Int, y: Int): Int {
return x + y
}
在 TypeScript 中,函数的参数可以被标记为可选的,这意味着如果在调用函数时没有提供这个参数,那么这个参数的值为 undefined。
TypeScript 可选参数示例
function greet(name?: string): void {
if (name) {
console.log(`Hello, ${name}!`);
} else {
console.log("Hello, world!");
}
}
然而,在 Kotlin 中,没有直接的 “可选参数” 的概念,但是可以通过设置参数的默认值来达到类似的效果。
Kotlin 默认参数示例
fun greet(name: String = "world") {
println("Hello, $name!")
}
TypeScript 和 Kotlin 都支持变长参数,也就是你可以将任意数量的参数作为一个数组传递给函数。
TypeScript 变长参数示例:
function addNumbers(...numbers: number[]): number {
let result = 0;
for (let number of numbers) {
result += number;
}
return result;
}
Kotlin 变长参数示例:
fun addNumbers(vararg numbers: Int): Int {
var result = 0
for (number in numbers) {
result += number
}
return result
}
在 TypeScript 和 Kotlin 中,都可以使用箭头函数(又称为 Lambda 表达式),但是他们的语法和行为有些许不同。
在 TypeScript 中,箭头函数使用 => 符号,它有以下特性:
TS的箭头函数示例:
let add = (x: number, y: number): number => {
return x + y;
};
console.log(add(1, 2)); // 输出 "3"
在 Kotlin 中,Lambda 表达式用 {} 包围,箭头函数使用 -> 符号,例如:
val add = { x: Int, y: Int ->
x + y
}
println(add(1, 2)) // 输出 "3"
Kotlin Lambda 表达式的一些特性:
在 TypeScript 和 Kotlin 中,你都可以将函数作为参数传递给另一个函数。以下是一些例子:
在 TypeScript 中,可以定义一个函数类型,然后将一个匹配此类型的函数作为参数传递给另一个函数。下面是一个例子,其中一个函数接受另一个函数作为参数:
function applyFunction(value: number, func: (x: number) => number): number {
return func(value);
}
const double = (x: number) => x * 2;
console.log(applyFunction(5, double)); // 输出 10
在此例子中,applyFunction 接受一个数字和一个函数作为参数。这个函数接受一个数字并返回一个数字。然后,applyFunction 将其第一个参数传递给这个函数,并返回结果。
在 Kotlin 中,可以使用函数类型来定义一个可以接受其他函数作为参数的函数。以下是一个例子:
fun applyFunction(value: Int, func: (Int) -> Int): Int {
return func(value)
}
val double = { x: Int -> x * 2 }
println(applyFunction(5, double)) // 输出 10
在这个例子中,applyFunction 接受一个整数和一个函数作为参数。这个函数接受一个整数并返回一个整数。然后,applyFunction 将其第一个参数传递给这个函数,并返回结果。
这两个例子展示了 TypeScript 和 Kotlin 中函数作为一等公民的概念,即函数可以被赋值给变量,可以作为参数传递给其他函数,也可以作为其他函数的返回值。
在 TypeScript 中,类定义包括类名、构造函数和成员变量或方法。构造函数在 TypeScript 中被命名为 constructor。示例如下:
class Person {
constructor(public name: string, private age: number) {}
greet() {
console.log(`Hello, my name is ${this.name}`);
}
}
class Employee extends Person {
constructor(name: string, age: number, public department: string) {
super(name, age);
}
greet() {
super.greet();
console.log(`I work in ${this.department}`);
}
}
let employee = new Employee("Alice", 25, "Engineering");
employee.greet();
// 输出 "Hello, my name is Alice"
// 输出 "I work in Engineering"
在上述示例中,Person 类有两个成员变量 name 和 age(age 是私有的),一个公共方法 greet 和一个私有方法 getAge。greet 可以被类的实例访问,而 getAge 只能在类的内部访问。
在 Kotlin 中,主构造函数是类头部的一部分,可以直接在类名后面定义。示例如下:
open class Person(val name: String, private val age: Int) {
open fun greet() {
println("Hello, my name is $name")
}
}
class Employee(name: String, age: Int, val department: String) : Person(name, age) {
override fun greet() {
super.greet()
println("I work in $department.")
}
}
val employee = Employee("Alice", 25, "Engineering")
employee.greet()
// 输出 "Hello, my name is Alice"
// 输出 "I work in Engineering."
TypeScript 和 Kotlin 中的模块概念主要用于代码的组织和封装,有助于提高代码的可维护性和可重用性。
在 TypeScript 中,一个模块就是一个文件。每个 TypeScript 文件都是一个独立的作用域,文件中的变量、函数、类等默认都是私有的。如果你想在其他 TypeScript 文件中使用它们,那么你必须使用 export 关键字来导出它们,然后在其他文件中使用 import 关键字来导入它们。
例如,你可能有一个名为add.ts 的模块,它导出一个 add 函数:
// add.ts
export function add(x: number, y: number): number {
return x + y;
}
然后在另一个名为 main.ts 的模块中,你可以导入并使用 add 函数:
// main.ts
import { add } from './math';
console.log(add(1, 2)); // 输出 3
在 Kotlin 中,模块(Module)是一种组织代码的方式,它可以包含多个文件、包和类。一个模块可以有自己的构建和测试过程。
Kotlin 中的模块概念更接近于项目或子项目的概念,比如在 IntelliJ IDEA 或 Android Studio 中创建的项目或者子项目就是模块。
此外,Kotlin 还有包(Package)的概念,用于组织相关的类、接口和函数。包名通常与文件的物理布局相匹配,但这并不是必须的。
例如,你可能有一个包含 add 函数的包 com.example.math:
// 在 com/example/math.kt 文件中
package com.example
fun add(x: Int, y: Int): Int {
return x + y
}
然后在其他地方,你可以通过 import 关键字来导入并使用 add 函数:
// 在其他文件中
import com.example.add
fun main() {
println(add(1, 2)) // 输出 3
}
TypeScript 和 Kotlin 都提供了丰富的容器类,比如数组和集合,用于存储和操作数据。以下是一些示例。
在 TypeScript 中,数组是最常见的容器类,可以用于存储多个元素。数组元素可以通过索引访问和修改,可以添加和删除元素,并且可以使用 for…of 循环进行遍历。
let arr = [1, 2, 3];
// 增加元素
arr.push(4); // arr 现在是 [1, 2, 3, 4]
// 删除元素
arr.pop(); // arr 现在是 [1, 2, 3]
// 修改元素
arr[0] = 10; // arr 现在是 [10, 2, 3]
// 查询元素
console.log(arr[0]); // 输出 10
// 遍历元素
for (let x of arr) {
console.log(x);
}
在 TypeScript 中,Map 是一种内置的集合类型,可以保存键值对,并且键可以是任意类型。
创建 Map、添加、删除、修改和查询元素的示例:
// 创建一个新的 Map
let map = new Map<string, number>();
// 增加元素
map.set('One', 1);
// 查询元素
console.log(map.get('One')); // 输出 1
// 修改元素
map.set('One', 100);
console.log(map.get('One')); // 输出 100
// 删除元素
map.delete('One');
console.log(map.get('One')); // 输出 undefined
// 遍历 Map
map.set('Two', 2);
map.set('Three', 3);
for (let [key, value] of map) {
console.log(`${key}: ${value}`);
}
在 TypeScript 中,Set 是一种内置的集合类型,可以保存无重复的元素。
创建 Set、添加、删除和查询元素的示例:
// 创建一个新的 Set
let set = new Set<number>();
// 增加元素
set.add(1);
// 查询元素
console.log(set.has(1)); // 输出 true
// 删除元素
set.delete(1);
console.log(set.has(1)); // 输出 false
// 遍历 Set
set.add(2);
set.add(3);
for (let value of set) {
console.log(value);
}
在 Kotlin 中,有两种类型的容器:不可变的(例如 List)和可变的(例如 MutableList)。不可变容器只能进行查询和遍历,不能进行添加、删除和修改。可变容器则支持所有操作。
val list = mutableListOf(1, 2, 3)
// 增加元素
list.add(4) // list 现在是 [1, 2, 3, 4]
// 删除元素
list.removeAt(list.lastIndex) // list 现在是 [1, 2, 3]
// 修改元素
list[0] = 10 // list 现在是 [10, 2, 3]
// 查询元素
println(list[0]) // 输出 10
// 遍历元素
for (x in list) {
println(x)
}
在 Kotlin 中,有两个 Map 接口:Map 和 MutableMap。Map 是不可变的,只提供了查询操作,不能添加、删除和修改元素。MutableMap 是可变的,可以添加、删除和修改元素。
创建 MutableMap、添加、删除、修改和查询元素的示例:
// 创建一个新的 MutableMap
val map = mutableMapOf<String, Int>()
// 增加元素
map["One"] = 1
// 查询元素
println(map["One"]) // 输出 1
// 修改元素
map["One"] = 100
println(map["One"]) // 输出 100
// 删除元素
map.remove("One")
println(map["One"]) // 输出 null
// 遍历 Map
map["Two"] = 2
map["Three"] = 3
for ((key, value) in map) {
println("$key: $value")
}
在 Kotlin 中,有两个 Set 接口:Set 和 MutableSet。Set 是不可变的,只提供了查询操作,不能添加和删除元素。MutableSet 是可变的,可以添加和删除元素。
创建 MutableSet、添加、删除和查询元素的示例:
// 创建一个新的 MutableSet
val set = mutableSetOf<Int>()
// 增加元素
set.add(1)
// 查询元素
println(set.contains(1)) // 输出 true
// 删除元素
set.remove(1)
println(set.contains(1)) // 输出 false
// 遍历 Set
set.add(2)
set.add(3)
for (value in set) {
println(value)
}