原始数据类型与引用类型

JavaScript的数据类型分为两类：原始数据类型和引用类型。原始类型包括基本类型如string（字符串）, number（数字）, boolean（布尔值）, null（空值）, undefined（未定义）, symbol（符号）和bigint（大整数）。引用类型则涉及数组、对象和函数。

let name = "Alice"; // 原始类型：字符串
let age = 25; // 原始类型：数字
let isStudent = true; // 原始类型：布尔值
let x = null; // 原始类型：null
let y; // 原始类型：undefined
let id = Symbol("id"); // 引用类型：symbol
let arr = [1, 2, 3]; // 引用类型：数组
let obj = { name: "Bob", age: 30 }; // 引用类型：对象
let func = function() {}; // 引用类型：函数

原始类型与引用类型的比较

原始类型和引用类型在内存中的存储方式不同。原始类型直接存储在栈内存中，而引用类型存储在堆内存中。对原始类型进行操作时，改变的是同一个内存中的数据，而对引用类型操作时，改变的是引用指向的对象。

实例展示：

let x = 10;
let y = x;
x = 20;

console.log(x); // 20
console.log(y); // 20

示例代码：

let arr1 = [1, 2, 3];
let arr2 = arr1;

arr2.push(4);

console.log(arr1); // [1, 2, 3, 4]
console.log(arr2); // [1, 2, 3, 4]

函数的基础知识

JavaScript是一种基于函数的语言，函数可以作为参数传递，也可以作为返回值。函数的使用提高了代码的复用性和可维护性。

function add(a, b) {
  return a + b;
}

let result = add(3, 4);
console.log(result); // 7

函数的高级特性

匿名函数与箭头函数

匿名函数可以不被赋予名称直接使用，箭头函数则是ES6引入的简洁的函数定义方式。

(function(a, b) {
  console.log(a + b);
})(3, 4);

const add = (a, b) => a + b;

函数的柯里化

柯里化是一种将接受多个参数的函数转换为一系列只接受单个参数的函数的方法，有助于渐进式提供参数。

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

const add = curry((a, b, c) => a + b + c);
console.log(add(1)(2)(3)); // 6

闭包

闭包允许函数访问其外部作用域的变量，通常用于封装数据，保护数据不被外部代码修改。

function createCounter() {
  let count = 0;

  return {
    increment() {
      count++;
      console.log(count);
    },
    decrement() {
      count--;
      console.log(count);
    },
    getCount() {
      console.log(count);
    }
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
counter.decrement();
counter.getCount();

异步编程基础

异步编程用于处理性能瓶颈和长时间运行任务，如I/O操作，不阻塞主线程。

setTimeout(() => {
  console.log("Delayed message");
}, 2000);

Promise的使用

Promise封装异步操作的状态和结果，用于管理异步流程。

const promise = new Promise((resolve, reject) => {
  // 异步操作
  setTimeout(() => {
    // 成功
    resolve("Operation complete");
  }, 2000);
});

promise.then(result => {
  console.log(result);
}).catch(error => {
  console.error(error);
});

链式Promise

链式调用Promise，以清晰地组织异步操作的顺序。

const fetchUser = () => {
  return new Promise((resolve, reject) => {
    // 模拟异步操作
    setTimeout(() => {
      // 成功
      resolve({ name: "Alice", age: 30 });
    }, 2000);
  });
};

fetchUser()
  .then(user => {
    console.log(user);
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        // 成功
        resolve(user.name);
      }, 1000);
    });
  })
  .then(name => {
    console.log("User name:", name);
  })
  .catch(error => {
    console.error("Error:", error);
  });

Node.js的事件循环

事件循环是Node.js的核心概念，用于管理异步操作和事件，允许同时处理多个连接和任务。

setInterval(() => {
  console.log("Tick");
}, 1000);

Node.js的非阻塞性

Node.js通过事件驱动模型实现非阻塞性操作，允许同时执行多个任务。

const net = require("net");
const server = net.createServer(socket => {
  socket.write("Hello, client!");
});

server.listen(3000);

模块化与CommonJS

CommonJS是用于模块化的标准，使用require和module.exports进行定义和导入。

// module.js
module.exports = function() {
  return "Hello, from module!";
};

// index.js
const module = require("./module");
console.log(module());

ES6模块

ES6引入模块系统，使用import和export进行导入和导出。

// module.js
export const greeting = "Hello, from module!";

// index.js
import greeting from "./module";
console.log(greeting);

类与继承

ES6引入类和继承概念，简化面向对象编程。

class Animal {
  constructor(name) {
    this.name = name;
  }
  speak() {
    console.log("I'm an animal");
  }
}

class Dog extends Animal {
  speak() {
    console.log("Woof!");
  }
}

const dog = new Dog("Rover");
dog.speak();

代码可读性与可维护性

遵循代码风格规范，如Prettier或ESLint，保持代码简洁和结构清晰。

// Bad practice
function getSum(x, y) {
  return x + y;
}

// Good practice
function calculateTotal(a, b) {
  return a + b;
}

性能优化

使用缓存

减少重复计算，提高性能。

const expensiveCalculation = () => {
  // ... 高性能计算
  return result;
};

const cache = {};

function getExpensiveCalculation() {
  if (!cache.hasOwnProperty("result")) {
    cache.result = expensiveCalculation();
  }
  return cache.result;
}

避免全局变量

减少全局变量使用，提高代码维护性。

// Bad practice
var globalVar = "global";

function someFunction() {
  console.log(globalVar);
}

// Good practice
const moduleName = "module";
const globalVar = "global";

// Within the module
function someFunction() {
  console.log(globalVar);
}

异步优化

使用Promise.all()和async/await简化异步操作管理。

async function fetchData() {
  try {
    const [data1, data2] = await Promise.all([
      fetch("url1").then(res => res.json()),
      fetch("url2").then(res => res.json()),
    ]);
    // 同步执行后续操作
  } catch (error) {
    console.error("Error fetching data:", error);
  }
}

总之，通过深入理解JavaScript高级知识，从基本数据类型到异步编程，再到模块化和最佳实践，开发者可以编写出高效、可维护的代码。随着实践经验的积累，JavaScript编程之旅将持续深化和扩展。