数组，类数组

一、数组

1.数组的定义

　　1）字面量 var arr=[1,2,3];

　　2）构造方法 new Array(length/content)

2.数组的方法

　　1）改变原数组：push ,pop ,shift, unshift ，reverse , splice ，sort

　　2）不改变原数组：concat ，toString，slice，join <=> split

// push :向数组末尾添加一个或多个元素，返回新的长度
var arr=[];
Array.prototype.push=function(){
    for(var i=0;i<arguments.length;i++){
        this[this.length]=arguments[i];
    }
    return this.length;
}

arr.push(1,2,3); //3

// pop 删除最后一个元素,返回数组的最后一个元素

// shift 删除第一个元素,返回数组的第一个元素
// unshift 向数组开头添加一个或多个元素，并返回新的长度。
// reverse  数组逆转顺序,并返回新数组

var arr=[1,2,3,4];
arr.reverse(); //[4, 3, 2, 1]

// splice 删除元素，并向数组添加新元素,返回被截取元素的数组

// arr.splice(从第几位开始，截取多少的长度，在切口处添加新的数据);

var arr=[1,2,3,4];

arr.splice(1,2,0,0,0);//[2, 3]
console.log(arr); // [1, 0, 0, 0, 4]

arr.splice(3,0,5);//[]
console.log(arr); // [1, 2, 3, 5, 4]

// sort  排序，返回排序后的数组
// 1.必须写两个形参
// 2.看返回值。
//          1）返回值为负数时，那么前面的数在前
//          2）正数，后面的数在前
//          3）0，不动


arr.sort(function(a,b){
    return a-b;//升序
    // return b-a;//降序
})

// 给一个有序的数组，乱序

var arr=[1,2,3,4,5,6,7];

arr.sort(function(){
    return Math.random()-0.5;
});

// 按字符串长度排序
var arr=['adadsd','asds','ss','sdw'];
arr.sort(function(a,b){
    return a.length-b.length
});

console.log(arr); //["ss", "sdw", "asds", "adadsd"]

//concat 连接两个或更多的数组，并返回连接后的数组

// toString 把数组转换为字符串，并返回结果。//[1,2,3]--> '1,2,3'

// slice 数组截取，返回被截取元素的数组

// slice(从该为开始截取，截取到该位)

var arr=[1,2,3,4];

arr.slice(1,3);// [2, 3]

arr.slice(1);//[2, 3, 4] 一个参数表示截取到末尾

arr.slice(-1);//[4] 负数表示：-1+数组的长度=3

arr.slice();//[1, 2, 3, 4] 没有参数：全部截取

//join 元素通过指定的分隔符进行分隔,返回字符串
// split 字符串方法，通过指定分隔符切割，返回数组
var arr=[1,2,3];
var str=arr.join('-');//'1-2-3'

var newArr=str.split('-');//["1", "2", "3"]

// 字符串拼接
var str='wang';
var str1='liu';
var str2='aswewe';

var arr=[str,str1,str2];
arr.join('');//"wangliuaswewe"

3.数组去重

// 数组去重(哈希)
Array.prototype.unique=function(){
    var obj={},
        arr=[],
        len=this.length;
    for(var i=0;i<len;i++){
        if(!obj[this[i]]){
            obj[this[i]]='abc';
            arr.push(this[i]);
        }
    }
    return arr;
}

var arr=[1,1,1,1,2,2,2,2,3,3,3,7,8,8,9];
var newArr=arr.unique();// [1, 2, 3, 7, 8, 9]

4.区分数据类型

// 1.分两类 原始值，引用值
// 2.区分引用值

function typeFn(target){
    var template={
        '[object Array]':'array',
        '[object Object]':'object',
        '[object Number]':'number-object',
        '[object Boolean]':'boolean-object',
        '[object String]':'string-object',
    }
    if(target===null) return 'null';

    if(typeof(target)=='object'){
        // 数组 ，对象，包装类 
        var str=Object.prototype.toString.call(target);
        return template[str];
    }else{
        // function， number,string,boolean,undefined,
        return typeof(target);
    }
}

5.数组循环的方法

I.参数相同。两个参数：(循环回调函数(当前元素，当前元素的索引，原数组),this指向谁)

不会改变原始数组，不会对空数组进行检测

1.forEach :代替普通for循环,没有返回值

2.map :通过指定函数处理数组的每个元素，并返回处理后的数组。

1）正常情况下，需要return，返回一个新数组

2）若是没有return,相当于forEach,返回全部是undefiend的数组，[undefined, undefined, undefined]

　　　3.filter: 过滤 ,返回符合条件所有元素的数组。

1）过滤一些不合格元素，如果回调函数返回true，就留下来

3）不会改变原始数组，不会对空数组进行检测

4.some :检测数组中是否有元素符合条件。返回true或false

类似查找，数组里面某一个元素符合条件，返回true

5.every :检测数值中的每个元素是否都符合条件。返回true或false

数组里面所有元素都符合条件，返回true

II.参数不同。两个参数：(回调函数(计算结束后的返回值, 当前元素, 当前元素的索引, 原数组), 传递给函数的初始值)

　　1.reduce :将数组元素计算为一个值（从左到右）。返回计算结果

　　2.reduceRight :将数组元素计算为一个值（从右到左）。返回计算结果

// 1. forEach:代替普通for循环,没有返回值

let arr=['apple','banana','orange'];

let newarr=arr.forEach(function(val,index,arr){
    console.log(val,index,arr);
    // apple 0  ["apple", "banana", "orange"]
    // banana 1  ["apple", "banana", "orange"]
    // orange 2  ["apple", "banana", "orange"]
});
console.log(newarr);//undefined

// 2.map 重新整理数据结构

let arr=['apple','banana','orange'];

var newArr=arr.map(function(item,index,arr){
    return item+'123';
});
console.log(newArr); // ["apple123", "banana123", "orange123"]
console.log(arr);//["apple", "banana", "orange"]


// 3.filter:过滤 过滤一些不合格元素，如果回调函数返回true，就留下来

let arr=[{
    name:'as',age:12
},{
    name:'asas',age:21
},{
    name:'xcxc',age:18
}]

var newArr=arr.filter((item,index,arr)=>{
    return item.age<20;
});
console.log(newArr);//0: {name: "as", age: 12} 1: {name: "xcxc", age: 18}
console.log(arr);//原数组不变

// 4.some :类似查找，数组里面某一个元素符合条件，返回true

let arr=['apple','banana','orange'];

var newArr=arr.some((val,index,arr)=>{
    return val=='apple'
})
console.log(newArr);//true

// 5.every:数组里面所有元素都符合条件，返回true

let arr=[1,3,9,8];

var newArr=arr.every((val,index,arr)=>{
    return val<10
})
console.log(newArr);//true

// 6.reduce ,从左到右
// 求数组的和，
let arr=[1,2,3,4,5];

let res=arr.reduce((prev,cur,index,arr)=>{
    console.log(prev);//1,3,6,10
    return prev+cur;
});
console.log(res);//15


// 7.reduceRight ,从右到左

let arr=[1,2,3,4,5];

let res=arr.reduceRight((prev,cur,index,arr)=>{
    console.log(prev);//5,9,12,14
    return prev+cur;
});
console.log(res);//15

III. 循环for of

let arr=['a','b','c'];

for(let val of arr){
    console.log(val);// a b c
}

// keys() 数组下标 。用于从数组创建一个包含数组键的可迭代对象。
let keys=arr.keys();
console.log(keys.next().value);//0

for(let index of arr.keys()){  
    console.log(index);// 0 1 2
}

// entries() 数组某一项。返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
var entries=arr.entries();
console.log(entries.next().value);//[0, "a"]

for(let item of arr.entries()){
    console.log(item);//[0, "a"] [1, "b"]  [2, "c"]
    console.log(item[0]); // 0 1 2
}

for(let [index,val] of arr.entries()){
    console.log(index);// 0 1 2
    console.log(val);// a b c
}

IV 循环中的return，break报错：Illegal break statement

　　可以用 some（return true;），every,跳出循环

// every 
// return true ;return false ; 跳出循环  返回 1

let arr=[1,2,3];

arr.every(function(val) {
    if(val==2){
        return false;
    }
    console.log(val);//1

}, this);


// some 
// return true ;跳出循环  返回 1
// return false ;跳出本次循环  返回 1,3

let arr=[1,2,3];
arr.some(function(val) {
    if(val==2){
        return true;
    }
    console.log(val);//1

}, this);


// forEach,filter ,map
// return true ;return false ;跳出本次循环  返回 1,3

let arr=[1,2,3];
arr.map (function(val) {
    if(val==2){
        return false;
    }
    console.log(val);//1

}, this);

二、类数组（eg：arguments）

属性要为索引(数字)属性,必须有length属性，最好加上push

1.可以利用属性名模拟数组的特性

2.可以动态的增长length属性

3.如果强行让类数组调用push方法，则会根据length属性值的位置进行属性的扩充

var obj={
    '2':'a',
    '3':'b',
    'length':2,
    'push':Array.prototype.push,
}
obj.push('d');
obj.push('e');
obj.push('f');
//obj-> {2: "d", 3: "e", 4: "f", length: 5, push: ƒ}
Array.prototype.push=function(target){
    obj[obj.length]=target;
    obj.lenth++;
}

posted @ 2018-08-21 17:38 yuesu 阅读(219) 评论(0) 收藏举报

刷新页面返回顶部

数组，类数组

一、数组

1.数组的定义

1） 字面量 var arr=[1,2,3];

2）构造方法 new Array(length/content)

2.数组的方法

1）改变原数组 ：push ,pop ,shift, unshift ，reverse , splice ，sort

2）不改变原数组：concat ，toString，slice，join <=> split

5.数组循环的方法

I.参数相同 。两个参数：(循环回调函数(当前元素，当前元素的索引，原数组),this指向谁)

不会改变原始数组 ，不会对空数组进行检测

1.forEach :代替普通for循环,没有返回值

2.map :通过指定函数处理数组的每个元素，并返回处理后的数组。

1） 正常情况下，需要return，返回一个新数组

2） 若是没有return,相当于forEach,返回全部是undefiend的数组，[undefined, undefined, undefined]

3.filter: 过滤 ,返回符合条件所有元素的数组。

1）过滤一些不合格元素，如果回调函数返回true，就留下来

3）不会改变原始数组 ，不会对空数组进行检测

4.some :检测数组中是否有元素符合条件。返回true或false

类似查找，数组里面某一个元素符合条件，返回true

5.every :检测数值中的每个元素是否都符合条件。返回true或false

数组里面所有元素都符合条件，返回true

II.参数不同 。两个参数：(回调函数(计算结束后的返回值, 当前元素, 当前元素的索引, 原数组), 传递给函数的初始值)

1.reduce :将数组元素计算为一个值（从左到右）。返回计算结果

2.reduceRight :将数组元素计算为一个值（从右到左）。返回计算结果

III. 循环for of

二、类数组 （eg：arguments）

属性要为索引(数字)属性,必须有length属性，最好加上push

1.可以利用属性名模拟数组的特性

2.可以动态的增长length属性

3.如果强行让类数组调用push方法，则会根据length属性值的位置进行属性的扩充

公告

　　1）字面量 var arr=[1,2,3];

　　2）构造方法 new Array(length/content)

　　1）改变原数组：push ,pop ,shift, unshift ，reverse , splice ，sort

　　2）不改变原数组：concat ，toString，slice，join <=> split

I.参数相同。两个参数：(循环回调函数(当前元素，当前元素的索引，原数组),this指向谁)

不会改变原始数组，不会对空数组进行检测

1）正常情况下，需要return，返回一个新数组

2）若是没有return,相当于forEach,返回全部是undefiend的数组，[undefined, undefined, undefined]

　　　3.filter: 过滤 ,返回符合条件所有元素的数组。

3）不会改变原始数组，不会对空数组进行检测

II.参数不同。两个参数：(回调函数(计算结束后的返回值, 当前元素, 当前元素的索引, 原数组), 传递给函数的初始值)

　　1.reduce :将数组元素计算为一个值（从左到右）。返回计算结果

　　2.reduceRight :将数组元素计算为一个值（从右到左）。返回计算结果

二、类数组（eg：arguments）