手写不易，如果对您有帮助，帮忙点个免费的赞赞૮₍♡>..< ₎ა
一.JavaScript Array toString() 方法
定义和用法
toString() 方法返回包含所有数组值的字符串，以逗号分隔。
注释：toString() 方法不会改变原始数组。
参数
无参数。
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni","hao","jian","jian"]
Array.prototype.newtoString = function (str) { //与join方法类似
var string = '';
if (this.length == 1) {
return string + this[this.length - 1]
} else {
string += this[0]
for (var i = 1; i < this.length; i++) {
string += (',' + this[i])
}
return string
}
}
var str = arr.newtoString();
console.log(str);
console.log(arr1.newtoString());
console.log(arr2.newtoString());二.JavaScript Array includes() 方法
定义和用法
includes() 方法确定数组是否包含指定的元素。
如果数组包含元素，则此方法返回 true，否则返回 false。
注释：includes() 方法区分大小写。
参数值
| 参数 | 描述 |
|---|---|
| element | 必需。要搜索的元素。 |
| start | 可选。默认 0。在数组中的哪个位置开始搜索。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newIncludes=function(str,start){
var startIndex=0;
if(start){
if(start<0){
startIndex=this.length+start;
}else{
startIndex=start;
}
}
for(var i=startIndex;i<this.length;i++){ //循环遍历数组，检索符合条件的值
if(this[i]===str){ //进行判断是否相等
return true
}
}
return false
}
console.log(arr.newIncludes(25,3));
console.log(arr.newIncludes(22));
console.log(arr2.newIncludes('ni'));
console.log(arr2.newIncludes('NI'));三.JavaScript Array valueOf() 方法
定义和用法
valueOf() 方法返回数组。
valueOf() 方法是数组对象的默认方法。
注释：valueOf() 方法不会改变原始数组。
参数
无参数。
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = ["ni", "hao", "jian", "jian"]
Array.prototype.newValueOf=function(){
//错误示例
// var newarr=this;
//正确示例
var newarr=[];
for(var i=0;i<this.length;i++){
newarr[i]=this[i];
}
return newarr;
}
console.log(arr.newValueOf());
console.log(arr1.newValueOf());四.JavaScript Array unshift() 方法
定义和用法
unshift() 方法将新项添加到数组的开头，并返回新的长度。
注释：unshift() 方法会改变数组的长度。
提示：如需在数组末尾添加新项，请使用 push() 方法。
参数值
| 参数 | 描述 |
|---|---|
| item1, item2, ..., itemX | 必需。要添加到数组开头的项。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newUnshift=function(){
//记录一下长度，防止后期数组变化时不受影响
var arrlen=this.length;
var arglen=arguments.length;
//创建一个临时数组去存储之前数组中的值
var newarr=[];
for(var i=0;i<this.length;i++){
newarr[i]=this[i];
}
//将数组中的值进行从新赋值
for(var i=0;i<arrlen+arglen;i++){
if(i<arglen){
this[i]=arguments[i]; //判断是否将传来的值全部插入数组前完毕
}else{
this[i]=newarr[i-arglen]
}
}
}
arr.newUnshift();
console.log(arr);
arr.newUnshift("16",14)
console.log(arr);五.JavaScript Array fill() 方法
定义和用法
fill() 方法用静态值填充数组中的指定元素。
您可以指定开始和结束填充的位置。如果未指定，则将填充所有元素。
注释：fill() 会覆盖原始数组。
参数值
| 参数 | 描述 |
|---|---|
| value | 必需。用于填充数组的值。 |
| start | 可选。开始填充数组的索引（默认为 0）。 |
| end | 可选。停止填充数组的索引（默认为 array.length）。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newFill=function(val,start,end){
var startIndex=0;
var endIndex=this.length;
if(start){
startIndex=start;
}
if(end){
endIndex=end;
}
for(var i=startIndex;i<endIndex;i++){
this[i]=val;
}
}
arr.newFill('ha',1,5)
console.log(arr);六.JavaScript Array concat() 方法
定义和用法
concat() 方法用于连接两个或多个数组。
concat() 方法不会更改现有数组，而是返回一个新数组，其中包含已连接数组的值。
参数值
| 参数 | 描述 |
|---|---|
| array2, array3, ..., arrayX | 必需。要连接的数组。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newConcat = function () {
//创建一个临时数组去存储之前数组中的值
var newarr = [];
for (var i = 0; i < this.length; i++) {
newarr[i] = this[i];
}
for(let i=0;i<arguments.length;i++){ //循环遍历次数等于传递的参数的个数
var arrdeslen=newarr.length; //每次循环重新获取一下新数组的长度
for(var j=0;j<arguments[i].length;j++){ //循环遍历次数等于获取每一个参数的数组长度
newarr[arrdeslen+j]=arguments[i][j] //在新数组后面接上传递过来的参数数组
}
}
return newarr;
}
var newarr=arr.newConcat(arr1,arr2)
console.log(newarr);七.JavaScript Array map() 方法
定义和用法
map() 方法使用为每个数组元素调用函数的结果创建新数组。
map() 方法按顺序为数组中的每个元素调用一次提供的函数。
注释：map() 对没有值的数组元素不执行函数。
注释：map() 不会改变原始数组。
参数值
| 参数 | 描述 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| function(currentValue, index, arr) | 必需。为数组中的每个元素运行的函数。 函数参数：
|
||||||||
| thisValue | 可选。要传递给函数以用作其 "this" 值的值。 如果此参数为空，则值 "undefined" 将作为其 "this" 值传递。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newMap = function (fun) {
var newarr=[];
for(var i=0;i<this.length;i++){ //循环遍历，遍历到数组中每一个数值
newarr[i]= fun(this[i]) //将经过函数作用过的值传递给新数组
}
return newarr //将新数组返回
}
function test(val){ //测试函数
return val*2
}
console.log(arr.newMap(test));八.JavaScript Array filter() 方法
定义和用法
filter() 方法创建数组，其中填充了所有通过测试的数组元素（作为函数提供）。
注释：filter() 不会对没有值的数组元素执行该函数。
注释：filter() 不会改变原始数组。
参数值
| 参数 | 描述 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| function(currentValue, index, arr) | 必需。为数组中的每个元素运行的函数。 函数参数：
|
||||||||
| thisValue | 可选。要传递给函数以用作其 "this" 值的值。 如果此参数为空，则值 "undefined" 将作为其 "this" 值传递。 |
原生js手写实现：
var arr = [12, 25, 15, 36, 88]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newFilter = function (fun) {
var newarr=[];
for(var i=0,j=0;i<this.length;i++,j++){ //循环遍历，遍历到数组中每一个数值 //新数组索引加一
if(fun(this[i])){ //判断是否满足条件
newarr[j]=this[i]; //满足条件的赋值给新数组
}
}
return newarr //将新数组返回
}
function test(val){ //测试函数
return val>15
}
console.log(arr.newFilter(test));九.JavaScript Array forEach() 方法
定义和用法
forEach() 方法按顺序为数组中的每个元素调用一次函数。
注释：对于没有值的数组元素，不执行forEach() 方法。
参数值
| 参数 | 描述 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| function(currentValue, index, arr) | 必需。为数组中的每个元素运行的函数。 函数参数：
|
||||||||
| thisValue | 可选。要传递给函数以用作其 "this" 值的值。 如果此参数为空，则值 "undefined" 将作为其 "this" 值传递。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newForeach = function (fun) {
for(var i=0;i<this.length;i++){ //循环遍历，遍历到数组中每一个数值
this[i]= fun(this[i]) //将经过函数作用过的值传递给数组
}
}
function test(val){ //测试函数
return val*2
}
var sum=0;
function myFunction(item) {
sum += item;
}
arr.newForeach(myFunction)
console.log(sum);
arr.newForeach(test)//证明Foreach方法会改变原数组导致发生错误
console.log(arr);十.JavaScript Array reduce() 方法
定义和用法
reduce() 方法将数组缩减为单个值。
reduce() 方法为数组的每个值（从左到右）执行提供的函数。
函数的返回值存储在累加器中（结果/总计）。
注释：对没有值的数组元素，不执行 reduce() 方法。
注释：reduce() 方法不会改变原始数组。
参数值
| 参数 | 描述 | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| function(total, currentValue, index, arr) | 必需。为数组中的每个元素运行的函数。 函数参数：
|
||||||||||
| initialValue | 可选。作为初始值传递给函数的值。 |
原生js手写实现：
var arr = [12.5, 15.6, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newReduce = function (fun) {
var first = this[0];
for (var i = 1; i < this.length; i++) {
var first=fun(first, this[i])
}
return first
}
function myFunc(total, num) {
return total - num;
}
function getSum(total, num) {
return total + Math.round(num);
}
console.log( arr.newReduce(myFunc));
console.log(arr.newReduce(getSum));十一.JavaScript Array reduceRight() 方法
定义和用法
reduceRight() 方法将数组缩减为单个值。
reduceRight() 方法为数组的每个值（从右到左）执行提供的函数。
函数的返回值存储在累加器中（结果/总计）。
注释：对没有值的数组元素，不执行 reduceRight() 方法。
参数值
| 参数 | 描述 | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| function(total, currentValue, index, arr) | 必需。为数组中的每个元素运行的函数。 函数参数：
|
||||||||||
| initialValue | 可选。作为初始值传递给函数的值。 |
原生js手写实现：
var arr = [12, 156, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newReduceRight = function (fun) {
var first = this[this.length-1];
for (var i = 0; i < this.length-1; i++) {
var first = fun(first, this[i])
}
return first
}
function myFunc(total, num) {
return total - num;
}
console.log(arr.newReduceRight(myFunc));
十二.JavaScript Array indexOf() 方法
定义和用法
indexOf() 方法在数组中搜索指定项目，并返回其位置。
搜索将从指定位置开始，如果未指定开始位置，则从头开始，并在数组末尾结束搜索。
如果未找到该项目，则 indexOf() 返回 -1。
如果该项目出现多次，则 indexOf() 方法返回第一次出现的位置。
注释：第一项的位置为 0，第二项的位置为 1，依此类推。
提示：如果您想从尾到头搜索，请使用 lastIndexOf() 方法。
参数值
| 参数 | 描述 |
|---|---|
| item | 必需。要搜索的项目。 |
| start | 可选。从哪里开始搜索。负值给定的位置将从结尾计数，然后搜索到最后。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newIndexOf=function(item,start){
var startIndex=0;
if(start){
if(start<0){
startIndex=this.length+start;
}else{
startIndex=start;
}
}
for(var i=startIndex;i<this.length;i++){
if(item===this[i]){
return i;
}
}
return -1;
}
console.log( arr.newIndexOf(36,4));
console.log( arr2.newIndexOf('jian'));
console.log( arr2.newIndexOf('jian',3));十三.JavaScript Array lastIndexOf() 方法
定义和用法
lastIndexOf() 方法在数组中搜索指定项目，并返回其位置。
搜索将从指定位置开始，如果未指定开始位置，则从末尾开始，并在数组的开头结束搜索。
如果未找到该项目，则 lastIndexOf() 方法返回 -1。
如果要搜索的项目不止一次出现，lastIndexOf() 方法将返回最后一次出现的位置。
提示：如果要从头到尾搜索，使用 indexOf() 方法。
参数值
| 参数 | 描述 |
|---|---|
| item | 必需。要搜索的项目。 |
| start | 可选。从哪里开始搜索。负值的给定的位置从末尾计数，然后搜索到开头。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newLastIndexOf=function(item,start){
var startIndex=this.length-1;
if(start){
if(start<0){
startIndex=this.length+start;
}else{
startIndex=start;
}
}
for(var i=startIndex;i>=0;i--){
if(item===this[i]){
var ls=i
}
}
if(ls){
return ls;
}else{
return -1;
}
}
console.log( arr.newLastIndexOf(36,4));
console.log( arr2.newLastIndexOf('jian'));
console.log( arr2.newLastIndexOf('jian',-3));十四.JavaScript Array isArray() 方法
定义和用法
isArray() 方法确定对象是否为数组。
如果对象是数组，则此函数返回 true，否则返回 false。
参数值
| 参数 | 描述 |
|---|---|
| obj | 必需。需测试的对象。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = []
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newIsArray = function () {
if(this.constructor.name=="Array"){
return true;
}else{
return false
}
}
console.log(arr.newIsArray());十五.JavaScript Array splice() 方法
定义和用法
splice() 方法向/从数组添加/删除项目，并返回删除的项目。
注释：splice() 方法会改变原始数组。
参数值
| 参数 | 描述 |
|---|---|
| index | 必需。整数，指定在什么位置添加/删除项目，使用负值指定从数组末尾开始的位置。 |
| howmany | 可选。要删除的项目数。如果设置为 0，则不会删除任何项目。 |
| item1, ..., itemX | 可选。要添加到数组中的新项目。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newSplice = function (index, howmany) {
//确定好删除位置索引的值
if (index < 0) {
var startindex = this.length + index;
} else {
startindex = index;
}
//调节一下删除的数量
if (howmany > 0) {
var number = howmany;
} else {
number = 0
}
//创建一个临时数组，将删除索引之后的值存起来
var arrlen = this.length;
var newarr = [];
for (var i = startindex; i < arrlen; i++) {
newarr[i - startindex] = this[i]
}
//先将传递过来的需要插入的数据长度查出来
var arglen = arguments.length - 2;
for (var i = 0; i < arglen; i++) { //将传来的数据插入到数组当中去
this[i + startindex] = arguments[i + 2]
}
//将数组中剩余的插入到数组中去
for (var i = number; i < newarr.length; i++) {
this[startindex + arglen + i - number] = newarr[i];
}
}
arr.newSplice(2, 0, 56, 55)
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.newSplice(2, "Lemon", "Kiwi");
console.log(fruits);
console.log(arr);十六.JavaScript Array copyWithin() 方法
定义和用法
copyWithin() 方法将数组元素复制到数组中的另一个位置，覆盖现有值。
copyWithin() 方法永远不会向数组添加更多项。
提示：copyWithin() 方法会覆盖原始数组。
参数值
| 参数 | 描述 |
|---|---|
| target | 必需。将元素复制到的索引位置。 |
| start | 可选。开始复制元素的索引位置（默认为 0）。 |
| end | 可选。停止从中复制元素的索引位置（默认为 array.length）。 |
原生js手写实现：
var arr = [12, 15, 25, 36, 88]
var arr1 = [16]
var arr2 = ["ni", "hao", "jian", "jian"]
Array.prototype.newCopyWithin = function (target,start,end) {
var startIndex=0;
var endIndex=this.length;
//开始索引，负数从后数
if(start){
if(start<0){
startIndex=this.length+start;
}else{
startIndex=start;
}
}
//结束索引，负数从后数
if(end){
if(end<0){
endIndex=this.length+end;
}else{
endIndex=end;
}
}
//创建一个临时数组，将原始值存放起来
var newarr=[];
for(var i=0;i<this.length;i++){
newarr[i]=this[i];
}
//进行复制
for(var i=target,j=startIndex;i<this.length&&j<endIndex;i++,j++){
this[i]=newarr[j];
}
}
arr.newCopyWithin(2,0)
console.log(arr);
arr2.newCopyWithin(2,0,1)
console.log(arr2);