[TOC]

常用过滤器一(filters)

描述：”过滤器（filters）”可以帮助我们对数据进行处理，ansible中的过滤器功能来自于jinja2模板引擎，我们可以借助jinja2的过滤器功能在ansible中对数据进行各种处理;很多其他的过滤器有些是jinja2内置的有些是ansible特有,变量和过滤器之间采用类似于管道符进行拼接;

(1)字符串操作有关的过滤器:

  • upper 过滤器 : 将所有小写字母都被变成了大写
  • lower 过滤器 : 将所有大写字母都被变成了小写
  • capitalize 过滤器 : 将字符串变成首字母大写,之后所有字母纯小写
  • reverse 过滤器 : 将字符串反转
  • list 过滤器 : 将字符串转换成列表，每个字符作为一个元素
  • shuffle 过滤器 : 字面意思为洗牌,将字符串转换成列表每个字符作为一个元素，并且随机打乱顺序 #在随机打乱顺序时将ansible_date_time.epoch的值设置为随机种子
  • first 过滤器 : 返回字符串的第一个字符
  • last 过滤器 : 返回字符串的最后一个字符
  • length 过滤器 : 返回字符串长度,length与count等效,可以写为count
  • center(width=30) : 将字符串放在中间，并且设置字符串的长度默认以0补齐

(2)数字操作有关的过滤器

  • int,int(default=6) : 将对应的值转换成int类型,将对应的值转换成int类型,如果无法转换,默认返回0
  • float,float(8.88) : 将对应的值转换成浮点型，如果无法转换，默认返回’0.0’,当对应的值无法被转换成浮点型时，则返回指定值’8.8‘
  • abs : 获取对应数值的绝对值
  • round,round(5): 四舍五入或者取小数点后
  • random(seed=(ansible_date_time.epoch)),random(start=5),random(start=5,step=3): 随机返回一个随机数并且可以设置步长，同样可以设置随机数种子

(3)与列表相关的过滤器

  • length,first,last,random,shuffle,upper,lower : 与前面意思相同不同在于是列表
  • min : 返回列表中最小的值
  • max : 返回列表中最大的值
  • sort, sort(reverse=true) :将列表升序排序输出,将列表降序排序输出
  • sum : 返回纯数字非嵌套列表中所有数字的和
  • flatten : 那么使用flatten可以’拉平’嵌套的列表
  • join, join(‘ , ‘) : 列表元素合成字符串还可以每个元素之间用指定的字符隔开；
  • unique : 去掉列表中重复的元素，重复的元素只留下一个
  • union(testvar12) : 两个列表的并集
  • intersect(testvar12) : 两个列表的交集
  • symmetric_difference(testvar12) : 去除两个列表的补集
  • difference(testvar12) : 两个列表的交集在列表1中的补集

(4)变量未定义时相关操作的过滤器

  • default(‘WeiyiGeek’) : 如果变量没有定义，则临时返回一个指定的默认值
  • mandatory : 如果对应的变量未定义,则报出“Mandatory variable not defined.”错误


基础示例1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# cat >filtersString.yml<<END
---
- hosts: local
  remote_user: root
  gather_facts: no
  vars:
    testvar: "abc123ABC 666"
    testvar1: "  abc  "
    testvar2: '123456789'
    testvar3: "1a2b,@#$%^&"
  tasks:
  - debug:
      #将字符串转换成纯大写.将获取到的变量的值中的所有字母都变成大写
      msg: "{{ testvar | upper }}"
  - debug:
      #将字符串转换成纯小写
      msg: "{{ testvar | lower }}"
  - debug:
      #将字符串变成首字母大写,之后所有字母纯小写
      msg: "{{ testvar | capitalize }}"
  - debug:
      #将字符串反转
      msg: "{{ testvar | reverse }}"
  - debug:
      #返回字符串的第一个字符
      msg: "{{ testvar | first }}"
  - debug:
      #返回字符串的最后一个字符
      msg: "{{ testvar | last }}"
  - debug:
      #将字符串开头和结尾的空格去除
      msg: "{{ testvar1 | trim }}"
  - debug:
      #将字符串放在中间，并且设置字符串的长度为30，字符串两边用空格补齐30位长
      msg: "{{ testvar1 | center(width=30) }}"
  - debug:
      #返回字符串长度,length与count等效,可以写为count
      msg: "{{ testvar2 | length }}"
  - debug:
      #将字符串转换成列表，每个字符作为一个元素
      msg: "{{ testvar3 | list }}"
  - debug:
      #将字符串转换成列表，每个字符作为一个元素，并且随机打乱顺序
      #shuffle的字面意思为洗牌
      msg: "{{ testvar3 | shuffle }}"
  - debug:
      #将字符串转换成列表，每个字符作为一个元素，并且随机打乱顺序
      #在随机打乱顺序时，将ansible_date_time.epoch的值设置为随机种子
      #也可以使用其他值作为随机种子，ansible_date_time.epoch是facts信息
      msg: "{{ testvar3 | shuffle(seed=(ansible_date_time.epoch)) }} 
END


基础示例1：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#cat >filtersNumber.yml<<END
---
- hosts: test70
  remote_user: root
  vars:
    testvar4: -1
  tasks:
  - debug:
      #将对应的值转换成int类型
      #ansible中，字符串和整形不能直接计算，比如{{ 8+'8' }}会报错
      #所以，我们可以把一个值为数字的字符串转换成整形后再做计算
      msg: "{{ 8+('8' | int) }}"
  - debug:
      #将对应的值转换成int类型,如果无法转换,默认返回0
      #使用int(default=6)或者int(6)时，如果无法转换则返回指定值6
      msg: "{{ 'a' | int(default=6) }}"
  - debug:
      #将对应的值转换成浮点型，如果无法转换，默认返回'0.0'
      msg: "{{ '8' | float }}"
  - debug:
      #当对应的值无法被转换成浮点型时，则返回指定值’8.8‘
      msg: "{{ 'a' | float(8.88) }}"
  - debug:
      #获取对应数值的绝对值
      msg: "{{ testvar4 | abs }}"
  - debug:
      #四舍五入
      msg: "{{ 12.5 | round }}"
  - debug:
      #取小数点后五位
      msg: "{{ 3.1415926 | round(5) }}"
  - debug:
      #从0到100中随机返回一个随机数
      msg: "{{ 100 | random }}"
  - debug:
      #从5到10中随机返回一个随机数
      msg: "{{ 10 | random(start=5) }}"
  - debug:
      #从5到15中随机返回一个随机数,步长为3
      #步长为3的意思是返回的随机数只有可能是5、8、11、14中的一个
      msg: "{{ 15 | random(start=5,step=3) }}"
  - debug:
      #从0到15中随机返回一个随机数,这个随机数是5的倍数
      msg: "{{ 15 | random(step=5) }}"
  - debug:
      #从0到15中随机返回一个随机数，并将ansible_date_time.epoch的值设置为随机种子
      #也可以使用其他值作为随机种子，ansible_date_time.epoch是facts信息
      #seed参数从ansible2.3版本开始可用
      msg: "{{ 15 | random(seed=(ansible_date_time.epoch)) }}"
END


基础示例2：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
cat >filtersList.yml<<END
---
- hosts: local
  remote_user: root
  vars:
    testvar7: [22,18,5,33,27,30]
    testvar8: [1,[7,2,[15,9]],3,5]
    testvar9: [1,'b',5]
    testvar10: [1,'A','b',['QQ','wechat'],'CdEf']
    testvar11: ['abc',1,3,'a',3,'1','abc']
    testvar12: ['abc',2,'a','b','a']
  tasks:
  - debug:
      #返回列表长度,length与count等效,可以写为count
      msg: "{{ testvar7 | length }}"
  - debug:
      #返回列表中的第一个值
      msg: "{{ testvar7 | first }}"
  - debug:
      #返回列表中的最后一个值
      msg: "{{ testvar7 | last }}"
  - debug:
      #返回列表中最小的值
      msg: "{{ testvar7 | min }}"
  - debug:
      #返回列表中最大的值
      msg: "{{ testvar7 | max }}"
  - debug:
      #将列表升序排序输出
      msg: "{{ testvar7 | sort }}"
  - debug:
      #将列表降序排序输出
      msg: "{{ testvar7 | sort(reverse=true) }}"
  - debug:
      #返回纯数字非嵌套列表中所有数字的和
      msg: "{{ testvar7 | sum }}"
  - debug:
      #如果列表中包含列表，那么使用flatten可以'拉平'嵌套的列表
      #2.5版本中可用,执行如下示例后查看效果
      msg: "{{ testvar8 | flatten }}"
  - debug:
      #如果列表中嵌套了列表，那么将第1层的嵌套列表‘拉平’
      #2.5版本中可用,执行如下示例后查看效果
      msg: "{{ testvar8 | flatten(levels=1) }}"
  - debug:
      #过滤器都是可以自由结合使用的，就好像linux命令中的管道符一样
      #如下，取出嵌套列表中的最大值
      msg: "{{ testvar8 | flatten | max }}"
  - debug:
      #将列表中的元素合并成一个字符串
      msg: "{{ testvar9 | join }}"
  - debug:
      #将列表中的元素合并成一个字符串,每个元素之间用指定的字符隔开
      msg: "{{ testvar9 | join(' , ') }}"
  - debug:
      #从列表中随机返回一个元素
      #对列表使用random过滤器时，不能使用start和step参数
      msg: "{{ testvar9 | random }}"
  - debug:
      #从列表中随机返回一个元素,并将ansible_date_time.epoch的值设置为随机种子
      #seed参数从ansible2.3版本开始可用
      msg: "{{ testvar9 | random(seed=(ansible_date_time.epoch)) }}"
  - debug:
      #随机打乱顺序列表中元素的顺序
      #shuffle的字面意思为洗牌
      msg: "{{ testvar9 | shuffle }}"
  - debug:
      #随机打乱顺序列表中元素的顺序
      #在随机打乱顺序时，将ansible_date_time.epoch的值设置为随机种子
      #seed参数从ansible2.3版本开始可用
      msg: "{{ testvar9 | shuffle(seed=(ansible_date_time.epoch)) }}"
  - debug:
      #将列表中的每个元素变成纯大写
      msg: "{{ testvar10 | upper }}"
  - debug:
      #将列表中的每个元素变成纯小写
      msg: "{{ testvar10 | lower }}"
  - debug:
      #去掉列表中重复的元素，重复的元素只留下一个
      msg: "{{ testvar11 | unique }}"
  - debug:
      #将两个列表合并，重复的元素只留下一个
      #也就是求两个列表的并集
      msg: "{{ testvar11 | union(testvar12) }}"
  - debug:
      #取出两个列表的交集，重复的元素只留下一个
      msg: "{{ testvar11 | intersect(testvar12) }}"
  - debug:
      #取出存在于testvar11列表中,但是不存在于testvar12列表中的元素
      #去重后重复的元素只留下一个
      #换句话说就是:两个列表的交集在列表1中的补集
      msg: "{{ testvar11 | difference(testvar12) }}"
  - debug:
      #取出两个列表中各自独有的元素,重复的元素只留下一个
      #即去除两个列表的交集，剩余的元素
      msg: "{{ testvar11 | symmetric_difference(testvar12) }}"
END


基础示例3：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
cat >filtersVarible.yml<<END
---
- hosts: test70
  remote_user: root
  gather_facts: no
  vars:
    testvar6: ''
  tasks:
  - debug:
      #如果变量没有定义，则临时返回一个指定的默认值
      #注：如果定义了变量，变量值为空字符串，则会输出空字符
      #default过滤器的别名是d
      msg: "{{ testvar5 | default('WeiyiGeek') }}"
  - debug:
      #如果变量的值是一个空字符串或者变量没有定义，则临时返回一个指定的默认值
      msg: "{{ testvar6 | default('WeiyiGeek',boolean=true) }}"
  - debug:
      #如果对应的变量未定义,则报出“Mandatory variable not defined.”错误，而不是报出默认错误
      msg: "{{ testvar5 | mandatory }}"
END

default过滤器还有一个很方便的用法，不仅能在变量未定义时返回指定的值，还能够让模块的参数变得”可有可无”

  • 如果item有mode属性，就把file模块的mode参数的值设置为item的mode属性的值
  • 如果item没有mode属性，file模块就直接省略mode参数’omit’的字面意思就是”省略”

实际案例：对应其中一个建立建立的文件进行权限设定，而其他建立的文件则设置为系统缺省权限;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# cat >default.yml<<END
---
- hosts: local
  remote_user: root
  gather_facts: no
  vars:
    paths:
      - path: /tmp/test
        mode: '0444'
      - path: /tmp/foo
      - path: /tmp/bar
  tasks:
  #未使用了default过滤器
  # - file: dest={{item.path}} state=touch mode={{item.mode}}
  #   with_items: "{{ paths }}"
  #   when: item.mode is defined
  # - file: dest={{item.path}} state=touch
  #   with_items: "{{ paths }}"
  #   when: item.mode is undefined
  #使用了default过滤器
  - file: dest={{item.path}} state=touch mode={{item.mode | default(omit)}} #我们并没有对文件是否有mode属性进行判断，而是直接调用了file模块的mode参数
    with_items: "{{ paths }}"
END

过滤器的用法详细:


json_query 过滤器

描述：如果有时候您从某处API接口进行请求并且成功返回一串json字符串的话,有当您打开后发现里面是杂乱无章的这时可以借助于我们的ansible神器;

1
{"logs":[{"domain":"test.com","url":"?key=asdashashdhad&uid=124"},{"domain":"test.com","url":"?key=jioenlkhuxcai&uid=125"}]}

将这段数据所在的文件当做变量文件引入到playbook中，然后输出对应的变量即可;

1
2
3
4
5
6
7
8
9
10
---
- hosts: test70
  remote_user: root
  gather_facts: no
  tasks:
  - include_vars:
      file: "/testdir/ansible/CDN.log"
      name: testjson
  - debug:
      msg: "{{test.json}}"

运行上面这段脚本后便会将杂乱无章的json格式化显示;
原因：其实json是yaml的子集，yaml是json的超集，yaml格式的数据和json格式的数据是可以互相转换的，所以对于ansible来说，当我们把上例中的json数据文件当做变量文件引入时，就好像引入了一个我们定义好的yaml格式的变量文件一样，对于ansible来说是没有区别的，而且，即使在变量文件中使用yaml格式定义了变量，在使用debug模块输出变量信息时，ansible也会自动将yaml格式的数据转化为json格式后进行输出;

我们把上述json数据转换成yaml的格式，同时列出上述数据的json格式与yaml格式，你可以根据自己的使用习惯选择阅读哪种格式的数据，以便你能够更好的理解这段数据的含义，yaml格式如下:

1
2
3
4
5
6
7
8
9
10
11
12
#cat >/root/filter.txt<<END
---
logs:
- domainName: test.com
  files:
   - dateFrom: 2018-09-05-0000
     url: ?key=asdashashdhad&uid=124
- domainName: test123.com
  files:
   - dateFrom: 2018-09-05-0000
     url: ?key=asdashashdhad&uid=124
END

此刻如果我们想要获取到整个列表中的所有日志文件的Url，我们该怎么办呢？
答:我们有两种方式一种是通过with_subelements,另外一种是通过json_query的过滤器实现;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#cat >/root/filterYml.yml<<END
---
- hosts: local
  remote_user: root
  gather_facts: no
  tasks:
  - include_vars:
      file: "/root/filter.txt"
      name: vartest
  - debug:
      msg: "{{item.1.url}}"
    with_subelements:
    - "{{vartest.logs}}"
    - files
END

执行结果:(坑呀)
1
2
3
4
5
6
7
TASK [debug] 
ok: [local] => (item=[{u'domainName': u'test.com'}, {u'url': u'?key=asdashashdhad&uid=124', u'dateFrom': u'2018-09-05-0000'}]) => {
    "msg": "?key=asdashashdhad&uid=124"
}
ok: [local] => (item=[{u'domainName': u'test123.com'}, {u'url': u'?key=asdashashdhad&uid=124', u'dateFrom': u'2018-09-05-0000'}]) => {
    "msg": "?key=asdashashdhad&uid=124"
}

json_query过滤器
描述：可以直接提取json数据,可以进行通配符进行配置,从而比上面采用with_subelement更加的简便;在复现上面的实例的时候我们先来看看你它如何使用;
基础示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# cat > filter1.txt<<END
---
users:
- name: tom
  age: 17
  hobby:
    - run
    - pingpang
- name: jerry
  age: 12
  hobby:
    - computer
    - basketball
END

  • 当数据结构中存在列表时，我们可以使用\”列表名[*]\”获取到列表下面的所有项
  • 使用json_query过滤器对这个变量进行了处理json_query(‘users[*].name’)表示找到users列表中所有元素的name属性
  • 使用json_query(‘test.users[?name==`tom`].hobby[*]’)表示只查找users列表中name属性等于tom的hobby信息 (注意是反引号)
  • 使用json_query(‘test.users[*].{uname:name,uage:age}’)表示找到users列表中所有用户的name值和age值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#cat >json_queryDemo.yml<<END
---
- hosts: local
  remote_user: root
  gather_facts: no
  tasks:
  - include_vars:
      file: "/root/filter1.txt"
      name: vartest
      #坑：注意下面是name(在palybook执行中显示的title)
  - name: "json_query Demo 1 : Name"
    debug:
      msg: "{{vartest | json_query('users[*].name')}}" 
  - name: "json_query Demo 2 : Hobby"
    debug:
      msg: "{{vartest | json_query('users[*].hobby[*]')}}"
  - name: "Advances json_query Demo1"
    debug:
      msg: "{{vartest | json_query('users[?name==\`tom\`].hobby[*]')}}" #关键点指定用户过滤
  - name: "Advances json_query Demo2"
    debug:
       #用户的姓名和年龄都按照我们定义的方式输出
       msg: "{{vartest | json_query('users[*].{username:name,userage:age}')}}"
END
`

执行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
TASK [json_query Demo 1 : Name] 
ok: [local] => {
    "msg": ["tom","jerry"]
}

TASK [json_query Demo 2 : Hobby] 
ok: [local] => {
    "msg": [
        ["run", "pingpang"],
        ["computer","basketball"]
    ]
}

TASK [Advances json_query Demo] 
ok: [local] => {
    "msg": [["run","pingpang"]]  #关键点1 过滤判断是关键
}

TASK [Advances json_query Demo2] 
ok: [local] => {
    "msg": [
        {"userage": 17, "username": "tom"},
        { "userage": 12, "username": "jerry"}  #关键点2 指定格式输出
    ]
}

回归最初的示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
#cat >json_query.yml<<END
---
- hosts: local
  remote_user: root
  gather_facts: no
  tasks:
  - include_vars:
      file: "/root/filter.txt"
      name: vartest
  - name: "json_query Filter Demo"
    debug:
      msg: "{{vartest|json_query('logs[*].files[*].url')}}"
END

执行结果:
1
2
3
4
5
TASK [json_query Filter Demo] 
ok: [local] => {
    #从这里可以看出于with_subelements关键字的不同更加的高效
    "msg": [["?key=asdashashdhad&uid=124"], ["?key=asdashashdhad&uid=124"]]
}


常用过滤器二

描述：继续总结一些使用的过滤器,可以直接采用cmd进行测试:

1
2
#查看软连接的实际文件(注意硬连接是不行的)
ansible local -m debug -e "path=/bin/bash" -a "msg={{path|realpath}}"


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
---
- hosts: test70
  remote_user: root
  gather_facts: no
  tasks:
  ######################################################################
  #在调用shell模块时，如果引用某些变量时需要添加引号，则可以使用quote过滤器代替引号
  #示例如下，先看示例，后面会有注解
  - shell: "echo {{teststr | quote}} > /testdir/testfile"
    vars:
      teststr: "a\nb\nc"
  #上例中shell模块的写法与如下写法完全等效
  #shell: "echo '{{teststr}}' > /testdir/testfile"
  #没错，如你所见，quote过滤器能够代替引号
  #上例中，如果不对{{teststr}}添加引号，则会报错，因为teststr变量中包含"\n"转义符
  ######################################################################
  #ternary过滤器可以实现三元运算的效果 示例如下
  #如下示例表示如果name变量的值是John，那么对应的值则为Mr,否则则为Ms
  #简便的实现类似if else对变量赋值的效果
  - debug: 
      msg: "{{ (name == 'John') | ternary('Mr','Ms') }}"
    vars:
      name: "John"
  ######################################################################
  #basename过滤器可以获取到一个路径字符串中的 文件名 "msg": "test.conf"
  - debug:
      msg: "{{teststr | basename}}"
    vars:
      teststr: "/testdir/ansible/testfile"
  ######################################################################
  #获取到一个windows路径字符串中的文件名,2.0版本以后的ansible可用
  - debug:
      msg: "{{teststr | win_basename}}"
    vars:
      teststr: 'D:\study\WeiyiGeek' 
  #示例如下"msg": "D:\\study"
  ######################################################################
  #dirname过滤器可以获取到一个路径字符串中的 路径名
  - debug:
      msg: "{{teststr | dirname}}"
    vars:
      teststr: "/testdir/ansible/testfile"
  ######################################################################
  #获取到一个windows路径字符串中的文件名,2.0版本以后的ansible可用
  - debug:
      msg: "{{teststr | win_dirname}}"
    vars:
      teststr: 'D:\study\WeiyiGeek'
  ######################################################################
  #将一个windows路径字符串中的盘符和路径分开,2.0版本以后的ansible可用
  - debug:
      msg: "{{teststr | win_splitdrive}}"
    vars:
      teststr: 'D:\study\WeiyiGeek'
  #可以配合之前总结的过滤器一起使用，比如只获取到盘符/路径，示例如下 "msg": "(u'D:', u'\\\\study\\\\WeiyiGeek')"
  ######################################################################
  #realpath过滤器可以获取软链接文件所指向的真正文件
  - debug:
      msg: "{{ path | realpath }}"
    vars:
      path: "/testdir/ansible/testsoft"
  ######################################################################
  #relpath过滤器可以获取到path对于“指定路径”来说的“相对路径”
  - debug:
      msg: "{{ path | relpath('/testdir/testdir') }}"
    vars:
      path: "/testdir/ansible"
  ######################################################################
  #splitext过滤器可以将带有文件名后缀的路径从“.后缀”部分分开
  - debug:
      msg: "{{ path | splitext }}"
    vars:
      path: "/etc/nginx/conf.d/test.conf"
  #可以配置之前总结的过滤器，获取到文件前缀名路径以及后缀名 "msg": "(u'/etc/nginx/conf.d/test', u'.conf')"
  ######################################################################
  #to_uuid过滤器能够为对应的字符串生成uuid  "msg": "9e4cc6d9-89b3-5a09-be35-f3fbd1526102"
  - debug:
      msg: "{{ teststr | to_uuid }}"
    vars:
      teststr: "This is a test statement" 
  ######################################################################
  #bool过滤器可以根据字符串的内容返回bool值true或者false
  #字符串的内容为yes、1、True、true则返回布尔值true，字符串内容为其他内容则返回false
  - debug:
      msg: "{{ teststr | bool }}"
    vars:
      teststr: "1"
  #当和用户交互时，有可能需要用户从两个选项中选择一个，比如是否继续，
  #这时，将用户输入的字符串通过bool过滤器处理后得出布尔值，从而进行判断，比如如下用法
  #- debug:
  #    msg: "output when bool is true"
  #  when: some_string_user_input | bool
  ######################################################################
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#map过滤器可以从列表中获取到每个元素所共有的某个属性的值，并将这些值组成一个列表
#当列表中嵌套了列表，不能越级获取属性的值，也就是说只能获取直接子元素的共有属性值。
  - vars:
      users:
      - name: tom
        age: 18
        hobby:
        - Skateboard
        - VideoGame
      - name: jerry
        age: 20
        hobby:
        - Music
    debug:
      msg: "{{ users | map(attribute='name') | list }}"
  #也可以组成一个字符串，用指定的字符隔开，比如分号
  #msg: "{{ users | map(attribute='name') | join(';') }}"
  ######################################################################

  #与python中的用法相同，两个日期类型相减能够算出两个日期间的时间差
  #下例中，我们使用to_datatime过滤器将字符串类型转换成了日期了类型，并且算出了时间差
  - debug:
      msg: '{{ ("2016-08-14 20:00:12"| to_datetime) - ("2012-12-25 19:00:00" | to_datetime) }}'

  #默认情况下，to_datatime转换的字符串的格式必须是“%Y-%m-%d %H:%M:%S”
  #如果对应的字符串不是这种格式，则需要在to_datetime中指定与字符串相同的时间格式，才能正确的转换为时间类型
  - debug:
      msg: '{{ ("20160814"| to_datetime("%Y%m%d")) - ("2012-12-25 19:00:00" | to_datetime) }}'

  #如下方法可以获取到两个日期之间一共相差多少秒
  - debug:
      msg: '{{ ( ("20160814"| to_datetime("%Y%m%d")) - ("20121225" | to_datetime("%Y%m%d")) ).total_seconds() }}'

  #如下方法可以获取到两个日期“时间位”相差多少秒，注意：日期位不会纳入对比计算范围
  #也就是说，下例中的2016-08-14和2012-12-25不会纳入计算范围只是计算20:00:12与08:30:00相差多少秒
  #如果想要算出连带日期的秒数差则使用total_seconds()
  - debug:
      msg: '{{ ( ("2016-08-14 20:00:12"| to_datetime) - ("2012-12-25 08:30:00" | to_datetime) ).seconds }}'

  #如下方法可以获取到两个日期“日期位”相差多少天，注意：时间位不会纳入对比计算范围
  - debug:
      msg: '{{ ( ("2016-08-14 20:00:12"| to_datetime) - ("2012-12-25 08:30:00" | to_datetime) ).days }}'
  ######################################################################
  #使用base64编码方式对字符串进行编码
  - debug:
      msg: "{{ 'hello' | b64encode }}"
  #使用base64编码方式对字符串进行解码
  - debug:
      msg: "{{ 'aGVsbG8=' | b64decode }}"
  #######################################################################
  #使用sha1算法对字符串进行哈希
  - debug:
      msg: "{{ '123456' | hash('sha1') }}"
  #使用md5算法对字符串进行哈希
  - debug:
      msg: "{{ '123456' | hash('md5') }}"
  #获取到字符串的校验和,与md5哈希值一致
  - debug:
      msg: "{{ '123456' | checksum }}"
  #使用blowfish算法对字符串进行哈希，注:部分系统支持
  - debug:
      msg: "{{ '123456' | hash('blowfish') }}"
  #使用sha256算法对字符串进行哈希,哈希过程中会生成随机"盐",以便无法直接对比出原值
  - debug:
      msg: "{{ '123456' | password_hash('sha256') }}"
  #使用sha256算法对字符串进行哈希,并使用指定的字符串作为"盐"
  - debug:
      msg: "{{ '123456' | password_hash('sha256','mysalt') }}"
  #使用sha512算法对字符串进行哈希,哈希过程中会生成随机"盐",以便无法直接对比出原值
  - debug:
      msg: "{{ '123123' | password_hash('sha512') }}"
  #使用sha512算法对字符串进行哈希,并使用指定的字符串作为"盐"
  - debug:
      msg: "{{ '123123' | password_hash('sha512','.U5cjaHe55KK') }}"
  #如下方法可以幂等的为每个主机的密码生成对应哈希串
  #有了之前总结的过滤器用法作为基础，你一定已经看懂了
  - debug:
      msg: "{{ '123123' | password_hash('sha512', 65534|random(seed=inventory_hostname)|string) }}"