Using the "in" operator should make bracket access safe on an object

Search Terms

object in keyof bracket operator in

Suggestion

Checking a key with the "in" operator on an object should make it safe to to use in brackets

Use Cases

Useful when writing functions that process input JSON/doesn't have a concrete type.

Examples

//  Ideally this uses TypeScripts control flow logic to allow the bracket access.
function getPropFailsToCompile(data: object, key: string): any {
    if (!(key in data)) {
        throw new Error("Data is malformed")
    }
    return data[key]
}

// Compiles but keyof object has type 'never' in Typescript
function getPropCompilesButNotReasonable(data: object, key: keyof object): any {
    if (!(key in data)) {
        throw new Error("Data is malformed")
    }
    return data[key]
}

// Best way I've gotten this to work.
function getPropWorks(data: object, key: string): any {
    if (!(key in data)) {
        throw new Error("Data is malformed")
    }
    return (<any>data)[key]
}

Checklist

My suggestion meets these guidelines:

• [x ] This wouldn't be a breaking change in existing TypeScript/JavaScript code
• [x ] This wouldn't change the runtime behavior of existing JavaScript code
• [x ] This could be implemented without emitting different JS based on the types of the expressions
• [x ] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• [ x] This feature would agree with the rest of TypeScript's Design Goals.

Inizia con i tre esempi TypeScript dell'issue e la discussione circostante per comprendere il comportamento di narrowing proposto per l'operatore "in" e l'accesso tramite parentesi quadre. Il lavoro è completato quando il primo esempio supera il controllo dei tipi senza un cast, preservando il comportamento esistente di JavaScript a runtime.