JavaScript開發技巧必備【一】

风雨后见彩虹發表於2024-09-12
JavaScript

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];

相關文章