Sortable.js
拖拽的時候主要由這幾個事件完成，
ondragstart 事件：當拖拽元素開始被拖拽的時候觸發的事件，此事件做用在被拖曳元素上
ondragenter 事件：當拖曳元素進入目標元素的時候觸發的事件，此事件做用在目標元素上
ondragover 事件：拖拽元素在目標元素上移動的時候觸發的事件，此事件做用在目標元素上
ondrop 事件：被拖拽的元素在目標元素上同時鼠標放開觸發的事件，此事件做用在目標元素上
ondragend 事件：當拖拽完成後觸發的事件，此事件做用在被拖曳元素上
主要是拖拽的時候發生ondragstart事件和ondragover事件的時候節點交換位置，其實就是把他們的節點互相調換，固然這只是最簡單的拖拽排序方式，裏面用到了許多技術比用判斷拖拽滾動條的時候是滾動拖拽元素上面的根節點的父節點滾動，仍是滾動window上面的滾動條， 還有拖拽的時候利用getBoundingClientRect() 屬性判斷鼠標是在dom節點的左邊，右邊，上面，仍是下面。還有利用回調和函數式編程聲明函數，利用布爾值相加相減去，作0和1判斷，利用了事件綁定來斷定兩個列表中的不一樣元素，這些都是頗有趣的技術。
注意：這個插件是用html5 拖拽的因此也不支持ie9 如下瀏覽器
接下來咱們先看看簡單的簡單的dome，先加載他的拖拽js Sortable.js 插件，和app.css. 建立一個簡單的拖拽很簡單 只要傳遞一個dom節點進去就能夠，第二個參數傳一個空對象進去
固然app.css，加不加無所謂，若是不加的話要加一個樣式就是javascript
.sortable-ghost {
opacity: 0.4;
background-color: #F4E2C9;
}
拖拽的時候有陰影效果更好看些
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<ul id="foo" class="block__list block__list_words">
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
<li>5</li>
<li>6</li>
<li>7</li>
<li>8</li>
</ul>
<script>
Sortable.create(document.getElementById('foo'), {});
</script>
</body>
</html>
該插件還提供了拖拽時候動畫，讓拖拽變得更炫，很簡單加多一個參數就行animation: 150，拖拽時間內執行完動畫的時間。裏面是用css3動畫的ie9如下瀏覽器 含ie9瀏覽器不支持
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<ul id="foo" class="block__list block__list_words">
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
<li>5</li>
<li>6</li>
<li>7</li>
<li>8</li>
</ul>
<script>
Sortable.create(document.getElementById('foo'),
{
animation: 150, //動畫參數
});
</script>
</body>
</html>
這個插件不只僅提供拖拽功能，還提供了拖拽完以後排序，固然排序的思惟很簡單，判斷鼠標按下去拖拽的那個節點和拖拽到目標節點的兩個元素髮生ondragover的時候判斷他們的dom節點位置，而且互換dom位置就造成了排序。拖拽完成只有 Sortable.js 插件還提供了幾個事件接口，咱們看看那dome，
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<ul id="foo" class="block__list block__list_words">
<li>1</li>
<li>2</li>
<li>3</li>
<li>4</li>
<li>5</li>
<li>6</li>
<li>7</li>
<li>8</li>
</ul>
<script>
Sortable.create(document.getElementById('foo'), {
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
</script>
</body>
</html>
咱們看看上面的例子，首先看看當拖拽完成的時候他發生事件順序css
onAdd onRemove 沒有觸發說明當列表中的拖拽數據有增長和減小的時候纔會發生該事件， 固然若是有興趣的朋友能夠看看他生事件的順序和條件。
還有傳遞一個evt參數，咱們看看該參數有些什麼東西。主要看_dispatchEvent 這個函數 改函數的功能是:建立一個事件，事件參數主要由name 提供，而且觸發該事件，其實就是模擬事件而且觸發該事件。
看看改函數的關鍵源碼
var evt = document.createEvent('Event'), //建立一個事件
options = (sortable || rootEl[expando]).options, //獲取options 參數
//name.charAt(0) 獲取name的第一個字符串
//toUpperCase() 變成大寫
//name.substr(1) 提取從索引爲1下標到字符串的結束位置的字符串
//onName 將得到 on+首個字母大寫+name從第一個下標獲取到的字符串
onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
evt.initEvent(name, true, true); //自定義一個事件
evt.to = rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.from = fromEl || rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.item = targetEl || rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.clone = cloneEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.oldIndex = startIndex; //開始拖拽節點
evt.newIndex = newIndex; //如今節點
//觸發該事件，而且是在rootEl 節點上面 。觸發事件接口就這這裏了。onAdd: onUpdate: onRemove:onStart:onSort:onEnd:
接下來事件有了， 咱們怎麼作排序呢？其實很簡單，只要咱們作排序的列表中加一個drag-id就能夠，而後在拖拽過程當中有幾個事件onAdd， onUpdate，onRemove，onStart，onSort，onEnd，而後咱們不須要關心這麼多事件，咱們也不須要關心中間拖拽發生了什麼事情。而後咱們關心的是當拖拽結束以後咱們只要調用onEnd事件就能夠了 而後改接口會提供 evt。 evt中能夠有一個from就是拖列表的根節點，只要獲取到改節點下面的字節的就能夠獲取到排序id。請看dome
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<ul id="foo" class="block__list block__list_words">
<li drag-id="1">1</li>
<li drag-id="2">2</li>
<li drag-id="3">3</li>
<li drag-id="4">4</li>
<li drag-id="5">5</li>
<li drag-id="6">6</li>
<li drag-id="7">7</li>
<li drag-id="8">8</li>
</ul>
<script>
Sortable.create(document.getElementById('foo'), {
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
var id_arr=''
for(var i=0, len=evt.from.children.length; i<len; i++){
id_arr+=','+ evt.from.children[i].getAttribute('drag-id');
}
id_arr=id_arr.substr(1);
//而後請求後臺ajax 這樣就完成了拖拽排序
console.log(id_arr);
}
});
</script>
</body>
</html>
該插件還提供了多列表拖拽。下面dome是 從a列表拖拽到b列表，b列表拖拽到a列表 兩個倆表互相拖拽，而後主要參數是 group
若是group不是對象則變成對象，而且group對象的name就等於改group的值 而且添加多['pull', 'put'] 屬性默認值是true
若是設置
group{
pull:true, 則能夠拖拽到其餘列表 不然反之
put:true, 則能夠從其餘列表中放數據到改列表，false則反之
}
pull: 'clone', 還有一個做用是克隆，就是當這個列表拖拽到其餘列表的時候不會刪除改列表的節點。
看看簡單的列表互相拖拽dome 只要設置參數group:"words", group的name要相同才能互相拖拽
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<div class="container" style="height: 520px">
<div data-force="30" class="layer block" style="left: 14.5%; top: 0; width: 37%">
<div class="layer title">List A</div>
<ul id="foo" class="block__list block__list_words">
<li>бегемот</li>
<li>корм</li>
<li>антон</li>
<li>сало</li>
<li>железосталь</li>
<li>валик</li>
<li>кровать</li>
<li>краб</li>
</ul>
</div>
<div data-force="18" class="layer block" style="left: 58%; top: 143px; width: 40%;">
<div class="layer title">List B</div>
<ul id="bar" class="block__list block__list_tags">
<li>казнить</li>
<li>,</li>
<li>нельзя</li
><li>помиловать</li>
</ul>
</div>
</div>
<script>
Sortable.create(document.getElementById('foo'), {
group:"words",
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
Sortable.create(document.getElementById('bar'), {
group:"words",
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
</script>
</body>
</html>
固然也支持 只能從a列表拖拽到b列表 dome
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<div class="container" style="height: 520px">
<div data-force="30" class="layer block" style="left: 14.5%; top: 0; width: 37%">
<div class="layer title">List A</div>
<ul id="foo" class="block__list block__list_words">
<li>бегемот</li>
<li>корм</li>
<li>антон</li>
<li>сало</li>
<li>железосталь</li>
<li>валик</li>
<li>кровать</li>
<li>краб</li>
</ul>
</div>
<div data-force="18" class="layer block" style="left: 58%; top: 143px; width: 40%;">
<div class="layer title">List B</div>
<ul id="bar" class="block__list block__list_tags">
<li>казнить</li>
<li>,</li>
<li>нельзя</li
><li>помиловать</li>
</ul>
</div>
</div>
<script>
Sortable.create(document.getElementById('foo'), {
group: {
name:"words",
pull: true,
put: true
},
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
Sortable.create(document.getElementById('bar'), {
group: {
name:"words",
pull: false,
put: true
},
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
</script>
</body>
</html>
固然也支持克隆 從a列表可克隆dom節點拖拽添加到b倆表 只要把參數 pull: 'clone', 這樣就能夠了 domehtml
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable.js"></script>
<body>
<div class="container" style="height: 520px">
<div data-force="30" class="layer block" style="left: 14.5%; top: 0; width: 37%">
<div class="layer title">List A</div>
<ul id="foo" class="block__list block__list_words">
<li>бегемот</li>
<li>корм</li>
<li>антон</li>
<li>сало</li>
<li>железосталь</li>
<li>валик</li>
<li>кровать</li>
<li>краб</li>
</ul>
</div>
<div data-force="18" class="layer block" style="left: 58%; top: 143px; width: 40%;">
<div class="layer title">List B</div>
<ul id="bar" class="block__list block__list_tags">
<li>казнить</li>
<li>,</li>
<li>нельзя</li
><li>помиловать</li>
</ul>
</div>
</div>
<script>
Sortable.create(document.getElementById('foo'), {
group: {
name:"words",
pull: 'clone',
put: true
},
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
Sortable.create(document.getElementById('bar'), {
group: {
name:"words",
pull: false,
put: true
},
animation: 150, //動畫參數
onAdd: function (evt){ //拖拽時候添加有新的節點的時候發生該事件
console.log('onAdd.foo:', [evt.item, evt.from]);
},
onUpdate: function (evt){ //拖拽更新節點位置發生該事件
console.log('onUpdate.foo:', [evt.item, evt.from]);
},
onRemove: function (evt){ //刪除拖拽節點的時候促發該事件
console.log('onRemove.foo:', [evt.item, evt.from]);
},
onStart:function(evt){ //開始拖拽出發該函數
console.log('onStart.foo:', [evt.item, evt.from]);
},
onSort:function(evt){ //發生排序發生該事件
console.log('onSort.foo:', [evt.item, evt.from]);
},
onEnd: function(evt){ //拖拽完畢以後發生該事件
console.log('onEnd.foo:', [evt.item, evt.from]);
}
});
</script>
</body>
</html>
該插件也支持刪除拖拽列表的節點，主要是設置filter 參數，改參數能夠設置成函數，可是設置成函數的時候不還要本身定義拖拽，顯得有些麻煩，因此通常設置成class，或者是tag，設置成class和tag的時候就是作拖拽列表中含有calss，tag的節點能夠點擊的時候能夠觸發onFilter函數，觸發會傳遞一個evt參數進來evt.item 就是class或者tag的dom節點，能夠經過他們的血緣關係從而刪除須要刪除的節點。html5
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>無標題文檔</title>
</head>
<link href="st/app.css" rel="stylesheet" type="text/css"/>
<script src="Sortable3.js"></script>
<body>
<body>
<!-- Editable list -->
<a name="e"></a>
<div class="container" style="margin-top: 100px">
<div id="filter" style="margin-left: 30px">
<div><div data-force="5" class="layer title title_xl">Editable list</div></div>
<div style="margin-top: -8px; margin-left: 10px" class="block__list block__list_words">
<ul id="editable">
<li>Оля<i class="js-remove">✖</i></li>
<li>Владимир<i class="js-remove">✖</i></li>
<li>Алина<i class="js-remove">✖</i></li>
</ul>
</div>
</div>
</div>
<script>
// Editable list
var editableList = Sortable.create(document.getElementById('editable'), {
animation: 150,
filter: '.js-remove',
onFilter: function (evt) {
console.log(evt.item)
evt.item.parentNode.parentNode.removeChild(evt.item.parentNode);
}
});
</script>
</body>
</html>
Sortable.js 接口參數還有不少個，不 一 一 作dome了列出來給你們看看，其中比較經常使用的是上面所說的dome參數，還有handle這個參數也經常使用規定哪些calss，或者tag拖拽。java
var defaults = {
group: Math.random(), //產生一個隨機數 //產生一個隨機數 //改參數是對象有三個兩個參數 pull: 拉, put:放 默認都是是true pull還有一個值是: 'clone', pull: 拉, put:放 設置爲false 就不能拖拽了， 若是 pull 這種爲'clone'則能夠重一個列表中拖拽到另外一個列表而且克隆dom節點， name：是兩個或者多個列表拖拽之間的通訊，若是name相同則他們能夠互相拖拽
sort: true, // 類型：Boolean,分類 false時候在本身的拖拽區域不能拖拽，可是能夠拖拽到其餘區域，true則能夠作本身區域拖拽或者其餘受權地方拖拽
disabled: false, //類型：Boolean 是否禁用拖拽 true 則不能拖拽 默認是true
store: null, // 用來html5 存儲的 改返回 拖拽的節點的惟一id
handle: null, //handle 這個參數是設置該標籤，或者該class能夠拖拽 可是不要設置 id的節點和子節點相同的tag否則會有bug
scroll: true, //類型：Boolean，設置拖拽的時候滾動條是否智能滾動。默認爲真，則智能滾動，false則不智能滾動
scrollSensitivity: 30, //滾動的靈敏度,實際上是拖拽離滾動邊界的距離觸發事件的距離邊界+-30px的地方觸發拖拽滾動事件，
scrollSpeed: 10, //滾動速度
draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',//draggable 判斷拖拽節點的父層是不是ou ul
ghostClass: 'sortable-ghost', // 排序鏡像class,就是當鼠標拉起拖拽節點的時候添加該class
chosenClass: 'sortable-chosen', // //爲拖拽的節點添加一個class 開始拖拽鼠標按下去的時候 添加該class
ignore: 'a, img', //a 或者是img
filter: null, //改參數能夠傳遞一個函數，或者字符串，字符串能夠是class或者tag，而後用於觸發oFilter函數，這樣能夠用來自定義事件等
animation: 0, //拖拽動畫時間戳
setData: function (dataTransfer, dragEl) { //設置拖拽傳遞的參數
dataTransfer.setData('Text', dragEl.textContent);
},
dropBubble: false, // 發生 drop事件 拖拽的時候是否阻止事件冒泡
dragoverBubble: false, //發生 dragover 事件 拖拽的時候是否阻止事件冒泡
dataIdAttr: 'data-id', //拖拽元素的id 數組
delay: 0, //延遲拖拽時間, 其實就是鼠標按下去拖拽延遲
forceFallback: false, // 不詳
fallbackClass: 'sortable-fallback', // 排序回退class
fallbackOnBody: false,// 是否把拖拽鏡像節點ghostEl放到body上
};
下面是Sortable.js插件源碼，本人花了一些時間作了註釋，有興趣的朋友能夠研究下。
若是您發現哪些地方有錯誤註釋能夠聯繫個人郵箱281113270@qq.com ；node
/**!
* Sortable
* @author RubaXa <trash@rubaxa.org>
* @license MIT
*/
(function (factory) {
"use strict"; //嚴格模式
if (typeof define === "function" && define.amd) { //兼容 require.js 寫法
define(factory);
}
else if (typeof module != "undefined" && typeof module.exports != "undefined") { //兼容node寫法
module.exports = factory();
}
else if (typeof Package !== "undefined") {
Sortable = factory(); // export for Meteor.js 兼容 Meteor.js 寫法
}
else {
/* jshint sub:true */
window["Sortable"] = factory(); //把它掛載在window下
}
})(function () {
"use strict";
if (typeof window == "undefined" || typeof window.document == "undefined") { //判斷該js是否在window或者document 下運行
return function () {
throw new Error("Sortable.js requires a window with a document"); //若是不是則拋出一個錯誤
};
}
var i=0;
var dragEl, //當前拖拽節點,開始拖拽節點，鼠標按下去的節點
parentEl,
ghostEl, // 拖拽鏡像節點
cloneEl, //克隆節點
rootEl, //鼠標開始按下去拖拽的根節點
nextEl, //下一個節點
scrollEl,//滾動節點
scrollParentEl, //滾動的父節點
lastEl, //根節點中的最後一個本身點
lastCSS,
lastParentCSS,
oldIndex, //開始拖拽節點的索引 就是鼠標按下去拖拽節點的索引
newIndex, //拖拽完以後如今節點
activeGroup,
autoScroll = {}, //滾動對象用於存鼠標的xy軸
/*
tapEvt 觸摸對象包括x與y軸與拖拽當前節點
tapEvt = {
target: dragEl,
clientX: touch.clientX,
clientY: touch.clientY
};
*/
tapEvt,
touchEvt,
moved,
/** @const */
RSPACE = /\s+/g, //全局匹配空格
expando = 'Sortable' + (new Date).getTime(), //字符串Sortable+時間戳
win = window, //縮寫win
document = win.document,
parseInt = win.parseInt;
//draggable html5 拖拽屬性 初始化的時候是true
var supportDraggable = !!('draggable' in document.createElement('div')),
//判斷瀏覽器是否支持css3 這個屬性pointer-events
supportCssPointerEvents = (function (el) {
el = document.createElement('x');
el.style.cssText = 'pointer-events:auto';
return el.style.pointerEvents === 'auto';
})(),
_silent = false, //默認
abs = Math.abs,
slice = [].slice,
touchDragOverListeners = [], //新建一個數組 鼠標觸摸拖拽數組
//_autoScroll 至關於 被一個函數付值
/* _autoScroll = function(callback,ms){
var args,
_this;
if (args === void 0) {
args = arguments;
_this = this;
setTimeout(function () {
if (args.length === 1) {
callback.call(_this, args[0]);
} else {
callback.apply(_this, args);
}
args = void 0;
}, ms);
}
其實就是_autoScroll=function(參數){
放到 _throttle 的回調函數中 function (/參數/)
}
}*/
/***********************************************************************************************
*函數名 ：_autoScroll
*函數功能描述 ： 拖拽智能滾動
*函數參數 ：
evt：
類型：boj, 事件對象
options：類型：obj， 參數類
rootEl：類型：obj dom節點，拖拽的目標節點
*函數返回值 ： viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_autoScroll = _throttle(
//回調函數
function (/**Event*/evt, /**Object*/options, /**HTMLElement*/rootEl) {
//每次拖拽只會調用一次該函數
//evt 是事件對象 event
//options.scroll若是爲真 而且rootEl 爲真的時候
// Bug: https://bugzilla.mozilla.org/show_bug.cgi?id=505521
if (rootEl && options.scroll) {
var el,
rect,
sens = options.scrollSensitivity, //滾動靈敏度 默認是30
speed = options.scrollSpeed, //滾動速度 默認是10
x = evt.clientX, //獲取鼠標在可視窗口的x值
y = evt.clientY, //獲取鼠標在可視窗口的y值
winWidth = window.innerWidth, //獲取可視窗口的高度和寬度 有兼容性問題 不包括滾動條
winHeight = window.innerHeight,
vx,
vy
;
// Delect scrollEl 觀察滾動節點 若是滾動的父節點scrollParentEl不等於當前的根節點的時候則 能夠滾動
if (scrollParentEl !== rootEl) {
scrollEl = options.scroll; //true 布爾值
scrollParentEl = rootEl; //鼠標開始按下的根節點
if (scrollEl === true) {
scrollEl = rootEl;
do {
//判斷父節點，哪一個父節點出現滾動條，若是有滾動條則設置改拖拽的節點滾動條父節點
if ((scrollEl.offsetWidth < scrollEl.scrollWidth) ||
(scrollEl.offsetHeight < scrollEl.scrollHeight)
) {
break;
}
/* jshint boss:true */
} while (scrollEl = scrollEl.parentNode);
}
}
if (scrollEl) {
el = scrollEl;
rect = scrollEl.getBoundingClientRect();
/*
var box=document.getElementById('box'); // 獲取元素
alert(box.getBoundingClientRect().top); // 元素上邊距離頁面上邊的距離
alert(box.getBoundingClientRect().right); // 元素右邊距離頁面左邊的距離
alert(box.getBoundingClientRect().bottom); // 元素下邊距離頁面上邊的距離
alert(box.getBoundingClientRect().left); // 元素左邊距離頁面左邊的距離
y：y = evt.clientY, //獲取鼠標在可視窗口的y值
sens： sens = options.scrollSensitivity, //滾動靈敏度 默認是30
*/
//vx 與 vy 只是個布爾值判斷 而後就得出一個值
/*
true-true=0
true-false=1
false-false=0
false-true=-1
*/
vx = (abs(rect.right - x) <= sens) - (abs(rect.left - x) <= sens);
vy = (abs(rect.bottom - y) <= sens) - (abs(rect.top - y) <= sens); //這樣判斷並非很好由於只會在邊界判斷事件發生，若是一開始拖拽快速超過了設置的+-sens值滾動事件將沒有發生。我的感受改爲一下判斷會比較好。
/*
if(rect.top+sens-y>=0){
vy=-1;
} else if(rect.bottom+sens-y<=0){
vy=1;
}else{
vy=0;
}
*/
}
if (!(vx || vy)) { //當他等於0的時候 拖拽滾動的是window
vx = (winWidth - x <= sens) - (x <= sens);
vy = (winHeight - y <= sens) - (y <= sens);
/* jshint expr:true */
(vx || vy) && (el = win);
}
if (autoScroll.vx !== vx || autoScroll.vy !== vy || autoScroll.el !== el) {
autoScroll.el = el;
autoScroll.vx = vx;
autoScroll.vy = vy;
//speed=10 滾動速度
clearInterval(autoScroll.pid);
if (el) {
autoScroll.pid = setInterval(function () {
if (el === win) {
win.scrollTo(win.pageXOffset + vx * speed, win.pageYOffset + vy * speed);
} else {
vy && (el.scrollTop += vy * speed); //設置元素滾動條的位置,每次滾動1*speed若是是0 則不會滾動
vx && (el.scrollLeft += vx * speed);//設置元素滾動條的位置
}
},
24);
}
}
}
//時間 毫秒
}, 30),
/***********************************************************************************************
*函數名 ：_prepareGroup
*函數功能描述 ： //options.group 屬性變成對象 。若是group不是對象則變成對象，而且group對象的name就等於改group的值 而且添加多['pull', 'put'] 屬性默認值是true
若是設置group{
pull:true, 則能夠拖拽到其餘列表 不然反之
put:true, 則能夠從其餘列表中放數據到改列表，false則反之
}
pull: 'clone', 還有一個做用是克隆，就是當這個列表拖拽到其餘列表的時候不會刪除改列表的節點。
*函數參數 ：
options：
類型：boj, options 拖拽參數
*函數返回值 ： viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_prepareGroup = function (options) {
var group = options.group; //把options.group 付值給group
// 先判斷他group 是不是對象，若是不是則變成對象，name是他的屬性
if (!group || typeof group != 'object') { //若是當前options.group; 不存在或者不是obj則把他變成一個對象
group = options.group = {name: group};
}
//判斷有沒有設置 'pull', 'put' 若是沒有 則添加 'pull', 'put' 屬性而且設置爲真
['pull', 'put'].forEach(function (key) {
if (!(key in group)) { //
group[key] = true; //將爲group對象添加兩個屬性'pull', 'put' 而且爲true
}
});
//options.group 變成對象以後join方法將匹配不到任何東西
//若是他直接是數組的話這裏就是把數組的值拆分紅字符串鏈接起來
//options.group 屬性變成對象 。
options.groups = ' ' + group.name + (group.put.join ? ' ' + group.put.join(' ') : '') + ' ';
}
;
/**
* @class Sortable
* @param {HTMLElement} el
* @param {Object} [options]
*/
//el html dom節點
//param obj 數據對象
/***********************************************************************************************
*函數名 ：Sortable
*函數功能描述 ： 主類，裏面包含不少方法
*函數參數 ： dom節點rootEl
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function Sortable(el, options) {
//判斷 param 若是不是HTMLDOM 則拋出錯誤
if (!(el && el.nodeType && el.nodeType === 1)) {
throw 'Sortable: `el` must be HTMLElement, and not ' + {}.toString.call(el);
}
//把dom節點存到this中 好操做 就是id 父層節點
this.el = el; // root element
this.options = options = _extend({}, options); //把options初始化的數據存到this中 好操做
// Export instance
//把 Sortable 類放在HTMLDOM節點的expando屬性中
el[expando] = this;
// Default options
//初始化 defaults 數據
var defaults = {
group: Math.random(), //產生一個隨機數 //產生一個隨機數 //改參數是對象有三個兩個參數 pull: 拉, put:放 默認都是是true pull還有一個值是: 'clone', pull: 拉, put:放 設置爲false 就不能拖拽了， 若是 pull 這種爲'clone'則能夠重一個列表中拖拽到另外一個列表而且克隆dom節點， name：是兩個或者多個列表拖拽之間的通訊，若是name相同則他們能夠互相拖拽
sort: true, // 類型：Boolean,分類 false時候在本身的拖拽區域不能拖拽，可是能夠拖拽到其餘區域，true則能夠作本身區域拖拽或者其餘受權地方拖拽
disabled: false, //類型：Boolean 是否禁用拖拽 true 則不能拖拽 默認是true
store: null, // 用來html5 存儲的 改返回 拖拽的節點的惟一id
handle: null, //handle 這個參數是設置該標籤，或者該class能夠拖拽 可是不要設置 id的節點和子節點相同的tag否則會有bug
scroll: true, //類型：Boolean，設置拖拽的時候滾動條是否智能滾動。默認爲真，則智能滾動，false則不智能滾動
scrollSensitivity: 30, //滾動的靈敏度,實際上是拖拽離滾動邊界的距離觸發事件的距離邊界+-30px的地方觸發拖拽滾動事件，
scrollSpeed: 10, //滾動速度
draggable: /[uo]l/i.test(el.nodeName) ? 'li' : '>*',//draggable 判斷拖拽節點的父層是不是ou ul
ghostClass: 'sortable-ghost', // 排序鏡像class,就是當鼠標拉起拖拽節點的時候添加該class
chosenClass: 'sortable-chosen', // //爲拖拽的節點添加一個class 開始拖拽鼠標按下去的時候 添加該class
ignore: 'a, img', //a 或者是img
filter: null, //改參數能夠傳遞一個函數，或者字符串，字符串能夠是class或者tag，而後用於觸發oFilter函數，這樣能夠用來自定義事件等
animation: 0, //拖拽動畫時間戳
setData: function (dataTransfer, dragEl) { //設置拖拽傳遞的參數
dataTransfer.setData('Text', dragEl.textContent);
},
dropBubble: false, // 發生 drop事件 拖拽的時候是否阻止事件冒泡
dragoverBubble: false, //發生 dragover 事件 拖拽的時候是否阻止事件冒泡
dataIdAttr: 'data-id', //拖拽元素的id 數組
delay: 0, //延遲拖拽時間, 其實就是鼠標按下去拖拽延遲
forceFallback: false, // 不詳
fallbackClass: 'sortable-fallback', // 排序回退class
fallbackOnBody: false,// 是否把拖拽鏡像節點ghostEl放到body上
};
// Set default options
//當options類中的數據沒有defaults類中的數據的時候 就把defaults類中的數據賦值給options類
for (var name in defaults) {
!(name in options) && (options[name] = defaults[name]);
}
//把group: 變成一個對象，原本是一個屬性的
_prepareGroup(options);
// Bind all private methods
for (var fn in this) {
if (fn.charAt(0) === '_') {
//若是這個 Sortable 類下的函數 開始字符串還有_下劃線的就把他的this指向Sortable類
this[fn] = this[fn].bind(this);
}
}
// Setup drag mode
//forceFallback 若是是false 那麼給supportDraggable 函數他，而後判斷瀏覽器是否支持draggable 拖拽若是支持是true 不然是false
this.nativeDraggable = options.forceFallback ? false : supportDraggable;
// Bind events
//添加事件 // 入口從這裏開始
_on(el, 'mousedown', this._onTapStart);
_on(el, 'touchstart', this._onTapStart);
//html5 dragover 添加拖拽事件
if (this.nativeDraggable) {
//傳遞整個類進去
_on(el, 'dragover', this); //而後會執行這個函數handleEvent
_on(el, 'dragenter', this); //而後會執行這個函數handleEvent
}
//touchDragOverListeners 添加一個false 數據到數組裏。
touchDragOverListeners.push(this._onDragOver);
// Restore sorting
//sort 排序函數
//store 是null 未找到get函數不知道怎麼回事 可能它是屬於store.js的api
options.store && this.sort(options.store.get(this));
}
/***********************************************************************************************
*函數名 ：Sortable.prototype
*函數功能描述 ： 主類，的原型
*函數參數 ：
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
Sortable.prototype = /** @lends Sortable.prototype */ {
constructor: Sortable, //防止繼承混亂，構造方法指向他的構造函數
/***********************************************************************************************
*函數名 ：_onTapStart
*函數功能描述 ： 鼠標按下去函數,oldIndex統計目標節點與同級同胞的上節點總和
*函數參數 ： viod
*函數返回值 ： 無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_onTapStart: function (/** Event|TouchEvent */evt) {
var _this = this,
el = this.el, //id dom節點
options = this.options, //參數類
type = evt.type, //事件類型
touch = evt.touches && evt.touches[0], //觸摸屏事件
target = (touch || evt).target, //目標節點
originalTarget = target,
filter = options.filter; // null
//若是是鼠標按下去事件，可是若是不是左鍵按下去的話，或者disabled 爲假的時候 結束該程序 disabled 爲fasle
if (type === 'mousedown' && evt.button !== 0 || options.disabled) {
return; // only left button or enabled
}
//draggable=/[uo]l/i.test(el.nodeName) ? 'li' : '>*',
// target=el
// target = _closest(target, options.draggable, el); //true
//
if (!target) {
return;
}
// get the index of the dragged element within its parent
//獲取索引
oldIndex = _index(target, options.draggable);
// Check filter+
//filter 若是是函數 可是默認值filter
if (typeof filter === 'function') {
if (filter.call(this, evt, target, this)) { //而且有返回值是true 的話
//觸發該函數
_dispatchEvent(_this, originalTarget, 'filter', target, el, oldIndex); //則觸發oFilter事件
evt.preventDefault(); //中止默認事件
return; // cancel dnd
}
}
else if (filter) {
//// JavaScript數組some()方法測試數組中的某個元素是否經過由提供的功能來實現測試 ,只要有一個真則返回真
/*
例子
if (!Array.prototype.some)
{
Array.prototype.some = function(fun )
{
var len = this.length;
if (typeof fun != "function")
throw new TypeError();
var thisp = arguments[1];
for (var i = 0; i < len; i++)
{
if (i in this &&
fun.call(thisp, this[i], i, this))
return true;
}
return false;
};
}
function isBigEnough(element, index, array) {
return (element >= 10);
}
var retval = [2, 5, 8, 1, 4].some(isBigEnough);
document.write("Returned value is : " + retval );
var retval = [12, 5, 8, 1, 4].some(isBigEnough);
document.write("<br />Returned value is : " + retval );
*/
filter = filter.split(',').some(function (criteria) { //若是filter是字符串，則會用split 拆分紅數組而且遍歷他只有一個class 對的上則_closest 匹配tag和class 若是設置的filter中有calss 和拖拽元素上面的clss相同，或者tag相同，則會觸發oFilter函數
criteria = _closest(originalTarget, criteria.trim(), el);//_closest
if (criteria) {
_dispatchEvent(_this, criteria, 'filter', target, el, oldIndex); //調用自定義事件
return true;
}
});
if (filter) {
evt.preventDefault();
return; // cancel dnd
}
}
//handle 存在
//originalTarget
//handle 這個參數是設置該標籤，或者該class能夠拖拽 可是不要設置 id的節點和子節點相同的tag否則會有bug
if (options.handle && !_closest(originalTarget, options.handle, el)) {
return;
}
// Prepare `dragstart`
// 到這裏
this._prepareDragStart(evt, touch, target);
},
/***********************************************************************************************
*函數名 ：_onTapStart
*函數功能描述 ： 開始準備拖
*函數參數 ： evt：
類型:obj,事件對象
touch：
類型:obj,觸摸事件對象，判斷是不是觸摸事件仍是鼠標事件
target： 類型:dom-obj,目標節點
*函數返回值 ： 無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_prepareDragStart: function (/** Event */evt, /** Touch */touch, /** HTMLElement */target) {
//evt pc 的事件對象
//touch 移動的的事件對象
//target 目標節點
var _this = this,
el = _this.el, //id節點，就是父層節點
options = _this.options, //參數類
ownerDocument = el.ownerDocument, //整個文檔
dragStartFn; //聲明開始拖拽函數
//target 目標節點存在 dragEl 當前拖拽的節點 而且目標節點的父節點是id的節點的時候
if (target && !dragEl && (target.parentNode === el)) {
tapEvt = evt; //事件對象
rootEl = el; //拖拽的根節點 就是傳進來的id那個節點
dragEl = target; //目標節點 當前的拖拽節點 鼠標按下去拖拽的節點
parentEl = dragEl.parentNode; //目標節點 當前的拖拽節點 的父節點 就是 dragEl.parentNode ==rootEl
nextEl = dragEl.nextSibling; //目標節點 的下一個節點
activeGroup = options.group; //Object {name: "words", pull: true, put: true}
//開始拖拽函數
dragStartFn = function () {
// Delayed drag has been triggered 延遲拖動已被觸發
// we can re-enable the events: touchmove/mousemove 咱們能夠從新啓用touchmove / MouseMove事件：
//解綁事件，關閉_dragStartTimer 定時器 取消dragStartFn 函數執行
_this._disableDelayedDrag();
// Make the element draggable 使元件拖動
//把當前的拖拽節點的draggable 屬性設置爲真，讓他支持html5拖拽事件
dragEl.draggable = true;
// Chosen item dragEl 目標節點 類 _this.options.chosenClass='sortable-chosen'
//爲拖拽的節點添加一個class
_toggleClass(dragEl, _this.options.chosenClass, true);
// Bind the events: dragstart/dragend 綁定事件拖曳開始dragend
_this._triggerDragStart(touch);
};
// Disable "draggable" ignore="a, img"
options.ignore.split(',').forEach(function (criteria) {
// criteria 遍歷數組的當前target
//criteria.trim() 去除空格
/*
el.draggable //html5拖拽屬性
function _disableDraggable(el) {
el.draggable = false;
}
*/
// 該函數功能是把當前拖拽對象的a和img節點的html5 拖拽屬性改成false
_find(dragEl, criteria.trim(), _disableDraggable);
});
_on(ownerDocument, 'mouseup', _this._onDrop); //在ownerDocument 文檔上面當發生鼠標擡起的時候，添加_onDrop函數
_on(ownerDocument, 'touchend', _this._onDrop);//在ownerDocument 文檔上面當發生觸摸擡起的時候，添加_onDrop函數
_on(ownerDocument, 'touchcancel', _this._onDrop);//在ownerDocument 文檔上面當發生觸摸劃過擡起的時候，解綁_onDrop函數
//delay 初始值爲0
if (options.delay) {
/*
這裏裏面的程序塊添加了事件只有調用_disableDelayedDrag，添加了一個定時器執行一次dragStartFn函數，這個函數又立刻解綁_disableDelayedDrag事件，關閉定時器，整個思路是隻讓程序發生一次，而且立刻解綁事件,銷燬該事件。這樣思惟有些特別
*/
// If the user moves the pointer or let go the click or touch 若是用戶移動指針或單擊「單擊」或「觸摸」
// before the delay has been reached: //以前的延遲已達到
// disable the delayed drag //禁用延遲拖動
_on(ownerDocument, 'mouseup', _this._disableDelayedDrag); //當鼠標擡起的時候在文檔上添加_disableDelayedDrag事件
_on(ownerDocument, 'touchend', _this._disableDelayedDrag); //觸摸擡起的時候在文檔上添加_disableDelayedDrag事件
_on(ownerDocument, 'touchcancel', _this._disableDelayedDrag); //觸摸劃過擡起的時候在文檔上添加_disableDelayedDrag事件
_on(ownerDocument, 'mousemove', _this._disableDelayedDrag); //當鼠標移動mousemove的時候在文檔上添加_disableDelayedDrag事件
_on(ownerDocument, 'touchmove', _this._disableDelayedDrag); //觸摸移動的時候在文檔上添加_disableDelayedDrag事件
_this._dragStartTimer = setTimeout(dragStartFn, options.delay); //執行dragStartFn函數
} else {
//開始拖拽
dragStartFn();
}
}
},
/***********************************************************************************************
*函數名 ：_disableDelayedDrag
*函數功能描述 ： 禁用延遲拖拽 當拖拽延時的時候，把全部事件解綁，而且關閉定時器。
*函數參數 ：
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_disableDelayedDrag: function () {
var ownerDocument = this.el.ownerDocument;
clearTimeout(this._dragStartTimer); //關閉定時器
_off(ownerDocument, 'mouseup', this._disableDelayedDrag);//當鼠標擡起的時候在文檔上解綁_disableDelayedDrag事件
_off(ownerDocument, 'touchend', this._disableDelayedDrag);//觸摸擡起的時候在文檔上解綁_disableDelayedDrag事件
_off(ownerDocument, 'touchcancel', this._disableDelayedDrag);//當觸摸劃過擡起的時候在文檔上解綁_disableDelayedDrag事件
_off(ownerDocument, 'mousemove', this._disableDelayedDrag);//當鼠移動起的時候在文檔上解綁_disableDelayedDrag事件
_off(ownerDocument, 'touchmove', this._disableDelayedDrag);//觸摸的時候在文檔上解綁_disableDelayedDrag事件
},
/***********************************************************************************************
*函數名 ：_triggerDragStart
*函數功能描述 ： 爲拖拽前作好準本，包括判斷是不是觸摸設備，或者pc，或者沒有dragend
*函數參數 ：
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_triggerDragStart: function (/** Touch */touch) {
//按下去的值
if (touch) {
// Touch device support 觸摸設備支持
tapEvt = {
target: dragEl,
clientX: touch.clientX,
clientY: touch.clientY
};
this._onDragStart(tapEvt, 'touch'); //觸摸設備
}
else if (!this.nativeDraggable) {
this._onDragStart(tapEvt, true); //pc設備
}
else {
//若是當前的html尚未設置拖拽屬性則先設置拖拽屬性
_on(dragEl, 'dragend', this);
_on(rootEl, 'dragstart', this._onDragStart);
}
try {
if (document.selection) {
// Timeout neccessary for IE9
setTimeout(function () {
document.selection.empty(); //取消選中
});
} else {
window.getSelection().removeAllRanges();//取消選中
}
} catch (err) {
}
},
_dragStarted: function () {
if (rootEl && dragEl) { //若是鼠標按下去的拖拽節點存在和拖拽的根節點存在
// Apply effect
//爲拖拽節點添加一個class名字是'sortable-ghost'
_toggleClass(dragEl, this.options.ghostClass, true);
//Sortable類賦值給Sortable.active 屬性
Sortable.active = this;
// Drag start event
//開始拖拽 而且會相應onStart 接口函數
_dispatchEvent(this, rootEl, 'start', dragEl, rootEl, oldIndex);
}
},
_emulateDragOver: function () {
if (touchEvt) {
if (this._lastX === touchEvt.clientX && this._lastY === touchEvt.clientY) {
return;
}
this._lastX = touchEvt.clientX;
this._lastY = touchEvt.clientY;
if (!supportCssPointerEvents) {
_css(ghostEl, 'display', 'none');
}
var target = document.elementFromPoint(touchEvt.clientX, touchEvt.clientY),
parent = target,
groupName = ' ' + this.options.group.name + '',
i = touchDragOverListeners.length;
if (parent) {
do {
if (parent[expando] && parent[expando].options.groups.indexOf(groupName) > -1) {
while (i--) {
touchDragOverListeners[i]({
clientX: touchEvt.clientX,
clientY: touchEvt.clientY,
target: target,
rootEl: parent
});
}
break;
}
target = parent; // store last element
}
/* jshint boss:true */
while (parent = parent.parentNode);
}
if (!supportCssPointerEvents) {
_css(ghostEl, 'display', '');
}
}
},
/*
tapEvt = {
target: dragEl,
clientX: touch.clientX,
clientY: touch.clientY
};
*/
/***********************************************************************************************
*函數名 ：_onTouchMove
*函數功能描述 ： 觸摸移動拖拽動畫事件ghostEl，把拖拽移動的xy值給ghostEl節點
*函數參數 ： viod
*函數返回值 ： 無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_onTouchMove: function (/**TouchEvent*/evt) {
//evt 事件對象
if (tapEvt) {
// only set the status to dragging, when we are actually dragging
if (!Sortable.active) { //Sortable.active 不存在則執行_dragStarted函數 設置拖拽動態
this._dragStarted();
}
// as well as creating the ghost element on the document body
// 建立一個ghostEl dom節點，而且是克隆拖拽節點的rootEl下面就是id那個dom節點，添加在，而且設置了一些屬性，高,寬，top，left，透明度，鼠標樣式，
this._appendGhost();
var touch = evt.touches ? evt.touches[0] : evt, //判斷是不是觸摸事件仍是pc鼠標事件
dx = touch.clientX - tapEvt.clientX, //鼠標移動的x位置減去鼠標按下去的位置。
dy = touch.clientY - tapEvt.clientY,//鼠標移動的y位置減去鼠標按下去的位置。
//3d 特效 x是左右，y是上下，z是放大縮小 設置3d效果
translate3d = evt.touches ? 'translate3d(' + dx + 'px,' + dy + 'px,0)' : 'translate(' + dx + 'px,' + dy + 'px)';
moved = true;
touchEvt = touch; //事件對象
_css(ghostEl, 'webkitTransform', translate3d); //設置3d效果
_css(ghostEl, 'mozTransform', translate3d); //設置3d效果
_css(ghostEl, 'msTransform', translate3d) ; //設置3d效果
_css(ghostEl, 'transform', translate3d); //設置3d效果
evt.preventDefault(); // 阻止默認事件
}
},
/***********************************************************************************************
*函數名 ：_appendGhost
*函數功能描述 ： 建立一個ghostEl dom節點，而且是克隆拖拽節點的rootEl下面就是id那個dom節點，添加在，而且設置了一些屬性，高,寬，top，left，透明度，鼠標樣式，
*函數參數 ： viod
*函數返回值 ： 無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_appendGhost: function () {
if (!ghostEl) { // 若是ghostEl 是空的，或者是假，或者是undefined，或者是0，則執行下面程序
/*getBoundingClientRect()
其實跟 o_dom.getBoundingClientRect().left= o_dom.offsetLeft; 他們值相等
這個方法返回一個矩形對象，包含四個屬性：left、top、right和bottom。分別表示元素各邊與頁面上邊和左邊的距離。
*/
var rect = dragEl.getBoundingClientRect(),
css = _css(dragEl), //返回當前obj 全部的style的屬性
options = this.options, //this.options 參數
ghostRect; //一個空變量
ghostEl = dragEl.cloneNode(true); //克隆dragEl 當前拖拽的節點
//options.ghostClass='sortable-ghost'
_toggleClass(ghostEl, options.ghostClass, false);
//fallbackClass= 'sortable-fallback
_toggleClass(ghostEl, options.fallbackClass, true);
//給新建立的節點的left和top和該節點的left和top值相等，因此要減去marginTop，marginLeft
_css(ghostEl, 'top', rect.top - parseInt(css.marginTop, 10));
_css(ghostEl, 'left', rect.left - parseInt(css.marginLeft, 10));
_css(ghostEl, 'width', rect.width); //寬和高和拖拽節點相同
_css(ghostEl, 'height', rect.height);
_css(ghostEl, 'opacity', '0.8'); //透明度爲0.8
_css(ghostEl, 'position', 'fixed'); // 固定定位
_css(ghostEl, 'zIndex', '100000'); //層爲100000
_css(ghostEl, 'pointerEvents', 'none'); //pointer-events:none顧名思意，就是鼠標事件拜拜的意思。元素應用了該CSS屬性，連接啊，點擊啊什麼的都變成了「浮雲牌醬油」。
//把ghostEl 添加到拖拽的根節點那
options.fallbackOnBody && document.body.appendChild(ghostEl) || rootEl.appendChild(ghostEl);
// Fixing dimensions. 固定尺寸 可是我覺這樣寫畫蛇添足，由於上面已經設置高寬了，而後再乘以2，再減去通常結果仍是同樣的
ghostRect = ghostEl.getBoundingClientRect();
_css(ghostEl, 'width', rect.width * 2 - ghostRect.width);
_css(ghostEl, 'height', rect.height * 2 - ghostRect.height);
}
},
/***********************************************************************************************
*函數名 ：_onDragStart
*函數功能描述 ： 拖拽開始 爲document添加觸摸事件與鼠標事件
*函數參數 ：
evt：
類型:obj, 事件對象
useFallback:類型：string， Boolean 值
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_onDragStart: function (/**Event*/evt, /**boolean*/useFallback) {
//html5拖拽屬性。dataTransfer對象有兩個主要的方法：getData()方法和setData()方法。
var dataTransfer = evt.dataTransfer,
options = this.options;
//解綁文檔上面的一些事件
this._offUpEvents();
//Object {name: "words", pull: true, put: true}
//activeGroup={name: "words", pull: true, put: true}
if (activeGroup.pull == 'clone') { //若是 參數是clone 則能夠克隆節點而不是拖拽節點過去
cloneEl = dragEl.cloneNode(true); //cloneNode(false) 克隆複製節點，參數若是是false則不復制裏面的html，true則會複製整個dom包括裏面的html
//設置cloneEl 節點隱藏
_css(cloneEl, 'display', 'none');
//插入加點，在當前拖拽的dom節點前面插入一個節點
rootEl.insertBefore(cloneEl, dragEl);
}
if (useFallback) { //若是是觸摸則添加觸摸事件
if (useFallback === 'touch') {
// Bind touch events
//添加觸摸移動事件
_on(document, 'touchmove', this._onTouchMove);
//添加觸摸擡起事件
_on(document, 'touchend', this._onDrop);
//添加觸摸劃過結束事件
_on(document, 'touchcancel', this._onDrop);
} else {
// Old brwoser
//pc 添加鼠標移動事件
_on(document, 'mousemove', this._onTouchMove);
//pc 添加鼠標擡起事件
_on(document, 'mouseup', this._onDrop);
}
this._loopId = setInterval(this._emulateDragOver, 50);
}
else {
//html5拖拽屬性。dataTransfer對象有兩個主要的方法：getData()方法和setData()方法。
if (dataTransfer) {
dataTransfer.effectAllowed = 'move';//move ：只容許值爲」move」的dropEffect。
/*
setData: function (dataTransfer, dragEl) { dataTransfer.setData('Text', dragEl.textContent);}
設置拖拽時候拖拽信息
*/
options.setData && options.setData.call(this, dataTransfer, dragEl);
}
_on(document, 'drop', this); //添加拖拽結束事件
setTimeout(this._dragStarted, 0); //pc拖拽事件
}
},
/***********************************************************************************************
*函數名 ：_onDragOver
*函數功能描述 ： 拖拽元素進進入拖拽區域， 判斷拖拽節點與拖拽碰撞的節點，交換他們的dom節點位置，並執行動畫。
*函數參數 ：evt
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_onDragOver: function (/**Event*/evt) {
var el = this.el,
target,
dragRect,
revert,
options = this.options,
group = options.group,
groupPut = group.put,
isOwner = (activeGroup === group),
canSort = options.sort;
if (evt.preventDefault !== void 0) {
evt.preventDefault(); //阻止默認事件
!options.dragoverBubble && evt.stopPropagation();//終止事件在傳播過程的捕獲、目標處理或起泡階段進一步傳播
}
moved = true;
//activeGroup={name: "words", pull: true, put: true}
//activeGroup=true
//options.disabled=false
//isOwner=true 由於isOwner=true 則執行canSort || (revert = !rootEl.contains(dragEl))
//若是父節點包含子節點則返回true ，contains,因此當canSort 是假時候(revert = !rootEl.contains(dragEl)
//revert = !rootEl.contains(dragEl) 取反賦值
//這裏的if須要一個假才能拖拽
//(activeGroup.name === group.name) ==true;
//(evt.rootEl === void 0 || evt.rootEl === this.el) ==true
//因此 該功能是 給設置sort參數提供的
if (
activeGroup &&
!options.disabled &&
(
isOwner? canSort || (revert = !rootEl.contains(dragEl)) // Reverting item into the original list
: activeGroup.pull && groupPut && (
(activeGroup.name === group.name) || // by Name
(groupPut.indexOf && ~groupPut.indexOf(activeGroup.name)) // by Array
)
) &&
(evt.rootEl === void 0 || evt.rootEl === this.el) // touch fallback
)
{
// Smart auto-scrolling 智能滾動
_autoScroll(evt, options, this.el);
if (_silent) {
return;
}
target = _closest(evt.target, options.draggable, el); //調整拖拽目標節點
dragRect = dragEl.getBoundingClientRect(); //獲取dom節點的一個獲取left，right ，top，bottmo，值
if (revert) { //revert undefined
_cloneHide(true); //設置克隆的節點隱藏仍是顯示
if (cloneEl || nextEl) { //若是克隆節點存在或者下一個節點存在
rootEl.insertBefore(dragEl, cloneEl || nextEl);//就把dragEl添加到克隆節點存在或者下一個節點的上面
}
else if (!canSort) { //canSort 默認是true ，是設置是否 判斷是否在本身區域拖拽
rootEl.appendChild(dragEl); //canSort 是假添加到根節點
}
return;
}
//el.children.length 若是拖拽根節點沒有子節點的時候該爲true
//el.children[0] === ghostEl若是根節點的字節點等於鏡像節點的時候爲真
//el === evt.target 根節點等於目標節點的時候
if ((el.children.length === 0) || (el.children[0] === ghostEl) ||
(el === evt.target) && (target = _ghostIsLast(el, evt))
) {
if (target) { // 若是_ghostIsLast 返回最後一個節點
if (target.animated) { //判斷 target.animated 動畫是否在執行，若是在執行那麼就不執行下面函數
return;
}
targetRect = target.getBoundingClientRect();
}
//隱藏克隆節點
_cloneHide(isOwner);
/*
rootEl:拖拽根節點
el:拖拽根節點
dragEl:拖拽節點
dragRect:拖拽幾點的Rect
target:目標節點或者是根節點的最後一個子節點，釋放鼠標的節點
targetRect:target的Rect
*/
if (_onMove(rootEl, el, dragEl, dragRect, target, targetRect) !== false) {
if (!dragEl.contains(el)) { // 判斷dragEl中沒有存在根節點
el.appendChild(dragEl); //就把目拖拽節點添加到根節點那
parentEl = el; // actualization
}
//動畫
this._animate(dragRect, dragEl);
target && this._animate(targetRect, target);
}
}
//target 拖拽的目標節點存在
//target.animated動畫沒有在執行
//target !== dragEl 拖拽的節點不等於目標節點 就是發生了dragenter事件
//target 拖拽的父節點是根節點 rootEl
else if (target && !target.animated && target !== dragEl && (target.parentNode[expando] !== void 0)) {
i++;
if (lastEl !== target) { // 拖拽的目標節點就是發生拖拽ondragover時候的節點 不是最後一個子節點的時候
lastEl = target; //將拖拽的目標節點賦值給最後一個節點
lastCSS = _css(target); //獲取最後目標節點的css所有屬性
lastParentCSS = _css(target.parentNode); //獲取根節點的所有css屬性
}
///left|right|inline/.test(str) 匹配str中只要含有left|right|inline 中的任何一個就能夠爲真
//floating 其實就是判斷這裏的拖拽節點是否已經有浮動，或者是inline也跟浮動差很少，或者是css3的flex-direction橫向對其成一排的那個屬性
//isWide：若是目標節點的寬大於拖拽節點的寬
//isLong:若是目標節點的高大於拖拽節點的高
var targetRect = target.getBoundingClientRect(), //目標節點的rect
width = targetRect.right - targetRect.left, //目標節點的寬
height = targetRect.bottom - targetRect.top, //目標節點的高
floating = /left|right|inline|inlineBlock/.test(lastCSS.cssFloat + lastCSS.display)
|| (lastParentCSS.display == 'flex' && lastParentCSS['flex-direction'].indexOf('row') === 0),
isWide = (target.offsetWidth > dragEl.offsetWidth), //目標節點寬大於拖拽節點
isLong = (target.offsetHeight > dragEl.offsetHeight),//目標節點高大於拖拽節點
//halfway 若是floating 浮動，inline，橫向對齊 了就判斷此時鼠標是在target中間的左邊仍是右邊，右邊則爲true，不然false
//halfway 若是floating 沒有浮動，inline，橫向對齊 就判斷此時鼠標是在target中間的上面邊仍是下面，下邊則爲true，不然false
halfway = (floating ?
(evt.clientX - targetRect.left) / width :
(evt.clientY - targetRect.top) / height
)
> 0.5,
// 目標節點的下一個節點。
nextSibling = target.nextElementSibling,
/*
rootEl:拖拽根節點
el:拖拽根節點
dragEl:拖拽節點
dragRect:拖拽幾點的Rect
target:拖拽節點或者是根節點的最後一個子節點
targetRect:target的Rect
*/
moveVector = _onMove(rootEl, el, dragEl, dragRect, target, targetRect), //空undefined
after // after true 往下拖拽, false 往上拖拽
;
if (moveVector !== false) {
_silent = true;
setTimeout(_unsilent, 30); //30毫秒設置爲假
_cloneHide(isOwner); //隱藏克隆節點
if (moveVector === 1 || moveVector === -1) {//空undefined
after = (moveVector === 1);
}
else if (floating) { //若是浮動
var elTop = dragEl.offsetTop, //拖拽接點的top
tgTop = target.offsetTop; //目標節點top
if (elTop === tgTop) { // //拖拽幾點的top===目標節點top 說明他們是在同一列中
//target.previousElementSibling 若是目標節點的上一個節點是拖拽節點，這裏就是他們上下節點互換位置,!isWide 目標節點寬小於拖拽節點
//或者 halfway 爲真而且 isWide 目標節點寬大於拖拽節點
//
} else {
//目標節點top大於>拖拽接點的top
after = tgTop > elTop; // after true 往下拖拽 false 往上拖拽
}
} else {
//沒有浮動的時候
// 目標節點的下一個節點。
// console.log('nextSibling !== dragEl'+(nextSibling !== dragEl)); //往下拖拽
//dom節點是按照拖拽完以後排序作判斷
//(nextSibling !== dragEl) 不是往上拖拽的時候 則爲真的時候 若是目標節點的高大於拖拽節點的高
//halfway 爲真的時候。若是目標節點的高大於拖拽節點的高after 爲真
after = (nextSibling !== dragEl) && !isLong || halfway && isLong;
}
if (!dragEl.contains(el)) {
if (after && !nextSibling) { //
el.appendChild(dragEl); //若是此時 目標的的下一個節點不存在那麼直接把拖拽節點添加在後面便可
} else {
//判斷拖拽節點添加到哪一個位置after真時候是往下拖拽則把拖拽節點添加到target下面。
//判斷拖拽節點添加到哪一個位置after假時候是往下拖拽則把拖拽節點添加到target上面。
target.parentNode.insertBefore(dragEl, after ? nextSibling : target);
}
}
parentEl = dragEl.parentNode; // actualization
//交換位置前的drgRect， 交換後位置的拖拽節點dragEl
//交換位置前的目標節點targetRect， 交換後位置的目標節點dragEl
//執行動畫。css3動畫
this._animate(dragRect, dragEl); //執行css3動畫其實只是一種掩飾而已，真正的核心是他們交換dom節點的位置
//執行動畫。css3動畫
this._animate(targetRect, target);
}
}
}
},
/***********************************************************************************************
*函數名 ：_animate
*函數功能描述 ： 動畫效果，執行css3動畫
*函數參數 ：
prevRect：obj，初始動畫的座標，
target：obj，target 其實最重要是獲取交換dom節點後的座標
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_animate: function (prevRect, target) {
//每次當目標節點與拖拽節點交替的時候就調用次改函數
//i++;
//prevRect: obj.getBoundingClientRect
//target:obj
var ms = this.options.animation; //動畫延遲
if (ms) {
var currentRect = target.getBoundingClientRect();
//debugger;
_css(target, 'transition', 'none');
_css(target, 'transform', 'translate3d('
+ (prevRect.left - currentRect.left) + 'px,'
+ (prevRect.top - currentRect.top) + 'px,0)'
);
target.offsetWidth; // repaint
_css(target, 'transition', 'all ' + ms + 'ms');
_css(target, 'transform', 'translate3d(0,0,0)');
clearTimeout(target.animated);
target.animated = setTimeout(function () {
_css(target, 'transition', '');
_css(target, 'transform', '');
target.animated = false;
}, ms);
}
},
/***********************************************************************************************
*函數名 ：_offUpEvents
*函數功能描述 ： 解綁文檔上的拖拽函數
*函數參數 ： viod
*函數返回值 ：viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_offUpEvents: function () {
var ownerDocument = this.el.ownerDocument;
_off(document, 'touchmove', this._onTouchMove); //當文檔上面document 發生觸摸移動事件的時候解綁 _onTouchMove事件
_off(ownerDocument, 'mouseup', this._onDrop); //當文檔上面document 發生鼠標擡起事件的時候解綁 _onTouchMove事件
_off(ownerDocument, 'touchend', this._onDrop); //當文檔上面document 發生觸摸結束事件的時候解綁 _onTouchMove事件
//當一些更高級別的事件發生的時候（如電話接入或者彈出信息）會取消當前的touch操做，即觸發ontouchcancel。通常會在ontouchcancel時暫停遊戲、存檔等操做。
_off(ownerDocument, 'touchcancel', this._onDrop); //當文檔發生手指劃過結束的時候解綁_onDrop 事件
},
//Drop被拖拽的元素在目標元素上同時鼠標放開觸發的事件，此事件做用在目標元素上
/***********************************************************************************************
*函數名 ：init
*函數功能描述 ： 初始化做用
*函數參數 ：
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_onDrop: function (/**Event*/evt) {
//evt 事件對象
var el = this.el, //拖拽的根節點
options = this.options; //參數類
clearInterval(this._loopId); //清除_loopId 定時器
clearInterval(autoScroll.pid);//清除pid 定時器
clearTimeout(this._dragStartTimer);//清除_dragStartTimer 定時器
// Unbind events
_off(document, 'mousemove', this._onTouchMove); //解除文檔上面的鼠標移動事件函數爲_onTouchMove
/*
DataTransfer 對象：退拽對象用來傳遞的媒介，使用通常爲Event.dataTransfer。
draggable 屬性：就是標籤元素要設置draggable=true，不然不會有效果，例如：
<div title="拖拽我" draggable="true">列表1</div>
ondragstart 事件：當拖拽元素開始被拖拽的時候觸發的事件，此事件做用在被拖曳元素上
ondragenter 事件：當拖曳元素進入目標元素的時候觸發的事件，此事件做用在目標元素上
ondragover 事件：拖拽元素在目標元素上移動的時候觸發的事件，此事件做用在目標元素上
ondrop 事件：被拖拽的元素在目標元素上同時鼠標放開觸發的事件，此事件做用在目標元素上
ondragend 事件：當拖拽完成後觸發的事件，此事件做用在被拖曳元素上
Event.preventDefault() 方法：阻止默認的些事件方法等執行。在ondragover中必定要執行preventDefault()，不然ondrop事件不會被觸發。另外，若是是從其餘應用軟件或是文件中拖東西進來，尤爲是圖片的時候，默認的動做是顯示這個圖片或是相關信息，並非真的執行drop。此時須要用用document的ondragover事件把它直接幹掉。
Event.effectAllowed 屬性：就是拖拽的效果。
若是nativeDraggable是true 那麼
*/
if (this.nativeDraggable) {
_off(document, 'drop', this); //解綁drop 事件 函數是handleEvent
_off(el, 'dragstart', this._onDragStart); //解綁html5的拖拽dragstart事件 函數是 _onDragStart
}
//解綁文檔上面的一些事件
this._offUpEvents();
if (evt) {
if (moved) {
evt.preventDefault(); //阻止默認事件
!options.dropBubble && evt.stopPropagation(); //阻止事件冒泡
}
//ghostEl 在736行時候纔會建立該節點，因此在736行調用_onDrop函數的時候都是爲空
//若是拖拽的鏡像對象存在那麼他就添加在拖拽的根節點
ghostEl && ghostEl.parentNode.removeChild(ghostEl);
if (dragEl) {
if (this.nativeDraggable) {
//若是拖拽節點存在了 就解綁this 的 handleEvent 事件
_off(dragEl, 'dragend', this);
}
//禁用拖拽html5 屬性
_disableDraggable(dragEl);
// Remove class's //刪除css
_toggleClass(dragEl, this.options.ghostClass, false);
_toggleClass(dragEl, this.options.chosenClass, false);
if (rootEl !== parentEl) { //若是從一個列表拖拽到另外一個列表的時候
//返回當前的索引
newIndex = _index(dragEl, options.draggable);
if (newIndex >= 0) { //若是當前的索引大於0
// drag from one list and drop into another //從類表中拖拽到另外一個列表
//事件接口
_dispatchEvent(null, parentEl, 'sort', dragEl, rootEl, oldIndex, newIndex); //開始拖拽函數建立與觸發
_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);//開始拖拽函數建立與觸發
// Add event
_dispatchEvent(null, parentEl, 'add', dragEl, rootEl, oldIndex, newIndex);//添加節點拖拽函數建立與觸發
// Remove event//刪除節點拖拽函數建立與觸發
_dispatchEvent(this, rootEl, 'remove', dragEl, rootEl, oldIndex, newIndex);
}
}
else { //同一個列表中
// Remove clone
cloneEl && cloneEl.parentNode.removeChild(cloneEl);
if (dragEl.nextSibling !== nextEl) {
// Get the index of the dragged element within its parent
newIndex = _index(dragEl, options.draggable);
if (newIndex >= 0) {
// drag & drop within the same list //update拖拽更新新數據
_dispatchEvent(this, rootEl, 'update', dragEl, rootEl, oldIndex, newIndex);
_dispatchEvent(this, rootEl, 'sort', dragEl, rootEl, oldIndex, newIndex);
}
}
}
if (Sortable.active) { //Sortable.active 存在說明已經拖拽開始了
/* jshint eqnull:true */
if (newIndex == null || newIndex === -1) {//newIndex 這個條件成立的時候是拖拽第一個節點而且沒有更換拖拽位置
newIndex = oldIndex;
}
//拖拽結束
_dispatchEvent(this, rootEl, 'end', dragEl, rootEl, oldIndex, newIndex);
// Save sorting //保存排序
this.save();
}
}
}
//從新初始化參數
this._nulling();
},
/***********************************************************************************************
*函數名 ：_nulling
*函數功能描述 ： 初始化拖拽的數據
*函數參數 ：
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
_nulling: function () {
if (Sortable.active === this) {
rootEl = //鼠標按下去拖拽節點的根節點
dragEl = //鼠標按下去拖拽節點
parentEl = //拖拽的父節點 鼠標拖拽 發生ondragover 事件 拖拽節點放到目標節點的時候發生事件 的根節點 父節點，也有多是鼠標按下去拖拽的根節點
ghostEl = // 拖拽鏡像
nextEl = //下一個節點
cloneEl = //拖拽克隆節點
scrollEl = //滾動節點
scrollParentEl = //滾動的父節點
tapEvt = //tapEvt 觸摸對象包括x與y軸與拖拽當前節點
touchEvt = //觸摸事件對象
moved = //布爾值
newIndex = //拖拽的如今索引
lastEl = //拖拽根節點中的最後一個子節點
lastCSS = //拖拽根節點中的最後一個子節點class
activeGroup = //options.group
Sortable.active = null;
}
},
/***********************************************************************************************
*函數名 ：handleEvent
*函數功能描述 ： 爲事件綁定this的時候提供該事件，判斷是否在拖拽仍是拖拽結束，調用對應的函數
*函數參數 ：
evt:
類型：object，事件類型 拖拽的事件類型
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
handleEvent: function (/**Event*/evt) {//handleEvent 是該事件綁定這個對象的時候則發生這裏的事件，則事件綁定給Sortable 的時候則發生這裏的事件
var type = evt.type;
//dragover 在拖拽區域移動拖拽時候發生事件至關於move
//dragenter 元素放入到拖拽的區域中至關於 over
if (type === 'dragover' || type === 'dragenter') { //事件正在拖拽的時候
if (dragEl) { //在300行的時候調用dragover與dragenter事件，這個時候dragEl是處於聲明而已可是沒有賦值因此是undefined， 若是dragEl 存在則是真正拖拽的時候，dragEl是拖拽鏡像
this._onDragOver(evt);
_globalDragOver(evt);
}
}
else if (type === 'drop' || type === 'dragend') { //拖拽事件結束的時候
this._onDrop(evt);
}
},
/**
* Serializes the item into an array of string.
* @returns {String[]}
*/
/***********************************************************************************************
*函數名 ：toArray
*函數功能描述 ： 獲取dom節點的 data-id 的屬性 若是沒有則 會調用_generateId函數生成惟一表示符
*函數參數 ： viod
*函數返回值 ： 類型：array 生成惟一標識符的id數組
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
toArray: function () {
var order = [],
el,
children = this.el.children, //獲取全部子節點
i = 0,
n = children.length, //獲取子節點的長度
options = this.options;
for (; i < n; i++) {
el = children[i];
if (_closest(el, options.draggable, this.el)) {
//getAttribute獲取 data-id 的屬性
//order.push 若是沒有data-id 屬性獲取不到值，則會調用_generateId函數生成惟一表示符
order.push(el.getAttribute(options.dataIdAttr) || _generateId(el));
}
}
//返回惟一標識符id 數組 類型
return order;
},
/**
* Sorts the elements according to the array.
* @param {String[]} order order of the items
*/
/***********************************************************************************************
*函數名 ：sort
*函數功能描述 ： 刪除含有這個id的子節點 刪除他 讓他從新排序， 從棧底部插入數據
*函數參數 ： order：
類型：array， 數組id
*函數返回值 ： void
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
sort: function (order) {
debugger;
//order 數組
var items = {},
rootEl = this.el; //鼠標開始拖拽的根節點
this.toArray().forEach(function (id, i) { //遍歷this.toArray() 數組中的id
var el = rootEl.children[i];
if (_closest(el, this.options.draggable, rootEl)) {
items[id] = el; //遍歷數組中的id 賦值給一個對象
}
}, this);
order.forEach(function (id) {
if (items[id]) {
rootEl.removeChild(items[id]); //刪除含有這個id的子節點 刪除他 讓他從新排序，
rootEl.appendChild(items[id]);//刪除含有這個id的子節點 刪除他 讓他從新排序， 從棧底部插入數據
}
});
},
/**
* Save the current sorting
保存排序
*/
save: function () {
var store = this.options.store;
store && store.set(this);
},
/**
* For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree.
* @param {HTMLElement} el
* @param {String} [selector] default: `options.draggable`
* @returns {HTMLElement|null}
*/
/***********************************************************************************************
*函數名 ：_closest
*函數功能描述 ： 用來調節節點，匹配節點。匹配calss。 匹配觸發dom該函數的dom節點中的tag或者class，selector參數能夠是tag或者class或者>*，
若是是>* 而且當前的父節點和ctx 參數相同 則不須要匹配直接返回el，若是是tag或者class則匹配。
*函數參數 ：
el：
類型:obj，拖拽節點dom
selector：
類型：字符串，若是selector是'li' : '>*'則返回是改節點dom，還有若是selector是和當前拖拽節點的name相同則也返回改節點dom，還有匹配觸發該函數的el中的class是不是和參數中selector相同，相同則返回true，不然返回null
*函數返回值 ：dom和null
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
closest: function (el, selector) {
return _closest(el, selector || this.options.draggable, this.el);
},
/**
* Set/get option
* @param {string} name
* @param {*} [value]
* @returns {*}
*/
/***********************************************************************************************
*函數名 ：option
*函數功能描述 ： 獲取option對象中的某個參數，或者設置option對象中的某個參數
*函數參數 ：name：
類型：string， option的key，
value：類型：string， 設置option的值
*函數返回值 ： viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
option: function (name, value) {
var options = this.options;
if (value === void 0) { //當沒有傳遞第二個參數的時候 則返回該options參數的某個值
return options[name];
} else {
options[name] = value;// 設置options參數的某個值
if (name === 'group') { // 若是name 是group 則在後面添加['pull', 'put']屬性
_prepareGroup(options);
}
}
},
/**
* Destroy 破壞
*/
/***********************************************************************************************
*函數名 ：destroy
*函數功能描述 ： 清空拖拽事件，和狀況拖拽列表dom節點，銷燬拖拽 。
*函數參數 viod
*函數返回值 ： viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
destroy: function () {
var el = this.el;
el[expando] = null; //把每個時間戳的Sortable 的對象置爲空
_off(el, 'mousedown', this._onTapStart); // 解綁拖拽類表中的mousedown事件_onTapStart函數
_off(el, 'touchstart', this._onTapStart); // 解綁拖拽類表中的touchstart事件_onTapStart函數
if (this.nativeDraggable) {
_off(el, 'dragover', this); // 解綁拖拽類表中的dragover事件handleEvent函數
_off(el, 'dragenter', this);// 解綁拖拽類表中的dragover事件handleEvent函數
}
// Remove draggable attributes
//把頁面上全部含有draggable 屬性的dom節點 所有刪除該屬性，讓它不能拖拽
Array.prototype.forEach.call(el.querySelectorAll('[draggable]'), function (el) {
el.removeAttribute('draggable');
});
//刪除touchDragOverListeners 觸摸列表事件_onDragOver
touchDragOverListeners.splice(touchDragOverListeners.indexOf(this._onDragOver), 1);
this._onDrop(); //從新初始化
this.el = el = null; //把拖拽列表的dom節點清空
}
};
/***********************************************************************************************
*函數名 ：_cloneHide
*函數功能描述 ： 設置克隆的節點隱藏顯示，是否添加到頁面
*函數參數 ：
state：
類型:Boolean 真，假
*函數返回值 ： viod
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _cloneHide(state) {
//state布爾值
//cloneEl 克隆的節點
//state 狀態
if (cloneEl && (cloneEl.state !== state)) {//若是cloneEl 存在，而且cloneEl.state 不等於state 的時候
_css(cloneEl, 'display', state ? 'none' : ''); //state 爲真的時候把它隱藏，爲假的時候顯示
!state && cloneEl.state && rootEl.insertBefore(cloneEl, dragEl);//state爲假的時候cloneEl.state 爲真則把cloneEl添加在dragEl前面
cloneEl.state = state; //
}
}
/***********************************************************************************************
*函數名 ：_closest
*函數功能描述 ： 匹配觸發dom該函數的dom節點中的tag或者class，selector參數能夠是tag或者class或者>*，
若是是>* 而且當前的父節點和ctx 參數相同 則不須要匹配直接返回el，若是是tag或者class則匹配
*函數參數 ：
el：
類型:obj，拖拽節點dom
selector：
類型：字符串，若是selector是'li' : '>*'則返回是改節點dom，還有若是selector是和當前拖拽節點的name相同則也返回改節點dom，還有匹配觸發該函數的el中的class是不是和參數中selector相同，相同則返回true，不然返回null
ctx：ctx用來匹配當前selector的父節點是否等於ctx節點
*函數返回值 ：dom和null
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _closest(/**HTMLElement*/el, /**String*/selector, /**HTMLElement*/ctx) {
/* el 目標節點
selector /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
ctx 父親節點*/
if (el) {
//若是沒有傳父親節點過來則是整個文檔
ctx = ctx || document;
do {
if (
//若是不是li而是其餘節點 而且已經搜索完了直到是父親節點的時候就返回true
//或者走_matches _matches 須要true
//selector === '>*' && el.parentNode === ctx 若是 selector === '>*' 表示父節點不是ol或ul
(selector === '>*' && el.parentNode === ctx)
|| _matches(el, selector)
) {
return el;
}
}
//el !== ctx 若是目標節點不是當前的父節點，則會一直找上一層的父節點知道當他找到當前的根父節點程序則中止。
while (el !== ctx && (el = el.parentNode)); //若是條件不成立一直需找上一層父節點
}
return null;
}
/*
*函數名 ：_globalDragOver
*函數功能描述 ：設置拖動的元素移動到放置目標。
*參數說明：
evt：類型obj事件對象
返回值：void
*/
function _globalDragOver(/**Event*/evt) {
/*
1.effectAllowed屬性表示容許拖放元素的哪一種dropEffect。什麼是dropEffect?也是dataTransfer 的一種屬性。
dropEffect屬性能夠知道被拖動的元素可以執行哪一種放置行爲（當拖到目的地時）。這個屬性有下列4個可能的值。
「none」：不能把拖動的元素放在這裏。這是除文本框以外全部元素的默認值。
「move」：應該把拖動的元素移動到放置目標。
「copy」：應該把拖動的元素複製到放置目標。
「link」：表示放置目標會打開拖動的元素（但拖動的元素必須是一個連接，有URL）。
2. dt.effectAllowed = 'all'：即說被拖動元素在放置到目的地時，能夠上面的任意一種效果來處理。
3. 必須在ondraggstart事件處理程序中設置effectAllowed屬性。
*/
if (evt.dataTransfer) {
evt.dataTransfer.dropEffect = 'move'; //「move」：應該把拖動的元素移動到放置目標。
}
evt.preventDefault();
}
/*
*函數名 ：_on
*函數功能描述 ： 事件綁定
*參數說明：
el：類型DOM節點，
name：類型string，事件類型
fn：類型：function，須要綁定的函數
*/
function _on(el, event, fn) {
el.addEventListener(event, fn, false);
}
/*
*函數名 ：_toggleClass
*函數功能描述 ： 添加刪除calss
*參數說明：
el：類型DOM節點， 須要添加和刪除的dom節點，
name：類型string，須要添加刪除class字符串的
fn：類型：布爾值，若是是真則刪除name的class名稱不然添加
*/
function _off(el, event, fn) {
el.removeEventListener(event, fn, false);
}
/*
*函數名 ：_toggleClass
*函數功能描述 ： 添加刪除calss
*參數說明：
el：類型DOM節點， 須要添加和刪除的dom節點，
name：類型string，須要添加刪除class字符串的
state：類型：布爾值，若是是真則刪除name的class名稱不然添加
*/
function _toggleClass(el, name, state) {
//console.log(el.classList); //獲取dom節點clss的個數而且以數組形式存儲起來
//el.classList 判斷當前的拖拽節點又沒有class 若是有
if (el) {
if (el.classList) {
//若是state 是真則在改節點上面添加name class 不然刪除name class
el.classList[state ? 'add' : 'remove'](name);
}
else {
//replace() 方法用於在字符串中用一些字符替換另外一些字符，或替換一個與正則表達式匹配的子串。
// RSPACE = /\s+/g, 匹配1-n個空格 全局匹配
// (' ' + el.className + ' ').replace(RSPACE, ' ') 去除class 中的全部空格 而且只保留一個空格 每個class中
//className = (' ' + el.className + ' ').replace(RSPACE, '').replace(' ' + name + ' ', ' '); 剔除 name class
var className = (' ' + el.className + ' ').replace(RSPACE, '').replace(' ' + name + ' ', ' ');
//若是state 是真則在改節點上面添加name class 不然刪除name class
el.className = (className + (state ? ' ' + name : '')).replace(RSPACE, ' ');
}
}
}
/*
*函數名 ：設置 樣式 與 獲取dom節點的style屬性
*函數功能描述 ： 添加刪除calss,獲取dom節點所有css屬性，若是是一個參數的時候將返回該dom節點的所有css屬性，若是是兩個參數的時候該返回該css的第二個參數的值，若是是三個參數的話將設置css樣式
*參數說明：
el：類型DOM節點， 須要添加和刪除的dom節點，
prop：類型string，須要添加刪除class字符串的那麼
val：類型：布爾值，若是是真則刪除name的class名稱不然添加
*/
function _css(el, prop, val) {
var style = el && el.style; //若是el存在而且他是dom節點style=el.style
if (style) {
if (val === void 0) { //若是val===undefined
//var win = document.defaultView; 返回當前文檔上面的全部對象
//document.defaultView.getComputedStyle 返回當前文檔上的對象的樣式方法
//
if (document.defaultView && document.defaultView.getComputedStyle) {
val = document.defaultView.getComputedStyle(el, ''); //獲取到改dom節點的所有style屬性，而且帶有值
}
else if (el.currentStyle) {
val = el.currentStyle; //getComputedStyle與currentStyle獲取樣式(style/class)
}
return prop === void 0 ? val : val[prop]; //若是prop爲undefined則返回style所有屬性
}
else {
if (!(prop in style)) { //若是prop中這個屬性中style中沒有
prop = '-webkit-' + prop; //則在這個prop前面加 '-webkit-' 字符串
}
style[prop] = val + (typeof val === 'string' ? '' : 'px'); // 若是val類型是數子則添加px
}
}
}
/***********************************************************************************************
*函數名 ：_find
*函數功能描述 ： 獲取拖拽節點下面的全部a和img標籤，而且設置他們禁止拖拽行爲
*函數參數 ：
ctx：
類型：dom-obj 拖拽的節點
tagName：
類型：string，ctx.getElementsByTagName(tagName)
獲取拖拽節點下面的全部a和img
*函數返回值 ： a和img的dom集合
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _find(ctx, tagName, iterator) {
/*
ctx 拖拽的節點
ctx.getElementsByTagName(tagName) 獲取拖拽節點下面的全部a和img
_disableDraggable 是一個函數
iterator=_disableDraggable
_find(ctx, tagName, iterator) 該函數功能是把當前拖拽對象的a和img節點的html5 拖拽屬性改成false
*/
if (ctx) {
var list = ctx.getElementsByTagName(tagName), i = 0, n = list.length;
if (iterator) {
for (; i < n; i++) {
iterator(list[i], i);
}
}
return list;
}
return [];
}
/***********************************************************************************************
*函數名 ：_dispatchEvent
*函數功能描述 ： 建立一個事件，事件參數主要由name 提供，而且觸發該事件，其實就是模擬事件而且觸發該事件
*函數參數 ：
sortable：
類型： obj sortable
rootEl：
類型： dom-obj 鼠標按下去拖拽節點的根節點
name： 類型： string 須要建立的事件
targetEl：dom-obj 鼠標按下去拖拽節點，觸屏到發生事件ondragover的節點的根節點，就是目標節點的根節點。可是若是是start事件的時候傳進來的改參數就是鼠標按下去拖拽節點的根節點
fromEl：
類型： dom-obj 鼠標按下去拖拽節點的根節點 參數和第二個同樣，爲何重寫參數進來呢，多是爲了兼容這樣的的吧
startIndex：
類型： number 鼠標按下去拖拽節點的索引
newIndex：
類型： number
* *函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _dispatchEvent(sortable, rootEl, name, targetEl, fromEl, startIndex, newIndex) {
var evt = document.createEvent('Event'), //建立一個事件
options = (sortable || rootEl[expando]).options, //獲取options 參數
//name.charAt(0) 獲取name的第一個字符串
//toUpperCase() 變成大寫
//name.substr(1) 提取從索引爲1下標到字符串的結束位置的字符串
//onName 將得到 on+首個字母大寫+name從第一個下標獲取到的字符串
onName = 'on' + name.charAt(0).toUpperCase() + name.substr(1);
evt.initEvent(name, true, true); //自定義一個事件
evt.to = rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.from = fromEl || rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.item = targetEl || rootEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.clone = cloneEl; //在觸發該事件發生evt的時候，將evt添加多一個to屬性，值爲rootEl
evt.oldIndex = startIndex; //開始拖拽節點
evt.newIndex = newIndex; //如今節點
//觸發該事件，而且是在rootEl 節點上面 。觸發事件接口就這這裏了。onAdd: onUpdate: onRemove:onStart:onSort:onEnd:
rootEl.dispatchEvent(evt);
if (options[onName]) {
options[onName].call(sortable, evt);
}
}
/***********************************************************************************************
*函數名 ：_onMove
*函數功能描述 ： 表格分頁數據
*函數參數 ：
fromEl：
類型：obj，拖拽的根節點
toEl：
類型：obj，拖拽的根節點
dragEl：
類型：obj，拖拽的節點
dragRect：
類型：obj，拖拽的節點rect
targetEl：
類型：obj，目標節點 ondragover 發生事件的節點
targetRect：
類型：obj，目標節點rect
*函數返回值 ： retVal
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _onMove(fromEl, toEl, dragEl, dragRect, targetEl, targetRect) {
var evt,
//sortable 類 //fromEl 是根節點
sortable = fromEl[expando], //expando = 'Sortable' + (new Date).getTime(), //字符串Sortable+時間戳 el[expando] = this; //把 Sortable 類放在HTMLDOM節點的expando屬性中
onMoveFn = sortable.options.onMove, //空undefined
retVal;
evt = document.createEvent('Event'); //建立一個事件對象
evt.initEvent('move', true, true); //添加移動事件
evt.to = toEl; //把根節點賦值給to的屬性上面
evt.from = fromEl; //把根節點賦值給from的屬性上面
evt.dragged = dragEl; //把如今拖拽節點賦值給to的屬性上面
evt.draggedRect = dragRect; //把現 在拖拽節點的rect
evt.related = targetEl || toEl; //判斷目標節點或者是toel節點誰存在誰賦值給related 不過targetEl 有限權限高
evt.relatedRect = targetRect || toEl.getBoundingClientRect(); //判斷targetEl的節點的rect或者是toel節點rect誰存在誰賦值給related 不過targetEl的rect 有限權限高
fromEl.dispatchEvent(evt); //在根節點觸發移動事件
if (onMoveFn) {
retVal = onMoveFn.call(sortable, evt); //若是移動函數存在則知心移動函數onMoveFn
}
return retVal; //返回該移動函數執行的結果 //空undefined
}
/***********************************************************************************************
*函數名 ：_disableDraggable
*函數功能描述 ： 禁用拖動 把heml5的拖拽屬性設置爲假
*函數參數 ：viod
*函數返回值 ：無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _disableDraggable(el) {
el.draggable = false;
}
/***********************************************************************************************
*函數名 ：_unsilent
*函數功能描述 ： 將 _silent 設置爲假
*函數參數 ：viod
*函數返回值 ：無
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _unsilent() {
_silent = false;
}
/** @returns {HTMLElement|false} */
/***********************************************************************************************
*函數名 ：_ghostIsLast
*函數功能描述 ： 表格分頁數據
*函數參數 ：
el ：類型：dom，拖拽的根節點
evt：類型：obj，事件對象
*函數返回值 ：
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _ghostIsLast(el, evt) {
var lastEl = el.lastElementChild, //最後一個節點
rect = lastEl.getBoundingClientRect(); //最後一個節點的rect
return (
(evt.clientY - (rect.top + rect.height) > 5) || //判斷鼠標位置是否在dom節點的bottom下面仍是上面 若是是作下面則結果大於0 不然小於0 ，若是鼠標位置在dom節點bottom下面大於5px的時候則返回lastEl 節點
(evt.clientX - (rect.right + rect.width) > 5) //不知道是否是程序把right寫錯了，寫成了left。若是是right話則是這樣。判斷鼠標位置是否在dom節點的right左邊仍是右邊 若是是左邊則大於0，不然小於0 若是鼠標位置在dom節點right右邊面大於5px的時候則返回lastEl 節點
) && lastEl; // min delta
}
/**
* Generate id
* @param {HTMLElement} el
* @returns {String}
* @private
*/
/***********************************************************************************************
*函數名 ：_generateId
*函數功能描述 ： 根據tag的name和class，src，href，文本內容，來匹配生成惟一的標識符
*函數參數 ：
el：dom節點
*函數返回值 ：string
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _generateId(el) {
var str = el.tagName + el.className + el.src + el.href + el.textContent,
i = str.length,
sum = 0;
while (i--) {
sum += str.charCodeAt(i);
}
return sum.toString(36); //生成36進制
}
/**
* Returns the index of an element within its parent for a selected set of
* elements
* @param {HTMLElement} el
* @param {selector} selector
* @return {number}
*/
/***********************************************************************************************
*函數名 ：_index
*函數功能描述 ： 返回在其父範圍內的元素的元素的索引
*函數參數 ：
el
*函數返回值 ：number
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _index(el, selector) {
var index = 0;
//若是目標節點不存在，或者目標節點的父節點不存在則返回一個 -1 就是當前目標節點若是是window 則返回-1
if (!el || !el.parentNode) {
return -1;
}
//el.previousElementSibling 獲取上一個節點
/*
TEMPLATE 標籤 html5 模板標籤 例子
// 模板文本
<template id="tpl">
<img src="dummy.png" title="{{title}}"/>
</template>
// 獲取模板
<script type="text/javascript">
var tplEl = document.getElementById('tpl')
// 經過tplEl.innerText獲取也能夠
var tpl = tplEl.innerHTML
tpl = tpl.replace(/^[\s\u3000]*|[\s\u3000]*$/, '')
Handlebars.compile(tpl)({title: 'test'})
</script>
意思是當節點是TEMPLATE標籤的時候則表示該搜索標籤已經到達了最頂端
*/
while (el && (el = el.previousElementSibling)) {
if (el.nodeName.toUpperCase() !== 'TEMPLATE'
&& _matches(el, selector)) {
index++;
}
}
return index;
}
/***********************************************************************************************
*函數名 ：_matches
*函數功能描述 ： 匹配tag和tag，匹配clsss和tag，
*函數參數 ：
el：
類型:obj，當前拖拽節點dom
selector:
類型：string, tag或者clasname
*函數返回值 ：
類型：Boolean,真假，selector若是傳遞的是tag，則當前的el的tag和selector的tag要一樣，或當前的el的class含有selector 中的calss則返回真，不然返回假
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _matches(/**HTMLElement*/el, /**String*/selector) {
/*
el 目標節點
selector = /[uo]l/i.test(el.nodeName) ? 'li' : '>*',
selector=>*
*/
if (el) {
//split 字符串截取 //沒有.則返回爲空 可是selector 的值仍是原來的 li 可是selector 類型變成了數組
//shift 刪除數組第一個字符串並返回該字符串
//toUpperCase 把字符串變成大寫
//整個思惟是把一個字符串好比 ".aa .ccc .bbb .ddd" 而後提取到改class中的第一個變成大寫 AA
selector = selector.split('.'); // 這裏分割判斷是class仍是tag
var tag = selector.shift().toUpperCase(), // class
//join 把數組["a","b","c"]變成a|b|c
// (?=)會做爲匹配校驗，但不會出如今匹配結果字符串裏面 就是先後必需要匹配有空格 可是不會匹配上空格
//好比匹配 " aa bb cc " 匹配到 [aa,bb,cc]
/*
\\s 與 (?=\\s) 先後必需要有空格，可是不會匹配上空格
*/
re = new RegExp('\\s(' + selector.join('|') + ')(?=\\s)', 'g'); //
return (
//tag === '' el.nodeName.toUpperCase() == tag
//selector.length=2 tag === '' true
//el.nodeName.toUpperCase() == tag 若是父節點是ul ol 則這裏條件爲真
(tag === '' || el.nodeName.toUpperCase() == tag) &&
//匹配 class 的長度等於標籤的長度，。這裏意思是在el中匹配的class含有selector的class就能匹配上
(!selector.length || ((' ' + el.className + ' ').match(re) || []).length == selector.length)
);
}
return false;
}
/***********************************************************************************************
*函數名 ：_throttle
*函數功能描述 ： 回調初始化一個函數 而且調用該回調函數
*函數參數 ：
callback：
類型:function，回調函數
ms:
類型：number, 毫秒
*函數返回值 ：
類型：function，函數，能夠用來聲明一個函數做用
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _throttle(callback, ms) {
var args,
_this;
return function (/*有多是n個參數*/) {
if (args === void 0) {
args = arguments; //arguments 就是callback中的callback 因此參數決定來源於它
_this = this;
//執行回調函數
setTimeout(function () {
if (args.length === 1) { //當callback 函數一個參數的時候
callback.call(_this, args[0]);
} else {
callback.apply(_this, args);//當callback 函數多個參數的時候
}
args = void 0;
}, ms);
}
};
}
/***********************************************************************************************
*函數名 ：_extend
*函數功能描述 ：類合併
*函數參數 ：
dst：類型：obj，子類
src：類型：obj，父類
*函數返回值 ： dst 子類
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
function _extend(dst, src) {
if (dst && src) {
for (var key in src) { //遍歷對象
if (src.hasOwnProperty(key)) { //過濾原型
dst[key] = src[key];
}
}
}
return dst;
}
//聲明一個類utils
// Export utils
Sortable.utils = {
on: _on,
off: _off,
css: _css,
find: _find,
is: function (el, selector) {
return !!_closest(el, selector, el);
},
extend: _extend,
throttle: _throttle,
closest: _closest,
toggleClass: _toggleClass,
index: _index
};
/**
* Create sortable instance
* @param {HTMLElement} el
* @param {Object} [options]
*/
/***********************************************************************************************
*函數名 ：Sortable.create
*函數功能描述 ：在類Sortable中添加多個一個方法，而調用Sortable構造函數實例化給Sortable.create 屬性,建立了拖拽功能
*函數參數 ：
el：類型：obj，拖拽列表的dom節點
options：類型：obj，拖拽的參數
*函數返回值 ： dst 子類
*做者 ：
*函數建立日期 ：
*函數修改日期 ：
*修改人 ：
*修改緣由 ：
*版本 ：
*歷史版本 ：
***********************************************************************************************/
Sortable.create = function (el, options) {
return new Sortable(el, options);
};
// Export
Sortable.version = '1.4.2'; //版本
return Sortable;
});css3
- 1. sortable.js 華麗麗的排序
- 2. 拖放排序插件Sortable.js
- 3. jQuery-ui 中 拖放排序插件Sortable.js
- 4. sortable.js——Vue 數據更新問題
- 5. ElementUI le-table + sortable.js實現表格行拖拽功能
- 6. vuejs2.0使用Sortable.js實現的拖拽功能
- 7. vue+element-ui+sortable.js實現表格行和列的拖拽
- 8. Sortable.js拖拽排序方法，以及案例使用心得
- 9. sortable+element 實現表格行拖拽
- 10. 前端可視化搭建的拖拽平臺
- 更多相關文章...
-
每一个你不满意的现在，都有一个你没有努力的曾经。