4、数组（上）

1、认识数组

/
数组
存储一大推数据。
为什么要用数组： 存储整个班级所有的成绩。
【注】有处理批量同类型数据的需求，发明数组，存储批量的数据。
数据类型：
==基本数据类型：==
++数字、字符串、布尔值++、
==特殊数据类型：==
(++null undefined NaN++)
==复合数据类型：==
++数组、函数。++
/

/*
语法：
数组：array 简写arr
【注】虽然可以存任意类型的值，一般情况下，存储同类型的批量数据。
声明数组

1、通过new关键字声明

                括号里面，可以传，你要去存储的数据，值用逗号隔开。  

【注】如果括号里，只传一个数据，并且这个数据是数字，声明我要申请的数组的长度。
*/

var arr1 = new Array(10);
            alert(arr1);
            // var arr1 = new Array(10, true, "hello");
            // alert(arr1); //10,true,hello

2、声明new关键字声明

        var arr2 = Array(10, true, "hello");
        // alert(arr2); //10,true,hello

3、声明数组

数组的常量形式 [数据1, 数据2, 数据3];

var arr3 = [10, true, "hello"];
            // alert(arr3);
            
            /*
                arr1 arr2 arr3 数组名字
                元素： 每一个数据/每一位住户 
            */

            /*
                找房间去访问元素
                官方：通过下标去访问元素。房间号是从0开始的。
                格式：
                    数组名[下标];
                    【注】就是当做一个普通变量使用。
            */
            /*alert(arr3[1]);

            arr3[1] = "world";

            alert(arr3);*/

2、数组的操作

length
功能是：输出数组的长度。
格式：数组.length

// var arr = [10, 20, 30, 40, 50];
            // alert(arr.length);

            //arr[0] arr[1]

数组的遍历(逐个访问)
【注】循环和数组是一对好夫妻。
【注】遍历访问。

        /*for(var i = 0; i < arr.length; i++){
            alert(arr[i]);
        }*/

        /*
            1、声明一个长度为10的数组
            2、每一个元素，存储一个0~9的随机数。
            Math.random();
            【注】遍历赋值。
        */
        /*var arr = new Array(10);
        // alert(arr.length);
        for(var i = 0; i < arr.length; i++){
            //生成随机数
            var tmp = parseInt(Math.random() * 10);
            arr[i] = tmp;
        }
        alert(arr);*/

        /*
            1、声明长度为25的数组
            存储1~25的数

            2、再去遍历数组，将数组中的元素求和。
        */
        
        var arr = new Array(25);
        alert(arr.length)
        //赋值
        for(var i = 0; i < arr.length; i++){
            arr[i] = i + 1;
        
        }
        alert(arr);

        //求和
        var sum = 0;
        for(var i = 0; i < arr.length; i++){
            sum += arr[i];
        }
        alert(sum); //325


        /*
        【注】for...in要比for循还快。
        【注】快速遍历/快速枚举
            i 就是下标。
            格式:
            for(var i in arr){
                
            }
        */
        var arr = [10, 20, 30, 40, 50];
        for(var j in arr){
            alert(arr[j] + ", " + j);
        }
        

for in

/
for循环 侧重循环 能用于计算
for...in 遍历（Bug）遍历的时候，不能对数组有任何操作。
/

/
splice(start, length, 数据1, 数据2...)
值：数组，数组放着，截取出来的元素
/

            //增  
            var arr = [10, 20, 30, 40];
            /*arr.splice(1, 0, 90, 100);
            alert(arr);*/
            
            //改（先删除后增加）
            /*arr.splice(1, 2, 90, 100);
            alert(arr);*/

            //删除
            var newArr = arr.splice(1, 1);
            alert(arr);
            alert(newArr.length);
            
            var arr1 = [10, 20, 30];

3、数组方法

栈 木盆
特点：从一头放，从同一头取。
特点：先进后出。
数组通过方法，模拟栈结构。

push()
【格式】数组.push()
【括号里，传数据】：数据个数随意，逗号隔开
【功能】给原数组的末尾添加元素。
【调用函数以后的值】添加完元素以后，数组的长度。

var arr = ["钢铁侠", "星爵", "猩红女巫"];
                var result = arr.push("格鲁特", "蚁人", "金刚狼");
                // alert(arr);
                alert(result);

pop()
【格式】数组.pop()
括号内不传任何数据
【功能】从数组末尾取元素，每次只能取一个元素。

/*var arr = ["钢铁侠", "星爵", "猩红女巫", "美国队长"];
            var result = arr.pop();
            alert(result);
            alert(arr);*/

队列：从一头进，从另外一头出，叫队列。
特点：先进先出

push
shift()
【格式】数组.shift()
【功能】从数组的头部取一个元素，每次只能取一个。

var arr = ["钢铁侠", "星爵", "猩红女巫", "美国队长"];
                var result = arr.shift();
                alert(arr);
                alert(result);

unshift()
【格式】数组.unshift()
【功能】从数组的头部插数据，可以传数据，数据的个数随意，用逗号隔开。
【调用函数以后的值】添加完元素以后，数组的长度。

var arr = ["钢铁侠", "星爵", "猩红女巫", "美国队长"];
            var result = arr.unshift("绿巨人", "雷神");
            alert(arr);
            alert(result);
            
            
            /*var num1 = 10;
            var num2 = num1;
            num2 = 20;
            alert(num1);
            alert(num2);*/

数据类型：
基本数据类型
复合数据类型/引用数据类型
别的语言叫做指针
【注】复合数据类型不要直接赋值，本质上是地址的赋值。

/*          var arr1 = [10, 20, 30];
            var arr2 = arr1;
            arr2.push(50);
            alert(arr1);
            alert(arr2);*/

==concat()==
【格式】数组.concat()
【括号传数据】 ++数据是数组，数组每个元素拼接，新成功一个新的数组。++
==【功能】克隆出一个新数组==

/*          var arr1 = [10, 20, 30];
            var arr2 = arr1.concat();
            arr2.push(50);
            alert(arr1);
            alert(arr2);*/
            /*var arr1 = ["美国队长", "黑寡妇"];
            var arr2 = ["钢铁侠", "绿巨人"];
            var arr = arr1.concat(arr2);
            alert(arr);
            alert(arr1);
            alert(arr2);*/

==slice==
【格式】数组.slice(start, end); [start, end)
++【功能】将数组中下标==从start开始到end结束，但是不包括end位置的元素==，==提取出来以后，生成一个新的数组。==++

/*          var arr = [10, 20, 30, 40, 50];
            var newArr = arr.slice(1, 3);
            alert(newArr);
            alert(arr);*/

==splice()==
【格式】数组.splice(start, length, 元素1, 元素2 ...);
++第一个传入数据start:开始下标
第二个传入的参数length: 长度
从第三个传入的参数开始，要传入的元素。++
==【功能】可以根据不同的传参实现增、删、改==
【值】截取的元素。

            // var arr = [];
            //删除
            /*var arr = [10, 20, 30, 40, 50];
            var result = arr.splice(1, 2);
            alert(arr);
            alert(result);*/

            //增
            /*var arr = [10, 20, 30, 40, 50];
            var result = arr.splice(2, 0, 90, 100);
            alert(arr);
            alert(result);
*/      
            //改
            /*var arr = [10, 20, 30, 40, 50];
            arr.splice(2, 1, 100);
            alert(arr);*/

定义一个含有30个整型元素的数组，按顺序分别赋予从2开始的偶数；
然后按顺序每五个数求出一个平均值，
放在另一个数组中并输出。试编程。
            /*var arr = new Array(30);
            //1、给数组填充元素
            for(var i = 0; i < arr.length; i++){
                arr[i] = (i + 1) * 2;
            }
            alert(arr);*/

            var arr = []; //声明空数组
            for(var i = 0; i < 30; i++){
                arr.push((i + 1) * 2);

                // arr[i] = (i + 1) * 2;
            }
            alert(arr);

            //存平均数
方法一     /*var averagesArr = []; 
            for(var i = 0; i < 6; i++){
                //取五位元素出来
                var tmpArr = arr.splice(0, 5);
                var sum = 0;
                //计算平均数
                for(var j = 0; j < tmpArr.length; j++){
                    sum = sum + tmpArr[j];
                }
                averagesArr.push(sum / 5);
            }
            alert(averagesArr);*/


方法二     var sum = 0; //求和 每五个元素求一次和
            var averagesArr = [];
            for(var i in arr){
                sum += arr[i];
                i++;
                if(i % 5 == 0){
                    //每五个数会执行一遍这里
                    averagesArr.push(sum / 5);
                    sum = 0;
                }               
            }
            alert(averagesArr); //6,16,26,36,46，56

slice
功能：提取对应范围的元素，形成新数组。对原数组没有任何影响。
格式：数组.slice(start, end) [start,end)

splice
功能：截取，直接从原数组上截取元素下来。
格式：数组.splice(start, length);

reverse()改变原数组；

4、内存

基本数据类型内存分析

复合数据类型内存分析

内存分析

                    外设
                    CPU 
                    GPU（显卡） 
                    主板
                    内存
                    硬盘

                    硬盘 -> 内存
                    内存运行程序环境


                    程序被CPU运行


                    程序读到内存里面  CPU必须先找到程序才能运行。
                    32位
                    64位
                    可最大寻址基数

                    每一个1或者0 每一个开关到要进行编号。

                var num = 10;

计算机基础

  计算机的基本原理是:存储程序和程序控制。预先要把指挥计算机如何进行操作的指令序列（称为程序）和原始数据通过输入设备输送到计算机内存贮器中。每一条指令中明确规定了计算机从哪个地址取数，进行什么操作，然后送到什么地址去等步骤。

  ++冯·诺依曼结构++也称普林斯顿结构，是一种将程序指令存储器和数据存储器合并在一起的存储器结构。程序指令存储地址和数据存储地址指向同一个存储器的不同物理位置，因此程序指令和数据的宽度相同，如英特尔公司的8086中央处理器的程序指令和数据都是16位宽。

  计算机在运行时，先从内存中取出第一条指令，通过控制器的译码，按指令的要求，从存储器中取出数据进行指定的运算和逻辑操作等加工，然后再按地址把结果送到内存中去。接下来，再取出第二条指令，在控制器的指挥下完成规定操作。依此进行下去。直至遇到停止指令。

  程序与数据一样存贮，按程序编排的顺序，一步一步地取出指令，自动地完成指令规定的操作是计算机最基本的工作原理。这一原理最初是由美籍匈牙利数学家冯.诺依曼于1945年提出来的，故称为冯.诺依曼原理。