深夜课堂：JavaScript基本概念

╰半夏微凉° 2022-08-21 07:56 169阅读 0赞

**1、语法：**  
JavaScript区分大小写；  
标识符：第一个字母必须是字母，下划线或者符号；其它字符可以是字母，下划线，符号或者数字。  
注释：

// 单行注释方法
    /* 多行注释方法 ^~^ */

**2、关键字和保留字：**

/*
        关键字：不能用做标识符
        break
        case
        catch
        continue
        debugger
        default
        delete
        do           
        instanceof
        new
        finally      
        return
        switch
        function     
        this
        throw
        in           
        try
        typeof
        var
        void
        while
        with
    */

保留字：也不能用做标识符（ECMA-262第三版定义）

abstract
    boolean
    byte
    char
    class const debugger double enum export extends final float goto implements import int interface long native package private protected public short static super 12 synchronized throws transient volatile

在非严格模式下，第五版把保留字缩减为：

class enum extends super
    const          export        import

而在严格模式下，还要加上下面这几个：

implements
    interface
    let
    package
    private
    protected
    public
    static
    yield

如果使用了关键字或者保留字作为标识符，则会抛出错误：

Identifier Expected

**3、变量**  
ECMAScript的变量是松散型的。所谓松散，就是可以保存任何类型的数据：

var message = "fu萝卜"；
    message = 1;
    message = [1,2,3];

这样的定义完全可以，变量仅仅是一个用于保存值的占位符而已。  
（但是并不推荐这样做）

虾面，注意这两段代码的区别：

function test(){ 
        var message = "hi";
    }
    test();
    alert(message); // 错误

function test(){ message = "hi"; } test();
    alert(message); // "hi"

我们可以知道：在函数中使用var定义的变量是局部变量，在函数作用域外将会被销毁，而不知用var定义的变量则会变成全局变量，在函数作用域外部依旧有效。  
另外，使用逗号而不是分号，可以一次定义多个变量：

var message = "hi",
        found = false,
        age = 29;

**4、数据类型**  
ECMAScript中有5种简单的操作类型，Undefined Null Boolean Number String，还有一种比较复杂的操作类型：Object。ECMAScript不支持任何创建自定义类型的机制。

typeof操作符：用来检测给定变量的数据类型。它可能返回的值包括：undefined boolean string number object function。  
栗子：

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

有时候，typeof函数会返回一些让人费解但是却正确的值：比如 typeof null会返回object，因为null会被认为是一个空的对象引用。

undefined类型：  
变量仅仅声明而没有初始化的时候就是这个类型。  
栗子：

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

第二个栗子：

var message; //undefined 
    // 这个变量没有定义 
    // var age
    alert(typeof message);// "undefined"
    alert(typeof age);// "undefined"

结果表明，对没有初始化和没有声明的变量执行typeof函数都会返回undefined：这也有合理性，因为虽然这两个变量在技术上有本质的区别，但是无论对哪个变量都无法进行真正的操作。

null类型：  
null表示一个空的对象指针，这也就是为什么用typeof来测试null会返回object的原因。

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

Boolean类型：

var found = true;
    var lost = false;

调用函数Boolean()可以将某个其它的数据类型转化为Boolean类型：

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

再有：

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

在这个句子里，if后面就是自动的将message转化为了Boolean：true。

Number类型：  
十进制数值：

var intNum = 55;

八进制：

var octalNum1 = 070;
    var octalNum2 = 079;// 出现了9，是无效的八进制数，认为是十进制的79
    var octalNum3 = 08;// 同理

十六进制：

var hexNum1 = 0xA; //十六进制 10
    var hexNum2 = 0x1f; //十六进制 31

浮点数：

var floatNum1 = 1.1;
    var floatNum2 = 0.1;
    var floatNum3 = .1;// 不推荐这样写

保存浮点数所需要的空间是整数的两倍，所以，ECMAScript会不失时机地将浮点数转化为整数：  
例如，下面这两个数字，虽然都有小数点，但是还是被解析为整数保存。

var floatNum1 = 1.;
    var floatNum2 = 10.0;

e表示法：

var floatNum = 3.125e7; //31250000

浮点数值的最高精度时17位小数。但是在进行算数测试的时候，其精度不如整数：例如，0.2+0.1的结果不是0.3，而是0.30000000000000004。

if (a + b == 0.3){ // 不要这样测试 
        alert("You got 0.3.");
    }

如果ab分别为0.05和0.25，或者是0.15和0.15测试都可以通过，但是如果是0.1+0.2，测试将无法通过。这个叫做舍入误差，而且并非只有ECMAScript存在这样的问题，基于IEEE754数值的浮点数都会出现这样的问题。

数值范围：  
ECMAScript可以保存的最小数字保存在Number.MIN\_VALUE中：5e-324；  
最大数则保存在Number.MAX\_VALUE中：1.7976931348623157e+308。  
如果某次计算的结果超过了最大值，那么就会被保存为Infinity值（正无穷）或者-Infinity（负无穷）。  
如果一个数值是Infinity，那么它将无法进行下一步计算，确定一个数字是否为有穷的，可以使用下面这个函数，当数字在可计算的范围内，函数返回true：

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

另外，Number.NEGATIVE\_INFINITY  
Number.POSITIVE\_INFINITY也可以得到负的或者正的无穷大。

NaN：即not a number（非数值），是一个特殊的数值。这个数值用来表示一个本来要返回某个数值但是没返回的情况，这样，运行时就不会报错了：比如说，在其它编程语言中，0除以0都会报错，从而使得程序终止运行，而在ECMAScript中，0除以0会返回NaN，从而不会影响其它代码的运行。  
NaN本身有两个特点：  
第一，任何与NaN的数值操作都会返回NaN；第二，NaN与任何数都不相等，包括NaN自己。

alert(NaN == NaN); //false

针对NaN这两个特点，ECMAScript定义了一个isNaN函数，它接受一个参数，可以帮我们判断这个参数是不是数值：

alert(isNaN(NaN)); // true 不是数值
     alert(isNaN(10)); // false 是10
     alert(isNaN("10")); //false 可以被转化为10
     alert(isNaN("blue")); // true 不是数值也不能转化成数值
     alert(isNaN(true)); // false 可以转化为1

数值转换：  
有三个函数可以把非数值转化成数值：

Number() 
    parseInt() 
    parseFloat()

第一个函数可以用于任何数据类型，而后两个则专门用来将字符串转化为数值。  
Number函数的规则如下：

如果是Boolean：true转化为1，false转化为0
    如果是null，转化为0
    如果是undefined，转化为NaN
    空字符串，转化为0
    包含不是数字的字符串，例如：ttt，转化为NaN
    如果是对象，则调用对象的valueOf方法，如果转化结果为NaN，再调用对象的toString方法

栗子：

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

parseInt方法：  
比number方法更加合理。栗子：

var num1 = parseInt("1234blue");//1234
    var num2 = parseInt("");//NaN
    var num3 = parseInt("0xA");//10
    var num4 = parseInt(22.5);//22 小数点被被忽略，因为小数点不是有效的数字字符
    var num5 = parseInt("070");//56 八进制数
    var num6 = parseInt("70");//70
    var num7 = parseInt("0xf");//15 16进制数

另外，parseInt函数还可以接受第二个参数，用来指定转化的进制数：  
使用了第二个参数后，16进制的表示方法可以去掉前面的0x，栗子：

var num1 = parseInt("AF", 16); //175 
    var num2 = parseInt("AF"); //NaN

parseFloat和parseInt类似，也是从第一个字符开始，逐个解析，直到遇到无效的字符为止。但是，第一个小数点将会被视为有效字符，第二个小数点后面的数字则会被忽略。

var num1 = parseFloat("1234blue");//1234
    var num2 = parseFloat("0xA");//0
    var num3 = parseFloat("22.5");//22.5
    var num4 = parseFloat("22.34.5");//22.34
    var num5 = parseFloat("0908.5");//908.5
    var num6 = parseFloat("3.125e7");//31250000

String类型

var firstName = "Nicholas";
    var lastName = 'Zakas';

在ECMAScript中，单引号和双引号的作用相同。

特殊的字符字面量：

\n  换行  
    \t  制表
    \b  空格
    \r  回车
    \f  进纸
    \\  斜杠
    \'  单引号
    \"  双引号
    \xnn  16进制代码nn表示的一个字符
    \unnnn  16进制代码nnnn表示一个Unicode字符

字符串的特点：  
ECMAScript中的字符串是不可变的，也就是说，字符一旦创建，那么它的值就无法改变，只有销毁旧的创建新的，才能改变一个变量中保存的字符串。

转换为字符串方法：

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

注意，null和undefined没有这个方法。  
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"

另外，虽然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"

Object类型

创建自定义对象：

var o = new Object();

在ECMAScript中，Object类型是所有实例的基础。也就是说，Object拥有的所有属性和方法，也同样存在于更加具体的实例中。

**5、操作符**

一元操作符：只能操作一个值的操作符。  
一元递增／递减操作符：  
前置：

var age = 29;
    ++age;
    var age = 29;
    --age;

后置：

var age = 29; age++;

前置和后置的区别：

var num1 = 2;
    var num2 = 20;
    var num3 = --num1 + num2;   //21 
    var num4 = num1 + num2;     //21

var num1 = 2;
    var num2 = 20;
    var num3 = num1-- + num2; //22
    var num4 = num1 + num2;   //21

下面的栗子，则解释了一元递增／递减操作符的基本规则：

var s1 = "2";
    var s2 = "z";
    var b = false;
    var f = 1.1;
    var o = {
        valueOf: function() { 
            return -1;
    } };
    s1++; //3 字符串变量变成了数值变量
    s2++; //NaN
    b++; //1
    f--; //0.10000000000000009 浮点数舍入错误所致
    o--; //-2

一元加和减操作符：

var num = 25;
    num = +num; //依旧是25

＋号的规则：  
这个符号会像函数number一样对变量进行数值的转换。

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; //1
    s2 = +s2; //1.1
    s3 = +s3; //NaN
    b= +b; //0
    f= +f; //1.1
    o= +o; //-1

一元减号操作符和一元加号操作符的规则类似，不过会做相反数的操作。

位操作符：  
位操作符作用于最基本的层次上，即按照内存中数值的位来操作数值。  
tips：负数补码如何求？——该数值的绝对值的二进制数，取反，＋1。

按位非：

var num1 = 25; // 00000000000000000000000000011001
    var num2 = ~num1; // 11111111111111111111111111100110
    alert(num2); // -26

按位非的结果是将操作数取反减一，但是由于按位非是最底层的操作，因此速度比较快。

按位与 按位或 按位异或：

var result = 25 & 3;
    alert(result); //1
    
    var result = 25 | 3;
    alert(result); //27
    
    var result = 25 ^ 3;
    alert(result); //26

（待续)