Spread và Rest

const array = [1, 2, 3, 4, 5];
 
console.log(...array); // 1 2 3 4 5

package main
 
import "fmt"
 
func main() {
	array := []byte{1, 2, 3, 4, 5}
 
	var i []any // any = interface{}, chứa được phần tử khác kiểu
	for _, value := range array {
		i = append(i, value)
	}
 
	fmt.Println(i...) // 1 2 3 4 5
}

fn main() {
    let array = [1, 2, 3, 4, 5];
 
    // Rust không có spread; một mảng cỡ cố định thì destructure được qua
    // pattern rồi in từng biến — không tổng quát hoá cho mảng cỡ động.
    let [a, b, c, d, e] = array;
    println!("{a} {b} {c} {d} {e}"); // 1 2 3 4 5
}

let array = [1, 2, 3, 4, 5]
 
// Swift không spread một mảng vào tham số variadic; phải join thủ công.
print(array.map(String.init).joined(separator: " ")) // 1 2 3 4 5

static String joinAll(Object... items) {
    return Arrays.stream(items).map(String::valueOf).collect(Collectors.joining(" "));
}
 
void main() {
    Integer[] array = {1, 2, 3, 4, 5};
 
    // truyền thẳng một mảng có sẵn vào tham số variadic — gần nhất với spread
    IO.println(joinAll((Object[]) array)); // 1 2 3 4 5
}

function sum(...nums) {
  let t = 0;
 
  for (let n of nums) {
    t += n;
  }
 
  return t;
}
 
console.log(sum(1, 2, 3, 4, 5)); // 15

func sum(nums ...int) int {
	var t int
	for _, n := range nums {
		t += n
	}
 
	return t
}
 
func main() {
	fmt.Println(sum(1, 2, 3, 4, 5)) // 15
}

// Rust không có hàm variadic thật; tương đương gần nhất là nhận một slice.
fn sum(nums: &[i32]) -> i32 {
    nums.iter().sum()
}
 
fn main() {
    println!("{}", sum(&[1, 2, 3, 4, 5])); // 15
}

// Swift có tham số variadic thật, gần với rest của JS nhất.
func sum(_ nums: Int...) -> Int {
    nums.reduce(0, +)
}
 
print(sum(1, 2, 3, 4, 5)) // 15

// Java cũng có tham số variadic thật.
static int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}
 
void main() {
    IO.println(sum(1, 2, 3, 4, 5)); // 15
}