227 Php Developer Interview Questions & Answers

I normally use echo for direct output. Echo can output one or more comma separated expressions and does not return a value. Print accepts one expression and always returns the integer 1, so it can be used as part of another expression. Both are PHP language constructs, and performance or memory differences are normally not a useful reason to choose between them.

Both echo and print send a value to PHP output. They are often used to build a web page, show a command line message, or produce simple text. The main difference is how each construct fits into PHP code. Echo can output several separate expressions and gives no result back. Print handles one expression and gives back the number 1. Most applications can use either one for a single value, so the practical choice is usually based on clear code rather than speed or memory.

1. Does the example need to output several separate expressions?
2. Does the output operation need to be used inside another expression?

Echo and print are PHP language constructs used to produce output. They are not normal functions, so parentheses are not required and they cannot be called as variable functions or with named arguments.

Echo accepts one or more expressions separated by commas. It produces their string forms in order and does not add spaces or new lines. Echo has no return value, so it cannot be used where PHP requires an expression result.

Print accepts one expression. It produces that value and always returns the integer 1. Because it returns a value, print can be used inside an expression, such as a condition or a conditional expression. This is valid, but it is uncommon because a separate output statement is usually easier to read.

Parentheses do not turn either construct into a function. Echo can still output separately parenthesized expressions when commas remain outside the parentheses. However, echo followed by one pair of parentheses containing several comma separated values is invalid because that content is not one valid PHP expression.

Both constructs convert suitable values to strings even when strict types are enabled. For example, an integer becomes its text form. An array produces an Array conversion warning and the text Array, so var_dump or print_r is more suitable for inspecting an array. An object must support string conversion before it can be output directly.

There is normally no useful performance reason to prefer one construct. Memory use depends more on the expressions being created. For example, joining many values into one string can allocate a combined string, while separate echo arguments can avoid creating that combined result. In production, readability, correct escaping, buffering, and response handling matter more.

A common mistake is calling echo or print a normal function. Both are language constructs. Another mistake is saying that print returns the value it outputs. Print always returns the integer 1. Candidates may also claim that echo accepts only one expression, but it can accept several expressions separated by commas. Another mistake is believing that parentheses turn either construct into a function call. They do not. It is also incorrect to use echo directly as an expression because it has no return value. Finally, candidates should not claim that one construct always uses less memory or is meaningfully faster in every application.

Start with the practical choice. Say that echo is normally used for direct output. Then compare argument count, return value, and expression use. Mention that both are language constructs and finish by saying that readability matters more than tiny performance claims.

I use === by default when the type matters. The == operator performs loose comparison, so PHP may convert the operands before comparing them. For example, 0 == "0" is true. The === operator performs strict comparison, so both the value and type must match. Therefore, 0 === "0" is false. Strict comparison usually makes production code safer and easier to understand.

The practical rule is to use the stricter check when two values must have the same form as well as the same meaning. The other check may treat values from different sources as equal after changing how one value is understood during the comparison. This can be convenient, but it can also hide invalid input or a wrong assumption. In most application code, the stricter check is safer because it clearly separates values such as zero, false, null, and text. The less strict check should be used only when accepting different forms is an intentional requirement.

1. Can the compared values come from different sources, such as a form and a database?
2. Should values with different types be accepted as equal?
3. Must the code support PHP versions older than PHP 8?

In PHP, == is the loose equality operator. It checks whether two operands are equal after PHP applies its comparison conversion rules. This behavior is called type juggling. The original variables are not permanently changed by the comparison.

The === operator is the identity operator. It returns true only when both operands have the same type and the same value. PHP does not convert different types to make them match.

For example, 0 == "0" is true because PHP compares the numeric string with the integer as numeric values. However, 0 === "0" is false because one operand is an integer and the other is a string.

Boolean comparisons can also be surprising. false == "0" is true because PHP converts both operands to boolean for that loose comparison. false === "0" is false because their types differ.

A version boundary also matters. In PHP 8 and later, 0 == "hello" is false because a number compared with a nonnumeric string is compared as strings instead of converting the string to zero. Before PHP 8, that comparison was true.

For arrays, == checks whether both arrays contain the same key and value pairs, while === also requires the same order and matching value types. For objects, === means both operands refer to the same object instance.

Use === for identifiers, status values, validation results, authentication decisions, and function return values. Use == only when accepting equivalent values of different types is deliberate and tested.

Scalar comparisons normally have trivial time and memory cost. Comparing arrays or objects can require examining their contents, so the cost can grow with the amount of data. These operators do not copy or permanently change the operands.

The executable example compares the same values with == and ===. It shows numeric string conversion, boolean comparison behavior, and the PHP 8 and later rule for comparing zero with a nonnumeric string. The operands remain unchanged after every comparison.

A common mistake is assuming that == compares only the visible values. PHP may first apply comparison conversion rules. Another mistake is using == when false, null, zero, and an empty string must remain different. Developers may also assume that declare(strict_types=1) changes == into strict comparison, but it does not affect comparison operators. A further mistake is using in_array or array_search without strict mode when different value types must not match. Code must also avoid relying on loose comparison behavior from PHP versions before PHP 8.

Begin by saying that == may compare after type conversion, while === requires the same type and value. Give the example 0 == "0" being true and 0 === "0" being false. Then state that === is the safer default when predictable types matter.

Use isset() when the key must exist and its value must not be null. Use array_key_exists() when you only need to know whether the key is present, even when its value is null. Use empty() when missing keys and values such as null, false, zero, an empty string, the string "0", and an empty array should all count as empty. The main risk is that empty() can reject valid values such as zero or false.

These three checks answer different questions about an array value. One checks whether a named place exists and contains something other than null. One checks only whether the named place exists. The last checks whether the value should be treated as having no useful content. This difference matters because zero, false, and the text "0" may be valid information. Choosing the wrong check can reject valid input, overwrite saved data, or confuse a missing field with a field that was intentionally supplied with no value.

1. Should a stored null value count as present?
2. Are zero, false, and the string "0" valid values?
3. Must missing input be different from supplied empty input?

isset($array['key']) is a PHP language construct. It returns true only when the key exists and its value is not null. It returns false for both a missing key and a key whose value is null. Values such as false, 0, "", "0", and an empty array still make isset() return true because they are not null.

array_key_exists('key', $array) is a PHP array function. It checks only whether the key exists. It returns true even when the stored value is null. Use it when null has a real meaning or when an update operation must distinguish an omitted field from a field explicitly set to null. It checks only the given array level. It does not search nested arrays automatically.

empty($array['key']) is also a PHP language construct. It returns true when the key is missing or when the value converts to false. Relevant empty values include null, false, 0, 0.0, negative zero, "", "0", and an empty array. It can safely check a missing array key without producing an undefined key warning.

For example, a quantity of 0 and an enabled flag of false may be valid. Using empty() would treat both as empty. In that case, use array_key_exists() to confirm that the field was supplied, then validate its value separately. Use isset() instead when null should be treated the same as a missing value.

Each check performs a direct lookup for the requested key. It does not copy the array or its stored value. The result is a boolean, so the extra memory cost is negligible. In production code, choose the check based on the meaning of missing, null, and empty values rather than relying on truthiness by accident.

The example creates one PHP array containing null, false, zero, an empty string, the string "0", an empty array, and a normal string. It also checks a missing key. For each key, the program prints the results from isset(), empty(), and array_key_exists(). isset() returns false only for the missing key and the null value. empty() returns true for the missing key and every stored empty value. array_key_exists() returns true for every stored key, including the key containing null, and false only for the missing key.

A common mistake is using isset() when a key containing null must still count as present. Another mistake is using empty() for required numeric or boolean input. It treats 0, 0.0, false, the string "0", an empty string, null, and an empty array as empty, so valid data may be rejected. Developers may also assume that array_key_exists() searches every nested level, but it checks only the supplied array level. Another mistake is checking only whether a field is present and then skipping separate type and business rule validation.

State the decision rule first. Say that isset() means the key exists and the value is not null, array_key_exists() means the key exists even when its value is null, and empty() groups missing keys with values that convert to false. Then compare null, zero, false, and the string "0" because those examples show the practical difference clearly.

session_unset() clears all variables from the active session, but it does not end the session. session_destroy() deletes the stored data associated with the active session, but it does not clear the current $_SESSION array or remove the session cookie. For a complete logout, I clear $_SESSION, delete the session cookie when cookies are used, call session_destroy(), and stop further protected processing.

These two actions remove different parts of the information used to remember a signed in visitor. One removes the values available to the page that is running now. The other removes the saved record used by later pages. Neither action alone removes every trace of the old login. A complete logout should clear the current values, remove the small browser marker when it is used, delete the saved record, and stop the page from continuing as the signed in user. This order helps prevent old login information from being reused.

1. Does the application use the normal PHP session cookie?
2. Should logout remove every session value or only authentication values?
3. Does the application use a custom session storage handler?

session_unset() removes all variables registered in the active session. With normal modern PHP session code, this clears the values available through $_SESSION. The session identifier still exists, and the session remains active. New values can therefore be added to the same session during the current request.

session_destroy() deletes the stored data associated with the active session. The exact storage operation depends on the configured session handler. For example, the normal file handler removes the stored session record. However, session_destroy() does not clear the $_SESSION array that PHP already loaded into memory for the current request. It also does not remove the session cookie from the browser.

This difference is important during logout. Calling only session_unset() clears the variables but leaves the session active. Calling only session_destroy() deletes the stored record, but later code in the same request can still read values that remain in $_SESSION. The browser can also continue sending the old session identifier if its cookie is not deleted.

A complete logout normally starts or resumes the session, assigns an empty array to $_SESSION, deletes the session cookie using the same cookie path, domain, secure setting, HTTP only setting, and same site setting, and then calls session_destroy(). The application should immediately redirect or return a response so protected code does not continue running.

If the application must keep safe preferences, such as a language choice, it can remove only authentication related keys instead of destroying the entire session. That approach requires careful review so no sensitive value remains.

The code resumes the active session, clears the $_SESSION array for the current request, and reads the existing session cookie settings. When PHP uses cookies for sessions, it expires the session cookie with the same path, domain, secure setting, HTTP only setting, and same site setting. It then calls session_destroy() to delete the stored session data. Finally, it redirects and exits so no protected code continues after logout.

A common mistake is assuming that session_destroy() also clears $_SESSION. Values already loaded for the current request remain available until the application clears them or the request ends. Another mistake is assuming that session_unset() ends the session. It only clears registered session variables. Developers may also forget to delete the session cookie, use cookie settings that do not match the original cookie, call these functions before starting the session, continue running protected code after logout, or destroy the entire session when only authentication values should be removed.

Explain the distinction first. session_unset() clears session variables, while session_destroy() deletes stored session data. Then state what remains after each call and finish with the complete logout sequence: clear $_SESSION, remove the cookie, destroy the session, and stop further processing.

$this refers to the current object whose instance method is running. I use it to access that object’s properties and methods, such as $this->name or $this->save(). It is available only when PHP has an object context, so it is unavailable inside a static method. self resolves to the class where the code was declared, while static uses late static binding and can resolve to the class used for the current call.

$this means the object that is currently doing the work. It lets code inside an object read or change information that belongs to that same object. It also lets one action inside the object call another action on the same object. This matters because several objects can be created from one class, and each object can hold different information. PHP uses $this to know exactly which object should receive the read, change, or action during that method call. It does not create another object or copy the object’s information.

1. Should I also compare $this with self and static?
2. Should I explain how $this behaves inside closures?
3. Would you like a small inheritance example?

In PHP, $this is a special variable that refers to the current object. PHP makes it available when a method runs in an object context. For example, when $user->rename() runs, $this inside rename() refers to that exact $user object.

Use $this->property to read or update an instance property. Use $this->method() to call another instance method on the same object. The object operator is required because the property or method belongs to an object instance.

$this is unavailable inside a method declared static. A static method can be called without creating an object, so PHP has no current object to assign to $this. Trying to use $this without an object context throws an Error. In PHP 8 and later, calling a non static method statically also throws an Error.

$this is different from self and static. $this refers to an object instance. self resolves using the class where the code was declared. static uses late static binding, so inherited class behavior can resolve using the class selected by the current call.

A normal closure created in an object context is automatically bound to the current object, so it can use $this. A closure declared static is not bound to an object and cannot use $this. A bound closure can also keep its object alive while the closure remains reachable, which may matter in long running workers.

Accessing $this does not copy the object or allocate a new object. It uses the existing object context. Access itself has constant time behavior and normally adds no meaningful memory cost. The work performed by the accessed property or method may have its own cost. Production code should use $this only for data or behavior that belongs to the current object.

The example creates two User objects that hold separate names. Calling rename on the first object makes $this refer only to that object, so the second object remains unchanged. The describe method reads the current object’s name through $this. The className method uses self::class, which resolves to User because that is where the method was declared. The calledClassName method uses static::class, so a call through AdminUser resolves to AdminUser through late static binding. No static method uses $this because a static call has no required object context.

A common mistake is saying that $this refers to the class. It refers to the current object. Another mistake is using $this inside a static method, where no current object exists. Developers may also confuse $this->method() with self::method() or static::method(). The first calls through the current object. self resolves from the class where the code was declared. static uses late static binding. Another mistake is assuming that every closure has $this. A static closure has no object binding. Developers should also avoid storing a bound closure longer than needed when retaining the related object could increase memory use in a long running process.

Start by saying that $this refers to the current object instance. Give one property example and one method example. Then state that it is unavailable in static methods. Finish by separating $this from self and static. Mention closure binding only if the interviewer asks for an edge case.

PHP is a general purpose programming language that is especially suited to server side web development. PHP code normally runs on the server, processes a request, performs application work, and produces a response such as HTML or JSON. PHP is dynamically typed, while modern PHP also supports explicit type declarations. Its mature web support, Composer package ecosystem, broad hosting support, and straightforward request model make it practical for many web applications.

PHP is a language often used to make websites do useful work. It usually runs on the computer that sends the website to the visitor. When a person opens a page or submits information, PHP can check the information, make decisions, read or save data, and prepare what the visitor receives. It is popular because it works well for many kinds of websites, has many reusable tools, connects easily to common data stores, and can be used for both small sites and large business systems.

1. Should I explain PHP mainly in the context of traditional web applications?
2. Would you like me to compare PHP with JavaScript running in the browser?

PHP is a general purpose programming language with strong support for server side web development. In a common production setup, a web server receives an HTTP request and passes PHP work through a server interface, often PHP FPM. PHP creates the request context, runs the application entry code, performs work such as validation, business logic, database access, or service calls, produces output such as HTML or JSON, and then completes request shutdown.

With traditional PHP FPM, worker processes can stay alive and handle many requests over time, but normal user application variables belong to the current request and should not be treated as shared mutable state between requests. Separate workers also do not share ordinary PHP variables. Long running PHP runtimes are different because application objects and static state can remain in memory between requests, so explicit state cleanup is important.

PHP is dynamically typed. A variable can hold values of different types during execution. Modern PHP also supports explicit parameter types, return types, property types, union types, intersection types, nullable types, and other type declarations. The strict types declaration changes scalar type coercion behavior for relevant function calls, but it does not turn PHP into a statically typed language.

PHP has a large package ecosystem centered on Composer, with Packagist commonly used as a package repository. Composer, Packagist, Laravel, and Symfony are separate from the core PHP language.

PHP strengths include mature web capabilities, a large ecosystem, broad deployment support, and a simple request based execution model. Tradeoffs include runtime type mistakes when types are not controlled carefully and additional lifecycle concerns in long running processes. Traditional PHP worker processes also consume memory for the runtime and loaded application state, so production systems usually tune worker counts according to available memory and workload.

Client side JavaScript normally runs in the browser and can directly work with the page and browser features. PHP normally runs on the server and prepares data or content that is sent back to the client.

A common mistake is saying PHP normally runs in the browser like client side JavaScript. PHP normally runs on the server. Another mistake is saying all PHP requests share ordinary application variables. Standard PHP FPM commonly uses separate worker processes, and normal request variables should not be treated as shared state across requests. Candidates may also call PHP completely untyped. PHP is dynamically typed, but modern PHP supports extensive explicit type declarations. Another mistake is treating Laravel, Symfony, Composer, Packagist, PHP FPM, or database extensions as if they were all built into the PHP language.

Start by saying that PHP is a general purpose language especially suited to server side web development. Then explain the request flow in simple order: receive a request, run PHP application code, perform the required work, and return a response such as HTML or JSON. Mention dynamic typing with modern type declarations, Composer as the common dependency manager, and the difference between server side PHP and JavaScript running in the browser.

A PHP array is an ordered map. It stores values under integer or string keys and keeps insertion order. I can use it like an indexed list with integer keys or like an associative collection with named string keys. Values can have different types and can contain nested arrays. PHP arrays are very flexible, but they use more memory than a simple fixed size array in a lower level language.

A PHP array is a flexible container that stores several values together. Each value has a key that helps PHP find it. A key can be a number or text. PHP also remembers the order in which entries were added. The same array feature can therefore represent a simple list, named values, or data containing other arrays. The stored values do not need to be the same kind. This flexibility makes PHP arrays useful for many everyday tasks, but it also makes them use more memory than a simple fixed size group of values in many lower level languages.

1. Would you like me to explain both indexed and associative arrays?
2. Should I also cover key conversion and memory tradeoffs?

A PHP array is an ordered map. A map connects a key to a value, and ordered means PHP preserves insertion order.

An indexed array normally uses integer keys such as 0, 1, and 2. An associative array uses string keys such as name or email. PHP uses the same array type for both forms, and one array can contain both integer and string keys.

Array values can have different PHP types. One entry can hold a string, another an integer, and another an array. Arrays inside arrays are called nested arrays.

PHP converts some key types. A valid decimal integer string such as "8" becomes the integer key 8. A float key is converted to an integer by removing its fractional part. True becomes the integer key 1, false becomes 0, and null becomes an empty string key. If two supplied keys become the same final key, a later assignment replaces the earlier value.

I read or write a value by its key. Empty brackets append a value using the next available integer key. I normally iterate through an array with foreach, which can provide both the key and value.

If a key may contain null and I must distinguish that from a missing key, I use array_key_exists. isset returns false when the key is missing and also when its value is null.

PHP arrays provide convenient key access and flexible values, but this ordered map structure uses more memory than a compact fixed size array. Array assignment uses value semantics. PHP can avoid an immediate physical copy through copy on write behavior, and separation occurs when a shared array must be modified.

A common mistake is saying that a PHP array is only a list. It is an ordered map and supports integer and string keys. Another mistake is assuming every supplied key keeps its original type even when PHP converts it. Candidates may also use isset when they need to distinguish a missing key from a present key whose value is null. Another mistake is saying array assignment makes the two variables references to the same array. Normal assignment uses value semantics, while PHP can delay physical copying through copy on write behavior. PHP arrays should also not be described as compact fixed size arrays because their flexibility has a significant memory cost.

Start by saying that a PHP array is an ordered map with integer or string keys. Then explain indexed and associative use, insertion order, mixed values, key conversion, and foreach. Finish with one practical detail, such as array_key_exists for a null value, plus the memory tradeoff of PHP arrays.

Object oriented programming in PHP means organizing related data and behavior inside classes and creating objects from those classes. Properties store state, methods perform actions, and constructors prepare new objects. Visibility supports encapsulation by controlling access to members. Interfaces, inheritance, abstract classes, traits, composition, and polymorphism can help reuse or replace behavior when there is a real need. I prefer a simple function or small value object when a larger class design would only add complexity.

Object oriented programming is a way to keep related information and actions together. For example, an order can store its number and total amount, and it can also know how to describe itself. This can make a larger program easier to organize because each part has a clear job. It also gives developers several ways to reuse behavior or replace one implementation with another. The important point is not to create many layers just because PHP supports them. A simple function or small object is often clearer when the problem itself is simple.

1. Would you like a small PHP example that shows the main object oriented features together?
2. Should I also explain when composition is better than inheritance?

In PHP, a class defines properties and methods. An object is an instance created from that class. Properties hold state, and methods define behavior. A constructor named __construct runs when an object is created and can receive the values or dependencies that the object needs.

Visibility controls access to class members. A public member can be accessed from outside the class. A protected member can be accessed inside the declaring class and its child classes. A private member can be accessed only from the class that declares it. This supports encapsulation because a class can protect its internal state and expose only the operations callers should use.

Inheritance lets one class extend another class. It is most useful when the child really represents a specialized form of the parent. An abstract class cannot be instantiated directly. It can provide shared implementation and can declare abstract methods that concrete child classes must implement. An interface defines a contract that implementing classes must satisfy. Different classes that implement the same interface can be accepted through that interface type. Using different concrete objects through the same type is polymorphism.

A trait lets classes reuse properties or methods without creating a parent and child relationship. Composition means one object contains or receives another object and delegates work to it. Composition often keeps classes less tightly connected and makes dependencies easier to replace.

In the order example, Order receives a PriceFormatter interface. Different formatter objects can provide different formatting behavior without changing Order. If a problem only needs one calculation, a function may be clearer. If it represents a small group of values with rules, a value object may be enough. Large inheritance trees can increase object count, dependencies, and maintenance cost without improving the design.

This example uses one small order domain. Order stores its own state and receives a PriceFormatter through an interface. DollarPriceFormatter and PlainPriceFormatter provide different implementations of the same format method, so Order can work with either implementation through polymorphism. BaseEntity is an abstract class that gives Order a shared identifier. HasLabel is a trait that reuses a small label method. The Order constructor receives the initial total and formatter dependency. Private properties protect internal state, while public methods expose supported behavior. The formatter is included through composition instead of inheritance. This keeps the example small while demonstrating the main PHP object oriented features.

A common mistake is treating object oriented programming as a reason to turn every function into a class. Another mistake is using inheritance only to reuse code even when the classes do not have a real parent and child relationship. Developers may also expose every property as public, which weakens encapsulation. Another mistake is thinking an interface provides shared implementation. An interface defines required behavior, while a trait can provide reusable implementation. Developers may also think a private parent property is directly accessible from a child class. It is not. Deep inheritance trees can make behavior harder to follow and change. Composition is often simpler when one object only needs another object's service.

Start by saying that classes group related state and behavior and objects are instances of those classes. Then explain constructors, visibility, and encapsulation. After that, compare interfaces, inheritance, abstract classes, traits, composition, and polymorphism with one small example. Finish by saying that good object oriented design does not mean using classes everywhere. A simple function or small value object is often the better choice for a simple problem.

A PHP namespace groups related names and helps prevent name collisions. I declare one with the namespace statement. I can then refer to a class by its fully qualified name or import it with use. An alias can give an imported name a different local name. Namespaces organize names, but they do not load files by themselves. File loading is normally handled by an autoloader such as Composer.

A namespace gives a group of PHP classes and functions its own naming area. This lets two parts of an application use the same short name without confusing PHP about which one is meant. You give the group a name near the start of the PHP file. Other code can then refer to an item by its complete name or bring that name into the current file with a shorter local name. A namespace only changes how names are identified. It does not find or open PHP files. File loading is a separate job.

1. Would you like a simple class example showing namespace and use?
2. Should I also explain how namespaces work with Composer autoloading?

A PHP namespace is a way to organize named code and avoid name collisions. For example, two libraries might both define a class called Logger. They can exist together if their complete names are different, such as App\Logging\Logger and Vendor\Tools\Logger.

A file can declare a namespace with a statement such as namespace App\Logging;. A class or function declared after that statement belongs to that namespace unless another namespace declaration changes the current namespace.

A fully qualified name starts with a backslash and identifies a name from the global namespace, such as \App\Logging\Logger. An unqualified class name such as Logger normally refers to the current namespace unless a use import provides another meaning. PHP does not fall back to a global class when that namespaced class is missing.

The use statement imports a name for easier reference in the current file. For example, use App\Logging\Logger; lets the code write Logger. PHP also supports aliases, such as use App\Logging\Logger as AppLogger;. The alias changes only the local name used by that file.

Function resolution has an important difference. An unqualified function call inside a namespace first refers to that namespace. If the namespaced function does not exist, PHP can fall back to a global function with that name. Using a fully qualified function name makes the target explicit.

Namespaces are often designed to match project folders, but PHP itself does not require that relationship. Composer projects commonly use PSR 4 rules to map namespace prefixes to directories. Composer can then register an autoloader that loads matching class files when needed.

The key limitation is that a namespace never loads a file by itself. It controls names. Autoloading is a separate mechanism. Namespace use normally has no meaningful application level memory or performance cost compared with the work done by the application itself.

A common mistake is saying that a namespace loads a PHP file. It does not. Another mistake is assuming that a namespace must exactly match the directory structure. PHP itself does not require that mapping. Developers may also confuse use with file inclusion. The use statement imports a name into the current naming context. It does not work like require. Another mistake is expecting an unqualified class name to fall back to a global class when a namespaced class is missing. That fallback applies to unqualified functions and constants, not classes. An alias also changes only the local name used in that file. It does not rename the original class.

Start by saying that namespaces organize names and prevent collisions. Then explain a fully qualified name, a use import, and an alias. Mention that class resolution and function resolution have an important difference. Finish by making the key distinction that namespaces identify code, while an autoloader is responsible for loading files.