数组：
指一组有顺序的数据，其作用就是用来一次性存储多个数据。（数组元素：数组中的每一个数据；数组长度：数据中元素的个数；数组索引：用来存储或访问数组中的数据，也叫下标，索引从0开始，即第一个数组元素的索引为0）创建数组的方法有两种：
1、通过构造函数创建数组：var 数组名 = new Array();
<script>
var array = new Array(4);
console.log(array); //[empty × 4],new Array(4)括号中的数字若为一个，则表示数组的长度，此时无数据；若为多个，则表示数组的每一项数据，特别注意：通过字面量的方式创建的数组当为一个值时，此时表示的是一个数组元素
var array = new Array(1, 2, 3, 4, 5);
console.log(array[3]); //4，数组中通过数组名[索引]来读取元素或储存元素
array[5] = 6;//通过索引添加数组元素
console.log(array);//[1, 2, 3, 4, 5, 6]
console.log(array.length);//5，数组名.length用来获取数组的长度
console.log(array[10]); //undefined,获取一个数组中没有的数组元素返回的值为undefined
</script>
2、通过字面量的方式创建数组：var 数组名 = [];
<script>
var array = [3];
console.log(array); //[3]，通过字面量的方式创建的数组中[]中的数字就是表示数组的元素
array = [3, true, null, "str"];
array[4] = 5;
console.log(array); //[3, true, null, "str", 5],数组中可以存多个数据类型的数据
console.log(array.length); //5,数组名.length用来获取数组的长度，即数组元素的个数
console.log(array[10]); //undefined,获取一个数组中没有的数组元素返回的值为undefined
var arr = [1, 2, 3, 4, 5];
var sum = 0;
for (var i = 0; i < arr.length; i++) {
sum += arr[i];
};
console.log('arr的和为：' + sum + '------' + 'arr的平均数为：' + sum / arr.length);//arr的和为：15------arr的平均数为：3
var array = [2, 3, 5, 1, 4];
var max = array[0];
for (var i = 0; i < array.length; i++) {
if (max < array[i]) {
max = array[i];
};
};
console.log('array中的最大值为：' + max); //array中的最大值为：5
var arr = [2, 3, 4, 5, 6, 1];
for (var i = arr.length - 1; i >= 0; i--) {
console.log('倒数arr：' + arr[i]);//1 6 5 4 3 2
};
var fruits = ['苹果', '香蕉', '菠萝蜜', '芒果', '荔枝'];
var str = '';
for (var i = 0; i < fruits.length - 1; i++) {
str += fruits[i] + '|';
};
str += fruits[fruits.length - 1];
console.log('在fruits中加|得到的结果：' + str); //在fruits中加|得到的结果：苹果|香蕉|菠萝蜜|芒果|荔枝
var arr = [1, 2, 3, 4, 0, 2, 0, 3];
var arr2 = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] != 0) {
arr2[arr2.length] = arr[i];
};
};
arr = arr2;
console.log(arr); //[1, 2, 3, 4, 2, 3],去掉arr中的0
var arr = [1, 2, 3, 4, 5];
var temp = arr[0];
for (var i = 0; i < arr.length / 2; i++) {
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
var temp = arr[i + 1];
};
console.log(arr); //[5, 4, 3, 2, 1],翻转数组
</script>
冒泡排序:
指把数组里面的元素按照从大到小或者从小到大的顺序进行排列。
<script>
var arr = [3, 4, 2, 1, 5];
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);//[5, 4, 3, 2, 1]
</script>
函数定义：
函数：把重复的代码进行封装，在需要的时候直接调用。语法：function 函数名(){函数体}，这里指命名函数，后面还有匿名函数；函数使用：函数名();注意： 函数需要先定义后使用，函数的命名需要遵循驼峰命名法，命名函数一旦重名，后面的会把前面的覆盖，函数也是一种数据类型
<script>
//1.函数声明：
function myName() {
console.log('苦海');
};
myName(); //苦海
//2.函数表达式：
var fn = function() {
console.log('函数体');
};
// 3.利用new Function(参数，函数体);创建函数，参数可以是多个，函数体写在最后面,
// 注意：括号里面各参数都是字符串形式,不推荐这种写法
var myFn = new Function('x', 'y', 'return x + y');
var myFn1 = new Function('x', 'y', 'console.log(x+y)');
console.log(myFn(1, 3));
myFn1(2, 3);
</script>
函数的参数：
函数后面小括号里的变量就是参数，形参：定义函数的时候函数后面小括号中的变量就是形参，实参：函数在调用的时候，括号里传的值为实参，当实参没有传值时，返回的是undefined，函数的参数可以是任何数据类型
<script>
function sum(x, y) {
var sum = x + y;
console.log(sum);
}
sum(10, 20);//30
sum(20,30);//50
function sum(x, y) {
var sum = x + y;
console.log(sum);
}
var num1 = parseInt(prompt('输入第一个数字'));
var num2 = parseInt(prompt('输入第二个数字'));
sum(num1, num2);
</script>
函数的返回值：
在函数内部有return关键字，并且在关键字后面有内容，那么这个内容就被返回,如果一个函数中没有明确的返回值，调用时被接收了，那么结果就是undefined,return后面的代码是不会执行的。形参和实参的个数可以不同，当实参的个数多于形参的个数时，正常返回形参个数处理后的结果；当实参的个数少于形参的个数时，此时没有实参对应的形参的值为undefined，函数的返回值可以是任何数据类型。
<script>
function getSum(x, y) {
var sum = x + y;
return sum;
console.log('测试return后面的代码是否执行');//经过测试后return后面的代码不执行
};
var result = getSum(1, 4);
console.log(result);// 5
</script>
函数里面可以调用函数：
<script>
function getSum(x, y) {
return x + y;
};
function getDiffer(x, y, z, g) {
return getSum(x, y) - getSum(z, g);
};
console.log(getDiffer(1, 2, 3, 4));
</script>
arguments伪数组：
当函数不确定参数时，可以使用arguments来解决问题，arguments.length是获取函数中传入的参数的个数；arguments[数字]用来获取某个参数，当数字为0时表示第一个参数。
<script>
function getSum() {
var sum = 0;
for (var i = 0; i < arguments.length; i++) {
sum += arguments[i];
};
return sum;
};
var result = getSum(1, 2);
console.log(result); //3
</script>
匿名函数（函数的其他调用方式及区别）：
指通过字面量的方式创建的函数(函数表达式)，其调用是变量名 + ( )；另一种匿名函数是把匿名函数的代码用括号包裹起来，这样就不会报错，然后想调用，就在括号后面在加一个括号。命名函数中，如果两个函数出现重名，无论在哪里调用，后面的函数会把前面的函数覆盖掉；而在匿名函数(函数表达式)中，变量的名字相同时，后面的不会覆盖前面的函数，只会给变量重新赋值。
<script>
var fn = function() {
console.log('这是一个通过字面量的方式创建的匿名函数');
};
fn(); //匿名函数的调用：变量名();
(function() {
console.log('这是一个通过字面量的方式创建的匿名函数');
})(); //匿名函数的调用：(匿名函数的代码)()，一次性的
// 相同函数名的命名函数中：
function f1() {
console.log('命名函数1');
};
f1(); //命名函数2
function f1() {
console.log('命名函数2');
};
f1(); //命名函数2.两个命名函数都执行的是函数2的代码
// 相同变量名的函数表达式中：
var f2 = function() {
console.log('函数表达式1');
};
f2();//函数表达式1
var f2 = function() {
console.log('函数表达式2');
};
f2();//函数表达式2
</script>
async function异步函数：
async function是用来定义异步函数，其语法：async function 函数名可选(函数参数) { 函数语句 }，
<script>
function fn(x) {
return new Promise(resolve => {
setTimeout(() => {
resolve(x);
}, 2000);
});
}
async function f1() {
var x = await fn(10);
console.log(x); // 10
}
f1();
</script>
await:
await用于等待一个Promise对象，只能在异步函数中使用，如果等待的值不是Promise，那么将当成promise处理过的值。
function* 表达式：
function*可以在一个函数内部定义一个生成器函数，函数里面的yield是定义数据的，如：
<script>
function* fn() {
yield 'a';
yield 'b';
yield 'c';
};
for (const values of fn()) {
console.log(values);// a b c
};
</script>
提示：本文图片等素材来源于网络，若有侵权，请发邮件至邮箱：810665436@qq.com联系笔者 删除。
笔者：苦海
