javascript 高程二 第三章，基本概念

     /* typeof操作符:检测给定变量的数据类型。typeof(obj),typeof是一个操作符，而不是个函数。这个返回值会作为 typeof 操          作符的一个操作数
         * typeof 其实只有一个实际的应用这个实际应用是用来检测一个对象是否已经定义或者是否已经赋值，而这个应用却不是用来   检查对象的类型。
         * 
        */

        var foo = "foo";
        var obj = new String("foo"); 
        var num = 2.2;
        var oNum = new Number(2.2);
        var fa = false;
        var oFa = new Boolean(false);
        var date = new Date();
        var err = new Error();
        var arr = [1,2,3];
        var oArr = new Array(1,2,3);
        var fun = new Function("");
        var reg = /abc/g;
        var oReg = new RegExp("moon");
        var nn = {};
        var oNn = new Object();


        console.log(typeof foo);                //string
        console.log(typeof obj);                //object
        console.log(typeof num);                //number
        console.log(typeof(oNum));              //object
        console.log(typeof fa);                 //boolean
        console.log(typeof oFa);                //object
        console.log(typeof date);               //object
        console.log(typeof err);                //object
        console.log(typeof arr);                //object
        console.log(typeof oArr);               //object
        console.log(typeof fun);                //function
        console.log(typeof reg);                //object
        console.log(typeof oReg);               //object
        console.log(typeof nn);                 //object
        console.log(typeof oNn);                //object

        //typeof检测对象类型时并不准确，大多情况下都返回object,
        /*
         * 可以使用Object.prototype.toString方法检测对象类型
        */
        
        var num = new Number(111);
        console.log(typeof num);                                                        //object 还是返回object
        console.log(Object.prototype.toString.call(num));       //[object,Number]

        console.log(Object.prototype.toString.call([]));        //[object,Array]
        console.log(Object.prototype.toString.call({}));        //[object,Object]
        console.log(Object.prototype.toString.call(2));         //[object,Number]
        /*
         *在 ECMAScript 5 中，为了方便，对 null 和 undefined 调用 Object.prototype.toString 方法， 其返回值由 Object 变成了     Null 和 Undefined。
        */
        //IE8
        alert(Object.prototype.toString.call(null));            //[object Object]
        alert(Object.prototype.toString.call(undefined));       //[object Object]

        //firefox 4
        alert(Object.prototype.toString.call(null));            //[object Null]
        alert(Object.prototype.toString.call(undefined));       //[object Undefined]
        

        //Object.prototype.toString 方法被调用，this 被设置为了需要获取的对象类型值的对象。


        var sss='fuck you';
        var sssT = Object.prototype.toString.call(sss);    
        console.log(sssT);                              //[object String]
        sssT.slice(8,-1);                               //String
        //Object.prototype.toString 返回一种标准格式字符串[object,Number],可以通过slice截取指定位置的字符串,如上面代码

        function isType(type,obj){              
                var clas = Object.prototype.toString.call(obj).slice(8,-1);
                return obj !== undefined && obj !== null && clas ===type;
        }
        console.log(isType('String', 'asdasd'));                                //true
        console.log(isType('Number', new Number(1111)));                //true
        console.log(isType('Boolean', new Boolean(1)));                 //true
        console.log(isType('Boolean', new Boolean(0)));                 //true
        
        var nums = new Number(111);

        if(isType('Number',nums)){
                console.log("yse");
        }else{
                console.log("NO");
        }

        //因此检测对象类型使用Object.prototype.toString方法。

        //typeof 用来检测变量是否已定义。这是typeof 唯一的用处
                var aggress = "sss";
                console.log(typeof aggress!== 'undefined');     //true
                console.log(typeof fuck !=='undefined');                //false
                console.log(typeof ok !=='undefined');                  //false

        /*
         * Undefined类型 对应的值是undefined。存在于栈中，在使用var声明变量但未初始化时，该变量值为undefined
        */
        
        var message;
        
        //var age
        console.log(message)   //undefined
        console.log(age)                //error

        //对应未初始化的变量typeof操作符会返回undefined，对未声明的变量执行typeof也会返回undefined

        var message;
        alert(typeof message);          //undefined
        alert(typeof age);                      //undefined

        /*
         * Null类型，对应的其值为null，表示一个空对象的指针，存在于栈中。
         * undefined值是派生自unll值的。对他们测试会返回true
        
        */
        alert(undefined == null)        //true

        //Udefined代表没有赋值的基本数据类型，Null代表没有赋值的引用数据类型
        alert(undefined === null)  //false 表示的类型不同。

        /*
         * Boolean 类型。 类型转换 通过使用 否 操作符两次，可以把一个值转换为布尔型。
        */

        console.log('foo');             //foo
        console.log(!!'foo');   //true
        console.log(!!'');              //false
        console.log(!!'0');             //true
        console.log(!!'-1');    //true
        console.log(!!{});              //true
        console.log(!!true);    //true

        /*
         * Number类型 
         * 最大值Number.MAX_VALUE,最小值Number.MIN_VALUE,超出数值范围，自动转换为Infinity的值。
         * 如果数值是负数，则转换为-Infinity。是正数，转换为Infinity
         * 检测一个书是否在最大值和最小值之间，使用isFinite()函数
        */

        var result = Number.MAX_VALUE+Number.MAX_VALUE;
        console.log(isFinite(result));  //false

        //NaN类型 not a number NaN自身和自身不想等，使用isNaN()函数判断NaN类型,

        console.log(isNaN(NaN));     //true
        console.log(isNaN(10));          //false
        console.log(isNaN('10'));        //false
        console.log(isNaN(true));        //false
        console.log(isNaN('blue'));      //true
        //isNaN函数适用于对象，调用是先调用对象的valueOf()方法，确定是否可以转换为数值，如果不能，基于这个返回值，再调用toString()方法，再测试返回值
        /*
         * 数值转换。通过Number转换，如果是null，返回0；如果是undefined返回NaN；
        */
        var num1 = Number('fuck you');
        var num2 = Number('');
        var num3 = Number('0000011111');
        var num4 = Number(true);

        console.log(num1,num2,num3,num4);  //NaN 0 11111 1

        //转换字符串的函数parseInt()和parseFloat(),
        var num1 = parseInt('1234fuck you');
        var num2 = parseInt('');
        var num3 = parseInt('0000011111');
        var num4 = parseInt('smsn');
        var num5 = parseInt('0xA');             //10十六进制
        var num6 = parseInt(22.5);              
        var num7 = parseInt('070');             //56 八进制
        var num8 = parseInt('70');              //10 十进制
        var num9 = parseInt('0xf')              //15 十六进制

        console.log(num1,num2,num3,num4,num5,num6,num7,num8,num9) //1234 NaN 4681 NaN 10 22 56 70 15

        //parseInt()可传入转换的基数,如果不指定基数，传入的值是由parseInt()决定。因此应写明确指定基数
        var num1 = parseInt('10',2);            //二进制
        var num2 = parseInt('10',8);            //八进制
        var num3 = parseInt('10',10);           //十进制
        var num4 = parseInt('10',16);           //十六进制

        //parseFloat()原理和parseInt()解析方式相同，唯一区别是他只能解析十进制的值

        var num1 = parseFloat('1234fuck you');
        var num2 = parseFloat('0xA');                   //十六进制转换为0
        var num3 = parseFloat('070');                   //八进制转换为70
        var num4 = parseFloat('0808.5');
        var num5 = parseFloat('22.555.55');             
        var num6 = parseFloat('3.11415926e7');  

        
        console.log(num1,num2,num3,num4,num5,num6)              //1234 0 70 808.5 22.555 31141592.6

        /*
         * String类型
         * 转换为字符串，1.调用每个值都有的toString()方法，toString可指定基数，默认为十进制,null和undefined没有这个方法
         *                                2.不知道转换值为null或undefined情况下 使用String() 
        */
        var age = 11;
        var bol = true;
        var num = 10;

        console.log(age.toString());            //'11'
        console.log(bol.toString());            //'true'
        console.log(num.toString(2));           //'1010'
        console.log(num.toString(8));           //'12'
        console.log(num.toString(10));          //'10'
        console.log(num.toString(16));          //'a'

        var value1 = null;
        var value2 = undefined;
        console.log(String(value1));            //'unll'
        console.log(String(value2));            //'undefined'

        /*
         * Object每个实例都具有的属性和方法：
         * constructor 保存着用于创建当前对象的函数
         * hasOwnProperty 检查给定的属性在当前的对象实例中是否存在，而不是实例的原型中，
         * isPrototypeOf(object),用于检查传入的对象是否为另一个对象的原型
         * propertyIsEnumerable, 检查给定的属性是否可以使用for-in枚举
         * toString(),返回对象的字符串表示，
         * valueOf() 返回对象的字符串，数值或布尔值表示，返回值通常和toString()返回的值相同，
        */

        /*
         * 操作符
         * 一元操作符 ，执行前置递增和递减时，变量的值是在语句被求值以前就改变了。
         * 后置递增和递减的操作，是在包含他们的语句被求值之后才执行的
         *      
        */
                var age = 20;
                var anotherAge = --age+2;
                console.log(age);                       //19 执行前置递增和递减时，变量的值是在语句被求值以前就改变了。
                console.log(anotherAge);        //21

                var num1 = 3;
                var num2 = 33;
                var num3 = num1-- + num2 ;      //36
                var num4 = num1 +num2;          //35 后置递增和递减的操作，是在包含他们的语句被求值之后才执行的

                console.log(num3,num4)          //36 35

        //逻辑与 && 第一个操作数的值为false 意味着结果必定为false，就不会去执行第二个操作数，&&为短路操作符
        //逻辑或 || 第一个操作数为true，就不会去执行第二个操作数，也是短路操作符，利用||来避免变量父null或undefined

学习笔记。记录学习的过程。