Quote the specification to translate this sentence into English.

Reference Specifications

References (refs) in Git are pointers to commit objects, essentially files containing SHA-1 values. References are categorized into local branches, remote-tracking branches, tags, HEAD, and other types, each with specific naming conventions and usage scenarios.

Local Branch References

Local branches are stored in the .git/refs/heads/ directory and follow these naming rules:

• Must use lowercase letters, numbers, hyphens (-), and underscores (_)
• Cannot start with a hyphen
• Cannot contain consecutive dots (..)
• Cannot contain spaces or special characters

# Valid branch name examples
feature/login
bugfix/123
release_v1.2

# Invalid branch name examples
Feature/Login  # Contains uppercase letters
-bugfix        # Starts with a hyphen
hot..fix       # Contains consecutive dots

Remote-Tracking Branches

Remote-tracking branches are stored in the .git/refs/remotes/ directory and follow the format <remote>/<branch>:

• The remote name is typically origin
• Branch naming rules are the same as for local branches

# View remote branches
git branch -r

# Typical remote-tracking branch examples
origin/main
origin/develop
upstream/feature

Tag References

Tags are stored in the .git/refs/tags/ directory and are divided into lightweight tags and annotated tags:

• Lightweight tags: Direct pointers to specific commits
• Annotated tags: Full objects stored in the Git database

# Create a lightweight tag
git tag v1.0-lightweight

# Create an annotated tag
git tag -a v1.0 -m "Release version 1.0"

# Tag names typically follow semantic versioning
v1.0.0
v2.1.3-rc1

HEAD Reference

HEAD is a special reference that usually points to the currently checked-out branch:

• Stored in the .git/HEAD file
• Can be a symbolic reference (pointing to another reference) or directly point to a commit SHA-1

# View HEAD content
cat .git/HEAD
# Typical output: ref: refs/heads/main

# Detached HEAD state (directly points to a commit)
git checkout e3d5a48

Reference Log (reflog)

Git records all reference change history:

• Stored in the .git/logs/ directory
• Contains change records for branches, HEAD, and other references

# View reference log
git reflog
# Example output:
# e3d5a48 HEAD@{0}: commit: Update login page
# 82b1d7a HEAD@{1}: checkout: moving from main to feature/login

Reference Operation Commands

Common reference operation examples:

# Create a branch (essentially creating a reference)
git branch new-feature

# Delete a branch (delete a reference)
git branch -d old-feature

# Rename a branch
git branch -m old-name new-name

# View reference details
git show-ref

Reference Resolution Mechanism

Git resolves references in the following order:

1. Checks if it's a local branch (refs/heads/)
2. Checks if it's a remote-tracking branch (refs/remotes/)
3. Checks if it's a tag (refs/tags/)
4. Checks if it's a special reference (HEAD, FETCH_HEAD, etc.)

# Use rev-parse to view reference resolution results
git rev-parse main
# Output: e3d5a4876f5d4b3f9c7a2d8b6f4c3a1e9d8b7f6c

Reference Wildcards

Git supports wildcards to match multiple references:

# Delete all matching remote branches
git push origin --delete feature/*

# List all v1.x tags
git tag -l 'v1.*'

References and Hooks

Git hooks can monitor reference change events:

• pre-commit: Triggers before a commit
• post-commit: Triggers after a commit
• pre-push: Triggers before a push

#!/bin/sh
# Example pre-push hook to check branch names
while read local_ref local_sha remote_ref remote_sha
do
  if [[ $local_ref =~ "refs/heads/main" ]]; then
    echo "Error: Direct pushes to main branch are not allowed"
    exit 1
  fi
done

Reference Security Guidelines

Team collaboration reference guidelines:

1. Protect important branches (e.g., main, production)
2. Use merge requests instead of direct pushes
3. Regularly clean up stale branches
4. Use namespaces to organize branches

# Example branch protection rules
git config --add receive.denyDeleteBranch main
git config --add receive.denyNonFastForwards main

References and CI/CD Integration

Proper use of references in continuous integration:

# GitHub Actions example
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{ github.ref }}  # Uses the current branch or tag reference

Reference Performance Optimization

Optimization tips for handling large numbers of references:

# Pack references to improve performance
git pack-refs --all

# Find dangling references
git fsck --unreachable --dangling

References and Submodules

Submodules use special references to store version information:

# .gitmodules file example
[submodule "lib/core"]
    path = lib/core
    url = https://github.com/example/core.git
    branch = main  # Reference specification