1、+ 号的隐式类型转换使用
+[3] //3
+[1,2,3].slice(-1) //将 [3] 转换为了3
2、日期的转换
const addDaysToDate = (date, n) => {
const d = new Date(date);
d.setDate(d.getDate() + n);
return d.toISOString().split('T')[0];
};
addDaysToDate('2020-10-15', 10); // '2020-10-25'
平时做日期的计算可能更多的使用时间戳，秒数去加减，其实有对应的 setDate，getDate等方法去做（月份也一样）
toISOString 可以将日期对象转换为 YYYY-MM-DDTHH:mm:ss.sssZ 格式，分割掉 T 字符，即可以得到日期形式
3、对象的合并
Object.assign
// 在像某对象添加多个属性时，可以直接采取合并方式
const addStyles = (el, styles) => Object.assign(el.style, styles)
addStyles(document.getElementById('my-element'), {
background: 'red',
color: '#ffff00',
fontSize: '3rem'
})
4、Array.from
/
对于这个api知道更多的只是将类数组转化为真正的数组
(arrayLike,mapFn) 准确的说应该是类数组或者 可迭代对象({length: 5})
mapFn 接收一个回调，返回的数组每个元素会执行该回调 /
let a = Array.from({length: 10},(_,i) => i)
a // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
5、关于工具函数封装tips
在封装工具类函数时，可以往闭包的角度靠（内部再返回一个函数）
有时候可以具有更好的拓展性
// 栗子：获取某些数中的最大值
const ary = (fn,n) => (...arg) => fn(...arg.slice(0,n))
const firstTwoMax = ary(Math.max, 2)
firstTwoMax(1,2,3,4)
// ary的函数将传入的函数，作为返回函数的返回值调用，类似于将传入的函数缓存下来，再一次调用时，传入比较值
// 这样有个好处是，其实我们可以更改比较条件，比如 取最小值等等
// 这样工具函数更具有灵活性
6、 按条件分割数组
const bifurcateBy = (arr, fn) =>
arr.reduce((acc, val, i) => (acc[fn(val, i) ? 0 : 1].push(val), acc), [
[],
[],
])
bifurcateBy(['beep', 'boop', 'foo', 'bar'], x => x[0] === 'b');
// [ ['beep', 'boop', 'bar'], ['foo'] ]
/
利用 reduce 将结果汇总，同时把分割条件作为一个 返回布尔值的函数传入
内部通过布尔值的判断，添加到对应的数组中 /
7、二分搜索算法，来查找已排序数组中某元素的位置
尽管现在有api可以直接实现位置查找，不过这个算法思想还是可以的
const binarySearch = (arr,item) => {
// 获取首位下标
let l = 0,
r = arr.length - 1;
while(l <= r) {
// 找到中间下标
const middle = Math.floor( (l + r) / 2)
const guess = arr[middle]
// 中间值与目标值比较
if(guess == item) return middle
// 中间值 > 目标值 ? 说明目标值在左侧，则取左边中间值再比较，反之亦然
guess > item ? r = middle - 1 : l = middle + 1
}
return -1
}
binarySearch([1,2,3,4],4) // 3
二分搜索算法，采取折中的方式，将中间值与目标做比较，然后不断修改中间值，进而找到目标值
8、冒泡排序
const bubbleSort = arr => {
let swapped = false;
const a = [...arr];
for (let i = 1; i < a.length; i++) {
swapped = false;
for (let j = 0; j < a.length - i; j++) {
if (a[j + 1] < a[j]) {
// es6 变量交换
[a[j], a[j + 1]] = [a[j + 1], a[j]];
swapped = true;
}
}
if (!swapped) return a;
}
return a;
};
核心思想是将当前值a 与 下一位置值b比较，如果 a > b,就把 a和b交互位置
同时，一轮排序其实就可以实现最大值排最后了，所以循环次数越往后会越少，这也是 i < a.length ,j < a.length - i 的原因
es6 的变量交换位置，更加方便了，其实也可以用于多个变量的赋值改变类似： [count, i] = [count + 1, r + 1]…
9、将字符串首字母转换为大写
// 有意思的是 这里只是通过解构的方式，就把字符串的首字符与剩余字符分开了
// 在此之前你说否还想着截取首字母再来转换？
const capitalize = ([first, ...rest], lowerRest = false) =>
first.toUpperCase() +
(lowerRest ? rest.join('').toLowerCase() : rest.join(''));
capitalize('fooBar', true); // 'Foobar'
10、链式控制异步流程
const chainAsync = fns => {
let curr = 0;
const last = fns[fns.length - 1];
// 内部实现一个函数，用于逐次从数组中提取执行函数
const next = () => {
const fn = fns[curr++];
// 提取函数与最后一个做对比，是否为最后一个函数
// 同时将这个内部函数，作为回调，传入下一个 异步函数中
fn === last ? fn() : fn(next);
};
next();
};
chainAsync([
next => {
console.log('0 seconds');
// 函数执行后，再执行传入的回调next
setTimeout(next, 1000);
},
next => {
console.log('1 second');
setTimeout(next, 1000);
},
() => {
console.log('2 second');
}
]);
异步的实现，其实还是回调的使用，只不过封装后，看似同步
好比 Promise的resolve，获取结果后，通过resolve回调出去
Promise + async ，运用迭代器，使得可以控制函数的暂停和恢复，更加具有同步风范
11、js 实现一个剪切板
const copyToClipboard = str => {
const el = document.createElement('textarea');
el.value = str;
el.setAttribute('readonly', '');
el.style.position = 'absolute';
el.style.left = '-9999px';
document.body.appendChild(el);
const selected =
document.getSelection().rangeCount > 0
? document.getSelection().getRangeAt(0)
: false;
el.select();
document.execCommand('copy');
document.body.removeChild(el);
if (selected) {
document.getSelection().removeAllRanges();
document.getSelection().addRange(selected);
}
}
copyToClipboard('Lorem ipsum')
12、根据给定函数或者属性，统计符合条件的数组元素的个数
const countBy = (arr, fn) =>
arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val) => {
acc[val] = (acc[val] || 0) + 1;
return acc;
}, {});
countBy([6.1, 4.2, 6.3], Math.floor); // {4: 1, 6: 2}
countBy(['one', 'two', 'three'], 'length'); // {3: 2, 5: 1}
countBy([{ count: 5 }, { count: 10 }, { count: 5 }], x => x.count)
13、实现一个发布订阅模式
const createEventHub = () => ({
hub: Object.create(null),
emit(event, data) {
(this.hub[event] || []).forEach(handler => handler(data));
},
on(event, handler) {
if (!this.hub[event]) this.hub[event] = [];
this.hub[event].push(handler);
},
off(event, handler) {
const i = (this.hub[event] || []).findIndex(h => h === handler);
if (i > -1) this.hub[event].splice(i, 1);
if (this.hub[event].length === 0) delete this.hub[event];
}
});
//代码效果参考：http://www.zidongmutanji.com/zsjx/306135.html
const handler = data => console.log(data);
const hub = createEventHub();
let increment = 0;
// Subscribe:
hub.on('message', handler);
hub.on('message', () => console.log('Message event fired'));
hub.on('increment', () => increment++);
// Publish
hub.emit('message', 'hello world');
hub.emit('message', { hello: 'world' });
hub.emit('increment');
// Unsubscribe
hub.off('message', handler);
14、补充一点关于函数length属性
/*
- js 函数的length是表示参数的个数，需要注意的是
- 该个数指的是 函数必须接收参数的个数，且是有效参数（应当是默认值前的参数个数）
- */
function a( a,b = 10,c) {} //a.lenght = 1
// 对于包含默认值的参数，只有传递 undefiend 时（或者不传）才是取默认值，其他情况均为传啥就是啥a(10,'',30) // a = 10 b = '' c = 30 a(10,null,30) // a = 10 b = null c = 30 a(10,undefiend,30) // a =10 b = 10 c = 30
