叫我叮当

叫我叮当 查看完整档案

杭州编辑  |  填写毕业院校  |  填写所在公司/组织 segmentfault.com/u/hamsind 编辑
编辑

Keep learning and love.

个人动态

叫我叮当 发布了文章 · 2019-07-15

Webpack基本功能理解以及使用

对于前端工程化,webpack一个神奇的工具,既然是个神奇的工具。那我们保留我们的好奇心,来聊一聊它,首先我们要搞清楚webpack到底是用来解决什么问题的,然后我们来看看它到底是怎么做的,最后来看看它的一些基本用法,下面就来侃一侃。

什么是webpack以及webpack的作用 (解决什么问题)

如今web前端的业务功能越来越复杂,实现方式也越来越丰富,在web页面开发过程中我们通常会引用很多第三方模块以及一些拓展语言(stylus,Scss, JSX...)来简化开发难度,而这些第三方模块和一些拓展语言浏览器不能直接识别,所以要通过经过打包过程生成可以让浏览器识别的格式。

就像一幢居民楼,要建起这样一座居民楼,最基本的材料是砖、瓦、钢筋、混凝土。而要组合这些材料形成一幢建筑,肯定是有一定的方法流程以及工具的,比如第一步先搭建地基,后面用塔吊不断的在地基上叠加完善就形成了一幢建筑。在这个过程中,用到的方法流程以及工具起到的作用就类似于webpack。

进入正题,webpack其实就是一个JavaScript模块集成工具,同时具有压缩文件以及优化文件结构的作用。经过webpack打包生成的bundle包,可被浏览器识别解析。

在这个过程中,会用到一些loaders解析工具用来预处理一些模块以及拓展语言(例如:stylus、Scss...),这些工具的配置使用都是在webpack中完成的。其中常用的loaders工具有:style-loader、 css-loader、 stylus-loader。

webpack实现原理 (怎么做的)

webpack1.png

原理的理解可以参照上图。
webpack的最核心的原理: 1、一切皆模块 2、按需加载。

  • 一切皆模块 webpack会将源程序按照程序结构分割成一个个独立的小模块,当需要这些小模块时,进行组合重构,避免冗余,达到重复利用。
  • 按需加载 传统的打包工具是将所有模块编译生成一个庞大的bundle.js文件,这样形成的打包文件体积过于庞大,而webpack通过异步加载可以实现按需加载,减小了打包后的体积。

webpack的使用方法 (怎么用它)

在使用webpack之前首先要理解四个基本概念:

1. 入口(entry)

webpack要实现打包,首先我们得指定它的入口,指定入口后,webpack才会找出那些模块和库是入口起点(直接和间接)的依赖。
接下来我们来看一个最简单的entry的配置例子。

webpack.base.config.js

module.exports = {
  entry: './src/main.js'
};

2. 出口(output)

出口即配置打包后的输出文件路径,以及如何命名这些文件,默认值为 ./dist。基本上,整个应用程序结构,都会被编译到你指定的输出路径的文件夹中。你可以通过在配置中指定一个 output 字段,来配置这些处理过程:

webpack.base.config.js

const path = require('path');

module.exports = {
  entry: './src/main.js',
  output: {
    path: path.resolve(__dirname, 'dist'),  // 输出路径
    filename: 'output.bundle.js'  // 输出文件名
  }
};

3. loader

loader能够将非JavaScript文件转化为webpack识别的JavaScript文件,比如讲图片转化为JavaScript可调用的格式,或者将一些扩展语言文件转化为浏览器可识别的文件格式。
本质上,webpack loader 将所有类型的文件,转换为应用程序的依赖图(和最终的 bundle)可以直接引用的模块。
在更高层面,在 webpack 的配置中 loader 有两个目标:

  • test 属性,用于标识出应该被对应的 loader 进行转换的某个或某些文件。
  • use 属性,表示进行转换时,应该使用哪个 loader。

webpack.config.js

const path = require('path');

const config = {
  output: {
    filename: 'my-first-webpack.bundle.js'
  },
  module: {
    rules: [
      { test: /\.txt$/, use: 'raw-loader' }
    ]
  }
};

module.exports = config;

4. 插件(plugins)

loader 被用于转换某些类型的模块,而插件则可以用于执行范围更广的任务。插件的范围包括,从打包优化和压缩,一直到重新定义环境中的变量。插件接口功能极其强大,可以用来处理各种各样的任务。

想要使用一个插件,你只需要 require() 它,然后把它添加到 plugins 数组中。多数插件可以通过选项(option)自定义。你也可以在一个配置文件中因为不同目的而多次使用同一个插件,这时需要通过使用 new 操作符来创建它的一个实例。

webpack.config.js

const HtmlWebpackPlugin = require('html-webpack-plugin'); // 通过 npm 安装
const webpack = require('webpack'); // 用于访问内置插件

const config = {
  module: {
    rules: [
      { test: /\.txt$/, use: 'raw-loader' }
    ]
  },
  plugins: [
    new HtmlWebpackPlugin({template: './src/index.html'})
  ]
};

module.exports = config;

其他一些详细用法可以参考webpack官方文档。

参考: webpack中文文档

本文基于自己学习网络中的webpack整理的一份基本概念文档,是自己对于webpack使用的理解总结,如有问题,烦请评论指正,共同学习,共同进步。😁😁😁😁

查看原文

赞 0 收藏 0 评论 0

叫我叮当 发布了文章 · 2019-07-15

前端面试重点之——多列布局

在页面开发中,当我们拿到设计师给出的UI图后,首先考虑的就是布局问题,而多列布局会是我们碰到最多的布局问题,个人就汇总了开发中常见多列布局问题的解决方法。按列数可以分为两列布局,三列布局,多列布局,其中布局方法中的原理都有类似之处。

目录

一、定宽+自适应两列布局

二、两列定宽,一列自适应布局

三、左边不定宽,右边自适应布局

四、多列不定宽,一列自适应

五、等宽布局解决方案

六、等高布局解决方案

(文中Css代码中颜色需自行添加)

一、定宽+自适应两列布局

<div class="parent">
    <div class="left"><p>left</p></div>
    <div class="right"><p>right</p></div>
</div>
  • 需求:实现左侧100px,右侧自适应,且间距20px

image-20190623235624776.png

方法一:左侧浮动,右侧宽度通过margin调整
.left {
    float: left;
    width: 100px;
}
.right {
    margin-left: 120px; //相差的20px是左右之间的间距
}
方法二:左侧浮动,右侧BFC
.left {
    float: left;
    width: 100px;
    margin-right: 20px;
}
.right {
    overflow: hidden;
}
方法三:table

单元格默认会等宽,但是table-layout: fixed能够让table元素布局优先,。

.parent {
    display: table;
    width: 100%;
    table-layout: fixed;
}
.left, .right {
    display: table-cell;
}
.left {
    width: 100px;
    padding-right: 20px;
}
方法四:flex
.parent {
    display: flex;
}
.left {
    width: 100px;
    margin-right: 20px;
}
.right {
    flex: 1
}
方法五:css3 calc()计算属性
.left {
    display: inline-block;
    width: 100px;
    margin-right: 20px;
}
.right {
    display: inline-block;
    width: calc(100% - 120px);
}

二、两列定宽,一列自适应布局

多列布局用到的属性原理基本都一样,上面的方法也同样适用于此。

<div class="parent">
   <div class="left"><p>left</p></div>
   <div class="center"><p>center</p></div>
   <div class="right"><p>right</p></div>
</div>

image-20190623235324720.png

  • 需求1:left和center定宽100px,right自适应。
  • 需求2:left和right定宽100px,center自适应。

需求1使用的方法跟上面有相同之处,不做赘述。重点以需求2为例说明。

方法一:父元素相对布局,子元素绝对布局
.parent {
    position: relative;
}
.left{
    position: absolute;
    left: 0px;
    top: 0px;
    width: 100px;
}
.right {
    position: absolute;
    right: 0px;
    top: 0px;
    width: 100px;
}
.center {
    margin: 0 120px;
}
方法二:flex布局
.parent {
    display: flex;
}
.left, .right {
    width: 100px;
}
.left {
    margin-right: 20px;
}
.right {
    margin-left: 20px;
}
.center {
    flex: 1;
}
方法三:双飞翼布局

双飞翼布局需要将center块提前,并且需要在center的内嵌包裹块,方便设置间距,注意在设置center宽度为100%的时候,要将center的盒模型转换为IE盒模型,这样它的宽度就包含了padding。

<div class="parent">
    <div class="center">
        <div class="content">
            <p>center</p>
        </div>
    </div>
    <div class="left"><p>left</p></div>
    <div class="right"><p>right</p></div>
</div>
.center, .left, .right {
    float: left;
}
.left {
    width: 100px;
    margin-left: -100%;
}
.right {
    width: 100px;
    margin-left: -100px;
}
.center {
    box-sizing: border-box;
    width: 100%;
    padding-left: 120px;
    padding-right: 120px;
}
.content {
    height: 100%;
}

三、左边不定宽,右边自适应布局

<div class="parent">
   <div class="left"><p>left</p></div>
   <div class="right"><p>right</p></div>
</div>

image-20190624233637505.png

  • 需求:左侧不定宽,右侧自适应,间距20px。
方法一:float + overflow
.left {
    float: left;
    margin-right: 20px;
}
.right {
    overflow: hidden;
}
方法二:table布局

由内容决定宽度,不由布局决定宽度,取消table-layout:fixed的作用

.parent {
    display: table;
    width: 100%;
}
.left, .right {
    display: table-cell;
}
.left {
    width: 0.1% //取最小宽度,实际宽度由内容决定
    padding-right: 20px;
}
方法三:flex
.parent {
    diaplay: flex;
}
.left {
    margin-right: 20px;
}
.right {
    flex: 1;
}

四、多列不定宽,一列自适应

三、左边不定宽,右边自适应布局 方法相同。

五、等宽布局解决方案

<div class="parent">
    <div class="column"><p>column1</p></div>
    <div class="column"><p>column2</p></div>
    <div class="column"><p>column3</p></div>
    <div class="column"><p>column4</p></div>
</div>

image-20190624235549824.png

  • 需求:多列等宽,并保留20px间距。
方法一:margin + float

此时需要考虑多个间距的问题,缺点:需要提前知道有多少列计算好每列宽度占比+间距,具体就是让父元素多拥有20px的宽度。

.parent {
    margin-left: -20px;
}
.column {
    float: left;
    width: 25%;
    padding-left: 20px;
    box-sizing: border-box;
}
方法二:table

此时需要在parent元素外层再添加一层盒子parent-layout,并设置宽度使得宽度再增加20px。

<div class="parent-layout">
    <div class="parent">
        <div class="column"><p>column1</p></div>
        <div class="column"><p>column2</p></div>
        <div class="column"><p>column3</p></div>
        <div class="column"><p>column4</p></div>
    </div>
</div>
.parent-layout {
    margin-left: -20px;
}
.parent {
    display: table;
    width: 100%;
    table-layout: fixed;
}
.column {
    display: table-cell;
    padding-left: 20px;
}

方法三:flex

.parent {
    display: flex;
}
.column {
    flex: 1;
}
.column + .column {
    margin-left: 20px;
}

六、等高布局解决方案

除了解决分栏的问题之外,我们同时需要解决分列后等高布局的解决方法:

方法一:table

利用table单元格本身具有等高特性

.parent {
    display: table;
    width: 100%;
    table-layout: fixed;
}
.left, .right  {
    display: table-cell;
}
.left {
    widht: 100px;
    border-right: 20px solid transparent;
    background-clip: padding-box; //由于是border-box,需要把背景颜色去掉
}
方法二:flex
.parent {
    display: flex;
}
.left {
    width: 100px;
    margin-right: 20px;
}
.right {
    flex: 1;
}
方法三:float

伪等高

.left, .right  {
    flex: left;
    width: 100%;
    margin-right: 20px;
}
.right {
    overflow: hidden;
}
.left, .right {
    padding-bottom:9999px;
    margin-bottom: -9999px;
}
.parent {
    overflow: hidden;
}

(文中样式代码中的背景颜色可自行添加)

说明:

  1. BFC(块级格式上下文),可以实现和浮动元素共存,且不会遮挡浮动元素,通过overflow:hidden,
    作用:避免边距折叠,不被浮动元素遮盖。且BFC能够将内容元素浮动清除,避免高度塌陷。

喜欢那就点个赞吧😝

(完)

查看原文

赞 1 收藏 1 评论 0

叫我叮当 赞了文章 · 2019-07-15

前端需要了解的 Docker 与 Kubernetes 知识

本文将以一个简单的示例演示如何使用 Docker 与 Kubernetes 部署应用上线。

Http Service

首先使用 Go 语言搭建一个简单的 Http 服务,监听 8080 端口。

main.go
package main

import (
  "fmt"
  "net/http"
)

func main() {
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World")
  })

  http.ListenAndServe(":8080", nil)
}

打开终端执行 go run main.go,再开一个终端输入 curl http://127.0.0.1:8080 输出 Hello,World 则表示该 Http 服务没有问题。
图片描述

Docker

将 Http 服务打包成 Docker 镜像,然后将镜像实例化并运行,方便部署。

构建

Dockerfile
# 拉取 golang 镜像,提供程序运行环境
FROM golang:1.11
# 创建 code 目录,存放 golang 代码
RUN mkdir /code
# 将当前目录下的文件拷贝到 docker 中的 code 目录
COPY . /code/
# 将 code 目录设为工作区
WORKDIR /code
# 编译 go 文件,输入名字为 main 的二进制文件
RUN go build -o main .
# 执行 code 目录下 main 的二进制文件
ENTRYPOINT ["/code/main"]

执行 docker build -f ./Dockerfile -t go . 构建名字为 go 的镜像。本地从 DockerHub 上拉取镜像慢,推荐使Play with Docker构建。
图片描述

由上图可以看出除了我们拉取的 golang 镜像还多出了我们自己构建的 go 镜像。

验证

创建一个 go 镜像的实例看下我们的 Http 服务是否已经启动,执行 docker run -dt --name go go 基于 go 镜像创建一个 go 的实例,执行 docker exec -it go sh 进入到 go 实例,执行 curl http://127.0.0.1:8080 查看是否输入 Hello,World
图片描述

推送

执行 docker tag 43f7215dd448 pldaily/go:helloworld 给我们的 go 镜像打一个 tag,执行 docker push pldaily/go 将你的 go 镜像推到 DockerHub。此处以我的账号为例,需要推送到你自己的账号。
图片描述

部署

执行 docker rm -f go 删除之前生成的 go 实例,执行 docker run -d -p 80:8080 --name go go 将服务器 80 端口映射到 docker 内部 8080 端口,如果需要可再通过 nginx 反向代理实现部署。
图片描述

虽然这样也能达到部署的目的,但是 docker 实例进程与 nginx 均需要自己维护,让我们看下 Kubernetes 能帮我们做些什么。

Kubernetes

Kubernetes 是一种自动化运维工具,本文主要需要了解 Pod,Deloyment,Service 三个概念。

  1. Pod 是Kubernetes 最基本的操作单元
  2. Deployment 用于管理Pod
  3. Service 提供 Pod 的对外访问接口

Minikube

Minikube 是一个轻量级的 Kubernetes 实现,会在本机创建一台虚拟机,并部署一个只包含一个节点的简单集群。由于国内网络问题,推荐使用阿里云镜像的 Minikube。本地如果搭建有问题,可以使用Play with Kubernetes

Deployment

go-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: go-deployment
  labels:
    app: go
spec:
  # 起 3 个replicated Pods
  replicas: 3
  # 哪个 pod 被管理
  selector:
    matchLabels:
      app: go
  # 运行的容器
  template:
    metadata:
      labels:
        app: go
    spec:
      containers:
      - name: go
        # 要拉取的镜像
        image: pldaily/go:helloworld
        ports:
        # 暴露的端口
        - containerPort: 8080

执行 kubctl create -f go-deployment.yaml 创建 Deployment,该 Deployment 会启 3个 replicated Pods。
图片描述

Service

go-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: go-service
spec:
  type: NodePort
  sessionAffinity: ClientIP
  selector:
    app: go
  ports:
    # svc 暴露的端口
    - port: 8080
      # 对外暴露的端口
      nodePort: 30081

执行 kubctl create -f go-service.yaml 启一个 service 将端口暴露出来。
图片描述

至此成功使用 Kubernetes 部署应用。

参考

https://my.oschina.net/u/2306127/blog/1647246
https://github.com/PLDaily/docker

查看原文

赞 1 收藏 1 评论 0

叫我叮当 回答了问题 · 2019-07-14

js或者css前端如何实现点赞点踩,只能点一次呢?

之前做过这样的一个功能。
当时我这边的需求是:点赞红心,再点取消红心。
实现上,点赞操作请求后台接口,根据返回结果是否点赞成功的标志判断,成功红心,不成功不作操作。
如果你不需要持久记录点赞状态,单纯页面记录,不用后台交互,

关注 5 回答 5

叫我叮当 赞了文章 · 2019-07-14

Go 函数调用 ━ 栈和寄存器视角

  函数的调用过程主要要点在于借助寄存器和内存帧栈传递参数和返回值。虽然同为编译型语言,Go 相较 C 对寄存器和栈的使用有一些差别,同时,Go 语言自带协程并引入 defer 等语句,在调用过程上显得更加复杂。 理解Go函数调用在CPU指令层的过程有助于编写高效的代码,在性能优化、Bug排查的时候,能更迅速的确定要点。本文以简短的示例代码和对应的汇编代码演示了Go的调用过程,展示了不同数据类型的参数的实际传递过程,同时分析了匿名函数、闭包作为参数或者返回值传递时,在内存上的实际数据结构。对于协程对栈的使用和实现细节,本文不展开。
  阅读本文需要掌握计算机体系结构基础知识(至少了解程序内存布局、栈、寄存器)、Go 基础语法。参考文档提供了这些主题更详细的知识。
  以下:

术语

  • 栈:每个进程/线程/goroutine有自己的调用栈,参数和返回值传递、函数的局部变量存放通常通过栈进行。和数据结构中的栈一样,内存栈也是后进先出,地址是从高地址向低地址生长。
  • 栈帧:(stack frame)又常被称为帧(frame)。一个栈是由很多帧构成的,它描述了函数之间的调用关系。每一帧就对应了一次尚未返回的函数调用,帧本身也是以栈的形式存放数据的。
  • caller 调用者
  • callee 被调用者,如在 函数 A 里 调用 函数 B,A 是 caller,B 是 callee

寄存器(X86)

  • ESP:栈指针寄存器(extended stack pointer),存放着一个指针,该指针指向栈最上面一个栈帧(即当前执行的函数的栈)的栈顶。注意:

    • ESP指向的是已经存储了内容的内存地址,而不是一个空闲的地址。例如从 0xC0000000 到 0xC00000FF是已经使用的栈空间,ESP指向0xC00000FF
  • EBP:基址指针寄存器(extended base pointer),也叫帧指针,存放着一个指针,该指针指向栈最上面一个栈帧的底部。
  • EIP:寄存器存放下一个CPU指令存放的内存地址,当CPU执行完当前的指令后,从EIP寄存器中读取下一条指令的内存地址,然后继续执行。

注意:16位寄存器没有前缀(SP、BP、IP),32位前缀是E(ESP、EBP、EIP),64位前缀是R(RSP、RBP、RIP)

汇编指令

  • PUSH:进栈指令,PUSH指令执行时会先将ESP减4,接着将内容写入ESP指向的栈内存。
  • POP :出栈指令,POP指令执行时先将ESP指向的栈内存的一个字长的内容读出,接着将ESP加4。注意:

    • 用PUSH指令和POP指令时只能按字访问栈,不能按字节访问栈。
  • CALL:调用函数指令,将返回地址(call指令的下一条指令)压栈,接着跳转到函数入口。
  • RET:返回指令,将栈顶返回地址弹出到EIP,接着根据EIP继续执行。
  • LEAVE:等价于 mov esp,ebp; pop ebp;
  • MOVL:在内存与寄存器、寄存器与寄存器之间转移值
  • LEAL:用来将一个内存地址直接赋给目的操作数

注意:8位指令后缀是B、16位是S、32位是L、64位是Q

调用惯例

  调用惯例(calling convention)是指程序里调用函数时关于如何传参如何分配和清理栈等的方案。一个调用惯例的内容包括:

  • 参数是通过寄存器传递还是栈传递或者二者混合
  • 通过栈传递时参数是从左至右压栈还是从右至左压栈
  • 函数结果是通过寄存器传递还是通过栈传递
  • 调用者(caller)还是被调用者(callee)清理栈空间
  • 被调用者应该为调用者保存哪些寄存器

    例如,C 的调用惯例(cdecl, C declaration)是:

  • 函数实参在线程栈上按照从右至左的顺序依次压栈。
  • 函数结果保存在寄存器EAX/AX/AL中
  • 浮点型结果存放在寄存器ST0中
  • 编译后的函数名前缀以一个下划线字符
  • 调用者负责从线程栈中弹出实参(即清栈)
  • 8比特或者16比特长的整形实参提升为32比特长。
  • 受到函数调用影响的寄存器(volatile registers):EAX, ECX, EDX, ST0 - ST7, ES, GS
  • 不受函数调用影响的寄存器: EBX, EBP, ESP, EDI, ESI, CS, DS
  • RET指令从函数被调用者返回到调用者(实质上是读取寄存器EBP所指的线程栈之处保存的函数返回地址并加载到IP寄存器)

  cdecl 将函数返回值保存在寄存器中,所以 C 语言不支持多个返回值。另外,cdecl 是调用者负责清栈,因而可以实现可变参数的函数。如果是被调用者负责清理的话,无法实现可变参数的函数,但是编译代码的效率会高一点,因为清理栈的代码不用在每次调用的时候(编译器计算)生成一遍。(x86的ret指令允许一个可选的16位参数说明栈字节数,用来在返回给调用者之前解堆栈。代码类似ret 12这样,如果遇到这样的汇编代码,说明是被调用者清栈。)

  注意,虽然 C 语言 里都是借助寄存器传递返回值,但是返回值大小不同时有不同的处理情形。若小于4字节,返回值存入eax寄存器,由函数调用方读取eax。若返回值5到8字节,采用eax和edx联合返回。若大于8个字节,首先在栈上额外开辟一部分空间temp,将temp对象的地址做为隐藏参数入栈。函数返回时将数据拷贝给temp对象,并将temp对象的地址用寄存器eax传出。调用方从eax指向的temp对象拷贝内容。

  可以看到,设计一个编程语言的特性时,需要为其选择合适调用惯例才能在底层实现这些特性。(调用惯例是编程语言的编译器选择的,同样的语言不同的编译器可能会选择实现不同的调用惯例)

一次典型的 C 函数调用过程

在caller里

  • 将实参从右至左压栈(X86-64下是:将实参写入寄存器,如果实参超过 6 个,超出的从右至左压栈)
  • 执行 call 指令(会将返回地址压栈,并跳转到 callee 入口)

进入callee里

  • push ebp; mov ebp,esp; 此时EBP和ESP已经分别表示callee的栈底和栈顶了。之后 EBP 的值会保持固定。此后局部变量和临时存储都可以通过基准指针EBP加偏移量找到了。
  • sub xxx, esp; 栈顶下移,为callee分配空间,用于存放局部变量等。分配的内存单元可以通过 EBP - K 或者 ESP + K 得到地址访问。
  • 将某些寄存器的值压栈(可能)
  • callee执行
  • 将某些寄存器值弹出栈(可能)
  • mov esp,ebp; pop ebp; (这两条指令也可以用 leave 指令替代)此时 EBP 和 ESP 回到了进入callee之前的状态,即分别表示caller的栈底和栈顶状态。
  • 执行 ret 指令

回到了caller里的代码

int add(int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8) {
    return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8;
}

int main() {
    int i = add(1, 2, 3 , 4, 5, 6, 7, 8);
}

x86版汇编

    .section    __TEXT,__text,regular,pure_instructions
    .build_version macos, 10, 14    sdk_version 10, 14
    .globl    _add                    ## -- Begin function add
    .p2align    4, 0x90
_add:                                   ## @add
    .cfi_startproc
## %bb.0:
    pushl    %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset %ebp, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register %ebp
    pushl    %ebx
    pushl    %edi
    pushl    %esi
    subl    $32, %esp
    .cfi_offset %esi, -20
    .cfi_offset %edi, -16
    .cfi_offset %ebx, -12
    movl    36(%ebp), %eax
    movl    32(%ebp), %ecx
    movl    28(%ebp), %edx
    movl    24(%ebp), %esi
    movl    20(%ebp), %edi
    movl    16(%ebp), %ebx
    movl    %eax, -16(%ebp)         ## 4-byte Spill
    movl    12(%ebp), %eax
    movl    %eax, -20(%ebp)         ## 4-byte Spill
    movl    8(%ebp), %eax
    movl    %eax, -24(%ebp)         ## 4-byte Spill
    movl    8(%ebp), %eax
    addl    12(%ebp), %eax
    addl    16(%ebp), %eax
    addl    20(%ebp), %eax
    addl    24(%ebp), %eax
    addl    28(%ebp), %eax
    addl    32(%ebp), %eax
    addl    36(%ebp), %eax
    movl    %ebx, -28(%ebp)         ## 4-byte Spill
    movl    %ecx, -32(%ebp)         ## 4-byte Spill
    movl    %edx, -36(%ebp)         ## 4-byte Spill
    movl    %esi, -40(%ebp)         ## 4-byte Spill
    movl    %edi, -44(%ebp)         ## 4-byte Spill
    addl    $32, %esp
    popl    %esi
    popl    %edi
    popl    %ebx
    popl    %ebp
    retl
    .cfi_endproc
                                        ## -- End function
    .globl    _main                   ## -- Begin function main
    .p2align    4, 0x90
_main:                                  ## @main
    .cfi_startproc
## %bb.0:
    pushl    %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset %ebp, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register %ebp
    subl    $40, %esp
    movl    $1, (%esp)
    movl    $2, 4(%esp)
    movl    $3, 8(%esp)
    movl    $4, 12(%esp)
    movl    $5, 16(%esp)
    movl    $6, 20(%esp)
    movl    $7, 24(%esp)
    movl    $8, 28(%esp)
    calll    _add
    xorl    %ecx, %ecx
    movl    %eax, -4(%ebp)
    movl    %ecx, %eax
    addl    $40, %esp
    popl    %ebp
    retl
    .cfi_endproc
                                        ## -- End function

.subsections_via_symbols

x86-64版汇编

    .section    __TEXT,__text,regular,pure_instructions
    .build_version macos, 10, 14    sdk_version 10, 14
    .globl    _add                    ## -- Begin function add
    .p2align    4, 0x90
_add:                                   ## @add
    .cfi_startproc
## %bb.0:
    pushq    %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    movl    24(%rbp), %eax
    movl    16(%rbp), %r10d
    movl    %edi, -4(%rbp)
    movl    %esi, -8(%rbp)
    movl    %edx, -12(%rbp)
    movl    %ecx, -16(%rbp)
    movl    %r8d, -20(%rbp)
    movl    %r9d, -24(%rbp)
    movl    -4(%rbp), %ecx
    addl    -8(%rbp), %ecx
    addl    -12(%rbp), %ecx
    addl    -16(%rbp), %ecx
    addl    -20(%rbp), %ecx
    addl    -24(%rbp), %ecx
    addl    16(%rbp), %ecx
    addl    24(%rbp), %ecx
    movl    %eax, -28(%rbp)         ## 4-byte Spill
    movl    %ecx, %eax
    movl    %r10d, -32(%rbp)        ## 4-byte Spill
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function
    .globl    _main                   ## -- Begin function main
    .p2align    4, 0x90
_main:                                  ## @main
    .cfi_startproc
## %bb.0:
    pushq    %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register %rbp
    subq    $32, %rsp
    movl    $1, %edi
    movl    $2, %esi
    movl    $3, %edx
    movl    $4, %ecx
    movl    $5, %r8d
    movl    $6, %r9d
    movl    $7, (%rsp)
    movl    $8, 8(%rsp)
    callq    _add
    xorl    %ecx, %ecx
    movl    %eax, -4(%rbp)
    movl    %ecx, %eax
    addq    $32, %rsp
    popq    %rbp
    retq
    .cfi_endproc
                                        ## -- End function

.subsections_via_symbols

  可以看到 Clang 编译出的X86目标代码并不使用寄存器传递参数,而X86-64目标代码里,使用寄存器传递前六个参数。

一次典型的Go函数调用过程

Go 选择的调用惯例是:

  • 参数完全通过栈传递,从参数列表的右至左压栈
  • 返回值通过栈传递,返回值的栈空间在参数之前,即返回值在更接近caller栈底的位置
  • caller负责清理栈
package main

func main() {
    add(1,2)
}

//go:noinline
func add(a , b int) int {
    c := 3
    d := a + b + c
    return d
}
TEXT main.main(SB) /Users/user/go/src/test/main.go
  main.go:4        0x104ea20        65488b0c2530000000    MOVQ GS:0x30, CX            
  main.go:4        0x104ea29        483b6110        CMPQ 0x10(CX), SP    
  main.go:4        0x104ea2d        762e            JBE 0x104ea5d                
  main.go:4        0x104ea2f        4883ec20        SUBQ $0x20, SP ; 增加 32 bytes 的栈空间(四个 qword,8个bytes 为一个 qword)                
  main.go:4        0x104ea33        48896c2418        MOVQ BP, 0x18(SP) ; 将 BP 的值写入到刚分配的栈空间的第一个qword
  main.go:4        0x104ea38        488d6c2418        LEAQ 0x18(SP), BP ; 将刚分配的栈空间的第一个字的地址赋值给BP(即BP此时指向了刚才存放旧BP值的地址)            
  main.go:5        0x104ea3d        48c7042401000000    MOVQ $0x1, 0(SP); 将给add函数的第一个实参值1 写入到刚分配栈空间的最后一个qword
  main.go:5        0x104ea45        48c744240802000000    MOVQ $0x2, 0x8(SP); 将给add函数的第二个实参值2 写入到刚分配栈空间的第三个qword。第二个 qword 没有用到,实际上是给callee用来存放返回值的。             
  main.go:5        0x104ea4e        e81d000000        CALL main.add(SB); 调用 add 函数    
  main.go:6        0x104ea53        488b6c2418        MOVQ 0x18(SP), BP; 将从栈里第四个qword将旧的BP值取回赋值到BP
  main.go:6        0x104ea58        4883c420        ADDQ $0x20, SP; 增加SP的值,栈收缩,收回 32 bytes的栈空间                 
  main.go:6        0x104ea5c        c3            RET                    
  
  TEXT main.add(SB) /Users/user/go/src/test/main.go
  main.go:11        0x104ea70        4883ec18        SUBQ $0x18, SP; 分配 24 bytes 的栈空间(3 个 qword)。        
  main.go:11        0x104ea74        48896c2410        MOVQ BP, 0x10(SP); 将 BP值 写入第一个qword
  main.go:11        0x104ea79        488d6c2410        LEAQ 0x10(SP), BP; 将刚分配的24 bytes 栈空间的第一个字的地址赋值给BP(即BP此时指向了刚才存放旧BP值的地址)        
  main.go:11        0x104ea7e        48c744243000000000    MOVQ $0x0, 0x30(SP);将存放返回值的地址清零,0x30(SP) 对应的内存位置是上一段 main.main 里分配的栈空间的第二个qword。
  main.go:12        0x104ea87        48c744240803000000    MOVQ $0x3, 0x8(SP); 对应 c := 3 这行代码。局部变量 c 对应的是栈上内存。3 被写入到刚分配的 24 bytes 空间的第二个qword。
  main.go:13        0x104ea90        488b442420        MOVQ 0x20(SP), AX; 将add的实参 1 写入到AX 寄存器。
  main.go:13        0x104ea95        4803442428        ADDQ 0x28(SP), AX; 将add的实参 2 增加到 AX 寄存器。
  main.go:13        0x104ea9a        4883c003        ADDQ $0x3, AX; 将局部变量值 3 增加到 AX 寄存器        
  main.go:13        0x104ea9e        48890424        MOVQ AX, 0(SP); 将 AX 的值(计算结果) 写入到刚分配的 24 bytes 空间的第三个qword。(对应代码 d := a + b + c)
  main.go:14        0x104eaa2        4889442430        MOVQ AX, 0x30(SP); 将 AX 的值写入到main里为返回值留的栈空间(main里分配的32 bytes 中的第二个 qword)
  main.go:14        0x104eaa7        488b6c2410        MOVQ 0x10(SP), BP; 恢复BP的值为函数入口处保存的旧BP的值。
  main.go:14        0x104eaac        4883c418        ADDQ $0x18, SP; 将 SP 增加三个字,收回add入口处分配的栈空间。    
  main.go:14        0x104eab0        c3            RET            

函数调用过程中,栈的变化情况如图:

初始状态:

call add执行前栈状态:

进入add里之后栈状态:

add里ret执行前栈状态:

main里ret执行前栈状态:

  可以看到 Go 的调用过程和 C 类似,区别在于 Go 的参数完全通过栈传递,Go 的返回值也是通过栈传递。对于每种数据类型在作为参数传递时的表现,可以测试一下:

不同数据类型作为参数时的传递方式

Go 基础数据类型的参数传递

package main

import (
    "fmt"
    "runtime/debug"
)

func main() {

    str := "hello"
    int8 := int8(8)
    int64 := int64(64)

    boolValue := true

    ExampleStr(str)
    ExampleBool(boolValue)
    ExampleInt8(int8)
    ExampleInt64(int64)
    ExampleMultiParams(false, 9, 8, 7)
}


func ExampleStr(str string){
    fmt.Println(string(debug.Stack()))
}

func ExampleBool(boolValue bool){

    boolValue = false

    fmt.Println(string(debug.Stack()))
}



func ExampleInt64(v int64){
    fmt.Println(string(debug.Stack()))
}

func ExampleInt8(v int8){
    fmt.Println(string(debug.Stack()))
}

func ExampleMultiParams(b bool, x, y, z int8){
    bl := b
    xl := x
    yl := y
    zl := z

    fmt.Println(bl, xl, yl, zl)
    fmt.Println(string(debug.Stack()))

}
goroutine 1 [running]:
runtime/debug.Stack(0xc000084f38, 0x1057aad, 0x10aeb20)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStr(0x10c6c34, 0x5)
    /Users/user/go/src/test/main.go:25 +0x26
main.main()
    /Users/user/go/src/test/main.go:16 +0x36

goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleBool(0x10c6c01)
    /Users/user/go/src/test/main.go:32 +0x26
main.main()
    /Users/user/go/src/test/main.go:17 +0x3f

goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt8(0x10c6c08)
    /Users/user/go/src/test/main.go:42 +0x26
main.main()
    /Users/user/go/src/test/main.go:18 +0x48

goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f58)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleInt64(0x40)
    /Users/user/go/src/test/main.go:38 +0x26
main.main()
    /Users/user/go/src/test/main.go:19 +0x55

false 9 8 7
goroutine 1 [running]:
runtime/debug.Stack(0x10e0580, 0xc000092000, 0xc000084f28)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMultiParams(0x7080900)
    /Users/user/go/src/test/main.go:52 +0xf6
main.main()
    /Users/user/go/src/test/main.go:20 +0x61

可以看到:

  • string传递时,分为pointer和length两个参数传递。
  • int64传递时,复制了值进行传递。
  • 看debug.Stack()打印出的调用栈,int8和bool传递时,传递的是一个内存地址,这似乎容易引起误解,难道传递的是caller里变量的内存地址?那不是会导致callee修改也导致caller里值也发生改变?当然不是这样!int和bool当然都是值传递。当caller传递给callee的时候,int和bool都会被在caller的栈里复制一份给callee使用。(在callee直接通过引用参数名修改参数值,这个参数的内存位置实际上是在caller的栈上)。
  • ExampleMultiParams函数虽然有四个参数,但是调用栈打印出来只传递了一个值 0x7080900,这是为什么?原来这四个参数都是一个byte,合起来是一个双字。查看汇编代码可以发现编译器做了优化,直接组合成一个值,并在caller里用指令MOVL $0x7080900, 0(SP)写入栈上。当然,在caller里取值的时候,还是借助MOVB去一个字节一个字节取值的。当然,如果是这四个参数是main里的四个局部变量,调用ExampleMultiParams的时候通过传递变量名的形式调用(ExampleMultiParams(b, x, y, z)而不是 ExampleMultiParams(true, 9, 8, 7)的形式),体现在汇编代码里又是另一种形式。

Go 组合数据类型的参数传递

package main

import (
"fmt"
"runtime/debug"
)

type MyStruct struct {
    a int
    b string
}

func main() {
    slice := make([]string, 2, 4)
    array := [...]int{9,8,7,6,7,8,9}
    myMap := make(map[string]int)
    myStruct := MyStruct{8, "test"}
    myStructPtr := &myStruct
    myChan := make(chan int, 4)


    ExampleSlice(slice)

    ExampleArray(array)

    ExampleMap(myMap)

    ExampleStruct(myStruct)

    ExamplePtr(myStructPtr)

    ExampleChan(myChan)
}

func ExampleSlice(slice []string){
    fmt.Println(string(debug.Stack()))
}

func ExampleArray(array [7]int){
    fmt.Println(string(debug.Stack()))
}

func ExampleMap(myMap map[string]int){
    fmt.Println(string(debug.Stack()))
}

func ExampleStruct(myStruct MyStruct){
    fmt.Println(string(debug.Stack()))
}

func ExamplePtr(ptr *MyStruct){
    fmt.Println(string(debug.Stack()))
}

func ExampleChan(myChan chan int){
    fmt.Println(string(debug.Stack()))
}

调用栈

goroutine 1 [running]:
runtime/debug.Stack(0x130a568, 0xc00007eda8, 0x1004218)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleSlice(0xc00007ee78, 0x2, 0x4)
    /Users/user/go/src/test/main.go:62 +0x26
main.main()
    /Users/user/go/src/test/main.go:46 +0x159

goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleArray(0x9, 0x8, 0x7, 0x6, 0x7, 0x8, 0x9)
    /Users/user/go/src/test/main.go:66 +0x26
main.main()
    /Users/user/go/src/test/main.go:48 +0x185

goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleMap(0xc00007ee48)
    /Users/user/go/src/test/main.go:74 +0x26
main.main()
    /Users/user/go/src/test/main.go:52 +0x1af

goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleStruct(0x8, 0x10c6f88, 0x4)
    /Users/user/go/src/test/main.go:78 +0x26
main.main()
    /Users/user/go/src/test/main.go:54 +0x1d7

goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExamplePtr(0xc00007ee30)
    /Users/user/go/src/test/main.go:82 +0x26
main.main()
    /Users/user/go/src/test/main.go:56 +0x1e5

goroutine 1 [running]:
runtime/debug.Stack(0x10e0a80, 0xc00008c000, 0xc00007ed98)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.ExampleChan(0xc000092000)
    /Users/user/go/src/test/main.go:86 +0x26
main.main()
    /Users/user/go/src/test/main.go:58 +0x1f3

可以看到:

  • 对于数组、结构体、指针,是复制一份拷贝传递给callee。
  • 数组作为参数时,编译后参数的数量是数组元素的数量。
  • 结构体作为参数时,编译后参数的数量需要再次分析结构体里元素的类型。如上述代码里结构体由一个int和一个string组成,传递参数时是int值、string的地址、string的长度三个参数。
  • slice传递时,会将slice底层的pointer、len、cap作为三个参数分开传递。(即编译后,参数数量由源代码里的一个参数变为了三个参数)。所以slice其实也是值传递。
  • map、chan传递时,是将map、chan的地址指针作为参数传递。

方法:pointer receiver 与 value receiver

在 Java 中,当我们调用一个对象的方法的时候,当然是可以修改对象的成员变量的。但是在 Go 中,结果取决于定义方法时方法的接收者是值还是指针(value receiver 和 pointer receiver)。

Go 的方法接收者有两种,一种是值接收者(value receiver),一种是指针接收者(pointer receiver)。值接收者,是接收者的类型是一个值,是一个副本,方法内部无法对其真正的接收者做更改。指针接收者,接收者的类型是一个指针,是接收者的引用,对这个引用的修改会影响真正的接收者。

看如下代码:

package main

import "fmt"

type XAxis int

type Point struct{
    X int
    Y int
}


func (x XAxis)VIncr(offset XAxis){
    x += offset
    fmt.Printf("In VIncr, new x = %d\n", x)
}

func (x *XAxis)PIncr(offset XAxis){
    *x += offset
    fmt.Printf("In PIncr, new x = %d\n", *x)
}

func (p Point)VScale(factor int){
    p.X *= factor
    p.Y *= factor

    fmt.Printf("In VScale, new p = %v\n", p)
}


func (p *Point)PScale(factor int){
    p.X *= factor
    p.Y *= factor

    fmt.Printf("In PScale, new p = %v\n", p)
}

func main(){
    var x XAxis = 10

    fmt.Printf("In main, before VIncr, x = %v\n", x)
    x.VIncr(5)
    fmt.Printf("In main, after VIncr, new x = %v\n", x)

    fmt.Println()

    fmt.Printf("In main, before PIncr, x = %v\n", x)
    x.PIncr(5)
    fmt.Printf("In main, after PIncr, new x = %v\n", x)

    fmt.Println()

    p := Point{2, 2}

    fmt.Printf("In main, before VScale, p = %v\n", p)
    p.VScale(5)
    fmt.Printf("In main, after VScale, new p = %v\n", p)

    fmt.Println()

    fmt.Printf("In main, before PScale, p = %v\n", p)
    p.PScale(5)
    fmt.Printf("In main, after PScale, new p = %v\n", p)
}

输出:

In main, before VIncr, x = 10
In VIncr, new x = 15
In main, after VIncr, new x = 10

In main, before PIncr, x = 10
In PIncr, new x = 15
In main, after PIncr, new x = 15

In main, before VScale, p = {2 2}
In VScale, new p = {10 10}
In main, after VScale, new p = {2 2}

In main, before PScale, p = {2 2}
In PScale, new p = &{10 10}
In main, after PScale, new p = {10 10}

在定义方法的时候,receiver 是在方法名的前面,而不是在参数列表里,那在方法执行的时候,方法内的指令怎么找到receiver的呢?
我们精简一下代码(注释掉 print 相关语句),然后把反编译:

TEXT %22%22.XAxis.VIncr(SB) gofile../Users/user/go/src/test/main.go
  main.go:14        0xbb0            488b442408        MOVQ 0x8(SP), AX    
  main.go:14        0xbb5            4803442410        ADDQ 0x10(SP), AX    
  main.go:14        0xbba            4889442408        MOVQ AX, 0x8(SP)    
  main.go:16        0xbbf            c3            RET            

TEXT %22%22.(*XAxis).PIncr(SB) gofile../Users/user/go/src/test/main.go
  main.go:19        0xbd4            488b442408        MOVQ 0x8(SP), AX    
  main.go:19        0xbd9            8400            TESTB AL, 0(AX)        
  main.go:19        0xbdb            488b4c2408        MOVQ 0x8(SP), CX    
  main.go:19        0xbe0            8401            TESTB AL, 0(CX)        
  main.go:19        0xbe2            488b00            MOVQ 0(AX), AX        
  main.go:19        0xbe5            4803442410        ADDQ 0x10(SP), AX    
  main.go:19        0xbea            488901            MOVQ AX, 0(CX)        
  main.go:21        0xbed            c3            RET            

TEXT %22%22.Point.VScale(SB) gofile../Users/user/go/src/test/main.go
  main.go:24        0xc0a            488b442408        MOVQ 0x8(SP), AX    
  main.go:24        0xc0f            488b4c2418        MOVQ 0x18(SP), CX    
  main.go:24        0xc14            480fafc1        IMULQ CX, AX        
  main.go:24        0xc18            4889442408        MOVQ AX, 0x8(SP)    
  main.go:25        0xc1d            488b442410        MOVQ 0x10(SP), AX    
  main.go:25        0xc22            488b4c2418        MOVQ 0x18(SP), CX    
  main.go:25        0xc27            480fafc1        IMULQ CX, AX        
  main.go:25        0xc2b            4889442410        MOVQ AX, 0x10(SP)    
  main.go:28        0xc30            c3            RET            

TEXT %22%22.(*Point).PScale(SB) gofile../Users/user/go/src/test/main.go
  main.go:32        0xc47            488b442408        MOVQ 0x8(SP), AX    
  main.go:32        0xc4c            8400            TESTB AL, 0(AX)        
  main.go:32        0xc4e            488b4c2408        MOVQ 0x8(SP), CX    
  main.go:32        0xc53            8401            TESTB AL, 0(CX)        
  main.go:32        0xc55            488b00            MOVQ 0(AX), AX        
  main.go:32        0xc58            488b542410        MOVQ 0x10(SP), DX    
  main.go:32        0xc5d            480fafc2        IMULQ DX, AX        
  main.go:32        0xc61            488901            MOVQ AX, 0(CX)        
  main.go:33        0xc64            488b442408        MOVQ 0x8(SP), AX    
  main.go:33        0xc69            8400            TESTB AL, 0(AX)        
  main.go:33        0xc6b            488b4c2408        MOVQ 0x8(SP), CX    
  main.go:33        0xc70            8401            TESTB AL, 0(CX)        
  main.go:33        0xc72            488b4008        MOVQ 0x8(AX), AX    
  main.go:33        0xc76            488b542410        MOVQ 0x10(SP), DX    
  main.go:33        0xc7b            480fafc2        IMULQ DX, AX        
  main.go:33        0xc7f            48894108        MOVQ AX, 0x8(CX)    
  main.go:36        0xc83            c3            RET            

TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
  main.go:38        0xcaa            65488b0c2500000000    MOVQ GS:0, CX        [5:9]R_TLS_LE        
  main.go:38        0xcb3            483b6110        CMPQ 0x10(CX), SP    
  main.go:38        0xcb7            0f86b3000000        JBE 0xd70        
  main.go:38        0xcbd            4883ec50        SUBQ $0x50, SP        
  main.go:38        0xcc1            48896c2448        MOVQ BP, 0x48(SP)    
  main.go:38        0xcc6            488d6c2448        LEAQ 0x48(SP), BP    
  main.go:39        0xccb            48c74424300a000000    MOVQ $0xa, 0x30(SP)    
  main.go:42        0xcd4            48c704240a000000    MOVQ $0xa, 0(SP)    
  main.go:42        0xcdc            48c744240805000000    MOVQ $0x5, 0x8(SP)    
  main.go:42        0xce5            e800000000        CALL 0xcea        [1:5]R_CALL:%22%22.XAxis.VIncr    
  main.go:48        0xcea            488d442430        LEAQ 0x30(SP), AX    
  main.go:48        0xcef            48890424        MOVQ AX, 0(SP)        
  main.go:48        0xcf3            48c744240805000000    MOVQ $0x5, 0x8(SP)    
  main.go:48        0xcfc            e800000000        CALL 0xd01        [1:5]R_CALL:%22%22.(*XAxis).PIncr    
  main.go:53        0xd01            0f57c0            XORPS X0, X0        
  main.go:53        0xd04            0f11442438        MOVUPS X0, 0x38(SP)    
  main.go:53        0xd09            48c744243802000000    MOVQ $0x2, 0x38(SP)    
  main.go:53        0xd12            48c744244002000000    MOVQ $0x2, 0x40(SP)    
  main.go:56        0xd1b            48c7042402000000    MOVQ $0x2, 0(SP)    
  main.go:56        0xd23            48c744240802000000    MOVQ $0x2, 0x8(SP)    
  main.go:56        0xd2c            48c744241005000000    MOVQ $0x5, 0x10(SP)    
  main.go:56        0xd35            e800000000        CALL 0xd3a        [1:5]R_CALL:%22%22.Point.VScale    
  main.go:62        0xd3a            488d442438        LEAQ 0x38(SP), AX    
  main.go:62        0xd3f            48890424        MOVQ AX, 0(SP)        
  main.go:62        0xd43            48c744240805000000    MOVQ $0x5, 0x8(SP)    
  main.go:62        0xd4c            e800000000        CALL 0xd51        [1:5]R_CALL:%22%22.(*Point).PScale    
  main.go:64        0xd51            48c7042400000000    MOVQ $0x0, 0(SP)    
  main.go:64        0xd59            0f57c0            XORPS X0, X0        
  main.go:64        0xd5c            0f11442408        MOVUPS X0, 0x8(SP)    
  main.go:64        0xd61            e800000000        CALL 0xd66        [1:5]R_CALL:fmt.Println    
  main.go:65        0xd66            488b6c2448        MOVQ 0x48(SP), BP    
  main.go:65        0xd6b            4883c450        ADDQ $0x50, SP        
  main.go:65        0xd6f            c3            RET            
  main.go:38        0xd70            e800000000        CALL 0xd75        [1:5]R_CALL:runtime.morestack_noctxt    
  main.go:38        0xd75            e930ffffff        JMP %22%22.main(SB)    

以main.go 42行 x.VIncr(5)为例,在main里面,传递参数对应的指令是

  main.go:42        0xcd4            48c704240a000000    MOVQ $0xa, 0(SP); 将值 10 作为第一个参数
  main.go:42        0xcdc            48c744240805000000    MOVQ $0x5, 0x8(SP); 将值 5 作为第二个参数    
  main.go:42        0xce5            e800000000        CALL 0xcea        [1:5]R_CALL:%22%22.XAxis.VIncr    

再看 x.VIncr 的汇编代码:

  main.go:14        0xbb0            488b442408        MOVQ 0x8(SP), AX; 取第一个参数到寄存器AX    
  main.go:14        0xbb5            4803442410        ADDQ 0x10(SP), AX; 取第二个参数加到寄存器AX
  main.go:14        0xbba            4889442408        MOVQ AX, 0x8(SP); 将和写入到了第一个参数在栈上的位置
  main.go:16        0xbbf            c3            RET    

可以看到,方法 VIncr 的 receiver 是值,则caller在调用VIncr的时候,将这个值复制到栈上给VIncr的参数区里,在 VIncr 对receiver的修改,实际上是修改的这个参数区里的值,而不是 caller 栈里保存局部变量的区里的 receiver 的值(在语言使用者视角,就是 修改的是拷贝而不是原值)。

接着我们看main.go第48行 x.PIncr(5),在main里面,调用的指令是:

  main.go:39        0xccb            48c74424300a000000    MOVQ $0xa, 0x30(SP)    
...
  main.go:48        0xcea            488d442430        LEAQ 0x30(SP), AX; 将SP+0x30这个内存地址保存到AX;    SP+0x30这个内存地址里存的是 10(执行 var x XAxis = 10 时定义的局部变量)
  main.go:48        0xcef            48890424        MOVQ AX, 0(SP); 将AX的值作为第一个参数。        
  main.go:48        0xcf3            48c744240805000000    MOVQ $0x5, 0x8(SP); 将 5 作为第二个参数    
  main.go:48        0xcfc            e800000000        CALL 0xd01        [1:5]R_CALL:%22%22.(*XAxis).PIncr

PIncr的汇编代码:

  main.go:19        0xbd4            488b442408        MOVQ 0x8(SP), AX; 将第一个参数(即main的帧栈上局部变量 x 的内存地址)读取到AX    
  main.go:19        0xbd9            8400            TESTB AL, 0(AX)        
  main.go:19        0xbdb            488b4c2408        MOVQ 0x8(SP), CX; 将第一个参数(即main的帧栈上局部变量 x 的内存地址)读取到 CX    
  main.go:19        0xbe0            8401            TESTB AL, 0(CX)        
  main.go:19        0xbe2            488b00            MOVQ 0(AX), AX; 从 AX 里读到内存地址,从内存地址里拿到值,再读到AX(就是main的局部变量 x 的值)        
  main.go:19        0xbe5            4803442410        ADDQ 0x10(SP), AX; 将 第二个参数 5 加到 AX 里
  main.go:19        0xbea            488901            MOVQ AX, 0(CX); 将计算结果写入到 CX 里的内存地址(即 main的帧栈上局部变量 x 的内存地址)    
  main.go:21        0xbed            c3            RET    

可以看到,方法 PIncr 的 receiver 是指针(pointer),则caller在调用PIncr的时候,将这个pointer复制到栈上给PIncr的参数区里,在 PIncr 对receiver的修改,实际上是修改pointer指向的内存区域,也就是main的局部变量 x。(在语言使用者视角,就是 修改的是原值)。

打印调用栈,相比汇编更方便的看实际传递的参数:

goroutine 1 [running]:
runtime/debug.Stack(0x1036126, 0x10a4360, 0xc000098000)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.XAxis.VIncr(0xa, 0x5)
    /Users/user/go/src/test/main.go:18 +0x26
main.main()
    /Users/user/go/src/test/main.go:47 +0x40

goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*XAxis).PIncr(0xc000080f70, 0x5)
    /Users/user/go/src/test/main.go:24 +0x33
main.main()
    /Users/user/go/src/test/main.go:53 +0x57

goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.Point.VScale(0x2, 0x2, 0x5)
    /Users/user/go/src/test/main.go:31 +0x26
main.main()
    /Users/user/go/src/test/main.go:61 +0x90

goroutine 1 [running]:
runtime/debug.Stack(0x10e0480, 0xc000094000, 0xc000080f10)
    /usr/local/go/src/runtime/debug/stack.go:24 +0x9d
main.(*Point).PScale(0xc000080f78, 0x5)
    /Users/user/go/src/test/main.go:39 +0x46
main.main()
    /Users/user/go/src/test/main.go:67 +0xa7

当方法的receiver是value的时候,调用方法时是把value拷贝一份作为第一个参数传递给callee的,这样caller里对receiver的修改实际上是修改的拷贝,不影响原值。当方法的receiver是pointer的时候,调用方法时是把pointer拷贝一份作为第一个参数传递给caller的,这样callee可以通过这个pointer修改原值。

一点补充

  • 如果在方法里修改receiver的值要对caller生效,使用 pointer receiver
  • 出于性能优化,如果receiver是结构体或者数组这样占用较多内存的数据类型,优先使用pointer receiver

注意:

  • 值接收器是并发安全的,而指针接收器不是并发安全的。

调用规则:

  • 类型 T 的可调用方法集包含接受者为 T 或 T 的所有方法集
  • 类型 T 的可调用方法集包含接受者为 T 的所有方法
  • 类型 T 的可调用方法集不包含接受者为 *T 的方法

方法的接收者与函数/方法的参数的比较

  • 函数/方法的实参类型和形参类型必须一致,(在语法上)不能一个是pointer而另一个是value。
  • 方法的接收者比较智能,如果是 pointer receiver,在值上也可以调用这个方法(编译器会自动插入从值取到指针的指令)。如果是 value receiver,那么当在pointer上调用这个方法时,编译器会自动将pointer转换为pointer所对应的值。

匿名函数和闭包

匿名函数

  匿名函数由一个不带函数名的函数声明和函数体组成,匿名函数可以赋值给变量,作为结构体字段,或者在channel中传递。在底层实现中,实际上传递的是匿名函数的入口地址。

package main

func test() func(int) int {
    return func(x int) int {
        x += x
        return x
    }
}

func main() {

    f := test()
    f(100)
}
TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go
  main.go:4        0x4e7            48c744240800000000    MOVQ $0x0, 0x8(SP)    
  main.go:5        0x4f0            488d0500000000        LEAQ 0(IP), AX        [3:7]R_PCREL:%22%22.test.func1·f    
  main.go:5        0x4f7            4889442408        MOVQ AX, 0x8(SP)    
  main.go:5        0x4fc            c3            RET            

TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
  main.go:11        0x517            65488b0c2500000000    MOVQ GS:0, CX        [5:9]R_TLS_LE        
  main.go:11        0x520            483b6110        CMPQ 0x10(CX), SP    
  main.go:11        0x524            7633            JBE 0x559        
  main.go:11        0x526            4883ec20        SUBQ $0x20, SP        
  main.go:11        0x52a            48896c2418        MOVQ BP, 0x18(SP)    
  main.go:11        0x52f            488d6c2418        LEAQ 0x18(SP), BP    
  main.go:12        0x534            e800000000        CALL 0x539        [1:5]R_CALL:%22%22.test    
  main.go:12        0x539            488b1424        MOVQ 0(SP), DX        
  main.go:12        0x53d            4889542410        MOVQ DX, 0x10(SP)    
  main.go:13        0x542            48c7042464000000    MOVQ $0x64, 0(SP)    
  main.go:13        0x54a            488b02            MOVQ 0(DX), AX        
  main.go:13        0x54d            ffd0            CALL AX            [0:0]R_CALLIND        
  main.go:14        0x54f            488b6c2418        MOVQ 0x18(SP), BP    
  main.go:14        0x554            4883c420        ADDQ $0x20, SP        
  main.go:14        0x558            c3            RET            
  main.go:11        0x559            e800000000        CALL 0x55e        [1:5]R_CALL:runtime.morestack_noctxt    
  main.go:11        0x55e            ebb7            JMP %22%22.main(SB)    

TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go
  main.go:5        0x58a            48c744241000000000    MOVQ $0x0, 0x10(SP)    
  main.go:6        0x593            488b442408        MOVQ 0x8(SP), AX    
  main.go:6        0x598            4803442408        ADDQ 0x8(SP), AX    
  main.go:6        0x59d            4889442408        MOVQ AX, 0x8(SP)    
  main.go:7        0x5a2            4889442410        MOVQ AX, 0x10(SP)

闭包

  当函数引用外部作用域的变量时,我们称之为闭包。在底层实现上,闭包由函数地址和引用到的变量的地址组成,并存储在一个结构体里,在闭包被传递时,实际是该结构体的地址被传递。因为栈帧上的值在该帧的函数退出后就失效了,因此闭包引用的外部作用域的变量会被分配到堆上。在以下的实现中,test()函数返回一个闭包赋值给f,实际是main里收到闭包结构体(堆上)的地址,并保存在DX寄存器上,地址对应的内存值是闭包函数地址(函数地址取到寄存器之后,就可以通过 call 调用),地址偏移8个字节(+8bytes)是变量x的的地址,在main里调用闭包函数f时,f内部依然是通过读取DX的值来得到变量x的地址。即main调用f虽然没有传递参数也没有返回值,但是他们却共享了一个寄存器DX的值。

package main

func test() func() {
    x := 100
    return func() {
        x += 100
    }
}

func main() {
    f := test()
    f()
    f()
    f()
}
TEXT %22%22.test(SB) gofile../Users/user/go/src/test/main.go
  main.go:3        0x6ad            65488b0c2500000000    MOVQ GS:0, CX        [5:9]R_TLS_LE        
  main.go:3        0x6b6            483b6110        CMPQ 0x10(CX), SP    
  main.go:3        0x6ba            0f869b000000        JBE 0x75b        
  main.go:3        0x6c0            4883ec28        SUBQ $0x28, SP        
  main.go:3        0x6c4            48896c2420        MOVQ BP, 0x20(SP)    
  main.go:3        0x6c9            488d6c2420        LEAQ 0x20(SP), BP    
  main.go:3        0x6ce            48c744243000000000    MOVQ $0x0, 0x30(SP)    
  main.go:4        0x6d7            488d0500000000        LEAQ 0(IP), AX        [3:7]R_PCREL:type.int    
  main.go:4        0x6de            48890424        MOVQ AX, 0(SP)        
  main.go:4        0x6e2            e800000000        CALL 0x6e7        [1:5]R_CALL:runtime.newobject    
  main.go:4        0x6e7            488b442408        MOVQ 0x8(SP), AX    
  main.go:4        0x6ec            4889442418        MOVQ AX, 0x18(SP)    
  main.go:4        0x6f1            48c70064000000        MOVQ $0x64, 0(AX)    
  main.go:5        0x6f8            488d0500000000        LEAQ 0(IP), AX        [3:7]R_PCREL:type.noalg.struct { F uintptr; %22%22.x *int }    
  main.go:5        0x6ff            48890424        MOVQ AX, 0(SP)        
  main.go:5        0x703            e800000000        CALL 0x708        [1:5]R_CALL:runtime.newobject    
  main.go:5        0x708            488b442408        MOVQ 0x8(SP), AX    
  main.go:5        0x70d            4889442410        MOVQ AX, 0x10(SP)    
  main.go:5        0x712            488d0d00000000        LEAQ 0(IP), CX        [3:7]R_PCREL:%22%22.test.func1    
  main.go:5        0x719            488908            MOVQ CX, 0(AX)        
  main.go:5        0x71c            488b442410        MOVQ 0x10(SP), AX    
  main.go:5        0x721            8400            TESTB AL, 0(AX)        
  main.go:5        0x723            488b4c2418        MOVQ 0x18(SP), CX    
  main.go:5        0x728            488d7808        LEAQ 0x8(AX), DI    
  main.go:5        0x72c            833d0000000000        CMPL $0x0, 0(IP)    [2:6]R_PCREL:runtime.writeBarrier+-1    
  main.go:5        0x733            7402            JE 0x737        
  main.go:5        0x735            eb1a            JMP 0x751        
  main.go:5        0x737            48894808        MOVQ CX, 0x8(AX)    
  main.go:5        0x73b            eb00            JMP 0x73d        
  main.go:5        0x73d            488b442410        MOVQ 0x10(SP), AX    
  main.go:5        0x742            4889442430        MOVQ AX, 0x30(SP)    
  main.go:5        0x747            488b6c2420        MOVQ 0x20(SP), BP    
  main.go:5        0x74c            4883c428        ADDQ $0x28, SP        
  main.go:5        0x750            c3            RET            
  main.go:5        0x751            4889c8            MOVQ CX, AX        
  main.go:5        0x754            e800000000        CALL 0x759        [1:5]R_CALL:runtime.gcWriteBarrier    
  main.go:5        0x759            ebe2            JMP 0x73d        
  main.go:3        0x75b            e800000000        CALL 0x760        [1:5]R_CALL:runtime.morestack_noctxt    
  main.go:3        0x760            e948ffffff        JMP %22%22.test(SB)    

TEXT %22%22.main(SB) gofile../Users/user/go/src/test/main.go
  main.go:10        0x7bc            65488b0c2500000000    MOVQ GS:0, CX        [5:9]R_TLS_LE        
  main.go:10        0x7c5            483b6110        CMPQ 0x10(CX), SP    
  main.go:10        0x7c9            763f            JBE 0x80a        
  main.go:10        0x7cb            4883ec18        SUBQ $0x18, SP        
  main.go:10        0x7cf            48896c2410        MOVQ BP, 0x10(SP)    
  main.go:10        0x7d4            488d6c2410        LEAQ 0x10(SP), BP    
  main.go:11        0x7d9            e800000000        CALL 0x7de        [1:5]R_CALL:%22%22.test    
  main.go:11        0x7de            488b1424        MOVQ 0(SP), DX        
  main.go:11        0x7e2            4889542408        MOVQ DX, 0x8(SP)    
  main.go:12        0x7e7            488b02            MOVQ 0(DX), AX        
  main.go:12        0x7ea            ffd0            CALL AX            [0:0]R_CALLIND        
  main.go:13        0x7ec            488b542408        MOVQ 0x8(SP), DX    
  main.go:13        0x7f1            488b02            MOVQ 0(DX), AX        
  main.go:13        0x7f4            ffd0            CALL AX            [0:0]R_CALLIND        
  main.go:14        0x7f6            488b542408        MOVQ 0x8(SP), DX    
  main.go:14        0x7fb            488b02            MOVQ 0(DX), AX        
  main.go:14        0x7fe            ffd0            CALL AX            [0:0]R_CALLIND        
  main.go:15        0x800            488b6c2410        MOVQ 0x10(SP), BP    
  main.go:15        0x805            4883c418        ADDQ $0x18, SP        
  main.go:15        0x809            c3            RET            
  main.go:10        0x80a            e800000000        CALL 0x80f        [1:5]R_CALL:runtime.morestack_noctxt    
  main.go:10        0x80f            ebab            JMP %22%22.main(SB)    

TEXT %22%22.test.func1(SB) gofile../Users/user/go/src/test/main.go
  main.go:5        0x84b            4883ec10        SUBQ $0x10, SP        
  main.go:5        0x84f            48896c2408        MOVQ BP, 0x8(SP)    
  main.go:5        0x854            488d6c2408        LEAQ 0x8(SP), BP    
  main.go:5        0x859            488b4208        MOVQ 0x8(DX), AX    
  main.go:5        0x85d            48890424        MOVQ AX, 0(SP)        
  main.go:6        0x861            48830064        ADDQ $0x64, 0(AX)    
  main.go:7        0x865            488b6c2408        MOVQ 0x8(SP), BP    
  main.go:7        0x86a            4883c410        ADDQ $0x10, SP        
  main.go:7        0x86e            c3            RET        

递归函数

  从本质上讲递归函数与普通函数并无特殊之处,只是不断调用自身,栈不断增加而已。在 C 里面栈大小是固定的,因此需要关心栈溢出(Stack overflow)的问题。不过 Go 里面栈根据需要自动扩容,不需要担心这个问题。

关于 defer 语句

defer与return

  可以先看一下下面三个函数,尝试推理函数的返回值:

func f() (result int) {
    defer func() {
        result++
    }()
    return 0
}

func f() (r int) {
     t := 5 
     defer func() {
       t = t + 5
     }()
     return t
}

func f() (r int) {
    defer func(r int) {
          r = r + 5
    }(r)
    return 1
}

  正确答案分别是:1,5,1。如果你的答案正确,可以略过下面的解释了 :)

  "defer 后的函数调用 在 return 语句之前执行"这句话并不容易理解正确。实际上 return xxx 语句不是原子的,而是先将xxx写入到 caller 为返回值分配的栈空间,接着执行 RET 指令这两步操作。defer函数就是插入在 RET 指令前执行。

goroutine的控制结构里有一张记录defer表达式的表,编译器在defer出现的地方插入了指令 call runtime.deferproc,它将defer的表达式记录在表中。然后在函数返回之前依次从defer表中将表达式出栈执行,这时插入的指令是call runtime.deferreturn。

defer 与闭包

  defer 语句调用的函数的参数是在defer注册时求值或复制的。因此局部变量作为参数传递给defer的函数语句后,后面对局部变量的修改将不再影响defer函数内对该变量值的使用。但是defer函数里使用非参数传入的外部函数的变量,将使用到该变量在外部函数生命周期内最终的值。

package main

import "fmt"


func test() {
    x, y := 10, 20
    defer func(i int) {
        fmt.Println("defer:", i, y)
    }(x)

    x += 10
    y += 100
    fmt.Println(x, y)
}

func main(){
    test()
}
输出:
20 120
defer: 10 120

备注:

  • 内存中栈从高地址空间向低地址空间增长,栈顶比栈底的内存地址小,分配栈空间对应的是 sp 值的减小。
  • 写值是从低地址往高地址写,比如 SP 指向 0xff00,往栈里写入一个字(8 字节),占用的是 0xff00 到 0xff07 这 8 个字节。
  • intel存储字节的顺序为小端优先:即低有效字节存储在内存低地址中。
  • 在IA-32和X86-64中,字长定义为16位,dword(双倍字)是 32 位,qword(四倍字)是64位。

生成汇编文件的方法

  1. 使用 go tool compile -N -l -S go_file.go 生成
  2. 使用 go tool compile -N -l go_file.go编译成二进制文件,接着执行 go tool objdump bin_name.o反汇编出代码,可以通过 -s 指定函数名从而只反汇编特定函数:go tool objdump -s YOUR_FUNC_NAME bin_name.o
  3. 使用 go build -gcflags -S生成

  注意:go tool compile 和 go build -gcflags -S 生成的是过程中的汇编,go tool objdump生成的是最终的机器码的汇编。

总结

  Go 语言完全使用栈来传递参数和返回值并由调用者负责清栈,通过栈传递返回值使得Go函数能支持多返回值,调用者清栈则可以实现可变参数的函数。Go 使用值传递的模式传递参数,因此传递数组和结构体时,应该尽量使用指针作为参数来避免大量数据拷贝从而提升性能。
  Go 方法调用的时候是将接收者作为参数传递给了callee,接收者分值接收者和指针接收者。
  当传递匿名函数的时候,传递的实际上是函数的入口指针。当使用闭包的时候,Go 通过逃逸分析机制将变量分配到堆内存,变量地址和函数入口地址组成一个存在堆上的结构体,传递闭包的时候,传递的就是这个结构体的地址。
  Go 的数据类型分为值类型和引用类型,但 Go 的参数传递是值传递。当传递的是值类型的时候,是完全的拷贝,callee里对参数的修改不影响原值;当传递的是引用类型的时候,callee里的修改会影响原值。
  带返回值的return语句对应的是多条机器指令,首先是将返回值写入到caller在栈上为返回值分配的空间,然后执行ret指令。有defer语句的时候,defer语句里的函数就是插入到 ret 指令之前执行。

参考和深入阅读:

关于调用惯例
x86 calling conventions
Calling convention

关于内存布局和函数帧栈
x86-64 下函数调用及栈帧原理
Process Memory Layout
Anatomy of a Program in Memory
Linux进程地址空间 && 进程内存布局
运行时内存布局与栈帧结构
C程序的内存布局(Memory Layout
C函数调用过程原理及函数栈帧分析

关于Plan9汇编
plan9 汇编入门
golang汇编基础知识
golang 汇编

关于Go
Function declarations, Method declarations
Effective Go Functions
深入研究goroutine栈
Go defer关键字
Go语言高级编程 再论函数

本文从这些文章中引用了代码样例和语句

Stack Traces In Go
浅谈Go语言实现原理-函数调用

查看原文

赞 12 收藏 8 评论 0

叫我叮当 发布了文章 · 2019-07-13

前端面试重点之--居中问题

前端面试重点——居中问题

在页面布局开发中,居中问题是我们经常碰到的问题,掌握居中问题对于解决页面布局非常重要,同时它也是常见的面试重点。本文汇总一些常见的居中方式以及一些注意点,权当学习笔记。

[toc]

一、水平居中

1. inline-block + text-align

确保子元素是行内块级元素后,给父元素 text-align: center; 这种情况对于子元素定宽或者不定宽都生效。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    text-align: center;
}
.child {
    display: inline-block;
}

2. table + margin

此时利用table的宽度是内容的宽度,且table可以使用margin
<div class="parent">
    <div class="child">child</div>
</div>
.child {
    display: table;
    margin: 0 auto;
}

3. absolute + transform

确定父元素 相对定位后,将子元素通过绝对定位在父元素内实现居中。该方法适用于子元素定宽或者不定宽,万能方法。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    position: relative;
}
.child {
    position: absolute;
    left: 50%;
    top: translateX(-50%);
}

4. flex + justify-content

弹性布局(flex布局)也是常用来居中的方式,只需要给父级元素添加弹性布局格式,同时设置横轴对齐方式justiify-content来设置居中。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    display: flex;
    justify-content: center;
}
在选择居中对齐的时候,也可以通过考虑子元素的宽度是否确定,如果宽度确定,也可通过:margin: 0 auto;实现水平居中。

注意点:

  • text-align用来设置元素中的的文本行内元素的对齐方式;
  • text-align只对行内元素有效,对块元素无效,不能设置块元素的对齐方式;

二、垂直居中

1. line-height = height (只适用于单行内行内元素)

这种方法在设置单行块的时候特别有效,需要知道父元素高度。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    height: 100px;
}
.child {
    line-height: 100px;
}

2. table-cell + vertical-align(单行,多行都可居中)

利用表格单元格的特性,单元格内支持居中。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    display: table-cell;
    vertical-align: middle;
}

3. absolute + transform

父元素相对布局,子元素绝对布局,适用很多场景。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    position: relative;
}
.child {
    position: absolute;
    top: 50%;
    transfrom: translateY(-50%);
}

4. flex + align-item

flex布局,通过纵向对齐align-item设置交叉轴对齐。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    display: flex;
    align-items: center;
}

三、水平垂直居中

将上面的水平居中方法和垂直居中方法结合起来就可以实现水平垂直居中。

1. inline-block + text-align + table-cell + vertical-align

<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    diaplay: teable-cell;
    text-align: center;
    vertical-align: middle;
}
.child {
    display: inline-block;
}

2. margin: auto

已知宽高的元素父元素相对定位,子元素绝对定位。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    positon: relative;
}
.child {
    position: absolute;
    top: 0;
    right: 0;
    left: 0;
    bottom: 0;
    margin: auto;
}

3. transform + translate

不管宽高是否给定,都可以使用父元素相对定位,子元素绝对定位。(未知宽高可能是行内元素)

<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    positon: relative;
}
.child {
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(-50%, -50%);
}

4. flex

flex布局,设置主轴和交叉轴的对齐方式。
<div class="parent">
    <div class="child">child</div>
</div>
.parent {
    display: flex;
    justify-content: center;
    align-items: center;
}

注意点:

  1. 行内元素设置宽高是无效的,可以通过设置line-height实现行内元素高度的设置,行内元素设置margin或者padding只有左右有效,上下无效。
  2. flex(ie 9以上才支持)的兼容性写法:
{
    display: -webkit-box;
    display: -webkit-flex;
     display: -moz-flex; 
      display: -ms-flexbox; 
      display: flex;
}

(完)

查看原文

赞 2 收藏 2 评论 0

叫我叮当 关注了专栏 · 2019-07-13

前端爱翻译

我会在这里定期翻译一些前端领域优秀的,且包含示例的文章, 至少,我觉得这些文章对我自己有用~ グッ!(๑•̀ㅂ•́)و✧

关注 4965

叫我叮当 关注了专栏 · 2019-07-13

高级前端进阶公众号

木易杨,资深前端工程师。接下来让我带你走进高级前端的世界,在进阶的路上,共勉!

关注 399

叫我叮当 关注了专栏 · 2019-07-13

疯狂的技术宅

本专栏文章首发于公众号:前端先锋 。

关注 31420

叫我叮当 关注了专栏 · 2019-07-13

终身学习者

我要先坚持分享20年,大家来一起见证吧。

关注 57418

认证与成就

  • 获得 3 次点赞
  • 获得 0 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 0 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-07-13
个人主页被 273 人浏览