在 ArkTS 中，如何有效地進行記憶體管理和避免記憶體泄漏？

来源:https://www.cnblogs.com/wgjava/p/18435162
-Advertisement-
Play Games

ArkTS 是鴻蒙生態的應用開發語言，它在 TypeScript 的基礎上進行了優化和定製，以適應鴻蒙系統的需求。 以下是在 ArkTS 中進行有效的記憶體管理和避免記憶體泄漏： 1. 使用 const 和 let 合理聲明變數： 使用 const 聲明那些不會重新賦值的變數，這有助於確保變數的不變性， ...


ArkTS 是鴻蒙生態的應用開發語言，它在 TypeScript 的基礎上進行了優化和定製，以適應鴻蒙系統的需求。

以下是在 ArkTS 中進行有效的記憶體管理和避免記憶體泄漏：

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

  • 使用 const 聲明那些不會重新賦值的變數，這有助於確保變數的不變性，並可能讓編譯器進行更多的優化。
  • 使用 let 聲明那些需要重新賦值的變數，避免使用 var，因為 var 會導致變數提升到函數作用域的頂部，可能會引起意外的錯誤。

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

使用 const 聲明不變的變數：

// 正確的使用方式：使用 const 聲明一個不會被重新賦值的變數
const PI = 3.14159; // PI 是一個常量，不應該被重新賦值

// 嘗試重新賦值將會導致編譯錯誤
// PI = 3.14; // Error: Cannot assign to 'PI' because it is a read-only property.

使用 let 聲明可變的變數：

// 正確的使用方式：使用 let 聲明一個可能會被重新賦值的變數
let count = 0; // count 是一個變數，可以被重新賦值

// 可以重新賦值
count = 1;
console.log(count); // 輸出：1

對比示例：

function vgFunction() {
  // 使用 const 聲明一個常量，表示這個變數不應該被修改
  const name = "VG";
  console.log(name); // 輸出：VG

  // 使用 let 聲明一個變數，表示這個變數可能會被修改
  let age = 18;
  console.log(age); // 輸出：18，永遠18

  // 根據某些條件修改變數
  if (age < 30) {
    age = 30;
  }
  console.log(age); // 輸出：30
}

vgFunction();

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

避免使用 var 的示例：

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

exampleFunction();
console.log(globalVar); // 輸出：I name is VG

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

2. 避免全局變數：

  • 儘量減少全局變數的使用，因為全局變數在整個應用生命周期中都存在，難以管理，容易造成記憶體泄漏。

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

使用全局變數的示例：

// 全局變數
var globalCounter = 0;

function increment() {
  globalCounter++; // 直接修改全局變數
}

function decrement() {
  globalCounter--; // 直接修改全局變數
}

increment();
console.log(globalCounter); // 輸出：1
decrement();
console.log(globalCounter); // 輸出：0

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

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

// 避免使用全局變數，改為使用局部變數和參數傳遞
function counterManager() {
  let counter = 0; // 局部變數

  function increment() {
    counter++; // 修改局部變數
  }

  function decrement() {
    counter--; // 修改局部變數
  }

  return {
    increment: increment,
    decrement: decrement,
    getCount: function () {
      return counter;
    }
  };
}

const counter = counterManager(); // 創建一個局部變數 counter 來持有管理器對象
counter.increment();
console.log(counter.getCount()); // 輸出：1
counter.decrement();
console.log(counter.getCount()); // 輸出：0

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

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

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

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

在 ArkTS 或 TypeScript 中，並沒有內置的弱引用（Weak References）概念，這是因為 JavaScript 引擎（包括 V8，即 Node.js 和大多數瀏覽器的 JavaScript 引擎）預設就是使用垃圾回收來管理記憶體的。弱引用通常是指那些不阻止垃圾回收器回收其所引用對象的引用。

然而，我們可以通過一些設計模式來模擬弱引用的行為，尤其是在處理大型對象或者迴圈引用時。如何避免迴圈引用導致的記憶體泄漏，來看這個例子：

可能導致記憶體泄漏的迴圈引用示例：

class Person {
  name: string;
  friends: Person[]; // 朋友列表

  constructor(name: string) {
    this.name = name;
    this.friends = [];
  }

  addFriend(friend: Person) {
    this.friends.push(friend);
    // 這裡創建了一個迴圈引用，friend.friends.push(this) 會使得 person 和 friend 互相引用
    friend.friends.push(this);
  }
}

const personA = new Person("VG");
const personB = new Person("Vin");
personA.addFriend(personB);
// 此時，personA 和 personB 互相引用，形成了迴圈引用

在這個例子中，Person 類的每個實例都維護了一個朋友列表，當一個 Person 實例被添加到另一個 Person 實例的朋友列表時，同時也將後者添加到前者的朋友列表中，形成了迴圈引用。

避免迴圈引用的示例：

為了避免迴圈引用，我們可以不直接在 Person 類中添加彼此的引用，而是通過其他方式來管理這種關係，比如使用一個外部的映射或者服務來管理朋友關係。

class Person {
  name: string;
  friends: string[]; // 朋友列表，只存儲名字而不是直接引用對象

  constructor(name: string) {
    this.name = name;
    this.friends = [];
  }

  addFriend(name: string) {
    this.friends.push(name);
    // 這裡不再創建迴圈引用，而是將朋友的名字添加到列表中
  }
}

const personA = new Person("VG");
const personB = new Person("Vin");
personA.addFriend(personB.name);
// 此時，personA 的 friends 列表中只有 personB 的名字，不會造成迴圈引用

在這個改進的例子中，我們不再直接將 Person 對象添加到朋友列表中，而是只存儲朋友的名字。這樣，即使 Person 對象之間有多個連接，也不會形成迴圈引用，從而避免了潛在的記憶體泄漏問題。

如何通過設計模式來避免迴圈引用，這是在 JavaScript 和 TypeScript 中管理記憶體和避免記憶體泄漏的一種常用方法。在某些特定的 JavaScript 環境中，如 Node.js，可以使用弱引用（WeakRef）和弱映射（WeakMap）這樣的內置對象來更直接地實現弱引用。但在大多數前端 JavaScript 環境中，這些對象並不可用。

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

  • 當對象不再需要時，應該手動將其設置為 null 或刪除其引用，這樣垃圾回收器可以回收這部分記憶體。

在 JavaScript 或 TypeScript 中，及時清理不再使用的對象是避免記憶體泄漏的重要策略。這通常涉及到移除事件監聽器、取消網路請求、銷毀定時器等操作。以下是一個業務場景的示例代碼對比，展示如何及時清理不再使用的對象：

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

// 假設我們有一個組件，它在載入時訂閱了一個事件
class Component {
  private eventListener: () => void;

  constructor() {
    this.eventListener = () => {
      console.log('Event triggered');
    };
    document.addEventListener('customEvent', this.eventListener);
  }

  // 組件被銷毀時，應該清理事件監聽器
  destroy() {
    // 忘記移除事件監聽器
    // document.removeEventListener('customEvent', this.eventListener);
  }
}

const myComponent = new Component();
// 當組件不再需要時，應該調用 destroy 方法
// myComponent.destroy();

在這個例子中，Component 類在構造時添加了一個事件監聽器，但在 destroy 方法中忘記移除這個監聽器。如果 myComponent 被銷毀而沒有調用 destroy 方法，事件監聽器仍然存在，這將導致記憶體泄漏，因為 myComponent 和它的 eventListener 方法仍然被事件監聽器引用。

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

class Component {
  private eventListener: () => void;

  constructor() {
    this.eventListener = () => {
      console.log('Event triggered');
    };
    document.addEventListener('customEvent', this.eventListener);
  }

  // 組件被銷毀時，及時清理事件監聽器
  destroy() {
    document.removeEventListener('customEvent', this.eventListener);
  }
}

const myComponent = new Component();
// 當組件不再需要時，調用 destroy 方法
myComponent.destroy();

在這個改進的例子中，Component 類在 destroy 方法中正確地移除了事件監聽器。這樣，當組件不再需要時，通過調用 destroy 方法，可以確保不會有任何遺留的引用，從而避免記憶體泄漏。

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

class TimerComponent {
  private timerId: number;

  constructor() {
    this.timerId = window.setInterval(() => {
      console.log('Timer tick');
      // 定時器執行的代碼
    }, 1000);
  }

  // 組件被銷毀時，清除定時器
  destroy() {
    clearInterval(this.timerId);
  }
}

const myTimerComponent = new TimerComponent();
// 當定時器組件不再需要時，調用 destroy 方法
// myTimerComponent.destroy();

在這個例子中，TimerComponent 類使用 setInterval 創建了一個定時器。在 destroy 方法中，使用 clearInterval 清除了定時器，這樣可以避免定時器繼續執行並引用 TimerComponent 實例，從而避免記憶體泄漏。

我們可以看到及時清理不再使用的對象對於防止記憶體泄漏是多麼重要。在實際開發中，我們應該養成良好的習慣，確保在對象不再需要時，清理所有相關的資源。

5. 使用事件監聽時註意移除監聽器：

  • 在添加事件監聽器時，確保在不需要監聽時移除它們，否則即使對象本身不再被使用，事件監聽器也會保持對象的引用，導致記憶體泄漏。

在 JavaScript 或 TypeScript 中，使用事件監聽是常見的交互方式，但如果沒有在適當的時候移除監聽器，可能會導致記憶體泄漏。如何正確地添加和移除事件監聽器，上代碼：

未移除事件監聽器的示例：

class Widget {
  private element: HTMLElement;

  constructor(selector: string) {
    this.element = document.querySelector(selector)!;
    this.element.addEventListener('click', this.handleClick);
  }

  // 處理點擊事件的方法
  handleClick = () => {
    console.log('Widget clicked');
  }

  // 假設有一個方法來銷毀 Widget 實例，但沒有移除事件監聽器
  destroy() {
    // 應該在這裡移除事件監聽器，但被遺漏了
    // this.element.removeEventListener('click', this.handleClick);
  }
}

const widget = new Widget('#myWidget');
// 當 widget 不再需要時，應該調用 destroy 方法
// widget.destroy();

在這個例子中，Widget 類在構造函數中為元素添加了一個點擊事件監聽器。然而，在 destroy 方法中，我們忘記了移除這個監聽器。如果 widget 實例被銷毀而沒有調用 destroy 方法，事件監聽器仍然存在，這將導致 Widget 實例和它的 handleClick 方法被持續引用，從而造成記憶體泄漏。

正確移除事件監聽器的示例：

class Widget {
  private element: HTMLElement;

  constructor(selector: string) {
    this.element = document.querySelector(selector)!;
    this.element.addEventListener('click', this.handleClick);
  }

  // 處理點擊事件的方法
  handleClick = () => {
    console.log('Widget clicked');
  }

  // 銷毀 Widget 實例，並移除事件監聽器
  destroy() {
    this.element.removeEventListener('click', this.handleClick);
  }
}

const widget = new Widget('#myWidget');
// 當 widget 不再需要時，調用 destroy 方法
widget.destroy();

在這個改進的例子中，Widget 類在 destroy 方法中正確地移除了點擊事件監聽器。這樣，當 widget 實例不再需要時，通過調用 destroy 方法，可以確保不會有任何遺留的引用，從而避免記憶體泄漏。

使用事件委托的示例：

class WidgetManager {
  private container: HTMLElement;

  constructor(selector: string) {
    this.container = document.querySelector(selector)!;
    this.container.addEventListener('click', this.handleClick);
  }

  // 使用事件委托來處理子元素的點擊事件
  handleClick = (event: MouseEvent) => {
    const target = event.target as HTMLElement;
    if (target.classList.contains('widget')) {
      console.log('Widget clicked');
    }
  }

  // 銷毀 WidgetManager 實例，並移除事件監聽器
  destroy() {
    this.container.removeEventListener('click', this.handleClick);
  }
}

const widgetManager = new WidgetManager('#widgetsContainer');
// 當 widgetManager 不再需要時，調用 destroy 方法
widgetManager.destroy();

在這個例子中，WidgetManager 類使用事件委托來處理所有子元素的點擊事件。這樣做的好處是，即使子元素是後來動態添加的，我們也不需要為它們單獨添加事件監聽器。當 widgetManager 實例不再需要時，通過調用 destroy 方法，可以移除事件監聽器，避免記憶體泄漏。

我們可以看到在適當的時候移除事件監聽器對於防止記憶體泄漏是多麼重要。在實際開發中，我們應該確保在組件或對象銷毀時，清理所有相關的事件監聽器。

6. 合理使用閉包：

  • 閉包可以持續訪問函數外部的變數，如果不當使用，可能會導致記憶體泄漏。確保在不需要閉包時釋放相關資源。

閉包是一個強大的特性，它允許一個函數訪問其定義時的作用域鏈。然而，不當使用閉包可能會導致記憶體泄漏，因為閉包會保持對外部作用域的引用，從而阻止垃圾回收。

不當使用閉包的示例：

// 假設我們有一個函數，用於創建計數器
function createCounter() {
  let count = 0;
  return function() {
    console.log(++count);
  };
}

const counter = createCounter();
counter(); // 輸出：1
counter(); // 輸出：2

// 假設我們不再需要這個計數器，但是由於閉包，count 變數仍然被引用
// 這可能會導致記憶體泄漏，如果 createCounter 被頻繁調用

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

合理使用閉包的示例：

// 改進後的計數器函數，使用一個外部對象來存儲計數
const counter = (function() {
  let count = 0;
  return {
    increment: function() {
      console.log(++count);
    },
    value: function() {
      return count;
    }
  };
})();

counter.increment(); // 輸出：1
counter.increment(); // 輸出：2

// 當計數器不再需要時，可以將其設置為 null，幫助垃圾回收器回收記憶體
counter = null;

在這個改進的例子中，我們使用了一個立即執行的函數表達式（IIFE）來創建一個包含 count 變數的對象。這樣，所有的計數器都共用同一個 count 變數，而不是每個閉包都有自己的副本。當計數器不再需要時，我們可以將 counter 設置為 null，這有助於垃圾回收器回收記憶體。

使用閉包進行數據綁定的示例：

// 一個簡單的數據綁定函數
function bindData(element, data) {
  const template = document.createElement('div');
  template.innerHTML = `<strong>${data.name}</strong>: ${data.value}`;
  element.appendChild(template);

  // 使用閉包來更新數據
  return function update(newData) {
    template.innerHTML = `<strong>${newData.name}</strong>: ${newData.value}`;
  };
}

const dataWidget = bindData(document.body, { name: 'Initial', value: 'Data' });
dataWidget({ name: 'Updated', value: 'Data' });
// 當數據綁定不再需要時，可以將其設置為 null
dataWidget = null;

在這個例子中，bindData 函數創建了一個閉包，用於更新綁定到 DOM 元素的數據。當數據更新時，我們調用返回的 update 函數。當數據綁定不再需要時，我們可以將 dataWidget 設置為 null，這有助於垃圾回收器回收記憶體。

我們應該確保在不需要閉包時釋放相關資源，以避免不必要的記憶體占用。

7. 利用垃圾回收機制：

  • 理解 ArkTS 的垃圾回收機制，合理組織代碼結構，以便於垃圾回收器高效工作。

在 ArkTS 中，利用垃圾回收機制同樣重要，因為它可以幫助開發者管理記憶體，避免記憶體泄漏：

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

@Entry
@Component
struct MyComponent {
  private resource: any;

  build() {
    // 假設這裡載入了一個資源，但沒有提供釋放資源的方法
    this.resource = this.loadResource('resource.json');
  }

  private loadResource(url: string): any {
    // 資源載入邏輯
    return new ResourceData();
  }

  // 組件銷毀時，沒有釋放資源
  onDestroy() {
    // 應該在這裡釋放資源，但被遺漏了
  }
}

在這個例子中，MyComponent 組件在 build 方法中載入了一個資源，但沒有提供釋放資源的方法。在組件銷毀時，也沒有釋放資源，這可能會導致記憶體泄漏。

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

@Entry
@Component
struct MyComponent {
  private resource: any;

  build() {
    // 假設這裡載入了一個資源，並提供了釋放資源的方法
    this.resource = this.loadResource('resource.json');
  }

  private loadResource(url: string): any {
    // 資源載入邏輯
    return new ResourceData();
  }

  private releaseResource() {
    // 釋放資源邏輯
    this.resource = null;
  }

  // 組件銷毀時，釋放資源
  onDestroy() {
    this.releaseResource();
  }
}

在這個改進的例子中，MyComponent 組件在 build 方法中載入了一個資源，併在 releaseResource 方法中提供了釋放資源的邏輯。在組件銷毀時，調用 releaseResource 方法來釋放資源，這樣可以幫助垃圾回收器回收資源占用的記憶體。

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

@Entry
@Component
struct MyComponent {
  private timerId: number;

  build() {
    // 設置一個定時器，用於定期執行某些操作
    this.timerId = setInterval(() => {
      this.performTask();
    }, 1000);
  }

  private performTask() {
    // 執行某些任務
    console.log('Task performed');
  }

  // 組件銷毀時，清除定時器
  onDestroy() {
    clearInterval(this.timerId);
  }
}

在這個例子中，MyComponent 組件在 build 方法中設置了一個定時器。在組件銷毀時，調用 clearInterval 來清除定時器，這樣可以避免定時器繼續執行並引用組件，從而避免記憶體泄漏。

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

8. 避免不必要的對象創建：

  • 在迴圈或頻繁調用的函數中，避免創建不必要的新對象，這會增加垃圾回收的負擔。

在 ArkTS 中，避免不必要的對象創建是優化性能和記憶體使用的一個重要方面。如何在 ArkTS 中避免不必要的對象創建呢，來看一下代碼示例：

不必要的對象創建示例：

@Entry
@Component
struct MyComponent {
  build() {
    for (let i = 0; i < 1000; i++) {
      // 在迴圈中創建了1000個不必要的新對象
      const data = this.createDataObject(i);
      console.log(data);
    }
  }

  private createDataObject(index: number): DataObject {
    // 假設 DataObject 是一個複雜的對象
    return new DataObject(index);
  }
}

class DataObject {
  constructor(public index: number) {
    // 構造函數中可能包含一些初始化邏輯
  }
}

在這個例子中，MyComponent 組件的 build 方法在迴圈中創建了1000個 DataObject 實例。如果這些對象在迴圈之後不再需要，這種創建和立即丟棄的做法會導致不必要的記憶體分配和潛在的性能問題。

避免不必要的對象創建示例：

@Entry
@Component
struct MyComponent {
  private dataObjects: DataObject[] = [];

  build() {
    for (let i = 0; i < 1000; i++) {
      // 復用已有的對象，而不是在每次迭代中創建新對象
      if (!this.dataObjects[i]) {
        this.dataObjects[i] = this.createDataObject(i);
      } else {
        this.dataObjects[i].update(i); // 假設 DataObject 有一個更新方法
      }
      console.log(this.dataObjects[i]);
    }
  }

  private createDataObject(index: number): DataObject {
    return new DataObject(index);
  }
}

class DataObject {
  constructor(public index: number) {
  }

  update(newIndex: number) {
    this.index = newIndex;
  }
}

在這個改進的例子中，MyComponent 組件維護了一個 DataObject 數組。在迴圈中，它首先檢查是否已經存在對象，如果不存在，則創建新對象；如果已存在，則調用 update 方法更新對象的數據。這種方式避免了在每次迭代中創建新對象，從而減少了記憶體分配和提高了性能。

使用對象池模式避免不必要的對象創建示例：

@Entry
@Component
struct MyComponent {
  private objectPool: DataObject[] = new Array(1000).fill(null).map(() => new DataObject());

  build() {
    for (let i = 0; i < 1000; i++) {
      // 從對象池中獲取對象，而不是每次都創建新對象
      const data = this.objectPool[i];
      data.update(i);
      console.log(data);
    }
  }
}

class DataObject {
  constructor(public index: number) {
  }

  update(newIndex: number) {
    this.index = newIndex;
  }
}

在這個例子中，MyComponent 組件使用了一個對象池來管理 DataObject 實例。對象池在組件初始化時一次性創建了足夠數量的對象，併在迴圈中復用這些對象。這種方法可以顯著減少對象創建和銷毀的開銷，特別是在對象生命周期短且頻繁創建銷毀的場景中。

開發中，我們要考慮對象的生命周期和使用場景，儘可能地復用對象，或者使用對象池模式來管理對象的創建和銷毀。

9. 使用對象池模式：

  • 對於頻繁創建和銷毀的對象，可以考慮使用對象池模式來重用對象，減少記憶體分配和回收的開銷。

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

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

@Entry
@Component
struct GameComponent {
  private poolSize: number = 10;

  build() {
    for (let i = 0; i < this.poolSize; i++) {
      this.spawnEnemy();
    }
  }

  private spawnEnemy() {
    // 創建一個新的敵人對象
    const enemy = new Enemy();
    // 將敵人添加到游戲世界
    this.addEnemyToGameWorld(enemy);
  }

  private addEnemyToGameWorld(enemy: Enemy) {
    // 添加到游戲世界的邏輯
    console.log('Enemy added to game world:', enemy);
  }
}

class Enemy {
  constructor() {
    // 敵人對象的初始化邏輯
    console.log('Enemy created');
  }
}

在這個例子中，GameComponent 組件在 build 方法中迴圈創建了10個 Enemy 對象。每次調用 spawnEnemy 方法都會創建一個新的 Enemy 實例，這在創建大量敵人時可能會導致性能問題。

使用對象池模式的示例：

@Entry
@Component
struct GameComponent {
  private enemyPool: Enemy[] = [];
  private poolSize: number = 10;

  onCreate() {
    // 初始化敵人對象池
    for (let i = 0; i < this.poolSize; i++) {
      this.enemyPool.push(new Enemy());
    }
  }

  build() {
    for (let i = 0; i < this.poolSize; i++) {
      this.spawnEnemy();
    }
  }

  private spawnEnemy() {
    // 從對象池中獲取一個敵人對象
    const enemy = this.enemyPool.shift(); // 移除並獲取數組的第一個元素
    if (enemy) {
      // 將敵人添加到游戲世界
      this.addEnemyToGameWorld(enemy);
    } else {
      // 如果對象池為空，則創建一個新的敵人對象
      const newEnemy = new Enemy();
      this.addEnemyToGameWorld(newEnemy);
      this.enemyPool.push(newEnemy); // 將新創建的敵人對象放回池中
    }
  }

  private addEnemyToGameWorld(enemy: Enemy) {
    // 添加到游戲世界的邏輯
    console.log('Enemy added to game world:', enemy);
  }
}

class Enemy {
  constructor() {
    // 敵人對象的初始化邏輯
    console.log('Enemy created');
  }

  reset() {
    // 重置敵人對象的狀態，以便再次使用
    console.log('Enemy reset for reuse');
  }
}

在這個改進的例子中，GameComponent 組件使用了一個 enemyPool 數組作為對象池來管理 Enemy 對象。在 onCreate 方法中，我們預先創建了一定數量的 Enemy 對象並放入池中。當需要創建新的敵人時，我們首先嘗試從對象池中獲取一個現有的對象。如果對象池為空，我們才創建一個新的敵人對象，併在添加到游戲世界後將其放回池中。此外，我們添加了一個 reset 方法來重置敵人對象的狀態，以便它可以被重覆使用。

使用對象池模式可以顯著減少在游戲或動畫中創建和銷毀對象的次數，從而提高性能和減少記憶體壓力。在 ArkTS 中，這種模式尤其適用於那些頻繁創建和銷毀對象的場景，如粒子系統、游戲中的敵人、子彈等。

最後

有效地管理 ArkTS 應用中的記憶體使用，減少記憶體泄漏的風險，並提高應用的性能和穩定性，這在 ArkTS編碼中同樣至關重要，你在使用 ArkTS的過程中，還有其它有效管理記憶體的經驗嗎，歡迎評論區告訴我，國產替代，支持鴻蒙，我們都是一份子。


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 深入工作流調度的內核
    在大數據時代，工作流任務調度系統成為了數據處理和業務流程管理的核心組件，在大數據平臺的構建和開發過程中尤為重要。隨著數據量的激增和業務需求的多樣化，合理的任務調度不僅能夠提高資源利用率，還能保證業務流程的穩定和高效運行。本文將結合實際場景，探討目前市面上常見的工作流任務調度及其關鍵特性。 一、工作流 ...
  • 【YashanDB知識庫】windows配置ODBC跟蹤日誌， 使用日誌定位問題
    本文轉自YashanDB官網，具體內容請見https://www.yashandb.com/newsinfo/7441388.html?templateId=1718516 問題現象 客戶剛開始使用YashanDB odbc的時候，需要查看調用日誌詳情， 確認相應介面調用情況。 問題的風險及影響 客 ...
  • 歐拉系統postgresql 與PostGis 離線環境安裝
    postgresql 與PostGis 離線環境安裝 上傳文件至伺服器 #安裝所需依賴 yum install /opt/PGsql-13-gis/rpm/* -y Postgresql安裝 tar -zxvf postgresql-13.2.tar.gz #進入該目錄 ./configure -- ...
  • 讀數據湖倉01讓數據可信
    1. 讓數據可信 1.1. 每個終端用戶(End User)都有一個共同的需求：訪問想要的數據 1.2. 真的能夠相信我正在訪問的這些數據嗎？ 1.2.1. 終端用戶很快就會發現，訪問數據和相信正在訪問的數據是兩回事 1.2.2. 訪問數據和相信數據不是同一回事 1.2.3. 如果數據不可信，可能會 ...
  • Sql介紹 與 Sql基礎查詢
    Sql介紹 與 Sql基礎查詢 SQL SQL也稱為結構化查詢語言(Structure Query Language),是一種用於管理和操作關係型資料庫的標準化電腦語言,SQL語言廣泛應用於各種關係型資料庫系統(RDBMS)如Mysql,Oracle,Microsoft SQL Server等等 ...
  • Flutter 實現骨架屏
    什麼是骨架屏 在客戶端開發中，我們總是需要等待拿到服務端的響應後，再將內容呈現到頁面上，那麼在用戶發起請求到客戶端成功拿到響應的這段時間內，應該在屏幕上呈現點什麼好呢？ 答案是：骨架屏 那麼什麼是骨架屏呢，來問下 GPT： 骨架屏（Skeleton Screen）是一種現代的用戶界面設計技術，用於提 ...
  • 10款好用的開源 HarmonyOS 工具庫
    大家好，我是 V 哥，今天給大家分享10款好用的 HarmonyOS的工具庫，在開發鴻蒙應用時可以用下，好用的工具可以簡化代碼，讓你寫出優雅的應用來。廢話不多說，馬上開整。 1. efTool efTool是一個功能豐富且易用的相容API12的HarmonyOS工具庫，通過諸多實用工具類的使用，旨在 ...
  • FragmentContainerView、ViewPager、ViewPager2與 BottomNaviagtionView結合使用的區別
    現在市面的應用界面大多是通過一個Fragment容器+底部導航欄框架來實現頁面切換的，而當我們想要去搭建一個這樣的框架時，上層的Fragment容器是可選的，常見的有FragmentContanerView、ViewPager、ViewPager2。我們應該如何選擇呢？這時就需要考慮這三者的自身自帶 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類