mvc開啟gzip緊縮示例分享

mvc開啟gzip緊縮示例分享。本站提示廣大學習愛好者：（mvc開啟gzip緊縮示例分享）文章只能為提供參考，不一定能成為您想要的結果。以下是mvc開啟gzip緊縮示例分享正文

在 class 界說裡應用分歧的構造。

class Person
   # extend and include go first
   extend SomeModule
   include AnotherModule

   # constants are next
   SOME_CONSTANT = 20

   # afterwards we have attribute macros
   attr_reader :name

   # followed by other macros (if any)
   validates :name

   # public class methods are next in line
   def self.some_method
   end

   # followed by public instance methods
   def some_method
   end

   # protected and private methods are grouped near the end
   protected

   def some_protected_method
   end

   private

   def some_private_method
   end
  end

    偏向應用 module，而不是只要類辦法的 class。種別應當只在創立實例是公道的時刻應用。

 # bad
  class SomeClass
   def self.some_method
    # body omitted
   end

   def self.some_other_method
   end
  end

  # good
  module SomeClass
   module_function

   def some_method
    # body omitted
   end

   def some_other_method
   end
  end

    當你願望將模塊的實例辦法釀成 class 辦法時，偏心應用 module_function 勝過 extend self。

  # bad
  module Utilities
   extend self

   def parse_something(string)
    # do stuff here
   end

   def other_utility_method(number, string)
    # do some more stuff
   end
  end

  # good
  module Utilities
   module_function

   def parse_something(string)
    # do stuff here
   end

   def other_utility_method(number, string)
    # do some more stuff
   end
  end

    When designing class hierarchies make sure that they conform to the
    Liskov Substitution Principle.

    在設計類條理的時刻確保他們相符 Liskov Substitution Principle 准繩。(譯者注: LSP准繩年夜概寄義為: 假如一個函數中援用了 父類的實例, 則必定可使用其子類的實例替換, 而且函數的根本功效不變. (固然功效許可被擴大))

        Liskov調換准繩：子類型必需可以或許調換它們的基類型 <br/>
        1. 假如每個類型為T1的對象o1，都有類型為T2的對象o2，使得以T1界說的一切法式P在一切的對象o1都代換為o2時,法式P的行動沒有變更，那末類型T2是類型T1的子類型。 <br/>
        2. 換言之，一個軟件實體假如應用的是一個基類的話，那末必定實用於其子類，並且它基本不克不及發覺出基類對象和子類對象的差別。只要衍生類調換基類的同時軟件實體的功效沒有產生變更，基類能力真正被復用。 <br/>
        3. 裡氏代換准繩由Barbar Liskov(芭芭拉.裡氏)提出，是繼續復用的基石。 <br/>
        4. 一個繼續能否相符裡氏代換准繩，可以斷定該繼續能否公道（能否隱蔽出缺陷）。

    盡力使你的類盡量的硬朗 [SOLID](http://en.wikipedia.org/wiki/SOLID_object-oriented_design\))。(

    老是為你本身的類供給 to_s 辦法, 用來表示這個類（實例）對象包括的對象.

 class Person
   attr_reader :first_name, :last_name

   def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
   end

   def to_s
    "#@first_name #@last_name"
   end
  end

    應用 attr 功效成員來界說各個實例變量的拜訪器或許修正器辦法。

 # bad
  class Person
   def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
   end

   def first_name
    @first_name
   end

   def last_name
    @last_name
   end
  end

  # good
  class Person
   attr_reader :first_name, :last_name

   def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
   end
  end

    防止應用 attr。應用 attr_reader 和 attr_accessor 作為替換。

  # bad - creates a single attribute accessor (deprecated in 1.9)
  attr :something, true
  attr :one, :two, :three # behaves as attr_reader

  # good
  attr_accessor :something
  attr_reader :one, :two, :three

    斟酌應用 Struct.new, 它可以界說一些瑣碎的 accessors,
    constructor（結構函數） 和 comparison（比擬） 操作。

  # good
  class Person
   attr_reader :first_name, :last_name

   def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
   end
  end

  # better
  class Person < Struct.new(:first_name, :last_name)
  end

    斟酌應用 Struct.new，它替你界說了那些瑣碎的存取器（accessors），結構器（constructor）和比擬操作符（comparison operators）。

  # good
  class Person
   attr_accessor :first_name, :last_name

   def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
   end
  end

  # better
  Person = Struct.new(:first_name, :last_name) do
  end

    不要去 extend 一個 Struct.new - 它曾經是一個新的 class。擴大它會發生一個過剩的 class 層級
    而且能夠會發生奇異的毛病假如文件被加載屢次。

    斟酌添加工場辦法來供給靈巧的辦法來創立特定類實例。

class Person
   def self.create(potions_hash)
    # body omitted
   end
  end

    鴨子類型（duck-typing）優於繼續。

 # bad
  class Animal
   # abstract method
   def speak
   end
  end

  # extend superclass
  class Duck < Animal
   def speak
    puts 'Quack! Quack'
   end
  end

  # extend superclass
  class Dog < Animal
   def speak
    puts 'Bau! Bau!'
   end
  end

  # good
  class Duck
   def speak
    puts 'Quack! Quack'
   end
  end

  class Dog
   def speak
    puts 'Bau! Bau!'
   end
  end

    Avoid the usage of class (@@) variables due to their "nasty" behavior
    in inheritance.

    防止應用類變量（@@）由於他們憎惡的繼續習氣（在子類中也能夠修正父類的類變量）。

 class Parent
   @@class_var = 'parent'

   def self.print_class_var
    puts @@class_var
   end
  end

  class Child < Parent
   @@class_var = 'child'
  end

  Parent.print_class_var # => will print "child"

    正如上例看到的, 一切的子類同享類變量, 而且可以直接修正類變量,此時應用類實例變量是更好的主張.

    依據辦法的用處為他們分派適合的可見度( private, protected )，不要讓一切的辦法都是 public (這是默許設定)。這是 Ruby 不是 Python。

    public, protected, 和 private 等可見性症結字應當和其（指定）的辦法具有雷同的縮進。而且分歧的可見性症結字之間留一個空格。

 class SomeClass
   def public_method
    # ...
   end

   private

   def private_method
    # ...
   end

   def another_private_method
    # ...
   end
  end

    應用 def self.method 來界說單例辦法. 現代碼重構時, 這將使得代碼加倍輕易由於類名是不反復的.

  class TestClass
   # bad
   def TestClass.some_method
    # body omitted
   end

   # good
   def self.some_other_method
    # body omitted
   end

   # Also possible and convenient when you
   # have to define many singleton methods.
   class << self
    def first_method
     # body omitted
    end

    def second_method_etc
     # body omitted
    end
   end
  end

  class SingletonTest
   def size
    25
   end
  end

  test1 = SingletonTest.new
  test2 = SingletonTest.new
  def test2.size
   10
  end
  test1.size # => 25
  test2.size # => 10

    本例中，test1 與 test2 屬於統一類別，但 test2 具有從新定義的 size 辦法，是以兩者的行為會紛歧樣。只給予單一物件的辦法稱為單例辦法 (singleton method)。