let 和 const 命令

// 问题1：变量提升
console.log(name) // undefined，而不是报错
var name = '张三'

// 问题2：没有块级作用域
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)
}
// 输出：3, 3, 3（而不是 0, 1, 2）

// 问题3：可以重复声明
var count = 1
var count = 2 // 不报错，容易造成 bug

let age = 25
age = 26 // 可以重新赋值

let username = '李四'
// let username = '王五'; // SyntaxError: 不能重复声明

{
  let a = 10
  var b = 20
}
// console.log(a); // ReferenceError: a is not defined
console.log(b) // 20

for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 100)
}
// 输出：0, 1, 2 ✅

// TDZ 开始
console.log(x) // ReferenceError: Cannot access 'x' before initialization
let x = 10 // TDZ 结束

function foo(x = y, y = 2) {
  return [x, y]
}
foo() // ReferenceError: y 在 TDZ 中

const PI = 3.14159
// PI = 3.14; // TypeError: Assignment to constant variable

// const MAX; // SyntaxError: Missing initializer

const user = { name: '张三' }
user.name = '李四' // ✅ 可以修改属性
user.age = 25 // ✅ 可以添加属性
// user = {}; // ❌ TypeError: 不能重新赋值

const list = [1, 2, 3]
list.push(4) // ✅ 可以修改数组内容
// list = []; // ❌ TypeError

const frozen = Object.freeze({ name: '张三' })
frozen.name = '李四' // 静默失败，严格模式下报错
console.log(frozen.name) // '张三'

// 注意：freeze 是浅冻结
const nested = Object.freeze({
  info: { age: 25 },
})
nested.info.age = 30 // 仍然可以修改
console.log(nested.info.age) // 30

function deepFreeze(obj) {
  Object.keys(obj).forEach((key) => {
    if (typeof obj[key] === 'object' && obj[key] !== null) {
      deepFreeze(obj[key])
    }
  })
  return Object.freeze(obj)
}

const config = deepFreeze({
  api: { url: 'https://api.example.com' },
})
config.api.url = 'xxx' // 无效

// ES5
;(function () {
  var private = '私有变量'
})()

// ES6
{
  let private = '私有变量'
}

function process(condition) {
  if (condition) {
    let result = '处理结果'
    return result
  }
  // result 在这里不可访问，避免意外使用
  return null
}

// 🔶 没有块作用域会报错
switch (type) {
  case 'A':
    let msg = 'Type A' // 报错：重复声明
    break
  case 'B':
    let msg = 'Type B'
    break
}

// ✅ 正确写法：用块包裹
switch (type) {
  case 'A': {
    let msg = 'Type A'
    console.log(msg)
    break
  }
  case 'B': {
    let msg = 'Type B'
    console.log(msg)
    break
  }
}

var globalVar = 'var'
let globalLet = 'let'
const globalConst = 'const'

console.log(window.globalVar) // 'var'
console.log(window.globalLet) // undefined
console.log(window.globalConst) // undefined

// ✅ 推荐
const config = { debug: true }
const API_URL = 'https://api.example.com'
const numbers = [1, 2, 3]

// 只有需要重新赋值时才用 let
let count = 0
count++

// ❌ 避免
var name = '张三'

// ✅ 推荐
const name = '张三'

function process(items) {
  // 变量声明放在块的顶部
  const result = []
  let total = 0

  for (const item of items) {
    result.push(item.value)
    total += item.value
  }

  return { result, total }
}

// for...of 和 for...in 使用 const
for (const item of items) {
  console.log(item)
}

for (const key in obj) {
  console.log(key)
}

// 传统 for 循环使用 let
for (let i = 0; i < 10; i++) {
  console.log(i)
}

// JavaScript 引擎知道 x 存在，但不让你访问
console.log(x) // ReferenceError
let x = 1

// 计数器
let count = 0
items.forEach(() => count++)

// 累加器
let sum = 0
for (const num of numbers) {
  sum += num
}

// 状态标记
let isReady = false
// ... 某些操作后
isReady = true

// 方案1：Object.freeze()（浅冻结）
const obj = Object.freeze({ a: 1 })

// 方案2：深冻结函数
// 方案3：使用 Immutable.js 等库
// 方案4：TypeScript 的 Readonly 类型（编译时检查）