jQuery UI widget源码解析

123. // inheriting from

124. //这里深复制一份options

125. basePrototype.options = $.widget.extend({}, basePrototype.options);

126. //在传入的ui原型中有方法调用this._super 和this.__superApply会调用到base上（最基类上）的方法

127. $.each(prototype, function(prop, value) {

128. //如果val不是function 则直接给对象赋值字符串

129. if (!$.isFunction(value)) {

130. proxiedPrototype[prop] = value;

131. return;

132. }

133. //如果val是function

134. proxiedPrototype[prop] = (function() {

135. //两种调用父类函数的方法

136. var _super = function() {

137. //将当期实例调用父类的方法

138. return base.prototype[prop].apply(this, arguments);

139. },

140. _superApply = function(args) {

141. return base.prototype[prop].apply(this, args);

142. };

143. return function() {

144. var __super = this._super,

145. __superApply = this._superApply,

146. returnValue;

147. //                console.log(prop, value,this,this._super,‘===’)

148. //                debugger;

149. //在这里调用父类的函数

150. this._super = _super;

151. this._superApply = _superApply;

152. returnValue = value.apply(this, arguments);

153. this._super = __super;

154. this._superApply = __superApply;

155. //                console.log(this,value,returnValue,prop,‘===’)

156. return returnValue;

157. };

158. })();

159. });

160. //    console.info(proxiedPrototype)

161. //    debugger;

162. //这里是实例化获取的内容

163. constructor.prototype = $.widget.extend(basePrototype, {

164. // TODO: remove support for widgetEventPrefix

165. // always use the name + a colon as the prefix, e.g., draggable:start

166. // don’t prefix for widgets that aren’t DOM-based

167. widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name

168. }, proxiedPrototype, {

169. //重新把constructor指向 constructor 变量

170. constructor: constructor,

171. namespace: namespace,

172. widgetName: name,

173. widgetFullName: fullName

174. });

175. // If this widget is being redefined then we need to find all widgets that

176. // are inheriting from it and redefine all of them so that they inherit from

177. // the new version of this widget. We’re essentially trying to replace one

178. // level in the prototype chain.

179. //这里判定插件是否被使用了。一般来说，都不会被使用的。

180. //因为插件的开发者都是我们自己，呵呵

181. if (existingConstructor) {

182. $.each(existingConstructor._childConstructors, function(i, child) {

183. var childPrototype = child.prototype;

184. // redefine the child widget using the same prototype that was

185. // originally used, but inherit from the new version of the base

186. $.widget(childPrototype.namespace + “.” + childPrototype.widgetName, constructor, child._proto);

187. });

188. // remove the list of existing child constructors from the old constructor

189. // so the old child constructors can be garbage collected

190. delete existingConstructor._childConstructors;

191. } else {

192. //父类添加当前插件的实例 主要用于作用域链查找 不至于断层

193. base._childConstructors.push(constructor);

194. }

195. //将此方法挂在jQuery对象上

196. $.widget.bridge(name, constructor);

197. return constructor;

198. };

199. //扩展jq的extend方法，实际上类似$.extend(true,…) 深复制

200. $.widget.extend = function(target) {

201. var input = widget_slice.call(arguments, 1),

202. inputIndex = 0,

203. inputLength = input.length,

204. key, value;

205. for (; inputIndex < inputLength; inputIndex++) {

206. for (key in input[inputIndex]) {

207. value = input[inputIndex][key];

208. if (input[inputIndex].hasOwnProperty(key) && value !== undefined) {

209. // Clone objects

210. if ($.isPlainObject(value)) {

211. target[key] = KaTeX parse error: Undefined control sequence: \[ at position 22: …inObject(target\̲[̲key\]) ? .widget.extend({}, target[key], value) :

212. // Don’t extend strings, arrays, etc. with objects

213. $.widget.extend({}, value);

214. // Copy everything else by reference

215. } else {

216. target[key] = value;

217. }

218. }

219. }

220. }

221. return target;

222. };

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

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

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

226. //这里就是插件了

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

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

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

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

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

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

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

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

235. returnValue = this;

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

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

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

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

240. if (isMethodCall) {

241. this.each(function() {

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

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

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

245. returnValue = instance;

246. return false;

247. }

248. if (!instance) {

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

250. }

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

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

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

254. }

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

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

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

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

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

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

261. return false;

262. }

263. });

264. } else {

265. this.each(function() {

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

267. if (instance) {

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

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

270. if (instance._init) {

271. instance._init();

272. }

273. } else {

274. //缓存插件实例

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

276. }

277. });

278. }

279. return returnValue;

280. };

281. };

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

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

284. $.Widget._childConstructors = [];

285. $.Widget.prototype = {

286. widgetName: “widget”,

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

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

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

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

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

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

293. widgetEventPrefix: “”,

294. defaultElement: “

     ”,

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

296. options: {

297. disabled: false,

298. // callbacks

299. create: null

300. },

301. _createWidget: function(options, element) {

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

303. this.element = $(element);

304. this.uuid = widget_uuid++;

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

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

307. this.bindings = $();

308. this.hoverable = $();

309. this.focusable = $();

310. if (element !== this) {

311. //            debugger

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

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

314. remove: function(event) {

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

316. this.destroy();

317. }

318. }

319. });

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

321. // element within the document

322. element.ownerDocument :

323. // element is window or document

324. element.document || element);

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

326. }

327. this._create();

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

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

330. this._init();

331. },

332. _getCreateOptions: $.noop,

333. _getCreateEventData: $.noop,

334. _create: $.noop,

335. _init: $.noop,

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

337. destroy: function() {

338. this._destroy();

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

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

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

342. // support: jquery <1.6.3

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

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

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

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

347. // clean up events and states

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

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

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

351. },

352. _destroy: $.noop,

353. widget: function() {

354. return this.element;

355. },

356. //设置选项函数

357. option: function(key, value) {

358. var options = key,

359. parts, curOption, i;

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

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

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

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

364. }

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

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

367. options = {};

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

369. key = parts.shift();

370. if (parts.length) {

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

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

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

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

375. }

376. key = parts.pop();

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

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

379. }

380. curOption[key] = value;

381. } else {

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

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

384. }

385. options[key] = value;

386. }

387. }

388. this._setOptions(options);

389. return this;

390. },

391. _setOptions: function(options) {

392. var key;

393. for (key in options) {

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

395. }

396. return this;

397. },

398. _setOption: function(key, value) {

399. this.options[key] = value;

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

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

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

403. if (value) {

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

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

406. }

407. }

408. return this;

409. },

410. enable: function() {

411. return this._setOptions({

412. disabled: false

413. });

414. },

415. disable: function() {

416. return this._setOptions({

417. disabled: true

418. });

419. },

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

421. var delegateElement, instance = this;

422. // no suppressDisabledCheck flag, shuffle arguments

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

424. handlers = element;

425. element = suppressDisabledCheck;

426. suppressDisabledCheck = false;

427. }

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

429. if (!handlers) {

430. handlers = element;

431. element = this.element;

432. delegateElement = this.widget();

433. } else {

434. // accept selectors, DOM elements

435. element = delegateElement = $(element);

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

437. }

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

439. function handlerProxy() {

440. // allow widgets to customize the disabled handling

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

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

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

444. return;

445. }

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

447. }

448. // copy the guid so direct unbinding works

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

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

451. }

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

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

454. selector = match[2];

455. if (selector) {

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

457. } else {

458. element.bind(eventName, handlerProxy);

459. }

460. });

461. },

462. _off: function(element, eventName) {

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

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

465. },

466. _delay: function(handler, delay) {

467. function handlerProxy() {

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

469. }

470. var instance = this;

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

472. },

473. _hoverable: function(element) {

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

475. this._on(element, {

476. mouseenter: function(event) {

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

478. },

479. mouseleave: function(event) {

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

481. }

482. });

483. },

484. _focusable: function(element) {

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

486. this._on(element, {

487. focusin: function(event) {

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

489. },

490. focusout: function(event) {

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

492. }

493. });

494. },

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

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

497. data = data || {};

498. event = $.Event(event);

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

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

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

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

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

504. orig = event.originalEvent;

505. if (orig) {

506. for (prop in orig) {

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

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

509. }

510. }

511. }

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

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

514. }

515. };

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

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

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

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

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

最后

本人分享一下这次字节跳动、美团、头条等大厂的面试真题涉及到的知识点，以及我个人的学习方法、学习路线等，当然也整理了一些学习文档资料出来是附赠给大家的。知识点涉及比较全面，包括但不限于前端基础，HTML，CSS，JavaScript，Vue，ES6，HTTP，浏览器，算法等等

详细大厂面试题答案、学习笔记、学习视频等资料领取，点击资料领取直通车！！

前端视频资料：
曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

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

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

[外链图片转存中…(img-NvH2wCRv-1711679238362)]

[外链图片转存中…(img-8Qzy8Hqi-1711679238362)]

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

[外链图片转存中…(img-ORxydUkm-1711679238363)]

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

如果你觉得这些内容对你有帮助，可以扫码获取！！（资料价值较高，非无偿）

最后

本人分享一下这次字节跳动、美团、头条等大厂的面试真题涉及到的知识点，以及我个人的学习方法、学习路线等，当然也整理了一些学习文档资料出来是附赠给大家的。知识点涉及比较全面，包括但不限于前端基础，HTML，CSS，JavaScript，Vue，ES6，HTTP，浏览器，算法等等

详细大厂面试题答案、学习笔记、学习视频等资料领取，点击资料领取直通车！！

[外链图片转存中…(img-7PSy6P4p-1711679238363)]

前端视频资料：