介绍

jQuery 是当今网络上使用最多的库，虽然 jQuery 相对较小且运行速度相当快，但它仍然代表应用程序中的一定量的开销。jQuery 提供的大部分功能现在都可以通过原生 DOM API 实现，并且在当今的 Web 应用程序中可能是不必要的。一些开发者认为，jQuery 可以保护我们不受浏览器兼容的影响，而事实上，在 IE8 之后，浏览器自己就很容易处理兼容问题了，而在 IE 时代之后，浏览器在兼容方面会做得更多。

fetch 替代 AJAX 方法

$(selector).load

1
2
3
4
5
$('#selector').load('/path/to/template.html');
// 等价替换
const response = await fetch('/path/to/template.html');
const body = await response.text();
document.querySelector('#selector').innerHTML = body;

$.get

1
2
3
4
5
6
7
8
$.get('/my/url', function(data){
  // 处理 data 数据
});
// 等价替换
const response = await fetch('/my/url');
if (!response.ok) {
}
const data = await response.text();

$.getJSON

1
2
3
4
5
6
$.getJSON('/my/url', function(data){
  // 处理 data 数据
});
// 等价替换
const response = await fetch('/my/url');
const data = await response.json();

$.ajax

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$.ajax({
  type: 'POST',
  url: '/my/url',
  data: data,
  success: function (res) {},
  error: function () {}
});
// 等价替换
const res = await fetch('/my/url', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(data)
});

元素操作

$(el).toggle

1
2
3
$(el).toggle();
// 等价替换
el.classList.toggle('hide');
1
2
3
.hide {
  display: none;
}

$(el).addClass

1
2
3
$(el).addClass(className);
// 等价替换
el.classList.add(className);

$(el).removeClass

1
2
3
$(el).removeClass(className);
// 等价替换
el.classList.remove(className);

$(el).hasClass

1
2
3
$(el).hasClass(className);
// 等价替换
el.classList.contains(className);

$(el).css

1
2
3
4
5
6
7
$(el).css(ruleName);
// 等价替换
getComputedStyle(el)[ruleName];

$(el).css(prop, val);
// 等价替换
el.style.cssText = `${prop}: ${val}`;

$(target).after

1
2
3
$(target).after(element);
// 等价替换
target.after(element);

$(target).before

1
2
3
$(target).before(element);
// 等价替换
target.before(el);

$(parent).append

1
2
3
$(parent).append(el);
// 等价替换
parent.append(el);

$(el).appendTo

1
2
3
$(el).appendTo(parent);
// 等价替换
parent.append(el);

$(el).clone

1
2
3
$(el).clone();
// 等价替换
el.cloneNode(true);

$(el).closest

1
2
3
$(el).closest(selector);
// 等价替换
el.closest(selector);

$.contains

1
2
3
$.contains(el, childNode);
// 等价替换
el.contains(childNode);

:contains

1
2
3
4
5
$("div:contains('my text')");
// 等价替换
[...document.querySelectorAll('div')].filter((el) =>
  el.textContent.includes('my text')
);

Create Elements

1
2
3
4
5
6
7
8
$('<div>Hello World!</div>');
// 等价替换
function generateElements(html) {
  const template = document.createElement('template');
  template.innerHTML = html.trim();
  return template.content.children;
}
generateElements('<div>Hello World!</div>');

$(selector).each

1
2
3
$(selector).each(function (i, el) {});
// 等价替换
document.querySelectorAll(selector).forEach((el, i) => {});

$(el).empty

1
2
3
$(el).empty();
// 等价替换
el.replaceChildren();

$(selector).filter

1
2
3
$(selector).filter(filterFn);
// 等价替换
[...document.querySelectorAll(selector)].filter(filterFn);

$(el).find

1
2
3
$(el).find(selector);
// 等价替换
el.querySelectorAll(`:scope ${selector}`);

$(el).height|width

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$(el).height();
$(el).width();
// 等价替换
el.getBoundingClientRect().height;
el.getBoundingClientRect().width;

$(el).height(val);
$(el).width(val);
// 等价替换
function setHeight(el, val) {
  if (typeof val === 'function') val = val();
  else if (typeof val === 'string') el.style.height = val;
  else el.style.height = val + 'px';
}
function setWidth(el, val) {
  if (typeof val === 'function') val = val();
  else if (typeof val === 'string') el.style.width = val;
  else el.style.width = val + 'px';
}

$(el).index

1
2
3
$(el).index();
// 等价替换
[...el.parentNode.children].indexOf(el);

$(el).innerHeight|innerWidth

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
$(el).innerHeight();
$(el).innerHeight(150);
$(el).innerWidth();
$(el).innerWidth(150);
// 等价替换
function innerHeight(el, value) {
  if (value === undefined) {
    return el.clientHeight;
  } else {
    el.style.height = value;
  }
}
function innerWidth(el, value) {
  if (value === undefined) {
    return el.clientWidth;
  } else {
    el.style.width = value;
  }
}
innerHeight(el);
innerHeight(el, 150);
innerWidth(el);
innerWidth(el, 150);

$(selector).last

1
2
3
$(selector).last();
// 等价替换
document.querySelectorAll(selector).at(-1);

$(el).is

1
2
3
$(el).is('.my-class');
// 等价替换
el.matches('.my-class');

$(el).offset

1
2
3
4
5
6
7
8
9
10
$(el).offset();
// 等价替换
function offset(el) {
  const box = el.getBoundingClientRect();
  const docElem = document.documentElement;
  return {
    top: box.top + window.pageYOffset - docElem.clientTop,
    left: box.left + window.pageXOffset - docElem.clientLeft
  };
}

相对视口的位置

1
2
3
4
5
6
7
8
9
function offset(el) {
  const offset = $(el).offset();
  return {
    top: offset.top - document.body.scrollTop,
    left: offset.left - document.body.scrollLeft
  };
}
// 等价替换
el.getBoundingClientRect();

$(el).offsetParent

1
2
3
$(el).offsetParent();
// 等价替换
el.offsetParent || el;

$(el).outerHeight|outerWidth

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
$(el).outerHeight();
$(el).outerWidth();
// 等价替换
el.offsetHeight;
el.offsetWidth;

// 加上 margin
$(el).outerHeight(true);
$(el).outerWidth(true);
// 等价替换
function outerHeight(el) {
  const style = getComputedStyle(el);
  return (
    el.getBoundingClientRect().height +
    parseFloat(style.getPropertyValue('marginTop')) +
    parseFloat(style.getPropertyValue('marginBottom'))
  );
}
function outerWidth(el) {
  const style = getComputedStyle(el);
  return (
    el.getBoundingClientRect().width +
    parseFloat(style.getPropertyValue('marginLeft')) +
    parseFloat(style.getPropertyValue('marginRight'))
  );
}
outerHeight(el);
outerWidth(el);

$(el).parents

1
2
3
4
5
6
7
8
9
$(el).parents(selector);
// 等价替换
function parents(el, selector) {
  const parents = [];
  while ((el = el.parentNode) && el !== document) {
    if (!selector || el.matches(selector)) parents.unshift(el);
  }
  return parents;
}

$(el).position

1
2
3
4
5
6
7
8
9
10
$(el).position();
// 等价替换
function position(el) {
  const {top, left} = el.getBoundingClientRect();
  const {marginTop, marginLeft} = getComputedStyle(el);
  return {
    top: top - parseInt(marginTop),
    left: left - parseInt(marginLeft)
  };
}

$(el).next|prev

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
$(el).next();
$(el).prev();
// 等价替换
el.nextElementSibling;
el.previousElementSibling;

$(el).next(selector);
$(el).prev(selector);
// 等价替换
function next(el, selector) {
  if (selector) {
    let next = el.nextElementSibling;
    while (next && !next.matches(selector)) {
      next = next.nextElementSibling;
    }
    return next;
  }
}
function prev(el, selector) {
  if (selector) {
    let previous = el.previousElementSibling;
    while (previous && !previous.matches(selector)) {
      previous = previous.previousElementSibling;
    }
    return previous;
  }
}

$(el|selector).remove

1
2
3
4
5
6
7
8
9
$(el).remove();
// 等价替换
el.remove();

$(selector).remove();
// 等价替换
for (const el of [...document.querySelectorAll(selector)]) {
  el.remove();
}

$(el).replaceWith

1
2
3
$(el).replaceWith(string);
// 等价替换
el.outerHTML = string;

$(el).scrollLeft

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$(el).scrollLeft();
$(el).scrollLeft(value);
// 等价替换
function scrollLeft(el, value) {
  if (value === undefined) {
    return el.pageXOffset;
  } else {
    if (el === window || el.nodeType === 9) {
      el.scrollTo(value, el.pageXOffset);
    } else {
      el.pageXOffset = value;
    }
  }
}

$(el).scrollTop

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$(el).scrollTop();
$(el).scrollTop(value);
// 等价替换
function scrollTop(el, value) {
  if (value === undefined) {
    return el.pageYOffset;
  } else {
    if (el === window || el.nodeType === 9) {
      el.scrollTo(value, el.pageYOffset);
    } else {
      el.pageYOffset = value;
    }
  }
}

$(formElement).serialize

1
2
3
$(formElement).serialize();
// 等价替换
new URLSearchParams(new FormData(formElement)).toString();

$(el).siblings

1
2
3
$(el).siblings();
// 等价替换
[...el.parentNode.children].filter((child) => child !== el);

$(el).wrap

1
2
3
4
5
6
7
el.wrap('<div></div>');
// 等价替换
function wrap(el) {
  const wrappingElement = document.createElement('div');
  el.replaceWith(wrappingElement);
  wrappingElement.appendChild(el);
}

$(el).unwrap

1
2
3
$(el).unwrap();
// 等价替换
el.replaceWith(...el.childNodes);

$(el).val

1
2
3
4
5
6
7
8
9
10
11
$(el).val();
// 等价替换
function val(el) {
  if (el.options && el.multiple) {
    return el.options
      .filter((option) => option.selected)
      .map((option) => option.value);
  } else {
    return el.value;
  }
}

事件操作

$(document).ready

1
2
3
4
5
6
7
8
9
$(document).ready(function () {});
// 等价替换
function ready(fn) {
  if (document.readyState !== 'loading') {
    fn();
  } else {
    document.addEventListener('DOMContentLoaded', fn);
  }
}

$(document).on

1
2
3
4
5
6
7
$(document).on(eventName, elementSelector, handler);
// 等价替换
document.addEventListener(eventName, (event) => {
  if (event.target.closest(elementSelector)) {
    handler.call(event.target, event);
  }
});

$(el).click

1
2
3
$(el).click(function () {});
// 等价替换
el.addEventListener('click', () => {});

$(el).on

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
$(el).on(eventName, eventHandler);
$(el).on(eventName, selector, eventHandler);
// 等价替换
function addEventListener(el, eventName, eventHandler, selector) {
  if (selector) {
    const wrappedHandler = (e) => {
      if (e.target && e.target.matches(selector)) {
        eventHandler(e);
      }
    };
    el.addEventListener(eventName, wrappedHandler);
    return wrappedHandler;
  } else {
    el.addEventListener(eventName, eventHandler);
    return eventHandler;
  }
}
addEventListener(el, eventName, eventHandler);
addEventListener(el, eventName, eventHandler, selector);

$(el).off

1
2
3
$(el).off(eventName, eventHandler);
// 等价替换
el.removeEventListener(eventName, eventHandler);

$(el).trigger

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$(el).trigger('my-event', {some: 'data'});
// 等价替换
const event = new CustomEvent('my-event', {detail: {some: 'data'}});
el.dispatchEvent(event);

$(el).trigger('focus');
$(el).trigger(new PointerEvent('pointerover'));
// 等价替换
function trigger(el, eventType) {
  if (typeof eventType === 'string' && typeof el[eventType] === 'function') {
    el[eventType]();
  } else {
    const event =
      eventType === 'string'
        ? new Event(eventType, {bubbles: true})
        : eventType;
    el.dispatchEvent(event);
  }
}
trigger(el, 'focus');
trigger(el, new PointerEvent('pointerover'));

内置操作

$.inArray|isArray

1
2
3
4
5
$.inArray(item, array);
$.isArray(arr);
// 等价替换
array.indexOf(item);
Array.isArray(arr);

$.each|map

1
2
3
4
5
6
7
8
9
$.each(array, fn);
$.map(array, fn);
// 等价替换
array.forEach(fn);
array.map(fn);

$.each(obj, function (key, value) {});
// 等价替换
for (const [key, value] of Object.entries(obj)) {}

$.proxy

1
2
3
$.proxy(fn, context);
// 等价替换
fn.bind(context);

$.extend

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
$.extend({}, objA, objB);
// 等价替换
const result = {...objA, ...objB};

$.extend(true, {}, objA, objB);
// 等价替换
function deepExtend(out, ...arguments_) {
  if (!out) {
    return {};
  }
  for (const obj of arguments_) {
    if (!obj) {
      continue;
    }
    for (const [key, value] of Object.entries(obj)) {
      switch (Object.prototype.toString.call(value)) {
        case '[object Object]':
          out[key] = deepExtend(out[key], value);
          break;
        case '[object Array]':
          out[key] = deepExtend(new Array(value.length), value);
          break;
        default:
          out[key] = value;
      }
    }
  }
  return out;
}
deepExtend({}, objA, objB);

$.isNumeric

1
2
3
4
5
6
7
8
9
$.isNumeric(val);
// 等价替换
function isNumeric(num) {
  if (typeof num === 'number') return num - num === 0;
  if (typeof num === 'string' && num.trim() !== '')
    return Number.isFinite(+num);
  return false;
}
isNumeric(val);

$.parseHTML

1
2
3
4
5
6
7
8
$.parseHTML(htmlString);
// 等价替换
function parseHTML(str) {
  const tmp = document.implementation.createHTMLDocument('');
  tmp.body.innerHTML = str;
  return [...tmp.body.childNodes];
}
parseHTML(htmlString);

$.type

1
2
3
4
5
6
$.type(obj);
// 等价替换
Object.prototype.toString
  .call(obj)
  .replace(/^\[object (.+)\]$/, '$1')
  .toLowerCase();

原文链接