Sử dụng $GLOBALS để xử lý biến toàn cục trong hàm PHP

PHP Tutorial | 05/07/2025 by Học PHP

Biến toàn cục là những biến được khai báo bên ngoài bất kỳ hàm nào, có vẻ như chúng có thể được truy cập ở mọi nơi. Tuy nhiên, khi bạn bắt đầu viết các hàm để tổ chức mã của mình, bạn sẽ nhanh chóng nhận ra một "quy tắc" quan trọng của PHP: các hàm mặc định không tự động nhìn thấy biến toàn cục. Các biến được định nghĩa bên trong một hàm chỉ có "phạm vi" (scope) cục bộ, nghĩa là chúng chỉ tồn tại và có thể được sử dụng bên trong chính hàm đó.

Vậy làm thế nào để một hàm có thể truy cập hoặc thậm chí thay đổi giá trị của một biến đã được khai báo ở phạm vi toàn cục? PHP cung cấp một giải pháp mạnh mẽ và linh hoạt dưới dạng $GLOBALS. Đây là một biến toàn cục đặc biệt (Superglobal) được tích hợp sẵn, đóng vai trò như một "cửa sổ" cho phép bạn nhìn thấy và thao tác với tất cả các biến toàn cục trong script của mình từ bất kỳ đâu, kể cả bên trong các hàm. Bài viết này sẽ đi sâu vào cách $GLOBALS hoạt động, cách bạn có thể sử dụng nó để truy cập và sửa đổi biến toàn cục bên trong hàm, đồng thời so sánh nó với từ khóa global để bạn có thể chọn phương pháp phù hợp nhất cho từng tình huống.

`$GLOBALS` Là Gì?

$GLOBALS là một trong những biến toàn cục đặc biệt (Superglobal) trong PHP. Nó là một công cụ mạnh mẽ cho phép bạn truy cập và thao tác với tất cả các biến toàn cục từ bất kỳ đâu trong script của bạn, kể cả bên trong các hàm hoặc phương thức của lớp, mà không cần sử dụng từ khóa global.

Định Nghĩa và Bản Chất

Là một Superglobal: Điều này có nghĩa là $GLOBALS luôn có sẵn trong mọi phạm vi (scope) của script PHP. Bạn không cần phải khai báo nó bằng từ khóa global bên trong một hàm để sử dụng.
Là một mảng kết hợp (associative array): $GLOBALS hoạt động giống như bất kỳ mảng kết hợp nào khác trong PHP. Mỗi phần tử trong mảng này tương ứng với một biến toàn cục trong script của bạn.

Mục Đích và Công Dụng Chính

Mục đích chính của $GLOBALS là cung cấp một cách thức tập trung để quản lý và truy cập tất cả các biến toàn cục hiện có. Nó hoạt động như một "danh mục" chứa tất cả các biến đã được khai báo ở phạm vi toàn cục.

Truy cập biến toàn cục từ mọi nơi: Dù bạn đang ở trong một hàm sâu bên trong cấu trúc mã, bạn vẫn có thể đọc hoặc sửa đổi giá trị của một biến toàn cục bằng cách tham chiếu đến nó qua $GLOBALS.
Thao tác với biến toàn cục động: Vì $GLOBALS là một mảng, bạn có thể duyệt qua nó, kiểm tra sự tồn tại của biến toàn cục bằng tên của chúng, hoặc thậm chí tạo mới/xóa biến toàn cục một cách động.
Được tự động điền: PHP tự động điền vào mảng $GLOBALS với bất kỳ biến nào được khai báo ở phạm vi toàn cục. Bạn không cần phải thêm chúng vào $GLOBALS một cách thủ công.

Cấu Trúc của `$GLOBALS`

Cấu trúc của $GLOBALS rất đơn giản: Khóa (key) của mảng $GLOBALS chính là tên của biến toàn cục (không có dấu $ ở phía trước), và giá trị (value) của phần tử đó là giá trị của biến toàn cục tương ứng.

Ví dụ về cấu trúc:

<?php
$globalMessage = "Hello World!";
$globalNumber = 123;

echo "<pre>";
print_r($GLOBALS); // In ra toàn bộ nội dung của mảng $GLOBALS
echo "</pre>";
/* Output sẽ bao gồm (và nhiều biến Superglobal khác):
Array
(
    ... (các Superglobal khác như _GET, _POST, _SERVER, v.v.)
    [globalMessage] => Hello World!
    [globalNumber] => 123
)
*/
?>

Truy cập biến thông qua $GLOBALS:

<?php
$app_name = "My Awesome App"; // Biến toàn cục
$version = "1.0";             // Biến toàn cục

function displayAppInfo() {
    // Truy cập biến toàn cục 'app_name' thông qua $GLOBALS
    echo "Ứng dụng: " . $GLOBALS['app_name'] . "<br>";

    // Truy cập biến toàn cục 'version' thông qua $GLOBALS
    echo "Phiên bản: " . $GLOBALS['version'] . "<br>";
}

displayAppInfo();
// Output:
// Ứng dụng: My Awesome App
// Phiên bản: 1.0
?>

Trong ví dụ trên, mặc dù $app_name và $version được khai báo bên ngoài hàm displayAppInfo(), chúng ta vẫn có thể truy cập chúng từ bên trong hàm bằng cách sử dụng $GLOBALS['app_name'] và $GLOBALS['version']. Điều này minh họa rõ ràng cách $GLOBALS hoạt động như một cổng để đến với các biến toàn cục.

Cách Sử Dụng `$GLOBALS` Trong Hàm PHP

$GLOBALS cung cấp một cách linh hoạt để tương tác với các biến toàn cục từ bên trong các hàm. Bạn có thể sử dụng nó để đọc giá trị của một biến toàn cục hoặc thậm chí thay đổi giá trị của nó.

Truy Cập Giá Trị Của Biến Toàn Cục

Khi bạn muốn đọc giá trị của một biến toàn cục từ bên trong một hàm, $GLOBALS là cách trực tiếp nhất. Bạn không cần bất kỳ từ khóa đặc biệt nào như global để khai báo biến đó bên trong hàm.

Cách thức: Đơn giản là truy cập vào mảng $GLOBALS bằng tên của biến toàn cục mà bạn muốn đọc, giống như bạn truy cập bất kỳ phần tử nào trong một mảng kết hợp.

Cú pháp: echo $GLOBALS['ten_bien_toan_cuc'];

Ví dụ code: Lấy giá trị của một biến toàn cục và in ra.

<?php
echo "<h3>1. Truy Cập Giá Trị Của Biến Toàn Cục</h3>";

$companyName = "Tech Solutions Inc."; // Biến toàn cục
$maxUsers = 1000;                     // Biến toàn cục

function displayCompanyInfo() {
    // Truy cập giá trị của $companyName thông qua $GLOBALS
    echo "Tên công ty: " . $GLOBALS['companyName'] . "<br>";

    // Truy cập giá trị của $maxUsers thông qua $GLOBALS
    echo "Số người dùng tối đa: " . $GLOBALS['maxUsers'] . "<br>";
}

displayCompanyInfo();
// Output:
// Tên công ty: Tech Solutions Inc.
// Số người dùng tối đa: 1000

echo "<hr>";

// Ví dụ khác: Truy cập thông tin từ $_SERVER (một Superglobal khác, cũng có trong $GLOBALS)
function displayServerIp() {
    if (isset($GLOBALS['SERVER']['SERVER_ADDR'])) {
        echo "Địa chỉ IP của Server: " . $GLOBALS['SERVER']['SERVER_ADDR'] . "<br>";
    } else {
        echo "Không thể lấy địa chỉ IP của Server.<br>";
    }
}
// displayServerIp(); // Bạn có thể chạy hàm này trên một môi trường web server để thấy kết quả
echo "Để thấy ví dụ displayServerIp hoạt động, hãy chạy trên Web Server (ví dụ: Apache, Nginx).<br>";
?>

Thay Đổi Giá Trị Của Biến Toàn Cục

Không chỉ đọc, bạn hoàn toàn có thể thay đổi giá trị của một biến toàn cục từ bên trong một hàm bằng cách sử dụng $GLOBALS. Khi bạn gán một giá trị mới cho phần tử tương ứng trong mảng $GLOBALS, biến toàn cục bên ngoài hàm cũng sẽ được cập nhật.

Cách thức: Gán giá trị mới trực tiếp vào phần tử trong mảng $GLOBALS mà bạn muốn sửa đổi.

Cú pháp: $GLOBALS['ten_bien_toan_cuc'] = $gia_tri_moi;

Ví dụ code: Thay đổi giá trị của biến toàn cục và kiểm tra bên ngoài hàm.

<?php
echo "<h3>2. Thay Đổi Giá Trị Của Biến Toàn Cục</h3>";

$currentTheme = "light-mode"; // Biến toàn cục ban đầu
$counter = 0;                 // Biến toàn cục ban đầu

echo "Giá trị ban đầu của \$currentTheme: " . $currentTheme . "<br>"; // Output: light-mode
echo "Giá trị ban đầu của \$counter: " . $counter . "<br><br>"; // Output: 0

function updateSettings() {
    // Thay đổi giá trị của $currentTheme thông qua $GLOBALS
    $GLOBALS['currentTheme'] = "dark-mode";
    echo "Trong hàm, \$currentTheme đã được đổi thành: " . $GLOBALS['currentTheme'] . "<br>";

    // Tăng giá trị của $counter thông qua $GLOBALS
    $GLOBALS['counter']++;
    echo "Trong hàm, \$counter đã được tăng lên: " . $GLOBALS['counter'] . "<br>";
}

updateSettings();
// Output:
// Trong hàm, $currentTheme đã được đổi thành: dark-mode
// Trong hàm, $counter đã được tăng lên: 1

echo "<br>";
// Kiểm tra giá trị của biến toàn cục sau khi hàm đã chạy
echo "Giá trị sau khi hàm đã chạy của \$currentTheme: " . $currentTheme . "<br>"; // Output: dark-mode
echo "Giá trị sau khi hàm đã chạy của \$counter: " . $counter . "<br>"; // Output: 1
?>

Như bạn thấy, việc thay đổi $GLOBALS['currentTheme'] và $GLOBALS['counter'] bên trong hàm updateSettings() đã trực tiếp ảnh hưởng đến giá trị của các biến toàn cục $currentTheme và $counter bên ngoài hàm. Điều này làm cho $GLOBALS trở thành một công cụ mạnh mẽ để quản lý trạng thái ứng dụng trên phạm vi toàn cục.

So Sánh `$GLOBALS` Với Từ Khóa `global` trong PHP

Trong PHP, cả $GLOBALS và từ khóa global đều cho phép bạn truy cập và thao tác với các biến toàn cục từ bên trong một hàm. Tuy nhiên, chúng có những khác biệt đáng kể về cách sử dụng, ưu và nhược điểm. Việc hiểu rõ sự khác biệt này sẽ giúp bạn chọn phương pháp phù hợp nhất cho từng tình huống.

Từ Khóa global

Từ khóa global được sử dụng để khai báo rằng một biến cục bộ bên trong hàm thực chất là tham chiếu đến một biến toàn cục đã tồn tại bên ngoài hàm.

Cách dùng: Bạn đặt từ khóa global theo sau là tên biến (có dấu $) bên trong hàm, trước khi sử dụng biến đó.

<?php
echo "<h3>1. Từ Khóa `global`</h3>";

$counter = 10; // Biến toàn cục

function incrementCounterGlobal() {
    global $counter; // Khai báo rằng $counter trong hàm này là biến toàn cục
    $counter++;      // Thao tác trực tiếp lên biến toàn cục
    echo "Trong hàm (global): \$counter = " . $counter . "<br>";
}

echo "Trước khi gọi hàm: \$counter = " . $counter . "<br>"; // Output: Trước khi gọi hàm: $counter = 10
incrementCounterGlobal();
echo "Sau khi gọi hàm: \$counter = " . $counter . "<br>"; // Output: Sau khi gọi hàm: $counter = 11
?>

Ưu điểm:

Ngắn gọn hơn: Đối với một hoặc hai biến, cú pháp global $variable; có vẻ ngắn gọn và trực tiếp hơn so với \$GLOBALS['variable'].
Trực quan hơn cho một số trường hợp: Với những người quen thuộc với các ngôn ngữ khác, cách khai báo global có thể cảm thấy quen thuộc hơn khi muốn "mang" một biến toàn cục vào phạm vi cục bộ.

Nhược điểm:

Chỉ có thể truy cập các biến đã được khai báo bằng global: Nếu bạn có nhiều biến toàn cục cần dùng, bạn sẽ phải lặp lại global $var1, $var2, ...; cho từng biến, điều này có thể gây lộn xộn.
Có thể khó theo dõi khi có nhiều biến global: Trong các hàm lớn hoặc dự án phức tạp, việc rải rác các khai báo global có thể khiến việc tìm kiếm và theo dõi các biến toàn cục trở nên khó khăn.
Có thể gây nhầm lẫn khi trùng tên với biến cục bộ: Nếu bạn vô tình khai báo một biến cục bộ cùng tên với một biến toàn cục mà không dùng global, PHP sẽ coi đó là hai biến riêng biệt, dẫn đến lỗi logic không mong muốn.

<?php
$value = "Toàn cục";

function testScope() {
    $value = "Cục bộ"; // Đây là biến cục bộ, không phải biến toàn cục $value
    echo "Trong hàm: " . $value . "<br>"; // Output: Trong hàm: Cục bộ
}

testScope();
echo "Ngoài hàm: " . $value . "<br>"; // Output: Ngoài hàm: Toàn cục
?>

`$GLOBALS`

$GLOBALS là một biến toàn cục đặc biệt (Superglobal) được PHP tự động tạo ra, hoạt động như một mảng kết hợp chứa tất cả các biến toàn cục đang có trong script.

Cách dùng: Bạn truy cập trực tiếp $GLOBALS như một mảng, sử dụng tên của biến toàn cục (dưới dạng chuỗi) làm khóa. Ví dụ: $GLOBALS['ten_bien'].

<?php
echo "<h3>2. `\$GLOBALS`</h3>";

$productName = "Laptop X"; // Biến toàn cục
$price = 1200;             // Biến toàn cục

function updateProductPrice() {
    // Thay đổi giá trị của $price thông qua $GLOBALS
    $GLOBALS['price'] += 50;
    echo "Trong hàm (\$GLOBALS): \$price = " . $GLOBALS['price'] . "<br>";
}

echo "Trước khi gọi hàm: \$productName = " . $productName . ", \$price = " . $price . "<br>"; // Output: Laptop X, $price = 1200
updateProductPrice();
echo "Sau khi gọi hàm: \$productName = " . $productName . ", \$price = " . $price . "<br>"; // Output: Laptop X, $price = 1250
?>

Ưu điểm:

Luôn có sẵn ở mọi phạm vi (là Superglobal): Bạn không cần bất kỳ khai báo nào để sử dụng $GLOBALS bên trong hàm, nó luôn có sẵn.
Cho phép duyệt qua tất cả các biến toàn cục như một mảng: Vì nó là một mảng, bạn có thể dùng các hàm mảng như foreach để duyệt qua hoặc kiểm tra sự tồn tại của các biến toàn cục một cách động. Điều này hữu ích trong các tình huống nâng cao.
Rõ ràng hơn về việc đang thao tác với biến toàn cục: Cú pháp $GLOBALS['variable'] trực tiếp chỉ ra rằng bạn đang truy cập vào một biến nằm trong không gian tên toàn cục, giúp code dễ hiểu hơn về mặt ngữ nghĩa.

Nhược điểm:

Cú pháp dài hơn một chút: So với global $variable;, việc gõ $GLOBALS['variable'] có thể tốn thêm vài ký tự.

Khi Nào Dùng Cái Nào?

Việc lựa chọn giữa global và $GLOBALS thường phụ thuộc vào ngữ cảnh và sở thích cá nhân, nhưng có một số hướng dẫn chung:

Sử dụng global khi:

Bạn chỉ cần truy cập hoặc thay đổi một vài biến toàn cục đã biết tên cụ thể.
Bạn muốn cú pháp ngắn gọn và trực quan hơn cho những trường hợp đơn giản.
Ví dụ: Hàm incrementCounterGlobal ở trên.

Sử dụng $GLOBALS khi:

Bạn muốn truy cập hoặc thao tác với tất cả các biến toàn cục (ví dụ: để debug hoặc kiểm tra động).
Bạn cần một cách rõ ràng và không thể nhầm lẫn để chỉ ra rằng bạn đang thao tác với biến toàn cục, tránh các vấn đề về phạm vi biến cục bộ trùng tên.
Bạn muốn xử lý các biến toàn cục một cách động, ví dụ, sử dụng tên biến được tạo ra từ một chuỗi.

<?php
echo "<h3>Khi Nào Dùng Cái Nào?</h3>";

$config_db_host = "localhost";
$config_db_user = "root";

function printConfigValue($key) {
    // Dùng $GLOBALS khi tên biến được truyền động
    if (isset($GLOBALS['config_' . $key])) {
        echo "Giá trị config cho '$key': " . $GLOBALS['config_' . $key] . "<br>";
    } else {
        echo "Không tìm thấy config cho '$key'.<br>";
    }
}

printConfigValue("db_host"); // Output: Giá trị config cho 'db_host': localhost
printConfigValue("db_user"); // Output: Giá trị config cho 'db_user': root
printConfigValue("db_pass"); // Output: Không tìm thấy config cho 'db_pass'.
?>

Lưu ý Khi Sử Dụng Biến Toàn Cục trong PHP

Mặc dù các biến toàn cục (và đặc biệt là Superglobals như $GLOBALS) cung cấp khả năng truy cập tiện lợi từ mọi nơi trong mã, việc lạm dụng chúng có thể dẫn đến những vấn đề nghiêm trọng về chất lượng mã và khả năng bảo trì.

Hạn Chế Sử Dụng Biến Toàn Cục

Đây là một nguyên tắc cơ bản trong lập trình hiện đại. Việc sử dụng biến toàn cục một cách bừa bãi có thể gây ra nhiều rắc rối:

Code khó hiểu và khó bảo trì (Spaghetti Code): Khi nhiều phần khác nhau của chương trình cùng đọc và ghi vào cùng một biến toàn cục, rất khó để theo dõi luồng dữ liệu. Bạn không thể dễ dàng biết được biến đó đang được sử dụng ở đâu, ai đã thay đổi nó, và khi nào nó bị thay đổi. Điều này dẫn đến mã nguồn trở nên lộn xộn, giống như "một đĩa mì spaghetti" với các sợi mã rối tung vào nhau.

Ví dụ minh họa:

<?php
$globalCounter = 0; // Biến toàn cục

function processA() {
    // Hàm A thay đổi $globalCounter
    $globalCounter += 5;
}

function processB() {
    // Hàm B cũng thay đổi $globalCounter
    $globalCounter *= 2;
}

function displayResult() {
    // Hàm C đọc $globalCounter
    echo "Kết quả cuối cùng: " . $globalCounter . "<br>";
}

processA(); // Global counter = 5
processB(); // Global counter = 10
displayResult(); // Output: 10 (Nếu bạn không biết thứ tự gọi hàm, rất khó để đoán)
// Nếu thay đổi thứ tự gọi:
$globalCounter = 0; // Reset
processB(); // Global counter = 0
processA(); // Global counter = 5
displayResult(); // Output: 5
// Rất dễ gây nhầm lẫn!
?>

Trong ví dụ trên, giá trị của $globalCounter phụ thuộc hoàn toàn vào thứ tự gọi các hàm và những gì chúng làm với biến toàn cục đó.

Tăng nguy cơ lỗi khi nhiều phần của chương trình cùng thay đổi một biến: Khi nhiều hàm hoặc mô-đun cùng truy cập và sửa đổi một biến toàn cục, rất dễ xảy ra các lỗi không mong muốn (side effects). Một thay đổi nhỏ ở một nơi có thể gây ra lỗi ở một nơi khác tưởng chừng không liên quan, khiến việc debug trở nên cực kỳ khó khăn.
Khó kiểm thử độc lập (Unit Testing): Để kiểm thử một hàm một cách độc lập (unit test), bạn cần đảm bảo rằng hàm đó nhận đầu vào rõ ràng và cho ra đầu ra dự đoán được. Khi hàm phụ thuộc vào biến toàn cục, việc thiết lập môi trường kiểm thử cho hàm trở nên phức tạp, vì bạn phải đảm bảo trạng thái của tất cả các biến toàn cục liên quan là chính xác trước mỗi lần kiểm thử. Điều này làm giảm khả năng kiểm thử tự động và độ tin cậy của mã.

Giải Pháp Thay Thế (Thường Tốt Hơn)

Thay vì phụ thuộc vào biến toàn cục, có những cách tiếp cận tốt hơn và "sạch sẽ" hơn để truyền và quản lý dữ liệu trong các hàm:

a. Truyền Đối Số Vào Hàm: Đây là cách sạch sẽ và được khuyến nghị nhất để cung cấp dữ liệu cho một hàm. Bằng cách truyền dữ liệu dưới dạng đối số, hàm sẽ chỉ hoạt động với dữ liệu được cung cấp rõ ràng cho nó, làm cho hàm độc lập và dễ kiểm soát hơn nhiều.

Ưu điểm: Rõ ràng về đầu vào của hàm, dễ kiểm thử, ít lỗi phụ thuộc.
Ví dụ code:

<?php
echo "<h4>a. Truyền Đối Số Vào Hàm</h4>";

$initialValue = 10; // Biến toàn cục

// Hàm chỉ nhận đầu vào qua đối số
function processValue($valueToAdd) {
    $localResult = 50 + $valueToAdd;
    return $localResult;
}

$result = processValue($initialValue); // Truyền giá trị của biến toàn cục vào hàm
echo "Kết quả của hàm: " . $result . "<br>"; // Output: Kết quả của hàm: 60
echo "Giá trị ban đầu (\$initialValue) không đổi: " . $initialValue . "<br>"; // Output: Giá trị ban đầu ($initialValue) không đổi: 10
?>

Trong ví dụ này, processValue không trực tiếp truy cập $initialValue mà nhận 10 như một đối số, đảm bảo tính độc lập.

b. Trả Về Giá Trị Từ Hàm: Nếu một hàm tạo ra một kết quả hoặc thay đổi dữ liệu, cách tốt nhất là để hàm trả về giá trị đó thay vì sửa đổi một biến toàn cục. Điều này giúp tách biệt trách nhiệm và làm cho luồng dữ liệu dễ theo dõi hơn.

Ưu điểm: Rõ ràng về đầu ra của hàm, hàm không có "tác dụng phụ" không mong muốn lên các biến khác.
Ví dụ code:

<?php
echo "<h4>b. Trả Về Giá Trị Từ Hàm</h4>";

$totalPrice = 100; // Biến toàn cục ban đầu

// Hàm tính thuế và trả về giá trị thuế
function calculateTax($price, $taxRate) {
    return $price * $taxRate;
}

$taxAmount = calculateTax($totalPrice, 0.1); // Hàm trả về giá trị
$finalPrice = $totalPrice + $taxAmount;

echo "Giá gốc: " . $totalPrice . "<br>"; // Output: Giá gốc: 100
echo "Thuế: " . $taxAmount . "<br>"; // Output: Thuế: 10
echo "Giá cuối cùng: " . $finalPrice . "<br>"; // Output: Giá cuối cùng: 110
?>

Ở đây, calculateTax không sửa đổi bất kỳ biến toàn cục nào mà chỉ trả về kết quả, sau đó kết quả này được sử dụng để tính finalPrice.

c. Sử Dụng Đối Tượng/Lớp (Lập Trình Hướng Đối Tượng - OOP): Đây là giải pháp mạnh mẽ nhất cho các ứng dụng phức tạp. Lập trình hướng đối tượng (Object-Oriented Programming - OOP) cho phép bạn gói gọn dữ liệu (thuộc tính/properties) và các hành vi (phương thức/methods) liên quan vào các đối tượng. Dữ liệu được lưu trữ trong các thuộc tính của đối tượng và được truy cập thông qua các phương thức của chính đối tượng đó.

Ưu điểm: Tổ chức mã tốt hơn, tăng khả năng tái sử dụng, dễ bảo trì, và giảm đáng kể sự phụ thuộc vào biến toàn cục. Dữ liệu được quản lý cục bộ trong từng đối tượng.
Ví dụ code:

<?php
echo "<h4>c. Sử Dụng Đối Tượng/Lớp (OOP)</h4>";

class Product {
    public $name;
    public $price;
    private $taxRate = 0.1; // Tỷ lệ thuế là thuộc tính riêng của lớp

    public function __construct($name, $price) {
        $this->name = $name;
        $this->price = $price;
    }

    public function getFinalPrice() {
        $tax = $this->price * $this->taxRate;
        return $this->price + $tax;
    }
}

$myProduct = new Product("Smartphone", 800); // Tạo một đối tượng sản phẩm
echo "Sản phẩm: " . $myProduct->name . "<br>";
echo "Giá gốc: " . $myProduct->price . "<br>";
echo "Giá cuối cùng (bao gồm thuế): " . $myProduct->getFinalPrice() . "<br>";
// Output:
// Sản phẩm: Smartphone
// Giá gốc: 800
// Giá cuối cùng (bao gồm thuế): 880
?>

Trong ví dụ OOP, name, price, và taxRate là thuộc tính của đối tượng $myProduct. Hàm getFinalPrice() truy cập dữ liệu này thông qua $this-> mà không cần đến bất kỳ biến toàn cục nào, tạo ra một giải pháp sạch sẽ và có cấu trúc.

Tóm lại, mặc dù $GLOBALS cung cấp một cách để tương tác với biến toàn cục, bạn nên cân nhắc kỹ lưỡng và ưu tiên các giải pháp thay thế như truyền đối số, trả về giá trị, hoặc sử dụng OOP để xây dựng các ứng dụng PHP mạnh mẽ, dễ bảo trì và có khả năng mở rộng.

Kết bài

Việc hiểu và sử dụng $GLOBALS là một khía cạnh quan trọng khi làm việc với các biến toàn cục trong PHP, đặc biệt là khi bạn cần truy cập hoặc thay đổi chúng từ bên trong các hàm. $GLOBALS cung cấp một cách tiếp cận mạnh mẽ và rõ ràng, hoạt động như một mảng kết hợp chứa tất cả các biến toàn cục đang hiện diện trong script của bạn. Điều này cho phép bạn đọc và gán giá trị mới cho biến toàn cục một cách trực tiếp thông qua tên của chúng làm khóa.

Chúng ta đã tìm hiểu:

Bản chất của $GLOBALS: Là một Superglobal luôn có sẵn, cho phép bạn truy cập mọi biến toàn cục mà không cần khai báo global.
Cách sử dụng cơ bản: Đọc giá trị bằng echo $GLOBALS['ten_bien']; và thay đổi giá trị bằng $GLOBALS['ten_bien'] = $gia_tri_moi;.
So sánh với từ khóa global: Phân tích ưu và nhược điểm của cả hai phương pháp, giúp bạn đưa ra lựa chọn phù hợp tùy thuộc vào độ phức tạp và yêu cầu về tính rõ ràng của mã.

Tuy nhiên, điều quan trọng nhất cần ghi nhớ là hạn chế việc lạm dụng biến toàn cục. Mặc dù tiện lợi, việc phụ thuộc quá nhiều vào chúng có thể dẫn đến mã khó hiểu (spaghetti code), khó bảo trì, và dễ gây lỗi do các tác dụng phụ không mong muốn.