Joindre les éléments d'un tableau en chaîne délimitée snippet

-- PostgreSQL: join an ARRAY with a delimiter
SELECT array_to_string(ARRAY['go', 'rust', 'zig'], ', ') AS langs;
-- langs: go, rust, zig

-- Joining ROWS is a different job — aggregate, don't array-join:
SELECT string_agg(name, ', ' ORDER BY name) AS langs
FROM (VALUES ('zig'), ('go'), ('rust')) AS t(name);
-- langs: go, rust, zig

const langs = ['go', 'rust', 'zig'];
console.log(langs.join(', ')); // go, rust, zig

// join() COERCES instead of throwing — know the rules:
console.log([1, null, undefined, [2, 3]].join('|')); // 1|||2,3
// null/undefined become '' and nested arrays flatten ONE level,
// so the separator inside the nested array is ',' — not yours.

const parts: string[] = ['a', 'b', 'c'];
const csv: string = parts.join(',');

// Typed arrays of string | null join fine at runtime but lie about
// content — scrub before joining to keep the type honest:
const dirty: (string | null)[] = ['a', null, 'c'];
const clean: string = dirty.filter((p): p is string => p !== null).join(',');
console.log(csv, clean); // a,b,c a,c

package main

import (
	"fmt"
	"strings"
)

func main() {
	langs := []string{"go", "rust", "zig"}
	fmt.Println(strings.Join(langs, ", ")) // go, rust, zig
}

fn main() {
    let langs = vec!["go", "rust", "zig"];
    println!("{}", langs.join(", ")); // go, rust, zig

    // Non-strings: map to String first, then join.
    let nums: Vec<String> = [1, 2, 3].iter().map(|n| n.to_string()).collect();
    println!("{}", nums.join("-")); // 1-2-3
}

<?php
$langs = ['go', 'rust', 'zig'];
echo implode(', ', $langs), PHP_EOL; // go, rust, zig

// null silently becomes ''; scalars are cast; nested arrays WARN:
$dirty = ['a', null, 3];
echo implode('|', $dirty), PHP_EOL; // a||3

langs = ["go", "rust", "zig"]
print(", ".join(langs))                          # go, rust, zig
print("-".join(str(n) for n in [1, None, 3]))   # 1-None-3 — None is NOT skipped

# Non-str elements raise TypeError, and the message is the teacher:
try:
    ", ".join(["a", 1])
except TypeError as err:
    print(err)  # sequence item 1: expected str instance, int found

#include <stdio.h>
#include <string.h>

/* Join n parts with sep into out (size bytes). NUL-terminates, truncates
   safely on overflow, and never emits the separator after the last part.
   Returns out. */
char *join(char *out, size_t size, const char *sep, const char **parts, size_t n) {
    size_t pos = 0;
    out[0] = '\0';
    for (size_t i = 0; i < n; i++) {
        size_t len = strlen(parts[i]);
        size_t sep_len = i > 0 ? strlen(sep) : 0;
        if (pos + sep_len + len + 1 > size) {
            break; /* not enough room for part + NUL — stop here */
        }
        if (i > 0) {
            memcpy(out + pos, sep, sep_len);
            pos += sep_len;
        }
        memcpy(out + pos, parts[i], len);
        pos += len;
        out[pos] = '\0';
    }
    return out;
}

int main(void) {
    const char *parts[] = {"go", "rust", "zig"};
    char buf[64];
    printf("%s\n", join(buf, sizeof buf, ", ", parts, 3)); /* go, rust, zig */
    return 0;
}

#include <iostream>
#include <string>
#include <vector>

// Separator BETWEEN elements only — the `if (i > 0)` guard is what
// kills the trailing-separator bug. C++23 adds std::views::join_with.
std::string join(const std::vector<std::string>& parts, const std::string& sep) {
    std::string out;
    for (std::size_t i = 0; i < parts.size(); ++i) {
        if (i > 0) out += sep;
        out += parts[i];
    }
    return out;
}

int main() {
    std::cout << join({"go", "rust", "zig"}, ", ") << '\n'; // go, rust, zig
}

string[] langs = { "go", "rust", "zig" };
Console.WriteLine(string.Join(", ", langs)); // go, rust, zig

// Accepts IEnumerable<T> and calls ToString; null renders as empty:
Console.WriteLine(string.Join(", ", new object?[] { 1, null, "x" })); // 1, , x

import java.util.List;

public class JoinDemo {
    public static void main(String[] args) {
        List<String> langs = List.of("go", "rust", "zig");
        System.out.println(String.join(", ", langs)); // go, rust, zig
    }
}

let langs = ["go", "rust", "zig"]
print(langs.joined(separator: ", ")) // go, rust, zig

// Non-strings: map to String first.
print([1, 2, 3].map(String.init).joined(separator: "-")) // 1-2-3

fun main() {
    val langs = listOf("go", "rust", "zig")
    println(langs.joinToString(", ")) // go, rust, zig

    println(listOf(1, null, 3).joinToString("-")) // 1-null-3
}

langs = %w[go rust zig]
puts langs.join(', ') # go, rust, zig

# nil stringifies to '' — and nested arrays are flattened RECURSIVELY,
# with your separator applied inside them too:
puts [1, nil, [2, 3]].join('|').inspect # "1||2|3"

const std = @import("std");

pub fn main() !void {
    const parts = [_][]const u8{ "go", "rust", "zig" };
    const sep = ", ";

    // Size the buffer exactly (saturating sub guards the empty case),
    // allocate once, then fill — no trailing separator.
    var total: usize = 0;
    for (parts) |p| total += p.len;
    total += sep.len * (parts.len -| 1);

    const a = std.heap.page_allocator;
    const out = try a.alloc(u8, total);
    defer a.free(out);

    var pos: usize = 0;
    for (parts, 0..) |p, i| {
        if (i > 0) {
            @memcpy(out[pos..][0..sep.len], sep);
            pos += sep.len;
        }
        @memcpy(out[pos..][0..p.len], p);
        pos += p.len;
    }
    std.debug.print("{s}\n", .{out}); // go, rust, zig
}