huruji / blog Goto Github PK

npm i babel-loader -D

const config = {
  // ......
  module: {
    rules: [{
      test: /\.js$/,
      use:{
        loader: 'babel-loader',
        options: {
          presets: ['env']
        }
      }
    }]
  }
};

module.exports = config;

const config = {
  // ......
  module: {
    rules: [{
      test: /\.js$/,
      use:[
        'babel-loader'
      ]
    }]
  }
};

module.exports = config;

{
  "presets": [
    "es2015"
  ]
}

npm i eslint-loader -D

const config = {
  // ......
  module: {
    rules: [{
      test: /\.js$/,
      use:[
        'eslint-loader',
        'babel-loader'
      ]
    }]
  }
};

module.exports = config;

npm i node-sass sass-loader webpack -D

npm i resolve-url-loader -D

const config = {
  // ......
  module: {
    rules: [{
      test: /\.scss$/,
      use: [
        'style-loader',
        'css-loader',
        'resolve-url-loader',
        'sass-loader?sourceMap'
      ]
    }]
  }
};

module.exports = config;

npm i less-loader -D

const config = {
  // ......
  module: {
    rules: [{
      test: /\.scss$/,
      use: [
        'style-loader',
        'css-loader',
        'less-loader'
      ]
    }]
  }
};

module.exports = config;

  function isFun(f) {
    return Object.prototype.toString.call(f).toLowerCase().indexOf('function') > -1;
  }

  function isArr(arr) {
    return Array.isArray(arr);
  }

  function isStr(str) {
    return typeof str === 'string';
  }

  function define(name, deps, callback) {
    if(!isStr(name)) {
      callback = deps;
      deps = name;
      name = null;
    }
    
    if(!isArr(deps)) {
      callback = deps;
      deps = [];
    }

    if(moduleMap[name]) {
      name=moduleMap[name]
    } 
    name = replaceName(name);
    deps = deps.map(function(ele, i) {
      return replaceName(ele); 
    });
    
    modMap[name] = modMap[name] || {};
    modMap[name].deps = deps;
    modMap[name].status = 'loaded';
    modMap[name].callback = callback;
    modMap[name].oncomplete = modMap[name].oncomplete || [];
  }

  function replaceName(name) {
    if(name===null) {
      return name;
    }
    // ......
  }

    loadjs.config({
      baseUrl:'./static',
      paths: {
        app: './app'
      }
    });

    loadjs.define('cc',['a'], function(a) {
      console.log(1);
      console.log(a.add(1,2));
    });

    loadjs.define('ab', function() {
      console.log('ab');
    });

    loadjs.define(function() {
      console.log('unknow');
    });

    loadjs.use(['ab','cc'],function() {
      console.log('main');
    });

(function(root){
  var modMap = {};
  var moduleMap = {};
  var cfg = {
    baseUrl: location.href.replace(/(\/)[^\/]+$/g, function(s, s1){
      return s1
    }),
    path: {

    }
  };
  
  // 完整网址
  var fullPathRegExp = /^[(https?\:\/\/) | (file\:\/\/\/)]/;
  
  // 局对路径
  var absoPathRegExp = /^\//;
  
  // 以./开头的相对路径
  var relaPathRegExp = /^\.\//;
  
  // 以../开头的的相对路径
  var relaPathBackRegExp = /^\.\.\//;


  function isFun(f) {
    return Object.prototype.toString.call(f).toLowerCase().indexOf('function') > -1;
  }

  function isArr(arr) {
    return Array.isArray(arr);
  }

  function isStr(str) {
    return typeof str === 'string';
  }
  
  function merge(obj1, obj2) {
    if(obj1 && obj2) {
      for(var key in obj2) {
        obj1[key] = obj2[key]
      }
    }
  }
  
  function outputPath(baseUrl, path) {
    if (relaPathRegExp.test(path)) {
      if(/\.\.\//g.test(path)) {
        var pathArr = baseUrl.split('/');
        var backPath = path.match(/\.\.\//g);
        var joinPath = path.replace(/[(^\./)|(\.\.\/)]+/g, '');
        var num = pathArr.length - backPath.length;
        return pathArr.splice(0, num).join('/').replace(/\/$/g, '') + '/' +joinPath;
      } else {
        return baseUrl.replace(/\/$/g, '') + '/' + path.replace(/[(^\./)]+/g, '');
      }
    } else if (fullPathRegExp.test(path)) {
      return path;
    } else if (absoPathRegExp.test(path)) {
      return baseUrl.replace(/\/$/g, '') + path;
    } else {
      return baseUrl.replace(/\/$/g, '') + '/' + path;
    }
  }

  function replaceName(name) {
    if(name===null) {
      return name;
    }
    if(fullPathRegExp.test(name) || absoPathRegExp.test(name) || relaPathRegExp.test(name) || relaPathBackRegExp.test(name)) {
      return outputPath(cfg.baseUrl, name);
    } else {
      var prefix = name.split('/')[0] || name;
      if(cfg.paths[prefix]) {
        if(name.split('/').length === 0) {
         return cfg.paths[prefix];
        } else {;
          var endPath = name.split('/').slice(1).join('/');
          return outputPath(cfg.paths[prefix], endPath);
        }
      } else {
        return outputPath(cfg.baseUrl, name);
      }
    }
  }

  function fixUrl(name) {
    return name.split('/')[name.split('/').length-1]
  }
  function config(obj) {
    if(obj){
     if(obj.baseUrl) {
       obj.baseUrl = outputPath(cfg.baseUrl, obj.baseUrl);
     }
     if(obj.paths) {
       var base = obj.baseUrl || cfg.baseUrl;
       for(var key in obj.paths) {
         obj.paths[key] = outputPath(base, obj.paths[key]);
       }
     }
      merge(cfg, obj);
    }
  }


  
  function use(deps, callback) {
    if(deps.length === 0) {
      callback();
    }
    var depsLength = deps.length;
    var params = [];
    
    for(var i = 0; i < deps.length; i++) {
      moduleMap[fixUrl(deps[i])] = deps[i];
      deps[i] = replaceName(deps[i]);
      (function(j){
        loadMod(deps[j], function(param) {
          depsLength--;
          params[j] = param;
          if(depsLength === 0) {
            callback.apply(null, params);
          }
        })
      })(i)
    }
    
  }

  function loadMod(name, callback) {
    /*模块还未定义*/
    if(!modMap[name]) {
      modMap[name] = {
        status: 'loading',
        oncomplete: []
      };
      loadscript(name, function() {
        use(modMap[name].deps, function() {
          execMod(name, callback, Array.prototype.slice.call(arguments, 0));
        })
      });
    } else if(modMap[name].status === 'loading') {
      
      // 模块正在加载
      modMap[name].oncomplete.push(callback);
    } else if (!modMap[name].exports){
      
      //模块还未执行完
      use(modMap[name].deps, function() {
        execMod(name, callback, Array.prototype.slice.call(arguments, 0));
      })
    }else {
      callback(modMap[name].exports);
    }
  }

  function execMod(name, callback, params) {
    var exp = modMap[name].callback.apply(null, params);
    modMap[name].exports = exp;
    callback(exp);
    execComplete(name);
  }

  function execComplete(name) {
    for(var i = 0; i < modMap[name].oncomplete.length; i++) {
      modMap[name].oncomplete[i](modMap[name].exports);
    }
  }
  
  
  function loadscript(name, callback) {
    var doc = document;
    var node = doc.createElement('script');
    node.charset = 'utf-8';
    node.src = name + '.js';
    
    /*为每个模块添加一个随机id*/
    node.id = 'loadjs-js-' + (Math.random() * 100).toFixed(3);
    doc.body.appendChild(node);
    node.onload = function() {
      callback();
    }
  }

  function define(name, deps, callback) {
    /*匿名模块*/
    if(!isStr(name)) {
      callback = deps;
      deps = name;
      name = null;
    }

    /*没有依赖*/
    if(!isArr(deps)) {
      callback = deps;
      deps = [];
    }

    if(moduleMap[name]) {
      name=moduleMap[name]
    } 
    
    name = replaceName(name);
    
    /*对每个依赖名进行路径替换*/
    deps = deps.map(function(ele, i) {
      return replaceName(ele); 
    });

    modMap[name] = modMap[name] || {};
    modMap[name].deps = deps;
    modMap[name].status = 'loaded';
    modMap[name].callback = callback;
    modMap[name].oncomplete = modMap[name].oncomplete || [];
  }

  var loadjs = {
    define: define,
    use: use,
    config: config
  };

  root.define = define;
  root.loadjs = loadjs;
  root.modMap = modMap;
})(window);

const resource = require('resource-router-middleware');
let users = [];
const huruji = {
    id:12,
    name: 'huruji',
    age: 12,
    sex: 'man'
};
const grey = {
    id: 13,
    name: 'grey',
    age: 12,
    sex: 'man'
};

users = [huruji, grey];

module.exports = resource({
   mergeParams: true,
   id: 'user',
   load: function(res,id, callback) {
       callback(null, huruji);
   },
   list: function(req, res) {
       res.json(users);
   },
   create: function(req, res) {
       var user = req.body;
       users.push(user);
       res.json(user);
   },
    read: function(req, res) {
       res.json(req.user);
    },
    update: function(req, res) {
       var id = req.params[this.id];
       for(var i = users.length;i--;) {
           if(users[i].id === id){
               users[i] = req.body;
               users[i].id = id;
               return res.status(204).send('Accepted');
           }
       }
       res.status(404).send('Not found');
    },
    delete: function(req, res) {
       var id = req.params[this.id];
       for(var i =users.length;i--;) {
           if(users[i].id===id) {
               users.splice(i,1);
               return res.status(200);
           }
       }
       res.status(404).send('Not found');
    }
});

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const userResource = require('./user');

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use('/user',userResource);


app.listen(5000, function(err) {
    if(err) {
        return console.log(err);
    }
    console.log('server is listening port 5000')
});

var Router = require('express').Router;

var keyed = ['get', 'read', 'put', 'update', 'patch', 'modify', 'del', 'delete'],
    map = { index:'get', list:'get', read:'get', create:'post', update:'put', modify:'patch' };

module.exports = function ResourceRouter(route) {
    route.mergeParams = route.mergeParams ? true : false;
    // Express.Router可以提供一个对象参数
    /**
     * @param {
     * mergeParams: 是否保留父级路由的req.params，且父子的req.params冲突时，优先使用子级的
     * caseSensitive：路由的路径是否大小写敏感，默认为false
     * strict：是否启用严格模式，即/foo与/foo/区别对待
     * }
     */
    var router = Router({mergeParams: route.mergeParams}),
        key, fn, url;

    // 如果有中间件则装载中间价
    if (route.middleware) router.use(route.middleware);

    // router.param方法的回调函数的参数分别是req,res,next,params的值，params的key
    // 使用这个我们可以为路由的params找到数据之后直接定义在req对象中，供后续处理
    if (route.load) {
        router.param(route.id, function(req, res, next, id) {
            route.load(req, id, function(err, data) {
                if (err) return res.status(404).send(err);
                req[route.id] = data;
                next();
            });
        });
    }

    for (key in route) {
        // fn为对应的http method
        fn = map[key] || key;
        if (typeof router[fn]==='function') {
            // ~取反位运算，这个很有意思，三目运算符只有在~keyed.indexOf(key)为0时运算'/'，取反值与原值相加为-1的原则知原值keyed.indexOf(key)为-1，也就是说
            // url = ~keyed.indexOf(key) ? ('/:'+route.id) : '/'与url = (keyed.indexOf(key) > -1) ? ('/:'+route.id) : '/';效果相同
            // 意义在于如果用户是使用keyed数组里的元素来定义键的，则使用('/:'+route.id)路由路径，否则使用'/'路由路径
            url = ~keyed.indexOf(key) ? ('/:'+route.id) : '/';
            console.log(key);
            console.log('url:' + url)
            router[fn](url, route[key]);
        }
    }

    return router;
};

module.exports.keyed = keyed;

// 不纯
const minimum = 21;
const checkAge = function(age){
    return age >= minimum
}

// 纯的

const checkAge = function(age) {
     const minimum = 21;
     return age >= minimum;
}

const immutableState = Object.freeze({
    minimum: 21
});

immutableState.minimumu;
// 21

immutableState.minimumu = 32;
// 严格模式下将会报错

immutableState.minimumu;
// 21

const squareNumber = memoize(function(x){
    return x * x;
})

squareNumber(4);
// 16        首次计算


squareNumber(4);
// 16        从缓存中直接读取结果

const memoize = function(f) {
    const cache = {};
    return function(){
        const arg_str = JSON.stringify(arguments);
        cache[arg_str] = cache[arg_str] || f.apply(f, arguments);
        return cache[arg_str];
    }
}

const add = function(x) {
    return function(y) {
        return x + y;
    }
}


const addTen = add(10);

addTen(2);
//  12

const curry = require("lodash").curry;

const match = curry(function(what, str){
    return str.match(what);
});

const replace = curry(function(what, replacement, str){
    return str.replace(what, replacement);
})

match(/\s+/g, "hello world");
// [" "]

match(/\s+/g)("hello world");
// [" "]

const  hasSpaces = match(/\s+/g);

hasSpaces("hello world");
// [" "]

const compose = function(f, g) {
    return function(x){
        return f(g(x));
    }
}

const toUpperCase = function(x) {
    return x.toUpperCase();
};

const exclaim = function(x) {
    return x + '!';
};

cosnt shout = compose(exclaim, toUpperCase);

shout("good student");
// "GOOD STUDENT!"

const head = function(x){
    return x[0];
}

const reverse = reduce(function(acc, x) {
    return [x].concat(acc);
}, []);

const last = compose(head, reverse);

const associative = compose(f, compose(g, h)) == compose(compose(f,g), h);

const isUndefined = s => s === void 0

const spawn = require('child_process').spawn;

const child = spawn('node', ['test.js', 'one', 'two'],{
  cwd: './test',
  stdio: 'inherit'
});

const fs = require('fs');
const out = fs.createWriteStream('./message.txt');

console.log('请输入：');

process.stdin.on('data', function(data) {
  out.write(data)
});
process.stdin.on('end', function(data) {
  process.exit()
});

child.on('error', function(err) {
	// 错误处理程序
})

child.kill();

const child = spawn('node',['test.js'], {
	cwd: __dirname,
	stdio: 'inherit',
	detached: true
});

child.unref();

const fork = require('child_process').fork;

fork('./test/test.js',['123123123'], {
  cwd: __dirname,
  encoding: 'utf-8',
  slient: false
});

const fork = require('child_process').fork;

fork('./test/test.js',['123123123'], {
  cwd: __dirname,
  encoding: 'utf-8',
  slient: false
});

process.on('message', (m) => {
  console.log('子进程收到消息');
  console.log(m.userName);
});

process.send({age: 1200});

function inspect(x) {
    return (typeof x === 'function') ? inspectFn(x) :inspectArgs(x);
}

function inspectFn(f) {
    return (f.name) ? f.name : f.toString();
}

function inspectArgs(args) {
    Array.prototype.slice.call(arguments, 0);
    return [].slice.call(args, 0).reduce(function(acc, x){
        return acc += inspect(x);
    }, '(') + ')';
}

function curry(fx) {
    // 函数的length属性返回函数必须传入的参数个数
    var arity = fx.length;

    return function f1() {
        var args = Array.prototype.slice.call(arguments, 0);
        // 参数个数满足的处理
        if (args.length >= arity) {
            return fx.apply(null, args);
        }
        else {
        // 参数个数不满足的处理
            var f2 = function f2() {
                var args2 = Array.prototype.slice.call(arguments, 0);
                return f1.apply(null, args.concat(args2));
            }
            f2.toString = function() {
                return inspectFn(fx) + inspectArgs(args);
            }
            return f2;
        }
    };
}

add = curry(function(x, y) {
    return x + y;
});

const add5 = add(5);

ad5(4)
// 9

add = curry(function(x, y) {
    return x + y;
});

match = curry(function(what, x) {
    return x.match(what);
});

replace = curry(function(what, replacement, x) {
    return x.replace(what, replacement);
});

filter = curry(function(f, xs) {
    return xs.filter(f);
});

map = curry(function map(f, xs) {
    return xs.map(f);
});

reduce = curry(function(f, a, xs) {
    return xs.reduce(f, a);
});

split = curry(function(what, x) {
    return x.split(what);
});

join = curry(function(what, x) {
    return x.join(what);
});

npm i webpack webpack-dev-server -D

const path = require('path');
const webpack = require('webpack');

const config = {
  entry: './src/main.js',
  output: {
    filename: 'bundle.js',
    path: path.join(__dirname, 'dist')
  },
  devtool: 'inline-source-map',
  devServer: {
    contentBase: './dist',
    hot: true
  },
  plugins: [
    new webpack.HotModuleReplacementPlugin()
  ]
}

module.exports = config;

https:{
    key: fs.readFileSync("/path/to/server.key"),
    cert: fs.readFileSync("/path/to/server.crt"),
    ca: fs.readFileSync("/path/to/ca.pem"),
}

headers: {
  "X-Custom-Foo": "bar"
}

historyApiFallback:true

historyApiFallback: {
  rewrites: [
    { from: /^\/$/, to: '/views/landing.html' },
    { from: /^\/subpage/, to: '/views/subpage.html' },
    { from: /./, to: '/views/404.html' }
  ]
}

"scripts": {
    "dev": "webpack-dev-server --open --hot --colors --progress --inline --config webpack.dev.js"
  },

const mysql = require('mysql');
const config = require('./../config/default');

const pool = mysql.createPool({
  host: config.database.HOST,
  port: config.database.PORT,
  user: config.database.USERNAME,
  password: config.database.PASSWORD,
  database: config.database.DATABASE
});

let query = function(sql, values) {
  return new Promise((resolve, reject) => {
    pool.getConnection(function(err, connection) {
      if(err) {
        resolve(err);
      } else {
        connection.query(sql, values, (err, rows) => {
          if(err) {
            reject(err);
          } else {
            resolve(rows)
          }
          connection.release();
        })
      }
    })
  })
};

let users = `create table if not exists users(
 id INT NOT NULL AUTO_INCREMENT,
 name VARCHAR(100) NOT NULL,
 pass VARCHAR(40) NOT NULL,
 PRIMARY KEY ( id )
);`;

let posts = `create table if not exists posts(
 id INT NOT NULL AUTO_INCREMENT,
 name VARCHAR(100) NOT NULL,
 title VARCHAR(40) NOT NULL,
 content  VARCHAR(40) NOT NULL,
 uid  VARCHAR(40) NOT NULL,
 moment  VARCHAR(40) NOT NULL,
 comments  VARCHAR(40) NOT NULL DEFAULT '0',
 pv  VARCHAR(40) NOT NULL DEFAULT '0',
 PRIMARY KEY ( id )
);`;

let comment = `create table if not exists comment(
 id INT NOT NULL AUTO_INCREMENT,
 name VARCHAR(100) NOT NULL,
 content VARCHAR(40) NOT NULL,
 postid VARCHAR(40) NOT NULL,
 PRIMARY KEY ( id )
);`;

let createTable = function(sql) {
  return query(sql, []);
};

createTable(users);
createTable(posts);
createTable(comment);

let insertData = function(value) {
  let _sql = "insert into users(name,pass) values(?,?);";
  return query(_sql, value);
};

let insertPost = function(value) {
  let _sql = "insert into posts(name, title, content, uid, moment) values(?,?,?,?,?);";
  return query(_sql, value);
};

let updatePostComment = function(value) {
  let _sql = "update posts set comment=? where id=?";
  return query(_sql, value);
};

let updatePostPv = function(value) {
  let _sql = "update posts set pv=? where id=? ";
  return query(_sql, value);
};

let insertComment = function(value) {
  let _sql = "insert into comment(name, content, postid) values(?,?,?);";
  return query(_sql, value);
};

let findDataByName = function(name) {
  let _sql =`select * from users where name="${name}"`;
  return query(_sql);
};

let findDataByUser = function(name) {
  let _sql = `select * from posts where name="${name}"`;
  return query(_sql);
}

let findDataById = function(id) {
  let _sql = `select * from posts where id="${id}"`;
  return query(_sql);
}

let findCommentById = function(id) {
  let _sql = `select * from comment where postid="${id}"`;
  return query(_sql);
}

let findAllPost = function() {
  let _sql = `select * from posts`;
  return query(_sql);
}

let updatePost = function(values) {
  let _sql = `update posts set title=?,content=? where id=?`;
  return query(_sql, values);
}

let deletePost = function(id) {
  let _sql = `delete from posts where id=?`;
  return query(_sql);
}

let deleteComment = function(id) {
  let _sql = `delete from comment where id = ${id}`;
  return query(_sql);
}

let deleteAllPostComment = function (id) {
  let _sql = `delete from comment where postid = ?`;
  return query(_sql);
}

let findCommentLength = function(id) {
  let _sql = `select content from comment where postid in (select id from posts where id=${id})`;
  return query(_sql);
}

module.exports = {
  query,
  createTable,
  insertData,
  findDataByName,
  findDataById,
  findDataByUser,
  insertPost,
  findAllPost,
  insertComment,
  findCommentById,
  updatePost,
  deletePost,
  deleteComment,
  findCommentLength,
  updatePostComment,
  deleteAllPostComment,
  updatePostPv
};

const Koa = require('koa');
const config = require('./config/default');
const path = require('path');
const ejs = require('ejs');
const router = require('koa-router');
const koaStatic = require('koa-static');
const views = require('koa-views');
const bodyParser = require('koa-bodyparser');
const session = require('koa-session-minimal');
const MysqlStore = require('koa-mysql-session');


const app = new Koa();

const sessionMysqlConfig = {
  user: config.database.USERNAME,
  password: config.database.PASSWORD,
  database: config.database.DATABASE,
  host: config.database.HOST
};

app.use(session({
  key:'USER_SID',
  store: new MysqlStore(sessionMysqlConfig)
}))

app.use(koaStatic(path.join(path.join(__dirname, 'public'))));

app.use(views(path.join(__dirname,'views'),{
  extension: 'ejs'
}));

app.use(bodyParser());

app.use(require('./routes/singup.js').routes());

app.use(require('./routes/signin.js').routes());

app.use(require('./routes/posts').routes());

app.use(require('./routes/signout').routes());

app.listen(config.port);

const config = {
  port: 3000,
  database: {
    DATABASE: 'koablog',
    USERNAME: 'root',
    PASSWORD: '123456',
    PORT: '3306',
    HOST: 'localhost'
  }
};

module.exports = config;

var hasOwnProperty = Object.prototype.hasOwnProperty

module.exports = PseudoMap

function PseudoMap (set) {
    // 检测this的指向来判断该函数是否被当做构造函数运行，使用new实例化
    // 构造函数时将改变this的指向为该对象，直接运行函数，this则是指全局对象
    if (!(this instanceof PseudoMap)) // whyyyyyyy
        throw new TypeError("Constructor PseudoMap requires 'new'")


    this.clear()

    // 设置传递的参数
    if (set) {
        if ((set instanceof PseudoMap) ||
            (typeof Map === 'function' && set instanceof Map))
            set.forEach(function (value, key) {
                this.set(key, value)
            }, this)
        else if (Array.isArray(set))
            set.forEach(function (kv) {
                this.set(kv[0], kv[1])
            }, this)
        else
            throw new TypeError('invalid argument')
    }
}

PseudoMap.prototype.forEach = function (fn, thisp) {
    thisp = thisp || this
    Object.keys(this._data).forEach(function (k) {
        if (k !== 'size')
            fn.call(thisp, this._data[k].value, this._data[k].key)
    }, this)
}

PseudoMap.prototype.has = function (k) {
    return !!find(this._data, k)
}

PseudoMap.prototype.get = function (k) {
    var res = find(this._data, k)
    // 利用逻辑与的执行特点，不存在时直接返回undefined，这样就不需要在find方法中去判断了，妙
    return res && res.value
}

// 存储
PseudoMap.prototype.set = function (k, v) {
    set(this._data, k, v)
}

// 删除
PseudoMap.prototype.delete = function (k) {
    var res = find(this._data, k)
    if (res) {
        delete this._data[res._index]
        this._data.size--
    }
}

PseudoMap.prototype.clear = function () {
    // 创建一个空对象
    var data = Object.create(null)
    data.size = 0

    // 重新设置构造函数的_data属性，不可写，不可枚举防止其被篡改
    Object.defineProperty(this, '_data', {
        value: data,
        enumerable: false,
        configurable: true,
        writable: false
    })
}

// 设置size的get方法返回this._data.size
Object.defineProperty(PseudoMap.prototype, 'size', {
    get: function () {
        return this._data.size
    },
    set: function (n) {},
    enumerable: true,
    configurable: true
})

PseudoMap.prototype.values =
    PseudoMap.prototype.keys =
        PseudoMap.prototype.entries = function () {
            throw new Error('iterators are not implemented in this version')
        }

// 两者相等或者两个都是NaN时返回true，注意逻辑与的优先级大于逻辑或
// Either identical, or both NaN
function same (a, b) {
    return a === b || a !== a && b !== b
}

// 用来储存键值信息的对象
function Entry (k, v, i) {
    this.key = k
    this.value = v
    this._index = i
}

function find (data, k) {
    for (var i = 0, s = '_' + k, key = s;
         hasOwnProperty.call(data, key);
         key = s + i++) {
        if (same(data[key].key, k))
            return data[key]
    }
}

function set (data, k, v) {
    // 此时则是重新设置值
    for (var i = 0, s = '_' + k, key = s;
         hasOwnProperty.call(data, key);
         key = s + i++) {
        if (same(data[key].key, k)) {
            data[key].value = v
            return
        }
    }
    // size自增
    data.size++
    // 将键值关系作为一个Entry对象储存，这样就避免了传统的对象键只能是字符串的短板
    data[key] = new Entry(k, v, key)
}