JS常见案例

JS常见案例

九九乘法表

外层的 for 循环控制行数，内层的 for 循环控制列数，核心算法：每一行 公式的个数正好和行数一致， j <= i;

var str = "";
for (var i = 1; i <= 9; i++) {
    for (var j = 1; j <= i; j++) {
    	str += j + "*" + i + "=" + i * j + "\t";
    }
    str += "\n";
}
console.log(str);

数组内元素拼接，并用分割符隔开

将数组 [‘red’, ‘green’, ‘blue’, ‘pink’] 转换为字符串，并且用 | 或其他符号分割

var arr = ['red', 'green', 'blue', 'pink'];
var str = '';
var sep = '*';
for (var i = 0; i < arr.length; i++) {
    str += arr[i] + sep;
}
console.log(str);

去除数组内某个元素

将数组[2, 0, 6, 1, 77, 0, 52, 0, 25, 7]中的 0 去掉后，形成一个不包含 0 的新数组

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] != 0) {
    	newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

数组翻转

将数组 [‘red’, ‘green’, ‘blue’, ‘pink’, ‘purple’] 的内容反过来存放

var arr = ['red', 'green', 'blue', 'pink', 'purple', 'hotpink'];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
	newArr[newArr.length] = arr[i]
}
console.log(newArr);

冒泡排序

是一种算法，把一系列的数据按照一定的顺序进行排列显示(从小到大或从大到小)。

例如：将数组[5,4,3,2,1]中的元素按照从小到大的顺序排序，输出:1，2，3，4，5

var arr = [4, 1, 2, 3, 5];
for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数 
    for (var j = 0; j <= arr.length - i - 1; j++) { // 里面的循环管 每一趟的交换次数
        // 内部交换2个变量的值 前一个和后面一个数组元素相比较
         if (arr[j] <  arr[j + 1]) { // 从大到小排列
        // if (arr[j] >  arr[j + 1]) { // 从小到大排列
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}
console.log(arr);

var arr = ['red', 'blue','green' ];
arr.reverse();
console.log(arr);

arr.sort(function (a, b) {
    //  return a - b; 升序的顺序排列
    return b - a; // 降序的顺序排列
});
console.log(arr1);

求可变数组的最大值

利用arguments和函数求可变数组元素的最大值

function getMax() { // arguments = [1,2,3]
    var max = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}
console.log(getMax(1, 2, 3));
console.log(getMax(1, 2, 3, 4, 5));

函数封装：数组翻转

将数组 [‘red’, ‘green’, ‘blue’, ‘pink’, ‘purple’] 的内容反过来存放

function reverse(arr) {
    var newArr = [];
    for (var i = arr.length - 1; i >= 0; i--) {
        newArr[newArr.length] = arr[i];
    }
	return newArr;
}
var arr1 = reverse([1, 3, 4, 6, 9]);
console.log(arr1);
var arr2 = reverse(['red', 'pink', 'blue']);
console.log(arr2);

函数封装：冒泡排序

将数组[5,4,3,2,1]中的元素按照从小到大的顺序排序，输出:1，2，3，4，5

function asc(arr) {
    var temp = arr[0];
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j]
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
function desc(arr) {
    var temp;
    for (var i = 0; i < arr.length - 1; i++) {
        for (var j = 0; j < arr.length - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                temp = arr[j]
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
console.log(asc([2, 3, 5, 1, 4]));
console.log(desc([2, 3, 5, 1, 4]));

函数封装：判断闰年

输入一个年份，判断是否是闰年(闰年:能被4整除并且不能被100整数，或者能被400整除)

function isRunYear(year) {
    // 如果是闰年我们返回 true  否则 返回 false 
    var flag = false;
    if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
        flag = true;
    }
	return flag;
}
console.log(isRunYear(2000));
console.log(isRunYear(1999));

函数封装：获取当前时分秒

封装一个函数返回当前的时分秒 格式 08:08:08

function getTimer() {
    var time = new Date();
    var h = time.getHours();
    h = h < 10 ? '0' + h : h;
    var m = time.getMinutes();
    m = m < 10 ? '0' + m : m;
    var s = time.getSeconds();
    s = s < 10 ? '0' + s : s;
    return h + ':' + m + ':' + s;
}
console.log(getTimer());

倒计时

核心算法∶输入的时间减去现在的时间就是剩余的时间，即倒计时

用时间戳来做。用户输入时间总的亳秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒数。

把剩余时间总的亳秒数转换为天、时、分、秒（时间戳转换为时分秒)

转换公式如下:

d = parseInt(总秒数/60/60/24); //计算天数
h = parselnt(总秒数/66/60%24) //计算小时
m = parselnt(总秒数/60 %60); //计算分数
s = parseInt(总秒数%60); //计算当前秒数

function countDown(time) {
    var nowTime = +new Date(); // 返回的是当前时间总的毫秒数
    var inputTime = +new Date(time); // 返回的是用户输入时间总的毫秒数
    var times = (inputTime - nowTime) / 1000; // times是剩余时间总的秒数 
    var d = parseInt(times / 60 / 60 / 24); // 天
    d = d < 10 ? '0' + d : d;
    var h = parseInt(times / 60 / 60 % 24); //时
    h = h < 10 ? '0' + h : h;
    var m = parseInt(times / 60 % 60); // 分
    m = m < 10 ? '0' + m : m;
    var s = parseInt(times % 60); // 当前的秒
    s = s < 10 ? '0' + s : s;
    return d + '天' + h + '时' + m + '分' + s + '秒';
}
console.log(countDown('2050-1-1 00:00:00'));

函数封装：数组去重

把旧数组里面不重复的元素选取出来放到新数组中， 重复的元素只保留一个， 放到新数组中去重

核心算法： 遍历旧数组， 然后拿着旧数组元素去查询新数组， 如果该元素在新数组里面没有出现过， 我们就添加， 否则不添加。

function unique(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (newArr.indexOf(arr[i]) === -1) {
            newArr.push(arr[i]);
        }
    }
    return newArr;
}
var demo = unique(['blue', 'green', 'blue'])
console.log(demo);

字符串中字符出现位置和次数

查找字符串"abcoefoxyozopp"中所有o出现的位置以及次数。

核心算法:先查找第一个o出现的位置，然后只要indexOf返回的结果不是-1就继续往后查找，因为indexOf只能查找到第一个，所以后面的查找，利用第二个参数，当前索引加1，从而继续查找

var str = "oabcoefoxyozzopp";
var index = str.indexOf('o');
var num = 0;
// console.log(index);
while (index !== -1) {
    console.log("o出现的索引为：" + index);
    num++;
    index = str.indexOf('o', index + 1); // 查询的字符串后面没有o，index的值才为-1 
}
console.log('o出现的次数是: ' + num);

字符串中出现次数最多的字符，并统计其次数

判断一个字符串"abcoefoxyozzopp’中出现次数最多的字符，并统计其次数。

核心算法：利用charA(）遍历这个字符串，把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1

// 遍历对象，得到最大值和该字符
var str = 'abcoefoxyozzopp';
var o = {};
for (var i = 0; i < str.length; i++) {
    var chars = str.charAt(i); // chars 是 字符串的每一个字符
    if (o[chars]) { // o[chars] 得到的是属性值
    	o[chars]++; // 有o.chars属性，0.chars的属性值+1
    } else {
    	o[chars] = 1; // 没有o.chars属性，0.chars的属性值赋值为1
    }
}
console.log(o);
// 遍历对象，获取最大值
var max = 0;
var ch = '';
for (var k in o) {  // k 得到是 属性名，o为对象，o[k] 得到的是属性值
    if (o[k] > max) {
        max = o[k]; //
        ch = k;
    }
}
console.log(max);
console.log('最多的字符是' + ch);