常用数组、字符串、数学运算相关API

数组相关

// concat()	连接两个或更多的数组，并返回结果。
// copyWithin()	从数组的指定位置拷贝元素到数组的另一个指定位置中。
// entries()	返回数组的可迭代对象。
// every()	检测数值元素的每个元素是否都符合条件。
// fill()	使用一个固定值来填充数组。
// filter()	检测数值元素，并返回符合条件所有元素的数组。
// find()	返回符合传入测试（函数）条件的数组元素。
// findIndex()	返回符合传入测试（函数）条件的数组元素索引。
// forEach()	数组每个元素都执行一次回调函数。
// from()	通过给定的对象中创建一个数组。
// includes()	判断一个数组是否包含一个指定的值。
// indexOf()	搜索数组中的元素，并返回它所在的位置。
// isArray()	判断对象是否为数组。
// join()	把数组的所有元素放入一个字符串。
// keys()	返回数组的可迭代对象，包含原始数组的键(key)。
// lastIndexOf()	搜索数组中的元素，并返回它最后出现的位置。
// map()	通过指定函数处理数组的每个元素，并返回处理后的数组。
// pop()	删除数组的最后一个元素并返回删除的元素。
// push()	向数组的末尾添加一个或更多元素，并返回新的长度。
// reduce()	将数组元素计算为一个值（从左到右）。
// reduceRight()	将数组元素计算为一个值（从右到左）。
// reverse()	反转数组的元素顺序。
// shift()	删除并返回数组的第一个元素。
// slice()	选取数组的的一部分，并返回一个新数组。
// some()	检测数组元素中是否有元素符合指定条件。
// sort()	对数组的元素进行排序。
// splice()	从数组中添加或删除元素。
// toString()	把数组转换为字符串，并返回结果。
// unshift()	向数组的开头添加一个或更多元素，并返回新的长度。
// valueOf()	返回数组对象的原始值。


// concat()	连接两个或更多的数组，并返回结果。
var hege = ["Cecilie", "Lone"];
var stale = ["Emil", "Tobias", "Linus"];
var kai = ["Robin"];
var children = hege.concat(stale,kai);//Cecilie,Lone,Emil,Tobias,Linus,Robin

// copyWithin()	从数组的指定位置拷贝元素到数组的另一个指定位置中。
//array.copyWithin(target, start, end) target	必需。复制到指定目标索引位置。start	可选。元素复制的起始位置。end	可选。停止复制的索引位置 (默认为 array.length)。如果为负值，表示倒数。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.copyWithin(2, 0);//Banana,Orange,Banana,Orange
var fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi", "Papaya"];
fruits.copyWithin(2, 0, 2);//Banana,Orange,Banana,Orange,Kiwi,Papaya

// entries()	返回数组的可迭代对象。该对象包含数组的键值对 (key/value)。迭代对象中数组的索引值作为 key， 数组元素作为 value。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x=fruits.entries();//数组本身无变化
// [0, "Banana"]
// [1, "Orange"]
// [2, "Apple"]
// [3, "Mango"]


// every()	检测数值元素的每个元素是否都符合条件。检测所有元素，有一个不符合返回false
var ages = [32, 33, 16, 40];
function checkAdult(age) {
    return age >= 18;
}
var x=ages.every(checkAdult)//false

// fill()	使用一个固定值来填充数组。
//array.fill(value, start, end) value	必需。填充的值。start	可选。开始填充位置。end	可选。停止填充位置 (默认为 array.length)
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob");//Runoob,Runoob,Runoob,Runoob
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4);//Banana,Orange,Runoob,Runoob


// filter()	检测数值元素，并返回符合条件所有元素的数组。
var ages = [32, 33, 16, 40];
function checkAdult(age) {
    return age >= 18;
}
var x=ages.filter(checkAdult)//32,33,40

// find()	返回通过测试（函数内判断）的数组的第一个元素的值.如果没有符合条件的元素返回 undefined
// findIndex()	返回符合传入测试（函数）条件的数组元素索引。
var ages = [3, 10, 18, 20];
function checkAdult(age) {
    return age >= 18;
}
var x= ages.find(checkAdult);//18 //获取数组中年龄大于 18 的第一个元素
var x=ages.findIndex(checkAdult);//2 

// forEach()	数组每个元素都执行一次回调函数。
var numbers = [4, 9, 16, 25];
function myFunction(item, index) {
    return "index[" + index + "]: " + item; 
}
numbers.forEach(myFunction) //0:4 1:9 2:16 3:25
var sum=0;
function myFunction(item) {
  sum += item;
  return sum;
}
var x=numbers.forEach(myFunction)//125

// from()	通过给定的对象中创建一个数组。
var myArr = Array.from("RUNOOB");//["R","U","N","o","o","B"]

//Array.from相关方法
const LEN = 3;
const arr1 = new Array(LEN).fill(false);
console.log(arr1)
//Array.from
let arr = [1,2,3,4,5,6,7,8,9]
let set = new Set(arr)
console.log(Array.from(set, item => item + 1)) // [2,3,4,5,6,7,8,9,10]

let  str = 'hello world!';
console.log(Array.from(str)) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d", "!"]

const myMap = new Map().set(true, 7)
console.log(myMap); //Map(1) {true => 7}
console.log([...myMap]); //[true ,7]

let dp=Array.from(new Array(5),()=>new Array(4).fill(0))//初始化一个5*4的二维数组
console.log(dp);

// includes()	判断一个数组是否包含一个指定的值。
//arr.includes(searchElement, fromIndex) searchElement	必须。需要查找的元素值。 fromIndex	可选。从该索引处开始查找 searchElement。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
let site = ['runoob', 'google', 'taobao'];
site.includes('runoob'); // true 
site.includes('baidu'); // false
var arr = ['a', 'b', 'c'];
arr.includes('c', 3);   //false
arr.includes('c', 100); // false //如果fromIndex 大于等于数组长度 ，则返回 false 。该数组不会被搜索:
arr.includes('a', -100); // true //如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。如果计算出的索引小于 0，则整个数组都会被搜索。

// indexOf()	搜索数组中的元素，并返回它所在的位置。
// lastIndexOf()	搜索数组中的元素，并返回它最后出现的位置。
//array.indexOf(item,start) item	必须。查找的元素。 start	可选的整数参数。规定在数组中开始检索的位置。它的合法取值是 0 到 stringObject.length - 1。如省略该参数，则将从字符串的首字符开始检索。
var fruits = ["Banana", "Orange",  "Apple", "Mango"];
var a = fruits.indexOf("Apple");//2
var a = fruits.lastIndexOf("Apple");//2
var fruits=["Banana","Orange","Apple","Mango","Banana","Orange","Apple"];
var a = fruits.indexOf("Apple",4);//6

// isArray()	判断对象是否为数组。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x = Array.isArray(fruits);//true

// join()	把数组的所有元素放入一个字符串。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join();//Banana,Orange,Apple,Mango
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var energy = fruits.join(" and ");//Banana and Orange and Apple and Mango

// keys()	返回数组的可迭代对象，包含原始数组的键(key)。 如果对象是数组返回 true，否则返回 false。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var x=fruits.keys();//0 1 2

//map()	通过指定函数处理数组的每个元素，并返回处理后的数组。 
//map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
//map() 方法按照原始数组元素顺序依次处理元素。
// 注意： map() 不会对空数组进行检测。
// 注意： map() 不会改变原始数组。
var numbers = [4, 9, 16, 25];
function myFunction() {
  var x = numbers.map(Math.sqrt);//2,3,4,5
}
//1、数字数组转化为字符串数组
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
arr.map(String);  //结果： ['1', '2', '3', '4', '5', '6', '7', '8', '9']
//2、字符串数组转化为数字数组
var a = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
a.map(Number);  //结果：[1, 2, 3, 4, 5, 6, 7, 8, 9]

// pop()	删除数组的最后一个元素并返回删除的元素。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();//Banana,Orange,Apple

// push()	向数组的末尾添加一个或更多元素，并返回新的长度。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi")//Banana,Orange,Apple,Mango,Kiwi

// reduce()	将数组元素计算为一个值（从左到右）。
//arr.reduce(function(prev,cur,index,arr){...}, init);
// arr 表示原数组；
// prev 表示上一次调用回调时的返回值，或者初始值 init;
// cur 表示当前正在处理的数组元素；
// index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
// init 表示初始值。
//求数组项之和
var sum = arr.reduce(function (prev, cur) {return prev + cur;},0);
//求数组项最大值
var max = arr.reduce(function (prev, cur) {return Math.max(prev,cur);});
//数组去重
var newArr = arr.reduce(function (prev, cur) { prev.indexOf(cur) === -1 && prev.push(cur); return prev;},[]);

// reverse()	反转数组的元素顺序。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();//fruits 结果输出：Mango,Apple,Orange,Banana

// shift()	删除并返回数组的第一个元素。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()//fruits 结果输出：Orange,Apple,Mango

// slice()	选取数组的的一部分，并返回一个新数组。
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);//Orange,Lemon
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var myBest = fruits.slice(-3,-1);//Lemon,Apple

// sort()	对数组的元素进行排序。数组在原数组上进行排序
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();//fruits 输出结果：Apple,Banana,Mango,Orange
var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});//fruits输出结果： 1,5,10,25,40,100

// splice()	从数组中添加或删除元素。这种方法会改变原始数组。返回值为删除的元素
// /array.splice(index,howmany,item1,.....,itemX) index为从何处添加/删除元素，howmany为删除多少元素，可以为0，未规定则删除到末尾
//注意，for循环中使用splice()进行删除的时候，删除之后需要i--。因为如果有两个连着的元素都需要删除，会只删除第一个，第二个会被跳过。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");//fruits 输出结果 Banana,Orange,Lemon,Kiwi,Apple,Mango
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,2);//fruits 输出结果：Banana,Orange

// toString()	把数组转换为字符串，并返回结果。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.toString();//fruits将输出：Banana,Orange,Apple,Mango

// unshift()	向数组的开头添加一个或更多元素，并返回新的长度。
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon","Pineapple");//fruits 将输出：Lemon,Pineapple,Banana,Orange,Apple,Mango

字符串相关

// charAt()	返回在指定位置的字符。
// charCodeAt()	返回在指定的位置的字符的 Unicode 编码。
// concat()	连接两个或更多字符串，并返回新的字符串。
// fromCharCode()	将 Unicode 编码转为字符。
// indexOf()	返回某个指定的字符串值在字符串中首次出现的位置。
// includes()	查找字符串中是否包含指定的子字符串。
// lastIndexOf()	从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。
// match()	查找找到一个或多个正则表达式的匹配。
// repeat()	复制字符串指定次数，并将它们连接在一起返回。
// replace()	在字符串中查找匹配的子串， 并替换与正则表达式匹配的子串。
// search()	查找与正则表达式相匹配的值。
// slice()	提取字符串的片断，并在新的字符串中返回被提取的部分。
// split()	把字符串分割为字符串数组。
// startsWith()	查看字符串是否以指定的子字符串开头。
// substr()	从起始索引号提取字符串中指定数目的字符。
// substring()	提取字符串中两个指定的索引号之间的字符。
// toLowerCase()	把字符串转换为小写。
// toUpperCase()	把字符串转换为大写。
// trim()	去除字符串两边的空白
// toLocaleLowerCase()	根据本地主机的语言环境把字符串转换为小写。
// toLocaleUpperCase()	根据本地主机的语言环境把字符串转换为大写。
// valueOf()	返回某个字符串对象的原始值。
// toString()	返回一个字符串。

//charAt()	返回在指定位置的字符。
var str = "HELLO WORLD";
var n = str.charAt(2) //L

// concat()	连接两个或更多字符串，并返回新的字符串。
var str1 = "Hello ";
var str2 = "world!";
var n = str1.concat(str2); //Hello world!

// indexOf()	返回某个指定的字符串值在字符串中首次出现的位置。
var str="Hello world, welcome to the universe.";
var n=str.indexOf("welcome");//13

// includes()	查找字符串中是否包含指定的子字符串。
var str = "Hello world, welcome to the Runoob。";
var n = str.includes("world");//true

// lastIndexOf()	从后向前搜索字符串，并从起始位置（0）开始计算返回字符串最后出现的位置。
var str="I am from runoob，welcome to runoob site.";
var n=str.lastIndexOf("runoob");//28

// match()	查找找到一个或多个正则表达式的匹配。返回所有匹配的值
var str="The rain in SPAIN stays mainly in the plain"; 
var n=str.match(/ain/g);//ain,ain,ain

// repeat()	复制字符串指定次数，并将它们连接在一起返回。
var str = "Runoob";
str.repeat(2);//RunoobRunoob

// replace()	在字符串中查找匹配的子串， 并替换与正则表达式匹配的子串。
var str="Visit Microsoft! Visit Microsoft!";
var n=str.replace("Microsoft","Runoob");//Visit Runoob!Visit Microsoft!

// search()	查找与正则表达式相匹配的值。返回首个匹配字符串的位置
var str="Visit Runoob!"; 
var n=str.search("Runoob");//6

// slice()	提取字符串的片断，并在新的字符串中返回被提取的部分。
var str="Hello world!";
var n=str.slice(1,5);//返回字符串的第1个字符到第4个字符//ello
var n=str.slice(0,1);//提取字符串的第一个字符 //H
var n=str.slice(-1);//提取字符串的最后一个字符 //！
var n=str.slice(3);//从字符串的第3个位置提取字符串片段: //lo world!

// split()	把字符串分割为字符串数组。返回一个字符串数组
// string.split(separator,limit) separator为字符串对象，limit为可选参数，指定返回字符串数组的最大长度
var str="How are you doing today?";
var n=str.split(" ");//How,are,you,doing,today?
var n=str.split(" ",3);//How,are,you
var n=str.split("");//分割每个字符 //H,o,w, ,a,r,e, ,y,o,u, ,d,o,i,n,g, ,t,o,d,a,y,?


// startsWith()	查看字符串是否以指定的子字符串开头。
// string.startsWith(searchvalue, start) searchvalue为要查找的字符串，start为可选参数，查询的起始位置
var str = "Hello world, welcome to the Runoob.";
var n = str.startsWith("Hello");//true
var n = str.startsWith("world", 6);//true

// substr()	从起始索引号提取字符串中指定数目的字符。不指定长度，则从起始位置提取到最后
var str="Hello world!";
var n=str.substr(2,3)//llo
var n=str.substr(2)//llo world! 

// substring()	提取字符串中两个指定的索引号之间的字符。返回的子串包括 开始 处的字符，但不包括 结束 处的字符。
var str="Hello world!";
document.write(str.substring(3)+"<br>");//lo world!
document.write(str.substring(3,7));//lo w

// toLowerCase()	把字符串转换为小写。
// toUpperCase()	把字符串转换为大写。
var str="Runoob";
document.write(str.toLowerCase());//runoob
document.write(txt.toUpperCase());//RUNOOB

// trim()	去除字符串两边的空白
var str = "       Runoob        ";
alert(str.trim());//Runoob

// valueOf()	返回某个字符串对象的原始值。
var str="Hello world!";
document.write(str.valueOf());//Hello world!

// toString()	返回一个字符串。
var str = "Runoob";
var res = str.toString();//Runoob
var str = [1,2,3,4];
var res = str.toString();//1,2,3,4 //字符串

数学运算相关

// abs(x)	返回 x 的绝对值。
Math.abs(-7.25);//7.25
var a=Math.abs(7.25);//7.25
var b=Math.abs(-7.25);//7.25
var c=Math.abs(null);//0
var d=Math.abs("Hello");//NaN
var e=Math.abs(2+3);//5

// ceil(x)	对数进行上舍入。
Math.ceil(1.4)//2
var a=Math.ceil(0.60);//1
var b=Math.ceil(0.40);//1
var c=Math.ceil(5);//5
var d=Math.ceil(5.1);//6
var e=Math.ceil(-5.1);//-5
var f=Math.ceil(-5.9);//-5

// floor(x)	对 x 进行下舍入。
var a=Math.floor(0.60);//0
var b=Math.floor(0.40);//0
var c=Math.floor(5);//5
var d=Math.floor(5.1);//5
var e=Math.floor(-5.1);//-6
var f=Math.floor(-5.9);//-6

// exp(x)	返回 Ex 的指数。
var a=Math.exp(-1);//0.36787944117144233
var b=Math.exp(5);//148.4131591025766
var c=Math.exp(10);//22026.465794806718

// log(x)	返回数的自然对数（底为e）。
var a=Math.log(2.7183);//1.0000066849139877
var b=Math.log(2);//0.6931471805599453
var c=Math.log(1);//0
var d=Math.log(0);//-Infinity
var e=Math.log(-1);//NaN

// max(x,y,z,...,n)	返回 x,y,z,...,n 中的最高值。
// min(x,y,z,...,n)	返回 x,y,z,...,n中的最低值。
var a=Math.max(5,10);//10
var b=Math.max(0,150,30,20,38);//150
var c=Math.max(-5,10);//10
var d=Math.max(-5,-10);//-5
var e=Math.max(1.5,2.5);//2.5

// pow(x,y)	返回 x 的 y 次幂。

// random()	返回 0 ~ 1 之间的随机数。
Math.random();//0.11081733578243935
Math.floor((Math.random()*10)+1);//在本例中，我们将取得介于 1 到 10 之间的一个随机数：
Math.floor((Math.random()*100)+1);//在本例中，我们将取得介于 1 到 100 之间的一个随机数：
function getRndInteger(min, max) {//以下函数返回 min（包含）～ max（不包含）之间的数字：
  return Math.floor(Math.random() * (max - min) ) + min;
}
function getRndInteger(min, max) {//以下函数返回 min（包含）～ max（包含）之间的数字：
  return Math.floor(Math.random() * (max - min + 1) ) + min;
}

// round(x)	四舍五入。


// sqrt(x)	返回数的平方根。
var a=Math.sqrt(0);//0
var b=Math.sqrt(1);//1
var c=Math.sqrt(9);//3
var d=Math.sqrt(64);//8
var e=Math.sqrt(-9);//NaN


//parseInt(x) 返回整数