JS的基础知识上

命名规范
	由字母(大小写)、数字（0-9）、特殊符号（_$）组成，例如：age、userName、user_name
	同样的变量名，大小写不一样，代表不同的变量 ,例如:userName、username是两个变量
	不能使用关键字，eg:var name value 可以写val
	变量名不能以数字开头 eg:1age 、1_age
	遵循驼峰命名，首字母小写，后面的单词首字母全部要大写：age email myFristName

3.字面量

// 18 + '20' 1820
	// 18 + 20 38
	// 字面量：定义时就已经知道是什么数据
	var age = 18;//18是数字类型控制台打印是蓝色 Number
	var Age = '20';//字符串类型控制台打印是黑色 String
	var arr = []; //[]是数组 Array
	var obj = {}; //{ } 是对象类型 Object
	console.log(age)
	console.log(Age)

4.数据类型

// 数据类型：
	// 数据类型分为：简单数据类型复杂数据类型（引用数据类型）

	// 1、简单数据类型
	// 1、Number 数字型
	// js中number可以是整数也可以是小数
	var num = 2;
	var num = 3;
	var num = 3.1415926;
	// 2、数字型的进制八进制 0-7
	//
	// var num1 = 07;//十进制的7
	// var num2 = 08; //十进制的7
	// var num3 = 019; //十进制的19

	// 最大值
	console.log(Number.MAX_VALUE)
	//最小值
	console.log(-Number.MIN_VALUE)

	// 无穷大
	console.log(Number.MAX_VALUE * 2)
	// 无穷小
	console.log(-Number.MIN_VALUE * 2)
	// 无穷大无穷小
	// Infinity 代表无穷大,大于任何数字
	// -Infinity 代表无穷小，小于任何数字

	// NaN not a number的缩写
	// 判断是否为非数字类型 isNaN是方法需要带括号，把需要判断的变量放在括号里
	// isNaN返回值为false 和true false代表是数字型 true代表不是数字型
	var age = 18;
	var uname = '李四';
	// console.log(isNaN(age)); //false age不是一个非数字类型
	// console.log(isNaN(uname)); //true uname是一个非数字类型

5.字符串

字符串：String 字符串需要用引号，引号里面可以是任意文本，js中一般使用单引号'',也可以使用双引号"",
		// 但是html里面使用的都是双引号，为了做区分，所以js一般使用单引号
		// 只要是引号里面的东西都可以编译出来

6.布尔值

// 布尔值 boolean 有两个值 true和false,true是真，false是假
	// true其实就是1 false就是0
	var bool = true;
	var bools = false;
	console.log(bool + 1)
	console.log(bools + 1)
	console.log(10 > 9)//true
	console.log(9 > 10)//false

7.运算符

// 运算符：也叫操作符，主要是实现赋值、算数运算等功能；
	// typeof 也是运算符
	// + - * / %

	// + 加法运算符
	// 只要是跟字符串相加的都会转成字符串,(相互拼接)
	// 数字跟NaN相加的是NaN，字符串跟NaN相加就是拼接

	// console.log(1 + 1) //2
	// console.log(1 + '1') //11
	// console.log('1' + true) //1true
	// console.log(1 + true) //1true
	// console.log(1 + 'true') //1true
	// console.log(1 + NaN) //NaN
	// console.log('1' + NaN) //NaN


	// -减法运算符
	// 减法运算符会把字符串中的数字转化为数值型
	// 非数值型的字符串就会是NaN
	// console.log(1 - 1) //0
	// console.log(1 - '1') //00
	// console.log(1 - true) //2
	// console.log(1 - 'true') //NaN
	// console.log("1" - true) //0
	// console.log(1 - NaN) //NaN
	// console.log('1' - NaN) //NaN



	// * 乘法运算符也会把字符串的数字转化为数值型

	// 数值乘非数字型的字符串返回的是NaN
	// console.log(1 * 1) // 1
	// console.log(1 * '1') //00
	// console.log(1 * true) //1
	// console.log(1 * 'true') //NaN
	// console.log("1" * true) //1
	// console.log(1 * NaN) //NaN
	// console.log('1' * NaN) //NaN

	// / 除法运算符也会把字符串的数字转化为数值型
	// 数值除非数字型的字符串返回的是NaN
	// console.log(1 / 1) // 1
	// console.log(1 / '1') //00
	// console.log(1 / true) //1
	// console.log(1 / 'true') //NaN
	// console.log("1" / true) //1
	// console.log(1 / NaN) //NaN
	// console.log('1' / NaN) //NaN

	// % 取余运算符

	// console.log(4 % 2)
	// console.log(3 % 2)
	// console.log(9 % 2)
	// console.log(19 % 3)


	var str = "白日依山尽，黄河入海流，欲穷千里目，更上一层楼"
	// console.log(str)
	var str1 = "白日依山尽，" +
	"黄河入海流，" +
	"欲穷千里目，" +
	"更上一层楼"
	// console.log(str1)


	// 浮点数小数
	// 浮点数精确度浮点值最高精确度17位小数，在算数运算中浮点数之间的运算精确度没有正数高

	console.log(1 + 1)
	console.log(1 + 2)
	console.log(0.1 + 0.2)
	console.log(0.1 * 0.2)

8.简单的表达与返回的描述

// 表达式:由数字、运算符、变量等组成的式子
	// 1 + 1 = 2
	var num;
	num = 1 + 1 //表达式
	// num是返回值
	console.log(num)

9.增减运算符

// 递增运算符：反复给数字变量增加相同的值，例如增加1

	var num = 3
	// console.log(num + 1)
	// 前置递增简写 ++变量名先自加1在进行其他运算
	// console.log(++num) //4
	// console.log(++num + 2) //7
	// 5

	// 后置递增变量名++ 先运算再自加

	console.log(num++)
	// num=num+1
	console.log(num)

/*
	递减运算符:分为前置递减(--num) 后置递减(num--)
	前置和后置都是立马给变量减1
	前置递减(--num)是递减后的新值
	后置递减(num--)是原来的值


	*/
	var num = 10;
	// console.log(--num)
	// console.log(num--)
	// var num1 = num--;

	// console.log(num1)
	console.log(num-- + --num) //18

10.比较运算符

console.log(1 > 2)//false
	console.log(2 < 3)//true
	console.log(2 >= 3) //false
	console.log(1 == 2) //false
	// ==是指只要值相等就会返回true,字符串转化成数值型的值进行对比
	console.log(18 == '18')//true
	console.log(12 == 'nihao')//false
	console.log('hello' == 'nihao')//false
	// ===是值相等的同时数据类型也必须相等（全等于）
	console.log(18 === '18') //false
	console.log('nihao' === 'hello') //false
	console.log('181' === '18') //false

比较运算符之间会出现布尔值

11.逻辑运算符

// 逻辑运算符：就是用来进行布尔值运算的运算符，返回值也是布尔值，开发中常用
	// 逻辑与 && 其实就是and
	// 特点:两边必须都是true才会返回true,否则返回false
	console.log(2 > 3 && 3 < 4) //false
	// false true
	console.log(5 < 6 && 7 < 8) //true
	// true true
	console.log(5 > 6 && 7 > 8) //false



	// 逻辑或 \|\| or
	// 特点: 两边只要有一个true就会返回true,两边都是false时才会返回false
	console.log(2 > 3 \|\| 3 < 4) //true
	// false true
	console.log(5 < 6 \|\| 7 < 8) //true
	// true true
	console.log(5 > 6 \|\| 7 > 8) //false


	// 逻辑非 ! not
	// 特点:也叫取反,用来曲一个布尔值的相反值,例如 true的相反值时false
	var flag = true
	// console.log(!true)
	var flags = !flag
	console.log(flags)
	console.log(!flags)

12.相等运算符

// == 只要值相等就返回true 否则返回false ,底层:就是把两个数据类型自动转换成同一种数据类型,然后进行比较
	// 其实undefined是null衍生而来的

	// console.log(undefined == null)
	//=== 必须值和数据类型一致的情况下才会返回true,不会进行数据类型的转换

	// != 不等于两个值会自动转换成同一种值进行对比
	// console.log(5 != 4)//true
	// console.log('5' != 4) //true
	// console.log('4' != 4) //false
	// console.log('abg' != 'rfc') //true
	// !== 完全不相等不会进行数据类型的转换
	console.log(5 !== 4)//true
	console.log('5' !== 4) //true
	console.log('4' !== 4) //true
	// console.log('abg' != 'rfc') //true

13.一元运算符

// 一元运算符:就是一个值的运算
	// 特点: - + 会自动把值转换成数值型的

	var num = '2';
	var num1 = 'fdd'
	// console.log(+2)
	// console.log(num1)
	// console.log(-num)
	console.log(+true)

14.短路运算

// 短路运算 :当有多个表达式时,左边的表达式的值可以确定结果时,就不再继续运算右边的表达式的值;
	// 逻辑与 &&
	// 语法:表达式1&&表达式2

	// 特点:如果第一个表达式的值为真时,就返回第二个表达式
	// 如果第一个表达式为假时,就会返回第一个表达式
	// 数字里0代表假除0以外都是真
	// console.log(1 && 2) // 2
	// console.log(0 && 2) // 0
	// console.log(12 && 23 && 45 && 67) // 67

	// 逻辑或 \|\|

	// 语法:表达式1 \|\| 表达式2
	// 特点:如果第一个表达式为真时,就返回第一个表达式
	// 如果第一个表达式为假时就会返回第二个表达式
	console.log(123 \|\| 456) //123
	console.log(0 \|\| 234) //234
	console.log(123 \|\| 0 \|\| 234 \|\| 456) //123

15.赋值运算

// 赋值运算符
	// 加法运算符
	var age = 18
	// age = age + 1
	// console.log(age)
	// console.log(age += 1)
	// 减法运算符
	// age = age - 1
	// console.log(age -= 1)
	// 除法运算符
	// age = age / 2
	// console.log(age /= 2)
	// 除乘法运算符
	// age = age * 2
	// console.log(age *= 2)

	// 取余运算符
	// age = age % 2
	console.log(age %= 2)

16.运算符的优先级

// js中和数学中一样,运算符也具有优先级
	// 逻辑与比逻辑或优先级高,从左到右运算.想要改变计算结果需要加括号
	// 数学中加减乘除
	console.log(11 && 22 \|\| 33) //22 11&&22-->22 22\|\|33 --> 22
	console.log(11 \|\| 22 && 33) //11 11\|\|22-->11 11&&33-->33 22&&33-->33 11\|\|33-->11
	console.log(0 && 22 \|\| 33) //33 0&&22-->0 0\|\|33-->33 22\|\|33-->22 0&&22-->0
	console.log(4 < 6 \|\| '1' != 1 && true) //true


	var num = 10
	console.log(5 == num / 2 && (2 + 2 * num).toString() === '22') //true

	var a = 3 > 5 && a < 7 && 3 == 4
	console.log(a) //false
	var b = 3 <= 4 \|\| 3 > 1 \|\| 3 != 2
	console.log(b) //true
	var c = 2 === '2'
	console.log(c) //false
	var d = !c \|\| b && a
	// true (true false)
	console.log(d) // true

17.三元表达式

// 三元表达式 : 三个表达式语法:表达式1 ? 表达式2 : 表达式3
	// 如果表达式1为真的话,会返回表达式2 ,如果表达式1为假的话,会返回表达式3
	console.log(3 > 4 ? 1 : 2) //2
	var num = ''//空字符串就是假
	console.log(num ? num : '2') //2
	console.log(3 > 4 ? 4 > 5 ? 3 : 2 : 2) //2
	var str = '1' //'2'

	console.log(str == 1 ? '已支付' : '未支付')
	var flag = true
	console.log(true ? '0' : '1')

	// 三元表达式的场景：
	/*
	1、列表里需要展示类似于已支付未支付等这些字眼时，后端返回的是0 1 2等数字时，
	需要用三元表达式判断然后转化成文字展示在页面上
	str == 1 ? '已支付' : '未支付'

	2、不是必须输入的input（也可以输入内容），传给后端值时，
	值为空，需要给一个默认值时，就需要用到三元表达式，
	如果用户填了内容那就传给后端用户填的，如果没填就给一个默认值
	num ? num : '2'

18.if分支语句

// {} 可以实现一段代码块
	// {
	// console.log(111)
	// console.log(4334)
	// }
	/*
	if语句做判断语法 if(表达式) 只有表达式里为真的时候才会进行下去
	if如果后面只有一段代码时,{}可以不用写,但不规范,如果没有{}那它只对紧挨着他的代码有效果


	*/
	// if (1) console.log(111)
	// console.log(222)


	// if (false) console.log(333)
	// console.log(444)


	//
	// if (true) {
	// console.log(333)
	// console.log(444)
	// }

	// if else
	/*
	if(表达式){

	}else{

	}

	*/
	// var num = 2
	// if (num > 0) {
	// console.log('我比0大')
	// } else {
	// console.log('你个垃圾,都没0大')
	// }


	// if else if else
	/* // 语法:if(表达式){

	} else if(表达式){
	}else{

	}



	*/
	var num1 = 50
	if (num1 > 80) {
	console.log('宝贝,你真棒!')
	} else if (num1 > 60 && num1 < 80) {
	console.log('你个垃圾,都没考及格')
	} else if (num1 < 20) {
	console.log('细狗,主动离职吧')
	} else {
	console.log('我不想说话了')
	}

19.switch分支语句

/*
	switch 分支语句场景:在固定的数值使用判断,匹配相同的选项 (case)进行执行
	语法:switch(表达式){ //表达式为真时执行
	case value1:
	//表达式匹配成功时执行的
	case value1:
	//表达式匹配成功时执行的
	case value1:
	//表达式匹配成功时执行的

	}
	// 如果没有break时,匹配成功的表达式会执行,并且也会执行下面全部的表达式
	break就是终止执行,跳出switch
	*/
	var num = 10
	switch (num) {
	case 1:
	console.log('我是1')
	break;
	case 2:
	console.log('我是2')
	break;
	case 3:
	console.log('我是3')
	break;
	case 4:
	console.log('我是4')
	break;
	default:
	console.log('没有可选的了')
	}

20.for循环

// for循环目的：就是重复运行相同的代码
	/*
	语法：
	for(初始化变量;条件表达式;操作的表达式 ){
	循环体
	}
	初始化变量：就是使用var关键字声明变量，并进行复制，作为整个循环的初始值
	条件表达式：确实每一次循环时候能够执行，如果是true，就继续循环，否则退出循环

	操作表达式：确实每一次循环是否能够执行，如果是true就继续循环，否则退出循环
	*/
	// var i=0在整个循环中只运行一次
	// 条件表达式循环体操作表达式三个之间的循环
	// 在循环体结果大于条件表达式时才会跳出循环

	for (var i = 0; i <= 5; i++) {
	console.log(i)
	}

21.for循环的练习

// 1、弹出100次亲爱的，我错了！
	// for (var i = 0; i < 100; i++) {
	// alert('亲爱的，我错了！')
	// }



	// 2、让用户输入想道歉的次数，再根据输入的次数弹出亲爱的，我错了！
	// var str = prompt("亲爱的，你想让我道歉几次呢") - 0;
	// for (var i = 1; i <= str; i++) {
	// alert('亲爱的，我错了！')
	// }



	// 3、求1-100之间所有能被3整除的数字的和
	// var num = 0
	// for (var i = 1; i <= 100; i++) {
	// if (i % 3 == 0) {
	// num = num + i
	// }
	// }
	// console.log(num)



	// 4、求0-100之间的总和
	// var num1 = 0
	// for (var i = 0; i <= 100; i++) {
	// num = num + i
	// }
	// console.log(num1)
	// 5、求1-100之间有多少偶数，多少奇数

	var even = 0;
	var odd = 0;
	for (var i = 1; i <= 100; i++) {
	if (i % 2 == 0) {
	even += 1
	} else {
	odd += 1
	}
	}
	console.log('1~100 之间所有的偶数和是' + even);
	console.log('1~100 之间所有的奇数和是' + odd);



	// 初始化变量
	// var num = 0;
	// for (var i = 0; i <= 100; i++) {

	// num = num + i
	// i=0 num=0
	// num=0 + 0

	// num += i
	// }

22.双重for循环

/*
	双重for循环：循环嵌套，一个for循环里面还可以再嵌套一个for循环，这样的语句就是双重for循环
	语法：for(外循环的初始化;外循环的条件;外循环的表达式){
	for(内循环的初始化;内循环的条件;内循环的表达式){
	循环体（需要执行的代码）
	}
	}
	注意点：1、两个循环体的初始化变量名不一样;
	2、外层for循环循环一次，里层for循环一遍，直到里层for循环不满足条件时才会跳出里层循环。再次进行外循环，
	*/
	for (var i = 0; i < 5; i++) {
	for (var j = 0; j < 5; j++) {
	console.log(i)
	console.log(j)
	}
	}
	for (var i = 0; i <= 5; i++) {
	for (var j = 0; j <= 5; j++) {
	document.write('*')
	}
	document.write('<br />')
	}

23.双重for循环案例

// 1 六行星号，每行有6个
	// for (var i = 1; i <= 6; i++) { //行
	// for (var j = 1; j <= 6; j++) {
	// document.write('*')
	// }
	// document.write('<br />')
	// }

	var str = ""
	for (var i = 1; i <= 6; i++) { //行
	for (var j = 1; j <= 6; j++) {
	str = str + '*'
	}
	str = str + '\n'
	}
	console.log(str)

24.倒三角案例

// 倒三角星
	// 思路：每一行都会少一个星
	for (var i = 1; i <= 10; i++) { //外层循环控制行数
	// 1 - 10行
	for (var j = i; j <= 10; j++) { //里层循环控制个数
	// 10 9 8 7 6 5 4 3 2 1
	document.write('*')
	}
	document.write('<br>')
	}

25.乘法表

// 九九乘法表
	// 一共有9行，但是每行的个数不一样，因此需要用到双重 for 循环
	// 外层的 for 循环控制行数 i ，循环9次，可以打印 9 行
	// 内层的 for 循环控制每行公式 j
	// 核心算法：每一行公式的个数正好和行数一致， j <= i;
	// 每行打印完毕，都需要重新换一行
	var str = '';
	for (var i = 1; i <= 9; i++) { // 外层循环控制行数
	for (var j = 1; j <= i; j++) { // 里层循环控制每一行的个数 j <= i
	// 1 × 2 = 2
	// str = str + '★';
	str += j + '×' + i + '=' + i * j + '\t';
	}
	str += '\n';
	}
	console.log(str);

26.while循环

// while 当.....的时候
	// 语法：while(条件表达式){
	// 循环体
	// }

	/*
	特点：1、先执行条件表达式，如果结果是true,则执行循环体内容；如果是false,则退出循环
	必须要有退出条件

	while循环三要素：
	变量的起始值
	终止条件（如果没有终止条件就会死循环）
	变量的变化量（变量自增）
	*/
	var num = 2
	while (num < 3) {
	document.write('宝贝，你真棒！')
	num++
	}

27.continue和break

// continue关键字用于立即跳出本次循环，继续下一次的循环
	// 吃5个苹果，第三个有虫子，扔掉第三个，继续吃第4、5个
	// for (var i = 1; i <= 5; i++) {
	// if (i == 3) {
	// console.log(i)
	// continue;
	// }
	// console.log('我吃了' + i)
	// }



	// break关键字是立即跳出整个循环

	// 吃5个苹果，第三个有虫子，后面都不吃了
	for (var i = 1; i <= 5; i++) {
	if (i == 3) {
	break;
	}
	console.log('我吃了' + i)
	}

28.do ...while 循环

// do....while
	/*
	do{
	// 循环体
	}while(条件表达式)


	// 特点：1、先执行一次循环体
	2、再执行条件表达式，如果是true，继续执行循环体，如果是false，退出循环

	*/

	do {
	document.write("我要输出")
	} while (false)

29.数组

<!--
	数组(Array)：可以把一组相关的数据存放在一起，并且提供了方便的查找阅读方式
	数组是一组数据的集合，其中每个数据叫做元素，在数组中可以存放任意类型的元素，
	注意点：每个数据必须用，隔开
	数组的字面量必须用[]
	字面量方式是以后常用
	里面有文字时需要加引号

	创建数组方法：
	1 利用new 创建数组
	语法： var 数组名 =new Array() //不常用

	var arr=new Array() //创建了一个空数组 Array A必须要大写
	2 利用字面量创建数组
	语法： var 数组名=[]

	var arr=[]

	-->

	<script>
	var arr = ['0', 1, true, '23']
	console.log(arr)
	</script>

30.获取数组的元素

// 数组每个元素都对应一个属于自己的下标，
	/*

	下标（索引）:可以访问数组中每个元素的序号（数组中的索引从0开始）
	索引的作用：数组可以通过索引来访问、设置，修改对应的数组元素，也可以通过数组名[索引] 获取数组中的元素


	*/
	var arr = [1, 2, '张三', '李四']
	// document.write(arr[0])
	// document.write(arr[3]) // 李四

	// 新增数组元素，先找到需要新增数组的元素位置，然后进行赋值
	// arr[4] = '王五'
	// console.log(arr) //[1, 2, '张三', '李四','王五']

	// 修改数组中的元素其实就是重新给数组中的某个元素重新赋值
	// 先找到需要修改元素,再赋值
	// arr[2] = '王二'
	// console.log(arr) //[1, 2, '王二', '李四']


	// 如果访问的数组没有和索引值对应的元素时，则得到的返回值时undefined
	document.write(arr[6])

31.获取数组的长度

/*


	获取数组长度：使用length属性
	语法：数组名.length
	注意：数组长度默认情况下是数组元素的个数
	数组长度和数组索引一定要区分开，一般情况下，索引会比长度小1
	索引也叫 index arr[index]
	*/
	var arr = [1, 2, '张三', '李四']
	arr.length = 6
	console.log(arr)
	document.write(arr)

32.数组的遍历

// 把所有元素从头到尾访问一遍并打印出来

	var arr = ['张三', '李四', '王二', '麻子', '郑日安', '王多磊', '王志刚']

	for (var i = 0; i < arr.length; i++) { //下标比length少1，所以i要小于arr.length
	console.log(arr[i])
	}

33.数组的案例

/*
	1、请打印出数组[2, 6, 1, 7, 4]的和以及平均值

	*/
	// (1)声明一个求和变量 num。
	// (2)遍历这个数组，把里面每个数组元素加到 num 里面。
	// (3)用求和变量 num。除以数组的长度就可以得到数组的平均值。
	var arr = [2, 6, 1, 7, 4]
	var num = 0
	var average = 0
	for (var i = 0; i < arr.length; i++) {
	num += arr[i]

	}
	average = num / arr.length
	console.log(num, average)
	/*
	2、请打印出数组[2, 6, 1, 77, 52, 25, 7, 99]的最大值
	*/
	// 声明一个保存最大元素的变量 max。
	// 默认最大值可以取数组中的第一个元素。
	// 遍历这个数组，把里面每个数组元素和 max 相比较。
	// 如果这个数组元素大于max 就把这个数组元素存到 max 里面，否则继续下一轮比较。
	// 最后输出这个 max
	var arr = [2, 6, 1, 77, 52, 25, 7, 99];
	var max = arr[0];
	for (var i = 1; i < arr.length; i++) {
	if (arr[i] > max) {
	max = arr[i];
	}
	}
	console.log('该数组里面的最大值是：' + max);

	/*
	3 将数组 ['red', 'green', 'blue', 'hotpink'] 转换为字符串，并且用 \| 或其他符号分割

	*/
	// 1.需要一个新变量用于存放转换完的字符串 str。
	// 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。
	// 3.同时在后面多加一个分隔符
	var arr = ['red', 'green', 'blue', 'pink'];
	var str = '';
	for (var i = 0; i < arr.length; i++) {
	str += arr[i] + '\|';
	}
	console.log(str);
	/*
	4 将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。

	*/
	// 1、声明一个新的数组用于存放新数据newArr。
	// 2、遍历原来的旧数组，找出大于等于 10 的元素。
	// 3、依次追加给新数组 newArr。
	var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
	var newArr = [];
	var j = 0;
	for (var i = 0; i < arr.length; i++) {
	if (arr[i] >= 10) {
	// 新数组索引号应该从0开始依次递增
	newArr[j] = arr[i];//arr[i] arr的元素
	j++;
	}
	}
	console.log(newArr);

34.数组去重（删除相同的数据）

// 将数组[2, 3, 6, 1, 77, 3, 52, 3, 25, 7]中的 3 去掉后，形成一个不包含 3 的新数组。
	// 1 需要一个新数组存放筛选出来的数据
	// 2 遍历原数组，把不是3的值添加到新数组
	// 3 新数组里面的个数通过length不断累加
	var arr = [2, 3, 6, 1, 77, 3, 52, 3, 25, 7]
	var newArr = [] //此时的length是0
	for (var i = 0; i < arr.length; i++) {
	if (arr[i] != 3) {
	newArr[newArr.length] = arr[i]
	}
	}
	console.log(newArr)

35.数组存放元素

//给一个空数组存放1-10 10个数
	// 1 声明一个空数组
	// 2 遍历1-10进行存放在空数组里

	var arr = []
	for (var i = 1; i <= 10; i++) {
	arr[i - 1] = i
	}
	console.log(arr)

36.翻转数组

// 将数组['red','green','pink','blue','hotpink']的内容反过来存放到新数组中
	/*
	1 声明一个新数组
	2 把旧数组索引4取过来然后赋值给i初始化的值,i>=0，进行i--


	*/
	var arr = ['red', 'green', 'pink', 'blue', 'hotpink']
	var newArr = []
	for (var i = arr.length - 1; i >= 0; i--) {
	newArr[newArr.length] = arr[i]
	}
	console.log(newArr)

37.冒泡排序

// 将 [2，4，3，5，1]按从小到大排序




	// 2 4 3 5 1
	// for循环
	// 2 --> 4 3 5 1------> 1
	// 4 ---> 2 3 5 -----> 2
	// .........



	var arr = [2, 4, 3, 5, 1]
	for (var i = 0; i <= arr.length - 1; i++) { //外层for循环，决定循环的次数
	for (var j = 0; j <= arr.length - 1 - i; j++) { //里面的for循环，交换次数
	if (arr[j] > arr[j + 1]) {
	//内部需要交换相邻的两个值（第二个比第一个小）
	var temp = arr[j]
	arr[j] = arr[j + 1]
	arr[j + 1] = temp
	}
	}
	}
	console.log(arr)

38.冒泡排序原理

// 将 [2，4，3，5，1]按从小到大排序


	// 冒泡排序原理：
	// 在循环的过程中，进行两个值的交换，如果两个值的位置是错就进行交换，如果两个值的位置是正确的，就按兵不动

	// 5，4，3，2，1 ==> 1 ,2 ,3 ,4, 5

	/* 一： 5 == 4 > 4
	5 == 3 > 3
	5 == 2 > 2
	5 == 1 > 1

	4 3 2 1 5
	二：
	4 == 3 > 3
	4 == 2 > 2
	4 == 1 > 1
	3 2 1 4 5
	三：
	3 == 2 > 2
	3 == 1 > 1
	2 1 3 4 5
	四：
	2 == 1 > 1
	1 2 3 4 5 */

39.函数

/*
	函数：
	在我们编写代码时，经常性写的一个功能可以在很多地方使用（重复使用），
	那为了解决这个重复使用的代码，出现了函数包裹整个代码，进行重复使用，
	函数就是封装了一段可以被重复使用的代码块。

	模块


	*/
	// 使用
	// 1 声明函数
	// （1）自定义函数方式因为它有自己的名字也叫命名函数
	// 利用函数关键字 function自定义函数方式
	// 语法： function fn(){

	// }
	// （2）函数表达式方式（匿名函数）
	//语法： var fn =function(){

	// }

	// 声明函数特点： function是关键词，必须小写

	//2 调用函数
	fn()
	// 调用：调用的时候必须加（），因为函数本身是不会执行代码的，只有调用函数时才会执行

40.函数的基本使用

// 函数名最好是语义化的，函数是一个动态的，
	// 所以最好使用动词,函数名如果是多个单词组成，最好是驼峰命名
	// 声明函数
	function getName() {
	console.log('我叫张三')
	}

	// 调用函数
	getName()

41.函数求和

// 在函数内可以写任意代码
	function getSum() {
	var a = 5
	var b = 10
	var c = a + b
	console.log(c)
	}

	getSum()

42.函数的参数

// 函数参数：
	// 形参：函数在定义时接收调用时的传入参数（虚拟参数）
	// 实参：函数调用时传入的真实参数

	// 参数之间需要用逗号隔开
	// 语法：
	// function fn(形参,形参,.....){}
	// fn(实参,实参,....)



	// 注意：形参顺序是与实参传入的顺序一一对应
	// 如果没有传入实参时，定义了形参，那形参就是undefined
	// 如果实参个数小于形参，那多出来的形参是undefined
	// 如果形参个数少于实参时，那只能拿到形参对应的实参值
	function getSum(a) {
	// var c = a + b
	// console.log(c)
	console.log(a)
	// console.log(b)

	}

	getSum(1, 2)

43.函数的封装求和

// 求1-10之间的和
	// var sum = 0
	// for (var i = 1; i <= 10; i++) {
	// sum = sum + i

	// }
	// console.log(sum)
	// // 求 10-20之间的和
	// var sum1 = 0
	// for (var i = 10; i <= 20; i++) {
	// sum = sum + i

	// }
	// console.log(sum1)


	function getSum(a, b) {
	var sum2 = 0
	for (var i = a; i <= b; i++) {
	sum2 = sum2 + i

	}
	console.log(sum2)
	}
	getSum(1, 10)
	getSum(10, 20)

44.reture语句

/*
	return 和continue/break相似，
	continue是跳出本次循环
	break是跳出整个循环
	return 不仅可以结束循环，还可以返回return语句中的值，还可以结束当前的函数体内的代码
	*/

	function fn() {
	console.log('你好')
	return
	console.log('我在这呢')
	}
	fn()

45.return使用

// return特点：
	/*
	1 不仅可以结束循环，
	2 还可以返回return语句中的值，
	3 还可以结束当前的函数体内的代码
	*/
	// function getSum(a, b) {
	// var sum2 = 0
	// for (var i = a; i <= b; i++) {
	// sum2 = sum2 + i
	// return
	// }
	// console.log(sum2)
	// }
	// getSum(1, 10)
	// getSum(10, 20)

	//函数中如果没有return值打印函数会是undefined
	// function fn() {

	// }
	// console.log(fn())


	// return语句后灭有返回值，会返回undefined
	// function fn() {
	// return
	// }
	// console.log(fn())


	//如果return后有一个返回值，就会返回这一个值
	// function fn() {
	// return 1
	// }
	// console.log(fn())


	//如果return中返回了多个以逗号隔开的值，会返回最后一个
	// function fn() {
	// return 1, 2, 3
	// }
	// console.log(fn())



	//如果return后面写的是数组，会返回数组
	function fn() {
	return [1, 2, 3, 4]
	}
	console.log(fn())

46.return案例

// 三元表达式返回两个值中的最小值
	// function getMin(a, b) {
	// return a > b ? b : a
	// }
	// // console.log(getMin(44, 64))
	// var min = getMin(44, 64)
	// console.log(min)

	// console.log(1 > 2 ? true : '')