JavaScript中的不纯函数示例是什么

在看到了许多纯函数以及它们如何没有副作用之后，一个总是被视为不稳定和主要误差源的不纯函数的例子会是什么呢？

我能想到的一个例子（这确实很令人困惑）是。它不返回新数组，而是在返回原始数组时就地修改它

---

其他一些数组函数也可以这样做，例如

splice

，

push

，

shift

，

pop

，

unshift

，

pure

函数（获取参数并返回新值）：

inpure

函数（获取参数，修改参数并返回修改对象）：

---

例如，不纯函数对其自身范围外的变量产生副作用：

var count = 0;

function increaseCount(val) {
    count += val;
}

或一个函数，该函数为同一输入返回不同的值，因为它计算的变量不是作为参数给定的：

var count = 0;

function getSomething() {
    return count > 0;
}

不纯functon是一个返回不同结果的函数 相同的输入参数，也就是说它取决于某个状态

函数，该函数可以为相同的输入参数返回相同的结果，但 该会变异其他状态对象。它不依赖但其他对象依赖的对象//会导致副作用

例如：

1）

Math.random（）

是一个不纯函数；它更改

Math

对象的内部状态，以便在连续调用时获得不同的值

console.log（）

和

alert（）

是不纯净的函数，因为它们有副作用（尽管它们生成相同的行为，并且总是为相同的调用返回相同的值）

任何改变其参数内部状态或某些外部变量值的函数都是不纯函数。这包括调用方法更改闭包本身内部状态的闭包：

let nextInt = (function() {
    var i = 0;
    return function() {
        return i++;
    };
})();

let a = nextInt(); // sets a to 0
let b = nextInt(); // sets b to 1
                   // etc.

---

你从哪里知道不纯函数总是被认为是一件坏事？

一个纯函数不依赖于，也不会修改超出其范围的变量状态

具体地说，这意味着纯函数在给定相同参数的情况下总是返回相同的结果。它的执行不依赖于系统的状态

var values = { a: 1 };

function impureFunction ( items ) {
  var b = 1;

  items.a = items.a * b + 2;

  return items.a;
}

var c = impureFunction( values );
// Now `values.a` is 3, the impure function modifies it.

这里我们修改给定对象的属性。因此，我们修改了超出我们功能范围的对象：功能是不纯净的

var values = { a: 1 };

function pureFunction ( a ) {
  var b = 1;

  a = a * b + 2;

  return a;
}

var c = pureFunction( values.a );

我们只需修改函数范围内的参数，外部不做任何修改

var values = { a: 1 };
var b = 1;

function impureFunction ( a ) {
  a = a * b + 2;

  return a;
}

var c = impureFunction( values.a );
// Actually, the value of `c` will depend on the value of `b`.
// In a bigger codebase, you may forget about that, which may 
// surprise you because the result can vary implicitly.

这里，b不在函数的范围内。结果将取决于上下文：期待惊喜

var values = { a: 1 };
var b = 1;

function pureFunction ( a, c ) {
  a = a * c + 2;

  return a;
}

var c = pureFunction( values.a, b );
// Here it's made clear that the value of `c` will depend on
// the value of `b`.

---

参考资料：

我喜欢这个例子，因为这是我目前最大的陷阱。我完全支持类似API的JavaScript调用（保持函数的纯净），但是，我也支持在使用JavaScript时考虑OOP，其中可能包括不纯净的函数，如MyStringClass.length（）。纯函数背后的思想是不使用OOP。如果你想建立一个保存状态的“类”，你将永远拥有不纯函数。但只要它们都是同一个“类”的一部分，这就是您必须为OOP进行的权衡。

console.log（）

怎么会是不纯函数？你能告诉我一些想法吗？@Sourav-我解释了原因：每次调用

console.log（）

都有副作用（特别是它写入控制台的输出）。根据定义，任何生成输出的函数调用都是不纯函数。（例如，请参阅）我应该说，命名法建议应避免使用不纯函数，尽管我现在意识到情况并非总是如此

var values = { a: 1 };

function pureFunction ( a ) {
  var b = 1;

  a = a * b + 2;

  return a;
}

var c = pureFunction( values.a );

var values = { a: 1 };
var b = 1;

function impureFunction ( a ) {
  a = a * b + 2;

  return a;
}

var c = impureFunction( values.a );
// Actually, the value of `c` will depend on the value of `b`.
// In a bigger codebase, you may forget about that, which may 
// surprise you because the result can vary implicitly.

var values = { a: 1 };
var b = 1;

function pureFunction ( a, c ) {
  a = a * c + 2;

  return a;
}

var c = pureFunction( values.a, b );
// Here it's made clear that the value of `c` will depend on
// the value of `b`.