Mock 框架应用

其他 2021-03-09 00:47:39 阅读次数: 0

Mock 框架应用

1. 前端测试框架应用场景

  • 项目开发的分工导致前、后端开发进度不一致
  • 测试数据的要求
    • 一定的数量
    • 特定的格式
    • 模拟服务器请求方式

2. 前端测试框架 Mock

在这里插入图片描述

3. Mock 的技术特性

在这里插入图片描述

4. Mock 的安装

4.1 Node.js 方式

# 安装
npm install mockjs

# 使用 Mock
var Mock = require('mockjs')
var data = Mock.mock({
    
    
    // 属性 list 的值是一个数组，其中含有 1 到 10 个元素
    'list|1-10': [{
    
    
        // 属性 id 是一个自增数，起始值为 1，每次增 1
        'id|+1': 1
    }]
})
// 输出结果
console.log(JSON.stringify(data, null, 4))

4.2 Bower 方式

# 安装
npm install -g bower
bower install --save mockjs

# 使用
<script type="text/javascript" src="./bower_components/mockjs/dist/mock.js"></script>

4.3 直接加载方式

<script src=“js/mock.js”></script>
<script>
var data = Mock.mock(
	{
     
     
		'list|1-10’ : [ {'id | +1’ : 1 }] // 输出结果 
	}) 		
	console.log(JSON.stringify(data))
</script>

5. Mock 的定义规范

  • 数据模板定义规范（Data Template Definition，DTD）
  • 数据占位符定义规范（Data Placeholder Definition，DPD）

5.1 数据模版定义规范 DTD

5.1.1 数据模版组成
  • 数据模板由三部分组成
    • 属性名 name
    • 规则 rule
    • 属性值 value
# 属性名 和 生成规则 之间用竖线 | 分隔
'name | rule' : value
5.1.2 DTD 规范_属性值的类型
  • 属性值有7种数据类型
    • String、Number、Boolean、Object
    • Array、Function、RegExp
5.1.3 DTD 规范_规则的格式
  • DTD 规则是可选的，共有7种格式
  • 含义由属性值类型决定
  • 属性值中可以含有@占位符
  • 属性值还指定了最终值的初始值和类型
    • 'name|min-max': value
    • 'name|count': value
    • 'name|min-max.dmin-dmax': value
    • 'name|min-max.dcount': value
    • 'name|count.dmin-dmax': value
    • 'name|count.dcount': value
    • 'name|+step': value

5.2 数据占位符定义规范 DPD

  • 占位符只是在属性值字符串中占个位置
    • 并不出现在最终的属性值中，用@来标识其后的字符串是占位符
5.2.1 占位符的格式
@占位符
@占位符(参数 [, 参数])
5.2.2 占位符引用 Mock.Radom 中的方法
var Random = Mock.Random 
Random.email()
Mock.mock( {
    
     email ｜ 2 : ‘@email’ } )
5.2.3 占位符注意点
  • 用 @ 来标识其后的字符串是 占位符
  • 占位符 引用的是 Mock.Random 中的方法
  • 通过 Mock.Random.extend() 来扩展自定义占位符
  • 占位符 会优先引用 数据模板 中的属性
  • 占位符 支持 相对路径 和 绝对路径
Mock.mock({
    
    
    name: {
    
    
        first: '@FIRST',
        middle: '@FIRST',
        last: '@LAST',
        full: '@first @middle @last'
    }
})

# 结果
{
    
    
    "name": {
    
    
        "first": "Charles",
        "middle": "Brenda",
        "last": "Lopez",
        "full": "Charles Brenda Lopez"
    }
}

6. Mock 的常用方法

6.1 Mock.mock()

  • 作用
    • Mock.mock() 生成前端需要的测试数据
# 模板定义语法
var data = Mock.mock({
    
    
	'list|1-10': [{
    
     'id|+1': 1 }] // 输出结果 
})
console.log(JSON.stringify(data))

在这里插入图片描述

6.2 Mock.setup()

  • 作用
    • Mock.setup() 配置拦截ajax请求参数

6.3 Mock.valid()

  • 作用
    • Mock.valid() 验证数据是否符合模版

6.4 Mock.Random()

  • 作用
    • Mock.Random() 生成各类随机数据

7. Mock 方法的应用

  • Mock.mock(template)
    • 根据模版生成模拟数据
  • Mock.mock(rurl,function(option))
    • 拦截ajax请求，执行函数并将结果返回
  • Mock.mock(rurl,rtype,template)
    • 拦截ajax请求，根据模版生成数据并返回
<script>
    //自定义扩展数据
    var Random = Mock.Random
    Random.extend({
     
     
        constellation: function (date) {
     
     
            var constellations = ['1.jpg', '2.jpg', '3.jpg', '4.jpg']
            return this.pick(constellations)
        }
    })
    $(function () {
     
     
        //1.配置Mock，拦截Ajax请求
        Mock.mock('http://localhost:5500/api/getAllUsers', function () {
     
     
            var result = []
            for (var i = 0; i < 30; i++) {
     
     
                var rndUser = Mock.mock({
     
     
                    'userId': 'user' + '@increment()',
                    'userName': Random.cname(3),
                    'headPic': Random.constellation(),
                    'experince': Random.cparagraph(),
                    'birth': function(){
     
     
                        var date = null
                        while(true){
     
     
                            date = new Date(Random.date())
                            if(date.getFullYear() > 1980 && date.getFullYear() < 2000){
     
     
                                return date.toLocaleDateString()
                            }
                        }
                    }
                })
                result.push(rndUser)
            }
            return result
        })
        //2.发出Ajax请求，获取接口数据
        $.ajax({
     
     
            url: 'http://localhost:5500/api/getAllUsers',
            type: 'get',
            dataType: 'json',
            success: function (data) {
     
     
                var strHTML = ''
                for (var i = 0; i < data.length; i++) {
     
     
                    strHTML += ` <li>
                                    <h3>${
       
       data[i].userId}-${
       
       data[i].userName}</h3>
                                    <img src="images/${
       
       data[i].headPic}" alt="">
                                    <p>${
       
       data[i].experince}</p>
                                    <p>${
       
       data[i].birth}</p>
                                </li>`
                }
                $('#users').html(strHTML)
            },
            error: function () {
     
     
                console.log('请求失败！')
            }
        })
    })
</script>

<body>
    <ul id="users"></ul>
</body>

8. Mock 的随机方法应用

  • Mock.Random是一个工具类，用于生成各种随机数据
Type Method
Basic boolean, natural, integer, float, character, string, range, date, time, datetime, now
Image image, dataImage
Color color
Text paragraph, sentence, word, title, cparagraph, csentence, cword, ctitle
Name first, last, name, cfirst, clast, cname
Web url, domain, email, ip, tld
Address area, region
Helper capitalize, upper, lower, pick, shuffle
Miscellaneous guid, id

9. Mock 的随机自定义方法应用

  • Mock.Random.extend用于自定义扩展数据
Random.extend({
    
     
	constellation: function(date) {
    
     
		var constellations = [‘白羊座’, ‘金牛座’, ‘双子座’, ‘巨蟹座’, ‘狮子座’, ‘处女座’, ‘天秤座’, ‘天蝎座’, ‘射手座’, ‘摩羯座’, ‘水瓶座’, ‘双鱼座’] 
		return this.pick(constellations) 
	} 
}) 
Random.constellation() 
Mock.mock(‘@CONSTELLATION’) 
Mock.mock({
    
     constellation: '@CONSTELLATION' })

10. Mock 示例

10.1 属性值是字符串 String

  • 'name|min-max': string
    • 通过重复 string 生成一个字符串，重复次数大于等于 min，小于等于 max
Mock.mock({
    
    
  "string|1-10": "★"
})

# 结果
# 随机生成 1-10 内的 ★
{
    
    "string": "★★"}
  • 'name|count': string
    • 通过重复 string 生成一个字符串，重复次数等于 count
Mock.mock({
    
    
  "string|3": "★★★"
})

# 结果
# 生成3个的 ★★★
{
    
    "string": "★★★★★★★★★"}

10.2 属性值是数字 Number

  • 'name|+1': number
    • 属性值自动加 1，初始值为 number
Mock.mock({
    
    
  "number|+1": 202
})

# 结果
{
    
    
  "number": 201
}
  • 'name|min-max': number
    • 生成一个大于等于 min、小于等于 max 的整数，属性值 number 只是用来确定类型
Mock.mock({
    
    
  "number|1-100": 100
})

# 结果
{
    
    
  "number": 31
}
  • 'name|min-max.dmin-dmax': number
    • 生成一个浮点数，整数部分大于等于 min、小于等于 max，小数部分保留 dmin 到 dmax 位
Mock.mock({
    
    
    'number1|1-100.1-10': 1,
    'number2|123.1-10': 1,
    'number3|123.3': 1,
    'number4|123.10': 1.123
})

# 结果
{
    
    
    "number1": 12.92,
    "number2": 123.51,
    "number3": 123.777,
    "number4": 123.1231091814
}

10.3 属性值是布尔型 Boolean

  • 'name|1': boolean
    • 随机生成一个布尔值，值为 true 的概率是 1/2，值为 false 的概率同样是 1/2
Mock.mock({
    
    
  "boolean|1": true
})

# 结果
{
    
    
  "boolean": false
}
  • 'name|min-max': value
    • 随机生成一个布尔值，值为 value 的概率是 min / (min + max)，值为 !value 的概率是 max / (min + max)
Mock.mock({
    
    
  "boolean|1-2": true
})

# 结果
{
    
    
  "boolean": false
}

10.4 属性值是对象 Object

  • 'name|count': object
    • 从属性值 object 中随机选取 count 个属性
Mock.mock({
    
    
  "object|2": {
    
    
    "310000": "上海市",
    "320000": "江苏省",
    "330000": "浙江省",
    "340000": "安徽省"
  }
})

# 结果
{
    
    
  "object": {
    
    
    "320000": "江苏省",
    "330000": "浙江省"
  }
}
  • 'name|min-max': object
    • 从属性值 object 中随机选取 min 到 max 个属性
Mock.mock({
    
    
  "object|2-4": {
    
    
    "110000": "北京市",
    "120000": "天津市",
    "130000": "河北省",
    "140000": "山西省"
  }
})

# 结果
{
    
    
  "object": {
    
    
    "130000": "河北省",
    "140000": "山西省"
  }
}

10.5 属性值是数组 Array

  • 'name|1': array
    • 从属性值 array 中随机选取 1 个元素，作为最终值
Mock.mock({
    
    
  "array|1": [
    "AMD",
    "CMD",
    "UMD"
  ]
})

# 结果
{
    
    
  "array": "CMD"
}
  • 'name|+1': array
    • 从属性值 array 中顺序选取 1 个元素，作为最终值
Mock.mock({
    
    
  "array|+1": [
    "AMD",
    "CMD",
    "UMD"
  ]
})

# 结果
{
    
    
  "array": "AMD"
}
==================================
Mock.mock({
    
    
  "array|1-10": [
    {
    
    
      "name|+1": [
        "Hello",
        "Mock.js",
        "!"
      ]
    }
  ]
})

# 结果
{
    
    
  "array": [
    {
    
    
      "name": "Hello"
    },
    {
    
    
      "name": "Mock.js"
    },
    {
    
    
      "name": "!"
    },
    {
    
    
      "name": "Hello"
    },
    {
    
    
      "name": "Mock.js"
    }
  ]
}
  • 'name|min-max': array
    • 通过重复属性值 array 生成一个新数组，重复次数大于等于 min，小于等于 max
Mock.mock({
    
    
  "array|1-10": [
    "Mock.js"
  ]
})

# 结果
{
    
    
  "array": [
    "Mock.js",
    "Mock.js",
    "Mock.js",
    "Mock.js",
    "Mock.js",
    "Mock.js"
  ]
}
========================
Mock.mock({
    
    
  "array|1-10": [
    "Hello",
    "Mock.js",
    "!"
  ]
})

# 结果
{
    
    
  "array": [
    "Hello",
    "Mock.js",
    "!",
    "Hello",
    "Mock.js",
    "!"
  ]
}
  • 'name|count': array
    • 通过重复属性值 array 生成一个新数组，重复次数为 count
Mock.mock({
    
    
  "array|3": [
    "Mock.js"
  ]
})

# 结果
{
    
    
  "array": [
    "Mock.js",
    "Mock.js",
    "Mock.js"
  ]
}
======================
Mock.mock({
    
    
  "array|3": [
    "Hello",
    "Mock.js",
    "!"
  ]
})

# 结果
{
    
    
  "array": [
    "Hello",
    "Mock.js",
    "!",
    "Hello",
    "Mock.js",
    "!",
    "Hello",
    "Mock.js",
    "!"
  ]
}

10.6 属性值是函数 Function

  • 'name': function
    • 执行函数 function，取其返回值作为最终的属性值，函数的上下文为属性 name 所在的对象
Mock.mock({
    
    
  'foo': 'Syntax Demo',
  'name': function() {
    
    
    return this.foo
  }
})

# 结果
{
    
    
  "foo": "Syntax Demo",
  "name": "Syntax Demo"
}

10.7 属性值是正则表达式 RegExp

  • 'name': regexp
    • 根据正则表达式 regexp 反向生成可以匹配它的字符串
    • 用于生成自定义格式的字符串
Mock.mock({
    
    
    'regexp1': /[a-z][A-Z][0-9]/,
    'regexp2': /\w\W\s\S\d\D/,
    'regexp3': /\d{5,10}/
})

# 结果
{
    
    
    "regexp1": "pJ7",
    "regexp2": "F)\fp1G",
    "regexp3": "561659409"
}
=========================================
Mock.mock({
    
    
  'regexp|3': /\d{5,10}\-/
})

# 结果
{
    
    
  "regexp": "6832424-9141995256-46521642-"
}
============================================
Mock.mock({
    
    
  'regexp|1-5': /\d{5,10}\-/
})

# 结果
{
    
    
  "regexp": "055507106-"
}

10.8 属性值是路径 Path

10.8.1 绝对路径
  • Absolute Path
Mock.mock({
    
    
  "foo": "Hello",
  "nested": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "Mock.js"
      }
    }
  },
  "absolutePath": "@/foo @/nested/a/b/c"
})

# 结果
{
    
    
  "foo": "Hello",
  "nested": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "Mock.js"
      }
    }
  },
  "absolutePath": "Hello Mock.js"
}
10.8.2 相对路径
  • Relative Path
Mock.mock({
    
    
  "foo": "Hello",
  "nested": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "Mock.js"
      }
    }
  },
  "relativePath": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "@../../../foo @../../../nested/a/b/c"
      }
    }
  }
})

# 结果
{
    
    
  "foo": "Hello",
  "nested": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "Mock.js"
      }
    }
  },
  "relativePath": {
    
    
    "a": {
    
    
      "b": {
    
    
        "c": "Hello Mock.js"
      }
    }
  }
}

10.9 数据占位符定义

10.9.1 Basic
  • Random.boolean( min?, max?, current? )
    • min = min / (min + max)(current 出现的概率)
    • max = max / (min + max)(!current 出现的概率)
    • current 为布尔值 true 或 false
    • 返回一个随机的布尔值 current
// Random.boolean()
Random.boolean()
Mock.mock('@boolean')
Mock.mock('@boolean()')

# 结果
// Random.boolean()
false
true
true

// Random.boolean( min, max, current )
Random.boolean(1, 9, true)
Mock.mock('@boolean(1, 9, true)')

# 结果
// Random.boolean( min, max, current )
true
false
  • Random.natural( min?, max? )
    • Random.natural()
    • Random.natural( min )
    • Random.natural( min, max )
    • 返回一个随机的自然数（大于等于 0 的整数）
Random.natural()
// => 1002794054057984
Random.natural(10000)
// => 71529071126209
Random.natural(60, 100)
// => 77
  • Random.integer( min?, max? )
    • Random.integer()
    • Random.integer( min )
    • Random.integer( min, max )
    • 返回一个随机的整数
Random.integer()
// => -3815311811805184
Random.integer(10000)
// => 4303764511003750
Random.integer(60,100)
// => 96
  • Random.float( min?, max?, dmin?, dmax? )
    • 返回一个随机的浮点数
Random.float()
// => -1766114241544192.8
Random.float(0)
// => 556530504040448.25
Random.float(60, 100)
// => 82.56779679549358
Random.float(60, 100, 3)
// => 61.718533677927894
Random.float(60, 100, 3, 5)
// => 70.6849
  • Random.character( pool? )
    • 返回一个随机字符
# pool 字符池
# 如果传入了 'lower' 或 'upper'、'number'、'symbol'，表示从内置的字符池从选取
# 如果未传入该参数，则从 `lower + upper + number + symbol` 中随机选取一个字符返回
{
    
    
    lower: "abcdefghijklmnopqrstuvwxyz",
    upper: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
    number: "0123456789",
    symbol: "!@#$%^&*()[]"
}

Random.character()
// => "P"
Random.character('lower')
// => "y"
Random.character('upper')
// => "X"
Random.character('number')
// => "1"
Random.character('symbol')
// => "&"
Random.character('aeiou')
// => "u"
  • Random.string( pool?, min?, max? )
    • min (随机字符串的最小长度, 默认值为 3)
    • max(随机字符串的最大长度, 默认值为 7)
Random.string()
// => "pJjDUe"
Random.string( 5 )
// => "GaadY"
Random.string( 'lower', 5 )
// => "jseqj"
Random.string( 7, 10 )
// => "UuGQgSYk"
Random.string( 'aeiou', 1, 3 )
// => "ea"
Random.string( '壹贰叁肆伍陆柒捌玖拾', 3, 5 )
// => "肆捌伍叁"
  • Random.range( start?, stop, step? )
    • Random.range( stop )
    • Random.range( start, stop )
    • Random.range( start, stop, step )
    • 返回一个整型数组
# start 数组中整数的起始值
# stop  数组中整数的结束值（不包含在返回值中）
# step  数组中整数之间的步长，默认值为1

Random.range(10)
// => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Random.range(3, 7)
// => [3, 4, 5, 6]
Random.range(1, 10, 2)
// => [1, 3, 5, 7, 9]
Random.range(1, 10, 3)
// => [1, 4, 7]
10.9.2 Date
  • Random.date( format? )
    • format 指示生成的日期字符串的格式, 默认值为 yyyy-MM-dd
    • 返回一个随机的日期字符串
Random.date()
// => "2002-10-23"
Random.date('yyyy-MM-dd')
// => "1983-01-29"
Random.date('yy-MM-dd')
// => "79-02-14"
Random.date('y-MM-dd')
// => "81-05-17"
Random.date('y-M-d')
// => "84-6-5"
  • Random.time( format? )
    • format 指示生成的时间字符串的格式, 默认值为 HH:mm:ss
    • 返回一个随机的时间字符串
Random.time()
// => "00:14:47"
Random.time('A HH:mm:ss')
// => "PM 20:47:37"
Random.time('a HH:mm:ss')
// => "pm 17:40:00"
Random.time('HH:mm:ss')
// => "03:57:53"
Random.time('H:m:s')
// => "3:5:13"
  • Random.datetime( format? )
    • format 指示生成的日期和时间字符串的格式, 默认值为 yyyy-MM-dd HH:mm:ss
    • 返回一个随机的日期和时间字符串
Random.datetime()
// => "1977-11-17 03:50:15"
Random.datetime('yyyy-MM-dd A HH:mm:ss')
// => "1976-04-24 AM 03:48:25"
Random.datetime('yy-MM-dd a HH:mm:ss')
// => "73-01-18 pm 22:12:32"
Random.datetime('y-MM-dd HH:mm:ss')
// => "79-06-24 04:45:16"
Random.datetime('y-M-d H:m:s')
// => "02-4-23 2:49:40"
  • Random.now( unit?, format? )
    • unit 表示时间单位，用于对当前日期和时间进行格式化
    • 返回当前的日期和时间字符串
Random.now()
// => "2014-04-29 20:08:38 "
Random.now('day', 'yyyy-MM-dd HH:mm:ss SS')
// => "2014-04-29 00:00:00 000"
Random.now('day')
// => "2014-04-29 00:00:00 "
Random.now('yyyy-MM-dd HH:mm:ss SS')
// => "2014-04-29 20:08:38 157"

Random.now('year')
// => "2014-01-01 00:00:00"
Random.now('month')
// => "2014-04-01 00:00:00"
Random.now('week')
// => "2014-04-27 00:00:00"
Random.now('day')
// => "2014-04-29 00:00:00"
Random.now('hour')
// => "2014-04-29 20:00:00"
Random.now('minute')
// => "2014-04-29 20:08:00"
Random.now('second')
// => "2014-04-29 20:08:38"
10.9.3 Image
  • Random.image( size?, background?, foreground?, format?, text? )
    • 生成一个随机的图片地址
Random.image()
// => "http://dummyimage.com/125x125"
Random.image('200x100')
// => "http://dummyimage.com/200x100"
Random.image('200x100', '#fb0a2a')
// => "http://dummyimage.com/200x100/fb0a2a"
Random.image('200x100', '#02adea', 'Hello')
// => "http://dummyimage.com/200x100/02adea&text=Hello"
Random.image('200x100', '#00405d', '#FFF', 'Mock.js')
// => "http://dummyimage.com/200x100/00405d/FFF&text=Mock.js"
Random.image('200x100', '#ffcc33', '#FFF', 'png', '!')
// => "http://dummyimage.com/200x100/ffcc33/FFF.png&text=!"
  • Random.dataImage( size?, text? )
    • 生成一段随机的 Base64 图片编码
10.9.4 Color
  • Random.color()
    • 随机生成一个有吸引力的颜色，格式为 '#RRGGBB'
  • Random.hex()
    • 随机生成一个有吸引力的颜色，格式为 '#RRGGBB'
  • Random.rgb()
    • 随机生成一个有吸引力的颜色，格式为 'rgb(r, g, b)'
  • Random.rgba()
    • 随机生成一个有吸引力的颜色，格式为 'rgba(r, g, b, a)'
  • Random.hsl()
    • 随机生成一个有吸引力的颜色，格式为 'hsl(h, s, l)'
Random.color()
// => "#3538B2"

Random.hex()
// => "#3538B2"

Random.rgb()
// => "rgb(242, 198, 121)"

Random.rgba()
// => "rgba(242, 198, 121, 0.13)"

Random.hsl()
// => "hsl(345, 82, 71)"
10.9.5 Text

  • Random.paragraph( min?, max? )

    • 随机生成一段文本

  • Random.cparagraph( min?, max? )

    • 随机生成一段中文文本

  • Random.sentence( min?, max? )

    • 随机生成一个句子，第一个单词的首字母大写

  • Random.csentence( min?, max? )

    • 随机生成一段中文文本

  • Random.word( min?, max? )

    • 随机生成一个单词

  • Random.cword( pool?, min?, max? )

    • 随机生成一个汉字

  • Random.title( min?, max? )

    • 随机生成一句标题，其中每个单词的首字母大写

  • Random.ctitle( min?, max? )

    • 随机生成一句中文标题
Random.paragraph(1, 3)
// => "Qdgfqm puhxle twi lbeqjqfi bcxeeecu pqeqr srsx tjlnew oqtqx zhxhkvq pnjns eblxhzzta hifj csvndh ylechtyu."

Random.cparagraph(1, 3)
// => "候无部社心性有构员其深例矿取民为。须被亲需报每完认支这明复几下在铁需连。省备可离展五斗器就石正队除解动。"

Random.sentence(3, 5)
// => "Mgl qhrprwkhb etvwfbixm jbqmg."

Random.csentence()
// => "第任人九同段形位第律认得。"

Random.word(3, 5)
// => "kemh"

Random.cword(5, 7)
// => "设过证全争听"

Random.title(3, 5)
// => "Hvjexiondr Pyickubll Owlorjvzys Xfnfwbfk"

Random.ctitle(3, 5)
// => "出料阶相"
10.9.6 Name

  • Random.first()

    • 随机生成一个常见的英文名

  • Random.name( middle? )

    • 随机生成一个常见的英文姓名

  • Random.cname()

    • 随机生成一个常见的中文姓名
Random.first()
// => "Nancy"

Random.name()
// => "Larry Wilson"

Random.cname()
// => "袁军"
10.9.7 Web

  • Random.url( protocol, host )

    • 随机生成一个 URL

  • Random.domain()

    • 随机生成一个域名

  • Random.email( domain )

    • 随机生成一个邮件地址

  • Random.ip()

    • 随机生成一个 IP 地址
Random.url('http', 'nuysoft.com')
// => "http://nuysoft.com/ewacecjhe"

Random.domain()
// => "kozfnb.org"

Random.email('nuysoft.com')
// => "[email protected]"

Random.ip()
// => "34.206.109.169"
10.9.8 Address

  • Random.region()

    • 随机生成一个（中国）大区

  • Random.province()

    • 随机生成一个（中国）省（或直辖市、自治区、特别行政区）

  • Random.city( prefix )

    • prefix 指示是否生成所属的省
    • 随机生成一个（中国）市

  • Random.county( prefix )

    • 随机生成一个（中国）县

  • Random.zip()

    • 随机生成一个邮政编码（六位数字）
Random.region()
// => "华北"

Random.province()
// => "黑龙江省"

Random.city()
// => "唐山市"
Random.city(true)
// => "福建省 漳州市"

Random.county()
// => "上杭县"
Random.county(true)
// => "甘肃省 白银市 会宁县"

Random.zip()
// => "908812"
10.9.9 Miscellaneous
  • Random.guid()
    • 随机生成一个 GUID
Random.guid()
// => "662C63B4-FD43-66F4-3328-C54E3FF0D56E"
  • Random.id()
    • 随机生成一个 18 位身份证
Random.id()
// => "420000200710091854"
  • Random.increment( step )
    • 生成一个全局的自增整数
    • step 整数自增的步长, 默认值为 1
Random.increment()
// => 1
Random.increment(100)
// => 101
Random.increment(1000)
// => 1101

10. 总结

  • Mock.js 能模拟数据，完成前端页面的相关测试，做个笔记

猜你喜欢

转载自blog.csdn.net/qq_43645678/article/details/108500038
今日推荐
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
周排行
rbac——界面、权限
Apache CXF + SpringMVC 整合发布WebService
so插件化
Vue.js实战系列---图标字体制作（svg格式）
PAT乙级 1007 素数对猜想(孪生素数对) (20分) ---（C语言 + 详细注释）
被IRM保护的文档，打开失败
Calendar和Date计算日期差的小问题
win10子系统ubuntu18.4安装docker
利用Wrap Shell Script定位Android Native内存泄漏
MySQL: Transaction (Part I - Basic Concept)
每日归档
更多
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022