1
2
3
4
5
6
7

let i = 1
// let d: Double = i        // 🛑 没有隐式数值转换
let d = Double(i)             // 显式构造
let n = Int(3.9)               // 3（向零截断）
let m = Int(exactly: 3.9)       // nil
let any: Any = i
if let s = any as? String { }    // 类型转换（不是数值转换）

1
2
3
4
5
6

var i int32 = 1
// var j int64 = i          // 🛑 没有隐式转换
j := int64(i)
var f float64 = 1             // ✅ 无类型常量自动适配
var n int = 3
f2 := float64(n) / 2           // 3/2 会是 1，必须显式转

1
2
3
4
5

1 + 1.5          # 2.5：int 自动提升为 float
True + 1          # 2：bool 是 int 子类
3 / 2              # 1.5：/ 永远给 float
3 // 2              # 1：地板除保持 int
"1" + 1              # 🛑 TypeError：字符串不会自动转数字

1
2
3
4
5
6
7

val i = 1
// val l: Long = i           // 🛑 没有隐式拓宽
val l: Long = i.toLong()
val x: Long = 1                // ✅ 字面量常量可以
val sum = 1 + 2L                // Long（运算符重载自动提升）
val y: Int? = null
val z: Int = y ?: 0              // 可空性靠 ?: / !! 处理

1
2
3
4
5
6
7
8

byte b = 1;
int i = b;            // 拓宽：自动
long l = i;            // 自动
double d = l;           // 自动
// byte b2 = i;         // 🛑 窄化需要强制转换
byte b2 = (byte) i;
String s = "x" + 1;      // 字符串拼接（1 自动转字符串）
Integer boxed = 1;        // 自动装箱

1
2
3
4
5
6

int i = 1;
long l = i;              // 标准转换：自动
double d = i;             // 自动
struct Meters { explicit Meters(double); };
// Meters m = 1.5;         // 🛑 explicit 阻止隐式构造
Meters m{1.5};

1
2
3
4
5
6

char c = 1;
int i = c;                 /* 整型提升 */
unsigned u = 1;
if (-1 < u) { }              /* 🛑 false：i 被转成 unsigned */
double d = 1 / 2;             /* 0.0！先做整数除法 */
double e = 1 / 2.0;            /* 0.5 */

1
2
3
4
5
6

1 + 1.5            # 2.5：promote(Int, Float64) → Float64
typeof(1 + 1.5)     # Float64
x::Int = 1.0         # 🛑 InexactError：赋值不做隐式转换
convert(Float64, 1)   # 1.0（显式 convert）
Int(3.9)               # 🛑 InexactError
trunc(Int, 3.9)         # 3（显式取整）

1
2
3
4
5
6
7
8

byte b = 1;
int i = b;                 // 拓宽：自动
long l = i;
double d = l;
// byte b2 = (byte)300;     // 44：显式窄化
checked { byte b3 = checked((byte)300); }   // 🛑 OverflowException
object o = i;               // 装箱
string s = "x" + i;          // 字符串拼接

1
2
3
4
5
6

num a = 1;          // int 是 num 的子类型
num b = 1.5;
print(1 + 1.5);      // 2.5：int 与 double 混算自动提升
Object o = 42;
if (o is int) print(o + 1);    // 类型提升（智能转换）
var s = o as String;             // 🛑 类型不符抛 TypeError

1
2
3
4
5

c(1, 2.5)        # double 向量（int 被提升）
c(1, "a")        # character 向量（全部变字符串）
TRUE + 1          # 2（logical 提升为 integer）
1 < "2"            # 用字符比较（强制层级：character 最高）
as.numeric("3.5")   # 3.5；as.numeric("a") → NA + 警告

1
2
3
4
5
6

const a: u8 = 250;
var b: i32 = a;          // ✅ u8 → i32 可隐式（i32 能装下 u8）
// var c: u8 = 300;      // 🛑 编译期越界
const d: i32 = @intCast(300);
const e: u8 = @truncate(d);        // 44（显式截断）
const f: u8 = std.math.cast(u8, 300) orelse 0;   // 可失败转换

1
2
3
4
5

print("10" + 1)      -- 11    字符串自动转数字
print("10" .. 1)      -- 101   数字自动转字符串（拼接）
print(1 + 1.0)         -- 2.0   整数提升为浮点
print(math.type(1 + 1.0))  -- float
print(tonumber("ff", 16))    -- 255

1
2
3
4
5
6

const x: number = 1;
const y: string = "1";
// const z: number = y;      // 🛑 编译错误
const z = Number(y);           // 运行时转换
const w = y as unknown as number;   // 断言：只骗编译器，不做转换
const lit = "a" as const;       // 字面量类型

1
2
3
4
5
6
7
8

"1" + 1;         // "11"    + 触发字符串拼接
"1" - 1;          // 0       其它算术运算符触发数字转换
1 == "1";          // true
Number("42");       // 42
Number("");          // 0     ⚠️
Number(null);         // 0     ⚠️
Number(undefined);     // NaN
!!0;                    // false

1
2
3
4
5
6
7
8

function f(int $x): int { return $x; }
declare(strict_types=1);         // 之后调用处不再自动转

"10" + 1;                         // 11（松散）
(int) "12abc";                     // 12
intval("ff", 16);                   // 255
1 == "1";                            // true（松散）
1 === "1";                            // false

1
2
3
4
5
6

1 + 1.5        # 2.5：Integer 提升为 Float
1 + Rational(1, 2)   # (3/2)：提升为 Rational
1.to_s          # "1"
Integer("42")    # 42（严格，失败抛异常）
"12abc".to_i      # 12（宽松）
[1, 2] + [3]       # 数组拼接（+ 被重载）

1
2
3
4
5

Int(3.9)                // 3（向零截断）
Int(Double.nan)          // 🛑 崩溃
Int(exactly: 3.9)         // nil（可失败）
Int(clamping: 999)         // 255（UInt8 时饱和）
Int(truncatingIfNeeded: 300)   // 4400...（按位截断）

1
2
3
4
5
6
7

var f float64 = 3.9
int(f)                  // 3（向零截断）
int64(-1)               // -1
string(rune(65))         // "A"
string([]byte{65})        // "A"
strconv.Atoi("42")         // 42, nil
strconv.ParseInt("ff", 16, 64)   // 255

1
2
3
4
5
6
7

int(3.9)        # 3（向零）
int(-3.9)        # -3
int("ff", 16)     # 255
float("1e3")       # 1000.0
str(42)             # "42"
int("4x")            # 🛑 ValueError
int(float("nan"))     # 🛑 ValueError

1
2
3
4
5
6
7

3.9.toInt()              // 3（截断）
Double.NaN.toInt()        // 0
1e300.toInt()              // Int.MAX_VALUE
3.9.roundToInt()            // 4
"42".toInt()                 // 42（失败抛 NumberFormatException）
"42".toIntOrNull()            // Int?
java.math.BigDecimal(3.9).intValueExact()   // 抛 ArithmeticException

1
2
3
4
5
6

(int) 3.9;                 // 3（向零）
(int) Double.NaN;           // 0
(int) 1e300;                 // Integer.MAX_VALUE（JLS 定义的饱和）
Integer.parseInt("42");       // 抛 NumberFormatException 当输入非法
Integer.parseInt("ff", 16);    // 255
Math.toIntExact(9_000_000_000L);   // 🛑 ArithmeticException

1
2
3
4
5

static_cast<int>(3.9);          // 3
static_cast<unsigned char>(300); // 44
std::bit_cast<std::uint32_t>(1.0f);   // 位重解释（C++20）
std::stoi("42");                       // 抛 std::invalid_argument
std::from_chars(s.data(), s.data()+s.size(), n);   // 无异常、不分配

1
2
3
4
5

(int) 3.9;                 /* 3 */
(unsigned char) 300;        /* 44 */
long v = strtol("42", &end, 10);   /* 带回错误检测 */
double d = strtod("3.14", NULL);
/* atoi("4x") 静默返回 4，没有错误检测——别用 */

1
2
3
4
5
6

Int(3.9)            # 🛑 InexactError
trunc(Int, 3.9)      # 3
round(Int, 3.5)       # 4（银行家舍入在 .5 时取偶）
parse(Int, "42")       # 42（失败抛 ArgumentError）
parse(Int, "ff", base=16)   # 255
reinterpret(UInt32, 1.0f0)   # 位重解释

1
2
3
4
5
6

(int) 3.9;                 // 3（unchecked）
checked((int) 1e300);        // 🛑 OverflowException
Convert.ToInt32(3.9);         // 4（四舍五入）
Convert.ToInt32(1e300);        // 🛑 OverflowException
int.Parse("42");                // 抛 FormatException 当非法
int.TryParse("4x", out int n);   // false

1
2
3
4
5
6

3.9.toInt();            // 3
3.9.round();             // 4
double.nan.toInt();       // 🛑 UnsupportedError
int.parse("42");           // 42（失败抛 FormatException）
int.tryParse("4x");         // null
double.parse("1e3");         // 1000.0

1
2
3
4
5
6

as.integer(3.9)        # 3（向零截断）
as.integer(-3.9)        # -3
as.integer(2147483648)   # NA + 警告（超出 32 位）
as.numeric("3.5")         # 3.5
as.numeric("a")            # NA + 警告
trunc(3.9); round(3.5)      # 3；4（银行家舍入：round(2.5)=2）

1
2
3
4
5
6

const f: f64 = 3.9;
const i: i32 = @intFromFloat(f);   // 3（安全模式：越界/NaN→panic）
const big: u16 = 300;
const small: u8 = @truncate(big);    // 44（显式截断）
const n = try std.fmt.parseInt(i32, "42", 10);
const bits: u64 = @bitCast(f);        // 位重解释

1
2
3
4
5
6
7

print(tonumber("42"))        -- 42（整数）
print(tonumber("42.5"))       -- 42.5（浮点）
print(tonumber("ff", 16))      -- 255
print(tonumber("x"))            -- nil（失败不抛错）
print(math.tointeger(3.0))       -- 3
print(math.tointeger(3.5))        -- nil
print(3.9 // 1)                    -- 3.0（截断技巧）

1
2
3
4
5
6
7

Number("42");            // 42
Number("");               // 0   ⚠️
Number.parseInt("42px");   // 42  ⚠️ 静默截断
Number.parseInt("ff", 16);  // 255
String(42);                  // "42"
BigInt("9007199254740993");   // 9007199254740993n
value as number;               // 仅编译期，不做转换

1
2
3
4
5
6
7
8

Number("42");        // 42
parseInt("42px", 10);  // 42   ⚠️ 静默截断
parseFloat("3.14x");    // 3.14
String(null);             // "null"
Boolean("");               // false
~~3.9;                      // 3（32 位取整）
3.9 | 0;                     // 3
BigInt(42);                   // 42n

1
2
3
4
5
6
7

(int) 3.9;             // 3
(int) "12abc";          // 12
intval("ff", 16);        // 255
floatval("3.14");         // 3.14
strval(42);                // "42"
settype($x, "integer");     // 原地转换（返回 bool）
(int) NAN;                   // 结果无可移植保证

1
2
3
4
5
6
7

3.9.to_i          # 3（向零）
3.9.round          # 4
Integer("42")       # 42（严格，失败抛 ArgumentError）
"ff".to_i(16)        # 255
"12abc".to_i          # 12（宽松）
Float("1.5")           # 1.5
[65].pack("C")          # "A"

1
2
3
4
5

Int("42")            // Optional(42)
Int("4x")             // nil（不抛异常）
Double("1.5")          // Optional(1.5)
String(42)              // "42"
String(format: "%05d", 42)   // "00042"

1
2
3
4
5

n, err := strconv.Atoi("42")            // 42, nil
m, err := strconv.ParseInt("ff", 16, 64)  // 255
s := strconv.Itoa(42)
f := fmt.Sprintf("%05d %.2f", 42, 3.14159)
// string(65) 是 "A"（rune → 字符串），不是 "65"

1
2
3
4
5

int("42"); int("ff", 16)      # 42；255
float("1.5"); float("nan")     # 1.5；nan
str(42); repr("a")              # "42"；"'a'"
f"{42:05d} {3.14159:.2f}"        # '00042 3.14'
int("4x")                         # 🛑 ValueError

1
2
3
4
5

"42".toInt()             // 抛 NumberFormatException
"42".toIntOrNull()        // Int?
"ff".toInt(16)              // 255
42.toString(); 42.toString(2)   // "42"；"101010"
"%05d".format(42)                // "00042"

1
2
3
4
5

Integer.parseInt("42");           // 抛 NumberFormatException 当非法
Integer.parseInt("ff", 16);         // 255
Integer.toString(42, 2);             // "101010"
String.format("%05d", 42);            // "00042"
Double.parseDouble("1.5");

1
2
3
4
5

std::stoi("42");                 // 抛 std::invalid_argument
std::stod("1.5");
int n; std::from_chars(s.data(), s.data()+s.size(), n);   // 无异常、无分配
std::string t = std::to_string(42);
std::string u = std::format("{:05d}", 42);   // C++20

1
2
3
4
5

long n = strtol("42", &end, 10);     /* 带错误检测 */
double d = strtod("1.5", NULL);
char buf[16];
snprintf(buf, sizeof buf, "%05d", 42);   /* "00042" */
/* atoi 没有错误检测，别用 */

1
2
3
4
5

parse(Int, "42")                 # 失败抛 ArgumentError
tryparse(Int, "4x")                # nothing（不抛）
parse(Int, "ff", base=16)           # 255
string(42); "$(42)"                  # "42"
using Printf; @sprintf("%05d", 42)    # "00042"

1
2
3
4
5
6

int.Parse("42");                  // 抛 FormatException 当非法
int.TryParse("4x", out int n);      // false（不抛）
Convert.ToInt32("42");
42.ToString("D5");                   // "00042"
$"{42:X}";                            // "2A"（十六进制）
// ⚠️ 默认按当前区域解析；跨系统用 CultureInfo.InvariantCulture

1
2
3
4
5
6

int.parse("42");            // 抛 FormatException
int.tryParse("4x");          // null
int.parse("ff", radix: 16);   // 255
double.parse("1.5");
42.toString();                 // "42"
42.toRadixString(16);           // "2a"

1
2
3
4
5

as.numeric("3.5")        # 3.5
as.numeric("a")           # NA + 警告（不抛错）
as.character(42)           # "42"
sprintf("%05d", 42)          # "00042"
format(3.14159, digits = 3)   # "3.14"

1
2
3
4

const n = try std.fmt.parseInt(i32, "42", 10);
const f = try std.fmt.parseFloat(f64, "1.5");
var buf: [32]u8 = undefined;
const s = try std.fmt.bufPrint(&buf, "{d:0>5}", .{42});   // "00042"

1
2
3
4
5
6

print(tonumber("42"))        -- 42
print(tonumber("ff", 16))     -- 255
print(tonumber("x"))           -- nil（不抛错）
print(tostring(42))             -- "42"
print(string.format("%05d", 42)) -- "00042"
print("10" + 1)                  -- 11（自动转换）

1
2
3
4
5
6
7

Number("42");                  // 42
Number.parseInt("ff", 16);      // 255
Number.parseFloat("3.14");
String(42);                      // "42"
(42).toString(2);                 // "101010"
(3.14159).toFixed(2);              // "3.14"
`${42}`;                            // "42"

1
2
3
4
5
6

Number("42");               // 42
Number("");                  // 0     ⚠️
Number.parseInt("42px", 10);  // 42   ⚠️ 静默截断
String(42);                    // "42"
(42).toString(2);               // "101010"
(3.14159).toFixed(2);            // "3.14"

1
2
3
4
5
6
7

intval("42");              // 42
intval("ff", 16);           // 255
floatval("3.14");
strval(42);                  // "42"
sprintf("%05d", 42);          // "00042"
number_format(1234.5678, 2);   // "1,234.57"
"10" + 1;                      // 11

1
2
3
4
5
6

Integer("42")          # 42（严格，失败抛 ArgumentError）
"ff".to_i(16)           # 255
Float("1.5")             # 1.5
42.to_s; 255.to_s(16)     # "42"；"ff"
"%05d" % 42                # "00042"
"%.2f" % 3.14159            # "3.14"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func side(_ tag: String, _ v: Bool) -> Bool { print("eval \(tag)"); return v }
func arg(_ tag: String, _ v: Int) -> Int { print("arg \(tag)"); return v }
func f(_ a: Int, _ b: Int, _ c: Int) -> Int { a + b + c }

print(2 + 3 * 4)              // 14
print(1 << 2 + 3)             // 7：<< 高于 +
print((1 | 2) == 2)           // false
print(true || false && false) // true
print(10 - 3 - 2)             // 5
let a: Int? = nil
let b: Int? = 7
print(a ?? b ?? 0)            // 7：?? 右结合
print(side("a", false) && side("b", true))  // eval a -> false
print(f(arg("1", 1), arg("2", 2), arg("3", 3)))  // arg 1/2/3 -> 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func side(tag string, v bool) bool { fmt.Println("eval", tag); return v }
func arg(tag string, v int) int    { fmt.Println("arg", tag); return v }
func f(a, b, c int) int            { return a + b + c }

fmt.Println(2 + 3*4)                 // 14
fmt.Println(1<<2 + 3)                // 7：<< 与 * 同级，高于 +
fmt.Println((1 | 2) == 2)            // false：比较低于 |
fmt.Println(true || false && false)  // true：&& 高于 ||
fmt.Println(10 - 3 - 2)              // 5：左结合
fmt.Println(side("a", false) && side("b", true)) // eval a -> false
fmt.Println(f(arg("1", 1), arg("2", 2), arg("3", 3))) // arg 1/2/3 -> 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

def side(tag, v):
    print("eval", tag)
    return v

def arg(tag, v):
    print("arg", tag)
    return v

def f(a, b, c):
    return a + b + c

print(2 + 3 * 4)          # 14
print(2 ** 3 ** 2)        # 512：** 右结合
print(-2 ** 2)            # -4：** 高于一元负号
print(1 << 2 + 3)         # 32：+ 高于 <<
print(True or False and False)  # True：and 高于 or
print([] or "default")    # default：or 返回操作数
print(1 < 2 < 3)          # True：链式比较
print(side("a", False) and side("b", True))  # eval a -> False
print(f(arg("1", 1), arg("2", 2), arg("3", 3)))  # arg 1/2/3 -> 6

1
2
3
4
5
6
7
8

println(2 + 3 * 4)               // 14
println(1 shl 2 + 3)             // 32：shl 是 infix，优先级低于 +
println((1..5 step 2).toList())  // [1, 3, 5]：Range 先于 infix，读作 (1..5) step 2
println(true || false && false)  // true：&& 高于 ||
val a: String? = null
println(a?.length ?: 0)          // 0：?. 先结合，?: 兜底
val b: Int? = 7
println(b ?: 0)                  // 7：?: 短路，不取右边

1
2
3
4
5
6
7
8
9

static int arg(String tag, int v) { System.out.println("arg " + tag); return v; }
static int f(int a, int b, int c) { return a + b + c; }

System.out.println(2 + 3 * 4);              // 14
System.out.println(1 << 2 + 3);             // 32：+ 高于 <<
System.out.println((1 | 2) == 2);           // false：== 高于 |
System.out.println(1 < 2 == true);          // true：关系先于相等
System.out.println(true || false && false); // true：&& 高于 ||
System.out.println(f(arg("1", 1), arg("2", 2), arg("3", 3))); // arg 1/2/3 -> 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <cstdio>
#include <compare>
int arg(const char *t, int v) { std::printf("arg %s\n", t); return v; }
int f(int a, int b, int c) { return a + b + c; }

std::printf("%d\n", 2 + 3 * 4);      // 14
std::printf("%d\n", 1 << 2 + 3);     // 32：+ 高于 <<
std::printf("%d\n", (1 | 2) == 2);   // 0：== 高于 |
std::printf("%d\n", 1 || 0 && 0);    // 1：&& 高于 ||
std::printf("%d\n", (1 <=> 2) < 0);  // 1：C++20 三路比较
std::printf("%d\n", -1 < 1u);        // 0：有符号被转成无符号
std::printf("%d\n", f(arg("1", 1), arg("2", 2), arg("3", 3))); // 顺序未指定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#include <stdio.h>
static int arg(const char *t, int v) { printf("arg %s\n", t); return v; }
static int f(int a, int b, int c) { return a + b + c; }

printf("%d\n", 2 + 3 * 4);    /* 14 */
printf("%d\n", 1 << 2 + 3);   /* 32：+ 高于 << */
printf("%d\n", (1 | 2) == 2); /* 0：== 高于 | */
printf("%d\n", 1 || 0 && 0);  /* 1：&& 高于 || */
printf("%d\n", 1 ? 2 : 3);    /* 2：?: 右结合 */
printf("%d\n", (1, 2));       /* 2：逗号运算符最低 */
printf("%d\n", f(arg("1", 1), arg("2", 2), arg("3", 3))); /* 顺序未指定 */

1
2
3
4
5
6
7
8

2 + 3 * 4          # 14
2 ^ 3 ^ 2          # 512：^ 右结合
-2 ^ 2             # -4：^ 高于一元负号
1 << 2 + 3         # 7：移位高于加法
true || false && false   # true
1 < 2 < 3          # true：链式比较，中间项只求值一次
Base.operator_precedence(:+), Base.operator_precedence(:*), Base.operator_precedence(:.)
# (11, 12, 17)：手册给出的数值优先级查询

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

static int Arg(string t, int v) { Console.WriteLine("arg " + t); return v; }
static int F(int a, int b, int c) { return a + b + c; }

Console.WriteLine(2 + 3 * 4);      // 14
Console.WriteLine(1 << 2 + 3);     // 32：+ 高于 <<
Console.WriteLine((1 | 2) == 2);   // False：== 高于 |
Console.WriteLine(true || false && false);   // True：&& 高于 ||
int? n = null;
Console.WriteLine(n ?? 0);         // 0：?? 只在左侧为 null 时取右边
Console.WriteLine(F(Arg("1", 1), Arg("2", 2), Arg("3", 3)));  // arg 1/2/3 -> 6

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int arg(String t, int v) { print('arg $t'); return v; }
int f(int a, int b, int c) => a + b + c;

print(2 + 3 * 4);              // 14
print(1 << 2 + 3);             // 32：+ 高于 <<
print((1 | 2) == 2);           // false：== 高于 |
print(true || false && false); // true：&& 高于 ||
String? name;
print(name ?? 'Guest');        // Guest：?? 只把 null 当作缺失
print(f(arg('1', 1), arg('2', 2), arg('3', 3)));  // arg 1/2/3 -> 6