function outer(){
    const a = 1
    function f(){
        console.log(a)
    }
    f()
}
outer()//输出1

function outer(){
    let i = 1
    function fn(){
        console.log(i)
    }
    return fn
}
const fun = outer()
fun()//输出1
// 外层函数使用内部函数的变量

//简化写法
function outer(){
    let i = 1
    return function (){
        console.log(i)
    }
}
const fun = outer()
fun()

function fn(){
    count++
    console.log(`函数被调用${count}次`)
}
fn()//2
fn()//3

function fn(){
    let count=1
    return function (){
        count++
        console.log(`函数被调用${count}次`)
    }
}
fn()//2
fn()//3

foo()
function foo(){
    console.log('函数提升')
}
// 函数表达式不存在函数提升！
bear()
var bar = function(){
    console.log('函数提升')
}

function logParams() {
  console.log(arguments[0]); // 第一个参数
  console.log(arguments.length); // 传入参数的总数
}

logParams('A', 'B', 'C'); 
// 输出: 'A' , 3

function sum() {
  const args = Array.from(arguments); // 转换为真数组
  // 或 const args = [...arguments];
  return args.reduce((total, n) => total + n, 0);
}

function func(a, b, ...theArgs) {
  // theArgs 是一个数组，包含从第三个参数开始的所有实参
}

// 场景：计算商品总价（基本价 + 多项附加费）
function calculateTotal(basePrice, ...fees) {
  const totalFees = fees.reduce((acc, fee) => acc + fee, 0);
  return basePrice + totalFees;
}

console.log(calculateTotal(100, 10, 20, 5)); // 输出: 135
// basePrice = 100, fees = [10, 20, 5]

// 剩余参数（函数定义中，收集）
function sum(...numbers) {  // 这里的 ... 是“剩余参数”
  return numbers.reduce((a, b) => a + b);
}
sum(1, 2, 3); // numbers = [1, 2, 3]

// 展开运算符（函数调用中，打散）
const nums = [1, 2, 3];
sum(...nums); // 这里的 ... 是“展开运算符”，等价于 sum(1, 2, 3)

// 1. 零参数：必须写空括号
const greet = () => console.log('Hello');

// 2. 单参数：括号可选
const double = x => x * 2;

// 3. 多参数：必须加括号
const sum = (a, b) => a + b;

// 4. 函数体多行：必须加花括号，并显式 return
const process = (a, b) => {
  const result = a + b;
  return result * 2;
};

// 5. 返回对象字面量：必须用括号包裹，否则会和函数体花括号混淆
const createUser = name => ({ name: name, age: 18 });

const add = (a, b) => a + b; // 自动返回 a + b

// 相当于传统写法：
function add(a, b) { return a + b; }

const getSum = (...args)=>{
    let sum=0
    for(let i=0;i<args.length;i++){
        sum += args[i]
    }
    return sum
}
console.log(getSum(1,2,3))

const obj = {
  name: '前端文档',
  // 普通函数：this 指向 obj
  normalFunc: function() {
    console.log(this.name); 
  },
  // 箭头函数：this 指向全局（严格模式下为 undefined）或外层 this
  arrowFunc: () => {
    console.log(this.name); 
  }
};

obj.normalFunc(); // 输出: '前端文档'
obj.arrowFunc();  // 输出: undefined （因为定义时外层是全局对象）

// 普通函数在 setTimeout 中丢失 this（指向 window）
const obj = {
  name: '张三',
  sayLater: function() {
    setTimeout(function() {
      console.log(this.name); // undefined（this 指向 window）
    }, 1000);
  }
};

// 箭头函数修复（捕获外层 this）
const obj2 = {
  name: '张三',
  sayLater: function() {
    setTimeout(() => {
      console.log(this.name); // '张三'（箭头函数捕获了外层的 this）
    }, 1000);
  }
};

const colors = ['红', '绿', '蓝'];

// 传统写法
// const red = colors[0];
// const green = colors[1];

// 解构写法
const [red, green, blue] = colors;
console.log(red);   // '红'
console.log(green); // '绿'
console.log(blue);  // '蓝'

const [, , third] = ['A', 'B', 'C'];
console.log(third); // 'C'（跳过前两个）

const [first, ...rest] = [10, 20, 30, 40];
console.log(first); // 10
console.log(rest);  // [20, 30, 40]

const [a = 1, b = 2] = [100];
console.log(a); // 100（覆盖默认值）
console.log(b); // 2（使用默认值）

let x = 1, y = 2;
[x, y] = [y, x];
console.log(x, y); // 2 1

const user = { name: '张三', age: 25, city: '杭州' };

const { name, age } = user;
console.log(name); // '张三'
console.log(age);  // 25

const { name: userName, age: userAge } = user;
console.log(userName); // '张三'
console.log(userAge);  // 25

const { gender = '未知', city } = user;
console.log(gender); // '未知'（原对象中没有 gender）
console.log(city);   // '杭州'

const { country: userCountry = '中国' } = user;
console.log(userCountry); // '中国'

const person = {
  name: '李四',
  address: {
    province: '浙江',
    city: '杭州'
  }
};

const { address: { city } } = person;
console.log(city); // '杭州'

const str ='abc'
console.log(str.length)//3

const user = new Object({name:"张三",age:13})

const arr = new Array(3,5)
console.log(arr)// [3,5]

// ------------forEach 代码示例-------------
const nums = [1, 2, 3, 4, 5];

// forEach  打印每个元素
nums.forEach(item => {
  console.log(item); // 输出 1 2 3 4 5
});

// -------------filter代码示例--------------
const scores = [85, 92, 78, 66, 95, 88];

// 场景1：筛选及格（>=60）的成绩
const passed = scores.filter(score => score >= 60);
console.log(passed); // [85, 92, 78, 66, 95, 88] （全及格）

// 场景3：筛选数组中的对象
const users = [
  { name: '小明', age: 18 },
  { name: '小红', age: 25 },
  { name: '小刚', age: 16 }
];
const adults = users.filter(user => user.age >= 18);
console.log(adults); 
// [{ name: '小明', age: 18 }, { name: '小红', age: 25 }]

// 场景4：去重（配合 indexOf）
const arr = [1, 2, 2, 3, 3, 4];
const unique = arr.filter((item, index) => arr.indexOf(item) === index);
console.log(unique); // [1, 2, 3, 4]
//-----------map代码示例------------
const nums = [1, 2, 3, 4, 5];

// 场景1：每个元素乘以2
const doubled = nums.map(item => item * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

// 场景2：提取对象数组中的某个字段（最常用！）
const users = [
  { id: 1, name: '小明' },
  { id: 2, name: '小红' },
  { id: 3, name: '小刚' }
];
const names = users.map(user => user.name);
console.log(names); // ['小明', '小红', '小刚']

// 场景3：添加新字段
const usersWithAge = users.map(user => ({
  ...user,
  age: 18 // 给每个人加个年龄字段
}));
console.log(usersWithAge);
// [{ id: 1, name: '小明', age: 18 }, ...]

// 场景4：格式化数据（转字符串）
const prices = [100, 200, 300];
const formatted = prices.map(price => `¥${price}.00`);
console.log(formatted); // ['¥100.00', '¥200.00', '¥300.00']


//------------reduce------------------
const nums = [1, 2, 3, 4, 5];

// 场景1：求和（最经典）
const sum = nums.reduce((acc, cur) => acc + cur, 0);
console.log(sum); // 15

// 场景2：求乘积
const product = nums.reduce((acc, cur) => acc * cur, 1);
console.log(product); // 120

// 场景3：求最大值
const max = nums.reduce((acc, cur) => acc > cur ? acc : cur);
console.log(max); // 5

// 场景4：统计数组中每个元素出现次数（面试常考）
const fruits = ['苹果', '香蕉', '苹果', '橙子', '香蕉', '香蕉'];
const count = fruits.reduce((acc, cur) => {
  acc[cur] = (acc[cur] || 0) + 1;
  return acc;
}, {});
console.log(count); // { 苹果: 2, 香蕉: 3, 橙子: 1 }

// 场景5：数组扁平化（将二维数组转一维）
const nested = [[1, 2], [3, 4], [5, 6]];
const flat = nested.reduce((acc, cur) => acc.concat(cur), []);
console.log(flat); // [1, 2, 3, 4, 5, 6]

// 场景6：求和对象数组中某个字段的总价
const cart = [
  { name: '苹果', price: 5, count: 3 },
  { name: '香蕉', price: 3, count: 5 },
  { name: '橙子', price: 4, count: 2 }
];
const total = cart.reduce((acc, cur) => acc + cur.price * cur.count, 0);
console.log(total); // 15 + 15 + 8 = 38

const str = 'hello';
console.log(typeof str); // 'string'
console.log(str.toUpperCase()); // 'HELLO'（自动装箱）

const str = 'Hello, World! Hello, JS!';

console.log(str.indexOf('Hello'));     // 0（第一次出现）
console.log(str.lastIndexOf('Hello')); // 14（最后一次出现）
console.log(str.indexOf('Python'));    // -1（不存在）

console.log(str.includes('World'));    // true
console.log(str.startsWith('Hello'));  // true
console.log(str.endsWith('JS!'));      // true

// 带起始位置的查找
console.log(str.indexOf('Hello', 5));  // 14（从索引5开始找）

const str = 'JavaScript';

console.log(str.slice(0, 4));     // 'Java'（从0到4，不包括4）
console.log(str.slice(4));        // 'Script'（从4到末尾）
console.log(str.slice(-6));       // 'Script'（从倒数第6个开始）
console.log(str.slice(-6, -1));   // 'Scrip'（从倒数第6到倒数第1）

console.log(str.substring(0, 4)); // 'Java'
console.log(str.substring(-3));   // 'JavaScript'（负数当0处理）

// ❌ substr 已废弃，别用了
// console.log(str.substr(4, 6)); // 'Script'

// split：字符串 → 数组
const str = 'apple,banana,orange';
const fruits = str.split(',');
console.log(fruits); // ['apple', 'banana', 'orange']

// 不带分隔符：拆成每个字符
console.log('hello'.split('')); // ['h', 'e', 'l', 'l', 'o']

// 限制拆分次数
console.log('a-b-c-d'.split('-', 2)); // ['a', 'b']

// 配合 join：数组 → 字符串（复习一下）
const arr = ['2024', '08', '11'];
console.log(arr.join('-')); // '2024-08-11'

const str = 'Hello World';

console.log(str.toUpperCase()); // 'HELLO WORLD'
console.log(str.toLowerCase()); // 'hello world'

// 常见场景：不区分大小写比较
const userInput = 'Admin';
if (userInput.toLowerCase() === 'admin') {
  console.log('欢迎管理员'); // 匹配成功
}

const str = '   Hello World   ';

console.log(str.trim());        // 'Hello World'
console.log(str.trimStart());   // 'Hello World   '
console.log(str.trimEnd());     // '   Hello World'

// 常见场景：用户输入清洗
const username = '  张三  ';
console.log(username.trim()); // '张三'

// replace / replaceAll
const str = 'Hello Hello Hello';
console.log(str.replace('Hello', 'Hi'));      // 'Hi Hello Hello'（只替换第一个）
console.log(str.replaceAll('Hello', 'Hi'));   // 'Hi Hi Hi'（全部替换）

// 正则替换（更强大）
console.log(str.replace(/Hello/g, 'Hi'));     // 'Hi Hi Hi'

// padStart / padEnd（补位）
console.log('5'.padStart(3, '0'));   // '005'（常见于日期格式化）
console.log('5'.padEnd(3, '0'));     // '500'
console.log('2024'.padStart(10, '-')); // '------2024'

// repeat
console.log('*'.repeat(5)); // '*****'
console.log('abc'.repeat(3)); // 'abcabcabc'

const str = 'JavaScript';

console.log(str.length); // 10
console.log(str.charAt(4)); // 'S'（从0开始数）
console.log(str[4]); // 'S'（ES5 支持，更常用）
console.log(str.concat(' is', ' awesome')); // 'JavaScript is awesome'

// match（配合正则）
console.log('abc123def'.match(/\d+/)); // ['123']

let str = 'hello';
str.toUpperCase(); // 返回 'HELLO'
console.log(str);  // 还是 'hello'（原串没变）

// 必须重新赋值
str = str.toUpperCase();
console.log(str); // 'HELLO'

// 字符串 → 数组
const str = 'hello';
const arr = str.split(''); // ['h','e','l','l','o']

// 数组 → 字符串
const newStr = arr.join(''); // 'hello'

// 逆序字符串（面试常考）
const reversed = str.split('').reverse().join('');
console.log(reversed); // 'olleh'

function getExtension(filename) {
  return filename.slice(filename.lastIndexOf('.') + 1);
}

console.log(getExtension('photo.jpg')); // 'jpg'
console.log(getExtension('archive.tar.gz')); // 'gz'

const num = 42;
console.log(typeof num); // 'number'
console.log(num.toFixed(2)); // '42.00'（自动装箱）

// 强制转换
console.log(Number('123'));     // 123
console.log(Number('123abc'));  // NaN（不能完全转换）
console.log(Number(true));      // 1
console.log(Number(null));      // 0
console.log(Number(undefined)); // NaN

// parseInt / parseFloat（更宽容）
console.log(parseInt('123abc'));   // 123（只解析数字部分）
console.log(parseInt('123.45'));   // 123
console.log(parseFloat('123.45')); // 123.45
console.log(parseInt('0x10'));     // 16（十六进制）
console.log(parseInt('10', 2));    // 2（指定二进制）

// 判断
console.log(isNaN(NaN));            // true
console.log(isNaN('abc'));          // true（'abc' 转数字是 NaN）
console.log(Number.isNaN('abc'));   // false（更严格，不先转换）
console.log(Number.isInteger(42));  // true
console.log(Number.isInteger(42.0));// true
console.log(Number.isInteger(42.5));// false

// 特殊值
console.log(Number.MAX_VALUE);  // 1.7976931348623157e+308（最大数）
console.log(Number.MIN_VALUE);  // 5e-324（最小正数）
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991（安全整数上限）
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

const num = 123.456789;

// toFixed：保留小数位数（最常用）
console.log(num.toFixed(2));   // '123.46'（四舍五入）
console.log(num.toFixed(0));   // '123'
console.log((123).toFixed(2)); // '123.00'（补零）

// 金额格式化常用
const price = 9.9;
console.log(`¥${price.toFixed(2)}`); // '¥9.90'

// toPrecision：保留有效数字
console.log(num.toPrecision(4)); // '123.5'
console.log(num.toPrecision(2)); // '1.2e+2'（不够位数用科学计数法）

// toString：进制转换
console.log((255).toString(16)); // 'ff'（转十六进制）
console.log((255).toString(2));  // '11111111'（转二进制）
console.log((255).toString(8));  // '377'（转八进制）

// Math 常用方法
console.log(Math.round(4.7));   // 5（四舍五入取整）
console.log(Math.floor(4.7));   // 4（向下取整）
console.log(Math.ceil(4.1));    // 5（向上取整）
console.log(Math.trunc(4.7));   // 4（去除小数部分，ES6）

console.log(Math.max(1, 3, 2)); // 3（最大值）
console.log(Math.min(1, 3, 2)); // 1（最小值）
console.log(Math.random());     // 0~1 之间的随机数

console.log(Math.pow(2, 3));    // 8（2 的 3 次方）
console.log(Math.sqrt(16));     // 4（平方根）
console.log(Math.abs(-5));      // 5（绝对值）

// 随机整数公式（牢记）
function getRandomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandomInt(1, 10)); // 1~10 随机整数

console.log(0.1 + 0.2);        // 0.30000000000000004 ❌
console.log(0.1 + 0.2 === 0.3); // false ❌

// 解决方案 1：使用 toFixed 后比较
console.log(Number((0.1 + 0.2).toFixed(10)) === 0.3); // true

// 解决方案 2：转为整数计算（金额常用）
function add(a, b) {
  const factor = Math.pow(10, 10);
  return (a * factor + b * factor) / factor;
}
console.log(add(0.1, 0.2)); // 0.3

// 解决方案 3：使用第三方库（如 decimal.js、big.js）

// 全局 isNaN 会先转换再判断
console.log(isNaN('abc'));   // true（'abc' → NaN）
console.log(isNaN(undefined)); // true
console.log(isNaN({}));      // true（{} → NaN）

// Number.isNaN 更严格：只有值是 NaN 才返回 true
console.log(Number.isNaN('abc'));   // false
console.log(Number.isNaN(undefined)); // false
console.log(Number.isNaN(NaN));     // true

// ✅ 推荐使用 Number.isNaN

// 旧版浏览器中，parseInt('08') 会被解析为八进制 → 0
// 现代浏览器已修复，但仍建议指定进制
console.log(parseInt('08'));      // 8
console.log(parseInt('08', 10));  // 8 ✅ 明确指定十进制

// 更好的做法：用 Number 或 + 运算符
console.log(Number('08'));   // 8
console.log(+'08');          // 8

// 超过安全范围会丢失精度
console.log(9007199254740992 + 1 === 9007199254740992); // true ❌

// 使用 BigInt 处理大数
const big1 = 9007199254740992n;
const big2 = 1n;
console.log(big1 + big2); // 9007199254740993n ✅

function formatMoney(amount) {
  return '¥' + amount.toFixed(2).replace(/\B(?=(\d{3})+(?!\d))/g, ',');
}

console.log(formatMoney(1234567.89)); // '¥1,234,567.89'
console.log(formatMoney(9.9));        // '¥9.90'

function generateCode(length = 6) {
  let code = '';
  for (let i = 0; i < length; i++) {
    code += Math.floor(Math.random() * 10);
  }
  return code;
}
console.log(generateCode()); // '847291'

function padZero(num) {
  return String(num).padStart(2, '0');
}

const year = 2024;
const month = 8;
const day = 5;
console.log(`${year}-${padZero(month)}-${padZero(day)}`); // '2024-08-05'

function isNumeric(value) {
  return !isNaN(parseFloat(value)) && isFinite(value);
}

console.log(isNumeric('123'));   // true
console.log(isNumeric('12.3'));  // true
console.log(isNumeric('abc'));   // false
console.log(isNumeric(''));      // false
console.log(isNumeric(null));    // false

function getPercentage(part, total) {
  if (total === 0) return '0%';
  return ((part / total) * 100).toFixed(2) + '%';
}

console.log(getPercentage(35, 200)); // '17.50%'
console.log(getPercentage(0, 200));  // '0.00%'
console.log(getPercentage(100, 0));  // '0%'（防止除以0）

function Person(name) {
  this.name = name;
}

console.log(typeof Person.prototype); // 'object'
console.log(Person.prototype); 
// 打印出来：{ constructor: f Person(), __proto__: Object }

function Person(name) {
  this.name = name;
}

console.log(Person.prototype.constructor === Person); // true

const p = new Person('张三');
console.log(p.constructor === Person); // true
// 注意：p本身没有constructor，它是顺着原型链找到的 Person.prototype.constructor

function Person(name) { this.name = name; }
const p = new Person('张三');

console.log(p.__proto__ === Person.prototype); // true

function Person(name) {
  this.name = name;
}
Person.prototype.sayHi = function() {
  console.log('Hi ' + this.name);
};

function Student(name, grade) {
  Person.call(this, name); // 借用构造函数，继承实例属性
  this.grade = grade;
}

// 核心继承步骤：让 Student.prototype 的原型指向 Person.prototype
Student.prototype = Object.create(Person.prototype);
// 修复 constructor，因为上面一行把原来的 constructor 覆盖了
Student.prototype.constructor = Student; 

const stu = new Student('李四', 3);
stu.sayHi(); // 'Hi 李四' （成功继承到了）

console.log(stu.__proto__ === Student.prototype);                  // true
console.log(Student.prototype.__proto__ === Person.prototype);     // true
console.log(Person.prototype.__proto__ === Object.prototype);      // true
console.log(Object.prototype.__proto__);                           // null

// 以前的写法（基于 prototype）
function Person(name) {
  this.name = name;
}
Person.prototype.sayHi = function() { console.log('Hi'); };

// ES6 Class 写法（底层依然是原型）
class Person {
  constructor(name) {
    this.name = name;
  }
  sayHi() {  // 这个方法会自动挂载到 Person.prototype 上
    console.log('Hi');
  }
}

// 继承也变得更优雅（extends + super）
class Student extends Person {
  constructor(name, grade) {
    super(name); // 相当于 Person.call(this, name)
    this.grade = grade;
  }
}

const original = {
  name: '张三',
  age: 18,
  address: {
    city: '北京',
    district: '海淀'
  }
};

// 方法1：扩展运算符（最常用）
const copy1 = { ...original };

// 方法2：Object.assign()
const copy2 = Object.assign({}, original);

// 方法3：数组的 slice()
const arr = [1, 2, [3, 4]];
const copyArr = arr.slice();

copy1.name = '李四';        // 修改第一层基本类型
console.log(original.name); // '张三'（没变，因为是独立副本）

copy1.address.city = '上海'; // 修改第二层引用类型的属性
console.log(original.address.city); // '上海'（变了！因为 address 指向同一个对象）

const deepCopy = JSON.parse(JSON.stringify(original));
deepCopy.address.city = '上海';
console.log(original.address.city); // '北京'（没变！完全独立）

const obj = {
  func: function() { console.log('hi'); },
  date: new Date(),
  undef: undefined
};
const copy = JSON.parse(JSON.stringify(obj));
console.log(copy); // { date: '2024-...' } （func 和 undef 丢了）

function deepClone(obj, hash = new WeakMap()) {
  // 处理 null 和基本类型
  if (obj === null || typeof obj !== 'object') return obj;
  
  // 处理循环引用
  if (hash.has(obj)) return hash.get(obj);
  
  // 处理数组和对象
  const clone = Array.isArray(obj) ? [] : {};
  hash.set(obj, clone);
  
  // 递归拷贝所有属性
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      clone[key] = deepClone(obj[key], hash);
    }
  }
  return clone;
}

// lodash 的 cloneDeep
import _ from 'lodash';
const deepCopy = _.cloneDeep(original);

// 或者用 structuredClone（现代浏览器原生支持）
const deepCopy = structuredClone(original);

try {
  // 可能抛出错误的代码
  let data = JSON.parse('{ invalid }');
} catch (error) {
  // 捕获并处理错误
  console.error('出错了:', error.message);
} finally {
  // 无论是否出错，都会执行（如关闭连接、清理状态）
  console.log('清理工作完成');
}

function divide(a, b) {
  if (b === 0) {
    // 抛出错误对象，包含自定义信息
    throw new Error('除数不能为0');
  }
  return a / b;
}

class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = 'ValidationError';
    this.field = field; // 自定义属性
  }
}

// 使用
try {
  throw new ValidationError('邮箱格式无效', 'email');
} catch (err) {
  if (err instanceof ValidationError) {
    console.log(`字段 ${err.field} 校验失败`);
  }
}

function show() {
  console.log(this.name);
}

const person = { name: '小明', show: show };
const admin = { name: '管理员', show: show };

person.show(); // 输出 '小明' (person 调用了 show)
admin.show();  // 输出 '管理员' (admin 调用了 show)

const standalone = show;
standalone();  // 浏览器输出 '' (window.name)，Node 输出 undefined (全局对象没有 name)

```js

function introduce(age, city) {
  console.log(`我叫${this.name}，${age}岁，来自${city}`);
}

const person = { name: '张三' };

// 让 introduce 函数中的 this 指向 person
introduce.call(person, 25, '杭州'); 
// 输出：我叫张三，25岁，来自杭州
```

**使用场景**：借用一个对象的方法，参数不多且明确。

和 `call` 完全一样，只是第二个参数必须是数组（或类数组）。

```js
const person = { name: '李四' };
const args = [30, '北京'];

introduce.apply(person, args);
// 输出：我叫李四，30岁，来自北京
```

**经典使用场景**：配合 Math 求数组最大/最小值

```js
const numbers = [3, 8, 1, 10];
// 原本 Math.max 不支持数组，用 apply 可以把数组拆成参数
const max = Math.max.apply(null, numbers); 
console.log(max); // 10

// 现在更推荐用展开运算符：Math.max(...numbers)
```

const obj = {
  name: '箭头示例',
  // 箭头函数中的 this 指向定义时的外层（此处为全局）
  greet: () => console.log(this.name) 
};
obj.greet(); // 浏览器输出 '' (window.name)，不是 '箭头示例'

// 典型正确用法：在对象方法内部返回箭头函数
const obj2 = {
  name: '正确用法',
  getName: function() {
    // 箭头函数捕获了外层 getName 的 this (即 obj2)
    return () => console.log(this.name);
  }
};
obj2.getName()(); // 输出 '正确用法'

function debounce(fn, delay) {
  let timer = null;
  
  return function(...args) {
    // 每次触发都清除之前的定时器
    clearTimeout(timer);
    
    // 重新设置定时器
    timer = setTimeout(() => {
      fn.apply(this, args); // 注意这里的 this 和参数传递
    }, delay);
  };
}

// 原始的搜索函数
function search(keyword) {
  console.log(`搜索: ${keyword}`);
}

// 创建防抖版本（延迟 500ms）
const debouncedSearch = debounce(search, 500);

// 连续输入时，只有停止输入 500ms 后才会执行
debouncedSearch('a');
debouncedSearch('ab');
debouncedSearch('abc'); // 最终只会执行 'abc' 的搜索

function throttle(fn, interval) {
  let lastTime = 0;
  
  return function(...args) {
    const now = Date.now();
    const context = this;
    
    // 如果距离上次执行超过间隔时间，立即执行
    if (now - lastTime >= interval) {
      fn.apply(context, args);
      lastTime = now;
    }
  };
}

function handleScroll() {
  console.log('滚动位置:', window.scrollY);
}

// 每 200ms 最多执行一次
const throttledScroll = throttle(handleScroll, 200);
window.addEventListener('scroll', throttledScroll);