fix: --

Author: huangguangda

js-code/code/合并区间.js

@@ -0,0 +1,31 @@
+// s1 s2 s1[1] >= s2[0]
+// current next
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ 56. 合并区间
+ */
+ var merge = function(intervals) {
+  let ans = []
+  let len = intervals.length
+  let index = 0
+  let current = []
+  intervals.sort((prev, next) => prev[0] - next[0])
+  while(index < len) {
+      next = intervals[index++]
+      if (current.length === 0) {
+          current = next
+      } else {
+          if(current[1] >= next[0]) {
+              current = [current[0], Math.max(current[1], next[1])]
+          }else{
+              ans.push([...current])
+              current = next
+          }
+      }
+  }
+  if(current.length > 0) {
+      ans.push([...current])
+  }
+  return ans
+};

js-code/code/字符串相加 .js

@@ -0,0 +1,45 @@
+/**
+ * @param {string} num1
+ * @param {string} num2
+ * @return {string}
+ 415.字符串相加 
+ */
+ var addStrings = function(num1, num2) {
+  let len1 = num1.length
+  let len2 = num2.length
+  let i = len1 - 1
+  let j = len2 - 1
+  let carry = 0
+  let ans = ''
+  while(i>=0 || j>=0) {
+      let cur1 = i < 0 ? 0 : num1[i] * 1
+      let cur2 = j < 0 ? 0 : num2[j] * 1
+      let {result, nextcarry} = add (cur1, cur2, carry)
+      carry = nextcarry
+      ans = result + ans
+      i--
+      j--
+  }
+  if(carry!==0) {
+      ans = carry + ans
+  }
+  return ans
+};
+
+function add(n1, n2, lastCarry) {
+  let result = 0
+  let nextcarry = 0
+  let num = n1 + n2 + lastCarry
+  if(num >= 10) {
+      let strnum = String(num)
+      result = strnum.slice(1) * 1
+      nextcarry = strnum.slice(0,1) * 1
+  } else {
+      result = num
+  }
+  return {
+      result,
+      nextcarry
+  }
+}
+

js-code/code/最长连续递增序列.js

@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ 674. 最长连续递增序列
+ */
+ var findLengthOfLCIS = function(nums) {
+  let len = nums.length
+  let max = 0
+  let count = 1
+  for(let i = 0; i < len; i++) {
+      if(nums[i] < nums[i+1]) {
+          count++
+      } else {
+          max = Math.max(count, max)
+          count = 1
+      }
+  }
+  return max
+};

js-code/code/最长递增子序列.js

@@ -0,0 +1,28 @@
+// 动态规划，一个完整的问题，它可以分解成很多更小规模的子问题，然后由这些小规模的子问题，小规模问题的最优解，就可以推导出来整个问题的最优解
+// 只有你局部做到最优，那么你全局整个问题都是最优的
+// 动态规划：状态 + 选择
+/**
+[10,9,2,5,3,7,101,18]
+[10,9,2,5,3,7,101]
+[10,9,2,5,3,7] 18 3 + 1 = 4
+3
+ */
+/**
+ * @param {number[]} nums
+ * @return {number}
+ 300.最长递增子序列 #动态规划
+ */
+ var lengthOfLIS = function(nums) {
+  let len = nums.length
+  let max = 1
+  let dp = new Array(len).fill(1)
+  for (let i = 0; i<len; i++) {
+      for (let j = 0; j < i; j++) {
+          if(nums[j] <nums[i]) {
+              dp[i] = Math.max(dp[j] + 1, dp[i])
+          }
+      }
+      max = Math.max(dp[i], max)
+  }
+  return max
+};

js-code/js/Object.create.js

@@ -0,0 +1,9 @@
+// 传入的对象作为原型
+function create(ojb) {
+ // 构造函数
+ function F() {}
+ // 构造函数的原型 被 赋值为 传入的对象
+ F.prototype = ojb
+ // 返回新的对象实例
+ return new F()
+}

js-code/js/Promise.all.js

@@ -0,0 +1,59 @@
+// 接收一个Promie实例的数组或具有Iterator接口的对象作为参数
+// 这个方法返回一个新的promise对象
+// 遍历传入的参数，用Promise.resolve()将参数"包一层",使其变成一个promise对象
+// 参数所有回调成功才是成功，返回值数组与参数顺序一致
+// 参数数组其中一个失败，则触发失败状态，第一个触发失败的Promise错误信息作为Promise.all的错误信息
+
+// Promise.all 用来处理多个并发请求，也是为了页面数据构造的方便
+
+function promiseAll(promises) {
+ return new Promise(function(resolve, reject) {
+  // 返回一个promise
+  if(!Array.isArray(promises)) {
+   // 判断参数是否为数组
+   throw new TypeError(`argument must be a array`)
+  }
+  var resolvedCounter = 0; // 计算数量到达数组的长度
+
+  var resolvedResult = []; // 得到的结果
+  var promiseNum = promises.length; // 获取数组的长度
+
+  for(let i = 0; i < promiseNum; i++) {
+
+   Promise.resolve(promises[i]).then(value => {
+    resolvedCounter++;
+    resolvedResult[i] = value; // 放到结果数组里
+    // 判断是否是时候了
+    if(resolvedCounter === promiseNum) {
+     return resolve(resolvedResult) // 获取所有值进行return
+    }
+   }, error => {
+    return reject(error)
+   })
+
+  }
+
+ })
+}
+
+let p1 = new Promise(function(resolve, reject) {
+ setTimeout(function() {
+  resolve(1)
+ }, 1000)
+})
+
+let p2 = new Promise(function(resolve, reject) {
+ setTimeout(function() {
+  resolve(2)
+ }, 2000)
+})
+
+let p3 = new Promise(function(resolve, reject) {
+ setTimeout(function() {
+  resolve(3)
+ }, 3000)
+})
+
+promiseAll([p1, p2, p3]).then(res => {
+ console.log(res) // [ 1, 2, 3 ]
+})

js-code/js/Promise.race.js

@@ -0,0 +1,59 @@
+// Promise.race(iterable) 方法返回一个 promise，一旦迭代器中的某个promise解决或拒绝，返回的promise就会解决或拒绝
+
+function promiseRace(promises) {
+ return new Promise(function(resolve, reject) {
+  // 返回一个promise
+  if(!Array.isArray(promises)) {
+   // 判断参数是否为数组
+   throw new TypeError(`argument must be a array`)
+  }
+  var promiseNum = promises.length; // 获取数组的长度
+  for(let i = 0; i < promiseNum; i++) {
+
+   Promise.resolve(promises[i]).then(value => {
+     return resolve(value)
+   }, error => {
+    return reject(error)
+   })
+
+  }
+
+ })
+
+ // return new Promise(function(resolve, reject) {
+ //  if(!Array.isArray(promises)) {
+ //   throw new TypeError(`argument must be a array`)
+ //  }
+ //  var promiseNum = promises.length; // 获取数组的长度
+ //  for(let i = 0; i < promiseNum; i++) {
+ //   Promise.resolve(promises[i]).then(value => {
+ //    return resolve(value)
+ //   }, error => {
+ //    return reject(error)
+ //   })
+ //  }
+ // })
+}
+
+const promise1 = new Promise((resolve, reject) => {
+ setTimeout(resolve, 500, 'one');
+});
+
+const promise2 = new Promise((resolve, reject) => {
+ setTimeout(reject, 100, 'two');
+});
+
+Promise.race([promise1, promise2]).then((value) => {
+ console.log(value);
+ // Both resolve, but promise2 is faster
+},(error) => {
+ console.log(error);
+});
+// expected output: "two"
+
+promiseRace([promise1, promise2]).then((value) => {
+ console.log(value);
+ // Both resolve, but promise2 is faster
+},(error) => {
+ console.log(error);
+});

js-code/js/Promise.then.js

@@ -0,0 +1,43 @@
+// then方法返回一个新的promise实例
+// promise状态发生变化时 (resolve / reject 被调用时) 再执行then里的函数
+
+then(onFulfilled, onReject) {
+ // 保存前一个promise的this
+ const self = this;
+
+ return new MyPromise((resolve,reject) => {
+  // 封装前一个promise成功时执行的函数
+  let fulfilled = () => {
+   try {
+    const result = onFulfilled(self.value); // 承前
+    return result instanceof MyPromise ? result.then(resolve, reject) : resolve(result) 
+   } catch (err) {
+    reject(err)
+   }
+  }
+
+  // 封装前一个promise失败时执行的函数
+  let rejected = () => {
+   try{
+    const result = onReject(self.reason);
+    return result instanceof MyPromise ? result.then(resolve, reject) : reject(result)
+   } catch(err) {
+    reject(err)
+   }
+  }
+
+  switch(self.status) {
+   case PENDING:
+    self.onFulfilledCallbacks.push(fulfilled);
+    self.onRejectedCallbacks.push(reject);
+    break;
+   case FULFILLED: 
+    fulfilled();
+    break;
+   case REJECT:
+    rejected();
+    break;
+  }
+  
+ })
+}

js-code/js/apply.js

@@ -0,0 +1,30 @@
+// apply()方法调用一个具有给定this值的函数，以及一个数组的形式提供的参数
+
+Function.prototype.myApply = function(context) {
+ // 判断调用对象是否为函数，即使我们是定义在函数的原型上的
+ // 判断调用对象是否为函数
+ if(typeof this !== 'function') {
+  throw new TypeError('Error');
+ }
+ let result = null;
+ // 判断context是否存在，如果不存在为window
+ context = context || window;
+ // 将函数设为对象的方法
+ context.fn = this;
+ // 数组
+ if(arguments[1]) {
+  result = context.fn(...arguments[1])
+ } else {
+  result = context.fn()
+ }
+ // 将属性删除
+ delete context.fn;
+ return result;
+}
+
+const numbers = [5, 6, 2, 3, 7];
+
+const max = Math.max.apply(null, numbers);
+
+console.log(max);
+// expected output: 7

js-code/js/bind.js

@@ -0,0 +1,34 @@
+// bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。
+
+Function.prototype.myBind = function(context) {
+ // 判断调用对象是否为函数
+ if(typeof this !== 'function') {
+  throw new TypeError('Error')
+ }
+ // 获取参数
+ var args = [...arguments].slice(1)
+ fn = this;
+ return function(fn){
+  // 根据调用方式，传入不同绑定值
+  return fn.apply(
+   this instanceof Fn ? this : context,
+   args.concat(...arguments)
+  );
+ };
+};
+
+
+// const module = {
+//  x: 42,
+//  getX: function() {
+//    return this.x;
+//  }
+// };
+
+// const unboundGetX = module.getX;
+// console.log(unboundGetX()); // The function gets invoked at the global scope
+// expected output: undefined
+
+// const boundGetX = unboundGetX.bind(module);
+// console.log(boundGetX());
+// expected output: 42