Les Fonctions

// Definition
function saluer(nom) {
    return `Bonjour ${nom} !`;
}

// Appel
const message = saluer("Alice");
console.log(message);  // "Bonjour Alice !"

// Definition (dans une classe)
public static String saluer(String nom) {
    return "Bonjour " + nom + " !";
}

// Appel
String message = saluer("Alice");
System.out.println(message);  // "Bonjour Alice !"

// Definition
static string Saluer(string nom) {
    return $"Bonjour {nom} !";
}

// Appel
string message = Saluer("Alice");
Console.WriteLine(message);  // "Bonjour Alice !"

// Definition
std::string saluer(std::string nom) {
    return "Bonjour " + nom + " !";
}

// Appel
std::string message = saluer("Alice");
std::cout << message << std::endl;  // "Bonjour Alice !"

# Definition avec function()
saluer <- function(nom) {
    paste("Bonjour", nom, "!")
}

# Appel
message <- saluer("Alice")
print(message)  # "Bonjour Alice !"

# R retourne la derniere expression auto !
carre <- function(x) x^2  # Une ligne

// Plusieurs parametres
function calculerPrix(prix, quantite, remise) {
    const total = prix * quantite;
    const reduction = total * remise;
    return total - reduction;
}

// Utilisation
const final = calculerPrix(100, 3, 0.1);
console.log(final);  // 270

// Plusieurs parametres
static double calculerPrix(double prix, int quantite, double remise) {
    double total = prix * quantite;
    double reduction = total * remise;
    return total - reduction;
}

// Utilisation
double finalPrice = calculerPrix(100, 3, 0.1);
System.out.println(finalPrice);  // 270.0

// Parametres par defaut avec =
function saluer(nom, langue = "fr", formel = false) {
    let salut;
    if (langue === "fr") {
        salut = formel ? "Bonjour" : "Salut";
    } else {
        salut = formel ? "Good day" : "Hi";
    }
    return `${salut} ${nom} !`;
}

// Differentes facons d'appeler :
saluer("Alice");                   // Salut Alice !
saluer("Bob", "en");              // Hi Bob !
saluer("Marie", "fr", true);     // Bonjour Marie !

// Java n'a PAS de parametres par defaut !
// On utilise la SURCHARGE (overloading) :

static String saluer(String nom) {
    return saluer(nom, "fr", false);  // Appelle la version complete
}

static String saluer(String nom, String langue) {
    return saluer(nom, langue, false);
}

static String saluer(String nom, String langue, boolean formel) {
    String salut = langue.equals("fr")
        ? (formel ? "Bonjour" : "Salut")
        : (formel ? "Good day" : "Hi");
    return salut + " " + nom + " !";
}

// Java choisit automatiquement la bonne version !
saluer("Alice");                   // → version 1 param
saluer("Bob", "en");              // → version 2 params
saluer("Marie", "fr", true);     // → version 3 params

// JavaScript : parametres par defaut
function aire(a, b = null, forme = "rect") {
    if (b === null) {
        return a * a;                   // Carre
    } else if (forme === "tri") {
        return (a * b) / 2;            // Triangle
    } else {
        return a * b;                   // Rectangle
    }
}

// Utilisation :
aire(5);                 // 25 (carre)
aire(4, 6);              // 24 (rectangle)
aire(4, 6, "tri");       // 12 (triangle)

// Java : VRAIE surcharge (plusieurs methodes)
static double aire(double cote) {
    return cote * cote;              // Carre
}

static double aire(double longueur, double largeur) {
    return longueur * largeur;       // Rectangle
}

static double aire(double base, double hauteur, String type) {
    if (type.equals("triangle")) {
        return (base * hauteur) / 2;
    }
    return base * hauteur;
}

// Java choisit la bonne methode selon les arguments !
aire(5);                           // → version 1 param
aire(4, 6);                        // → version 2 params
aire(4, 6, "triangle");           // → version 3 params

// Fonction classique
function doubler(x) {
    return x * 2;
}

// Arrow function equivalente
const doubler = (x) => x * 2;

console.log(doubler(5));  // 10

// Utile avec map, filter...
const nombres = [1, 2, 3, 4];
const doubles = nombres.map(x => x * 2);
// [2, 4, 6, 8]

// Java 8+ avec lambdas
List<Integer> nombres = Arrays.asList(1, 2, 3, 4);

// Lambda avec Stream API
List<Integer> doubles = nombres.stream()
    .map(x -> x * 2)  // Lambda
    .collect(Collectors.toList());
// [2, 4, 6, 8]

// Interface fonctionnelle
Function<Integer, Integer> doubler = x -> x * 2;
doubler.apply(5);  // 10

// C# avec lambdas
var nombres = new List<int> { 1, 2, 3, 4 };

// Lambda avec LINQ
var doubles = nombres.Select(x => x * 2).ToList();
// [2, 4, 6, 8]

// Func delegate
Func<int, int> doubler = x => x * 2;
doubler(5);  // 10

function afficherMenu() {
    console.log("=== MENU ===");
    console.log("1. Jouer");
    console.log("2. Options");
    console.log("3. Quitter");
    // Pas de return (retourne undefined)
}

afficherMenu();  // Affiche le menu

// void = pas de retour
static void afficherMenu() {
    System.out.println("=== MENU ===");
    System.out.println("1. Jouer");
    System.out.println("2. Options");
    System.out.println("3. Quitter");
}

afficherMenu();  // Affiche le menu

const additionner = (a, b) => a + b;
const soustraire = (a, b) => a - b;
const multiplier = (a, b) => a * b;
const diviser = (a, b) => b === 0 ? "Erreur" : a / b;

function calculer(a, op, b) {
    const operations = {
        "+": additionner,
        "-": soustraire,
        "*": multiplier,
        "/": diviser
    };
    return operations[op]?.(a, b) ?? "Operation inconnue";
}

console.log(calculer(10, "+", 5));  // 15
console.log(calculer(10, "/", 3));  // 3.333...