ArkTS內(nèi)存管理：避免內(nèi)存泄漏的9大策略

2024-12-04 09:49 更新

ArkTS 是鴻蒙生態(tài)的應(yīng)用開發(fā)語言，它在 TypeScript 的基礎(chǔ)上進(jìn)行了優(yōu)化和定制，以適應(yīng)鴻蒙系統(tǒng)的需求。

以下是在 ArkTS 中進(jìn)行有效的內(nèi)存管理和避免內(nèi)存泄漏：

1. 使用 const 和 let 合理聲明變量：

  • 使用 const 聲明那些不會重新賦值的變量，這有助于確保變量的不變性，并可能讓編譯器進(jìn)行更多的優(yōu)化。

  • 使用 let 聲明那些需要重新賦值的變量，避免使用 var，因為 var 會導(dǎo)致變量提升到函數(shù)作用域的頂部，可能會引起意外的錯誤。

    在 ArkTS 中，const 和 let 是用來聲明變量的關(guān)鍵字，它們在作用域和可變性方面有所不同。以下是使用 const 和 let 合理聲明變量的示例代碼對比：

使用 const 聲明不變的變量：

  1. // 正確的使用方式：使用 const 聲明一個不會被重新賦值的變量
  2. const PI = 3.14159; // PI 是一個常量，不應(yīng)該被重新賦值
  5. // 嘗試重新賦值將會導(dǎo)致編譯錯誤
  6. // PI = 3.14; // Error: Cannot assign to 'PI' because it is a read-only property.

使用 let 聲明可變的變量：

  1. // 正確的使用方式：使用 let 聲明一個可能會被重新賦值的變量
  2. let count = 0; // count 是一個變量，可以被重新賦值
  5. // 可以重新賦值
  6. count = 1;
  7. console.log(count); // 輸出：1

對比示例：

  1. function vgFunction() {
  2.   // 使用 const 聲明一個常量，表示這個變量不應(yīng)該被修改
  3.   const name = "VG";
  4.   console.log(name); // 輸出：VG
  7.   // 使用 let 聲明一個變量，表示這個變量可能會被修改
  8.   let age = 18;
  9.   console.log(age); // 輸出：18，永遠(yuǎn)18
  12.   // 根據(jù)某些條件修改變量
  13.   if (age < 30) {
  14.     age = 30;
  15.   }
  16.   console.log(age); // 輸出：30
  17. }
  20. vgFunction();

在這個例子中，name 被聲明為常量，表示它的值不應(yīng)該改變，而 age 被聲明為變量，表示它的值可能會改變。使用 const 和 let 可以清晰地表達(dá)出變量的預(yù)期用途，有助于代碼的可讀性和維護(hù)性。

避免使用 var 的示例：

  1. // 不推薦使用 var，因為它會提升變量到函數(shù)作用域的頂部
  2. function exampleFunction() {
  3.   var globalVar = "I name is VG"; // 這實際上是一個全局變量
  4.   console.log(globalVar); // 輸出：I name is VG
  5. }
  8. exampleFunction();
  9. console.log(globalVar); // 輸出：I name is VG

在這個例子中，使用 var 聲明的 globalVar 實際上是一個全局變量，即使它在函數(shù)內(nèi)部聲明。這可能會導(dǎo)致意外的副作用，因為全局變量可以在程序的任何地方被訪問和修改。因此，推薦使用 const 或 let 來替代 var。

2. 避免全局變量：

  • 盡量減少全局變量的使用，因為全局變量在整個應(yīng)用生命周期中都存在，難以管理，容易造成內(nèi)存泄漏。

全局變量是指在全局作用域中聲明的變量，它們可以在整個程序的任何地方被訪問和修改。過度使用全局變量可能會導(dǎo)致代碼難以維護(hù)、理解和調(diào)試，因為它們可以在任何地方被改變，增加了代碼的耦合性。以下是避免全局變量的示例代碼對比：

使用全局變量的示例：

  1. // 全局變量
  2. var globalCounter = 0;
  5. function increment() {
  6.   globalCounter++; // 直接修改全局變量
  7. }
  10. function decrement() {
  11.   globalCounter--; // 直接修改全局變量
  12. }
  15. increment();
  16. console.log(globalCounter); // 輸出：1
  17. decrement();
  18. console.log(globalCounter); // 輸出：0

在這個例子中，globalCounter 是一個全局變量，可以在 increment 和 decrement 函數(shù)中被直接訪問和修改。這可能會導(dǎo)致在程序的其他部分不小心修改了這個變量，從而產(chǎn)生難以追蹤的錯誤。

避免使用全局變量的示例：

  1. // 避免使用全局變量，改為使用局部變量和參數(shù)傳遞
  2. function counterManager() {
  3.   let counter = 0; // 局部變量
  6.   function increment() {
  7.     counter++; // 修改局部變量
  8.   }
  11.   function decrement() {
  12.     counter--; // 修改局部變量
  13.   }
  16.   return {
  17.     increment: increment,
  18.     decrement: decrement,
  19.     getCount: function () {
  20.       return counter;
  21.     }
  22.   };
  23. }
  26. const counter = counterManager(); // 創(chuàng)建一個局部變量 counter 來持有管理器對象
  27. counter.increment();
  28. console.log(counter.getCount()); // 輸出：1
  29. counter.decrement();
  30. console.log(counter.getCount()); // 輸出：0

在這個例子中，我們創(chuàng)建了一個 counterManager 函數(shù)，它返回一個對象，包含 increment、decrement 和 getCount 方法。這些方法操作的是 counterManager 函數(shù)內(nèi)部的局部變量 counter，而不是全局變量。這樣，counter 的值就被封裝在 counterManager 函數(shù)的作用域內(nèi)，不會影響到全局作用域中的其他變量。

通過這種方式，我們減少了全局變量的使用，提高了代碼的封裝性和模塊化，使得代碼更易于維護(hù)和理解。同時，這也有助于避免全局變量可能引起的命名沖突和意外的副作用。

3. 使用弱引用（Weak References）：

  • 對于不需要長期持有的對象，可以使用弱引用，這樣垃圾回收器可以更容易地回收這些對象。

在 ArkTS 或 TypeScript 中，并沒有內(nèi)置的弱引用（Weak References）概念，這是因為 JavaScript 引擎（包括 V8，即 Node.js 和大多數(shù)瀏覽器的 JavaScript 引擎）默認(rèn)就是使用垃圾回收來管理內(nèi)存的。弱引用通常是指那些不阻止垃圾回收器回收其所引用對象的引用。

然而，我們可以通過一些設(shè)計模式來模擬弱引用的行為，尤其是在處理大型對象或者循環(huán)引用時。如何避免循環(huán)引用導(dǎo)致的內(nèi)存泄漏，來看這個例子：

可能導(dǎo)致內(nèi)存泄漏的循環(huán)引用示例：

  1. class Person {
  2.   name: string;
  3.   friends: Person[]; // 朋友列表
  6.   constructor(name: string) {
  7.     this.name = name;
  8.     this.friends = [];
  9.   }
  12.   addFriend(friend: Person) {
  13.     this.friends.push(friend);
  14.     // 這里創(chuàng)建了一個循環(huán)引用，friend.friends.push(this) 會使得 person 和 friend 互相引用
  15.     friend.friends.push(this);
  16.   }
  17. }
  20. const personA = new Person("VG");
  21. const personB = new Person("Vin");
  22. personA.addFriend(personB);
  23. // 此時，personA 和 personB 互相引用，形成了循環(huán)引用

在這個例子中，Person 類的每個實例都維護(hù)了一個朋友列表，當(dāng)一個 Person 實例被添加到另一個 Person 實例的朋友列表時，同時也將后者添加到前者的朋友列表中，形成了循環(huán)引用。

避免循環(huán)引用的示例：

為了避免循環(huán)引用，我們可以不直接在 Person 類中添加彼此的引用，而是通過其他方式來管理這種關(guān)系，比如使用一個外部的映射或者服務(wù)來管理朋友關(guān)系。

  1. class Person {
  2.   name: string;
  3.   friends: string[]; // 朋友列表，只存儲名字而不是直接引用對象
  6.   constructor(name: string) {
  7.     this.name = name;
  8.     this.friends = [];
  9.   }
  12.   addFriend(name: string) {
  13.     this.friends.push(name);
  14.     // 這里不再創(chuàng)建循環(huán)引用，而是將朋友的名字添加到列表中
  15.   }
  16. }
  19. const personA = new Person("VG");
  20. const personB = new Person("Vin");
  21. personA.addFriend(personB.name);
  22. // 此時，personA 的 friends 列表中只有 personB 的名字，不會造成循環(huán)引用

在這個改進(jìn)的例子中，我們不再直接將 Person 對象添加到朋友列表中，而是只存儲朋友的名字。這樣，即使 Person 對象之間有多個連接，也不會形成循環(huán)引用，從而避免了潛在的內(nèi)存泄漏問題。

如何通過設(shè)計模式來避免循環(huán)引用，這是在 JavaScript 和 TypeScript 中管理內(nèi)存和避免內(nèi)存泄漏的一種常用方法。在某些特定的 JavaScript 環(huán)境中，如 Node.js，可以使用弱引用（WeakRef）和弱映射（WeakMap）這樣的內(nèi)置對象來更直接地實現(xiàn)弱引用。但在大多數(shù)前端 JavaScript 環(huán)境中，這些對象并不可用。

4. 及時清理不再使用的對象：

  • 當(dāng)對象不再需要時，應(yīng)該手動將其設(shè)置為 null 或刪除其引用，這樣垃圾回收器可以回收這部分內(nèi)存。

在 JavaScript 或 TypeScript 中，及時清理不再使用的對象是避免內(nèi)存泄漏的重要策略。這通常涉及到移除事件監(jiān)聽器、取消網(wǎng)絡(luò)請求、銷毀定時器等操作。以下是一個業(yè)務(wù)場景的示例代碼對比，展示如何及時清理不再使用的對象：

未及時清理不再使用的對象示例：

  1. // 假設(shè)我們有一個組件，它在加載時訂閱了一個事件
  2. class Component {
  3.   private eventListener: () => void;
  6.   constructor() {
  7.     this.eventListener = () => {
  8.       console.log('Event triggered');
  9.     };
  10.     document.addEventListener('customEvent', this.eventListener);
  11.   }
  14.   // 組件被銷毀時，應(yīng)該清理事件監(jiān)聽器
  15.   destroy() {
  16.     // 忘記移除事件監(jiān)聽器
  17.     // document.removeEventListener('customEvent', this.eventListener);
  18.   }
  19. }
  22. const myComponent = new Component();
  23. // 當(dāng)組件不再需要時，應(yīng)該調(diào)用 destroy 方法
  24. // myComponent.destroy();

在這個例子中，Component 類在構(gòu)造時添加了一個事件監(jiān)聽器，但在 destroy 方法中忘記移除這個監(jiān)聽器。如果 myComponent 被銷毀而沒有調(diào)用 destroy 方法，事件監(jiān)聽器仍然存在，這將導(dǎo)致內(nèi)存泄漏，因為 myComponent 和它的 eventListener 方法仍然被事件監(jiān)聽器引用。

及時清理不再使用的對象示例：

  1. class Component {
  2.   private eventListener: () => void;
  5.   constructor() {
  6.     this.eventListener = () => {
  7.       console.log('Event triggered');
  8.     };
  9.     document.addEventListener('customEvent', this.eventListener);
  10.   }
  13.   // 組件被銷毀時，及時清理事件監(jiān)聽器
  14.   destroy() {
  15.     document.removeEventListener('customEvent', this.eventListener);
  16.   }
  17. }
  20. const myComponent = new Component();
  21. // 當(dāng)組件不再需要時，調(diào)用 destroy 方法
  22. myComponent.destroy();

在這個改進(jìn)的例子中，Component 類在 destroy 方法中正確地移除了事件監(jiān)聽器。這樣，當(dāng)組件不再需要時，通過調(diào)用 destroy 方法，可以確保不會有任何遺留的引用，從而避免內(nèi)存泄漏。

使用定時器時及時清理示例：

  1. class TimerComponent {
  2.   private timerId: number;
  5.   constructor() {
  6.     this.timerId = window.setInterval(() => {
  7.       console.log('Timer tick');
  8.       // 定時器執(zhí)行的代碼
  9.     }, 1000);
  10.   }
  13.   // 組件被銷毀時，清除定時器
  14.   destroy() {
  15.     clearInterval(this.timerId);
  16.   }
  17. }
  20. const myTimerComponent = new TimerComponent();
  21. // 當(dāng)定時器組件不再需要時，調(diào)用 destroy 方法
  22. // myTimerComponent.destroy();

在這個例子中，TimerComponent 類使用 setInterval 創(chuàng)建了一個定時器。在 destroy 方法中，使用 clearInterval 清除了定時器，這樣可以避免定時器繼續(xù)執(zhí)行并引用 TimerComponent 實例，從而避免內(nèi)存泄漏。

我們可以看到及時清理不再使用的對象對于防止內(nèi)存泄漏是多么重要。在實際開發(fā)中，我們應(yīng)該養(yǎng)成良好的習(xí)慣，確保在對象不再需要時，清理所有相關(guān)的資源。

5. 使用事件監(jiān)聽時注意移除監(jiān)聽器：

  • 在添加事件監(jiān)聽器時，確保在不需要監(jiān)聽時移除它們，否則即使對象本身不再被使用，事件監(jiān)聽器也會保持對象的引用，導(dǎo)致內(nèi)存泄漏。

在 JavaScript 或 TypeScript 中，使用事件監(jiān)聽是常見的交互方式，但如果沒有在適當(dāng)?shù)臅r候移除監(jiān)聽器，可能會導(dǎo)致內(nèi)存泄漏。如何正確地添加和移除事件監(jiān)聽器，上代碼：

未移除事件監(jiān)聽器的示例：

  1. class Widget {
  2.   private element: HTMLElement;
  5.   constructor(selector: string) {
  6.     this.element = document.querySelector(selector)!;
  7.     this.element.addEventListener('click', this.handleClick);
  8.   }
  11.   // 處理點擊事件的方法
  12.   handleClick = () => {
  13.     console.log('Widget clicked');
  14.   }
  17.   // 假設(shè)有一個方法來銷毀 Widget 實例，但沒有移除事件監(jiān)聽器
  18.   destroy() {
  19.     // 應(yīng)該在這里移除事件監(jiān)聽器，但被遺漏了
  20.     // this.element.removeEventListener('click', this.handleClick);
  21.   }
  22. }
  25. const widget = new Widget('#myWidget');
  26. // 當(dāng) widget 不再需要時，應(yīng)該調(diào)用 destroy 方法
  27. // widget.destroy();

在這個例子中，Widget 類在構(gòu)造函數(shù)中為元素添加了一個點擊事件監(jiān)聽器。然而，在 destroy 方法中，我們忘記了移除這個監(jiān)聽器。如果 widget 實例被銷毀而沒有調(diào)用 destroy 方法，事件監(jiān)聽器仍然存在，這將導(dǎo)致 Widget 實例和它的 handleClick 方法被持續(xù)引用，從而造成內(nèi)存泄漏。

正確移除事件監(jiān)聽器的示例：

  1. class Widget {
  2.   private element: HTMLElement;
  5.   constructor(selector: string) {
  6.     this.element = document.querySelector(selector)!;
  7.     this.element.addEventListener('click', this.handleClick);
  8.   }
  11.   // 處理點擊事件的方法
  12.   handleClick = () => {
  13.     console.log('Widget clicked');
  14.   }
  17.   // 銷毀 Widget 實例，并移除事件監(jiān)聽器
  18.   destroy() {
  19.     this.element.removeEventListener('click', this.handleClick);
  20.   }
  21. }
  24. const widget = new Widget('#myWidget');
  25. // 當(dāng) widget 不再需要時，調(diào)用 destroy 方法
  26. widget.destroy();

在這個改進(jìn)的例子中，Widget 類在 destroy 方法中正確地移除了點擊事件監(jiān)聽器。這樣，當(dāng) widget 實例不再需要時，通過調(diào)用 destroy 方法，可以確保不會有任何遺留的引用，從而避免內(nèi)存泄漏。

使用事件委托的示例：

  1. class WidgetManager {
  2.   private container: HTMLElement;
  5.   constructor(selector: string) {
  6.     this.container = document.querySelector(selector)!;
  7.     this.container.addEventListener('click', this.handleClick);
  8.   }
  11.   // 使用事件委托來處理子元素的點擊事件
  12.   handleClick = (event: MouseEvent) => {
  13.     const target = event.target as HTMLElement;
  14.     if (target.classList.contains('widget')) {
  15.       console.log('Widget clicked');
  16.     }
  17.   }
  20.   // 銷毀 WidgetManager 實例，并移除事件監(jiān)聽器
  21.   destroy() {
  22.     this.container.removeEventListener('click', this.handleClick);
  23.   }
  24. }
  27. const widgetManager = new WidgetManager('#widgetsContainer');
  28. // 當(dāng) widgetManager 不再需要時，調(diào)用 destroy 方法
  29. widgetManager.destroy();

在這個例子中，WidgetManager 類使用事件委托來處理所有子元素的點擊事件。這樣做的好處是，即使子元素是后來動態(tài)添加的，我們也不需要為它們單獨添加事件監(jiān)聽器。當(dāng) widgetManager 實例不再需要時，通過調(diào)用 destroy 方法，可以移除事件監(jiān)聽器，避免內(nèi)存泄漏。

我們可以看到在適當(dāng)?shù)臅r候移除事件監(jiān)聽器對于防止內(nèi)存泄漏是多么重要。在實際開發(fā)中，我們應(yīng)該確保在組件或?qū)ο箐N毀時，清理所有相關(guān)的事件監(jiān)聽器。

6. 合理使用閉包：

  • 閉包可以持續(xù)訪問函數(shù)外部的變量，如果不當(dāng)使用，可能會導(dǎo)致內(nèi)存泄漏。確保在不需要閉包時釋放相關(guān)資源。

    閉包是一個強大的特性，它允許一個函數(shù)訪問其定義時的作用域鏈。然而，不當(dāng)使用閉包可能會導(dǎo)致內(nèi)存泄漏，因為閉包會保持對外部作用域的引用，從而阻止垃圾回收。

不當(dāng)使用閉包的示例：

  1. // 假設(shè)我們有一個函數(shù)，用于創(chuàng)建計數(shù)器
  2. function createCounter() {
  3.   let count = 0;
  4.   return function() {
  5.     console.log(++count);
  6.   };
  7. }
  10. const counter = createCounter();
  11. counter(); // 輸出：1
  12. counter(); // 輸出：2
  15. // 假設(shè)我們不再需要這個計數(shù)器，但是由于閉包，count 變量仍然被引用
  16. // 這可能會導(dǎo)致內(nèi)存泄漏，如果 createCounter 被頻繁調(diào)用

在這個例子中，每次調(diào)用 createCounter 都會創(chuàng)建一個新的閉包，它捕獲了 count 變量。如果 createCounter 被頻繁調(diào)用，每個閉包都會保持對 count 的引用，即使 counter 函數(shù)不再被使用。

合理使用閉包的示例：

  1. // 改進(jìn)后的計數(shù)器函數(shù)，使用一個外部對象來存儲計數(shù)
  2. const counter = (function() {
  3.   let count = 0;
  4.   return {
  5.     increment: function() {
  6.       console.log(++count);
  7.     },
  8.     value: function() {
  9.       return count;
  10.     }
  11.   };
  12. })();
  15. counter.increment(); // 輸出：1
  16. counter.increment(); // 輸出：2
  19. // 當(dāng)計數(shù)器不再需要時，可以將其設(shè)置為 null，幫助垃圾回收器回收內(nèi)存
  20. counter = null;

在這個改進(jìn)的例子中，我們使用了一個立即執(zhí)行的函數(shù)表達(dá)式（IIFE）來創(chuàng)建一個包含 count 變量的對象。這樣，所有的計數(shù)器都共享同一個 count 變量，而不是每個閉包都有自己的副本。當(dāng)計數(shù)器不再需要時，我們可以將 counter 設(shè)置為 null，這有助于垃圾回收器回收內(nèi)存。

使用閉包進(jìn)行數(shù)據(jù)綁定的示例：

  1. // 一個簡單的數(shù)據(jù)綁定函數(shù)
  2. function bindData(element, data) {
  3.   const template = document.createElement('div');
  4.   template.innerHTML = `<strong>${data.name}</strong>: ${data.value}`;
  5.   element.appendChild(template);
  8.   // 使用閉包來更新數(shù)據(jù)
  9.   return function update(newData) {
  10.     template.innerHTML = `<strong>${newData.name}</strong>: ${newData.value}`;
  11.   };
  12. }
  15. const dataWidget = bindData(document.body, { name: 'Initial', value: 'Data' });
  16. dataWidget({ name: 'Updated', value: 'Data' });
  17. // 當(dāng)數(shù)據(jù)綁定不再需要時，可以將其設(shè)置為 null
  18. dataWidget = null;

在這個例子中，bindData 函數(shù)創(chuàng)建了一個閉包，用于更新綁定到 DOM 元素的數(shù)據(jù)。當(dāng)數(shù)據(jù)更新時，我們調(diào)用返回的 update 函數(shù)。當(dāng)數(shù)據(jù)綁定不再需要時，我們可以將 dataWidget 設(shè)置為 null，這有助于垃圾回收器回收內(nèi)存。

我們應(yīng)該確保在不需要閉包時釋放相關(guān)資源，以避免不必要的內(nèi)存占用。

7. 利用垃圾回收機制：

  • 理解 ArkTS 的垃圾回收機制，合理組織代碼結(jié)構(gòu)，以便于垃圾回收器高效工作。

在 ArkTS 中，利用垃圾回收機制同樣重要，因為它可以幫助開發(fā)者管理內(nèi)存，避免內(nèi)存泄漏：

不利用垃圾回收機制的示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   private resource: any;
  7.   build() {
  8.     // 假設(shè)這里加載了一個資源，但沒有提供釋放資源的方法
  9.     this.resource = this.loadResource('resource.json');
  10.   }
  13.   private loadResource(url: string): any {
  14.     // 資源加載邏輯
  15.     return new ResourceData();
  16.   }
  19.   // 組件銷毀時，沒有釋放資源
  20.   onDestroy() {
  21.     // 應(yīng)該在這里釋放資源，但被遺漏了
  22.   }
  23. }

在這個例子中，MyComponent 組件在 build 方法中加載了一個資源，但沒有提供釋放資源的方法。在組件銷毀時，也沒有釋放資源，這可能會導(dǎo)致內(nèi)存泄漏。

利用垃圾回收機制的示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   private resource: any;
  7.   build() {
  8.     // 假設(shè)這里加載了一個資源，并提供了釋放資源的方法
  9.     this.resource = this.loadResource('resource.json');
  10.   }
  13.   private loadResource(url: string): any {
  14.     // 資源加載邏輯
  15.     return new ResourceData();
  16.   }
  19.   private releaseResource() {
  20.     // 釋放資源邏輯
  21.     this.resource = null;
  22.   }
  25.   // 組件銷毀時，釋放資源
  26.   onDestroy() {
  27.     this.releaseResource();
  28.   }
  29. }

在這個改進(jìn)的例子中，MyComponent 組件在 build 方法中加載了一個資源，并在 releaseResource 方法中提供了釋放資源的邏輯。在組件銷毀時，調(diào)用 releaseResource 方法來釋放資源，這樣可以幫助垃圾回收器回收資源占用的內(nèi)存。

利用垃圾回收機制的另一個示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   private timerId: number;
  7.   build() {
  8.     // 設(shè)置一個定時器，用于定期執(zhí)行某些操作
  9.     this.timerId = setInterval(() => {
  10.       this.performTask();
  11.     }, 1000);
  12.   }
  15.   private performTask() {
  16.     // 執(zhí)行某些任務(wù)
  17.     console.log('Task performed');
  18.   }
  21.   // 組件銷毀時，清除定時器
  22.   onDestroy() {
  23.     clearInterval(this.timerId);
  24.   }
  25. }

在這個例子中，MyComponent 組件在 build 方法中設(shè)置了一個定時器。在組件銷毀時，調(diào)用 clearInterval 來清除定時器，這樣可以避免定時器繼續(xù)執(zhí)行并引用組件，從而避免內(nèi)存泄漏。

我們可以看到在 ArkTS 中如何通過編寫良好的代碼習(xí)慣來配合垃圾回收機制，確保及時釋放不再需要的資源。

8. 避免不必要的對象創(chuàng)建：

  • 在循環(huán)或頻繁調(diào)用的函數(shù)中，避免創(chuàng)建不必要的新對象，這會增加垃圾回收的負(fù)擔(dān)。

在 ArkTS 中，避免不必要的對象創(chuàng)建是優(yōu)化性能和內(nèi)存使用的一個重要方面。如何在 ArkTS 中避免不必要的對象創(chuàng)建呢，來看一下代碼示例：

不必要的對象創(chuàng)建示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   build() {
  5.     for (let i = 0; i < 1000; i++) {
  6.       // 在循環(huán)中創(chuàng)建了1000個不必要的新對象
  7.       const data = this.createDataObject(i);
  8.       console.log(data);
  9.     }
  10.   }
  13.   private createDataObject(index: number): DataObject {
  14.     // 假設(shè) DataObject 是一個復(fù)雜的對象
  15.     return new DataObject(index);
  16.   }
  17. }
  20. class DataObject {
  21.   constructor(public index: number) {
  22.     // 構(gòu)造函數(shù)中可能包含一些初始化邏輯
  23.   }
  24. }

在這個例子中，MyComponent 組件的 build 方法在循環(huán)中創(chuàng)建了1000個 DataObject 實例。如果這些對象在循環(huán)之后不再需要，這種創(chuàng)建和立即丟棄的做法會導(dǎo)致不必要的內(nèi)存分配和潛在的性能問題。

避免不必要的對象創(chuàng)建示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   private dataObjects: DataObject[] = [];
  7.   build() {
  8.     for (let i = 0; i < 1000; i++) {
  9.       // 復(fù)用已有的對象，而不是在每次迭代中創(chuàng)建新對象
  10.       if (!this.dataObjects[i]) {
  11.         this.dataObjects[i] = this.createDataObject(i);
  12.       } else {
  13.         this.dataObjects[i].update(i); // 假設(shè) DataObject 有一個更新方法
  14.       }
  15.       console.log(this.dataObjects[i]);
  16.     }
  17.   }
  20.   private createDataObject(index: number): DataObject {
  21.     return new DataObject(index);
  22.   }
  23. }
  26. class DataObject {
  27.   constructor(public index: number) {
  28.   }
  31.   update(newIndex: number) {
  32.     this.index = newIndex;
  33.   }
  34. }

在這個改進(jìn)的例子中，MyComponent 組件維護(hù)了一個 DataObject 數(shù)組。在循環(huán)中，它首先檢查是否已經(jīng)存在對象，如果不存在，則創(chuàng)建新對象；如果已存在，則調(diào)用 update 方法更新對象的數(shù)據(jù)。這種方式避免了在每次迭代中創(chuàng)建新對象，從而減少了內(nèi)存分配和提高了性能。

使用對象池模式避免不必要的對象創(chuàng)建示例：

  1. @Entry
  2. @Component
  3. struct MyComponent {
  4.   private objectPool: DataObject[] = new Array(1000).fill(null).map(() => new DataObject());
  7.   build() {
  8.     for (let i = 0; i < 1000; i++) {
  9.       // 從對象池中獲取對象，而不是每次都創(chuàng)建新對象
  10.       const data = this.objectPool[i];
  11.       data.update(i);
  12.       console.log(data);
  13.     }
  14.   }
  15. }
  18. class DataObject {
  19.   constructor(public index: number) {
  20.   }
  23.   update(newIndex: number) {
  24.     this.index = newIndex;
  25.   }
  26. }

在這個例子中，MyComponent 組件使用了一個對象池來管理 DataObject 實例。對象池在組件初始化時一次性創(chuàng)建了足夠數(shù)量的對象，并在循環(huán)中復(fù)用這些對象。這種方法可以顯著減少對象創(chuàng)建和銷毀的開銷，特別是在對象生命周期短且頻繁創(chuàng)建銷毀的場景中。

開發(fā)中，我們要考慮對象的生命周期和使用場景，盡可能地復(fù)用對象，或者使用對象池模式來管理對象的創(chuàng)建和銷毀。

9. 使用對象池模式：

  • 對于頻繁創(chuàng)建和銷毀的對象，可以考慮使用對象池模式來重用對象，減少內(nèi)存分配和回收的開銷。

對象池模式是一種常用的優(yōu)化技術(shù)，特別是在處理大量短生命周期對象時，它可以幫助減少內(nèi)存分配和垃圾回收的開銷。我以游戲場景為例，來講一下如何使用對象池模式：

未使用對象池模式的示例：

  1. @Entry
  2. @Component
  3. struct GameComponent {
  4.   private poolSize: number = 10;
  7.   build() {
  8.     for (let i = 0; i < this.poolSize; i++) {
  9.       this.spawnEnemy();
  10.     }
  11.   }
  14.   private spawnEnemy() {
  15.     // 創(chuàng)建一個新的敵人對象
  16.     const enemy = new Enemy();
  17.     // 將敵人添加到游戲世界
  18.     this.addEnemyToGameWorld(enemy);
  19.   }
  22.   private addEnemyToGameWorld(enemy: Enemy) {
  23.     // 添加到游戲世界的邏輯
  24.     console.log('Enemy added to game world:', enemy);
  25.   }
  26. }
  29. class Enemy {
  30.   constructor() {
  31.     // 敵人對象的初始化邏輯
  32.     console.log('Enemy created');
  33.   }
  34. }

在這個例子中，GameComponent 組件在 build 方法中循環(huán)創(chuàng)建了10個 Enemy 對象。每次調(diào)用 spawnEnemy 方法都會創(chuàng)建一個新的 Enemy 實例，這在創(chuàng)建大量敵人時可能會導(dǎo)致性能問題。

使用對象池模式的示例：

  1. @Entry
  2. @Component
  3. struct GameComponent {
  4.   private enemyPool: Enemy[] = [];
  5.   private poolSize: number = 10;
  8.   onCreate() {
  9.     // 初始化敵人對象池
  10.     for (let i = 0; i < this.poolSize; i++) {
  11.       this.enemyPool.push(new Enemy());
  12.     }
  13.   }
  16.   build() {
  17.     for (let i = 0; i < this.poolSize; i++) {
  18.       this.spawnEnemy();
  19.     }
  20.   }
  23.   private spawnEnemy() {
  24.     // 從對象池中獲取一個敵人對象
  25.     const enemy = this.enemyPool.shift(); // 移除并獲取數(shù)組的第一個元素
  26.     if (enemy) {
  27.       // 將敵人添加到游戲世界
  28.       this.addEnemyToGameWorld(enemy);
  29.     } else {
  30.       // 如果對象池為空，則創(chuàng)建一個新的敵人對象
  31.       const newEnemy = new Enemy();
  32.       this.addEnemyToGameWorld(newEnemy);
  33.       this.enemyPool.push(newEnemy); // 將新創(chuàng)建的敵人對象放回池中
  34.     }
  35.   }
  38.   private addEnemyToGameWorld(enemy: Enemy) {
  39.     // 添加到游戲世界的邏輯
  40.     console.log('Enemy added to game world:', enemy);
  41.   }
  42. }
  45. class Enemy {
  46.   constructor() {
  47.     // 敵人對象的初始化邏輯
  48.     console.log('Enemy created');
  49.   }
  52.   reset() {
  53.     // 重置敵人對象的狀態(tài)，以便再次使用
  54.     console.log('Enemy reset for reuse');
  55.   }
  56. }

在這個改進(jìn)的例子中，GameComponent 組件使用了一個 enemyPool 數(shù)組作為對象池來管理 Enemy 對象。在 onCreate 方法中，我們預(yù)先創(chuàng)建了一定數(shù)量的 Enemy 對象并放入池中。當(dāng)需要創(chuàng)建新的敵人時，我們首先嘗試從對象池中獲取一個現(xiàn)有的對象。如果對象池為空，我們才創(chuàng)建一個新的敵人對象，并在添加到游戲世界后將其放回池中。此外，我們添加了一個 reset 方法來重置敵人對象的狀態(tài)，以便它可以被重復(fù)使用。

使用對象池模式可以顯著減少在游戲或動畫中創(chuàng)建和銷毀對象的次數(shù)，從而提高性能和減少內(nèi)存壓力。在 ArkTS 中，這種模式尤其適用于那些頻繁創(chuàng)建和銷毀對象的場景，如粒子系統(tǒng)、游戲中的敵人、子彈等。

最后

有效地管理 ArkTS 應(yīng)用中的內(nèi)存使用，減少內(nèi)存泄漏的風(fēng)險，并提高應(yīng)用的性能和穩(wěn)定性，這在 ArkTS編碼中同樣至關(guān)重要，你在使用 ArkTS的過程中，還有其它有效管理內(nèi)存的經(jīng)驗嗎，歡迎評論區(qū)告訴我，國產(chǎn)替代，支持鴻蒙，我們都是一份子。

以上內(nèi)容是否對您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號
微信公眾號

編程獅公眾號