Namenskonventionen für NodeJS

NodeJS

TypeScript

Conventions

In der dynamischen Welt der Node.js-Entwicklung sind die Lesbarkeit und Wartbarkeit des Codes von entscheidender Bedeutung. Einer der einfachsten, aber effektivsten Wege, dies zu erreichen, sind konsistente Namenskonventionen. Namenskonventionen helfen nicht nur dabei, den Code auf einen Blick zu verstehen, sondern stellen auch sicher, dass Ihre Codebasis skalierbar und einfach zu verwalten ist, wenn Ihr Projekt wächst. In diesem Blogbeitrag werden wir einige Best Practices für Namenskonventionen in Node.js untersuchen, die Ihre Codierungsstandards verbessern können.

Bevorzugen Sie “Bindestriche” gegenüber anderen Definitionen für Dateinamen

// gut
// fetch-sync.ts
export function fetchSync(endpoint: string){}
...
// schlecht
// fetchSync.ts
export function fetchSync(endpoint: string){}

...
// gut
// fetch-async.ts
export const fetchAsync = async (endpoint: string) => {}
...
// schlecht
// fetchAsync.ts
export const fetchAsync = async (endpoint: string) => {}

// gut
// foo-bar.ts
export class FooBar {
  ...
}
...
// schlecht
// fooBar.ts or FooBar.ts
export class FooBar {
  ...
}

// gut
// console-message.ts
export const ConsoleMessage = {
  ...
}
...
// schlecht
// consoleMessage.ts or ConsoleMessage.ts
export const ConsoleMessage = {
  ...
}

// gut
// http-status.ts
export enum HttpStatus {
  Ok = 200,
  BadRequest = 400
}
...
// schlecht
// httpStatus.ts or HttpStatus.ts
export enum HttpStatus {
  Ok = 200,
  BadRequest = 400
}

Wenn die Datei zu `spec` (Unit Test) gehört, bezeichne sie mit `.spec.ts`.

// gut
// fetsch-async.spec.ts
describe('fetchAsync', () => {
  ...
})
...
// schlecht
// fetschAsync.spec.ts
describe('fetchAsync', () => {
  ...
})

Vorschlag für: type vs. interface

Unterschiede zwischen Type und Interface
Verwenden Sie Interface, wenn Sie extends oder implements benötigen
Verwenden Sie Type, wenn Sie eine Vereinigung oder Überschneidung benötigen
Verwenden Sie lieber eine Interface als einen Type.

Vorschlag für Type

Verwenden Sie PascalCase für Namen.
Verwenden Sie camelCase für members.

// gut
type Foo = {
  foo: string;
  fooBar: number
};
...
// schlecht
type foo = {
  foo: string;
  fooBar: number
}

// schlecht
type Foo = {
  Foo: string;
  FooBar: number
}

Vorschlag für Interfaces

Verwenden Sie PascalCase für Namen.
Verwenden Sie camelCase für members.
Kein Präfix mit I

// gut
interface Foo {
  foo: string;
  fooBar: number
};

...
// schlecht
interface FooI {
  foo: string;
  fooBar: number
};

// schlecht
interface IFoo {
  foo: string;
  fooBar: number
};

Vorschlag für Klassennamen

Verwenden Sie PascalCase für Klassennamen.
Verwenden Sie camelCase für Klassenmitglieder und Methoden

// gut
class Bar {
  private foo: string;
  fooBar(){
    return 'foo-bar';
  }
}
...
// schlecht
class bar {
  private foo: string;
  fooBar(){
    return 'foo-bar';
  }
}

Vorschlag für Namensraumnamen

Klassennamen sind PascalCase => Namensraumnamen sind PascalCase

PascalCase für Namen verwenden

// gut
namespace Bar {
}
...
// schlecht
namespace bar {
}

Vorschlag für Enums

Verwenden Sie PascalCase für Enum-Namen
PascalCase für Enum-Mitglieder verwenden

// gut
enum Foo {
  Foo,
  Bar
}
...
// schlecht
enum foo {
  Foo,
  Bar
}
...
// schlecht
enum Foo {
  foo,
  bar
}

Schreiten Sie weiter voran und genießen Sie jeden Schritt Ihrer Programmierreise.