├── .gitattributes ├── CONTRIBUTING.md └── README.ja.md /.gitattributes: -------------------------------------------------------------------------------- 1 | *.md whitespace=trailing-space,tab-in-indent 2 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | * [Fork](https://help.github.com/articles/fork-a-repo) the project on GitHub. 2 | * Make your feature addition or bug fix in a feature branch. (Include a description of your changes) 3 | * Push your feature branch to GitHub. 4 | * Send a [Pull Request](https://help.github.com/articles/using-pull-requests). -------------------------------------------------------------------------------- /README.ja.md: -------------------------------------------------------------------------------- 1 | # はじめに 2 | 3 | > ロールモデルが重要なのだ。
4 | > -- アレックス・マーフィー巡査 / ロボコップ 5 | 6 | Rubyディベロッパーとして、私は常にあることに悩まされてきました — 7 | Pythonにはプログラミングスタイルのすばらしい基準 ([PEP-8][]) がある一方で、 8 | Rubyにはコーディングスタイルやベストプラクティスに関する公式のガイドがこれまで存在してきませんでした。 9 | 私にはスタイルは重要なことだとしか思われないのにです。 10 | Rubyが持っているような素晴らしいハッカーコミュニティは、 11 | 誰もが羨むようなドキュメントを作り出す力があるはずなのにです。 12 | 13 | このガイドは、私達の社内製Rubyコーディング規約から生まれました 14 | (著者は[私](https://github.com/bbatsov))。 15 | しかし仕事をするうちに、自分の仕事はRubyコミュニティの人たち全員に興味を持ってもらえるものではないかと思い始めました。 16 | また、内製コーディング規約といったものをこの惑星はこれ以上必要としていないのではないかとの思いもありました。 17 | そうではない、コミュニティ駆動の、コミュニティに認められた、 18 | Rubyのための慣習、語法、スタイル規定は、 19 | 確実にRubyコミュニティに有益たりえると確信したのです。 20 | 21 | このガイドを公開して以来、私は世界中の優れたRubyコミュニティのメンバーから、 22 | たくさんのフィードバックを受けています。 23 | 全ての提案、サポートに感謝します！ 24 | お互いに、また全てのRubyディベロッパーにとって有益なリソースを、 25 | 一緒に作ることができています。 26 | 27 | また、もしあなたがRailsのことに興味があるなら、 28 | こちらの補足も確認してみてください。 29 | [Ruby on Rails Style Guide][rails-style-guide]. 30 | 31 | # The Ruby Style Guide 32 | 33 | このRubyスタイルガイドでおすすめしているベストプラクティスは、実在のRubyプログラマが他の実在のRubyプログラマのために、メンテナンスしやすいコードを書いていくためのものです。 34 | 実社会での使われ方を反映したスタイルガイドは、実社会で使われるし、 35 | たとえそれがどんなに素晴らしい理想であっても、 36 | 利用者が拒絶するようなスタイルに固執するスタイルガイドは結局全く使われなくなる危険性があります。 37 | 38 | このガイドは、関連するルールごとにいくつかのセクションに分かれています。 39 | ルールの後ろにその根拠も付け加えるように努めています 40 | (そのような根拠が省略されているときは、自明のものと判断したとお考えください)。 41 | 42 | 私はこれら全てのルールをどこからともなく考えついたわけではありません — 43 | これらのほとんどは、私の職業SEとしての長い経験と、 44 | Rubyコミュニティのメンバーからの意見や提案、 45 | また、["Programming Ruby"][pickaxe]や、 46 | ["The Ruby Programming Language"][trpl]のような、 47 | 様々な評価の高いRubyプログラミング関連資料に基づいています。 48 | 49 | Rubyコミュニティ内でもスタイルについての統一見解が存在しないという領域もいくらか存在します 50 | (文字列リテラルの引用記号、ハッシュリテラルの内側のスペース、複数行のメソッドチェーンのドットの位置、などなど)。 51 | そのようなシナリオでは、いずれの有力なスタイルも許容されるので、 52 | どれを選んで、一貫して用いるかはあなた次第です。 53 | 54 | 新たな慣習が生まれたり、Ruby自身が変化することで慣習が時代遅れになったりしたことに従いながら、このガイドは時代とともに進化してきました。 55 | 56 | 多くのプロジェクトは、それ自身のコーディング規約を持っています 57 | (しばしばこのガイドを基に生成されています)。 58 | ルールの衝突が発生した場合は、 59 | そのプロジェクトにおいては、プロジェクト固有のガイドを優先してください。 60 | 61 | このガイドのPDFやHTMLのコピーは[Pandoc][]を使って生成できます。 62 | 63 | [RuboCop][]は、 64 | このスタイルガイドに基づいたコード分析器です。 65 | 66 | 以下の言語の翻訳が利用可能です: 67 | 68 | * [中国語(簡体)](https://github.com/JuanitoFatas/ruby-style-guide/blob/master/README-zhCN.md) 69 | * [中国語(繁体)](https://github.com/JuanitoFatas/ruby-style-guide/blob/master/README-zhTW.md) 70 | * [アラビア語エジプト方言](https://github.com/HassanTC/ruby-style-guide/blob/master/README-EgAr.md) 71 | * [フランス語](https://github.com/gauthier-delacroix/ruby-style-guide/blob/master/README-frFR.md) 72 | * [日本語](https://github.com/fortissimo1997/ruby-style-guide/blob/japanese/README.ja.md) 73 | * [韓国語](https://github.com/dalzony/ruby-style-guide/blob/master/README-koKR.md) 74 | * [ポルトガル語 (pt-BR)](https://github.com/rubensmabueno/ruby-style-guide/blob/master/README-PT-BR.md) 75 | * [ロシア語](https://github.com/arbox/ruby-style-guide/blob/master/README-ruRU.md) 76 | * [スペイン語](https://github.com/alemohamad/ruby-style-guide/blob/master/README-esLA.md) 77 | * [ベトナム語](https://github.com/CQBinh/ruby-style-guide/blob/master/README-viVN.md) 78 | 79 | ## 目次 80 | 81 | * [レイアウト](#レイアウト) 82 | * [構文](#構文) 83 | * [命名規則](#命名規則) 84 | * [コメント](#コメント) 85 | * [注釈](#注釈) 86 | * [マジックコメント](#マジックコメント) 87 | * [クラスとモジュール](#クラスとモジュール) 88 | * [例外](#例外) 89 | * [コレクション](#コレクション) 90 | * [数値](#数値) 91 | * [文字列](#文字列) 92 | * [日時](#日時) 93 | * [正規表現](#正規表現) 94 | * [パーセントリテラル](#パーセントリテラル) 95 | * [メタプログラミング](#メタプログラミング) 96 | * [雑則](#雑則) 97 | * [ツール](#ツール) 98 | 99 | ## レイアウト 100 | 101 | > ほとんどすべての人が、彼ら自身のものを除くすべてのスタイルが 102 | > 醜くて、読むに耐えないと確信している。 103 | > 「彼ら自身のものを除く」を除けば、おそらく正しいのだが… 104 | > -- Jerry Coffin (インデントについて) 105 | 106 | * 107 | ソースファイルのエンコーディングには`UTF-8`を用いましょう。 108 | ^{[[link](#utf-8)]} 109 | 110 | * 111 | インデントには **スペース** 2つを用いましょう(別名ソフトタブ)。ハードタブを用いてはいけません。 112 | ^{[[link](#spaces-indentation)]} 113 | 114 | ```ruby 115 | # 悪い例 - 4つのスペース 116 | def some_method 117 | do_something 118 | end 119 | 120 | # 良い例 121 | def some_method 122 | do_something 123 | end 124 | ``` 125 | 126 | * 127 | Unix-styleの改行にしましょう。 128 | (\*BSD/Solaris/Linux/macOS ユーザーはデフォルトで設定されています。 129 | Windows ユーザーは特に注意が必要です。) 130 | ^{[[link](#crlf)]} 131 | 132 | * もしGitを使っていれば、プロジェクトにWindowsの改行が紛れ込まないように、以下の設定を追加したほうがよいかもしれません: 133 | 134 | ```bash 135 | $ git config --global core.autocrlf true 136 | ``` 137 | 138 | * 139 | 命令文や式の区切りに`;`を用いてはいけません。 140 | 当然、１行につき式１つにしましょう。 141 | ^{[[link](#no-semicolon)]} 142 | 143 | ```ruby 144 | # 悪い例 145 | puts 'foobar'; # 余分なセミコロンです 146 | 147 | puts 'foo'; puts 'bar' # ２つの式が１行にあります 148 | 149 | # 良い例 150 | puts 'foobar' 151 | 152 | puts 'foo' 153 | puts 'bar' 154 | 155 | puts 'foo', 'bar' # putsの場合はこれも可です 156 | ``` 157 | 158 | * 159 | 本文のないクラスは１行のフォーマットを用いましょう。 160 | ^{[[link](#single-line-classes)]} 161 | 162 | ```ruby 163 | # 悪い例 164 | class FooError < StandardError 165 | end 166 | 167 | # 悪くない例 168 | class FooError < StandardError; end 169 | 170 | # 良い例 171 | FooError = Class.new(StandardError) 172 | ``` 173 | 174 | * 175 | １行のメソッドは避けましょう。 176 | この用法は実際にはよく見かけるものではあるのですが、 177 | 構文に奇妙な点があるため、使用は望ましくないです。 178 | 仮に使うとしても、 179 | １行メソッドに含めるのは多くとも式１つまでにすべきです。 180 | ^{[[link](#no-single-line-methods)]} 181 | 182 | ```ruby 183 | # 悪い例 184 | def too_much; something; something_else; end 185 | 186 | # 悪くない例 - 最初の ; は必要です 187 | def no_braces_method; body end 188 | 189 | # 悪くない例 - ２つ目の ; は任意です 190 | def no_braces_method; body; end 191 | 192 | # 悪くない例 - 文法上は正しいです、ただし; がない記述は少し読みづらいです 193 | def some_method() body end 194 | 195 | # 良い例 196 | def some_method 197 | body 198 | end 199 | ``` 200 | 201 | 本文が空のメソッドはこのルールの例外です。 202 | 203 | ```ruby 204 | # 良い例 205 | def no_op; end 206 | ``` 207 | 208 | * 209 | 演算子の前後、コンマ、コロン、セミコロンの後ろにはスペースを入れましょう。 210 | スペースはRubyのインタープリタには(ほとんどの場合)重要ではありませんが、 211 | スペースの適切な使用は、読みやすいコードを書くための鍵です。 212 | ^{[[link](#spaces-operators)]} 213 | 214 | ```ruby 215 | sum = 1 + 2 216 | a, b = 1, 2 217 | class FooError < StandardError; end 218 | ``` 219 | 220 | 演算子について、いくつか例外があります。まずは、指数演算子です: 221 | 222 | ```ruby 223 | # 悪い例 224 | e = M * c ** 2 225 | 226 | # 良い例 227 | e = M * c**2 228 | ``` 229 | 230 | 同様に、有理数のリテラル（rational literals）も例外です: 231 | 232 | ```ruby 233 | # 悪い例 234 | o_scale = 1 / 48r 235 | 236 | # 良い例 237 | o_scale = 1/48r 238 | ``` 239 | 240 | 同様に、safe navigation operator（ぼっち演算子）も例外です: 241 | ```ruby 242 | # 悪い例 243 | foo &. bar 244 | foo &.bar 245 | foo&. bar 246 | 247 | # 良い例 248 | foo&.bar 249 | ``` 250 | 251 | * 252 | `(`, `[`の後ろ、`]`, `)`の前にはスペースは入れません。 253 | `{`の前後、`}`の前にはスペースが必要です。 254 | ^{[[link](#spaces-braces)]} 255 | 256 | ```ruby 257 | # 悪い例 258 | some( arg ).other 259 | [ 1, 2, 3 ].each{|e| puts e} 260 | 261 | # 良い例 262 | some(arg).other 263 | [1, 2, 3].each { |e| puts e } 264 | ``` 265 | 266 | `{` と `}` については多少の解説が必要でしょう。 267 | ブロック、ハッシュリテラル、そして文字列埋め込み式にそれぞれ使われるからです。 268 | 269 | ハッシュリテラルでは、２つのスタイルが許容できます。 270 | １つ目の書き方は、わずかながら少し読みやすいです(そして、Rubyコミュニティでより広く使われているのはこちらかもしれません)。 271 | ２つ目の書き方は、ブロックとハッシュを視覚的に差別化できるという点で有利です。 272 | どちらでも片方を採用すれば、常に同じ方式を採用しましょう。 273 | 274 | ```ruby 275 | # 良い例 - スペースを { の後と } の前に入れる 276 | { one: 1, two: 2 } 277 | 278 | # 良い例 - スペースを { の後と } の前に入れない 279 | {one: 1, two: 2} 280 | ``` 281 | 282 | 文字列埋め込み式では、中括弧の内側に空白を入れないでください。 283 | 284 | ```ruby 285 | # 悪い例 286 | "From: #{ user.first_name }, #{ user.last_name }" 287 | 288 | # 良い例 289 | "From: #{user.first_name}, #{user.last_name}" 290 | ``` 291 | 292 | * 293 | `!`の後にはスペースは入れません。 294 | ^{[[link](#no-space-bang)]} 295 | 296 | ```ruby 297 | # 悪い例 298 | ! something 299 | 300 | # 良い例 301 | !something 302 | ``` 303 | 304 | * 305 | 範囲リテラルの内側にスペースは入れません。 306 | ^{[[link](#no-space-inside-range-literals)]} 307 | 308 | ```ruby 309 | # 悪い例 310 | 1 .. 3 311 | 'a' ... 'z' 312 | 313 | # 良い例 314 | 1..3 315 | 'a'...'z' 316 | ``` 317 | 318 | * 319 | `when`は`case`と同じ深さに揃えましょう。 320 | このスタイルは"The Ruby Programming Language"と"Programming Ruby"の双方で確立されたものです。 321 | `case`及び`switch`をインデントしないのは、 322 | もともとこれらはブロックにならないという事実から来ています。 323 | また、`when`及び`else`キーワードはラベルです。 324 | （C言語においては、これらは`JMP`命令のためのラベルにすぎません） 325 | ^{[[link](#indent-when-to-case)]} 326 | 327 | ```ruby 328 | # 悪い例 329 | case 330 | when song.name == 'Misty' 331 | puts 'Not again!' 332 | when song.duration > 120 333 | puts 'Too long!' 334 | when Time.now.hour > 21 335 | puts "It's too late" 336 | else 337 | song.play 338 | end 339 | 340 | # 良い例 341 | case 342 | when song.name == 'Misty' 343 | puts 'Not again!' 344 | when song.duration > 120 345 | puts 'Too long!' 346 | when Time.now.hour > 21 347 | puts "It's too late" 348 | else 349 | song.play 350 | end 351 | ``` 352 | 353 | * 354 | 条件式を変数に代入するときは、 355 | 条件分岐のインデントは普段と同じ基準で揃えましょう。 356 | ^{[[link](#indent-conditional-assignment)]} 357 | 358 | ```ruby 359 | # 悪い例 - かなり複雑です 360 | kind = case year 361 | when 1850..1889 then 'Blues' 362 | when 1890..1909 then 'Ragtime' 363 | when 1910..1929 then 'New Orleans Jazz' 364 | when 1930..1939 then 'Swing' 365 | when 1940..1950 then 'Bebop' 366 | else 'Jazz' 367 | end 368 | 369 | result = if some_cond 370 | calc_something 371 | else 372 | calc_something_else 373 | end 374 | 375 | # 良い例 - 何が行われているか明らかです 376 | kind = case year 377 | when 1850..1889 then 'Blues' 378 | when 1890..1909 then 'Ragtime' 379 | when 1910..1929 then 'New Orleans Jazz' 380 | when 1930..1939 then 'Swing' 381 | when 1940..1950 then 'Bebop' 382 | else 'Jazz' 383 | end 384 | 385 | result = if some_cond 386 | calc_something 387 | else 388 | calc_something_else 389 | end 390 | 391 | # 良い例 (少しだけ幅の効率がよいです) 392 | kind = 393 | case year 394 | when 1850..1889 then 'Blues' 395 | when 1890..1909 then 'Ragtime' 396 | when 1910..1929 then 'New Orleans Jazz' 397 | when 1930..1939 then 'Swing' 398 | when 1940..1950 then 'Bebop' 399 | else 'Jazz' 400 | end 401 | 402 | result = 403 | if some_cond 404 | calc_something 405 | else 406 | calc_something_else 407 | end 408 | ``` 409 | 410 | * 411 | メソッド定義式の間には空行をいれ、 412 | メソッド同士は論理的なかたまりに分けましょう。 413 | ^{[[link](#empty-lines-between-methods)]} 414 | 415 | ```ruby 416 | def some_method 417 | data = initialize(options) 418 | 419 | data.manipulate! 420 | 421 | data.result 422 | end 423 | 424 | def some_method 425 | result 426 | end 427 | ``` 428 | 429 | * 430 | 空行を複数連続して用いてはいけません。 431 | ^{[[link](#two-or-more-empty-lines)]} 432 | 433 | ```ruby 434 | # 悪い例 - 空行が2つあります 435 | some_method 436 | 437 | 438 | some_method 439 | 440 | # 良い例 441 | some_method 442 | 443 | some_method 444 | ``` 445 | 446 | * 447 | アクセス修飾子の前後には空行を用いましょう。 448 | ^{[[link](#empty-lines-around-access-modifier)]} 449 | 450 | ```ruby 451 | # 悪い例 452 | class Foo 453 | attr_reader :foo 454 | def foo 455 | # do something... 456 | end 457 | end 458 | 459 | # 良い例 460 | class Foo 461 | attr_reader :foo 462 | 463 | def foo 464 | # do something... 465 | end 466 | end 467 | ``` 468 | 469 | * 470 | メソッド、クラス、モジュール、ブロックの本文の前後には、空行を用いてはいけません。 471 | ^{[[link](#empty-lines-around-bodies)]} 472 | 473 | ```ruby 474 | # 悪い例 475 | class Foo 476 | 477 | def foo 478 | 479 | begin 480 | 481 | do_something do 482 | 483 | something 484 | 485 | end 486 | 487 | rescue 488 | 489 | something 490 | 491 | end 492 | 493 | end 494 | 495 | end 496 | 497 | # 良い例 498 | class Foo 499 | def foo 500 | begin 501 | do_something do 502 | something 503 | end 504 | rescue 505 | something 506 | end 507 | end 508 | end 509 | ``` 510 | 511 | * 512 | メソッド呼び出しの最後の引数の後ろのコンマは避けましょう。 513 | 引数が複数行にわかれていない時は、特に避けましょう。 514 | ^{[[link](#no-trailing-params-comma)]} 515 | 516 | ```ruby 517 | # 悪い例 - 簡単に引数を移動・追加・削除できますが、それでもお奨めできません 518 | some_method( 519 | size, 520 | count, 521 | color, 522 | ) 523 | 524 | # 悪い例 525 | some_method(size, count, color, ) 526 | 527 | # 良い例 528 | some_method(size, count, color) 529 | ``` 530 | 531 | * 532 | メソッドの引数に初期値を割り当てるとき、 533 | `=`演算子の周りにはスペースを入れましょう。 534 | ^{[[link](#spaces-around-equals)]} 535 | 536 | ```ruby 537 | # 悪い例 538 | def some_method(arg1=:default, arg2=nil, arg3=[]) 539 | # do something... 540 | end 541 | 542 | # 良い例 543 | def some_method(arg1 = :default, arg2 = nil, arg3 = []) 544 | # do something... 545 | end 546 | ``` 547 | 548 | いくつかのRuby本は最初のスタイルを提案していますが、 549 | 実践的には2つ目の方がより有力とされています。 550 | (そして、おそらくこちらのほうが読みやすいでしょう) 551 | 552 | * 553 | `\`を用いた行の継続は可能であれば避けましょう。 554 | 可能であればというのは、つまり、文字列連結以外のすべての場合でです。 555 | ^{[[link](#no-trailing-backslash)]} 556 | 557 | ```ruby 558 | # 悪い例 559 | result = 1 - \ 560 | 2 561 | 562 | # 良い例 (ただし、それでも極めて醜い) 563 | result = 1 \ 564 | - 2 565 | 566 | long_string = 'First part of the long string' \ 567 | ' and second part of the long string' 568 | ``` 569 | 570 | * 571 | 一貫した複数行のメソッドチェーンのスタイルを採用しましょう。 572 | Rubyコミュニティには2つのよく使われるスタイル — 先頭に`.`を付けるもの (Option A)、 573 | 末尾に`.`を付けるもの (Option B) — があり、 574 | どちらも良いと考えられています。 575 | ^{[[link](#consistent-multi-line-chains)]} 576 | 577 | * **(Option A)** メソッドチェーンを次の行へつなげる時は、 578 | `.`は次の行に置きましょう。 579 | 580 | ```ruby 581 | # 悪い例 - ２行目を理解するのに１行目を調べなければなりません 582 | one.two.three. 583 | four 584 | 585 | # 良い例 - ２行目で何が行われているかすぐに理解できます 586 | one.two.three 587 | .four 588 | ``` 589 | 590 | * **(Option B)** メソッドチェーンを次の行につなげる時は、 591 | 式が続くことを示すように最初の行に`.`を置きましょう。 592 | 593 | ```ruby 594 | # 悪い例 - メソッドチェーンが続いているかを知るには、次の行を読む必要があります 595 | one.two.three 596 | .four 597 | 598 | # 良い例 - 最初の行を越えて式が続くか一目瞭然です 599 | one.two.three. 600 | four 601 | ``` 602 | 603 | 双方のスタイルのメリットに関する議論は[こちら](https://github.com/rubocop-hq/ruby-style-guide/pull/176)で見ることができます。 604 | 605 | * 606 | メソッド呼び出しが複数行に及ぶときは、引数は揃えましょう。 607 | １行の長さの制約のために、引数を揃えるのに適していない時は、 608 | 最初の引数以降をインデント１つ分で揃えるスタイルも許容できます。 609 | ^{[[link](#no-double-indent)]} 610 | 611 | ```ruby 612 | # 初期状態 (１行がとても長いです) 613 | def send_mail(source) 614 | Mailer.deliver(to: 'bob@example.com', from: 'us@example.com', subject: 'Important message', body: source.text) 615 | end 616 | 617 | # 悪い例 (インデントが倍) 618 | def send_mail(source) 619 | Mailer.deliver( 620 | to: 'bob@example.com', 621 | from: 'us@example.com', 622 | subject: 'Important message', 623 | body: source.text) 624 | end 625 | 626 | # 良い例 627 | def send_mail(source) 628 | Mailer.deliver(to: 'bob@example.com', 629 | from: 'us@example.com', 630 | subject: 'Important message', 631 | body: source.text) 632 | end 633 | 634 | # 良い例 (通常のインデントです) 635 | def send_mail(source) 636 | Mailer.deliver( 637 | to: 'bob@example.com', 638 | from: 'us@example.com', 639 | subject: 'Important message', 640 | body: source.text 641 | ) 642 | end 643 | ``` 644 | 645 | * 646 | 複数行に及ぶ配列は、要素を揃えましょう。 647 | ^{[[link](#align-multiline-arrays)]} 648 | 649 | ```ruby 650 | # 悪い例 - インデント1つです 651 | menu_item = %w[Spam Spam Spam Spam Spam Spam Spam Spam 652 | Baked beans Spam Spam Spam Spam Spam] 653 | 654 | # 良い例 655 | menu_item = %w[ 656 | Spam Spam Spam Spam Spam Spam Spam Spam 657 | Baked beans Spam Spam Spam Spam Spam 658 | ] 659 | 660 | # 良い例 661 | menu_item = 662 | %w[Spam Spam Spam Spam Spam Spam Spam Spam 663 | Baked beans Spam Spam Spam Spam Spam] 664 | ``` 665 | 666 | * 667 | 可読性のため、大きな数値にはアンダースコアをつけましょう。 668 | ^{[[link](#underscores-in-numerics)]} 669 | 670 | ```ruby 671 | # 悪い例 - 0はいくつありますか？ 672 | num = 1000000 673 | 674 | # 良い例 - 人の頭でもより簡単に解析できます 675 | num = 1_000_000 676 | ``` 677 | 678 | * 679 | 数値リテラルのプレフィックスには、英小文字を使用しましょう。 680 | 8進数には`0o`を、16進数には`0x`を、2進数には`0b`を使用します。 681 | 10進数には`0d`を使用しません。 682 | ^{[[link](#numeric-literal-prefixes)]} 683 | 684 | ```ruby 685 | # 悪い例 686 | num = 01234 687 | num = 0O1234 688 | num = 0X12AB 689 | num = 0B10101 690 | num = 0D1234 691 | num = 0d1234 692 | 693 | # good - プレフィックスと数字の分離が容易 694 | num = 0o1234 695 | num = 0x12AB 696 | num = 0b10101 697 | num = 1234 698 | ``` 699 | 700 | * 701 | APIドキュメントを書くなら、[YARD][yard]とその規約に従いましょう。 702 | コメント行と`def`の間に空行を入れてはいけません。 703 | ^{[[link](#api-documentation)]} 704 | 705 | * 706 | １行は80字までにしましょう。 707 | ^{[[link](#80-character-limits)]} 708 | 709 | * 710 | 行末のスペースは避けましょう。 711 | ^{[[link](#no-trailing-whitespace)]} 712 | 713 | * 714 | ファイルの終端には改行を入れましょう。 715 | ^{[[link](#newline-eof)]} 716 | 717 | * 718 | ブロックコメントは使ってはいけません。 719 | 前にスペースが入ると機能しませんし、 720 | 通常のコメントと違い、簡単に見分けが付きません。 721 | ^{[[link](#no-block-comments)]} 722 | 723 | ```ruby 724 | # 悪い例 725 | =begin 726 | comment line 727 | another comment line 728 | =end 729 | 730 | # 良い例 731 | # comment line 732 | # another comment line 733 | ``` 734 | 735 | ## 構文 736 | 737 | * 738 | `::`は、定数(クラスやモジュールも含みます)や 739 | コンストラクタ(例えば`Array()`や`Nokogiri::HTML()`)を参照するときにのみ使いましょう。 740 | 通常のメソッド呼び出しでは`::`の使用は避けましょう。 741 | ^{[[link](#double-colons)]} 742 | 743 | ```ruby 744 | # 悪い例 745 | SomeClass::some_method 746 | some_object::some_method 747 | 748 | # 良い例 749 | SomeClass.some_method 750 | some_object.some_method 751 | SomeModule::SomeClass::SOME_CONST 752 | SomeModule::SomeClass() 753 | ``` 754 | 755 | * 756 | クラスメソッドを定義する目的で`::`を使ってはいけません。 757 | ^{[[link](#colon-method-definition)]} 758 | 759 | ```ruby 760 | # 悪い例 761 | class Foo 762 | def self::some_method 763 | end 764 | end 765 | 766 | # 良い例 767 | class Foo 768 | def self.some_method 769 | end 770 | end 771 | ``` 772 | 773 | * 774 | 引数があるとき、`def`は括弧と共に使いましょう。 775 | 引数がない場合は括弧は省略しましょう。 776 | ^{[[link](#method-parens)]} 777 | 778 | ```ruby 779 | # 悪い例 780 | def some_method() 781 | # 本文省略 782 | end 783 | 784 | # 良い例 785 | def some_method 786 | # 本文省略 787 | end 788 | 789 | # 悪い例 790 | def some_method_with_parameters param1, param2 791 | # 本文省略 792 | end 793 | 794 | # 良い例 795 | def some_method_with_parameters(param1, param2) 796 | # 本文省略 797 | end 798 | ``` 799 | 800 | * 801 | メソッド呼び出しの引数の周りに括弧を使用しましょう。 802 | `f((3 + 2) + 1)`のようにメソッドの最初の引数が開き括弧で始まる場合は、 803 | 特に括弧を用いましょう。 804 | ^{[[link](#method-invocation-parens)]} 805 | 806 | ```ruby 807 | # 悪い例 808 | x = Math.sin y 809 | # 良い例 810 | x = Math.sin(y) 811 | 812 | # 悪い例 813 | array.delete e 814 | # 良い例 815 | array.delete(e) 816 | 817 | # 悪い例 818 | temperance = Person.new 'Temperance', 30 819 | # 良い例 820 | temperance = Person.new('Temperance', 30) 821 | ``` 822 | 823 | 以下の場合は常に括弧を省略します 824 | 825 | * 引数のないメソッド: 826 | 827 | ```ruby 828 | # 悪い例 829 | Kernel.exit!() 830 | 2.even?() 831 | fork() 832 | 'test'.upcase() 833 | 834 | # 良い例 835 | Kernel.exit! 836 | 2.even? 837 | fork 838 | 'test'.upcase 839 | ``` 840 | 841 | * 内部DSLに含まれるメソッド(例えばRake, Rails, RSpec): 842 | 843 | ```ruby 844 | # 悪い例 845 | validates(:name, presence: true) 846 | # 良い例 847 | validates :name, presence: true 848 | ``` 849 | 850 | * Rubyで「キーワード」と認識されているメソッド: 851 | 852 | ```ruby 853 | class Person 854 | # 悪い例 855 | attr_reader(:name, :age) 856 | # 良い例 857 | attr_reader :name, :age 858 | 859 | # body omitted 860 | end 861 | ``` 862 | 863 | 以下の場合は括弧を省略することができます 864 | 865 | * Rubyで「キーワード」と認識されているが、宣言的ではないメソッド: 866 | 867 | ```Ruby 868 | # 良い例 869 | puts(temperance.age) 870 | system('ls') 871 | # こちらも良い例 872 | puts temperance.age 873 | system 'ls' 874 | ``` 875 | 876 | * 877 | オプショナル引数は引数リストの最後に定義しましょう。 878 | 引数リストの先頭にオプショナル引数があるメソッドを呼んだ場合、 879 | Rubyの挙動は予測不能です。 880 | ^{[[link](#optional-arguments)]} 881 | 882 | ```ruby 883 | # 悪い例 884 | def some_method(a = 1, b = 2, c, d) 885 | puts "#{a}, #{b}, #{c}, #{d}" 886 | end 887 | 888 | some_method('w', 'x') # => '1, 2, w, x' 889 | some_method('w', 'x', 'y') # => 'w, 2, x, y' 890 | some_method('w', 'x', 'y', 'z') # => 'w, x, y, z' 891 | 892 | # 良い例 893 | def some_method(c, d, a = 1, b = 2) 894 | puts "#{a}, #{b}, #{c}, #{d}" 895 | end 896 | 897 | some_method('w', 'x') # => '1, 2, w, x' 898 | some_method('w', 'x', 'y') # => 'y, 2, w, x' 899 | some_method('w', 'x', 'y', 'z') # => 'y, z, w, x' 900 | ``` 901 | * 902 | メソッドにbooleanを渡す時にはキーワード引数を使いましょう。 903 | 904 | ```Ruby 905 | # 悪い例 906 | def some_method(bar = false) 907 | puts bar 908 | end 909 | 910 | # 悪い例 - キーワード引数が導入される以前によく見られたハックです 911 | def some_method(options = {}) 912 | bar = options.fetch(:bar, false) 913 | puts bar 914 | end 915 | 916 | # 良い例 917 | def some_method(bar: false) 918 | puts bar 919 | end 920 | 921 | some_method # => false 922 | some_method(bar: true) # => true 923 | ``` 924 | 925 | * 926 | オプショナル引数のハッシュではなくキーワード引数を使いましょう。 927 | 928 | ```Ruby 929 | # 悪い例 930 | def some_method(options = {}) 931 | bar = options.fetch(:bar, false) 932 | puts bar 933 | end 934 | 935 | # 良い例 936 | def some_method(bar: false) 937 | puts bar 938 | end 939 | ``` 940 | 941 | * 942 | 変数を定義するために多重代入を使うのは避けましょう。 943 | 多重代入を使っていいのはメソッド戻り値を変数に代入する時、 944 | splat演算子とともに使う時、 945 | 変数の値を相互に入れ替えたい時に限ります。 946 | 多重代入は代入をそれぞれ別に実施した場合と比べて可読性に劣ります。 947 | ^{[[link](#parallel-assignment)]} 948 | 949 | ```ruby 950 | # 悪い例 951 | a, b, c, d = 'foo', 'bar', 'baz', 'foobar' 952 | 953 | # 良い例 954 | a = 'foo' 955 | b = 'bar' 956 | c = 'baz' 957 | d = 'foobar' 958 | 959 | # 良い例 - 変数の値の入れ替え 960 | # この用法は変数に入っている値を相互に入れ替えることができるので 961 | # 特例として認められます。 962 | a = 'foo' 963 | b = 'bar' 964 | 965 | a, b = b, a 966 | puts a # => 'bar' 967 | puts b # => 'foo' 968 | 969 | # 良い例 - メソッドの戻り値 970 | def multi_return 971 | [1, 2] 972 | end 973 | 974 | first, second = multi_return 975 | 976 | # 良い例 - splatとともに使う場合 977 | first, *list = [1, 2, 3, 4] # first => 1, list => [2, 3, 4] 978 | 979 | hello_array = *'Hello' # => ["Hello"] 980 | 981 | a = *(1..3) # => [1, 2, 3] 982 | ``` 983 | 984 | * 985 | 多重代入においては不要なアンダースコア変数を後ろに並べないようにしましょう。 986 | アンダースコア変数は名前が付いていたほうがコンテキストを明示できるので、 987 | 名前をつけておいたほうが良いでしょう。 988 | アンダースコア変数は、その代入より左にスプラット変数が存在する場合には必要です。 989 | その場合、スプラット変数はアンダースコア変数ではありません。 990 | ^{[[link]](#trailing-underscore-variables)} 991 | 992 | ```ruby 993 | # 悪い例 994 | foo = 'one,two,three,four,five' 995 | # 有用な情報を提供しない不要な代入です。 996 | first, second, _ = foo.split(',') 997 | first, _, _ = foo.split(',') 998 | first, *_ = foo.split(',') 999 | 1000 | # 良い例 1001 | foo = 'one,two,three,four,five' 1002 | # このアンダースコア変数は、最後の要素を除いた全ての要素が必要で 1003 | # あることを示すために必要です。 1004 | *beginning, _ = foo.split(',') 1005 | *beginning, something, _ = foo.split(',') 1006 | 1007 | a, = foo.split(',') 1008 | a, b, = foo.split(',') 1009 | # 未使用変数への代入は必須ではありませんが、この代入は有用な情報を 1010 | # 提供します。 1011 | first, _second = foo.split(',') 1012 | first, _second, = foo.split(',') 1013 | first, *_ending = foo.split(',') 1014 | ``` 1015 | 1016 | * 1017 | `for`は、どうしても使わなければいけない明確な理由が明言できる人以外は、使ってはいけません。 1018 | 多くの場合は代わりにイテレータを使うべきです。 1019 | `for`は`each`をつかって実装されています(だから、より遠回しです)が、 1020 | `for`は(`each`と違い)新しいスコープを導入せず、 1021 | そのブロック内で定義された変数は、ブロックの外からも見えます。 1022 | ^{[[link](#no-for-loops)]} 1023 | 1024 | ```ruby 1025 | arr = [1, 2, 3] 1026 | 1027 | # 悪い例 1028 | for elem in arr do 1029 | puts elem 1030 | end 1031 | 1032 | # elemはループの外からも参照できることに注意しましょう 1033 | elem # => 3 1034 | 1035 | # 良い例 1036 | arr.each { |elem| puts elem } 1037 | 1038 | # elemはeachブロックの外からは参照できません 1039 | elem # => NameError: undefined local variable or method `elem' 1040 | ``` 1041 | 1042 | * 1043 | `then`は複数行にまたがる`if`/`unless`では使ってはいけません。 1044 | ^{[[link](#no-then)]} 1045 | 1046 | ```ruby 1047 | # 悪い例 1048 | if some_condition then 1049 | # 本文省略 1050 | end 1051 | 1052 | # 良い例 1053 | if some_condition 1054 | # 本文省略 1055 | end 1056 | ``` 1057 | 1058 | * 1059 | 複数行にまたがる`if`/`unless`では、条件式は常に`if`/`unless`と同じ行に置きましょう。 1060 | ^{[[link](#same-line-condition)]} 1061 | 1062 | ```ruby 1063 | # 悪い例 1064 | if 1065 | some_condition 1066 | do_something 1067 | do_something_else 1068 | end 1069 | 1070 | # 良い例 1071 | if some_condition 1072 | do_something 1073 | do_something_else 1074 | end 1075 | ``` 1076 | 1077 | * 1078 | 三項演算子(`?:`)を`if/then/else/end`構文よりも優先的に使いましょう。 1079 | そちらの方がより一般的だし、あきらかに簡潔です。 1080 | ^{[[link](#ternary-operator)]} 1081 | 1082 | ```ruby 1083 | # 悪い例 1084 | result = if some_condition then something else something_else end 1085 | 1086 | # 良い例 1087 | result = some_condition ? something : something_else 1088 | ``` 1089 | 1090 | * 1091 | 三項演算子の１つの分岐には１つだけ式を入れましょう。 1092 | つまり、三項演算子はネストしてはいけません。 1093 | そのようなケースでは`if/else`の方がよいです。 1094 | ^{[[link](#no-nested-ternary)]} 1095 | 1096 | ```ruby 1097 | # 悪い例 1098 | some_condition ? (nested_condition ? nested_something : nested_something_else) : something_else 1099 | 1100 | # 良い例 1101 | if some_condition 1102 | nested_condition ? nested_something : nested_something_else 1103 | else 1104 | something_else 1105 | end 1106 | ``` 1107 | 1108 | * 1109 | `if x; ...`を使ってはいけません。代わりに三項演算子を使いましょう。 1110 | ^{[[link](#no-semicolon-ifs)]} 1111 | 1112 | ```ruby 1113 | # 悪い例 1114 | result = if some_condition; something else something_else end 1115 | 1116 | # 良い例 1117 | result = some_condition ? something : something_else 1118 | ``` 1119 | 1120 | * 1121 | `if`や`case`が式で、値を返すという事実を活用しましょう。 1122 | ^{[[link](#use-if-case-returns)]} 1123 | 1124 | ```ruby 1125 | # 悪い例 1126 | if condition 1127 | result = x 1128 | else 1129 | result = y 1130 | end 1131 | 1132 | # 良い例 1133 | result = 1134 | if condition 1135 | x 1136 | else 1137 | y 1138 | end 1139 | ``` 1140 | 1141 | * 1142 | １行の`case`文では`when x then ...`を使いましょう。 1143 | 代わりの表現である`when x: ...`は、Ruby 1.9で廃止されました。 1144 | ^{[[link](#one-line-cases)]} 1145 | 1146 | * 1147 | `when x; ...`を使ってはいけません。前のルールを見てください。 1148 | ^{[[link](#no-when-semicolons)]} 1149 | 1150 | * 1151 | `not`の代わりに`!`を使いましょう。 1152 | ^{[[link](#bang-not-not)]} 1153 | 1154 | ```ruby 1155 | # 悪い例 - 演算子優先順位のため、()が必要になります 1156 | x = (not something) 1157 | 1158 | # 良い例 1159 | x = !something 1160 | ``` 1161 | 1162 | * 1163 | `!!`は避けましょう。 1164 | ^{[[link](#no-bang-bang)]} 1165 | 1166 | `!!`は値をbooleanに変換しますが、制御式の条件で明示的な変換は必要ありません。 1167 | あなたの意図を隠すだけです。 1168 | `nil`チェックをしたい場合、代わりに`nil?`を使用しましょう。 1169 | 1170 | ```ruby 1171 | # 悪い例 1172 | x = 'test' 1173 | # 難読なnil判定 1174 | if !!x 1175 | # body omitted 1176 | end 1177 | 1178 | # 良い例 1179 | x = 'test' 1180 | if x 1181 | # body omitted 1182 | end 1183 | ``` 1184 | 1185 | * 1186 | `and`と`or`の使用は禁止です。可読性を良くするとしても、バグを埋め込む可能性が高いため使用に値しません。 1187 | boolean式では常に、代わりに`&&`と`||`を使いましょう。 1188 | フロー制御では`if`と`unless`を使いましょう。`&&`と`||`も許容されますが、あまり明確ではありません。 1189 | ^{[[link](#no-and-or-or)]} 1190 | 1191 | ```ruby 1192 | # 悪い例 1193 | # boolean式 1194 | ok = got_needed_arguments and arguments_are_valid 1195 | 1196 | # 制御構文 1197 | document.save or raise("Failed to save document!") 1198 | 1199 | # 良い例 1200 | # boolean式 1201 | ok = got_needed_arguments && arguments_are_valid 1202 | 1203 | # 制御構文 1204 | raise("Failed to save document!") unless document.save 1205 | 1206 | # ok 1207 | # 制御構文 1208 | document.save || raise("Failed to save document!") 1209 | ``` 1210 | 1211 | * 1212 | 複数行にまたがる三項演算子`?:`は避けましょう; 代わりに`if`/`unless`を使いましょう。 1213 | ^{[[link](#no-multiline-ternary)]} 1214 | 1215 | * 1216 | 本文が１行のときは、`if`/`unless`修飾子を優先的に使いましょう。 1217 | 他の良い代替案としては`&&`/`||`を使った制御構文があります。 1218 | ^{[[link](#if-as-a-modifier)]} 1219 | 1220 | ```ruby 1221 | # 悪い例 1222 | if some_condition 1223 | do_something 1224 | end 1225 | 1226 | # 良い例 1227 | do_something if some_condition 1228 | 1229 | # もう１つの良い例 1230 | some_condition && do_something 1231 | ``` 1232 | 1233 | * 1234 | 複数行に渡るような些細とは言えない規模のブロックに`if`/`unless`修飾子を用いるのは避けましょう。 1235 | ^{[[link](#no-multiline-if-modifiers)]} 1236 | 1237 | ```ruby 1238 | # 悪い例 1239 | 10.times do 1240 | # 複数行のbody省略 1241 | end if some_condition 1242 | 1243 | # 良い例 1244 | if some_condition 1245 | 10.times do 1246 | # 複数行のbody省略 1247 | end 1248 | end 1249 | ``` 1250 | 1251 | * 1252 | `if`/`unless`/`while`/`until` 修飾子をネストして利用しないようにしましょう。 1253 | 可能であれば `&&`/`||` を使いましょう。 1254 | ^{[[link](#no-nested-modifiers)]} 1255 | 1256 | ```ruby 1257 | # 悪い例 1258 | do_something if other_condition if some_condition 1259 | 1260 | # 良い例 1261 | do_something if some_condition && other_condition 1262 | ``` 1263 | 1264 | * 1265 | 否定形のときは`if`より`unless`を優先的に使いましょう。(もしくは`||`構文を使いましょう)。 1266 | ^{[[link](#unless-for-negatives)]} 1267 | 1268 | ```ruby 1269 | # 悪い例 1270 | do_something if !some_condition 1271 | 1272 | # 悪い例 1273 | do_something if not some_condition 1274 | 1275 | # 良い例 1276 | do_something unless some_condition 1277 | 1278 | # もう１つの良い例 1279 | some_condition || do_something 1280 | ``` 1281 | 1282 | * 1283 | `unless`を`else`付きで使ってはいけません。 1284 | 肯定条件を先にして書き換えましょう。 1285 | ^{[[link](#no-else-with-unless)]} 1286 | 1287 | ```ruby 1288 | # 悪い例 1289 | unless success? 1290 | puts 'failure' 1291 | else 1292 | puts 'success' 1293 | end 1294 | 1295 | # 良い例 1296 | if success? 1297 | puts 'success' 1298 | else 1299 | puts 'failure' 1300 | end 1301 | ``` 1302 | 1303 | * 1304 | 条件式の周囲を括弧で括らないようにしましょう。 1305 | ^{[[link](#no-parens-around-condition)]} 1306 | 1307 | ```ruby 1308 | # 悪い例 1309 | if (x > 10) 1310 | # body omitted 1311 | end 1312 | 1313 | # 良い例 1314 | if x > 10 1315 | # body omitted 1316 | end 1317 | ``` 1318 | 1319 | 留意しなければならないのは、このルールには例外([条件式中の安全な代入](#safe-assignment-in-condition))があるということです。 1320 | 1321 | * 1322 | 複数行の`while/until`では、`while/until condition do`を使ってはいけません。 1323 | ^{[[link](#no-multiline-while-do)]} 1324 | 1325 | ```ruby 1326 | # 悪い例 1327 | while x > 5 do 1328 | # 本文省略 1329 | end 1330 | 1331 | until x > 5 do 1332 | # 本文省略 1333 | end 1334 | 1335 | # 良い例 1336 | while x > 5 1337 | # 本文省略 1338 | end 1339 | 1340 | until x > 5 1341 | # 本文省略 1342 | end 1343 | ``` 1344 | 1345 | * 1346 | 本文が１行のときは、`while/until`修飾子を利用しましょう。 1347 | ^{[[link](#while-as-a-modifier)]} 1348 | 1349 | ```ruby 1350 | # 悪い例 1351 | while some_condition 1352 | do_something 1353 | end 1354 | 1355 | # 良い例 1356 | do_something while some_condition 1357 | ``` 1358 | 1359 | * 1360 | 否定形のときは、`while`よりも`until`を使いましょう。 1361 | ^{[[link](#until-for-negatives)]} 1362 | 1363 | ```ruby 1364 | # 悪い例 1365 | do_something while !some_condition 1366 | 1367 | # 良い例 1368 | do_something until some_condition 1369 | ``` 1370 | 1371 | * 1372 | 無限ループが必要な時は、`while/until`の代わりに`Kernel#loop`を用いましょう。 1373 | ^{[[link](#infinite-loop)]} 1374 | 1375 | ```ruby 1376 | # 悪い例 1377 | while true 1378 | do_something 1379 | end 1380 | 1381 | until false 1382 | do_something 1383 | end 1384 | 1385 | # 良い例 1386 | loop do 1387 | do_something 1388 | end 1389 | ``` 1390 | 1391 | * 1392 | 後判定ループの場合、`begin/end/until`や`begin/end/while`より、`break`付きの`Kernel#loop`を使いましょう。 1393 | ^{[[link](#loop-with-break)]} 1394 | 1395 | ```ruby 1396 | # 悪い例 1397 | begin 1398 | puts val 1399 | val += 1 1400 | end while val < 0 1401 | 1402 | # 良い例 1403 | loop do 1404 | puts val 1405 | val += 1 1406 | break unless val < 0 1407 | end 1408 | ``` 1409 | 1410 | * 1411 | 暗黙のオプションハッシュの外側の括弧は省略しましょう。 1412 | ^{[[link](#no-braces-opts-hash)]} 1413 | 1414 | ```ruby 1415 | # 悪い例 1416 | user.set({ name: 'John', age: 45, permissions: { read: true } }) 1417 | 1418 | # 良い例 1419 | user.set(name: 'John', age: 45, permissions: { read: true }) 1420 | ``` 1421 | 1422 | * 1423 | 内部DSLの一部として使われるメソッドの引数では、外側の括弧類は省略しましょう 1424 | ^{[[link](#no-dsl-decorating)]} 1425 | 1426 | ```ruby 1427 | class Person < ActiveRecord::Base 1428 | # 悪い例 1429 | validates(:name, { presence: true, length: { within: 1..10 } }) 1430 | 1431 | # 良い例 1432 | validates :name, presence: true, length: { within: 1..10 } 1433 | end 1434 | ``` 1435 | 1436 | * 1437 | ブロック内で呼び出されるメソッドがただ１つである場合、簡略化されたproc呼び出しを用いましょう。 1438 | ^{[[link](#single-action-blocks)]} 1439 | 1440 | ```ruby 1441 | # 悪い例 1442 | names.map { |name| name.upcase } 1443 | 1444 | # 良い例 1445 | names.map(&:upcase) 1446 | ``` 1447 | 1448 | * 1449 | １行のブロックでは`do...end`より`{...}`を使いましょう。 1450 | 複数行のブロックでは`{...}`は避けましょう 1451 | (複数行のメソッドチェーンは常に醜いです)。 1452 | 制御構文(的な用法)やメソッド定義(的な用法)では常に`do...end`を使いましょう 1453 | (例えばRakefilesや特定のDSLなど) 1454 | メソッドチェーンでの`do...end`は避けましょう。 1455 | ^{[[link](#single-line-blocks)]} 1456 | 1457 | ```ruby 1458 | names = %w[Bozhidar Steve Sarah] 1459 | 1460 | # 悪い例 1461 | names.each do |name| 1462 | puts name 1463 | end 1464 | 1465 | # 良い例 1466 | names.each { |name| puts name } 1467 | 1468 | # 悪い例 1469 | names.select do |name| 1470 | name.start_with?('S') 1471 | end.map { |name| name.upcase } 1472 | 1473 | # 良い例 1474 | names.select { |name| name.start_with?('S') }.map(&:upcase) 1475 | ``` 1476 | 1477 | `{...}`を用いた複数行のメソッドチェーンをOKと主張する人もいるかもしれないが、 1478 | 自問してみてほしい — そのコードは本当に読みやすいだろうか？ 1479 | また、そのブロックの中はメソッドに切り出すことはできないのか？ 1480 | 1481 | * 1482 | 単に他のブロックに引数を渡すだけのブロックリテラルを避けるため、 1483 | ブロック引数を明示することを検討しましょう。 1484 | ただしブロックが`Proc`に変換されることでのパフォーマンスに気をつけましょう。 1485 | ^{[[link](#block-argument)]} 1486 | 1487 | ```ruby 1488 | require 'tempfile' 1489 | 1490 | # 悪い例 1491 | def with_tmp_dir 1492 | Dir.mktmpdir do |tmp_dir| 1493 | Dir.chdir(tmp_dir) { |dir| yield dir } # 引数を渡しているだけのブロック 1494 | end 1495 | end 1496 | 1497 | # 良い例 1498 | def with_tmp_dir(&block) 1499 | Dir.mktmpdir do |tmp_dir| 1500 | Dir.chdir(tmp_dir, &block) 1501 | end 1502 | end 1503 | 1504 | with_tmp_dir do |dir| 1505 | puts "dir is accessible as parameter and pwd is set: #{dir}" 1506 | end 1507 | ``` 1508 | 1509 | * 1510 | 制御構文上不要な`return`は避けましょう。 1511 | ^{[[link](#no-explicit-return)]} 1512 | 1513 | ```ruby 1514 | # 悪い例 1515 | def some_method(some_arr) 1516 | return some_arr.size 1517 | end 1518 | 1519 | # 良い例 1520 | def some_method(some_arr) 1521 | some_arr.size 1522 | end 1523 | ``` 1524 | 1525 | * 1526 | 不要な`self`は避けましょう 1527 | (`self`のアクセサへの書き込み、メソッド名が予約語の場合、オーバーロード可能なオペレータの場合でのみ必要です)。 1528 | ^{[[link](#no-self-unless-required)]} 1529 | 1530 | ```ruby 1531 | # 悪い例 1532 | def ready? 1533 | if self.last_reviewed_at > self.last_updated_at 1534 | self.worker.update(self.content, self.options) 1535 | self.status = :in_progress 1536 | end 1537 | self.status == :verified 1538 | end 1539 | 1540 | # 良い例 1541 | def ready? 1542 | if last_reviewed_at > last_updated_at 1543 | worker.update(content, options) 1544 | self.status = :in_progress 1545 | end 1546 | status == :verified 1547 | end 1548 | ``` 1549 | 1550 | * 1551 | 当然の帰結として、ローカル変数でメソッドをシャドウイングするのは、 1552 | それらが等価なものでない限り避けましょう。 1553 | ^{[[link](#no-shadowing)]} 1554 | 1555 | ```ruby 1556 | class Foo 1557 | attr_accessor :options 1558 | 1559 | # ok 1560 | def initialize(options) 1561 | self.options = options 1562 | # options と self.options はここでは等価 1563 | end 1564 | 1565 | # 悪い例 1566 | def do_something(options = {}) 1567 | unless options[:when] == :later 1568 | output(self.options[:message]) 1569 | end 1570 | end 1571 | 1572 | # 良い例 1573 | def do_something(params = {}) 1574 | unless params[:when] == :later 1575 | output(options[:message]) 1576 | end 1577 | end 1578 | end 1579 | ``` 1580 | 1581 | * 1582 | 代入部分を括弧で囲まずに、`=`の返り値を条件式に用いてはいけません。 1583 | これは、Rubyistの中では *条件式内での安全な代入* としてとても有名です。 1584 | ^{[[link](#safe-assignment-in-condition)]} 1585 | 1586 | ```ruby 1587 | # 悪い例 (+ 警告が出ます) 1588 | if v = array.grep(/foo/) 1589 | do_something(v) 1590 | # some code 1591 | end 1592 | 1593 | # 良い例 (MRIはこれでも文句を言いますが、RuboCopでは問題ありません) 1594 | if (v = array.grep(/foo/)) 1595 | do_something(v) 1596 | # some code 1597 | end 1598 | 1599 | # 良い例 1600 | v = array.grep(/foo/) 1601 | if v 1602 | do_something(v) 1603 | # some code 1604 | end 1605 | ``` 1606 | 1607 | * 1608 | 利用できるときには省略された自己代入演算子を用いましょう。 1609 | ^{[[link](#self-assignment)]} 1610 | 1611 | ```ruby 1612 | # 悪い例 1613 | x = x + y 1614 | x = x * y 1615 | x = x**y 1616 | x = x / y 1617 | x = x || y 1618 | x = x && y 1619 | 1620 | # 良い例 1621 | x += y 1622 | x *= y 1623 | x **= y 1624 | x /= y 1625 | x ||= y 1626 | x &&= y 1627 | ``` 1628 | 1629 | * 1630 | 変数がまだ初期化されていないときにだけ初期化したいのであれば、`||=`を使いましょう。 1631 | ^{[[link](#double-pipe-for-uninit)]} 1632 | 1633 | ```ruby 1634 | # 悪い例 1635 | name = name ? name : 'Bozhidar' 1636 | 1637 | # 悪い例 1638 | name = 'Bozhidar' unless name 1639 | 1640 | # 良い例 - nameがnilかfalseの場合のみ、Bozhidarで初期化します 1641 | name ||= 'Bozhidar' 1642 | ``` 1643 | 1644 | * 1645 | boolean変数には`||=`を用いてはいけません 1646 | (現在の値が`false`であったときに何が起こるか考えてみましょう)。 1647 | ^{[[link](#no-double-pipes-for-bools)]} 1648 | 1649 | ```ruby 1650 | # 悪い例 - たとえenabledがfalseでもtrueが入ります 1651 | enabled ||= true 1652 | 1653 | # 良い例 1654 | enabled = true if enabled.nil? 1655 | ``` 1656 | 1657 | * 1658 | 値が入っているかわからない変数の前処理には`&&=`を用いましょう。 1659 | `&&=`を使えば変数が存在するときのみ値を変更するので、 1660 | 存在確認に用いている不要な`if`を除去できます。 1661 | ^{[[link](#double-amper-preprocess)]} 1662 | 1663 | ```ruby 1664 | # 悪い例 1665 | if something 1666 | something = something.downcase 1667 | end 1668 | 1669 | # 悪い例 1670 | something = something ? something.downcase : nil 1671 | 1672 | # ok 1673 | something = something.downcase if something 1674 | 1675 | # 良い例 1676 | something = something && something.downcase 1677 | 1678 | # より良い例 1679 | something &&= something.downcase 1680 | ``` 1681 | 1682 | * 1683 | case等価演算子`===`の露骨な使用は避けましょう。 1684 | その名が示す通り、`case`の条件判定で用いられており、 1685 | その外で用いられると混乱のもとになります。 1686 | ^{[[link](#no-case-equality)]} 1687 | 1688 | ```ruby 1689 | # 悪い例 1690 | Array === something 1691 | (1..100) === 7 1692 | /something/ === some_string 1693 | 1694 | # 良い例 1695 | something.is_a?(Array) 1696 | (1..100).include?(7) 1697 | some_string.match?(/something/) 1698 | ``` 1699 | 1700 | * 1701 | `==`で用が足りるなら`eql?`は使わないようにしましょう。 1702 | `eql?`で実現されている、より厳密な等価性が必要になることは、実際には稀です。 1703 | ^{[[link](#eql)]} 1704 | 1705 | ```ruby 1706 | # 悪い例 - eql? は文字列に対する == と同じです 1707 | 'ruby'.eql? some_str 1708 | 1709 | # good 1710 | 'ruby' == some_str 1711 | 1.0.eql? x # eql? はIntegerとFloatの1を識別したいのであれば意味があります 1712 | ``` 1713 | 1714 | * 1715 | Perlスタイルの(`$:`や`$;`などのような)特別な変数の使用は避けましょう。 1716 | それらは極めて暗号的なので、ワンライナー以外での利用は推奨できません。 1717 | `English`ライブラリから提供される人にやさしいエイリアスを用いましょう。 1718 | ^{[[link](#no-cryptic-perlisms)]} 1719 | 1720 | ```ruby 1721 | # 悪い例 1722 | $:.unshift File.dirname(__FILE__) 1723 | 1724 | # 良い例 1725 | require 'English' 1726 | $LOAD_PATH.unshift File.dirname(__FILE__) 1727 | ``` 1728 | 1729 | * 1730 | メソッド名と開き括弧の間にスペースを入れてはいけません。 1731 | ^{[[link](#parens-no-spaces)]} 1732 | 1733 | ```ruby 1734 | # 悪い例 1735 | f (3 + 2) + 1 1736 | 1737 | # 良い例 1738 | f(3 + 2) + 1 1739 | ``` 1740 | 1741 | * 1742 | Rubyインタープリタを走らせるときは、常に`-w`オプションを付けましょう。 1743 | これまでのルールのどれかを忘れてしまった時に警告を出してくれます！ 1744 | ^{[[link](#always-warn-at-runtime)]} 1745 | 1746 | * 1747 | ネストしたメソッド定義は行ってはいけません - 代わりにラムダを用いましょう。 1748 | ネストしたメソッド定義は実際には外側のメソッドと同じスコープ(例えばclass)でメソッドを生成します。 1749 | そのうえ、そのようにネストしたメソッドは、そのメソッドを含んでいるメソッドが呼び出されるたびに再定義されるでしょう。 1750 | ^{[[link](#no-nested-methods)]} 1751 | 1752 | ```ruby 1753 | # 悪い例 1754 | def foo(x) 1755 | def bar(y) 1756 | # 本文略 1757 | end 1758 | 1759 | bar(x) 1760 | end 1761 | 1762 | # 良い例 - 前の例と同じですが、foo呼び出し時にのbar再定義がおこりません 1763 | def bar(y) 1764 | # 本文略 1765 | end 1766 | 1767 | def foo(x) 1768 | bar(x) 1769 | end 1770 | 1771 | # こちらも良い例 1772 | def foo(x) 1773 | bar = ->(y) { ... } 1774 | bar.call(x) 1775 | end 1776 | ``` 1777 | 1778 | * 1779 | １行の本文を持つラムダには新しいリテラルを持ちましょう。 1780 | `lambda`は複数行にまたがるときに使いましょう。 1781 | ^{[[link](#lambda-multi-line)]} 1782 | 1783 | ```ruby 1784 | # 悪い例 1785 | l = lambda { |a, b| a + b } 1786 | l.call(1, 2) 1787 | 1788 | # 正しい例、ですがギクシャクしています 1789 | l = ->(a, b) do 1790 | tmp = a * 7 1791 | tmp * b / 50 1792 | end 1793 | 1794 | # 良い例 1795 | l = ->(a, b) { a + b } 1796 | l.call(1, 2) 1797 | 1798 | l = lambda do |a, b| 1799 | tmp = a * 7 1800 | tmp * b / 50 1801 | end 1802 | ``` 1803 | 1804 | * 1805 | stabby lambdaを定義するときは、引数の周りの括弧は省略しないようにしましょう。 1806 | ^{[[link](#stabby-lambda-with-args)]} 1807 | 1808 | ```ruby 1809 | # 悪い例 1810 | l = ->x, y { something(x, y) } 1811 | 1812 | # 良い例 1813 | l = ->(x, y) { something(x, y) } 1814 | ``` 1815 | 1816 | * 1817 | stabby lambdaに引数がないときは、引数のための括弧は省略しましょう。 1818 | ^{[[link](#stabby-lambda-no-args)]} 1819 | 1820 | ```ruby 1821 | # 悪い例 1822 | l = ->() { something } 1823 | 1824 | # 良い例 1825 | l = -> { something } 1826 | ``` 1827 | 1828 | * 1829 | `Proc.new`より`proc`を使いましょう。 1830 | ^{[[link](#proc)]} 1831 | 1832 | ```ruby 1833 | # 悪い例 1834 | p = Proc.new { |n| puts n } 1835 | 1836 | # 良い例 1837 | p = proc { |n| puts n } 1838 | ``` 1839 | 1840 | * 1841 | lambdaやprocの呼び出しには`proc[]`や`proc.()`より`proc.call()`を使いましょう。 1842 | ^{[[link](#proc-call)]} 1843 | 1844 | ```ruby 1845 | # 悪い例 - 列挙型のアクセスに似ているように見えます 1846 | l = ->(v) { puts v } 1847 | l[1] 1848 | 1849 | # こちらも悪い例 - 珍しい構文です 1850 | l = ->(v) { puts v } 1851 | l.(1) 1852 | 1853 | # 良い例 1854 | l = ->(v) { puts v } 1855 | l.call(1) 1856 | ``` 1857 | 1858 | * 1859 | 使わないブロック引数やローカル変数の先頭には`_`を付けましょう。 1860 | 単に`_`を用いるのも許容されます 1861 | (少し説明不足ではありますが)。 1862 | この記法を使うことで、 1863 | RubyインタープリタやRuboCopのような対応しているツールでは 1864 | 変数を使っていないという警告を抑制できます。 1865 | ^{[[link](#underscore-unused-vars)]} 1866 | 1867 | ```ruby 1868 | # 悪い例 1869 | result = hash.map { |k, v| v + 1 } 1870 | 1871 | def something(x) 1872 | unused_var, used_var = something_else(x) 1873 | # some code 1874 | end 1875 | 1876 | # 良い例 1877 | result = hash.map { |_k, v| v + 1 } 1878 | 1879 | def something(x) 1880 | _unused_var, used_var = something_else(x) 1881 | # some code 1882 | end 1883 | 1884 | # 良い例 1885 | result = hash.map { |_, v| v + 1 } 1886 | 1887 | def something(x) 1888 | _, used_var = something_else(x) 1889 | # some code 1890 | end 1891 | ``` 1892 | 1893 | * 1894 | `STDOUT/STDERR/STDIN`の代わりに`$stdout/$stderr/$stdin`を用いましょう。 1895 | `STDOUT/STDERR/STDIN`は定数であり、 1896 | Rubyでの定数は、実際は再代入できます(つまりリダイレクトに使えます)が、 1897 | もし実行するとインタープリタからの警告が出ます。 1898 | ^{[[link](#global-stdout)]} 1899 | 1900 | * 1901 | `$stderr.puts`の代わりに`warn`を用いましょう。 1902 | 簡潔さや明快さもさることながら、 1903 | `warn`は必要であれば警告を抑制することができます 1904 | (警告レベルを`-W0`を用いて0に設定することによって実現できます)。 1905 | ^{[[link](#warn)]} 1906 | 1907 | * 1908 | あまりに暗号めいている`String#%`メソッドよりも`sprintf`や`format`を使いましょう。 1909 | ^{[[link](#sprintf)]} 1910 | 1911 | ```ruby 1912 | # 悪い例 1913 | '%d %d' % [20, 10] 1914 | # => '20 10' 1915 | 1916 | # 良い例 1917 | sprintf('%d %d', 20, 10) 1918 | # => '20 10' 1919 | 1920 | # 良い例 1921 | sprintf('%d %d', first: 20, second: 10) 1922 | # => '20 10' 1923 | 1924 | format('%d %d', 20, 10) 1925 | # => '20 10' 1926 | 1927 | # 良い例 1928 | format('%d %d', first: 20, second: 10) 1929 | # => '20 10' 1930 | ``` 1931 | 1932 | * 1933 | 名前付きフォーマット文字列を使用する場合、`%{name}`よりも`%s`を使いましょう。 1934 | `%s`は値の型に関する情報をエンコードするためです。 1935 | ^{[[link]](#named-format-tokens)} 1936 | 1937 | ```ruby 1938 | # 悪い例 1939 | format('Hello, %{name}', name: 'John') 1940 | 1941 | # 良い例 1942 | format('Hello, %s', name: 'John') 1943 | ``` 1944 | 1945 | * 1946 | あまりに暗号めいている`Array#*`メソッドよりも`Array#join`を使いましょう。 1947 | ^{[[link](#array-join)]} 1948 | 1949 | ```ruby 1950 | # 悪い例 1951 | %w[one two three] * ', ' 1952 | # => 'one, two, three' 1953 | 1954 | # 良い例 1955 | %w[one two three].join(', ') 1956 | # => 'one, two, three' 1957 | ``` 1958 | 1959 | * 1960 | 配列かどうかわからない変数を配列とみなして処理したいときは、 1961 | 明示的に`Array`かどうかチェックすることや`[*var]`よりも、`Array()`を使いましょう。 1962 | ^{[[link](#array-coercion)]} 1963 | 1964 | ```ruby 1965 | # 悪い例 1966 | paths = [paths] unless paths.is_a? Array 1967 | paths.each { |path| do_something(path) } 1968 | 1969 | # 悪い例 (常に新しいArrayのインスタンスを生成します) 1970 | [*paths].each { |path| do_something(path) } 1971 | 1972 | # 良い例 (そして少し読みやすいです) 1973 | Array(paths).each { |path| do_something(path) } 1974 | ``` 1975 | 1976 | * 1977 | ロジックを使って複雑な比較を行うよりも、 1978 | 可能な限り`Range`や`Comparable#between?`を用いましょう。 1979 | ^{[[link](#ranges-or-between)]} 1980 | 1981 | ```ruby 1982 | # 悪い例 1983 | do_something if x >= 1000 && x <= 2000 1984 | 1985 | # 良い例 1986 | do_something if (1000..2000).include?(x) 1987 | 1988 | # 良い例 1989 | do_something if x.between?(1000, 2000) 1990 | ``` 1991 | 1992 | * 1993 | `==`を明示した比較よりも判定メソッドを用いましょう。 1994 | 数値の比較はOKです。 1995 | ^{[[link](#predicate-methods)]} 1996 | 1997 | ```ruby 1998 | # 悪い例 1999 | if x % 2 == 0 2000 | end 2001 | 2002 | if x % 2 == 1 2003 | end 2004 | 2005 | if x == nil 2006 | end 2007 | 2008 | # 良い例 2009 | if x.even? 2010 | end 2011 | 2012 | if x.odd? 2013 | end 2014 | 2015 | if x.nil? 2016 | end 2017 | 2018 | if x.zero? 2019 | end 2020 | 2021 | if x == 0 2022 | end 2023 | ``` 2024 | 2025 | * 2026 | boolean値を扱わない限り、明示的な`nil`でないかの検査は避けましょう。 2027 | ^{[[link](#no-non-nil-checks)]} 2028 | 2029 | ```ruby 2030 | # 悪い例 2031 | do_something if !something.nil? 2032 | do_something if something != nil 2033 | 2034 | # 良い例 2035 | do_something if something 2036 | 2037 | # 良い例 - boolean値を扱うとき 2038 | def value_set? 2039 | !@some_boolean.nil? 2040 | end 2041 | ``` 2042 | 2043 | * 2044 | `BEGIN`ブロックの使用は避けましょう。 2045 | ^{[[link](#no-BEGIN-blocks)]} 2046 | 2047 | * 2048 | `END`ブロックを使ってはいけません。代わりに`Kernel#at_exit`を使いましょう。 2049 | ^{[[link](#no-END-blocks)]} 2050 | 2051 | ```ruby 2052 | # 悪い例 2053 | END { puts 'Goodbye!' } 2054 | 2055 | # 良い例 2056 | at_exit { puts 'Goodbye!' } 2057 | ``` 2058 | 2059 | * 2060 | フリップフロップの使用は避けましょう。 2061 | ^{[[link](#no-flip-flops)]} 2062 | 2063 | * 2064 | 制御構文で条件式のネストは避けましょう。 2065 | ^{[[link](#no-nested-conditionals)]} 2066 | 2067 | 不正なデータを弾きたいときはガード節を使いましょう。 2068 | ガード節とは、できるだけ素早く関数から抜けられるようにと 2069 | 関数の先頭に置かれている条件文のことです。 2070 | 2071 | ```ruby 2072 | # 悪い例 2073 | def compute_thing(thing) 2074 | if thing[:foo] 2075 | update_with_bar(thing[:foo]) 2076 | if thing[:foo][:bar] 2077 | partial_compute(thing) 2078 | else 2079 | re_compute(thing) 2080 | end 2081 | end 2082 | end 2083 | 2084 | # 良い例 2085 | def compute_thing(thing) 2086 | return unless thing[:foo] 2087 | update_with_bar(thing[:foo]) 2088 | return re_compute(thing) unless thing[:foo][:bar] 2089 | partial_compute(thing) 2090 | end 2091 | ``` 2092 | 2093 | ループ内では条件判定ブロックよりも`next`を使いましょう。 2094 | ```ruby 2095 | # 悪い例 2096 | [0, 1, 2, 3].each do |item| 2097 | if item > 1 2098 | puts item 2099 | end 2100 | end 2101 | 2102 | # 良い例 2103 | [0, 1, 2, 3].each do |item| 2104 | next unless item > 1 2105 | puts item 2106 | end 2107 | ``` 2108 | * 2109 | `collect`より`map`、`detect`より`find`、`find_all`より`select` 2110 | `inject`より`reduce`、`length`より`size`を使いましょう。 2111 | これは絶対のルールではないです。 2112 | 別名のほうが可読性に優れているなら、 2113 | そちらを使っていただいて構いません。 2114 | 韻を踏んでいるほうのメソッド名はSmalltalkから引き継いできたもので、 2115 | 他のプログラミング言語でそこまで一般的ではないです。 2116 | `find_all`よりも`select`が推奨されるのは、 2117 | `reject`との相性がよいことと、 2118 | メソッド名から挙動を推察することも容易だからです。 2119 | ^{[[link](#map-find-select-reduce-size)]} 2120 | 2121 | * 2122 | `size`の代わりに`count`を用いてはいけません。 2123 | `Array`以外の`Enumerable`オブジェクトでは、 2124 | `count`を使うと要素数の計算のためにコレクション全体を走査してしまいます。 2125 | ^{[[link](#count-vs-size)]} 2126 | 2127 | ```ruby 2128 | # 悪い例 2129 | some_hash.count 2130 | 2131 | # 良い例 2132 | some_hash.size 2133 | ``` 2134 | 2135 | * 2136 | `map`と`flatten`の組み合わせの代わりに、`flat_map`を用いましょう。 2137 | これは深さが２より大きい配列には適用できません。 2138 | すなわち、`users.first.songs == ['a', ['b','c']]`のときは、 2139 | `flat_map`より`map + flatten`を用いましょう。 2140 | `flatten`は配列を全て平坦にするのに対し、`flat_map`は配列を１次元だけ平坦にします。 2141 | ^{[[link](#flat-map)]} 2142 | 2143 | ```ruby 2144 | # 悪い例 2145 | all_songs = users.map(&:songs).flatten.uniq 2146 | 2147 | # 良い例 2148 | all_songs = users.flat_map(&:songs).uniq 2149 | ``` 2150 | 2151 | * 2152 | `reverse.each`の代わりに`reverse_each`を用いましょう。 2153 | 何故なら、`Enumerable`をincludeしているクラスの側で、 2154 | より効率のよい実装が行われていることがあるからです。 2155 | 最悪、クラスが特殊化を行っていない場合でも、`Enumerable`から継承される一般的な実装は、 2156 | `reverse.each`を用いた場合と同じ効率です。 2157 | ^{[[link](#reverse-each)]} 2158 | 2159 | ```ruby 2160 | # 悪い例 2161 | array.reverse.each { ... } 2162 | 2163 | # 良い例 2164 | array.reverse_each { ... } 2165 | ``` 2166 | 2167 | ## 命名規則 2168 | 2169 | > プログラミングで真に困難な領域は、キャッシュの無効化と命名にしかない。
2170 | > -- Phil Karlton 2171 | 2172 | * 2173 | 識別子は英語で名づけましょう。 2174 | ^{[[link](#english-identifiers)]} 2175 | 2176 | ```ruby 2177 | # 悪い例 - 識別子がnon-asciiな文字列です 2178 | заплата = 1_000 2179 | 2180 | # 悪い例 - (キリル文字の代わりに)ラテン文字で書かれてはいますが、識別子がブルガリア語です 2181 | zaplata = 1_000 2182 | 2183 | # 良い例 2184 | salary = 1_000 2185 | ``` 2186 | 2187 | * 2188 | シンボル、メソッド、変数には`snake_case`を用いましょう。 2189 | ^{[[link](#snake-case-symbols-methods-vars)]} 2190 | 2191 | ```ruby 2192 | # 悪い例 2193 | :'some symbol' 2194 | :SomeSymbol 2195 | :someSymbol 2196 | 2197 | someVar = 5 2198 | 2199 | def someMethod 2200 | # some code 2201 | end 2202 | 2203 | def SomeMethod 2204 | # some code 2205 | end 2206 | 2207 | # 良い例 2208 | :some_symbol 2209 | 2210 | some_var = 5 2211 | 2212 | def some_method 2213 | # some code 2214 | end 2215 | ``` 2216 | 2217 | * 2218 | シンボル、メソッド、および変数名において、文字と数字を分離しないようにしましょう。 2219 | ^{[[link](#snake-case-symbols-methods-vars-with-numbers)]} 2220 | 2221 | ```ruby 2222 | # 悪い例 2223 | :some_sym_1 2224 | 2225 | some_var_1 = 1 2226 | 2227 | var_10 = 10 2228 | 2229 | def some_method_1 2230 | # some code 2231 | end 2232 | 2233 | # 良い例 2234 | :some_sym1 2235 | 2236 | some_var1 = 1 2237 | 2238 | var10 = 10 2239 | 2240 | def some_method1 2241 | # some code 2242 | end 2243 | ``` 2244 | 2245 | * 2246 | クラスやモジュールには`CamelCase`を用いましょう。(HTTP、RFC、XMLのような頭字語は大文字を保ちましょう)。 2247 | ^{[[link](#camelcase-classes)]} 2248 | 2249 | ```ruby 2250 | # 悪い例 2251 | class Someclass 2252 | # some code 2253 | end 2254 | 2255 | class Some_Class 2256 | # some code 2257 | end 2258 | 2259 | class SomeXml 2260 | # some code 2261 | end 2262 | 2263 | class XmlSomething 2264 | # some code 2265 | end 2266 | 2267 | # 良い例 2268 | class SomeClass 2269 | # some code 2270 | end 2271 | 2272 | class SomeXML 2273 | # some code 2274 | end 2275 | 2276 | class XMLSomething 2277 | # some code 2278 | end 2279 | ``` 2280 | 2281 | * 2282 | ファイル名には`snake_case`を用いましょう。例えば`hello_world.rb`のように。 2283 | ^{[[link](#snake-case-files)]} 2284 | 2285 | * 2286 | ディレクトリ名には`snake_case`を用いましょう。例えば`lib/hello_world/hello_world.rb`のように。 2287 | ^{[[link](#snake-case-dirs)]} 2288 | 2289 | 2290 | * 2291 | ソースファイル１つにつきただ１つのクラス/モジュールだけが書かれている状態を目指しましょう。 2292 | そのファイルの名前はそのクラス/モジュールと同じ名前で、ただしキャメルケースをスネークケースに変換して用いましょう。 2293 | ^{[[link](#one-class-per-file)]} 2294 | 2295 | * 2296 | 他の定数は`SCREAMING_SNAKE_CASE`を用いましょう。 2297 | ^{[[link](#screaming-snake-case)]} 2298 | 2299 | ```ruby 2300 | # 悪い例 2301 | SomeConst = 5 2302 | 2303 | # 良い例 2304 | SOME_CONST = 5 2305 | ``` 2306 | 2307 | * 2308 | 述語メソッド(boolean値が返るメソッド)は疑問符で終わりましょう。 2309 | (すなわち`Array#empty?`のように)。 2310 | boolean値を返さないメソッドは、疑問符で終わるべきではないです。 2311 | ^{[[link](#bool-methods-qmark)]} 2312 | 2313 | * 2314 | 述語メソッドに `is`、` does`、 `can`のような助動詞をつけるべきではありません。 2315 | これらの単語は冗長で、Rubyコアライブラリの述語メソッドのスタイル 2316 | ( `empty？`や `include？`など)と矛盾しています。 2317 | ^{[[link](#bool-methods-prefix)]} 2318 | 2319 | ```ruby 2320 | # 悪い例 2321 | class Person 2322 | def is_tall? 2323 | true 2324 | end 2325 | 2326 | def can_play_basketball? 2327 | false 2328 | end 2329 | 2330 | def does_like_candy? 2331 | true 2332 | end 2333 | end 2334 | 2335 | # 良い例 2336 | class Person 2337 | def tall? 2338 | true 2339 | end 2340 | 2341 | def basketball_player? 2342 | false 2343 | end 2344 | 2345 | def likes_candy? 2346 | true 2347 | end 2348 | end 2349 | ``` 2350 | 2351 | * 2352 | *危険* な可能性のあるメソッド 2353 | (引数や`self`を変更するようなメソッドや、 2354 | `exit!`(`exit`と違ってファイナライザが走らない)のようなもの) 2355 | は、その安全なバージョンがある場合には、 *危険* であることを明示する意味で感嘆符で終わりましょう。 2356 | ^{[[link](#dangerous-method-bang)]} 2357 | 2358 | ```ruby 2359 | # 悪い例 - 対応する「安全」なメソッドが存在しません 2360 | class Person 2361 | def update! 2362 | end 2363 | end 2364 | 2365 | # 良い例 2366 | class Person 2367 | def update 2368 | end 2369 | end 2370 | 2371 | # 良い例 2372 | class Person 2373 | def update! 2374 | end 2375 | 2376 | def update 2377 | end 2378 | end 2379 | ``` 2380 | 2381 | * 2382 | 危険な(感嘆符付き)メソッドがあるときは、対応する安全な(感嘆符なし)メソッドを定義できないか検討しましょう。 2383 | ^{[[link](#safe-because-unsafe)]} 2384 | 2385 | ```ruby 2386 | class Array 2387 | def flatten_once! 2388 | res = [] 2389 | 2390 | each do |e| 2391 | [*e].each { |f| res << f } 2392 | end 2393 | 2394 | replace(res) 2395 | end 2396 | 2397 | def flatten_once 2398 | dup.flatten_once! 2399 | end 2400 | end 2401 | ``` 2402 | 2403 | * 2404 | 二項演算子や演算子風のメソッドを定義するときは、 2405 | 演算子の「対称性」を明確にするために引数名は`other`を用いましょう。 2406 | ここでいう対称性とは、演算子の両辺が典型的には同じ、 2407 | またはcoerce可能な型であるという意味です。 2408 | ^{[[link](#other-arg)]} 2409 | 2410 | * 対称性のある演算子や演算子風のメソッド（引数名を`other`とすべきもの）: `+`, `-`, `*`, `/`, `%`, `**`, `==`, 2411 | `>`, `<`, `|`, `&`, `^`, `eql?`, `equal?`; 2412 | * 対称性のない演算子（引数名を`other`とすべきではない）: `<<`, `[]` （コレクションとその要素の関係にある演算子）, 2413 | `===` （パターンやマッチの関係性）; 2414 | 2415 | このルールは演算子の両辺が同じセマンティクスを持っている場合 **のみ** に用いることに注意しましょう。 2416 | 典型的な例外としては、Ruby本体の`Array#*(int)`が挙げられます。 2417 | 2418 | ```ruby 2419 | # 良い例 2420 | def +(other) 2421 | # body omitted 2422 | end 2423 | 2424 | # 悪い例 2425 | def <<(other) 2426 | @internal << other 2427 | end 2428 | 2429 | # 良い例 2430 | def <<(item) 2431 | @internal << item 2432 | end 2433 | 2434 | # 悪い例 2435 | # Returns some string multiplied `other` times 2436 | def *(other) 2437 | # body omitted 2438 | end 2439 | 2440 | # 良い例 2441 | # Returns some string multiplied `num` times 2442 | def *(num) 2443 | # body omitted 2444 | end 2445 | ``` 2446 | 2447 | ## コメント 2448 | 2449 | > 良く書けたコードは、それ自身が最良のドキュメントでもある。 2450 | > コメントを書こうとしている時は、常に自問してほしい、 2451 | > "このコメントが不要になるようにコードを改善できるだろうか？" 2452 | > コードを改善した上で、ドキュメントでさらに明快にするのだ。 2453 | > -- Steve McConnell 2454 | 2455 | * 2456 | 自己説明的なコードを書いて、このセクションの残りのパートは無視しましょう。本当に！ 2457 | ^{[[link](#no-comments)]} 2458 | 2459 | * 2460 | コメントは英語で書きましょう。 2461 | ^{[[link](#english-comments)]} 2462 | 2463 | * 2464 | 最初の`#`とコメントの間にスペースを１つ入れましょう。 2465 | ^{[[link](#hash-space)]} 2466 | 2467 | * 2468 | １語より長いコメントは頭語を大文字化してピリオドを打ちましょう。 2469 | 文と文の間にはスペースを[一つだけ](https://en.wikipedia.org/wiki/Sentence_spacing)入れましょう。 2470 | ^{[[link](#english-syntax)]} 2471 | 2472 | * 2473 | 過剰なコメントは避けましょう。 2474 | ^{[[link](#no-superfluous-comments)]} 2475 | 2476 | ```ruby 2477 | # 悪い例 2478 | counter += 1 # カウンターをインクリメント 2479 | ``` 2480 | 2481 | * 2482 | コメントは最新に保ちましょう。 2483 | 古くなったコメントは、コメントがないより悪いです。 2484 | ^{[[link](#comment-upkeep)]} 2485 | 2486 | > 良いコードは良いジョークのようだ - なんの説明もいらない。
2487 | > — プログラマの格言 [Russ Olsen](http://eloquentruby.com/blog/2011/03/07/good-code-and-good-jokes/) 2488 | 2489 | * 2490 | 悪いコードを説明するコメントは避けましょう。 2491 | 自己説明的なコードへのリファクタリングを行いましょう 2492 | (「やるかやらないか — "やってみる"はなしだ。」 Yoda)。 2493 | ^{[[link](#refactor-dont-comment)]} 2494 | 2495 | ### 注釈 2496 | 2497 | * 2498 | 注釈は、通常関連するコードのすぐ上に書きましょう。 2499 | ^{[[link](#annotate-above)]} 2500 | 2501 | * 2502 | 注釈のキーワードの後ろは`: `を続けましょう。 2503 | その後ろに問題点を書きましょう。 2504 | ^{[[link](#annotate-keywords)]} 2505 | 2506 | * 2507 | もし問題点の記述に複数行かかる場合は、 2508 | 後続の行は`#`の後ろにスペース３つでインデントしましょう。 2509 | (通常の１つに加え、インデント目的に２つ) 2510 | ^{[[link](#indent-annotations)]} 2511 | 2512 | ```ruby 2513 | def bar 2514 | # FIXME: This has crashed occasionally since v3.2.1. It may 2515 | # be related to the BarBazUtil upgrade. 2516 | baz(:quux) 2517 | end 2518 | ``` 2519 | 2520 | * 2521 | もし問題が明らかで、説明すると冗長になる時は、 2522 | 問題のある行の末尾に、本文なしの注釈だけ付けましょう。 2523 | この用法は例外であり、ルールではありません。 2524 | ^{[[link](#rare-eol-annotations)]} 2525 | 2526 | ```ruby 2527 | def bar 2528 | sleep 100 # OPTIMIZE 2529 | end 2530 | ``` 2531 | 2532 | * 2533 | あとで追加されるべき、今はない特徴や機能の注釈には`TODO`を使いましょう。 2534 | ^{[[link](#todo)]} 2535 | 2536 | * 2537 | 直す必要がある壊れたコードの注釈には`FIXME`を使いましょう。 2538 | ^{[[link](#fixme)]} 2539 | 2540 | * 2541 | パフォーマンスに問題を及ぼすかもしれない遅い、または非効率なコードの注釈には`OPTIMIZE`を使いましょう。 2542 | ^{[[link](#optimize)]} 2543 | 2544 | * 2545 | 疑問の残るコードの書き方でコードの臭いを感じた箇所の注釈には`HACK`を使いましょう。 2546 | ^{[[link](#hack)]} 2547 | 2548 | * 2549 | 意図したとおりに動くか確認する必要がある箇所の注釈には`REVIEW`を使いましょう。 2550 | 例: `REVIEW: Are we sure this is how the client does X currently?` 2551 | ^{[[link](#review)]} 2552 | 2553 | * 2554 | 適切に感じるのであれば、他の独自のキーワードを用いても構いませんが、 2555 | それらのキーワードは`README`やそれに類するものに書いておきましょう。 2556 | ^{[[link](#document-annotations)]} 2557 | 2558 | ### マジックコメント 2559 | 2560 | * 2561 | マジックコメントは、全てのコメントとコードよりも上に置きましょう(Shebangは例外で、それに関しては次の項目を参照のこと)。 2562 | ^{[[link](#magic-comments-first)]} 2563 | 2564 | ```ruby 2565 | # 悪い例 2566 | # Some documentation about Person 2567 | 2568 | # frozen_string_literal: true 2569 | class Person 2570 | end 2571 | 2572 | # 良い例 2573 | # frozen_string_literal: true 2574 | 2575 | # Some documentation about Person 2576 | class Person 2577 | end 2578 | ``` 2579 | 2580 | * 2581 | ファイルにShebangが存在する場合は、マジックコメントはその下に置きましょう。 2582 | ^{[[link](#below-shebang)]} 2583 | 2584 | ```ruby 2585 | # 悪い例 2586 | # frozen_string_literal: true 2587 | #!/usr/bin/env ruby 2588 | 2589 | App.parse(ARGV) 2590 | 2591 | # 良い例 2592 | #!/usr/bin/env ruby 2593 | # frozen_string_literal: true 2594 | 2595 | App.parse(ARGV) 2596 | ``` 2597 | 2598 | * 2599 | マジックコメントが複数必要な場合、一つのマジックコメントは一つの行に置きましょう。 2600 | ^{[[link](#one-magic-comment-per-line)]} 2601 | 2602 | ```ruby 2603 | # 悪い例 2604 | # -*- frozen_string_literal: true; encoding: ascii-8bit -*- 2605 | 2606 | # 良い例 2607 | # frozen_string_literal: true 2608 | # encoding: ascii-8bit 2609 | ``` 2610 | 2611 | * 2612 | マジックコメントは、コードやドキュメントから空行で区切りましょう。 2613 | ^{[[link](#separate-magic-comments-from-code)]} 2614 | 2615 | ```ruby 2616 | # 悪い例 2617 | # frozen_string_literal: true 2618 | # Some documentation for Person 2619 | class Person 2620 | # Some code 2621 | end 2622 | 2623 | # 良い例 2624 | # frozen_string_literal: true 2625 | 2626 | # Some documentation for Person 2627 | class Person 2628 | # Some code 2629 | end 2630 | ``` 2631 | 2632 | ## クラスとモジュール 2633 | 2634 | * 2635 | クラス定義の構造には一貫性をもたせましょう。 2636 | ^{[[link](#consistent-classes)]} 2637 | 2638 | ```ruby 2639 | class Person 2640 | # extendとincludeを最初に書きます。 2641 | extend SomeModule 2642 | include AnotherModule 2643 | 2644 | # 内部クラス 2645 | CustomError = Class.new(StandardError) 2646 | 2647 | # 次に定数 2648 | SOME_CONSTANT = 20 2649 | 2650 | # 次にattribute系マクロ 2651 | attr_reader :name 2652 | 2653 | # (あれば) それ以外のマクロ 2654 | validates :name 2655 | 2656 | # publicクラスメソッドが続きます 2657 | def self.some_method 2658 | end 2659 | 2660 | # initializationはクラスメソッドと他のpublicメソッドの間に 2661 | def initialize 2662 | end 2663 | 2664 | # 他のpublicメソッドが続きます 2665 | def some_method 2666 | end 2667 | 2668 | # protectedとprivateのメソッドは最後のあたりにグループ化します 2669 | protected 2670 | 2671 | def some_protected_method 2672 | end 2673 | 2674 | private 2675 | 2676 | def some_private_method 2677 | end 2678 | end 2679 | ``` 2680 | 2681 | * 2682 | 複数のミックスインは、別々の行に分割しましょう。 2683 | ^{[[link](#mixin-grouping)]} 2684 | 2685 | ```ruby 2686 | # 悪い例 2687 | class Person 2688 | include Foo, Bar 2689 | end 2690 | 2691 | # 良い例 2692 | class Person 2693 | # 複数のミックスインは分割された文にします 2694 | include Foo 2695 | include Bar 2696 | end 2697 | ``` 2698 | 2699 | * 2700 | クラスの中に複数行あるようなクラスをネストしてはいけません。 2701 | それぞれのクラスごとにファイルに分けて、 2702 | 外側のクラスの名前のついたフォルダに含めるようにしましょう。 2703 | ^{[[link](#file-classes)]} 2704 | 2705 | ```ruby 2706 | # 悪い例 2707 | 2708 | # foo.rb 2709 | class Foo 2710 | class Bar 2711 | # 中に30メソッド 2712 | end 2713 | 2714 | class Car 2715 | # 中に20メソッド 2716 | end 2717 | 2718 | # 中に30メソッド 2719 | end 2720 | 2721 | # 良い例 2722 | 2723 | # foo.rb 2724 | class Foo 2725 | # 中に30メソッド 2726 | end 2727 | 2728 | # foo/bar.rb 2729 | class Foo 2730 | class Bar 2731 | # 中に30メソッド 2732 | end 2733 | end 2734 | 2735 | # foo/car.rb 2736 | class Foo 2737 | class Car 2738 | # 中に20メソッド 2739 | end 2740 | end 2741 | ``` 2742 | 2743 | * 2744 | 名前空間の中にクラスやモジュールを定義したり再定義したりする場合、 2745 | その名前空間を明示的にネストして記述しましょう。 2746 | Rubyの[レキシカルスコープ](https://cirw.in/blog/constant-lookup.html) 2747 | は定義された場所のモジュールのネスティングに依存しているため、 2748 | 名前解決演算子を用いてしまうと、定数参照が意図しない振る舞いをすることがあります。 2749 | ^{[[link](#namespace-definition)]} 2750 | 2751 | ```Ruby 2752 | module Utilities 2753 | class Queue 2754 | end 2755 | end 2756 | 2757 | # 悪い例 2758 | class Utilities::Store 2759 | Module.nesting # => [Utilities::Store] 2760 | 2761 | def initialize 2762 | # nestingにUtilitiesを含まないため、 2763 | # この参照はトップレベルの ::Queueを参照します。 2764 | @queue = Queue.new 2765 | end 2766 | end 2767 | 2768 | # 良い例 2769 | module Utilities 2770 | class WaitingList 2771 | Module.nesting # => [Utilities::WaitingList, Utilities] 2772 | 2773 | def initialize 2774 | @queue = Queue.new # Utilities::Queue を参照します 2775 | end 2776 | end 2777 | end 2778 | ``` 2779 | 2780 | * 2781 | クラスメソッドしかないクラスよりモジュールを使いましょう。 2782 | クラスはインスタンスを生成することに意味がある時にのみ使われるべきです。 2783 | ^{[[link](#modules-vs-classes)]} 2784 | 2785 | ```ruby 2786 | # 悪い例 2787 | class SomeClass 2788 | def self.some_method 2789 | # body omitted 2790 | end 2791 | 2792 | def self.some_other_method 2793 | # body omitted 2794 | end 2795 | end 2796 | 2797 | # 良い例 2798 | module SomeModule 2799 | module_function 2800 | 2801 | def some_method 2802 | # body omitted 2803 | end 2804 | 2805 | def some_other_method 2806 | # body omitted 2807 | end 2808 | end 2809 | ``` 2810 | 2811 | * 2812 | モジュールのインスタンスメソッドをクラスメソッドにしたいときは、 2813 | `extend self`よりも`module_function`を使いましょう。 2814 | ^{[[link](#module-function)]} 2815 | 2816 | ```ruby 2817 | # 悪い例 2818 | module Utilities 2819 | extend self 2820 | 2821 | def parse_something(string) 2822 | # do stuff here 2823 | end 2824 | 2825 | def other_utility_method(number, string) 2826 | # do some more stuff 2827 | end 2828 | end 2829 | 2830 | # 良い例 2831 | module Utilities 2832 | module_function 2833 | 2834 | def parse_something(string) 2835 | # do stuff here 2836 | end 2837 | 2838 | def other_utility_method(number, string) 2839 | # do some more stuff 2840 | end 2841 | end 2842 | ``` 2843 | 2844 | * 2845 | クラス階層の設計を行うときは、 2846 | [リスコフの置換原則](https://ja.wikipedia.org/wiki/%E3%83%AA%E3%82%B9%E3%82%B3%E3%83%95%E3%81%AE%E7%BD%AE%E6%8F%9B%E5%8E%9F%E5%89%87). 2847 | に従いましょう。 2848 | ^{[[link](#liskov)]} 2849 | 2850 | * 2851 | あなたのクラスを可能な限り 2852 | [SOLID](https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)) 2853 | に保ちましょう。 2854 | ^{[[link](#solid-design)]} 2855 | 2856 | * 2857 | ドメインオブジェクトのクラスにおいては常に適切な`to_s`メソッドを提供しましょう。 2858 | ^{[[link](#define-to-s)]} 2859 | 2860 | ```ruby 2861 | class Person 2862 | attr_reader :first_name, :last_name 2863 | 2864 | def initialize(first_name, last_name) 2865 | @first_name = first_name 2866 | @last_name = last_name 2867 | end 2868 | 2869 | def to_s 2870 | "#{first_name} #{last_name}" 2871 | end 2872 | end 2873 | ``` 2874 | 2875 | * 2876 | 単純なアクセサやミューテータの定義には、`attr`群を用いましょう。 2877 | ^{[[link](#attr_family)]} 2878 | 2879 | ```ruby 2880 | # 悪い例 2881 | class Person 2882 | def initialize(first_name, last_name) 2883 | @first_name = first_name 2884 | @last_name = last_name 2885 | end 2886 | 2887 | def first_name 2888 | @first_name 2889 | end 2890 | 2891 | def last_name 2892 | @last_name 2893 | end 2894 | end 2895 | 2896 | # 良い例 2897 | class Person 2898 | attr_reader :first_name, :last_name 2899 | 2900 | def initialize(first_name, last_name) 2901 | @first_name = first_name 2902 | @last_name = last_name 2903 | end 2904 | end 2905 | ``` 2906 | 2907 | * 2908 | アクセサやミューテータの場合、メソッド名の前に`get_`や`set_`をつけないようにしましょう。 2909 | アクセサ(リーダ)にはアトリビュートの名前を、ミューテータ(ライタ)には`attr_name=` 2910 | を使用するのはRubyの規約です。 2911 | ^{[[link](#accessor_mutator_method_names)]} 2912 | 2913 | ```ruby 2914 | # 悪い例 2915 | class Person 2916 | def get_name 2917 | "#{@first_name} #{@last_name}" 2918 | end 2919 | 2920 | def set_name(name) 2921 | @first_name, @last_name = name.split(' ') 2922 | end 2923 | end 2924 | 2925 | # 良い例 2926 | class Person 2927 | def name 2928 | "#{@first_name} #{@last_name}" 2929 | end 2930 | 2931 | def name=(name) 2932 | @first_name, @last_name = name.split(' ') 2933 | end 2934 | end 2935 | ``` 2936 | 2937 | * 2938 | `attr`の使用は避けましょう。代わりに`attr_reader`や`attr_accessor`を使いましょう。 2939 | ^{[[link](#attr)]} 2940 | 2941 | ```ruby 2942 | # 悪い例 - １つのアクセサしか作れません(Ruby 1.9で廃止されました) 2943 | attr :something, true 2944 | attr :one, :two, :three # attr_readerと同じです 2945 | 2946 | # 良い例 2947 | attr_accessor :something 2948 | attr_reader :one, :two, :three 2949 | ``` 2950 | 2951 | * 2952 | `Struct.new`の使用を考えましょう、 2953 | それは、単純なアクセサ、コンストラクタや比較演算子を定義してくれます。 2954 | ^{[[link](#struct-new)]} 2955 | 2956 | ```ruby 2957 | # 良い例 2958 | class Person 2959 | attr_accessor :first_name, :last_name 2960 | 2961 | def initialize(first_name, last_name) 2962 | @first_name = first_name 2963 | @last_name = last_name 2964 | end 2965 | end 2966 | 2967 | # より良い例 2968 | Person = Struct.new(:first_name, :last_name) do 2969 | end 2970 | ``` 2971 | 2972 | * 2973 | `Struct.new`で初期化されたインスタンスを拡張してはいけません。 2974 | それは余分なクラスレベルをもたらし、 2975 | 複数回`require`された時に、奇妙なエラーの原因にもなります。 2976 | ^{[[link](#no-extend-struct-new)]} 2977 | 2978 | ```ruby 2979 | # 悪い例 2980 | class Person < Struct.new(:first_name, :last_name) 2981 | end 2982 | 2983 | # 良い例 2984 | Person = Struct.new(:first_name, :last_name) 2985 | ``` 2986 | 2987 | * 2988 | あるクラスのインスタンス生成する追加の方法を提供したいときは、 2989 | ファクトリメソッドの追加を検討しましょう。 2990 | ^{[[link](#factory-methods)]} 2991 | 2992 | ```ruby 2993 | class Person 2994 | def self.create(options_hash) 2995 | # body omitted 2996 | end 2997 | end 2998 | ``` 2999 | 3000 | * 3001 | 継承より[ダック・タイピング](https://ja.wikipedia.org/wiki/%E3%83%80%E3%83%83%E3%82%AF%E3%83%BB%E3%82%BF%E3%82%A4%E3%83%94%E3%83%B3%E3%82%B0)を使いましょう。 3002 | ^{[[link](#duck-typing)]} 3003 | 3004 | ```ruby 3005 | # 悪い例 3006 | class Animal 3007 | # abstract method 3008 | def speak 3009 | end 3010 | end 3011 | 3012 | # 継承 3013 | class Duck < Animal 3014 | def speak 3015 | puts 'Quack! Quack' 3016 | end 3017 | end 3018 | 3019 | # 継承 3020 | class Dog < Animal 3021 | def speak 3022 | puts 'Bau! Bau!' 3023 | end 3024 | end 3025 | 3026 | # 良い例 3027 | class Duck 3028 | def speak 3029 | puts 'Quack! Quack' 3030 | end 3031 | end 3032 | 3033 | class Dog 3034 | def speak 3035 | puts 'Bau! Bau!' 3036 | end 3037 | end 3038 | ``` 3039 | 3040 | * 3041 | 継承での振る舞いが"扱いづらい"ので、クラス変数(`@@`)の使用は避けましょう。 3042 | ^{[[link](#no-class-vars)]} 3043 | 3044 | ```ruby 3045 | class Parent 3046 | @@class_var = 'parent' 3047 | 3048 | def self.print_class_var 3049 | puts @@class_var 3050 | end 3051 | end 3052 | 3053 | class Child < Parent 3054 | @@class_var = 'child' 3055 | end 3056 | 3057 | Parent.print_class_var # => will print 'child' 3058 | ``` 3059 | 3060 | このように、ひとつのクラス階層に属するすべてのクラスは、 3061 | １つのクラス変数を共有してしまいます。 3062 | クラス変数よりもクラスのインスタンス変数のほうを使うべきです。 3063 | 3064 | * 3065 | 意図した使い方に沿って、可視性(`private`、`protected`)を設定しましょう。 3066 | 全てを`public`(デフォルトの設定)のままにしないようにしましょう。 3067 | 結局私達は今 *Ruby* を書いているのだから。 *Python* ではなく。 3068 | ^{[[link](#visibility)]} 3069 | 3070 | * 3071 | `public`、`protected`、`private`は、適用するメソッド定義と同じインデントにしましょう。 3072 | そして、以降のすべてのメソッド定義に適用されることを強調するために、 3073 | それらの修飾子の前１行と後１行に空行を入れましょう。 3074 | ^{[[link](#indent-public-private-protected)]} 3075 | 3076 | ```ruby 3077 | class SomeClass 3078 | def public_method 3079 | # some code 3080 | end 3081 | 3082 | private 3083 | 3084 | def private_method 3085 | # some code 3086 | end 3087 | 3088 | def another_private_method 3089 | # some code 3090 | end 3091 | end 3092 | ``` 3093 | 3094 | * 3095 | クラスメソッドを定義するときは`def self.method`を用いましょう。 3096 | クラス名を繰り返さないので、簡単にリファクタリングできるようになります。 3097 | ^{[[link](#def-self-class-methods)]} 3098 | 3099 | ```ruby 3100 | class TestClass 3101 | # 悪い例 3102 | def TestClass.some_method 3103 | # body omitted 3104 | end 3105 | 3106 | # 良い例 3107 | def self.some_other_method 3108 | # body omitted 3109 | end 3110 | 3111 | # たくさんのクラスメソッドを定義しなければならない時 3112 | # この書き方も便利です。 3113 | class << self 3114 | def first_method 3115 | # body omitted 3116 | end 3117 | 3118 | def second_method_etc 3119 | # body omitted 3120 | end 3121 | end 3122 | end 3123 | ``` 3124 | 3125 | * 3126 | メソッドの別名をつける時は`alias`を使いましょう。 3127 | クラスのレキシカルスコープの中では`self`と同じように名前解決されます。 3128 | またユーザーにとっても、実行時やサブクラス側で明示的にエイリアスを変更しなければ、 3129 | 変更されないことが読み取りやすいです。 3130 | ^{[[link](#alias-method-lexically)]} 3131 | 3132 | ```ruby 3133 | class Westerner 3134 | def first_name 3135 | @names.first 3136 | end 3137 | 3138 | alias given_name first_name 3139 | end 3140 | ``` 3141 | 3142 | `alias`は`def`と同じく予約語なので、シンボルや文字列よりも名前そのものを使いましょう。 3143 | 言い換えると、`alias :foo :bar`ではなく、`alias foo bar`と書きましょう。 3144 | 3145 | また、Rubyがエイリアスや継承をどのように扱うか注意しましょう。 3146 | `alias`はそれが定義された地点で解決されたメソッドを参照します。 3147 | 動的には解決されません。 3148 | 3149 | ```ruby 3150 | class Fugitive < Westerner 3151 | def first_name 3152 | 'Nobody' 3153 | end 3154 | end 3155 | ``` 3156 | 3157 | この例では、`Fugitive#given_name`は、`Fugitive#first_name`ではなく、オリジナルの`Westerner#first_name`を呼び出します。 3158 | `Fugitive#given_name`もオーバーライドしたい時は、継承したクラスでも 3159 | 再定義しなければなりません。 3160 | 3161 | ```ruby 3162 | class Fugitive < Westerner 3163 | def first_name 3164 | 'Nobody' 3165 | end 3166 | 3167 | alias given_name first_name 3168 | end 3169 | ``` 3170 | 3171 | * 3172 | モジュールやクラス、実行時のシングルトンクラス等では、 3173 | `alias`の挙動が予期できないので、 3174 | エイリアス定義には常に`alias_method`を用いましょう。 3175 | ^{[[link](#alias-method)]} 3176 | 3177 | ```ruby 3178 | module Mononymous 3179 | def self.included(other) 3180 | other.class_eval { alias_method :full_name, :given_name } 3181 | end 3182 | end 3183 | 3184 | class Sting < Westerner 3185 | include Mononymous 3186 | end 3187 | ``` 3188 | 3189 | * 3190 | クラス(またはモジュール)メソッドが他のメソッドを呼び出す際は、 3191 | `self`または自分自身のクラス名の後に`.`を続けて使用しないようにしましょう。 3192 | これは、「サービスクラス」やそれと類似の、クラスがあたかも関数であるかのように 3193 | 扱われるコンセプトの場合でよく見られます。 3194 | この規則は、そのようなクラスで反復的なボイラープレートを減らす傾向があります。 3195 | ^{[[link](#class-and-self)]} 3196 | 3197 | ```ruby 3198 | class TestClass 3199 | # 悪い例 -- クラスのリネームやメソッドの移動の際に余分な手間がかかります 3200 | def self.call(param1, param2) 3201 | TestClass.new(param1).call(param2) 3202 | end 3203 | 3204 | # 悪い例 -- 必要以上に冗長です 3205 | def self.call(param1, param2) 3206 | self.new(param1).call(param2) 3207 | end 3208 | 3209 | # 良い例 3210 | def self.call(param1, param2) 3211 | new(param1).call(param2) 3212 | end 3213 | 3214 | # ...other methods... 3215 | end 3216 | ``` 3217 | 3218 | ## 例外 3219 | 3220 | * 3221 | 例外は`fail`より`raise`を使いましょう。 3222 | ^{[[link](#prefer-raise-over-fail)]} 3223 | 3224 | ```ruby 3225 | # 悪い例 3226 | fail SomeException, 'message' 3227 | 3228 | # 良い例 3229 | raise SomeException, 'message' 3230 | ``` 3231 | 3232 | * 3233 | ２引数の`raise`では、`RuntimeError`を明示しないようにしましょう。 3234 | ^{[[link](#no-explicit-runtimeerror)]} 3235 | 3236 | ```ruby 3237 | # 悪い例 3238 | raise RuntimeError, 'message' 3239 | 3240 | # 良い例 - デフォルトでRuntimeErrorが発生します 3241 | raise 'message' 3242 | ``` 3243 | 3244 | * 3245 | `raise`の引数としては例外クラスのインスタンスよりも、 3246 | 例外クラスとメッセージをそれぞれの引数で渡す方を使いましょう。 3247 | ^{[[link](#exception-class-messages)]} 3248 | 3249 | ```ruby 3250 | # 悪い例 3251 | raise SomeException.new('message') 3252 | # `raise SomeException.new('message'), backtrace`とする書き方が存在しないことに注意しましょう。 3253 | 3254 | # 良い例 3255 | raise SomeException, 'message' 3256 | # `raise SomeException, 'message', backtrace`の用法と一貫性があります 3257 | ``` 3258 | 3259 | * 3260 | `ensure`ブロックから`return`してはいけません。 3261 | もし`ensure`の中から明示的に値を返した場合は、 3262 | `return`はどの例外発生よりも優先されて、 3263 | 例外など発生していなかったかのように値を返してしまいます。 3264 | 事実上、例外は静かに捨てられます。 3265 | ^{[[link](#no-return-ensure)]} 3266 | 3267 | ```ruby 3268 | # 悪い例 3269 | def foo 3270 | raise 3271 | ensure 3272 | return 'very bad idea' 3273 | end 3274 | ``` 3275 | 3276 | * 3277 | 可能な場所では、 *暗黙のbeginブロック* を用いましょう。 3278 | ^{[[link](#begin-implicit)]} 3279 | 3280 | ```ruby 3281 | # 悪い例 3282 | def foo 3283 | begin 3284 | # main logic goes here 3285 | rescue 3286 | # failure handling goes here 3287 | end 3288 | end 3289 | 3290 | # 良い例 3291 | def foo 3292 | # main logic goes here 3293 | rescue 3294 | # failure handling goes here 3295 | end 3296 | ``` 3297 | 3298 | * 3299 | *不確実性のあるメソッド*(Avdi Grimmによって作られた言葉です) 3300 | を用いて`begin`の蔓延を和らげましょう。 3301 | ^{[[link](#contingency-methods)]} 3302 | 3303 | ```ruby 3304 | # 悪い例 3305 | begin 3306 | something_that_might_fail 3307 | rescue IOError 3308 | # handle IOError 3309 | end 3310 | 3311 | begin 3312 | something_else_that_might_fail 3313 | rescue IOError 3314 | # handle IOError 3315 | end 3316 | 3317 | # 良い例 3318 | def with_io_error_handling 3319 | yield 3320 | rescue IOError 3321 | # handle IOError 3322 | end 3323 | 3324 | with_io_error_handling { something_that_might_fail } 3325 | 3326 | with_io_error_handling { something_else_that_might_fail } 3327 | ``` 3328 | 3329 | * 3330 | 例外をもみ消してはいけません。 3331 | ^{[[link](#dont-hide-exceptions)]} 3332 | 3333 | ```ruby 3334 | # 悪い例 3335 | begin 3336 | # an exception occurs here 3337 | rescue SomeError 3338 | # the rescue clause does absolutely nothing 3339 | end 3340 | 3341 | # 悪い例 3342 | do_something rescue nil 3343 | ``` 3344 | 3345 | * 3346 | `rescue`を修飾子として利用するのは避けましょう。 3347 | ^{[[link](#no-rescue-modifiers)]} 3348 | 3349 | ```ruby 3350 | # 悪い例 - StandardErrorとそれを継承した全てのクラスをキャッチしてしまいます 3351 | read_file rescue handle_error($!) 3352 | 3353 | # 良い例 - Errno::ENOENTとそれを継承したクラスのみをキャッチします 3354 | def foo 3355 | read_file 3356 | rescue Errno::ENOENT => ex 3357 | handle_error(ex) 3358 | end 3359 | ``` 3360 | 3361 | 3362 | * 3363 | 制御フローに例外を使っては行けません。 3364 | ^{[[link](#no-exceptional-flows)]} 3365 | 3366 | ```ruby 3367 | # 悪い例 3368 | begin 3369 | n / d 3370 | rescue ZeroDivisionError 3371 | puts 'Cannot divide by 0!' 3372 | end 3373 | 3374 | # 良い例 3375 | if d.zero? 3376 | puts 'Cannot divide by 0!' 3377 | else 3378 | n / d 3379 | end 3380 | ``` 3381 | 3382 | * 3383 | `Exception`を`rescue`するのは避けましょう。 3384 | これは`exit`のシグナルも捕捉するため、プロセスを殺すのに`kill -9`が必要になります。 3385 | ^{[[link](#no-blind-rescues)]} 3386 | 3387 | ```ruby 3388 | # 悪い例 3389 | begin 3390 | # calls to exit and kill signals will be caught (except kill -9) 3391 | exit 3392 | rescue Exception 3393 | puts "you didn't really want to exit, right?" 3394 | # exception handling 3395 | end 3396 | 3397 | # 良い例 3398 | begin 3399 | # a blind rescue rescues from StandardError, not Exception as many 3400 | # programmers assume. 3401 | rescue => e 3402 | # exception handling 3403 | end 3404 | 3405 | # こちらも良い例 3406 | begin 3407 | # an exception occurs here 3408 | 3409 | rescue StandardError => e 3410 | # exception handling 3411 | end 3412 | 3413 | ``` 3414 | 3415 | * 3416 | より詳細な例外を`rescue`チェーンの上に配置しましょう。 3417 | そうでなければ、決して`rescue`されません。 3418 | ^{[[link](#exception-ordering)]} 3419 | 3420 | ```ruby 3421 | # 悪い例 3422 | begin 3423 | # 処理 3424 | rescue StandardError => e 3425 | # エラー処理 3426 | rescue IOError => e 3427 | # 決して到達しないエラー処理 3428 | end 3429 | 3430 | # 良い例 3431 | begin 3432 | # 処理 3433 | rescue IOError => e 3434 | # エラー処理 3435 | rescue StandardError => e 3436 | # エラー処理 3437 | end 3438 | ``` 3439 | 3440 | * 3441 | プログラム内で確保した外部リソースは、`ensure`で開放しましょう 3442 | ^{[[link](#release-resources)]} 3443 | 3444 | ```ruby 3445 | f = File.open('testfile') 3446 | begin 3447 | # .. process 3448 | rescue 3449 | # .. handle error 3450 | ensure 3451 | f.close if f 3452 | end 3453 | ``` 3454 | 3455 | * 3456 | 自動的にリソースを開放してくれる機能を含むメソッドを利用可能な時は、そちらを使いましょう。 3457 | ^{[[link](#auto-release-resources)]} 3458 | 3459 | ```ruby 3460 | # 悪い例 - 明示的にファイルディスクリプタを閉じる必要が有ります 3461 | f = File.open('testfile') 3462 | # ファイルに対する何らかのアクション 3463 | f.close 3464 | 3465 | # 良い例 - ファイルディスクリプタは自動的に閉じられます 3466 | File.open('testfile') do |f| 3467 | # ファイルに対する何らかのアクション 3468 | end 3469 | ``` 3470 | 3471 | * 3472 | 新しい例外クラスを導入するより、基本ライブラリの例外クラスを使いましょう 3473 | ^{[[link](#standard-exceptions)]} 3474 | 3475 | ## コレクション 3476 | 3477 | * 3478 | 配列やハッシュを生成する時はリテラル記法を使いましょう。 3479 | (コンストラクタに引数を渡す場合を除けば、ということですが) 3480 | ^{[[link](#literal-array-hash)]} 3481 | 3482 | ```ruby 3483 | # 悪い例 3484 | arr = Array.new 3485 | hash = Hash.new 3486 | 3487 | # 良い例 3488 | arr = [] 3489 | arr = Array.new(10) 3490 | hash = {} 3491 | hash = Hash.new(0) 3492 | ``` 3493 | 3494 | * 3495 | 単語(空でなく、スペースを含まない文字列)の配列を生成する時は 3496 | `%w`リテラルを使いましょう。 3497 | このルールは配列の要素が２つ以上の場合に限ります。 3498 | ^{[[link](#percent-w)]} 3499 | 3500 | ```ruby 3501 | # 悪い例 3502 | STATES = ['draft', 'open', 'closed'] 3503 | 3504 | # 良い例 3505 | STATES = %w[draft open closed] 3506 | ``` 3507 | 3508 | * 3509 | シンボルの配列が必要な時 3510 | (かつRuby 1.9との互換性を維持しなくていい時)は 3511 | `%i`リテラルを使いましょう。 3512 | このルールは配列の要素が２つ以上の場合に限ります。 3513 | ^{[[link](#percent-i)]} 3514 | 3515 | ```ruby 3516 | # 悪い例 3517 | STATES = [:draft, :open, :closed] 3518 | 3519 | # 良い例 3520 | STATES = %i[draft open closed] 3521 | ``` 3522 | 3523 | * 3524 | `Array`や`Hash`リテラルの最後の要素の後ろの`,`は避けましょう。 3525 | 複数行にわかれていない時は特に避けましょう。 3526 | ^{[[link](#no-trailing-array-commas)]} 3527 | 3528 | ```ruby 3529 | # 悪い例 - 簡単に要素を移動・追加・削除できますが、それでもお奨めできません 3530 | VALUES = [ 3531 | 1001, 3532 | 2020, 3533 | 3333, 3534 | ] 3535 | 3536 | # 悪い例 3537 | VALUES = [1001, 2020, 3333, ] 3538 | 3539 | # 良い例 3540 | VALUES = [1001, 2020, 3333] 3541 | ``` 3542 | 3543 | * 3544 | 配列に大きな隙間を作るのは避けましょう。 3545 | ^{[[link](#no-gappy-arrays)]} 3546 | 3547 | ```ruby 3548 | arr = [] 3549 | arr[100] = 1 # now you have an array with lots of nils 3550 | ``` 3551 | 3552 | * 3553 | 配列の最初や最後にアクセスしたいときは、 3554 | `[0]`や`[-1]`より`first`や`last`を使いましょう。 3555 | ^{[[link](#first-and-last)]} 3556 | 3557 | * 3558 | 要素が一意のものを扱うときは、`Array`の代わりに`Set`を用いましょう。 3559 | `Set`は要素に重複と順序がないようなコレクションの実装です。 3560 | これは`Array`の直感的な二項演算子と、`Hash`の速さが合わさっています。 3561 | ^{[[link](#set-vs-array)]} 3562 | 3563 | * 3564 | ハッシュのキーには文字列よりシンボルが好まれます。 3565 | ^{[[link](#symbols-as-keys)]} 3566 | 3567 | ```ruby 3568 | # 悪い例 3569 | hash = { 'one' => 1, 'two' => 2, 'three' => 3 } 3570 | 3571 | # 良い例 3572 | hash = { one: 1, two: 2, three: 3 } 3573 | ``` 3574 | 3575 | * 3576 | 変更のできるオブジェクトをハッシュのキーに使うのは避けましょう。 3577 | ^{[[link](#no-mutable-keys)]} 3578 | 3579 | * 3580 | ハッシュのキーがシンボルの時は、Ruby 1.9のハッシュリテラル記法を用いましょう。 3581 | ^{[[link](#hash-literals)]} 3582 | 3583 | ```ruby 3584 | # 悪い例 3585 | hash = { :one => 1, :two => 2, :three => 3 } 3586 | 3587 | # 良い例 3588 | hash = { one: 1, two: 2, three: 3 } 3589 | ``` 3590 | 3591 | * 3592 | Ruby 1.9のハッシュ記法とロケット記法を同じハッシュリテラル内で混在させてはいけません。 3593 | シンボルでないキーがある場合は、ロケット記法を使いましょう。 3594 | ^{[[link](#no-mixed-hash-syntaces)]} 3595 | 3596 | ```ruby 3597 | # 悪い例 3598 | { a: 1, 'b' => 2 } 3599 | 3600 | # 良い例 3601 | { :a => 1, 'b' => 2 } 3602 | ``` 3603 | 3604 | * 3605 | `Hash#has_key?`より`Hash#key?`を、 3606 | `Hash#has_value?`より`Hash#value?`を用いましょう。 3607 | ^{[[link](#hash-key)]} 3608 | 3609 | ```ruby 3610 | # 悪い例 3611 | hash.has_key?(:test) 3612 | hash.has_value?(value) 3613 | 3614 | # 良い例 3615 | hash.key?(:test) 3616 | hash.value?(value) 3617 | ``` 3618 | 3619 | * 3620 | `Hash#keys.each` の代わりに `Hash#each_key` を、 `Hsah#values.each` の代わりに 3621 | `Hash#each_value` を用いましょう。 3622 | ^{[[link](#hash-each)]} 3623 | 3624 | ```ruby 3625 | # 悪い例 3626 | hash.keys.each { |k| p k } 3627 | hash.values.each { |v| p v } 3628 | hash.each { |k, _v| p k } 3629 | hash.each { |_k, v| p v } 3630 | 3631 | # 良い例 3632 | hash.each_key { |k| p k } 3633 | hash.each_value { |v| p v } 3634 | ``` 3635 | 3636 | * 3637 | 存在すべきキーを扱う時は、`Hash#fetch`を用いましょう。 3638 | ^{[[link](#hash-fetch)]} 3639 | 3640 | ```ruby 3641 | heroes = { batman: 'Bruce Wayne', superman: 'Clark Kent' } 3642 | # 悪い例 - もし誤りがあってもすぐに気づくことができないかもしれません 3643 | heroes[:batman] # => 'Bruce Wayne' 3644 | heroes[:supermann] # => nil 3645 | 3646 | # 良い例 - fetchはKeyErrorを投げるので、問題が明らかになります 3647 | heroes.fetch(:supermann) 3648 | ``` 3649 | 3650 | * 3651 | `Hash#fetch`のデフォルト値を使い、自力でロジックを書かないようにしましょう。 3652 | ^{[[link](#hash-fetch-defaults)]} 3653 | 3654 | ```ruby 3655 | batman = { name: 'Bruce Wayne', is_evil: false } 3656 | 3657 | # 悪い例 - たんに||演算子を使ってしまうと偽値が入っていた時に望まない結果になります 3658 | batman[:is_evil] || true # => true 3659 | 3660 | # 良い例 - fetchなら偽値でも正しく動きます 3661 | batman.fetch(:is_evil, true) # => false 3662 | ``` 3663 | 3664 | * 3665 | `Hash#fetch`のデフォルト値は評価するべき式に副作用があったり実行コストが高いときはうまくいかないので、代わりにブロックを使いましょう。 3666 | ^{[[link](#use-hash-blocks)]} 3667 | 3668 | ```ruby 3669 | batman = { name: 'Bruce Wayne' } 3670 | 3671 | # 悪い例 - デフォルト値が使われると、先に評価してしまいます 3672 | # だから、もし複数回呼ばれると、プログラムが遅くなります 3673 | batman.fetch(:powers, get_batman_powers) # get_batman_powers は高コストな呼び出し 3674 | 3675 | # 良い例 - ブロックは後から評価されます。だから、KeyErrorが評価の引き金になります 3676 | batman.fetch(:powers) { get_batman_powers } 3677 | ``` 3678 | 3679 | * 3680 | ハッシュから連続して複数の値が必要になる時は、`Hash#values_at`を用いましょう。 3681 | ^{[[link](#hash-values-at)]} 3682 | 3683 | ```ruby 3684 | # 悪い例 3685 | email = data['email'] 3686 | username = data['nickname'] 3687 | 3688 | # 良い例 3689 | email, username = data.values_at('email', 'nickname') 3690 | ``` 3691 | 3692 | * 3693 | Ruby 1.9以降、ハッシュは順序付けられるということを信頼しましょう。 3694 | ^{[[link](#ordered-hashes)]} 3695 | 3696 | * 3697 | コレクションを走査している時に変更を加えてはいけません。 3698 | ^{[[link](#no-modifying-collections)]} 3699 | 3700 | * 3701 | コレクションにアクセスするとき、`[n]`の代替のリーダーメソッドが提供されている場合に 3702 | 直接`[n]`経由でアクセスすることは避けましょう。 3703 | `nil`に対して`[]`を呼ぶことを避けることが出来ます。 3704 | ^{[[link](#accessing-elements-directly)]} 3705 | 3706 | ```ruby 3707 | # 悪い例 3708 | Regexp.last_match[1] 3709 | 3710 | # 良い例 3711 | Regexp.last_match(1) 3712 | ``` 3713 | 3714 | * 3715 | コレクションに対するアクセサを提供するとき、 3716 | コレクション内の要素にアクセスする前に、 3717 | `nil`でアクセスするのを防ぐための代替のアクセス方法を提供しましょう。 3718 | ^{[[link](#provide-alternate-accessor-to-collections)]} 3719 | 3720 | ```ruby 3721 | # 悪い例 3722 | def awesome_things 3723 | @awesome_things 3724 | end 3725 | 3726 | # 良い例 3727 | def awesome_things(index = nil) 3728 | if index && @awesome_things 3729 | @awesome_things[index] 3730 | else 3731 | @awesome_things 3732 | end 3733 | end 3734 | ``` 3735 | 3736 | ## 数値 3737 | 3738 | * 3739 | 整数型の型をチェックする為に、`Integer`を使用して下さい。 3740 | `Fixnum`はプラットフォームに依存するため、32ビットマシンと64ビットマシンで異なる結果が返されます。 3741 | ^{[[link](#integer-type-checking)]} 3742 | 3743 | ```ruby 3744 | timestamp = Time.now.to_i 3745 | 3746 | # 悪い例 3747 | timestamp.is_a? Fixnum 3748 | timestamp.is_a? Bignum 3749 | 3750 | # 良い例 3751 | timestamp.is_a? Integer 3752 | ``` 3753 | 3754 | * 3755 | 乱数を生成する場合は、整数とオフセットの代わりに範囲リテラルを使用しましょう。 3756 | 意図が明確であるためです。サイコロの役割をシミュレートすることを想像してください: 3757 | ^{[[link](#random-numbers)]} 3758 | 3759 | ```ruby 3760 | # 悪い例 3761 | rand(6) + 1 3762 | 3763 | # 良い例 3764 | rand(1..6) 3765 | ``` 3766 | 3767 | ## 文字列 3768 | 3769 | * 3770 | 文字列連結の代わりに文字列挿入や文字列整形を使いましょう。 3771 | ^{[[link](#string-interpolation)]} 3772 | 3773 | ```ruby 3774 | # 悪い例 3775 | email_with_name = user.name + ' <' + user.email + '>' 3776 | 3777 | # 良い例 3778 | email_with_name = "#{user.name} <#{user.email}>" 3779 | 3780 | # 良い例 3781 | email_with_name = format('%s <%s>', user.name, user.email) 3782 | ``` 3783 | 3784 | * 3785 | 文字列リテラルの引用符は一貫したスタイルで使いましょう。 3786 | Rubyコミュニティでは、 3787 | デフォルトでシングルクォートを用いるもの (Option A)、 3788 | ダブルクォートを用いるもの (Option B) 3789 | の二つのよく使われるスタイルがあって、 3790 | どちらも良いと考えられています。 3791 | ^{[[link](#consistent-string-literals)]} 3792 | 3793 | * **(Option A)** 文字列挿入の必要がないときや、`\t`や`\n`｀’｀等の特別な文字がない場合は、 3794 | シングルクォーテーションを使いましょう。 3795 | 3796 | ```ruby 3797 | # 悪い例 3798 | name = "Bozhidar" 3799 | 3800 | name = 'De\'Andre' 3801 | 3802 | # 良い例 3803 | name = 'Bozhidar' 3804 | 3805 | name = "De'Andre" 3806 | ``` 3807 | 3808 | * **(Option B)** 文字列中に`"`を含んでいたり、エスケープ文字を抑えたいときでない限り、 3809 | ダブルクォーテーションを使いましょう。 3810 | 3811 | ```ruby 3812 | # 悪い例 3813 | name = 'Bozhidar' 3814 | 3815 | sarcasm = "I \"like\" it." 3816 | 3817 | # 良い例 3818 | name = "Bozhidar" 3819 | 3820 | sarcasm = 'I "like" it.' 3821 | ``` 3822 | 3823 | このガイド内の文字列リテラル表記は、 3824 | １つ目のスタイルを採用しています。 3825 | 3826 | * 3827 | 文字リテラル構文`?x`を用いてはいけません。 3828 | Ruby 1.9以降、この表記法を必要とする場面はないはずです — 3829 | `?x`は`'x'`(１文字の文字列)と解釈されるからです。 3830 | ^{[[link](#no-character-literals)]} 3831 | 3832 | ```ruby 3833 | # 悪い例 3834 | char = ?c 3835 | 3836 | # 良い例 3837 | char = 'c' 3838 | ``` 3839 | 3840 | * 3841 | 文字列の中の挿入されるインスタンス変数やグローバル変数の周りの 3842 | `{}`は省略してはいけません。 3843 | ^{[[link](#curlies-interpolate)]} 3844 | 3845 | ```ruby 3846 | class Person 3847 | attr_reader :first_name, :last_name 3848 | 3849 | def initialize(first_name, last_name) 3850 | @first_name = first_name 3851 | @last_name = last_name 3852 | end 3853 | 3854 | # 悪い例 - 有効ですが不格好です 3855 | def to_s 3856 | "#@first_name #@last_name" 3857 | end 3858 | 3859 | # 良い例 3860 | def to_s 3861 | "#{@first_name} #{@last_name}" 3862 | end 3863 | end 3864 | 3865 | $global = 0 3866 | # 悪い例 3867 | puts "$global = #$global" 3868 | 3869 | # 良い例 3870 | puts "$global = #{$global}" 3871 | ``` 3872 | 3873 | * 3874 | 文字列に挿入するときに`Object#to_s`を使ってはいけません。 3875 | 自動的に呼び出されます。 3876 | ^{[[link](#no-to-s)]} 3877 | 3878 | ```ruby 3879 | # 悪い例 3880 | message = "This is the #{result.to_s}." 3881 | 3882 | # 良い例 3883 | message = "This is the #{result}." 3884 | ``` 3885 | 3886 | * 3887 | 大きなデータの塊を作る必要があるときは、`String#+`の使用は避けましょう。 3888 | 代わりに、`String#<<`を使いましょう。 3889 | 文字列連結は、文字列インスタンスを直接書き換えるため、 3890 | たくさんの新しいオブジェクトを作ってしまう`String#+`よりも常に速いです。 3891 | ^{[[link](#concat-strings)]} 3892 | 3893 | ```ruby 3894 | # 悪い例 3895 | html = '' 3896 | html += '

Page title

' 3897 | 3898 | paragraphs.each do |paragraph| 3899 | html += "

#{paragraph}

" 3900 | end 3901 | 3902 | # 良く、そして速い例 3903 | html = '' 3904 | html << '

Page title

' 3905 | 3906 | paragraphs.each do |paragraph| 3907 | html << "

#{paragraph}

" 3908 | end 3909 | ``` 3910 | 3911 | * 3912 | 利用するケースにより特化した速い代替手段がある場合、`String#gsub`は使わないようにしましょう。 3913 | ^{[[link](#dont-abuse-gsub)]} 3914 | 3915 | ```ruby 3916 | url = 'http://example.com' 3917 | str = 'lisp-case-rules' 3918 | 3919 | # 悪い例 3920 | url.gsub('http://', 'https://') 3921 | str.gsub('-', '_') 3922 | 3923 | # 良い例 3924 | url.sub('http://', 'https://') 3925 | str.tr('-', '_') 3926 | ``` 3927 | 3928 | * 3929 | 複数行のヒアドキュメントを用いるときは、 3930 | 先頭のスペースも保持してしまうということを頭に入れておかなければなりません。 3931 | 過剰なスペースを取り除くためのマージンを採用するのはよい習慣です。 3932 | ^{[[link](#heredocs)]} 3933 | 3934 | ```ruby 3935 | code = <<-END.gsub(/^\s+\|/, '') 3936 | |def test 3937 | | some_method 3938 | | other_method 3939 | |end 3940 | END 3941 | # => "def test\n some_method\n other_method\nend\n" 3942 | ``` 3943 | 3944 | * 3945 | きちんとインデントされた複数行の文字列には、Ruby 2.3 の、インデントされた 3946 | ヒアドキュメントを使いましょう。 3947 | ^{[[link](#squiggly-heredocs)]} 3948 | 3949 | ```ruby 3950 | # 悪い例 - Powerpack の String#strip_margin を使用しています。 3951 | code = <<-RUBY.strip_margin('|') 3952 | |def test 3953 | | some_method 3954 | | other_method 3955 | |end 3956 | RUBY 3957 | 3958 | # こちらも悪い例 3959 | code = <<-RUBY 3960 | def test 3961 | some_method 3962 | other_method 3963 | end 3964 | RUBY 3965 | 3966 | # 良い例 3967 | code = <<~RUBY 3968 | def test 3969 | some_method 3970 | other_method 3971 | end 3972 | RUBY 3973 | ``` 3974 | 3975 | * 3976 | 3977 | ヒアドキュメントのデリミタは説明的な名前にしましょう。 3978 | デリミタはヒアドキュメントの内容に関して追加の情報になりますし、 3979 | エディタによっては適切なデリミタを使うことでヒアドキュメント内のコードをハイライトしてくれるかもしれません。 3980 | ^{[[link](#heredoc-delimiters)]} 3981 | 3982 | ```ruby 3983 | # 悪い例 3984 | code = <<~END 3985 | def foo 3986 | bar 3987 | end 3988 | END 3989 | 3990 | # 良い例 3991 | code = <<~RUBY 3992 | def foo 3993 | bar 3994 | end 3995 | RUBY 3996 | 3997 | # 良い例 3998 | code = <<~SUMMARY 3999 | 著名なSF作家アーサー C. クラークの短編を独創的に解釈したこの作品では、 4000 | 巨大な黒色の構造物が過去、そして未来とのつながりを指し示す。 4001 | SUMMARY 4002 | ``` 4003 | 4004 | ## 日時 4005 | 4006 | * 4007 | 現在のシステム時間を読み出すには、`Time.new`よりも`Time.now`を使いましょう。 4008 | ^{[[link](#time-now)]} 4009 | 4010 | * 4011 | 改暦を考慮する必要がある場合を除いて、`DateTime`を使用しないようにしましょう。 4012 | もし必要な場合は、`start`引数を明示的に指定して意図を明示して下さい。 4013 | ^{[[link](#no-datetime)]} 4014 | 4015 | ```ruby 4016 | # 悪い例 - DateTimeを現在の時刻の為に使用 4017 | DateTime.now 4018 | 4019 | # 良い例 - Timeを現在の時刻の為に使用 4020 | Time.now 4021 | 4022 | # 悪い例 - DateTimeを現代の日の為に使用 4023 | DateTime.iso8601('2016-06-29') 4024 | 4025 | # 良い例 - Dateを現代の日の為に使用 4026 | Date.iso8601('2016-06-29') 4027 | 4028 | # 良い例 - DateTimeを`start`と共に過去の日付の為に使用 4029 | DateTime.iso8601('1751-04-23', Date::ENGLAND) 4030 | ``` 4031 | 4032 | ## 正規表現 4033 | 4034 | > なにか問題に突き当たった時、「わかった、正規表現を使えばいいんだ」と思う人がいますね。 4035 | > その時、元の問題のほかにもう一つ問題が加わっているんです。
4036 | > -- Jamie Zawinski 4037 | 4038 | * 4039 | 単に文字列中から文字列を探すだけの時は、 4040 | 正規表現を使ってはいけません: `string['text']`を使いましょう。 4041 | ^{[[link](#no-regexp-for-plaintext)]} 4042 | 4043 | * 4044 | 文字列の添字に直接正規表現を渡すことで、文字列の構築をシンプルにできます。 4045 | ^{[[link](#regexp-string-index)]} 4046 | 4047 | ```ruby 4048 | match = string[/regexp/] # マッチした内容が得られる 4049 | first_group = string[/text(grp)/, 1] # キャプチャグループの内容が得られる 4050 | string[/text (grp)/, 1] = 'replace' # string => 'text replace' 4051 | ``` 4052 | 4053 | * 4054 | キャプチャした結果を使う必要のないときは、キャプチャしないグループを用いましょう。 4055 | ^{[[link](#non-capturing-regexp)]} 4056 | 4057 | ```ruby 4058 | # 悪い例 4059 | /(first|second)/ 4060 | 4061 | # 良い例 4062 | /(?:first|second)/ 4063 | ``` 4064 | 4065 | * 4066 | 最後に正規表現にマッチした値を示すPerlレガシーの暗号的な変数を用いてはいけません 4067 | (`$1`、`$2`など)。 4068 | 代わりに`Regexp.last_match(n)`を用いましょう。 4069 | ^{[[link](#no-perl-regexp-last-matchers)]} 4070 | 4071 | ```ruby 4072 | /(regexp)/ =~ string 4073 | ... 4074 | 4075 | # 悪い例 4076 | process $1 4077 | 4078 | # 良い例 4079 | process Regexp.last_match(1) 4080 | ``` 4081 | 4082 | 4083 | * 4084 | どの値が入っているか追うのが困難になるので、 4085 | グループ番号を使うのは避けましょう。 4086 | 代わりにグループに名前をつけましょう。 4087 | ^{[[link](#no-numbered-regexes)]} 4088 | 4089 | ```ruby 4090 | # 悪い例 4091 | /(regexp)/ =~ string 4092 | # some code 4093 | process Regexp.last_match(1) 4094 | 4095 | # 良い例 4096 | /(?regexp)/ =~ string 4097 | # some code 4098 | process meaningful_var 4099 | ``` 4100 | 4101 | * 4102 | 文字クラスの中では、特別な意味を持つ文字が少ないので注意が必要です: 4103 | `^`、`-`、`\`、`]`のみが特別な意味を持つので、 4104 | `.`や括弧を`[]`の中でエスケープしてはいけません。 4105 | ^{[[link](#limit-escapes)]} 4106 | 4107 | * 4108 | `^`や`$`は、文字列の先頭や末尾ではなく、 4109 | 行頭や行末にマッチするので注意が必要です。 4110 | もし文字列全体の先頭末尾にマッチさせたいときは、 4111 | `\A`、`\z`を使いましょう 4112 | (`\n?\z`と等価である`\Z`と混同しないようにしましょう)。 4113 | ^{[[link](#caret-and-dollar-regexp)]} 4114 | 4115 | ```ruby 4116 | string = "some injection\nusername" 4117 | string[/^username$/] # matches 4118 | string[/\Ausername\z/] # don't match 4119 | ``` 4120 | 4121 | * 4122 | 複雑な正規表現には`x`識別子を用いましょう。 4123 | これを用いることで、より読みやすくなり、 4124 | 便利なコメントを使えるようになります。 4125 | スペースが無視されることに注意しましょう。 4126 | ^{[[link](#comment-regexes)]} 4127 | 4128 | ```ruby 4129 | regexp = / 4130 | start # some text 4131 | \s # white space char 4132 | (group) # first group 4133 | (?:alt1|alt2) # some alternation 4134 | end 4135 | /x 4136 | ``` 4137 | 4138 | * 4139 | `sub`/`gsub`での複雑な置換は、ブロックやハッシュを用いることで実現できます。 4140 | ^{[[link](#gsub-blocks)]} 4141 | 4142 | ```ruby 4143 | words = 'foo bar' 4144 | words.sub(/f/, 'f' => 'F') # => 'Foo bar' 4145 | words.gsub(/\w+/) { |word| word.capitalize } # => 'Foo Bar' 4146 | ``` 4147 | 4148 | ## パーセントリテラル 4149 | 4150 | * 4151 | 文字列挿入と`"`文字の双方が入る１行の文字列には、 4152 | `%()`(`%Q()`の短縮形)を使いましょう。 4153 | 複数行の時はヒアドキュメントを使いましょう。 4154 | ^{[[link](#percent-q-shorthand)]} 4155 | 4156 | ```ruby 4157 | # 悪い例 (挿入の必要がありません) 4158 | %(

Some text

) 4159 | # '

Some text

' であるべき 4160 | 4161 | # 悪い例 (ダブルクォートがありません) 4162 | %(This is #{quality} style) 4163 | # "This is #{quality} style" であるべき 4164 | 4165 | # 悪い例 (複数行です) 4166 | %(

\n#{exclamation}\n

) 4167 | # ヒアドキュメントであるべき 4168 | 4169 | # 良い例 (挿入が必要、ダブルクォートがある、そして１行です) 4170 | %(#{name}) 4171 | ``` 4172 | 4173 | * 4174 | 文字列に`'`と`"`双方が含まれない限り、 4175 | `%()`や、それと同等の`%q()`の使用は避けましょう。 4176 | 通常の文字列リテラルのほうがより読みやすいので、 4177 | エスケープが大量に必要出ない限りは、そちらを使いましょう。 4178 | ^{[[link](#percent-q)]} 4179 | 4180 | ```ruby 4181 | # 悪い例 4182 | name = %q(Bruce Wayne) 4183 | time = %q(8 o'clock) 4184 | question = %q("What did you say?") 4185 | 4186 | # 良い例 4187 | name = 'Bruce Wayne' 4188 | time = "8 o'clock" 4189 | question = '"What did you say?"' 4190 | ``` 4191 | 4192 | * 4193 | `'/'`が１つ *以上の* 正規表現に限り、`%r`を使いましょう。 4194 | ^{[[link](#percent-r)]} 4195 | 4196 | ```ruby 4197 | # 悪い例 4198 | %r{\s+} 4199 | 4200 | # 良い例 4201 | %r{^/(.*)$} 4202 | %r{^/blog/2011/(.*)$} 4203 | ``` 4204 | 4205 | * 4206 | 呼び出すコマンドにバッククォートが含まれる(かなり起こりえないが)ことがない限り、 4207 | `%x`の使用は避けましょう。 4208 | ^{[[link](#percent-x)]} 4209 | 4210 | ```ruby 4211 | # 悪い例 4212 | date = %x(date) 4213 | 4214 | # 良い例 4215 | date = `date` 4216 | echo = %x(echo `date`) 4217 | ``` 4218 | 4219 | * 4220 | `%s`の使用は避けましょう。 4221 | Rubyコミュニティは、スペースを含むシンボルを作る時は 4222 | `:"文字列"`がよいと決めたようです。 4223 | ^{[[link](#percent-s)]} 4224 | 4225 | * 4226 | さまざまな種類のパーセントリテラルに最も適した括弧を使用します。 4227 | ^{[[link](#percent-literal-braces)]} 4228 | - 文字列リテラル(`%q`, `%Q`)には`()`を使用しましょう。 4229 | - 配列リテラル(`%w`, `%i`, `%W`, `%I`)には、標準の配列リテラルに 4230 | 合わせて`[]`を使用しましょう。 4231 | - 正規表現リテラル(`%r`)には、`{}`を使用しましょう。 4232 | 正規表現の中に括弧が現れることが多いためです。 4233 | `{`が最も一般的でない為、`%r`の区切り文字には最適です。 4234 | - その他のリテラル(例えば `%s`, `%x`)には`()`を使用しましょう。 4235 | 4236 | ```ruby 4237 | # 悪い例 4238 | %q{"Test's king!", John said.} 4239 | 4240 | # 良い例 4241 | %q("Test's king!", John said.) 4242 | 4243 | # 悪い例 4244 | %w(one two three) 4245 | %i(one two three) 4246 | 4247 | # 良い例 4248 | %w[one two three] 4249 | %i[one two three] 4250 | 4251 | # 悪い例 4252 | %r((\w+)-(\d+)) 4253 | %r{\w{1,2}\d{2,5}} 4254 | 4255 | # 良い例 4256 | %r{(\w+)-(\d+)} 4257 | %r|\w{1,2}\d{2,5}| 4258 | ``` 4259 | 4260 | ## メタプログラミング 4261 | 4262 | * 4263 | 不要なメタプログラミングは避けましょう。 4264 | ^{[[link](#no-needless-metaprogramming)]} 4265 | 4266 | * 4267 | ライブラリを作成する時にコアクラスを汚染するのはやめましょう。 4268 | (モンキーパッチを当ててはいけません)。 4269 | ^{[[link](#no-monkey-patching)]} 4270 | 4271 | * 4272 | ブロック渡しの`class_eval`のほうが、文字列挿入型よりも好ましいです。 4273 | ^{[[link](#block-class-eval)]} 4274 | 4275 | ```ruby 4276 | class_eval 'def use_relative_model_naming?; true; end', __FILE__, __LINE__ 4277 | ``` 4278 | 4279 | - 文字列挿入型を使う時は、バックトレースが働くように、常に`__FILE__`と`__LINE__`を渡しましょう: 4280 | 4281 | ```ruby 4282 | class_eval 'def use_relative_model_naming?; true; end', __FILE__, __LINE__ 4283 | ``` 4284 | 4285 | - `define_method`の方が、`class_eval{ def ... }`よりも好ましいです。 4286 | 4287 | * 4288 | 文字列挿入型の`class_eval`(または他の`eval`)を用いる時は、 4289 | 挿入されたときのコードをコメントに追加しましょう(Railsで使われているプラクティス)。 4290 | ^{[[link](#eval-comment-docs)]} 4291 | 4292 | ```ruby 4293 | # from activesupport/lib/active_support/core_ext/string/output_safety.rb 4294 | UNSAFE_STRING_METHODS.each do |unsafe_method| 4295 | if 'String'.respond_to?(unsafe_method) 4296 | class_eval <<-EOT, __FILE__, __LINE__ + 1 4297 | def #{unsafe_method}(*params, &block) # def capitalize(*params, &block) 4298 | to_str.#{unsafe_method}(*params, &block) # to_str.capitalize(*params, &block) 4299 | end # end 4300 | 4301 | def #{unsafe_method}!(*params) # def capitalize!(*params) 4302 | @dirty = true # @dirty = true 4303 | super # super 4304 | end # end 4305 | EOT 4306 | end 4307 | end 4308 | ``` 4309 | 4310 | * 4311 | `method_missing`を用いたメタプログラミングは避けましょう。 4312 | 何故なら、バックトレースがよくわからなくなるし、 4313 | `#methods`のリストの中に出てこず、 4314 | ミススペルしたメソッド呼び出しも無言で動いてしまいます、 4315 | 例えば`nukes.launch_state = false`のようにです。 4316 | 代わりに、移譲、プロキシ、または`define_method`を使いましょう。 4317 | もし`method_missing`を使わなければならない時は: 4318 | ^{[[link](#no-method-missing)]} 4319 | 4320 | - [`respond_to_missing?`](http://blog.marc-andre.ca/2010/11/methodmissing-politely.html)も実装されているか確かめましょう 4321 | - 既知の接頭辞、`find_by_*`のようなものだけを捕捉しましょう -- 可能な限りアサートさせましょう 4322 | - 最後に`super`を呼び出しましょう 4323 | - アサートする、特別でないメソッドに移譲しましょう: 4324 | 4325 | ```ruby 4326 | # 悪い例 4327 | def method_missing(meth, *params, &block) 4328 | if /^find_by_(?.*)/ =~ meth 4329 | # ... lots of code to do a find_by 4330 | else 4331 | super 4332 | end 4333 | end 4334 | 4335 | # 良い例 4336 | def method_missing(meth, *args, &block) 4337 | if /^find_by_(?.*)/ =~ meth 4338 | find_by(prop, *args, &block) 4339 | else 4340 | super 4341 | end 4342 | end 4343 | 4344 | # というか、最も良い選択は、発見できる全てのアトリビュートにdefine_methodすることです 4345 | ``` 4346 | 4347 | * 4348 | `private`/`protected`制約を回避しないために、`send`よりも`public_send`を使いましょう。 4349 | ^{[[link](#prefer-public-send)]} 4350 | 4351 | ```ruby 4352 | # OrganizationというActiveModelがあって、Activatableをincludeしている 4353 | module Activatable 4354 | extend ActiveSupport::Concern 4355 | 4356 | included do 4357 | before_create :create_token 4358 | end 4359 | 4360 | private 4361 | 4362 | def reset_token 4363 | # some code 4364 | end 4365 | 4366 | def create_token 4367 | # some code 4368 | end 4369 | 4370 | def activate! 4371 | # some code 4372 | end 4373 | end 4374 | 4375 | class Organization < ActiveRecord::Base 4376 | include Activatable 4377 | end 4378 | 4379 | linux_organization = Organization.find(...) 4380 | # 悪い例 - 可視性を無視している 4381 | linux_organization.send(:reset_token) 4382 | # 良い例 - 例外があがる 4383 | linux_organization.public_send(:reset_token) 4384 | ``` 4385 | 4386 | * 4387 | `send`は他の既存のメソッドと衝突するかもしれないので、`__send__`を使いましょう。 4388 | ^{[[link](#prefer-__send__)]} 4389 | 4390 | ```ruby 4391 | require 'socket' 4392 | 4393 | u1 = UDPSocket.new 4394 | u1.bind('127.0.0.1', 4913) 4395 | u2 = UDPSocket.new 4396 | u2.connect('127.0.0.1', 4913) 4397 | # レシーバーオブジェクトにメッセージが送信されない 4398 | # かわりに、UDPソケット経由でメッセージが送信されてしまう 4399 | u2.send :sleep, 0 4400 | # こちらならたしかにレシーバーオブジェクトにメッセージが送信される 4401 | u2.__send__ ... 4402 | ``` 4403 | 4404 | ## 雑則 4405 | 4406 | * 4407 | `ruby -w`で実行しても何も警告されないコードを書きましょう。 4408 | ^{[[link](#always-warn)]} 4409 | 4410 | * 4411 | オプショナルな変数としてのハッシュの使用を避けましょう。そのメソッドはあまりにたくさんのことをやろうとしていませんか？(オブジェクトの初期化はこのルールの例外です) 4412 | ^{[[link](#no-optional-hash-params)]} 4413 | 4414 | * 4415 | コードのある行が10行を超えるメソッドは避けましょう。 4416 | 理想を言えば、多くのメソッドは5行以内がよいです。 4417 | 空行は行数には含めません。 4418 | ^{[[link](#short-methods)]} 4419 | 4420 | * 4421 | ３つや４つ以上引数を設定するのは避けましょう。 4422 | ^{[[link](#too-many-params)]} 4423 | 4424 | * 4425 | もし本当にグローバルなメソッドが必要な場合は、 4426 | Kernelに定義し、privateに設定しましょう。 4427 | ^{[[link](#private-global-methods)]} 4428 | 4429 | * 4430 | グローバル変数の代わりに、モジュールのインスタンス変数を使用しましょう。 4431 | ^{[[link](#instance-vars)]} 4432 | 4433 | ```ruby 4434 | # 悪い例 4435 | $foo_bar = 1 4436 | 4437 | # 良い例 4438 | module Foo 4439 | class << self 4440 | attr_accessor :bar 4441 | end 4442 | end 4443 | 4444 | Foo.bar = 1 4445 | ``` 4446 | 4447 | * 4448 | 複雑なコマンドラインオプションをパースするために`OptionParser`を使いましょう。 4449 | また、些細なオプションには`ruby -s`を使いましょう。 4450 | ^{[[link](#optionparser)]} 4451 | 4452 | * 4453 | 破壊的変更をしなくても済むなら、できるだけ関数的プログラミング手法を使いましょう。 4454 | ^{[[link](#functional-code)]} 4455 | 4456 | 4457 | ```ruby 4458 | a = []; [1, 2, 3].each { |i| a << i * 2 } # 悪い例 4459 | a = [1, 2, 3].map { |i| i * 2 } # 良い例 4460 | 4461 | a = {}; [1, 2, 3].each { |i| a[i] = i * 17 } # 悪い例 4462 | a = [1, 2, 3].reduce({}) { |h, i| h[i] = i * 17; h } # 良い例 4463 | a = [1, 2, 3].each_with_object({}) { |i, h| h[i] = i * 17 } # 良い例 4464 | ``` 4465 | 4466 | * 4467 | それがメソッドの目的でない限り、引数に破壊的変更をするのはやめましょう。 4468 | ^{[[link](#no-param-mutations)]} 4469 | 4470 | * 4471 | ３段階を超えるブロックのネストは避けましょう。 4472 | ^{[[link](#three-is-the-number-thou-shalt-count)]} 4473 | 4474 | * 4475 | 一貫性を保ちましょう。理想を言えば、このガイドラインに沿いましょう。 4476 | ^{[[link](#be-consistent)]} 4477 | 4478 | * 4479 | 常識を用いましょう。 4480 | ^{[[link](#common-sense)]} 4481 | 4482 | ## ツール 4483 | 4484 | ここでは、このガイドに反するコードを自動的にチェックするのを支援するツールをいくつか紹介します。 4485 | 4486 | ### RuboCop 4487 | 4488 | [RuboCop][]は、このガイドに基づいた 4489 | Rubyコードスタイルチェッカーです。 4490 | RuboCopはすでにこのガイドの重要な部分をカバーしており、 4491 | MRI 1.9、MRI 2.0 双方をサポートし、Emacs向けのよいプラグインがあります。 4492 | 4493 | ### RubyMine 4494 | 4495 | [RubyMine](http://www.jetbrains.com/ruby/) のコードインスペクションは、このガイドに 4496 | [部分的に基づいています](http://confluence.jetbrains.com/display/RUBYDEV/RubyMine+Inspections)。 4497 | 4498 | # Contributing 4499 | 4500 | このガイドはまだ未完成です — いくつかのルールは例がなく、いくつかのルールの例はじゅうぶんにクリアにルールを説明できていません。 4501 | そのようなルールの改善はRubyコミュニティを助ける素晴らしい(そしてシンプルな)手段です! 4502 | 4503 | これらの課題はやがて解決されると思いたいです — ただ現状にご留意ください。 4504 | 4505 | このガイドに書いてあることには変更不能なものはありません。 4506 | Rubyのコードスタイルに興味のある全ての人と共に取り組むことで、 4507 | 究極的には、全てのRubyコミュニティにとって有益なリソースを作ることができればと思っています。 4508 | 4509 | 改善のために、遠慮せずチケットを立てたりプルリクエストを送ったりしてください。 4510 | あなたの手助けに予め感謝します！ 4511 | 4512 | また、このプロジェクト(とRuboCop)への金銭的な貢献は、 4513 | [Patreon](https://www.patreon.com/bbatsov)経由で行うことができます。 4514 | 4515 | ## 貢献するには 4516 | 4517 | 簡単です！ [contribution guidelines](https://github.com/rubocop-hq/ruby-style-guide/blob/master/CONTRIBUTING.md)を読んでください！ 4518 | 4519 | # ライセンス 4520 | 4521 | ![Creative Commons License](http://i.creativecommons.org/l/by/3.0/88x31.png) 4522 | この著作物は、[Creative Commons Attribution 3.0 Unported License](http://creativecommons.org/licenses/by/3.0/deed.en_US) 4523 | に従います。 4524 | 4525 | # 広めましょう 4526 | 4527 | コミュニティ駆動のスタイルガイドは、これを知らないコミュニティにはほとんど役に立ちません。 4528 | このガイドについてつぶやいたり、友達や同僚にシェアしてください。 4529 | 全てのコメント、提案、オプションがこのガイドを少しだけでも良くしていきます。 4530 | そして、考えうるベストのガイドが欲しいですよね？ 4531 | 4532 | ありがとう
4533 | [Bozhidar](https://twitter.com/bbatsov) 4534 | 4535 | [PEP-8]: https://www.python.org/dev/peps/pep-0008/ 4536 | [rails-style-guide]: https://github.com/rubocop-hq/rails-style-guide 4537 | [pickaxe]: https://pragprog.com/book/ruby4/programming-ruby-1-9-2-0 4538 | [trpl]: http://www.amazon.com/Ruby-Programming-Language-David-Flanagan/dp/0596516177 4539 | [Pandoc]: http://pandoc.org/ 4540 | [RuboCop]: https://github.com/rubocop-hq/rubocop 4541 | [yard]: https://yardoc.org/ 4542 | --------------------------------------------------------------------------------