Siga las TypeScript prácticas recomendadas

TypeScript es un lenguaje que amplía las capacidades de JavaScript. Es un lenguaje fuertemente tipificado y orientado a objetos. Se puede utilizar TypeScript para especificar los tipos de datos que se transmiten en el código y tiene la capacidad de informar de errores cuando los tipos no coinciden. En esta sección se proporciona una descripción general de las prácticas TypeScript recomendadas.

Describir los datos

Puede utilizarla TypeScript para describir la forma de los objetos y las funciones de su código. El uso del tipo any equivale a dejar de comprobar el tipo de una variable. Recomendamos que evite el uso de any en su código. A continuación se muestra un ejemplo.

type Result = "success" | "failure"
function verifyResult(result: Result) {
    if (result === "success") {
        console.log("Passed");
    } else {
        console.log("Failed")
    }
}

Utilizar enumeraciones

Puede utilizar enumeraciones para definir un conjunto de constantes con nombre y definir estándares que se puedan reutilizar en su base de código. Le recomendamos que exporte las enumeraciones una vez a nivel global y, a continuación, deje que otras clases importen y utilicen las enumeraciones. Suponga que desea crear un conjunto de posibles acciones para registrar los eventos en su base de código. TypeScript proporciona enumeraciones numéricas y basadas en cadenas. En el siguiente ejemplo, se utiliza una enumeración.

enum EventType {
    Create,
    Delete,
    Update
}

class InfraEvent {
    constructor(event: EventType) {
        if (event === EventType.Create) {
            // Call for other function
            console.log(`Event Captured :${event}`);
        }
    }
}

let eventSource: EventType = EventType.Create;
const eventExample = new InfraEvent(eventSource)

Utilizar interfaces

Una interfaz es un contrato para la clase. Si crea un contrato, sus usuarios deberán cumplirlo. En el siguiente ejemplo, se utiliza una interfaz para estandarizar las props y garantizar que las personas que llaman ingresen el parámetro esperado al utilizar esta clase.

import { Stack, App } from "aws-cdk-lib";
import { Construct } from "constructs";

interface BucketProps {
    name: string;
    region: string;
    encryption: boolean;

}

class S3Bucket extends Stack {
    constructor(scope: Construct, props: BucketProps) {
        super(scope);
        console.log(props.name);

    }
}
const app = App();
const myS3Bucket = new S3Bucket(app, {
    name: "my-bucket",
    region: "us-east-1",
    encryption: false
})

Algunas propiedades solo se pueden modificar cuando se crea un objeto por primera vez. Puede especificar esto al poner readonly antes del nombre de la propiedad, como se muestra en el siguiente ejemplo.

interface Position {
    readonly latitude: number;
    readonly longitute: number;
}

Ampliar interfaces

La amplificación de las interfaces reduce la duplicación, ya que no es necesario copiar las propiedades entre las interfaces. Además, el lector del código puede entender con facilidad las relaciones de la aplicación.

 interface BaseInterface{
    name: string;
  }
  interface EncryptedVolume extends BaseInterface{
      keyName: string;
  }
  interface UnencryptedVolume extends BaseInterface {
      tags: string[];
  }

Evitar interfaces vacías

Le recomendamos que evite las interfaces vacías debido a los posibles riesgos que conllevan. En el siguiente ejemplo, hay una interfaz vacía llamada. BucketProps Los objetos myS3Bucket1 y myS3Bucket2 son válidos, pero siguen estándares diferentes porque la interfaz no exige ningún contrato. El siguiente código compilará e imprimirá las propiedades, pero esto generará incoherencias en la aplicación.

interface BucketProps {}

class S3Bucket implements BucketProps {
    constructor(props: BucketProps){
        console.log(props);
    }
}

const myS3Bucket1 = new S3Bucket({
    name: "my-bucket",
    region: "us-east-1",
    encryption: false,
});

const myS3Bucket2 = new S3Bucket({
    name: "my-bucket",
});

Utilizar fábricas

En un patrón Fábrica abstracta, una interfaz es responsable de crear una fábrica de objetos relacionados sin especificar sus clases de forma explícita. Por ejemplo, puede crear una fábrica de Lambda para crear funciones de Lambda. En lugar de crear una nueva función Lambda dentro de su construcción, delega el proceso de creación en la fábrica. Para obtener más información sobre este patrón de diseño, consulte Abstract Factory TypeScript en la documentación de Refactoring.Guru.

Utilizar la desestructuración en las propiedades

La desestructuración, introducida en ECMAScript 6 (ES6), es una JavaScript función que permite extraer varios datos de una matriz u objeto y asignarlos a sus propias variables.

const object = {
    objname: "obj",
    scope: "this",
};

const oName = object.objname;
const oScop = object.scope;

const { objname, scope } = object;

Definir las convenciones de nomenclatura estándar

La aplicación de una convención de nomenclatura mantiene la coherencia de la base de código y reduce la sobrecarga a la hora de pensar en cómo nombrar una variable. Le recomendamos lo siguiente:

• Utilice camelCase para los nombres de variables y funciones.

• Se utiliza PascalCase para los nombres de las clases y los nombres de las interfaces.

• Utilice camelCase para los miembros de la interfaz.

• Se utiliza PascalCase para nombres de tipos y nombres de enumeración.

• Nombre los archivos con camelCase (por ejemplo, ebsVolumes.tsx o storage.tsb)

No utilices la palabra clave var

La let sentencia se utiliza para declarar una variable local en TypeScript. Es similar a la var palabra clave, pero tiene algunas restricciones de alcance en comparación con la var palabra clave. Una variable declarada en un bloque con let solo se puede utilizar en ese bloque. La var palabra clave no puede tener un ámbito de bloques, lo que significa que se puede acceder a ella desde fuera de un bloque concreto (representado por{}), pero no fuera de la función en la que está definida. Puede volver a declarar y actualizar las variables. var Se recomienda evitar el uso de la palabra clave. var

Considerar el uso de ESLint y Prettier

ESLint analiza de forma estática su código para encontrar problemas con rapidez. Puede utilizar ESLint para crear una serie de afirmaciones (denominadas reglas lint) que definen cómo debe verse o comportarse su código. ESLint también tiene sugerencias de reparación automática para ayudarlo a mejorar su código. Por último, puede utilizar ESLint para cargar reglas lint desde complementos compartidos.

Prettier es un formateador de código conocido que admite una variedad de lenguajes de programación diferentes. Puede utilizar Prettier para establecer el estilo de su código y evitar formatear el código de forma manual. Tras la instalación, puede actualizar su archivo package.json y ejecutar los comandos npm run format y npm run lint.

El siguiente ejemplo le muestra cómo habilitar ESLint y el formateador Prettier para su proyecto. AWS CDK

"scripts": {
    "build": "tsc",
    "watch": "tsc -w",
    "test": "jest",
    "cdk": "cdk",
    "lint": "eslint --ext .js,.ts .",
    "format": "prettier --ignore-path .gitignore --write '**/*.+(js|ts|json)'"
}

Utilizar modificadores de acceso

El modificador privado TypeScript limita la visibilidad solo a la misma clase. Cuando agrega el modificador privado a una propiedad o método, puede acceder a esa propiedad o método dentro de la misma clase.

El modificador público permite acceder a las propiedades y los métodos de las clases desde todas las ubicaciones. Si no especificas ningún modificador de acceso para las propiedades y los métodos, usarán el modificador público de forma predeterminada.

El modificador protegido permite acceder a las propiedades y los métodos de una clase dentro de la misma clase y dentro de las subclases. Usa el modificador protegido cuando pienses crear subclases en tu aplicación. AWS CDK

Usa tipos de utilidades

Los tipos de utilidades TypeScript son funciones de tipos predefinidas que realizan transformaciones y operaciones en los tipos existentes. Esto le ayuda a crear tipos nuevos basados en los tipos existentes. Por ejemplo, puede cambiar o extraer propiedades, hacer que las propiedades sean opcionales u obligatorias, o crear versiones inmutables de los tipos. Al usar tipos de utilidades, puede definir tipos más precisos y detectar posibles errores en tiempo de compilación.

Parcial <Type>

Partialmarca todos los miembros de un tipo de entrada Type como opcionales. Esta utilidad devuelve un tipo que representa todos los subconjuntos de un tipo determinado. A continuación se muestra un ejemplo de Partial.

interface Dog {
  name: string;
  age: number;
  breed: string;
  weight: number;
}

let partialDog: Partial<Dog> = {};

Necesario <Type>

Requiredhace lo contrario dePartial. Hace que todos los miembros de un tipo de entrada Type no sean opcionales (en otras palabras, obligatorios). A continuación se muestra un ejemplo de Required.

interface Dog {
  name: string;
  age: number;
  breed: string;
  weight?: number;
}

let dog: Required<Dog> = { 
  name: "scruffy",
  age: 5,
  breed: "labrador",
  weight 55 // "Required" forces weight to be defined
};