Vue2常用全局自定义指令的封装详解_Javascript

准备工作

创建目录文件：src/directive/index.js

import copy from "./copy";
import longpress from "./longpress"
import debounce from "./debounce";
import emoji from "./emoji";
import lazyload from "./lazyload";
import permission from "./permission";
import watermarker from "./watermarker";
import draggable from "./draggable";
import empty from "./empty";
const directives = {
  copy,longpress,debounce,emoji,lazyload,permission,watermarker,draggable,empty
};
export default {
  install(vue) {
    object.keys(directives).foreach((key) => {
      vue.directive(key, directives[key]);
    });
  },
};

然后再main.js中引入并注册

// 引入全局自定义指令
import directive from './directive'
vue.use(directive)

注释：自定义指令的钩子函数

bind: 只调用一次,指令第一次绑定到元素时使用,可以用这个钩子函数定义一个在绑定时执行一次的初始动作
inserted: 被绑定的元素插入父节点时调用,(父节点存在即可调用,不必存在于document中)
update: 被绑定元素所在的模板更新时调用,而不论绑定值是否变化,通过比较更新前后的变化,可以忽略掉不必要的更新
componentupdated: 被绑定元素所在模板完成一次更新周期时调用
unbind: 只调用一次,指令与元素解绑时调用

钩子函数的参数的注意事项:

el: 指令所绑定的元素,可以用来直接操作dom
binding: 一个对象,包含以下属性:
- name: 指令名,不包括v-前缀
- value: 指令的绑定值,这个值就是使用的时候传进来的,如果是指就直接复制,如果是函数可以直接调用
- oldvalue: 指令绑定的上一个值,仅在update和componentupdated中可用,无论值是否改变都可用
- expression: 绑定值的表达式或变量名,
- arg: 传给指令的参数,例如v-my-directive：foo，arg的值是"foo"
- modifiers：一个包含修饰符的对象，例如v-my-directive.foo.bar，修饰符对象modifiers的值是{foo：true，bar：true}
vnode：vue编译生成的虚拟节点。
oldvnode：上一个虚拟节点，仅在update和componentupdated钩子中可用。

除了 el 之外，其它参数都应该是只读的，切勿进行修改。

一键复制

需求: 实现一键复制文本内容,用于鼠标右键粘贴

思路：

动态创建 textarea 标签，并设置 readonly 属性及移出可视区域

将要复制的值赋给 textarea 标签的 value 属性，并插入到 body

选中值 textarea 并复制

将 body 中插入的 textarea 移除

在第一次调用时绑定事件，在解绑时移除事件

export default {
 bind(el, { value }) {
   el.$value = value;
   el.handler = () => {
     if (!el.$value) {
       // 值为空的时候，给出提示。可根据项目ui仔细设计
       console.log("无复制内容");
       return;
     }
     // 动态创建 textarea 标签
     const textarea = document.createelement("textarea");
     // 将该 textarea 设为 readonly 防止 ios 下自动唤起键盘，同时将 textarea 移出可视区域
     textarea.readonly = "readonly";
     textarea.style.position = "absolute";
     textarea.style.left = "-9999px";
     // 将要 copy 的值赋给 textarea 标签的 value 属性
     textarea.value = el.$value;
     // 将 textarea 插入到 body 中
     document.body.appendchild(textarea);
     // 选中值并复制
     textarea.select();
     const result = document.execcommand("copy");
     if (result) {
       console.log("复制成功"); // 可根据项目ui仔细设计
     }
     document.body.removechild(textarea);
   };
   // // 绑定点击事件，就是所谓的一键 copy 啦
   el.addeventlistener("click", el.handler);
 },
 // 当传进来的值更新的时候触发
 componentupdated(el, { value }) {
   el.$value = value;
 },
 // 指令与元素解绑的时候，移除事件绑定
 unbind(el) {
   el.removeeventlistener("click", el.handler);
 },
};

<button v-copy="copycontent">点击复制</button>

data(){
 return {
   copycontent: "复制出来的信息",
 }
}

一键长按

需求：

实现长按，用户需要按下并按住按钮几秒钟，触发相应的事件

思路：

创建一个计时器， 2 秒后执行函数

当用户按下按钮时触发 mousedown 事件，启动计时器；用户松开按钮时调用 mouseout 事件。

如果 mouseup 事件 2 秒内被触发，就清除计时器，当作一个普通的点击事件

如果计时器没有在 2 秒内清除，则判定为一次长按，可以执行关联的函数。

在移动端要考虑 touchstart，touchend 事件

export default {
 bind: function (el, binding, vnode) {
   // 判断类型
   if (typeof binding.value !== "function") {
     throw "callback must be a function";
   }
   // 定义变量
   let presstimer = null;
   // 创建定时器,两秒后执行
   let start = (e) => {
     if (e.type === "click" && e.button !== 0) {
       return;
     }
     if (presstimer === null) {
       presstimer = settimeout(() => {
         handler();
       }, 2000);
     }
   };
   // 取消定时器
   let cancel = (e) => {
     if (presstimer !== null) {
       cleartimeout(presstimer);
       presstimer = null;
     }
   };
   // 运行函数
   const handler = (e) => {
     binding.value(e);
   };
   // 添加事件监听器
   el.addeventlistener("mousedown", start);
   el.addeventlistener("touchstart", start);
   // 取消计时器
   el.addeventlistener("click", cancel);
   el.addeventlistener("mouseout", cancel);
   el.addeventlistener("touchend", cancel);
   el.addeventlistener("touchcancel", cancel);
 },
 // 当传进来的值更新的时候触发
 componentupdated(el, { value }) {
   el.$value = value;
 },
 // 指令与元素解绑的时候，移除事件绑定
 unbind(el) {
   el.removeeventlistener("click", el.handler);
 },
};

<!-- longpress 必须是一个函数 -->
<button v-longpress="longpress">两秒长按</button>

防抖

需求：

防止按钮在短时间内被多次点击，使用防抖函数限制规定时间内只能点击一次。

思路：

定义一个延迟执行的方法，如果在延迟时间内再调用该方法，则重新计算执行时间。

将时间绑定在 click 方法上。

export default {
    inserted: function(el,binding) {
        let timer;
        el.addeventlistener("click", () => {
            if(timer) {
                cleartimeout(timer)
            }
            timer = settimeout(() => {
                binding.value()
            },1000)
        })
    }
}

<!-- 防抖 -->
<button v-debounce="debounceclick">点击防抖</button>

 debounceclick() {
    console.log("就应该只触发一次");
  },

限制输入框类型

开发中遇到的表单输入，往往会有对输入内容的限制，比如不能输入表情和特殊字符，只能输入数字或字母等。

我们常规方法是在每一个表单的 on-change 事件上做处理。这样代码量比较大而且不好维护

需求：

根据正则表达式，设计自定义处理表单输入规则的指令，下面以禁止输入表情和特殊字符为例。

let findele = (parent, type) => {
return parent.tagname.tolowercase() === type
  ? parent
  : parent.queryselector(type);
};

const trigger = (el, type) => {
const e = document.createevent("htmlevents");
e.initevent(type, true, true);
el.dispatchevent(e);
};

export default {
bind: function (el, binding, vnode) {
  // 正则规则可根据需求自定义 
  // var regrule = /[^u4e00-u9fa5|d|a-za-z|rns,.?!，。？！…—&$=()-+/*{}[]]|s/g;
  var regrule = /[^\u4e00-\u9fa5\da-za-z]|/g; // 只能输入中文,英文和数字
  let $inp = findele(el, "input");
  el.$inp = $inp;
  $inp.handle = function () {
    let val = $inp.value;
    $inp.value = val.replace(regrule, "");
    trigger($inp, "input");
  };
  $inp.addeventlistener("keyup", $inp.handle);
},
unbind: function (el) {
  el.$inp.removeeventlistener("keyup", el.$inp.handle);
},
};

使用

 <!-- 限制输入类型 -->
<input type="text" v-model="value" v-emoji>

图片懒加载

需求：实现一个图片懒加载指令，只加载浏览器可见区域的图片。

思路：

图片懒加载的原理主要是判断当前图片是否到了可视区域这一核心逻辑实现的

拿到所有的图片 dom ，遍历每个图片判断当前图片是否到了可视区范围内

如果到了就设置图片的 src 属性，否则显示默认图片

图片懒加载有两种方式可以实现，一是绑定 srcoll 事件进行监听，二是使用 intersectionobserver 判断图片是否到了可视区域，

但是有浏览器兼容性问题。

下面封装一个懒加载指令兼容两种方法，判断浏览器是否支持 intersectionobserver api，

如果支持就使用 intersectionobserver 实现懒加载，否则则使用 srcoll 事件监听 + 节流的方法实现。

使用时:<img v-lazyload="xxx.jpg" /> 将组件内标签的 src 换成 v-lazyload

export default {
  install(vue, options) {
    const defaultsrc = options.default; 
    vue.directive("lazy", {
      bind(el, binding) {
        lazyload.init(el, binding.value, defaultsrc);
      },
      inserted(el) {
        if (intersectionobserver) {
          lazyload.observe(el);
        } else {
          lazyload.listenerscroll(el);
        }
      },
    });
  },
  // 初始化
  init(el, val, def) {
    el.setattribute("data-src", val);
    el.setattribute("src", def);
  },
  // 利用intersectionobserver监听el
  observe(el) {
    var io = new intersectionobserver((entries) => {
      const realsrc = el.dataset.src;
      if (entries[0].isintersecting) {
        if (realsrc) {
          el.src = realsrc;
          el.removeattribute("data-src");
        }
      }
    });
    io.observe(el);
  },
  // 监听scroll事件
  listenerscroll(el) {
    const handler = lazyload.throttle(lazyload.load, 300);
    lazyload.load(el);
    window.addeventlistener("scroll", () => {
      handler(el);
    });
  },
  // 加载真实图片
  load(el) {
    const windowheight = document.documentelement.clientheight;
    const eltop = el.getboundingclientrect().top;
    const elbtm = el.getboundingclientrect().bottom;
    const realsrc = el.dataset.src;
    if (eltop - windowheight < 0 && elbtm > 0) {
      if (realsrc) {
        el.src = realsrc;
        el.removeattribute("data-src");
      }
    }
  },
  // 节流
  throttle(fn, delay) {
    let timer;
    let prevtime;
    return function (...args) {
      const currtime = date.now();
      const context = this;
      if (!prevtime) prevtime = currtime;
      cleartimeout(timer);

      if (currtime - prevtime > delay) {
        prevtime = currtime;
        fn.apply(context, args);
        cleartimeout(timer);
        return;
      }

      timer = settimeout(function () {
        prevtime = date.now();
        timer = null;
        fn.apply(context, args);
      }, delay);
    };
  },
};

页面内指定容器的权限判断

背景：

在一些后台管理系统，我们可能需要根据用户角色进行一些操作权限的判断，

很多时候我们都是粗暴地给一个元素添加 v-if / v-show 来进行显示隐藏，

但如果判断条件繁琐且多个地方需要判断，这种方式的代码不仅不优雅而且冗余。

针对这种情况，我们可以通过全局自定义指令来处理。

需求：自定义一个权限指令，对需要权限判断的 dom 进行显示隐藏。

思路：

自定义一个权限数组

判断用户的权限是否在这个数组内，如果是则显示，否则则移除 dom

function checkarray(key) {
  let arr = ["1", "2", "3", "4"];
  let index = arr.indexof(key);
  if (index > -1) {
    return true; // 有权限
  } else {
    return false; // 无权限
  }
}

export default {
  inserted: function (el, binding) {
    let permission = binding.value; // 获取到 v-permission的值
    if (permission) {
      let haspermission = checkarray(permission);
      if (!haspermission) {
        // 没有权限 移除dom元素
        el.parentnode && el.parentnode.removechild(el);
      }
    }
  },
};

使用时:示例

<!-- 显示 -->
  <button v-permission="'1'">权限按钮1</button>

  <!-- 不显示 -->
  <button v-permission="'10'">权限按钮2</button></div>

页面添加水印

需求：给整个页面添加背景水印

思路：

使用 canvas 特性生成 base64 格式的图片文件，设置其字体大小，颜色等。

将其设置为背景图片，从而实现页面或组件水印效果

function addwatermarker(str, parentnode, font, textcolor) {
  // 水印文字，父元素，字体，文字颜色
  var can = document.createelement("canvas");
  parentnode.appendchild(can);
  can.width = 200;
  can.height = 150;
  can.style.display = "none";
  var cans = can.getcontext("2d");
  cans.rotate((-20 * math.pi) / 180);
  cans.font = font || "16px microsoft jhenghei";
  cans.fillstyle = textcolor || "rgba(180, 180, 180, 0.3)";
  cans.textalign = "left";
  cans.textbaseline = "middle";
  cans.filltext(str, can.width / 10, can.height / 2);
  parentnode.style.backgroundimage = "url(" + can.todataurl("image/png") + ")";
}
export default {
    bind: function (el, binding) {
        addwatermarker(binding.value.text, el, binding.value.font, binding.value.textcolor)
    },
}

使用时:

<div v-watermarker="{text:'bjg版权所有',textcolor:'rgba(180, 180, 180, 0.4)'}"></div>

指定 dom 拖拽

需求：

实现一个拖拽指令，可在页面可视区域任意拖拽元素。

思路：

设置需要拖拽的元素为相对定位，其父元素为绝对定位。

鼠标按下(onmousedown)时记录目标元素当前的 left 和 top 值。

鼠标移动(onmousemove)时计算每次移动的横向距离和纵向距离的变化值，并改变元素的 left 和 top 值

鼠标松开(onmouseup)时完成一次拖拽

export default {
 inserted: function (el) {
   el.style.cursor = "move";
   el.onmousedown = function (e) {
     let disx = e.pagex - el.offsetleft;
     let disy = e.pagey - el.offsettop;
     document.onmousemove = function (e) {
       let x = e.pagex - disx;
       let y = e.pagey - disy;
       let maxx =
         document.body.clientwidth -
         parseint(window.getcomputedstyle(el).width);
       let maxy =
         document.body.clientheight -
         parseint(window.getcomputedstyle(el).height);
       if (x < 0) {
         x = 0;
       } else if (x > maxx) {
         x = maxx;
       }

       if (y < 0) {
         y = 0;
       } else if (y > maxy) {
         y = maxy;
       }

       el.style.left = x + "px";
       el.style.top = y + "px";
     };
     document.onmouseup = function () {
       document.onmousemove = document.onmouseup = null;
     };
   };
 },
};

使用时:

<div class="el-dialog" v-draggable></div>

指定容器根据内容判断是否显示

如果传过来的对象或者数组为空,则不显示该dom元素

// 判断对象或数组是否为空
function isempty(obj) {
 if (array.isarray(obj)) {
   return obj.length === 0;
 } else if (typeof obj === "object") {
   return object.keys(obj).length === 0;
 }
 return true; // 其他类型默认为空
}
export default {
 inserted: function (el, binding) {
   const value = binding.value;
   if (isempty(value)) {
     el.style.display = "none";
   }
 },
};

以上就是vue2常用全局自定义指令的封装详解的详细内容，更多关于vue2全局自定义指令的资料请关注代码网其它相关文章！