精华内容
下载资源
问答
  • 一、算数运算符 + - * / %(取余符号) 计算机进行自动数据类型转换:不同数据类型之间没有办法进行运算,将数据转成同一数据类型,再进行计算。 其中一个操作数是字符串,运算符是+号,别的数据类型转换成字符串,...

    一、算数运算符 + - * / %(取余符号)

    计算机进行自动数据类型转换:不同数据类型之间没有办法进行运算,将数据转成同一数据类型,再进行计算。

    1. 其中一个操作数是字符串,运算符是+号,别的数据类型转换成字符串,两个字符串会拼接起来。
        alert('hello' + 100);//hello100
        alert('hello' + true);//hellotrue
        alert('hello' + NaN);//helloNaN
        alert('hello' + undefined);//helloundefined
        alert('hello' + 'de');//hellode
    
    1. 任何数据和字符串做+以外的操作,那么字符串要先转成数字再去进行运算。(100 - "20"结果为80)
    • 如果字符串是一个纯数字字符组成的字符串,转成对应的数字;

    • 如果字符串中含有除数字外的字符,转成NaN, NaN和任何数据运算都是NaN ;

    alert(100 - '20');//相当于100-20  结果为80
    alert(100 -"20a");//'20a'转换成数字为NaN,所以结果为NaN
    
    1. 除字符串以外的数据,进行算术运算的时候,先转成数字,再进行运算
         alert(10 + true);//true=>1
         alert(10 +false); //false=>0
         alert(100 - NaN); //结果NaN
         alert(100 -undefined);//结果NaN
         alert(100 -null); //结果100  null=>0
    

    注意:

    <1>计算机不会进行小数运算
    <2>在js中除数能为0

     alert(0.8-0.1)
    
       alert(10 / 0);//Infinity
       alert(-10 / 0);//-Infinity
    
    Infinity是一个数字,可以跟数字运算 ,结果总是无穷大。
    

    二、 关系运算符 < > <= >= == != === !==

    1. 判断的结果绝对是布尔值
    2. 不同数据类型在进行比较的时候所遵循的规律:
      (1) 两个操作数都是数值,则数值进行比较。
      (2)两个操作符都是字符串,则比较两个字
      符串对应的字符编码值。ASCII码表是电脑内部每一个字符对应编码得一张表。
      ①如果是两个单个字符进行比较,直接进行比较ASCII码值。
      ②逐位进行比较,直到比较出大小 得到结果。
      “abcd” < “ad” : a相同 , b为98, d为100, 所以结果为true.
      ASCII表
      (3)两个操作数有一个是数值,则将另一个转化为数值,再进行数值比较。
    1 == true //true转成数字是1,false转成数字是0,比较结果是true 
    10 == "10" //结果是true
    

    (4)NaN, ==返回false,!=返回true,且NaN与自身不等。

    alert(10 == "10a" );//false
    alert(10 != "10a");//true
    alert("10a" == NaN);//false
    

    在这里插入图片描述

    1. === 恒等 必须数字和数据类型都相同,才返回true

      注意:Number(null)是0;Number(undefined)是NaN; 但是null == undefined是true.

    三、 逻辑运算符 && || !

    1. 与运算:

          &&  (表达式1 && 表达式2 ) 只有当两个表达式都为true时,整个表达式才为真。
      
          注意短路操作:只要左边一个为假,整个表达式就为假,不会再运行右边的代码。比如 10<5 && alert(num);    不会报未声明变量num的错误,因为右边不执行。
      
    2. 或运算:

          || (表达式1 || 表达式2)  只有当两个表达式都为false时,整个表达式为假。
          (同样表达式1为真的话就会不在运行表达式二,直接得出整个表达式为true)
      
    3. 非运算:

          !表达式   将表达式的数据类型转换为布尔值(非0即真,非空即真),然后再取反。
      

    四、一元运算符 ++ - -

    1. a++:

    对原来变量进行加1操作 ,先取a得值作为a++表达式得值 ,再对a加一

    1. ++a:

    对原来变量进行加1操作,先对a加一,再将a的值作为++a的表达式。

      var a = 5;
    alert(a++);//5
    alert(++a);//7 上一语句先将a的值作为a++的值输出,再对a加一变成6,此句将a加一变成7,再讲a得值7作为++a的值输出。
    
    1. a- - 、 - -a

    对原来变量进行减1操作

    五、 赋值运算符 基本 = 复合+= -= *

       “=” 将等号右边的值赋值给等号左边的变量:
    
       var num = 10 + 20;
       alert(num); //结果是30
    
       “+=” : num = num + 9  =>  num += 9
    
    展开全文
  • 一元运算符重载

    2017-05-06 10:44:46
    -------------------siwuxie095               ... 运算符重载,就是给原有运算符赋予新的功能            如:原来的加号 + 是用来做数字相加操作的,但我们往往 会用加号 + 去

    -------------------siwuxie095

      

      

      

      

      

      

      

      

    在 C++ 中,运算符重载既是重点,也是难点

      

    那么,什么是运算符重载呢?

      

    所谓运算符重载,就是给原有运算符赋予新的功能

      

      

      

      

    如:原来的加号 + 是用来做数字相加操作的,但我们往往

    会用加号+ 去做两个字符串的拼接,其实这就是给加号 +

    做了运算符的重载

      

      

    看如下实例:

      

      

      

    在 main() 函数中就使用了加号 + 去连接多个字符串,使之拼接成

    一个字符串,而且打印时也可以将这个字符串直接打印出来

      

    那么这个字符串就进行了多个运算符的重载,即加号运算符+ 、

    等号运算符=、输出运算符 << 都进行了重载

      

      

      

    再看另一个实例:

      

      

      

    在 main() 函数中有两个坐标,它们其实也是可以进行相加的,

    相加之后形成一个新的坐标

      

    但是,坐标相加,对于加号+ 本身来说,并不具备这样的功能,

    为了能够让它具备这样的功能,就可以通过运算符重载来实现

      

    同时,如果想直接输出一个坐标,也可以通过重载输出运算符

    << 来做到

      

      

      

    运算符重载的本质,其实就是函数重载,它并没有神秘的地方

      

      

      

      

    定义运算符重载的关键字:operator,即 运算符

      

      

    运算符重载有很多种,包括一元运算符重载、二元运算符重载

      

      

      

      

      

      

    一元运算符重载

      

      

    所谓 一元运算符,即 这个符号只与一个操作数进行运算

      

      

    1)负号- 的重载

      

      

      

    负号- 的重载方式有两种:

      

    第一种是友元函数重载,即 在类中定义一个全局函数作为友元函数,

    用这个友元函数来做运算符的重载,从而实现一个符号多了一项功能

      

    第二种是成员函数重载,其实就是定义一个类的成员函数

      

      

      

    1)先来看成员函数重载,如下:

      

    定义一个坐标类:Coordinate

      

      

      

      

    如果想对负号 - 做成员函数的重载,应该写成这样:Coordinate 接一个

    引用,然后是关键字operator,后面是负号 -,然后是一对括号

      

    因为是一元运算符,而且是作为类的成员函数存在的,所以不需要在其中

    传任何的参数

      

      

      

    在实现时:

      

      

      

    虽然没有传参数,但作为一个普通的成员函数来说,它还是有一个隐性的

    this 指针的,而这个隐性的 this 指针其实就是它的一个操作数,那么就可

    以将每一个数据成员取反,重新赋值给本身,使得它所有的数据成员都由正

    变为负都由负变为正,然后将*this 作为返回值返回出去即可

      

      

      

    在使用时:

      

      

      

    在 main() 函数中先定义一个 Coordinate 的对象 coor1,只需要在

    coor1 的前面取一个负号,就会使得coor1 的所有值都会取反,就

    相当于是用coor1 去调用 operator-() 这个函数

      

    -coor1; coor1.operator-(); 是等价的

      

    在计算机解释时,当遇到-coor1 这样的表示符号,计算机就会把它

    解释为一个函数的调用

      

      

      

    2)再来看友元函数的重载,如下:

      

      

      

    此时,使用友元声明,通过 friend 来声明一个全局函数 operator-()

    并传入参数Coordinate 的一个引用,它的返回值也是 Coordinate 的

    一个引用

      

      

      

    在实现时:

      

      

      

    通过引用变量分别对它的每一个数据成员取反,并赋值给本身,

    最后将*this返回回去

      

      

      

    在使用时:

      

      

      

    当给对象 coor1 取反时,计算机就会把它解释为 operator-(coor1);

      

      

    比对成员函数重载和友元函数重载:

      

    对于成员函数重载,写的是coor1.operator-();

      

    对于友元函数重载,写的是 operator-(coor1);

      

      

      

      

      

      

    (2)自增符号 ++ 的重载

      

      

      

    自增符号 ++ 的重载方式有两种:一种是 前置++,一种是 后置++

      

      

      

    1)先来看前置++ 的重载,如下:

      

      

      

    如果想要做 ++ 运算符的前置重载,并把它当做成员函数来操作的话,

    可以这样写:Coordinate& operator++();,因为它是一个一元运算符,

    所以这里也不传入任何参数

      

      

      

    在实现时:

      

      

      

    作为成员函数来进行定义,使它的每一个成员都做 ++ 操作,最后将

    *this作为返回值返回出去,即外面接收到的值其实就是 ++ 之后的

    值了

      

      

      

    在使用时:

      

      

      

    如果调用 ++coor1;,就相当于调用 coor1.operator++();, 相当于在

    调一个普通的成员函数

      

    如果传入的是 3 5,在 ++ 之后,就变成了 4 6

      

      

      

    2)再来看后置++ 的重载,如下:

      

      

      

    计算机要对后置++ 前置++ 进行区分,所以 后置++ 需要特别注意:

      

    返回值不再是引用,而是Coordinate 的一个对象,同时,参数一定要传入

    一个 int,这里的 int 是一个标识,它标识当前的 ++ 符号做的是后置重载,

    在使用时,这个int 并不传入任何值,即便是传入任何值也没有意义,因为

    根本就不去使用它,只是一个标识而已

      

      

      

    在实现时:

      

      

      

    首先要保证有一个旧的值,即 先要定义一个临时对象 old,然后将当前

    的值*this先保存到临时对象 old 当中,最后通过return 将 old 返回出

      

    如果在当前行接收到后置++ 的值,那么后置++ 的值也是没有 ++

    之前的值,但是在下一行代码中如果再去使用当前对象时,里面的值

    就已经发生变化了

      

      

      

    在使用时:

      

      

      

    如果调用 coor1++;,就相当于调用 coor1.operator++(0);,即 系统

    会默认为我们传入一个值,一般来说是0,它没有什么意义,但能够表

    达出这是一个在调用后置++ 的运算

      

      

      

      

    程序 1

      

    Coordinate.h:

      

    #ifndef COORDINATE_H

    #define COORDINATE_H

      

    #include <iostream>

    using namespace std;

      

      

    class Coordinate

    {

    // 友元函数的负号运算符重载

    //与注释掉的成员函数的负号运算符重载进行对比

    friend Coordinate &operator-(Coordinate &c);

      

    public:

    Coordinate(int x, int y);

    //成员函数的负号运算符重载

    //Coordinate &operator-();

    int getX();

    int getY();

    private:

    int m_iX;

    int m_iY;

    };

      

    #endif

      

      

      

    Coordinate.cpp:

      

    #include"Coordinate.h"

      

    Coordinate::Coordinate(int x, int y)

    {

    m_iX = x;

    m_iY = y;

    }

      

    int Coordinate::getX()

    {

    return m_iX;

    }

      

    int Coordinate::getY()

    {

    return m_iY;

    }

      

    //Coordinate &Coordinate::operator-()

    //{

    // // this->m_iX=-this->m_iX; this->m_iX=-(this->m_iX); 均可注意隐形的this指针

    // m_iX = -m_iX;

    // m_iY = -m_iY;

    // return *this;

    //}

      

      

    //友元全局函数

    Coordinate &operator-(Coordinate &c)

    {

    c.m_iX = -c.m_iX;

    c.m_iY = -c.m_iY;

    return c;

    }

      

      

      

    main.cpp:

      

    #include"stdlib.h"

    #include"Coordinate.h"

      

    int main(void)

    {

    Coordinate coor(3, 5);

    cout << coor.getX() << "," << coor.getY() << endl;

    //成员函数重载

    //-coor;//coor.operator-(); //可以尝试 -(-coor); 负负得正

      

    //友元函数重载

    -coor;// operator-(coor);

    cout << coor.getX() << "," << coor.getY() << endl;

    system("pause");

    return0;

    }

      

      

      

      

      

      

    程序 2:

      

    Coordinate.h:

      

    #ifndef COORDINATE_H

    #define COORDINATE_H

    #include <iostream>

    using namespace std;

      

      

    class Coordinate

    {

    public:

    Coordinate(int x, int y);

      

    //前置++ 因为是一元运算符在做成员函数重载时就不需要传入参数

    Coordinate &operator++();

      

    //后置++ 有一个参数 int 其实是一个标志型参数

    //告诉编译器当前所做的++运算符重载是后置++的运算符重载

    //

    //编译器看到int就会把它当做后置++的运算符重载标志

    //返回值亦不一样返回的是Coordinate的一个对象而不是一个引用

    Coordinate operator++(int);

    int getX();

    int getY();

    private:

    int m_iX;

    int m_iY;

    };

      

    //因为表达式前置++ 此时表达式的值就是++之后的值

    //把表达式++之后的值当做整个表达式的值就是前置++的实现方式

    //

    //而表达式后置++ 当前的表达式是++之前的那个值而下一行代码

    //再去访问这个对象时才是++之后的这个对象的值所以实现时也要进行特别区分

      

    #endif

      

      

      

    Coordinate.cpp:

      

    #include"Coordinate.h"

      

    Coordinate::Coordinate(int x, int y)

    {

    m_iX = x;

    m_iY = y;

    }

      

    int Coordinate::getX()

    {

    return m_iX;

    }

      

    int Coordinate::getY()

    {

    return m_iY;

    }

      

    //返回出去的值应该是作了++之后的值对每一个数据成员都要做一次++

    Coordinate &Coordinate::operator++()

    {

    m_iX++;// ++m_iX; 均可并不影响函数最终的效果

    m_iY++;//++m_iY;

    return *this;

    }

      

    Coordinate Coordinate::operator++(int)//注意不要漏了int

    {

    //先做一个临时对象temp 或者old 采用直接赋值 *this 放进去

    //用到了拷贝构造函数(因为没有指针并且没有在构造函数中申请内存,

    //所以这里是默认的拷贝构造函数)

    Coordinate old(*this);

    this->m_iX++;

    this->m_iY++;

    //return的是old 这样就能实现当前表达式所拿到的是this ++之前的值

    //而在当前表达式之后再去运行的代码所拿到的对象则是this ++之后的值

    //这样就实现了后置++的效果

    return old;

    }

      

      

      

    main.cpp:

      

    #include"stdlib.h"

    #include"Coordinate.h"

      

    int main(void)

    {

    Coordinate coor(3, 5);

    cout << coor.getX() << "," << coor.getY() << endl;//3,5

    ++coor;

    cout << coor.getX() << "," << coor.getY() << endl;//4,6

    cout << (coor++).getX() << ",";//x=4

    cout << (coor++).getY() << endl;//y=7

    cout << coor.getX() << "," << coor.getY() << endl;//6,8

      

    system("pause");

    return0;

    }

      

      

      

      

      

      

      

      

      

      

      

    【made by siwuxie095】

    展开全文
  • 一元运算符,二元运算符

    千次阅读 2018-07-06 20:46:13
    一元运算符有1个操作数。例如,递增运算符”++”就是一元运算符。 二元运算符有2个操作数。例如,除法运算符”/”有2个操作数。 三元运算符有3个操作数。例如,条件运算符”?:”具有3个操作数。 运算符的行为还...

    运算符可以是一元、二元或三元的。
    一元运算符有1个操作数。例如,递增运算符”++”就是一元运算符。
    二元运算符有2个操作数。例如,除法运算符”/”有2个操作数。
    三元运算符有3个操作数。例如,条件运算符”?:”具有3个操作数。
    运算符的行为还可能因所提供的操作数的数量而异。减法运算符”-“既是一元运算符又是二元运算符。对于减法运算符,如果只提供一个操作数,则该运算符会对操作数取反并返回结果;如果提供两个操作数,则减法运算符返回这两个操作数的差。
    1) 二元运算符
    Java的二元运算符有+(加)、-(减)、*(乘)、/(除)、%(取余数)。
    2) 一元运算符
    Java的一元运算符有++(自加)、–(自减)
    3) 三元运算符
    true?value1:value2;
    例: int a=0x10 , b=010 , max ;
    max=a>b ? a : b ;

    展开全文
  • 一元运算符i++和++i的个人理解心得,资源包括实际应用做题的举例,清楚的描述了怎么去按着作者想法去理解i++和++i,
  • 029_一元运算符

    2020-11-06 18:24:35
    1. 一元运算符只有一个参数, 即要操作的对象或值。它们是JavaScript中最简单的运算符。 2. 一元加法(+) 2.1. 一元加法的用法与您数学中学到的用法相同。 2.2. 一元加法对数字无作用。 2.3. 一个有趣的效果, 一元...

    1. 一元运算符只有一个参数, 即要操作的对象或值。它们是JavaScript中最简单的运算符。

    2. 一元加法(+)

    2.1. 一元加法对数字无作用; 数字对象转为原始数字; NaN还是NaN。

    2.2. 一元加法把null转为数字0。

    2.3. 一元加法把空字符串(''和new String())转为数字0。

    2.4. 一元加法把空数组([]和new Array())转为数字0。

    2.5. 一元加法把true、new Boolean(true)转为数字1, false、new Boolean(false)转为数字0。

    2.6. 一元加法把可完整转为数字的字符串转为数字; 八进制的字符串忽略前导0, 然后按十进制转换; 字符串NaN转为数字NaN。

    2.7. 一元加法把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象(new String())、可完整转为数字的字符串对象(new String('8'))、空数组对象([]和new Array())、布尔对象(new Boolean(true)和new Boolean(false))、数字对象(new Number()构造函数创建的数字对象))转为数字NaN。

    2.8. 一元加法并没有改变运算数本身的类型。

    2.9. 例

    2.9.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>一元加法</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('一元加法对数字无作用; 数字对象转为原始数字: <br />');
    			document.write('na = ' + na + ', +na = ' + +na + ', na的类型: ' + typeof na + ', +na的类型: ' + typeof +na + '<br />');
    			document.write('nb = ' + nb + ', +nb = ' + +nb + ', nb的类型: ' + typeof nb + ', +nb的类型: ' + typeof +nb + '<br />');
    			document.write('nc = ' + nc + ', +nc = ' + +nc + ', nc的类型: ' + typeof nc + ', +nc的类型: ' + typeof +nc + '<br />');
    			document.write('nd = ' + nd + ', +nd = ' + +nd + ', nd的类型: ' + typeof nd + ', +nd的类型: ' + typeof +nd + '<br />');
    			document.write('ne = ' + ne + ', +ne = ' + +ne + ', ne的类型: ' + typeof ne + ', +ne的类型: ' + typeof +ne + '<br />');
    			document.write('nf = ' + nf + ', +nf = ' + +nf + ', nf的类型: ' + typeof nf + ', +nf的类型: ' + typeof +nf + '<br />');
    			document.write('ng = ' + ng + ', +ng = ' + +ng + ', ng的类型: ' + typeof ng + ', +ng的类型: ' + typeof +ng + '<br />');
    			document.write('nh = ' + nh + ', +nh = ' + +nh + ', nh的类型: ' + typeof nh + ', +nh的类型: ' + typeof +nh + '<br />');
    			document.write('ni = ' + ni + ', +ni = ' + +ni + ', ni的类型: ' + typeof ni + ', +ni的类型: ' + typeof +ni + '<br />');
    			document.write('nj = ' + nj + ', +nj = ' + +nj + ', nj的类型: ' + typeof nj + ', +nj的类型: ' + typeof +nj + '<br />');
    			document.write('nk = ' + nk + ', +nk = ' + +nk + ', nk的类型: ' + typeof nk + ', +nk的类型: ' + typeof +nk + '<br />');
    			document.write('nl = ' + nl + ', +nl = ' + +nl + ', nl的类型: ' + typeof nl + ', +nl的类型: ' + typeof +nl + '<br />');
    			document.write('nm = ' + nm + ', +nm = ' + +nm + ', nm的类型: ' + typeof nm + ', +nm的类型: ' + typeof +nm + '<hr />');
    
    			document.write('一元加法把null转为数字0: <br />');
    			document.write('la = ' + la + ', +la = ' + +la + ', na的类型: ' + typeof la + ', +na的类型: ' + typeof +la + '<hr />');
    
    			document.write('一元加法把空字符串(\'\'和new String())转为数字0: <br />');
    			document.write('sa = ' + sa + ', +sa = ' + +sa + ', sa的类型: ' + typeof sa + ', +sa的类型: ' + typeof +sa + '<br />');
    			document.write('sp = ' + sp + ', +sp = ' + +sp + ', sp的类型: ' + typeof sp + ', +sp的类型: ' + typeof +sp + '<hr />');
    
    			document.write('一元加法把空数组([]和new Array())转为数字0: <br />');
    			document.write('aa = ' + aa + ', +aa = ' + +aa + ', aa的类型: ' + typeof aa + ', +aa的类型: ' + typeof +aa + '<br />');
    			document.write('ac = ' + ac + ', +ac = ' + +ac + ', ac的类型: ' + typeof ac + ', +ac的类型: ' + typeof +ac + '<hr />');
    
    			document.write('一元加法把true、new Boolean(true)转为数字1, false、new Boolean(false)转为数字0: <br />');
    			document.write('ba = ' + ba + ', +ba = ' + +ba + ', ba的类型: ' + typeof ba + ', +ba的类型: ' + typeof +ba + '<br />');
    			document.write('bb = ' + bb + ', +bb = ' + +bb + ', bb的类型: ' + typeof bb + ', +bb的类型: ' + typeof +bb + '<br />');
    			document.write('bc = ' + bc + ', +bc = ' + +bc + ', bc的类型: ' + typeof bc + ', +bc的类型: ' + typeof +bc + '<br />');
    			document.write('bd = ' + bd + ', +bd = ' + +bd + ', bd的类型: ' + typeof bd + ', +bd的类型: ' + typeof +bd + '<hr />');
    			
    			document.write('一元加法把可完整转为数字的字符串转为数字; 八进制的字符串忽略前导0, 然后按十进制转换: <br />');
    			document.write('sd = ' + sd + ', +sd = ' + +sd + ', sd的类型: ' + typeof sd + ', +sd的类型: ' + typeof +sd + '<br />');
    			document.write('se = ' + se + ', +se = ' + +se + ', se的类型: ' + typeof se + ', +se的类型: ' + typeof +se + '<br />');
    			document.write('sg = ' + sg + ', +sg = ' + +sg + ', sg的类型: ' + typeof sg + ', +sg的类型: ' + typeof +sg + '<br />');
    			document.write('sh = ' + sh + ', +sh = ' + +sh + ', sh的类型: ' + typeof sh + ', +sh的类型: ' + typeof +sh + '<br />');
    			document.write('si = ' + si + ', +si = ' + +si + ', si的类型: ' + typeof si + ', +si的类型: ' + typeof +si + '<br />');
    			document.write('sj = ' + sj + ', +sj = ' + +sj + ', sj的类型: ' + typeof sj + ', +sj的类型: ' + typeof +sj + '<br />');
    			document.write('sk = ' + sk + ', +sk = ' + +sk + ', sk的类型: ' + typeof sk + ', +sk的类型: ' + typeof +sk + '<br />');
    			document.write('sl = ' + sl + ', +sl = ' + +sl + ', sl的类型: ' + typeof sl + ', +sl的类型: ' + typeof +sl + '<br />');
    			document.write('sm = ' + sm + ', +sm = ' + +sm + ', sm的类型: ' + typeof sm + ', +sm的类型: ' + typeof +sm + '<br />');
    			document.write('sn = ' + sn + ', +sn = ' + +sn + ', sn的类型: ' + typeof sn + ', +sn的类型: ' + typeof +sn + '<br />');
    			document.write('so = ' + so + ', +so = ' + +so + ', so的类型: ' + typeof so + ', +so的类型: ' + typeof +so + '<br />');
    			document.write('sq = ' + sq + ', +sq = ' + +sq + ', sq的类型: ' + typeof sq + ', +sq的类型: ' + typeof +sq + '<hr />');
    
    			document.write('一元加法把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', +ua = ' + +ua + ', ua的类型: ' + typeof ua + ', +ua的类型: ' + typeof +ua + '<br />');
    			document.write('sb = ' + sb + ', +sb = ' + +sb + ', sb的类型: ' + typeof sb + ', +sb的类型: ' + typeof +sb + '<br />');
    			document.write('sc = ' + sc + ', +sc = ' + +sc + ', sc的类型: ' + typeof sc + ', +sc的类型: ' + typeof +sc + '<br />');
    			document.write('sf = ' + sf + ', +sf = ' + +sf + ', sf的类型: ' + typeof sf + ', +sf的类型: ' + typeof +sf + '<br />');
    			document.write('ab = ' + ab + ', +ab = ' + +ab + ', ab的类型: ' + typeof ab + ', +ab的类型: ' + typeof +ab + '<br />');
    			document.write('oa = ' + oa + ', +oa = ' + +oa + ', oa的类型: ' + typeof oa + ', +oa的类型: ' + typeof +oa + '<br />');
    			document.write('ob = ' + ob + ', +ob = ' + +ob + ', ob的类型: ' + typeof ob + ', +ob的类型: ' + typeof +ob + '<br />');
    			document.write('oc = ' + oc + ', +oc = ' + +oc + ', oc的类型: ' + typeof oc + ', +oc的类型: ' + typeof +oc + '<br />');
    		</script>
    	</body>
    </html>

    2.9.2. 效果图

    3. 一元减法(-)

    3.1. 一元减法对数字求负; 数字对象转为原始数字并求负; NaN还是NaN。

    3.2. 一元减法把null转为数字0。

    3.3. 一元减法把空字符串(''和new String())在数学运算中转为数字0。

    3.4. 一元减法把空数组([]和new Array())转为数字0。

    3.5. 一元减法把true、new Boolean(true)转为数字-1, false、new Boolean(false)转为数字0。

    3.6. 一元减法把可完整转为数字的字符串转为数字并求负; 八进制的字符串忽略前导0, 然后按十进制转换并求负; 字符串NaN转为数字NaN。

    3.7. 一元减法把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象(new String())、可完整转为数字的字符串对象(new String('8'))、空数组对象([]和new Array())、布尔对象(new Boolean(true)和new Boolean(false))、数字对象(new Number()构造函数创建的数字对象))转为数字NaN。

    3.8. 一元减法并没有改变运算数本身的类型。

    3.9. 例

    3.9.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>一元减法</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('一元减法对数字求负; 数字对象转为原始数字并求负; NaN不求负: <br />');
    			document.write('na = ' + na + ', -na = ' + -na + ', na的类型: ' + typeof na + ', -na的类型: ' + typeof -na + '<br />');
    			document.write('nb = ' + nb + ', -nb = ' + -nb + ', nb的类型: ' + typeof nb + ', -nb的类型: ' + typeof -nb + '<br />');
    			document.write('nc = ' + nc + ', -nc = ' + -nc + ', nc的类型: ' + typeof nc + ', -nc的类型: ' + typeof -nc + '<br />');
    			document.write('nd = ' + nd + ', -nd = ' + -nd + ', nd的类型: ' + typeof nd + ', -nd的类型: ' + typeof -nd + '<br />');
    			document.write('ne = ' + ne + ', -ne = ' + -ne + ', ne的类型: ' + typeof ne + ', -ne的类型: ' + typeof -ne + '<br />');
    			document.write('nf = ' + nf + ', -nf = ' + -nf + ', nf的类型: ' + typeof nf + ', -nf的类型: ' + typeof -nf + '<br />');
    			document.write('ng = ' + ng + ', -ng = ' + -ng + ', ng的类型: ' + typeof ng + ', -ng的类型: ' + typeof -ng + '<br />');
    			document.write('nh = ' + nh + ', -nh = ' + -nh + ', nh的类型: ' + typeof nh + ', -nh的类型: ' + typeof -nh + '<br />');
    			document.write('ni = ' + ni + ', -ni = ' + -ni + ', ni的类型: ' + typeof ni + ', -ni的类型: ' + typeof -ni + '<br />');
    			document.write('nj = ' + nj + ', -nj = ' + -nj + ', nj的类型: ' + typeof nj + ', -nj的类型: ' + typeof -nj + '<br />');
    			document.write('nk = ' + nk + ', -nk = ' + -nk + ', nk的类型: ' + typeof nk + ', -nk的类型: ' + typeof -nk + '<br />');
    			document.write('nl = ' + nl + ', -nl = ' + -nl + ', nl的类型: ' + typeof nl + ', -nl的类型: ' + typeof -nl + '<br />');
    			document.write('nm = ' + nm + ', -nm = ' + -nm + ', nm的类型: ' + typeof nm + ', -nm的类型: ' + typeof -nm + '<hr />');
    
    			document.write('一元减法把null转为数字0: <br />');
    			document.write('la = ' + la + ', -la = ' + -la + ', na的类型: ' + typeof la + ', -na的类型: ' + typeof -la + '<hr />');
    
    			document.write('一元减法把空字符串(\'\'和new String())转为数字0: <br />');
    			document.write('sa = ' + sa + ', -sa = ' + -sa + ', sa的类型: ' + typeof sa + ', -sa的类型: ' + typeof -sa + '<br />');
    			document.write('sp = ' + sp + ', -sp = ' + -sp + ', sp的类型: ' + typeof sp + ', -sp的类型: ' + typeof -sp + '<hr />');
    
    			document.write('一元减法把空数组([]和new Array())转为数字0: <br />');
    			document.write('aa = ' + aa + ', -aa = ' + -aa + ', aa的类型: ' + typeof aa + ', -aa的类型: ' + typeof -aa + '<br />');
    			document.write('ac = ' + ac + ', -ac = ' + -ac + ', ac的类型: ' + typeof ac + ', -ac的类型: ' + typeof -ac + '<hr />');
    
    			document.write('一元减法把true、new Boolean(true)转为数字1, false、new Boolean(false)转为数字0: <br />');
    			document.write('ba = ' + ba + ', -ba = ' + -ba + ', ba的类型: ' + typeof ba + ', -ba的类型: ' + typeof -ba + '<br />');
    			document.write('bb = ' + bb + ', -bb = ' + -bb + ', bb的类型: ' + typeof bb + ', -bb的类型: ' + typeof -bb + '<br />');
    			document.write('bc = ' + bc + ', -bc = ' + -bc + ', bc的类型: ' + typeof bc + ', -bc的类型: ' + typeof -bc + '<br />');
    			document.write('bd = ' + bd + ', -bd = ' + -bd + ', bd的类型: ' + typeof bd + ', -bd的类型: ' + typeof -bd + '<hr />');
    			
    			document.write('一元减法把可完整转为数字的字符串转为数字并求负; 八进制的字符串忽略前导0, 然后按十进制转换并求负; NaN只转数字不求负: <br />');
    			document.write('sd = ' + sd + ', -sd = ' + -sd + ', sd的类型: ' + typeof sd + ', -sd的类型: ' + typeof -sd + '<br />');
    			document.write('se = ' + se + ', -se = ' + -se + ', se的类型: ' + typeof se + ', -se的类型: ' + typeof -se + '<br />');
    			document.write('sg = ' + sg + ', -sg = ' + -sg + ', sg的类型: ' + typeof sg + ', -sg的类型: ' + typeof -sg + '<br />');
    			document.write('sh = ' + sh + ', -sh = ' + -sh + ', sh的类型: ' + typeof sh + ', -sh的类型: ' + typeof -sh + '<br />');
    			document.write('si = ' + si + ', -si = ' + -si + ', si的类型: ' + typeof si + ', -si的类型: ' + typeof -si + '<br />');
    			document.write('sj = ' + sj + ', -sj = ' + -sj + ', sj的类型: ' + typeof sj + ', -sj的类型: ' + typeof -sj + '<br />');
    			document.write('sk = ' + sk + ', -sk = ' + -sk + ', sk的类型: ' + typeof sk + ', -sk的类型: ' + typeof -sk + '<br />');
    			document.write('sl = ' + sl + ', -sl = ' + -sl + ', sl的类型: ' + typeof sl + ', -sl的类型: ' + typeof -sl + '<br />');
    			document.write('sm = ' + sm + ', -sm = ' + -sm + ', sm的类型: ' + typeof sm + ', -sm的类型: ' + typeof -sm + '<br />');
    			document.write('sn = ' + sn + ', -sn = ' + -sn + ', sn的类型: ' + typeof sn + ', -sn的类型: ' + typeof -sn + '<br />');
    			document.write('so = ' + so + ', -so = ' + -so + ', so的类型: ' + typeof so + ', -so的类型: ' + typeof -so + '<br />');
    			document.write('sq = ' + sq + ', -sq = ' + -sq + ', sq的类型: ' + typeof sq + ', -sq的类型: ' + typeof -sq + '<hr />');
    
    			document.write('一元减法把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', -ua = ' + -ua + ', ua的类型: ' + typeof ua + ', -ua的类型: ' + typeof -ua + '<br />');
    			document.write('sb = ' + sb + ', -sb = ' + -sb + ', sb的类型: ' + typeof sb + ', -sb的类型: ' + typeof -sb + '<br />');
    			document.write('sc = ' + sc + ', -sc = ' + -sc + ', sc的类型: ' + typeof sc + ', -sc的类型: ' + typeof -sc + '<br />');
    			document.write('sf = ' + sf + ', -sf = ' + -sf + ', sf的类型: ' + typeof sf + ', -sf的类型: ' + typeof -sf + '<br />');
    			document.write('ab = ' + ab + ', -ab = ' + -ab + ', ab的类型: ' + typeof ab + ', -ab的类型: ' + typeof -ab + '<br />');
    			document.write('oa = ' + oa + ', -oa = ' + -oa + ', oa的类型: ' + typeof oa + ', -oa的类型: ' + typeof -oa + '<br />');
    			document.write('ob = ' + ob + ', -ob = ' + -ob + ', ob的类型: ' + typeof ob + ', -ob的类型: ' + typeof -ob + '<br />');
    			document.write('oc = ' + oc + ', -oc = ' + -oc + ', oc的类型: ' + typeof oc + ', -oc的类型: ' + typeof -oc + '<br />');
    		</script>
    	</body>
    </html>

    3.9.2. 效果图

    4. 前增量/后增量运算符

    4.1. 所谓前增量运算符, 就是数值上加1, 形式是在变量前放两个加号(++)。

    4.2. 后增量运算符也是给数值上加1, 形式是在变量后放两个加号(++)。

    4.3. 前增量发生在计算表达式之前; 后增量是在计算过包含它们的表达式后才进行增量。

    4.4. 前增量或后增量对数字加1; 数字对象转为原始数字并加1; 对NaN、Infinity和-Infinity无影响。

    4.5. 前增量或后增量把null转为数字0并加1。

    4.6. 前增量或后增量把空字符串(''和new String())转为数字0并加1。

    4.7. 前增量或后增量把空数组([]和new Array())转为数字0并加1。

    4.8. 前增量或后增量把true、new Boolean(true)转为数字1并加1, false、new Boolean(false)转为数字0并加1。

    4.9. 前增量或后增量把可完整转为数字的字符串转为数字并加1; 八进制的字符串忽略前导0, 然后按十进制转换并加1; 字符串NaN转为数字NaN。

    4.10. 前增量或后增量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象(new String())、可完整转为数字的字符串对象(new String('8'))、空数组对象([]和new Array())、布尔对象(new Boolean(true)和new Boolean(false))、数字对象(new Number()构造函数创建的数字对象))转为数字NaN。

    4.11. 增量运算符把运算数本身的类型都改成了数字类型。

    4.12. 前增量

    4.12.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>前增量运算符</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('前增量对数字加1; 数字对象转为原始数字并加1; 对NaN、Infinity和-Infinity无影响: <br />');
    			document.write('na = ' + na + ', na的类型: ' + typeof na + ', ++na = ' + ++na + '<br />');
    			document.write('nb = ' + nb + ', nb的类型: ' + typeof nb + ', ++nb = ' + ++nb + '<br />');
    			document.write('nc = ' + nc + ', nc的类型: ' + typeof nc + ', ++nc = ' + ++nc + '<br />');
    			document.write('nd = ' + nd + ', nd的类型: ' + typeof nd + ', ++nd = ' + ++nd + '<br />');
    			document.write('ne = ' + ne + ', ne的类型: ' + typeof ne + ', ++ne = ' + ++ne + '<br />');
    			document.write('nf = ' + nf + ', nf的类型: ' + typeof nf + ', ++nf = ' + ++nf + '<br />');
    			document.write('ng = ' + ng + ', ng的类型: ' + typeof ng + ', ++ng = ' + ++ng+ '<br />');
    			document.write('nh = ' + nh + ', nh的类型: ' + typeof nh + ', ++nh = ' + ++nh + '<br />');
    			document.write('ni = ' + ni + ', ni的类型: ' + typeof ni + ', ++ni = ' + ++ni + '<br />');
    			document.write('nj = ' + nj + ', nj的类型: ' + typeof nj + ', ++nj = ' + ++nj + '<br />');
    			document.write('nk = ' + nk + ', nk的类型: ' + typeof nk + ', ++nk = ' + ++nk + '<br />');
    			document.write('nl = ' + nl + ', nl的类型: ' + typeof nl + ', ++nl = ' + ++nl + '<br />');
    			document.write('nm = ' + nm + ', nm的类型: ' + typeof nm + ', ++nm = ' + ++nm + ', 前增量修改了nm本身的类型: ' + typeof nm + '<hr />');
    
    			document.write('前增量把null转为数字0并加1: <br />');
    			document.write('la = ' + la + ', na的类型: ' + typeof la + ', ++la = ' + ++la + ', 前增量修改了na本身的类型: ' + typeof la + '<hr />');
    
    			document.write('前增量把空字符串(\'\'和new String())转为数字0并加1: <br />');
    			document.write('sa = ' + sa + ', sa的类型: ' + typeof sa + ', ++sa = ' + ++sa + ', 前增量修改了sa本身的类型: ' + typeof sa + '<br />');
    			document.write('sp = ' + sp + ', sp的类型: ' + typeof sp + ', ++sp = ' + ++sp + ', 前增量修改了sp本身的类型: ' + typeof sp + '<hr />');
    
    			document.write('前增量把空数组([]和new Array())转为数字0并加1: <br />');
    			document.write('aa = ' + aa + ', aa的类型: ' + typeof aa + ', ++aa = ' + ++aa + ', 前增量修改了aa本身的类型: ' + typeof aa + '<br />');
    			document.write('ac = ' + ac + ', ac的类型: ' + typeof ac + ', ++ac = ' + ++ac + ', 前增量修改了ac本身的类型: ' + typeof ac + '<hr />');
    
    			document.write('前增量把true、new Boolean(true)转为数字1并加1, false、new Boolean(false)转为数字0并加1: <br />');
    			document.write('ba = ' + ba + ', ba的类型: ' + typeof ba + ', ++ba = ' + ++ba + ', 前增量修改了ba本身的类型: ' + typeof ba + '<br />');
    			document.write('bb = ' + bb + ', bb的类型: ' + typeof bb + ', ++bb = ' + ++bb + ', 前增量修改了bb本身的类型: ' + typeof bb + '<br />');
    			document.write('bc = ' + bc + ', bc的类型: ' + typeof bc + ', ++bc = ' + ++bc + ', 前增量修改了bc本身的类型: ' + typeof bc + '<br />');
    			document.write('bd = ' + bd + ', bd的类型: ' + typeof bd + ', ++bd = ' + ++bd + ', 前增量修改了bd本身的类型: ' + typeof bd + '<hr />');
    			
    			document.write('前增量把可完整转为数字的字符串转为数字并加1; 八进制的字符串忽略前导0, 然后按十进制转换并加1: <br />');
    			document.write('sd = ' + sd + ', sd的类型: ' + typeof sd + ', ++sd = ' + ++sd + ', 前增量修改了sd本身的类型: ' + typeof sd + '<br />');
    			document.write('se = ' + se + ', se的类型: ' + typeof se + ', ++se = ' + ++se + ', 前增量修改了se本身的类型: ' + typeof se + '<br />');
    			document.write('sg = ' + sg + ', sg的类型: ' + typeof sg + ', ++sg = ' + ++sg + ', 前增量修改了sg本身的类型: ' + typeof sg + '<br />');
    			document.write('sh = ' + sh + ', sh的类型: ' + typeof sh + ', ++sh = ' + ++sh + ', 前增量修改了sh本身的类型: ' + typeof sh + '<br />');
    			document.write('si = ' + si + ', si的类型: ' + typeof si + ', ++si = ' + ++si + ', 前增量修改了si本身的类型: ' + typeof si + '<br />');
    			document.write('sj = ' + sj + ', sj的类型: ' + typeof sj + ', ++sj = ' + ++sj + ', 前增量修改了sj本身的类型: ' + typeof sj + '<br />');
    			document.write('sk = ' + sk + ', sk的类型: ' + typeof sk + ', ++sk = ' + ++sk + ', 前增量修改了sk本身的类型: ' + typeof sk + '<br />');
    			document.write('sl = ' + sl + ', sl的类型: ' + typeof sl + ', ++sl = ' + ++sl + ', 前增量修改了sl本身的类型: ' + typeof sl + '<br />');
    			document.write('sm = ' + sm + ', sm的类型: ' + typeof sm + ', ++sm = ' + ++sm + ', 前增量修改了sm本身的类型: ' + typeof sm + '<br />');
    			document.write('sn = ' + sn + ', sn的类型: ' + typeof sn + ', ++sn = ' + ++sn + ', 前增量修改了sn本身的类型: ' + typeof sn + '<br />');
    			document.write('so = ' + so + ', so的类型: ' + typeof so + ', ++so = ' + ++so + ', 前增量修改了so本身的类型: ' + typeof so + '<br />');
    			document.write('sq = ' + sq + ', sq的类型: ' + typeof sq + ', ++sq = ' + ++sq + ', 前增量修改了sq本身的类型: ' + typeof sq + '<hr />');
    
    			document.write('前增量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', ua的类型: ' + typeof ua + ', ++ua = ' + ++ua + ', 前增量修改了ua本身的类型: ' + typeof ua + '<br />');
    			document.write('sb = ' + sb + ', sb的类型: ' + typeof sb + ', ++sb = ' + ++sb + ', 前增量修改了sb本身的类型: ' + typeof sb + '<br />');
    			document.write('sc = ' + sc + ', sc的类型: ' + typeof sc + ', ++sc = ' + ++sc + ', 前增量修改了sc本身的类型: ' + typeof sc + '<br />');
    			document.write('sf = ' + sf + ', sf的类型: ' + typeof sf + ', ++sf = ' + ++sf + ', 前增量修改了sf本身的类型: ' + typeof sf + '<br />');
    			document.write('ab = ' + ab + ', ab的类型: ' + typeof ab + ', ++ab = ' + ++ab + ', 前增量修改了ab本身的类型: ' + typeof ab + '<br />');
    			document.write('oa = ' + oa + ', oa的类型: ' + typeof oa + ', ++oa = ' + ++oa + ', 前增量修改了oa本身的类型: ' + typeof oa + '<br />');
    			document.write('ob = ' + ob + ', ob的类型: ' + typeof ob + ', ++ob = ' + ++ob + ', 前增量修改了ob本身的类型: ' + typeof ob + '<br />');
    			document.write('oc = ' + oc + ', oc的类型: ' + typeof oc + ', ++oc = ' + ++oc + ', 前增量修改了oc本身的类型: ' + typeof oc + '<br />');
    		</script>
    	</body>
    </html>

    4.12.2. 效果图

    4.13. 后增量

    4.13.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>后增量运算符</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('后增量对数字加1; 数字对象转为原始数字并加1; 对NaN、Infinity和-Infinity无影响: <br />');
    			document.write('na = ' + na + ', na的类型: ' + typeof na + ', na++ = ' + na++ + ', na = ' + na + '<br />');
    			document.write('nb = ' + nb + ', nb的类型: ' + typeof nb + ', nb++ = ' + nb++ + ', nb = ' + nb + '<br />');
    			document.write('nc = ' + nc + ', nc的类型: ' + typeof nc + ', nc++ = ' + nc++ + ', nc = ' + nc + '<br />');
    			document.write('nd = ' + nd + ', nd的类型: ' + typeof nd + ', nd++ = ' + nd++ + ', nd = ' + nd + '<br />');
    			document.write('ne = ' + ne + ', ne的类型: ' + typeof ne + ', ne++ = ' + ne++ + ', ne = ' + ne + '<br />');
    			document.write('nf = ' + nf + ', nf的类型: ' + typeof nf + ', nf++ = ' + nf++ + ', nf = ' + nf + '<br />');
    			document.write('ng = ' + ng + ', ng的类型: ' + typeof ng + ', ng++ = ' + ng++ + ', ng = ' + ng + '<br />');
    			document.write('nh = ' + nh + ', nh的类型: ' + typeof nh + ', nh++ = ' + nh++ + ', nh = ' + nh + '<br />');
    			document.write('ni = ' + ni + ', ni的类型: ' + typeof ni + ', ni++ = ' + ni++ + ', ni = ' + ni + '<br />');
    			document.write('nj = ' + nj + ', nj的类型: ' + typeof nj + ', nj++ = ' + nj++ + ', nj = ' + nj + '<br />');
    			document.write('nk = ' + nk + ', nk的类型: ' + typeof nk + ', nk++ = ' + nk++ + ', nk = ' + nk + '<br />');
    			document.write('nl = ' + nl + ', nl的类型: ' + typeof nl + ', nl++ = ' + nl++ + ', nl = ' + nl + '<br />');
    			document.write('nm = ' + nm + ', nm的类型: ' + typeof nm + ', nm++ = ' + nm++ + ', 后增量修改了nm本身的类型: ' + typeof nm + ', nm =  ' + nm + '<hr />');
    
    			document.write('后增量把null转为数字0并加1: <br />');
    			document.write('la = ' + la + ', na的类型: ' + typeof la + ', la++ = ' + la++ + ', 后增量修改了na本身的类型: ' + typeof la + ', la =  ' + la + '<hr />');
    			
    			document.write('后增量把空字符串(\'\'和new String())转为数字0并加1: <br />');
    			document.write('sa = ' + sa + ', sa的类型: ' + typeof sa + ', sa++ = ' + sa++ + ', 后增量修改了sa本身的类型: ' + typeof sa + ', sa =  ' + sa + '<br />');
    			document.write('sp = ' + sp + ', sp的类型: ' + typeof sp + ', sp++ = ' + sp++ + ', 后增量修改了sp本身的类型: ' + typeof sp + ', sp =  ' + sp + '<hr />');
    
    			document.write('后增量把空数组([]和new Array())转为数字0并加1: <br />');
    			document.write('aa = ' + aa + ', aa的类型: ' + typeof aa + ', aa++ = ' + aa++ + ', 后增量修改了aa本身的类型: ' + typeof aa + ', aa =  ' + aa + '<br />');
    			document.write('ac = ' + ac + ', ac的类型: ' + typeof ac + ', ac++ = ' + ac++ + ', 后增量修改了ac本身的类型: ' + typeof ac + ', ac =  ' + ac + '<hr />');
    
    			document.write('后增量把true、new Boolean(true)转为数字1并加1, false、new Boolean(false)转为数字0并加1: <br />');
    			document.write('ba = ' + ba + ', ba的类型: ' + typeof ba + ', ba++ = ' + ba++ + ', 后增量修改了ba本身的类型: ' + typeof ba + ', ba =  ' + ba + '<br />');
    			document.write('bb = ' + bb + ', bb的类型: ' + typeof bb + ', bb++ = ' + bb++ + ', 后增量修改了bb本身的类型: ' + typeof bb + ', bb =  ' + bb + '<br />');
    			document.write('bc = ' + bc + ', bc的类型: ' + typeof bc + ', bc++ = ' + bc++ + ', 后增量修改了bc本身的类型: ' + typeof bc + ', bc =  ' + bc + '<br />');
    			document.write('bd = ' + bd + ', bd的类型: ' + typeof bd + ', bd++ = ' + bd++ + ', 后增量修改了bd本身的类型: ' + typeof bd + ', bd =  ' + bd + '<hr />');
    			
    			document.write('后增量把可完整转为数字的字符串转为数字并加1; 八进制的字符串忽略前导0, 然后按十进制转换并加1: <br />');
    			document.write('sd = ' + sd + ', sd的类型: ' + typeof sd + ', sd++ = ' + sd++ + ', 后增量修改了sd本身的类型: ' + typeof sd + ', sd =  ' + sd + '<br />');
    			document.write('se = ' + se + ', se的类型: ' + typeof se + ', se++ = ' + se++ + ', 后增量修改了se本身的类型: ' + typeof se + ', se =  ' + se + '<br />');
    			document.write('sg = ' + sg + ', sg的类型: ' + typeof sg + ', sg++ = ' + sg++ + ', 后增量修改了sg本身的类型: ' + typeof sg + ', sg =  ' + sg + '<br />');
    			document.write('sh = ' + sh + ', sh的类型: ' + typeof sh + ', sh++ = ' + sh++ + ', 后增量修改了sh本身的类型: ' + typeof sh + ', sh =  ' + sh + '<br />');
    			document.write('si = ' + si + ', si的类型: ' + typeof si + ', si++ = ' + si++ + ', 后增量修改了si本身的类型: ' + typeof si + ', si =  ' + si + '<br />');
    			document.write('sj = ' + sj + ', sj的类型: ' + typeof sj + ', sj++ = ' + sj++ + ', 后增量修改了sj本身的类型: ' + typeof sj + ', sj =  ' + sj + '<br />');
    			document.write('sk = ' + sk + ', sk的类型: ' + typeof sk + ', sk++ = ' + sk++ + ', 后增量修改了sk本身的类型: ' + typeof sk + ', sk =  ' + sk + '<br />');
    			document.write('sl = ' + sl + ', sl的类型: ' + typeof sl + ', sl++ = ' + sl++ + ', 后增量修改了sl本身的类型: ' + typeof sl + ', sl =  ' + sl + '<br />');
    			document.write('sm = ' + sm + ', sm的类型: ' + typeof sm + ', sm++ = ' + sm++ + ', 后增量修改了sm本身的类型: ' + typeof sm + ', sm =  ' + sm + '<br />');
    			document.write('sn = ' + sn + ', sn的类型: ' + typeof sn + ', sn++ = ' + sn++ + ', 后增量修改了sn本身的类型: ' + typeof sn + ', sn =  ' + sn + '<br />');
    			document.write('so = ' + so + ', so的类型: ' + typeof so + ', so++ = ' + so++ + ', 后增量修改了so本身的类型: ' + typeof so + ', so =  ' + so + '<br />');
    			document.write('sq = ' + sq + ', sq的类型: ' + typeof sq + ', sq++ = ' + sq++ + ', 后增量修改了sq本身的类型: ' + typeof sq + ', sq =  ' + sq + '<hr />');
    
    			document.write('后增量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', ua的类型: ' + typeof ua + ', ua++ = ' + ua++ + ', 后增量修改了ua本身的类型: ' + typeof ua + '<br />');
    			document.write('sb = ' + sb + ', sb的类型: ' + typeof sb + ', sb++ = ' + sb++ + ', 后增量修改了sb本身的类型: ' + typeof sb + '<br />');
    			document.write('sc = ' + sc + ', sc的类型: ' + typeof sc + ', sc++ = ' + sc++ + ', 后增量修改了sc本身的类型: ' + typeof sc + '<br />');
    			document.write('sf = ' + sf + ', sf的类型: ' + typeof sf + ', sf++ = ' + sf++ + ', 后增量修改了sf本身的类型: ' + typeof sf + '<br />');
    			document.write('ab = ' + ab + ', ab的类型: ' + typeof ab + ', ab++ = ' + ab++ + ', 后增量修改了ab本身的类型: ' + typeof ab + '<br />');
    			document.write('oa = ' + oa + ', oa的类型: ' + typeof oa + ', oa++ = ' + oa++ + ', 后增量修改了oa本身的类型: ' + typeof oa + '<br />');
    			document.write('ob = ' + ob + ', ob的类型: ' + typeof ob + ', ob++ = ' + ob++ + ', 后增量修改了ob本身的类型: ' + typeof ob + '<br />');
    			document.write('oc = ' + oc + ', oc的类型: ' + typeof oc + ', oc++ = ' + oc++ + ', 后增量修改了oc本身的类型: ' + typeof oc + '<br />');
    		</script>
    	</body>
    </html>

    4.13.2. 效果图

    5. 前减量/后减量运算符

    5.1. 同样, 前减量运算符是从数值上减1, 形式是在变量前放两个减号(--)。

    5.2. 后减量运算符也是从数值上减1, 形式为在变量后加两个减号(--)。

    5.3. 前减量发生在计算表达式之前; 后减量是在计算过包含它们的表达式后才进行减量。

    5.4. 前减量或后减量对数字减1; 数字对象转为原始数字并减1; 对NaN、Infinity和-Infinity无影响。

    5.5. 前减量或后减量把null转为数字0并减1。

    5.6. 前减量或后减量把空字符串(''和new String())转为数字0并减1。

    5.7. 前减量或后减量把空数组([]和new Array())转为数字0并减1。

    5.8. 前减量或后减量把true、new Boolean(true)转为数字1并减1, false、new Boolean(false)转为数字0并减1。

    5.9. 前减量或后减量把可完整转为数字的字符串转为数字并减1; 八进制的字符串忽略前导0, 然后按十进制转换并减1; 字符串NaN转为数字NaN。

    5.10. 前减量或后减量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象(new String())、可完整转为数字的字符串对象(new String('8'))、空数组对象([]和new Array())、布尔对象(new Boolean(true)和new Boolean(false))、数字对象(new Number()构造函数创建的数字对象))转为数字NaN。

    5.11. 减量运算符把运算数本身的类型都改成了数字类型。

    5.12. 减量例

    5.12.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>前减量运算符</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('前减量对数字减1; 数字对象转为原始数字并减1; 对NaN、Infinity和-Infinity无影响: <br />');
    			document.write('na = ' + na + ', na的类型: ' + typeof na + ', --na = ' + --na + '<br />');
    			document.write('nb = ' + nb + ', nb的类型: ' + typeof nb + ', --nb = ' + --nb + '<br />');
    			document.write('nc = ' + nc + ', nc的类型: ' + typeof nc + ', --nc = ' + --nc + '<br />');
    			document.write('nd = ' + nd + ', nd的类型: ' + typeof nd + ', --nd = ' + --nd + '<br />');
    			document.write('ne = ' + ne + ', ne的类型: ' + typeof ne + ', --ne = ' + --ne + '<br />');
    			document.write('nf = ' + nf + ', nf的类型: ' + typeof nf + ', --nf = ' + --nf + '<br />');
    			document.write('ng = ' + ng + ', ng的类型: ' + typeof ng + ', --ng = ' + --ng + '<br />');
    			document.write('nh = ' + nh + ', nh的类型: ' + typeof nh + ', --nh = ' + --nh + '<br />');
    			document.write('ni = ' + ni + ', ni的类型: ' + typeof ni + ', --ni = ' + --ni + '<br />');
    			document.write('nj = ' + nj + ', nj的类型: ' + typeof nj + ', --nj = ' + --nj + '<br />');
    			document.write('nk = ' + nk + ', nk的类型: ' + typeof nk + ', --nk = ' + --nk + '<br />');
    			document.write('nl = ' + nl + ', nl的类型: ' + typeof nl + ', --nl = ' + --nl + '<br />');
    			document.write('nm = ' + nm + ', nm的类型: ' + typeof nm + ', --nm = ' + --nm + ', 前减量修改了nm本身的类型: ' + typeof nm + '<hr />');
    
    			document.write('前减量把null转为数字0并减1: <br />');
    			document.write('la = ' + la + ', na的类型: ' + typeof la + ', --la = ' + --la + ', 前减量修改了na本身的类型: ' + typeof la + '<hr />');
    
    			document.write('前减量把空字符串(\'\'和new String())转为数字0并减1: <br />');
    			document.write('sa = ' + sa + ', sa的类型: ' + typeof sa + ', --sa = ' + --sa + ', 前减量修改了sa本身的类型: ' + typeof sa + '<br />');
    			document.write('sp = ' + sp + ', sp的类型: ' + typeof sp + ', --sp = ' + --sp + ', 前减量修改了sp本身的类型: ' + typeof sp + '<hr />');
    
    			document.write('前减量把空数组([]和new Array())转为数字0并减1: <br />');
    			document.write('aa = ' + aa + ', aa的类型: ' + typeof aa + ', --aa = ' + --aa + ', 前减量修改了aa本身的类型: ' + typeof aa + '<br />');
    			document.write('ac = ' + ac + ', ac的类型: ' + typeof ac + ', --ac = ' + --ac + ', 前减量修改了ac本身的类型: ' + typeof ac + '<hr />');
    
    			document.write('前减量把true、new Boolean(true)转为数字1并减1, false、new Boolean(false)转为数字0并减1: <br />');
    			document.write('ba = ' + ba + ', ba的类型: ' + typeof ba + ', --ba = ' + --ba + ', 前减量修改了ba本身的类型: ' + typeof ba + '<br />');
    			document.write('bb = ' + bb + ', bb的类型: ' + typeof bb + ', --bb = ' + --bb + ', 前减量修改了bb本身的类型: ' + typeof bb + '<br />');
    			document.write('bc = ' + bc + ', bc的类型: ' + typeof bc + ', --bc = ' + --bc + ', 前减量修改了bc本身的类型: ' + typeof bc + '<br />');
    			document.write('bd = ' + bd + ', bd的类型: ' + typeof bd + ', --bd = ' + --bd + ', 前减量修改了bd本身的类型: ' + typeof bd + '<hr />');
    
    			document.write('前减量把可完整转为数字的字符串转为数字并减1; 八进制的字符串忽略前导0, 然后按十进制转换并减1: <br />');
    			document.write('sd = ' + sd + ', sd的类型: ' + typeof sd + ', --sd = ' + --sd + ', 前减量修改了sd本身的类型: ' + typeof sd + '<br />');
    			document.write('se = ' + se + ', se的类型: ' + typeof se + ', --se = ' + --se + ', 前减量修改了se本身的类型: ' + typeof se + '<br />');
    			document.write('sg = ' + sg + ', sg的类型: ' + typeof sg + ', --sg = ' + --sg + ', 前减量修改了sg本身的类型: ' + typeof sg + '<br />');
    			document.write('sh = ' + sh + ', sh的类型: ' + typeof sh + ', --sh = ' + --sh + ', 前减量修改了sh本身的类型: ' + typeof sh + '<br />');
    			document.write('si = ' + si + ', si的类型: ' + typeof si + ', --si = ' + --si + ', 前减量修改了si本身的类型: ' + typeof si + '<br />');
    			document.write('sj = ' + sj + ', sj的类型: ' + typeof sj + ', --sj = ' + --sj + ', 前减量修改了sj本身的类型: ' + typeof sj + '<br />');
    			document.write('sk = ' + sk + ', sk的类型: ' + typeof sk + ', --sk = ' + --sk + ', 前减量修改了sk本身的类型: ' + typeof sk + '<br />');
    			document.write('sl = ' + sl + ', sl的类型: ' + typeof sl + ', --sl = ' + --sl + ', 前减量修改了sl本身的类型: ' + typeof sl + '<br />');
    			document.write('sm = ' + sm + ', sm的类型: ' + typeof sm + ', --sm = ' + --sm + ', 前减量修改了sm本身的类型: ' + typeof sm + '<br />');
    			document.write('sn = ' + sn + ', sn的类型: ' + typeof sn + ', --sn = ' + --sn + ', 前减量修改了sn本身的类型: ' + typeof sn + '<br />');
    			document.write('so = ' + so + ', so的类型: ' + typeof so + ', --so = ' + --so + ', 前减量修改了so本身的类型: ' + typeof so + '<br />');
    			document.write('sq = ' + sq + ', sq的类型: ' + typeof sq + ', --sq = ' + --sq + ', 前减量修改了sq本身的类型: ' + typeof sq + '<hr />');
    
    			document.write('前减量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', ua的类型: ' + typeof ua + ', --ua = ' + --ua + ', 前减量修改了ua本身的类型: ' + typeof ua + '<br />');
    			document.write('sb = ' + sb + ', sb的类型: ' + typeof sb + ', --sb = ' + --sb + ', 前减量修改了sb本身的类型: ' + typeof sb + '<br />');
    			document.write('sc = ' + sc + ', sc的类型: ' + typeof sc + ', --sc = ' + --sc + ', 前减量修改了sc本身的类型: ' + typeof sc + '<br />');
    			document.write('sf = ' + sf + ', sf的类型: ' + typeof sf + ', --sf = ' + --sf + ', 前减量修改了sf本身的类型: ' + typeof sf + '<br />');
    			document.write('ab = ' + ab + ', ab的类型: ' + typeof ab + ', --ab = ' + --ab + ', 前减量修改了ab本身的类型: ' + typeof ab + '<br />');
    			document.write('oa = ' + oa + ', oa的类型: ' + typeof oa + ', --oa = ' + --oa + ', 前减量修改了oa本身的类型: ' + typeof oa + '<br />');
    			document.write('ob = ' + ob + ', ob的类型: ' + typeof ob + ', --ob = ' + --ob + ', 前减量修改了ob本身的类型: ' + typeof ob + '<br />');
    			document.write('oc = ' + oc + ', oc的类型: ' + typeof oc + ', --oc = ' + --oc + ', 前减量修改了oc本身的类型: ' + typeof oc + '<br />');
    		</script>
    	</body>
    </html>

    5.12.2. 效果图

    5.13. 减量例

    5.13.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>后减量运算符</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var ua = undefined;
    			var la = null;
    			var ba = true, bb = false, bc = new Boolean(true), bd = new Boolean(false);
    			var na = 0, nb = 1, nc = -10, nd = 0x10, ne = 010, nf = +10, ng = 3.1415926, nh = 5e-324, ni = 1.7976931348623157e+308;
    			var nj = NaN, nk = Infinity, nl = -Infinity, nm = new Number(1000);
    			var sa = '', sb = '1abc', sc = 'ABC1', sd ='16', se = '3.1415926', sf = '3.14.15926', sg = '+10', sh = '-10', si = '0x10', sj = '010', sk = '5e-324';
    			var sl = '1.7976931348623157e+308', sm = 'Infinity', sn = '-Infinity', so = 'NaN', sp = new String(), sq = new String('8');
    			var aa = [], ab = ['高性能JavaScript'], ac = new Array();
    			var oa = {}, ob = {id: 1001, name: 'zhangsan'}, oc = new Object();
    
    			document.write('后减量对数字减1; 数字对象转为原始数字并减1; 对NaN、Infinity和-Infinity无影响: <br />');
    			document.write('na = ' + na + ', na的类型: ' + typeof na + ', na-- = ' + na-- + ', na = ' + na + '<br />');
    			document.write('nb = ' + nb + ', nb的类型: ' + typeof nb + ', nb-- = ' + nb-- + ', nb = ' + nb + '<br />');
    			document.write('nc = ' + nc + ', nc的类型: ' + typeof nc + ', nc-- = ' + nc-- + ', nc = ' + nc + '<br />');
    			document.write('nd = ' + nd + ', nd的类型: ' + typeof nd + ', nd-- = ' + nd-- + ', nd = ' + nd + '<br />');
    			document.write('ne = ' + ne + ', ne的类型: ' + typeof ne + ', ne-- = ' + ne-- + ', ne = ' + ne + '<br />');
    			document.write('nf = ' + nf + ', nf的类型: ' + typeof nf + ', nf-- = ' + nf-- + ', nf = ' + nf + '<br />');
    			document.write('ng = ' + ng + ', ng的类型: ' + typeof ng + ', ng-- = ' + ng-- + ', ng = ' + ng + '<br />');
    			document.write('nh = ' + nh + ', nh的类型: ' + typeof nh + ', nh-- = ' + nh-- + ', nh = ' + nh + '<br />');
    			document.write('ni = ' + ni + ', ni的类型: ' + typeof ni + ', ni-- = ' + ni-- + ', ni = ' + ni + '<br />');
    			document.write('nj = ' + nj + ', nj的类型: ' + typeof nj + ', nj-- = ' + nj-- + ', nj = ' + nj + '<br />');
    			document.write('nk = ' + nk + ', nk的类型: ' + typeof nk + ', nk-- = ' + nk-- + ', nk = ' + nk + '<br />');
    			document.write('nl = ' + nl + ', nl的类型: ' + typeof nl + ', nl-- = ' + nl-- + ', nl = ' + nl + '<br />');
    			document.write('nm = ' + nm + ', nm的类型: ' + typeof nm + ', nm-- = ' + nm-- + ', 后减量修改了nm本身的类型: ' + typeof nm + ', nm =  ' + nm + '<hr />');
    
    			document.write('后减量把null转为数字0并减1: <br />');
    			document.write('la = ' + la + ', na的类型: ' + typeof la + ', la-- = ' + la-- + ', 后减量修改了na本身的类型: ' + typeof la + ', la =  ' + la + '<hr />');
    
    			document.write('后减量把空字符串(\'\'和new String())转为数字0并减1: <br />');
    			document.write('sa = ' + sa + ', sa的类型: ' + typeof sa + ', sa-- = ' + sa-- + ', 后减量修改了sa本身的类型: ' + typeof sa + ', sa =  ' + sa + '<br />');
    			document.write('sp = ' + sp + ', sp的类型: ' + typeof sp + ', sp-- = ' + sp-- + ', 后减量修改了sp本身的类型: ' + typeof sp + ', sp =  ' + sp + '<hr />');
    
    			document.write('后减量把空数组([]和new Array())转为数字0并减1: <br />');
    			document.write('aa = ' + aa + ', aa的类型: ' + typeof aa + ', aa-- = ' + aa-- + ', 后减量修改了aa本身的类型: ' + typeof aa + ', aa =  ' + aa + '<br />');
    			document.write('ac = ' + ac + ', ac的类型: ' + typeof ac + ', ac-- = ' + ac-- + ', 后减量修改了ac本身的类型: ' + typeof ac + ', ac =  ' + ac + '<hr />');
    
    			document.write('后减量把true、new Boolean(true)转为数字1并减1, false、new Boolean(false)转为数字0并减1: <br />');
    			document.write('ba = ' + ba + ', ba的类型: ' + typeof ba + ', ba-- = ' + ba-- + ', 后减量修改了ba本身的类型: ' + typeof ba + ', ba =  ' + ba + '<br />');
    			document.write('bb = ' + bb + ', bb的类型: ' + typeof bb + ', bb-- = ' + bb-- + ', 后减量修改了bb本身的类型: ' + typeof bb + ', bb =  ' + bb + '<br />');
    			document.write('bc = ' + bc + ', bc的类型: ' + typeof bc + ', bc-- = ' + bc-- + ', 后减量修改了bc本身的类型: ' + typeof bc + ', bc =  ' + bc + '<br />');
    			document.write('bd = ' + bd + ', bd的类型: ' + typeof bd + ', bd-- = ' + bd-- + ', 后减量修改了bd本身的类型: ' + typeof bd + ', bd =  ' + bd + '<hr />');
    			
    			document.write('后减量把可完整转为数字的字符串转为数字并减1; 八进制的字符串忽略前导0, 然后按十进制转换并减1: <br />');
    			document.write('sd = ' + sd + ', sd的类型: ' + typeof sd + ', sd-- = ' + sd-- + ', 后减量修改了sd本身的类型: ' + typeof sd + ', sd =  ' + sd + '<br />');
    			document.write('se = ' + se + ', se的类型: ' + typeof se + ', se-- = ' + se-- + ', 后减量修改了se本身的类型: ' + typeof se + ', se =  ' + se + '<br />');
    			document.write('sg = ' + sg + ', sg的类型: ' + typeof sg + ', sg-- = ' + sg-- + ', 后减量修改了sg本身的类型: ' + typeof sg + ', sg =  ' + sg + '<br />');
    			document.write('sh = ' + sh + ', sh的类型: ' + typeof sh + ', sh-- = ' + sh-- + ', 后减量修改了sh本身的类型: ' + typeof sh + ', sh =  ' + sh + '<br />');
    			document.write('si = ' + si + ', si的类型: ' + typeof si + ', si-- = ' + si-- + ', 后减量修改了si本身的类型: ' + typeof si + ', si =  ' + si + '<br />');
    			document.write('sj = ' + sj + ', sj的类型: ' + typeof sj + ', sj-- = ' + sj-- + ', 后减量修改了sj本身的类型: ' + typeof sj + ', sj =  ' + sj + '<br />');
    			document.write('sk = ' + sk + ', sk的类型: ' + typeof sk + ', sk-- = ' + sk-- + ', 后减量修改了sk本身的类型: ' + typeof sk + ', sk =  ' + sk + '<br />');
    			document.write('sl = ' + sl + ', sl的类型: ' + typeof sl + ', sl-- = ' + sl-- + ', 后减量修改了sl本身的类型: ' + typeof sl + ', sl =  ' + sl + '<br />');
    			document.write('sm = ' + sm + ', sm的类型: ' + typeof sm + ', sm-- = ' + sm-- + ', 后减量修改了sm本身的类型: ' + typeof sm + ', sm =  ' + sm + '<br />');
    			document.write('sn = ' + sn + ', sn的类型: ' + typeof sn + ', sn-- = ' + sn-- + ', 后减量修改了sn本身的类型: ' + typeof sn + ', sn =  ' + sn + '<br />');
    			document.write('so = ' + so + ', so的类型: ' + typeof so + ', so-- = ' + so-- + ', 后减量修改了so本身的类型: ' + typeof so + ', so =  ' + so + '<br />');
    			document.write('sq = ' + sq + ', sq的类型: ' + typeof sq + ', sq-- = ' + sq-- + ', 后减量修改了sq本身的类型: ' + typeof sq + ', sq =  ' + sq + '<hr />');
    
    			document.write('后减量把undefined、不能完整转为数字的字符串、对象(不包括空字符串对象和空数组对象)转为数字NaN: <br />');
    			document.write('ua = ' + ua + ', ua的类型: ' + typeof ua + ', ua-- = ' + ua-- + ', 后减量修改了ua本身的类型: ' + typeof ua + '<br />');
    			document.write('sb = ' + sb + ', sb的类型: ' + typeof sb + ', sb-- = ' + sb-- + ', 后减量修改了sb本身的类型: ' + typeof sb + '<br />');
    			document.write('sc = ' + sc + ', sc的类型: ' + typeof sc + ', sc-- = ' + sc-- + ', 后减量修改了sc本身的类型: ' + typeof sc + '<br />');
    			document.write('sf = ' + sf + ', sf的类型: ' + typeof sf + ', sf-- = ' + sf-- + ', 后减量修改了sf本身的类型: ' + typeof sf + '<br />');
    			document.write('ab = ' + ab + ', ab的类型: ' + typeof ab + ', ab-- = ' + ab-- + ', 后减量修改了ab本身的类型: ' + typeof ab + '<br />');
    			document.write('oa = ' + oa + ', oa的类型: ' + typeof oa + ', oa-- = ' + oa-- + ', 后减量修改了oa本身的类型: ' + typeof oa + '<br />');
    			document.write('ob = ' + ob + ', ob的类型: ' + typeof ob + ', ob-- = ' + ob-- + ', 后减量修改了ob本身的类型: ' + typeof ob + '<br />');
    			document.write('oc = ' + oc + ', oc的类型: ' + typeof oc + ', oc-- = ' + oc-- + ', 后减量修改了oc本身的类型: ' + typeof oc + '<br />');
    		</script>
    	</body>
    </html>

    5.13.2. 效果图

    6. void运算符

    6.1. void运算符总是返回undefined。该运算符通常用于避免输出不应该输出的值。

    6.2. 从html的<a>元素调用JavaScript函数

    6.2.1. 从html的<a>元素调用JavaScript函数时, 函数不能返回有效值, 否则浏览器将清空页面, 只显示函数的结果:

    <a href="javascript:window.open('about:blank')">Click me</a>

    6.2.2. 如果把上面这行代码放入html页面, 点击其中的链接, 即可看到屏幕上显示"[object]"。这是因为window.open()方法返回了新打开的窗口的引用。然后该对象将被转换成要显示的字符串。

    6.2.3. 要避免这种效果, 可以用void运算符调用 window.open()函数:

    <a href="javascript:void(window.open('about:blank'))">Click me</a>

    6.2.4. 这使window.open()调用返回undefined, 它不是有效值, 不会显示在浏览器窗口中。

    6.3. 没有返回值的函数真正返回的都是undefined。

    6.4. 例

    6.4.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>void运算符</title>
    	</head>
    	<body>
    		<a href="javascript:window.open('about:blank');">Click me</a> 
    		<br /><br />
    		<a href="javascript:void(window.open('about:blank'));">Click me</a>
    	</body>
    </html>

    6.4.2. 效果图

    7. delete运算符

    7.1. delete操作符被设计用于对象属性。它对变量或函数没有影响。  
    7.2. delete关键词从对象中删除属性。
    7.3. delete关键词会同时删除属性的值和属性本身。删除完成后, 属性在被添加回来之前是无法使用的。
    7.4. delete操作符不应被用于预定义的JavaScript对象属性。这样做会使应用程序崩溃。

    7.3. 例

    7.3.1. 代码

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<head>
    		<meta charset="utf-8" />
    		<title>delete运算符</title>
    	</head>
    	<body>
    		<script type="text/javascript">
    			var o = {id: 100001, name: "David"};
    
    			for(var key in o){
    				document.write(key + " = " + o[key] + '<br />');
    			}
    			document.write('------------------------<br />');
    			
    			delete o.name;
    			for(var key in o){
    				document.write(key + " = " + o[key] + '<br />');
    			}
    		</script>
    	</body>
    </html>

    7.3.2. 效果图

    展开全文
  • js中的一元运算符

    2019-09-23 22:49:31
    一元运算符只有一个参数,即要操作的对象或值。它们是 ECMAScript 中最简单的运算符。 delete delete 运算符删除对以前定义的对象属性或方法的引用。例如: var o = new Object; o.name = "David"; alert(o....
  • 运算符有一元运算符、二元运算符及三元运算符。 一元运算符有1个操作数。例如,递增运算符"++“就是一元运算符。 二元运算符有2个操作数。例如,除法运算符”/“有2个操作数。 三元运算符有3个操作数。例如,条件...
  • 位移运算符: i<<N 运算符把i的所有位向左移N指定的位数,低位用0代替。 i>>N就是运算符把 i的所有位向右移 N指定的位数。i的符号位被用来填充右移后左边空出来的位。向右移出的位被丢弃。 i>&...
  • 今天我们将讨论一元运算符,即一元加(+)和一元减(-)运算符。 今天的很多资料都基于上一篇文章中的资料,因此如果您需要复习,请返回第 7 部分并再次阅读。请记住:重复是所有学习之母。 话虽如此,这就是你今天...
  • 一元运算符 + 表示正号 - 表示负号

    千次阅读 2015-04-09 22:05:01
    一元运算符包括 + - sizeof() ! ~ ++ -- 其中 + 表示正号; - 表示负号
  • ECMAScript运算符
  • 赋值,算术和一元运算符翻译自ORACLE Java Tutorials –Assignment, Arithmetic, and Unary Operators简单分配算子您将遇到的最常见的运算符之一是简单的赋值运算符“=”。你在自行车课上看到这个操作符它将其右侧的...
  • 一元运算符: 只能操作一个值得运算符. 递增++,递减-- 前置和后置的区别: 在没有赋值操作的时候,前置和后置是没有区别的. 存在赋值操作的时候: var box=100++; //box=100 var nox=--100;//box=99 其他...
  • JavaScript 一元运算符简介 JavaScript 中最简单的运算符是一元运算符一元运算符作用于一个操作数。JavaScript 中的一元运算符是: 一元加号 (+) – 将操作数转换为数字 一元减号 (-) – 将操作数转换为数字,...
  • 算术运算符 mul(self, other)定义乘法的行为: truediv(self, other)...divmod(a, b)把除数和余数运算结果结合起来,返回一个包含商和余数的元组(a // b, a % b)。 反算术运算符 radd(self, other)定义加法的行为:+
  • = 将等号右边的值赋予给左边, 要求左边必须是一个容器 其他赋值运算符: += -= *= /= %= 使用这些运算符可以在对变量赋值时进行快速操作 之前写法 赋值运算符写法 一元运算符 自增: 符号:++ 作用:让变量的值 ...
  • 一元运算符 The Unary Operators 一元运算符只需要一个operand;它们执行各种操作,例如将值增加/减少1,否定表达式或者将布尔值取反。 下面的程序UnaryDemo测试一元运算符: class UnaryDemo { public static void...
  • 一元运算符只有一个参数,即要操作的对象或值。它们是 ECMAScript 中最简单的运算符 delete delete 运算符删除对以前定义的对象属性或方法的引用。例如:var o = new Object; o.name = "David"; alert(o.name); //...
  • ECMAScript 一元运算符

    2009-08-06 03:06:00
    一元运算符只有一个参数,即要操作的对象或值。它们是 ECMAScript 中最简单的运算符。deletedelete 运算符删除对以前定义的对象属性或方法的引用。例如:var o = new Object;o.name = "David";alert(o.name); //输出...
  • 在这一小节中,我们来讨论一元运算符表达式的语义检查,与其相关的代码如图4.2.35所示。对于“前加加”和“前减减”运算符而言,我们采取的策略跟处理“后加加”和“后减减”一样,都是将--a转换为a -= 1,而将++a...
  • 5.一元运算符、逻辑运算符、赋值运算符、关系运算符、非波尔值的与或运算 一、一元运算符 代码示例如下: <!DOCTYPE html> <!-- * @Author: KylinYang * @Description: 一元运算符 * @Date: 2021-02-02 ...
  • 8.4.7:一元运算符

    2013-11-10 16:03:31
    一元运算符只对一个表达式执行操作,在SQL Server 2008中一元操作符包含+(正)、-(负)和~(位反)。+-可以用于数字数据类型的表达式,~只能用于整数数据类型的表达式。
  • C++运算符

    2017-11-16 23:01:53
    算术运算符中,一元运算符优先级最高,其次是乘法和除法,优先级最低的是加法和减法。C++的算术运算符都满足左结合律,意味着当优先级相同时,按照从左向右的顺序进行组合。 算术运算符的运算对象和求值结果都是右值...
  • Python中+(pos)一元运算符的目的是什么?一般来说,一元obj应该在Python中做什么?我问是因为到目前为止,我从未见过这样的情况:+obj != obj其中obj是实现+的通用对象。所以我想知道:为什么存在+和__pos__()? ...
  • MySQL详解之运算符

    2019-12-02 20:43:24
    一、运算符 算数运算符:加法+    减法-    乘法*    除法/    取余% 注意:除数非法时,返回结果为NULL。 比较运算符:左右...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,225
精华内容 9,690
关键字:

一元运算符包括