1.函数
无参数的函数：
声明函数：function 函数名（）{
函数体
}
调用函数：函数名（）
注意：函数不调用，自己不执行
********************************************************************************
带参数的函数：
function 函数名（形参1，形参2....）{
console.log（形参1，形参2）
}
函数名（实参1，实参2....）
********************************************************************************
带返回值的函数：
function 函数名（）{
return 需要返回的结果
}
函数名（）
案例：
function fun3(num1, num2) {
let sum = num1 + num2
return sum
}
let sum = fun3(100, 200)
console.log(sum);
2.递归
function 函数名(形参) {
if (值 === 1) {
return 值
}
let 变量 = 值 + 函数名(值 - 1)
return 变量
}
console.log(函数名(实参));
案例：
function calc(num) {
if (num === 1) {
return num
}
return num + calc(num - 1)
}
console.log(calc(1));
3.高阶函数-回调函数
function 函数名(形参1：300, 形参2：100, 回调函数callback) {
return 回调函数callback(参数1：300, 参数2：100)
}
定义一个方法：
let add = function(参数1：300, 参数2：100) {
return 参数1：300+ 参数2：100
}
let 变量r1 = 函数名(实参1：300, 实参2：100, 方法：add)
console.log(变量r1);
直接写到实参里：
let 变量r1 = 函数名(实参1：300, 实参2：100, 方法：function(num1, num2) {
return num1+num2
})
箭头函数简写形式：
let 变量r1 = 函数名(实参1：300, 实参2：100,方法：(num1, num2) => num1+num2)
案例：
function myFor(arr, callback) {
for (let i = 0; i < arr.length; i++) {
if (callback(arr[i])) {
console.log(arr[i]);
}
}
}
// myFor(arr, function(num) {
// return num % 2 === 0
// })
myFor(arr, num => num % 3 === 0)
4.闭包函数
function 方法1() {
let num1 = 10
let num2 = 20
function 方法2() {
let sum = num1 + num2
return sum
}
return fun2
}
let r = fun1()
console.log(r);
console.log(r());
案例：
function calc(n1, n2, type) {
// 数据定义在函数里面，用参数传值，保证了数据的安全性
let num1 = n1
let num2 = n2
switch (type) {
case '+':
return function() {
console.log(`${num1}+${num2}=${num1 + num2}`);
}
case '-':
return function() {
console.log(`${num1}-${num2}=${num1 - num2}`);
}
}
}
5.arguments
arguments是函数内部的一个内置对象
arguments对象里面保存这方法的所有参数
arguments对象里面有个一个callee方法，该方法指向当前方法本身
案例：
function calc(num) {
if (num === 1) {
return num
}
// 因为arguments.callee 就是 指向当前方法本身。
// 这样的做的好处是，防止外部方法名修改后，导致递归调用失效。
let sum = num + arguments.callee(num - 1)
return sum
}
6.对象
let obj = {
定义属性——属性名：属性值
定义方法——方法名：function（）{ }
或者——方法名（）{ }
}
定义方法时，可以方法名：function（）{ }
也可以方法名（）{ }
案例：
定义一个计算器对象
let calc = {
定义计算器的属性
num1: 0,
num2: 0,
定义计算器的方法：方法名：function（）{ }
jia: function() {
在对象的方法中，获取对象的其它成员，要通过this
console.log(`${this.num1}+${this.num2}=${this.num1+this.num2}`);
},
在SE6中，对象的方法，也可以采用下面的方式：方法名（）{ }
jian() {
console.log(`${this.num1}-${this.num2}=${this.num1-this.num2}`);
7.构造函数
function Student(形参1,形参2,形参3...) {
this.属性名=形参1
this.属性名=形参2
this.属性名=形参3
this.方法名=function（）{ }
...............
}
let s1 = new Student(实参1,实参2,实参3...)
定义方法时，可以this.方法名=function（）{ }
案例：
function Student(no, name, age, sex) {
this.no = no
this.name = name
this.age = age
this.sex = sex
this.sayHi = function() {
console.log(`大家好！我叫${this.name}`);
}
}
let s1 = new Student(1001, '张三', 20, '男')
console.log(s1);
s1.sayHi()
8.原型对象
function Student(形参1,形参2,形参3...) {
this.属性名=形参1
this.属性名=形参2
this.属性名=形参3
...............
}
Student . prototype . 方法名=function（）{ }
let s1 = new Student(实参1,实参2,实参3...)
定义方法时，可以构造函数名.prototype.方法名=function（）{ }
案例：
function Student(name, age, sex) {
this.name = name
this.age = age
this.sex = sex
}
将方法写到原型对象上
Student.prototype.sayHi = function() {
console.log(`Hi！我叫${this.name}，今年${this.age}岁，性别是${this.sex}`);
}
let s1 = new Student('张三', 20, '男')
s1.sayHi()
s1.study(8)
s1.play(3)
9.ES6新语法
class Student {
constructor(形参1,形参2,形参3...){
this.属性名=形参1
this.属性名=形参2
this.属性名=形参3
...............
}
方法名=function（）{ }——给类添加一个方法
方法名（）{ }——给原型对象加方法
}
let s1 = new Student(实参1,实参2,实参3...)
定义方法时，可以方法名=function（）{ }
案例：
class Person {
constructor(name, age, gender) {
this.name = name,
this.age = age
this.gender = gender
}
// 给类添加一个方法
sayHi = function() {
console.log(this.name, this.age, this.gender);
}
// 用这种方式定义的方法，是将方法定义的类的原型对象中去
sayHello() {
console.log('hello!');
}
}
let s1 = new Student('张三', 20, '男')
s1.sayHi()
10.继承
定义第一个构造函数：
function Student(形参1,形参2,形参3..) {
this.属性名=形参1
this.属性名=形参2
this.属性名=形参3
}
Student . prototype . 方法名=function（）{ }
let s1 = new Student(实参1,实参2,实参3...)
定义第二个构造函数：
function Teacher(形参1,形参2,形参3,形参4) {
Student.call（this，形参1,形参2,形参3）——继承Student的属性
this.属性名=形参4——定义属于Teacher自己的属性
}
Teacher . prototype=new Student（）—— 继承Student的方法
Teacher . prototype . 方法名=function（）{ }——定义属于Teacher自己的方法
let t1 = new Teacher(实参1,实参2,实参3，实参4)
后面的以此类推，
继承第一个构造函数的属性用：第一个构造函数名.call（this，形参1,形参2,形参3）
继承第一个构造函数的方法用：第二个构造函数名 . prototype = new 第一个构造函数名（）
11.ES6的继承
定义第一个构造函数：
class Student {
constructor(形参1,形参2,形参3){
this.属性名=形参1
this.属性名=形参2
this.属性名=形参3
}
方法名（）{ }——给原型对象加方法
}
let s1 = new Student(实参1,实参2,实参3)
定义第二个构造函数：
class Teacher extends Animal { ——继承Student的方法
constructor(形参1,形参2,形参3，形参4) {
super(形参1,形参2,形参3) ——调用父类（Student）的构造函数
this.属性名 = 形参4
}
函数名( ) { }——定义属于Teacher自己的方法
}
let t1 = new Teacher(实参1,实参2,实参3，实参4)t
后面的以此类推，
继承父类构造函数：class 第二个构造函数名 extends 第一个构造函数名
调用父类的构造函数： super(形参1,形参2,形参3)
