Er det noen måte å oppdage type action.payload bruke Loggfila?

stemmer
1

Jeg har mye av handlinger, og jeg vil oppdage en type min nyttelast inn i en bestemt casei min redusering avhengig handlingstype.

Nå vet jeg ikke hva som er i en nyttelast:

function someReducer(state: ISomeState = getDefaultSomeState(), action) {
    switch (action.type) {
        case FIRST: {
            // What is type of action.payload?
            return {...};
        }
        default: {
            return state;
        }
    }
}
Publisert på 02/12/2019 klokken 23:57
kilden bruker
På andre språk...                            


1 svar

stemmer
1

Type Guards Loggfila funksjonen er kan du begrense den type av et objekt i en betinget blokk. Det betyr at du kan spesifisere typen din løst med forholdene og brytere.

Hvordan det fungerer?

La oss si at vi har to grensesnitt og et objekt:

interface IDog {
    woof();
}

interface ICat {
    meow();
}

const animal: IDog | ICat = getAnimal();

animal.woof(); // can we do it? ...typescript don't know because animal may be a kitten

La oss legge til noen funksjoner til våre grensesnitt

interface IDog {
    type: "Dog"; // yes, type of type is just a string literal
    woof();
}

interface ICat {
    type: "Cat";
    meow();
}

const animal: IDog | ICat = getAnimal();

switch (animal.type) {
    case "Dog":
        animal.woof(); // now we are sure that animal has woof because only Dog has this method
        return;
    case "Cat":
        animal.meow(); // typescript understands what type we are using now
        return;
    default:
        throw Error("I don't know given animal");
}

Så, nå kan vi skille fagforenings typer.

La oss se hvordan vi kan bruke det i våre programmer

function someReducer(state: ISomeState = getDefaultSomeState(), action) {
    switch (action.type) {
        case "FIRST": {
            // What is inside action.payload?
            return {...};
        }
        case "SECOND": {
            // Does action.payload have a name property?
            return {...};
        }
        default: {
            return state;
        }
    }
}

Hvis du har mange handlingstyper du ikke kan svare på disse spørsmålene trygt. Så kan vi hjelpe Loggfila hjelp oss.

La oss se på fil erklære våre handlinger:

interface IFirstAction {
    type: "FIRST";
    payload: {
        name: string;
    };
}

interface ISecondAction {
    type: "SECOND";
    payload: {
        age: number;
    };
}

// we declare union type here
export type TAction =
    IFirstAction |
    ISecondAction;

Og vår redusering:

function someReducer(state: ISomeReducerState = getDefaultSomeState(), action: TAction) {
    switch (action.type) {
        case "FIRST": {
            // What is inside action.payload?
            // Even our favourite IDE will tell us that action.payload has a name property
            // And the name is a string
            return {...};
        }
        case "SECOND": {
            // Does action.payload have a name property?
            // Nope, action.payload has an age property only
            return {...};
        }
        default: {
            return state;
        }
    }
}

Vel, hvis du utvikler hjelp Loggfila og redux, bruker type vakter også. Det vil definitivt spare tid for deg og ditt team.

Du kan også lese om andre avanserte Loggfila funksjoner

Svarte 02/12/2019 kl. 23:57
kilden bruker

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more