# NodeJs

{
    "script":{
    	"dev":"node ./dev.js",
        "build":"node ./app.js"
    }
}

// 运行
npm run dev
npm run build

const ejs = require('ejs')
console.log(ejs)

{ cache:
   { _data: {},
     set: [Function: set],
     get: [Function: get],
     reset: [Function: reset] },
  fileLoader: [Function: readFileSync],
  localsName: 'locals',
  promiseImpl: [Function: Promise],
  resolveInclude: [Function],
  compile: [Function: compile],
  render: [Function],
  renderFile: [Function],
  clearCache: [Function],
  escapeXML: { [Function] toString: [Function] },
  __express: [Function],
  VERSION: '2.6.1',
  name: 'ejs' }

exports.render = function (template, d, o) {  
    var data = d || {};  
    var opts = o || {};  
  
    // No options object -- if there are optiony names  
    // in the data, copy them to options  
    if (arguments.length == 2) {  
      utils.shallowCopyFromList(opts, data, _OPTS);  
    }  
  
    // handleCache 缓存中有编译函数，获取编译函数；若无，通过文件名读取文件后，获得编译函数，并存入缓存  
    return handleCache(opts, template)(data);  
}; 

// template：ejs模板
// opts：参数配置对象
// 返回值：返回值可以是任何类型，并且返回值取决于opts.client和opts.async
exports.compile = function compile(template, opts) {
  var templ;

  // 旧版本的scope替换为contex
  if (opts && opts.scope) {
    if (!scopeOptionWarned){
      console.warn('`scope` option is deprecated and will be removed in EJS 3');
      scopeOptionWarned = true;
    }
    if (!opts.context) {
      opts.context = opts.scope;
    }
    delete opts.scope;
  }
  templ = new Template(template, opts);
  return templ.compile();
};

var _OPTS_PASSABLE_WITH_DATA = ['delimiter', 'scope', 'context', 'debug', 'compileDebug',
  'client', '_with', 'rmWhitespace', 'strict', 'filename', 'async'];

// 因为要兼容Express2，3，4各个版本，所以这里有2个，并且有render和renderFile2个方法
var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat('cache');

// 调用
// render方法
utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);

// renderFile方法
utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);

utils.js
// list以数组形式约定从from浅拷贝给to的属性名或方法名
exports.shallowCopyFromList = function (to, from, list) {
  for (var i = 0; i < list.length; i++) {
    var p = list[i];
    if (typeof from[p] != 'undefined') {
      to[p] = from[p];
    }
  }
  return to;
};

var _DEFAULT_DELIMITER = '%';
var _DEFAULT_LOCALS_NAME = 'locals';

// 配置项
function Template(text, opts) {
  opts = opts || {};
  var options = {};
  options.client = opts.client || false;
  options.escapeFunction = opts.escape || utils.escapeXML;
  options.compileDebug = opts.compileDebug !== false;
  options.debug = !!opts.debug;
  options.filename = opts.filename;
  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
  options.strict = opts.strict || false;
  options.context = opts.context;
  options.cache = opts.cache || false;
  options.rmWhitespace = opts.rmWhitespace;
  options.root = opts.root;
  options.outputFunctionName = opts.outputFunctionName;
  options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
  options.views = opts.views;
  options.async = opts.async;

  if (options.strict) {
    options._with = false;
  }
  else {
    options._with = typeof opts._with != 'undefined' ? opts._with : true;
  }

  this.opts = options;

  this.regex = this.createRegex();
}

// 源码实现
var _NAME = 'ejs';
exports.name = _NAME;

// 源码实现
// 最终导出的版本是在package.json中定义的version字段
var _VERSION_STRING = require('../package.json').version字段;
exports.VERSION = _VERSION_STRING;

exports.cache = {
  _data: {},
  set: function (key, val) {
    this._data[key] = val;
  },
  get: function (key) {
    return this._data[key];
  },
  reset: function () {
    this._data = {};
  }
};

var fs = require('fs');
exports.fileLoader = fs.readFileSync

// 获取子模板的绝对路径  
// 当前模板设置filename文件或目录路径，name传参为相对filename目录的文件路径 
exports.resolveInclude = function(name, filename, isDir) {
  var dirname = path.dirname;
  var extname = path.extname;
  var resolve = path.resolve;
  var includePath = resolve(isDir ? filename : dirname(filename), name);
  var ext = extname(name);
  if (!ext) {
    includePath += '.ejs';
  }
  return includePath;
};

/** 
 * 通过模板路径和模板数据获取编译结果，并执行回调 
 * @param {String}            filename  模板路径 
 * @param {Object}            [data={}] 模板数据 
 * @param {Options}           [opts={}] 编译配置 
 * @param {RenderFileCallback} cb 回调函数 
 */  
exports.renderFile = function () {
  var args = Array.prototype.slice.call(arguments);
  var filename = args.shift();
  var cb;
  var opts = {filename: filename};
  var data;
  var viewOpts;

  // Do we have a callback?
  if (typeof arguments[arguments.length - 1] == 'function') {
    cb = args.pop();
  }
  // Do we have data/opts?
  if (args.length) {
    // Should always have data obj
    data = args.shift();
    // Normal passed opts (data obj + opts obj)
    if (args.length) {
      // Use shallowCopy so we don't pollute passed in opts obj with new vals
      utils.shallowCopy(opts, args.pop());
    }
    // Special casing for Express (settings + opts-in-data)
    else {
      // Express 3 and 4
      if (data.settings) {
        // Pull a few things from known locations
        if (data.settings.views) {
          opts.views = data.settings.views;
        }
        if (data.settings['view cache']) {
          opts.cache = true;
        }
        // Undocumented after Express 2, but still usable, esp. for
        // items that are unsafe to be passed along with data, like `root`
        viewOpts = data.settings['view options'];
        if (viewOpts) {
          utils.shallowCopy(opts, viewOpts);
        }
      }
      // Express 2 and lower, values set in app.locals, or people who just
      // want to pass options in their data. NOTE: These values will override
      // anything previously set in settings  or settings['view options']
      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
    }
    opts.filename = filename;
  }
  else {
    data = {};
  }

  return tryHandleCache(opts, data, cb);
};

// 通过模板路径和模板数据获取编译结果，并执行回调
exports.__express = exports.renderFile;

// 清空模板编译函数
exports.clearCache = function () {
  // 清除缓存
  exports.cache.reset();
};

// ejs.js
exports.escapeXML = utils.escapeXML;

// utils.js
// html转义  
exports.escapeXML = function (markup) {  
    return markup == undefined ? '' : String(markup).replace(_MATCH_HTML, encode_char);  
};  
// 函数转化成字符串时，同时将参数变量全部转化为字符串输入  
exports.escapeXML.toString = function () {  
    return Function.prototype.toString.call(this) + ';\n' + escapeFuncStr;  
};

// 和renderFile相关
// 通过模板路径和模板数据获取编译结果，并执行回调
exports.__express = exports.renderFile;

const express = require('express')
const path = require('path')

const app = express()

// 指定模板文件存放位置
app.set('views', path.join(__dirname,'views'))
app.engine('html', require('ejs').renderFile)
// 设置默认的模板引擎
// 第二个参数如果是html，render的时候，html文件就不用添加扩展名
// 第二个参数如果是ejs，render的时候，ejs文件就不用添加扩展名
// 注意：如果render的时候，文件添加了后缀名，都是可以渲染的
// app.set('view engine', 'html')
app.set('view engine', 'ejs')

// 路由
app.get('/ejs',function(req,res){
    // 返回res.render渲染的模板文件
    res.render('index.ejs',{name:'小峰哥ejs'})
})

app.get('/html',function(req,res){
    res.render('admin.html',{name:'小峰哥html'})
})

app.listen('8080',function(){
    console.log('服务器已启动，端口号：8080')
})

// 遍历打印 process.argv
process.argv.forEach((val, index) => {
  console.log(`${index}: ${val}`);
});

node process-args.js one two=three four

0: /usr/local/bin/node
1: /Users/mjr/work/node/process-args.js
2: one
3: two=three
4: four