J教程二部分

内容十八，for循环

都是循环执行代码的
和while和do while循环不太一样的一种循环结构
语法：

for（@1初始化表达式；@2条件表达式；@4更新表达式）
{
@3语句。。。
}

1，执行初始化表达式，初始化变量

2，执行条件表达式，判断是否执行循环

3，如果为true，则执行循环@3，如果为false，则终止循环

4，执行更新表达式，更新表达式执行完毕继续重复@2

实际该种循环比较好用

内容十九，循环控制语句

1，break终止循环

在循环没有进行完毕的时候，因为设置的条件满足，提前终止循环
要终止循环 ，就可以直接使用break关键字
例如

        for (var i = 1 ; i <=5 ;i++)
        {
            if (i==3)
            {break}
            document.write(i)
        }            

输出结果为1和2

2，continue结束本次循环

在循环中，把本次循环跳过去，继续执行后面的循环
跳过本次循环，就可以使用continue关键字
与break 相似

内容二十，求质数

        var n = 19
        var isZhiShu = true
        for(var i = 2;i<=n/2;i++)
        {
            if(n%i==0)
            {
                isZhiShu = false
                break
            }
        // console.log(i)
        }

        if (isZhiShu)
        {
            console.log("是质数")
        }
        else
        {
            console.log("不是")
        }

内容二十一，九九乘法表

        for (var m = 1 ;m <=9 ; m++)
            {
                for (var n = 1 ; n <=m; n++)
                {document.write(m+"*"+n+"="+m*n)
            }
            document.write("<br>")
            
        }

内容二十二，函数

1，定义函数

（1）声明式

例如

        function test1(){
            console.log("这是test1套餐")
        }

声明式可以先声明再使用，也可以先使用再声明

（2）赋值式

赋值式需要先给其赋值再使用

        var test3 = function(){
            console,console.log("这是test3");
        }

        test3()

2，调用函数

调用方法：直接在需要调用的地方输入函数名

内容二十二，函数的参数

我们在定义函数和调用函数的时候都出现过()
()就是用来放置参数的位置
参数分为两种：形参和实参
示例：

        function test(a,b){
            var yinliao = a===1?"可乐":"雪碧"
            var xiaoshi = b===1?"炸鸡":"薯条"
            console.log(yinliao,xiaoshi)
        }
        
        test(1,2)     

此代码中，形参就是a，实参就是给a赋的值1
形参只能在函数内部使用，不会再在外部使用
参数

内容二十三，函数的返回值

        function add(x,y,z){
            var rseult = x + y + z
            return rseult
        }
        var res = add(1,2,3)
        console.log(res)
        function test(a){
            console.log("传给后端",a)
        }
        test(res)

return可以保留函数执行的结果并将它导入给外部的变量

注意：

1，return看需求
2，return后面的代码就无法执行了

内容二十四，预解析

预解析其实就是关于JS代码的编译和执行
JS是一个解释型语言，就是在代码执行之前，先对代码进行通读和解释，然后再执行代码，也就是说，我们的JS代码在运行的时候，会经历两个环节：解释代码和换行代码

1，解释代码

因为是在所有代码执行之前进行解释，所以叫做预解析
需要解释的内容有两个

声明式函数：

在内存中先声明有一个变量名是函数名，并且这个名字代表的内容是一个函数

var关键字

在内存中先声明有一个变量名
赋值式函数会按照var关键字的规则进行预解析

内容二十五，作用域

作用域是一个可以使变量快速生效的范围
变量不是在所有的地方都可以使用，而这个变量的使用范围就是作用域

1，全局作用域

全局作用域是最大的作用域
在全局作用域中定义的变量可以在任何地方使用
页面打开的时候，浏览器会自动给我们生成一个全局作用域windows
这个作用域一直存在，直到页面关闭就销毁了

2，局部作用域

局部作用域就是在全局作用域下面有开辟出来的一个相对小一些的作用域
在局部作用域中定义的变量只能在这个局部作用域内部使用
在JS中只有函数能生成一个局部作用域，别的都不行每一个函数都是一个局部作用域

内容二十六，变量使用规则

访问规则

当想获取一个变量的值时，这个行为称为访问
获取变量的规则：

首先，在自己的作用域内部查找，如果有，就直接拿来使用
如果没有，就去上一级作用域查找，如果有，就直接拿来使用
如果上一级作用域依然没有，那就继续往上寻找，依次推类
如果一直到全局作用域都没有，那么就会直接报错

内容二十七，对象

对象是一个复杂数据类型
其中存储了一些基本数据类型
例如：

        var obj ={
            num:100,
            str: 'hello world',
            boo:true
        }

这里的{}和函数中的{}不一样
函数里面的{}是写代码的，而对象里面是写一些整数的

对象就是一个键值对的集合

{}里面的每一个键都是一个成员
也就是说，我们可以把一些数据放在一个对象里面，那么他们就互不干扰了

对象的基本操作

（1）创建对象

例如：

var obj = new Object();

创建了一个名为obj的对象

（2）向对象增加属性

语法：对象，属性名=属性值
例如：

obj.name="孙悟空"
obj.gender="男"
obj.age=18

（3）读取对象的属性

语法：对象，属性名

var obj = new Object(obj);
obj.name="孙悟空"
obj.gender="男"
obj.age=18
console.log(obj.name)
console.log(obj.gender)
console.log(obj.age)
console.log(obj.height)

（4）修改对象的属性值

语法：对象，属性名=新值

var obj = new Object(obj);
obj.name="孙悟空"
console.log(obj.name)
obj.name="tom"
console.log(obj.name)

（5）删除对象的属性值

语法：delete 对象.属性名
例如：

var obj = new Object(obj);
obj.name="孙悟空"
console.log(obj.name)
obj.name="tom"
console.log(obj.name)
delete obj.name;
console.log(obj.name)

内容二十八，数据类型的存储

基本数据类型和复杂数据类型有一些基本区别
其中最大的区别就是存储的区别

栈内存和堆内存

栈内存：主要存储基本数据类型
堆内存：主要存储复杂数据类型

基本数据类型的存储

直接在栈空间内存储一个数据

var num = 100

复杂数据类型的存储

下面是一个对象的存储

        var obj ={
            num:100,
            str: 'hello world',
            boo:true
        }

复杂数据类型的存储

1，在堆里面开辟一个存储空间
2，把数据存储到存储空间内
3，把存储空间的地址赋值给栈里面的内存

内容二十九，数组

数组是数据的集合
也就是我们把数据放在一个盒子里面，按顺序排好
这个东西就是一个数组，存储着一些数据的集合
数据

复杂数据类型：

包括：函数（function），对象（object），数组（array）等
数组也是数据类型的一种

创建一个数组

数组就是一个[]
在[]里面存储着各种各样的数据，按照顺序依次排好

字面量方式创建一个数组

      var arr = []      //空数组
      var arry = [1,2,3]//创建一个有内容的数组

内置构造函数创建数组

使用JS的内置构造函数Array创建一个数组

            var arr1 = new Array()//创建一个空数组
            var arr2 = new Array(10)//创建一个长度为10的数组
            var arr3 = new Array(1,2,3)//创建一个有内容的数组

数组的长度

长度用length表示
例如：

            var arr3 = new Array(1,2,3)
            arr3.length = 2
            console.log(arr3)

这样可以快速清空数组

数组的索引

例如

            var arr2 = [1,2,3]
            console.log(arr2[0],arr2[1])

数组的索引要从零开始

数组的遍历（打印出数组所有的数据）

            var arr3 = [3,4,5,6,7]
            for(var i = 0 ;i<arr3.length;i++){
                console.log(arr3[1])
            }

数组的排序

冒泡排序

先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，就把两个换位置
遍历一遍之后，最后一个数字就是最大的那个
然后进行第二遍遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置

var arr = [12,32,42,1,15,97];
for (var i = 0; i < arr.length - 1; i++) {
    for (var j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
console.log(arr);

选择排序

找到数组中最大（最小）的元素；
将该元素与数组中第一个元素交换位置（如果第一个元素就是最大或者最小的元素那么就和自己交换位置）
在剩下的元素中找到最大（小）的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。

var arr = [4, 7, 2, 8, 0, 3]; 
for (let i = 0; i < arr.length - 1; i++) {
    let min = i; 
    for (let j = min + 1; j < arr.length; j++) {
        if (arr[min] > arr[j]) {
            min = j; 
        }
    }
    let temp = arr[min];
    arr[min] = arr[i];
    arr[i] = temp;
}

console.log(arr);