変数・関数(メソッド)・クラス名接頭辞・接尾辞チートシート

みなさんコーディング中に**変数・関数(メソッド)・クラスの名前**を悩みませんか？また，プロジェクト内で命名規則を定めたいケースはありますか？本記事では、変数、関数、クラス等の識別子に用いられる接頭辞および接尾辞の種類を従来よりもさらに豊富に紹介する．
各要素の命名規則はコードの可読性および保守性を向上させる重要な要素であり，ここで紹介する使用例を参考に，プロジェクトやチームごとのルールに合わせた統一的な命名を実践していただきたい．

# 他のチートシート
git/gh コマンド(gitコマンド以外にもgitの概念も書いてあります)

https://qiita.com/JavaLangRuntimeException/items/6b46551f56e0def76eba

lazygit

https://qiita.com/JavaLangRuntimeException/items/42087d09728d5739d73d

Docker コマンド(dockerコマンド以外にもdockerの概念の記事へのリンクもあります)

https://qiita.com/JavaLangRuntimeException/items/21f7c7bf3d143f821697

ステータスコード

https://qiita.com/JavaLangRuntimeException/items/ab1bc7b976ed2dfad91c

TypeScript

https://qiita.com/JavaLangRuntimeException/items/5894391c08e0d8e28389

Go/Gorm

https://qiita.com/JavaLangRuntimeException/items/d388717fc1436bc3ec9d


Ruby・Ruby on Rails

https://qiita.com/JavaLangRuntimeException/items/42d935cf92c212f1c7ec

SQL

https://qiita.com/JavaLangRuntimeException/items/f038fbaccdd92fb0308a

Vim

https://qiita.com/JavaLangRuntimeException/items/0c68ab96ea198e0a7294

プルリクエスト・マークダウン記法チートシート

https://qiita.com/JavaLangRuntimeException/items/329eb92a47a07ff4dde8

ファイル操作コマンドチートシート

https://qiita.com/JavaLangRuntimeException/items/16f244606a73f7d106e4

VSCode Github Copilot拡張機能

https://qiita.com/JavaLangRuntimeException/items/be13dc3a346cf6e5ee44

OpenAI Assistants API

https://qiita.com/JavaLangRuntimeException/items/1a1abc01e8d7d05dce93

GitHub API

https://qiita.com/JavaLangRuntimeException/items/ab1bc7b976ed2dfad91c


# 他のシリーズ記事

**TypeScriptで学ぶプログラミングの世界**
プログラミング言語を根本的に理解するシリーズ

https://qiita.com/JavaLangRuntimeException/items/cadf49bb419076819963

**情報処理技術者試験合格への道[IP・SG・FE・AP]**
情報処理技術者試験に出題されるコンピュータサイエンス用語の紹介や単語集

https://qiita.com/JavaLangRuntimeException/items/991be402099542ccb936

**Project Gopher: Unlocking Go’s Secrets**
Go言語や標準ライブラリの深掘り調査レポート

https://qiita.com/JavaLangRuntimeException/items/dc45b412d3fbd2ccb9e8


# 1. 変数の命名規則

変数は扱うデータの性質や役割を的確に表現する必要がある．

## 1.1 変数の接頭辞一覧

| 接頭辞 | 意味                                             | 採用例                                        |
| ------ | ------------------------------------------------ | --------------------------------------------- |
| is     | 真偽値を示し、状態や条件を表す                   | isActive, isEnabled, isVisible                |
| has    | 保有しているかどうかを示す                       | hasAccess, hasItems, hasError                 |
| can    | 可能性・許可の有無を示す                         | canExecute, canSave, canLoad                  |
| m      | クラスのメンバー変数であることを示す             | mUserName, mAccountBalance                    |
| s      | 静的変数／クラス変数であることを示す             | sInstanceCount, sConfig                       |
| g      | グローバル変数を示す                             | gHttpClient, gUserSettings                    |
| n      | 数値型であることを強調する                       | nCount, nTotal, nIndex                        |
| str    | 文字列型であることを明示する                     | strName, strMessage, strUrl                   |
| lst    | リストまたは配列の集合であることを示す           | lstItems, lstRecords                          |
| dict   | 辞書型またはマッピングを扱う変数であることを示す   | dictUserData, dictConfig                      |
| p      | ポインタ型（C/C++等）を示す                      | pBuffer, pData                                |
| obj    | オブジェクト型であることを示す                   | objUser, objCar                               |
| fn     | 関数やコールバック関数を保持する変数として示す   | fnCallback, fnProcessor                       |

### 使用例

#### is
JavaScript  
```js
let isActive = true;  
```
Python
```py
isValid = True
```
Java
```java
boolean isComplete = false;
```
#### has

JavaScript  
```js
const hasItems = (items.length > 0);  
Ruby
```rb
has_errors = errors.any?  
```
Java  
```java
boolean hasAccess = user.hasAccess();
```
#### can

Python
```py
def canExecute(task):  
return task.is_ready()  
```
TypeScript  
```ts
const canSave: boolean = checkSavePermission(); 
```
C#  
```cs
bool canLoad = loader.CanLoad();
```
#### m
C++  
```cpp
class User {  
private:  
    std::string mUserName;  
};  
```
Java  
```java
private String mPassword;  
```
C#  
```cs
private int mAge;
```

#### s
Java  
```java
public static int sInstanceCount = 0;
```
C++  
```cpp
static int sCounter;
```
C#  
```cs
public static string sConfig = "Default";
```

#### g
C  
```c
int gHttpClient = initializeClient();  
```
JavaScript 
```js
var gUserSettings = {};
```
PHP  
```php
$gConnection = connectDB();
```

#### n
Java  
```java
int nTotal = 100; 
```
JavaScript  
```js
let nIndex = 0;  
```
C#  
```cs
int nCount = 42;
```

#### str

JavaScript
```js
const strMessage = "Hello World"; 
```
Python  
```py
strTitle = "Welcome"  
```
Java  
```java
String strUrl = "https://example.com";
```

#### lst 
Python
```py
lstItems = [1, 2, 3]
```
JavaScript 
```js
let lstRecords = [record1, record2];  
```
Java (ArrayList使用) 
```java
List<String> lstNames = new ArrayList<>();
```

#### dict
Python  
```py
dictConfig = {"mode": "dark", "timeout": 30} 
```
JavaScript (オブジェクトとして)  
```js
const dictUserData = {name: "Alice", age: 25};
```
C# (Dictionary使用)  
```cs
Dictionary<string, int> dictScores = new Dictionary<string, int>();
```

#### p  
C/C++ 
```c
int* pData = &data;  
```
Objective-C  
```obj-c
id *pObject = &object;
```

#### obj
JavaScript
```js
let objUser = { name: "Bob", age: 30 }; 
```
Java  
```java
Object objCar = new Car();
```

#### fn
JavaScript  
```js
const fnCallback = () => { console.log("Called back"); }; 
```
Python  
```py
fn_processor = lambda x: x * 2;
```
---

### 1.2 変数の接尾辞一覧

| 接尾辞 | 意味                                  | 採用例                                        |
| ------ | ------------------------------------- | --------------------------------------------- |
| Count  | 個数や数量を示す                      | userCount, errorCount                         |
| List   | リストまたはコレクションであることを示す | productList, orderList                        |
| Array  | 配列であることを示す                  | scoreArray, dataArray                         |
| Map    | キーと値の対応を示すマッピング         | configMap, routeMap                           |
| Id     | 識別子を示す                         | userId, orderId, productId                      |
| Flag   | 真偽情報を示すフラグ                  | errorFlag, debugFlag, retryFlag               |
| Num    | 数値型であることを示す                | ageNum, countNum                              |
| Val    | 値や結果を示す                        | totalVal, tempVal                             |
| Ptr    | ポインタ型（C/C++等）を示す             | bufferPtr, dataPtr                            |

**使用例：**

#### Count
Java  
```java
int userCount = users.size();
```
Python
```py
item_count = len(items)  
```
JavaScript
```js
const errorCount = errors.length;
```

#### List 
Python
```py
userList = ["Alice", "Bob", "Charlie"]  
```
JavaScript  
```js
let productList = ["Laptop", "Tablet", "Smartphone"];  
```
Java (ArrayList 使用)  
```java
List<Order> orderList = new ArrayList<>();
```

#### Array
JavaScript  
```js
const scoreArray = [95, 82, 77]; 
```
Java 
```java
int[] dataArray = {1, 2, 3, 4};  
```
C#
```cs
string[] idArray = new string[] { "ID1", "ID2", "ID3" };
```

#### Map
Java 
```java
Map<String, String> configMap = new HashMap<>(); 
```
Python (辞書として)
```py
user_map = {"Alice": 25, "Bob": 30}
```
C#
```cs
Dictionary<int, string> routeMap = new Dictionary<int, string>();
```

#### Id 
C# 
```cs
int userId = 1001;
```
JavaScript 
```js
const orderId = "ORD12345"; 
```
PHP
```php
$productId = 987;
```

#### Flag
C  
```c
bool errorFlag = false;
```
JavaScript
```js
let debugFlag = true;  
```
Python
```py
retry_flag = False;
```

#### Num  
Java
```java
int ageNum = 30;
```
JavaScript
```js
let countNum = 5;
```
C#
```cs
int scoreNum = 88;
```

#### Val 
JavaScript  
```js
const totalVal = price * quantity;
```
Python
```py
temp_val = calculate_value()
```
Java
```java
double resultVal = computeResult();
```

#### Ptr  
C/C++
```cpp
char* bufferPtr = malloc(256);
```
Objective-C
```objc
id *objectPtr = &obj;
```

---

## 2. 関数の命名規則

関数（またはメソッド）は、実行する動作や処理内容を明確に命名する必要があるである．

### 2.1 関数の接頭辞一覧

| 接頭辞     | 意味                                         | 採用例                                          |
| ---------- | -------------------------------------------- | ----------------------------------------------- |
| get        | データの取得処理を示す                       | getUserInfo, getAccountDetails                  |
| set        | データの設定処理を示す                       | setUserName, setConfiguration                   |
| update     | 更新処理を示す                               | updateRecord, updateUserData                    |
| calculate  | 計算処理を示す                               | calculateTotal, calculateDiscount               |
| process    | 入力やデータ処理を示す                       | processInput, processOrder                      |
| fetch      | 外部ソースからの取得処理を示す               | fetchData, fetchResults                         |
| init       | 初期化処理を示す                             | initValues, initConfiguration                   |
| create     | 新規作成を示す                               | createUser, createRecord                        |
| build      | オブジェクトや構造の構築を示す               | buildQuery, buildUserProfile                    |
| load       | データの読み込みを示す                       | loadData, loadConfiguration                     |
| save       | データの保存処理を示す                       | saveUser, saveRecord                            |
| delete     | データの削除処理を示す                       | deleteUser, deleteRecord                        |
| validate   | 入力やデータの検証処理を示す                 | validateInput, validateForm                     |
| format     | データのフォーマット処理を示す               | formatDate, formatMessage                       |
| filter     | 指定条件によるデータの抽出処理を示す         | filterItems, filterResults                      |

### 使用例

#### get 
JavaScript
```js
function getUserInfo(userId) {  
// ユーザー情報の取得処理である  
return database.getUserById(userId);  
} 
```
Python
```py
def get_account_details(account_id):  
# アカウント情報を取得する処理である  
return db.fetch_account(account_id)
```

#### set
Python
```py
def set_user_name(user, name):  
user.name = name  
```

Java
```java
public void setConfiguration(Config config) {  
this.config = config;  
}
```

#### update  
Java
```java
public void updateRecord(Record record) {  
// レコード更新処理である  
} 
```
C++
```cpp
void updateUserData(User &user) {  
    // ユーザーデータの更新処理である  
}
```

#### calculate  
C++ 
```cpp
double calculateTotal(double price, int quantity) {  
return price * quantity;  
}
```
JavaScript  
```js
function calculateDiscount(price, rate) {  
return price * rate;  
}
```

#### process
C#  
```cs
void processInput(string input) {  
// 入力データの処理である  
} 
```
Python
```py
def process_order(order):  
# 注文情報の処理である  
return order.process()
```

#### fetch  
Python
```py
def fetchData(url):  
# URLからデータを取得する処理である  
return requests.get(url)
```
TypeScript
```ts
function fetchResults(apiEndpoint: string): Promise<any> {  
return fetch(apiEndpoint).then(res => res.json());  
}
```
#### init
JavaScript
```js
function initValues() {  
// 初期値設定処理である  
return { count: 0, items: [] };  
}  
```
Java
```java
public void initConfiguration() {  
// 設定初期化の処理である  
}
```

#### create 
Ruby 
```ruby
def create_user(name, email)  
# ユーザー生成処理である  
User.new(name, email)  
end  
```
C#
```cs
User createRecord(string data) {  
// レコード作成処理である  
return new User(data);  
}
```

#### build  
JavaScript
```js
function buildQuery(params) {  
// クエリ文字列生成処理である  
return Object.keys(params).map(key => key + "=" + params[key]).join("&");  
} 
```
Java
```java
public Query buildUserProfile(User user) {  
// ユーザープロファイルの構築処理である  
return new Query(user);  
}
```

#### load  
JavaScript  
```js
function loadData(sourceUrl) {  
// データ読み込み処理である  
return fetch(sourceUrl);  
} 
```
Python
```py
def load_configuration(file_path):  
# 設定ファイルの読み込み処理である  
with open(file_path) as f:  
    return json.load(f)
```

#### save
JavaScript
```js
function saveRecord(record) {  
// レコード保存処理である  
database.save(record);  
}  
```
C#  
```cs
void saveUser(User user) {  
// ユーザー情報の保存処理である  
}
```

#### delete
Java 
```java
public void deleteUser(int userId) {  
// ユーザー削除処理である  
}  
```
Python
```py
def delete_record(record_id):  
# レコード削除処理である  
db.delete(record_id)
```

#### validate
JavaScript
```js
function validateInput(input) {  
// 入力値検証処理である  
return input !== "";  
}  
```
Python
```py
def validate_form(data):  
# フォームデータ検証処理である  
return all(data.values())
```

#### format  
Python 
```py
def format_date(date_obj):  
# 日付フォーマット処理である  
return date_obj.strftime("%Y-%m-%d")
```
JavaScript
```js
function formatMessage(msg) {  
// メッセージフォーマット処理である  
return msg.trim();  
}
```

#### filter
JavaScript
```js
function filterItems(items, predicate) {  
// 条件によるリストフィルタリング処理である  
return items.filter(predicate);  
}  
```
Python
```py
def filter_results(results, condition):  
# 結果のフィルタリング処理である  
return [r for r in results if condition(r)];
```
---

### 2.2 関数の接尾辞一覧

| 接尾辞   | 意味                                       | 採用例                                        |
| -------- | ------------------------------------------ | --------------------------------------------- |
| Handler  | イベントハンドラや応答処理を示す             | clickHandler, keyPressHandler                 |
| Callback | コールバック用の関数を示す                 | loadCallback, errorCallback                   |
| Function | 汎用的な処理関数を示す                     | renderFunction, computeFunction               |
| Async    | 非同期処理で動作する関数を示す             | fetchDataAsync, processAsync                  |
| Sync     | 同期処理を明示する関数の名称として示す       | updateSync, loadSync                          |

### 使用例

#### Handler
JavaScript
```js
function clickHandler(event) {  
    // クリックイベント処理である  
    console.log("クリックされました");  
}  
```
C#  
```cs
void keyPressHandler(object sender, KeyEventArgs e) {  
    // キー入力イベント処理である  
}
```

#### Callback  
Node.js 
```js
function loadCallback(err, data) {  
    if (err) {  
        console.error(err);  
        return;  
    }  
    console.log("データ読み込み成功：", data);  
}  
```
JavaScript
```js
const errorCallback = (error) => {  
    console.error("エラー発生：", error);  
};
```

#### Function 
Java
```java
public void renderFunction() {  
    // UIレンダリング処理である  
}  
```
Python
```py
def compute_function(x, y):  
    # 計算処理である  
    return x + y
```
 
#### Async  
JavaScript (async/await) 
```js
async function fetchDataAsync(url) {  
    const response = await fetch(url);  
    return await response.json();  
}  
```
Python (asyncio)
```py
async def process_async(data):  
    # 非同期処理を実行するである  
    await asyncio.sleep(1);  
    return data;
```
#### Sync
Java 
```java
public void loadSync() {  
    // 同期処理でデータ読み込みを行うである  
} 
```
Python 
```py
def update_sync(record):  
    # 同期的に更新処理を行うである  
    record.update();
```
---

## 3. クラスの命名規則

クラス名はそのクラスが表す概念や役割を明確に示すため、通常はパスカルケース（UpperCamelCase）で記述するである．

### 3.1 クラスの接頭辞一覧

| 接頭辞   | 意味                                               | 採用例                                              |
| -------- | -------------------------------------------------- | --------------------------------------------------- |
| Abstract | 抽象クラスであることを示す                         | AbstractController, AbstractShape                   |
| I        | インターフェイスを示す（主に C# や Java で採用）   | IUserService, IAccountManager                        |
| Base     | 共通機能／基底クラスを示す                         | BaseController, BaseModel                           |
| Mock     | モックまたはテスト用の実装を示す                   | MockUserService, MockRepository                     |
| Fake     | 疑似実装（テストダブル）を示す                     | FakePaymentGateway, FakeUserRepository              |
| Stub     | スタブ実装を示す                                   | StubEmailService, StubLogger                        |

### 使用例

#### Abstract
Java 
```java
public abstract class AbstractController {  
    public abstract void handleRequest();  
}  
```
C++  
```cpp
class AbstractShape {  
public:  
    virtual double calculateArea() = 0;  
};
```

#### I
C#
```cs
public interface IUserService {  
    User GetUserInfo(int userId);  
}  
```
Java
```java
public interface IAccountManager {  
    void manageAccount();  
}
```

#### Base
JavaScript
```js
class BaseController {  
    constructor() {  
        // 共通の初期化処理である  
    }  
} 
```
PHP 
```php
    class BaseModel {  
        protected $db;  
        public function __construct($db) {  
            $this->db = $db;  
        }  
    }
```
#### Mock
JavaScript (テスト用)
```js
class MockUserService {  
    getUser() {  
        return { id: 1, name: "Test User" };  
    }  
}  
```
Java
```java
public class MockRepository {  
    // モック実装である  
}
```

#### Fake
Java
```java
public class FakePaymentGateway {  
    // 疑似的な支払い処理を実装するである  
}  
```
Python
```py
class FakeUserRepository:  
    def get_user(self, user_id):  
        return {"id": user_id, "name": "Fake User"}
```

#### Stub  
JavaScript 
```js
class StubLogger {  
    log(message) {  
        // ログ出力のスタブ実装である  
    }  
} 
```
Python
```py
class StubEmailService:  
    def send_email(self, to, subject, body):  
        # スタブ実装でメール送信を模倣するである  
        pass;
```
---

### 3.2 クラスの接尾辞一覧

| 接尾辞      | 意味                                               | 採用例                                                |
| ----------- | -------------------------------------------------- | ----------------------------------------------------- |
| Manager     | 管理や統括の役割を持つクラスを示す                   | UserManager, SessionManager                           |
| Controller  | 制御や調整を行うクラスを示す                         | MainController, LoginController                       |
| Service     | ビジネスロジックやサービス提供を行うクラスを示す       | PaymentService, EmailService                          |
| Helper      | 補助的な機能を提供するクラスを示す                   | DateHelper, StringHelper                              |
| Repository  | データの永続化やアクセスを行うクラスを示す           | UserRepository, ProductRepository                     |
| Exception   | 例外処理を表すクラスである                           | CustomException, DatabaseException                    |
| Model       | エンティティやデータモデルを示すクラスである         | UserModel, ProductModel                               |
| View        | ユーザーインターフェイス（UI）表示を行うクラスである   | UserView, ProductView                                 |
| Factory     | オブジェクト生成を担うクラスを示す                   | UserFactory, ConnectionFactory                        |
| Adapter     | インターフェイス変換や適合処理を行うクラスを示す       | JsonAdapter, XmlAdapter                               |
| Decorator   | 既存オブジェクトに機能追加するクラスを示す             | LoggingDecorator, CachingDecorator                    |
| Strategy    | 戦略パターンの実装を行うクラスを示す                 | SortingStrategy, CompressionStrategy                  |
| Singleton   | 単一インスタンス生成を保証するクラスである           | LoggerSingleton, ConfigSingleton                      |
| Util        | 補助的なユーティリティ機能を提供するクラスを示す       | StringUtil, DateUtil                                  |

### 使用例

#### Manager 
Java 
```java
public class UserManager {  
    // ユーザー管理処理の実装である  
}  
```
Python 
```py
class SessionManager:  
    def __init__(self):  
        self.sessions = {}  
```
C# 
```cs
public class ResourceManager {  
    // リソース管理処理を実装するである  
}
```

#### Controller  
JavaScript (React コンポーネントとして)
```js
class MainController extends React.Component {  
    render() {  
        return (<div>Main Controller</div>);  
    }  
}  
```
Java (Spring MVC 惣例)  
```java
@Controller  
public class LoginController {  
    // ログイン制御処理である  
}
```

#### Service
Ruby
```rb
class PaymentService  
  def process_payment(amount)  
    # 決済処理を実装するである  
  end  
end  
```
C#  
```cs
public class EmailService {  
    public void SendEmail(string recipient) {  
        // メール送信処理を実装するである  
    }  
}
```

#### Helper
PHP  
```php
class DateHelper {  
    public static function format($date) {  
        return date("Y-m-d", strtotime($date));  
    }  
}
```
JavaScript
```js
class StringHelper {  
    static toUpperCase(str) {  
        return str.toUpperCase();  
    }  
}
```

#### Repository
Java
```java   
public class UserRepository {  
    public User findUserById(int id) {  
        // ユーザー検索処理を実装するである  
        return new User();  
    }  
}  
```
C#  
```cs
public class ProductRepository {  
    public Product GetProduct(int id) {  
        // 製品情報取得処理を実装するである  
        return new Product();  
    }  
}
```

#### Exception
Python  
```py
class CustomException(Exception):  
    pass
```
Java  
```java
public class DatabaseException extends Exception {  
    public DatabaseException(String message) {  
        super(message);  
    }  
}
```

#### Model
Java 
```java
public class UserModel {  
    private String userName;  
    // ゲッターおよびセッターを実装するである  
}  
```
C#  
```cs
public class ProductModel {  
    public int Id { get; set; }  
    public string Name { get; set; }  
}
```

#### View
JavaScript (React コンポーネントとして)  
```js
class UserView extends React.Component {  
    render() {  
        return (<div>User Information</div>);  
    }  
}  
```
PHP (MVC の View クラスとして) 
```php
class ProductView {  
    public function render() {  
        // 製品情報表示処理を実装するである  
    }  
}
```
#### Factory
Java  
```java
public class UserFactory {  
    public User createUser(String name) {  
        return new User(name);  
    }  
}  
```
Python  
```py
class ConnectionFactory:  
    def create_connection(self):  
        # コネクション生成処理である  
        pass;
```

#### Adapter
JavaScript  
```js
class JsonAdapter {  
    convert(jsonData) {  
        // JSONデータを目的の形式に変換するである  
        return JSON.parse(jsonData);  
    }  
} 
```
Java
```java
public class XmlAdapter {  
    public Document convert(String xmlData) {  
        // XMLデータ変換処理である  
        return parseXml(xmlData);  
    }  
}
```

#### Decorator
JavaScript 
```js
class LoggingDecorator {  
    constructor(component) {  
        this.component = component;  
    }  
    execute() {  
        console.log("実行前のログ出力");  
        this.component.execute();  
        console.log("実行後のログ出力");  
    }  
}  
```
Java  
```java
public class CachingDecorator extends DataService {  
    private DataService service;  
    public CachingDecorator(DataService service) {  
        this.service = service;  
    }  
    public Data getData() {  
        // キャッシュ利用のロジックを実装するである  
        return service.getData();  
    }  
}
```

#### Strategy  
Java 
```java
public interface SortingStrategy {  
    void sort(int[] numbers);  
}  
public class QuickSortStrategy implements SortingStrategy {  
    public void sort(int[] numbers) {  
        // クイックソートの実装である  
    }  
}
```

#### Singleton 
Java  
```java
public class LoggerSingleton {  
    private static LoggerSingleton instance = new LoggerSingleton();  
    private LoggerSingleton() {}  
    public static LoggerSingleton getInstance() {  
        return instance;  
    }  
}  
```
C# 
```cs
public sealed class ConfigSingleton {  
    private static readonly ConfigSingleton instance = new ConfigSingleton();  
    private ConfigSingleton() {}  
    public static ConfigSingleton Instance {  
        get { return instance; }  
    }  
}
```

#### Util
JavaScript  
```js
    class StringUtil {  
        static trim(str) {  
            return str.replace(/^\s+|\s+$/g, "");  
        }  
    } 
```
Java  
```java
public final class DateUtil {  
    private DateUtil() {}  
    public static String formatDate(Date date) {  
        // 日付フォーマット処理である  
        return new SimpleDateFormat("yyyy-MM-dd").format(date);  
    }  
}
```

---

本記事では、変数、関数、クラスにおける従来の接頭辞・接尾辞に加え、さらに多様な種類の接頭辞および接尾辞を紹介しました．．  
識別子において接頭辞や接尾辞を効果的に用いることは、各構成要素の役割やデータの性質を明確に伝えるために有用であり、コードの一貫性と保守性を大いに高めるであろう．  
プロジェクトやチームごとのルールに合わせ、ここで紹介した豊富な使用例を参考に、一層洗練された命名規則の整備を実践していただきたい．