// 1分页计算
let pageSize = 10
// 向上取整
let index = 10
const pageNo = Math.ceil((index + 1) / pageSize)
console.log(pageNo)
// 2数组的最大值
const A = [1, 2, 3, 4]
const max = Math.max(...A)
console.log(max)
// const max = Math.max.apply(null, A)
// 3.20-30的随机整数
let b = Math.round(20 + Math.random() * 10)
console.log(b)
// 4.判断一个数是不是素数
// 素数就是一个 除了 0 和1  ，她两既不是素数，也不是合数
// 然后判断他是不是除了1 和 自身，就不能被别的数整除了
// 可以使用遍历，但是遍历所有就太多了，就先看他的平方根
// 然后向下取整 就循环到这里就可以了
function is_prime (n) {
  if (n <= 1) return false
  // 算平方根取值
  const N = Math.floor(Math.sqrt(n))
  let is_prime = true
  for (let i = 2; i <= N; i++) {
    if (n % i === 0) {
      is_prime = false
      break
    }
  }
  return is_prime
}
console.log(is_prime(13))

数组替换splice

map的使用

为什么这里要解构出来一个新的那？

我们希望 map映射出来的数组里的对象是一个全新的，和原来数据是没有关联的，要不直接在原来的值上去修改的话，原来的数组上就 突然多了一项 ，而且，有可能还会 改变 原数组

使用reduce进行分组

sort排序

怎么是升序，怎么是降序

sort return a-b 的话，返回值是升序 ，return b-a 的话 是降序

var points = [40,100,1,5,25,10];
points.sort(function(a,b){return a-b});
fruits输出结果：
1,5,10,25,40,100
points.sort(function(a,b){return b-a});
fruits输出结果：
100,40,25,10,5,1

// 5.括号匹配问题 栈的解法，就是先进先出
// 给定一个表达式，中间只有[] 和() 判断表达式两边括号是不是平衡的，比如[(())]平衡，比如[()(()]不平衡
// var [a, ...b] = 'asdasd'
// a = 'a'
// b = ["s", "d", "a", "s", "d"]
function is_balance (str) {
  const [first, ...others] = str
  const stack = [first]
  while (others.length > 0) {
    const c = stack[stack.length - 1]
    // .shift() 从数组中删除第一个，返回值就是第一个 .pop() 从数组中删除最后一个，返回最后一个
    const n = others.shift()
    // 如果不匹配 就在添加一个 ，匹配的话，移除当前最后一个
    if (!match(n, c)) {
      stack.push(n)
    } else {
      stack.pop()
    }
  }
  // 如果当前最后剩余的结果集是空的就ok了
  return stack.length === 0
}
function match (n, c) {
  return (c === '[' && n === ']') || (c === '(' && n === ')')
}
console.log(is_balance('[()(()]'))
// 6.数组去重
let c = [...new Set(['a', 'b', 'b', 'c'])]
console.log(c)
// 7 写一个函数，给定一个函数，判断数组中的某一项，或者任意多项的和，是否可以被另一个整数整除
// 相当于判断子数组的余数 和 solve([7,8,2],7) 相当于 solve([0,1,2],7)
function solve (arr, num) {
  const s = new Set()
  for (let i = 0; i <= arr.length; i++) {
    for (let j = i + 1; j <= arr.length; j++) {
      const remain = arr.slice(i, j).reduce((x, y) => x + y, 0) % num
      s.add(remain)
    }
  }
  return s.has(0)
}
solve([3, 5, 8], 13) // true
solve([3, 9], 15) // false
solve([7, 8, 2], 7) // true
solve([1, 2, 3], 6) // true
// 最简单写法的拍平
console.log(eval(`[${[1, [2, 3, [4]]] + ''}]`))
// 生成器构造无穷斐波那契数列
function* fibonacci () {
  let a = 1; b = 1
  yield a; yield b;
  while (true) {
    const t = b;
    b = a + b; a = t;
    yield b
  }
}
const it = fibonacci()
const feb10 = Array.from(Array(10), it.next, it).map(x => x.value)
console.log(feb10);

ramda 库

数组拍平 最简单写法：

eval([${[1, [2, 3, [4]]] + ''}])

迭代器和生成器

JS函数生成器，function* () {}**

　　简单来说，用法如下：

function* fn() {
    console.log(1);
    //暂停！
    yield;
    //调用next方法继续执行
    console.log(2);
}
var iter = fn();
iter.next(); //1
iter.next(); //2

　　1、函数生成器特点是函数名前面有一个‘*’
　　2、通过调用函数生成一个控制器
　　3、调用next()方法开始执行函数
　　4、遇到yield函数将暂停
　　5、再次调用next()继续执行函数

生成器的优势

迭代器的遍历