cristinazhou / blog Goto Github PK

if (!Array.isArray) {
  Array.isArray = function(arg) {
    return Object.prototype.toString.call(arg) === '[object Array]';
  };
}

function new_instance_of(left, right) { 
    let rightProto = right.prototype; // 取右表达式的 prototype 值
    left = left.__proto__; // 取左表达式的__proto__值
    while (true) {
    	if (left === null) {
            return false;	
        }
        if (left === rightProto) {
            return true;	
        } 
        left = left.__proto__ 
    }
}

输入：nums = [10,9,2,5,3,7,101,18]
输出：4
解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

var lengthOfLIS = function(nums) {
    const len = nums.length;
    if (len < 2) {
        return len;
    }
let max = 0;
const dp = new Array(len).fill(1); // 以i为结尾的最⻓⼦串的⻓度
    for (let i = 1; i< len; i++) {
        for (let j = 0; j < i; j++) {
            if (nums[i] > nums[j]) {
                dp[i] = Math.max(dp[j] + 1, dp[i]);
            }
        }
    max = Math.max(dp[i], max);
    }
return max;

};

const template = 'I'm ${name}, i love ${city}.'
const context = {name: 'coder',city: 'shanghai'}
处理后结果：I'm coder, i love shanghai.  (写的时候没用正则，硬拆字符串弄出来的 -_-||)

function parse_str(template, context) {
      return template.replace(/\$\{(.+?)\}/g, (match, key) => context[key]);
 }

//  .*? 是正则固定搭配用法，表示非贪婪匹配模式，尽可能匹配少的，

最小K个数
输入： arr = [1,3,5,7,2,4,6,8], k = 4
输出： [1,2,3,4]
var smallestK = function(arr, k) {
    if (k >= arr.length) {
        return arr;
    }
    quickSort(arr, 0, arr.length - 1, k);
    return arr.slice(0, k);
};

function quickSort(arr, start, end, k) {
    if (start > k || start >= end) {
        return ;
    }
    let left = start;
    let right = end;
    let mid = arr[left];
    while(left < right) {
        while(left < right && arr[right] >= mid) {
            right--;
        }
        if (left < right) {
            arr[left++] = arr[right];
        }
        while(left < right && arr[left] <= mid) {
            left++;
        }
        if (left < right) {
            arr[right--] = arr[left];
        }
    }
    arr[left] = mid;
    if (left === k) {
        return ;
    }
    quickSort(arr, start, left - 1, k);
    quickSort(arr, left + 1, end, k);
}

Fisher-Yates洗牌算法的一个变种是KnuthShuffle每次从未处理的数组中随机取一个元素，然后把该元素放到数组的尾部，即数组的尾部放的就是已经处理过的元素，这是一种原地打乱的算法，每个元素随机概率也相等，时间复杂度从Fisher算法的O(n2)提升到了O(n)
1.选取数组(长度n)中最后一个元素(arr[length-1])，将
其与n个元素中的任意一个交换，此时最后一个元素
已经确定;
2.选取倒数第二个元素(arrflength-2])，将其与n-1个元
素中的任意一个交换;
3.重复第12步，直到剩下1个元素为止
function shuffle( arr ) {
var length=arr.Length, temp, random;
while(0 != length) {
    random=Math.floor(Math.random() * length)
    length--;
    // swap
    temp=arr[lengthl;
    arr[lengthl=arr[random]
    arr[random]=temp;
    return arr;
}

减少HTTP请求次数
1、http 强缓存

提高HTTP请求得响应速度
1、CDN
2、DNS Prefetch
3、http2

减小资源大小
1、 代码压缩
2、图片压缩
3、代码拆分

优化资源加载时机
1、按需加载
2、懒加载
3、预加载

优化资源加载方式
1、客户端内H5 可考虑使用离线包
2、内容直出SSR

let url = https://github.com/cristinazhou/Blog/issues/5?a=%E5%8C%97%E4%BA%AC&b=1&b=3&c

解析成 
object = {

a: '北京'，// 中文解析
b: [ 1, 3],   // 相同参数解析为数组
c: true   // 没有值的参数 赋值为true
}


function parseURL(url) {
  const queryIndex = url.indexOf('?');
  const queryString = url.slice(queryIndex + 1);
  
  const params = new URLSearchParams(queryString);
  const object = {};

  for (const [key, value] of params.entries()) {
    if (value === '') {
      object[key] = true;
    } else {
      if (object.hasOwnProperty(key)) {
        if (Array.isArray(object[key])) {
          object[key].push(value);
        } else {
          object[key] = [object[key], value];
        }
      } else {
        object[key] = decodeURIComponent(value);
      }
    }
  }

  return object;
}

// 示例用法：
const url = 'https://github.com/cristinazhou/Blog/issues/5?a=%E5%8C%97%E4%BA%AC&b=1&b=3&c';
const parsedObject = parseURL(url);
console.log(parsedObject);

// middleware 函数签名
type MiddlewareAPI = { dispatch: Dispatch, getState: () => State } 
type Middleware = (api: MiddlewareAPI) => (next: Dispatch) => Dispatch 
// 最外层函数的作用是接收middlewareApi ，给middleware提供store 的部分api，它返回的函数参与compose，以实现middleware的链式调用。

export default function applyMiddleware(...middlewares) {
    return (createStore) =>{             
            // 初始化store，拿到dispatch             
            const store = createStore(reducer, preloadedState)             
            // 不允许在middlware中调用dispath             
            let dispatch: Dispatch = () => {                 
                throw new Error(                     
                'Dispatching while constructing your middleware is not allowed. ' +                     'Other middleware would not be applied to this dispatch.'                 
                )             
            }             
            const middlewareAPI: MiddlewareAPI = {
                getState: store.getState,                 
                dispatch: (action, ...args) => dispatch(action, ...args)
            }            
            // 把api注入middlware             
            const chain = middlewares.map(middleware => middleware(middlewareAPI))                 // 重点理解
            // compose后传入dispatch，生成一个新的经过层层包装的dispath调用链
            dispatch = compose<typeof dispatch>(...chain)(store.dispatch)
            // 替换掉dispath，返回
            return {                 
                ...store,                 
                dispatch             
            }         
        } 
} 

export default function compose(...funcs) {
    if (funcs.length === 0) {
        return (arg) => arg
    }
    if (funcs.length === 1) {
        return funcs[0]
    }
    // 简单直接的compose
    return funcs.reduce(
        (a, b) =>
            (...args: any) =>
                a(b(...args))
    )
}

1、快排 （原地排序）
2、洗牌算法
3、url 解析