$GLOBALS
$HTTP_RAW_POST_DATA
$_COOKIE
$_ENV
$_FILES
$_GET
$_POST
$_REQUEST
$_SERVER
$argc
$argv
$http_response_header
$php_errormsg
$this
(void) Cast
. Directory
. File
.env File
.htaccess
@, No Scream Operator
__CLASS__
__FILE__
__FUNCTION__
__LINE__
__METHOD__
__TRAIT__
__autoload
__call() Method
__callStatic() Method
__clone() Method
__get() Method
__halt_compiler()
__invoke() Method
__isset() Method
__serialize() Method
__set() Method
__set_state() Method
__sleep() Method
__toString() Method
__unserialize() Method
__unset() Method
__wakeup() Method
AJAX
Absolute
Absolute Name
Absolute Value
Abstract Class
Abstract Factory
Abstract Keyword
Abstract Method
Abstract Syntactic Tree (AST)
Abstraction
Abstraction Layer
Access Control List (ACL)
Accessibility
Accountability
Active Record
Adapters
Addition
Agile
Ahead Of Time (OAT)
Algorithm
Algorithmic Complexity
Alias
Alias Types
Allow Dynamic Properties
Alternative Syntax
American Standard Code for Information Interchange (ASCII)
Analysis
Anchor
And Operator
Annotations
Anonymize
Anonymous
Anonymous Catch
Anonymous Class
Anonymous Constant
Anonymous Function
Appeasement Pattern
Application
Application Performance Management (APM)
Application Programming Interface (API)
Application Server
Arbitrary Number Of Argument
Arcane
Architectural Decision Record (ADR)
Architecture
Archive
Argon2
Argument
ArgumentCountError
ArithmeticError Error
Arm
Array
Array Append
Array Callback
Array Dot Notation
Array Element
Array Prepend
Array Spread
Array Syntax
Array With Curly Braces
ArrayAccess
ArrayObject
Arrow Functions
Artifact
Artificial Intelligence (AI)
As
Aspect Oriented Programming
Aspect-Oriented
Assertions
Asset
Assignations
Associative Array
Assumption
Asymmetric Cryptography
Asymmetric Property
Asymmetric Visibility
Async
Asynchronous
Atomic Operation
Attack
Attribute
Attribute Class
Audit
Audit Trail
Authentication
Authorize
Autocompletion
Automagic
Automatic Index
Autovivification
Autowiring
Availability
abs()
array_column
array_combine()
array_fill()
array_key_exists()
array_keys()
array_map()
array_merge()
array_pad()
array_pop()
array_push()
array_search
array_shift()
array_slice()
array_splice()
array_unique()
array_unshift()
array_values()
array_walk()
Back-tick
Backed
Backed Enum
Backed Property
BackedEnum
Backend
Backslash
Backtrace
Backward Compatible
Backward Incompatible
BadFunctioncallException
Balanced
Bang !
Base
Base 64 Encoding
Base Class
Batch
Bcmath
Benchmarking
Best Practices
Big-o-notation
Binary
Binary Integer
Binary Not Operator
Binary Operator
Bind
Bitfield
Bitmask
Bitshift Operators
Bitwise Operators
Blind Variable
Block
Blocking Wait
Bloom Filter
Body
Boilerplate
Boolean
Bootstrap
Bottleneck
Bracket
Bracketless
Branch
Breach
Break
Broken Object Level Authorization (BOLA)
Browser
Bucket
Bug
Business Logic
Byte
basename
browscap
bzip2 Extension
C2 Framework
CAPTCHA
CSS
CSV Injection
Cache
Calendar
Call
Call Graph
Callable Arrays
Callables
Callbacks
Callstack
Camel Case
Cancellation
Canonical
Carriage Return
Case
Case Sensitivity
Cast Operator
Catch
Centralization
Chaining
Chaining Exceptions
Chaining New Without Parenthesis
Character
Checksum
Child Class
Circuit Breaker
Circular Reference
Class
Class Aliases
Class Autoloading
Class Constant Syntax
Class Constants Visibility
Class Entities
Class Getter Method
Class Hierarchy
Class Hoisting
Class Interface Trait Enumeration (CITE)
Class Invasion
Class Operator
Class Setter Method
Class Wither Method
Clean Architecture
Clean Code
Client
Client URL (CURL)
Clock
Clone
Close Naming
Close Tag
Closed Source
ClosedGeneratorException
Closure
Closure Binding
Closure Class
Cloud
Coalesce Operator
Code Architecture
Code Coverage
Code Formatter
Code Freeze
Code Generator
Code Injection
Code Inventory
Code Reuse
Code Review
Code Smell
Codepoint
Coding Conventions
Coding Formatting
Cognitive Complexity
Cohesion
Collection
Collision
Colon
Column Database
Comma
Comma Secparated Values (CSV)
Command
Command Bus
Command Line Interface (CLI)
Command Query Responsibility Segregation (CQRS)
Comments
Commit
Common Gateway Interface (CGI)
Common Vulnerabilities And Exposures (CVE)
Community
Compact Array
Comparison
Compatibility
Compile
Compile Time
Complexity
Compliance
Component
Composer
Composition
Compression
Concatenation
Concatenative
Concrete Class
Concrete Method
Concurency
Concurent Version System (CVS)
Condition
Conditional
Conditional Structures
Conditioned Structures
Configuration
Connection
Connection Persistence
Consistency
Const
Constant Case
Constant Combination
Constant Expression
Constant Scalar Expression
Constants
Constants In Trait
Constructor
Container
Content Management System (CMS)
Continue
Continuous Delivery (CD)
Continuous Integration (CI)
Contravariance
Contribution
Control Flow
Control Flow Graph
Control Structures
Controller
Convention
Convert
Cookie
Copy On Write (COW)
Core
Coroutine
Countable Interface
Coupling
Covariance
Coverage
Crack
Create, Read, Update And Delete (CRUD)
Cron
Cross Site Request Forgery (CSRF)
Cross Site Scripting (XSS)
Cryptographic Hash
Cryptography
Ctype
Curly Brackets
Custom
Custom Function
Cyclic Redundancy Check 32-bit (CRC32)
Cyclomatic Complexity
class_alias()
class_implements()
compact()
constant()
count()
DIRECTORY_SEPARATOR
DOM
DOMChildNode
DOMParentNode
Dangling Reference
Data
Data Access Object (DAO)
Data Container
Data Leak
Data Mapper
Data Source Name (DSN)
Data Structure
Data Transfer Object (DTO)
Database
Database Abstraction Layer (DBA) Extension
Database Abstraction Layer (DBAL)
Database Commit
Dataset
Datastack
DateInterval
DateTime
DateTimeInterface
Dates
Datetime Trap
Days Are Not 86400 Seconds
Days In Month
Dead Code
Debug
Debugger
Declaration
Declarative Programming
Decode
Decorator Pattern
Decoupling
Deep Clone
Default
Default Parameter
Default Value
Defensive Programming
Definition
Delimiter
Dependency
Dependency Injection
Dependency Injection Container
Dependent Type
Deployment
Deprecated
Deprecation
Depth
Deque
Dereferencing
Design By Contract (DBC)
Design Pattern
Design Pattern Wrapper
Desktop Application
Destructor
Determinism
Deterministic
DevOps
Dictionary
Diff
Digital Signature
Dir
Direct Output
Directives
DirectoryIterator
Disable
Disable Classes
Disable Functions
Disjunctive Normal Form (DNF)
Distributed Denial Of Service (DDOS)
Distributed State
Division
DivisionByZeroError
Do While
Docblock
Docker
Docker Container
Docker Image
Document Database
Document Object Model (DOM)
Documentation
Dollar /
Domain
Domain Design Driven (DDD)
Domain Name
Domain Name System (DNS)
DomainException
Don’t Repeat Yourself (DRY)
Dot Notation
Dot-dot Directory ..
Double
Double Arrow
Double Check
Double Quotes Strings
Downtime
Drop-in
Duck Typing
Duplicate
Dynamic
Dynamic Call
Dynamic Class
Dynamic Class Constant
Dynamic Constant
Dynamic Expression
Dynamic Loading
Dynamic Method
Dynamic Properties
Dynamic Variable
debug_backtrace()
declare Encoding
declare()
default_charset
define()
defined()
delayedtargetvalidation
dirname
display_errors
E
Early Binding
Echo
Echo Tag
Ecosystem
Edge Case
Elephpant
Ellipsis
Email
Embed
Emoji
Empty
Empty String
Enable
Encapsulation
Encode
Encoding
End To End Test
Entities
Enumeration (enum)
Enumeration Case
Environment
Environment Variables
Eponymous
Equal Operator
Error
Error Handler
Error Handling
Error Reporting
Error Suppression
Escape Character
Escape Data
Escape Sequences
Eval()
Event Driven
Event Loop
Event Sourcing
Event Storming
Exception
Exception Handler
Execution
Execution Path
Execution Time
Existence
Exit
Explanation
Explicit
Explicit Boolean Comparison
Exponent
Exponential
Expression
Expressive Interface
Extensible Markup Language (XML)
Extensions
each
exec
explode()
expose_php
extends
extract()
Facade
Factory
Faker
Fallback
Fallback Function
Fallback To Global
False
Falsy
FastCGI
FastCGI Process Manager (FPM)
Fatal Error
Feature
Feature Flag
Feature Testing
Fibers
File
File Extension
File Mode
File System
File Transfer Protocol (FTP)
File Transfer Protocol Secure (FTPS)
File Upload
FileSystemIterator
Final Class Constants
Final Keyword
Finally
Finite State Machine
First Class Callable
First In, First Out (FIFO)
Fixture
Flag
Flame Graph
Flexibility
Floating Point Numbers
Fluent Interface
Folklore
For
Foreign Function Interface (FFI)
Form
Format
Forum
Forward Compatible
Fossilized Methods
Framework
Framework Interoperability Group (FIG)
Free
Front-end
Fully Qualified Name
Function Subscripting
Functional Programming
Functions
Functor
Future
Fuzzing
file://
file_get_contents()
file_put_contents()
filter
fnmatch()
fopen()
foreach()
ftp://
func_get_args()
GIF
GNU Multiple Precision (GMP)
Garbage Collection
Generator
Generics
Global Code
Global Space
Global Variables
Glue
God Object
Golf
Goto
Goto Labels
Gradual Type Checking
Graph
Graph Database
GraphQL
Graphic Draw (GD)
gRPC (Google Remote Procedure Call)
get_class()
get_class_vars()
get_object_vars()
gettext Extension
git
glob()
global Scope
HMAC
HTML Entities
HTML Entity
HTML Escaping
HTTP Code
HTTP Encoding
HTTP Headers
HTTP Request Headers
Habit
Handle
Hard Coded
Hardening
Hash
Hash #
Hash Comparisons
Haystack
Headers
Headless
Heredocs
Heuristics
Hexadecimal Integer
Hexagonal Architecture
Hidden State
Hoisting
Honey Pot
Horizontal Scaling
Hosting
Hydratation
Hyper Text Transfer Protocol (HTTP)
Hyper Text Transfer Protocol Secure (HTTPS)
HyperText Markup Language (HTML)
hash() Function
hash_equals()
hg
hrtime()
html_entity_decode
html_errors
htmlentities()
htmlspecialchars
http://
http_build_query()
hypot()
INF
INI
IaaS
Iconv
Idempotent
Identical Operator
Identification
Identifier
Identity
Identity Comparison
If Then Else
Iffectation
Image
ImagickException
ImagickPixelException
Immutable
Imperative Programming
Implicit
Implicit State
Import
Impure Function
Inclusions
Incoming Data
Inconsistent
Increment
Indentation
Index
Index For Arrays
Index For SQL
Indexed Array
Inequality
Infinite
Infinite Loop
InfiniteIterator
Inflector
Infrastructure as Code (IaC)
Inheritance
Inherited Variable
Initialisation
Injection
Inlining
Insecure Deserialization
Insteadof
Instruction
Integrated Environment of Development (IDE)
Integration Test
Interface
Interface Segregation Principle (ISP)
Internals
Internationalization
Internationalization Functions
Internet
Internet Protocol (IP)
Interoperability
Interpolation
Interpreted
Intersection Type
Introspection
InvalidArgumentException
Invoke
Isset
Iterable
Iterator
IteratorAggregate
imagick
implements
implode()
in_array()
include
include_path
ini_set()
instance
instanceof
intdiv()
integer
is_a()
is_object()
iterator_to_array()
JPEG
JSON Lines (JSONC)
JSON Lines (JSONL)
JSON Web Token (JWT)
JavaScript Object Notation (JSON)
Javascript
Jobqueue
JsonException
JsonSerializable
Jump
Just In Time (JIT)
json_decode()
json_encode()
KISS
Key-value Stores
Keyword
LSP
Language Construct
Laravel
Large Language Model (LLM)
Last In, First Out (LIFO)
Late Static Binding
Latency
Latin1
Lazy Loading
Lazy Objects
Leading Numeric String
Leading Zero Means Octal
Leak
Legacy
LengthException
Letter Logical Bug
Lexical Variable
Library
Library Loading
Licence
Lifecycle
Lightweight Directory Access Protocol (LDAP)
Line Feed
Link
Lint, Won’t Execute
Linting
Linux Apache Mysql PHP (LAMP)
Linux Nginx Mysql PHP (LEMP)
Liskov Substitution Principle (LSP)
List
Listener
Literal
Literal Types
Load Balancer
Local File Inclusion
Local Scope
Local Variable
Locale
Lock
Log
Log File
Logarithm
LogicException
Logical Operators
Loops
libsodium
Machine Learning
Magic
Magic Bytes
Magic Code
Magic Constants
Magic Hash
Magic Methods
Magic Numbers
Magic Property
Mail
Maintenability
Maintenance
Man In The Middle
Map
Markdown
Marketplace
Match
Math
Memoization
Memory
Memory Leak
Merge
Message Bus
Message Digest Algorithm 5 (MD5)
Message Queue
Method
Method Collision
Method Compatibility
Method Overloading
Method Resolution Order (MRO)
Method Signature
Methodcall
Metrics
Micro-framework
Micro-optimisation
Micro-second
Microservice
Middleware Pattern
Migration
Minification
Minimum Viable Product (MVP)
Minus -
Minus One -1
Missing Validation
Mixed
Mobile Application
Mock
Model
Model - View - Controller (MVC)
Model Context Protocol (MCP)
Module
Modulo
Monitoring
Monolith
Monomorphization
Multi-byte
Multibyte String
Multidimensional Array
Multiplication
Multithreading
Multiton
Mutation Testing
MySQL
max_execution_time
mcrypt Extension
memory_limit
microtime()
mysqli
mysqli_sql_exception
N+1 Query Problem
Name
Name Conventions
Named Constructors
Named Parameters
Named Type
Namespace Alias
Namespace Name
Namespaced Name
Namespaces
Naming
Naming Conflict
Native
NativePHP
Needle
Nested Attributes
Nesting
Network
Neural Network
Neutral Element
Never Type
New In Initializers
New Line
New Without Parenthesis
NoDiscard
Non Breakable Spaces
Non-instantiable
Non-numeric
Non-static
Nonce
Noop
Nosql Database
Not A Number (NAN)
Not Operator
Notice
Nowdocs
Null
Null Byte
Null Pattern
Null Safe Object Operator
Nullable
Nullsafe
Number
Numeric Base
Numeric Separator
Numeric String
negative-index
new
OAuth
OOP (Object Oriented Programming)
OWASP
Obfuscation
Object
Object API
Object Injection
Object Invasion
Object Nullsafe Operator ?->
Object Operator ->
Object Persistence
Object Relational Mapping (ORM)
Object Syntax
Object Type
Oblic Quotes
Observer Design Pattern
Observer Pattern
Octal Integer
Offensive Programming
Offset
On Premise Software
One Liner
One-Time Password (OTP)
Onion Architecture
Opcache
Opcode
Opcode Specialisation
Open Closed Principle (OCP)
Open Source
Open Tag
OpenSSL
Operand
Operator Overloading
Operator Precedence
Operators
Optimisation
Option
Optional Parameter
Oracle
Order Of Execution
OutOfRangeException
OuterIterator
Outgoing Data
Output buffering
Over-engineer
Overflow
OverflowException
Overloading
Override Attribute
Overriding
Overwrite
one
open_basedir
PDF
PDOException
PEAR
PHP AI Editor
PHP Constants
PHP Data Objects (PDO)
PHP Docker Container
PHP Editor
PHP Engine
PHP Extension C Library (PECL)
PHP Extensions
PHP Foundation
PHP Group
PHP Handlers
PHP Installer For Extensions (PIE)
PHP Manual
PHP Native Attribute
PHP Native Attributes
PHP Native Function
PHP Native Interfaces
PHP Natives
PHP Predefined Exception
PHP Profiler
PHP RFC
PHP Runtime
PHP Standards Recommendations (PSR)
PHP Tags
PHP User Groups
PHP Variables
PHP Wrappers
PHP, Hypertext Preprocessor (PHP)
PHP_INT_MAX
PHP_INT_MIN
PHPdoc
PHPunit
PNG
PaaS
Package Manager
Packagist
Pagination
Pair
Paradigm
Parallel
Parameter
Parameter Removal
Parenthesis
Parquet
Parse
ParseError
Parser
Partial Function
Pascal Case
Passing By Reference
Passing By Value
Passphrase
Password
Password API
Path
Path Traversal
Pattern Matching
Pay-as-you-go
Penetration Test
Performance
Perl Compatible Regular Expressions (PCRE)
Permission
Persistence
Phar
PharException
Phptoken
Pipe Operator
Pipeline
Plain Old PHP Object (POPO)
Plain Text
Plugin
Plus +
Pointer
Poisoned Pipeline Execution (PPE)
Polling
Polyfill
Polymorphism
Pop
Port
Portability
Positional Parameters
Positive Integer
Post-increment
PostgreSQL
Pound #
Pre-increment
Preappend File Directive
Precedence
Predefined Constants
Prefix
Preg_match
Prepared Query
Preprocessing
Primitive Obsession
Print
Privacy
Private Visibility
Procedural Programming
Process
Process Control (pcntl)
Product Requirements Document (PDR)
Production
Program To Interface
Progressive Web App
Promise
Promoted Properties
Propagation
Properties
Property Hook
Property Type Declaration
Proprietary Source
Protected Visibility
Protocol
Proxy
Proxy Class
Pseudo-type
Pseudo-variable
Pub/Sub
Public Visibility
Pull Request (PR)
Pure Function
pack
parent
parse_str()
parse_url()
pcntl_signal()
php.ini
php://
php://filter
php://input
php://memory
php://output
php://tmp
phpinfo()
precision
preg_split()
print_r()
printf()
Quality
Quality of Service (QoS)
Query
Query String
Question Mark ?
Queue
Quine
Quoted Printable
RACI Model
REST API
RFC
RSA
Race Condition
Railroad Programming
Random
RandomCryptoSafeEngine
RandomEngine
RangeException
Rate Limiting
Read Eval Print Loop (REPL)
Readability
Readable
Reading
Readline
Readonly
Real Numbers
Real Time
Recursion
Recursive Array
RecursiveArrayIterator
RecursiveDirectoryIterator
RecursiveIterator
RecursiveTreeIterator
Redirect
Refactoring
Reference Count
References
Reflection
ReflectionException
Reflector
Regexploit
Register Globals
Registry
Regular Expression
Relational DataBase Management System (RDBMS)
Relative
Relative Name
Relative Types
Relaxed Comparison
Relaxed Keywords
Relaxed Syntax
Relay Function
Release
Reliability
Remote Code Execution (RCE)
Remote Procedure Call (RPC)
Render
Renderer
Request For Change (RFC)
Reserved For Future Use (RFU)
Reserved Names
Resource Leak
Responsability
Response
Retrieval Augmented Generation (RAG)
Return
Return Carriage
Return Type
Return Type Will Change
Return Value
Reverse Regex
Revision
Rich Text
Rigidity
Role Based Access Control (RBAC)
Rollback
Rounding
Route
Rubber Ducking Debugging
Runtime Checks
range()
register_argc_argv
resource
robots.txt
SNMP3
SOLID
SQL Database
SQL Injection
SQL Views
SQLite3
STDOUT
SVMException
SVN
Sandbox
Sanitation
Scaffolding
Scalable Vector Graphics (SVG)
Scalar Types
Scaling
Schema
Scheme
Scope
Scope Resolution Operator ::
Search Engine
Search Engine Optimization (SEO)
Second Order SQL Injection
Secret
Secure Hash Algorithm (SHA)
Secure Shell (SSH)
Secure Sockets Layer (SSL)
Security
SeekableIterator
Segmentation Fault
Self
Self-documenting
Self-reference
Semantic Versioning
Semantics
Semicolon
Sensitive Parameter
Separation Of Concerns
Separator
Sequence
Serde
Serializable
Serialization
Server
Server Application Programming Interface (SAPI)
Server Architecture
Server Sent Event (SSE)
Serverless
Service
Service Container
Service Level Agreement (SLA)
Session
Session Fixation
Session Hijacking
SessionHandlerInterface
SessionIdInterface
SessionUpdateTimestampHandlerInterface
Set
Shallow Clone
Shard
Shared Memory
Shell
Shell Exec
Ship
Short Assignations
Short Syntax
Short Tags
Short Ternary Operator
Shutdown Function
Side Effect
Sign
Signature
Silent Behavior
Simple Mail Transfer Protocol (SMTP)
Simple Network Management Protocol (SNMP)
Simple Object Access Protocol (SOAP)
Simple Switch
SimpleXML
Single
Single Page Application (SPA)
Single Quotes Strings
Single Responsability Principle (SRP)
Single Sign On (SSO)
Singleton
Slash /
Slug
Snake Case
Snapshot
Socket
Software Bill Of Material (SBOM)
Software Development Kit (SDK)
Software Development Life Cycle (SDLC)
Software-as-a-Service (SAAS)
Sort
Source Code
Space
Spaceship Operator
Special Constant
Special Types
Specification
Spiral
SplDoublyLinkedList
SplFileInfo
SplFileObject
SplObjectStorage
SplObserver
SplStack
SplStorageObjects
SplSubject
Square Brackets
Stack
Standalone Types
Standard
Standard PHP Library (SPL)
Star *
State
Stateful
Stateless
Statement
Static Application Security Testing (SAST)
Static Call
Static Class
Static Code Analysis (SCA)
Static Constant
Static Expression
Static Method
Static Property
Static Single Assignment Form (SSA)
Static Variables
Stealth Generator
Storage Systems
Stream
Stream Wrapper
Streamlining
Strict Comparison
String
String Increment
String Interpolation
Stringable
Strpos() Syndrome
Structure
Structured Query Language (SQL)
Stubs Files
Sub (prefix)
Subclass
Subnamespaces
Suffix
Sunsetting
Superglobal Variables
Supply Chain
Supply Chain Attack
Support Vector Machine (SVM)
Swagger
Swap
Switch
Switch Case
Switch Default
Switch Fallthrough
Symfony
Synchronous
Syntax
Syntax Error
System
System Call
System Event
serialize_precision
set_error_handler()
setlocale
shell_exec()
sitemap
sleep
sprintf
sqrt()
sscanf()
static
stdclass
str_contains()
str_ends_with()
str_starts_with()
strict_types
strpos
strtolower()
strtoupper()
subtype
supertype
TCP
TODO
Tabulation
Taint Analysis
Tarpit
Task
Task Runner
Tech Island
Tech Silo
Technical Debt
Technical Reference
Telemetry
Tempest
Template
Temporary Expression
Terminal User Interface (TUI)
Ternary Operator
Test
Test Data Provider
Test Framework
Test Pyramid
Testable
Text
Text Encoding
Thin Method
Thread
Three Dots
Throwable
Tick
Time Of Check To Time Of Use (TOCTOU)
Time Travel
Timing Attack
To Crypt
To Decrypt
Token
Token Oriented Object Notation (TOON)
Tokenizer
Tom’s Obvious Minimal Language (TOML)
Tool
Total Cost Of Ownership (TCO)
Trace
Trailing Comma
Trait
Transaction
Transpile
Transport Layer Security (TLS)
Traversable
Traversal
Tree
Treemap
Triple
Troubleshoot
True
Truthy
Try-catch
Tutorial
Type Checking
Type Coverage
Type Error
Type Inference
Type Invariant
Type Juggling
Type System
TypeError
Typed Constant
Typed Property
Types Erasure
Typo
testdox
throw
trigger_error()
trim
URI Class
URI Extension
UTF-8
UUencode Encoding
Unary Operator
Unbacked Enum
Undefined
Underflow
Underscore
UnexpectedValueException
UnhandledMatchError
Unicode
Uninitialized
Union Type
Unique Identifier
Unit Test
UnitEnum
Universal Resource Identifier (URI)
Universal Resource Locator (URL)
Universally Unique IDentifier (UUID)
Unpacking
Unreachable Code
Unserialization
Unused
Upgrade
Use
Use Alias
Use In Traits
Used
Useless
User Datagram Protocol (UDP)
User Operations For Zend (UOPZ)
Userland
unset()
VCS
VCS Commit
Validation
Value
Value Object
Value Object (VO)
ValueError
Var
Variable Arguments
Variable Scope
Variable Shadowing
Variable Variables
Variables
Variadic
Vector Database
Vendor Lock-in
Version
Vertical Scaling
View
View In Presentation
Virtual Machine (VM)
Virtual Property
Visibility
Visual Debt
Void
Vulnerability
var_dump()
var_export()
variable_order
WHATWG
Warning
Waterfall
Weak Cryptography
Weak References
Weakmap
Web Application
Web-spider
WebRTC
Webscraping
Webserver
Webshell
Websocket
While
Whitespace
Wildcard
Word Combination
Workflow
Worktree
World Wide Web (WWW)
Wrapper
Wrapper Pattern
Writable
Write Everything Twice (WET)
Writeable
Writing
XML Database
XMLReader
XMLwriter
XXTEA
Xdebug
YAML Ain’t Markup Language (YAML)
Yield
Yoda Condition
You Are Not Going To Need It (YAGNI)
yield from Keyword
Zend Engine
Zero Cost
Zero Day Vulnerability
Zombie Code
Zval
zend.assertions
zero
zip Extension
zlib extension
~ Tilde
The definitive reference with all things PHP, and their definitions.
Contents: