dictionary.rst

PHP Dictionary

• $

  • :ref:`$GLOBALS <globals>`
  • :ref:`$HTTP_RAW_POST_DATA <$HTTP_RAW_POST_DATA>`
  • :ref:`$_COOKIE <$_cookie>`
  • :ref:`$_ENV <$_env>`
  • :ref:`$_FILES <$_FILES>`
  • :ref:`$_GET <$_get>`
  • :ref:`$_POST <$_post>`
  • :ref:`$_REQUEST <$_request>`
  • :ref:`$_SERVER <$_server>`
  • :ref:`$argc <$argc>`
  • :ref:`$argv <$argv>`
  • :ref:`$http_response_header <$http_response_header>`
  • :ref:`$php_errormsg <$php_errormsg>`
  • :ref:`$this <$this>`

• (

  • :ref:`(void) Cast <void-cast>`

• .

  • :ref:`. Directory <dot-directory>`
  • :ref:`. File <dot-file>`
  • :ref:`.. Directory <dot-dot-directory>`
  • :ref:`.env File <env-file>`
  • :ref:`.htaccess <htaccess>`

• @

  • :ref:`@, No Scream Operator <noscream>`

• _

  • :ref:`__CLASS__ <-__class__>`
  • :ref:`__FILE__ <-__file__>`
  • :ref:`__FUNCTION__ <-__function__>`
  • :ref:`__LINE__ <-__line__>`
  • :ref:`__METHOD__ <-__method__>`
  • :ref:`__TRAIT__ <-__trait__>`
  • :ref:`__autoload <-__autoload>`
  • :ref:`__call() Method <-__call>`
  • :ref:`__callStatic() Method <-__callstatic>`
  • :ref:`__clone() Method <-__clone>`
  • :ref:`__get() Method <-__get>`
  • :ref:`__halt_compiler() <halt-compiler>`
  • :ref:`__invoke() Method <-__invoke>`
  • :ref:`__isset() Method <-__isset>`
  • :ref:`__serialize() Method <-__serialize>`
  • :ref:`__set() Method <-__set>`
  • :ref:`__set_state() Method <-__set_state>`
  • :ref:`__sleep() Method <-__sleep>`
  • :ref:`__toString() Method <-__tostring>`
  • :ref:`__unserialize() Method <-__unserialize>`
  • :ref:`__unset() Method <-__unset>`
  • :ref:`__wakeup() Method <-__wakeup>`

• A

  • :ref:`Absolute <absolute>`
  • :ref:`Absolute Name <absolute-name>`
  • :ref:`Absolute Value <absolute-value>`
  • :ref:`Abstract Class <abstract-class>`
  • :ref:`Abstract Factory <abstract-factory>`
  • :ref:`Abstract Keyword <abstract>`
  • :ref:`Abstract Method <abstract-method>`
  • :ref:`Abstract Syntactic Tree (AST) <ast>`
  • :ref:`Abstraction <abstraction>`
  • :ref:`Abstraction Layer <abstraction-layer>`
  • :ref:`Accessibility <accessibility>`
  • :ref:`Accountability <accountability>`
  • :ref:`Active Record <active-record>`
  • :ref:`Adapters <adapter>`
  • :ref:`Addition <addition>`
  • :ref:`Agile <agile>`
  • :ref:`Ahead Of Time (OAT) <aot>`
  • :ref:`Algorithm <algorithm>`
  • :ref:`Algorithmic Complexity <algorithmic-complexity>`
  • :ref:`Alias <alias>`
  • :ref:`Alias Types <alias-types>`
  • :ref:`Allow Dynamic Properties <allowdynamicproperties>`
  • :ref:`Alternative Syntax <alternative-syntax>`
  • :ref:`American Standard Code for Information Interchange (ASCII) <ascii>`
  • :ref:`And Operator <and>`
  • :ref:`Annotations <annotation>`
  • :ref:`Anonymize <anonymize>`
  • :ref:`Anonymous <anonymous>`
  • :ref:`Anonymous Catch <anonymous-catch>`
  • :ref:`Anonymous Class <anonymous-class>`
  • :ref:`Anonymous Constant <anonymous-constant>`
  • :ref:`Anonymous Function <anonymous-function>`
  • :ref:`Application Performance Management (APM) <apm>`
  • :ref:`Application Programming Interface (API) <api>`
  • :ref:`Application Server <app-server>`
  • :ref:`Arbitrary Number Of Argument <arbitrary-argument>`
  • :ref:`Arcane <arcane>`
  • :ref:`Architectural Decision Record (ADR) <adr>`
  • :ref:`Architecture <architecture>`
  • :ref:`Archive <archive>`
  • :ref:`Argon2 <argon2>`
  • :ref:`Argument <argument>`
  • :ref:`ArgumentCountError <argumentcounterror>`
  • :ref:`ArithmeticError Error <arithmeticerror>`
  • :ref:`Arm <arm>`
  • :ref:`Array <array>`
  • :ref:`Array Append <append>`
  • :ref:`Array Callback <array-callback>`
  • :ref:`Array Element <array-element>`
  • :ref:`Array Prepend <prepend>`
  • :ref:`Array Spread <array-spread>`
  • :ref:`Array Syntax <array-syntax>`
  • :ref:`Array With Curly Braces <array-curly-braces>`
  • :ref:`ArrayAccess <arrayaccess>`
  • :ref:`ArrayObject <arrayobject>`
  • :ref:`Arrow Functions <arrow-function>`
  • :ref:`Artifact <artifact>`
  • :ref:`As <as>`
  • :ref:`Aspect Oriented Programming <aspect-programming>`
  • :ref:`Assertions <assertion>`
  • :ref:`Asset <asset>`
  • :ref:`Assignations <assignation>`
  • :ref:`Associative Array <associative-array>`
  • :ref:`Assumption <assumption>`
  • :ref:`Asymmetric Property <asymmetric-property>`
  • :ref:`Asymmetric Visibility <asymmetric-visibility>`
  • :ref:`Async <async>`
  • :ref:`Asynchronous <asynchronous>`
  • :ref:`Attribute <attribute>`
  • :ref:`Attribute Class <attribute-class>`
  • :ref:`Audit Trail <audit-trail>`
  • :ref:`Authentication <authentication>`
  • :ref:`Authorize <authorize>`
  • :ref:`Automagic <automagic>`
  • :ref:`Automatic Index <automatic-index>`
  • :ref:`Autovivification <autovivification>`
  • :ref:`Autowiring <autowiring>`
  • :ref:`abs() <abs>`
  • :ref:`array_column <array_column>`
  • :ref:`array_combine() <array_combine>`
  • :ref:`array_key_exists() <array_key_exists>`
  • :ref:`array_keys() <array_keys>`
  • :ref:`array_map() <array_map>`
  • :ref:`array_merge() <array_merge>`
  • :ref:`array_unique() <array_unique>`
  • :ref:`array_values() <array_values>`
  • :ref:`array_walk() <array_walk>`

• B

  • :ref:`Back-tick <backtick>`
  • :ref:`Backed <backed>`
  • :ref:`Backed Enum <backed-enum>`
  • :ref:`Backed Property <backed-property>`
  • :ref:`BackedEnum <backedenum>`
  • :ref:`Backend <backend>`
  • :ref:`Backslash \ <back-slash>`
  • :ref:`Backtrace <backtrace>`
  • :ref:`Backward Incompatible <backward-incompatible>`
  • :ref:`BadFunctioncallException <badfunctioncallexception>`
  • :ref:`Balanced <balanced>`
  • :ref:`Bang ! <bang>`
  • :ref:`Base 64 Encoding <base64>`
  • :ref:`Batch <batch>`
  • :ref:`Bcmath <bcmath>`
  • :ref:`Benchmarking <benchmarking>`
  • :ref:`Best Practices <best-practice>`
  • :ref:`Binary <binary>`
  • :ref:`Binary Integer <binary-integer>`
  • :ref:`Binary Not Operator <binary-not>`
  • :ref:`Binary Operator <binary-operator>`
  • :ref:`Bind <bind>`
  • :ref:`Bitfield <bitfield>`
  • :ref:`Bitmask <bitmask>`
  • :ref:`Bitshift Operators <bitshift-operator>`
  • :ref:`Bitwise Operators <bitwise-operator>`
  • :ref:`Blind Variable <blind-key>`
  • :ref:`Block <block>`
  • :ref:`Bloom Filter <bloom-filter>`
  • :ref:`Body <body>`
  • :ref:`Boilerplate <boilerplate>`
  • :ref:`Boolean <boolean>`
  • :ref:`Bootstrap <bootstrap>`
  • :ref:`Bottleneck <bottleneck>`
  • :ref:`Bracket <bracket>`
  • :ref:`Bracketless <bracketless>`
  • :ref:`Branch <branch>`
  • :ref:`Breach <breach>`
  • :ref:`Break <break>`
  • :ref:`Broken Object Level Authorization (BOLA) <bola>`
  • :ref:`Bucket <bucket>`
  • :ref:`Bug <bug>`
  • :ref:`Byte <byte>`
  • :ref:`basename <basename>`
  • :ref:`browscap <browscap>`
  • :ref:`bzip2 Extension <bzip2>`

• C

  • :ref:`C2 Framework <c2-framework>`
  • :ref:`CAPTCHA <captcha>`
  • :ref:`CSV Injection <csv-injection>`
  • :ref:`Cache <cache>`
  • :ref:`Calendar <calendar>`
  • :ref:`Call <call>`
  • :ref:`Callable Arrays <array-callable>`
  • :ref:`Callables <callable>`
  • :ref:`Callbacks <callback>`
  • :ref:`Callstack <callstack>`
  • :ref:`Camel Case <camel-case>`
  • :ref:`Canonical <canonical>`
  • :ref:`Case <case>`
  • :ref:`Case Sensitivity <case-sensitivity>`
  • :ref:`Cast Operator <cast>`
  • :ref:`Catch <catch>`
  • :ref:`Centralization <centralization>`
  • :ref:`Chaining <chaining>`
  • :ref:`Chaining Exceptions <exception-chain>`
  • :ref:`Chaining New Without Parenthesis <chaining-new-without-parenthesis>`
  • :ref:`Character <character>`
  • :ref:`Child Class <child-class>`
  • :ref:`Circuit Breaker <circuit-breaker>`
  • :ref:`Circular Reference <circular-reference>`
  • :ref:`Class <class>`
  • :ref:`Class Aliases <class-alias>`
  • :ref:`Class Autoloading <autoload>`
  • :ref:`Class Constant Syntax <class-constant-syntax>`
  • :ref:`Class Constants Visibility <class-constant-visibility>`
  • :ref:`Class Entities <class-entity>`
  • :ref:`Class Getter Method <getter>`
  • :ref:`Class Hierarchy <class-hierarchy>`
  • :ref:`Class Hoisting <class-hoisting>`
  • :ref:`Class Interface Trait Enumeration (CITE) <cite>`
  • :ref:`Class Invasion <class-invasion>`
  • :ref:`Class Operator <class-operator>`
  • :ref:`Class Setter Method <setter>`
  • :ref:`Class Wither Method <wither>`
  • :ref:`Clean Architecture <clean-architecture>`
  • :ref:`Clean Code <clean-code>`
  • :ref:`Client URL (CURL) <curl>`
  • :ref:`Clone <clone>`
  • :ref:`Close Naming <close-naming>`
  • :ref:`Close Tag <close-tag>`
  • :ref:`Closed Source <closed-source>`
  • :ref:`ClosedGeneratorException <closedgeneratorexception>`
  • :ref:`Closure <closure>`
  • :ref:`Closure Binding <closure-binding>`
  • :ref:`Closure Class <closure-class>`
  • :ref:`Coalesce Operator <coalesce>`
  • :ref:`Code Architecture <code-architecture>`
  • :ref:`Code Coverage <code-coverage>`
  • :ref:`Code Formatter <code-formatter>`
  • :ref:`Code Freeze <code-freeze>`
  • :ref:`Code Generator <code-generator>`
  • :ref:`Code Injection <code-injection>`
  • :ref:`Code Inventory <inventory>`
  • :ref:`Code Reuse <code-reuse>`
  • :ref:`Code Review <code-review>`
  • :ref:`Code Smell <code-smell>`
  • :ref:`Codepoint <codepoint>`
  • :ref:`Coding Conventions <coding-convention>`
  • :ref:`Coding Formatting <code-formatting>`
  • :ref:`Cognitive Complexity <cognitive-complexity>`
  • :ref:`Collection <collection>`
  • :ref:`Collision <collision>`
  • :ref:`Colon <colon>`
  • :ref:`Comma <comma>`
  • :ref:`Comma Secparated Values (CSV) <csv>`
  • :ref:`Command Bus <command-bus>`
  • :ref:`Command Line Interface (CLI) <cli>`
  • :ref:`Command Query Responsibility Segregation (CQRS) <cqrs>`
  • :ref:`Comments <comment>`
  • :ref:`Commit <commit>`
  • :ref:`Common Interface Gateway (CGI) <cgi>`
  • :ref:`Common Vulnerabilities And Exposures (CVE) <cve>`
  • :ref:`Community <community>`
  • :ref:`Compact Array <compact-array>`
  • :ref:`Comparison <comparison>`
  • :ref:`Compatibility <compatibility>`
  • :ref:`Compile <compile>`
  • :ref:`Compile Time <compile-time>`
  • :ref:`Complexity <complexity>`
  • :ref:`Compliance <compliance>`
  • :ref:`Component <component>`
  • :ref:`Composer <composer>`
  • :ref:`Composition <composition>`
  • :ref:`Compression <compression>`
  • :ref:`Concatenation <concatenation>`
  • :ref:`Concatenative <concatenative>`
  • :ref:`Concrete Class <concrete>`
  • :ref:`Concrete Method <concrete-method>`
  • :ref:`Concurency <concurency>`
  • :ref:`Concurent Version System (CVS) <cvs>`
  • :ref:`Condition <condition>`
  • :ref:`Conditional Structures <conditional-structure>`
  • :ref:`Conditioned Structures <conditioned>`
  • :ref:`Configuration <configuration>`
  • :ref:`Connexion Persistence <connexion-persistence>`
  • :ref:`Consistency <consistency>`
  • :ref:`Const <const>`
  • :ref:`Constant Case <constant-case>`
  • :ref:`Constant Combinaison <constant-combinaison>`
  • :ref:`Constant Expression <constant-expression>`
  • :ref:`Constant Scalar Expression <constant-scalar-expression>`
  • :ref:`Constants <constant>`
  • :ref:`Constants In Trait <constant-in-trait>`
  • :ref:`Constructor <constructor>`
  • :ref:`Container <container>`
  • :ref:`Content Management System (CMS) <cms>`
  • :ref:`Continue <continue>`
  • :ref:`Continuous Delivery (CD) <cd>`
  • :ref:`Continuous Integration (CI) <ci>`
  • :ref:`Contravariance <type-contravariance>`
  • :ref:`Control Flow <control-flow>`
  • :ref:`Control Flow Graph <control-flow-graph>`
  • :ref:`Control Structures <control-structure>`
  • :ref:`Controller <controller>`
  • :ref:`Convention <convention>`
  • :ref:`Convert <convert>`
  • :ref:`Cookie <cookie>`
  • :ref:`Copy On Write (COW) <copy-on-write>`
  • :ref:`Core <core>`
  • :ref:`Coroutine <coroutine>`
  • :ref:`Countable Interface <countable>`
  • :ref:`Coupling <coupling>`
  • :ref:`Covariance <type-covariance>`
  • :ref:`Coverage <coverage>`
  • :ref:`Create, Read, Update And Delete (CRUD) <crud>`
  • :ref:`Cron <cron>`
  • :ref:`Cross Site Request Forgery (CSRF) <csrf>`
  • :ref:`Cross Site Scripting (XSS) <xss>`
  • :ref:`Cryptographic Hash <hash-crypto>`
  • :ref:`Cryptography <cryptography>`
  • :ref:`Ctype <ctype>`
  • :ref:`Curly Brackets <curly-bracket>`
  • :ref:`Custom <custom>`
  • :ref:`Cyclic Redundancy Check 32-bit (CRC32) <crc32>`
  • :ref:`Cyclomatic Complexity <cyclomatic-complexity>`
  • :ref:`class_alias() <class_alias>`
  • :ref:`compact() <compact>`
  • :ref:`constant() <constant-function>`
  • :ref:`count() <count>`

• D

  • :ref:`DIRECTORY_SEPARATOR <directory_separator>`
  • :ref:`DOM <domxml>`
  • :ref:`Dangling Reference <dangling-reference>`
  • :ref:`Data <data>`
  • :ref:`Data Access Object (DAO) <dao>`
  • :ref:`Data Container <data-container>`
  • :ref:`Data Leak <data-leak>`
  • :ref:`Data Mapper <data-mapper>`
  • :ref:`Data Source Name (DSN) <dsn>`
  • :ref:`Data Structure <ds>`
  • :ref:`Data Transfer Object (DTO) <dto>`
  • :ref:`Database <database>`
  • :ref:`Database Abstraction Layer (DBA) Extension <dba>`
  • :ref:`Database Abstraction Layer (DBAL) <dbal>`
  • :ref:`Dataset <dataset>`
  • :ref:`Datastack <datastack>`
  • :ref:`DateInterval <dateinterval>`
  • :ref:`DateTime <datetime>`
  • :ref:`Dates <date>`
  • :ref:`Datetime Trap <datetime-trap>`
  • :ref:`Day Are Not 86400 Seconds <day-in-seconds>`
  • :ref:`Days In Month <days-in-month>`
  • :ref:`Dead Code <dead-code>`
  • :ref:`Debugger <debugger>`
  • :ref:`Declaration <declaration>`
  • :ref:`Declarative Programming <declarative-programming>`
  • :ref:`Decorator Pattern <decorator>`
  • :ref:`Decoupling <decoupling>`
  • :ref:`Deep Clone <deep-clone>`
  • :ref:`Default <default>`
  • :ref:`Default Parameter <default-parameter>`
  • :ref:`Default Value <default-value>`
  • :ref:`Defensive Programming <defensive-programming>`
  • :ref:`Definition <definition>`
  • :ref:`Delimiter <delimiter>`
  • :ref:`Dependency <dependency>`
  • :ref:`Dependency Injection <dependency-injection>`
  • :ref:`Dependency Injection Container <dependency-injection-container>`
  • :ref:`Dependent Type <dependent-type>`
  • :ref:`Deployment <deploy>`
  • :ref:`Deprecated <deprecated>`
  • :ref:`Deprecation <deprecation>`
  • :ref:`Depth <depth>`
  • :ref:`Dereferencing <dereferencing>`
  • :ref:`Design By Contract (DBC) <contract>`
  • :ref:`Design Pattern <design-pattern>`
  • :ref:`Design Pattern Wrapper <wrapper-designpattern>`
  • :ref:`Destructor <destructor>`
  • :ref:`Dictionary <dictionary>`
  • :ref:`Diff <diff>`
  • :ref:`Dir <dir>`
  • :ref:`Directives <directive>`
  • :ref:`DirectoryIterator <directoryiterator>`
  • :ref:`Disable <disable>`
  • :ref:`Disable Classes <disable-classes>`
  • :ref:`Disable Functions <disable-functions>`
  • :ref:`Disjunctive Normal Form (DNF) <dnf-type>`
  • :ref:`Distributed Denial Of Service (DDOS) <ddos>`
  • :ref:`Division <division>`
  • :ref:`DivisionByZeroError <divisionbyzeroerror>`
  • :ref:`Do While <do-while>`
  • :ref:`Docblock <docblock>`
  • :ref:`Docker Container <docker-container>`
  • :ref:`Documentation <documentation>`
  • :ref:`Dollar / <dollar>`
  • :ref:`Domain Design Driven (DDD) <ddd>`
  • :ref:`Domain Name System (DNS) <dns>`
  • :ref:`DomainException <domainexception>`
  • :ref:`Don't Repeat Yourself (DRY) <dry>`
  • :ref:`Dot Notation <dot-notation>`
  • :ref:`Double <double>`
  • :ref:`Double Arrow <double-arrow>`
  • :ref:`Double Check <double-check>`
  • :ref:`Double Quotes Strings <double-quote>`
  • :ref:`Downtime <downtime>`
  • :ref:`Duck Typing <ducktyping>`
  • :ref:`Dynamic <dynamic>`
  • :ref:`Dynamic Call <dynamic-call>`
  • :ref:`Dynamic Class <dynamic-class>`
  • :ref:`Dynamic Class Constant <dynamic-class-constant>`
  • :ref:`Dynamic Constant <dynamic-constant>`
  • :ref:`Dynamic Expression <dynamic-expression>`
  • :ref:`Dynamic Loading <dynamic-loading>`
  • :ref:`Dynamic Method <dynamic-method>`
  • :ref:`Dynamic Properties <dynamic-property>`
  • :ref:`Dynamic Variable <dynamic-variable>`
  • :ref:`declare Encoding <declare-encoding>`
  • :ref:`declare() <declare>`
  • :ref:`default_charset <default_charset>`
  • :ref:`define() <define>`
  • :ref:`defined() <defined>`
  • :ref:`delayedtargetvalidation <delayedtargetvalidation>`
  • :ref:`dirname <dirname>`
  • :ref:`display_errors <display_errors>`

• E

  • :ref:`Early Binding <early-binding>`
  • :ref:`Echo <echo>`
  • :ref:`Echo Tag <echo-tag>`
  • :ref:`Ecosystem <ecosystem>`
  • :ref:`Edge Case <edge-case>`
  • :ref:`Elephpant <elephpant>`
  • :ref:`Ellipsis <ellipsis>`
  • :ref:`Email <email>`
  • :ref:`Embed <embed>`
  • :ref:`Emoji <emoji>`
  • :ref:`Empty <empty>`
  • :ref:`Empty String <empty-string>`
  • :ref:`Enable <enable>`
  • :ref:`Encapsulation <encapsulation>`
  • :ref:`Encoding <encoding>`
  • :ref:`Entities <entity>`
  • :ref:`Enumeration (enum) <enum>`
  • :ref:`Enumeration Case <enum-case>`
  • :ref:`Environment <environment>`
  • :ref:`Environment Variables <environment-variable>`
  • :ref:`Eponymous <eponymous>`
  • :ref:`Equal Operator <equal>`
  • :ref:`Error <error>`
  • :ref:`Error Handler <error-handler>`
  • :ref:`Error Handling <error-handling>`
  • :ref:`Error Reporting <error_reporting>`
  • :ref:`Escape Character <escape-character>`
  • :ref:`Escape Data <escape-data>`
  • :ref:`Escape Sequences <escape-sequence>`
  • :ref:`Eval() <eval>`
  • :ref:`Event Driven <event-driven>`
  • :ref:`Event Loop <event-loop>`
  • :ref:`Event Sourcing <event-sourcing>`
  • :ref:`Event Storming <event-storming>`
  • :ref:`Exception <exception>`
  • :ref:`Exception Handler <exception-handler>`
  • :ref:`Execution Path <execution-path>`
  • :ref:`Execution Time <execution-time>`
  • :ref:`Exit <exit>`
  • :ref:`Explicit <explicit>`
  • :ref:`Explicit Boolean Comparison <explicit-boolean-comparison>`
  • :ref:`Exponent <exponent>`
  • :ref:`Exponential <exponential>`
  • :ref:`Expression <expression>`
  • :ref:`Expressive Interface <expressive-interface>`
  • :ref:`Extensible Markup Language (XML) <xml>`
  • :ref:`Extensions <extension>`
  • :ref:`each <each>`
  • :ref:`exec <exec>`
  • :ref:`explode() <explode>`
  • :ref:`expose_php <expose_php>`
  • :ref:`extends <extends>`
  • :ref:`extract() <extract>`

• F

  • :ref:`Facade <facade>`
  • :ref:`Factory <factory>`
  • :ref:`Faker <faker>`
  • :ref:`Fallback Function <fallback-function>`
  • :ref:`Fallback To Global <fallback-to-global>`
  • :ref:`False <false>`
  • :ref:`Falsy <falsy>`
  • :ref:`FastCGI <fastcgi>`
  • :ref:`FastCGI Process Manager (FPM) <fpm>`
  • :ref:`Fatal Error <fatal-error>`
  • :ref:`Feature <feature>`
  • :ref:`Feature Flag <feature-flag>`
  • :ref:`Feature Testing <feature-testing>`
  • :ref:`Fibers <fibers>`
  • :ref:`File <file>`
  • :ref:`File Extension <file-extension>`
  • :ref:`File Mode <file-mode>`
  • :ref:`File System <filesystem>`
  • :ref:`File Transfer Protocol (FTP) <ftp>`
  • :ref:`File Transfer Protocol Secure (FTPS) <ftps>`
  • :ref:`File Upload <upload>`
  • :ref:`FileSystemIterator <filesystemiterator>`
  • :ref:`Final Class Constants <final-class-constant>`
  • :ref:`Final Keyword <final>`
  • :ref:`Finally <finally>`
  • :ref:`Finite State Machine <finite-state-machine>`
  • :ref:`First Class Callable <first-class-callable>`
  • :ref:`First In, First Out (FIFO) <fifo>`
  • :ref:`Fixture <fixture>`
  • :ref:`Flag <flag>`
  • :ref:`Flame Graph <flamegraph>`
  • :ref:`Floating Point Numbers <float>`
  • :ref:`Fluent Interface <fluent-interface>`
  • :ref:`Folklore <folklore>`
  • :ref:`For <for>`
  • :ref:`Foreign Function Interface (FFI) <ffi>`
  • :ref:`Form <form>`
  • :ref:`Format <format>`
  • :ref:`Forum <forum>`
  • :ref:`Forward Compatible <forward-compatible>`
  • :ref:`Fossilized Methods <fossilized-method>`
  • :ref:`Framework <framework>`
  • :ref:`Framework Interoperability Group (FIG) <php-fig>`
  • :ref:`Front-end <frontend>`
  • :ref:`Fully Qualified Name <fully-qualified-name>`
  • :ref:`Function Subscripting <function-subscripting>`
  • :ref:`Functional Programming <functional-programming>`
  • :ref:`Functions <function>`
  • :ref:`Functor <functor>`
  • :ref:`Fuzzing <fuzzing>`
  • :ref:`file:// <wrapper-file>`
  • :ref:`file_get_contents() <file_get_contents>`
  • :ref:`file_put_contents() <file_put_contents>`
  • :ref:`filter <filter>`
  • :ref:`fnmatch() <fnmatch>`
  • :ref:`foreach() <foreach>`
  • :ref:`ftp:// <wrapper-ftp>`
  • :ref:`func_get_args() <func_get_args>`

• G

  • :ref:`GNU Multiple Precision (GMP) <gmp>`
  • :ref:`Garbage Collection <garbage-collection>`
  • :ref:`Generator <generator>`
  • :ref:`Generics <generics>`
  • :ref:`Global Code <global-code>`
  • :ref:`Global Space <global-space>`
  • :ref:`Global Variables <global-variable>`
  • :ref:`Glue <glue>`
  • :ref:`God Object <god-object>`
  • :ref:`Golf <golf>`
  • :ref:`Goto <goto>`
  • :ref:`Goto Labels <label>`
  • :ref:`Gradual Type Checking <gradual-type-checking>`
  • :ref:`GraphQL <graphql>`
  • :ref:`Graphic Draw (GD) <gd>`
  • :ref:`gRPC (Google Remote Procedure Call) <grpc>`
  • :ref:`get_class() <get_class>`
  • :ref:`get_object_vars() <get_object_vars>`
  • :ref:`gettext Extension <gettext>`
  • :ref:`git <git>`
  • :ref:`glob() <glob>`
  • :ref:`global Scope <global>`

• H

  • :ref:`HTML Entities <html-entities>`
  • :ref:`HTML Entity <html-entity>`
  • :ref:`HTML Escaping <escape-html>`
  • :ref:`HTTP Code <http-code>`
  • :ref:`HTTP Encoding <http-encoding>`
  • :ref:`HTTP Headers <http-header>`
  • :ref:`Handle <handle>`
  • :ref:`Hard Coded <hard-coded>`
  • :ref:`Hardening <hardening>`
  • :ref:`Hash <hash>`
  • :ref:`Hash # <hash-character>`
  • :ref:`Hash Comparisons <hash-comparison>`
  • :ref:`Haystack <haystack>`
  • :ref:`Headless <headless>`
  • :ref:`Heredocs <heredoc>`
  • :ref:`Heuristics <heuristic>`
  • :ref:`Hexadecimal Integer <hexadecimal-integer>`
  • :ref:`Hexagonal Architecture <hexagonal>`
  • :ref:`Honey Pot <honeypot>`
  • :ref:`Hosting <hosting>`
  • :ref:`Hydratation <hydrate>`
  • :ref:`Hyper Text Transfer Protocol (HTTP) <http>`
  • :ref:`Hyper Text Transfer Protocol Secure (HTTPS) <https>`
  • :ref:`HyperText Markup Language (HTML) <html>`
  • :ref:`hash() Function <hash-function>`
  • :ref:`hg <hg>`
  • :ref:`hrtime() <hrtime>`
  • :ref:`html_errors <html_errors>`
  • :ref:`http:// <wrapper-http>`
  • :ref:`http_build_query() <http_build_query>`

• I

  • :ref:`INF <inf>`
  • :ref:`INI <ini>`
  • :ref:`Iconv <iconv>`
  • :ref:`Idempotent <idempotent>`
  • :ref:`Identical Operator <identical>`
  • :ref:`Identification <identification>`
  • :ref:`Identifier <identifier>`
  • :ref:`Identity Comparison <identity-comparison>`
  • :ref:`If Then Else <if-then>`
  • :ref:`Iffectation <iffectation>`
  • :ref:`Image <image>`
  • :ref:`ImagickException <imagickexception>`
  • :ref:`ImagickPixelException <imagickpixelexception>`
  • :ref:`Immutable <immutable>`
  • :ref:`Imperative Programming <imperative>`
  • :ref:`Implicit <implicit>`
  • :ref:`Import <import>`
  • :ref:`Inclusions <inclusion>`
  • :ref:`Incoming Data <incoming-data>`
  • :ref:`Increment <increment>`
  • :ref:`Indentation <indentation>`
  • :ref:`Index <index>`
  • :ref:`Index For Arrays <index-array>`
  • :ref:`Index For SQL <index-sql>`
  • :ref:`Indexed Array <indexed-array>`
  • :ref:`Inequality <inequality>`
  • :ref:`Infinite <infinite>`
  • :ref:`Infinite Loop <infinite-loop>`
  • :ref:`InfiniteIterator <infiniteiterator>`
  • :ref:`Inflector <inflector>`
  • :ref:`Inheritance <inheritance>`
  • :ref:`Inherited Variable <inherited-variable>`
  • :ref:`Initialisation <initialisation>`
  • :ref:`Injection <injection>`
  • :ref:`Inlining <inlining>`
  • :ref:`Insteadof <insteadof>`
  • :ref:`Interface <interface>`
  • :ref:`Interface Segregation Principle (ISP) <isp>`
  • :ref:`Internals <internals>`
  • :ref:`Internationalization <internationalization>`
  • :ref:`Internationalization Functions <intl>`
  • :ref:`Internet Protocol (IP) <ip>`
  • :ref:`Interpolation <interpolation>`
  • :ref:`Intersection Type <intersection-type>`
  • :ref:`InvalidArgumentException <invalidargumentexception>`
  • :ref:`Invoke <invoke>`
  • :ref:`Isset <isset>`
  • :ref:`Iterable <iterable>`
  • :ref:`Iterator <iterator>`
  • :ref:`IteratorAggregate <iteratoraggregate>`
  • :ref:`imagick <imagick>`
  • :ref:`implements <implements>`
  • :ref:`implode() <implode>`
  • :ref:`in_array() <in_array>`
  • :ref:`include <include>`
  • :ref:`include_path <include_path>`
  • :ref:`ini_set() <ini_set>`
  • :ref:`instance <instance>`
  • :ref:`instanceof <instanceof>`
  • :ref:`integer <integer>`
  • :ref:`is_a() <is_a>`
  • :ref:`is_object() <is_object>`
  • :ref:`iterator_to_array() <iterator_to_array>`

• J

  • :ref:`JSON Lines (JSONC) <jsonc>`
  • :ref:`JSON Lines (JSONL) <jsonl>`
  • :ref:`JavaScript Object Notation (JSON) <json>`
  • :ref:`Javascript <javascript>`
  • :ref:`Jobqueue <jobqueue>`
  • :ref:`JsonException <jsonexception>`
  • :ref:`JsonSerializable <jsonserializable>`
  • :ref:`Jump <jump>`
  • :ref:`Just In Time (JIT) <jit>`
  • :ref:`json_decode() <json_decode>`
  • :ref:`json_encode() <json_encode>`

• K

  • :ref:`KISS <kiss>`
  • :ref:`Key-value Stores <key-value-store>`
  • :ref:`Keyword <keyword>`

• L

  • :ref:`Language Construct <language-construct>`
  • :ref:`Laravel <laravel>`
  • :ref:`Large Language Model (LLM) <llm>`
  • :ref:`Last In, First Out (LIFO) <lifo>`
  • :ref:`Late Static Binding <late-static-binding>`
  • :ref:`Latin1 <latin1>`
  • :ref:`Lazy Loading <lazy-loading>`
  • :ref:`Lazy Objects <lazy-objects>`
  • :ref:`Leading Numeric String <leading-numeric-string>`
  • :ref:`Leading Zero Means Octal <leading-zero-means-octal>`
  • :ref:`Leak <leak>`
  • :ref:`LengthException <lengthexception>`
  • :ref:`Letter Logical Bug <letter-logical>`
  • :ref:`Lexical Variable <lexical>`
  • :ref:`Library Loading <library-loading>`
  • :ref:`Licence <licence>`
  • :ref:`Lifecycle <lifecycle>`
  • :ref:`Line Feed <line-feed>`
  • :ref:`Lint, Won't Execute <lint-wont-execute>`
  • :ref:`Linting <linting>`
  • :ref:`Linux Apache Mysql PHP (LAMP) <lamp>`
  • :ref:`Liskov Substitution Principle (LSP) <lsp>`
  • :ref:`List <list>`
  • :ref:`Literal <literal>`
  • :ref:`Literal Types <literal-types>`
  • :ref:`Local File Inclusion <local-file-inclusion>`
  • :ref:`Local Scope <local>`
  • :ref:`Local Variable <local-variable>`
  • :ref:`Locale <locale>`
  • :ref:`Lock <lock>`
  • :ref:`Log <log>`
  • :ref:`LogicException <logicexception>`
  • :ref:`Logical Operators <logical-operator>`
  • :ref:`Loops <loop>`
  • :ref:`libsodium <libsodium>`

• M

  • :ref:`Machine Learning <machine-learning>`
  • :ref:`Magic <magic>`
  • :ref:`Magic Bytes <magic-byte>`
  • :ref:`Magic Code <magic-in-the-code>`
  • :ref:`Magic Constants <magic-constant>`
  • :ref:`Magic Hash <magic-hash>`
  • :ref:`Magic Methods <magic-method>`
  • :ref:`Magic Numbers <magic-number>`
  • :ref:`Magic Property <magic-property>`
  • :ref:`Mail <mail>`
  • :ref:`Maintenability <maintenability>`
  • :ref:`Maintenance <maintenance>`
  • :ref:`Man In The Middle <man-in-the-middle>`
  • :ref:`Map <map>`
  • :ref:`Markdown <markdown>`
  • :ref:`Marketplace <marketplace>`
  • :ref:`Match <match>`
  • :ref:`Math <math>`
  • :ref:`Memoization <memoization>`
  • :ref:`Memory <memory>`
  • :ref:`Memory Leak <memory-leak>`
  • :ref:`Merge <merge>`
  • :ref:`Message Digest Algorithm 5 (MD5) <md5>`
  • :ref:`Message Queue <message-queue>`
  • :ref:`Method <method>`
  • :ref:`Method Collision <method-collision>`
  • :ref:`Method Compatibility <method-compatibility>`
  • :ref:`Method Overloading <method-overloading>`
  • :ref:`Method Signature <signature>`
  • :ref:`Methodcall <methodcall>`
  • :ref:`Metrics <metrics>`
  • :ref:`Micro-framework <microframework>`
  • :ref:`Micro-optimisation <micro-optimisation>`
  • :ref:`Micro-second <micro-second>`
  • :ref:`Microservice <microservice>`
  • :ref:`Middleware Pattern <middleware>`
  • :ref:`Migration <migration>`
  • :ref:`Minification <minification>`
  • :ref:`Minimum Viable Product (MVP) <mvp>`
  • :ref:`Minus - <minus>`
  • :ref:`Minus One -1 <minus-one>`
  • :ref:`Missing Validation <missing-validation>`
  • :ref:`Mixed <mixed>`
  • :ref:`Mock <mock>`
  • :ref:`Model <model>`
  • :ref:`Model - View - Controller (MVC) <mvc>`
  • :ref:`Model Context Protocol (MCP) <mcp>`
  • :ref:`Module <module>`
  • :ref:`Modulo <modulo>`
  • :ref:`Monitoring <monitoring>`
  • :ref:`Monolith <monolith>`
  • :ref:`Multi-byte <multi-byte>`
  • :ref:`Multibyte String <mbstring>`
  • :ref:`Multidimensional Array <multidimensional-array>`
  • :ref:`Multiplication <multiplication>`
  • :ref:`Multithreading <multithreading>`
  • :ref:`Multiton <multiton>`
  • :ref:`Mutation Testing <mutation-test>`
  • :ref:`MySQL <mysql>`
  • :ref:`max_execution_time <max_execution_time>`
  • :ref:`mcrypt Extension <mcrypt>`
  • :ref:`memory_limit <memory_limit>`
  • :ref:`microtime() <microtime>`
  • :ref:`mysqli <mysqli>`
  • :ref:`mysqli_sql_exception <mysqli_sql_exception>`

• N

  • :ref:`N+1 Query Problem <n-query>`
  • :ref:`Name <name>`
  • :ref:`Named Constructors <named-constructor>`
  • :ref:`Named Parameters <named-parameter>`
  • :ref:`Named Type <named-type>`
  • :ref:`Namespace Alias <namespace-alias>`
  • :ref:`Namespace Name <namespace-name>`
  • :ref:`Namespaced Name <namespaced-name>`
  • :ref:`Namespaces <namespace>`
  • :ref:`Naming <naming>`
  • :ref:`Naming Conflict <naming-conflict>`
  • :ref:`Native <native>`
  • :ref:`Needle <needle>`
  • :ref:`Nested Attributes <nested-attribute>`
  • :ref:`Nesting <nesting>`
  • :ref:`Neutral Element <neutral-element>`
  • :ref:`Never Type <never>`
  • :ref:`New In Initializers <new-in-initializer>`
  • :ref:`New Line <new-line>`
  • :ref:`New Without Parenthesis <new-without-parenthesis>`
  • :ref:`NoDiscard <nodiscard>`
  • :ref:`Non Breakable Spaces <non-breakable-space>`
  • :ref:`Non-instantiable <non-instantiable>`
  • :ref:`Non-numeric <non-numeric>`
  • :ref:`Non-static <non-static>`
  • :ref:`Nonce <nonce>`
  • :ref:`Noop <noop>`
  • :ref:`Nosql Database <nosql-database>`
  • :ref:`Not A Number (NAN) <nan>`
  • :ref:`Not Operator <not>`
  • :ref:`Notice <notice>`
  • :ref:`Nowdocs <nowdoc>`
  • :ref:`Null <null>`
  • :ref:`Null Byte <null-byte>`
  • :ref:`Null Pattern <nullpattern>`
  • :ref:`Null Safe Object Operator <nullsafe-object-operator>`
  • :ref:`Nullable <nullable>`
  • :ref:`Nullsafe <nullsafe>`
  • :ref:`Number <number>`
  • :ref:`Numeric Base <numeric-base>`
  • :ref:`Numeric Separator <numeric-separator>`
  • :ref:`Numeric String <numeric-string>`
  • :ref:`negative-index <negative-index>`
  • :ref:`new <new>`

• O

  • :ref:`OOP (Object Oriented Programming) <oop>`
  • :ref:`OWASP <owasp>`
  • :ref:`Obfuscation <obfuscation>`
  • :ref:`Object <object>`
  • :ref:`Object API <object-api>`
  • :ref:`Object Injection <object-injection>`
  • :ref:`Object Invasion <object-invasion>`
  • :ref:`Object Nullsafe Operator ?-> <object-nullsafe-operator>`
  • :ref:`Object Operator -> <object-operator>`
  • :ref:`Object Persistence <object-persistence>`
  • :ref:`Object Relational Mapping (ORM) <orm>`
  • :ref:`Object Syntax <object-syntax>`
  • :ref:`Object Type <object-type>`
  • :ref:`Oblic Quotes <oblic-quote>`
  • :ref:`Observer Design Pattern <observer>`
  • :ref:`Octal Integer <octal-integer>`
  • :ref:`Offensive Programming <offensive-programming>`
  • :ref:`Offset <offset>`
  • :ref:`One Liner <one-liner>`
  • :ref:`Onion Architecture <onion-architecture>`
  • :ref:`Opcache <opcache>`
  • :ref:`Opcode <opcode>`
  • :ref:`Opcode Specialisation <opcode-specialization>`
  • :ref:`Open Closed Principle (OCP) <ocp>`
  • :ref:`Open Source <open-source>`
  • :ref:`Open Tag <open-tag>`
  • :ref:`OpenSSL <openssl>`
  • :ref:`Operand <operand>`
  • :ref:`Operator Overloading <operator-overloading>`
  • :ref:`Operator Precedence <operator-precedence>`
  • :ref:`Operators <operator>`
  • :ref:`Optimisation <optimisation>`
  • :ref:`Optional Parameter <optional-parameter>`
  • :ref:`OutOfRangeException <outofrangeexception>`
  • :ref:`Outgoing Data <outgoing-data>`
  • :ref:`Over-engineer <overengineer>`
  • :ref:`Overflow <overflow>`
  • :ref:`OverflowException <overflowexception>`
  • :ref:`Overloading <overloading>`
  • :ref:`Override Attribute <override>`
  • :ref:`Overriding <overriding>`
  • :ref:`Overwrite <overwrite>`
  • :ref:`one <one>`
  • :ref:`open_basedir <open_basedir>`

• P

  • :ref:`PDOException <pdoexception>`
  • :ref:`PEAR <pear>`
  • :ref:`PHP Constants <php-constant>`
  • :ref:`PHP Data Objects (PDO) <pdo>`
  • :ref:`PHP Docker Container <php-docker-container>`
  • :ref:`PHP Engine <php-engine>`
  • :ref:`PHP Extension C Library (PECL) <pecl>`
  • :ref:`PHP Extensions <php-extension>`
  • :ref:`PHP Foundation <php-foundation>`
  • :ref:`PHP Group <php-group>`
  • :ref:`PHP Handlers <handler>`
  • :ref:`PHP Installer For Extensions (PIE) <pie>`
  • :ref:`PHP Native Attribute <php-native-attribute>`
  • :ref:`PHP Native Attributes <php-attribute>`
  • :ref:`PHP Native Interfaces <php-interface>`
  • :ref:`PHP Natives <native-type>`
  • :ref:`PHP Predefined Exception <predefined-exception>`
  • :ref:`PHP Profiler <profiler>`
  • :ref:`PHP RFC <php-rfc>`
  • :ref:`PHP Standards Recommendations (PSR) <psr>`
  • :ref:`PHP Tags <php-tag>`
  • :ref:`PHP User Groups <php-ug>`
  • :ref:`PHP Variables <php-variable>`
  • :ref:`PHP Wrappers <php-wrapper>`
  • :ref:`PHP, Hypertext Preprocessor (PHP) <php>`
  • :ref:`PHP_INT_MAX <php_int_max>`
  • :ref:`PHP_INT_MIN <php_int_min>`
  • :ref:`PHPdoc <phpdoc>`
  • :ref:`PHPunit <phpunit>`
  • :ref:`Packagist <packagist>`
  • :ref:`Pagination <pagination>`
  • :ref:`Paradigm <paradigm>`
  • :ref:`Parallel <parallel>`
  • :ref:`Parameter <parameter>`
  • :ref:`Parameter Removal <parameter-removal>`
  • :ref:`Parenthesis <parenthesis>`
  • :ref:`Parquet <parquet>`
  • :ref:`Parse <parse>`
  • :ref:`ParseError <parseerror>`
  • :ref:`Parser <parser>`
  • :ref:`Partial Function <partial-function>`
  • :ref:`Pascal Case <pascal-case>`
  • :ref:`Passing By Reference <by-reference>`
  • :ref:`Passing By Value <by-value>`
  • :ref:`Passphrase <passphrase>`
  • :ref:`Password <password>`
  • :ref:`Password API <password-ext>`
  • :ref:`Path <path>`
  • :ref:`Path Traversal <path-traversal>`
  • :ref:`Pattern Matching <pattern-matching>`
  • :ref:`Performance <performance>`
  • :ref:`Perl Compatible Regular Expressions (PCRE) <pcre>`
  • :ref:`Permission <permission>`
  • :ref:`Persistence <persistence>`
  • :ref:`Phar <phar>`
  • :ref:`PharException <pharexception>`
  • :ref:`Pipe Operator <pipe>`
  • :ref:`Pipeline <pipeline>`
  • :ref:`Plugin <plugin>`
  • :ref:`Plus + <plus>`
  • :ref:`Pointer <pointer>`
  • :ref:`Polyfill <polyfill>`
  • :ref:`Polymorphism <polymorphism>`
  • :ref:`Port <port>`
  • :ref:`Portability <portability>`
  • :ref:`Positional Parameters <positional-parameter>`
  • :ref:`Positive Integer <positive-integer>`
  • :ref:`Post-increment <post-increment>`
  • :ref:`PostgreSQL <pgsql>`
  • :ref:`Pre-increment <pre-increment>`
  • :ref:`Preappend File Directive <auto_prepend_file>`
  • :ref:`Precedence <precedence>`
  • :ref:`Predefined Constants <predefined-constant>`
  • :ref:`Prefix <prefix>`
  • :ref:`Preg_match <preg_match>`
  • :ref:`Prepared Query <prepared-query>`
  • :ref:`Preprocessing <preprocess>`
  • :ref:`Primitive Obsession <primitive-obsession>`
  • :ref:`Print <print>`
  • :ref:`Private Visibility <private>`
  • :ref:`Procedural Programming <procedural-programming>`
  • :ref:`Process <process>`
  • :ref:`Process Control (pcntl) <pcntl>`
  • :ref:`Product Requirements Document (PDR) <pdr>`
  • :ref:`Production <production>`
  • :ref:`Promise <promise>`
  • :ref:`Promoted Properties <promoted-property>`
  • :ref:`Propagation <propagation>`
  • :ref:`Properties <property>`
  • :ref:`Property Hook <property-hook>`
  • :ref:`Property Type Declaration <type-declaration-property>`
  • :ref:`Protected Visibility <protected>`
  • :ref:`Protocol <protocol>`
  • :ref:`Pseudo-type <pseudo-type>`
  • :ref:`Pseudo-variable <pseudo-variable>`
  • :ref:`Public Visibility <public>`
  • :ref:`Pull Request (PR) <pr>`
  • :ref:`Pure Function <pure-function>`
  • :ref:`pack <pack>`
  • :ref:`parent <parent>`
  • :ref:`parse_str() <parse_str>`
  • :ref:`php.ini <php.ini>`
  • :ref:`php:// <wrapper-php>`
  • :ref:`php://input <php-input>`
  • :ref:`php://memory <php-memory>`
  • :ref:`php://output <php-output>`
  • :ref:`phpinfo() <phpinfo>`
  • :ref:`precision <precision>`
  • :ref:`preg_split() <preg_split>`
  • :ref:`print_r() <print_r>`
  • :ref:`printf() <printf>`

• Q

  • :ref:`Quality <quality>`
  • :ref:`Query <query>`
  • :ref:`Query String <query-string>`
  • :ref:`Question Mark ? <question-mark>`
  • :ref:`Queue <queue>`
  • :ref:`Quine <quine>`
  • :ref:`Quoted Printable <quoted-printable>`

• R

  • :ref:`REST API <rest-api>`
  • :ref:`RFC <rfc>`
  • :ref:`RSA <rsa>`
  • :ref:`Railroad Programming <railroad-programming>`
  • :ref:`Random <random>`
  • :ref:`RangeException <rangeexception>`
  • :ref:`Read Eval Print Loop (REPL) <repl>`
  • :ref:`Readability <readability>`
  • :ref:`Readable <readable>`
  • :ref:`Reading <reading>`
  • :ref:`Readline <readline>`
  • :ref:`Readonly <readonly>`
  • :ref:`Real Numbers <real>`
  • :ref:`Real Time <real-time>`
  • :ref:`Recursion <recursion>`
  • :ref:`Recursive Array <recursive-array>`
  • :ref:`RecursiveIterator <recursiveiterator>`
  • :ref:`RecursiveTreeIterator <recursivetreeiterator>`
  • :ref:`Refactoring <refactoring>`
  • :ref:`Reference Count <reference-count>`
  • :ref:`References <reference>`
  • :ref:`Reflection <reflection>`
  • :ref:`ReflectionException <reflectionexception>`
  • :ref:`Regexploit <regexploit>`
  • :ref:`Register Globals <register-globals>`
  • :ref:`Registry <registry>`
  • :ref:`Regular Expressions <regex>`
  • :ref:`Relational DataBase Management System (RDBMS) <rdbms>`
  • :ref:`Relative <relative>`
  • :ref:`Relative Name <relative-name>`
  • :ref:`Relative Types <relative-types>`
  • :ref:`Relaxed Comparison <relaxed-comparison>`
  • :ref:`Relaxed Keywords <relaxed-keywords>`
  • :ref:`Relaxed Syntax <relaxed-syntax>`
  • :ref:`Relay Function <relay-function>`
  • :ref:`Release <release>`
  • :ref:`Remote Code Execution (RCE) <rce>`
  • :ref:`Remote Procedure Call (RPC) <rpc>`
  • :ref:`Render <render>`
  • :ref:`Renderer <renderer>`
  • :ref:`Request For Change (RFC) <rfchange>`
  • :ref:`Reserved For Future Use (RFU) <rfu>`
  • :ref:`Reserved Names <reserved-name>`
  • :ref:`Retrieval Augmented Generation (RAG) <rag>`
  • :ref:`Return <return>`
  • :ref:`Return Carriage <return-carriage>`
  • :ref:`Return Type <return-type>`
  • :ref:`Return Type Will Change <returntypewillchange>`
  • :ref:`Return Value <return-value>`
  • :ref:`Revision <revision>`
  • :ref:`Role Based Access Control (RBAC) <rbac>`
  • :ref:`Rounding <rounding>`
  • :ref:`Route <route>`
  • :ref:`Rubber Ducking Debugging <rubber-ducking>`
  • :ref:`Runtime Checks <runtime-checks>`
  • :ref:`range() <range>`
  • :ref:`register_argc_argv <register_argc_argv>`
  • :ref:`resource <resource>`

• S

  • :ref:`SNMP3 <snmp3>`
  • :ref:`SOLID <solid>`
  • :ref:`SQL Database <sql-database>`
  • :ref:`SQL Injection <sql-injection>`
  • :ref:`SQL Views <view-sql>`
  • :ref:`STDOUT <stdout>`
  • :ref:`SVMException <svmexception>`
  • :ref:`SVN <svn>`
  • :ref:`Sandbox <sandbox>`
  • :ref:`Sanitation <sanitation>`
  • :ref:`Scaffolding <scaffolding>`
  • :ref:`Scalar Types <scalar-type>`
  • :ref:`Scaling <scaling>`
  • :ref:`Schema <schema>`
  • :ref:`Scheme <scheme>`
  • :ref:`Scope <scope>`
  • :ref:`Scope Resolution Operator :: <scope-resolution-operator>`
  • :ref:`Second Order SQL Injection <second-order-sql-injection>`
  • :ref:`Secret <secret>`
  • :ref:`Secure Hash Algorithm (SHA) <sha>`
  • :ref:`Secure Sockets Layer (SSL) <ssl>`
  • :ref:`Security <security>`
  • :ref:`Segmentation Fault <segmentation-fault>`
  • :ref:`Self <self>`
  • :ref:`Self-documenting <self-documenting>`
  • :ref:`Self-reference <self-reference>`
  • :ref:`Semantic Versioning <semantic-versioning>`
  • :ref:`Semantics <semantics>`
  • :ref:`Semicolon <semicolon>`
  • :ref:`Sensitive Parameter <sensitiveparameter>`
  • :ref:`Separator <separator>`
  • :ref:`Serde <serde>`
  • :ref:`Serializable <serializable>`
  • :ref:`Serialization <serialization>`
  • :ref:`Server Application Programming Interface (SAPI) <sapi>`
  • :ref:`Server Architecture <server-architecture>`
  • :ref:`Server Sent Event (SSE) <sse>`
  • :ref:`Service <service>`
  • :ref:`Service Container <service-container>`
  • :ref:`Session <session>`
  • :ref:`Session Fixation <session-fixation>`
  • :ref:`Session Hijacking <session-highjacking>`
  • :ref:`Shallow Clone <shallow-clone>`
  • :ref:`Shard <shard>`
  • :ref:`Shared Memory <shared-memory>`
  • :ref:`Shell <shell>`
  • :ref:`Short Assignations <short-assignation>`
  • :ref:`Short Syntax <short-syntax>`
  • :ref:`Short Tags <short-tag>`
  • :ref:`Short Ternary Operator <short-ternary>`
  • :ref:`Shutdown Function <shutdown-function>`
  • :ref:`Side Effect <side-effect>`
  • :ref:`Sign <sign>`
  • :ref:`Silent Behavior <silent>`
  • :ref:`Simple Mail Transfer Protocol (SMTP) <smtp>`
  • :ref:`Simple Network Management Protocol (SNMP) <snmp>`
  • :ref:`Simple Object Access Protocol (SOAP) <soap>`
  • :ref:`Simple Query Language (SQL) <sql>`
  • :ref:`Simple Switch <simple-switch>`
  • :ref:`SimpleXML <simplexml>`
  • :ref:`Single Page Application (SPA) <spa>`
  • :ref:`Single Quotes Strings <single-quote>`
  • :ref:`Single Responsability Principle (SRP) <srp>`
  • :ref:`Single Sign On (SSO) <sso>`
  • :ref:`Singleton <singleton>`
  • :ref:`Slash / <slash>`
  • :ref:`Snake Case <snake-case>`
  • :ref:`Socket <socket>`
  • :ref:`Software Bill Of Material (SBOM) <sbom>`
  • :ref:`Software Development Kit (SDK) <sdk>`
  • :ref:`Software Development Life Cycle (SDLC) <sdlc>`
  • :ref:`Software-as-a-Service (SAAS) <saas>`
  • :ref:`Sort <sort>`
  • :ref:`Space <space>`
  • :ref:`Spaceship Operator <spaceship>`
  • :ref:`Special Constant <special-constant>`
  • :ref:`Special Types <special-typehint>`
  • :ref:`SplDoublyLinkedList <spldoublylinkedlist>`
  • :ref:`SplStack <splstack>`
  • :ref:`SplStorageObjects <splstorageobjects>`
  • :ref:`Sqlite3 <sqlite3>`
  • :ref:`Square Brackets <square-bracket>`
  • :ref:`Stack <stack>`
  • :ref:`Standalone Types <standalone-type>`
  • :ref:`Standard PHP Library (SPL) <spl>`
  • :ref:`Star * <star>`
  • :ref:`State <state>`
  • :ref:`Stateful <stateful>`
  • :ref:`Stateless <stateless>`
  • :ref:`Statement <statement>`
  • :ref:`Static Application Security Testing (SAST) <sast>`
  • :ref:`Static Call <static-call>`
  • :ref:`Static Code Analysis (SCA) <sca>`
  • :ref:`Static Constant <class-constant>`
  • :ref:`Static Expression <static-expression>`
  • :ref:`Static Method <static-method>`
  • :ref:`Static Property <static-property>`
  • :ref:`Static Single Assignment Form (SSA) <ssa>`
  • :ref:`Static Variables <static-variable>`
  • :ref:`Stealth Generator <stealth-generator>`
  • :ref:`Storage Systems <storage-system>`
  • :ref:`Stream <stream>`
  • :ref:`Stream Wrapper <wrapper-stream>`
  • :ref:`Strict Comparison <strict-comparison>`
  • :ref:`String <string>`
  • :ref:`String Increment <string-increment>`
  • :ref:`String Interpolation <string-interpolation>`
  • :ref:`Stringable <stringable>`
  • :ref:`Strpos() Syndrome <strpos-syndrom>`
  • :ref:`Structure <structure>`
  • :ref:`Stubs Files <stubs>`
  • :ref:`Sub (prefix) <sub>`
  • :ref:`Subclass <subclass>`
  • :ref:`Subnamespaces <subnamespace>`
  • :ref:`Suffix <suffix>`
  • :ref:`Sunsetting <sunsetting>`
  • :ref:`Superglobal Variables <superglobal>`
  • :ref:`Supply Chain <supply-chain>`
  • :ref:`Supply Chain Attack <supply-chain-attack>`
  • :ref:`Support Vector Machine (SVM) <svm>`
  • :ref:`Swap <swap>`
  • :ref:`Switch <switch>`
  • :ref:`Switch Case <switch-case>`
  • :ref:`Switch Default <switch-default>`
  • :ref:`Switch Fallthrough <fallthrough>`
  • :ref:`Synchronous <synchronous>`
  • :ref:`Syntax <syntax>`
  • :ref:`Syntax Error <syntax-error>`
  • :ref:`System <system>`
  • :ref:`System Call <system-call>`
  • :ref:`System Event <system-event>`
  • :ref:`set_error_handler() <set_error_handler>`
  • :ref:`shell_exec() <shell_exec>`
  • :ref:`sleep <sleep>`
  • :ref:`sprintf <sprintf>`
  • :ref:`static <static>`
  • :ref:`stdclass <stdclass>`
  • :ref:`str_contains() <str_contains>`
  • :ref:`strict_types <strict_types>`
  • :ref:`strpos <strpos>`
  • :ref:`subtype <subtype>`
  • :ref:`supertype <supertype>`

• T

  • :ref:`TCP <tcp>`
  • :ref:`Tabulation <tabulation>`
  • :ref:`Taint Analysis <taint>`
  • :ref:`Tarpit <tarpit>`
  • :ref:`Task <task>`
  • :ref:`Task Runner <task-runner>`
  • :ref:`Technical Debt <debt>`
  • :ref:`Telemetry <telemetry>`
  • :ref:`Template <template>`
  • :ref:`Temporary Expression <temporary-expression>`
  • :ref:`Ternary Operator <ternary>`
  • :ref:`Test <test>`
  • :ref:`Test Data Provider <test-data-provider>`
  • :ref:`Test Pyramid <test-pyramid>`
  • :ref:`Text Encoding <encoding-text>`
  • :ref:`Thin Method <thin-method>`
  • :ref:`Thread <thread>`
  • :ref:`Three Dots <three-dots>`
  • :ref:`Throwable <throwable>`
  • :ref:`Tick <tick>`
  • :ref:`Time Of Check To Time Of Use (TOCTOU) <toctou>`
  • :ref:`Time Travel <time-travel>`
  • :ref:`To Crypt <crypt>`
  • :ref:`To Decrypt <decrypt>`
  • :ref:`Token <token>`
  • :ref:`Token Oriented Object Notation (TOON) <toon>`
  • :ref:`Tom's Obvious Minimal Language (TOML) <toml>`
  • :ref:`Total Cost Of Ownership (TCO) <tco>`
  • :ref:`Trailing Comma <trailing-comma>`
  • :ref:`Trait <trait>`
  • :ref:`Transpile <transpile>`
  • :ref:`Transport Layer Security (TLS) <tls>`
  • :ref:`Traversable <traversable>`
  • :ref:`Traversal <traversal>`
  • :ref:`Tree <tree>`
  • :ref:`Treemap <treemap>`
  • :ref:`Troubleshoot <troubleshoot>`
  • :ref:`True <true>`
  • :ref:`Truthy <truthy>`
  • :ref:`Try-catch <try-catch>`
  • :ref:`Tutorial <tutorial>`
  • :ref:`Type Coverage <type-coverage>`
  • :ref:`Type Error <typerror>`
  • :ref:`Type Invariant <invariant>`
  • :ref:`Type Juggling <type-juggling>`
  • :ref:`Type System <type>`
  • :ref:`TypeError <typeerror>`
  • :ref:`Typed Constant <typed-constant>`
  • :ref:`Typed Property <typed-property>`
  • :ref:`Typo <typo>`
  • :ref:`testdox <testdox>`
  • :ref:`throw <throw>`
  • :ref:`trigger_error() <trigger_error>`
  • :ref:`trim <trim>`

• U

  • :ref:`URI Class <uri-class>`
  • :ref:`URI Extension <uri-extension>`
  • :ref:`UTF-8 <utf-8>`
  • :ref:`UUencode Encoding <uuencode>`
  • :ref:`Unary Operator <unary>`
  • :ref:`Unbacked Enum <unbacked-enum>`
  • :ref:`Undefined <undefined>`
  • :ref:`Underflow <underflow>`
  • :ref:`Underscore <underscore>`
  • :ref:`UnexpectedValueException <unexpectedvalueexception>`
  • :ref:`UnhandledMatchError <unhandledmatcherror>`
  • :ref:`Unicode <unicode>`
  • :ref:`Uninitialized <uninitialized>`
  • :ref:`Union Type <union-type>`
  • :ref:`UnitEnum <unitenum>`
  • :ref:`Universal Resource Identifier (URI) <uri>`
  • :ref:`Universal Resource Locator (URL) <url>`
  • :ref:`Universally Unique IDentifier (UUID) <uuid>`
  • :ref:`Unpacking <unpacking>`
  • :ref:`Unreachable Code <unreachable-code>`
  • :ref:`Unserialization <unserialize>`
  • :ref:`Unused <unused>`
  • :ref:`Upgrade <upgrade>`
  • :ref:`Use <use>`
  • :ref:`Use Alias <use-alias>`
  • :ref:`Use In Traits <use-trait>`
  • :ref:`Used <used>`
  • :ref:`Useless <useless>`
  • :ref:`User Datagram Protocol (UDP) <udp>`
  • :ref:`User Operations For Zend (UOPZ) <uopz>`
  • :ref:`Userland <userland>`
  • :ref:`unset() <unset>`

• V

  • :ref:`VCS <vcs>`
  • :ref:`Validation <validation>`
  • :ref:`Value <value>`
  • :ref:`Value Object <value-object>`
  • :ref:`Value Object (VO) <vo>`
  • :ref:`ValueError <valueerror>`
  • :ref:`Var <var>`
  • :ref:`Variable Arguments <variable-argument>`
  • :ref:`Variable Scope <variable-scope>`
  • :ref:`Variable Shadowing <variable-shadowing>`
  • :ref:`Variable Variables <variable-variable>`
  • :ref:`Variables <variable>`
  • :ref:`Variadic <variadic>`
  • :ref:`Vector Database <vector-database>`
  • :ref:`Vendor Lock-in <vendor-lockin>`
  • :ref:`Version <version>`
  • :ref:`View <view>`
  • :ref:`View In Presentation <view-presentation>`
  • :ref:`Virtual Machine (VM) <virtual-machine>`
  • :ref:`Virtual Property <virtual-property>`
  • :ref:`Visibility <visibility>`
  • :ref:`Visual Debt <visual-debt>`
  • :ref:`Void <void>`
  • :ref:`Vulnerability <vulnerability>`
  • :ref:`var_dump() <var_dump>`
  • :ref:`variable_order <variable_order>`

• W

  • :ref:`Warning <warning>`
  • :ref:`Weak Cryptography <weak-cryptography>`
  • :ref:`Weak References <weak-reference>`
  • :ref:`Weakmap <weakmap>`
  • :ref:`Web-spider <web-spider>`
  • :ref:`WebRTC <webrtc>`
  • :ref:`Webscraping <webscraping>`
  • :ref:`Webserver <webserver>`
  • :ref:`Webshell <webshell>`
  • :ref:`Websocket <websocket>`
  • :ref:`While <while>`
  • :ref:`Whitespace <whitespace>`
  • :ref:`Wildcard <wildcard>`
  • :ref:`Word Combination <word-combinaison>`
  • :ref:`Workflow <workflow>`
  • :ref:`World Wide Web (WWW) <web>`
  • :ref:`Wrapper <wrapper>`
  • :ref:`Wrapper Pattern <wrapper-pattern>`
  • :ref:`Writable <writable>`
  • :ref:`Write Everything Twice (WET) <wet>`
  • :ref:`Writing <writing>`

• X

  • :ref:`XML Database <xml-database>`
  • :ref:`XMLReader <xmlreader>`
  • :ref:`XMLwriter <xmlwriter>`
  • :ref:`XXTEA <xxtea>`

• Y

  • :ref:`YAML Ain't Markup Language (YAML) <yaml>`
  • :ref:`Yield <yield>`
  • :ref:`Yoda Condition <yoda>`
  • :ref:`You Are Not Going To Need It (YAGNI) <yagni>`
  • :ref:`yield from Keyword <yield-from>`

• Z

  • :ref:`Zend Engine <zend-engine>`
  • :ref:`Zero Cost <zero-cost>`
  • :ref:`Zombie Code <zombie-code>`
  • :ref:`Zval <zval>`
  • :ref:`zend.assertions <zend-assertions>`
  • :ref:`zero <zero>`
  • :ref:`zip Extension <zip>`
  • :ref:`zlib extension <zlib>`

• ~

  • :ref:`~ Tilde <tilde>`