@getify/eslint-plugin-proper-ternary

中文文档
3.1.1发布于 2021/04/27MITCommonJS零依赖近 30 天下载 3.8万

ESLint规则,以确保适当使用三重/有条件表达式

中文使用文档
文档目录19 节
  1. 概览
  2. 启用插件
  3. extends
  4. .eslintrc.json
  5. package.json
  6. ESLint CLI 参数
  7. ESLint 节点 API
  8. 内含注释
  9. 规则: "nested"
  10. 规则配置
  11. 规则: "parens"
  12. 规则配置
  13. 规则: "where"
  14. 规则配置
  15. npm 软件包
  16. 构建
  17. 测试
  18. 测试范围
  19. 许可证

ESLint 插件: 正版

Build Status npm Module Dependencies devDependencies Coverage Status

概览

这个 正规 ESLint 插件提供了控制定义的规则 ? : 有条件的表达式(aka,"ternary servery"),将其限制在更窄和更合适的/可读的形式.

此插件中定义的规则 :

  • "nested":控制巢穴 ? : 三角表达式.

  • "parens": 需要环绕 ( .. ) 括号内为文字表述条款中特定种类的表述.

  • "where":在程序结构trinary表达式中可以使用的地方限制:禁止将它们作为独立语句,对象属性,参数等.

启用插件

用于 正规,将它作为插件加载到 ESLint 中,并按要求配置规则.

extends

如果你愿意的话 正规 在推荐配置预设中的插件,您可以在 extends 选项,并选择名称预设 :

"extends": [
    // ..
    "plugin:@getify/proper-ternary/CONFIG-PRESET-NAME",
    // ..
]

说明: 所有包含的配置预设不仅定义了特定的规则配置,而且还自动加载了插件本身,所以您 别 需要列出 正规 输入 plugins 条款.

可用配置预设从 :

  • getify-says:这是我的个人配置. 见 预设定义。 。 。 .

  • .

需要注意的是,在配置中仍然可以推翻任何预设的规则定义. 将这些预设视为仍然可以定制的便利"默认".

.eslintrc.json

通过本地或全局装入插件并启用其规则 .eslintrc.json 配置文件 :

"plugins": [
    "@getify/proper-ternary"
],
"rules": {
    "@getify/proper-ternary/nested": "error",
    "@getify/proper-ternary/parens": "error",
    "@getify/proper-ternary/where": "error"
}

package.json

通过工程加载插件并启用其规则 package.json数字 :

"eslintConfig": {
    "plugins": [
        "@getify/proper-ternary"
    ],
    "rules": {
        "@getify/proper-ternary/nested": "error",
        "@getify/proper-ternary/parens": "error",
        "@getify/proper-ternary/where": "error"
    }
}

ESLint CLI 参数

要通过 ESLint CLI 参数加载插件并启用其规则,请使用 --plugin 财务报告和审定财务报表 --rule 旗帜 :

eslint .. --plugin='@getify/proper-ternary' --rule='@getify/proper-ternary/nested: error' ..
eslint .. --plugin='@getify/proper-ternary' --rule='@getify/proper-ternary/parens: error' ..
eslint .. --plugin='@getify/proper-ternary' --rule='@getify/proper-ternary/where: error' ..

ESLint 节点 API

要使用带有 ESLint API 的节点.js 插件, 需要 npm 模块, 然后( 例如) 将规则的定义传递到 Linter#defineRule(..),类似于:

var properTernary = require("@getify/eslint-plugin-proper-ternary");

// ..

var eslinter = new (require("eslint").Linter)();

eslinter.defineRule("@getify/proper-ternary/nested",properTernary.rules.nested);

eslinter.defineRule("@getify/proper-ternary/parens",properTernary.rules.parens);

eslinter.defineRule("@getify/proper-ternary/where",properTernary.rules.where);

然后输入一些代码 这样:

eslinter.verify(".. some code ..",{
    rules: {
        "@getify/proper-ternary/nested": "error",
        "@getify/proper-ternary/parens": "error",
        "@getify/proper-ternary/where": "error"
    }
});

内含注释

一旦插件被装入,该规则可以任意使用内置代码注释来配置,例如:

/* eslint "@getify/proper-ternary/nested": "error" */
/* eslint "@getify/proper-ternary/parens": "error" */
/* eslint "@getify/proper-ternary/where": "error" */

规则: "nested"

这个 正规编号 :筑巢 规则控制巢穴 ? : 三角表达式.

将这项规则:

"@getify/proper-ternary/nested": "error"

本条规则的主要目的是避免为下列目的造成可读性损害: ? : 与混淆了其他毒性表达式的嵌入相通的毒性表达. 通过禁止混淆的筑巢,读者可以更清楚地理解三角星会带来什么.

例如:

var name = userData ? userData.name : "-empty-";

这种毒性表达法没有其他的毒性表达法嵌入其中. 更清楚地知道它的行为会是什么. 因此 正规编号 :筑巢 规则不会报告任何错误.

默认情况下, 禁止三角表达式筑巢 在所有三个三重表达式条款中,而筑巢深度进一步限制在一等. 因此,本规则 将 默认为 报告错误 每一发言:

var name =
    (typeof isLoggedIn == "function" ? isLoggedIn() : false)
        ? userData.name
        : "-empty-";

var email =
    userData != null
        ? (userData.email != "" ? userData.email : "[email protected]")
        : "-empty-";

var accountType =
    userData.type == 1 ? "admin" :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor" :
    "customer";

这个 name 任务语句在外立方语表达式的"测试"条款内有ternary表达式. 这个 email 指派语句在外立方表达式的"当时"(aka "econd")条款内嵌入了ternary表达式. 这个 accountType 指定语句在它们的外立体表达式的"else"(aka "talnate")条款中嵌入了ternary表达式. 此外 accountType 任务语句有 双层筑巢,而 name 财务报告和审定财务报表 email 任务语句各有三进制表达式 一级巢穴。 。 。 .

允许在特定条款中筑巢("test", (中文(简体) ), "then",以及 "else"),必须配置该条款类型。 为了让巢穴超过一个水平 "depth" 必须增加配置.

规则配置

这个 正规编号 :筑巢 规则可以配置为这些模式的各种组合:

  • "test" (默认 : false)允许在另一个ternary表达式的"测试"条款中嵌入一个ternary表达式.

  • "then" (默认 : false)允许在"当时"(aka,"相继")条款中嵌入了另一个ternary表达式.

  • "else" (默认 : false)允许在"else"(aka,"alternate")条款中嵌入了另一种ternary表达式.

  • "depth" (默认 : 1)控制了允许几级的ternary表达式筑巢. 要有效使用此选项, 您必须至少启用其中之一 "test" 编号 : "then" 编号 : "else" 条款模式.

说明: 这一规则不考虑结构可读性,如白空间或括号(见 "parens" 规则),只有筑巢的结构问题.

规则 "nested" 配置:条款

要配置 "test", (中文(简体) ), "then",或 "else" 规则模式( 每个默认 : false:

"@getify/proper-ternary/nested": [ "error", { "test": true, "then": true, "else": true }

每项条款必须明确允许在条款中允许嵌入式三角表达式。 将所有三种条款类型都禁用,从而有效地禁用所有毒性表达式嵌入.

"test" 缠绕

若为 "test" 模式已启用,在 测试 条款看起来是这样:

var name =
    (typeof isLoggedIn == "function" ? isLoggedIn() : false)
        ? userData.name
        : "-empty-";

这种形式相当于相当尴尬的:

var name;
if (
    (typeof isLoggedIn == "function" || false) && isLoggedIn()
) {
    name = userData.name;
}
else {
    name = "-empty-";
}

令人尴尬/困惑的布尔逻辑在这里 if..else 等同形式建议更简单的逻辑结构:

var name;
if (typeof isLoggedIn == "function" && isLoggedIn()) {
    name = userData.name;
}
else {
    name = "-empty-";
}

虽然这个逻辑当然更合理,但它说明了为什么在.. 测试 条款比较罕见,因为首先基本上不需要附加条件:

var name =
    (typeof isLoggedIn == "function" && isLoggedIn())
        ? userData.name
        : "-empty-";

在此情况下,偏好三角表达形式的主要原因,而不是 if..else 形式,就是在后一种形式中,更清楚的是,有一个变量 name 被指定为两个值之一。 与 if..else 形式,有两个独立的任务,所以这个细节略为不那么明显.

"then" 缠绕

如果 "then" 模式被启用,在 接下来 在另一个三边表达式中,它看起来像:

var email =
    userData != null
        ? (userData.email != "" ? userData.email : "[email protected]")
        : "-empty-";

这种形式,显然有一个单变量 email 被分配。 这个 if..else 等量:

var email;
if (userData != null) {
    if (userData.email != "") {
        email = userData.email;
    }
    else {
        email = "[email protected]";
    }
}
else {
    email = "-empty-";
}

在这种形式下,单项转让(包含三个值之一)略为不明显. 一般来说,在这样的情况下,更倾向于使用前一种毒性表达式,作为比较容易读取的形式.

"else" 缠绕

如果 "else" 模式已启用,在 其他情况 另一种毒性表达式中,另一个毒性表达式中的条款可能是最可读的:

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor"  :
    "customer";

这种形式,相当清楚的是,有一个变量 accountType 被指定为四个值中的一个,基于三个特定的比较,第四个值是默认“else”值.

动词越多 if..else if 等量:

var accountType;
if (userData.type == 1) {
    accountType = "admin";
}
else if (userData.type == 2) {
    accountType = "manager";
}
else if (userData.type == 3) {
    accountType = "vendor";
}
else {
    accountType = "customer";
}

单变量( E)accountType) 分配在这种形式上略显少了一点,而为了达到同样的结果,会有更多的合成噪音. 因此,三角表达形式可能更可取一些.

规则 "nested" 配置 : "depth"

配置此规则模式( 默认 ): 1:

"@getify/proper-ternary/nested": [ "error", { "depth": 1 } ]

如果有的话 "test" 编号 : "then" 编号 : "else" 模式 在启用时,您也可以控制有多少个三进制表达式与 "depth" 设置.

例如, 默认情况下, 此规则模式不会报告此三进制表达式的任何错误 :

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    "customer";

筑巢水平是 1 (在第二个/最外端的表达式内).

相比之下,这个规则模式 将 默认报告错误:

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor"  :
    "customer";

这里,筑巢水平是 2 (在第三个/最外端的表达式内),因此默认的巢穴水平为: 1 将造成错误,用于报告 userData.type == 3 ? .. 毒性表达式.

规则: "parens"

这个 正规编号 :参数 规则要求 ( .. ) 当各种表达式出现在任何三进制表达式的条款中时,用括号包围其类型.

将这项规则:

"@getify/proper-ternary/parens": "error"

本条规则的主要目的是避免为下列目的造成可读性损害: ? : 要求分解的毒性表达式 ( .. ) 任何条款的表达,如果该表达的边界不明显,例如操作员的关联性或优先性.

例如:

var total = 1 + base ? base * 2 : base * 3;

在不查看操作员优先级的情况下,读者可能无法确定 1 + 属于 测试 ,或者在三元解决后添加。 换句话说,这个例子可以合理地假定为:

var total = (1 + base) ? base * 2 : base * 3;

// OR

var total = 1 + (base ? base * 2 : base * 3);

哪个? 因为操作者优先,所以它是第一个(第1个)(1 + base) ? ..) (中文(简体) ). 但是这种模棱两可的模棱两可会真正损害可读性. 此外,当快速扫描代码时 base * 2 财务报告和审定财务报表 base * 3 表达式可以模糊 ? 财务报告和审定财务报表 : 运算符和条款边界.

考虑一个更可读的备选方案:

var total = (1 + base) ? (base * 2) : (base * 3);

是的,那个 ( .. ) 这是“不必要的”,但是它们确实消除了这些例子的模糊性。 应优先考虑这种可读性.

这个规则的默认行为是侵略性的,因为它需要用括号围住 所有条款表达式类型 (简单的识别符号/文学除外) 报告错误 每一条:

var total = base > 1 ? base * 2 : base * 3;

这个 base > 1 表达式是 比较 表达式,并且可以通过使 "comparison" 模式。 这个 base * 2 财务报告和审定财务报表 base * 3 表达式为 复数; 存在 此规则中没有模式 以禁用报告错误.

规则配置

这个 正规编号 :参数 规则可以配置为这些模式的任何组合,应用到表达式 任何条款 毒性表达式:

  • "ternary" (默认 : true) 需要一个嵌入式三角表达式 ( .. ) 围绕它.

  • "comparison" (默认 : true)需要一个比较表达式(即:, x == y, (中文(简体) ), x > y(d) 拥有 ( .. ) 围绕它.

  • "logical" (默认 : true)需要逻辑表达式(即:, x && y, (中文(简体) ), !x(d) 拥有 ( .. ) 围绕它.

  • "call" (默认 : true)需要调用表达式(即:, foo(), (中文(简体) ), new Foo()(d) 拥有 ( .. ) 围绕它.

  • "object" (默认 : true)需要一个对象或阵列字元(即:, {x:1}, (中文(简体) ), [1,2](d) 拥有 ( .. ) 围绕它.

  • "simple" (单位:千美元)默认 : false)需要一个简单的表达式(即, x, (中文(简体) ), x.y, (中文(简体) ), 42(d) 拥有 ( .. ) 围绕它。 很可能您想要保留此模式的禁用( 默认) .

说明: 这些模式未涵盖的任何表达式,例如 x + y,被视为 复数 表达式。 如果启用此规则, 复杂的表达式总是需要 ( .. ) 环绕着他们;没有 "complex" 模式来禁用它们。 原因:如果你觉得 x + y * z 足以表示不需要 ( .. ),那么你几乎肯定也倾向于禁用以上所有其它模式,在这种情况下,你应该完全禁用规则.

规则 "nested" 配置: 第三级

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/parens": [ "error", { "ternary": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var x = y ? z : w ? u : v;

为避免此错误, 使用 ( .. ) 环绕巢穴:

var x = y ? z : (w ? u : v);

规则 "nested" 配置: 比较

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/parens": [ "error", { "comparison": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var x = y > 3 ? y : z;

为避免此错误, 使用 ( .. ) 围绕比较表达式:

var x = (y > 3) ? y : z;

规则 "nested" 配置: 逻辑

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/parens": [ "error", { "logical": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var x = y && z ? y : z;

为避免此错误, 使用 ( .. ) 围绕逻辑表达式:

var x = (y && z) ? y : z;

规则 "nested" 配置: 调用

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/parens": [ "error", { "call": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var x = y ? foo(y,z) : z;

为避免此错误, 使用 ( .. ) 环绕呼叫表达式 :

var x = y ? ( foo(y,z) ) : z;

规则 "nested" 配置: 对象

说明: 此规则模式适用于两个阵列文字([1,2])和对象字节({x:1}) (中文(简体) ).

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/parens": [ "error", { "object": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var x = y ? [y,z] : z;

为避免此错误, 使用 ( .. ) 围绕数组或对象表达式:

var x = y ? ( [y,z] ) : z;

规则 "nested" 配置: 简单

说明: 很可能你会想要保持这个模式(默认),因为你不太可能需要 ( .. ) 连简单的标识符和原始字面符号都存在.

配置此规则模式 打开 (单位:千美元)关 默认 :

"@getify/proper-ternary/parens": [ "error", { "simple": true } ]

如果启用此模式, 它会报告每个条款的错误 :

var x = y ? w.u : 42;

为了避免这些错误,请使用 ( .. ) 围绕每个三元条款的表达式:

var x = (y) ? (w.u) : (42);

规则: "where"

这个 正规编号 :地点 规则限制在程序结构中可使用三角表达式的地方.

将这项规则:

"@getify/proper-ternary/where": "error"

这一规则的主要目的是避免程序在下列情况下的可读性损害: ? : 毒性表达式被滥用。 通过将ternary表达式限制于某些用法,ternary-forbend用法结构化使用更合适的语法/logic.

例如,一些强烈感觉的ternary表达式只应作为表达式(指有条件地选择一个值)使用,而不应作为诸如:

(isLoggedIn(user) && user.admin)
    ? renderAdminHeader()
    : renderBasicHeader();

这种构造可能令读者感到困惑,因为很容易错过任何一种的副作用 接下来 或者说 其他情况 条款。 比较可取的做法是使用独立的 if..else 语句 :

if (isLoggedIn(user) && user.admin) {
    renderAdminHeader();
}
else {
    renderBasicHeader();
}

这种情景正是 if..else 语句最合适; 滥用三进制表达式来保存几个字符无助于可读性.

另一个例子是:

var loginRecord = {
    name: userData.name,
    accountType: (
        userData.type == 1 ? "admin"   :
        userData.type == 2 ? "manager" :
        userData.type == 3 ? "vendor"  :
        "customer"
    )
};

这里在对象文字中正在使用三进制,但也许更可读的方法是通过可变转让首先选择值:

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor"  :
    "customer";

var loginRecord = {
    name: userData.name,
    accountType
};

函数调用时也会出现类似的情况:因为调用站点通常没有明显的名称,如果除了没有任何语义名称来描述取值选择之外,没有其他原因,以trinary表达式作为参数可能不太容易被读取. 在任务中先执行三元条件值选择,再通过被命名的变量作为参数,往往更好.

当ternary表达式是另一个表达式中的子表达式时,例如unary,读取代码也会更困难 ! 否定的表述如下:

var isAllowed = !(
    (userSession != null)
        ? userSession.user.accountType == "customer"
        : defaultAccountType == "vendor"
);

这里的间接否定逻辑更令读者困惑. 更好的办法:

var basicAccountType =
    (userSession != null)
        ? userSession.user.accountType == "customer"
        : defaultAccountType == "vendor";

var isAllowed = !basicAccountType;

通过对最终决定的结果进行命名(basicAccountType),否定语更清晰地理解.

当然,在这个例子中,ternary本身并非绝对必要,因为逻辑结构本来可以是:

var basicAccountType = (
    (userSession != null && userSession.user.accountType == "customer") ||
    (defaultAccountType == "vendor")
);

var isAllowed = !basicAccountType;

一些人更喜欢三元版本,另一些人则更喜欢这种非一元形式.

规则配置

这个 正规编号 :地点 规则可以配置为这些模式的任何组合 :

  • "statement" (默认 : true) 禁止单独表达式语句.

  • "property" (默认 : true) 禁止在对象字面属性分配或数组字面位置分配中出现三进制表达式.

  • "argument" (默认 : true) 禁止以三角表达式作为函数调用的参数.

  • "return" (默认 : true) 禁止以毒性表示a return 以及简洁的返回 => 箭头函数.

  • "default" (默认 : true)禁止默认值表达式(函数参数和去结构化模式)中的三进制表达式.

  • "sub" (默认 : true) 禁止以三进制表达式作为非二进制运算符表达式(即, 1 + (x ? y : z)) (中文(简体) ).

    说明: 此规则模式不控制嵌入到其他三元表达式中的三元表达式. 这点,请使用 "nested" 规则。 。 。 .

  • "assignment" (默认 : false(a) 禁止转让语句中(使用 = 运营商).

    说明: 与这里的其他规则模式不同的是,这种模式默认关闭,因为你不太可能想要禁用指派表达式中的ternary表达式(即:, x = y ? z : w因为这里基本上是最自然有用的地方 为了完整起见,它被包含在内,但如果你倾向于 打开这个规则模式, 你也许只是考虑 取消所有ternary表达 与内置 "无常"规则。 。 。 .

规则 "where" 配置: 声明

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "statement": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

(isLoggedIn(user) && user.admin)
    ? renderAdminHeader()
    : renderBasicHeader();

为了避免错误,请使用 if..else 语句改为:

if (isLoggedIn(user) && user.admin) {
    renderAdminHeader();
}
else {
    renderBasicHeader();
}

规则 "where" 配置: 属性

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "property": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var loginRecord = {
    name: userData.name,
    accountType: (
        userData.type == 1 ? "admin"   :
        userData.type == 2 ? "manager" :
        userData.type == 3 ? "vendor"  :
        "customer"
    )
};

为了避免错误,请使用 if..else 语句改为:

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor"  :
    "customer";

var loginRecord = {
    name: userData.name,
    accountType
};

规则 "where" 配置: 属性

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "property": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var loginRecord = {
    name: userData.name,
    accountType: (
        userData.type == 1 ? "admin"   :
        userData.type == 2 ? "manager" :
        userData.type == 3 ? "vendor"  :
        "customer"
    )
};

为了避免错误,请使用 if..else 语句改为:

var accountType =
    userData.type == 1 ? "admin"   :
    userData.type == 2 ? "manager" :
    userData.type == 3 ? "vendor"  :
    "customer";

var loginRecord = {
    name: userData.name,
    accountType
};

规则 "where" 配置: 参数

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "argument": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

checkAccount(
    (isLoggedIn(user) && user.admin) ? user : defaultUser
);

为了避免这个错误,首先将三进制表达式的结果指定给一个变量:

var accountToCheck =
    (isLoggedIn(user) && user.admin) ? user : defaultUser;

checkAccount(accountToCheck);

规则 "where" 配置: 返回

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "argument": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

function lookupAccount(userID = -1) {
    return (
        userID != -1 ? users[userID] : defaultUser
    );
}

为了避免这个错误,首先将三进制表达式的结果指定给一个变量:

function lookupAccount(userID = -1) {
    var user =
        userID != -1 ? users[userID] : defaultUser;

    return user;
}

规则 "where" 配置: 默认

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "default": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

function createUser(data,cb = data.adminUser ? onAdminUser : () => {}) {
    // ..
    cb(user);
}

为避免此错误, (重新) 手动指定变量 :

function createUser(data,cb) {
    cb =
        cb !== undefined ? cb          :
        data.adminUser   ? onAdminUser :
        () => {};

    // ..
    cb(user);
}

规则 "where" 配置: 子

关闭此规则模式( 默认情况下) :

"@getify/proper-ternary/where": [ "error", { "sub": false } ]

如果此模式已打开( 默认) , 它将报告错误 :

var isAllowed = !(
    (userSession != null)
        ? userSession.user.accountType == "customer"
        : defaultAccountType == "vendor"
);

为了避免这个错误,首先将三进制表达式的结果指定给一个变量:

var basicAccountType =
    (userSession != null)
        ? userSession.user.accountType == "customer"
        : defaultAccountType == "vendor";

var isAllowed = !basicAccountType;

规则 "where" 配置: 任务

说明: 您不太可能想要禁用指派表达式中的 ternary 表达式( e, x = y ? z : w因为这里基本上是最自然有用的地方 这个规则模式是为了完整而包含的,但是如果你倾向于打开它,你也许可以考虑用内置的去除所有ternary表达式 "无常"规则。 。 。 .

配置此规则模式 打开 (单位:千美元)关 默认 :

"@getify/proper-ternary/where": [ "error", { "assignment": true } ]

如果此模式已打开( 默认) , 它将报告错误 :

var name = userRecord != null ? userRecord.name : "Kyle";

为了避免错误,请使用 if..else 语句而不是三进制表达式:

var name;
if (userRecord != null) {
    name = userRecord.name;
}
else {
    name = "Kyle";
}

npm 软件包

要使用这个全局安装 ESLint (推荐) 的插件 :

npm install -g @getify/eslint-plugin-proper-ternary

要使用本地安装 ESLint 的插件 :

npm install @getify/eslint-plugin-proper-ternary

构建

Build Status npm Module

如果您需要捆绑/分发此 Eslint 插件, 请使用 dist/eslint-plugin-proper-ternary.js,它与 npm 软件包分配预建;您不需要在正常情况下重建它.

然而,如果你通过 Git 下载此寄存器:

  1. 包括的建筑效用scripts/build-core.js建造(并改进) dist/eslint-plugin-proper-ternary.js 从源.

  2. 安装构建和测试依赖, 运行 npm install 从工程根目录.

  3. 用 npm 手动运行构建工具 :

    npm run build
    
  4. 没有 npm 直接运行构建工具 :

    node scripts/build-core.js
    

测试

这个寄存器中包含一个全面的测试套件,以及npm包分发. 默认测试行为运行测试套件 lib/index.js。 。 。 .

  1. 包括Node.js测试工具(scripts/node-tests.js运行测试套房.

  2. 确保通过运行安装测试依赖性 npm install 从工程根目录.

    • 说明: 从 npm v5 开始,测试工具是 没有 在此期间自动运行 npm install。在 npm v4 和之前,测试工具在此时自动运行.
  3. 用 npm 运行测试工具 :

    npm test
    

    其他 npm 测试脚本 :

    • npm run test:dist 将运行测试套件对 dist/eslint-plugins-proper-ternary.js 而不是默认 lib/index.js。 。 。 .

    • npm run test:package 将运行测试套件,仿佛软件包刚刚通过 npm 安装。 这保证 package.json数字 :main 正确引用 dist/eslint-plugins-proper-ternary.js 供列入.

    • npm run test:all 将运行测试套件的所有三种模式.

  4. 在无 npm 的情况下直接运行测试工具 :

    node scripts/node-tests.js
    

测试范围

Coverage Status

如果你有的话 伊斯坦布尔 已安装在您的系统中( 需要 v1.0+) , 您可以用它来检查测试覆盖 :

npm run coverage

那就开门 coverage/lcov-report/index.html 在浏览此报表的浏览器中.

没有npm直接运行伊斯坦布尔:

istanbul cover scripts/node-tests.js

说明: Npm 脚本 coverage:report 仅供项目维护者使用;它向 盖子。 。 。 .

许可证

所有代码和文件都是(c) 2019-2021 Kyle Simpson 并按 MIT 许可证. 麻省理工学院许可证副本 也包括。 。 。 .

版本与发布记录

@getify/eslint-plugin-proper-ternary 共发布 12 个版本,首次发布于 2019/03/25;过去 12 个月发布了 0 个版本。

版本发布日期距今
3.1.1latest2021/04/275 年前
3.1.02021/04/275 年前
3.0.12019/04/077 年前
3.0.02019/04/017 年前
2.1.12019/03/277 年前
2.1.02019/03/277 年前

关于 @getify/eslint-plugin-proper-ternary 的常见问题

@getify/eslint-plugin-proper-ternary 是什么?

ESLint规则,以确保适当使用三重/有条件表达式

如何安装 @getify/eslint-plugin-proper-ternary?

在项目目录运行 npm install @getify/eslint-plugin-proper-ternary,或使用 pnpm add / yarn add / bun add。它还需要宿主项目提供 peer 依赖:eslint(>= 7.25.0)。npm 7 及以上与 pnpm 8 及以上默认会自动安装必需的 peer 依赖,Yarn 需要手动安装。

@getify/eslint-plugin-proper-ternary 支持 TypeScript 吗?

该包的 package.json 没有声明类型入口。需要类型提示时,可以在 npm 上查找社区维护的 @types/getify__eslint-plugin-proper-ternary 是否存在。

@getify/eslint-plugin-proper-ternary 支持 ESM 还是 CommonJS?

以 CommonJS 形式发布,可以直接 require();在 ES Module 项目中也可以用 import 引入(Node.js 会把 module.exports 作为默认导出)。

@getify/eslint-plugin-proper-ternary 可以商用吗?

@getify/eslint-plugin-proper-ternary 使用 MIT 许可。宽松许可:允许商业使用、修改和再分发,通常只需在分发时保留原版权与许可声明。以上为概括,不构成法律意见,请以许可原文为准。

@getify/eslint-plugin-proper-ternary 的下载量有多少?

根据 npm 官方下载统计,@getify/eslint-plugin-proper-ternary 在 2026/10/17 – 2026/11/15 这 30 天内被下载 37,639 次,日均约 1,255 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入,适合横向比较热度,不能直接等同于使用人数。

@getify/eslint-plugin-proper-ternary 还在维护吗?

最新版本 3.1.1 发布于 2021/04/27(5 年前);至今共发布 12 个版本,其中过去 12 个月发布了 0 个;首次发布于 2019/03/25。发布频率只是参考信号:功能稳定的工具可能很少需要更新,建议结合源码仓库的 issue 和提交记录判断。