//递归函数,就是在函数的内部继续调用自己,注意:递归函数一定要有结束条件,否则就是死循环
function fun() {
console.log("你好!");
let jx = prompt("继续执行吗(y/n)")
//这个判断就是控制递归函数的结束条件
if (jx == "y") {
fun()
}
}
fun()
//高阶函数:当前函数的参数是函数或函数的返回值是函数,满足其中一个就是高阶函数
//1。函数的参数是函数
function fun1() {
console.log("我是方法一");
}
//方法二是高阶函数,因为它的参数是函数
function fun2(fun) {
fun()
console.log("我是方法二");
}
fun2(fun1)
//2.函数的返回值是函数
function fun3() {
return function () {
console.log("我是方法三");
}
}
let fun4 = fun3()
fun4()
//函数的参数是一个函数。这个函数我们也称为回调函数
let arr = [11, 22, 33, 44, 55, 66, 77, 88, 111, 222, 333, 444]
//返回数组中所有的偶数,并保存到一个新的数组中
let os = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0) {
os.push(arr[i])
}
}
console.log(os);
let sws = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] % 2 == 0 && arr[i] < 1000) {
sws.push(arr[i])
}
}
console.log(sws);
//返回数组中所有能被3整除
function myFilter(arr, callBack) {
let newArr = [] //定义一个新数组
for (let i = 0; i < arr.length; i++) {
//if的条件返回true,表示找到了满足条件的数,但是条件会变化
if (callBack(arr[i])) {
newArr.push(arr[i])
}
}
return newArr
}
//判断函数是否是偶数
function osFun(num) {
return num % 2 == 0
}
let a1 = myFilter(arr, osFun)
console.log(a1);
let ret2 = myFilter(arr, function (num) { return num % 2 != 0 })
console.log(ret2);
let ret3 = myFilter(arr, num => num % 2 != 0)
console.log(ret3);
let arr = [11, 22, 33, 44, 55, 66, 77, 88, 111, 222, 333, 444]
//forEach方法,用于遍历数组,方法需要传一个函数参数,函数的第一个参数是数组的每一项元素,第二个参数是每一项元素的索引
arr.forEach(function (item, index) {
console.log(item + " " + index);
})
console.log("-------------------------------------");
//filter方法,用于过滤数组,从数组中返回满足条件的数
let ret1 = arr.filter(function (item) {
return item % 2
})
console.log(ret1);
let ret2 = arr.filter(item => item % 3 == 0)
console.log(ret2);
console.log("-------------------------------------");
//map方法,用于根据原数组隐射出满足条件的新数组
//要求 :返回数组每个数+100后的数组
let ret3 = arr.map(item => item + 100)
console.log(ret3);
//返回数组中,每个数%3后的余数
let ret4 = arr.map(item => item % 3)
console.log(ret4);
console.log("-------------------------------------");
//some方法用于检查数组中是否有满足条件的数据,有返回true,没有返回falase
let ret5 = arr.some(item => item == 66) //条件满足等于66
console.log(ret5);
let ret6 = arr.some(item => item > 100) //条件满足大于100
console.log(ret6);
console.log("-------------------------------------");
//every方法,用于检查数组中所有满足条件
let ret8 = arr.every(item => item % 2 == 0) //检查数组中所有的数是否都是偶数
console.log(ret8);
let ret9 = arr.every(item => item > 10) //检查数组中的数是否大于0
console.log(ret9);
console.log("-------------------------------------");
let arr10 = [55, 99, 11, 33, 66]
//sort方法,默认就是升序,可以传一个回调函数,回调函数有两个参数
//参数1-参数2是升序,参数2-参数1是降序
arr10.sort()
console.log(arr10); //默认值 不传参数 是升序
arr10.sort((a, b) => a - b)
console.log(arr10); //升序
arr10.sort((a, b) => b - a)
console.log(arr10); //降序
console.log("-------------------------------------");
//find方法用于在数组中查找满足条件的第一个数 ,如果没有返回undefined
let ret10 = arr.find(item => item % 4 == 0) //查找数组中第一个能被4整除的数
console.log(ret10);
let ret11 = arr.find(item => item > 10000)
console.log(ret11);
console.log("-------------------------------------");
//findIndex 方法,用于数组中查找满足条件的数组第一个数索引位置,如果没有返回-1
let ret12 = arr.findIndex(item => item > 10000)
console.log(ret12);
let momey = 10000
function pay() {
if (momey >= 7000) {
money -= 7000
console.log(`买了一部ipone15,花了7000,存款还剩下${money}`);
} else {
console.log("对不起,余额不足");
}
}
console.log('调用pay方法才会触发花钱机制,不调用就不会触发,或者可以先不调用....');
momey -= 10000 //成员变量是公开的,很容易被篡改
//定义一个变量只是暂时先不用,很有可能被其他程序修改,所以成员变量不能保证数据的安全性
pay()
console.log("-----------------------------------");
//如何解决成员变量不安全的问题,使用闭包函数去保护
//闭包函数,也是一个高阶函数,因为它要在函数内部返回出去一个函数
function myCk() {
//闭包函数就是在外层函数中定义函数,在内层函数中使用函数
let money = 10000
return function () {
if (momey >= 7000) {
money -= 7000
console.log(`买了一部ipone15,花了7000,存款还剩下${money}`);
} else {
console.log("对不起,余额不足");
}
}
}
//调用myCk函数,此时在函数中会初始化一个money,值是10000
//myCk函数会返回一个函数,这里我们用一个变量去接受
let my = myCk()
console.log("此时我赞了一笔存款不想花。。。。。");
console.log("当我想花的时候调用方法");
my()