记忆和记忆的补完

About

Mon, 16 Jul 2018 13:38:52 +0800

我们仍未知道那天的记忆和记忆的补完

这是lonelycode的个人技术博客。主要专注于Web后端开发，涉及主要内容如下：

Python 和 Golang的使用
数据库
微服务
Emacs/Vim/Linux/CommandLine等工具分享

本人Github地址

Linux使用的点点滴滴

Tue, 17 Jul 2018 11:48:14 +0000

完全Linux下工作已经接近一年半的时间，中间零零碎碎记录一些好的东西和遇到的坑。有些只是为了记录而记录，网上都提到就不提了。持续更新…

基础

查看具体某个进程TCP端口占用情况， lsof -p <pid> -i "TCP"
tail -f file.log 尾部跟踪log文件（主要是-f参数–follow），可以实时输出最后的结果，对于实时请求可以看到信息。可以监控多个文件 tail -f /path/*/file.log*
source + sh 可以重启执行sh文件
grep -A -B -C 参数可以指定行数，找到结果之前、之后、上下几行的信息。
awk 可以用于按分割符打印输入的字符串, $1 代表参数 1, $2代表参数2，默认按空格打印，如果是其他分隔符用参数 -F
scp 可用于将本地代码通过ssh拷贝到目标机器(sshcopy简称)
增量更新两个相同的目录： rsync -avz src dst
找到对应的文件进行删除： find . -name '*.bill' | xargs rm -f
ls -li 其中i用于显示列出项的inode，对于查看链接的文件或者目录有用
设置代理其实就是修改https_proxy变量，export https_proxy=socks5://127.0.0.1:1080

有用

pip可以直接从github上安装，方式是 pip install git+https://.....git
zsh插件叫autojump，自动跳转目录，非常好用。
使用sshfs可以用来将远程路径映射到本地，所有本地操作都会自动同步到远程去，当然是ssh安全的。命令如右边 sshfs /remote/path/ /local/path/ -o follow_symlinks -o sshfs_sync -o reconnect
mycli mysql 的命令行工具，也有对应的postgresql工具
ssh免密码登录需要最后设置：ssh-copy-id <remoteIP>
lsyncd 是有用的同步目录的工具，可以设置的同步延时时间： lsyncd -delay 2 -rsync src dst
mysqldump 同的mysql命令几乎一样，前者重定向输出，后者重定向输入： mysqldump -u <user> -h <host> <dbname> -p --skip-lock-tables > xxx.sql
strace 用于监控某个进程的读写情况：strace -p <pid> -e trace=open,write,read,close
redshift 用于护眼：redshift -c /etc/redshift.conf &
vimdiff 对于的熟悉vim的人进行两个文件临时diff简直是神器
tcpdump
dig
用sed命令批量替换某个路径下的字符， grep 原字符串 -rl 所在目录 | xargs sed -i “s/原字符串/新字符串/g”`
使用httpie替代curl或者postman，可以将request data 通过管道导入， cat xxxx.json | sudo http -b POST :8080/xxxxx/xxxx\?token=kjl\&uid=uid2

备忘

emacs直接安装需要安装依赖: sudo apt-get install build-essential texinfo libx11-dev libxpm-dev libjpeg-dev libpng-dev libgif-dev libtiff-dev libgtk2.0-dev libncurses-dev
svn 进行某一部分的目录单独更新：一，对父目录进行svn checkout svn://svn.oa.com/SrcCodes/trunk/ --depth 'immediates'，二，到对应的想更新的路径操作svn up --set-depth 'infinity'
查看mysql数据库对应的用户和ip的权限: select DISTINCT(GRANTEE) frominformation_schema.USER_PRIVILEGES;
设置用户mysql权限 GRANT insert,update,select,delect PRIVILEGES ON <dbname>.* TO 'user@'192.168.%.%' identified by 'password';
mysql 安装和使用：
- apt-get install mysql-server
- apt-get install mysql-client
- apt-get install python-mysqldb 接着使用mysql -u root -p进入客户端，然后输入密码，记得安装过程会提示你输入密码；create database [databasename]，注意mysql需要设置为中文，加后缀create database [databasename] character set gbk
在新的设备上把SSH密钥添加到个人github账号的方式：ssh-keygen -t rsa -C your@email.com
设置autojump，一般从github上下载源码，然后在.zshrc文件下添加autojump插件，最重要的是要添加下面两句: shell [[ -s /home/xxxx/.autojump/etc/profile.d/autojump.sh ]] && source /home/xxxx/.autojump/etc/profile.d/autojump.sh 最后运行 source .zshrc。

博客迁移到 HUGO

Mon, 16 Jul 2018 16:01:23 +0800

迁移原因

之前不明白别人的博客为什么要迁移来迁移去，迁移完还要发一篇文章简述原因。后来换了电脑之后，原来的博客代码丢了，才知道对于自己不熟悉而且偶尔用的东西，往往累觉不爱。

对于 HEXO

几乎没接触前端，NPM 在新的环境不是强制安装的；
NPM 的速度和依赖对于偶尔使用的人体验太差，容易劝退。

对于 HUGO

只要一个编译好的可执行文件，可以扔到不同的环境当中；
使用 go 一段时间了；
生成博客的速度快；
支持 org-mode；
工程结构很清晰，主题在单独的文件夹当中，直接依赖 github 项目，太棒。

迁移过程

网上已经很多，下面这篇挺不错的： GitHub + Hugo 搭建个人博客

初识postgresql以及在Flask里面的关联使用

Tue, 19 Apr 2016 00:50:21 +0000

起因发现同一个服务器上面有人安装了postgresql用来跑一个大型的应用，postgresql如雷贯耳，一直没机会接触，于是好奇折腾了起来。因为牵扯众多只挑重点来讲。

1.安装

在Ubuntu系统以及其延伸系统安装特别方便。
123

sudo apt-get postgresql sudo apt-get postgresql-client sudo apt-get pgadmin3
分别为本体、客户端和一个管理postgresql的图形界面软件，非常好用，建议不熟悉命令行的新手使用。
在window下直接下载exe文件安装。安装完成后将postgresql的bin目录加入到系统环境变量Path,譬如;C:\Program Files (x86)\postgres\9.3\bin加入到计算机->属性->高级环境变量->环境变量->系统变量->Path最末端。之后也可以在cmd下面操作。

2. 初始化–添加用户和数据库

初始化的时候让人很疑惑，postgresql的用户和系统用户不关联，它本身自己拥有一套用户管理系统，必须新建一个用户和一个和用户名同名的数据才能使用（有疑问?）。

``` sql
# 所有的命令都可以加 --help来查看用法，下面用-s参数新建一个superuser账号 hehe。
createuser -s hehe
# 新建一个同名的数据库hehe并用参数-O指定owner（所有者）。
createdb -O hehe hehe    # createdb -O username databasename
```

值得一提的是，它自带一个postgres用户和postgres数据库。

3. 登陆和使用

psql 是连接postgresql的命令控制台工具。常用的几个参数选项和MySQL很相似。

1234	``` sql # 用上节新建的账号登陆 psql -h 127.0.0.1 -p 5442 -U hehe -d hehe ```

最常用的几个参数-h指定服务器，-p指定端口，缺省默认的为5432，-U 指定登陆的用户，-d指定数据库，缺省默认和用户名相同的数据库。如果此用户需要密码接下来还需要输入口令。

4. 登陆之后

登陆之后就进入命令控制台，几乎所有操作都是在这个环境下进行的。

基本操作

 1 2 3 4 5 6 7 8 910

1. \h:查看sql命令的解释
2. \?:所有psql命令列表
3. \l:现有所有数据库列表
4. \c [databasename]:直接跳转连接到其他数据库
5. \d:列出当前数据库的表格
6. \d [tablename]:列出表格的结构，非常有用的命令
7. \du:列出所有用户
8. \conninfo:当前连接信息
9. \password:为当前用户指定一个登陆口令
10. \q:退出当前控制台

sql操作

sql命令很多而且所有数据库大多都雷同。

# 新建表
CREATE TABLE books(book_no integer,name text,price numberic,UNIQUE (book_no));
# 插入数据
INSERT INTO books(book_no,name,price) VALUES(2333,'万历十五年',18.5);
# 查询
SELECT * FROM books
# 等等...

5. 启动、备份和恢复

启动中止状态操作

12	1. Ubuntu: /etc/init.d/postgresql start (stop/status/restart) 2. Windows: /PostgreSQL/9.3/bin/pg_ctl.exe (stop/status/restart/reload)

备份和恢复

1. pg_dump [databasename]:将postgresql数据导出到一个脚本文件
2. pg_dumpall:将所有的postgresql数据库导出到一个脚本文件
3. pg_restore:从以上两个命令导出脚本文件恢复
4. psql [databasename] < backup.sql恢复外部数据

6. 连接Flask的依赖

1. Psycopg2: 一个适配连接postgres数据库的python包，windows下请选择 win-Psycopg不然会提示缺少DLL的error
2. Flask-SQLAlchemy(2.1):Flask下的SQLAlchemy拓展，以更加python的形式来写数据库结构，更容易迁移数据库
3. Flask-Migrate:Flask数据库的初始化、迁移脚本和版本管理的利器
4. Flask-Script:命令行的拓展
几乎使用Flask的用户都默认安装后三者，真正依赖是Psycopg2。

7. 最小使用

在Flask项目的config.py文件里面最主要设置SQLALCHEMY_DATABASE_URI变量就可以了

 1 2 3 4 5 6 7 8 91011

import os
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy

SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
'postgresql://username:password@localhost:5432/databasename
DEBUG =True

app=Flask(__name__)
app.config.from_object(__name__)
db=SQLAlchemy(app)

比如用之前建好的数据库hehe就把最后那行改成 postgresql://hehe:@localhost:5432/hehe

用SQLAlchemy来建一个名为User的测试model,保存为model.py文件

 1 2 3 4 5 6 7 8 910111213

from config import db

class User(db.Model):
    __tablename__ = 'users'

    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(64), unique=True, index=True)
    username = db.Column(db.String(64), unique=True, index=True)
    password_hash = db.Column(db.String(128))
    name = db.Column(db.String(64))

    def __repr__(self):
        return '<User %r>' % self.username

建立一个名为manage.py文件，最小化使用Flask框架。

 1 2 3 4 5 6 7 8 91011121314151617181920

from config import app,db
from flask.ext.script import Manager
from flask.ext.migrate import Migrate,MigrateCommand
from model import User

migrate=Migrate(app,db)
manager=Manager(app)

manager.add_command('db',MigrateCommand)

@app.route('/')
def hello():
    return 'Hello'

@app.route('/<name>')
def hello_user(name):
    return "hello {} !".format(name)

if __name__=='__main__':
    manager.run()

命令行下初始化数据库，先来到项目目录下，按顺序输入下面三个命令
123456

# 初始化 python manage.py db init # 建立迁移脚本 python manage.py db migrate -m "init databasename for postgres" # 更新 python manage.py db upgrade
可以看见当前目录下面生成了一个名为migrations文件夹，这个文件夹是保存迁移脚本和数据库版本控制的地方，下次如果添加了新的model只要使用上面最后两条命令即可。

在psql下查看

 1 2 3 4 5 6 7 8 910111213141516171819202122

$ psql -U hehe
# 查看当前数据库的表
hehe=# \d
Schema   |      Name       |  Type | Owner
---------|-----------------|-------|--------
public   | alembic_version | table | hehe
public   | users           | table | hehe
public   | users_id_seq    | ??????| hehe
# 查看users表结构
hehe=# \d users
                                    Table "public.users"
    Column    |         Type           |                 Modifiers
--------------|------------------------|---------------------------------------------
id            | integer                | not null nextval('users_id_seq'::regclass)
email         | character varying(64)  |
username      | character varying(64)  |
password_hash | character varying(128) |
name          | character varying(64)  |
Indexes:
    "users_pkey" PRIMARY KEY, btree (id)
    "ix_users_email" UNIQUE, btree (email)
    "ix_users_username" UNIQUE, btree (username)

说明成功了

8. 添加数据和显示

还是用命令行操作，需要在manage.py文件下面添加:

from flask.ext.script import Shell
def make_shell_context():
    return dict(app=app,db=db,User=User)
manager.add_command('shell',Shell(make_context=make_shell_context))

然后再命令行下面python manage.py shell进入带有app、db和User上下文环境的shell控制台。

u = User(username="xibao")
# 添加一个名为xibao的用户
db.session.add(u)
db.session.commit()
# 退出当前控制台
exit

启动服务python manage runserver，在浏览器上面输入127.0.0.1:5000\xibao会返回”hello xibao !“。

9. 从postgresql里面备份

`12`	`# 使用之前pg_dump命令备份 pg_dump -f backup.sql hehe`

当前项目目录下面会多出一个backup.sql文件。

emacs完全补完计划（五）——歌剧魅影Elisp

Sun, 28 Feb 2016 20:18:06 +0000

闲话elisp

如果说emacs是一出庞大的歌剧，那么elisp则是撑起全场的主角，它犹如一道魅影，神秘、黑暗、引人入胜，在剧初以无以伦比的优雅身姿和独一无二的音色试图唤起观众的灵魂共鸣；当有人尝试接近它的时候，或许期望越大失望越大，藏在另一半面具下是人性特有的丑陋，是受世人侮辱唾弃后难掩的愤怒和敏感；而最后它高尚的选择和坚持让作为学习者的我们不断反思，什么叫做美？不是世俗的外在的可视的，是来源内在的人性之光，能够让灵魂起舞。事实上扯远了，不过大概总结了学习elisp的三个阶段，首先被洗脑认为lisp系语言如同武林传说中的秘籍邪典，迷迷糊糊建立了莫名的崇拜，后来深入学习才发现lisp系语言有固有的缺陷，致使它们在现代背景下难有立足之地，最后在完全了解它们了，发现在语言演变的历史长河它们是那么的独一无二，具有难以言表在时间的美，仿佛洞开了一个新世界。lisp相对现在很古老，在这期间有很多篇文章试图向别人灌输它的思想，这篇文章也是其中一篇，但lisp系语言太庞大，就elisp本身的官方手册都有一千多页，要在一篇文章里面完全展现它是不现实的，只能按笔者自己的有限理解来书写，可能夹杂着不恰当的比喻，希望观者有所悟。

七言七日七符

中国古代只用“七言”寥寥数语就表达出了无尽的情感和哲思，简直是“少即是多”的典范。而在西方传闻上帝仅仅花了七日便创造了世界。so what？说明“七”是吉祥的数字……传说lisp语言在创造之初也仅仅存在七个操作符。分别是 quote,atom,eq,car,cdr,cons以及 cond，如果从这七个角度出发就能化繁为简，理解lisp语言之源。之前的文章有提到三点操作符前置、数据结构以及返回机制，其实都是针对lisp语言的最大特征–括号而言的，在括号里面操作符会前置，遇到括号就执行并返回的机制，在括号外部引入引号让括号返回本身。实际上括号的只体现了lisp语言构成二分一的元素–语法。而七个操作符体现了语言的另一半组成–语义。

atom

atom翻译过来是原子，不可分割的意思。可以联想到古代由于科学不发达，许多人都想找到世界里最基本东西，用来理解世界的本质或者掌握其中的运行规律。一个经典的模型就是“五行”–金木水火土，世间万物的都是由这五种基本元素组成的。基本元素的概念其实就对应着atom，语言中一些基础类型是atom的一种。比如最常见的字符串、数字还有布尔值都是。之前有讲过elisp里面用后缀为p的函数来判断一个object的类型，比如stringp、numberp等等，可是没有atomp，因为atom只是一个笼统的概念，没有实际对应的类型，就干脆把atom当做判断符，用来判断一个object是否是atom。

(atom "hello") ;;==>t
(atom 233)  ;;==>t
(atom nil)  ;;==>t
(atom :keyword) ;;==>t

实际上elisp用type-of返回一个object的具体类型。

(type-of "hello") ;;==>string
(type-of 233) ;;===>integer
(type-of nil) ;;===>symbol

cons、car、cdr

不得不吐槽一下知道atom这个概念并没什么卵用，其实是为了理解cons这个概念做铺垫。cons可以翻译成序对或者点对，个人更倾向于后者。回到“五行”说，当我们手握五大元素的时候会做什么能更有趣？让它们发生关系！这就是所谓相克相生的运行体系，譬如钻木取火、水来土掩、水火不容等等…cons就是把两个基本元素(atom)结合的一种数据结构，让单独的atom彼此建立联系，cons这个字符本身就是建立这种结构的函数。如下图所示：

可以看出cons返回的形式是(1 . 2)，所以又可以叫做点对结构。

;;consp是用来判断是否是一个点对结构的函数。
(consp (cons "fire" "water"))  ;;毋庸置疑返回t
(consp '("fire"."water"))  ;;居然也返回t，说明也可以用'(xx.oo)的形式构造一个点对。

而car和cdr是对cons最基本的操作，比如(car (cons "阴" "阳"))会返回阴，cons的头部；(cdr (cons "阴" "阳"))则返回阳，cons的尾部；相当于一个负责“采阴”，另一个负责“取阳”。 cons犹如雌雄、阴阳、黑白、天地等相互对立又相互依存的统一矛盾体，不禁让人联想到太极，也如同太极能够演化出两仪四象八卦万物一样，cons理论上也能构造出任何的数据结构，简单而强大。不信请看：之前常常提到的list（列表）也是一种特殊的cons，上面第三个例子就是list的结构图，不仅要有“你和我”而且还要大家围在一起手牵手。(cons 1 (cons 2 (cons 3 (cons 4 nil))))这样生成list方式太麻烦所以创造了一个list的函数。

;;下面两个表达式是完全相等的
(cons 1 (cons 2 (cons 3 (cons 4 nil))))  ;;==>(1 2 3 4)
(list 1 2 3 4)  ;;==>(1 2 3 4)
;;将233加入到一个list的头部，并返回加入之后的新list
(cons 233 (list 1 2 3 4))  ;;==>(233 1 2 3 4)
;;用consp来判断
(consp (list 1 2 3 4))  ;;==> t

由于cons存在无限的可能，car和cdr这种一次只取一步的操作显然就不合时宜。于是乎创造出各种延伸变异版本的car和cdr，简直丧心病狂。

12345678

;;X代表某种cons复合结构。
(caar X)  ;;Return the car of the car of X.
(cddr X)  ;;Return the cdr of the cdr of X.
.
.
.
(caaaar X) ;;Return the `car' of the `car' of the `car' of the `car' of X.
(cddddr X) ;;Return the `cdr' of the `cdr' of the `cdr' of the `cdr' of X.

实际上，cons更常用于表示概念名称和具体实物之间的关联，像(cons key value)或者'(key . value)便可以表达一个物体。更实际的是，虽然cons结构能千变万化，但是对内存的效率却不高，所以lisp方言们都吸取了其他语言的数据结构，比如数组(array)、哈希表(hash table)等等来提高操作数据的效率，诚然，这样会让lisp方言们摇身一变成了“通用性的语言”，更易于其他程序猿的接受和自身的推广，但点对结构不该被遗忘或抛弃，它是lisp纯粹本质的体现之一。

quote

quote在之前已经提到过了，其实等同于'，引号是quote的简写，(quote a)完全等同于'a。之前还提到过因为lisp语法只要遇到括号就会根据前置的“操作符”求值返回，quote的存在就是对抗这种固化的机制而存在的。可以说没有quote的lisp里面都是“一个求值过程”，quote不求值只返回，数据就很容易构造出来，说到底quote 的存在是由于lisp代码和数据都是都用统一的S表达式带来了困扰。

(quote (1 2 3 4))
;;等同于
'(1 2 3 4)
;;等同于
(list 1 2 3 4)

这种不求值只返回的机制不仅仅用于构建数据，自然还可以让代码不求值返回，让代码之上又有的一层机制，为神奇的宏的出现埋好了伏笔。

eq

判断相等的，我至今不明白为什么eq会位列七个操作符之内，它看起来并不是很重要。它的定义是：(eq x y)，如果x和y是同一个原子(atom)或者空表(cons)，则返回t，否则返回nil。eq是最表面的判断，equal才是更深入的判断，之后会罗列elisp里面所以和判断相等有关的函数。

cond

cond是控制结构，类似其他语言里面的select-case控制功能，为什么七个操作符里面没有if，大概cond可以判断一种或者多种条件进行跳转，if只能一个或者两个条件，多种条件要不停的嵌套。形如：

(cond 
    ((条件1) 表达式1)
    ((条件2) 表达式2)
    ((条件3) 表达式3)
    ((条件4) 表达式4)
)

从上到下依次执行，直到遇到条件表达式返回值为t，则将该条件后面表达式的值当做整个cond表达式的返回值。

elisp的基本数据类型

回到elisp，基本数据类型有些和其他语言差不多，限于篇幅，挑重点讲。

integer

整型，#bNNN表示二进制数，同理有#o(八进制数)、#x(十六进制数)。

float

INF表示无穷大。

Char

Char其实就是integer，字符型用整数型对应的编码表示了而已。可以用?字母来打印字面量。

`12`	`(prin1 ?a) ;;==>97 (prin1 ?A) ;;==>65`

也和其他语言的一样，\n来表示空一行，\t表示TAB键等等，elisp里面多了几个：

 1 2 3 4 5 6 7 8 91011

?\a ;=> 7                 ; control-g, `C-g'
?\b ;=> 8                 ; backspace, <BS>, `C-h'
?\t ;=> 9                 ; tab, <TAB>, `C-i'
?\n ;=> 10                ; newline, `C-j'
?\v ;=> 11                ; vertical tab, `C-k'
?\f ;=> 12                ; formfeed character, `C-l'
?\r ;=> 13                ; carriage return, <RET>, `C-m'
?\e ;=> 27                ; escape character, <ESC>, `C-['
?\s ;=> 32                ; space character, <SPC>
?\\ ;=> 92                ; backslash character, `\'
?\d ;=> 127               ; delete character, <DEL>

elisp的容器类型

也是基础的数据结构，因为具有容纳的作用，而且彼此之间是有联系的，所以独起一章。这么多的容器式数据类型，区别它们的无非两点：存储的数据类型和底层的存储形式。关系如下图：

Sequence（序列）是hash-table外所有容器类型的总称了。用(length aSequence)获取Sequence的长度，(elt sequence N)来获取第N个元素，对任何一种序列都有用。

List

list是特殊的cons点对结构，是emacs里面最常见的数据类型。

创建list:使用list函数(list 1 2 3 4)或者'(1 2 3 4)
获取list里面的元素

函数	功能
(car X)	first element
(nth n X)	nth element (start from 0)
(car (last X))	last element
(cdr X)	2nd to last elements
(nthcdr n X)	nth to last elements
(butlast X n)	without the last n elements

在list头部添加元素:(cons element mylist)
合并两个list:(append list1 list2)
判断list是否为空:null
判断某个元素是否存在：(member element X)
返回元素所在的位置:(position element X)

alist(association list)

alist是elisp里面非常重要的概念，理解了点对结构之后，alist其实是把一组cons组织成一个列表，每个元素就是一个cons。形如：

(list
    '(key1 . value1)
    '(key2 . value2)
    '(key3 . value3)
)

emacs里面组织存放一组变量的最常见的形式。值得一提的是alist里面的元素是顺序的，且允许重复键值。一个非常有用的函数assoc，用key来寻找value，key的匹配使用的是equal。这么用：

 1 2 3 4 5 6 7 8 910

;;构建一个alist，并把它赋给dict
(setq dict
'((pine . cones)
 (oak . acorns)
 (maple . seeds)))
;;使用assoc，找到对应的cons并返回
(assoc 'oak dict) ;;==>(oak . acorns)
;;结合car、cdr可以把cons里面key和value分别取出来
(car (assoc 'oak dict))  ;;==>oak
(cdr (assoc 'oak dict))  ;;==>acorns

plist(Property list)

顾名思义，属性列表，其作用和alist相似，不过语法更加清晰些。形如：

`1`	`'(:key1 value1 :key2 value2 :key3 value3)`

注意:是不能省略的，而且key的值必须是唯一的。用plist-get取出值，plist-put来加入新的值。

;;构建一个plist，并把它赋给plst
(setq plst (list :buffer (current-buffer) :line 10 :pos 2000))
;;plist-get取出值
(plist-get plst :pos) ;;==>2000

Array

创建Array需要指定一个固定长度，除了char-table，这点限制了它的使用。除了从sequence继承过来的length和elt函数，array本身也有几个函数，对下属的类型都有效。设置元素位置和值：(aset array index value)

Vector

创建一个Vector：两种形式[v1 v2 v3 ...]和(vector v1 v2 v3 ...)，显然引入了[]，在一堆括号里面也另类。
将多个sequence合并成为一个vector：(voncat seq1 seq2)
vector和list的转换：(append vector nil)

bool-vector

bool-vector是vector的子集，只能用来存放nil或t。
创建 bool-vector：(make-bool-vector LENGTH INIT)。

char-table

string

string是不可变的，这点和大部分的语言一致
string可以包含文本属性properties，形如#("str" property-data)，property-data是以plist形式包含了string的一些属性。
string用string=和string<进行对比。

Hash Table(哈希表)

在其他语言比较常见的类型，数据容量到达一定级别速度依旧非常快，没有特殊的顺序要求，但不能重复。如果是小型数据装载还是建议用list，大集合用哈希表。

创建的哈希表时候可以根据一些关键字:key来指定初始属性。
- :test 因为哈希表里面的key值要求不能重复，所以key值需要比较，这个关键字指定key值比较的函数，可以是eq、eql、equal，默认是eql。
- :size 指定初始容量大小
访问hash table相关的函数：
- (gethash KEY TABLE)
- (puthash KEY VALUE TABLE)
- (remhash KEY TABLE):移除某个元素
- (clrhash TABLE):清理hash table
- (maphash FUNCTION TABLE):对每个元素都应用FUNCTION
拷贝：(copy-hash-table table)
个数：(hash-table-count table)

emacs基本数据类型小结

数据类型间的转换

number-to-string/string-to-number

concat可以将序列转换成字符串：

`12`	`(concat '(?a ?b ?c ?d ?e)) ; => "abcde" (concat [?a ?b ?c ?d ?e]) ; => "abcde"`

vconcat 把字符串转换成向量

`1`	`(vconcat "abcde") ;;==>[97 98 99 100 101]`

append原来是用来拼接两个list或者向list添加元素的，这里也可以把字符串转换成一个列表。
1

(append "abcdef" nil) ; => (97 98 99 100 101 102)
字母大小写：downcase、upcase、capitalize
转换数字为float类型：(float number)
float转integer：ceiling、round

对比相等

(eq OBJ1 OBJ2)：只是简单的对比两个object是否相等。

(eql OBJ1 OBJ2)：比eq高级一个点，遇到数字的时候还会判断数字的类型和大小。

;;除了数值为1，一个为整数一个为浮点数，所以为nil
(eql 1 1.0) ;;==>nil
;;类型和数值都一样才返回t
(eql 1.0 1.0) ;;==>t

(equal O1 O2)：因为比上面两个都长，所以更加深入，比较类型、数值以及结构全部相等情况，最常用的比较。
12

;;下面左右两个都是cons结构的生成方式，所以返回t (equal '(1 . 2) (cons 1 2)) ;;==>t
=：数字比较，主要针对值，(= 2 2.0)返回t。
string=和string-equal：两者是一样的，前者是后者的别名，比较字符串是否相等。

正则表达式

之前已经讲到正则常用的函数string-match和look-at，前者必须指定正则表达式和需要匹配的字符串，而look-at则是从此buffer的光标开始出进行匹配。 elisp的正则语法和其他语言基本一致，但有一点特别丑陋，像(,) {,} \等都需要转义才能使用，因为”\“也需要转义所以需要以”\“形式转义其他字符，比如匹配四位数字的正则”[0-9]\{4\}“。

;;匹配2016这个数字
(string-match "[0-9]\\{4\\}" "欢迎2016的到来")
;;中间参数0代表第0分组，也就是所有分组。
(match-string 0 "欢迎2016的到来") ;;==>"2016"

Symbol(符号)

概述

理解symbol是理解elisp的关键。当初在elisp成形的时候，面向对象的思想还没这么盛行，这种思想用继承和实例化的方式结构化地梳理代码间的关系，尤为重要的是对象状态的组织和存储以一种非常合理的形式呈现。elisp没有包含面向对象的思想，所以不现代很落后。就像用对象来指代一切很多现代语言一样，symbol是elip 里面的通用货币。symbol可以同时拥有下面四种值: 1. “name”，symbol-name符号名字 2. “value”，存储的变量值 3. “function”，存储的函数或者宏 4. “property list”，存储的属性列表

symbol定义

symbol具有唯一的名字，它拥有四个Cell，cell应该翻译成“槽”或者“域”，作用就是存储指向以上四个值的“指针”。symbol 名字定义的规则很简单，就是(quote name)或者'name，单引号+普通字符，遇到特殊的字符该转义的还是得转义，比如:

(symbolp '+1)  ;;==>nil
(symbolp '\+1)  ;;==>t
;;使用symbol-name获得名字
(symbol-name '\+1) ;;==>"+1"

求值规则和symbol

现在完全总结一下elisp里面的求值规则，一共三种： 1. 第一种就是自求值，数字、字符串、cons以及nil、t等会直接返回它所拥有的值。 2. 第二种是本节讨论的符号，符号虽然是使用了单引号这种形式，但它会根据不同环境或者“操作符”从cells里面返回不同值。 3. 第三种是列表求值，之前说的“遇到括号就返回”，如果在括号外围有quote或者单引号只会返回列表本身。也可以用(eval 表达式)方式来主动求值（evaluation），相当于抵消quote的作用。

;;下面两个表达式是完全相等的
(+ 2 3 4 5) ;;==>14
(eval '(+ 2 3 4 5)) ;;==>14

symbol组成

用(set (quote sym) val)可将值赋给一个符号，看起来太麻烦了，用(setq sym val)是同样的效果，其中val不能是自求值类型，占有一个符号中的cell只能是一个不能自求值类型。如果是自求值类型的话symbol不再是symbol而只是一个变量。 1. value cell的存储和取出

 1 2 3 4 5 6 7 8 91011

;;如果是基本类型直接赋值的话，根本不会当符号处理，因为它们返回自求值
(setq num 123)
(symbol-value num) ;;==>*** Eval error ***  Wrong type argument: symbolp,123
(symbolp num) ;;==>nil
(type-of num) ;;==>integer
;;但是将num这个变量使用quote的话，就变成一个符号
(setq sym—num 'num)
(symbolp sym-num) ;;==>t
;;symbol-value 的作用是从cell里面取出符号并进行eval
(symbol-value sym-num) ;;==>123
;;也可以先判断一个symbol是否已经绑定一个变量值

function cell 的存储和取出 lisp ;;使用symbol-function取出操作 (symbol-function 'car) ;;==> #<subr car> ;;使用fset将上节sym-num这个符号的function cell存储一个函数 (fset sym-num 'car) ;;==>car ;;fboundp来判断是否有绑定函数 (fboundp sym-num) ;;==>t ;;用funcall来调用 (funcall sym-num '(a . b)) ;;==>a

property list属性列表，属性列表为了变量和函数存在的，用来存储附加属性或者状态。形如(pro1 value1 pro2 value2…)。

 1 2 3 4 5 6 7 8 910

;;使用put 和 get 分配或者取出操作，貌似一次只能分配一次
(put sym-num :key "value1")
(put sym-num :color "blue")
;;":key"是一种特殊的符号，一般用在property list 和hash table 里面
(get sym-num :color) ;;==>"blue"
;;symbol-plist获取整个属性列表
(symbol-plist sym-num) ;;==>(group-documentation "The X Window system." :key "value1" :color "blue")
;;把symbol-plist单独提取出来自然可以用plist-get和plist-put操作
(setq my-plist (symbol-plist sym-num))
(plist-get my-plist :color) ;;==>"blue"

string 和symbol转换

值得一提的是，字符串和符号之间可以直接转换。

;;将symbol 转换成string
(symbol-name 'sym-num)
;;将string 转换成symbol
(intern "minecraft")

未完待续……

emacs完全补完计划(四)--API大考古

Fri, 19 Feb 2016 23:36:37 +0000

查找和学会使用API最好的方法是阅读官方文档，这篇文章着重讲一些emacs常用的概念和API惯用方法，之前提到的buffer、mode等都是从构架层次上来讲的，这次要具体的分析，所有编辑器的刚需都差不多，所以概念的东西都一样，重要的是如何使用。

如何查看内部文档？

emacs内部文档完整且条理清晰，这也是我投入到emacs的重要原因之一。使用M-x info或者默认绑定键C-h i，可以按分类阅读内置文档。或者按关键字索引文档，这么用M-x info-apropos，非常有用的命令，建议绑定一个常用快键键。进入文档后，以下是阅读文档的正确姿势：

按键	功能
SPC	下翻一页，可越过章节
BACKSAPCE	向上翻一页，可越过章节
b	跳到本章节开始处
n	下个同级章节
p	上个同级章节
]	下个章节
[	上个章节
u	父章节
q	退出
?	帮助列表

怎么测试运行elisp代码？

上图包含了elisp运行的方法，结合两个buffer，一个名为scratch，可以临时书写代码并运行查看结果；另一个为IELM，可按M-x ielm打开，和其他脚本语言一样用来REPL(read eval print loop)。下图演示了两者的关联。

其实这两个命令分别绑定 eval-print-last-sexp和eval-last-sexp，eval就是用来执行elisp代码的，以下是相关的函数：

函数	功能
eval-last-sexp	执行上一个elisp表达式
eval-print-last-sexp	执行并打印上一个elisp表达式
eval-defun	执行定义的函数（其实就是把定义的函数加入到当前emacs执行环境当中）
eval-region	执行选中的区域代码
eval-current-buffer	执行当前buffer所有代码

Emacs 中的术语

Emacs中有些术语过于古老（好魔幻的感觉），下图是对应现代编辑器的概念：

EMACS术语	现代概念	说明
Point	Point	光标位置
Buffer	Buffer	和其他编辑器的概念一样
Mark	select	选择一段文字
Region	selection	被选中的区域，Mark的作用结果
Windows	Windows	操作窗口
Yank	Copy	复制
Kill	Cut	剪切
Kill Ring	Clipboard	剪切板
fringe	gutter/margin	左右边栏
Font Locking	Syntax highlight	语法高亮控制
face	style	样式、装饰，涉及Font、color等
imenu	function list/symbol list	显示函数和变量的列表

Buffer

buffer是编辑器最基本的构成，其他部件都可以说是依附其上。又因为编辑器管理的是多个buffer，所以会有个buffer list，也有相应的列表函数，对buffer操作的函数应该最多。

buffer对象本身

有些函数能够望文生义，这里仅做记录，不做说明，如要使用参考自带文档即可：

函数	功能
buffer-list	省略
buffer-name	省略
get-buffer	省略
kill-buffer	省略
erase-buffer	省略
save-buffer	省略
rename-buffer	省略
set-buffer	省略
buffer-file-name	省略
previous-buffer	省略
next-buffer	省略

current-buffer 和 with-current-buffer (current-buffer)直接返回当前的对象，with-current-buffer则在当前buffer下执行代码，相当于把代码包含到当前buffer上下文内：(with-current-buffer buffer对象或者buffer名称代码)
generate-new-buffer：新建buffer对象，若已存在也会新建，则在同名的buffer基础加上递增的数字后缀。
window-buffer:获得窗口对应的buffer，(window-buffer &optional WINDOW)，输入的是window对象。

buffer文本操作

操作buffer里面的文本内容相关的函数： 1. buffer-string: 获得整个buffer的文本内容 2. buffer-substring 和 buffer-substring-no-properties:获得buffer某些区间的文本内容，后面返回纯文本内容，前者则包含了一些text专属的properties。 3. insert、insert-char、insert-string、insert-buffer-substring-no-properties:插入操作，根据后缀可以看出它们的不同用途。所有的插入，是根据当前buffer光标位置而言的。 4. insert-file-contens:插入某个文件的内容。

buffer中查找和替换

查找和替换难免会涉及到正则表达式，以后会详细说明，现在提有用到的函数： 1. string-match 搜索文本，(string-match REGEXP STRING &optional START)后面接着一个正则表达式和需要搜索的内容，最后参数可选择搜索的起始位置。 2. match-string以及match-beginning/match-end/match-data (match-string N) 返回上次正则查询的第N个分组的内容。(match-beginning N)获得上次正则查询第N个分组的起始字符，match-end同上。match-data以列表的形式返回上次查找的内容。 3. replace-match 替换操作，需要与其他的search类函数配合，替代search匹配的文本。 4. replace-regexp 以正则方式查找并替换。 5. looking-at (looking-at REGEXP) 一般用作判断文本是否存在。

save-current-buffer保存现场

(save-current-buffer 表达式)保存当前buffer，执行其中的表达式，完成后又回到原来的buffer。这个是常用的伎俩，还有两个类似的函数： 1. (save-excursion 表达式)执行完又回到原来的光标位置，随处可见。 2. (save-window-excursion 表达式)针对window的。

编辑操作

编辑操作基本上都是基于buffer的，这一小节完全可以归并到buffer里面讲，但涉及到的细节比较多，故而单独拿出来讲。

Point

光标位置的重要性不言而喻。

获得Point

函数	说明
(point)	返回当前的光标位置
(point-min)	buffer的最开始位置
(point-max)	buffer的最末尾位置
(line-beginning-position)	一行最开始的位置
(line-end-position)	一行最末尾的位置
(region-beginning)	被选中区域的开始位置
(region-end)	被选中区域的末尾位置

bobp(beginning of buffer predicate)用来判断是否在buffer头部，eobp(end of buffer predicate)用来判断是否在buffer尾部。
bolp(beginning of line predicate)用来判断是否在行首，eolp(end of line predicate)用来判断是否在行尾。

光标移动

goto-char:跳转到某个光标位置，(goto-char POSITION)，输入位置参数。
forward-char/backward-char/forward-word/backward-word/forward-line/backward-line:按单个字符向前或者向后移动；按一个单词向前或者向后移动；按行向前或者向后移动。
search-forward/search-backward:向前或者向后搜索字符串(search-forward Str)光标移动到Str末尾位置。
(re-search-forward Regex)/(search-forward-regexp Regex):同上，不过是用的正则查询。同理有：(re-search-backward myRegex) / (search-backward-regexp myRegex)
beginning-of-buffer/end-of-buffer/beginning-of-line/end-of-line:移动到buffer的起始位置或者末尾位置；移动到一行开始或者结束位置。

thing-at-point

thing-at-point是非常智能的识别当前光标所在位置的字符串类型，并返回这个字符串。比如：(thing-at-point 'email)，如果光标位于形如 xxx@xxx.com的任何位置，都将返回整个”xxx@xxx.com”字符串。
可识别的字符串类型：symbol',list’, sexp',defun’, filename',url’, email',word’, sentence',whitespace’, line',number’, `page’。
bounds-of-thing-at-point:以点对的形式返回可识别字符串两头的位置。

Region/Mark

region是选择后的区域，以下都是选择区域后的操作。 1. region-beginning / region-end:区域的开始位置和末尾的位置。 2. comment-region:注释region。 3. delete-region/kill-region:删除region。 4. indent-region:缩进region。 5. region-active-p:判断region是否活动。

Marker

Marker是标记，中文直接意译为马克，按自己定义的名称在某个地方标记一下，用来快速跳转不同位置： 1. make-marker:创建空的标记。 2. set-marker:设置标记的位置和缓冲区(set-marker temp (point))。 3. point-marker:得到point处的标记。 4. copy-marker:复制标记 5. maker-position / marker-buffer:得到一个marker的内容。

window

窗口对象，和操作buffer的函数相似。 1. selected-window:得到当前光标所在的窗口 2. window-list:当前frame的window列表 3. next-window/window-previo:windo-list里面向前一个window和向后一个window 4. delete-window/delete-other-windows:删除当前window/删除当前其他window 5. split-window:分割window 6. current-window-configuration:所谓的window-configuration是当前frame里面的window状态，有几个window，分割成什么样。 7. set-window-configuration:设置当前窗口配置信息。 8. walk-windows:遍历窗口 9. set-window-buffer:让某个窗口显示指定的buffer。 10. select-window:选择某个窗口。 11. window-live-p:判断窗口对象是否存在。 12. window-height/window-width

file、directory

文件和路径操作和buffer一样特别多，而且两者操作互相关联。

file和directory

函数	功能
find-file	查找文件
rename-file	重命名文件
copy-file	拷贝
delete-file	删除
copy-directory	直接拷贝目录
delete-directory	删除目录
make-directory	创建目录
write-file	将buffer内容写入文件
file-exists-p	判断file在某个路径下是否存在
file-readable-p	文件是否可读
file-attributes	返回文件相关的属性
set-file-time	设置文件的修改时间
set-file-modes	设置文件模式

从上面可以看出-p结尾的函数一般用来判断，p是predicate(谓词)的缩写，去掉-这规则也成立:

(numberp 45)   ;;==> t
(stringp "hello") ;;==>t
(symbolp 'buffer-name) ;;==t

file-name和directory

file-name-directory/file-name-nodirectory/file-name-extension:

(file-name-directory "~/wtx/tempfile.txt") ;; => "~/wts/"
(file-name-nondirectory "~/wtx/tempfile.txt") ;; => "tempfile.txt"
(file-name-extension "~/wtx/tempfile.txt") ;; => "txt"

(expand-file-name filename):得到绝对路径。
(file-relative-name FilePath dirPath):把绝对路径转换成相对路径，第二参数为相对的路径。
directory-file-name:获得目录名。
directory-files / directory-files-attributes:得到某个目录的全部或者符合正则表达式的文件列表directory-files-attributes返回文件列表里面的属性。

OS API(操作系统接口)

emacs可以与操作系统交互。

Commands 和 Apps

shell-command/async-shell-command:执行shell命令，等待shell命令结束或者异步。
shell-command-to-string:执行命令得带shell命令结束，并获取命令的输出: lisp (shell-command-to-string "pwd") ;;==>"/home/wtx\n"
shell-command-on-region:使用外部命令对所选择的区域进行处理。
call-process/start-process:调用外部程序；开始外部程序。前者同步的，后者异步的。
call-process-shell-command/start-process-shell-command:使用shell命令同步或者异步打开外部程序。

Environment Variables(环境变量)

getenv:获得当前系统的环境变量值 lisp (getenv "HOME") ;;==>"/home/wtx"
setenv:设置环境变量的值 lisp (getenv "JAVA_HOME" "/usr/local/java") ;;==>"/usr/local/java" (setenv "LANG" "en_US.UTF8") ;;==>"en_US.UTF8"
system-type:变量，指向当前系统类型。 lisp system-type ;;==>gnu/linux
process-environment:当前系统所有环境参数集合，是一个列表，遍历便可以单个变量的名称和相应的值。

emacs完全补完计划（三）——package的引入和管理

Tue, 02 Feb 2016 23:30:39 +0000

package说明

emacs中package（包）和其他编辑器一样，把一些功能或者特性包装成为一个package。

package存放在哪里？

有package那么肯定需要知道存放在哪里，现在公认有两个稳定的仓库分别是ELPA和MELPA，当然也可以去emacswiki或者github 上直接下载。下面的程序在emacs24以上的版本下有用，将它加入到init.el文件里面去：

 1 2 3 4 5 6 7 8 910111213

;;内置的package管理，emacs24以上的版本有用
(require 'package)
;;将melpa仓库地址加入到package-archives这个列表变量里面
(add-to-list 'package-archives
    '("melpa" . "http://melpa.org/packages/") t)
;;这个是国内一个elpa仓库镜像，速度更快一些，你懂得
(add-to-list 'package-archives 
    '("popkit" . "http://elpa.popkit.org/packages/") t)
;;初始化package
(package-initialize)
;;更新仓库里面的package
(when (not package-archive-contents)
  (package-refresh-contents))

如何下载和安装？

在emacs里面运行M-x package-list-packages，就进入package的下载界面。按 n 表示next，按i表示标记需要安装的包，按u表示取消标记，按x表示执行刚刚已经标记的包。比如想安装emacs里面的VIM模拟器evil，可以先用C-s向下搜索evil，找到后按i再按x就下载到本地了。然后打开emacs的配置文件init.el，在里面添加下面：

`12`	`(require 'evil) (evil-mode t)`

重启emacs就算安装完成了。每个包都会说明如何在init.el里面添加配置，各有不同，可以到网上查找它的说明，不过一般都是(xxx-mode)或者(xxx-mode t)。可以看到init.el路径下面多出了一个elpa文件夹，里面存放着我们刚刚下载过的package。

package加载机制的前世今生

在前面两节完全可以安装和配置package了，但是会遗留许多问题，第一就是不够灵活，如果这个package不在已有仓库上面或者我们自己编写了一个*.el文件如何加到emacs配置里面？如果有很多个*.el文件分布到各个文件夹里面如何管理？如果有几个包是相互引用的，如何确定它们的加载次序？每次启动emacs的时候都全部加载会严重拖慢启动速度，怎么解决？怎么将一个自己写的某个函数挂载在某个package上面？要解决这些，我们需要了解emacs中引入package的内部机理。spacemacs有一篇写的很不错的emacs加载机制的文章，下面的内容相当于翻译加上自己的一些理解。

load-file

最简单粗暴的加载方式：

`1`	`(load-file "~/elisp/foo.el")`

这是最为原始的方式，填写的路径必须是绝对路径，这个路径也不会加入到emacs中load-path里（后面会提到）。它也不会优先寻找编译过.elc文件（显然编译过文件的会更快些）。这种方式已经被抛弃，仅作为历史提一下。

Features

Features(特性)是emacs默认的另外一种常见的加载方式。相当于在xxx.el文件里面先注册，后在init.el里面引入，需要双方互相约定的协议。比如我编写了一个名为my-feature.el的文件，提供某些功能想加入到emacs里面，先在这个文件最底下写：

`12`	`;; Your code goes here ... (provide 'my-feature)`

其中provide（提供）就是所谓注册，后面跟的参数一定要和当前文件名一样。然后再init.el文件里面加上：

`12`	`;; Your code goes here ... (require 'my-feature)`

那么在启动emacs之后会从一个叫features的列表里检查my-feature这个feature有没有存在，没有会查找叫做my-feature.el或者my-feature.elc文件，加载它，如果没有找到会提示错误。实际上这个机制可以让各个package根据require 出现在init.el文件里的顺序来加载的，一定程度上解决了package之间的相互依赖的关系。在这里还有个问题，features机制提到会自动查找.el和.elc文件，那么它会在哪里查找，总不能搜寻硬盘里面的所有位置吧。所以需要一个列表来管理这些位置，名叫load-path，跟电脑里面的环境变量相似。

`1`	`(push "/some/path" load-path)`

相当把某个路径添加到load-path里面了。可以用来管理分布在多个不同路径下的.el和.elc文件。之前从elpa或者melpa下载安装package其实已经自动把下载的package路径加入到了load-path里面，所以可以直接使用require来配置包。

Auto-loading

使用require机制可能比粗暴load-file高明那么一丢丢，它解决了package加载顺序的问题，还有管理不同地方的elisp文件。但是它的加载方式也是比较暴力，每次emacs启动会全部一次性加载能查找到的所有文件，这将导致emacs的启动速度大大减慢。 auto-loading就是为了解决这种情况而诞生。你可以向emacs中注册一个函数，只有当调用或者使用这个函数的时候，包含这个函数的文件才会加载。这么用：

`1`	`(autoload 'some-function "some-file")`

当调用some-function 时，加载some-file.el，再执行这个函数。autoload完整参数：(autoload FUNCTION FILE &optional DOCSTRING INTERACTIVE TYPE)，可以看出它除了提供加载文件地址外，还可以编写说明文档，在不加载文件时也能够查看它的用法。 autoload这种方法可以写入的到emacs配置文件里面，但明显不好管理，为什么不在函数定义处就指明它是一个autoload形式的函数呢？事实上可以用所谓的”魔术”注释来装饰一个函数的开头，让它autoload。

;;;###autoload
(defun my-function ()
  ;; Source code...
  )

;;;###autoload是一种神奇的注释。当然autoload这种机制不局限于函数，可以用在一切可以定义的东西上面，比如宏、主模式、次模式等等。

Eval after load

当我们加载一个package的时候想配置它，比如绑定一个自定义的函数等等。为了能够让我们的自定义的代码也autoload，使用with-eval-after-load。

(with-eval-after-load 'helm
     ;; Some-Code
     )

当helm这个package加载后，some-code将接着执行，不管是使用features机制还是autoload机制。在emacs24.3方能使用with-eval-after-load，之前版本使用eval-after-load。

Use-package

Use-package是一个第三方的package，使用前需要安装。Use-package可以说是为了解决之前提到的所有问题而出现的。Use-package是一个宏，来看看它是怎么使用的：

`1`	`(use-package helm)`

最简单的加载，等同于(require ‘helm)。

`12`	`(use-package helm :defer t)`

:defer是个关键字，如果为t，则表示helm的里面的凡是被autoload的函数、宏、模式等都成立。

(use-package helm
  :defer t
  :init
  ;; Code to execute before Helm is loaded
  :config
  ;; Code to execute after Helm is loaded
  )

增加了两个关键字:init和:config，顾名思义，针对package加载之前和package加载之后添加一些自己的配置。在:init中可以加载一些入口设定，比如定义一些按键调用这个package里面的函数。:config关键字后面的代码和with-eval-after-load功用是一样的，都是package实际被加载之后才会执行。 use-package还有很多关键字，比如指定某些条件下才会加载package，可以指定某些特定文件才加载这个package，可以进官方文档自行查看。

org-babel-load-file

org是和markdown一样是一种格式标记文本形式，可以用来编写文档的，但它比markdown厉害得多，提供功能更齐全，其中一种功能是将org里面编写的程序放到org-babel（org文件的某个块区域）里面，和markdown仅仅用来展示程序不同，org-babel里面的程序可以用org-babel-load-file来执行。

`1`	`(org-babel-load-file "~/.emacs.d/config.org")`

意味着你可以在一个org文件里面写出emacs的配置和相应的说明，是一种高效管理emacs配置的方式，初次听说还蛮刷三观的。不过因为加载速度的原因没能完全流行起来，不过还是有一些emacser坚持使用这种方式。

小结

use-package渐渐一统以前古老的配置方式，许多知名的emacser用这个包将自己的配置又重新写了一遍。因为它既包含了现有的所有定义方式又提供了许多关键字，让配置一个package简单易行，而且可以将所有的包都变成了延时加载，只有使用的时候再加载，大大加速了emacs的启动速度。懂得以上所有的emacs加载机制后，基本上自己动手配置一个emacs配置不成问题。下篇文章会提到emacs能提供给我们的常用API。

附录

几个对新手友好的包

better-defaults:正如其名，是更好的默认emacs小设置。
which-key:按键提醒，当你按一个按键的时候，会弹出之后所有可能的按键以及说明。
swiper:增强搜索和minibuffer的交互，包括一些模糊搜索。
evil-mode和evil-leader：vim党专用，emacs上的vim模拟器，功能十分完整，请自行搜索配置。

本文参考

emacs完全补完计划（二）——简单配置和设置

Mon, 01 Feb 2016 23:34:00 +0000

我们在谈论lisp的时候谈论什么？

很多emacs教程都想避开Emacs Lisp(下面简称elisp)，完全不可能，反而学习过程中会磕磕碰碰。其实lisp作为一个古老的语言，语法上确实相比现代语言看起来看起来怪异很多，但并不落后，反而有独到之处，简洁易懂。在函数式编程复兴的浪潮中，去了解函数编程的始祖显得意义非凡。之后的内容在配置过程中不断回顾elisp的语法和用法，先提三点：

操作符前置

程序的本质是什么，无非是数据本身和操作数据过程。lisp把操作数据的“操作符”前置了，比如平常计算多个数加法的时候用 1+2+3+4+5，lisp这样做： (+ 1 2 3 4 5)，括号是lisp的特性，左括号的往右的第一个字符就是所谓的“操作符”，用空格来区别不同的参数。这样做有什么好处？现代语言因为更偏向自然语言，操作符的位置更加灵活，比如调用一个方法的时候：object.method(args)，方法需要一个对象支撑，自己变成了附庸品，后置了；几乎所有连接字符串都可以这么操作："HE"+"LLO"+"WORLD"，操作符+位于中间；还有最后一种情况，常见的 Assert statement 或者内置函数调用 ABS(num)又把操作符前置了，在操作符使用过程中混乱不协调，容易迷惑然后出错，所以灵活也有它的弊端。括号和操作符前置两个特性让lisp独特而优雅，组成了为人称道的S-expression(S表达式)，以后还会提及它的好处。

数据结构

将操作符前置是高度统一又美好理想的理念(别给我扯汇编)，因为纯数据的存在导致不可能所有括号里面的最左边都是操作符。lisp其实叫做列表处理语言，这里就引出了lisp里面最基础的数据结构–list，还有它的组成元素atom(原子)。其实我们已经见过了list就是(+ 1 2 3 4 5)，只有在括号括起来的表达式就叫做一个list，里面的元素只要不是另外一个list就叫做原子(atom)，意为不能再分解的意思。那么纯数据该怎么表示？像这样(1 2 3 4 5 )，显然不符合操作符前置的原则，会报错说找不到名为1的函数，于是考虑再三就把操作符扩充到了括号之外，变成'(1 2 3 4 5)表示整个括号里面不执行，直接返回整个list。像(+ 1 2 3 4 5)这样的list会执行，返回值为15；而'(+ 1 2 3 4 5)会直接返回(+ 1 2 3 4 5)本身。

返回机制

上面提到了返回，在其他大部分的语言里需要一个关键字return来实现，而lisp只要遇到括号就代表自动返回值，可以执行括号内容后返回，也可以根据括号前面的'单引号只返回括号本身。这时候就有人想在返回的时候部分内容能够执行就好了，比如(5 (* 2 5) 15 20)，如果返回的时候里面的表达式(* 2 5)能直接执行的话整个表达式就能返回(5 10 15 20)这样的数列。于是就有人想出了用外层的括号来控制内层的括号，变成`(5 ,(* 2 5) 15 20)，外层加个反引号内层加个逗号就能返回以5为倍数的数列了。

配置文件位置

在linux 下，sudo touch ~/emacs.d/init.el，其中init.el文件是emacs 配置文件，用elisp写的文件都以el为拓展名。在window下新建一个文件夹C:\Users\username\AppData\Roaming\.emacs.d，其中username为本机的名字，在这个文件夹下新建一个init.txt，把它改为init.el即可。

常见配置方法

在这节只会提及一些elisp常见的关键字，这些关键字经常会困扰着新手，首先要知道elisp用-来连接声明不同功用的变量名和函数名的。

`nil` 和 `t`

nil和t在elisp里面分别代表着false和true，用单个字母t来代表true让人措手不及。和其他语言一样，正整数也表示true，负整数表示false。

`require`

顾名思义它的作用就是引用包，后面一般加着包名，至于具体的设置和用法会在下一篇文章详细分析，只要知道它和其他语言中的import，require一样把其他模块或者包的上下文空间引入当前文件下。

`setq`

setq作用是赋值，一般这么用(setq variable value)，比如(setq kill-ring-max 200)让emacs剪切板存放的条目数上限为200。

`add-to-list`

添加一个元素到某个list里面，这样用(add-to-list LIST ELEMENT)。也可以看出除了用单个变量来控制某种配置外，emacs里面还存在各种list这种容器式数据结构，用来映射或者存放一组变量。

`add-hook`

添加钩子，比如(add-hook ‘window-setup-hook ‘toggle-frame-maximized)，作用是当window启动的时候frame最大化。在添加钩子的时候要查看是否有以-hook结尾的函数。

`global-set-key`、`define-key` 以及`kbd`

kbd是一个宏，至于什么是宏，我们先暂按不说，它的存在就是为简化定义一系列按键输入（键序列），比如(kbd “C-x C-f”)会返回control+c 然后control+f的输入操作。global-set-key用来定义按键绑定的函数，之前提到过emacs里面的任何操作都是由一个或者多个函数组成，结合上面的kbd宏，emacs这样定义的一个按键的功能——(global-set-key (kbd "C-x C-f") 'find-file)。那么define-key又是什么？global-set-key显而易见是用来定义全局的，针对于整个emacs而言的，污染性太大，define-key则用来定义针对某个mode才有的按键，也就是说当我们进入到某个mode的时候这个按键才生效。常见用法(define-key keymap function)，keymap保管了key和function的映射表，一般每个mode都会提供了一个keymap用于用户自定义。如果不知道自己输入的键序列在kbd里面是怎么写的，可以使用C-h k来查看有没有此键序列的绑定，如果没有绑定任何的函数会返回这个键序列本身，就是写入kbd里面的内容。

一份通用配置说明

这份配置几乎可以说是最基本的配置，没有安装其他的package，仅仅是内置和外观方面的设置。

 1 2 3 4 5 6 7 8 9101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657

;;禁止菜单栏
(menu-bar-mode -1)
;;禁止显示工具栏
(when (fboundp 'tool-bar-mode) (tool-bar-mode -1))
;;禁止显示滚动条
(when (fboundp 'scroll-bar-mode) (scroll-bar-mode -1))
;;禁止emacs一个劲的叫
(setq visible-bell t);
;;在console，不想看到屏幕不停的闪
(setq ring-bell-function (lambda () t))
;;关闭启动是的那个“开机画面”
(setq inhibit-startup-message t)
;;设置剪切板最大条目数为200
(setq kill-ring-max 200)
;;一行显示最多显示80列
(setq default-fill-column 80)
;;缺省的major-mode为text-mode
(setq default-major-mode 'text-mode)
;;括号匹配时显示另外一边的括号
(show-paren-mode t)
(setq show-paren-style 'parentheses)
;;显示语法高亮
(global-font-lock-mode t)
;;设置编码
(set-buffer-file-coding-system 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-16-le)
(set-default-coding-systems 'utf-8)
(set-clipboard-coding-system 'utf-8)
(set-language-environment "UTF-8")
(prefer-coding-system 'utf-8)  
(set-file-name-coding-system 'gb18030)
;;内部有个自动补全功能，根据当前buffer的内容、文件名、剪切板等自动补全
(setq hippie-expand-try-functions-list
      '(
        try-expand-dabbrev
        try-expand-dabbrev-visible
        try-expand-dabbrev-all-buffers
        try-expand-dabbrev-from-kill
        try-complete-file-name-partially
        try-complete-file-name
        try-expand-all-abbrevs
        try-expand-list
        try-expand-line
        try-complete-lisp-symbol-partially
        try-complete-lisp-symbol))
;;按ALT+/ 键进行补全
(global-set-key (kbd "M-/") 'hippie-expand)
;;用ibuffer替换默认的buffer管理器
(global-set-key (kbd "C-x C-b") 'ibuffer)
;;用正则搜索替换默认搜索
(global-set-key (kbd "C-s") 'isearch-forward-regexp)
(global-set-key (kbd "C-r") 'isearch-backward-regexp)
;;一个好用的minibuffer插件ido，许多插件都基于它。
(ido-mode t)
(setq ido-enable-flex-matching t)

可以看出除了数字、nil和t之外所有的值都需要加'来传值，如果不加表示执行这个值，加了表示只需要返回它本身的字符。

内置的自定义方法

显然虽然可以通过package说明来定义配置，但每个package包含了大量的自定义变量或者函数，使用M-x customize则会出现一个buffer列出了可自定义的类别，进入每个类别当中，又有各个package的名字，再随便选择一个package的名字就会展开这个package可定义的变量或者函数，每个条目都包含了此条目的说明以及现有默认的值。

比如M-x customize，进入 Faces这个用来配置emacs外观的配置组，再深入到Basic Faces，就可以看到一系列的变量和函数，接着选择 Cursor face(用来配置光标外观的)，在最左边按下enter键，就会展开一个Choose按钮，点击则会列出各种颜色，随便选一个，选完点最上面用apply或apply and save两个按钮，光标的颜色就变成了刚刚选取的颜色。其实打开init.el文件也可以看到文件末尾增加了两个函数，也就是说在emacs内置的自定义操作最后还是以文字的形式保存到了init.el里。增加的函数如下：

 1 2 3 4 5 6 7 8 9101112

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 )
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(cursor ((t (:background "DarkOliveGreen1")) (t nil))))

本文参考

emacs完全补完计划（一）——嘴炮和入门

Thu, 28 Jan 2016 00:25:08 +0000

交代一下背景，笔者在接触emacs之前只写过C，只使用过芯片厂商提供的开发环境，没有真正使用过IDE(Integrated Development Environment)，可以说是从零开始接触emacs。当然并不是一时的心血来潮，而是为了成为更好的程序猿，在不断接触linux、VIM、git过程中偶然接触了一门名为Lisp 的语言，其实也不算是偶然，而是买了一本名叫SICP的”编程入门书”，被Lisp的优(qi)雅(pa)语法深深吸引了，后来又听说emacs是用lisp一种方言作为拓展语言的，禁不住网上各种推销就去学习了被誉为神之编辑器的emacs。真是一步一坑，从此走上了一条不归路…这一系列文章被称作教程，不如说是个人学习emacs经历总结回顾。

你为什么需要一个编辑器而不是IDE?

这个问题显然又会引发无数口水，因为接触IDE的时间不多(后来试着使用过VS2015和pycharm一段时间)，可能不具有太多的发言权。但结合我浅薄的经验和网上的各种说辞来看，一个集成开发环境的编辑器相比IDE有一下几点优势：

编程是输入活儿，编辑器可以做到双手不离键盘，所思即所得。
编辑器有灵活的拓展性，可以根据自己的需求个性定制添加插件，提高自动化程度，省去人工时间。
免费，大部分的编辑器都是开源的：VIM、Emacs、Atom；轻量级，打开速度快。这两点都是相对IDE而言的。
编辑器的操作和工作流一旦固定，可以继续在已有的基础上配置一门语言的开发环境，不用再为了学习一门语言去适应新的IDE。
成为更优秀程序猿，老一代的前辈总是告诫我们说IDE封装好太多东西了，自己用编辑器配置一个开发环境会学到很多，其实说来说去就是为了–装逼~
当然纯粹用编辑器编程也有很多的缺点，比如在大型工程上功能无力、对一些高级语言支持不够比如java、跳转不准确、对菜鸟不友好完全没图形界面来的方便、入门门槛太高，可能还要为此学习一门语言等等。就本人经验而言，你需要一颗生命不止折腾不休的心，期间会消耗大量的时间，需要持久的忍耐力，但是浪费的时间会有更高的回报，一旦修炼完成工作效率会成倍的提高，是一桩不会亏本的买卖。

为什么是emacs?

原因之一是Lisp，一门古老而有趣的语言，对当代语言有深远的影响，不管作为菜鸟还是大牛都应该找个时间了解一下它。emacs对所有Lisp系的语言的支持都非常好。而且Emacs Lisp作为一门语言完整而强大，极大增强了emacs的拓展性以至于emacs被戏称为一个操作系统。
第二Org-mode，它可以像Markdown一样为你的项目写文档，也能够以纯文本的格式进行GTD，进行时间管理和自我管理。这是很多人转向emacs的原因。
其三evil-mode，一个emacs上的VIM-simulation,很多人学会了VIM之后体会到了它在编辑上的高效，在各个地方都装上了VIM模拟器——浏览器、IDE的插件等等。evil-mode模拟VIM比其他任何一个都要完整，因为它可以自己制定命令，而且还有从VIM移植过来的插件evil-matchit、evil-nerd-commenter等。可以说emacs为人诟病的按键低效也被evil弥补了。
最后是magit，这是个人私心加上的，magit是emacs上git的一个插件。对于git因为其强大的功能在操作的时候显得过于繁琐，总是有各种各样的命令和选项记不住，通常做法是在命令行上自定义别名，但是别名增多又会遗忘。magit按键定义高效而清晰，又提供了”半图形”的界面，内容对比、日志查看等都可以在编辑器里完成。

作为一个普通的编辑器？

当初对编辑器的印象停留在notepad++ 上，作为一个稍微高级一点的编辑器，基本上都具备以下功能：

能够使用一套自定义的快捷键来编辑文本，熟悉之后会行云流水。
有行号、可以缩进、注释、显示块级，可以展开或者折叠块级。
可以选择编辑的不同语言，比如C、python、JavaScript等。
语法高亮提示。
可以同时打开多个文件，以选项卡的形式陈列。
能够显示工程的文件树。
选择文件编码。
简单的自动完成。
搜索、替换、书签。
甚至能够运行程序。
添加插件、进行简单的主题变换等等。
启动速度极快。

所有”高级”编辑器都有以上的特性，包括一些概念也是通用的，我们暂且不讨论在终端下的编辑器，以下概念以图形界面的编辑器为主。

文件(file)和缓冲区(buffer)

当用一个编辑器打开一个文件时，这个文件就会变成一个buffer，顾名思义把打开文件的过程就是把它丢到内存里面，buffer是内存里文件形式。

窗口(window)和外框架(frame)

window是用来显示buffer的，一个window一次只能显示一个buffer，但是一个buffer可以在多个window中显示。buffer可以不显示出来，隐藏在window之外，隐藏在冰山之下，所以这两者并不是绝对联结在一起的，因为一个是可视的实物，一个只存在于深深的内存中。外框架（frame）就是用来管理window的，一个frame可以分割成不同的窗口。我们平常打开一个编辑器就是打开一个frame，通过管理window来管理不同的buffer，每个buffer又对应着不同的文件。一层一层来达到同时编辑多个文件的目的。

作为再高级的编辑器？

再高级一点，我们的目的就是能够配置成一个写程序的环境。

主模式(major-mode)和次模式(minor-mode)

emacs 是通过modes这种形式来配置不同语言环境的。mode中文翻译为模式，这和vim中的模式是完全不一样的概念。一个buffer可以分为major-mode(主模式)和minor-mode(次模式)，比如当打开一个*.md文件时主模式就变成了markdown-mode，再打开一个*.py文件时主模式会自动切换成python-mode，一个buffer只会有个主模式。而次模式会有很多种，分别实现了一些通用的功能比如各个语言的缩进处理、拼写错误检查、语法错误检查、智能匹配成对的特殊符号等等。显然一个major-mode可以挂载无数多个minor-mode。

mode-line和minibuffer

上一节我们讲到了mode，为了显示当前主模式和次模式的信息，会在当前buffer 的下边多加一条显示栏，这就是所谓的mode-line，这和vim是一样的。不过mode-line已经被玩出各种花样不仅限于显示当前mode信息，可以显示buffer内容的进度，显示时间，显示一个倒计时，显示当前文档的git分支(如果该文档是用git进行版本管理的话)等。minibuffer在emacs的最底下，当执行一些命令时会跳出提示，比如保存一个buffer 的时候会显示保存的路径，搜索的时候minibuffer会等待你的输入，打开文件的时候会列出当前的路径下部分文件名等。总而言之就是用户与emacs交互的窗口，这种联系就如同shell跟操作系统的关系一样，除了编辑文件你大部分的时间都是在minibuffer里面和emacs交互。

一图胜千言

这张图概括了前面提到的所有概念

基本操作概念

emacs里面每个操作都对应着一个命令，一个命令意味需要一个或多个函数来支持，即使像最简单的向前移动一个字符，都是一个名叫forward-char的函数实现的。

按键说明

emacs因为其古老悠久的原因，许多按键说明没有跟上现代键盘的发展的脚步。以下会提到的和我们现在所用键盘按键的对应关系。

按键	名称	实际对应的实体键
M	Meta	Alt
A	Meta	Alt
C	Control	Ctrl
S	Shift	Shift
SPC	Space	Space

经常会看到C-x 其实同时按control键和x键，C-x C-s就是同时按control和s键后又同时按control和s键。其他同理。一些常见按键前缀约定：

前缀按键(key)	功能
C-x	触发系统默认的功能
C-c	默认留给用户自定义
M-x	触发minibuffer，等待用户输入需要运行的命令
C-g	取消运行的命令(这个命令很有用)

帮助

control + h 键是帮助命令前缀按键，前期对新手的帮助非常大。

按键	功能
C-h a	模糊搜索关键字帮助
C-h i	阅读内置info帮助文档
C-h f	查找一个函数信息
C-h v	查找一个变量信息
C-h m	查找一个模式信息
C-h b	查找当前的buffer的按键绑定
C-h k	查找一个按键的绑定信息

key、hook、map

这三个概念会不断的出现在定制emacs的过程当中，从上两节了解到key其实就是按键，map中文意思是映射，一个map就是一个按键与一个函数或者多个函数成关系映射。hook中文解释为钩子，顾名思义，一般用在将某个minor-mode挂载到某个major-mode上面，也可以将某个函数挂载在某个mode上面。

emacs官方自带指南

接着安装emacs，网上都有在不同系统下的安装教程，这里略过不提。知道了上面的这些就可以按C-h t 进入官方指南，按照指南操作emacs，大概在半个小时内操作一遍。VIM党可以跳过这一步。完成之后emacs算是基本入门了。

本文参考

Org-mode个人总结

Mon, 25 Jan 2016 22:48:14 +0000

这是一份个人总结，并不能带你入门，我也曾尝试些一个教程，但不自信比这个中文教程好：Org-mode 简明手册，翻译官方的 mini manual，有个最佳实践 organize your life plain text。Org 用来做 GTD 是极好的，它的绝对优势就是完全是纯文本的，所有的格式状态都是由一些符号和特殊字符组成，不依赖于任何的数据库，而且可自定义的东西太多，因为是纯文本的，许多格式定义可以都涉及到一些程序通用的表达式，对于程序猿是非常友好的，但对于普通人需要一定的学习成本。本文提炼了Org常用的功能和设置，作为备忘记录。

强调

强调基本和其他的富文本的格式相同，有时会忘记，先记下：

*粗体*
/斜体/
+删除线+
_下划线_
下标：H_2 O(这里必须留一个空格要不然 2 和 O 都成为小标，目前还不知道怎么去掉空格)
上标：E=mc^2
等宽字：  =git=

视图

稀疏疏

主要是针对本文件

按键	说明
C-c /	稀疏树的创建命令
C-c / r	其中一项，会提示输入匹配串，所有的匹配项都会高亮

议程视图

调用命令：M-x org-agenda，然后会有提示执行对应的命令

周/日议程
全局 TODO 列表
匹配标签和属性
单文件的时间轴
查找视图

转移

归档

命令:M-x org-achive-x，可以为 subtree,file 甚至 agenda 等等当一个条目完成时想从当前项目去除的时候，可以定制归档地址

转送笔记

命令:M-x org-refile，refille 可以顾名思义，重新定义当前条目的 file 归属一个条目转移到另外一个工程里面时可以用到转送，同样可以定义转送目标地址

捕捉

M-x org-capture 在编辑过程中突然冒出一个想法，可以用这个中断当前的工作，可以通过自定义模板定义分类和地址

时间戳

时间戳是一个具有特定格式的日期，可以出现在树条目的标题和正文的任何地方。

最简单的：时间+时间
时间按规律重复：N 天（d）、周（w）、月（m）、年（y），会在时间点后面加个尾巴，称作中继器，比如： <2015-07-29 周三 +1w>

注意看后面的+1w，代表每个周（w）都要重复，直到<2015-07-29 周三>为止，在 weekly agenda 里面查看时候会一直有这一项
时间/日期段连续输入时间戳的时候自动生成一个时间段 <2015-07-29 周三>–<2015-09-01 周二>
非激活的时间戳跟普通的时间一样，只不过它不被激活，即不会出现在议程当中关于时间戳的快捷键：

快捷键	描述
C-c .	创建时间，如果连续使用则会自动将两个时间连接成时间段
C-c !	未激活的时间戳
S-left/right	改变时间戳的一天
S-UP/DOWN	将光标置于时间戳的年月日之上，则修改相应时间

快捷键	描述
C-c C-d	在标题下面插入”DEADLINE”关键字的时间戳
C-c C-s	同上，为”SCHEDULED”

快捷键	描述
C-c C-x C-！	开始计时（CLOCK-IN), 加 C-u 前缀，从当前计时的任务当中选择任务？
C-c C-x C-o	停止计时（CLOCK-OUT),会计算时间在时间段后面插入
C-c C-x C-e	为当前计时任务更新进度
C-c C-x C-x	取消计时
C-c C-x C-j	跳转到当前计时的任务条目
C-c C-x C-r	插入 org 表格统计计时报告
C-c C-c	如果有上面的计时报告则更新它，需要置于首行，即#+BEGIN:

常用的可以自定义的函数或者变量

org-startup-folded，设置为 t 默认打开文件的时候自动展开折叠
org-log-into-drawer 和 org-todo-keywords 前者可以跟踪 TODO 条目状态变化 WAIT(w@/!) 注意看括号里面，w 代表改成 WAIT 状态时候的快捷键，”!”代表转变状态的时候会做一个时间戳，”@”代表做一个一个记录。所以改为 DONE 的时候会有时间戳，CANCELED 会有一个记录后者则定义除了 TODO 和 DONE 外的状态：
1234

(setq org-todo-keywords '((sequence "TODO(t)" "|" "DONE(d)") (sequence "REPORT(r!)" "BUG(b)" "KNOWNCAUSE(k)" "|" "FIXED(f)") (sequence "|" "CANCELED(c@)")))
其中用”|”来分割不同的状态，同样可以使用”!”和”@”语法，上面的转变成 REPORT 会有时间戳在条目下面
org-tag-alist 指定 tag 值免得每次都要重新输入一大堆的东西，此为 alist，可以用相关的 list 函数添加: 其中?w 就代表字母 w,当你改变或者新增 tag 的关键字，按下 w 则，会输入”@work”的 tag
1

(setq org-tag-alist '(("@work" . ?w) ("@home" . ?h) ("laptop" . ?l)))
org-tags-match-list-sublevels 用于定义议程文件匹配的标签一个全局列表
org-refile-targets 设置转送笔记的目标地址
org-archivelocation 设置归档位置
org-agenda-files 设置议程文件

org-capture-templates 设置捕获模板

(setq org-capture-templates
'(("t" "Todo" entry (file+headline "~/org/gtd.org" "Tasks")
"* TODO %?\n %i\n %a")
("j" "Journal" entry (file+datetree "~/org/journal.org")
"* %?\nEntered on %U\n %i\n %a")))

定义两个模板

org-agenda-custom-commands 自定义议程视图搜索
1234

(setq org-agenda-custom-commands '(("w" todo "WAITING") ("u" tags "+boss-urgent") ("v" tags-todo "+boss-urgent")))
第一项为关键字，可以选择范围 tags 或 todo 项，最后为搜索关键字搜索字符串可以使用 ‘&’ 作与运算， ‘|’ 作或运算。‘&’ 的约束力比 ‘|’ 的强
org-startup-indented 缩进相关
org-structure-template-alist 定义元数据的模板，下面为默认模板:
1

("e" "#+BEGIN_EXAMPLE\n?\n#+END_EXAMPLE" "<example>\n?\n</example>")
其中”e”代表你<e 时候会自动补全接下的内容，最后也可以看出元数据其实是定义了一些 html 节点，其中”?”为内容的占位符。
(setq org-agenda-start-day “+2d”)可以显示未来两天的议程。

org-todo-keyword-faces 可以定义 TODO 状态的颜色显示各种显示等

(setq org-todo-keyword-faces
  '(("TODO" . org-warning)("STARTED" . "black")
  ("CANCELED" . (:foreground "yellow" :weight bold))))

git使用小结

Sun, 24 Jan 2016 23:40:05 +0000

git 一些原理和概念

在本地有三个区域：工作区，staged 区以及本地仓库，当然还有一个抽象的概念的就是分支
远程有：远程仓库和分支
HEAD 是个指针，指向 git 自动帮我们创建的第一个分支 master。master 才指向提交的，提交到远程 > 几乎所有的操作的都是基于以上的区域的，值得一提一点：本地的 git 仓库和 github 仓库之间的传输是通过 SSH 加密的

git初始化

git init在目录下面新建一个git 仓库

git 添加操作

git add 添加到 staged 暂存区，加入也意味着可以 track 追踪文件的变化状态，可以是git add “file name”或者添加整个目录git add .
git commit 提交到本地的仓库的当前分支，加参数-m(message)添加提交信息，-a(all)则省略add操作直接提交到仓库。
git push origin master 提交到远程仓库的默认库的 master 分支
git push -u origin master，把本地库的内容推送到远程，用 git push 命令，实际上是把当前分支 master 推送到远程。由于远程库是空的，我们第一次推送 master 分支时，加上了-u 参数，Git 不但会把本地的 master 分支内容推送的远程新的 master 分支，还会把本地的 master 分支和远程的 master 分支关联起来，在以后的推送或者拉取时就可以简化命令。git push origin master

git 查看操作

git log 查看提交历史，–pretty=oneline 每个版本信息放到一行显示，分支历史也可以用这个命令查看
git reflog 可以查看命令历史，re-reset 操作可以从其中找到 ID,恢复到最新版本
git status 查看一下现有状态，针对本地库
用 git diff HEAD – file 命令可以查看工作区和版本库里面最新版本的区别，git diff什么都没加表示查看当前repository与暂存区的差别。
用 git log -–graph 命令可以看到分支合并图

git 还原操作

git checkout –file 其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”
命令 git rm 删掉，并且 git commit，此为彻底删除操作
用命令 git reset HEAD file，git reset 命令既可以回退版本，也可以把暂存区的修改回退到工作区。当我们用 HEAD 时，表示最新的版本
head 为当前版本，head^是上一个版本，head^^是上上个版本，用 HEAD~100 代表 100 个版本之前 git reset –hard HEAD^回到上一个版本，git reset –hard ，加 ID 比较通用，HEAD 就指向那个 ID 了

git 分支操作

git checkout -b dev，git checkout 命令加上-b 参数表示创建并切换 dev 分支
dev 分支的工作完成，我们就可以切换回 master 分支：git checkout master
用 git branch 命令查看当前分支
git branch -d dev 用来删除 dev 分支操作
git merge branchname 命令用于合并指定分支到当前分支准备合并 dev 分支，请注意–no-ff 参数，表示禁用 Fast forward。通常，合并分支时，如果可能，Git 会用 Fast forward 模式，但这种模式下，删除分支后，会丢掉分支信息。比如 git merge –no-ff -m “merge with no-ff” dev
如果要丢弃一个没有被合并过的分支，可以通过 git branch -D 强行删除
git-rebase +命令主要用在从上游分支获取最新 commit 信息，并有机的将当前分支和上游分支进行合并,可能会出现冲突
git checkout - 切换回上一个分支。

git 远程操作

git clone [url] 克隆一个远程仓库到本地
当你从远程仓库克隆时，实际上 Git 自动把本地的 master 分支和远程的 master 分支对应起来了，并且，远程仓库的默认名称是 origin
查看远程库信息，使用 git remote -v；git remote add [url]本地仓库关联远程分支，url就是网络仓库地址如git@github.com:LonglyCode/LonglyCode.github.io.git；
从本地推送分支，使用 git push origin branch-name，第一次推送最好加上-u参数；如果推送失败，先用 git pull 抓取远程的新提交；
在本地创建和远程分支对应的分支，使用 git checkout -b branch-name origin/branch-name，本地和远程分支的名称最好一致；
建立本地分支和远程分支的关联，使用 git branch –set-upstream branch-name origin/branch-name；
从远程抓取分支，使用 git pull，如果有冲突，要先处理冲突。
git fetch：相当于是从远程获取最新版本到本地，不会自动 merge,= git pull 相当于 git fetch + git merge =

git 标签操作

Git 的标签虽然是版本库的快照，但其实它就是指向某个 commit 的指针（跟分支很像对不对？但是分支可以移动，标签不能移动），所以，创建和删除标签都是瞬间完成的
命令 git tag 用于新建一个标签，默认为 HEAD，也可以指定一个 commit id；
git tag -a -m “blablabla…”可以指定标签信息；
git tag -s -m “blablabla…”可以用 PGP 签名标签；
git tag 可以查看所有标签；
git push origin 可以推送一个本地标签；
git push origin –tags 可以推送全部未推送过的本地标签；
git tag -d 可以删除一个本地标签；
git push origin :refs/tags/可以删除一个远程标签

MISC

Git 还提供了一个 stash 功能，可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作，你可以多次 stash，恢复的时候，先用 git stash list 查看，然后恢复指定的 stash，git stash pop 用来恢复，恢复的同时把 stash 内容也删了
在 GitHub 上，可以任意 Fork 开源仓库；自己拥有 Fork 后的仓库的读写权限；可以推送 pull request 给官方仓库来贡献代码。
git config –global alias.st status，用来设置别名减少操作，现在 git st就代表了 git status了
ssh-keygen -t rsa -C “my@email.com” 设置SSH

python进阶知识总览

Thu, 21 Jan 2016 17:52:11 +0000

有些人学完python之后不知道能干些什么或者要干些什么，实际上python本身语言很容易入门，如果不是按需学习就无法更上一层。正如有人抱怨的如今学完一门成熟的语言其实不难，难的是需要花费很多时间去了解它的生态，比如内置库还有第三方库的用法，以及各种成型的流行的框架的使用。有个网站统计开源库所使用库的流行程度，链接在这里python流行库排行。我也是通过这个网站才想到自己有了解过许多的库但是总是零零洒洒，不成体系，所以个人归纳分类了一下，决定每个库都要去实践和记录一下，好记性不如烂笔头。感兴趣的可以关注我的博客，会尽量把坑填完。

语法和用法

闭包和装饰器

魔术方法

描述符

生成器和协程

python编码

标准库

实际上有许多标准库在学python的过程中已经有所了解，但是总有那么几个标准库本身看起来好像平常没什么用,但到处有在使用，以下几个个人觉得有必要去了解去深入的，当然又要涉及到各种python2.x和python3.x之争，也会在文中提及。

logging

itertools

functools

collections

contextlib

re

unittest

threading

第三库和框架

优秀的库不仅在于它本身的创意新颖或者框架先进，它们的文档一般都非常优秀容易阅读，所以最好的学习方式还是读官方文档。第三库只会提及在某些领域已经被广泛应用的或认可，以下库按用途和功能将其分类。

开发环境和调试

virtualenv

pip

ipython 和 ipdb

爬虫以及WEB请求和解析

scrapy

requests

Beautiful Soup或者lxml

httpie

html2text

数据库相关

SQLAlchemy

渲染模板引擎

Jinja2

网站框架

Flask

Djiango

异步和协程

gevent

Celery

python基础零碎笔记

Wed, 20 Jan 2016 11:54:22 +0000

这些是很久之前学python的时候零零散散记录了的一些笔记，现在看来很简单，整理了一下用于开篇的博文吧。python 是优雅的语言，但有些技巧和语法需要注意一下。

1. 循环技巧：

在字典中循环时，关键字和对应的值可以用 items() 方法解读出来
在序列中循环时，索引位置和对应值可以使用 enumerate() 函数同时得到
同时循环两个或更多的序列，可以使用 zip() 整体解读

2. 作用域：

Python 的一个特别之处在于其赋值操作总是在最里层的作用域。赋值不会复制数据——只是将命名绑定到对象。删除也是如此：“del x ”只是从局部作用域的命名空间中删除命名 x

3. slots 方法

slots方法其实广为人知，听说有人用这个方法节省了很多内存。slots的作用是阻止在实例化类时为实例分配dict，默认情况下每个类都会有一个dict,通过__dict__访问，这个dict维护了这个实例的所有属性。当你在一个class中定义了__slots__后所有class的实例中只有slots中定义的attributes会出现在class的实例中。当你实例化多个对象时可以节省内存，当然副作用就是你的实例对象不能动态添加class里slots定义之外的属性。

12345678

class User(object):
    __slots__ =("name","age")
    def __init__(self,name,age):
        self.name = name
        self.age = age
u = User("dog",22)
hasattr(u,"__dict__") #return false
u.high = 1.75 #给不存在在slots里面的属性赋值会报错

4. `getatrribute` 和 `getattr`区别

__getatrribute__用来查询任意属性，包括存在和不存在的，__getattr__只有查询不存在的属性的时候才会触发，重写这个方法可以用于属性访问异常处理。

5. 字符串

字符串的连接

这个几乎上应该是入门者必须了解的特性了:因为字符串在内存里面不可变，所以如果用+号连接两个字符串时，将会进行各种内存调度工作，所以连接多个字符串先将其放进序列里面，然后用”“.join(seq)的方法，其中 seq 代表字符串序列。

In[4]: temp_str ="".join( list("wo" "he" "ni"))
In[5]: temp_str
Out[5]: 'woheni'
#实际上join()方法是把前面的字符当做连接符来连接序列里面的字符串
In[6]: temp_str =";".join( list("wo" "he" "ni"))
In[7]: temp_str
Out[7]: 'w;o;h;e;n;i'

字符串的反转

12	> 是一个技巧性的方法 > a为字符串，a[::-1]用切片可以达到reverse的效果

6. 各种判断和比较

永远不要用==或者!=来比较单件, 比如 None. 使用 is 或者 is not
一行判断：return_value = True if a == 1 else False 和 c 里面的 a?b:c 一样
all([a, b, c])和a and b and c 效果是一样的

7. 头文字

通常认为用 #!/usr/bin/env python 要比 #!/usr/bin/python 更好，因为 python 解释器有时并不安装在默认路径，例如在 virtualenv 中，如果你用 python xxoo.py 来运行，那么写不写都没关系，如果要用 ./xxoo.py 那么就必须加这行，这行被称为 shebang, 用来为脚本语言指定解释器。

8. 字典

字典的创建可以有以下这几种方式

 1 2 3 4 5 6 7 8 91011

In[13]: dict(a=1,b=2)
Out[13]: {'a': 1, 'b': 2}
In[14]: {"a":1,"b":2}
Out[14]: {'a': 1, 'b': 2}
In[15]: dict([("a",1),("b",2)])
Out[15]: {'a': 1, 'b': 2}
In[16]: names
Out[16]: ('a', 'b')
In[17]: dict(zip(names,range(2)))
Out[17]: {'a': 0, 'b': 1}
#用zip()来解析两个表达式，当然也可以用列表推导式来代替

字典取值

判断一个 key 是否在一个 dict 里面，用 has_key(key,default=none),其中第二参数可以自己定义当为空时的返回值

字典比较差异

用视图来判断两个字典的差异，即viewitems,具体用法如下: 在 Python 2.x 里面，iteritems() 和 viewitems() 这两个方法都已经废除了，而 item() 得到的结果是和 2.x 里面 viewitems() 一致的。以下代码在python3.4中测试。

 1 2 3 4 5 6 7 8 910111213141516

n[18]: d = dict(a=1,b=2,c=4)
In[19]: d2 = dict(a=1,b=2,c=3)
In[20]: d.items()
Out[20]: dict_items([('b', 2), ('c', 4), ('a', 1)])
In[21]: v1 = d.items()
In[22]: v2 = d2.items()
In[23]: v1 | v2 #求并集
Out[23]: {('a', 1), ('b', 2), ('c', 3), ('c', 4)}
In[24]: v1 & v2 #求交集
Out[24]: {('a', 1), ('b', 2)}
#有意思的一点是视图会随着原来的字典的变化而变化
In[25]: d.update(e=8)
In[26]: d
Out[26]: {'a': 1, 'b': 2, 'c': 4, 'e': 8}
In[27]: v1
Out[27]: dict_items([('e', 8), ('b', 2), ('c', 4), ('a', 1)])

setdefault和defaultdict的用法

对字典设置默认值，如果已经存在就直接返回已有值，不存在就设置
按某个关键字进行分组收集
defaultdict 其实是生成工厂

from collections import defaultdict
def tree():
    return defaultdict(tree)

9. sorted方法和使用

sorted(a, key=lambda result: result[0],reverse=True) ，这个排序居然跟 lisp 里面很像，基本抄过来的。在 key 里面定义一个匿名函数，在函数里面自定排序规则，因为输入参数默认为 a（sorted 的第一个参数），所以使用匿名函数时可以使用 map 等提取单独元素，完整方法以及参数 sorted(data, cmp=None, key=None, reverse=False)
operator.itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值。所以sorted(aa.items(),key=itemgetter(1)) 是对字典 aa 的value值进行排序，使用之前 from operator import itemgetter

10. yield from

yield from 更像是一种约定，把异步任务以协程发出去，然后等待结果返回，可以在结果返回上下文做文章。至于怎么知道结果到了，就需要事件循环来调度，某种任务协议来驱动。

ps：更像执行体和调用方直接建立了管道。

11. 可变对象copy

b = range(9);a=[];a[:]=b等同于a=copy.decopy(b)

12. 将某个包全局化

(不建议这么做) import site;site.getsitepackages()可以看到安装系统package的位置，.pth结尾的文件可以将本地python包的绝对位置暴露给全局，把.pth文件放到 site.getsitepackages所返回的路径当中即可。sys.path返回的是PYTHONPATH变量指向的位置。

13. 关于`import`

__import__方法其实就是import的原型，只不过前者接收的是字符串，而且在导入package.module，返回的是package而不是module，建议用importlib中的import_module替代。sys.modules是一个包含了当前解释器的所有导入模块的字典。

14. pkgutil

如果要获取包里面的所有模块列表，不应该用 os.listdir()，而是 pkgutil 模块。

15. 关于闭包

至少有两种主要方式来捕获和保存状态信息,你可以在一个对象实例 (通过一个绑定方法) 或者在一个闭包中保存它。

16. yield 常用用法

大量数据迭代，节省内存

def return_l():
    return [i for i in range(1000000)]


def yield_l():
    for i in range(1000000):
        yield i

多个的字符串join

这种用法排版比较清晰

12345678

def _join(db_name, key, value):
    yield "\n"
    yield "INSERT INTO `{}`.`{}` (".format(db_name, key)
    yield ") SELECT "
    yield " FROM `{}`.`{}`;".format(db_name, key)
    yield "\n"
# 使用
s = ''.join(_join("db_name", "k", "v"))

17.优雅的上下文管理

自己实现一个类似, `with open` 的用法

本质是类提供的 enter 和 exit方法

 1 2 3 4 5 6 7 8 910

class MyOpen(object):
    def __init__(self, file_name, mode):
        self.file_obj = open(file_name, mode)

    def __enter__(self):
        return self.file_obj

    def __exit__(self, exc_type, exc_value, traceback):
        self.file_obj.close()
        print "close the file is {}".format(self.file_obj.closed)

函数式的实现`contextlib`

下面方法来自的sqlalchemy官方文档，对session的commit,rollback,close结合使用，在实际项目中可以直接使用。

 1 2 3 4 5 6 7 8 91011121314151617

from contextlib import contextmanager

@contextmanager
def session_context(db_session):
    session = db_session
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()

# 此处传入sqlalchemy的session
with session_context(db_session) as session:
    session.query("something")