awesome-repositories.com
Blog
awesome-repositories.com

Entdecke die besten Open-Source-Repositories mit KI-gestützter Suche.

EntdeckenKuratierte SuchenOpen-Source-AlternativenSelf-hosted SoftwareBlogSitemap
ProjektÜber unsRanking-MethodikPresseMCP-Server
RechtlichesDatenschutzAGB
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
codeigniter4 avatar

codeigniter4/CodeIgniter4

0
View on GitHub↗
5,924 Stars·1,997 Forks·PHP·MIT·6 Aufrufecodeigniter.com↗

CodeIgniter4

CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web applications. It provides a lightweight toolkit with minimal configuration, organizing application logic into controllers, models, and views for clean separation of concerns. The framework includes a fluent query builder for constructing SQL statements programmatically, PSR-4 autoloading with namespace mapping, and a service-based dependency injection container for managing shared class instances.

The framework distinguishes itself through its comprehensive set of built-in tools for common development tasks. It offers a complete CLI toolkit called Spark for code generation, database migrations, and task scheduling without external dependencies. For API development, CodeIgniter provides pre-built RESTful controllers with auto-routing, content negotiation for JSON and XML responses, and a full HTTP client for outbound requests. Security features include token-based CSRF protection, input validation and filtering, XSS prevention through context-aware escaping, and configurable Content Security Policy headers.

CodeIgniter includes a robust database abstraction layer with support for multiple drivers, schema management through migrations and seeding, and entity classes with automatic type casting and change detection. The framework provides session management with multiple storage backends, caching mechanisms for pages and data, and an event-driven lifecycle hook system. Additional capabilities cover email sending via multiple protocols, image manipulation, pagination, localization, and a debug toolbar for performance monitoring and request inspection.

The framework ships with a built-in testing toolkit that supports simulating HTTP requests, asserting responses, generating fake test data, and mocking application services. It can be installed via Composer or downloaded manually, and includes a development server command for local testing without a full web server setup.

Features

  • MVC Implementations - Organizes application logic into Models, Views, and Controllers for clean separation of concerns.
  • Model-View-Controller Frameworks - Organizes application logic into models, views, and controllers for clean separation of concerns.
  • Full-Stack Web Applications - CodeIgniter provides a lightweight MVC toolkit for building complete web applications with minimal configuration and a small footprint.
  • Full-Stack Web Frameworks - Provides a complete MVC framework for building full-stack web applications with minimal configuration.

KI-Suche

Entdecke weitere awesome Repositories

Beschreibe in einfachen Worten, was du brauchst — die KI bewertet tausende kuratierte Open-Source-Projekte nach Relevanz.

Start searching with AI
  • PHP - CodeIgniter applies a PHP filter type to any retrieved input value to sanitize or validate the data.
  • File Upload - CodeIgniter returns uploaded file data as structured objects, supporting single and multi-file retrieval.
  • Form Validation - Validates submitted form data against rules and returns errors for any failing fields.
  • PHP CLI Frameworks - Ships a complete CLI toolkit called Spark for code generation, migrations, and task scheduling.
  • PHP Framework Helpers - Ships a comprehensive set of built-in helper functions for HTML generation, form creation, and text formatting.
  • Server-Side Form Helpers - CodeIgniter provides functions to generate form elements, including inputs, selects, and buttons, with CSRF protection.
  • PHP Security Libraries - Includes CSRF protection, XSS filtering, content security policy, and input validation tools.
  • PHP Attribute Filters - Attaches one or more filters to a controller class or method using PHP attributes, with support for before/after execution and filter parameters.
  • Mass Assignment Protected Saves - Provides model methods to insert or update records while enforcing a whitelist of allowed fields.
  • Schema Versioning - CodeIgniter manages incremental schema updates as migration files so teams can apply and roll back changes consistently.
  • Data Validation - Automatically runs configured validation rules on model data before saving to the database.
  • Database Abstraction Layers - Provides a query builder, migrations, and schema management for multiple database drivers.
  • Database Connection Configurations - Stores database credentials and connection settings in config files or environment variables.
  • Database Operations - Provides a full database abstraction layer with query builder, transactions, and schema management.
  • Select Query Builders - Constructs and executes SELECT statements with limit, offset, and WHERE clauses to retrieve records.
  • Database Query Execution - Executes SQL queries using a query builder, transactions, and metadata retrieval with multiple driver support.
  • Schema-Managed Querying - Executes SQL queries, builds queries programmatically, and manages database schema through migrations and seeding.
  • Database Query Joins - Supports INNER, LEFT, RIGHT, and OUTER joins with ON conditions in queries.
  • Record Updates - Provides a model method to modify rows by primary key using an associative array of data.
  • Database Record Querying - Retrieves data from database tables using models and the query builder.
  • Database Schema Managers - Ships a complete migration and schema manipulation toolkit for versioning and evolving database structures.
  • Model Table Mappings - Maps model classes to database tables with automatic CRUD methods and validation.
  • Database Transaction Management - CodeIgniter wraps a series of queries in a commit or rollback block to preserve data integrity on failure.
  • Database Transactions - CodeIgniter groups multiple queries into an atomic unit that commits all changes on success or rolls them back on any failure.
  • Entity Modeling - Represents database rows as entity objects with validation, events, and relationships.
  • Primary Key Retrievals - Provides a model method to fetch rows by primary key, returning results in the configured format.
  • Fluent Query Builders - Constructs SQL statements programmatically using a method chain, preventing manual string concatenation.
  • Session Variable Stores - Reads and writes arbitrary key-value pairs to the session array using accessor methods.
  • Pre-Save Validation Hooks - Automatically validates data against rules before insert, update, or save operations.
  • MVC Controller-Model Writers - CodeIgniter organizes application logic into controller classes for handling requests and model classes for data interaction.
  • Malicious URI Character Filters - CodeIgniter rejects requests containing dangerous characters in the URL path to prevent path traversal and injection attacks.
  • Logical Grouping - Provides a fluent query builder with nested parenthetical WHERE clause grouping.
  • Raw SQL Execution - Runs arbitrary SQL statements directly against the database and returns the result set.
  • All-Record Retrievers - Provides a model method to retrieve all records from a table with limit and offset support.
  • Result Ordering and Limiting - Orders result sets by specified columns and restricts returned rows with offset.
  • Programmatic Schema Forge Tools - CodeIgniter applies schema changes such as creating, altering, and dropping tables through a programmatic forge tool.
  • Server-Side Session Stores - Maintains user state across requests using server-side storage with configurable drivers.
  • SQL Query Builders - Executes raw SQL statements against the connected database and returns results.
  • SQL Literal Escaping - Automatically escapes values during SQL insert operations to prevent injection.
  • WHERE Clause Builders - Adds conditions to queries using key/value pairs, arrays, custom strings, subqueries, or raw SQL.
  • Application Error Handling - CodeIgniter catches PHP errors and exceptions and displays user-friendly error pages or logs them.
  • CLI Command Frameworks - Provides a built-in CLI framework (Spark) for registering and running user-defined commands.
  • CLI Command Registrars - Executes framework commands by passing their name and arguments to the spark script.
  • Custom Command Definitions - Ships a Spark CLI toolkit that lets developers define custom commands by extending a base class.
  • Code Organization - CodeIgniter structures application code into dedicated directories for controllers, models, views, configuration, and other components to enforce separation of concerns.
  • Command-Line Scaffolding - Runs Spark commands for code generation, migrations, and controller execution from the terminal.
  • Namespaced Configuration Classes - Defines application settings as public properties in namespaced class files for type-safe configuration.
  • Database Administration CLI - Executes migration, seeding, and schema operations through terminal commands without a web interface.
  • Automated Test Execution - Executes unit, database, controller, and HTTP tests with mocking and benchmarking to verify application behavior.
  • Server-Side Form Helpers - CodeIgniter creates an HTML form tag with a site URL, optional attributes, hidden fields, and automatic CSRF protection when enabled.
  • String Localization - Stores translatable text in language-specific files and retrieves it by key for the current locale.
  • MVC Module Organizers - CodeIgniter organizes controllers, models, views, and config files into namespaced directories that act as self-contained mini-applications.
  • HTTP-Verb Controller Generators - Generates controller classes with HTTP-verb-prefixed methods for handling GET, POST, PUT, and DELETE requests.
  • RESTful Controller Bases - Ships a base controller class with pre-defined methods that correspond to standard CRUD resource routes.
  • Custom Base Controllers - CodeIgniter creates a custom base controller that all other controllers inherit, centralizing shared logic and preloaded components.
  • Server-Side RESTful Controllers - CodeIgniter creates API endpoints with controllers and auto-routing, returning consistent JSON responses via a response trait.
  • SQL Query Executions - Executes raw SQL queries directly against the database and returns result objects or success booleans.
  • Template Variable Outputs - Substitutes placeholders in view files with provided data values for dynamic output.
  • HTTP Request Dispatchers - Sends HTTP requests to external services with full control over headers, body, and authentication.
  • Global Helper Function Overrides - Provides a dedicated mechanism to override built-in global helper functions with custom implementations.
  • Shared Class Instance Loading - Creates and returns shared or new class instances to reduce memory overhead by reusing object states.
  • PSR-4 Namespace Autoloading - Implements PSR-4 autoloading to automatically load module classes by namespace without manual includes.
  • Autoloading Specifications - Implements PSR-4 autoloading to resolve PHP classes on demand without manual includes.
  • API Authentication - Provides API authentication to restrict access to endpoints using tokens and credentials.
  • Input Security Functions - Provides built-in functions for input filtering, XSS cleaning, and other security tasks.
  • Web Security - Blocks CSRF and XSS attacks with built-in security features including context-sensitive escaping and Content Security Policy.
  • Authentication and Authorization - Provides a framework for verifying user identity and managing access permissions.
  • Content Security Policies - CodeIgniter sets HTTP headers that restrict which scripts, styles, and resources the browser may load.
  • Cross-Site Request Forgery Protections - Generates and validates a unique session token on state-changing requests to block cross-site forgery.
  • Input Validation - Checks user-submitted values against defined rules and rejects malformed input before processing.
  • Session State Tracking - Maintains a persistent state for each visitor by updating session data on every page load.
  • Query Parameterization - Replaces placeholders in SQL strings with escaped values using positional and named bindings.
  • Security Best Practices - Incorporates features and techniques that make it easy to follow good security practices without extra effort.
  • Security Headers - CodeIgniter attaches HTTP response headers that help protect against common web vulnerabilities.
  • CSRF Protections - Validates a token on state-changing requests to block forged submissions from malicious sites.
  • Output Escaping - Automatically escapes variable values for HTML, attributes, CSS, or JavaScript contexts to prevent XSS.
  • Parameterized Query Bindings - Separates SQL logic from user-supplied values so injected code cannot alter the query structure.
  • User Authentication Systems - Provides a framework for verifying user identity and managing login/logout.
  • Web Application Security - Provides built-in CSRF protection, XSS prevention, input validation, and configurable Content Security Policy headers.
  • Application Configuration - Loads and reads configuration values from files and environment variables to control application behavior.
  • Component Decoupling Patterns - CodeIgniter keeps each part of the system independent so they can be reused, replaced, or tested without affecting others.
  • Validation Rule Engines - Sets one or more validation rules for a field using a pipe-delimited string or an array of rules.
  • Dependency Injection Containers - Registers and retrieves shared service instances through a centralized container for loose coupling.
  • MVC Controller Implementations - CodeIgniter organizes application logic into Models, Views, and Controllers for clean separation of concerns.
  • Namespace Mappings - Resolves classes automatically by mapping namespace prefixes to directory paths without manual includes.
  • Reusable Component Architectures - CodeIgniter provides classes and functions that each serve a single, narrow purpose for maximum clarity and reusability.
  • Boilerplate Scaffolders - CodeIgniter scaffolds boilerplate files such as controllers, models, and migrations using built-in command-line generators.
  • Service Instance Managers - Provides a centralized service container for registering and retrieving shared service instances.
  • Service Replacement Mechanisms - CodeIgniter swaps a built-in class with a custom implementation by defining a factory method that returns a new instance.
  • Error Logging Utilities - CodeIgniter writes application error messages to daily log files for later review and debugging.
  • Severity-Level Log Writers - CodeIgniter records application events at eight severity levels (debug through emergency) to local log files for monitoring and debugging.
  • Simulated Request Testing - Simulates HTTP requests and asserts responses during automated testing.
  • Function Behavior Replacement - Provides a mechanism to replace default global helper functions with custom implementations.
  • Test Utilities & Assertions - Provides built-in assertions, mocking utilities, and environment setup for unit, controller, and HTTP tests.
  • HTTP Response Assertions - Checks controller or HTTP test results against conditions like status codes and content.
  • HTTP Request Clients - Makes GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS requests and returns structured responses.
  • End-to-End Testing - Ships a testing toolkit that validates full application workflows across controllers, HTTP, CLI, and database layers.
  • PHP Testing Frameworks - Ships a built-in testing toolkit with HTTP simulation, assertions, and mocking.
  • Input Validation Rules - Validates user-submitted data against rules like required, email, min length, and custom callbacks.
  • Input Sanitization Rules - CodeIgniter applies configurable sanitization rules to each incoming request field to strip or reject dangerous content.
  • Plugin Templated View Rendering - Assembles HTML output from template files and returns it to the user's browser.
  • Template Inheritance Layouts - Defines base templates with placeholders filled by child views for consistent page structure.
  • Resource Presenter Controllers - Provides a base controller class with methods for rendering resource views and processing form submissions.
  • URI-to-Controller Mappings - Associates an incoming URL path with a specific controller class and method to handle the request.
  • API Endpoint Filters - Attaches filter classes to selected URI patterns so they run only on designated pages or API endpoints.
  • Request & Response Handling - Processes incoming HTTP requests and generates appropriate responses for client-server communication.
  • HTTP Request Handling - Processes incoming HTTP requests by parsing URIs, headers, and method spoofing to route them to controllers.
  • Content Negotiation Utilities - CodeIgniter matches client preferences against server capabilities to return the best-suited media type, language, encoding, or character set.
  • HTTP Response Builders - Provides utilities for constructing HTTP responses with status codes, headers, and body content.
  • Content Negotiation - CodeIgniter selects the best matching language, media type, charset, or encoding from the client's Accept headers.
  • Controller-Action Routing - Maps URI segments to controller classes and methods automatically, eliminating the need to define every route manually.
  • Data Validation - Validates incoming data arrays against defined rules and returns a boolean success indicator.
  • Dynamic View Rendering - Sends variables from controllers to view files for rendering in the response.
  • Form Data Validation - Checks form input against defined rules and returns the form with errors on failure.
  • Input Sanitizers - Strips or escapes dangerous characters from incoming data to prevent injection attacks and cross-site scripting.
  • Lightweight Web Frameworks - CodeIgniter loads and executes only the components needed for each request, keeping the system small and fast by default.
  • Resource-Based Routing - Maps standard CRUD operations to controller methods so a resource endpoint works automatically.
  • Response Formatting - CodeIgniter detects the client's preferred format and returns the response as JSON or XML without manual configuration.
  • RESTful API Development - Ships pre-built RESTful controllers with auto-routing and content negotiation for JSON and XML responses.
  • Route Pattern Parsers - Provides route pattern parsing with named tokens for dynamic parameter extraction.
  • Routing Libraries - Maps URLs to controller methods with support for auto-routing, resource routes, and route groups.
  • HTTP Routing - Maps specific HTTP methods like POST to controller actions for precise request handling.
  • Route Grouping - Wraps a set of routes inside a shared URI prefix to reduce repetition and apply common options.
  • Convention-Based Mappings - Maps URI segments to controller classes and methods automatically without explicit route definitions.
  • URL Construction - Constructs and parses URLs that map to specific controllers and methods within the application.
  • URL Routing - Provides a configurable URL routing system that maps incoming requests to controller methods.
  • Web Application Frameworks - CodeIgniter provides a rich set of libraries for common tasks and a simple interface to accelerate development beyond writing from scratch.
  • View Rendering from Routes - Ships a feature to render view files directly from route definitions without a controller.
  • CLI and Argument Parsing - Extracts positional path segments and named options from a command-line invocation for programmatic access.
  • Email and Notifications - Composes and dispatches emails with attachments, HTML content, and multiple protocols.
  • HTML Tag Helpers - CodeIgniter creates an HTML `` element for stylesheets or other linked resources, with full attribute control.
  • API Response Caching - Stores generated API responses and serves cached copies to reduce server load.
  • Manual Transaction Controls - CodeIgniter provides explicit begin, commit, and rollback calls for full control over the transaction lifecycle.
  • Application Data Caches - Stores frequently accessed data in memory or file-based caches to reduce database load and speed up page delivery.
  • Current User Identifiers - Provides a standard function to retrieve the currently logged-in user's unique identifier.
  • Data Model File Generation - Creates a new model class file with database interaction methods from a command-line template.
  • JSON Response Assertions - Validates JSON response structure and values during automated testing.
  • Relational Resource Mapping - CodeIgniter loads and appends related data when the client specifies an include query parameter, using dedicated methods on the transformer.
  • Client-Requested Resource Inclusions - CodeIgniter attaches nested related data to an API response only when the client explicitly requests it via a query parameter.
  • Application-Level Casting Handlers - Registers custom handlers for transforming data between database and PHP representations.
  • Property Cast Handlers - Registers custom handler classes that transform property values during get and set operations.
  • Table Metadata Inspection - Displays field names, column types, and metadata for a specified database table from the CLI.
  • Relational Database Metadata Inspectors - CodeIgniter reads schema information such as table lists, field names, and index details from the connected database.
  • Slug-Based Record Retrieval - Filters database queries by URL slug to return a single matching record.
  • Row Count Assertions - Verifies database row counts match expected values in test assertions.
  • Database Seeding Tools - CodeIgniter populates database tables with sample records using seed scripts for development and testing environments.
  • Nested Transactions - CodeIgniter allows transaction calls to be nested, with only the outermost block actually committing or rolling back.
  • In-Memory Caches - Stores frequently accessed data in memory or on disk to reduce database queries and speed up page loads.
  • Web Page Output Caching - Stores the fully rendered output of a page and serves it on subsequent requests until it expires.
  • File-Based Session Stores - Persists session data to the filesystem using the default file handler.
  • Memcached Session Stores - Persists session data in a Memcached store for high performance.
  • Relational Database Session Stores - Persists session data in MySQL or PostgreSQL tables for direct access to session records.
  • Index Management Operations - CodeIgniter removes a regular or unique index from a table.
  • Computational Result Caching - Invokes a callback when a cache miss occurs, stores the result, and returns it on subsequent requests.
  • Multi-Namespace Migration Executors - CodeIgniter discovers migration files across all registered namespaces and executes them together during each migration run.
  • Migration File Generation - Creates a new database migration class file for versioning schema changes.
  • Model Instantiation - Returns shared or new model instances with optional database connections.
  • Pagination - CodeIgniter automatically splits a collection of resources into pages and returns a paginated response with a configurable page size.
  • Controller Output Caches - Stores a controller method's response for a configurable duration, optionally with a custom cache key, to reduce repeated processing.
  • Model-Bound - Provides a shared query builder pre-configured with the model's table for custom queries.
  • Object Result Fetches - CodeIgniter fetches all matching rows from a query and returns them as an array of objects for iteration.
  • Single Row Fetches - CodeIgniter fetches one row from a query result and returns it as a single object.
  • Record Deletion - Removes records by primary key with support for soft-delete permanent removal.
  • Record Insertion - Creates new rows from arrays or objects and returns the primary key.
  • Upsert Operations - Inserts or updates records automatically by detecting primary key presence.
  • Soft Deletion - Provides model support for marking records as deleted by setting a timestamp instead of removing them.
  • Hard Deletion of Soft-Deleted Records - Permanently removes all rows that have been soft-deleted from the table.
  • Soft-Delete Query Overrides - Temporarily overrides soft-delete filters to retrieve deleted or all rows.
  • Row Existence Assertions - Checks whether database rows exist or are absent during automated tests.
  • Application Debug Logging - Inspects and logs application variables and flow to diagnose issues during testing.
  • Configurable Rule Groups - Stores reusable validation rule groups in configuration files for application-wide reuse.
  • Non-Class File Autoloading - Loads procedural functions, constants, and bootstrap files from a configured list for global availability.
  • Programmatic Command Invokers - Offers a helper function to invoke any CLI command programmatically from within application code.
  • Modular - CodeIgniter groups related controllers, models, views, and configs into self-contained units for larger applications.
  • Class Alias Definitions - Maps fully qualified class names to aliases for simplified access through the service container.
  • Named Option Definitions - Returns the value of a specific named option passed on the command line.
  • Database CLI Tools - Creates databases directly from the command line using a dedicated spark command.
  • Environment Configuration Management - Switches configuration sets automatically based on the server environment (development, production, testing).
  • Performance Benchmarking - Measures execution time of code segments to identify performance bottlenecks.
  • Composer Library Packaging - Wraps reusable functionality into Composer packages for installation and autoloading in any project.
  • Route Pattern Matching - Provides regular expression pattern matching in route definitions for flexible URL handling.
  • Framework Debugging Toolbars - Shows a toolbar with benchmarks, queries, and request data for at-a-glance performance and debugging insight.
  • Response Transformers - CodeIgniter formats resource data into a consistent array structure using a dedicated transformer class before encoding as JSON or XML.
  • Multi-Segment URI Parameters - Provides the ability to capture multiple URI segments as a single parameter in route patterns.
  • Controller Executions - Allows executing controller methods directly from the command line for automated testing and scripting.
  • Redis-Backed Session Stores - Persists session data in a Redis store for high performance with TLS support.
  • Authentication Integration - Adds user login, session management, and access checks by extending the framework's authentication system.
  • Lifecycle Event Hooks - Registers custom code to run automatically at predefined points in the request lifecycle.
  • Rate Limiting Algorithms - Implements a token bucket algorithm to restrict how many times an action can be performed within a time window.
  • Route Priority Assignments - Provides numeric priority assignment for routes to control matching order.
  • Per-Client Request Throttlers - Caps how many requests a single client may make in a time window and rejects excess traffic.
  • Custom Request Headers - Sets arbitrary HTTP headers on test requests to simulate client metadata.
  • Request Timeout Configurations - Limits how long a request may take to connect or complete, with an option to wait indefinitely.
  • Query Parameter Encoders - Automatically formats and appends associative arrays as valid query strings to request URLs.
  • Multi-Protocol Sending - Sends email using Mail, Sendmail, or SMTP protocols with TLS and SSL encryption.
  • Hostname-Based Route Restrictions - Provides hostname-based route restrictions to limit request matching to specific domains or subdomains.
  • Environment-Specific Route Restrictions - Provides environment-specific route restrictions to limit access based on the application environment.
  • URI Construction and Parsing - CodeIgniter parses a full or partial URL into accessible parts like scheme, host, path, and query for programmatic manipulation.
  • URI Segment Readers and Modifiers - CodeIgniter accesses or alters individual path segments by position, with optional default values and silent error handling.
  • Controller File Generators - Creates a new controller class file from a command-line template to handle incoming HTTP requests.
  • Native Class Subclassing - Adds new methods or overrides existing ones on a system class by subclassing it and registering the subclass through a service.
  • Class Extensions - Replaces or inherits from built-in framework classes to alter internal behavior without modifying the original source.
  • Core Class Replacements - Swaps a built-in system class with a custom implementation by ensuring autoloading, interface compliance, and service configuration.
  • Custom Method Routings - Provides a mechanism to intercept and reroute all incoming requests through a custom controller method.
  • Request-Level Preloaders - CodeIgniter loads helpers, models, libraries, and services in the base controller so they are available across every request without manual inclusion.
  • Short Name Model Resolution - Resolves model classes from module namespaces using short class names.
  • Composer Module Packaging - Packages reusable code modules as Composer packages for installation and sharing across projects.
  • Caching Interfaces - Provides standard cache interfaces for storing and retrieving cached data, enabling interoperability with compatible libraries.
  • Database Value Casting - Converts database values to native PHP types like int, bool, and datetime automatically.
  • Property Type Casting - Automatically casts entity properties to integer, boolean, array, JSON, or enum types.
  • Worker Mode Runtimes - Supports handling multiple requests within a single PHP process using FrankenPHP.
  • Controller Filters - CodeIgniter executes custom logic before a controller method runs, allowing request modification or early termination.
  • Post-Controller Hooks - CodeIgniter executes custom logic after a controller method runs, allowing response modification or final processing.
  • Field Whitelists - CodeIgniter limits which fields or related resources a client may request by defining whitelists in the transformer class.
  • Character Escaping - Converts HTML special characters in form values to prevent breakage from quotes and special characters.
  • Content Security Policy Nonce Support - CodeIgniter produces the nonce attribute for script or style tags to enforce Content Security Policy.
  • Controller Filters - Runs one or more before/after filters on a specific route for authentication, logging, or other middleware tasks.
  • Filter Parameterizations - CodeIgniter supplies configuration values to a filter at the point of assignment so the same filter can behave differently per route.
  • Cross-Origin Resource Sharing Policies - Configures which external origins may access server resources and blocks unauthorized cross-origin requests.
  • Cross-Origin Security Policies - Configures allowed origins, methods, and headers so browsers permit requests from other domains.
  • Cryptographic Key Generation - Creates a pseudo-random key of a specified length using the operating system's secure random source.
  • URI Exemptions - CodeIgniter skips a filter for specific URI patterns while keeping it active for all other requests.
  • Host and Environment Restrictions - CodeIgniter limits controller access to specific hostnames, subdomains, or application environments using a declarative attribute.
  • Encryption Key Management - Keeps old keys available for decrypting legacy data while using a new key for fresh encryption operations.
  • File Type Validators - Applies file-specific validation rules like size, dimensions, MIME type, and extension to uploads.
  • Personal Access Tokens - Issues and validates bearer tokens for stateless API client authentication.
  • Data Encryption - Transforms data into an unreadable format using a cipher so only authorized parties can decrypt it.
  • Stream Encryption and Decryption - Encrypts plaintext with a chosen cipher and key, then decrypts ciphertext back to the original message.
  • Request Authentication - Provides HTTP Basic and Digest authentication for securing endpoints.
  • Request Throttling - Limits how many requests a client can make in a time window to prevent API abuse.
  • Role-Based Access Control - Assigns roles with granular permissions and checks them on each request to restrict access.
  • Runtime CSP Modifications - CodeIgniter modifies Content Security Policy directives dynamically in controllers through the response object's CSP instance.
  • Security Logging Management - CodeIgniter records security-relevant actions and errors to a persistent store for later review and incident analysis.
  • Session Authentication - Manages user login and session persistence using server-side sessions for stateful authentication.
  • Security Configuration Auditing - Provides automated scanning of application settings and PHP environment for insecure defaults.
  • Closure Route Handlers - Provides the ability to use closures as direct route handlers without a controller class.
  • Dot-Notation Nested Validators - Validates fields within nested associative arrays using dot-notation and wildcards.
  • Field Value Placeholders - Substitutes placeholders in validation rules with actual submitted field values at runtime.
  • Controller Subdirectory Organizers - CodeIgniter structures controllers into nested directories under app/Controllers, with the first URI segment selecting the sub-directory.
  • Lifecycle Event Callbacks - Allows registering custom methods that run before or after model insert, update, find, and delete operations.
  • Log Event Enrichment - Inserts dynamic values like user IDs or IP addresses into log messages using placeholder substitution.
  • Module Functionality Extenders - Replaces or augments built-in classes and functions with custom implementations without modifying the framework.
  • Namespace-Based Module Auto-Discovery - Automatically discovers module routes, events, filters, and services by scanning registered namespaces.
  • Plugin Extenders - Allows core framework components to be easily extended or completely swapped to match custom requirements.
  • Service Container Extensions - Replaces or augments built-in classes and functions with custom implementations through the service container and events system.
  • Lifecycle Event Hooks - Fires custom code at predefined points in the request lifecycle using a publish-subscribe pattern.
  • URI Dash-to-Underscore Translations - Provides automatic conversion of hyphens to underscores in URI segments for controller matching.
  • Single Value Validators - Validates individual values against rules without requiring a full data array.
  • Persistent - Configures which framework services persist across requests to improve performance.
  • Namespace-Based Service Auto-Discovery - Automatically discovers and registers module service definitions by scanning registered namespaces.
  • Severity Level Filtering - Sets a minimum severity threshold or selects specific levels to control which messages are written to the log.
  • Output Capture Utilities - Captures STDOUT and STDERR output for verifying CLI command content in tests.
  • Stream Output Capture for Testing - Captures PHP stream output for inspection during test assertions.
  • CLI Input Simulations - Provides a mechanism to simulate user keystrokes for testing interactive CLI commands.
  • Static Analysis - CodeIgniter integrates static analysis tools and testing frameworks to detect bugs and enforce code quality automatically.
  • Controller Isolations - Provides a dedicated method to test controllers in isolation with simulated requests.
  • Test Assertion Extensions - Includes extended assertions for verifying events, headers, execution times, and accessing private methods.
  • Session State Assertions - Asserts session values after controller requests during HTTP testing.
  • Database Seeders - Creates a new database seeder class file to populate tables with test or default data.
  • Virtual Time Testing - Fixes or changes the current time during testing for predictable time-dependent code.
  • Property Accessor Methods - Invokes custom setter and getter methods automatically to enforce validation or transformation.
  • Named Content Sections - Wraps content in named blocks that automatically replace placeholders in parent layouts.
  • Custom Validation Messages - Assigns field-specific custom error messages to validation rules with dynamic tag support.
  • Custom Fake Data Formatters - Overrides default Faker output with model-specific logic for test data generation.
  • Inline Callback Rules - Defines validation rules as inline callbacks within controllers for ad-hoc checks.
  • Interface Text Localization - Replaces language strings in views with translations based on the user's locale setting.
  • Locale Detection - Determines the correct language for a request through content negotiation or URL segments.
  • Locale-Aware Value Formatting - Replaces placeholders in language strings with locale-aware numbers, dates, and times.
  • Partial View Inclusions - Embeds separate view files as reusable components that can be inserted into any page.
  • View Data Inheritance - Sets variables on the view object so they are available to all nested sections and partials.
  • Route Definitions - Provides a method to define routes for presentation controllers that return views and process forms.
  • Body Manipulators - Provides interfaces for accessing and modifying the content of HTTP request and response bodies.
  • HTTP Header Manipulators - Provides functions for adding, modifying, or removing HTTP header fields in requests or responses.
  • Component Caching - Stores a rendered component's output for a configurable number of seconds, serving the cached version on subsequent calls.
  • Controller-Based Organization - CodeIgniter groups controller files into nested folders under the main controllers directory for larger applications.
  • Base Controller Hierarchies - CodeIgniter defines separate base controllers for different application sections, such as public and admin, to organize distinct shared functionality.
  • Immutable Date Conversions - Automatically converts date columns into immutable Time objects with locale-aware formatting.
  • Reusable View Components - Renders self-contained PHP classes that return HTML for injection into parent views.
  • HTTP Status Code Management - CodeIgniter returns appropriate HTTP status codes and structured JSON payloads for success, creation, deletion, and error conditions.
  • Dot Notation Field Accessors - CodeIgniter reads a single value or nested value from a JSON request body using dot notation.
  • Request Body Attachers - Allows sending raw strings, form-encoded parameters, or JSON data as the body of an HTTP request.
  • JSON Response Formatters - Converts arrays of data into JSON strings and sets the Content-Type header to application/json.
  • XML Response Formatters - Converts arrays of data into XML strings and sets the Content-Type header to application/xml.
  • Route Grouping - Places one route group inside another to create hierarchical URI structures with merged options.
  • Multi-Verb Route Matchers - Accepts a route that matches any of several specified HTTP methods in a single definition.
  • Module Controller Routings - Provides routing to controllers within module namespaces using namespace-prefixed route groups.
  • Route Naming Systems - Assigns a human-readable name to a route so links can be generated by name instead of by path.
  • Named Route Redirects - Returns a RedirectResponse that sends the client to a URI resolved from a named route or controller method.
  • Auto-Routing Toggles - Forces the router to use only explicitly defined routes and ignore automatic controller discovery.
  • Session Flash Messaging - Marks session data to be available only for the next request, ideal for status or error messages.
  • Template Logic - Evaluates if/elseif/else blocks with standard PHP operators inside template files.
  • URL Generators - Builds a full URL from config, appending index page and optional URI segments for portable local links.
  • Base URL Mappers - Returns the configured base URL, optionally appending URI segments or file paths.
  • Current URL Readers - Returns the full URL of the page being viewed, derived from config settings rather than the browser URL.
  • CLI-Only Routes - Creates routes that are reachable only from the command line and ignored by web requests.
  • Redirection Rules - Issues an HTTP redirect to a different URI or named route when the original route is matched.
  • Relative URI Redirects - Returns a RedirectResponse that sends the client to a specific URI path relative to the base URL.
  • Previous Page Redirects - Returns a RedirectResponse that sends the client back to the last page viewed during the session.
  • Logging Interfaces - CodeIgniter implements all interfaces from the PSR-3 Logger Interface standard for structured logging.
  • Developer Tools - Lightweight MVC framework for web development.
  • Php Projects - Listed in the “Php Projects” section of the Awesome For Beginners awesome list.

    • Star-Verlauf

    Star-Verlauf für codeigniter4/codeigniter4Star-Verlauf für codeigniter4/codeigniter4

    Häufig gestellte Fragen

    Was macht codeigniter4/codeigniter4?

    CodeIgniter is a PHP web framework built on the Model-View-Controller pattern, designed for building full-stack web applications. It provides a lightweight toolkit with minimal configuration, organizing application logic into controllers, models, and views for clean separation of concerns. The framework includes a fluent query builder for constructing SQL statements programmatically, PSR-4 autoloading with namespace mapping, and a service-based dependency injection…

    Was sind die Hauptfunktionen von codeigniter4/codeigniter4?

    Die Hauptfunktionen von codeigniter4/codeigniter4 sind: MVC Implementations, Model-View-Controller Frameworks, Full-Stack Web Applications, Full-Stack Web Frameworks, PHP, File Upload, Form Validation, PHP CLI Frameworks.

    Welche Open-Source-Alternativen gibt es zu codeigniter4/codeigniter4?

    Open-Source-Alternativen zu codeigniter4/codeigniter4 sind unter anderem: kataras/iris — Iris is a high-performance web framework and API toolkit for the Go programming language. It provides the… loco-rs/loco — Loco is a full-stack web framework for Rust designed to accelerate application development using a… knex/knex — Knex is a multi-dialect database client that provides a programmatic SQL query builder, a connection pool manager, and… uptrace/bun — Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping.… quarkusio/quarkus — Quarkus is a Kubernetes-native Java framework designed for building high-performance, memory-efficient applications.… laravel/framework — This project is a full-stack web framework that provides a comprehensive environment for building server-side…

    Open-Source-Alternativen zu CodeIgniter4

    Ähnliche Open-Source-Projekte, sortiert nach der Anzahl der gemeinsamen Funktionen mit CodeIgniter4.
    • kataras/irisAvatar von kataras

      kataras/iris

      25,582Auf GitHub ansehen↗

      Iris is a high-performance web framework and API toolkit for the Go programming language. It provides the infrastructure necessary to build HTTP/2 web applications, REST APIs, and MVC-based websites. The project distinguishes itself through a flexible architectural model that supports multiple isolated application instances within a single process and allows for binary-embedded asset loading to eliminate external filesystem dependencies. It features dynamic router hot-reloading and a pluggable view engine for rendering dynamic HTML content. The framework covers a broad range of capabilities,

      Go
      Auf GitHub ansehen↗25,582
    • loco-rs/locoAvatar von loco-rs

      loco-rs/loco

      8,645Auf GitHub ansehen↗

      Loco is a full-stack web framework for Rust designed to accelerate application development using a convention-over-configuration approach. It functions as an MVC web framework that provides a structured environment for building web applications and REST APIs. The project distinguishes itself through an integrated API development toolkit and a command-line scaffolding engine. These tools automate the creation of controllers, models, and migrations, allowing for the rapid generation of functional CRUD resources and application boilerplate. The framework covers a broad range of backend capabili

      Rustapiaxumrust
      Auf GitHub ansehen↗8,645
    • knex/knexAvatar von knex

      knex/knex

      20,300Auf GitHub ansehen↗

      Knex is a multi-dialect database client that provides a programmatic SQL query builder, a connection pool manager, and a versioned schema migration tool. It enables programmatic database interaction across multiple SQL engines, including PostgreSQL, MySQL, SQLite3, SQL Server, CockroachDB, and Oracle. The project distinguishes itself through a fluent interface for constructing complex SQL statements and a dedicated framework for database seeding. It utilizes specialized dialects to translate generic query representations into database-specific syntax while maintaining a consistent API across

      JavaScript
      Auf GitHub ansehen↗20,300
    • uptrace/bunAvatar von uptrace

      uptrace/bun

      4,867Auf GitHub ansehen↗

      Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping. It functions as a programmable SQL query builder, a database connection manager, and a tool for mapping database tables to Go structs. The project distinguishes itself through a multi-dialect SQL support system, allowing a single codebase to interact with different database engines via a consistent interface. It includes a built-in database observability tool for query interception, distributed tracing, and logging, as well as a schema migration tool for versioning structural c

      Godatabasegogolang
      Auf GitHub ansehen↗4,867
    Alle 30 Alternativen zu CodeIgniter4 anzeigen→