旅行の梦

Investment01

2026-04-03T03:03:24.000Z

1. 移动平均线 (MA)

定义：计算一段时间内的平均价格，平滑价格波动，反映趋势方向。
常见类型：
- 简单移动平均线 (SMA)：如5日、10日、20日、50日。
- 指数移动平均线 (EMA)：更重视近期价格，反应更快。
使用方法：
- 金叉：短期均线（如5日）上穿长期均线（如20日），看涨信号。
- 死叉：短期均线下穿长期均线，看跌信号。
- 支撑/阻力：均线常作为动态支撑或阻力位。
应用：判断趋势方向，适合中长期交易。

2. 相对强弱指数 (RSI)

定义：衡量价格超买或超卖的震荡指标，范围0-100。
计算：RSI = 100 - [100 / (1 +平均上涨幅度/平均下跌幅度)]，通常取14日。
使用方法：
- 超买：RSI > 70，可能回调，考虑止盈。
- 超卖：RSI < 30，可能反弹，考虑买入。
- 背离：价格创新高而RSI未创新高，暗示反转。
应用：捕捉短期买卖点，适合震荡行情。

3. 随机震荡指标(Stochastic Oscillator, KDJ)

定义：比较收盘价与一段时间内价格范围的关系，判断超买超卖。
组成：%K（快线）、%D（慢线），范围0-100。
使用方法：
- 超买：%K > 80，可能下跌。
- 超卖：%K < 20，可能上涨。
- 交叉信号：%K上穿%D为买入信号，反之为卖出信号。
应用：短线交易，适合波动市场。

4. 布林带 (BollingerBands)

定义：由中轨（通常20日SMA）和上下轨（中轨±2倍标准差）组成，反映价格波动范围。
使用方法：
- 突破上下轨：价格突破上轨看涨，下轨看跌，但需确认趋势。
- 收窄：布林带收窄预示大行情将至。
- 反弹：价格触碰上下轨后常回撤至中轨。
应用：判断趋势强度和反转点，适合波段交易。

5. MACD(指数平滑异同移动平均线)

定义：通过快线（DIF）、慢线（DEA）和柱状图（MACD）分析趋势和动能。
计算：
- DIF = 12日EMA - 26日EMA
- DEA = DIF的9日EMA
- MACD柱 = DIF - DEA
使用方法：
- 金叉：DIF上穿DEA，买入信号。
- 死叉：DIF下穿DEA，卖出信号。
- 柱状图：柱由负转正看涨，由正转负看跌。
应用：捕捉趋势转折，适合中短期交易。

6. 平均真实波幅 (ATR)

定义：衡量价格波动幅度，常用于设定止盈止损。
计算：取一段时间内真实波幅（TR）的平均值，TR =Max(高-低, |高-前收|, |低-前收|)。
使用方法：
- 止损：买入价 - 2×ATR。
- 止盈：买入价 + 3×ATR。
应用：动态调整交易范围，适合波动性大的股票。

7. 成交量 (Volume)

定义：反映市场参与度和资金流动，需结合K线分析。
使用方法：
- 放量上涨：看涨，趋势可能持续。
- 缩量下跌：可能反弹，卖压减弱。
- 异常放量：结合K线形态判断反转或突破。
应用：验证K线信号的可靠性。

8. 斐波那契回调(Fibonacci Retracement)

定义：利用斐波那契比例（23.6%、38.2%、50%、61.8%）预测支撑和阻力位。
使用方法：
- 从波段低点拉到高点，回调至38.2%或50%可能是买入点。
- 从高点拉到低点，反弹至61.8%可能是卖出点。
应用：确定关键价格区间，适合波段交易。

9. 一目均衡表 (IchimokuCloud)

定义：综合指标，包括转换线、基准线、云带等，反映趋势、支撑阻力。
使用方法：
- 价格在云带上方：看涨。
- 价格在云带下方：看跌。
- 云带颜色变化：绿色看涨，红色看跌。
应用：全面判断趋势，适合中长期分析。

10. 支撑位与阻力位

定义：基于历史K线高低点，判断价格可能停顿或反转的区域。
使用方法：
- 支撑位：历史低点或密集成交区，跌至此处可能反弹。
- 阻力位：历史高点或密集成交区，涨至此处可能回落。
应用：结合K线形态设定止盈止损。

如何结合K线使用技术指标

确认趋势：
- 用MA或MACD判断大方向，避免逆势操作。
寻找买卖点：
- RSI、KDJ、布林带适合捕捉超买超卖信号。
验证信号：
- 成交量和K线形态（如锤头线、吞没形态）确认指标信号。
设定止盈止损：
- ATR和支撑阻力位提供具体价格参考。

示例

假设当日K线：开盘100元，收盘103元，最高105元，最低98元。 -MA：5日均线102元，价格突破看涨。 -RSI：若为75，接近超买，考虑止盈。 -布林带：上轨106元，接近时可止盈；下轨97元，跌破可止损。- MACD：DIF上穿DEA，买入信号。

注意事项

指标局限：单一指标可能失灵，建议组合使用（如MACD+RSI）。
时间周期：短线用1分钟/5分钟K线，长线用日K线或周K线。
市场环境：震荡行情用RSI/KDJ，趋势行情用MA/MACD。

pmp

2020-09-26T15:16:32.000Z

2020-09-26-PMP

pyData

2020-09-23T08:48:03.000Z

2020-09-23-pyData

一、环境搭建

pip常用命令

#查找模块
pip search <包名>
#安装/更新/卸载模块
pip install -r requirements.txt -i SOURCE
    pip install / uninstall <包名>
    pip install -U <包名>
#列出已安装模块
    pip freeze >requirements.txt#导出模块清单
    pip list

#指定全局安装源
##在unix和macos，配置文件为：$HOME/.pip/pip.conf
##在windows上，配置文件为：%HOME%\pip\pip.ini
    ## 阿里源
    [global]
    timeout = 6000
    index-url = http://mirrors.aliyun.com/pypi/simple/
    trusted-host = mirrors.aliyun.com
## 豆瓣源
[global]
    timeout = 6000
index-url = http://pypi.douban.com/simple
trusted-host = pypi.douban.com
#解决 ModuleNotFoundError: No module named 'pip'
python -m ensurepip
python -m pip install --upgrade pip 
python -m pip install --upgrade setuptools
#源
##豆瓣 http://pypi.douban.com/ 
##中国科学技术大 http://pypi.mirrors.ustc.edu.cn/simple/ 
##清华：https://pypi.tuna.tsinghua.edu.cn/simple
##阿里云：http://mirrors.aliyun.com/pypi/simple/

安装virtualenv与virtualenvwrapper-win模块

pip3 install virtualenv
pip3 install virtualenvwrapper-win

WORKON_HOME
Path:

常用命令

mkvirtualenv pyData#创建虚拟环境
lsvirtualenv / workon#查看虚拟环境
workon pyData#进入虚拟环境
rmvirtualenv pyData#删除虚拟环境
deactivate#停止 虚拟环境

二、数据可视化库Matplotlib快速入门

三、科学计算库NumPy快速入门

五、数据分析库Pandas快速入门

六、Python爬虫

Linux Tools

2019-11-29T07:19:44.000Z

2019-11-29-LinuxTools

Linux 系统观测工具

系统负载及性能

1. uptime

root@192.168.1.161:~$uptime
10:30:06 up 10 days, 19:26,  1 user,  load average: 3.05, 2.81, 2.15

1、当前时间 10:30:06
2、系统已运行的时间 10 days, 19:26
3、当前前在线用户 1 user
4、平均负载：0.54, 0.40, 0.20，最近1分钟、5分钟、15分钟系统的负载
5、load average数据是每隔5秒钟检查一次活跃的进程数，然后按特定算法计算出的数值。如果这个数除以逻辑CPU的数量，结果高于5的时候就表明系统在超负荷运转了；

2. dmesg

3. top

top参考
系统运行时间和平均负载
Tasks — 任务（进程），系统现在共有137个进程，其中处于运行中的有1个，136个在休眠（sleep），stoped状态的有0个，zombie状态（僵尸）的有0个
CPU 状态
- us, user: 运行(未调整优先级的) 用户进程的CPU时间 √
- sy，system: 运行内核进程的CPU时间 √
- ni，niced: 运行已调整优先级的用户进程的CPU时间
- wa，IO wait: 用于等待IO完成的CPU时间
- hi: 处理硬件中断的CPU时间
- si: 处理软件中断的CPU时间
- st：这个虚拟机被hypervisor偷去的CPU时间（译注：如果当前处于一个hypervisor下的vm，实际上hypervisor也是要消耗一部分CPU处理时间的）
内存使用
- 第一行是物理内存使用，第二行是虚拟内存使用(交换空间)
- 第四行的free + 第四行的buffers + 第五行的cached √

top - 10:41:25 up 10 days, 19:37,  1 user,  load average: 0.34, 1.03, 1.56
Tasks: 137 total,   1 running, 136 sleeping,   0 stopped,   0 zombie
%Cpu(s): 16.6 us,  1.7 sy,  0.0 ni, 81.2 id,  0.3 wa,  0.0 hi,  0.3 si,  0.0 st
KiB Mem :  7730168 total,   204536 free,  7324360 used,   201272 buff/cache
KiB Swap:  5242876 total,   399728 free,  4843148 used.    81848 avail Mem

  PID USER PR  NI  VIRT    RES    SHR  S  %CPU %MEM   TIME+   COMMAND
21257 xy   20  0   4757972 990552 3384 S  12.0 12.8   3173:53 /opt/xy/java+

16.6% us — 用户空间占用CPU的百分比；1.7% sy — 内核空间占用CPU的百分比。
0.0% ni  — 改变过优先级的进程占用CPU的百分比
81.2% id — 空闲CPU百分比
0.3% wa — IO等待占用CPU的百分比
0.0% hi — 硬中断（Hardware IRQ）占用CPU的百分比
0.3% si — 软中断（Software Interrupts）占用CPU的百分比

命令	描述
d	指定刷新时间（s）
M	按内存占用率显示
P	按CPU占用率显示
T	按累计时间显示
c	切换显示命令名称和完整命令行

4. htop

CPU使用率

1. vmstat(Virtual MeomoryStatistic)

对系统的整体情况进行统计，对系统的整体情况进行统计
r经常大于4，id经常少于40，表示cpu的负荷很重;bi，bo长期不等于0，表示内存不足;disk经常不等于0，且在b中的队列大于3，表示io性能不好
-f,--fork 显示从系统启动至今的fork数量
-s 显示内存相关统计信息及多种系统活动数量
-d,--disk 查看磁盘的读写

Procs（进程）
- r: 运行队列中进程数量
- b: 等待IO的进程数量
Memory（内存）
- swpd: 使用虚拟内存大小
- free: 可用内存大小
- buff: 用作缓冲的内存大小
- cache: 用作缓存的内存大小
Swap
- si: 每秒从交换区写到内存的大小
- so: 每秒写入交换区的内存大小
IO(现在的Linux版本块的大小为1024bytes）
- bi: 每秒从块设备接收到的块数，单位：块/秒也就是读块设备
- bo: 每秒发送到块设备的块数，单位：块/秒也就是写块设备
系统
- in: 每秒中断数，包括时钟中断[interrupt]
- cs: 每秒上下文切换数[count/second]
CPU(以百分比表示)
- us: 用户进程执行时间(user time)
- sy: 系统进程执行时间(system time)
- id: 空闲时间(包括IO等待时间),中央处理器的空闲时间,以百分比表示
- wa: 等待IO时间

root@192.168.1.161:~$vmstat 5 5  # 5s内采集5个样本
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
4  0 4216792 187800      0 212148   88   40   746    84    9    4 10  2 86  2  0

root@192.168.1.161:~$vmstat -a 2 5  # -a,--active
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r  b   swpd   free  inact active   si   so    bi    bo   in   cs us sy id wa st
1  0 4215656 196520 1385284 5829956   88   40   746    84    9    5 10  2 86  2  0

2. mpstat

主要用于多CPU环境下，它显示各个可用CPU的状态
mpstat -P CPU 时间间隔采集次数

root@192.168.1.161:~$mpstat -P ALL
Linux 3.10.0-693.el7.x86_64 (centos) 2019年11月29日 _x86_64_(4 CPU)

12时10分00秒  CPU    %usr   %nice    %sys %iowait    %irq   %soft  %steal  %guest  %gnice   %idle
12时10分00秒  all    9.62    0.00    1.44    2.34    0.00    0.35    0.01    0.00    0.00   86.24

3. sar(System ActivityReporter)

参考sar
sar [options][-o file] [t] [n]
t为采样间隔，n为采样次数，默认值是1；

%nice：显示在用户级别，用于nice操作，所占用 CPU 总时间的百分比
%steal：管理程序(hypervisor)为另一个虚拟进程提供服务而等待虚拟 CPU的百分比。
%idle：显示 CPU 空闲时间占用 CPU 总时间的百分比。

root@192.168.1.161:~$sar -u -o test 10 3  # 周期 次数
Linux 3.10.0-693.el7.x86_64 (centos) 2019年11月29日 _x86_64_(4 CPU)

12时16分46秒     CPU     %user     %nice   %system   %iowait    %steal     %idle
12时16分56秒     all     12.16      0.00      1.90      5.22      0.00     80.72

root@192.168.1.161:~$sar -u -f test# 查看

4. pidstat

主要用于监控全部或指定进程占用系统资源的情况，如CPU，内存、设备IO、任务切换、线程等
cpu使用情况统计(-u)
内存使用情况统计(-r) IO情况统计(-d)

5. dstat

综合了vmstat，iostat，ifstat，netstat
dstat [option] [time] [count]
常用选项：-l,–load; -m,–memory; -tcp

内存使用率

free -m

进程

vmstat 1：查看进程是否阻塞（r）
pidstat 1：查看每个进程的情况”

磁盘IO

iostat -xzm 1

网络IO

sar -n DEV 1
sar -n TCP,ETCP 1

6. 磁盘扩容

df -h # 查看分区空间使用情况-T,显示文件系统类型
- parted -l
- lsblk -f
- file -s /dev/sda1
du -sh * # 查看文件所占用大小
fdisk -l # 查看磁盘

6.1 新增加的磁盘

[root@anyue ~]# pvs             # 查看新增加的盘
[root@anyue ~]# fdisk /dev/sdb  # 建立新分区更改类型为8e
[root@anyue ~]# mkfs.ext4 /dev/sdb1
[root@anyue ~]# pvcreate /dev/sdb1      # pvscan
[root@anyue ~]# vgextend VolGroup /dev/sdb1     # 当前需要扩容的LVM的组名，通过lvs查看
[root@anyue ~]# lvextend -L +20G /dev/mapper/VolGroup-lv_root 
[root@anyue ~]# resize2fs -p /dev/mapper/VolGroup-lv_root

6.2 从其他分区获得空间,/home299G

[root@anyue ~]# umount /home    # 提到无法卸载，fuser -m /home
[root@anyue ~]# e2fsck -f /dev/mapper/VolGroup-lv_home
[root@anyue ~]# resize2fs -p /dev/mapper/VolGroup-lv_home 279G
[root@anyue ~]# mount /home     # 此时可查看 df -h /home
[root@anyue ~]# lvreduce -L 279G /dev/mapper/VolGroup-lv_home   # -L,减小到20G；-l,减小20G；+
[root@anyue ~]# lvextend -L +20G /dev/mapper/VolGroup-lv_root
[root@anyue ~]# resize2fs -p /dev/mapper/VolGroup-lv_root

SPL

2019-11-20T08:06:25.000Z

2019-11-20-SPL

堆栈队列

参考

参考1
参考2
参考3
堆：
- 堆是在程序运行时，而不是在程序编译时，申请某个大小的内存空间。即动态分配内存，对其访问和对一般内存的访问没有区别。
- 堆是应用程序在运行的时候请求操作系统分配给自己内存，一般是申请/给予的过程。
- 堆是指程序运行时申请的动态内存，而栈只是指一种使用堆的方法(即先进后出)。
堆区：由程序员分配释放，若程序员不释放，程序结束时可能有OS回收（引用类型值）。
栈：
- 一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
- 栈就是一个桶，后放进去的先拿出来，它下面本来有的东西要等它出来之后才能出来（先进后出）。
- 栈(Stack)是操作系统在建立某个进程时或者线程（在支持多线程的操作系统中是线程）为这个线程建立的存储区域。
栈区：由编辑器自动分配释放，存放函数的参数值，局部变量的值等（基本类型值）。
队列：
- 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行删除操作的端称为队头，进行插入操作的端称为队尾。
- 队列中没有元素时，称为空队列。
- 建立顺序队列结构必须为其静态分配或动态申请一片连续的存储空间，并设置两个指针进行管理。一个是队头指针front，它指向队头元素；另一个是队尾指针rear，它指向下一个入队元素的存储位置。
- 队列采用的FIFO(first in firstout)，新元素（等待进入队列的元素）总是被插入到链表的尾部，而读取的时候总是从链表的头部开始读取。每次读取一个元素，释放一个元素。所谓的动态创建，动态释放。因而也不存在溢出等问题。由于链表由结构体间接而成，遍历也方便。（先进先出）
堆栈的特性：
- 堆本身就是栈，最后一个放入堆栈中的物体总是被最先拿出来，这个特性通常称为后进先出(LIFO)队列。
- 堆栈中定义了一些操作，两个最重要的是PUSH和POP。PUSH操作在堆栈的顶部加入一个元素。POP操作相反，在堆栈顶部移去一个元素，并将堆栈的大小减一。

链表

链表中每一个元素都是一个对象，每个对象称为一个节点，包含有数据域key和指向下一个节点的指针next。通过各个节点之间的相互连接，最终串联成一个链表。

关于SPL

SPL:Search ProcessLanguage(搜索处理语言)

AND OR () NOT 
通配符：'* ? []'
field:[x TO y]

cat /var/log/messages |grep Error |awk '{print substr($3,1,5)}' |sort |uniq -c |sort -nr |head 10 
source:"/var/log/messages" Error |bucket timestamp sapn=1m as ts |stats count() by ts |sort by 'count()' |limit 10

常用命令

stats

提供统计信息，可以选择按照字段分组(单值统计)
* count() – 返回字段出现次数，统计事件数
1
2
3
# 统计ip和stats的组合的事件数量
logtype:apache 
|stats count() by apache.clientip,apache.status

avg() – 返回字段平均值

# 统计平均值
logtype:apache 
|stats avg(apache.resp_len) as avg_resp_len by apache.request_path 
|rename avg_resp_len as "平均响应长度"

sum()

1
2
3

# 统计日志量
* |stats sum(raw_message_length) as byte 
|eval Mb=byte/1024/1024

max()
min()
dc() – 返回字段唯一个数，去重，dedup field

bucket

将字段连续的值放到离散的数据桶中，可用于后续的stats等命令分组字段中

/*每1小时跨度内每个hostname的apache.resp_len平均值*/
logtype:apache 
|bucket timestamp span=1h as ts 
|stats avg(apache.resp_len) by hostname,ts 
|eval ts_human=foramtdate(ts)
/******/
/*返回apache.status为100-200，200-400，400以上的apache.status事件数*/
logtype:apache 
|bucket apache.status ranges=((100,200),(200,400),(400,)) as rs 
|stats count(apache.status) by rs

rename

重命名指定字段，支持对多字段同时进行重命名用,分开，支持通配符
1
2
logtype:apache 
|rename apache.clientip as "ip地址"

eval

计算表达式并将生成值放到新的字段中，存在将覆盖
常用函数：todouble()、formatdate(timestamp,“HH:mm”)
* 根据响应时间获取short,middle,long三个分类值
1
2
3
4
5
6
7
8
9
10
11
logtype:apache 
|eval length=case(apache.resp_len<1500,"short",apache.resp_len>2000,"long",default,"middle") 
|stats count(desc) by desc
/********************************/

logtype:apache 
|eval desc=if(apache.status==20,"OK","Error") 
|stats count(desc) by desc
/********************************/
logtype apache 
|eval int status=tolong(apache.status)

fileds

保留搜索结果中的字段，支持通配
1
2
3
logtype:apache 
|stats count() by appname,hostname 
|fields appname,hostname

table

将查询结果以表格形式展示，并对字段进行筛选，若不包含空行显示，支持通配符
1
2
3
4
5
* |table apache.status,apache.method
/*****/  
appname:nginx AND nginx.request_time:* 
|eval new_reuqest_time=todouble(nginx.request_time) 
|table nginx.client_ip.geo.ip,nginx.client_ip.geo.isp,nginx.client_ip.gep.province

makeresults

构造指定的结果
* 产生一条结果并生成新的app字段，用于后续map命令
1
2
3
* | makeresults count=1 
|eval app="zookeeper" 
|map "* appname:$app$"

where

使用表达式对结果进行过滤

1
2
3

logtype:apache AND apache.geo.city:"深圳市" 
|stats dc(apache.clientip) as dc_count by apache.request_path 
|where dc_count>40 && dc_count<100

top

获取字段出现次数前N的值集合
1
* |top 5 nginx.client_ip.geo.province

limit

返回前n个结果

logtype:apache |limit 2
/*******/
logtype:apache 
|stats count() by apache.clientip 
|limit 5

sort

按照指定字段对搜索结果排序，+升序，-降序

logtype:apache |sort by +timestamp
/********/
logtype:apache 
|stats count(apache.clientip) as ip_count by appname 
|sort by -ip_count

join

对父管道结果和子管道结果进行类似SQL的join，关联分析
type=left/inner (取左/取并)
* 统计昨天每个小时每个IP的事件数占当前这个小时总数的百分比
1
2
3
4
5
6
7
8
9
logtype:apache 
|bucket timestamp span=1h as ts 
|stats count() as ip_count by apache.clientip,ts 
|join type=left ts [[ 
  logtype:apache 
  |bucket timestamp span=1h as ts 
  |stats count() as hour_count by ts
  ]] 
|eval ippercent=100*ip_count/hour_count

按照运营商ISP统计总数，status：400-499数量及占比，status：500-599数量及占比，请求长度大于1000数量及占比，形成一张统计表

logtype:apache 
|stats count(logtype) as count_all by apache.geo.isp 
|sort by count_all 
|limit 5
/**************/
logtype:apache AND apache.status:[400 TO 499] 
|stats count(logtype) as count_400 by apache.geo.isp
/**************/
logtype:apache AND apache.status:[500 TO 599] 
|stats count(logtype) as count_500 by apache.geo.isp
/**************/
logtype:apache AND apache.resp_len>1000 
|stats count(logtype) as len_1000 by apache.geo.isp
/**************/
logtype:apache 
|stats count(logtype) as count_all by apache.geo.isp 
|sort by count_all 
|limit 5 
|join type=left apache.geo.isp [[ 
  logtype:apache AND apache.status:[400 TO 499] 
  |stats count(logtype) as count_400 by apache.geo.isp
  ]]  
|join type=left apache.geo.isp [[ 
  logtype:apache AND apache.status:[500 TO 599] 
  |stats count(logtype) as count_500 by apache.geo.isp
  ]] 
|join type=left apache.geo.isp [[
  logtype:apache AND apache.resp_len>1000 
  |stats count(logtype) as len_1000 by apache.geo.isp
  ]]

append

将子管道结果附加在主管道结果之后，可以将不同类型数据进行关联分析，子查询*主管道统计大前天的平均响应值，append命令中子管道统计昨天的平均值，其结果合并在一张表中

starttime="-3d/d" endtime="-2d/d" * 
|stats avg(apache.resp_len) 
|eval day="the day before yesterday" 
|append [[
  starttime="-1d/d" endtime="now/d" * 
  |stats avg(apache.resp_len) 
  |eval day="yesterday"
  ]]
/**************/
starttime="-1d/d endtime=now/d" 
|bucket timestamp span=1h as ts 
|eval time=formatdate(ts,"HH") 
|stats count() as _count by time 
|eval group="yesterday" 
|append [[
  starttime="now/d endtime=now" 
  |bucket timestamp span=1h as ts 
  |eval time=formatdate(ts,"HH") 
  |stats count() as _count by time 
  |eval group="today"
  ]]

autoregress

一般用作行与行之间的值计算，计算指标数据，如环比， *按小时统计事件数，并计算出当前小时和上个小时的事件变化率

* |bucket timestamp span=1h as ts 
|stats count() as count_ by ts 
|autoregress count_ as last_count p=1 
|eval a=(last_count-count_) / count_ 
|eval change_rate=format("%.3f%%",(last_count - count_)*100 / count_)
/**************/
starttime="-2h/h" endtime="now/h" * 
|bucket timestamp span=10m as ts 
|stats count() as count_app by ts \
|eval time=formatdate(ts) 
|autoregress count_app p=3

lookup

外部导入生成新字段 * csv文件字段host,user,department将搜索结果的hostname字段与csv文件的host进行关联
1
2
3
logtype:apache 
|stats count() by hostname 
|lookup user,department /data/rizhiyi/share/host_user.csv on hostname=host

map

引用上次搜索结果 *列出日志数最多的三种logtype他们各自最大的日志文本长度
1
2
3
4
5
* |stats count() by logtype 
|limit 3 
|rename logtype as type 
|map "logtype:$type$ 
|stats max(raw_message_length)"

parse

搜索时抽取字段
* 从原文中抽取IP地址，得到新的字段ip_addr分组并计算appname的个数
1
2
* |parse "(?\d+\.\d+\.\d+\.\d+)" 
|stats count(appname) by ip_addr

parsedate

时间处理

1
2
3

|makeresults count=1 
|eval pd=parsedate("28/04/2019:12:01:01","dd/MM/yyyy:HH:mm:ss") 
|eval fd=formatdate(bd,"yyyy/dd/MM HH:mm:ss")

esma智能运维

对某一个字段的未来值进行预测
* 统计过去一年的每天平均延迟，推测接下来一个月网络延迟
1
2
3
* |bucket timestamp span=1d as ts 
|stats avg(network.latency) as latency by ts 
|esma latency timefield=ts period=7 futurecount=30

主机内存使用预测

appname:top_info_system_stats AND ip:192.168.10.1 
|bucket timestamp span=10m as ts 
|stats avg(json.Mem.used_percent) as mem_use by ts 
|esma mem_use timefield=ts

movingavg

计算移动平均值
*以分钟为单位统计apache返回apache_len长度的和，以10为窗口计算移动平均值，得到每分钟的响应长度和平滑后的值
1
2
3
4
logtype:apache 
|bucket timestamp span=1m as ts 
|stats sum(apache.resp_len) as sum_len by ts 
|movingavg sum_len,10 as moving_avg_resp_len

rollingavg

计算移动标准差 *以时间分组算出apache返回的reponse长度的和，以10为窗口计算rolling的标准差，观察resp_len的波动情况
1
2
3
logtype:apache 
|stats sum(apache.resp_len) as sum_resp_len by timestamp 
|rollingstd sum_resp_len,10 as resp_len_rolling_std

transpose

将查询的表格数据进行行列转换

1 2	`* \|stats count() as cnt by apache.method,apache.status \|transpose row=apache.method column=apache.status valuefield=cnt`

Zookeeper和Kafka

2019-11-08T14:58:30.000Z

2019-11-08-Zookeeper&Kafka

Zookeeper

Zookeeper官网

1. 什么是Zookeeper?

Zookeeper是开源分布式的，为分布式应用提供协调服务的Apache项目；
Zookeeper是一个基于观察者模式设计的分布式服务管理框架，负责存储和管理数据，接受观察者的注册，数据状态一旦发生变化，Zookeeper负责通知已经在Zookeeper注册的观察者做出相应的反应；
应用场景：统一命名服务；统一配置管理；统一集群管理；监控服务器动态上下线；软负载均衡；

2. Zookeeper特点

2.1 Zookeeper的设计目标

一个Leader，多个Follwers；
集群只要有半数以上节点存活，集群就可以正常服务，适合安装奇数台服务器；
全局数据一致，每个Server保存一份相同数据副本；
数据更新原子性，要么成功，要么失败；
实时性：一定时间内，Client能读到最新数据；
顺序性：来自同一个Client的更新请求按其发送顺序一次执行；

2.2Zookeeper数据模型和分层名称

类似于Unix文件系统，每个节点称为ZNode，默认存储1MB的数据，每个节点可以通过其路径唯一表示；

3. Zookeeper的使用

3.1 下载地址

Zookeeper下载地址

3.2 本地模式安装部署

JDK

vim /etc/profile

JAVA_HOME=/opt/jdk1.8
JRE_HOME=$JAVA_HOME/jre
CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$JAVA_HOME/bin:$PATH

解压Zookeeper到/opt

3.3 修改配置文件

路径：/zookeepr-version/conf

mv ./zoo_sample.cfg ./zoo.cfg && mkdir zkData

vim zoo.cfg

tickTime=2000 # 通信心跳时间 2s，S-C
initLimit=10  # 2sx10=20s，初始Leader与Followed通信时限
syncLimit=5   # LF同步通信时限，5x2s=10s
clientPort=2181   # 监听客户端连接端口号
dataDir=/opt/zookeeper-version/zkData # 数据文件目录和数据持久化路径

启动zookeeper服务端&客户端
- ./bin/zkServer.sh start
- jps # Java Virtual Machine Process Status Tool
- ./bin/zkCli.sh -server IP # Command lineIteraction

3.4 测试

命令	说明
ls	查看节点
–	watch, 监听节点变化
create	创建节点
–	-s, 自动建立序号
delete	删除节点
set	设置节点值
get	获取节点的值
–	watch, 监听节点值的变化
stat	查看节点状态

连接到Zookeeper：
$ bin/zkCli.sh -server 127.0.0.1:2181 # help查询帮助命令

创建znode

[zkshell: 9] create /zk_test "my_data"    # 要有相应的值 
Created /zk_test

[zkshell: 11] ls /
[zookeeper, zk_test]

[zkshell: 12] get /zk_test    # set /zk_test junk     delete /zk_test
my_data
cZxid = 5
...
numChildren = 0

4. 分布式安装部署(建议奇数台)

vim conf/zoo.cfg
tickTime=2000
dataDir=/var/lib/zookeeper
clientPort=2181
initLimit=5
syncLimit=2
server.1=zoo1:2888:3888 # zoo1建议为主机名； 
server.2=zoo2:2888:3888 # 2888：该server与集群leader server交换信息的端口；
server.3=zoo3:2888:3888 # 3888选举端口；

# 配置myid 在数据目录下
vim myid
1

Kafka

Kafka官网

1. 什么是Kafka？

Kafka是一个分布式的基于发布/订阅模式的消息队列(MessageQueue)，主要应用于大数据领域的实时计算以及日志采集。

2. 什么是Message Queue？

消息队列比作是一个存放消息的容器，需要使用消息的时候可以取出消息供自己使用，消息队列是分布式系统中重要的组件，目前使用较多的消息队列有ActiveMQ，RabbitMQ，Kafka，RocketMQ；队列Queue 是一种先进先出的数据结构。

消息队列的模式：
>点对点模式，消费者主动拉取数据，消息收到后消息清除（阅后即焚）；

> 发布-订阅模式，发布到Topic数据不会清除，分为push / pull；

优点：
> 1）通过异步处理提高系统性能（削峰、减少响应所需时间）；
>2）降低系统耦合性，消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息；

3. Kafka的4个核心API

Producer API：允许应用程序发布的记录流至一个或多个Kafkatopics。
Consumer API：允许应用程序订阅一个或多个主题，并处理所产生的记录流。
Streams API：允许应用程序扮演流处理器，从一个或多个主题消耗的输入流，并产生一个输出流至一个或多个输出的主题，有效地把输入数据流转变输出流。
Connector API：允许构建和运行可重复使用的生产者或消费者，将Kafkatopics连接到现有的应用程序或数据系统。例如，关系数据库的连接器可能会捕获对表的所有更改。
在Kafka中，客户端和服务器之间的通信是通过简单，高性能，与语言无关的TCP协议完成的。

topics：主题是被发布记录的一种类别或者订阅名称，Kafka的主题是通常是多用户的，也即一个主题可以有零个，一个或者多个消费者来订阅写入该主题的数据；对于每个主题，Kafka集群都会维护一个分区日志。

4. kafka架构：

Producer：消息生产者，就是向kafkabroker发消息的客户端；
Consumer：消息消费者，向kafkabroker取消息的客户端；
Consumer Group （CG）：kafka用来实现一个topic消息的广播（发给所有的consumer）和单播（发给任意一个consumer）的手段；广播的实现：让每一个Consuner拥有独立的CG；
- 第一：同一个消费者组里面，只能有一个消费者去消费分区的数据；
- 第二：同一个消费者组里面是不会重复消费消息的；
- 第三：同一个消费者组的一个消费者不是以一条一条数据为单元的，是以分区为单元，就相当于消费者和分区建立某种socket，进行传输数据，所以，一旦建立这个关系，这个分区的数据只能是由这个消费者消费；
Broker：一台kafka服务器就是一个broker；一个集群由多个broker组成。一个broker可以容纳多个topic；
Topic：可以理解为一个队列；
Partition：为了实现扩展性，数据量大的topic可以分布到多个broker（即服务器）上，一个topic可以分为多个partition，每个partition是一个有序的队列。partition中的每条消息都会被分配一个有序的id（offset）。kafka只保证按一个partition中的顺序将消息发给consumer，不保证一个topic的整体（多个partition间）的顺序；
Offset：kafka的存储文件都是按照offset.kafka来命名，用offset做名字的好处是方便查找。例如你想找位于2049的位置，只要找到2048.kafka的文件即可。当然thefirst offset就是00000000000.kafka；
Zookeeper：存储Kafka集群信息，实现集群的高可用；

5. kafka安装部署：

5.1 下载地址

依赖于Zk

5.2 安装部署

1	`tar -xzvf kafka_version.tgz -C /opt/`

五笔和双拼

2019-11-05T10:46:43.000Z

2019-11-05-五笔和双拼

Linux笔记

2019-10-31T09:12:13.000Z

2019-10-31

用户操作练习

# 创建一个用户mandriva，其ID号为2002，基本组为distro（组ID为3003），附加组为linux
groupadd -g 3003 distro
groupadd linux
useradd -u 2002 -g distro -G linux mandriva

# 创建一个用户fedora，其全名为Fedora Community，默认shell为tcsh
useradd -c "Fedora Community" -s /bin/tcsh fedora

# 修改mandriva的ID号为4004，基本组为linux，附加组为distro和fedora
usermod -u 4004 -g linux -G distro,fedora mandriva

# 给fedora加密码，并设定其密码最短使用期限2D，最长为50D
passwd -n 2 -x 50 fedora

# 将mandriva的默认shell修改为/bin/bash
usermod -s /bin/bash mandriva

# 添加系统用户hbase，且不允许登录系统
useradd -r -s /sbin/nologin hbase

# 新建一个没有家目录的用户openstack
useradd -M openstack

权限练习

# 复制/etc/skel 为/home/openstack
cp -r /etc/skel /home/openstack

# 改变/home/openstack及其内部文件的属主属组均为openstack
chown -R openstack.openstack /home/openstack

# /home/openstack及其内部文件属主与其他用户没有任何访问权限
chmod -R go= /home/openstack

统计

# 统计/usr/bin目录下的文件个数
ls /usr/bin |wc -l

# 取出当前系统上所有用户的shell，每种shell只显示一次，并且按顺序进行显示
cat /etc/passwd |cut -d: -f7 |sort -u

# 如何显示/var/log目录下每个文件的内容类型？
file /var/log/* 
file $(ls /var/log)

# 取出/etc/inittab文件的第六行
head -n6 |tail -n1

# 取出/etc/passwd文件中倒数第九个用户的用户名和shell，显示到屏幕并将其保存至/tmp/users文件中
tail -n9 |head -n1 |cut -d: -f1,7 >/tmp/users

# 显示/etc目录所有以pa开头的文件，并统计个数
ls -d /etc/pa* |wc -l

# 不使用文本编辑器将alias cls="clear"添加到当前用户的.bashrc文件中
printf "alias cls=clear">>~/.bashrc

grep/sed/awk

# 找出ifconfig命令结果中的1-255之间的整数
grep -E '(\<([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\>\.){3}\<([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\>'  
  A: 1-127  
  B: 128-191  
  C: 192-223  
grep -E '\<[1-9]|1[1-9]{2}|2[01][0-9]|22[0-3]\>(\.\<([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-4])\>){2}\.\<([1-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-4])\>'

# 删除/etc/grub.conf文件中行首的空白符
sed 's/[[:space:]]+//g' /etc/grub.conf

# 替换/etc/inittab文件中"id:3:initdefault"一行中的数字5
sed 's@\(id:\)[0-9]\(:initdefault:\)@\15\2@g' /etc/inittab 

# 删除/etc/inittab文件中的空白行
sed '/^$/d' /etc/inittab

# 删除/etc/inittab文件开头的#号
sed 's/^#//g' /etc/inittab

# 删除某文件中开头的#及后面的空白字符，但要求#后面必须有空白字符
sed -r 's@^#[[:space:]]+@@' /etc/inittab

# 删除某文件以空白字符且后边跟#号的开头的行的空白字符及#
sed 's/^[[:space:]+#//g' /etc/inittab

# 取出一个文件路径的目录名称
echo '/etc/rc.d' |sed -r 's@^(/.*/)[^/]+/?@\1@g'/etc/
echo '/etc/rc.d' |sed -r 's@^/.*/([^/]+)/?@\1@g'rc.d

find

# 查找/var 下属主为root并且属组为mail的所有文件
find /var -user root -a -group mail

# 查找/usr 下不属于root,bin,或student的文件
find /usr -not \( -user root -o -user bin -o -user student \)
find  /usr -not -user root -a -not -user bin -not -user student

# 查找/etc 下最近一周内内容修改过的且不属于root及student用户的文件
find /etc -mtime -7 -not \( -user root -o -user student \)
find /etc -mtime -7 -not -user root -a -not -user student

# 查找当前系统上没有属主或属组且最近1天内被访问过的文件，并将其属主属组均改为root
find / \( -nouser -o -nogroup \) -a -atime -1 -exec chown root.root {} \;

# 查找/etc下大于1M 的文件，并将其文件名写入/tmp/etc.largefiles文件中
find /etc -size +1M -exec echo {} >>/tmp/etc.largefiles \;  
find /etc -size +1M >>/tmp/etc.largefiles

# xargs - build and execute command lines from standford input
find /etc -size +1M |xargs echo >>/tmp/etc.largefiles 

# 查找/etc下所有用户都没有写权限的文件，显示出详细信息
find /etc -not -perm /222 -ls

磁盘

# 创建5G的分区，文件系统为ext3，卷标为MYDATA，块大小为1024，预留管理空间为磁盘分区3%，要求开机后自动挂载至/data目录，并且自动挂载的设备要使用卷标进行引导
mke2fs -t ext3 -L MYDATA -b 1024 -m 3 /dev/sda2
blkid# 查看磁盘 UUID  TYPE  LABEL等属性  
tune2fs # 调整文件系统属性 -L -m -o
dumpe2fs# 显示文件属性信息  
fsck / e2fsck

# 上述如何操作，让其自动挂载的同时启用ACL功能
/etc/fstab
LABEL='MYDATA'/dataext3defaults,acl0 0

# 创建一个本地回环文件/var/swaptmp/swapfile来用于swap，要求大小为512MB，卷标为SWAP-FILE，且开机自动挂载此交换设备

mkdir /var/swaptmp
dd if=/dev/zero of=/var/swaptmp/swapfile bs=1M count=512
mkswap LABLE=SWAP-FILE /var/swaptmp/swapfile

/var/swaptmp/swapfileswapswapdefaults0 0

Redis

2019-09-14T01:30:20.000Z

2019-09-14-Redis

Redis

介绍

Redis是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用;Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储;Redis支持数据的备份，即master-slave模式的数据备份。

安装

[root@anyue ~]# wget http://download.redis.io/releases/redis-5.0.5.tar.gz
[root@anyue redis-5.0.5]# tar -xzf redis-5.0.5.tar.gz
[root@anyue redis-5.0.5]# make PREFIX=/usr/local/redis install 
[root@anyue redis-5.0.5]# mkdir /usr/local/redis/etc
[root@anyue redis-5.0.5]# cp ./redis.conf /usr/local/redis/etc/
[root@anyue redis-5.0.5]# vim /usr/local/redis/etc/redis.conf   
  daemonize yes  
[root@anyue redis-5.0.5]# ln -s /usr/local/redis/bin/* /usr/local/bin 
[root@anyue redis-5.0.5]# cp /utils/redis_init_script /usr/local/redis/etc/  # 启动脚本
[root@anyue redis-5.0.5]# vim /usr/local/redis/etc/redis_init_script  
#!/bin/sh
# chkconfig: 2345 80 90
# description: source package redis

# Simple Redis init.d script conceived to work on Linux systems
# as it does use of the /proc filesystem.
### BEGIN INIT INFO
# Provides:     redis_6379
# Default-Start:        2 3 4 5
# Default-Stop:         0 1 6
# Short-Description:    Redis data structure server
# Description:          Redis data structure server. See https://redis.io
### END INIT INFO

REDISPORT=6379
EXEC=/usr/local/redis/bin/redis-server
CLIEXEC=/usr/local/redis/bin/redis-cli

PIDFILE=/var/run/redis_${REDISPORT}.pid
CONF="/usr/local/redis/etc/${REDISPORT}.conf"

case "$1" in
start)
if [ -f $PIDFILE ]; then
echo "$PIDFILE exists, process is already running or crashed"
else
echo "Starting Redis server..."
$EXEC $CONF &
fi
;;
stop)
if [ ! -f $PIDFILE ]; then
echo "$PIDFILE does not exist, process is not running"
else
PID=$(cat $PIDFILE)
echo "Stopping ..."
$CLIEXEC -p $REDISPORT shutdown
while [ -x /proc/${PID} ]
do
echo "Waiting for Redis to shutdown ..."
sleep 1
done
echo "Redis stopped"
fi
;;
*)
echo "Please use start or stop as first argument"
;;
esac
[root@anyue redis-5.0.5]# ln -s /usr/local/redis/etc/redis_init_script /etc/init.d/redisd  
[root@anyue redis-5.0.5]# chkconfig --add redisd`  # 加入开机自启

使用

string 类型及操作

1	`[root@anyue redis-5.0.5]# redis-cli -h 127.0.0.1 -p6379 -apasswd # 远程`

待续。。。

ES

2019-09-14T00:30:20.000Z

2019-09-14-ElasticSearch

rsync 同步服务：

rsync基本使用：

选项	说明
-a	归档模式
-v	显示同步过程
-z	传输时压缩

下载: rsync -avz 服务器IP:/服务器目录/file /本地目录

  rsync -avz root@192.168.37.10:/filesrc/text.txt /filedst/
  ```  

+ 上传: rsync -avz /本地目录/file 服务器IP:/服务器目录/*

rsync -avz /filedst/test.txtroot@192.168.37.10:/filesrc/

    
*ssh-keygen -t rsa -b 2048*  
*ssh-copy-id root@192.168.37.20*  

#### rsync服务端(NFS服务器)
```bash
[root@xy ~]# vim /etc/rsyncd.conf  
  address = 192.168.37.10 #rsync服务绑定IP
  port = 873
  log file =/var/log/rsyncd.log 
  pid file = /var/run/rsyncd.pid
  [web]
      comment = web directory backup
      path = /filesrc
      read only = no
      dont commpress = *.gz *.bz2
      auth users =user1   # 非系统用户, 自行创建
      secrets file = /etc/rsyncd_users.db
[root@xy ~]# vim /etc/rsyncd_users.db   
  user1:123456
[root@xy ~]# chmod 600 /etc/rsyncd_users.db 
[root@xy ~]# rsync --daemon  
[root@xy ~]# netstat -antp |grep :873  
[root@xy ~]# setfacl -m u:nobody:rwx /filesrc

客户端

1 2	[root@xy ~]# rsync -avz rsync://user1@192.168.37.10/filesrc /filedst # 下载 [root@xy ~]# rsync -avz /filedst/* rsync://user1@192.168.37.10/filesrc` # 上传

rsync(基于xinetd)+ inotifywait 实现单向实时同步：

inotifywait 命令选项	说明
-m	始终保持监听
-r	递归查询目录
-q	只打印监控事件信息

服务端

[root@xy ~]# yum -y install gcc*  
[root@xy ~]# tar -xvf inotify-tools-3.14.tar.gz 
[root@xy ~]# cd inotify-tools-3.14.tar.gz
[root@xy ~]# ./configure && make make install  

# 监控动作：modify,create,attrib,move,delete 
[root@xy ~]# inotifywait -mrq -e 监控动作1,监控动作2 /监控目录 &     
[root@xy ~]# inotifywait -mrq -e create,delete,modify /filesrc &   
  #!/bin/bash  
  Inotfiy = "inotifywait -mrq -e create,delete,modify /filesrc"
  Rsync = "rsync -avz /filesrc/* root@192.168.37.20:/filedst"
  $Inotfiy | while read directory event file
  do
     $Rsync
  done

rsync(基于xinetd) +unison + inotify 实现双向实时同步：

服务端(192.168.37.10)

[root@xy ~]# tar -xzvf inotify-tools-3.14.tar.gz  
[root@xy ~]# cd inotify-tools-3.14
[root@xy ~]# ./configure && make && make install  
[root@xy ~]# tar -xzvf ocaml-3.10.1.tar.gz 
[root@xy ~]# cd ocmal-3.10.1
[root@xy ~]# ./configure
[root@xy ~]# make world opt
[root@xy ~]# make install
[root@xy ~]# tar -xzvf unison-2.13.16.tar.gz
[root@xy ~]# cd unison-2.13.16
[root@xy ~]# make UISTYLE=text THREADS=true STATIC=true  
[root@xy ~]# cp unison /usr/local/bin 
  #!/bin/bash  
  Inotfiy = "inotifywait -mrq -e create,delete,modify /filesrc"
  Unison = "/usr/local/bin/unison -batch /filesrc ssh://192.168.37.20/filedst"
  $Inotfiy | while read directory event file
  do
     $Unison
  done

客户端(192.168.37.20)

安装inotify-tools-3.14.tar.gz，ocaml-3.10.1.tar.gz，unison-2.13.16.tar.gz

#!/bin/bash  
Inotfiy = "inotifywait -mrq -e create,delete,modify /filesrc"
Unison = "/usr/local/bin/unison -batch /filedst ssh://192.168.37.10/filesrc"
$Inotfiy | while read directory event file
do
  $Unison
done

Linux 日志概述

系统常见日志文件

syslog服务
- syslogd：系统
- klogd：内核

日志文件	说明
/var/log/cron	定时任务log
/var/log/cpus	打印信息log
/var/log/dmesg	内核自检log, `dmesg`
/var/log/btmp	错误登录log, 二进制格式, 用`lastb`查看
/var/log/lastlog	最后一次登录时间log, `lastlog`查看
/var/log/mailog	邮件log
/var/log/messages	系统重要信息log
/var/log/secure	验证与授权log
/var/log/wtmp	永久记录所有用户登录, `last`查看
/var/run/utmp	当前已经登录用户信息, `w who users`查看
/var/log/httpd	RPM安装apache服务默认日志目录

日志格式: syslog 服务

配置路径: /etc/syslog.conf
配置格式: 日志服务[链接符号]日志等级日志记录位置

35 # Include all config files in /etc/rsyslog.d/
36 $IncludeConfig /etc/rsyslog.d/*.conf
54 *.info;mail.none;authpriv.none;cron.none      /var/log/messages 
55 authpriv.*                                   /var/log/secure
56 *.emerg                                      *   # 每个用户
60 mail.*                                      -/var/log/maillog    # 异步写入

日志等级（从低到高）	说明(级别越低，信息越详细)
debug	一般调试信息
info	基本通知信息
notice	普通信息
wraning	警告信息
err/error	错误信息
crit	大于err
alert	警告,大于crit
emerg/panic	会导致系统不可用
*	所有日志等级
none	和* 相反

日志轮替 logrotate(切割,轮替)

旧日志移动开改名,同时建立新的空日志文件,当旧日志文件超出保存范围,会进行删除,系统自带配置文件/etc/logrotate.conf

20 # no packages own wtmp and btmp -- we'll rotate them here
21 /var/log/wtmp {
22     monthly
23     create 0664 root utmp
24     minsize 1M
25     rotate 1
26 }

配置参数	说明
daily	日志轮替周期是每天
weekly	每周
monthly	每月
compress	日志轮替时,压缩旧日志
rotate	保留日志个数
create mode owner group	建立新日志,指定权限与所有者/所属组
mail address	发送邮件
missingok	日志不存在忽略日志警告信息
notifempty	若日志为空,不进行轮替
minsize	轮替最小值
size	大于size才会轮替
dateext	使用日期作为轮替文件后缀
sharedscripts	此关键字后脚本只执行一次
prerotate/endscript	轮替前执行脚本
postrotate/endscript	轮替后执行脚本

ELK(Elasticsearch+Logstash+Kibana)### ELK日志分析：

ELK是三个开源软件的缩写，分别表示：Elasticsearch、Logstash、Kibana它们都是开源软件,新增了FileBeat，轻量级的日志收集处理工具；

Filebeat：属于Beats
- Filebeat：搜集文件数据 √
- Packetbeat：搜集网络流量数据
- Topbeat：搜集系统、进程和文件系统级别的CPU和内存使用情况
- Winlogbeat：搜集Windows事件日志数据
Logstash(5044)：负责日志的收集、分析、功率，支持大量数据获取方式，C/S架构，client端安装在需要收集日志的主机上，server端负责将收集到的节点日志进行过滤发至Elastiserach上;
ElastiSearch(9200)：开源分布式搜索引擎，提供搜集、分析、存储数据三大功能;
Kibana(5601)：为 Logstash 和 Elasticserach 提供Web界面;

数据存储

索引分片副本

参考
index索引:就类似于关系型数据库的数据库，数据库建立好，然后就把数据存到index中；
- Mapping:定义文档字段的类型；
- Settimt:定义不同数据分布；
shard分片:对于分布式的搜索引擎,索引通常都会分解成不同部分,而这些分布在不同节点的数据就是分片,一个分片只存储一部分数据，所有分片加起来就是一个完整的索引数据；
- 分片分为primaryshard主分片和replica副本分片,一个索引可以创建多个分片数量，es默认创建的就是5个主分片数量，可以根据自己的实际业务确定主分片数量;
- 注意的是主分片数量一旦确定创建就无法进行修改。
replica副本:就是对主分片（Primary shard）的备份；
- 每个主分片（primary shard）不会和副本分片（replicashard）存在于同一个节点中，有效的保证es的数据高可用性；

ELK 服务端部署(192.168.37.10)

Docker部署01
Docker部署02
K8S部署

配置JAVA环境

[root@xy elk]# mkdir /usr/local/java
[root@xy elk]# tar -xzvf  jdk-8u261-linux-x64.tar.gz -C /usr/local/java
[root@xy ~]# vim /etc/profile
  # JAVA ENVIRONMENT
  export JAVA_HOME=/usr/local/java/jdk1.8.0_261
  export CLASSPATH=.:$JAVA_HOME/jre/lib/rt.jar:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
  export PATH=$PATH:$JAVA_HOME/bin
[root@xy ~]# source /etc/profile
[root@xy ~]# java -version   # 验证

安装包

[root@xy ~]# mkdir /elk;cd /elk  
[root@xy elk]# wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.2.3.tar.gz
[root@xy elk]# wget https://artifacts.elastic.co/downloads/logstash/logstash-6.2.3.tar.gz
[root@xy elk]# wget https://artifacts.elastic.co/downloads/kibana/kibana-6.2.3-linux-x86_64.tar.gz
[root@xy elk]# tar -xzvf elasticsearch-6.2.3.tar.gz 
[root@xy elk]# tar -xzvf logstash-6.2.3.tar.gz
[root@xy elk]# tar -xf kibana-6.2.3-linux-x86_64.tar.gz

配置 elasticserch

[root@xy elk]# chown -Rf root:root kibana-6.2.3-linux-x86_64
[root@xy elk]# cp -a elasticsearch-6.2.3/ logstash-6.2.3/ kibana-6.2.3-linux-x86_64/ /usr/local
[root@xy elk]# yum install -y java-1.8*   # JAVA 环境
[root@xy elk]# useradd elasticsearch   
[root@xy elk]# chown elasticsearch:elasticsearch /usr/local/elasticsearch-6.2.3/
[root@xy elk]# su elasticsearch  # 以elasticsearch 用户运行
[elasticsearch@xy elasticsearch-6.2.3]$ ./bin/elasticsearch -d  
[elasticsearch@xy elasticsearch-6.2.3]$ netstat -antp  # 9200端口  
[elasticsearch@xy elasticsearch-6.2.3]$ cat /usr/local/elasticserch-6.2.3/logs/elasticsearch.log
[elasticsearch@xy elasticsearch-6.2.3]$ curl localhost:9200

配置 logstash

[root@xy logstash-6.2.3]# vim /vendor/bundle/jruby/2.3.0/gems/logstash-patterns-core-4.1.2/patterns/grok-patterns   
  # Nginx log
  WZ ([^ ]*)
  NGINXACCESS %{IP:remote_ip} \- \- \[%{HTTPDATE:timestamp}\] "%{WORD:method} %{WZ:request} HTTP/%{NUMBER:httpversion}" %{NUMBER:status} %{NUMBER:bytes} %{QS:referer} %{QS:agent} %{QS:xforward}
   
[root@xy logstash-6.2.3]# vim /usr/local/logstash-6.2.3/default.conf 
  input {
      beats{
          port => "5044"
      }
  }
  # 数据过滤
  filter {
      grok {
          match => { "message" => "%{NGINXACCESS}" }
      }
      geoip {
          # nginx 客户端 ip
          source => "192.168.37.20"
      }
  }
  # 输出配置为本机的 9200 端口,这是elasticsearch 服务的监听端口
  output {
      elasticsearch {
          hosts => ["127.0.0.1:9200"]
      }
  }
    
[root@xy logstash-6.2.3]# nohup ./bin/logstash -f default.conf &
[root@xy logstash-6.2.3]# tail -f nohup.out
[root@xy logstash-6.2.3]# netstat -antp | grep 5044

配置 Kibana

[root@xy kibana-6.2.3-linux-x86_64]# vim /usr/local/kibana-6.2.3-linux-x86_64/config/kibana.yml  
  server.host: "192.168.37.10"
[root@xy kibana-6.2.3-linux-x86_64]# nohup ./bin/kibana &
[root@xy kibana-6.2.3-linux-x86_64]# tail -f nohup.out
[root@xy kibana-6.2.3-linux-x86_64]# netstat -antp | grep 5601  
# 测试：192.168.37.10:5601   # Kibana 测试地址

问题解决：

max file descriptors [4096] for elasticsearch process is too low,increase to at least [65535]

1
2
3

[elasticsearch@xy ~]$ sudo vim /etc/security/limits.conf
  * soft    nofile          65536
  *    hard    nofile          65536

dockercompose部署ES遇到 Error opening log file ‘logs/gc.log’:Permission denied
- 参考
  1
  - TAKE_FILE_OWNERSHIP=true #volumes 挂载权限问题

Nginx部署(192.168.37.20)

[root@xy ~]# yum install -y nginx  
[root@xy ~]# wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-6.2.3-linux-x86_64.tar.gz  
[root@xy ~]# tar -xzf ./filebeat-6.2.3-linux-x86_64.tar.gz -C /usr/local/  
[root@xy filebeat-6.2.3-linux-x86_64]# vim filebeat.yml  
  enable：false                 #修改为true
  paths：/var/log/*.log         #修改为/var/log/nginx/*.log
  #output.elasticsearch:        #将此行注释掉
  #hosts: ["localhost:9200"]    #将此行注释掉
  output.logstash:              #取消此行注释
  hosts: ["192.168.37.10:5044"] #取消此行注释并修改IP 地址为ELK 服务器地址
[root@xy filebeat-6.2.3-linux-x86_64]# nohup ./filebeat -e -c filebeat.yml &  
[root@xy filebeat-6.2.3-linux-x86_64]# tailf nohup.out

设置服务自启动

#!bin/bash
# chkconfig: 2345 21  89
# description: elasticsearch

# JAVA_HOME=/usr/local/jdk1.8
ES_HOME=/usr/local/elasticsearch
case $1 in
    start) sudo -iu elasticsearch $ES_HOME/bin/elasticsearch &;;
    *)  echo "require start";;
esac
------------------------------------

#!/bin/bash
# chkconfig: 2345 50  50
# description: logstash

LS_HOME=/usr/local/logstash
case $1 in
    start)sudo -iu elasticsearch $LS_HOME/bin/logstash -f $LS_HOME/config &;;
    *) echo "require start";;
esac
-----------------------------------

#!/bin/bash
# chkconfig: 2345 98  02
# description: kibana

KIBANA_HOME=/usr/local/kibana
case $1 in
    start) $KIBANA_HOME/bin/kibana &;;
    *) echo "require start";;
esac

tomcat 服务自启动

#!/bin/bash
# description: Tomcat8 Start Stop Restart
# processname: tomcat8
# chkconfig: 234 20 80

CATALINA_HOME=/usr/local/tomcat8/

case $1 in
    start)
        sh $CATALINA_HOME/bin/startup.sh
        ;;
    stop)
        sh $CATALINA_HOME/bin/shutdown.sh
        ;;
    restart)
        sh $CATALINA_HOME/bin/shutdown.sh
        sh $CATALINA_HOME/bin/startup.sh
        ;;
    *)
        echo 'please use : tomcat {start | stop | restart}'
        ;;
esac
exit 0

python

2019-09-10T15:25:10.000Z

2019-09-10-python

python

注释： 单行#comment 多行'''comment''' """comment"""

python2 -m pip install --upgrade pip  
pip install virtualenv virtualenvwrapper  
virtualenv testvir  
active.bat 或者 deactive.bat  
pip install flask  
pip freeze >requirements.txt

基础语法

1 2	`from package import module import module as alias`

变量和数据类型

对象（object）是内存中专门用来存储数据的一块区域，id&& type && value

变量和对象：
(1)对象并没有直接存储到变量中，Python中变量更像是给对象起了一个别名；
(2)变量中存储的不是对象的值，而是对象的id（内存地址），使用变量时，实际上就是在通过对象id在查找对象；
(3)变量中保存的对象，只有在为变量重新赋值时才会改变；
(4)变量和变量之间是相互独立的，修改一个变量不会影响另一个变量

python中的数据类型: 不可变(Number/String/Tuple) 和可变(list/dict/set)，不可变值得是不允许变量的值发生变化，如果改变变量的值，相当于新建了一个对象，而对于相同值的对象，在内存中只有一个对象。

如果改变数字数据类型的值，意味着是一个新的对象，将会重新分配内存空间

判断是否引用的是同一个对象: x is y,类似于id(x)===id(y)

数据类型

整数、浮点数(1.23x10^9: 1.23e9)

字符串

'abc', "xyz"         >> abc xyz
'I\'m\"OK\"!'        >> I'm OK！
r'\\\t\\'            >> '\\\t\\'  # 原始字符串r
r'''hello,\nworld''' >> 'hello,\\nworld'

布尔值

1
2
3

and: ture and flase  >> false
or:  false or true   >> true
not: not false       >> true

变量

变量名必须是大小写英文、数字和_的组合，且不能用数字开头,Python支持多种数据类型，在计算机内部，可以把任何数据都看成一个“对象”，而变量就是在程序中用来指向这些数据对象的，对变量赋值就是把数据和变量给关联起来.

# -*- coding: utf-8 -*-
a = 'ABC'# 内存中创建'ABC'字符串
b = a# 内存创建变量b指向'ABC'
a = 'XYZ'   # 创建'XYZ', 将a指向此字符串
print(b)

>> ABC

字符串和编码

Python3版本中，字符串是以`Unicode`编码

ord('中')  >> 20013
chr(25991) >> '文'

'中文'.encode('utf-8')
>> b'\xe4\xb8\xad\xe6\x96\x87'

b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
>> '中'

len(b'ABC')  >> 3# 字节
len('中文'.encode('utf-8'))  >> 6

格式化输出(`%`)

%s %d %?

1
2
3

'Hello, %s' % 'world'    >> 'Hello, world'
print('%2d-%02d' % (3, 1))  >> 补空格3-01
print('%.2f' % 3.1415926)   >> 3.14

format()

1	`'Hello, {0}, 成绩提升了{1:.1f}%'.format('小明', 17.125) >> 'Hello, 小明, 成绩提升了17.1%'`

格式化字符串
- 格式化字符串，可以通过在字符串前添加一个f来创建一个格式化字符串
- 在格式化字符串中可以直接嵌入变量
  1
  c = f'hello {a} {b}' \ print(f'a = {a}')

list tuple dict set

list[]

Python内置的数据类型列表：list是一种有序的集合，可以随时添加和删除其中的元素

方法	说明
list.append()	追加元素到末尾
list.insert()	插入到指定位置
list.pop()方法	删除指定位置元素
list.len()	列表元素个数

classmates = ['Michael', 'Bob', 'Tracy']  >> ['Michael', 'Bob', 'Tracy']
len(classmates)  >> 3
classmates[-1]   >> 'Tracy'
classmates[-2]   >> 'Bob'
classmates.append('Adam')  >> ['Michael', 'Bob', 'Tracy', 'Adam']
classmates.insert(1, 'Jack')  >> ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
classmates.pop(3)          >> 'Tracy' -->['Michael', 'Jack', 'Bob', 'Adam']
classmates[1] = 'Sarah'       >> ['Michael', 'Sarah', 'Tracy']

L = ['Apple', 123, True]
s = ['python', 'java', ['asp', 'php'], 'scheme']

tuple()

Python内置的数据类型有序列表叫元组：tuple，tuple和list非常类似，但是tuple一旦初始化就不能修改

classmates = ('Michael', 'Bob', 'Tracy')
t = ('a', 'b', ['X', 'Y'])
>> t[2][0] = 'X'
>> t[2][1] = 'Y'

dict

字典的键可以是任意的不可变对象(int, str,bool, tuple…), 不能重复；字典的值可以是任何对象
{key1:value1,key2:value2,…}

d = dict(name='Li',age='1',gender='boy')
d = dict([('name','Li'),('age','1')])
d = {'name': 'Li', 'age': 1, 'gender': 'boy'}

d['name']>> Li
d['name'] = "Xing"# 修改
d.get('name', default)>> Li # key存在返回对应值，不存在返回默认值
d.pop('name')>> 删除name对应的值

for k in d.keys():# keys()  返回序列，保存由字典所有键
print(k,d[k])

>> name Li
   age 1
   gender by

for v in d.values():  # values()  返回序列，保存由字典所有值
print(v)

for k,v in d.items(): # items() dict_item([('name','Li'), ('age', '1'), ('gender', 'boy')])
print(k , '=' , v)

>> name = Li
   age = 18
   gender = boy

set

集合中只能存储不可变对象，不重复且无序;将字典转为集合只包含字典中键
对于不变对象来说，调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的

s = {'a', 'b', '1,' '2', '3'}  >> {'a', 'b', 1, 2, 3}
s = set([1, 2, 3, 1, 4])>> {1, 2, 3, 4}
s.add(5)
s.remove(4)

条件判断&&循环(注意缩进)

# 判断水仙花数(n>=3)
i = 100
while i < 1000:
bai = i // 100
# shi = (i -a * 100) // 10
shi = i // 10 % 10
ge = i % 10
if bai**3 + shi**3 + ge**3 == i:
print(i)
i += 1
----------------------------------------
# 判断质数(只能被1和它自身整除)
from time import *
begin = time()
num = int(input('输入大于1的整数：'))
i = 2 
while i <= num: # 取出 2-num 所有数
flag = True # 
j = 2
while j <= i ** 0.5:
if i % j == 0:# num不是质数 
flag = False
break
j += 1
if flag:
# pass
print(i)
i += 1
end = time()
print("use time=",end - begin, '秒')
----------------------------------------------
# 99乘法表(嵌套)
i = 0
while i < 9:
i += 1# 外层高度
while j < i:# 内层宽度
j += 1
print(f"{j}*{i}={i*j} ", end="")
print()
----------------------------------------------
# break && continue(对就近循环起作用)
i = 0 
while i < 5:
i += 1
if i == 2:
break# 结束整个循环
continue # 结束当次循环
print(i)
i += 1
else:
print('循环结束')
---------------------------------------------
names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

迭代器：iter和生成器：yield

迭代器是访问集合元素的一种方式，是可以记住遍历的位置的对象，从集合第一个元素开始到所有元素被访问完结束，只能往前不会后退；基本方法iter()和next()，字符串、列表和元组均可用于创建迭代器

生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器，调用一个生成器函数，返回的是一个迭代器对象，在调用生成器运行的过程中，每次遇到yield 时函数会暂停并保存当前所有的运行信息，返回 yield的值, 并在下一次执行 next() 方法时从当前位置继续运行。

import sys
def fibonaci(n,w=0):# 生成器函数:斐波那契
    a, b, counter = 0, 1, 0
    while True:
    if(counter >n):
    return 
    yield a
    a, b = b, a + b
    print('%d,%d' % (a,b))
    counter +=1

f = fibonaci(3,0) # f 是一个迭代器，由生成器返回生成
while True:
try:
print(next(f), enf=" ")
except:
sys.exit()
------------
Output:
0 1,1
1 1,2
1 2,3
2 3,5

函数

概念

函数是一个对象，在内存中专门用来存储数据的一块区域；如果形参执行的是一个对象，当通过形参去改对象时，会影响到所有指向该对象的变量；print(fn)，fn是函数对象，实际是打印函数对象；而print(fn())，则是在打印fn()函数的返回值

定义:

1 2	`def functionName(argu1, argu2, ...): code block`

函数的参数:

位置参数，调用函数时，传入的两个值按照位置顺序依次赋给参数x和n
1
2
3
4
5
6
def power(x,n): s = 1 while n > 0: n = n -1 s = s * x return s

默认参数，必须指向不变对象

def add_end(L=None):
  if L is None:
     L = []
     L.append('END')
  return L

可变参数，允许传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

def calc(*numbers):# *nums表示把nums这个list的所有元素作为可变参数传进去
  sum = 0
  for n in numbers:
    sum = sum + n * n
  return sum
>>> nums = [1, 2, 3]
>>> calc(*nums)
    14

关键字参数，允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)

>>> person('Bob', 35, city='Beijing')
    name: Bob age: 35 other: {'city': 'Beijing'}

递归：

def factorial(n):
'''
求任意数的阶乘
参数: 
n: 要求阶乘的数字
'''
  if n == 1:
    return 1
    return n * factorial(n-1)
------------------------------
def huiWen(s):
'''
判断是否为回文字符串
参数：
s：要检查的字符串
'''
if len(s) == 2:
  return False
elif s[0] != s[-1]:
  return False
return huiWen(s[1:-1])

filter、匿名函数: lambda 与map

filter(function,iterable):可以从序列中过滤出符合条件的元素，保存到一个新的序列对象中，
1
2
a = filter(lambda x: x % 2 == 0, range(10)) >>> <filter object at 0x0000027939040390>
lambda 参数列表 : 返回值:
1
filter(lambda i:i>5,l)
map(function, iterable, ...):可以对可迭代对象中的所有元素做指定操作，然后将其添加到一个新的对象中返回，
1
2
map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) >>> <map object at 0x0000027939040CF8>

闭包：函数嵌套&& 将内部函数作为返回值返回 &&内部函数必须使用到外部函数的变量

def makeAverager():
  nums = []
def averager(n):
  nums.append(n)
  return sum(nums)/len(nums)
return averager

averager = makeAverager()

装饰器:在不改变函数代码的情况下，扩展函数功能

def log(old):
  def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
return wrapper

@log# now = log(now)
def now():
  print('2015-3-25')

>>> now()
  call now():
  2015-3-25

面向对象编程

基础

类：对对象的抽象，是创建对象的模板；属性&&方法
对象：则是由类创建的一个实例，而变量是指向对象的内容，如：a='abc'，经常说的对象a的内容是’abc’，其实是指，a本身是一个变量，它指向的对象的内容才是’abc’

定义类: p1 = Person('an')执行流程

(1)创建一个变量；
(2)在内存中创建新对象；
(3)__init__(self)方法执行，init在对象创建以后执行，用来初始化新创建的对象
(4)将对象的id赋值给变量
(5)self指的是类实例对象本身(注意：不是类本身)

self参考

 class Person:
   def __init__(self, name):# 在对象初始化时执行
     self.name = name    # self为调用该属性/方法实例对象自身 
  # self.__name = name    # 隐藏属性 __name ==> _Person__name
def sayHello(self):
  print('我是：%s' %self.name)
def get_name(self):
  # print('读取属性')
  return self.name
def set_name(self, name):
     # print('设置属性')
  return self.name = name

p1 = Person('an')

特征：

封装:隐藏对象中一些不希望被外部所访问到的属性或方法，确保对象中的数据安全

getter 获取对象中的指定属性（get_属性名）

setter 用来设置对象的指定属性（set_属性名）

class Person:
  def __init__(self,name):
    self._name = name
  def get_name(self):
    return self._name

  def set_name(self , name):
    self._name = name   

 p = Person('孙悟空')
 print(p._name)

继承：实现子类的属性和方法的功能扩展，保证了对象的可扩展性

 class Animal:
   def run(self):
     print('动物会跑~~~')
   def sleep(self):
     print('动物睡觉~~~')
   @property
   def name(self):
     return self._name
   @name.setter    
   def name(self,name):
     self._name = name

 class Dog(Animal):
   def __init__(self,name,age):
       # 调用父类的__init__来初始化父类中定义的属性
       # super() 可以用来获取当前类的父类，
       # 并且通过super()返回对象调用父类方法时，不需要传递self
     super().__init__(name)
     self._age = age
   def bark(self):
     print('汪汪汪~~~') 
   def run(self):
     print('狗跑~~~~') 
   @property
def age(self):
  return self._age
@age.setter    
def age(self,age):
  self._age = name

 d = Dog('旺财',18) 
 print(d.name)       
 print(d.age)

多态：一个对象可以以不同的形态去呈现，保证了程序的灵活性

模块(python文件) 包(文件)

导入模块:

1 2	`import 模块名 import 模块名 as 模块别名`

访问模块变量：模块名.变量名
导入模块部分内容:
1
from 模块名 import 变量 as 别名

异常

print('异常出现前')
l = []
try:
  print(10/0)
except NameError:
  # 如果except后不跟任何的内容，则此时它会捕获到所有的异常
  # 如果在except后跟着一个异常的类型，那么此时它只会捕获该类型的异常
  print('出现 NameError 异常')
except ZeroDivisionError:
  print('出现 ZeroDivisionError 异常')
except IndexError:
  print('出现 IndexError 异常')

# Exception 是所有异常类的父类，所以如果except后跟的是Exception，他也会捕获到所有的异常
# 可以在异常类后边跟着一个 as xx 此时xx就是异常对象
except Exception as e :
  print('未知异常',e,type(e))
finally :
  print('无论是否出现异常，该子句都会执行')

print('异常出现后')
----------------------------------------------------------------------------------
# 自定义异常类，创建一个类继承Exception
class MyError(Exception):
  pass

def add(a,b):
# 如果a和b中有负数，就向调用处抛出异常
  if a < 0 or b < 0:
  # raise用于向外部抛出异常，后边可以跟一个异常类，或异常类的实例
  # raise Exception    
  # 抛出异常的目的
  # raise Exception('两个参数中不能有负数！')  
  raise MyError('自定义的异常')

  # 也可以通过if else来代替异常的处理
  # return None
  r = a + b
  return r

print(add(-123,456))

文件

文件打开 –>操作文件(读/写) –>关闭文件

file_name = 'demo.txt'
file_obj = open(file_name)
content = file_obj.read()
file_obj.close()

# with ... as 语句
# with open(file_name) as file_obj :
# 在with语句中可以直接使用file_obj来做文件操作
# 此时这个文件只能在with中使用，一旦with结束则文件会自动close()
# print(file_obj.read())

file_name = 'demo.txt'
try: 
  with open(file_name,encoding='utf-8') as file_obj:
    file_content = ''
    chunk = 100
    while True:
      content = file_obj.read(chunk)
      if not content:
        break
      # print(content,end='')
      file_content += content

except FileNotFoundError :
  print(f'{file_name} 这个文件不存在！')
print(file_content)

apache-nginx-tomcat

2019-09-09T15:25:10.000Z

2019-09-09-ANT

进程与线程

参考文章
进程是资源分配的最小单位，线程是CPU调度的最小单位；

二者关系

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程（通常说的主线程）;
资源分配给进程，同一进程的所有线程共享该进程的所有资源;
线程在执行过程中，需要协作同步。不同进程的线程间要利用消息通信的办法实现同步;
处理任务分给线程，即真正在处理任务上运行的是线程;
线程是指进程内的一个执行单元，也是进程内的可调度实体;

同步/异步 && 阻塞/非阻塞

同步/异步（被调用者）

描述网络通信模式，适用于请求-响应模型
同步：发送方发送请求后，需要等待接收响应，否则将一直等待
异步：发送方发送请求后，不需要等待响应，可以继续发送下一个请求，或者主动挂起线程并释放CPU

阻塞/非阻塞（调用者-应用程序）

描述进程的函数调用方式
阻塞：IO 调用会一直阻塞，直至结果返回才能继续执行
非阻塞：IO 调用会立即返回，不需要等待结果，并可以执行下一个 I/O调用

IO多路复用的三种模型:Select，Poll，Epoll

参考文章
IO有内存IO、网络IO和磁盘IO三种，通常说的IO指的是后两者;以文件IO为例,一个IO读过程是文件数据从磁盘→内核缓冲区→用户内存的过程。同步与异步的区别主要在于数据从内核缓冲区→用户内存这个过程需不需要用户进程等待，即实际的IO读写是否阻塞请求进程。(网络IO把磁盘换做网卡即可)

项目	select	poll	epoll
操作方式	遍历	遍历	回调
底层实现	数组	链表	哈希表
IO效率	线性遍历,时间复杂度O(n)	线性遍历, O(n)	事件通知方式,O(1)
最大连接数	1024(x86)/2048(x64)	无上限	无上限
fd拷贝	每次调用,fd集合从用户态拷贝到内核态	同select	拷贝进内核保存

apache、nginx与tomcat区别

Apache和nginx应该叫做HTTP Server，而tomcat是一个Application Server，JSP/Servlet容器应用的容器;Apache HTTPServer和Nginx都能够将某一个静态资源的内容通过HTTP协议返回到客户端，但是这个文本文件的内容是固定的——也就是说无论何时、任何人访问它得到的内容都是完全相同的;Tomcat能够动态的生成资源并返回到客户端;

apache

原理浅析

Apache基于多进程的HTTP服务器，它需要对每个用户请求创建一个子进程进行响应，并发的请求量大就会需要非常多的进程，从而占用极多的cpu资源和内存;
Apache是基于模块化设计的，MPM（Multi-ProcessingModules，多重处理模块）是Apache的核心组件之一，Apache通过MPM来使用操作系统的资源，对进程和线程池进行管理;
MPM有三种工作方式：

prefork 模式(预派生子进程)

prefork是一个非线程型的、预派生的MPM，使用多个进程彼此独立，且每个进程只有一个线程，每个进程在某个确定的时间只单独处理一个连接，效率高，但内存使用比较大。
优点：适合于没有线程安全库，需要避免线程兼容性问题的系统。它是要求将每个请求相互独立的情况下最好的MPM，这样若一个请求出现问题就不会影响到其他请求。
缺点：一个进程相对占用更多的系统资源，消耗更多的内存。而且，它并不擅长处理高并发请求，在这种场景下，它会将请求放进队列中，一直等到有可用进程，请求才会被处理。

worker 模式

worker基于多进程,但是使用了多进程和多线程的混合模式，worker模式也同样会先预派生一些子进程，然后每个子进程创建一些线程，同时包括一个监听线程，每个请求过来会被分配到一个线程来服务。
优点：线程比起进程会更轻量，因为线程是通过共享父进程的内存空间，因此，内存的占用会减少一些，在高并发，高流量的场景下会比prefork有更多可用的线程，表现会更优秀一些；
缺点：如果一个线程出现了问题也会导致同一进程下的线程出现问题，如果是多个线程出现问题，也只是影响Apache的一部分，而不是全部。由于用到多进程多线程，需要考虑到线程的安全了，在使用keep-alive长连接的时候，某个线程会一直被占用，即使中间没有请求，需要等待到超时才会被释放（该问题在prefork模式下也存在）。

event 模式

Apache最新的工作模式，它和worker模式很像
优点：不同的是在于它解决了keep-alive长连接的时候占用线程资源被浪费的问题（HTTP的Keepalive方式能减少TCP连接数量和网络负载），在event工作模式中，会有一些专门的线程用来管理这些keep-alive类型的线程，当有真实请求过来的时候，将请求传递给服务器的线程，执行完毕后，又允许它释放。这增强了在高并发场景下的请求处理；

nginx

参考文章

官方网站

原理浅析

组成

Nginx由一个master进程和多个worker进程组成，主进程接收客户端请求，再转交给工作进程处理，从而很好地利用多核心CPU的计算能力。

编译安装

# ./configure --prefix=/srv/nginx \
  --with-file-aio \
  --with-http_auth_request_module \  
  --with-http_ssl_module \
  --with-http_v2_module \
  --with-http_realip_module \ 
  --with-http_addition_module \ 
  --with-http_xslt_module=dynamic \ 
  --with-http_geoip_module=dynamic \
  --with-http_sub_module \
  --with-http_dav_module \
  --with-http_flv_module \
  --with-http_mp4_module \
  --with-http_gunzip_module \ 
  --with-http_gzip_static_module \ 
  --with-http_random_index_module \
  --with-http_secure_link_module \
  --with-http_degradation_module \
  --with-http_slice_module \
  --with-http_stub_status_module \ 
  --with-http_perl_module=dynamic \
  --with-pcre \
  --with-pcre-jit \ 
  --with-stream=dynamic \ 
  --with-stream_ssl_module \

配置

sed -i '/^[[:space:]]*#/d' nginx.conf 
  user nginx;
  worker_process auto; 
  error_log /var/log/nginx/error.log;
  pid /run/nginx.pid;
  include /usr/share/nginx/modules/*.conf;

  event {
      worker_connections 1024;
  }
  http {
      include         mime.types;
      default_type    application/octet-stream;

      sendfile         on;
      keepalived       65;
      
      include /etc/nginx/conf.d/*.conf;
      include /etc/nginx/conf.d/vhosts/*.conf;    # 

      server {
          listen       80;
          server_name  localhost;

          location / {                # localhost:80/ 
              root     html;          # 路径
              index    index.html index.htm;
          }
          
          location /demo {        # localhost:80/demo/
              root /opt/test;     # 实际访问 /opt/test/demo
              alias /opt/test;    # 实际访问 /opt/test
          }

          error_page   500 502 503 504  /50x.html;
          location = /50x.html {
              root html;
          }
      }
  }

CGI、FastCGI、PHP-FPM

CGI（CommonInterface，公共网关接口）是Web服务器与外部程序之间的接口标准，用于两种不同程序之间的信息传递。CGI规范允许Web服务器根据浏览器请求调用CGI程序，并将其输出结果通过响应发送给浏览器，从而使Web服务器支持处理复杂的网站业务需求;
FastCGI主要用于解决CGI性能上的缺陷。传统CGI方式是每当客户端请求CGI时，Web服务器就通过操作系统创建一个新的CGI进程，一个CGI进程完成一个请求处理后就退出，下次请求再创建一个新CGI进程。由于这种方式需要不断为每个请求创建进程，因此在网站并发量很大时显得非常低效。FastCGI优化了这种工作方式，它由一个常驻的CGI进程管理器，通过管理一个进程池来处理Web服务器的请求，由此提高了性能;
PHP提供的PHP-FPM（FastCGI ProcessManager）就是一个FastCGI进程管理器，其可执行文件位于PHP安装的目录中;

tomcat

参考文章

官方网站

Ansible

2019-08-28T01:22:57.000Z

2019-08-28-Ansible

Ansible

前话

IAAS(Infrastucture as a Service)‘’基础设施即服务’’
PAAS(Platform as a Service) ‘’平台即服务’’
SAAS(Service as a Service) ‘’软件即服务’’

简介

ansible是新出现的自动化运维工具，基于Python开发，集合了众多运维工具（puppet、cfengine、chef、func、fabric）的优点，实现了批量系统配置、批量程序部署、批量运行命令等功能。

ansible是基于模块工作的，本身没有批量部署的能力。真正具有批量部署的是ansible所运行的模块，ansible只是提供一种框架。主要包括：
(1)connection plugins：负责和被监控端实现通信；
(2)host inventory：指定操作的主机，是一个配置文件里面定义监控的主机；
(3)各种模块核心模块、command模块、自定义模块；(4)借助于插件完成记录日志邮件等功能；
(5)playbook：剧本执行多个任务时，非必需可以让节点一次性运行多个任务。

架构与原理

ansible通过ssh实现配置管理、应用部署、任务执行等功能

安装:

RPM 方式

mv /etc/yum.repos.d/epel.repo /etc/yum.repos.d/epel.repo.backup
mv /etc/yum.repos.d/epel-testing.repo /etc/yum.repos.d/epel-testing.repo.backup
wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo

yum install ansible

Git 方式

1
2
3

git clone git://github.com/ansible.git --recursive
cd ./ansible
source ./hacking/env-setup

基本使用

ansible [options]

[root@anyue ~]# /etc/ansible/ansible.cfg  
  61 host_key_checking = False         # 启用  
  101 log_path = /var/log/ansible.log  # 启用日志  
[root@anyue ~]# /etc/ansible/hosts
  [group1]  
  hostIP1  
  hostIP2  

  [group2]  
  hostIP1  

  [group:children]  
  group1   
  group2

命令

命令	选项	说明
`ansible-doc`	-a	显示所有模块文档
–	`-l,--list`	列出可用模块,也可以指定模块
–	`-s,--snippet`	指定模块playbook片段
`ansible`	-m	指定模块,默认command模块
–	-a	传递命令
–	`-k,--ask-pass`	提示输入ssh密码,默认Key验证
–	–list	显示主机
–	`-C,--check`	测试执行过程
`ansible-galaxy`	list	列出所装角色
–	info	角色信息
–	remove	删除角色
`ansible-pull`	–	推送命令至远程
`ansible-playbook`	-C	检查,不执行
–	`--limit hosts`	在指定主机执行
–	`--list-hosts`	列出运行任务的主机
`ansible-vault`	encrypt	加密playbook
–	decrypt
`ansible-console`	–	–

1
2
3

[root@anyue ansible]# ansible dbser --list
[root@anyue ansible]# ansible dbser -m ping -u root -k  
[root@anyue ansible]# ansible dbser -m command -u xy -k -a 'ls/root' -b -K # 默认为command

Host-pattern

all:
1
ansible all -m ping
*:
1
ansible "*" -m ping

与或非关系:

1
2
3

ansible 'dbser:webser' -m ping  # 或
ansible 'dbser:&webser' -m ping # 与
ansible 'dbser:!webser' -m ping # 非

常见模块

文件类操作模块

copy file blockinline lineinfile find replace fetch

1.copy

选项: src dest force backup owner group mode

1
2
3

ansible all -m copy -a 'src=/root/ansible/selinux dest=/etc/selinux/config backup=yes'
ansible all -m copy -a 'src=/etc/shadow dest=/data/ mode=000 owner=xy' 
ansible all -m copy -a 'content="hello\world\n" dest=/data/f2 backup=yes mode=755 owner=root'

2.file(path,dest,name)

选项: path state src force owner group mode recurse

1
2
3

ansible dbsrv -m file 'path=/root/a.sh owner=xy mode=755'  
ansible dbsrv -m file 'src=/etc/fstab dest=/data/fstab-link state=link'  
ansible dbsrv -m file 'path=/home/state/test te=directory owner=xy group=xy recuser=yes'

3.blockinfile:在指定的文件中插入”一段文本”

选项: path block marker state insertafter insertbefore backupcreate

1
2

ansible dbsvr -m blockfile -a 'path=/test/rc.local block="systemctl start mariadb\nsystemctl start httpd" marker="#{mark} service to start"'
ansible dbsvr -m blockfile -a 'path=/test/rc.local marker="#{mark} service to start" state=absent'

4.lineinfile:

选项: path line regexp state backrefs inserafter insertbefore backupcreate

1
2
3

# 确保某一行文本存在指定的文件中，若存在不做任何操作，默认在文件的末尾插入这行文本  
ansible dbsvr -m lineinfile -a 'path=/test/test.txt regexp="^line" line="test text"'  
ansible dbsvr -m -m lineinfile -a 'path=/test/test.txt regexp="(H.{4}).*(H.{4})" line="\2" backrefs=yes'

5.find

选项: path recurse hidden file_type patterns
use_regex contains age(s m h d w)
age_stamp(atime ctime mtime) size(t g m k b) get_checksum

1 2	`ansible dbsvr -m find -a 'path=/test patterns="*.sh" file_type=any hidden=yes' ansible dbsvr -m find -a 'path=/test age=-4d age_stamp=atime recurse=yes' # 4天以内`

6.replace

选项: path regexp replace backup

1	`ansible dbsvr -m replace -a 'path=/test regexp="ASM" replace=asm backup=yes'`

7.fetch(远程单个文件,可以先tar)

1	`ansible all -m fetch -a 'src=/var/log/message dest=/data'`

命令类操作模块

command shell script

1.command(默认)

选项: free_form chdir creates removes

# 该模块不支持`$、<、>、|、;、&`等
ansible dbser -m command -a 'chdir=/data/f1.sh'
ansible dbser -a 'echo 123456 |passwd --stdin user1' # fail
ansible dbuser -k all -m command -a "ping -c 1 www.baidu.com"

2.shell

选项: free_form chdir creates removes executable

1	`ansible dbser -m shell -a 'cat /etc/passwd \|awk -F: {print $1,$2}' &>/tmp/test.txt`

3.script

选项: free_form chdir creates removes

1
2
3

#!/bin/bash
echo "hostname is $HOSTNAME"
ansible all -m script -a '/root/ansible/host.sh'

系统类模块

cron service user group hostname yum setup synchronize debugyum_repository

1.cron

选项: minute hour day month weekday
special_time user job name
state disabled backup

1
2
3

ansible all -m cron -a 'minute=* weekday=1,3,5 job="/usr/bin/wall FBI warnning" name=broadcast'  
ansible all -m cron -a 'disabled=true job="/usr/bin/wall FBI warnning" name=broadcast'  
ansible all -m cron -a 'job="/usr/bin/wall FBI warnning" name=broadcast state=absent'

2.service

选项: name state enabled

1	`ansible dbsvr -m service -a 'name=vsftpd state=started/stopped/reloaded/restarted enabled=true'`

3.user

选项: name group gourps append shell uid
expires(指定用户过期时间) comment state
remove password update_passowrd(always on_create)
generate_ssh_key ssh_key_file ssh_key_passphrase ssh_key_type

1
2

ansible dbsvr -m user -a 'name=nginx shell=/sbin/nologin system=true home=/usr/local/nginx groups=root,bin uid=80 comment="nginx service"'
ansible dbsvr -m user -a 'name=nginx state=absent remove=true'

4.group

选项: name state gid

1
2
3

ansible dbsvr -m group -a 'name=nginx system=true gid=80'
ansible dbsvr -m  -a 'getent group nginx'
ansible dbsvr -m group -a 'name=nginx state=absent'

5.hostname

1	`ansible 192.168.30.103 -m hostname -a 'name=node1'`

6.yum_repository && yum

选项: name baseurl description file enabled gpgcheck gpgcakeystate

1
2

ansible dbsvr -m yum_repository -a 'name=AliEpel description="alibaba EPEL" baseurl=https://mirrors.aliyun.com/epel/$releasever\Server/$basearch/'
ansible dbsvr -m yum_repository -a 'name=local baseurl=file://media description="local cd yum" enabled=no'

选项: name state disable_gpg_check enablerepo disablerepo

ansible dbsvr -m yum -a 'name=vsftpd,httpd state=installed'  
ansible dbsvr -m yum -a 'name=vsftpd,httpd state=removed'
ansible dbsvr -m yum -a 'list=installed'  
ansible dbsvr -m yum -a 'name=dstat update_cache=yes'

7.setup(内部变量)

1
2
3

ansible all -m setup -a "filter=*memtotal*"  # 查看 内部变量
ansible_memetotal_mb# 4  
ansible all -m -a 'filter=ansible_memory_mb'

8.synchronize(目录文件同步,基于rsync命令工具)

1	`ansible -k all -m synchronize -a 'src=/tmp/ dest=/tmp compress=yes rsync_opts=--no-motd,--exclude=.txt'`

9.debug

ansible dbsvr -m debug -a "msg={{ansible_version}}"
---
- host: test01
  remote_user: root
  vars: 
    testvar: value of test variable
  tasks:
    - name: debug demo
      debug: 
        var: testvar
        msg: "value of testvar is: {{testvar}}"

---
- hosts: test02
  remote_user: root
  vars_prompt:
    - name: "Your_name"
      prompt: "What is your name"
    - name: "Your_age"
      prompt: "How old are you"
  tasks:
    - name: output vars
      debug:
        msg: Your name is {{Your_name}},You are {{Your_age}} years old.

ansible-playbook

PlayBook是由一个或多个”play”组成的列表，play的主要功能是为Ansible中的task定义好角色–指定剧本对应的服务器组；task是一个任务，调用Ansible各种模块，将多个play组织在一个PlayBook剧本中，组成非常完整的流程控制集合。

剧本 <–task <–modules

Usage

1 2	`ansible-playbook [options] playbook.yml [playbook2 ...] ansible-playbook --syntax-check sample.yml# 测试是否由语法错误`

语法

在YAML语法中，---表示文档开始，-作为开头也表示一个块序列的节点；列表 - 字典 key: value 或者 { key1: value1, key2: value2, …}

Ansible的幂等性:幂等性能够保持重复执行一项操作时，得到的结果是相同的，ansible是以“结果为导向的”，指定一个状态，ansible会自动判断，“当前状态”是否一致，如果一致，则不进行任何操作，不一致将当前状态变为目标指定状态。

key: value 可同行写也可换行写, 值可是字符串，也可是列表；

基础

---
# test yml
- hosts: websrv
  remote_user: root
  tasks:
    - name: create new file  # describe
      file: name=/data/newfile 
            state=touch
    - name: create new user
      user: 
        name=test2 
        system=yes 
        shell=/sbin/nologin
    - name: install package
      yum: name=httpd

handler && notify || tags

---
# apache service
- hosts: websrvs
  remote_user: root
  tasks:
    - name: install httpd package
      yum: name=httpd
      tags: inshttpd            # 标签，指定执行哪些任务
    - name: copy conf file
      copy: src=files/httpd.conf dest=/etc/httpd/conf backup=yes
      notify: restart service   # 触发特性条件，跳过以下命令，执行指定handlers任务
    - name: start service
      service: name=httpd state=started enabled=true
      tags: reshttpd     # 标签
  handlers:         # 触发器，另一种形式的task
    - name: restart service
      service: name=httpd state=restarted
 
ansible-playbook -t inshttpd,reshttpd httpd.yml  # -t,--tags 指定执行标签

var 变量

---
# var
- hosts: appserv
  remote: root
  vars:  # 变量
    nginx:
    conf80: /etc/nginx/conf.d/80.conf
    conf8080: /etc/nginx/conf.d/8080.conf
  tasks:
    - name: task1
      file: 
        path="{{nginx.conf80}}" 
        state=touch
    - name: task2
      file: 
        path="{{nginx['conf8080']}}"
        state=touch
#############################
cat vars.yml
- var1: httpd
- var2: nginx
######
---
- hosts: web
  remote_user: root
  vars_files:
    - vars.yml
  tasks:
    - name: vreate httpd log
      file: name=/app/{{ var1 }}.log state=touch
    - name: vreate httpd log
      file: name=/app/{{ var2 }}.log state=touch

Template(Jinja2)

when

---
# test template
- hosts: websrvs
  remove_user: root
  vars:
    - http_port: 88
  tasks:
    - name: install package
      yum: name=nginx
    - name: copy template
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf  # 模板
      when: ansible_distribution_major_version == "7"   # 判断
      notify: restart service
    - name: copy template
      template: src=nginx.conf.j2 dest=/etc/nginx/nginx.conf  # 模板
      when: ansible_distribution_major_version == "6" 
      notify: restart service
    - name: start service
      service: name=nginx state=started enables=true
  handlers:
    - name: restart service
      service: name=nginx state=restarted 

# 查看内置变量, 修改 nginx 模板, 其它配置不变
ansible websrvs/all -m setup |grep cpu    

vim templates/nginx.conf.j2
  user nginx;  
  worker_processes {{ ansible_processor_vcpu**2 }};  #
  server { listen[::]:{{ http_port }} default_server; }

# vim /etc/ansible/hosts  
[websrvs]  
192.168.30.101 http_port=81  
192.168.30.102 http_port=82    

ansible-playbook -e "http_port=99" testtempl.yml

循环

---
- hosts: websrvs 
  remote_user: root
  tasks:
  - name: create groups
    # item 用的是with_item的内容
    group: name={{ item }} state=present 
    with_items: # 列表循环 [], with_items: [1, 2, 3]
      - group1
      - group2
      - group3
  - name: create users
    user: name={{ item.name }} group={{ item.group }} state=present
    with_items:  # 字典{key.value}
      - { name: 'user1', group: 'group1' } 
      - { name: 'user2', group: 'group2' } 
      - { name: 'user3', group: 'group3' }

for

---
- hosts: websrvs
  remote_user: root
  vars:
    ports:
      - web1:
        port: 81
        # name: web1.xy.com
        rootdir: /data/website1
      - web2:
        port: 82
        name: web2.xy.com
        rootdir: /data/website2
      - web1:
        port: 83
        # name: web3.xy.com
        rootdir: /data/website2
  tasks:
    - name: copy conf
      templte: src=for1.conf.j2 dest=/data/for1.conf
###########
vim for1.conf.j2
    {% for i in ports %}
      server {
          listen {{ i.port }}
          servername {{ i.name }}
          documemtroot {{ i.rootdir }}
      }
    {% endfor %}

vim testfor.yml
---
- hosts: websrvs
  remote_user: root
  vars:
    ports:
      - 81
      - 82
      - 83
  task:
    - name:copy conf
      templtate: src=for1.conf.j2 dest=/data/for1.conf

if

vim for4.conf.j2
  {% for i in ports %}
    server {
      listen {{ i.port }}
    {% if i.name defined %}
        servername {{ i.name }}
      {% endif %}
      documemtroot {{ i.rootdir }}
    }
  {% endfor %}

Roles 角色

参考

Js

2019-08-21T04:49:26.000Z

2019-08-21-JS

Js相关知识点

Js代码运行阶段:

解析阶段: 检查是否由语法错误及变量、函数的声明
运行阶段: 变量的赋值，代码流程的执行

数据类型

Number String Boolen undefined null Objec(function, 数组)

关于this：

指的是调用当前方法 / 函数的那个对象

function fn1 () {
    this;
}
fn1();// this => window
------------------------------------------------------
oDiv.onclick = fn1;  // this => oDiv, 事件调用不加 ();
------------------------------------------------------    
oDiv.onclick = function () {
    fn1();// fn1() 里的this => window
}
------------------------------------------------------
var obj = {
    name: 'Li',
    age: 18,
    fun: function(){
        var s = this.age;   // this =>obj
        console.log(s);
    }
}
obj.fun();

1.以函数的形式调用时, this永远都是window, 比如fun();相当于window.fun();
2.以方法的形式调用时, this是调用方法的那个对象
3.以构造函数的形式调用时, this是新创建的那个对象
4.以使用call和apply调用时, this是指定的那个对象

关于函数返回值：

函数名+括号: fn1() ==> return 后面的的值，函数返回值
仅仅是函数名调用：fn1==>函数体对象为参数，即整个函数代码
所有函数默认返回值：未定义
return 之后任何代码都不执行

函数声明：

    function 函数名(形参1,形参2,...){         
        code;                                        
        return 返回值;                           
} 
    
    var fun = function(){
        code;
}  
    
    (function(){
        code;
    })();        匿名函数(立即执行函数,自调用匿名函数)

关于定时器：

var timer = setInterval(函数名，毫秒);
- clearInterval(timer); // 重复执行
- clearTimout(timer); // 执行一次

关于OOP：

特点：
- 抽象：抓问题核心
- 封装：不考虑内部实现原理，只考虑功能使用
- 继承：从已有对象，继承出新的对象，多重继承，多态

组成：

方法：函数(过程、动态的)

属性：变量(状态、静态的)

function People (name) {  // 构造
    this.name = name;//  属性
    this.showName = showName;
}
function showName () {// 方法
    alert(this.name);
}
var p1 = new People('Jhon');
p1.showName();
=========================================
function People (name) {
    this.name = name;
}
People.prototype.showName = function () {
    alert(this.name);
}
var p1 = new People('Jhon');
p1.showName();
=========================================
var obj = {name:'Li', age:12, fly:function(){}};
var obj = new Object();

关于 DOM 对像.属性操作的各种尺寸宽高：

offset
- offsetWidth[Height] –> 元素(盒子)的宽高+padding+borde
- offsetLeft[Top] –> 元素(盒子)的父级带有定位属性，左侧(顶部)距离数字，从父亲的padding 开始算，父亲的 border不算；若没有定位，则以body为准
offsetParent
- 带有定位的父级元素节点，若没有定位，返回结果为body；若有返回最近的父级元素
- 本身定位为fixed
  - offsetParent:null (非火狐)
  - offsetParent:body（火狐）
- 本身定位不为fixed
  - 父级没有定位：offsetParent:body
  - 父级有定位：offsetParent:定位父级
scroll
- scrollWidth[Height] –> 元素(盒子)的宽高，不包括border+margin，scrollWidth[Height]=width[Height]+padding
  scrollHeight有一个特点：如果文字超出了盒子，高度为内容的高（包括超出的内容）；不超出，则是盒子本身高度。
- scrollTop[Left] –>网页被卷去的头部与左部的距离，兼容写法：window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop
client
- clientWidth[Height] –> 元素(盒子)的宽高，padding + width[height]，调用body / html为获取网页可视区的宽高
- clientX[]Y] –> 鼠标距离可视区左侧 /上侧的距离
- clientTop[Left] –> 元素(盒子)的上 /左border

总结：

区别：宽高

offsetWidth = width + padding + border  //  占位宽
offsetHeight = height + padding + border     //  占位高

scrollWidth = 内容宽度（不包含border） //  内容宽
scrollHeight = 内容高度（不包含border） // 内容高

clientWidth = width + padding   //  可视区宽
clientHeight = height + padding //  可视区高

区别：上左

offsetTop/offsetLeft：
调用者：任意元素。(盒子为主)
作用：距离父系盒子中带有定位的距离。

scrollTop/scrollLeft：
调用者：document.body.scrollTop（window调用）(盒子也可以调用，但必须有滚动条)
作用：浏览器无法显示的部分（被卷去的部分）。

clientY/clientX：
调用者：event   // 重要
作用：鼠标距离浏览器可视区域的距离（左、上）

获取元素的样式：

currentStyle –>该属性获取当前元素的样式，只有IE支持
- box1.currentStyle.width
getComputerStyle() –>该方法获取当前元素样式，
- getComputerStyle((box1, null).width);
参看{}、[]、()区别

{}–>表示对象;[]–>表示对象的属性、方法;()–>如果用在方法名后面

function getStyle(obj, attr) {
return obj.currentStyle?obj.currentStyle[attr]:obj.getComputerStyle[attr];
}
showMsg.innerHTML = "x = "+x + ", y = "+y; // x, 均为变量

关于闭包：

嵌套的内部函数引用了嵌套的外部函数的变量，就产生了闭包

闭包存在于嵌套的内部函数中

function fn1(){
  var a = 2;
  var b = 'abc';
  function fn2(){ // 执行函数定义产生闭包(不用调用内部函数)
  console.log(a);
  } 
}
fn1();  //

关于ES6

变量的解构赋值, 给多个形参赋值

对象的解构赋值: 
let obj = {username: 'anyue', age: 39};
// let username = obj.username;
let {username, age} = obj;

数组的解构赋值:
let arr = [1, 3, 5, 'abc', true];
let [, , c, d, e] =arr;

function foo({username, age}) {
    console.log(username, age);
}

模版字符串

必须用 `` 包含
变化的部分使用 {xxx} 定义

let obj = {username: 'anyue', age: 39};
let str = '我的名字是: ' + obj.username + ', 我今年的年龄是: ' + obj.age;
str = `我的名字是: $(obj.username), 我今年的年龄是: {obj.age}`;

对象的简写方式

let username = 'anyue';
let age = 39;
let obj = {
    // username: username,
    // age: age,
    // getName: function(){}

    username,   // 省略同名的属性值
    age,
    getName() { // 省略方法的 function
        return this.username;
    }
};

箭头函数

不是调用的时候决定的, 而是在定义的时候处在的对像就是它的this,常规函数则相反箭头函数的this确定: 外层有函数,则外层函数的this就是内部箭头函数的this, 若没有, 则this是window 参数=> 语句/表达式

// let fun = function() {};
let fun = () => console('我是箭头函数');
fun();
形参:
  1.没有形参:
    let fun1 = () => console.log('我是箭头函数');
    fun1;
  2.只有一个形参:
    let fun2 = a => console.log(a); // 形参的()可以省略
    fun2(aaa);
  3.两个及以上:
    let fun3 = (x, y) => console.log(x, y); 
    fun3(25, 36);
函数体:
  1.函数体只有一条执行语句/表达式, {}可以省略, 会自动返回执行的结果:
    let fun4 = (x, y) => x+y; // let fun1 = (x, y) => {return x+y};
    console.log(fun4(25, 36));
  2.函数体不只一条执行语句/表达式:
    let fun5 = (x, y) => {
        console.log(x, y);
        return x + y;
    }
    console.log(fun5(25, 36));
测试箭头函数的this:
let btn1 = doucument.getElementById('btn1');
let btn2 = doucument.getElementById('btn2');

btn1.onclick = function() {alert(this)};    // this = btn1
btn2.onclick = () => {alert(this)}  // this = Window

let obj = {
    name: '箭头函数',
    getName: function(){
        btn2.onclick = () => {alert(this)};
    }
}
obj.getName();  // this = obj

三点运算符 && 数组扩展方法

function foo(...value){
    console.log(value);
    value.foreach(function(item, index){
        console.log(item, index);
    })
}

var arr = [2, 4, 3, 1, 2, 6, 5, 4];
console.log(arr.indexOf(4));    // 1 得到值在数组中的第一个下标

console.log(arr.lastIndexOf(4));    // 7 

arr.forEach(function(item, index) {
    console.log(item, index);   // 遍历数组
});

var arr1 = arr.map(function(item, index) {
    return item+10;
});
console.log(arr1, arr);  // 遍历数组返回新的数组, 返回加工之后的值

var arr2 = arr.filter(function(item, index) {
    return item > 3;
})
console.log(arr2, arr); // 4, 6, 5, 4

Promise 对象

function getNews(url) {
    let promise = new Promise((resolve, reject) => {
        // 状态: 初始化

        // 执行异步任务
        let xmlHttp = new XMLHttpRequest();
        xmlHttp.onreadystatechange = function() {
            if(xmlHttp.readyState ===4){
                if(xmlHttp.status == 200){
                    console.log(xmlHttp.reponseText);
                    resolve(xmlHttp.reponseText);  // 修改
            }else{
                reject('暂时没有数据');
                }
            }
        };
        xmlHttp.open('GET', url);
        xmlHttp.send();
    })
    return promise;
}
getNews('http://localhost:1080/news?id=2')
    .then((data) => {
        console.log(data);
        let commentsUrl = JSON.parse(data).commentsUrl;
        let url = 'http://localhost:1080' + commentsUrl;
        return getNews(url);
    }, (error) =>{
        console.log(error);
    })

shell

2019-08-12T14:37:07.000Z

2019-08-12-Shell

Shell

第一个Shell

1 2	`#!/bin/bash echo "Hello World!"`

bash -x file.sh        #单步执行  
/etc/motd && /etc/issue  
printenv env export    # 查看当前shell中的环境变量
set                    # 查看shell中的变量
unset                  # 撤销变量

选项	说明
-e	支持
-n	输出不换行

变量

定义变量

your_name="anyue967",  # 变量名前不加$，不能有空格  

for file in `ls /etc`# 显示直接俄赋值/语句赋值
for file in $(ls /etc)

当前shell中执行${ ls;cd /etc/; }

特殊符号	说明
()	重新开子shell中执行`$( ls;cd /etc/ )`
{}
“”	–
’’	–
`` / $()	执行命令
[]	变量测试
#	注释
$	引用变量
\	转义符

使用变量

引用变量时, 变量名前要加$,建议变量名外加{}, 一种习惯

1
2
3

for skill in Ada Coffe Action Java Shell; do
    echo "I am good at ${skill}Script"
done

变量类型:局部、环境、Shell变量三种

local 局部变量 在脚本或命令中定义,仅在当前shell实例中有效, 其他shell启动的程序不能访问局部变量；
export 环境变量作用范围：当前shell及子shell；
shell变量 shell变量是由shell程序设置的特殊变量,shell变量中有一部分是环境变量，有一部分是局部变量，这些变量保证了shell的正常运行；
只读变量readonly name 或 declare -r name readonly -p；

各个环境变量配置文件(source <==> .)

profile: 设定环境变量，运行命令/脚本

bashrc: 设定本地变量，定义命令别名 #### 配置文件

1 2	`登录shell：/etc/profile -->/etc/profile.d/.sh -->~/.bash_profile -->~/.bashrc -->/etc/bashrc 非登录shell：~/.bashrc -->/etc/bashrc -->/etc/profile.d/.sh`

位置变量 | 符号 | 说明 | | :——– | :———————————— | | $1,$2,… |对应位置参数 | | $0 | 脚本名称 | | $* |传递所有参数,全部参数合为一个字符串 | | $@ |传递所有参数,每个参数表现为独立字符串 | | $# | 参数个数 | | $? |返回最后一条命令执行的状态 | | $$ | 当前进程PID | | $! |后台运行最后一个进程的PID | | set | 清空所有位置变量 | | shift n |移动参数,前n位参数被销毁 |
关于()、(())、[]、[[]]、{}
参考 | 类型| 说明 | | :—— | :——————————————————– | | () |用于多个命令组、命令替换cmd、初始化数组$(cmd)| | (()) |算数:整数扩展、运算符、重定义变量值、算数运算比较 | | [[]]| 支持数学运算，支持逻辑测试: && || ! | | []/test |不支持数学运算，比较运算:== !=，逻辑测试使用:-a -o ! | | {} | 用于命令合集或者范围，mkdir -p/data/201{7,8} |

字符串

字符串, 可以用`''`,也可以用`""`

单引号里的任何字符都会原样输出,单引号字符串中的变量是无效的;
单引号字串中不能出现单独一个的单引号(对单引号使用转义符后也不行),但可成对出现，作为字符串拼接使用
双引号里可以有变量, 可以出现转义字符
获取字串长度
1
2
string="abcd" echo ${#string}# 4

提取字符串

1 2	`string="anyue967 is a good website" echo ${string:1:4}# nyue`

# ##表示去掉左边,#表示从左边删除到第一个指定的字符;##表示从左边删除到最后一个指定的字符

% %%表示去掉右边,%表示从右边删除到第一个指定的字符;%%表示从右边删除到最后一个指定的字符

#!bin/bash
var="http://www.runoob.com/linux/linux-shell-variable.html"

s1=${var%%t*}     # h
s2=${var%t*}      # http://www.runoob.com/linux/linux-shell-variable.h
s3=${var%%.*}     # http://www
s4=${var#*/}      # /www.runoob.com/linux/linux-shell-variable.html
s5=${var##*/}     # 空

数组

bash支持一维数组(不支持多维数组),并且没有限定数组的大小

定义: arrName=(value1 value2 ... n)

array_name=(
  value0
  value1
  value2
)
array_name[0]=value0  # 引用数组  
echo "数组元素: ${array_name[@]}"  
echo "数组元素: ${array_name[*]}"  

echo "数组元素个数为: ${#array_name[*]}"

注释

#开头单行注释

:<<EOF
comment...
comment...
EOF

read命令,用于获取键盘输入信息

read [-option] [variable ...]

选项	说明
-p	“提示信息”
-t	时间
-s	隐藏输入
-n	只接收一个输入字符就会执行

#!/bin/bash
read -p "input a val:" a
read -p "input a val:" b

c=$(($a+$b))          # $((exp))
c=$[$a+$b]            # $[exp]
let c=$a+$b           # let exp
c=expr $a + $b        # expr 算数表达式  

echo "result=${r}"

传递参数

#!/bin/bash
echo "Shell 传递参数实例！";
echo "执行的文件名：$0";
echo "第一个参数为：$1";
echo "第二个参数为：$2";
echo "第三个参数为：$3";
echo "参数个数：$#";
echo "进程号：$$";
echo "后台运行的最后一个进程号：$!";
echo "传递参数作为字串显示：$*";
echo "命令推出状态：$?";

Shell基本运算符

let命令用于指定算术运算, 即let expretion

let var=$[exp] 算数表达式 $((exp))
echo $[$RANDOM%50]: 0-49之间随机数
- COLOR=$[$RANDOM%7+31]; echo -e "\e[1;${COLOR}mcolor\e[0m"

declare

declare -i I=1 # 整型变量声明

算数运算, 用`(())`

#!/bin/bash
a=10
b=20

val=expr $a + $b
echo "a + b : $val"

val=expr $a - $b
echo "a - b : $val"

val=expr $a \* $b
echo "a * b : $val"

val=expr $b / $a
echo "b / a : $val"

val=expr $b % $a
echo "b % a : $val"

if [$a == $b ]; then
  echo "a 等于 b"
fi
if [ $a != $b ]; then
  echo "a 不等于 b"
fi

关系运算(-eq -ne -gt -lt -le)

#!/bin/bash
a=10
b=20

if [ $a -eq $b ]; then
  echo "$a -eq $b : a 等于 b"
else
  echo "$a -eq $b: a 不等于 b"
fi
if [ $a -ne $b ]; then
  echo "$a -ne $b: a 不等于 b"
else
  echo "$a -ne $b : a 等于 b"
fi
if [ $a -gt $b ]; then
  echo "$a -gt $b: a 大于 b"
else
  echo "$a -gt $b: a 不大于 b"
fi
if [ $a -lt $b ]; then
  echo "$a -lt $b: a 小于 b"
else
  echo "$a -lt $b: a 不小于 b"
fi
if [ $a -ge $b ]; then
  echo "$a -ge $b: a 大于或等于 b"
else
  echo "$a -ge $b: a 小于 b"
fi
if [ $a -le $b ]; then
  echo "$a -le $b: a 小于或等于 b"
else
  echo "$a -le $b: a 大于 b"
fi

布尔运算(!= -a -o)

#!/bin/bash
a=10
b=20

if [ $a != $b ]; then
  echo "$a != $b : a 不等于 b"
else
  echo "$a == $b: a 等于 b"
fi
if [ $a -lt 100 -a $b -gt 15 ]; then
  echo "$a 小于 100 且 $b 大于 15 : 返回 true"
else
  echo "$a 小于 100 且 $b 大于 15 : 返回 false"
fi
if [ $a -lt 100 -o $b -gt 100 ]; then
  echo "$a 小于 100 或 $b 大于 100 : 返回 true"
else
  echo "$a 小于 100 或 $b 大于 100 : 返回 false"
fi
if [ $a -lt 5 -o $b -gt 100 ]; then
  echo "$a 小于 5 或 $b 大于 100 : 返回 true"
else
  echo "$a 小于 5 或 $b 大于 100 : 返回 false"
fi

逻辑运算(&& || )

#!/bin/bash
a=10
b=20

if [[ $a -lt 100 && $b -gt 100 ]]; then
  echo "返回 true"
else
  echo "返回 false"
fi
if [[ $a -lt 100 || $b -gt 100 ]]; then
  echo "返回 true"
else
  echo "返回 false"
fi

文件测试(-r -w -x -f -d -s-e)

#!/bin/bash
file="/var/www/runoob/test.sh"

if [ -r $file ]; then
  echo "文件可读"
else
  echo "文件不可读"
fi
if [ -w $file ]; then
  echo "文件可写"
else
  echo "文件不可写"
fi
if [ -x $file ]; then
  echo "文件可执行"
else
  echo "文件不可执行"
fi
if [ -f $file ]; then
  echo "文件为普通文件"
else
  echo "文件为特殊文件"
fi
if [ -d $file ]; then
  echo "文件是个目录"
else
  echo "文件不是个目录"
fi
if [ -s $file ]; then
  echo "文件不为空"
else
  echo "文件为空"
fi
if [ -e $file ]; then
  echo "文件存在"
else
  echo "文件不存在"
fi

字符串运算(= != -z -n)

#!/bin/bash
a="abc"
b="efg"

if [ $a = $b ]; then
  echo "$a = $b : a 等于 b"
else
  echo "$a = $b: a 不等于 b"
fi
if [ $a != $b ]; then
  echo "$a != $b : a 不等于 b"
else
  echo "$a != $b: a 等于 b"
fi
if [ -z $a ]; then
  echo "-z $a : 字符串长度为 0"
else
  echo "-z $a : 字符串长度不为 0"
fi
if [ -n "$a" ]; then
  echo "-n $a : 字符串长度不为 0"
else
  echo "-n $a : 字符串长度为 0"
fi
if [ $a ]; then
  echo "$a : 字符串不为空"
else
  echo "$a : 字符串为空"
fi

Shell printf

print format-str [arguments...]

#!/bin/bash
printf "%-10s %-8s %-4s\n" 姓名 性别 体重kg  
printf "%-10s %-8s %-4.2f\n" 郭靖 男 66.1234 
printf "%-10s %-8s %-4.2f\n" 杨过 男 48.6543 
printf "%-10s %-8s %-4.2f\n" 郭芙 女 47.9876 

姓名     性别   体重kg
郭靖     男      66.12
杨过     男      48.65
郭芙     女      47.99

流程控制

if-elif-else-fi

#!/bin/bash
ratio = $(df -h |grep /dev/sda3 |awk '{print $5}' |cut -d "%" -f1)
if [ "$ratio" -ge 80 ]; then
  echo "钉钉报警!" 
fi
----------------------------------------------------
#!/bin/bash
ntpdate asia.pool.ntp.org &>/dev/null
date = $(date +%Y%m%d)
size = $(du -sh /var/lib/mysql)
if [ -d /tmp/dbbak ]; then
  echo "Date: $date!" >/tmp/dbbak/dbinfo.txt
  echo "Date: $size!" >>/tmp/dbbak/dbinfo.txt
  cd /tmp/dbbak
  tar -czf mysql-lib-$date.tar.gz /var/lib/mysql dbinfo.txt &>/dev/null
  rm -rf /tmp/dbbak/dbinfo.txt
else
  mkdir /tmp/dbbak
  echo "Date: $date!" >/tmp/dbbak/dbinfo.txt
  echo "Date: $size!" >>/tmp/dbbak/dbinfo.txt
fi
-----------------------------------------------------
#!/bin/bash
port = `nmap -sT 192.168.137.129 |grep tcp |grep http |awk '{print $2}'`
if [ "$port" == "open"]; then
  echo "$(date) httpd is ok!" >>/tmp/autostart-acc.log
  else
    /etc/init.d/httpd start &>/dev/null
    echo "$(date) restart ok!" >>/tmp/autostart-acc.log
fi
-----------------------------------------------------
#!/bin/bash
read -t 30 -p "Input num1:" num1
read -t 30 -p "Input num2:" num2
if [ -n "$num1" -a -n "$num2" -a -n "$opt" ]; then 
  test1 = $(echo num1 |sed 's/[0-9]//g')
  test2 = $(echo num2 |sed 's/[0-9]//g')
  if [ -z "$test1" -a -z "$test2" ]; then
    if [ "$opt" == '+' ]; then
      value = $(( $num1 + $num2 ))
    elif [ "opt" == '-' ]; then 
      value = $(( $num1 - $num2 ))
    elif [ "opt" == '*' ]; then 
      value = $(( $num1 * $num2 ))
    elif [ "opt" == '/' ]; then
      value = $(( $num1 / $num2 ))
    else
      echo "Please enter a valid symbol"
      exit 10
  fi
else 
  echo "Please input content"
  exit 12
fi

for-do-done

#!/bin/bash
cd /root/tar
ls *.tar.gz >tar.log
ls *.tgz >>tar.log &>/dev/null
line = $(cat tar.log |wc -l)
for i in $line
do 
  tar -xzvf $i -C /root/tar
done
rm -rf tar.log

for (( i=1; i<"$line"; i++))
do
  num = $(cat tar.log |awk 'NR=='$i' {print $1}')
  tar -xzvf $num -C /root/tar
done
rm -rf tar.log
---------------------------------------------------------
#!/bin/bash
grep "<\([0-9]\{1,3\}\.\)\{3\}[0-9]\{1,3\}\>" /root/ip.txt >/root/iptest_1.txt
grep "^[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}\.[0-9]\{1,3\}$" /root/ip.txt >/root/iptest_1.txt
line = $(wc -l /root/iptest_1.txt awk '{print $1}')
echo "" >/root/iptest.txt
for (( i=1; i<=$line; i++))
do
  cat /root/iptest_1.txt |awk 'NR=='$i' {print}' >/root/iptest_2.txt
  a = $(cat /root/iptest_2.txt |cut -d '.' -f1)
  b = $(cat /root/iptest_2.txt |cut -d '.' -f2)
  c = $(cat /root/iptest_2.txt |cut -d '.' -f3)
  d = $(cat /root/iptest_2.txt |cut -d '.' -f4)
  if [ "$a" -lt 1 -o "$a" -gt 255 ]; then
    continue
  fi
  if [ "$b" -lt 0 -o "$b" -gt 255 ]; then
    continue
  fi
  if [ "$c" -lt 0 -o "$c" -gt 255 ]; then
    continue
  fi
  if [ "$d" -lt 0 -o "$d" -gt 255 ]; then
    continue
  fi
  cat /root/iptest_2.txt >>/root/iptest.txt
done
rm -rf /root/iptest_1.txt
---------------------------------------------------------
#!/bin/bash
read -t 30 -p "Please input users name:" NAME
read -t 30 -p "Please input the number of users:" NUM
read -t 30 -p "Please input the password of users name:" PASS
if [ ! -z "$NAME" -a ! -z "$NUM" -a ! -z "$PASS"]; then
  TMP = $(echo $NUM |sed 's/[0-9]//g')
  if [ -z "$TMP" ]; then
    for(( i=1; i<$NUM; i=i+1))
    do
      /usr/sbin/useradd $NAME$i &>/dev/null
      echo $PASS |/usr/bin/passwd --stdin $NAME$i &>/dev/null
      chage -d 0 $NAME$i &>/dev/null
    done 
  fi
fi
---------------------------------------------------------
#！/bin/bash
user = $(cat /etc/passwd |grep "/bin/bash" |grep -v "root" |cut -d ":" -f1)
for i in $user
do 
  userdel -r $i
done

while-do-done

#!/bin/bash
i = 1
s = 0
while [ $i -le 100 ]
do
  s = $(( $s + $i ))
  i = $(( $i + $1 ))
done
echo "The sum is: $s"

while    while truefor(( ; ; ))
do         do
done       done

case-in-esac

#!/bin/bash
echo '输入 1 到 4 之间的数字:'
echo '你输入的数字为:'
read aNum
case $aNum in
  1)  echo '你选择了 1'
  ;;
  1)  echo '你选择了 2'
  ;;
  1)  echo '你选择了 3'
  ;;
  1)  echo '你选择了 4'
  ;;
  *)  echo '你没有输入 1 到 4 之间的数字'
  ;;
esac

关于 `break` 与`continue`

break命令允许跳出所有循环（终止执行后面的所有循环）

continue命令与break命令类似，只有一点差别，它不会跳出所有循环，仅仅跳出当前循环

#!/bin/bash
while :
do
   echo -n "输入 1 到 5 之间的数字:"
   read aNum
case $aNum in
   1|2|3|4|5) echo "你输入的数字为 $aNum!"
   ;;
   *) echo "你输入的数字不是 1 到 5 之间的! 游戏结束"
      break
   ;;
esac
done

输入 1 到 5 之间的数字:3
你输入的数字为 3!
输入 1 到 5 之间的数字:7
你输入的数字不是 1 到 5 之间的! 游戏结束
------------------------------------------------
#!/bin/bash
while :
do
   echo -n "输入 1 到 5 之间的数字: "
   read aNum
   case $aNum in
      1|2|3|4|5) echo "你输入的数字为 $aNum!"
      ;;
      *) echo "你输入的数字不是 1 到 5 之间的!"
            continue
            echo "游戏结束"
      ;;
   esac
done

Shell function

定义函数

funWithReturn(){
   echo "这个函数会对输入的两个数字进行相加运算..."
   echo "输入第一个数字: "
   read aNum
   echo "输入第二个数字: "
   read anotherNum
   echo "两个数字分别为 $aNum 和 $anotherNum !"
   return $(($aNum+$anotherNum))
}
funWithReturn
echo "输入的两个数字之和为 $? !"


funWithParam(){
   echo "第一个参数为 $1 !"
   echo "第二个参数为 $2 !"
   echo "第十个参数为 $10 !"
   echo "第十个参数为 ${10} !"
   echo "第十一个参数为 ${11} !"
   echo "参数总数有 $# 个!"
   echo "作为一个字符串输出所有参数 $* !"
}
funWithParam 1 2 3 4 5 6 7 8 9 34 73

CSS

2019-08-08T12:01:40.000Z

2019-08-08-CSS

CSS

概念:

CSS 指层叠样式表 (Cascading Style Sheets),样式定义以何种方式显示 HTML 元素, 外部样式表通常存储在 CSS文件中

h1 {color:blue; font-size:12px;}
选择器 属性:属性值 
注释:
/* ... */

选择器:

id 选择器(#)

#para{
 text-align: center;
 color: red;
}

class 选择器(.)
1
.center{ text-align: center;}

子选择器(SS)

 
 <div>
<p>red textp>  
 <table>
 /*文字是非红色的*/
<tr><td><p>no red text;td>p>tr>
 table>
 div>

相邻兄弟选择器


<div>
  <p>not red textp>
  <p>not red textp>
div>
<p>red textp>    
<p>not red textp>

后续兄弟选择器(BS)

 
 <div>
<p>no red textp>  /*文字是非红色的*/
<div>no red textdiv>
<p>red textp>  /*文字是红色的*/
 div>

伪类:

语法:
选择器.CSS类:伪类{属性:属性值} /选择器:伪类{属性:属性值}


<body>
<p>我的名字是 Donaldp>
<p>我住在 Ducksburgp>
<p><b>注意：b> :after在IE8中运行，必须声明 !DOCTYPE p>

多重样式优先级

参考文章
插入样式表的方法有三种:
+ 外部样式表(External style sheet) +内部样式表(Internal style sheet) +内联样式(Inline style)
+ 行内样式(1000)> id选择器(100)> 类选择器(10)>标签选择器(1)

/*外部*/
text/css" href="mystyle.css">


/*内部*/



<p style="color:sienna;margin-left:20px">这是一个段落。
/*内联*/

background(背景,要设置宽高)

body{
  background: all;
  backdround-color: #FFFFFF;/*rgb(255,255,255)*/
  background-imgage: url('url');
  background-repeat: repeat-x / repeat-y / no-repeat;
  
  // 水平位置(left center right) 垂直位置(top center bottom)
  background-position: 固定值 / 百分比 / 单词; 
  background-attachment: scroll / fixed / inherit;
}

Text(文本)

body{
  color: red;
  text-align: center / right / justify;
  text-decoration: none;
  text-transform: uppercase / lowercase / capitalize;
  text-indent: 10px; /*指定文本的第一行的缩进*/
  text-shadow: 2px 2px #ff0000; /*CSS3: 水平阴影的位置 垂直阴影的位置 模糊的距离(blur) 阴影的颜色(color)*/
  vertical-align: text-top; /*设置元素的垂直对齐*/
  word-spacing: 30px;/*设置英文单词之间的间距*/
  letter-spacing:30px;/*设置字母与字母之间的间距*/
}

Font(字体)

body{
  font: all;
  font-style: normal / italic / oblique;
  font-size: 14px / 14px/16=0.875em;
  font-family:"Times New Roman",Georgia,Serif;
  font-weight: normal / bold / bolder / lighter;/*指定字体的粗细*/
}

链接

a:link: {color: yellow;}
a:visited: {color: black;}
a:hover: {color: blue;}
a:active: {color: red;}

列表

ul{
  list-style: all;
  list-style-type: circle / square / upper-roman / lower-alpha;
  list-style-image: url('url');
  list-style-position: inside / outside / inherit;
}

盒子模型(上右下左)

所有HTML元素可以看作盒子, 在CSS中, "box model"这一术语是用来设计和布局时使用,CSS盒模型本质上是一个盒子, 封装周围的HTML元素, 它包括:边距, 边框, 填充,和实际内容 一个盒子的高度一般不用单独设置,由其内容撑开 不要给元素添加具有指定宽度的内边距,而是尝试将内边距或外边距添加到元素的父元素和子元素

margin (外边距) - 清除边框外的区域,外边距是透明的(盒子与盒子之间的距离)
border (边框) - 围绕在内边距和内容外的边框
padding (内边距) - 清除内容周围的区域,内边距是透明的(内容填充, 内容到边框之间的距离)
content (内容) - 盒子的内容, 显示文本和图像
说明: margin属性本意描述的兄弟与兄弟元素之间的关系,若是父子元素关系, 就最好给其父元素加 padding 属性

margin 实现水平居中 > 元素要有固定的宽度(未设置,为父元素100%的宽度), 只有块元素可以实现水平居中, 行内元素不能实现;只有标准文档流中的盒子可以使用 margin 实现水平居中 > margin属性是用来实现盒子的水平居中, 而不是文本的水平居中

注意: > 在标准文档流中垂直方向的margin 值不会叠加, 仅仅会取比较大的值 > 水平方向没有 margin的塌陷现象 > 浮动元素它是没有 margin 的塌陷现象的

几种属性

关于尺寸:

width &&height(设置元素的宽高)

p{ height:100px; width:100px;}

line-height(设置元素的行高)

p{line-height: 14px;}

display(行内与块级相互转化)&& visibility

块级元素(block)特性: 总是独占一行, 表现为另起一行开始,而且其后的元素也必须另起一行显示; 宽度(width), 高度(height),内边距(padding)和外边距(margin)都可控制;

块级元素: div, h1, h2, h3, h4, h5, h6, hr, dl, ul, li, form, ol, p, pre, table

内联元素(inline)特性: 和相邻的内联元素在同一行; 宽度(width),高度(height),内边距的top/bottom(padding-top/padding-bottom)和外边距的top/bottom(margin-top/margin-bottom)都不可改变,就是里面文字或图片的大小, 即宽高有内容撑开;

内联元素: a, img, br, input, select, small, span, strong, sub, sup, textarea,

h1{ display: none;}/*隐藏一个元素, 不会占用空间*/
h1{ visibility: hidden}/*隐藏一个元素, 隐藏的元素仍需占用与未隐藏之前一样的空间*/

li{ display: inline;}/*显示为内联元素*/
span{ display: block;}/*显示为块级元素*/

position(定位)

标准文档流: 从左至右, 从上至下; 遇到换行做空格解析；高低不齐, 底部对齐 定位有四个属性值

1. static: 默认值, 即没有定位,元素出现在正常的文档流中

div.static {
  position: static;
  border: 3px solid #73AD21;
}

2. fixed:元素位置相对于浏览器窗口是固定位置,即使窗口滚动也不会动,与标准文档流无关, 层级比标准文档流元素高, 且不占据空间

p.pos_fixed
{
  position:fixed;
  top:30px;
  right:5px;
}

3. relative:
1)相对定位不脱标
2)相对定位不改变元素的性质, 不设置偏移属性, 位置不发生改变3)相对定位元素的定位是相对于,文档流中原先位置进行定位
4)元素会提升一个层级, 它原本所占的空间并不会改变

h2.pos_left
{
  position:relative;
  left:-20px;
}
h2.pos_right
{
  position:relative;
  left:20px;
}

4. absolute:
1)绝对定位改变元素的性质, 不设置偏移属性, 位置不发生改变
2)绝对定位脱离标准文档流, 定位的元素和其他元素重叠
3)绝对定位的元素的位置相对于”最近”的已定位(无论是相对、绝对或固定)的父元素, 如果没有, 则它的位置相对于

(浏览器窗口)进行定位

h2
{
  position:absolute;
  left:100px;
  top:150px;
}

z-index 属性

z-index 表示层级大小, 数值大的会压盖数值小的, 默认为0只有定位元素才有 z-index 值, 若多个定位元素未设置, 或者值相同,则写在HTML后面的定位元素会压盖前面的的定位元素

float(浮动)

浮动的特点
> 1. 脱离文档流, 浮动的元素互相贴靠,浮动元素有”字围”效果、收缩; > 2. 一旦元素浮动后, 即脱离文档流,就不受文档流的控制了, 也就没有行内、块级之分了; > 3.行内元素能够支持宽高, 但浮动元素未设置宽高,其宽高由内容撑开;

浮动清除的方法:
> 经过浮动的元素, 会影响到它下面元素的布局,浮动元素的父元素没有将浮动元素包裹 > 1.给浮动元素的父级元素加高度: 如果一个元素要浮动,那么它的父级元素一定要有高度, 保证父级高度不能小于子级高度,有高度的盒子, 才能包住浮动的子元素; > 2.追加一个空元素并添加clear: both;:(该元素的左右两侧都不能有浮动元素),但是这种方法有一个非常大的、致命的问题, 它所在的标签,“margin属性失效了”, margin失效的本质原因是: 父级高度为零. > 3.在最后的浮动元素增加

.clear{
   zoom: 1;  /*兼容 IE6 利用 hasLayout*/
}
.clear:before, .clear:after{  
  # 父级后边 追加 空内容 
   content: '';
   display: block;
   clear: both;
}

`transform (2D效果)`

通过CSS3 转换, 可以实现对元素的移动、缩放、转动、拉长或拉伸移动:translate(10px,30px)/旋转:rotate(40deg)/缩放:scale(2,4)/倾斜:skew(30deg,20deg)/矩阵:matrix()

矩阵效果参考

`transform (3D效果)`

rotateX() rotateY() rotateZ()

`transition (过度)`

CSS3 过度是元素从一种样式逐渐改变为另一种的效果目标属性、时长


<body>
<div>div>
body>

`@keyframes (animation)`

在 @keyframes中规定某项 CSS 样式, 可以创建由当前样式逐渐改为新样式的动画效果动画名称、动画时长


<body><div>div>body>

待续…



html-02
2019-08-08T10:58:47.000Z
2019-08-08-HTML2 
简单介绍 HTML5
结构
新元素
一、Canvas
 元素用于图形的绘制, 标签只是图形容器, 通过脚本(通常是JavaScript)来完成
如下是一些例子:
1.绘制矩形 
1
2
3
4
5
6
7
8


<script>
   var c=document.getElemnetById("canvas");  //找到 
   var ctx=c.getContent("2d"); // 创建 context 对象
   ctx.fillStyle="#FF0000"; 
   ctx.fillRect(0,0,150,75); // fillRect(x,y,width,height) 
script>
2.绘制路径
1
2
3
4
5
6
7

3.绘制圆形
1
2
3
4
5
6
7

4.渲染文本
1
2
3
4
5
6

5.渐变
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6.渲染图像
1
2
3
4
5
6

二、SVG
SVG 指可伸缩矢量图形 (Scalable Vector Graphics),用于定义用于网络的基于矢量的图形, 使用 XML 格式定义图形, SVG图像在放大或改变尺寸的情况下其图形质量不会有损失
五角星
1
2
3
4
"190" height="190">
  <polygon points="100,10 40,180 190,60 10,60 160,180"
  style="fill:lime; stroke:purple; stroke-width:5; fill-rule:evenodd;">
svg>
三、Video 与 Audio
1
2
3
4
5
6
7
8
9
10
11
<video width="320" height="240" controls="controls">
  <source src="movie.mp4" type="video/mp4">
  <source src="movie.ogg" type="video/ogg">
  您的浏览器不支持 HTML5 video 标签。
video>

<audio controls="controls">
  <source src="horse.ogg" type="audio/ogg">
  <source src="horse.mp3" type="audio/mpeg">
您的浏览器不支持 audio 元素。
audio>
四、拖放
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22


<body>
   <div id="box" ondrop="drop(event)" ondragover="allowDrop(event)">div>
   <img id="drag" src="images/1.png" draggable="true ondragstart=" drag(event)"/>
body>
待续…


html-01
2019-08-08T07:44:11.000Z
HTML01 
HTML
概念:
超文本标记语言(HyperText Markup Language)是一种用于创建网页的标准标记语言
结构:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html>
<html>
<head>
<meta charset="utf-8">
<meta name="description" content="tutorial">
<meta http-equiv="refresh" content="30">
<title>title>
<link rel="stylesheet" type="text/css" href="css.css">
<style>
body {background: red;}
style>
head>

<body>
<h1>我的第一个标题h1>
<p>我的第一个段落p>
body>
html>
1
2
3
4
5
6
7
8
html> 声明为 HTML5 文档
<html> 元素是 HTML 页面的根元素
<head> 元素包含了文档的元（meta）数据，如 `<meta charset="utf-8">` 定义网页编码格式为 utf-8
<title> 元素描述了文档的标题
<link> 标签通常用于链接到样式表
<body> 元素包含了可见的页面内容
<h1> 元素定义一个大标题
<p> 元素定义一个段落
基础:
注释:
1
...<-->
元素(标签)
标题(Heading) 
1
2
3
4
<h1>h1> - <h6>h6> 标签进行定义
<h1> 定义最大的标题, 
<h6> 定义最小的标题
<hr /> 标签进行定义水平线
段落(Paragraph) 
1
2
<p>p> 标签进行定义 
<br /> 标签进行定义换行
文本格式化 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<b>b> 定义粗体文本
<em>em> 定义着重文字( em = pixels / 16 )
<i>i> 定义斜体字
<small>small> 定义小号字
<strong>strong> 定义加重语气
<sub>sub> 定义下标字
<sup>sup> 定义上标字
<ins>ins> 定义插入字
<del>del> 定义删除字
<code>code> 定义计算机代码
<kbd>kbd> 定义键盘码
<samp>samp> 定义计算机代码样本
<var>var> 定义变量
<pre>pre> 定义预格式文本
<abbr>abbr> 定义缩写
<address>address> 定义地址
<bdo>bdo> 定义文字方向
<blockquote>blockquote> 定义长的引用
<q>q> 定义短的引用语
<cite>cite> 定义引用、引证
<dfn>dfn> 定义一个定义项目
链接 
1
<a hred="url" target="_blank" rel="noopener noreferrer">a> 
图像 
1
<img src="url" alt="sone_text" /> 
表格 
1
2
3
4
5
6
7
8
9
10
<table>
  <tr>
    <th>Header1th>
    <th>Header1th>
  tr>
  <tr>
    <td>row1, cell1td>
    <td>row1, cell2td>
  tr>
table>
 1
2
<tr>tr> 定义行
<td>td> 定义列
列表 
1
2
3
4
5
6
7
8
9
  <ul><li>li>ul> 无序
<ol><li>li>ol> 有序

<dl> 自定义
    <dt>Coffeedt>
      <dd>- black hot drinkdd>
    <dt>Milkdt>
      <dd>- white cold drinkdd>
    dl>   
表单 
1
2
3
4
5
6
7
<form action="action.php" method="get">
     文本框: <input type="text" name="firstname" /><br />
  密码框: <input type="password" name="pwd" /><br />
  <input type="radio" name="sex" value="male" />单选框<br />
  <input type="checkbox" name="vehicle" value="Bike" />复选框<br />
  <input type="submit" value="Submit">
form>
属性
HTML 元素可以设置属性
属性可以在元素中添加附加信息
属性一般描述于开始标签
属性总是以属性名/属性值对的形式出现, 比如:name=“value”
class 属性可以多用 class=”“(引号里面可以填入多个class属性)
id 属性只能单独设置 id=” “(只能填写一个,多个无效)
待续…


网站数据备份
2019-08-05T05:39:06.000Z
2019-08-05-网站数据备份 
将网站数据备份至GitHub
CSDN参考文章
使用hexo，如果换了电脑怎么更新博客？
具体操作:
情况1, 新建博客
创建仓库: http://username.github.io
创建两个分支: master 与 hexo
设置 hexo为默认分支(只需要手动管理这个分支上的Hexo网站文件)
使用 
1
git clone git@github.com:username/username.github.io.git  # 拷贝仓库
在本地 http://username.github.io文件夹下通过Git bash依次执行
1
2
3
4
npm install hexo -g
hexo init
npm install
npm install hexo-deployer-git # 此时当前分支应显示为hexo
修改_config.yml中的deploy参数,分支应为master;
依次执行 
1
2
3
git add .
git commit -m "XXXX"
git push origin hexo # 提交网站相关的文件
执行hexo g -d生成网站并部署到 GitHub 上
情况2,已经有部分博文部署到git但没有备份分支
创建 hexo 分支, 并设置为默认分支
git clone git@github.com:username/username.github.io.git到本地,删除除了 .git 以外的文件;
复制原有的博客源文件, 注意除了.deploy_git, 并创建.gitignore 
1
2
3
4
5
6
7
.DS_Store
Thumbs.db
db.json
*.log
node_modules/
public/
.deploy*/
然后执行 
1
2
3
git add .
git commit -m "add hexo branch" 
git push
注意:
If you’re using GitHub Free andchange a repository’s visibility from public toprivate, you’ll lose access to features like protectedbranches and GitHub Pages.
Any published GitHub Pages site will be automaticallyunpublished. If you added a custom domain to the GitHubPages site, you should remove or update your DNS records before makingthe repository private, to avoid the risk of a domain takeover. For moreinformation, see “Adding or removing a custom domain for your GitHubPages site.”
helpgithub
设置域名
CDN加速Github Pages
又拍云的CDN
又拍云CDN配置文档
又拍云联盟
又拍云联盟用户每月独享优惠加入又拍云联盟，按步骤完成申请，即可获得10GB免费存储空间+15GB免费CDN流量
配置CDN服务
upyun配置
智能压缩 开启 Gzip 和 Brotli
HTTP 302 调度
HTTPS 配置
TLS 1.3
WebP 自适应
腾讯云域名配置
增加又拍云提供的CDN域名
国外增加GitHub分配的域名
参考文档
Github Pages配置
source目录下增加CNAME文件写上域名
Github Pages的settings下Custom domain配置域名，开启htpps


tools
2019-07-29T12:40:35.000Z
2019-07-29-tools 
## 转自https://github.com/shenzekun
useful-tools
🔨一些有用的工具网站（注意：有些网站可能需要翻墙才能看到）
浏览器兼容类🌎
caniuse(网站开发浏览器兼容性查询)
browserhacks(一些浏览器兼容写法)
图片类😎
Tinypng | 智图 (压缩图片)
标你妹啊 (psd标注)
Cool Backgrounds(生成好看的渐变背景图)
carbon(生成类似 mac 风格的代码图片，用于分享)
Unsplash Source(生成随机图片)
CSS SpriteGenerator (生成雪碧图)
iconfont(阿里巴巴矢量图标库)
Preloaders | LOADING.IO(加载图，有些是收费的)
desktoppr(好看的壁纸)
Materialicons (Material icons图标)
Iloveimg(批量编辑图片的所有工具。包括压缩图片，剪裁图片，图片加水印，转化至jpg图片等等)
pkgif (任意GIF添加字幕)
ImageCyborg(一键下载当前网页的所有图片)
MarkMaker (在线logo 随机生成工具)
Removebg(在线移除背景工具，想改图片的背景可以用这个，证件照必备😀)
SVGOMG(SVG图形压缩优化)
## 代码类⌨️
Ubuntu pastebin(代码分享)
Codepen | Jsbin (在线代码编辑)
CodeSandbox(在线写React,自动编译,有代码提示)
Ultimate CSSGradient Generator (生成 css 渐变)
Grabient (生成漂亮的 css渐变)
CharacterEntity Reference Chart (各种符号的转义字符)
css三角形产生器| CSS ARROW PLEASE(生成CSS小三角)
缓动函数速查表
Regexper (正则可视化)
Regex101 (正则表达式测试)
Visualgo(数据结构，算法可视化)
Animista (在线生成 css 动画)
PageSpeedInsights (测试网站速度，优化性能)
Learn Git Branching(以动画的形式让你学习 git)
Asciiflow(生成类似代码注释里那种佛祖的代码。。自己画😄)
PXtoEM (PX EM 单位换算)
epic-spinners(一个好看的css loading 代码库)
Emogrifier(邮件模板必备工具-html转换成内联样式)
效率类⚡️
墨刀 (画原型图)
石墨文档 | 腾讯文档(多人实时协作的云端文档与表格)
resume-examples(简历模板)
Enhancv (生成简历)
KOPPT (ppt 模板)
Beautiful.Ai (人工智能 ppt模板创建)
Canva (设计模板)
ProcessOn(在线画流程图，思维导图、UI原型图等等)
WakaTime(跟踪项目花费的时间，得装插件)
Screen Sizes (移动屏幕尺寸)
Habitica (游戏化Todo)
Smallpdf(非常厉害的一个网站，PDF压缩，PDF转PPT，Word，Excel等等都可以直接通过这个页面实现)
草料二维码 (在线生成二维码)
声享 (在线制作 PPT)
幕布(极简大纲笔记，一键生成思维导图)
Infogram (在线图表制作工具)
UZER.ME(能够在线使用ps，ai，office，xmind，火狐浏览器等多个应用的网站)
NiceTool(在线工具集合网站)
codelf(开发变量命名神器)
表格转换(Markdown表格生成,LaTex表格生成)
JSONPath(在线JSON提取工具)
JMESPath(在线JSON提取工具)
查询类🔎
devhints(常用速查表，快速查询各类框架和库的常用方法，很实用)
印记中文(快速查询各类框架和周边库的中文文档)
Css Triggers(列出了哪些CSS属性在不同的渲染引擎中是否会触发重排或重绘)
Security Headers(搜索网站是否有不安全的头部 header 设置，并会评分)
devdocs (各种编程语言 API文档)
Seepdtest(测速网站)300M的家庭带宽，家庭网络需要使用千兆无线路由器、千兆网线组网
1Mbps=1024Kbps=128KB/s, 300Mbps=300x128=38400KB/s=37.5MB/s
关于网线:五类线：该类电缆增加了绕线密度，传输带宽为100MHz，用于语音传输和最高传输速率为100Mbps的数据传输，主要用于100BASE-T和10BASE-T网络，已被超五类线替代。
超五类线：具有衰减小，串扰少，比五类线增加了近端串音功率和的测试要求，并且具有更高的衰减串扰比（ACR)和信噪比、更小的时延误差，性能得到很大提高。超五类线的最大带宽为100MHz。
六类线：的传输性能远远高于超五类标准，最适用于传输速率为1Gbps的应用。六类与超五类的一个重要的不同点在于：改善了在串扰以及回波损耗方面的性能，对于新一代全双工的高速网络应用而言，优良的回波损耗性能是极重要的。
超六类线：是六类线的改进版，发布于2008年，同样是ANSI/TIA-568C.2和ISO/IEC11801超六类/EA级标准中规定的一种双绞线电缆，主要应用于万兆位网络中。传输频率500MHz，最大传输速度也可达到10Gbps ，在外部串扰等方面有较大改善
七类线：该线是ISO/IEC 11801 7类/F级标准中于2002年,认可的一种双绞线，它主要为了适应万兆以太网技术的应用和发展。但它不再是一种非屏蔽双绞线了，而是一种屏蔽双绞线，所以它的传输频率至少可达600MHz，传输速率可达10 Gbps。

旅行の梦

Investment01

1. 移动平均线 (MA)

2. 相对强弱指数 (RSI)

3. 随机震荡指标(Stochastic Oscillator, KDJ)

4. 布林带 (BollingerBands)

5. MACD(指数平滑异同移动平均线)

6. 平均真实波幅 (ATR)

7. 成交量 (Volume)

8. 斐波那契回调(Fibonacci Retracement)

9. 一目均衡表 (IchimokuCloud)

10. 支撑位与阻力位

示例

注意事项

pmp

pyData

一、环境搭建

安装virtualenv与virtualenvwrapper-win模块

常用命令

三、科学计算库NumPy快速入门

五、数据分析库Pandas快速入门

六、Python爬虫

Linux Tools

Linux 系统观测工具

系统负载及性能

1. uptime

2. dmesg

3. top

4. htop

CPU使用率

1. vmstat(Virtual MeomoryStatistic)

2. mpstat

3. sar(System ActivityReporter)

4. pidstat

5. dstat

内存使用率

进程

磁盘IO

网络IO

6. 磁盘扩容

6.1 新增加的磁盘

6.2 从其他分区获得空间,/home299G

SPL

堆 栈 队列

参考

链表

关于SPL

SPL:Search ProcessLanguage(搜索处理语言)

常用命令

stats

bucket

rename

eval

fileds

table

makeresults

where

top

limit

sort

join

append

autoregress

lookup

map

parse

parsedate

esma智能运维

movingavg

rollingavg

transpose

Zookeeper和Kafka

Zookeeper

Zookeeper官网

1. 什么是Zookeeper?

2. Zookeeper特点

2.1 Zookeeper的设计目标

2.2Zookeeper数据模型和分层名称

3. Zookeeper的使用

3.1 下载地址

堆栈队列

索引分片副本

Python3版本中，字符串是以`Unicode`编码

格式化输出(`%`)