PHP type conversion is flexible but cautious, and is prone to cause implicit bugs; 1. Extract the starting value when string is converted to numbers, and if there is no number, it is 0; 2. Floating point to integer truncation to zero, not rounded; 3. Only 0, 0.0, "", "0", null and empty arrays are false, and the rest such as "false" are also true; 4. Number to strings may be distorted due to floating point accuracy; 5. Empty array to Boolean to false, non-empty is true; 6. Array to string always is "Array", and no content is output; 7. Object to array retains public attributes, and private protected attributes are modified; 8. Array to object to generate stdClass instances; 9. Resources cannot be converted effectively, and the result is usually 0 or ""; 10. When converting objects to strings, you need to define the __toString() method; you should verify the input, use filter_var() and is_() functions to check the type, avoid implicit conversion, and ensure type safety.

PHP's type casting system is both flexible and forgiving — a double-edged sword that empowers rapid development but can also introduce subtle bugs if misunderstood. At the heart of this system are scalar and compound types, and how PHP behaves when converting between them. Let's break down the nuances of casting in PHP, focusing on practical implications and common pitfalls.

Understanding Scalar Type Casting

Scalar types in PHP include int , float , string , and bool . These are the simplest data types, and casting among them follow predictable but sometimes surprise rules.

Key Casting Behaviors

• String to Number :
  When casting a string to an integer or float, PHP extracts the leading numeric portion:

  

   (int)"123abc" // 123
  (float)"4.5xyz" // 4.5
  (int)"abc123" // 0 (no leading digits)

  This can lead to silent data loss if input isn't validated.

• Float to Int :
  PHP truncates toward zero, not rounds:

  

   (int)3.9 // 3
  (int)-3.9 // -3

  Use round() explicitly if rounding is intended.

• Booleans :
  Only 0 , 0.0 , "" , "0" , null , and empty arrays cast to false . Everything else — including "0.0" , "false" , and " " — is true :

   (bool)"false" // true — a common gotcha

• Numbers to String :
  Straightforward, but be cautious with precision:

   (string)0.1 0.2 // "0.300000000000000004" when converted, due to float imprecision

Compound Types: Arrays, Objects, and Resources

Compound types ( array , object , resource ) behave very differently during casting, and some conversions are lossy or context-dependent.

Array Casting Rules

• Array to Boolean :
  Empty array → false , otherwise true .

   (bool)[] // false
  (bool)[0] // true

• Array to String :
  Always results in the string "Array" , never the contents:

   echo (string)[1,2,3]; // Prints: Array

  This often causes confusion in concatenation:

   "Data: " . [1,2,3] // "Data: Array"

• Object to Array :
  Converts object properties to associate array keys:

   (array) new DateTime() // ['date' => ..., 'timezone' => ...]

  Public properties become keys; private/protected ones are mangled.

• Array to Object :
  Creates a generic stdClass with keys as property names:

   (object)['name' => 'John'] // ->name === 'John'

Objects and Resources

• Resource to Anything :
  Resources (like file handles) cannot be meaningfully cast. Attempting to cast to string or int usually results in 0 or "" , and may trigger warnings.

• Object to String :
  Only works if the class defines a __toString() method:

   (string)new DateTime(); // Works — has __toString()
  (string)new stdClass(); // Fatal error without __toString()

Practical Tips for Safer Casting

To avoid surprises, follow these guidelines:

• ? Validate input before casting — especially when dealing with user data.
• ? Use strict comparison ( === ) after casting to ensure expected types.
• ? Prefer filter_var() over raw casting for sanitization:

   filter_var($input, FILTER_VALIDATE_INT) // Returns int or false

• ? * Use `is_ ()` functions** to check types before casting:

   if (is_numeric($value)) { ... }

• ? Avoid relying on implicit casting in conditions or arithmetic.

Final Notes

PHP's casting is convenient but demands awareness. Scalar casts often “do something,” even when that something isn't what you expect. Compound types lose data or fail silently in unexpected ways. The key is to treat casting not as a magic fix, but as a deliberate operation — best paired with validation and type checking.

Basically: cast with care, verify with intent.

The above is the detailed content of Unraveling the Intricacies of PHP's Scalar and Compound Type Casting. For more information, please follow other related articles on the PHP Chinese website!