Ruby's Louvre

The Crankiness of Belief achieves Great , not the Trick of Regulation.

导航

公告

javascript 的位操作符转换推断

var a = "10" | 0;
 alert(a);
 alert (typeof a);

结果为10,number。

这就是说这条语句可以将字符串转化为number。

如果:


var a = "sss" | 0;
alert(a);

结果为0

parseInt("sss")的话,会返回NaN。

这个太强大了,就是说不管是啥都能转换为number。。。

比如:


(function (){})| 0;
({})| 0;
([])| 0;

我了个去……变态啊。

这玩意绝对不不合常理啊。

位运算是按操作符两边内容的二进制值计算的。

就拿String来说,字符串“1”和数值1的二进制难道是一样的?觉没可能!!

那function和object就更没法解释了。

我了个去……还是搞出java来看看吧。

public class aaa {

    public String toBinary(String str){
        char[] strChar = str.toCharArray();
        String result = "";
        for(int i = 0; i < strChar.length; i++){
            result += Integer.toBinaryString(strChar[i]);
        }
        return result;
        }
   
    public static void main(String[] args) {
        String s = "1";
        int n = 1;
        System.out.println(Integer.toBinaryString(n));
        System.out.println(new aaa().toBinary(s));
    }

输出结果:


1010
110001 110000

说明1的二进制值是1010,“1”的是110001110000。

显然他们按位或运算后转换成二进制值完全不同。

运行再次还原回number后结果必然会不同。

那js的内核又是怎么实现的呢?

这里仅作猜测,可能为如下方式:


public class aaa {
     private int _OR_ (String s1, String s2){
        int result1,result2;
        try {
            result1 = Integer.parseInt(s1);
        }catch(Exception e){
            result1 = 0;
        }
        try {
            result2 = Integer.parseInt(s2);
        }catch(Exception e){
            result2 = 0;
        }
        return result1 | result2;
    }
    private int _OR_ (String s1, int s2){
        int result1,result2;
        try {
            result1 = Integer.parseInt(s1);
        }catch(Exception e){
            result1 = 0;
        }
        return result1 | s2;
    }
    private int _OR_ (int s1, String s2){
        int result2;
        try {
            result2 = Integer.parseInt(s2);
        }catch(Exception e){
            result2 = 0;
        }
        return s1 | result2;
    }
    private int _OR_ (int n1, int n2){
        return n1 | n2;
    }  
    public static void main(String[] args) {
        System.out.println(new aaa()._OR_("10","1"));
    }
}

由于在强类型语言中,位运算符仅能用在int和long类型中。

如果猜测没错,js是弱类型,所有内容在位运算操作前需要在js引擎实现内部统一转换为int或long。

如果无法转换则默认为赋值为0。最后再经行位运算操作。由此也就产生了这个"变态"现象。

posted on 2013-07-11 11:32 司徒正美 阅读(...) 评论(...) 编辑 收藏