表达式和语句
表达式
一个表达式可以产生一个值，有可能是运算、函数的调用、有可能是字面量。表达式可以放在任何需要值的地方。
语句
语句可以理解为一个行为，循环语句和判断语句就是典型的语句，一个程序中有很多个语句组成，一般情况下；分隔成一个一个的语句。
流程控制
程序的三种基本结构
顺序结构
从上到下执行的代码就是顺序结构，程序默认是由上到下顺序执行的
分支结构
根据不同的情况，执行对应的代码
循环结构
循环结构：重复做一件事
分支结构
if语句
语法结构
if (/* 条件表达式 */) {
// 执行语句
}
if (/* 条件表达式 */){
// 成立执行语句
} else {
// 否则执行语句
}
if (/* 条件1 */){
// 成立执行语句
} else if (/* 条件2 */){
// 成立执行语句
} else if (/* 条件3 */){
// 成立执行语句
} else {
// 最后默认执行语句
}
案例
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>if语句</title>
<!-- 引入jquery -->
<script src="jquery-1.11.3.min.js"></script>
</head>
<body>
<input type="date" class="times">
<button class="btn">判断闰年</button>
<div class="no"></div>
<script>
// 判断一个年份是闰年还是平年
//条件是四年一闰，四百年一闰，一百年不闰
// 要求点击按钮判断input里面的月份是不是闰年
// var year = 2020;
// 声明一个字符串
var values = '';
// 给input自定义一个属性获取到每次input的val值
$(".times").change(function () {
$(".times").attr("value", $(this).val()); //赋值
console.log($(this).val())
values = $(this).val();
// 截取字符串substring(0,i),从0到第i个
values = values.substring(0, 4);
console.log(values)
});
// 点击按钮判断
$(".btn").click(function () {
// 判断条件
if ((values % 4 == 0) || (values % 400 == 0) && (values % 100 != 0)) {
$(".no").text('今年是闰年！');
} else {
$(".no").text('今年不是闰年！');
}
})
// 求两个数的最大数
var a = 10, b = 20;
if (a > b) {
console.log('a比b大');
} else {
console.log('b比a大');
}
// 判断一个数是偶数还是奇数
var c = 8;
if (c % 2 == 0) {
console.log('c是偶数');
} else {
console.log('c是奇数');
}
// 分数转换，把 <60 E 60-70 D 70-80 C 80-90 B 90 - 100 A
var score = 58;
// 或者大于等于90 ...
if (score < 60) {
console.log("E");
} else if (60 < score < 70) {
console.log("D");
} else if (70 < score < 80) {
console.log("C");
} else if (80 < score < 90) {
console.log("B");
} else {
console.log("A");
}
</script>
</body>
</html>
三元运算符
表达式1？表达式2：表达式3
是if…else语句的一种简化写法
案例
<script>
// 是否年满十八岁
var age = 19;
var msg = age >= 18 ? '满十八岁' : '不满十八岁';
console.log(msg);
// 两个数找最大
var a = 10; b = 20;
var msgs = a > b ? a + '大于' + b : b + '大于' + a;
console.log(msgs);
</script>
switch语句
语法格式
switch (expression) {
case 常量1:
语句;
break;
case 常量2:
语句;
break;
case 常量3:
语句;
break;
…
case 常量n:
语句;
break;
default:
语句;
break;
}
案例：
<script>
// 显示星期几
var day = 5;
switch (day) {
case 1:
console.log('星期一');
break;
case 2:
console.log('星期二');
break;
case 3:
console.log('星期三');
break;
case 4:
console.log('星期四');
break;
case 5:
console.log('星期五');
break;
case 6:
console.log('星期六');
break;
case 7:
console.log('星期天');
break;
}
</script>
break可以省略，如果省略，代码会继续执行下一个case
switch语句在比较值时使用的是全等操作符，因此不会发生类型转换（例如字符串‘10’不会等于数字10）
布尔类型的隐式转换
流程控制语句会把后面的值隐式转换成布尔类型
转换为true 非空字符串 非0数字 true 任何对象
转换为false 空字符串0 false null undefined
// var num = 0;
// console.log(Boolean(num));
// 转换成false的情况 0 ''空字符串 NaN null undefined
// 隐式类型转换
// if (num) {
// console.log('hello');
// }
//
//
// var msg;
// if (msg) {
// console.log('hello');
// }
//
//
var str = '123';
var isOK = !!str; // Boolean(str);
console.log(isOK);
循环结构
在JavaScript中，循环语句有三种，while、do…while、for循环
while语句
基本语法
// 当循环条件为true时，执行循环体，
// 当循环条件为false时，结束循环。
while (循环条件) {
//循环体
}
代码示例：
// 计算1-100之间所有数的和
// 初始化变量
var i = 1;
var sum = 0;
// 判断条件
while (i <= 100) {
// 循环体
sum += i;
// 自增
i++;
}
console.log(sum);
<script>
var num = 1;
var sum = 0;
// 循环的条件100以内
while (num <= 100) {
// if判断 打印100以内7的倍数
// if (num % 7 == 0) {
// console.log(num);
// }
// 打印100以内的所有偶数
// if (num % 2 == 0) {
// console.log(num);
// }
// 打印100以内所有偶数
if (num % 2 == 0) {
sum += num;
}
num++;
}
console.log(sum);
</script>
do…while语句
do…while语句和while循环非常像，二者经常可以相互替代，但是do…while的特点是不管条件成不成立，都会执行一次。
基础语法：
do {
// 循环体;
} while (循环条件);
代码示例：
// 初始化变量
var i = 1;
var sum = 0;
do {
sum += i;//循环体
i++;//自增
} while (i <= 100);//循环条件
案例：
<script>
// 求100以内所有3的倍数的和
// var i = 1;
// var sum = 0;
// do {
// // 循环体
// if (i % 3 == 0) {
// sum += i;
// }
// i++;
// } while (i <= 100);
// console.log(sum);
// do-while循环
do {
var msg = prompt('你到底爱不爱我？', '请输入yes/no');
} while (msg !== 'yes');
console.log('小样还想点no');
</script>
for语句
while和do…while 一般用来解决无法确认次数的循环，for循环一般在循环次数确定的时候比较方便
for循环语法：
// for循环的表达式之间用的是;号分隔的，千万不要写成,
for (初始化表达式1; 判断表达式2; 自增表达式3) {
// 循环体4
}
执行顺序：1243 —- 243 —–243(直到循环条件变成false)
- 初始化表达式
- 判断表达式
- 自增表达式
- 循环体
案例：
<script>
// 打印1-100之间的数
// for (var i = 1; i <= 100; i++) {
// console.log(i);
// }
// 打印1-100之间所有数的和
// var sum = 0;
// for (var i = 1; i <= 100; i++) {
// sum += i;
// }
// console.log(sum);
// 打印1-100之间所有数的平均值
// var sum = 0;
// var avg;
// for (let i = 1; i < 100; i++) {
// sum += i;
// }
// avg = sum / 100;
// console.log(avg);
// 打印1-100之间所有偶数的和
// var num = 0;
// for (let i = 1; i <= 100; i++) {
// if (i % 2 == 0) {
// num += i;
// }
// }
// console.log(num);
// 打印九九乘法表
// 声明一个字符串变量
var str = '';
// 外循环，循环九次
for (let i = 0; i <= 9; i++) {
// 内循环 j=i
for (let j = i; j <= 9; j++) {
str += i + '*' + j + '=' + i * j + '\t';
}
// 换行
str += '\n';
}
console.log(str);
</script>
continue和break
break：立即跳出整个循环，即循环结束，开始执行循环后面的内容（直接跳到大括号）
continue：立即跳出循环，继续下一次循环（跳到++的地方）
案例：
<script>
// 求整数1-100的累加值，但要求碰到个位为3的数着暂停累加
// var sum = 0;
// for (let i = 1; i <= 100; i++) {
// if (i % 10 == 3) {
// console.log(i)
//
// }else{
// sum + = i;
// }
// }
// console.log(sum);
// 求整数1-100的累加值，但要求碰到个位为3的数就跳过
var sum = 0;
for (let i = 1; i <= 100; i++) {
if (i % 10 == 3) {
continue;
}
sum += i;
}
console.log(sum);
</script>
调试
- 过去调试JavaScript的方式
- alert（）
- console.log()
- 断点调试
断点调试是指自己在程序的某一行设置一个断点，调试时，程序运行到这一行就会停住，然后你可以一步一步往下调试，调试过程中可以看各个变量的当前的值，出错的话，调试到出错的代码行即显示错误，停下。 - 调试步骤
浏览器中按F12—–>sources—->找到需要调试的文件—>在程序的某一点设置断点 - 调试中的相关操作
watch：监视，可以通过watch可以监视变量的值的变化，非常的常用。
F10：程序单步执行，让程序一行一行的执行，这个时候，观察watch中的变量的值的变化
F8：跳到下一个断点处，如果后面没有断点了，则程序执行结束
tips:监视变量，不要监视表达式，因为监视了表达式，那么这个表达式也会执行。- 代码调试的能力非常重要，只有学会了代码提调试，才能学会自己解决bug的能力。
数组
数组是一个有序的列表，可以在数组中存放任意的数据，并且数组的长度可以动态的调整
- 字面量
// 创建一个空数组
var arr1 = [];
// 创建一个包含3个数值的数组，多个数组项以逗号隔开
var arr2 = [1, 3, 4];
// 创建一个包含2个字符串的数组
var arr3 = ['a', 'c'];
// 可以通过数组的length属性获取数组的长度
console.log(arr3.length);
// 可以设置length属性改变数组中元素的个数
arr3.length = 0;
获取数组元素
数组的取值
// 格式：数组名[下标] 下标又称索引
// 功能：获取数组对应下标的那个值，如果下标不存在，则返回undefined。
var arr = ['red',, 'green', 'blue'];
arr[0]; // red
arr[2]; // blue
arr[3]; // 这个数组的最大下标为2,因此返回undefined
遍历数组
遍历：遍及所有，对数组的每一个元素都访问一次就叫遍历。
数组遍历的基本语法：
for(var i = 0; i < arr.length; i++) {
// 数组遍历的固定结构
}
for(var n in arr){console.log(arr(n))}
数组中新增元素
数组的赋值：
// 格式：数组名[下标/索引] = 值;
// 如果下标有对应的值，会把原来的值覆盖，如果下标不存在，会给数组新增一个元素。
var arr = ["red", "green", "blue"];
// 把red替换成了yellow
arr[0] = "yellow";
// 给数组新增加了一个pink的值
arr[3] = "pink";
<script>
// // 数组 是一种数据类型
// // Number String
// var n1 = 6;
// var name = 'zs';
// // 数组 可以存储很多项，有顺序，很多项形成一个集合，这个集合就是数组 Array
// // 数组的字面量 []
// var names = ['zs', 'ls', 'ww', 'zl'];
// // 如何获取数组中的数据
// // 索引/下标 数组中的第一项的索引是从0开始
// console.log(names[0]);
// console.log(names[1]);
// // 获取数组中最后一项的值
// console.log(names[3]);
// // undefined
// console.log(names[4]);
//
//
// 数组中存储的数据类型可以不一致
// 但是不推荐这么用
// var names = ['zs', 'ls', 18, 19, true];
// console.log(names);
//
// 数组的长度: 数组中元素的个数
// var names = ['zs', 'ls', 'ww', 'zl', '', 'abc', '123'];
// // 获取数组的长度
// // console.log(names.length);
// //
// // console.log(names[0]);
// // 获取数组中的最后一个元素
// // 如果数组中有29项，最后一项的索引是多少？ 数组的长度 - 1
// console.log(names.length);
// console.log(names[names.length - 1]);
// 数组 的长度 可以动态改变
// var names = ['zs', 'ls', 'ww', 'zl'];
// // 如何修改数组中的元素
// // names[0] = 'xxx';
// // console.log(names);
// //
// // 给数组增加一项
// // names[4] = 'abc';
// names[6] = 'xxx';
// console.log(names);
// console.log(names.length);
// 获取数组中的每一项，并打印（遍历数组）
// var names = ['zs', 'ls', 'ww', 'zl'];
// for (var i = 0; i < names.length; i++) {
// console.log(names[i]);
// }
// 遍历数组 先打印最后一项 长度 - 1 长度 - 2
// var names = ['zs', 'ls', 'ww', 'zl'];
// for (var i = names.length - 1; i >= 0; i--) {
// console.log(names[i]);
// }
//
//
// 补充
var scores = []; // 空数组
console.log(scores.length);
for (var i = 0; i < 10; i++) {
scores[i] = i;
}
console.log(scores);
// 清空数组
scores.length = 0;
console.log(scores);
// var array = [57, 90, 100];
</script>
案例：
<script>
// 求一组数中所有数的和和平均值
var arr = [20, 10, 40, 0, 30, 50, 60, 0];
// 假设最大值在第一位
// var max = arr[0];
// var min = arr[0];
// var maxIndex = 0;
// var minIndex = 0;
// var sum = 0;
// var avg;
// for (let i = 0; i < arr.length; i++) {
// var a = arr[i];
// sum += a;
// }
// avg = sum / arr.length;
// console.log(sum);
// console.log(avg);
// 求一个数组中的最大值和最小值以及所在的位置
// for (let i = 0; i < arr.length; i++) {
// if (max < arr[i]) {
// max = arr[i];
// maxIndex = i;
// }
// if (min > arr[i]) {
// min = arr[i];
// minIndex = i;
// }
// }
// console.log('最大值：' + max);
// console.log('最大值所在的位置：' + maxIndex);
// console.log('最小值：' + min);
// console.log('最小值所在的位置：' + minIndex);
// 将字符串数组用|分隔
// var a = ['a', 'b', 'c'];
// var str = '';
// var fgf = '|';
// for (let i = 0; i < a.length; i++) {
// //在a后面加分隔符
// // str += a[i] + fgf;
// // 在a前面加分隔符
// str += fgf + a[i];
// }
// console.log(str);
//将数组中的第0项去掉，将不为0的值存入一个新数组
// var newArry = [];
// for (let i = 0; i < arr.length; i++) {
// // 判断不为0
// if (arr[i] !== 0) {
// // 将数据存入新数组
// newArry[newArry.length] = arr[i];
// }
// }
// console.log(newArry);
// 翻转数组
// 创建新数组
// var array = [];
// // 倒着遍历
// for (var i = arr.length - 1; i >= 0; i--) {
// array[array.length] = arr[i];
// }
// console.log(array);
// 冒泡排序 从小到大 外层循环：控制趟数，每一趟一个最大值 内层循环：控制比较次数，并且判断两个数的大小
// var count = 0; //记录趟数
// for (let i = 0; i < arr.length - 1; i++) {
// count++;
// for (let 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);
// console.log(count);
// 优化
var count = 0; //记录趟数
for (let i = 0; i < arr.length - 1; i++) {
// 假设数据排好了顺序
var isSort = true;
count++;
for (let j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// 没有排好
isSort = false;
var temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
// 某一趟结束，判断一下排序是否结束
// 如何判断排序是否排好，根据是否发生了数据交换，如果发生了数据交换说明没有排好
if (isSort) {
// 如果排序完成
break;
}
}
console.log(arr);
console.log(count);
</script>
函数
函数就是把一段相对独立的具有特定功能的代码块封装起来，形成一个独立实体，就是函数，在后续开发中可以反复调用，函数的作用就是封装一段代码，将来可以重复使用
函数的定义
- 函数声明
function 函数名(){
// 函数体
}
- 函數表式
var fn = function() {
// 函数体
}
特点：
函数体只有在调用的时候才会执行，调用需要（）进行调用
可以调用多次（重复使用）
代码示例：
// 声明函数
function sayHi() {
console.log("吃了没？");
}
// 调用函数
sayHi();
// 求1-100之间所有数的和
function getSum() {
var sum = 0;
for (var i = 0; i < 100; i++) {
sum += i;
}
console.log(sum);
}
// 调用
getSum();
函数的参数
- 为什么要有参数
function getSum() {
var sum = 0;
for (var i = 1; i <= 100; i++) {
sum += i;
}
console.log();
}
// 虽然上面代码可以重复调用，但是只能计算1-100之间的值
// 如果想要计算n-m之间所有数的和，应该怎么办呢？
- 语法
// 函数内部是一个封闭的环境，可以通过参数的方式，把外部的值传递给函数内部
// 带参数的函数声明
function 函数名(形参1, 形参2, 形参…){
// 函数体
}
// 带参数的函数调用
函数名(实参1, 实参2, 实参3);
- 形参和实参
- 形式参数：在声明一个函数的时候，为了函数的功能更加灵活，有些值是固定不了的值。我们可以给函数设置参数，这个参数没有具体的值，仅仅起到一个占位置的作用，我们通常称之为形式参数，也叫形参。
- 实际参数：如果函数在声明时，设置了形参，那么在函数调用的时候就需要传入对应的参数，我们把传入的参数叫做实际参数，也叫实参。
var x = 5, y = 6;
fn(x,y);
function fn(a, b) {
console.log(a + b);
}
//x,y实参，有具体的值。函数执行的时候会把x,y复制一份给函数内部的a和b，
函数内部的值是复制的新值，无法修改外部的x,y
函数的返回值
当函数执行完的时候，并不是所有时候都要把结果打印。我们期望函数给我一些反馈，这个时候可以让函数返回一些东西，也就是返回值。函数通过return 返回一个值。
返回值语法：
//声明一个带返回值的函数
function 函数名(形参1, 形参2, 形参...){
//函数体
return 返回值;
}
//可以通过变量来接收这个返回值
var 变量 = 函数名(实参1, 实参2, 实参3);
函数的调用结果就是返回值，因此我们可以直接对函数调用结果进行操作。
返回值详解：
- 如果函数没有显示的使用return语句，你们函数有默认的返回值：undefined
- 如果函数使用return语句，那么跟在return后面的值，就成了函数的返回值
- 如果函数使用return语句，但是return后面没有任何值，那么函数的返回值也是：undefined
- 函数使用return后，这个函数会在执行完return语句之后停止并立即退出，也就是说return后面的所有其他代码都不会执行
推荐：要么始终都返回一个值，要么永远都不要返回值。
案例：
<script>
// 写一个函数，计算两个数的和
function getSum(x, y) {
var sum = x + y;
console.log(sum); //300 3
}
// 调用函数
getSum(100, 200);
// 实参和形参
var a = 1;
var b = 2;
getSum(a, b);
// 圆的面积
function clice(r) {
var pi = 3.1415926;
console.log(pi * r * r);
}
clice(6);
// 求两个数中最大值,求三个数就用&&
function maxNumber(a, b) {
if (a > b) {
console.log(a);
} else {
console.log(b);
}
}
maxNumber(10, 20);
var c = 30;
var d = 40;
maxNumber(c, d);
// - 判断一个数是否是素数(又叫质数，只能被1和自身整数的数)
function jdugePrimeNumber(number) {
// 假设number是质数
var isPrime = true;
for (var i = 2; i < number; i++) {
// 判断是否有能被number整数的数
if (number % i === 0) {
// 如果此处执行了。说明不是质数
isPrime = false;
break;
}
}
if (isPrime) {
console.log('质数');
} else {
console.log('不是质数');
}
}
jdugePrimeNumber(13);
返回值
<script>
// 求一组数组中的最大值
function arrayMax(array) {
var max = array[0];
for (let i = 0; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
}
}
// 函数返回值
return max;
}
// 调用函数
var arr = [1, 3, 55, 8, 0, 48];
var max = arrayMax(arr);
console.log(max);
// 求阶乘 5*4*3*2*1
function getJieChen(n) {
var result = 1;
for (let i = 1; i <= n; i++) {
result = result * i;
}
return result;
}
var num = getJieChen(5);
console.log(num);
// 求1！+2！+3！+n!
function getSum(n) {
var sum = 0;
for (let i = 1; i <= n; i++) {
// 累加阶乘
sum += getJieChen(n);
}
return sum;
}
var sums = getSum(5);
console.log(sums);
</script>
arguments的使用
JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有的实参。arguments是一个伪数组，因此可以进行遍历。
案例：
<script>
function test(a, b, c) {
// 我们可以通过arguments 获取函数调用的时候的实参
// arguments非常像数组，但不是数组
console.log(arguments);
}
test(4, 5, 6);
// 求任意个数的最大值
function getMax() {
var num = arguments[0];
for (let i = 0; i < arguments.length; i++) {
if (num < arguments[i]) {
num = arguments[i];
}
}
return num;
}
var max = getMax(5, 0, 50, 20, 88);
console.log(max);
// 求斐波那契数列中第n个数是多少
function fibonacci(n) {
// 函数体
var n1 = 1;
var n2 = 1;
var n3;
for (let i = 3; i <= n; i++) {
n3 = n1 + n2;
n1 = n2;
n2 = n3;
}
return n3;
}
var r = fibonacci(6);
console.log(r);
// 翻转数组
// var a = [1, 2, 5, 8, 5, 4];
// var b = [];
// for (let i = a.length - 1; i >= 0; i--) {
// b[b.length] = a[i];
// }
// console.log(b);
// 翻转数组，返回一个新数组 [5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
// function reverse(array) {
// var newArray = [];
// for (var i = array.length - 1; i >= 0; i--) {
// newArray[newArray.length] = array[i];
// }
// return newArray;
// }
// // var arr = [5, 3, 2, 1];
// // console.log(reverse(arr));
// var arr = ['abc', 'xyz', '123'];
// console.log(reverse(arr));
// 对数组排序，从小到大 -- 冒泡排序
// function sort(array) {
// // 外层循环 控制趟数
// for (var i = 0; i < array.length - 1; i++) {
// // 假设排好序了
// var isSort = true;
// // 内层循环 控制比较的次数
// for (var j = 0; j < array.length - 1 - i; j++) {
// if (array[j] > array[j + 1]) {
// isSort = false;
// // 交换位置
// var tmp = array[j];
// array[j] = array[j + 1];
// array[j + 1] = tmp;
// }
// }
// // 判断是否排好了
// if (isSort) {
// break;
// }
// }
// return array;
// }
// var array = [34, 12, 88, 20, 30];
// console.log(sort(array));
// }
// 输入一个年份，判断是否是闰年[闰年：能被4整数并且不能被100整数，或者能被400整数]
// function isRun(year) {
// var result = false;
// if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
// result = true;
// }
// return result;
// }
// console.log(isRun(2016));
// 输入某年某月某日，判断这一天是这一年的第几天？
// 1998 5 18
// 5月份 18
// 4月份 30
// 3月份 31
// 2月份 闰年的时候29天 平年的时候28天
// 1月份 31
//
// 判断年份是否是闰年
function isRun(year) {
var result = false;
if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
result = true;
}
return result;
}
// 获取年月日 是当前年的多少天
function getDays(year, month, day) {
// 计算总共有多少天
var days = day; // 当前月份的天数
for (var i = 1; i < month; i++) {
switch (i) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days += 31;
break;
case 4:
case 6:
case 9:
case 11:
days += 30;
break;
case 2:
// 判断是平年28还是闰年29
if (isRun(year)) {
days += 29;
} else {
days += 28;
}
break;
}
}
return days;
}
console.log(getDays(1998, 5, 2));
</script>
函数其它
匿名函数
匿名函数：没有名字的函数
匿名函数如何使用：
将匿名函数赋值给一个变量，这样可以通过变量进行调用 匿名函数自调用
关于自执行函数（匿名函数自调用）的作用：防止全局变量污染
自调用函数
匿名函数不能通过直接调用来执行，因此可以通过匿名函数的自调用的方式来执行
(function () {
alert(123);
})();
函數是一种数据类型
function fn() {}
console.log(typeof fn);
- 函数作为参数
因为函数也是一种类型，可以把函数作为一个函数的参数，在一个函数中调用 - 函数作为返回值
因为函数是一种类型，所以可以把函数作为返回值从内部返回，这种用法在后面很常见。
function fn(b) {
var a = 10;
return function () {
alert(a+b);
}
}
fn(15)();
案例：
<script>
// //1 函数声明 - 命名函数
// function fn() {
// }
// //2 函数表达式 -- 后半部分 匿名函数
// var fn = function () {
// }
//
// 3 自调用函数 -- 当函数书写完成之后立即调用
// (function () {
// console.log('我是自调用函数');
// })()
//
//
// 4 函数也是一种数据类型 function 也是一种数据类型
var n = 5;
var str = '123';
var fn = function () {
console.log('我是传过来的函数');
}
// console.log(typeof fn);
// 4.1 因为函数是一种数据类型，所以函数可以作为另一个函数的参数
// function test(fun) {
// // 当我们调用函数的时候。如果没有传递参数，此时形参的值是什么？
// // 此时fun的值是undefined
// // console.log(fun);
// fun();
// }
// test(fn);
//
// 4.2 因为函数是一种数据类型，所以函数可以作为另一个函数的返回值
function test(a) {
var b = 5;
return function () {
console.log(a + b);
}
}
var fn = test(2); // 此函数返回的结果是一个函数
fn();
</script>
代码规范
- 命名规范
- 变量规范
var name = ‘zs’; - 注释规范
// 这里是注释 - 空格规范
- 换行规范
var arr = [1, 2, 3, 4];
if (a > b) {
}
for(var i = 0; i < 10; i++) {
}
function fn() {
}
cpm geometry homework proposal presentation purchase term paper