jQuery UI widget源码解析，想找工作的你还不看这份资料就晚了

221. // Copy everything else by reference

222. } else {

223. target[key] = value;

224. }

225. }

226. }

227. }

228. return target;

229. };

230. //bridge 是设计模式的一种，这里将对象转为插件调用

231. $.widget.bridge = function(name, object) {

232. var fullName = object.prototype.widgetFullName || name;

233. //这里就是插件了

234. //这部分的实现主要做了几个工作，也是制作一个优雅的插件的主要代码

235. //1、初次实例化时将插件对象缓存在dom上，后续则可直接调用，避免在相同元素下widget的多实例化。简单的说，就是一个单例方法。

236. //2、合并用户提供的默认设置选项options

237. //3、可以通过调用插件时传递字符串来调用插件内的方法。如:$(‘#id’).menu(‘hide’) 实际就是实例插件并调用hide()方法。

238. //4、同时限制外部调用“_”下划线的私有方法

239. $.fn[name] = function(options) {

240. var isMethodCall = typeof options === “string”,

241. args = widget_slice.call(arguments, 1),

242. returnValue = this;

243. // allow multiple hashes to be passed on init.

244. //可以简单认为是$.extend(true,options,args[0],…),args可以是一个参数或是数组

245. options = !isMethodCall && args.length ? $.widget.extend.apply(null, [options].concat(args)) : options;

246. //这里对字符串和对象分别作处理

247. if (isMethodCall) {

248. this.each(function() {

249. var methodValue, instance = $.data(this, fullName);

250. //如果传递的是instance则将this返回。

251. if (options === “instance”) {

252. returnValue = instance;

253. return false;

254. }

255. if (!instance) {

256. return $.error("cannot call methods on " + name + " prior to initialization; " + “attempted to call method '” + options + “'”);

257. }

258. //这里对私有方法的调用做了限制，直接调用会抛出异常事件

259. if (!$.isFunction(instance[options]) || options.charAt(0) === “_”) {

260. return $.error(“no such method '” + options + “’ for " + name + " widget instance”);

261. }

262. //这里是如果传递的是字符串，则调用字符串方法，并传递对应的参数.

263. //比如插件有个方法hide(a,b); 有2个参数：a，b

264. //则调用时$(‘#id’).menu(‘hide’,1,2);//1和2 分别就是参数a和b了。

265. methodValue = instance[options].apply(instance, args);

266. if (methodValue !== instance && methodValue !== undefined) {

267. returnValue = methodValue && methodValue.jquery ? returnValue.pushStack(methodValue.get()) : methodValue;

268. return false;

269. }

270. });

271. } else {

272. this.each(function() {

273. var instance = $.data(this, fullName);

274. if (instance) {

275. instance.option(options || {});

276. //这里每次都调用init方法

277. if (instance._init) {

278. instance._init();

279. }

280. } else {

281. //缓存插件实例

282. $.data(this, fullName, new object(options, this));

283. }

284. });

285. }

286. return returnValue;

287. };

288. };

289. //这里是真正的widget基类

290. $.Widget = function( /* options, element */ ) {};

291. $.Widget._childConstructors = [];

292. $.Widget.prototype = {

293. widgetName: “widget”,

294. //用来决定事件的名称和插件提供的callbacks的关联。

295. // 比如dialog有一个close的callback，当close的callback被执行的时候，一个dialogclose的事件被触发。

296. // 事件的名称和事件的prefix+callback的名称。widgetEventPrefix 默认就是控件的名称，但是如果事件需要不同的名称也可以被重写。

297. // 比如一个用户开始拖拽一个元素,我们不想使用draggablestart作为事件的名称，我们想使用dragstart，所以我们可以重写事件的prefix。

298. // 如果callback的名称和事件的prefix相同，事件的名称将不会是prefix。

299. // 它阻止像dragdrag一样的事件名称。

300. widgetEventPrefix: “”,

301. defaultElement: “

     ”,

302. //属性会在创建模块时被覆盖

303. options: {

304. disabled: false,

305. // callbacks

306. create: null

307. },

308. _createWidget: function(options, element) {

309. element = $(element || this.defaultElement || this)[0];

310. this.element = $(element);

311. this.uuid = widget_uuid++;

312. this.eventNamespace = “.” + this.widgetName + this.uuid;

313. this.options = $.widget.extend({}, this.options, this._getCreateOptions(), options);

314. this.bindings = $();

315. this.hoverable = $();

316. this.focusable = $();

317. if (element !== this) {

318. //            debugger

319. $.data(element, this.widgetFullName, this);

320. this._on(true, this.element, {

321. remove: function(event) {

322. if (event.target === element) {

323. this.destroy();

324. }

325. }

326. });

327. this.document = $(element.style ?

328. // element within the document

329. element.ownerDocument :

330. // element is window or document

331. element.document || element);

332. this.window = $(this.document[0].defaultView || this.document[0].parentWindow);

333. }

334. this._create();

335. //创建插件时，有个create的回调

336. this._trigger(“create”, null, this._getCreateEventData());

337. this._init();

338. },

339. _getCreateOptions: $.noop,

340. _getCreateEventData: $.noop,

341. _create: $.noop,

342. _init: $.noop,

343. //销毁模块：去除绑定事件、去除数据、去除样式、属性

344. destroy: function() {

345. this._destroy();

346. // we can probably remove the unbind calls in 2.0

347. // all event bindings should go through this._on()

348. this.element.unbind(this.eventNamespace).removeData(this.widgetFullName)

349. // support: jquery <1.6.3

350. // http://bugs.jquery.com/ticket/9413

351. .removeData($.camelCase(this.widgetFullName));

352. this.widget().unbind(this.eventNamespace).removeAttr(“aria-disabled”).removeClass(

353. this.widgetFullName + "-disabled " + “ui-state-disabled”);

354. // clean up events and states

355. this.bindings.unbind(this.eventNamespace);

356. this.hoverable.removeClass(“ui-state-hover”);

357. this.focusable.removeClass(“ui-state-focus”);

358. },

359. _destroy: $.noop,

360. widget: function() {

361. return this.element;

362. },

363. //设置选项函数

364. option: function(key, value) {

365. var options = key,

366. parts, curOption, i;

367. if (arguments.length === 0) {

368. // don’t return a reference to the internal hash

369. //返回一个新的对象，不是内部数据的引用

370. return $.widget.extend({}, this.options);

371. }

372. if (typeof key === “string”) {

373. // handle nested keys, e.g., “foo.bar” => { foo: { bar: ___ } }

374. options = {};

375. parts = key.split(“.”);

376. key = parts.shift();

377. if (parts.length) {

378. curOption = options[key] = $.widget.extend({}, this.options[key]);

379. for (i = 0; i < parts.length - 1; i++) {

380. curOption[parts[i]] = curOption[parts[i]] || {};

381. curOption = curOption[parts[i]];

382. }

383. key = parts.pop();

384. if (arguments.length === 1) {

385. return curOption[key] === undefined ? null : curOption[key];

386. }

387. curOption[key] = value;

388. } else {

389. if (arguments.length === 1) {

390. return this.options[key] === undefined ? null : this.options[key];

391. }

392. options[key] = value;

393. }

394. }

395. this._setOptions(options);

396. return this;

397. },

398. _setOptions: function(options) {

399. var key;

400. for (key in options) {

401. this._setOption(key, options[key]);

402. }

403. return this;

404. },

405. _setOption: function(key, value) {

406. this.options[key] = value;

407. if (key === “disabled”) {

408. this.widget().toggleClass(this.widgetFullName + “-disabled”, !! value);

409. // If the widget is becoming disabled, then nothing is interactive

410. if (value) {

411. this.hoverable.removeClass(“ui-state-hover”);

412. this.focusable.removeClass(“ui-state-focus”);

413. }

414. }

415. return this;

416. },

417. enable: function() {

418. return this._setOptions({

419. disabled: false

420. });

421. },

422. disable: function() {

423. return this._setOptions({

424. disabled: true

425. });

426. },

427. _on: function(suppressDisabledCheck, element, handlers) {

428. var delegateElement, instance = this;

429. // no suppressDisabledCheck flag, shuffle arguments

430. if (typeof suppressDisabledCheck !== “boolean”) {

431. handlers = element;

432. element = suppressDisabledCheck;

433. suppressDisabledCheck = false;

434. }

435. // no element argument, shuffle and use this.element

436. if (!handlers) {

437. handlers = element;

438. element = this.element;

439. delegateElement = this.widget();

440. } else {

441. // accept selectors, DOM elements

442. element = delegateElement = $(element);

443. this.bindings = this.bindings.add(element);

444. }

445. $.each(handlers, function(event, handler) {

446. function handlerProxy() {

447. // allow widgets to customize the disabled handling

448. // - disabled as an array instead of boolean

449. // - disabled class as method for disabling individual parts

450. if (!suppressDisabledCheck && (instance.options.disabled === true || $(this).hasClass(“ui-state-disabled”))) {

451. return;

452. }

453. return (typeof handler === “string” ? instance[handler] : handler).apply(instance, arguments);

454. }

455. // copy the guid so direct unbinding works

456. if (typeof handler !== “string”) {

457. handlerProxy.guid = handler.guid = handler.guid || handlerProxy.guid || $.guid++;

458. }

459. var match = event.match(/^([\w:-]*)\s*(.*)$/),

460. eventName = match[1] + instance.eventNamespace,

461. selector = match[2];

462. if (selector) {

463. delegateElement.delegate(selector, eventName, handlerProxy);

464. } else {

465. element.bind(eventName, handlerProxy);

466. }

467. });

468. },

469. _off: function(element, eventName) {

470. eventName = (eventName || “”).split(" ").join(this.eventNamespace + " ") + this.eventNamespace;

471. element.unbind(eventName).undelegate(eventName);

472. },

473. _delay: function(handler, delay) {

474. function handlerProxy() {

475. return (typeof handler === “string” ? instance[handler] : handler).apply(instance, arguments);

476. }

477. var instance = this;

478. return setTimeout(handlerProxy, delay || 0);

479. },

480. _hoverable: function(element) {

481. this.hoverable = this.hoverable.add(element);

482. this._on(element, {

483. mouseenter: function(event) {

484. $(event.currentTarget).addClass(“ui-state-hover”);

485. },

486. mouseleave: function(event) {

487. $(event.currentTarget).removeClass(“ui-state-hover”);

488. }

489. });

490. },

491. _focusable: function(element) {

492. this.focusable = this.focusable.add(element);

493. this._on(element, {

494. focusin: function(event) {

495. $(event.currentTarget).addClass(“ui-state-focus”);

496. },

497. focusout: function(event) {

498. $(event.currentTarget).removeClass(“ui-state-focus”);

499. }

500. });

501. },

502. _trigger: function(type, event, data) {

503. var prop, orig, callback = this.options[type];

504. data = data || {};

505. event = $.Event(event);

506. event.type = (type === this.widgetEventPrefix ? type : this.widgetEventPrefix + type).toLowerCase();

507. // the original event may come from any element

508. // so we need to reset the target on the new event

509. event.target = this.element[0];

510. // copy original event properties over to the new event

511. orig = event.originalEvent;

512. if (orig) {

513. for (prop in orig) {

514. if (!(prop in event)) {

515. event[prop] = orig[prop];

516. }

517. }

518. }

519. this.element.trigger(event, data);

520. return !($.isFunction(callback) && callback.apply(this.element[0], [event].concat(data)) === false || event.isDefaultPrevented());

521. }

522. };

523. $.each({

524. show: “fadeIn”,

525. hide: “fadeOut”

526. }, function(method, defaultEffect) {

527. $.Widget.prototype[“_” + method] = function(element, options, callback) {

528. if (typeof options === “string”) {

529. options = {

530. effect: options

531. };

532. }

533. var hasOptions, effectName = !options ? method : options === true || typeof options === “number” ? defaultEffect : options.effect || defaultEffect;

534. options = options || {};

535. if (typeof options === “number”) {

536. options = {

537. duration: options

538. };

539. }

540. hasOptions = !$.isEmptyObject(options);

541. options.complete = callback;

542. if (options.delay) {

543. element.delay(options.delay);

544. }

545. if (hasOptions && KaTeX parse error: Expected 'EOF', got '&' at position 10: .effects &̲& .effects.effect[effectName]) {

546. element[method](options);

547. } else if (effectName !== method && element[effectName]) {

548. element[effectName](options.duration, options.easing, callback);

549. } else {

550. element.queue(function(next) {

551. $(this)[method]();

552. if (callback) {

553. callback.call(element[0]);

554. }

555. next();

556. });

557. }

558. };

559. });

560. return $.widget;

561. }));

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注前端）

下面是我在学习HTML和CSS的时候整理的一些笔记，有兴趣的可以看下：

进阶阶段

进阶阶段，开始攻 JS，对于刚接触 JS 的初学者，确实比学习 HTML 和 CSS 有难度，但是只要肯下功夫，这部分对于你来说，也不是什么大问题。

JS 内容涉及到的知识点较多，看到网上有很多人建议你从头到尾抱着那本《JavaScript高级程序设计》学，我是不建议的，毕竟刚接触 JS 谁能看得下去，当时我也不能，也没那样做。

我这部分的学习技巧是，增加次数，减少单次看的内容。就是说，第一遍学习 JS 走马观花的看，看个大概，去找视频以及网站学习，不建议直接看书。因为看书看不下去的时候很打击你学下去的信心。

然后通过一些网站的小例子，开始动手敲代码，一定要去实践、实践、实践，这一遍是为了更好的去熟悉 JS 的语法。别只顾着来回的看知识点，眼高手低可不是个好习惯，我在这吃过亏，你懂的。

1、JavaScript 和 ES6

在这个过程你会发现，有很多 JS 知识点你并不能更好的理解为什么这么设计，以及这样设计的好处是什么，这就逼着让你去学习这单个知识点的来龙去脉，去哪学？第一，书籍，我知道你不喜欢看，我最近通过刷大厂面试题整理了一份前端核心知识笔记，比较书籍更精简，一句废话都没有，这份笔记也让我通过跳槽从8k涨成20k。

2、前端框架

前端框架太多了，真的学不动了，别慌，其实对于前端的三大马车，Angular、React、Vue 只要把其中一种框架学明白，底层原理实现，其他两个学起来不会很吃力，这也取决于你以后就职的公司要求你会哪一个框架了，当然，会的越多越好，但是往往每个人的时间是有限的，对于自学的学生，或者即将面试找工作的人，当然要选择一门框架深挖原理。

以 Vue 为例，我整理了如下的面试题。

能看得下去，当时我也不能，也没那样做。

我这部分的学习技巧是，增加次数，减少单次看的内容。就是说，第一遍学习 JS 走马观花的看，看个大概，去找视频以及网站学习，不建议直接看书。因为看书看不下去的时候很打击你学下去的信心。

然后通过一些网站的小例子，开始动手敲代码，一定要去实践、实践、实践，这一遍是为了更好的去熟悉 JS 的语法。别只顾着来回的看知识点，眼高手低可不是个好习惯，我在这吃过亏，你懂的。

1、JavaScript 和 ES6

在这个过程你会发现，有很多 JS 知识点你并不能更好的理解为什么这么设计，以及这样设计的好处是什么，这就逼着让你去学习这单个知识点的来龙去脉，去哪学？第一，书籍，我知道你不喜欢看，我最近通过刷大厂面试题整理了一份前端核心知识笔记，比较书籍更精简，一句废话都没有，这份笔记也让我通过跳槽从8k涨成20k。

2、前端框架

前端框架太多了，真的学不动了，别慌，其实对于前端的三大马车，Angular、React、Vue 只要把其中一种框架学明白，底层原理实现，其他两个学起来不会很吃力，这也取决于你以后就职的公司要求你会哪一个框架了，当然，会的越多越好，但是往往每个人的时间是有限的，对于自学的学生，或者即将面试找工作的人，当然要选择一门框架深挖原理。

以 Vue 为例，我整理了如下的面试题。