1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 | (function (global, factory) {
|
7 | typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
8 | typeof define === 'function' && define.amd ? define(factory) :
|
9 | (global.XEUtils = factory());
|
10 | }(this, function () {'use strict'
|
11 |
|
12 |
|
13 | var setupDefaults = {
|
14 | cookies: {
|
15 | path: '/'
|
16 | },
|
17 | treeOptions: {
|
18 | parentKey: 'parentId',
|
19 | key: 'id',
|
20 | children: 'children'
|
21 | },
|
22 | formatString: 'yyyy-MM-dd HH:mm:ss',
|
23 | dateDiffRules: [
|
24 | ['yyyy', 31536000000],
|
25 | ['MM', 2592000000],
|
26 | ['dd', 86400000],
|
27 | ['HH', 3600000],
|
28 | ['mm', 60000],
|
29 | ['ss', 1000],
|
30 | ['S', 0]
|
31 | ]
|
32 | }
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 | var XEUtils = function () {}
|
40 |
|
41 | function mixin () {
|
42 | arrayEach(arguments, function (methods) {
|
43 | each(methods, function (fn, name) {
|
44 | XEUtils[name] = isFunction(fn) ? function () {
|
45 | var result = fn.apply(XEUtils.$context, arguments)
|
46 | XEUtils.$context = null
|
47 | return result
|
48 | } : fn
|
49 | })
|
50 | })
|
51 | }
|
52 |
|
53 | function setup (options) {
|
54 | return assign(setupDefaults, options)
|
55 | }
|
56 |
|
57 | XEUtils.VERSION = '3.4.2'
|
58 | XEUtils.mixin = mixin
|
59 | XEUtils.setup = setup
|
60 |
|
61 |
|
62 |
|
63 | function helperCreateGetObjects (name, getIndex) {
|
64 | var proMethod = Object[name]
|
65 | return function (obj) {
|
66 | var result = []
|
67 | if (obj) {
|
68 | if (proMethod) {
|
69 | return proMethod(obj)
|
70 | }
|
71 | each(obj, getIndex > 1 ? function (key) {
|
72 | result.push(['' + key, obj[key]])
|
73 | } : function () {
|
74 | result.push(arguments[getIndex])
|
75 | })
|
76 | }
|
77 | return result
|
78 | }
|
79 | }
|
80 |
|
81 |
|
82 |
|
83 | function helperCreateIndexOf (name, callback) {
|
84 | return function (obj, val) {
|
85 | if (obj) {
|
86 | if (obj[name]) {
|
87 | return obj[name](val)
|
88 | }
|
89 | if (isString(obj) || isArray(obj)) {
|
90 | return callback(obj, val)
|
91 | }
|
92 | for (var key in obj) {
|
93 | if (hasOwnProp(obj, key)) {
|
94 | if (val === obj[key]) {
|
95 | return key
|
96 | }
|
97 | }
|
98 | }
|
99 | }
|
100 | return -1
|
101 | }
|
102 | }
|
103 |
|
104 |
|
105 |
|
106 | function helperCreateInInObjectString (type) {
|
107 | return function (obj) {
|
108 | return '[object ' + type + ']' === objectToString.call(obj)
|
109 | }
|
110 | }
|
111 |
|
112 |
|
113 |
|
114 | function helperCreateInTypeof (type) {
|
115 | return function (obj) {
|
116 | return typeof obj === type
|
117 | }
|
118 | }
|
119 |
|
120 |
|
121 |
|
122 | function helperCreateIterateHandle (prop, useArray, restIndex, matchValue, defaultValue) {
|
123 | return function (obj, iterate, context) {
|
124 | if (obj && iterate) {
|
125 | if (prop && obj[prop]) {
|
126 | return obj[prop](iterate, context)
|
127 | } else {
|
128 | if (useArray && isArray(obj)) {
|
129 | for (var index = 0, len = obj.length; index < len; index++) {
|
130 | if (!!iterate.call(context, obj[index], index, obj) === matchValue) {
|
131 | return [true, false, index, obj[index]][restIndex]
|
132 | }
|
133 | }
|
134 | } else {
|
135 | for (var key in obj) {
|
136 | if (hasOwnProp(obj, key)) {
|
137 | if (!!iterate.call(context, obj[key], key, obj) === matchValue) {
|
138 | return [true, false, key, obj[key]][restIndex]
|
139 | }
|
140 | }
|
141 | }
|
142 | }
|
143 | }
|
144 | }
|
145 | return defaultValue
|
146 | }
|
147 | }
|
148 |
|
149 |
|
150 |
|
151 | function helperCreateiterateIndexOf (callback) {
|
152 | return function (obj, iterate, context) {
|
153 | if (obj && isFunction(iterate)) {
|
154 | if (isArray(obj) || isString(obj)) {
|
155 | return callback(obj, iterate, context)
|
156 | }
|
157 | for (var key in obj) {
|
158 | if (hasOwnProp(obj, key)) {
|
159 | if (iterate.call(context, obj[key], key, obj)) {
|
160 | return key
|
161 | }
|
162 | }
|
163 | }
|
164 | }
|
165 | return -1
|
166 | }
|
167 | }
|
168 |
|
169 |
|
170 |
|
171 |
|
172 | function helperCreateMathNumber(name) {
|
173 | return function (num, digits) {
|
174 | var numRest = toNumber(num)
|
175 | var rest = numRest
|
176 | if (numRest) {
|
177 | digits = digits >> 0
|
178 | var numStr = toNumberString(numRest)
|
179 | var nums = numStr.split('.')
|
180 | var intStr = nums[0]
|
181 | var floatStr = nums[1] || ''
|
182 | var fStr = floatStr.substring(0, digits + 1)
|
183 | var subRest = intStr + (fStr ? ('.' + fStr) : '')
|
184 | if (digits >= floatStr.length) {
|
185 | return toNumber(subRest)
|
186 | }
|
187 | subRest = numRest
|
188 | if (digits > 0) {
|
189 | var ratio = Math.pow(10, digits)
|
190 | rest = Math[name](helperMultiply(subRest, ratio)) / ratio
|
191 | } else {
|
192 | rest = Math[name](subRest)
|
193 | }
|
194 | }
|
195 | return rest
|
196 | }
|
197 | }
|
198 |
|
199 |
|
200 |
|
201 |
|
202 | function helperCreateMinMax (handle) {
|
203 | return function (arr, iterate) {
|
204 | if (arr && arr.length) {
|
205 | var rest, itemIndex
|
206 | arrayEach(arr, function (itemVal, index) {
|
207 | if (iterate) {
|
208 | itemVal = isFunction(iterate) ? iterate(itemVal, index, arr) : get(itemVal, iterate)
|
209 | }
|
210 | if (!eqNull(itemVal) && (eqNull(rest) || handle(rest, itemVal))) {
|
211 | itemIndex = index
|
212 | rest = itemVal
|
213 | }
|
214 | })
|
215 | return arr[itemIndex]
|
216 | }
|
217 | return rest
|
218 | }
|
219 | }
|
220 |
|
221 |
|
222 |
|
223 | function helperCreatePickOmit (case1, case2) {
|
224 | return function (obj, callback) {
|
225 | var item, index
|
226 | var rest = {}
|
227 | var result = []
|
228 | var context = this
|
229 | var args = arguments
|
230 | var len = args.length
|
231 | if (!isFunction(callback)) {
|
232 | for (index = 1; index < len; index++) {
|
233 | item = args[index]
|
234 | result.push.apply(result, isArray(item) ? item : [item])
|
235 | }
|
236 | callback = 0
|
237 | }
|
238 | each(obj, function (val, key) {
|
239 | if ((callback ? callback.call(context, val, key, obj) : findIndexOf(result, function (name) {
|
240 | return name === key
|
241 | }) > -1) ? case1 : case2) {
|
242 | rest[key] = val
|
243 | }
|
244 | })
|
245 | return rest
|
246 | }
|
247 | }
|
248 |
|
249 |
|
250 | function helperCreateToNumber (handle) {
|
251 | return function (str) {
|
252 | if (str) {
|
253 | var num = handle(str)
|
254 | if (!isNaN(num)) {
|
255 | return num
|
256 | }
|
257 | }
|
258 | return 0
|
259 | }
|
260 | }
|
261 |
|
262 |
|
263 | function helperCreateTreeFunc (handle) {
|
264 | return function (obj, iterate, options, context) {
|
265 | var opts = options || {}
|
266 | var optChildren = opts.children || 'children'
|
267 | return handle(null, obj, iterate, context, [], [], optChildren, opts)
|
268 | }
|
269 | }
|
270 |
|
271 |
|
272 | function helperDefaultCompare (v1, v2) {
|
273 | return v1 === v2
|
274 | }
|
275 |
|
276 |
|
277 | function helperDeleteProperty (obj, property) {
|
278 | try {
|
279 | delete obj[property]
|
280 | } catch (e) {
|
281 | obj[property] = undefined
|
282 | }
|
283 | }
|
284 |
|
285 |
|
286 |
|
287 |
|
288 | function helperEqualCompare (val1, val2, compare, func, key, obj1, obj2) {
|
289 | if (val1 === val2) {
|
290 | return true
|
291 | }
|
292 | if (val1 && val2 && !isNumber(val1) && !isNumber(val2) && !isString(val1) && !isString(val2)) {
|
293 | if (isRegExp(val1)) {
|
294 | return compare('' + val1, '' + val2, key, obj1, obj2)
|
295 | } if (isDate(val1) || isBoolean(val1)) {
|
296 | return compare(+val1, +val2, key, obj1, obj2)
|
297 | } else {
|
298 | var result, val1Keys, val2Keys
|
299 | var isObj1Arr = isArray(val1)
|
300 | var isObj2Arr = isArray(val2)
|
301 | if (isObj1Arr || isObj2Arr ? isObj1Arr && isObj2Arr : val1.constructor === val2.constructor) {
|
302 | val1Keys = keys(val1)
|
303 | val2Keys = keys(val2)
|
304 | if (func) {
|
305 | result = func(val1, val2, key)
|
306 | }
|
307 | if (val1Keys.length === val2Keys.length) {
|
308 | return isUndefined(result) ? every(val1Keys, function (key, index) {
|
309 | return key === val2Keys[index] && helperEqualCompare(val1[key], val2[val2Keys[index]], compare, func, isObj1Arr || isObj2Arr ? index : key, val1, val2)
|
310 | }) : !!result
|
311 | }
|
312 | return false
|
313 | }
|
314 | }
|
315 | }
|
316 | return compare(val1, val2, key, obj1, obj2)
|
317 | }
|
318 |
|
319 |
|
320 |
|
321 | function helperFormatEscaper (dataMap) {
|
322 | var replaceRegexp = new RegExp('(?:' + keys(dataMap).join('|') + ')', 'g')
|
323 | return function (str) {
|
324 | return toValueString(str).replace(replaceRegexp, function (match) {
|
325 | return dataMap[match]
|
326 | })
|
327 | }
|
328 | }
|
329 |
|
330 |
|
331 | function helperGetDateFullYear (date) {
|
332 | return date.getFullYear()
|
333 | }
|
334 |
|
335 |
|
336 | function helperGetDateMonth (date) {
|
337 | return date.getMonth()
|
338 | }
|
339 |
|
340 |
|
341 | function helperGetDateTime (date) {
|
342 | return date.getTime()
|
343 | }
|
344 |
|
345 |
|
346 | function helperGetHGSKeys (property) {
|
347 |
|
348 | return property ? (property.splice && property.join ? property : ('' + property).replace(/(\[\d+\])\.?/g,'$1.').replace(/\.$/, '').split('.')) : []
|
349 | }
|
350 |
|
351 |
|
352 |
|
353 | function helperGetLocatOrigin () {
|
354 | return staticLocation ? (staticLocation.origin || (staticLocation.protocol + '//' + staticLocation.host)) : ''
|
355 | }
|
356 |
|
357 |
|
358 | function helperGetUTCDateTime (resMaps) {
|
359 | return Date.UTC(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0)
|
360 | }
|
361 |
|
362 |
|
363 |
|
364 | function helperGetYMD (date) {
|
365 | return new Date(helperGetDateFullYear(date), helperGetDateMonth(date), date.getDate())
|
366 | }
|
367 |
|
368 |
|
369 |
|
370 | function helperGetYMDTime (date) {
|
371 | return helperGetDateTime(helperGetYMD(date))
|
372 | }
|
373 |
|
374 |
|
375 |
|
376 | function helperMultiply (multiplier, multiplicand) {
|
377 | var str1 = toNumberString(multiplier)
|
378 | var str2 = toNumberString(multiplicand)
|
379 | return parseInt(str1.replace('.', '')) * parseInt(str2.replace('.', '')) / Math.pow(10, helperNumberDecimal(str1) + helperNumberDecimal(str2))
|
380 | }
|
381 |
|
382 |
|
383 | function helperNewDate () {
|
384 | return new Date()
|
385 | }
|
386 |
|
387 |
|
388 |
|
389 | function helperNumberAdd (addend, augend) {
|
390 | var str1 = toNumberString(addend)
|
391 | var str2 = toNumberString(augend)
|
392 | var ratio = Math.pow(10, Math.max(helperNumberDecimal(str1), helperNumberDecimal(str2)))
|
393 | return (multiply(addend, ratio) + multiply(augend, ratio)) / ratio
|
394 | }
|
395 |
|
396 |
|
397 | function helperNumberDecimal (numStr) {
|
398 | return (numStr.split('.')[1] || '').length
|
399 | }
|
400 |
|
401 |
|
402 |
|
403 | function helperNumberDivide (divisor, dividend) {
|
404 | var str1 = toNumberString(divisor)
|
405 | var str2 = toNumberString(dividend)
|
406 | var divisorDecimal = helperNumberDecimal(str1)
|
407 | var dividendDecimal = helperNumberDecimal(str2)
|
408 | var powY = dividendDecimal - divisorDecimal
|
409 | var isMinus = powY < 0
|
410 | var multiplicand = Math.pow(10, isMinus ? Math.abs(powY) : powY)
|
411 | return multiply(str1.replace('.', '') / str2.replace('.', ''), isMinus ? 1 / multiplicand : multiplicand)
|
412 | }
|
413 |
|
414 |
|
415 | function helperNumberOffsetPoint (str, offsetIndex) {
|
416 | return str.substring(0, offsetIndex) + '.' + str.substring(offsetIndex, str.length)
|
417 | }
|
418 |
|
419 |
|
420 | function helperStringLowerCase (str) {
|
421 | return str.toLowerCase()
|
422 | }
|
423 |
|
424 |
|
425 |
|
426 | function helperStringRepeat (str, count) {
|
427 | if (str.repeat) {
|
428 | return str.repeat(count)
|
429 | }
|
430 | var list = isNaN(count) ? [] : new Array(staticParseInt(count))
|
431 | return list.join(str) + (list.length > 0 ? str : '')
|
432 | }
|
433 |
|
434 |
|
435 | function helperStringSubstring (str, start, end) {
|
436 | return str.substring(start, end)
|
437 | }
|
438 |
|
439 |
|
440 | function helperStringUpperCase (str) {
|
441 | return str.toUpperCase()
|
442 | }
|
443 |
|
444 |
|
445 | var staticStrUndefined = 'undefined'
|
446 |
|
447 |
|
448 | var staticStrLast = 'last'
|
449 |
|
450 |
|
451 | var staticStrFirst = 'first'
|
452 |
|
453 |
|
454 | var staticDayTime = 86400000
|
455 |
|
456 |
|
457 |
|
458 | var staticWeekTime = staticDayTime * 7
|
459 |
|
460 |
|
461 |
|
462 |
|
463 | var staticLocation = typeof location === staticStrUndefined ? 0 : location
|
464 |
|
465 |
|
466 |
|
467 |
|
468 | var staticWindow = typeof window === staticStrUndefined ? 0 : window
|
469 |
|
470 |
|
471 |
|
472 |
|
473 | var staticDocument = typeof document === staticStrUndefined ? 0 : document
|
474 |
|
475 |
|
476 | var staticEncodeURIComponent = encodeURIComponent
|
477 |
|
478 |
|
479 | var staticDecodeURIComponent = decodeURIComponent
|
480 |
|
481 |
|
482 | var objectToString = Object.prototype.toString
|
483 |
|
484 |
|
485 | var staticParseInt = parseInt
|
486 |
|
487 |
|
488 | var staticEscapeMap = {
|
489 | '&': '&',
|
490 | '<': '<',
|
491 | '>': '>',
|
492 | '"': '"',
|
493 | "'": ''',
|
494 | '`': '`'
|
495 | }
|
496 |
|
497 |
|
498 | var staticHGKeyRE = /(.+)?\[(\d+)\]$/
|
499 |
|
500 |
|
501 |
|
502 | var objectAssignFns = Object.assign
|
503 |
|
504 | function handleAssign (destination, args, isClone) {
|
505 | var len = args.length
|
506 | for (var source, index = 1; index < len; index++) {
|
507 | source = args[index]
|
508 | arrayEach(keys(args[index]), isClone ? function (key) {
|
509 | destination[key] = clone(source[key], isClone)
|
510 | } : function (key) {
|
511 | destination[key] = source[key]
|
512 | })
|
513 | }
|
514 | return destination
|
515 | }
|
516 |
|
517 |
|
518 |
|
519 |
|
520 |
|
521 |
|
522 |
|
523 |
|
524 | var assign = function (target) {
|
525 | if (target) {
|
526 | var args = arguments
|
527 | if (target === true) {
|
528 | if (args.length > 1) {
|
529 | target = isArray(target[1]) ? [] : {}
|
530 | return handleAssign(target, args, true)
|
531 | }
|
532 | } else {
|
533 | return objectAssignFns ? objectAssignFns.apply(Object, args) : handleAssign(target, args)
|
534 | }
|
535 | }
|
536 | return target
|
537 | }
|
538 |
|
539 |
|
540 |
|
541 |
|
542 |
|
543 |
|
544 |
|
545 |
|
546 |
|
547 |
|
548 |
|
549 | function objectMap (obj, iterate, context) {
|
550 | var result = {}
|
551 | if (obj) {
|
552 | if (iterate) {
|
553 | if (!isFunction(iterate)) {
|
554 | iterate = property(iterate)
|
555 | }
|
556 | each(obj, function (val, index) {
|
557 | result[index] = iterate.call(context, val, index, obj)
|
558 | })
|
559 | } else {
|
560 | return obj
|
561 | }
|
562 | }
|
563 | return result
|
564 | }
|
565 |
|
566 |
|
567 |
|
568 | function objectEach (obj, iterate, context) {
|
569 | if (obj) {
|
570 | for (var key in obj) {
|
571 | if (hasOwnProp(obj, key)) {
|
572 | iterate.call(context, obj[key], key, obj)
|
573 | }
|
574 | }
|
575 | }
|
576 | }
|
577 |
|
578 |
|
579 |
|
580 | function lastObjectEach (obj, iterate, context) {
|
581 | lastArrayEach(keys(obj), function (key) {
|
582 | iterate.call(context, obj[key], key, obj)
|
583 | })
|
584 | }
|
585 |
|
586 |
|
587 |
|
588 | function handleMerge (target, source) {
|
589 | if ((isPlainObject(target) && isPlainObject(source)) || (isArray(target) && isArray(source))) {
|
590 | each(source, function (obj, key) {
|
591 | target[key] = handleMerge(target[key], obj)
|
592 | })
|
593 | return target
|
594 | }
|
595 | return source
|
596 | }
|
597 |
|
598 |
|
599 |
|
600 |
|
601 |
|
602 |
|
603 |
|
604 |
|
605 | var merge = function (target) {
|
606 | if (!target) {
|
607 | target = {}
|
608 | }
|
609 | var args = arguments
|
610 | var len = args.length
|
611 | for (var source, index = 1; index < len; index++) {
|
612 | source = args[index]
|
613 | if (source) {
|
614 | handleMerge(target, source)
|
615 | }
|
616 | }
|
617 | return target
|
618 | }
|
619 |
|
620 |
|
621 |
|
622 |
|
623 |
|
624 |
|
625 |
|
626 |
|
627 |
|
628 | function uniq (array) {
|
629 | var result = []
|
630 | each(array, function (value) {
|
631 | if (!includes(result, value)) {
|
632 | result.push(value)
|
633 | }
|
634 | })
|
635 | return result
|
636 | }
|
637 |
|
638 |
|
639 |
|
640 |
|
641 |
|
642 |
|
643 |
|
644 |
|
645 |
|
646 | function union () {
|
647 | var args = arguments
|
648 | var result = []
|
649 | var index = 0
|
650 | var len = args.length
|
651 | for (; index < len; index++) {
|
652 | result = result.concat(toArray(args[index]))
|
653 | }
|
654 | return uniq(result)
|
655 | }
|
656 |
|
657 |
|
658 |
|
659 | var sortBy = orderBy
|
660 |
|
661 |
|
662 |
|
663 |
|
664 | var ORDER_PROP_ASC = 'asc'
|
665 | var ORDER_PROP_DESC = 'desc'
|
666 |
|
667 |
|
668 |
|
669 |
|
670 |
|
671 |
|
672 | function handleSort (v1, v2) {
|
673 | if (isUndefined(v1)) {
|
674 | return 1
|
675 | }
|
676 | if (isNull(v1)) {
|
677 | return isUndefined(v2) ? -1 : 1
|
678 | }
|
679 | return v1 && v1.localeCompare ? v1.localeCompare(v2) : (v1 > v2 ? 1 : -1)
|
680 | }
|
681 |
|
682 | function buildMultiOrders (name, confs, compares) {
|
683 | return function (item1, item2) {
|
684 | var v1 = item1[name]
|
685 | var v2 = item2[name]
|
686 | if (v1 === v2) {
|
687 | return compares ? compares(item1, item2) : 0
|
688 | }
|
689 | return confs.order === ORDER_PROP_DESC ? handleSort(v2, v1) : handleSort(v1, v2)
|
690 | }
|
691 | }
|
692 |
|
693 | function getSortConfs (arr, list, fieldConfs, context) {
|
694 | var sortConfs = []
|
695 | fieldConfs = isArray(fieldConfs) ? fieldConfs : [fieldConfs]
|
696 | arrayEach(fieldConfs, function (handle, index) {
|
697 | if (handle) {
|
698 | var field = handle
|
699 | var order
|
700 | if (isArray(handle)) {
|
701 | field = handle[0]
|
702 | order = handle[1]
|
703 | } else if (isPlainObject(handle)) {
|
704 | field = handle.field
|
705 | order = handle.order
|
706 | }
|
707 | sortConfs.push({
|
708 | field: field,
|
709 | order: order || ORDER_PROP_ASC
|
710 | })
|
711 | arrayEach(list, isFunction(field) ? function (item, key) {
|
712 | item[index] = field.call(context, item.data, key, arr)
|
713 | } : function (item) {
|
714 | item[index] = field ? get(item.data, field) : item.data
|
715 | })
|
716 | }
|
717 | })
|
718 | return sortConfs
|
719 | }
|
720 |
|
721 | /**
|
722 | * 将数组进行排序
|
723 | *
|
724 | * @param {Array} arr 数组
|
725 | * @param {Function/String/Array} fieldConfs 方法或属性
|
726 | * @param {Object} context 上下文
|
727 | * @return {Array}
|
728 | */
|
729 | function orderBy (arr, fieldConfs, context) {
|
730 | if (arr) {
|
731 | if (eqNull(fieldConfs)) {
|
732 | return toArray(arr).sort(handleSort)
|
733 | }
|
734 | var compares
|
735 | var list = map(arr, function (item) {
|
736 | return { data: item }
|
737 | })
|
738 | var sortConfs = getSortConfs(arr, list, fieldConfs, context)
|
739 | var len = sortConfs.length - 1
|
740 | while (len >= 0) {
|
741 | compares = buildMultiOrders(len, sortConfs[len], compares)
|
742 | len--
|
743 | }
|
744 | if (compares) {
|
745 | list = list.sort(compares)
|
746 | }
|
747 | return map(list, property('data'))
|
748 | }
|
749 | return []
|
750 | }
|
751 |
|
752 |
|
753 |
|
754 |
|
755 |
|
756 |
|
757 |
|
758 |
|
759 |
|
760 |
|
761 | function shuffle (array) {
|
762 | var index
|
763 | var result = []
|
764 | var list = values(array)
|
765 | var len = list.length - 1
|
766 | for (; len >= 0; len--) {
|
767 | index = len > 0 ? random(0, len) : 0
|
768 | result.push(list[index])
|
769 | list.splice(index, 1)
|
770 | }
|
771 | return result
|
772 | }
|
773 |
|
774 |
|
775 |
|
776 |
|
777 |
|
778 |
|
779 |
|
780 |
|
781 |
|
782 |
|
783 | function sample (array, number) {
|
784 | var result = shuffle(array)
|
785 | if (arguments.length <= 1) {
|
786 | return result[0]
|
787 | }
|
788 | if (number < result.length) {
|
789 | result.length = number || 0
|
790 | }
|
791 | return result
|
792 | }
|
793 |
|
794 |
|
795 |
|
796 |
|
797 |
|
798 |
|
799 |
|
800 |
|
801 |
|
802 |
|
803 |
|
804 | var some = helperCreateIterateHandle('some', 1, 0, true, false)
|
805 |
|
806 |
|
807 |
|
808 |
|
809 |
|
810 |
|
811 |
|
812 |
|
813 |
|
814 |
|
815 |
|
816 | var every = helperCreateIterateHandle('every', 1, 1, false, true)
|
817 |
|
818 |
|
819 |
|
820 |
|
821 |
|
822 |
|
823 |
|
824 |
|
825 |
|
826 | function slice (array, startIndex, endIndex) {
|
827 | var result = []
|
828 | var argsSize = arguments.length
|
829 | if (array) {
|
830 | startIndex = argsSize >= 2 ? toNumber(startIndex) : 0
|
831 | endIndex = argsSize >= 3 ? toNumber(endIndex) : array.length
|
832 | if (array.slice) {
|
833 | return array.slice(startIndex, endIndex)
|
834 | }
|
835 | for (; startIndex < endIndex; startIndex++) {
|
836 | result.push(array[startIndex])
|
837 | }
|
838 | }
|
839 | return result
|
840 | }
|
841 |
|
842 |
|
843 |
|
844 |
|
845 |
|
846 |
|
847 |
|
848 |
|
849 |
|
850 |
|
851 |
|
852 | function filter (obj, iterate, context) {
|
853 | var result = []
|
854 | if (obj && iterate) {
|
855 | if (obj.filter) {
|
856 | return obj.filter(iterate, context)
|
857 | }
|
858 | each(obj, function (val, key) {
|
859 | if (iterate.call(context, val, key, obj)) {
|
860 | result.push(val)
|
861 | }
|
862 | })
|
863 | }
|
864 | return result
|
865 | }
|
866 |
|
867 |
|
868 |
|
869 |
|
870 |
|
871 |
|
872 |
|
873 |
|
874 |
|
875 |
|
876 |
|
877 | var find = helperCreateIterateHandle('find', 1, 3, true)
|
878 |
|
879 |
|
880 |
|
881 |
|
882 |
|
883 |
|
884 |
|
885 |
|
886 |
|
887 |
|
888 |
|
889 | function findLast (obj, iterate, context) {
|
890 | if (obj) {
|
891 | if (!isArray(obj)) {
|
892 | obj = values(obj)
|
893 | }
|
894 | for (var len = obj.length - 1; len >= 0; len--) {
|
895 | if (iterate.call(context, obj[len], len, obj)) {
|
896 | return obj[len]
|
897 | }
|
898 | }
|
899 | }
|
900 | }
|
901 |
|
902 |
|
903 |
|
904 |
|
905 |
|
906 |
|
907 |
|
908 |
|
909 |
|
910 |
|
911 |
|
912 | var findKey = helperCreateIterateHandle('', 0, 2, true)
|
913 |
|
914 |
|
915 |
|
916 |
|
917 |
|
918 |
|
919 |
|
920 |
|
921 |
|
922 |
|
923 | function includes (obj, val) {
|
924 | if (obj) {
|
925 | if (obj.includes) {
|
926 | return obj.includes(val)
|
927 | }
|
928 | for (var key in obj) {
|
929 | if (hasOwnProp(obj, key)) {
|
930 | if (val === obj[key]) {
|
931 | return true
|
932 | }
|
933 | }
|
934 | }
|
935 | }
|
936 | return false
|
937 | }
|
938 |
|
939 |
|
940 | function arrayIndexOf (list, val) {
|
941 | if (list.indexOf) {
|
942 | return list.indexOf(val)
|
943 | }
|
944 | for (var index = 0, len = list.length; index < len; index++) {
|
945 | if (val === list[index]) {
|
946 | return index
|
947 | }
|
948 | }
|
949 | }
|
950 |
|
951 |
|
952 | function arrayLastIndexOf (list, val) {
|
953 | if (list.lastIndexOf) {
|
954 | return list.lastIndexOf(val)
|
955 | }
|
956 | for (var len = list.length - 1; len >= 0; len--) {
|
957 | if (val === list[len]) {
|
958 | return len
|
959 | }
|
960 | }
|
961 | return -1
|
962 | }
|
963 |
|
964 |
|
965 |
|
966 |
|
967 |
|
968 |
|
969 |
|
970 |
|
971 |
|
972 |
|
973 |
|
974 | function map (obj, iterate, context) {
|
975 | var result = []
|
976 | if (obj && arguments.length > 1) {
|
977 | if (obj.map) {
|
978 | return obj.map(iterate, context)
|
979 | } else {
|
980 | each(obj, function () {
|
981 | result.push(iterate.apply(context, arguments))
|
982 | })
|
983 | }
|
984 | }
|
985 | return result
|
986 | }
|
987 |
|
988 |
|
989 |
|
990 |
|
991 |
|
992 |
|
993 |
|
994 |
|
995 |
|
996 |
|
997 |
|
998 | function reduce (array, callback, initialValue) {
|
999 | if (array) {
|
1000 | var len, reduceMethod
|
1001 | var index = 0
|
1002 | var context = null
|
1003 | var previous = initialValue
|
1004 | var isInitialVal = arguments.length > 2
|
1005 | var keyList = keys(array)
|
1006 | if (array.length && array.reduce) {
|
1007 | reduceMethod = function () {
|
1008 | return callback.apply(context, arguments)
|
1009 | }
|
1010 | if (isInitialVal) {
|
1011 | return array.reduce(reduceMethod, previous)
|
1012 | }
|
1013 | return array.reduce(reduceMethod)
|
1014 | }
|
1015 | if (isInitialVal) {
|
1016 | index = 1
|
1017 | previous = array[keyList[0]]
|
1018 | }
|
1019 | for (len = keyList.length; index < len; index++) {
|
1020 | previous = callback.call(context, previous, array[keyList[index]], index, array)
|
1021 | }
|
1022 | return previous
|
1023 | }
|
1024 | }
|
1025 |
|
1026 |
|
1027 |
|
1028 |
|
1029 |
|
1030 |
|
1031 |
|
1032 |
|
1033 |
|
1034 |
|
1035 |
|
1036 |
|
1037 | function copyWithin (array, target, start, end) {
|
1038 | if (isArray(array) && array.copyWithin) {
|
1039 | return array.copyWithin(target, start, end)
|
1040 | }
|
1041 | var replaceIndex, replaceArray
|
1042 | var targetIndex = target >> 0
|
1043 | var startIndex = start >> 0
|
1044 | var len = array.length
|
1045 | var endIndex = arguments.length > 3 ? end >> 0 : len
|
1046 | if (targetIndex < len) {
|
1047 | targetIndex = targetIndex >= 0 ? targetIndex : len + targetIndex
|
1048 | if (targetIndex >= 0) {
|
1049 | startIndex = startIndex >= 0 ? startIndex : len + startIndex
|
1050 | endIndex = endIndex >= 0 ? endIndex : len + endIndex
|
1051 | if (startIndex < endIndex) {
|
1052 | for (replaceIndex = 0, replaceArray = array.slice(startIndex, endIndex); targetIndex < len; targetIndex++) {
|
1053 | if (replaceArray.length <= replaceIndex) {
|
1054 | break
|
1055 | }
|
1056 | array[targetIndex] = replaceArray[replaceIndex++]
|
1057 | }
|
1058 | }
|
1059 | }
|
1060 | }
|
1061 | return array
|
1062 | }
|
1063 |
|
1064 |
|
1065 |
|
1066 |
|
1067 |
|
1068 |
|
1069 |
|
1070 |
|
1071 |
|
1072 |
|
1073 | function chunk (array, size) {
|
1074 | var index
|
1075 | var result = []
|
1076 | var arrLen = size >> 0 || 1
|
1077 | if (isArray(array)) {
|
1078 | if (arrLen >= 0 && array.length > arrLen) {
|
1079 | index = 0
|
1080 | while (index < array.length) {
|
1081 | result.push(array.slice(index, index + arrLen))
|
1082 | index += arrLen
|
1083 | }
|
1084 | } else {
|
1085 | result = array.length ? [array] : array
|
1086 | }
|
1087 | }
|
1088 | return result
|
1089 | }
|
1090 |
|
1091 |
|
1092 |
|
1093 |
|
1094 |
|
1095 |
|
1096 |
|
1097 |
|
1098 | function zip () {
|
1099 | return unzip(arguments)
|
1100 | }
|
1101 |
|
1102 |
|
1103 |
|
1104 |
|
1105 |
|
1106 |
|
1107 |
|
1108 |
|
1109 |
|
1110 | function unzip (arrays) {
|
1111 | var index, maxItem, len
|
1112 | var result = []
|
1113 | if (arrays && arrays.length) {
|
1114 | index = 0
|
1115 | maxItem = max(arrays, function (item) {
|
1116 | return item ? item.length : 0
|
1117 | })
|
1118 | for (len = maxItem ? maxItem.length : 0; index < len; index++) {
|
1119 | result.push(pluck(arrays, index))
|
1120 | }
|
1121 | }
|
1122 | return result
|
1123 | }
|
1124 |
|
1125 |
|
1126 |
|
1127 |
|
1128 |
|
1129 |
|
1130 |
|
1131 |
|
1132 |
|
1133 |
|
1134 | function zipObject (props, arr) {
|
1135 | var result = {}
|
1136 | arr = arr || []
|
1137 | each(values(props), function (val, key) {
|
1138 | result[val] = arr[key]
|
1139 | })
|
1140 | return result
|
1141 | }
|
1142 |
|
1143 |
|
1144 |
|
1145 | function flattenDeep (array, deep) {
|
1146 | var result = []
|
1147 | arrayEach(array, function (vals) {
|
1148 | result = result.concat(isArray(vals) ? (deep ? flattenDeep(vals, deep) : vals) : [vals])
|
1149 | })
|
1150 | return result
|
1151 | }
|
1152 |
|
1153 |
|
1154 |
|
1155 |
|
1156 |
|
1157 |
|
1158 |
|
1159 | function flatten (array, deep) {
|
1160 | if (isArray(array)) {
|
1161 | return flattenDeep(array, deep)
|
1162 | }
|
1163 | return []
|
1164 | }
|
1165 |
|
1166 |
|
1167 |
|
1168 |
|
1169 |
|
1170 |
|
1171 |
|
1172 |
|
1173 |
|
1174 | function toArray (list) {
|
1175 | return map(list, function (item) {
|
1176 | return item
|
1177 | })
|
1178 | }
|
1179 |
|
1180 |
|
1181 |
|
1182 |
|
1183 |
|
1184 |
|
1185 |
|
1186 |
|
1187 |
|
1188 |
|
1189 | function includeArrays (array1, array2) {
|
1190 | var len
|
1191 | var index = 0
|
1192 | if (isArray(array1) && isArray(array2)) {
|
1193 | for (len = array2.length; index < len; index++) {
|
1194 | if (!includes(array1, array2[index])) {
|
1195 | return false
|
1196 | }
|
1197 | }
|
1198 | return true
|
1199 | }
|
1200 | return includes(array1, array2)
|
1201 | }
|
1202 |
|
1203 |
|
1204 |
|
1205 |
|
1206 |
|
1207 |
|
1208 |
|
1209 |
|
1210 |
|
1211 |
|
1212 | function pluck (obj, key) {
|
1213 | return map(obj, property(key))
|
1214 | }
|
1215 |
|
1216 |
|
1217 |
|
1218 |
|
1219 | function deepGetObj (obj, path) {
|
1220 | var index = 0
|
1221 | var len = path.length
|
1222 | while (obj && index < len) {
|
1223 | obj = obj[path[index++]]
|
1224 | }
|
1225 | return len && obj ? obj : 0
|
1226 | }
|
1227 |
|
1228 |
|
1229 |
|
1230 |
|
1231 |
|
1232 |
|
1233 |
|
1234 |
|
1235 |
|
1236 | function invoke (list, path) {
|
1237 | var func
|
1238 | var args = arguments
|
1239 | var params = []
|
1240 | var paths = []
|
1241 | var index = 2
|
1242 | var len = args.length
|
1243 | for (; index < len; index++) {
|
1244 | params.push(args[index])
|
1245 | }
|
1246 | if (isArray(path)) {
|
1247 | len = path.length - 1
|
1248 | for (index = 0; index < len; index++) {
|
1249 | paths.push(path[index])
|
1250 | }
|
1251 | path = path[len]
|
1252 | }
|
1253 | return map(list, function (context) {
|
1254 | if (paths.length) {
|
1255 | context = deepGetObj(context, paths)
|
1256 | }
|
1257 | func = context[path] || path
|
1258 | if (func && func.apply) {
|
1259 | return func.apply(context, params)
|
1260 | }
|
1261 | })
|
1262 | }
|
1263 |
|
1264 |
|
1265 | function arrayEach (list, iterate, context) {
|
1266 | if (list) {
|
1267 | if (list.forEach) {
|
1268 | list.forEach(iterate, context)
|
1269 | } else {
|
1270 | for (var index = 0, len = list.length; index < len; index++) {
|
1271 | iterate.call(context, list[index], index, list)
|
1272 | }
|
1273 | }
|
1274 | }
|
1275 | }
|
1276 |
|
1277 |
|
1278 | function lastArrayEach (obj, iterate, context) {
|
1279 | for (var len = obj.length - 1; len >= 0; len--) {
|
1280 | iterate.call(context, obj[len], len, obj)
|
1281 | }
|
1282 | }
|
1283 |
|
1284 |
|
1285 |
|
1286 |
|
1287 |
|
1288 |
|
1289 | function strictTree (array, optChildren) {
|
1290 | each(array, function (item) {
|
1291 | if (item.children && !item.children.length) {
|
1292 | remove(item, optChildren)
|
1293 | }
|
1294 | })
|
1295 | }
|
1296 |
|
1297 |
|
1298 |
|
1299 |
|
1300 |
|
1301 |
|
1302 |
|
1303 |
|
1304 | function toArrayTree (array, options) {
|
1305 | var opts = assign({}, setupDefaults.treeOptions, options)
|
1306 | var optStrict = opts.strict
|
1307 | var optKey = opts.key
|
1308 | var optParentKey = opts.parentKey
|
1309 | var optChildren = opts.children
|
1310 | var optMapChildren = opts.mapChildren
|
1311 | var optSortKey = opts.sortKey
|
1312 | var optReverse = opts.reverse
|
1313 | var optData = opts.data
|
1314 | var result = []
|
1315 | var treeMap = {}
|
1316 | var idList, id, treeData, parentId
|
1317 |
|
1318 | if (optSortKey) {
|
1319 | array = orderBy(clone(array), optSortKey)
|
1320 | if (optReverse) {
|
1321 | array = array.reverse()
|
1322 | }
|
1323 | }
|
1324 |
|
1325 | idList = map(array, function (item) {
|
1326 | return item[optKey]
|
1327 | })
|
1328 |
|
1329 | each(array, function (item) {
|
1330 | id = item[optKey]
|
1331 |
|
1332 | if (optData) {
|
1333 | treeData = {}
|
1334 | treeData[optData] = item
|
1335 | } else {
|
1336 | treeData = item
|
1337 | }
|
1338 |
|
1339 | parentId = item[optParentKey]
|
1340 | treeMap[id] = treeMap[id] || []
|
1341 | treeMap[parentId] = treeMap[parentId] || []
|
1342 | treeMap[parentId].push(treeData)
|
1343 | treeData[optKey] = id
|
1344 | treeData[optParentKey] = parentId
|
1345 | treeData[optChildren] = treeMap[id]
|
1346 | if (optMapChildren) {
|
1347 | treeData[optMapChildren] = treeMap[id]
|
1348 | }
|
1349 |
|
1350 | if (!optStrict || (optStrict && !parentId)) {
|
1351 | if (!includes(idList, parentId)) {
|
1352 | result.push(treeData)
|
1353 | }
|
1354 | }
|
1355 | })
|
1356 |
|
1357 | if (optStrict) {
|
1358 | strictTree(array, optChildren)
|
1359 | }
|
1360 |
|
1361 | return result
|
1362 | }
|
1363 |
|
1364 |
|
1365 |
|
1366 |
|
1367 |
|
1368 | function unTreeList (result, array, opts) {
|
1369 | var optChildren = opts.children
|
1370 | var optData = opts.data
|
1371 | var optClear = opts.clear
|
1372 | each(array, function (item) {
|
1373 | var children = item[optChildren]
|
1374 | if (optData) {
|
1375 | item = item[optData]
|
1376 | }
|
1377 | result.push(item)
|
1378 | if (children && children.length) {
|
1379 | unTreeList(result, children, opts)
|
1380 | }
|
1381 | if (optClear) {
|
1382 | delete item[optChildren]
|
1383 | }
|
1384 | })
|
1385 | return result
|
1386 | }
|
1387 |
|
1388 |
|
1389 |
|
1390 |
|
1391 |
|
1392 |
|
1393 |
|
1394 |
|
1395 | function toTreeArray (array, options) {
|
1396 | return unTreeList([], array, assign({}, setupDefaults.treeOptions, options))
|
1397 | }
|
1398 |
|
1399 |
|
1400 |
|
1401 | function findTreeItem (parent, obj, iterate, context, path, node, parseChildren, opts) {
|
1402 | if (obj) {
|
1403 | var item, index, len, paths, nodes, match
|
1404 | for (index = 0, len = obj.length; index < len; index++) {
|
1405 | item = obj[index]
|
1406 | paths = path.concat(['' + index])
|
1407 | nodes = node.concat([item])
|
1408 | if (iterate.call(context, item, index, obj, paths, parent, nodes)) {
|
1409 | return { index: index, item: item, path: paths, items: obj, parent: parent, nodes: nodes }
|
1410 | }
|
1411 | if (parseChildren && item) {
|
1412 | match = findTreeItem(item, item[parseChildren], iterate, context, paths.concat([parseChildren]), nodes, parseChildren, opts)
|
1413 | if (match) {
|
1414 | return match
|
1415 | }
|
1416 | }
|
1417 | }
|
1418 | }
|
1419 | }
|
1420 |
|
1421 |
|
1422 |
|
1423 |
|
1424 |
|
1425 |
|
1426 |
|
1427 |
|
1428 |
|
1429 |
|
1430 | var findTree = helperCreateTreeFunc(findTreeItem)
|
1431 |
|
1432 |
|
1433 |
|
1434 | function eachTreeItem (parent, obj, iterate, context, path, node, parseChildren, opts) {
|
1435 | var paths, nodes
|
1436 | each(obj, function (item, index) {
|
1437 | paths = path.concat(['' + index])
|
1438 | nodes = node.concat([item])
|
1439 | iterate.call(context, item, index, obj, paths, parent, nodes)
|
1440 | if (item && parseChildren) {
|
1441 | paths.push(parseChildren)
|
1442 | eachTreeItem(item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts)
|
1443 | }
|
1444 | })
|
1445 | }
|
1446 |
|
1447 |
|
1448 |
|
1449 |
|
1450 |
|
1451 |
|
1452 |
|
1453 |
|
1454 |
|
1455 | var eachTree = helperCreateTreeFunc(eachTreeItem)
|
1456 |
|
1457 |
|
1458 |
|
1459 |
|
1460 | function mapTreeItem (parent, obj, iterate, context, path, node, parseChildren, opts) {
|
1461 | var paths, nodes, rest
|
1462 | var mapChildren = opts.mapChildren || parseChildren
|
1463 | return map(obj, function (item, index) {
|
1464 | paths = path.concat(['' + index])
|
1465 | nodes = node.concat([item])
|
1466 | rest = iterate.call(context, item, index, obj, paths, parent, nodes)
|
1467 | if (rest && item && parseChildren && item[parseChildren]) {
|
1468 | rest[mapChildren] = mapTreeItem(item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts)
|
1469 | }
|
1470 | return rest
|
1471 | })
|
1472 | }
|
1473 |
|
1474 |
|
1475 |
|
1476 |
|
1477 |
|
1478 |
|
1479 |
|
1480 |
|
1481 |
|
1482 |
|
1483 | var mapTree = helperCreateTreeFunc(mapTreeItem)
|
1484 |
|
1485 |
|
1486 |
|
1487 |
|
1488 |
|
1489 |
|
1490 |
|
1491 |
|
1492 |
|
1493 |
|
1494 |
|
1495 |
|
1496 | function filterTree (obj, iterate, options, context) {
|
1497 | var result = []
|
1498 | if (obj && iterate) {
|
1499 | eachTree(obj, function (item, index, items, path, parent, nodes) {
|
1500 | if (iterate.call(context, item, index, items, path, parent, nodes)) {
|
1501 | result.push(item)
|
1502 | }
|
1503 | }, options)
|
1504 | }
|
1505 | return result
|
1506 | }
|
1507 |
|
1508 |
|
1509 |
|
1510 |
|
1511 |
|
1512 | function searchTreeItem (parentAllow, parent, obj, iterate, context, path, node, parseChildren, opts) {
|
1513 | var paths, nodes, rest, isAllow, hasChild
|
1514 | var rests = []
|
1515 | var hasOriginal = opts.original
|
1516 | var sourceData = opts.data
|
1517 | var mapChildren = opts.mapChildren || parseChildren
|
1518 | arrayEach(obj, function (item, index) {
|
1519 | paths = path.concat(['' + index])
|
1520 | nodes = node.concat([item])
|
1521 | isAllow = parentAllow || iterate.call(context, item, index, obj, paths, parent, nodes)
|
1522 | hasChild = parseChildren && item[parseChildren]
|
1523 | if (isAllow || hasChild) {
|
1524 | if (hasOriginal) {
|
1525 | rest = item
|
1526 | } else {
|
1527 | rest = assign({}, item)
|
1528 | if (sourceData) {
|
1529 | rest[sourceData] = item
|
1530 | }
|
1531 | }
|
1532 | rest[mapChildren] = searchTreeItem(isAllow, item, item[parseChildren], iterate, context, paths, nodes, parseChildren, opts)
|
1533 | if (isAllow || rest[mapChildren].length) {
|
1534 | rests.push(rest)
|
1535 | }
|
1536 | } else if (isAllow) {
|
1537 | rests.push(rest)
|
1538 | }
|
1539 | })
|
1540 | return rests
|
1541 | }
|
1542 |
|
1543 |
|
1544 |
|
1545 |
|
1546 |
|
1547 |
|
1548 |
|
1549 |
|
1550 |
|
1551 |
|
1552 | var searchTree = helperCreateTreeFunc(function (parent, obj, iterate, context, path, nodes, parseChildren, opts) {
|
1553 | return searchTreeItem(0, parent, obj, iterate, context, path, nodes, parseChildren, opts)
|
1554 | })
|
1555 |
|
1556 |
|
1557 |
|
1558 |
|
1559 |
|
1560 |
|
1561 |
|
1562 |
|
1563 |
|
1564 | function hasOwnProp (obj, key) {
|
1565 | return obj && obj.hasOwnProperty ? obj.hasOwnProperty(key) : false
|
1566 | }
|
1567 |
|
1568 |
|
1569 |
|
1570 |
|
1571 |
|
1572 |
|
1573 |
|
1574 |
|
1575 | function eqNull (obj) {
|
1576 | return isNull(obj) || isUndefined(obj)
|
1577 | }
|
1578 |
|
1579 |
|
1580 |
|
1581 |
|
1582 | function isNumberNaN (obj) {
|
1583 | return isNumber(obj) && isNaN(obj)
|
1584 | }
|
1585 |
|
1586 |
|
1587 |
|
1588 | function isNumberFinite (obj) {
|
1589 | return isNumber(obj) && isFinite(obj)
|
1590 | }
|
1591 |
|
1592 |
|
1593 |
|
1594 |
|
1595 |
|
1596 |
|
1597 |
|
1598 |
|
1599 |
|
1600 |
|
1601 | var isUndefined = helperCreateInTypeof(staticStrUndefined)
|
1602 |
|
1603 |
|
1604 |
|
1605 |
|
1606 |
|
1607 |
|
1608 |
|
1609 |
|
1610 |
|
1611 | var isArray = Array.isArray || helperCreateInInObjectString('Array')
|
1612 |
|
1613 |
|
1614 |
|
1615 |
|
1616 |
|
1617 |
|
1618 |
|
1619 |
|
1620 |
|
1621 | function isFloat (obj) {
|
1622 | return !isNull(obj) && !isNaN(obj) && !isArray(obj) && !isInteger(obj)
|
1623 | }
|
1624 |
|
1625 |
|
1626 |
|
1627 |
|
1628 |
|
1629 |
|
1630 |
|
1631 |
|
1632 |
|
1633 | var isInteger = function (obj) {
|
1634 | return !isNull(obj) && !isNaN(obj) && !isArray(obj) && obj % 1 === 0
|
1635 | }
|
1636 |
|
1637 |
|
1638 |
|
1639 |
|
1640 |
|
1641 |
|
1642 |
|
1643 |
|
1644 |
|
1645 | var isFunction = helperCreateInTypeof('function')
|
1646 |
|
1647 |
|
1648 |
|
1649 |
|
1650 |
|
1651 |
|
1652 |
|
1653 |
|
1654 |
|
1655 | var isBoolean = helperCreateInTypeof('boolean')
|
1656 |
|
1657 |
|
1658 |
|
1659 |
|
1660 |
|
1661 |
|
1662 |
|
1663 |
|
1664 |
|
1665 | var isString = helperCreateInTypeof('string')
|
1666 |
|
1667 |
|
1668 |
|
1669 |
|
1670 |
|
1671 |
|
1672 |
|
1673 |
|
1674 |
|
1675 | var isNumber = helperCreateInTypeof('number')
|
1676 |
|
1677 |
|
1678 |
|
1679 |
|
1680 |
|
1681 |
|
1682 |
|
1683 |
|
1684 |
|
1685 | var isRegExp = helperCreateInInObjectString('RegExp')
|
1686 |
|
1687 |
|
1688 |
|
1689 |
|
1690 |
|
1691 |
|
1692 |
|
1693 |
|
1694 |
|
1695 | var isObject = helperCreateInTypeof('object')
|
1696 |
|
1697 |
|
1698 |
|
1699 |
|
1700 |
|
1701 |
|
1702 |
|
1703 |
|
1704 | function isPlainObject (obj) {
|
1705 | return obj ? obj.constructor === Object : false
|
1706 | }
|
1707 |
|
1708 |
|
1709 |
|
1710 |
|
1711 |
|
1712 |
|
1713 |
|
1714 |
|
1715 |
|
1716 | var isDate = helperCreateInInObjectString('Date')
|
1717 |
|
1718 |
|
1719 |
|
1720 |
|
1721 |
|
1722 |
|
1723 |
|
1724 |
|
1725 |
|
1726 | var isError = helperCreateInInObjectString('Error')
|
1727 |
|
1728 |
|
1729 |
|
1730 |
|
1731 |
|
1732 |
|
1733 |
|
1734 |
|
1735 | function isTypeError (obj) {
|
1736 | return obj ? obj.constructor === TypeError : false
|
1737 | }
|
1738 |
|
1739 |
|
1740 |
|
1741 |
|
1742 |
|
1743 |
|
1744 |
|
1745 |
|
1746 | function isEmpty (obj) {
|
1747 | for (var key in obj) {
|
1748 | return false
|
1749 | }
|
1750 | return true
|
1751 | }
|
1752 |
|
1753 |
|
1754 |
|
1755 |
|
1756 |
|
1757 |
|
1758 |
|
1759 |
|
1760 | function isNull (obj) {
|
1761 | return obj === null
|
1762 | }
|
1763 |
|
1764 |
|
1765 |
|
1766 |
|
1767 |
|
1768 |
|
1769 |
|
1770 |
|
1771 |
|
1772 |
|
1773 | var supportSymbol = typeof Symbol !== staticStrUndefined
|
1774 | function isSymbol (obj) {
|
1775 | return supportSymbol && Symbol.isSymbol ? Symbol.isSymbol(obj) : (typeof obj === 'symbol')
|
1776 | }
|
1777 |
|
1778 |
|
1779 |
|
1780 |
|
1781 |
|
1782 |
|
1783 |
|
1784 |
|
1785 |
|
1786 | var isArguments = helperCreateInInObjectString('Arguments')
|
1787 |
|
1788 |
|
1789 |
|
1790 |
|
1791 |
|
1792 |
|
1793 |
|
1794 |
|
1795 |
|
1796 | function isElement (obj) {
|
1797 | return !!(obj && isString(obj.nodeName) && isNumber(obj.nodeType))
|
1798 | }
|
1799 |
|
1800 |
|
1801 |
|
1802 |
|
1803 |
|
1804 |
|
1805 |
|
1806 |
|
1807 |
|
1808 | function isDocument (obj) {
|
1809 | return !!(obj && staticDocument && obj.nodeType === 9)
|
1810 | }
|
1811 |
|
1812 |
|
1813 |
|
1814 |
|
1815 |
|
1816 |
|
1817 |
|
1818 |
|
1819 |
|
1820 | function isWindow (obj) {
|
1821 | return staticWindow && !!(obj && obj === obj.window)
|
1822 | }
|
1823 |
|
1824 |
|
1825 |
|
1826 |
|
1827 |
|
1828 |
|
1829 |
|
1830 |
|
1831 |
|
1832 |
|
1833 | var supportFormData = typeof FormData !== staticStrUndefined
|
1834 | function isFormData (obj) {
|
1835 | return supportFormData && obj instanceof FormData
|
1836 | }
|
1837 |
|
1838 |
|
1839 |
|
1840 |
|
1841 |
|
1842 |
|
1843 |
|
1844 |
|
1845 |
|
1846 |
|
1847 | var supportMap = typeof Map !== staticStrUndefined
|
1848 | function isMap (obj) {
|
1849 | return supportMap && obj instanceof Map
|
1850 | }
|
1851 |
|
1852 |
|
1853 |
|
1854 |
|
1855 |
|
1856 |
|
1857 |
|
1858 |
|
1859 |
|
1860 |
|
1861 | var supportWeakMap = typeof WeakMap !== staticStrUndefined
|
1862 | function isWeakMap (obj) {
|
1863 | return supportWeakMap && obj instanceof WeakMap
|
1864 | }
|
1865 |
|
1866 |
|
1867 |
|
1868 |
|
1869 |
|
1870 |
|
1871 |
|
1872 |
|
1873 |
|
1874 |
|
1875 | var supportSet = typeof Set !== staticStrUndefined
|
1876 | function isSet (obj) {
|
1877 | return supportSet && obj instanceof Set
|
1878 | }
|
1879 |
|
1880 |
|
1881 |
|
1882 |
|
1883 |
|
1884 |
|
1885 |
|
1886 |
|
1887 |
|
1888 |
|
1889 | var supportWeakSet = typeof WeakSet !== staticStrUndefined
|
1890 | function isWeakSet (obj) {
|
1891 | return supportWeakSet && obj instanceof WeakSet
|
1892 | }
|
1893 |
|
1894 |
|
1895 |
|
1896 |
|
1897 |
|
1898 |
|
1899 |
|
1900 |
|
1901 |
|
1902 |
|
1903 | function isLeapYear (date) {
|
1904 | var year
|
1905 | var currentDate = date ? toStringDate(date) : helperNewDate()
|
1906 | if (isDate(currentDate)) {
|
1907 | year = currentDate.getFullYear()
|
1908 | return (year % 4 === 0) && (year % 100 !== 0 || year % 400 === 0)
|
1909 | }
|
1910 | return false
|
1911 | }
|
1912 |
|
1913 |
|
1914 |
|
1915 |
|
1916 |
|
1917 |
|
1918 |
|
1919 |
|
1920 |
|
1921 |
|
1922 |
|
1923 | function isMatch (obj, source) {
|
1924 | var objKeys = keys(obj)
|
1925 | var sourceKeys = keys(source)
|
1926 | if (sourceKeys.length) {
|
1927 | if (includeArrays(objKeys, sourceKeys)) {
|
1928 | return some(sourceKeys, function (key2) {
|
1929 | return findIndexOf(objKeys, function (key1) {
|
1930 | return key1 === key2 && isEqual(obj[key1], source[key2])
|
1931 | }) > -1
|
1932 | })
|
1933 | }
|
1934 | } else {
|
1935 | return true
|
1936 | }
|
1937 | return isEqual(obj, source)
|
1938 | }
|
1939 |
|
1940 |
|
1941 |
|
1942 |
|
1943 |
|
1944 |
|
1945 |
|
1946 |
|
1947 |
|
1948 |
|
1949 | function isEqual (obj1, obj2) {
|
1950 | return helperEqualCompare(obj1, obj2, helperDefaultCompare)
|
1951 | }
|
1952 |
|
1953 |
|
1954 |
|
1955 |
|
1956 |
|
1957 |
|
1958 |
|
1959 |
|
1960 |
|
1961 |
|
1962 |
|
1963 |
|
1964 | function isEqualWith (obj1, obj2, func) {
|
1965 | if (isFunction(func)) {
|
1966 | return helperEqualCompare(obj1, obj2, function (v1, v2, key, obj1, obj2) {
|
1967 | var result = func(v1, v2, key, obj1, obj2)
|
1968 | return isUndefined(result) ? helperDefaultCompare(v1, v2) : !!result
|
1969 | }, func)
|
1970 | }
|
1971 | return helperEqualCompare(obj1, obj2, helperDefaultCompare)
|
1972 | }
|
1973 |
|
1974 |
|
1975 |
|
1976 |
|
1977 |
|
1978 |
|
1979 |
|
1980 |
|
1981 |
|
1982 | function getType (obj) {
|
1983 | if (isNull(obj)) {
|
1984 | return 'null'
|
1985 | }
|
1986 | if (isSymbol(obj)) {
|
1987 | return 'symbol'
|
1988 | }
|
1989 | if (isDate(obj)) {
|
1990 | return 'date'
|
1991 | }
|
1992 | if (isArray(obj)) {
|
1993 | return 'array'
|
1994 | }
|
1995 | if (isRegExp(obj)) {
|
1996 | return 'regexp'
|
1997 | }
|
1998 | if (isError(obj)) {
|
1999 | return 'error'
|
2000 | }
|
2001 | return typeof obj
|
2002 | }
|
2003 |
|
2004 |
|
2005 |
|
2006 |
|
2007 |
|
2008 |
|
2009 |
|
2010 |
|
2011 | var __uniqueId = 0
|
2012 | function uniqueId (prefix) {
|
2013 | return [prefix, ++__uniqueId].join('')
|
2014 | }
|
2015 |
|
2016 |
|
2017 |
|
2018 |
|
2019 |
|
2020 |
|
2021 |
|
2022 |
|
2023 |
|
2024 | function getSize (obj) {
|
2025 | var len = 0
|
2026 | if (isString(obj) || isArray(obj)) {
|
2027 | return obj.length
|
2028 | }
|
2029 | each(obj, function () {
|
2030 | len++
|
2031 | })
|
2032 | return len
|
2033 | }
|
2034 |
|
2035 |
|
2036 |
|
2037 |
|
2038 |
|
2039 |
|
2040 |
|
2041 |
|
2042 |
|
2043 |
|
2044 |
|
2045 | var indexOf = helperCreateIndexOf('indexOf', arrayIndexOf)
|
2046 |
|
2047 |
|
2048 |
|
2049 |
|
2050 |
|
2051 |
|
2052 |
|
2053 |
|
2054 |
|
2055 |
|
2056 |
|
2057 | var lastIndexOf = helperCreateIndexOf('lastIndexOf', arrayLastIndexOf)
|
2058 |
|
2059 |
|
2060 |
|
2061 |
|
2062 |
|
2063 |
|
2064 |
|
2065 |
|
2066 |
|
2067 |
|
2068 |
|
2069 | var findIndexOf = helperCreateiterateIndexOf(function (obj, iterate, context) {
|
2070 | for (var index = 0, len = obj.length; index < len; index++) {
|
2071 | if (iterate.call(context, obj[index], index, obj)) {
|
2072 | return index
|
2073 | }
|
2074 | }
|
2075 | return -1
|
2076 | })
|
2077 |
|
2078 |
|
2079 |
|
2080 |
|
2081 |
|
2082 |
|
2083 |
|
2084 |
|
2085 |
|
2086 |
|
2087 |
|
2088 | var findLastIndexOf = helperCreateiterateIndexOf(function (obj, iterate, context) {
|
2089 | for (var len = obj.length - 1; len >= 0; len--) {
|
2090 | if (iterate.call(context, obj[len], len, obj)) {
|
2091 | return len
|
2092 | }
|
2093 | }
|
2094 | return -1
|
2095 | })
|
2096 |
|
2097 |
|
2098 |
|
2099 |
|
2100 |
|
2101 |
|
2102 |
|
2103 |
|
2104 |
|
2105 | function toStringJSON (str) {
|
2106 | if (isPlainObject(str)) {
|
2107 | return str
|
2108 | } else if (isString(str)) {
|
2109 | try {
|
2110 | return JSON.parse(str)
|
2111 | } catch (e) {}
|
2112 | }
|
2113 | return {}
|
2114 | }
|
2115 |
|
2116 |
|
2117 |
|
2118 |
|
2119 |
|
2120 |
|
2121 |
|
2122 |
|
2123 |
|
2124 | function toJSONString (obj) {
|
2125 | return eqNull(obj) ? '' : JSON.stringify(obj)
|
2126 | }
|
2127 |
|
2128 |
|
2129 |
|
2130 |
|
2131 |
|
2132 |
|
2133 |
|
2134 |
|
2135 |
|
2136 | var keys = helperCreateGetObjects('keys', 1)
|
2137 |
|
2138 |
|
2139 |
|
2140 |
|
2141 |
|
2142 |
|
2143 |
|
2144 |
|
2145 |
|
2146 | var values = helperCreateGetObjects('values', 0)
|
2147 |
|
2148 |
|
2149 |
|
2150 |
|
2151 |
|
2152 |
|
2153 |
|
2154 |
|
2155 |
|
2156 | var entries = helperCreateGetObjects('entries', 2)
|
2157 |
|
2158 |
|
2159 |
|
2160 |
|
2161 |
|
2162 |
|
2163 |
|
2164 |
|
2165 |
|
2166 |
|
2167 | var pick = helperCreatePickOmit(1, 0)
|
2168 |
|
2169 |
|
2170 |
|
2171 |
|
2172 |
|
2173 |
|
2174 |
|
2175 |
|
2176 |
|
2177 |
|
2178 | var omit = helperCreatePickOmit(0, 1)
|
2179 |
|
2180 |
|
2181 |
|
2182 |
|
2183 |
|
2184 |
|
2185 |
|
2186 |
|
2187 |
|
2188 | function first (obj) {
|
2189 | return values(obj)[0]
|
2190 | }
|
2191 |
|
2192 |
|
2193 |
|
2194 |
|
2195 |
|
2196 |
|
2197 |
|
2198 |
|
2199 |
|
2200 | function last (obj) {
|
2201 | var list = values(obj)
|
2202 | return list[list.length - 1]
|
2203 | }
|
2204 |
|
2205 |
|
2206 |
|
2207 |
|
2208 |
|
2209 |
|
2210 |
|
2211 |
|
2212 |
|
2213 |
|
2214 |
|
2215 | function each (obj, iterate, context) {
|
2216 | if (obj) {
|
2217 | return (isArray(obj) ? arrayEach : objectEach)(obj, iterate, context)
|
2218 | }
|
2219 | return obj
|
2220 | }
|
2221 |
|
2222 |
|
2223 |
|
2224 |
|
2225 |
|
2226 |
|
2227 |
|
2228 | function forOf (obj, iterate, context) {
|
2229 | if (obj) {
|
2230 | if (isArray(obj)) {
|
2231 | for (var index = 0, len = obj.length; index < len; index++) {
|
2232 | if (iterate.call(context, obj[index], index, obj) === false) {
|
2233 | break
|
2234 | }
|
2235 | }
|
2236 | } else {
|
2237 | for (var key in obj) {
|
2238 | if (hasOwnProp(obj, key)) {
|
2239 | if (iterate.call(context, obj[key], key, obj) === false) {
|
2240 | break
|
2241 | }
|
2242 | }
|
2243 | }
|
2244 | }
|
2245 | }
|
2246 | }
|
2247 |
|
2248 |
|
2249 |
|
2250 |
|
2251 |
|
2252 |
|
2253 |
|
2254 | function lastForOf (obj, iterate, context) {
|
2255 | if (obj) {
|
2256 | var len, list
|
2257 | if (isArray(obj)) {
|
2258 | for (len = obj.length - 1; len >= 0; len--) {
|
2259 | if (iterate.call(context, obj[len], len, obj) === false) {
|
2260 | break
|
2261 | }
|
2262 | }
|
2263 | } else {
|
2264 | list = keys(obj)
|
2265 | for (len = list.length - 1; len >= 0; len--) {
|
2266 | if (iterate.call(context, obj[list[len]], list[len], obj) === false) {
|
2267 | break
|
2268 | }
|
2269 | }
|
2270 | }
|
2271 | }
|
2272 | }
|
2273 |
|
2274 |
|
2275 |
|
2276 |
|
2277 |
|
2278 |
|
2279 |
|
2280 |
|
2281 |
|
2282 |
|
2283 |
|
2284 | function lastEach (obj, iterate, context) {
|
2285 | if (obj) {
|
2286 | return (isArray(obj) ? lastArrayEach : lastObjectEach)(obj, iterate, context)
|
2287 | }
|
2288 | return obj
|
2289 | }
|
2290 |
|
2291 |
|
2292 |
|
2293 |
|
2294 |
|
2295 |
|
2296 |
|
2297 |
|
2298 |
|
2299 |
|
2300 |
|
2301 |
|
2302 | function has (obj, property) {
|
2303 | if (obj) {
|
2304 | if (hasOwnProp(obj, property)) {
|
2305 | return true
|
2306 | } else {
|
2307 | var prop, arrIndex, objProp, matchs, rest, isHas
|
2308 | var props = helperGetHGSKeys(property)
|
2309 | var index = 0
|
2310 | var len = props.length
|
2311 | for (rest = obj; index < len; index++) {
|
2312 | isHas = false
|
2313 | prop = props[index]
|
2314 | matchs = prop ? prop.match(staticHGKeyRE) : ''
|
2315 | if (matchs) {
|
2316 | arrIndex = matchs[1]
|
2317 | objProp = matchs[2]
|
2318 | if (arrIndex) {
|
2319 | if (rest[arrIndex]) {
|
2320 | if (hasOwnProp(rest[arrIndex], objProp)) {
|
2321 | isHas = true
|
2322 | rest = rest[arrIndex][objProp]
|
2323 | }
|
2324 | }
|
2325 | } else {
|
2326 | if (hasOwnProp(rest, objProp)) {
|
2327 | isHas = true
|
2328 | rest = rest[objProp]
|
2329 | }
|
2330 | }
|
2331 | } else {
|
2332 | if (hasOwnProp(rest, prop)) {
|
2333 | isHas = true
|
2334 | rest = rest[prop]
|
2335 | }
|
2336 | }
|
2337 | if (isHas) {
|
2338 | if (index === len - 1) {
|
2339 | return true
|
2340 | }
|
2341 | } else {
|
2342 | break
|
2343 | }
|
2344 | }
|
2345 | }
|
2346 | }
|
2347 | return false
|
2348 | }
|
2349 |
|
2350 |
|
2351 |
|
2352 |
|
2353 |
|
2354 |
|
2355 |
|
2356 |
|
2357 |
|
2358 |
|
2359 |
|
2360 | function get (obj, property, defaultValue) {
|
2361 | if (eqNull(obj)) {
|
2362 | return defaultValue
|
2363 | }
|
2364 | var result = getValueByPath(obj, property)
|
2365 | return isUndefined(result) ? defaultValue : result
|
2366 | }
|
2367 |
|
2368 | function getDeepProps (obj, key) {
|
2369 | var matchs = key ? key.match(staticHGKeyRE) : ''
|
2370 | return matchs ? (matchs[1] ? (obj[matchs[1]] ? obj[matchs[1]][matchs[2]] : undefined) : obj[matchs[2]]) : obj[key]
|
2371 | }
|
2372 |
|
2373 | function getValueByPath (obj, property) {
|
2374 | if (obj) {
|
2375 | var rest, props, len
|
2376 | var index = 0
|
2377 | if (obj[property] || hasOwnProp(obj, property)) {
|
2378 | return obj[property]
|
2379 | } else {
|
2380 | props = helperGetHGSKeys(property)
|
2381 | len = props.length
|
2382 | if (len) {
|
2383 | for (rest = obj; index < len; index++) {
|
2384 | rest = getDeepProps(rest, props[index])
|
2385 | if (eqNull(rest)) {
|
2386 | if (index === len - 1) {
|
2387 | return rest
|
2388 | }
|
2389 | return
|
2390 | }
|
2391 | }
|
2392 | }
|
2393 | return rest
|
2394 | }
|
2395 | }
|
2396 | }
|
2397 |
|
2398 |
|
2399 |
|
2400 |
|
2401 |
|
2402 | var sKeyRE = /(.+)?\[(\d+)\]$/
|
2403 |
|
2404 | function setDeepProps (obj, key, isEnd, nextKey, value) {
|
2405 | if (obj[key]) {
|
2406 | if (isEnd) {
|
2407 | obj[key] = value
|
2408 | }
|
2409 | } else {
|
2410 | var index
|
2411 | var rest
|
2412 | var currMatchs = key ? key.match(sKeyRE) : null
|
2413 | if (isEnd) {
|
2414 | rest = value
|
2415 | } else {
|
2416 | var nextMatchs = nextKey ? nextKey.match(sKeyRE) : null
|
2417 | rest = nextMatchs && !nextMatchs[1] ? new Array(staticParseInt(nextMatchs[2]) + 1) : {}
|
2418 | }
|
2419 | if (currMatchs) {
|
2420 | if (currMatchs[1]) {
|
2421 |
|
2422 | index = staticParseInt(currMatchs[2])
|
2423 | if (obj[currMatchs[1]]) {
|
2424 | obj[currMatchs[1]][index] = rest
|
2425 | } else {
|
2426 | obj[currMatchs[1]] = new Array(index + 1)
|
2427 | obj[currMatchs[1]][index] = rest
|
2428 | }
|
2429 | } else {
|
2430 |
|
2431 | obj[currMatchs[2]] = rest
|
2432 | }
|
2433 | } else {
|
2434 |
|
2435 | obj[key] = rest
|
2436 | }
|
2437 | return rest
|
2438 | }
|
2439 | return obj[key]
|
2440 | }
|
2441 |
|
2442 |
|
2443 |
|
2444 |
|
2445 |
|
2446 |
|
2447 |
|
2448 | function set (obj, property, value) {
|
2449 | if (obj) {
|
2450 | if ((obj[property] || hasOwnProp(obj, property)) && !isPrototypePolluted(property)) {
|
2451 | obj[property] = value
|
2452 | } else {
|
2453 | var rest = obj
|
2454 | var props = helperGetHGSKeys(property)
|
2455 | var len = props.length
|
2456 | for (var index = 0; index < len; index++) {
|
2457 | if (isPrototypePolluted(props[index])) {
|
2458 | continue
|
2459 | }
|
2460 | var isEnd = index === len - 1
|
2461 | rest = setDeepProps(rest, props[index], isEnd, isEnd ? null : props[index + 1], value)
|
2462 | }
|
2463 | }
|
2464 | }
|
2465 | return obj
|
2466 | }
|
2467 |
|
2468 |
|
2469 |
|
2470 |
|
2471 |
|
2472 | function isPrototypePolluted(key) {
|
2473 | return key === '__proto__' || key === 'constructor' || key === 'prototype'
|
2474 | }
|
2475 |
|
2476 |
|
2477 |
|
2478 | function createiterateEmpty (iterate) {
|
2479 | return function () {
|
2480 | return isEmpty(iterate)
|
2481 | }
|
2482 | }
|
2483 |
|
2484 |
|
2485 |
|
2486 |
|
2487 |
|
2488 |
|
2489 |
|
2490 |
|
2491 |
|
2492 | function groupBy (obj, iterate, context) {
|
2493 | var groupKey
|
2494 | var result = {}
|
2495 | if (obj) {
|
2496 | if (iterate && isObject(iterate)) {
|
2497 | iterate = createiterateEmpty(iterate)
|
2498 | } else if (!isFunction(iterate)) {
|
2499 | iterate = property(iterate)
|
2500 | }
|
2501 | each(obj, function (val, key) {
|
2502 | groupKey = iterate ? iterate.call(context, val, key, obj) : val
|
2503 | if (result[groupKey]) {
|
2504 | result[groupKey].push(val)
|
2505 | } else {
|
2506 | result[groupKey] = [val]
|
2507 | }
|
2508 | })
|
2509 | }
|
2510 | return result
|
2511 | }
|
2512 |
|
2513 |
|
2514 |
|
2515 |
|
2516 |
|
2517 |
|
2518 |
|
2519 |
|
2520 |
|
2521 |
|
2522 |
|
2523 |
|
2524 | function countBy (obj, iterate, context) {
|
2525 | var result = groupBy(obj, iterate, context || this)
|
2526 | objectEach(result, function (item, key) {
|
2527 | result[key] = item.length
|
2528 | })
|
2529 | return result
|
2530 | }
|
2531 |
|
2532 |
|
2533 |
|
2534 |
|
2535 | function getCtorObject (val, args) {
|
2536 | var Ctor = val.__proto__.constructor
|
2537 | return args ? new Ctor(args) : new Ctor()
|
2538 | }
|
2539 |
|
2540 | function handleValueClone (item, isDeep) {
|
2541 | return isDeep ? copyValue(item, isDeep) : item
|
2542 | }
|
2543 |
|
2544 | function copyValue (val, isDeep) {
|
2545 | if (val) {
|
2546 | switch(objectToString.call(val)) {
|
2547 | case "[object Object]":
|
2548 | case "[object Arguments]": {
|
2549 | var restObj = getCtorObject(val)
|
2550 | objectEach(val, function (item, key) {
|
2551 | restObj[key] = handleValueClone(item, isDeep)
|
2552 | })
|
2553 | return restObj
|
2554 | }
|
2555 | case "[object Date]":
|
2556 | case "[object RegExp]": {
|
2557 | return getCtorObject(val, val.valueOf())
|
2558 | }
|
2559 | case "[object Array]": {
|
2560 | var restArr = []
|
2561 | arrayEach(val, function (item) {
|
2562 | restArr.push(handleValueClone(item, isDeep))
|
2563 | })
|
2564 | return restArr
|
2565 | }
|
2566 | case "[object Set]": {
|
2567 | var restSet = getCtorObject(val)
|
2568 | restSet.forEach(function (item) {
|
2569 | restSet.add(handleValueClone(item, isDeep))
|
2570 | })
|
2571 | return restSet
|
2572 | }
|
2573 | case "[object Map]": {
|
2574 | var restMap = getCtorObject(val)
|
2575 | restMap.forEach(function (item, key) {
|
2576 | restMap.set(handleValueClone(item, isDeep))
|
2577 | })
|
2578 | return restMap
|
2579 | }
|
2580 | }
|
2581 | }
|
2582 | return val
|
2583 | }
|
2584 |
|
2585 |
|
2586 |
|
2587 |
|
2588 |
|
2589 |
|
2590 |
|
2591 |
|
2592 | function clone (obj, deep) {
|
2593 | if (obj) {
|
2594 | return copyValue(obj, deep)
|
2595 | }
|
2596 | return obj
|
2597 | }
|
2598 |
|
2599 |
|
2600 |
|
2601 |
|
2602 |
|
2603 |
|
2604 |
|
2605 |
|
2606 |
|
2607 |
|
2608 |
|
2609 |
|
2610 | function clear (obj, defs, assigns) {
|
2611 | if (obj) {
|
2612 | var len
|
2613 | var isDefs = arguments.length > 1 && (isNull(defs) || !isObject(defs))
|
2614 | var extds = isDefs ? assigns : defs
|
2615 | if (isPlainObject(obj)) {
|
2616 | objectEach(obj, isDefs ? function (val, key) {
|
2617 | obj[key] = defs
|
2618 | } : function (val, key) {
|
2619 | helperDeleteProperty(obj, key)
|
2620 | })
|
2621 | if (extds) {
|
2622 | assign(obj, extds)
|
2623 | }
|
2624 | } else if (isArray(obj)) {
|
2625 | if (isDefs) {
|
2626 | len = obj.length
|
2627 | while (len > 0) {
|
2628 | len--
|
2629 | obj[len] = defs
|
2630 | }
|
2631 | } else {
|
2632 | obj.length = 0
|
2633 | }
|
2634 | if (extds) {
|
2635 | obj.push.apply(obj, extds)
|
2636 | }
|
2637 | }
|
2638 | }
|
2639 | return obj
|
2640 | }
|
2641 |
|
2642 |
|
2643 |
|
2644 |
|
2645 | function pluckProperty (name) {
|
2646 | return function (obj, key) {
|
2647 | return key === name
|
2648 | }
|
2649 | }
|
2650 |
|
2651 |
|
2652 |
|
2653 |
|
2654 |
|
2655 |
|
2656 |
|
2657 |
|
2658 |
|
2659 | function remove (obj, iterate, context) {
|
2660 | if (obj) {
|
2661 | if (!eqNull(iterate)) {
|
2662 | var removeKeys = []
|
2663 | var rest = []
|
2664 | if (!isFunction(iterate)) {
|
2665 | iterate = pluckProperty(iterate)
|
2666 | }
|
2667 | each(obj, function (item, index, rest) {
|
2668 | if (iterate.call(context, item, index, rest)) {
|
2669 | removeKeys.push(index)
|
2670 | }
|
2671 | })
|
2672 | if (isArray(obj)) {
|
2673 | lastEach(removeKeys, function (item, key) {
|
2674 | rest.push(obj[item])
|
2675 | obj.splice(item, 1)
|
2676 | })
|
2677 | } else {
|
2678 | rest = {}
|
2679 | arrayEach(removeKeys, function (key) {
|
2680 | rest[key] = obj[key]
|
2681 | helperDeleteProperty(obj, key)
|
2682 | })
|
2683 | }
|
2684 | return rest
|
2685 | }
|
2686 | return clear(obj)
|
2687 | }
|
2688 | return obj
|
2689 | }
|
2690 |
|
2691 |
|
2692 |
|
2693 |
|
2694 |
|
2695 |
|
2696 |
|
2697 |
|
2698 |
|
2699 |
|
2700 | function range (start, stop, step) {
|
2701 | var index, len
|
2702 | var result = []
|
2703 | var args = arguments
|
2704 | if (args.length < 2) {
|
2705 | stop = args[0]
|
2706 | start = 0
|
2707 | }
|
2708 | index = start >> 0
|
2709 | len = stop >> 0
|
2710 | if (index < stop) {
|
2711 | step = step >> 0 || 1
|
2712 | for (; index < len; index += step) {
|
2713 | result.push(index)
|
2714 | }
|
2715 | }
|
2716 | return result
|
2717 | }
|
2718 |
|
2719 |
|
2720 |
|
2721 |
|
2722 |
|
2723 |
|
2724 |
|
2725 |
|
2726 |
|
2727 |
|
2728 |
|
2729 |
|
2730 | function destructuring (destination, sources) {
|
2731 | if (destination && sources) {
|
2732 | var rest = assign.apply(this, [{}].concat(slice(arguments, 1)))
|
2733 | var restKeys = keys(rest)
|
2734 | arrayEach(keys(destination), function (key) {
|
2735 | if (includes(restKeys, key)) {
|
2736 | destination[key] = rest[key]
|
2737 | }
|
2738 | })
|
2739 | }
|
2740 | return destination
|
2741 | }
|
2742 |
|
2743 |
|
2744 |
|
2745 |
|
2746 |
|
2747 |
|
2748 |
|
2749 |
|
2750 |
|
2751 | function random (minVal, maxVal) {
|
2752 | return minVal >= maxVal ? minVal : ((minVal = minVal >> 0) + Math.round(Math.random() * ((maxVal || 9) - minVal)))
|
2753 | }
|
2754 |
|
2755 |
|
2756 |
|
2757 |
|
2758 |
|
2759 |
|
2760 |
|
2761 |
|
2762 |
|
2763 |
|
2764 | var min = helperCreateMinMax(function (rest, itemVal) {
|
2765 | return rest > itemVal
|
2766 | })
|
2767 |
|
2768 |
|
2769 |
|
2770 |
|
2771 |
|
2772 |
|
2773 |
|
2774 |
|
2775 |
|
2776 |
|
2777 | var max = helperCreateMinMax(function (rest, itemVal) {
|
2778 | return rest < itemVal
|
2779 | })
|
2780 |
|
2781 |
|
2782 |
|
2783 |
|
2784 |
|
2785 |
|
2786 |
|
2787 |
|
2788 |
|
2789 |
|
2790 |
|
2791 |
|
2792 | function commafy(num, options) {
|
2793 | var opts = options || {}
|
2794 | var optDigits = opts.digits
|
2795 | var isNum = isNumber(num)
|
2796 | var rest, result, isNegative, intStr, floatStr
|
2797 | if (isNum) {
|
2798 | rest = (opts.ceil ? ceil : (opts.floor ? floor : round))(num, optDigits)
|
2799 | result = toNumberString(optDigits ? toFixed(rest, optDigits) : rest).split('.')
|
2800 | intStr = result[0]
|
2801 | floatStr = result[1]
|
2802 | isNegative = intStr && rest < 0
|
2803 | if (isNegative) {
|
2804 | intStr = intStr.substring(1, intStr.length)
|
2805 | }
|
2806 | } else {
|
2807 | rest = toValueString(num).replace(/,/g, '')
|
2808 | result = rest ? [rest] : []
|
2809 | intStr = result[0]
|
2810 | }
|
2811 | if (result.length) {
|
2812 | return (isNegative ? '-' : '') + intStr.replace(new RegExp('(?=(?!(\\b))(.{' + (opts.spaceNumber || 3) + '})+$)', 'g'), (opts.separator || ',')) + (floatStr ? ('.' + floatStr) : '')
|
2813 | }
|
2814 | return rest
|
2815 | }
|
2816 |
|
2817 |
|
2818 |
|
2819 |
|
2820 |
|
2821 |
|
2822 |
|
2823 |
|
2824 |
|
2825 |
|
2826 | var round = helperCreateMathNumber('round')
|
2827 |
|
2828 |
|
2829 |
|
2830 |
|
2831 |
|
2832 |
|
2833 |
|
2834 |
|
2835 |
|
2836 |
|
2837 | var ceil = helperCreateMathNumber('ceil')
|
2838 |
|
2839 |
|
2840 |
|
2841 |
|
2842 |
|
2843 |
|
2844 |
|
2845 |
|
2846 |
|
2847 |
|
2848 | var floor = helperCreateMathNumber('floor')
|
2849 |
|
2850 |
|
2851 |
|
2852 |
|
2853 |
|
2854 |
|
2855 |
|
2856 |
|
2857 |
|
2858 |
|
2859 |
|
2860 | function toFixed (num, digits) {
|
2861 | digits = digits >> 0
|
2862 | var str = toValueString(round(num, digits))
|
2863 | var nums = str.split('.')
|
2864 | var intStr = nums[0]
|
2865 | var floatStr = nums[1] || ''
|
2866 | var digitOffsetIndex = digits - floatStr.length
|
2867 | if (digits) {
|
2868 | if (digitOffsetIndex > 0) {
|
2869 | return intStr + '.' + floatStr + helperStringRepeat('0', digitOffsetIndex)
|
2870 | }
|
2871 | return intStr + helperNumberOffsetPoint(floatStr, Math.abs(digitOffsetIndex))
|
2872 | }
|
2873 | return intStr
|
2874 | }
|
2875 |
|
2876 |
|
2877 |
|
2878 |
|
2879 |
|
2880 |
|
2881 |
|
2882 |
|
2883 |
|
2884 | var toNumber = helperCreateToNumber(parseFloat)
|
2885 |
|
2886 |
|
2887 |
|
2888 |
|
2889 |
|
2890 |
|
2891 |
|
2892 |
|
2893 |
|
2894 | function toNumberString(num) {
|
2895 | var rest = '' + num
|
2896 | var scienceMatchs = rest.match(/^([-+]?)((\d+)|((\d+)?[.](\d+)?))e([-+]{1})([0-9]+)$/)
|
2897 | if (scienceMatchs) {
|
2898 | var isNegative = num < 0
|
2899 | var absFlag = isNegative ? '-' : ''
|
2900 | var intNumStr = scienceMatchs[3] || ''
|
2901 | var dIntNumStr = scienceMatchs[5] || ''
|
2902 | var dFloatNumStr = scienceMatchs[6] || ''
|
2903 | var sciencFlag = scienceMatchs[7]
|
2904 | var scienceNumStr = scienceMatchs[8]
|
2905 | var floatOffsetIndex = scienceNumStr - dFloatNumStr.length
|
2906 | var intOffsetIndex = scienceNumStr - intNumStr.length
|
2907 | var dIntOffsetIndex = scienceNumStr - dIntNumStr.length
|
2908 | if (sciencFlag === '+') {
|
2909 | if (intNumStr) {
|
2910 | return absFlag + intNumStr + helperStringRepeat('0', scienceNumStr)
|
2911 | }
|
2912 | if (floatOffsetIndex > 0) {
|
2913 | return absFlag + dIntNumStr + dFloatNumStr + helperStringRepeat('0', floatOffsetIndex)
|
2914 | }
|
2915 | return absFlag + dIntNumStr + helperNumberOffsetPoint(dFloatNumStr, scienceNumStr)
|
2916 | }
|
2917 | if (intNumStr) {
|
2918 | if (intOffsetIndex > 0) {
|
2919 | return absFlag + '0.' + helperStringRepeat('0', Math.abs(intOffsetIndex)) + intNumStr
|
2920 | }
|
2921 | return absFlag + helperNumberOffsetPoint(intNumStr, intOffsetIndex)
|
2922 | }
|
2923 | if (dIntOffsetIndex > 0) {
|
2924 | return absFlag + '0.' + helperStringRepeat('0', Math.abs(dIntOffsetIndex)) + dIntNumStr + dFloatNumStr
|
2925 | }
|
2926 | return absFlag + helperNumberOffsetPoint(dIntNumStr, dIntOffsetIndex) + dFloatNumStr
|
2927 | }
|
2928 | return rest
|
2929 | }
|
2930 |
|
2931 |
|
2932 |
|
2933 |
|
2934 |
|
2935 |
|
2936 |
|
2937 |
|
2938 |
|
2939 |
|
2940 | var toInteger = helperCreateToNumber(staticParseInt)
|
2941 |
|
2942 |
|
2943 |
|
2944 |
|
2945 |
|
2946 |
|
2947 |
|
2948 |
|
2949 |
|
2950 |
|
2951 | function add (num1, num2) {
|
2952 | return helperNumberAdd(toNumber(num1), toNumber(num2))
|
2953 | }
|
2954 |
|
2955 |
|
2956 |
|
2957 |
|
2958 |
|
2959 |
|
2960 |
|
2961 |
|
2962 |
|
2963 |
|
2964 | function subtract (num1, num2) {
|
2965 | var subtrahend = toNumber(num1)
|
2966 | var minuend = toNumber(num2)
|
2967 | var str1 = toNumberString(subtrahend)
|
2968 | var str2 = toNumberString(minuend)
|
2969 | var digit1 = helperNumberDecimal(str1)
|
2970 | var digit2 = helperNumberDecimal(str2)
|
2971 | var ratio = Math.pow(10, Math.max(digit1, digit2))
|
2972 | var precision = (digit1 >= digit2) ? digit1 : digit2
|
2973 | return parseFloat(toFixed((subtrahend * ratio - minuend * ratio) / ratio, precision))
|
2974 | }
|
2975 |
|
2976 |
|
2977 |
|
2978 |
|
2979 |
|
2980 |
|
2981 |
|
2982 |
|
2983 |
|
2984 |
|
2985 |
|
2986 | function multiply (num1, num2) {
|
2987 | var multiplier = toNumber(num1)
|
2988 | var multiplicand = toNumber(num2)
|
2989 | return helperMultiply(multiplier, multiplicand)
|
2990 | }
|
2991 |
|
2992 |
|
2993 |
|
2994 |
|
2995 |
|
2996 |
|
2997 |
|
2998 |
|
2999 |
|
3000 |
|
3001 | function divide (num1, num2) {
|
3002 | return helperNumberDivide(toNumber(num1), toNumber(num2))
|
3003 | }
|
3004 |
|
3005 |
|
3006 |
|
3007 |
|
3008 |
|
3009 |
|
3010 |
|
3011 |
|
3012 |
|
3013 |
|
3014 |
|
3015 |
|
3016 | function sum (array, iterate, context) {
|
3017 | var result = 0
|
3018 | each(array, iterate ? isFunction(iterate) ? function () {
|
3019 | result = helperNumberAdd(result, iterate.apply(context, arguments))
|
3020 | } : function (val) {
|
3021 | result = helperNumberAdd(result, get(val, iterate))
|
3022 | } : function (val) {
|
3023 | result = helperNumberAdd(result, val)
|
3024 | })
|
3025 | return result
|
3026 | }
|
3027 |
|
3028 |
|
3029 |
|
3030 |
|
3031 |
|
3032 |
|
3033 |
|
3034 |
|
3035 |
|
3036 |
|
3037 |
|
3038 |
|
3039 |
|
3040 | function mean (array, iterate, context) {
|
3041 | return helperNumberDivide(sum(array, iterate, context), getSize(array))
|
3042 | }
|
3043 |
|
3044 |
|
3045 |
|
3046 |
|
3047 |
|
3048 |
|
3049 |
|
3050 |
|
3051 | var now = Date.now || function () {
|
3052 | return helperGetDateTime(helperNewDate())
|
3053 | }
|
3054 |
|
3055 |
|
3056 |
|
3057 |
|
3058 |
|
3059 |
|
3060 |
|
3061 |
|
3062 |
|
3063 |
|
3064 |
|
3065 |
|
3066 | var timestamp = function (str, format) {
|
3067 | if (str) {
|
3068 | var date = toStringDate(str, format)
|
3069 | return isDate(date) ? helperGetDateTime(date) : date
|
3070 | }
|
3071 | return now()
|
3072 | }
|
3073 |
|
3074 |
|
3075 |
|
3076 |
|
3077 |
|
3078 |
|
3079 |
|
3080 |
|
3081 |
|
3082 | function isValidDate (val) {
|
3083 | return isDate(val) && !isNaN(helperGetDateTime(val))
|
3084 | }
|
3085 |
|
3086 |
|
3087 |
|
3088 |
|
3089 |
|
3090 |
|
3091 |
|
3092 |
|
3093 |
|
3094 |
|
3095 | function isDateSame (date1, date2, format) {
|
3096 | if (date1 && date2) {
|
3097 | date1 = toDateString(date1, format)
|
3098 | return date1 !== 'Invalid Date' && date1 === toDateString(date2, format)
|
3099 | }
|
3100 | return false
|
3101 | }
|
3102 |
|
3103 |
|
3104 |
|
3105 |
|
3106 |
|
3107 | function getParseRule (txt) {
|
3108 | return '(\\d{' + txt + '})'
|
3109 | }
|
3110 |
|
3111 | function toParseMs (num) {
|
3112 | if (num < 10) {
|
3113 | return num * 100
|
3114 | } else if (num < 100) {
|
3115 | return num * 10
|
3116 | }
|
3117 | return num
|
3118 | }
|
3119 |
|
3120 | function toParseNum (num) {
|
3121 | return isNaN(num) ? num : staticParseInt(num)
|
3122 | }
|
3123 |
|
3124 | var d2 = getParseRule('2')
|
3125 | var d1or2 = getParseRule('1,2')
|
3126 | var d1or3 = getParseRule('1,3')
|
3127 | var d3or4 = getParseRule('3,4')
|
3128 | var place = '.{1}'
|
3129 | var d1Or2RE = place + d1or2
|
3130 | var dzZ = '(([zZ])|([-+]\\d{2}:?\\d{2}))'
|
3131 |
|
3132 | var defaulParseStrs = [d3or4, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, d1Or2RE, place + d1or3, dzZ]
|
3133 | var defaulParseREs = []
|
3134 |
|
3135 | for (var len = defaulParseStrs.length - 1; len >= 0; len--) {
|
3136 | var rule = ''
|
3137 | for (var i = 0; i < len + 1; i++) {
|
3138 | rule += defaulParseStrs[i]
|
3139 | }
|
3140 | defaulParseREs.push(new RegExp('^' + rule + '$'))
|
3141 | }
|
3142 |
|
3143 |
|
3144 |
|
3145 |
|
3146 | function parseDefaultRules (str) {
|
3147 | var matchRest, resMaps = {}
|
3148 | for (var i = 0, dfrLen = defaulParseREs.length; i < dfrLen; i++) {
|
3149 | matchRest = str.match(defaulParseREs[i])
|
3150 | if (matchRest) {
|
3151 | resMaps.y = matchRest[1]
|
3152 | resMaps.M = matchRest[2]
|
3153 | resMaps.d = matchRest[3]
|
3154 | resMaps.H = matchRest[4]
|
3155 | resMaps.m = matchRest[5]
|
3156 | resMaps.s = matchRest[6]
|
3157 | resMaps.S = matchRest[7]
|
3158 | resMaps.Z = matchRest[8]
|
3159 | break
|
3160 | }
|
3161 | }
|
3162 | return resMaps
|
3163 | }
|
3164 |
|
3165 | var customParseStrs = [
|
3166 | ['yyyy', d3or4],
|
3167 | ['yy', d2],
|
3168 | ['MM', d2],
|
3169 | ['M', d1or2],
|
3170 | ['dd', d2],
|
3171 | ['d', d1or2],
|
3172 | ['HH', d2],
|
3173 | ['H', d1or2],
|
3174 | ['mm', d2],
|
3175 | ['m', d1or2],
|
3176 | ['ss', d2],
|
3177 | ['s', d1or2],
|
3178 | ['SSS', getParseRule('3')],
|
3179 | ['S', d1or3],
|
3180 | ['Z', dzZ]
|
3181 | ]
|
3182 | var parseRuleMaps = {}
|
3183 | var parseRuleKeys = ['\\[([^\\]]+)\\]']
|
3184 |
|
3185 | for (var i = 0; i < customParseStrs.length; i++) {
|
3186 | var itemRule = customParseStrs[i]
|
3187 | parseRuleMaps[itemRule[0]] = itemRule[1] + '?'
|
3188 | parseRuleKeys.push(itemRule[0])
|
3189 | }
|
3190 |
|
3191 | var customParseRes = new RegExp(parseRuleKeys.join('|'), 'g')
|
3192 | var cacheFormatMaps = {}
|
3193 |
|
3194 |
|
3195 |
|
3196 |
|
3197 | function parseCustomRules (str, format) {
|
3198 | var cacheItem = cacheFormatMaps[format]
|
3199 | if (!cacheItem) {
|
3200 | var posIndexs = []
|
3201 | var re = format.replace(/([$(){}*+.?\\^|])/g, "\\$1").replace(customParseRes, function (text, val) {
|
3202 | var firstChar = text.charAt(0)
|
3203 |
|
3204 | if (firstChar === '[') {
|
3205 | return val
|
3206 | }
|
3207 | posIndexs.push(firstChar)
|
3208 | return parseRuleMaps[text]
|
3209 | })
|
3210 | cacheItem = cacheFormatMaps[format] = {
|
3211 | _i: posIndexs,
|
3212 | _r: new RegExp(re)
|
3213 | }
|
3214 | }
|
3215 | var resMaps = {}
|
3216 | var matchRest = str.match(cacheItem._r)
|
3217 | if (matchRest) {
|
3218 | var _i = cacheItem._i
|
3219 | for (var i = 1, len = matchRest.length; i < len; i++) {
|
3220 | resMaps[_i[i - 1]] = matchRest[i]
|
3221 | }
|
3222 | return resMaps
|
3223 | }
|
3224 | return resMaps
|
3225 | }
|
3226 |
|
3227 |
|
3228 |
|
3229 |
|
3230 | function parseTimeZone (resMaps) {
|
3231 |
|
3232 | if (/^[zZ]/.test(resMaps.Z)) {
|
3233 | return new Date(helperGetUTCDateTime(resMaps))
|
3234 | } else {
|
3235 |
|
3236 | var matchRest = resMaps.Z.match(/([-+])(\d{2}):?(\d{2})/)
|
3237 | if (matchRest) {
|
3238 | return new Date(helperGetUTCDateTime(resMaps) - (matchRest[1] === '-' ? -1 : 1) * staticParseInt(matchRest[2]) * 3600000 + staticParseInt(matchRest[3]) * 60000)
|
3239 | }
|
3240 | }
|
3241 | return new Date('')
|
3242 | }
|
3243 |
|
3244 |
|
3245 |
|
3246 |
|
3247 |
|
3248 |
|
3249 |
|
3250 |
|
3251 | function toStringDate (str, format) {
|
3252 | if (str) {
|
3253 | var isDType = isDate(str)
|
3254 | if (isDType || (!format && /^[0-9]{11,15}$/.test(str))) {
|
3255 | return new Date(isDType ? helperGetDateTime(str) : staticParseInt(str))
|
3256 | }
|
3257 | if (isString(str)) {
|
3258 | var resMaps = format ? parseCustomRules(str, format) : parseDefaultRules(str)
|
3259 | if (resMaps.y) {
|
3260 | if (resMaps.M) {
|
3261 | resMaps.M = toParseNum(resMaps.M) - 1
|
3262 | }
|
3263 | if (resMaps.S) {
|
3264 | resMaps.S = toParseMs(toParseNum(resMaps.S))
|
3265 | }
|
3266 | if (resMaps.Z) {
|
3267 | return parseTimeZone(resMaps)
|
3268 | } else {
|
3269 | return new Date(resMaps.y, resMaps.M || 0, resMaps.d || 1, resMaps.H || 0, resMaps.m || 0, resMaps.s || 0, resMaps.S || 0)
|
3270 | }
|
3271 | }
|
3272 | }
|
3273 | }
|
3274 | return new Date('')
|
3275 | }
|
3276 |
|
3277 |
|
3278 |
|
3279 |
|
3280 |
|
3281 |
|
3282 |
|
3283 |
|
3284 | function handleCustomTemplate (date, formats, match, value) {
|
3285 | var format = formats[match]
|
3286 | if (format) {
|
3287 | if (isFunction(format)) {
|
3288 | return format(value, match, date)
|
3289 | } else {
|
3290 | return format[value]
|
3291 | }
|
3292 | }
|
3293 | return value
|
3294 | }
|
3295 |
|
3296 | function formatDayE (day) {
|
3297 | return day === 0 ? 7 : day
|
3298 | }
|
3299 |
|
3300 |
|
3301 |
|
3302 |
|
3303 |
|
3304 |
|
3305 |
|
3306 |
|
3307 |
|
3308 | var dateFormatRE = /\[([^\]]+)]|y{2,4}|M{1,2}|d{1,2}|H{1,2}|h{1,2}|m{1,2}|s{1,2}|S{1,3}|Z{1,2}|W{1,2}|D{1,3}|[aAeEq]/g
|
3309 | function toDateString (date, format, options) {
|
3310 | if (date) {
|
3311 | date = toStringDate(date)
|
3312 | if (isValidDate(date)) {
|
3313 | var result = format || setupDefaults.formatString
|
3314 | var hours = date.getHours()
|
3315 | var apm = hours < 12 ? 'am' : 'pm'
|
3316 | var formats = assign({}, setupDefaults.formatStringMatchs, options ? options.formats : null)
|
3317 | var fy = function (match, length) {
|
3318 | return ('' + helperGetDateFullYear(date)).substr(4 - length)
|
3319 | }
|
3320 | var fM = function (match, length) {
|
3321 | return padStart(helperGetDateMonth(date) + 1, length, '0')
|
3322 | }
|
3323 | var fd = function (match, length) {
|
3324 | return padStart(date.getDate(), length, '0')
|
3325 | }
|
3326 | var fH = function (match, length) {
|
3327 | return padStart(hours, length, '0')
|
3328 | }
|
3329 | var fh = function (match, length) {
|
3330 | return padStart(hours <= 12 ? hours : hours - 12, length, '0')
|
3331 | }
|
3332 | var fm = function (match, length) {
|
3333 | return padStart(date.getMinutes(), length, '0')
|
3334 | }
|
3335 | var fs = function (match, length) {
|
3336 | return padStart(date.getSeconds(), length, '0')
|
3337 | }
|
3338 | var fS = function (match, length) {
|
3339 | return padStart(date.getMilliseconds(), length, '0')
|
3340 | }
|
3341 | var fZ = function (match, length) {
|
3342 | var zoneHours = date.getTimezoneOffset() / 60 * -1
|
3343 | return handleCustomTemplate(date, formats, match, (zoneHours >= 0 ? '+' : '-') + padStart(zoneHours, 2, '0') + (length === 1 ? ':' : '') + '00')
|
3344 | }
|
3345 | var fW = function (match, length) {
|
3346 | return padStart(handleCustomTemplate(date, formats, match, getYearWeek(date)), length, '0')
|
3347 | }
|
3348 | var fD = function (match, length) {
|
3349 | return padStart(handleCustomTemplate(date, formats, match, getYearDay(date)), length, '0')
|
3350 | }
|
3351 | var parseDates = {
|
3352 | yyyy: fy,
|
3353 | yy: fy,
|
3354 | MM: fM,
|
3355 | M: fM,
|
3356 | dd: fd,
|
3357 | d: fd,
|
3358 | HH: fH,
|
3359 | H: fH,
|
3360 | hh: fh,
|
3361 | h: fh,
|
3362 | mm: fm,
|
3363 | m: fm,
|
3364 | ss: fs,
|
3365 | s: fs,
|
3366 | SSS: fS,
|
3367 | S: fS,
|
3368 | ZZ: fZ,
|
3369 | Z: fZ,
|
3370 | WW: fW,
|
3371 | W: fW,
|
3372 | DDD: fD,
|
3373 | D: fD,
|
3374 | a: function (match) {
|
3375 | return handleCustomTemplate(date, formats, match, apm)
|
3376 | },
|
3377 | A: function (match) {
|
3378 | return handleCustomTemplate(date, formats, match, helperStringUpperCase(apm))
|
3379 | },
|
3380 | e: function (match) {
|
3381 | return handleCustomTemplate(date, formats, match, date.getDay())
|
3382 | },
|
3383 | E: function (match) {
|
3384 | return handleCustomTemplate(date, formats, match, formatDayE(date.getDay()))
|
3385 | },
|
3386 | q: function (match) {
|
3387 | return handleCustomTemplate(date, formats, match, Math.floor((helperGetDateMonth(date) + 3) / 3))
|
3388 | }
|
3389 | }
|
3390 | return result.replace(dateFormatRE, function (match, skip) {
|
3391 | return skip || (parseDates[match] ? parseDates[match](match, match.length) : match)
|
3392 | })
|
3393 | }
|
3394 | return 'Invalid Date'
|
3395 | }
|
3396 | return ''
|
3397 | }
|
3398 |
|
3399 |
|
3400 |
|
3401 |
|
3402 |
|
3403 |
|
3404 |
|
3405 |
|
3406 |
|
3407 |
|
3408 |
|
3409 |
|
3410 |
|
3411 | function getWhatYear (date, offset, month) {
|
3412 | var number
|
3413 | date = toStringDate(date)
|
3414 | if (isValidDate(date)) {
|
3415 | if (offset) {
|
3416 | number = offset && !isNaN(offset) ? offset : 0
|
3417 | date.setFullYear(helperGetDateFullYear(date) + number)
|
3418 | }
|
3419 | if (month || !isNaN(month)) {
|
3420 | if (month === staticStrFirst) {
|
3421 | return new Date(helperGetDateFullYear(date), 0, 1)
|
3422 | } else if (month === staticStrLast) {
|
3423 | date.setMonth(11)
|
3424 | return getWhatMonth(date, 0, staticStrLast)
|
3425 | } else {
|
3426 | date.setMonth(month)
|
3427 | }
|
3428 | }
|
3429 | }
|
3430 | return date
|
3431 | }
|
3432 |
|
3433 |
|
3434 |
|
3435 |
|
3436 |
|
3437 | function getQuarterNumber (date) {
|
3438 | var month = date.getMonth()
|
3439 | if (month < 3) {
|
3440 | return 1
|
3441 | } else if (month < 6) {
|
3442 | return 2
|
3443 | } else if (month < 9) {
|
3444 | return 3
|
3445 | }
|
3446 | return 4
|
3447 | }
|
3448 |
|
3449 |
|
3450 |
|
3451 |
|
3452 |
|
3453 |
|
3454 |
|
3455 |
|
3456 |
|
3457 | function getWhatQuarter (date, offset, day) {
|
3458 | var currMonth, monthOffset = offset && !isNaN(offset) ? offset * 3 : 0
|
3459 | date = toStringDate(date)
|
3460 | if (isValidDate(date)) {
|
3461 | currMonth = (getQuarterNumber(date) - 1) * 3
|
3462 | date.setMonth(currMonth)
|
3463 | return getWhatMonth(date, monthOffset, day)
|
3464 | }
|
3465 | return date
|
3466 | }
|
3467 |
|
3468 |
|
3469 |
|
3470 |
|
3471 |
|
3472 |
|
3473 |
|
3474 |
|
3475 |
|
3476 |
|
3477 |
|
3478 |
|
3479 |
|
3480 | function getWhatMonth (date, offset, day) {
|
3481 | var monthOffset = offset && !isNaN(offset) ? offset : 0
|
3482 | date = toStringDate(date)
|
3483 | if (isValidDate(date)) {
|
3484 | if (day === staticStrFirst) {
|
3485 | return new Date(helperGetDateFullYear(date), helperGetDateMonth(date) + monthOffset, 1)
|
3486 | } else if (day === staticStrLast) {
|
3487 | return new Date(helperGetDateTime(getWhatMonth(date, monthOffset + 1, staticStrFirst)) - 1)
|
3488 | } else if (isNumber(day)) {
|
3489 | date.setDate(day)
|
3490 | }
|
3491 | if (monthOffset) {
|
3492 | var currDate = date.getDate()
|
3493 | date.setMonth(helperGetDateMonth(date) + monthOffset)
|
3494 | if (currDate !== date.getDate()) {
|
3495 |
|
3496 | date.setDate(1)
|
3497 | return new Date(helperGetDateTime(date) - staticDayTime)
|
3498 | }
|
3499 | }
|
3500 | }
|
3501 | return date
|
3502 | }
|
3503 |
|
3504 |
|
3505 |
|
3506 |
|
3507 |
|
3508 |
|
3509 |
|
3510 |
|
3511 |
|
3512 |
|
3513 |
|
3514 |
|
3515 |
|
3516 |
|
3517 | function getWhatWeek (date, offset, day) {
|
3518 | var time, whatDayTime, currentDay, customDay
|
3519 | date = toStringDate(date)
|
3520 | if (isValidDate(date)) {
|
3521 | customDay = staticParseInt(/^[0-7]$/.test(day) ? day : date.getDay())
|
3522 | currentDay = date.getDay()
|
3523 | time = helperGetDateTime(date)
|
3524 | whatDayTime = time + ((customDay === 0 ? 7 : customDay) - (currentDay === 0 ? 7 : currentDay)) * staticDayTime
|
3525 | if (offset && !isNaN(offset)) {
|
3526 | whatDayTime += offset * staticWeekTime
|
3527 | }
|
3528 | return new Date(whatDayTime)
|
3529 | }
|
3530 | return date
|
3531 | }
|
3532 |
|
3533 |
|
3534 |
|
3535 |
|
3536 |
|
3537 |
|
3538 |
|
3539 |
|
3540 |
|
3541 |
|
3542 |
|
3543 |
|
3544 |
|
3545 | function getWhatDay (date, offset, mode) {
|
3546 | date = toStringDate(date)
|
3547 | if (isValidDate(date) && !isNaN(offset)) {
|
3548 | date.setDate(date.getDate() + staticParseInt(offset))
|
3549 | if (mode === staticStrFirst) {
|
3550 | return new Date(helperGetDateFullYear(date), helperGetDateMonth(date), date.getDate())
|
3551 | } else if (mode === staticStrLast) {
|
3552 | return new Date(helperGetDateTime(getWhatDay(date, 1, staticStrFirst)) - 1)
|
3553 | }
|
3554 | }
|
3555 | return date
|
3556 | }
|
3557 |
|
3558 |
|
3559 |
|
3560 |
|
3561 |
|
3562 |
|
3563 |
|
3564 |
|
3565 |
|
3566 |
|
3567 |
|
3568 |
|
3569 | function getYearDay (date) {
|
3570 | date = toStringDate(date)
|
3571 | if (isValidDate(date)) {
|
3572 | return Math.floor((helperGetYMDTime(date) - helperGetYMDTime(getWhatYear(date, 0, staticStrFirst))) / staticDayTime) + 1
|
3573 | }
|
3574 | return NaN
|
3575 | }
|
3576 |
|
3577 |
|
3578 |
|
3579 |
|
3580 |
|
3581 |
|
3582 |
|
3583 |
|
3584 |
|
3585 |
|
3586 |
|
3587 | function getYearWeek (date) {
|
3588 | date = toStringDate(date)
|
3589 | if (isValidDate(date)) {
|
3590 | date.setHours(0, 0, 0, 0)
|
3591 | date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7)
|
3592 | var week = new Date(date.getFullYear(), 0, 4)
|
3593 | return Math.round(((date.getTime() - week.getTime()) / staticDayTime + (week.getDay() + 6) % 7 - 3) / 7) + 1
|
3594 | }
|
3595 | return NaN
|
3596 | }
|
3597 |
|
3598 |
|
3599 |
|
3600 |
|
3601 |
|
3602 |
|
3603 |
|
3604 |
|
3605 |
|
3606 |
|
3607 |
|
3608 |
|
3609 | function getMonthWeek (date) {
|
3610 | var monthFirst, monthFirstWeek
|
3611 | var currentDate = toStringDate(date)
|
3612 | if (isValidDate(currentDate)) {
|
3613 | monthFirst = getWhatMonth(currentDate, 0, staticStrFirst)
|
3614 | monthFirstWeek = getWhatWeek(monthFirst, 0, 1)
|
3615 | if (monthFirstWeek < monthFirst) {
|
3616 | monthFirstWeek = getWhatWeek(monthFirst, 1, 1)
|
3617 | }
|
3618 | if (currentDate >= monthFirstWeek) {
|
3619 | return Math.floor((helperGetYMDTime(currentDate) - helperGetYMDTime(monthFirstWeek)) / staticWeekTime) + 1
|
3620 | }
|
3621 | return getMonthWeek(getWhatWeek(currentDate, 0, 1))
|
3622 | }
|
3623 | return NaN
|
3624 | }
|
3625 |
|
3626 |
|
3627 |
|
3628 |
|
3629 |
|
3630 |
|
3631 |
|
3632 |
|
3633 |
|
3634 |
|
3635 |
|
3636 | function getDayOfYear (date, year) {
|
3637 | date = toStringDate(date)
|
3638 | if (isValidDate(date)) {
|
3639 | return isLeapYear(getWhatYear(date, year)) ? 366 : 365
|
3640 | }
|
3641 | return NaN
|
3642 | }
|
3643 |
|
3644 |
|
3645 |
|
3646 |
|
3647 |
|
3648 |
|
3649 |
|
3650 |
|
3651 |
|
3652 |
|
3653 |
|
3654 |
|
3655 |
|
3656 | function getDayOfMonth (date, month) {
|
3657 | date = toStringDate(date)
|
3658 | if (isValidDate(date)) {
|
3659 | return Math.floor((helperGetDateTime(getWhatMonth(date, month, staticStrLast)) - helperGetDateTime(getWhatMonth(date, month, staticStrFirst))) / staticDayTime) + 1
|
3660 | }
|
3661 | return NaN
|
3662 | }
|
3663 |
|
3664 |
|
3665 |
|
3666 |
|
3667 |
|
3668 |
|
3669 |
|
3670 |
|
3671 |
|
3672 |
|
3673 |
|
3674 |
|
3675 |
|
3676 |
|
3677 | function getDateDiff (startDate, endDate, rules) {
|
3678 | var startTime, endTime, item, diffTime, rule, len, index
|
3679 | var result = { done: false, time: 0 }
|
3680 | startDate = toStringDate(startDate)
|
3681 | endDate = endDate ? toStringDate(endDate) : helperNewDate()
|
3682 | if (isValidDate(startDate) && isValidDate(endDate)) {
|
3683 | startTime = helperGetDateTime(startDate)
|
3684 | endTime = helperGetDateTime(endDate)
|
3685 | if (startTime < endTime) {
|
3686 | diffTime = result.time = endTime - startTime
|
3687 | rule = rules && rules.length > 0 ? rules : setupDefaults.dateDiffRules
|
3688 | result.done = true
|
3689 | for (index = 0, len = rule.length; index < len; index++) {
|
3690 | item = rule[index]
|
3691 | if (diffTime >= item[1]) {
|
3692 | if (index === len - 1) {
|
3693 | result[item[0]] = diffTime || 0
|
3694 | } else {
|
3695 | result[item[0]] = Math.floor(diffTime / item[1])
|
3696 | diffTime -= result[item[0]] * item[1]
|
3697 | }
|
3698 | } else {
|
3699 | result[item[0]] = 0
|
3700 | }
|
3701 | }
|
3702 | }
|
3703 | }
|
3704 | return result
|
3705 | }
|
3706 |
|
3707 |
|
3708 |
|
3709 |
|
3710 |
|
3711 |
|
3712 |
|
3713 |
|
3714 |
|
3715 | function trim (str) {
|
3716 | return str && str.trim ? str.trim() : trimRight(trimLeft(str))
|
3717 | }
|
3718 |
|
3719 |
|
3720 |
|
3721 |
|
3722 |
|
3723 |
|
3724 |
|
3725 |
|
3726 |
|
3727 | function trimLeft (str) {
|
3728 | return str && str.trimLeft ? str.trimLeft() : toValueString(str).replace(/^[\s\uFEFF\xA0]+/g, '')
|
3729 | }
|
3730 |
|
3731 |
|
3732 |
|
3733 |
|
3734 |
|
3735 |
|
3736 |
|
3737 |
|
3738 |
|
3739 | function trimRight (str) {
|
3740 | return str && str.trimRight ? str.trimRight() : toValueString(str).replace(/[\s\uFEFF\xA0]+$/g, '')
|
3741 | }
|
3742 |
|
3743 |
|
3744 |
|
3745 |
|
3746 |
|
3747 |
|
3748 |
|
3749 |
|
3750 |
|
3751 |
|
3752 | var escape = helperFormatEscaper(staticEscapeMap)
|
3753 |
|
3754 |
|
3755 |
|
3756 |
|
3757 |
|
3758 | var unescapeMap = {}
|
3759 | each(staticEscapeMap, function (item, key) {
|
3760 | unescapeMap[staticEscapeMap[key]] = key
|
3761 | })
|
3762 |
|
3763 |
|
3764 |
|
3765 |
|
3766 |
|
3767 |
|
3768 |
|
3769 | var unescape = helperFormatEscaper(unescapeMap)
|
3770 |
|
3771 |
|
3772 |
|
3773 | var camelCacheMaps = {}
|
3774 |
|
3775 |
|
3776 |
|
3777 |
|
3778 |
|
3779 |
|
3780 |
|
3781 | function camelCase (str) {
|
3782 | str = toValueString(str)
|
3783 | if (camelCacheMaps[str]) {
|
3784 | return camelCacheMaps[str]
|
3785 | }
|
3786 | var strLen = str.length
|
3787 | var rest = str.replace(/([-]+)/g, function (text, flag, index) {
|
3788 | return index && index + flag.length < strLen ? '-' : ''
|
3789 | })
|
3790 | strLen = rest.length
|
3791 | rest = rest.replace(/([A-Z]+)/g, function (text, upper, index) {
|
3792 | var upperLen = upper.length
|
3793 | upper = helperStringLowerCase(upper)
|
3794 | if (index) {
|
3795 | if (upperLen > 2 && index + upperLen < strLen) {
|
3796 | return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen))
|
3797 | }
|
3798 | return helperStringUpperCase(helperStringSubstring(upper, 0, 1)) + helperStringSubstring(upper, 1, upperLen)
|
3799 | } else {
|
3800 | if (upperLen > 1 && index + upperLen < strLen) {
|
3801 | return helperStringSubstring(upper, 0, upperLen - 1) + helperStringUpperCase(helperStringSubstring(upper, upperLen - 1, upperLen))
|
3802 | }
|
3803 | }
|
3804 | return upper
|
3805 | }).replace(/(-[a-zA-Z])/g, function (text, upper) {
|
3806 | return helperStringUpperCase(helperStringSubstring(upper, 1, upper.length))
|
3807 | })
|
3808 | camelCacheMaps[str] = rest
|
3809 | return rest
|
3810 | }
|
3811 |
|
3812 |
|
3813 |
|
3814 | var kebabCacheMaps = {}
|
3815 |
|
3816 |
|
3817 |
|
3818 |
|
3819 |
|
3820 |
|
3821 |
|
3822 | function kebabCase (str) {
|
3823 | str = toValueString(str)
|
3824 | if (kebabCacheMaps[str]) {
|
3825 | return kebabCacheMaps[str]
|
3826 | }
|
3827 | if (/^[A-Z]+$/.test(str)) {
|
3828 | return helperStringLowerCase(str)
|
3829 | }
|
3830 | var rest = str.replace(/^([a-z])([A-Z]+)([a-z]+)$/, function (text, prevLower, upper, nextLower) {
|
3831 | var upperLen = upper.length
|
3832 | if (upperLen > 1) {
|
3833 | return prevLower + '-' + helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1)) + '-' + helperStringLowerCase(helperStringSubstring(upper, upperLen - 1, upperLen)) + nextLower
|
3834 | }
|
3835 | return helperStringLowerCase(prevLower + '-' + upper + nextLower)
|
3836 | }).replace(/^([A-Z]+)([a-z]+)?$/, function (text, upper, nextLower) {
|
3837 | var upperLen = upper.length
|
3838 | return helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1) + '-' + helperStringSubstring(upper, upperLen - 1, upperLen) + (nextLower || ''))
|
3839 | }).replace(/([a-z]?)([A-Z]+)([a-z]?)/g, function (text, prevLower, upper, nextLower, index) {
|
3840 | var upperLen = upper.length
|
3841 | if (upperLen > 1) {
|
3842 | if (prevLower) {
|
3843 | prevLower += '-'
|
3844 | }
|
3845 | if (nextLower) {
|
3846 | return (prevLower || '') + helperStringLowerCase(helperStringSubstring(upper, 0, upperLen - 1)) + '-' + helperStringLowerCase(helperStringSubstring(upper, upperLen - 1, upperLen)) + nextLower
|
3847 | }
|
3848 | }
|
3849 | return (prevLower || '') + (index ? '-' : '') + helperStringLowerCase(upper) + (nextLower || '')
|
3850 | })
|
3851 | rest = rest.replace(/([-]+)/g, function (text, flag, index) {
|
3852 | return index && index + flag.length < rest.length ? '-' : ''
|
3853 | })
|
3854 | kebabCacheMaps[str] = rest
|
3855 | return rest
|
3856 | }
|
3857 |
|
3858 |
|
3859 |
|
3860 |
|
3861 |
|
3862 |
|
3863 |
|
3864 |
|
3865 |
|
3866 |
|
3867 |
|
3868 | function repeat (str, count) {
|
3869 | return helperStringRepeat(toValueString(str), count)
|
3870 | }
|
3871 |
|
3872 |
|
3873 |
|
3874 |
|
3875 |
|
3876 |
|
3877 |
|
3878 |
|
3879 |
|
3880 |
|
3881 |
|
3882 |
|
3883 |
|
3884 | function padStart (str, targetLength, padString) {
|
3885 | var rest = toValueString(str)
|
3886 | targetLength = targetLength >> 0
|
3887 | padString = isUndefined(padString) ? ' ' : '' + padString
|
3888 | if (rest.padStart) {
|
3889 | return rest.padStart(targetLength, padString)
|
3890 | }
|
3891 | if (targetLength > rest.length) {
|
3892 | targetLength -= rest.length
|
3893 | if (targetLength > padString.length) {
|
3894 | padString += helperStringRepeat(padString, targetLength / padString.length)
|
3895 | }
|
3896 | return padString.slice(0, targetLength) + rest
|
3897 | }
|
3898 | return rest
|
3899 | }
|
3900 |
|
3901 |
|
3902 |
|
3903 |
|
3904 |
|
3905 |
|
3906 |
|
3907 |
|
3908 |
|
3909 |
|
3910 |
|
3911 |
|
3912 |
|
3913 | function padEnd (str, targetLength, padString) {
|
3914 | var rest = toValueString(str)
|
3915 | targetLength = targetLength >> 0
|
3916 | padString = isUndefined(padString) ? ' ' : '' + padString
|
3917 | if (rest.padEnd) {
|
3918 | return rest.padEnd(targetLength, padString)
|
3919 | }
|
3920 | if (targetLength > rest.length) {
|
3921 | targetLength -= rest.length
|
3922 | if (targetLength > padString.length) {
|
3923 | padString += helperStringRepeat(padString, targetLength / padString.length)
|
3924 | }
|
3925 | return rest + padString.slice(0, targetLength)
|
3926 | }
|
3927 | return rest
|
3928 | }
|
3929 |
|
3930 |
|
3931 |
|
3932 |
|
3933 |
|
3934 |
|
3935 |
|
3936 |
|
3937 |
|
3938 |
|
3939 |
|
3940 | function startsWith (str, val, startIndex) {
|
3941 | var rest = toValueString(str)
|
3942 | return (arguments.length === 1 ? rest : rest.substring(startIndex)).indexOf(val) === 0
|
3943 | }
|
3944 |
|
3945 |
|
3946 |
|
3947 |
|
3948 |
|
3949 |
|
3950 |
|
3951 |
|
3952 |
|
3953 |
|
3954 |
|
3955 | function endsWith (str, val, startIndex) {
|
3956 | var rest = toValueString(str)
|
3957 | var argsLen = arguments.length
|
3958 | return argsLen > 1 && (argsLen > 2 ? rest.substring(0, startIndex).indexOf(val) === startIndex - 1 : rest.indexOf(val) === rest.length - 1)
|
3959 | }
|
3960 |
|
3961 |
|
3962 |
|
3963 |
|
3964 |
|
3965 |
|
3966 |
|
3967 |
|
3968 |
|
3969 |
|
3970 |
|
3971 | function template (str, args, options) {
|
3972 | return toValueString(str).replace((options || setupDefaults).tmplRE || /\{{2}([.\w[\]\s]+)\}{2}/g, function (match, key) {
|
3973 | return get(args, trim(key))
|
3974 | })
|
3975 | }
|
3976 |
|
3977 |
|
3978 |
|
3979 | /**
|
3980 | * 字符串格式化占位符
|
3981 | * @param { string } str
|
3982 | * @param { object | any[] } obj
|
3983 | */
|
3984 | function toFormatString (str, obj) {
|
3985 | return template(str, obj,{ tmplRE: /\{([.\w[\]\s]+)\}/g })
|
3986 | }
|
3987 |
|
3988 |
|
3989 |
|
3990 |
|
3991 |
|
3992 | function toValueString (obj) {
|
3993 | if (isNumber(obj)) {
|
3994 | return toNumberString(obj)
|
3995 | }
|
3996 | return '' + (eqNull(obj) ? '' : obj)
|
3997 | }
|
3998 |
|
3999 |
|
4000 |
|
4001 |
|
4002 |
|
4003 | function noop () {}
|
4004 |
|
4005 |
|
4006 |
|
4007 |
|
4008 |
|
4009 |
|
4010 |
|
4011 |
|
4012 |
|
4013 | function property (name, defs) {
|
4014 | return function (obj) {
|
4015 | return isNull(obj) ? defs : obj[name]
|
4016 | }
|
4017 | }
|
4018 |
|
4019 |
|
4020 |
|
4021 |
|
4022 |
|
4023 |
|
4024 |
|
4025 |
|
4026 |
|
4027 |
|
4028 |
|
4029 | function bind (callback, context) {
|
4030 | var args = slice(arguments, 2)
|
4031 | return function () {
|
4032 | return callback.apply(context, slice(arguments).concat(args))
|
4033 | }
|
4034 | }
|
4035 |
|
4036 |
|
4037 |
|
4038 |
|
4039 |
|
4040 |
|
4041 |
|
4042 |
|
4043 |
|
4044 |
|
4045 |
|
4046 | function once (callback, context) {
|
4047 | var done = false
|
4048 | var rest = null
|
4049 | var args = slice(arguments, 2)
|
4050 | return function () {
|
4051 | if (done) {
|
4052 | return rest
|
4053 | }
|
4054 | rest = callback.apply(context, slice(arguments).concat(args))
|
4055 | done = true
|
4056 | return rest
|
4057 | }
|
4058 | }
|
4059 |
|
4060 |
|
4061 |
|
4062 |
|
4063 |
|
4064 |
|
4065 |
|
4066 |
|
4067 |
|
4068 |
|
4069 | function after (count, callback, context) {
|
4070 | var runCount = 0
|
4071 | var rests = []
|
4072 | return function () {
|
4073 | var args = arguments
|
4074 | runCount++
|
4075 | if (runCount <= count) {
|
4076 | rests.push(args[0])
|
4077 | }
|
4078 | if (runCount >= count) {
|
4079 | callback.apply(context, [rests].concat(slice(args)))
|
4080 | }
|
4081 | }
|
4082 | }
|
4083 |
|
4084 |
|
4085 |
|
4086 |
|
4087 |
|
4088 |
|
4089 |
|
4090 |
|
4091 |
|
4092 |
|
4093 | function before (count, callback, context) {
|
4094 | var runCount = 0
|
4095 | var rests = []
|
4096 | context = context || this
|
4097 | return function () {
|
4098 | var args = arguments
|
4099 | runCount++
|
4100 | if (runCount < count) {
|
4101 | rests.push(args[0])
|
4102 | callback.apply(context, [rests].concat(slice(args)))
|
4103 | }
|
4104 | }
|
4105 | }
|
4106 |
|
4107 |
|
4108 |
|
4109 |
|
4110 |
|
4111 |
|
4112 |
|
4113 |
|
4114 |
|
4115 |
|
4116 | function throttle (callback, wait, options) {
|
4117 | var args, context
|
4118 | var opts = options || {}
|
4119 | var runFlag = false
|
4120 | var timeout = 0
|
4121 | var optLeading = 'leading' in opts ? opts.leading : true
|
4122 | var optTrailing = 'trailing' in opts ? opts.trailing : false
|
4123 | var runFn = function () {
|
4124 | runFlag = true
|
4125 | callback.apply(context, args)
|
4126 | timeout = setTimeout(endFn, wait)
|
4127 | }
|
4128 | var endFn = function () {
|
4129 | timeout = 0
|
4130 | if (!runFlag && optTrailing === true) {
|
4131 | runFn()
|
4132 | }
|
4133 | }
|
4134 | var cancelFn = function () {
|
4135 | var rest = timeout !== 0
|
4136 | clearTimeout(timeout)
|
4137 | runFlag = false
|
4138 | timeout = 0
|
4139 | return rest
|
4140 | }
|
4141 | var throttled = function () {
|
4142 | args = arguments
|
4143 | context = this
|
4144 | runFlag = false
|
4145 | if (timeout === 0) {
|
4146 | if (optLeading === true) {
|
4147 | runFn()
|
4148 | } else if (optTrailing === true) {
|
4149 | timeout = setTimeout(endFn, wait)
|
4150 | }
|
4151 | }
|
4152 | }
|
4153 | throttled.cancel = cancelFn
|
4154 | return throttled
|
4155 | }
|
4156 |
|
4157 |
|
4158 |
|
4159 |
|
4160 |
|
4161 |
|
4162 |
|
4163 |
|
4164 |
|
4165 |
|
4166 | function debounce (callback, wait, options) {
|
4167 | var args, context
|
4168 | var opts = options || {}
|
4169 | var runFlag = false
|
4170 | var timeout = 0
|
4171 | var isLeading = typeof options === 'boolean'
|
4172 | var optLeading = 'leading' in opts ? opts.leading : isLeading
|
4173 | var optTrailing = 'trailing' in opts ? opts.trailing : !isLeading
|
4174 | var runFn = function () {
|
4175 | runFlag = true
|
4176 | timeout = 0
|
4177 | callback.apply(context, args)
|
4178 | }
|
4179 | var endFn = function () {
|
4180 | if (optLeading === true) {
|
4181 | timeout = 0
|
4182 | }
|
4183 | if (!runFlag && optTrailing === true) {
|
4184 | runFn()
|
4185 | }
|
4186 | }
|
4187 | var cancelFn = function () {
|
4188 | var rest = timeout !== 0
|
4189 | clearTimeout(timeout)
|
4190 | timeout = 0
|
4191 | return rest
|
4192 | }
|
4193 | var debounced = function () {
|
4194 | runFlag = false
|
4195 | args = arguments
|
4196 | context = this
|
4197 | if (timeout === 0) {
|
4198 | if (optLeading === true) {
|
4199 | runFn()
|
4200 | }
|
4201 | } else {
|
4202 | clearTimeout(timeout)
|
4203 | }
|
4204 | timeout = setTimeout(endFn, wait)
|
4205 | }
|
4206 | debounced.cancel = cancelFn
|
4207 | return debounced
|
4208 | }
|
4209 |
|
4210 |
|
4211 |
|
4212 |
|
4213 |
|
4214 |
|
4215 |
|
4216 |
|
4217 |
|
4218 |
|
4219 |
|
4220 | function delay (callback, wait) {
|
4221 | var args = slice(arguments, 2)
|
4222 | var context = this
|
4223 | return setTimeout(function () {
|
4224 | callback.apply(context, args)
|
4225 | }, wait)
|
4226 | }
|
4227 |
|
4228 |
|
4229 |
|
4230 |
|
4231 |
|
4232 | function parseURLQuery (uri) {
|
4233 | return unserialize(uri.split('?')[1] || '')
|
4234 | }
|
4235 |
|
4236 | function parseUrl (url) {
|
4237 | var hashs, portText, searchs, parsed
|
4238 | var href = '' + url
|
4239 | if (href.indexOf('//') === 0) {
|
4240 | href = (staticLocation ? staticLocation.protocol : '') + href
|
4241 | } else if (href.indexOf('/') === 0) {
|
4242 | href = helperGetLocatOrigin() + href
|
4243 | }
|
4244 | searchs = href.replace(/#.*/, '').match(/(\?.*)/)
|
4245 | parsed = {
|
4246 | href: href,
|
4247 | hash: '',
|
4248 | host: '',
|
4249 | hostname: '',
|
4250 | protocol: '',
|
4251 | port: '',
|
4252 | search: searchs && searchs[1] && searchs[1].length > 1 ? searchs[1] : ''
|
4253 | }
|
4254 | parsed.path = href.replace(/^([a-z0-9.+-]*:)\/\//, function (text, protocol) {
|
4255 | parsed.protocol = protocol
|
4256 | return ''
|
4257 | }).replace(/^([a-z0-9.+-]*)(:\d+)?\/?/, function (text, hostname, port) {
|
4258 | portText = port || ''
|
4259 | parsed.port = portText.replace(':', '')
|
4260 | parsed.hostname = hostname
|
4261 | parsed.host = hostname + portText
|
4262 | return '/'
|
4263 | }).replace(/(#.*)/, function (text, hash) {
|
4264 | parsed.hash = hash.length > 1 ? hash : ''
|
4265 | return ''
|
4266 | })
|
4267 | hashs = parsed.hash.match(/#((.*)\?|(.*))/)
|
4268 | parsed.pathname = parsed.path.replace(/(\?|#.*).*/, '')
|
4269 | parsed.origin = parsed.protocol + '//' + parsed.host
|
4270 | parsed.hashKey = hashs ? (hashs[2] || hashs[1] || '') : ''
|
4271 | parsed.hashQuery = parseURLQuery(parsed.hash)
|
4272 | parsed.searchQuery = parseURLQuery(parsed.search)
|
4273 | return parsed
|
4274 | }
|
4275 |
|
4276 |
|
4277 |
|
4278 |
|
4279 | function stringifyParams (resultVal, resultKey, isArr) {
|
4280 | var _arr
|
4281 | var result = []
|
4282 | each(resultVal, function (item, key) {
|
4283 | _arr = isArray(item)
|
4284 | if (isPlainObject(item) || _arr) {
|
4285 | result = result.concat(stringifyParams(item, resultKey + '[' + key + ']', _arr))
|
4286 | } else {
|
4287 | result.push(staticEncodeURIComponent(resultKey + '[' + (isArr ? '' : key) + ']') + '=' + staticEncodeURIComponent(isNull(item) ? '' : item))
|
4288 | }
|
4289 | })
|
4290 | return result
|
4291 | }
|
4292 |
|
4293 |
|
4294 |
|
4295 |
|
4296 |
|
4297 |
|
4298 | function serialize (query) {
|
4299 | var _arr
|
4300 | var params = []
|
4301 | each(query, function (item, key) {
|
4302 | if (!isUndefined(item)) {
|
4303 | _arr = isArray(item)
|
4304 | if (isPlainObject(item) || _arr) {
|
4305 | params = params.concat(stringifyParams(item, key, _arr))
|
4306 | } else {
|
4307 | params.push(staticEncodeURIComponent(key) + '=' + staticEncodeURIComponent(isNull(item) ? '' : item))
|
4308 | }
|
4309 | }
|
4310 | })
|
4311 | return params.join('&').replace(/%20/g, '+')
|
4312 | }
|
4313 |
|
4314 |
|
4315 |
|
4316 |
|
4317 |
|
4318 |
|
4319 |
|
4320 |
|
4321 |
|
4322 | function unserialize (str) {
|
4323 | var items
|
4324 | var result = {}
|
4325 | if (str && isString(str)) {
|
4326 | arrayEach(str.split('&'), function (param) {
|
4327 | items = param.split('=')
|
4328 | result[staticDecodeURIComponent(items[0])] = staticDecodeURIComponent(items[1] || '')
|
4329 | })
|
4330 | }
|
4331 | return result
|
4332 | }
|
4333 |
|
4334 |
|
4335 |
|
4336 |
|
4337 |
|
4338 | function getBaseURL () {
|
4339 | if (staticLocation) {
|
4340 | var pathname = staticLocation.pathname
|
4341 | var lastIndex = lastIndexOf(pathname, '/') + 1
|
4342 | return helperGetLocatOrigin() + (lastIndex === pathname.length ? pathname : pathname.substring(0, lastIndex))
|
4343 | }
|
4344 | return ''
|
4345 | }
|
4346 |
|
4347 |
|
4348 |
|
4349 |
|
4350 |
|
4351 |
|
4352 |
|
4353 |
|
4354 |
|
4355 | function locat () {
|
4356 | return staticLocation ? parseUrl(staticLocation.href) : {}
|
4357 | }
|
4358 |
|
4359 |
|
4360 |
|
4361 |
|
4362 |
|
4363 | function isBrowseStorage (storage) {
|
4364 | try {
|
4365 | var testKey = '__xe_t'
|
4366 | storage.setItem(testKey, 1)
|
4367 | storage.removeItem(testKey)
|
4368 | return true
|
4369 | } catch (e) {
|
4370 | return false
|
4371 | }
|
4372 | }
|
4373 |
|
4374 | function isBrowseType (type) {
|
4375 | return navigator.userAgent.indexOf(type) > -1
|
4376 | }
|
4377 |
|
4378 |
|
4379 |
|
4380 |
|
4381 |
|
4382 | function browse () {
|
4383 | var $body, isChrome, isEdge
|
4384 | var isMobile = false
|
4385 | var result = {
|
4386 | isNode: false,
|
4387 | isMobile: isMobile,
|
4388 | isPC: false,
|
4389 | isDoc: !!staticDocument
|
4390 | }
|
4391 | if (!staticWindow && typeof process !== staticStrUndefined) {
|
4392 | result.isNode = true
|
4393 | } else {
|
4394 | isEdge = isBrowseType('Edge')
|
4395 | isChrome = isBrowseType('Chrome')
|
4396 | isMobile = /(Android|webOS|iPhone|iPad|iPod|SymbianOS|BlackBerry|Windows Phone)/.test(navigator.userAgent)
|
4397 | if (result.isDoc) {
|
4398 | $body = staticDocument.body || staticDocument.documentElement
|
4399 | arrayEach(['webkit', 'khtml', 'moz', 'ms', 'o'], function (core) {
|
4400 | result['-' + core] = !!$body[core + 'MatchesSelector']
|
4401 | })
|
4402 | }
|
4403 | assign(result, {
|
4404 | edge: isEdge,
|
4405 | firefox: isBrowseType('Firefox'),
|
4406 | msie: !isEdge && result['-ms'],
|
4407 | safari: !isChrome && !isEdge && isBrowseType('Safari'),
|
4408 | isMobile: isMobile,
|
4409 | isPC: !isMobile,
|
4410 | isLocalStorage: isBrowseStorage(staticWindow.localStorage),
|
4411 | isSessionStorage: isBrowseStorage(staticWindow.sessionStorage)
|
4412 | })
|
4413 | }
|
4414 | return result
|
4415 | }
|
4416 |
|
4417 |
|
4418 |
|
4419 |
|
4420 |
|
4421 |
|
4422 |
|
4423 | function toCookieUnitTime (unit, expires) {
|
4424 | var num = parseFloat(expires)
|
4425 | var nowdate = helperNewDate()
|
4426 | var time = helperGetDateTime(nowdate)
|
4427 | switch (unit) {
|
4428 | case 'y': return helperGetDateTime(getWhatYear(nowdate, num))
|
4429 | case 'M': return helperGetDateTime(getWhatMonth(nowdate, num))
|
4430 | case 'd': return helperGetDateTime(getWhatDay(nowdate, num))
|
4431 | case 'h':
|
4432 | case 'H': return time + num * 60 * 60 * 1000
|
4433 | case 'm': return time + num * 60 * 1000
|
4434 | case 's': return time + num * 1000
|
4435 | }
|
4436 | return time
|
4437 | }
|
4438 |
|
4439 | function toCookieUTCString (date) {
|
4440 | return (isDate(date) ? date : new Date(date)).toUTCString()
|
4441 | }
|
4442 |
|
4443 |
|
4444 |
|
4445 |
|
4446 |
|
4447 |
|
4448 |
|
4449 |
|
4450 |
|
4451 |
|
4452 |
|
4453 |
|
4454 |
|
4455 | function cookie (name, value, options) {
|
4456 | if (staticDocument) {
|
4457 | var opts, expires, values, result, cookies, keyIndex
|
4458 | var inserts = []
|
4459 | var args = arguments
|
4460 | if (isArray(name)) {
|
4461 | inserts = name
|
4462 | } else if (args.length > 1) {
|
4463 | inserts = [assign({ name: name, value: value }, options)]
|
4464 | } else if (isObject(name)) {
|
4465 | inserts = [name]
|
4466 | }
|
4467 | if (inserts.length > 0) {
|
4468 | arrayEach(inserts, function (obj) {
|
4469 | opts = assign({}, setupDefaults.cookies, obj)
|
4470 | values = []
|
4471 | if (opts.name) {
|
4472 | expires = opts.expires
|
4473 | values.push(staticEncodeURIComponent(opts.name) + '=' + staticEncodeURIComponent(isObject(opts.value) ? JSON.stringify(opts.value) : opts.value))
|
4474 | if (expires) {
|
4475 | if (isNaN(expires)) {
|
4476 |
|
4477 | expires = expires.replace(/^([0-9]+)(y|M|d|H|h|m|s)$/, function (text, num, unit) {
|
4478 | return toCookieUTCString(toCookieUnitTime(unit, num))
|
4479 | })
|
4480 | } else if (/^[0-9]{11,13}$/.test(expires) || isDate(expires)) {
|
4481 |
|
4482 | expires = toCookieUTCString(expires)
|
4483 | } else {
|
4484 |
|
4485 | expires = toCookieUTCString(toCookieUnitTime('d', expires))
|
4486 | }
|
4487 | opts.expires = expires
|
4488 | }
|
4489 | arrayEach(['expires', 'path', 'domain', 'secure'], function (key) {
|
4490 | if (!isUndefined(opts[key])) {
|
4491 | values.push(opts[key] && key === 'secure' ? key : (key + '=' + opts[key]))
|
4492 | }
|
4493 | })
|
4494 | }
|
4495 | staticDocument.cookie = values.join('; ')
|
4496 | })
|
4497 | return true
|
4498 | } else {
|
4499 | result = {}
|
4500 | cookies = staticDocument.cookie
|
4501 | if (cookies) {
|
4502 | arrayEach(cookies.split('; '), function (val) {
|
4503 | keyIndex = val.indexOf('=')
|
4504 | result[staticDecodeURIComponent(val.substring(0, keyIndex))] = staticDecodeURIComponent(val.substring(keyIndex + 1) || '')
|
4505 | })
|
4506 | }
|
4507 | return args.length === 1 ? result[name] : result
|
4508 | }
|
4509 | }
|
4510 | return false
|
4511 | }
|
4512 |
|
4513 | function hasCookieItem (value) {
|
4514 | return includes(cookieKeys(), value)
|
4515 | }
|
4516 |
|
4517 | function getCookieItem (name) {
|
4518 | return cookie(name)
|
4519 | }
|
4520 |
|
4521 | function setCookieItem (name, value, options) {
|
4522 | cookie(name, value, options)
|
4523 | return cookie
|
4524 | }
|
4525 |
|
4526 | function removeCookieItem (name, options) {
|
4527 | cookie(name, '', assign({ expires: -1 }, setupDefaults.cookies, options))
|
4528 | }
|
4529 |
|
4530 | function cookieKeys () {
|
4531 | return keys(cookie())
|
4532 | }
|
4533 |
|
4534 | function cookieJson () {
|
4535 | return cookie()
|
4536 | }
|
4537 |
|
4538 | assign(cookie, {
|
4539 | has: hasCookieItem,
|
4540 | set: setCookieItem,
|
4541 | setItem: setCookieItem,
|
4542 | get: getCookieItem,
|
4543 | getItem: getCookieItem,
|
4544 | remove: removeCookieItem,
|
4545 | removeItem: removeCookieItem,
|
4546 | keys: cookieKeys,
|
4547 | getJSON: cookieJson
|
4548 | })
|
4549 |
|
4550 |
|
4551 |
|
4552 | // 核心
|
4553 |
|
4554 | // 对象相关的方法
|
4555 |
|
4556 | // 数组相关的方法
|
4557 |
|
4558 | // 基础方法
|
4559 |
|
4560 | // 数值相关方法
|
4561 |
|
4562 | // 日期相关的方法
|
4563 |
|
4564 | // 字符串相关的方法
|
4565 |
|
4566 | // 函数相关的方法
|
4567 |
|
4568 | // 地址相关的方法
|
4569 |
|
4570 | // 浏览器相关的方法
|
4571 |
|
4572 | assign(XEUtils, {
|
4573 |
|
4574 | assign: assign,
|
4575 | objectEach: objectEach,
|
4576 | lastObjectEach: lastObjectEach,
|
4577 | objectMap: objectMap,
|
4578 | merge: merge,
|
4579 |
|
4580 |
|
4581 | uniq: uniq,
|
4582 | union: union,
|
4583 | sortBy: sortBy,
|
4584 | orderBy: orderBy,
|
4585 | shuffle: shuffle,
|
4586 | sample: sample,
|
4587 | some: some,
|
4588 | every: every,
|
4589 | slice: slice,
|
4590 | filter: filter,
|
4591 | find: find,
|
4592 | findLast: findLast,
|
4593 | findKey: findKey,
|
4594 | includes: includes,
|
4595 | arrayIndexOf: arrayIndexOf,
|
4596 | arrayLastIndexOf: arrayLastIndexOf,
|
4597 | map: map,
|
4598 | reduce: reduce,
|
4599 | copyWithin: copyWithin,
|
4600 | chunk: chunk,
|
4601 | zip: zip,
|
4602 | unzip: unzip,
|
4603 | zipObject: zipObject,
|
4604 | flatten: flatten,
|
4605 | toArray: toArray,
|
4606 | includeArrays: includeArrays,
|
4607 | pluck: pluck,
|
4608 | invoke: invoke,
|
4609 | arrayEach: arrayEach,
|
4610 | lastArrayEach: lastArrayEach,
|
4611 | toArrayTree: toArrayTree,
|
4612 | toTreeArray: toTreeArray,
|
4613 | findTree: findTree,
|
4614 | eachTree: eachTree,
|
4615 | mapTree: mapTree,
|
4616 | filterTree: filterTree,
|
4617 | searchTree: searchTree,
|
4618 |
|
4619 |
|
4620 | hasOwnProp: hasOwnProp,
|
4621 | eqNull: eqNull,
|
4622 | isNaN: isNumberNaN,
|
4623 | isFinite: isNumberFinite,
|
4624 | isUndefined: isUndefined,
|
4625 | isArray: isArray,
|
4626 | isFloat: isFloat,
|
4627 | isInteger: isInteger,
|
4628 | isFunction: isFunction,
|
4629 | isBoolean: isBoolean,
|
4630 | isString: isString,
|
4631 | isNumber: isNumber,
|
4632 | isRegExp: isRegExp,
|
4633 | isObject: isObject,
|
4634 | isPlainObject: isPlainObject,
|
4635 | isDate: isDate,
|
4636 | isError: isError,
|
4637 | isTypeError: isTypeError,
|
4638 | isEmpty: isEmpty,
|
4639 | isNull: isNull,
|
4640 | isSymbol: isSymbol,
|
4641 | isArguments: isArguments,
|
4642 | isElement: isElement,
|
4643 | isDocument: isDocument,
|
4644 | isWindow: isWindow,
|
4645 | isFormData: isFormData,
|
4646 | isMap: isMap,
|
4647 | isWeakMap: isWeakMap,
|
4648 | isSet: isSet,
|
4649 | isWeakSet: isWeakSet,
|
4650 | isLeapYear: isLeapYear,
|
4651 | isMatch: isMatch,
|
4652 | isEqual: isEqual,
|
4653 | isEqualWith: isEqualWith,
|
4654 | getType: getType,
|
4655 | uniqueId: uniqueId,
|
4656 | getSize: getSize,
|
4657 | indexOf: indexOf,
|
4658 | lastIndexOf: lastIndexOf,
|
4659 | findIndexOf: findIndexOf,
|
4660 | findLastIndexOf: findLastIndexOf,
|
4661 | toStringJSON: toStringJSON,
|
4662 | toJSONString: toJSONString,
|
4663 | keys: keys,
|
4664 | values: values,
|
4665 | entries: entries,
|
4666 | pick: pick,
|
4667 | omit: omit,
|
4668 | first: first,
|
4669 | last: last,
|
4670 | each: each,
|
4671 | forOf: forOf,
|
4672 | lastForOf: lastForOf,
|
4673 | lastEach: lastEach,
|
4674 | has: has,
|
4675 | get: get,
|
4676 | set: set,
|
4677 | groupBy: groupBy,
|
4678 | countBy: countBy,
|
4679 | clone: clone,
|
4680 | clear: clear,
|
4681 | remove: remove,
|
4682 | range: range,
|
4683 | destructuring: destructuring,
|
4684 |
|
4685 | // number
|
4686 | random: random,
|
4687 | min: min,
|
4688 | max: max,
|
4689 | commafy: commafy,
|
4690 | round: round,
|
4691 | ceil: ceil,
|
4692 | floor: floor,
|
4693 | toFixed: toFixed,
|
4694 | toNumber: toNumber,
|
4695 | toNumberString: toNumberString,
|
4696 | toInteger: toInteger,
|
4697 | add: add,
|
4698 | subtract: subtract,
|
4699 | multiply: multiply,
|
4700 | divide: divide,
|
4701 | sum: sum,
|
4702 | mean: mean,
|
4703 |
|
4704 | // date
|
4705 | now: now,
|
4706 | timestamp: timestamp,
|
4707 | isValidDate: isValidDate,
|
4708 | isDateSame: isDateSame,
|
4709 | toStringDate: toStringDate,
|
4710 | toDateString: toDateString,
|
4711 | getWhatYear: getWhatYear,
|
4712 | getWhatQuarter: getWhatQuarter,
|
4713 | getWhatMonth: getWhatMonth,
|
4714 | getWhatWeek: getWhatWeek,
|
4715 | getWhatDay: getWhatDay,
|
4716 | getYearDay: getYearDay,
|
4717 | getYearWeek: getYearWeek,
|
4718 | getMonthWeek: getMonthWeek,
|
4719 | getDayOfYear: getDayOfYear,
|
4720 | getDayOfMonth: getDayOfMonth,
|
4721 | getDateDiff: getDateDiff,
|
4722 |
|
4723 | // string
|
4724 | trim: trim,
|
4725 | trimLeft: trimLeft,
|
4726 | trimRight: trimRight,
|
4727 | escape: escape,
|
4728 | unescape: unescape,
|
4729 | camelCase: camelCase,
|
4730 | kebabCase: kebabCase,
|
4731 | repeat: repeat,
|
4732 | padStart: padStart,
|
4733 | padEnd: padEnd,
|
4734 | startsWith: startsWith,
|
4735 | endsWith: endsWith,
|
4736 | template: template,
|
4737 | toFormatString: toFormatString,
|
4738 | toString: toValueString,
|
4739 | toValueString: toValueString,
|
4740 |
|
4741 | // function
|
4742 | noop: noop,
|
4743 | property: property,
|
4744 | bind: bind,
|
4745 | once: once,
|
4746 | after: after,
|
4747 | before: before,
|
4748 | throttle: throttle,
|
4749 | debounce: debounce,
|
4750 | delay: delay,
|
4751 |
|
4752 | // url
|
4753 | unserialize: unserialize,
|
4754 | serialize: serialize,
|
4755 | parseUrl: parseUrl,
|
4756 |
|
4757 | // web
|
4758 | getBaseURL: getBaseURL,
|
4759 | locat: locat,
|
4760 | browse: browse,
|
4761 | cookie: cookie
|
4762 | })
|
4763 |
|
4764 |
|
4765 | return XEUtils
|
4766 | }))
|