JavaScript Cookbook (我自己攒的JS菜谱)

语法基础

字符串

1.字符串切割

let str = "hello world"
str.slice(0) // output: hello world
str.slice(0, 1) // output: h

2.大小写转化

StringObject.toUpperCase()
StringObject.toLowerCase()

数组

1. 嵌套数组扁平化

/** 
 * 使嵌套数组扁平化
 * @param  {[list]}
 * @return {[list]}
 */
function flatten(lis) {
    let res = []
    for (let li of lis) {
        if (Array.isArray(li)) {
            res.push(...li)
        } else {
            res.push(li)
        }
    }
    return res
}
/**
* 多层嵌套扁平化
* 
*/

let arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];

function flatten(arr) {
  let result = [];
  for (let i = 0; i < arr.length; i++) {
    let item = arr[i];
    if (Array.isArray(item)) {
      result.push(...flatten(item))
    } else {
      result.push(item)
    }
  }
  return result;
}

忽然发现Js其实又类似的函数 Array.flat()

let arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];
arr.flat(Infinity)

输出结果

面试题：

已知如下数组：

var arr = [ [1, 2, 2], [3, 4, 5, 5], [6, 7, 8, 9, [11, 12, [12, 13, [14] ] ] ], 10];

编写一个程序将数组扁平化去并除其中重复部分数据，最终得到一个升序且不重复的数组

Array.from(new Set(arr.flat(Infinity))).sort((a,b)=>{ return a-b})

2.数组切割

不修改原数组

let arr = [1,2,3,4,5];

console.log(arr.slice(0, 2)); // console: 1, 2
// ArrayObject.slice(start, end)从已有的数组中返回选定的元素
// 

修改原数组

如何直接删除数组中的某一段呢？

arrayObject.splice(index,howmany,item1,…..,itemX)

参数	描述
index	必需。整数，规定添加/删除项目的位置，使用负数可从数组结尾处规定位置。
howmany	必需。要删除的项目数量。如果设置为 0，则不会删除项目。
item1, …, itemX	可选。向数组添加的新项目

简单来说，以index 为开始位置，howmany为长度，截取原数组中的元素，还可以在截取后向原数组添加元素

let arr = [1,2,3,4,5];

let a = arr.splice(0,1, 'helloworld')
console.log(a); // [1]
console.log(arr); // [ 'helloworld', 2, 3, 4, 5 ]

3.几个我平时不怎么常用，但是很有用的数组函数

every() 方法使用指定函数检测数组中的所有元素：

• 如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
• 如果所有元素都满足条件，则返回 true。

let arr = [23, 32, 12, 14, 56];

arr.every(b => {
  return b > 40;
})

// 结果 false

some() 方法会依次执行数组的每个元素：

• 如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
• 如果没有满足条件的元素，则返回false。
• 基本跟every相反，只要存在满足的条件的就返回true

let arr = [23, 32, 12, 14, 56];

arr.every(b => {
  return b > 40;
})

// 结果 true

filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。所以这个函数可以很方便的过滤出需要的元素。

let arr = [23, 32, 12, 14, 56];

arr.filter(b => {
  return b > 40
})

// 输出： [56]

对象

1.对象判空

/**
 * 判空
 * @param  {[ object]}
 * @return {[Boolean]} 如果为空，返回 true
 */
function objectIsEmpty(obj) {
    if (Object.keys(obj).length === 0){
        return true
    }
    return false
}

文件处理

1.读取文件

1.1 全部读取

// 异步读取
fs.readFile('./doc/鬼头.txt', function (err, data) {
    if (err) {
        console.log(err)
    }
    console.log(data.toString())
})

1.2 逐行读取文件

const readline = require('readline')
const fs = require('fs')

const rl = readline.createInterface({
    input: fs.createReadStream('./doc/鬼头.txt')
})
// 加载文件
rl.on('line', (line) => {
    console.log(line)
})

// 文件加载完成
rl.on("close", (data) => {
    console.log('finish')
})

1.3 获取超大文件行数

代码参考自：https://itnext.io/using-node-js-to-read-really-really-large-files-pt-1-d2057fe76b33

var fs = require('fs')
var readline = require('readline')
var stream = require('stream')

var instream = fs.createReadStream('itcont.txt')
var outstream = new stream()
var rl = readline.createInterface(instream, outstream)

// line Count
lineCount = 0

rl.on('line', function (line) {
    lineCount++
})

rl.on('close', function () {
    // totle line count
    console.log(lineCount)
})

2.写入二进制文件

const fs = require('fs')

// 异步写入
fs.writeFile('../filename', data, 'binary', function (err) {
    console.log(err)
})

fs.createWriteStream('filepath', {flags: 'w'})

// 同步写入
fs.writeSync('./filname', data)

3. 处理JSON文件

let obj = {a: 'hello', b: 'world'}
// 对象转字符串， 序列化
let objStr = JSON.stringify(obj)

// 字符串转回对象, 反序列化
let objFromStr = JSON.parse(objStr)

时间处理

1. 获取指定长度的时间

function getTimestamp (length = 13) {
    dd = new Date().getTime()
    if (length < 13 && length > 0) {
        dd = String(dd).slice(0, length)
    }
    return dd
}

并发

自定义并发数量

let mapLimit = (list, limit, asyncHandle) => {
    if (limit > list.length) {
        limit = list.length
    }
    let recursion = (arr) => {
        return asyncHandle(arr.shift())
            .then(() => {
                if (arr.length !== 0) return recursion(arr)
                else return 'finish'
            })
    }

    let listCopy = [].concat(list)
    let asyncList = []
    while (limit--) {
        asyncList.push(recursion(listCopy))
    }
    return Promise.all(asyncList)
}

// 使用示例
    mapLimit(data, limit, (curItem) => {
        return new Promise((resolve) => {
            count++
            setTimeout(()=>{resolve()}, 2000)
        })
    }).then(() => {
        console.log('finish')
    })