Qualité de code

let message : string = 'Hello world!'
let maxNumberOfWords = 15
function writeLine(line : string) {...}

let MESSAGE : string = 'Hello world!'
let max_number_of_words = 15
function WriteLine(line : string) {...}

type LabelledValue {...}
type Point3D {...}
type GraduateStudent {...}

type Labelled_Value {...}
type POINT3D {...}
type graduatestudent {...}

const ANNEE_FONDATION : number = 2022
console.log(`Nantes Université a été fondée en ${ANNEE_FONDATION}`);

kebab-case-looks-like-this
max-parallel-events

snake_case_looks_like_this
another_variable_name

ALSO_KNOWN_AS_UPPER_CASE_EMBEDDED_UNDERSCORE
COMMONLY_REFERS_TO_CONSTANTS

const maximumNumberOfActiveThreads : number = 8;

const MAXIMUM_NUMBER_OF_ACTIVE_THREADS : number = 8;

function sumArray(values : number[]): number {
    let sum: number;
    for (let each of list) {
        sum = sum + each;
    }
    return sum;
}

function euclideanNorm(values: number[]): number {
    let retval: number = 0;
    for(let i : number = 0; i  < values.length ; i+=1) {
        retval += values[i] * values[i]
    }
    return Math.sqrt(retval);
}

retval += values[i] + values[i]

sumOfSquares += values[i] + values[i]

    if(begin > end) {
        let tmp: number = end;
        end = begin;
        begin = tmp;
    }

for(let i : number = 0; i < 10; i+=1) {
    for(let j : number = 0; j < 20; j+=1) {
        for(let k : number = 0; k < 40; k+=1) {
            // instructions
        }
    }
}

function wait(delay: number){}

function wait(delayMilliseconds: number){}

let start: number = now();
treatmentThatTakesTime();
let elapsed = now() - start;
console.log("The execution took " + elapsed.toString() + "seconds")

let startMilliseconds: number = now();
treatmentThatTakesTime();
let elapsedMilliseconds = now() - startMilliseconds;
console.log("The execution took " +
    elapsedMilliseconds.toString() + "seconds")

results = filter(clients, "birthyear > 2000")

const tooManyCartItems: number = 24;

const maxNumberOfCartItems: number = 24;

todayEvents = eventsInRange("22/1/2018 00:00", "23/1/2018 00:00")

todayEvents = eventsInRange("22/1/2018 00:00", "22/1/2018 23:59")

let readPassword: boolean = true;

let isAuthenticated : boolean = true;
let needPassword    : boolean = true;

function pgcd(a: number, b: number): number
{
	while (a!=b){
	if (a>b){ a-=b ;}
	else {b-=a;}
	}
	return a;}

title = request.POST.get('title')
email = request.POST.get('email')
location = request.POST.get('location')
email = request.POST.get('email')
url = request.POST.get('url')
details = request.POST.get('details')

title    = request.POST.get('title')
email    = request.POST.get('email')
location = request.POST.get('location')
email    = request.POST.get('email')
url      = request.POST.get('url')
details  = request.POST.get('details')

function validateEmail(email: Email): string {
 let error:string="";
 let tfl:string = email.value.trim();
 let emailFilter:RegExp = /^[^@]+@[^@.]+\.[^@]*\w\w$/ ;
 let illegalChars:RegExp = /[\(\)\<\>\,\;\:\\\"\[\]]/ ;
 if (email.value === "") {
     email.style.background = 'Yellow';
     error = "You didn't enter an email address.\n";
 } else if (!emailFilter.test(tfld)) {
     email.style.background = 'Yellow';
     error = "Please enter a valid email address.\n";
 } else if (email.value.match(illegalChars)) {
     email.style.background = 'Yellow';
     error = "The email address contains illegal characters.\n";
 } else {
     email.style.background = 'White';
 }
 return error;
}

function validateEmail(email: Email): string {
    const emailFilter : RegExp = /^[^@]+@[^@.]+\.[^@]*\w\w$/;
    const illegalChars: RegExp = /[\(\)\<\>\,\;\:\\\"\[\]]/;

    let error   : string = "";
    let tfl     : string = email.value.trim();

    if (email.value === "") {
        email.style.background = 'Yellow';
        error = "You didn't enter an email address.\n";

    } else if (!emailFilter.test(tfld)) {
        email.style.background = 'Yellow';
        error = "Please enter a valid email address.\n";

    } else if (email.value.match(illegalChars)) {
        email.style.background = 'Yellow';
        error = "The email address contains illegal characters.\n";

    } else {
        email.style.background = 'White';
    }

    return error;
}

1er CAS : Aucun robinet d’arrêt n’est fermé :
    Purger la valve
2e CAS : Un robinet d’arrêt est fermé :
    Ouvrir le robinet
    Dans les 2 cas :
      - ouvrir le robinet d’arrêt
      - vérifier les freins du dernier véhicule
Remettre le train en marche

1er CAS : Aucun robinet d’arrêt n’est fermé :
    Purger la valve
2e CAS : Un robinet d’arrêt est fermé :
    Ouvrir le robinet
Dans les 2 cas :
    - ouvrir le robinet d’arrêt
    - vérifier les freins du dernier véhicule
Remettre le train en marche

annee = 2026
if annee == 2026:
print("Cette année")

IndentationError: expected an indented block after 'if' statement on line 2

// Function declaration
function factorial(num: number): number {
    let factorial:number = 1; // Assigns 1 to factorial
    let i: number = num; // Assigns num to i

    while(i >= 1) {  // loops while i >= 1
        // assigns factorial with de product of factorial and i
        factorial = factorial * i;
        i--; // decrements i
     }
     return factorial; // return factorial
}

// Total number of active threads for handling requets
const threads: number = 5

// I compared the performance several times using from 1 to 20 active
// threads and find out that 5 active threads achieves the best
// performance for 8 cores CPU.
const numberOfActiveThreads = 5;

/*
after hours of consulting the tome of google
i have discovered that by the will of unknown forces
without the below line, IE7 believes that 6px = 12px
*/
font-size: 0px;

// After adding new features for version 3.0 (November 2017), the
// code became fragile. Maybe we should split this function into
// two others, displayRaw() and displayHTML().
function display(){}

// Calculates the factorial of a number.
function factorial(num: number): number {
    let factorial:number = 1;
    let i: number = num;

    // A loop has better performance than recursive calls.
    while(i >= 1) {
        factorial = factorial * i;
        i--;
     }
     return factorial;
}

if (length > 10)

if (10 < length)

timeString = (hour > 12) ? 'pm' : 'am';

let isLeapYear: boolean = ((year % 400) === 0) ? true :
                            (((year % 100) === 0)? false :
                            (((year % 4) === 0)  ? true : false));

float _x = abs(x - deviceInfo->position.x) / scale;
int directionCode;
if (0 < _x && x != deviceInfo->position.x) {
  if (0 > x - deviceInfo->position.x) {
    directionCode = 0x04 /*left*/;
  } else if (0 < x - deviceInfo->position.x) {
    directionCode = 0x02 /*right*/;
  }
}

static const int DIRECTION_CODE_RIGHT = 0x02;
static const int DIRECTION_CODE_LEFT = 0x04;
static const int DIRECTION_CODE_NONE = 0x00;

int oldX = deviceInfo->position.x;
int directionCode
  = (x > oldX)? DIRECTION_CODE_RIGHT
  : (x < oldX)? DIRECTION_CODE_LEFT
  : DIRECTION_CODE_NONE;

function contains(str: string , substr: string ): boolean {
    if (str === null || substr === null) return false;
    if (substr === "") return true;

    // (...)
}

if (a === b) {
    // Cas 1
} else {
    // Cas 2
}

if (a !== b) {
    // Cas 2
} else {
    // Cas 1
}

if (<booleanExpression>) {
    return true;
} else {
    return false;
}

if (a > b) {
    return true;
} else {
    return false;
}

let annee = 2046;
if(annee = 2000){
    console.log("An 2000 !");
}else{
    console.log("Pas l'an 2000");
}

if(2046 == "2046"){
    console.log("Test 1");
}
if(2046 === "2046"){
    console.log("Test 2");
}