indent

--fix命令行上的选项可以自动修复一些被这条规则反映的问题。

有几个通用的指导方针需要嵌套块和语句的特定缩进,如:

function hello(indentSize, type) {
    if (indentSize === 4 && type !== 'tab') {
        console.log('Each next indentation will increase on 4 spaces');
    }
}

这些是不同风格指南中推荐的最常见方案:

  • 两个空格,不再是标签:Google,npm,Node.js,Idiomatic,Felix
  • 标签:jQuery
  • 四个空间:克罗克福德

规则细节

此规则强制执行一致的缩进样式。默认样式是4 spaces

选项

这条规则有一个混合选项:

例如,对于2格缩进:

{
    "indent": ["error", 2]
}

或者用于制表符缩进:

{
    "indent": ["error", "tab"]
}

此规则的默认选项的代码错误示例:

/*eslint indent: "error"*/

if (a) {
  b=c;
  function foo(d) {
    e=f;
  }
}

具有默认选项的此规则的正确代码示例:

/*eslint indent: "error"*/

if (a) {
    b=c;
    function foo(d) {
        e=f;
    }
}

该规则有一个对象选项:

  • "SwitchCase"(默认:0)强制缩进级别case的条款switch声明
  • "VariableDeclarator"(默认值:1)为var声明者执行缩进级别; 也可以采取一个目的是定义单独的规则varletconst声明。
  • "outerIIFEBody" (默认值:1)对文件级IIFE执行缩进级别。
  • "MemberExpression"(默认值:1)对多行属性链执行缩进级别。这也可以设置为"off"禁用检查MemberExpression缩进。
  • "FunctionDeclaration" 需要一个对象来定义函数声明的规则。
    • parameters(默认值:1)为函数声明中的参数实施缩进级别。这可以是指示缩进级别的数字,也可以是指示"first"声明的所有参数必须与第一个参数对齐的字符串。这也可以设置为"off"禁止检查FunctionDeclaration参数。
    • body (默认值:1)为函数声明的主体强制实施缩进级别。
  • "FunctionExpression" 需要一个对象来定义函数表达式的规则。
    • parameters(默认值:1)对函数表达式中的参数执行缩进级别。这可以是表示缩进级别的数字,也可以是表示"first"表达式的所有参数必须与第一个参数对齐的字符串。这也可以设置为"off"禁止检查FunctionExpression参数。
    • body (默认值:1)为函数表达式的主体执行缩进级别。
  • "CallExpression" 需要一个对象来定义函数调用表达式的规则。
    • arguments(默认值:1)为调用表达式中的参数实施缩进级别。这可以是表示缩进级别的数字,也可以是表示"first"表达式的所有参数都必须与第一个参数对齐的字符串。这也可以设置为"off"禁止检查CallExpression参数。
  • "ArrayExpression"(默认值:1)对数组中的元素执行缩进级别。它也可以设置为字符串"first",表示数组中的所有元素都应该与第一个元素对齐。这也可以设置为"off"禁止检查数组元素。
  • "ObjectExpression"(默认值:1)对对象中的属性执行缩进级别。它可以设置为字符串"first",表示对象中的所有属性都应该与第一个属性对齐。这也可以设置为"off"禁用对象属性的检查。
  • "ImportDeclaration"(默认值:1)为导入语句执行缩进级别。它可以设置为字符串"first",表示模块中的所有导入成员应与列表中的第一个成员对齐。这也可以设置为"off"禁用检查导入的模块成员。
  • "flatTernaryExpressions": truefalse默认情况下)不需要对嵌套在其他三元表达式中的三元表达式进行缩进。
  • ignoredNodes接受一系列选择器。如果AST节点与任何选择器相匹配,那么该节点的直接子节点的标记缩进将被忽略。如果您不同意为特定语法模式强制实施的缩进,则可以将其用作放松规则的逃生线。

缩进级别表示指定缩进的倍数。例:

  • VariableDeclarator设置为4的空格2缩进将使用8个空格缩进多行变量声明。
  • VariableDeclarator设置为2的空格2缩进将使用4个空格缩进多行变量声明。
  • VariableDeclarator设置为2的空格的{"var": 2, "let": 2, "const": 3}缩进将缩进多行变量声明,其中4个空格用于varlet6个空格用于const语句。
  • 缩进VariableDeclarator设置为的选项卡2将使用2个选项卡缩进多行变量声明。
  • SwitchCase设置为2的空格的0缩进不会缩减case语句方面的子句switch
  • SwitchCase设置为2的空格的1缩进将case针对switch语句使用2个空格缩进子句。
  • SwitchCase设置为2的空格的2缩进将case针对switch语句缩进4个空格的子句。
  • SwitchCase设置为的缩进选项卡2将缩进case关于switch语句的2个选项卡的子句。
  • MemberExpression设置为2的空格的0缩进将使用0空格缩进多行属性链。
  • MemberExpression设置为2的空格的缩进将使用2个空格1缩进多行属性链。
  • MemberExpression设置为2的空格的2缩进将使用4个空格缩进多行属性链。
  • MemberExpression设置为4的空格0缩进将使用0空格缩进多行属性链。
  • MemberExpression设置为4的空格缩进将使用4个空格1缩进多行属性链。
  • MemberExpression设置为4的空格2缩进将使用8个空格缩进多行属性链。

标签

此规则的错误代码示例包含以下"tab"选项:

/*eslint indent: ["error", "tab"]*/

if (a) {
     b=c;
function foo(d) {
           e=f;
 }
}

此规则的正确代码示例包含以下"tab"选项:

/*eslint indent: ["error", "tab"]*/

if (a) {
/*tab*/b=c;
/*tab*/function foo(d) {
/*tab*//*tab*/e=f;
/*tab*/}
}

SwitchCase

此规则的代码错误代码示例2, { "SwitchCase": 1 }如下:

/*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/

switch(a){
case "a":
    break;
case "b":
    break;
}

此规则的正确代码示例包含以下2, { "SwitchCase": 1 }选项:

/*eslint indent: ["error", 2, { "SwitchCase": 1 }]*/

switch(a){
  case "a":
    break;
  case "b":
    break;
}

VariableDeclarator

此规则的代码错误代码示例2, { "VariableDeclarator": 1 }如下:

/*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
/*eslint-env es6*/

var a,
    b,
    c;
let a,
    b,
    c;
const a = 1,
    b = 2,
    c = 3;

此规则的正确代码示例包含以下2, { "VariableDeclarator": 1 }选项:

/*eslint indent: ["error", 2, { "VariableDeclarator": 1 }]*/
/*eslint-env es6*/

var a,
  b,
  c;
let a,
  b,
  c;
const a = 1,
  b = 2,
  c = 3;

此规则的正确代码示例包含以下2, { "VariableDeclarator": 2 }选项:

/*eslint indent: ["error", 2, { "VariableDeclarator": 2 }]*/
/*eslint-env es6*/

var a,
    b,
    c;
let a,
    b,
    c;
const a = 1,
    b = 2,
    c = 3;

此规则的正确代码示例包含以下2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }选项:

/*eslint indent: ["error", 2, { "VariableDeclarator": { "var": 2, "let": 2, "const": 3 } }]*/
/*eslint-env es6*/

var a,
    b,
    c;
let a,
    b,
    c;
const a = 1,
      b = 2,
      c = 3;

outerIIFEBody

此规则的代码错误代码示例2, { "outerIIFEBody": 0 }如下:

/*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/

(function() {

  function foo(x) {
    return x + 1;
  }

})();


if(y) {
console.log('foo');
}

此规则的正确代码示例包含以下选项2, {"outerIIFEBody": 0}

/*eslint indent: ["error", 2, { "outerIIFEBody": 0 }]*/

(function() {

function foo(x) {
  return x + 1;
}

})();


if(y) {
   console.log('foo');
}

MemberExpression

此规则的代码错误代码示例2, { "MemberExpression": 1 }如下:

/*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/

foo
.bar
.baz()

此规则的正确代码示例包含以下2, { "MemberExpression": 1 }选项:

/*eslint indent: ["error", 2, { "MemberExpression": 1 }]*/

foo
  .bar
  .baz();

FunctionDeclaration

此规则的错误代码示例包含以下2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }选项:

/*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/

function foo(bar,
  baz,
  qux) {
    qux();
}

此规则的正确代码示例包含以下2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }选项:

/*eslint indent: ["error", 2, { "FunctionDeclaration": {"body": 1, "parameters": 2} }]*/

function foo(bar,
    baz,
    qux) {
  qux();
}

此规则的错误代码示例包含以下2, { "FunctionDeclaration": {"parameters": "first"} }选项:

/*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/

function foo(bar, baz,
  qux, boop) {
  qux();
}

此规则的正确代码示例包含以下2, { "FunctionDeclaration": {"parameters": "first"} }选项:

/*eslint indent: ["error", 2, {"FunctionDeclaration": {"parameters": "first"}}]*/

function foo(bar, baz,
             qux, boop) {
  qux();
}

FunctionExpression

此规则的错误代码示例包含以下2, { "FunctionExpression": {"body": 1, "parameters": 2} }选项:

/*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/

var foo = function(bar,
  baz,
  qux) {
    qux();
}

此规则的正确代码示例包含以下2, { "FunctionExpression": {"body": 1, "parameters": 2} }选项:

/*eslint indent: ["error", 2, { "FunctionExpression": {"body": 1, "parameters": 2} }]*/

var foo = function(bar,
    baz,
    qux) {
  qux();
}

此规则的错误代码示例包含以下2, { "FunctionExpression": {"parameters": "first"} }选项:

/*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/

var foo = function(bar, baz,
  qux, boop) {
  qux();
}

此规则的正确代码示例包含以下2, { "FunctionExpression": {"parameters": "first"} }选项:

/*eslint indent: ["error", 2, {"FunctionExpression": {"parameters": "first"}}]*/

var foo = function(bar, baz,
                   qux, boop) {
  qux();
}

CallExpression

此规则的错误代码示例包含以下2, { "CallExpression": {"arguments": 1} }选项:

/*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/

foo(bar,
    baz,
      qux
);

此规则的正确代码示例包含以下2, { "CallExpression": {"arguments": 1} }选项:

/*eslint indent: ["error", 2, { "CallExpression": {"arguments": 1} }]*/

foo(bar,
  baz,
  qux
);

此规则的错误代码示例包含以下2, { "CallExpression": {"arguments": "first"} }选项:

/*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/

foo(bar, baz,
  baz, boop, beep);

此规则的正确代码示例包含以下2, { "CallExpression": {"arguments": "first"} }选项:

/*eslint indent: ["error", 2, {"CallExpression": {"arguments": "first"}}]*/

foo(bar, baz,
    baz, boop, beep);

ArrayExpression

此规则的错误代码示例包含以下2, { "ArrayExpression": 1 }选项:

/*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/

var foo = [
    bar,
baz,
      qux
];

此规则的正确代码示例包含以下2, { "ArrayExpression": 1 }选项:

/*eslint indent: ["error", 2, { "ArrayExpression": 1 }]*/

var foo = [
  bar,
  baz,
  qux
];

此规则的错误代码示例包含以下2, { "ArrayExpression": "first" }选项:

/*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/

var foo = [bar,
  baz,
  qux
];

此规则的正确代码示例包含以下2, { "ArrayExpression": "first" }选项:

/*eslint indent: ["error", 2, {"ArrayExpression": "first"}]*/

var foo = [bar,
           baz,
           qux
];

ObjectExpression

此规则的错误代码示例包含以下2, { "ObjectExpression": 1 }选项:

/*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/

var foo = {
    bar: 1,
baz: 2,
      qux: 3
};

此规则的正确代码示例包含以下2, { "ObjectExpression": 1 }选项:

/*eslint indent: ["error", 2, { "ObjectExpression": 1 }]*/

var foo = {
  bar: 1,
  baz: 2,
  qux: 3
};

此规则的错误代码示例包含以下2, { "ObjectExpression": "first" }选项:

/*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/

var foo = { bar: 1,
  baz: 2 };

此规则的正确代码示例包含以下2, { "ObjectExpression": "first" }选项:

/*eslint indent: ["error", 2, {"ObjectExpression": "first"}]*/

var foo = { bar: 1,
            baz: 2 };

ImportDeclaration

此规则的正确代码示例4, { "ImportDeclaration": 1 }(缺省值):

/*eslint indent: ["error", 4, { ImportDeclaration: 1 }]*/

import { foo,
    bar,
    baz,
} from 'qux';

import {
    foo,
    bar,
    baz,
} from 'qux';

此规则的错误代码示例包含以下4, { ImportDeclaration: "first" }选项:

/*eslint indent: ["error", 4, { ImportDeclaration: "first" }]*/

import { foo,
    bar,
    baz,
} from 'qux';

此规则的正确代码示例包含以下4, { ImportDeclaration: "first" }选项:

/*eslint indent: ["error", 4, { ImportDeclaration: "first" }]*/

import { foo,
         bar,
         baz,
} from 'qux';

flatTernaryExpressions

此规则的默认代码错误代码示例4, { "flatTernaryExpressions": false }

/*eslint indent: ["error", 4, { "flatTernaryExpressions": false }]*/

var a =
    foo ? bar :
    baz ? qux :
    boop;

具有默认选项的此规则的正确代码示例4, { "flatTernaryExpressions": false }

/*eslint indent: ["error", 4, { "flatTernaryExpressions": false }]*/

var a =
    foo ? bar :
        baz ? qux :
            boop;

此规则的错误代码示例包含以下4, { "flatTernaryExpressions": true }选项:

/*eslint indent: ["error", 4, { "flatTernaryExpressions": true }]*/

var a =
    foo ? bar :
        baz ? qux :
            boop;

此规则的正确代码示例包含以下4, { "flatTernaryExpressions": true }选项:

/*eslint indent: ["error", 4, { "flatTernaryExpressions": true }]*/

var a =
    foo ? bar :
    baz ? qux :
    boop;

ignoredNodes

以下配置忽略ConditionalExpression(“三元表达式”)节点的缩进:

此规则的正确代码示例包含以下4, { "ignoredNodes": ["ConditionalExpression"] }选项:

/*eslint indent: ["error", 4, { "ignoredNodes": ["ConditionalExpression"] }]*/

var a = foo
      ? bar
      : baz;

var a = foo
                ? bar
: baz;

以下配置忽略了IIFE主体中的缩进。

此规则的正确代码示例包含以下4, { "ignoredNodes": ["CallExpression > FunctionExpression.callee > BlockStatement.body"] }选项:

/*eslint indent: ["error", 4, { "ignoredNodes": ["CallExpression > FunctionExpression.callee > BlockStatement.body"] }]*/

(function() {

foo();
bar();

})

Compatibility

该规则在ESLint 0.14.0中引入。

资源

扫码关注云+社区

领取腾讯云代金券