Início / user-9224183

Lumin's questions

Martin Hope
Lumin
Asked: 2025-03-07 01:26:53 +0800 CST
  • 8

Ao sombrear identro do loop for, o seguinte código

#include <stdio.h>

int main()
{
    for (int i = 1; i < 5; i++) {
        printf("%d", i);
        int i = i;
        printf("%d ", i);
    }
}

saídas:

10 20 30 40

Pelo meu entendimento de shadowing, deveria ter sido icriado um novo com o valor igual ao anterior i. Isso significa que a saída que eu esperava seria:

11 22 33 44

Além disso, o código parece armazenar o novo ivalor se você incrementá-lo.

#include <stdio.h>

int main()
{
    for (int i = 1; i < 5; i++) {
        printf("%d", i);
        int i = i + 2;
        printf("%d ", i);
    }
}

isso produz:

12 24 36 48

Aparentemente, inão está sendo redeclarado a cada iteração - funciona como uma variável que foi inicialmente 0e depois incrementada a cada iteração.

O que está realmente acontecendo aqui? Como você prevê o comportamento?

c
Martin Hope
Lumin
Asked: 2023-08-18 02:49:41 +0800 CST
  • 5

Dado um objeto:

const obj = { a: 1 } as { a: number } | { b: number }
const key = "a" as string

if (key in obj) {
  console.log(obj[key])
  // string cannot be used to index { a: number } | { b: number }
}

Como faço para acessar com segurança obj(sem declaração de tipo)?

Não consigo usar verificações literais

if ("a" in obj) {
   // obj.a is number
}

uma vez que o valor de keynão é pré-determinado.

Link do Playground

typescript
Martin Hope
Lumin
Asked: 2023-08-18 01:55:45 +0800 CST
  • 5

Considere uma função auxiliar

const isKeyOf = <K extends PropertyKey, O extends object>(key: K, object: O): key is K & keyof O => key in object

Aqui, isKeyOflimita o tipo de chave ao verificar se existe uma chave em um objeto

const obj = {
    a: 1,
    b: 2,
    c: 3
}

const key: string = "a" // type of key is string

if (isKeyOf(key, obj)) {
    // type of key is "a" | "b" | "c"
}

Isso funciona bem, desde que obj não seja uma união de tipos, no entanto:

const holder: Record<number, { a: number } | { b: number }> = {
    1: { a: 1 },
    2: { b: 2 }
}

// type of obj is { a: number } | { b: number }
const obj = holder[1 as number]
const key: string = "a" // type of key is string
 
if (isKeyOf(key, obj)) {
     // type of key is never!
     // However, this branch does execute, and
     console.log(typeof key) // prints string
     console.log(obj) // prints { a: 1 }
}

Depois de alguma investigação, descobri que isso ocorre porque o keyofoperador lista apenas as chaves que são comuns a todos os tipos em uma união

type objType = { a: number } | { b: number }
type key = keyof objType // = never

ainda assim, neste caso, verifiquei se keyrealmente está in objTypeno tipo de guarda. Como faço para escrever um tipo de proteção que verifique isso corretamente e atribua o tipo correto à chave?

typescript