请问TT是什么啊,令人抓狂,出自我同事考我的一个变态题目

Question

呵呵,估计要用eval了没时间考虑,一下

Answer 1

有点意思我试过一个可以使errCount为1...

Answer 2

<script>
var tt = new Object();
tt.toString = function(){
// alert(tt.toString.caller)
return false;
}
var errCount = 0;
function assert(v) { 
if (!v) {
alert("assert error");
errCount++;
}
}assert((tt || true)   == false)
assert((tt || false)  == false)
assert((tt && true)   == true)
assert((tt && false)  == false)
assert((true || tt )  == true)
assert((tt || true )  == false)
assert((false || tt ) == false)
assert((tt || false ) == false)
assert((true && tt)   == false)
assert((tt && true )  == true)
assert((false && tt ) == false)
assert((tt && false ) == false)assert((tt ? true : false) == true)
assert((tt == false)       == true)
assert((!tt == tt  )       == true)
assert((tt + '')           == "false")
assert(tt                  == false)
alert(errCount)  //结果是打印 0</script>

Answer 3

<script>var tt=new Boolean();var errCount=0  //全局变量，用来记录 assert 函数出现断言宣告的次数/*
断言函数
如果v为假，该函数就 alert("assert error"),并累加计数器 errCount
如果v为真，就什么也不做
*/
function assert(v) { 
if (!v) {
alert("assert error");
errCount++;
}
}assert((tt || true)   == false) //无解
assert((tt || false)  == false) //tt != true
assert((tt && true)   == true) //tt =true
assert((tt && false)  == false) //tt = any
assert((true || tt )  == true) //tt = any
assert((tt || true )  == false) //无解
assert((false || tt ) == false) //tt=false
assert((tt || false ) == false) //tt=false
assert((true && tt)   == false) //tt=any
assert((tt && true )  == true)  //tt=true
assert((false && tt ) == false) //tt=any
assert((tt && false ) == false) //tt=any
assert((tt ? true : false) == true) //tt=true
assert((tt == false)       == true) //tt=false;
assert((!tt == tt  )       == true) //无解
assert((tt + '')           == "false") //tt=false
assert(tt                  == false) //tt=false
alert(errCount)  //结果是打印 0</script>
================================================试验了 null/false/NaN都不行
想想，除了一个空的Boolean没别的办法
于是…………搞定

Answer 4

<script>var tt=new Object(false);var errCount=0  //全局变量，用来记录 assert 函数出现断言宣告的次数/*
断言函数
如果v为假，该函数就 alert("assert error"),并累加计数器 errCount
如果v为真，就什么也不做
*/
function assert(v) { 
if (!v) {
alert("assert error");
errCount++;
}
}assert((tt || true)   == false) //无解
assert((tt || false)  == false) //tt != true
assert((tt && true)   == true) //tt =true
assert((tt && false)  == false) //tt = any
assert((true || tt )  == true) //tt = any
assert((tt || true )  == false) //无解
assert((false || tt ) == false) //tt=false
assert((tt || false ) == false) //tt=false
assert((true && tt)   == false) //tt=any
assert((tt && true )  == true)  //tt=true
assert((false && tt ) == false) //tt=any
assert((tt && false ) == false) //tt=any
assert((tt ? true : false) == true) //tt=true
assert((tt == false)       == true) //tt=false;
assert((!tt == tt  )       == true) //无解
assert((tt + '')           == "false") //tt=false
assert(tt                  == false) //tt=false
alert(errCount)  //结果是打印 0</script>
--------------------------------------------------------
我这个也可以做到

Answer 5

不过实在搞不懂为什么会这样
可能和运算符的优先级、自动类型转换、以及JScript的类型机制有关
有时间研究一下

Answer 6

天啦，这是什么东西，用!运算结果还能不变？我最少让errCount为6，看来差你们远了……
是什么让errCount为1的，发出来看看啊。

Answer 7

<script>var tt=' ';
var errCount=0  //全局变量，用来记录 assert 函数出现断言宣告的次数/*
断言函数
如果v为假，该函数就 alert("assert error"),并累加计数器 errCount
如果v为真，就什么也不做
*/
function assert(v) { 
if (!v) {
alert("assert error");
errCount++;
}
}assert((tt || true)   == false) //无解
assert((tt || false)  == false) //tt != true
assert((tt && true)   == true) //tt =true
assert((tt && false)  == false) //tt = any
assert((true || tt )  == true) //tt = any
assert((tt || true )  == false) //无解
assert((false || tt ) == false) //tt=false
assert((tt || false ) == false) //tt=false
assert((true && tt)   == false) //tt=any
assert((tt && true )  == true)  //tt=true
assert((false && tt ) == false) //tt=any
assert((tt && false ) == false) //tt=any
assert((tt ? true : false) == true) //tt=true
assert((tt == false)       == true) //tt=false;
assert((!tt == tt  )       == true) //无解
assert((tt + '')           == "false") //ft~这个地方不能通过。
assert(tt                  == false) //tt=false
alert(errCount)  //结果是打印 1</script>

Answer 8

呵呵,逻辑上满足条件的基本没有
我考虑hack手法
function assert(v) { 
if (true){}return true; {
alert("assert error");
errCount++;
} 
}
如果能适当构造tt,能把assert(v)函数在运行时动态的替换成上面这个就成了

Answer 9

其实答案都是试出来的.var tt=new Object(false);
var tt=new Boolean();
var tt=new Boolean(false);都可以但是很难讲出为什么会这样.

Answer 10

原因在于：
alert(new Boolean() || true);
alert(typeof new Boolean() || true);

Answer 11

呵呵，我也来个hack方法，这个也应该算是的吧，没有违规吧。
<script>var tt=(function () {
if (typeof(assert)=="function") {
window.assert = function () {
};
}
}
)();var errCount=0  //全局变量，用来记录 assert 函数出现断言宣告的次数/*
断言函数
如果v为假，该函数就 alert("assert error"),并累加计数器 errCount
如果v为真，就什么也不做
*/
function assert(v) { 
if (!v) {
alert("assert error");
errCount++;
}
}assert((tt || true)   == false)
assert((tt || false)  == false)
assert((tt && true)   == true)
assert((tt && false)  == false)
assert((true || tt )  == true)
assert((tt || true )  == false)
assert((false || tt ) == false)
assert((tt || false ) == false)
assert((true && tt)   == false)
assert((tt && true )  == true)        
assert((false && tt ) == false)
assert((tt && false ) == false)assert((tt ? true : false) == true)
assert((tt == false)       == true)
assert((!tt == tt  )       == true)
assert((tt + '')           == "false")
assert(tt                  == false)
alert(errCount)  //结果是打印 0</script>

Answer 12

问题变态回复也够绝另外一个 hack 版本
var tt=window["assert"]=new Function();

Answer 13

其实hack只需要将顶层的window下面的成员assert改成一个空function就行了，可以构造任意个，但原理是一样的。如果要搞清楚object转型时为什么会出现上面的情况，个人觉得，蛮麻烦。比如下面的，在Mozilla，和IE里运行，看看结果？<script>
foo = {
 'bar': function () {
 alert(this);
 },
 'toString': function () {
 return 'foo';
 }
};
(foo.bar || null)();
</script>

Answer 14

至于这段代码为什么会出现一个object(in IE), 一个foo(Mozilla Firefox)，与this和||有关。
详细参见：http://blog.never-online.net/article.asp?id=117js内部解释器是如何解释的，很难推测或者自己想办法用代码来判断。上面object转型和||的运用也是类似。

Answer 15

这个问题我想到我们以前经常判断有没有这个元素的方法
if(!document.getElementById("aaa"))
{
    alert("没有")
}
也就是说object算true,而现在的程序在看看，一个object和boolean的||就只有可能是object或者true,不可能有其他选择
大家可以看
alert("aaa"||true)
alert("bbbb"||false)
alert(true||"aaa")
alert(false||"bbbb")
也就是说第一个先判断如果为false，还要执行后面的，这就是说这里全部都是(!v)全部都是false
boolean的值默认是false
alert(new Boolean() || true);这句话的意思我感觉其实是false这个对象和true进行比较，而不是false这个value值，也就是说，这样我们再看看上面所有的操作assert((tt || true)   == false)    //第一个条件就成立，后面不执行，括号内为对象false（注意不是值），和false值相等true
assert((tt || false)  == false)    //同上
assert((tt && true)   == true)     //括号内为true，和true值相等true
assert((tt && false)  == false)    //括号内为false，和false值相等true
assert((true || tt )  == true)     //括号内为true，和true值相等true
assert((tt || true )  == false)     //第一个条件就成立，后面不执行，括号内为对象false（注意不是值），和false值相等true
assert((false || tt ) == false)     //第一个条件就成立，后面不执行，括号内为false值，和false值相等true
assert((tt || false ) == false)     //第一个条件就成立，后面不执行，括号内为对象false（注意不是值），和false值相等trueassert((true && tt)   == false)     //括号内为false，和false值相等true   ?????????
assert((tt && true )  == true)      //括号内为true，和true值相等true    ?????????
assert((false && tt ) == false)     //括号内为false，和false值相等true 
assert((tt && false ) == false)     //括号内为false，和false值相等true assert((tt ? true : false) == true)  //后面不写了，同理的
assert((tt == false)       == true)
assert((!tt == tt  )       == true)
assert((tt + '')           == "false")
assert(tt                  == false)但是现在我有个地方想不通
alert(new Boolean() && true);
alert(new Boolean() && false);
alert(true && new Boolean() );
alert(false && new Boolean() );
上面这四个为什么第一个和第三个不相同。

Answer 16

上面写的比较废话，：）主要就是Boolean的false被当成对象和其他的进行逻辑运算了，而不是boolean的false值。
至于后面的想不通的地方，好象只有最开始的第一个则被当成对象运算，其后的都是值来运算，搞不懂怎么设计的
比如也可以看alert(new Boolean() && true && new Boolean());这样就是false了

Answer 17

||是这样运算的：从第一个开始，遇到有意义的返回，否则返回最后一个表达式（注意不一定是Boolean值）；
&&是这样运算的：从第一个开始，遇到无意义的返回，否则返回最后一个表达式（注意同上）；
!是这样运算的：对表达式的值取非（注意不是对表达式）。什么是无意义呢：如下六个 0,null,undefined,"",false,NaN
除此，视为有意义。new Boolean(),new Boolean(false)是同一个东西，由于它是一个对象，故是有意义的，但其值为false，所以，可以看为“有意义的false”，这样，就可以解释所有的问题了。
new Object(false)，也是有意义的，其值也为false，只不过其类型为Object，而new Boolean()其类型为Boolean而已。
但在这里类型并不影响所涉及的运算。相信大家都应该明白了。===
注明一下：有意义无意义是我给的概念[不知是不是我以前看别人这么说，呵呵]，但是这样的解释是非常合理，而且易记的。
==
楼主结帖吧，版主加精最好。呵呵！

Answer 18

呵呵
<script language=javascript>
alert(new Boolean() && true && new Boolean());
alert(new Boolean() &&  new Boolean()&& true);
</script>

Answer 19

assert((tt || true)   == false)//出现了两次
assert((tt || false ) == false)//出现了两次
assert((tt && true )  == true)//出现了两次
assert((tt && false ) == false)//出现了两次
我觉得要点在这里：alert(typeof (tt||true))
alert(typeof (tt||false))
alert(typeof (true||tt))
alert(typeof (false||tt))
alert(typeof (tt && true))
alert(typeof (tt && false))
alert(typeof (true && tt))
alert(typeof (false && tt))

Answer 20

或者更明白一些：tt.toString=function(){return "test"}alert((tt||true).toString())//"test"
alert((tt||false).toString())//"test"
alert((true||tt).toString())//"true"
alert((false||tt).toString())//"test"
alert((tt && true).toString())//"true"
alert((tt && false).toString())//"false"
alert((true && tt).toString())//"test"
alert((false && tt).toString())//"false"

Answer 21

xxuu503(被扣信誉是种光荣)的这段经典，刚才我还想说逻辑符有的不会转型，却一时没想到用typeof...:p
。用||逻辑符是不会进行转型的，至少结果如此
alert("" || true)
alert(' ' || true)用其它的逻辑符就应该会转型。
alert("123"==123)

Answer 22

hbhbhbhbhb1021(天外水火(我要多努力)) ( ) 信誉：100    Blog  2006-10-9 11:01:01  得分: 0  
 
 
   
呵呵
<script language=javascript>
alert(new Boolean() && true && new Boolean());
alert(new Boolean() &&  new Boolean()&& true);
</script>  
 
我还以为结果应该是object true原来是false true哈哈

Answer 23

刚才一看。HB已经把贴子设顶了还加了一个变态题目:D

Answer 24

BlueDestiny(blog.never-online.net) ( ) 信誉：100    Blog  2006-10-09 12:28:00  得分: 0  
 
 
   xxuu503(被扣信誉是种光荣)的这段经典，刚才我还想说逻辑符有的不会转型，却一时没想到用typeof...:p
。用||逻辑符是不会进行转型的，至少结果如此
alert("" || true)
alert(' ' || true)用其它的逻辑符就应该会转型。
alert("123"==123)
  
 
……………………不是不转型，只不过是算法很古怪

Answer 25

请从这里向上搜索我的名，标准答案就在那里。再提醒一点：||与&&这两个运算符不是对值的运算，即在运算过程中不管表达式的值，而是对表达式本身进行运算；这两个运算符对表达式究竟如何运算？
答：只管表达式是否有意义，而不管其值几何。
对于表达式，无意义的只有6个（见我上次回复）；这里要注意：所有以new方式生成的对象为动态对象，动态对象均视为有意义--这一点上次回复忘加说明（-_-!）。再举例两个说明：
一、0||false||new Boolean(false)
运算如下：
首先：0是一个常数，刚好是无意义之一，故继续；而false也是无意义之一，故再继续；new Boolean(false)为动态对象，有意义，故上面运算结果为new Boolean(false)
二、0||new Boolean(false)||true
这会是什么结果？很多人不注意就会以为结果为true,但这是不对的。
先说答案：结果同上
首先：0是一个常数，刚好是无意义之一，故继续；new Boolean(false)为动态对象，有意义；这里已经找到有意义的表达式，故不再往下运算了。所以结果同上。
=====
对&&运算符，同理，不再多说。

Answer 26

var tt
这里tt值是undefined
undefined类型转到bool都是false
但
undefined==false 返回的是false哟

Answer 27

一帮人都是神经病????没看清楚楼主的问题吗???TT是什么???  TT就是taotao , 即ML时用的,书本上称避孕套....

Answer 28

拷到文件里试一下就知道了。<script>
var yn=new Boolean(false);
alert(yn)
alert(!yn)
alert("Fuck Begin");
alert( (yn||false) ) //false
alert( (yn||true) ) //false
alert( (yn&&false) ) //false
alert( (yn&&true) ) //true
alert("-------------------");
alert( (false||yn) ) //false
alert( (true||yn) ) //true
alert( (false&&yn) ) //false
alert( (true&&yn) ) //false
alert("Fuck End");
</script><script>
alert( "||出错时返回第一个对象"||yn );
alert( yn&&"&&出错时返回最后一个对象" );
</script>

Answer 29

TT 以前DOS下的打字练习程序，可惜有千年虫。汉化版好垃圾的说。

Answer 30

我以为是TAOTAO的，汗自己一下:)

Answer 31

var tt=/*这里怎么定义tt啊*/;改成下面那样就可以了
var tt;我测试过最后是13
javascript的类型不用指定，会自动转换为任何类型，即使是转换成一个自定义的对象也不成问题。

Answer 32

如果要求是0的话就难办了，javascript会自动转换与它作运算的类型。因此，最后与true或false运算的都将先被转换为true或false了。如果说错，还望高手纠正，学习……