jherr/houses.json

aekryz1993 · 2022-02-24T14:03:25Z

import houses from "./houses.json";

interface House {
  name: string;
  planets: string[] | string;
}

interface HouseWithID extends House {
  id: number;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(houses: unknown, filter?: unknown): HouseWithID[] {
  const housesData = typeof houses === "string" ? JSON.parse(houses) : houses;
  const housesWithIds = housesData.map((house: House, idx: number) => ({
    id: idx,
    ...house,
  }));
  return housesWithIds.filter(filter);
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

soymikey · 2022-02-28T08:30:41Z

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: number
}

const houses: House[] = [
    { "name": "Atreides", "planets": "Calladan" },
    { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
    { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]
function findHouses(houses: string): HouseWithID[];
function findHouses(
    houses: string,
    filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[];

function findHouses(houses: unknown, filter?: (house: House) => boolean) {
    const tempHouses: House[] = typeof houses === 'string' ? JSON.parse(houses) : houses
    return tempHouses.map(house => ({ id: tempHouses.indexOf(house), ...house }))

}



console.log(
    findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

sansarun · 2022-03-10T06:27:17Z

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: string;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(
  houses: string | House[],
  filter?: (house: House) => boolean
) {
  const genId = () => Math.floor(Math.random() * 1000);
  const parsedHouses = typeof houses === "string" ? JSON.parse(houses) : houses;
  const housesWithId = parsedHouses.map((h: House) => ({ ...h, id: genId() }));
  return filter ? housesWithId.filter(filter) : housesWithId;
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === `"Harkonnen"));`

berkaygurcan · 2022-04-20T17:19:18Z

Hello!

Here is my solution :) . I got stuck in some places and looked at the video for an idea. It wasn't very good :/ .(I couldn't understand what was asked because my English level is not good, but I solved it later :))

//My solution
import houses from "./houses";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID {
  id: number;
  name: string;
  planets: string | string[];
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(
  input: string | House[],
  filter?: (house: House) => boolean
): HouseWithID[] {
  const houses = typeof input === "string" ? JSON.parse(input) : input;

  houses.forEach((house: HouseWithID, i: number) => {
    //added if for each house item
    house.id = i + 1;
  });

  const result = filter ? houses.find((house: House) => filter(house)) : houses;

  return result;
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

Rauraurautis · 2022-05-31T11:22:51Z

My Approach:

const houses: House[] = [
	{ name: 'Atreides', planets: 'Calladan' },
	{ name: 'Corrino', planets: ['Kaitan', 'Salusa Secundus'] },
	{ name: 'Harkonnen', planets: ['Giedi Prime', 'Arrakis'] },
];

interface House {
	name: string;
	planets: string | string[];
}

interface HouseWithID extends House {
	id: string;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: (house: House) => boolean): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[];

function findHouses(houses: unknown, filter?: (house: House) => boolean): HouseWithID[] {
	if (typeof houses === 'string') houses = JSON.parse(houses);

	let housesWithId: HouseWithID[] = (houses as House[]).map((updatedHouse) => ({
		id: Math.random().toString(36).substr(2, 9),
		...updatedHouse,
	}));
	if (filter) housesWithId = housesWithId.filter(filter);

	return housesWithId;
}

Thanks a lot for this, really learnt a lot. So much better than my code which was 3 times longer lol

RichardPriddy · 2022-06-24T08:47:41Z

Really enjoying the series, feel a little late to the party, but with a little refactoring I manged to find a simple one line solution:

import houses from './houses.json';

interface House {
    name: string;
    planets: string | string[]
}

interface HouseWithID extends House {
    id: string;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
    houses: string,
    filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
    houses: House[],
    filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: string | House[], filter: (house: House) => boolean = () => true): HouseWithID[] {
    return (typeof(houses) === "string" ? (JSON.parse(houses) as House[]) : houses)
            .map(h => {return {id: h.name, ...h}})
            .filter(filter);
}

console.log(
    findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

However, the find houses function may be more readable as this:

function findHouses(houses: string | House[], filter: (house: House) => boolean = () => true): HouseWithID[] {
    const parseHouses = (houses: string | House[]): House[] => {
        return typeof(houses) === "string" ? (JSON.parse(houses) as House[]) : houses;
    }

    return parseHouses(houses)
            .map(h => {return {id: h.name, ...h}})
            .filter(filter);
}

deamon-cool · 2022-06-27T07:11:19Z

There are plenty of great solutions up there, so some refactored approach from my side.
PS Jack, thank you for all the awesome series about ts.

const houses = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type HousesParam = string | House[];

type FilterFun = (house: House) => boolean;

function findHouses(houses: HousesParam): HouseWithID[];
function findHouses(houses: HousesParam, filter: FilterFun): HouseWithID[];

function findHouses(houses: unknown, filter?: unknown) {
  let housesWithID: HouseWithID[] = [];
  let l_houses: House[] = [];

  if (typeof houses === 'string') {
    l_houses = JSON.parse(houses);
  }

  if (Array.isArray(houses)) {
    l_houses = houses;
  }

  l_houses.forEach((item, i) => {
    housesWithID.push({
      id: i,
      ...item,
    });
  });

  if (typeof filter === 'function') {
    return housesWithID.filter(filter as FilterFun);
  }

  return housesWithID;
}

console.log(findHouses(JSON.stringify(houses)));
console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

wtfzambo · 2022-08-12T15:48:33Z

this is how I implemented it. Took me a while but definitely not a full GoT season 😄

import houses from "./houses";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: (house: House) => boolean): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[];

function findHouses(input: House[] | string, filter?: (house: House) => boolean): HouseWithID[] {
  let houses: House[];
  let housesWithId: HouseWithID[];

  typeof input === "string" ? (houses = JSON.parse(input)) : (houses = input);

  housesWithId = houses.map((house, id) => ({ ...house, id }));
  housesWithId = filter ? housesWithId.filter(filter) : housesWithId;

  return housesWithId;
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

azubikeenu · 2022-08-28T14:07:14Z

import fs from 'fs';

type House = {
  name: string;
  planets: string | Array<string>;
};

type HouseWithID = {
  id: number;
} & House;

const houses = fs.readFileSync('houses.json', 'utf-8');

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(houses: House[]): HouseWithID[];

function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(
  param: unknown,
  filter?: (house: House) => boolean
): HouseWithID[] {
  let houseWithID: HouseWithID[] = [];
  const housesArray: House[] = typeof param === 'string' ? JSON.parse(houses) : param;
  houseWithID = housesArray.map((house, idx) => ({ id: idx, ...house }));
  return filter ? houseWithID.filter(filter) : houseWithID;
}

console.log(findHouses(JSON.stringify(houses)));

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides')
);

const houseObj: House[] = JSON.parse(houses);
console.log(findHouses(houseObj, ({ name }) => name === 'Harkonnen'));

arditnurcaj · 2022-09-20T13:25:57Z

interface House {
	name: string;
	planets: string | string[];
}

interface HouseWithID extends House {
	id: string;
}

function generateUniqueID(): string {
	return (
		'house-' + new Date().getMilliseconds() + Math.floor(Math.random() * 1000)
	);
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
	houses: string,
	filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
	houses: House[],
	filter: (house: House) => boolean
): HouseWithID[];
function findHouses(
	houses: unknown,
	filter?: (house: House) => boolean
): HouseWithID[] {
	if (!houses) return [];

	let modifiedHouses: House[] = [];

	try {
		if (typeof houses === 'string') {
			modifiedHouses = JSON.parse(houses);
		} else {
			modifiedHouses = houses as House[];
		}

		if (filter) {
			modifiedHouses = modifiedHouses.filter(filter);
		}
	} catch (error) {
		console.log('Wrong data on houses!');
	}

	return modifiedHouses.map((house) => ({ ...house, id: generateUniqueID() }));
}

console.log(
	findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides')
);

console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'));

javierportillo · 2022-09-29T02:50:37Z

My version

const houses = [
  { name: "Atreides", planets: "Calladan" },
  { name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
  { name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: string;
}

type houseFilter = (house: House) => boolean

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: string, filter: houseFilter): HouseWithID[];
function findHouses(houses: House[], filter: houseFilter): HouseWithID[];

function findHouses(houses: string | House[], filter?: houseFilter): HouseWithID[] {
  if (typeof houses === "string") {
    houses = JSON.parse(houses) as House[]
  }

  houses = houses.map((house, idx) => ({
    ...house,
    id: `${idx + 1}`,
  }));

  if (filter) {
    houses = houses.filter(filter);
  }

  return houses as HouseWithID[]
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

strangeiot · 2022-10-21T04:30:19Z

My Approach after watching the tutorial

const houses = [
    { "name": "Atreides", "planets": "Calladan" },
    { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
    { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    ID: string
}

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: (house: House) => boolean): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[];

function findHouses(input: unknown, filter?: (house: House) => boolean): HouseWithID[] {
    let housesWithId: HouseWithID[] = []
    let houses: House[] = []
    if (typeof input === "string") {
        houses = JSON.parse(input) as House[]
    } else{
        houses = input as House[]
    }
    housesWithId = houses.map((data: House, index: number) => {
        return {
            ID: index.toString(),
            name: data.name,
            planets: data.planets
        }
    })
    if (filter) {
        housesWithId = housesWithId.filter(filter)
    }

    return housesWithId
}
console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

Thank you @jherr

muhammadtalha242 · 2022-12-06T14:28:36Z

Here is my approach.

interface HouseWithID extends House {
  id: number;
}

type housesInput = House[] | string;
type housesFilter = (house: House) => boolean;

function findHouses(houses: housesInput, filter?: housesFilter): HouseWithID[] {
  let housesArr: House[] =
    typeof houses === "string" ? JSON.parse(houses) : houses;
  let housesWithIDArr: HouseWithID[] = housesArr.map(
    (house: House, id: number) => ({
      id,
      ...house,
    })
  );
  housesWithIDArr = filter ? housesWithIDArr.filter(filter) : housesWithIDArr;
  return housesWithIDArr;
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

Thank you @jherr

theaungmyatmoe · 2023-01-14T21:59:25Z

Description can be found here.
https://gist.github.com/amm834/3de41ccf4f296a92aa9b382b0fbfc49e

KISS

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: number;
}

type TFilterFn = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(
    houses: string,
    filter: TFiler
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
    houses: House[],
    filter: TFilterFn
): HouseWithID[];
function findHouses(arg1: unknown, filter?: TFilterFn): HouseWithID[] {
    const houses = Array.isArray(arg1) ? arg1 : JSON.parse(arg1);

    const housesWithID = houses.map((house, index) => ({
        ...house,
        id: index,
    }));
    return filter ? housesWithID.filter(filter) : housesWithID;
}


const houses = [
    {"name": "Atreides", "planets": "Calladan"},
    {"name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"]},
    {"name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"]}
]


console.log(
    findHouses(JSON.stringify(houses), ({name}) => name === "Atreides")
);

console.log(findHouses(houses, ({name}) => name === "Harkonnen"));
console.log(findHouses(houses));

Hachikoi-the-creator · 2023-02-03T08:36:03Z

I can't sleep so I decided to continue this tutorials and surpsingly worked!
Also got distracted looking for diference between interface & type so I found out about extends

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type FilterCB = (house: House) => boolean;
// overload
function findHouses(houses: string): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: string, filter: FilterCB): HouseWithID[];
function findHouses(houses: House[], filter: FilterCB): HouseWithID[];

// implementation
function findHouses(
  houses: string | House[],
  filter?: FilterCB
): HouseWithID[] {
  if (typeof houses === "string" && !!filter) {
    const parsed: HouseWithID[] = (JSON.parse(houses) as House[]).map(
      (h, i) => ({ ...h, id: i })
    );

    return filter ? parsed.filter((h) => filter(h)) : parsed;
  }

  const casted = (houses as House[]).map((h, i) => ({ ...h, id: i }));
  return filter ? casted.filter((h) => filter(h)) : casted;
}

PhilippAubert · 2023-02-19T18:30:28Z

Ok, so here I go.

A little verbose, but I'm happy with it 😸


const houses = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]

interface House {
    name:string,
    planets:string|string[]
}

interface HouseWithID {
    house:House,
    id:number
}

const findHouses = (houses:House[], filter?:(house:House)=>boolean):HouseWithID[] => {
    let houseWithIds:HouseWithID[] = [];
    if (filter) {
        houses = houses.filter(filter);
    }
        houses.map((house:House, id:number)=> {
            id+=1;
            let newHouse:HouseWithID = {
                house:{
                    name:house.name,
                    planets:house.planets
                },
                id:id
            }
            houseWithIds.push(newHouse);
            return houseWithIds;
        })
    return houseWithIds;
}

mateuszjansowa · 2023-02-26T11:52:52Z

Thanks for challenge! 👍

My solution:

import houses from "./houses.json";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type HouseFilter = (v: House) => boolean;

function findHouses(arg1: unknown, arg2?: HouseFilter): HouseWithID[] {
  const houses: House[] = Array.isArray(arg1)
    ? [...arg1]
    : JSON.parse(arg1 as string);

  const mappedHouses: HouseWithID[] = houses.map((v: House, i: number) => ({
    ...v,
    id: i
  }));

  if (arg2 && typeof arg2 === "function") {
    return mappedHouses.filter(arg2);
  }

  return mappedHouses;
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Harkonnen")
);

jaxkashif34 · 2023-05-07T06:58:41Z

const houses: House[] = [
  { name: 'Atreides', planets: 'Calladan' },
  { name: 'Corrino', planets: ['Kaitan', 'Salusa Secundus'] },
  { name: 'Harkonnen', planets: ['Giedi Prime', 'Arrakis'] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

function findHouses(houses: string | House[], filter: (house: House) => boolean): HouseWithID[] {
  const housesJSON = typeof houses === 'string' ? JSON.parse(houses) : houses;
  const housesWithID: HouseWithID[] = housesJSON.map((house: House, index: number) => ({ ...house, id: index }));

  return housesWithID.filter(filter);
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'));
console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'));

khanhledev · 2023-05-24T13:55:57Z

@jherr thank you so much for amazing series. This is my solution:

import data from "./houses.json";
interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  id: number;
}

type HouseFilter = (house: House) => boolean;

function findHouses(
  input: House[] | string,
  filter: HouseFilter
): HouseWithID[] {
  let houses: HouseWithID[] = [];
  if (typeof input === "string") {
    input = JSON.parse(input) as House[];
  }

  houses = input.map((item: House, index: number) => ({
    ...item,
    ...{ id: index },
  }));
  if (filter) {
    houses = houses.filter(filter);
  }

  return houses;
}

console.log(
  findHouses(JSON.stringify(data), ({ name }) => name === "Atreides")
);

console.log(findHouses(data, ({ name }) => name === "Harkonnen"));

dzulfiqarzaky · 2023-08-01T02:05:32Z

const houses = require("./houses.json");

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: number;
}
type Filter = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: Filter): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: Filter): HouseWithID[];
function findHouses(houses: unknown, filter?: Filter): HouseWithID[] {
    if (houses == null) {
        return [];
    }
    let house: HouseWithID[] = [];

    if (typeof houses === "string") {
        house = (JSON.parse(houses) as House[]).map((housemap) => ({
            ...housemap,
            id: Math.random(),
        }));
    } else {
        house = (houses as House[]).map((housemap) => ({
            ...housemap,
            id: Math.random(),
        }));
    }

    if (typeof filter === "function") {
        return house.filter(filter);
    }
    return house;
}

console.log(
    findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

nazifbara · 2023-08-07T10:41:42Z

const houses: House[] = [
  { name: "Atreides", planets: "Calladan" },
  { name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
  { name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID extends House {
  ID: string;
}

type FilterFn = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFn): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFn): HouseWithID[];
function findHouses(arg1: unknown, arg2?: FilterFn): HouseWithID[] {
  let houses: House[] = [];

  // Parse if arg1 is a string
  if (typeof arg1 === "string") {
    houses = JSON.parse(arg1);
  } else if (typeof arg1 === "object") {
    houses = arg1 as House[];
  }

  // Filter if there is a filter function
  houses = arg2 ? houses.filter(arg2) : houses;

  // Create the houses with IDs and return them
  return houses.map((house, idx) => ({
    ID: `${house.name}#${idx}`,
    ...house,
  }));
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

ozgursar · 2023-08-12T12:04:55Z

import houses from './houses.json'

interface House {
  name: string
  planets: string | string[]
}

interface HouseWithID extends House {
  id: number
}

function findHouses(houses: string): HouseWithID[]

function findHouses(houses: string, filter: (house: House) => boolean): HouseWithID[]

function findHouses(houses: House[]): HouseWithID[]

function findHouses(houses: House[], filter: (house: House) => boolean): HouseWithID[]

function findHouses(houses: string | House[], filter?: (house: House) => boolean): HouseWithID[] {
  let houseList: House[] = []
  if (typeof houses === 'string') {
    houseList = JSON.parse(houses)
  } else {
    houseList = houses
  }
  const housesWithID: HouseWithID[] = houseList.map((house, index) => ({ id: index, ...house }))

  if (filter) {
    return housesWithID.filter(filter)
  } else {
    return housesWithID
  }
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'))

console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'))

lovenangelo · 2023-08-15T01:29:50Z

const houses : House[] = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
]

interface House {
  name: string,
  planets: string | string[]
}

interface HouseWithID extends House {
  id: number
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(house: string | House[], filter?: (house: House)=>boolean): HouseWithID[]{

  let housesWithId : HouseWithID[] | [] = [];

  const addHouseId = (houseList: House[] = house as House[]): HouseWithID[] =>{
    return houseList.map((house: House, index) => {
      return {
        ...house,
        id: index+1
      }
    })
  }

  const filterHouse = (housesWithId: HouseWithID[]) => {
    return housesWithId.filter(filter!);
  }

  if(typeof house == 'string'){
    const parsedHouse : House[] = JSON.parse(house)
    housesWithId = addHouseId(parsedHouse)
  }else{
    housesWithId = addHouseId()
  }

  if(filter){
    const house = filterHouse(housesWithId);
    return house;
  }
  
  return housesWithId;
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === 'Atreides'))

console.log(findHouses(houses, ({ name }) => name === 'Harkonnen'))

Elle0320 · 2023-08-15T20:59:06Z

import houses from './houses.json';

interface House {
name: string;
planets: string|string[];
}

interface HouseWithID extends House{
id: string;
}

function findHouses(
input: House[]| string,
filter?: (house: House) => boolean
): HouseWithID[]{
const houses = typeof input == "string"? JSON.parse(input) : input;
return (filter? houses.filter(filter) : houses)
.map((h:House)=>{
return {...h, id: houses.indexOf(h)}
})
};

console.log(
findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses as any, ({ name }) => name === "Harkonnen"));

AlanJereb · 2023-08-22T11:24:28Z

const houses = [
  { "name": "Atreides", "planets": "Calladan" },
  { "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
  { "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
];

// Challenge #1

interface House {
    name: string;
    planets: string | string[];
}

interface HouseWithID extends House {
    id: string;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(arg: string | House[], f?: (house: House) => boolean): HouseWithID[] {
    let result: HouseWithID[] = [];
    let values: House[] = [];

    // Base
    if (typeof arg === "string") {
        values = JSON.parse(arg);
    } else {
        values = arg;
    }
    values.forEach((ar) => {
        result.push({
            ...ar,
            id: ar.name.charAt(0),
        })
    })
    // filter
    if (f) {
        result = result.filter(f);
    }

    return result;
}

console.log(findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides"));
console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

waraich1 · 2024-01-12T04:57:09Z

Here's an easy to understand solution

  { name: "Atreides", planets: "Calladan" },
  { name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
  { name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID {
  name: string;
  planets: string | string[];
  id: number;
}

function findHouses(houses: string): HouseWithID[];

function findHouses(
  houses: string,
  filter: (house: House) => boolean
): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];

function findHouses(
  houses: House[],
  filter: (house: House) => boolean
): HouseWithID[];

function findHouses(
  input: string | House[],
  filter?: (house: House) => Boolean
) {
  const temp = (
    typeof input === "string" ? JSON.parse(input) : input
  ) as House[];
  let filteredHouses = filter ? temp.filter(filter) : temp;

  return filteredHouses.map(
    (house, id): HouseWithID => ({
      ...house,
      id,
    })
  );
}

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

kafkaphoenix · 2024-05-26T23:06:05Z

in the tsconfig.json file you can enable "resolveJsonModule": true, so you can import the json file as import housesData from "./data/houses.json"; that way is an array

Kahffi · 2024-09-06T19:59:17Z

interface House {
	name: string;
	planets: string | string[];
}
const houses: House[] = [
	{ name: "Atreides", planets: "Calladan" },
	{ name: "Corrino", planets: ["Kaitan", "Salusa Secundus"] },
	{ name: "Harkonnen", planets: ["Giedi Prime", "Arrakis"] },
];

interface HouseWithID extends House {
	id: number;
}

type FilterFunction = (houses: House) => boolean;

function addHouseId(houses: House[]): HouseWithID[] {
	return houses.map((house, index) => {
		const newHouse: HouseWithID = { ...house, id: index };
		return newHouse;
	});
}
function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFunction): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFunction): HouseWithID[];

function findHouses(arg1: unknown, arg2?: FilterFunction): HouseWithID[] {
	if (typeof arg1 === "string") arg1 = JSON.parse(arg1);
	if (arg2) {
		return addHouseId(arg1 as House[]).filter((house) => arg2(house));
	} else {
		return addHouseId(arg1 as House[]);
	}
}

console.log(
	findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

fciurana · 2024-09-25T23:02:38Z

Hi @jherr ,

Thanks for your series.

Here's my solution :

import data from "./houses.json";

interface House {
    name: string;
    planets: string[];
 }
    
interface HouseWithID {
    Id: number;
    House: House;
}

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter?: (house: House) => boolean): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter?: (house: House) => boolean): HouseWithID[];
function findHouses(houses: unknown, filter?: (house: House) => boolean): HouseWithID[] {
    let housesWithId: HouseWithID[] = [];
    var i = 1;

    let houseArray = (typeof houses === `string` ? JSON.parse((houses as string)) : houses) as House[]; 

    houseArray.map(h => {
        if(filter?.(h))
            housesWithId.push({Id: i, House: h});
        i++;
    });
    
    return housesWithId;
}

console.log(
  findHouses(JSON.stringify(data), ({ name }) => name === "Atreides")
);

console.log(findHouses(data as any, ({ name }) => name === "Harkonnen"));

ElMehdi-l · 2024-12-07T16:54:13Z

import houses from "./houses.json";

interface House {
  name: string;
  planets: string | string[];
}

interface HouseWithID {
  id: number;
  house: House;
}

type FilterFunc = (house: House) => boolean;

function findHouses(houses: string): HouseWithID[];
function findHouses(houses: string, filter: FilterFunc): HouseWithID[];
function findHouses(houses: House[]): HouseWithID[];
function findHouses(houses: House[], filter: FilterFunc): HouseWithID[];

function findHouses(houses: unknown, filter?: unknown): HouseWithID[] {
  let housesWithID: HouseWithID[] = (
    typeof houses === "string" ? JSON.parse(houses) : houses
  ).map((house: House, index: number) => ({
    house,
    id: index + 1,
  }));

  if (typeof filter === "function") {
    housesWithID = housesWithID.filter((house: HouseWithID) =>
      (filter as FilterFunc)(house.house)
    );
  }

  return housesWithID;
}

console.log(findHouses(JSON.stringify(houses)));

console.log(
  findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
);

console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

jherr/houses.json

aekryz1993 commented Feb 24, 2022

soymikey commented Feb 28, 2022

sansarun commented Mar 10, 2022

berkaygurcan commented Apr 20, 2022

Rauraurautis commented May 31, 2022 •

edited

Loading

RichardPriddy commented Jun 24, 2022

deamon-cool commented Jun 27, 2022 •

edited

Loading

wtfzambo commented Aug 12, 2022

azubikeenu commented Aug 28, 2022

arditnurcaj commented Sep 20, 2022

javierportillo commented Sep 29, 2022 •

edited

Loading

strangeiot commented Oct 21, 2022 •

edited

Loading

muhammadtalha242 commented Dec 6, 2022 •

edited

Loading

theaungmyatmoe commented Jan 14, 2023 •

edited

Loading

Hachikoi-the-creator commented Feb 3, 2023 •

edited

Loading

PhilippAubert commented Feb 19, 2023

mateuszjansowa commented Feb 26, 2023

jaxkashif34 commented May 7, 2023

khanhledev commented May 24, 2023

dzulfiqarzaky commented Aug 1, 2023

nazifbara commented Aug 7, 2023

ozgursar commented Aug 12, 2023 •

edited

Loading

lovenangelo commented Aug 15, 2023 •

edited

Loading

Elle0320 commented Aug 15, 2023

AlanJereb commented Aug 22, 2023

waraich1 commented Jan 12, 2024 •

edited

Loading

kafkaphoenix commented May 26, 2024

Kahffi commented Sep 6, 2024 •

edited

Loading

fciurana commented Sep 25, 2024

ElMehdi-l commented Dec 7, 2024

	[
	{ "name": "Atreides", "planets": "Calladan" },
	{ "name": "Corrino", "planets": ["Kaitan", "Salusa Secundus"] },
	{ "name": "Harkonnen", "planets": ["Giedi Prime", "Arrakis"] }
	]

	interface House {
	...
	}

	interface HouseWithID {
	...
	}

	function findHouses(houses: string): HouseWithID[];
	function findHouses(
	houses: string,
	filter: (house: House) => boolean
	): HouseWithID[];
	function findHouses(houses: House[]): HouseWithID[];
	function findHouses(
	houses: House[],
	filter: (house: House) => boolean
	): HouseWithID[];

	console.log(
	findHouses(JSON.stringify(houses), ({ name }) => name === "Atreides")
	);

	console.log(findHouses(houses, ({ name }) => name === "Harkonnen"));

jherr/houses.json

aekryz1993 commented Feb 24, 2022

soymikey commented Feb 28, 2022

sansarun commented Mar 10, 2022

berkaygurcan commented Apr 20, 2022

Rauraurautis commented May 31, 2022 • edited Loading

RichardPriddy commented Jun 24, 2022

deamon-cool commented Jun 27, 2022 • edited Loading

wtfzambo commented Aug 12, 2022

azubikeenu commented Aug 28, 2022

arditnurcaj commented Sep 20, 2022

javierportillo commented Sep 29, 2022 • edited Loading

strangeiot commented Oct 21, 2022 • edited Loading

muhammadtalha242 commented Dec 6, 2022 • edited Loading

theaungmyatmoe commented Jan 14, 2023 • edited Loading

Hachikoi-the-creator commented Feb 3, 2023 • edited Loading

PhilippAubert commented Feb 19, 2023

mateuszjansowa commented Feb 26, 2023

jaxkashif34 commented May 7, 2023

khanhledev commented May 24, 2023

dzulfiqarzaky commented Aug 1, 2023

nazifbara commented Aug 7, 2023

ozgursar commented Aug 12, 2023 • edited Loading

lovenangelo commented Aug 15, 2023 • edited Loading

Elle0320 commented Aug 15, 2023

AlanJereb commented Aug 22, 2023

waraich1 commented Jan 12, 2024 • edited Loading

kafkaphoenix commented May 26, 2024

Kahffi commented Sep 6, 2024 • edited Loading

fciurana commented Sep 25, 2024

ElMehdi-l commented Dec 7, 2024

Rauraurautis commented May 31, 2022 •

edited

Loading

deamon-cool commented Jun 27, 2022 •

edited

Loading

javierportillo commented Sep 29, 2022 •

edited

Loading

strangeiot commented Oct 21, 2022 •

edited

Loading

muhammadtalha242 commented Dec 6, 2022 •

edited

Loading

theaungmyatmoe commented Jan 14, 2023 •

edited

Loading

Hachikoi-the-creator commented Feb 3, 2023 •

edited

Loading

ozgursar commented Aug 12, 2023 •

edited

Loading

lovenangelo commented Aug 15, 2023 •

edited

Loading

waraich1 commented Jan 12, 2024 •

edited

Loading

Kahffi commented Sep 6, 2024 •

edited

Loading