node.js中express-session配置項(xiàng)詳解

var Cookie = module.exports = function Cookie(options) { 
 this.path = '/'; 
 this.maxAge = null; 
 this.httpOnly = true; 
 if (options) merge(this, options); 
 this.originalMaxAge = undefined == this.originalMaxAge 
  ? this.maxAge 
  : this.originalMaxAge; 
 //默認(rèn)的originalMaxAge就是this.maxAge也就是null,如果指定了originalMaxAge那么就是用戶指定的值 
}; 

app.use(session({ 
  genid: function(req) { 
   return genuuid() // use UUIDs for session IDs  
  }, 
  secret: 'keyboard cat' 
 }) 

function generateSessionId(sess) { 
 return uid(24); 
} 
 var generateId = options.genid || generateSessionId;

//如果用戶沒有傳入genid參數(shù)那么就是默認(rèn)使用generateSessionId函數(shù)來完成 

name = options.name || options.key || 'connect.sid'
  //很顯然cookie的name默認(rèn)是connect.sid，而且首先獲取到的name而不是key 
r cookieId = req.sessionID = getcookie(req, name, secrets); 

var resaveSession = options.resave; 
 if (resaveSession === undefined) { 
  deprecate('undefined resave option; provide resave option'); 
  resaveSession = true;//如果用戶沒有指定resavedSession那么默認(rèn)就是true 
 } 

 store.get(req.sessionID, function(err, sess){ 
   // error handling 
   //如果報(bào)錯(cuò)那么也會(huì)創(chuàng)建一個(gè)session 
   if (err) { 
    debug('error %j', err); 
    if (err.code !== 'ENOENT') { 
     next(err); 
     return; 
    } 
    generate(); 
   // no session那么就會(huì)創(chuàng)建一個(gè)session 
   } else if (!sess) { 
    debug('no session found'); 
    generate(); 
   // populate req.session 
   //如果找到了這個(gè)session處理的代碼邏輯 
   } else { 
    debug('session found'); 
    store.createSession(req, sess); 
    originalId = req.sessionID; 
    originalHash = hash(sess); 
    //originalHash保存的是找到的這個(gè)session的hash結(jié)果，如果明確指定了resave為false那么savedHash就是原來的session的結(jié)果 
    if (!resaveSession) { 
     savedHash = originalHash 
    } 
    wrapmethods(req.session); 
   } 
   next(); 
  }); 
 }; 
}; 

function isSaved(sess) { 
   return originalId === sess.id && savedHash === hash(sess); 
  } 

rollingSessions = options.rolling || false;//默認(rèn)為false 

//這個(gè)方法用戶判斷是否需要在請(qǐng)求頭中設(shè)置cookie 
 // determine if cookie should be set on response 
 function shouldSetCookie(req) { 
  // cannot set cookie without a session ID 
  //如果沒有sessionID直接返回，這時(shí)候不用設(shè)置cookie 
  if (typeof req.sessionID !== 'string') { 
   return false; 
  } 
  //var cookieId = req.sessionID = getcookie(req, name, secrets); 
  return cookieId != req.sessionID  
   ? saveUninitializedSession || isModified(req.session) 
   //rollingSessions = options.rolling || false,其中rolling表示sessionCookie在每一個(gè)響應(yīng)中都應(yīng)該被發(fā)送。也就是說如果用戶設(shè)置了rolling即使sessionID沒有被修改 
   //也依然會(huì)把session的cookie發(fā)送到瀏覽器 
   : rollingSessions || req.session.cookie.expires != null && isModified(req.session); 
 } 

 var saveUninitializedSession = options.saveUninitialized; 
/如果用戶不指定saveUninitializedSession那么提示用戶并設(shè)置saveUninitializedSession為true 
if (saveUninitializedSession === undefined) { 
 deprecate('undefined saveUninitialized option; provide saveUninitialized option'); 
 saveUninitializedSession = true; 
} 

// determine if session should be saved to store 
  //判斷是否需要把session保存到到store中 
  function shouldSave(req) { 
   // cannot set cookie without a session ID 
   if (typeof req.sessionID !== 'string') { 
    debug('session ignored because of bogus req.sessionID %o', req.sessionID); 
    return false; 
   } 
   // var saveUninitializedSession = options.saveUninitialized; 
   // var cookieId = req.sessionID = getcookie(req, name, secrets); 
   return !saveUninitializedSession && cookieId !== req.sessionID 
    ? isModified(req.session) 
    : !isSaved(req.session) 
  } 

//這個(gè)方法用戶判斷是否需要在請(qǐng)求頭中設(shè)置cookie 
  // determine if cookie should be set on response 
  function shouldSetCookie(req) { 
   // cannot set cookie without a session ID 
   //如果沒有sessionID直接返回，這時(shí)候不用設(shè)置cookie 
   if (typeof req.sessionID !== 'string') { 
    return false; 
   } 
   //var cookieId = req.sessionID = getcookie(req, name, secrets); 
   return cookieId != req.sessionID  
    ? saveUninitializedSession || isModified(req.session) 
    //rollingSessions = options.rolling || false,其中rolling表示sessionCookie在每一個(gè)響應(yīng)中都應(yīng)該被發(fā)送。也就是說如果用戶設(shè)置了rolling即使sessionID沒有被修改 
    //也依然會(huì)把session的cookie發(fā)送到瀏覽器 
    : rollingSessions || req.session.cookie.expires != null && isModified(req.session); 
  } 

var secret = options.secret; 
 //unsetDestroy表示用戶是否指定了unset參數(shù)是destroy，是布爾值 
 if (Array.isArray(secret) && secret.length === 0) { 
  throw new TypeError('secret option array must contain one or more strings'); 
 } 
 //保證secret保存的是一個(gè)數(shù)組，即使用戶傳入的僅僅是一個(gè)string 
 if (secret && !Array.isArray(secret)) { 
  secret = [secret]; 
 } 
 //必須提供secret參數(shù) 
 if (!secret) { 
  deprecate('req.secret; provide secret option'); 
 } 

//作用：用于從請(qǐng)求對(duì)象request中獲取session ID值，其中name就是我們?cè)趏ptions中指定的，首先從req.headers.cookie獲取，接著從req.signedCookies中獲取，最后從req.cookies獲取 
function getcookie(req, name, secrets) { 
 var header = req.headers.cookie; 
 var raw; 
 var val; 
 // read from cookie header 
 if (header) { 
  var cookies = cookie.parse(header); 
  raw = cookies[name]; 
  if (raw) { 
   if (raw.substr(0, 2) === 's:') { 
    //切割掉前面的字符"s:"! 
    val = unsigncookie(raw.slice(2), secrets); 
    //val表示false意味著客戶端傳遞過來的cookie被篡改了! 
    if (val === false) { 
     debug('cookie signature invalid'); 
     val = undefined; 
    } 
   } else { 
    debug('cookie unsigned') 
   } 
  } 
 } 
 // back-compat read from cookieParser() signedCookies data 
 if (!val && req.signedCookies) { 
  val = req.signedCookies[name]; 
  if (val) { 
   deprecate('cookie should be available in req.headers.cookie'); 
  } 
 } 
 
 // back-compat read from cookieParser() cookies data 
 if (!val && req.cookies) { 
  raw = req.cookies[name]; 
 
  if (raw) { 
   if (raw.substr(0, 2) === 's:') { 
    val = unsigncookie(raw.slice(2), secrets); 
 
    if (val) { 
     deprecate('cookie should be available in req.headers.cookie'); 
    } 
 
    if (val === false) { 
     debug('cookie signature invalid'); 
     val = undefined; 
    } 
   } else { 
    debug('cookie unsigned') 
   } 
  } 
 } 
 
 return val; 
} 

// setcookie(res, name, req.sessionID, secrets[0], cookie.data); 
//方法作用：為HTTP響應(yīng)設(shè)置cookie，設(shè)置的cookie是把req.sessionID進(jìn)行加密過后的cookie,其中name用于保存到客戶端的sessionID的cookie的名稱 
function setcookie(res, name, val, secret, options) { 
 var signed = 's:' + signature.sign(val, secret); 
 //對(duì)要發(fā)送的cookie進(jìn)行加密，密鑰為secret 
 var data = cookie.serialize(name, signed, options); 
 //其中options中可能有decode函數(shù)，返回序列化的cookie 
 debug('set-cookie %s', data); 
 var prev = res.getHeader('set-cookie') || []; 
 //獲取set-cookie頭，默認(rèn)是一個(gè)空數(shù)組 
 var header = Array.isArray(prev) ? prev.concat(data) 
  : Array.isArray(data) ? [prev].concat(data) 
  : [prev, data]; 
 //通過set-cookie，發(fā)送到客戶端 
 res.setHeader('set-cookie', header) 
} 

store = options.store || new MemoryStore 
// notify user that this store is not 
// meant for a production environment 
//如果在生產(chǎn)環(huán)境下，同時(shí)store也就是用戶傳入的store(默認(rèn)為MemoryStore)是MemoryStore那么給出警告 
if ('production' == env && store instanceof MemoryStore) { 
 console.warn(warning); 
} 
// generates the new session 
//為用于指定的store添加一個(gè)方法generate，同時(shí)為這個(gè)方法傳入req對(duì)象，在這個(gè)generate方法中為req指定了sessionID,session,session.cookie 
//如果用戶傳入的secure為auto, 
store.generate = function(req){ 
 req.sessionID = generateId(req); 
 req.session = new Session(req); 
 req.session.cookie = new Cookie(cookieOptions); 
 //用戶指定的secure參數(shù)如果是auto,那么修改req.session.cookie的secure參數(shù)，并通過issecure來判斷 
 if (cookieOptions.secure === 'auto') { 
  req.session.cookie.secure = issecure(req, trustProxy); 
 } 
}; 
//查看store是否實(shí)現(xiàn)了touch方法 
var storeImplementsTouch = typeof store.touch === 'function'; 
//為store注冊(cè)disconnect事件，在該事件中吧storeReady設(shè)置為false 
store.on('disconnect', function(){ storeReady = false; }); 
//為stroe注冊(cè)connect事件，把storeReady設(shè)置為true 
store.on('connect', function(){ storeReady = true; }); 
 // expose store 
 req.sessionStore = store; 

'use strict'; 
var EventEmitter = require('events').EventEmitter 
 , Session = require('./session') 
 , Cookie = require('./cookie') 
var Store = module.exports = function Store(options){}; 
//這個(gè)Store實(shí)例是一個(gè)EventEmitter實(shí)例，也就是說Store實(shí)例最后還是一個(gè)EventEmitter實(shí)例對(duì)象 
Store.prototype.__proto__ = EventEmitter.prototype; 
 //每一個(gè)store有一個(gè)默認(rèn)的regenerate方法用于產(chǎn)生session 
Store.prototype.regenerate = function(req, fn){ 
 var self = this; 
 //regenerate底層調(diào)用的是destroy方法，第一個(gè)參數(shù)是req.sessionID,至于回調(diào)中的self.generate必須是對(duì)容器進(jìn)行指定的 
 this.destroy(req.sessionID, function(err){ 
  self.generate(req); 
  fn(err);//最后回調(diào)fn 
 }); 
 //調(diào)用這個(gè)store的destory方法,銷毀req.sessionID，銷毀成功后通過剛才的store的generate方法產(chǎn)生一個(gè)sessionID 
}; 
 
//通過指定的sid加載一個(gè)Session實(shí)例，然后觸發(fā)函數(shù)fn(err,sess) 
Store.prototype.load = function(sid, fn){ 
 var self = this; 
 //最后調(diào)用的是Store的get方法 
 this.get(sid, function(err, sess){ 
  if (err) return fn(err); 
  if (!sess) return fn(); 
  //如果sess為空那么調(diào)用fn()方法 
  var req = { sessionID: sid, sessionStore: self }; 
  //調(diào)用createSession來完成的 
  sess = self.createSession(req, sess); 
  fn(null, sess); 
 }); 
}; 
//從一個(gè)JSON格式的sess中創(chuàng)建一個(gè)session實(shí)例，如sess={cookie:{expires:xx,originalMaxAge:xxx}} 
Store.prototype.createSession = function(req, sess){ 
 var expires = sess.cookie.expires 
  , orig = sess.cookie.originalMaxAge; 
  //創(chuàng)建session時(shí)候獲取其中的cookie域下面的expires,originalMaxAge參數(shù) 
 sess.cookie = new Cookie(sess.cookie); 
 //更新session.cookie為一個(gè)Cookie實(shí)例而不再是一個(gè){}對(duì)象了 
 if ('string' == typeof expires) sess.cookie.expires = new Date(expires); 
 sess.cookie.originalMaxAge = orig; 
 //為新構(gòu)建的cookie添加originalMaxAge屬性 
 req.session = new Session(req, sess); 
 //創(chuàng)建一個(gè)session實(shí)例，其中傳入的第一個(gè)參數(shù)是req,第二個(gè)參數(shù)是sess也就是我們剛才創(chuàng)建的那個(gè)Cookie實(shí)例，簽名為sess={cookie:cookie對(duì)象} 
 return req.session; 
}; 

//如果用戶指定了unset，但是unset不是destroy/keep，那么保存 
 if (options.unset && options.unset !== 'destroy' && options.unset !== 'keep') { 
  throw new TypeError('unset option must be "destroy" or "keep"'); 
 } 
 // TODO: switch to "destroy" on next major 
 var unsetDestroy = options.unset === 'destroy'; 
  // determine if session should be destroyed 
  //sessionID還存在，但是req.session已經(jīng)被銷毀了 
  function shouldDestroy(req) { 
   // var unsetDestroy = options.unset === 'destroy'; 
   return req.sessionID && unsetDestroy && req.session == null; 
  } 

var app = express() 
app.set('trust proxy', 1) // trust first proxy  
app.use(session({ 
 secret: 'keyboard cat', 
 resave: false, 
 saveUninitialized: true, 
 cookie: { secure: true } 
})) 

var app = express() 
var sess = { 
 secret: 'keyboard cat', 
 cookie: {} 
} 
if (app.get('env') === 'production') { 
 app.set('trust proxy', 1) // trust first proxy  
 sess.cookie.secure = true // serve secure cookies  
} 
app.use(session(sess)) 

// Use the session middleware  
app.use(session({ secret: 'keyboard cat', cookie: { maxAge: 60000 }})) 
// Access the session as req.session  
app.get('/', function(req, res, next) { 
 var sess = req.session//用這個(gè)屬性獲取session中保存的數(shù)據(jù)，而且返回的JSON數(shù)據(jù) 
 if (sess.views) { 
  sess.views++ 
  res.setHeader('Content-Type', 'text/html') 
  res.write('<p>views: ' + sess.views + '</p>') 
  res.write('<p>expires in: ' + (sess.cookie.maxAge / 1000) + 's</p>') 
  res.end() 
 } else { 
  sess.views = 1 
  res.end('welcome to the session demo. refresh!') 
 } 
}) 

session:    
 //req.session域下面保存的是一個(gè)Session實(shí)例，其中有cookie表示是一個(gè)對(duì)象  
  Session {  
  //這里是req.session.cookie是一個(gè)Cookie實(shí)例  
   cookie:  
   { path: '/',  
    _expires: Fri May 06 2016 15:44:48 GMT+0800 (中國(guó)標(biāo)準(zhǔn)時(shí)間),  
    originalMaxAge: 2591999960,  
    httpOnly: true },  
    flash: { error: [Object]   
   }  
 }  

Store.prototype.regenerate = function(req, fn){ 
 var self = this; 
 //regenerate底層調(diào)用的是destroy方法，第一個(gè)參數(shù)是req.sessionID,至于回調(diào)中的self.generate必須是對(duì)容器進(jìn)行指定的 
 this.destroy(req.sessionID, function(err){ 
  self.generate(req); 
  fn(err);//最后回調(diào)fn 
 }); 
 //調(diào)用這個(gè)store的destory方法,銷毀req.sessionID，銷毀成功后通過剛才的store的generate方法產(chǎn)生一個(gè)sessionID 
}; 

store.generate = function(req){ 
 req.sessionID = generateId(req); 
 req.session = new Session(req); 
 req.session.cookie = new Cookie(cookieOptions); 
 //用戶指定的secure參數(shù)如果是auto,那么修改req.session.cookie的secure參數(shù)，并通過issecure來判斷 
 if (cookieOptions.secure === 'auto') { 
  req.session.cookie.secure = issecure(req, trustProxy); 
 } 
}; 

  req.session.destroy(function(err) { 
 // cannot access session here  
}) 

  req.session.reload(function(err) { 
 // session updated  
}) 

  req.session.save(function(err) { 
 // session saved  
}) 

function Session(req, data) { 
 Object.defineProperty(this, 'req', { value: req }); 
 Object.defineProperty(this, 'id', { value: req.sessionID }); 
 if (typeof data === 'object' && data !== null) { 
  // merge data into this, ignoring prototype properties 
  for (var prop in data) { 
   if (!(prop in this)) { 
    this[prop] = data[prop] 
   } 
  } 
 } 
} 
//重置".cookie.maxAge"防止在session仍然存活的時(shí)候cookie已經(jīng)過期了 
defineMethod(Session.prototype, 'touch', function touch() { 
 return this.resetMaxAge(); 
}); 
//resetMaxAge方法，用于為cookie的maxAge指定為cookie的originalMaxAge 
defineMethod(Session.prototype, 'resetMaxAge', function resetMaxAge() { 
 this.cookie.maxAge = this.cookie.originalMaxAge; 
 return this; 
}); 

function Session(req, data) { 
 Object.defineProperty(this, 'req', { value: req }); 
 Object.defineProperty(this, 'id', { value: req.sessionID }); 
 if (typeof data === 'object' && data !== null) { 
  // merge data into this, ignoring prototype properties 
  for (var prop in data) { 
   if (!(prop in this)) { 
    this[prop] = data[prop] 
   } 
  } 
 } 
} 

//重寫了Object對(duì)象的defineProperty，其中defineProperty用于為這個(gè)對(duì)象指定一個(gè)函數(shù)，其中第二個(gè)參數(shù)是函數(shù)的名稱，第三個(gè)是函數(shù)本身 
function defineMethod(obj, name, fn) { 
 Object.defineProperty(obj, name, { 
  configurable: true, 
  enumerable: false, 
  value: fn, 
  writable: true 
 }); 
}; 

var hour = 3600000 
 req.session.cookie.expires = new Date(Date.now() + hour) 
 req.session.cookie.maxAge = hour//和上面的expires等價(jià) 

function MemoryStore() { 
 Store.call(this) 
 this.sessions = Object.create(null) 
} 
//繼承了Store中的所有的原型屬性 
util.inherits(MemoryStore, Store) 

//通過指定的sessionId獲取當(dāng)前的session對(duì)象，然后把這個(gè)對(duì)象的cookie更新為新的session對(duì)應(yīng)的cookie，同時(shí)sessions中的當(dāng)前session也進(jìn)行更新（包括過期時(shí)間等） 
MemoryStore.prototype.touch = function touch(sessionId, session, callback) { 
 var currentSession = getSession.call(this, sessionId) 
 if (currentSession) { 
  // update expiration 
  currentSession.cookie = session.cookie 
  this.sessions[sessionId] = JSON.stringify(currentSession) 
 } 
 callback && defer(callback) 
} 

session({ 
  secret: settings.cookieSecret, 
  //blog=s%3AisA3_M-Vso0L_gHvUnPb8Kw9DohpCCBJ.OV7p42pL91uM3jueaJATpZdlIj%2BilgxWoD8HmBSLUSo 
  //其中secret如果是一個(gè)string，那么就是用這個(gè)string對(duì)sessionID對(duì)應(yīng)的cookie進(jìn)行簽名，如果是一個(gè)數(shù)組那么只有第一個(gè)用于簽名，其他用于瀏覽器請(qǐng)求后的驗(yàn)證 
  key: settings.db, 
  //設(shè)置的cookie的名字，從上面可以看到這里指定的是blog，所以瀏覽器的請(qǐng)求中可以看到這里的sessionID已經(jīng)不是sessionID了，而是這里的blog 
  name:"qinliang",//name的優(yōu)先級(jí)比key要高，如果同時(shí)設(shè)置了那么就是按照name來制定的 
  //沒有name時(shí)候response中為：set-cookie:blog=s%3A6OJEWycwVMmTGXcZqawrW0HNLOTJkYKm.0Slax72TMfW%2B4Tiit3Ox7NAj5S6rPWvMUr6sY02l0DE; Path=/; Expires=Thu, 28 Apr 2016 10:47:13 GMT; HttpOnly 
  //當(dāng)有name的時(shí)候resopnse中：set-cookie:qinliang=s%3ABDOjujVhV0DH9Atax_gl4DgZ4-1RGvjQ.OeUddoRalzB4iSmUHcE8oMziad4Ig7jUT1REzGcYcdg; Path=/; Expires=Thu, 28 Apr 2016 10:48:26 GMT; HttpOnly 
  resave:true,//沒有實(shí)現(xiàn)touch方法，同時(shí)也設(shè)置了session的過期時(shí)間為30天 
  rolling:true,//如果設(shè)置了rolling為true，同時(shí)saveUninitialized為true，那么每一個(gè)請(qǐng)求都會(huì)發(fā)送沒有初始化的session！ 
  saveUninitialized:false,//設(shè)置為true,存儲(chǔ)空間浪費(fèi)，不允許權(quán)限管理 
  cookie:  
  { 
    maxAge: 1000 * 60 * 60 * 24 * 30 
   }, 
  //cookie里面全部的設(shè)置都是對(duì)于sessionID的屬性的設(shè)置，默認(rèn)的屬性為{ path: '/', httpOnly: true, secure: false, maxAge: null }. 
  //所以最后我們保存到數(shù)據(jù)庫(kù)里面的信息就是：{"cookie":{"originalMaxAge":2592000000,"expires":"2016-04-27T02:30:51.713Z","httpOnly":true,"path":"/"},"flash":{}} 
  store: new MongoStore({ 
   db: settings.db, 
   host: settings.host, 
   port: settings.port 
  }) 
}) 

function unsigncookie(val, secrets) { 
 for (var i = 0; i < secrets.length; i++) { 
  var result = signature.unsign(val, secrets[i]); 
  if (result !== false) { 
   return result; 
  } 
 } 
 return false; 
} 

// var cookieId = req.sessionID = getcookie(req, name, secrets); 
function getcookie(req, name, secrets) { 
 var header = req.headers.cookie; 
 var raw; 
 var val; 
 // read from cookie header 
 if (header) { 
  var cookies = cookie.parse(header); 
  raw = cookies[name]; 
  if (raw) { 
   if (raw.substr(0, 2) === 's:') { 
    //切割掉前面的字符"s:"! 
    val = unsigncookie(raw.slice(2), secrets); 
    //val表示false意味著客戶端傳遞過來的cookie被篡改了! 
    if (val === false) { 
     debug('cookie signature invalid'); 
     val = undefined; 
    } 
   } else { 
    debug('cookie unsigned') 
   } 
  } 
 } 
 // back-compat read from cookieParser() signedCookies data 
 //如果從req.headers.cookie中沒有讀取到session ID的數(shù)據(jù)，那么就去cookie parser的req.signedCookies中讀取 
 if (!val && req.signedCookies) { 
  val = req.signedCookies[name]; 
  if (val) { 
   deprecate('cookie should be available in req.headers.cookie'); 
  } 
 } 
 // back-compat read from cookieParser() cookies data 
 //如果req.signedCookies中也沒有獲取到數(shù)據(jù)那么直接從req.cookies中獲取 
 if (!val && req.cookies) { 
  raw = req.cookies[name]; 
  if (raw) { 
   if (raw.substr(0, 2) === 's:') { 
    val = unsigncookie(raw.slice(2), secrets); 
    if (val) { 
     deprecate('cookie should be available in req.headers.cookie'); 
    } 
    if (val === false) { 
     debug('cookie signature invalid'); 
     val = undefined; 
    } 
   } else { 
    debug('cookie unsigned') 
   } 
  } 
 } 
 return val; 
} 

var Session = require('./session/session') 
 , MemoryStore = require('./session/memory') 
 , Cookie = require('./session/cookie') 
 , Store = require('./session/store') 
 var cookieOptions = options.cookie || {}; 
function generateSessionId(sess) { 
 return uid(24); 
} 
 // generates the new session 
 store.generate = function(req){ 
  req.sessionID = generateId(req);//產(chǎn)生一個(gè)sessionID 
  req.session = new Session(req);//產(chǎn)生一個(gè)Session 
  req.session.cookie = new Cookie(cookieOptions);//在req.session對(duì)象的cookie域下面保存的是一個(gè)Cookie對(duì)象 
  if (cookieOptions.secure === 'auto') { 
   req.session.cookie.secure = issecure(req, trustProxy); 
  } 
 }; 

var Cookie = module.exports = function Cookie(options) { 
 this.path = '/'; 
 this.maxAge = null; 
 this.httpOnly = true; 
 //最終的this就是這個(gè)新創(chuàng)建的Cookie具有這些默認(rèn)的屬性，同時(shí)還具有用戶自己傳入的options參數(shù)，如用戶傳入的var cookieOptions = options.cookie || {}; 
 //也就是用戶傳入的options.cookie屬性 
 if (options) merge(this, options); 
 /*這個(gè)utils.merge的源碼只有一句話： 
 exports = module.exports = function(a, b){ 
 if (a && b) { 
  for (var key in b) { 
   a[key] = b[key]; 
  } 
 } 
 return a; 
};*/ 
 this.originalMaxAge = undefined == this.originalMaxAge 
  ? this.maxAge 
  : this.originalMaxAge; 
 //默認(rèn)的originalMaxAge就是this.maxAge也就是null,如果指定了originalMaxAge那么就是用戶指定的值 
};