JS对象、数组、字符串超详细方法

JavaScript

对象方法

对象创建的方式

对象字面量

var dog1 = {`
  `name: "大黄",`
  `age: 2,`
  `speak: function () {`
    `console.log("汪汪");`
  `},`
`};

使用Object构造函数

var dog2 = new Object();
dog2.name = "大黄";
dog2.age = 2;
dog2.speak = function () {
  console.log("汪汪");
};

使用自定义构造函数

// 使用构造函数
function Dog(name, age) {
  this.name = name;
  this.age = age;
}
Dog.prototype.speak = function () {
  console.log("汪汪");
};
var dog3 = new Dog("大黄", 2);

使用Object.create

Object.create 用于创建一个新对象，使用现有的对象来提供新创建对象的原型对象。
proto - 必须，新创建对象的原型对象。
prop - 可选，是一个对象，设置属性及属性值，默认值：undefined，（属性默认不能修改，不能枚举）。

语法：

Object.create(proto,prop)

创建一个原型为null的空对象

var o = Object.create(null);
console.log( o.__proto__ === undefined );  // true

创建一个以空对象为原型对象，且拥有一个属性p的对象

var o = Object.create({}, { p: { value: 42 } });
console.log(o);    // { p: 42 }

以字面量方式创建的空对象就相当于: Object.create(Object.prototype)

var o = {};
//相当于 var o = Object.create(Object.prototype)
console.log( o.__proto__ === Object.prototype );    //true

访问对象属性

以`.`的方式访问

const obj = {
  info: "wakaka",
  inner: {
    a: 10,
    b: 20,
  },
  arr: [1, 2],
  sayHi: (name) => {
    console.log(`hi,${name}`);
  },
};

// 用 dot(点 .) 的方式访问
console.log(obj.info); // wakaka
console.log(obj.inner); // {"a":10,"b":20}
console.log(obj.arr); // [1,2]
obj.sayHi("dengke"); // hi,dengke

以`[]`的方式访问

console.log(obj["info"]); // wakaka
console.log(obj["inner"]); // {"a":10,"b":20}
console.log(obj["arr"]); // [1,2]
obj["sayHi"]("dengke"); // hi,dengke

区别：

[]中括号法：可以用变量作为属性名或访问，而点语法不可以;

var obj = {};
obj.name = "张三";
var myName = "name";
console.log(obj.myName); //undefined,访问不到对应的属性
console.log(obj[myName]); //张三
var person = {
  name: "gogo",
};
console.log(person["name"]); //gogo
console.log(person.name); //gogo
//    优点：1,可以通过变量来访问属性
var propertyName = "name";
console.log(person[propertyName]); //gogo
var propertyName2 = "name2";
console.log(person[propertyName2]); //undefined

[]中括号法：可以用数字作为属性名，而点语法不可以;

var obj1 = {};
//    obj1.1=1;//Unexpected number
obj1[2] = 2;
//    console.log(obj1.1)
console.log(obj1[2]); //2
//    console.log(obj1.2)
console.log(obj1); //{2: 2}

[]中括号法：可以动态设置和获取属性名，点操作符就不行；

// （ 即 []--可以动态设置和获取)
var customer = {};
var addr = ["北京", "上海", "广州", "深圳"];
for (i = 0; i < 4; i++) {
  customer["address" + i] = addr[i];
}
console.log(addr);
console.log(customer);

删除对象属性

利用关键字 delete

const o = {
  p: 10,
  m: 20,
};
delete o.p;
console.log(o); // { m: 20 }
// 删除对象的属性后，在访问返回 undefined
console.log(o.p); // undefined

枚举对象的属性

for in: 会遍历对象中所有的可枚举属性（包括自有属性和继承属性）
Object.keys(): 会返回一个包括所有的可枚举的自有属性的名称组成的数组
Object.getOwnPropertyNames(): 会返回自有属性的名称（不管是不是可枚举的）

for…in…

会遍历对象中所有的可枚举属性（包括自有属性和继承属性）

- const obj = {
    itemA: "itemA",
    itemB: "itemB",
  };

  // 使用Object.create创建一个原型为obj的对象 （模拟继承来的属性）
  var newObj = Object.create(obj);

  newObj.newItemA = "newItemA";
  newObj.newItemB = "newItemB";

  for (i in newObj) {
    console.log(i);
  }
  // newItemA
  // newItemB
  // itemA
  // itemB

  // 现在我们将其中的一个属性变为不可枚举属性
  Object.defineProperty(newObj, "newItemA", {
    enumerable: false,
  });

  for (i in newObj) {
    console.log(i);
  }
  // newItemB
  // itemA
// itemB

Object.keys():

会返回一个包括所有的可枚举的自有属性的名称组成的数组

// 接上例

const result = Object.keys(newObj)
console.log(result) // ["newItemB"]

Object.getOwnPropertyNames()

会返回自有属性的名称（不管是不是可枚举的）

// 接上例
const result = Object.getOwnPropertyNames(newObj)

console.log(result) // ['newItemA','newItemB']

Object常用的API

Object.assign()

语法：

Object.assign(target, ...sources)

// 参数：target 目标参数，sources源对象 返回值：目标对象

Object.assign() 方法用于将所有可枚举属性的值从一个或多个源对象分配到目标对象。它将返回目标对象。常用来合并对象。

const obj1 = { a: 1, b: 2 };

const obj2 = { b: 4, c: 5 };

const obj3 = Object.assign(obj1, obj2);

const obj4 = Object.assign({}, obj1); // 克隆了obj1对象

console.log(obj1); // { a: 1, b: 4, c: 5 } 对同名属性b进行了替换 obj1发生改变是因为obj2赋给了obj1

console.log(obj2); // { b: 4, c: 5 }

console.log(obj3); // { a: 1, b: 4, c: 5 }

console.log(obj4); // { a: 1, b: 4, c: 5 }

注意：

如果目标对象中的属性具有相同的键，则属性将被源对象中的属性覆盖。
Object.assign 方法只会拷贝源对象自身的并且可枚举的属性到目标对象。

assign其实是浅拷贝而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。同名属性会替换。

const obj5 = {
  name: "dengke",
  a: 10,
  fn: {
    sum: 10,
  },
};

const obj6 = Object.assign(obj1, obj5);
console.log(obj6); // { a: 10, b: 2, name: 'dengke', fn: {…}}
console.log(obj1); // {a: 10, b: 2, name: 'dengke', fn: {…}} 对同名属性a进行了替换

Object.assign 不会在那些source对象值为null或undefined的时候抛出错误。

Object.keys()

语法：

Object.keys(obj)

参数：obj要返回其枚举自身属性的对象。

返回值：一个表示给定对象的所有可枚举属性的字符串数组。

Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和正常循环遍历该对象时返回的顺序一致。

与Object.values()相似，区别在于这个返回的是数据的属性就是key。

const arr = ["a", "b", "c"];

console.log(Object.keys(arr)); // ['0', '1', '2']

const obj = { 0: "a", 1: "b", 2: "c" };

console.log(Object.keys(obj)); // ['0', '1', '2']

const obj2 = { 100: "a", 2: "b", 7: "c" };

console.log(Object.keys(obj2)); // ['2', '7', '100']

注意

在ES5里，如果此方法的参数不是对象（而是一个原始值），那么它会抛出 TypeError。在ES2015中，非对象的参数将被强制转换为一个对象。

Object.values()

语法：

Object.values(obj)

参数：obj被返回可枚举属性值的对象。

返回值：一个包含对象自身的所有可枚举属性值的数组。

Object.values() 方法返回一个给定对象**自身的所有可枚举属性值的数组**，值的顺序与使用for…in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。与Object.keys()相似，区别在于这个返回的是数据的值也就是value

const obj1 = { foo: "bar", baz: 42 };
console.log(Object.values(obj1)); // ['bar', 42]

const obj2 = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj2)); // ['a', 'b', 'c']

注意

对象key为number的话，会从升序枚举返回。

const obj3 = { 100: 'a', 2: 'b', 7: 'c' }
console.log(Object.values(obj3)) // ['b', 'c', 'a']

Object.entries(obj)

语法：

Object.entries(obj)

参数：obj可以返回其可枚举属性的键值对的对象。
返回值：给定对象自身可枚举属性的键值对数组。

Object.entries() 方法返回一个给定对象自身可枚举属性的键值对数组。

可使用Object.fromEntries()方法，相当于反转了Object.entries()方法返回的数据结构。

const obj = { foo: "bar", baz: 42 };
console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]

// array like object 像数组的对象
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]

// array like object with random key ordering
const anObj = { 100: "a", 2: "b", 7: "c" };
// 返回值会按照key升序排列
console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]

// getFoo is property which isn't enumerable getFoo是不可枚举的属性
const myObj = Object.create(
  {},
  {
    getFoo: {
      value() {
        return this.foo;
      },
    },
  }
);
myObj.foo = "bar";
console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]  // 只会返回对象可枚举属性键值对组成的数组

// non-object argument will be coerced to an object //ES2015新增 会将非对象参数强转成对象
console.log(Object.entries("foo")); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]

// iterate through key-value gracefully 优雅地遍历键值对
const obj = { a: 5, b: 7, c: 9 };
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
}

// Or, using array extras 使用数组的额外功能
Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
});

补充

将Object转换为Map对象

new Map()构造函数接受一个可迭代的entries。借助Object.entries方法你可以很容易的将Object转换为Map:

const obj = { foo: "bar", baz: 42 };
const map = new Map(Object.entries(obj));
console.log(map); // Map { foo: "bar", baz: 42 }

Object.fromEntries()

语法：

Object.fromEntries(iterable)

参数：iterable类似Array、Map或者其它实现了可迭代协议的可迭代对象。

返回值：一个由该迭代对象条目提供对应属性的新对象。

Object.fromEntries() 方法把键值对列表转换为一个对象。

与Object.entries()相反。相当于反转了Object.entries()方法返回的数据结构。

const entries = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);

const obj = Object.fromEntries(entries);

console.log(obj);
// Object { foo: "bar", baz: 42 }

补充

Map对象转化为 Object

通过 Object.fromEntries，可以将Map转换为Object:

const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj);
// { foo: "bar", baz: 42 }

Array转化为Object

const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj);
// { 0: "a", 1: "b", 2: "c" }

Object.fromEntries 是与 Object.entries()相反的方法

可以像下面这样转换对象：

const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val * 2])
);

// Object.entries(object1) >>> [["a",1],["b",2],["c",3]]

console.log(object2); // { a: 2, b: 4, c: 6 }

Object.prototype.hasOwnProperty

上边枚举对象属性时为了避免for..in遍历继承来的属性，给大家补充了可以借助Object.prototype.hasOwnProperty()方法进行判断，在这里也具体为大家介绍一下它。

语法：

obj.hasOwnProperty(prop)

参数：prop 要检测的属性的String字符串形式表示的名称，或者Symbol。

返回值：用来判断某个对象是否含有指定的属性的布尔值Boolean。

hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性（也就是，是否有指定的键）。

注意：

只会对自身属性进行判断，继承来的一律返回false。

配合for...in使用，可以避免其遍历继承来的属性。

const obj1 = new Object();
obj1.property1 = 42;
Object.prototype.property2 = 111;
console.log(obj1.hasOwnProperty("property1")); // true
console.log(obj1.hasOwnProperty("property2")); // false
console.log(obj1.hasOwnProperty("toString")); // false
console.log(obj1.hasOwnProperty("hasOwnProperty")); // false

即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true。

const o = new Object();
o.propOne = null;
o.propTwo = undefined;

console.log(o.hasOwnProperty("propOne")); // true
console.log(o.hasOwnProperty("propTwo")); // true

isPrototypeOf

isPrototypeOf方法用于测试一个对象是否存在于另一个对象的原型链上

function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true

Object.getOwnPropertyNames()

Object.getOwnPropertyNames() 返回一个数组，该数组对元素是 obj自身拥有的枚举或不可枚举属性名称字符串。

数组中枚举属性的顺序与通过for…in循环和Object.keys迭代该对象属性时一致。数组中不可枚举属性的顺序未定义。

语法：

obj.getOwnPropertyNames(obj)

参数：obj一个对象，其自身的可枚举和不可枚举属性的名称被返回。

返回值：在给定对象上找到的自身属性对应的字符串数组。

const arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]

// 类数组对象
const obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.getOwnPropertyNames(obj).sort()); // ["0", "1", "2"]

// 使用Array.forEach输出属性名和属性值
Object.getOwnPropertyNames(obj).forEach(function (val, idx, array) {
  console.log(val + " -> " + obj[val]);
});
// 0 -> a
// 1 -> b
// 2 -> c

// 不可枚举属性
const my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
      enumerable: false,
    },
  }
);
my_obj.foo = 1;

// 不可枚举属性也会一并输出
console.log(Object.getOwnPropertyNames(my_obj).sort());
// ["foo", "getFoo"]

补充

Object.getOwnPropertyNames和Object.keys的区别：

Object.keys只适用于可枚举的属性

Object.getOwnPropertyNames返回对象的全部属性名称(包括不可枚举的)。

"use strict"
(function () {
  // 人类的构造函数
  const person = function (name, age, sex) {
    this.name = name;
    this.age = age;
    this.sex = sex;
    this.sing = () => {
      console.log("sing");
    };
  };

  // new 一个ladygaga
  const gaga = new person("ladygaga", 26, "girl");

  // 给嘎嘎发放一个不可枚举的身份证
  Object.defineProperty(gaga, "id", {
    value: "1234567890",
    enumerable: false,
  });

  //查看gaga的个人信息
  const arr = Object.getOwnPropertyNames(gaga);
  console.log(arr); // name, age, sex, sing, id

  // 注意和getOwnPropertyNames的区别，不可枚举的id没有输出
  const arr1 = Object.keys(gaga);
  console.log(arr1); // name, age, sex, sing
})();

如果你只要获取到可枚举属性，可以用Object.keys或用for…in循环（for…in会获取到原型链上的可枚举属性，可以使用hasOwnProperty()方法过滤掉）。

defineProperty定义对象属性

添加数据属性;
var obj = {};

// 1.添加一个数据属性
Object.defineProperty(obj, "newDataProperty", {
  value: 101,
  writable: true, // 是否允许修改
  enumerable: true, // 是否允许枚举
  configurable: true, // 是否允许删除
});

obj.newDataProperty; // 101

// 2.修改数据属性
Object.defineProperty(obj, "newDataProperty", {
  writable: false,
});

//添加访问器属性
var obj = {};

Object.defineProperty(obj, "newAccessorProperty", {
  set: function (x) {
    this.otherProperty = x;
  },
  get: function () {
    return this.otherProperty;
  },
  enumerable: true,
  configurable: true,
});

注意：  1.第一个参数必须为对象
        2.descriptor 不能同时具有 （value 或 writable 特性）（get 或 set 特性）。
        3.configurable 为false 时，不能重新修改装饰器

getPrototypeOf：获取指定对象的原型（内部[[Prototype]]属性的值）

const prototype1 = {};
const object1 = Object.create(prototype1);

console.log(Object.getPrototypeOf(object1) === prototype1);   // true

注意：Object.getPrototypeOf(Object) 不是 Object.prototype
     Object.getPrototypeOf( Object ) === Function.prototype;  // true

setPrototypeOf 设置一个指定的对象的原型

const obj = { a: 1 },
proto = { b: 2 };

Object.setPrototypeOf(obj, proto);

obj.__proto__ === proto; //true

Object.is ：它用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致

Object.is('foo', 'foo')     // true

Object.is({}, {})           // false

不同于 === 之处
+0 === -0                   //true
NaN === NaN                     // false

Object.is(+0, -0)           // false
Object.is(NaN, NaN)         // true

Object.freeze()和Object.isFrozen()

冻结对象是指那些不能添加新的属性，不能修改已有属性的值，不能删除已有属性，以及不能修改已有属性的可枚举性、可配置性、可写性的对象。也就是说，这个对象永远是不可变的。

let o3 = { a: 1 };

o3.b = 2; //添加属性b成功
Object.freeze(o3);

Object.isFrozen(o3); //true 对象已被冻结

o3.a = 2; //修改属性a值失败
o3.c = 5; //添加属性c失败
delete o3.b; //删除属性b失败

浅冻结与深冻结：

(function () {
  obj = {
    internal: {},
  };
  Object.freeze(obj); //浅冻结
  obj.internal.a = "aValue";
  console.log(obj.internal.a); //"aValue"

  //想让一个对象变得完全冻结,冻结所有对象中的对象,可以使用下面的函数.
  function deepFreeze(o) {
    var prop, propKey;
    Object.freeze(o); //首先冻结第一层对象
    for (propKey in o) {
      prop = o[propKey];
      if (
        !o.hasOwnProperty(propKey) ||
        !(typeof prop === "object") ||
        Object.isFrozen(prop)
      ) {
        continue;
      }
      deepFreeze(prop); //递归
    }
  }

  deepFreeze(obj);
  obj.internal.b = "bValue"; //静默失败
  console.log(obj.internal.b); //undefined
})();

数组方法

总览

改变原数组

splice( )

splice()方法用于添加或删除数组中的元素

注意： 这种方法会改变原始数组，toSpliced()是其不改变原数组的复制版本

返回值：

如果删除一个元素，则返回一个元素的数组

如果未删除任何元素，则返回空数组

语法：

array.splice(index, howmany, item1, ....., itemX)

参数：

参数	描述
index	必需，规定从何处添加/删除元素。该参数是开始插入和（或）删除的数组元素的下标，必须是数字（如果传递传递 undefined ，则会被转换为 0 ）
howmany	可选，规定应该删除多少元素。必须是数字，但可以是 "0"和负数。如果未规定此参数，则删除从 index开始到原数组结尾的所有元素
item1, …, itemX	可选，要添加到数组的新元素

注意：使用splice()进行添加时，如果第二个参数为0或者负数，意思是不替换原数据，否则直接替换元素

//情况一
let fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1,"Lemon","Kiwi"); // ['Banana', 'Orange', 'Lemon', 'Kiwi', 'Mango']

//情况二
let fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,2,"Lemon","Kiwi"); // ['Banana', 'Orange', 'Lemon', 'Kiwi']

//情况三，这种类似于将Lemon传给了第二个参数（危险用法）
let fruits = ['Banana', 'Orange', 'Apple', 'Mango']
fruits.splice(2, 'Lemon', 'Kiwi'); // [ 'Banana', 'Orange', 'Kiwi', 'Apple', 'Mango' ]

sort( )

sort() 方法用于对数组的元素进行排序，排序顺序可以是字母或数字。默认排序是将元素转换为字符串，然后按照它们的 UTF-16 码元值升序排序（升序时，"40"将排在"5"前面）

使用数字排序，你必须通过一个函数作为参数来调用，函数指定数字是按照升序还是降序排列

注意： 这种方法会改变原数组，toSorted()是其不改变原数组的复制版本

返回值：

sort() 会修改原数组项的排序，sort() 结束后会返回一个数组结果，这个结果其实就是原数组。并不是返回一个新的数组

语法：

array.sort(compareFn(a, b))

参数：

参数	描述
compareFn	可选，规定排序顺序，必须是函数
a，b	a：用于比较的第一个元素，不会是 `undefined` b：用于比较的第二个元素，不会是 `undefined`

compareFn(a, b) 返回值：

`compareFn(a, b)` 返回值	排序顺序
> 0	a`在`b`后，如`[b, a]
< 0	a`在`b`前，如`[a, b]
=== 0	保持 `a` 和 `b` 原来的顺序

比较函数形式：

function compareFn(a, b) {
  if (根据排序标准，a 小于 b) {
    return -1;
  }
  if (根据排序标准，a 大于 b) {
    return 1;
  }
  // a 一定等于 b
  return 0;
}

示例：

//数字升序
let points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b}); //降序只需要把a-b改为b-a

//字符升序
let fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort(); //默认为升序：['Apple', 'Banana', 'Mango', 'Orange']
fruits.reverse(); //将得到的字符串反转即可得到降序 ['Orange', 'Mango', 'Banana', 'Apple']

//对象数组的排序
const items = [
  { name: "Edward", value: 21 },
  { name: "Sharpe", value: 37 },
  { name: "And", value: 45 },
  { name: "The", value: -12 },
  { name: "Magnetic", value: 13 },
  { name: "Zeros", value: 37 },
];
// 根据 value 排序
items.sort((a, b) => a.value - b.value);

// 根据 name 排序
items.sort((a, b) => {
  const nameA = a.name.toUpperCase(); // 忽略大小写
  const nameB = b.name.toUpperCase(); // 忽略大小写
  if (nameA < nameB) {
    return -1;
  }
  if (nameA > nameB) {
    return 1;
  }
  // name 必须相等
  return 0;
});

reverse( )

reverse()方法用于颠倒数组中元素的顺序

注意： 此方法改变原数组

返回值：

返回颠倒后的原数组

语法：

array.reverse()

参数：

类型	描述
Array	颠倒顺序后的数组

示例：

let fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse() //['Mango', 'Apple', 'Orange', 'Banana']

fill( )

fill() 方法用于将一个固定值替换数组的元素

注意： 此方法改变原数组

返回值：

返回改变后的原数组

语法：

array.fill(value, start, end)

参数：

参数	描述
value	必需，填充的值
start	可选，开始填充位置
end	可选，停止填充位置，不包括end (默认为array.length)

示例：

//写明start和end（不包括end索引）
let fruits = ['Banana', 'Orange', 'Apple', 'Mango'];
fruits.fill('Runoob', 0, 2); //['Runoob', 'Runoob', 'Apple', 'Mango']

//不写明
let fruits = ['Banana', 'Orange', 'Apple', 'Mango'];
fruits.fill('Runoob'); //['Runoob', 'Runoob', 'Runoob', 'Runoob']

不改变原数组

forEach( )

forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数

注意：forEach()对于空数组是不会执行回调函数的

注意：forEach()没有返回值

语法：

array.forEach(callbackFn(currentValue, index, arr), thisValue)

参数	描述
callbackFn(currentValue, index, arr)	必需，数组中每个元素需要调用的函数。函数参数：currentValue必需，当前元素的索引值index可选，当前元素所属的数组对象arr可选
thisValue	可选，传递给函数的值一般用`this`值。如果这个参数为空，`undefined`会传递给`this`值

indexOf( )

indexOf() 方法可返回数组中某个指定的元素位置

该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）

返回值：

如果找到一个 item，则返回 item 的第一次出现的位置（索引）。如果在数组中没找到指定元素则返回 -1

语法：

let num = new Number(value);
//注意： 如果一个参数值不能转换为一个数字将返回 NaN (非数字值)

参数：

参数	描述
searchvalue	必需，规定需检索的字符串值
start	可选的整数参数，规定在字符串中开始检索的位置。取值是 0 到 string Object.length - 1 。如省略该参数，则将从字符串的首字符开始检索

filter( )

filter() 方法（过滤）创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素

注意：filter() 不会对空数组进行检测

注意：filter() 不会改变原始数组

返回值：

返回符合条件的新数组

语法：

array.filter(function(currentValue, index, arr), thisValue)

参数：

参数	描述
function(currentValue, index,arr)	必须，数组中的每个元素都会执行这个函数。函数参数：currentValue必须，当前元素的值index可选，当前元素属于的数组对象arr可选
thisValue	可选，对象作为该执行回调时使用，传递给函数，用作`this`的值。如果省略了 thisValue ，`this`的值为`undefined`

示例：

//获取全部偶数
let arr = [56, 15, 48, 3, 7];
let newArr = arr.filter(function (value, index, array) {
    return value % 2 === 0;
});
console.log(newArr)// [56, 48]

//数组去重
function unique(arr) {
  return arr.filter(function(item, index, arr) {
    //当前元素，在原始数组中的第一个索引==当前索引值，否则返回当前元素
    return arr.indexOf(item, 0) === index;
  });
}
var arr = [1,1,'RUNOOB','RUNOOB',true,true,15];
console.log(unique(arr))// [1, "RUNOOB", true, 15]

//去除数组空值
let  newrr = ['','',1,2,3]
var newArr = newrr.filter(item => item)//这里的return为判断条件，为真则放在新的数组中
console.log(newArr)//[1,2,3]

map( )

map() 方法（加工）按照原始数组元素顺序依次处理元素

注意：map() 不会对空数组进行检测

注意：map() 不会改变原始数组

返回值：

返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值

语法：

array.map(function(currentValue, index, arr), thisValue)

参数：

参数	描述
function(currentValue, index,arr)	必须，数组中的每个元素都会执行这个函数。函数参数：currentValue必须，当前元素的值index可选，当前元素属于的数组对象arr可选
thisValue	可选，对象作为该执行回调时使用，传递给函数，用作`this`的值。如果省略了 thisValue，或者传入`null、undefined`，那么回调函数的`this`为全局对象

示例：

//map对原数组加工
[4, 9, 16, 25].map((item) => Math.sqrt(item)) //[2, 3, 4, 5]

//面试题补充
let newArr = ['1', '2', '3'].map(parseInt)
console.log(newArr) //[1, NaN, NaN]

//原理：parseInt(string, radix)，接收两个参数。string：要转化的字符串；radix：要转化的进制数(将这个字符串转为多少进制的数，默认为 10，即将字符串转为十进制的数)，radix 的范围 为 2-36的整数， 超出这个返回将返回 NaN。
//当 map() 中的函数可以接收参数时，map() 函数会自动把参数传递进去，所以三次执行顺序，parseInt() 接收的三次参数分别是:[parseInt('1', 0), parseInt('2', 1), parseInt('3', 2)]。

相同点：filter 和 map都是对数组的操作，均返回一个新的数组

不同点：filter是满足条件的留下，是对原数组的过滤；map则是对原数组的加工，映射成一一映射的新数组

补充：

map最常见的用法就是遍历一个数组，返回一个新的数组。除此之外，map还可以这样用：

（1）map(Number)：将 string 数组转换为 number 数组

（2）map(String)：将 number 数组转成 string 数组

find( )

find()方法返回通过测试（函数内判断）的数组的第一个元素的值

find()方法为数组中的每个元素都调用一次函数执行

注意： find()对于空数组，函数是不会执行的

注意： find()并没有改变数组的原始值

注意： find()返回的元素如果是复杂数据类型，修改返回的元素，原数组中对应的元素也会更新，这里是因为引用的是同一个对象，属于浅拷贝

返回值：

当数组中的元素在测试条件时返回 true 时，find()返回符合条件的元素，之后的值不会再调用执行函数，如果没有符合条件的元素返回 undefined

语法：

array.find(function(currentValue, index, arr),thisValue)

参数：

参数	描述
function(currentValue, index,arr)	必须，数组中的每个元素都会执行这个函数。函数参数：currentValue必须，当前元素的值index可选，当前元素属于的数组对象arr可选
thisValue	可选，传递给函数的值一般用`this`值。如果这个参数为空，`undefined`会传递给`this`值

示例：

const array1 = [5, 12, 8, 130, 44];
const found = array1.find(element => element > 10);
console.log(found);// Expected output: 12

//浅拷贝影响原对象情况
const goods = [
    {
        name: '苹果',
        price: 9999,
    },
    {
        name: '黄瓜',
        price: 8888,
    },
    {
        name: '雪梨',
        price: 8888,
    },
];
const result = goods.find((item, index) => item.name === '苹果');
console.log(result); //{name: '苹果', price: 9999}
result.price++;
console.log(goods); 
//{name: '苹果', price: 10000},{name: '黄瓜', price: 8888},{name: '雪梨', price: 8888}

find与findIndex：用法完全一样，只不过find是找元素（找不到返回 undefined ），findIndex是找索引（找不到返回 -1 ）

find和filter的区别：

返回值不一样, filter返回的是数组find返回的是数组元素
查找方式不一样, filter是查找所有满足条件的数组元素, find只查找第一个满足条件的, 找到就终止查找

every( )

every()方法用于检测数组所有元素是否都符合指定条件（通过函数提供）

every()方法使用指定函数检测数组中的所有元素

注意： every()不会对空数组进行检测，数组为空则返回true

注意： every()不会改变原始数组

返回值：

如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。如果所有元素都满足条件，则返回 true

语法：

array.every(function(currentValue, index, arr), thisValue)

参数：

参数	描述
function(currentValue, index,arr)	必须，数组中的每个元素都会执行这个函数。函数参数：currentValue必须，当前元素的值index可选，当前元素属于的数组对象arr可选
thisValue	可选，对象作为该执行回调时使用，传递给函数，用作`this`的值。如果省略了 thisValue ，`this`的值为`undefined`

示例：

//写法一
const isBelowThreshold = (currentValue) => currentValue < 40;
const array1 = [1, 30, 39, 29, 10, 13];
console.log(array1.every(isBelowThreshold));// Expected output: true
//写法二
const arr = [10, 20, 30]
console.log(arr.every(item => item >= 11))// Expected output: false

every与some区别：

every所有数组元素满足条件则返回 true , 只要有一个不满足条件就返回 false （有一个不满足就停止），如果数组为空则返回 true
some只要有一个数组元素满足条件则返回 true , 都不满足则返回 false （都不满足才停止），如果数组为空则返回 false
对于some和every遍历空数组返回值的辅助理解：some的作用是找元素是否存在，因此数组为空时返回 false ，every是判断是否都满足条件，因此数组为空时返回 true

slice( )

slice() 方法可从已有的数组中返回选定的元素

slice() 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分

注意： slice() 方法不会改变原数组

返回值：

返回一个新的数组，包含从 start（包括该元素）到 end（不包括该元素）的 arrayObject 中的元素

语法：

array.slice(start, end)

参数：

参数描述

start 可选，规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）

end 可选，规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从start到数组结束的所有元素。如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）

参数	描述
start	可选，规定从何处开始选取。如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，`slice(-2)` 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）
end	可选，规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从start到数组结束的所有元素。如果该参数为负数，则它表示在原数组中的倒数第几个元素结束抽取。 `slice(-2,-1)` 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）

示例：

//菜鸟教程
let fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
let myBest = fruits.slice(-3,-1); // 截取倒数第三个（包含）到倒数第一个（不包含）的两个元素
let myBest = fruits.slice(-3);  // 截取最后三个元素

//MDN
const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];
console.log(animals.slice(2)); // ["camel", "duck", "elephant"]
console.log(animals.slice(2, 4)); // ["camel", "duck"]
console.log(animals.slice(1, 5)); // ["bison", "camel", "duck", "elephant"]
console.log(animals.slice(-2)); // ["duck", "elephant"]
console.log(animals.slice(2, -1)); // ["camel", "duck"]
console.log(animals.slice()); // ["ant", "bison", "camel", "duck", "elephant"]

concat( )

concat() 方法用于连接两个或多个数组

注意： 该方法不会改变原数组

返回值：

返回一个新的数组

语法：

array1.concat(array2, array3, ..., arrayX)

参数：

参数	描述
array2, array3,…, arrayX	必需，需要连接的数组

示例：

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = ['g', 'h', 'i'];
const array4 = array1.concat(array2, array3);
console.log(array4);  // 输出：['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']

join( )

join() 方法用于把数组中的所有元素转换一个字符串

元素是通过指定的分隔符（separator）进行分隔的

注意： 该方法不会改变原数组

返回值：

返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入 separator（分隔符）字符串 而生成的

语法：

array.join(separator)

参数：

参数	描述
separator	可选，指定要使用的分隔符。如果省略该参数，则使用逗号作为分隔符

示例：

//无参数
let fruits = ['Banana', 'Orange', 'Apple', 'Mango'];
console.log(fruits.join()); //Banana,Orange,Apple,Mango

//有参数
let fruits = ["Banana", "Orange", "Apple", "Mango"];
let energy = fruits.join(" and ");
console.log(energy);//Banana and Orange and Apple and Mango

reduce( )

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值

reduce()` 方法对数组中的每个元素按序执行一个提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值

第一次执行回调函数时，不存在“上一次的计算结果”。如果需要回调函数从数组索引为 0 的元素开始执行，则需要传递初始值。否则，数组索引为 0 的元素将被用作初始值，迭代器将从第二个元素开始执行（即从索引为 1 而不是 0 的位置开始）

注意: reduce() 对于空数组是不会执行回调函数的

不改变原数组

语法：

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

参数：

参数	描述
function(total,currentValue, index,arr)	必需，用于执行每个数组元素的函数函数参数：参数描述total必需，为初始值，或者计算结束后的返回值。当前元素currentValue必需。当前元素的索引currentIndex可选。当前元素所属的数组对象arr可选
initialValue	可选，传递给函数的初始值

示例：

// 0 + 1 + 2 + 3 + 4
const initialValue = 0;
const sumWithInitial = array1.reduce(
(accumulator, currentValue) => accumulator + currentValue,
initialValue
);
console.log(sumWithInitial); // Expected output: 10

const arr = [1, 2, 3, 6]
// 有初始值的情况
const sum = arr.reduce((prev, item) => prev + item, 0)
console.log(sum) //12
// 无初始值的情况: 直接从第二个元素开始遍历, 将第一个元素作为初始值传入 prev
const sum2 = arr.reduce((prev, item) => {
    console.log(prev, item)
    return prev + item
})
console.log(sum2) //12

reduce详细讲解：

reduce 方法是处理数组更通用的方式，而且 filter 和 map 方法都可以当作是 reduce 的特殊实现。 reduce 方法遍历数组中的每个项目并返回单个值（即字符串、数字、对象、数组）。这是通过在每次迭代中调用一个回调函数来实现的

回调函数接受四个参数。第一个参数称为叠加器，它是上一次迭代中回调函数的返回值，第二个参数是当前正在处理的数组元素，第三个参数是该参数的索引，第四个参数是在其上调用 reduce 方法的数组

除了回调函数，reduce 还有一个额外的参数作为叠加器的初始值。如果没有第二个参数，会跳过第一次迭代，第二次迭代给叠加器传入数组的第一个元素

字符串方法

String 对象用于处理文本（字符串）

String 对象创建方法： new String()

语法：

let txt = new String("string");
let txt = "string";

正则相关

search( )

search() 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串

返回值：

与指定查找的字符串或者正则表达式相匹配的 String 对象起始位置，如果没有找到任何匹配的子串，则返回 -1

语法：

string.search(searchvalue)

参数：

参数	描述
searchvalue	必需，查找的字符串或者正则表达式

示例：

//执行一次对大小写敏感的查找:
let str="Mr. Blue has a blue house";
console.log(str.search("blue")); //15

//执行一次忽略大小写的检索:
let str="Mr. Blue has a blue house";
console.log(str.search(/blue/i)); //对大小匹配不敏感，4

match( )

match()方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配

注意： match()方法将检索字符串 String Object ，以找到一个或多个与 regexp 匹配的文本。这个方法的行为在很大程度上有赖于 regexp 是否具有标志 g 。如果 regexp 没有标志 g ，那么match()方法就只能在 stringObject 中执行一次匹配。如果没有找到任何匹配的文本，match()将返回 null 。否则，它将返回一个数组，其中存放了与它找到的匹配文本有关的信息

返回值：

存放匹配结果的数组，该数组的内容依赖于 regexp 是否具有全局标志 g，如果没找到匹配结果返回 null

如果使用 g 标志，则将返回与完整正则表达式匹配的所有结果，但不会返回捕获组

如果未使用 g 标志，则仅返回第一个完整匹配及其相关的捕获组（Array）。在这种情况下，返回的项目将具有如下所述的其他属性

语法：

string.match(regexp)

参数：

参数	描述
regexp	必需，规定要匹配的模式的 RegExp 对象。如果该参数不是 RegExp 对象，则需要首先把它传递给 RegExp 构造函数，将其转换为 RegExp 对象

示例：

let str="The rain in SPAIN stays mainly in the plain"
let n=str.match(/ain/gi); //ain,AIN,ain,ain

//如果未使用 g 标志，则仅返回第一个完整匹配及其相关的捕获组（Array）。在这种情况下，返回的项目将具有如下所述的其他属性
const repeatStr = 'row row row oh row row'
const repeatRegex = /(\w+) \1 \1/
console.log(repeatRegex.test(repeatStr)) //true
console.log(repeatStr.match(repeatRegex)) //["row row row", "row"]

replace( )

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串

注意： 该方法不会改变原始字符串

返回值：

一个新的字符串，是用 replacement 替换了 regexp 的第一次匹配或所有匹配之后得到的

语法：

string.replace(searchvalue, newvalue)

参数：

参数	描述
searchvalue	必需，规定子字符串或要替换的模式的 RegExp 对象。如果该值是一个字符串，则将它作为要检索的直接量文本模式，而不是首先被转换为 RegExp 对象
newvalue	必需，一个字符串值。规定了替换文本或生成替换文本的函数

示例：

//正则全局替换
let str = "Mr Blue has a blue house and a blue car";
let n = str.replace(/blue/g,"red");

//基本用法
let str = "Visit Microsoft! Visit Microsoft!";
let n = str.replace("Microsoft","Runoob"); //Visit Runoob!Visit Microsoft!

split( )

split() 方法用于把一个字符串分割成字符串数组

如果把空字符串 (“”) 用作 separator ，那么 stringObject 中的每个字符之间都会被分割

注意： split() 方法不改变原始字符串

返回值：

一个字符串数组。该数组是通过在 separator 指定的边界处将字符串 string Object 分割成子串创建的。返回的数组中的字串不包括 separator 自身

语法：

string.split(separator, limit)

参数：

参数	描述
separator	可选，字符串或正则表达式，从该参数指定的地方分割 string Object
limit	可选，该参数可指定返回的数组的最大长度。如果设置了该参数，返回的子串不会多于这个参数指定的数组。如果没有设置该参数，整个字符串都会被分割，不考虑它的长度

示例：

//省略分割参数
let str1 = "How are you doing today?";
let n1 = str1.split();//['How are you doing today?']

//分割每个字符，包括空格
let str2 = "How are you doing today?";
let n2 = str2.split(""); //['H', 'o', 'w', ' ', 'a', 'r', 'e', ' ', 'y', 'o', 'u', ' ', 'd', 'o', 'i', 'n', 'g', ' ', 't', 'o', 'd', 'a', 'y', '?']

//分割路径
let str3 = "/goods/add/";
let n3 = str3.split("/"); //['', 'goods', 'add', '']

//使用 limit 参数
let str4 = "How are you doing today?";
let n4 = str3.split(" ",3); //['How', 'are', 'you']

//使用一个字符作为分隔符
let str5 ="How are you doing today?";
let n5 = str4.split("o"); //['H', 'w are y', 'u d', 'ing t', 'day?']

基本方法

charAt( )

charAt()` 方法可返回指定位置的字符

第一个字符位置为 0，第二个字符位置为 1，以此类推

返回值：

返回在指定位置的字符

语法：

string.charAt(index)

参数：

参数	描述
index	必需，表示字符串中某个位置的数字，即字符在字符串中的位置

示例：

let str = "HELLO WORLD";
let n = str.charAt(2) //L

concat( )

concat()` 方法用于连接两个或多个字符串

注意： 该方法没有改变原有字符串

返回值：

返回连接两个或多个字符串新字符串

语法：

string.concat(string1, string2, ..., stringX)

参数：

参数	描述
string1, string2, …, stringX	必需，将被连接为一个字符串的一个或多个字符串对象描述

示例：

let str1="Hello ";
let str2="world!";
let str3=" Have a nice day!";
let n = str1.concat(str2,str3); //Hello world! Have a nice day!

endsWith( )

endsWith() 方法用来判断当前字符串是否是以指定的子字符串结尾的（区分大小写）

返回值：

如果字符串以指定的值结尾返回 true ，否则返回 false

语法：

string.endsWith(searchvalue, length)

参数：

参数	描述
searchvalue	必需，要搜索的子字符串
length	设置字符串的长度，默认值为原始字符串长度 string.length

示例：

let str = "To be, or not to be, that is the question.";

str.endsWith("question.");  // true
str.endsWith("to be");      // false
str.endsWith("to be", 19);  // true

startsWith()用法与endsWith()类似，这里不再赘述

indexOf( )

indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置

注意： indexOf() 方法区分大小写

返回值：

查找指定字符串第一次出现的位置，如果没找到匹配的字符串则返回 -1

语法：

string.indexOf(searchvalue, start)

参数：

参数	描述
searchvalue	必需，规定需检索的字符串值
start	可选的整数参数，规定在字符串中开始检索的位置。取值是 0 到 string Object.length - 1 。如省略该参数，则将从字符串的首字符开始检索

示例：

//不带start参数
let str = "Hello world, welcome to the universe.";
let n = str.indexOf("e"); //1

//带start参数
let str = "Hello world, welcome to the universe.";
let n = str.indexOf("e",5); //14

includes( )

includes()` 方法用于判断字符串是否包含指定的子字符串

注意： includes() 方法区分大小写

返回值：

如果找到匹配的字符串返回 true，否则返回 false

语法：

string.includes(searchvalue, start)

参数：

参数	描述
searchvalue	必需，要查找的字符串
start	可选，设置从那个位置开始查找，默认为 0

示例：

let str = "Hello world, welcome to the Runoob.";
let n = str.includes("world", 12); //false

repeat( )

repeat() 方法可以把字符串复制指定次数

注意： 不改变原字符串

返回值：

返回复制指定次数并连接在一起的字符串

语法：

string.repeat(count)

参数：

参数	描述
count	必需，设置要复制的次数

示例：

let str = "Runoob";
str.repeat(2); //RunoobRunoob

slice( )

slice(start, end) 方法可提取字符串的某个部分，并以新的字符串返回被提取的部分

返回值：

提取的字符串

语法：

string.slice(start, end)

参数：

参数	描述
start	必需，要抽取的片断的起始下标，第一个字符位置为 0。如果为负数，则从尾部开始截取
end	可选，紧接着要截取的片段结尾的下标。若未指定此参数，则要提取的子串包括start到原字符串结尾的字符串。如果该参数是负数，那么它规定的是从字符串的尾部开始算起的位置。`slice(-2)` 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）

示例：

//提取所有字符串
let str = "Hello world!";
let n = str.slice(0); //Hello world!

//从字符串的第3个位置提取字符串片段
let str = "Hello world!";
let n = str.slice(3); //lo world!

//从字符串的第3个位置到第8个位置直接的字符串片段
let str = "Hello world!";
let n = str.slice(3,8); //lo wo

//提取最后一个字符和最后两个字符(-1 + str.length)、(-2 + str.length)
let str = "Hello world!";
let n = str.slice(-1); //!
let n2 = str.slice(-2); //d!

substr( )

substr()方法可在字符串中抽取从开始下标开始的指定数目的字符

提示：substr()的参数指定的是子串的开始位置和长度，官网目前已经弃用，不过仍可以使用（推荐substring）

返回值：

返回对应的子串

语法：

string.substr(start, length)

参数：

参数	描述
start	必需，要抽取的子串的起始下标。必须是数值。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。也就是说，-1 指字符串中最后一个字符，-2 指倒数第二个字符，以此类推
length	可选，子串中的字符数。必须是数值。如果省略了该参数，那么返回从 stringObject 的开始位置到结尾的字串

示例：

var str = "abcdefghij";

console.log("(1,2): "    + str.substr(1,2));   // (1,2): bc
console.log("(-3,2): "   + str.substr(-3,2));  // (-3,2): hi
console.log("(-3): "     + str.substr(-3));    // (-3): hij
console.log("(1): "      + str.substr(1));     // (1): bcdefghij
console.log("(-20, 2): " + str.substr(-20,2)); // (-20, 2): ab
console.log("(20, 2): "  + str.substr(20,2));  // (20, 2):

substring( )

substring() 方法用于提取字符串中介于两个指定下标之间的字符

substring() 方法返回的子串包括开始处的字符，但不包括结束处的字符

注意： substring()方法不会改变原字符串

返回值：

返回对应的子串

语法：

string.substring(from, to)

参数：

参数	描述
from	必需，一个非负的整数，规定要提取的子串的第一个字符在 string Object 中的位置。
to	可选，一个非负的整数，比要提取的子串的最后一个字符在 string Object 中的位置多 1(不包含to)。如果省略该参数，那么返回的子串会一直到字符串的结尾

示例：

let str="Hello world!";
console.log(str.substring(3)); //lo world!
console.log(str.substring(3,7)); //lo w

toLowerCase( )

toLowerCase() 方法用于把字符串转换为小写

返回值：

不改变原字符串，返回转换后的新字符串

语法：

string.toLowerCase()

示例：

let str="Runoob";
console.log(str.toLowerCase());

字符全部转换为大写：toUpperCase()

trim( )

trim()` 方法用于删除字符串的头尾空白符，空白符包括：空格、制表符 tab、换行符等其他空白符等

trim()` 方法不会改变原始字符串

trim() 方法不适用于null, undefined, Number`类型

返回值：

返回移除头尾空格的字符串

语法：

string.trim()

示例：

var str = "       Runoob        ";
console.log(str.trim());//Runoob

Number对象

Number 对象是原始数值的包装对象

Number 创建方式 new Number()

语法：

let num = new Number(value);
//注意： 如果一个参数值不能转换为一个数字将返回 NaN (非数字值)

Number常见属性

属性	描述
MAX_VALUE	可表示的最大的数。
MIN_VALUE	可表示的最小的数。
NEGATIVE_INFINITY	负无穷大，溢出时返回该值。
NaN	非数字值。
POSITIVE_INFINITY	正无穷大，溢出时返回该值。

Number常见方法：

方法	描述
isFinite	检测指定参数是否为无穷大。
isInteger	检测指定参数是否为整数。
isNaN	检测指定参数是否为 NaN。
isSafeInteger	检测指定参数是否为安全整数。
toFixed(x)	把数字转换为字符串，结果的小数点后有指定位数的数字。
toString()	把数字转换为字符串，使用指定的基数
valueOf()	返回一个 Number 对象的基本数字值。

Boolean对象

toString( )

toString() 方法可把一个逻辑值转换为字符串，并返回结果

注意： 当需要把 Boolean 对象转换成字符串的情况 JavaScript 会自动调用此方法

语法：

boolean.toString()

返回值：

Type	描述
String	“true” 或者 “false”

示例：

let bool = new Boolean(1);
let myvar = bool.toString(); //'true'

valueOf( )

valueOf() 方法可返回 Boolean 对象的原始值

返回值：

true 或者false

语法：

boolean.valueOf()

返回值：

Type	描述
Boolean	true 或者 false

示例：

let bool = new Boolean(0);
let myvar = bool.valueOf(); //true

Math对象

Math 对象用于执行数学任务

Math 对象并不像 Date 和 String 那样是对象的类，因此没有构造函数 Math( )

Math对象方法

方法	描述
abs(x)	返回 x 的绝对值。
acos(x)	返回 x 的反余弦值。
asin(x)	返回 x 的反正弦值。
atan(x)	以介于 -PI/2 与 PI/2 弧度之间的数值来返回 x 的反正切值。
atan2(y,x)	返回从 x 轴到点 (x,y) 的角度（介于 -PI/2 与 PI/2 弧度之间）。
ceil(x)	对数进行上舍入。
cos(x)	返回数的余弦。
exp(x)	返回 Ex 的指数。
floor(x)	对 x 进行下舍入。
log(x)	返回数的自然对数（底为e）。
max(x,y,z,…,n)	返回 x,y,z,…,n 中的最高值。
min(x,y,z,…,n)	返回 x,y,z,…,n中的最低值。
pow(x,y)	返回 x 的 y 次幂。
random()	返回 0 ~ 1 之间的随机数。
round(x)	四舍五入。
sin(x)	返回数的正弦。
sqrt(x)	返回数的平方根。
tan(x)	返回角的正切。
tanh(x)	返回一个数的双曲正切函数值。
trunc(x)	将数字的小数部分去掉，只保留整数部分。