JavaScript进阶学习

// 传统函数
const sum = function(a, b) { return a + b };

// 箭头函数简写
const sum = (a, b) => a + b;

let name = '张三';
let strall = `姓名为：${name}`;

const sum = (a, b) => a + b;
let strsum = `12 + 32 为：${sum(12,32)}`;

let item = {"name": "张三", "age": 15, "sex": "男"};
let str = `姓名：${item.name}，年龄${item.age}，性别：${item.sex}`;

let name = '张三';
str.startsWith('张'); // true
str.endsWith('三'); // true

let str = 'Hello';
str.repeat(3); // 'HelloHelloHello'

const arr = [1, 2];
arr.push(3);      // arr → [1, 2, 3]
arr.pop();        // arr → [1, 2]
arr.unshift(0);   // arr → [0, 1, 2]
arr.shift();      // arr → [1, 2]

const a = [1, 2];
const b = a.concat(3, [4, 5]);  // b → [1, 2, 3, 4, 5]

const str = a.join("-");        // str → "1-2"

const c = [10, 20, 30, 40];
const sub = c.slice(1, 3);      // sub → [20, 30]

c.splice(1, 2, 99);             // c → [10, 99, 40]

const map = new Map();
map.set("age", 18).set(100, "分数"); // 链式调用

console.log(map.get("age")); // 18
console.log(map.has("gender")); // false
console.log(map.size); // 2

const map = new Map([
  ["a", 1],
  ["b", 2],
  ["c", 3]
]);

// 遍历键值对
map.forEach((value, key) => {
  console.log(key, value); // a 1, b 2, c 3
});

// 使用 for...of
for (const [key, value] of map) {
  console.log(key, value); // 同上
}

// 获取迭代器
console.log([...map.keys()]); // ["a", "b", "c"]
console.log([...map.values()]); // [1, 2, 3]

let [a,b,c] = [11,22,33];

const arr1 = [1, 2, 3];
const arr2 = [3, 4, 5];
[...arr1, ...arr2]; // [1, 2, 3, 3, 4, 5]

let [arr3, ...rest] = [1, 2, 3, 4, 5];
arr3; // 1
rest; // [2, 3, 4, 5]

function sum(arg1, ...args) {
  console.log(arg1, args);
}
sum(1, 2, 3, 4, 5); // 1, [2, 3, 4, 5]

const originalArray = ["姓名","语文","班级","考号","总分","数学","物理","道法","道德","科学"];
// 使用正则表达式匹配 "语、数、英、道"
const result = originalArray.filter(str => /[语数英道理历生化]/.test(str));
console.log(result); // 把学科字段匹配出来

const users = [{name: 'Alice',age: 25}, {name: 'Blind',age: 25}, {name: 'Bob',age: 30}];
const user = users.find(user => user.age === 25); // {name: 'Alice'}

const users = [{name: 'Alice',age: 25}, {name: 'Blind',age: 27}, {name: 'Bob',age: 30}];;
const userIndex = users.findIndex(user => user.age > 28); //2

[1,2,3,4,5,6,7].includes(1); // true
[1,2,3,4,5,6,7].includes(10); // false

"hello".includes("el"); // true

let arr = [1, 2, 3, 4, 5];
let sum = arr.reduce(function (prev, cur, index, arr) {
    console.log(prev, cur, index);
    return prev + cur;
});
console.log('arr:', arr, 'sum:', sum); //sum=15

// 数组对象
const arr = [
    {id: 'a', value: 1},
    {id: 'b', value: 2},
    {id: 'c', value: 3}
];
// item是arr遍历出来的值
arr.reduce((sum, item) => {
    console.log(sum, item);
    return sum + item.value * 2; //返回给下一个your的值
},0); //给sum的初始值

// Array.some() 极简使用笔记
// 核心功能​​：判断数组中 ​​是否至少有一个元素​​ 满足指定条件，一旦找到符合条件的元素，立即返回 true（停止遍历），若全部不满足，返回 false
// 示例数组
const numbers = [1, 3, 5, 7, 9];

// 检查是否存在偶数
const hasEven = numbers.some(n => n % 2 === 0); 
console.log(hasEven); // false

// 检查是否存在大于5的数
const hasBig = numbers.some(n => n > 5); 
console.log(hasBig); // true（7和9满足）

const users2 = [
    {name: 'Alice', active: true },
    {name: 'Bob', active: false }
];

const hasActiveUser = users2.some(user => user.active);
console.log(hasActiveUser); // true（Alice是active）

const users = [
    { name: "Alice", age: 25 },
    { name: "Bob", age: 30 },
    { name: "Charlie", age: 18 }
];

// 检查所有用户是否都是成年人（age >= 18）
const allAdults = users.every(user => user.age >= 18);
console.log(allAdults); // true

const sortedStudents = [...students].sort((a, b) => 
    a.grade - b.grade || 
    a.class - b.class || 
    a.number - b.number
);

const nums = [19,8,4,3,11,67,2].sort((a, b) => a - b);
console.log(nums);

// 示例 3: 转换 Set 为数组
const set = new Set([1, 2, 3]);
const arrayFromSet = Array.from(set);
console.log(arrayFromSet); // [1, 2, 3]

// 示例 4: 转换字符串为字符数组
const str = "hello";
const chars = Array.from(str);
console.log(chars); // ['h', 'e', 'l', 'l', 'o']

// 示例 6: 转换 NodeList 并提取 id
const elements = document.querySelectorAll(".item");
const ids = Array.from(elements, el => el.id);
console.log(ids); // 所有元素的 id 数组

const user = { name: 'Alice', age: 25 };
const updatedUser = { ...user, age: 26 }; // 合并并覆盖属性

let user = { name: 'Alice', age: 18, sex: '男', address: 'Beijing'};
Object.keys(user); // ["name", "age", "sex", "address"]

let user = { name: 'Alice', age: 18, sex: '男', address: 'Beijing'};
Object.values(user); // ["Alice", 18, "男", "Beijing"]

const person = { name: 'Bob', age: 30 };
Object.entries(person).forEach(([key, val]) => {
  console.log(`${key}: ${val}`); // "name: Bob", "age: 30"
});

class Player {
  #score = 0; // 私有字段（ES2022）[1](@ref)
  
  constructor(name) { this.name = name; }

  // Getter/Setter
  get score() { return this.#score; }
  addPoints(points) { this.#score += points; }
}

const player = new Player('Alice');
player.addPoints(10);
console.log(player.score); // 10（无法直接访问 #score）

// math.js
export const PI = 3.14;
export function sum(a, b) { return a + b; }

// app.js
import { PI, sum } from './math.js';
console.log(sum(PI, 2)); // 5.14

const user = { address: { city: 'Beijing' } };
console.log(user?.address?.city); // "Beijing"
console.log(user?.contacts?.email); // undefined（不报错）

// 定义各科评分规则 (可动态配置)
const subjectConfig = {
  语文: { total: 150, pass: 90, high: 120 },
  数学: { total: 150, pass: 90, high: 135 },
  英语: { total: 120, pass: 72, high: 108 },
  化学: { total: 100, pass: 60, high: 85 },
  物理: { total: 100, pass: 60, high: 85 },
  历史: { total: 100, pass: 60, high: 85 },
  道法: { total: 100, pass: 60, high: 85 }
};

// 核心统计函数 (支持动态科目和规则)
function analyzeResults(students, subjectConfig) {
  const subjects = Object.keys(subjectConfig);
  
  // 初始化班级统计结构: Map<班级标识, 统计对象>
  const classStats = new Map();
  const globalStats = {
    total: 0,
    passAll: 0,
    highAny: 0,
    subjects: subjects.reduce((acc, subject) => ({
      ...acc,
      [subject]: { pass: 0, high: 0 }
    }), {})
  };

  // 遍历学生数据
  students.forEach(student => {
    // 生成班级唯一标识 (年级+班级)
    const classKey = `${student.年级}_${student.班级}`;
    // 动态初始化班级统计
    if (!classStats.has(classKey)) {
      classStats.set(classKey, {
        total: 0,
        passAll: 0,
        highAny: 0,
        subjects: subjects.reduce((acc, subject) => ({
          ...acc,
          [subject]: { pass: 0, high: 0 }
        }), {})
      });
    }
    const clsStats = classStats.get(classKey);
    
    // 更新计数
    clsStats.total++;
    globalStats.total++;

    // 核心判断逻辑
    let isAllPassed = true;
    let hasAnyHigh = false;
    
    subjects.forEach(subject => {
      const { pass, high } = subjectConfig[subject];
      const score = student[subject];
      
      // 判断单科是否及格
      const isPass = score >= pass;
      if (isPass) {
        clsStats.subjects[subject].pass++;
        globalStats.subjects[subject].pass++;
      } else {
        isAllPassed = false; // 存在一科不及格则全科不通过
      }
      
      // 判断单科是否高分
      const isHigh = score >= high;
      if (isHigh) {
        clsStats.subjects[subject].high++;
        globalStats.subjects[subject].high++;
        hasAnyHigh = true;
      }
    });

    // 更新全科/高分统计
    if (isAllPassed) {
      clsStats.passAll++;
      globalStats.passAll++;
    }
    if (hasAnyHigh) {
      clsStats.highAny++;
      globalStats.highAny++;
    }
  });

  // 计算比率
  const calculateRates = (stats) => ({
    ...stats,
    passAllRate: (stats.passAll / stats.total).toFixed(4),
    highAnyRate: (stats.highAny / stats.total).toFixed(4),
    subjects: Object.entries(stats.subjects).reduce((acc, [subject, data]) => ({
      ...acc,
      [subject]: {
        passRate: (data.pass / stats.total).toFixed(4),
        highRate: (data.high / stats.total).toFixed(4)
      }
    }), {})
  });

  // 生成最终结构化数据
  return {
    byClass: Object.fromEntries(
      Array.from(classStats).map(([classKey, stats]) => [
        classKey,
        { ...calculateRates(stats), total: stats.total }
      ])
    ),
    global: {
      ...calculateRates(globalStats),
      total: globalStats.total,
      subjects: Object.entries(globalStats.subjects).reduce((acc, [subject, data]) => ({
        ...acc,
        [subject]: {
          pass: data.pass,
          passRate: (data.pass / globalStats.total).toFixed(4),
          high: data.high,
          highRate: (data.high / globalStats.total).toFixed(4)
        }
      }), {})
    }
  };
}

// 使用示例
const result = analyzeResults(students, subjectConfig);
console.log(result);

// 筛选+转换结合
const users = [
    {id: 1, name: 'Alice', age: 25},
    {id: 2, name: 'Bob', age: 30},
    {id: 3, name: 'Charlie', age: 25}
];

// 按年龄分组：相当于array_group_by()
const data = users.reduce((groups, user) => {
    const key = user.age;
    groups[key] = groups[key] || [];
    groups[key].push(user.name);
    return groups;
}, {});
console.log(data);
// 输出: {25: [Alice, Charlie], 30: [Bob]}