Core Language Fundamentals Interview Questions

PHP (Hypertext Preprocessor) is a server-side scripting language designed specifically for web development. Originally, PHP stood for Personal Home Page, but it was later renamed to PHP: Hypertext Preprocessor.

PHP has eight primitive data types: Integer (int), Float/Double, String, Boolean, Array, Object, NULL, and Resource. As of PHP 7, two additional types were added: Object and Callable.

Type casting is converting one data type to another. In PHP, it can be done using either casting operators (int), (string), (array), etc., or functions like intval(), strval(), settype(). PHP also performs automatic type conversion.

The == operator checks only for equality of values, while === checks for both equality of values and equality of types. For example, '1' == 1 returns true, but '1' === 1 returns false.

Superglobals are built-in variables always available in all scopes. These include: $_GET, $_POST, $_SERVER, $_FILES, $_COOKIE, $_SESSION, $_REQUEST, $_ENV, and $GLOBALS.

Both include and require are used to include files, but they handle errors differently. require produces a fatal error and halts execution if the file is not found, while include only produces a warning and continues execution.

PHP has four variable scopes: local (inside functions), global (outside functions), static (retains value between function calls), and superglobal (accessible everywhere). The 'global' keyword or $GLOBALS array is used to access global variables inside functions.

GET sends data through URL parameters, visible in browser history, and has length limitations. POST sends data through HTTP request body, not visible in URL, more secure, and can handle larger data. GET is idempotent while POST is not.

Magic constants are predefined constants that change based on where they are used. Examples include __LINE__, __FILE__, __DIR__, __FUNCTION__, __CLASS__, __METHOD__, __NAMESPACE__. Their values are determined by where they are used.

The final keyword prevents child classes from overriding a method or prevents a class from being inherited. When used with methods, it prevents method overriding, and when used with classes, it prevents class inheritance.

Traits are mechanisms for code reuse in single inheritance languages like PHP. They allow you to reuse sets of methods freely in several independent classes living in different class hierarchies. They address the limitations of single inheritance.

Type hinting enforces specified data types for function parameters and return values. It can be used with arrays, objects, interfaces, and scalar types (in PHP 7+). It helps catch type-related errors early and improves code reliability.

Autoloading automatically loads PHP classes without explicitly using require or include statements. spl_autoload_register() is commonly used to register autoloader functions. PSR-4 is the modern standard for autoloading in PHP.

Anonymous functions, also known as closures, are functions without a name that can access variables from the outside scope. They are often used as callback functions and can be assigned to variables.

echo and print both output strings, but echo can take multiple parameters and is marginally faster, while print can only take one parameter and returns a value (always 1). echo is a language construct, not a function.

yield is used to implement generators, which provide a way to iterate over a set of data without keeping the entire set in memory. It's memory-efficient for large datasets as it generates values on-the-fly.

Magic methods are special methods that override PHP's default behavior when certain actions are performed on an object. Examples include __construct(), __destruct(), __get(), __set(), __isset(), __unset(), __call(), __toString().

self refers to the current class and is used to access static members, while $this refers to the current object instance and is used to access non-static members. self is resolved at compile time, while $this is resolved at runtime.

Namespaces are a way of encapsulating related classes, interfaces, functions, and constants to avoid name collisions. They provide better organization and reusability of code. They are declared using the namespace keyword.

PHP supports three types of arrays: Indexed arrays (numeric keys), Associative arrays (named keys), and Multidimensional arrays (arrays containing other arrays). Arrays in PHP are actually ordered maps.

Late static binding refers to a way of using static keyword to reference the class that was initially called at runtime rather than the class where the method is defined. It's implemented using the static keyword instead of self.

unset() completely removes a variable from memory, while setting a variable to null keeps the variable but sets its value to nothing. isset() returns false for both null values and unset variables.

Generators provide a way to implement simple iterators without the overhead of creating a class implementing Iterator interface. They're useful when working with large datasets or infinite sequences as they save memory.

Abstract classes can have properties and implemented methods, while interfaces can only have method signatures. A class can implement multiple interfaces but can extend only one abstract class. Abstract classes provide a partial implementation.

Variadic functions can accept a variable number of arguments using the ... operator. func_get_args() can also be used to get an array of all passed arguments. They provide flexibility in function parameter handling.

Constructor property promotion is a shorthand syntax that allows declaring and initializing class properties directly in the constructor parameter list. It reduces boilerplate code by combining property declaration and constructor parameter definition.

count() and sizeof() are identical functions and can be used interchangeably. Both return the number of elements in an array or properties in an object. sizeof() is an alias of count(), created for C/C++ programmers' familiarity.

The callable type hint ensures that a function parameter can be called as a function. It accepts regular functions, object methods, static class methods, and closure functions. It helps enforce that passed parameters are actually callable.

Enums are a special type of class that represents a fixed set of possible values. They provide type safety, autocompletion, and prevent invalid values. Enums can have methods and implement interfaces, making them more powerful than constant arrays.

Attributes (also known as annotations in other languages) provide a way to add metadata to classes, methods, properties, parameters, and constants. They are defined using #[] syntax and can be used for configuration, validation, and other metadata purposes.