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/`;
}