Tham số (Parameter) là gì? Giải thích đầy đủ & Ví dụ [2025]

Tham số (parameter) là một khái niệm nền tảng, không thể thiếu để viết code linh hoạt và hiệu quả trong mọi ngôn ngữ lập trình. Bài viết này sẽ dẫn dắt bạn tìm hiểu từ A-Z về chủ đề này: từ định nghĩa cốt lõi, lý do cần thiết, sự khác biệt mấu chốt với đối số (argument), cách ứng dụng thực tế qua ví dụ code đa dạng, đến các loại phổ biến, phạm vi biến và câu hỏi thường gặp.

Tham số (Parameter) là gì?

Tham số (parameter) trong lập trình là một biến đặc biệt, được định nghĩa trong phần khai báo của một hàm (function) hoặc phương thức (method). Nó hoạt động như một tên giữ chỗ (placeholder) hay một “cổng nhận dữ liệu” cho các giá trị sẽ được cung cấp từ bên ngoài khi hàm hoặc phương thức đó được gọi thực thi sau này.

Bạn có thể xem tham số như một thành phần trong “bản thiết kế” của hàm. Nó quy định loại thông tin mà hàm cần nhận để có thể hoạt động. Tên của tham số giúp chúng ta hiểu rõ hơn về mục đích của dữ liệu đầu vào đó trong logic xử lý của hàm.

Mục đích chính của việc sử dụng tham số là để tăng tính linh hoạt và khả năng tái sử dụng mã nguồn. Thay vì phải viết lại một hàm nhiều lần cho các dữ liệu đầu vào khác nhau, bạn có thể dùng cùng một hàm và truyền các giá trị khác nhau thông qua tham số của nó, giúp code ngắn gọn và dễ bảo trì hơn.

Hãy hình dung hàm như một công thức làm bánh mà bạn tìm thấy trong sách dạy nấu ăn. Tham số giống như danh sách các nguyên liệu (ví dụ: luong_bot, so_luong_trung, luong_duong) được liệt kê trong phần chuẩn bị của công thức đó. Chúng cho bạn biết cần chuẩn bị những gì.

Khi bạn thực sự bắt tay vào làm bánh (tức là gọi hàm), bạn sẽ cung cấp các nguyên liệu thực tế (ví dụ: 500g bột, 3 quả trứng, 100g đường). Những giá trị cụ thể này chính là đối số (argument), sẽ được “đổ” vào các “khuôn” tương ứng là tham số đã định nghĩa trong công thức.

Trong mã nguồn (source code), bạn sẽ thấy các tham số được liệt kê bên trong cặp dấu ngoặc đơn () ngay sau tên của hàm hoặc phương thức. Ví dụ, trong def greet(user_name):, thì user_name chính là tham số của hàm greet. Mỗi tham số thường có một tên và đôi khi đi kèm kiểu dữ liệu nó dự kiến nhận.

Về bản chất, tham số hoạt động như những biến cục bộ (local variable) bên trong hàm hoặc phương thức. Chúng chỉ tồn tại và có thể truy cập được trong phạm vi (scope) của hàm/phương thức đó. Chúng nhận giá trị từ bên ngoài thông qua các đối số được truyền vào khi hàm được gọi, làm cầu nối giữa thế giới bên ngoài và logic xử lý bên trong hàm.

Tại sao cần sử dụng Tham số trong lập trình?

Bạn có thể thắc mắc, tại sao không viết thẳng giá trị vào trong hàm mà cần đến tham số làm gì? Tham số mang lại những lợi ích vô cùng to lớn, là nền tảng cho việc viết code hiệu quả và chuyên nghiệp.

Lợi ích rõ ràng nhất là tăng tính linh hoạt. Một hàm được viết với tham số có thể xử lý nhiều loại dữ liệu đầu vào khác nhau. Ví dụ, thay vì viết hàm tinh_tong_2_va_3() và tinh_tong_5_va_7(), bạn chỉ cần viết một hàm tinh_tong(so_a, so_b) nhận hai tham số.

Khi cần tính tổng của hai số bất kỳ, bạn chỉ việc gọi hàm tinh_tong và truyền giá trị cụ thể (đối số) vào, ví dụ tinh_tong(2, 3) hoặc tinh_tong(5, 7). Hàm của bạn trở nên đa dụng hơn rất nhiều.

Điều này dẫn trực tiếp đến lợi ích thứ hai: tăng khả năng tái sử dụng code (code reusability). Bạn chỉ cần viết logic tính tổng một lần duy nhất trong hàm tinh_tong. Bất cứ khi nào cần thực hiện phép cộng, bạn gọi lại hàm này thay vì sao chép và dán (copy-paste) đoạn mã tính tổng nhiều lần.

Việc tái sử dụng code giúp chương trình ngắn gọn hơn, giảm thiểu lỗi (vì chỉ sửa logic ở một nơi nếu cần) và tiết kiệm thời gian phát triển đáng kể. Đây là một nguyên tắc cực kỳ quan trọng trong kỹ thuật phần mềm.

Hãy tưởng tượng bạn cần tính diện tích hình chữ nhật. Nếu không dùng tham số, bạn có thể phải viết các hàm như:

Python

# Cách làm tệ: Không dùng tham số
def tinh_dien_tich_5x10():
  return 5 * 10

def tinh_dien_tich_7x3():
  return 7 * 3

# ... và rất nhiều hàm khác cho mỗi kích thước

Cách làm này rất tệ vì lặp đi lặp lại logic dài * rộng.

Thay vào đó, với tham số, bạn chỉ cần:

Python

# Cách làm tốt: Dùng tham số
def tinh_dien_tich(chieu_dai, chieu_rong): # chieu_dai, chieu_rong là tham số
  return chieu_dai * chieu_rong

# Gọi hàm với các đối số khác nhau
dt1 = tinh_dien_tich(5, 10) # 5, 10 là đối số
dt2 = tinh_dien_tich(7, 3)  # 7, 3 là đối số
print(dt1) # Output: 50
print(dt2) # Output: 21

Rõ ràng cách dùng tham số hiệu quả hơn hẳn!

Cuối cùng, tham số hỗ trợ module hóa chương trình (modularity). Chúng giúp đóng gói một phần logic cụ thể vào trong một hàm, và hàm này giao tiếp với phần còn lại của chương trình thông qua các tham số (đầu vào) và giá trị trả về (đầu ra). Điều này làm cho cấu trúc chương trình rõ ràng, dễ quản lý và dễ gỡ lỗi hơn.

Phân biệt rõ ràng: Tham số (Parameter) vs Đối số (Argument)

Đây là điểm gây nhầm lẫn phổ biến nhất cho người mới học lập trình. Dù thường được sử dụng thay thế nhau trong giao tiếp thông thường, tham số (parameter) và đối số (argument) có ý nghĩa kỹ thuật khác biệt rõ ràng. Việc hiểu rõ sự khác biệt này là rất quan trọng.

Tham số (Parameter):

• Là biến được liệt kê bên trong dấu ngoặc đơn () trong phần khai báo (definition) của hàm hoặc phương thức.
• Nó giống như một chỗ giữ chỗ (placeholder) hoặc một cái tên đại diện cho giá trị sẽ được nhận vào.
• Nó thuộc về “thiết kế” của hàm, quy định loại dữ liệu hàm cần.
• Ví dụ: Trong def tinh_tong(so_hang_1, so_hang_2):, thì so_hang_1 và so_hang_2 là các tham số.

Đối số (Argument):

• Là giá trị thực tế được truyền vào cho các tham số tương ứng khi hàm hoặc phương thức được gọi (called/invoked).
• Nó là dữ liệu cụ thể mà hàm sẽ sử dụng để thực hiện công việc của mình.
• Nó thuộc về “thực thi” của hàm.
• Ví dụ: Khi bạn gọi ket_qua = tinh_tong(5, 10), thì 5 và 10 là các đối số.

Để dễ hình dung hơn, hãy xem xét ví dụ hàm xin_chao trong Python:

Python

# Khai báo hàm với một tham số tên là 'ten_nguoi_dung'
def xin_chao(ten_nguoi_dung): # ten_nguoi_dung là PARAMETER
  """Hàm này in lời chào đến người dùng."""
  print(f"Xin chào, {ten_nguoi_dung}! Chúc bạn một ngày tốt lành.")

# Gọi hàm lần 1
xin_chao("An") # "An" là ARGUMENT được truyền vào cho parameter ten_nguoi_dung

# Gọi hàm lần 2
ten_cua_ban = "Bình"
xin_chao(ten_cua_ban) # Biến ten_cua_ban chứa giá trị "Bình"
                     # Giá trị "Bình" là ARGUMENT được truyền vào

Trong ví dụ trên:

• ten_nguoi_dung trong dòng def xin_chao(ten_nguoi_dung): là tham số. Nó là tên biến được định nghĩa trong hàm.
• Chuỗi "An" trong dòng xin_chao("An") là đối số. Đây là giá trị cụ thể được truyền vào khi gọi hàm.
• Giá trị "Bình" (lấy từ biến ten_cua_ban) trong dòng xin_chao(ten_cua_ban) cũng là đối số.

Khi hàm xin_chao("An") được gọi, giá trị "An" (đối số) sẽ được gán cho biến ten_nguoi_dung (tham số) bên trong hàm. Sau đó, hàm sẽ thực thi lệnh print với giá trị này.

Hiểu rõ sự khác biệt này giúp bạn đọc hiểu code dễ dàng hơn và tránh các lỗi liên quan đến việc truyền sai hoặc thiếu đối số khi gọi hàm.

Đặc điểm	Tham số (Parameter)	Đối số (Argument)
Xuất hiện ở	Khai báo hàm/phương thức (Definition)	Lời gọi hàm/phương thức (Call)
Bản chất là	Biến (Variable)	Giá trị (Value)
Vai trò	Tên giữ chỗ, quy định đầu vào	Dữ liệu thực tế được truyền vào
Ví dụ (Code)	def func(param):	func(arg)

Cách khai báo và sử dụng Tham số trong thực tế (Ví dụ Code)

Cú pháp khai báo tham số có thể hơi khác nhau giữa các ngôn ngữ lập trình, nhưng nguyên tắc chung là liệt kê tên các tham số bên trong cặp dấu ngoặc đơn () sau tên hàm/phương thức. Các tham số thường được phân tách bằng dấu phẩy ,.

Ví dụ cú pháp cơ bản:

Python

# Python
def ten_ham(tham_so_1, tham_so_2):
  # Thân hàm xử lý logic
  pass # Lệnh giữ chỗ, không làm gì cả

# JavaScript
function tenHam(thamSo1, thamSo2) {
  // Thân hàm xử lý logic
}

# Java
public returnType tenHam(DataType thamSo1, DataType thamSo2) {
  // Thân hàm xử lý logic
}

Trong nhiều ngôn ngữ (như Java, C++), bạn cần chỉ định rõ kiểu dữ liệu (Data Type) cho từng tham số. Trong các ngôn ngữ như Python, JavaScript, việc này thường không bắt buộc khi khai báo, nhưng rất hữu ích cho việc đọc hiểu và kiểm tra lỗi sau này.

Dưới đây là một số cách sử dụng tham số phổ biến qua ví dụ cụ thể, chủ yếu dùng Python và JavaScript cho dễ hiểu với người mới.

Ví dụ với Tham số vị trí (Positional Parameters)

Đây là loại tham số cơ bản và phổ biến nhất. Khi bạn gọi hàm, các đối số bạn truyền vào sẽ được gán cho các tham số tương ứng dựa trên vị trí của chúng. Đối số đầu tiên gán cho tham số đầu tiên, đối số thứ hai cho tham số thứ hai, và cứ thế tiếp tục.

Python

# Python
def mo_ta_thu_cung(loai_thu_cung, ten_thu_cung):
  """Hàm mô tả thông tin thú cưng."""
  print(f"Tôi có một con {loai_thu_cung}.")
  print(f"Tên của nó là {ten_thu_cung}.")

# Gọi hàm với đối số vị trí
mo_ta_thu_cung("mèo", "Luna")
# Output:
# Tôi có một con mèo.
# Tên của nó là Luna.

# Nếu đổi vị trí đối số, kết quả sẽ sai logic
mo_ta_thu_cung("Max", "chó")
# Output:
# Tôi có một con Max. <--- Sai logic
# Tên của nó là chó.  <--- Sai logic

Như bạn thấy, thứ tự truyền đối số (“mèo”, “Luna”) rất quan trọng. Nó phải khớp với thứ tự khai báo tham số (loai_thu_cung, ten_thu_cung).

Ví dụ với Tham số mặc định (Default Parameters)

Đôi khi, bạn muốn một tham số có sẵn một giá trị mặc định nếu người dùng không cung cấp đối số tương ứng khi gọi hàm. Điều này làm cho hàm linh hoạt hơn. Bạn khai báo giá trị mặc định bằng cách dùng dấu = ngay sau tên tham số.

Python

# Python
def tinh_luy_thua(co_so, so_mu=2): # so_mu có giá trị mặc định là 2
  """Tính lũy thừa của cơ số với số mũ cho trước."""
  ket_qua = co_so ** so_mu
  print(f"{co_so} lũy thừa {so_mu} là {ket_qua}")

# Gọi hàm, không cung cấp đối số cho so_mu => dùng giá trị mặc định 2
tinh_luy_thua(5)
# Output: 5 lũy thừa 2 là 25

# Gọi hàm, cung cấp đối số cho so_mu => ghi đè giá trị mặc định
tinh_luy_thua(3, 3)
# Output: 3 lũy thừa 3 là 27

JavaScript

// JavaScript (ES6+)
function chaoHoi(ten, loiChao = "Xin chào") { // loiChao có giá trị mặc định
  console.log(`${loiChao}, ${ten}!`);
}

chaoHoi("Lan"); // Output: Xin chào, Lan!
chaoHoi("Tú", "Chào buổi sáng"); // Output: Chào buổi sáng, Tú!

Tham số mặc định rất hữu ích khi bạn muốn cung cấp các tùy chọn cấu hình hoặc các giá trị phổ biến mà người dùng không nhất thiết phải chỉ định mỗi lần gọi hàm. Lưu ý: Các tham số có giá trị mặc định thường phải được đặt sau các tham số không có giá trị mặc định trong danh sách tham số (quy tắc này áp dụng cho Python và nhiều ngôn ngữ khác).

Ví dụ với Tham số từ khóa (Keyword Parameters)

Trong một số ngôn ngữ như Python, bạn có thể truyền đối số bằng cách chỉ định rõ tên tham số mà bạn muốn gán giá trị cho nó, sử dụng cú pháp ten_tham_so=gia_tri. Ưu điểm lớn của cách này là thứ tự truyền đối số không còn quan trọng nữa, và code trở nên dễ đọc hơn, đặc biệt với các hàm có nhiều tham số.

Python

# Python - Sử dụng lại hàm mo_ta_thu_cung
def mo_ta_thu_cung(loai_thu_cung, ten_thu_cung):
  """Hàm mô tả thông tin thú cưng."""
  print(f"Tôi có một con {loai_thu_cung}.")
  print(f"Tên của nó là {ten_thu_cung}.")

# Gọi hàm sử dụng đối số từ khóa
mo_ta_thu_cung(ten_thu_cung="Goldie", loai_thu_cung="cá vàng")
# Output:
# Tôi có một con cá vàng.
# Tên của nó là Goldie.

# Thứ tự không quan trọng khi dùng từ khóa
mo_ta_thu_cung(loai_thu_cung="chó", ten_thu_cung="Max")
# Output:
# Tôi có một con chó.
# Tên của nó là Max.

Khi sử dụng đối số từ khóa, bạn chỉ cần nhớ tên tham số thay vì vị trí chính xác của nó. Bạn cũng có thể kết hợp đối số vị trí và đối số từ khóa (thường thì đối số vị trí phải đứng trước). Đây là một tính năng mạnh mẽ giúp code Python trở nên linh hoạt và dễ đọc.

Các loại Tham số thường gặp trong lập trình

Dựa trên cách chúng được định nghĩa và sử dụng, có thể phân loại tham số thành một số loại chính:

1. Tham số vị trí (Positional Parameters): Như đã giải thích, giá trị được gán dựa trên thứ tự. Đây là loại phổ biến nhất.
2. Tham số mặc định (Default Parameters): Có giá trị được định sẵn nếu không có đối số nào được cung cấp khi gọi hàm.
3. Tham số từ khóa (Keyword Parameters): (Chủ yếu trong Python) Cho phép truyền đối số bằng cách chỉ định tên tham số, không phụ thuộc vào vị trí.
4. (Nâng cao) Tham số tùy chọn/biến đổi (Variable-length Parameters): Cho phép hàm nhận một số lượng đối số không xác định trước.
   • Trong Python: *args (nhận các đối số vị trí dư thừa thành một tuple) và **kwargs (nhận các đối số từ khóa dư thừa thành một dictionary).
   • Trong JavaScript: Đối tượng arguments (cũ) hoặc sử dụng rest parameter ...tenBien (ES6+).
   • Ví dụ Python:Python

     def tinh_tong_nhieu_so(*args): # args là một tuple chứa các đối số vị trí
       tong = 0
       for so in args:
         tong += so
       return tong
     
     print(tinh_tong_nhieu_so(1, 2, 3)) # Output: 6
     print(tinh_tong_nhieu_so(5, 10, 15, 20)) # Output: 50
     

Việc hiểu các loại tham số này giúp bạn đọc hiểu tài liệu (documentation) của các thư viện, framework và viết các hàm linh hoạt hơn.

Mối liên hệ giữa Tham số và Phạm vi biến (Variable Scope)

Một điểm quan trọng cần nắm vững là phạm vi (scope) của tham số. Khi một hàm được gọi và các đối số được truyền vào, các biến tham số tương ứng sẽ được tạo ra bên trong hàm đó. Chúng được coi là biến cục bộ (local variables) của hàm.

Điều này có nghĩa là:

• Tham số chỉ tồn tại và có thể được truy cập bên trong thân hàm (khối lệnh của hàm) mà nó được định nghĩa.
• Khi hàm kết thúc thực thi, các biến tham số này sẽ bị hủy và giải phóng khỏi bộ nhớ.
• Mã nguồn bên ngoài hàm không thể truy cập trực tiếp vào các biến tham số của hàm đó.

Hãy xem ví dụ:

Python

def cong_hai_so(a, b): # a và b là tham số (biến cục bộ)
  ket_qua_cuc_bo = a + b
  print(f"Bên trong hàm: a={a}, b={b}, kết quả={ket_qua_cuc_bo}")
  return ket_qua_cuc_bo

so_1 = 5
so_2 = 10
tong = cong_hai_so(so_1, so_2) # Gọi hàm

print(f"Bên ngoài hàm: so_1={so_1}, so_2={so_2}, tổng={tong}")

# Thử truy cập biến tham số 'a' hoặc 'ket_qua_cuc_bo' từ bên ngoài => Gây lỗi!
# print(a) # NameError: name 'a' is not defined
# print(ket_qua_cuc_bo) # NameError: name 'ket_qua_cuc_bo' is not defined

Ví dụ trên cho thấy a, b và ket_qua_cuc_bo chỉ tồn tại trong hàm cong_hai_so. Bên ngoài hàm, chúng không được định nghĩa. Ngược lại, các biến so_1, so_2, tong được định nghĩa bên ngoài và có thể được sử dụng để truyền giá trị (dưới dạng đối số) vào hàm.

Hiểu về phạm vi cục bộ của tham số giúp tránh xung đột tên biến và quản lý trạng thái chương trình hiệu quả hơn.

Lưu ý quan trọng khi làm việc với Tham số

Sử dụng tham số đúng cách giúp code của bạn sạch sẽ, dễ hiểu và dễ bảo trì hơn. Dưới đây là một vài lời khuyên và thực hành tốt (best practices):

1. Đặt tên tham số rõ ràng, gợi ý: Tên tham số nên mô tả rõ ràng mục đích hoặc ý nghĩa của dữ liệu mà nó đại diện. Tránh các tên mơ hồ như x, y, data nếu có thể. Ví dụ: user_name, item_price, max_retries tốt hơn nhiều so với un, ip, mr. Tuân thủ quy ước đặt tên của ngôn ngữ (snake_case cho Python, camelCase cho JavaScript).
2. Tránh quá nhiều tham số: Một hàm có quá nhiều tham số (thường > 4 hoặc 5) có thể là dấu hiệu cho thấy hàm đó đang làm quá nhiều việc hoặc thiết kế chưa tối ưu. Nó cũng làm cho việc gọi hàm trở nên phức tạp. Cân nhắc nhóm các tham số liên quan vào một đối tượng (object), dictionary, hoặc struct và truyền đối tượng đó như một tham số duy nhất.
3. Kiểm tra tính hợp lệ của đối số (Argument Validation): Đặc biệt khi dữ liệu đầu vào đến từ người dùng hoặc nguồn không đáng tin cậy, bạn nên kiểm tra các đối số được truyền vào bên trong hàm. Kiểm tra xem chúng có đúng kiểu dữ liệu mong đợi không, có nằm trong phạm vi giá trị hợp lệ không, v.v. Điều này giúp hàm hoạt động ổn định và tránh các lỗi không mong muốn.
4. Sử dụng tham số mặc định một cách hợp lý: Tham số mặc định rất tiện lợi, nhưng hãy đảm bảo giá trị mặc định là giá trị phổ biến nhất hoặc an toàn nhất. Đừng lạm dụng chúng cho mọi tham số.
5. Hiểu rõ cơ chế truyền tham số (Pass by Value vs Pass by Reference): Cách đối số được truyền vào tham số (truyền giá trị hay truyền tham chiếu) khác nhau giữa các ngôn ngữ và kiểu dữ liệu. Hiểu rõ điều này rất quan trọng để tránh các hiệu ứng phụ không mong muốn, đặc biệt khi làm việc với các đối tượng có thể thay đổi (mutable objects) như list trong Python hay object trong JavaScript. (Chủ đề này phức tạp hơn và thường được đề cập trong các bài viết chuyên sâu hơn).

Việc áp dụng những lưu ý này sẽ giúp bạn viết code không chỉ chạy đúng mà còn chuyên nghiệp và dễ dàng làm việc nhóm hơn.

Câu hỏi thường gặp về Tham số (FAQ)

Dưới đây là một số câu hỏi thường gặp mà người mới bắt đầu hay thắc mắc về tham số:

1. Tham số và đối số khác nhau thế nào? (Tóm tắt)

• Tham số (Parameter) là biến được định nghĩa trong khai báo hàm, đóng vai trò như tên giữ chỗ.
• Đối số (Argument) là giá trị thực tế được truyền vào khi gọi hàm, cung cấp dữ liệu cho tham số.

2. Tham số có phải là biến không?

• Có. Tham số về cơ bản là một biến cục bộ (local variable) đặc biệt, chỉ tồn tại và hoạt động bên trong phạm vi của hàm hoặc phương thức mà nó được định nghĩa.

3. Một hàm có thể không có tham số không?

• Hoàn toàn có thể. Một hàm không có tham số thường thực hiện một công việc cố định hoặc lấy dữ liệu từ các nguồn khác (ví dụ: biến toàn cục, đọc file). Ví dụ:Python

  def in_loi_chao_co_dinh():
    print("Chào mừng bạn!")
  
  in_loi_chao_co_dinh() # Gọi hàm không cần đối số
  

4. Đặt tên tham số có quan trọng không?

• Rất quan trọng! Tên tham số rõ ràng, gợi nhớ giúp người đọc (bao gồm cả chính bạn trong tương lai) hiểu được mục đích của hàm và cách sử dụng nó mà không cần đọc kỹ phần logic bên trong. Đây là một phần quan trọng của việc viết code “sạch” (clean code).

5. Thứ tự tham số có quan trọng không?

• Có, đối với tham số vị trí. Thứ tự đối số truyền vào phải khớp với thứ tự tham số khai báo.
• Không quan trọng đối với tham số từ khóa (như trong Python) vì bạn chỉ định rõ tên tham số khi truyền giá trị.

---

Qua bài viết này, hy vọng bạn đã có cái nhìn rõ ràng và đầy đủ về tham số (parameter) là gì trong lập trình. Chúng không chỉ là những biến đơn thuần mà là công cụ thiết yếu giúp chúng ta xây dựng các hàm và phương thức linh hoạt, mạnh mẽ và có khả năng tái sử dụng cao.