Atom是一个很好用的编辑器，之前一直在纠结了用什么编辑器好，在对比了VSCode/Sublime Text3和Atom之后，我还是继续选择了Atom。Atom一个重要的功能就是插件(或者说package)，但是身在你国，Atom插件安装总是有点不稳定，比如下图：

在Atom设置界面中点击下载插件以后因为网络原因大多数情况都会卡住/报错。所以，还是自己手动安装需要的插件吧。

方法一：使用apm安装工具

apm(Atom Package Manager)是atom的包管理工具，可以方便的管理Atom的插件。
下面以安装插件atom-beautify为例:
首先打开你的cmd/bash,切换到atom的插件目录

1

$ cd ~/.atom/packages

使用

1

$ apm install <package-name>

这里的换为atom-beautify，运行命令。等待一些时间后，ok！atom-beautify安装完成。

重新打开你的Atom，是不是已经可以看到菜单里有atom-beautify了?

方法二：使用git clone整个插件的仓库

这种方法可能会少相关依赖，需要自行在package里运行npm install <node-package>安装相关的依赖。
在atom.io上(或者在atom设置界面中跳转到插件的网页)找到插件页面，点击Repo跳到插件的github仓库，将替换为仓库的地址，然后在packages目录下运行下列命令：

1

$ git clone <repo-url>

方法三：使用自己创建的仓库

为了保证各个设备的Atom设置同步，可以自己新建一个git仓库，把自己的插件及配置文件(config.cson,snippets.cson等等…) 提交上去，今后就可以方便的安装自己提交上去的插件啦！

1

$ git clone https://github.com/alucardlockon/MyAtomPackagesAndConfig

ATOM

编辑快捷键

C-p:上一页
C-n:下一页
C-f:向前
C-b:向后
C-a:行首
C-e:行尾
C-T:交换光标两边字符位置
C-G:跳转行号

首先，Atom自带许多Emacs的快捷键来浏览文档。要想上移或者下移一个字符，你可以 按 C-P 和 C-N 。左移或右移一个字符，按 C-B 和 C-F 。这样等同于按下方向 键，但是一些人不喜欢把他们的手移到方向键的位置。
除了单个字符的移动，还有一些其他的用于移动的快捷键。
alt-B , alt-left
移动到单词开头。
alt-F , alt-right
移动到单词末尾。
C-right , C-E
移动到整行末尾
C-left , C-A
移动到整行开头
C-up
移动到文件开头。
C-down
移动到文件末尾。
你也可以使用 C-G ，通过指定一行（和列）来直接移动光标。这会弹出一个对话框问你想 要跳到哪一行。你同样可以使用 row:column 语法来跳到那一行的某个字符。
C-R:它会打 开一个列表，包含当前文件中所有的符号，你可以通过 C-t 进行模糊查找。使 用 C-S-r 来查找存在于整个项目中的符号。

C-K , C-U
将当前字符转为大写
C-K , C-L
将当前字符转为小写

多重光标

C-A-上,C-A-下:在光标之上或之下添加新的多重光标
C-D: 选择文档中相同的下一个单词
A-F3:选择文档中相同的所有单词

书签

C-F2:查找书签
A-C-F2:书签
S-F2:跳到上一个书签
F2:跳到下一个书签

行操作

C+上,C+下:上移/下移行
C+S+K:删除整行
C+J:合并两行
C+S+D:复制行

折叠代码

A+C+[:折叠代码
A+C+]:展开代码
A+C+S+[:折叠全部
A+C+S+]:展开全部

窗口快捷键

C-,:设置
C-S-O:打开目录
C-\:切换树目录
C-S-L:选择语法
C-S-U:选择编码
C-W:关闭当前缓冲区
C-S-W 关闭

文件查找

C-T或C-P:查找文件(项目目录中所有文件中搜索)
C-B:只在当前打开的文件中搜索。
C-S-B:上次git提交添加修改的文件中搜索。

模糊查找工具同时使用 core.ignoredNames 和 fuzzy-finder.ignoredNames 设置，来过滤不显示 的文件和文件夹。如果你的项目中有大量你不想在其中搜索的文件，你可以向这两个设置之 一添加通配符或者目录。

文本选择

Atom中的文本选择支持很多操作，比如区域选择、缩进和一些查找操作, 以及用引号或者括号 把文字括起来之类的标记操作。
选择命令借鉴了很多查找命令。他们实际上具有相同的快捷键，只不过加了个 S 。
C-S-P
选择当前位置到上一行的相同列
C-S-N
选择当前位置到下一行的相同列
C-S-B
选择前一个字符
C-S-F
选择后一个字符
alt-S-B , alt-S-left
选择当前位置到单词开头
alt-S-F , alt-S-right
选择当前位置到单词末尾
C-S-E , C-S-right
选择当前位置到整行末尾
C-S-A , C-S-left
选择当前位置到整行开头
C-S-up
选择当前位置到文件开头
C-S-down
选择当前位置到文件末尾
除了和移动相关的选择命令，还有一些命令可以选择内容的特定区域。
C-A
选择整个缓冲区
Atom飞行手册（中文版）
36文 本选择
C-L
选择整行
C-S-W
选择当前单词

查找

C-F:在缓冲区中查找
C-S-F:在整个项目中查找

括号

C-M:当前匹配的括号。
C-A-M:选择当前括号中所有文本

自动补全

C-SPACE 查看自动补全提示

面板

C-K-方向键:在不同面板移动

Git

A-G O
在Github上打开文件。
alt-G B
在Github上打开文件的修改历史。
alt-G H
在Github上打开文件的提交历史。
alt-G C
复制当前文件在Github上的链接。
alt-G R
在Github上进行分支比较。

命令行

atom [filename]
$ apm help installapm安装帮助
apm install <package_name> 会安装最新版本。
apm install <package_name>@<package_version> 会安装指定版本。
apm search 搜索
apm view 查看指定包的详细信息

Hadoop

课堂笔记

HDFS(the Hadoop Distributed File System)

具有高性能，容错机制，主从架构，可扩展等特点。
组成:NameNode和SecondaryNameNode

NameNode

云数据信息存储，包含:文件存放路径所有者，block名称和路径。

SecondaryNameNode

定期从NameNode获取信息每小时或100w次提交则执行checkpoint

HA高可用性

SecondaryNameNode可在NameNode宕机时接管它

联邦(Federaion)模式

多个独立NameNode,每个NameNode管理namespace的一部分

其他

常用端口:50070
命令:hadoop fs -cat/-mkdir/ls/put/rm

MapRedurce

流程检查

YARN

作为集群管理平台
ResourceManager 作业初始化
NodeManager 作业控制
JobHistoryManeger 历史信息
YARN组成:Container/ApplicationMaster

Hbase

具有高可用性，支持海量数据等特点
基于列簇，单行事物，rowkey是唯一索引,支持PB+数据,高吞吐量

Hive

使用Sql查询，可ETL转码文字

Impala

效率高于Hive

Spark

大规模数据处理引擎

solr

搜索服务器

Markdown语法

中文手册

标题

# //一级标题
###### //六级标题

引用

to py or not to py,this is a question

–by ywh

列表

• name
• sex

• a
• b

• d
• c

1. a
2. c

代码

code here

1
2
3

function func(){
  alert(1);
}

分割线

链接/图片

LInk

强调/粗体

Yeah
Yeah

反斜杠

1
2
3
4
5
6
7
8
9
10
11
12

\   反斜线
`   反引号
*   星号
_   底线
{}  花括号
[]  方括号
()  括弧
#   井字号
+   加号
-   减号
.   英文句点
!   惊叹号

EMACS

快捷键

C-p:上一页
C-n:下一页
C-f:向前
C-n:向后
C-a:行首
C-e:行尾
C-@:mark
C-w:移除mark文字
C-k:移除整行,再次按下移除换行符

其他

命令后加数字多数是重复执行命令:C-20-n 下20行
终止结果:C-g

数据结构

程序设计=数据结构+算法

逻辑机构和物理结构

传统上，我们把数据结构分为逻辑机构和物理结构。
逻辑结构:是指数据对象中数据元素之间的相互关系。
物理结构:是指数据的逻辑结构在计算机中的存储形式。

四大逻辑结构

集合结构

没有不三不四的关系

线性结构

一对一

树形结构

一对多的层次关系

图形结构

多对多的关系

物理结构

顺序存储:把数据元素存放在地址连续的存储单元里
链式存储:把数据元素存放在任意的存储单元里，这些存储单元可以是连续的，也可以是不连续的。

算法

输入:算法具有零个或多个输入
输出:至少有一个或多个输出

有穷性:
算法在执行有限的步骤之后，自动结束
确定性:
算法的每个步骤都有确定的含义，有唯一的输出结构，每个步骤都应该明确不能有歧义

算法不是唯一的，同一个问题，可以有多种解决问题的算法。

正确性

• 程序没有语法错误
• 算法程序对于合法输入能够产生满足要求的输出
• 算法程序对于非法输入能够产生满足规格的说明
• 算法程序对于故意刁难的测试输入都有满足要求的输出结果(高阶)

可读性:
便于阅读，理解和交流
健壮性:
输入数据不合法时，能做出相关处理
时间效率高和存储量低:

C++

头文件

标准库#include <iostream>
不属于标准库的#include "my_H.h"

基本语法

文件重定向:$ addItems <infile >outfile

基本类型

算数类型

整形
浮点型

算数类型

Node.js

教程1
教程2-7天学会node.js
API
Express

hello,world

引入 required 模块并创建服务器

var http = require("http");

1
2
3
4
5
6
7
8
9
10
11

var http = require('http');
http.createServer(function (request, response) {
    // 发送 HTTP 头部
    // HTTP 状态值: 200 : OK
    // 内容类型: text/plain
    response.writeHead(200, {'Content-Type': 'text/plain'});
    // 发送响应数据 "Hello World"
    response.end('Hello World\n');
}).listen(8888);
// 终端打印如下信息
console.log('Server running at http://127.0.0.1:8888/');

运行server端:node server.js

npm升级/安装模块

npm install npm -g
npm install express 安装express模块
var express = require('express'); 引用模块
-g参数:全局安装，不带为本地安装
$ npm ls -g查看全局安装的模块
npm uninstall/update/search express 卸载/更新/搜索模块

npm常用命令

使用npm help 可查看某条命令的详细帮助，例如npm help install。
在package.json所在目录下使用npm install . -g可先在本地安装当前命令行程序，可用于发布前的本地测试。
使用npm cache clear可以清空NPM本地缓存，用于对付使用相同版本号发布新版本代码的人。

package.json

package.json 位于模块的目录下，用于定义包的属性。

Package.json 属性说明

name - 包名。
version - 包的版本号。
description - 包的描述。
homepage - 包的官网 url 。
author - 包的作者姓名。
contributors - 包的其他贡献者姓名。
dependencies - 依赖包列表。如果依赖包没有安装，npm 会自动将依赖包安装在 node_module 目录下。
repository - 包代码存放的地方的类型，可以是 git 或 svn，git 可在 Github 上。
main - main 字段是一个模块ID，它是一个指向你程序的主要项目。就是说，如果你包的名字叫 express，然后用户安装它，然后require(“express”)。
keywords - 关键字

非阻塞代码

1
2
3
4
5
6

var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log("程序执行结束!");

事件驱动程序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();
 
// 创建事件处理程序
var connectHandler = function connected() {
   console.log('连接成功。');
   // 触发 data_received 事件
   eventEmitter.emit('data_received');
}
// 绑定 connection 事件处理程序
eventEmitter.on('connection', connectHandler);
// 使用匿名函数绑定 data_received 事件
eventEmitter.on('data_received', function(){
   console.log('数据接收成功。');
});
// 触发 connection 事件
eventEmitter.emit('connection');
 
console.log("程序执行完毕。");

参数传递

1
2
3
4
5
6
7
8
9
10

//event.js 文件
var events = require('events');
var emitter = new events.EventEmitter();
emitter.on('someEvent', function(arg1, arg2) {
    console.log('listener1', arg1, arg2);
});
emitter.on('someEvent', function(arg1, arg2) {
    console.log('listener2', arg1, arg2);
});
emitter.emit('someEvent', 'arg1 参数', 'arg2 参数');

EventEmitter方法

addListener(event, listener) 为指定事件添加一个监听器到监听器数组的尾部。
on(event, listener) 为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。
once(event, listener) 为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器。
removeListener(event, listener) 移除指定事件的某个监听器，监听器 必须是该事件已经注册过的监听器。
removeAllListeners([event]) 移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器。
setMaxListeners(n) 默认情况下， EventEmitters 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners 函数用于提高监听器的默认限制的数量。
listeners(event) 返回指定事件的监听器数组。
emit(event, [arg1], [arg2], […])按参数的顺序执行每个监听器，如果事件有注册监听返回 true，否则返回 false。

类方法 listenerCount(emitter, event) 返回指定事件的监听器数量。

error事件

链接
EventEmitter 定义了一个特殊的事件 error，它包含了错误的语义，我们在遇到 异常的时候通常会触发 error 事件。
当 error 被触发时，EventEmitter 规定如果没有响 应的监听器，Node.js 会把它当作异常，退出程序并输出错误信息。
我们一般要为会触发 error 事件的对象设置监听器，避免遇到错误后整个程序崩溃。

Buffer类(缓冲区)

var buf = new Buffer(10);
var buf = new Buffer([10, 20, 30, 40, 50]);
var buf = new Buffer("www.runoob.com", "utf-8"); //utf-8是默认编码格式，可替换成"ascii", "utf8", "utf16le", "ucs2", "base64" 和 "hex"。
buf.write(string[, offset[, length]][, encoding])写入数据
buf.toString([encoding[, start[, end]]])读取数据
buf.toJSON()将Buffer转为json
Buffer.concat(list[, totalLength]) 缓冲区合并
buf.compare(otherBuffer); 缓冲区比较
buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]]) 拷贝缓冲区
buf.slice([start[, end]]) 裁剪缓冲区
buf.length; 缓冲区长度

Stream(流)

Stream 是一个抽象接口，Node 中有很多对象实现了这个接口。例如，对http 服务器发起请求的request 对象就是一个 Stream，还有stdout（标准输出）。
Node.js，Stream 有四种流类型：

• Readable - 可读操作。
• Writable - 可写操作。
• Duplex - 可读可写操作.
• Transform - 操作被写入数据，然后读出结果。

所有的 Stream 对象都是 EventEmitter 的实例。常用的事件有：

• data - 当有数据可读时触发。
• end - 没有更多的数据可读时触发。
• error - 在接收和写入过程中发生错误时触发。
• finish - 所有数据已被写入到底层系统时触发。

读取流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

var fs = require("fs");
var data = '';
// 创建可读流
var readerStream = fs.createReadStream('input.txt');
// 设置编码为 utf8。
readerStream.setEncoding('UTF8');
// 处理流事件 --> data, end, and error
readerStream.on('data', function(chunk) {
   data += chunk;
});
readerStream.on('end',function(){
   console.log(data);
});
readerStream.on('error', function(err){
   console.log(err.stack);
});
console.log("程序执行完毕");

写入流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

var fs = require("fs");
var data = '菜鸟教程官网地址：www.runoob.com';
// 创建一个可以写入的流，写入到文件 output.txt 中
var writerStream = fs.createWriteStream('output.txt');
// 使用 utf8 编码写入数据
writerStream.write(data,'UTF8');
// 标记文件末尾
writerStream.end();
// 处理流事件 --> data, end, and error
writerStream.on('finish', function() {
    console.log("写入完成。");
});
writerStream.on('error', function(err){
   console.log(err.stack);
});
console.log("程序执行完毕");

管道流

1
2
3
4
5
6
7
8
9

var fs = require("fs");
// 创建一个可读流
var readerStream = fs.createReadStream('input.txt');
// 创建一个可写流
var writerStream = fs.createWriteStream('output.txt');
// 管道读写操作
// 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
readerStream.pipe(writerStream);
console.log("程序执行完毕");

链式流

1
2
3
4
5
6
7

var fs = require("fs");
var zlib = require('zlib');
// 压缩 input.txt 文件为 input.txt.gz
fs.createReadStream('input.txt')
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream('input.txt.gz'));
console.log("文件压缩完成。");

模块

为了让Node.js的文件可以相互调用，Node.js提供了一个简单的模块系统。
模块是Node.js 应用程序的基本组成部分，文件和模块是一一对应的。换言之，一个 Node.js 文件就是一个模块，这个文件可能是JavaScript 代码、JSON 或者编译过的C/C++ 扩展。
编写稍大一点的程序时一般都会将代码模块化。在NodeJS中，一般将代码合理拆分到不同的JS文件中，每一个文件就是一个模块，而文件路径就是模块名。
在编写每个模块时，都有require、exports、module三个预先定义好的变量可供使用。

require

require函数用于在当前模块中加载和使用别的模块，传入一个模块名，返回一个模块导出对象。模块名可使用相对路径（以./开头），或者是绝对路径（以/或C:之类的盘符开头）。另外，模块名中的.js扩展名可以省略。

exports

exports对象是当前模块的导出对象，用于导出模块公有方法和属性。别的模块通过require函数使用当前模块时得到的就是当前模块的exports对象。以下例子中导出了一个公有方法。

module

通过module对象可以访问到当前模块的一些相关信息，但最多的用途是替换当前模块的导出对象。例如模块导出对象默认是一个普通对象，如果想改成一个函数的话，可以使用以下方式。

Linux 编译安装

编译安装
Linux系统下没有现成的安装程序可用，虽然一些发行版可以使用apt-get之类的方式安装，但不一定能安装到最新版。因此Linux系统下一般使用以下方式编译方式安装NodeJS。

1. 确保系统下g++版本在4.6以上，python版本在2.6以上。
2. 从nodejs.org下载tar.gz后缀的NodeJS最新版源代码包并解压到某个位置。
3. 进入解压到的目录，使用以下命令编译和安装。

   1 2 3

   $ ./configure $ make $ sudo make install

文件拷贝

小文件拷贝:

1
2
3
4
5
6
7
8

var fs = require('fs');
function copy(src, dst) {
    fs.writeFileSync(dst, fs.readFileSync(src));
}
function main(argv) {
    copy(argv[0], argv[1]);
}
main(process.argv.slice(2));

process是一个全局变量，可通过process.argv获得命令行参数。由于argv[0]固定等于NodeJS执行程序的绝对路径，argv[1]固定等于主模块的绝对路径，因此第一个命令行参数从argv[2]这个位置开始。

大文件拷贝:

1
2
3
4
5
6
7
8

var fs = require('fs');
function copy(src, dst) {
    fs.createReadStream(src).pipe(fs.createWriteStream(dst));
}
function main(argv) {
    copy(argv[0], argv[1]);
}
main(process.argv.slice(2));

工程目录

了解了以上知识后，现在我们可以来完整地规划一个工程目录了。以编写一个命令行程序为例，一般我们会同时提供命令行模式和API模式两种使用方式，并且我们会借助三方包来编写代码。除了代码外，一个完整的程序也应该有自己的文档和测试用例。因此，一个标准的工程目录都看起来像下边这样。

1
2
3
4
5
6
7
8
9
10
11

- /home/user/workspace/node-echo/   # 工程目录
    - bin/                          # 存放命令行相关代码
        node-echo
    + doc/                          # 存放文档
    - lib/                          # 存放API相关代码
        echo.js
    - node_modules/                 # 存放三方包
        + argv/
    + tests/                        # 存放测试用例
    package.json                    # 元数据文件
    README.md                       # 说明文件

HTTP Server

创建Server

1
2
3
4
5
6

var http=require('http');
http.createServer(function(req,res){
    res.writeHead(200,{'Content-Type':'text/html'});
    res.write('<h1>Node.js</h1>');
    res.end('<p>Hello World</p>');
}).listen(3000);

获取GET请求内容

1
2
3
4
5
6
7
8

var http=require('http');
var url=require('url');
var util=require('util');
 
http.createServer(function(){
  res.writeHead(200,{'Content-Type':'text/html'});
  res.end(util.inspect(url.parse(req.url,true))); //通过url.parse,原始的path被解析为一个对象，其中的query就是GET请求的内容,pathname则是路径
}).listen(3000);

获取POST请求内容(仅测试，有效率和安全问题)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

var http=require('http');
var querystring=require('querystring');
var util=require('util');
 
http.createServer(function(){
  var post='';
 
  req.on('data',function(chunk)){
    post+=chunk;
  });
 
  req.on('end',function(){
    post=querystring.parse(post);
    res.end(util.inspect(post));
  });
 
}).listen(3000);

Node.js Web开发实战

MVC

• 模型是对象及其数据结构的实现，通常包含数据库操作
• 视图表示用户界面，在网站中通常就是HTML的组织结构
• 控制器用于处理用户请求和数据流,复杂模型，将输出传递给视图。

Express框架

示例

1
2
3
4
5
6
7
8

var express =require('express');
 
var app=express.createServer();
app.use(express.bodyParser());
app.all('/',function(rq,res){
  res.send(req.body.title+req.body.text);
});
app.listen(3000);

通过应用生成器工具 express 可以快速创建一个应用的骨架。
$ npm install express-generator -g

路由规划

1
2
3
4
5
6

/ 首页 app.get('/',routes.index);
/u/[user] 用户主页 app.get('/u/:user',routes.user);
/post 发表信息 app.post('/post',routes.post);
/reg 用户注册 app.get('/reg',routes.reg); app.post('/reg',routes.doreg);
/login 用户登录
/logout 用户登出

repository:https://github.com/yuanzm/microblog

Lua

中文手册

交互模式

进入：lua

参数

-i：进入交互模式
dofile(“name”) 可交互模式测试代码
-l：加载一个文件
-e：直接传命令至lua
args变量:参数

语法

helloword
‘print(hello,world)’
注释 –
变量 a=10
删除变量 a=nil
==相等
~=不相等
逻辑运算 and / or / not
..连接运算 “aa”..”bb” –> “aabb”
局部变量 local
句末的;可加可不加

代码块

使用do…end来包围代码以在交互模式下运行

if判断 if elseif else end..

1
2
3
4
5
6

if i>20 then
  local a
  a=20
else
  a=0
end

循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

for a in io.lines() do
  list={next=list,value=a}
end
while a>1 do
  a--;
end
repeat
  a++;
until a>1;
--for第三个参数step可省略,默认1
for a=1,10,1 do
  print(a)
end
--范型for循环
for a in tb1 do print(a) end

break:退出循环
iparis(table)遍历

require

加载运行库

错误 error(“my error”)

debug库可收集错误信息
debug.debug:给出lua的提示符
debug,traceback:给出更多的错误信息

基本变量类型

1. nil
2. boolean(true,false)
3. number
   lua没有整数,number表示实数，无需担心误差
4. string
5. userdata
   userdata可以将C数据放在lua变量中
6. function
   函数
7. thread
8. table
   创建表

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   tb1={"cell1","cell2","cell3"} ``` weak table:(\_\_mode=\"k(key) or v(value)\")会被lua内存垃圾回收收集 type(变量):测试函数类型 字符串和数字运算时自动转换成string ### 保留字 > and break do else elseif end false for function if in local nil not or repeat return then true until while ### 函数 ``` lua function func_name(args) xxx; end;

当函数只有一个参数，且是字符串或表构造函数，则无需使用()来调用函数:

1

print "Lua";

lua使用的函数也可以是其他语言编写的

Lua函数可以有多个返回值
retun para1,para2;
可变参数:f(unpack(a)):unpack返回a所有的元素作为f的参数
…:表示参数

1
2
3
4
5

function a(...)
  for a in ipairs(arg) do
    xxx
  end
end

_,x=strinig.find(a,b) 哑元(只返回第二个参数)

1
2
3
4

function Go(opts)
  xxx;
  _Go(opts.x or 0,opts.y or 0)
end

匿名函数

print(function(a) xxx end)

协同

协同有三个状态挂起态(suspended),运行态(runnig),停止态（dead）,create时为挂起，调用resume(co)后为运行态，完成后，dead

1
2
3

co=coroutine.create(
  function () print "1"; end;
  )

yield()函数能挂起

面向对象

1
2
3
4

Account={balance=0}
function Account.withdraw(self/this(可隐藏),v)
  self.balance=Account.balance-v
end

继承

VipAccount=Account:new()

标准库

数学库math

math: sin/rad/deg…
math.randomseed(os.time()) //避免重复随机数

Table库

table.getn():返回table大小
setn():设置table大小
insert()/remove()
sort()

String库

upper(“”)/lower(s)
len(s)
rep(s,n) –返回重复n次字符串s的值
sub()
char()/byte() 转换
format(“%d”,s) 格式化字符串
find(s,”abc”) 查找abc,第二个参数能使用修饰模式(+-*\?)
gsub()

IO库

io.write(“”)/io.read(“*all”)
io.lines()
io.open(“/etc/aaaa”,”w/r”(二进制:wb,rb))

系统库

os.rename() 修改文件名
os.remove() 删除文件
os.time()/os.date()
os.getenv(“HOME”) 环境变量
os.execute(“dir”) 执行系统命令
os.setlocale(“GBK”,”xxx”) 设置地区特性

Debug库

debug.info 自省函数
debug.traceback()
debug.setlocal/getlocal 设置/获取一个局部变量
debug.getupvalue(func,i) 获取upvalue级别

Hooks 跟踪器

debug.sethook(print,”999”)

C API

C API是一个C代码与Lua进行交互的函数集

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>
#include <lua.h>  //LUA基础函数
#include <luaxlib.h> //辅助库
#include <lualib.h>
int main(void){
  int a=0;
  lua_State \*L=lua_open();
  luaopen_base(L);
  luaopen_table(L);
  luaopen_string(L);
}

读取配置文件

height=1000
lua_getglobal(L,”width”);

调用lua函数

1
2
3

int a=1;
lua_getglobal(L,"func");
lua_pushnumber(L,x);

C

预处理

1
2
3

#define ABC 1//宏定义
#include //包含
#if #ifdef #ifndef #elif #else #endif //条件编译

预处理指令总是在一行，除非使用“\”来换行

宏

1
2
3
4
5
6
7

//宏甚至可以改变语法如用BEGIN替代{}
#define BEGIN {
#define END }
//控制条件编译
#define DEBUG
//带参数的宏
#define MAX(x,y)

#将宏的参数转化为一个字符串字面量
##可以将两个记号粘合成为一个记号
#undef 取消宏

预定义宏

1
2
3
4
5
6
7

__LINE__ 被编译文件中的行号  
__FILE__ 被编译的文件名  
__DATE__ 编译的日期  
__TIME__ 编译的时间  
__STDC__ 如果编译器符合C标准，则值为1
__STDC__VERSION__ 支持的C标准版本(c99)
__func__ 函数名

参数加…(c99)参数可变

条件编译

1
2
3
4
5
6
7

if defined(WIN32)
...
#elif defined(MAC_OS)
...
#elif defined(LINUX)
...
#endif

指令

#error 显示一条包含消息的出错消息

1
2
3

#if A<100
#error int type is too small
#endif

#line 100 改变行号(行号从100开始)

避免多次包含

1
2

#ifndef ABC_H
#define ABC_H

结构

结构的声明

1
2
3
4

struct abc{
  int a;
  char b;
}

枚举

enum {ABC,DEF} s1,s2
即ABC,DEF的值能赋值给s1,s2变量

指针

*取地址,&逆运算,取该地址的值

动态调节指针存储空间

p=(char *)malloc(n+1):为字符串动态分配内存
a=calloc(n,sizeof(int))
realloc(p)：调整数组大小以符合需要
free(p):释放内存(如果再访问可能会有悬空指针的问题)

“->”右箭头选择

->相当于.和*的结合

存储类型

auto 只对属于块的变量有效,默认,无需明确声明
static 静态，无限期保留值
extern 使几个源文件可以共享一个变量
register 不保留在内存，而是在CPU寄存器中(适合频繁访问或更新的对象)
函数的存储类型:extern/static

####内联函数(c99)
inline int a(){}:内联函数，(内联表明把函数调用使用机器指令代替，加快速度)

标准库

c89标准库

1. assert.h 诊断
2. ctype.h 字符处理
3. errno.h 错误
4. float.h 浮点类型的特性
5. limits.h 整数类型的大小
6. locale.h 本地化
7. math.h 数学计算
8. setjmp.h 非本地跳转
9. signal.h 信号处理
10. stdarg.h 可变参数
11. stddef.h 常用定义
12. stdio.h 输入输出
13. stdlib.h 实用程序
14. string.h 字符串处理
15. time.h 日期和时间

c99标准库

1. ccmplex.h 复数计算
2. fenv.h 浮点环境
3. inttypes.h 整数类型格式转换
4. iso646.h 拼写转换
5. stdbool.h 布尔类型和值
6. stdint.h 整数类型
7. tgmath.h 泛型数学
8. wchar.h 扩展的多字节和宽字符实用程序
9. wctype.h 宽字符分类和映射实用工具

函数

printf

d 以十进制形式输出带符号整数(正数不输出符号)
o 以八进制形式输出无符号整数(不输出前缀0)
x,X 以十六进制形式输出无符号整数(不输出前缀Ox)
u 以十进制形式输出无符号整数
f 以小数形式输出单、双精度实数
e,E 以指数形式输出单、双精度实数
g,G 以%f或%e中较短的输出宽度输出单、双精度实数
c 输出单个字符
s 输出字符串

getc/putc 读/写

getc/fgetc(FILE stream) 从文件读取char
getchar() 从标准输入流stdin读入一个字符
putc/fputc(ch,fp) 写入char
putchar() 从标准输出流stdout写一个字符
gets(\s)/puts(*s) 读写一个行
fread(list,sizeof(list[0]),sizeof(list)/sizeof(list[0]),fp)/fwrite(list,sizeof(list[0]),sizeof(list)/sizeof(list[0]),fp) 块读取写入

fseek() 查找文件

SEEK_SET 文件的起始处
SEEK_CUR 文件的当前位置
SEEK_END 文件末尾处
fseek(fp,0L,SEEK_SET) //搜索开头

sprintf()/sscanf 读写入字符串

数学计算(math.h)

三角函数

acos(double x)/asin(d)/atan(x)/atan2(x,y)/cos(d)/sin(x)/tan(x)

指数/对数函数

exp(double x)/log(double x)/modf(value,*p)

幂/取整，绝对值，取余

pow(x,y)/sqrt(x)/ceil(x)/fabs(x)/floor(x)/fmod(x,y)

字符处理(string.h)

tolower(int c)/topower(int c):大小写映射
字符串复制:*strcpy(*s1,*s2) / strncpy(*s1,*s2,int size) 及*memcpy/*memmove
字符串拼接:*strcat(*s1,*s2) / strncat(s1,s2,size)
字符串比较:memcmp,strcm,strcoll,strncmp,strxfrm
字符串搜索:*memchr / *strchr