1、使用 Object.entries() 和 Object.fromEntries() // 將對象轉換為數組並轉換回來,以便於操作 const person = { name: 'jack', age: 20 }; const entries = Object.entries(person); ...
1、使用 Object.entries() 和 Object.fromEntries()
// 將對象轉換為數組並轉換回來,以便於操作
const person = { name: 'jack', age: 20 };
const entries = Object.entries(person); // [['name', 'jack'],['age', 20]]
const newPerson = Object.fromEntries(entries); // { name: 'jack', age: 20 }
2、new Set()數組去重
const numbers = [1, 1, 2, 3, 4, 4, 5];
const uniqueNumbers = [...new Set(numbers)]; // [1, 2, 3, 4, 5]
3、使用 bind() 進行函數柯里化
function multiply(a, b) {
return a * b;
}
const double = multiply.bind(null, 2);
console.log(double(5)); // 10
bind()方法會創建一個新函數,稱為綁定函數,當調用這個綁定函數時,綁定函數會以創建它時傳入 bind()方法的第一個參數作為 this,傳入 bind() 方法的第二個以及以後的參數加上綁定函數運行時本身的參數按照順序作為原函數的參數來調用原函數。
上面代碼也可以改成如下:
function multiply(a, b) {
return a * b;
}
const double = multiply.bind(null, 2, 5);
console.log(double()); // 10
4、使用 Array.from() 將類似數組或可迭代的對象轉換為真正的數組
// 將類似數組或可迭代的對象轉換為真正的數組。
let nodeList = document.querySelectorAll('a');
let nodeArray = Array.from(nodeList);
5、可迭代對象的 for…of 迴圈
// 直接迭代可迭代對象(包括數組、映射、集合等)。
for (const value of ['a', 'b']) {
console.log(value);
}
結果:
a
b
6、使用 ^ 交換值
let b = 4;
a ^= b;
b ^= a;
a ^= b;
console.log(a, b); // a = 4, b = 2
這段JavaScript代碼使用了位異或(XOR)
運算符(^=)
來實現兩個變數a和b的數值交換,而不需要引入第三個臨時變數。位異或運算符^對兩個數的二進位表示進行操作,如果兩個相應的二進位位不相同,則結果為1;如果相同,則結果為0。
解析:
1.初始狀態:
let a = 2; // 二進位表示為 010
let b = 4; // 二進位表示為 100
2.第一步:a ^= b;
執行a ^= b;相當於a = a ^ b;。這裡,a和b進行位異或操作。
- a的二進位是010
- b的二進位是100
- a ^ b的結果是110(因為只有在一位上兩者不相同時,結果才為1)
- 因此,a的新值是110(即十進位的6)
現在
a = 6; // 二進位表示為 110
b = 4; // 二進位表示為 100
3.第二步:b ^= a;
執行b ^= a;,即b = b ^ a;。
- b的二進位是100
- a(更新後)的二進位是110
- b ^ a的結果是010(因為只有在b的第三位和a的第二位上兩者不同時,結果才為1)
- 因此,b的新值是010(即十進位的2,它原來是a的值)
現在,
a = 6; // 二進位表示為 110
b = 2; // 二進位表示為 010
4.第三步:a ^= b;
再次執行a ^= b;,即a = a ^ b;。
- a的二進位是110
- b(更新後)的二進位是010
- a ^ b的結果是100(因為只有在a的第二位和b的第二位上兩者不同時,結果才為1,其他位上相同則為0)
- 因此,a的新值是100(即十進位的4,它原來是b的值)
最終,
a = 4; // 二進位表示為 100
b = 2; // 二進位表示為 010
7、使用 flat() 展平數組
// 使用 flat() 方法輕鬆展平嵌套數組,展平深度作為可選參數。
const arr = [1, [2, [3, [4]]]];
const flatArr = arr.flat(Infinity);
console.log(flatArr); // [1, 2, 3, 4]
const arr2 = [{ a: 1 }, [3, { b: 2 }, [{ c: 3 }]]];
const flatArr2 = arr2.flat(Infinity);
console.log(flatArr2); // [{a:1},3,{b:2},{c:3}]
8、使用+將字元串轉換成數字
// 使用一元加法運算符快速將字元串或其他值轉換為數字。
const str = '123';
const num = +str;
console.log(num, typeof num); // 123 'number'
註意:不過其只適合用於字元串數據,否則將返回NaN
當然我們可以將該功能寫成一個函數,代碼如下:
function toNumber(strNumber) {
return +strNumber;
}
console.log(toNumber("1234")); // 1234
console.log(toNumber("ACB")); // NaN
這個也適用於Date,在本例中,它將返回的是時間戳數字:
console.log(+new Date()) // 1461288164385
9、Function.prototype.bind() 的強大功能
// 將函數綁定到上下文(此值)並部分應用參數,創建更可重用和模塊化的代碼。
const print = function (msg, mark) {
return `${msg}, ${this.name}${mark}`;
};
const printInfo = print.bind({ name: 'Tom' }, 'Hello');
console.log(printInfo('!')); // "Hello, Tom!"
10、Object.freeze()防止對象修改
// 使用 Object.freeze() 防止對對象的修改,使其不可變。為了實現更深層次的不變性,請考慮更徹底地實施不變性的庫或者遞歸調用freeze。
const obj = { name: 'Tom' };
Object.freeze(obj);
obj.name = 'Jack'; // error:Cannot assign to read only property 'name' of object '#<Object>'
11、使用Web Workers提高響應性和性能
於複雜和耗時的任務,可以考慮使用Web Workers。Web Workers允許你在後臺線程中運行JavaScript代碼,這樣就不會阻塞主線程,提高了應用的響應性和性能。
主線程中的耗時任務:
// 假設這是一個耗時的計算任務
function longRunOpert() {
let result = 0;
for (let i = 0; i < 10000; i++) {
result += i;
}
return result;
}
console.log(longRunOpert());
使用Web Worker,main.js代碼:
import Worker from './app.worker.js';
const worker = new Worker();
worker.postMessage({ code: 'start' });// 告訴worker開始執行代碼
worker.onmessage = function (e) {
console.log(`Result: ${e.data}`);
};
console.log('others things');
app.worker.js代碼:
self.onmessage = function (e) {
if (e.data.code === 'start') {
let result = 0;
for (let i = 0; i < 10000; i++) {
result += i;
}
self.postMessage(result);
}
};
最終列印結果以及順序:
others things
Result: 49995000
註:在vue工程中需要安裝worker-loader,併進行配置,如下webpack中rules配置
module: {
rules: [
.....
{
test: /\.worker\.js$/,
use: { loader: 'worker-loader' }
}
.....
]
},
12、 使用事件委托,避免大量的子元素添加事件監聽器
當為大量的子元素添加事件監聽器會增加記憶體的使用,導致頁面響應變慢。事件委托是一種技術,它利用了事件冒泡的原理
我們只在父元素上設置一個事件監聽器來管理所有子元素的事件。這種方法不僅減少了記憶體的使用,還簡化了事件處理器的管理。
不推薦的逐個添加事件監聽器(vue3):
<template>
<div class="container-main">
<div class="list">
<ul>
<li v-for="(item, index) in list" :key="item.id" class="list-item" @click="clickLi(item)">{{ item.title }}</li>
</ul>
</div>
</div>
</template>
<script setup>
import { reactive } from 'vue';
const list = reactive([
{ title: '列表一', id: 1 },
{ title: '列表二', id: 2 },
{ title: '列表三', id: 3 }
]);
const clickLi = (item) => {
console.log('li clicked');
console.log(item); // 當前對應的列表數據
};
</script>
推薦的事件委托方式(vue3):
<template>
<div class="container-main">
<div class="list">
<ul @click="clickLi">
<li v-for="(item, index) in list" :key="item.id" class="list-item" :data-index="index">{{ item.title }}</li>
</ul>
</div>
</div>
</template>
<script setup>
import { reactive } from 'vue';
const list = reactive([
{ title: '列表一', id: 1 },
{ title: '列表二', id: 2 },
{ title: '列表三', id: 3 }
]);
const clickLi = (e) => {
if (e.target.classList.contains('list-item')) {
console.log('li clicked');
const index = e.target.getAttribute('data-index');
const curLiObj = list[index];
console.log(curLiObj); // 當前對應的列表數據
}
};
</script>
從這兒可以看出,我們把事件綁定到了 ul上,當我們的數據特別多的時候,建議可以這樣去做,當然數據量小的情況下,第一種是我們習慣的編寫方式。
原生代碼操作DOM方式,不推薦的逐個添加事件監聽器:
document.querySelectorAll('.button').forEach(button => {
button.addEventListener('click', function() {
console.log('Button clicked!');
});
});
原生代碼操作DOM方式,推薦的事件委托方式:
document.addEventListener('click', function(e) {
if (e.target.classList.contains('button')) {
console.log('Button clicked!');
}
});
13、在迴圈中緩存array.length
這個技巧很簡單,這個在處理一個很大的數組迴圈時,對性能影響將是非常大的。基本上,大家都會寫一個這樣的同步迭代的數組:
for(let i = 0; i < array.length; i++) {
console.log(array[i]);
}
如果是一個小型數組,這樣做很好,如果你要處理的是一個大的數組,這段代碼在每次迭代都將會重新計算數組的大小,這將會導致一些延誤。為了避免這種現象出現,可以將array.length做一個緩存:
const length = array.length;
for(let i = 0; i < length; i++) {
console.log(array[i]);
}
你也可以寫在這樣:
for(let i = 0, length = array.length; i < length; i++) {
console.log(array[i]);
}
14、獲取數組中最後一個元素
Array.prototype.slice(begin,end)
用來獲取begin和end之間的數組元素。如果你不設置end參數,將會將數組的預設長度值當作end值。但有些同學可能不知道這個函數還可以接受負值作為參數。如果你設置一個負值作為begin的值,那麼你可以獲取數組的最後一個元素。如:
var array = [1,2,3,4,5,6];
console.log(array.slice(-1)); // [6]
console.log(array.slice(-2)); // [5,6]
console.log(array.slice(-3)); // [4,5,6]
15、數組截斷
這個小技巧主要用來鎖定數組的大小,如果用於刪除數組中的一些元素來說,是非常有用的。例如,你的數組有10個元素,但你只想只要前五個元素,那麼你可以通過array.length=5來截斷數組。如下麵這個示例:
let array = [1,2,3,4,5,6];
console.log(array.length); // 6
array.length = 3;
console.log(array.length); // 3
console.log(array); // [1,2,3]
16、合併數組
如果你要合併兩個數組,一般情況之下你都會使用Array.concat()
函數:
const array1 = [1,2,3];
const array2 = [4,5,6];
console.log(array1.concat(array2)); // [1,2,3,4,5,6];
然後這個函數並不適合用來合併兩個大型的數組,因為其將消耗大量的記憶體來存儲新創建的數組。在這種情況之個,可以使用Array.push().apply(arr1,arr2)
來替代創建一個新數組。這種方法不是用來創建一個新的數組,其只是將第一個第二個數組合併在一起,同時減少記憶體的使用:
const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
array1.push.apply(array1, array2); // 6
console.log(array1); // [1,2,3,4,5,6];