🔥前端面试大厂手写源码系列(上)

如今前端攻城狮的要求越来越高,会使用常见的API已经不能满足现如今前端日益快速发展的脚步。现在大厂基本都会要求面试者手写前端常见API的原理,以此来证明你对该知识点的理解程度。接下来,我将列举我面试时以及自认为比较重要的CSS部分、JS部分常见手写原理题!后续分享Vue全家桶、React全家桶手写原理图,敬请期待!

JS部分

手写原生Ajax

平时项目开发中,一定会用到ajax请求后端接口获取数据在前端渲染效果。目前市面上有很多封装好的ajax请求库,例如:jQuery版的ajax、基于Promise的Axios请求库、Flyio等等。目前很多人都只会使用这些API,但是如今面试经常会被问到:你了解ajax原理吗?你知道原生ajax实现步骤吗?...接下来,我将封装一个完整的原生ajax。

一个完整的 ajax 请求一般包括以下步骤:
  • 实例化 XMLHttpRequest 对象
  • 连接服务器
  • 发送请求
  • 介绍
function ajax(options) {
  let method = options.method || 'GET', // 不传则默认为GET请求
      params = options.params, // GET请求携带的参数
      data   = options.data, // POST请求传递的参数
      url    = options.url + (params ? '?' + Object.keys(params).map(key => key + '=' + params[key]).join('&') : ''),
      async  = options.async === false ? false : true,
      success = options.success,
      headers = options.headers;

  let xhr;
  // 创建xhr对象
  if(window.XMLHttpRequest) {
    xhr = new XMLHttpRequest();
  } else {
    xhr = new ActiveXObject('Microsoft.XMLHTTP');
  }

  xhr.onreadystatechange = function() {
    if(xhr.readyState === 4 && xhr.status === 200) {
      success && success(xhr.responseText);
    }
  }

  xhr.open(method, url, async);

  if(headers) {
    Object.keys(Headers).forEach(key => xhr.setRequestHeader(key, headers[key]))
  }

  method === 'GET' ? xhr.send() : xhr.send(data)
}

注意:IE5、6不兼容XMLHttpRequest,所以要使用ActiveXObject()对象,并传入 'Microsoft.XMLHTTP',达到兼容目的。

  • readyState的五种状态详解:

    0 - (未初始化)还没有调用send()方法

    1 - (载入)已调用send()方法,正在发送请求

    2 - (载入完成)send()方法执行完成,已经接收到全部响应内容

    3 - (交互)正在解析响应内容

    4 - (完成)响应内容解析完成,可以在客户端调用了

手写防抖和节流

如今前端界面效果越来越复杂,有一些频繁操作会导致页面性能和用户体验度低。像:输入框搜索会频繁调端口接口、放大缩小窗口等。

防抖 - debounce 当持续触发事件时,一定时间段内没有再触发事件,事件处理函数才会执行一次,如果设定的时间到来之前,又一次触发了事件,就重新开始延时。
const debounce = (fn, delay) => {
  let timer = null;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => {
      fn.apply(this, args);
    }, delay);
  };
};
节流 - throttle 当持续触发事件时,保证一定时间段内只调用一次事件处理函数。
const throttle = (fn, delay = 500) => {
  let flag = true;
  return (...args) => {
    if (!flag) return;
    flag = false;
    setTimeout(() => {
      fn.apply(this, args);
      flag = true;
    }, delay);
  };
};

手写jsonp的实现原理

function jsonp({url, params, cb}) { 
   return new Promise((resolve, reject) => {
     window[cb] = function (data) {  // 声明全局变量
        resolve(data)
        document.body.removeChild(script)
      }
      params = {...params, cb}
      let arrs = []
      for(let key in params) {
         arrs.push(`${key}=${params[key]}`)
      }
      let script = document.createElement('script')
      script.src = `${url}?${arrs.join('&')}`
      document.body.appendChild(script)
   })
}

jsonp的缺点

  1. 只能发送Get请求 不支持post put delete
  2. 不安全 xss攻击

手写apply的实现原理

apply 的实现原理和 call 的实现原理差不多,只是参数形式不一样。--- 数组

Function.prototype.apply = function(content = window) {
    content.fn = this;
    let result;
    // 判断是否有第二个参数
    if(arguments[1]) {
        result = content.fn(...arguments[1]);
    } else {
        result = content.fn();
    }
    delete content.fn;
    return result;
}

注意:当apply传入的第一个参数为null时,函数体内的this会指向window。

手写bind的实现原理

bind 方法会创建一个新函数。当这个新函数被调用时,bind() 的第一个参数将作为它运行时的 this,之后的一序列参数将会在传递的实参前传入作为它的参数。
Function.prototype.bind = function(content) {
   if(typ this != 'function') {
      throw Error('not a function');
   }
   let _this = this;
   let args = [...arguments].slice(1);
   return function F() {
      // 判断是否被当做构造函数使用
      if(this instanc F) {
         return _this.apply(this, args.concat([...arguments]))
      }
      return _this.apply(content, args.concat([...arguments]))
   }
}

手写call的实现原理

call语法:fun.call(thisArg, arg1, arg2, arg3, .....)

call 的核心原理:

  • 将函数设为对象的属性
  • 执行和删除这个函数
  • 指定this到函数并传入给定参数执行函数
  • 如果不传参数,默认指向window
Function.prototype.call2 = function(content = window) {
    // 判断是否是underfine和null
    // if(typ content === 'undefined' || typ content === null){
    //     content = window
    // }
    content.fn = this;
    let args = [...arguments].slice(1);
    let result = content.fn(...args);
    delete content.fn;
    return result;
}

注意:当call传入的第一个参数为null时,函数体内的this会指向window。

手写new的实现原理

实现一个new操作符的具体实现步骤:
  • 首先函数接受不定量的参数,第一个参数为构造函数,接下来的参数被构造函数使用
  • 然后内部创建一个空对象 obj
  • 因为 obj 对象需要访问到构造函数原型链上的属性,所以我们通过 setPrototypeOf 将两者联系起来。这段代码等同于 obj.__proto__ = Con.prototype
  • 将 obj 绑定到构造函数上,并且传入剩余的参数
  • 判断构造函数返回值是否为对象,如果为对象就使用构造函数返回的值,否则使用 obj,这样就实现了忽略构造函数返回的原始值
/**
 * 创建一个new操作符
 * @param {*} Con 构造函数
 * @param  {...any} args 忘构造函数中传的参数
 */
  function createNew(Con, ...args) {
    let obj = {} // 创建一个对象,因为new操作符会返回一个对象
    Object.setPrototyp(obj, Con.prototype) // 将对象与构造函数原型链接起来
    // obj.__proto__ = Con.prototype // 等价于上面的写法
    let result = Con.apply(obj, args) // 将构造函数中的this指向这个对象,并传递参数
    return result instanc Object ? result : obj
}

注意

一、new操作符的几个作用:

  1. new操作符返回一个对象,所以我们需要在内部创建一个对象
  2. 这个对象,也就是构造函数中的this,可以访问到挂载在this上的任意属性
  3. 这个对象可以访问到构造函数原型链上的属性,所以需要将对象与构造函数链接起来
  4. 返回原始值需要忽略,返回对象需要正常处理

二、new操作符的特点:

  1. new通过构造函数Test创建处理的实例可以访问构造函数中的属性也可以访问构造函数原型链上的属性,所以:通过new操作符,实例与构造函数通过原型链连接了起来
  2. 构造函数如果返回原始值,那么这个返回值毫无意义
  3. 构造函数如果返回对象,那么这个返回值会被正常的使用,导致new操作符没有作用

手写instanceof的实现原理

instanceof 用来检测一个对象在其原型链中是否存在一个构造函数的 prototype 属性
function instanc(left,right) {
    let proto = left.__proto__;
    let prototype = right.prototype
    while(true) {
        if(proto === null) return false
        if(proto === prototype) return true
        proto = proto.__proto__;
    }
}

手写Promise A+规范

在面试中高级前端时。要求被手写Promise A+规范源码是必考题了。如果想详细了解,请参考 一步步教你实现Promise/A+ 规范 完整版

class Promise {
    constructor(executor) {
        this.status = 'pending' // 初始化状态
        this.value = undefined // 初始化成功返回的值
        this.reason = undefined // 初始化失败返回的原因

        // 解决处理异步的resolve
        this.onResolvedCallbacks = [] // 存放所有成功的resolve
        this.onRejectedCallbacks = [] // 存放所有失败的reject

        /**
         * @param {*} value 成功返回值
         * 定义resolve方法
         * 注意:状态只能从pending->fulfilled和pending->rejected两个
         */
        const resolve = (value) => { 
            if(this.status === 'pending') {
                this.status = 'fulfilled' // 成功时将状态转换为成功态fulfilled
                this.value = value // 将成功返回的值赋值给promise
                // 为了解决异步resolve以及返回多层promise
                this.onResolvedCallbacks.forEach(fn => {
                    fn() // 当状态变为成功态依次执行所有的resolve函数
                })
            }
        }
        const reject = (reason) => {
            if(this.status === 'pending') {
                this.status = 'rejected' // 失败时将状态转换为成功态失败态rejected
                this.reason = reason // 将失败返回的原因赋值给promise
                this.onRejectedCallbacks.forEach(fn => {
                    fn() // 当状态变为失败态依次执行所有的reject函数
                })
            }
        }
        executor(resolve, reject) // 执行promise传的回调函数
    }
    /**
     * 定义promise的then方法 
     * @param {*} onFulfilled 成功的回调
     * @param {*} onRejected 失败的回调
     */
    then(onFulfilled, onRejected) {
        // 为了解决then方法返回Promise的情况
        const promise2 = new Promise((resolve, reject) => {
            if(this.status === 'fulfilled') { // 如果状态为fulfilled时则将值传给这个成功的回调
                setTimeout(() => {
                    const x = onFulfilled(this.value) // x的值有可能为 promise || 123 || '123'...
                    // 注意:此时调用promise2时还没有返回值,要用setTimeout模拟进入第二次事件循环;先有鸡先有蛋
                    resolvePromise(promise2, x, resolve, reject) 
                }, 0)
            }
            if(this.status === 'rejected') {
                setTimeout(() => {
                    const x = onRejected(this.reason) // 如果状态为rejected时则将视频的原因传给失败的回调
                    resolvePromise(promise2, x, resolve, reject) 
                }, 0)
            }
            if(this.status === 'pending') { // 记录-》解决异步
                this.onResolvedCallbacks.push(() => {
                    setTimeout(() => {
                        const x = onFulfilled(this.value)
                        resolvePromise(promise2, x, resolve, reject) 
                    }, 0)
                })
                this.onRejectedCallbacks.push(() => {
                    setTimeout(() => {
                        const x = onRejected(this.reason)
                        resolvePromise(promise2, x, resolve, reject) 
                    }, 0)
                })
            }
        })
        return promise2; // 解决多次链式调用的问题
    }
}

const resolvePromise = (promise2, x, resolve, reject) => {
    // console.log(promise2, x, resolve, reject)
    if(promise2 === x) { // 如果返回的值与then方法返回的值相同时
        throw TypeError('循环引用')
    }
    // 判断x是不是promise;注意:null的typ也是object要排除
    if(typ x === 'function' || (typ x === 'object' && x !== null)) {
        try {
            const then = x.then // 获取返回值x上的then方法;注意方法会报错要捕获异常;原因111
            if(typ then === 'function') { // 就认为是promise
                then.call(x, y => {
                    // resolve(y)
                    // 递归解析 ; 有可能返回多个嵌套的promise
                    resolvePromise(promise2, y, resolve, reject)
                }, r => {
                    reject(r)
                })
            }
        } catch(e) {
            reject(e)
        }
    } else {
        resolve(x);
    }
}
module.exports = Promise;

手写JS深浅拷贝

对象深浅拷贝,是面试常见的面试题之一。

原对象:

let obj = {
   a: 100,
   b: [100, 200, 300],
   c: {
      x: 10
   },
   d: /^\d+$/
}
浅克隆

浅克隆 只克隆第一层

方法一:

let obj2 = {...obj};

方法二:

let obj2 = {};
for(let key in obj) {
   if(!obj.hasOwnProperty(key)) break;
   obj2[key] = obj[key];
}
深克隆

注意:在函数、日期、正则表达式时,JSON.stringify时,都会被转换成对象{}

方法一:

let obj3 = JSON.parse(JSON.stringify(obj));

方法二:

function deepClone(obj) {
    // 过滤一些特殊情况
    if(obj === null) return null;
    if(typ obj !== "object") return obj;
    if(obj instanc RegExp) { // 正则
         return new RegExp(obj);
    }
    if(obj instanc Date) { // 日期
         return new Date(obj);
    }
    // let newObj = {}
    // let newObj = new Object()
    let newObj = new obj.constructor; // 不直接创建空对象的目的:克隆的结果和之前保持所属类  =》 即能克隆普通对象,又能克隆某个实例对象
    for(let key in obj) {
        if(obj.hasOwnProperty(key)) {
             newObj[key] = deepClone(obj[key]);
        }
    }
    return newObj;
}

Symbol的用法以及常见应用

// Symbol 基本数据类型 string number boolean null undefined
// Symbol对象数据类型 object

// 特点:独一无二 永远不相等
let s1 = Symbol('tmc'); // symbol中的标识 一般只放number或string 不然结果返回Symbol([object Object])
let s2 = Symbol();
console.log(s1 === s2)

let obj = {
    [s1]: 1,
    a: 2
}
// 声明的Symbol属性是不可枚举的 for - in 可以遍历自身属性和原型上的属性ß
for(let key in obj) {
    console.log(obj[key])
}
// 获取对象上的属性
console.log(Object.getOwnPropertySymbols(obj));

let s3 = Symbol.for('tmc');
let s4 = Symbol.for('tmc');
console.log(s3 === s4);
// 通过Symbol来获取key值
console.log(Symbol.keyFor(s3))

// Symbol 内置对象
// Symbol.iterator 实现对象的遍历
// 元编程 可以去对原生js的操作进行修改
let instance = {
    [Symbol.hasInstance](value) {
        return 'a' in value;
    }
};
console.log({a: 3} instanc instance)

let arr = [1, 2, 3];
arr[Symbol.isConcatSpreadable] = false; // 拼接数组时不展开
console.log([].concat(arr, [1, 2, 3]));

// match split search方法
let obj1 = {
    [Symbol.match](value) {
        return value.length === 3;
    }
}
console.log('abc'.match(obj1));

//species 衍生对象
class MyArray extends Array {
    constructor(...args) {
        super(...args)
    }
    // 强制修改一下
    static get [Symbol.species]() {
        return Array
    }
}
let v = new MyArray(1, 2, 3);
let c = v.map(item => item*=2); // c是v的衍生对象
console.log(c instanc MyArray)

// Symbol.toPrimitive
// 数据类型转化
let obj3 = {
    [Symbol.toPrimitive](type) {
        console.log(type)
        return 123
    }
}
console.log(obj++)

// Symbol.toStringTag
let obj5 = {
    [Symbol.toStringTag]: 'xxxx'
}

console.log(Object.prototype.toString.call(obj5));

函数柯里化

柯里化(Currying)是把接受多个参数的函数变换成接受一个单一参数(最初函数的第一个参数)的函数,并且返回接受余下的参数且返回结果的新函数的技术
 // 通用版
function curry(fn, args) {
    var length = fn.length;
    var args = args || [];
    return function() {
        newArgs = args.concat(Array.prototype.slice.call(arguments))
        console.log(newArgs)
        if(newArgs.length < length) {
            return curry.call(this, fn, newArgs);
        } else {
            return fn.apply(this, newArgs);
        }
    }
}
function multiFn(a, b, c) {
    console.log(a * b * c)
    return a * b * c;
}

var multi = curry(multiFn);
multi(2)(3)(4);
// multi(2, 3, 4)
// multi(2)(3, 4)
// multi(2, 3)(4)

注意函数柯里化的主要作用和特点就是参数复用、提前返回和延迟执行。

JS数组

去重

普通项

let arr2 = [1, 2, 3, 2, 33, 55, 66, 3, 55];

第一种:

let newArr = [];
   arr2.forEach(item => {
       if(newArr.indexOf(item) == '-1') {
           newArr.push(item);
       }
   })
console.log(newArr);

// (6) [1, 2, 3, 33, 55, 66]

第二种:

let newArr = [...new Set(arr2)];
console.log(newArr);

// (6) [1, 2, 3, 33, 55, 66]

注意:Array.from()、filter()、for()等方法都可以完成上面数组去重。

对象项
let arr1 = [
    {id: 1, name: '汤小梦'},
    {id: 2, name: '石小明'},
    {id: 3, name: '前端开发'},
    {id: 1, name: 'web前端'}
];

实现方法:

const unique = (arr, key) => {
    return [...new Map(arr.map(item => [item[key], item])).values()]
}
console.log(unique(arr1, 'id'));

// [
    {id: 1, name: "web前端"},
    {id: 2, name: "石小明"},
    {id: 3, name: "前端开发"}
]

合并

let arr3 = ['a', 'b']
let arr4 = ['c', 'd']

方法一:ES5

let arr5 = arr3.concat(arr4);
console.log(arr5);

// ['a', 'b', 'c', 'd']

方法一:ES6

let arr6 = [...arr3, ...arr4];
console.log(arr6);

// ['a', 'b', 'c', 'd']

展平

let arr7 = [1, 2, [3, 4], [5, 6, [7, 8, 9]]];

第一种:

let arrNew = arr7.flat(Infinity);
console.log(arrNew);

// (9) [1, 2, 3, 4, 5, 6, 7, 8, 9]

第二种:

let arrNew = arr7.join().split(',').map(Number);
console.log(arrNew);

// (9) [1, 2, 3, 4, 5, 6, 7, 8, 9]

第三种:

let arrNew = arr7.toString().split(',').map(Number);
console.log(arrNew);

// (9) [1, 2, 3, 4, 5, 6, 7, 8, 9]

第四种:

const flattern = (arr) => {
     const result = []
     arr.forEach((item) => {
         if (Array.isArray(item)) {
              result.push(...flattern(item))
         } else {
              result.push(item)
         }
    })
    return result
}
flattern(arr7);

// (9) [1, 2, 3, 4, 5, 6, 7, 8, 9]

是否为数组

let arr = []

第一种:instanceof

console.log(arr instanc Array)

第二种:constructor

console.log(arr.constructor === Array)

第三种:判断对象是否有 push 等数组的一些方法

console.log(!!arr.push && !!arr.concat)

第四种: toString

console.log(Object.prototype.toString.call(arr) === '[object Array]')

第五种:Array.isArray

console.log(Array.isArray(arr))

注意:第五种方式最优~

CSS部分

三角形

画三角形的原理就是使用border属性加transparent(透明)来完成的。下面我将列举常见的三角形的实现方法。

等腰直角

css部分

.box1 {
   border-width: 100px;
   border-color: transparent tomato transparent transparent;
}

html部分

<div class="box1"/>

效果图:

等边

css部分

.box2 {
   border-width: 100px 173px;
   border-color: transparent transparent tomato transparent;
}

html部分

<div class="box2"/>

效果图:

等腰

css部分

.box3 {
   border-width: 100px 80px;
   border-color: transparent transparent tomato transparent;
}

html部分

<div class="box3"/>

效果图:

其他

css部分

.box4 {
   border-width: 100px 90px 80px 70px;
   border-color: transparent transparent transparent tomato;
}

html部分

<div class="box4"/>

效果图:

两栏布局

两栏布局:左右两栏,左边固定,右边自适应

效果图

  1. 第一种方式 --- 浮动

    HTML部分:

    <div class="outer outer1">
        <div class="left">1-left</div>
        <div class="right">1-right</div>
    </div>

    CSS部分:

    .outer1 .left {
        width: 200px;
        float: left;
    }
    .outer1 .right {
        width: auto;
        margin-left: 200px;
    }
  2. 第二种方式 --- flex

    HTML部分:

    <div class="outer outer2">
        <div class="left">2-left</div>
        <div class="right">2-right</div>
    </div>

    CSS部分:

    .outer2 {
       display: flex;
    }
    .outer2 .left {
       flex: 0 0 200px;
       /* flex-grow: 0;
       flex-shrink:0;
       flex-basis:200px; */
    }
    .outer2 .right {
       flex: auto;
    }
    
    注意:flex: 0 0 200px是flex: flex-grow flex-shrink flex-basis的简写
  3. 第三种方式 --- position

    HTML部分:

    <div class="outer outer3">
       <div class="left">3-left</div>
       <div class="right">3-right</div>
    </div>

    CSS部分:

    .outer3 {
       position: relative;
    }
    .outer3 .left {
       position: absolute;
       width: 200px;
    }
    .outer3 .right {
       margin-left: 200px;
    }
  4. 第四种方式 --- position again

    HTML部分:

    <div class="outer outer4">
        <div class="left">4-left</div>
        <div class="right">4-right</div>
    </div>

    CSS部分:

    .outer4 {
        position: relative;
    }
    .outer4 .left {
        width: 200px;
    } 
    .outer4 .right {
        position: absolute;
        top: 0;
        left: 200px;
        right: 0;
    }

三栏布局

三栏布局: 中间列自适应宽度,旁边两侧固定宽度

效果图

  1. 第一种方式 --- 定位

    HTML部分:

    <div class="outer outer1">
       <div class="left">1-left</div>
       <div class="middle">1-middle</div>
       <div class="right">1-right</div>
    </div>

    CSS部分:

    .outer1 {
       position: relative;
    }
    .outer1 .left {
       position: absolute;
       width: 100px;
    }
    .outer1 .middle {
       margin: 0 200px 0 100px;
    }
    .outer1 .right {
       position: absolute;
       width: 200px;
       top: 0;
       right: 0;
    }
    注意:左右分别使用绝对定位,中间设置外边距
  2. 第二种方式 --- flex布局

    HTML部分:

    <div class="outer outer2">
       <div class="left">2-left</div>
       <div class="middle">2-middle</div>
       <div class="right">2-right</div>
    </div>

    CSS部分:

    .outer2 {
       display: flex;
    }
    .outer2 .left {
       flex: 0 0 100px;
    }
    .outer2 .middle {
       flex: auto;
    }
    .outer2 .right {
       flex: 0 0 200px;
    }
  3. 第三种方式 --- 浮动原理

    HTML部分:

    <div class="outer outer3">
       <div class="left">3-left</div>
       <div class="right">3-right</div>
       <div class="middle">3-middle</div>
    </div>

    CSS部分:

    .outer3 .left{
       float: left;
       width: 100px;
    }
    .outer3 .right {
       float: right;
       width: 200px;
    }
    .outer3 .middle {
       margin: 0 200px 0 100px;
    }

圣杯布局

圣杯布局: 中间的优先渲染,独立的左中右结构

具体实现圣杯布局的步骤:

  1. 让左右浮动在一行显示,相对定位
  2. 让中间模块的middle宽度为100%
  3. 让左边的色块移动到middle前面,margin-left:-100%
  4. 让右边的色块移动到middle的后面,margin-left:-宽度
  5. 给三个小块的父元素加一个内填充的属性padding,为的是填充挤到中间
  6. 给左边的块移动到左边left:-200px, 给右边的块移动到右边right:-200px

效果图

HTML部分:

<header>header</header>
   <div class="container">
      <div class="middle">midlle</div>
      <div class="left">left</div>
      <div class="right">right</div>
   </div>
<footer>footer</footer>

CSS部分:

header, footer {
   height: 100px;
   width: 100%;
   background-color: antiquewhite;
}
.container {
   height: 200px;
   padding-left: 200px;
   padding-right: 300px;
}
.container > div {
   float: left;
   position: relative;
   height: 100%;
}
.left {
   width: 200px;
   height: 200px;
   background-color: burlywood;
   margin-left: -100%;
   left: -200px;
}
.right {
   width: 300px;
   height: 200px;
   background-color: burlywood;
   margin-left: -300px;
   right: -300px;
}
.middle {
   width: 100%;
   height: 200px;
   background-color: #b0f9c2;
}

双飞翼布局

双飞翼布局

具体实现双飞翼布局的步骤:

  1. 给左,中,右 加浮动,在一行显示
  2. 给middle宽度为100%
  3. 让左边的模块移动middle的左边 margin-left:-100%
  4. 让右边的模块移动middle的右边 margin-left:-自己宽度
  5. 给middle里面的容器添加外间距 margin: 左右

效果:

html部分

<div class="main">
    <div class="middle">
            <div class="middle-inner">中间</div>
    </div>
    <div class="left">左边</div>
    <div class="right">右边</div>
</div>

css部分

.main>div { 
    float:left;
    position: relative;
    height: 300px; 
}
.middle { 
    width: 100%;
    background-color: lightgreen 
}
.left { 
   width:200px;
   margin-left:-100%;
   background-color:#b0f9c2 
}
.right { 
   width: 200px;
   margin-left:-200px;
   background-color:pink 
}
.middle-inner{
   margin:0 200px; 
   background-color: burlywood; 
   height:300px;
}

水平垂直居中

html部分

<div class="box" id="box">
   石小明
</div>

css部分

公共部分

body {
    width: 100vw;
    height: 100vh;
    overflow: hidden;
}
.box {
    box-sizing: border-box;
    width: 100px;
    height: 50px;
    line-height: 50px;
    text-align: center;
    font-size: 16px;
    border: 1px solid lightblue;
    background: lightcyan;
}

第一种:定位

.box {
    position: absolute;
    top: 50%;
    left: 50%;
    margin-left: -50px;
    margin-top: -25px;
}

注意:上面的方式是一定要知道具体的宽高。但下面的方式是知道宽高,但是没有用到宽高。

第二种:flex

body {
    display: flex;
    justify-content: center;
    align-items: center;
}

注意:这种方式也是兼容性不是很好

第三种:JavaScript

let html = document.documentElement,
            winW = html.clientWidth,
            winH = html.clientHeight,
            boxW = box.offsetWidth, // offsetWidth带边框
            boxH = box.offsetHeight;

            box.style.position = 'absolute';
            box.style.left = (winW - boxW) / 2 + 'px';
            box.style.top = (winH - boxH) / 2 + 'px';

第四种:table-cell

body {
    display: table-cell;
    vertical-align: middle;
    text-align: center;
}

总结

上面总结的常见的CSS、JS部分手写原理题。希望有小伙伴需要的请认真思考阅读,必有收获。希望您取得满意的offer~❤️

最后

欢迎大家加入,一起学习前端,共同进步!




原文链接:segmentfault.com

上一篇:webpack 入口起点(Entry Points)
下一篇:2020前端面试经验总结

相关推荐

  • 🚩Vue源码——组件是如何注册的

    最近参加了很多场面试,几乎每场面试中都会问到Vue源码方面的问题。在此开一个系列的专栏,来总结一下这方面的经验,如果觉得对您有帮助的,不妨点个赞支持一下呗。 前言 在上一篇 🚩Vue源码——组件...

    1 个月前
  • 🚩Vue源码——组件如何渲染成最终的DOM

    最近参加了很多场面试,几乎每场面试中都会问到Vue源码方面的问题。在此开一个系列的专栏,来总结一下这方面的经验,如果觉得对您有帮助的,不妨点个赞支持一下呗。 前言 Vue有两个核心思想,一个是数据...

    1 个月前
  • 🚩Vue源码——如何监听数据变化

    最近参加了很多场面试,几乎每场面试中都会问到Vue源码方面的问题。在此开一个系列的专栏,来总结一下这方面的经验,如果觉得对您有帮助的,不妨点个赞支持一下呗。 前言 Vue 是用数据来驱动来生成视图...

    11 天前
  • 🔥手写大厂前端知识点源码系列(上)

    如今前端攻城狮的要求越来越高,会使用常见的API已经不能满足现如今前端日益快速发展的脚步。现在大厂基本都会要求面试者手写前端常见API的原理,以此来证明你对该知识点的理解程度。

    7 个月前
  • 🔥0202年了,几个基础的手写函数总得会吧

    这几天看到一个大三大佬面试字节跳动的蚊子,突然觉得自己太辣鸡了···校招的题我一半多都不会啊···赶紧潜下心来学习学习提(an)高(wei)自己,边翻掘金边谷歌,简单实现了几个常用函数···(借鉴了太...

    7 个月前
  • (源码分析)为什么 Vue 中 template 有且只能一个 root ?

    引言 今年,疫情并没有影响到各种面经的正常出现,可谓是络绎不绝(学不动...)。然后,在前段时间也看到一个这样的关于 Vue 的问题,为什么每个组件 template 中有且只能一个 root? 可能...

    6 个月前
  • 面试!你真的准备好了吗?|手写API系列梳理

    "不畏惧,不讲究,未来的日子好好努力"——大家好!我是小芝麻😄 标题党,它又、又、又来了...... 这篇文章是集合了小芝麻之前所有写过和没写过的API的汇总,为后面整体复习做准备,如果...

    3 个月前
  • 面试高频JS考查点手写实现

    原文链接 考查 this call、apply Function.prototype._call = function(ctx = window, ...args) { const fnKey...

    7 个月前
  • 面试题|手写JSON解析器

    这周的 Cassidoo 的每周简讯有这么一个面试题:: 写一个函数,这个函数接收一个正确的 JSON 字符串并将其转化为一个对象(或字典,映射等,这取决于你选择的语言)。

    8 个月前
  • 面试题里的那些各种手写

    最近准备初级前端面试,发现有很多手写实现什么的,例如什么手写实现bind,promise。手写ajax,手写一些算法。 翻阅了很多书籍和博客。 这里做一个总结改进,算是对我后面大概为期一个月找工作的准...

    2 年前

官方社区

扫码加入 JavaScript 社区