nodejs編程

前端開發需要學什麼啊?

1、前端開發需要學習的內容包括PC網站布局、HTML5＋CSS3基礎項目、webapp頁面布局等。學習web前端開發，web開發工具有frontpage，可以使用word讓人輕松學習frontpage，另一個常見的是Dreamweaver，這兩個是最常用的HTML網頁製作工具。

2、需要學習如下內容：HTML語言掌握HTML是網頁的核心，是一種製作萬維網頁面的標准語言，是萬維網瀏覽器使用的一種語言，它消除了不同計算機之間信息交流的障礙。

3、響應式設計顯然是目前web前端開發領域的主要趨勢之一，響應式網站設計是一種網路頁面設計布局，其理念是：集中創建頁面的圖片排版大小，可以智能地根據用戶行為以及使用的設備環境進行相對應的布局。

4、web前端開發中需要掌握的技術：學習HTML，這是最簡單，最基本的是要掌握div，formtable、Ulli、P、跨度、字體這些標簽，這些都是最常用的，尤其是DIV和表格，DIV，表也可以用於布局，但不靈活，和用於基本表處理數據。

5、前端開發需要學HTML、CSS和JavaScript。這是做前必須要學的東西。

1、阮一峰，70後，英文名Frank。他原是上海財經大學世界經濟博士研究生。主要研究宏觀金融、貨幣政策與美國經濟。於2008年6月獲得博士學位。目前在上海一所當地大學（上海金融學院國際經貿學院）任教。

2、阮一峰是個牛人，他的博克非常值得讀。根據東升做的人肉搜索，他原是上海財經大學世界經濟博士研究生。主要研究宏觀金融、貨幣政策與美國經濟。今年(2008年)6月獲得博士學位。恭賀！不知道他現在哪裡高就。

3、作為linux以及git的主要創造者，Linus的編程水平是毋庸置疑的。但是Linux的主要編程語言是C，從這個意義上說，他的C++可能不太好。

❷ 如何編寫 Node.js 擴展

一、編寫Node.js原生擴展

Node.js是一個強大的平台，理想狀態下一切都都可以用javascript寫成。然而，你可能還會用到許多遺留的庫和系統，這樣的話使用c++編寫Node.JS擴展會是一個不錯的注意。

以下所有例子的源代碼可在node擴展示例中找到 。

編寫Node.js C + +擴展很大程度上就像是寫V8的擴展； Node.js增加了一些介面，但大部分時間你都是在使原始的V8數據類型和方法，為了理解以下的代碼，你必須首先閱讀V8引擎嵌入指南。

Javascript版本的Hello World

在講解C++版本的例子之前，先讓我們來看看在Node.js中用Javascript編寫的等價模塊是什麼樣子。這是一個最簡單的Hello World，也不是通過HTTP，但它展示了node模塊的結構，而其介面也和大多數C++擴展要提供的介面差不多：

HelloWorldJs = function() {

this.m_count = 0;

};

HelloWorldJs.prototype.hello = function()

{

this.m_count++;

return 「Hello World」;

};

exports.HelloWorldJs = HelloWorldJs;

正如你所看到的，它使用prototype為HelloWorldJs類創建了一個新的方法。請注意，上述代碼通過將HelloWorldJS添加到exports變數來暴露構造函數。

要在其他地方使用該模塊，請使用如下代碼：

var helloworld = require(『helloworld_js』);

var hi = new helloworld.HelloWorldJs();

console.log(hi.hello()); // prints 「Hello World」 to stdout

C++版本的Hello World

要開始編寫C++擴展，首先要能夠編譯Node.js（請注意，我們使用的是Node.js 2.0版本）。本文所講內容應該兼容所有未來的0.2.x版本。一旦編譯安裝完node，編譯模塊就不在需要額外的東西了。

完整的源代碼可以在這里找到 。在使用Node.js或V8之前，我們需要包括相關的頭文件：

#include <v8.h>

#include <node.h>

using namespace node;

using namespace v8;

在本例子中我直接使用了V8和node的命名空間，使代碼更易於閱讀。雖然這種用法和谷歌的自己的C++編程風格指南相悖，但由於你需要不停的使用V8定義的類型，所以目前為止的大多數node的擴展仍然使用了V8的命名空間。

接下來，聲明HelloWorld類。它繼承自node::ObjectWrap類 ，這個類提供了幾個如引用計數、在V8內部傳遞contex等的實用功能。一般來說，所有對象應該繼承ObjectWrap：

class HelloWorld: ObjectWrap

{

private:

int m_count;

public:

聲明類之後，我們定義了一個靜態成員函數，用來初始化對象並將其導入Node.js提供的target對象中。設個函數基本上是告訴Node.js和V8你的類是如何創建的，和它將包含什麼方法：

static Persistent<FunctionTemplate> s_ct;

static void Init(Handle<Object> target)

{

HandleScope scope;

Local<FunctionTemplate> t = FunctionTemplate::New(New);

s_ct = Persistent<FunctionTemplate>::New(t);

s_ct->InstanceTemplate()->SetInternalFieldCount(1);

s_ct->SetClassName(String::NewSymbol(「HelloWorld」));

NODE_SET_PROTOTYPE_METHOD(s_ct, 「hello」, Hello);

target->Set(String::NewSymbol(「HelloWorld」),

s_ct->GetFunction());

}

在上面這個函數中target參數將是模塊對象，即你的擴展將要載入的地方。（譯著：這個函數將你的對象及其方法連接到
這個模塊對象，以便外界可以訪問）首先我們為New方法創建一個FunctionTemplate，將於稍後解釋。我們還為該對象添加一個內部欄位，並命
名為HelloWorld。然後使用NODE_SET_PROTOTYPE_METHOD宏將hello方法綁定到該對象。最後，一旦我們建立好這個函數模板後，將他分配給target對象的HelloWorld屬性，將類暴露給用戶。

接下來的部分是一個標準的C++構造函數：

HelloWorld() :

m_count(0)

{

}

~HelloWorld()

{

}

接下來，在::New 方法中V8引擎將調用這個簡單的C++構造函數：

static Handle<Value> New(const Arguments& args)

{

HandleScope scope;

HelloWorld* hw = new HelloWorld();

hw->Wrap(args.This());

return args.This();

}

此段代碼相當於上面Javascript代碼中使用的構造函數。它調用new HelloWorld
創造了一個普通的C++對象，然後調用從ObjectWrap繼承的Wrap方法，
它將一個C++HelloWorld類的引用保存到args.This()的值中。在包裝完成後返回args.This()，整個函數的行為和
javascript中的new運算符類似，返回this指向的對象。

現在我們已經建立了對象，下面介紹在Init函數中被綁定到hello的函數：

static Handle<Value> Hello(const Arguments& args)

{

HandleScope scope;

HelloWorld* hw = ObjectWrap::Unwrap<HelloWorld>(args.This());

hw->m_count++;

Local<String> result = String::New(「Hello World」);

return scope.Close(result);

}

函數中首先使用ObjectWrap模板的方法提取出指向HelloWorld類的指針，然後和javascript版本的HelloWorld一樣遞增計數器。我們新建一個內容為「HelloWorld」的v8字元串對象，然後在關閉本地作用域的時候返回這個字元串。

上面的代碼實際上只是針對v8的介面，最終我們還需要讓Node.js知道如何動態載入我們的代碼。為了使Node.js的擴展可以在執行時從動態鏈接庫載入，需要有一個dlsym函數可以識別的符號，所以執行編寫如下代碼：

extern 「C」 {

static void init (Handle<Object> target)

{

HelloWorld::Init(target);

}

NODE_MODULE(helloworld, init);

}

由於c++的符號命名規則，我們使用extern
C，以便該符號可以被dysym識別。init方法是Node.js載入模塊後第一個調用的函數，如果你有多個類型，請全部在這里初始化。
NODE_MODULE宏用來填充一個用於存儲模塊信息的結構體，存儲的信息如模塊使用的API版本。這些信息可以用來防止未來因API不兼容導致的崩
潰。

到此，我們已經完成了一個可用的C++ NodeJS擴展。

Node.js也提供了一個用於構建模塊的簡單工具:
node-waf首先編寫一個包含擴展編譯方法的wscript文件，然後執行node-waf configure &&
node-waf build完成模塊的編譯和鏈接工作。對於這個helloworld的例子來說，wscript內容如下：

def set_options(opt):

opt.tool_options(「compiler_cxx」)

def configure(conf):

conf.check_tool(「compiler_cxx」)

conf.check_tool(「node_addon」)

def build(bld):

obj = bld.new_task_gen(「cxx」, 「shlib」, 「node_addon」)

obj.cxxflags = [「-g」, 「-D_FILE_OFFSET_BITS=64」, 「-D_LARGEFILE_SOURCE」, 「-Wall」]

obj.target = 「helloworld」

obj.source = 「helloworld.cc」

非同步IO的HelloWorld

對於實際的應用來說，HelloWorld的示例太過簡單了一些，Node.js主要的優勢是提供非同步IO。
Node.js內部通過libeio將會產生阻塞的操作全都放入線程池中執行。如果需要和遺留的c庫交互，通常需要使用非同步IO來為javascript
代碼提供回調介面。

通常的模式是提供一個回調，在非同步操作完成時被調用——你可以在整個Node.js的API中看到這種模式。
Node.js的filesystem模塊提供了一個很好的例子，其中大多數的函數都在操作完成後通過調用回調函數來傳遞數據。和許多傳統的GUI框架一
樣，Node.js只在主線程中執行JavaScript，因此主線程以外的任何操作都不應該直接和V8或Javascript交互。

同樣helloworld_eio.cc源代碼在GitHub上。我只強調和原來HelloWorld之間的差異，其中大部分代碼保持不變，變化集中在Hello方法中：

static Handle<Value> Hello(const Arguments& args)

{

HandleScope scope;

REQ_FUN_ARG(0, cb);

HelloWorldEio* hw = ObjectWrap::Unwrap<HelloWorldEio>(args.This());

在Hello函數的入口處 ，我們使用宏從參數列表的第一個位置獲取回調函數，在下一節中將詳細介紹。然後，我們使用相同的Unwarp方法提取指向類對象的指針。

hello_baton_t *baton = new hello_baton_t();

baton->hw = hw;

baton->increment_by = 2;

baton->sleep_for = 1;

baton->cb = Persistent<Function>::New(cb);

這里我們創建一個baton結構，並將各種參數保存在裡面。請注意，我們為回調函數創建了一個永久引用，因為我們想要在超出當前函數作用域的地方使用它。如果不這么做，在本函數結束後將無法再調用回調函數。

hw->Ref();

eio_custom(EIO_Hello, EIO_PRI_DEFAULT, EIO_AfterHello, baton);

ev_ref(EV_DEFAULT_UC);

return Undefined();

}

如下代碼是真正的重點。首先，我們增加HelloWorld對象的引用計數，這樣在其他線程執行的時候他就不會被回收。
函數eio_custom接受兩個函數指針作為參數。EIO_Hello函數將在線程池中執行，然後EIO_AfterHello函數將回到在「主線程」
中執行。我們的baton結構也被傳遞進各函數，這些函數可以使用baton結構中的數據完成相關的操作。同時，我們也增加event
loop的引用。這很重要，因為如果event
loop無事可做，Node.js就會退出。最終，函數返回Undefined，因為真正的工作將在其他線程中完成。

static int EIO_Hello(eio_req *req)

{

hello_baton_t *baton = static_cast<hello_baton_t *>(req->data);

sleep(baton->sleep_for);

baton->hw->m_count += baton->increment_by;

return 0;

}

這個回調函數將在libeio管理的線程中執行。首先，解析出baton結構，這樣可以訪問之前設置的各種參數。然後
sheep
baton->sleep_for秒，這么做是安全的，因為這個函數運行在獨立的線程中並不會阻塞主線程中javascript的執行。然後我們的
增計數器，在實際的系統中，這些操作通常需要使用Lock/Mutex進行同步。

當上述方法返回後，libeio將會通知主線程它需要在主線成上執行代碼，此時EIO_AfterHello將會被調用。

static int EIO_AfterHello(eio_req *req)

{

HandleScope scope;

hello_baton_t *baton = static_cast<hello_baton_t *>(req->data);

ev_unref(EV_DEFAULT_UC);

baton->hw->Unref();

進度此函數時，我們提取出baton結構，刪除事件循環的引用，並減少HelloWorld對象的引用。

Local<Value> argv[1];

argv[0] = String::New(「Hello World」);

TryCatch try_catch;

baton->cb->Call(Context::GetCurrent()->Global(), 1, argv);

if (try_catch.HasCaught()) {

FatalException(try_catch);

}

新建要傳遞給回調函數的字元串參數，並放入字元串數組中。然後我們調用回調傳遞一個參數，並檢測可能拋出的異常。

baton->cb.Dispose();

delete baton;

return 0;

}

在執行過回調之後，應該銷毀持久引用，然後刪除之前創建的baton結構。

最後，你可以使用如下形式在Javascript中使用該模塊：

var helloeio = require(『./helloworld_eio』);

hi = new helloeio.HelloWorldEio();

hi.hello(function(data){

console.log(data);

});

參數傳遞與解析

除了HelloWorld之外，你還需要理解最後一個問題：參數的處理。在helloWorld EIO例子中，我們使用一個REQ_FUN_ARG宏，然我們看看這個宏到底都做些什麼。

#define REQ_FUN_ARG(I, VAR) \

if (args.Length() <= (I) || !args[I]->IsFunction()) \

return ThrowException(Exception::TypeError( \

String::New(「Argument 」 #I 」 must be a function」))); \

Local<Function> VAR = Local<Function>::Cast(args[I]);

就像Javascript中的argument變數，v8使用數組傳遞所有的參數。由於沒有嚴格的類型限制，所以傳遞給函數的參數數目可能和期待的不同。為了對用戶友好，使用如下的宏檢測一下參數數組的長度並判斷參數是否是正確的類型。如果傳遞了錯誤的參數類型，該宏將會拋出TypeError異常。為簡化參數的解析，目前為止大多數的Node.js擴展都有一些本地作用域內的宏，用於特定類型參數的檢測。

二、揭秘node.js事件

要使用NodeJS，你需要知道一個重要的東西：事件（events）。Node中有很多對象都可以觸發事件，Node
的文檔中有很多示例。但文檔也許並不能清晰的講解如何編寫自定義事件以及監聽函數。對於一些簡單的程序你可以不使用自定義事件，但這樣很難應對復雜的應
用。那麼如何編寫自定義事件？首先需要了解的是在node.js中的』events』模塊。

快速概覽

要訪問此模塊，只需使用如下語句：

require(『events』)
requires(『events』).EventEmitter

特別說明，node中所有能觸發事件的對象基本上都是後者的實例。讓我們創建一個簡單的演示程序Dummy：

mmy.js

view plain to clipboardprint?

// basic imports
var events = require(『events』);

// for us to do a require later
mole.exports = Dummy;

function Dummy() {
events.EventEmitter.call(this);
}
10.

11. // inherit events.EventEmitter

12. Dummy.super_ = events.EventEmitter;

13. Dummy.prototype = Object.create(events.EventEmitter.prototype, {

14. constructor: {
15. value: Dummy,
16. enumerable: false
17. }

18. });

// basic imports

var events = require(『events』);

// for us to do a require later

mole.exports = Dummy;

function Dummy() {

events.EventEmitter.call(this);

}

// inherit events.EventEmitter

Dummy.super_ = events.EventEmitter;

Dummy.prototype = Object.create(events.EventEmitter.prototype, {

constructor: {

value: Dummy,

enumerable: false

}

});

上述代碼中重點展示如何使用EventEmitter擴充對象，並從中繼承所有的原型對象，方法…等等。

現在，我們假設Dummy有一個cooking()的方法，一旦把食物做熟之後它會觸發』cooked』事件，並調用一個名為』eat』的回調函數。

mmy-cooking.js

view plain to clipboardprint?

Dummy.prototype.cooking = function(chicken) {
var self = this;
self.chicken = chicken;
self.cook = cook(); // assume mmy function that』ll do the cooking
self.cook(chicken, function(cooked_chicken) {
self.chicken = cooked_chicken;
self.emit(『cooked』, self.chicken);
});

10. return self;

11. }

Dummy.prototype.cooking = function(chicken) {

var self = this;

self.chicken = chicken;

self.cook = cook(); // assume mmy function that』ll do the cooking

self.cook(chicken, function(cooked_chicken) {

self.chicken = cooked_chicken;

self.emit(『cooked』, self.chicken);

});

return self;

}

❸ Node.js 與 python 作為後端服務的編程語言各有什麼優劣

一. NodeJS的特點
我們先來看看NodeJS官網上的介紹：
Node.js is a platform built on Chrome』s JavaScript runtime for easily building fast, scalable network applications. node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.
其特點為：
1. 它是一個Javascript運行環境
2. 依賴於Chrome V8引擎進行代碼解釋
3. 事件驅動
4. 非阻塞I/O
5. 輕量、可伸縮，適於實時數據交互應用
6. 單進程，單線程
二. NodeJS帶來的對系統瓶頸的解決方案
它的出現確實能為我們解決現實當中系統瓶頸提供了新的思路和方案，下面我們看看它能解決什麼問題。
1. 並發連接
舉個例子，想像一個場景，我們在銀行排隊辦理業務，我們看看下面兩個模型。
（1）系統線程模型：
這種模型的問題顯而易見，服務端只有一個線程，並發請求（用戶）到達只能處理一個，其餘的要先等待，這就是阻塞，正在享受服務的請求阻塞後面的請求了。
（2）多線程、線程池模型：
這個模型已經比上一個有所進步，它調節服務端線程的數量來提高對並發請求的接收和響應，但並發量高的時候，請求仍然需要等待，它有個更嚴重的問題。到代碼層面上來講，我們看看客戶端請求與服務端通訊的過程：
服務端與客戶端每建立一個連接，都要為這個連接分配一套配套的資源，主要體現為系統內存資源，以PHP為例，維護一個連接可能需要20M的內存。這就是為什麼一般並發量一大，就需要多開伺服器。
那麼NodeJS是怎麼解決這個問題的呢？我們來看另外一個模型，想像一下我們在快餐店點餐吃飯的場景。
（3）非同步、事件驅動模型
我們同樣是要發起請求，等待伺服器端響應；但是與銀行例子不同的是，這次我們點完餐後拿到了一個號碼，拿到號碼，我們往往會在位置上等待，而在我們後面的請求會繼續得到處理，同樣是拿了一個號碼然後到一旁等待，接待員能一直進行處理。
等到飯菜做號了，會喊號碼，我們拿到了自己的飯菜，進行後續的處理（吃飯）。這個喊號碼的動作在NodeJS中叫做回調（Callback），能在事件（燒菜，I/O）處理完成後繼續執行後面的邏輯（吃飯），這體現了NodeJS的顯著特點，非同步機制、事件驅動整個過程沒有阻塞新用戶的連接（點餐），也不需要維護已經點餐的用戶與廚師的連接。
基於這樣的機制，理論上陸續有用戶請求連接，NodeJS都可以進行響應，因此NodeJS能支持比Java、PHP程序更高的並發量雖然維護事件隊列也需要成本，再由於NodeJS是單線程，事件隊列越長，得到響應的時間就越長，並發量上去還是會力不從心。
總結一下NodeJS是怎麼解決並發連接這個問題的：更改連接到伺服器的方式，每個連接發射（emit）一個在NodeJS引擎進程中運行的事件（Event），放進事件隊列當中，而不是為每個連接生成一個新的OS線程（並為其分配一些配套內存）。
2. I/O阻塞
NodeJS解決的另外一個問題是I/O阻塞，看看這樣的業務場景：需要從多個數據源拉取數據，然後進行處理。
（1）串列獲取數據，這是我們一般的解決方案，以PHP為例
假如獲取profile和timeline操作各需要1S，那麼串列獲取就需要2S。
（2）NodeJS非阻塞I/O，發射/監聽事件來控制執行過程
NodeJS遇到I/O事件會創建一個線程去執行，然後主線程會繼續往下執行的，因此，拿profile的動作觸發一個I/O事件，馬上就會執行拿timeline的動作，兩個動作並行執行，假如各需要1S，那麼總的時間也就是1S。它們的I/O操作執行完成後，發射一個事件，profile和timeline，事件代理接收後繼續往下執行後面的邏輯，這就是NodeJS非阻塞I/O的特點。
總結一下：Java、PHP也有辦法實現並行請求（子線程），但NodeJS通過回調函數（Callback）和非同步機制會做得很自然。
三. NodeJS的優缺點
優點：1. 高並發（最重要的優點）
2. 適合I/O密集型應用
缺點：1. 不適合CPU密集型應用；CPU密集型應用給Node帶來的挑戰主要是：由於JavaScript單線程的原因，如果有長時間運行的計算（比如大循環），將會導致CPU時間片不能釋放，使得後續I/O無法發起；
解決方案：分解大型運算任務為多個小任務，使得運算能夠適時釋放，不阻塞I/O調用的發起；
2. 只支持單核CPU，不能充分利用CPU
3. 可靠性低，一旦代碼某個環節崩潰，整個系統都崩潰
原因：單進程，單線程
解決方案：（1）Nnigx反向代理，負載均衡，開多個進程，綁定多個埠；
（2）開多個進程監聽同一個埠，使用cluster模塊；
4. 開源組件庫質量參差不齊，更新快，向下不兼容
5. Debug不方便，錯誤沒有stack trace
四. 適合NodeJS的場景
1. RESTful API
這是NodeJS最理想的應用場景，可以處理數萬條連接，本身沒有太多的邏輯，只需要請求API，組織數據進行返回即可。它本質上只是從某個資料庫中查找一些值並將它們組成一個響應。由於響應是少量文本，入站請求也是少量的文本，因此流量不高，一台機器甚至也可以處理最繁忙的公司的API需求。
2. 統一Web應用的UI層
目前MVC的架構，在某種意義上來說，Web開發有兩個UI層，一個是在瀏覽器裡面我們最終看到的，另一個在server端，負責生成和拼接頁面。
不討論這種架構是好是壞，但是有另外一種實踐，面向服務的架構，更好的做前後端的依賴分離。如果所有的關鍵業務邏輯都封裝成REST調用，就意味著在上層只需要考慮如何用這些REST介面構建具體的應用。那些後端程序員們根本不操心具體數據是如何從一個頁面傳遞到另一個頁面的，他們也不用管用戶數據更新是通過Ajax非同步獲取的還是通過刷新頁面。
3. 大量Ajax請求的應用
例如個性化應用，每個用戶看到的頁面都不一樣，緩存失效，需要在頁面載入的時候發起Ajax請求，NodeJS能響應大量的並發請求。總而言之，NodeJS適合運用在高並發、I/O密集、少量業務邏輯的場景。
Python的優缺點
優點
簡單————Python是一種代表簡單主義思想的語言。閱讀一個良好的Python程序就感覺像是在讀英語一樣，盡管這個英語的要求非常嚴格！Python的這種偽代碼本質是它最大的優點之一。它使你能夠專注於解決問題而不是去搞明白語言本身。
易學————就如同你即將看到的一樣，Python極其容易上手。前面已經提到了，Python有極其簡單的語法。
免費、開源————Python是FLOSS（自由/開放源碼軟體）之一。簡單地說，你可以自由地發布這個軟體的拷貝、閱讀它的源代碼、對它做改動、把它的一部分用於新的自由軟體中。FLOSS是基於一個團體分享知識的概念。這是為什麼Python如此優秀的原因之一——它是由一群希望看到一個更加優秀的Python的人創造並經常改進著的。
高層語言————當你用Python語言編寫程序的時候，你無需考慮諸如如何管理你的程序使用的內存一類的底層細節。
可移植性————由於它的開源本質，Python已經被移植在許多平台上（經過改動使它能夠工作在不同平台上）。如果你小心地避免使用依賴於系統的特性，那麼你的所有Python程序無需修改就可以在下述任何平台上面運行。這些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE甚至還有PocketPC、Symbian以及Google基於linux開發的Android平台！
解釋性————這一點需要一些解釋。一個用編譯性語言比如C或C++寫的程序可以從源文件（即C或C++語言）轉換到一個你的計算機使用的語言（二進制代碼，即0和1）。這個過程通過編譯器和不同的標記、選項完成。當你運行你的程序的時候，連接/轉載器軟體把你的程序從硬碟復制到內存中並且運行。而Python語言寫的程序不需要編譯成二進制代碼。你可以直接從源代碼 運行 程序。在計算機內部，Python解釋器把源代碼轉換成稱為位元組碼的中間形式，然後再把它翻譯成計算機使用的機器語言並運行。事實上，由於你不再需要擔心如何編譯程序，如何確保連接轉載正確的庫等等，所有這一切使得使用Python更加簡單。由於你只需要把你的Python程序拷貝到另外一台計算機上，它就可以工作了，這也使得你的Python程序更加易於移植。
面向對象————Python既支持面向過程的編程也支持面向對象的編程。在「面向過程」的語言中，程序是由過程或僅僅是可重用代碼的函數構建起來的。在「面向對象」的語言中，程序是由數據和功能組合而成的對象構建起來的。與其他主要的語言如C++和Java相比，Python以一種非常強大又簡單的方式實現面向對象編程。
可擴展性————如果你需要你的一段關鍵代碼運行得更快或者希望某些演算法不公開，你可以把你的部分程序用C或C++編寫，然後在你的Python程序中使用它們。
可嵌入性————你可以把Python嵌入你的C/C++程序，從而向你的程序用戶提供腳本功能。
豐富的庫————Python標准庫確實很龐大。它可以幫助你處理各種工作，包括正則表達式、文檔生成、單元測試、線程、資料庫、網頁瀏覽器、CGI、FTP、電子郵件、XML、XML-RPC、HTML、WAV文件、密碼系統、GUI（圖形用戶界面）、Tk和其他與系統有關的操作。記住，只要安裝了Python，所有這些功能都是可用的。這被稱作Python的「功能齊全」理念。除了標准庫以外，還有許多其他高質量的庫，如wxPython、Twisted和Python圖像庫等等。
概括————Python確實是一種十分精彩又強大的語言。它合理地結合了高性能與使得編寫程序簡單有趣的特色。
規范的代碼————Python採用強制縮進的方式使得代碼具有極佳的可讀性。
缺點
強制縮進
這也許不應該被稱為局限，但是它用縮進來區分語句關系的方式還是給很多初學者帶來了困惑。即便是很有經驗的Python程序員，也可能陷入陷阱當中。最常見的情況是tab和空格的混用會導致錯誤，而這是用肉眼無法分別的。
單行語句和命令行輸出問題
很多時候不能將程序連寫成一行，如import sys;for i in sys.path:print i。而perl和awk就無此限制，可以較為方便的在shell下完成簡單程序，不需要如Python一樣，必須將程序寫入一個.py文件。（對很多用戶而言這也不算是限制）
NO.1 運行速度，有速度要求的話，用C++改寫關鍵部分吧。
NO.2 國內市場較小（國內以python來做主要開發的，目前只有一些 web2.0公司）。但時間推移，目前很多國內軟體公司，尤其是游戲公司，也開始規模使用他。
No.3 中文資料匱乏（好的python中文資料屈指可數）。托社區的福，有幾本優秀的教材已經被翻譯了，但入門級教材多，高級內容還是只能看英語版。
NO.4 構架選擇太多（沒有像C#這樣的官方.net構架，也沒有像ruby由於歷史較短，構架開發的相對集中。Ruby on Rails 構架開發中小型web程序天下無敵）。不過這也從另一個側面說明，python比較優秀，吸引的人才多，項目也多。

❹ Nodejs編程md5怎麼計算

文件：
var filename = process.argv[2];
var crypto = require('crypto');
var fs = require('fs');

var md5sum = crypto.createHash('md5');

var s = fs.ReadStream(filename);
s.on('data', function(d) {
md5sum.update(d);
});

s.on('end', function() {
var d = md5sum.digest('hex');
console.log(d + ' ' + filename);
});
字串：
var crypto = require('crypto');
var hash = crypto.createHash('md5').update('AAA').digest("hex");
console.log(hash);