前端工程師進階之旅-手撕代碼
主要包括一些作業中常用的方法，面試常問到的方法，還有一些不太了解，趁機深入了解的知識點，
廢話少說，直接干代碼就完事了，
資料型別判斷
使用 Object.prototype.toString 實作，
function myTypeof(data) {
return Object.prototype.toString.call(data).slice(8, -1).toLowerCase();
}
陣列去重
//new Set() 集合
//ES6提供了新的資料結構Set，它類似于陣列，但是成員的值都是唯一的，沒有重復的值，
function unique(arr) {
return [...new Set(arr)];
}
//陣列去重 filter
function unique(arr) {
return arr.filter((item, index, array) => {
return array.indexOf(item) === index;
});
}
// 陣列去重 forEach
function unique(arr) {
let res = [];
arr.forEach((item) => {
res.includes(item) ? "" : res.push(item);
});
return res;
}
陣列排序
// 快排排序
function quickSort(arr) {
// 陣列長度為1 直接回傳
if (arr.length <= 1) return arr
var left = [],
right = []
var centerIndex = Math.floor(arr.length / 2)
// 定義中間值
var center = arr[centerIndex];
for (let i = 0; i < arr.length; i++) {
// 小于中間值資料添加到left
if (arr[i] < center) {
left.push(arr[i])
} else if (arr[i] > center) {
// 大于中間值資料添加到right
right.push(arr[i])
}
}
// 遞回回傳 concat連接回傳資料
return quickSort(left).concat([center], quickSort(right))
}
// 冒泡排序
function bubbleSort(arr) {
for (var i = 0; i < arr.length - 1; i++) {
for (var j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
var temp = arr[j]
arr[j] = arr[i]
arr[i] = temp
}
}
}
return arr
}
陣列扁平化
//使用 Infinity，可展開任意深度的嵌套陣列
arr.flat(Infinity);
//適用JSON轉換
JSON.parse("[" + JSON.stringify(arr).replace(/\[|\]/g, "") + "]");
//遞回
function myFlat(arr) {
let res = [];
arr.forEach((item) => {
if (Array.isArray(item)) {
res = res.concat(myFlat(item));
} else {
res.push(item);
}
});
return res;
}
//some
function myFlat(arr) {
while (arr.some((res) => Array.isArray(res))) {
arr = [].concat(...arr);
}
return arr;
}
深拷貝深克隆
// 簡單克隆 無法復制函式
var newObj = JSON.parse(JSON.stringify(obj));
// 深克隆 無法克隆特殊實體 Date等
function deepClone(target) {
if (typeof target !== "object") {
return target;
}
var result;
if (Object.prototype.toString.call(target) == "[object Array]") {
// 陣列
result = [];
} else {
// 物件
result = {};
}
for (var prop in target) {
if (target.hasOwnProperty(prop)) {
result[prop] = deepClone(target[prop]);
}
}
return result;
}
//復雜版深克隆
function deepClone(target) {
if (typeof target !== "object") return target;
// 檢測RegDate型別創建特殊實體
let constructor = target.constructor;
if (/^(RegExp|Date)$/i.test(constructor.name)) {
return new constructor(target);
}
// 判斷型別
var result =
Object.prototype.toString.call(target) == "[object Array]" ? [] : {};
// 迭代回圈
for (var prop in target) {
if (target.hasOwnProperty(prop)) {
// 遞回
result[prop] = deepClone(target[prop]);
}
}
return result;
}
繼承方法
原型鏈繼承：
// 原型鏈繼承
// 問題：原型中的參考物件會被所有的實體共享，子類在實體化的時候不能給父類建構式傳參
function Father() {
this.hobby = ["coding", "eat"];
}
Father.prototype.skill = function () {
console.log("i will javascript");
};
function Son() {}
Son.prototype = new Father();
var father = new Father();
var son = new Son();
var son1 = new Son();
console.log(father.hobby); //[ 'coding', 'eat' ]
father.hobby.push("play");
console.log(father.hobby, son.hobby, son1.hobby);
//[ 'coding', 'eat', 'play' ] [ 'coding', 'eat' ] [ 'coding', 'eat' ]
son.hobby.push("hei");
console.log(father.hobby, son.hobby, son1.hobby);
//[ 'coding', 'eat', 'play' ] [ 'coding', 'eat', 'hei' ] [ 'coding', 'eat', 'hei' ]
son.skill(); //i will javascript
借用建構式實作繼承
// 原型鏈繼承
// 問題：方法需要定義在建構式內，因此每次創建子類實體都會創建一邊方法
function Father(name) {
this.name = name;
this.sayNmae = function () {
return this.name;
};
}
function Son(name) {
Father.call(this, name);
}
Son.prototype = new Father();
var father = new Father("wenbo");
var son = new Son("zhijian");
console.log(father.name, son.name); //wenbo zhijian
console.log(father.sayNmae(), son.sayNmae()); //wenbo zhijian
組合繼承
//組合繼承，結合原型鏈繼承和借用建構式，使用原型鏈繼承原型上的屬性和方法，借用建構式繼承實體屬性，
//即可以把方法定義在原型上實作重用，又可以讓每個實體都有自己的屬性
// 組合繼承
function Father(name) {
this.name = name;
}
Father.prototype.sayName = function () {
return this.name;
};
function Son(name, age) {
Father.call(this, name);
this.age = age;
}
Son.prototype = new Father();
Son.prototype.constructor = Son;
var son = new Son("yewen", 18);
console.log(son); //Son { name: 'yewen', age: 18 }
console.log(son.sayName()); //yewen
寄生式組合繼承
//寄生組合繼承
// 組合繼承會導致呼叫兩次父類建構式
function Father(name) {
this.name = name;
}
Father.prototype.sayName = function () {
return this.name;
};
function Son(name, age) {
Father.call(this, name);
this.age = age;
}
Son.prototype = Object.create(Father.prototype);
Son.prototype.constructor = Son;
class 實作繼承
// calss繼承
class Father {
constructor(name) {
this.name = name;
}
getName() {
return this.name;
}
}
class Son extends Father {
constructor(name, age) {
super(name);
this.age = age;
}
getAge() {
return this.age;
}
}
var son = new Son("heihei", 18);
console.log(son); //Son { name: 'heihei', age: 18 }
console.log(son.getName(), son.getAge()); //heihei 18
事件總線（發布訂閱模式）
class EventEmitter {
constructor() {
this.cache = {};
}
//添加訂閱
on(name, fn) {
if (this.cache[name]) {
this.cache[name].push(fn);
} else {
this.cache[name] = [fn];
}
}
//洗掉訂閱
off(name, fn) {
let tasks = this.cache[name];
if (tasks) {
const index = tasks.findIndex((f) => f === fn || f.callback === fn);
index >= 0 ? tasks.splice(index, 1) : "";
}
}
//發布事件
emit(name, once, ...args) {
if (this.cache[name]) {
// 創建副本
let tasks = this.cache[name].slice();
for (const fn of tasks) {
fn(...args);
}
once ? delete this.cache[name] : "";
}
}
}
let demo = new EventEmitter();
demo.on("wenbo", function (data) {
console.log("wenbo", data);
});
let fn1 = function (data) {
console.log("hello:", data);
};
demo.on("wenbo", fn1);
demo.emit("wenbo", false, "world");
demo.off("wenbo", fn1);
demo.emit("wenbo", false, "world");
//wenbo world
//hello: world
//wenbo world
防抖函式
function debounce(fun, wait) {
var timeId = null;
return function () {
var _this = this;
var _arg = arguments;
clearTimeout(timeId);
timeId = setTimeout(function () {
fun.apply(_this, _arg);
}, wait);
};
}
節流函式
function throttle(fun, wait) {
var lastTime = 0;
return function () {
var _this = this;
var _arg = arguments;
var nowTime = new Date().getTime();
if (nowTime - lastTime > wait) {
fun.apply(_this, _arg);
lastTime = nowTime;
}
};
}
圖片加載優化懶加載
// 獲取全部img元素 并且將類陣列轉化成陣列
let imgList = [...document.querySelectorAll("img")];
let len = imgList.length;
// 圖片懶加載
function imgLazyLoad() {
let count = 0;
return (function () {
let isLoadList = [];
imgList.forEach((item, index) => {
let h = item.getBoundingClientRect();
// 判斷圖片是否快要滾動道可視區域
if (h.top < window.innerHeight + 200) {
item.src = https://www.cnblogs.com/yevin/archive/2021/04/25/item.dataset.src;
console.log(item.dataset.src);
isLoadList.push(index);
count++;
// 全部加載 移出scroll事件
if (len == count) {
document.removeEventListener("scroll", imgLazyLoad);
}
}
});
// 移出已經加載完成的圖片
imgList = imgList.filter((img, index) => !isLoadList.includes(index));
})();
}
// 節流函式
function throttle(fun, wait) {
var lastTime = 0;
return function () {
var _this = this;
var _arg = arguments;
var nowTime = new Date().getTime();
if (nowTime - lastTime > wait) {
fun.apply(_this, _arg);
lastTime = nowTime;
}
};
}
// 默認執行一次加載首屏圖片
imgLazyLoad();
// 節流執行
document.addEventListener("scroll", throttle(imgLazyLoad, 200));
管理操作Cookie
var cookie = {
//設定cookie
set: function (name, value, time) {
document.cookie = `${name}=${value};expires=${time};path=/`;
return this;
},
//獲取cookie
get: function (name) {
var arr;
var reg = new RegExp('(^| )' + name + '=([^;]*)(;|$)');
if ((arr = document.cookie.match(reg))) {
return unescape(arr[2]);
} else {
return null;
}
},
//移出token
remove: function (name) {
return this.setCookie(name, "", -1);
},
};
封裝 myForEach 方法
// thisValue 可選引數，當執行回呼函式 callback 時，用作 this 的值，
Array.prototype.myForEach = function (callback, thisValue) {
var _this
// 當this為空拋出例外
if (this == null) {
throw new TypeError(' this is null or not defined');
}
// var len = this.length
// this.length >>> 0 相當于 所有非數值轉換成0 ,所有大于等于 0 等數取整數部分
var len = this.length >>> 0
// callback不是函式時 拋出例外
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
// 判斷是夠有傳參 thisValue
if (arguments.length > 1) {
_this = thisValue
}
// 回圈遍歷
for (var i = 0; i < len; i++) {
// 回呼函式
callback.call(_this, this[i], i, this)
}
}
封裝 myFilter 方法
Array.prototype.myFilter = function (callback, thisValue) {
var _this
var arr = []
if (this == null) {
throw new TypeError(' this is null or not defined');
}
var len = this.length >>> 0
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
if (arguments.length > 1) {
_this = thisValue
}
for (var i = 0; i < len; i++) {
callback.call(_this, this[i], i, this) && arr.push(this[i])
}
return arr
}
封裝 myMap 方法
Array.prototype.myMAp = function (callback, thisValue) {
var _this
var arr = []
if (this == null) {
throw new TypeError(' this is null or not defined');
}
var len = this.length >>> 0
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
if (arguments.length > 1) {
_this = thisValue
}
for (var i = 0; i < len; i++) {
arr.push(callback.call(_this, this[i], i, this))
}
return arr
}
封裝 myEvery 方法
Array.prototype.myEvery = function (callback, thisValue) {
var _this
if (this == null) {
throw new TypeError(' this is null or not defined');
}
var len = this.length >>> 0
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
if (arguments.length > 1) {
_this = thisValue
}
for (var i = 0; i < len; i++) {
if (!callback.call(_this, this[i], i, this)) {
return false
}
}
return true
}
封裝 myReduce 方法
Array.prototype.myEvery = function (callback, initialValue) {
var value = https://www.cnblogs.com/yevin/archive/2021/04/25/0
console.log(value)
if (this == null) {
throw new TypeError(' this is null or not defined');
}
var len = this.length >>> 0
if (typeof callback !== "function") {
throw new TypeError(callback + ' is not a function');
}
if (arguments.length > 1) {
value = https://www.cnblogs.com/yevin/archive/2021/04/25/initialValue
}
for (var i = 0; i < len; i++) {
value = callback(value, this[i], i, this)
}
return value
}
獲取 URL 引數回傳物件
function getURLParam(url) {
let obj = {};
url.replace(/(?<=[?|&])(\w+)=(\w+)/g, function (data, key, value) {
if (obj[key]) {
obj[key] = [].concat(obj[key], value);
} else {
obj[key] = value;
}
});
return obj;
}
HTML 字串模板
function render(template, data) {
return template.replace(/\{(\w+)}/g, function ($1, key) {
return data[key] ? data[key] : "";
});
}
let html = "我叫{name},今年{id}歲，";
let data = https://www.cnblogs.com/yevin/archive/2021/04/25/{
name:"Yevin",
age: 18,
};
render(html, data); //我叫Yevin，今年18歲
利用 JSONP 實作跨域請求
function jsonp(url, callbackName) {
return new Promise((resolve, reject) => {
var script = document.createElement("script");
script.src = "https://www.cnblogs.com/yevin/archive/2021/04/25/demo.js";
document.body.appendChild(script);
window[callbackName] = function (res) {
//移除remove
script.remove();
//回傳資料
resolve(res);
};
});
}
原生 JS 封裝 AJAX
function Ajax(method, url, callback, data, async = true) {
var xhr;
//同一轉換method方法為大寫
method = method.toUpperCase();
// 開啟XMLHTTPRequest
xhr = new XMLHttpRequest();
// 監控狀態變化 執行回呼函式
xhr.onreadystatechange = function () {
if (xhr.readyState == 4 && xhr.readyState == 200) {
// 回呼函式回傳引數
callback(xhr.responseText);
}
};
// 判斷請求方式 get post或者其他
if (method == "GET") {
xhr.open("GET", url, async);
} else if (method == "POST") {
xhr.open("POST", url, async);
// 設定請求頭
xhr.setRequestHeader("Content-Type", "application/json");
// 發送引數
xhr.send(data);
}
}
函式柯里化
//把多個引數的函式變換成接受一個單一引數的函式，并且回傳接受余下的引數且回傳結果的新函式的技術
function curry(fun) {
let fn = function (...arg) {
if (arg.length == fun.length) return fun(...arg);
return (...arg2) => fn(...arg, ...arg2);
};
return fn;
}
function demo(a, b) {
return a * b;
}
console.log(demo(1, 2)); //2
console.log(curry(demo)(1)(2)); //2
偏函式
// 偏函式，就是固定一個函式的一個或者多個引數，回傳一個新的函式，這個函式用于接受剩余的引數，
function partial(fn, ...arg) {
return function (...args) {
return fn(...arg, ...args);
};
}
function demo(a, b, c) {
console.log(a, b, c); // 1, 2,3
}
var a = partial(demo, 1);
a(2, 3);
轉載請註明出處，本文鏈接：https://www.uj5u.com/qiye/280204.html
標籤：其他
上一篇：盒子布局