1
const str = '   hello';
2
console.log(str.trimStart());
3
//制表符
4
'\t\thello'.trimStart();//'hello'
5
//换行符
6
'\n\nhello'.trimStart();
7

8
const str = 'hello   ';
9
console.log(str.trimEnd());
10
//中间的空格不会删除
11
'he   llo'.trim();
12

13
//trim()两端都删除。
14
'   hello   '.trim();
15

16
//用户输入处理
17
const username = input.value.trim();
18

19
//字符串不会被修改
20
const str = '  hello';
21
str.trimStart();
22
const newStr = str.trimStart();
23
console.log(str);
24
console.log(newStr);

1
//searchElement：要查找的元素。
2
//fromIndex：从哪个索引开始查找（可选）
3
arr.includes(searchElement, fromIndex)
4

5
//基本使用
6
const arr = [1, 2, 3, 4];
7
console.log(arr.includes(2));
8
console.log(arr.includes(5));//false
9

10
//第二个参数 fromIndex
11
const arr = [1, 2, 3, 2];
12
console.log(arr.includes(2, 2));//true
13
//支持负数索引
14
const arr = [1, 2, 3, 4];
15
console.log(arr.includes(3, -2));//true 往后倒数
16

17
//和 indexOf() 的区别（重点）
18
arr.indexOf(2) !== -1
19
arr.includes(2)//更直观
20

21
//最大的区别：NaN
22
[1, NaN].indexOf(NaN);//-1找不到。
23
[1, NaN].includes(NaN);//true
24

25
//对象比较
26
const obj = { a: 1 };
27
const arr = [obj];
28
console.log(arr.includes(obj));//true
29
arr.includes({ a: 1 });//false  对象比较的是引用地址。

1
//基本用法
2
console.log(Array.from('str'));//[ 's', 't', 'r' ]
3

4
// 2.哪些可以通过Array.from(转换成数组
5
// 2.1.所有可遍历的
6
// 数组、字符串、Set、Map、NodeList、arguments
7
console.log(Array.from(new Set([1, 2, 1])));
8
console.log([...new Set([1, 2, 1])]);//也是转数组更简洁
9

10
//2.2拥有length属性的任意对象
11
const obj = {
12
  0: 'a',//只有键值是数字才会转换
13
  1: 'b',
14
  2: 'c',
15
  name:'alex'//不转
16
  length: 3//由这个决定数组长度
17
};
18
const arr = Array.from(obj);
19
console.log(arr);
20

21
//3.第二个参数
22
//作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组
23
Array.from([1, 2, 3], item => item * 2);
24
//等价于
25
Array.from([1, 2, 3]).map(item => item * 2);//但前者效率更高，因为只遍历一次
26

27
//生成指定长度的数组
28
Array.from({ length: 5 }, () => 0);//[0, 0, 0, 0, 0]
29

30
//生成数字序列
31
Array.from({ length: 5 }, (_, i) => i);//[0, 1, 2, 3, 4]
32

33
//4第三个参数，修改this指向 普通函数才能修改this
34
const obj = {};
35
Array.from(
36
  '12',
37
  function () {
38
    console.log(this);
39
  },
40
  obj,
41
);//this-》obj

1
arr.find(callback)
2
const arr = [5, 12, 8, 130, 44];
3
const res = arr.find(item => item > 10);
4
console.log(res);//12
5

6
const f = [1, 5, 7, 8, 9, 3].find((value, index, arr) => {
7
  //value 值 index索引 ，arr数组
8
  return value > 8;
9
});
10
console.log(f);//9
11
const f = [1, 5, 7, 8, 9, 3].findIndex((value, index, arr) => {
12
  //value 值 index索引 ，arr数组
13
  return value > 8;
14
});
15
console.log(f);//4
16

17
//第三个参数，修改this指向 普通函数才能修改this
18
const obj = {};
19
const f = [1, 5, 7, 8, 9, 3].findIndex(function (value, index, arr) {
20
  console.log(this);
21
}, obj);
22

23
//应用
24
//find 查对象
25
const users = [
26
  { id: 1, name: 'A' },
27
  { id: 2, name: 'B' }
28
];
29
const user = users.find(u => u.id === 2);
30
console.log(user);//{ id: 2, name: 'B' }
31
//findIndex 查位置
32
const index = users.findIndex(u => u.id === 2);
33
console.log(index);

1
//基本用法，会修改原对象
2
const obj1 = { a: 1 };
3
const obj2 = { b: 2 };
4
const result = Object.assign(obj1, obj2);
5
console.log(result);//{ a: 1, b: 2 }
6
console.log(obj1);//{ a: 1, b: 2 }
7

8
//避免污染原对象
9
const result = Object.assign({}, obj1, obj2);
10

11
//浅拷贝
12
const obj = {
13
  a: 1,
14
  b: { c: 2 }
15
};
16
const copy = Object.assign({}, obj);
17
copy.b.c = 999;
18
console.log(obj.b.c);//999
19

20
//数组也可以用，因为数组本质也是对象（key 是索引）不常用
21
const arr1 = [1, 2];
22
const arr2 = [3, 4];
23
Object.assign(arr1, arr2);
24
console.log(arr1);//[3, 4]与本意不符
25

26
//应用
27
const logUser = (UserOption) => {
28
  //默认配置
29
  const DEFAULTS = {
30
    name: 'zhangsan',
31
    age: 0,
32
  };
33
  //合并
34
  const option = Object.assign({}, DEFAULTS, UserOption);
35
  console.log(option);
36
};
37
logUser({ name: 'alex' });

1
const obj = {
2
  name: 'Alice',
3
  age: 18
4
};
5
console.log(Object.entries(obj));
6
//输出
7
[
8
  ['name', 'Alice'],
9
  ['age', 18]
10
]
11

12
//遍历对象（推荐写法）
13
for (const [key, value] of Object.entries(obj)) {
14
  console.log(key, value);
15
}
16
//转 Map
17
const map = new Map(Object.entries(obj));
18
//对象转数组处理
19
Object.entries(obj).map(([k, v]) => {
20
  console.log(k, v);
21
});