Saya tidak tahu anda boleh menggunakan parameter adik-beradik sebagai nilai lalai dalam fungsi.

JavaScript telah menyokong nilai parameter lalai sejak ES2015. Anda tahu ini. Saya tahu ini. Apa yang saya tidak tahu ialah anda boleh menggunakan adik beradik parameter sebagai nilai lalai itu sendiri. (Atau mungkin "parameter kedudukan bersebelahan"? Tidak pasti untuk memanggilnya apa.)

function myFunc(arg1, arg2 = arg1) {
  console.log(arg1, arg2);
}

myFunc("arg1!");
// "arg1!" "arg1!"

Ini juga berfungsi dalam pembina kelas – sesuatu yang saya dapati agak membantu dalam menjadikan beberapa kod PicPerf.io lebih boleh diuji. Ia adalah perkara biasa untuk melihat suntikan pergantungan mudah digunakan untuk tujuan itu. Mari kita terokainya sedikit.

Satu Senario

Mengikut tema pengoptimuman imej, katakan anda mempunyai kelas OptimizedImage. Sediakan URL imej kepada pembinanya dan anda boleh mendapatkan sama ada penimbal imej yang baru dioptimumkan atau versi cache.

class OptimizedImage {
  constructor(
    imageUrl: string,
    cacheService = new CacheService(),
    optimizeService = new OptimizeService()
  ) {
    this.imageUrl = imageUrl;
    this.cacheService = cacheService;
    this.optimizeService = optimizeService;
  }

  async get() {
    const cached = this.cacheService.get(this.imageUrl);

    // Return the previously optimized image.
    if (cached) return cached;

    const optimizedImage = await this.optimizeService
      .optimize(this.imageUrl);

    // Cache the optimized image for next time.
    return this.cacheService.put(this.imageUrl, optimizedImage);
  }
}

const instance = new OptimizedImage('https://macarthur.me/me.jpg');
const imgBuffer = await instance.get();

Satu-satunya parameter pembina yang digunakan dalam pengeluaran ialah imageUrl, tetapi menyuntik CacheService dan OptimizeService membolehkan ujian unit lebih mudah dengan olok-olok:

import { it, expect, vi } from 'vitest';
import { OptimizedImage } from './main';

it('returns freshly optimized image', async function () {
  const fakeImageBuffer = new ArrayBuffer('image!');
  const mockCacheService = {
    get: (url) => null,
    put: vi.fn().mockResolvedValue(fakeImageBuffer),
  };

  const mockOptimizeService = {
    optimize: (url) => fakeImageBuffer,
  };

  const optimizedImage = new OptimizedImage(
    'https://test.jpg',
    mockCacheService,
    mockOptimizeService
  );

  const result = await optimizedImage.get();

  expect(result).toEqual(fakeImageBuffer);
  expect(mockCacheService.put).toHaveBeenCalledWith(
    'https://test.jpg',
    'optimized image'
  );
});

Menjadikannya Lebih Rumit

Dalam contoh itu, kedua-dua kelas perkhidmatan tersebut menggunakan imageUrl hanya apabila kaedah tertentu digunakan. Tetapi bayangkan jika mereka memerlukannya untuk dihantar ke pembina mereka sendiri. Anda mungkin tergoda untuk menarik instantiasi ke dalam pembina OptimizedImage (saya dahulu):

class OptimizedImage {
  constructor(
    imageUrl: string
  ) {
    this.imageUrl = imageUrl;
    this.cacheService = new CacheService(imageUrl);
    this.optimizeService = new OptimizeService(imageUrl);
  }

Itu berkesan, tetapi kini OptimizedImage bertanggungjawab sepenuhnya untuk instantiasi perkhidmatan dan ujian juga menjadi lebih menyusahkan. Tidak begitu mudah untuk menyampaikan olok-olok untuk contoh perkhidmatan.

Anda boleh mengatasi masalah ini dengan menghantar takrifan kelas olok-olok, tetapi kemudian anda perlu mencipta versi olok-olok kelas tersebut dengan pembinanya sendiri, menjadikan ujian lebih membosankan. Nasib baik, terdapat pilihan lain: gunakan parameter imageUrl dalam senarai hujah anda yang lain.

Berkongsi Parameter Adik Beradik

Saya tidak sedar ini mungkin berlaku sehingga beberapa ketika dahulu. Begini rupanya:

export class OptimizedImage {
  constructor(
    imageUrl: string,
    // Use the same `imageUrl` in both dependencies.
    cacheService = new CacheService(imageUrl),
    optimizeService = new OptimizeService(imageUrl)
  ) {
    this.cacheService = cacheService;
    this.optimizeService = optimizeService;
  }

  async get() {
    const cached = this.cacheService.get();

    // Return the previously optimized image.
    if (cached) return cached;

    const optimizedImage = await this.optimizeService.optimize();

    // Cache the optimized image for next time.
    return this.cacheService.put(optimizedImage);
  }
}

Dengan persediaan ini, anda boleh mengejek kejadian tersebut semudah dahulu, dan seluruh kelas tidak perlu memegang tika imageUrl itu sendiri. Sejurus, sudah tentu, masih kekal mudah:

const instance = new OptimizedImage('https://macarthur.me/me.jpg');

const img = await instance.get();

Pendekatan ujian yang sama kekal dalam kebijaksanaan juga:

import { it, expect, vi } from 'vitest';
import { OptimizedImage } from './main';

it('returns freshly optimized image', async function () {
  const mockCacheService = {
    get: () => null,
    put: vi.fn().mockResolvedValue('optimized image'),
  };

  const mockOptimizeService = {
    optimize: () => 'optimized image',
  };

  const optimizedImage = new OptimizedImage(
    'https://test.jpg',
    mockCacheService,
    mockOptimizeService
  );

  const result = await optimizedImage.get();

  expect(result).toEqual('optimized image');
  expect(mockCacheService.put).toHaveBeenCalledWith('optimized image');
});

Tiada apa-apa terobosan di sini – hanya ciri kecil yang menjadikan hidup saya lebih ergonomik sedikit. Saya berharap untuk menemui lebih banyak permata seperti ini pada masa hadapan.

Atas ialah kandungan terperinci Saya tidak tahu anda boleh menggunakan parameter adik-beradik sebagai nilai lalai dalam fungsi.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!