例题归纳

丝白嘚MAN

已于 2024-04-03 09:34:57 修改

阅读量77

点赞数

分类专栏： JavaScript 文章标签： javascript 前端开发语言

于 2023-11-02 20:52:07 首次发布

本文链接：https://blog.csdn.net/qq_54825857/article/details/134189622

版权

JavaScript 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

流程控制语句

流程控制语句

i love china字符串反转

var str = 'i love china';
// 将字符串转为数组 split(' ')
var res = str.split(" ");//['i','love','china']
var result = '';
for (var i = res.length - 1; i >= 0; i--) {
    result += res[i] + ' '
}
console.log(result)		//china love i

1~1000以内完美数

（数本身=因子之和。6=1+2+3）

function perfect(num) {
    // 第一层for循环处理完美数本身 
    for (var i = 1; i <= num; i++) {
        // 拿一个变量求因子之和
        var sum = 0;
        // 处理因子
        for (var j = 1; j < i; j++) {
            if (i % j == 0) {
                sum += j;
            }
        }
        if (i == sum) {
            console.log(i + '是完美数')
        }
    }
}
perfect(1000)
//6是完美数
//28是完美数
//496是完美数

1 2 3 4 组合三位数，个十百位都不相同

for (var i = 1; i <= 4; i++) {
    for (var j = 1; j <= 4; j++) {
        for (var k = 1; k <= 4; k++) {
            if (i != j && i != k && j != k) {
                // console.log(i*100+j*10+k*1)
                console.log(i + '' + j + '' + k)
            }
        }
    }
}
// 123
// 124
// 132
// 134
// 142
// 143
// 213
// 214
// 231
// 234
// 241
// 243
// 312
// 314
// 321
// 324
// 341
// 342
// 412
// 413
// 421
// 423
// 431
// 432

冒泡排序

/**
 * 冒泡排序核心思路：
 *  1.比较相邻两项，将大的往后放，将小的往前放 交换位置
 *  2.每一轮比较后最大的数在最后面 
 *  3.由于最后一个数是最大得数 不参与这一轮比较
 *  外部总共比较多少轮  每一轮比较次数 
 * 
 *  第一轮：20 18 [18,20,27,19,35]
 *         20 27  [18,20,27,19,35]
 *         27 19  [18,20,19,27,35]
 *         27 35  [18,20,19,27,35]
 *  第二轮  18 20 [18,20,19,27,35]
 *          20 19 [18,19,20,27,35]
 *          20 27 [18,19,20,27,35]
 *  第三轮:  18 19 [18,19,20,27,35]
 *          19 20 [18,19,20,27,35]
 *  第四轮  18 19 [18,19,20,27,35]
 */
var arr = [20,18,27,19,35];//进行排序 从小到大排序 
function bSort(arr){
  // 控制外面比较轮数 
  for(var i=0;i<arr.length-1;i++){
    // 控制每一轮比较次数
    for(var j=0;j<arr.length-1-i;j++){
      // 比较前一项和后一项
      if(arr[j]>arr[j+1]){
        //交换位置  把后一项存起来
        var temp = arr[j+1];
        // 把小得往前放 
        arr[j+1] = arr[j];
        arr[j] = temp;
      }
    }
  }
  return arr
}
console.log(bSort(arr));

6的阶乘


function fc(n) {
  // 设置跳出条件
  if(n==1){return 1}
  return n * fc(n - 1)
}
var res = fc(6);
console.log(res)/720/


/**
 * 递归就是函数自身调用自身
 * 使用场景：深拷贝 斐波那契数列 阶乘
 * 6得阶乘  6 * 5 * 4 * 3 * 2 *1 
 * 跳出条件
 */
/** 
 * 1阶乘 1 fc(1)
 * 2 2*fc(1) = fc(2)
 * 3 3*fc(2)
 * 4 4*fc(3)
 * 5 5*fc(4)
 * 6 6*fc(5)
*/

封装函数实现10的阶乘

/**
 * 10=10*9*8*7*6*5*4*3*2*1=3628800
 * 封装一个函数实现10的阶乘
 */
function fc(num){
  var str =num+'=',sum=1;
  for(var i=num;i>=1;i--){
    sum*=i;
    if(i==1){
      str+=i+'='
    }else{
      str+=i+'*'
    }
  }
  console.log(str + sum);
}
fc(10)//10=10*9*8*7*6*5*4*3*2*1=3628800

水仙花数

一个数个位立方+十位立方+百位立方 = 数
100-1000

function sum(){
  for(var i=100;i<1000;i++){
    var a = parseInt(i/100);//百位数字 
    var b = parseInt(i%100/10);//十位数字
    var c = i%10;
    // if(a*a*a+b*b*b+c*c*c == i){
    //   console.log(i+'是水仙花数');
    // }
    if(Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3)==i){
      console.log(i+'是水仙花数');
    }
  }
}
sum()
// 153是水仙花数
// 370是水仙花数
// 371是水仙花数
// 407是水仙花数

给定一个数组[2,5,7,11],target=9;如果数组元素之和等于target 返回数组元素下标

var nums = [2,5,7,11,4],target = 9;
function add(nums,target){
  var arr =[];
  for(var i=0;i<nums.length;i++){
    for(var j=i+1;j<nums.length;j++){
      if(nums[i]+nums[j]==target){
        // 给数组添加元素
        arr.push([i,j])
      }
    }
  }
  return arr
}
var res = add(nums,target);
console.log(res)		//[ [ 0, 2 ], [ 1, 4 ] ]


var arr0=[2,5,7,11,4];
var arr1=[];
function add(){
    for(var i=0;i<arr0.length;i++){
        for(var j=0;j<arr0.length;j++){
            if(i!=j){
                if(arr0[i]+arr0[j]==9){
                    console.log([i,j])
                    arr1.push([i,j])
                }
            }
        }
    }
    return arr1
}
console.log(add())
// [ 0, 2 ]
// [ 1, 4 ]
// [ 2, 0 ]
// [ 4, 1 ]
// [ [ 0, 2 ], [ 1, 4 ], [ 2, 0 ], [ 4, 1 ] ]

求字符串中最长单词长度 / 求最长单词

var str = 'he is jumped ahdjksnadkjfhkjas';
var res = str.split(' ');//['he','is','','']
function maxLength(){
  var max = 0;//最长单词长度
  for(var i=0;i<res.length;i++){
    if(res[i].length>max){
      max = res[i].length
    }
  }
  return max
}
function maxWord(){
  var max = 0;
  for (var i = 0; i < res.length; i++) {
        if (res[i].length > res[max].length) {
            max = i
        }
    }
    return res[max]
}
console.log(maxLength());		//17
console.log(maxWord());		    //ahdjksnadkjfhkjas

重构数组方法

Array.prototype.方法名 = function () { }

//.pop()    要求重写myPop实现pop一样得功能
Array.prototype.myPop = function () {
  if (this.length > 0) {
    var last = this[this.length - 1];
    this.length--;
    return last;
  }else{
    return undefined
  }
};
var arr = [];
var res = arr.myPop();//myPop方法被arr调用 方法内部this指向arr
console.log(res, arr);



//push
Array.prototype.myPush = function(){
  // arr[arr.length] 将新增数组元素添加给原数组元素最后一项下一项
  // 循环遍历实际参数 'tom' 'jack' 'zack'
  for(var i=0;i<arguments.length;i++){
    // 将每一个实际参数依次从末尾添加给原数组 
    this[this.length] = arguments[i]
  }
  return this.length
} 
var arr = [1,2,3,4];
var res = arr.myPush('tom','jack','zack','world');
console.log(res,arr)




//shift
Array.prototype.myShift = function(){
  // 返回第一项 
  var first = this[0];
  for(var i=0;i<this.length;i++){
    // 将后面的数组元素往前移动一项
    this[i] = this[i+1]
  }
  this.length--;
  return first
}
var arr = [1,2,3,4,5];
var res = arr.myShift();
console.log(res,arr);




//unshift
Array.prototype.myUnshift = function(){
  // 获取新数组长度 
  var length = this.length + arguments.length;
  // [1,2,3,4,5]//4     i=4
  // [,,,1,2,3,4,5]//7  i=4+arguments.length  i 7   i = i-arguments.length
  // ['tom','larry','hello',1,2,3,4,5]
  // 将原数组元素向后移动arguments.length位 
  for(var i = length-1;i>=0;i--){
    // 当i等于arguments.length-1 原数组元素移动完成
    if(i>arguments.length-1){
      this[i] = this[i-arguments.length]
    }else{
      this[i] = arguments[i]
    }
  }
  // 新数组下标i为auguments.length-1 
  // 返回新数组长度
  return length
}
var arr = [1,2,3,4,5];
var res = arr.myUnshift('tom','larry','hello');
console.log(res,arr);




//.reverse()
Array.prototype.myReverse = function(){
  var newArr = [];
  // [5,4,3,2,1]---->[0,1,2,3,4]
  for(var i=this.length-1;i>=0;i--){
    // newArr.push(this[i]);
    newArr[newArr.length] = this[i]
  }
  arr = newArr
  return arr
}
var arr = [1,2,3,4,5];
var res = arr.myReverse();
console.log(res,arr);




/**
 * 迭代方法 forEach
 */
var arr = [1, 2, 3, 4, 5];
Array.prototype.myForEach = function (callback) {
    // callback--->function(){}
    for (var i = 0; i < arr.length; i++) {
        callback(arr[i], i, arr)
    }
};
arr.myForEach(function (item, index, arr) {
    console.log(item, index, arr)
});




/**
 * every 判断数组元素是否符合表达式 只要有一项不符合直接返回false 跳出循环
 */

Array.prototype.myEvery = function (callback) {
    for (var i = 0; i < arr.length; i++) {
        // 把函数调用当作条件的判断
        if (!callback(arr[i], i, arr)) {
            return false
        }
    }
    return true
}
var arr = [1, 2, 3, 4, 5];
var res = arr.myEvery(function (item, index, arr) {
    return item > 1
});
console.log(res, arr);




/**
 * some 判断数组元素是否符合表达式  只要有一个符合就返回true 跳出循环
 */
Array.prototype.mySome = function (callback) {
    for (var i = 0; i < arr.length; i++) {
        // 只要有一个满足条件 直接返回true
        if (callback(arr[i], i, arr)) {
            return true
        }
    }
    return false
}
var arr = [1, 2, 3, 4, 5];
var res = arr.mySome(function (item, index, arr) {
    return item > 5
});
console.log(arr, res);




/**
 * filter 过滤符合条件数组元素组成新数组
 */
Array.prototype.myFilter = function (callback) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (callback(arr[i], i, arr)) {
            // newArr.push(arr[i])
            newArr[newArr.length] = arr[i]
        }
    }
    return newArr
}
var arr = [1, 2, 3, 4, 5];
var res = arr.myFilter(function (item, index, arr) {
    return item > 4
});
console.log(res, arr);




/**
 * map 映射 对每一个数组元素进行操作
 */
Array.prototype.myMap = function (callback) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        newArr[newArr.length] = callback(arr[i], i, arr)
    }
    return newArr
};
var arr = [1, 2, 3, 4, 5];
var res = arr.myMap(function (item, index, arr) {
    return item + 5
});
console.log(res, arr)

数组查重

function checkForDuplicatesWithCount(arr) {
    let duplicates = {};
    arr.forEach((element, index) => {
        if (arr.indexOf(element, index + 1) !== -1) {
            if (duplicates[element]) {
                duplicates[element]++;
            } else {
                duplicates[element] = 2; // 第一次出现时是第二次，因此从2开始计数
            }
        }
    });   
    return duplicates;
}
// 示例用法
const array = [1, 2, 3, 4, 2, 5, 6, 3];
const duplicatesWithCount = checkForDuplicatesWithCount(array);
for (const key in duplicatesWithCount) {
    console.log(key + " 重复了 " + (duplicatesWithCount[key] - 1) + " 次");
}



//其他方法
function checkForDuplicatesWithCount2(arr) {
    let duplicates = {};
    arr.forEach(element => {
        duplicates[element] = (duplicates[element] || 0) + 1;
    });
    return Object.fromEntries(
        Object.entries(duplicates).filter(([key, value]) => value > 1)
    );
}
// 示例用法
const array = [1, 2, 3, 4, 2, 5, 6, 3];
const duplicatesWithCount2 = checkForDuplicatesWithCount2(array);

for (const key in duplicatesWithCount2) {
    console.log(key + " 重复了 " + (duplicatesWithCount2[key] - 1) + " 次");
}




//set方法
function findDuplicateElements(arr) {
    let set = new Set();
    let duplicates = new Set();  
    arr.forEach(element => {
        if (set.has(element)) {
            duplicates.add(element);
        } else {
            set.add(element);
        }
    });    
    return Array.from(duplicates);
}
let arr = [1, 2, 3, 4, 2, 3, 5, 6, 1];
let duplicates = findDuplicateElements(arr);
console.log(duplicates); // Output: [2, 3, 1]




//双重for循环
function findDuplicateElements(arr) {
    let duplicates = [];
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j] && !duplicates.includes(arr[i])) {
                duplicates.push(arr[i]);
            }
        }
    }
    return duplicates;
}
let arr = [1, 2, 3, 4, 2, 3, 5, 6, 1];
let duplicateElements = findDuplicateElements(arr);
console.log(duplicateElements); // Output: [2, 3, 1]




//map方法
function findDuplicates(arr) {
    let map = new Map();
    let duplicates = [];
    for (let i = 0; i < arr.length; i++) {
        if (map.has(arr[i])) {
            map.set(arr[i], map.get(arr[i]) + 1);
        } else {
            map.set(arr[i], 1);
        }
    }
    map.forEach((value, key) => {
        if (value > 1) {
            duplicates.push({ element: key, count: value });
        }
    });
    return duplicates;
}
// 示例用法
let arr = [1, 2, 3, 2, 4, 5, 3, 6, 4, 7, 8, 9, 7];
let result = findDuplicates(arr);
console.log(result);

数组去重

//双层for循环去重 
//对比前一项和后一项是否相等 相等删除后一项，修正下标 
var arr = [1,2,3,4,5,4,1,3,2,1];
function unique(arr){
  // 循环前一项
  for(var i=0;i<arr.length;i++){
    //循环后一项
    for(var j=i+1;j<arr.length;j++){
      if(arr[i]===arr[j]){
        // 删除后一项重复的数组元素
        arr.splice(j,1);
        // 修正下标
        j--;
      }
    }
  }
  return arr
}
console.log(unique(arr));			//[ 1, 2, 3, 4, 5 ]






// 2.使用indexOf去重 3.使用lastIndexOf去重
 // 思路：创建一个新的数组 判断重复数组元素是否存在新数组中 不存在直接添加到新数组
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        // 判断每一项数组元素是否存在新数组中  不存在则添加到新数组中
        newArr.indexOf(arr[i]) === -1 ? newArr.push(arr[i]) : ""
        // newArr.indexOf(arr[i]) === -1 ? newArr[newArr.length] = arr[i] : ""
    }
    return newArr
}
console.log(unique(arr));






 // 3.利用includes方法进行数组去重
 // 检测数组元素是否存在数组中 存在返回true  不存在返回false
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        // newArr.includes(arr[i])===false?newArr[newArr.length]=arr[i]:""
        if (!newArr.includes(arr[i])) {
            newArr.push(arr[i])
        }
    }
    return newArr
}
console.log(unique(arr))



//4. forEach + includes /indexOf /lastIndexOf
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
    var newArr = [];
    arr.forEach(function (item) {
        newArr.indexOf(item) === -1 ? newArr.push(item) : ""
        // newArr.lastIndexOf(item) === -1 ? newArr.push(item) : ""
        // newArr.includes(item) === false ? newArr.push(item) : ""
    })
    return newArr
}
console.log(unique(arr));




// 5.利用filter方法 + includes/indexOf/lastIndexOf
 
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
function unique(arr) {
    var newArr = [];
    return arr.filter(function (item) {
        return newArr.indexOf(item) === -1 ? newArr.push(item) : ""
    })

}
console.log(unique(arr));





//6.利用set去重 set成员是唯一的
var arr = [1, 2, 3, 4, 5, 4, 1, 3, 2, 1];
var set = new Set(arr);
console.log(Array.from(set));
console.log([...set]);

数组扁平化

[1,2,[3,4,5,[6,7,8,[9,10]]]]-------> [1,2,3,4,5,6,7,8,9,10]
//1.利用递归实现数组扁平化
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14]]]]]];
function flat(arr) {
    var newArr = [];
    for (var i = 0; i < arr.length; i++) {
        if (Array.isArray(arr[i])) {
            newArr = newArr.concat(flat(arr[i]))
        } else {
            newArr.push(arr[i])
        }
    }
    return newArr;
}
console.log(flat(arr));



//2.
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14, 'hello']]]]]];
// console.log(arr.toString().split(",")); '1' '2'
function flat(arr) {
    return arr.toString().split(',').map(function (item) {
        if (isFinite(+item) === false) {
            return item
        } else {
            return +item
        }
    })
}
console.log(flat(arr));





//3.利用es6 flat方法进行数组扁平化  展开数组 n Infinity
var arr = [1, 2, [3, 4, 5, [6, 7, 8, [9, 10, [11, 12, [13, 14, 'hello']]]]]];
var res = arr.flat(Infinity);
console.log(res, arr);