array_slice() treats null offsets as 0, clamps out-of-bounds offsets to return empty arrays or full arrays, and handles null length as "to the end"; substr() casts null offsets to 0 but returns false on out-of-bounds or invalid offsets, requiring explicit checks. 1) null offset in array_slice() becomes 0; 2) offset beyond length returns empty array; 3) negative offset beyond start returns full array; 4) null offset in substr() becomes 0; 5) offset beyond string length returns false; 6) negative offset beyond start returns false; 7) null input string is treated as empty string; 8) always validate or cast substr() results to avoid false-related bugs. Developers must anticipate these edge cases to prevent logic errors.

When working with PHP’s array and string slicing functions—like array_slice() and substr()—developers often focus on typical use cases. But edge cases involving null values and out-of-bounds offsets can lead to subtle bugs if not properly understood. Let’s examine how PHP handles these scenarios in practice.

How array_slice() Handles Null and Invalid Offsets

The array_slice($array, $offset, $length = null) function extracts a portion of an array. Here's how it behaves under edge conditions:

• Null offset (null):
  PHP treats null as 0 when used as the offset. So:

  

  $arr = ['a', 'b', 'c'];
  print_r(array_slice($arr, null, 2));
  // Output: Array ( [0] => a [1] => b )

  This is equivalent to starting from the beginning.

• Negative null offset (null as negative):
  Doesn't apply—null is cast to 0, not -0. So no reverse indexing occurs.

  

• Offset beyond array length:
  Returns an empty array:

  array_slice(['a', 'b'], 10); // Returns: []

• Negative offset out of bounds:
  If the negative offset goes beyond the start, it returns the full array:

  array_slice(['a', 'b', 'c'], -10); // Returns: ['a','b','c']

  PHP clamps the offset to the valid range rather than throwing an error.

• Length null:
  This is the default and means “until the end.” No issues here—it's expected behavior.

? Key takeaway: array_slice() is forgiving. Invalid offsets don’t cause errors; they’re clamped or result in empty arrays.

How substr() Deals with Null and Out-of-Bounds

substr($string, $offset, $length = null) works similarly but with strings. Edge cases here can be trickier.

• Null offset:
  Like with arrays, null is cast to 0:

  substr("hello", null, 3); // Returns "hel"

• Offset greater than string length:
  Returns false:

  substr("hi", 5); // Returns false

  ?? This is a gotcha—returning false instead of an empty string can break logic if not checked.

• Negative offset beyond start:
  Returns false:

  substr("hi", -10); // Returns false

• Zero-length string input:
  Any offset (except 0 or -0) returns false. Offset 0 returns empty string:

  substr("", 0); // Returns ""
  substr("", 1); // Returns false

• Null as input string:
  null is cast to an empty string:

  substr(null, 0, 3); // Returns ""

  But if you pass null for offset or length, they are cast to integers (0), so:

  substr("test", null, null); // Returns "test" (from 0, length ignored = rest)

?? Watch out: substr() returns false on out-of-bounds, not "". Always cast or check:

$result = substr($str, $offset) ?: '';

Summary of Edge Behaviors

Best Practices to Avoid Bugs

To avoid surprises:

• Always validate offsets when they come from user input or calculations.
• Use null coalescing or casting when dealing with substr():

  $part = substr($str, $start, $len) ?: '';

• Pre-check array/string length if offsets are dynamic.
• Avoid relying on implicit casting of null—be explicit for readability.

Basically, PHP prioritizes "graceful failure" over strict errors in slicing functions. While this prevents fatal crashes, it shifts the responsibility to the developer to anticipate edge cases—especially the false returns from substr(). Know the rules, and you’ll slice safely.

The above is the detailed content of Edge Case Examination: How PHP Slicing Functions Handle Nulls and Out-of-Bounds Offsets. For more information, please follow other related articles on the PHP Chinese website!