JS常用数据类型的方法函数调用，数组的方法、对象的方法、字符串的方法、数字的方法、集合的方法、映射的方法、栈的方法、队列的方法、链表的封装、树的封装、

1. 数组（Array）：数组是一组按顺序存储的元素的集合：

concat(): 连接两个或多个数组，并返回一个新数组
let arr1 = [1,2,3];
arr1 = arr1.concat([1,2,3],[4,5,6])
console.log(arr1);
join(): 将数组的所有元素连接成一个字符串。
let str1 = arr1.join("");
console.log(str1);
push(): 向数组的末尾添加一个或多个元素，并返回新的长度。
arr1.push(1)
pop(): 删除并返回数组的最后一个元素
let last = arr1.pop()
shift(): 删除并返回数组的第一个元素
let first = arr1.shift()
unshift(): 向数组的开头添加一个或多个元素，并返回新的长度。
arr1.unshift(0)
slice(): 从数组中提取指定位置的元素，并返回新数组
let afterSlice = arr1.slice(2,4)
splice(): 删除、替换或添加数组的元素，并返回被删除的元素。
arr1.splice(1,4)
console.log(arr1)
reverse(): 颠倒数组中元素的顺序。
arr1.reverse()
console.log(arr1)
sort(): 对数组元素进行排序。
arr1.sort((a,b)=>a-b)
console.log(arr1)
indexOf(): 返回指定元素在数组中首次出现的索引。
let firstFindIndex = arr1.indexOf(1)
lastIndexOf(): 返回指定元素在数组中最后一次出现的索引。
let lastFindIndex = arr1.lastIndexOf(1)
filter(): 创建一个新数组，其中包含通过函数筛选的所有元素。
let afterFilter = arr1.filter((item)=>item==2)
map(): 创建一个新数组，其中包含对原数组的每个元素应用函数的结果。
let afterMap = arr1.map((item,index)=>{return item*2})
reduce(): 通过函数对数组的元素进行累积计算，返回一个值，累加器初始化为0
let afterReduce = arr1.reduce((accumulator,currentVal)=>{return acuumulator+currentVal},0)
forEach(): 对数组的每个元素执行一次指定的函数。
arr1.forEach((item)=>{item+=1;})
every(): 检查数组的所有元素是否满足指定的条件。
let res = arr1.every((item,index)=>{return item>0;})
some(): 检查数组的是否至少有一个元素满足指定的条件。
let res = arr1.some((item)=>{
return item<0;})
find(): 返回数组中满足指定条件的第一个元素。
let res = arr1.find((item)=>{
return item>2;})
findIndex(): 返回数组中满足指定条件的第一个元素的索引。
let res = arr1.findIndex((item)=>{return item>2;})
这些方法会直接修改原始数组，并返回具体的操作结果或修改后的数组。
会改变原数组的方法：
push()
pop()
shift()
unshift()
splice()
reverse()
sort()
会返回新数组的方法,这些方法不会修改原始数组，而是返回一个新的数组作为结果。原始数组保持不变：
concat()
slice()
filter()
map()
其他方法：
join()
indexOf()
lastIndexOf()
reduce()
forEach()
every()
some()
find()
findIndex()

2. 对象（Object）：对象是一种键值对的集合，其中每个键都是唯一的

Object.keys(obj): 返回一个包含对象自身可枚举属性的数组。
Object.values(obj): 返回一个包含对象自身可枚举属性的值的数组。
Object.entries(obj): 返回一个包含对象自身可枚举属性的键值对的数组。
Object.assign(target, ...sources): 将一个或多个源对象的属性复制到目标对象中，并返回目标对象。
Object.create(proto, [propertiesObject]): 使用指定的原型对象和属性创建一个新对象。
Object.defineProperty(obj, prop, descriptor): 在对象上定义一个新属性或修改现有属性的特性。
Object.getOwnPropertyDescriptor(obj, prop): 返回指定对象上一个自有属性对应的属性描述符。
Object.getOwnPropertyNames(obj): 返回一个包含对象自身所有属性（不仅是可枚举属性）的数组。
Object.getPrototypeOf(obj): 返回指定对象的原型。
Object.setPrototypeOf(obj, prototype): 设置一个对象的原型到另一个对象或null。
Object.hasOwnProperty(prop): 判断对象是否具有指定名称的自身属性。

3. 字符串（String）：

length: 返回字符串的长度。
charAt(index): 返回指定索引位置的字符。
charCodeAt(index): 返回指定索引位置的字符的Unicode编码。
concat(str1, str2, ..., strN): 连接两个或多个字符串，并返回一个新字符串。
indexOf(searchValue, [start]): 返回指定字符串首次出现的索引。
lastIndexOf(searchValue, [start]): 返回指定字符串最后一次出现的索引。
slice(start, [end]): 提取字符串的一部分，并返回一个新字符串。
substring(start, [end]): 提取字符串的一部分，并返回一个新字符串。与slice()类似，但不支持负索引。
substr(start, [length]): 提取字符串的指定长度的子字符串，并返回一个新字符串。
replace(searchValue, replaceValue): 替换字符串中的指定内容，并返回一个新字符串。
toLowerCase(): 将字符串转换为小写。
toUpperCase(): 将字符串转换为大写。
trim(): 移除字符串两端的空格或其他指定字符。
split(separator, [limit]): 将字符串分割为子字符串数组，根据指定的分隔符。
startsWith(searchString, [position]): 检查字符串是否以指定字符串开头。
endsWith(searchString, [length]): 检查字符串是否以指定字符串结尾。
includes(searchString, [position]): 检查字符串是否包含指定字符串。
match(regexp): 在字符串中搜索匹配指定正则表达式的结果，并返回一个数组。
search(regexp): 在字符串中搜索匹配指定正则表达式的结果，并返回匹配的索引。
substring(start, [end]): 提取字符串的一部分，并返回一个新字符串。与slice()类似，但不支持负索引。

4. 数字（Number）：

toFixed(digits): 将数字格式化为指定小数位数的字符串表示。
toPrecision(precision): 将数字格式化为指定有效位数的字符串表示。
toString([radix]): 将数字转换为指定进制（2到36）的字符串表示。
parseFloat(string): 解析一个字符串参数并返回一个浮点数。
parseInt(string, radix): 解析一个字符串参数并返回一个整数。
isFinite(number): 检查一个数字是否有限（非Infinity或NaN）。
isNaN(number): 检查一个数字是否是NaN（Not-a-Number）。
isInteger(number): 检查一个数字是否是整数。
isSafeInteger(number): 检查一个数字是否是安全整数。
toExponential(fractionDigits): 返回一个数字的指数表示法的字符串。
toLocaleString([locales, [options]]): 返回一个数字的本地化表示字符串。
valueOf(): 返回一个数字的原始值。

5. 集合（Set）：集合是一组唯一值的集合：

const mySet = new Set();
add(value): 向集合中添加一个新的元素。
delete(value): 从集合中删除指定的元素。
has(value): 检查集合中是否存在指定的元素，返回一个布尔值。
clear(): 清空集合，删除所有元素。
size: 返回集合中元素的数量。
values(): 返回一个包含集合中所有元素的迭代器。
forEach(callbackFn, [thisArg]): 对集合中的每个元素执行指定的回调函数。

6. 映射（Map）：映射是一组键值对的集合，其中每个键都是唯一的：

const myMap = new Map();
myMap.set("name", "John");
myMap.set("age", 25);
console.log(myMap.toArray()); // 输出: [['name', 'John']]
若不是new Map的映射，不能使用.has等
用for(let item of map){if(item in map){}}

set(key, value): 向Map中添加一个新的键值对。
get(key): 获取指定键对应的值。
has(key): 检查Map中是否存在指定的键，返回一个布尔值。
delete(key): 从Map中删除指定键及其对应的值。
clear(): 清空Map，删除所有键值对。
size: 返回Map中键值对的数量。
keys(): 返回一个包含Map中所有键的迭代器。
values(): 返回一个包含Map中所有值的迭代器。
entries(): 返回一个包含Map中所有键值对的迭代器。
forEach(callbackFn, [thisArg]): 对Map中的每个键值对执行指定的回调函数。

7. 栈（Stack）：栈是一种遵循先进后出（LIFO）原则的数据结构：

const myStack = new Stack();
push(element1, element2, ..., elementN): 将一个或多个元素添加到栈的顶部。
pop(): 移除并返回栈顶部的元素。
peek(): 返回栈顶部的元素，但不对栈进行修改。
isEmpty(): 检查栈是否为空，返回一个布尔值。
clear(): 清空栈，移除所有元素。
size(): 返回栈中元素的数量。

8. 队列（Queue）：队列是一种遵循先进先出（FIFO）原则的数据结构：

const myQueue = new Queue();
enqueue(element1, element2, ..., elementN): 将一个或多个元素添加到队列的末尾（也称为入队）。
dequeue(): 移除并返回队列的第一个元素（也称为出队）。
peek(): 返回队列的第一个元素，但不对队列进行修改。
isEmpty(): 检查队列是否为空，返回一个布尔值。
clear(): 清空队列，移除所有元素。
size(): 返回队列中元素的数量。

9. 链表（Linked List）：链表是一种由节点组成的线性数据结构：

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}
class LinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  // 在链表末尾添加新节点
  append(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }
  // 在链表头部添加新节点
  appendhead(value) {
    const newNode = new Node(value);

    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      newNode.next = this.head;
      this.head = newNode;
    }
  }
  forEach() {
    let currentNode = this.head;
    while (currentNode) {
      console.log(currentNode.value);
      currentNode = currentNode.next;
    }
  }
}
const mylink = new LinkedList()
mylink.append(1)
mylink.prepend(2)
mylink.append(3)
mylink.forEach()

10. 树（Tree）：树是一种由节点组成的层次结构：

class TreeNode {
  constructor(value) {
    this.value = value;
    this.left = null;
    this.right = null;
  }
}
class BinaryTree {
  constructor() {
    this.root = null;
  }
  insert(value) {
    const newNode = new TreeNode(value);
    if (this.root === null) {
      this.root = newNode;
    } else {
      this.insertNode(this.root, newNode);
    }
  }
  insertNode(node, newNode) {
    if (newNode.value < node.value) {
      if (node.left === null) {
        node.left = newNode;
      } else {
        this.insertNode(node.left, newNode);
      }
    } else {
      if (node.right === null) {
        node.right = newNode;
      } else {
        this.insertNode(node.right, newNode);
      }
    }
  }
}