Let’s dive deeper into the statement comparing how functions are defined and used in TypeScript and C#, focusing on their declaration styles, parameter handling, and overloading mechanisms. I’ll provide clear examples to illustrate each point.

TypeScript: Function Declarations and Features

TypeScript, as a superset of JavaScript, offers multiple ways to declare functions, inheriting JavaScript’s flexibility while adding type safety. It supports optional and rest parameters but does not allow traditional function overloading, instead using union types for flexibility.

1. Function Declaration Styles

TypeScript allows functions to be defined in several ways:

• Using the function keyword:

  function greet(name: string): string {
      return `Hello, ${name}!`;
  }
  console.log(greet("Alice")); // Output: Hello, Alice!
• Arrow functions (concise syntax, often used for callbacks or functional programming):

  const greetArrow = (name: string): string => `Hello, ${name}!`;
  console.log(greetArrow("Bob")); // Output: Hello, Bob!
• As methods in objects or classes:

  class Greeter {
      greet(name: string): string {
          return `Hello, ${name}!`;
      }
  }
  const greeter = new Greeter();
  console.log(greeter.greet("Charlie")); // Output: Hello, Charlie!
   
  // Object method
  const obj = {
      greet(name: string): string {
          return `Hello, ${name}!`;
      }
  };
  console.log(obj.greet("Dave")); // Output: Hello, Dave!

These options provide flexibility, especially in JavaScript-heavy environments, where arrow functions are popular for their concise syntax and lexical this binding.

2. Optional and Rest Parameters

• Optional Parameters: Parameters can be marked optional with ?, meaning they can be omitted when calling the function. Optional parameters must come after required ones.

  function describePerson(name: string, age?: number): string {
      return age ? `${name} is ${age} years old` : `${name} has no age provided`;
  }
  console.log(describePerson("Alice")); // Output: Alice has no age provided
  console.log(describePerson("Bob", 30)); // Output: Bob is 30 years old
• Rest Parameters: Use ... to collect multiple arguments into an array, allowing variable-length argument lists.

  function sumNumbers(...numbers: number[]): number {
      return numbers.reduce((sum, num) => sum + num, 0);
  }
  console.log(sumNumbers(1, 2, 3)); // Output: 6
  console.log(sumNumbers(10)); // Output: 10
  console.log(sumNumbers()); // Output: 0

3. No Function Overloading, but Union Types for Flexibility

TypeScript does not support traditional function overloading (multiple signatures for the same function name with different parameter types). Instead, it uses union types to handle different input types flexibly.

• Union Types Example:

  function processInput(input: string | number): string {
      if (typeof input === "string") {
          return `String input: ${input.toUpperCase()}`;
      } else {
          return `Number input: ${input * 2}`;
      }
  }
  console.log(processInput("hello")); // Output: String input: HELLO
  console.log(processInput(5)); // Output: Number input: 10
• TypeScript allows defining multiple signatures for a function using function overload signatures, but the implementation must handle all cases in a single body:

  function combine(a: string, b: string): string;
  function combine(a: number, b: number): number;
  function combine(a: string | number, b: string | number): string | number {
      if (typeof a === "string" && typeof b === "string") {
          return a + b;
      } else if (typeof a === "number" && typeof b === "number") {
          return a + b;
      }
      throw new Error("Invalid argument types");
  }
  console.log(combine("Hello, ", "World!")); // Output: Hello, World!
  console.log(combine(5, 10)); // Output: 15
  Here, the overload signatures define the allowed input/output combinations, but the implementation is a single function that uses type checking.

C#: Function (Method) Declarations and Features

C# functions, typically called methods, are more rigid and structured, as they are usually defined within classes or structs. C# emphasizes explicit typing, method overloading, and supports optional and variable-length parameters.

1. Method Declarations (Part of Classes or Structs)

Methods in C# are declared within classes or structs, with explicit return types (or void for no return). They are not standalone functions like in TypeScript.

• Example:

  public class Greeter
  {
      public string Greet(string name)
      {
          return $"Hello, {name}!";
      }
  }
   
  class Program
  {
      static void Main()
      {
          Greeter greeter = new Greeter();
          Console.WriteLine(greeter.Greet("Alice")); // Output: Hello, Alice!
      }
  }
  Methods must be part of a class or struct, and standalone functions are rare (only allowed as local functions within methods or in newer C# versions with top-level statements).

2. Method Overloading

C# supports method overloading, where multiple methods with the same name can exist in a class, provided they have different parameter lists (number or types).

• Example:

  public class Calculator
  {
      public int Add(int a, int b)
      {
          return a + b;
      }
   
      public double Add(double a, double b)
      {
          return a + b;
      }
   
      public int Add(int a, int b, int c)
      {
          return a + b + c;
      }
  }
   
  class Program
  {
      static void Main()
      {
          Calculator calc = new Calculator();
          Console.WriteLine(calc.Add(2, 3)); // Output: 5
          Console.WriteLine(calc.Add(2.5, 3.5)); // Output: 6.0
          Console.WriteLine(calc.Add(1, 2, 3)); // Output: 6
      }
  }
  The compiler resolves which method to call based on the argument types and count.

3. Optional Parameters with Default Values

C# allows optional parameters by specifying default values, but they must appear after required parameters.

• Example:

  public class Person
  {
      public string Describe(string name, int age = 0)
      {
          return age > 0 ? $"{name} is {age} years old" : $"{name} has no age provided";
      }
  }
   
  class Program
  {
      static void Main()
      {
          Person person = new Person();
          Console.WriteLine(person.Describe("Alice")); // Output: Alice has no age provided
          Console.WriteLine(person.Describe("Bob", 30)); // Output: Bob is 30 years old
      }
  }

4. Variable-Length Arguments with params

C# uses the params keyword to allow a variable number of arguments, passed as an array.

• Example:

  public class MathOperations
  {
      public int Sum(params int[] numbers)
      {
          return numbers.Sum();
      }
  }
   
  class Program
  {
      static void Main()
      {
          MathOperations math = new MathOperations();
          Console.WriteLine(math.Sum(1, 2, 3)); // Output: 6
          Console.WriteLine(math.Sum(10)); // Output: 10
          Console.WriteLine(math.Sum()); // Output: 0
      }
  }
  The params array can be empty, and only one params parameter is allowed, at the end of the parameter list.

Key Differences Summarized with Examples

1. Declaration Flexibility:

   • TypeScript: Offers multiple function declaration styles (function, arrow functions, object/class methods), suitable for JavaScript’s dynamic nature.

     const arrowFn = (x: number) => x * 2;
     function regularFn(x: number) { return x * 2; }
     class MyClass { method(x: number) { return x * 2; } }
   • C#: Methods are tied to classes/structs, with a more rigid structure.

     public class MyClass
     {
         public int Method(int x) { return x * 2; }
     }

2. Optional Parameters:

   • TypeScript: Uses ? for optional parameters, which can be undefined if omitted.

     function fn(name: string, age?: number) {
         return age ? `${name}, ${age}` : name;
     }
   • C#: Uses default values for optional parameters, which are used if omitted.

     public string Fn(string name, int age = 0)
     {
         return age > 0 ? $"{name}, {age}" : name;
     }

3. Variable-Length Parameters:

   • TypeScript: Uses ...rest parameters, which collect arguments into an array.

     function fn(...args: number[]) {
         return args.reduce((a, b) => a + b, 0);
     }
   • C#: Uses params keyword, similar but part of the .NET type system.

     public int Fn(params int[] args)
     {
         return args.Sum();
     }

4. Overloading vs. Union Types:

   • TypeScript: No true overloading; uses union types or overload signatures to handle different types.

     function fn(input: string | number): string {
         return typeof input === "string" ? input : input.toString();
     }
   • C#: Supports true method overloading with distinct signatures.

     public class MyClass
     {
         public string Fn(string input) { return input; }
         public string Fn(int input) { return input.ToString(); }
     }

5. Context:

   • TypeScript: Functions often operate in a JavaScript runtime (browser/Node.js), with loose coupling to objects.
   • C#: Methods are tightly coupled to classes/structs, reflecting .NET’s object-oriented design.

TypeScript vs C# Function Differences