《JavaScript高程第六章》

《JavaScript高程第六章》

1、Object

object 是JS中最常见的类型，主要的功能是存贮和交换数据

    let person=new Object();
    person.name="Jack Ma";
    person.age=29;

或者创建对象

    let person={
        "name":"JackMa",
        "age":29,
        "isMan":false;
    }

2、Array数组

（1）创建数组

创建数组的方法1

    let colors=Array("white","black","blue");

创建数组的方法2

    let num=[1,3,5,7,9];

（2）遍历数组

遍历数组方法1 for

    let a=[1,3,5,7,9,11,13,15];
    for(let i=0;i<a.length;i++){
        console.log(a[i]);
    }

遍历数组方法2 forEach()对象方法

    let a=Array(1,3,5,7,9);
    a.forEach(function(item,index,array){
        console.log(item);            //返回各项值
        console.log(index);            //返回各项的索引
    })

    let a=Array(1,3,5,7);
    a.forEach(ele=>console.log(ele));    //输出1,3,5,7,

（3）数组的插入删除

对象方法Push()、pop()、shift()、unshift()

    let a=Array(1,3,5,7,9,11);
    a.push(15);        //在数组末尾添加15
    a.pop();        //弹出末尾的15
    a.unshift(-1);    //在头部添加-1
    a.shift();    //删除头部 -1

（4）数组的索引对象方法 indexof()和lastIndexOf()

    let a=[1,3,5,7,9,1];
    console.log(a.indexOf(1));        //返回0
    console.log(a.indexof(2));        //返回 -1
    console.log(a.lastIndexOf(1));    //返回 5 ，找到最后一个1 的位置
    console.log(a.lastIndexOf(2));    //返回 -1

（5）通过索引删除某个元素，对象方法splice()

splice()方法通过删除或者替换现有元素、或者添加新的元素了来修改数组，并以数组的方式返回被修改的元素。同时此方法会改变原数组

splice(start,howMany,replace); 必需参数start开始的位置，howMany可选参数几个，replace替换的内容

    let a=[1,3,5,7];
    console.log(a.splice(1,2,"replaceString"));        //返回 [3,5]
    console.log(a);            //返回 [1,"replaceString",7]

通过splice复制一个数组 (深拷贝)

    let ar=Array.of("String",1,3,5,true);
    let a=ar.splice('');    //a深拷贝了数组ar

（6）Array类方法from()、isArray()、Array.of()

from()类函数

from(“伪数组”,mapFn[,thisArg])从一个类似数组或者可迭代对象，返回一个新的数组，mapFn如果指定了该参数，新数组中每个元素会执行该回调函数。thisArg执行回调函数mapFn的this对象

    let s=Array.from("13579",ret=>ret*ret);
    console.log(s);            //返回 [1,9,25,49,81]

Sample1 从字符串中生成数组

    let str=Array.from("String");
    console.log(str);            //返回["S","t","i","n","g"]

Sample2 从set生成数组

    let str=new set(["s","t","r","i","n","g"]);
    let sta=Array.from(str);        //此处返回数组 ['s','t','r','i','n','g']

Sample3 from()类函数中使用箭头函数

    let str=new set([1,3,5,7,9]);
    let sta=Array.from(str,x=>x+x);    //此处返回数组    [2,6,10,14,18]

类方法isArray()

判断一个变量是否为数组，返回true或者false

    let a1=Array(1,3,5,7,9);
    console.log(Array.isArray(a1));        //返回的true和false

Array.of()

Array.of()目的是添加相应的元素，不考虑类型，构造成新的数组实例

    let a=Array.of("String",1,3,5,true);
    console.log(a);            //返回数组["String",1,3,5,true]

（7）对象方法concat

concat方法，用于将两个数组进行合并

    let a=Array(1,3,5,7);
    let b=[2,4,6,8];
    let c=a.concat(b);    //返回[1,3,5,7,2,4,6,8];

（8）对象方法copyWithin

copyWithin(目标,开始位置,结束位置) 将一组数据浅拷贝到另一数组上

    let a=Array(1,3,5,7,9);
    let aa=a.copyWithin(a,1,3);
    console.log(aa);    //返回数组    3,5,5,7,9

（9）对象方法entries()

entries返回一个iterator对象，iterator中包含键/值对，key和value

    let a=Array(1,3,5);
    let iterator=a.entries();
    for(let i=0;i<a.length;i++){
        console.log(iterator.next().value);    //返回(0,1)、(1,3)、(2,5);前面是键，后面是值
    }

（10）对象方法every()

every方法，是监测数组中的每一个元素是否通过函数测试，返回布尔值，true或者false

    arr.every(callback(element[, index[, array]])[, thisArg])

Sample 1 判断一个数组中的所有元素是否为质数

every(method); every里面放变量，变量可以是函数，表达式

    const isPrime=(curVal)=>{
        if(curVal==2||curVal==3){
            retrun true;
        }else if(curVal<2){
            return false;
        }
        for(let i=2;i<Math.floor(curVal/2);i++){
            if(curVal%i==0){
                return false;
            }
        }
        return true;
    }
    let a=[2,3,5,7,11];
    console.log(a.every(isPrime));

Sample2 判断数组中的所有元素是否大于0

    const isZero=(curVal)=>curVal>0?true:false;
    let a=[-1,3,5,7,9];
    console.log(a.every(isZero));     //返回false

（11）对象方法some(),判断是否存在

    const lessThanZero=(curVal)=>curVal<0?true:false;
    let a=[1,3,5,7,9,-1];
    console.log(a.some(lessThanZero));    //返回true

（12）对象方法filter，过滤

Sample1 过滤字符串长度大于5的，以数组的方式返回

    let a=Array("String","JackMa","Spring","jhon","tim","ojbk");
    let s=a.filter(curStr=>curStr.length>5);
    console.log(s);        //返回"String","JackMa","Spring"

（13）对象方法find()和findIndex()

find(条件) 方法里面存放判断条件，返回符合条件的第一个参数，findIndex是返回索引

    let a=[1,3,5,7,9,11,13];
    let ret=a.find(curVal=>curVal>10);    //返回11
    let rst=a.findIndex(curVal=>curVal>10)    //返回5

（14）对象方法keys，返回一个数组

    let a=[1,3,5,7,9];
    let s=a.keys();    
    console.log(s);        //0 1 2 3 4

（15）对象方法map，返回一个由回调函数的返回值组成的新数组

map()方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

    let a=[1,3,5,7,9];
    let s=a.map(curVal=>curVal*2);
    console.log(s);        //返回数组[2,6,10,14,18]

（16） reduce对象方法，reduceRight对象方法

reduce方法里面是一个回调函数，callback(AcVal,CurVal,Index,Array);

callBack里面四个参数，分别是累计值，当前值，索引，原数组

Sample1 利用reduce计算累加

    let a=[1,3,5,7,9];
    const calSum=(acVal,CurVal)=>return acVal+CurVal;
    let sum=a.reduce(calsum);

Sample2 利用reduceRight计算累减

    let a=[1,1,1,1,1];
    const func=function(acVal,curVal){
        console.log(acVal+"-"+curVal);    //返回 1-1=0-1=-1-1=-2-1=-3
        return acVal-curVal;
    }
    console.log(a.reduceRight(func));//    最后返回-3

（17）对象方法，value,包含数组中对象的所有的值

ie浏览器不支持，HbuilderX 内置浏览器也不支持

    let a=[1,3,5,7];
    let ret=a.values();
    for(let item in ret){
        console.log(item);    //返回1 3 5 7 
    }

（18）对象方法sort

按照ASCII码来进行排序

    let a=[1,3,5,"str","jack","a"];
    console.log(a.sort());    //返回数组[1,3,5,"a","jack","str"];

（19）ArrayBuffer

ArrayBuffer相当于C语言中的malloc，申请一块内存，按照官方的话就是ArrayBuffer 对象用来表示通用的、固定长度的原始二进制数据缓冲区。

（20）DataView

视图是一个可以从二进制ArrayBuffer 对象中读写多种数值类型的底层接口，使用它时，不用考虑不同平台的字节序问题。

3、Map类

Map对象保存键值对，并且能够记住键的原始插入顺序。任何值（对象或者原始值）都可以作为一个键或者一个值

(1)、描述

一个Map对象在迭代时会根据对象中元素的插入顺序来进行遍历，一个for…of循环在每次迭代后返回一个[key,value]的数组

    let myMap=new Map();
    let keyString="a String";
    let keyFunc=(CurVal)=>{
        return CurVal*2;
    }
    myMap.set(keyString,"这是一个String");
    myMap.set(keyFunc,"这是一个function");
    console.log(myMap.get(keyString));        //返回：这是一个String
    console.log(myMap.get(keyFunc));        //返回：这是一个function

Map和Object的区别

	Map	Object
意外的键	Map默认不包含任何键，只包含显示的键	一个object又一个原型，原型链上的键名有可能和你在对象上的设置的键名产生冲突
键的类型	一个Map键可以是任意值，包括函数，对象或任意基本类型	一个Object的键必须是一个String或者是一个Symbol
键的顺序	Map中的键是有序的。因此，当迭代的时候，一个Map对象以插入的顺序返回键值	一个Object键是无序的
Size	Map中的key是有序的。因此，当迭代的时候，一个Map对象插入的顺序返回值键值	Object的键只能通过手动计算
迭代	Map是iterable的，所以可以直接被迭代	迭代一个Object需要以某种方式获取他的键才能迭代
性能	在频繁的增删改查中表现得更好	在频繁的增删改查中需要优化

(1)、对象方法clear()

clear方法是用于清除所有的键值对

    let m=new Map();
    m.set(1,110);
    m.set(2,120);
    console.log(m.size);//    返回2
    m.clear();        //
    console.log(m.size);//    返回0

(2)、对象方法delete(key)

delete方法，如果存在就删除，返回true，否则返回false

Capter6（Object、Array、Map）