JS基础入门-----函数

函数

函数的作用：可以实现一定功能
即把可以实现一定功能的代码，封装成一个函数
声明函数
注：不会直接执行，什么时候执行取决于什么时候调用
1.字面量声明
书写格式： 关键字 标识符（函数名） 小括号 {代码块/函数体}
function f70 () {代码块}

function serach() {//创建函数
    console.log("ddddd");
}

2.构造函数声明
书写格式 ：关键字 标识符 赋值符号 new Fution();
let f70 = new Function();
3.匿名函数表达式(函数表达式（匿名函数表达式）声明函数)
书写格式： 标识符 赋值符号 function() {函数体 }

let f70 = function() {
    console.log(`1234569`);
}

调用函数
书写格式 函数名（）

function serach() {//创建函数
    console.log("ddddd");
}
serach()//执行函数

函数三要素：
1.函数名
2.参数
形参（形式参数）
在函数声明的时候
实参（实际参数）
在函数调用的时候
形参和实参可以重名，但是不影响
形参比实参多，多的形参会是undefined
实参的个数比形参多，多的实参不会使用

function f70(name,name1,name2,name3){
    console.log(`1号${name},2号${name1},3号${name2},4号${name3}`);
}
let name = "aaa";
let name1 = "bbb"
let name2 = "ccc"
let name3 = "ddd"
f70(name,name2,name1,name3)//1号aaa,2号ccc,3号bbb,4号ddd

3.返回值
返回值 return （只能返回一个值 但是可以用引用数据类型返回多个值）
写了return，只返回后面的return后面的内容
如果没有，就返回undefined
注：具备终止函数的功能

function f70 (){
    console.log("aaa");
}
console.log(f70());//先执行console.log("aaa");然后没有返回值在输出undefined

类数组
函数名.arguments
arguments是函数的属性，返回所有实参的内容;
可以类似于数组的使用方法进行值的获取
函数名.arguments[下标]可以获取到第几个值
函数名.arguments[.arguments.length-1] 获取最后一个实参的值

function f70(name,name1,name2,name3){
    console.log(`1号${name},2号${name1},3号${name2},4号${name3}`);
console.log(f70.name);//f70
console.log(f70.arguments)//[Arguments] { '0': 'aaa', '1': 'ccc', '2': 'bbb', '3': 'ddd' }
console.log(f70.arguments[1])//ccc
console.log(f70.arguments.length)//4
}
let name = "aaa";
let name1 = "bbb"
let name2 = "ccc"
let name3 = "ddd"
f70(name,name2,name1,name3)//1号aaa,2号ccc,3号bbb,4号ddd

不定参数（…最后一个形参）
必须写在最后一位形参的（最后一个会接收后面所有的值）

 function f70(a,b,...c){
     console.log(a,b,c);
     }
f70(1,2,3,4,5,6);//1 2 [ 3, 4, 5, 6 ]


function f70(a,...b,c){
    console.log(a,b,c);
}
f70(1,2,3,4,5,6);
//SyntaxError: Rest parameter must be last formal parameter

函数名.length会返回函数形参的个数
不计算不定参数（…参数）
只计算有默认值前面的形参个数

箭头函数
1.省略function关键字，
2.如果只有一个形参，可以省略小括号
3.如果函数体只有一条语句，可以省略大括 号
4.如果函数体只有一条语句，并且需要返回这条语句的结果可以省略return
5.不可以使用arguments（arguments是函数的属性，返回所有实参的内容）
6.不会吧this绑定到函数上
7.不可以用作构造函数

let f71 = a => a + 1;
console.log(f71(0));//1

let f71 = () => console.log(1);
f71();//1

let f71 = a =>a+1;
console.log(f71(2));//3

let f71 = (a,b) =>{
    let f70 = a+b;
    return f70;
}
console.log(f71(1,2));//3

回调函数

函数A给函数B当参数的时候，A就是回调函数

function A(temp){
    console.log('aaa');
    temp();
}
function B(){
    console.log('bbb')
}
A(B)//aaa  bbb

数组的排序

//数组排序
let F70 = [1, 30, 5, 6, 8, 35];
//升序
let arr = F70.sort((a, b) => a - b);
console.log(arr);
//降序
let arr1 = F70.sort((a, b) => b - a)
console.log(arr1);

数组的方法.every
判断数组中的每个数是否满足需求，有一个不是都会返回false，都满足才会输出true

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.every(a => a % 2 == 0)
console.log(state);//false

数组的方法.some
判断数组中的每个数是否满足需求，有一个是都会返回true，都不满足才会false

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.some(a => a % 2 == 0)
console.log(state);//true

数组的方法.filter
过滤，返回满足条件的值

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.filter(a => a % 2 == 0)
console.log(state);//[ 30, 6, 8 ]

【扩展】

let A = [1,2,3]
let B = [2,3,4]
// 交集(相同的值)
let intersect = A.filter(a=>B.includes(a))
console.log(intersect);//[ 2, 3 ]

// 差集(不同的值)
let difference = A.filter(a=>!B.includes(a))
console.log(difference);//[ 1 ]

//并集
let union = new Set([...A,...B]);
console.log([...union]);//[ 1, 2, 3, 4 ]

数组的方法.map
遍历出数组中的每个值，执行箭头函数操作，吧结果以新数组形式返回，不会改变原数组。
不能使用break终止遍历

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.map(a => a % 2 == 0)
console.log(state);//[ false, true, false, true, true, false ]

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.map(a => a -1)
console.log(state,F70);//[ 0, 29, 4, 5, 7, 34 ] [ 1, 30, 5, 6, 8, 35 ]

数组的方法.forEach
遍历出数组中的每个值，执行箭头函数操作，没有返回值，不会改变原数组。
不能使用break终止遍历

let F70 = [1, 30, 5, 6, 8, 35]
let state = F70.forEach(a => a -1)
console.log(state);//undefined

let F70 = [1, 30, 5, 6, 8, 35]
F70.forEach(a => {
console.log(a-1);  //0,29,4,5,7,34
})

立即执行函数
创建即调用，调用即销毁
使用场景：关于一次性变量

(function f70(){
    console.log('123');
})()