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