孟州网站制作【孟州网站优化】孟州建网站、孟州微信公众号运营、孟州网页设计、孟州微信小程序商城

孟州市，隶属河南省焦作市，为焦作市代管县级市。地处河南省西北部，北依太行，南滨黄河，地理坐标东经112°33’— 112°55’，北纬34°50’— 35°02’。总面积541.6平方公里，辖4个街道、6个镇、1个乡，现有人口40万。

孟州是“唐宋八大家”之首韩愈的故里，1996年撤县设市。主要旅游景点有：韩园、老家莫沟、黄河湿地、古城湖、白墙水库、金山寺、滨河公园等。特产有：四大怀药（地黄、山药、菊花、牛膝）、苹果、羊剪绒及制品、麦草画、澄泥砚、文公砚。特色小吃有：孟州烧饼、孟州炒面、孟州糖饼、孟州烩面、混浆绿豆凉粉、西沃卤肉、浆面条等。

2019年，孟州市完成地区生产总值完373.5亿元，增长8.2%。其中：第一产业增加值22.9亿元，增长4.2%；第二产业增加值250.4亿元，增长9.0%；第三产业增加值100.2亿元，增长6.9%。人均生产总值99383元，同比增长7.6%。三次产业结构为6.1：67.1：26.8。 [1] 

2020年11月13日，入选2020年“中国工业百强县”名单。 [2] 

编程风格

1. 块级作用域

2. 字符串

3. 解构赋值

4. 对象

5. 数组

6. 函数

7. Map 结构

8. Class

9. 模块

10. ESLint 的使用

本章探讨如何将 ES6 的新语法，运用到编码实践之中，与传统的 JavaScript 语法结合在一起，写出合理的、易于阅读和维护的代码。

多家公司和组织已经公开了它们的风格规范，下面的内容主要参考了 Airbnb 公司的 JavaScript 风格规范。

块级作用域

（1）let 取代 var

ES6 提出了两个新的声明变量的命令：let和const。其中，let完全可以取代var，因为两者语义相同，而且let没有副作用。

'use strict';if (true) {
  let x = 'hello';}for (let i = 0; i < 10; i++) {
  console.log(i);}

上面代码如果用var替代let，实际上就声明了两个全局变量，这显然不是本意。变量应该只在其声明的代码块内有效，var命令做不到这一点。

var命令存在变量提升效用，let命令没有这个问题。

'use strict';if (true) {
  console.log(x); // ReferenceError  let x = 'hello';}

上面代码如果使用var替代let，console.log那一行就不会报错，而是会输出undefined，因为变量声明提升到代码块的头部。这违反了变量先声明后使用的原则。

所以，建议不再使用var命令，而是使用let命令取代。

（2）全局常量和线程安全

在let和const之间，建议优先使用const，尤其是在全局环境，不应该设置变量，只应设置常量。

const优于let有几个原因。一个是const可以提醒阅读程序的人，这个变量不应该改变；另一个是const比较符合函数式编程思想，运算不改变值，只是新建值，而且这样也有利于将来的分布式运算；最后一个原因是 JavaScript 编译器会对const进行优化，所以多使用const，有利于提高程序的运行效率，也就是说let和const的本质区别，其实是编译器内部的处理不同。

// badvar a = 1, b = 2, c = 3;// goodconst a = 1;const b = 2;const c = 3;// bestconst [a, b, c] = [1, 2, 3];

const声明常量还有两个好处，一是阅读代码的人立刻会意识到不应该修改这个值，二是防止了无意间修改变量值所导致的错误。

所有的函数都应该设置为常量。

长远来看，JavaScript 可能会有多线程的实现（比如 Intel 公司的 River Trail 那一类的项目），这时let表示的变量，只应出现在单线程运行的代码中，不能是多线程共享的，这样有利于保证线程安全。

字符串

静态字符串一律使用单引号或反引号，不使用双引号。动态字符串使用反引号。

// badconst a = "foobar";const b = 'foo' + a + 'bar';// acceptableconst c = `foobar`;// goodconst a = 'foobar';const b = `foo${a}bar`;

解构赋值

使用数组成员对变量赋值时，优先使用解构赋值。

const arr = [1, 2, 3, 4];// badconst first = arr[0];const second = arr[1];// goodconst [first, second] = arr;

函数的参数如果是对象的成员，优先使用解构赋值。

// badfunction getFullName(user) {
  const firstName = user.firstName;
  const lastName = user.lastName;}// goodfunction getFullName(obj) {
  const { firstName, lastName } = obj;}// bestfunction getFullName({ firstName, lastName }) {}

如果函数返回多个值，优先使用对象的解构赋值，而不是数组的解构赋值。这样便于以后添加返回值，以及更改返回值的顺序。

// badfunction processInput(input) {
  return [left, right, top, bottom];}// goodfunction processInput(input) {
  return { left, right, top, bottom };}const { left, right } = processInput(input);

对象

单行定义的对象，最后一个成员不以逗号结尾。多行定义的对象，最后一个成员以逗号结尾。

// badconst a = { k1: v1, k2: v2, };const b = {
  k1: v1,
  k2: v2};// goodconst a = { k1: v1, k2: v2 };const b = {
  k1: v1,
  k2: v2,};

对象尽量静态化，一旦定义，就不得随意添加新的属性。如果添加属性不可避免，要使用Object.assign方法。

// badconst a = {};a.x = 3;// if reshape unavoidableconst a = {};Object.assign(a, { x: 3 });// goodconst a = { x: null };a.x = 3;

如果对象的属性名是动态的，可以在创造对象的时候，使用属性表达式定义。

// badconst obj = {
  id: 5,
  name: 'San Francisco',};obj[getKey('enabled')] = true;// goodconst obj = {
  id: 5,
  name: 'San Francisco',
  [getKey('enabled')]: true,};

上面代码中，对象obj的最后一个属性名，需要计算得到。这时最好采用属性表达式，在新建obj的时候，将该属性与其他属性定义在一起。这样一来，所有属性就在一个地方定义了。

另外，对象的属性和方法，尽量采用简洁表达法，这样易于描述和书写。

var ref = 'some value';// badconst atom = {
  ref: ref,

  value: 1,

  addValue: function (value) {
    return atom.value + value;
  },};// goodconst atom = {
  ref,

  value: 1,

  addValue(value) {
    return atom.value + value;
  },};

数组

使用扩展运算符（...）拷贝数组。

// badconst len = items.length;const itemsCopy = [];let i;for (i = 0; i < len; i++) {
  itemsCopy[i] = items[i];}// goodconst itemsCopy = [...items];

使用 Array.from 方法，将类似数组的对象转为数组。

const foo = document.querySelectorAll('.foo');const nodes = Array.from(foo);

函数

立即执行函数可以写成箭头函数的形式。

(() => {
  console.log('Welcome to the Internet.');})();

那些使用匿名函数当作参数的场合，尽量用箭头函数代替。因为这样更简洁，而且绑定了 this。

// bad[1, 2, 3].map(function (x) {
  return x * x;});// good[1, 2, 3].map((x) => {
  return x * x;});// best[1, 2, 3].map(x => x * x);

箭头函数取代Function.prototype.bind，不应再用 self/_this/that 绑定 this。

// badconst self = this;const boundMethod = function(...params) {
  return method.apply(self, params);}// acceptableconst boundMethod = method.bind(this);// bestconst boundMethod = (...params) => method.apply(this, params);

简单的、单行的、不会复用的函数，建议采用箭头函数。如果函数体较为复杂，行数较多，还是应该采用传统的函数写法。

所有配置项都应该集中在一个对象，放在最后一个参数，布尔值不可以直接作为参数。

// badfunction divide(a, b, option = false ) {}// goodfunction divide(a, b, { option = false } = {}) {}

不要在函数体内使用 arguments 变量，使用 rest 运算符（...）代替。因为 rest 运算符显式表明你想要获取参数，而且 arguments 是一个类似数组的对象，而 rest 运算符可以提供一个真正的数组。

// badfunction concatenateAll() {
  const args = Array.prototype.slice.call(arguments);
  return args.join('');}// goodfunction concatenateAll(...args) {
  return args.join('');}

使用默认值语法设置函数参数的默认值。

// badfunction handleThings(opts) {
  opts = opts || {};}// goodfunction handleThings(opts = {}) {
  // ...}

Map 结构

注意区分 Object 和 Map，只有模拟现实世界的实体对象时，才使用 Object。如果只是需要key: value的数据结构，使用 Map 结构。因为 Map 有内建的遍历机制。

let map = new Map(arr);for (let key of map.keys()) {
  console.log(key);}for (let value of map.values()) {
  console.log(value);}for (let item of map.entries()) {
  console.log(item[0], item[1]);}

Class

总是用 Class，取代需要 prototype 的操作。因为 Class 的写法更简洁，更易于理解。

// badfunction Queue(contents = []) {
  this._queue = [...contents];}Queue.prototype.pop = function() {
  const value = this._queue[0];
  this._queue.splice(0, 1);
  return value;}// goodclass Queue {
  constructor(contents = []) {
    this._queue = [...contents];
  }
  pop() {
    const value = this._queue[0];
    this._queue.splice(0, 1);
    return value;
  }}

使用extends实现继承，因为这样更简单，不会有破坏instanceof运算的危险。

// badconst inherits = require('inherits');function PeekableQueue(contents) {
  Queue.apply(this, contents);}inherits(PeekableQueue, Queue);PeekableQueue.prototype.peek = function() {
  return this._queue[0];}// goodclass PeekableQueue extends Queue {
  peek() {
    return this._queue[0];
  }}

模块

首先，Module 语法是 JavaScript 模块的标准写法，坚持使用这种写法。使用import取代require。

// badconst moduleA = require('moduleA');const func1 = moduleA.func1;const func2 = moduleA.func2;// goodimport { func1, func2 } from 'moduleA';

使用export取代module.exports。

// commonJS的写法var React = require('react');var Breadcrumbs = React.createClass({
  render() {
    return <nav />;
  }});module.exports = Breadcrumbs;// ES6的写法import React from 'react';class Breadcrumbs extends React.Component {
  render() {
    return <nav />;
  }};export default Breadcrumbs;

如果模块只有一个输出值，就使用export default，如果模块有多个输出值，就不使用export default，export default与普通的export不要同时使用。

不要在模块输入中使用通配符。因为这样可以确保你的模块之中，有一个默认输出（export default）。

// badimport * as myObject from './importModule';// goodimport myObject from './importModule';

如果模块默认输出一个函数，函数名的首字母应该小写。

function makeStyleGuide() {}export default makeStyleGuide;

如果模块默认输出一个对象，对象名的首字母应该大写。

const StyleGuide = {
  es6: {
  }};export default StyleGuide;

ESLint 的使用

ESLint 是一个语法规则和代码风格的检查工具，可以用来保证写出语法正确、风格统一的代码。

首先，在项目的根目录安装 ESLint。

$ npm install --save-dev eslint

然后，安装 Airbnb 语法规则，以及 import、a11y、react 插件。

$ npm install --save-dev eslint-config-airbnb
$ npm install --save-dev eslint-plugin-import eslint-plugin-jsx-a11y eslint-plugin-react

最后，在项目的根目录下新建一个.eslintrc文件，配置 ESLint。

{
  "extends": "eslint-config-airbnb"}

现在就可以检查，当前项目的代码是否符合预设的规则。

index.js文件的代码如下。

var unused = 'I have no purpose!';function greet() {
    var message = 'Hello, World!';
    console.log(message);}greet();

使用 ESLint 检查这个文件，就会报出错误。

$ npx eslint index.js
index.js  1:1  error  Unexpected var, use let or const instead          no-var  1:5  error  unused is defined but never used                 no-unused-vars  4:5  error  Expected indentation of 2 characters but found 4  indent  4:5  error  Unexpected var, use let or const instead          no-var  5:5  error  Expected indentation of 2 characters but found 4  indent

✖ 5 problems (5 errors, 0 warnings)

上面代码说明，原文件有五个错误，其中两个是不应该使用var命令，而要使用let或const；一个是定义了变量，却没有使用；另外两个是行首缩进为 4 个空格，而不是规定的 2 个空格。

孟州网站制作【孟州网站优化】孟州建网站、孟州微信公众号运营、孟州网页设计、孟州微信小程序商城