kn-es-features 1.0.0

package/src/features/es2015/01-let-const.js

@@ -0,0 +1,54 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testLetConst() {
+  const { test, assert, getResults } = createSuite('let & const')
+
+  test('let 块级作用域', () => {
+    let results = []
+    for (let i = 0; i < 3; i++) {
+      results.push(i)
+    }
+    assert(results[0] === 0 && results[2] === 2, 'let 循环变量应为独立值')
+  })
+
+  test('let 不可重复声明', () => {
+    try {
+      // 用 Function 构造器在独立作用域测试
+      new Function('"use strict"; let x = 1; let x = 2;')()
+      assert(false, '应抛出 SyntaxError')
+    } catch (e) {
+      assert(e instanceof SyntaxError || e instanceof TypeError, '应为语法错误')
+    }
+  })
+
+  test('let 暂时性死区(TDZ)', () => {
+    try {
+      new Function('"use strict"; console.log(y); let y = 1;')()
+      assert(false, '应抛出 ReferenceError')
+    } catch (e) {
+      assert(true)
+    }
+  })
+
+  test('const 声明常量', () => {
+    const PI = 3.14159
+    assert(PI === 3.14159, 'const 值应保持不变')
+  })
+
+  test('const 不可重新赋值', () => {
+    try {
+      new Function('"use strict"; const x = 1; x = 2;')()
+      assert(false, '应抛出 TypeError')
+    } catch (e) {
+      assert(e instanceof TypeError, '应为 TypeError')
+    }
+  })
+
+  test('const 对象属性可修改', () => {
+    const obj = { a: 1 }
+    obj.a = 2
+    assert(obj.a === 2, 'const 对象的属性可以修改')
+  })
+
+  return getResults()
+}

package/src/features/es2015/02-arrow-functions.js

@@ -0,0 +1,68 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testArrowFunctions() {
+  const { test, assert, getResults } = createSuite('箭头函数')
+
+  test('基本语法', () => {
+    const add = (a, b) => a + b
+    assert(add(2, 3) === 5, '箭头函数返回值应为 5')
+  })
+
+  test('单参数省略括号', () => {
+    const double = n => n * 2
+    assert(double(4) === 8, '单参数箭头函数应正常工作')
+  })
+
+  test('无参数需要括号', () => {
+    const greet = () => 'hello'
+    assert(greet() === 'hello', '无参数箭头函数应正常工作')
+  })
+
+  test('多行函数体需要花括号和 return', () => {
+    const calc = (a, b) => {
+      const sum = a + b
+      return sum * 2
+    }
+    assert(calc(2, 3) === 10, '多行箭头函数应正确计算')
+  })
+
+  test('返回对象字面量需要括号', () => {
+    const makeObj = (x) => ({ value: x })
+    const obj = makeObj(42)
+    assert(obj.value === 42, '箭头函数返回对象应正确包裹')
+  })
+
+  test('this 词法绑定', () => {
+    function Timer() {
+      this.count = 0
+      const tick = () => {
+        this.count++
+      }
+      tick()
+      tick()
+    }
+    const t = new Timer()
+    assert(t.count === 2, '箭头函数 this 应绑定外层作用域')
+  })
+
+  test('没有 arguments 对象', () => {
+    const fn = () => typeof arguments === 'undefined' || true
+    // 在模块顶层 arguments 未定义，所以箭头函数内也未定义
+    assert(true, '箭头函数无独立 arguments')
+  })
+
+  test('不能用作构造函数（原生环境）', () => {
+    const Fn = () => {}
+    // Babel 将箭头函数编译为普通函数时，此限制在运行时不可复现，故跳过检测
+    const isNativeArrow = Fn.prototype === undefined
+    if (!isNativeArrow) return  // 编译降级环境跳过
+    try {
+      new Fn()
+      assert(false, '应抛出 TypeError')
+    } catch (e) {
+      assert(e instanceof TypeError, '箭头函数不能 new')
+    }
+  })
+
+  return getResults()
+}

package/src/features/es2015/03-template-literals.js

@@ -0,0 +1,51 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testTemplateLiterals() {
+  const { test, assert, getResults } = createSuite('模板字符串')
+
+  test('基本插值', () => {
+    const name = 'ES2015'
+    const str = `Hello, ${name}!`
+    assert(str === 'Hello, ES2015!', '模板字符串插值应正确')
+  })
+
+  test('表达式插值', () => {
+    const a = 3, b = 4
+    const str = `${a} + ${b} = ${a + b}`
+    assert(str === '3 + 4 = 7', '模板字符串支持表达式')
+  })
+
+  test('多行字符串', () => {
+    const multi = `第一行
+第二行`
+    assert(multi.includes('\n'), '模板字符串支持多行')
+  })
+
+  test('嵌套模板', () => {
+    const items = ['a', 'b', 'c']
+    const list = `items: ${items.map(i => `[${i}]`).join(', ')}`
+    assert(list === 'items: [a], [b], [c]', '模板字符串可以嵌套')
+  })
+
+  test('标签模板 - 基本用法', () => {
+    function tag(strings, ...values) {
+      return strings.raw[0] + values[0].toUpperCase()
+    }
+    const name = 'world'
+    const result = tag`hello ${name}`
+    assert(result === 'hello WORLD', '标签模板应正确处理')
+  })
+
+  test('标签模板 - String.raw', () => {
+    const path = String.raw`C:\Users\test\n`
+    assert(path.includes('\\n'), 'String.raw 应保留原始反斜杠')
+  })
+
+  test('模板字符串中调用函数', () => {
+    const upper = (s) => s.toUpperCase()
+    const str = `result: ${upper('hello')}`
+    assert(str === 'result: HELLO', '模板字符串中可调用函数')
+  })
+
+  return getResults()
+}

package/src/features/es2015/04-destructuring.js

@@ -0,0 +1,68 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testDestructuring() {
+  const { test, assert, getResults } = createSuite('解构赋值')
+
+  test('数组解构 - 基本', () => {
+    const [a, b, c] = [1, 2, 3]
+    assert(a === 1 && b === 2 && c === 3, '数组解构基本用法')
+  })
+
+  test('数组解构 - 跳过元素', () => {
+    const [, second, , fourth] = [1, 2, 3, 4]
+    assert(second === 2 && fourth === 4, '数组解构可跳过元素')
+  })
+
+  test('数组解构 - 默认值', () => {
+    const [x = 10, y = 20] = [1]
+    assert(x === 1 && y === 20, '数组解构默认值')
+  })
+
+  test('数组解构 - rest 元素', () => {
+    const [first, ...rest] = [1, 2, 3, 4]
+    assert(first === 1 && rest.length === 3, '数组解构 rest 元素')
+  })
+
+  test('数组解构 - 交换变量', () => {
+    let p = 1, q = 2;
+    [p, q] = [q, p]
+    assert(p === 2 && q === 1, '解构交换变量')
+  })
+
+  test('对象解构 - 基本', () => {
+    const { name, age } = { name: 'Alice', age: 25 }
+    assert(name === 'Alice' && age === 25, '对象解构基本用法')
+  })
+
+  test('对象解构 - 重命名', () => {
+    const { name: userName, age: userAge } = { name: 'Bob', age: 30 }
+    assert(userName === 'Bob' && userAge === 30, '对象解构重命名')
+  })
+
+  test('对象解构 - 默认值', () => {
+    const { a = 1, b = 2 } = { a: 10 }
+    assert(a === 10 && b === 2, '对象解构默认值')
+  })
+
+  test('对象解构 - rest 属性', () => {
+    const { x, ...others } = { x: 1, y: 2, z: 3 }
+    assert(x === 1 && others.y === 2 && others.z === 3, '对象解构 rest 属性')
+  })
+
+  test('嵌套解构', () => {
+    const { a: { b: { c } } } = { a: { b: { c: 42 } } }
+    assert(c === 42, '嵌套解构')
+  })
+
+  test('函数参数解构', () => {
+    const fn = ({ name, age = 18 }) => `${name}:${age}`
+    assert(fn({ name: 'Alice' }) === 'Alice:18', '函数参数解构')
+  })
+
+  test('字符串解构', () => {
+    const [a, b, c] = 'abc'
+    assert(a === 'a' && b === 'b' && c === 'c', '字符串解构')
+  })
+
+  return getResults()
+}

package/src/features/es2015/05-default-rest-spread.js

@@ -0,0 +1,87 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testDefaultRestSpread() {
+  const { test, assert, getResults } = createSuite('默认参数/Rest/Spread')
+
+  // 默认参数
+  test('默认参数 - 基本', () => {
+    const greet = (name = 'World') => `Hello, ${name}!`
+    assert(greet() === 'Hello, World!', '默认参数应生效')
+    assert(greet('Alice') === 'Hello, Alice!', '传参时默认参数应被覆盖')
+  })
+
+  test('默认参数 - undefined 触发默认值', () => {
+    const fn = (a = 1) => a
+    assert(fn(undefined) === 1, 'undefined 触发默认参数')
+    assert(fn(null) === null, 'null 不触发默认参数')
+  })
+
+  test('默认参数 - 使用前面的参数', () => {
+    const fn = (a, b = a * 2) => b
+    assert(fn(5) === 10, '默认参数可引用前面的参数')
+  })
+
+  test('默认参数 - 表达式', () => {
+    const fn = (x = Math.random()) => x
+    const result = fn()
+    assert(typeof result === 'number', '默认参数可以是表达式')
+  })
+
+  // Rest 参数
+  test('rest 参数 - 收集剩余参数', () => {
+    const sum = (first, ...rest) => rest.reduce((acc, n) => acc + n, first)
+    assert(sum(1, 2, 3, 4) === 10, 'rest 参数应收集剩余参数')
+  })
+
+  test('rest 参数 - 是真正的数组', () => {
+    const fn = (...args) => Array.isArray(args)
+    assert(fn(1, 2, 3) === true, 'rest 参数是真正的数组')
+  })
+
+  test('rest 参数只能在最后', () => {
+    try {
+      new Function('function f(...a, b){}')()
+      assert(false, '应抛出 SyntaxError')
+    } catch (e) {
+      assert(true, 'rest 参数只能在最后')
+    }
+  })
+
+  // Spread 操作符
+  test('spread 展开数组', () => {
+    const a = [1, 2, 3]
+    const b = [0, ...a, 4]
+    assert(b.join(',') === '0,1,2,3,4', 'spread 展开数组')
+  })
+
+  test('spread 复制数组', () => {
+    const original = [1, 2, 3]
+    const copy = [...original]
+    copy.push(4)
+    assert(original.length === 3 && copy.length === 4, 'spread 复制数组为浅拷贝')
+  })
+
+  test('spread 合并数组', () => {
+    const merged = [...[1, 2], ...[3, 4], ...[5]]
+    assert(merged.join(',') === '1,2,3,4,5', 'spread 合并数组')
+  })
+
+  test('spread 传入函数参数', () => {
+    const nums = [1, 2, 3]
+    assert(Math.max(...nums) === 3, 'spread 传入函数参数')
+  })
+
+  test('spread 展开对象', () => {
+    const obj1 = { a: 1, b: 2 }
+    const obj2 = { ...obj1, c: 3 }
+    assert(obj2.a === 1 && obj2.b === 2 && obj2.c === 3, 'spread 展开对象')
+  })
+
+  test('spread 对象覆盖属性', () => {
+    const base = { a: 1, b: 2 }
+    const extended = { ...base, b: 99 }
+    assert(extended.b === 99, 'spread 后面属性覆盖前面')
+  })
+
+  return getResults()
+}

package/src/features/es2015/06-classes.js

@@ -0,0 +1,100 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testClasses() {
+  const { test, assert, getResults } = createSuite('类(Class)')
+
+  test('基本类定义', () => {
+    class Animal {
+      constructor(name) {
+        this.name = name
+      }
+      speak() {
+        return `${this.name} makes a sound.`
+      }
+    }
+    const a = new Animal('Cat')
+    assert(a.name === 'Cat', '构造函数应正确赋值')
+    assert(a.speak() === 'Cat makes a sound.', '实例方法应正常工作')
+  })
+
+  test('类继承', () => {
+    class Animal {
+      constructor(name) { this.name = name }
+      speak() { return `${this.name}: ...` }
+    }
+    class Dog extends Animal {
+      speak() { return `${this.name}: Woof!` }
+    }
+    const d = new Dog('Rex')
+    assert(d.speak() === 'Rex: Woof!', '子类应覆盖父类方法')
+    assert(d instanceof Dog && d instanceof Animal, 'instanceof 检查应通过')
+  })
+
+  test('super 调用父类方法', () => {
+    class Shape {
+      area() { return 0 }
+      describe() { return `面积: ${this.area()}` }
+    }
+    class Circle extends Shape {
+      constructor(r) { super(); this.r = r }
+      area() { return Math.PI * this.r * this.r }
+      describe() { return super.describe() + ` (圆形)` }
+    }
+    const c = new Circle(1)
+    assert(c.describe().includes('面积:'), 'super 方法调用')
+  })
+
+  test('静态方法', () => {
+    class MathUtil {
+      static add(a, b) { return a + b }
+      static PI = 3.14159
+    }
+    assert(MathUtil.add(2, 3) === 5, '静态方法应直接通过类调用')
+    assert(MathUtil.PI === 3.14159, '静态属性应正确设置')
+  })
+
+  test('getter 和 setter', () => {
+    class Temperature {
+      constructor(celsius) { this._celsius = celsius }
+      get fahrenheit() { return this._celsius * 9 / 5 + 32 }
+      set fahrenheit(f) { this._celsius = (f - 32) * 5 / 9 }
+    }
+    const t = new Temperature(0)
+    assert(t.fahrenheit === 32, 'getter 应正确计算')
+    t.fahrenheit = 212
+    assert(Math.round(t._celsius) === 100, 'setter 应正确转换')
+  })
+
+  test('私有字段 (#)', () => {
+    class Counter {
+      #count = 0
+      increment() { this.#count++ }
+      get value() { return this.#count }
+    }
+    const c = new Counter()
+    c.increment()
+    c.increment()
+    assert(c.value === 2, '私有字段应正确工作')
+    assert(!('count' in c), '私有字段不可从外部访问')
+  })
+
+  test('类表达式', () => {
+    const Rect = class Rectangle {
+      constructor(w, h) { this.w = w; this.h = h }
+      area() { return this.w * this.h }
+    }
+    const r = new Rect(3, 4)
+    assert(r.area() === 12, '类表达式应正常工作')
+  })
+
+  test('类不存在变量提升', () => {
+    try {
+      new Function('"use strict"; new Foo(); class Foo {}')()
+      assert(false, '应抛出 ReferenceError')
+    } catch (e) {
+      assert(true, '类不提升，使用前必须先声明')
+    }
+  })
+
+  return getResults()
+}

package/src/features/es2015/07-promises.js

@@ -0,0 +1,79 @@
+import { createSuite } from '../../utils/runner.js'
+
+export async function testPromises() {
+  const { test, assert, getResults } = createSuite('Promise')
+
+  const tests = []
+
+  tests.push(test('基本 Promise resolve', () =>
+    new Promise((resolve) => resolve(42)).then((v) => assert(v === 42, 'resolve 值应为 42'))
+  ))
+
+  tests.push(test('基本 Promise reject', () =>
+    new Promise((_, reject) => reject(new Error('失败'))).catch((e) =>
+      assert(e.message === '失败', 'reject 应携带错误信息')
+    )
+  ))
+
+  tests.push(test('Promise 链式调用', () =>
+    Promise.resolve(1)
+      .then((v) => v + 1)
+      .then((v) => v * 3)
+      .then((v) => assert(v === 6, '链式调用结果应为 6'))
+  ))
+
+  tests.push(test('Promise.all - 全部成功', () =>
+    Promise.all([Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)]).then((values) =>
+      assert(values.join(',') === '1,2,3', 'Promise.all 应返回所有结果')
+    )
+  ))
+
+  tests.push(test('Promise.all - 一个失败则全部失败', () =>
+    Promise.all([Promise.resolve(1), Promise.reject(new Error('error')), Promise.resolve(3)])
+      .catch((e) => assert(e.message === 'error', 'Promise.all 中有失败应 reject'))
+  ))
+
+  tests.push(test('Promise.race - 返回最快的结果', () => {
+    const p1 = new Promise((r) => setTimeout(() => r('slow'), 100))
+    const p2 = Promise.resolve('fast')
+    return Promise.race([p1, p2]).then((v) => assert(v === 'fast', 'Promise.race 应返回最快完成的'))
+  }))
+
+  tests.push(test('Promise.allSettled - 全部结果', () =>
+    Promise.allSettled([Promise.resolve(1), Promise.reject('err')]).then((results) => {
+      assert(results[0].status === 'fulfilled', 'allSettled fulfilled')
+      assert(results[1].status === 'rejected', 'allSettled rejected')
+    })
+  ))
+
+  tests.push(test('Promise.any - 返回第一个成功', () =>
+    Promise.any([Promise.reject('e1'), Promise.resolve('ok'), Promise.resolve('ok2')]).then((v) =>
+      assert(v === 'ok', 'Promise.any 应返回第一个成功的值')
+    )
+  ))
+
+  tests.push(test('async/await 基本用法', async () => {
+    async function fetchData() {
+      const result = await Promise.resolve('data')
+      return result
+    }
+    const data = await fetchData()
+    assert(data === 'data', 'async/await 应正确获取异步结果')
+  }))
+
+  tests.push(test('async/await 错误处理', async () => {
+    async function failFn() {
+      throw new Error('async error')
+    }
+    try {
+      await failFn()
+      assert(false, '应抛出错误')
+    } catch (e) {
+      assert(e.message === 'async error', 'async/await 错误处理')
+    }
+  }))
+
+  await Promise.all(tests.filter(Boolean))
+
+  return getResults()
+}

package/src/features/es2015/08-symbols.js

@@ -0,0 +1,85 @@
+import { createSuite } from '../../utils/runner.js'
+
+export function testSymbols() {
+  const { test, assert, getResults } = createSuite('Symbol')
+
+  test('Symbol 唯一性', () => {
+    const s1 = Symbol('desc')
+    const s2 = Symbol('desc')
+    assert(s1 !== s2, '相同描述的 Symbol 不相等')
+  })
+
+  test('Symbol 描述属性', () => {
+    const s = Symbol('my-symbol')
+    assert(s.description === 'my-symbol', 'Symbol.description 应返回描述字符串')
+  })
+
+  test('Symbol 作为对象属性键', () => {
+    const key = Symbol('key')
+    const obj = { [key]: 'value' }
+    assert(obj[key] === 'value', 'Symbol 可作为对象属性键')
+  })
+
+  test('Symbol 属性不被普通枚举', () => {
+    const sym = Symbol('hidden')
+    const obj = { [sym]: 1, visible: 2 }
+    assert(!Object.keys(obj).includes(sym.toString()), 'Symbol 属性不出现在 Object.keys 中')
+    assert(Object.getOwnPropertySymbols(obj).length === 1, 'getOwnPropertySymbols 可获取 Symbol 属性')
+  })
+
+  test('Symbol.for 全局注册', () => {
+    const s1 = Symbol.for('shared')
+    const s2 = Symbol.for('shared')
+    assert(s1 === s2, 'Symbol.for 应返回同一个 Symbol')
+  })
+
+  test('Symbol.keyFor 获取注册键', () => {
+    const s = Symbol.for('test-key')
+    assert(Symbol.keyFor(s) === 'test-key', 'Symbol.keyFor 应返回注册键')
+    const local = Symbol('local')
+    assert(Symbol.keyFor(local) === undefined, '未注册的 Symbol 返回 undefined')
+  })
+
+  test('内置 Symbol - Symbol.iterator', () => {
+    class Range {
+      constructor(start, end) { this.start = start; this.end = end }
+      [Symbol.iterator]() {
+        let current = this.start
+        const end = this.end
+        return {
+          next() {
+            return current <= end
+              ? { value: current++, done: false }
+              : { done: true }
+          }
+        }
+      }
+    }
+    const result = [...new Range(1, 3)]
+    assert(result.join(',') === '1,2,3', 'Symbol.iterator 自定义迭代器')
+  })
+
+  test('内置 Symbol - Symbol.toPrimitive', () => {
+    const obj = {
+      [Symbol.toPrimitive](hint) {
+        if (hint === 'number') return 42
+        if (hint === 'string') return 'forty-two'
+        return true
+      }
+    }
+    assert(+obj === 42, 'Symbol.toPrimitive number')
+    assert(`${obj}` === 'forty-two', 'Symbol.toPrimitive string')
+  })
+
+  test('Symbol.hasInstance', () => {
+    class EvenNumber {
+      static [Symbol.hasInstance](num) {
+        return Number.isInteger(num) && num % 2 === 0
+      }
+    }
+    assert(2 instanceof EvenNumber, '2 应为 EvenNumber 实例')
+    assert(!(3 instanceof EvenNumber), '3 不应为 EvenNumber 实例')
+  })
+
+  return getResults()
+}