哪些編程語言有閉包

① javascript的變數是強類型還是弱類型，是否了解閉包概念，原型鏈

javascript的變數是弱類型。
閉包：在類似C/C++這種的非函數式編程語言中專，也可以定義函數指針並返屬回，但外層函數在執行結束後為內層函數定義的上下文信息會被銷毀，而在閉包中，則保存了返回的函數，還包含返回函數的上下文信息。閉包有兩個用途，一是方便實現嵌套的回調函數，二是隱藏對象的細節。
原型鏈：創建對象時，應該在構造函數內定義一般成員，而是其原型定義成員函數。js中有兩個特殊的對象：Object與Function，它們都是構造函數，用於生成對象。Object.prototype是所有對象的祖先，Function.prototype是所有函數的原型，包括構造函數。可以將JS的對象分為三類：用戶創建對象，構造函數對象，原型對象。所有對象中都有一個__proto__屬性，其指向此對象的原型。
構造函數對象有prototype，指向其原型對象，通過此構造函數創建對象時，新創建對象的__proto__屬性將會指向構造函數的prototype屬性。原型對象有一個constructor屬性，指向它對應的構造函數。

② 閉包是什麼，有什麼特性，對頁面有什麼影響

閉包是可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。
閉包 (closure）是個精確但又很難解釋的電腦名詞。在 Perl 裡面，閉包是以 匿名函數的形式來實現，具有持續參照位於該函數范圍之外的文字式變數值的能力。這些外部的文字變數會神奇地保留它們在閉包函數最初定義時的值 （深連結）。
如果一個程式語言容許函數遞回另一個函數的話 （像 Perl 就是），閉包便具有意義。要注意的是，有些語言雖提供匿名函數的功能，但卻無法正確處理閉包； Python 這個語言便是一例。如果要想多了解閉包的話，建議你去找本功能性程式 設計的教科書來看。Scheme這個語言不僅支持閉包，更鼓勵多加使用。
以下是個典型的產生函數的函數：
sub add_function_generator {
return sub { shift + shift };
}
$add_sub = add_function_generator();
$sum = &$add_sub(4,5)； # $sum是 9了
閉包用起來就像是個函數樣板，其中保留了一些可以在稍後再填入的空格。add_function_generator() 所遞回的匿名函數在技術上來講並不能算是一個閉包， 因為它沒有用到任何位在這個函數范圍之外的文字變數。
把上面這個例子和下面這個make_adder()函數對照一下，下面這個函數所遞回的匿名函數中使用了一個外部的文字變數。這種指明外部函數的作法需要由 Perl遞回一個適當的閉包，因此那個文字變數在匿名函數產生之時的值便永久地被鎖進閉包里。
sub make_adder {
my $addpiece = shift;
return sub { shift + $addpiece };
}
$f1 = make_adder(20)；
$f2 = make_adder(555)；
這樣一來&$f1($n) 永遠會是 20加上你傳進去的值$n ，而&$f2($n) 將 永遠會是 555加上你傳進去的值$n。$addpiece的值會在閉包中保留下來。
閉包在比較實際的場合中也常用得到，譬如當你想把一些程式碼傳入一個函數時：
my $line;
timeout（30,sub { $line = <STDIN> });
如果要執行的程式碼當初是以字串的形式傳入的話，即'$line = <STDIN>' ，那麼timeout() 這個假想的函數在回到該函數被呼叫時所在的范圍後便無法再擷取$line這個文字變數的值了。

語法結構編輯
Groovy的閉包
閉包（Closure）是Java所不具備的語法結構。閉包就是一個代碼塊，用「{ }」包起來。此時，程序代碼也就成了數據，可以被一個變數所引用（與C語言的函數指針比較類似）。閉包的最典型的應用是實現回調函數（callback）。Groovy的API大量使用閉包，以實現對外開放。閉包的創建過程很簡單，例如：
{ 參數 ->
代碼...
}
參考下面的例子代碼，定義了c1和c2兩個閉包，並對它們進行調用：
def c1 = { println it }
def c2 = { text -> println text }
c1.call("content1") //用call方法調用閉包
c2("content2") //直接調用閉包
「->；」之前的部分為閉包的參數，如果有多個參數，之間可用逗號分割；「->；」之後的部分為閉包內的程序代碼。如果省略了「->；」和它之前的部分，此時閉包中代碼，可以用名為「it」的變數訪問參數。
閉包的返回值和函數的返回值定義方式是一樣的：如果有return語句，則返回值是return語句後面的內容；如果沒有return語句，則閉包內的最後一行代碼就是它的返回值。[1]

環境表達編輯
在Javascript中閉包（Closure)
什麼是閉包
「官方」的解釋是：所謂「閉包」，指的是一個擁有許多變數和綁定了這些變數的環境的表達式（通常是一個函數），因而這些變數也是該表達式的一部分。
相信很少有人能直接看懂這句話，因為他描述的太學術。我想用如何在Javascript中創建一個閉包來告訴你什麼是閉包，因為跳過閉包的創建過程直接理解閉包的定義是非常困難的。看下面這段

代碼

1
2
3
4
5
6
7
8
9

function a(){
var i=0;
function b(){
alert(++i);
}
return b;
}
var c=a();
c();

特點
這段代碼有兩個特點：
1、函數b嵌套在函數a內部；
2、函數a返回函數b。
這樣在執行完var c=a( )後，變數c實際上是指向了函數b，再執行c( )後就會彈出一個窗口顯示i的值（第一次為1）。這段代碼其實就創建了一個閉包，為什麼？因為函數a外的變數c引用了函數a內的函數b，就是說：
當函數a的內部函數b被函數a外的一個變數引用的時候，就創建了一個閉包。

作用
簡而言之，閉包的作用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制GC不會收回a所佔用的資源，因為a的內部函數b的執行需要依賴a中的變數。這是對閉包作用的非常直白的描述，不專業也不嚴謹，但大概意思就是這樣，理解閉包需要循序漸進的過程。
在上面的例子中，由於閉包的存在使得函數a返回後，a中的i始終存在，這樣每次執行c（），i都是自加1後alert出i的值。
那 么我們來想像另一種情況，如果a返回的不是函數b，情況就完全不同了。因為a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，因此函數a和b互相引用但又不被外界打擾（被外界引用），函數a和b就會被GC回收。（關於Javascript的垃圾回收機制將在後面詳細介紹）

另一個例子
模擬私有變數
function Counter(start){
var count = start;
return{
increment:function(){
count++;
},
get:function(){
return count;
}
}
}
var foo =Counter(4);
foo.increment();
foo.get();// 5

結果
這里，Counter 函數返回兩個閉包，函數 increment 和函數 get。 這兩個函數都維持著 對外部作用域 Counter 的引用，因此總可以訪問此作用域內定義的變數 count.
文法
objective c的閉包（block）
objective c 中的的閉包，是通過block實現的。Apple在C，Objective-C和C++中擴充了Block這種文法的，並且在GCC4.2中進行了支持。你可以把它理解為函數指針，匿名函數，閉包，lambda表達式，這里暫且用塊對象來表述，因為它們之間還是有些許不同的。
聲明一個塊
如果以內聯方式使用塊對象，則無需聲明。塊對象聲明語法與函數指針聲明語法相似，但是塊對象應使用脫字元(^)而非星號指針 (*)。下面的代碼聲明一個aBlock變數，它標識一個需傳入三個參數並具有float返回值的塊。
float (^aBlock)(const int*, int, float);
l 創建一個塊
塊使用脫字元(^)作為起始標志，使用分號作為結束標志。下面的例子聲明一個簡單塊，並且將其賦給之前聲明的block變數（oneFrom）。
int (^oneFrom)(int);
oneFrom = ^(int anInt) {
return anInt - 1;
};
微觀世界
如 果要更加深入的了解閉包以及函數a和嵌套函數b的關系，我們需要引入另外幾個概念：函數的執行環境（execution context）、活動對象（call object）、作用域（scope）、作用域鏈（scope chain）。以函數a從定義到執行的過程為例闡述這幾個概念。
1、當定義函數a的時候，js解釋器會將函數a的作用域鏈（scope chain）設置為定義a時a所在的「環境」，如果a是一個全局函數，則scope chain中只有window對象。
2、當函數a執行的時候，a會進入相應的執行環境（execution context）。
3、在創建執行環境的過程中，首先會為a添加一個scope屬性，即a的作用域，其值就為第1步中的scope chain。即a.scope=a的作用域鏈。
4、然後執行環境會創建一個活動對象（call object）。活動對象也是一個擁有屬性的對象，但它不具有原型而且不能通過JavaScript代碼直接訪問。創建完活動對象後，把活動對象添加到a的作用域鏈的最頂端。此時a的作用域鏈包含了兩個對象：a的活動對象和window對象。
5、下一步是在活動對象上添加一個arguments屬性，它保存著調用函數a時所傳遞的參數。
6、最後把所有函數a的形參和內部的函數b的引用也添加到a的活動對象上。在這一步中，完成了函數b的的定義，因此如同第3步，函數b的作用域鏈被設置為b所被定義的環境，即a的作用域。
到此，整個函數a從定義到執行的步驟就完成了。此時a返回函數b的引用給c，又函數b的作用域鏈包含了對函數a的活動對象的引用，也就是說b可以訪問到a中定義的所有變數和函數。函數b被c引用，函數b又依賴函數a，因此函數a在返回後不會被GC回收。
當函數b執行的時候亦會像以上步驟一樣。因此，執行時b的作用域鏈包含了3個對象：b的活動對象、a的活動對象和window對象，如下圖所示：
如圖所示，當在函數b中訪問一個變數的時候，搜索順序是先搜索自身的活動對象，如果存在則返回，如果不存在將繼續搜索函數a的活動對象，依 次查找，直到找到為止。如果整個作用域鏈上都無法找到，則返回undefined。如果函數b存在prototype原型對象，則在查找完自身的活動對象 後先查找自身的原型對象，再繼續查找。這就是Javascript中的變數查找機制。

應用場景
1、保護函數內的變數安全。以最開始的例子為例，函數a中i只有函數b才能訪問，而無法通過其他途徑訪問到，因此保護了i的安全性。
2、在內存中維持一個變數。依然如前例，由於閉包，函數a中i的一直存在於內存中，因此每次執行c（），都會給i自加1。
以上兩點是閉包最基本的應用場景，很多經典案例都源於此。
回收機制
在Javascript中，如果一個對象不再被引用，那麼這個對象就會被GC回收。如果兩個對象互相引用，而不再被第3者所引用，那麼這兩個互相引用的對象也會被回收。因為函數a被b引用，b又被a外的c引用，這就是為什麼函數a執行後不會被回收的原因。

匿名內部
在Python中的閉包（Closure)
學過Java GUI編程的人都知道定義匿名內部類是注冊監聽等處理的簡潔有效手段，閉包的定義方式有點類似於這種匿名內部類，
但是閉包的作用威力遠遠超過匿名內部類，這也是很多流行動態語言選擇閉包的原因，相信你在JavaScript中已經了解它的神奇功效了。

定義
如果在一個內部函數里，對在外部作用域（但不是在全局作用域）的變數進行引用，那麼內部函數就被認為是閉包（closure）。
簡單閉包的例子：
下面是一個使用閉包簡單的例子，模擬一個計數器，通過將整型包裹為一個列表的單一元素來模擬使看起來更易變：
函數counter（）所作的唯一一件事就是接受一個初始化的值來計數，並將該值賦給列表count成員，然後定義一個內部函數incr（）。通過內部函數使用變數count，就創建了一個閉包。最魔法的地方是counter（）函數返回一個incr（），一個可以調用的函數對象。
運行：
>>> c = counter⑸
>>> type(c)
<type 'function'>
>>> print c()6
>>> print c()
7
代碼格式較重要
>>> c2 = counter（99）
100
>>> print c()
8

③ swift 什麼情況下使用閉包

閉包是功能性自包含模塊，可以在代碼中被傳遞和使用。 Swift 中的閉包與 C 和 Objective-C中的 blocks 以及其他一些編程語言中的 lambdas 比較相似。

閉包可以 捕獲 和存儲其所在上下文中任意常量和變數的引用。 這就是所謂的閉合並包裹著這些常量和變數，俗稱閉包。Swift會為您管理在 捕獲 過程中涉及到的內存操作。
注意：如果您不熟悉 捕獲 (capturing) 這個概念也不用擔心，後面會詳細對其進行介紹。
在Swift函數章節中介紹的全局和嵌套函數實際上也是特殊的閉包，閉包採取如下三種形式之一：
全局函數是一個有名字但不會捕獲任何值的閉包
嵌套函數是一個有名字並可以捕獲其封閉函數域內值的閉包
閉包表達式是一個利用輕量級語法所寫的可以捕獲其上下文中變數或常量值的沒有名字的閉包

Swift的閉包表達式擁有簡潔的風格，並鼓勵在常見場景中以實現語法優化，主要優化如下：
利用上下文推斷參數和返回值類型
單表達式（single-expression）閉包可以省略 return 關鍵字
參數名稱簡寫
Trailing 閉包語法

④ 用哪些編程語言寫出的代碼，讀著能感受到美

很多人都認為編程怎麼會和美掛上關系呢，苦澀無為的編程怎麼會美，這不可能啊，相信很多人都是這樣想的。那麼今天我就來和大家說說用哪些編程語言寫出的代碼，讀著能感受到美。大家一起來看看吧。

希望這些能對你們有所幫助。

⑤ 編程語言的分類和用途

編程語言的分類主要有：JavaScript、PHP、C、C++、java。

1、C語言：實模式、保護模式、調度、中斷、調用棧、回調……基本上計算機科學裡面的基本概念都會涉及。結構化編程，即將解決方案描述為一個清晰的過程，這其中會涉及數據的建模，介面的定義，項目整體的組織結構。

2、c++語言：虛函數、虛表、內聯、多繼承、const、泛型、模板（語言相關）opencv、OGRE、3D渲染、GPU、mesh、skeleton、幀循環、DX、GUI、MFC、Qt、消息隊列、非阻塞IO。適合領域：多媒體、高性能網路伺服器等較講究效率的應用程序。

3、java：位元組碼、虛擬機、垃圾回收、介面、多線程、包、程序庫、反射、框架、集成、組件、http、web、資料庫、SSH、javaee。java的程序比較講究擴展性和可維護性，一般會使用比較多的設計模式，常用的程序組織形式是MVC、監聽者模式等。

4、Javascript：閉包、對象、函數、CSS、DOM、Ajax、HTML5、node.js、V8。基於prototype的OO，以及基於閉包的函數式編程（後者用的更多）。常用代碼組織形式：事件觸發的回調機制（node.js與前端的區別是其自己定義、觸發事件）、基於非阻塞非同步IO的框架（node.js）。

5、PHP即「超文本預處理器」，是一種通用開源腳本語言。PHP是在伺服器端執行的腳本語言，與C語言類似，是常用的網站編程語言。PHP獨特的語法混合了C、Java、Perl以及 PHP 自創的語法。利於學習，使用廣泛，主要適用於Web開發領域。

⑥ 閉包的Lua中

當一個函數內部嵌套另一個函數定義時，內部的函數體可以訪問外部的函數的局部變數，這種特徵在lua中我們稱作詞法定界。雖然這看起來很清楚，事實並非如此，詞法定界加上第一類函數在編程語言里是一個功能強大的概念，很少語言提供這種支持。
下面看一個簡單的例子，假定有一個學生姓名的列表和一個學生名和成績對應的表；想根據學生的成績從高到低對學生進行排序， names = {Peter,Paul,Mary}
grades = {Mary = 10,Paul = 7,Peter = 8}
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] -- compare the grades
end) 假定創建一個函數實現此功能：
function sortbygrade (names,grades)
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] --compare the grades
end) 例子中包含在sortbygrade函數內部的sort中的匿名函數可以訪問sortbygrade的參數grades，在匿名函數內部grades不是全局變數也不是局部變數，我們稱作外部的局部變數（external local variable）或者upvalue。（upvalue意思有些誤導，然而在Lua中他的存在有歷史的根源，還有他比起external local variable簡短）。
看下面的代碼：
function newCounter()
local i = 0
return function() -- anonymous function
i = i + 1
return i
end
end
c1 = newCounter()
print(c1()) --> 1
print(c1()) --> 2
匿名函數使用upvalue i保存他的計數，當我們調用匿名函數的時候i已經超出了作用范圍，因為創建i的函數newCounter已經返回了。然而Lua用閉包的思想正確處理了這種情況。簡單的說，閉包是一個函數以及它的upvalues。如果我們再次調用newCounter，將創建一個新的局部變數i，因此我們得到了一個作用在新的變數i上的新閉包。
c2 = newCounter()
print(c2()) --> 1
print(c1()) --> 3
print(c2()) --> 2
c1、c2是建立在同一個函數上，但作用在同一個局部變數的不同實例上的兩個不同的閉包。
技術上來講，閉包指值而不是指函數，函數僅僅是閉包的一個原型聲明；盡管如此，在不會導致混淆的情況下我們繼續使用術語函數代指閉包。
閉包在上下文環境中提供很有用的功能，如前面我們見到的可以作為高級函數（sort）的參數；作為函數嵌套的函數（newCounter）。這一機制使得我們可以在Lua的函數世界裡組合出奇幻的編程技術。閉包也可用在回調函數中，比如在GUI環境中你需要創建一系列button，但用戶按下button時回調函數被調用，可能不同的按鈕被按下時需要處理的任務有點區別。具體來講，一個十進制計算器需要10個相似的按鈕，每個按鈕對應一個數字，可以使用下面的函數創建他們：
function digitButton (digit)
return Button{ label = digit,
action = function ()
add_to_display(digit)
end
}
end
這個例子中我們假定Button是一個用來創建新按鈕的工具，label是按鈕的標簽，action是按鈕被按下時調用的回調函數。（實際上是一個閉包，因為他訪問upvalue digit）。digitButton完成任務返回後，局部變數digit超出范圍，回調函數仍然可以被調用並且可以訪問局部變數digit。
閉包在完全不同的上下文中也是很有用途的。因為函數被存儲在普通的變數內我們可以很方便的重定義或者預定義函數。通常當你需要原始函數有一個新的實現時可以重定義函數。例如你可以重定義sin使其接受一個度數而不是弧度作為參數：
oldSin = math.sin
math.sin = function (x)
return oldSin(x*math.pi/180）
end
更清楚的方式：
do
local oldSin = math.sin
local k = math.pi/180
math.sin = function (x)
return oldSin(x*k)
end
end
這樣我們把原始版本放在一個局部變數內，訪問sin的唯一方式是通過新版本的函數。
利用同樣的特徵我們可以創建一個安全的環境（也稱作沙箱，和java里的沙箱一樣），當我們運行一段不信任的代碼（比如我們運行網路伺服器上獲取的代碼）時安全的環境是需要的，比如我們可以使用閉包重定義io庫的open函數來限製程序打開的文件。
do
local oldOpen = io.open
io.open = function (filename,mode)
if access_OK(filename,mode) then
return oldOpen(filename,mode)
else
return nil,access denied
end
end Scheme中的閉包
其他編程的語言主要採用的是閉包的第二種意義（一個與閉包毫不相乾的概念）：閉包也算一種為表示帶有自由變數的過程而用的實現技術。但Scheme的術語「閉包」來自抽象代數。在抽象代數里，一集元素稱為在某個運算（操作）之下封閉，如果將該運算應用於這一集合中的元素，產生出的仍然是該集合里的元素。
用Scheme的序對舉例，為了實現數據抽象，Scheme提供了一種稱為序對的復合結構。這種結構可以通過基本過程cons構造出來。過程cons取兩個參數，返回一個包含這兩個參數作為其成分的復合數據對象。請注意，一個序對也算一個數據對象。進一步說，還可以用cons去構造那種其元素本身就是序對的序對，並繼續這樣做下去。
（define x (cons 1 2)) //構造一個x序對，有1，2組成
（define y (cons 3 4))
(define z (cons x y))
Scheme可以建立元素本身也算序對的序對，這就是表結構得以作為一種表示工具的根本基礎。我們將這種能力稱為cons的閉包性質。一般說，某種組合數據對象的操作滿足閉包性質，那就是說，通過它組合起數據對象得到的結果本身還可以通過同樣的操作再進行組合。閉包性質是任何一種組合功能的威力的關鍵要素，因為它使我們能夠建立起層次性結構，這種結構由一些部分構成，而其中的各個部分又是由它們的部分構成，並且可以如此繼續下去。

⑦ Java 8為什麼需要Lambda表達式

為什麼 Java 需要 Lambda 表達式？
如果忽視註解(Annotations)、泛型(Generics)等特性，自 Java 語言誕生時起，它的變化並不大。Java 一直都致力維護其對象至上的特徵，在使用過 JavaScript 之類的函數式語言之後，Java 如何強調其面向對象的本質，以及源碼層的數據類型如何嚴格變得更加清晰可感。其實，函數對 Java 而言並不重要，在 Java 的世界裡，函數無法獨立存在。

在函數式編程語言中，函數是一等公民，它們可以獨立存在，你可以將其賦值給一個變數，或將他們當做參數傳給其他函數。JavaScript 是最典型的函數式編程語言。點擊此處以及此處可以清楚了解 JavaScript 這種函數式語言的好處。函數式語言提供了一種強大的功能——閉包，相比於傳統的編程方法有很多優勢，閉包是一個可調用的對象，它記錄了一些信息，這些信息來自於創建它的作用域。Java 現在提供的最接近閉包的概念便是 Lambda 表達式，雖然閉包與 Lambda 表達式之間存在顯著差別，但至少 Lambda 表達式是閉包很好的替代者。
在 Steve Yegge 辛辣又幽默的博客文章里，描繪了 Java 世界是如何嚴格地以名詞為中心的，如果你還沒看過，趕緊去讀吧，寫得非常風趣幽默，而且恰如其分地解釋了為什麼 Java 要引進 Lambda 表達式。
Lambda 表達式為 Java 添加了缺失的函數式編程特點，使我們能將函數當做一等公民看待。盡管不完全正確，我們很快就會見識到 Lambda 與閉包的不同之處，但是又無限地接近閉包。在支持一類函數的語言中，Lambda 表達式的類型將是函數。但是，在 Java 中，Lambda 表達式是對象，他們必須依附於一類特別的對象類型——函數式介面(functional interface)。我們會在後文詳細介紹函數式介面。
Mario Fusco 的這篇思路清晰的文章介紹了為什麼 Java 需要 Lambda 表達式。他解釋了為什麼現代編程語言必須包含閉包這類特性。

⑧ Go語言怎麼樣

Go語言是谷歌推出的一種全新的編程語言，可以在不損失應用程序性能的情況下降低代碼的復雜性。谷歌首席軟體工程師羅布派克(Rob Pike)說:我們之所以開發Go，是因為過去10多年間軟體開發的難度令人沮喪。

Go是谷歌2009發布的第二款編程語言。2009年7月份，谷歌曾發布了Simple語言，它是用來開發Android應用的一種BASIC語言.

Go Logo
北京時間2010年1月10日，Go語言摘得了TIOBE公布的2009年年度大獎。該獎項授予在2009年市場份額增長最多的編程語言。

谷歌資深軟體工程師羅布·派克(Rob Pike)表示，"Go讓我體驗到了從未有過的開發效率。"派克表示，和今天的C++或C一樣，Go是一種系統語言。他解釋道，"使用它可以進行快速開發，同時它還是一個真正的編譯語言，我們之所以現在將其開源，原因是我們認為它已經非常有用和強大。"

2007年，谷歌把Go作為一個20%項目開始研發，即讓員工抽出本職工作之外時間的20%， 投入在該項目上。除了派克外，該項目的成員還有其他谷歌工程師也參與研發。

派克表示，編譯後Go代碼的運行速度與C語言非常接近,而且編譯速度非常快，就像在使用一個互動式語言。現有編程語言均未專門對多核處理器進行優化。Go就是谷歌工程師為這類程序編寫的一種語言。它不是針對編程初學者設計的，但學習使用它也不是非常困難。Go支持面向對象，而且具有真正的閉包(closures)和反射 (reflection)等功能。

在學習曲線方面，派克認為Go與Java類似，對於Java開發者來說，應該能夠輕松學會 Go。之所以將Go作為一個開源項目發布，目的是讓開源社區有機會創建更好的工具來使用該語言，例如 Eclipse IDE中的插件。

在谷歌公開發布的所有網路應用中，均沒有使用Go，但是谷歌已經使用該語言開發了幾個內部項目。派克表示，Go是否會對谷歌即將推出的Chrome OS產生影響，還言之尚早,不過Go的確可以和Native Client配合使用。他表示"Go可以讓應用完美的運行在瀏覽器內。"例如，使用Go可以更高效的實現Wave，無論是在前端還是後台。

Go 同時具有兩種編譯器，一種是建立在GCC基礎上的Gccgo，另外一種是分別針對64位x64和32位x86計算機的一套編譯器(6g和8g)。谷歌目前正在研發其對ARM晶元和Android設備的支持。派克表示，"Android手機存在的問題是，我們一直沒有一個數學協處理器。"