【导语】“slhot”通过精心收集，向本站投稿了18篇Redis总结笔记（一）：安装和常用命令，以下是小编为大家整理后的Redis总结笔记（一）：安装和常用命令，仅供参考，欢迎大家阅读。
- 目录
- 第1篇：Redis总结笔记（一）：安装和常用命令第2篇：redis学习笔记第3篇：Redis命令详解关键字第4篇：Redis命令详解关键字第5篇：Redis命令详解关键字第6篇：Redis命令详解关键字第7篇：Redis list 类型学习笔记与总结第8篇：Redis禁用命令、危险命令及规避方法第9篇：RVM安装和使用总结笔记第10篇：Redis String 类型和 Hash 类型学习笔记与总结第11篇：linux中redis安装配置linux操作系统第12篇：Redis教程(七)：Key操作命令详解第13篇：关于如何安装iotop命令使用教程第14篇：Linux 下安装软件命令第15篇：redis中各种数据类型对应的jedis操作命令第16篇：oracle学习笔记命令和函数第17篇：SQLSERVER命令总结第18篇：安装年度总结
篇1：Redis总结笔记（一）：安装和常用命令
这篇文章主要介绍了Redis总结笔记（一）：安装和常用命令,本文着重总结了常用命令,如对value操作的命令、对String操作的命令、对List操作的命令、对Set操作的命令等,需要的朋友可以参考下
一、redis简单介绍
redis是NoSql家族的一员，键值对的内存型数据库，但是它支持把数据保存到本地。这点比memcached好。
缺点: 没有本地数据缓冲, 目前还没有完整的数据聚集化支持
优点: 配置简单, 使用方便, 高性能,支持不同的数据类型(hashes, lists, sets, sorted sets)
ASP.NET WebUI for viewing content of the cache
二、安装
windows版本非官方版本。但是是”微软的团队维护的“这个是官方的说法。下载解压运行起来服务端（如图）
linux版官方版本，具体安装也很简单
代码如下:
$ wget download.redis.io/releases/redis-2.8.17.tar.gz
$ tar xzf redis-2.8.17.tar.gz
$ cd redis-2.8.17
$ make
三、常用命令
set key value 插入键
get key 获取value
keys * 查询所有键
del key 删除键
flushall 清空数据库
连接操作相关的命令
quit：关闭连接（connection）
auth：简单密码认证
持久化
save：将数据同步保存到磁盘
bgsave：将数据异步保存到磁盘
lastsave：返回上次成功将数据保存到磁盘的Unix时戳
shundown：将数据同步保存到磁盘，然后关闭服务
远程服务控制
info：提供服务器的信息和统计
monitor：实时转储收到的请求
slaveof：改变复制策略设置
config：在运行时配置Redis服务器
对value操作的命令
exists(key)：确认一个key是否存在
del(key)：删除一个key
type(key)：返回值的类型
keys(pattern)：返回满足给定pattern的所有key
randomkey：随机返回key空间的一个
keyrename(oldname, newname)：重命名key
dbsize：返回当前数据库中key的数目
expire：设定一个key的活动时间（s）
ttl：获得一个key的活动时间
select(index)：按索引查询
move(key, dbindex)：移动当前数据库中的key到dbindex数据库
flushdb：删除当前选择数据库中的所有key
flushall：删除所有数据库中的所有key
对String操作的命令
set(key, value)：给数据库中名称为key的string赋予值value
get(key)：返回数据库中名称为key的string的value
getset(key, value)：给名称为key的string赋予上一次的value
mget(key1, key2,…, key N)：返回库中多个string的value
setnx(key, value)：添加string，名称为key，值为value
setex(key, time, value)：向库中添加string，设定过期时间time
mset(key N, value N)：批量设置多个string的值
msetnx(key N, value N)：如果所有名称为key i的string都不存在
incr(key)：名称为key的string增1操作
incrby(key, integer)：名称为key的string增加integer
decr(key)：名称为key的string减1操作
decrby(key, integer)：名称为key的string减少integer
append(key, value)：名称为key的string的值附加value
substr(key, start, end)：返回名称为key的string的value的子串
对List操作的命令
rpush(key, value)：在名称为key的list尾添加一个值为value的元素
lpush(key, value)：在名称为key的list头添加一个值为value的 元素
llen(key)：返回名称为key的list的长度
lrange(key, start, end)：返回名称为key的list中start至end之间的元素
ltrim(key, start, end)：截取名称为key的list
lindex(key, index)：返回名称为key的list中index位置的元素
lset(key, index, value)：给名称为key的list中index位置的元素赋值
lrem(key, count, value)：删除count个key的list中值为value的元素
lpop(key)：返回并删除名称为key的list中的首元素
rpop(key)：返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout)：lpop命令的block版本，
brpop(key1, key2,… key N, timeout)：rpop的block版本。
rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
对Set操作的命令
sadd(key, member)：向名称为key的set中添加元素member
srem(key, member) ：删除名称为key的set中的元素member
spop(key) ：随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member) ：移到集合元素
scard(key) ：返回名称为key的set的基数
sismember(key, member) ：member是否是名称为key的set的元素
sinter(key1, key2,…key N) ：求交集
sinterstore(dstkey, (keys)) ：求交集并将交集保存到dstkey的集合
sunion(key1, (keys)) ：求并集
sunionstore(dstkey, (keys)) ：求并集并将并集保存到dstkey的集合
sdiff(key1, (keys)) ：求差集
sdiffstore(dstkey, (keys)) ：求差集并将差集保存到dstkey的集合
smembers(key) ：返回名称为key的set的所有元素
srandmember(key) ：随机返回名称为key的set的一个元素
对Hash操作的命令
hset(key, field, value)：向名称为key的hash中添加元素field
hget(key, field)：返回名称为key的hash中field对应的value
hmget(key, (fields))：返回名称为key的hash中field i对应的value
hmset(key, (fields))：向名称为key的hash中添加元素field
hincrby(key, field, integer)：将名称为key的hash中field的value增加integer
hexists(key, field)：名称为key的hash中是否存在键为field的域
hdel(key, field)：删除名称为key的hash中键为field的域
hlen(key)：返回名称为key的hash中元素个数
hkeys(key)：返回名称为key的hash中所有键
hvals(key)：返回名称为key的hash中所有键对应的value
hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value
篇2：redis学习笔记
一、几种数据结构：
1、String：key->value
（1）添加：set key value/setnx key value(不存在时才添加，已存在返回0)/setex key time value(添加并设置有效时间)/setrange key index value(将key对应的值从index位置开始替换为value)/mset key1 value1 key2 value2(一次设置多个值，失败返回0)/msetnx key1 value1 key2 value2(同上一个，但不覆盖已有的);
（2）获取：get key/getset key value(重设值，并返回旧值)/getrange key index1 index2(返回key对应value的子串：index1到index2)/mget key1 key2 key3（一次获取多个值);
（3）加减法：incr key(如果key的值为int类型，加一；如果key的值为非int类型，返回错误；如果key不存在，则设置key的值为1，即认为原来值为0)/incrby key number(key的值加number，其他同上一个)/decr key/decrby key number(这是减法，规格同incr/incrby);
（4）字符串操作：append key val(将val追加在key对应的值后面)/strlen key(返回key对应的值的长度) 注意点：字符串的左面下标从0开始，右面下标从-1开始，
2、hash：map，即每个hash表中有一到多个键值对
（1）添加：hset myhash key value(添加键值对key->value到hash表myhash中)/hsetnx myhash key value(同hset，但不覆盖)/hmset myhash key1 value1 key2 value2(添加多个键值对到hash表myhash中);
（2）获取：hget myhash key(获取hash表myhash中键为key的值)/hmget myhash key1 key2 key3(获取hash表myhash中多个键的值)/hincrby myhash key number(hash表myhash中key对应的值加number);
（3）其他操作：hexists myhash key(判断myhash中是否存在键为key，0表示无，1表示有)/hlen myhash(返回myhash键数量)/hdel myhash key(删除myhash中键为key的键值对)/hkeys myhash(返回myhash中所有键)/hvals myhash(返回myhash中所有值)/hgetall myhash(返回myhash中所有键和值)
3、list：由value串成的list
（1）添加：lpush mylist value(添加值value到mylist头部)/rpush mylist value(添加值value到mylist尾部)/linsert mylist before value1 value(将value插入到mylist中value1的前面)/lset mylist index value(将mylist中第index位置的值重设为value)
（2）获取：lrange mylist index1 index2(获取list中第index1个到第index2个)/lindex mylist index(返回mylist下标为index的值)/llen mylist(返回mylist的长度)
（3）删除：lrem mylist count value(删除|count|个mylist中值为value的元素，count>0：从头到尾删；count<0：从尾到头删；count=0：删除全部)/ltrim mylist index1 index2(只保留index1到index2范围的值)/lpop mylist(删除mylist头部并返回)/rpop mylist(删除mylist尾部并返回)/rpoplpush mylist1 mylist2(将mylist1的尾部移到mylist2的头部)
4、set：由value组成的set
（1）添加：sadd myset value
（2）获取：smembers myset(返回myset所有值)/sdiff myset1 myset2(返回两个set的差集)/sdiffstore myset myset1 myset2(将myset1与myset2的差集存在myset中)/sinter myset1 myset2(返回两个set的交集)/sinterstore myset myset1 myset2(将myset1和myset2的交集存在myset中)/sunion myset1 myset2(返回两个set的并集)/sunionstore myset myset1 myset2(将myset1和myset2的并集存在myset中)/scard myset(返回myset的元素个数)/sismember myset value(测试value是否为myset中的元素，1为是，0为否)/srandmember myset(随机返回myset中的一个元素，但不删除)
（3）删除：srem myset value(删除值为value的元素)/spop myset(随机删除并返回myset中的某个元素)/smove myset1 myset2 value(从myset1中移除value并添加到myset2中) 5、sorted set(zset)：带排序的set
（1）添加：zadd myzset score value(添加value到myzset，score用于排序，如果已存在value，则更新其score）
（2）获取：zrange myzset index1 index2 withscores(返回myzset中下标范围为index1到index2的元素及其score值，按score从小到大顺序)/zrank myzset value(返回value在myzset中的排名，从0开始计数)/zrevrank myzset value(返回value在myzset中的倒序排名，从0开始计数)/zrevrange myzset index1 index2 withscores(zrange的倒序)/zrangebyscore myzset a b withscores(返回myzset中score在a到b范围的值和score)/zcount myzset a b(返回myzset中score范围在a到b的值的数量)/zcard myzset(返回元素个数)/zscore myzset value(返回myzset中value对应的score值)
（3）删除：zrem myzset value(删除myzset中值为value的元素)/zremrangebyrank myzset index1 index2(删除myzset中score排名在index1到index2之间的元素)/zremrangebyscore myzset a b(删除myzset中score值在a和b之间的元素)
（4）加减score：zincrby myzset number value(将值为value的score加number) 二、redis常用命令：
1、keys pattern：返回给定pattern的所有key，pattern为正则表达式
2、exists key：判断是否存在key
3、del key：删除key
4、expire key time：设置一个key的过期时间
5、move key db：将一个key移到数据库db中
6、ttl key：返回key还有多长时间过期（-1表示无过期时间）
7、peisist key：移除key的过期时间
8、randomkey：随机返回某个key
9、rename oldkey newkey：将oldkey重命名为newkey
10、type value：返回value的类型
11、dbsize：返回当前数据库的key数量
12、flushdb：删除当前数据库的所有key
13、flushall：删除所有数据库的所有key
14、info：获取服务器信息和统计
15、config get：获取服务器配置信息 ps：redis的数据库编号为0-15，默认为数据库0，
篇3：Redis命令详解关键字
整数：被删除的keys的数量
2.dump key
加入版本 2.6.0。
时间复杂度： 查找给定键的复杂度为 O(1) ，对键进行序列化的复杂度为 O(N*M) ，其中 N 是构成 key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。如果序列化的对象是比较小的字符串，那么复杂度为 O(1) 。
序列化给定 key ，并返回被序列化的值，使用 RESTORE 命令可以将这个值反序列化为 Redis 键。
序列化生成的值有以下几个特点：
它带有 64 位的校验和，用于检测错误，RESTORE 在进行反序列化之前会先检查校验和。
值的编码格式和 RDB 文件保持一致。
RDB 版本会被编码在序列化值当中，如果因为 Redis 的版本不同造成 RDB 格式不兼容，那么 Redis 会拒绝对这个值进行反序列化操作。
序列化的值不包括任何生存时间信息。
篇4：Redis命令详解关键字
如果 key 不存在，那么返回 nil。
否则，返回序列化之后的值。
3.restore key ttl serialized-value
加入版本 2.6.0。
时间复杂度： 查找给定键的复杂度为 O(1) ，对键进行反序列化的复杂度为 O(N*M) ，其中 N 是构成 key 的 Redis 对象的数量，而 M 则是这些对象的平均大小。 有序集合(sorted set)的反序列化复杂度为 O(N*M*log(N)) ，因为有序集合每次插入的复杂度为 O(log(N)) ，
如果反序列化的对象是比较小的字符串，那么复杂度为 O(1) 。
反序列化给定的序列化值，并将它和给定的 key 关联。
参数 ttl 以毫秒为单位为 key 设置生存时间；如果 ttl 为 0 ，那么不设置生存时间。
RESTORE 在执行反序列化之前会先对序列化值的 RDB 版本和数据校验和进行检查，如果 RDB 版本不相同或者数据不完整的话，那么 RESTORE 会拒绝进行反序列化，并返回一个错误。
篇5：Redis命令详解关键字
整数，如下的整数结果
1 如果key存在0 如果key不存在
5.expire key seconds
加入版本 1.0.0。
时间复杂度： O(1)。
设置key的过期时间。如果key已过期，将会被自动删除。设置了过期时间的key被称之为volatile。
在key过期之前可以重新更新他的过期时间，也可以使用PERSIST命令删除key的过期时间。
在Redis< 2.1.3之前的版本,key的生存时间可以被更新
Note that in Redis 2.4 the expire might not be pin-point accurate, and it could be between zero to one seconds out. Development versions of Redis fixed this bug and Redis 2.6 will feature a millisecond precision EXPIRE.
篇6：Redis命令详解关键字
如果反序列化成功那么返回 OK ，否则返回一个错误。
4.exists key
加入版本 1.0.0。
时间复杂度： O(1)。
返回key是否存在。
篇7：Redis list 类型学习笔记与总结
这篇文章主要介绍了Redis list 类型学习笔记与总结,本文着重讲解了关于List的一些常用方法,比如lpush 方法、lrange 方法、rpush 方法、linsert 方法、lset 方法等,需要的朋友可以参考下
redis 版本
代码如下:
[root@localhost ~]# redis-server --version
Redis server v=2.8.19 sha=00000000:0 malloc=jemalloc-3.6.0 bits=32 build=e2559761bd460ca0
list 是一个链表结构，主要功能是 push（类似 PHP 的 array_push 方法）、pop（类似 PHP 的 array_pop() 方法）、获取一个范围的所有值 等， 操作
中 key 理解为链表的名字，Redis 的 list 类型其实就是一个每个子元素都是 string 类型的 双向链表。
链表的最大长度是(2的 32 次方)。我们可以通过 push, pop 操作从链表的头部或者尾部添加删除元素。这使得 list 既可以用作栈，也可以用作队列。
有意思的是 list 的 pop 操作还有阻塞版本的，当我们[lr]pop 一个 list 对象时，如果 list 是空，或者不存在，会立即返回 nil。但是阻塞版本的 b[lr]pop 可以则可以阻塞，当然可以加超时时间，超时后也会返回 nil。为什么要阻塞版本的 pop 呢，主要是为了避免轮询。举个简单的例子如果我们用 list 来实现一个工作队列。执行任务的 thread 可以调用阻塞版本的 pop 去获取任务这样就可以避免轮询去检查是否有任务存在。当任务来时候工作线程可以立即返回，也可以避免轮询带来的延迟。
① lpush 方法（栈）
在 key 对应 list 的头部 添加（压入）字符串元素。
② lrange 方法
lrange list1 0 -1 代表从链表 list1 的头部第一个元素取到 尾部第一个元素（-1 代表尾部第一个元素）。
【例】
代码如下:
127.0.0.1:6379>lpush list1 hello
(integer) 1
127.0.0.1:6379>lpush list1 world
(integer) 2
127.0.0.1:6379>lrange list1 0 -1
1) “world”
2) “hello”
③ rpush 方法（队列）
在 key 对应 list 的尾部 添加（压入）字符串元素。
【例】
代码如下:
127.0.0.1:6379>rpush list2 hello
(integer) 1
127.0.0.1:6379>rpush list2 world
(integer) 2
127.0.0.1:6379>lrange list2 0 -1
1) “hello”
2) “world”
不论是 lpush 还是 rpush 方法，都是从 list 的 两端压入。
④ linsert 方法
在 key 对应 list 的特定位置前或后添加字符串。
【例】
代码如下:
127.0.0.1:6379>rpush list3 one
(integer) 1
127.0.0.1:6379>linsert list3 before one two
(integer) 2
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “one”
127.0.0.1:6379>linsert list3 before one three
(integer) 3
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “three”
3) “one”
注意：
| | 头（前）
| | ↑
| | 尾
⑤ lset 方法
设置 list 中指定下标的元素值（替换指定下标的元素，类似 PHP 中的数组：$arr = array(‘a‘, ‘b‘, ‘c‘); $arr[0] = ‘d‘; ）。
【例】
代码如下:
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “three”
3) “one”
127.0.0.1:6379>lset list3 1 tmp
OK
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “tmp”
3) “one”
127.0.0.1:6379>lset list3 0 reset
OK
127.0.0.1:6379>lrange list3 0 -1
1) “reset”
2) “tmp”
3) “one”
⑥ lrem 方法
从 key 对应 list 中删除 n 个和 value 相同的元素。（n < 0 从尾删除，n = 0 全部删除）。返回删除的个数。
【例】
代码如下:
127.0.0.1:6379>lrange list3 0 -1
1) “reset”
2) “tmp”
3) “one”
127.0.0.1:6379>lpush list3 two
(integer) 4
127.0.0.1:6379>lpush list3 two
(integer) 5
127.0.0.1:6379>lpush list3 two
(integer) 6
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “two”
3) “two”
4) “reset”
5) “tmp”
6) “one”
127.0.0.1:6379>lrem list3 1 two
(integer) 1
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “two”
3) “reset”
4) “tmp”
5) “one”
127.0.0.1:6379>rpush list3 two
(integer) 6
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “two”
3) “reset”
4) “tmp”
5) “one”
6) “two”
127.0.0.1:6379>lrem list3 -2 two
(integer) 2
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “reset”
3) “tmp”
4) “one”
【例2】
代码如下:
127.0.0.1:6379>lrange list3 0 -1
1) “two”
2) “reset”
3) “tmp”
4) “one”
127.0.0.1:6379>lrem list3 -2 two
(integer) 1
127.0.0.1:6379>lrange list3 0 -1
1) “reset”
2) “tmp”
3) “one”
127.0.0.1:6379>lrem list3 -2 two
(integer) 0
127.0.0.1:6379>lrange list3 0 -1
1) “reset”
2) “tmp”
3) “one”
⑦ ltrm 方法
保留指定 key 的值范围内的数据，
【例】
代码如下:
127.0.0.1:6379>lpush list4 one
(integer) 1
127.0.0.1:6379>lpush list4 two
(integer) 2
127.0.0.1:6379>lpush list4 three
(integer) 3
127.0.0.1:6379>lpush list4 four
(integer) 4
127.0.0.1:6379>lrange list4 0 -1
1) “four”
2) “three”
3) “two”
4) “one”
127.0.0.1:6379>ltrim list4 1 2
OK
127.0.0.1:6379>lrange list4 0 -1
1) “three”
2) “two”
说明：保留下标（key）为 1 开始到下标为 2 的元素，其他两端的元素全部删除。
【例2】
代码如下:
127.0.0.1:6379>lrange list4 0 -1
1) “seven”
2) “six”
3) “five”
4) “three”
5) “two”
127.0.0.1:6379>ltrim list4 2 -1
OK
127.0.0.1:6379>lrange list4 0 -1
1) “five”
2) “three”
3) “two”
⑧ lpop 方法
从 list 的头部 删除 元素，并返回删除的元素（类似 PHP 中的 array_pop() 方法：将数组的最后一个单元弹出（删除））。
（rpop：代表从尾部删除元素）
【例】
代码如下:
127.0.0.1:6379>lrange list4 0 -1
1) “five”
2) “three”
3) “two”
127.0.0.1:6379>lpop list4
“five”
127.0.0.1:6379>lrange list4 0 -1
1) “three”
2) “two”
127.0.0.1:6379>rpop list4
“two”
127.0.0.1:6379>lrange list4 0 -1
1) “three”
⑨ rpoplpush 方法
从第一个 list 的尾部移除元素并添加到 第二个 list 的头部。
代码如下:
127.0.0.1:6379>lrange list4 0 -1
1) “eight”
2) “seven”
3) “three”
127.0.0.1:6379>lrange list5 0 -1
1) “redis”
2) “nginx”
3) “mysql”
4) “php”
127.0.0.1:6379>rpoplpush list4 list5
“three”
127.0.0.1:6379>lrange list4 0 -1
1) “eight”
2) “seven”
127.0.0.1:6379>lrange list5 0 -1
1) “three”
2) “redis”
3) “nginx”
4) “mysql”
5) “php”
⑩ lindex 方法
返回名称为 key 的 list 中 index 位置的元素。
【例】
代码如下:
127.0.0.1:6379>lrange list5 0 -1
1) “three”
2) “redis”
3) “nginx”
4) “mysql”
5) “php”
127.0.0.1:6379>lindex list5 1
“redis”
127.0.0.1:6379>lindex list5 -1
“php”
⑪ llen 方法（类似 PHP 中 count($arr) ）
返回 list 链表中元素的个数。
【例】
代码如下:
127.0.0.1:6379>lrange list5 0 -1
1) “three”
2) “redis”
3) “nginx”
4) “mysql”
5) “php”
127.0.0.1:6379>llen list5
(integer) 5
篇8：Redis禁用命令、危险命令及规避方法
这篇文章主要介绍了Redis禁用命令、危险命令及规避方法,本文介绍了个非常致命的两个命令以及用配置文件禁用这些命令的方法,需要的朋友可以参考下
FLUSHALL FLUSHDB 命令会清空数据，而且从不失败，对于线上集群非常危险，
KEYS * 命令，当数据规模较大时使用，会严重影响Redis性能，也非常危险。
如果从根本上规避这些风险呢？
Redis提供了非常简单且有效的方法，直接在配置文件中设置禁用这些命令，
设置非常简单，如下
代码如下:
rename-command FLUSHALL “”
rename-command FLUSHDB “”
rename-command KEYS “”
需要注意的一点是，rename-command命名无法直接对线上集群生效。如果需要使用rename-command，必须重启集群。
所以建议一开始，就将该配置配置好。
篇9：RVM安装和使用总结笔记
这篇文章主要介绍了RVM安装和使用总结笔记,本文讲解了RVM安装和配置命令,同时讲解了ruby的安装和配置,需要的朋友可以参考下
安装RVM命令:
代码如下:
bash < <( curl rvm.beginrescueend.com/releases/rvm-install-head )
然后修改用户配置文件/Users/username/.profile,你也可以写到别的全局配置里.
添加一行代码:
代码如下:
[[ -s “$HOME/.rvm/scripts/rvm” ]] && . “$HOME/.rvm/scripts/rvm” # This loads RVM into a shell session.
如果“$HOME/.rvm/scripts/rvm” 存在，则执行
重启Terminal,RVM就安装好了. RVM的使用过程中不需要使用sudo,gem也不需要.
然后就可以安装ruby了,例如:
代码如下:
rvm install ruby-1.8.7 --head --docs
--docs是编译安装后自动生成文档，--head是最新的版本
删除某个版本的ruby，并且把文档和gems都删除,则:
代码如下:
rvm remove ruby-1.8.7 --docs --gems
选择版本:
代码如下:
rvm use ruby-1.8.7 --default
查询当前版本:
代码如下:
rvm info
列出版本:
代码如下:
rvm list
rvm除了可以管理不同的ruby版本外，还可以为每个ruby版本创建不同的Gem集合（gemsets），从而使不同的Ruby应用可以独立使用自己的Gem集合，
RVM安装和使用总结笔记
，
比如在使用ruby-1.9.2-p290的情况下，我需要建立两个rails工程，一个使用rails-3.0，一个使用rails-3.1.0，我们便可创建两个gemset，并在各个gemset下分别安装对应的rails版本和所需其他Gem：
代码如下:
rvm gemset create rails-3.0 #创建名为rails-3.0的gemset
rvm 1.9.2-p290@rails-3.0 #使用ruby-1.9.2-p290并使用rails-3.0 gemset
gem install rails -v 3.0 #在rails-3.0 gemset下安装rails的3.0版本
rvm gemset create rails-3.1.0 #创建名为rails-3.1.0的gemset
rvm 1.9.2-p290@rails-3.1.0 #使用ruby-1.9.2-p290并使用rails-3.1.0 gemset
gem install rails -v 3.1.0 #在rails-3.0 gemset下安装rails的3.1.0版本
更多命令,访问 rvm.beginrescueend.com/rvm/
篇10：Redis String 类型和 Hash 类型学习笔记与总结
这篇文章主要介绍了Redis String 类型和 Hash 类型学习笔记与总结,本文分别对String 类型的一些方法和Hash 类型做了详细介绍,需要的朋友可以参考下
Linux 版本信息：
代码如下:
cat /etc/issue 或cat /etc/redhat-release（Linux查看版本当前操作系统发行版信息）
CentOS release 6.6 (Final)
（一）String 类型
【定义】string 是最简单的类型，你可以理解成与 Memcached 是一模一样的类型，一个 key 对应一个 value，其上支持的操作与 Memcached 的操作类似，但它的功能更丰富。
string 类型是二进制安全的。意思是 redis 的 string 可以包含任何数据， 比如 jpg 图片或者序 列化的对象。 从内部实现来看其实 string 可以看作 byte 数组，最大上限是 1G 字节。
【操作】
① set 方法
设置 key 对应的值为 string 类型的 value。
【例】添加 name = dee 的键值对：
代码如下:
127.0.0.1:6379>set name dee
OK
设置成功。
② get 方法
【例】
代码如下:
127.0.0.1:6379>get name
“dee”
获取成功。
再次设置 name = deathmask，值会被覆盖：
代码如下:
127.0.0.1:6379>set name deathmask
OK
127.0.0.1:6379>get name
“deathmask”
③ setnx 方法
设置 key 对应的值为 string 类型的 value，如果 key 已经存在，返回 0，nx 表示 not exist。
【例】
代码如下:
127.0.0.1:6379>setnx name dee
(integer) 0
127.0.0.1:6379>setnx app weibo
(integer) 1
127.0.0.1:6379>get name
“deathmask”
127.0.0.1:6379>get app
“weibo”
表示 name 已经存在而且没有更改，app 不存在则成功 set。
④ setex 方法
设置 key 对应的值为 string 类型的 value，并指定 此键值 对应的有效期。
【例】
代码如下:
127.0.0.1:6379>setex mobile 10 iphone
OK
127.0.0.1:6379>get mobile
“iphone”
127.0.0.1:6379>get mobile
“iphone”
127.0.0.1:6379>get mobile
(nil)
设置 mobile 的值为 iPhone，并且指定有效期为 10 秒。
⑤ setrange 方法
设定指定 key 的 value 值的子字符串
【例】将 dee 的 126 邮箱 替换为 gmail 邮箱
代码如下:
127.0.0.1:6379>set email dee@126.com
OK
127.0.0.1:6379>get email
“dee@126.com”
127.0.0.1:6379>setrange email 4 gmail.com
(integer) 13
127.0.0.1:6379>get email
“dee@gmail.com”
其中 4 代表下标，(integer) 13 表示字符串的长度。
【例2】
代码如下:
127.0.0.1:6379>set email dee@vip.ofim.com
OK
127.0.0.1:6379>get email
“dee@vip.ofim.com”
127.0.0.1:6379>setrange email 4 gmail.com
(integer) 16
127.0.0.1:6379>get email
“dee@gmail.comcom”
说明：如果替换的字符串没有源字符串长，则只会把源字符串中相同长度的字符替换掉，同时保留源字符串中剩余的字符。
⑥ mset 方法
一次设置多个 key 值，成功返回 ok，表示所有的值都设置了，失败返回 0，表示没有任何值被设置。
【例】
代码如下:
127.0.0.1:6379>mset key1 dee1 key2 dee2
OK
127.0.0.1:6379>get key1
“dee1”
127.0.0.1:6379>get key2
“dee2”
⑦ msetnx 方法
一次设置多个 key 的值，成功返回 1，表示所有的值都被设置了。失败返回 0 ，表示没有任何值被设置，但是不会覆盖已经存在的 key。
代码如下:
127.0.0.1:6379>msetnx key3 dee3 key4 dee4
(integer) 1
127.0.0.1:6379>msetnx key3 dee333 key4 dee444 key5 dee5
(integer) 0
127.0.0.1:6379>get key3
“dee3”
127.0.0.1:6379>get key4
“dee4”
127.0.0.1:6379>get key5
(nil)
⑧ getset 方法
设置 key 的值，并返回 key 的旧值。
【例】
代码如下:
127.0.0.1:6379>getset key1 emperor
“dee1”
⑨ getrange 方法
获取 key 的 value 值的子字符串。
代码如下:
127.0.0.1:6379>get email
“dee@gmail.comcom”
127.0.0.1:6379>getrange email 0 12
“dee@gmail.com”
返回第 0 到第12 个字符。
⑩ mget 方法
一次获取多个 key 的值，如果对应 key 不存在则对应返回 nil。
【例】
代码如下:
127.0.0.1:6379>mget key1 key2 key3 key4 key5
1) “emperor”
2) “dee2”
3) “dee3”
4) “dee4”
5) (nil)
⑪ incr 方法
对 key 的值做 加加 操作，并返回新的值。
【例】每次递增1
代码如下:
127.0.0.1:6379>set age 28
OK
127.0.0.1:6379>get age
“28”
127.0.0.1:6379>incr age
(integer) 29
127.0.0.1:6379>incr age
(integer) 30
127.0.0.1:6379>get age
“30”
【例2】
代码如下:
127.0.0.1:6379>get real-age
(nil)
127.0.0.1:6379>incr real-age
(integer) 1
127.0.0.1:6379>get real-age
“1”
⑫ incrby 方法
同 incr 方法类似，加指定值，key 不存在时会设置 key，并认为原来的 value 为 0。
【例】
代码如下:
127.0.0.1:6379>get times
(nil)
127.0.0.1:6379>incrby times 5
(integer) 5
127.0.0.1:6379>get times
“5”
【例2】
代码如下:
127.0.0.1:6379>incrby times -5
(integer) 0
127.0.0.1:6379>get times
“0”
⑬ decr 方法
对 key 的值做 减减操作，
⑭ decrby 方法
同 decr 方法类似，减指定值。
【例】
代码如下:
127.0.0.1:6379>get age
“30”
127.0.0.1:6379>decr age
(integer) 29
127.0.0.1:6379>decrby age 10
(integer) 19
127.0.0.1:6379>decrby age -10
(integer) 29
⑮ append 方法（重要）
给指定 key 的字符串追加 value ，返回新字符串的长度。
【例】
代码如下:
127.0.0.1:6379>get name
“deathmask”
127.0.0.1:6379>append name @163.com
(integer) 17
127.0.0.1:6379>get name
“deathmask@163.com”
⑯ strlen 方法
取指定 key 的 value 值的长度。
【例】
代码如下:
127.0.0.1:6379>get name
“deathmask@163.com”
127.0.0.1:6379>strlen name
(integer) 17
（二）Hash 类型
Redis hash 是一个 string 类型的 field 和 value 的 映射表。它的添加、删除操作都是 0(1)（平均操作）。
hash 特别 适合用于存储对象。相较于将对象的每个字段存成单个 string 类型（string 类型可以存储对象序列化）。
将一个对象存储在 hash 类型中会占用更少的内存，并且可以更方便的存取整个对象。
（省内存的原因是新建一个 hash 对象时开始是用 zipmap（又称为 small hash）来存储的。
这个 zipmap 其实并不是 hash table，但是 zipmap 相比正常的 hash 实现可以节省不少 hash 本身需要的一些元数据存储开销。
尽管 zipmap 的添加，删除，查找都是 O(n)，但是由于一般对象的 field 数量都不太多，所以使用 zipmap 也是很快的,也就是说添加删除平均还是 O(1)。
如果 field 或者 value的大小超出一定限制后， Redis 会在内部自动将 zipmap 替换成正常的 hash 实现. 这个限制可以在配置文件中指定。
hash-max-zipmap-entries 64 #配置字段最多 64 个，hash-max-zipmap-value 512 #配置 value 最大为 512 字节）
【操作】
① hset 方法 / hget 方法
设置hash field 为指定值，如果 key 不存在，则先创建。
【例】
代码如下:
127.0.0.1:6379>hset myhash field1 hello
(integer) 1
说明：myhash 是 hash 表的名称，field1 是 hash 表的一个字段，hello 是这个字段对应的值。存储用户比较方便。
【例2】
代码如下:
127.0.0.1:6379>hset user:001 name dee
(integer) 1
127.0.0.1:6379>hget user:001 name
“dee”
说明：设置 user 表 id 为 001 的用户，用户名为 dee。
可以把 user:001 看作一张表。
② hsetnx 方法
设置 hash field 为指定值，如果 key 不存在，则先创建；如果存在，则返回 0。
【例】
代码如下:
127.0.0.1:6379>hsetnx myhash field “hello”
(integer) 1
127.0.0.1:6379>hsetnx myhash field “hello!”
(integer) 0
127.0.0.1:6379>hget myhash field
“hello”
③ hmset 方法
同时设置 hash 的多个 field
【例】
代码如下:
127.0.0.1:6379>hmset user:002 name dee specialty php
OK
127.0.0.1:6379>hget user:002 name
“dee”
127.0.0.1:6379>hget user:002 specialty
“php”
④ hget 方法
获取全部指定的 hash field。
【例】
代码如下:
127.0.0.1:6379>hmget user:002 name specialty
1) “dee”
2) “php”
⑤ hincrby 方法
指定的 hash field 加上给定值。
【例】
代码如下:
127.0.0.1:6379>hmset user:002 name dee specialty redis age 28
OK
127.0.0.1:6379>hincrby user:002 age -6
(integer) 22
127.0.0.1:6379>hmget user:002 name specialty age
1) “dee”
2) “redis”
3) “22”
127.0.0.1:6379>hincrby user:002 age 5
(integer) 27
127.0.0.1:6379>hmget user:002 name specialty age
1) “dee”
2) “redis”
3) “27”
⑥ hexists 方法
测试指定 field 是否存在。
【例】
代码如下:
127.0.0.1:6379>hexists user:002 name
(integer) 1
127.0.0.1:6379>hexists user:002 sex
(integer) 0
⑦ hlen 方法
返回指定 hash 的 field 数量。
【例】
代码如下:
127.0.0.1:6379>hlen user:002
(integer) 3
⑧ hdel 方法
删除指定 hash 的 field。
【例】
代码如下:
127.0.0.1:6379>hdel user:002 age
(integer) 1
127.0.0.1:6379>hget user:002 age
(nil)
⑨ hkeys 方法（类似 PHP 中 array_keys 方法）
返回 hash 的所有 field。
【例】
代码如下:
127.0.0.1:6379>hkeys user:002
1) “name”
2) “specialty”
⑩ hvals 方法（类似 PHP 中的 array_values() 方法）
返回 hash 的所有 value。
【例】
代码如下:
127.0.0.1:6379>hvals user:002
1) “dee”
2) “redis”
⑪ hgetall 方法
获取某个 hash 中全部的 field 及 value。
【例】
代码如下:
127.0.0.1:6379>hgetall user:002
1) “name”
2) “dee”
3) “specialty”
4) “redis”
【总结】设置 hash 类型的数据，首先要设置 hash 的表，然后设置 hash 的 field，最后设置 hash field 的 value。
篇11：linux中redis安装配置linux操作系统
MySQL是关系型数据库，并不擅长分布式数据出路，因为它缺乏并行执行查询的能力，这时候，可以使用其他工具。如redis。
redis是非关系型数据库。Nosql的一个开源项目。对于简单的键值存储，在复制严重落后的非常高速的访问场景中可以使用redis替代mysql。
redis安装如下。
1、下载安装包，下载地址是servicestack。如我下载的版本是redis-2.0.2.rar。
2、解压文件到相应目录。可以看到解压后内有文件：
3、其中配置文件需要自己创建，现将源代码附在下面：
代码如下复制代码# Redis configuration file example# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize no
# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
# You can specify a custom pid file location here.
pidfile /var/run/redis.pid
# Accept connections on the specified port, default is 6379
port 6379
# If you want you can bind a single interface, if the bind option is not
# specified all the interfaces will listen for connections.
#
# bind 127.0.0.1
# Close the connection after a client is idle for N seconds (0 to disable)
timeout 300
# Set server verbosity to 'debug'
# it can be one of:
# debug (a lot of information, useful for development/testing)
# notice (moderately verbose, what you want in production probably)
# warning (only very important / critical messages are logged)
loglevel debug
# Specify the log file name. Also 'stdout' can be used to force
# the demon to log on the standard output. Note that if you use standard
# output for logging but daemonize, logs will be sent to /dev/null
logfile stdout
# Set the number of databases. The default database is DB 0, you can select
# a different one on a per-connection basis using SELECT
# dbid is a number between 0 and 'databases'-1
databases 16
################################ SNAPSHOTTING #################################
#
# Save the DB on disk:
#
# save
#
# Will save the DB if both the given number of seconds and the given
# number of write operations against the DB occurred.
#
# In the example below the behaviour will be to save:
# after 900 sec (15 min) if at least 1 key changed
# after 300 sec (5 min) if at least 10 keys changed
# after 60 sec if at least 10000 keys changed
save 900 1
save 300 10
save 60 10000
# Compress string objects using LZF when dump .rdb databases?
# For default that's set to 'yes' as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes
# The filename where to dump the DB
dbfilename dump.rdb
# For default save/load DB in/from the working directory
# Note that you must specify a directory not a file name.
dir ./
################################# REPLICATION #################################
# Master-Slave replication. Use slaveof to make a Redis instance a copy of
# another Redis server. Note that the configuration is local to the slave
# so for example it is possible to configure the slave to save the DB with a
# different interval, or to listen to another port, and so on.
#
# slaveof
# If the master is password protected (using the “requirepass” configuration
# directive below) it is possible to tell the slave to authenticate before
# starting the replication synchronization process, otherwise the master will
# refuse the slave request.
#
# masterauth
################################## SECURITY ###################################
# Require clients to issue AUTH
before processing any other
# commands. This might be useful in environments in which you do not trust
# others with access to the host running redis-server.
#
# This should stay commented out for backward compatibility and because most
# people do not need auth (e.g. they run their own servers).
#
# requirepass foobared
################################### LIMITS ####################################
# Set the max number of connected clients at the same time. By default there
# is no limit, and it's up to the number of file descriptors the Redis process
# is able to open. The special value '0' means no limts.
# Once the limit is reached Redis will close all the new connections sending
# an error 'max number of clients reached'.
#
# maxclients 128
# Don't use more memory than the specified amount of bytes.
# When the memory limit is reached Redis will try to remove keys with an
# EXPIRE set. It will try to start freeing keys that are going to expire
# in little time and preserve keys with a longer time to live.
# Redis will also try to remove objects from free lists if possible.
#
# If all this fails, Redis will start to reply with errors to commands
# that will use more memory, like SET, LPUSH, and so on, and will continue
# to reply to most read-only commands like GET.
#
# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
# 'state' server or cache, not as a real DB. When Redis is used as a real
# database the memory usage will grow over the weeks, it will be obvious if
# it is going to use too much memory in the long run, and you'll have the time
# to upgrade. With maxmemory after the limit is reached you'll start to get
# errors for write operations, and this may even lead to DB inconsistency.
#
# maxmemory
############################## APPEND ONLY MODE ###############################
# By default Redis asynchronously dumps the dataset on disk. If you can live
# with the idea that the latest records will be lost if something like a crash
# happens this is the preferred way to run Redis. If instead you care a lot
# about your data and don't want to that a single record can get lost you should
# enable the append only mode: when this mode is enabled Redis will append
# every write operation received in the file appendonly.log. This file will
# be read on startup in order to rebuild the full dataset in memory.
#
# Note that you can have both the async dumps and the append only file if you
# like (you have to comment the “save” statements above to disable the dumps).
# Still if append only mode is enabled Redis will load the data from the
# log file at startup ignoring the dump.rdb file.
#
# The name of the append only file is “appendonly.log”
#
# IMPORTANT: Check the BGREWRITEAOF to check how to rewrite the append
# log file in background when it gets too big.
appendonly no
# The fsync() call tells the Operating System to actually write data on disk
# instead to wait for more data in the output buffer. Some OS will really flush
# data on disk, some other OS will just try to do it ASAP.
#
# Redis supports three different modes:
#
# no: don't fsync, just let the OS flush the data when it wants. Faster.
# always: fsync after every write to the append only log . Slow, Safest.
# everysec: fsync only if one second passed since the last fsync. Compromise.
#
# The default is “always” that's the safer of the options. It's up to you to
# understand if you can relax this to “everysec” that will fsync every second
# or to “no” that will let the operating system flush the output buffer when
# it want, for better performances (but if you can live with the idea of
# some data loss consider the default persistence mode that's snapshotting).
appendfsync always
# appendfsync everysec
# appendfsync no
############################### ADVANCED CONFIG ###############################
# Glue small output buffers together in order to send small replies in a
# single TCP packet. Uses a bit more CPU but most of the times it is a win
# in terms of number of queries per second. Use 'yes' if unsure.
glueoutputbuf yes
# Use object sharing. Can save a lot of memory if you have many common
# string in your dataset, but performs lookups against the shared objects
# pool so it uses more CPU and can be a bit slower. Usually it's a good
# idea.
#
# When object sharing is enabled (shareobjects yes) you can use
# shareobjectspoolsize to control the size of the pool used in order to try
# object sharing. A bigger pool size will lead to better sharing capabilities.
# In general you want this value to be at least the double of the number of
# very common strings you have in your dataset.
# www.111cn.net
# WARNING: object sharing is experimental, don't enable this feature
# in production before of Redis 1.0-stable. Still please try this feature in
# your development environment so that we can test it better.
# shareobjects no
# shareobjectspoolsize 1024
4、命令行进入安装目录下（或者配置环境变量），
如图，
5、另开一个cmd,输入redis_cli.exe -h 127.0.0.1 -p 6349。接下来，你就可以玩了。
篇12：Redis教程(七)：Key操作命令详解
这篇文章主要介绍了Redis教程(七)：Key操作命令详解,本文讲解了Key操作命令概述、相关命令列表、命令使用示例等内容,需要的朋友可以参考下
一、概述：
在该系列的前几篇博客中，主要讲述的是与Redis数据类型相关的命令，如String、List、Set、Hashes和Sorted-Set，这些命令都具有一个共同点，即所有的操作都是针对与Key关联的Value的。而该篇博客将主要讲述与Key相关的Redis命令。学习这些命令对于学习Redis是非常重要的基础，也是能够充分挖掘Redis潜力的利器。
在该篇博客中，我们将一如既往的给出所有相关命令的明细列表和典型示例，以便于我们现在的学习和今后的查阅。
二、相关命令列表：
命令原型时间复杂度命令描述返回值KEYSpatternO(N)时间复杂度中的N表示数据库中Key的数量。获取所有匹配pattern参数的Keys。需要说明的是，在我们的正常操作中应该尽量避免对该命令的调用，因为对于大型数据库而言，该命令是非常耗时的，对Redis服务器的性能打击也是比较大的。pattern支持glob-style的通配符格式，如*表示任意一个或多个字符，?表示任意字符，[abc]表示方括号中任意一个字母。匹配模式的键列表。DELkey [key ...]O(N)时间复杂度中的N表示删除的Key数量。从数据库删除中参数中指定的keys，如果指定键不存在，则直接忽略。还需要另行指出的是，如果指定的Key关联的数据类型不是String类型，而是List、Set、Hashes和Sorted Set等容器类型，该命令删除每个键的时间复杂度为O(M)，其中M表示容器中元素的数量。而对于String类型的Key，其时间复杂度为O(1)。实际被删除的Key数量。EXISTSkeyO(1)判断指定键是否存在。1表示存在，0表示不存在。MOVEkey dbO(1)将当前数据库中指定的键Key移动到参数中指定的数据库中。如果该Key在目标数据库中已经存在，或者在当前数据库中并不存在，该命令将不做任何操作并返回0。移动成功返回1，否则0。RENAMEkey newkeyO(1)为指定指定的键重新命名，如果参数中的两个Keys的命令相同，或者是源Key不存在，该命令都会返回相关的错误信息。如果newKey已经存在，则直接覆盖。RENAMENXkey newkeyO(1)如果新值不存在，则将参数中的原值修改为新值。其它条件和RENAME一致。1表示修改成功，否则0。PERSISTkeyO(1)如果Key存在过期时间，该命令会将其过期时间消除，使该Key不再有超时，而是可以持久化存储。1表示Key的过期时间被移出，0表示该Key不存在或没有过期时间。EXPIREkey secondsO(1)该命令为参数中指定的Key设定超时的秒数，在超过该时间后，Key被自动的删除。如果该Key在超时之前被修改，与该键关联的超时将被移除。1表示超时被设置，0则表示Key不存在，或不能被设置。EXPIREATkey timestampO(1)该命令的逻辑功能和EXPIRE完全相同，唯一的差别是该命令指定的超时时间是绝对时间，而不是相对时间。该时间参数是Unix timestamp格式的，即从1970年1月1日开始所流经的秒数。1表示超时被设置，0则表示Key不存在，或不能被设置。TTLkeyO(1)获取该键所剩的超时描述。返回所剩描述，如果该键不存在或没有超时设置，则返回-1。RANDOMKEYO(1)从当前打开的数据库中随机的返回一个Key。返回的随机键，如果该数据库是空的则返回nil。TYPEkeyO(1)获取与参数中指定键关联值的类型，该命令将以字符串的格式返回。返回的字符串为string、list、set、hash和zset，如果key不存在返回none。SORTkey [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination]O(N+M*log(M))这个命令相对来说是比较复杂的，因此我们这里只是给出最基本的用法，有兴趣的网友可以去参考redis的官方文档。返回排序后的原始列表。
三、命令示例：
1. KEYS/RENAME/DEL/EXISTS/MOVE/RENAMENX:
代码如下:
#在Shell命令行下启动Redis客户端工具。
/>redis-cli
#清空当前选择的数据库，以便于对后面示例的理解。
redis 127.0.0.1:6379>flushdb
OK
#添加String类型的模拟数据。
redis 127.0.0.1:6379>set mykey 2
OK
redis 127.0.0.1:6379>set mykey2 “hello”
OK
#添加Set类型的模拟数据。
redis 127.0.0.1:6379>sadd mysetkey 1 2 3
(integer) 3
#添加Hash类型的模拟数据。
redis 127.0.0.1:6379>hset mmtest username “stephen”
(integer) 1
#根据参数中的模式，获取当前数据库中符合该模式的所有key，从输出可以看出，该命令在执行时并不区分与Key关联的Value类型。
redis 127.0.0.1:6379>keys my*
1) “mysetkey”
2) “mykey”
3) “mykey2”
#删除了两个Keys。
redis 127.0.0.1:6379>del mykey mykey2
(integer) 2
#查看一下刚刚删除的Key是否还存在，从返回结果看，mykey确实已经删除了。
redis 127.0.0.1:6379>exists mykey
(integer) 0
#查看一下没有删除的Key，以和上面的命令结果进行比较。
redis 127.0.0.1:6379>exists mysetkey
(integer) 1
#将当前数据库中的mysetkey键移入到ID为1的数据库中，从结果可以看出已经移动成功。
redis 127.0.0.1:6379>move mysetkey 1
(integer) 1
#打开ID为1的数据库。
redis 127.0.0.1:6379>select 1
OK
#查看一下刚刚移动过来的Key是否存在，从返回结果看已经存在了。
redis 127.0.0.1:6379[1]>exists mysetkey
(integer) 1
#在重新打开ID为0的缺省数据库，
redis 127.0.0.1:6379[1]>select 0
OK
#查看一下刚刚移走的Key是否已经不存在，从返回结果看已经移走。
redis 127.0.0.1:6379>exists mysetkey
(integer) 0
#准备新的测试数据。
redis 127.0.0.1:6379>set mykey “hello”
OK
#将mykey改名为mykey1
redis 127.0.0.1:6379>rename mykey mykey1
OK
#由于mykey已经被重新命名，再次获取将返回nil。
redis 127.0.0.1:6379>get mykey
(nil)
#通过新的键名获取。
redis 127.0.0.1:6379>get mykey1
“hello”
#由于mykey已经不存在了，所以返回错误信息。
redis 127.0.0.1:6379>rename mykey mykey1
(error) ERR no such key
#为renamenx准备测试key
redis 127.0.0.1:6379>set oldkey “hello”
OK
redis 127.0.0.1:6379>set newkey “world”
OK
#由于newkey已经存在，因此该命令未能成功执行。
redis 127.0.0.1:6379>renamenx oldkey newkey
(integer) 0
#查看newkey的值，发现它也没有被renamenx覆盖。
redis 127.0.0.1:6379>get newkey
“world”
2. PERSIST/EXPIRE/EXPIREAT/TTL:
代码如下:
#为后面的示例准备的测试数据。
redis 127.0.0.1:6379>set mykey “hello”
OK
#将该键的超时设置为100秒。
redis 127.0.0.1:6379>expire mykey 100
(integer) 1
#通过ttl命令查看一下还剩下多少秒。
redis 127.0.0.1:6379>ttl mykey
(integer) 97
#立刻执行persist命令，该存在超时的键变成持久化的键，即将该Key的超时去掉。
redis 127.0.0.1:6379>persist mykey
(integer) 1
#ttl的返回值告诉我们，该键已经没有超时了。
redis 127.0.0.1:6379>ttl mykey
(integer) -1
#为后面的expire命令准备数据。
redis 127.0.0.1:6379>del mykey
(integer) 1
redis 127.0.0.1:6379>set mykey “hello”
OK
#设置该键的超时被100秒。
redis 127.0.0.1:6379>expire mykey 100
(integer) 1
#用ttl命令看一下当前还剩下多少秒，从结果中可以看出还剩下96秒。
redis 127.0.0.1:6379>ttl mykey
(integer) 96
#重新更新该键的超时时间为20秒，从返回值可以看出该命令执行成功。
redis 127.0.0.1:6379>expire mykey 20
(integer) 1
#再用ttl确认一下，从结果中可以看出果然被更新了。
redis 127.0.0.1:6379>ttl mykey
(integer) 17
#立刻更新该键的值，以使其超时无效。
redis 127.0.0.1:6379>set mykey “world”
OK
#从ttl的结果可以看出，在上一条修改该键的命令执行后，该键的超时也无效了。
redis 127.0.0.1:6379>ttl mykey
(integer) -1
3. TYPE/RANDOMKEY/SORT:
代码如下:
#由于mm键在数据库中不存在，因此该命令返回none。
redis 127.0.0.1:6379>type mm
none
#mykey的值是字符串类型，因此返回string。
redis 127.0.0.1:6379>type mykey
string
#准备一个值是set类型的键。
redis 127.0.0.1:6379>sadd mysetkey 1 2
(integer) 2
#mysetkey的键是set，因此返回字符串set。
redis 127.0.0.1:6379>type mysetkey
set
#返回数据库中的任意键。
redis 127.0.0.1:6379>randomkey
“oldkey”
#清空当前打开的数据库。
redis 127.0.0.1:6379>flushdb
OK
#由于没有数据了，因此返回nil。
redis 127.0.0.1:6379>randomkey
(nil)
篇13：关于如何安装iotop命令使用教程
iotop命令是界面风格类似top命令。这个命令只有在kernelv2.6.20及以后的版本中才有。python版本需要 python2.7及以上版本
官方的说明：
Linux has always been able to show how much I/O was going on （the bi and bo columns of the vmstat 1 command）。
Iotop is a Python program with a top like UI used to show of behalf of which process is the I/O going on. It requires Python ≥ 2.7 and a Linux kernel ≥ 2.6.20 with the TASK_DELAY_ACCT CONFIG_TASKSTATS， TASK_IO_ACCOUNTING and CONFIG_VM_EVENT_COUNTERS options on.
iotop安装：
直接yum安装。
yum install iotop
在Ubuntu里安装命令是： sudo apt-get install iotop
安装好之后在终端输入：iotop就可以了
或者：
git clone git://repo.or.cz/iotop.git
iotop使用说明：
可以用左右箭头操作，按 r 是相反方向，按 o 是动态切换
用法 iotop -参数
Cversion 查看版本信息的
-h， Chelp 查看帮助信息的
-o， Conly 只显示在划硬盘的程序
-b， Cbatch 批量处理 用来记录日志的
-n NUM 设定循环几次
-d SEC， Cdelay=SEC 设定显示时间间隔
上面就是Linux下安装iotop命令的方法介绍了，如果你要使用iotop命令的话，可按照上面的命令进行安装，安装后可使用该命令进行硬盘IO的查看，你学会了吗？
[关于如何安装iotop命令使用教程]
篇14：Linux 下安装软件命令
怎么安装应用软件？
我的软件安装在什么地方？
如何删除不要的应用软件？
……
下面，我们就一起来认识一下这些方面的问题，
一、解析Linux应用软件安装包：
通常Linux应用软件的安装包有三种：
1） tar包，如software-1.2.3-1.tar.gz。它是使用UNIX系统的打包工具tar打包的。
2） rpm包，如software-1.2.3-1.i386.rpm。它是Redhat Linux提供的一种包封装格式。
3） dpkg包，如software-1.2.3-1.deb。它是Debain Linux提供的一种包封装格式。
而且，大多数Linux应用软件包的命名也有一定的规律，它遵循：
名称-版本-修正版-类型
例如：
1） software-1.2.3-1.tar.gz 意味着：
软件名称：software
版本号：1.2.3
修正版本：1
类型：tar.gz，说明是一个tar包。
2） sfotware-1.2.3-1.i386.rpm
软件名称：software
版本号：1.2.3
修正版本：1
可用平台：i386，适用于Intel 80x86平台。
类型：rpm，说明是一个rpm包。
注：由于rpm格式的通常是已编译的程序，所以需指明平台。在后面会详细说明。
而software-1.2.3-1.deb就不用再说了吧！大家自己练习一下。
二、了解包里的内容：
一个Linux应用程序的软件包中可以包含两种不同的内容：
1） 一种就是可执行文件，也就是解开包后就可以直接运行的。在Windows中所 有的软件包都是这种类型。安装完这个程序后，你就可以使用，但你看不到源程序。而且下载时要注意这个软件是否是你所使用的平台，否则将无法正常安装。
2） 另一种则是源程序，也就解开包后，你还需要使用编译器将其编译成为可执行文件。这在Windows系统中是几乎没有的，因为Windows的思想是不开放 源程序的。
通常，用tar打包的，都是源程序；而用rpm、dpkg打包的则常是可执行程序。一般来说，自己动手编译源程序能够更具灵活性，但也容易遇到各 种问题和困难。而相对来说，下载那些可执行程序包，反而是更容易完成软件的安装，当然那样灵活性就差多了。所以一般一个软件总会提供多种打包格式的安装程 序的。你可以根据自己的情况来选择。
三、搞定使用tar打包的应用软件
1. 安装：
整个安装过程可以分为以下几步：
1） 取得应用软件：通过下载、购买光盘的方法获得；
2）解压缩文件：一般tar包，都会再做一次压缩，如gzip、bz2等，所以你需要先解压。如果是最常见的gz格式，则可以执行：“tar –xvzf 软件包名”，就可以一步完成解压与解包工作。如果不是，则先用解压软件，再执行“tar –xvf 解压后的tar包”进行解包；
3） 阅读附带的INSTALL文件、README文件；
4） 执行“./configure”命令为编译做好准备；
5） 执行“make”命令进行软件编译；
6） 执行“make install”完成安装；
7） 执行“make clean”删除安装时产生的临时文件。
好了，到此大功告成。我们就可以运行应用程序了。但这时，有的读者就会问，我怎么执行呢？这也是一个Linux特色的问题。其实，一般来说， Linux的应用软件的可执行文件会存放在/usr/local/bin目录下！不过这并不是“放四海皆准”的真理，最可靠的还是看这个软件的 INSTALL和README文件，一般都会有说明。
2. 卸载：
通常软件的开发者很少考虑到如何卸载自己的软件，而tar又仅是完成打包的工作，所以并没有提供良好的卸载方法。
那么是不是说就不能够卸载呢！其实也不是，有两个软件能够解决这个问题，那就是Kinstall和Kife，它们是tar包安装、卸载的黄金搭 档。它们的使用方法，笔者会另行文介绍。在此就不加赘述了。
四、搞定使用rpm打包的应用软件
rpm可谓是Redhat公司的一大贡献，它使Linux的软件安装工作变得更加简单容易。
1. 安装：
我只需简单的一句话，就可以说完。执行：
rpm –ivh rpm软件包名
更高级的，请见下表：
rpm参数 参数说明
-i 安装软件
-t 测试安装，不是真的安装
-p 显示安装进度
-f 忽略任何错误
-U 升级安装
-v 检测套件是否正确安装
这些参数可以同时采用。更多的内容可以参考RPM的命令帮助。
2. 卸载：
我同样只需简单的一句话，就可以说完。执行：
rpm –e 软件名
不过要注意的是，后面使用的是软件名，而不是软件包名，
例如，要安装software-1.2.3-1.i386.rpm这个包时，应执行：
rpm –ivh software-1.2.3-1.i386.rpm
而当卸载时，则应执行：
rpm –e software。
另外，在Linux中还提供了象GnoRPM、kpackage等图形化的RPM工具，使得整个过程会更加简单。这些软件的具体应用，笔者会另行 文介绍。
五、搞定使用deb打包的应用程序
这是Debian Linux提供的一个包管理器，它与RPM十分类似。但由于RPM出现得更早，所以在各种版本的Linux都常见到。而debian的包管理器dpkg则 只出现在Debina Linux中，其它Linux版本一般都没有。我们在此就简单地说明一下：
1. 安装
dpkg –i deb软件包名
如：dpkg –i software-1.2.3-1.deb
2. 卸载
dpkg –e 软件名
如：dpkg –e software
好了，就说到这，希望能够帮助大家找到北。有什么问题请在“安装与入门”版中提出，或E-mail to：。
===================================================================================
软件的安装
---- Linux下软件的安装主要有两种不同的形式。第一种安装文件名为filename.tar.gz。另一种安装文件名为 filename.i386.rpm。以第一种方式发行的软件多为以源码形式发送的。第二种方式则是直接以二进制形式发行的。i386即表示该软件是按 Inter 386指令集编译生成的。
---- 对于第一种，安装方法如下：
---- 首先，将安装文件拷贝至你的目录中。例如，如果你是以root身份登录上的，就将软件拷贝至/root中。
---- #cp filename.tar.gz /root
---- 由于该文件是被压缩并打包的，所以，应对其解压缩。命令为：
---- #tar xvzf filename.tar.gz
---- 执行该命令后，安装文件按路径，解压缩在当前目录下。用ls命令可以看到解压缩后的文件。通常在解压缩后产生的文件中，有名为“INSTALL”的文件。 该文件为纯文本文件，详细讲述了该软件包的安装方法。
---- 对于多数需要编译的软件，其安装的方法大体相同。执行解压缩后产生的一个名为configure的可执行脚本程序。它是用于检查系统是否有编译时所需的 库，以及库的版本是否满足编译的需要等安装所需要的系统信息。为随后的编译工作做准备。命令为：
---- #./configure
---- 如果检查过程中，发现有错误，configure将给予提示，并停止检查。你可以跟据提示对系统进行配置。再重新执行该程序。检查通过后，将生成用于编译 的MakeFile文件。此时，可以开始进行编译了。编译的过程视软件的规模和计算机的性能的不同，所耗费的时间也不同。命令为：
---- #make
---- 成功编译后，键入如下的命令开始安装：
---- #make install
---- 安装完毕，应清除编译过程中产生的临时文件和配置过程中产生的文件。键入如下命令：
#make clean
#make distclean
至此，软件的安装结束。
---- 对于第二种，其安装方法要简单的多。
---- 同第一种方式一样，将安装文件拷贝至你的目录中。然后使用rpm来安装该文件。命令如下：
---- #rpm -i filename.i386.rpm
---- rpm将自动将安装文件解包，并将软件安装到缺省的目录下。并将软件的安装信息注册到rpm的数据库中。参数i的作用是使rpm进入安装模式。
---- 另外，还有一些Linux平台下的商业软件。在其安装文件中，有Setup安装程序，其安装方法同Windows平台下的一样。如:Corel WordPerfect。
软件的卸载
---- 软件的卸载主要是使用rpm来进行的。卸载软件首先要知道软件包在系统中注册的名称。键入命令：
---- #rpm -q -a
---- 即可查询到当前系统中安装的所有的软件包。参数q的作用是使rpm进入查询命令模式。参数a是查询模式的子参数，意为全部（ALL）。查询到的信息较多， 可使用less人屏显示。
---- 确定了要卸载的软件的名称，就可以开始实际卸载该软件了。键入命令：
---- #rpm -e [package name]
---- 即可卸载软件。参数e的作用是使rpm进入卸载模式。对名为[package name]的软件包进行卸载。由于系统中各个软件包之间相互有依赖关系。如果因存在依赖关系而不能卸载，rpm将给予提示并停止卸载。你可以使用如下的命 令来忽略依赖关系，直接开始卸载：
---- #rpm -e [package name] -nodeps
---- 忽略依赖关系的卸载可能会导致系统中其它的一此软件无法使用。你可以使用
---- #rpm -e [package name] -test
---- 使rpm进行一次卸载预演，而不是真正卸载。这样可以使你检查一下软件是否存在有依赖关系。卸载过程中是否有错误
篇15：redis中各种数据类型对应的jedis操作命令
一、常用数据类型简介：
redis常用五种数据类型:string,hash,list,set,zset(sorted set).
1.String类型
String是最简单的类型，一个key对应一个value
String类型的数据最大1G，redis中各种数据类型对应的jedis操作命令
。String类型的值可以被视作integer，从而可以让“INCR”命令族操作(incrby、decr、decrby),这种情况下，该integer的值限制在64位有符号数。
在list、set和zset中包含的独立的元素类型都是Redis String类型。
2.List类型
链表类型，主要功能是push、pop、获取一个范围的所有值等。其中的key可以理解为链表的名字。
在Redis中，list就是Redis String的列表，按照插入顺序排序。比如使用LPUSH命令在list头插入一个元素，使用RPUSH命令在list的尾插入一个元素。当这两个命令之一作用于一个空的key时，一个新的list就创建出来了。
List的最大长度是2^32-1个元素。
3.Set类型
集合，和数学中的集合概念相似。操作中的key理解为集合的名字。
在Redis中，set就是Redis String的无序集合，不允许有重复元素。
Set的最大元素数是2^32-1。
Redis中对set的操作还有交集、并集、差集等。
4.ZSet(Sorted Set)类型
Zset是set的一个升级版本，在set的基础上增加了一个顺序属性，这一属性在添加修改元素时可以指定，每次指定后zset会自动安装指定值重新调整顺序。可以理解为一张表，一列存value，一列存顺序。操作中的key理解为zset的名字。
Zset的最大元素数是2^32-1。
对于已经有序的zset，仍然可以使用SORT命令，通过指定ASC|DESC参数对其进行排序。
5.hash类型
hash是最接近关系数据库结构的数据类型，可以将数据库一条记录或程序中一个对象转换成hashmap存放在redis中。
二、jedis操作命令：
1.对value操作的命令
exists(key)：确认一个key是否存在
del(key)：删除一个key
type(key)：返回值的类型
keys(pattern)：返回满足给定pattern的所有key
randomkey：随机返回key空间的一个key
rename(oldname, newname)：将key由oldname重命名为newname，若newname存在则删除newname表示的key
dbsize：返回当前数据库中key的数目
expire：设定一个key的活动时间（s）
ttl：获得一个key的活动时间
select(index)：按索引查询
move(key, dbindex)：将当前数据库中的key转移到有dbindex索引的数据库
flushdb：删除当前选择数据库中的所有key
flushall：删除所有数据库中的所有key
2.对String操作的命令
set(key, value)：给数据库中名称为key的string赋予值value
get(key)：返回数据库中名称为key的string的value
getset(key, value)：给名称为key的string赋予上一次的value
mget(key1, key2,…, key N)：返回库中多个string（它们的名称为key1，key2…）的value
setnx(key, value)：如果不存在名称为key的string，则向库中添加string，名称为key，值为value
setex(key, time, value)：向库中添加string（名称为key，值为value）同时，设定过期时间time
mset(key1, value1, key2, value2,…key N, value N)：同时给多个string赋值，名称为key i的string赋值value i
msetnx(key1, value1, key2, value2,…key N, value N)：如果所有名称为key i的string都不存在，则向库中添加string，名称 key i赋值为value i
incr(key)：名称为key的string增1操作
incrby(key, integer)：名称为key的string增加integer
decr(key)：名称为key的string减1操作
decrby(key, integer)：名称为key的string减少integer
append(key, value)：名称为key的string的值附加value
substr(key, start, end)：返回名称为key的string的value的子串
3.对List操作的命令
rpush(key, value)：在名称为key的list尾添加一个值为value的元素
lpush(key, value)：在名称为key的list头添加一个值为value的 元素
llen(key)：返回名称为key的list的长度
lrange(key, start, end)：返回名称为key的list中start至end之间的元素（下标从0开始，下同）
ltrim(key, start, end)：截取名称为key的list，保留start至end之间的元素
lindex(key, index)：返回名称为key的list中index位置的元素
lset(key, index, value)：给名称为key的list中index位置的元素赋值为value
lrem(key, count, value)：删除count个名称为key的list中值为value的元素。count为0，删除所有值为value的元素，count>0 从头至尾删除count个值为value的元素，count<0从尾到头删除|count|个值为value的元素。
lpop(key)：返回并删除名称为key的list中的首元素
rpop(key)：返回并删除名称为key的list中的尾元素
blpop(key1, key2,… key N, timeout)：lpop 命令的block版本。即当timeout为0时，若遇到名称为key i的list不存在或该list为空，则命令结束。如果 timeout>0，则遇到上述情况时，等待timeout秒，如果问题没有解决，则对key i+1开始的list执行pop操作。
brpop(key1, key2,… key N, timeout)：rpop的block版本。参考上一命令。
rpoplpush(srckey, dstkey)：返回并删除名称为srckey的list的尾元素，并将该元素添加到名称为dstkey的list的头部
4.对Set操作的命令
sadd(key, member)：向名称为key的set中添加元素member
srem(key, member) ：删除名称为key的set中的元素member
spop(key) ：随机返回并删除名称为key的set中一个元素
smove(srckey, dstkey, member) ：将member元素从名称为srckey的集合移到名称为dstkey的集合
scard(key) ：返回名称为key的set的基数
sismember(key, member) ：测试member是否是名称为key的set的元素
sinter(key1, key2,…key N) ：求交集
sinterstore(dstkey, key1, key2,…key N) ：求交集并将交集保存到dstkey的集合
sunion(key1, key2,…key N) ：求并集
sunionstore(dstkey, key1, key2,…key N) ：求并集并将并集保存到dstkey的集合
sdiff(key1, key2,…key N) ：求差集
sdiffstore(dstkey, key1, key2,…key N) ：求差集并将差集保存到dstkey的集合
smembers(key) ：返回名称为key的set的所有元素
srandmember(key) ：随机返回名称为key的set的一个元素
5.对zset（sorted set）操作的命令
zadd(key, score, member)：向名称为key的zset中添加元素member，score用于排序。如果该元素已经存在，则根据score更新该元素的顺序。
zrem(key, member) ：删除名称为key的zset中的元素member
zincrby(key, increment, member) ：如果在名称为key的zset中已经存在元素member，则该元素的score增加increment；否则向集合中添加该元素，其score的值为increment
zrank(key, member) ：返回名称为key的zset（元素已按score从小到大排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”
zrevrank(key, member) ：返回名称为key的zset（元素已按score从大到小排序）中member元素的rank（即index，从0开始），若没有member元素，返回“nil”
zrange(key, start, end)：返回名称为key的zset（元素已按score从小到大排序）中的index从start到end的所有元素
zrevrange(key, start, end)：返回名称为key的zset（元素已按score从大到小排序）中的index从start到end的所有元素
zrangebyscore(key, min, max)：返回名称为key的zset中score >= min且score <= max的所有元素
zcard(key)：返回名称为key的zset的基数
zscore(key, element)：返回名称为key的zset中元素element的score
zremrangebyrank(key, min, max)：删除名称为key的zset中rank >= min且rank <= max的所有元素
zremrangebyscore(key, min, max) ：删除名称为key的zset中score >= min且score <= max的所有元素
zunionstore / zinterstore(dstkeyN, key1,…,keyN, WEIGHTS w1,…wN, AGGREGATE SUM|MIN|MAX)：对N个zset求并集和交集，并将最后的集合保存在dstkeyN中。对于集合中每一个元素的score，在进行AGGREGATE运算前，都要乘以对于的WEIGHT参数。如果没有提供WEIGHT，默认为1。默认的AGGREGATE是SUM，即结果集合中元素的score是所有集合对应元素进行 SUM运算的值，而MIN和MAX是指，结果集合中元素的score是所有集合对应元素中最小值和最大值。
6.对Hash操作的命令
hset(key, field, value)：向名称为key的hash中添加元素field<―>value
hget(key, field)：返回名称为key的hash中field对应的value
hmget(key, field1, …,field N)：返回名称为key的hash中field i对应的value
hmset(key, field1, value1,…,field N, value N)：向名称为key的hash中添加元素field i<―>value i
hincrby(key, field, integer)：将名称为key的hash中field的value增加integer
hexists(key, field)：名称为key的hash中是否存在键为field的域
hdel(key, field)：删除名称为key的hash中键为field的域
hlen(key)：返回名称为key的hash中元素个数
hkeys(key)：返回名称为key的hash中所有键
hvals(key)：返回名称为key的hash中所有键对应的value
hgetall(key)：返回名称为key的hash中所有的键（field）及其对应的value
三、各种数据类型所对应的应用场景
1.String类型的应用场景
String是最常用的一种数据类型,普通的key/value存储.
2.list类型的应用场景
比较适用于列表式存储且顺序相对比较固定，例如：
省份、城市列表
品牌、厂商、车系、车型等列表
拆车坊专题列表...
3.set类型的应用场景
Set对外提供的功能与list类似,当需要存储一个列表数据,又不希望出现重复数据时,可选用set
4.zset(sorted set)类型的应用场景
zset的使用场景与set类似,区别是set不是自动有序的,而zset可以通过用户额外提供一个优先级(score)的参数来为成员排序,并且是插入有序的,即自动排序.当你需要一个有序的并且不重复的集合列表,那么可以选择zset数据结构，
电脑资料
例如:
根据PV排序的热门车系车型列表
根据时间排序的新闻列表
5.hash类型的应用场景
类似于表记录的存储
页面视图所需数据的存储
四、具体使用参考示例：
private void testKey { System.out.println(“=============key==========================”); // 清空数据 System.out.println(jedis.flushDB()); System.out.println(jedis.echo(“foo”)); // 判断key否存在 System.out.println(shardedJedis.exists(“foo”)); shardedJedis.set(“key”, “values”); System.out.println(shardedJedis.exists(“key”)); } private void testString() { System.out.println(“=============String==========================”); // 清空数据 System.out.println(jedis.flushDB()); // 存储数据 shardedJedis.set(“foo”, “bar”); System.out.println(shardedJedis.get(“foo”)); // 若key不存在，则存储 shardedJedis.setnx(“foo”, “foo not exits”); System.out.println(shardedJedis.get(“foo”)); // 覆盖数据 shardedJedis.set(“foo”, “foo update”); System.out.println(shardedJedis.get(“foo”)); // 追加数据 shardedJedis.append(“foo”, “ hello, world”); System.out.println(shardedJedis.get(“foo”)); // 设置key的有效期，并存储数据 shardedJedis.setex(“foo”, 2, “foo not exits”); System.out.println(shardedJedis.get(“foo”)); try {Thread.sleep(3000); } catch (InterruptedException e) { } System.out.println(shardedJedis.get(“foo”)); // 获取并更改数据 shardedJedis.set(“foo”, “foo update”); System.out.println(shardedJedis.getSet(“foo”, “foo modify”)); // 截取value的值 System.out.println(shardedJedis.getrange(“foo”, 1, 3)); System.out.println(jedis.mset(“mset1”, “mvalue1”, “mset2”, “mvalue2”, “mset3”, “mvalue3”, “mset4”, “mvalue4”)); System.out.println(jedis.mget(“mset1”, “mset2”, “mset3”, “mset4”)); System.out.println(jedis.del(new String[] { “foo”, “foo1”, “foo3” })); } private void testList() { System.out.println(“=============list==========================”); // 清空数据 System.out.println(jedis.flushDB()); // 添加数据 shardedJedis.lpush(“lists”, “vector”); shardedJedis.lpush(“lists”, “ArrayList”); shardedJedis.lpush(“lists”, “LinkedList”); // 数组长度 System.out.println(shardedJedis.llen(“lists”)); // 排序 System.out.println(shardedJedis.sort(“lists”)); // 字串 System.out.println(shardedJedis.lrange(“lists”, 0, 3)); // 修改列表中单个值 shardedJedis.lset(“lists”, 0, “hello list!”); // 获取列表指定下标的值 System.out.println(shardedJedis.lindex(“lists”, 1)); // 删除列表指定下标的值 System.out.println(shardedJedis.lrem(“lists”, 1, “vector”)); // 删除区间以外的数据 System.out.println(shardedJedis.ltrim(“lists”, 0, 1)); // 列表出栈 System.out.println(shardedJedis.lpop(“lists”)); // 整个列表值 System.out.println(shardedJedis.lrange(“lists”, 0, -1)); } private void testSet() { System.out.println(“=============set==========================”); // 清空数据 System.out.println(jedis.flushDB()); // 添加数据 shardedJedis.sadd(“sets”, “HashSet”); shardedJedis.sadd(“sets”, “SortedSet”); shardedJedis.sadd(“sets”, “TreeSet”); // 判断value是否在列表中 System.out.println(shardedJedis.sismember(“sets”, “TreeSet”)); ; // 整个列表值 System.out.println(shardedJedis.smembers(“sets”)); // 删除指定元素 System.out.println(shardedJedis.srem(“sets”, “SortedSet”)); // 出栈 System.out.println(shardedJedis.spop(“sets”)); System.out.println(shardedJedis.smembers(“sets”)); // shardedJedis.sadd(“sets1”, “HashSet1”); shardedJedis.sadd(“sets1”, “SortedSet1”); shardedJedis.sadd(“sets1”, “TreeSet”); shardedJedis.sadd(“sets2”, “HashSet2”); shardedJedis.sadd(“sets2”, “SortedSet1”); shardedJedis.sadd(“sets2”, “TreeSet1”); // 交集 System.out.println(jedis.sinter(“sets1”, “sets2”)); // 并集 System.out.println(jedis.sunion(“sets1”, “sets2”)); // 差集 System.out.println(jedis.sdiff(“sets1”, “sets2”)); } private void testSortedSet() { System.out.println(“=============zset==========================”); // 清空数据 System.out.println(jedis.flushDB()); // 添加数据 shardedJedis.zadd(“zset”, 10.1, “hello”); shardedJedis.zadd(“zset”, 10.0, “:”); shardedJedis.zadd(“zset”, 9.0, “zset”); shardedJedis.zadd(“zset”, 11.0, “zset!”); // 元素个数 System.out.println(shardedJedis.zcard(“zset”)); // 元素下标 System.out.println(shardedJedis.zscore(“zset”, “zset”)); // 集合子集 System.out.println(shardedJedis.zrange(“zset”, 0, -1)); // 删除元素 System.out.println(shardedJedis.zrem(“zset”, “zset!”)); System.out.println(shardedJedis.zcount(“zset”, 9.5, 10.5)); // 整个集合值 System.out.println(shardedJedis.zrange(“zset”, 0, -1)); } private void testHash() { System.out.println(“=============hash==========================”); // 清空数据 System.out.println(jedis.flushDB()); // 添加数据 shardedJedis.hset(“hashs”, “entryKey”, “entryValue”); shardedJedis.hset(“hashs”, “entryKey1”, “entryValue1”); shardedJedis.hset(“hashs”, “entryKey2”, “entryValue2”); // 判断某个值是否存在 System.out.println(shardedJedis.hexists(“hashs”, “entryKey”)); // 获取指定的值 System.out.println(shardedJedis.hget(“hashs”, “entryKey”)); // 批量获取指定的值 System.out.println(shardedJedis.hmget(“hashs”, “entryKey”, “entryKey1”)); // 删除指定的值 System.out.println(shardedJedis.hdel(“hashs”, “entryKey”)); // 为key中的域 field 的值加上增量 increment System.out.println(shardedJedis.hincrBy(“hashs”, “entryKey”, 123l)); // 获取所有的keys System.out.println(shardedJedis.hkeys(“hashs”)); // 获取所有的values System.out.println(shardedJedis.hvals(“hashs”)); }
篇16：oracle学习笔记命令和函数
，
select months_between(to_date('01-31-1999','MM-DD-YYYY'),to_date('12-31-1998','MM-DD-YYYY')) “MONTHS” FROM DUAL;
1
2．Months_between(日期1,日期2)
返回日期1和日期2之间的月数
select months_between(
to_date('2010-2-1','yyyy-mm-dd'),
to_date('2010-3-1','yyyy-mm-dd')
) from dual;
结果：-1
3．Add_months(日期,n)
把n个月加到日期上
select add_months(sysdate,'1') from dual;
结果：2010-9-24 15:53:12
4．Next_day(日期，字符串)
返回下一个由字符串（星期几）指定的日期
select next_day(to_date('2010-2-1','yyyy-mm-dd'),'星期一') from dual;、
结果：2010-2-8
注意：因为安装时中文的oracle 所以这里要用星期一
5．Last_day(日期)
返回该日期所在月份的最后一天
select last_day(to_date('2010-2-1','yyyy-mm-dd')) from dual;
结果：2010-2-28
6、to_char（日期，格式）
格式：
Yyyy:完整的年份
Year:年份的英文表示
MM:两位数表示月份
Month:月份完整的英文表示
Dy:用3个英文字符缩写表示星期几
Day: 星期几的完整英文表示
DD:几号的数字表示
select to_char(to_date('2010-2-1','yyyy-mm-dd'),'dy') from dual;
结果：星期一
select to_char(to_date('2010-2-1','yyyy-mm-dd'),'yyyy') from dual;
结果：2010
select to_char(to_date('2010-2-1','yyyy-mm-dd'),'year') from dual;
结果：twenty ten
select to_char(to_date('2010-2-1','yyyy-mm-dd'),'month') from dual;
结果：2月
7．To_char(数字，格式)
格式：
9:一位数字
0:显示前导零
$:显示美元符号
L: 显示本地货币符号
.:显示小数点
,:显示千位符
MI: 在数的右边显示减号
PR:把复数用尖括号括起来
select to_char(20,9) from dual;
结果：##
select to_char(2,9) from dual;
结果：2
select to_char(3434,9999.99) from dual;
结果：3434.00
select to_char(3434,9999.90) from dual;
结果：3434.0
select to_char(03434,'L99999.00') from dual;
结果： ￥3434.00
select to_char(03434,'L09999.00') from dual;
结果： ￥03434.00
select to_char(123,'009') from dual;
结果：123
select to_char(123,'00999') from dual;
结果：00123
select to_char(-123,'999PR') from dual;
结果：<123>
select to_char(-123,'999MI') from dual;
结果：123-
8．To_number(字符串)
篇17：SQLSERVER命令总结
SQL SERVER命令总结
查询语句:
SELECT [ALL/DISTINCT][TOP]
<目标列>[as 别名][,<目标列1>as 别名]…
FROM <表名或视图名>[as 别名]…
[WHERE 条件表达式…]
[GROUP BY <列名1>[HAVING<条件表达式>]]
[ORDER BY<列名2>[ASC/DESC]]
应该注意:SELECT语句的顺序:
SELECT-->FROM-->WHERE-->GROUP BY-à HAVING àORDER BY
SELECT INTO:生成新表格
DISTINCT:唯一
GROUP BY:分组汇总
ORDER BY:排序,默认情况下为升序.
ASC:升序
DESC:降序
AS:起别名
HAVING:筛选分组汇总后的行
SELECT TOP n
SELECT TOP n PERCENT*FROM<表名>:表示按一定的百分比提取
LIKE:模糊查询,仅于CHAR或是VERCHAR以及通配符连用
其他模糊查询:
IN:用于返回给定的值与列表中的值相匹配的行
BETWEEN…AND…:在..之间查询
IS NOT NULL:查询不为空的数据
查询中使用的常量:一般与 “+”连用.起到一个组合的目的
注意
1. SELECT后面的字段如果不包括聚合函数,必须参加分组(GROUP BY
2. GROUP BY后面不能使用聚合函数
3. 查询时,可以使用2个聚合函数
使用INSERT插入数据
ü 添加完整记录:
INSERT [INTO]<目标表名>VALUES
VALUES:字段值列表(顺序与建表的顺序必须一样)
ü 添加不完整记录:
INSERT [INTO]<目标表名>(字段名列表)VALUES<字段值列表>
特别的记住:字段名列表和字段值列表是一一对应的.即后面的字段值随着前面的字段名的改变而改变.
另一种方法:
语法:INSERT<表名>SELECT
还可以将数据有选择性的添加到另一个表中
语法:INSERT INTO Sales(Stor_id)SELECT stor_id FROM Stores
UPDATE语句
更新一行:
UPDATE<新表名>SET<目标列 值=“值”>[WHERE<条件>](范围)
更新多行:
UPDATE<表名>SET<目标列 值=“值”>;{<---没有WHERE}
更新一行和更新多行的区别在于有没有WHERE的存在
DELETE语句
1:删除一行:
语法:DELETE FROM<表名>[WHERE<条件>]
2:删除多行:
语法:DELETE FROM<表名>
删除一行和删除多行区别在于有没有WHERE的存在
3:TRUNCATE TABLE
用于删除表中所有行的命令.DROP删除表
与DELETE的区别在于:TRUNCATE不写日值文件,无法恢复数据
JOIN语句 联接信息:
Table_a AS table_alias_a JOIN table_b AS table_alias_b
On
table_alias_a .
?--------------------公共字段---------------------------à
A:内联接
INNER JOIN:查询两个表中的公共部分
B:外联接
左外联接:left OUTER JOIN
右外联接:right OUTER JOIN
完整联接:FULL OUTER JOIN
C:自联接
创建表的结构
1.名称：表名 字段名
2.数据类型： 系统定义的
用户定义的: exec sp_addtype 用户定义的数据类型名 , 数据类型(系统有的),not null(是否允许为空)
3.大小:
4.约束:
主键约束 PRIMARY KEY create table 表名(字段 数据类型 primary key /
primary key(字段…))
唯一约束 UNIQUE create table 表名(字段数据类型 unique)
默认约束DEFAULT create table 表名(字段 数据类型 default ‘值/表达式’)
检查约束 CHECK create table 表名(字段 数据类型 check (字段的表达式)
外键约束 FOREIGN KEY create table表名(字段 数据类型 foreign key references(应用) 另一个表名(字段))
更新表的结构
1.修改数据类型：alter table 表名 alter column 列名 数据类型
2.添加一列： alter table 表名 add 列名数据类型
3.删除一列： alter table 表名 drop column 列名
4.增加约束： alter table 表名 add constraint 约束名 约束表达式
主键约束： primary key（列名列表）
唯一约束： unique（列名）
默认约束： default ‘值’for 列名
检查约束： check （列的检查约束表达式）
外键约束： foreign key（列名）references 表名（列名）
删除表的结构
drop table 表名
子查询
Select 字段 from 表（select查询）
子查询就是内层查询产生一个用于外层查询的条件
子查询经常使用的是条件运算符（>,<,<=,>=,=,!=）
子查询与in联合使用经常用于判断一列数据
子查询与exists联合使用经常用于判断一张表的字段
触发器
1，触发器:是一种特殊存储过程,它能对有触发器的表中的数据进行保护.
2。触发器主要通过操作事件(insert,update,delete)进行触发而被自动执行，
不能被调用，也不能传递参数
3。a)触发器根据数据修改语句可分为：insert触发器，update触发器，delete触发器
b)根据引起触发时刻可分为after触发器，instead触发器。
i.after触发器是在执行数据操作之后激发
ii.instead of 触发器是在执行数据操作之前激发
iii.一个表可以建立多个after触发器，可以建立一个instead of触发器
触发器中的inserted表和deleted表
1。触发器运行后在内存中自动创建。
2。他们用于对触发器执行后某些数据的测试条件
3。用户不能直接操作2个表
4。delete触发器将删除的内容放在deleted表中。
insert触发器将添加的内容存在inserted表中。
update触发器将替换前的内容放在deleted表中，将替换后的新内容放在inserted表中。
创建触发器：
CREATE TRIGGER 触发器名
ON 表名/视图名
FOR 触发器类型
AS
……T-SQL语句
例如：
/*如果被删除的学生有考试成绩的话，就不允许删除这个学生*/
create trigger t_stu
on tbl_stu
for delete
begin
declare @id int
select @id = stuid from deleted
if exists(select * from tbl_cj where stuid = @id)
begin
print '学生有成绩,不可删除!!'
rollback transaction
end
end
delete tbl_stu where stuid = 1007—当删除时，看消息框提示
删除触发器：drop trigger 触发器名
例如：drop trigger t_stu
修改触发器：将创建触发器的create关键字更换成alter
存储过程
存储过程：是存储在salserver服务器中的一组预编译过的t-sql语句，当第一次调用后，就驻留在内存中，以后调用时不必再进行编译。优点在于一次编写，多次调用。调用过程在服务器端执行，执行速度快。
存储过程分为：系统存储过程，系统存储过程。
存储过程语法：
create procedure 存储过程名 @参数 参数类型
as
任意数量的T-SQL语句
例如：
create procedure stu_name @stuname char(10)
as
select * from stu
调用存储过程 exec 存储过程名 参数
例如：exec stu_name 'aa'
事务
--显示事务
Create table aaa
(
Aid int ,
Aname char(10),
Asex char(2) check(asex in (‘m’,’n’))
)
Set xact_abort on
Begin transaction
Intsert into aaa values(101,’aa’,’n’)
Intsert into aaa values(102,’bb’,’m’)
Intsert into aaa values(103,’cc’,’n’)
Intsert into aaa values(104,’dd’,’a’)
Intsert into aaa values(105,’ee’,’m’)
If @@error = 0
Commit
Else
Rollback
Go
Select * from aaa
Drop table aaa
--隐性事务
Set xact_abort on
Set implicit_transactions on
Create table aaa
(
Aid int ,
Aname char(10),
Asex char(2) check(asex in (‘m’,’n’))
)
Intsert into aaa values(101,’aa’,’n’)
Intsert into aaa values(102,’bb’,’m’)
Intsert into aaa values(103,’cc’,’n’)
Intsert into aaa values(104,’dd’,’a’)
Intsert into aaa values(105,’ee’,’m’)
Commit
--默认提交事务
Create table aaa
(
Aid int ,
Aname char(10),
Asex char(2) check(asex in (‘m’,’n’))
)
Intsert into aaa values(101,’aa’,’n’)
Intsert into aaa values(102,’bb’,’m’)
Intsert into aaa values(103,’cc’,’n’)
Intsert into aaa values(104,’dd’,’a’)
Intsert into aaa values(105,’ee’,’m’)
/*-------------------------------------------------------------------
Commit :提交事务中的一切操作，使得事务对数据库的修改有效
Rollback：回滚事务中的一切操作，使得事务对数据库的操作无效
--------------- ---------------------------------------------------
事务控制语句
1． 设置隐性事务模式
1） set implicit_transactions on启动隐性事务模式
2） set implicit_transactions off 关闭隐性事务模式
2． 设置自动回滚模式
1） set xact_abort on 当事务中任意一条语句产生运行时错误，整个事物将中止，并整体回滚，
2） set xact_abort off 当事务中语句产生运行时错误，将中止本条语句并且回滚本条语句。
注意：set xact_abort 的设置是在执行或运行时设置，而不是在分析时设置。
--------------------------------------------------------------
首次执行下列语句都会自动启动一个隐性事务：
Alter table,create,delete,drop,fetch(读取),grant（授予）,insert,open,revoke（撤销）,select,truncate table,update
事务中不可以使用的语句：
1. 数据库创建:create database
2. 数据库修改:alter database
3. 数据库删除:drop database
4. 数据库备份:dump database,backup database
5. 数据库还原:load database,restore database
6. 事务日志备份:dump transaction,backup log
7. 事务日志还原:load transcation,restore log
8. 配置:reconfigure
9. 磁盘初始化:disk init
10. 更新统计数据:updata statistics
11. 显示或设置数据库选项:sp_dboptin
游标
游标：允许用户能够从select语句查询的结果集中，逐条访问纪录，可以根据用户需要逐行的显示、修改、删除这些记录的数据访问处理机制。（游标就是数据表上的指针）
使用游标的步骤：
（1） 声明游标
declare 游标名 cursor for select 语句
（2） 打开游标
open 游标名
1） 当游标被打开时，指针会自动指在第一行；
2） 打开游标后，如果@@error＝0表示游标打开操作成功；
3） 打开游标后，可以用@@cursor_rows返回纪录行数；
（3） 处理数据：
a) 移动到当前行并读取数据
fetch游标名
b) 删除当前行数据
delete from 表名／视图名 where current of游标名
c) 修改当前行数据
update from表名／视图名 set 列名＝表达式 where current of 游标名
（4） 关闭游标
close 游标名
（5） 释放游标
deallocate 游标名
游标类型：
（1）static：静态，当用户A察看表中记录的同时，如果有用户B修改表中记录，A用户将不会看到B修改的纪录，只看A使用open打开表时所看到的纪录。
（2）Dynamic：动态，当用户A察看表中记录的同时，如果有用户B修改表中记录，A用户将看到B修改的纪录，也就是表中记录会不断的刷新，但是会耗费较大的系统资源。
（3）Forward Only：仅向前，游标仅能向前滚动。
（4）Scroll：滚动，游标可以前后左右滚动。
select * from student
/*打开游标，读取数据*/
declare c_stu cursor keyset for select * from student
open c_stu
if @@error = 0
print '学生总数' + convert(char(5),@@cursor_rows)
else
print '读取学生数出错！'
close c_stu
deallocate c_stu
---------------------------------------------------------------------------------------------------------
--keyset:键集游标,当游标打开时，在tempdb数据库中自动创建keyset表，用来记录游标读取的数据（仅纪录表示字段）
---------------------------------------------------------------------------------------------------------
/*使用游标处理数据*/
--使用游标，在表中逐行读取
select * from student
declare c_stu cursor for select * from student
open c_stu
fetch next from c_stu
while @@fetch_status = 0
fetch next from c_stu
close c_stu
deallcoate c_stu
-------------------------------------------------------------------------------------------------------
--fetch的使用
--1.first：移动到第一行，并作为当前行
--2.next:移动到下一行，并作为当前行
--3.prior:移动到上一行，并作为当前行
--4.last:移动到最后一行，并作为当前行
--5.absolute n:n>0时，从第一行开始，移动n行，作为当前行，n<0时，从最后一行倒数n行，作为当前行。
--6.relative n:n>0时，从当前行正数移动n行，作为当前行，n<0时，从当前行倒数n行，作为当前行。
--7.打开游标后第一次执行fetch next可以得到表中第一条数据，执行fetch prior得不到任何数据
--8.可用@@fetch_status返回执行fetch操作后游标的状态：
---- 0表示成功读取。
---- -1表示读取操作超出结果集。
---- -2表示行在表中不存在。
-------------------------------------------------------------------------------------------------------
--修改数据，将数据表中的第2行数据的姓名改成“张三”
select * from student
declare c_stu cursor for select * from student
open c_stu
fetch c_stu
fetch c_stu
update student set sname = '张三' where current of c_stu
close c_stu
deallocate c_stu
------------------------------------------------
--update student set sname = '张三' where current of c_stu
--如果去掉where current of c_stu，不进行指定，将更新表中所有字段
------------------------------------------------
--删除数据，将表中第2行数据删除
select * from student
declare c_stu cursor for select * from student
open c_stu
fetch c_stu
fetch c_stu
delete from student where current of c_stu
close c_stu
deallocate c_stu
函数
/*--------------------------------------
自定义函数的种类：
√ 1.标量函数
√ 2.内嵌表函数
3.多语句表值函数
---------------------
标量函数基本语法
create function 函数名
returns 返回的参数类型 as
begin
函数体
return 函数返回的标量值
end
--------------------------
内嵌表函数语法
create function 函数名
returns table as
return (select查询语句)
-------------------------------------*/
/*----------------------------------------
注意：函数是可以带参数的，但是参数不可以是：
1.时间戳(timestamp)
2.游标(cursor)
3.表(table)
----------------------------------------*/
/*------------------------------------------------------------------------
标量函数
create function chinacode(@str varchar(255))
returns char(2) as
begin
declare @i int,@j int
set @i = len(@str)
set @j = 1
while (@j<=@i)
begin
if(unicode(substring(@str,@j,1))<256)
return '否'
set @j = @j + 1
end
return '是'
end
select dbo.chinacode('我是中国人')
select dbo.chinacode('我,是中国人')
select dbo.chinacode('ilovechina')
-------------------------------------------------------
substring(expression , start , length ) 字符串截取函数
expression :字符串
start :是一个整数，表示截取的位置
length :是一个整数，表示一次截取的长度
-------------------------------------------------------
-------------------------------------------------------------------------*/
/*------------------------------------------------------------------------
内嵌表函数
-------------------------------------------------------------------------
1.内嵌表
create function age(@maxage int,@minage int)
returns table as
return(select * from tbl_stu where stuage < @maxage and stuage >@minage)
select * from age(13,11)
------------------------------------------------------------------------
2.内嵌视图
create function grade(@ss float)
returns table as
return(select * from stu_cj_view where sumscore >@ss)
select * from grade(200)
-------------------------------------------------------------------------*/
/*---------------------------------------
修改函数
把create function写成alter function
删除函数
drop function 函数名
----------------------------------------*/
篇18：安装年度总结
一、严格落实“三检制”，确保施工质量。
质量是企业的命脉，日常工作中我通过“三检制”、“三率跟踪回访”等手段，严格施工质量管理，学标准，用标准，严把质量关。在日常工作中，我除了在生产会上对当天工程中应注意的质量问题加以强调，提醒广大职工在施工中严格把关外；对于重点项目的施工，我注重现场检查指导，发现问题立即要求整改，努力将事故隐患消除在萌芽状态；另外，今年我们还特别强调了“三率”跟踪的实施，组织有关人员随时对施工项目进行跟踪回访，征求乙方的意见和建议，对出现的问题及时进行整改，确保后期验收工作的顺利开展。与此同时，对出现的问题落实到责任人，严格执行奖惩制度，强化全队的质量管理，提高广大职工的责任意识、服务意识。近年来，我队工程质量合格率、服务满意率均达到100％。项目《运用qc方法，创建优质工程》获得XXXqc管理成果三等奖。
二、以提高广大职工的`技术业务水平为目的，抓好职工培训工作。
在职工培训工作中，我以“素质升级”为总目标，以改变现有职工队伍素质的结构要素为基本手段，充分利用焊接培训基地的有利条件，大力开展职工技能训练、技术交流和创新实践活动。成立技术强化培训学习小组，引导职工立足岗位成材，使他们的技能水平迅速提升，并带动周围的一大批职工积极投身到学业务、练本领的洪流中。我队多名职工在职工技术比赛中取得第一、二名的优异成绩，并且XXX还在局第十二届、第十三届职工技术比赛中取得了气焊工第三名、第九名的好成绩。我单位被授予××××基层培训示范基地，《××××》被推荐为精品职工培训项目。
三、打破惯性思维，用创新的思想开展工作。
作为一名专业技术人员，我深知熟练掌握本职技术及多方面业务知识是顺利完成工作的前提，因此，我在工作中时刻不忘勤奋学习，刻苦钻研，大胆创新，提出各种建设性意见和合理化建议，提高自己解决现场实际问题的能力，为基层建设、科学施工、降本增效做出积极贡献。多年来，有我参与并完成的《文化整合在企业管理中的推广与应用》、《实施梯形激励模式，铸就上产钢铁防线》、《维修全天候抢险体系的设计与运行》、《合理使用胶木螺丝，解决防爆问题的建议》等多项成果分别获得厂现代化管理成果、厂科技创新成果二、三等奖，为全队的发展建设做出了自己的贡献。
四、与班子成员团结协作，积极投身全队生产经营建设。
在生产实践中，我团结广大干部、职工一起对本单位生产、安全、技术和管理上存在的问题进行技术攻关、革新改造和提合理化建议，近年来由我提出的合理化建议20余条，采纳10余条，为该队生产经营做出了积极贡献。我还从本单位实际出发，成立“××”青年突击队，塑造了一支技术精湛、作风过硬的青工队伍，20xx年××××团支部被评为全国“五四”红旗团支部，并被授予“山东省青年突击队标兵”荣誉称号。
以上是我对近年来主要工作的简要汇报，在今后的工作中我会继续努力提高自身的综合素质，为石油事业的发展做出自己更大的贡献.
★ 国务院命令范文
★ 命令格式优秀
★ 任职命令范文
★ 提干命令范文
★ 公文命令格式
★ 授衔命令范文
Redis总结笔记（一）：安装和常用命令（精选18篇）
