PHP exceptions ద్వారా errors ను try/catch/finally ఉపయోగించి నిర్వహిస్తుంది. సరైన exception handling అంటే నిర్దిష్ట types ను catch చేయడం, అర్థవంతమైన కస్టమ్ exceptions తయారు చేయడం, resources ని శుభ్రపరచడం, మరియు user లకు internal details లను ఎన్నటికీ బహిర్గతం చేయకపోవడం.
{
= ();
} ( ) {
(->());
} (DatabaseException ) {
();
} ( ) {
();
;
} {
();
}
నిర్దిష్ట exception types లను catch చేయండి (అత్యంత నిర్దిష్టమైనది ముందుగా), చివరి catch-all గా Throwable ను ఉపయోగించండి (both Error మరియు Exception లను కవర్ చేస్తుంది), మరియు finally ను ఎల్లప్పుడూ రన్ చేయాల్సిన cleanup కోసం ఉపయోగించండి.
// throwing
if ($amount < 0) {
throw new InvalidArgumentException("Amount must be positive, got $amount");
}
// a custom exception for your domain
class InsufficientFundsException extends Exception {
public function __construct(private float $shortfall) {
parent::__construct("Short by $shortfall");
}
public function getShortfall(): float { return $this->shortfall; }
}
throw new InsufficientFundsException(50.0);
కస్టమ్ exception classes error handling ను expressive చేస్తాయి మరియు callers ను నిర్దిష్ట domain errors ను catch చేయడానికి అనుమతిస్తాయి.
try {
$db->query(...);
} catch (PDOException $e) {
// wrap with context, preserving the original as the "previous" exception
throw new RepositoryException("Failed to load user", 0, $e);
}
మూడవ constructor argument original exception ($e->getPrevious()) ని chain చేస్తుంది, debugging కోసం full cause ని సంరక్షిస్తుంది.
✓ Catch SPECIFIC exceptions, not a blanket Throwable (unless intentionally last)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use finally / proper cleanup for resources (files, connections)
✓ Create meaningful custom exceptions for domain errors
✓ SECURITY: log details internally; show users a generic message (don't leak
stack traces / internal info — display_errors off in production)
సరైన exception handling robust, reliable, మరియు secure PHP applications తయారు చేయడానికి అవసరం.
try/catch/finally నిర్మాణాన్ని, నిర్దిష్ట exception types ను catch చేయడం (targeted handling కోసం) చేసి Throwable ను ఒక చివరి catch-all గా (modern PHP లో both Error మరియు Exception లను కవర్ చేస్తుంది), మరియు guaranteed cleanup కోసం finally ను ఉపయోగించడం అనేది ప్రాథమిక రోజువారీ జ్ఞానం.
మెకానిక్ల మించి, best practices ముఖ్యమైనవి: domain errors కోసం meaningful custom exceptions తయారు చేయడం code ను expressive చేస్తుంది మరియు callers ను నిర్దిష్ట failures ను హ్యాండిల్ చేయడానికి అనుమతిస్తుంది; exception chaining debugging కోసం root cause ను సంరక్షిస్తుంది; మరియు కీలకంగా, exceptions ను నిశ్శబ్దంగా సుగమం చేయకపోవడం (logging లేదా re-throwing బదులుగా) hidden failures ను నిరోధిస్తుంది.
ప్రత్యేకంగా ముఖ్యమైన విషయం security: exceptions మరియు errors అంతర్గతంగా logged చేయబడాలి కానీ users కు ఎప్పటికీ బహిర్గతం చేయకూడదు (stack traces మరియు internal details sensitive information లీక చేస్తాయి మరియు attackers కు సహాయం చేస్తాయి — అందువల్ల production లో display_errors off).
Exceptions ను సరిగ్గా నిర్వహించడం ఎలాగో తెలుసుకోవడం — specific catches, custom exceptions, cleanup, chaining, మరియు exposure కంటే secure logging — robust, professional PHP ను fragile code నుండి అలాగే distinguish చేస్తుంది అది ungracefully crash చేస్తుంది లేదా information లీక చేస్తుంది, reliable, secure applications తయారు చేయడానికి ఇది ముఖ్యమైన జ్ఞానం.