Luvref

簡介 luv luv-intro uv

local uv = vim.uv
local server = uv.new_tcp()
server:bind("127.0.0.1", 1337)
server:listen(128, function (err)
  assert(not err, err)
  local client = uv.new_tcp()
  server:accept(client)
  client:read_start(function (err, chunk)
    assert(not err, err)
    if chunk then
      client:write(chunk)
    else
      client:shutdown()
      client:close()
    end
  end)
end)
print("TCP server listening at 127.0.0.1 port 1337")
uv.run() -- an explicit run call is necessary outside of luvit

目錄 luv-contents

錯誤處理 luv-error-handling

版本檢查 luv-version-checking

uv_loop_t — 事件迴圈 luv-event-loop uv_loop_t

uv.loop_configure("block_signal", "sigprof")

-- Example usage of uv.walk to close all handles that
-- aren't already closing.
uv.walk(function (handle)
  if not handle:is_closing() then
    handle:close()
  end
end)

uv_req_t — 基本請求 luv-base-request uv_req_t

uv_handle_t — 基本控制代碼 luv-base-handle uv_handle_t

參考計數 luv-reference-counting

uv_timer_t — 定時器 handle luv-timer-handle uv_timer_t

-- Creating a simple setTimeout wrapper
local function setTimeout(timeout, callback)
  local timer = uv.new_timer()
  timer:start(timeout, 0, function ()
    timer:stop()
    timer:close()
    callback()
  end)
  return timer
end
-- Creating a simple setInterval wrapper
local function setInterval(interval, callback)
  local timer = uv.new_timer()
  timer:start(interval, interval, function ()
    callback()
  end)
  return timer
end
-- And clearInterval
local function clearInterval(timer)
  timer:stop()
  timer:close()
end

uv_prepare_t — 準備 handle luv-prepare-handle uv_prepare_t

local prepare = uv.new_prepare()
prepare:start(function()
  print("Before I/O polling")
end)

uv_check_t — 檢查 handle luv-check-handle uv_check_t

local check = uv.new_check()
check:start(function()
  print("After I/O polling")
end)

uv_idle_t — 閒置 handle luv-idle-handle uv_idle_t

local idle = uv.new_idle()
idle:start(function()
  print("Before I/O polling, no blocking")
end)

uv_async_t — 非同步 handle luv-async-handle uv_async_t

local async
async = uv.new_async(function()
  print("async operation ran")
  async:close()
end)
async:send()

uv_poll_t — 輪詢 handle luv-poll-handle uv_poll_t

uv_signal_t — 信號處理 luv-signal-handle uv_signal_t

-- Create a new signal handler
local signal = uv.new_signal()
-- Define a handler function
uv.signal_start(signal, "sigint", function(signal)
  print("got " .. signal .. ", shutting down")
  os.exit(1)
end)

uv_process_t — 程序處理 luv-process-handle uv_process_t

local stdin = uv.new_pipe()
local stdout = uv.new_pipe()
local stderr = uv.new_pipe()
print("stdin", stdin)
print("stdout", stdout)
print("stderr", stderr)
local handle, pid = uv.spawn("cat", {
  stdio = {stdin, stdout, stderr}
}, function(code, signal) -- on exit
  print("exit code", code)
  print("exit signal", signal)
end)
print("process opened", handle, pid)
uv.read_start(stdout, function(err, data)
  assert(not err, err)
  if data then
    print("stdout chunk", stdout, data)
  else
    print("stdout end", stdout)
  end
end)
uv.read_start(stderr, function(err, data)
  assert(not err, err)
  if data then
    print("stderr chunk", stderr, data)
  else
    print("stderr end", stderr)
  end
end)
uv.write(stdin, "Hello World")
uv.shutdown(stdin, function()
  print("stdin shutdown", stdin)
  uv.close(handle, function()
    print("process closed", handle, pid)
  end)
end)

uv_stream_t — 串流 handle luv-stream-handle uv_stream_t

server:listen(128, function (err)
  local client = uv.new_tcp()
  server:accept(client)
end)

stream:read_start(function (err, chunk)
  if err then
    -- handle read error
  elseif chunk then
    -- handle data
  else
    -- handle disconnect
  end
end)

uv_tcp_t — TCP 控制代碼 luv-tcp-handle uv_tcp_t

local client = uv.new_tcp()
client:connect("127.0.0.1", 8080, function (err)
  -- check error and carry on.
end)

-- Simple read/write with tcp
local fds = uv.socketpair(nil, nil, {nonblock=true}, {nonblock=true})
local sock1 = uv.new_tcp()
sock1:open(fds[1])
local sock2 = uv.new_tcp()
sock2:open(fds[2])
sock1:write("hello")
sock2:read_start(function(err, chunk)
  assert(not err, err)
  print(chunk)
end)

uv_pipe_t — 管道控制代碼 luv-pipe-handle uv_pipe_t

local pipe = uv.new_pipe(false)
pipe:bind('/tmp/sock.test')
pipe:listen(128, function()
  local client = uv.new_pipe(false)
  pipe:accept(client)
  client:write("hello!\n")
  client:close()
end)

-- Simple read/write with pipe_open
local fds = uv.pipe({nonblock=true}, {nonblock=true})
local read_pipe = uv.new_pipe()
read_pipe:open(fds.read)
local write_pipe = uv.new_pipe()
write_pipe:open(fds.write)
write_pipe:write("hello")
read_pipe:read_start(function(err, chunk)
  assert(not err, err)
  print(chunk)
end)

uv_tty_t — TTY 句柄 luv-tty-handle uv_tty_t

-- Simple echo program
local stdin = uv.new_tty(0, true)
local stdout = uv.new_tty(1, false)
stdin:read_start(function (err, data)
  assert(not err, err)
  if data then
    stdout:write(data)
  else
    stdin:close()
    stdout:close()
  end
end)

uv_udp_t — UDP 句柄 luv-udp-handle uv_udp_t

uv_fs_event_t — FS 事件控制代碼 luv-fs-event-handle uv_fs_event_t

uv_fs_poll_t — FS 輪詢控制代碼 luv-fs-poll-handle uv_fs_poll_t

檔案系統操作 luv-file-system-operations uv_fs_t

local function readFileSync(path)
  local fd = assert(uv.fs_open(path, "r", 438))
  local stat = assert(uv.fs_fstat(fd))
  local data = assert(uv.fs_read(fd, stat.size, 0))
  assert(uv.fs_close(fd))
  return data
end
local data = readFileSync("main.lua")
print("synchronous read", data)

local function readFile(path, callback)
  uv.fs_open(path, "r", 438, function(err, fd)
    assert(not err, err)
    uv.fs_fstat(fd, function(err, stat)
      assert(not err, err)
      uv.fs_read(fd, stat.size, 0, function(err, data)
        assert(not err, err)
        uv.fs_close(fd, function(err)
          assert(not err, err)
          return callback(data)
        end)
      end)
    end)
  end)
end
readFile("main.lua", function(data)
  print("asynchronous read", data)
end)

執行緒池工作排程 luv-thread-pool-work-scheduling

local function work_callback(a, b)
  return a + b
end
local function after_work_callback(c)
  print("The result is: " .. c)
end
local work = uv.new_work(work_callback, after_work_callback)
work:queue(1, 2)
-- output: "The result is: 3"

DNS 工具函式 luv-dns-utility-functions

執行緒和同步工具 luv-threading-and-synchronization-utilities

其他工具 luv-miscellaneous-utilities

度量操作 luv-metrics-operations

貢獻者 luv-credits