javascript项目开发中的常用公共方法

本篇文章纯属干货，包含了笔者在实际项目开发中经常用到的一些公共通用方法，希望可以帮助大家。

部分方法适用ReactNative

import {
    PixelRatio,
    Dimensions,
    Platform,
    findNodeHandle,
    UIManager
} from 'react-native';

/**
 * 日期格式化函数
 * @param {} date 
 */

function formatNumber(n) {
    n = n.toString()
    return n[1] ? n : '0' + n
}

export function formatDate(date, type) {
    var year = date.getFullYear()
    var month = date.getMonth() + 1
    var day = date.getDate()

    var hour = date.getHours()
    var minute = date.getMinutes()
    var second = date.getSeconds()

    if (type = 'YYYY-MM-DD') {
        return [year, month, day].map(formatNumber).join('-')
    }
    else {
        return [year, month, day].map(formatNumber).join('-') + ' ' + [hour, minute, second].map(formatNumber).join(':')
    }
}



//获取设备屏幕的实际宽度

export const deviceW = Dimensions.get('window').width;
export const deviceH = Dimensions.get('window').height;


// 设置自适应字体,以iphone6为例
const basePx = 375

export function px2dp(px) {
    return px * deviceW / basePx
}

/**
 * 判断是否为iphoneX
 * @returns {boolean}
 */
 
const X_WIDTH = 375;
const X_HEIGHT = 812;

export function isIphoneX() {
    return (
        Platform.OS === 'ios' &&
        ((deviceH >= X_HEIGHT && deviceW >= X_WIDTH) ||
            (deviceH >= X_WIDTH && deviceW >= X_HEIGHT))
    )
}


/**
 * 根据是否是iPhoneX返回不同的样式
 * @param iphoneXStyle
 * @param iosStyle
 * @param androidStyle
 * @returns {*}
 */

export function ifIphoneX(iphoneXStyle, iosStyle, androidStyle) {
    if (isIphoneX()) {
        return iphoneXStyle;
    } else if (Platform.OS === 'ios') {
        return iosStyle
    } else {
        if (androidStyle) return androidStyle;
        return iosStyle
    }
}


//判断设备是否是ios平台
export const isIphone = Platform.OS == 'ios' ? true : false

/** 
 * 返回精确的n位小数数值
 * @param num:number
 * @param dig:number
*/

export function digitToFixed(num, digit = 2) {
	// NaN，undefined，空值
    if (typeof (num) == 'undefined') {
        return '0.00'
    }
    else {
        return parseFloat(num).toFixed(digit)
    }
}

/** 
 * 返回账户金额，每隔三位数字添加一个逗号
 * @param str:string

*/

export function threeNumberAPointer(str) {
    return parseFloat(str).toFixed(2).replace(/\d(?=(?:\d{3})+\b)/g, `$&,`)
}

/**
 * 将银行卡末尾n位数字截取出来
 *  @param cardCode:string 银行卡号
 *  @param digit:num  截取长度
*/

export function bankCardLastNum(cardCode, digit = 4) {
    return cardCode.substring(cardCode.length - digit, cardCode.length)
}

/**
*获取react-native-element元素的宽度和高度等信息
* @param ref:ref 组件ref
*/

export function getRnElementInfo(ref) {
    const handle = findNodeHandle(ref);
    return new Promise((resolve) => {
        UIManager.measure(handle, (x, y, width, height, pageX, pageY) => {
            resolve({
                x,
                y,
                width,
                height,
                pageX,
                pageY
            });
        });
    });
}

/** 
 * 返回银行卡号，每隔四个数字添加一个空格
 * @param str:string

*/
export function formatBankCard(str) {
    let newStr = str.replace(/\d(?=(?:\d{4})+\b)/g, `$& `);
    return String(newStr)
}

//判断参数的类型

const Types = {

  isPrototype( data ) {
    return Object.prototype.toString.call(data).toLowerCase()
  },

  isArray( data ) {
    return this.isPrototype( data ) === '[object array]'
  },

  isJSON( data ) {
    return this.isPrototype( data ) === '[object object]'
  },

  isFunction( data ) {
    return this.isPrototype( data ) === '[object function]'
  },

  isString( data ) {
    return this.isPrototype( data ) === '[object string]'
  },

  isNumber( data ) {
    return this.isPrototype( data ) === '[object number]'
  },

  isUndefined( data ) {
    return this.isPrototype( data ) === '[object undefined]'
  },

  isNull( data ) {
    return this.isPrototype( data ) === '[object null]'
  }

}

/*
 * @desc 按照给定参数类型对数组进行排序
 * 使用方法 Array.sort(sortBy(param,1))
 * @param {string} attr 需要进行排序的属性
 * @param {any} rev 进行升序还是降序排列
*/
export function sortBy(attr, rev) {
    //第二个参数没有传递 默认升序排列
    if (rev == undefined) {
        rev = 1;
    } else {
        rev = (rev) ? 1 : -1;
    }

    return function (a, b) {
        a = a[attr];
        b = b[attr];
        if (a < b) {
            return rev * -1;
        }
        if (a > b) {
            return rev * 1;
        }
        return 0;
    }
}

/**
 *  @desc 通过指定key 使用reduce方法对数组去重并返回新数组
 *  使用方法 newArr = singleArray(oldArr,label)
 *  @param {array} arr 需要进行去重的数组
 *  @param {string} label 数组中唯一的key标识
*/
 export function singleArray(arr, label) {
    let obj = {}
    return arr.reduce(function (item, next) {
      let key = next[label]
      obj[key] ? '' : obj[key] = true && item.push(next)
        return item
  },[])
}
/*
 * @desc 返回数字的n! 排列可能性
 * 使用方法 factorial(5)——————>5*4*3*2*1 = 120
 * @param {number} n 需要获取的数字值
*/
export function factorial(n) {
  return n ? n * factorial(n - 1) : 1;
}

/* @desc 返回数字的组合值 
 * 使用方法 combination(5,4)————————>5*4*3*2*1/4*3*2*1 = 5
 * @param {number} m 下标 
 * @param {number} n 上标
*/
export function combination(m, n) {
   if (n == 1 || (m - n) == 1) {
      return m
   }
   return factorial(m) / factorial(m - n)
}
/*
 * @desc 字符串翻转
 * 使用方法 reverseStr(str)
 * @param {string} str 需要转化的字符串
*/
export function reverseStr(str){
   str = str.toString()
   //转化为数组 然后翻转 然后转化为字符串
   return str.split('').reverse().join('')
}

/*
 * @desc 回文算法 指一个字符串忽略标点符号、大小写和空格，正着读和反着读一模一样。
 * 使用方法 palindrome(str) ——————>palindrome("eye") true
 * @param {string} str 需要判断的字符串
*/
export function palindrome(str) {
   //正则含意 \w 为删除所有非字母数字字符 _ 匹配下划线 | 
   str = str.toLowerCase().replace(/_|\W/gi,'')
   return str === reverseStr(str)
}

/**
* @desc 寻找最长的单词算法 
* @return number 
* 使用方法 findLongestWord(str) 
* @param {string} str 需要处理的字符串
* @param {string} reg 字符串切割的方式
*/
function findLongestWord(str,reg = ' ') {
  return str.split(reg).reduce((sum, current) => {
     return Math.max(sum, current.length)
  }, 0)
}
/**
 * @desc 设置首字母大写算法
 * @return string
 * 使用方法 titleCase(str)
 * @param {string} str 需要转化的字符串
*/
function titleCase(str) {
    return str.toLowerCase().split(/\s+/).reduce(function(prev, item) {  
        return prev + (prev.trim() && ' ') + item.slice(0, 1).toUpperCase() + item.slice(1);  
    }, '');  
}
/**
 * @desc 寻找数组中的最大值算法挑战
 * @return array
 * 使用方法 largestOfFour(arr)
 *  largestOfFour([
 *    [4, 5, 1, 3],
 *    [13, 27, 18, 26],
 *    [32, 35, 37, 39],
 *    [1000, 1001, 857, 1]
 *  ]);————————> [5, 27, 39, 1001]
 * @param {array} arr 二维数组
*/
function largestOfFour(arr) {
  let newArr = []
  for (let value of arr){
     newArr.push(value.sort((a,b)=>b-a)[0])
  }
  return newArr
}

/**
 * @desc 确认末尾字符算法 检查一个字符串(str)是否以指定的字符串(target)结尾。
 * @return boolean
 * 使用方法 confirmEnding(str,target)
 * @param {string} str 需要确认的母字符串
 * @param {string} target 用来匹配的子串
*/
export function confirmEnding(str, target) {
   let lastStr = str.slice(str.length - target.length)
   return target === lastStr;
}
/**
 * @desc 重复操作算法 循环拼接一个指定的字符串 num次，如果num是一个负数,则返回一个空字符串。
 * @return string
 * 使用方法 repeat(str,num)
 * @param {string} str 需要重复的字符串
 * @param {number} num 需要重复的次数
*/
export function repeat(str, num) {
   let _str = str
   if(Number(num) < 0 ){
      return ''
   }
   new Array(num-1).fill(1).map(item=>_str+=str)
    return _str         
}
/**
 * @desc 字符串截取算法  如果字符串的长度比给定的参数num长，则把多余的部分用...来表示。
 * 切记，插入到字符串尾部的三个点号也会计入字符串的长度。
 * 然而，如果指定的参数num小于或等于3，则添加的三个点号不会计入字符串的长度。
 * @return string
 * 使用方法 truncate(str,num)
 * @param {string} str 母字符串
 * @param {number} num 判断截取的长度
*/
export function truncate(str, num) {
  let rep = '...',len = 0
  if(num >= str.length){
      return str
  }
  if(num >3){
     len = 3
  }
  return str.slice(0,num - len)+rep;
}
/**
 * @desc 数组分割算法 把一个数组arr按照指定的数组大小size分割成若干个数组块。
 * @return array ————————>chunk([1,2,3,4],2)=[[1,2],[3,4]];
 * 使用方法 chunk(str,num)
 * @param {array} arr 被截取的数组
 * @param {number} size 截成几个子数组
*/
export function chunk(arr, size) {
  const newArr = []
  let tmpArr = []
  arr.forEach((item,index) => {
      tmpArr.push(item)
      if((index+1) % size === 0 || index == arr.length - 1){
         newArr.push(tmpArr)
         tmpArr = []
      }
  })
return newArr
}
/**
 * @desc 数组截断算法 返回一个数组被截断n个元素后还剩余的元素，从索引0开始截断。
 * @return array ————————>slasher([1, 2, 3], 2) = 3;
 * 使用方法 slasher(str,num)
 * @param {array} arr 被截取的数组
 * @param {number} size 截去几个元素
*/
export function slasher(arr, howMany) {
  if(!howMany){
     return arr
   }
  if(howMany > arr.length){
     return []
   }
   return arr.slice(howMany)
}
/**
 * @desc 数组查询算法 如果数组第一个字符串元素包含了第二个字符串元素的所有字符，则函数返回true。(忽略大小写)
 * @return boolean ————————>mutation(["hello", "hey"]) = false;
 * 使用方法 mutation(arr1,arr2)
 * @param {array} arr 判断的数组数据
*/
export function mutation(arr) {
  let pArr = arr[0]
  let cArr = arr[1]
  let count = 0
    for(let val of cArr){
      if(pArr.indexOf(val.toLowerCase()) > -1 || pArr.indexOf(val.toUpperCase()) > -1){
        count++
    }
  }
  return count == cArr.length
}
/**
 * @desc 删除数组中的所有的假值。 
 * @return array ————————>bouncer([7, "ate", "", false, 9]) = [7, "ate", 9];
 * 使用方法 bouncer(arr)
 * @param {array} arr 判断的数组数据
*/
export function bouncer(arr) {
  return arr.filter(item=>!!item);
}
/**
 * @desc 去除数组中任意多个值算法。
 * @return array ————————>destroyer([1, 2, 3, 1, 2, 3], 2, 3) = [1, 1];
 * 使用方法 destroyer(arr)
 * @param {array} arr 数组数据
*/
export function destroyer(arr) {
    //arguments是保存当前函数所有的参数的类数组对象
    //遍历参数数组，与初始数组的每个元素进行比较，返回初始数组中不同的元素
    for (var i = 1; i < arguments.length; i++) {
        arr = arr.filter(item=>arguments[i] !== item)
    }
    return arr
}
/**
 * @desc 数组排序并插入值算法。先给数组排序，然后找到指定的值在数组的位置，最后返回位置对应的索引。
 * @return number ————————>where([5, 3, 20, 3], 5) = 2;
 * 使用方法 where(arr,num)
 * @param {array} arr 数组数据
 * @param {number} num 需要比较的元素
*/
export function where(arr, num) {
   arr.push(num);
   return arr.sort((a, b) => a - b).findIndex(item => item == num);
}
/**
 * @desc 位移密码算法。移位密码也就是密码中的字母会按照指定的数量来做移位。写一个ROT13函数，实现输入加密字符串，输出解密字符串。
 * @return string ————————>rot13("SERR CVMMN!") = "FREE PIZZA!";
 * 使用方法 where(arr,num)
 * @param {string} str 需要解密的字符串
*/
export function rot13(str) {
    //定义一个数组，用来存放解密后的字符
    var newArr = [];
    //遍历参数字符串
    for (var i = 0; i < str.length; i++) {
         // 非字母形式的字符，直接跳过，存入数组newArr中
       if (str.charCodeAt(i) < 65 || str.charCodeAt(i) > 90) {
          newArr.push(str.charAt(i));
       } else if (str.charCodeAt(i) > 77) {
           // 后13个大写字母，减去13
           newArr.push(String.fromCharCode(str.charCodeAt(i) - 13));
       } else {
           // 前13个大写字母，加上13 
           newArr.push(String.fromCharCode(str.charCodeAt(i) + 13));
        }
      }
 return newArr.join("");
}