senchalabs/connect được TopGit xếp vào nhóm dự án frontend, với 9.9k sao trên GitHub, viết chủ yếu bằng JavaScript. Connect is an extensible HTTP server framework for node using "plugins" known as middleware.
Tóm tắt dựng từ metadata GitHub của chính dự án — chưa có bài review TopGit. Trang sẽ tự động cập nhật khi bài review đầy đủ được xuất bản.
VÌ SAO CHƯA CÓ REVIEW
TopGit viết bài đầy đủ cho repo có nhiều sao nhất và được yêu cầu nhiều nhất. Trang này là snapshot trong thời gian chờ — xem README gốc ở tab READ ME.
Connect is an extensible HTTP server framework for node using "plugins" known as middleware.
var connect = require('connect');
var http = require('http');
var app = connect();
// gzip/deflate outgoing responses
var compression = require('compression');
app.use(compression());
// store session state in browser cookie
var cookieSession = require('cookie-session');
app.use(cookieSession({
keys: ['secret1', 'secret2']
}));
// parse urlencoded request bodies into req.body
var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({extended: false}));
// respond to all requests
app.use(function(req, res){
res.end('Hello from Connect!\n');
});
//create node.js http server and listen on port
http.createServer(app).listen(3000);
Getting Started
Connect is a simple framework to glue together various "middleware" to handle requests.
Install Connect
$ npm install connect
Create an app
The main component is a Connect "app". This will store all the middleware
added and is, itself, a function.
var app = connect();
Use middleware
The core of Connect is "using" middleware. Middleware are added as a "stack"
where incoming requests will execute each middleware one-by-one until a middleware
does not call next() within it.
The .use() method also takes an optional path string that is matched against
the beginning of the incoming request URL. This allows for basic routing.
app.use('/foo', function fooMiddleware(req, res, next) {
// req.url starts with "/foo"
next();
});
app.use('/bar', function barMiddleware(req, res, next) {
// req.url starts with "/bar"
next();
});
Error middleware
There are special cases of "error-handling" middleware. There are middleware
where the function takes exactly 4 arguments. When a middleware passes an error
to next, the app will proceed to look for the error middleware that was declared
after that middleware and invoke it, skipping any error middleware above that
middleware and any non-error middleware below.
// regular middleware
app.use(function (req, res, next) {
// i had an error
next(new Error('boom!'));
});
// error middleware for errors that occurred in middleware
// declared before this
app.use(function onerror(err, req, res, next) {
// an error occurred!
});
Create a server from the app
The last step is to actually use the Connect app in a server. The .listen() method
is a convenience to start a HTTP server (and is identical to the http.Server's listen
method in the version of Node.js you are running).
var server = app.listen(port);
The app itself is really just a function with three arguments, so it can also be handed
to .createServer() in Node.js.
var server = http.createServer(app);
Middleware
These middleware and libraries are officially supported by the Connect/Express team:
body-parser - previous bodyParser, json, and urlencoded. You may also be interested in:
body
co-body
raw-body
compression - previously compress
connect-timeout - previously timeout
cookie-parser - previously cookieParser
cookie-session - previously cookieSession
csurf - previously csrf
errorhandler - previously error-handler
express-session - previously session
method-override - previously method-override
morgan - previously logger
response-time - previously response-time
serve-favicon - previously favicon
serve-index - previously directory
serve-static - previously static
vhost - previously vhost
Most of these are exact ports of their Connect 2.x equivalents. The primary exception is cookie-session.
Some middleware previously included with Connect are no longer supported by the Connect/Express team, are replaced by an alternative module, or should be superseded by a better module. Use one of these alternatives instead:
cookieParser
cookies and keygrip
limit
raw-body
multipart
connect-multiparty
connect-busboy
query
qs
staticCache
st
connect-static
Checkout http-framework for many other compatible middleware!
API
The Connect API is very minimalist, enough to create an app and add a chain
of middleware.
When the connect module is required, a function is returned that will construct
a new app when called.
// require module
var connect = require('connect')
// create app
var app = connect()
app(req, res[, next])
The app itself is a function. This is just an alias to app.handle.
app.handle(req, res[, out])
Calling the function will run the middleware stack against the given Node.js
http request (req) and response (res) objects. An optional function out
can be provided that will be called if the request (or error) was not handled
by the middleware stack.
app.listen([...])
Start the app listening for requests. This method will internally create a Node.js
HTTP server and call .listen() on it.
This is an alias to the server.listen() method in the version of Node.js running,
so consult the Node.js documentation for all the different variations. The most
common signature is app.listen(port).
app.use(fn)
Use a function on the app, where the function represents a middleware. The function
will be invoked for every request in the order that app.use is called. The function
is called with three arguments:
app.use(function (req, res, next) {
// req is the Node.js http request object
// res is the Node.js http response object
// next is a function to call to invoke the next middleware
})
In addition to a plan function, the fn argument can also be a Node.js HTTP server
instance or another Connect app instance.
app.use(route, fn)
Use a function on the app, where the function represents a middleware. The function
will be invoked for every request in which the URL (req.url property) starts with
the given route string in the order that app.use is called. The function is
called with three arguments:
app.use('/foo', function (req, res, next) {
// req is the Node.js http request object
// res is the Node.js http response object
// next is a function to call to invoke the next middleware
})
In addition to a plan function, the fn argument can also be a Node.js HTTP server
instance or another Connect app instance.
The route is always terminated at a path separator (/) or a dot (.) character.
This means the given routes /foo/ and /foo are the same and both will match requests
with the URLs /foo, /foo/, /foo/bar, and /foo.bar, but not match a request with
the URL /foobar.
The route is matched in a case-insensitive manner.
In order to make middleware easier to write to be agnostic of the route, when the
fn is invoked, the req.url will be altered to remove the route part (and the
original will be available as req.originalUrl). For example, if fn is used at the
route /foo, the request for /foo/bar will invoke fn with req.url === '/bar'
and req.originalUrl === '/foo/bar'.
Running Tests
npm install
npm test
People
The Connect project would not be the same without all the people involved.
The original author of Connect is TJ Holowaychuk
The current lead maintainer is Douglas Christopher Wilson
senchalabs/connect thuộc nhóm Frontend trên TopGit, cùng 2 topic GitHub. Trang Trending và Topics liệt kê các repo cùng số sao và cùng ngôn ngữ để so sánh.
Đọc thêm về senchalabs/connect ở đâu?
Trang TopGit này là một snapshot — tab "Readme" hiển thị nguyên văn README của repo (đã bỏ link, giữ ảnh). Repo GitHub ở github.com/senchalabs/connect là nguồn chính thức.
senchalabs/connect có bao nhiêu sao?
senchalabs/connect có 9.9k sao GitHub — tải lại trang để xem số mới nhất, hoặc xem trực tiếp github.com/senchalabs/connect. TopGit phản chiếu số sao của GitHub nhưng không cam kết đến từng phút.
senchalabs/connect có phải mã nguồn mở không?
Có — senchalabs/connect phát hành theo license MIT, nghĩa là mã nguồn mở để đọc, fork và (tùy license) tái sử dụng. Mã: github.com/senchalabs/connect.
senchalabs/connect còn đang phát triển không?
Commit gần nhất trên senchalabs/connect là 2.1 năm trước (theo timestamp GitHub). Repo có 1.1k fork — một chỉ báo về mức độ quan tâm của cộng đồng.
senchalabs/connect dùng license gì?
senchalabs/connect phát hành theo license MIT. Nên mở file LICENSE trên GitHub để xác nhận — license metadata đôi khi lệch với thực tế dự án.
senchalabs/connect là gì?
senchalabs/connect (senchalabs/connect) là dự án JavaScript trên GitHub. Theo mô tả gốc: Connect is an extensible HTTP server framework for node using "plugins" known as middleware.
senchalabs/connect viết bằng ngôn ngữ gì?
senchalabs/connect chủ yếu viết bằng JavaScript. Trường "language" của GitHub dựa trên phần lớn byte ở nhánh mặc định.
Đọc đầy đủ README ở tab phía trên.
Muốn nghe thêm một ý kiến về connect?
Hỏi một AI đọc được trang này — một cú bấm là có ngay nhận định về connect.