Array方法(汇总)
isArray(obj)
用于确定传递的值是否是一个 Array。
验证方法
Array.isArray([1, 2, 3]);
// true
Array.isArray({foo: 123});
// false
Array.isArray("foobar");
// false
Array.isArray(undefined);
// false
参数
obj 需要检测的值
返回值
如果值是Array 则为true; 否则为false。
join(separator)
方法将一个数组的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。
const elements = ['火', '空气', '水'];
console.log(elements.join());
// "火,空气,水"
console.log(elements.join(''));
// "火空气水"
console.log(elements.join('-'));
// "火-空气-水"
参数
separator 可选 指定分隔符号 该参数默认值为","
返回值
一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串。
注意
如果一个元素为 undefined 或 null，它会被转换为空字符串。
push(element1,...,elementN)
方法将一个或多个元素添加到数组的末尾，并返回该数组的新长度。
var animals = ['猪', '狗', '牛'];
var count = animals.push('大象');
console.log(count);
// 4
console.log(animals);
// ['猪', '狗', '牛','大象']
animals.push('鸡', '鸭', '鹅');
console.log(animals);
//['猪', '狗', '牛', '大象', '鸡', '鸭', '鹅']
参数
elementN 可选多个参数
参数会添加到数组末尾
返回值
当调用该方法时，新的 length 属性值将被返回。
unshift(element1,...,elementN)
方法将一个或多个元素添加到数组的头部，并返回该数组的新长度。
var animals = ['猪', '狗', '牛'];
var count = animals.unshift('大象');
console.log(count);
// 4
console.log(animals);
// ['大象', '猪', '狗', '牛']
animals.unshift('鸡', '鸭', '鹅');
console.log(animals);
//[ '鸡', '鸭' , '鹅','大象','猪', '狗', '牛' ]
参数
elementN 可选多个参数
参数会添加到数组头部
返回值
当调用该方法时，新的 length 属性值将被返回。
pop()
方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
var plants = ['西红柿', '黄瓜', '芹菜', '豆角', '土豆'];
console.log(plants.pop());
// "土豆"
console.log(plants);
// ['西红柿', '黄瓜', '芹菜', '豆角']
plants.pop();
console.log(plants);
// ['西红柿', '黄瓜', '芹菜']
参数
无
返回值
从数组中删除的元素(当数组为空时返回undefined)。
shift()
方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
var array = [1, 2, 3];
var firstElement = array.shift();
console.log(array);
// Array [2, 3]
console.log(firstElement);
// 1
参数
无
返回值
从数组中删除的元素; 如果数组为空则返回undefined 。
slice() (裁切)
切割方法返回一个新的数组对象，这一对象是一个由
begin和end决定的原数组的浅拷贝（包括begin(起始下标)，不包括end(结束下标)）。原始数组不会被改变。
var plants = ['西红柿', '黄瓜', '芹菜', '豆角', '土豆'];
console.log(plants.slice(2));
// ['芹菜', '豆角', '土豆']
console.log(plants.slice(2, 4));
// [ '芹菜', '豆角']
console.log(plants.slice(1, 5));
// ['黄瓜', '芹菜', '豆角', '土豆']
参数
arr.slice([begin[, end]]) //begin 和end都是可选参数
如果不传参 默认切割整个数组
begin 可选
提取起始处的索引（从 0 开始），从该索引开始提取原数组元素。
如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二 个元素到最后一个元素（包含最后一个元素）。
如果省略 begin，则 slice 从索引 0 开始。
如果 begin 大于原数组的长度，则会返回空数组。
end 可选
提取终止处的索引（从 0 开始），在该索引处结束提取原数组元素。slice 会提取原数组中索引从 begin 到 end 的所有元素（包含 begin，但不包含 end）。
slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素）。
如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中 的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
如果 end 被省略，则 slice 会一直提取到原数组末尾。
如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。
返回值
一个含有被提取元素的新数组。
concat()（）
合并方法用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
不传参数 concat 会返回调用此方法的现存数组的一个浅拷贝。
var plants = ['西红柿', '黄瓜', '芹菜', '豆角', '土豆'];
var otherPlants = ['冬瓜', '韭菜']
var newPlants = plants.concat(otherPlants);
console.log(newPlants);
//['西红柿', '黄瓜', '芹菜', '豆角', '土豆', '冬瓜', '韭菜']
参数
var newArray = oldArray.concat(value1[, value2[, ...[, valueN]]]);
valueN可选
数组和/或值，将被合并到一个新的数组中。如果省略了所有 valueN 参数，则 concat 会返回调用此方法的现存数组的一个浅拷贝。
返回值
一个合并后的新数组。
indexOf()
方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
var plants = ['西红柿', '黄瓜', '芹菜', '豆角', '土豆','黄瓜'];
console.log(plants.indexOf('黄瓜'));
//1
console.log(plants.indexOf('黄瓜',3));
//5
console.log(plants.indexOf('大象'));
//-1
参数
//arr.indexOf(searchElement[, fromIndex])
arr.indexOf(searchElement, fromIndex)
searchElement
要查找的元素
fromIndex 可选
开始查找的位置。如果该索引值大于或等于数组长度，意味着不会在数组里查找，返回-1。如果参数中提供的索引值是一个负值，则将其作为数组末尾的一个抵消，即-1表示从最后一个元素开始查找，-2表示从倒数第二个元素开始查找 ，以此类推。 注意：如果参数中提供的索引值是一个负值，并不改变其查找顺序，查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于0，则整个数组都将会被查询。其默认值为0.
返回值
首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1
forEach()
方法对数组的每个元素执行一次给定的函数。
var items = ['item1', 'item2', 'item3'];
var copy = [];
// for写法
for (var i=0; i<items.length; i++) {
copy.push(items[i]);
}
// forEach方法
items.forEach(function(item){
copy.push(item);
});
var arr = [1,2,3,4,5,6,7,8]
arr.forEach(function(curr,index,array){
console.log(curr,index,array)
})
//手写forEach(js内部不是这样 理论是差不多的)
function forEach(arr,callbank){
for(var i = 0; i < arr.length;i++){
callbank(arr[i],i,arr)//这是形参
}
}
forEach([1,2,3,4,5,6],function(curr,index,array){
console.log(curr,index,array)//这是实参
})
//属性 thisAr
arr.forEach(function(curr,index,array){
console.log(this)//指向window
})
var obj = {
name:'ls'
}
arr.forEach(function(curr,index,array){
console.log(this)//指向obj
},obj)//改变了 内部this指向
参数
arr.forEach(callback(currentValue [, index [, array]])[, thisArg])
callback
为数组中每个元素执行的函数，该函数接收一至三个参数：
currentValue
数组中正在处理的当前元素。
index 可选
数组中正在处理的当前元素的索引。
array 可选
forEach() 方法正在操作的数组。
thisArg 可选
可选参数。当执行回调函数 callback 时，用作 this 的值。
返回值
undefined
sort()
方法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的
const months = ['March', 'Jan', 'Feb', 'Dec'];
months.sort();
console.log(months);
// ["Dec", "Feb", "Jan", "March"]
const array1 = [1, 30, 4, 21, 100000];
array1.sort();
console.log(array1);
// [1, 100000, 21, 30, 4]
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
return a - b;
});
console.log(numbers);
// [1, 2, 3, 4, 5]
var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
return b - a;
});
console.log(numbers);
// [5, 4, 3, 2, 1]
如果没有指明 排序函数 ，那么元素会按照转换为的字符串的诸个字符的Unicode位点进行排序。例如 "Banana" 会被排列到 "cherry" 之前。当数字按由小到大排序时，9 出现在 80 之前，但因为（没有指明 排序函数），比较的数字会先被转换为字符串，所以在Unicode顺序上 "80" 要比 "9" 要靠前。
参数
arr.sort([function compareFunction(firstEl,secondEl) {
}])
compareFunction 可选
用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
firstEl
第一个用于比较的元素。
secondEl
第二个用于比较的元素。
返回值
排序后的数组。请注意，数组已原地排序，不会产生新数组。
map()
方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。
var originArr = [1,2,3,4,5];
var newArr = originArr.map(function(current,index,array){
return current * 2;
});
console.log(newArr);
//[2,4,6,8,10]
---------------------------------------------------
var kvArray = [{key: 1, value: 10},
{key: 2, value: 20},
{key: 3, value: 30}];
var reformattedArray = kvArray.map(function(obj) {
var rObj = {};
rObj[obj['key']] = obj.value;
return rObj;
});
console.log(reformattedArray);
// [{1: 10}, {2: 20}, {3: 30}],
map 方法会给原数组中的每个元素都按顺序调用一次 callback 函数。callback 每次执行后的返回值（包括 undefined）组合起来形成一个新数组。 callback 函数只会在有值的索引上被调用；那些从来没被赋过值或者使用 delete 删除的索引则不会被调用。
callback 函数会被自动传入三个参数：数组元素，元素索引，原数组本身。
map 不修改调用它的原数组本身（当然可以在 callback 执行时改变原数组）
参数
var new_array = arr.map(function callback(currentValue[, index[, array]]) {
// Return element for new_array
}[, thisArg])
callback
生成新数组元素的函数，使用三个参数：
currentValue
callback 数组中正在处理的当前元素。
index可选
callback 数组中正在处理的当前元素的索引。
array可选
map 方法调用的数组。
thisArg可选
执行 callback 函数时值被用作this。
返回值
一个由原数组每个元素执行回调函数的结果组成的新数组。
find()/findIndex()
数组.filter(function(*item*,*index*,origin){})s
输入：回调函数，所有数组成员依次执行该函数，直到找到第一个返回值为true的成员。 回调函数可以接受三个参数，依次为值，位置，原数组。
find() 方法返回通过测试（函数内判断）的数组的第一个元素的值。
find() 方法为数组中的每个元素都调用一次函数执行：
当数组中的元素在测试条件时返回 true 时, find() 返回符合条件的元素，之后的值不会再调用执行函数。
如果没有符合条件的元素返回 undefined
find() 对于空数组，函数是不会执行的。
find() 并没有改变数组的原始值。
findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置。
findIndex() 方法为数组中的每个元素都调用一次函数执行：
当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。
如果没有符合条件的元素返回 -1
findIndex() 对于空数组，函数是不会执行的。
findIndex() 并没有改变数组的原始值。
var arr = [2,3,4,5,6,8,9,3]
//find()
var newarr = arr.find(function(item,index,origin){
return item >3
})
console.log(newarr)//4 返回的是数组的值
//findIndex()
var newarr1 = arr.findIndex(function(item,index,origin){
return item >3
})
console.log(newarr1)//2 返回的是地址值
some()
some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。
some() 不会对空数组进行检测。
some() 不会改变原始数组。
参数：item当前元素的值
index当前元素的索引值
arr当前元素属于的数组对象
var arr = [6,5,4,3,6,5]
var newarr = arr.some(function(item,index,origin){
return item >5
})
console.log(newarr)//true
every()
every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
every() 不会对空数组进行检测。
every() 不会改变原始数组。
参数：currentValue当前元素的值
index当前元素的索引值
arr当前元素属于的数组对象
var arr = [6,5,4,3,6,5]
var newarr1 = arr.every(function(item,index,origin){
return item >3
})
console.log(newarr1)//false
filter()
方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
var arr = [
{ id: 15 },
{ id: -1 },
{ id: 0 },
{ id: 3 },
{ id: 12.2 },
{ },
{ id: null },
{ id: NaN },
{ id: 'undefined' }
];
function isNumber(obj) {
return obj !== undefined && typeof(obj) === 'number' && !isNaN(obj);
}
var arrByID = arr.filter(function(item) {
return isNumber(item.id) && item.id !== 0;
});
console.log(arrByID);
// [{ id: 15 }, { id: -1 }, { id: 3 }, { id: 12.2 }]
filter 为数组中的每个元素调用一次 callback 函数，并利用所有使得 callback 返回 true 或等价于 true 的值的元素创建一个新数组。callback 只会在已经赋值的索引上被调用，对于那些已经被删除或者从未被赋值的索引不会被调用。那些没有通过 callback 测试的元素会被跳过，不会被包含在新数组中。
callback 被调用时传入三个参数：
元素的值
元素的索引
被遍历的数组本身
如果为 filter 提供一个 thisArg 参数，则它会被作为 callback 被调用时的 this 值。否则，callback 的 this 值在非严格模式下将是全局对象，严格模式下为 undefined。callback 函数最终观察到的 this 值是根据通常函数所看到的 "this"的规则确定的。
filter 不会改变原数组，它返回过滤后的新数组。
filter 遍历的元素范围在第一次调用 callback 之前就已经确定了。在调用 filter 之后被添加到数组中的元素不会被 filter 遍历到。如果已经存在的元素被改变了，则他们传入 callback 的值是 filter 遍历到它们那一刻的值。被删除或从来未被赋值的元素不会被遍历到。
参数
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
callback
用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：
element
数组中当前正在处理的元素。
index可选
正在处理的元素在数组中的索引。
array可选
调用了 filter 的数组本身。
thisArg可选
执行 callback 时，用于 this 的值
返回值
一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。
reduce()
方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。
var originArr = [3,4,5,6,7,8];
var sum = originArr.reduce(function(acc,current,idx,arr){
return acc + current;
});
console.log(sum);
//33 数组中每项累加和
var str = 'jfkldsajgklasjkhlgjefaklhjaerkl';
var statistics = str.split('').reduce(function(acc,current){
if(acc[current]){
acc[current]++;
}else {
acc[current] = 1;
}
return acc;
},{});
console.log(statistics);
// {a: 4, d: 1, e: 2, f: 2, g: 2, h: 2, j: 5, k: 5, l: 5, r: 1, s: 2} 字符串统计后的对象结果
reduce为数组中的每一个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：
accumulator 累计器
currentValue 当前值
currentIndex 当前索引
array 数组
回调函数第一次执行时，accumulator 和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue，accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供 initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值。
参数
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
callback
执行数组中每个值 (如果没有提供 initialValue则第一个值除外)的函数，包含四个参数：
accumulator
累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
currentValue
数组中正在处理的元素。
index 可选
数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则从索引1起始。
array可选
调用reduce()的数组
initialValue可选
作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
返回值
函数累计处理的结果
lastIndexOf()
方法返回指定元素（也即有效的 JavaScript 值或变量）在数组中的最后一个的索引，如果不存在则返回 -1。从数组的后面向前查找，从
fromIndex处开始。
var array = [2, 5, 9, 2];
var index = array.lastIndexOf(2);
// index is 3
index = array.lastIndexOf(7);
// index is -1
index = array.lastIndexOf(2, 3);
// index is 3
index = array.lastIndexOf(2, 2);
// index is 0
index = array.lastIndexOf(2, -2);
// index is 0
index = array.lastIndexOf(2, -1);
// index is 3
lastIndexOf 使用严格相等（strict equality，即 ===）比较 searchElement 和数组中的元素。
参数
arr.lastIndexOf(searchElement[, fromIndex])
searchElement
被查找的元素。
fromIndex 可选
从此位置开始逆向查找。默认为数组的长度减 1(arr.length - 1)，即整个数组都被查找。如果该值大于或等于数组的长度，则整个数组会被查找。如果为负值，将其视为从数组末尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。如果该值为负时，其绝对值大于数组长度，则方法返回 -1，即数组不会被查找。
返回值
数组中该元素最后一次出现的索引，如未找到返回-1。
reverse()
方法将数组中元素的位置颠倒，并返回该数组。数组的第一个元素会变成最后一个，数组的最后一个元素变成第一个。该方法会改变原数组。
var array1 = ['one', 'two', 'three'];
console.log( array1);
// ["one", "two", "three"]
var reversed = array1.reverse();
console.log( reversed);
// ["three", "two", "one"]
console.log(array1);
// ["three", "two", "one"]
reverse会对原数组造成修改影响
参数
arr.reverse()
返回值
颠倒后的数组。
splice()
方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
var months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// 在下标1的位置新增了1项
console.log(months);
// ["Jan", "Feb", "March", "April", "June"]
months.splice(4, 1, 'May');
// 在下标4的位置 修改了 1项
console.log(months);
//["Jan", "Feb", "March", "April", "May"]
splice会修改原数组
参数
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
start
指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
deleteCount 可选
整数，表示要移除的数组元素的个数。
如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
item1, item2, ... 可选
要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
返回值
由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
includes()
方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回 true，否则返回false。
var array1 = [1, 2, 3];
console.log(array1.includes(2));
// expected output: true
var pets = ['cat', 'dog', 'bat'];
console.log(pets.includes('cat'));
// expected output: true
console.log(pets.includes('at'));
// expected output: false
参数
valueToFind
需要查找的元素值。
Note: 使用 includes()比较字符串和字符时是区分大小写。
fromIndex 可选
从fromIndex 索引处开始查找 valueToFind。如果为负值，则按升序从 array.length + fromIndex 的索引开始搜 （即使从末尾开始往前跳 fromIndex 的绝对值个索引，然后往后搜寻）。默认为 0。
返回值
返回一个布尔值 Boolean ，如果在数组中找到了（如果传入了 fromIndex ，表示在 fromIndex 指定的索引范围中找到了）则返回 true 。
flat()
方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
var arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
//使用 Infinity，可展开任意深度的嵌套数组
var arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
//二维展开替代方案
var arr = [1, 2, [3, 4]];
var flatArr = arr.reduce(function(acc,curr){
return acc.concat(curr);
},[]);
console.log(flatArr);
//[1, 2, 3, 4]
参数
var newArray = arr.flat([depth])
depth 可选
指定要提取嵌套数组的结构深度，默认值为 1。
返回值
一个包含将数组与子数组中所有元素的新数组。
方法汇总
toString() 把数组转换成字符串，逗号分隔每一项
valueOf() 返回数组对象值本身
// 1 栈操作(先进后出)
push()
pop() //取出数组中的最后一项，修改length属性
// 2 队列操作(先进先出)
push()
shift() //取出数组中的第一个元素，修改length属性
unshift() //在数组最前面插入项，返回数组的长度
// 3 排序方法
reverse() //翻转数组
sort(); //即使是数组sort也是根据字符，从小到大排序
// 带参数的sort是如何实现的？
// 4 操作方法
concat() //把参数拼接到当前数组
slice() //从当前数组中截取一个新的数组，不影响原来的数组，参数start从0开始,end从1开始
splice() //删除或替换当前数组的某些项目，参数start, deleteCount, options(要替换的项目)
// 5 位置方法
indexOf()、lastIndexOf() //如果没找到返回-1
// 6 迭代方法 不会修改原数组(可选)
every()、filter()、forEach()、map()、reduce()、some() find()、findlndex()
// 7 方法将数组的所有元素连接到一个字符串中。
join()
String方法
字符串常用方法
charAt()
charAt()
方法从一个字符串中返回指定的字符。
var str ='你好,我是海牙老师';
console.log(str.charAt(3));
//返回了 str[3]的值
参数
index(索引值)
字符串中的字符从左向右索引，第一个字符的索引值为 0，最后一个字符（假设该字符位于字符串 stringName 中）的索引值为 stringName.length - 1。 如果指定的 index 值超出了该范围，则返回一个空字符串。
返回值
指定字符串
charCodeAt
*语法：字符串.charCodeAt(索引)
*作用：查询指定下标的值 对应的 十进制码
*返回值：查询到的值对应的十进制码 没有查到返回NAN
toLowerCase
*语法：字符串.toLowerCase
*作用：将这个字符串转换为小写
*返回值：转换后的字符串
toUpperCase
*语法：字符串.toUpperCase
*作用：将字符串转换为大写
*返回值：转换后的字符串
分割截取字符串的方法
substr
*语法：字符串.substr(开始索引，多少个)
*作用：截取指定的字符串
*返回值：截取到的字符串
*注意：mdn 说明这个方法将来某一天可能会删除，所以建议我们使用 substri
substring
*语法：字符串substring(开始索引,结束下标)
*作用：截取指定的字符串
*返回值：截取到的字符串
*注意
1.参数包前不包后
2.结束索引可以不写，相当于写了length
3.不可以接受负值
slice
*语法：字符串slice(开始索引,结束下标)
*作用：截取指定的字符串
*返回值：截取到的字符串
*注意
1.参数包前不包后
2.结束索引可以不写，相当于写了length
3.开始索引可以不写，相当于写了0
4.结束索引支持负数
concat
*语法：字符串.concat(数据1,数据2,数据3....)
*作用：将字符串和参数传递的数据 进行拼接
*返回值：拼接后的字符串
indexOf
*语法：字符串.indexOf(数据,开始下标)
*作用：寻找数据在字符串出的位置
*返回值:找到返回下标，找不到-1
注意
第二个参数可以不传递 默认0
第二个参数小于0从0开始 大于length从length开始
lastindexOf
*语法：字符串.indexOf(数据,开始下标)
*作用：寻找数据在字符串出的位置(从后往前找)
*注意
第二个参数小于0从0开始 大于length从length开始(方向右-左)
split**
*作用：split() 方法使用指定的分隔符字符串将一个String对象分割成 子字符串数组
*返回值 数组
*不传参 或者传递的参数字符串中没有 转换的数组只有一个值
//split
var str = 'qwr,tr,ad, cc'
console.log(str.split(' '))
//['qwr,tr,ad,', 'cc'] //' '没了
console.log(str.split(','))
//['qwr', 'tr', 'ad', ' cc']逗号没了
console.log(str.split('a'))
//['qwr,tr,', 'd, cc']a没了
console.log(str.split(''))
//'q', 'w', 'r', ',', 't', 'r', ',', 'a', 'd', ',', ' ', 'c', 'c'
//每一项都分割了 包括空格
console.log(str.split())//['qwr,tr,ad, cc']
console.log(str.split('z'))//['qwr,tr,ad, cc']
trim()
语法：字符串.trim()
作用:去掉字符串两侧的空格
返回值：去掉空格后的字符串
var str = ' a b c '
console.log(str)//'a b c'
trimStart/trimLeft
语法：字符串.trimStart/字符串.trimLeft()
作用：去掉字符串开始(左侧)空格
返回值：去掉空格后的字符串
trimEnd/trimRight
语法：字符串.trimEnd/字符串.trimRight()
作用：去掉字符串末尾(右侧)空格
返回值：去掉空格后的字符串
includes()
语法：字符串.includes(字符串片段)
作用：判断当前值符传中，是否拥有指定字符串
返回值：布尔值
var str = 'abcdef'
var str1 = str.includes('bcde')
console.log(str1)//true
startswith()
语法：字符串.startswith(字符串片段)
作用：判断字符串开始 是不是指定的 字符串片段
返回值：一个布尔值
endswith()
语法：字符串.endswith(字符串片段)
作用：判断字符结尾 是不是指定的 字符串片段
返回值：一个布尔值
replace
语法：字符串.replace(被替换的，替换的)
作用：判断字符结尾 是不是指定的 字符串片段
返回值：一个布尔值
方法汇总
// 1 字符方法
charAt() //获取指定位置处字符
charCodeAt() //获取指定位置处字符的ASCII码
str[0] //HTML5，IE8+支持 和charAt()等效
// 2 字符串操作方法
concat() //拼接字符串，等效于+，+更常用
slice() //从start位置开始，截取到end位置，end取不到
substring() //从start位置开始，截取到end位置，end取不到
substr() //从start位置开始，截取length个字符
// 3 位置方法
indexOf() //返回指定内容在元字符串中的位置
lastIndexOf() //从后往前找，只找第一个匹配的
// 4 去除空白
trim() //只能去除字符串前后的空白
// 5 大小写转换方法
to(Locale)UpperCase() //转换大写
to(Locale)LowerCase() //转换小写
// 6 其它
search()
replace() //替换
split() //分隔成字符串
fromCharCode() //unicode转字符串
// String.fromCharCode(101, 102, 103);
案例
- 截取字符串"我爱中华人民共和国"，中的"中华"
var s = "我爱中华人民共和国";
s = s.substr(2,2);
console.log(s);
---------------------
function padLeft(num){
num = num || 0;
return ('00'+num).substr(-2);
}
- "abcoefoxyozzopp"查找字符串中所有o出现的位置
var s = 'abcoefoxyozzopp';
var array = [];
do {
var index = s.indexOf('o', index + 1);
//index 第一轮为undefind undefind+1 = NAN
//NAN不存在 默认从0开始
if (index != -1) {
array.push(index);
}
} while (index > -1);
console.log(array);
- 把字符串中所有的o替换成!
var s = 'abcoefoxyozzopp';
do {
s = s.replace('o', '');
} while (s.indexOf('o') > -1);
console.log(s);
console.log(s.replace(/o/ig, ''));
//错误示范
var s1 = 'abcoefoxyozzopp';
var snew1 = s1.replace('o','我')//这样只会第一个o变
console.log(snew1)//abc我efoxyozzopp
- 判断一个字符串中出现次数最多的字符，统计这个次数
var s = 'abcoefoxyozzopp';
var o = {};
for (var i = 0; i < s.length; i++) {
var item = s.charAt(i);
if (o[item]) {
o[item] ++;
}else{
o[item] = 1;
}
}
var max = 0;
var char ;
for(var key in o) {
if (max < o[key]) {
max = o[key];
char = key;
}
}
console.log(max);
console.log(char);
Math数字方法
/*
1.random**
*语法：Math.random()
*作用：得到一个随机数0-1，每次生成的数字都不一样，包含0 不包含1
2.round
* 语法: Math.round()
* 作用: 将数据 四舍五入取整
3.ceil**
* 语法: Math.ceil()
* 作用: 将数据 向上取整
4. floor**
* 语法: Matn.floor()
* 作用: 将数据 向下取整
5. abs
* 语法: Math.abs()
* 作用: 取数据的绝对值
6.sqrt
* 语法: Math.sqrt()
* 作用: 求平方根
7.pow
* 语法: Math.pow(基数, 幂)
* 作用: 求一个基数的 X 次幂
8. max **
* 语法: Math.max(数据1, 数据2, 数据3, ...)
* 作用: 求参数中 的 最大值
9. min
* 语法: Math.min(数据1, 数据2, 数据3, ...)
* 作用: 求参数中 的 最小值
10. PI
* 语法: Math.PI
* 作用: 求圆周率
*PI 并非方法，而是属性，无需括号
*/
随机函数
//a-b的随机数
//不能用round 比如0-10 0和10的概率 只有一半
var suiji = *Math*.floor((*Math*.random() * b-a+1) + a);
console.log(suiji)
方法汇总
Math.PI // 圆周率
Math.random() // 生成随机数
Math.floor()/Math.ceil() // 向下取整/向上取整
Math.round() // 取整，四舍五入
Math.abs() // 绝对值
Math.max()/Math.min() // 求最大和最小值
Math.sin()/Math.cos() // 正弦/余弦
Math.power()/Math.sqrt() // 求指数次幂/求平方根
练习
数组塌陷
//按顺序删除数组内的值
var arr = [0,1,2,3,4]
console.log('原始数组'+arr)
for(var i =0; i<arr.length;i++){
arr.pop() //[0,1,2] i =3 arr.length =3 循环停止了
}
//组织数组塌陷
//方法一
for(var i =arr.length-1; i >= 0;i--){
// arr.pop()
// arr.shift()
arr.splice(i,1)
}
//方法二
for(var i =0; i < arr.length; i++){
// arr.pop()
// arr.shift()
arr.splice(i,1)
i-- //i++ i--循环 i一直等于0 直到 arr.length = 0
//0<0 不成立 循环结束
}
console.log(arr)
//方法三
// for(var i =0 , len = arr.length; i<len;i++){
// arr.pop()
// }
Date对象方法
创建
Date实例用来处理日期和时间。Date 对象基于1970年1月1日（世界标准时间）起的毫秒数。
// 获取当前时间，UTC世界时间，距1970年1月1日（世界标准时间）起的毫秒数
var now = new Date();
console.log(now.valueOf()); // 获取距1970年1月1日（世界标准时间）起的毫秒数
Date构造函数的参数
1. 毫秒数 1498099000356 new Date(1498099000356)
2. 日期格式字符串 '2015-5-1' new Date('2015-5-1')
3. 年、月、日…… new Date(2015, 4, 1) // 月份从0开始
- 获取日期的毫秒形式
var now = new Date();
// valueOf用于获取对象的原始值
console.log(date.valueOf())
// HTML5中提供的方法，有兼容性问题
var now = Date.now();
// 不支持HTML5的浏览器，可以用下面这种方式
var now = + new Date(); // 调用 Date对象的valueOf()
- 日期格式化方法
toString() // 转换成字符串
valueOf() // 获取毫秒值
// 下面格式化日期的方法，在不同浏览器可能表现不一致，一般不用
toDateString()
toTimeString()
toLocaleDateString()
toLocaleTimeString()
- 获取日期指定部分
getTime() // 返回毫秒数和valueOf()结果一样，valueOf()内部调用的getTime()
getMilliseconds()
getSeconds() // 返回0-59
getMinutes() // 返回0-59
getHours() // 返回0-23
getDay() // 返回星期几 0周日 6周6
getDate() // 返回当前月的第几天
getMonth() // 返回月份，***从0开始***
getFullYear() //返回4位的年份 如 2016
- 设置日期指定部分
setTime() //设置 到1970年的总毫秒数//就是从1970年开始 走多少秒
setMilliseconds()
setSeconds() // 返回0-59
setMinutes() // 返回0-59
setHours() // 返回0-23
//注意*** 不能设置星期几
setDate() // 返回当前月的第几天
setMonth() // 返回月份，***从0开始***
setFullYear() //返回4位的年份 如 2016
案例
- 写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式
function formatDate(d) {
//如果date不是日期对象，返回
if (!date instanceof Date) {
return;
}
var year = d.getFullYear(),
month = d.getMonth() + 1,
date = d.getDate(),
hour = d.getHours(),
minute = d.getMinutes(),
second = d.getSeconds();
month = padLeft(month);
date = padLeft(date);
hour =padLeft(hour);
minute = padLeft(minute);
second = padLeft(second);
return year + '-' + month + '-' + date + ' ' + hour + ':' + minute + ':' + second;
}
function padLeft(num){
return String(num)[1] && String(num) || '0' + num;
}
- 计算时间差，返回相差的天/时/分/秒
function getInterval(start, end) {
var day, hour, minute, second, interval;
interval = end - start;
interval /= 1000;
day = ~~(interval / 60 /60 / 24);
hour = ~~(interval / 60 /60 % 24);
minute = ~~(interval / 60 % 60);
second = ~~(interval % 60);
return {
day: day,
hour: hour,
minute: minute,
second: second
}
}