JavaScrip学习2

循环控制语句

1.BREAK终止循环

●在循环没有进行完毕的时候，因为我设置的条件满足，提前终止循环

●比如:我要吃五个包子，吃到三个的时候，不能在吃了，我就停止吃包子这个事情●要终止循环，就可以直接使用break关键字

for(vari=1;i<=5;i++){

// 没循环次，吃一个包子

console. 1og('我吃了一个包子 ')

//当i的值为3的时候，条件为true, 执行{}里面的代码终止循环//循环就不会继续向下执行了，也就没有4和5了

if(i===3) {

    break
  }
}

2. CONTINUE结束本次循环

• 在循环中，把循环的本次跳过去，继续执行后续的循环

• 比如:吃五个包子，到第三个的时候，第三个掉地下了，不吃了，跳过第三个，继续吃第四个和第五个

• 跳过本次循环，就可以使用continue关键字

案例
打印1-100内所有的质数(除了1和本身没有其他的数可以整除)

//从2数到100
for(var i=2;i<=100;i++){
    var count = 0//记录能整除的数的个数
    //从2开始到本身-1结束 如果在这个范围内有可以整除的就证明他不是质数 没有的话就是质数
    //记录能整除的数
    for(var j=2;j<i-1;j++){
        if(i%j==0){
            count++
        }
    }
    //当前的个数如果为0 就打印
    if(!count){
        console.log(i)
    }
}

案例：
质数

//从2数到100
for(var i=2;i<=100;i++){
    var count = 0//记录能整除的数的个数
    //从2开始到本身-1结束 如果在这个范围内有可以整除的就证明他不是质数 没有的话就是质数
    //记录能整除的数
    for(var j=2;j<i-1;j++){
        if(i%j==0){
            count++
        }
    }
    //当前的个数如果为0 就打印
    if(!count){
        console.log(i)
    }
}

函数

函数是一个对象
函数创建：var fun = new Function(“代码”);
函数的申明：function 函数名 ([形参1，形参2....形参n]){代码}
[]内是可去调用函数函数名();

九九成法表

var i; //定义行数
var j; //定义列数
document.write("<table align='center' cellspacing='0'>"); //使用table标签包裹住循环体

for (i = 1;i <= 9;i++){ //循环9行

    document.write("<tr>") //使用tr包裹住一行
    for(j = 1;j <= i;j++){ //循环9列 j <= i时循环
        
        document.write("<td>");
        
        //输出“列*行=结果”
        document.write(j + "*" + i + "=" + i*j + "&nbsp;&nbsp;&nbsp;");

        document.write("</td>");
    }
    document.write("</tr>");
}

document.write("</table>");

retun

返回值可以是任意的数据类型

• 函数调用本身也是一一个表达式，表达式就应该有一个值出现
• 现在的函数执行完毕之后，是不会有结果出现的

//比如1+ 2是一个表达式，那么这个表达式的结果就是3
console.log(1 + 2) // 3

function fn(){
     //执行代码
}
// fn()也是一个表达式，这个表达式就没有结果出现
console. log(fn()) // undefined

• return关键字是可以给函数执行完毕一个结果

function fn() {
//执行代码
return 100

//此时，fnO这个表达式执行完毕之后就有结果出现了
console. log(fn()) //100
}

预解析

• 预解析其实就是聊聊js代码的编译和执行

• js是一个解释型语言，就是在代码执行之前，先对代码进行通读和解释，然后在执行代码

• 也就是说，我们的js代码在运行的时候，会经历两个环节解释代码和执行代码

解释代码

• 因为是在所有代码执行之 前进行解释，所以叫做预解析(预解释)

• 需要解释的内容有两个

声明式函数

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

■在内存中先声明有一个变量名

●看下面一段代码

fn(

console.1og(num)

function fn(){
console.log("我是fn函数")}

作用域

• 什么是作用域，就是一个变量可以生效的范围

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

全局作用域

●全局作用域是最大的作用域

• 在全局作用域中定义的变量可以在任何地方使用

●页面打开的时候，浏览器会自动给我们生成-个全局作用域wi ndow
●这个作用域会一直存在， 直到页面关闭就销毁了

//下面两个变量都是存在在全局作用域下面的，都是可以在任意地方使用的var num = 100

var num2 = 200

局部作用域

●局部作用域就是在全局作用域下面有开辟出来的一一个相对小一些的作用域
访问规则

●当我想获取一个变量的值的时候，我们管这个行为叫做访问

获取变量的规则:

• 首先，在自己的作用域内部查找，如果有，就直接拿来使用

• 如果没有，就去上-级作用域查找，如果有，就拿来使用

• 如果没有，就继续去上一-级作用域查找，依次类推

• 如果-直到全局作用域都没有这个变量，那么就会直接报错(该变量is not defined)

var num = 100

function fn( {var num2 = 200

function fun() {var num3 = 300

console. l1og(num3) //自己作用域内有，拿过来用

console. log(num2) //自己作用域内没有，就去上一级，就是fn的作用域里而找，发现有，拿过来用
console.1og(num) //自己这没有，去上一级fn那里也没有，再上-级到全局作用域，发现有，直接用
console. 1og(a) //自己没有，一 级一级找上去到全局都没有，就会报错

对象数据类型

●对象是一个复杂数据类型

●其实说是复杂，但是没有很复杂，只不过是存储了一-些基本数据类型的一个集合

varobj= {

num: 100,

str: 'hello world',boo: true

●这里的{}和函数中的{}不-样

●函数里面的是写代码的，而对象里面是写一些数据的

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

●{}里面的每一个键都是一个成员

●也就是说，我们可以把一-些数据放在一 一个对象里面，那么他们就互不干扰了

●其实就是我们准备一一个房子，把我们想要的数据放进去，然后把房子的地址给到变量名，当我们需要某一一个数据的时候，就可以根据变量名里面存储的地址找到对应的房子，然后去房子里面找到对应的数据

对象的基本操作

●字面量的方式创建一个对象

//创建一- 个空对象
var obj = {}

//像对象中添加成员
obj. name = 'Jack'
obj.age = 18

●内置构造函数的方式创建对象

//创建-一个空对象

var obj = new object()

//向对象中添加成员
obj. name = ' Rose '
obj.age = 20

• object是js内置给我们的构造函数，用于创建一个对象使用的

    var obj={
        name:lucy,
        age:18,
    }
    document.write(obj)
    var obj2=new object()
    obj2.name=lucy
    obj2.age=18

不同数据类型的储存

●既然我们区分了基本数据类型和复杂数据类型●那么他们之间就一定会存在一些区别

●他们最大的区别就是在存储上的区别

●我们的存储空间分成两种栈和堆

●栈:主要存储基本数据类型的内容

●堆:主要存储复杂数据类型的内容

数组数据类型

●数组就是数字的组合

●其实不太准确，准确的来说数组是一一个 数据的集合

●也就是我们把- -些数据放在一个盒子里面，按照顺序排好

[1，2，3，'he11o'， true， false]

●这个东西就是一个数组，存储着一 些数据的集合

数据类型分类

●number / string / boolean /undefined/null/ object / function / array / …
●数组也是数据类型中的- -种

●我们简单的把所有数据类型分为两个大类基本数据类型和复杂数据类型

●基本数据类型: number 1/string / boolean / undefined / null

●复杂数据类型:object/ function / array /…

数组基本操作

长度length
可读，可写

document.write(arr1.length)

arr.length=3改变数组长度为3
也可直接改为0，清空数组

索引

let arr=["a","b","c"]
document.write(arr[0])

输出结果为a

document.write(arr[4])
输出结果为undefined

let arr=[1,2,3]
arr[4]=7
document.write(arr[4])
输出结果为7

遍历

let arr=[1,2,3]
for(let i=0;i<arr.length;i++){
    document.write(arr[i])
}

输出结果为1 2 3

复制

let arr1=[1,2,3,4]
let arr2=[]
for(let i=0;i<arr1.length;i++){
    arr2[i]=arr1[i]
    document.write(arr2[i])
}
 arr2[1]=8
document.write(arr2)

冒泡排序

原理：相邻的数据进行两两比较，小数放在前面，大数放在后面，这样一趟下来，最小的数就被排在了第一位，第二趟也是如此，如此类推，直到所有的数据排序完成。

描述：

<1>比较相邻的元素。如果第一个比第二个大，就交换它们两个；
<2>对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
<3>针对所有的元素重复以上的步骤，除了最后一个；
<4>重复步骤1~3，直到排序完成。

var arr = [4,23,100,9,7,49,36,57];
		console.log("原始数据："+arr);

		for(var i=0;i<arr.length-1;i++){//确定轮数
			for(var j=0;j<arr.length-i-1;j++){//确定每次比较的次数
				if(arr[j]>arr[j+1]){
					tem = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = tem;
				}
			}
			console.log("第"+i+"次排序"+arr)
		}
		console.log("最终排序："+arr)

选择排序

选择排序思想如下：

找到数组中最大（最小）的元素；
将该元素与数组中第一个元素交换位置（如果第一个元素就是最大或者最小的元素那么就和自己交换位置）
在剩下的元素中找到最大（小）的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。
从上面的过程可以看出，选择排序在不断地选择剩余元素中的最大（小）者。

例如，当前有数组 [4, 7, 2, 8, 0, 3] 从小到大排序，它的选择排序过程如下：

步骤	数组	说明
1	[0, 7, 2, 8, 4, 3]	数组中0最小，与数组中第一个位置的4交换位置
2	[0, 2, 7, 8, 4, 3]	剩下（0之后）的数组中，2最小，与第二个位置的7交换位置
3	[0, 2, 3, 8, 4, 7]	剩下（2之后）的数组中，3最小，与第三个位置的7交换位置
4	[0, 2, 3, 4, 8, 7]	剩下（3之后）的数组中，4最小，与第四个位置的8交换位置
5	[0, 2, 3, 4, 7, 8]	剩下（4之后）的数组中，7最小，与第五个位置的8交换位置

let arr = [4, 7, 2, 8, 0, 3]; // 要排序的数组

// 外层循环，从该位置取数据，剩下最后一个数字无需选择排序，因此-1
for (let i = 0; i < arr.length - 1; i++) {
    let min = i; // 初始时假设当前最小数据的下标为i，并记录在min中
    // 内层循环，找出最小的数字下标
    for (let j = min + 1; j < arr.length; j++) {
        // 如果记录的最小数字大于当前循环到的数组数字
        if (arr[min] > arr[j]) {
            min = j; // 将min修改为当前的下标
        }
    }
    // 内层循环结束，此时min记录了剩余数组的最小数字的下标
    // 将min下标的数字与i位置的数字交换位置
    let temp = arr[min];
    arr[min] = arr[i];
    arr[i] = temp;
}

console.log(arr); // [ 0, 2, 3, 4, 7, 8 ]