Title says it all - why doesn't Object.keys(x) in TypeScript return the type Array<keyof typeof x>? That's what Object.keys does, so it seems like an obvious oversight on the part of the TypeScript definition file authors to not make the return type simply be keyof T.

标题说明了一切--为什么类型脚本中的Object.key(X)不返回类型数组 ？这就是Object.key所做的事情，所以对于类型脚本定义文件的作者来说，不将返回类型简单地设置为key of T似乎是一个明显的疏忽。

Should I log a bug on their GitHub repo, or just go ahead and send a PR to fix it for them?

我应该在他们的GitHub回购中记录错误，还是直接发送公关为他们修复它？

优秀答案推荐

The current return type (string[]) is intentional. Why?

当前返回类型(字符串[])是有意的。为什么？

Consider some type like this:

考虑一下这样的类型：

interface Point {
    x: number;
    y: number;
}

You write some code like this:

您可以编写一些代码，如下所示：

function fn(k: keyof Point) {
    if (k === "x") {
        console.log("X axis");
    } else if (k === "y") {
        console.log("Y axis");
    } else {
        throw new Error("This is impossible");
    }
}

Let's ask a question:

让我们问一个问题：

In a well-typed program, can a legal call to fn hit the error case?

The desired answer is, of course, "No". But what does this have to do with Object.keys?

当然，人们希望得到的答案是“不”。但这与Object.key有什么关系呢？

Now consider this other code:

现在考虑下面的另一段代码：

interface NamedPoint extends Point {
    name: string;
}

const origin: NamedPoint = { name: "origin", x: 0, y: 0 };

Note that according to TypeScript's type system, all NamedPoints are valid Points.

注意，根据TypeScrip的类型系统，所有NamedPoint都是有效的点。

Now let's write a little more code:

现在，让我们再编写一些代码：

function doSomething(pt: Point) {
    for (const k of Object.keys(pt)) {
        // A valid call if Object.keys(pt) returns (keyof Point)[]
        fn(k);
    }
}
// Throws an exception
doSomething(origin);

Our well-typed program just threw an exception!

我们的类型良好的程序刚刚抛出了一个异常！

Something went wrong here!
By returning keyof T from Object.keys, we've violated the assumption that keyof T forms an exhaustive list, because having a reference to an object doesn't mean that the type of the reference isn't a supertype of the type of the value.

这里出了点问题！通过从对象键返回key of T，我们违反了key of T形成详尽列表的假设，因为拥有对对象的引用并不意味着引用的类型不是值类型的超类型。

Basically, (at least) one of the following four things can't be true:

基本上，(至少)以下四件事中的一件不可能是真的：

1. keyof T is an exhaustive list of the keys of T


2. A type with additional properties is always a subtype of its base type


3. It is legal to alias a subtype value by a supertype reference


4. Object.keys returns keyof T

Throwing away point 1 makes keyof nearly useless, because it implies that keyof Point might be some value that isn't "x" or "y".

丢弃Point1使key of几乎毫无用处，因为它意味着key of Point可能是不是“x”或“y”的某个值。

Throwing away point 2 completely destroys TypeScript's type system. Not an option.

扔掉第二点完全摧毁了打字稿的字体系统。没有选择的余地。

Throwing away point 3 also completely destroys TypeScript's type system.

扔掉第三点也会彻底摧毁打字稿的字体系统。

Throwing away point 4 is fine and makes you, the programmer, think about whether or not the object you're dealing with is possibly an alias for a subtype of the thing you think you have.

丢弃第4点是可以的，这会让您(程序员)考虑您正在处理的对象是否可能是您认为您拥有的东西的子类型的别名。

The "missing feature" to make this legal but not contradictory is Exact Types, which would allow you to declare a new kind of type that wasn't subject to point #2. If this feature existed, it would presumably be possible to make Object.keys return keyof T only for Ts which were declared as exact.

使这一点合法但不矛盾的“缺失功能”是精确类型，这将允许您声明一种不受第2点约束的新类型。如果存在此功能，可能会使Object.key仅为声明为精确的类型返回key of T。

---

Addendum: Surely generics, though?

Commentors have implied that Object.keys could safely return keyof T if the argument was a generic value. This is still wrong. Consider:

评论者暗示，如果参数是泛型值，则Object.key可以安全地返回key of T。这仍然是错误的。请考虑：

class Holder<T> {
    value: T;
    constructor(arg: T) {
        this.value = arg;
    }

    getKeys(): (keyof T)[] {
        // Proposed: This should be OK
        return Object.keys(this.value);
    }
}
const MyPoint = { name: "origin", x: 0, y: 0 };
const h = new Holder<{ x: number, y: number }>(MyPoint);
// Value 'name' inhabits variable of type 'x' | 'y'
const v: "x" | "y" = (h.getKeys())[0];

or this example, which doesn't even need any explicit type arguments:

或者这个示例，它甚至不需要任何显式类型参数：

function getKey<T>(x: T, y: T): keyof T {
    // Proposed: This should be OK
    return Object.keys(x)[0];
}
const obj1 = { name: "", x: 0, y: 0 };
const obj2 = { x: 0, y: 0 };
// Value "name" inhabits variable with type "x" | "y"
const s: "x" | "y" = getKey(obj1, obj2);

For a workaround in cases when you're confident that there aren't extra properties in the object you're working with, you can do this:

对于您确信正在使用的对象中没有额外属性的情况下的一种解决方法，您可以这样做：

const obj = {a: 1, b: 2}
const objKeys = Object.keys(obj) as Array<keyof typeof obj>
// objKeys has type ("a" | "b")[]

You can extract this to a function if you like:

如果您愿意，可以将其提取到一个函数中：

const getKeys = <T>(obj: T) => Object.keys(obj) as Array<keyof T>

const obj = {a: 1, b: 2}
const objKeys = getKeys(obj)
// objKeys has type ("a" | "b")[]

As a bonus, here's Object.entries, pulled from a GitHub issue with context on why this isn't the default:

作为额外的好处，以下是从GitHub的一个问题中摘录的对象条目，其中包含关于为什么这不是默认设置的问题：

type Entries<T> = {
  [K in keyof T]: [K, T[K]]
}[keyof T][]

function entries<T>(obj: T): Entries<T> {
  return Object.entries(obj) as any;
}

This is the top hit on google for this type of issue, so I wanted to share some help on moving forwards.

这是谷歌在这类问题上的热门话题，所以我想分享一些关于继续前进的帮助。

These methods were largely pulled from the long discussions on various issue pages which you can find links to in other answers/comment sections.

这些方法很大程度上是从各种问题页面上的长时间讨论中提取的，您可以在其他答案/评论部分找到链接。

So, say you had some code like this:

因此，假设您有如下代码：

const obj = {};
Object.keys(obj).forEach((key) => {
  obj[key]; // blatantly safe code that errors
});

Here are a few ways to move forwards:

以下是一些前进的方法：

1. If you don't need the keys and really just need the values, use .entries() or .values() instead of iterating over the keys.

   
   

   const obj = {};
   Object.values(obj).forEach(value => value);
   Object.entries(obj).forEach([key, value] => value);
   

   
   



2. Create a helper function:

   
   

   function keysOf<T extends Object>(obj: T): Array<keyof T> {
     return Array.from(Object.keys(obj)) as any;
   }
   
   const obj = { a: 1; b: 2 };
   keysOf(obj).forEach((key) => obj[key]); // type of key is "a" | "b"
   

   
   



3. Re-cast your type (this one helps a lot for not having to rewrite much code)

   
   

   const obj = {};
   Object.keys(obj).forEach((_key) => {
     const key = _key as keyof typeof obj;
     obj[key];
   });
   

   
   

Which one of these is the most painless is largely up to your own project.

其中哪一个是最无痛的，很大程度上取决于你自己的项目。

Possible solution

可能的解决方案

const isName = <W extends string, T extends Record<W, any>>(obj: T) =>
  (name: string): name is keyof T & W =>
    obj.hasOwnProperty(name);

const keys = Object.keys(x).filter(isName(x));

I had this issue too, so I wrote some typed functions.

我也有这个问题，所以我编写了一些类型化函数。

Knowing that Object.keys and Object.entries return all keys as string I created a ToStringKey type:

知道了Object.key和Object.Entries以字符串形式返回所有键的情况下，我创建了一个ToStringKey类型：

/**
 * Returns the names of the _typed_ enumerable string properties and methods of an object.
 *
 * Note: Limiting Object.keys to a specific type may lead to inconsistencies between type-checking and runtime behavior.
 * Use this function when you are certain of the objects keys.
 */
export const getTypedKeys = Object.keys as <T extends object>(
  obj: T
  // Using `ToStringKey` because Object.keys returns all keys as strings.
) => Array<ToStringKey<T>>;

/**
 * Returns an array of _typed_ values of the enumerable properties of an object.
 */
export const getTypedValues = Object.values as <T extends object>(obj: T) => Array<T[keyof T]>;

/**
 * Returns an array of _typed_ key/values of the enumerable properties of an object.
 *
 * Note: Limiting Object.entries to a specific type may lead to inconsistencies between type-checking and runtime behavior.
 * Use this function when you are certain of the objects keys.
 */
export const getTypedEntries = Object.entries as <T extends object>(
  obj: T
  // Using `ToStringKey` because Object.entries returns all keys as strings.
) => Array<[ToStringKey<T>, T[keyof T]]>;

/**
 * Converts object keys to their string literal types.
 */
type ToStringKey<T> = `${Extract<keyof T, string | number>}`;

I do not recommend defining these method types globally. Create separate utility functions instead.

我不建议全局定义这些方法类型。取而代之的是创建单独的实用函数。

While TypeScript can infer and work with types, it cannot determine runtime-specific characteristics like enumerability.

虽然TypeScrip可以推断和处理类型，但它不能确定运行时特定的特征，如可枚举性。

just do this and the problem is gone

只要这样做，问题就解决了

declare global {
  interface ObjectConstructor {
    keys<T>(o: T): (keyof T)[]
    // @ts-ignore
    entries<U, T>(o: { [key in T]: U } | ArrayLike<U>): [T, U][]
  }
}

I added // @ts-ignore because ts would tell me this:

我添加了//@ts-Ignore，因为ts会告诉我：

Type 'T' is not assignable to type 'string | number | symbol

If someone have a solution to get rid of // @ts-ignore without loosing the ability to preserve the dynamic aspect of T, let us know in the comments

如果有人有一个解决方案可以在不失去保持T的动态方面的能力的情况下摆脱// @ts-ignore，请在评论中告诉我们。

If this breaks your code you can do:

如果这破坏了您的代码，您可以执行以下操作：

Object.tsKeys = function getObjectKeys<Obj>(obj: Obj): (keyof Obj)[] {
 return Object.keys(obj!) as (keyof Obj)[]
}
// @ts-ignore
Object.tsEntries = function getObjectEntries<U, T>(obj: { [key in T]: U }): [T, U][] {
 return Object.entries(obj!) as unknown as [T, U][]
}
declare global {
 interface ObjectConstructor {
   // @ts-ignore
   tsEntries<U, T>(o: { [key in T]: U }): [T, U][]
   tsKeys<T>(o: T): (keyof T)[]
 }
}