Php Fundamentals

PHP Fundamentals Skill

Atomic skill for mastering modern PHP programming fundamentals

Overview

This skill provides comprehensive training in modern PHP development, from basic syntax to advanced PHP 8.4 features. Designed for progressive learning with hands-on exercises.

Skill Parameters

Input Validation

interface SkillParams {
  topic:
    | "syntax"           // Variables, operators, control structures
    | "oop"              // Classes, interfaces, traits
    | "type-system"      // Type declarations, unions, intersections
    | "php8-features"    // Modern PHP 8.x features
    | "composer"         // Dependency management
    | "standards";       // PSR compliance

  level: "beginner" | "intermediate" | "advanced";
  php_version?: "8.0" | "8.1" | "8.2" | "8.3" | "8.4";
  output_format?: "tutorial" | "reference" | "exercises";
}

Validation Rules

validation:
  topic:
    required: true
    allowed: [syntax, oop, type-system, php8-features, composer, standards]
  level:
    required: true
    allowed: [beginner, intermediate, advanced]
  php_version:
    default: "8.3"

Learning Modules

Module 1: PHP Syntax Fundamentals

topics:
  - Variables and data types
  - Operators and expressions
  - Control structures (if, switch, match)
  - Loops (for, foreach, while)
  - Functions and closures
  - Error handling basics

exercises:
  - Build a calculator function
  - Create array manipulation utilities
  - Implement string processing functions

duration: 8-12 hours
prerequisites: none

Module 2: Object-Oriented Programming

topics:
  - Classes and objects
  - Properties and methods
  - Inheritance and polymorphism
  - Interfaces and abstract classes
  - Traits and composition
  - SOLID principles

exercises:
  - Design a Shape hierarchy
  - Implement Repository pattern
  - Build a simple DI container

duration: 15-20 hours
prerequisites: [syntax]

Module 3: PHP 8.x Modern Features

topics:
  php_8_0:
    - Named arguments
    - Constructor property promotion
    - Match expressions
    - Nullsafe operator
    - Attributes
    - Union types

  php_8_1:
    - Enums
    - Readonly properties
    - Fibers
    - Intersection types

  php_8_2:
    - Readonly classes
    - DNF types

  php_8_3:
    - Typed class constants
    - json_validate()
    - "#[Override]" attribute

  php_8_4:
    - Property hooks
    - Asymmetric visibility

duration: 10-15 hours

Execution Flow

graph TD
    A[Skill Invoked] --> B{Valid Parameters?}
    B -->|No| C[Return Validation Error]
    B -->|Yes| D[Load Module Content]
    D --> E{Level?}
    E -->|Beginner| F[Basic Concepts + Examples]
    E -->|Intermediate| G[Patterns + Exercises]
    E -->|Advanced| H[Deep Dive + Best Practices]
    F --> I[Generate Response]
    G --> I
    H --> I

Error Handling & Retry Logic

Error Categories

errors:
  INVALID_TOPIC:
    code: "SKILL_001"
    recovery: "Display available topics"

  VERSION_MISMATCH:
    code: "SKILL_002"
    recovery: "Suggest minimum version or alternative"

Retry Strategy

retry:
  max_attempts: 3
  backoff:
    type: exponential
    initial_delay_ms: 100
    max_delay_ms: 2000
    multiplier: 2

Logging & Observability

Event Hooks

hooks:
  on_skill_start: [log_invocation, track_topic]
  on_module_complete: [update_progress, award_badge]
  on_error: [log_error, suggest_recovery]
  on_skill_complete: [recommend_next_skill]

Code Examples

Beginner: Basic Syntax

<?php
declare(strict_types=1);

// Variables and types
$name = 'PHP Developer';
$version = 8.3;

// Match expression (PHP 8.0+)
$status = match($code) {
    200 => 'OK',
    404 => 'Not Found',
    default => 'Unknown',
};

Intermediate: OOP Patterns

<?php
declare(strict_types=1);

// Constructor property promotion (PHP 8.0+)
final readonly class User
{
    public function __construct(
        public int $id,
        public string $email,
        public string $name,
    ) {}
}

Advanced: PHP 8.4 Features

<?php
declare(strict_types=1);

// Property hooks (PHP 8.4+)
class Temperature
{
    public float $celsius {
        get => $this->celsius;
        set => $value >= -273.15 ? $value : throw new \InvalidArgumentException();
    }

    public float $fahrenheit {
        get => $this->celsius * 9/5 + 32;
        set => $this->celsius = ($value - 32) * 5/9;
    }
}

Test Templates

<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;
use PHPUnit\Framework\Attributes\Test;

final class CalculatorTest extends TestCase
{
    #[Test]
    public function it_adds_two_numbers(): void
    {
        $calculator = new Calculator();
        $this->assertSame(5, $calculator->add(2, 3));
    }
}

Troubleshooting

Common Issues

Quality Metrics

Usage

Skill("php-fundamentals", {topic: "oop", level: "intermediate"})

Php Fundamentals Guide

Overview

This guide provides comprehensive documentation for the php-fundamentals skill in the custom-plugin-php plugin.

Category: General

Quick Start

Prerequisites

• Familiarity with general concepts
• Development environment set up
• Plugin installed and configured

Basic Usage

# Invoke the skill
claude "php-fundamentals - [your task description]"

# Example
claude "php-fundamentals - analyze the current implementation"

Core Concepts

Key Principles

1. Consistency - Follow established patterns 2. Clarity - Write readable, maintainable code 3. Quality - Validate before deployment

Best Practices

• Always validate input data
• Handle edge cases explicitly
• Document your decisions
• Write tests for critical paths

Common Tasks

Task 1: Basic Implementation

# Example implementation pattern
def implement_php_fundamentals(input_data):
    """
    Implement php-fundamentals functionality.

    Args:
        input_data: Input to process

    Returns:
        Processed result
    """
    # Validate input
    if not input_data:
        raise ValueError("Input required")

    # Process
    result = process(input_data)

    # Return
    return result

Task 2: Advanced Usage

For advanced scenarios, consider:

• Configuration customization via assets/config.yaml
• Validation using scripts/validate.py
• Integration with other skills

Troubleshooting

Common Issues

Related Resources

• SKILL.md - Skill specification
• config.yaml - Configuration options
• validate.py - Validation script

---

Last updated: 2025-12-30

Php Fundamentals Patterns

Design Patterns

Pattern 1: Input Validation

Always validate input before processing:

def validate_input(data):
    if data is None:
        raise ValueError("Data cannot be None")
    if not isinstance(data, dict):
        raise TypeError("Data must be a dictionary")
    return True

Pattern 2: Error Handling

Use consistent error handling:

try:
    result = risky_operation()
except SpecificError as e:
    logger.error(f"Operation failed: {e}")
    handle_error(e)
except Exception as e:
    logger.exception("Unexpected error")
    raise

Pattern 3: Configuration Loading

Load and validate configuration:

import yaml

def load_config(config_path):
    with open(config_path) as f:
        config = yaml.safe_load(f)
    validate_config(config)
    return config

Anti-Patterns to Avoid

❌ Don't: Swallow Exceptions

# BAD
try:
    do_something()
except:
    pass

✅ Do: Handle Explicitly

# GOOD
try:
    do_something()
except SpecificError as e:
    logger.warning(f"Expected error: {e}")
    return default_value

Category-Specific Patterns: General

Recommended Approach

1. Start with the simplest implementation 2. Add complexity only when needed 3. Test each addition 4. Document decisions

Common Integration Points

• Configuration: assets/config.yaml
• Validation: scripts/validate.py
• Documentation: references/GUIDE.md

---

Pattern library for php-fundamentals skill