『壹』 簡單的閉包問題
概念
閉包，在《javascripts高級程序設計》裡面是這樣介紹的:閉包是指有權訪問另一個作用域中的變數的函數。額。。這句話我以前看過很多遍，但依然不是很懂，只知道它是跟作用域有關。現在我知道了，如果這句話換成：但凡是內部的函數被保存到了外部，必定生成閉包。這樣就容易理解多了不是。
我們以下面的這個代碼塊為例：
例子解釋
function a() {const num = 100;function b () {num++;console.log(num);}return b;}const demo = a();demo();demo();
我們先執行上述代碼，看看結果是什麼：
a執行完，返回了b,此時的b只是聲明，但還沒調用，所以沒有形成自己的AO,但作用域鏈和 a doing 時是一樣的，所以雖然 a() 的作用域被銷毀了，但是相同的一份卻被b保存到了外面。這也就是內部函數被保存到了外面形成閉包的本質。這樣也不難理解為什麼上述代碼列印出來的值是那樣的了：
執行第一個demo()時，也即是執行 b(),由於b保存了a的作用域鏈，所以也可以訪問到 num ,執行 b() 後，加一；
那為什麼第二次執行 demo(),列印出的值還是有自增了呢？這是因為操作的都是保存在 b 里的 num ,雖然每次調用 demo() 都會形成新的作用域鏈，但是num，卻是每次從上一次的作用域鏈直接 到當前作用域鏈中的。
- function createFunctions() {var result = [];for(let i = 0; i< 10; i++) {result[i] = function() {console.log(i);}}return result;}var myArr = createFunctions();for(var j = 0; j < 10; j++) {myArr[j]();}
- function createFunctions() {var result = [];for(var i = 0; i < 10; i++) {(function(j) {result[i] = function() {document.write(j + " ");}}(i));}return result;}var myArr = createFunctions();for(var j = 0; j < 10; j++) {myArr[j]();}
實現共有變數
如累加器:調用多少次，累加多少次，用閉包更加模塊化
- function add() {var count = 0;function demo() {count++;console.log(count);}return demo;}var counter = add();counter();//1counter();//2counter();//3
實現緩存
- function eater() {var food = '';var obj = {eat: function() {console.log('eating' + food);food = '';},push: function(myFood) {food = myFood;}}return obj;// 相當於返回裡面的eat和push操作food;}var eater1 = eater();eater1.push('banana');eater1.eat();
這樣形成的閉包雖然可以使外部可以訪問到內部的函數，但是導致了原有的作用域鏈不釋放，會造成內存泄漏。（內存泄漏的意思就是佔用內存，可用內存資源變少了）。所以如果不是特殊需要，應盡量防止這種情況發生。
並且，作用域鏈的配置機制引出了一個值得注意的副作用：即閉包只取得包含函數中任何變數最後一個值，比如下面這個例子：
這個函數會返回一個函數數組，表面上看，似乎每個函數都應該有自己的索引值，即會返回：0，1，2...9;但實際上，每個函數都會返回10;這是因為在createFunctions()執行時，for循環跳出的條件是i=10；所以函數返回後，i的值是10 ；而每個result的作用域鏈中都保存這createFunctions()的AO,所以他們引用的都是createFunctions()的i值，所以每個函數內部i的值都是10；
這樣，我們可以創建一個立即執行函數強制讓閉包的行為符合預期：
典型應用
下面看看幾個用到閉包的典型例子：
如eater: eat和push保存的都是eater的AO;,所以eat中food改變後。實際上是eater變了，所以也會影響push;
『貳』 閉包的定義是什麼
閉包的定義是：
閉包就是能夠讀取其他函數內部變數的函數。例如在javascript中，只有函數內部的子函數才能讀取局部變數，所以閉包可以理解成「定義在一個函數內部的函數「。在本質上，閉包是將函數內部和函數外部連接起來的橋梁。
閉包的本質：
集合 是閉集當且僅當 Cl(S)=S。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集。有限多個集合的並集的閉包和這些集合的閉包的並集相等。
零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
『叄』 資料庫中的閉包
第一步：（1）X(0)=空集，X(1)=D（2）由於X(0)=空集，置X(0)=D
（3）檢查函數的依賴，置X(1)=D∪HG=DHG
第二步：置X(0)=DHG,檢查函數的依賴,置X(1)=DHG
第三步：X(0)=X(1),屬性集D關於F的閉包為DHG
『肆』 sql 請問SQL高手，系統中的這幾個資料庫都是做什麼用的
數據：計算機中用來描述事物的記錄
數據模型：是一種對客觀事物抽象化的表現形式。數據模型應該真實、易於理解、便於實現
建模：對客觀事物加以抽象，提取主要特徵，歸納成一個簡單清晰的輪廓，使復雜問題變得易於處理
數據模型三要素：數據結構、數據操作、完整性約束
數據結構描述靜態特徵，按數據結構可以把數據模型分為層次模型、網狀模型、關系模型
數據操作描述動態特徵，數據操作主要分為更新（插入、刪除、修改）、檢索兩大類，統稱增、刪、改、查
完整性約束確保數據的正確性、有效性、相容性
資料庫：簡稱DB(database)，是由資料庫管理系統管理的數據的聚集
資料庫管理系統:簡稱DBMS(DataBase Management System)是專門用於建立和管理資料庫的一套軟體，介於應用程序和操作系統之間。屬於系統軟體
資料庫系統：簡稱DBS（DataBase System)。資料庫、DBMS、應用程序和軟體系統統稱資料庫系統
關系：關系就是一張二維表
關系模型：數據以關系的形式表示，就是以二維表的形式表示數據模型
屬性：關系的標題欄中各列的名字
模式：關系的名稱和關系的屬性集
元組：二維表的所有行統稱為元組，元組的各個分量對應於關系的各個屬性。一個元組表示一個對象
域：關系的每個屬性的取值范圍
關系的實例：給定關系中元組的集合稱為該關系的「實例」。一個給定的關系模式，可以有許多關系實例。
關系型資料庫管理系統：簡稱RDBMS(Relationg DataBase Management System)，採用關系數據模型的資料庫管理系統。
資料庫系統的體系結構的三層結構和兩層映象：從資料庫管理的角度出發，資料庫系統的體系可分三層，外模式、模式、內模式。兩層映象是，外模式/模式映象、模式/內模式映象
外模式：又稱用戶模式，相當於SQL中的視圖（VIEW)模式，是資料庫用戶可以看見和使用的局部數據的邏輯結構和特徵描述，是與某應用有關的數據的邏輯表示
模式：分為概念模式、邏輯模式，是所有資料庫用戶的公共數據視圖，是資料庫中全部數據的邏輯結構和特徵的描述，一個資料庫只有一個模式
外模式/模式映象：把局部邏輯結構描述與全局邏輯結構描述聯系起來。一個模式可以與多個外模式對應聯系。例如，SQL SERVER中一個關系模式上可以建立多個滿足不同用戶要求的視圖VIEW。這種映象可以保證數據與應用程序之間的邏輯獨立性，即改變模式，不影響外模式，則與外模式相關的應用程序無序修改
內模式：由稱為存儲模式，是資料庫物理結構和存儲方式的描述，是數據在資料庫內部的表示方式。一個資料庫只有一個內模式。內模式描述記錄的存儲方式、索引的組織方式、數據是否壓縮、是否加密等，不涉及硬體設備。
模式/內模式映象：把全局邏輯結構描述與物理結構描述聯系起來。一個模式只有一個內模式。這種映象保證了數據與程序之間的物理獨立性，當內模式修改時，由於模式未變，所以無需修改程序。
DBMS的體系結構（組成）：查詢處理程序、存儲管理程序、事務管理程序、客戶/伺服器程序體系結構
查詢處理程序：負責查詢處理，它的一個重要任務是「優化」查詢。
事務管理程序：保證多個事務並發執行
存儲管理程序：既管理磁碟上的數據文件又管理存放數據文件部分內容的內存數據緩沖區
客戶/伺服器程序體系結構：大多數DBMS程序採用這種程序體系結構，把整個DBMS程序系統劃分為兩部分，DBMS核心部分屬於伺服器程序，客戶程序主要用於與用戶相互配合並將查詢或其他命令傳送給伺服器程序的查詢介面。
資料庫設計
資料庫設計的步驟：需求分析、概念設計、邏輯設計、物理設計
需求分析和概念設計階段的工作與具體資料庫管理系統無關，這一階段的工作獨立於資料庫管理系統
邏輯設計和物理設計階段的共組與具體採用何種資料庫管理系統相關。
需求分析階段：應用領域的調查、定義信息與應用、定義操作任務、定義數據項、預測未來改變，結果產生相關文檔
概念設計階段：也稱為建模
任務：資料庫概念模式（模式）設計、事務設計
概念模式設計的工具：E/R圖。對於面向對象的資料庫則可採用面向對象定義語言ODL
E/R圖：稱為實體-聯系模型
E/R圖的組成：實體集（矩形）、屬性（橢圓）、聯系（菱形）
聯系的類型：一對一、一對多、多對多。用線條和箭頭表示不同的聯系。箭頭指向的一方代表「一」
鍵碼屬性的表示：下劃線
聯系中的角色：即一個實體集內部實體之間的聯系
多向聯系：多個實體集之間發生的一個聯系
多向聯系轉化為雙向聯系的方法：將多向聯系轉換成實體集，然後在原來與之聯系的實體集和新的實體集之間建立新的雙向聯系
E/R圖中的子類的表示方法和繼承：如果實體集B是實體集A的子類，則它們之間用一個標有isa的三角形和兩根線條建立特殊的聯系。三角形的尖端指向超類（父類），子類實體集上只需標出子類特有的屬性，繼承父類的所有屬性。
ODL對象定義語言：是用面向對象的術語來說明資料庫結構的一種推薦的標准語言，主要用途是書寫面向對象資料庫的設計
對象：是某種可研究，可觀察的實體，例如：一個人、一門課程、一本書等等
類：具有相似特性的對象可以歸為一類
ODL描述的三種特性：屬性（Attribute)、聯系（Relationship)、方法(Method)
ODL書寫規則：
interface 類名1{
attribute 數據類型1 屬性名1；
attribute 數據類型2 屬性名2；
.
.
.
relationship [Set]<類名2> 聯系名1
inverse 類名2::聯系名2；
.
.
}
說明：
關鍵字interface、attribute、relationship、<set>、inverse
常用數據類型有string（字元串）、integer（整型）、float（浮點型）、enum（枚舉型）
[]中的set為任選項，當類1與類2的聯系是一對一時，不需要使用set，當類1與類2的聯系是一對多時必須使用set
inverse表示在類2中聯系名2所表示的聯系與類1中聯系名1所表示的聯系是多對一的對應聯系
ODL例一：用ODL描述製片公司與電影，假如製片公司部名稱不重復。因為，一個製片公司可以製作多部影片，而一部影片只能由一個公司製作發行，所以製片公司與影片的關系是一對多的關系。
interface studio{
attribute string studioname;
attribute string address;
attribute string phone;
relationship set<movie> make
inverse movie::madeby;
}
interface movie{
attribute string movietitle;
attribute integer length;
attribute enum incolor ;
attribute integer year;
relationship set studio madeby
inverse studio::make;
}
ODL例二：用ODL描述學生與課程，一名學生可以選擇多門課程來學習，一門課程可以被多名學生選修。
interface student{
attribute string sname;
attribute string address;
attribute enum gender ;
attribute integer age;
relationship set<course> choice
inverse course::choisedby;
}
interface course{
attribute string ctitle;
attribute integer credit;
relationship set<student> choisedby
inverse student::choice;
}
ODL例三：用ODL描述校長與學校的關系，一名校長只能管理一所學校，一所學校只能設一名校長。
interface chairman{
attribute string chname;
attribute enum gender ;
attribute integer age;
attribute string phone;
relationship set university manage
inverse university::leadby;
}
interface university{
attribute string unnmae;
attribute string addr;
relationship set chairman leadby
inverse chairman::manage;
}
ODL子類描述方法：自類繼承父類的所有屬性和聯系。子類可以有自己的特殊屬性和聯系。子類中屬性和聯系的描述方法與上述例子相同。
interface 子類名:基類名
ODL子類描述例：碩士研究生類是學生的一個子類。每名碩士研究生有若干名導師，一名導師可以帶多名碩士研究生。
interface student{
attribute string sname;
attribute string address;
attribute enum gender ;
attribute integer age;
}
interface master:student{
attribute string special;
relationship set<advisor> direct
inverse advisor::directedby;
}
interface advisor{
attribute string name;
attribute string address;
}
邏輯設計階段：把概念設計階段產生的資料庫概念模式變換為資料庫邏輯模式。資料庫邏輯模式依賴於邏輯數據模型和資料庫管理系統。目前做流行的資料庫管理系統都是關系型邏輯數據模型。所以，本教程知討論如何把概念模式轉變為關系模型
邏輯設計階段的步驟：
1.概念模式轉變為關系模型
2.對關系模型進行規范化和優化
3.適應DBMS限制條件的修改
4.對性能、存儲空間等的優化
1.概念模式轉變為關系模型
E/R圖轉變為關系模型的方法：
1.一個實體集轉變為一個關系模式，這個關系模式包含實體集所有的簡單屬性和復合屬性的簡單子屬性。實體集的名稱可以用作為關系模式的名稱，用下劃線來表示關系的鍵碼
2.一個聯系轉變為一個關系模式，一般情況下用聯系名作為關系名，用聯系的實體集的鍵碼和聯系本身的屬性作為此關系模式的屬性集。
E/R圖轉變為關系模型實例：
實例一：一個班級只能有一個班長，而且必須有一個班長，E/R圖如下：
學生與班級的聯系是一對一的聯系(1:1)。學生實體集的鍵碼是學號。班級實體集的鍵碼是班號。這個E/R圖可以轉變為如下的關系模型
學生（學號，姓名，性別，出生日期）
班級（班號，名稱，地點）
班長（學號，班號，注冊）
聯系反映的是具有某學號的學生擔任具有某班號班級的班長。這種轉變方法是常用的方法。
如果想減少查詢時使用連接操作的次數，提高查詢效率，以上E/R圖也可以轉變為如下關系模型
學生（學號，姓名，性別，出生日期，班號）
班級（班號，名稱，地點）
學生關系模式中的「班號」是外鍵碼。這種關系模式中，由於學生關系中記錄了所有學生的學號，但不是每個學生都擔任班長（按教科書上的術語叫做不是全參與），因此不是每個元組的班號屬性都有數據，即應該允許班號為空。否則，學生實體集必須是全參與，即每個學生都是班長。
實例二：一個影片公司可以製作多部影片，但是一部影片只能歸一個製片公司所有。假如公司不重名，影片也不重名，則公司名稱是製片公司實體集的鍵碼，影片名是影片實體集的鍵碼。
影片公司與影片的聯系是1對多的聯系（1：N)。這個E/R圖可以轉變為以下關系模型
影片公司（公司名稱，地點）
影片（影片名，片長）
製作（公司名稱，影片名）
同樣，假如影片公司是全參與，即每個影片公司至少製作了一部電影，則可以轉變為以下關系模型
影片公司（公司名稱，地點，影片名）
影片（影片名，片長）
其中，影片公司關系中的影片名是外鍵碼
實例三：學生與課程之間的聯系是「選修」。一個學生可以選多門課程，一門課程可以被多名學生選修，所以它們之間的「選修」聯系是多對多(N:M)
上述E/R圖可以轉變為以下關系模型
學生（學號，姓名）
課程（課程號，課程名）
選修（學號，課程號，成績）
選修關系中的學號和課程號是外鍵碼
2.對關系模型進行規范化和優化
為什麽要把關系模型規范化：為了有效地消除關系中存在的數據冗餘和更新異常等現象
基本概念
函數依賴：如果關系R的兩個元組在屬性A1，A2，...An上一致，則它們的另一個屬性B上也一致，那末，我們就說在關系R中屬性B函數地依賴於屬性A1，A2，...An或者說屬性A1，A2，...An函數決定屬性B。
關系的鍵碼：
如果一個或多個屬性的集合滿足如下條件，則稱該集合為關系R的鍵碼（key):
1.這些屬性函數決定該關系的所有其它屬性。
2.的任何真子集都不能函數決定R的所有其它屬性。
關系的超鍵碼：包含鍵碼的屬性集稱為超鍵碼，是「鍵碼的超集」的簡稱
函數依賴規則：分解/合並規則、傳遞規則、平凡依賴規則
平凡依賴：對於函數依賴A1，A2，...An->B，如果B是A中的某一個，我們稱這種依賴是平凡依賴
非平凡依賴：對於函數依賴A1，A2，...An->B，如後B中至少有一個不在A中，我們稱這種依賴是非平凡依賴
完全非平凡依賴：對於函數依賴A1，A2，...An->B，B中沒有一個在A中，我們稱這種依賴是完全非平凡依賴
主屬性：鍵碼所在的屬性
非主屬性：鍵碼以外的屬性
封閉集（閉包）對於給定的函數依賴集S，屬性集A函數決定的屬性集合就是屬性集A在依賴集S下的封閉集
範式就是符合某一種級別的關系模式的集合。
規范化通過分解把屬於低級範式的關系模式轉換為幾個屬於高級範式的關系模式的集合，這一過程稱為規范化
1範式（1NF)，如果一個關系模式R的所有屬性都是不可分割的基本數據項，則這個關系屬於1NF
2範式(2NF),若關系模式R屬於1NF，且每個非主屬性都完全依賴於鍵碼，則R屬於2NF
3範式（3NF),若關系模式R屬於1NF，且每個非主屬性都不傳遞依賴於鍵碼，則R屬於3NF
BC範式（BCNF),若關系模式屬於1NF，且R的每個非平凡依賴的決定因素都包含鍵碼，則R屬於BCNF
規范化分解原則：無損連接、保持依賴
無損連接：當對關系模式R進行分解時，R的元組將分別在相應屬性集進行投影而產生新的關系，如果對新的關系進行自然連接得到的元組的集合與原關系完全一致，則稱為無損連接
保持依賴：如果分解後的總的函數依賴集與原函數依賴集保持一致，則稱為保持依賴。
模式分解的兩個規則：公共屬性共享、相關屬性合一
公共屬性共享：保留公共屬性，進行自然連接是分解後的模式實現無損連接的必要條件
相關屬性合一：把以函數依賴的形式聯系在一起的相關屬性放在一個模式中，從而使原有的函數依賴得以保持，這是分解後的模式實現保持依賴的充分條件
模式分解的三種方法
一、部分依賴歸子集；完全依賴隨鍵碼——用於建立2NF
例：關系R(A,B,C,D,E,F,G)上存在函數依賴,A->BCD,E->F,AE->G,AE->BCD,AE->F
分析以上依賴可以看出，AE是鍵碼（AE->BCD)。因為AE是鍵碼，A是主屬性，A->BCD，所以BCD是部分依賴於AE
根據部分依賴歸子集的方法，因為A是AE的真子集，所以A與BCD歸在一起構成一個關系模式。R1(A,B,C,D)
同理對於AE->F，有E->F所以AE->F是部分依賴，非主屬性F所依賴的真子集是E，所以E和F可以歸在一個關系模式中R2(E,F)
AE->G是完全函數依賴，完全依賴隨鍵碼，所以AEG歸在一個關系模式中R3(A,E,G)
因此R(A,B,C,D,E,F,G)可以分解為符合2NF的關系模式如下:
R1(A,B,C,D)
R2(E,F)
R3(A,E,G)
二、基本依賴為基礎，中間屬性做橋梁——用於建立3NF
例：關系R(A,B,C,D,E)上存在函數依賴,AB->C,C->D,D->E
顯然中間橋梁是C->D，他構成了傳遞依賴鏈，因此，R可以分解為R1(A,B,C),R2(C,D)。分解後在R1，R2中都不存在傳遞依賴。
三、找違例自成一體，舍其右全集歸一；若發現仍有違例，再回首如法炮製——用於建立BCNF
BCNF違例：違背BC範式的函數依賴稱為BC範式違例
例：關系R(A,B,C,D,E)的鍵碼是AB,有函數依賴AB->CDE,ABC->E,C->D
分析上述三個函數依賴可以看出，C->D是BCNF違例。因為它的決定因素不包含鍵碼。我們作如下分解
違例自成一體，即CD構成一個關系模式R1(C,D)
舍其右全集歸一，即從R的屬性中取掉C->D的右邊的屬性D，其左邊的屬性C與其他所有屬性構成一個新的關系R2(A,B,C,E)
新的關系模式如下：
R1(C,D)
R2(A,B,C,E)
注意：以BCNF違例為基礎進行模式分解，最終得到的屬於BCNF的關系模式都能實現無損連接，但未必能保持函數依賴
邏輯設計例一：假如有關系模式R(A,B,C,D)和函數依賴集S=。
（1）找出所有BCNF違例。
（2）如果該關系模式不是BCNF，則將它分解為BCNF
（3）找出所有的違背3NF的依賴
（4）如果該關系不是3NF，則將它分解為3NF
步驟一：找出R在S上的所有非平凡依賴，首先計算封閉集
單屬性封閉集：A+=A,B+=BCD,C+=C,D+=D
雙屬性封閉集：AB+=ABCD,AC+=AC,AD+=AD,BC+=BCD,BD+=BCD,CD+=CD
三屬性封閉集：ABC+=ABCD,ABD+=ABCD,BCD+=BCD,ACD+=ACD
四屬性封閉集：ABCD+=ABCD
步驟二：根據計算所得的封閉集，找出鍵碼和超鍵碼
鍵碼：AB
超鍵碼：ABC,ABD,ABCD
步驟三：找出所有的非平凡函數依賴
B->C,B->D,AB->C,AB->D,BC->D,BD->C,ABC->D,ABD->C
其中，AB->C,AB->D,ABC->D,ABD->C不是BCNF違例，因為前兩個依賴的決定因素本身就是鍵碼，而後兩個依賴的決定因素包含鍵碼。所以，B->C,B->D,BC->D,BD->C是BCNF違例，因為它們的決定因素都不包含鍵碼。實際上可以看出R不是2NF，因為存在部分函數依賴：ABC->D,ABD->C,AB->C,AB->D,B->C,B->D
步驟四：進行BCNF規范。BCNF違例自成一體。從以上BCNF違例中選擇B->C自成一體
R1(B,C)
舍其右全集歸一，即捨去B->C的右邊屬性C，所以得到
R2(A,B,D)
但是在R2中還存在BCNF違例B->D，因此B->D自成一體，得到R21(B,D),舍其右全集歸一得到R22(A,B)
最後得到的關系模式是：R1(B,C),R21(B,D),R22(A,B)
通過關系模式分解，把一個非2NF的關系模式歸范成一個BCNF。代價是，在實際操作中增加了連接操作。
（3）B->C,B->D，B不是鍵碼也不是超鍵碼，而C,D都是鍵碼以外的屬性，即是非主屬性。所以R不是3NF。
邏輯設計例二：有關系R(A,B,C,D)和函數依賴集S=
（1）找出所有BCNF違例。
（2）如果該關系模式不是BCNF，則將它分解為BCNF
（3）找出所有的違背3NF的依賴
（4）如果該關系不是3NF，則將它分解為3NF
步驟一：找出R在S上的所有非平凡依賴，首先計算封閉集
單屬性封閉集：A+=ABCD,B+=ABCD,C+=ABCD,D+=ABCD
雙屬性封閉集：AB+=ABCD,AC+=ABCD,AD+=ABCD,BC+=ABCD,BD+=ABCD,CD+=ABCD
三屬性封閉集：ABC+=ABCD,ABD+=ABCD,BCD+=ABCD,ACD+=ABCD
四屬性封閉集：ABCD+=ABCD
步驟二：找出所有非平凡函數依賴
A->B,A->C,A->D,B->A,B->C,B->D,C->A,C->B,C->D,D->A,D->B,D->C
AB->C,AB->D,AC->B,AC->D,AD->B,AD->C,BC->A,BC->D,BD->A,BD->C,CD->A,CD->B
ABC->D,ABD->C,BCD->A,ACD->B
步驟三：找出鍵碼和超鍵碼
鍵碼：A,B,C,D
超鍵碼：AB,AC,AD,BC,BD,CD,ABC,ABD,BCD,ACD,ABCD
根據以上結果分析，R是3NF也是BCNF
3NF要求不存在每個非主屬性對於鍵碼的部分依賴或傳遞依賴
練習：對於
1.R(A,B,C,D)和函數依賴集S=
2.R(A,B,C,D,E)和函數依賴集S=
3.R(A,B,C,D,E)和函數依賴集S=
（1）找出所有BCNF違例。
（2）如果該關系模式不是BCNF，則將它分解為BCNF
物理設計階段：任務是在資料庫邏輯設計的基礎上，為每個關系模式選擇合適的存儲結構和存取路徑
物理設計階段步驟：
（1）分析影響資料庫物理設計的因素；
（2）為關系模?
請參考
『伍』 資料庫閉包怎麼算的
閉包就是由一個屬性直接或間接推導出的所有屬性的集合，例如： f={a->b,b->c,a->d,e->f} ，由a可直接得到b和d，間接得到c，則a的閉包就是{a,b,c,d}。
例：設關系R(A,B,C, D,E, G)有函數依賴集F={AB→C, BC→AD,D→E, CG→B}，求AB的閉包。
解：首先從AB出發，令X={A,B}，由於函數依賴AB→C左邊的所有屬性都在X中，所以可以把右邊的C添加到X中，這時X={A, B,C}，其次考慮函數依賴BC→AD，左邊B，C均在X中，右邊D不在X中,將其添加到X中，此時X={A,B,C,D}。
再考慮函數依賴D→E，同理可將E添加到X中，此時x={A,B,C,D,E}。上述方法再不能向X中添加屬性，所以得到{A,B} +={A,B,C,D, E}。
(5)sql的閉包擴展閱讀：
使用閉包的注意點
1，由於閉包會使得函數中的變數都被保存在內存中，內存消耗很大，所以不能濫用閉包，否則會造成網頁的性能問題，在IE中可能導致內存泄露。解決方法是，在退出函數之前，將不使用的局部變數全部刪除。
2，閉包會在父函數外部，改變父函數內部變數的值。所以，如果你把父函數當作對象（object）使用，把閉包當作它的公用方法（Public Method），把內部變數當作它的私有屬性（private value），這時一定要小心，不要隨便改變父函數內部變數的值。
『陸』 資料庫中的閉包的意思
閉包是可以包含自由（未綁定）變數的代碼塊；這些變數不是在這個代碼塊或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數的存在，相關變數引用沒有釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby 和 Python 等語言中都能找到對閉包不同程度的支持。
閉包的價值在於可以作為函數對象 或者匿名函數，對於類型系統而言這就意味著不僅要表示數據還要表示代碼。支持閉包的多數語言都將函數作為第一級對象，就是說這些函數可以存儲到變數中、作為參數傳遞給其他函數，最重要的是能夠被函數動態地創建和返回。
『柒』 在資料庫的函數依賴里，閉包(closure)是什麼意思謝謝~
閉包就是由一個屬性直接或間接推導出的所有屬性的集合，例如：
f={a->b,b->c,a->d,e->f}
由a可直接得到b和d，間接得到c，則a的閉包就是{a,b,c,d}
『捌』 python函數的閉包怎麼理解
1. 閉包的概念
首先還得從基本概念說起，什麼是閉包呢？來看下維基上的解釋:
復制代碼代碼如下:
在計算機科學中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變數的函數。這個被引用的自由變數將和這個函數一同存在，即使已經離開了創造它的環境也不例外。所以，有另一種說法認為閉包是由函數和與其相關的引用環境組合而成的實體。閉包在運行時可以有多個實例，不同的引用環境和相同的函數組合可以產生不同的實例。
....
上面提到了兩個關鍵的地方： 自由變數 和 函數, 這兩個關鍵稍後再說。還是得在贅述下「閉包」的意思，望文知意，可以形象的把它理解為一個封閉的包裹，這個包裹就是一個函數，當然還有函數內部對應的邏輯，包裹裡面的東西就是自由變數，自由變數可以在隨著包裹到處游盪。當然還得有個前提，這個包裹是被創建出來的。
在通過Python的語言介紹一下，一個閉包就是你調用了一個函數A，這個函數A返回了一個函數B給你。這個返回的函數B就叫做閉包。你在調用函數A的時候傳遞的參數就是自由變數。
舉個例子：
復制代碼代碼如下:
def func(name):
def inner_func(age):
print 'name:', name, 'age:', age
return inner_func
bb = func('the5fire')
bb(26) # >>> name: the5fire age: 26
這裡面調用func的時候就產生了一個閉包——inner_func,並且該閉包持有自由變數——name，因此這也意味著，當函數func的生命周期結束之後，name這個變數依然存在，因為它被閉包引用了，所以不會被回收。
另外再說一點，閉包並不是Python中特有的概念，所有把函數做為一等公民的語言均有閉包的概念。不過像Java這樣以class為一等公民的語言中也可以使用閉包，只是它得用類或介面來實現。
更多概念上的東西可以參考最後的參考鏈接。
2. 為什麼使用閉包
基於上面的介紹，不知道讀者有沒有感覺這個東西和類有點相似，相似點在於他們都提供了對數據的封裝。不同的是閉包本身就是個方法。和類一樣，我們在編程時經常會把通用的東西抽象成類，（當然，還有對現實世界——業務的建模），以復用通用的功能。閉包也是一樣，當我們需要函數粒度的抽象時，閉包就是一個很好的選擇。
在這點上閉包可以被理解為一個只讀的對象，你可以給他傳遞一個屬性，但它只能提供給你一個執行的介面。因此在程序中我們經常需要這樣的一個函數對象——閉包，來幫我們完成一個通用的功能，比如後面會提到的——裝飾器。
3. 使用閉包
第一種場景 ，在python中很重要也很常見的一個使用場景就是裝飾器，Python為裝飾器提供了一個很友好的「語法糖」——@，讓我們可以很方便的使用裝飾器，裝飾的原理不做過多闡述，簡言之你在一個函數func上加上@decorator_func, 就相當於decorator_func(func):
復制代碼代碼如下:
def decorator_func(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@decorator_func
def func(name):
print 'my name is', name
# 等價於
decorator_func(func)
在裝飾器的這個例子中，閉包（wrapper）持有了外部的func這個參數，並且能夠接受外部傳過來的參數，接受過來的參數在原封不動的傳給func，並返回執行結果。
這是個簡單的例子，稍微復雜點可以有多個閉包，比如經常使用的那個LRUCache的裝飾器，裝飾器上可以接受參數@lru_cache(expire=500)這樣。實現起來就是兩個閉包的嵌套:
復制代碼代碼如下:
def lru_cache(expire=5):
# 默認5s超時
def func_wrapper(func):
def inner(*args, **kwargs):
# cache 處理 bala bala bala
return func(*args, **kwargs)
return inner
return func_wrapper
@lru_cache(expire=10*60)
def get(request, pk)
# 省略具體代碼
return response()
不太懂閉包的同學一定得能夠理解上述代碼，這是我們之前面試經常會問到的面試題。
第二個場景 ，就是基於閉包的一個特性——「惰性求值」。這個應用比較常見的是在資料庫訪問的時候，比如說：
復制代碼代碼如下:
# 偽代碼示意
class QuerySet(object):
def __init__(self, sql):
self.sql = sql
self.db = Mysql.connect().corsor() # 偽代碼
def __call__(self):
return db.execute(self.sql)
def query(sql):
return QuerySet(sql)
result = query("select name from user_app")
if time > now:
print result # 這時才執行資料庫訪問
上面這個不太恰當的例子展示了通過閉包完成惰性求值的功能，但是上面query返回的結果並不是函數，而是具有函數功能的類。有興趣的可以去看看Django的queryset的實現，原理類似。
第三種場景 ， 需要對某個函數的參數提前賦值的情況，當然在Python中已經有了很好的解決訪問 functools.parial,但是用閉包也能實現。
復制代碼代碼如下:
def partial(**outer_kwargs):
def wrapper(func):
def inner(*args, **kwargs):
for k, v in outer_kwargs.items():
kwargs[k] = v
return func(*args, **kwargs)
return inner
return wrapper
@partial(age=15)
def say(name=None, age=None):
print name, age
say(name="the5fire")
# 當然用functools比這個簡單多了
# 只需要： functools.partial(say, age=15)(name='the5fire')
看起來這又是一個牽強的例子，不過也算是實踐了閉包的應用。
『玖』 什麼是閉包，我的理解
閉包是可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Lua、objective c 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
中文名：閉包
外文名：closure
相關學科：離散數學
用途：編程邏輯
特點：未綁定到特定對象
分享
拓撲概念
集合A的閉包定義為所有包含A的閉集之交。A的閉包是包含A的最小閉集。
本質
集合 S 是閉集當且僅當 Cl(S)=S（這里的cl即closure，閉包）。特別的，空集的閉包是空集，X 的閉包是 X。集合的交集的閉包總是集合的閉包的交集的子集（不一定是真子集）。有限多個集合的並集的閉包和這些集合的閉包的並集相等；零個集合的並集為空集，所以這個命題包含了前面的空集的閉包的特殊情況。無限多個集合的並集的閉包不一定等於這些集合的閉包的並集，但前者一定是後者的父集。
若 A 為包含 S 的 X 的子空間，則 S 在 A 中計算得到的閉包等於 A 和 S 在 X 中計算得到的閉包（Cl_A(S) = A ∩ Cl_X(S））的交集。特別的，S在 A 中是稠密的，當且僅當 A 是 Cl_X(S) 的子集。
『拾』 什麼是閉包，為什麼要使用閉包，寫出一個閉包的常用寫法
用閉包主要是 復用 和 處理非同步 因為 不用閉包的時候，用的數據為變數，使用閉包，數據為參數（比如例子中的 t ）；
ex1:function cg(t){console.log(t)};
cg(1) //1
cg(2) //2
cg(3) //3
ex2: function plus(t,n){
return t+n;
}
var score = plus(3,3) // score = 6