JS：编写自己的函数库

一、前言

还没想好要说什么。

二、发布自己的代码库

1. 准备一个代码库

返回目录

1. 初始化工程

   #创建工程目录
   mkdir mylib && cd mylib
   #初始化 npm，生成 package.json 文件
   npm init -y
   

2. 新建 index.js

   let obj = {};
   obj.hello = () => console.log("hello world");
   module.exports = obj;
   

3. 工程目录是这样的

   / mylib
   |- index.js
   |- package.json
   

2. 发布到 npm

返回目录

1. 注册或登陆 npm，镜像源必须是 npm

   #注册或登陆npm
   npm addUser
   Username: #输入用户名
   Password: #输入密码
   Email: (this IS public) #输入公开的电子邮箱
   

2. 发布版到 npm

   npm publish #发布正式版
   npm publish --beta #发布测试beta版
   

3. 每次发布前都要修改一下版本

   npm version #查看版本
   npm version <x.y.z> #新版本 [x,y,z]=[major,minor,patch]
   npm version patch #版本 x.y.z+1
   npm version minor #版本 x.y+1.z=0
   npm version major #版本 x+1.y=0.z=0
   npm version prepatch #版本 x.y.z-r，z+1,r=0
   npm version preminor #版本 x.y.z-r，y+1,z=0,r=0
   npm version premajor #版本 x.y.z-r，x+1,y=0,z=0,r=0
   npm version prerelease #版本 x.y.z-r，r+1
   npm version prerelease --preid=<n> #版本 x.y.z-n.r，z=!n?+1:z，n=n?+1:0
   npm version from-git #从 git 上获取版本
   npm version patch -m "%s" #或 --message，%s 为改动后的版本号，提交git用的
   

4. 撤回发布，好像只能撤回24小时之内发布的包

   npm unpublish #撤回发布
   npm unpublish --force #强制撤回
   

3. 使用自己的代码库

返回目录

1. 通过 npm 安装到本地

   npm install mylib #安装正式版
   npm install mylib@beta #安装测试beta版
   

2. 引入自己的代码库

   const mylib = require("mylib");
   
   mylib.hello(); //输出 hello world 
   

三. 往代码库中添加内容

1. deepCopy 深拷贝

返回目录

1. 实现功能
   1.1 只拷贝 undefined、null、boolean、number、string、object、array 等数据类型
   1.2 保持循环引用 和 保持相同的引用
   1.3 递归实现容易溢出报错，采用循环方式。
2. 代码

   obj.copy = target => {
     //不是引用类型，直接返回
     if (target === null || typeof target !== 'object') {
       return target;
     }
     //是引用类型，判断是数组还是对象
     let result = (Array.isArray(target)) ? [] : {};
     //保存引用类型到栈里
     let stack = [{ parent: result, key: undefined ,data: target }];
     //保存已拷贝的数据
     let copiedList = [{copied: result, target: target}];
   
     while (stack.length) {
       const node = stack.shift();
       const parent = node.parent;
       const key = node.key;
       const data = node.data;
   
       for(let k in data) {
         //检索是否有已拷贝的数据
         let copiedData;
         for(let l in copiedList) {
           if(copiedList[l].target === data[k]) {
             copiedData = copiedList[l].copied;
             break;
           }
         }
   	  
         if(copiedData) {
         	//保持相同的引用，不拷贝直接复制之前的数据
           parent[k] = copiedData;
           //保持循环引用，所以就不复制子元素了
         } else {
           if (data[k] === null || typeof data[k] !== 'object') {
             //拷贝基本数据类型
             parent[k] = data[k];
           } else {
             //引用类型
             parent[k] = Array.isArray(data[k]) ? [] : {};
             //压入栈中和已拷贝列表
             stack.push({ parent: parent[k],key:k, data: data[k] });
             copiedList.push({ copied: parent[k], target: data[k] })
           }
         }
       }
   
     }
   
     return result;
   }
   

2. 吃豆子过桥

  /**
   * 吃豆子过桥
   * @param {Int} long 桥长
   * @param {Int} maxSeeds 最多带的豆子
   */
  calEatSeed(long, maxSeeds) {
    //如果桥长小于等于最大携带豆子数，返回桥长的豆子数
    if(long <= maxSeeds) {
      return long;
    }

    //上次吃的豆子
    let seeds = this.calEatSeed(long-1, maxSeeds);

    //往返回的次数，用上次吃的豆子除以最大携带的豆子
    let n = Math.floor((seeds)/(maxSeeds))*2+1;

    console.log('seeds',seeds,'maxSeeds',maxSeeds, n);
    上次吃的豆子
    return seeds + n;
  }