JSON.stringify() 将值转换为相应的JSON格式：

- 转换值如果有 toJSON() 方法，该方法定义什么值将被序列化。
- 非数组对象的属性不能保证以特定的顺序出现在序列化后的字符串中。
- 布尔值、数字、字符串的包装对象在序列化过程中会自动转换成对应的原始值。
- undefined、任意的函数以及 symbol 值，在序列化过程中会被忽略（出现在非数组对象的属性值中时）或者被转换成 null（出现在数组中时）。函数、undefined 被单独转换时，会返回 undefined，如JSON.stringify(function(){}) or JSON.stringify(undefined).
- **对包含循环引用的对象（对象之间相互引用，形成无限循环）执行此方法，会抛出错误**。
- 所有以 symbol 为属性键的属性都会被完全忽略掉，即便 replacer 参数中强制指定包含了它们。
- Date 日期调用了 toJSON() 将其转换为了 string 字符串（同Date.toISOString()），因此会被当做字符串处理。
- NaN 和 Infinity 格式的数值及 null 都会被当做 null。
- 其他类型的对象，包括 Map/Set/WeakMap/WeakSet，仅会序列化可枚举的属性。

Uncaught TypeError: Converting circular structure to JSON
    --> starting at object with constructor 'Object'
    |     property 'abc' -> object with constructor 'Object'
    --- property 'b' closes the circle
    at JSON.stringify (<anonymous>)
    at js (<anonymous>:2:24)
    at <anonymous>:1:1

function deepCopy(obj) {
	let result = {}
	if (obj === null) return null
	if (typeof obj !== 'object') return obj
	if (obj instanceof Date) return new Date(obj)
	for (let key in obj) {
		if (obj.hasOwnProperty(key)) {
			if (typeof obj[key] === 'object' && obj[key] !== null) {
				result[key] = deepCopy(obj[key])
			} else {
				result[key] = obj[key]
			}

		}
	}
	return result
}

Array.prototype.bubleSort = function() {
	for (let i = 0; i < this.length; i ++) {
		for (let j=0; j<this.length -1; j++) {
			if (this[j] > this[j + 1]) {
				let cur = this[j]
				this[j] = this[j+1]
				this[j+1] = cur
			}
		}
	}
}

Array.prototype.quickSort = function() {
	const partition = (array, left, right) => {
		let pivot = array[Math.floor((right + left) / 2)]
		let i = left
		let j = right
		while(i <= j) {
			while(array[i] < pivot) {
				i++
			}
			while(array[j] > pivot) {
				j--
			}
			if (i <= j) {
				let cur = array[i]
				array[i] = array[j]
				array[j] = cur
				i++
				j--
			}
		}
		return i
	}
	const quick = (array, left, right) => {
		let index
		if (array.length > 1) {
			index = partition(array, left, right)
			if (left < index -1) {
				quick(array, left, index - 1)
			}
			if (index < right) {
				quick(array, index, right)
			}
		}
	}
	quick(this, 0, this.lenght -1)
	return this
}

Array.prototype.binarySearch = function(item) {
	this.quickSort()
	let low = 0
	let mid = null
	let element = null
	let high = this.length -1

	while(low <= high) {
		mid = Math.floor((low + high) / 2)
		element = this[mid]
		if (elemnet < item) {
			low = mid + 1
		}  else if (element > item) {
			high = mid - 1 
		} else {
			return mid
		}
	}
	return -1
}

function fibonacci(num) {
	if (num ===1 || num === 2) return 1
	return fibonacci(num - 1) + fibonacci(num - 2)
}

const PENDING = 'PENDING'
const RESOLVED = 'RESOLVED'
const REJECTED = 'REJECTED'

function MyPromise(fn) {
  const that = this
  that.status = PENDING
  that.value = null
  that.resolvedCallbacks = []
  that.rejectedCallbacks = []

  function resolve(value) {
    if (that.status === PENDING) {
      that.value = value
      that.status = RESOLVED
      that.resolvedCallbacks.forEach(f => f(value))
    }
  }

  function reject(value) {
    if (that.status === PENDING) {
      that.status = REJECTED
      that.value = value
      that.rejectedCallbacks.forEach(fn => fn(value))
    }
  }

  try {
    fn(resolve, reject)
  } catch(e) {
    reject(e)
  }
}

MyPromise.prototype.then = function (onFulfilled, onRejected) {
  if (this.status === PENDING) {
    this.resolvedCallbacks.push(onFulfilled)
    this.rejectedCallbacks.push(onRejected)
  }
  if (this.status === RESOLVED) {
    onFulfilled(this.value)
  }
  if (this.status === REJECTED) {
    onRejected(this.value)
  }
   
  return this
}

    const result = new MyPromise((resolve, reject) => {
      setTimeout(() => {
        resolve('1s 返回的值')
      }, 1000)
    })
    console.log('正常')
    result.then(value => {
      console.log('这是：', value)
    }).then(value => {
      console.log('zhe 222:', value)
    })

Promise.myAll = function(promises) {
  return new Promise((resolve, reject) => {
    if (!promises.length) {
      return resolve([])
    }
    let result = []
    let count = 0
    for (let i = 0; i < promises.length; i++) {
      const ele = promises[i]
      if (!(ele instanceof Promise)) {
        result[i] = ele
        if (++count === promises.length) {
          resolve(result)
        }
      } else {
        ele.then(value => {
          result[i] = value
          if (++count === promises.length) {
            resolve(result)
          }
        }, e => {
          reject(e)
        })
      }
    }
  })
}

Promise.myRace = function(promises) {
  return new Promise((resolve, reject) => {    
    for (let i = 0; i < promises.length; i++) {
      const ele = promises[i]
      if (!(ele instanceof Promise)) {
        Promise.resolve(ele).then(resolve, reject)
      }
      ele.then(resolve, reject)
    }
  })
}

function throttle(fn, delay) {
  let start = 0
  return function() {
    let now = Date.now()
    if (now - start > delay) {
      fn()
      start = now
    }
  }
}

function debouce(fn, delay) {
  let timer = null
  return function() {
    clearTimeout(timer)
    timer = setTimeout(fn, delay)
  }
}

function flatDeep(array, deep = 1) {
  return deep > 0 ? array.reduce((acc, val) => acc.concat(Array.isArray(val) ? flatDeep(val, deep - 1) : val), []) : array.slice()
}

Function.prototype.myCall = function (thisArg, ...args) {
  thisArg = Object(thisArg) || window
  let fn = Symbol()
  thisArg[fn] = this
  let result = thisArg[fn](...args)
  delete thisArg[fn]
  return result
}

Function.prototype.myApply = function (thisArg, ...args) {
  thisArg = Object(thisArg)
  let fn = Symbol()
  thisArg[fn] = this
  let result = thisArg[fn](args)
  delete thisArg[fn]
  return result
}

Function.prototype.myBind = function(context, ...args) {
  return function(...newArgs) {
    return this.call(context, ...args, ...newArgs)
  }
}

function limitRunTask(tasks, n) {
  return new Promise((resolve, reject) => {
    let start = 0
    let finished = 0
    let index = 0
    let result = []
    function run() {
      if (finished === tasks.length) {
        resolve(result)
        return
      }
      while (start < n && index < tasks.length) {
        start ++
        let cur = index
        tasks[index ++]().then(val => {
          start --
          finished ++
          result[cur] = val
          run()
        })
      }
    }
    run()
  })
}