String to Number Conversion in PHP: Methods, Principles and Practice

Basic Principles of PHP Type Conversion

As a dynamically typed language, PHP automatically performs type conversion in most cases, which is known as type juggling. When strings participate in mathematical operations, PHP automatically converts them to appropriate numeric types. For example, when the string '3.14' is added to the number 5, PHP automatically converts the string to a floating-point number for calculation.

Explicit Type Conversion Methods

Although PHP supports automatic type conversion, explicit conversion is more reliable in scenarios requiring precise type control. PHP provides multiple explicit conversion methods:

Type Casting Operators

Using (int) and (float) operators is the most direct type conversion approach:

$num = "3.14";
$int = (int)$num;    // Result: 3
$float = (float)$num; // Result: 3.14

This method is simple and efficient, but it's important to note that integer conversion directly truncates the decimal portion rather than rounding.

intval() and floatval() Functions

These functions are specifically designed to obtain integer and floating-point values of variables:

$myFloat = floatval('3.9'); // Result: 3.9
$myInt = intval('3.9');    // Result: 3

The intval() function supports specifying a base parameter, which is particularly useful when dealing with numeric strings in different bases:

echo intval("0x1a", 0); // Hexadecimal, result: 26
echo intval("057", 0);  // Octal, result: 47
echo intval("42", 0);   // Decimal, result: 42

settype() Function

The settype() function can directly modify a variable's type:

$pi = '3.14';
settype($pi, "float");
var_dump($pi); // Output: float(3.14)

This method directly modifies the original variable's type, suitable for scenarios where preserving the original string is not necessary.

Implicit Type Conversion

Implicit type conversion can be achieved through mathematical operations:

$num = "1000.314";
echo $num + 0;   // Output: 1000.314
echo $num + 0.0; // Output: 1000.314

PHP automatically converts strings participating in mathematical operations to numeric types, making this the most natural conversion approach.

Other Conversion Methods

filter_var() Function

The filter_var() function provides a safer approach to number conversion:

$string = "123.45";
$floatNumber = filter_var($string, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);
$intNumber = filter_var($string, FILTER_SANITIZE_NUMBER_INT);

sscanf Function

The sscanf function can parse strings according to specified formats:

$string = "12345.6789";
sscanf($string, "%f", $number);
echo $number; // Output: 12345.6789

Considerations and Best Practices

When converting strings to numbers, the following points should be considered:

Precision Issues

Floating-point operations may suffer from precision loss:

$n = "19.99";
print intval($n * 100);        // May output 1998
print intval(strval($n * 100)); // Outputs 1999

Input Validation

Do not rely solely on intval() for input validation:

// Unsafe validation approach
if(intval($_GET['id']) > 0){
    echo $id;
}

// Safe validation approach
if(is_numeric($_GET['id']) && intval($_GET['id']) > 0){
    echo $id;
}

Scientific Notation Handling

intval() parses scientific notation:

echo intval("123.e2-e"); // Outputs 12300
echo intval("123.e-22"); // Outputs 0

Performance Comparison

In terms of performance, type casting operators are typically the fastest, followed by mathematical operation implicit conversion, with function calls being relatively slower. However, in most application scenarios, this performance difference is negligible.

Conclusion

PHP provides multiple methods for converting strings to numbers, each with its applicable scenarios. Type casting operators are simple and efficient, intval() and floatval() functions are feature-rich, settype() function directly modifies variable types, and mathematical operation implicit conversion is the most natural. Developers should choose appropriate methods based on specific requirements and pay attention to handling precision issues and performing proper input validation.