js数组 day4

  • 数组的概念及定义

概念:数组为一组一般情况下相同类型的数据。

除了 Object 类型之外,Array 类型是ECMAScript 最常用的类型。而且 ECMAScript 中的        Array 类型和其他语言中的数组有着很大的区别。 虽然数组都是有序排列, 但 ECMAScript       中的数组每个元素可以保存任何类型。ECMAScript 中数组的大小也是可以调整的。

  • 数组的创建方式
  1. 第一种是 new 运算符(构造函数);

注意:给构造函数传递一个值也可以创建数组。如果传递的是数字,则会按照该数自创建包含       给定项数的数组;而如果传递的是其他类型的参数,则会创建包含那个值的只有一项的数组。

    1. 第二种是字面量(json格式);

在计算机科学中,字面量是用于表达源代码中一个固定值的表示法。

  • 数组的length和下标
    1. 使用索引下标来读取数组的值--下标是固定的,从0开始
    2. 数组的length属性--代表长度,数组的 length 属性不只是只读的。通过设置这个属性,可以从数组的末尾移除项或向数      组中添加新项。
    3. 数组的遍历--for循环
  1. 检测数组:Array.isArray() 静态方法(对象的构造函数开头的)

Array.isArray():确定括号中的某个值到底是不是数组

  • 数组的方法--传统方法
  1. push() 可以接收任意数量的参数,把它们逐个添加到数组末尾,并返回修改后数组的长度。
  2. pop() 从数组末尾移除最后一项,减少数组的length值,然后返回移除的项。
  3. unshift()方法能够在数组前端添加任意个项并返回新数组的长度。
  4. shift() 方法能够移除数组中的第一个项并返回该项,同时将数组长度减 1。
  5. reverse() 方法会反转数组项的顺序。
  6. sort() 方法按字母表升序排列数组项。
  7. 注意:如果按照其他方式而非字母表顺序进行数组排列,必须给sort方法传递一个比较函         数做参数。
  8. concat() 方法可以基于当前数组中的所有项创建一个新数组。
  9. slice() 方法它能够基于当前数组中的一或多个项创建一个新数组。可以接受一或两个参数,即要返回项的起始和结束位置,不包括结束位置。
  10. splice() 方法,对数组进行删除、插入、替换,是最强大的数组方法。返回值是数组。
  11. join()方法,将数组转换成对应的字符串。参数就是连接符。
  • 整数数组/字符串数组/对象数组/二维数组
  • 数组的排序(冒泡排序、选择排序)
  • 强化练习
  1. 随机生成一个五位以内的数,然后输出该数共有多少位,分别是什么。
  2. 数组的冒泡排序(封装函数)
  3. 数组的选择排序(封装函数)
  4. 编写函数map(arr) 把数组中的每一位数字都增加30%
  5. 编写函数has(arr , 60) 判断数组中是否存在60这个元素,返回布尔类型
  • 综合应用
  1. 编写函数norepeat(arr) 将数组的重复元素去掉,并返回新的数组。
  2. 有一个从小到大排好序的数组。现输入一个数,要求按原来的规律将它插入数组中。
  3. 定义一个含有30个整型元素的数组,按顺序分别赋予从2开始的偶数;然后按顺序每五个数求出一个平均值,放在另一个数组中并输出。试编程。
  4. 通过循环按行顺序为一个5×5的二维数组a赋1到25的自然数,然后输出该数组的左下半三角。试编程。

<script type="text/javascript">
            //一.利用构造函数创建数组。
            //构造函数:构造函数也是函数,特点是首字母大写,同时需要new运算符进行调用。
            /*function Array(){//系统定义的,无需自己定义,直接调用。
                
            }*/
            
            //1.对象下面都拥有属性和方法,通过点操作符操作。
            //Array:构造函数,它下面也会出现一些方法,静态方法。
            //var arr1=new Array(100,200,300,400);//定义一个数组。 arr1:数组对象。Array:构造函数
            //数组对象的属性--length:数组里面数组项的长度。
            //alert(arr1.length);//4
            //alert(arr2.length);//3
            
            //2.数组名等同于数组的所有值。
            //alert(arr1);//100,200,300,400
            //console.log(arr1);//[100, 200, 300, 400]
            
            //3.通过length属性修改(添加,删除)数组
            //console.log(arr1);//[100, 200, 300, 400]
            //arr1.length=2;
            //console.log(arr1);// [100, 200]
            
            //console.log(arr1);//[100, 200, 300, 400]
            //arr1.length=10;
            //console.log(arr1);//[100, 200, 300, 400, empty × 6]
            //alert(arr1);//100,200,300,400,,,,,,
            
            
            //4.数组的索引,也叫下标,通过下标(默认的索引编号)来访问数组中的某一个值。
            //数组的索引下标从0开始。  数组名[下标]  arr[3]:访问数组第四个位置的值。
            //数组都是有序排列
            //var arr2=new Array('zhangsan','lisi','wangwu');
            //alert(arr2[0]);//zhangsan
            //alert(arr2[2]);//wangwu
            //alert(arr2[8]);//undefined 值不存在。
            
            //5.数组的下标也是动态的,通过数组的下标改变数组的长度。
            //alert(arr2.length);//3
            //arr2[9]='ending';
            //alert(arr2.length);//10
            
            
            
            //6.数组的类型
            //var arr2=new Array('zhangsan','lisi','wangwu');
            //alert(typeof arr2);//object
            
            
            //总结:
            //1.通过构造函数创建数组。
            //2.通过数组的length属性和索引下标动态的改变数组。
            //3.数组的名称是所有数组项的值
            //4.数组的类型是对象。
            
            
            //二.利用字面量的简洁方式定义数组--常用的
            //在计算机科学中,字面量是用于表达源代码中一个固定值的表示法。
            //var arr2=new Array('zhangsan','lisi','wangwu');
            /*var arr2=['zhangsan','lisi','wangwu'];
            alert(arr2.length);//3
            alert(arr2[1]);//lisi*/
            
            
            //三.构造函数创建和字面量创建数组区别
            //给构造函数传递一个值也可以创建数组。如果传递的是数字,则会按照该数自创建包含给定项数目的数组;而如果传递的是其他类型的参数,则会创建包含那个值的只有一项的数组。
            //var arr=new Array(3);//3不是数组的第一项,代表是数组的长度
            //alert(arr[0]);//undefined
            //alert(arr.length);//3
            //console.log(arr);//[empty × 3]
            
            /*var arr=new Array('hello');
            alert(arr[0]);//hello
            alert(arr.length);//1*/
            
            
            /*var arr=[3];//字面量创建没有上面的问题。
            alert(arr[0]);//3
            alert(arr.length);*///1

<script type="text/javascript">
            //1.数组的遍历--for循环
            //var arr=['apple','banana','pear','orange','group'];//索引0-4
            /*for(var i=0;i<arr.length;i++){
                alert(arr[i]);
            }*/
            
            //2.检测数组:Array.isArray() 静态方法(对象的构造函数开头的)固定的方法。
            //确定括号中的某个值到底是不是数组,返回布尔值

            //var arr=null;
            //var arr1=[1,2,3,4];
            //alert(typeof null);//object
            //alert(typeof arr);//object
            //alert(Array.isArray(arr));//false
            //alert(Array.isArray(arr1));//true
        </script>

数组的方法一:

改变原数组

<script type="text/javascript">
        //1.push() 可以接收任意数量的参数,把它们逐个添加到数组末尾,并返回修改后数组的长度。
        var arr=['apple','banana'];
        console.log(arr);//["apple", "banana"]
        console.log(arr.push('pear','orange','group'));//5
        console.log(arr);///["apple", "banana", "pear", "orange", "group"]
        /*var arr=['apple','banana'];
        arr.push('pear');
        arr.push('apple');
        arr.push('apple');
        console.log(arr);*/
        //2.pop() 从数组末尾移除最后一项,减少数组的length值,然后返回移除的项。
        //只能一项一项进行移除。
        /*var arr=["apple", "banana", "pear", "orange", "group"];
        arr.pop();//group
        arr.pop();//orange
        arr.pop();//pear
        console.log(arr);*/
        //3.unshift()方法能够在数组前端添加任意个项并返回新数组的长度。
        /*var arr=['one'];
        arr.unshift('two','three');//["two", "three", "one"]
        console.log(arr);*/
        //4.shift() 方法能够移除数组中的第一个项并返回该项,同时将数组长度减 1。
        /*var arr=["two", "three", "one"];
        arr.shift();
        console.log(arr);*/
        
        //5.reverse() 方法会反转数组项的顺序。
        //var arr=[100,200,300,400,500];
        //arr.reverse();
        //console.log(arr);//[500, 400, 300, 200, 100]
        
        //6.sort() 方法按字母表升序排列数组项。(unicode编码)
        //注意:如果按照其他方式而非字母表顺序进行数组排列,必须给sort方法传递一个比较函数做参数。
        /*var arr=[ "banana", "pear","apple", "orange", "group"];
        arr.sort();
        console.log(arr);*///["apple", "banana", "group", "orange", "pear"]
        
        //A-Z   unicode   65-90
        //a-z   unicode   97-122
        //0-9   unicode   48-57
        
        /*var arr=[9,6,3,8,5,2,1,4,7,0];
        arr.sort();//按照unicode编码进行排列
        console.log(arr);// [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]*/
        
        
        //问题:无法对象正常的数字进行排序。
        //如果需要排序数字,提供一个比较函数实现,将比较函数当中sort的参数传递,对数字进行排序。
        /*function compare(a,b){
            if(a>b){
                return 1;
            }else if(a<b){
                return -1;
            }else{
                return 0;
            }
        }*/
        /*function compare(a,b){
            return a-b;
        }*/
        
        //var arr=[91,620,3,89,50,212,1000,45,7,-23,7,3];
        //arr.sort(compare);
        /*arr.sort(function(a,b){
            return a-b;
        });
        console.log(arr);*/// [-23, 3, 3, 7, 7, 45, 50, 89, 91, 212, 620, 1000]
        
        //总结:上面这些方法会改变原数组。
        </script>

<script type="text/javascript">
        //7.concat() 方法可以基于当前数组中的所有项创建一个新数组。
        //var arr=[ "banana", "pear","apple", "orange", "group"];
        //var arr1=[1,2,3,4,5,6];
        /*var newarr=arr.concat();//拷贝
        console.log(arr);
        console.log(newarr);*/
        
        //concat的参数:多个值,也可以是数组,全部拼接成一个数组
        /*var newarr=arr.concat('hehe','haha',arr,arr,arr1);
        console.log(arr);
        console.log(newarr);*/
        //console.log(arr1.concat(arr1,arr1));
        
        
        //8.slice() 方法它能够基于当前数组中的一或多个项创建一个新数组。可以接受一或两个参数(索引下标的位置),即要返回项的起始和结束位置,不包括结束位置。
        //var arr=[ "banana", "pear","apple", "orange", "group"];
        //console.log(arr.slice(0,3));//[ "banana", "pear","apple"]
        //console.log(arr.slice());//没有参数,截取全部  ["banana", "pear", "apple", "orange", "group"]
        //console.log(arr.slice(0));//从0索引下标开始截取["banana", "pear", "apple", "orange", "group"]
        //console.log(arr.slice(2));//从2索引下标开始截取 ["apple", "orange", "group"]
        //console.log(arr.slice(100));//[]
        //console.log(arr.slice(0,-2));//负数从后往前数。[ "banana", "pear","apple"]
        //console.log(arr.slice(-5,-2));//[ "banana", "pear","apple"]
        //console.log(arr.slice(0,3));//[ "banana", "pear","apple"]
        //console.log(arr.slice(-10,-7));//[]
        //js的规律:如果是两个位置做参数,一般不包括结束位置。
        
        //9.splice() 方法,对数组进行删除、插入、替换,是最强大的数组方法。返回值是数组,会改变原数组。
        //var arr=[ "banana", "pear","apple", "group"];
        //console.log(arr);
        //删除--主要功能。
        //第一个参数:开始的位置   第二个参数:删除的长度。
        //返回值就是删除的数组项。
        //console.log(arr.splice(1,2));//["pear","apple"]
        //console.log(arr);// ["banana", "group"]
        
        //插入:
        //第一个参数:开始的位置   第二个参数:删除的长度。从第三个参数开始就是插入到数组的数组项。
        //从设置的位置开始插入。
        /*console.log(arr.splice(1,0,'zhangsan','lisi','wangwu'));
        console.log(arr);*/
        
        
        //替换:
        //console.log(arr.splice(1,2,'hehe','haha'));//["pear","apple"]
        //console.log(arr);//["banana", "hehe", "haha", "group"]
        
        //10.join()方法,将数组转换成对应的字符串。参数就是连接符。
        //var arr1=['a','b','c','d'];
        //console.log(arr1.join());//a,b,c,d
        //console.log(typeof arr1.join());//string
        //console.log(arr1.join('#'));//a#b#c#d
        //console.log(arr1.join(''));//abcd  空隙
        //console.log(arr1.join(' '));//a b c d  空格
        
        
        //var arr2=['my','name','is','zhangsan'];
        //console.log(arr2.join(' '));
        //console.log(arr2.reverse().join(' '));//zhangsan is name my
        
        
        </script>js规律:如果是两个位置做参数,一般不包括结束位置;

数组的类型:<script type="text/javascript">
            //1.二维数组:数组里面嵌套数组。
            //获取多维数组的值。
            //var arr=[1,2,3,[4,'hello',['a','c'],6],7,[8,9]];
            //alert(arr[3][1]);
            //alert(arr[3][2][1])
            
            //二维数组赋值
            var arr=['a','b'];
            //arr[2][0]=10;//不能直接给二维数组赋值。
            arr[2]=[];//先确认数组的某项是数组。
            arr[2][0]=10;
            arr[2][1]=100;
            arr[2][5]=1000;
            console.log(arr);

        </script>

 

 

 

 

 

 

 

 

 

 

 

 

 

day5:script type="text/javascript">
        //定义一个含有30个整型元素的数组,按顺序分别赋予从2开始的偶数;
        //然后按顺序每五个数求出一个平均值,放在另一个数组中并输出。试编程。
        //1.创建数组
        /*var arr=[];
        for(var i=1;i<=30;i++){
            arr.push(2*i);
        }
        console.log(arr);
        
        //2.五个数求出一个平均值,放在另一个数组中并输出;
        var newarr=[];
        var svg=0;//平均值
        for(var j=0;j<arr.length;j++){
            svg+=arr[j];
            if((j+1)%5==0){
                newarr.push(svg/5);//将5个数字和的平均值给新数组
                svg=0;
            }
        }
        console.log(newarr);*/
        
        
        //4.通过循环按行顺序为一个5×5的二维数组arr赋1到25的自然数,然后输出该数组的左下半三角。试编程。
        //var arr=[[1,2,3,4,5],[6,7,8,9,10]......]
        //arr[0][0]  arr[0][1]  arr[0][2]  arr[0][3]  arr[0][4]
        
        function double(n){
            return n<10 ? '0'+n : n;
        }
        var arr=[];
        var num=1;
        for(var i=0;i<5;i++){
            arr[i]=[];//数组的每一项还是数组
            for(var j=0;j<5;j++){
                arr[i][j]=double(num++);
                if(i>=j){
                    document.write(arr[i][j]+'&nbsp;&nbsp;&nbsp;&nbsp;');    
                }
            }
            document.write('<br>');
        }
        </script>

 

  • 新增数组操作方法
    1. 位置方法----indexOf()  lastIndexOf()返回要查找的项在数组中的索引位置,没找到的情况下返回-1。(两个参数:要查找的项和(可选的)表示查找起点位置的索引)

indexOf() 方法从数组的开头开始向后查找。

lastIndexOf() 方法则从数组的末尾开始向前查找。

  1. 迭代方法(不会改变原数组)

迭代是重复反馈过程的活动,其目的通常是为了逼近所需目标或结果。每一次对过程的重       复称为一次“迭代”,而每一次迭代得到的结果会作为下一次迭代的初始值。

两个参数:

第一个参数:要在每一项上运行的函数

此函数会接收三个参数:数组项的值、该项在数组中的位置、数组对象本身。

第二个参数:(可选的)运行该函数的作用域对象(影响 this 的值)。

every()

对数组中的每一项运行给定函数,如果该函数对每一项都返回 true ,则返回 true 。

some()

对数组中的每一项运行给定函数,如果该函数对任意一项返回 true ,则返回 true 。

filter()

对数组中的每一项运行给定函数,返回该函数结果为 true 的项组成的数组。

  1. 利用filter 来去除数字重复;

Var  arr=[5,5,533,33,55,66,66,11,23,43,43]

Var  arr2=arr.filter(function(a,b){

Return   arr.indexOf(a)==b//满足条件的会输出来,返回的是一个新的数组

})

Console.log(arr2)

       

map()

对数组中的每一项运行给定函数,返回每次函数调用的结果组成的数组

返回就是数组,不考虑true或者false;

forEach() :对数组中的每一项运行给定函数。这个方法没有返回值。

以上方法都不会修改数组中的包含的值。

    1. 归并方法---- reduce()  reduceRight()

这两个方法都会迭代数组的所有项,然后构建一个最终返回的值。

reduce() 方法从数组的第一项开始,逐个遍历到最后。

reduceRight() 方法从数组的最后一项开始,向前遍历到第一项。

两个参数:每一项上调用的函数和(可选的)作为归并的初始值。

调用的函数接收 4 个参数:前一个值、当前值、项的索引和数组对象。

  • 对象的本质和意义

对象是javascript的数据类型。对象是一种复合值,它将很多值聚合在一起,可通过名字访 问这些值。对象也看做是属性的无序集合,每个属性都是一个名/值对。

  • 对象的创建
    1. 构造函数创建对象--var obj=new Object();
    2. 字面量创建对象--var obj={ };
  • JSON表示对象的方法:利用json的方式创建对象。(类似于字面量创建对象)

JSON 是一种轻量级的数据交换格式。它是基于 ECMAScript的一个子集,采用完全独立于编       程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 JSON 成为理想的数据交换       语言。 易于人阅读和编写,同时也易于机器解析和生成,并有效地提升网络传输效率。

  • JSON的特点
    1. json: 是一种轻量级的数据交换格式。不是js独有的。
    2. json组成:简单值+对象+数组。
    3. json里面字符串需要添加双引号。
    4. json没有var关键字,没有分号(;)
  • 对象的遍历--for...in循环
  • 值传递和引用传递。
    1. 栈:自动分配内存空间,系统自动释放,基本类型的值和引用类型的地址
    2. 堆:动态分配的内存,大小不定,也不会自动释放。存放引用类型的值。

 

  • 强化练习
  1. 使用json形式创建一个对象,该对象存储一个学生的信息,该对象包含姓名,学号、身份        证、年龄、性别、所学专业等属性信息,同时该对象包含一个自我介绍的方法,用来输出               该对象的所有信息。
  2. 随机点名程序。
  3. 扩展案例:快速排序的实现。
  4. 扩展案例:多种方式实现数组去重。
  5. 扩展案例:数组的扁平化。

<script type="text/javascript">
            //1.indexOf/lastIndexOf
            /*var arr=['zhangsan','lisi','wangwu','zhaoliu','lisi','wangwu'];
            alert(arr.indexOf('lisi'));//1
            alert(arr.indexOf('lisi',2));//4
            alert(arr.lastIndexOf('lisi'));//4*/
            
            //2.迭代方法
            //every
/*            var arr=['zhangsan','lisi','wangwu',123,'lisi','wangwu'];
            var newarr=[];
            var result=arr.every(function(value,index,array){
                //console.log(value);
                //newarr.push(value);
                return typeof value=='string';//每一个数组项都要走一遍函数。
            });
            console.log(result);//false*/
            
            /*var arr=['zhangsan','lisi','wangwu',123,'lisi','wangwu'];
            arr.every(function(value,index,array){
                console.log(typeof value=='string');//一次执行。
            });*/
            
            
            //some:返回值也是一个
            var arr=['zhangsan','lisi','wangwu','123','lisi','wangwu'];
            /*var result=arr.some(function(value,index,array){
                //console.log(typeof value=='string');
                return typeof value=='string';
            });
            console.log('结果:'+result);*/
            
            //函数名等于函数体,方法是由函数构建的。
            //alert(alert);//function alert() { [native code] }
            console.log(arr.some(alert));//false
            console.log(arr.some(function alert(a) { }));//false
            console.log(arr.some(function log(a,b,c,d,e,f) { }));//false
            //alert('一个参数');
            //console.log('a','b','c','d');//多个参数
            //alert(console.log)
            //arr.some(console.log);
            
            //filter:返回的是一个数组,结果为true的项。
            //map:返回的是一个数组,不管真假。
            //返回的是map内部的函数返回的值,不管值是否存在,都会返回对应的值。
            /*var arr=['zhangsan','lisi','wangwu',123,'lisi','wangwu'];
            var newarr=arr.filter(function(value){
                console.log(value);
                //return value;
            });
            console.log(newarr);//[]*/
            
            /*var arr=['zhangsan','lisi','wangwu',123,'lisi','wangwu'];
            var newarr=arr.map(function(value){
                //console.log(value);
                return typeof value=='string';
            });
            console.log(newarr);*///[undefined, undefined, undefined, undefined, undefined, undefined]
            
            //forEach:没有返回值,替换for循环
            /*var arr=[123,56,2,89,456,2,7,89,100];
            function fn(arr){
                var newarr=arr.sort(function(a,b){
                    return a-b;
                });
                var minvalue=newarr[0];
                var maxvalue=newarr[newarr.length-1];
                var sum=0;
                arr.forEach(function(v){
                    sum+=v;
                });
                return '数组的最大值:'+maxvalue+'<br/>数组的最小值:'+minvalue+'<br/>数组的和:'+sum;
            }
            document.write(fn(arr))*/
        </script>

day5:

 

猜你喜欢

转载自blog.csdn.net/QiuShuiFuPing/article/details/85041339