如何检查变量是否是 ES6 类声明？

Question

我正在从一个模块中导出以下 ES6 类：

export class Thingy {
  hello() {
    console.log("A");
  }

  world() {
    console.log("B");
  }
}

并从另一个模块导入它：

import {Thingy} from "thingy";

if (isClass(Thingy)) {
  // Do something...
}

如何检查变量是否为类？不是类实例，而是类声明？

也就是说，我将如何实现上面示例中的isClass 函数？

Answer 1

如果您想确保该值不仅是一个函数，而且是一个类的构造函数，您可以将函数转换为字符串并检查其表示形式。 The spec dictates the string representation of a class constructor.

function isClass(v) {
  return typeof v === 'function' && /^\s*class\s+/.test(v.toString());
}

---

另一种解决方案是尝试将该值作为普通函数调用。类构造函数不能像普通函数一样调用，但错误消息可能因浏览器而异：

function isClass(v) {
  if (typeof v !== 'function') {
    return false;
  }
  try {
    v();
    return false;
  } catch(error) {
    if (/^Class constructor/.test(error.message)) {
      return true;
    }
    return false;
  }
}

缺点是调用函数会产生各种未知的副作用...

Answer 2

这里我先说清楚，任意函数都可以是构造函数。如果您要区分“类”和“函数”，那么您的 API 设计选择就很糟糕。例如，如果您假设某些东西必须是 class，那么使用 Babel 或 Typescript 的任何人都不会被检测为 class，因为他们的代码将被转换为函数。这意味着您要求使用您的代码库的任何人必须在一般情况下在 ES6 环境中运行，因此您的代码将无法在旧环境中使用。

您在此处的选项仅限于实现定义的行为。在 ES6 中，一旦解析了代码并处理了语法，就没有太多特定于类的行为了。你所拥有的只是一个构造函数。你最好的选择是做

if (typeof Thingy === 'function'){
  // It's a function, so it definitely can't be an instance.
} else {
  // It could be anything other than a constructor
}

如果有人需要执行非构造函数，请为此公开一个单独的 API。

显然，这不是您要寻找的答案，但明确这一点很重要。

正如这里提到的另一个答案，您确实有一个选择，因为函数上的.toString() 需要返回类声明，例如

class Foo {}
Foo.toString() === "class Foo {}" // true

然而，关键是它只适用于如果可以的话。实现是 100% 符合规范的

class Foo{}
Foo.toString() === "throw SyntaxError();"

目前没有浏览器这样做，但是有几个嵌入式系统例如专注于 JS 编程，为了为您的程序本身保留内存，一旦源代码被解析，它们就会丢弃它，这意味着他们将没有源代码可以从 .toString() 返回，这是允许的。

同样，通过使用.toString()，您对面向未来和通用 API 设计做出了假设。说你做

const isClass = fn => /^\s*class/.test(fn.toString());

因为这依赖于字符串表示，它很容易被破坏。

以装饰器为例：

@decorator class Foo {}
Foo.toString() == ???

这里的.toString() 是否包括装饰器？如果装饰器本身返回 function 而不是类怎么办？

Answer 3

检查prototype 和arguments 应该允许在不对输入进行字符串化、调用或实例化的情况下确定函数的类型。

    function isFunction(x) {
        return typeof x !== 'function'
           ? ''
           : x.hasOwnProperty('arguments')
              ? 'function'
              : x.prototype
                 ? 'class'
                 : x.constructor.name === 'AsyncFunction'
                    ? 'async'
                    : 'arrow';
    }

...确实如此（在节点和客户端中）

console.assert([
   isFunction(null),
   isFunction(class C{}),
   isFunction(function f(){}),
   isFunction(()=>{})
   isFunction(async function(){})
].join(',') === ',class,function,arrow,async');

Answer 4

怎么样：

function isClass(v) {
   return typeof v === 'function' && v.prototype.constructor === v;
}

Answer 5

此解决方案使用Felix's answer 修复了两个误报：

1. 它适用于在类主体之前没有空格的匿名类：
   • isClass(class{}) // true
2. 它适用于本机类：
   • isClass(Promise) // true
   • isClass(Proxy) // true

function isClass(value) {
  return typeof value === 'function' && (
    /^\s*class[^\w]+/.test(value.toString()) ||

    // 1. native classes don't have `class` in their name
    // 2. However, they are globals and start with a capital letter.
    (globalThis[value.name] === value && /^[A-Z]/.test(value.name))
  );
}

const A = class{};
class B {}
function f() {}

console.log(isClass(A));                // true
console.log(isClass(B));                // true
console.log(isClass(Promise));          // true

console.log(isClass(Promise.resolve));  // false
console.log(isClass(f));                // false

缺点

遗憾的是，它仍然不适用于 node 内置（可能还有许多其他特定于平台的）类，例如：

const EventEmitter = require('events');
console.log(isClass(EventEmitter));  // `false`, but should be `true` :(

Answer 6

也许这会有所帮助

let is_class = (obj) => {
    try {
        new obj();
        return true;
    } catch(e) {
        return false;
    };
};

Answer 7

很好地浏览了一些答案，并认为@Joe Hildebrand 突出了边缘情况，因此更新了以下解决方案以反映大多数尝试过的边缘情况。对可能存在边缘情况的更多识别开放。

关键见解：虽然我们正在进入类，但就像 JS 中的指针和引用辩论一样，并不能证实其他语言的所有品质 - JS 本身没有我们在其他语言结构中拥有的类。

有些争论它是函数的糖衣语法，有些争论是另一种明智的。我相信课程仍然是一个功能，但与其说是糖衣，不如说是可以放在类固醇上的东西。类会做一些功能不能做或不想升级它们做的事情。

因此暂时将类作为函数处理打开了另一个潘多拉盒子。 JS 中的一切都是对象，JS 不理解但愿意跟随开发者的一切都是对象，例如

• 布尔值可以是对象（如果使用 new 关键字定义）
• 数字可以是对象（如果使用 new 关键字定义）
• 字符串可以是对象（如果使用 new 关键字定义）
• 日期总是对象
• 数学总是对象
• 正则表达式始终是对象
• 数组总是对象
• 函数始终是对象
• 对象永远是对象

那么类到底是什么？ 重要 类是创建对象的模板，在这一点上它们不是对象。 当您在某处创建类的实例时，它们成为对象，该实例被视为对象。 因此，我们需要进行筛选

• 我们正在处理哪种类型的对象
• 然后我们需要筛选出它的属性。
• 函数始终是对象，它们始终具有原型和参数属性。
• 箭头函数实际上是老式函数的糖衣，没有这个或更多简单返回上下文的概念，因此即使您尝试定义它们也没有原型或参数。
• 类是一种可能的函数的蓝图，没有参数属性但有原型。这些原型在实例之后成为事实对象。

因此，我尝试捕获并记录我们检查的每次迭代以及结果。

希望对你有帮助

'use strict';
var isclass,AA,AAA,BB,BBB,BBBB,DD,DDD,E,F;
isclass=function(a) {
if(/null|undefined/.test(a)) return false;
    let types = typeof a;
    let props = Object.getOwnPropertyNames(a);
    console.log(`type: ${types} props: ${props}`);


    return  ((!props.includes('arguments') && props.includes('prototype')));}
    
    class A{};
    class B{constructor(brand) {
    this.carname = brand;}};
    function C(){};
     function D(a){
     this.a = a;};
 AA = A;
 AAA = new A;
 BB = B;
 BBB = new B;
 BBBB = new B('cheking');
 DD = D;
 DDD = new D('cheking');
 E= (a) => a;
 
F=class {};
 
console.log('and A is class: '+isclass(A)+'\n'+'-------');
console.log('and AA as ref to A is class: '+isclass(AA)+'\n'+'-------');
console.log('and AAA instance of is class: '+isclass(AAA)+'\n'+'-------');
console.log('and B with implicit constructor is class: '+isclass(B)+'\n'+'-------');
console.log('and BB as ref to B is class: '+isclass(BB)+'\n'+'-------');
console.log('and BBB as instance of B is class: '+isclass(BBB)+'\n'+'-------');
console.log('and BBBB as instance of B is class: '+isclass(BBBB)+'\n'+'-------');
console.log('and C as function is class: '+isclass(C)+'\n'+'-------');
console.log('and D as function method is class: '+isclass(D)+'\n'+'-------');
console.log('and DD as ref to D is class: '+isclass(DD)+'\n'+'-------');
console.log('and DDD as instance of D is class: '+isclass(DDD)+'\n'+'-------');
console.log('and E as arrow function is class: '+isclass(E)+'\n'+'-------');
console.log('and F as variable class is class: '+isclass(F)+'\n'+'-------');
console.log('and isclass as variable  function is class: '+isclass(isclass)+'\n'+'-------');
console.log('and 4 as number is class: '+isclass(4)+'\n'+'-------');
console.log('and 4 as string is class: '+isclass('4')+'\n'+'-------');
console.log('and DOMI\'s string is class: '+isclass('class Im a class. Do you believe me?')+'\n'+'-------');

更短的清理函数，涵盖严格模式、es6 模块、null、未定义以及对象上的任何非属性操作。

到目前为止，我发现的是，从上面的讨论中，类在实例出现之前并不是它们自己的蓝图。因此运行 toString 函数几乎总是会在实例之后产生类 {} 输出而不是 [object object] 等等。一旦我们知道什么是一致的，那么只需运行正则表达式测试以查看结果是否以单词类开头。

"use strict"
let isclass = a =>{
return (!!a && /^class.*{}/.test(a.toString()))
}
class A {}
class HOO {}
let B=A;
let C=new A;
Object.defineProperty(HOO, 'arguments', {
  value: 42,
  writable: false
});


console.log(isclass(A));
console.log(isclass(B));
console.log(isclass(C));
console.log(isclass(HOO));
console.log(isclass());
console.log(isclass(null));
console.log(HOO.toString());
//proxiy discussion
console.log(Proxy.toString());
//HOO was class and returned true but if we proxify it has been converted to an object
HOO = new Proxy(HOO, {});
console.log(isclass(HOO));
console.log(HOO.toString());
console.log(isclass('class Im a class. Do you believe me?'));

来自 DOMI 的讨论

class A {
static hello (){console.log('hello')}
hello () {console.log('hello there')}
}

A.hello();
B = new A;
B.hello();

console.log('it gets even more funnier it is properties and prototype mashing');  

class C {
  constructor() {
    this.hello = C.hello;
  }
static hello (){console.log('hello')}
}
C.say = ()=>{console.log('I said something')} 
C.prototype.shout = ()=>{console.log('I am shouting')} 

C.hello();
D = new C;
D.hello();
D.say();//would throw error as it is not prototype and is not passed with instance
C.say();//would not throw error since its property not prototype
C.shout();//would throw error as it is prototype and is passed with instance but is completly aloof from property of static 
D.shout();//would not throw error
console.log('its a whole new ball game ctaching these but gassumption is class will always have protoype to be termed as class');