Lima Corak Reka Bentuk yang perlu diketahui dalam Node.js

Hei!

Baru-baru ini saya telah melalui pelbagai sumber pengetahuan untuk mengetahui lebih lanjut tentang reka bentuk popular dan corak seni bina dalam Node.js. Matlamat saya adalah terutamanya di bahagian pelayan (belakang) tetapi semasa saya melaluinya, saya melihat banyak persamaan dengan rangka kerja pelayar (bahagian hadapan). Sesetengah daripada mereka bahkan digunakan secara langsung dalam rangka kerja yang saya lebih gembira kerana saya telah menggunakannya tanpa mengetahuinya ?

Terdapat banyak (sangat banyak) corak reka bentuk yang boleh anda gunakan, jadi dalam artikel ini, saya memutuskan untuk memilih 10 daripadanya dan menerangkannya dengan lebih terperinci.

Nikmati!

? Apakah Corak Reka Bentuk?

Corak reka bentuk adalah penyelesaian yang terbukti dan diuji pertempuran untuk menyelesaikan masalah yang kami sebagai pembangun hadapi setiap hari. Corak ini membantu menggalakkan amalan terbaik dan melaksanakan pendekatan berstruktur untuk menyelesaikan isu harian semasa mereka bentuk dan membangunkan seni bina perisian. Jurutera perisian boleh membangunkan sistem yang boleh diselenggara, selamat dan stabil dengan menggunakan corak ini.

Node.js kerana fleksibilitinya tidak memaksa anda untuk berpegang pada corak tertentu tetapi sebaliknya memberi anda kebebasan memilih hanya yang diperlukan untuk tugas anda. Itulah sebabnya pada pendapat saya ia digunakan secara meluas hari ini (dan dengan cara ini terima kasih kepada JavaScript :D).

✅ Lima Corak Reka Bentuk Popular dalam Node.js

Di bawah, anda akan melihat senarai 5 corak reka bentuk terpilih yang saya suka.

Singleton

Corak ini adalah mengenai kelas yang hanya boleh mempunyai satu tika dan menyediakan akses global kepadanya. Modul boleh dicache dan dikongsi merentas aplikasi dalam Node.js yang akan membantu meningkatkan kecekapan sumber. Contoh biasa corak tunggal sedemikian ialah modul untuk menyambung dengan perkhidmatan pihak ketiga tertentu seperti pangkalan data, perkhidmatan cache, pembekal e-mel, dll yang digunakan secara meluas dalam rangka kerja Nest.js. Mari kita lihat contoh berikut:

class Redis {
  constructor() {
    this.connection = null;
  }

  static getInstance() {
    if (!Redis. instance) {
      Redis.instance = new Redis(options);
    }

    Return Redis.instance;
  }

  connect() {
    this.connection = 'Redis connected'
  }
}

Dan kemudian kita boleh menggunakannya seperti berikut:

const medicine = Redis.getInstance();
const redisTwo = Redis.getInstance();

console.log(redisOne === RedisTwo); // it will result to `true`

redisOne.connect();

console.log(redisOne.connection) // 'Redis connected'
console.log(redisTwo.connection) // 'Redis connected'

Pendekatan ini memastikan bahawa hanya terdapat satu sambungan ke Redis dan menghalang sambungan pendua.

Kilang

Dengan corak ini, anda boleh mencipta objek baharu tanpa menyatakan kelas objek yang akan dibuat. Terima kasih kepadanya, kami mengabstrakkan penciptaan objek yang boleh membantu meningkatkan kebolehbacaan kod dan kebolehgunaan semula:

class Character {
  constructor(name, health) {
    this.name = name;
    this.health = health;
  }
}

class CharacterFactory {
  createCharacter(name) {
    switch(name) {
      case 'mage': 
        return new Character('Powerful Mage', 8);
      case 'warrior':
        return new Character('Courageous Warrior', 10);
      case 'rogue':
        return new Character('Sneaky Rogue', 9)
      default:
        return new Error('Unknown character');
    }
  }
}

Dan kemudian kita boleh menggunakannya seperti berikut:

const characterFactory = new CharacterFactory();

const mage = characterFactory.createCharacter('mage');
const warrior = characterFactory.createCharacter('warrior');

console.log(mage.name) // Powerful Mage
console.log(warrior.name) // Courageous Warrior

Pendekatan ini membolehkan pengguna kilang ini menggunakan kod kilang dan bukannya menggunakan pembina kelas Aksara secara langsung.

Pemerhati

Corak ini berfungsi dengan cara yang anda akan mempunyai entiti yang mengurus senarai elemen bergantung yang dipanggil pemerhati dan memberitahu mereka jika keadaan berubah. Corak ini digunakan secara meluas dalam rangka kerja Vue.js dan dilaksanakan seperti ini:

class Topic {
  constructor() {
    this.observers = []; 
  }

  subscribe(observer) {
    this.observers.push(observer);
  }

  unsubscribe(observer) {
    this.observers = this.observers.filter(o => o !== observer);
  }

  notify(data) {
    this.observers.forEach(o => o.update(data));
  }
}

class Observer {
  constructor(name) {
    this.name = name;
  }

  update(data) {
    console.log(`${this.name} received ${data}`);
  }
}

Dan anda boleh menggunakannya seperti berikut:

const topic = new Topic();

const observer1 = new Observer('Observer 1');
const observer2 = new Observer('Observer 2');

topic.subscribe(observer1);
topic.subscribe(observer2);

topic.notify('Hello World');
// Observer 1 received Hello World 
// Observer 2 received Hello World

topic.unsubscribe(observer2);

topic.notify('Hello Again');
// Observer 1 received Hello Again

Ia adalah corak yang sangat berguna untuk pengendalian acara dan aliran kerja tak segerak yang membolehkan untuk mengemas kini berbilang objek tanpa menggandingkan penerbit dengan pelanggan.

Penghias

Corak ini agak berguna untuk melanjutkan fungsi sedia ada dengan yang baharu tanpa menjejaskan kejadian awal/asal. Ia digunakan secara meluas dalam rangka kerja Nest.js terima kasih kepada sokongan penuh TypeScript tetapi dalam Node.js biasa ia boleh digunakan dalam berikut:

class Character {
  constructor() {
    this.endurance = 10;
  }

  getEndurance() {
    return this.endurance;
  }
}

class CharacterActions {
  constructor(character) {
    this.character = character;
  }

  attack() {
    this.character.endurance -= 2;
  }

  rest() {
    this.character.endurance += 1; 
  }
}

Dan kemudian ia boleh digunakan seperti berikut:

const character = new Character();

console.log(character.getEndurance()); // 10

const characterWithActions = new CharacterActions(character);

characterWithActions.attack(); // - 2
characterWithActions.rest(); // + 1

console.log(characterWithActions.character.getEndurance()); // 9

Dengan menggunakan corak ini, kami boleh melanjutkan kelas sedia ada dengan mudah tanpa menjejaskan fungsi terasnya.

Suntikan Ketergantungan

Dalam corak ini, kelas atau modul menerima kebergantungan daripada sumber luaran dan bukannya mendaftarkannya secara dalaman. Pendekatan ini membolehkan mengekstrak elemen boleh guna semula tertentu daripada sistem anda untuk ujian dan penyelenggaraan yang lebih mudah. Ia digunakan secara meluas dalam rangka kerja Nest.js. Ia boleh dilaksanakan seperti berikut:

class UserService {
  constructor(databaseService, loggerService) {
    this.db = databaseService;
    this.logger = loggerService;
  }

  async getUser(userId) {
    const user = await this.db.findUserById(userId);
    this.logger.log(`Fetched user ${user.name}`);
    return user;
  }
}

Dan kemudian, anda boleh menggunakannya seperti berikut:

const databaseService = new Database();
const loggerService = new Logger();

const userService = new UserService(databaseService, loggerService);

userService.getUser(1);

Pendekatan ini membolehkan anda mengekstrak elemen sistem anda ke dalam entiti bebas yang boleh disuntik apabila diperlukan.

? Ketahui lebih lanjut

Jika anda ingin mengetahui lebih lanjut tentang Vue, Nuxt, JavaScript atau teknologi berguna lain, semak VueSchool dengan mengklik pautan ini atau dengan mengklik imej di bawah:

Ia merangkumi konsep yang paling penting semasa membina aplikasi Vue atau Nuxt moden yang boleh membantu anda dalam kerja harian atau projek sampingan anda ?

✅ Ringkasan

Syabas! Anda baru sahaja mengetahui cara corak reka bentuk tertentu berfungsi dalam Node.js dan cara melaksanakannya.

Berhati-hati dan jumpa anda lain kali!

Dan selamat mengekod seperti biasa ?️

Atas ialah kandungan terperinci Lima Corak Reka Bentuk yang perlu diketahui dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!