[笔记]JavaScript入门啦

参考资料:
ECMAScript 6 入门:
http://es6.ruanyifeng.com/

以下所有代码示例均为在nodejs交互模式下进行的,环境:Linux

  • JavaScript不区分整数和浮点数,统一用Number表示;
  • js注释

    1
    2
    3
    4
    5
    // 注释

    /*
    注释
    */
  • js等号比较运算符

    1
    2
    3
    == // 会自动转换数据类型再比较,很多时候会得到非常诡异的结果

    === // 不会自动转换数据类型,如果数据类型不一致,直接返回false,一致的话再比较
  • 实际时常用===而不用==

  • 使用isNaN()函数判断是否为NaN
  • 浮点数运算有误差
  • %求余运算
  • node交互模式中,_表示上一次语句执行成功后的结果
  • null不等于0也不等于''

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    > null == 0
    false
    > null === 0
    false
    > null == ''
    false
    > null === ''
    false
    > null == null
    true
    > null === null
    true
    > 0 == ''
    true
    > 0 === ''
    false
  • js中还有一个特殊的元素undefined

    1
    2
    > undefined === undefined
    true
  • js中var与不加var的区别:https://www.cnblogs.com/liuna/p/6140901.html

  • js中typeof关键字的使用:https://blog.csdn.net/z18842589113/article/details/53315910
  • typeof运算符把类型信息当作字符串返回

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    > i = 1
    1
    > typeof(i)
    'number'

    > i = "imlk"
    'imlk'
    > typeof(i)
    'string'

    > i = true
    true
    > typeof(i)
    'boolean'

    > typeof(this)
    'object'

    > i = function(){
    ... this.console.log("imlk");
    ... }
    [Function: i]
    > typeof(i)
    'function'
  • Javascript的delete与C++不同,它不会删除i指向的对象,而是删除i这个属性本身。

  • Javascript中的对象都有一个方法toString()
  • 对类型为Function的对象执行toString()方法将打印函数的内容。

    1
    2
    3
    4
    5
    6
    7
    8
    > i = function(e){
    ... console.log(e)
    ... }
    [Function: i]
    > i
    [Function: i]
    > i.toString()
    'function (e){\nconsole.log(e)\n}'
  • js中的函数对象本身代表一个函数

  • js中构造一个函数对象(函数)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    > function f1(){};
    undefined
    > var f2 = function(){};
    undefined
    > var f3 = new Function('str','console.log(str)');//anonymous匿名函数
    undefined

    > f1
    [Function: f1]
    > f2
    [Function: f2]
    > f3
    [Function: anonymous]

    > f1.toString()
    'function f1(){}'
    > f2.toString()
    'function (){}'
    > f3.toString()
    'function anonymous(str\n/*``*/) {\nconsole.log(str)\n}'

    > f1.name
    'f1'
    > f2.name
    'f2'
    > f3.name
    'anonymous'

    > f1.prototype
    f1 {}
    > f2.prototype
    f2 {}
    > f3.prototype
    anonymous {}
  • JS所有内置对象属性和方法汇总:https://segmentfault.com/a/1190000011467723

  • JavaScript 的 valueOf() 方法,返回对象原始值

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    > b = new Boolean(true)
    [Boolean: true]
    > typeof b
    'object'
    > b.valueOf()
    true
    > typeof b.valueOf()
    'boolean'

    > s = new String('imlk')
    [String: 'imlk']
    > typeof s
    'object'
    > s.valueOf()
    'imlk'
    > typeof s.valueOf()
    'string'

    > n = new Number(2333)
    [Number: 2333]
    > typeof n
    'object'
    > n.valueOf()
    2333
    > typeof n.valueOf()
    'number'
    ......
  • valueOf()之相反的则是new Object(obj),它将原始值转化为对应的对象

    1
    2
    3
    4
    5
    6
    7
    8
    > a = 1;
    1
    > b = new Object(a)
    [Number: 1]
    > a == b
    true
    > a === b
    false
  • js中没有类

  • js中创建对象的7种方式:http://www.jb51.net/article/106325.htm
    1.工厂模式(在函数中构造对象并返回)
    2.构造函数模式(对函数使用new操作符,生成的对象的constructor属性指向构造函数)
    3.原型模式(每一个函数都有一个prototype(原型)属性,它指向一个对象,可以理解为共享的一个对象,这个对象是与构造函数挂钩的,所有实例共享它所包含的属性和方法,注意此时所有生成的对象所访问的原型中定义的对象都是同一个东西)
    4.组合使用构造函数模式和原型模式
    5.动态原型模式
    6.寄生构造函数模式
    7.稳妥构造函数模式
  • js中的对象,我们可以把ECMAScript的对象想象成散列表:无非就是一组名对值,其中值可以是数据或函数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > b = {'one': 'emmm','t':23333}
    { one: 'emmm', t: 23333 }
    > for (var key in b){
    ... console.log(key);
    ... console.log(b[key]);
    ... }
    one
    emmm
    t
    23333
    undefined
  • js的函数中有一个特殊的关键字arguments,因此可以支持可变长参数传递,这个arguments变量只可在函数中使用,是一个特殊的对象,与一个普通的对象相比,可以读取arguments.length属性

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > f1 = function(e){
    ... console.log(typeof arguments);
    ... console.log(arguments.length);
    ... console.log(arguments);
    ... }
    [Function: f1]
    > f1(1,2);
    object
    2
    { '0': 1, '1': 2 }
    undefined
  • js中的instanceof关键字

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    > c = new f1(1,2);
    object
    2
    { '0': 1, '1': 2 }
    f1 {}
    > c.constructor
    [Function: f1]
    > c.constructor === f1
    true
    > c instanceof f1
    true
  • exports 和 module.exports 的区别
    http://cnodejs.org/topic/5231a630101e574521e45ef8

    1
    2
    3
    module.exports 初始值为一个空对象 {}
    exports 是指向的 module.exports 的引用
    require() 返回的是 module.exports 而不是 exports
  • exports 快捷方式
    http://nodejs.cn/api/modules.html#modules_exports_shortcut
    exports变量是在模块的文件级别作用域内有效的,它在模块被执行前被赋予module.exports的值。

  • js定义常量语法糖const { PI }
    https://segmentfault.com/q/1010000011190967

    1
    2
    3
    const { PI } = Math;
    实际上是语法糖,等价于:
    const PI = Math.PI
  • js模块包装器
    http://nodejs.cn/api/modules.html#modules_the_module_wrapper
    在执行模块代码之前,Node.js 会使用一个如下的函数包装器将其包装:

    1
    2
    3
    (function(exports, require, module, __filename, __dirname) {
    // 模块的代码实际上在这里
    });
  • export
    模块是独立的文件,该文件内部的所有的变量外部都无法获取。如果希望获取某个变量,必须通过export输出,

    1
    2
    3
    export var firstName = 'Michael';
    export var lastName = 'Jackson';
    export var year = 1958;