零星的JavaScript公用方法,JavaScript常用脚本集中

前者基础进阶(10):面向对象实战之封装拖拽对象

2017/04/02 · JavaScript
·
面向对象

初稿出处: 波同学   

澳门葡京 1

终于

眼前几篇小说,我跟大家享受了JavaScript的部分基础知识,那篇小说,将会进入第二个实战环节:利用前边几章的所涉嫌到的学识,封装一个拖拽对象。为了可以扶助我们了然更加多的艺术与举办对照,我会使用三种不相同的不二法门来兑现拖拽。

  • 不封装对象直接完结;
  • 利用原生JavaScript封装拖拽对象;
  • 通过扩充jQuery来落到实处拖拽对象。

本文的例证会停放于codepen.io中,供我们在翻阅时一直查看。假如对于codepen不打听的校友,可以花点时间有些精晓一下。

拖拽的完结进度会涉及到非凡多的实用小知识,因而为了巩固自己要好的学识积累,也为了大家可以学到越来越多的知识,我会尽量详细的将部分细节分享出去,相信我们认真阅读之后,一定能学到一些事物。

复制代码 代码如下:

function stopBubble(e) {
if (e && e.stopPropagation) {//即使传入了轩然大波目标,那么就是非IE浏览器
e.stopPropagation();
} else {
window.event.cancelBubble = true;//使用IE的不二法门来撤废事件冒泡
}
}
function stopDefault(e) {
if (e && e.preventDefault) {
e.preventDefault();//幸免默许浏览器行为(W3C)
} else {
window.event.returnValue = false;
}
return false;
}

JavaScript常用脚本集中(三)

 本文给大家分享的常用脚本有通过数组,拓展字符串拼接简单造成品质的标题、页面
视口
滚动条的岗位的拉扯函数、调节因素透明度的函数、获取鼠标地方的多少个通用的函数、使用cssdisplay属性来切换元素可知性的一组函数、样式相关的通用函数、获取元素当前的中度和幅度。

 

 

经过数组,拓展字符串拼接简单导致品质的标题

 

代码如下:

function StringBuffer() {
this.__strings__ = new Array();
}
StringBuffer.prototype.append = function (str) {
this.__strings__.push(str);
return this;
}
StringBuffer.prototype.toString = function () {
return this.__strings__.join(“”);
}
var buffer = new StringBuffer();
buffer.append(“Hello “).append(“javascript”);
var result = buffer.toString();
alert(result); //Hello javascript

页面 视口 滚动条的地方的援救函数

 

代码如下:

/*规定当前页面高度和宽窄的多少个函数*/
function pageHeight() {
return document.body.scrollHeight;
}
function pageWidth() {
return document.body.scrollWidth;
}
/*确定滚动条水平和垂直的职责*/
function scrollX() {
var de = document.documentElement;
return self.pageXOffset || (de && de.scrollLeft) ||
document.body.scrollLeft;
}
function scrollY() {
var de = document.documentElement;
return self.pageYOffset || (de && de.scrollTop) ||
document.body.scrollTop;
}
/*确定浏览器视口的可观和幅度的五个函数*/
function windowHeight() {
var de = document.documentElement;
return self.innerHeight || (de && de.clientHeight) ||
document.body.clientHeight;
}
function windowWidth() {
var de = document.documentElement;
return self.innerWidth || (de && de.clientWidth) ||
document.body.clientWidth;
}

调节因素透明度的函数

 

代码如下:

/*调剂因素透明度的函数*/
function setOpacity(elem, level) {
//IE处理透明度
if (elem.filters) {
elem.style.filters = ‘alpha(opacity=’ + level + ‘)’;
} else {
elem.style.opacity = level / 100;
}
}

收获鼠标地点的几个通用的函数

 

代码如下:

/*五个通用函数,用于获取鼠标相对于一体页面的脚下任务*/
function getX(e) {
e = e || window.event;
return e.pageX || e.clientX + document.body.scrollLeft;
}
function getY(e) {
e = e || window.event;
return e.pageY || e.clientY + document.body.scrollTop;
}
/*五个得到鼠标相对于当下元素地点的函数*/
function getElementX(e) {
return (e && e.layerX) || window.event.offsetX;
}
function getElementY(e) {
return (e && e.layerY) || window.event.offsetY;
}

接纳cssdisplay属性来切换元素可知性的一组函数

 

代码如下:

/**
* 使用display来隐藏元素的函数
* */
function hide(elem) {
var curDisplay = getStyle(elem, ‘display’);

 

if (curDisplay != ‘none’) {
elem.$oldDisplay = curDisplay;
}
零星的JavaScript公用方法,JavaScript常用脚本集中。elem.style.display = ‘none’;
}
/**
* 使用display来展现元素的函数
* */
function show(elem) {
elem.style.display = elem.$oldDisplay || ”;
}

体制相关的通用函数

 

代码如下:

/**
* 获取指定元素(elem)的体制属性(name)
* */
function getStyle(elem, name) {
//即使存在于style[]中,那么它已被安装了(并且是眼下的)
if (elem.style[name]) {
return elem.style[name];
}
//否则,测试IE的方法
else if (elem.currentStyle) {
return elem.currentStyle[name];
}
//或者W3C的方法
else if(document.defaultView &&
document.defaultView.getComputedStyle){
name = name.replace(/(A-Z)/g, “-$1”);
name = name.toLowerCase();
var s = document.defaultView.getComputedStyle(elem, “”);
return s && s.getPropertyValue(name);
}
//否则,用户拔取的是其余浏览器
else {
return null;
}
}

获取元素当前的万丈和增幅

 

代码如下:

/**
* 获取元素的忠实中度
* 着重的getStyle见上面的函数。
* */
function getHeight(elem) {
return parseInt(getStyle(elem, ‘height’));
}
/**
* 获取元素的真正宽度
* 信赖的getStyle见上面的函数
* */
function getWidth(elem) {
return parseInt(getStyle(elem, ‘width’));
}

以上就是本文分享的javascript常用脚本了,希望大家可以欣赏。

本文给大家大快朵颐的常用脚本有通过数组,拓展字符串拼接简单造成质量的题材、页面
视口 滚动条的职位的扶助…

1、怎么样让一个DOM元素动起来

大家寻常会通过修改元素的top,left,translate来其的职责暴发转移。在下面的事例中,每点击五次按钮,对应的要素就会活动5px。我们可点击查阅。

点击查看一个让元素动起来的小例子

由于修改一个元素top/left值会挑起页面重绘,而translate不会,由此从性质优化上来判断,我们会事先选拔translate属性。

//获取元素的样式值。
function getStyle(elem,name){
if(elem.style[name]){
return elem.style[name];
}else if(elem.currentStyle){
return elem.currentStyle[name];
}else if(document.defaultView&&document.defaultView.getComputedStyle){
name=name.replace(/([A-Z])/g,”-$1″);
name=name.toLowerCase();
var s=document.defaultView.getComputedStyle(elem,””);
return s&&s.getPropertyValue(name);
}else{
return null
}
}
//获取元素相对于这些页面的x和y坐标。
function pageX(elem){
return
elem.offsetParent?(elem.offsetLeft+pageX(elem.offsetParent)):elem.offsetLeft;
}
function pageY(elem){
return
elem.offsetParent?(elem.offsetTop+pageY(elem.offsetParent)):elem.offsetTop;
}
//获取元素相对于父元素的x和y坐标。
function parentX(elem){
return
elem.parentNode==elem.offsetParent?elem.offsetLeft:pageX(elem)-pageX(elem.parentNode);
}
function parentY(elem){
return
elem.parentNode==elem.offsetParent?elem.offsetTop:pageY(elem)-pageY(elem.parentNode);
}
//获取使用css定位的因素的x和y坐标。
function posX(elem){
return parseInt(getStyle(elem,”left”));
}
function posY(elem){
return parseInt(getStyle(elem,”top”));
}
//设置元素地点。
function setX(elem,pos){
elem.style.left=pos+”px”;
}
function setY(elem,pos){
elem.style.top=pos+”px”;
}
//增新币素X和y坐标。
function addX(elem,pos){
set(elem,(posX(elem)+pos));
}
function addY(elem,pos){
set(elem,(posY(elem)+pos));
}
//获取元素运用css控制大小的可观和宽度
function getHeight(elem){
return parseInt(getStyle(elem,”height”));
}
function getWidth(elem){
return parseInt(getStyle(elem,”width”));
}
//获取元素可能,完整的中度和幅度
function getFullHeight(elem){
if(getStyle(elem,”display”)!=”none”){
return getHeight(elem)||elem.offsetHeight;
}else{
var
old=resetCss(elem,{display:”block”,visibility:”hidden”,position:”absolute”});
var h=elem.clientHeight||getHeight(elem);
restoreCss(elem,old);
return h;
}
}
function getFullWidth(elem){
if(getStyle(elem,”display”)!=”none”){
return getWidth(elem)||elem.offsetWidth;
}else{
var
old=resetCss(elem,{display:”block”,visibility:”hidden”,position:”absolute”});
var w=elem.clientWidth||getWidth(elem);
restoreCss(elem,old);
return w;
}
}
//设置css,并保存旧的css
function resetCss(elem,prop){
var old={};
for(var i in prop){
old[i]=elem.style[i];
elem.style[i]=prop[i];
}
return old;
}
function restoreCss(elem,prop){
for(var i in prop){
elem.style[i]=prop[i];
}
}
//突显和潜伏
function show(elem){
elem.style.display=elem.$oldDisplay||” “;
}
function hide(elem){
var curDisplay=getStyle(elem,”display”);
if(curDisplay!=”none”){
elem.$oldDisplay=curDisplay;
elem.style.display=”none”;
}
}
//设置透明度
function setOpacity(elem,num){
if(elem.filters){
elem.style.filter=”alpha(opacity=”+num+”)”;
}else{
elem.style.opacity=num/100;
}
}
//滑动
function slideDown(elem){
var h=getFullHeight(elem);
elem.style.height=”0px”;
show(elem);
for(var i=0;i<=100;i+=5){
new function(){
var pos=i;
setTimeout(function(){elem.style.height=(pos/100*h)+”px”;},(pos*10));
}
}
}
//渐变
function fadeIn(elem){
show(elem);
setOpacity(elem,0);
for(var i=0;i<=100;i+=5){
new function(){
var pos=i;
setTimeout(function(){setOpacity(elem,pos);},(pos+1)*10);
}
}
}
//获取鼠标光标相对于全部页面的岗位。
function getX(e){
e=e||window.event;
return e.pageX||e.clientX+document.body.scrollLeft;
}
function getY(e){
e=e||window.event;
return e.pageY||e.clientY+document.body.scrollTop;
}
//获取鼠标光标相对于近期因素的职位。
function getElementX(e){
return (e&&e.layerX)||window.event.offsetX;
}
function getElementY(e){
return (e&&e.layerY)||window.event.offsetY;
}
//获取页面的中度和幅度
function getPageHeight(){
var de=document.documentElement;
return document.body.scrollHeight||(de&&de.scrollHeight);
}
function getPageWidth(){
var de=document.documentElement;
return document.body.scrollWidth||(de&&de.scrollWidth);
}
//获取滚动条的职位。
function scrollX(){
var de=document.documentElement;
return
self.pageXOffset||(de&&de.scrollLeft)||document.body.scrollLeft;
}
function scrollY(){
var de=document.documentElement;
return self.pageYOffset||(de&&de.scrollTop)||document.body.scrollTop;
}
//获取视口的冲天和幅度。
function windowHeight() {
var de = document.documentElement;
return self.innerHeight||(de &&
de.offsetHeight)||document.body.offsetHeight;
}
function windowWidth() {
var de = document.documentElement;
return self.innerWidth||( de && de.offsetWidth
)||document.body.offsetWidth;
}

function addEvent(element, type, handler) {
if (!handler.$$guid) {//为每一个事件处理函数赋予一个独立的ID
handler.$$guid = addEvent.guid++;
}
if (!element.events) {//为元素建立一个轩然大波类型的散列表
element.events = {};
}
var handlers = element.events[type];
if (!handler) {
handlers = element.events[type] = {};
if (element[“on” + type])
{//存储已部分事件处理函数(如果已经存在一个)
handlers[0] = element[“on” + type];
}
}
handlers[handler.$$guid] = handler;//在散列表中存在该事件处理函数
element[“on” + type] = handleEvent;
}
add伊夫nt.guid = 1;//创造独立ID的计数器
function remove伊夫nt(element, type, handler)
{//从散列表中删除事件处理函数
if (element.events && element.events[type]) {
delete element.events[type][handler.$$guid];
}
}
function handleEvent(event) {
var returnValue = true;
event = event ||
fix伊芙nt(window.event);//得到事件目的(IE使用全局的事件目的)
var handlers =
this.events[event.type];//得到事件处理函数散列表的引用
for (var i in handlers) {//依次执行各类事件处理函数
this.$$handlerEvent = handlers[i];
if (this.$$handlerEvent(event) === false) {
returnValue = false;
}
}
return returnValue;
}
function fix伊夫nt(event) {//扩大一些IE事件目标的缺少的方法
event.preventDefault = fix伊芙nt.preventDefault;//扩充W3C标准事件措施
event.stopPropagation = fixEvent.stopPropagation;
return event;
}
fixEvent.preventDefault = function () {
this.returnValue = false;
}
fixEvent.stopPropagation = function () {
this.cancelBubble = true;
}
//获取指定元素elem的体制属性
function getStyle(elem, name) {
if (elem.style[name])
{//假设属性存在于style[]中,那么它已被安装了(并且是眼下的)
return elem.style[name];
} else {
if (elem.currentStyle) {//尝试使用IE的方法
return elem.currentStyle[name];
} else if (document.defaultView &&
document.defaultView.getComputedStyle) {//或者W3C的办法,倘诺存在的话
//name=name.replace(/([A-Z)/g,”-$1″);
name = name.toLowerCase();
var s = document.defaultView.getComputedStyle(elem,
”);//获取样式对象并获取属性(存在的话)值
return s && s.getPropertyValue(name);
澳门葡京 ,} else {
return null;
}
}
}
//获取元素的X(水平、左端)地点
function pageX(elem) {
return elem.offsetParent ?//查看我们是还是不是位于根元素
elem.offsetLeft + pageX(elem.offsetParent)
://假使大家能两次三番取得上一个因素,增添当前的偏移量并继承上扬递归
elem.offsetLeft;//否则获得当前的偏移量
}
//得到元素Y(垂直、顶端)地方
function pageY(elem) {
return elem.offsetParent ?//查看咱们是不是位于根元素
elem.offsetTop + pageY(elem.offsetParent)
://假如能继承获得上一个因素,扩充当前的偏移量并无冕上扬递归
elem.offsetTop;//否则获取当前的偏移量
}
//获取元素相对于大叔的品位地点
function parentX(elem) {
return elem.parentNode == elem.offsetParent
?//若是offsetParent是因素的生父,那么提前退出
elem.offsetLeft :
pageX(elem) –
pageX(elem.parentNode);//否则,大家需求找到元素和因素的阿爸相对于整个页面地方,并盘算他们以前的差
}
//获取元素相对于岳丈的垂直地方
function parentY(elem) {
return elem.parentNode == elem.offsetParent
?//要是offsetParent是因素的阿爸,那么提前退出
elem.offsetTop :
pageX(elem) –
pageY(elem.parentNode);//否则,大家须要找到元素和要素的老爹相对于全体页面地方,并统计他们事先的差
}
//苏醒css原的特性值 幸免reset css函数副作用的函数
function restoreCSS(elem, prop) {
for (var i in prop) {//重置所有属性,復苏它们的原有值
elem.style[i] = prop[i];
}
}
//设置CSS一组属性的函数,它可以復苏到原有设置
function resetCSS(elem, prop) {
var old = [];
for (var i in prop) {
old[i] = elem.style[i];//记录旧的属性值
elem.style[i] = prop[i];//并安装新的值
}
return old;//再次回到已经成形的值集合,预留给restoreCSS函数使用
}
function getHeight(elem) {//获得元素的真人真事高度
return parseInt(getStyle(elem,
‘height’));//得到CSS的末梢值并分析出可用的数值
}
function getWidth(elem) {//获得元素的实在宽度
return parseInt(getStyle(elem,
‘width’));//拿到CSS的末段值并分析出可用的数值
}
//查找元素完整的,可能的冲天
function fullHeight(elem) {
//假诺元素是显得的,那么使用offsetHeight就能获取中度,如若没有offsetHeight,则使用getHeight()
if (getStyle(elem, ‘display’) != ‘none’) {
return elem.offsetHeight || getHeight(elem);
}
//处理display为none的元素,所以重置它的css属性以赢得更规范的读数
var old = resetCSS(elem, {
display: ”,
visibility: ‘hidden’,
position: ‘absolute’
});
var h = elem.clientHeight ||
getHeight(elem);//使用clientHeihgt找到元素的完全中度,假诺还不见效,则利用getHeight函数
restoreCSS(elem, old);//苏醒css原的性质
return h;//重临元素的完整中度
}
//查找元素完整的,可能的大幅度
function fullWidth(elem) {
//倘若元素是突显的,那么使用offsetWidth就能得到中度,如若没有offsetHeight,则使用getHeight()
if (getStyle(elem, ‘display’) != ‘none’) {
return elem.offsetWidth || getWidth(elem);
}
//处理display为none的元素,所以重置它的css属性以赢得更规范的读数
var old = resetCSS(elem, {
display: ”,
visibility: ‘hidden’,
position: ‘absolute’
});
var h = elem.clientWidth ||
getWidth(elem);//使用clientWidth找到元素的完全中度,倘诺还不奏效,则利用getWidth函数
restoreCSS(elem, old);//苏醒css原的习性
return h;//再次回到元素的一体化中度
}

连带小说

连锁搜索:

今日看啥

探寻技术库

回到首页

  • 隐性调用php程序的艺术
  • 浅谈JavaScript中的Math.atan()方法的拔取
  • JavaScript中反正弦函数Math.asin()的运用简介
  • JavaScript中的acos()方法运用详解
  • 介绍JavaScript中Math.abs()方法的利用
  • JavaScript中Math.SQRT2属性的选拔详解

有关频道:
HTML/CSS  HTML5  Javascript  jQuery  AJax教程  前端代码  正则表明式  Flex教程  WEB前端教程  

2、怎么着得到当前浏览器协助的transform兼容写法

transform是css3的特性,当大家应用它时就只能够面对包容性的难点。差异版本浏览器的万分写法大概有如下二种:

['transform', 'webkitTransform', 'MozTransform', 'msTransform', 'OTransform']

由此大家需求看清当前浏览器环境辅助的transform属性是哪类,方法如下:

JavaScript

// 获取当前浏览器帮忙的transform包容写法 function getTransform() { var
transform = ”, divStyle = document.createElement(‘div’).style, //
可能涉及到的两种包容性写法,通过巡回找出浏览器识其余那些 transformArr
= [‘transform’, ‘webkitTransform’, ‘MozTransform’, ‘msTransform’,
‘OTransform’], i = 0, len = transformArr.length; for(; i < len; i++)
{ if(transformArr[i] in divStyle) { // 找到之后立刻回去,为止函数
return transform = transformArr[i]; } } //
假如没有找到,就径直回到空字符串 return transform; }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 获取当前浏览器支持的transform兼容写法
function getTransform() {
    var transform = ”,
        divStyle = document.createElement(‘div’).style,
        // 可能涉及到的几种兼容性写法,通过循环找出浏览器识别的那一个
        transformArr = [‘transform’, ‘webkitTransform’, ‘MozTransform’, ‘msTransform’, ‘OTransform’],
 
        i = 0,
        len = transformArr.length;
 
    for(; i < len; i++)  {
        if(transformArr[i] in divStyle) {
            // 找到之后立即返回,结束函数
            return transform = transformArr[i];
        }
    }
 
    // 如果没有找到,就直接返回空字符串
    return transform;
}

该办法用于获取浏览器辅助的transform属性。如果回去的为空字符串,则意味近年来浏览器并不扶助transform,这几个时候大家就须求动用left,top值来改变元素的地方。若是协助,就改成transform的值。

你或许感兴趣的文章:

  • jQuery常用知识点统计以及平日打包常用函数
  • 依据jquery封装的一个js分页
  • jquery数组封装使用方式分享(jquery数组遍历)
  • Jquery封装tab自动切换效果的切实可行落实
  • jquery自动将form表单封装成json的现实贯彻
  • jquery
    datatable后台封装数据示例代码
  • jQuery大旨图切换特效插件封装实例
  • 依照jquery的用dl模拟已毕可自定义样式的SELECT下拉列表(已打包)
  • jQueryUI的Dialog的简练包装
  • 【经典源码收藏】基于jQuery的品类常见函数封装集合

function hide(elem) {//隐藏元素
var curDisplay = getStyle(elem, ‘display’);//找到元素display的当下场所
if (curDisplay != ‘none’) {//记录它的display状态
elem.$oldDisplay = curDisplay;
}
elem.style.display = ‘none’;//设置display为none 隐藏元素
}
function show(elem) {//显示元素
elem.style.display = elem.$oldDisplay ||
”;//设置display属性为它的原始值,如没有记录原始值 则选择block
}

帮客评论

3、 怎么样赢得元素的开首地方

大家首先须要得到到目标元素的初叶地点,因而这里大家要求一个专门用来收获元素样式的效果函数。

不过获取元素样式在IE浏览器与其余浏览器有局地差异,由此大家须求一个包容性的写法。

JavaScript

function getStyle(elem, property) { //
ie通过currentStyle来博取元素的体制,其他浏览器通过getComputedStyle来收获
return document.defaultView.getComputedStyle ?
document.defaultView.getComputedStyle(elem, false)[property] :
elem.currentStyle[property]; }

1
2
3
4
function getStyle(elem, property) {
    // ie通过currentStyle来获取元素的样式,其他浏览器通过getComputedStyle来获取
    return document.defaultView.getComputedStyle ? document.defaultView.getComputedStyle(elem, false)[property] : elem.currentStyle[property];
}

有了那些法子之后,就可以起来入手写获取目的元素开端地点的不二法门了。

JavaScript

function getTargetPos(elem) { var pos = {x: 0, y: 0}; var transform =
getTransform(); if(transform) { var transformValue = getStyle(elem,
transform); if(transformValue == ‘none’) { elem.style[transform] =
‘translate(0, 0)’; return pos; } else { var temp =
transformValue.match(/-?\d+/g); return pos = { x:
parseInt(temp[4].trim()), y: parseInt(temp[5].trim()) } } } else {
if(getStyle(elem, ‘position’) == ‘static’) { elem.style.position =
‘relative’; return pos; } else { var x = parseInt(getStyle(elem, ‘left’)
? getStyle(elem, ‘left’) : 0); var y = parseInt(getStyle(elem, ‘top’) ?
getStyle(elem, ‘top’) : 0); return pos = { x: x, y: y } } } }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
function getTargetPos(elem) {
    var pos = {x: 0, y: 0};
    var transform = getTransform();
    if(transform) {
        var transformValue = getStyle(elem, transform);
        if(transformValue == ‘none’) {
            elem.style[transform] = ‘translate(0, 0)’;
            return pos;
        } else {
            var temp = transformValue.match(/-?\d+/g);
            return pos = {
                x: parseInt(temp[4].trim()),
                y: parseInt(temp[5].trim())
            }
        }
    } else {
        if(getStyle(elem, ‘position’) == ‘static’) {
            elem.style.position = ‘relative’;
            return pos;
        } else {
            var x = parseInt(getStyle(elem, ‘left’) ? getStyle(elem, ‘left’) : 0);
            var y = parseInt(getStyle(elem, ‘top’) ? getStyle(elem, ‘top’) : 0);
            return pos = {
                x: x,
                y: y
            }
        }
    }
}

在拖拽进程中,我们必要不停的安装目的元素的新职责,这样它才会移动起来,因而大家须求一个设置目的元素地方的主意。

JavaScript

// pos = { x: 200, y: 100 } function setTargetPos(elem, pos) { var
transform = getTransform(); if(transform) { elem.style[transform] =
‘translate(‘+ pos.x +’px, ‘+ pos.y +’px)’; } else { elem.style.left =
pos.x + ‘px’; elem.style.top = pos.y + ‘px’; } return elem; }

1
2
3
4
5
6
7
8
9
10
11
// pos = { x: 200, y: 100 }
function setTargetPos(elem, pos) {
    var transform = getTransform();
    if(transform) {
        elem.style[transform] = ‘translate(‘+ pos.x +’px, ‘+ pos.y +’px)’;
    } else {
        elem.style.left = pos.x + ‘px’;
        elem.style.top = pos.y + ‘px’;
    }
    return elem;
}

function setOpacity(elem, level) {//设置元素透明度 级别从0-100
if (elem.filters) {//借使存在filters这些属性 则它是IE
所以设置元素的Alpha滤镜
elem.style.filters = “alpha(opacity=” + level + “)”;
} else {
elem.style.opacity = level / 100;//使用W3C的opacity属性
}
}
function slideDown(elem) {
elem.style.height = ‘0px’;//从0高度开端滑动
show(elem);//先突显元素(不过看不到它,因为它的冲天是0)
var h = fullHeight(elem);//找到元素的完好的地下中度
for (var i = 0; i <= 100; i += 5) {//在一分钟内执行一个20帧的卡通片
//保障可以维持正确的i的闭包函数
(function () {
var pos = i;
setTimeout(function () {
elem.style.height = ((pos / 100) * h) + ‘px’;
}, (pos + 1) * 10);
})();
}
}
function fadeIn(elem) {
setOpacity(elem, 0);//从0透明度先河
show(elem);//先突显元素(不过看不到它,因为它的透明度是0)
for (var i = 0; i <= 100; i += 5) {//在一分钟内执行一个20帧的动画
//保障可以保持正确的i的闭包函数
(function () {
var pos = i;
setTimeout(function () {
setOpacity(elem, pos);
}, (pos + 1) * 10);
})();
}
}
function getX(e) {//获取光标的档次地方
e = e || window.event;//标准化事件目标
return e.pageX || e.clientX +
document.body.scrollLeft;//先检查非IE浏览器的职务,再自我批评IE的职位
}
function getY(e) {//获取光标的垂直地方
e = e || window.event;//标准化事件目标
return e.pageY || e.clientY +
document.body.scrollTop;//先检查非IE浏览器的职责,再自我批评IE的任务
}
function getElementX(e)
{//得到鼠标相对于当下元素(事件对象e的性质target)的X地方
return (e && e.layerX) || window.event.offsetX;//得到不错的偏移量
}
function getElementY(e)
{//得到鼠标相对于近年来因素(事件对象e的特性target)的Y地点
return (e && e.layerY) || window.event.offsetY;//得到正确的偏移量
}
function pageHeight() {//重临页面的惊人(扩充内容的时候也许会改变)
return document.body.scrollHeight;
}
function pageWidth() {//重回页面的涨幅(增添内容的时候也许会改变)
return document.body.scrollWidth;
}
function scrollX() {//确定浏览器水平滚动地方的函数
var de = document.documentElement;
return self.pageXOffset ||//假如浏览器存在pageXOffset属性 则使用它
(de || de.scrollLeft) ||//尝试获取根节点的左端滚动的偏移量
document.body.scrollLeft;//尝试获取body元素的左端滚动的偏移量
}
function scrollY() {//确定浏览器垂直滚动地点的函数
var de = document.documentElement;
return self.pageYOffset ||//借使浏览器存在pageYOffset属性 则利用它
(de || de.scrollTop) ||//尝试获取根节点的顶端滚动的偏移量
document.body.scrollTop;//尝试得到body元素的上边滚动的偏移量
}
function windowHeight() {//获取视口的高度
var de = document.documentElement;
return self.innerHeight ||////如若浏览器存在innerHeight属性 则使用它
(de && de.clientHeight) ||//尝试获取根节点的冲天偏移量
document.body.clientHeight;//尝试获取body元素的中度偏移量
}
function windowWidth() {//获取视口的拉长率
var de = document.documentElement;
return self.innerWidth ||////假如浏览器存在innerWidth属性 则使用它
(de && de.clientWidth) ||//尝试获取根节点的莫大偏移量
document.body.clientWidth;//尝试获取body元素的惊人偏移量
}

5、大家要求用到何以事件?

在pc上的浏览器中,结合mousedown、mousemove、mouseup这多个事件可以协理大家兑现拖拽。

  • mousedown 鼠标按下时接触
  • mousemove 鼠标按下后拖动时接触
  • mouseup 鼠标放手时触发

而在移动端,分别与之相应的则是touchstart、touchmove、touchend

当我们将元素绑定这个事件时,有一个事件目标将会作为参数传递给回调函数,通过事件目的,大家得以获取到当前鼠标的规范地方,鼠标地方音讯是完结拖拽的主要。

事件目标极度根本,其中蕴含了丰盛多的实用的音讯,那里我就不扩展了,我们可以在函数少将事件目的打印出来查看里面的具体性质,这么些方式对于记不清事件目的主要性质的童鞋分外管用。

 随机数公式:

6、拖拽的法则

当事件触发时,大家得以经过事件目的获得到鼠标的精切地点。那是促成拖拽的机要。当鼠标按下(mousedown触发)时,我们要求记住鼠标的上马地点与对象元素的启幕地点,我们的对象就是落成当鼠标移动时,目标元素也随着移动,按照原理大家得以汲取如下事关:

挪动后的鼠标地方 – 鼠标初步地方 = 移动后的目标元素地点 –
目的元素的起来地方

1
移动后的鼠标位置 – 鼠标初始位置 = 移动后的目标元素位置 – 目标元素的初始位置

假设鼠标地方的差值我们用dis来代表,那么目的元素的职位就相当于:

举手投足后目的元素的义务 = dis + 目标元素的初始地点

1
移动后目标元素的位置 = dis + 目标元素的初始位置

因此事件目的,我们得以规范的了然鼠标的脚下岗位,由此当鼠标拖动(mousemove)时,大家得以不停的计量出鼠标移动的差值,以此来求出目的元素的方今地点。这一个进度,就落到实处了拖拽。

而在鼠标松手(mouseup)截止拖拽时,我们必要处理局地为止工作。详情见代码。

澳门葡京 2

7、 我又来推举思维导图协理写代码了

时常有新娘朋友跑来问我,如若逻辑思维能力不强,能或不能够写代码做前端。我的答案是:能。因为依靠思维导图,可以很轻松的弥补逻辑的短板。而且比在团结头脑中脑补逻辑更是清晰明了,不易出错。

地方第六点我介绍了规律,因而怎么样做就突显不是那么难了,而现实的手续,则在底下的思维导图中有目共睹给出,大家只必要听从那个手续来写代码即可,试试看,一定很轻松。

澳门葡京 3

应用思维导图清晰的表述出一切拖拽进程大家需要干的作业

 

8、代码完成

part1、准备干活

JavaScript

// 获取目的元素对象 var oElem = document.getElementById(‘target’); //
声明2个变量用来保存鼠标开头地点的x,y坐标 var startX = 0; var startY =
0; // 申明2个变量用来保存目的元素发轫地点的x,y坐标 var sourceX = 0; var
sourceY = 0;

1
2
3
4
5
6
7
8
9
10
// 获取目标元素对象
var oElem = document.getElementById(‘target’);
 
// 声明2个变量用来保存鼠标初始位置的x,y坐标
var startX = 0;
var startY = 0;
 
// 声明2个变量用来保存目标元素初始位置的x,y坐标
var sourceX = 0;
var sourceY = 0;

part2、效用函数

因为事先早已贴过代码,就不再另行

JavaScript

// 获取当前浏览器帮忙的transform包容写法 function getTransform() {} //
获取元素属性 function getStyle(elem, property) {} // 获取元素的开始地方function getTargetPos(elem) {} // 设置元素的发端地点 function
setTargetPos(elem, potions) {}

1
2
3
4
5
6
7
8
9
10
11
// 获取当前浏览器支持的transform兼容写法
function getTransform() {}
 
// 获取元素属性
function getStyle(elem, property) {}
 
// 获取元素的初始位置
function getTargetPos(elem) {}
 
// 设置元素的初始位置
function setTargetPos(elem, potions) {}

part3、申明多少个事件的回调函数

那五个法子就是促成拖拽的主导所在,我将从严依据下边思维导图中的步骤来完结我们的代码。

JavaScript

// 绑定在mousedown上的回调,event为流传的轩然大波目的 function start(event)
{ // 获取鼠标初步地点 startX = event.pageX; startY = event.pageY; //
获取元素开头位置 var pos = getTargetPos(oElem); sourceX = pos.x; sourceY
= pos.y; // 绑定 document.add伊夫ntListener(‘mousemove’, move, false);
document.add伊芙ntListener(‘mouseup’, end, false); } function move(event)
{ // 获取鼠标当前岗位 var currentX = event.pageX; var currentY =
event.pageY; // 计算差值 var distanceX = currentX – startX; var
distanceY = currentY – startY; // 总括并设置元素当前地方setTargetPos(oElem, { x: (sourceX + distanceX).toFixed(), y: (sourceY +
distanceY).toFixed() }) } function end(event) {
document.remove伊夫ntListener(‘mousemove’, move);
document.remove伊芙ntListener(‘mouseup’, end); // do other things }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 绑定在mousedown上的回调,event为传入的事件对象
function start(event) {
    // 获取鼠标初始位置
    startX = event.pageX;
    startY = event.pageY;
 
    // 获取元素初始位置
    var pos = getTargetPos(oElem);
 
    sourceX = pos.x;
    sourceY = pos.y;
 
    // 绑定
    document.addEventListener(‘mousemove’, move, false);
    document.addEventListener(‘mouseup’, end, false);
}
 
function move(event) {
    // 获取鼠标当前位置
    var currentX = event.pageX;
    var currentY = event.pageY;
 
    // 计算差值
    var distanceX = currentX – startX;
    var distanceY = currentY – startY;
 
    // 计算并设置元素当前位置
    setTargetPos(oElem, {
        x: (sourceX + distanceX).toFixed(),
        y: (sourceY + distanceY).toFixed()
    })
}
 
function end(event) {
    document.removeEventListener(‘mousemove’, move);
    document.removeEventListener(‘mouseup’, end);
    // do other things
}

OK,一个简便的拖拽,似乎此喜欢的完毕了。点击上面的链接,能够在线查看该例子的demo。

运用原生js完结拖拽

9、封装拖拽对象

在前边一章我给大家分享了面向对象如何促成,基于那个基础知识,大家来将下面完毕的拖拽封装为一个拖拽对象。咱们的靶子是,只要大家声爱他美(Aptamil)(Beingmate)个拖拽实例,那么传入的对象元素将机关具备可以被拖拽的法力。

在实际上开发中,一个目的大家日常会单独放在一个js文件中,那一个js文件将独立作为一个模块,利用各样模块的法门社团起来使用。当然那里没有复杂的模块交互,因为那几个例子,大家只须要一个模块即可。

为了幸免变量污染,我们要求将模块放置于一个函数自推行措施模拟的块级作用域中。

JavaScript

; (function() { … })();

1
2
3
4
;
(function() {
    …
})();

在平凡的模块协会中,大家只是独自的将洋洋js文件裁减成为一个js文件,因而那里的率先个分店则是为着防备上一个模块的最后不用分号导致报错。必不可少。当然在经过require或者ES6模块等措施就不会冒出这么的情事。

咱俩清楚,在包装一个对象的时候,大家可以将性能与格局放置于构造函数或者原型中,而在大增了自进行函数之后,大家又可以将质量和办法幸免与模块的内部成效域。那是闭包的知识。

那就是说我们面临的挑衅就在于,如何合理的拍卖属性与办法的地方。

当然,每一个对象的状态都不雷同,不可能比量齐观,大家要求明显的明亮那三种职位的特点才能做出最适合的控制。

  • 构造函数中:
    属性与措施为当下实例单独拥有,只可以被当下实例访问,并且每声Bellamy个实例,其中的主意都会被另行创造四次。
  • 原型中:
    属性与措施为具备实例共同所有,能够被抱有实例访问,新注明实例不会再一次创设方法。
  • 模块效用域中:属性和艺术无法被其余实例访问,可是能被内部方法访问,新注解的实例,不会再一次制造相同的法门。

对于措施的论断比较不难。

因为在构造函数中的方法总会在声美赞臣(Aptamil)个新的实例时被再度创设,由此大家注解的法子都尽量防止出现在构造函数中。

而一旦你的法门中必要用到构造函数中的变量,或者想要公开,那就需求放在原型中。

如果格局必要个人不被外面访问,那么就停放在模块功效域中。

对于属性放置于怎么样岗位有些时候很难做出科学的判断,由此我很难交付一个确切的定义告诉您怎么样性质一定要放在如何岗位,那必要在其实费用中不止的下结论经验。可是总的来说,依旧要结成那多少个岗位的特色来做出最合适的论断。

假如属性值只好被实例单独拥有,比如person对象的name,只好属于某一个person实例,又例如此处拖拽对象中,某一个因素的起来地方,也仅仅只是那几个因素的脚下岗位,这么些特性,则吻合放在构造函数中。

而只要一个属性仅仅供内部方法访问,那么些特性就适合放在模块功用域中。

有关面向对象,上边的几点考虑自己认为是那篇小说最值得认真思考的精髓。借使在封装时没有思想清楚,很可能会遇见不少您意想不到的bug,所以指出我们结合自己的支付经历,多多考虑,总计出自己的视角。

基于那些思考,我们可以团结尝尝封装一下。然后与自家的做一些对待,看看我们的想法有怎样两样,在底下例子的诠释中,我将团结的想法表明出来。

点击查阅已经封装好的demo

js 源码

JavaScript

; (function() { // 那是一个民用属性,不必要被实例访问 var transform =
getTransform(); function Drag(selector) { //
放在构造函数中的属性,都是属于每一个实例单独拥有 this.elem = typeof
selector == ‘Object’ ? selector : document.getElementById(selector);
this.startX = 0; this.startY = 0; this.sourceX = 0; this.sourceY = 0;
this.init(); } // 原型 Drag.prototype = { constructor: Drag, init:
function() { // 起始时要求做些什么工作 this.setDrag(); }, //
稍作改造,仅用于获取当前因素的习性,类似于getName getStyle:
function(property) { return document.defaultView.getComputedStyle ?
document.defaultView.getComputedStyle(this.elem, false)[property] :
this.elem.currentStyle[property]; }, //
用来博取当前因素的职位音信,注意与此前的不一样之处 getPosition: function()
{ var pos = {x: 0, y: 0}; if(transform) { var transformValue =
this.getStyle(transform); if(transformValue == ‘none’) {
this.elem.style[transform] = ‘translate(0, 0)’; } else { var temp =
transformValue.match(/-?\d+/g); pos = { x: parseInt(temp[4].trim()),
y: parseInt(temp[5].trim()) } } } else { if(this.getStyle(‘position’)
== ‘static’) { this.elem.style.position = ‘relative’; } else { pos = {
x: parseInt(this.getStyle(‘left’) ? this.getStyle(‘left’) : 0), y:
parseInt(this.getStyle(‘top’) ? this.getStyle(‘top’) : 0) } } } return
pos; }, // 用来设置当前因素的职位 setPostion: function(pos) {
if(transform) { this.elem.style[transform] = ‘translate(‘+ pos.x +’px,
‘+ pos.y +’px)’; } else { this.elem.style.left = pos.x + ‘px’;
this.elem.style.top = pos.y + ‘px’; } }, // 该办法用来绑定事件 setDrag:
function() { var self = this; this.elem.add伊夫ntListener(‘mousedown’,
start, false); function start(event) { self.startX = event.pageX;
self.startY = event.pageY; var pos = self.getPosition(); self.sourceX =
pos.x; self.sourceY = pos.y; document.add伊芙ntListener(‘mousemove’,
move, false); document.add伊夫ntListener(‘mouseup’, end, false); }
function move(event) { var currentX = event.pageX; var currentY =
event.pageY; var distanceX = currentX – self.startX; var distanceY =
currentY – self.startY; self.setPostion({ x: (self.sourceX +
distanceX).toFixed(), y: (self.sourceY + distanceY).toFixed() }) }
function end(event) { document.remove伊夫ntListener(‘mousemove’, move);
document.remove伊芙ntListener(‘mouseup’, end); // do other things } } }
// 私有方法,仅仅用来获得transform的匹配写法 function getTransform() {
var transform = ”, divStyle = document.createElement(‘div’).style,
transformArr = [‘transform’, ‘webkitTransform’, ‘MozTransform’,
‘msTransform’, ‘OTransform’], i = 0, len = transformArr.length; for(; i
< len; i++) { if(transformArr[i] in divStyle) { return transform =
transformArr[i]; } } return transform; } // 一种对外暴露的主意
window.Drag = Drag; })(); // 使用:表明2个拖拽实例 new Drag(‘target’);
new Drag(‘target2’);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
;
(function() {
    // 这是一个私有属性,不需要被实例访问
    var transform = getTransform();
 
    function Drag(selector) {
        // 放在构造函数中的属性,都是属于每一个实例单独拥有
        this.elem = typeof selector == ‘Object’ ? selector : document.getElementById(selector);
        this.startX = 0;
        this.startY = 0;
        this.sourceX = 0;
        this.sourceY = 0;
 
        this.init();
    }
 
 
    // 原型
    Drag.prototype = {
        constructor: Drag,
 
        init: function() {
            // 初始时需要做些什么事情
            this.setDrag();
        },
 
        // 稍作改造,仅用于获取当前元素的属性,类似于getName
        getStyle: function(property) {
            return document.defaultView.getComputedStyle ? document.defaultView.getComputedStyle(this.elem, false)[property] : this.elem.currentStyle[property];
        },
 
        // 用来获取当前元素的位置信息,注意与之前的不同之处
        getPosition: function() {
            var pos = {x: 0, y: 0};
            if(transform) {
                var transformValue = this.getStyle(transform);
                if(transformValue == ‘none’) {
                    this.elem.style[transform] = ‘translate(0, 0)’;
                } else {
                    var temp = transformValue.match(/-?\d+/g);
                    pos = {
                        x: parseInt(temp[4].trim()),
                        y: parseInt(temp[5].trim())
                    }
                }
            } else {
                if(this.getStyle(‘position’) == ‘static’) {
                    this.elem.style.position = ‘relative’;
                } else {
                    pos = {
                        x: parseInt(this.getStyle(‘left’) ? this.getStyle(‘left’) : 0),
                        y: parseInt(this.getStyle(‘top’) ? this.getStyle(‘top’) : 0)
                    }
                }
            }
 
            return pos;
        },
 
        // 用来设置当前元素的位置
        setPostion: function(pos) {
            if(transform) {
                this.elem.style[transform] = ‘translate(‘+ pos.x +’px, ‘+ pos.y +’px)’;
            } else {
                this.elem.style.left = pos.x + ‘px’;
                this.elem.style.top = pos.y + ‘px’;
            }
        },
 
        // 该方法用来绑定事件
        setDrag: function() {
            var self = this;
            this.elem.addEventListener(‘mousedown’, start, false);
            function start(event) {
                self.startX = event.pageX;
                self.startY = event.pageY;
 
                var pos = self.getPosition();
 
                self.sourceX = pos.x;
                self.sourceY = pos.y;
 
                document.addEventListener(‘mousemove’, move, false);
                document.addEventListener(‘mouseup’, end, false);
            }
 
            function move(event) {
                var currentX = event.pageX;
                var currentY = event.pageY;
 
                var distanceX = currentX – self.startX;
                var distanceY = currentY – self.startY;
 
                self.setPostion({
                    x: (self.sourceX + distanceX).toFixed(),
                    y: (self.sourceY + distanceY).toFixed()
                })
            }
 
            function end(event) {
                document.removeEventListener(‘mousemove’, move);
                document.removeEventListener(‘mouseup’, end);
                // do other things
            }
        }
    }
 
    // 私有方法,仅仅用来获取transform的兼容写法
    function getTransform() {
        var transform = ”,
            divStyle = document.createElement(‘div’).style,
            transformArr = [‘transform’, ‘webkitTransform’, ‘MozTransform’, ‘msTransform’, ‘OTransform’],
 
            i = 0,
            len = transformArr.length;
 
        for(; i < len; i++)  {
            if(transformArr[i] in divStyle) {
                return transform = transformArr[i];
            }
        }
 
        return transform;
    }
 
    // 一种对外暴露的方式
    window.Drag = Drag;
})();
 
// 使用:声明2个拖拽实例
new Drag(‘target’);
new Drag(‘target2’);

如此那般一个拖拽对象就封装完成了。

提议大家按照自己提供的合计形式,多多尝试封装一些零件。比如封装一个弹窗,封装一个循环往复轮播等。练得多了,面向对象就不再是难题了。那种思考方法,在未来其余时候都是力所能及利用的。

下一章分析jQuery对象的已毕,与什么将大家那边封装的拖拽对象增加为jQuery插件。

2 赞 1 收藏
评论

澳门葡京 4

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website