js的細小知識點

熟悉module的概念

"use strcit"; var M = module.exports = {}; M.onCreate = function(){}; M.onDestroy = function(){};

通過閉包，實現全局唯一的ID設計；

  var createID = function(id){
      var now = new Date().valueOf();
      if(id) now = id + '-' + now;
      var i = 0;
      return function(){
          ++i
          return now + '_' + i;
      };
  }
  exports.createWid = createID();

Object使用

1. assign
   涉及到一個深拷貝和淺拷貝的概念。
   javascript中存儲對象都是存地址的，所以淺拷貝是都指向同一塊內存區塊，而深拷貝則是另外開闢了一塊區域。
   既可以copy又可以merge。
   Object.assign() 只是一級屬性複製，比淺拷貝多深拷貝了一層而已。用的時候，還是要注意這個問題的。

     var a = Object.assign(this, obj); // obj的屬性融合到this上。並且返回一個對象；
   

   
   if (!Object.assign) {
       // 定義assign方法
     Object.defineProperty(Object, 'assign', {
       enumerable: false,
       configurable: true,
       writable: true,
       value: function(target) { // assign方法的第一個參數
         'use strict';
         // 第一個參數爲空，則拋錯
         if (target === undefined || target === null) {
           throw new TypeError('Cannot convert first argument to object');
         }
   
         var to = Object(target);
         // 遍歷剩餘所有參數
         for (var i = 1; i < arguments.length; i++) {
           var nextSource = arguments[i];
           // 參數爲空，則跳過，繼續下一個
           if (nextSource === undefined || nextSource === null) {
             continue;
           }
           nextSource = Object(nextSource);
   
           // 獲取改參數的所有key值，並遍歷
           var keysArray = Object.keys(nextSource);
           for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
             var nextKey = keysArray[nextIndex];
             var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
             // 如果不爲空且可枚舉，則直接淺拷貝賦值
             if (desc !== undefined && desc.enumerable) {
               to[nextKey] = nextSource[nextKey];
             }
           }
         }
         return to;
       }
     });
   }

2. JSON.stringify 和JSON.parse ,簡單實現深拷貝的方法，如下：

   javascript
const obj1 = JSON.parse(JSON.stringify(obj));


3. Object.defineProperty
   存取器描述.當使用存取器描述屬性的特性的時候，允許設置以下特性屬性：

   var obj = {};
   Object.defineProperty(obj,"newKey",{
       get:function (){} | undefined,
       set:function (value){} | undefined
       configurable: true | false
       enumerable: true | false
   });

   var a = {};
   a._name ="default";
   Object.defineProperty(a,"name",{
   
       get:function(){
           return a._name;
       },
       set:function(v){
           a._name = v;
       },
       configurable :true,
       enumerabele:true
   })
   a.name = "shit";
   
   
   var desc = Object.getOwnPropertyDescriptor(a,"name");
   console.log(desc);
   

注意：get或set不是必須成對出現，任寫其一就可以。如果不設置方法，則get和set的默認值爲undefined.
當使用了getter或setter方法，不允許使用writable和value這兩個屬性

讓一個函數聲明語句變成一個表達式

任何消除函數聲明和函數表達式間歧義的方法，都可以被解析器正確識別。

var i = function(){return 10}();        // undefined
1 && function(){return true}();        // true
1, function(){alert('iifksp')}();        // undefined

// 一元運算都是有效的：
!function(){alert('iifksp')}()        // true
+function(){alert('iifksp')}()        // NaN
-function(){alert('iifksp')}()        // NaN
~function(){alert('iifksp')}()        // -1

// 甚至下面這些關鍵字，都能很好的工作：
void function(){alert('iifksp')}()        // undefined
new function(){alert('iifksp')}()        // Object
delete function(){alert('iifksp')}()        // true

// 無論括號括在聲明上還是把整個函數都括在裏面，都是合法的：
(function(){alert('iifksp')})()        // undefined
(function(){alert('iifksp')}())        // undefined

正則表達式是描述字符模式的對象。

聲明一個RegExp 對象如/pattern/modifiers
其中modifiers是修飾符描述

i   執行對大小寫不敏感的匹配。
g   執行全局匹配（查找所有匹配而非在找到第一個匹配後停止）。
m   執行多行匹配。

var c = "I am a string"
var spaceReg = /\s/i;
var bracketReg = /["'`]/i;
// test is hes method
var result = spaceReg.test(c);
console.log(result);

Date的一種方法

 var now = new Date().valueOf() // 1504426009506
 var now = new Date() // Sun Sep 03 2017 16:06:59 GMT+0800 (CST)

函數的arguments：類數組對象

"use strict";

var f = function(a,b){
    console.log(arguments);
    var arg = [].slice.call(arguments);
    console.log(arg);
}
f(1,2);

// { '0': 1, '1': 2 }類數組對象
// [ 1, 2 ]

函數關鍵點

1. 函數是功能完整的類。
2. 函數名是指向函數對象的引用值。用Function來創建函數，比傳統方式慢得多，但所有函數都是Function類的實例

// var functionName = new Function(arg1,…,argn,functionBody);

// 匿名函數
var a = function(name){
    console.log("hi %s",name);
}

// 函數名爲b
function b(name){
    console.log("hi %s",name);
}

// 匿名函數

var c = new Function("name","console.log(\"hi %s\",name)");
a("Tim");
b("Brook");
c("Trace");
console.log(b.valueOf(),b instanceof Function);
console.log(a.valueOf(),a instanceof Function);
console.log(c.valueOf(),c instanceof Function);
console.log(c.toString());

// hi Tim
// hi Brook
// hi Trace
// [Function] true
// [Function: b] true
// [Function] true
// function anonymous(name
// /**/) {
// console.log("hi %s",name)
// }

require一個目錄

1. 目錄下有package.json文件，則標識該目錄下的一個主模塊，例如：require 就會嘗試加載”./path/to/main/file”這個文件。

{
  "name":"name for the folder or module",
  "main":"./path/to/main/file"
}

1. 如果沒有package.json文件，node將試圖從這個目錄下加載index.js或index.node文件。

一般index.js文件是這個模塊的集中控制模塊，會引入模塊內的文件；

"use strict";

module.exports = {
    moduleA: require("./moduleA"),
    ViewModel: require("./viewModel")
};

path resolve操作

把它作爲一個shell的cd命令，從文件所在目錄cd 過去，得到的pwd路徑就是函數返回的路徑。

get viewPath() {
    let dirPath = path.dirname(path.resolve("./index.js"));
    return `${__dirname}${dirPath}src/views/`;
}