重温JS基础--引用类型(二)

摘要：创建一个日期对象中国标准时间在调用构造函数而不传参数的情况下，新创建的对象自动获得当前日期和时间。日期格式化方法类型还有一些专门用于将日期格式化为字符串的方法中国标准时间下午以上的这些方法都会根据系统环境而异。

咱们接着上面一篇继续~

JavaScript中的Date类型使用自UTC时间，1970年1月1日零时开始的毫秒数来保存日期。
创建一个日期对象：

var now = new Date()
console.log(now) //Fri Sep 22 2017 15:42:29 GMT+0800 (中国标准时间)

在调用Date构造函数而不传参数的情况下，新创建的对象自动获得当前日期和时间。

如果想根据特定的日期和时间创建日期对象，必须传入表示日期的毫秒数（即从UTC时间开始截止到当前的毫秒数）。

var d = new Date(2165461213546)
console.log(d) //Sun Aug 15 2038 13:00:13 GMT+0800 (中国标准时间)

Date.parse() 、 Date.UTC()
还有一些简化的方法：Date.parse() 和 Date.UTC()。其中Date.parse()方法接受一个表示日期的字符串参数，然后尝试根据这个字符串返回相应日期的毫秒数。（但是在JavaScript中并没有规定传入改方法的参数的格式）：

Date.parse()通常有以下几种格式的参数：
1."月/年/日"， 如：6/12/2017
2."英文月名 日，年"，如：January 12,2004
3."英文星期几 英文月名 日 年 时:分:秒 时区"，如Tue May 25 2004 00:00:00 GMT-0700

var some = new Date(Date.parse("May 25, 2004"))
console.log(some) //Tue May 25 2004 00:00:00 GMT+0800 (中国标准时间)

//其实这样写也是可以的，它在内部会先调用Date.parse()方法
var someDate = new Date("May 25, 2004"); 

Date.UTC()方法同样也是返回表示日期的毫秒数，它和Date.parse()在构建值时使用不同的信息。Date.UTC()接受的参数分别是年份，基于0的月份，月中的哪一天，小时数，分钟，秒，毫秒。在这些参数中，前两个参数是必填的。如果没有提供月中的日期数，则会默认为1，如果省略其他数，则都假设为0.

var y2k = new Date(Date.UTC(2000, 0))
console.log(y2k) //Sat Jan 01 2000 08:00:00 GMT+0800 (中国标准时间)

//其实这样写也是可以的.
var d = new Date(2000, 0)
var d1 = new Date(2005,4,5,17,55,55)
以上代码创建的日期对象，只不过这次的日期对象是基于系统设置的be

Date.now()
该方法可以获取当前日期和时间的毫秒数：

var start = Date.now() //获取开始时间

do() //做些啥

var stop = Date.now() //获取结束时间

如果某些浏览器不支持的话，我们可以通过以下技巧获得当前时间的毫秒数,就是在前面加一个‘+’：

var s = +new Date()
console.log(s) //1506069877901

继承的方法
这里说下继承自Object的三个方法，toLocalString, toString, valueOf：

var d = new Date()
d.toLocaleString() //"2017/9/22 下午4:49:43"
d.toString() //"Fri Sep 22 2017 16:49:43 GMT+0800 (中国标准时间)"
d.valueOf() //1506070183078

稍微下他们之间的区别，主要valueOf返回的是时间对象的毫秒数。

日期格式化方法
Date类型还有一些专门用于将日期格式化为字符串的方法：

var d = new Date()
d.toDateString()  //"Fri Sep 22 2017"
d.toTimeString() //"17:02:27 GMT+0800 (中国标准时间)"
d.toLocaleDateString() //"2017/9/22"
d.toLocaleTimeString() //"下午5:02:27"
d.toUTCString() //"Fri, 22 Sep 2017 09:02:27 GMT"

以上的这些方法都会根据系统环境而异。

日期/时间组件方法
下面介绍一下Date对象提供的一些方法，可以取得和设置日期值中特定部分的方法。

var d = new Date()

1. 获取日期的毫秒数，和valueOf方法返回的值相同。
d.getTime() //1506071307006

2. 通过毫秒设置日期，会改变当前的日期对象。
d.setTime(1213123)
console.log(d) //Thu Jan 01 1970 08:20:13 GMT+0800 (中国标准时间)

3. 获取4位数的年份
d.getFullYear() // 1970

4. 返回UTC日期的4位数年份
d.getUTCFullYear() //1970

5. 返回日期中的月份，从0开始算起
d.getMonth() // 8

6. 返回UTC日期中的月份，从0开始算起
d.getUTCMonth() //8

7. 返回日期月份中的天数， 如果传入的值超过了该月应有的天数，则增加月份
d.getDate() // 22

8. 返回UTC日期月份中的天数， 如果传入的值超过了该月应有的天数，则增加月份
d.getUTCDate() // 22

9. 返回日期中星期的星期几（0表示星期天，6表示星期6）
d.getDay() //6

10. 返回UTC中的日期中的星期几（0表示星期天，6表示星期6）
d.getUTCDay() //1

11.返回日期中的小时数(0~23)，传入的值超过23则增加月份中的天数
d.getHours() // 9

12. 返回UTC日期中的小时数(0~23)，传入的值超过23则增加月份中的天数
d.getUTCHours()

13. 返回日期中的分钟数(0~59),也可以进行设置。
d.getMinutes()

14. 返回UTC中日期的分钟数,也可以进行设置。
d.getUTCMinutes()

15. 返回日期中的秒数0~59，也可以进行设置。
d.getSeconds()

16. 返回日期对象中UTC的秒数
d.getUTCSeconds()

17. 返回日期中的毫秒数,也可以进行设置
d.getMilliseconds()

在JavaScript中，函数其实就是一个对象，每个函数都是Function类型的实例，而且和其他引用类型一样具有属性和方法。
因为函数是一个对象，所以函数名其实是一个指向函数对象的指针，不会与某个函数绑定。
定义函数有两种方法：函数声明和函数表达式。

function fn(){ ... }

var fn = function() { ... };

还有一种方法就是通过Function构造函数。Function构造函数可以接受任意数量的参数，但最后一个参数始终都是被看成函数体。前面的额参数则枚举新函数的参数。

var fn = new Function("num1", "num2", "return num1+num2")

从技术的角度来说，这是一个函数表达式。但是最佳实践中并不推荐使用这种方法，因为这种方法会导致解析两次代码。第一次是正常的解析，第二次是解析传入构造函数中的字符串。
由于函数名是一个指针，所以函数可能会具有多个函数名：

function fn() {console.log(123)}
var fn1 = fn

如果以下操作还可以继续访问:
fn = null
fn1() // 123

没有重载
先看一个例子：

fucntion add (num){
    return num + 100
}

function add (num) {
    return num + 200
}
console.log(add(100)) // 300

然后改写下上面的例子：

var add = function(num) {
    return num + 100
}

add = function (num) {
    return num + 200
}
add(100) //300

函数表达式和函数声明
之前说过创建函数的方法有两种，函数声明和函数表达式，我们来看下他们之间的区别。

js引擎在解析的时候会先读取函数声明，并使其在执行任何代码之前可以访问。因为在代码执行之前，解析器就已经通过一个函数声明提升的过程，读取并将函数声明添加到执行环境中。对代码求值时，JavaScript引擎会在第一遍声明函数，并将它们放到源代码树的顶部。

函数表达式，必须等解析器执行到它所在的代码行，才会真正的被解释执行：

console.log(fn(10, 10)) // error "fn is not a function"

var fn = function(a, b) {
    return a + b
}

以上代码会报错，因为在函数位于一个初始化语句中。而不是一个函数声明。换句话说，在执行到函数所在的语句之前，变量fn是不会保存对函数的引用。而且由于第一行已经报错了，代码也不会继续向下执行。

作为值的函数
JavaScript中，函数名本身也是一个变量，所以函数可以作为值来使用。所以函数可以作为另外一个函数的参数，而且可以将一个函数作为另外一个函数的结果进行返回。

function callSomeFn(fn, arg) {
    return fn(arg)
}

如上，这个函数接受两个参数，第一个参数应该是一个函数，第二个参数是要传递给函数的一个值。然后，就可以如下：

function add(num) {
    return num+10
}
var res = callSomeFn(fn, 10)
console.log(res) //20

function greet (name) {
    return "hello" + name
}
var res = callSomeFn(greet, "world")
console.log(res) //"hello world"

而且，我们可以在一个函数中返回另外一个函数,如下我们通过函数创建另外一个函数然后返回：

function create(proName) {
    return function (obj1, obj2) {
        var val1 = obj1[proName]
        var val2 = obj[proName]
        
        if(val1 < val2) {
            return -1
        }else if(val1 > val2) {
            return 1
        }else {
            return 0
        }
    }
}

函数内部属性

callee
在函数内部，有两个特殊的对象：arguments和this。arguments是一个类数组的对象，它包含传入函数中的所有参数。该对象还有一个callee的属性，该属性是一个指针,指向的是拥有这个arguments对象的函数。

function factor(num) {
    if(num <= 1) {
        return 1
    }else{
        return num * factor(num - 1)
    }
}

如上是一个递归函数，通过callee可以改写成下面这样：

function factor(num) {
    if(num < 1) {
        return 1
    }else{
        return num * argument.callee(num - 1)
    }
}

this
函数内部的另一个特殊对象是this，this引用的是函数当前执行的环境对象。this是在函数调用的时候进行绑定的。完全取决于函数的调用位置。

当某个函数在全局作用域中定义的，当在全局作用域中调用改函数时，this引用的是全局对象window.

var a = 12
function b() {
    console.log(this.a)
}
b() //12

在理解this的绑定过程之前，我们了解一下调用位置，调用位置表示的是函数所被调用的位置，而不是其声明的位置。

如何知道函数的调用位置，最重要的是分析函数的调用栈（即为了到达当前执行位置所调用的所有函数）。那么调用位置就是当前正在执行函数的前一个调用中。

function baz() {
  //当前的调用栈是baz
  //当前的调用位置是全局作用域，即当前调用栈的前一个调用
  console.log("baz");
  bar();
}

function bar() {
  //当前调用栈是 baz-->bar
  //当前的调用位置是：baz
  console.log("bar");
  foo();
}

function foo() {
  //当前的调用栈是baz --> bar --> foo
  //当前调用位置是bar
}

baz(); //<-- baz的调用位置就是全局作用域

caller
另外一个函数对象的属性是：caller.该属性保存着调用当前函数的函数引用。如果在全局作用域中调用当前函数，它的值为null。

function outer() {
    inner()
}
function inner() {
    console.log(inner.caller)
}
outer()

函数属性和方法
前面说过函数也是一个对象，所以函数也是有属性和方法的。每个函数都包含两个属性：length和prototype.其中length属性表示函数接受命名参数的个数。

funtion setName(name) {
    console.log(name)
}
function sun(s1, s2){
    //...
}
console.log(setName.length) // 1
console.log(sun.length) //2

再说下prototype属性，它是保存所有实例方法的真正所在。

再说下apply()和call()。这两个方法的用途都是在特定的作用域中调用函数，实际上等于设置函数体内this对象的值。它们是每个函数都具有的非继承而来的方法。
apply()接受两个参数，一个是在其中运行函数的作用域，另一个是参数数组。其中第二个参数可以是Array实例，也可以是arguments对象。
call()和apply()相同，它们的区别仅在于接受参数的方式不同。call()第一个参数是this的指向，其余的参数都是直接传递给函数。

--本篇记录不是一次性写完，中间有很多事情耽搁了，零零散散的感觉没有什么逻辑，随便看看了各位~