Question

我有caluclateAcess函数，该函数将数组作为输入，数组最多包含三个元素，最少包含一个元素所以可能出现的元素是创建，读取和更新所以它基本上是2 ^ 3，这意味着可以出现8个概率我列出所有概率并返回值

我将列出可能的输入以及应该返回的输出。空数组不会来了，这意味着错误，错误，错误

create => 'CreateAndRead'
read => 'Read'
update => 'UpdateAndRead'
create,read => 'CreateAndRead'
update, read => 'UpdateAndRead'
create, update => 'ALL'
create,read, update => 'ALL'

所以我写了下面的函数，有没有更好的方法来实现这一点

   let READ = 'read';
   let CREATE = 'create';
   let UPDATE = 'update';


   const caluclateAcess = (inputArray) => {
  if (
    (inputArray.indexOf(READ) > -1
    && inputArray.indexOf(UPDATE) > -1
    && inputArray.indexOf(CREATE) > -1)
    || 
    (
      inputArray.indexOf(UPDATE) > -1
      && inputArray.indexOf(CREATE) > -1
    )
  ) {
    return 'ALL';
  }
  if (
    (inputArray.indexOf(CREATE) > -1
    && inputArray.indexOf(READ) > -1)
    || (inputArray.indexOf(CREATE) > -1
    && (inputArray.indexOf(READ) === -1 && inputArray.indexOf(UPDATE) === -1))
  ) {
    return 'CreateAndRead';
  }
  if (
    (inputArray.indexOf(UPDATE) > -1
    && inputArray.indexOf(READ) > -1)
    || (inputArray.indexOf(UPDATE) > -1
    && (inputArray.indexOf(READ) === -1 && inputArray.indexOf(CREATE) === -1))
  ) {
    return 'UpdateAndRead';
  }
  if (inputArray.indexOf(READ) > -1) {
    return 'Read';
  }
};

任何帮助表示赞赏

Answer 1

您可以通过删除重复的inputArray.indexOf()调用来开始-这使所有内容都难以阅读。只检查一次更简单：

const hasCreate = inputArray.indexOf(CREATE) > -1;
const hasUpdate = inputArray.indexOf(UPDATE) > -1;
const hasRead = inputArray.indexOf(READ) > -1;

第二，您设置的规则显示您具有三个访问属性-read，update和create，每个访问属性可能暗示另一个。查看这些内容，很显然您具有以下关系：

read => read
update => update, read
create => create, read

因此，update和create实际上是复合的。这意味着可以修改初始检查以解决这些问题：

const hasCreate = inputArray.indexOf(CREATE) > -1;
const hasUpdate = inputArray.indexOf(UPDATE) > -1;
const hasRead = hasCreate || hasUpdate || inputArray.indexOf(READ) > -1;

这避免了检查某人是否有read或update。

需要特别注意的是，您可以仅使用Array#includes而不是检查索引。

话虽这么说，但阅读权限几乎是无关紧要的。重要的是是否只有个可用，在所有其他情况下，它几乎被忽略或假定存在。尽管如此，对隐含规则进行建模还是很有用的-也许将来可能会改变。

最后，逻辑太复杂了。仅有四种可能的最终状态，如上所述，read甚至没有用于大多数状态。这是进行所有检查的更新代码。对于根本没有权限的情况，我添加了一个称为“无”的状态。即使这种情况不可能发生，我发现拥有它也比忽略它更容易被使用：

const caluclateAcess = (inputArray) => {
  const hasCreate = inputArray.includes('create');
  const hasUpdate = inputArray.includes('update');
  const hasRead = hasCreate || hasUpdate || inputArray.includes('read');
  
  if (hasCreate === true && hasUpdate === true) return "ALL";
  if (hasCreate) return "CreateAndRead";
  if (hasUpdate) return "UpdateAndRead";
  if (hasRead) return "Read";
  
  return "None";
};

console.log("create =>",               caluclateAcess(["create"])                  );
console.log("read =>",                 caluclateAcess(["read"])                    );
console.log("update =>",               caluclateAcess(["update"])                  );
console.log("create, read =>",         caluclateAcess(["create", "read"])          );
console.log("update, read=>",          caluclateAcess(["update", "read"])          );
console.log("create, update =>",       caluclateAcess(["create", "update"])        );
console.log("create, read, update =>", caluclateAcess(["create", "read", "update"]));
console.log("<nothing> =>",            caluclateAcess([])                          );

{em}不需要READ，CREATE和UPDATE变量，因为它们只使用一次，所以我内联它们以缩短代码，甚至更多。

但是，如果确实不可能有一个空的访问属性数组，则表明read访问是完全无关紧要的。不拥有它是不可能的。因此，可以完全跳过对其的检查，并且可以将函数的默认返回值从"None"更改为"Read"。但是，我个人希望保留检查-这不会损害任何功能，并且实现不会偏离规范。如果规格将来会更改，或者存在某种错误，最好不要自动授予读取访问权限。

基于返回不同输出的数组元素

1 个答案: