前端转后端基础- 变量和类型

PHP、Go、JavaScript三种语言在变量和类型相关的核心语法对照。

一、变量声明和赋值

PHP 变量语法

<?php
// PHP变量以$符号开头
$name = "张三";
$age = 25;
$height = 175.5;
$isStudent = true;
$score = null;

// 变量命名规则
$firstName = "李";           // 驼峰命名
$last_name = "四";           // 下划线命名
$UserName = "admin";         // 大驼峰命名
$_privateVar = "secret";     // 私有变量
$MAX_VALUE = 100;            // 常量风格

// 动态类型 - 变量类型可以改变
$var = 10;                   // 整数
$var = "hello";              // 字符串
$var = 3.14;                 // 浮点数
$var = [1, 2, 3];            // 数组
$var = new stdClass();       // 对象

// 引用赋值
$a = 5;
$b = &$a;                    // $b是$a的引用
$b = 10;
echo $a;                     // 输出10，$a的值也被改变了

// 可变变量
$varName = "name";
$$varName = "王五";          // 相当于 $name = "王五"
echo $name;                  // 输出"王五"

// 变量解析
$greeting = "Hello";
$message = "$greeting World";    // 双引号中变量会被解析
$message2 = '$greeting World';   // 单引号中变量不会被解析

// 变量变量
$prefix = "user";
${$prefix . "_name"} = "赵六";   // 相当于 $user_name = "赵六"
echo $user_name;                 // 输出"赵六"

// 变量作用域
$globalVar = "全局变量";

function testScope() {
    global $globalVar;           // 使用global关键字访问全局变量
    $localVar = "局部变量";
    echo $globalVar;
}

// 静态变量
function counter() {
    static $count = 0;
    $count++;
    return $count;
}

echo counter();  // 1
echo counter();  // 2
echo counter();  // 3

// 变量销毁
$var = "test";
unset($var);                     // 销毁变量
// echo $var;                    // 会报错：未定义变量

// 变量存在性检查
$var = "exists";
if (isset($var)) {
    echo "变量存在";
}

// 变量类型检查
$var = 123;
if (is_int($var)) {
    echo "是整数";
}

// 变量输出
$var = "test";
echo $var;                       // 直接输出
print $var;                      // print函数输出
var_dump($var);                  // 输出变量类型和值
print_r($var);                   // 打印变量信息

// 变量插值
$name = "张三";
$age = 25;
echo "姓名：$name，年龄：$age";
echo "姓名：{$name}，年龄：{$age}";

// 变量赋值运算符
$a = 10;
$a += 5;     // $a = $a + 5
$a -= 3;     // $a = $a - 3
$a *= 2;     // $a = $a * 2
$a /= 4;     // $a = $a / 4
$a %= 3;     // $a = $a % 3
$a .= "test"; // $a = $a . "test" (字符串连接)

// 递增递减运算符
$i = 0;
$i++;        // 后置递增
++$i;        // 前置递增
$i--;        // 后置递减
--$i;        // 前置递减

// 三元运算符
$age = 20;
$status = ($age >= 18) ? "成人" : "未成年";

// 空合并运算符
$username = $_GET['user'] ?? 'guest';

// 变量类型声明（PHP 7+）
function add(int $a, int $b): int {
    return $a + $b;
}

// 严格类型模式
declare(strict_types=1);

// 变量变量的高级用法
$var1 = "value1";
$var2 = "var1";
echo $$var2;  // 输出"value1"

// 变量引用的高级用法
function modifyByRef(&$param) {
    $param = "modified";
}

$value = "original";
modifyByRef($value);
echo $value;  // 输出"modified"
?>

Go 变量语法

package main

import (
    "fmt"
    "reflect"
)

func main() {
    // 基本变量声明
    var name string = "张三"
    var age int = 25
    var height float64 = 175.5
    var isStudent bool = true
    var score *int = nil
    
    // 简短声明
    firstName := "李"
    lastName := "四"
    userName := "admin"
    
    // 多变量声明
    var (
        city string = "北京"
        population int = 21540000
        area float64 = 16410.54
    )
    
    // 多变量同时赋值
    a, b, c := 1, 2, 3
    x, y := "hello", 3.14
    
    // 变量类型推断
    var inferred = "自动推断类型"  // 推断为string
    inferred2 := 123               // 推断为int
    
    // 常量声明
    const (
        PI = 3.14159
        MAX_SIZE = 100
        DEFAULT_NAME = "guest"
    )
    
    // 枚举常量
    const (
        Sunday = iota
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
        Saturday
    )
    
    // 类型别名
    type Celsius float64
    type Fahrenheit float64
    
    var temperature Celsius = 25.5
    
    // 指针变量
    var ptr *int
    num := 10
    ptr = &num
    fmt.Println(*ptr)  // 解引用
    
    // 数组变量
    var arr [3]int = [3]int{1, 2, 3}
    arr2 := [5]string{"a", "b", "c", "d", "e"}
    
    // 切片变量
    slice := []int{1, 2, 3, 4, 5}
    slice2 := make([]string, 3)
    
    // 映射变量
    m := make(map[string]int)
    m["age"] = 25
    m["score"] = 90
    
    // 结构体变量
    type Person struct {
        Name string
        Age  int
    }
    
    var p Person
    p.Name = "张三"
    p.Age = 25
    
    p2 := Person{Name: "李四", Age: 30}
    
    // 接口变量
    var i interface{}
    i = "hello"
    i = 123
    i = 3.14
    
    // 通道变量
    ch := make(chan int)
    
    // 函数变量
    var add func(int, int) int
    add = func(a, b int) int {
        return a + b
    }
    
    // 变量作用域
    globalVar := "全局作用域"
    
    {
        localVar := "块级作用域"
        fmt.Println(localVar)
    }
    
    // 变量遮蔽
    outer := "outer"
    {
        outer := "inner"  // 遮蔽外层变量
        fmt.Println(outer)  // 输出"inner"
    }
    fmt.Println(outer)  // 输出"outer"
    
    // 变量零值
    var zeroInt int      // 0
    var zeroString string // ""
    var zeroBool bool    // false
    var zeroPtr *int     // nil
    
    // 变量类型转换
    var i1 int = 10
    var f1 float64 = float64(i1)
    var i2 int = int(f1)
    
    // 变量地址和指针
    value := 42
    ptrValue := &value
    fmt.Printf("值: %d, 地址: %p\n", value, ptrValue)
    
    // 变量比较
    str1 := "hello"
    str2 := "hello"
    fmt.Println(str1 == str2)  // true
    
    // 变量打印
    fmt.Println(name, age, height)
    fmt.Printf("姓名: %s, 年龄: %d\n", name, age)
    fmt.Printf("类型: %T, 值: %v\n", name, name)
    
    // 反射获取变量信息
    varName := "test"
    fmt.Println("类型:", reflect.TypeOf(varName))
    fmt.Println("值:", reflect.ValueOf(varName))
    
    // 变量交换
    x1, y1 := 1, 2
    x1, y1 = y1, x1  // 交换值
    
    // 变量初始化
    var initialized string
    initialized = "已初始化"
    
    // 多返回值
    result1, result2 := multipleReturn()
    fmt.Println(result1, result2)
    
    // 匿名变量
    _, nameOnly := getNameAndAge()
    fmt.Println(nameOnly)
    
    // 变量可见性
    // 首字母大写：包外可见
    // 首字母小写：包内可见
    
    // 变量命名规范
    // 使用驼峰命名法
    // 首字母大写表示导出
    // 首字母小写表示私有
    
    // 变量注释
    // 单行注释
    /* 
       多行注释
    */
    
    // 变量文档注释
    // ExportedVar 是一个导出的变量
    var ExportedVar = "exported"
}

// 多返回值函数
func multipleReturn() (int, string) {
    return 1, "hello"
}

// 返回多个值的函数
func getNameAndAge() (string, int) {
    return "张三", 25
}

JavaScript 变量语法

// var 声明（函数作用域）
var name = "张三";
var age = 25;
var height = 175.5;
var isStudent = true;
var score = null;
var undefinedVar;

// let 声明（块级作用域）
let firstName = "李";
let lastName = "四";
let userName = "admin";

// const 声明（常量）
const PI = 3.14159;
const MAX_SIZE = 100;
const DEFAULT_NAME = "guest";

// 变量提升
console.log(hoistedVar);  // undefined
var hoistedVar = "提升";

// 暂时性死区
// console.log(tempDead);  // ReferenceError
let tempDead = "暂时性死区";

// 重复声明
var x = 1;
var x = 2;  // 允许
// let y = 1;
// let y = 2;  // SyntaxError: Identifier 'y' has already been declared

// 变量作用域
var globalVar = "全局变量";

function testScope() {
    var functionVar = "函数作用域";
    let blockVar = "块级作用域";
    
    if (true) {
        var ifVar = "if块中的var";
        let ifLetVar = "if块中的let";
    }
    
    console.log(ifVar);     // 可访问
    // console.log(ifLetVar); // ReferenceError
}

// 块级作用域
{
    let blockScoped = "块级作用域变量";
    const blockConst = "块级常量";
}
// console.log(blockScoped);  // ReferenceError

// 变量解构赋值
// 数组解构
let [a, b, c] = [1, 2, 3];
let [first, , third] = [1, 2, 3];  // 跳过第二个元素
let [head, ...tail] = [1, 2, 3, 4, 5];  // rest操作符

// 对象解构
let {name: n, age: a} = {name: "张三", age: 25};
let {city = "北京"} = {};  // 默认值

// 嵌套解构
let {user: {name: userName}} = {user: {name: "李四"}};

// 交换变量
let x1 = 1, y1 = 2;
[x1, y1] = [y1, x1];

// 多返回值解构
function multipleReturn() {
    return [1, "hello", true];
}
let [num, str, bool] = multipleReturn();

// 变量类型
let str = "字符串";
let num = 123;
let float = 3.14;
let bool = true;
let n = null;
let undef = undefined;
let sym = Symbol("unique");
let bigInt = 123n;

// 动态类型
let dynamic = 10;
dynamic = "hello";
dynamic = true;
dynamic = [1, 2, 3];
dynamic = {key: "value"};

// typeof 运算符
console.log(typeof str);      // "string"
console.log(typeof num);      // "number"
console.log(typeof bool);     // "boolean"
console.log(typeof n);        // "object"
console.log(typeof undef);    // "undefined"
console.log(typeof sym);      // "symbol"
console.log(typeof bigInt);   // "bigint"

// 类型转换
// 字符串转换
let strNum = String(123);
let strBool = String(true);
let strNull = String(null);

// 数字转换
let numStr = Number("123");
let numBool = Number(true);
let numParse = parseInt("123");
let floatParse = parseFloat("3.14");

// 布尔转换
let boolStr = Boolean("hello");
let boolNum = Boolean(0);
let boolArr = Boolean([]);

// 隐式类型转换
let result = "5" + 3;      // "53"
let result2 = "5" - 3;     // 2
let result3 = "5" * 3;     // 15

// 变量比较
console.log(5 == "5");      // true (宽松相等)
console.log(5 === "5");     // false (严格相等)
console.log(null == undefined);  // true
console.log(null === undefined); // false

// 变量运算符
let count = 0;
count++;      // 后置递增
++count;      // 前置递增
count--;      // 后置递减
--count;      // 前置递减

count += 5;   // count = count + 5
count -= 3;   // count = count - 3
count *= 2;   // count = count * 2
count /= 4;   // count = count / 4
count %= 3;   // count = count % 3

// 三元运算符
let age = 20;
let status = (age >= 18) ? "成人" : "未成年";

// 逻辑运算符
let andResult = true && "hello";  // "hello"
let orResult = false || "default"; // "default"
let nullish = null ?? "default";  // "default"

// 可选链操作符
let user = {name: "张三"};
let city = user?.address?.city;  // undefined，不会报错

// 空值合并运算符
let username = null ?? "guest";  // "guest"

// 模板字符串
let name = "张三";
let age = 25;
let message = `姓名：${name}，年龄：${age}`;
let multiLine = `
    这是
    多行
    字符串
`;

// 变量属性访问
let obj = {key: "value"};
let keyName = "key";
console.log(obj.key);        // 点号访问
console.log(obj["key"]);     // 方括号访问
console.log(obj[keyName]);   // 动态属性名

// 变量方法调用
let str = "hello";
console.log(str.toUpperCase());  // "HELLO"
console.log(str.length);         // 5

// 变量作为函数参数
function greet(name) {
    console.log(`Hello, ${name}!`);
}
greet("张三");

// 变量作为函数返回值
function createPerson(name, age) {
    return {name, age};
}
let person = createPerson("李四", 30);

// 闭包中的变量
function outer() {
    let outerVar = "outer";
    return function inner() {
        console.log(outerVar);
    };
}
let closure = outer();
closure();  // "outer"

// 立即执行函数表达式中的变量
(function() {
    let iifeVar = "IIFE";
    console.log(iifeVar);
})();

// 变量垃圾回收
let largeData = new Array(1000000).fill(0);
largeData = null;  // 允许垃圾回收

// 变量冻结
const obj = {key: "value"};
Object.freeze(obj);
// obj.key = "new";  // 严格模式下会报错

// 变量密封
const sealed = {key: "value"};
Object.seal(sealed);
// sealed.newKey = "new";  // 严格模式下会报错

// 变量属性描述符
let descriptorObj = {};
Object.defineProperty(descriptorObj, 'readOnly', {
    value: "只读",
    writable: false,
    enumerable: true,
    configurable: false
});

// 变量代理
let target = {key: "value"};
let proxy = new Proxy(target, {
    get: function(obj, prop) {
        return prop in obj ? obj[prop] : "默认值";
    }
});

// 变量符号
let sym1 = Symbol("description");
let sym2 = Symbol("description");
console.log(sym1 === sym2);  // false

// 全局符号注册表
let globalSym = Symbol.for("global");
let sameSym = Symbol.for("global");
console.log(globalSym === sameSym);  // true

// 变量迭代
let iterable = [1, 2, 3];
for (let item of iterable) {
    console.log(item);
}

// 变量展开运算符
let arr1 = [1, 2, 3];
let arr2 = [...arr1, 4, 5];
let obj1 = {a: 1, b: 2};
let obj2 = {...obj1, c: 3};

// 变量剩余参数
function sum(...numbers) {
    return numbers.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4, 5));  // 15

// 变量标签模板
function tag(strings, ...values) {
    console.log(strings);
    console.log(values);
}
let name = "张三";
tag`Hello ${name}!`;

// 变量私有字段（ES2022+）
class MyClass {
    #privateField = "私有字段";
    getPrivate() {
        return this.#privateField;
    }
}

// 变量静态字段
class MyClass2 {
    static staticField = "静态字段";
}
console.log(MyClass2.staticField);

// 变量装饰器（实验性）
// @decorator
// class DecoratedClass {
//     @readonly
//     method() {}
// }

二、数据类型详解

PHP 数据类型

<?php
// 标量类型
// 整数类型
$int1 = 123;              // 十进制
$int2 = -123;             // 负数
$int3 = 0123;             // 八进制（123）
$int4 = 0x1A;             // 十六进制（26）
$int5 = 0b11111111;       // 二进制（255）

// 浮点数类型
$float1 = 1.234;
$float2 = 1.2e3;          // 1200
$float3 = 7E-10;          // 0.0000000007

// 字符串类型
$string1 = '单引号字符串';
$string2 = "双引号字符串，可以包含变量 $name";
$string3 = "转义字符：\n 换行，\t 制表符";
$string4 = <<<EOT
    多行字符串
    Heredoc语法
EOT;

// 布尔类型
$bool1 = true;
$bool2 = false;
$bool3 = (bool)1;         // true
$bool4 = (bool)0;         // false
$bool5 = (bool)"0";       // false
$bool6 = (bool)"";        // false
$bool7 = (bool)null;      // false

// 复合类型
// 数组类型
$array1 = array(1, 2, 3);          // 索引数组
$array2 = [1, 2, 3];               // 短数组语法
$array3 = ["a" => 1, "b" => 2];    // 关联数组
$array4 = [1, "a" => 2, 3];        // 混合数组

// 对象类型
class Person {
    public $name;
    public $age;
    
    function __construct($name, $age) {
        $this->name = $name;
        $this->age = $age;
    }
}

$obj = new Person("张三", 25);

// 特殊类型
// NULL类型
$null1 = null;
$null2 = NULL;
$null3;  // 未初始化的变量

// 资源类型
$file = fopen("test.txt", "r");
// $file 是一个资源类型

// 回调类型
function callback($param) {
    echo $param;
}
$cb = 'callback';
$cb("test");

// 类型声明
// 标量类型声明（PHP 7+）
function add(int $a, int $b): int {
    return $a + $b;
}

function divide(float $a, float $b): float {
    return $a / $b;
}

function greet(string $name): string {
    return "Hello, $name";
}

function isActive(bool $status): bool {
    return $status;
}

// 返回类型声明
function getArray(): array {
    return [1, 2, 3];
}

function getObject(): Person {
    return new Person("李四", 30);
}

function getCallable(): callable {
    return function() {
        return "callable";
    };
}

// 可空类型
function nullable(?string $name): ?string {
    return $name;
}

// 联合类型（PHP 8+）
function union(int|string $param): int|string {
    return $param;
}

// 交集类型（PHP 8.1+）
function intersection(Traversable&Countable $param) {
    // ...
}

// 类型检查函数
$var = 123;
var_dump(is_int($var));        // true
var_dump(is_float($var));      // false
var_dump(is_string($var));     // false
var_dump(is_bool($var));       // false
var_dump(is_array($var));      // false
var_dump(is_object($var));     // false
var_dump(is_null($var));       // false
var_dump(is_numeric($var));    // true
var_dump(is_scalar($var));     // true

// 类型转换
// 显式转换
$int = (int)"123";
$float = (float)"3.14";
$string = (string)123;
$bool = (bool)"true";
$array = (array)$obj;
$object = (object)$array;

// settype函数
$var = "123";
settype($var, "integer");
var_dump($var);  // int(123)

// 类型比较
var_dump(1 == "1");      // true (宽松比较)
var_dump(1 === "1");     // false (严格比较)
var_dump(0 == false);    // true
var_dump(0 === false);   // false
var_dump(null == 0);     // true
var_dump(null === 0);    // false

// 类型提示
class Container {
    private array $items = [];
    
    public function addItem(string $item): void {
        $this->items[] = $item;
    }
    
    public function getItems(): array {
        return $this->items;
    }
}

// 枚举类型（PHP 8.1+）
enum Status: string {
    case DRAFT = 'draft';
    case PUBLISHED = 'published';
    case ARCHIVED = 'archived';
}

$status = Status::PUBLISHED;
echo $status->value;  // "published"

// 只读属性（PHP 8.1+）
class User {
    public readonly string $name;
    
    public function __construct(string $name) {
        $this->name = $name;
    }
}

// 新的初始化器（PHP 8.1+）
class Product {
    public function __construct(
        private string $name,
        private float $price = 0.0,
        private array $tags = []
    ) {}
}

// 属性类型
class Article {
    public string $title;
    public ?string $content = null;
    public array $metadata = [];
    public DateTime $createdAt;
}

// 泛型注释（虽然PHP没有原生泛型）
/**
 * @template T
 * @param T $value
 * @return T
 */
function identity($value) {
    return $value;
}
?>

Go 数据类型

package main

import (
    "fmt"
    "math"
    "math/big"
    "unsafe"
)

func main() {
    // 布尔类型
    var b1 bool = true
    var b2 bool = false
    fmt.Println(b1, b2)
    
    // 数值类型
    // 整数类型
    var int8Var int8 = 127           // -128 to 127
    var int16Var int16 = 32767       // -32768 to 32767
    var int32Var int32 = 2147483647  // -2147483648 to 2147483647
    var int64Var int64 = 9223372036854775807 // -9223372036854775808 to 9223372036854775807
    var intVar int = 42              // 平台相关，32或64位
    
    // 无符号整数
    var uint8Var uint8 = 255         // 0 to 255
    var uint16Var uint16 = 65535     // 0 to 65535
    var uint32Var uint32 = 4294967295 // 0 to 4294967295
    var uint64Var uint64 = 18446744073709551615 // 0 to 18446744073709551615
    var uintVar uint = 42            // 平台相关
    
    // 浮点数类型
    var float32Var float32 = 3.14    // IEEE-754 32位浮点数
    var float64Var float64 = 3.141592653589793 // IEEE-754 64位浮点数
    
    // 复数类型
    var complex64Var complex64 = 1 + 2i
    var complex128Var complex128 = 3 + 4i
    
    // 字符串类型
    var str1 string = "Hello"
    var str2 string = `Raw string
    多行字符串
    不转义`
    
    // 字节和符文
    var byteVar byte = 'A'           // uint8的别名
    var runeVar rune = '中'          // int32的别名，表示Unicode码点
    
    // 派生类型
    // 指针类型
    var ptr *int
    num := 42
    ptr = &num
    fmt.Println(*ptr)
    
    // 数组类型
    var arr1 [3]int = [3]int{1, 2, 3}
    var arr2 = [5]string{"a", "b", "c", "d", "e"}
    var arr3 = [...]int{1, 2, 3, 4, 5}  // 编译器推断长度
    
    // 切片类型
    var slice1 []int = []int{1, 2, 3}
    var slice2 = make([]string, 3)
    var slice3 = make([]float64, 5, 10) // 长度5，容量10
    
    // 映射类型
    var map1 map[string]int = make(map[string]int)
    var map2 = map[string]string{
        "name": "张三",
        "city": "北京",
    }
    
    // 结构体类型
    type Person struct {
        Name string
        Age  int
    }
    var p1 Person
    var p2 = Person{Name: "李四", Age: 30}
    
    // 接口类型
    var i1 interface{}
    i1 = "hello"
    i1 = 123
    i1 = 3.14
    
    // 函数类型
    var add func(int, int) int
    add = func(a, b int) int {
        return a + b
    }
    
    // 通道类型
    var ch1 chan int = make(chan int)
    var ch2 chan string = make(chan string, 10) // 带缓冲的通道
    
    // 类型别名
    type Celsius float64
    type Fahrenheit float64
    
    var temp Celsius = 25.5
    
    // 类型定义
    type MyInt int
    var myInt MyInt = 42
    
    // 枚举类型（使用iota）
    type Weekday int
    
    const (
        Sunday Weekday = iota
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
        Saturday
    )
    
    // 类型转换
    var i int = 42
    var f float64 = float64(i)
    var j int = int(f)
    
    var b byte = byte(i)
    var r rune = rune(i)
    
    // 类型断言
    var val interface{} = "hello"
    str, ok := val.(string)
    if ok {
        fmt.Println(str)
    }
    
    // 类型开关
    switch v := val.(type) {
    case string:
        fmt.Println("字符串:", v)
    case int:
        fmt.Println("整数:", v)
    default:
        fmt.Println("未知类型")
    }
    
    // 类型大小
    fmt.Println("int8大小:", unsafe.Sizeof(int8Var))
    fmt.Println("int64大小:", unsafe.Sizeof(int64Var))
    fmt.Println("float64大小:", unsafe.Sizeof(float64Var))
    
    // 类型零值
    var zeroInt int      // 0
    var zeroFloat float64 // 0.0
    var zeroBool bool    // false
    var zeroString string // ""
    var zeroPtr *int     // nil
    var zeroSlice []int  // nil
    var zeroMap map[string]int // nil
    var zeroFunc func()  // nil
    var zeroChan chan int // nil
    
    // 常量
    const Pi = 3.14159
    const MaxSize = 100
    
    const (
        A = iota  // 0
        B         // 1
        C         // 2
    )
    
    // 无类型常量
    const untyped = 42  // 无类型整数常量
    const untypedFloat = 3.14  // 无类型浮点数常量
    
    // 类型检查
    var x interface{} = 42
    fmt.Println("类型:", fmt.Sprintf("%T", x))
    fmt.Println("值:", x)
    
    // 大数类型
    bigInt := big.NewInt(12345678901234567890)
    fmt.Println("大整数:", bigInt)
    
    // 位运算
    a := 5  // 101
    b := 3  // 011
    fmt.Println("与:", a & b)   // 001 = 1
    fmt.Println("或:", a | b)   // 111 = 7
    fmt.Println("异或:", a ^ b) // 110 = 6
    fmt.Println("左移:", a << 1) // 1010 = 10
    fmt.Println("右移:", a >> 1) // 10 = 2
    
    // 数学常量
    fmt.Println("最大int8:", math.MaxInt8)
    fmt.Println("最小int8:", math.MinInt8)
    fmt.Println("最大float64:", math.MaxFloat64)
    
    // 类型方法
    type MyType int
    
    func (m MyType) Double() MyType {
        return m * 2
    }
    
    var mt MyType = 5
    fmt.Println("Double:", mt.Double())
    
    // 匿名结构体
    anon := struct {
        Name string
        Age  int
    }{
        Name: "匿名",
        Age:  25,
    }
    fmt.Println(anon)
    
    // 嵌入类型
    type Address struct {
        City string
    }
    
    type Employee struct {
        Name    string
        Address // 嵌入
    }
    
    emp := Employee{
        Name: "张三",
        Address: Address{City: "北京"},
    }
    fmt.Println(emp.City)  // 通过嵌入访问
    
    // 标签（struct tags）
    type User struct {
        Name  string `json:"name" validate:"required"`
        Email string `json:"email" validate:"email"`
    }
    
    // 泛型（Go 1.18+）
    type Number interface {
        int | int64 | float64
    }
    
    func Sum[T Number](nums []T) T {
        var sum T
        for _, num := range nums {
            sum += num
        }
        return sum
    }
    
    result := Sum([]int{1, 2, 3, 4, 5})
    fmt.Println("Sum:", result)
}

JavaScript 数据类型

// 原始类型（Primitive Types）
// 字符串类型
let str1 = "双引号字符串";
let str2 = '单引号字符串';
let str3 = `模板字符串，可以包含变量 ${name}`;
let str4 = String(123);  // 类型转换
let str5 = new String("对象字符串");  // 不推荐

// 数值类型
let num1 = 123;           // 整数
let num2 = -456;          // 负数
let num3 = 3.14;          // 浮点数
let num4 = 1.23e4;        // 科学计数法 12300
let num5 = 0xFF;          // 十六进制 255
let num6 = 0o777;         // 八进制 511
let num7 = 0b1111;        // 二进制 15
let num8 = Infinity;      // 无穷大
let num9 = -Infinity;     // 负无穷大
let num10 = NaN;          // 非数字
let num11 = Number.MAX_VALUE;  // 最大数值
let num12 = Number.MIN_VALUE;  // 最小数值

// 大整数类型（ES2020+）
let bigInt1 = 123n;
let bigInt2 = BigInt(123);
let bigInt3 = BigInt("123456789012345678901234567890");

// 布尔类型
let bool1 = true;
let bool2 = false;
let bool3 = Boolean(1);       // true
let bool4 = Boolean(0);       // false
let bool5 = Boolean("hello"); // true
let bool6 = Boolean("");      // false
let bool7 = !!value;          // 双重否定转换

// Undefined类型
let undef1;
let undef2 = undefined;
let undef3 = void 0;          // 另一种写法

// Null类型
let null1 = null;

// Symbol类型（ES2015+）
let sym1 = Symbol("description");
let sym2 = Symbol("description");
console.log(sym1 === sym2);  // false，唯一性

// 全局Symbol注册表
let globalSym1 = Symbol.for("global");
let globalSym2 = Symbol.for("global");
console.log(globalSym1 === globalSym2);  // true

// Symbol作为对象属性键
let obj = {
    [Symbol("key")]: "value",
    [Symbol.iterator]: function*() {
        yield 1;
        yield 2;
    }
};

// 对象类型（Object Types）
// 普通对象
let obj1 = {key: "value"};
let obj2 = new Object();
let obj3 = Object.create(null);  // 无原型对象

// 数组
let arr1 = [1, 2, 3];
let arr2 = new Array(1, 2, 3);
let arr3 = Array.of(1, 2, 3);
let arr4 = Array.from("hello");  // ['h', 'e', 'l', 'l', 'o']

// 函数
function func1() {}
let func2 = function() {};
let func3 = () => {};
let func4 = new Function('a', 'b', 'return a + b');

// 日期对象
let date1 = new Date();
let date2 = new Date(2024, 0, 1);  // 2024年1月1日
let date3 = new Date("2024-01-01");

// 正则表达式
let regex1 = /pattern/;
let regex2 = new RegExp("pattern");
let regex3 = /pattern/gi;  // 全局、忽略大小写

// 错误对象
let error1 = new Error("错误信息");
let error2 = new TypeError("类型错误");
let error3 = new RangeError("范围错误");

// Map对象（ES2015+）
let map = new Map();
map.set("key", "value");
map.set(1, "number");
map.set(true, "boolean");

// Set对象（ES2015+）
let set = new Set();
set.add(1);
set.add(2);
set.add(2);  // 重复值不会添加
set.add("string");

// WeakMap对象（ES2015+）
let weakMap = new WeakMap();
let keyObj = {};
weakMap.set(keyObj, "value");

// WeakSet对象（ES2015+）
let weakSet = new WeakSet();
weakSet.add(keyObj);

// Promise对象（ES2015+）
let promise = new Promise((resolve, reject) => {
    resolve("成功");
});

// Proxy对象（ES2015+）
let target = {key: "value"};
let proxy = new Proxy(target, {
    get: function(obj, prop) {
        return prop in obj ? obj[prop] : "默认值";
    }
});

// Reflect对象（ES2015+）
let objReflect = {};
Reflect.set(objReflect, 'key', 'value');
console.log(Reflect.get(objReflect, 'key'));

// 类（ES2015+）
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
    
    greet() {
        console.log(`Hello, ${this.name}`);
    }
}

// 静态方法和属性
class MyClass {
    static staticProp = "静态属性";
    
    static staticMethod() {
        return "静态方法";
    }
}

// 私有字段（ES2022+）
class PrivateClass {
    #privateField = "私有字段";
    
    getPrivate() {
        return this.#privateField;
    }
}

// 类型检查
let value = "hello";

console.log(typeof value);        // "string"
console.log(typeof 123);          // "number"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof null);         // "object" (历史遗留问题)
console.log(typeof {});           // "object"
console.log(typeof []);           // "object"
console.log(typeof function(){}); // "function"
console.log(typeof Symbol());     // "symbol"
console.log(typeof 123n);         // "bigint"

// instanceof 检查
console.log([] instanceof Array);        // true
console.log({} instanceof Object);       // true
console.log(function(){} instanceof Function); // true
console.log(new Date() instanceof Date); // true

// Array.isArray 检查
console.log(Array.isArray([]));  // true
console.log(Array.isArray({}));  // false

// Object.prototype.toString 检查
console.log(Object.prototype.toString.call([]));      // "[object Array]"
console.log(Object.prototype.toString.call({}));      // "[object Object]"
console.log(Object.prototype.toString.call(null));    // "[object Null]"
console.log(Object.prototype.toString.call(undefined)); // "[object Undefined]"

// 类型转换
// 字符串转换
let strNum = String(123);
let strBool = String(true);
let strObj = String({key: "value"});
let strNull = String(null);
let strUndef = String(undefined);

// 数字转换
let numStr = Number("123");
let numBool = Number(true);
let numObj = Number({valueOf: () => 42});
let numParseInt = parseInt("123");
let numParseFloat = parseFloat("3.14");

// 布尔转换
let boolStr = Boolean("hello");
let boolNum = Boolean(0);
let boolObj = Boolean({});
let boolArr = Boolean([]);

// 隐式类型转换
let result1 = "5" + 3;      // "53" (字符串拼接)
let result2 = "5" - 3;      // 2 (数字减法)
let result3 = "5" * 3;      // 15 (数字乘法)
let result4 = "5" / 2;      // 2.5 (数字除法)
let result5 = "5" % 2;      // 1 (数字取模)

// == 和 === 的区别
console.log(5 == "5");      // true (类型转换后比较)
console.log(5 === "5");     // false (类型和值都比较)
console.log(0 == false);    // true
console.log(0 === false);   // false
console.log(null == undefined);  // true
console.log(null === undefined); // false

// 类型转换规则
// ToPrimitive - 转换为原始值
let objToPrim = {
    valueOf: function() { return 42; },
    toString: function() { return "hello"; }
};
console.log(+objToPrim);  // 42 (优先调用valueOf)

// ToNumber - 转换为数字
console.log(Number("123"));    // 123
console.log(Number("3.14"));   // 3.14
console.log(Number(""));       // 0
console.log(Number("hello"));  // NaN
console.log(Number(true));     // 1
console.log(Number(false));    // 0
console.log(Number(null));     // 0
console.log(Number(undefined)); // NaN

// ToString - 转换为字符串
console.log(String(123));      // "123"
console.log(String(true));     // "true"
console.log(String(null));     // "null"
console.log(String(undefined)); // "undefined"
console.log(String({}));       // "[object Object]"

// ToBoolean - 转换为布尔值
// 以下值转换为false
console.log(Boolean(false));   // false
console.log(Boolean(0));       // false
console.log(Boolean(-0));      // false
console.log(Boolean(0n));      // false
console.log(Boolean(""));      // false
console.log(Boolean(null));    // false
console.log(Boolean(undefined)); // false
console.log(Boolean(NaN));     // false

// 其他所有值转换为true
console.log(Boolean("0"));     // true
console.log(Boolean("false")); // true
console.log(Boolean([]));      // true
console.log(Boolean({}));      // true
console.log(Boolean(function(){})); // true

// 类型安全函数
function safeAdd(a, b) {
    if (typeof a !== 'number' || typeof b !== 'number') {
        throw new TypeError('参数必须是数字');
    }
    return a + b;
}

// TypeScript类型注释（虽然不是原生支持）
/**
 * @param {number} a
 * @param {number} b
 * @returns {number}
 */
function add(a, b) {
    return a + b;
}

// JSDoc类型注释
/**
 * @typedef {Object} User
 * @property {string} name
 * @property {number} age
 * @property {string[]} hobbies
 */

/**
 * @param {User} user
 * @returns {string}
 */
function greetUser(user) {
    return `Hello, ${user.name}`;
}

// 类型守卫
function isString(value) {
    return typeof value === 'string';
}

function process(value) {
    if (isString(value)) {
        // TypeScript中这里value会被推断为string类型
        return value.toUpperCase();
    }
    return value;
}

以上是三种语言在变量和类型方面的详细对照，涵盖了基本语法、数据类型、类型转换、作用域等核心概念。每种语言都有其独特的特性和最佳实践。