Généralités

Concepts de base en programmation

• Variables et constantes.
  • 💡 Losque le langage permet d'en créer facilement (exemples: JS, TS et Kotlin), il est recommandé de créer des constantes par défaut et de changer en variables au besoin.
• Fonctions et arguments.
  • 💡 Beaucoup de langages permettent de donner des valeurs par défaut aux arguments.
• Structures de contrôle: if, for, for-each, while
• Interpolation de chaînes de caractères.
• Différence entre typage statique et dynamique.
  • Typage statique: le type d'une variable ou d'un argument ne change pas.
  • Typage dynamique: le type d'une variable ou d'un argument peut changer.
• Si le compilateur déduit le type d'une donnée dans certaines situation sans qu'on ait à l'expliciter, on dit que c'est un typage implicite. C'est aussi appelé l'inférence de types.

Préfixer ses classes, fonctions, variables et constantes par export permet de les rendre accessibles dans d'autres fichiers.

static_demo.ts

// Méthode globale (pas conseillée si on veut suivre l'orienté objet)
export function subsctract(x: number, y: number): number {
  return x - y;
}

export const gravity = 10;

export class MathUtils {
  // doit être appelé depuis la classe
  static readonly PI = 3.14;
  // doit être appelé depuis la classe
  static add(x: number, y: number): number {
    return x + y;
  }
  // doit être appelé depuis une instance
  multiply(x: number, y: number): number {
    return x * y;
  }
}

console.log(MathUtils.PI);
console.log(MathUtils.add(2, 5));

const mu = new MathUtils();
console.log(mu.multiply(2, 5));

// erreur
//console.log(MathUtils.multiply(2, 5));

// On ne peut pas appeler du statique depuis un objet en TS
// console.log(mu.PI);
// console.log(mu.add(2, 5));

Des clauses import en début de fichier permettent d'utiliser des symboles exportés par d'autres fichiers. Le doc de MDN montre les différentes syntaxes possibles de la clause import.

import_demo.ts

import { MathUtils, subsctract, gravity } from "./static_demo";

console.log(MathUtils.PI);
console.log(subsctract(10, -4), gravity);

Export et import en TypeScript

Quick tour of TypeScript

let amount: number = 400;
//amount = "Hello"; // error because TS est statically typed

// TypeScript allows to type implicitly in certain situations
const message = "hello";

function sayHello(s: string) {
  console.log(s);
}
sayHello("Hello");

// Type unions allows to allow multiple types to the same variable
let x: number | string = "Hello";
x = 5;
console.log(x);

// String interpolation possible with back-tick `
console.log(`I am an interpolated string ${x}, ${message}`);

Règles de nommage

• Une variable porte un nom passif qui commence par une majuscule
• Une variable de type collection (tableau, liste, etc.) porte un nom au pluriel
• Le nom d'une fonction commence par un verbe.
  • Dans la plupart des langages, le nom d'une fonction commence par une minuscule.
• Respecter le type de séparation entre les mots d'un identifiant
  • Kamel case
  • Snake case
  • Kebab case