chapter1.4、JS的函数，作用域，异常处理

JS语法

函数

一等公民

function 函数名(参数列表) {
    函数体;
    return 返回值;
}

function add(x,y){
    return x+y;
}
console.log(add(3,5));

函数表达式

// 匿名函数
const add = function(x, y){
    return x + y;
    };
console.log(add(4, 6));
// 有名字的函数表达式
const sub = function fn(x, y){
    return x - y; 
};
console.log(sub(5, 3));
//console.log(fn(3, 2)); // fn只能用在函数内部
// 有名字的函数表达式
const sum = function _sum(n) {
    if (n==1) return n;
    return n + _sum(--n) // _sum只能内部使用
}
console.log(sum(4));

函数、匿名函数、函数表达式的差异

除非递归使用，否则不用内部命名

函数会声明提升，函数表达式不会

高阶函数

高阶函数：函数作为参数或返回一个函数

计数器counter

const counter = function () {
    let c = 0;
    return function(){
        return ++c;
    };
};
const c = counter()
console.log(c())
console.log(c())
console.log(c())
console.log(c())

map函数，可以对某一个数组的元素进行某种处理

const map = function(arr,fn) {
    let newarr = [];
    for (let i in arr) {
        newarr[i] = fn(arr[i])
    }
    return newarr
}
console.log(map([1,2,3,4], function(x){return ++x}))
console.log(map([1,2,3,4],x => x+3))

生成器版本

var map = function* (fn, arr) {
    for (i in arr)
    yield fn(arr[i]);
};
let newarr = map(x => x+10, [1,2,3,4]);
for (x of newarr)
    console.log(x);    

箭头函数

箭头函数就是匿名函数，它是一种更加精简的格式。

箭头函数参数

如果一个函数没有参数，使用()
如果只有一个参数，参数列表可以省略小括号()
多个参数不能省略小括号，且使用逗号间隔

箭头函数返回值

如果函数体部分有多行，就需要使用{}，如果有返回值使用return。
如果只有一行语句，可以同时省略大括号和return。
只要有return语句，就不能省略大括号。 console.log(map([1,2,3,4], x => {return ++x})) ，有return必须有大括号。
如果只有一条非return语句，加上大括号，函数就成了无返回值了，例如 console.log(map([1,2,3,4], x => {x*2})); 加上了大括号，它不等价于 x =>{return x*2} 。因此，记住 x => x*2 这种正确的形式就行了。

函数参数

普通参数

一个参数占一个位置，支持默认参数

const add = (x,y) => x+y;
console.log(add(4,5));
// 缺省值
const add1 = (x,y=5) => x+y;
console.log(add1(4,6));
console.log(add1(4));

1、JS中并没有Python中的关键字传参

2、JS只是做参数位置的对应

3、JS并不限制默认参数的位置

add2(y=2,z=3)相当于add2(2,3)，因为JS没有关键字传参，但是它的赋值表达式有值，y=2就是2，

z=3就是3

参缺省值参数尽量往后放。

函数的所有参数会被保存在一个arguments的键值对字典对象中。

可以传表达式，没有值就是在函数内定义了一个为define的变量，处理为undefined
形参随便传，按照位置对应，可以超出，也可以少于，保存在数组中。少于就是undefined，多也会保存在键值对字典中。

可变参数(rest parameters剩余参数)

const sum = function (...args){
    let result = 0;
    for (let x in args){
        result += args[x];
    }
    return result;
};
console.log(sum(3,6,9))

arguments对象

(function (p1, ...args) {
    console.log(p1);
    console.log(args);
    console.log('----------------');
    console.log(arguments); // 字典
    for (let x of arguments)
        console.log(x);
})('abc', 1,3,5)

ES6之前，arguments是唯一可变参数的实现。

ES6开始，不推荐，建议使用可变参数。为了兼容而保留。

注意，使用箭头函数，取到的arguments不是我们想要的，如下

参数解构

Js支持参数解构，不需要解构后的值个数和参数个数对应

函数返回值

python 中可以使用 return 1,2 返回多值，本质上也是一个值，就是一个元组。

表达式的值
类C的语言，都有一个概念——表达式的值

赋值表达式的值：等号右边的值。

逗号表达式的值：类C语言，都支持逗号表达式，逗号表达式的值，就是最后一个表达式的值。

JS的函数返回值依然是单值

a = (x = 5, y = 6, true);
console.log(a); // true
b = (123, true, z = 'test')
console.log(b)
function c() {
    return x = 5, y = 6, true, 'ok';
}
console.log(c()); // ok

函数作用域

function是函数的定义，是一个独立的作用域，其中定义的变量在函数外不可见。
var a = 100 可以提升声明，也可以突破非函数的块作用域。
a = 100 隐式声明不能提升声明，在“严格模式”下会出错，但是可以把变量隐式声明为全局变量。建议少用。
let a = 100 不能提升声明，而且不能突破任何的块作用域。推荐使用。

严格模式：使用"use strict";，这条语句放到函数的首行，或者js脚本首行

异常

抛出异常

Js的异常语法和Java相同，使用throw关键字抛出。
使用throw关键字可以抛出任意对象的异常

捕获异常

try...catch 语句捕获异常。
try...catch...finally 语句捕获异常，finally保证最终一定执行。

注意这里的catch不支持类型，也就是说至多一个catch语句。可以在catch的语句块内，自行处理异常

try {
    //throw new Error('new error');
    //throw new ReferenceError('Ref Error');
    //throw 1;
    //throw new Number(100);
    // throw 'not ok';
    // throw [1,2,3];
    // throw {'a':1};
    throw () => {}; // 函数
} catch (error) {
    console.log(typeof(error));
    console.log(error.constructor.name);
} finally {
    console.log('===end===')
}