某中型公司面试原题（下）

// 拦截器构造函数
function InterceptorManager() {
    this.handlers = [];
}
InterceptorManager.prototype.use = function use(fulfilled, rejected) {
    this.handlers.push({
        fulfilled: fulfilled,
        rejected: rejected
    });
    return this.handlers.length - 1;
};
// 请求拦截和响应拦截均是拦截器的实例化
function Axios(instanceConfig) {
    this.defaults = instanceConfig;
    this.interceptors = {
        request: new InterceptorManager(),
        response: new InterceptorManager()
    };
}
// 用数组存储执行链
var chain = [dispatchRequest, undefined];
var promise = Promise.resolve(config);
// 将请求拦截成对推入执行链的头部
// 知道这个原理以后，我们就知道在设置多个请求拦截时，会按照设置时的顺序，倒序处理
this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
    chain.unshift(interceptor.fulfilled, interceptor.rejected);
});
// 将响应拦截成对推入执行链的尾部，执行时按照设置时的顺序，正序处理
this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
    chain.push(interceptor.fulfilled, interceptor.rejected);
});
// 依次成对执行，并用新的promise代替旧的promise，最后返回最新的promise
while (chain.length) {
    promise = promise.then(chain.shift(), chain.shift());
}
return promise;
// 取消请求
function CancelToken(executor) {
  if (typeof executor !== 'function') {
    throw new TypeError('executor must be a function.');
  }
  // 在 CancelToken 上定义一个 pending 状态的 promise ，将 resolve 回调赋值给外部变量 resolvePromise
  var resolvePromise;
  this.promise = new Promise(function promiseExecutor(resolve) {
    resolvePromise = resolve;
  });
  var token = this;
  // 立即执行 传入的 executor函数，将真实的 cancel 方法通过参数传递出去。
  // 一旦调用就执行 resolvePromise 即前面的 promise 的 resolve，就更改promise的状态为 resolve。
  // 那么xhr中定义的 CancelToken.promise.then方法就会执行, 从而xhr内部会取消请求
  executor(function cancel(message) {
    // 判断请求是否已经取消过，避免多次执行
    if (token.reason) {
      return;
    }
    token.reason = new Cancel(message);
    resolvePromise(token.reason);
  });
}
CancelToken.source = function source() {
  // source 方法就是返回了一个 CancelToken 实例，与直接使用 new CancelToken 是一样的操作
  var cancel;
  var token = new CancelToken(function executor(c) {
    cancel = c;
  });
  // 返回创建的 CancelToken 实例以及取消方法
  return {
    token: token,
    cancel: cancel
  };
};

.hide {
    display:none;
}

.hidden{
  visibility:hidden
}

.transparent {
  opacity:0;
}

justify-content:space-around;
 /**
 *center:水平居中,
 *flex-start:靠左;
 *flex-end:靠右；
 *space-between:两边的向两边靠，中间等分；
 *space-around:完美的平均分配
 **/

align-items:stretch;
/**
*center:垂直居中、
*flex-start：至顶、
*flex-end:至底、
*space-between、
*space-around
**/

flex-direction: row;
 /**
 *column从上向下的排列，
 *column-reverse、
 *row:从左到右，
 *row-reverse:从右向左
 **/

flex-wrap:wrap;
/**
*wrap多行显示（父容器不够显示的时候，从上到下）、
*nowrap(当容器不够宽的时候，子元素会平分父容器的宽或者高)、
*wrap-reverse:从下向上
**/

import {
  init,
  classModule,
  propsModule,
  styleModule,
  eventListenersModule,
  h,
} from "snabbdom";
// 创建patch函数
let patch = init([classModule, propsModule, styleModule, eventListenersModule]);
// 创建一个虚拟节点，但是它还没有在DOM树上。要想把它放在DOM树上，需要patch函数
let vnode1 = h('a', {props: {href: 'http://www.baidu.com',target:'_blank'}}, '百度一下')
let container = document.getElementById('container');
// 让虚拟结点上树，patch函数只能让一个虚拟结点上树。如果vnode2和vnode3要上树，需要把这个注释掉
patch(container, vnode1);
let vnode2 = h('div',{class:{"box":true}},'我是一个盒子');
let vnode3 = h('ul',{},[
    h('li','苹果'), // 第二个参数可以没有
    h('li','香蕉'), // 这里已经调用了h函数
    h('li',[
        h('p',{},'桔子'),
        h('p',{},'哈哈')
    ]),
    h('li','西瓜'),
    h('li',h('span','火龙果')) // 如果children只有一个子元素，第三个参数可以不要数组
]);

window.onhashchange = function(event){
  console.log(event.oldURL, event.newURL);
  let hash = location.hash.slice(1);
  document.body.style.color = hash;
}

window.history.pushState(stateObject, title, URL)
window.history.replaceState(stateObject, title, URL)

location / {
    try_files $uri $uri/ /index.html;
  }

<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteBase /
    RewriteRule ^index\.html$ - [L]
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    RewriteRule . /index.html [L]
  </IfModule>

const http = require('http')
  const fs = require('fs')
  const httpPort = 80
  http.createServer((req, res) => {
    fs.readFile('index.htm', 'utf-8', (err, content) => {
      if (err) {
        console.log('We cannot open "index.htm" file.')
      }
      res.writeHead(200, {
        'Content-Type': 'text/html; charset=utf-8'
     })
      res.end(content)
    })
  }).listen(httpPort, () => {
    console.log('Server listening on: http://localhost:%s', httpPort)
  })