JavaScript

let val
try {
  val = mayThrows()
} catch (e) {
  // handle errors
}
// use val

• 标识符val是可变的
• 变量的声明与初始化位置分离

try {
  const val = mayThrows()
  
  // use val
} catch (e) {
  // handle errors
}

• try块内的所有异常都挤在同一个catch块里处理
• try块内的代码可能会很长, 影响可读性

const val = go(() => {
  try {
    return mayThrows()
  } catch (e) {
    // handle errors
  }
})
// use val

• catch块无法控制外部函数的返回

// 使用 var 是为了能够重复声明 err
var [err, val] = getErrorResult(() => mayThrows())
if (err) {
  // handle errors
}
// use val

• 标识符val是可变的
• TypeScript不能用if语句判断出 [err, undefined] | [undefined, val] 的类型差异,
  为此需要 assert(isntUndefined(val)), 这同时造成val的值不能是undefined.

• 其右值不能省略, 省略时会直接语法错误.
• 返回值与yield不一样.

function* foo() {
  console.log(yield* bar()) // undefined
  yield 'C'
}
function* bar() {
  console.log(yield 'A') // 1
  console.log(yield 'B') // 2
}
const iter = foo()
console.log(iter.next()) // { value: 'A', done: false }
console.log(iter.next(1)) // { value: 'B', done: false }
console.log(iter.next(2)) // { value: 'C', done: false }
console.log(iter.next(3)) // { done: true }

function* num() {
  yield 1
  yield 2
  yield 3
}
// 即使改用 const iter = num()[Symbol.iterator](),
// 或是从iter里再调用Symbol.iterator创建出一个iterable也是一样
const iter = num()
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 不会运行
}

function* num() {
  yield 1
  yield 2
  yield 3
}
const iter = num()
for (const val of iter) {
  console.log(val) // 1
  break
}
console.log([...iter]) // []

function wrapper(iterator) {
  return {
    [Symbol.iterator]() {
      return {
        next() {
          return iterator.next()
        }
      }
    }
  }
}
function* num() {
  yield 1
  yield 2
  yield 3
}
const iter = wrapper(num())
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 2, 3
}

function* num() {
  yield 1
  yield 2
  yield 3
}
// 生成器函数的原型是一个Generator实例, 为return赋值只是遮蔽掉原型方法, 因此不会影响其他生成器函数, 异步生成器函数同理.
num.prototype.return = undefined;
const iter = num()
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 2, 3
}

const num = {
  i: 0
, [Symbol.iterator]() {
    // 如果在此处插入一个console.log, 会发现此iterator被创建了两次
    return {
      next() {
        if (num.i < 3) {
          return { done: false, value: ++num.i }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}
const iter = num
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
    console.log(val) // 2, 3
}

const num = {
  i: 0
, *[Symbol.iterator]() {
    // 如果在此处插入一个console.log, 会发现此iterator被创建了两次
    while (num.i < 3) {
      yield ++num.i
    }
  }
}
const iter = num
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 2, 3
}

const num = {
  i: 0
, [Symbol.iterator]() {
    // 如果在此处插入一个console.log, 会发现此iterator被创建了两次
    return {
      next() {
        if (num.i < 3) {
          return { done: false, value: ++num.i }
        } else {
          return { done: true, value: undefined }
        }
      }
    , return(...args) {
        console.log('return', args)
        return { done: true }
      }
    }
  }
}
const iter = num
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
    console.log(val) // 2, 3
}
// 输出顺序为:
// 1
// return []
// 2
// 3

const num = [1, 2, 3]
const iter = num[Symbol.iterator]()
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 2, 3
}

const num = [1, 2, 3]
const iter = num[Symbol.iterator]()
for (const val of iter) {
  console.log(val) // 1
  break
}
console.log([...iter]) // [2, 3]

const num = '123'
const iter = num[Symbol.iterator]()
for (const val of iter) {
  console.log(val) // 1
  break
}
for (const val of iter) {
  console.log(val) // 2, 3
}

const num = '123'
const iter = num[Symbol.iterator]()
for (const val of iter) {
  console.log(val) // 1
  break
}
console.log([...iter]) // ["2", "3"]

1. 1.
   browser字段
2. 2.
   module字段
3. 3.
   main字段

• webpack-dev-server Web开发热重载
• webpack-ext-reloader 浏览器扩展程序热重载

• 对monorepo的CommonJS项目不友好: https://github.com/vitejs/vite/issues/5668
• 导入转译支持有限:
  一个能通过webpack转译的包和能通过Node.js导入的包可以通过vite的构建,
  但却可能在浏览器中导入失败.
  解决方案: https://vike.dev/broken-npm-package
• 开发模式下没有tree shaking: https://github.com/vitejs/vite/issues/8237
  这是Vite为了表面上的性能而投机取巧的地方, 也使其不如Webpack有用:
• • 大型项目将会加载特别多的文件, 导致与之相关的一切变得缓慢低效.
  • 一部分依赖Node.js的脚本因此被打包,
    这些脚本可能在加载过程中就需要调用Node.js相关的API, 进而导致失败.
    该问题据称会在Vite 8支持rolldown后通过Full Bundle Mode解决,
    目前虽然可以通过 experimental.bundledDev 实验性地启用此功能,
    但还能未解决相关问题.

• https://nodejs.org/api/cli.html#cli_preserve_symlinks
• https://github.com/nodejs/node/issues/34866