移动端六大语言速记：第1部分 - 基础语法与控制结构

移动端六大语言速记：第1部分 - 基础语法与控制结构

本文将对比Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的基础语法与控制结构，帮助开发者快速理解各语言间的差异与共性。

1. 基础语法

1.1 数据类型

各语言的基本数据类型对比：

语言	整数类型	浮点类型	字符串	布尔值	特殊类型
Java	byte, short, int, long	float, double	String	boolean	char
Kotlin	Byte, Short, Int, Long	Float, Double	String	Boolean	Char, Any, Unit, Nothing
Dart	int	double	String	bool	dynamic, Symbol
Python	int (无大小限制)	float	str	bool	None, complex
ArkTS	number, byte, short, int, long	float, double	string	boolean	char, any
Swift	Int, Int8, Int16, Int32, Int64	Float, Double	String	Bool	Character, Any, AnyObject

示例对比

Java:

int number = 10;
double price = 99.99;
String name = "Java";
boolean isActive = true;
char grade = 'A';

Kotlin:

val number: Int = 10
val price: Double = 99.99
val name: String = "Kotlin"
val isActive: Boolean = true
val grade: Char = 'A'
// 类型推断
val inferredNumber = 10 // 自动推断为Int类型

Dart:

int number = 10;
double price = 99.99;
String name = "Dart";
bool isActive = true;
// var关键字进行类型推断
var inferredNumber = 10; // 自动推断为int类型

Python:

number = 10  # 自动为int类型
price = 99.99  # 自动为float类型
name = "Python"  # 自动为str类型
is_active = True  # 布尔值首字母大写

ArkTS:

let number: number = 10;
let price: number = 99.99;
let name: string = "ArkTS";
let isActive: boolean = true;
// 类型推断
let inferredNumber = 10; // 自动推断为number类型

Swift:

let number: Int = 10
let price: Double = 99.99
let name: String = "Swift"
let isActive: Bool = true
// 类型推断
let inferredNumber = 10 // 自动推断为Int类型

1.2 变量与常量

各语言变量和常量的声明方式：

语言	变量声明	常量声明	类型声明位置	类型推断
Java	type name;	final type name;	类型在前	有限支持(Java 10+的var)
Kotlin	var name: Type	val name: Type	类型在后	完全支持
Dart	var name; 或 Type name;	final name; 或 const name;	类型在前或省略	支持
Python	name = value	无显式常量(约定用大写)	无显式类型声明	默认行为
ArkTS	let name: Type	const name: Type	类型在后	支持
Swift	var name: Type	let name: Type	类型在后	完全支持

变量作用域对比

Java:

// 类级别变量
public class Example {
    private int classVar = 10; // 实例变量
    private static int staticVar = 20; // 静态变量
    
    public void method() {
        int localVar = 30; // 局部变量
        if (true) {
            int blockVar = 40; // 块级变量
            // blockVar只在if块内可用
        }
        // localVar在整个方法内可用
    }
}

Kotlin:

// 类级别变量
class Example {
    private val classVar = 10 // 实例变量
    
    companion object {
        private val staticVar = 20 // 类似Java静态变量
    }
    
    fun method() {
        val localVar = 30 // 局部变量
        if (true) {
            val blockVar = 40 // 块级变量
            // blockVar只在if块内可用
        }
        // localVar在整个方法内可用
    }
}

Dart:

// 类级别变量
class Example {
    int classVar = 10; // 实例变量
    static int staticVar = 20; // 静态变量
    
    void method() {
        int localVar = 30; // 局部变量
        if (true) {
            int blockVar = 40; // 块级变量
            // blockVar只在if块内可用
        }
        // localVar在整个方法内可用
    }
}

Python:

# 类级别变量
class Example:
    class_var = 10  # 类变量
    
    def __init__(self):
        self.instance_var = 20  # 实例变量
    
    def method(self):
        local_var = 30  # 局部变量
        if True:
            block_var = 40  # Python没有真正的块级作用域
        # block_var在整个方法内可用，这与其他语言不同

ArkTS:

// 类级别变量
class Example {
    private classVar: number = 10; // 实例变量
    private static staticVar: number = 20; // 静态变量
    
    method() {
        let localVar: number = 30; // 局部变量
        if (true) {
            let blockVar: number = 40; // 块级变量
            // blockVar只在if块内可用
        }
        // localVar在整个方法内可用
    }
}

Swift:

// 类级别变量
class Example {
    private var classVar = 10 // 实例变量
    private static var staticVar = 20 // 静态变量
    
    func method() {
        let localVar = 30 // 局部变量
        if true {
            let blockVar = 40 // 块级变量
            // blockVar只在if块内可用
        }
        // localVar在整个方法内可用
    }
}

1.3 运算符

各语言常见运算符对比：

运算符类型	Java	Kotlin	Dart	Python	ArkTS	Swift
算术运算符	+, -, *, /, %, ++, –	+, -, *, /, %, ++, –	+, -, *, /, ~/, %, ++, –	+, -, *, /, //, %, **	+, -, *, /, %, ++, –	+, -, *, /, %, 无自增自减
比较运算符	==, !=, >, <, >=, <=	==, !=, >, <, >=, <=	==, !=, >, <, >=, <=	==, !=, >, <, >=, <=	==, !=, >, <, >=, <=	==, !=, >, <, >=, <=
逻辑运算符	&&, ||, !	&&, ||, !	&&, ||, !	and, or, not	&&, ||, !	&&, ||, !
位运算符	&, |, ^, ~, <<, >>	&, |, ^, ~, <<, >>	&, |, ^, ~, <<, >>	&, |, ^, ~, <<, >>	&, |, ^, ~, <<, >>	&, |, ^, ~, <<, >>
赋值运算符	=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=	=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=	=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=	=, +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=	=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=	=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=

示例对比

Java:

// 算术运算符
int a = 10;
int b = 3;
int sum = a + b;  // 13
int diff = a - b;  // 7
int product = a * b;  // 30
int quotient = a / b;  // 3 (整数除法)
int remainder = a % b;  // 1
a++;  // a现在是11

// 比较运算符
boolean isEqual = (a == b);  // false
boolean isNotEqual = (a != b);  // true
boolean isGreater = (a > b);  // true

// 逻辑运算符
boolean condition1 = true;
boolean condition2 = false;
boolean andResult = condition1 && condition2;  // false
boolean orResult = condition1 || condition2;  // true
boolean notResult = !condition1;  // false

Kotlin:

// 算术运算符
val a = 10
val b = 3
val sum = a + b  // 13
val diff = a - b  // 7
val product = a * b  // 30
val quotient = a / b  // 3 (整数除法)
val remainder = a % b  // 1
var c = a
c++  // c现在是11

// 比较运算符
val isEqual = (a == b)  // false
val isNotEqual = (a != b)  // true
val isGreater = (a > b)  // true

// 逻辑运算符
val condition1 = true
val condition2 = false
val andResult = condition1 && condition2  // false
val orResult = condition1 || condition2  // true
val notResult = !condition1  // false

// 特殊运算符
val obj: Any = "Kotlin"
val isString = obj is String  // true
val str = obj as String  // 类型转换

Dart:

// 算术运算符
int a = 10;
int b = 3;
int sum = a + b;  // 13
int diff = a - b;  // 7
int product = a * b;  // 30
double quotient = a / b;  // 3.3333... (浮点除法)
int intQuotient = a ~/ b;  // 3 (整数除法)
int remainder = a % b;  // 1
a++;  // a现在是11

// 比较运算符
bool isEqual = (a == b);  // false
bool isNotEqual = (a != b);  // true
bool isGreater = (a > b);  // true

// 逻辑运算符
bool condition1 = true;
bool condition2 = false;
bool andResult = condition1 && condition2;  // false
bool orResult = condition1 || condition2;  // true
bool notResult = !condition1;  // false

Python:

# 算术运算符
a = 10
b = 3
sum_result = a + b  # 13
diff = a - b  # 7
product = a * b  # 30
quotient = a / b  # 3.3333... (浮点除法)
int_quotient = a // b  # 3 (整数除法)
remainder = a % b  # 1
power = a ** b  # 1000 (幂运算)

# 比较运算符
is_equal = (a == b)  # False
is_not_equal = (a != b)  # True
is_greater = (a > b)  # True

# 逻辑运算符
condition1 = True
condition2 = False
and_result = condition1 and condition2  # False
or_result = condition1 or condition2  # True
not_result = not condition1  # False

ArkTS:

// 算术运算符
let a: number = 10;
let b: number = 3;
let sum: number = a + b;  // 13
let diff: number = a - b;  // 7
let product: number = a * b;  // 30
let quotient: number = a / b;  // 3.3333... (浮点除法)
let remainder: number = a % b;  // 1
a++;  // a现在是11

// 比较运算符
let isEqual: boolean = (a == b);  // false
let isNotEqual: boolean = (a != b);  // true
let isGreater: boolean = (a > b);  // true

// 逻辑运算符
let condition1: boolean = true;
let condition2: boolean = false;
let andResult: boolean = condition1 && condition2;  // false
let orResult: boolean = condition1 || condition2;  // true
let notResult: boolean = !condition1;  // false

// 特殊运算符
let obj: any = "ArkTS";
let isString: boolean = obj instanceof String;  // 类型检查
let str: string = obj as string;  // 类型转换

Swift:

// 算术运算符
let a = 10
let b = 3
let sum = a + b  // 13
let diff = a - b  // 7
let product = a * b  // 30
let quotient = a / b  // 3.333... (浮点除法)
let remainder = a % b  // 1
// Swift没有自增自减运算符
var c = a
c += 1  // c现在是11

// 比较运算符
let isEqual = (a == b)  // false
let isNotEqual = (a != b)  // true
let isGreater = (a > b)  // true

// 逻辑运算符
let condition1 = true
let condition2 = false
let andResult = condition1 && condition2  // false
let orResult = condition1 || condition2  // true
let notResult = !condition1  // false

// 特殊运算符
let optionalValue: String? = "Swift"
let unwrappedValue = optionalValue ?? "默认值"  // 空合运算符
let isString = optionalValue is String  // 类型检查
if let str = optionalValue as? String {  // 条件类型转换
    // 使用str
}

1.4 特殊操作符

各语言特殊操作符对比：

操作符类型	Java	Kotlin	Dart	Python	ArkTS	Swift
条件操作符	? :	? :	? :	value if condition else other_value	? :	? :
类型比较操作符	instanceof	is, !is	is, is!	isinstance(), type()	instanceof	is, as, as?
空安全操作符	无	?., ?:, !!	?., ??, ??=	无	?.	?., ??
范围操作符	无	…, until, downTo, step	…	range()	无	…, …<
展开/收集操作符	无	*, ** (用于函数参数)	… (展开), … (收集)	* (解包列表), ** (解包字典)	… (展开)	无

示例对比

Java:

// 赋值操作符
int a = 10;
a += 5;  // a = a + 5, 现在a是15

// 条件操作符
int max = (a > 7) ? a : 7;  // 如果a>7，max=a，否则max=7

// 类型比较操作符
String str = "Hello";
boolean isString = str instanceof String;  // true

Kotlin:

// 赋值操作符
var a = 10
a += 5  // a = a + 5, 现在a是15

// 条件操作符
val max = if (a > 7) a else 7  // 如果a>7，max=a，否则max=7
// 或使用三元操作符语法
val max2 = if (a > 7) a else 7

// 类型比较操作符
val str: Any = "Hello"
val isString = str is String  // true
val notString = str !is String  // false

// 空安全操作符
val nullableStr: String? = "Kotlin"
val length = nullableStr?.length  // 安全调用，如果nullableStr为null，则length为null
val nonNullLength = nullableStr?.length ?: 0  // Elvis操作符，如果左侧为null，则使用右侧值
val forcedLength = nullableStr!!.length  // 非空断言，如果nullableStr为null，则抛出异常

// 范围操作符
for (i in 1..5) {  // 包含5
    println(i)  // 打印1, 2, 3, 4, 5
}
for (i in 1 until 5) {  // 不包含5
    println(i)  // 打印1, 2, 3, 4
}
for (i in 5 downTo 1) {  // 降序
    println(i)  // 打印5, 4, 3, 2, 1
}
for (i in 1..10 step 2) {  // 步长为2
    println(i)  // 打印1, 3, 5, 7, 9
}

Dart:

// 赋值操作符
int a = 10;
a += 5;  // a = a + 5, 现在a是15

// 条件操作符
int max = (a > 7) ? a : 7;  // 如果a>7，max=a，否则max=7

// 类型比较操作符
var str = "Hello";
var isString = str is String;  // true
var notString = str is! String;  // false

// 空安全操作符
String? nullableStr = "Dart";
int? length = nullableStr?.length;  // 安全调用，如果nullableStr为null，则length为null
var nonNullStr = nullableStr ?? "Default";  // 如果nullableStr为null，则使用"Default"
nullableStr ??= "New Value";  // 如果nullableStr为null，则赋值为"New Value"

// 级联操作符
var list = [1, 2];
list
  ..add(3)
  ..add(4);  // 链式调用方法，list现在是[1, 2, 3, 4]

// 展开操作符
var list1 = [1, 2, 3];
var list2 = [0, ...list1, 4];  // list2是[0, 1, 2, 3, 4]

Python:

# 赋值操作符
a = 10
a += 5  # a = a + 5, 现在a是15

# 条件操作符（三元操作符）
max_val = a if a > 7 else 7  # 如果a>7，max_val=a，否则max_val=7

# 类型比较操作符
str_val = "Hello"
is_string = isinstance(str_val, str)  # True
type_check = type(str_val) == str  # True

# 解包操作符
list1 = [1, 2, 3]
list2 = [0, *list1, 4]  # list2是[0, 1, 2, 3, 4]

# 字典解包
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, **dict1}  # dict2是{"c": 3, "a": 1, "b": 2}

# 海象操作符（Python 3.8+）
if (n := len("hello")) > 3:  # 赋值并使用n
    print(f"Length is {n}")

ArkTS:

// 赋值操作符
let a: number = 10;
a += 5;  // a = a + 5, 现在a是15

// 条件操作符
let max: number = (a > 7) ? a : 7;  // 如果a>7，max=a，否则max=7

// 类型比较操作符
let str: any = "Hello";
let isString: boolean = str instanceof String;  // 类型检查
let castedStr: string = str as string;  // 类型转换

// 空安全操作符
let nullableObj: Object | null = { name: "ArkTS" };
let name: string | undefined = nullableObj?.name;  // 安全调用，如果nullableObj为null，则name为undefined

// 展开操作符
let obj1 = { a: 1, b: 2 };
let obj2 = { ...obj1, c: 3 };  // obj2是{ a: 1, b: 2, c: 3 }

Swift:

// 赋值操作符
var a = 10
a += 5  // a = a + 5, 现在a是15

// 条件操作符
let max = (a > 7) ? a : 7  // 如果a>7，max=a，否则max=7

// 类型比较操作符
let anyValue: Any = "Hello"
let isString = anyValue is String  // true

// 类型转换操作符
if let str = anyValue as? String {  // 条件类型转换
    print(str.count)  // 安全地使用String方法
}
let forcedStr = anyValue as! String  // 强制类型转换，如果失败会崩溃

// 空安全操作符
let nullableStr: String? = "Swift"
let length = nullableStr?.count  // 安全调用，如果nullableStr为null，则length为null
let nonNullLength = nullableStr ?? "Default"  // 空合运算符，如果左侧为null，则使用右侧值

// 范围操作符
for i in 1...5 {  // 闭区间，包含5
    print(i)  // 打印1, 2, 3, 4, 5
}
for i in 1..<5 {  // 半开区间，不包含5
    print(i)  // 打印1, 2, 3, 4
}

总结

本文对比了Java、Kotlin、Flutter(Dart)、Python、ArkTS和Swift这六种移动端开发语言的基础语法，包括数据类型、变量与常量、运算符和特殊操作符。通过对比可以看出：

1. 数据类型：各语言都支持基本的整数、浮点数、字符串和布尔类型，但在命名和特殊类型上有所差异。

2. 变量与常量：Java和Dart使用类型在前的声明方式，而Kotlin、ArkTS和Swift使用类型在后的声明方式；Python则无需显式声明类型。

3. 运算符：基本运算符在各语言中较为一致，但Python使用英文单词表示逻辑运算符，Swift没有自增自减运算符。

4. 特殊操作符：Kotlin、Dart和Swift提供了丰富的空安全操作符；Kotlin和Swift有强大的范围操作符；Python和Dart支持解包操作。

在第2部分中，我们将继续探讨这六种语言的控制结构，包括条件语句、循环语句和异常处理等内容。