Ver3.0 ๐จ ์๋ฐ์คํฌ๋ฆฝํธ๋ก ๋ง๋๋ ๋๋๊ทธ ์ค ๋๋กญ ์ธํฐํ์ด์ค ์๋ฒฝ ๊ฐ์ด๋

๐จ ์๋ฐ์คํฌ๋ฆฝํธ๋ก ๋ง๋๋ ๋๋๊ทธ ์ค ๋๋กญ ์ธํฐํ์ด์ค ์๋ฒฝ ๊ฐ์ด๋
๋ง์ฐ์ค๋ก ์ฑ์น์ฑ์น! ์ง๊ด์ ์ธ UI์ ์ ์์ ํํค์ณ๋ณด์ โจ
๐ฌ ์์ฆ ์น์ฌ์ดํธ ์ฐ๋ค๋ณด๋ฉด ๋๋๊ทธ ์ค ๋๋กญ ๊ธฐ๋ฅ ์ง์ง ๋ง์ด ๋ณด์ด์ง ์์? ํ์ผ ์
๋ก๋ํ ๋, ํ ์ผ ๋ชฉ๋ก ์์ ๋ฐ๊ฟ ๋, ์นธ๋ฐ ๋ณด๋์์ ์นด๋ ์ฎ๊ธธ ๋... ์ด๋ฐ ๊ธฐ๋ฅ๋ค์ด ์ฌ์ฉ์ ๊ฒฝํ์ ์์ฒญ ํธํ๊ฒ ๋ง๋ค์ด์ฃผ๊ฑฐ๋ ใ
ใ
๊ทผ๋ฐ ๋ง์ ๊ฐ๋ฐํ๋ ค๊ณ ํ๋ฉด "์ด๋์๋ถํฐ ์์ํด์ผ ํ์ง?" ์ถ์ ๊ฒ ๋๋๊ทธ ์ค ๋๋กญ์ด์ผ. ์ค๋์ ์๋ฐ์คํฌ๋ฆฝํธ๋ก ์ด ๊ธฐ๋ฅ์ ์ฒ์๋ถํฐ ๋๊น์ง ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์๋ ค์ค๊ฒ! ๐
๐ฏ ๋๋๊ทธ ์ค ๋๋กญ, ์ ์ค์ํ๊ฐ?
๋๋๊ทธ ์ค ๋๋กญ(Drag and Drop)์ ์ฌ์ฉ์๊ฐ ๋ง์ฐ์ค๋ ํฐ์น๋ก ์์๋ฅผ ์ก์์ ๋ค๋ฅธ ์์น๋ก ์ฎ๊ธฐ๋ ์ธํฐ๋์ ์ด์ผ. ์ด๊ฒ ์ ์ค์ํ๋๋ฉด:
๐จ ์ง๊ด์ฑ UPํด๋ฆญ ๋ช ๋ฒ ๋์ ํ ๋ฒ์ ๋๋๊ทธ๋ก ๋! ์ฌ์ฉ์๊ฐ ์๊ฐํ๋ ๋๋ก ์๋ํ๋๊น ํ์ต ๊ณก์ ์ด ๊ฑฐ์ ์์ด.
โก ํจ์จ์ฑ ์ฆ๊ฐ๋ณต์กํ ๋ฉ๋ด ํ์ ์์ด ๋ฐ๋ก๋ฐ๋ก ์์ ๊ฐ๋ฅ. ํนํ ๋๋์ ์์ดํ ์ ๋ค๋ฃฐ ๋ ์๊ฐ ์ ์ฝ์ด ์์ฒญ๋.
๐ผ ์ ๋ฌธ์ฑ ํํ์ธ๋ จ๋ ๋๋๊ทธ ์ค ๋๋กญ ๊ธฐ๋ฅ์ ์๋น์ค์ ์์ฑ๋๋ฅผ ๋์ฌ์ค. ์ฌ์ฉ์๋ค์ด "์ค, ์ด ์ฌ์ดํธ ์ ๋๋ก๋ค?"๋ผ๊ณ ๋๋ผ๊ฒ ๋ง๋ค์ง ใ ใ
๐ง HTML5 Drag and Drop API ๊ธฐ๋ณธ ๊ฐ๋
์๋ฐ์คํฌ๋ฆฝํธ๋ก ๋๋๊ทธ ์ค ๋๋กญ์ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ํฌ๊ฒ ๋ ๊ฐ์ง์ผ:
๋ฐฉ๋ฒ 1HTML5 Drag and Drop API ์ฌ์ฉ
๋ธ๋ผ์ฐ์ ๊ฐ ๊ธฐ๋ณธ ์ ๊ณตํ๋ API๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ. ๋ค์ดํฐ๋ธ ๊ธฐ๋ฅ์ด๋ผ ์ฑ๋ฅ์ด ์ข๊ณ ์ ๊ทผ์ฑ๋ ์ฑ๊ธธ ์ ์์ด. ๋ค๋ง ์ปค์คํฐ๋ง์ด์ง์ ์ ์ฝ์ด ์ข ์์ง.
๋ฐฉ๋ฒ 2๋ง์ฐ์ค ์ด๋ฒคํธ๋ก ์ง์ ๊ตฌํ
mousedown, mousemove, mouseup ์ด๋ฒคํธ๋ฅผ ์กฐํฉํด์ ์ฒ์๋ถํฐ ๋ง๋๋ ๋ฐฉ๋ฒ. ์์ ๋๊ฐ ๋์ง๋ง ์ฝ๋๋์ด ๋ง์์ง๊ณ ํฐ์น ๋๋ฐ์ด์ค ๋์๋ ๋ฐ๋ก ํด์ค์ผ ํด.
์ค๋์ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ ๋ค ์๋ ค์ค ๊ฑด๋ฐ, ๋จผ์ HTML5 API๋ถํฐ ์์ํด๋ณผ๊ฒ! ๐ฌ
๐ ๋๋๊ทธ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค๊ธฐ - draggable ์์ฑ
HTML ์์๋ฅผ ๋๋๊ทธ ๊ฐ๋ฅํ๊ฒ ๋ง๋ค๋ ค๋ฉด draggable="true" ์์ฑ๋ง ์ถ๊ฐํ๋ฉด ๋ผ. ์ง์ง ๊ฐ๋จํ์ง? ใ ใ
<div draggable="true" id="dragItem">
๋๋ฅผ ๋๋๊ทธํด๋ณด์ธ์! ๐ฏ
</div>
์ด๋ ๊ฒ๋ง ํด๋ ์์๋ฅผ ๋ง์ฐ์ค๋ก ์ก์์ ์์ง์ผ ์ ์์ด. ๊ทผ๋ฐ ์ด๊ฒ๋ง์ผ๋ก๋ ์๋ฌด ์ผ๋ ์ ์ผ์ด๋. ๋๋๊ทธ๋ ๋๋๋ฐ ๋๋กญํ ๊ณณ๋ ์๊ณ , ๋ฐ์ดํฐ ์ ๋ฌ๋ ์ ๋๊ฑฐ๋ . ๊ทธ๋์ ์ด๋ฒคํธ ๋ฆฌ์ค๋๋ฅผ ์ถ๊ฐํด์ผ ํด!
๐ช ๋๋๊ทธ ์ด๋ฒคํธ์ ์ข ๋ฅ
๋๋๊ทธ ์ค ๋๋กญ ๊ณผ์ ์์ ๋ฐ์ํ๋ ์ด๋ฒคํธ๋ ์ด 7๊ฐ์ง์ผ. ๊ฐ๊ฐ ์ธ์ ๋ฐ์ํ๋์ง ์ ํํ ์์์ผ ์ ๋๋ก ํ์ฉํ ์ ์์ด:
๐ ๋๋๊ทธ๋๋ ์์์์ ๋ฐ์ํ๋ ์ด๋ฒคํธ
1. dragstart - ๋๋๊ทธ๋ฅผ ์์ํ ๋ ๋ฑ ํ ๋ฒ ๋ฐ์. ์ฌ๊ธฐ์ ์ ๋ฌํ ๋ฐ์ดํฐ๋ฅผ ์ค์ ํด์ค.
2. drag - ๋๋๊ทธํ๋ ๋์ ๊ณ์ ๋ฐ์. ๋ง์ฐ์ค ์์ง์ผ ๋๋ง๋ค ๋ฐ์ํ๋๊น ์ฑ๋ฅ ์ฃผ์!
3. dragend - ๋๋๊ทธ๊ฐ ๋๋ ๋ ๋ฐ์. ์ฑ๊ณตํ๋ ์คํจํ๋ ๋ฌด์กฐ๊ฑด ๋ฐ์ํด.
๐ ๋๋กญ ์์ญ(ํ๊ฒ)์์ ๋ฐ์ํ๋ ์ด๋ฒคํธ
4. dragenter - ๋๋๊ทธํ ์์๊ฐ ๋๋กญ ์์ญ์ ์ฒ์ ์ง์
ํ ๋ ๋ฐ์.
5. dragover - ๋๋กญ ์์ญ ์์ ์๋ ๋์ ๊ณ์ ๋ฐ์. ๊ธฐ๋ณธ ๋์์ ๋ง์์ค์ผ ๋๋กญ์ด ๊ฐ๋ฅํด!
6. dragleave - ๋๋กญ ์์ญ์ ๋ฒ์ด๋ ๋ ๋ฐ์.
7. drop - ๋๋กญ ์์ญ์์ ๋ง์ฐ์ค๋ฅผ ๋์ ๋ ๋ฐ์. ์ฌ๊ธฐ์ ์ค์ ์์
์ ์ฒ๋ฆฌํด.
๐ป ๊ธฐ๋ณธ ๋๋๊ทธ ์ค ๋๋กญ ๊ตฌํํ๊ธฐ
์ด์ ์ค์ ์ด์ผ! ๊ฐ๋จํ ํ ์ผ ๋ชฉ๋ก์ ๋๋๊ทธํด์ ์์๋ฅผ ๋ฐ๊พธ๋ ์์ ๋ฅผ ๋ง๋ค์ด๋ณผ๊ฒ. ์ฝ๋ ํ๋ํ๋ ๋ฏ์ด๋ณด๋ฉด์ ์ดํดํด๋ณด์ ใ ใ
<!-- HTML ๊ตฌ์กฐ -->
<div class="todo-container">
<div class="todo-item" draggable="true">
<span>๐โโ๏ธ ์ด๋ํ๊ธฐ</span>
</div>
<div class="todo-item" draggable="true">
<span>๐ ์ฑ
์ฝ๊ธฐ</span>
</div>
<div class="todo-item" draggable="true">
<span>๐ป ์ฝ๋ฉ ๊ณต๋ถ</span>
</div>
</div>
HTML์ ์ง์ง ์ฌํํ์ง? ๊ฐ ํ ์ผ ์์ดํ ์ draggable="true"๋ง ๋ถ์ฌ์คฌ์ด. ์ด์ ์๋ฐ์คํฌ๋ฆฝํธ๋ก ๋์์ ๊ตฌํํด๋ณด์!
// ๋๋๊ทธ ์์ํ ๋
const items = document.querySelectorAll('.todo-item');
let draggedItem = null;
items.forEach(item => {
// ๋๋๊ทธ ์์
item.addEventListener('dragstart', function(e) {
draggedItem = this;
this.style.opacity = '0.5';
// ๋ฐ์ดํฐ ์ ๋ฌ (์ ํ์ฌํญ)
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/html', this.innerHTML);
});
// ๋๋๊ทธ ๋
item.addEventListener('dragend', function(e) {
this.style.opacity = '1';
});
// ๋๋๊ทธ ์ค๋ฒ (์ค์! ๊ธฐ๋ณธ ๋์ ๋ง์์ผ ํจ)
item.addEventListener('dragover', function(e) {
e.preventDefault(); // ์ด๊ฑฐ ์ ํ๋ฉด drop ์ด๋ฒคํธ ์ ๋ฐ์ํด!
if (this === draggedItem) return;
// ๋๋๊ทธํ ์์ดํ
์ ํ์ฌ ์์น์ ์ฝ์
const container = this.parentNode;
const afterElement = getDragAfterElement(container, e.clientY);
if (afterElement == null) {
container.appendChild(draggedItem);
} else {
container.insertBefore(draggedItem, afterElement);
}
});
});
// ๋ง์ฐ์ค ์์น ๊ธฐ์ค์ผ๋ก ์ด๋ ์์ ๋ค์์ ๋ฃ์์ง ๊ณ์ฐ
function getDragAfterElement(container, y) {
const draggableElements = [...container.querySelectorAll('.todo-item:not(.dragging)')];
return draggableElements.reduce((closest, child) => {
const box = child.getBoundingClientRect();
const offset = y - box.top - box.height / 2;
if (offset < 0 && offset > closest.offset) {
return { offset: offset, element: child };
} else {
return closest;
}
}, { offset: Number.NEGATIVE_INFINITY }).element;
}
์ฝ๋๊ฐ ์ข ๊ธธ์ด ๋ณด์ด์ง๋ง ํ๋์ฉ ๋ฏ์ด๋ณด๋ฉด ๋ณ๊ฑฐ ์์ด ใ ใ
๐ ์ฝ๋ ์์ธ ๋ถ์
1๏ธโฃ dragstart ์ด๋ฒคํธ
๋๋๊ทธ๋ฅผ ์์ํ ๋ ๋ฐ์ํด. ์ฌ๊ธฐ์ ์ค์ํ ๊ฑด:
โข draggedItem ๋ณ์์ ํ์ฌ ๋๋๊ทธ ์ค์ธ ์์ ์ ์ฅ - ๋์ค์ ์ด๋ค ์์๋ฅผ ์์ง์ผ์ง ์์์ผ ํ๋๊น!
โข opacity๋ฅผ 0.5๋ก ์ค์ - ์๊ฐ์ ํผ๋๋ฐฑ. ์ฌ์ฉ์๊ฐ "์, ๋ด๊ฐ ์ด๊ฑฐ ๋๋๊ทธํ๊ณ ์๊ตฌ๋" ์ ์ ์๊ฒ.
โข dataTransfer ๊ฐ์ฒด ์ค์ - ๋๋๊ทธํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ์ปจํ
์ด๋์ผ. effectAllowed๋ ๋๋๊ทธ ํจ๊ณผ ํ์
(move, copy, link ๋ฑ), setData๋ ์ค์ ๋ฐ์ดํฐ ์ ์ฅ.
2๏ธโฃ dragend ์ด๋ฒคํธ
๋๋๊ทธ๊ฐ ๋๋๋ฉด opacity๋ฅผ ๋ค์ 1๋ก ๋ณต์. ๊ฐ๋จํ์ง?
3๏ธโฃ dragover ์ด๋ฒคํธ (ํต์ฌ!)
์ฌ๊ธฐ๊ฐ ์ง์ง ์ค์ํด! e.preventDefault()๋ฅผ ๊ผญ ํธ์ถํด์ผ ํด. ์๋๋ฉด ๋ธ๋ผ์ฐ์ ์ ๊ธฐ๋ณธ ๋์์ด ๋๋กญ์ ๋ง๊ฑฐ๋ . ์ด๊ฑฐ ์ ํ๋ฉด drop ์ด๋ฒคํธ๊ฐ ์์ ๋ฐ์ ์ ํด ใ ใ
๊ทธ๋ฆฌ๊ณ getDragAfterElement ํจ์๋ก ๋ง์ฐ์ค ์์น๋ฅผ ๊ณ์ฐํด์ ๋๋๊ทธํ ์์๋ฅผ ์ ์ ํ ์์น์ ์ฝ์ ํด์ค. ์ด๊ฒ ์ค์๊ฐ์ผ๋ก ์์๊ฐ ๋ฐ๋๋ ํจ๊ณผ๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ฑฐ์ผ!
โ ๏ธ ์ฃผ์์ฌํญ!dragover ์ด๋ฒคํธ๋ ๋ง์ฐ์ค ์์ง์ผ ๋๋ง๋ค ๊ณ์ ๋ฐ์ํด. ๊ทธ๋์ ์ฌ๊ธฐ์ ๋ฌด๊ฑฐ์ด ์ฐ์ฐ์ ๋ฃ์ผ๋ฉด ์ฑ๋ฅ์ด ๋จ์ด์ง ์ ์์ด. ๊ผญ ํ์ํ ๋ก์ง๋ง ๋ฃ์!
๐จ DataTransfer ๊ฐ์ฒด ์๋ฒฝ ์ดํดํ๊ธฐ
๋๋๊ทธ ์ค ๋๋กญ์์ ๋ฐ์ดํฐ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ํต์ฌ์ด ๋ฐ๋ก DataTransfer ๊ฐ์ฒด์ผ. ์ด๋ฒคํธ ๊ฐ์ฒด์ dataTransfer ํ๋กํผํฐ๋ก ์ ๊ทผํ ์ ์์ด.
๐ ์ฃผ์ ํ๋กํผํฐ์ ๋ฉ์๋
โข effectAllowed - ํ์ฉ๋๋ ๋๋๊ทธ ํจ๊ณผ ์ง์ (none, copy, move, link, copyMove, copyLink, linkMove, all)
โข dropEffect - ์ค์ ์ ์ฉ๋ ๋๋๊ทธ ํจ๊ณผ (none, copy, move, link)
โข setData(format, data) - ๋๋๊ทธํ ๋ฐ์ดํฐ ์ค์
โข getData(format) - ๋๋กญํ ๋ ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
โข clearData() - ์ ์ฅ๋ ๋ฐ์ดํฐ ์ญ์
โข files - ๋๋๊ทธ๋ ํ์ผ ๋ชฉ๋ก (ํ์ผ ์
๋ก๋ ์ ์ฌ์ฉ)
โข types - ์ ์ฅ๋ ๋ฐ์ดํฐ ํ์
๋ฐฐ์ด
// ๋ฐ์ดํฐ ์ค์ ์์
element.addEventListener('dragstart', (e) => {
// ํ
์คํธ ๋ฐ์ดํฐ
e.dataTransfer.setData('text/plain', '์๋
ํ์ธ์');
// JSON ๋ฐ์ดํฐ
const data = { id: 123, name: 'ํ ์ผ' };
e.dataTransfer.setData('application/json', JSON.stringify(data));
// HTML ๋ฐ์ดํฐ
e.dataTransfer.setData('text/html', '<strong>๊ฐ์กฐ๋ ํ
์คํธ</strong>');
});
// ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ ์์
dropZone.addEventListener('drop', (e) => {
e.preventDefault();
const text = e.dataTransfer.getData('text/plain');
const jsonData = JSON.parse(e.dataTransfer.getData('application/json'));
console.log(text); // "์๋
ํ์ธ์"
console.log(jsonData.id); // 123
});
๋ฐ์ดํฐ ํ์ ์ MIME ํ์ ์ผ๋ก ์ง์ ํด. text/plain, text/html, application/json ๊ฐ์ ๊ฑฐ! ์ฌ๋ฌ ํ์ ์ ๋์์ ์ค์ ํ ์๋ ์์ด์ ์ ์ฐํ๊ฒ ํ์ฉ ๊ฐ๋ฅํด ๐
๐ ํ์ผ ๋๋๊ทธ ์ค ๋๋กญ ๊ตฌํํ๊ธฐ
ํ์ผ ์ ๋ก๋ UI์์ ๋๋๊ทธ ์ค ๋๋กญ์ ๊ฑฐ์ ํ์๊ฐ ๋์ง? ์ฌ์ฉ์๊ฐ ํ์ผ์ ์ง์ ๋๋๊ทธํด์ ์ฌ๋ฆด ์ ์๊ฒ ๋ง๋ค์ด๋ณด์!
<!-- HTML -->
<div id="dropZone" class="drop-zone">
<p>๐ ์ฌ๊ธฐ์ ํ์ผ์ ๋๋๊ทธํ์ธ์</p>
<p class="hint">๋๋ ํด๋ฆญํด์ ํ์ผ ์ ํ</p>
<input type="file" id="fileInput" multiple hidden>
</div>
<div id="fileList"></div>
// JavaScript
const dropZone = document.getElementById('dropZone');
const fileInput = document.getElementById('fileInput');
const fileList = document.getElementById('fileList');
// ๋๋กญ์กด ํด๋ฆญ ์ ํ์ผ ์ ํ ์ฐฝ ์ด๊ธฐ
dropZone.addEventListener('click', () => {
fileInput.click();
});
// ํ์ผ ์ ํ ์ ์ฒ๋ฆฌ
fileInput.addEventListener('change', (e) => {
handleFiles(e.target.files);
});
// ๋๋๊ทธ ์ค๋ฒ ์ ์คํ์ผ ๋ณ๊ฒฝ
dropZone.addEventListener('dragover', (e) => {
e.preventDefault();
dropZone.classList.add('drag-over');
});
dropZone.addEventListener('dragleave', () => {
dropZone.classList.remove('drag-over');
});
// ๋๋กญ ์ฒ๋ฆฌ
dropZone.addEventListener('drop', (e) => {
e.preventDefault();
dropZone.classList.remove('drag-over');
const files = e.dataTransfer.files;
handleFiles(files);
});
// ํ์ผ ์ฒ๋ฆฌ ํจ์
function handleFiles(files) {
fileList.innerHTML = '';
Array.from(files).forEach(file => {
const fileItem = document.createElement('div');
fileItem.className = 'file-item';
// ํ์ผ ์ ๋ณด ํ์
fileItem.innerHTML = `
<span class="file-icon">๐</span>
<span class="file-name">${file.name}</span>
<span class="file-size">${formatFileSize(file.size)}</span>
`;
fileList.appendChild(fileItem);
// ์ค์ ๋ก๋ ์ฌ๊ธฐ์ ์๋ฒ์ ์
๋ก๋ํ๊ฑฐ๋ ์ฒ๋ฆฌ
uploadFile(file);
});
}
// ํ์ผ ํฌ๊ธฐ ํฌ๋งทํ
function formatFileSize(bytes) {
if (bytes === 0) return '0 Bytes';
const k = 1024;
const sizes = ['Bytes', 'KB', 'MB', 'GB'];
const i = Math.floor(Math.log(bytes) / Math.log(k));
return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i];
}
// ํ์ผ ์
๋ก๋ (์์)
function uploadFile(file) {
const formData = new FormData();
formData.append('file', file);
fetch('/upload', {
method: 'POST',
body: formData
})
.then(response => response.json())
.then(data => {
console.log('์
๋ก๋ ์ฑ๊ณต:', data);
})
.catch(error => {
console.error('์
๋ก๋ ์คํจ:', error);
});
}
ํ์ผ ๋๋๊ทธ ์ค ๋๋กญ์ ํต์ฌ์ e.dataTransfer.files์ผ. ์ฌ๊ธฐ์ ๋๋๊ทธ๋ ํ์ผ๋ค์ด FileList ๊ฐ์ฒด๋ก ๋ด๊ฒจ์์ด. ์ด๊ฑธ Array.from()์ผ๋ก ๋ฐฐ์ด๋ก ๋ณํํด์ ์ฒ๋ฆฌํ๋ฉด ๋ผ!
โ ๏ธ ๋ณด์ ์ฃผ์์ฌํญ
โข ํ์ผ ํ์
๊ฒ์ฆ์ ํด๋ผ์ด์ธํธ์ ์๋ฒ ์์ชฝ์์ ๋ค ํด์ผ ํด!
โข ํ์ผ ํฌ๊ธฐ ์ ํ๋ ์ค์ ํด์ค์ผ ์๋ฒ ๊ณผ๋ถํ๋ฅผ ๋ง์ ์ ์์ด.
โข ์
์ฑ ํ์ผ ์
๋ก๋๋ฅผ ๋ง๊ธฐ ์ํด ํ์ฅ์ ํ์ดํธ๋ฆฌ์คํธ ๋ฐฉ์ ์ฌ์ฉ ์ถ์ฒ!
๐ญ ๋๋๊ทธ ์ค ์๊ฐ์ ํผ๋๋ฐฑ ๊ฐ์ ํ๊ธฐ
์ฌ์ฉ์ ๊ฒฝํ์ ๋์ด๋ ค๋ฉด ์๊ฐ์ ํผ๋๋ฐฑ์ด ์ค์ํด! ๋๋๊ทธํ๋ ๋์ ๋ญ๊ฐ ์ผ์ด๋๊ณ ์๋ค๋ ๊ฑธ ๋ช ํํ๊ฒ ๋ณด์ฌ์ค์ผ ํด.
๐ก ๋๋๊ทธ ์ด๋ฏธ์ง ์ปค์คํฐ๋ง์ด์ง
๊ธฐ๋ณธ์ ์ผ๋ก ๋๋๊ทธํ๋ฉด ์์์ ๋ฐํฌ๋ช ๋ณต์ฌ๋ณธ์ด ๋ฐ๋ผ๋ค๋๋๋ฐ, ์ด๊ฑธ ์ํ๋ ์ด๋ฏธ์ง๋ก ๋ฐ๊ฟ ์ ์์ด!
element.addEventListener('dragstart', (e) => {
// ์ปค์คํ
๋๋๊ทธ ์ด๋ฏธ์ง ์์ฑ
const dragImage = document.createElement('div');
dragImage.className = 'custom-drag-image';
dragImage.textContent = '๐ฏ ๋๋๊ทธ ์ค...';
dragImage.style.position = 'absolute';
dragImage.style.top = '-1000px';
document.body.appendChild(dragImage);
// ๋๋๊ทธ ์ด๋ฏธ์ง ์ค์ (์์, x์คํ์
, y์คํ์
)
e.dataTransfer.setDragImage(dragImage, 50, 25);
// ๋๋๊ทธ ๋๋๋ฉด ์ ๊ฑฐ
setTimeout(() => {
document.body.removeChild(dragImage);
}, 0);
});
๐จ ๋๋กญ ์์ญ ํ์ด๋ผ์ดํธ
๋๋๊ทธํ ์์๊ฐ ๋๋กญ ๊ฐ๋ฅํ ์์ญ ์์ ์์ ๋ ์๊ฐ์ ์ผ๋ก ํ์ํด์ฃผ๋ฉด ์ข์!
// CSS
.drop-zone {
border: 2px dashed #ccc;
transition: all 0.3s ease;
}
.drop-zone.drag-over {
border-color: #4CAF50;
background-color: #f0f8f0;
transform: scale(1.02);
}
.drop-zone.invalid {
border-color: #f44336;
background-color: #fff0f0;
}
// JavaScript
dropZone.addEventListener('dragenter', (e) => {
e.preventDefault();
// ํ์ผ ํ์
๊ฒ์ฆ
const items = e.dataTransfer.items;
let isValid = true;
for (let item of items) {
if (item.kind === 'file') {
const file = item.getAsFile();
if (!isValidFileType(file)) {
isValid = false;
break;
}
}
}
if (isValid) {
dropZone.classList.add('drag-over');
} else {
dropZone.classList.add('invalid');
}
});
function isValidFileType(file) {
const allowedTypes = ['image/jpeg', 'image/png', 'image/gif'];
return allowedTypes.includes(file.type);
}
๐ ๋ง์ฐ์ค ์ด๋ฒคํธ๋ก ์ง์ ๊ตฌํํ๊ธฐ
HTML5 API๊ฐ ํธํ๊ธด ํ๋ฐ, ๋ ์ธ๋ฐํ ์ปจํธ๋กค์ด ํ์ํ๊ฑฐ๋ ๋ชจ๋ฐ์ผ ํฐ์น๊น์ง ์ง์ํ๋ ค๋ฉด ์ง์ ๊ตฌํํ๋ ๊ฒ ๋์ ๋๊ฐ ์์ด. ๋ง์ฐ์ค ์ด๋ฒคํธ๋ก ์ฒ์๋ถํฐ ๋ง๋ค์ด๋ณด์!
class DraggableElement {
constructor(element) {
this.element = element;
this.isDragging = false;
this.currentX = 0;
this.currentY = 0;
this.initialX = 0;
this.initialY = 0;
this.xOffset = 0;
this.yOffset = 0;
this.init();
}
init() {
// ๋ง์ฐ์ค ์ด๋ฒคํธ
this.element.addEventListener('mousedown', this.dragStart.bind(this));
document.addEventListener('mousemove', this.drag.bind(this));
document.addEventListener('mouseup', this.dragEnd.bind(this));
// ํฐ์น ์ด๋ฒคํธ (๋ชจ๋ฐ์ผ ์ง์)
this.element.addEventListener('touchstart', this.dragStart.bind(this));
document.addEventListener('touchmove', this.drag.bind(this));
document.addEventListener('touchend', this.dragEnd.bind(this));
}
dragStart(e) {
// ํฐ์น ์ด๋ฒคํธ์ ๋ง์ฐ์ค ์ด๋ฒคํธ ํตํฉ ์ฒ๋ฆฌ
if (e.type === 'touchstart') {
this.initialX = e.touches[0].clientX - this.xOffset;
this.initialY = e.touches[0].clientY - this.yOffset;
} else {
this.initialX = e.clientX - this.xOffset;
this.initialY = e.clientY - this.yOffset;
}
// ํด๋ฆญํ ์์๊ฐ ๋๋๊ทธ ๋์์ธ์ง ํ์ธ
if (e.target === this.element) {
this.isDragging = true;
this.element.style.cursor = 'grabbing';
}
}
drag(e) {
if (this.isDragging) {
e.preventDefault();
if (e.type === 'touchmove') {
this.currentX = e.touches[0].clientX - this.initialX;
this.currentY = e.touches[0].clientY - this.initialY;
} else {
this.currentX = e.clientX - this.initialX;
this.currentY = e.clientY - this.initialY;
}
this.xOffset = this.currentX;
this.yOffset = this.currentY;
this.setTranslate(this.currentX, this.currentY, this.element);
}
}
dragEnd(e) {
this.initialX = this.currentX;
this.initialY = this.currentY;
this.isDragging = false;
this.element.style.cursor = 'grab';
}
setTranslate(xPos, yPos, el) {
el.style.transform = `translate3d(${xPos}px, ${yPos}px, 0)`;
}
}
// ์ฌ์ฉ๋ฒ
const draggableElements = document.querySelectorAll('.draggable');
draggableElements.forEach(el => {
new DraggableElement(el);
});
์ด ๋ฐฉ์์ ์ฅ์ ์:
โ
ํฐ์น ์ด๋ฒคํธ๊น์ง ํ ๋ฒ์ ์ฒ๋ฆฌ ๊ฐ๋ฅ
โ
transform์ ์ฌ์ฉํด์ ๋ถ๋๋ฌ์ด ์ ๋๋ฉ์ด์
โ
๋๋๊ทธ ๋์์ ์์ ํ ์ปค์คํฐ๋ง์ด์ง ๊ฐ๋ฅ
โ
๋ธ๋ผ์ฐ์ ํธํ์ฑ ๋ฌธ์ ์ต์ํ
๐ฑ ๋ชจ๋ฐ์ผ ํฐ์น ์ต์ ํ
๋ชจ๋ฐ์ผ์์ ๋๋๊ทธ ์ค ๋๋กญ์ ๊ตฌํํ ๋๋ ๋ช ๊ฐ์ง ์ถ๊ฐ ๊ณ ๋ ค์ฌํญ์ด ์์ด!
๐ง ํฐ์น ์ด๋ฒคํธ ์ฒ๋ฆฌ ํ
1. ์คํฌ๋กค๊ณผ์ ์ถฉ๋ ๋ฐฉ์ง
๋๋๊ทธ ์ค์๋ ํ์ด์ง ์คํฌ๋กค์ ๋ง์์ผ ํด. preventDefault()๋ฅผ ์ ์ ํ ์ฌ์ฉํ๋, ์ธ๋ก ์คํฌ๋กค์ ํ์ฉํ๊ณ ๊ฐ๋ก ๋๋๊ทธ๋ง ์ฒ๋ฆฌํ๋ ์์ผ๋ก ์กฐ๊ฑด๋ถ ์ฒ๋ฆฌ๊ฐ ํ์ํ ์ ์์ด.
let startX, startY;
element.addEventListener('touchstart', (e) => {
startX = e.touches[0].clientX;
startY = e.touches[0].clientY;
});
element.addEventListener('touchmove', (e) => {
const deltaX = Math.abs(e.touches[0].clientX - startX);
const deltaY = Math.abs(e.touches[0].clientY - startY);
// ๊ฐ๋ก ์ด๋์ด ์ธ๋ก ์ด๋๋ณด๋ค ํฌ๋ฉด ๋๋๊ทธ๋ก ํ๋จ
if (deltaX > deltaY) {
e.preventDefault(); // ์คํฌ๋กค ๋ฐฉ์ง
// ๋๋๊ทธ ์ฒ๋ฆฌ
}
});
2. ํฐ์น ์์ญ ํฌ๊ธฐ
๋ชจ๋ฐ์ผ์์๋ ํฐ์น ํ๊ฒ์ด ์ต์ 44x44px์ ๋์ด์ผ ํธํ๊ฒ ์กฐ์ํ ์ ์์ด. ๋๋๊ทธ ํธ๋ค์ ๋ง๋ค ๋ ์ด ํฌ๊ธฐ๋ฅผ ์ง์ผ์ฃผ์!
3. ์๊ฐ์ ํผ๋๋ฐฑ ๊ฐํ
๋ง์ฐ์ค hover๊ฐ ์์ผ๋ ํฐ์น ์์ํ ๋ ๋ช
ํํ ํผ๋๋ฐฑ์ ์ค์ผ ํด. ์์ ๋ณํ, ํฌ๊ธฐ ๋ณํ, ๊ทธ๋ฆผ์ ํจ๊ณผ ๋ฑ์ ํ์ฉํ๋ฉด ์ข์.
๐ฏ ์ค์ ์์ : ์นธ๋ฐ ๋ณด๋ ๋ง๋ค๊ธฐ
์ด์ ๋ฐฐ์ด ๊ฑธ ๋ค ํ์ฉํด์ ์ค์ ํ๋ก์ ํธ๋ฅผ ๋ง๋ค์ด๋ณด์! Trello ๊ฐ์ ์นธ๋ฐ ๋ณด๋๋ฅผ ๊ตฌํํด๋ณผ๊ฒ ๐จ
<!-- HTML ๊ตฌ์กฐ -->
<div class="kanban-board">
<div class="kanban-column" data-status="todo">
<h3>๐ ํ ์ผ</h3>
<div class="card-container">
<div class="kanban-card" draggable="true" data-id="1">
<h4>๋ก๊ทธ์ธ ๊ธฐ๋ฅ ๊ตฌํ</h4>
<p>JWT ์ธ์ฆ ๋ฐฉ์์ผ๋ก ๊ตฌํ</p>
</div>
<div class="kanban-card" draggable="true" data-id="2">
<h4>UI ๋์์ธ ๊ฐ์ </h4>
<p>๋ฉ์ธ ํ์ด์ง ๋ฆฌ๋ด์ผ</p>
</div>
</div>
</div>
<div class="kanban-column" data-status="doing">
<h3>๐ ์งํ ์ค</h3>
<div class="card-container">
<div class="kanban-card" draggable="true" data-id="3">
<h4>API ๋ฌธ์ ์์ฑ</h4>
<p>Swagger๋ก ๋ฌธ์ํ</p>
</div>
</div>
</div>
<div class="kanban-column" data-status="done">
<h3>โ
์๋ฃ</h3>
<div class="card-container"></div>
</div>
</div>
// JavaScript - ์นธ๋ฐ ๋ณด๋ ๋ก์ง
class KanbanBoard {
constructor() {
this.cards = document.querySelectorAll('.kanban-card');
this.containers = document.querySelectorAll('.card-container');
this.draggedCard = null;
this.init();
}
init() {
// ์นด๋ ๋๋๊ทธ ์ด๋ฒคํธ
this.cards.forEach(card => {
card.addEventListener('dragstart', this.handleDragStart.bind(this));
card.addEventListener('dragend', this.handleDragEnd.bind(this));
});
// ์ปจํ
์ด๋ ๋๋กญ ์ด๋ฒคํธ
this.containers.forEach(container => {
container.addEventListener('dragover', this.handleDragOver.bind(this));
container.addEventListener('drop', this.handleDrop.bind(this));
container.addEventListener('dragenter', this.handleDragEnter.bind(this));
container.addEventListener('dragleave', this.handleDragLeave.bind(this));
});
}
handleDragStart(e) {
this.draggedCard = e.target;
e.target.classList.add('dragging');
e.dataTransfer.effectAllowed = 'move';
e.dataTransfer.setData('text/html', e.target.innerHTML);
}
handleDragEnd(e) {
e.target.classList.remove('dragging');
// ๋ชจ๋ ์ปจํ
์ด๋์์ ํ์ด๋ผ์ดํธ ์ ๊ฑฐ
this.containers.forEach(container => {
container.classList.remove('drag-over');
});
}
handleDragOver(e) {
e.preventDefault();
e.dataTransfer.dropEffect = 'move';
const afterElement = this.getDragAfterElement(e.currentTarget, e.clientY);
if (afterElement == null) {
e.currentTarget.appendChild(this.draggedCard);
} else {
e.currentTarget.insertBefore(this.draggedCard, afterElement);
}
}
handleDrop(e) {
e.preventDefault();
e.stopPropagation();
const column = e.currentTarget.closest('.kanban-column');
const newStatus = column.dataset.status;
const cardId = this.draggedCard.dataset.id;
// ์๋ฒ์ ์ํ ๋ณ๊ฒฝ ์์ฒญ
this.updateCardStatus(cardId, newStatus);
// ์ ๋๋ฉ์ด์
ํจ๊ณผ
this.draggedCard.style.animation = 'cardDrop 0.3s ease';
setTimeout(() => {
this.draggedCard.style.animation = '';
}, 300);
}
handleDragEnter(e) {
e.preventDefault();
e.currentTarget.classList.add('drag-over');
}
handleDragLeave(e) {
if (e.currentTarget.contains(e.relatedTarget)) return;
e.currentTarget.classList.remove('drag-over');
}
getDragAfterElement(container, y) {
const draggableElements = [
...container.querySelectorAll('.kanban-card:not(.dragging)')
];
return draggableElements.reduce((closest, child) => {
const box = child.getBoundingClientRect();
const offset = y - box.top - box.height / 2;
if (offset < 0 && offset > closest.offset) {
return { offset: offset, element: child };
} else {
return closest;
}
}, { offset: Number.NEGATIVE_INFINITY }).element;
}
updateCardStatus(cardId, newStatus) {
// ์ค์ ๋ก๋ ์๋ฒ API ํธ์ถ
fetch(`/api/cards/${cardId}`, {
method: 'PATCH',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ status: newStatus })
})
.then(response => response.json())
.then(data => {
console.log('์นด๋ ์ํ ์
๋ฐ์ดํธ ์ฑ๊ณต:', data);
})
.catch(error => {
console.error('์
๋ฐ์ดํธ ์คํจ:', error);
// ์คํจ ์ ์๋ ์์น๋ก ๋ณต์ํ๋ ๋ก์ง ์ถ๊ฐ
});
}
}
// ์ด๊ธฐํ
document.addEventListener('DOMContentLoaded', () => {
new KanbanBoard();
});
// CSS ์ ๋๋ฉ์ด์
@keyframes cardDrop {
0% {
transform: scale(1.05);
box-shadow: 0 8px 16px rgba(0,0,0,0.2);
}
100% {
transform: scale(1);
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
}
์นธ๋ฐ ๋ณด๋์ ํต์ฌ์ getDragAfterElement ํจ์์ผ. ๋ง์ฐ์ค Y ์ขํ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ด๋ ์นด๋ ๋ค์์ ์ฝ์ ํ ์ง ๊ณ์ฐํด์ฃผ๋ ๊ฑฐ์ง. ์ด๊ฒ ์์ด์ผ ์นด๋๋ค ์ฌ์ด์ ์์ฐ์ค๋ฝ๊ฒ ๋ผ์๋ฃ์ ์ ์์ด!
โก ์ฑ๋ฅ ์ต์ ํ ํ
๋๋๊ทธ ์ค ๋๋กญ์ ์ด๋ฒคํธ๊ฐ ์์ฒญ ๋ง์ด ๋ฐ์ํ๋ ๊ธฐ๋ฅ์ด๋ผ ์ฑ๋ฅ ์ต์ ํ๊ฐ ์ค์ํด. ๋ช ๊ฐ์ง ํ์ ์๋ ค์ค๊ฒ!
๐ฏ ์ด๋ฒคํธ ์์ ํ์ฉ
๊ฐ ์์๋ง๋ค ์ด๋ฒคํธ ๋ฆฌ์ค๋๋ฅผ ๋ถ์ด์ง ๋ง๊ณ , ๋ถ๋ชจ ์์ ํ๋์๋ง ๋ถ์ฌ์ ์ด๋ฒคํธ ๋ฒ๋ธ๋ง์ผ๋ก ์ฒ๋ฆฌํด. ๋ฉ๋ชจ๋ฆฌ๋ ์ ์ฝ๋๊ณ ๋์ ์ผ๋ก ์ถ๊ฐ๋๋ ์์๋ ์๋์ผ๋ก ์ฒ๋ฆฌ๋ผ!
// โ ๋นํจ์จ์
items.forEach(item => {
item.addEventListener('dragstart', handler);
});
// โ
ํจ์จ์
container.addEventListener('dragstart', (e) => {
if (e.target.classList.contains('draggable')) {
handler(e);
}
});
๐ requestAnimationFrame ์ฌ์ฉ
๋๋๊ทธ ์ค ์์น ์ ๋ฐ์ดํธ๋ requestAnimationFrame์ผ๋ก ๊ฐ์ธ์ ๋ธ๋ผ์ฐ์ ๋ ๋๋ง ์ฃผ๊ธฐ์ ๋ง์ถฐ ์คํํ๋ฉด ๋ถ๋๋ฌ์์ ธ!
let rafId = null;
element.addEventListener('drag', (e) => {
if (rafId) return;
rafId = requestAnimationFrame(() => {
updatePosition(e.clientX, e.clientY);
rafId = null;
});
});
๐พ DOM ์กฐ์ ์ต์ํ
๋๋๊ทธ ์ค์๋ DOM ์ฝ๊ธฐ/์ฐ๊ธฐ๋ฅผ ์ต์ํํด์ผ ํด. ํนํ getBoundingClientRect() ๊ฐ์ ๊ฑด ์บ์ฑํด์ ์ฌ์ฌ์ฉํ์!
// ์์น ์ ๋ณด ์บ์ฑ
const positions = new Map();
function cachePositions() {
elements.forEach(el => {
positions.set(el, el.getBoundingClientRect());
});
}
// ๋๋๊ทธ ์์ ์ ํ ๋ฒ๋ง ๊ณ์ฐ
element.addEventListener('dragstart', cachePositions);
โ ๏ธ ์ฃผ์: will-change ์์ฑ ๋จ์ฉ ๊ธ์ง! transform์ด๋ opacity์ will-change๋ฅผ ์ ์ฉํ๋ฉด ์ฑ๋ฅ์ด ์ข์์ง ์ ์์ง๋ง, ๋๋ฌด ๋ง์ ์์์ ์ ์ฉํ๋ฉด ์คํ๋ ค ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น์ผ. ๋๋๊ทธ ์์ํ ๋๋ง ์ถ๊ฐํ๊ณ ๋๋๋ฉด ์ ๊ฑฐํ๋ ๊ฒ ์ข์!
๐ ๏ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ์ฉํ๊ธฐ
์ง์ ๊ตฌํํ๋ ๊ฒ ๋ถ๋ด์ค๋ฝ๋ค๋ฉด ๊ฒ์ฆ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐ๋ ๊ฒ๋ ์ข์ ์ ํ์ด์ผ. ๋ช ๊ฐ์ง ์ถ์ฒ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์๊ฐํ ๊ฒ!
1๏ธโฃ SortableJS
๊ฐ์ฅ ์ธ๊ธฐ ์๋ ๋๋๊ทธ ์ค ๋๋กญ ๋ผ์ด๋ธ๋ฌ๋ฆฌ! ์ฌ์ฉ๋ฒ๋ ๊ฐ๋จํ๊ณ ๊ธฐ๋ฅ๋ ํ๋ถํด.
// ์ค์น
npm install sortablejs
// ์ฌ์ฉ๋ฒ
import Sortable from 'sortablejs';
const el = document.getElementById('items');
const sortable = Sortable.create(el, {
animation: 150,
ghostClass: 'sortable-ghost',
onEnd: function (evt) {
console.log('์ด์ ์ธ๋ฑ์ค:', evt.oldIndex);
console.log('์ ์ธ๋ฑ์ค:', evt.newIndex);
}
});
์ฅ์ : ๊ฐ๋ณ๊ณ (6KB), ์์กด์ฑ ์์, ํฐ์น ์ง์, ๋ค์ํ ์ต์ โจ
2๏ธโฃ React DnD
React ํ๋ก์ ํธ๋ผ๋ฉด ์ด๊ฒ ์ต๊ณ ! ์ปดํฌ๋ํธ ๊ธฐ๋ฐ์ผ๋ก ๊น๋ํ๊ฒ ๊ตฌํํ ์ ์์ด.
import { useDrag, useDrop } from 'react-dnd';
function DraggableCard({ id, text }) {
const [{ isDragging }, drag] = useDrag({
type: 'CARD',
item: { id },
collect: (monitor) => ({
isDragging: monitor.isDragging()
})
});
return (
<div ref={drag} style={{ opacity: isDragging ? 0.5 : 1 }}>
{text}
</div>
);
}
3๏ธโฃ interact.js
๋๋๊ทธ๋ฟ๋ง ์๋๋ผ ๋ฆฌ์ฌ์ด์ฆ, ์ ์ค์ฒ๊น์ง ์ง์ํ๋ ๊ฐ๋ ฅํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ!
import interact from 'interactjs';
interact('.draggable')
.draggable({
inertia: true,
modifiers: [
interact.modifiers.restrictRect({
restriction: 'parent',
endOnly: true
})
],
autoScroll: true,
listeners: {
move: dragMoveListener
}
});
๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ํํ ๋๋ ํ๋ก์ ํธ ๊ท๋ชจ, ํ์ํ ๊ธฐ๋ฅ, ๋ฒ๋ค ํฌ๊ธฐ๋ฅผ ๊ณ ๋ คํด์ผ ํด. ๊ฐ๋จํ ๊ธฐ๋ฅ์ด๋ฉด ์ง์ ๊ตฌํํ๋ ๊ฒ ๋์ ์๋ ์๊ณ , ๋ณต์กํ ์๊ตฌ์ฌํญ์ด๋ฉด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์๊ฐ์ ๋ง์ด ์ ์ฝํด์ค ๊ฑฐ์ผ ใ ใ
๐จ ์ ๊ทผ์ฑ(Accessibility) ๊ณ ๋ ค์ฌํญ
๋๋๊ทธ ์ค ๋๋กญ์ ์๊ฐ์ ์ผ๋ก ๋ฉ์ง์ง๋ง, ํค๋ณด๋๋ง ์ฌ์ฉํ๋ ์ฌ์ฉ์๋ ์คํฌ๋ฆฐ ๋ฆฌ๋ ์ฌ์ฉ์๋ ์ด๋ป๊ฒ ํ ๊น? ์ ๊ทผ์ฑ๋ ๊ผญ ์ฑ๊ฒจ์ผ ํด!
โฟ ํค๋ณด๋ ๋ค๋น๊ฒ์ด์ ์ง์
๋ง์ฐ์ค ์์ด๋ ๋๋๊ทธ ์ค ๋๋กญ๊ณผ ๋์ผํ ์์ ์ ํ ์ ์์ด์ผ ํด.
// ํค๋ณด๋๋ก ์์ ๋ณ๊ฒฝํ๊ธฐ
element.addEventListener('keydown', (e) => {
const item = e.target;
if (e.key === 'ArrowUp' && e.ctrlKey) {
// ์๋ก ์ด๋
const prev = item.previousElementSibling;
if (prev) {
item.parentNode.insertBefore(item, prev);
item.focus();
}
e.preventDefault();
}
if (e.key === 'ArrowDown' && e.ctrlKey) {
// ์๋๋ก ์ด๋
const next = item.nextElementSibling;
if (next) {
item.parentNode.insertBefore(next, item);
item.focus();
}
e.preventDefault();
}
if (e.key === 'Enter' || e.key === ' ') {
// ์ ํ/๋๋กญ ํ ๊ธ
toggleDragMode(item);
e.preventDefault();
}
});
๐ ARIA ์์ฑ ํ์ฉ
์คํฌ๋ฆฐ ๋ฆฌ๋ ์ฌ์ฉ์๋ฅผ ์ํด ์ ์ ํ ARIA ์์ฑ์ ์ถ๊ฐํด์ค์ผ ํด.
<div
class="draggable-item"
draggable="true"
role="button"
tabindex="0"
aria-grabbed="false"
aria-label="ํ ์ผ ํญ๋ชฉ: ์ฝ๋ฉ ๊ณต๋ถ. ๋๋๊ทธํ๋ ค๋ฉด ์คํ์ด์ค๋ฐ๋ฅผ ๋๋ฅด์ธ์"
>
์ฝ๋ฉ ๊ณต๋ถ
</div>
// JavaScript๋ก ์ํ ์
๋ฐ์ดํธ
element.addEventListener('dragstart', (e) => {
e.target.setAttribute('aria-grabbed', 'true');
});
element.addEventListener('dragend', (e) => {
e.target.setAttribute('aria-grabbed', 'false');
});
๐ข ๋ผ์ด๋ธ ๋ฆฌ์ ์ผ๋ก ํผ๋๋ฐฑ ์ ๊ณต
๋๋๊ทธ ์ค ๋๋กญ ๊ฒฐ๊ณผ๋ฅผ ์คํฌ๋ฆฐ ๋ฆฌ๋์ ์๋ ค์ค์ผ ํด.
<div aria-live="polite" aria-atomic="true" class="sr-only">
<!-- ์ฌ๊ธฐ์ ๋์ ์ผ๋ก ๋ฉ์์ง ์ฝ์
-->
</div>
// ๋๋กญ ์๋ฃ ์
function announceDropResult(itemName, newPosition) {
const liveRegion = document.querySelector('[aria-live]');
liveRegion.textContent = `${itemName}์ด(๊ฐ) ${newPosition}๋ฒ์งธ ์์น๋ก ์ด๋ํ์ต๋๋ค.`;
}
์ ๊ทผ์ฑ์ ์ ํ์ด ์๋๋ผ ํ์์ผ! ๋ชจ๋ ์ฌ์ฉ์๊ฐ ๋๋ฑํ๊ฒ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์์ด์ผ ์ง์ง ์ข์ UI๋ผ๊ณ ํ ์ ์์ง ๐
๐ ํํ ๋ฒ๊ทธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ
๋๋๊ทธ ์ค ๋๋กญ ๊ตฌํํ๋ค ๋ณด๋ฉด ์์ฃผ ๋ง๋๋ ๋ฒ๊ทธ๋ค์ด ์์ด. ๋ฏธ๋ฆฌ ์๊ณ ์์ผ๋ฉด ์ฝ์ง์ ์ค์ผ ์ ์์ง ใ ใ
๐ด ๋ฌธ์ 1: ๋๋กญ์ด ์ ๋ผ์!
์์ธ: dragover ์ด๋ฒคํธ์์ preventDefault()๋ฅผ ์ ๋ถ๋ ์ ๊ฐ๋ฅ์ฑ์ด ๋์.
ํด๊ฒฐ:
dropZone.addEventListener('dragover', (e) => {
e.preventDefault(); // ์ด๊ฑฐ ๊ผญ ํ์ํด!
e.dataTransfer.dropEffect = 'move';
});
๐ด ๋ฌธ์ 2: ์ด๋ฏธ์ง๋ ๋งํฌ๊ฐ ์ ํญ์ผ๋ก ์ด๋ ค์!
์์ธ: ๋ธ๋ผ์ฐ์ ์ ๊ธฐ๋ณธ ๋๋๊ทธ ๋์์ด ์คํ๋๊ณ ์์ด.
ํด๊ฒฐ:
element.addEventListener('dragstart', (e) => {
e.stopPropagation(); // ์ด๋ฒคํธ ์ ํ ์ค๋จ
// ๋๋ ์ด๋ฏธ์ง/๋งํฌ์ draggable="false" ์์ฑ ์ถ๊ฐ
});
๐ด ๋ฌธ์ 3: ๋ชจ๋ฐ์ผ์์ ์๋ ์ ํด์!
์์ธ: HTML5 Drag and Drop API๋ ๋ชจ๋ฐ์ผ ํฐ์น๋ฅผ ๊ธฐ๋ณธ ์ง์ ์ ํด.
ํด๊ฒฐ: ํฐ์น ์ด๋ฒคํธ๋ฅผ ๋ณ๋๋ก ์ฒ๋ฆฌํ๊ฑฐ๋ polyfill ์ฌ์ฉ
// mobile-drag-drop ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ
import { polyfill } from 'mobile-drag-drop';
polyfill({
dragImageTranslateOverride:
scrollBehaviourDragImageTranslateOverride
});
๐ด ๋ฌธ์ 4: ๋๋๊ทธ ์ค ๊น๋นก๊ฑฐ๋ ค์!
์์ธ: DOM ์กฐ์์ด ๋๋ฌด ์์ฃผ ์ผ์ด๋๊ฑฐ๋ ๋ฆฌํ๋ก์ฐ๊ฐ ๋ฐ์ํด.
ํด๊ฒฐ:
// transform ์ฌ์ฉ (๋ฆฌํ๋ก์ฐ ์์)
element.style.transform = `translate(${x}px, ${y}px)`;
// position ์ฌ์ฉ (๋ฆฌํ๋ก์ฐ ๋ฐ์) - ํผํ๊ธฐ
element.style.left = x + 'px';
element.style.top = y + 'px';
๐ด ๋ฌธ์ 5: ๋๋๊ทธ ์ค ํ ์คํธ๊ฐ ์ ํ๋ผ์!
์์ธ: ๋ง์ฐ์ค ๋๋๊ทธ ์ ๋ธ๋ผ์ฐ์ ๊ฐ ํ ์คํธ ์ ํ์ผ๋ก ์ธ์.
ํด๊ฒฐ:
// CSS๋ก ํ
์คํธ ์ ํ ๋ฐฉ์ง
.draggable {
user-select: none;
-webkit-user-select: none;
-moz-user-select: none;
}
// ๋๋ JavaScript๋ก
element.addEventListener('mousedown', (e) => {
e.preventDefault();
});
๐ ์ค๋ฌด ํ์ฉ ์ฌ๋ก
๋๋๊ทธ ์ค ๋๋กญ์ด ์ค์ ๋ก ์ด๋ป๊ฒ ์ฐ์ด๋์ง ๋ช ๊ฐ์ง ์ฌ๋ก๋ฅผ ๋ณด์ฌ์ค๊ฒ. ํน์ ์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ํ๋ก์ ํธ๋ฅผ ์งํํ๋ค๋ฉด ์ด๋ฐ ๊ธฐ๋ฅ๋ค์ ๊ตฌํํด๋ณผ ์ ์์ ๊ฑฐ์ผ!
๐ ๋์๋ณด๋ ์์ ฏ ๋ฐฐ์น
์ฌ์ฉ์๊ฐ ์ํ๋ ๋๋ก ์ฐจํธ๋ ์์ ฏ์ ๋ฐฐ์นํ ์ ์๊ฒ ํด์ค. ๊ฐ์ธํ๋ ๋์๋ณด๋๋ฅผ ๋ง๋ค ์ ์์ด์ ์ฌ์ฉ์ ๋ง์กฑ๋๊ฐ ๋์์ ธ!
๐ ํผ ๋น๋
์ค๋ฌธ์กฐ์ฌ๋ ์ ์ฒญ์ ๊ฐ์ ๊ฑธ ๋ง๋ค ๋, ํ๋๋ฅผ ๋๋๊ทธํด์ ์์๋ฅผ ๋ฐ๊พธ๊ฑฐ๋ ์ถ๊ฐํ ์ ์๊ฒ ํ๋ฉด ์์ฒญ ํธํด. Google Forms ๊ฐ์ ์๋น์ค๊ฐ ์ด๋ ๊ฒ ์๋ํ์ง!
๐จ ์ด๋ฏธ์ง ๊ฐค๋ฌ๋ฆฌ ์ ๋ ฌ
์ฌ์ง์ ๋๋๊ทธํด์ ์์๋ฅผ ๋ฐ๊พธ๊ฑฐ๋ ์จ๋ฒ ๊ฐ ์ด๋. ํนํ ํฌํธํด๋ฆฌ์ค ์ฌ์ดํธ์์ ์ ์ฉํด!
๐ ์ผ์ ๊ด๋ฆฌ
์บ๋ฆฐ๋์์ ์ผ์ ์ ๋๋๊ทธํด์ ๋ ์ง๋ ์๊ฐ์ ๋ณ๊ฒฝ. ์ง๊ด์ ์ด๋ผ ์ฌ์ฉ์๋ค์ด ์ข์ํด!
๐ต ์ฌ์๋ชฉ๋ก ํธ์ง
์์ ์ด๋ ๋น๋์ค ์ฌ์ ์์๋ฅผ ๋๋๊ทธ๋ก ๋ณ๊ฒฝ. Spotify, YouTube ๊ฐ์ ๊ณณ์์ ๋ง์ด ์ฐ์ด์ง!
๐๏ธ ํ์ผ ๊ด๋ฆฌ์
ํ์ผ์ ํด๋ ๊ฐ ์ด๋ํ๊ฑฐ๋ ์ ๋ ฌ. ํด๋ผ์ฐ๋ ์คํ ๋ฆฌ์ง ์๋น์ค์ ํ์ ๊ธฐ๋ฅ!
๐ฎ ๊ณ ๊ธ ํ ํฌ๋
๊ธฐ๋ณธ์ ๋ง์คํฐํ๋ค๋ฉด ์ด์ ์ข ๋ ๊ณ ๊ธ ๊ธฐ์ ์ ๋ฐฐ์๋ณผ ์ฐจ๋ก์ผ! ํ๋ก์ฒ๋ผ ๋ณด์ด๋ ๊ธฐ๋ฅ๋ค์ ๊ตฌํํด๋ณด์ ๐
๐ฏ ์ค๋ ๊ธฐ๋ฅ ๊ตฌํ
๋๋กญํ ๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ทธ๋ฆฌ๋๋ ์์์ ์๋์ผ๋ก ๋ถ๊ฒ ๋ง๋ค๊ธฐ!
function snapToGrid(x, y, gridSize = 20) {
return {
x: Math.round(x / gridSize) * gridSize,
y: Math.round(y / gridSize) * gridSize
};
}
element.addEventListener('dragend', (e) => {
const snapped = snapToGrid(e.clientX, e.clientY);
element.style.left = snapped.x + 'px';
element.style.top = snapped.y + 'px';
});
๐ ์๋ ์คํฌ๋กค ๊ตฌํ
๋๋๊ทธํ ์์๊ฐ ํ๋ฉด ๋์ ๊ฐ๋ฉด ์๋์ผ๋ก ์คํฌ๋กค๋๊ฒ!
let autoScrollInterval = null;
element.addEventListener('drag', (e) => {
const threshold = 50; // ์คํฌ๋กค ์์ ๊ฑฐ๋ฆฌ
const scrollSpeed = 10;
const viewportHeight = window.innerHeight;
const mouseY = e.clientY;
// ์์ชฝ ๋
if (mouseY < threshold) {
if (!autoScrollInterval) {
autoScrollInterval = setInterval(() => {
window.scrollBy(0, -scrollSpeed);
}, 16);
}
}
// ์๋์ชฝ ๋
else if (mouseY > viewportHeight - threshold) {
if (!autoScrollInterval) {
autoScrollInterval = setInterval(() => {
window.scrollBy(0, scrollSpeed);
}, 16);
}
}
// ์ค๊ฐ
else {
if (autoScrollInterval) {
clearInterval(autoScrollInterval);
autoScrollInterval = null;
}
}
});
element.addEventListener('dragend', () => {
if (autoScrollInterval) {
clearInterval(autoScrollInterval);
autoScrollInterval = null;
}
});
๐ญ ๋ค์ค ์ ํ ๋๋๊ทธ
์ฌ๋ฌ ๊ฐ ์ ํํด์ ํ ๋ฒ์ ๋๋๊ทธํ๊ธฐ!
let selectedItems = new Set();
// Ctrl/Cmd + ํด๋ฆญ์ผ๋ก ๋ค์ค ์ ํ
items.forEach(item => {
item.addEventListener('click', (e) => {
if (e.ctrlKey || e.metaKey) {
if (selectedItems.has(item)) {
selectedItems.delete(item);
item.classList.remove('selected');
} else {
selectedItems.add(item);
item.classList.add('selected');
}
} else {
selectedItems.clear();
items.forEach(i => i.classList.remove('selected'));
selectedItems.add(item);
item.classList.add('selected');
}
});
item.addEventListener('dragstart', (e) => {
if (!selectedItems.has(item)) {
selectedItems.clear();
selectedItems.add(item);
}
// ์ ํ๋ ๋ชจ๋ ์์ดํ
์ ๋ณด ์ ๋ฌ
const itemIds = Array.from(selectedItems).map(i => i.dataset.id);
e.dataTransfer.setData('application/json',
JSON.stringify(itemIds));
});
});
โฉ๏ธ ๋๋๋ฆฌ๊ธฐ(Undo) ๊ธฐ๋ฅ
๋๋๊ทธ ์ค ๋๋กญ ์์ ์ ์ทจ์ํ ์ ์๊ฒ!
class DragHistory {
constructor() {
this.history = [];
this.currentIndex = -1;
}
push(action) {
// ํ์ฌ ์์น ์ดํ์ ํ์คํ ๋ฆฌ ์ ๊ฑฐ
this.history = this.history.slice(0, this.currentIndex + 1);
this.history.push(action);
this.currentIndex++;
}
undo() {
if (this.currentIndex >= 0) {
const action = this.history[this.currentIndex];
this.revertAction(action);
this.currentIndex--;
}
}
redo() {
if (this.currentIndex < this.history.length - 1) {
this.currentIndex++;
const action = this.history[this.currentIndex];
this.applyAction(action);
}
}
revertAction(action) {
const { element, fromIndex, toIndex } = action;
// ์๋ ์์น๋ก ๋ณต์
moveElementToIndex(element, fromIndex);
}
applyAction(action) {
const { element, toIndex } = action;
moveElementToIndex(element, toIndex);
}
}
const history = new DragHistory();
element.addEventListener('drop', (e) => {
const fromIndex = parseInt(e.dataTransfer.getData('fromIndex'));
const toIndex = getCurrentIndex(e.target);
history.push({
element: draggedElement,
fromIndex,
toIndex
});
});
// Ctrl+Z๋ก ๋๋๋ฆฌ๊ธฐ
document.addEventListener('keydown', (e) => {
if ((e.ctrlKey || e.metaKey) && e.key === 'z') {
if (e.shiftKey) {
history.redo();
} else {
history.undo();
}
e.preventDefault();
}
});
๐ ํฌ๋ก์ค ๋ธ๋ผ์ฐ์ ํธํ์ฑ
๋๋๊ทธ ์ค ๋๋กญ์ ๋ธ๋ผ์ฐ์ ๋ง๋ค ๋์์ด ์กฐ๊ธ์ฉ ๋ฌ๋ผ์ ์ฃผ์๊ฐ ํ์ํด. ์ฃผ์ ์ด์๋ค์ ์ ๋ฆฌํด๋ดค์ด!
๐ ๋ธ๋ผ์ฐ์ ๋ณ ์ฐจ์ด์
Chrome/Edge
โข ๊ฐ์ฅ ์์ ์ ์ผ๋ก ์๋
โข dataTransfer.setDragImage() ์๋ฒฝ ์ง์
โข ํฐ์น ์ด๋ฒคํธ๋ ๋ณ๋ ์ฒ๋ฆฌ ํ์
Firefox
โข dataTransfer.setData()์์ ๋น ๋ฌธ์์ด ํ์ฉ ์ ํจ
โข effectAllowed ์ค์ ํ์
โข ๋๋๊ทธ ์ด๋ฏธ์ง ์์น ๊ณ์ฐ์ด ๋ค๋ฆ
Safari
โข dataTransfer.getData()๊ฐ drop ์ด๋ฒคํธ์์๋ง ์๋
โข ํ์ผ ๋๋๊ทธ ์ ๋ณด์ ์ ์ฝ ๋ ์๊ฒฉ
โข iOS Safari๋ HTML5 DnD API ์ง์ ์ ํจ
// ํฌ๋ก์ค ๋ธ๋ผ์ฐ์ ํธํ ์ฝ๋
element.addEventListener('dragstart', (e) => {
// Firefox ๋์: ๋น ๋ฌธ์์ด ๋์ ๊ณต๋ฐฑ
e.dataTransfer.setData('text/plain', ' ');
// Safari ๋์: effectAllowed ๋ช
์
e.dataTransfer.effectAllowed = 'move';
// ๋ธ๋ผ์ฐ์ ๊ฐ์ง
const isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
if (isFirefox) {
// Firefox ์ ์ฉ ์ฒ๋ฆฌ
}
if (isSafari) {
// Safari ์ ์ฉ ์ฒ๋ฆฌ
}
});
// iOS ๊ฐ์ง ๋ฐ ๋์ฒด ๋ฐฉ๋ฒ ์ ๊ณต
const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
if (isIOS) {
// ํฐ์น ์ด๋ฒคํธ๋ก ๋์ฒด ๊ตฌํ
implementTouchDragDrop();
}
๐ ์ฑ๋ฅ ์ธก์ ๊ณผ ๋ชจ๋ํฐ๋ง
๋๋๊ทธ ์ค ๋๋กญ์ด ์ผ๋ง๋ ๋ถ๋๋ฝ๊ฒ ์๋ํ๋์ง ์ธก์ ํ๋ ๊ฒ๋ ์ค์ํด. ์ฑ๋ฅ ๋ฌธ์ ๋ฅผ ์กฐ๊ธฐ์ ๋ฐ๊ฒฌํ์!
// Performance API๋ก ์ธก์
let dragStartTime;
let frameCount = 0;
let fps = 0;
element.addEventListener('dragstart', () => {
dragStartTime = performance.now();
frameCount = 0;
measureFPS();
});
element.addEventListener('drag', () => {
frameCount++;
});
element.addEventListener('dragend', () => {
const duration = performance.now() - dragStartTime;
const avgFPS = (frameCount / duration) * 1000;
console.log(`ํ๊ท FPS: ${avgFPS.toFixed(2)}`);
console.log(`์ด ํ๋ ์: ${frameCount}`);
console.log(`์์ ์๊ฐ: ${duration.toFixed(2)}ms`);
// ์ฑ๋ฅ ๋ฐ์ดํฐ ์ ์ก
sendAnalytics({
event: 'drag_performance',
fps: avgFPS,
duration: duration
});
});
function measureFPS() {
let lastTime = performance.now();
let frames = 0;
function tick() {
const now = performance.now();
frames++;
if (now >= lastTime + 1000) {
fps = Math.round((frames * 1000) / (now - lastTime));
frames = 0;
lastTime = now;
// FPS๊ฐ 30 ์ดํ๋ฉด ๊ฒฝ๊ณ
if (fps < 30) {
console.warn('๋ฎ์ FPS ๊ฐ์ง:', fps);
}
}
requestAnimationFrame(tick);
}
tick();
}
๋ชฉํ๋ 60 FPS๋ฅผ ์ ์งํ๋ ๊ฑฐ์ผ. 30 FPS ์ดํ๋ก ๋จ์ด์ง๋ฉด ์ฌ์ฉ์๊ฐ ๋ฒ๋ฒ ์์ ๋๋ผ๊ธฐ ์์ํด. ์ฑ๋ฅ ๋ฌธ์ ๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ์์์ ๋งํ ์ต์ ํ ๊ธฐ๋ฒ๋ค์ ์ ์ฉํด๋ด!
๐ก ์ค์ ํ๊ณผ ๋ฒ ์คํธ ํ๋ํฐ์ค
๋ง์ง๋ง์ผ๋ก ์ค๋ฌด์์ ๋ฐ๋ก ์จ๋จน์ ์ ์๋ ํ๋ค์ ์ ๋ฆฌํด์ค๊ฒ!
โ ๋ช ํํ ์๊ฐ์ ํผ๋๋ฐฑ
๋๋๊ทธ ๊ฐ๋ฅํ ์์๋ ์ปค์๋ฅผ grab์ผ๋ก, ๋๋๊ทธ ์ค์๋ grabbing์ผ๋ก ๋ฐ๊ฟ์ค. ๋๋กญ ๊ฐ๋ฅํ ์์ญ๋ ํ์ด๋ผ์ดํธ๋ก ํ์!
โ ์ ์ ํ ๋๋๊ทธ ํธ๋ค
์ ์ฒด ์์๋ฅผ ๋๋๊ทธ ๊ฐ๋ฅํ๊ฒ ํ๊ธฐ๋ณด๋ค๋ ํน์ ์์ญ(ํธ๋ค)๋ง ๋๋๊ทธ ๊ฐ๋ฅํ๊ฒ ํ๋ ๊ฒ ์ค์๋ฅผ ์ค์ฌ์ค.
โ ๋๋กญ ์์ญ ๋ช ํํ
์ด๋์ ๋๋กญํ ์ ์๋์ง ์ฌ์ฉ์๊ฐ ํ๋์ ์ ์ ์๊ฒ ํด์ผ ํด. ์ ์ ํ ๋๋ฆฌ๋ ๋ฐฐ๊ฒฝ์ ๋ณํ๋ก ํ์ํ์!
โ ์๋ฌ ์ฒ๋ฆฌ
์๋ชป๋ ์์น์ ๋๋กญํ๊ฑฐ๋ ๋คํธ์ํฌ ์ค๋ฅ๋ก ์ ์ฅ ์คํจ ์ ์๋ ์ํ๋ก ๋ณต์ํ๊ณ ์ฌ์ฉ์์๊ฒ ์๋ ค์ค.
โ ๋ก๋ฉ ์ํ ํ์
์๋ฒ์ ๋ฐ์ดํฐ ์ ์ฅํ๋ ๋์ ๋ก๋ฉ ์ธ๋์ผ์ดํฐ๋ฅผ ๋ณด์ฌ์ค. ์ฌ์ฉ์๊ฐ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ค๋ ๊ฑธ ์๊ฒ!
โ ๋ชจ๋ฐ์ผ ์ฐ์ ๊ณ ๋ ค
ํฐ์น ๋๋ฐ์ด์ค์์๋ ์ ์๋ํ๋์ง ๊ผญ ํ ์คํธํด์ผ ํด. ํฐ์น ์์ญ์ ์ต์ 44x44px!
// ๋ฒ ์คํธ ํ๋ํฐ์ค ์ข
ํฉ ์์
class BestPracticeDragDrop {
constructor(container) {
this.container = container;
this.isDragging = false;
this.draggedElement = null;
this.init();
}
init() {
// ๋๋๊ทธ ํธ๋ค๋ง ๋๋๊ทธ ๊ฐ๋ฅํ๊ฒ
const handles = this.container.querySelectorAll('.drag-handle');
handles.forEach(handle => {
handle.style.cursor = 'grab';
handle.addEventListener('mousedown', (e) => {
handle.style.cursor = 'grabbing';
const item = handle.closest('.draggable-item');
this.startDrag(item, e);
});
});
// ๋๋กญ ์์ญ ์ค์
const dropZones = this.container.querySelectorAll('.drop-zone');
dropZones.forEach(zone => {
zone.addEventListener('dragover', (e) => {
e.preventDefault();
zone.classList.add('drop-zone-active');
// ๋๋กญ ๊ฐ๋ฅ ์ฌ๋ถ ๊ฒ์ฆ
if (this.canDrop(this.draggedElement, zone)) {
zone.classList.add('drop-zone-valid');
} else {
zone.classList.add('drop-zone-invalid');
}
});
zone.addEventListener('dragleave', () => {
zone.classList.remove('drop-zone-active',
'drop-zone-valid', 'drop-zone-invalid');
});
zone.addEventListener('drop', async (e) => {
e.preventDefault();
if (!this.canDrop(this.draggedElement, zone)) {
this.showError('์ฌ๊ธฐ์๋ ๋๋กญํ ์ ์์ต๋๋ค');
return;
}
// ๋ก๋ฉ ํ์
zone.classList.add('loading');
try {
// ์๋ฒ์ ์ ์ฅ
await this.saveToServer(this.draggedElement, zone);
// ์ฑ๊ณต ํผ๋๋ฐฑ
this.showSuccess('์ ์ฅ๋์์ต๋๋ค');
zone.appendChild(this.draggedElement);
} catch (error) {
// ์๋ฌ ์ฒ๋ฆฌ ๋ฐ ๋ณต์
this.showError('์ ์ฅ ์คํจ: ' + error.message);
this.revertDrag();
} finally {
zone.classList.remove('loading');
}
});
});
}
canDrop(element, zone) {
// ๋๋กญ ๊ฐ๋ฅ ์ฌ๋ถ ๊ฒ์ฆ ๋ก์ง
const elementType = element.dataset.type;
const zoneType = zone.dataset.acceptType;
return !zoneType || elementType === zoneType;
}
async saveToServer(element, zone) {
const response = await fetch('/api/move', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
itemId: element.dataset.id,
targetZone: zone.dataset.id
})
});
if (!response.ok) {
throw new Error('์๋ฒ ์ค๋ฅ');
}
return response.json();
}
showSuccess(message) {
// ํ ์คํธ ๋ฉ์์ง ํ์
const toast = document.createElement('div');
toast.className = 'toast success';
toast.textContent = message;
document.body.appendChild(toast);
setTimeout(() => toast.remove(), 3000);
}
showError(message) {
const toast = document.createElement('div');
toast.className = 'toast error';
toast.textContent = message;
document.body.appendChild(toast);
setTimeout(() => toast.remove(), 3000);
}
revertDrag() {
// ์๋ ์์น๋ก ๋ณต์
if (this.originalParent && this.draggedElement) {
this.originalParent.appendChild(this.draggedElement);
}
}
}
๐ฌ ๋ง๋ฌด๋ฆฌํ๋ฉฐ
์... ์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด ์ง์ง ๋๋จํด! ๋๋๊ทธ ์ค ๋๋กญ์ ๋ํด ๊ฑฐ์ ๋ชจ๋ ๊ฑธ ๋ค๋ค์ด ใ ใ
์ฒ์์๋ ๋ณต์กํด ๋ณด์ด์ง๋ง, ๊ธฐ๋ณธ ์๋ฆฌ๋ง ์ดํดํ๋ฉด ์๊ฐ๋ณด๋ค ์ด๋ ต์ง ์์. HTML5 API๋ ์ง์ ๊ตฌํ์ด๋ , ์ค์ํ ๊ฑด ์ฌ์ฉ์ ๊ฒฝํ์ด์ผ. ๊ธฐ์ ์ ์ผ๋ก ์๋ฒฝํด๋ ์ฌ์ฉ์๊ฐ ๋ถํธํ๋ฉด ์๋ฏธ๊ฐ ์๊ฑฐ๋ .
๐ผ ์ฌ๋ฅ๋ท์์ ํ๋ก์ ํธ ์ฐพ๊ธฐ ๋๋๊ทธ ์ค ๋๋กญ ๊ธฐ๋ฅ์ ์ค์ ๋ก ๊ตฌํํด๋ณด๊ณ ์ถ๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ์ฐพ์๋ณด๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ์ค์ ๊ฒฝํ์ ์์ผ๋ฉด์ ํฌํธํด๋ฆฌ์ค๋ ๋ง๋ค ์ ์์ง. ๋๋ ๋ฐ๋๋ก ๋ค๊ฐ ์ด ๊ธฐ์ ์ ๋ง์คํฐํ๋ค๋ฉด ์ฌ๋ฅ๋ท์์ ๋ค๋ฅธ ์ฌ๋๋ค์ ๋์์ฃผ๋ฉด์ ์์ต๋ ๋ผ ์ ์์ด ๐
๊ธฐ์ตํด์ผ ํ ํต์ฌ ํฌ์ธํธ:
๐ฏ ์ด๋ฒคํธ ํ๋ฆ ์ดํด - dragstart, drag, dragover, drop, dragend์ ์์์ ์ญํ
๐ฏ preventDefault() ํ์ - dragover์์ ๊ผญ ํธ์ถํด์ผ drop ์ด๋ฒคํธ ๋ฐ์
๐ฏ DataTransfer ํ์ฉ - ๋ฐ์ดํฐ ์ ๋ฌ์ ํต์ฌ
๐ฏ ์ ๊ทผ์ฑ ๊ณ ๋ ค - ํค๋ณด๋ ๋ค๋น๊ฒ์ด์
๊ณผ ARIA ์์ฑ
๐ฏ ์ฑ๋ฅ ์ต์ ํ - requestAnimationFrame, ์ด๋ฒคํธ ์์, DOM ์กฐ์ ์ต์ํ
๐ฏ ๋ชจ๋ฐ์ผ ๋์ - ํฐ์น ์ด๋ฒคํธ ๋ณ๋ ์ฒ๋ฆฌ ๋๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ์ฉ
๐ฏ ์๋ฌ ์ฒ๋ฆฌ - ์คํจ ์ ๋ณต์ ๋ก์ง ํ์
์ด์ ์ง์ ๋ง๋ค์ด๋ณด๋ฉด์ ์ตํ๋ด! ์ฒ์์ ๊ฐ๋จํ ํ ์ผ ๋ชฉ๋ก๋ถํฐ ์์ํด์, ์ ์ ๋ณต์กํ ์นธ๋ฐ ๋ณด๋๋ ๋์๋ณด๋๋ก ๋ฐ์ ์์ผ ๋๊ฐ๋ฉด ๋ผ. ์ฝ๋ฉ์ ๊ฒฐ๊ตญ ์ง์ ํด๋ด์ผ ๋๊ฑฐ๋ ใ ใ
๊ถ๊ธํ ๊ฑฐ ์์ผ๋ฉด ์ธ์ ๋ ๋ฌผ์ด๋ด! ํ์ดํ ! ๐โจ
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.