Générateur de noms de projets aléatoires

' Fonction VBA Excel pour le générateur de noms de projet axé sur le développement
Function GenerateProjectName(Optional prefix As String = "", Optional suffix As String = "") As String
    Dim techPrefixes As Variant
    Dim techRoles As Variant
    techPrefixes = Array("React", "Angular", "Vue", "Node", "Express", "Django", "Spring")
    techRoles = Array("Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework")
    
    Dim techPrefix As String
    Dim techRole As String
    
    techPrefix = techPrefixes(Int(Rnd() * UBound(techPrefixes)))
    techRole = techRoles(Int(Rnd() * UBound(techRoles)))
    
    If prefix <> "" Then
        If Not prefix Like "*-" Then prefix = prefix & "-"
    End If
    
    If suffix <> "" Then
        If Not suffix Like "-*" Then suffix = "-" & suffix
    End If
    
    GenerateProjectName = prefix & techPrefix & "-" & techRole & suffix
End Function

' Exemple d'utilisation dans une cellule :
' =GenerateProjectName("my", "app")

# Fonction R pour le générateur de noms de projet axé sur le développement
generate_project_name <- function(prefix = "", suffix = "") {
  tech_prefixes <- c("React", "Angular", "Vue", "Node", "Express", "Django", "Spring")
  tech_roles <- c("Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework")
  
  tech_prefix <- sample(tech_prefixes, 1)
  tech_role <- sample(tech_roles, 1)
  
  if (prefix != "" && !endsWith(prefix, "-")) {
    prefix <- paste0(prefix, "-")
  }
  
  if (suffix != "" && !startsWith(suffix, "-")) {
    suffix <- paste0("-", suffix)
  }
  
  paste0(prefix, tech_prefix, "-", tech_role, suffix)
}

# Exemple d'utilisation
print(generate_project_name("my", "app"))

% Fonction MATLAB pour le générateur de noms de projet axé sur le développement
function projectName = generateProjectName(prefix, suffix)
    if nargin < 1
        prefix = "";
    end
    if nargin < 2
        suffix = "";
    end
    
    techPrefixes = {'React', 'Angular', 'Vue', 'Node', 'Express', 'Django', 'Spring'};
    techRoles = {'Frontend', 'Backend', 'API', 'Service', 'Microservice', 'Engine', 'Framework'};
    
    techPrefix = techPrefixes{randi(length(techPrefixes))};
    techRole = techRoles{randi(length(techRoles))};
    
    if ~isempty(prefix) && ~endsWith(prefix, "-")
        prefix = prefix + "-";
    end
    
    if ~isempty(suffix) && ~startsWith(suffix, "-")
        suffix = "-" + suffix;
    end
    
    projectName = prefix + techPrefix + "-" + techRole + suffix;
end

% Exemple d'utilisation
disp(generateProjectName("my", "app"));

import random

def generate_project_name(prefix="", suffix=""):
    tech_prefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"]
    tech_roles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"]
    
    tech_prefix = random.choice(tech_prefixes)
    tech_role = random.choice(tech_roles)
    
    if prefix and not prefix.endswith("-"):
        prefix += "-"
    
    if suffix and not suffix.startswith("-"):
        suffix = "-" + suffix
    
    return f"{prefix}{tech_prefix}-{tech_role}{suffix}"

# Exemple d'utilisation
print(generate_project_name("my", "app"))

function generateProjectName(prefix = "", suffix = "") {
  const techPrefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"];
  const techRoles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"];
  
  const techPrefix = techPrefixes[Math.floor(Math.random() * techPrefixes.length)];
  const techRole = techRoles[Math.floor(Math.random() * techRoles.length)];
  
  if (prefix && !prefix.endsWith("-")) {
    prefix += "-";
  }
  
  if (suffix && !suffix.startsWith("-")) {
    suffix = "-" + suffix;
  }
  
  return `${prefix}${techPrefix}-${techRole}${suffix}`;
}

// Exemple d'utilisation
console.log(generateProjectName("my", "app"));

import java.util.Random;

public class ProjectNameGenerator {
    private static final String[] TECH_PREFIXES = {"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"};
    private static final String[] TECH_ROLES = {"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"};
    private static final Random RANDOM = new Random();

    public static String generateProjectName(String prefix, String suffix) {
        String techPrefix = TECH_PREFIXES[RANDOM.nextInt(TECH_PREFIXES.length)];
        String techRole = TECH_ROLES[RANDOM.nextInt(TECH_ROLES.length)];
        
        if (prefix != null && !prefix.isEmpty() && !prefix.endsWith("-")) {
            prefix += "-";
        }
        
        if (suffix != null && !suffix.isEmpty() && !suffix.startsWith("-")) {
            suffix = "-" + suffix;
        }
        
        return prefix + techPrefix + "-" + techRole + suffix;
    }

    public static void main(String[] args) {
        System.out.println(generateProjectName("my", "app"));
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <random>
#include <chrono>

std::string generateProjectName(const std::string& prefix = "", const std::string& suffix = "") {
    std::vector<std::string> techPrefixes = {"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"};
    std::vector<std::string> techRoles = {"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"};

    unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
    std::default_random_engine generator(seed);

    std::uniform_int_distribution<int> prefixDist(0, techPrefixes.size() - 1);
    std::uniform_int_distribution<int> roleDist(0, techRoles.size() - 1);

    std::string techPrefix = techPrefixes[prefixDist(generator)];
    std::string techRole = techRoles[roleDist(generator)];
    
    std::string finalPrefix = prefix;
    if (!finalPrefix.empty() && !finalPrefix.back() == '-') {
        finalPrefix += "-";
    }
    
    std::string finalSuffix = suffix;
    if (!finalSuffix.empty() && !finalSuffix.front() == '-') {
        finalSuffix = "-" + finalSuffix;
    }
    
    return finalPrefix + techPrefix + "-" + techRole + finalSuffix;
}

int main() {
    std::cout << generateProjectName("my", "app") << std::endl;
    return 0;
}

using System;

class ProjectNameGenerator
{
    static readonly string[] TechPrefixes = { "React", "Angular", "Vue", "Node", "Express", "Django", "Spring" };
    static readonly string[] TechRoles = { "Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework" };
    static readonly Random Random = new Random();

    static string GenerateProjectName(string prefix = "", string suffix = "")
    {
        string techPrefix = TechPrefixes[Random.Next(TechPrefixes.Length)];
        string techRole = TechRoles[Random.Next(TechRoles.Length)];
        
        if (!string.IsNullOrEmpty(prefix) && !prefix.EndsWith("-"))
        {
            prefix += "-";
        }
        
        if (!string.IsNullOrEmpty(suffix) && !suffix.StartsWith("-"))
        {
            suffix = "-" + suffix;
        }
        
        return $"{prefix}{techPrefix}-{techRole}{suffix}";
    }

    static void Main()
    {
        Console.WriteLine(GenerateProjectName("my", "app"));
    }
}

class ProjectNameGenerator
  TECH_PREFIXES = %w[React Angular Vue Node Express Django Spring]
  TECH_ROLES = %w[Frontend Backend API Service Microservice Engine Framework]

  def self.generate(prefix = "", suffix = "")
    tech_prefix = TECH_PREFIXES.sample
    tech_role = TECH_ROLES.sample
    
    prefix += "-" if !prefix.empty? && !prefix.end_with?("-")
    suffix = "-" + suffix if !suffix.empty? && !suffix.start_with?("-")
    
    "#{prefix}#{tech_prefix}-#{tech_role}#{suffix}"
  end
end

# Exemple d'utilisation
puts ProjectNameGenerator.generate("my", "app")

package main

import (
	"fmt"
	"math/rand"
	"strings"
	"time"
)

var techPrefixes = []string{"React", "Angular", "Vue", "Node", "Express", "Django", "Spring"}
var techRoles = []string{"Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"}

func generateProjectName(prefix, suffix string) string {
	rand.Seed(time.Now().UnixNano())
	
	techPrefix := techPrefixes[rand.Intn(len(techPrefixes))]
	techRole := techRoles[rand.Intn(len(techRoles))]
	
	if prefix != "" && !strings.HasSuffix(prefix, "-") {
		prefix += "-"
	}
	
	if suffix != "" && !strings.HasPrefix(suffix, "-") {
		suffix = "-" + suffix
	}
	
	return prefix + techPrefix + "-" + techRole + suffix
}

func main() {
	fmt.Println(generateProjectName("my", "app"))
}

import Foundation

struct ProjectNameGenerator {
    static let techPrefixes = ["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"]
    static let techRoles = ["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"]
    
    static func generate(prefix: String = "", suffix: String = "") -> String {
        guard let techPrefix = techPrefixes.randomElement(),
              let techRole = techRoles.randomElement() else {
            return "Unknown-Project"
        }
        
        var finalPrefix = prefix
        if !finalPrefix.isEmpty && !finalPrefix.hasSuffix("-") {
            finalPrefix += "-"
        }
        
        var finalSuffix = suffix
        if !finalSuffix.isEmpty && !finalSuffix.hasPrefix("-") {
            finalSuffix = "-" + finalSuffix
        }
        
        return "\(finalPrefix)\(techPrefix)-\(techRole)\(finalSuffix)"
    }
}

// Exemple d'utilisation
print(ProjectNameGenerator.generate(prefix: "my", suffix: "app"))

use rand::seq::SliceRandom;

fn generate_project_name(prefix: &str, suffix: &str) -> String {
    let tech_prefixes = vec!["React", "Angular", "Vue", "Node", "Express", "Django", "Spring"];
    let tech_roles = vec!["Frontend", "Backend", "API", "Service", "Microservice", "Engine", "Framework"];
    
    let mut rng = rand::thread_rng();
    
    let tech_prefix = tech_prefixes.choose(&mut rng).unwrap_or(&"Unknown");
    let tech_role = tech_roles.choose(&mut rng).unwrap_or(&"Project");
    
    let mut final_prefix = prefix.to_string();
    if !final_prefix.is_empty() && !final_prefix.ends_with("-") {
        final_prefix.push_str("-");
    }
    
    let mut final_suffix = suffix.to_string();
    if !final_suffix.is_empty() && !final_suffix.starts_with("-") {
        final_suffix = format!("-{}", final_suffix);
    }
    
    format!("{}{}-{}{}", final_prefix, tech_prefix, tech_role, final_suffix)
}

fn main() {
    println!("{}", generate_project_name("my", "app"));
}

<?php

class ProjectNameGenerator {
    private static $techPrefixes = ['React', 'Angular', 'Vue', 'Node', 'Express', 'Django', 'Spring'];
    private static $techRoles = ['Frontend', 'Backend', 'API', 'Service', 'Microservice', 'Engine', 'Framework'];

    public static function generate($prefix = '', $suffix = '') {
        $techPrefix = self::$techPrefixes[array_rand(self::$techPrefixes)];
        $techRole = self::$techRoles[array_rand(self::$techRoles)];
        
        if ($prefix !== '' && !str_ends_with($prefix, '-')) {
            $prefix .= '-';
        }
        
        if ($suffix !== '' && !str_starts_with($suffix, '-')) {
            $suffix = '-' . $suffix;
        }
        
        return $prefix . $techPrefix . '-' . $techRole . $suffix;
    }
}

// Exemple d'utilisation
echo ProjectNameGenerator::generate('my', 'app');