06-自定义过滤器：时间格式化举例

前言

我们接着上一篇文章01-04来讲。

过滤器的概念

概念：Vue.js 允许我们自定义过滤器，可被用作一些常见的文本格式化。过滤器可以用在两个地方：mustache 插值表达式、 v-bind表达式。过滤器应该被添加在 JavaScript 表达式的尾部，由“管道”符指示。

Vue1.X中的系统过滤器

Vue提供了一系列的固定逻辑来使程序员更加容易的实现这些功能，这些过滤器称之为系统过滤器。

系统过滤器是Vue1.0中存在的，在Vue2.0中已经删除了。

系统过滤器的使用，可以参考参考文档：http://v1-cn.vuejs.org/api/#过滤器

Vue也提供了一个接口用来供程序员定义属于自己的特殊逻辑，Vue称之为自定义过滤器。我们接下来讲一讲。

自定义全局过滤器

文档地址：http://v1-cn.vuejs.org/guide/custom-filter.html

全局过滤器的基本使用

我们可以用全局方法Vue.filter()自定义一个全局过滤器。这样的话，每一个Vue的对象实例（每一个VM实例）都可以拿到这个过滤器。它接收两个参数：过滤器的名称 、过滤器函数。

比如说，我要将曾经，我也是一个单纯的少年，单纯的我，傻傻的问，谁是世界上最单纯的男人这句 msg 中的“单纯”改为“邪恶”。可以这样做：

（1）在差值表达式中这样调用：

  1.         <p>{{ msg | msgFormat }</p>

上方代码的意思是说：

  • 管道符前面的msg：要把 msg 这段文本进行过滤，

  • 管道符后面的msgFormat：是通过msgFormat这个过滤器进行来操作。

（2）定义过滤器msgFormat：

  1.         // Vue.filter 中的第一个参数是过滤器的名称，第二个参数是具体的过滤器函数
  2.         // 定义一个 Vue 全局的过滤器，名字叫做  msgFormat
  3.         Vue.filter('msgFormat', function (myMsg) {  // function 的第一个参数指的是管道符前面的 msg
  4.             // 字符串的  replace 方法，第一个参数，除了可写一个 字符串之外，还可以定义一个正则
  5.             return myMsg.replace(/单纯/g, '邪恶')
  6.         })

上方代码解释：

  • Vue.filter(‘过滤器的名称’, 具体的过滤器函数)中的第一个参数指的就是过滤器的名称（必须和管道符后面的名称完全一致），第二个参数是具体的过滤器函数

  • 过滤器函数function中，第一个参数指的管道符前面的msg。

  • replace()方法是用来做字符串的替换的。第一个参数如果只写成单纯，那么就会只修改 msg 中的第一个单纯字样。所以这里就用正则去匹配msg 中所有的单纯字样。

最终，完整版代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9.     <script src="vue2.5.16.js"></script>
  10. </head>
  12. <body>
  13.     <div id="app">
  14.         <!-- 通过 过滤器 msgFormat 对 msg 进行过滤-->
  15.         <p>{{ msg | msgFormat }}</p>
  16.     </div>
  18.     <script>
  19.         // 定义一个 Vue 全局的过滤器，名字叫做  msgFormat
  20.         Vue.filter('msgFormat', function (myMsg) {
  21.             // 字符串的  replace 方法，第一个参数，除了可写一个 字符串之外，还可以定义一个正则
  22.             //将 myMsg 中的所有`单纯`字样，修改为`邪恶`
  23.             return myMsg.replace(/单纯/g, '邪恶')
  24.         })
  26.         // 创建 Vue 实例，得到 ViewModel
  27.         var vm = new Vue({
  28.             el: '#app',
  29.             data: {
  30.                 msg: '曾经，我也是一个单纯的少年，单纯的我，傻傻的问，谁是世界上最单纯的男人'
  31.             },
  32.             methods: {}
  33.         });
  34.     </script>
  35. </body>
  37. </html>

网页显示效果如下：

06-自定义过滤器：时间格式化举例 - 图1

给过滤器添加多个参数

上面的举例代码中，{{ msg | msgFormat }}中，过滤器的调用并没有加参数，其实它还可以添加多个参数。

接下来，我们在上面的举例代码中进行改进。

改进一：过滤器加一个参数。如下：

将 msg 这个字符串中的“单纯”改为 xxx 变量。代码如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9.     <script src="vue2.5.16.js"></script>
  10. </head>
  12. <body>
  13.     <div id="app">
  14.         <!-- 【重要】通过 过滤器 msgFormat 对 msg 进行过滤。括号里的参数代表 function中的 arg2-->
  15.         <p>{{ msg | msgFormat('xxx') }}</p>
  17.     </div>
  19.     <script>
  20.         // 定义一个 Vue 全局的过滤器，名字叫做  msgFormat
  21.         Vue.filter('msgFormat', function (myMsg, arg2) {
  22.             // 字符串的  replace 方法：第一个参数，除了可写一个 字符串之外，还可以定义一个正则；第二个参数代表要替换为上面的xxx
  23.             //将 myMsg 中的所有`单纯`字样，修改为 arg2
  24.             return myMsg.replace(/单纯/g, arg2)
  25.         })
  27.         // 创建 Vue 实例，得到 ViewModel
  28.         var vm = new Vue({
  29.             el: '#app',
  30.             data: {
  31.                 msg: '曾经，我也是一个单纯的少年，单纯的我，傻傻的问，谁是世界上最单纯的男人'
  32.             },
  33.             methods: {}
  34.         });
  35.     </script>
  36. </body>
  38. </html>

06-自定义过滤器：时间格式化举例 - 图2

注意代码中那行重要的注释：括号里的参数代表 function中的 arg2。

改进二：过滤器加两个参数。如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9.     <script src="vue2.5.16.js"></script>
  10. </head>
  12. <body>
  13.     <div id="app">
  14.         <!-- 通过 过滤器 msgFormat 对 msg 进行过滤-->
  15.         <!-- 【重要】括号里的第一个参数代表 function 中的 arg2，括号里的第二个参数代表 function 中的 arg3-->
  16.         <p>{{ msg | msgFormat('【牛x】', '【参数arg3】') }}</p>
  18.     </div>
  20.     <script>
  21.         // 定义一个 Vue 全局的过滤器，名字叫做  msgFormat
  22.         Vue.filter('msgFormat', function (myMsg, arg2, arg3) {
  23.             // 字符串的  replace 方法：第一个参数，除了可写一个 字符串之外，还可以定义一个正则；第二个参数代表要替换为 xxx
  24.             //将 myMsg 中的所有`单纯`字样，修改为`arg2 + arg3`
  25.             return myMsg.replace(/单纯/g, arg2 + arg3)
  26.         })
  28.         // 创建 Vue 实例，得到 ViewModel
  29.         var vm = new Vue({
  30.             el: '#app',
  31.             data: {
  32.                 msg: '曾经，我也是一个单纯的少年，单纯的我，傻傻的问，谁是世界上最单纯的男人'
  33.             },
  34.             methods: {}
  35.         });
  36.     </script>
  37. </body>
  39. </html>

效果如下：

06-自定义过滤器：时间格式化举例 - 图3

改进3：同时使用多个过滤器

对 msg 同时使用多个过滤器。例如：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7.     <meta http-equiv="X-UA-Compatible" content="ie=edge">
  8.     <title>Document</title>
  9.     <script src="vue2.5.16.js"></script>
  10. </head>
  12. <body>
  13.     <div id="app">
  14.         <!-- 通过 两个过滤器（msgFormat、myFilter2）对 msg 进行过滤-->
  15.         <!-- 将 msg 交给第一个过滤器来处理，然后将处理的结果交给第二个过滤器来处理-->
  16.         <p>{{ msg | msgFormat('【牛x】', '【参数arg3】') | myFilter2}}</p>
  18.     </div>
  20.     <script>
  21.         // 定义一个 Vue 全局的过滤器，名字叫做  msgFormat
  22.         Vue.filter('msgFormat', function (myMsg, arg2, arg3) {
  23.             // 字符串的  replace 方法：第一个参数，除了可写一个 字符串之外，还可以定义一个正则；第二个参数代表要替换为 xxx
  24.             //将 myMsg 中的所有`单纯`字样，修改为`arg2 + arg3`
  25.             return myMsg.replace(/单纯/g, arg2 + arg3)
  26.         })
  28.         //定义第二个全局过滤器
  29.         Vue.filter('myFilter2', function (myMsg) {
  30.             //在字符串 msg 的最后面加上【后缀】
  31.             return myMsg + '【后缀】'
  32.         })
  34.         // 创建 Vue 实例，得到 ViewModel
  35.         var vm = new Vue({
  36.             el: '#app',
  37.             data: {
  38.                 msg: '曾经，我也是一个单纯的少年，单纯的我，傻傻的问，谁是世界上最单纯的男人'
  39.             },
  40.             methods: {}
  41.         });
  42.     </script>
  43. </body>
  45. </html>

效果如下：

06-自定义过滤器：时间格式化举例 - 图4

上方代码中，添加了多个过滤器，实现的思路是：将 msg 交给第一个过滤器来处理，然后将处理的结果交给第二个过滤器来处理 。

举例1：时间格式化

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Document</title>
  7.     <script src="vue2.5.16.js"></script>
  8. </head>
  10. <body>
  11.     <div id="app">
  12.         {{ time }}
  13.         <br /> {{ time | datefmt }}
  14.     </div>
  16.     <div id="app1">
  17.         {{ time | datefmt }}
  18.     </div>
  19. </body>
  20. <script>
  22.     // 定义一个名称为 datafmt的全局过滤器
  23.     Vue.filter('datefmt', function (input) {
  24.         // 过滤器的逻辑：将input的值格式化成 yyyy-MM-dd 字符串输出
  25.         var res = '';
  26.         var year = input.getFullYear();
  27.         var month = input.getMonth() + 1;
  28.         var day = input.getDate();
  30.         res = year + '-' + month + '-' + day;
  32.         return res;
  33.     });
  35.     new Vue({
  36.         el: '#app1',
  37.         data: {
  38.             time: new Date()
  39.         }
  40.     })
  42.     new Vue({
  43.         el: '#app',
  44.         data: {
  45.             time: new Date()
  46.         }
  47.     });
  48. </script>
  50. </html>

运行效果：

06-自定义过滤器：时间格式化举例 - 图5

举例2：时间格式化

上面的举例1，时间格式化的过滤器，我们还有个更高端的写法：（字符串模板）

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Document</title>
  7.     <script src="vue2.5.16.js"></script>
  8. </head>
  10. <body>
  11.     <div id="app">
  12.         2018-05-25T14:06:51.618Z
  13.         <br /> {{ '2018-05-25T14:06:51.618Z' | dateFormat }}
  14.     </div>
  16. </body>
  17. <script>
  19.     Vue.filter('dateFormat', function (dateStr, pattern = "") {
  20.         // 根据给定的时间字符串，得到特定的时间
  21.         var dt = new Date(dateStr)
  23.         //   yyyy-mm-dd
  24.         var y = dt.getFullYear()
  25.         var m = dt.getMonth() + 1
  26.         var d = dt.getDate()
  28.         // return y + '-' + m + '-' + d
  30.         if (pattern.toLowerCase() === 'yyyy-mm-dd') { //如果调用过滤器的参数写的是 yyyy-mm-dd，那就按照这种  yyyy-mm-dd 的格式写
  31.             //这里用的是字符串模板
  32.             return `${y}-${m}-${d}`
  33.         } else {  //否则（比如说调用过滤器时不写参数），后面就补上 时-分-秒
  34.             var hh = dt.getHours()
  35.             var mm = dt.getMinutes()
  36.             var ss = dt.getSeconds()
  38.             return `${y}-${m}-${d} ${hh}:${mm}:${ss}`
  39.         }
  40.     })
  42.     new Vue({
  43.         el: '#app',
  44.         data: {
  45.             time: new Date()
  46.         }
  47.     });
  48. </script>
  50. </html>

运行结果：

06-自定义过滤器：时间格式化举例 - 图6

【荐】举例2的改进：（字符串的padStart方法使用）

上图中，我们可以看到，箭头处的时间有些问题，比如说，6要写成06更合适。为了实现这个功能，我们可以这样做：

使用ES6中的字符串新方法 String.prototype.padStart(maxLength, fillString='') 或 String.prototype.padEnd(maxLength, fillString='')来填充字符串。 pad在英文中指的是补充。

实现举例如下：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Document</title>
  7.     <script src="vue2.5.16.js"></script>
  8. </head>
  10. <body>
  11.     <div id="app">
  12.         2018-05-25T14:06:51.618Z
  13.         <br /> {{ '2018-05-25T14:06:51.618Z' | dateFormat }}
  14.     </div>
  16. </body>
  17. <script>
  19.     Vue.filter('dateFormat', function (dateStr, pattern) {
  20.         // 根据给定的时间字符串，得到特定的时间
  21.         var dt = new Date(dateStr)
  23.         //   yyyy-mm-dd
  24.         var y = dt.getFullYear()
  25.         var m = (dt.getMonth() + 1).toString().padStart(2, '0')
  26.         var d = dt.getDate().toString().padStart(2, '0')
  28.         if (pattern && pattern.toLowerCase() === 'yyyy-mm-dd') { //如果调用过滤器的参数写的是 yyyy-mm-dd，那就按照这种  yyyy-mm-dd 的格式写
  29.             //这里用的是字符串模板
  30.             return `${y}-${m}-${d}`
  31.         } else { //否则（比如说调用过滤器时不写参数），后面就补上 时-分-秒
  32.             var hh = dt.getHours().toString().padStart(2, '0')
  33.             var mm = dt.getMinutes().toString().padStart(2, '0')
  34.             var ss = dt.getSeconds().toString().padStart(2, '0')
  36.             return `${y}-${m}-${d} ${hh}:${mm}:${ss} ~~~~~~~`
  37.         }
  38.     })
  40.     new Vue({
  41.         el: '#app',
  42.         data: {
  43.             time: new Date()
  44.         }
  45.     });
  46. </script>
  48. </html>

运行效果如下：

06-自定义过滤器：时间格式化举例 - 图7

pattern参数的解释：

在做if (pattern && pattern.toLowerCase() === 'yyyy-mm-dd')这个判断时，逻辑是：先保证pattern参数传进来了，然后继续后面的判断。

我们不能写成：if (pattern.toLowerCase() === 'yyyy-mm-dd')。因为，万一在调用的时候，不传递参数pattern，那么 if语句就相当于if (undefined.toLowerCase() === 'yyyy-mm-dd')，就会报错。

当然，ES6中有个新特性叫“默认参数”，我们就可以这样写：

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Document</title>
  7.     <script src="vue2.5.16.js"></script>
  8. </head>
  10. <body>
  11.     <div id="app">
  12.         2018-05-25T14:06:51.618Z
  13.         <br /> {{ '2018-05-25T14:06:51.618Z' | dateFormat }}
  14.     </div>
  16. </body>
  17. <script>
  19.     Vue.filter('dateFormat', function (dateStr, pattern = '') {
  20.         // 根据给定的时间字符串，得到特定的时间
  21.         var dt = new Date(dateStr)
  23.         //   yyyy-mm-dd
  24.         var y = dt.getFullYear()
  25.         var m = (dt.getMonth() + 1).toString().padStart(2, '0')
  26.         var d = dt.getDate().toString().padStart(2, '0')
  28.         if (pattern.toLowerCase() === 'yyyy-mm-dd') { //如果调用过滤器的参数写的是 yyyy-mm-dd，那就按照这种  yyyy-mm-dd 的格式写
  29.             //这里用的是字符串模板
  30.             return `${y}-${m}-${d}`
  31.         } else { //否则（比如说调用过滤器时不写参数），后面就补上 时-分-秒
  32.             var hh = dt.getHours().toString().padStart(2, '0')
  33.             var mm = dt.getMinutes().toString().padStart(2, '0')
  34.             var ss = dt.getSeconds().toString().padStart(2, '0')
  36.             return `${y}-${m}-${d} ${hh}:${mm}:${ss} ~~~~~~~`
  37.         }
  38.     })
  40.     new Vue({
  41.         el: '#app',
  42.         data: {
  43.             time: new Date()
  44.         }
  45.     });
  46. </script>
  48. </html>

自定义私有过滤器

私有过滤器：在某一个 vue 对象内部定义的过滤器称之为私有过滤器。这种过滤器只有在当前vue对象的el指定的监管区域有用。

举例：日期格式化

  1. <!DOCTYPE html>
  2. <html lang="en">
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>Document</title>
  7.     <script src="vue2.5.16.js"></script>
  8. </head>
  10. <body>
  11.     <div id="app">
  12.         {{ time }}
  13.         <br />
  14.         {{ time | datefmt }}
  15.     </div>
  17. </body>
  18. <script>
  20.     new Vue({
  21.         el: '#app',
  22.         data: {
  23.             time: new Date()
  24.         },
  25.         //在某一个vue对象内部定义的过滤器称之为私有过滤器，
  26.         //这种过滤器只有在当前vue对象el指定的监管的区域有用
  27.         filters: {
  28.             // input是自定义过滤器的默认参数，input的值永远都是取自于 | 左边的内容
  29.             datefmt: function (input) {
  30.                 // 定义过滤器的内容：将input的值格式化成 yyyy-MM-dd 字符串输出
  31.                 var res = '';
  32.                 var year = input.getFullYear();
  33.                 var month = input.getMonth() + 1;
  34.                 var day = input.getDate();
  36.                 res = year + '-' + month + '-' + day;
  38.                 return res;
  39.             }
  40.         }
  41.     });
  42. </script>
  44. </html>

上面的代码中，我们在vue实例中，通过filters关键字，在里面定义了一个局部过滤器datefmt。

运行结果：

06-自定义过滤器：时间格式化举例 - 图8

第一行代码显示的是默认的date。第二行代码显示的是格式化之后的date，说明过滤器是起到了作用的。

总结

过滤器调用的时候，采用的是就近原则，如果私有过滤器和全局过滤器名称一致了，这时候 优先调用私有过滤器。

axios

axios是在Vue中专门用来发送ajax请求的。

但是，axios并不依赖于Vue.js库，而是基于promise的。