JavaScript扩展语法（...）是否在其他编程语言中有等效语法？

Great question! I totally get where you're coming from—JavaScript's spread syntax (...) feels a little odd at first, but once you start using it for copying arrays/objects, unpacking function arguments, or combining collections, it becomes total second nature. Let's walk through equivalents in other popular languages, along with their official names:

Python #

Python has two operators that cover all of JavaScript's spread use cases:

• Iterable Unpacking Operator (*): Works for any iterable (lists, tuples, strings) and mirrors JS's array spread.
  Example code:

  # Copy a list
  original_list = [1, 2, 3]
  copied_list = [*original_list]
  
  # Unpack into function arguments
  def sum_three(a, b, c):
      return a + b + c
  nums = [4, 5, 6]
  print(sum_three(*nums))  # Output: 15
  

• Dictionary Unpacking Operator (**): For Python dictionaries (our version of JS objects), this does exactly what object spread does in JavaScript.
  Example code:

  user = {"name": "Mia", "age": 28}
  updated_user = {**user, "location": "Toronto"}
  

Ruby #

Ruby uses splat operators that handle both spread and rest parameter use cases (just like JS's ... does both spread and rest):

• Single Splat (*): For arrays and other enumerable types.
  Example code:

  # Duplicate an array
  original = [10, 20, 30]
  copied = [*original]
  
  # Unpack into method arguments
  def multiply(a, b, c)
    a * b * c
  end
  values = [2, 3, 4]
  puts multiply(*values)  # Output: 24
  

• Double Splat (**): For Ruby hashes (object-like structures), available in Ruby 2.0+.
  Example code:

  product = { name: "Laptop", price: 999 }
  discounted_product = { **product, discount: 100 }
  

TypeScript #

Since TypeScript is a superset of JavaScript, it supports the exact same ... spread syntax—no changes here! It works for arrays, objects, and function arguments just like vanilla JS, with the added benefit of type checking.

C# #

C# has a couple of tools to replicate spread behavior:

• Range Operator (..): Introduced in C# 8.0, this lets you create copies of arrays or lists, just like [...array] in JS.
  Example code:

  int[] original = { 1, 2, 3 };
  int[] copied = original[..]; // Creates a new array with all elements
  

• params Keyword: For unpacking collections into method parameters, params allows you to pass an array as individual arguments (similar to spreading function arguments in JS).
  Example code:

  static int CalculateSum(params int[] numbers)
  {
      return numbers.Sum();
  }
  
  int[] nums = { 5, 10, 15 };
  Console.WriteLine(CalculateSum(nums)); // Output: 30
  

Java #

Java doesn't have a dedicated spread operator, but you can replicate key behaviors with built-in features:

• Array Copying: Use Arrays.copyOf() to duplicate arrays, equivalent to JS's [...array].
• Varargs (...): In method definitions, varargs let you accept a variable number of arguments, which means you can pass an array directly as individual parameters (like spreading function arguments).
  Example code:

  public static int addNumbers(int... numbers) {
      int total = 0;
      for (int num : numbers) {
          total += num;
      }
      return total;
  }
  
  public static void main(String[] args) {
      int[] nums = { 3, 6, 9 };
      System.out.println(addNumbers(nums)); // Output: 18
  }
  

For object merging (like JS object spread), Java relies on constructors, builder patterns, or libraries rather than a native operator.

Overall, while the syntax and names differ, almost all modern languages have some form of unpacking/spreading functionality to handle the same common, boilerplate-reducing tasks that make JS's ... so useful.

内容的提问来源于stack exchange，提问作者Danyal Aytekin