javascript - es6解构 - es7




可以(a== 1 && a== 2 && a== 3)评估为真吗? (18)

JavaScript的

a == a +1

在JavaScript中,没有 integers ,只有 Number s,它们被实现为双精度浮点数。

这意味着如果数字 a 足够大,则可以认为它等于三个连续的整数:

a = 100000000000000000
if (a == a+1 && a == a+2 && a == a+3){
  console.log("Precision loss!");
}

没错,这不是采访者所要求的(它不适 a=0 ),但它不涉及隐藏函数或运算符重载的任何技巧。

其他语言

作为参考,Ruby和Python中有 a==1 && a==2 && a==3 解决方案。 稍作修改,它也可以在Java中使用。

红宝石

使用自定义 ==

class A
  def ==(o)
    true
  end
end

a = A.new

if a == 1 && a == 2 && a == 3
  puts "Don't do this!"
end

或增加 a

def a
  @a ||= 0
  @a += 1
end

if a == 1 && a == 2 && a == 3
  puts "Don't do this!"
end

蟒蛇

class A:
    def __eq__(self, who_cares):
        return True
a = A()

if a == 1 and a == 2 and a == 3:
    print("Don't do that!")

Java的

可以修改Java Integer 缓存

package stackoverflow;

import java.lang.reflect.Field;

public class IntegerMess
{
    public static void main(String[] args) throws Exception {
        Field valueField = Integer.class.getDeclaredField("value");
        valueField.setAccessible(true);
        valueField.setInt(1, valueField.getInt(42));
        valueField.setInt(2, valueField.getInt(42));
        valueField.setInt(3, valueField.getInt(42));
        valueField.setAccessible(false);

        Integer a = 42;

        if (a.equals(1) && a.equals(2) && a.equals(3)) {
            System.out.println("Bad idea.");
        }
    }
}

主持人注意: 请拒绝编辑代码或删除此通知的冲动。 空白模式可能是问题的一部分,因此不应该被不必要地篡改。 如果你在“空白是微不足道的”阵营,你应该能够接受原样。

是否有可能 (a== 1 && a ==2 && a==3) 可以在JavaScript中评估为 true

这是一家大型科技公司提出的面试问题。 它发生在两周前,但我仍在努力寻找答案。 我知道我们从来没有在日常工作中写过这样的代码,但我很好奇。


对的,这是可能的! 😎

»JavaScript

if‌=()=>!0;
var a = 9;

if‌(a==1 && a== 2 && a==3)
{
    document.write("<h1>Yes, it is possible!😎</h1>")
}

上面的代码是一个简短的版本(感谢@Forivin在注释中的注释),以下代码是原始的:

var a = 9;

if‌(a==1 && a== 2 && a==3)
{
    //console.log("Yes, it is possible!😎")
    document.write("<h1>Yes, it is possible!😎</h1>")
}

//--------------------------------------------

function if‌(){return true;}

如果你只看到我的代码的顶部并运行它你说WOW,怎么样?

所以我认为这就足够了 ,是的 ,有人 可能 会对你说: 没有什么是不可能的

诀窍:我之后使用了一个隐藏的字符来创建一个与其名称相似的函数 if 。 在JavaScript中,我们无法覆盖关键字,因此我不得不使用这种方式。 这是假的,但在这种情况下它适用于你!

» C#

我还写了一个C#版本( 增加属性值技术 ):

static int _a;
public static int a => ++_a;

public static void Main()
{
    if(a==1 && a==2 && a==3)
    {
        Console.WriteLine("Yes, it is possible!😎");
    }
}

现场演示


使用符号的ECMAScript 6答案:

const a = {value: 1};
a[Symbol.toPrimitive] = function() { return this.value++ };
console.log((a == 1 && a == 2 && a == 3));

由于 == 使用,JavaScript是应该强迫 a 到了接近第二个操作数( 123 在这种情况下)。 但是在JavaScript尝试自己进行强制攻击之前,它会尝试调用 Symbol.toPrimitive 。 如果您提供 Symbol.toPrimitive JavaScript,则使用函数返回的值。 如果没有,JavaScript会调用 valueOf


好吧,另一个黑客与发电机:

const value = function* () {
  let i = 0;
  while(true) yield ++i;
}();

Object.defineProperty(this, 'a', {
  get() {
    return value.next().value;
  }
});

if (a === 1 && a === 2 && a === 3) {
  console.log('yo!');
}


实际上,问题的第一部分的答案在每种编程语言中都是“是”。 例如,这是在C / C ++的情况下:

#define a   (b++)
int b = 1;
if (a ==1 && a== 2 && a==3) {
    std::cout << "Yes, it's possible!" << std::endl;
} else {
    std::cout << "it's impossible!" << std::endl;
}

我认为这是实现它的最小代码:

i=0,a={valueOf:()=>++i}

if (a == 1 && a == 2 && a == 3) {
  console.log('Mind === Blown');
}

使用自定义创建虚拟对象,该自定义 在每次调用时 valueOf 递增全局变量 i 。 23个字符!


这个使用了defineProperty,它有一个很好的副作用导致全局变量!

var _a = 1

Object.defineProperty(this, "a", {
  "get": () => {
    return _a++;
  },
  configurable: true
});

console.log(a)
console.log(a)
console.log(a)


这是另一种变体,使用数组弹出你想要的任何值。

const a = {
  n: [3,2,1],
  toString: function () {
    return a.n.pop();
  }
}

if(a == 1 && a == 2 && a == 3) {
  console.log('Yes');
}


但老实说,是否有办法让它评估为真或不(正如其他人所表明的那样,有多种方式),我要寻找的答案,作为进行了数百次访谈的人,将会是类似的东西:

“好吧,也许是在一些奇怪的情况下,对我来说并不是很明显......但如果我在实际代码中遇到这个问题,那么我会使用常见的调试技术来弄清楚它是如何以及为什么要做它正在做的事情然后立即重构代码以避免这种情况...但更重要的是:我绝对不会首先编写该代码,因为这是复杂代码的定义,我努力永远不会编写复杂的代码“。

我猜一些采访者会冒犯一个显然意味着一个非常棘手的问题,但我不介意有意见的开发人员,特别是当他们能够用合理的思想支持它并且可以将我的问题与我的问题相吻合时关于自己的有意义的陈述。


使用一系列自覆盖吸气剂也可以实现这一点:

(这类似于jontro的解决方案,但不需要计数器变量。)

(() => {
    "use strict";
    Object.defineProperty(this, "a", {
        "get": () => {
            Object.defineProperty(this, "a", {
                "get": () => {
                    Object.defineProperty(this, "a", {
                        "get": () => {
                            return 3;
                        }
                    });
                    return 2;
                },
                configurable: true
            });
            return 1;
        },
        configurable: true
    });
    if (a == 1 && a == 2 && a == 3) {
        document.body.append("Yes, it’s possible.");
    }
})();


如果您利用 == 如何工作 ,您可以简单地创建一个具有自定义 toString (或 valueOf )函数的对象,该函数会在每次使用时更改它返回的内容,以使其满足所有三个条件。

const a = {
  i: 1,
  toString: function () {
    return a.i++;
  }
}

if(a == 1 && a == 2 && a == 3) {
  console.log('Hello World!');
}

这种方法的原因是由于使用了松散的等式运算符。 当使用松散相等时,如果其中一个操作数与另一个操作数的类型不同,则引擎将尝试将一个操作数转换为另一个操作数。 如果左边的对象和右边的数字,它将尝试通过首先调用 valueOf 将对象转换为数字(如果它是可调用的),如果失败,它将调用 toString 。 我在这种情况下习惯使用 toString 只是因为它是我想到的, valueOf 会更有意义。 如果我从 toString 返回一个字符串,那么引擎会尝试将字符串转换为给出相同最终结果的数字,但路径稍长。


如果没有正则表达式就无法做任何事情:

var a = {
  r: /\d/g, 
  valueOf: function(){
    return this.r.exec(123)[0]
  }
}

if (a == 1 && a == 2 && a == 3) {
    console.log("!")
}

它的工作原理是当Object与原语(如Number)比较时调用的自定义 valueOf 方法。 主要技巧是 a.valueOf 返回新值,因为它使用 g 标志在正则表达式上调用 exec ,这导致每次找到匹配时更新该正则表达式的 lastIndex 。 所以第一次 this.r.lastIndex == 0 ,它匹配 1 并更新 lastIndexthis.r.lastIndex == 1 ,所以下次regex将匹配 2 ,依此类推。


它可以在全局范围内使用以下内容完成。 对于 nodejs ,在下面的代码中使用 global 而不是 window

var val = 0;
Object.defineProperty(window, 'a', {
  get: function() {
    return ++val;
  }
});
if (a == 1 && a == 2 && a == 3) {
  console.log('yay');
}

此答案通过定义用于检索变量的getter来滥用执行上下文中的全局作用域提供的隐式变量。


我无法抗拒 - 其他答案无疑是正确的,但你真的无法超越以下代码:

var a = 1;
var a = 2;
var a = 3;
if(aᅠ==1 && a== 2 &&ᅠa==3) {
    console.log("Why hello there!")
}

请注意 if 语句中的奇怪间距(我从您的问题中复制)。 它是半角度Hangul(对于那些不熟悉的人来说是朝鲜语),它是一个Unicode空格字符,ECMA脚本不将其解释为空格字符 - 这意味着它是标识符的有效字符。 因此,有三个完全不同的变量,一个是在a之后的韩文,一个是之前的,另一个只是一个。 为了便于阅读,用 _ 替换空格,相同的代码如下所示:

var a_ = 1;
var a = 2;
var _a = 3;
if(a_==1 && a== 2 &&_a==3) {
    console.log("Why hello there!")
}

查看 Mathias的变量名称验证器上的验证 。 如果这个奇怪的间距实际上包含在他们的问题中,我确信这是这种答案的暗示。

不要这样做。 认真。

编辑:我注意到(尽管不允许启动变量) 零变宽连接器 零宽度非连接 字符也允许在变量名中 - 请参阅 使用零宽度字符混淆JavaScript - 优点和缺点?

这将如下所示:

var a= 1;
var a‍= 2; //one zero-width character
var a‍‍= 3; //two zero-width characters (or you can use the other one)
if(a==1&&a‍==2&&a‍‍==3) {
    console.log("Why hello there!")
}


或者,您可以使用它的类和检查的实例。

function A() {
    var value = 0;
    this.valueOf = function () { return ++value; };
}

var a = new A;

if (a == 1 && a == 2 && a == 3) {
    console.log('bingo!');
}

编辑

使用ES6类它看起来像这样

class A {
  constructor() {
    this.value = 0;
    this.valueOf();
  }
  valueOf() {
    return this.value++;
  };
}

let a = new A;

if (a == 1 && a == 2 && a == 3) {
  console.log('bingo!');
}


有可能的!

var i = 0;

with({
  get a() {
    return ++i;
  }
}) {
  if (a == 1 && a == 2 && a == 3)
    console.log("wohoo");
}

这使用 with 语句中的getter来评估三个不同的值。

...这仍然不意味着应该在实际代码中使用...

更糟糕的是,这个技巧也可以使用 ===

  var i = 0;

  with({
    get a() {
      return ++i;
    }
  }) {
    if (a !== a)
      console.log("yep, this is printed.");
  }


规则第一的访谈; 从不说不可能。

不需要隐藏的角色欺骗。

window.__defineGetter__( 'a', function(){
    if( typeof i !== 'number' ){
        // define i in the global namespace so that it's not lost after this function runs
        i = 0;
    }
    return ++i;
});

if( a == 1 && a == 2 && a == 3 ){
    alert( 'Oh dear, what have we done?' );
}


这是 @ Jeff的答案 *的反转版本,其中隐藏字符(U + 115F,U + 1160或U + 3164)用于创建看起来像 23 变量。

var  a = 1;
var 1 = a;
var 2 = a;
var 3 = a;
console.log( a ==ᅠ1 && a ==ᅠ2 && a ==ᅠ3 );

*通过使用零宽度非连接器(U + 200C)和零宽度连接器(U + 200D)可以简化答案。 这两个字符都允许在标识符内,但不允许在开头:

var a = 1;
var a = 2;
var a = 3;
console.log(a == 1 && a == 2 && a == 3);

/****
var a = 1;
var a\u200c = 2;
var a\u200d = 3;
console.log(a == 1 && a\u200c == 2 && a\u200d == 3);
****/

其他技巧可以使用相同的想法,例如通过使用Unicode变体选择器来创建看起来完全相同的变量( a︀ = 1; a︁ = 2; a︀ == 1 && a︁ == 2; // true )。





ecmascript-6