数组

1.数组的基本用法

<script>
        // 1.声明变量的语法
        let arr = new Array()

        // 2.往数组中存放值
        // 用下标来存放
        arr[0] = 10
        arr[1] = 20
        arr[2] = 30
        console.log(arr);

        // 3.修改数组中的值
        // 也是用下标来修改的
        arr[1] = 100

        arr[3] = 10 // 比数组大的话就是 添加数组  你没有添加值就是undefined
        console.log(arr);

        /* 4.下标的几个专业名词
        1.下标：
        2.索引：
         3.元素：就是数组中存放的值 */
    </script>

2.数组的声明方法

1.语法：

let arr =[10,13,12]

3.数组的长度length

1.数组的长度，就是数组的元素的个数

打印数组会发现数组里面会有一个length属性表示数组的长度

	let arr = [12,13,14]
 	console.log(arr);
    console.log(arr.length); //打印一下数组的长度length

2.数组的长度，是数组的最大值的下标+1

 let arr2 = [12, 12, 10]
        arr2[7] = 50
        console.log(arr2.length, 22);//8

3.数组的长度（数组名.length) 是可以改(大小）

1.改变数组的长度

	 let arr7 = [10, 20]
        arr7[5] = 10
        console.log(arr7);

2.改变数组的长度变小

 let arr3 = [1, 2, 3, 4, 5, 6, 7]
 
        arr3.length = 3
		//会丢失元素，丢失了就找不回来了 可以把arr3.length = 3 删除就可以找回来了
        arr3.length = 6 //如果在这里修改就找不回来改变的数组了
        console.log(arr3);

4.往数组中添加新元素

let arr = [20,30]
arr[arr.length] = 2  // 在后面添加
arr[arr.lengtth] = 50  // 在后面添加
console.log(arr);

5.练习

let arr = []
for(let = i; i <= 10 ; i++) {
arr[arr.length] = i *10
}
  console.log(arr); //输出 10 20 30 40 50 60 70 80 90 100

4.遍历数组

1练习

let arr = [10,20,30,40,50,60]
for(let i = 0; i < arr.length; i++ ) {
console.log(arr[i])
}

5.翻转数组

let arr = [60, 50, 40, 30, 20, 10]
let arr1 = []
for(let i = arr.length - 1; i >= 0; i--) {
    arr1.push(arr[i])
}
  console.log(arr1);

2.翻转数组

    let arr = [60, 50, 40, 30, 20, 10]
      
        for (let i = 0; i < arr.length / 2; i++) {
            let arr1 = arr[i]
            arr[i] = arr[arr.length - 1 - i]
            arr[arr.length - 1 - i] = arr1
        }
        console.log(arr);

6.斐波拉契数列

<script>
        let arr = [1, 1]
        let sum = +prompt('你想要知道这几个数列的第几个数吗')

        for (let i = 2; i <= sum; i++) {
            arr[i] = arr[i - 1] + arr[i - 2]
        }
        console.log(arr, 18);
    </script>

7.for循环跟标签数组的元素生成

let arr =['我是li标签','我是li标签','我是li标签','我是li标签','我是li标签']

for (let i = 0; i < arr.length; i++) {
docuent.write(`<li>${arr[i]}</li>`)
}

8.数组去重

  for (let i = 1; i < arr.length; i++) {
        //     // 假设一个不在的数组里面的
             let flag = false
        //     // 验证
             for (let index = 0; index < array.length; index++) {
        //         // 判断他们在不在数组里面
                 if (arr[i] == array[index]) {
                     flag = true
                     break
                 }
             }
        //     // 判断false就要 true的就不要
             if (flag == false) {
                 array[array.length] = arr[i]
             }
         }

2.练习去重

let arr = [10,20,10,50,20,10]
for(let i = 1; i < arr.length; i++) {
let lang = array.includes(arr[i])
if(lang == false){
array.push(arr[i])
}
}
console.log(array) //输出 10 20 50

9.引用类型

1.简单数据类型： number unll undefined Boolean string

1简单数据类型是存在技术栈中

let num = 10
let num2 = num
num = 20 
console.log(num,num2)//20 10

2.复杂数据类型：object function array

1.数组在内存栈中是存在地址的

let arr = [10,20,30,40,50]
let arr2 = arr
arr2[0] = 100
console.log(arr[0]) //100

2.它两是存在同一个地址然后arr2数据改变了内存堆也跟着改变

10.检测数据类型

1.错误检测数据类型

let arr = [10,20,30]

typeof 不能检测数组的类型
console.log(typeof arr) // object

2.array.isArray(数组名)

1.如果真是一个数组就返回true 不是数组就返回 false

let arr = [10,20,30]

console.log(Array.isArray(arr)); //true
console.log(Array.isArray(100)); //false

3.instanceof检测数据类型

console.log(100 instanceof Array);//false
console.log(arr instanceof Array);true

4.万能检测数据类型

console.log(Object.prototype.toString.call(arr)); //Array
console.log(Object.prototype.toString.call(123));//Nemder
console.log(Object.prototype.toString.call('你好'))；//String
console.log(Object.prototype.toString.call(true));Boolean
console.log(Object.prototype.toString.call(undefined))//undefined

11.二维数组

1.数组中的元素又是一个数组，这样子的数组又称为二维数组

let arr = [10,20,30,[30,50,30,40],20,30]
let arr2 = [
    [10,20,30],
    [40,50,60],
    [70,80,90]
]
2.取值
console.log(arr[3][3]) //40
console.log(arr2[1][2])//60
console.log(arr2[0][2])//30

3.遍历二维数组

 <script>
        let arr = [10, 20, 30, [30, 50, 30, 40], 20, 30]
        for (let i = 0; i < arr.length; i++) {
            //对arr[i]判断 如果数组就继续遍历 不是就直接打印
            if (Array.isArray(arr)) {
                //遍历 arr 数组中的里面的数组
                for (let index = 0; index < arr[i].length; index++) {
                    console.log(arr[i][index]);
                }
            } else {
                console.log(arr[i])
            }
        }
    </script>

12.冒泡排序

1。从最小大最大

    <script>
        let arr = [2, 1, 3, 9, 5, 4, 3]

        for (let i = 0; i < arr.length - 1; i++) {
            for (let index = 0; index < arr.length - 1 - i; index++) {

                // 判断语句改为大于就是 重最大到最小
                if (arr[index] > arr[index + 1]) {
                    let tiem = arr[index]
                    arr[index] = arr[index + 1]
                    arr[index + 1] = tiem
                }
            }
        }
        console.log(arr)

    </script>

复习 数组和数组去重还有检测数据类型

数组