Try utilizing const instead of let to avoid unexpected changes

Question

Try utilizing const instead of let to avoid unexpected changes

Encountered an issue with the no-let rule in my tslint configuration. It is flagging the handler variable as requiring a const declaration, despite the fact that it is assigned within a switch case statement. This seems like a potential bug to me.

static def(name: string) {
    // [tslint]Unexpected let, use const instead (no-let)
    let handler: Function;
    switch (name) {
        case 'test':
            handler = console.error;
            break;
        default:
            handler = console.warn;
    }

    handler(name);
}

Attempting to change it to const handler: Function results in an error being thrown by tsserver.

    const handler: Function;

    switch (name) {
        case 'test':
            // [tsserver] Cannot assign to 'handler' because it's a constant
            handler = console.error;
            break;

typescript tslint

Answer 1

Answer №1

Function serves as a constructor, similar to String, Array, and other types...

Transform it into

let handler: () => void;

I chose void as console.error and console.warn both yield undefined

Answer 2

Function serves as a constructor, similar to String, Array, and other types...

Transform it into

let handler: () => void;

I chose void as console.error and console.warn both yield undefined

Answer 3

Answer №2

There's no bug here, as a constant cannot be reassigned since it's meant to be constant:

const num = 1;
num = 2; //this will trigger the same error message

To prevent this issue, you can directly return your desired result within the switch case like this:

static def(name: string) {
    switch (name) {
        case 'test':
            return console.error;
        default:
            return console.warn;
    }
}
def("test")("Your message to log as an error");
def("nottest")("Your message to log as a warning");

Answer 4

There's no bug here, as a constant cannot be reassigned since it's meant to be constant:

const num = 1;
num = 2; //this will trigger the same error message

To prevent this issue, you can directly return your desired result within the switch case like this:

static def(name: string) {
    switch (name) {
        case 'test':
            return console.error;
        default:
            return console.warn;
    }
}
def("test")("Your message to log as an error");
def("nottest")("Your message to log as a warning");

Try utilizing const instead of let to avoid unexpected changes

Answer №1

Answer №2

Similar questions

Container that displays vertical scroll while permitting floating overflows

The function 'ShouldWorkController' was expected but is not defined, receiving undefined instead

Prisma atomic operations encounter errors when attempting to update undefined values

Access the Ionic2 App through the Slider option

Encountering difficulties in loading environment variables while starting the server using typescript in combination with node.js

Efficiently process and handle the responses from Promise.all for every API call, then save the retrieved data

What could be causing the error within the 'react-code-blocks' library?

Performing unit tests in Angular 2 with karma

Growing the number of items in the shopping cart

Using NestJS to import and inject a TypeORM repository for database operations

Obtain the dimensions (width and height) of a collection of images using Angular and TypeScript

Is it possible to utilize instanceof to verify whether a certain variable is of a class constructor type in TypeScript?

Determining the best application of guards vs middlewares in NestJs

Utilize the power of TypeScript to display data with impact

Struggling with rotating an image in React

Is the naming convention for parameterized types (T, U, V, W) in Generics adhered to by Typescript?

Retrieving selected item values in Angular 2 using ng2-completer

Angular: Tips for retrieving image dimensions before rendering it in the DOM

Arranging an array containing three elements

Employing strict mode, albeit with certain exceptions