範式的定義

• 關係型數據庫中的關係是需要滿足一定條件的，滿足這些不同程度的規範化就叫做範式。

• 範式按照規範化程度從低到高排序為第一範式，第二範式，第三範式，BC範式，第四範式，第五範式。

前導知識

函數依賴

R(U)是屬性集U的關係模型，X，Y是U的一個子集，對於R(U)中的任一個關係r，不可能存在兩個元組在X上屬性值相同，而在Y上屬性值不同。則稱X函數確定Y，或Y函數依賴X。

• 說人話：U是表(可能不止一個表，可以是有關係的多個表)的所有列，X，Y分別是這些屬性列的一個子集，也就是若干個屬性，對於所有在X這些屬性上的值一樣的行，在Y上的屬性上也必須一樣，滿足這樣條件的這若干個屬性 X和Y叫稱其函數依賴。
• X相同則Y必須相同，但X不同Y可以相同，也可以不同。
• 如果Y是X的子集，就叫平凡的函數依賴，一般不考慮這種，因為就是廢話，X整個都相同，子集肯定相同。
• 如果Y不是X的子集，叫做非平凡的函數依賴。
• 如果Y函數依賴X，那麼X稱為決定因素。
• 如果Y函數依賴X，但不依賴X的任何一個真子集，也就是X是極小的，那就稱Y完全函數依賴X，否則稱Y部分函數依賴X。
• 如果X決定Y，Y決定Z，且Y不決定X，那麼稱Z對X傳遞函數依賴。

碼(鍵)

• U是屬性全集，K是U的子集，若U完全函數依賴K，則稱K為候選碼，候選碼若有多個，任意選擇一個都可作為主碼，若U部分函數依賴K，則稱K為超碼。顯然，候選碼當然也是超碼，而且是最小的超碼。
• 包含在任何一個候選碼的屬性都叫主屬性，其他都叫非主屬性。
• 在本書中主碼和候選碼統稱為碼，屬性集K不是該關係模式(表)的碼，而是另一個關係模式(表)的碼，則稱K為該關係模式(表)的外碼。

求候選碼

例子：

舉例

有這樣一個配件管理表WPE(WNO,PNO,ENO,QNT),其中WNO表示倉庫號，PNO表示配件號，ENO表示職工號，QNT表示數量。

有以下約束要求：

（1）一個倉庫有多名職工；

（2）一個職工僅在一個倉庫工作；

（3）每個倉庫里一種型號的配件由專人負責，但一個人可以管理幾種配件；

（4）同一種型號的配件可以分放在幾個倉庫中。

分析表中的函數依賴關係，可以得到：

（1）ENO->WNO;

（2）（WNO，PNO）->QNT

（3）（WNO，PNO）->ENO

（4）（ENO，PNO）->QNT

觀察法?：

候選碼的定義就是一組能決定所有列(某一個元組)的屬性。

所以根據這4個函數依賴關係，(WNO,PNO)顯然肯定是，因為它可以決定QNT，也可以決定ENO，加上它本身，就是屬性全集U了。

而(ENO,PNO)，雖然只有一個決定QNT，但是ENO可以單獨決定WNO，所以顯然(ENO,PNO)也就能一起決定QNT和WNO，因此也是候選碼。

六大範式?

第一範式

定義

滿足最基本的條件，每一個分量都是不可分的數據項。

• 說人話，每一列對應只有一個值。

第二範式

定義

R屬於第一範式，且每一個非主屬性完全函數依賴於任何一個候選碼，則R屬於第二範式

• 說人話，除了主碼候選碼之外的其他屬性都要完全函數依賴於主碼。
• 因為任意一個候選碼都能作為主碼，所以，也就是說，如果存在某個屬性不是完全函數依賴於某一個候選碼，可能是部分函數依賴，那就沒了。
• 比如主鍵是(學號，課程號)，但是現在有一個屬性完全函數依賴於學號，而部分函數依賴於(學號，課程號)，那就不滿足第二範式。

第三範式

定義

R屬於第二範式，若R中不存在碼X，屬性子集Y，非主屬性Z，使得X決定Y，Y不決定X，Y決定Z，則R屬於第三範式。

• 說人話，非主屬性必須直接完全函數依賴於主鍵，中間不能有其他函數，即不能是傳遞函數依賴。

BC範式

定義

R屬於第一範式，若X決定Y，且Y不是X的子集時X必含有碼，即每一個決定因素都包含碼，則R屬於BC範式。

• 說人話， 若R是第一範式，且每個屬性不部分函數依賴於候選碼也不傳遞函數依賴於候選碼，則R是BC範式，具體以下三點。
  • 所有非主屬性對每一個碼都是完全函數依賴。（也是第二範式要求）
  • 所有主屬性對每一個不包含它的碼也是完全函數依賴。（也就是排除了所有屬性對碼的部分依賴）
  • 沒有任何屬性完全函數依賴於非碼的任何一組屬性。（排除傳遞函數依賴）
• 實際上，BC範式就是在第三範式的基礎上消除了主屬性的傳遞依賴。

第四範式

多值依賴

• 說人話，多值依賴就是一個表中多對多的關係，如果可以分成兩列，這兩列多對多，這就平凡的多值依賴，如果是分成三列，固定某一列的值，其他兩列多對多，這就是非平凡的多值依賴，第四範式要消除的就是非平凡的多值依賴。

• 函數依賴是特殊的多值依賴，因為多對多其實也是一對多。

定義

R屬於第一範式，對應R的每一個非平凡多值依賴，X->->Y，X都含有碼，則R屬於第四範式。

• 說人話，在滿足第三範式的基礎上，關係表中不能含有一個實體的兩個或多個相互獨立的多值因子。
• 或者說，滿足第四範式即要求每個非平凡的多值依賴都含有碼，也就是實際上是函數依賴。

第五範式

定義

第五範式是指關係模式R依賴均由R候選碼所隱含。

這輩子應該不會用到的內容，就不管了。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※平板收購,iphone手機收購,二手筆電回收,二手iphone收購-全台皆可收購

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

一、簡單工廠模式

　　簡單工廠模式（Simple Factory Pattern）由一個工廠對象決定創建哪一種產品類的實例，簡單工廠模式適用於工廠類負責創建對象較少的情況，且客戶端只需要傳入工廠類的參數，對於如何創建對像不關心。

public  interface IBlog {
     // 寫隨筆
    public  void write();
}

public  class JavaBlog implements IBlog {
    @Override
    public  void write() {
        System.out.println( "寫java隨筆" );
    }
}

public  class WriteBlog {
     public  static  void main(String[] args) {
        IBlog blog = new JavaBlog();
        blog.write();
    }
}

　　上述代碼中，父類 IBlog 指向子類JavaBlog 的引用，應用層需要依賴JavaBlog，如果增加PythonBlog等等更多的課程，客戶端就會越來越臃腫。因此要把依賴減弱，把創建細節隱藏。現在我們用簡單工廠優化：

public class BlogFactory {
    public IBlog create(Class<? extends IBlog> clazz) {
        if (null != clazz) {
            try {
                return clazz.newInstance();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

客戶端改變：

  public static void main(String[] args) {
        BlogFactory blogFactory = new BlogFactory();
        IBlog blog = blogFactory.create(JavaBlog. class );
        blog.write();
    }

　　簡單工廠模式在JDK中很常見，如Calender類（感興趣去看源碼），還有logback,LoggerFactory中有很多重載的方法getLogger()。但是簡單工廠也有缺點：工廠類的職責相對過重，不易於擴展過於複雜的產品結構。

二、工廠方法模式

　　 工廠方法模式（Factory Method Pattern）是指定義一個創建對象的接口，但讓實現這個接口的類來決定實例化哪個類，工廠方法模式讓類的實例化推遲到子類中進行。在工廠方法模式中，用戶只需要關心所需產品對應工廠，無須關心創建的細節，而且加入新產品時符合開閉原則。

　　工廠方法模式主要解決產品擴展問題。在簡單工廠模式中，隨著產品的增多，如果不同語言書寫隨筆的邏輯各不相同，工廠職責越來越多，那工廠裏面就會亂搞一氣，狗屁不通。根據單一職責原則，我們將只能進行拆分，不同工廠做不同事，Java隨筆由Java工廠創建，Python隨筆由Python工廠創建，對工廠本身進行抽象。

先創建工廠類：

public  interface IBlogFactory {
    IBlog create();
}

再創建對應工廠：

public  class JavaBlogFactory implements IBlogFactory {
    @Override
    public IBlog create() {
        return new JavaBlog();
    }
}

public class PythonBlogFactory implements IBlogFactory {
    @Override
    public IBlog create() {
        return new PythonBlog();
    }
}

客戶端：

public class CreateBlog {
    public static void main(String[] args) {
        IBlogFactory factory = new PythonBlogFactory();
        IBlog blog = factory.create();
        blog.write();

        factory = new JavaBlogFactory();
        blog = factory.create();
        blog.write();
    }
}

總結來說就是：不同工廠抽像出一個工廠頭子，不同的工廠創建不同的實例。

工廠方法模式適用於以下場景：

1.創建對象需要大量重複代碼。

2.客戶端（應用層）不依賴於產品類實例如何被創建、如何被實現等細節。

3.一個類通過其子類來指定創建哪個對象。

缺點：

1.類的個數容易過多，增加複雜度。

2.增加了系統的抽象性和理解難度。

三、抽象工廠

　　抽象工廠（Abstract Factory Pattern）提供一個黃健一系列相關或相互依賴對象的接口，無需指定具體類。客戶端（應用層）不依賴於產品類實例如何被創建、如何被實現等細節，強調的是一系列相關得產品對象（屬於同一產品族）一起使用創建對象需要大量重複代碼。需要提供一個產品類的庫，所有產品以同樣接口出現，從而是客戶端不依賴於具體實現。

產品族：同一家的不同產品，比如小米，華為，蘋果；

產品等級：不同種類的產品，比如手機，電視，電腦。

工廠要做的就是生產我們牌子的所有產品。以博客為例，java分類的博客有隨筆、文章、日記等。

首先創建文章和日記的抽象接口：

public  interface IDocument {
     void write();
}

public  interface INote {
     void make();
}

再創建抽象工廠：

public  interface BlogFactory {
    INote createNote();

    IDocument createDocument();
}

實現Java文章和日記：

public  class JavaDocument implements IDocument {
    @Override
    public  void write() {
        System.out.println( "寫Java文章" );
    }
}

public  class JavaNote implements INote {
    @Override
    public  void make() {
        System.out.println( "寫Java筆記" );
    }
}

實現Java產品族具體工廠：

public  class JavaBlogFactory implements BlogFactory {
    @Override
    public INote createNote() {
         return  new JavaNote();
    }

    @Override
    public IDocument createDocument() {
         return  new JavaDocument();
    }
}

實現Python文章和日記、實現Python具體工廠參考Java的。

客戶端調用：

public  class BlogTest {
     public  static  void main(String[] args) {
        JavaBlogFactory factory = new JavaBlogFactory();
        factory.createDocument().write();
        factory.createNote().make();
    }
}

　　上述代碼描述了兩個產品族的工廠，如果想要擴展產品等級（就是再加點評啥的），要調整抽象工廠、具體工廠。由此可見抽象工廠模式的缺點：

1.規定所有可能被創建的產品集合，產品族（Java系列）中擴展新產品很困難，需要修改抽象工廠及實現；

2.增加系統抽象性和理解難度；

　　我們可以利用工廠模式創建好數據源連接池並放到容器中，業務需要時再取出。就避免了用一次創建一次的尷尬。

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?

前言

現在大多數程序設計語言中都有表達式和/或對象的類型概念。類型起着兩種主要作用：

• 為許多操作提供了隱含的上下文信息，使程序員可以在許多情況下不必显示的描述這種上下文。比如int類型的兩個對象相加就是整數相加、兩個字符串類型的對象相加就是拼接字符串、在Java和C#中new object()隱含在背後的就是要分配內存返回對象的引用等等。

• 類型描述了其對象上一些合法的可以執行的操作集合。類型系統將不允許程序員去做一個字符和一個記錄的加法。編譯器可以使用這個合法的集合進行錯誤檢查，好的類型系統能夠在實踐中捕獲很多錯誤

類型系統

從編譯方面的知識我們可以知道，計算機硬件可以按多種不同的方式去解釋寄存器里的一組二進制位。處理器的不同功能單元可能把一組二進制位解釋為指令、地址、字符、各種長度的整數或者浮點數等。當然，二進制位本身是無類型的，對存儲器的哪些位置應該如何解釋，大部分硬件也無任何保留信息。彙編語言由於僅僅是對一些二進制指令的“助記符號”翻譯，它也是這種無類型情況。高級語言中則總是關聯值與其類型，需要這種關聯的一些原因和用途就如前面說到的上下文信息和錯誤檢測。

一般來說，一個類型系統包含一種定義類型並將它們與特定的語言結構關聯的機制；以及一些關於類型等價、類型相容、類型推理的規則。 必須具有類型的結構就是那些可以有值的，或者可以引用具有值得對象的結構。類型等價規則確定兩個值得類型何時相同；類型相容規則確定特定類型的值是否可以用在特定的上下文環境里；類型推理規則基於一個表達式的各部分組成部分的類型以及其外圍上下文來確定這個表達式的類型。

在一些多態性變量或參數的語言中，區分表達式（如一個名字）的類型與它所引用的那個對象的類型非常重要，因為同一個名字在不同時刻有可能引用不同類型的對象。

在一些語言中，子程序也是有類型的，如果子程序是一級或者二級值，其值是動態確定的子程序，這時語言就需要通過類型信息，根據特定的子程序接口（即參數的個數和類型）提供給這種結構的可接受的值集合，那麼子程序就必須具有類型信息。在那些不能動態創建子程序引用的靜態作用域語言（這種語言中子程序是三級值），編譯器時就能確定一個名字所引用的子程序，因此不需要子程序具有類型就可以保證子程序的正確調用。

類型檢查

類型檢查時一個處理過程，其目的就是保證程序遵循了語言的類型相容規則，違背這種規則的情況稱為類型衝突。說一個語言是強類型的，那麼就表示這個語言的實現遵循一種禁止把任何操作應用到不支持這種操作的類型對象上的規則。說一個語言是靜態類型化（statically type）的，那麼它就是強類型的，且所有的類型檢查都能在編譯時進行（現實中很少有語言是真正的靜態類型，通常這一術語是指大部分類型檢查可以在編譯器執行，其餘一小部分在運行時檢查）。如C#我們通常都認為它是靜態類型化的語言。

動態（運行時）類型檢查是遲約束的一種形式，把大部分的檢查操作都推遲到運行的時候進行。採用動態作用域規則的語言大部分都是動態類型語言，因為它的名字和對象的引用都是在運行時確定的，而確定引用對象的類型則更是要在引用確定之後才能做出的。

類型檢查是把雙刃劍，嚴格的類型檢查會使編譯器更早的發現一些程序上的錯誤，但是也會損失一部分靈活性；動態類型檢查靈活性大大的，但是運行時的代價、錯誤的推遲檢查，各種語言的實現也都在這種利弊上進行權衡。

多態性

多態性使得同一段代碼體可以對多個類型的對象工作。它意味着可能需要運行時的動態檢查，但也未必一定需要。在Lisp、Smalltalk以及一些腳本語言中，完全的動態類型化允許程序員把任何操作應用於任何對象，只有到了運行時採取檢查一個對象是否實現了具體的操作。由於對象的類型可以看作它們的一個隱式的（未明確聲明的，一個不恰當的比喻就如C#中的this）參數，動態類型化也被說成是支持隱式的參數多態性。

雖然動態類型化具有強大的威力（靈活性），但卻會帶來很大的運行時開銷，還會推遲錯誤報告。一些語言如ML採用了一種複雜的類型推理系統，設法通過靜態類型化支持隱式的參數多態性。

在面向對象語言里，子類型多態性允許類型T的變量X引用了從T派生的任何類型的對象，由於派生類型必定支持基類型的所有操作，因此編譯器完全可以保證類型T的對象能接受的任何操作，X引用的對象也都能接受。對於簡單的繼承模型，子類型多態的類型檢查就能完全在編譯時實現。採用了這種實現的大多數語言（如C++,JAVA和C#）都提供另一種显示的參數化類型（泛型），允許程序員定義帶有類型參數的類。泛型對於容器（集合）類型特別有用，如T的列表（List ）和T的棧（Stack ）等，其中T只是一個類型佔位符，在初始化的這個容器對象時提供具體的類型來代替它。與子類型多態類似，泛型也可以在編譯時完成類型檢查。比如C++的模板完全就是編譯期間的東西，編譯后就完全沒有了模板的痕迹；JAVA則是利用一種“擦除”的技術實現的泛型，需要在運行時做一些檢查。

類型的含義

現在至少存在三種不同的考慮類型問題的方式，分別稱之為指稱的、構造的和基於抽象的

• 指稱的

按照指稱的觀點，一個類型就是一組值，一個值具有某個類型的條件是他屬於這個值集合，一個對象具有某個類型的條件是他的值保證屬於這個值集合

• 構造的

從構造的觀點看，一個類型或者是以一小組內部類型，或者是通過對一個或幾個更簡單些的類型，應用某個類型的構造符構造出來的

• 基於抽象的

從基於抽象的角度來看，一個類型就是一個接口，由一組定義良好而且具有相互協調的語義的操作組成。

類型的分類

在不同語言里，有關類型的術語也不相同，這裏說的通常都是常用的術語，大部分語言多提供的內部類型差不多就是大部分處理器所支持的類型：整數、字符、布爾和實數。

一般語言規範中都會規定數值類型的精度問題，以及一些字符的編碼規定。通常特殊的一個數值類型是枚舉類型，具體的語法在不同的語言中略有差異，但是其也都是一個目的（用一個字符友好的表示一個數值）。

關於枚舉類型，由一組命名元素組成。在C中可以這樣寫：

enum weekday { sun, mon, tue, wed, thu, fri, sat };

在C中這樣的寫法和直接對裏面的元素直接賦值除了語法上效果完全一樣。但是在之後的許多語言中，枚舉類型是一個真正的類型

還有一些語言中提供一種稱為子界的類型，它表示一種基於基本數值的一個連續的區間。比如Pascal中表示1到100：

type test_score = 0..100

複合類型：由一些簡單的基本類型組合成的一些類型稱為複合類型，比如常見的記錄、變體記錄、數組、集合、指針、表等，具體的都會在後面詳細介紹。

類型檢查

大多數的靜態類型語言中，定義一個對象都是需要描述清楚它的類型，進一步講，這些對象出現的上下文也都是有類型的，也就是說語言中的一些規則限制了這種上下文中可以合法出現的對象類型。

類型相容確定了一個特定類型的對象的能否用在一個特定上下文中。在最極端的情況下，對象可使用的條件就是它的類型與上下文所期望的類型等價。但是在大多數語言中，相容關係都比等價更寬鬆一些，即使對象與上下文的類型不同，它們也可以相容。

而類型推理想回答的是從一個簡單的表達式出發構造另一個表達式時，這整個的表達式的類型是什麼

類型等價

在用戶可以定義新類型的語言中，類型等價的定義一般基於兩種形式。

type R2 = record
    a : integer
    b : integer
end;

type R2 = record
    b : integer
    a : integer
end;

• 結構等價

基於類型定義的內容，就是它們由同樣的組成部分且按照同樣的方式組合而成

它的準確定義在不同的語言中也不一樣，因為它們要決定類型之間的哪些潛在差異是重要的，哪些是可以接受的（比如上面的兩個定義，是否還認為是等價的）。結構等價是一種很直接的認識類型的方式，早期的一些語言（Algol 68、Modula-3、ML）有些事基於結構等價的，現在的大部分語言（Java、C#）大都是基於名字等價了，為何呢？因為從某種意義上看，結構等價是由底層、由實現決定的，屬於比較低級的思考方式。就如一個上下文，如果你傳遞了一個結構等價但是不是所期待對象，實施結構等價的編譯器是不會拒絕這種情況的（假如這不是你希望的，那麼你也不會得到任何提示或者錯誤信息，很難排查的）。

• 名字等價

基於類型的詞法形式，可以認為是每一個名字都引進一個新的類型；

它基於一種假設，就是說程序員花時間定義了兩個類型，雖然它們的組成部分可能相同，但是程序員要表達的意思就是這是兩個不同的類型。名字等價的常規判斷就非常簡單了，看看聲明兩個對象的類型是否是一個就是了。但是也會有一些特殊的情況出現，比如類型別名（C、C++的程序員很熟悉這種東西吧），比如 typedef int Age; 就為int類型重新定義了一個別名”Age”。那些認為int不等價越Age的語言稱為嚴格名字等價，認為等價的稱為寬鬆名字等價。其實這兩種也是很容易區分的，只要能區分聲明和定義兩個概念的差異就可以區分。在嚴格名字等價中看待typedef int Age是認為定義了一個新類型Age，在寬鬆名字等價看來這就是一個類型聲明而已，int和Age共享同一個關於整數的定義。

類型變換和轉換

在靜態類型的語言中，如果“a=b”，那麼我們會期望b的類型和a的相同；現在假定所提供的類型和期望的類型和所提供的類型相同，那麼我們在要求某個類型的上下文中使用另外一個類型時就需要显示的寫出類型變換（或稱為類型轉換）。根據具體的變換的具體情況，在運行時執行這種變化會有以下三種主要的情況出現：

• 所涉及的類型可以認為是結構等價的，這種情況裏面因為涉及的類型採用了相同的底層的表示，則這種變換純粹就是概念上的操作，不需要運行時執行任何代碼。

• 所涉及的類型具有不同的值集合，但它們的值集合具有相同的表示形式。比如一個類型和它的子類型，一個整數和一個無符號的整數。拿無符號整數變換為整數來說，由於無符號整數的最大值是整數類型所容納不了的，則運行時就必須執行一些代碼來保證這種變換的合法性，如果合法則繼續下去，否則會產生一個動態語義錯誤。

• 所涉及的類型具有不同的底層表示，但是我們可以在它們的值之間定義某種對應關係。比如32位整數可以變換到IEEE的雙精度浮點數，且不會丟失精度。浮點數也可以通過舍入或割斷的形式變換成整數，但是會丟失小數部分。

非變換的類型轉換

有這麼一種情況，我們需要改變一個值，但是不需要改變它的二進製表示形式，更通俗點說就是我們希望按照另外一個類型的方式去解釋某個類型的二進制位，這種情況稱為非變換類型轉換。最簡單的一個例子比如說，一個byte類型的數值65，按byte類型來解釋它是65，如果按照char類型來解釋它就是字符“A”。比如C++中的static_cast執行類型變換，reinterpret_cast執行非變換的類型轉換。c中出現的union形式的結構，就可以認為是這種非變換的類型轉換的合法的安全的語言結構。在比如下面C中一般性非變換類型轉換代碼：

r=*((float *) &n);

任何非變換的類型轉換都極其危險的顛覆了語言的類型系統。在弱類型系統的語言中，這種顛覆可能很難發現，在強類型系統的語言中显示的使用這種非變換的類型轉換，起碼從代碼上可以看得出來它是這麼一回事，或多或少的有利於排查問題。

類型相容

大多數語言的上下文中並不要求類型等價，相應的一般都是實施較為“寬鬆”的類型相容規則。比如賦值語句要求右值相容與左值、參數類型相容，實際返回類型與指定的返回類型相容。在語言中，只要允許把一個類型的值用到期望的另外一個類型的上下文中，語言都必須執行一個到所期望類型的自動隱式變換，稱為類型強制(比如int b;double a=b;)。就像前面說的显示的類型變換一樣，隱式的類型變換也可能需要執行底層代碼或者做一些動態類型檢查。

重載

一個重載的名字可能引用不同類型的對象，這種歧義性需要通過上下文信息進行解析。比如a+b這個表達式可以表示整數或者浮點數的加法運算，在沒有強制的語言中，a和b必須都是整數或都是浮點數。如果是有強制的語言，那麼在a或者b有一個是浮點數的情況下，編譯器就必須使用浮點數的加法運算（另外一個整數強制轉換為浮點數）。如果語言中+只是進行浮點數運算，那麼即使a和b都是整數，也會被全部轉成浮點數進行運算（這代價就高了好多了）。

通用引用類型

通用引用類型：一些語言根據實習需求，設計有通用的引用類型，比如C中的void*、C#中的Object，任意的值都可以賦值給通用引用類型的對象。但是問題是存進去容易取出來難，當通用引用類型是右值的時候，左值的類型可能支持某些操作，然而這些操作右值對象是不具備的。為了保證通用類型到具體類型的賦值安全，一種解決辦法是讓對象可以自描述（也就是這個對象包含其真實類型的描述信息），C++,JAVA,C#都是這種方式，C#中如果賦值的類型不匹配則會拋出異常，而C++則是使用dynamic_cast做這種賦值操作，具體的後果呢，也是C++程序員負責。

類型推理

通過前面的類型檢查我們可以保證表達式的各各組成部分具有合適的類型，那麼這整個表達式的類型是什麼來着？其實在大多數的語言中也是比較簡單的，算術表達式的類型與運算對象相同、比較表達式總是布爾類型、函數調用的結果在函數頭聲明、賦值結果就是其左值的類型。在一些特殊的數據類型中，這個問題並不是那麼清晰明了，比如子界類型、複合類型。比如下面的子界類型問題（Pascal）：

type Atype=0..20;
type Btype=10..20;

var a: Atype;
var b: Btype;

那麼a+b什麼類型呢？？？它確實是不能是Atype或者Btype類型，因為它可能的結果是10-40。有人覺得那就新構造一個匿名的子界類型，邊界時10到40。實際情況是Pascal給的答案是它的基礎類型，也就是整數。

在Pascal中，字符串’abc’的類型是array[1..3] of char、而Ada則認為是一種未完全確定的類型，該類型與任何3個字符數組相容，比如在Ada中’abc’ & ‘defg’其結果是一個7字符的數組，那麼這個7字符數組的類型是array[1..7] of cahr呢還是某一個也是7個字符組成的類型array (weekday) of character呢，更或者是其他任意一個也是包含七個字符數組的另外一個類型。這種情況就必須依賴表達式所處的上下文信息才能推到出來具體的類型來。

記錄(結構)與變體(聯合)

一些語言中稱記錄為結構（struct），比如C語言。C++把結構定義為class的一種特殊形式（成員默認全局可見），Java中沒有struct的概念，而C#則對struct採用值模型，對class採用引用模型。

語法與運算

一個簡單的結構體在C中可以這樣定義：

struct element{
    char name[2];
    int number;
    double weight;
    Bool merallic;    
}; 

等價於Pascal中的：

 type two_chars=packed array [1..2] of char;
 type element - record
     name:two_chars;
     number:integer;
     weight:real;
     metallic:Boolean
 end

記錄裏面的成員（如name,number…）稱為域（field）。在需要引用記錄中的域時，大部分語言使用“.”記法形式。比如Pascal中：

 var copper:eement;
 copper.name=6.34;

大部分語言中還允許記錄的嵌套定義，比如在Pascal中：

 type short_string=packed array[1..30] of char；
 type ore=record
      name:short_string;
      element_yielded:record /*嵌套的記錄定義*/
          name:two_chars;
          number:integer;
          weight:real;
          metallic:Boolean
      end
 end

存儲布局及其影響

一個記錄的各個域通常被放入內存中的相鄰位置。編譯器在符號表中保存每個域的偏移量，裝載和保存的時候通過基址寄存器和偏移量即可得到域的內存地址。類型element在32位的機器中可能的布局如下：

此處有圖

（圖在最後面，因為markdown的這個畫表格不符合這個要求，又不想引圖了，就直接用html寫了，會被擠到最後去）

（table標籤和我博客園的樣式生成的時候會出bug，刪除了）

在對結構體的存儲布局方案上，如果使用正常排序，結構中的空洞會浪費空間。但是如果通過壓縮來節省空間，但是可能很帶來很嚴重的訪問時間的代價

數組

數組是最常見也是最重要的複合數據類型。記錄用於組合一些不同類型的域在一起；而數組則不同，它們總是同質的。從語義上看，可以把數組想象成從一個下標類型到成員（元素）類型的映射。

有些語言要求下標類型必須是integer，也有許多語言允許任何離散類型作為下標；有些語言要求數組的元素類型只能是標量，而大多數語言則允許任意類型的元素類型。也有一些語言允許非離散類型的下標，這樣產生的關聯數組只能通過散列表的方式實現，而無法使用高效的連續位置方式存儲，比如C++中的map，C#中的Dictionary。在本節中的討論中我們假定數組的下標是離散的。

語法和操作

大多數的語言都通過數組名后附加下標的方式（圓括號|方括號）來引用數組裡的元素。由於圓括號()一般用於界定子程序調用的實際參數，方括號在區分這兩種情況則有易讀的優勢。Fortran的數組用圓括號，是因為當時IBM的打卡片機器上沒有方括號

維數、上下界和分配

對於數組的形狀在聲明中就已經描述，對於這種有靜態形狀的數組，可以用通常的方式來管理內存：生存期是整個程序的數組使用棧分配，具有更一般的生存期的動態生成數組使用堆分配。但是對於在加工之前不知道其形狀的數組，或其形狀在執行期間可能改變的數組，存儲管理就會更複雜一點。

• 內情向量

在編譯期間，符號表維護者程序中的每個數組的維度和邊界信息。對於每個記錄，它還維護着每個域的偏移量。如果數組維度的數目和邊界是靜態已知的，編譯器就可以在符號表中找出它們，以便計算數組元素的地址。如果這些值不是靜態已知的，則編譯器就必須生成代碼，在運行時從一個叫內情向量的數據結構來查找它

• 棧分配

子程序參數是動態形狀數組最簡單的例子，其中數組的上下界在運行時才確定，調用方都會傳遞數組的數據和一個適當的內情向量，但是如果一個數組的形狀只能到加工時才知道，這種情況下仍可以在子程序的棧幀里為數組分配空間，但是需要多做一層操作

• 堆分配

在任意時間都可以改變形狀的數組，有時被稱為是完全動態的。因為大小的變化不會以先進先出的順序進行，所以棧分配就不夠用了。完全動態的數組必須在堆中分配。比如Java中的ArrayList

#### 內存布局

大多數語言的實現里，一個數組都存放在內存的一批連續地址中，比如第二個元素緊挨着第一個，第三個緊挨着第二個元素。對於多維數組而言，則是一個矩陣，會出現行優先和列優先的選擇題，這種選擇題對於語言使用者而言是透明的，而對語言的實現者則需要考慮底層方面的優化問題了。

在一些語言中，還有另外一種方式，對於數組不再用連續地址分配，也不要求各行連續存放，而是允許放置在內存的任何地方，再創建一個指向各元素的輔助指針數組，如果數組的維數多於兩維，就再分配一個指向指針數組的指針數組。這種方式稱為行指針布局，這種方式需要更多的內存空間，但是卻有兩個優點：

• 首先，可能加快訪問數組裡單獨元素的速度；
• 其次，允許創建不用長度的行，而且不需要再各行的最後留下對齊所用的空洞空間，這樣節省下來的空間有時候可能會超過指針佔據的空間。C，C++和C#都支持連續方式或行指針方式組織多維數組，從技術上講，連續布局才是真正的多維數組，而行指針方式則只是指向數組的指針數組。

字符串

許多語言中，字符串也就是字符的數組。而在另一些語言中，字符串的情況特殊，允許對它們做一些其他數組不能用的操作，比如Icon以及一些腳本語言中就有強大的字符串操作功能。

字符串是編程中非常重要的一個數據類型，故而很多語言都對字符串有特殊的處理以便優化其性能以及存儲（比如C#中的字符串不可變性保證了性能，字符串駐留技術照顧了存儲方面的需要），由於這些特殊的處理，故而各各語言中為字符串提供的操作集合嚴重依賴語言設計者對於實現的考慮。

集合

程序設計語言中的一個集合，也就是具有某個公共類型的任意數目的一組值的一種無序彙集。集合的元素所具有的類型叫做元類型或者基類型。現在的大多數程序設計語言都對集合提供了很大的支持，為集合提供了很多相關的操作

指針和遞歸類型

所謂的遞歸類型，就是可以在其對象中包含一個或多個本類型對象的引用類型。遞歸類型用於構造各種各樣的“鏈接”數據結構，比如樹。在一些對變量採用引用模型的語言中，很容易在創建這種遞歸類型，因為每個變量都是引用；在一些對變量採用值模型的語言中，定義遞歸類型就需要使用指針的概念，指針就是一種變量，其值是對其他對象的引用。

對於任何允許在堆里分配新對象的語言，都存在一個問題：若這種對象不在需要了，何時以及以何種方式收回對象佔用的空間？對於那些活動時間很短的程序，讓不用的存儲留在那裡，可能還可以接受，畢竟在它不活動時系統會負責回收它所使用的任何空間。但是大部分情況下，不用的對象都必須回收，以便騰出空間，如果一個程序不能把不再使用的對象存儲回收，我們就認為它存在“內存泄漏”。如果這種程序運行很長一段時間，那麼它可能就會用完所有的空間而崩潰。許多早期的語言要求程序員显示的回收空間，如C，C++等，另一些語言則要求語言實現自動回收不再使用的對象，如Java，C#以及所有的函數式語言和腳本語言。显示的存儲回收可以簡化語言的實現，但會增加程序員忘記回收不再使用的對象（造成內存泄漏），或者不當的回收了不該回收的正在使用的對象（造成懸空引用）的可能性。自動回收可以大大簡化程序員的工作，但是為語言的實現帶來了複雜度。

語法和操作

對指針的操作包括堆中對象的分配和釋放，對指針間接操作以訪問被它們所指的對象，以及用一個指針給另一個指針賦值。這些操作的行為高度依賴於語言是函數式還是命令式，以及變量/名字使用的是引用模型還是值模型。

函數式語言一般對名字採用某種引用模型（純的函數式語言里根本沒有變量和賦值）。函數式語言里的對象傾向於採取根據需要自動分配的方式。

命令式語言里的變量可能採用值模型或引用模型，有時是兩者的某種組合。比如 A=B；

• 值模型： 把B的值放入A。
• 引用模型： 使A去引用B所引用的那個對象。

Java的實現方式區分了內部類型和用戶定義的類型，對內部類型採用值模型，對用戶定義的類型採用則採用引用模型，C#的默認方式與Java類似，另外還提供一些附加的語言特性，比如“unsafe”可以讓程序員在程序中使用指針。

懸空引用

在前兩篇的名字、作用域和約束中我們列舉了對象的3種存儲類別：靜態、棧和堆。靜態對象在程序的執行期間始終是活動的，棧對象在它們的聲明所在的子程序執行期間是活動的，而堆對象則沒有明確定義活動時間。

在對象不在活動時，長時間運行的程序就需要回收該對象的空間，棧對象的回收將作為子程序調用序列的一部分被自動執行。而在堆中的對象，由程序員或者語言的自動回收機制負責創建或者釋放，那麼如果一個活動的指針並沒有引用合法的活動對象，這種情況就是懸空引用。比如程序員显示的釋放了仍有指針引用着的對象，就會造成懸空指針，再進一步假設，這個懸空指針原來指向的位置被其他的數據存放進去了，但是實際卻不是這個懸空指針該指向的數據，如果對此存儲位置的數據進行操作，就會破壞正常的程序數據。

那麼如何從語言層面應對這種問題呢？Algol 68的做法是禁止任何指針指向生存周期短於這個指針本身的對象，不幸的是這條規則很難貫徹執行。因為由於指針和被指對象都可能作為子程序的參數傳遞，只有在所有引用參數都帶有隱含的生存周期信息的情況下，才有可能動態的去執行這種規則的檢查。

廢料收集

對程序員而已，显示釋放堆對象是很沉重的負擔，也是程序出錯的主要根源之一，為了追蹤對象的生存軌跡所需的代碼，會導致程序更難設計、實現，也更難維護。一種很有吸引力的方案就是讓語言在實現層面去處理這個問題。隨着時間的推移，自動廢料收集回收都快成了大多數新生語言的標配了，雖然它的有很高的代價，但也消除了去檢查懸空引用的必要性了。關於這方面的爭執集中在兩方：以方便和安全為主的一方，以性能為主的另一方。這也說明了一件事，編程中的很多地方的設計，架構等等方面都是在現實中做出權衡。

廢料收集一般有這兩種思想，就不詳細說了。

• 引用計算
• 追溯式收集

表

表具有遞歸定義的結構，它或者是空表，或者是一個有序對，有序對由一個對象和另一個表組成。表對於函數式或者邏輯式語言程序設計非常適用，因為那裡的大多數工作都是通過遞歸函數或高階函數來完成的。

在Lisp中：

(cons 'a '(b))  => (a b)
(car '(a b))    => a
(cdr '(a b c))  => (b c)

在Haskell和Python還由一個非常有用的功能，叫做列表推導。在Python中可以這樣推導出一個列表

[i * i for i in range(1, 100) if i % 2 == 1]

文件和輸入/輸出

輸入/輸出（I/O）功能使程序可以與外部世界通信。在討論這種通信時，將交互式I/O和文件I/O分開可能有些幫助。交互式IO通常意味着與人或物理設備通信，人或設備都與運行着的程序并行工作，送給程序的輸入可能依賴程序在此之前的輸出。文件通常對應於程序的地址空間之外的存儲器，由操作系統實現。

有些語言提供了內置的File數據類型，另外一些語言將IO工作完全委託給庫程序包，這些程序包導出一個file類型。所以IO也算作是一種數據類型

相等檢測和賦值

對於簡單的基本數據類型，如整數、浮點數和字符，相等檢測和賦值相對來說都是直截了當的操作。其語義和實現也很明確，可以直接按照二進制位方式比較或複製，但是，對於更加複雜或抽象的數據類型，就可能還需要其它的比較方式

• 相互是別名？
• 二進制位是否都相等？
• 包含同樣的字符序列？
• 如果打印出來，看起來完全一樣？

就許多情況下，當存在引用的情況下，只有兩個表達式引用相同的對象時它們才相等，這種稱為淺比較。而對於引用的對象本身存在相等的含義時，這種比較稱為深比較。對於複雜的數據結構，進行深比較可能要進行遞歸的遍歷。所以相對來說，賦值也有深淺之分。深賦值時是進行完整的拷貝。

大多數的語言都使用淺比較和淺賦值

小結

本文從語言為何需要類型系統出發，解釋了類型系統為語言提供了那些有價值的用途：1是為許多操作提供隱含的上下文，使程序員在許多情況下不必显示的描述這種上下文；2是使得編譯器可以捕捉更廣泛的各種各樣的程序錯誤。 然後介紹了類型系統的三個重要規則：類型等價、類型相容、類型推理。以此3個規則推導出的強類型（絕不允許把任何操作應用到不支持該操作的對象上）、弱類型以及靜態類型化（在編譯階段貫徹實施強類型的性質）、動態類型化的性質以及在對語言的使用方面的影響。以及後續介紹了語言中常見的一些數據類型的用途以及語言在實現這種類型方面所遇到的問題以及其大致的實現方式。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?

我認為學習計算機語言，應該先用後學，這一節，我們來實現一個猜数字的小遊戲。

先簡單介紹一個這個遊戲的內容：遊戲先生成一個1到100之間的任意一個数字，然後我們輸入自己猜測的数字，遊戲會告訴我們輸入的数字太大還是太小，然後我們重新輸入新的数字，直到猜到遊戲生成的数字，然後遊戲結束。

創建項目

製作遊戲的第一步先創建項目，創建方法和上一節一樣，使用 cargo 來創建一個名為 guessing_game 的項目。

cargo new guessing_game && cd guessing_game

項目創建完成，可以運行一下，如果程序打印出 Hello, World! 則證明程序創建完成，運行命令如下：

cargo run 

讀取猜測的数字

正式寫遊戲的第一步，讓遊戲先讀取我們猜測的数字。我們可以先把打印語句換成提示我們輸入数字的提示語句。

use std::io;

fn main() {
    println!("猜測数字遊戲，請輸入您猜測的数字。");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("讀取数字失敗！");

    println!("您猜測的数字是：{}", guess);
}

這段代碼包含了大量的信息，我們一行一行地過一遍。
1.因為我們需要讀取用戶的輸入，然後把它作為結果打印出來，所以需要把 標準庫(被稱作 std )中的 io 依賴引入當前作用域。
2.在主函數中寫方法體，首先是打印提示語，不說了。
3.然後創建一個用於保存即將輸入的字符串的 String 類型的變量 guess。
4.把控制台輸入的数字讀取到變量 guess 中，如果讀取失敗，則打印 “讀取数字失敗！” 的字符串。
5.把讀取的数字再打印到控制台。

注：這段程序的細節暫時先不深究了，後續文章會一一解釋清楚。

測試一下這段程序：

cargo run                                    
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 1.01s
     Running `target/debug/guessing_game`
猜測数字遊戲，請輸入您猜測的数字。
2
您猜測的数字是：2

生成隨機數

我們的遊戲需要創建一個隨機數，供我們去猜測，這個数字要求每次啟動遊戲時都是不相同的，這樣遊戲才更加有意思。接下來我們在遊戲中生成一個1到100的隨機數。但是 rust 沒有在它的標準庫中提供生成隨機數的方法，不過沒關係，它提供了生成隨機數的名為 rand 的 crate。我們來引入一下生成隨機數的 crate，修改 Cargo.toml 文件：

[dependencies]

rand = "^0.3.14"

只需要在 [dependencies] 下面添加需要的 crate 即可。這次添加的 crate 名字是 rand，版本號 0.3.14， 而 ^ 的意思是兼容 0.3.14 版本的任何版本都可以。然後我們編譯一下程序，就會自動下載引入的依賴：

cargo build                                      
    Updating crates.io index
   Compiling libc v0.2.65
   Compiling rand v0.4.6
   Compiling rand v0.3.23
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 1m 13s

引入了生成隨機數和 crate 后，我們來生成一下需要的 crate，代碼如下：

use std::io;
use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("生成的隨機数字是：{}", secret_number);

    println!("猜測数字遊戲，請輸入您猜測的数字。");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("讀取数字失敗！");

    println!("您猜測的数字是：{}", guess);
}

可以看到我們在前面代碼的基礎上添加了三行代碼：
1.第一行是引入生成隨機數的依賴。
2.第二行是生成一個隨機數，隨機數的範圍是 [1, 101)，區間是左閉右開，說人話就是1到100。
3.第三行是打印生成的隨機數。
然後我們測試一下添加的隨機數是否生效：

cargo run                                    
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.45s
     Running `target/debug/guessing_game`
生成的隨機数字是：79
猜測数字遊戲，請輸入您猜測的数字。
6
您猜測的数字是：6

比較隨機數和猜測數

現在我們可以輸入自己猜測的数字，也可以生成隨機数字了，那麼接下來就是比較二者的大小了。但是在比較之前還有個問題，控制台輸入的数字是 string 類型的，而隨機生成的数字是無符號32位整型(u32)，二者不類型不一致，不能作比較，因此，在比較之前，我們應該先把控制台輸入的 string 類型的数字轉成u32類型的，代碼如下：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("生成的隨機数字是：{}", secret_number);

    println!("猜測数字遊戲，請輸入您猜測的数字。");

    let mut guess = String::new();

    io::stdin().read_line(&mut guess).expect("讀取数字失敗！");

    let guess: u32 = guess.trim().parse().expect("請輸入一個数字！");

    println!("您猜測的数字是：{}", guess);

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("您猜測的数字太小了！"),
        Ordering::Greater => println!("您猜測的数字太大了！"),
        Ordering::Equal => println!("恭喜您，猜對了！"),
    }
}

可見，我們在三個位置添加了代碼：
1.從標準庫中添加了比較的依賴。
2.把輸入的数字類型成u32類型，如果輸入的不是数字，則轉換失敗，打印出錯誤信息。
3.最後一部分就是比較一下二者的大小，並打印出比較的結果。
好了，我們先測試一下吧，這裏我們只測正確的輸入：

cargo run                                     101 ↵
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/guessing_game`
生成的隨機数字是：53
猜測数字遊戲，請輸入您猜測的数字。
4
您猜測的数字是：4
您猜測的数字太小了！

添加循環

我們發現，我們只輸入了一次，遊戲就結束了，這顯然不符合我們的預期。我們的預期是，我們可以一直猜一直猜，直到猜中才讓遊戲結束，那應該怎麼修改一下呢？添加一個循環，代碼如下：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("生成的隨機数字是：{}", secret_number);

    loop {

        println!("猜測数字遊戲，請輸入您猜測的数字。");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("讀取数字失敗！");

        let guess: u32 = guess.trim().parse().expect("請輸入一個数字！");

        println!("您猜測的数字是：{}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("您猜測的数字太小了！"),
            Ordering::Greater => println!("您猜測的数字太大了！"),
            Ordering::Equal => println!("恭喜您，猜對了！"),
        }
    }
}

這裏修改得比較簡單，只需要添加一個名叫 loop 的關鍵字，然後把需要循環的內容放在 {} 中即可，然後我們測試一下：

cargo run                                    
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.38s
     Running `target/debug/guessing_game`
生成的隨機数字是：71
猜測数字遊戲，請輸入您猜測的数字。
50
您猜測的数字是：50
您猜測的数字太小了！
猜測数字遊戲，請輸入您猜測的数字。
71
您猜測的数字是：71
恭喜您，猜對了！
猜測数字遊戲，請輸入您猜測的数字。
45
您猜測的数字是：45
您猜測的数字太小了！
猜測数字遊戲，請輸入
t
thread 'main' panicked at '請輸入一個数字！: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:1165:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.

我們的遊戲可以多次輸入了，但是有沒有發現一些問題呢？
1.遊戲直接告訴我們生成的数字了，那就不用猜了，直接輸入就好了。
2.當我們猜對后，遊戲沒有結束。
3.當我們輸入的內容不是数字的時候，才會結束遊戲，而且不僅打印了我們預期的錯誤信息，還打印了其它信息。
接下來，我們把這些問題依次修改，代碼如下：

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1, 101);

    // println!("生成的隨機数字是：{}", secret_number);

    loop {

        println!("猜測数字遊戲，請輸入您猜測的数字。");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("讀取数字失敗！");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("您猜測的数字是：{}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("您猜測的数字太小了！"),
            Ordering::Greater => println!("您猜測的数字太大了！"),
            Ordering::Equal => {
                println!("恭喜您，猜對了！");
                break;
            }
        }
    }
}

這三處錯誤的修改方式依次是：
1.把打印隨機數的代碼註釋掉。
2.在做類型轉換時，使用 match 關鍵字作判斷，如果轉化成功，則返迴轉化后的結果，如果轉化失敗，不管因為什麼原因失敗，都直接跳出本次循環。
3.在做二個数字大小判斷時，如果判斷相等，則結束循環。
我們來測試一下修改的結果：

cargo run                                    
   Compiling guessing_game v0.1.0 (/Users/shanpengfei/work/rust-work-space/study/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.38s
     Running `target/debug/guessing_game`
猜測数字遊戲，請輸入您猜測的数字。
50
您猜測的数字是：50
您猜測的数字太小了！
猜測数字遊戲，請輸入您猜測的数字。
r
猜測数字遊戲，請輸入您猜測的数字。
75
您猜測的数字是：75
您猜測的数字太小了！
猜測数字遊戲，請輸入您猜測的数字。
87
您猜測的数字是：87
您猜測的数字太大了！
猜測数字遊戲，請輸入您猜測的数字。
81
您猜測的数字是：81
恭喜您，猜對了！

可以看到我們的遊戲製作完成了~~

歡迎閱讀單鵬飛的學習筆記

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※收購3c,收購IPHONE,收購蘋果電腦-詳細收購流程一覽表

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，網站設計公司幫您達到更多曝光效益

※公開收購3c價格,不怕被賤賣!

※自行創業 缺乏曝光? 下一步"網站設計"幫您第一時間規劃公司的門面形象

匿名函數lambda

除了def語句，python還提供了一種生成函數對象的表達式形式。由於它與LISP語言中的一個工具類似，所以稱為lambda。

就像def一樣，這個表達式創建了一個之後能夠調用的函數，但是它返回一個函數而不是將這個函數賦值給一個變量。這些就是lambda叫做匿名函數的原因。實際上，他常常以一種行內進行函數定義的方式使用，或者用作推遲執行一些代碼。

lambda的一般形式是關鍵字lambda之後跟着一個或多個參數（與一個def頭部內用括號括起來的參數列表類似），緊跟着是一個冒號，之後是表達式

lambda arg1，arg2,argn:expression using arguments

由lambda表達式所返回的函數對象與由def創建並複製后的函數對象工作起來是完全一致的，但lambda有一些不同之處，讓其扮演特定的角色時更有用：

lambda是一個表達式，而不是一個語句

因為這一點，lambda可以出現在python語法不允許def出現的地方。
此外，作為一個表達式，lambda返回一個值（一個新的函數），可以選擇性的賦值給一個變量
相反，def語句總是得在頭部將一個新的函數賦值給一個變量，而不是將這個函數作為結果返回。

lambda的主題是單個表達式，而不是一個代碼塊

這個lambda的主題簡單的就好像放在def主體return語句中的代碼一樣。
簡單的將結果寫成一個順暢的表達式，而不是明確的返回。
但由於它僅限於表達式，故lambda通常要比def功能少…你僅能夠在lambda主體中封裝有限的邏輯進去，因為他是一個為編寫簡單函數而設計的。
除了上述這些差別，def和lambda都能過做同樣種類的工作

def與lambda的相同用法

x = lambda x, y, z: x + y + z
x(2, 3, 4)
>>> 9

y = (lambda a='hello', b='world': a + b)
y(b='Python')
>>> 'hellopython'

為什麼使用lambda

看過上面的兩個小例子，很多人會說這個和def沒什麼差別，我們又為什麼要使用lambda呢？

通常來說，lambda起到一種函數的速寫作用，允許在使用的代碼內嵌一個函數的定義，他完全是可選的(是可以使用def代替他們)，但是在你僅需要切入一段可執行代碼的情況下，它會帶來一個更簡潔的書寫效果。

lambda通常用來編寫跳轉表，也就是行為的列表或者字典，能夠按照需求執行操作，比如：

l = [lambda x: x ** 2, lambda x: x ** 3, lambda x: x ** 4]
for f in l:
    print(f(2))
>>> 4
>>> 8
>>> 16
print(l[0](3))
>>> 9

當需要把小段的可執行代碼編寫進def語句從語法上不能實現的地方是，lambda表達式作為def的一種速寫來說，是最為有用的，如果上面的代碼用def編寫，則變為：

def f1(x):
    return x ** 2
 
def f2(x):
    return x ** 3
 
def f3(x):
    return x ** 4
 
l = [f1, f2, f3]

for f in l:
    print(f(2))
print(l[0](3))

實際上，我們可以用python中的字典或者其他的數據結構來構建更多種類的行為表，從而做同樣的事情。

lambda中實現if-else

Python中具備的單行表達式：if a:b else c語法在lambda中同樣適用：

lower = lambda x,y:x if x<y else y
lower(4,5)
>>> 4

看了半天，大家可能也並未覺得lambda在python中到底比def優越與便利在哪裡，那麼說到lambda，就必須要提及三個函數map、filter、reduce，當你接觸了這三個函數，那麼你才能感受到lambda真實的方便之處

map 函數

程序對列表或者其他序列常常要做的一件事就是對每個元素進行一個操作，並把其結果集合起來。
python提供了一個工具map，它會對一個序列對象中的每一個元素應用該的函數，並返回一個包含了所有函數調用結果的列表。

舉個栗子，我們有一個列表，需要將列表的每一個字段+10，我們該如何操作？

list_show = [1, 2, 3, 4]
# 方式1
new_list_show = []
for i in list_show:
    new_list_show.append(i + 10)

print(new_list_show)

# 方式2
def adds(x):
    return x + 10

print(list(map(adds, list_show)))

# 更優雅的方式3：
print(list(map(lambda x: x + 10, list_show)))

看看上面三個實現方式，你覺得那種更加Pythonic？

eg:需要注意一點，map在python3中是一個可迭代對象，引入需要使用列表調用來使它生成所有的結果用於显示，python2不必如此。

當然map的闡述函數，不僅僅支持自己編寫的，同樣也支持python自帶的多種函數，比如：

list_show = [1, -2, 3, -4, 5, -6]
print(list(map(abs, list_show)))
>>> [1, 2, 3, 4, 5, 6]

filter函數

filter通過字面意思，大家就知道它的用處了，用於數據的過濾操作，它也是lambda的一個好基友，舉個栗子。
我們需要過濾0-9中，能被2整除的数字組成一個列表，我們該如何操作？只需要一行代碼：

print(list(filter(lambda x: x % 2 == 0, range(10))))
>>> [0, 2, 4, 6, 8]

沒錯，filter就是這麼的簡單實用….

reduce的妙用

reduce在python2中是一個簡單的函數，但在python3中它責備收錄與functools中。
它接收一個迭代器來處理並返回一個單個的結果。

list_show = [1, 2, 3, 4]
print(reduce(lambda x, y: x + y, list_show))
>>> 10
print(reduce(lambda x, y: x * y, list_show))
>>> 24

lambda的實用與它的好基友就介紹到這裏，希望對大家有所幫助。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※3c收購,鏡頭 收購有可能以全新價回收嗎?

※台北網頁設計公司這麼多，該如何挑選?? 網頁設計報價省錢懶人包"嚨底家"

※網頁設計公司推薦更多不同的設計風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※賣IPHONE,iPhone回收,舊換新!教你怎麼賣才划算?