コーディング・スタンダードの重要性の理解

Coding standards are like the grammar rules of programming. Just as proper grammar makes written language clear and understandable, coding standards make your code consistent and readable.

• For You: You’ll find it easier to read and update your code in the future.
• For Others: If you share your code or work in a team, others will appreciate the clarity.
• For WordPress: Since it’s open-source, many people contribute. Standards keep everything unified.

Real-World Application of Coding Standards in Teamwork

Imagine you’re working on a WordPress project as part of a large team. Everyone contributes different parts of the code—some focus on the backend, others on styling, and others on accessibility. Without consistent standards, the project can become chaotic quickly. Coding standards ensure that:

• Smooth Collaboration: When everyone follows the same rules, it’s easier for developers to read and understand each other’s work.
• Fewer Merge Conflicts: Inconsistent formatting often leads to code conflicts when merging changes. Standards minimize these conflicts, allowing the team to work more efficiently.
• Better Onboarding: New developers joining the project can quickly get up to speed by following a standardized coding style, reducing the time spent on understanding the existing code.

Consider a scenario where a developer leaves the project, and a new team member needs to take over their part. If the previous developer followed proper coding standards, the latest member can jump in quickly, maintain the code, and make improvements without needing much time to understand it.

---

WordPress PHP Coding Standards

PHP is WordPress’s core language. Following the PHP coding standards ensures that your code integrates smoothly with WordPress and is easy for others to understand.

1.PHP Tags: Always use full PHP tags <?php ?>. Avoid short tags like <? ?> because they may not work on all servers.

<?php
// Your PHP code here
?>

2.File Encoding: Save your PHP files in UTF-8 without a Byte Order Mark (BOM).

3.Line Endings: Use Unix-style line endings (\n).

4.Indentation: Use tabs for indentation (not spaces). This keeps code consistent across different editors.

Naming Conventions

1.Functions and Methods: Use lowercase letters and underscores.

function get_user_data( $user_id ) {
    // Function code
}

2.Variables: Same as functions—lowercase and underscores.

$user_name = 'John Doe';

3.Classes: Use Capitalized Words (StudlyCaps).

class UserProfile {
// Class code
}

4.Constants: All uppercase letters with underscores.

define( 'MAX_UPLOAD_SIZE', 1048576 );

Whitespace and Indentation

1.Spaces After Commas: When listing parameters or array items, include a space after each comma.

$colors = array( 'red', 'green', 'blue' );

2.Control Structures: Place a space between control keywords and the opening parenthesis.

if ( $condition ) {
    // Code
}

3.Operators: Include spaces around assignment, comparison, and logical operators.

$total = $price + $tax;
if ( $total > 100 ) {
    // Code
}

Control Structures

1.Braces Placement: Use the Allman style, where the opening brace is on a new line.

if ( $condition )
{
    // Code
}
else
{
    // Code
}

2.elseif** Keyword**: Use elseif instead of else if.

if ( $condition )
{
    // Code
}
elseif ( $other_condition )
{
    // Code
}

3.Yoda Conditions: Place the constant or literal on the left side of comparisons.

if ( true === $is_active )
{
    // Code
}

This helps prevent accidental assignment (= instead of ==).

Best Practices

1.Avoid Shorthand PHP Tags: Always use full tags for better compatibility.

2.Function Arguments: Use clear and descriptive variable names.

function calculate_total( $subtotal, $tax_rate ) {
    // Code
}

3.Sanitize Inputs: Always sanitize and validate user inputs.

$user_id = intval( $_GET['user_id'] );

4.Escape Outputs: Before outputting data, escape it to prevent security issues.

echo esc_html( $user_name );

5.Comments: Use comments to explain complex logic or important notes.

// Calculate the total price with tax

---

Inline Documentation Standards

Proper documentation makes your code easier to understand and maintain.

1.Function Comments: Before each function, include a comment block.

/**
 * Calculates the total price including tax.
 *
 * @param float $subtotal The subtotal amount.
 * @param float $tax_rate The tax rate as a decimal.
 * @return float The total price.
 */
function calculate_total( $subtotal, $tax_rate ) {
    // Function code
}

2.Parameter and Return Types: Specify the type of each parameter and the return value.

3.Inline Comments: Use them sparingly to explain complex parts of your code.

$discount = 0.0; // Initialize discount variable

---

HTML Coding Standards in WordPress

HTML is the backbone of web content. Writing clean and semantic HTML is crucial for accessibility and SEO.

General Guidelines

1.Doctype: Always start with the HTML5 doctype.

<!DOCTYPE html>

2.Language Attribute: Specify the language in the <html> tag.

<html lang="en">

3.Character Encoding: Use UTF-8 encoding.

<meta charset="UTF-8">

Structuring Your HTML

1.Semantic Elements: Use HTML5 semantic elements like <header>, <nav>, <section>, <article>, <footer>.

<header>
    <!-- Header content -->
</header>
<nav>
    <!-- Navigation links -->
</nav>
<main>
    <!-- Main content -->
</main>
<footer>
    <!-- Footer content -->
</footer>

2.Indentation: Use two spaces (or tabs if you prefer) to indent nested elements.

<ul>
    <li>Item 1</li>
    <li>Item 2</li>
</ul>

3.Attributes: Use lowercase for attribute names and wrap attribute values in double quotes.

<img src="image.jpg" alt="An awesome picture">

Best Practices

1.Accessibility: Always include alt attributes for images and use ARIA roles where appropriate.

<img src="logo.png" alt="Company Logo">

2.Self-Closing Tags: For HTML5, you don’t need to self-close void elements like <br>, <img>, <input>.

<br>
<img src="image.jpg" alt="Description">

3.Comments: Use HTML comments to explain sections of your code if necessary.

<!-- Main Navigation -->
<nav>
    <!-- Navigation links -->
</nav>

---

CSS Coding Standards in WordPress

CSS controls the presentation of your website. Writing clean and efficient CSS makes your site look good and load faster.

General Guidelines

1.Syntax: Follow standard CSS syntax—selector, braces, property-value pairs.

.class-selector {
    property: value;
}

2.Indentation: Use two spaces (or tabs) for indentation inside rules.

3.Comments: Use comments to separate sections and explain complex rules.

/* Header Styles */
header {
    /* Properties */
}

Writing Clean CSS

1.Selector Names: Use lowercase letters and hyphens.

.main-navigation {
    /* Styles */
}

2.Avoid IDs for Styling: Use classes instead of IDs to keep specificity low.

/* Correct */
.button {
    /* Styles */
}

/* Avoid */
#submit-button {
    /* Styles */
}

3.Shorthand Properties: Use shorthand properties where possible.

/* Correct */
margin: 10px 5px 15px 0;

/* Expanded */
margin-top: 10px;
margin-right: 5px;
margin-bottom: 15px;
margin-left: 0;

4.Zero Values: Omit units for zero values.

padding: 0;

Best Practices

1.Organize Styles: Group related styles together, such as layout, typography, colors.

2.Comments for Sections: Use comments to divide your stylesheet into sections.

/* Typography / / カラー / / Layout */

3.Avoid !important: Use specificity instead of !important to override styles.

4.Media Queries: Place media queries near the related styles or in a separate section.

@media (max-width: 768px) {
    .main-navigation {
        display: none;
    }
}

---

Recommended Tools and Plugins

To help ensure you are following WordPress coding standards, consider using the following tools:

1. PHP CodeSniffer: This tool can help detect violations of WordPress PHP coding standards. You can use it with the WordPress Coding Standards ruleset to automatically check your code.
2. EditorConfig: Many IDEs and code editors support .editorconfig files, which help maintain consistent coding styles between different editors and developers.
3. ESLint and Stylelint: Use these tools to lint JavaScript and CSS to catch common mistakes and enforce consistency.
4. Prettier: A code formatter that can automatically enforce consistent style for HTML, CSS, and JavaScript, making it easier for teams to maintain a unified code style.
5. VSCode Extensions:
   • PHP Intelephense: Provides intelligent autocomplete and function hinting and detects potential issues.
   • WordPress Snippets: A collection of commonly used WordPress functions and snippets to speed up development.

---

Common Errors to Avoid

1.Inconsistent Naming: Mixing camelCase and snake_case can lead to confusion, so stick to the prescribed naming conventions throughout your project.

2.Not Escaping Output: Always escape user-generated content before outputting it to prevent security vulnerabilities like XSS.

// Correct
echo esc_html( $user_input );

// Incorrect
echo $user_input;

3.Improper Use of Globals: Avoid using global variables unless necessary. Instead, pass variables explicitly to functions to keep your code modular and more accessible to test.

4.Using Inline Styles: Inline styles should be avoided as they make it harder to maintain and override CSS. Always use external stylesheets.

---

Putting It All Together

Let’s look at an example that combines PHP, HTML, and CSS following WordPress coding standards.

Example: A Simple PHP Template

PHP File (template-example.php):

<?php
/**
 * Template Name: Example Template
 *
 * A template to demonstrate coding standards.
 *
 * @package WordPress
 * @subpackage Your_Theme
 */

get_header(); ?>

<main id="main-content" class="site-main">
    <?php
    if ( have_posts() ) :
        while ( have_posts() ) :
            the_post(); ?>

            <article id="post-<?php the_ID(); ?>" no numeric noise key 1006>
                <header class="entry-header">
                    <?php the_title( '<h1>', '</h1>' ); ?>
                </header>

                <div class="entry-content">
                    <?php the_content(); ?>
                </div>
            </article>

        <?php endwhile;
    else : ?>

        <p><?php esc_html_e( 'Sorry, no posts matched your criteria.', 'your-text-domain' ); ?></p>

    <?php endif; ?>
</main>

<?php get_footer(); ?>

CSS File (style.css):

/* Main Content Styles */
.site-main {
    margin: 0 auto;
    max-width: 800px;
    padding: 20px;
}

.entry-header h1 {
    font-size: 2em;
    margin-bottom: 0.5em;
}

.entry-content {
    line-height: 1.6;
}

---

Additional Resources

• WordPress Developer Handbook: developer.wordpress.org
• PHP Documentation: php.net
• Mozilla Developer Network (MDN) Web Docs:
  • HTML
  • CSS
  • JavaScript
• W3C Markup Validation Service: validator.w3.org
• WordPress Coding Standards:
  • PHP Standards
  • HTML Standards
  • CSS Standards

---

結論

Following WordPress coding standards ensures your code is clean, consistent, and professional. This helps you maintain your projects and makes it easier for others in the WordPress community to collaborate with you.

Remember:

• Practice Makes Perfect: The more you code following these standards, the more natural it will become.
• Stay Updated: Coding standards evolve, so keep an eye on the official WordPress documentation.
• Ask for Help: If you need clarification, the WordPress community is friendly and willing to help.

Happy coding!