好的，这里有几个问题
当源文件（.ts或.tsx）文件和声明文件（.d.ts）文件都是模块解析的候选文件时，就像这里的情况一样，编译器将解析源文件。
您可能有两个文件，因为您要导出一个值，同时还要修改全局对象jest的类型。但是，您不需要两个文件，因为TypeScript有一个特定的构造，用于从模块中扩展全局范围。也就是说，您只需要以下.ts文件

myMatcher.ts

// use declare global within a module to introduce or augment a global declaration.
declare global {
  namespace jest {
    interface Matchers {
      myMatcher: typeof myMatcher;
    }
  }
}
export default function myMatcher<T>(this: jest.MatcherUtils, received: T, expected: T) {
  const pass = received === expected;
  return {
    pass,
    message: () => 'expected' + pass ? '===' : '!==';
  };
}

字符串
也就是说，如果你有这样的情况，在同一个文件中执行全局 mutation 和全局类型 augmentation 是一个很好的做法。鉴于此，我会考虑将其改写如下

myMatcher.ts

// ensure this is parsed as a module.
export {}

declare global {
  namespace jest {
    interface Matchers {
      myMatcher: typeof myMatcher;
    }
  }
}
function myMatcher<T>(this: jest.MatcherUtils, received: T, expected: T) {
  const pass = received === expected;
  return {
    pass,
    message: () => 'expected' + pass ? '===' : '!==';
  };
}

expect.extend({
  myMatcher
});

型

someTest.ts

import './myMatcher';

it('should work', () => {
  expect('str').myMatcher('str');
});

型

一个简单的方法是：

customMatchers.ts

declare global {
    namespace jest {
        interface Matchers<R> {
            // add any of your custom matchers here
            toBeDivisibleBy: (argument: number) => {};
        }
    }
}

// this will extend the expect with a custom matcher
expect.extend({
    toBeDivisibleBy(received: number, argument: number) {
        const pass = received % argument === 0;
        if (pass) {
            return {
                message: () => `expected ${received} not to be divisible by ${argument}`,
                pass: true
            };
        } else {
            return {
                message: () => `expected ${received} to be divisible by ${argument}`,
                pass: false
            };
        }
    }
});

字符串

我的规格ts

import "path/to/customMatchers";

test('even and odd numbers', () => {
   expect(100).toBeDivisibleBy(2);
   expect(101).not.toBeDivisibleBy(2);
});

型

@AluanHaddad的回答几乎是正确的，没有几种类型。这个可以用：

export {};

declare global {
  namespace jest {
    interface Matchers<R> {
      myMatcher: (received: string) => R;
    }
  }
}

function myMatcher<T>(this: jest.MatcherUtils, received: string, expected: string): jest.CustomMatcherResult {
  const pass = received === expected;
  return {
    pass,
    message: (): string => `expected ${received} to be ${expected}`,
  }
}

expect.extend({
  myMatcher,
});

字符串
有关真实世界的示例，请参见https://github.com/Quantum-Game/quantum-tensors/blob/master/tests/customMatchers.ts（测试实际通过：https://travis-ci.com/Quantum-Game/quantum-tensors）。

将"@types/testing-library__jest-dom"添加到tsconfig.json中的types，为我解决了这个问题

// tsconfig.json

"types": [
      "node",
      "jest",
      "@types/testing-library__jest-dom"
    ],

字符串
属性'toBeInTheDocument'在类型'Matchers '上不存在