语法对比手册（ES6+ 视角）

功能场景JavaScript (ES6+)Python (3.9+)关键差异说明
变量定义const / let（块级作用域）直接赋值（无关键字，作用域由代码块决定）Python 没有变量声明关键字
函数定义箭头函数：const fn = () => {}def fn(): + 缩进Python 使用缩进定义函数体
条件语句if (condition) { ... } else { ... }if condition: ... else: ...冒号替代大括号
模板字符串`Hello ${name}`f"Hello {name}"格式化字符串前缀差异
循环迭代for...of（可迭代对象）for item in iterable:语法结构高度相似
解构赋值const { prop } = obj;prop = obj["prop"] 或直接属性访问Python 需要显式访问
类定义class X { constructor() { ... } }class X: def __init__(self): ...self 参数与初始化方法差异
模块系统ES模块：import module from 'module'import module导入机制与路径解析差异
异步操作async/await + Promiseasync/await + 协程事件循环实现方式不同
展开运算符[...arr, newItem] / {...obj, key: val}[*arr, new_item] / {**dict, key: val}语法符号差异
生成器function* gen() { yield value; }def gen(): yield value语法声明方式不同
错误处理try { ... } catch (e) { ... }try: ... except Exception as e: ...异常捕获关键字差异

变量定义

JavaScript

const a = 1;
let b = 2;

Python

a = 1
b = 2

函数定义

Javascript

const add = (a, b) => a + b;
console.log(add(2, 3));

python

def add(a, b):
  return a + b

print(add(2,3))

条件语句

JavaScript

if (age > 18) {
  console.log("成年人");
} else {
  console.log("你是非成年人");
}

Python

if age > 18:
  print("成年人")
esle:
  print("你是非成年人")

模板字符串

JavaScript

const yourName = "John"
console.log(`Hello ${yourName}`)

Python

your_name = "John"
print(f'Hello {your_name}')

循环迭代

JavaScript

for (var i = 0; i < 10; i++) {
  console.log(`i 的值为：${i}`)
}

Python

for i in range(10):
  print(f"i 的值为：{i}")

类定义

Javascript

class Person {
  private name = ""
  private age = 0

  constructor(name, age) {
    this.name = name
    this.age = age
  }

  public getName() {
    return this.name
  }

  public getAge() {
    return this.age
  }

  get personName() {
    return this.name
  }

  set personName(name) {
    this.name = name
  }
}

// 使用示例
const p = new Person("Alice");
console.log(p.personName); // "ALICE"（自动调用 getter）
p.personName = " Bob ";    // 自动调用 setter
console.log(p.personName); // "BOB"（setter 处理后的值）

Python

class Person:

  # 构造器
  def __init__(self, name, age):
    # 私有成员通过双下划线 __ 前缀声明
    # self 参数表示实例本身
    # 成员变量在构造函数中直接初始化，无需提前声明
    self.__name = name
    self.__age = age
    
  def getName():
    return self.__name
    
  def getAge():
    return self.__age
    
  @property
  def persion_name():
    return self.__name
    
  @person_name.setter
  def person_name(self, name):
    self.__name = new_name.strip()
    
# 使用示例
p = Person("Alice")
print(p.person_name)  # "ALICE"（通过 @property 访问）
p.person_name = " Bob "  # 通过 setter 修改
print(p.person_name)  # "BOB"（处理后的值）

模块系统

Javascript

// mathUtils.js
export function add(a, b) {
  return a + b
}

export function publicFunc() {
}

function privateFunc() {
}

// main.js
import { add, publicFunc } from './mainUtils.js'

console.log(add(1, 2))
publicFunc()

Python

# math_unitls.py
__all__ = ["add"]

def add(a,b):
  return a + b
  
def pubic_func():
  pass
  
# 以 _ 开头不会被导入
def _private_func():
  pass

# main.py
from math_utils import *
print(add(1,2)) 
print(pubic_func())

异步操作

Javascript

function sleep(time) {
  return new Promise((resolve, reject) => {
    setTimeout(resolve, time);
  });
}

async function main() {
  await sleep(1000);
  console.log('Hello async/await')
}

Python

import asyncio

def sleep(milliseconds):
    # 创建未完成的 Future 对象
    future = asyncio.get_event_loop().create_future()
    
    # 设置定时器回调（注意时间单位转换：毫秒→秒）
    asyncio.get_event_loop().call_later(
        milliseconds / 1000, 
        future.set_result,  # 定时结束后完成 Future
        None
    )
    return future

async def main():
    await sleep(1000)  # 等待 1000 毫秒（1 秒）
    print("Hello async/await")

asyncio.run(main())  # 输出：Hello async/await（1 秒后）