代码可靠性

## 函数式编程

### 两种编程方式

- 命令式编程

命令计算机如何做一件事，计算机会按照你的命令，一步一步的实现

```javascript
// 忽略map
// 随便写一下实现功能
let arr = [1,2,3,4];
let newArr = [];
for (let i = 0, i < arr.length; i++){
newArr.push(arr[i] +1);
}
console.log(newArr) // [2,3,4,5]

// 写成一个函数
let arr = [1,2,3,4];
let newArr = (arr) => {
let res = [];
for (let i = 0, i < arr.length; i++){
res.push(arr[i] +1);
}
return res
}
console.log(newArr(arr)) // [2,3,4,5]
```

上段代码是一个纯命令式编程，代码基本上是写死的,现在又有一个需求加5 ~~(产品需求变得太快了)~~。

- 函数式编程

函数式编程是一种编程规范，是一种构建计算机程序结构和元素的风格，相当于把计算机运算看作是数学函数的运算，避免了状态的变化和数据的可变。

```javascript
let arr = [1,2,3,4];
let newArr = (arr,fn)=>{
let res = [];
for(let i = 0; i < arr.lenght; i++){
res.push(fn(arr[i]))
}
return res;
}
let add = item => item + 5
console.log(newArr(arr,add));
```

其实就是将我们的程序分解为一些可重用的，跟可靠的且更易于理解的部分，然后把他们结合起来，形成一个gen更易推理的程序整体；

将一个复杂的程序拆分为若干个小程序，在组合起来实现最终的目的（类似于组件化的思想）；

我们只需要关心我们所需要完成的功能的代码。无需关心内部的实现。既然无需关心函数内部的实现，那么它会不会有产生副作用的代码？

- 纯函数

如果函数调用的参数相同，则永远返回相同的结果，他不依赖于程序执行期间，任何外部状态或者数据变化的影响，必须只受输入参数的影响，纯函数没有**函数副作用**。

```javascript
// 纯函数
let take = (a,b)=>{
return a * b
}
console.log(take(2,100))
// 非纯函数
let a = 100;
let take = b =>{
return a * b
}
console.log(take(2))
a = 200;
console.log(take(2))
```

- **函数副作用**
当函数调用时，除却返回值以外，还对主调用函数产生影响（修改了外部的变量或者修改参数）；

```javascript
// 函数修改了外部比变量
let a = 100;
let take = () =>{
a = a * 10
}
console.log(a)
```

- 可变性和不可变性

- 可变性
指一个变量被创建后，可以背随便改变他的值；

```javascript
let obj = { a : 100 };
let fn = (data) =>{
data.a = 200;
}
console.log(obj.a) // 200
```

- 不可变性
一旦被创建，永远不会被改变，不可变性是函数编程的核心概念；

```javascript
let obj = { a : 100 };
let fn = (data) =>{
let b = JSON.parse(JSON.stringify(data))
b.a = 200;
}
console.log(obj.a) // 100

```