Javascript

Question

我在 Javascript 中得到了以下编码评估问题。我尽力解决，但我错过了一些边缘案例。我需要有关解决方案的帮助。

以下是我想执行的步骤。我仍然是学习数据结构和算法的初学者。我不确定以下方法是否有效。我需要帮助来解决这个问题。谢谢

问题

数组类型排序你的任务是编写一个函数，该函数接受一个包含不同类型值的数组和 returns 一个列出所有不同类型的对象，这些类型在各自的子部分中分组。

Examples
Types   Input   Output
Primitive types [ 1, "string", 2, true, false ] { number: [ 1, 2 ], string: [ "string" ], boolean: [ true, false ] }
Differrent Object Types [ {}, [], null ]    { object: [ {} ], array: [ [] ], null: [ null ] }

边缘案例 Class 实例无需考虑，可作为此赋值的类型对象。

const filterArray = () => {
  // fill me with code
}

export default filterArray

测试

import filterArray from './solution'

describe('basic tests', () => {
  test('strings', () => {
    expect(filterArray(["a", "b", "c"])).toEqual({ string: ["a", "b", "c"] })
  })
})```

我解决这个问题的思路

1.create new array that will be returned..
2.loop over given array...
3.check type if no: append "number: [1, 2]"
4.add more if else conditions for other types

Answer 1

const filterArray = (arr) => {
  let result = {}

  let str;
  // other variables
  for (const it of arr) {
    switch (typeof it) {
      case "string":
        if (!str) {
          str = []
          result.string = str
        }
        str.push(it)
        break;
      // other cases
    }
  }
  return result
}

已编辑：

const filterArray = (arr) => {
  // fill me with code
  let result = {};

  let str;
  let num;
  let bool;
  let obj;
  let arrX;
  let n;
  let u;
  // other variables
  for (const it of arr) {
    switch (typeof it) {
      case 'string':
        if (!str) {
          str = [];
          result.string = str;
        }
        str.push(it);
        break;
      case 'number':
        if (!num) {
          num = [];
          result.number = num;
        }
        num.push(it);
        break;

      case 'boolean':
        if (!bool) {
          bool = [];
          result.boolean = bool;
        }
        bool.push(it);
        break;

      case 'object':
        if (it instanceof Array) {
          if (!arrX) {
            arrX = [];
            result.array = arrX;
          }
          arrX.push(it);
        } else if (it === null) {
          if (!n) {
            n = [];
            result.null = n;
          }
          n.push(it);
        } else {
          if (!obj) {
            obj = [];
            result.object = obj;
          }
          obj.push(it);
        }
        break;

      case 'undefined':
        if (!u) {
          u = [];
          result.undefined = u;
        }
        u.push(it);
        break;
    }
  }

  console.log(result);
  return result;
};

此外，使用部分对象相等性来测试对象：

describe('filter test', () => {
  test('should specifiy types', () => {
    const filtered = filterArray([{}, [], null]);

    expect(filtered).toEqual(
      expect.objectContaining({
        object: expect.arrayContaining([expect.objectContaining({})]),
        array: expect.arrayContaining([expect.arrayContaining([])]),
        null: expect.arrayContaining([null]),
      })
    );
  });
});

Answer 2

你可以使用Array.prototype.reduce()来解决它。确保你理解下面的代码；不要简单地复制和粘贴它。

const func1 = () => {};
const func2 = () => {};

const input = [1, 2, 3.75, 'a', 'b', 'c', {}, { foo: 'bar' }, [], ['foo', 'bar'], null, null, undefined, null, true, false, func1, func2, NaN, NaN, 5 / 0, 0 / 5];

const output = input.reduce((outObj, item) => {
  // check the type of the item
  let itemType = typeof item;

  // if the item is of type 'number' you might want to discriminate
  // between actual numbers and `NaN` (Not-a-Number)
  if (itemType === 'number' && isNaN(item)) itemType = 'nan';
  
  // if the item is of type 'object' you will have to further check
  // whether it is `null`, an array, or an actual object
  if (itemType === 'object') {
    if (item === null) itemType = 'null';
    if (Array.isArray(item)) itemType = 'array';
  }
  
  // if the output object already contains a key for the item type
  // add the item to that key otherwise
  // create the output object new type key and add the item to it
  outObj[itemType] = outObj[itemType] ? [...outObj[itemType], item] : [item];
  
  // return the output object
  return outObj;
}, {});

// test
console.log(output)

[编辑]
代码块：

let itemType = typeof item;

if (itemType === 'number' && isNaN(item)) itemType = 'nan';

if (itemType === 'object') {
  if (item === null) itemType = 'null';
  if (Array.isArray(item)) itemType = 'array';
}

可以写成：

let itemType = typeof item;

if (item === null) {
  itemType = 'null';
} else if (itemType === 'object' && Array.isArray(item)) {
  itemType = 'array';
} else if (itemType === 'number' && isNaN(item)) {
  itemType = 'nan';
}

或

const itemType = item === null
  ? 'null'
  : Array.isArray(item)
    ? 'array'
    : typeof item === 'number' && isNaN(item)
      ? 'nan'
      : typeof item

或

const itemType = (item === null && 'null') ||
  (Array.isArray(item) && 'array') ||
  (typeof item === 'number' && isNaN(item) && 'nan') ||
  typeof item

IMVHO，第一个代码块更好地说明了“人类”推理（并且在注释插值方面表现得更好）因此解释逻辑是可以接受的，但你不太可能在真实案例。

Answer 3

@dharmisha 也删了你忘了我相信

Javascript - 数组中的组数据类型 - 编码评估

Javascript - Group data type in Array - Coding assessment

arrays

types

boolean

group