Javascript 基础编程练习记录

/**
* 合并数组arr1和数组arr2，不能直接修改数组arr，结果返回新的数组
*/

function myConcat(arr1,arr2) {
    return arr1.concat(arr2);
}
function concatTwo(arr1, arr2) {
    let temp = arr1.slice(0);
    [].push.apply(temp, arr2);
}
function concatThree(arr1, arr2) {
    return [...arr1, ...arr2]
}
let arr1 = [1,2,3],
    arr2 = [4,5,6];
console.log(concatThree(arr1, arr2));

 

/**
* 在数组arr的Index 处添加元素item,不要直接修改数组arr,结果返回新的数组
*/

function insert(arr, index, item) {
    let temp = arr.slice(0);
    temp.splice(index,0,item);
    return temp;
}
function insertTwo(arr, index,item) {
    return arr.slice(0,index).concat(item, arr.slice(index))
}
let arr = [1,2,3];
console.log(insertTwo(arr, 1, "new"));

 

/**
* 统计数组arr中值等于item 的元素出现的次数
*/

function countNum(arr, item) {
    let count = 0;
    arr.forEach(index => {
        if (arr[index] === item) {
            count++;
        }
    })
    return count;
}
console.log(countNum([1,2,3,3,4,3,3], 3))
/**

 

* 找出数组中重复出现的元素
*/

function findRepeat(arr) {
   // 先排序再比较或者
    let temp = [];
    arr.sort((a,b) => a-b)
    arr.forEach((item,index) => {
        if (arr[index] === arr[index-1]) {
            temp.push(arr[index])
        }
    });
    return [...(new Set(temp))];
}
function findRepeat2(arr) {
    let temp = [];
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j] && temp.indexOf(arr[i]) === -1) {
                temp.push(arr[i]);
            }
        } 
    }
    return temp;
}
// 数组元素作为辅助对象的索引，出现的次数作为 值，遍历对象，值大于1将该元素取出
function findRepeat3(arr) {
    let temp = [];
    let obj = {};
    arr.forEach((item) => {
        if (obj[item]) {
            obj[item] += 1;
        } else {
            obj[item] = 1;
        }
    });
    Object.getOwnPropertyNames(obj).forEach((item) => {
        if (obj[item] > 1) {
            temp.push(parseInt(item))
        }
    })
    return temp;
}
let arr3 = [1,2,3,4,3,2,4,5,6,7,6,6,6];
console.log(findRepeat3(arr3));

/**
* 为数组中的每个元素求二次方，不直接修改原数组，返回新数组
*/

function arrPow(arr) {
    let temp = [];
    arr.forEach((item, index) => {
        temp.push(Math.pow(item, 2))
    });
    return temp;
}
let array = [1,2,3,4];
console.log(arrPow(array));

/**
* 在数组arr中，查找值与item相等的元素出现的所有位置
*/

function equalIndex(arr, item) {
    let temp = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === item) {
            temp.push(i);
        }
    }
    return temp;
}
let a = [1,2,3,4,5,6,4,3,2,3,2,2,2];
console.log(equalIndex(a,2));

 

/**
* 实现一个打点记时器，要求1、从start到end ，每隔100毫秒console.log 一个数字。每次数字增幅为1
*                    2、返回值需要包含一个cancel方法，用于停止定时操作
*                    3、第一个数需要立即输出
*/

function printPoint(start,end) {
    let timeId = null;
    console.log(start++);
     timeId = setInterval(function () {
       if (start <= end) {
           console.log(start++);
       }
    },100)
    return {
        cancel:  () => {
            clearInterval(timeId);
        }
    };
}
printPoint(1,10);

 

/**
* 实现fizzBuzz函数，参数num 与返回值的关系如下：1、如果num能同时被3和5整除，返回字符串 fizzbuzz;
*                  如果num能被3整除，返回字符串fizz；如果能被5整除，返回字符串buzz
*                  如果参数为空或者不是Number类型，返回false；
*                  其余情况，返回num参数
*/

function fizzBuzz(num) {
    if (num === null || (typeof num ) !== Number) {
        return false;
    } else if (num % 3 === 0 && num % 5 === 0) {
        return 'fizzbuzz';
    } else if (num % 3 === 0) {
        return 'fizz';
    } else if (num % 5 === 0) {
        return 'buzz';
    }
    else {
        return num;
    }
}

 

/**
* 返回数字num二进制形式弟bit位的值，注意：bit从1开始，返回0或1 ，2 的二进制位 10 ，则第一位为0，第二位为1
*/

function numbBit(num, bit) {
   let temp = num.toString(2);
   if (bit <= temp.length) {
       return temp[temp.length - bit];
   } else {
       return false;
   }
}
console.log(numbBit(10,3));

 

/**
* 给定二进制字符串，将其换算成对应的十进制数字
*/

function twoToTen(str) {
    return parseInt(str,2);  // 第二个参数表示以二进制形式解析字符串
}
console.log(twoToTen('1001011'));

/**
* 将给定的数字转换成二进制字符串，如果字符串长度不足8位，则在前面补0到满8位
*/

function numB(num) {
    let temp = num.toString(2);
    if (temp.length < 8) {
        let count = 8 - temp.length;
        for (let i = count; i > 0; i--) {
            temp = '0' + temp;
        }
    }
    return temp;
}
function numB2(num) {
    let temp = num.toString(2);
    return '00000000'.slice(temp.length) + temp;
}
console.log(numB2(10));

 

/**
* 给定字符串str,检查其是否含有数字，包含返回true,否则返回false
*/

function hasNum(str) {
    return /\d+/.test(str);
}
console.log(hasNum('ugfhw1ghujhf'));

 

/**
* 给定字符串str，检查其是否包含重复的字母（a-zA-Z）,包含返回true，否则返回false
*/

function hasLetter(str) {
    return /([a-zA-Z])\1/.test(str);
}
console.log(hasLetter('123w234ee345'));

 

/**
* 给定字符串str,检查其是否以元音字母结尾
* 元音字母包括a,e,i,o,u 及其对应的大写
* 包含返回true,不包含返回false
*/

function yuanLetter(str) {
    let pattern = /[aeiou]/gi;
    return pattern.test(str);
}
console.log(yuanLetter('qwtryp'));

/**
* 给定字符串str,检查是否包含如下格式
* XXX-XXX-XXXX  X为Number 类型
*/

function testStr(str) {
    return /\d{3}-\d{3}-\d{4}/.test(str);
}
console.log(testStr('112-222-4444'));