// 转数字
Number('123') // 123
Number('abc') // NaN
parseInt('123px') // 123
parseFloat('3.14em') // 3.14

// 转字符串
String(123) // '123'
(123).toString() // '123'

// 转布尔值
Boolean(0) // false
Boolean('abc') // true

// 短路特性
true && 10 && 'abc' // 'abc'
0 || false || 20 // 20

// 空值合并与逻辑或的区别
0 ?? 100 // 0（0不是null/undefined，返回左侧）
0 || 100 // 100（0是falsy值，返回右侧）

// 可选链
const obj = { user: { name: '张三' } };
obj.user?.age?.num // undefined，不会报错
obj?.address?.city // undefined

// 单分支
if (score >= 60) {
  console.log('及格');
}

// 双分支
if (score >= 60) {
  console.log('及格');
} else {
  console.log('不及格');
}

// 多分支
if (score >= 90) {
  console.log('优秀');
} else if (score >= 60) {
  console.log('及格');
} else {
  console.log('不及格');
}

let day = 1;
switch (day) {
  case 1:
    console.log('星期一');
    break; // 终止执行，避免穿透
  case 2:
    console.log('星期二');
    break;
  default: // 所有case都不匹配时执行
    console.log('其他');
}

// 1. 实现私有变量
function createCounter() {
  let count = 0; // 私有变量，外部无法直接访问
  return {
    increment: () => ++count,
    decrement: () => --count,
    getCount: () => count
  };
}
const counter = createCounter();
counter.increment(); // 1
counter.getCount(); // 1

// 2. 函数柯里化
function add(a) {
  return function(b) {
    return a + b;
  };
}
const add5 = add(5);
add5(3); // 8

// 1. 全局调用
function fn() {
  console.log(this);
}
fn(); // 非严格模式：window

// 2. 对象方法调用
const obj = {
  name: '张三',
  sayName() {
    console.log(this.name);
  }
};
obj.sayName(); // 张三，this指向obj

// 3. 构造函数
function User(name) {
  this.name = name; // this指向新创建的实例
}
const user = new User('李四');
console.log(user.name); // 李四

// 4. call/apply/bind 修改this
function sayHi() {
  console.log(`你好，${this.name}`);
}
const user1 = { name: '王五' };
sayHi.call(user1); // 你好，王五，call立即执行，参数逐个传递
sayHi.apply(user1); // 你好，王五，apply立即执行，参数以数组传递
const bindFn = sayHi.bind(user1); // bind返回新函数，不会立即执行
bindFn(); // 你好，王五

// 5. 箭头函数的this
const obj2 = {
  name: '赵六',
  sayName: () => {
    console.log(this.name); // 继承外层this，此处为window
  }
};
obj2.sayName(); // 空（window无name属性）

// 1. 字面量方式（最常用）
const user = {
  name: '张三',
  age: 20,
  sayHi() {
    console.log(`你好，我是${this.name}`);
  }
};

// 2. new Object() 构造函数
const obj = new Object();
obj.name = '李四';

// 3. Object.create()：基于指定原型创建对象
const proto = { gender: '男' };
const obj2 = Object.create(proto);
console.log(obj2.gender); // 男，继承自proto

const user = { name: '张三', age: 20 };

// 1. 属性访问
console.log(user.name); // 点语法，属性名必须是合法标识符
console.log(user['age']); // 方括号语法，支持变量、特殊字符、动态属性名

// 2. 属性添加/修改
user.gender = '男'; // 添加
user.age = 21; // 修改

// 3. 属性删除
delete user.age;

const user = {
  _name: '张三',
  get name() {
    console.log('读取属性');
    return this._name;
  },
  set name(newVal) {
    console.log('修改属性');
    this._name = newVal;
  }
};
user.name; // 触发get，返回'张三'
user.name = '李四'; // 触发set，修改_name

// 构造函数
function User(name) {
  this.name = name;
}
// 原型上添加方法，所有实例共享
User.prototype.sayName = function() {
  console.log(this.name);
};

// 创建实例
const user1 = new User('张三');
user1.sayName(); // 张三

// 原型链验证
console.log(user1.__proto__ === User.prototype); // true
console.log(User.prototype.__proto__ === Object.prototype); // true
console.log(Object.prototype.__proto__ === null); // true

class User {
  // 构造方法，new实例时自动调用
  constructor(name, age) {
    this.name = name; // 实例属性
    this.age = age;
  }

  // 实例方法，挂载到类的prototype上
  sayHi() {
    console.log(`你好，我是${this.name}，今年${this.age}岁`);
  }

  // 静态方法，通过类本身调用，不能通过实例调用
  static sayHello() {
    console.log('Hello');
  }

  // 访问器属性
  get userInfo() {
    return `姓名：${this.name}，年龄：${this.age}`;
  }

  set userInfo(newVal) {
    const [name, age] = newVal.split(',');
    this.name = name;
    this.age = age;
  }
}

// 创建实例
const user1 = new User('张三', 20);
user1.sayHi(); // 你好，我是张三，今年20岁
User.sayHello(); // Hello，静态方法调用
console.log(user1.userInfo); // 触发get
user1.userInfo = '李四,21'; // 触发set

// 父类
class Person {
  constructor(name) {
    this.name = name;
  }
  sayName() {
    console.log(this.name);
  }
}

// 子类继承父类
class Student extends Person {
  constructor(name, grade) {
    super(name); // 必须先调用super，才能使用this
    this.grade = grade;
  }

  // 重写父类方法
  sayName() {
    super.sayName(); // 调用父类方法
    console.log(`我是${this.grade}年级的学生`);
  }
}

const student = new Student('王五', 3);
student.sayName(); // 王五  我是3年级的学生

const [a, b, c] = [1, 2, 3];
console.log(a); // 1
console.log(b); // 2

// 剩余参数
const [d, ...rest] = [1, 2, 3, 4];
console.log(rest); // [2,3,4]

// 默认值
const [e, f = 10] = [5];
console.log(f); // 10

// 创建Promise实例
const promise = new Promise((resolve, reject) => {
  // 异步操作
  setTimeout(() => {
    const isSuccess = true;
    if (isSuccess) {
      resolve('操作成功'); // 成功，状态改为fulfilled，触发then
    } else {
      reject('操作失败'); // 失败，状态改为rejected，触发catch
    }
  }, 1000);
});

// 链式调用
promise
  .then(res => {
    console.log(res); // 操作成功
    return '下一步处理';
  })
  .then(res => {
    console.log(res); // 下一步处理
  })
  .catch(err => {
    console.error(err); // 捕获错误
  })
  .finally(() => {
    console.log('无论成功失败都会执行');
  });

// 基础用法
// 封装异步函数
function getData() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('请求成功的数据');
    }, 1000);
  });
}

// async/await 调用
async function fetchData() {
  try {
    console.log('开始请求');
    const res = await getData(); // 等待异步完成
    console.log(res); // 请求成功的数据
    console.log('请求结束');
  } catch (err) {
    console.error('请求失败', err);
  }
}

fetchData();

// 模块文件：user.js
// 导出方式1：声明时导出
export const name = '张三';
export function sayHi() {
  console.log('你好');
}

// 导出方式2：统一导出
const age = 20;
const getAge = () => age;
export { age, getAge };

// 导入文件：index.js
// 方式1：按需导入
import { name, sayHi, age } from './user.js';
console.log(name); // 张三
sayHi();

// 方式2：整体导入，别名接收
import * as user from './user.js';
console.log(user.age); // 20
user.sayHi();

// 方式3：导入时重命名
import { name as userName } from './user.js';
console.log(userName); // 张三

// 导出：module.js
const name = '张三';
function sayHi() {
  console.log('你好');
}
module.exports = { name, sayHi };

// 导入：index.js
const { name, sayHi } = require('./module.js');
console.log(name);
sayHi();

try {
  // 可能出错的代码
  const num = 10;
  num.toUpperCase(); // 数字没有toUpperCase方法，会抛出错误
  console.log('不会执行，出错后直接跳转到catch');
} catch (err) {
  // 捕获错误，处理异常
  console.error('发生错误：', err.message);
} finally {
  // 无论成功失败都会执行，常用于释放资源
  console.log('执行完毕');
}

function checkAge(age) {
  if (typeof age !== 'number') {
    // 主动抛出错误
    throw new TypeError('年龄必须是数字');
  }
  if (age < 18) {
    throw new Error('年龄必须满18岁');
  }
  console.log('年龄合法');
}

try {
  checkAge(16);
} catch (err) {
  console.error(err.message); // 年龄必须满18岁
}

// 常用常量
Math.PI // 圆周率3.1415926...
Math.E // 自然常数e

// 常用方法
Math.abs(-10) // 10，绝对值
Math.floor(3.9) // 3，向下取整
Math.ceil(3.1) // 4，向上取整
Math.round(3.5) // 4，四舍五入
Math.max(1, 5, 3) // 5，最大值
Math.min(1, 5, 3) // 1，最小值
Math.random() // 0-1之间的随机数（不含1）
Math.pow(2, 3) // 8，幂运算
Math.sqrt(9) // 3，平方根

// 创建日期对象
const now = new Date(); // 当前时间
const targetDate = new Date('2025-01-01'); // 指定日期
const customDate = new Date(2025, 0, 1); // 年、月(0-11)、日

// 常用获取方法
now.getFullYear(); // 4位年份
now.getMonth(); // 月份(0-11)
now.getDate(); // 日期(1-31)
now.getDay(); // 星期(0-6，0代表周日)
now.getHours(); // 小时(0-23)
now.getMinutes(); // 分钟(0-59)
now.getSeconds(); // 秒(0-59)
now.getTime(); // 时间戳，1970-01-01至今的毫秒数

// 常用设置方法
now.setFullYear(2026); // 设置年份
now.setMonth(11); // 设置月份
now.setDate(25); // 设置日期

// 创建正则对象
// 方式1：字面量（常用）
const reg1 = /^\d{6}$/g; // 匹配6位数字，g为全局修饰符
// 方式2：构造函数
const reg2 = new RegExp('^\\d{6}$', 'g');

// 常用修饰符
// g：全局匹配，i：忽略大小写，m：多行匹配，s：允许.匹配换行符

// 正则实例方法
reg1.test('123456'); // true，检测字符串是否匹配正则
reg1.exec('123456'); // 返回匹配结果数组，匹配不到返回null

// 字符串的正则方法
'abc123def456'.match(/\d+/g); // ['123','456']，匹配所有符合规则的内容
'abc123'.replace(/\d+/, '***'); // 'abc***'，替换匹配内容
'abc123'.search(/\d+/); // 3，返回第一个匹配的索引，匹配不到返回-1
'a,b,c,d'.split(/,/); // ['a','b','c','d']，按正则分割字符串