前端开发规范

小怪獸 發表於 2022-12-2 10:13:00

<p></p><div class="toc"><div class="toc-container-header">目录</div><ul><li>1. 手册说明<ul><li>1.1 概述</li><li>1.2 手册约定</li></ul></li><li>2. 基本原则<ul><li>2.1 结构、样式、行为分离</li><li>2.2 文件规范</li><li>2.3 命名规范<ul><li>2.3.1 命名严谨性</li><li>2.3.2 项目命名</li><li>2.3.3 目录命名</li><li>2.3.4 组件文件命名</li></ul></li><li>2.4 缩进</li><li>2.5 文件编码</li><li>2.6 标签和属性一律使用小写字母</li><li>2.7 省略外链资源 URL 协议部分</li><li>2.8 统一注释<ul><li>2.8.1 HTML 注释</li><li>2.8.2 CSS注释</li><li>2.8.3 JavaScript注释</li></ul></li><li>2.9 编辑器配置</li></ul></li><li>3. HTML 规范<ul><li>3.1 通用规定<ul><li>3.1.1 标签</li><li>3.1.2 Class 与 ID</li><li>3.1.3 属性</li><li>3.1.4 引号</li><li>3.1.5 嵌套<ul><li>3.1.5.1 语义嵌套约束</li><li>3.1.5.2 严格嵌套约束</li></ul></li><li>3.1.6 布尔值属性</li><li>3.1.7 CSS 和 JavaScript 引入</li></ul></li><li>3.2 语义化<ul><li>3.2.1 常见标签语义</li><li>3.2.2 示例</li></ul></li><li>3.3 HEAD<ul><li>3.3.1 文档类型</li><li>3.3.2 语言属性</li><li>3.3.3 字符编码</li><li>3.3.4 IE 兼容模式</li><li>3.3.5 SEO 优化</li><li>3.3.6 title</li><li>3.3.7 viewport</li><li>3.3.8 iOS 图标</li><li>3.3.9 favicon</li><li>3.3.10 HEAD 模板</li></ul></li><li>3.4 图片</li><li>3.5 表单<ul><li>3.5.1 控件标题</li><li>3.5.2 按钮</li></ul></li><li>3.6 多媒体</li></ul></li><li>4. CSS 规范<ul><li>4.1 通用约定<ul><li>4.1.1 代码组织</li><li>4.1.2 Class 和 ID</li><li>4.1.3 命名规则常用单词</li><li>4.1.4 声明块格式</li><li>4.1.5 属性缩写</li><li>4.1.6 属性书写顺序</li><li>4.1.7 引号使用</li><li>4.1.8 文本编排<ul><li>4.1.8.1 字体族</li><li>4.1.8.2 字号</li></ul></li><li>4.1.9 媒体查询（Media query）的位置</li><li>4.1.10 不要使用<code>@import</code></li><li>4.1.11 链接的样式顺序</li><li>4.1.12 !important</li><li>4.1.13 无需添加浏览器厂商前缀</li></ul></li><li>4.2 BEM命名规范<ul><li>4.2.1 命名方法</li><li>4.2.2 Block</li><li>4.2.3 Element</li><li>4.2.4 <strong>Modifier</strong></li></ul></li><li>4.3 Less 规范<ul><li>4.3.1 代码组织</li><li>4.3.2 <code>@import</code> 语句</li><li>4.3.3 混入（Mixin）</li><li>4.3.4 避免嵌套层级过多</li><li>4.3.5 字符串插值</li></ul></li><li>4.4 性能优化<ul><li>4.4.1 慎重选择高消费的样式</li><li>4.4.2 避免过分重排</li><li>4.4.3 正确使用Display的属性</li><li>4.4.4 不滥用 Float</li><li>4.4.5 动画性能优化</li><li>4.4.6 多利用硬件能力，如通过3D变形开启GPU加速</li><li>4.4.7 提升 CSS 选择器性能</li></ul></li></ul></li><li>5. JavaScript 规范<ul><li>5.1 通用约定<ul><li>5.1.1 缩进<ul><li>[建议] 使用多行模板字符串时遵循缩进原则。当空行与空白字符敏感时，不使用多行模板字符串。</li></ul></li><li>5.1.2 空格</li><li>5.1.3 换行</li><li>5.1.4 语句<ul><li>[建议] 箭头函数的函数体只有一个单行表达式语句，且作为返回值时，省略 <code>{}</code> 和 <code>return</code>。</li><li>[建议] 箭头函数的函数体只有一个 <code>Object Literal (对象字面量)</code>，且作为返回值时，使用 <code>()</code> 包裹。</li><li>[强制] 解构多个变量时，如果超过行长度限制，每个解构的变量必须单独一行。</li></ul></li><li>5.1.5 注释<ul><li>5.1.5.1 原则</li><li>5.1.5.2 单行注释</li><li>5.1.5.3 多行注释</li><li>5.1.5.4 类型定义</li><li>5.1.5.5 文件注释</li><li>5.1.5.6 命名空间注释</li><li>5.1.5.7 类注释</li><li>5.1.5.8 函数/方法注释</li><li>5.1.5.9 事件注释</li><li>5.1.5.10 常量注释</li><li>5.1.5.11 细节注释</li></ul></li><li>5.1.6 命名</li><li>5.1.7 命名语法</li><li>5.1.8 接口命名规范</li><li>5.1.9 不要在 Array 上使用 for-in 循环</li><li>5.1.10 二元和三元操作符</li><li>5.1.11 条件(三元)操作符 (?😃</li></ul></li><li>5.2 语言特性<ul><li>5.2.1 变量</li><li>5.2.2 条件</li><li>5.2.3 循环</li><li>5.2.4 解构</li><li>5.2.5 类型<ul><li>5.2.5.1 类型检测</li><li>5.2.5.2 类型转换</li></ul></li><li>5.2.6 字符串</li><li>5.2.7 函数</li><li>5.2.8 对象</li><li>5.2.9 类</li><li>4.2.10 模块</li><li>4.2.11 集合</li></ul></li></ul></li><li>6. Vue代码规范<ul><li><ul><li>6.1 Vue 项目目录规范</li><li>6.2 组件规范</li><li>6.3Vue api 规范</li><li>6.4 Vue Router 规范</li><li>6.5 前后端对接 api 规范</li><li>6.6 注释说明</li><li>6.7 其他</li></ul></li></ul></li><li>7. 移动端规范</li><li>参考</li></ul></div><p></p>
<h2 id="1-手册说明">1. 手册说明</h2>
<h3 id="11-概述">1.1 概述</h3>
<p>为了提升团队凝聚力，统一团队代码风格，优化团队协作效率，需要推出专门的《前端开发规范手册》来约束同一项目不同程序员的代码风格。</p>
<p>本规范旨在为前端程序的开发者提供规范化最新的指导，可用于程序员个人编译环境以及研发团队集成环境等场合的代码规范化检查。</p>
<blockquote>
<p><em>不管有多少人共同参与同一项目，一定要确保每一行代码都像是同一个人编写的</em></p>
</blockquote>
<h3 id="12-手册约定">1.2 手册约定</h3>
<table>
<thead>
<tr>
<th>约束等级</th>
<th>约束效力</th>
<th>强制性</th>
</tr>
</thead>
<tbody>
<tr>
<td>【强制】</td>
<td>违反该项将被认为代码存在严重缺陷</td>
<td>前端程序团队必须遵守</td>
</tr>
<tr>
<td>【推荐】</td>
<td>违反该项将被认为代码存在轻微缺陷</td>
<td>根据具体产品特性的不同，选择性地遵守</td>
</tr>
<tr>
<td>【参考】</td>
<td>违反该项可被认为代码存在优化空间</td>
<td>从产品持续优化及人员技能提升的角度，参考使用</td>
</tr>
</tbody>
</table>
<h2 id="2-基本原则">2. 基本原则</h2>
<h3 id="21-结构样式行为分离">2.1 结构、样式、行为分离</h3>
<p>尽量确保文档和模板只包含 <code>HTML</code> 结构，样式都放到样式表里，行为都放到脚本里。</p>
<h3 id="22-文件规范">2.2 文件规范</h3>
<ul>
<li>
<p><strong><code>html</code> , <code>css</code> , <code>js</code> , <code>images</code> 文件均归档至约定的目录中。</strong></p>
</li>
<li>
<p><strong><code>html</code> 文件命名: 英文命名, 后缀<code>.html</code> 或<code>.htm.</code>同时将统一页面文件放于同目录中, 以方便后端添加功能时查找对应页面。</strong></p>
</li>
<li>
<p><strong><code>css</code> 文件命名: 英文命名, 后缀<code>.css</code>共用<code>base.css</code> , 首页<code>index.css</code> , 其他页面依实际模块需求命名。</strong></p>
</li>
<li>
<p><strong><code>Js</code>文件命名: 英文命名, 后缀<code>.js</code> 共用<code>common.js</code> , 其他依实际模块需求命名。</strong></p>
</li>
</ul>
<h3 id="23-命名规范">2.3 命名规范</h3>
<h4 id="231-命名严谨性">2.3.1 命名严谨性</h4>
<p>代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式。说明：正确的英文拼写和语法可以让开发者易于理解，避免歧义。注意，即使纯拼音命名方式也要避免采用,杜绝完全不规范的缩写，避免望文不知意。</p>
<ul>
<li>CODELF (unbug.github.io)变量命名网站 (现在暂时不可用，后续可能修复)</li>
</ul>
<h4 id="232-项目命名">2.3.2 项目命名</h4>
<p>使用 kebab-case 命名，小写形式，中横线分隔</p>
<p>例子：cloud-teach-client</p>
<h4 id="233-目录命名">2.3.3 目录命名</h4>
<p>全部采用小写或者 PascalCase(驼峰命名法) 方式命名，有负数目录结构时，要采用复数命名 , 缩写不需要采用负数</p>
<p>例子: styles 、components 、images 、layouts 、utils 、 api 、router</p>
<h4 id="234-组件文件命名">2.3.4 组件文件命名</h4>
<p>在 Vue 中 .vue文件命名使用PascalCase 杜绝完全不规范的缩写，避免望文不知意。</p>
<h3 id="24-缩进">2.4 缩进</h3>
<ul>
<li><strong>[强制] 统一 <code>Tab</code> 缩进（需设置1个<code>Tab</code>为2个空格数），不要使用 <code>Tab</code> 或者 <code>Tab</code>、空格混搭。</strong></li>
</ul>
<h3 id="25-文件编码">2.5 文件编码</h3>
<p><strong>使用不带 <code>BOM</code> 的 UTF-8 编码。</strong></p>
<ul>
<li>在 HTML中指定编码 <code><meta charset="utf-8"></code> ；</li>
<li>无需使用 <code>@charset</code> 指定样式表的编码，它默认为 <code>UTF-8</code> （参考 @charset）；</li>
</ul>
<h3 id="26-标签和属性一律使用小写字母">2.6 标签和属性一律使用小写字母</h3>
<pre><code class="language-html">
<img src="google.png" alt="Google">


<A HREF="/">Home</A>
</code></pre>
<pre><code class="language-css">/* 推荐 */
color: #e5e5e5;

/* 不推荐 */
color: #E5E5E5;
</code></pre>
<h3 id="27-省略外链资源-url-协议部分">2.7 省略外链资源 URL 协议部分</h3>
<p>省略外链资源（图片及其它媒体资源）URL 中的 <code>http</code> / <code>https</code> 协议，使 URL 成为相对地址，避免Mixed Content 问题，减小文件字节数。</p>
<p><strong>其它协议（<code>ftp</code> 等）的 URL 不省略。</strong></p>
<pre><code class="language-html">
<script src="//www.w3cschool.cn/statics/js/autotrack.js"></script>


<script src="http://www.w3cschool.cn/statics/js/autotrack.js"></script>
</code></pre>
<pre><code class="language-css">/* 推荐 */
.example {
background: url(//www.google.com/images/example);
}

/* 不推荐 */
.example {
background: url(http://www.google.com/images/example);
}
</code></pre>
<h3 id="28-统一注释">2.8 统一注释</h3>
<p>通过配置编辑器，可以提供快捷键来输出一致认可的注释模式。</p>
<h4 id="281-html-注释">2.8.1 HTML 注释</h4>
<ul>
<li>
<p>模块注释</p>
<pre><code class="language-html">
<div class="article-list">
...
</div>
</code></pre>
</li>
<li>
<p>区块注释</p>
<pre><code class="language-html">
</code></pre>
</li>
</ul>
<h4 id="282-css注释">2.8.2 CSS注释</h4>
<p>组件块和子组件块以及声明块之间使用一空行分隔，子组件块之间三空行分隔；</p>
<pre><code class="language-css">/* ==========================================================================
组件块
============================================================================ */

/* 子组件块
============================================================================ */
.selector {
padding: 15px;
margin-bottom: 15px;
}

/* 子组件块
============================================================================ */
.selector-secondary {
display: block; /* 注释*/
}

.selector-three {
display: span;
}
</code></pre>
<h4 id="283-javascript注释">2.8.3 JavaScript注释</h4>
<ul>
<li>单行注释</li>
</ul>
<p>必须独占一行。<code>//</code> 后跟一个空格，缩进与下一行被注释说明的代码一致。</p>
<ul>
<li>多行注释</li>
</ul>
<p>避免使用 <code>/*...*/</code> 这样的多行注释。有多行注释内容时，使用多个单行注释。</p>
<ul>
<li>函数/方法注释
<ul>
<li>函数/方法注释必须包含函数说明，有参数和返回值时必须使用注释标识；</li>
<li>参数和返回值注释必须包含类型信息和说明；</li>
<li>当函数是内部函数，外部不可访问时，可以使用 @inner 标识；</li>
</ul>
</li>
</ul>
<pre><code class="language-js">/**
* 函数描述
*
* @param {string} p1 参数1的说明
* @param {string} p2 参数2的说明，比较长
* 那就换行了.
* @param {number=} p3 参数3的说明（可选）
* @return {Object} 返回值描述
*/
function foo(p1, p2, p3) {
let p3 = p3 || 10;
return {
   p1: p1,
   p2: p2,
   p3: p3
};
}
</code></pre>
<ul>
<li>文件注释</li>
</ul>
<p>文件注释用于告诉不熟悉这段代码的读者这个文件中包含哪些东西。应该提供文件的大体内容, 它的作者, 依赖关系和兼容性信息。如下:</p>
<pre><code class="language-js">/**
* @fileoverview Description of file, its uses and information
* about its dependencies.
* @author user@meizu.com (Firstname Lastname)
* Copyright 2015 Meizu Inc. All Rights Reserved.
*/
</code></pre>
<h3 id="29-编辑器配置">2.9 编辑器配置</h3>
<p>将你的编辑器按照下面的配置进行设置，以避免常见的代码不一致和差异：</p>
<ul>
<li>制表符<code>tab</code>设置为<code>2</code> 个空格数。</li>
<li>保存文件时，删除尾部的空白符。</li>
<li>设置文件编码为 UTF-8。</li>
<li>在文件结尾添加一个空白行。</li>
</ul>
<p>参照文档并将这些配置信息添加到项目的 <code>.editorconfig</code> 文件中。</p>
<h2 id="3-html-规范">3. HTML 规范</h2>
<p>尽量遵循 HTML 标准和语义，但是不要以牺牲实用性为代价。任何时候都要尽量使用最少的标签并保持最小的复杂度。</p>
<h3 id="31-通用规定">3.1 通用规定</h3>
<h4 id="311-标签">3.1.1 标签</h4>
<ul>
<li>
<p><strong>[强制] 标签名必须使用小写字母。</strong></p>
<pre><code class="language-js">
<p>Hello StyleGuide!</p>


<P>Hello StyleGuide!</P>
</code></pre>
</li>
</ul>
<ul>
<li>
<p><strong>[强制] 对于无需自闭合的标签，不允许自闭合 ( 例如： <code>img</code> <code>input</code> <code>br</code> <code>hr</code> 等 )；</strong></p>
<pre><code class="language-html">
<input type="text" name="title">


<input type="text" name="title" />
</code></pre>
</li>
<li>
<p><strong>[强制] 可选的闭合标签（closing tag），需闭合 ( 例如：<code></li></code> 或 <code></body></code> )；</strong></p>
<pre><code class="language-html">
<ul>
<li>first</li>
<li>second</li>
</ul>


<ul>
<li>first
<li>second
</ul>
</code></pre>
</li>
<li>
<p><strong>[推荐] 尽量减少标签数量。</strong></p>
<pre><code class="language-html">
<span class="avatar">
<img src="...">
</span>


<img class="avatar" src="...">
</code></pre>
</li>
</ul>
<h4 id="312-class-与-id">3.1.2 Class 与 ID</h4>
<ul>
<li><strong>[强制] <code>class</code> 必须代表相应模块或部件的内容或功能，不得以样式信息进行命名。</strong></li>
<li><strong>[强制] class 与 id 单词全字母小写，多个单词组成时，采用中划线<code>-</code>分隔。</strong></li>
<li><strong>使用唯一的 id 作为 Javascript hook, 同时避免创建无样式信息的 class。</strong></li>
</ul>
<pre><code class="language-js">
<div class="j-hook left contentWrapper"></div>


<div id="j-hook" class="sidebar content-wrapper"></div>
</code></pre>
<ul>
<li>
<p><strong>[强制] 禁止为了 <code>hook 脚本</code>，创建无样式信息的 <code>class</code>。</strong></p>
<p>不允许 <code>class</code> 只用于让 JavaScript 选择某些元素，<code>class</code> 应该具有明确的语义和样式。否则容易导致 CSS class 泛滥。</p>
<p>使用 <code>id</code>、属性选择作为 hook 是更好的方式。</p>
</li>
</ul>
<h4 id="313-属性">3.1.3 属性</h4>
<ul>
<li>
<p><strong>[强制] 属性名必须使用小写字母。</strong></p>
<pre><code class="language-js">
<table cellspacing="0">...</table>


<table cellSpacing="0">...</table>
</code></pre>
</li>
<li>
<p><strong>[强制] 属性值必须用双引号包围。</strong></p>
<p>不允许使用单引号，不允许不使用引号。</p>
<pre><code class="language-html">
<script src="esl.js"></script>


<script src='esl.js'></script>
<script src=esl.js></script>
</code></pre>
</li>
<li>
<p><strong>[强制] HTML 属性应该按照特定的顺序出现以保证易读性。</strong></p>
<ul>
<li>id</li>
<li>class</li>
<li>name</li>
<li>data-xxx</li>
<li>src, for, type, href</li>
<li>title, alt</li>
</ul>
</li>
<li>
<p>aria-xxx, role</p>
<pre><code class="language-html"><a id="..." class="..." data-modal="toggle" href="###"></a>

<input class="form-control" type="text">

<img src="..." alt="...">
</code></pre>
</li>
</ul>
<pre><code>
- **[建议] 布尔类型的属性，建议不添加属性值。**

```html
<input type="text" disabled>
<input type="checkbox" value="1" checked>
</code></pre>
<ul>
<li>
<p><strong>[建议] 自定义属性建议以 <code>xxx-</code> 为前缀，推荐使用 <code>data-</code>。</strong></p>
<p>使用前缀有助于区分自定义属性和标准定义的属性。</p>
<pre><code class="language-html"><ol data-ui-type="Select"></ol>
</code></pre>
</li>
</ul>
<h4 id="314-引号">3.1.4 引号</h4>
<p>属性的定义，统一使用双引号。</p>
<pre><code class="language-html">
<span id='j-hook' class=text>Google</span>


<span id="j-hook" class="text">Google</span>
</code></pre>
<h4 id="315-嵌套">3.1.5 嵌套</h4>
<p><code>a 不允许嵌套 div</code>这种约束属于语义嵌套约束，与之区别的约束还有严格嵌套约束，比如<code>a 不允许嵌套 a</code>。</p>
<p>严格嵌套约束在所有的浏览器下都不被允许；而语义嵌套约束，浏览器大多会容错处理，生成的文档树可能相互不太一样。</p>
<p>详细的标签嵌套规则参见 HTML标签嵌套规则。</p>
<h5 id="3151-语义嵌套约束">3.1.5.1 语义嵌套约束</h5>
<p><code><li></code> 用于 <code><ul></code> 或 <code><ol></code> 下；</p>
<p><code><dd></code>, <code><dt></code> 用于 <code><dl></code> 下；</p>
<p><code><thead></code>, <code><tbody></code>, <code><tfoot></code>, <code><tr></code>, <code><td></code> 用于 <code><table></code> 下；</p>
<h5 id="3152-严格嵌套约束">3.1.5.2 严格嵌套约束</h5>
<ul>
<li>行内（inline-Level）元素，仅可以包含文本或其它行内（ inline-Level ）元素;</li>
<li><code><a></code>里不可以嵌套交互式元素<code><a></code>、<code><button></code>、<code><select></code>等;</li>
<li><code><p></code>里不可以嵌套块级元素<code><div></code>、<code><h1>~<h6></code>、<code><p></code>、<code><ul>/<ol>/<li></code>、<code><dl>/<dt>/<dd></code>、<code><form></code>等。</li>
</ul>
<h4 id="316-布尔值属性">3.1.6 布尔值属性</h4>
<p>HTML5 规范中 <code>disabled</code>、<code>checked</code>、<code>selected</code> 等属性不用设置值。</p>
<pre><code class="language-html"><input type="text" disabled>

<input type="checkbox" value="1" checked>

<select>
<option value="1" selected>1</option>
</select>
</code></pre>
<h4 id="317-css-和-javascript-引入">3.1.7 CSS 和 JavaScript 引入</h4>
<ul>
<li>
<p><strong>[强制] 引入 <code>CSS</code> 时必须指明 <code>rel="stylesheet"</code>。</strong></p>
<pre><code class="language-html"><link rel="stylesheet" href="page.css">
</code></pre>
</li>
<li>
<p><strong>[建议] 引入 <code>CSS</code> 和 <code>JavaScript</code> 时无须指明 <code>type</code> 属性。</strong></p>
</li>
<li>
<p><strong>[建议] 在 <code>head</code> 中引入页面需要的所有 <code>CSS</code> 资源。</strong></p>
<p>在页面渲染的过程中，新的CSS可能导致元素的样式重新计算和绘制，页面闪烁。</p>
</li>
<li>
<p><strong>[建议] <code>JavaScript</code> 应当放在页面末尾，或采用异步加载。</strong></p>
<p>将 <code>script</code> 放在页面中间将阻断页面的渲染。出于性能方面的考虑，如非必要，请遵守此条建议。</p>
</li>
</ul>
<h3 id="32-语义化">3.2 语义化</h3>
<p>没有 <code>CSS</code> 的 <code>HTML</code> 是一个语义系统而不是 UI 系统。</p>
<p>通常情况下，每个标签都是有语义的，各自有对应的功能和含义。</p>
<p>此外语义化的 <code>HTML</code> 结构，有助于机器（搜索引擎）理解，另一方面多人协作时，能迅速了解开发者意图。</p>
<h4 id="321-常见标签语义">3.2.1 常见标签语义</h4>
<table>
<thead>
<tr>
<th style="text-align: left">标签</th>
<th style="text-align: left">语义</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: left"><code><p></code></td>
<td style="text-align: left">段落</td>
</tr>
<tr>
<td style="text-align: left"><code><h1> <h2> <h3> ...</code></td>
<td style="text-align: left">标题</td>
</tr>
<tr>
<td style="text-align: left"><code><ul></code></td>
<td style="text-align: left">无序列表</td>
</tr>
<tr>
<td style="text-align: left"><code><ol></code></td>
<td style="text-align: left">有序列表</td>
</tr>
<tr>
<td style="text-align: left"><code><blockquote></code></td>
<td style="text-align: left">大段引用</td>
</tr>
<tr>
<td style="text-align: left"><code><cite></code></td>
<td style="text-align: left">一般引用</td>
</tr>
<tr>
<td style="text-align: left"><code><b></code></td>
<td style="text-align: left">为样式加粗而加粗</td>
</tr>
<tr>
<td style="text-align: left"><code><strong></code></td>
<td style="text-align: left">为强调内容而加粗</td>
</tr>
<tr>
<td style="text-align: left"><code><i></code></td>
<td style="text-align: left">为样式倾斜而倾斜</td>
</tr>
<tr>
<td style="text-align: left"><code><em></code></td>
<td style="text-align: left">为强调内容而倾斜</td>
</tr>
<tr>
<td style="text-align: left"><code>code</code></td>
<td style="text-align: left">代码标识</td>
</tr>
<tr>
<td style="text-align: left"><code>abbr</code></td>
<td style="text-align: left">缩写</td>
</tr>
</tbody>
</table>
<h4 id="322-示例">3.2.2 示例</h4>
<p>将你构建的页面当作一本书，将标签的语义对应的其功能和含义；</p>
<ul>
<li>书的名称：<code><h1></code></li>
<li>书的每个章节标题: <code><h2></code></li>
<li>章节内的文章标题: <code><h3></code></li>
<li>小标题/副标题: <code><h4> <h5> <h6></code></li>
<li>章节的段落: <code><p></code></li>
</ul>
<h3 id="33-head">3.3 HEAD</h3>
<h4 id="331-文档类型">3.3.1 文档类型</h4>
<ul>
<li>
<p><strong>为每个 HTML 页面的第一行添加标准模式（standard mode）的声明，这样能够确保在每个浏览器中拥有一致的表现。</strong></p>
<pre><code class="language-html"><!DOCTYPE html>
</code></pre>
</li>
</ul>
<h4 id="332-语言属性">3.3.2 语言属性</h4>
<p><strong>[建议] 在 <code>html</code> 标签上设置正确的 <code>lang</code> 属性。</strong></p>
<p>为什么使用 lang="zh-cmn-Hans" 而不是我们通常写的 lang="zh-CN" 呢? 请参考知乎上的讨论: 网页头部的声明应该是用 lang="zh" 还是 lang="zh-cn"？</p>
<pre><code class="language-html">
<html lang="zh-Hans">


<html lang="zh-cmn-Hans">


<html lang="zh-cmn-Hant">


<html lang="en">
</code></pre>
<h4 id="333-字符编码">3.3.3 字符编码</h4>
<ul>
<li><strong>[建议] <code>HTML</code> 文件使用无 <code>BOM</code> 的 <code>UTF-8</code> 编码。</strong></li>
<li><strong>[强制] 指定字符编码的 <code>meta</code> 必须是 <code>head</code> 的第一个直接子元素；</strong></li>
</ul>
<pre><code class="language-html"><html>
<head>
<meta charset="utf-8">
......
</head>
<body>
......
</body>
</html>
</code></pre>
<h4 id="334-ie-兼容模式">3.3.4 IE 兼容模式</h4>
<p>优先使用最新版本的IE 和 Chrome 内核</p>
<pre><code class="language-html"><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
</code></pre>
<h4 id="335-seo-优化">3.3.5 SEO 优化</h4>
<pre><code class="language-html"><head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">

<title>Style Guide</title>
<meta name="keywords" content="your keywords">
<meta name="description" content="your description">
<meta name="author" content="author,email address">
</head>
</code></pre>
<h4 id="336-title">3.3.6 title</h4>
<ul>
<li>
<p><strong>[强制] 页面必须包含 <code>title</code> 标签声明标题。</strong></p>
</li>
<li>
<p><strong>[强制] <code>title</code> 必须作为 <code>head</code> 的直接子元素，并紧随 <code>charset</code> 声明之后。</strong></p>
<pre><code class="language-html"><head>
<meta charset="UTF-8">
<title>页面标题</title>
</head>
</code></pre>
</li>
</ul>
<h4 id="337-viewport">3.3.7 viewport</h4>
<ul>
<li><code>viewport</code>: 一般指的是浏览器窗口内容区的大小，不包含工具条、选项卡等内容；</li>
<li><code>width</code>: 浏览器宽度，输出设备中的页面可见区域宽度；</li>
<li><code>device-width</code>: 设备分辨率宽度，输出设备的屏幕可见宽度；</li>
<li><code>initial-scale</code>: 初始缩放比例；</li>
<li><code>maximum-scale</code>: 最大缩放比例；</li>
</ul>
<p>为移动端设备优化，设置可见区域的宽度和初始缩放比例。</p>
<pre><code class="language-html"><meta name="viewport" content="width=device-width, initial-scale=1.0">
</code></pre>
<h4 id="338-ios-图标">3.3.8 iOS 图标</h4>
<ul>
<li>apple-touch-icon 图片自动处理成圆角和高光等效果;</li>
<li>apple-touch-icon-precomposed 禁止系统自动添加效果，直接显示设计原图;</li>
</ul>
<pre><code class="language-html">
<link rel="apple-touch-icon-precomposed" href="/apple-touch-icon-57x57-precomposed.png">


<link rel="apple-touch-icon-precomposed" href="/apple-touch-icon-72x72-precomposed.png" sizes="72x72">


<link rel="apple-touch-icon-precomposed" href="/apple-touch-icon-114x114-precomposed.png" sizes="114x114">


<link rel="apple-touch-icon-precomposed" href="/apple-touch-icon-144x144-precomposed.png" sizes="144x144">
</code></pre>
<p>关于Apple设备私有的apple-touch-icon属性详解</p>
<h4 id="339-favicon">3.3.9 favicon</h4>
<p>在未指定 favicon 时，大多数浏览器会请求 Web Server 根目录下的 favicon.ico 。为了保证 favicon 可访问，避免404，必须遵循以下两种方法之一：</p>
<ul>
<li>在 Web Server 根目录放置 favicon.ico 文件；</li>
<li>使用 link 指定 favicon；</li>
</ul>
<pre><code class="language-html"><link rel="shortcut icon" href="path/to/favicon.ico">
</code></pre>
<h4 id="3310-head-模板">3.3.10 HEAD 模板</h4>
<pre><code class="language-html"><!DOCTYPE html>
<html lang="zh-cmn-Hans">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
<title>Style Guide</title>
<meta name="description" content="不超过150个字符">
<meta name="keywords" content="">
<meta name="author" content="name, email@gmail.com">


<meta name="viewport" content="width=device-width, initial-scale=1.0">


<link rel="apple-touch-icon-precomposed" href="/apple-touch-icon-57x57-precomposed.png">

<link rel="alternate" type="application/rss+xml" title="RSS" href="/rss.xml" />
<link rel="shortcut icon" href="path/to/favicon.ico">
</head>
</code></pre>
<h3 id="34-图片">3.4 图片</h3>
<ul>
<li>
<p><strong>[强制] 禁止 <code>img</code> 的 <code>src</code> 取值为空。延迟加载的图片也要增加默认的 <code>src</code>。</strong></p>
<p><code>src</code> 取值为空，会导致部分浏览器重新加载一次当前页面。</p>
</li>
<li>
<p><strong>[建议] 避免为 <code>img</code> 添加不必要的 <code>title</code> 属性。</strong></p>
<p>多余的 <code>title</code> 影响看图体验，并且增加了页面尺寸。</p>
</li>
<li>
<p><strong>[建议] 为重要图片添加 <code>alt</code> 属性。</strong></p>
<p>可以提高图片加载失败时的用户体验。</p>
</li>
<li>
<p><strong>[建议] 添加 <code>width</code> 和 <code>height</code> 属性，以避免页面抖动。</strong></p>
</li>
<li>
<p><strong>[建议] 有下载需求的图片采用 <code>img</code> 标签实现，无下载需求的图片采用 CSS 背景图实现。</strong></p>
<ol>
<li>产品 logo、用户头像、用户产生的图片等有潜在下载需求的图片，以 <code>img</code> 形式实现，能方便用户下载。</li>
<li>无下载需求的图片，比如：icon、背景、代码使用的图片等，尽可能采用 CSS 背景图实现。</li>
</ol>
</li>
</ul>
<h3 id="35-表单">3.5 表单</h3>
<h4 id="351-控件标题">3.5.1 控件标题</h4>
<ul>
<li>
<p><strong>[强制] 有文本标题的控件必须使用 <code>label</code> 标签将其与其标题相关联。</strong></p>
<p>有两种方式：</p>
<ol>
<li>将控件置于 <code>label</code> 内。</li>
<li><code>label</code> 的 <code>for</code> 属性指向控件的 <code>id</code>。</li>
</ol>
<p>推荐使用第一种，减少不必要的 <code>id</code>。如果 DOM 结构不允许直接嵌套，则应使用第二种。</p>
<pre><code class="language-html"><label><input type="checkbox" name="confirm" value="on"> 我已确认上述条款</label>

<label for="username">用户名：</label> <input type="textbox" name="username" id="username">
</code></pre>
</li>
</ul>
<h4 id="352-按钮">3.5.2 按钮</h4>
<ul>
<li>
<p><strong>[强制] 使用 <code>button</code> 元素时必须指明 <code>type</code> 属性值。</strong></p>
<p><code>button</code> 元素的默认 <code>type</code> 为 <code>submit</code>，如果被置于 <code>form</code> 元素中，点击后将导致表单提交。为显示区分其作用方便理解，必须给出 <code>type</code> 属性。</p>
<pre><code class="language-html"><button type="submit">提交</button>
<button type="button">取消</button>
</code></pre>
</li>
</ul>
<h3 id="36-多媒体">3.6 多媒体</h3>
<ul>
<li>
<p><strong>[建议] 当在现代浏览器中使用 <code>audio</code> 以及 <code>video</code> 标签来播放音频、视频时，应当注意格式。</strong></p>
<p>音频应尽可能覆盖到如下格式：</p>
<ul>
<li>MP3</li>
<li>WAV</li>
<li>Ogg</li>
</ul>
<p>视频应尽可能覆盖到如下格式：</p>
<ul>
<li>MP4</li>
<li>WebM</li>
<li>Ogg</li>
</ul>
</li>
<li>
<p><strong>[建议] 在支持 <code>HTML5</code> 的浏览器中优先使用 <code>audio</code> 和 <code>video</code> 标签来定义音视频元素</strong></p>
</li>
<li>
<p><strong>[建议] 使用退化到插件的方式来对多浏览器进行支持。</strong></p>
<pre><code class="language-html"><audio controls>
<source src="audio.mp3" type="audio/mpeg">
<source src="audio.ogg" type="audio/ogg">
<object width="100" height="50" data="audio.mp3">
   <embed width="100" height="50" src="audio.swf">
</object>
</audio>

<video width="100" height="50" controls>
<source src="video.mp4" type="video/mp4">
<source src="video.ogg" type="video/ogg">
<object width="100" height="50" data="video.mp4">
   <embed width="100" height="50" src="video.swf">
</object>
</video>
</code></pre>
</li>
<li>
<p><strong>[建议] 只在必要的时候开启音视频的自动播放。</strong></p>
</li>
<li>
<p><strong>[建议] 在 <code>object</code> 标签内部提供指示浏览器不支持该标签的说明。</strong></p>
<pre><code class="language-html"><object width="100" height="50" data="something.swf">DO NOT SUPPORT THIS TAG</object>
</code></pre>
</li>
</ul>
<h2 id="4-css-规范">4. CSS 规范</h2>
<h3 id="41-通用约定">4.1 通用约定</h3>
<h4 id="411-代码组织">4.1.1 代码组织</h4>
<ul>
<li>以组件为单位组织代码段；</li>
<li>制定一致的注释规范；</li>
<li><code>组件块和子组件块</code>以及<code>声明块</code>之间使用<strong>一空行</strong>分隔，<code>子组件块</code>之间<strong>三空行</strong>分隔；</li>
<li>如果使用了多个 CSS 文件，将其按照组件而非页面的形式分拆，因为页面会被重组，而组件只会被移动；</li>
</ul>
<p>良好的注释是非常重要的。请留出时间来描述组件（component）的工作方式、局限性和构建它们的方法。不要让你的团队其它成员来猜测一段不通用或不明显的代码的目的。</p>
<p>提示：通过配置编辑器，可以提供快捷键来输出一致认可的注释模式。</p>
<pre><code class="language-css">/* ==========================================================================
组件块
============================================================================ */

/* 子组件块
============================================================================ */
.selector {
padding: 15px;
margin-bottom: 15px;
}

/* 子组件块
============================================================================ */
.selector-secondary {
display: block; /* 注释*/
}

.selector-three {
display: span;
}
</code></pre>
<h4 id="412-class-和-id">4.1.2 Class 和 ID</h4>
<ul>
<li>
<p>使用语义化、通用的命名方式；</p>
</li>
<li>
<p>使用连字符 - 作为 ID、Class 名称界定符，不要驼峰命名法和下划线；</p>
</li>
<li>
<p>避免选择器嵌套层级过多，尽量少于 3 级；</p>
</li>
<li>
<p>避免选择器和 Class、ID 叠加使用；</p>
<p>出于性能考量，在没有必要的情况下避免元素选择器叠加 Class、ID 使用。</p>
<p>元素选择器和 ID、Class 混合使用也违反关注分离原则。如果HTML标签修改了，就要再去修改 CSS 代码，不利于后期维护。</p>
</li>
</ul>
<pre><code class="language-css">/* 不推荐 */
.red {}
.box_green {}
.page .header .login #username input {}
ul#example {}

/* 推荐 */
#nav {}
.box-video {}
#username input {}
#example {}
</code></pre>
<h4 id="413-命名规则常用单词">4.1.3 命名规则常用单词</h4>
<p>头：header<br>
内容：content/container<br>
尾：footer<br>
导航：nav<br>
侧栏：sidebar<br>
栏目：column<br>
页面外围控制整体布局宽度：wrapper<br>
页面主体：main<br>
登录条：loginbar<br>
标志：logo<br>
广告：banner<br>
热点：hot<br>
新闻：news<br>
下载：download<br>
子导航：subnav<br>
菜单：menu<br>
子菜单：submenu<br>
搜索：search<br>
友情链接：friendlink<br>
页脚：footer<br>
版权：copyright<br>
滚动：scroll<br>
内容：content<br>
标签页：tab<br>
文章列表：list<br>
提示信息：msg<br>
小技巧：tips<br>
栏目标题：title<br>
加入：joinus<br>
指南：guide<br>
服务：service<br>
注册：regsiter<br>
状态：status<br>
投票：vote<br>
合作伙伴：partner</p>
<h4 id="414-声明块格式">4.1.4 声明块格式</h4>
<ul>
<li>
<p><strong>选择器分组时，保持独立的选择器占用一行；</strong></p>
<pre><code class="language-css">/* good */
.post,
.page,
.comment {
line-height: 1.5;
}

/* bad */
.post, .page, .comment {
line-height: 1.5;
}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>></code>、<code>+</code>、<code>~</code> 选择器的两边各保留一个空格。</strong></p>
<pre><code class="language-css">/* good */
main > nav {
padding: 10px;
}

label + input {
margin-left: 5px;
}

input:checked ~ button {
background-color: #69C;
}

/* bad */
main>nav {
padding: 10px;
}

label+input {
margin-left: 5px;
}

input:checked~button {
background-color: #69C;
}
</code></pre>
</li>
<li>
<p><strong>[强制] 属性定义必须另起一行。</strong></p>
<pre><code class="language-css">/* good */
.selector {
margin: 0;
padding: 0;
}

/* bad */
.selector { margin: 0; padding: 0; }
</code></pre>
</li>
<li>
<p><strong>[强制] 每行不得超过 <code>120</code> 个字符，除非单行不可分割。</strong></p>
<p>常见不可分割的场景为URL超长。</p>
</li>
<li>
<p><strong>[建议] 对于超长的样式，在样式值的 <code>空格</code> 处或 <code>,</code> 后换行，建议按逻辑分组。</strong></p>
<pre><code class="language-css">/* 不同属性值按逻辑分组 */
background:
transparent url(aVeryVeryVeryLongUrlIsPlacedHere)
no-repeat 0 0;

/* 可重复多次的属性，每次重复一行 */
background-image:
url(aVeryVeryVeryLongUrlIsPlacedHere)
url(anotherVeryVeryVeryLongUrlIsPlacedHere);

/* 类似函数的属性值可以根据函数调用的缩进进行 */
background-image: -webkit-gradient(
linear,
left bottom,
left top,
color-stop(0.04, rgb(88,94,124)),
color-stop(0.52, rgb(115,123,162))
);
</code></pre>
</li>
<li>
<p><strong>声明块的左括号 <code>{</code> 前添加一个空格；</strong></p>
</li>
<li>
<p><strong>声明块的右括号 <code>}</code> 应单独成行；</strong></p>
</li>
<li>
<p><strong>声明语句中的 <code>:</code> 后应添加一个空格；</strong></p>
</li>
<li>
<p><strong>声明语句应以分号 <code>;</code> 结尾；</strong></p>
</li>
<li>
<p><strong>一般以逗号分隔的属性值，每个逗号后应添加一个空格；</strong></p>
</li>
<li>
<p><strong><code>rgb()</code>、<code>rgba()</code>、<code>hsl()</code>、<code>hsla()</code> 或 <code>rect()</code> 括号内的值，逗号分隔，<em>但逗号后不添加一个空格</em>；</strong></p>
</li>
<li>
<p><strong>对于属性值或颜色参数，省略小于 1 的小数前面的 0 （例如，<code>.5</code> 代替 <code>0.5</code>；<code>-.5px</code> 代替<code>-0.5px</code>）；</strong></p>
</li>
<li>
<p><strong>十六进制值应该全部小写和尽量简写，例如，<code>#fff</code> 代替 <code>#ffffff</code>；</strong></p>
</li>
<li>
<p><strong>避免为 0 值指定单位，例如，用 <code>margin: 0;</code> 代替 <code>margin: 0px;</code>；</strong></p>
</li>
</ul>
<pre><code class="language-css">/*不推荐*/
.selector, .selector-secondary, .selector {
padding:15px;
margin:0px 0px 15px;
background-color:rgba(0, 0, 0, 0.5);
box-shadow:0px 1px 2px #CCC,inset 0 1px 0 #FFFFFF
}

/* 推荐 */
.selector,
.selector-secondary,
.selector {
padding: 15px;
margin-bottom: 15px;
background-color: rgba(0,0,0,.5);
box-shadow: 0 1px 2px #ccc, inset 0 1px 0 #fff;
}
</code></pre>
<h4 id="415-属性缩写">4.1.5 属性缩写</h4>
<ul>
<li>
<p><strong>[建议] 在可以使用缩写的情况下，尽量使用属性缩写。</strong></p>
<pre><code class="language-css">/* good */
.post {
font: 12px/1.5 arial, sans-serif;
}

/* bad */
.post {
font-family: arial, sans-serif;
font-size: 12px;
line-height: 1.5;
}
</code></pre>
</li>
<li>
<p><strong>[建议] 使用 <code>border</code> / <code>margin</code> / <code>padding</code> 等缩写时，应注意隐含值对实际数值的影响，确实需要设置多个方向的值时才使用缩写。</strong></p>
<p><code>border</code> / <code>margin</code> / <code>padding</code> 等缩写会同时设置多个属性的值，容易覆盖不需要覆盖的设定。如某些方向需要继承其他声明的值，则应该分开设置。</p>
<pre><code class="language-css">/* centering <article class="page"> horizontally and highlight featured ones */
article {
margin: 5px;
border: 1px solid #999;
}

/* good */
.page {
margin-right: auto;
margin-left: auto;
}

.featured {
border-color: #69c;
}

/* bad */
.page {
margin: 5px auto; /* introducing redundancy */
}

.featured {
border: 1px solid #69c; /* introducing redundancy */
}
</code></pre>
</li>
</ul>
<h4 id="416-属性书写顺序">4.1.6 属性书写顺序</h4>
<p><strong>[建议] 同一 rule set 下的属性在书写时，应按功能进行分组，并以 <em>Formatting Model（布局方式、位置） > Box Model（尺寸） > Typographic（文本相关） > Visual（视觉效果）</em> 的顺序书写，以提高代码的可读性。</strong></p>
<ul>
<li>Formatting Model 相关属性包括：<code>position</code> / <code>top</code> / <code>right</code> / <code>bottom</code> / <code>left</code> / <code>float</code> / <code>display</code> / <code>overflow</code> 等</li>
<li>Box Model 相关属性包括：<code>border</code> / <code>margin</code> / <code>padding</code> / <code>width</code> / <code>height</code> 等</li>
<li>Typographic 相关属性包括：<code>font</code> / <code>line-height</code> / <code>text-align</code> / <code>word-wrap</code> 等</li>
<li>Visual 相关属性包括：<code>background</code> / <code>color</code> / <code>transition</code> / <code>list-style</code> 等</li>
</ul>
<pre><code class="language-css">.sidebar {
/* formatting model: positioning schemes / offsets / z-indexes / display / ...*/
position: absolute;
top: 50px;
left: 0;
overflow-x: hidden;

/* box model: sizes / margins / paddings / borders / ...*/
width: 200px;
padding: 5px;
border: 1px solid #ddd;

/* typographic: font / aligns / text styles / ... */
font-size: 14px;
line-height: 20px;

/* visual: colors / shadows / gradients / ... */
background: #f5f5f5;
color: #333;
-webkit-transition: color 1s;
   -moz-transition: color 1s;
         transition: color 1s;
}
</code></pre>
<h4 id="417-引号使用">4.1.7 引号使用</h4>
<p><code>url()</code> 、属性选择符、属性值使用双引号。</p>
<pre><code class="language-css">/* 不推荐 */
@import url(//www.google.com/css/maia.css);

html {
font-family: 'open sans', arial, sans-serif;
}

/* 推荐 */
@import url("//www.google.com/css/maia.css");

html {
font-family: "open sans", arial, sans-serif;
}

.selector {

}
</code></pre>
<h4 id="418-文本编排">4.1.8 文本编排</h4>
<h5 id="4181-字体族">4.1.8.1 字体族</h5>
<ul>
<li>
<p><strong>[强制] <code>font-family</code> 属性中的字体族名称应使用字体的英文 <code>Family Name</code>，其中如有空格，须放置在引号中。</strong></p>
<table>
<thead>
<tr>
<th>字体</th>
<th>操作系统</th>
<th>Family Name</th>
</tr>
</thead>
<tbody>
<tr>
<td>宋体 (中易宋体)</td>
<td>Windows</td>
<td>SimSun</td>
</tr>
<tr>
<td>黑体 (中易黑体)</td>
<td>Windows</td>
<td>SimHei</td>
</tr>
<tr>
<td>微软雅黑</td>
<td>Windows</td>
<td>Microsoft YaHei</td>
</tr>
<tr>
<td>微软正黑</td>
<td>Windows</td>
<td>Microsoft JhengHei</td>
</tr>
<tr>
<td>华文黑体</td>
<td>Mac/iOS</td>
<td>STHeiti</td>
</tr>
</tbody>
</table>
<pre><code class="language-css">h1 {
font-family: "Microsoft YaHei";
}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>font-family</code> 按「西文字体在前、中文字体在后」、「效果佳 (质量高/更能满足需求) 的字体在前、效果一般的字体在后」的顺序编写，最后必须指定一个通用字体族( <code>serif</code> / <code>sans-serif</code> )。</strong></p>
<pre><code class="language-css">/* Display according to platform */
.article {
font-family: Arial, sans-serif;
}

/* Specific for most platforms */
h1 {
font-family: "Helvetica Neue", Arial, "Hiragino Sans GB", "WenQuanYi Micro Hei", "Microsoft YaHei", sans-serif;
}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>font-family</code> 不区分大小写，但在同一个项目中，同样的 <code>Family Name</code> 大小写必须统一。</strong></p>
<pre><code class="language-css">/* good */
body {
font-family: Arial, sans-serif;
}

h1 {
font-family: Arial, "Microsoft YaHei", sans-serif;
}

/* bad */
body {
font-family: arial, sans-serif;
}

h1 {
font-family: Arial, "Microsoft YaHei", sans-serif;
}
</code></pre>
</li>
</ul>
<h5 id="4182-字号">4.1.8.2 字号</h5>
<p><strong>[强制] 需要在 Windows 平台显示的中文内容，其字号应不小于 <code>12px</code>。</strong></p>
<p>由于 Windows 的字体渲染机制，小于 <code>12px</code> 的文字显示效果极差、难以辨认。</p>
<h4 id="419-媒体查询media-query的位置">4.1.9 媒体查询（Media query）的位置</h4>
<ul>
<li>
<p>**将媒体查询放在尽可能相关规则的附近。不要将他们打包放在一个单一样式文件中或者放在文档底部。如果你把他们分开了，将来只会被大家遗忘。**</p>
<pre><code class="language-css">.element { ... }
.element-avatar { ... }
.element-selected { ... }

@media (max-width: 768px) {
.element { ...}
.element-avatar { ... }
.element-selected { ... }
}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>Media Query</code> 如果有多个逗号分隔的条件时，应将每个条件放在单独一行中。</strong></p>
<pre><code class="language-css">@media
(-webkit-min-device-pixel-ratio: 2), /* Webkit-based browsers */
(min--moz-device-pixel-ratio: 2), /* Older Firefox browsers (prior to Firefox 16) */
(min-resolution: 2dppx),          /* The standard way */
(min-resolution: 192dpi) {       /* dppx fallback */
/* Retina-specific stuff here */
}
</code></pre>
</li>
</ul>
<h4 id="4110-不要使用import">4.1.10 不要使用<code>@import</code></h4>
<p>与 <code><link></code> 相比，<code>@import</code> 要慢很多，不光增加额外的请求数，还会导致不可预料的问题。</p>
<p>替代办法：</p>
<ul>
<li>使用多个元素；</li>
<li>通过 Sass 或 Less 类似的 CSS 预处理器将多个 CSS 文件编译为一个文件；</li>
<li>其他 CSS 文件合并工具；</li>
</ul>
<p>参考: 不要使用@import</p>
<h4 id="4111-链接的样式顺序">4.1.11 链接的样式顺序</h4>
<p><code>a:link -> a:visited -> a:hover -> a:active（LVHA）</code></p>
<h4 id="4112-important">4.1.12 !important</h4>
<ul>
<li>
<p><strong>[建议] 尽量不使用 <code>!important</code> 声明。</strong></p>
</li>
<li>
<p><strong>[建议] 当需要强制指定样式且不允许任何场景覆盖时，通过标签内联和 <code>!important</code> 定义样式。</strong></p>
<p>必须注意的是，仅在设计上 <code>确实不允许任何其它场景覆盖样式</code> 时，才使用内联的 <code>!important</code> 样式。通常在第三方环境的应用中使用这种方案。</p>
</li>
</ul>
<h4 id="4113-无需添加浏览器厂商前缀">4.1.13 无需添加浏览器厂商前缀</h4>
<p>使用 Autoprefixer 自动添加浏览器厂商前缀，编写 CSS 时不需要添加浏览器前缀，直接使用标准的 CSS 编写。</p>
<p>Autoprefixer 通过 Can I use，按兼容的要求，对相应的 CSS 代码添加浏览器厂商前缀。</p>
<h3 id="42-bem命名规范">4.2 BEM命名规范</h3>
<p>CSS 的命名规范又叫做BEM规范，为的是结束混乱的命名方式，达到一个语义化的CSS命名方式。</p>
<p>BEM是三个单词的缩写：Block（块）代表更高级别的抽象或组件，Element（元素） Block的后代，以及Modifier（修饰）不同状态的修饰符。</p>
<h4 id="421-命名方法">4.2.1 命名方法</h4>
<pre><code class="language-css">.block__element--modifier {
display: flex;
}
.block--modifier {
display: flex;
}
.block__element {
display: flex;
}

<p class="header">
<p class="header__body">
   <button class="header__button--primary"></button>
   <button class="header__button--default"></button>
</p>
</p>
</code></pre>
<h4 id="422-block">4.2.2 Block</h4>
<p>block 代表一个更高级别的抽象或者是一个组件，它仅仅作为一个边界。它主要的功能有下面三点：</p>
<ul>
<li>负责描述功能的，不应该包含状态。</li>
</ul>
<pre><code class="language-css">/* good */
.header {

}

/* bad */
.header--select {

}
</code></pre>
<ul>
<li>不影响自身布局，不包含具体的样式，也就是block里面不应该加样式</li>
</ul>
<pre><code class="language-css">/* good */
.header {

}

/* bad */
.header {
margin-top: 50px;
}
</code></pre>
<ul>
<li>不能使用元素选择器和ID选择器</li>
</ul>
<pre><code class="language-css">/* good */
.header {

}

/* bad */
.header a {
margin-top: 50px;
}
</code></pre>
<h4 id="423-element">4.2.3 Element</h4>
<ul>
<li>是用一个双下划线隔开</li>
</ul>
<pre><code class="language-css">/* good */
.header__body {
margin-top: 50px;
}

/* bad */
.header .body {
margin-top: 50px;
}
</code></pre>
<ul>
<li>表示的是目的，而不是状态，如下例子：目的是在header下面定义三个区域 body、logo、title，但是并没有指定任何状态。</li>
</ul>
<pre><code class="language-css">.header__body {
margin-top: 50px;
}

.header__logo {
margin-top: 50px;
}

.header__title {
margin-top: 50px;
}
</code></pre>
<ul>
<li>不能脱离Block父级单独使用</li>
</ul>
<pre><code class="language-css">/* good */
<p class="header">
<p class="header__body">
   <button class="header__button--primary"></button>
   <button class="header__button--default"></button>
</p>
</p>

/* bad */
<p>
<p class="header__body">
   <button class="header__button--primary"></button>
   <button class="header__button--default"></button>
</p>
</p>
</code></pre>
<h4 id="424-modifier">4.2.4 <strong>Modifier</strong></h4>
<ul>
<li>表示的是一个状态，是用双横杠分开的。</li>
</ul>
<pre><code class="language-css">.header__button--default {
background: none;
}
</code></pre>
<ul>
<li>Boolean</li>
</ul>
<pre><code class="language-css">.header__button--select {
background: none;
}
</code></pre>
<ul>
<li>枚举</li>
</ul>
<pre><code class="language-css">.header__button--primary {
background: #329FD9;
}
</code></pre>
<ul>
<li>不能单独使用</li>
</ul>
<pre><code class="language-css">/* correct */
<p class="header">
<p class="header__body">
   <button class="header__button--primary"></button>
   <button class="header__button--default"></button>
</p>
</p>

/* wrong */
<p>
<p>
   <button class="header__button--primary"></button>
   <button class="header__button--default"></button>
</p>
</p>
</code></pre>
<h3 id="43-less-规范">4.3 Less 规范</h3>
<h4 id="431-代码组织">4.3.1 代码组织</h4>
<p>代码按以下顺序组织：</p>
<ol>
<li><code>@import</code></li>
<li>变量声明</li>
<li>样式声明</li>
</ol>
<pre><code class="language-css">@import "mixins/size.less";

@default-text-color: #333;

.page {
width: 960px;
margin: 0 auto;
}
</code></pre>
<h4 id="432-import-语句">4.3.2 <code>@import</code> 语句</h4>
<p><code>@import</code> 语句引用的文需要写在一对引号内，<code>.less</code> 后缀不得省略。引号使用 <code>'</code> 和 <code>"</code> 均可，但在同一项目内需统一。</p>
<pre><code class="language-css">/* 不推荐 */
@import "mixins/size";
@import 'mixins/grid.less';

/* 推荐 */
@import "mixins/size.less";
@import "mixins/grid.less";
</code></pre>
<h4 id="433-混入mixin">4.3.3 混入（Mixin）</h4>
<ol>
<li>在定义 <code>mixin</code> 时，如果 <code>mixin</code> 名称不是一个需要使用的 className，必须加上括号，否则即使不被调用也会输出到 CSS 中。</li>
<li>如果混入的是本身不输出内容的 mixin，需要在 mixin 后添加括号（即使不传参数），以区分这是否是一个 className。</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
.big-text {
font-size: 2em;
}

h3 {
.big-text;
.clearfix;
}

/* 推荐 */
.big-text() {
font-size: 2em;
}

h3 {
.big-text(); /* 1 */
.clearfix(); /* 2 */
}
</code></pre>
<h4 id="434-避免嵌套层级过多">4.3.4 避免嵌套层级过多</h4>
<ul>
<li>将嵌套深度限制在3级。对于超过3级的嵌套，给予重新评估。这可以避免出现过于详实的CSS选择器。</li>
<li>避免大量的嵌套规则。当可读性受到影响时，将之打断。推荐避免出现多于20行的嵌套规则出现。</li>
</ul>
<h4 id="435-字符串插值">4.3.5 字符串插值</h4>
<p>变量可以用类似ruby和php的方式嵌入到字符串中，像@{name}这样的结构: <code>@base-url: "http://assets.fnord.com";</code> <code>background-image: url("@{base-url}/images/bg.png");</code></p>
<h3 id="44-性能优化">4.4 性能优化</h3>
<h4 id="441-慎重选择高消费的样式">4.4.1 慎重选择高消费的样式</h4>
<p>高消耗属性在绘制前需要浏览器进行大量计算：</p>
<ul>
<li>box-shadows</li>
<li>border-radius</li>
<li>transparency</li>
<li>transforms</li>
<li>CSS filters（性能杀手）</li>
</ul>
<h4 id="442-避免过分重排">4.4.2 避免过分重排</h4>
<p>当发生重排的时候，浏览器需要重新计算布局位置与大小，更多详情。</p>
<p>常见的重排元素:</p>
<ul>
<li>width</li>
<li>height</li>
<li>padding</li>
<li>margin</li>
<li>display</li>
<li>border-width</li>
<li>position</li>
<li>top</li>
<li>left</li>
<li>right</li>
<li>bottom</li>
<li>font-size</li>
<li>float</li>
<li>text-align</li>
<li>overflow-y</li>
<li>font-weight</li>
<li>overflow</li>
<li>font-family</li>
<li>line-height</li>
<li>vertical-align</li>
<li>clear</li>
<li>white-space</li>
<li>min-height</li>
</ul>
<h4 id="443-正确使用display的属性">4.4.3 正确使用Display的属性</h4>
<p>Display 属性会影响页面的渲染，请合理使用。</p>
<ul>
<li>display: inline后不应该再使用 width、height、margin、padding 以及 float；</li>
<li>display: inline-block 后不应该再使用 float；</li>
<li>display: block 后不应该再使用 vertical-align；</li>
<li>display: table-* 后不应该再使用 margin 或者 float；</li>
</ul>
<h4 id="444-不滥用-float">4.4.4 不滥用 Float</h4>
<p>Float在渲染时计算量比较大，尽量减少使用。</p>
<h4 id="445-动画性能优化">4.4.5 动画性能优化</h4>
<p>动画的实现原理，是利用了人眼的“视觉暂留”现象，在短时间内连续播放数幅静止的画面，使肉眼因视觉残象产生错觉，而误以为画面在“动”。</p>
<p>动画的基本概念：</p>
<ul>
<li>帧：在动画过程中，每一幅静止画面即为一“帧”;</li>
<li>帧率：即每秒钟播放的静止画面的数量，单位是fps(Frame per second);</li>
<li>帧时长：即每一幅静止画面的停留时间，单位一般是ms(毫秒);</li>
<li>跳帧(掉帧/丢帧)：在帧率固定的动画中，某一帧的时长远高于平均帧时长，导致其后续数帧被挤压而丢失的现象。</li>
</ul>
<p>一般浏览器的渲染刷新频率是 60 fps，所以在网页当中，帧率如果达到 50-60 fps 的动画将会相当流畅，让人感到舒适。</p>
<ul>
<li>如果使用基于 javaScript 的动画，尽量使用 requestAnimationFrame. 避免使用 setTimeout, setInterval.</li>
<li>避免通过类似 jQuery animate()-style 改变每帧的样式，使用 CSS 声明动画会得到更好的浏览器优化。</li>
<li>使用 translate 取代 absolute 定位就会得到更好的 fps，动画会更顺滑。</li>
</ul>
<h4 id="446-多利用硬件能力如通过3d变形开启gpu加速">4.4.6 多利用硬件能力，如通过3D变形开启GPU加速</h4>
<p>一般在 Chrome 中，3D或透视变换（perspective transform）CSS属性和对 opacity 进行 CSS 动画会创建新的图层，在硬件加速渲染通道的优化下，GPU 完成 3D 变形等操作后，将图层进行复合操作（Compesite Layers），从而避免触发浏览器大面积重绘和重排。</p>
<p>注：3D 变形会消耗更多的内存和功耗。</p>
<p>使用 translate3d 右移 500px 的动画流畅度要明显优于直接使用 left：</p>
<pre><code class="language-css">.ball-1 {
transition: -webkit-transform .5s ease;
-webkit-transform: translate3d(0, 0, 0);
}
.ball-1.slidein{
-webkit-transform: translate3d(500px, 0, 0);
}
.ball-2 {
transition: left .5s ease; left：0;
}
.ball-2.slidein {
left：500px;
}
</code></pre>
<h4 id="447-提升-css-选择器性能">4.4.7 提升 CSS 选择器性能</h4>
<p>CSS 选择器对性能的影响源于浏览器匹配选择器和文档元素时所消耗的时间，所以优化选择器的原则是应尽量避免使用消耗更多匹配时间的选择器。而在这之前我们需要了解 CSS 选择器匹配的机制，如子选择器规则：</p>
<pre><code>#header > a {font-weight:blod;}
</code></pre>
<p>我们中的大多数人都是从左到右的阅读习惯，会习惯性的设定浏览器也是从左到右的方式进行匹配规则，推测这条规则的开销并不高。</p>
<p>我们会假设浏览器以这样的方式工作：寻找 id 为 header 的元素，然后将样式规则应用到直系子元素中的 a 元素上。我们知道文档中只有一个 id 为 header 的元素，并且它只有几个 a 元素的子节点，所以这个 CSS 选择器应该相当高效。</p>
<p>事实上，却恰恰相反，<strong>CSS 选择器是从右到左进行规则匹配</strong>。了解这个机制后，例子中看似高效的选择器在实际中的匹配开销是很高的，浏览器必须遍历页面中所有的 a 元素并且确定其父元素的 id 是否为 header 。</p>
<p>如果把例子的子选择器改为后代选择器则会开销更多，在遍历页面中所有 a 元素后还需向其上级遍历直到根节点。</p>
<pre><code>#headera {font-weight:blod;}
</code></pre>
<p>理解了CSS选择器从右到左匹配的机制后，明白只要当前选择符的左边还有其他选择符，样式系统就会继续向左移动，直到找到和规则匹配的选择符，或者因为不匹配而退出。我们把<strong>最右边选择符</strong>称之为<strong>关键选择器</strong>。——更多详情</p>
<ol>
<li>避免使用通用选择器</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
.content * {color: red;}
</code></pre>
<p>浏览器匹配文档中所有的元素后分别向上逐级匹配 class 为 content 的元素，直到文档的根节点。因此其匹配开销是非常大的，所以应避免使用关键选择器是通配选择器的情况。</p>
<ol start="2">
<li>避免使用标签或 class 选择器限制 id 选择器</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
button#backButton {…}
/* 推荐 */
#newMenuIcon {…}
</code></pre>
<ol start="3">
<li>避免使用标签限制 class 选择器</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
treecell.indented {…}
/* 推荐 */
.treecell-indented {…}
/* 更推荐 */
.hierarchy-deep {…}
</code></pre>
<ol start="4">
<li>避免使用多层标签选择器。使用 class 选择器替换，减少css查找</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
treeitem > treerow > treecell {…}
/* 推荐 */
.treecell-mailfolder {…}
</code></pre>
<ol start="5">
<li>避免使用子选择器</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
treehead treerow treecell {…}
/* 推荐 */
treehead > treerow > treecell {…}
/* 更推荐 */
.treecell-header {…}
</code></pre>
<ol start="6">
<li>使用继承</li>
</ol>
<pre><code class="language-css">/* 不推荐 */
#bookmarkMenuItem > .menu-left { list-style-image: url(blah) }
/* 推荐 */
#bookmarkMenuItem { list-style-image: url(blah)
</code></pre>
<h2 id="5-javascript-规范">5. JavaScript 规范</h2>
<h3 id="51-通用约定">5.1 通用约定</h3>
<h4 id="511-缩进">5.1.1 缩进</h4>
<ul>
<li>
<p><strong>[强制]使用<code>Tab</code>键来缩进，需在编辑器设置一个缩进为<code>2</code>个字符。</strong></p>
</li>
<li>
<h5 id="建议-使用多行模板字符串时遵循缩进原则当空行与空白字符敏感时不使用多行模板字符串">[建议] 使用多行模板字符串时遵循缩进原则。当空行与空白字符敏感时，不使用多行模板字符串。</h5>
<p><code>2</code> 空格为一个缩进，换行后添加一层缩进。将起始和结束的`` `符号单独放一行，有助于生成 HTML 时的标签对齐。</p>
<p>为避免破坏缩进的统一，当空行与空白字符敏感时，建议使用 <code>多个模板字符串</code> 或 <code>普通字符串</code> 进行连接运算，也可使用数组 <code>join</code> 生成字符串。</p>
<pre><code class="language-js">// good
function foo() {
let html = `
<div>
   <p></p>
   <p></p>
</div>
`;
}

// Good
function greeting(name) {
return 'Hello, \n'
+ `${name.firstName} ${name.lastName}`;
}

// Bad
function greeting(name) {
return `Hello,
${name.firstName} ${name.lastName}`;
}
</code></pre>
</li>
</ul>
<h4 id="512-空格">5.1.2 空格</h4>
<ul>
<li>
<p><strong>二元运算符两侧必须有一个空格，一元运算符与操作对象之间不允许有空格。</strong></p>
<pre><code class="language-js">let a = !arr.length;
a++;
a = b + c;
</code></pre>
</li>
<li>
<p><strong>用作代码块起始的左花括号 <code>{</code> 前必须有一个空格。</strong></p>
<pre><code class="language-js">// good
if (condition) {
}

while (condition) {
}

function funcName() {
}

// bad
if (condition){
}

while (condition){
}

function funcName(){
}
</code></pre>
</li>
<li>
<p><strong><code>if / else / for / while / function / switch / do / try / catch / finally</code> 关键字后，必须有一个空格。</strong></p>
<pre><code class="language-js">// good
if (condition) {
}

while (condition) {
}

(function () {
})();

// bad
if(condition) {
}

while(condition) {
}

(function() {
})();
</code></pre>
</li>
<li>
<p><strong>在对象创建时，属性中的 <code>:</code> 之后必须有空格，<code>:</code> 之前不允许有空格。</strong></p>
<pre><code class="language-js">// good
let obj = {
a: 1,
b: 2,
c: 3
};

// bad
let obj = {
a : 1,
b:2,
c :3
};
</code></pre>
</li>
<li>
<p><strong>函数声明、具名函数表达式、函数调用中，函数名和 <code>(</code> 之间不允许有空格。</strong></p>
<pre><code class="language-js">// good
function funcName() {
}

let funcName = function funcName() {
};

funcName();

// bad
function funcName () {
}

let funcName = function funcName () {
};

funcName ();
</code></pre>
</li>
<li>
<p><strong><code>,</code> 和 <code>;</code> 前不允许有空格。如果不位于行尾，<code>,</code> 和 <code>;</code> 后必须跟一个空格。</strong></p>
<pre><code class="language-js">// good
callFunc(a, b);

// bad
callFunc(a , b) ;
</code></pre>
</li>
<li>
<p><strong>在函数调用、函数声明、括号表达式、属性访问、<code>if / for / while / switch / catch</code> 等语句中，<code>()</code> 和 <code>[]</code> 内紧贴括号部分不允许有空格。</strong></p>
<pre><code class="language-js">// good
callFunc(param1, param2, param3);

save(this.list]);

needIncream && (variable += increament);

if (num > list.length) {
}

while (len--) {
}

// bad
callFunc( param1, param2, param3 );

save( this.list[ this.indexes[ i ] ] );

needIncreament && ( variable += increament );

if ( num > list.length ) {
}

while ( len-- ) {
}
</code></pre>
</li>
<li>
<p><strong>单行声明的数组与对象，如果包含元素，<code>{}</code> 和 <code>[]</code> 内紧贴括号部分不允许包含空格。</strong></p>
<blockquote>
<p>声明包含元素的数组与对象，只有当内部元素的形式较为简单时，才允许写在一行。元素复杂的情况，还是应该换行书写。</p>
</blockquote>
<pre><code class="language-js">// good
let arr1 = [];
let arr2 = ;
let obj1 = {};
let obj2 = {name: 'obj'};
let obj3 = {
name: 'obj',
age: 20,
sex: 1
};

// bad
let arr1 = [ ];
let arr2 = [ 1, 2, 3 ];
let obj1 = { };
let obj2 = { name: 'obj' };
let obj3 = {name: 'obj', age: 20, sex: 1};
</code></pre>
</li>
<li>
<p><strong>行尾不得有多余的空格。</strong></p>
</li>
<li>
<p><strong>[强制] 使用 <code>generator</code> 时，<code>*</code> 前面不允许有空格，<code>*</code> 后面必须有一个空格。</strong></p>
<pre><code class="language-js">// good
function* caller() {
yield 'a';
yield* callee();
yield 'd';
}

// bad
function * caller() {
yield 'a';
yield *callee();
yield 'd';
}
</code></pre>
</li>
</ul>
<h4 id="513-换行">5.1.3 换行</h4>
<ul>
<li>
<p><strong>[强制] 每个独立语句结束后必须换行。</strong></p>
</li>
<li>
<p><strong>[强制] 每行不得超过 <code>120</code> 个字符。</strong></p>
<blockquote>
<p>超长的不可分割的代码允许例外，比如复杂的正则表达式。长字符串不在例外之列。</p>
</blockquote>
</li>
<li>
<p><strong>[强制] 运算符处换行时，运算符必须在新行的行首。</strong></p>
<pre><code class="language-js">// good
if (user.isAuthenticated()
&& user.isInRole('admin')
&& user.hasAuthority('add-admin')
|| user.hasAuthority('delete-admin')
) {
// Code
}

let result = number1 + number2 + number3
+ number4 + number5;

// bad
if (user.isAuthenticated() &&
user.isInRole('admin') &&
user.hasAuthority('add-admin') ||
user.hasAuthority('delete-admin')) {
// Code
}

let result = number1 + number2 + number3 +
number4 + number5;
</code></pre>
</li>
<li>
<p><strong>[强制] 在函数声明、函数表达式、函数调用、对象创建、数组创建、<code>for</code> 语句等场景中，不允许在 <code>,</code> 或 <code>;</code> 前换行。</strong></p>
<pre><code class="language-js">// good
let obj = {
a: 1,
b: 2,
c: 3
};

foo(
aVeryVeryLongArgument,
anotherVeryLongArgument,
callback
);

// bad
let obj = {
a: 1
, b: 2
, c: 3
};

foo(
aVeryVeryLongArgument
, anotherVeryLongArgument
, callback
);
</code></pre>
</li>
<li>
<p><strong>[建议] 不同行为或逻辑的语句集，使用空行隔开，更易阅读。</strong></p>
<pre><code class="language-js">// 仅为按逻辑换行的示例，不代表setStyle的最优实现
function setStyle(element, property, value) {
if (element == null) {
return;
}

element.style = value;
}
</code></pre>
</li>
<li>
<p><strong>[建议] 在语句的行长度超过 <code>120</code> 时，根据逻辑条件合理换行缩进。</strong></p>
<pre><code class="language-js">// 较复杂的逻辑条件组合，将每个条件独立一行，逻辑运算符放置在行首进行分隔，或将部分逻辑按逻辑组合进行分隔。
// 建议最终将右括号 ) 与左大括号 { 放在独立一行，保证与 `if` 内语句块能容易视觉辨识。
if (user.isAuthenticated()
&& user.isInRole('admin')
&& user.hasAuthority('add-admin')
|| user.hasAuthority('delete-admin')
) {
// Code
}

// 按一定长度截断字符串，并使用 + 运算符进行连接。
// 分隔字符串尽量按语义进行，如不要在一个完整的名词中间断开。
// 特别的，对于 HTML 片段的拼接，通过缩进，保持和 HTML 相同的结构。
let html = '' // 此处用一个空字符串，以便整个 HTML 片段都在新行严格对齐
+ '<article>'
+ '<h1>Title here</h1>'
+ '<p>This is a paragraph</p>'
+ '<footer>Complete</footer>'
+ '</article>';

// 也可使用数组来进行拼接，相对 `+` 更容易调整缩进。
let html = [
'<article>',
'<h1>Title here</h1>',
'<p>This is a paragraph</p>',
'<footer>Complete</footer>',
'</article>'
];
html = html.join('');

// 当参数过多时，将每个参数独立写在一行上，并将结束的右括号 ) 独立一行。
// 所有参数必须增加一个缩进。
foo(
aVeryVeryLongArgument,
anotherVeryLongArgument,
callback
);

// 也可以按逻辑对参数进行组合。
// 如 format 函数，调用时将参数分为“模板”和“数据”两块
format(
dateFormatTemplate,
year, month, date, hour, minute, second
);

// 当函数调用时，如果有一个或以上参数跨越多行，应当每一个参数独立一行。
// 这通常出现在匿名函数或者对象初始化等作为参数时，如 `setTimeout` 函数等。
setTimeout(
function () {
alert('hello');
},
200
);

order.data.read(
'id=' + me.model.id,
function (data) {
me.attchToModel(data.result);
callback();
},
300
);

// 链式调用较长时采用缩进进行调整。
$('#items')
.find('.selected')
.highlight()
.end();

// 三元运算符由3部分组成，因此其换行应当根据每个部分的长度不同，形成不同的情况。
let result = thisIsAVeryVeryLongCondition
? resultA : resultB;

let result = condition
? thisIsAVeryVeryLongResult
: resultB;

// 数组和对象初始化的混用，严格按照每个对象的 `{` 和结束 `}` 在独立一行的风格书写。
let array = [
{
// ...
},
{
// ...
}
];
</code></pre>
</li>
<li>
<p><strong>[建议] 对于 <code>if...else...</code>、<code>try...catch...finally</code> 等语句，推荐使用在 <code>}</code> 号后添加一个换行的风格，使代码层次结构更清晰，阅读性更好。</strong></p>
<pre><code class="language-js">if (condition) {
// some statements;
}
else {
// some statements;
}

try {
// some statements;
}
catch (ex) {
// some statements;
}
</code></pre>
</li>
</ul>
<h4 id="514-语句">5.1.4 语句</h4>
<ul>
<li>
<p><strong>[强制] 不得省略语句结束的分号。</strong></p>
</li>
<li>
<p><strong>[强制] 在 <code>if / else / for / do / while</code> 语句中，即使只有一行，也不得省略块 <code>{...}</code>。</strong></p>
<pre><code class="language-js">// good
if (condition) {
callFunc();
}

// bad
if (condition) callFunc();
if (condition)
callFunc();
</code></pre>
</li>
<li>
<p><strong>[强制] 函数定义结束不允许添加分号。</strong></p>
<pre><code class="language-js">// good
function funcName() {
}

// bad
function funcName() {
};

// 如果是函数表达式，分号是不允许省略的。
let funcName = function () {
};
</code></pre>
</li>
<li>
<p><strong>[强制] <code>IIFE</code>(Immediately-Invoked Function Expression, 立即执行函数) 必须在函数表达式外添加 <code>(</code>，非 <code>IIFE</code> 不得在函数表达式外添加 <code>(</code>。</strong></p>
<blockquote>
<p>额外的 <code> (</code>能够让代码在阅读的一开始就能判断函数是否立即被调用，进而明白接下来代码的用途。而不是一直拖到底部才恍然大悟。</p>
</blockquote>
<pre><code class="language-js">// good
let task = (function () {
// Code
return result;
})();

let func = function () {
};

// bad
let task = function () {
// Code
return result;
}();

let func = (function () {
});
</code></pre>
</li>
<li>
<p><strong>[强制] 类声明结束不允许添加分号。</strong></p>
</li>
<li>
<p><strong>[强制] 类成员定义中，方法定义后不允许添加分号，成员属性定义后必须添加分号。</strong></p>
</li>
<li>
<pre><code class="language-js">// good
class Foo {
foo = 3;

bar() {

}
}

// bad
class Foo {
foo = 3

bar() {

}
}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>export</code> 语句后，不允许出现表示空语句的分号。</strong></p>
<pre><code class="language-js">// good
export function foo() {
}

export default function bar() {
}

// bad
export function foo() {
};

export default function bar() {
};
</code></pre>
</li>
<li>
<p><strong>[强制] 属性装饰器后，可以不加分号的场景，不允许加分号。</strong></p>
<p>只有一种场景是必须加分号的：当属性 <code>key</code> 是 <code>computed property key</code> 时，其装饰器必须加分号，否则修饰 <code>key</code> 的 <code>[]</code> 会做为之前表达式的 <code>property accessor</code>。</p>
<p>上面描述的场景，装饰器后需要加分号。其余场景下的属性装饰器后不允许加分号。</p>
<pre><code class="language-js">// good
class Foo {
@log('INFO')
bar() {

}

@log('INFO');
['bar' + 2]() {

}
}

// bad
class Foo {
@log('INFO');
bar() {

}

@log('INFO')
['bar' + 2]() {

}
}
</code></pre>
</li>
<li>
<p><strong>[强制] 箭头函数的参数只有一个，并且不包含解构时，参数部分的括号必须省略。</strong></p>
<pre><code class="language-js">// good
list.map(item => item * 2);

// good
let fetchName = async id => {
let user = await request(`users/${id}`);
return user.fullName;
};

// bad
list.map((item) => item * 2);

// bad
let fetchName = async (id) => {
let user = await request(`users/${id}`);
return user.fullName;
};
</code></pre>
</li>
<li>
<h5 id="建议-箭头函数的函数体只有一个单行表达式语句且作为返回值时省略--和-return">[建议] 箭头函数的函数体只有一个单行表达式语句，且作为返回值时，省略 <code>{}</code> 和 <code>return</code>。</h5>
<p>如果单个表达式过长，可以使用 <code>()</code> 进行包裹。</p>
<pre><code class="language-js">// good
list.map(item => item * 2);

let foo = () => (
condition
   ? returnValueA()
   : returnValueB()
);

// bad
list.map(item => {
return item * 2;
});
</code></pre>
</li>
<li>
<h5 id="建议-箭头函数的函数体只有一个-object-literal-对象字面量且作为返回值时使用--包裹">[建议] 箭头函数的函数体只有一个 <code>Object Literal (对象字面量)</code>，且作为返回值时，使用 <code>()</code> 包裹。</h5>
<pre><code class="language-js">// good
list.map(item => ({name: item, email: item}));
</code></pre>
</li>
<li>
<h5 id="强制-解构多个变量时如果超过行长度限制每个解构的变量必须单独一行">[强制] 解构多个变量时，如果超过行长度限制，每个解构的变量必须单独一行。</h5>
<p>太多的变量解构会让一行的代码非常长，极有可能超过单行长度控制，使代码可读性下降。</p>
<pre><code class="language-js">// good
let {
name: personName,
email: personEmail,
sex: personSex,
age: personAge
} = person;

// bad
let {name: personName, email: personEmail,
sex: personSex, age: personAge
} = person;
</code></pre>
</li>
</ul>
<h4 id="515-注释">5.1.5 注释</h4>
<h5 id="5151-原则">5.1.5.1 原则</h5>
<ul>
<li>As short as possible（如无必要，勿增注释）：尽量提高代码本身的清晰性、可读性。</li>
<li>As long as necessary（如有必要，尽量详尽）：合理的注释、空行排版等，可以让代码更易阅读、更具美感。</li>
</ul>
<h5 id="5152-单行注释">5.1.5.2 单行注释</h5>
<p>[强制]必须独占一行。<code>//</code> 后跟一个空格，缩进与下一行被注释说明的代码一致。</p>
<h5 id="5153-多行注释">5.1.5.3 多行注释</h5>
<p>[建议]避免使用 <code>/*...*/</code> 这样的多行注释。有多行注释内容时，使用多个单行注释。</p>
<h5 id="5154-类型定义">5.1.5.4 类型定义</h5>
<ul>
<li>
<p><strong>[强制] 类型定义都是以 <code>{</code> 开始，以 <code>}</code> 结束。</strong></p>
<blockquote>
<p>常用类型如：{string}, {number}, {boolean}, {Object}, {Function}, {RegExp}, {Array}, {Date}。</p>
<p>类型不仅局限于内置的类型，也可以是自定义的类型。比如定义了一个类 Developer，就可以使用它来定义一个参数和返回值的类型。</p>
</blockquote>
</li>
<li>
<p><strong>[强制] 对于基本类型 {string}, {number}, {boolean}，首字母必须小写。</strong></p>
<table>
<thead>
<tr>
<th>类型定义</th>
<th>语法示例</th>
<th>解释</th>
</tr>
</thead>
<tbody>
<tr>
<td>String</td>
<td></td>
<td>字符串</td>
</tr>
<tr>
<td>Number</td>
<td></td>
<td>数字</td>
</tr>
<tr>
<td>Boolean</td>
<td></td>
<td>布尔值</td>
</tr>
<tr>
<td>Object</td>
<td></td>
<td>对象</td>
</tr>
<tr>
<td>Function</td>
<td></td>
<td>函数/方法</td>
</tr>
<tr>
<td>RegExp</td>
<td></td>
<td>正则表达式</td>
</tr>
<tr>
<td>Array</td>
<td></td>
<td>数组</td>
</tr>
<tr>
<td>Date</td>
<td></td>
<td>日期</td>
</tr>
<tr>
<td>单一类型集合</td>
<td></td>
<td>string 类型的数组</td>
</tr>
<tr>
<td>多类型</td>
<td></td>
<td>可能是 number 类型, 也可能是 boolean 类型</td>
</tr>
<tr>
<td>允许为null</td>
<td></td>
<td>可能是 number, 也可能是 null</td>
</tr>
<tr>
<td>不允许为null</td>
<td></td>
<td>Object 类型, 但不是 null</td>
</tr>
<tr>
<td>Function类型</td>
<td></td>
<td>函数, 形参类型</td>
</tr>
<tr>
<td>Function带返回值</td>
<td></td>
<td>函数, 形参, 返回值类型</td>
</tr>
<tr>
<td>Promise</td>
<td>Promise.<resolveType, rejectType></td>
<td>Promise，成功返回的数据类型，失败返回的错误类型</td>
</tr>
<tr>
<td>参数可选</td>
<td>@param {string=} name</td>
<td>可选参数, =为类型后缀</td>
</tr>
<tr>
<td>可变参数</td>
<td>@param {...number} args</td>
<td>变长参数,...为类型前缀</td>
</tr>
<tr>
<td>任意类型</td>
<td></td>
<td>任意类型</td>
</tr>
<tr>
<td>可选任意类型</td>
<td>@param {*=} name</td>
<td>可选参数，类型不限</td>
</tr>
<tr>
<td>可变任意类型</td>
<td>@param {...*} args</td>
<td>变长参数，类型不限</td>
</tr>
</tbody>
</table>
</li>
</ul>
<h5 id="5155-文件注释">5.1.5.5 文件注释</h5>
<ul>
<li>
<p><strong>[强制] 文件顶部必须包含文件注释，用 <code>@file</code> 标识文件说明。</strong></p>
</li>
<li>
<p><strong>[建议] 文件注释中可以用 <code>@author</code> 标识开发者信息。</strong></p>
<p>开发者信息能够体现开发人员对文件的贡献，并且能够让遇到问题或希望了解相关信息的人找到维护人。通常情况文件在被创建时标识的是创建者。随着项目的进展，越来越多的人加入，参与这个文件的开发，新的作者应该被加入 <code>@author</code> 标识。</p>
<p><code>@author</code> 标识具有多人时，原则是按照 <code>责任</code> 进行排序。通常的说就是如果有问题，就是找第一个人应该比找第二个人有效。比如文件的创建者由于各种原因，模块移交给了其他人或其他团队，后来因为新增需求，其他人在新增代码时，添加 <code>@author</code> 标识应该把自己的名字添加在创建人的前面。</p>
<p><code>@author</code> 中的名字不允许被删除。任何劳动成果都应该被尊重。</p>
<p>业务项目中，一个文件可能被多人频繁修改，并且每个人的维护时间都可能不会很长，不建议为文件增加 <code>@author</code> 标识。通过版本控制系统追踪变更，按业务逻辑单元确定模块的维护责任人，通过文档与wiki跟踪和查询，是更好的责任管理方式。</p>
<p>对于业务逻辑无关的技术型基础项目，特别是开源的公共项目，应使用 <code>@author</code> 标识。</p>
<pre><code class="language-js">/**
* @file Describe the file
* @author author-name(mail-name@domain.com)
*       author-name2(mail-name2@domain.com)
*/
</code></pre>
</li>
</ul>
<h5 id="5156-命名空间注释">5.1.5.6 命名空间注释</h5>
<p><strong>[建议] 命名空间使用 <code>@namespace</code> 标识。</strong></p>
<pre><code class="language-js">/**
* @namespace
*/
let util = {};
</code></pre>
<h5 id="5157-类注释">5.1.5.7 类注释</h5>
<ul>
<li>
<p><strong>[建议] 使用 <code>@class</code> 标记类或构造函数。</strong></p>
<p>对于使用对象 <code>constructor</code> 属性来定义的构造函数，可以使用 <code>@constructor</code> 来标记。</p>
<pre><code class="language-js">/**
* 描述
*
* @class
*/
function Developer() {
// constructor body
}
</code></pre>
</li>
<li>
<p><strong>[建议] 使用 <code>@extends</code> 标记类的继承信息。</strong></p>
<pre><code class="language-js">/**
* 描述
*
* @class
* @extends Developer
*/
function Fronteer() {
Developer.call(this);
// constructor body
}
util.inherits(Fronteer, Developer);
</code></pre>
</li>
<li>
<p><strong>[强制] 使用包装方式扩展类成员时，必须通过 <code>@lends</code> 进行重新指向。</strong></p>
<p>没有 <code>@lends</code> 标记将无法为该类生成包含扩展类成员的文档。</p>
<pre><code class="language-js">/**
* 类描述
*
* @class
* @extends Developer
*/
function Fronteer() {
Developer.call(this);
// constructor body
}

util.extend(
Fronteer.prototype,
/** @lends Fronteer.prototype */{
   getLevel: function () {
         // TODO
   }
}
);
</code></pre>
</li>
<li>
<p><strong>[强制] 类的属性或方法等成员信息不是 <code>public</code> 的，应使用 <code>@protected</code> 或 <code>@private</code> 标识可访问性。</strong></p>
<p>生成的文档中将有可访问性的标记，避免用户直接使用非 <code>public</code> 的属性或方法。</p>
<pre><code class="language-js">/**
* 类描述
*
* @class
* @extends Developer
*/
let Fronteer = function () {
Developer.call(this);

/**
* 属性描述
*
* @type {string}
* @private
*/
this.level = 'T12';

// constructor body
};
util.inherits(Fronteer, Developer);

/**
* 方法描述
*
* @private
* @return {string} 返回值描述
*/
Fronteer.prototype.getLevel = function () {
};
</code></pre>
</li>
</ul>
<h5 id="5158-函数方法注释">5.1.5.8 函数/方法注释</h5>
<ul>
<li>
<p><strong>函数/方法注释必须包含函数说明，有参数和返回值时必须使用注释标识。</strong></p>
<p>当 <code>return</code> 关键字仅作退出函数/方法使用时，无须对返回值作注释标识。</p>
</li>
<li>
<p><strong>[强制] 参数和返回值注释必须包含类型信息，且不允许省略参数的说明。</strong></p>
</li>
<li>
<p><strong>[建议]当函数是内部函数，外部不可访问时，可以使用 @inner 标识。</strong></p>
</li>
</ul>
<pre><code class="language-javascript">/**
* 函数描述
*
* @param {string} p1 参数1的说明
* @param {string} p2 参数2的说明，比较长
* 那就换行了.
* @param {number=} p3 参数3的说明（可选）
* @return {Object} 返回值描述
*/
function foo(p1, p2, p3) {
let p3 = p3 || 10;
return {
   p1: p1,
   p2: p2,
   p3: p3
};
}
</code></pre>
<ul>
<li>
<p><strong>[强制] 对 Object 中各项的描述，必须使用 <code>@param</code> 标识。</strong></p>
<pre><code class="language-js">/**
* 函数描述
*
* @param {Object} option 参数描述
* @param {string} option.url option项描述
* @param {string=} option.method option项描述，可选参数
*/
function foo(option) {
// TODO
}
</code></pre>
</li>
<li>
<p><strong>[建议] 重写父类方法时，应当添加 <code>@override</code> 标识。如果重写的形参个数、类型、顺序和返回值类型均未发生变化，可省略 <code>@param</code>、<code>@return</code>，仅用 <code>@override</code> 标识，否则仍应作完整注释。</strong></p>
<p>简而言之，当子类重写的方法能直接套用父类的方法注释时可省略对参数与返回值的注释。</p>
</li>
</ul>
<h5 id="5159-事件注释">5.1.5.9 事件注释</h5>
<ul>
<li>
<p><strong>[强制] 必须使用 <code>@event</code> 标识事件，事件参数的标识与方法描述的参数标识相同。</strong></p>
<pre><code class="language-js">/**
* 值变更时触发
*
* @event Select#change
* @param {Object} e e描述
* @param {string} e.before before描述
* @param {string} e.after after描述
*/
this.fire(
'change',
{
   before: 'foo',
   after: 'bar'
}
);
</code></pre>
</li>
<li>
<p><strong>[强制] 在会广播事件的函数前使用 <code>@fires</code> 标识广播的事件，在广播事件代码前使用 <code>@event</code> 标识事件。</strong></p>
</li>
<li>
<p><strong>[建议] 对于事件对象的注释，使用 <code>@param</code> 标识，生成文档时可读性更好。</strong></p>
</li>
</ul>
<h5 id="51510-常量注释">5.1.5.10 常量注释</h5>
<p><strong>[强制] 常量必须使用 <code>@const</code> 标记，并包含说明和类型信息。</strong></p>
<pre><code class="language-js">/**
* 常量说明
*
* @const
* @type {string}
*/
const REQUEST_URL = 'myurl.do';
</code></pre>
<h5 id="51511-细节注释">5.1.5.11 细节注释</h5>
<p>对于内部实现、不容易理解的逻辑说明、摘要信息等，我们可能需要编写细节注释。</p>
<ul>
<li>
<p><strong>[建议] 细节注释遵循单行注释的格式。说明必须换行时，每行是一个单行注释的起始</strong></p>
<pre><code class="language-js">function foo(p1, p2, opt_p3) {
// 这里对具体内部逻辑进行说明
// 说明太长需要换行
for (...) {
   ....
}
}
</code></pre>
</li>
<li>
<p><strong>[强制] 有时我们会使用一些特殊标记进行说明。特殊标记必须使用单行注释的形式。下面列举了一些常用标记：</strong></p>
<ol>
<li>TODO: 有功能待实现。此时需要对将要实现的功能进行简单说明。</li>
<li>FIXME: 该处代码运行没问题，但可能由于时间赶或者其他原因，需要修正。此时需要对如何修正进行简单说明。</li>
<li>HACK: 为修正某些问题而写的不太好或者使用了某些诡异手段的代码。此时需要对思路或诡异手段进行描述。</li>
<li>XXX: 该处存在陷阱。此时需要对陷阱进行描述。</li>
</ol>
</li>
</ul>
<h4 id="516-命名">5.1.6 命名</h4>
<ul>
<li><strong>[强制] <code>变量</code>, 使用 <code>Camel 命名法</code>。</strong></li>
</ul>
<pre><code class="language-js">let loadingModules = {};
</code></pre>
<ul>
<li><strong>[强制]<code>私有属性、私有变量和私有方法</code> 以下划线<code>_ </code> 开头。</strong></li>
</ul>
<pre><code class="language-js">let _privateMethod = {};
</code></pre>
<ul>
<li><strong>[强制] <code>常量</code> 使用 <code>全部字母大写，单词间下划线分隔</code> 的命名方式。</strong></li>
</ul>
<pre><code class="language-js">let HTML_ENTITY = {};
</code></pre>
<ul>
<li><strong>[强制] <code>函数</code> 使用 <code>Camel</code> 命名法。</strong></li>
</ul>
<pre><code class="language-js">function stringFormat(source) {}
</code></pre>
<ul>
<li>
<p><strong>[强制] 函数的 <code>参数</code>, 使用 <code>Camel</code> 命名法。</strong></p>
<pre><code class="language-js">function hear(theBells) {}
</code></pre>
</li>
<li>
<p><strong>[强制] <code>类</code> 使用 <code>Pascal</code> 命名法。</strong></p>
<pre><code class="language-js">function TextNode(options) {
}
</code></pre>
</li>
<li>
<p>**[强制]类的<code>方法 / 属性</code>使用 <code>Camel</code> 命名法。</p>
</li>
</ul>
<pre><code class="language-js">function TextNode(value, engine) {
this.value = value;
this.engine = engine;
}

TextNode.prototype.clone = function () {
return this;
};
</code></pre>
<ul>
<li><strong>[强制] <code>枚举变量</code>使用 <code>Pascal</code> 命名法，<code>枚举的属性</code>使用 <code>全部字母大写，单词间下划线分隔</code> 的命名方式。</strong></li>
</ul>
<pre><code class="language-js">let TargetState = {
READING: 1,
READED: 2,
APPLIED: 3,
READY: 4
};
</code></pre>
<ul>
<li>
<p><strong>[强制] <code>命名空间</code> 使用 <code>Camel命名法</code>。</strong></p>
<pre><code class="language-js">equipments.heavyWeapons = {};
</code></pre>
</li>
<li>
<p><strong>[强制]由多个单词组成的 <code>缩写词</code>，在命名中，根据当前命名法和出现的位置，所有字母的大小写与首字母的大小写保持一致。</strong></p>
</li>
</ul>
<pre><code class="language-js">function XMLParser() {}

function insertHTML(element, html) {}

let httpRequest = new HTTPRequest();
</code></pre>
<h4 id="517-命名语法">5.1.7 命名语法</h4>
<ul>
<li><strong>类名</strong>，使用名词。</li>
</ul>
<pre><code class="language-js">function Engine(options) {}
</code></pre>
<ul>
<li><strong>函数名</strong>，使用动宾短语。</li>
</ul>
<pre><code class="language-js">function getStyle(element) {}
</code></pre>
<ul>
<li><strong>boolean</strong> 类型的变量使用 is 或 has 开头。</li>
</ul>
<pre><code class="language-js">let isReady = false;
let hasMoreCommands = false;
</code></pre>
<ul>
<li><strong>Promise 对象</strong>用动宾短语的进行时表达。</li>
</ul>
<pre><code class="language-js">let loadingData = ajax.get('url');
loadingData.then(callback);
</code></pre>
<h4 id="518-接口命名规范">5.1.8 接口命名规范</h4>
<ol>
<li>可读性强，见名知义；</li>
<li>尽量写全。不用缩写，除非是下面列表中约定的；</li>
</ol>
<table>
<thead>
<tr>
<th style="text-align: left">常用词</th>
<th style="text-align: left">说明</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: left">options</td>
<td style="text-align: left">表示选项，与 jQuery 社区保持一致，不要用 config, opts 等</td>
</tr>
<tr>
<td style="text-align: left">active</td>
<td style="text-align: left">表示当前，不要用 current 等</td>
</tr>
<tr>
<td style="text-align: left">index</td>
<td style="text-align: left">表示索引，不要用 idx 等</td>
</tr>
<tr>
<td style="text-align: left">trigger</td>
<td style="text-align: left">触点元素</td>
</tr>
<tr>
<td style="text-align: left">triggerType</td>
<td style="text-align: left">触发类型、方式</td>
</tr>
<tr>
<td style="text-align: left">context</td>
<td style="text-align: left">表示传入的 this 对象</td>
</tr>
<tr>
<td style="text-align: left">object</td>
<td style="text-align: left">推荐写全，不推荐简写为 o, obj 等</td>
</tr>
<tr>
<td style="text-align: left">element</td>
<td style="text-align: left">推荐写全，不推荐简写为 el, elem 等</td>
</tr>
<tr>
<td style="text-align: left">length</td>
<td style="text-align: left">不要写成 len, l</td>
</tr>
<tr>
<td style="text-align: left">prev</td>
<td style="text-align: left">previous 的缩写</td>
</tr>
<tr>
<td style="text-align: left">next</td>
<td style="text-align: left">next 下一个</td>
</tr>
<tr>
<td style="text-align: left">constructor</td>
<td style="text-align: left">不能写成 ctor</td>
</tr>
<tr>
<td style="text-align: left">easing</td>
<td style="text-align: left">示动画平滑函数</td>
</tr>
<tr>
<td style="text-align: left">min</td>
<td style="text-align: left">minimize 的缩写</td>
</tr>
<tr>
<td style="text-align: left">max</td>
<td style="text-align: left">maximize 的缩写</td>
</tr>
<tr>
<td style="text-align: left">DOM</td>
<td style="text-align: left">不要写成 dom, Dom</td>
</tr>
<tr>
<td style="text-align: left">.hbs</td>
<td style="text-align: left">使用 hbs 后缀表示模版</td>
</tr>
<tr>
<td style="text-align: left">btn</td>
<td style="text-align: left">button 的缩写</td>
</tr>
<tr>
<td style="text-align: left">link</td>
<td style="text-align: left">超链接</td>
</tr>
<tr>
<td style="text-align: left">title</td>
<td style="text-align: left">主要文本</td>
</tr>
<tr>
<td style="text-align: left">img</td>
<td style="text-align: left">图片路径（img标签src属性）</td>
</tr>
<tr>
<td style="text-align: left">dataset</td>
<td style="text-align: left">html5 data-xxx 数据接口</td>
</tr>
<tr>
<td style="text-align: left">theme</td>
<td style="text-align: left">主题</td>
</tr>
<tr>
<td style="text-align: left">className</td>
<td style="text-align: left">类名</td>
</tr>
<tr>
<td style="text-align: left">classNameSpace</td>
<td style="text-align: left">class 命名空间</td>
</tr>
</tbody>
</table>
<h4 id="519-不要在-array-上使用-for-in-循环">5.1.9 不要在 Array 上使用 for-in 循环</h4>
<p>for-in 循环只用于 <code>object/map/hash</code> 的遍历, 对 <code>Array</code> 用 for-in 循环有时会出错. 因为它并不是从 0 到 length - 1 进行遍历, 而是所有出现在对象及其原型链的键值。</p>
<pre><code class="language-js">// 不推荐
function printArray(arr) {
for (let key in arr) {
print(arr);
}
}

printArray();// This works.

let a = new Array(10);
printArray(a);// This is wrong.

a = document.getElementsByTagName('*');
printArray(a);// This is wrong.

a = ;
a.buhu = 'wine';
printArray(a);// This is wrong again.

a = new Array;
a = 3;
printArray(a);// This is wrong again.

// 推荐
function printArray(arr) {
let l = arr.length;
for (let i = 0; i < l; i++) {
print(arr);
}
}
</code></pre>
<h4 id="5110-二元和三元操作符">5.1.10 二元和三元操作符</h4>
<p>操作符始终写在前一行, 以免<strong>分号的隐式插入</strong>产生预想不到的问题。</p>
<pre><code class="language-js">let x = a ? b : c;

let y = a ?
longButSimpleOperandB : longButSimpleOperandC;

let z = a ?
   moreComplicatedB :
   moreComplicatedC;
</code></pre>
<p><code>.</code> 操作符也是如此：</p>
<pre><code class="language-js">let x = foo.bar().
doSomething().
doSomethingElse();
</code></pre>
<h4 id="5111-条件三元操作符-">5.1.11 条件(三元)操作符 (?😃</h4>
<pre><code class="language-js">三元操作符用于替代 if 条件判断语句。

// 不推荐
if (val != 0) {
return foo();
} else {
return bar();
}

// 推荐
return val ? foo() : bar();
</code></pre>
<h3 id="52-语言特性">5.2 语言特性</h3>
<h4 id="521-变量">5.2.1 变量</h4>
<ul>
<li>
<p><strong>[强制] 变量、函数在使用前必须先定义。且需使用 <code>let</code> 或 <code>const</code>，不使用 <code>var</code> 。</strong></p>
<p>使用 <code>let</code> 和 <code>const</code> 定义时，变量作用域范围更明确。</p>
<pre><code class="language-js">// good
let name = 'MyName';
const PI = '3.14';
for (let i = 0; i < 10; i++) {

}

// bad
name = 'MyName';
for (var i = 0; i < 10; i++) {

}
</code></pre>
<p>原则上不建议使用全局变量，对于已有的全局变量或第三方框架引入的全局变量，需要根据检查工具的语法标识。</p>
<pre><code class="language-js"> /* globals jQuery */
let element = jQuery('#element-id');
</code></pre>
</li>
<li>
<p><strong>[强制] 每个 <code>let</code> 只能声明一个变量。</strong></p>
<p>一个 <code>let</code> 声明多个变量，容易导致较长的行长度，并且在修改时容易造成逗号和分号的混淆。</p>
<pre><code class="language-js">// good
let hangModules = [];
let missModules = [];
let visited = {};

// bad
let hangModules = [],
missModules = [],
visited = {};
</code></pre>
</li>
<li>
<p><strong>[强制] 变量必须 <code>即用即声明</code>，不得在函数或其它形式的代码块起始位置统一声明所有变量。</strong></p>
<p>变量声明与使用的距离越远，出现的跨度越大，代码的阅读与维护成本越高。虽然JavaScript的变量是函数作用域，还是应该根据编程中的意图，缩小变量出现的距离空间。</p>
<pre><code class="language-js">// good
function kv2List(source) {
let list = [];

for (let key in source) {
if (source.hasOwnProperty(key)) {
   let item = {
   k: key,
   v: source
   };

   list.push(item);
}
}

return list;
}

// bad
function kv2List(source) {
let list = [];
let key;
let item;

for (key in source) {
if (source.hasOwnProperty(key)) {
   item = {
   k: key,
   v: source
   };

   list.push(item);
}
}

return list;
}
</code></pre>
</li>
</ul>
<h4 id="522-条件">5.2.2 条件</h4>
<ul>
<li>
<p><strong>[强制] 在 Equality Expression 中使用类型严格的 <code>===</code>。仅当判断 <code>null</code> 或 <code>undefined</code> 时，允许使用 <code>== null</code>。</strong></p>
<p>使用 <code>===</code> 可以避免等于判断中隐式的类型转换。</p>
<pre><code class="language-js">// good
if (age === 30) {
// ......
}

// bad
if (age == 30) {
// ......
}
</code></pre>
</li>
<li>
<p><strong>[建议] 尽可能使用简洁的表达式</strong></p>
<pre><code class="language-js">// 字符串为空

// good
if (!name) {
// ......
}

// bad
if (name === '') {
// ......
}
</code></pre>
<pre><code class="language-js">// 字符串非空

// good
if (name) {
// ......
}

// bad
if (name !== '') {
// ......
}
</code></pre>
<pre><code class="language-js">// 数组非空

// good
if (collection.length) {
// ......
}

// bad
if (collection.length > 0) {
// ......
}
</code></pre>
<pre><code class="language-js">// 布尔不成立

// good
if (!notTrue) {
// ......
}

// bad
if (notTrue === false) {
// ......
}
</code></pre>
<pre><code class="language-js">// null 或 undefined

// good
if (noValue == null) {
// ......
}

// bad
if (noValue === null || typeof noValue === 'undefined') {
// ......
}
</code></pre>
</li>
<li>
<p><strong>[建议] 按执行频率排列分支的顺序。</strong></p>
<p>按执行频率排列分支的顺序好处是：</p>
<ol>
<li>阅读的人容易找到最常见的情况，增加可读性。</li>
<li>提高执行效率。</li>
</ol>
</li>
<li>
<p><strong>[建议] 对于相同变量或表达式的多值条件，用 <code>switch</code> 代替 <code>if</code>。</strong></p>
<pre><code class="language-js">// good
switch (typeof variable) {
case 'object':
   // ......
   break;
case 'number':
case 'boolean':
case 'string':
   // ......
   break;
}

// bad
let type = typeof variable;
if (type === 'object') {
// ......
}
else if (type === 'number' || type === 'boolean' || type === 'string') {
// ......
}
</code></pre>
</li>
<li>
<p><strong>[建议] 如果函数或全局中的 <code>if</code> 块有 <code>return</code> 且 <code>else</code> 块后没有任何语句，可以删除 <code>else</code>。</strong></p>
<pre><code class="language-js">// good
function getName() {
if (name) {
   return name;
}

return 'unnamed';
}

// bad
function getName() {
if (name) {
   return name;
}
else {
   return 'unnamed';
}
}
</code></pre>
</li>
</ul>
<h4 id="523-循环">5.2.3 循环</h4>
<ul>
<li>
<p><strong>[建议] 不要在循环体中包含函数表达式，事先将函数提取到循环体外。</strong></p>
<p>循环体中的函数表达式，运行过程中会生成循环次数个函数对象。</p>
<pre><code class="language-js">// good
function clicker() {
// ......
}

for (let i = 0, len = elements.length; i < len; i++) {
let element = elements;
addListener(element, 'click', clicker);
}

// bad
for (let i = 0, len = elements.length; i < len; i++) {
let element = elements;
addListener(element, 'click', function () {});
}
</code></pre>
</li>
<li>
<p><strong>[建议] 对循环内多次使用的不变值，在循环外用变量缓存。</strong></p>
<pre><code class="language-js">// good
let width = wrap.offsetWidth + 'px';
for (let i = 0, len = elements.length; i < len; i++) {
let element = elements;
element.style.width = width;
// ......
}

// bad
for (let i = 0, len = elements.length; i < len; i++) {
let element = elements;
element.style.width = wrap.offsetWidth + 'px';
// ......
}
</code></pre>
</li>
<li>
<p><strong>[建议] 对有序集合进行遍历时，缓存 <code>length</code>。</strong></p>
<p>虽然现代浏览器都对数组长度进行了缓存，但对于一些宿主对象和老旧浏览器的数组对象，在每次 <code>length</code> 访问时会动态计算元素个数，此时缓存 <code>length</code> 能有效提高程序性能。</p>
<pre><code class="language-js">for (let i = 0, len = elements.length; i < len; i++) {
let element = elements;
// ......
}
</code></pre>
</li>
</ul>
<h4 id="524-解构">5.2.4 解构</h4>
<ul>
<li>
<p><strong>[强制] 不要使用3层及以上的解构。</strong></p>
<p>过多层次的解构会让代码变得难以阅读。</p>
<pre><code class="language-js">// bad
let {documentElement: {firstElementChild: {nextSibling}}} = window;
</code></pre>
</li>
<li>
<p><strong>[建议] 使用解构减少中间变量。</strong></p>
<p>常见场景如变量值交换，可能产生中间变量。这种场景推荐使用解构。</p>
<pre><code class="language-js">// good
= ;

// bad
let temp = x;
x = y;
y = temp;
</code></pre>
</li>
<li>
<p><strong>[强制] 如果不节省编写时产生的中间变量，解构表达式 <code>=</code> 号右边不允许是 <code>ObjectLiteral</code> 和 <code>ArrayLiteral</code>。</strong></p>
<pre><code class="language-js">// good
let {first: firstName, last: lastName} = person;
let one = 1;
let two = 2;

// bad
let = ;
</code></pre>
</li>
<li>
<p><strong>[强制] 使用剩余运算符时，剩余运算符之前的所有元素必需具名。</strong></p>
<p>剩余运算符之前的元素省略名称可能带来较大的程序阅读障碍。如果仅仅为了取数组后几项，请使用 <code>slice</code> 方法。</p>
<pre><code class="language-js">// good
let = myArray;
let other = myArray.slice(3);

// bad
let [,,, ...other] = myArray;
</code></pre>
</li>
</ul>
<h4 id="525-类型">5.2.5 类型</h4>
<h5 id="5251-类型检测">5.2.5.1 类型检测</h5>
<ul>
<li>
<p><strong>[建议] 类型检测优先使用 <code>typeof</code>。对象类型检测使用 <code>instanceof</code>。<code>null</code> 或 <code>undefined</code> 的检测使用 <code>== null</code>。</strong></p>
<pre><code class="language-js">// string
typeof variable === 'string'

// number
typeof variable === 'number'

// boolean
typeof variable === 'boolean'

// Function
typeof variable === 'function'

// Object
typeof variable === 'object'

// RegExp
variable instanceof RegExp

// Array
variable instanceof Array

// null
variable === null

// null or undefined
variable == null

// undefined
typeof variable === 'undefined'
</code></pre>
</li>
</ul>
<h5 id="5252-类型转换">5.2.5.2 类型转换</h5>
<ul>
<li>
<p><strong>[建议] 转换成 <code>string</code> 时，使用 <code>+ ''</code>。</strong></p>
<pre><code class="language-js">// good
num + '';

// bad
new String(num);
num.toString();
String(num);
</code></pre>
</li>
<li>
<p><strong>[建议] 转换成 <code>number</code> 时，通常使用 <code>+</code>。</strong></p>
<pre><code class="language-js">// good
+str;

// bad
Number(str);
</code></pre>
</li>
<li>
<p><strong>[建议] <code>string</code> 转换成 <code>number</code>，要转换的字符串结尾包含非数字并期望忽略时，使用 <code>parseInt</code>。</strong></p>
<pre><code class="language-js">let width = '200px';
parseInt(width, 10);
</code></pre>
</li>
<li>
<p><strong>[建议] 转换成 <code>boolean</code> 时，使用 <code>!!</code>。</strong></p>
<pre><code class="language-js">let num = 3.14;
!!num;
</code></pre>
</li>
</ul>
<h4 id="526-字符串">5.2.6 字符串</h4>
<ul>
<li><strong>[强制] 字符串开头和结束使用单引号 <code>'</code>。</strong></li>
</ul>
<ol>
<li>输入单引号不需要按住 <code>shift</code>，方便输入。</li>
<li>实际使用中，字符串经常用来拼接 HTML。为方便 HTML 中包含双引号而不需要转义写法。</li>
</ol>
<pre><code class="language-js">let str = '我是一个字符串';
let html = '<div class="cls">拼接HTML可以省去双引号转义</div>';
</code></pre>
<ul>
<li>
<p><strong>[强制] 模板字符串字符串内变量替换时，不要使用 <code>2</code> 次及以上的函数调用。</strong></p>
<pre><code class="language-js">// good
let fullName = getFullName(getFirstName(), getLastName());
let s = `Hello ${fullName}`;

// bad
let s = `Hello ${getFullName(getFirstName(), getLastName())}`;
</code></pre>
</li>
</ul>
<h4 id="527-函数">5.2.7 函数</h4>
<ul>
<li>
<p><strong>[建议] 使用变量默认语法代替基于条件判断的默认值声明。</strong></p>
<pre><code class="language-js">// good
function foo(text = 'hello') {
}

// bad
function foo(text) {
text = text || 'hello';
}
</code></pre>
</li>
<li>
<p><strong>[强制] 不要使用 <code>arguments</code> 对象，应使用 <code>...args</code> 代替。</strong></p>
<pre><code class="language-js">// good
function foo(...args) {
console.log(args.join(''));
}

// bad
function foo() {
console.log([].join.call(arguments));
}
</code></pre>
</li>
</ul>
<h4 id="528-对象">5.2.8 对象</h4>
<ul>
<li>
<p><strong>[建议] 对象创建时，如果一个对象的所有 <code>属性</code> 均可以不添加引号，建议所有 <code>属性</code> 不添加引号。</strong></p>
<pre><code class="language-js">let info = {
name: 'someone',
age: 28
};
</code></pre>
</li>
<li>
<p><strong>[建议] 对象创建时，如果任何一个 <code>属性</code> 需要添加引号，则所有 <code>属性</code> 建议添加 <code>'</code>。<br>
如果属性不符合 Identifier 和 NumberLiteral 的形式，就需要以 StringLiteral 的形式提供。</strong></p>
<pre><code class="language-js">// good
let info = {
'name': 'someone',
'age': 28,
'more-info': '...'
</code></pre>
</li>
</ul>
<p>};</p>
<p>// bad<br>
let info = {<br>
name: 'someone',<br>
age: 28,<br>
'more-info': '...'<br>
};<br>
```</p>
<ul>
<li>
<p><strong>[建议] 定义对象时，如果所有键均指向同名变量，则所有键都使用缩写；如果有一个键无法指向同名变量，则所有键都不使用缩写。</strong></p>
<pre><code class="language-js">// good
let foo = {x, y, z};

let foo2 = {
x: 1,
y: 2,
z: z
};

// bad
let foo = {
x: x,
y: y,
z: z
};

let foo2 = {
x: 1,
y: 2,
z
};
</code></pre>
</li>
<li>
<p><strong>[强制] 定义方法时使用 <code>MethodDefinition</code> 语法，不使用 <code>PropertyName: FunctionExpression</code> 语法。</strong></p>
<pre><code class="language-js">// good
let foo = {
bar(x, y) {
   return x + y;
}
};

// bad
let foo = {
bar: function (x, y) {
   return x + y;
}
};
</code></pre>
</li>
<li>
<p><strong>[强制] 不允许修改和扩展任何原生对象和宿主对象的原型。</strong></p>
<pre><code class="language-js">// 以下行为绝对禁止
String.prototype.trim = function () {
};
</code></pre>
</li>
<li>
<p><strong>[建议] 属性访问时，尽量使用 <code>.</code>。</strong></p>
<p>属性名符合 Identifier 的要求，就可以通过 <code>.</code> 来访问，否则就只能通过 <code></code> 方式访问。</p>
<p>通常在 JavaScript 中声明的对象，属性命名是使用 Camel 命名法，用 <code>.</code> 来访问更清晰简洁。部分特殊的属性（比如来自后端的 JSON ），可能采用不寻常的命名方式，可以通过 <code></code> 方式访问。</p>
<pre><code class="language-js">info.age;
info['more-info'];
</code></pre>
</li>
<li>
<p><strong>[建议] 使用 <code>Object.keys</code> 或 <code>Object.entries</code> 进行对象遍历。</strong></p>
<pre><code class="language-js">// good
for (let key of Object.keys(foo)) {
let value = foo;
}

// good
for (let of Object.entries(foo)) {
// ...
}
</code></pre>
</li>
<li>
<p><strong>[建议] 定义对象的方法不应使用箭头函数。</strong></p>
<p>箭头函数将 <code>this</code> 绑定到当前环境，在 <code>obj.method()</code> 调用时容易导致不期待的 <code>this</code>。除非明确需要绑定 <code>this</code>，否则不应使用箭头函数。</p>
<pre><code class="language-js">// good
let foo = {
bar(x, y) {
   return x + y;
}
};

// bad
let foo = {
bar: (x, y) => x + y
};
</code></pre>
</li>
<li>
<p><strong>[建议] 尽量使用计算属性键在一个完整的字面量中完整地定义一个对象，避免对象定义后直接增加对象属性。</strong></p>
<p>在一个完整的字面量中声明所有的键值，而不需要将代码分散开来，有助于提升代码可读性。</p>
<pre><code class="language-js">// good
const MY_KEY = 'bar';
let foo = {
: 123
};

// bad
const MY_KEY = 'bar';
let foo = {};
foo = 123;
</code></pre>
</li>
</ul>
<h4 id="529-类">5.2.9 类</h4>
<ul>
<li>
<p><strong>[强制] 使用 <code>class</code> 关键字定义一个类。</strong></p>
<p>直接使用 <code>class</code> 定义类更清晰。不要再使用 <code>function</code> 和 <code>prototype</code> 形式的定义。</p>
<pre><code class="language-js">// good
class TextNode {
constructor(value, engine) {
   this.value = value;
   this.engine = engine;
}

clone() {
   return this;
}
}

// bad
function TextNode(value, engine) {
this.value = value;
this.engine = engine;
}

TextNode.prototype.clone = function () {
return this;
};
</code></pre>
</li>
<li>
<p><strong>[强制] 使用 <code>super</code> 访问父类成员，而非父类的 <code>prototype</code>。</strong></p>
<p>使用 <code>super</code> 和 <code>super.foo</code> 可以快速访问父类成员，而不必硬编码父类模块而导致修改和维护的不便，同时更节省代码。</p>
<pre><code class="language-js">// good
class TextNode extends Node {
constructor(value, engine) {
   super(value);
   this.engine = engine;
}

setNodeValue(value) {
   super.setNodeValue(value);
   this.textContent = value;
}
}

// bad
class TextNode extends Node {
constructor(value, engine) {
   Node.apply(this, arguments);
   this.engine = engine;
}

setNodeValue(value) {
   Node.prototype.setNodeValue.call(this, value);
   this.textContent = value;
}
}
</code></pre>
</li>
</ul>
<h4 id="4210-模块">4.2.10 模块</h4>
<ul>
<li>
<p><strong>[强制] <code>export</code> 与内容定义放在一起。</strong></p>
<p>何处声明要导出的东西，就在何处使用 <code>export</code> 关键字，不在声明后再统一导出。</p>
<pre><code class="language-js">// good
export function foo() {
}

export const bar = 3;

// bad
function foo() {
}

const bar = 3;

export {foo};
export {bar};
</code></pre>
</li>
<li>
<p><strong>[强制] 所有 <code>import</code> 语句写在模块开始处。</strong></p>
<pre><code class="language-js">// good
import {bar} from './bar';

function foo() {
bar.work();
}

// bad
function foo() {
import {bar} from './bar';
bar.work();
}
</code></pre>
</li>
</ul>
<h4 id="4211-集合">4.2.11 集合</h4>
<ul>
<li>
<p><strong>[建议] 对数组进行连接操作时，使用数组展开语法。</strong></p>
<p>用数组展开代替 <code>concat</code> 方法，数组展开对 <code>Iterable</code> 有更好的兼容性。</p>
<pre><code class="language-js">// good
let foo = [...foo, newValue];
let bar = [...bar, ...newValues];

// bad
let foo = foo.concat(newValue);
let bar = bar.concat(newValues);
</code></pre>
</li>
<li>
<p><strong>[建议] 不要使用数组展开进行数组的复制操作。</strong></p>
<p>使用数组展开语法进行复制，代码可读性较差。推荐使用 <code>Array.from</code> 方法进行复制操作。</p>
<pre><code class="language-js">// good
let otherArr = Array.from(arr);

// bad
let otherArr = [...arr];
</code></pre>
</li>
<li>
<p><strong>[建议] 当需要遍历功能时，使用 <code>Map</code> 和 <code>Set</code>。</strong></p>
<p><code>Map</code> 和 <code>Set</code> 是可遍历对象，能够方便地使用 <code>for...of</code> 遍历。不要使用使用普通 Object。</p>
<pre><code class="language-js">// good
let membersAge = new Map([
['one', 10],
['two', 20],
['three', 30]
]);
for (let of map) {
}

// bad
let membersAge = {
one: 10,
two: 20,
three: 30
};
for (let key in membersAge) {
if (membersAge.hasOwnProperty(key)) {
   let value = membersAge;
}
}
</code></pre>
</li>
<li>
<p><strong>[建议] 程序运行过程中有添加或移除元素的操作时，使用 <code>Map</code> 和 <code>Set</code>。</strong></p>
<p>使用 <code>Map</code> 和 <code>Set</code>，程序的可理解性更好；普通 Object 的语义更倾向于表达固定的结构。</p>
<pre><code class="language-js">// good
let membersAge = new Map();
membersAge.set('one', 10);
membersAge.set('two', 20);
membersAge.set('three', 30);
membersAge.delete('one');

// bad
let membersAge = {};
membersAge.one = 10;
membersAge.two = 20;
membersAge.three = 30;
delete membersAge['one'];
</code></pre>
</li>
</ul>
<h2 id="6-vue代码规范">6. Vue代码规范</h2>
<h4 id="61-vue-项目目录规范">6.1 Vue 项目目录规范</h4>
<pre><code class="language-markdown">|-- api                            所有api接口

|-- assets                         静态资源，images, icons, styles等

|-- components                   公用组件

|-- common                         公共方法

|-- config                         配置信息

|-- constants                      常量信息，项目所有Enum, 全局常量等

|-- directives                   自定义指令

|-- filters                      过滤器，全局工具

|-- datas                         模拟数据，临时存放

|-- lib                            外部引用的插件存放及修改文件

|-- mock                         模拟接口，临时存放

|-- plugins                      插件，全局使用

|-- router                         路由，统一管理

|-- store                         vuex, 统一管理

|-- themes                         自定义样式主题

|-- views                         视图目录
</code></pre>
<h4 id="62-组件规范">6.2 组件规范</h4>
<p>组件名必须是多个单词(大于等于2) 且命名规范全部为驼峰命名法，且第一个单词首字母也需要大写</p>
<pre><code class="language-vue">export default {

name: 'TodoItem'

// ...

};
</code></pre>
<p>写组件标签的时候必须写双标签不能写单标签</p>
<pre><code class="language-vue"><MyComponent></MyComponent>
</code></pre>
<h4 id="63--vue-api-规范">6.3Vue api 规范</h4>
<p>Prop 定义应该尽量详细</p>
<ul>
<li>必须指定类型</li>
<li>必须添加注释</li>
<li>必须加上 require 或者 default</li>
</ul>
<pre><code class="language-vue"> props: {
// 组件状态，用于控制组件的颜色
status: {
type: String,
required: true,
}
}

</code></pre>
<ul>
<li>
<p>如果运行时，需要非常频繁地切换，使用 v-show ；如果在运行时，条件很少改变，使用 v-if。</p>
</li>
<li>
<p>指令推荐都使用缩写形式，(用 : 表示 v-bind: 、用 @ 表示 v-on: 和用 # 表示 v-slot:)</p>
</li>
</ul>
<pre><code class="language-vue"><input @input="onInput" @focus="onFocus">
</code></pre>
<ul>
<li>{{}} moustache 语法中尽量不写复杂的表达式，必要时使用计算属性等方法表示</li>
</ul>
<h4 id="64-vue-router-规范">6.4 Vue Router 规范</h4>
<ul>
<li>
<p>必须使用路由懒加载机制</p>
</li>
<li>
<p>路由表中的 name 命名与 component 组件保持一致，因为 keep-alive 的存在</p>
<p>keep-alive 必须按照 component name 进行缓存两者必须保持高度统一，path</p>
<p>可以使用 name 命名第一个单词首字母改成小写</p>
</li>
</ul>
<h4 id="65-前后端对接-api-规范">6.5 前后端对接 api 规范</h4>
<ul>
<li>
<p>此目录对应后端 API 接口，按照后端一个 controller 一个 api js 文件。若项目较大时，可以按照业务划分子目录，并与后端保持一致。</p>
</li>
<li>
<p>api 中的方法名字要与后端 api url 尽量保持语义高度一致性。</p>
</li>
<li>
<p>对于 api 中的每个方法要添加注释，注释与后端 swagger 文档保持一致。</p>
</li>
</ul>
<h4 id="66-注释说明">6.6 注释说明</h4>
<p><strong>以下为必须添加注释的地方</strong></p>
<ul>
<li>
<p>公共组件使用说明</p>
</li>
<li>
<p>各组件中重要函数或者类说明</p>
</li>
<li>
<p>复杂的业务逻辑处理说明</p>
</li>
<li>
<p>api 目录的接口 js 文件必须加注释</p>
</li>
<li>
<p>store 中的 state, mutation, action 等必须加注释</p>
</li>
<li>
<p>.vue 文件中的 template 必须加注释，若文件较大添加 start end 注释</p>
</li>
<li>
<p>.vue 文件的 methods，每个 method 必须添加注释</p>
</li>
<li>
<p>.vue 文件的 data, 非常见单词要加注释</p>
</li>
<li>
<p>多行注释按照下面方式进行书写</p>
</li>
</ul>
<pre><code class="language-vue">/**
* 组件名称
* @module 组件存放位置
* @desc 组件描述
* @author 组件作者
* @date 2017年12月05日17:22:43
* @param {Object} - 参数说明
* @param {String} - 参数说明
* @example 调用示例
**/
<hbTable :title="title" :columns="columns" :tableData="tableData"></hbTable>
</code></pre>
<h4 id="67-其他">6.7 其他</h4>
<ul>
<li>使用 Vue 框架之后尽量不要再去手动操作DOM，包括增删改 dom 元素以及更改样式，添加事件</li>
<li>router 与 store 一定要将里面的代码按照业务进行拆分，不能放到同一个js文件里面</li>
<li>删除无用代码</li>
<li>更多参考见 Vue风格指南</li>
</ul>
<h2 id="7-移动端规范">7. 移动端规范</h2>
<ul>
<li>
<p><strong>click 的 300ms 延迟响应</strong></p>
<p>click 的 300ms 延迟是由双击缩放(double tap to zoom)所导致的，由于用户可以进行双击缩放或者双击滚动的操作，当用户一次点击屏幕之后，浏览器并不能立刻判断用户是确实要打开这个链接，还是想要进行双击操作。因此，移动端浏览器就等待 300 毫秒，以判断用户是否再次点击了屏幕。</p>
<ul>
<li>
<p><strong>解决方法1：禁止缩放</strong></p>
<p>既然双击缩放是造成300ms延迟的原因，那么只要禁用缩放就可以了。禁用缩放，也就没有了双击产生缩放的操作，那么就不需要等待300ms，也就没有了300ms的延迟。</p>
<pre><code class="language-html"><meta name="viewport" content="width=device-width,user-scalable=no">
</code></pre>
</li>
<li>
<p><strong>解决方法2：FastClick</strong></p>
<p>在检测到touched事件后，立即触发一个模拟click事件，并把浏览器300ms之后真正触发的click事件阻断掉。</p>
<pre><code class="language-js">window.addEventListener( "load", function() {
FastClick.attach( document.body );
}, false );
</code></pre>
</li>
</ul>
</li>
<li>
<p>快速回弹滚动</p>
<p>如果想要为某个元素拥有 Native 般的滚动效果，可以这样操作：</p>
<pre><code>.element {
overflow: auto; /* auto | scroll */
-webkit-overflow-scrolling: touch;
}
</code></pre>
<p>除了 iScroll 之外，还有一个更加强大的滚动插件 Swiper，支持 3D 和内置滚动条等。</p>
</li>
<li>
<p><strong>获取滚动条的位置</strong></p>
<p>PC 端滚动条的值是通过 <code>document.scrollTop</code> 和 <code>document.scrollLeft</code> 获得，但在 iOS 中并没有滚动条的概念，所以仅能通过 windows.scroll 获取，同时也能兼容 Android 。</p>
<pre><code class="language-js">window.scrollY
window.scrollX
</code></pre>
</li>
<li>
<p><strong>清除输入框内阴影</strong></p>
<p>在 iOS 上，输入框默认有内部阴影，但无法使用 box-shadow 来清除，如果不需要阴影，可以这样操作：</p>
<pre><code class="language-css">input,
textarea {
border: 0; /* 方法1 */
-webkit-appearance: none; /* 方法2 */
}
</code></pre>
</li>
<li>
<p><strong>页面窗口自动调整到设备宽度，并禁止用户缩放页面</strong></p>
<pre><code class="language-html"><meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no" />
</code></pre>
</li>
<li>
<p><strong>电话号码识别</strong></p>
<p>iOS Safari ( Android 或其他浏览器不会) 会自动识别看起来像电话号码的数字，将其处理为电话号码链接，比如：</p>
<ul>
<li>7位数字，形如：1234567</li>
<li>带括号及加号的数字，形如：(+86)123456789</li>
<li>双连接线的数字，形如：00-00-00111</li>
<li>11位数字，形如：13800138000</li>
</ul>
<pre><code class="language-html">
<meta name="format-detection" content="telephone=no" />


<a href="tel:123456">123456</a>


<a href="sms:123456">123456</a>
</code></pre>
</li>
<li>
<p><strong>邮箱地址的识别</strong></p>
<p>在 Android （ iOS 不会）上，浏览器会自动识别看起来像邮箱地址的字符串，不论有你没有加上邮箱链接，当你在这个字符串上长按，会弹出发邮件的提示。</p>
<pre><code class="language-html">
<meta name="format-detection" content="email=no" />


<a href="mailto:mobile@gmail.com">mobile@gmail.com</a>
</code></pre>
</li>
</ul>
<h2 id="参考">参考</h2>
<ul>
<li>
<p>W3Cschool 前端开发规范</p>
</li>
<li>
<p>airbnb javascript</p>
</li>
<li>
<p>airbnb javascript CN</p>
</li>
<li>
<p>HTML 和 CSS 代码规范</p>
</li>
<li>
<p>Baidu 前端规范</p>
</li>
<li>
<p>前端开发规范</p>
</li>
<li>
<p>Vue 风格指南</p>
</li>
<li>
<p>网页头部的声明应该是用 lang="zh" 还是 lang="zh-cn"？</p>
</li>
<li>
<p>HTML标签嵌套规则</p>
</li>
<li>
<p>Mixed Content</p>
</li>
<li>
<p>禁止 <code>img</code> 的 <code>src</code> 取值为空</p>
</li>
<li>
<p>关于Apple设备私有的apple-touch-icon属性详解</p>
</li>
<li>
<p>不要使用@import</p>
</li>
<li>
<p>避免过度重排</p>
</li>
</ul><br><br>
来源：https://www.cnblogs.com/qls-blog/p/16943585.html

頁: [1]

琼殿技术论坛's Archiver

前端开发规范