Andrew的博客

practice makes perfect

0%

lodash

发表于

lodash的demo

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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
<!DOCTYPE html>
<html>
<head>
    <title>lodash demo</title>
    <script src="https://cdn.jsdelivr.net/lodash/4.17.4/lodash.js"></script>
</head>
<body>
</body>
<script>
    /*
    lodash 是一个非常实用的 js 工具库
    在 node 中可以安装
    也可以自己下载来导入

    在 浏览器 中, 可以通过 CDN 的方式使用
    */
    // _ 是 lodash 的套路用法
    // const _ = require('./lodash.js')



    // each 用法
    const list = [
        'a',
        'b',
        'c',
    ]

    const dict = {
        k1: 'a',
        k2: 'b',
        k3: 'c',
    }

    _.each(list, (v, k) => {
        // each 方法的两个参数
        // 如果 list 是 列表，那么 v 和 k 分别是指 list 的 element/index
        // 如果 list 是 对象（字典），那么 v 和 k 分别是指 object 的 value/key
        console.log('element and index', v, k)
    })

    _.each(dict, (v, k) => {
        console.log('value and key', v, k)
    })



    // map 用法
    // 用 map 可以用一个旧数组生成一个新数组
    // 比如旧数组为
    const list1 = [
        10,
        20,
        30,
    ]

    const list2 = _.map(list1, (v, k) => {
        const r = v * v
        return r
    })
    console.log('list2', list2)



    // filter
    // 遍历数组/对象，返回符合判断函数中的元素
    var us = [
        {
            'name': 'a',
            'score': 70,
        },
        {
            'name': 'b',
            'score': 90,
        },
        {
            'name': 'c',
            'score': 80,
        },
        {
            'name': 'd',
            'score': 70,
        },
    ]

    var u = _.filter(us, (e) => {
        var b = e.score > 70
        return b
    })
    console.log('filter u', u)



    // orderBy
    // 根据条件排序
    // 先按照 score 升序，如果有 score 一样的
    // 再按照 name 降序
    var users = _.orderBy(us, ['score', 'name'], ['asc', 'desc'])
    console.log('order by users', users)



    // flatten
    // 减少一层嵌套数组
    // 也就是可以直接将二维数组拍成一维数组

    var l = [
        1,
        [2],
        [3, [4]],
        [5, [6], [7]],
    ]
    var f = _.flatten(l)
    console.log('flatten result', f)



    // compact
    // 剔除数组中的假值元素
    // js 中假值元素分别为
    // false null 0 NaN '' undefined

    // 这个方法可以和 map 配合使用
    // 剔除返回数组的数组中的假值元素
    var l = [
        0,
        1,
        NaN,
        '',
        'hello',
        false,
        undefined,
        null,
        {},
    ]
    var result = _.compact(l)
    console.log('compact result', result)



    // isEqual
    // 比较两个对象是否相等
    // 数组也可以用这个方法比较
    var o1 = {
        'key': 1,
    }

    var o2 = {
        'key': 1,
    }

    var result = _.isEqual(o1, o2)
    console.log('isEqual result', result)



    // 获取嵌套对象的值
    var o = {
        'k1': {
            'k2': {
                'k3': {
                    'k4': 'value in nested dict'
                }
            }
        }
    }

    var path = 'k1.k2.k3.k4'
    var result = _.result(o, path)
    console.log('result nested result', result)



    // 生成数组
    // 使用 range 生成数组后，就可以使用
    // each map filter 这些方法操作数组了
    var l = _.range(10)
    console.log('range l', l)



    // cloneDeep
    // 深拷贝
    var o = {
        'a': [1],
        'b': [2],
    }

    var deep = _.cloneDeep(o)
    console.log('deep', deep)



    // random
    // 返回给定范围的随机值
    var a = 10
    var b = 20

    // 返回 a 和 b 之间的一个整数
    var r1 = _.random(a, b)
    console.log('random r1', r1)


    // 如果指定第三个参数为 true，这个参数的意思是指 floating
    // 那么返回的就是一个浮点数
    var r2 = _.random(a, b, true)
    console.log('random r2', r2)



    // shuffle
    // 返回打乱顺序后的数组
    var l = [1, 2, 3, 4,]
    const s = _.shuffle(l)
    console.log('shuffle l', s)
</script>
</html>