1. //单对象模式，也叫做命名空间模式
    2. var MyFunctions = {
    3.     /**
    4.      * 判断一个数是不是奇数
    5.      * @param {number} n 要判断的数字
    6.      * @returns {boolean}
    7.      */
    8.     isOdd: function (n) {
    9.         return n % 2 !== 0;
    10.     },
    12.     /**
    13.      * 判断一个数是不是素数
    14.      * @param {*} n 
    15.      */
    16.     isPrime: function (n) {
    17.         if (n < 2) {
    18.             return false;
    19.         }
    20.         for (var i = 2; i < n; i++) {
    21.             if (n % i === 0) {
    22.                 return false;
    23.             }
    24.         }
    25.         return true;
    26.     },
    28.     /**
    29.      * 对数组求和
    30.      * @param {*} arr 
    31.      */
    32.     sumOfArray: function (arr) {
    33.         var sum = 0;
    34.         for (var i = 0; i < arr.length; i++) {
    35.             sum += arr[i];
    36.         }
    37.         return sum;
    38.     },
    40.     /**
    41.      * 得到数组中的最大值，如果数组长度为0，则返回undefined
    42.      * @param {*} arr 
    43.      */
    44.     maxOfArray: function (arr) {
    45.         if (arr.length === 0) {
    46.             return;
    47.         }
    48.         var max = arr[0];
    49.         for (var i = 1; i < arr.length; i++) {
    50.             if (arr[i] > max) {
    51.                 max = arr[i];
    52.             }
    53.         }
    54.         return max;
    55.     },
    58.     /**
    59.      * 得到数组中的最小值，如果数组长度为0，则返回undefined
    60.      * @param {*} arr 
    61.      */
    62.     minOfArray: function (arr) {
    63.         if (arr.length === 0) {
    64.             return;
    65.         }
    66.         var min = arr[0];
    67.         for (var i = 1; i < arr.length; i++) {
    68.             if (arr[i] < min) {
    69.                 min = arr[i];
    70.             }
    71.         }
    72.         return min;
    73.     },
    75.     /**
    76.      * 判断一个数组是不是稀松数组
    77.      * @param {*} arr 
    78.      */
    79.     hasEmptyInArray: function (arr) {
    80.         // 稀松数组的特点：下标连续
    81.         for (var i = 0; i < arr.length; i++) {
    82.             if (!(i in arr)) {
    83.                 return true;
    84.             }
    85.         }
    86.         return false;
    87.     },
    89.     /**
    90.      * 判断某年是不是闰年
    91.      * @param {*} year 
    92.      */
    93.     isLeap: function (year) {
    94.         // 4年一闰，百年不闰；400年一闰
    95.         return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
    96.     },
    98.     /**
    99.      * 得到某年某月的天数
    100.      * @param {*} year 
    101.      * @param {*} month 
    102.      */
    103.     getDays: function (year, month) {
    104.         if (month === 2) {
    105.             return this.isLeap(year) ? 29 : 28;
    106.         }
    107.         else if (month < 8 && this.isOdd(month) || month >= 8 && !this.isOdd(month)) {
    108.             return 31;
    109.         }
    110.         else {
    111.             return 30;
    112.         }
    113.     },
    115.     /**
    116.      * 得到数组中出现频率最高的数字或字符串和频率
    117.      * 返回一个对象
    118.      * @param {*} arr 
    119.      */
    120.     getTopFreqInArray: function (arr) {
    121.         var records = {}; //记录出现频率
    122.         for (var i = 0; i < arr.length; i++) {
    123.             var n = arr[i];
    124.             if (records[n]) {
    125.                 records[n]++;
    126.             }
    127.             else {
    128.                 records[n] = 1;
    129.             }
    130.         }
    131.         var result; //记录最终结果的对象
    132.         for (var prop in records) {
    133.             if (!result || records[prop] > result.frequency) {
    134.                 result = {
    135.                     number: prop,
    136.                     frequency: records[prop]
    137.                 };
    138.             }
    139.         }
    140.         return result;
    141.     },
    143.     /**
    144.      * 给指定的数组升序排序
    145.      * @param {*} arr 
    146.      * @param {Function} compare 比较大小，
    147.      * 该函数有两个参数，代表数组中的两个元素，
    148.      * 该函数返回一个数字，如果是正数，则第一个元素比第二个元素大，
    149.      * 如果是0，则相等，
    150.      * 如果是负数，则第一个元素比第二个元素小
    151.      */
    152.     sort: function (arr, compare) {
    153.         if (!compare) {
    154.             compare = function (a, b) {
    155.                 if (a > b) {
    156.                     return 1;
    157.                 }
    158.                 else if (a === b) {
    159.                     return 0;
    160.                 }
    161.                 else {
    162.                     return -1;
    163.                 }
    164.             }
    165.         }
    167.         for (var i = 1; i < arr.length; i++) {
    168.             for (var j = 0; j < arr.length - i; j++) {
    169.                 //比较arr[j] 和 arr[j+1]
    170.                 if (compare(arr[j], arr[j + 1]) > 0) {
    171.                     //交换
    172.                     var temp = arr[j];
    173.                     arr[j] = arr[j + 1];
    174.                     arr[j + 1] = temp;
    175.                 }
    176.             }
    177.         }
    178.     },
    179.     /**
    180.      * 筛选数组
    181.      * @param {*} arr 
    182.      * @param {Function} callback 回调函数，接收两个参数，
    183.      * 分别表示数组的某一项和其下标，返回boolean
    184.      * 满足条件返回true，否则返回false
    185.      */
    186.     filter: function (arr, callback) {
    187.         //遍历数组，看每一项是否满足条件
    188.         var newArr = [];
    189.         for (var i = 0; i < arr.length; i++) {
    190.             if (callback(arr[i], i)) {
    191.                 newArr.push(arr[i]);
    192.             }
    193.         }
    194.         return newArr;
    195.     },
    196.     /**
    197.      * 从指定的数组中，查找第一个满足条件的元素，如果没有找到，返回undefined
    198.      * @param {*} arr 
    199.      * @param {*} callback 回调函数，接收两个参数，
    200.      * 分别表示数组的某一项和其下标，返回boolean
    201.      * 满足条件返回true，否则返回false
    202.      */
    203.     find: function (arr, callback) {
    204.         for (var i = 0; i < arr.length; i++) {
    205.             if (callback(arr[i], i)) {
    206.                 return arr[i];
    207.             }
    208.         }
    209.     },
    210.     /**
    211.      * 按照指定的条件，得到某个数组中满足条件的元素数量
    212.      * @param {*} arr 
    213.      * @param {*} callback 回调函数，接收两个参数，
    214.      * 分别表示数组的某一项和其下标，返回boolean
    215.      * 满足条件返回true，否则返回false
    216.      */
    217.     count: function (arr, callback) {
    218.         var num = 0;
    219.         for (var i = 0; i < arr.length; i++) {
    220.             if (callback(arr[i], i)) {
    221.                 num++;
    222.             }
    223.         }
    224.         return num;
    225.     },
    226.     /**
    227.      * 得到一个最小值到最大值之间的随机整数
    228.      * @param {*} min 最小值
    229.      * @param {*} max 最大值
    230.      */
    231.     getRandom: function (min, max) {
    232.         return Math.floor(Math.random() * (max + 1 - min) + min);
    233.     },
    234.     /**
    235.      * 根据出生年月日，计算年龄
    236.      * @param {*} year 
    237.      * @param {*} month 
    238.      * @param {*} day 
    239.      */
    240.     getAge: function (year, month, day) {
    241.         //得到当前日期
    242.         var now = new Date();
    243.         var dec = now.getFullYear() - year;
    244.         //处理闰年
    245.         if (month === 2 && day === 29 && !this.isLeap(now.getFullYear())) {
    246.             day = 28;
    247.         }
    248.         //得到今年的生日
    249.         var birthdayThisYear = new Date(now.getFullYear(), month - 1, day);
    250.         if (birthdayThisYear > now) {
    251.             dec--;
    252.         }
    253.         return dec;
    254.     },
    255.     getDateString: function (date) {
    256.         var year = date.getFullYear().toString().padStart(4, "0");
    257.         var month = (date.getMonth() + 1).toString().padStart(2, "0");
    258.         var day = date.getDate().toString().padStart(2, "0");
    260.         var hour = date.getHours().toString().padStart(2, "0");
    261.         var minute = date.getMinutes().toString().padStart(2, "0");
    262.         var second = date.getSeconds().toString().padStart(2, "0");
    264.         return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
    265.     }
    266. }