JavaScript 中刁钻的代码

写javascript反混淆的项目中，遇到过许多刁钻的代码。现将他们以题目的方式整理出来。可能会有人认为这个题目没有什么意义。实际编程中也不太会用到。现实中确实是这样的。不过这些特性可以很好的利用在代码的混淆中。比如代码

let boolValue = true

这个时候代码就可以混淆为

let boolValue = !""

或者

let boolValue = ![]

再者

 let boolValue= 1< parseInt(0.0000005)

话不多说，放码出来。请写出下面题目的结果。

```
true + false
```
结果为：1
解析：布尔值进行数学运算的时候，会先转换为数字，然后进行求值。
参考链接：https://262.ecma-international.org/5.1/#sec-11.6
```
[,,,].length
```
结果：3
解析：JavaScript allows trailing commas wherever a comma-separated list of values is accepted and more values may be expected after the last item. This includes: Array literals,Object literals,Parameter definitions, Function calls,Named imports, Named exports, Array and object destructuring
参考链接： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Trailing_commas
```
[1, 2, 3] + [4, 5, 6]
```
结果：1,2,34,5,6”
解析：这是数组拼接的题目。可以看做是 [1, 2, 3 ].toString() + [4, 5, 6].toString()
```
0.2 + 0.1 === 0.3
```
结果：false
解析：javascript 中 0.1 + 0.2 = 0.30000000000000004 ,这是一个JavaScript 的知名笑话。再计算 0.30000000000000004 === 0.3
参考链接：https://0.30000000000000004.com/
```
let x = 1;
x = (x++, x);
console.log(x);
```
结果：2
解析：一个或者多个表达式中，最后一个表达式的值会作为返回值。
参考链接：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator
```
!!""
```
结果：false
解析：false, 0, -0, 0n, “”, null, undefined, 和 NaN 都被认为是fale,”!!”被称为double not,在任何值之前添加两个感叹号可获取其对应的布尔原语
参考链接：https://developer.mozilla.org/en-US/docs/Glossary/Falsy
```
+!![]
```
结果：1
解析：[] is truthy, but it’s also loosely equal to false. !![] 的结果是true , + 使其转换为数字，即1.
参考链接：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean#boolean_coercion
```
parseInt(0.0000005)
```
结果：5
解析：parseInt(string) ; parseInt(string, radix) 。如果参数不是字符串类型，那么这个时候会把参数转换为字符串，String(0.0000005); 会变为 “5e-7” 。parseInt(‘5e-7’); // => 5
参考链接：https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/parseInt
详细讲解parseInt：https://dmitripavlutin.com/parseint-mystery-javascript/
```
true == "true"
```
结果：false
解析：x ==y .如果x的类型是boolean.这个时候会将x转换为数字。如果y的类型也是boolean同样执行toNumber操作。结果既 1 == NaN.
参考链接：https://262.ecma-international.org/11.0/#sec-abstract-equality-comparison
```
010 - 03
```
结果：5
解析：010 是八进制，转换为十进制是8 ，03转换为十进制 3，故结果是5
```
"" - - ""
//减号
```
结果： 0
解析：根据上面的题目我们知道Number(“”) = 0 ， 0 - (-0) ，结果是0. 需要注意的是两个减号中间是有空格的。如没有空格会报SyntaxError
```
+null === +false
```
结果：true
解析：+null 会转换为数字0，+false同样会转换为0,0 === 0 。所以结果是true
```
0/0
```
结果： NaN
解析：isNaN(0/0) 结果是true
```
1/0 > 10 ** 1000
```
结果是：false
解析：1/0 结果是Infinity 10 ×× 1000;也就是Math.pow(10, 1000) 结果是Infinity 那么Infinity > Infinity; // -> false
```
true++
```
结果：SyntaxError
解析：
- true++; // -> SyntaxError
- 1++; // -> SyntaxError
- “x”++; // -> SyntaxError
- null++; // -> SyntaxError
- undefined++; // -> NaN
- $++; // -> NaN
- console.log++; // -> NaN
- NaN++; // -> NaN
```
(null - 0) + "0"
```
结果：00
解析：根据https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Trailing_commas中的列表，可以清晰的知道(0 - 0) + “0” = 0 + “0” ，最后即字符串拼接。
```
true + ("true" - 0)
```
结果： NaN
解析: number(“true”) 为NaN .所以整个表达式是NaN
```
!5 + !5
```
结果：0
解析：!5,即false， false + false ,转换为数字运算，0 + 0
```
[] + []
[] + {}
{} + []
{} + {}
```
结果：
- //空字符串
- [object Object]
- 0
- [object Object][object Object]
  解析：这是一个让我疯掉的题目。如果有人能清楚的解释运算的逻辑，以及转化的规则，我一定会认为他是JavaScript大神。我同时也在想，如果这个题目出现在面试题中，会怎么样。
```
1 + 2 + "3"
```
结果： 33
解析：根据上面的讲解，这题是非常简单的了。
```
typeof NaN
```
结果： number
解析：根据https://262.ecma-international.org/5.1/#sec-4.3.23中说：NaN number value that is a IEEE 754 “Not-a-Number” value. 并且 Object.is(NaN, NaN) 结果是true.
```
undefined + false
```
结果： NaN
解析：Number(undefined) 为NaN,所以整体表达式也是NaN
```
"" && -0
```
结果：“”
解析：逻辑与运算。expr1 && expr2 ，expr1如果为真，返回expr1,否则返回expr2.
```
+!!NaN * "" - - [,]
```
结果：0
解析：+!!NaN 结果为 0；+”” 结果为 0 ；-[,]结果也是 -0。所以整体表达式是0.

参考链接：

检索关键字：

jsfuck
javascript 尴尬运算
javascript 诡异运算