Loadsh 常用方法總結以及在vue中使用Loadsh

Lodash 是一個一致性、模塊化、高性能的 JavaScript 實用工具庫。處理復雜數組，對比等可以直接采用該庫，也方便快捷。

官方網站

https://www.lodashjs.com/

一. 在vue中使用Loadsh中的節流函數 debounce和throttle

.throttle是lodash中的節流函數,.debounce是lodash中的防抖函數。
具體作用可以直接看官方文檔。

在vue中具體怎么用

import _ from 'lodash'
export default{
 methods:{
    click:_.throttle(function(){
            console.log('test')
            console.log(this)
    },1000)
 }
}
import _ from 'lodash'
export default{
 methods:{
 onUpdateNote: _.debounce(function() {
      this.updateNote({ noteId: this.curNote.id, title: this.curNote.title, content: this.curNote.content })
        .then(data => {
          this.statusText = '已保存'
        }).catch(data => {
          this.statusText = '保存出錯'
        })
    }, 300)
}

在lodash的throttle，debounce方法中,可以直接使用function,而且無需重新指向this,在函數內部中已經做了apply,所以這里的this指向的就是vue實例,對已有函數的外面包一層.throttle/.debounce就可以了。

二.另外一種方法在vue中使用debounce和throttle

1、安裝

cnpm i lodash -S

2、方法一 全局使用

• 引入

import _ from 'lodash'
Vue.prototype._ = _

• 使用

this._.debounce(this.handleClick,1000,false)

3、方法二 局部使用

• 引入

let _ = require('lodash')

• 使用

_.debounce(this.handleClick,1000,false)

4、vue單文件組件中使用

里面分別有我自己寫的debounce函數和lodash的debounce函數，效果一樣！

<template>
  <div>
    <el-button @click="myDebounce">我的debounce</el-button>
    <el-button @click="_debounce">lodash的debounce</el-button>
  </div>
</template>

<script>
import { debounce } from '@/utils/util'
let _ = require('lodash')
export default {
  methods: {
    handleClick1() {
      console.log(`真正執行的函數，次數比較少：handleClick1.....`)
    },
    handleClick2() {
      console.log(`真正執行的函數，次數比較少：handleClick2.....`)
    },
    myDebounce() {
      console.log(`myDebounce.....`)
      this.DB()
    },
    _debounce() {
      console.log(`_debounce.....`)
       this._DB()
    }
  },
  created() {
    this.DB = debounce(this.handleClick1, 1000, false)
    this._DB = this._.debounce(this.handleClick2,1000,false)
  }
}
</script>

注意：以前我是在data選項里面定義，然后再methods里面初始化函數，但是需要判斷‘如果有了就不賦函數，如果為空就賦’，發現比較麻煩；后來直接在created鈎子里面定義，就很方便了！或者掛載之后。

三. Loadsh學習筆記

有多年開發經驗的工程師，往往都會有自己的一套工具庫，稱為utils、helpers等等，這套庫一方面是自己的技術積累，另一方面也是對某項技術的擴展，領先於技術規范的制訂和實現。

Lodash就是這樣的一套工具庫，它內部封裝了諸多對字符串、數組、對象等常見數據類型的處理函數，其中部分是目前ECMAScript尚未制訂的規范，但同時被業界所認可的輔助函數。莫倩每天使用npm安裝Lodash的數量在百萬級以上，這在一定程度上證明了其代碼的健壯性，值得我們在項目中一試。

模塊組成

Lodash聽得輔助函數主要分為以下幾類，函數列表和用法實力請查看Lodash的官方文檔：

• Array， 適合於數組類型，比如填充數據、查找元素、數組分片等操作
• Collocation， 適用於數組和對象類型，部分適用於字符串，比如分組、查找、過濾等操作
• Function， 適用於函數類型，比如節流、延遲、緩存、設置鈎子等操作
• Lang， 普遍適用於各種類型，常用於執行類型判斷和類型轉換
• Math， 使用與數值類型，常用於執行數學運算
• Number， 適用於生成隨機數，比較數值與數值區間的關系
• Object， 適用於對象類型，常用於對象的創建、擴展、類型轉換、檢索、集合等操作
• Seq， 常用於創建鏈式調用，提高執行性能（惰性計算）
• String， 適用於字符串類型
• lodash/fp 模塊提供了更接近函數式編程的開發方法，其內部的函數經過包裝，具有immutable、auto-curried、iteratee-first、data-last（官方介紹）等特點。
• Fixed Arity，固化參數個數，便於柯里化
• Rearragned Arguments， 重新調整參數位置，便於函數之間的聚合
• Capped Iteratee Argument， 封裝Iteratee參數

在React + Webpack + Babel(ES6)的開發環境中，使用Lodash需要安裝插件babel-plugin-lodash並更新Babel配置文件：

npm install --save lodash
npm install --save-dev babel-plugin-lodash

更新Bable的配置文件 .babelrc:

[](javascript:void(0)😉

{
    "presets":[
        "react",
        "es2015",
        "stage-0"
    ],
    "plugins":[
        "lodash"
    ]
}

[](javascript:void(0)😉

使用方式：

import _ from 'lodash';
import { add } from 'lodash/fp';

const addOne = add(1);
_.map([1, 2, 3], addOne);

性能

在 Filip Zawada的文章《How to Speed Up Lo-Dash ×100? Introducing Lazy Evaluation》中提到了Lodash提高執行速度的思路，主要有三點： Lazy Evaluation、Pipelining和Deferred Execution。下面兩張圖來自Filip的博客：

假設有如上圖所示的問題： 從若干個求中取出三個面值小於10的球。第一步是從所有的求中取出所有面值小於10的球，第二部是從上一步的結果中去三個球。

上圖是另一個解決方案，如果一個球能夠通過第一步，那么就繼續執行第二步，直至結束然后測試下一個球。。。當我們取到三個球之后就中斷整個循環。Filip稱這是Lazy Evaluation Algorithm， 就個人理解這並不全面，他后續提到的Pipelining（管道計算），再加上一個中斷循環執行的算法應該更符合這里的圖示。

此外，使用Lodash的鏈式調用時，只有現實或隱式調用 .value 方法才會對鏈式調用的整個操作進行取值，這種不在聲明時立即求值，而在使用時進行求職的方式，是Lazy Evaluation最大的特點。

九個實例

收益於Lodash的普及程度，使用它可以提高很多人開發時於都代碼的效率，減少彼此之間的誤解（Loss of Consciousness）。在《Lodash: 10 Javascript Utility Functions That You Should Probably Stop Rewriting》一文中，作者列舉了多個常用的Lodash函數，實例演示了使用Lodash的技巧。

1. N次循環

[](javascript:void(0)😉

// 1. Basic for loop.
for(var i = 0; i < 5; i++){
    //...
}

// 2. Using Array's join and split methods
Array.apply(null, Array(5)).forEach(function(){
    //...
});

// Lodash
_.times(5, function(){
    //...
});

[](javascript:void(0)😉

for 語句是執行虛幻的不二選擇，Array.apply也可以模擬循環，但在上面代碼的使用場景下，_.tiems()的解決方法更加簡潔和易於理解。

2. 深層查找屬性值

[](javascript:void(0)😉

// Fetch the name of the first pet from each owner
var ownerArr = [{
    "owner": "Colin",
    "pets": [{"name": "dog1"}, {"name": "dog2"}]
}, {
    "owner": "John",
    "pets": [{"name": "dog3"}, {"name": "dog4"}]
}];

// Array's map method.
ownerArr.map(function(owner){
    return owner.pets[0].name;
});

// Lodash
_.map(ownerArr, "pets[0].name");

[](javascript:void(0)😉

_.map 方法是對原生 map 方法的改進，其中使用 pets[0].name 字符串對嵌套數據取值的方式簡化了很多冗余的代碼，非常類似使用jQuery選擇DOM節點 ul>li>a , 對於前端開發者來說有種久違的親切感。

3. 個性化數組

[](javascript:void(0)😉

// Array's map method.
Array.apply(null, Array(6)).map(function(item, index){
    return "ball_" + index; 
});

// Lodash
_.times(6, _.uniqueId.bind(null, 'ball_'));

// Lodash
_.times(6, _.partial(_.uniqueId, 'ball_'));
// eg. [ball_0, ball_1, ball_2, ball_3, ball_4, ball_6]

[](javascript:void(0)😉

在上面的代碼中，我們要創建一個初始值不同、長度為6的數組，其中 _.uniqueId 方法用於生成獨一無二的標示符（遞增的數字，在程序運行期間保持獨一無二）， _.partial 方法是對 bind 的封裝。

4. 深拷貝

[](javascript:void(0)😉

var objA = {
    "name": "colin"
}

// 常用的方法一般會比較長，循環對象等
// http://stackoverflow.com/questions/4459928/how-to-deep-clone-in-javascript

// Lodash
var objB = _.cloneDeep(objA);
objB === objA // false

[](javascript:void(0)😉

JavaScript 沒有直接提供深拷貝的函數，但是我們可以用其他杉樹來模擬，比如 JSON.parse(JSON.stringify(objectToClone)), 但這種方法要求對象中的屬性值不能是函數。Lodash 中的 _.cloneDeep 函數封裝了深拷貝的邏輯，用起來更加簡潔。

5. 隨機數

[](javascript:void(0)😉

// Native utility method
function getRandomNumber(min, max){
    return Math.floor(Math.random() * (max - min + 1)) + min;
}

getRandomNumber(15, 20);

// Lodash
_.random(15, 20);

[](javascript:void(0)😉

Lodash 的隨機數生成函數更貼近實際開發，ECMAScript 的隨機數生成函數式底層必備的接口，兩者都不可獲取。此外，使用 _.random(15, 20, true) 還可以在15到20之間生成隨機的浮點數。

6. 對象擴展

[](javascript:void(0)😉

// Adding extend function to Object.prototype
Object.prototype.extend = function(obj) {
    for (var i in obj) {
        if (obj.hasOwnProperty(i)) {
            this[i] = obj[i];
        }
    }
};

var objA = {"name": "colin", "car": "suzuki"};
var objB = {"name": "james", "age": 17};

objA.extend(objB);
objA; // {"name": "james", "age": 17, "car": "suzuki"};

// Lodash
_.assign(objA, ojbB);

[](javascript:void(0)😉

_.assign 是淺拷貝， 和ES6新增的 Object.assign 函數功能一致（建議優先使用Object.assign）。

7. 篩選屬性

[](javascript:void(0)😉

// Native method: Remove an array of keys from object
Object.prototype.remove = function(arr) {
    var that = this;
    arr.forEach(function(key){
        delete(this[key]);
    });
};

var objA = {"name": "colin", "car": "suzuki", "age": 17};

objA.remove(['car', 'age']);
objA; // {"name": "colin"}

// Lodash
objA = _.omit(objA, ['car', 'age']);
// => {"name": "colin"}

objA = _.omit(objA, "car");
// => {"name": "colin", "age": 17}

objA = _.omit(objA, _.isNumber);
// => {"name": "colin", "car": "suzuki"};

[](javascript:void(0)😉

大多數情況下，Lodash所提供的輔助函數都會比原聲的函數更貼近開發需求。在上面的代碼中，開發者可以使用數組、字符串以及函數的方式篩選對象的屬性，並且最終會返回一個新的對象，中間執行篩選時不會對舊對象產生影響。

[](javascript:void(0)😉

// Native method: Returning a new object with selected properties
Object.prototype.pick = function(arr) {
    var _this = this;
    var obj = {};
    arr.forEach(function(){
        obj[key] = _this[key];
    });
    
    return obj;
};

var objA = {"name": "colin", "car": "suzuki", "age": 17};

var objB = objA.pick(['car', 'age']);
// => {"car": "suzuki", "age": 17}

// Lodash
var objB = _.pick(objA, ['car', 'age']);
// => {"car": "suzuki", "age":17}

[](javascript:void(0)😉

_.pick 是 _.omit 的相反操作，用於從其他對象中挑選屬性生成新的對象。

8.隨機元素

[](javascript:void(0)😉

var luckDraw = ["Colin", "John", "James", "Lily", "Mary"];

function pickRandomPerson(luckyDraw){
    var index = Math.floor(Math.random() * (luckyDraw.length - 1));
    return luckyDraw[index];
}

pickRandomPerson(luckyDraw); //John

// Lodash
_.sample(luckyDraw); // Colin

// Lodash - Getting 2 random item
_.sample(luckyDraw, 2); // ['John', 'Lily']

[](javascript:void(0)😉

_.sample 支持隨機挑選多個元素並返回新的數組。

9. 針對 JSON.parse 的錯誤處理

[](javascript:void(0)😉

// Using try-catch to handle the JSON.parse error
function parse(str){
    try {
        return JSON.parse(str);
    }
    
    catch(e) {
        return false;
    }
}

// With Lodash
function parseLodash(str){
    return _.attempt(JSON.parse.bind(null, str));
}

parse('a');
// => false
parseLodash('a');
// => Return an error object

parse('{"name": "colin"}');
// => Return {"name": "colin"}
parseLodash('{"name": "colin"}');
// => Return {"name": "colin"}

[](javascript:void(0)😉

如果你在使用 JSON.parse 時沒有預置錯誤處理，那么它很有可能會成為一個定時炸彈，我們不應該默認接收的JSON對象都是有效的。 try-catch 是常見的錯誤處理方式，如果項目中使用Lodash，那么可以使用 _.attmpt 替代 try-catch 的方式，當解析JSON出錯時，該方法會返回一個 Error 對象。

隨着ES6的普及，Lodash的功能或多或少會被原生功能所替代，所以使用時還需要進一步甄別，建議優先使用原生函數，有關ES6替代Lodash的部分，請參考文章《10 個可用 ES6 替代的 Lodash 特性》。

其中有兩處分廠值得一看：

[](javascript:void(0)😉

// 使用箭頭函數創建可復用的路徑
const object = { 'a': [{ 'b': { 'c': 3 } }, 4] };

[
    obj => obj.a[0].b.c,
    obj => ojb.a[1]
].map(path => path(object));

// 使用箭頭函數編寫鏈式調用
const pipe = function => data => {
    return functions.reduce(
        (value, func) => func(value),
        data
    );
};

const pipeline = pipe([
    x => x * 2,
    x => x / 3,
    x => x > 5,
    b => !b
]);

pipeline(5);
// true
pipeline(20);
// false

[](javascript:void(0)😉

在ES6中，如果一個函數只接收一個形參且函數提示一個 return 語句， 就可以使用箭頭函數簡化為：

[](javascript:void(0)😉

const func = p => v;

// 類似於（不完全相同）
const func = function(p) {
    return v;
}

[](javascript:void(0)😉

當有多重嵌套時，可以簡化為：

[](javascript:void(0)😉

const func = a => b => c => a + b + c;
func(1)(2)(3);
// => 6

// 類似於
const func = function (a) {
    return function (b) {
        return function (c) {
            return a + b + c;
        }
    }
}

[](javascript:void(0)😉

四. Loadsh 常用方法總結

日常開發中，通常會對數據，特別是數組和對象進行各種讀寫等操作：比如去重，拷貝，合並，過濾，求交集，求和等等。根據平時開發中對數據的操作，我對Lodash常見的用法做了以下總結，方便今后的學習和整理。

Array

Create

• 創建一個數組，元素為0, 1, 2, ... , 23

  _.range([start=0], end, [step=1])

  let arr = _.range(24)
  
  console.log(arr) // [0, 1, 2, 3, ... , 23]
  

• 創建一個數組，元素為100, 100, 100, 100, 100

  _.fill(array, value, [start=0], [end=array.length])

  let arr = _.fill(Array(5), 100)
  
  console.log(arr) // [100, 100, 100, 100, 100]
  

Read

• 獲取數組中最后一個元素

  _.last(array)

  let arr = [1, 2, 3, 4, 5]
  let lastElement = _.last(arr) 
  
  console.log(lastElement) // 5
  

• 獲取數組中倒數第二個元素

  _.nth(array, [n=0])

  let arr = [1, 2, 3, 4, 5]
  let lastSecondElement = _.nth(-2) 
  
  console.log(lastSecondElement) // 4
  

• 獲取對象數組中某一同名屬性的屬性值集合

  .map(collection, [iteratee=.identity])

  let users = [{
        id: 12,
        name: 'Adam',
        hobbies: [
          {name: 'running', index: 100},
          {name: 'cycling', index: 95}
        ]
     },{
        id: 14,
        name: 'Bob',
        hobbies: [
          {name: 'movie', index: 98},
          {name: 'music', index: 85}
        ]
     },{
        id: 16,
        name: 'Charlie',
        hobbies: [
         {name: 'travelling', index: 90},
         {name: 'fishing', index: 88}
        ]
     },{
        id: 18,
        name: 'David',
        hobbies: [
         {name: 'walking', index: 99},
         {name: 'football', index: 85}
       ]                
  
  
     }
  ]
  let userIds = _.map(users, 'id')
  let mostFavouriteHobbies = _.map(users, 'hobbies[0].name')
  
  console.log(userIds) // [12, 14, 16, 18]
  console.log(mostFavouriteHobbies) // ["running", "movie", "travelling", "walking"]
  

• 獲取對象數組中某一屬性值最大的對象

  .maxBy(array, [iteratee=.identity])

  let arr = [{a:1, b: 2, c: {d:4}}, {a:3, b: 4, c: {d:6}}]
  let maxBObj = _.maxBy(arr, 'b')
  
  console.log(maxBObj) // {a: 3, b: 4, c: {d: 6}}
  

• 找出兩個數組中元素值相同的元素

  _.intersection([arrays])

  let arr1 = [2, 1, {a: 1, b: 2}]
  let arr2 = [2, 3, {a: 1, b: 2}]
  let intersection = _.intersection(arr1, arr2) 
  
  console.log(intersection) // [2]
  

• 求數值數組中元素值的平均數

  _.mean(array)

  let numbers = [1, 2, 3, 4, 5]
  let average = _.mean(numbers)
  
  console.log(average) // 3
  

• 求對象數組中某個屬性值的平均數

  .meanBy(array, [iteratee=.identity])

  let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
  let average = _.meanBy(objects, 'n')
  
  console.log(average) // 5
  

• 獲取數組中前n個元素，不改變原數組

  _.take(array, [n=1])

  let arr = [1, 2, 3, 4, 5]
  let part1Arr = _.take(arr, 4)
  let part2Arr = _.take(arr, 6)
  let part3Arr = _.take([], 5)
  
  console.log(part1Arr) // [1, 2, 3, 4]
  console.log(part2Arr) // [1, 2, 3, 4, 5]
  console.log(part3Arr) // []
  

Delete

• 刪除數組中值為falsy的元素

  _.compact(array)

  let arr = [0, 1, false, 2, '', 3, null, undefined, NaN]
  let truthyArr = _.compact(arr) 
  
  console.log(truthyArr) // [1, 2, 3]
  

Format

• 去重。

  _.uniq(array)

  let arr = [2, 1, 2, '2', true]
  let uniqArr = _.uniq(arr)
  
  console.log(uniqArr) // [2, 1, '2', true]
  

• 排序。對象數組，根據對象中的某個屬性的值，升序或降序排序

  .orderBy(collection, [iteratees=[.identity]], [orders])

  let users = [
    {user: 'Tom', age: 25},
    {user: 'Amy', age: 23},
    {user: 'Perter', age: 22},
    {user: 'Ben', age: 29}
  ]
  let sortedUsers = _.orderBy(users, 'age', 'desc')
  
  console.log(sortedUsers)
  // [{user: "Ben", age: 29}, {user: "Tom", age: 25}, {user: "Amy", age: 23}, {user: "Perter", age: 22}]
  

• 分割數組[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]為 [1, 2, 3, 4, 5] 和 [6, 7, 8, 9, 10]

  _.chunk(array, [size=1])

  let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  let [left, right] = _.chunk(arr, 5)
  
  console.log(left) // [1, 2, 3, 4, 5]
  console.log(right) // [6, 7, 8, 9, 10]
  

• 脫掉一層[]

  _.flatten(array)

  let address = {
    '江蘇省': ['南京市', '蘇州市'],
    '浙江省': ['杭州市', '紹興市']
  }
  let cities = _.flatten(_.values(address))
  
  console.log(cities) // ["南京市", "蘇州市", "杭州市", "紹興市"]
  

• 將多維數組轉為一維數組

  _.flattenDeep(array)

  let flattenedArr = _.flattenDeep([1, [2, [3, [4]], 5]]);
  
  console.log(flattenedArr) // [1, 2, 3, 4, 5]
  

Object

Create

• 通過數組["x", "y"] 和 數組[10, 10] 創建對象 {x: 10, y: 10}

  _.zipObject([props=[]], [values=[]])

  let keys = ["x", "y"]
  let values = [10, 10]
  let obj = _.zipObject(keys, values) 
  
  console.log(obj) // {x: 10, y: 10}
  

• 合並對象

  _.assign(object, [sources])

  let desObj = {name: '', gender: 'male', job: 'developer'}
  let sourceObj = {name: 'Tom', job: ''}
  let mergedObj = _.assign(desObj, sourceObj)
  
  console.log(mergedObj) // {name: "Tom", gender: "male", job: ""}
  

• 深拷貝對象

  _.cloneDeep(value)

  let sourceObj = {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14]}}
  let desObj = _.cloneDeep(sourceObj)
  desObj.permissions.store.push(15, 16)
  
  console.log(desObj)
  // {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14, 15, 16]}}
  console.log(sourceObj)
  // {department_id: 1, permissions: {management: [1, 2, 3, 4], store: [11, 12, 13, 14]}}
  

• 合並多個對象中key值相同的鍵值對

  _.merge(object, [sources])

  let obj1 = {'9': {name: '樂購超市'}}
  let obj2 = {'9': {storeToken: 'xxx'}}
  let obj3 = {'9': {storePosition: 'Hangzhou'}}
  let mergedObj = _.merge(obj1, obj2, obj3) 
  
  console.log(mergedObj)
  // 9: {name: "樂購超市", storeToken: "xxx", storePosition: "Hangzhou"}
  

Read

• 判斷對象中是否有某個屬性

  _.has(object, path)

  let obj = {a: [{b: {c: 3}}]}
  let hasC = _.has(obj, 'a[0].b.c')
  
  console.log(hasC) // true
  

• 獲取對象中的某個屬性的值

  _.get(object, path, [defaultValue])

  let obj = {a: [{b: {c: 3}}]}
  let c = _.get(obj, 'a[0].b.c')
  
  console.log(c) // 3
  

Update

• 設置對象中的某個屬性的值

  _.set(object, path, value)

  let obj = {a: [{b: {c: 3}}]}
  let newObj = _.set(obj, 'a[0].b.c', 4);
  
  console.log(obj.a[0].b.c); // 4
  

• 對多個對象相同屬性的屬性值求和。

  let customers = {
    new_customer: {0: 33, 1: 5, ... , 23: 0},
    old_customer: {0: 22, 1: 7, ... , 24: 0}
  }
  let customer = {}
  let keys = _.keys(customers.new_customer)
  let values = _.values(customers)
  _.map(keys, key => {
    customer[key] = _.sumBy(values, key)
  })
  
  customers.customer = customer
  
  console.log(customers)
  // console
  {
    customer: {0: 55, 1: 12, ... , 23: 0}
    new_customer: {0: 33, 1: 5, ... , 23: 0}
    old_customer: {0: 22, 1: 7, ... , 23: 0}
  }
  

Number

• 生成一個隨機數，范圍n~m

  _.random([lower=0], [upper=1], [floating])

  let random1 = _.random(2, 5)
  let random2 = _.random(5)
  
  console.log(random1) // 2, 3, 4, 5
  console.log(random2) // 0, 1, 2, 3, 4, 5
  

Data Type

• 判斷數據類型

  _.isNumber(value)

  _.isInteger(value)

  ...

  _.isPlainObject(value)

  let variable = 'hello';
  // Number
  console.log(_.isNumber(variable));
  // Integer
  console.log(_.isInteger(variable));
  // Boolean
  console.log(_.isBoolean(variable));
  // String
  console.log(_.isString(variable));
  // Null
  console.log(_.isNull(variable));
  // Undefined
  console.log(_.isUndefined(variable));
  // Array
  console.log(_.isArray(variable));
  // Function
  console.log(_.isFunction(variable));
  // Object
  console.log(_.isPlainObject(variable));
  // Date
  console.log(_.isDate(variable));
  
  // DOM element
  console.log(_.isElement(variable));
  

• 數據類型轉換

  • _.toArray

    _.toArray('abc') // ["a", "b", "c"]
    

  • _.toInteger

    _.toInteger(3.2); // 3
    _.toInteger('3.2'); // 3
    

  • _.toNumber

    _.toNumber('3.2') // 3.2
    

  • _.toString

    _.toString(1); // "1"
    _.toString([1, 2, 3]); // "1,2,3"
    

Util

• 重復多次某個元素

  .times(n, [iteratee=.identity])

  const dateParams = _.times(2, () => '2018-08-27');
  console.log(dateParams) // ["2018-08-27", "2018-08-27"]