blocks|key|2635269|text|不，不是的。给定相同的输入，此函数将返回不同的值。然后你就不能建立一个映射输入和输出的‘表’。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2635270|来自Pure+function的维基百科文章：|offset|length|2635271|2635272|在给定相同的参数值的情况下，函数总是计算相同的结果值。函数结果值不能依赖于在程序执行过程中或在程序的不同执行之间可能改变的任何隐藏信息或状态，也不能依赖于来自I/O设备的任何外部输入|blockquote|2635273|2635274|2635275|此外，另一件事是纯函数可以替换为表示来自输入和输出的映射的表，如this+thread中所述。|2635276|如果您想重写此函数并将其更改为纯函数，则还应将随机值作为参数进行传递|2635277|function+test(random,+min,+max)+{
+++return+random+*+(max+-+min)+%2B+min;
}|code-block|syntax|javascript|2635278|然后这样调用它(例如，使用2和5作为min和max)：|2635279|test(+Math.random(),+2,+5)|2635280|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Pure_function|1|https://stackoverflow.com/questions/13766448/replacing-functions-with-table-lookups^0|0|2|D|0|0|0|0|0|0|W|B|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|F|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|1E|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1H|8|@]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|N|3|O|5|6|7|1L|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1M|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1N|8|@]|9|@]|A|$]]|$1|W|3|X|5|R|7|1O|8|@]|9|@]|A|$S|T]]|$1|Y|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

No, it's not. Given the same input, this function will return different values. And then you can't build a 'table' that maps the input and the outputs.

From the Wikipedia article for <a href="https://en.wikipedia.org/wiki/Pure_function" rel="noreferrer">Pure function</a>: 

<blockquote>
 The function always evaluates the same result value given the same
 argument value(s). The function result value cannot depend on any
 hidden information or state that may change while program execution
 proceeds or between different executions of the program, nor can it
 depend on any external input from I/O devices
</blockquote>

Also, another thing is that a pure function can be replaced with a table which represents the mapping from the input and output, as explained in <a href="https://stackoverflow.com/questions/13766448/replacing-functions-with-table-lookups">this thread</a>.

If you want to rewrite this function and change it to a pure function, you should pass the random value as an argument too

<pre><code>function test(random, min, max) {
 return random * (max - min) + min;
}
</code></pre>

and then call it this way (example, with 2 and 5 as min and max):

<pre><code>test( Math.random(), 2, 5)
</code></pre>

blocks|key|102535|text|纯函数是指返回值仅由输入值决定的函数，没有明显的副作用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102536|通过使用Math.random，您可以通过输入值以外的其他值来确定它的值。它不是一个纯函数。|102537|source|offset|length|102538|entityMap|0|LINK|mutability|MUTABLE|url|https://www.sitepoint.com/functional-programming-pure-functions/^0|0|0|0|6|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

A pure function is a function where the return value is only determined by its input values, without observable side effects

By using Math.random, you are determining its value by something other than input values. It's not a pure function.

<a href="https://www.sitepoint.com/functional-programming-pure-functions/" rel="noreferrer">source</a>

blocks|key|102494|text|对于相同的输入，纯函数总是返回相同的值。纯函数是可预测的，并且是引用透明的，这意味着我们可以用返回的输出替换函数调用，并且它不会改变程序的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102495|https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch3.md|offset|length|102496|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|22|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Pure functions always return the same value for same input.
Pure functions are predictable and are referential transparent which means that we can replace the function call with the output returned and it will not change the working of the program.

<a href="https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch3.md" rel="nofollow noreferrer">https://github.com/MostlyAdequate/mostly-adequate-guide/blob/master/ch3.md</a>

blocks|key|2635317|text|不，它不是。你根本不能计算出结果，所以这段代码不能测试。要使该代码可测试，您需要提取生成随机数的组件：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2635318|function+test(min,+max,+generator)+{
++return++generator()+*+(max+-+min)+%2B+min;
}|code-block|syntax|javascript|2635319|现在，您可以模拟生成器并正确测试代码：|2635320|const+result+=+test(1,+2,+()+=>+3);
result+==+4+//always+true|2635321|在你的“生产”代码中：|2635322|const+result+=+test(1,+2,+Math.random);|2635323|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

No, it isn't. You can't figure out the result at all, so this piece of code can't be tested. To make that code testable, you need to extract the component that generates the random number: 

<pre><code>function test(min, max, generator) {
 return generator() * (max - min) + min;
}
</code></pre>

Now, you can mock the generator and test your code properly:

<pre><code>const result = test(1, 2, () =&gt; 3);
result == 4 //always true
</code></pre>

And in your "production" code:

<pre><code>const result = test(1, 2, Math.random);
</code></pre>

blocks|key|102556|text|不，它不是纯函数，因为它的输出不只依赖于提供的输入(Math.random()可以输出任何值)，而纯函数应该始终为相同的输入输出相同的值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|102557|如果一个函数是纯函数，那么可以安全地优化具有相同输入的多个调用，只重用先前调用的结果。|102558|附注:至少对我和其他许多人来说，redux让术语纯函数流行起来。Straight+from+the+redux+docs|offset|length|style|BOLD|102559|102560|你永远不应该在一个减速机中做的事情：|blockquote|102561|102562|102563|102564|改变了其arguments;|unordered-list-item|102565|Perform副作用，如Date.now()或Math.random().|102566|等API调用和路由非纯函数。|102567|entityMap|0|LINK|mutability|MUTABLE|url|http://redux.js.org/docs/basics/Reducers.html#handling-actions^0|0|0|O|3|W|S|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@$F|18|G|19|H|I]]|9|@$F|1A|G|1B|1|1C]]|A|$]]|$1|J|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|1E|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1I|8|@]|9|@]|A|$]]|$1|T|3|U|5|S|7|1J|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1K|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|Y|$Z|$5|10|11|12|A|$13|14]]]]

No, it isn't a pure function because its output doesn't depend only on the input provided (Math.random() can output any value), while pure functions should always output the same value for same inputs.

If a function is pure, it's safe to optimize away multiple calls with the same inputs and just reuse the result of an earlier call.

P.S for me at least and for many others, redux made the term pure function popular. <a href="http://redux.js.org/docs/basics/Reducers.html#handling-actions" rel="noreferrer">Straight from the redux docs</a>:

<blockquote>
 Things you should never do inside a reducer:
 
 <ul>
 <li>Mutate its arguments;</li>
 <li>Perform side effects like API calls and routing transitions;</li>
 <li>Call non-pure functions, e.g. Date.now() or Math.random().</li>
 </ul>
</blockquote>

blocks|key|99595|text|对你的问题的简单回答是Math.random()+违反了规则2。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|99596|这里的许多其他答案都指出，Math.random()的存在意味着该函数不是纯函数。但我认为值得一提的是，为什么Math.random()会影响使用它的函数。|99597|与所有伪随机数生成器一样，Math.random()从一个“种子”值开始。然后，它将该值用作一系列低级位操作或其他操作的起点，这些操作会导致不可预测(但不是真正随机)的输出。|99598|在JavaScript中，涉及的过程依赖于实现，并且与许多其他语言不同，JavaScript提供了no+way+to+select+the+seed|99599|99600|该实现选择随机数生成算法的初始种子；它不能由用户选择或重置。|blockquote|99601|99602|99603|这就是为什么这个函数不是纯函数的原因:+JavaScript本质上使用了一个您无法控制的隐式函数参数。它从其他地方计算和存储的数据中读取参数，因此违反了您定义中的规则#2。|99604|如果你想使它成为一个纯函数，你可以使用here描述的替代随机数生成器之一。将该生成器称为seedable_random。它接受一个参数(种子)并返回一个“随机”数。当然，这个数字根本不是随机的；它是由种子唯一确定的。这就是为什么这是一个纯函数。seedable_random的输出只是“随机”的，因为根据输入预测输出是困难的。|99605|这个函数的纯版本需要接受三个参数：|99606|function+test(min,+max,+seed)+{
+++return++seedable_random(seed)+*+(max+-+min)+%2B+min;
}|code-block|syntax|javascript|99607|对于任何给定的(min,+max,+seed)参数三元组，这将始终返回相同的结果。|99608|注意，如果您希望seedable_random的输出是真正随机的，则需要找到一种将种子随机化的方法！无论您使用哪种策略，都将不可避免地是非纯的，因为它将要求您从函数之外的源收集信息。正如mtraceur和jpmc26提醒我的那样，这包括所有物理方法：hardware+random+number+generators、webcams+with+lens+caps、atmospheric+noise+collectors+--甚至lava+lamps。所有这些都涉及到使用在函数外部计算和存储的数据。|99609|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random|1|https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript|2|https://stackoverflow.com/questions/47035166/is-a-function-that-calls-math-random-pure/47037297?noredirect=1#comment81070224_47037297|3|https://stackoverflow.com/questions/47035166/is-a-function-that-calls-math-random-pure/47037297?noredirect=1#comment81075739_47037297|4|https://en.wikipedia.org/wiki/Hardware_random_number_generator|5|https://crypto.stackexchange.com/questions/5542/webcam-random-number-generator|6|https://www.random.org/|7|https://en.wikipedia.org/wiki/Lavarand^0|B|D|P|7|B|D|0|D|D|1J|D|0|D|D|0|1D|P|0|0|0|0|0|0|0|18|F|3E|F|J|4|1|0|0|0|7|G|0|8|F|2L|8|2|2U|6|3|3H|X|4|4F|M|5|52|S|6|5Z|A|7|0^^$0|@$1|2|3|4|5|6|7|1T|8|@$9|1U|A|1V|B|C]|$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|20|8|@$9|21|A|22|B|D]|$9|23|A|24|B|D]]|E|@]|F|$]]|$1|I|3|J|5|6|7|25|8|@$9|26|A|27|B|D]]|E|@]|F|$]]|$1|K|3|L|5|6|7|28|8|@]|E|@$9|29|A|2A|1|2B]]|F|$]]|$1|M|3|-4|5|6|7|2C|8|@]|E|@]|F|$]]|$1|N|3|O|5|P|7|2D|8|@]|E|@]|F|$]]|$1|Q|3|-4|5|6|7|2E|8|@]|E|@]|F|$]]|$1|R|3|-4|5|6|7|2F|8|@]|E|@]|F|$]]|$1|S|3|T|5|6|7|2G|8|@]|E|@]|F|$]]|$1|U|3|V|5|6|7|2H|8|@$9|2I|A|2J|B|D]|$9|2K|A|2L|B|D]]|E|@$9|2M|A|2N|1|2O]]|F|$]]|$1|W|3|X|5|6|7|2P|8|@]|E|@]|F|$]]|$1|Y|3|Z|5|10|7|2Q|8|@]|E|@]|F|$11|12]]|$1|13|3|14|5|6|7|2R|8|@$9|2S|A|2T|B|D]]|E|@]|F|$]]|$1|15|3|16|5|6|7|2U|8|@$9|2V|A|2W|B|D]]|E|@$9|2X|A|2Y|1|2Z]|$9|30|A|31|1|32]|$9|33|A|34|1|35]|$9|36|A|37|1|38]|$9|39|A|3A|1|3B]|$9|3C|A|3D|1|3E]]|F|$]]|$1|17|3|-4|5|6|7|3F|8|@]|E|@]|F|$]]]|18|$19|$5|1A|1B|1C|F|$1D|1E]]|1F|$5|1A|1B|1C|F|$1D|1G]]|1H|$5|1A|1B|1C|F|$1D|1I]]|1J|$5|1A|1B|1C|F|$1D|1K]]|1L|$5|1A|1B|1C|F|$1D|1M]]|1N|$5|1A|1B|1C|F|$1D|1O]]|1P|$5|1A|1B|1C|F|$1D|1Q]]|1R|$5|1A|1B|1C|F|$1D|1S]]]]

The simple answer to your question is that <code>Math.random()</code> violates rule #2. 

Many other answers here have pointed out that the presence of <code>Math.random()</code> means that this function is not pure. But I think it's worth saying why <code>Math.random()</code> taints functions that use it. 

Like all pseudorandom number generators, <code>Math.random()</code> starts with a "seed" value. It then uses that value as the starting point for a chain of low-level bit manipulations or other operations that result in an unpredictable (but not really random) output.

In JavaScript, the process involved is implementation-dependent, and unlike many other languages, JavaScript provides <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random" rel="noreferrer">no way to select the seed</a>:

<blockquote>
 The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.
</blockquote>

That's why this function isn't pure: JavaScript is essentially using an implicit function parameter that you have no control over. It's reading that parameter from data calculated and stored elsewhere, and therefore violates rule #2 in your definition.

If you wanted to make this a pure function, you could use one of the alternative random number generators described <a href="https://stackoverflow.com/questions/521295/seeding-the-random-number-generator-in-javascript">here</a>. Call that generator <code>seedable_random</code>. It takes one parameter (the seed) and returns a "random" number. Of course, this number isn't really random at all; it is uniquely determined by the seed. That's why this is a pure function. The output of <code>seedable_random</code> is only "random" in the sense that predicting the output based on the input is difficult.

The pure version of this function would need to take three parameters:

<pre><code>function test(min, max, seed) {
 return seedable_random(seed) * (max - min) + min;
}
</code></pre>

For any given triple of <code>(min, max, seed)</code> parameters, this will always return the same result. 

Note that if you wanted the output of <code>seedable_random</code> to be truly random, you'd need to find a way to randomize the seed! And whatever strategy you used would inevitably be non-pure, because it would require you to gather information from a source outside your function. As <a href="https://stackoverflow.com/questions/47035166/is-a-function-that-calls-math-random-pure/47037297?noredirect=1#comment81070224_47037297">mtraceur</a> and <a href="https://stackoverflow.com/questions/47035166/is-a-function-that-calls-math-random-pure/47037297?noredirect=1#comment81075739_47037297">jpmc26</a> remind me, this includes all physical approaches: <a href="https://en.wikipedia.org/wiki/Hardware_random_number_generator" rel="noreferrer">hardware random number generators</a>, <a href="https://crypto.stackexchange.com/questions/5542/webcam-random-number-generator">webcams with lens caps</a>, <a href="https://www.random.org/" rel="noreferrer">atmospheric noise collectors</a> -- even <a href="https://en.wikipedia.org/wiki/Lavarand" rel="noreferrer">lava lamps</a>. All of these involve using data calculated and stored outside the function.

blocks|key|102592|text|除了正确指出此函数的不确定性的其他答案之外，它还有一个副作用:它将导致将来对math.random()的调用返回不同的答案。没有该属性的随机数生成器通常会执行某种类型的I/O，例如从操作系统提供的随机设备读取数据。对于纯函数，这两个参数都是verboten。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|102593|entityMap^0|12|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

In addition to the other answers that correctly point out how this function is non-deterministic, it also has a side-effect: it will cause future calls to <code>math.random()</code> to return a different answer. And a random-number generator that doesn’t have that property will generally perform some kind of I/O, such as to read from a random device provided by the OS. Either is verboten for a pure function.

blocks|key|100198|text|从数学的角度来看，你的签名不是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|100199|test:+<number,+number>+->+<number>|code-block|syntax|javascript|100200|但|100201|test:+<environment,+number,+number>+->+<environment,+number>|100202|其中environment能够提供Math.random()的结果。实际上，生成随机值会改变环境，这是一个副作用，因此您还会返回一个新的环境，它不等于第一个环境！|offset|length|style|CODE|100203|换句话说，如果您需要任何类型的输入，而不是来自初始参数(+<number,+number>部分)，那么需要为您提供执行环境(在本例中，执行环境为Math提供状态)。这同样适用于其他答案中提到的其他事情，如I/O或诸如此类。|100204|100205|作为一个类比，你还可以注意到这就是面向对象编程的表示方式--如果我们说，例如。|100206|SomeClass+something
T+result+=+something.foo(x,+y)|100207|那么实际上我们使用的是|100208|foo:+<something:+SomeClass,+x:+Object,+y:+Object>+->+<SomeClass,+T>|100209|其中调用了其方法的对象是环境的一部分。为什么在result中使用SomeClass部分？因为something的状态也可能已经改变了！|100210|entityMap^0|0|0|0|0|2|B|H|D|0|T|G|20|4|0|0|0|0|0|0|W|9|1A|9|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|19|8|@$M|1A|N|1B|O|P]|$M|1C|N|1D|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1E|8|@$M|1F|N|1G|O|P]|$M|1H|N|1I|O|P]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1K|8|@]|9|@]|A|$]]|$1|V|3|W|5|D|7|1L|8|@]|9|@]|A|$E|F]]|$1|X|3|Y|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|1N|8|@]|9|@]|A|$E|F]]|$1|11|3|12|5|6|7|1O|8|@$M|1P|N|1Q|O|P]|$M|1R|N|1S|O|P]]|9|@]|A|$]]|$1|13|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|14|$]]

From mathematical point of view, your signature is not

<pre><code>test: &lt;number, number&gt; -&gt; &lt;number&gt;
</code></pre>

but

<pre><code>test: &lt;environment, number, number&gt; -&gt; &lt;environment, number&gt;
</code></pre>

where the <code>environment</code> is capable of providing results of <code>Math.random()</code>.
And actually generating the random value mutates the environment as a side effect, so you also return a new environment, which is not equal to the first one!

In other words, if you need any kind of input that does not come from initial arguments (the <code>&lt;number, number&gt;</code> part), then you need to be provided with execution environment (that in this example provides state for <code>Math</code>). The same applies to other things mentioned by other answers, like I/O or such.

<hr>

As an analogy, you can also notice this is how object-oriented programming can be represented - if we say, e.g.

<pre><code>SomeClass something
T result = something.foo(x, y)
</code></pre>

then actually we are using

<pre><code>foo: &lt;something: SomeClass, x: Object, y: Object&gt; -&gt; &lt;SomeClass, T&gt;
</code></pre>

with the object that has its method invoked being part of the environment. And why the <code>SomeClass</code> part of result? Because <code>something</code>'s state could have changed as well!

blocks|key|2635476|text|你对以下内容没意见：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2635477|return+(""+%2B+test(0,1))+%2B+test(0,1);|code-block|syntax|javascript|2635478|等同于|2635479|var+temp+=+test(0,+1);
return+(""+%2B+temp)+%2B+temp;|2635480|2635481|您可以看到，pure的定义是这样一种函数，它的输出不会随输入以外的任何东西而改变。如果我们说JavaScript有办法将一个函数标记为pure并利用它，优化器将被允许将第一个表达式重写为第二个表达式。|2635482|我对此有实际经验。SQL+server允许在“纯”函数中使用getdate()和newid()，优化器可以随意删除重复调用。有时这会做一些愚蠢的事情。|offset|length|style|CODE|2635483|entityMap^0|0|0|0|0|0|0|U|9|14|7|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|11|8|@$P|12|Q|13|R|S]|$P|14|Q|15|R|S]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|16|8|@]|9|@]|A|$]]]|U|$]]

Would you be fine with the following:

<pre><code>return ("" + test(0,1)) + test(0,1);
</code></pre>

be equivalent to

<pre><code>var temp = test(0, 1);
return ("" + temp) + temp;
</code></pre>

?

You see, the definition of pure is a function whose output does not change with anything other than its inputs. If we say that JavaScript had a way to tag a function pure and take advantage of this, the optimizer would be allowed to rewrite the first expression as the second.

I have practical experience with this. SQL server allowed <code>getdate()</code> and <code>newid()</code> in "pure" functions and the optimizer would dedupe calls at will. Sometimes this would do something dumb.

Is the following a pure function?

<pre><code>function test(min,max) {
 return Math.random() * (max - min) + min;
}
</code></pre>

My understanding is that a pure function follows these conditions:

<ol>
<li>It returns a value computed from the parameters</li>
<li>It doesn't do any work other than calculating the return value</li>
</ol>

If this definition is correct, is my function a pure function? Or is my understanding of what defines a pure function incorrect?

Is a function that calls Math.random() pure?

路由

下面的函数是纯函数吗？function test(min,max) {   return  Math.random() * (max - min) + min;}我的理解是，一个纯函数遵循以下条件：它返回一个从参数计算得到的值，除了计算返回值之外，它不做任何工作如果这个定义是正确的，那么我的函数是纯函数吗？或者我对定义...

问调用Math.random()的函数是纯函数吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问调用Math.random()的函数是纯函数吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问调用Math.random()的函数是纯函数吗？
EN