我不知道你可以使用同级参数作为函数中的默认值

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

myfunc("arg1!");
// "arg1!" "arg1!"

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();

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'
  );
});

class optimizedimage {
  constructor(
    imageurl: string
  ) {
    this.imageurl = imageurl;
    this.cacheservice = new cacheservice(imageurl);
    this.optimizeservice = new optimizeservice(imageurl);
  }

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);
  }
}

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

const img = await instance.get();

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');
});