《JavaScript高级程序设计》——第三章 基本概念

Posted 2021-02-27 WP-WangPin

这章讲了javascript的语法、数据类型、流控制语句和函数。理解还是挺好理解的，但有很多和C、C++、Java不同的地方需要记忆。比如，

• JavaScript标识符可以由Unicode字符字符组成。
• JavaScript每条语句后面的分号也不是必需的，语句后面没有分号时，解析器会自己确定语句的结尾。
• “+”，“-”，“*”、“/”、“&&”、“||”、“！”对不同类型操作对象进行计算的规则是不同的。
• switch()括号内不像其他语言必须是字符或数字，而可以放任何类型数据。
• 函数和其他语言也不一样，函数内有个arguments对象用来访问参数数组，函数不介意传递来多少个参数，也不在乎传进来的参数是什么的类型；函数没有重载，如果存在相同的函数名，只会保存最后一个函数。
• 有个label标签语句在以后由break，continue引用

 

 

下面是这章做的笔记

 

typeof用来返回数据类型

         
        var message = "some string";
        alert(typeof message);    //"string"
        alert(typeof 95);         //"number"

 

 

 

只声明不定义的变量的值为undefined

        var message;
        alert(message == undefined);    //true

也可以用undefined显式初始化变量

         
        var message = undefined;
        alert(message == undefined);    //true

没声明的变量除了typeof和delete操作，进行其他运算都会报错

       
        var message;     //this variable is declared but has a value of undefined
        
        //make sure this variable isn‘t declared
        //var age
        
        alert(message);  //"undefined"
        alert(age);      //causes an error

没声明的变量进行typeof操作返回值也是undefined

     
        var message;     //this variable is declared but has a value of undefined
        
        //make sure this variable isn‘t declared
        //var age
        
        alert(typeof message);  //"undefined"
        alert(typeof age);      //"undefined"

 

 

 

null的typeof操作返回"object"

        var car = null;
        alert(typeof car);   //"object"

undefined派生自null，因此他们进行相等测试时，返回true

 alert(null == undefined);   //true  

 

 

 

Boolean()可以将所有类型数据转换成布尔值

        var message = "Hello world!";
        var messageAsBoolean = Boolean(message);
        
        alert(messageAsBoolean); //true

流控制语句会自动将传进来的值转换成Boolean

        var message = "Hello world!";
        if (message){  
            alert("Value is true");
        }

 

 

 

NaN与任何值都不相等包括他自己

isNaN()先尝试将接收到的值转换成数值，然后判断转换后的值是否是数字，如果是数字则返回false，否则返回true

        alert(NaN == NaN);       //false
        alert(isNaN(NaN));       //true
        alert(isNaN(10));        //false ? 10 is a number
        alert(isNaN("10"));      //false ? can be converted to number 10
        alert(isNaN("blue"));    //true ? cannot be converted to a number
        alert(isNaN(true));      //false ? can be converted to number 1

 

 

 

Number()将何种数据类型转换成数值

        var num1 = Number("Hello world!");  //NaN
        var num2 = Number("");              //0
        var num3 = Number("000011");        //11
        var num4 = Number(true);            //1

        alert(num1);
        alert(num2);
        alert(num3);
        alert(num4);

parseInt()可以识别出整型格式（二、八、十、十六进制）

        var num1 = parseInt("1234blue");    //1234
        var num2 = parseInt("");            //NaN
        var num3 = parseInt("0xA");         //10 - hexadecimal
        var num4 = parseInt(22.5);          //22
        var num5 = parseInt("70");          //70 - decimal
        var num6 = parseInt("0xf");         //15 ? hexadecimal

paseInt()如果指定了第二个参数，字符串可以不必带0、0x前缀

        var num1 = parseInt("10", 2);         //2 ? parsed as binary
        var num2 = parseInt("10", 8);         //8 ? parsed as octal
        var num3 = parseInt("10", 10);        //10 ? parsed as decimal
        var num4 = parseInt("10", 16);        //16 ? parsed as hexadecimal

 

 

 

toString()返回一个值的字符串表现

        var age = 11;
        var ageAsString = age.toString();    //the string "11"
        var found = true;
        var foundAsString = found.toString(); //the string "true"

        alert(ageAsString);
        alert(typeof ageAsString);
        alert(foundAsString);
        alert(typeof foundAsString);

toString()可以返回数值的二进制、八进制、十六进制、默认情况下返回十进制

        var num = 10;
        alert(num.toString());       //"10"
        alert(num.toString(2));      //"1010"
        alert(num.toString(8));      //"12"
        alert(num.toString(10));     //"10"
        alert(num.toString(16));     //"a"

toString()不能转换null和undefined的值，而String()可以转换任意类型的值

        var value1 = 10;
        var value2 = true;
        var value3 = null;
        var value4;
        
        alert(String(value1));     //"10"
        alert(String(value2));     //"true"
        alert(String(value3));     //"null"
        alert(String(value4));     //"undefined"

 

 

 

 

 

“++”和“--”会将运算对象先转换成数值再进行递增、递减

        var s1 = "2";
        var s2 = "z";
        var b = false;
        var f = 1.1;
        var o = { 
            valueOf: function() {
                return -1;
            }
        };
        
        s1++;   //value becomes numeric 3
        s2++;   //value becomes NaN
        b++;    //value becomes numeric 1
        f--;    //value becomes 0.10000000000000009
        o--;    //value becomes numeric ?2  

        alert(s1);
        alert(s2);
        alert(b);
        alert(f);
        alert(o);

一元加减运算会将值转换成数值

        var s1 = "01";
        var s2 = "1.1";
        var s3 = "z";
        var b = false;
        var f = 1.1;
        var o = { 
            valueOf: function() {
                return -1;
            }
        };
        
        s1 = +s1;   //value becomes numeric 1
        s2 = +s2;   //value becomes numeric 1.1
        s3 = +s3;   //value becomes NaN
        b = +b;     //value becomes numeric 0
        f = +f;     //no change, still 1.1
        o = +o;     //value becomes numeric ?1

        alert(s1);
        alert(s2);
        alert(s3);
        alert(b);
        alert(f);
        alert(o);

        var s1 = "01";
        var s2 = "1.1";
        var s3 = "z";
        var b = false;
        var f = 1.1;
        var o = { 
            valueOf: function() {
                return -1;
            }
        };
        
        s1 = -s1;   //value becomes numeric -1
        s2 = -s2;   //value becomes numeric -1.1
        s3 = -s3;   //value becomes NaN
        b = -b;     //value becomes numeric 0
        f = -f;     //change to ?1.1
        o = -o;     //value becomes numeric 1

        alert(s1);
        alert(s2);
        alert(s3);
        alert(b);
        alert(f);
        alert(o);

“<<<”、“>>>”是无符号左移和无符号右移运算符

        var oldValue = 64;               //equal to binary 1000000
        var newValue = oldValue >>> 5;   //equal to binary 10 which is decimal 2
        alert(newValue);                 //2

        var oldValue = -64;              //equal to binary 11111111111111111111111111000000
        var newValue = oldValue >>> 5;   //equal to decimal 134217726
        alert(newValue);                 //134217726

“！”运算也是先将操作对象转换成布尔值在进行取非

“!!”相当于是Boolean()操作

   
        alert(!false);      //true
        alert(!"blue");     //false
        alert(!0);          //true
        alert(!NaN);        //true
        alert(!"");         //true
        alert(!12345);      //false

        alert(!!"blue");     //true
        alert(!!0);          //false
        alert(!!NaN);        //false
        alert(!!"");         //false
        alert(!!12345);      //true

逻辑与和逻辑或运算都存在逻辑短路现象

        var found = true;
        var result = (found && someUndeclaredVariable);    //error occurs here
        alert(result);    //this line never executes

        var found = false;
        var result = (found && someUndeclaredVariable);    //no error
        alert(result);    //works

        var found = true;
        var result = (found || someUndeclaredVariable);    //no error
        alert(result);    //works

        var found = false;
        var result = (found || someUndeclaredVariable);    //error occurs here
        alert(result);    //this line never executes

加性操作优先转换成字符串，减性操作优先转换成数值

        var result1 = 5 + 5;     //two numbers
        alert(result1);           //10
        var result2 = 5 + "5";   //a number and a string
        alert(result2);     


        var num1 = 5;
        var num2 = 10;
        var message = "The sum of 5 and 10 is " + num1 + num2;
        alert(message);    //"The sum of 5 and 10 is 510"

        var num1 = 5;
        var num2 = 10;
        var message = "The sum of 5 and 10 is " + (num1 + num2);
        alert(message);    //"The sum of 5 and 10 is 15"

全等“===”只在两个操作数未经转换之前就相等的情况下（数据类型一样）返回true，与之对应的是“!==”

        var result1 = ("55" == 55);    //true ? equal because of conversion
        var result2 = ("55" === 55);   //false ? not equal because different data types
       
        var result1 = ("55" != 55);    //false ? equal because of conversion
        var result2 = ("55" !== 55);   //true ? not equal because different data types
       

break与标签配合使用，跳出最外层循环

        var num = 0;
        
        outermost:
        for (var i=0; i < 10; i++) {
             for (var j=0; j < 10; j++) {
                if (i == 5 && j == 5) {
                    break outermost;
                }
                num++;
            }
        }

continue与标签配合使用，使跳出最外层之外的循环

        var num = 0;
        
        outermost:
        for (var i=0; i < 10; i++) {
             for (var j=0; j < 10; j++) {
                if (i == 5 && j == 5) {
                    continue outermost;
                }
                num++;
            }
        }
        
        alert(num);    //95  i==5的那一层执行到5时跳出内层循环，继续执行外层循环

switch（）括号内可以是任何数据类型

        switch ("hello world") {
            case "hello" + " world": 
                alert("Greeting was found.");
                break;
            case "goodbye": 
                alert("Closing was found.");
                break;
            default: 
                alert("Unexpected message was found.");

arguments对象可以和命名参数一起使用

        function doAdd(num1, num2) {
            if(arguments.length == 1) {
                alert(num1 + 10);
            } else if (arguments.length == 2) {
                alert(arguments[0] + num2);
            }
        }

        
        doAdd(10);        //20
        doAdd(30, 20);    //50

JavaScript没有函数重载，后定义的同名函数会覆盖前面的函数

        function addSomeNumber(num){
            return num + 100;
        }
        
        function addSomeNumber(num) {
            return num + 200;
        }
        
        var result = addSomeNumber(100);    //300
        alert(result);

 for-in语句

        for (var propName in window) {
             document.write(propName);
             document.write("<br />");
        }

 2020-04-23    18:29:22