合并两个有序数组：
// 新建一个空数组temp，数组长度表示为t，以及两个变量i, j标记两组数据当前比较值的下标进行对比，将比较小的值存入temp数组中，同时将下标和数值长度自增1
var arr1 = [1, 3, 5, 7, 9, 12, 15, 18]
var arr2 = [2, 8, 11, 16, 19]
var i=0,j=0,arr=[]
while(i<arr1.length && j<arr2.length)
{
if(arr1[i]<arr2[j]){
arr.push(arr1[i])
i++;
// arr.push(arr1[i++]) 另一种写法
//var t= 0; arr[t++] = arr1[i++]
}else{
arr.push(arr2[j])
j++;
}
}
if(i===arr1.length){
arr = arr.concat(arr2.slice(j,arr2.length)) // slice 复制出新数组 concat 不会改变原数组
}
if(j===arr2.length){
arr.push(...arr1.splice(i,arr1.length-i))// splice 截取数组 [...] 复制数组 push 返回长度
}
// 合并再排序
function concatArr(data1, data2) {
var arr = [];
var newArr = arr.concat(data1, data2).sort(function(a, b) {
return a - b;
});
return newArr;
}
在数组中找到两个值相加，与目标值相同，返回这两个值的索引，且索引一少于索引二:
function twoSum( numbers , target ) {
// write code here
for(let i=0; i<numbers.length; i++){
for (let j=i+1;j<numbers.length;j++){
if (numbers[i]+numbers[j]==target)
return [i+1,j+1]
}
}
}
数组反转：
// 定义一个新数组，把老数组中的元素反向添加到新数组中
function reverse(array){
var newArr = [];
for(var i=array.length-1;i>=0;i--){
newArr[newArr.length] = array[i];//新数组里面累加旧数组最后一个开始
}
return newArr;
}
//翻转原数组，直接修改原数组
function reverse2(array){
for(var i=0;i<array.length/2;i++){
var temp = array[i];// 临时元素temp 等于当前元素
array[i] = array[array.length-1-i];// 当前元素 等于对应的尾部位置
array[array.length-1-i] = temp;// 尾部位置的元素等于临时元素
}
return array; //Array对象中的方法返回了一个数组。
}
数组去重：
Array.from(new Set(arr))
[...new Set(arr)]
function arrayNonRepeatfy(arr) {
let map = new Map();
let array = new Array(); // 数组用于返回结果
for (let i = 0; i < arr.length; i++) {
if(map.has(arr[i])) {
continue // 如果有该key值
}else{
map.set(arr[i], 1); // 如果没有该key值
array.push(arr[i]);
}
}
return array ;
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
arrayNonRepeatfy(arr)
数组输出重复最大的次数,元素
function fnRepeat(ipLines) {
var [obj, max, name] = [{}, 1, ''];
ipLines.forEach(value => {
if (obj[value]) {
// 已经有值了 就把值+1
obj[value]++;
if (obj[value] > max) { // 判断重复次数有没有超过当前最高的
max = obj[value]; // 重复次数
name = value; // 当前元素
}
} else {
// 没有值 就初始化一个值
obj[value] = 1;
}
});
return '重复次数:'+name+'\n重复最多的元素：'+max;
};
fnRepeat(arr){
let [max,maxKey,arrMap]=[0,null,{}]
arr.forEach(item=>{
if(arrMap.hasOwnProperty(item)){
arrMap[item]++;// 存在加+1
} else{
arrMap[item]=1;// 不存在初始化1
}
if(arrMap[item]>max){
max = arrMap[item]
maxKey = item
}
})
return '重复次数:'+max+'\n重复最多的元素：'+maxKey;
}
获取连续递增序列最长的长度，入参字符串：
或者换种思路 后者-前者组成一个数组 找1连续重复最多的数量
getLength(str){
// str "abc2234019A334bc"
var arr = [],count=1,n=1// n为临时变量长度
str = str.replace(/[^0-9]/ig,"")// 过滤字符串 数字
arr = Array.from(str)// 一个字符串转数组
for(let i=0;i<arr.length-1;i++){
if(arr[i+1]-arr[i]===1){
++n;
}else{
if(n>count) count = n
n=1
}
}
}
判断一个数是不是素数：
function isSushu(num){
var count=0;//记录整除的次数
var i=2;
while(i<num){
if(num%i===0){
count++;// 除了1和本身被整除 计数+1
break;
}
i++;
}
if(count==0){
console.log(num+"是素数");
}else{
console.log(num+"不是素数");
}
}
比较两个版本号：
版本号规则为'x.y.z' 至少有x位
compare('0.1','1.1.1.3')// -1
compare('12.1','1.3.1.1')// 1
compare('1.3','1.3.0')// 1
compare(ver1, ver2) {
try {
if (!ver1 || !ver2) return 0;// 其他情况返回0
const list1 = ver1.split("."),list2 = ver2.split(".")// 转为两个数组比较
// 取最大的x数
const size = Number(list1[0]) >= Number(list2[0]) ? Number(list1[0]) : Number(list2[0]);
for (let i = 0; i < size; i++) {
if (!list1[i]) list1.push("0");//如果没有数据 就占位0
if (!list2[i]) list2.push("0");//如果没有数据 就占位0
if (list1[i] === list2[i]) continue;// 如果两个数相等 就继续下一轮比较
if (Number(list1[i]) > Number([list2[i]])) {// 如果list1元素大于list2
return 1;// ver1大于ver2 返回 1
} else {
return -1;// ver1小于ver2 返回 -1
}
}
return 0;// 其他情况返回0
} catch (e) {
return 0;
}
}
截取字符串：
// let tpl = '你好，我们国家是<% con.name %>，我们城市是<% city %>';
// let tplData = {
// con: {
// name: '中国'
// },
// city: '西溪北岸'
// }
// const str = renderTpl(tpl, tplData);
// console.log(str); // 最终输出结果为：你好，我们国家是中国，我们城市是西溪北岸。
function renderTpl(tpl, tplData) {
const fun = (_tplData, parentsKey) => {
if (!_tplData || typeof _tplData === "string") return; // 是字符串或者空就退出
//Object.keys 返回一个所有元素为字符串的数组
Object.keys(_tplData).forEach((key) => {
//拿到key的数组然后遍历 布尔表达式 ? 值0:值1;
// parentsKey = 指向当前节点的key 比如{a:{b:{c:3}}} 当前key是c parentsKey就是a.b
// parentsKey 和key 对应 `${parentsKey}.${key}` a.b.c 用于匹配key字符串<% a.b.c %>
const _key = parentsKey ? `${parentsKey}.${key}` : key; //拿到key或者下一层 深度遍历
const tplKey = `<% ${_key} %>`; // 拿到规定的key字符串
tpl = tpl.replace(tplKey, _tplData[key]); // key对应的值 替换 规定key字符串
fun(_tplData[key], _key); // 遍历到叶子节点
});
};
fun(tplData, ""); // 第一个节点
return tpl;
}
// var tpl = 'my name is ${name},im from ${city}'
// var data = {name:'肥羊',city:'中国'}
sprintf(tpl,data)// "my name is 肥羊,im from 中国"
function sprintf(tpl,data){
Object.keys(data).forEach(key=>{
const tplKey = '${'+key+'}'// 取出定义的key
tpl = tpl.replace(tplKey,data[key])// 用key对应的value值替换key
})
return tpl;
}
网友评论