W kwietniu opublikowałem 6 wpisów:

Inne:

1. Blog: Podsumowanie po roku

NodeJS:

1. Mongoose jak sprawdzić czy podano tablicę w modelu danych?

JavaScript:

1. RxJS: Operator pluck
2. Jak usunąć duplikaty z tablicy?
3. TypeScript: Omit

MongoDB:

1. Jak sprawdzić czy pole ma daną wartość lub null?

Przeczytałem dwie książki:

1. Czerwona kraina - Joe Abercrombie
2. Shitshow!. Ameryka się sypie, a oglądalność szybuje - Charlie LeDuff

Przesłuchałem trzy audiobooki:

1. 21 lekcji na XXI wiek - Yuval Noah Harari
2. Okruchy dnia - Kazuo Ishiguro
3. Dygot - Jakub Małecki

Omit tworzy nowy typ danych na podstawie już istniejącego. Przydaje się szczególnie wtedy kiedy chcemy się pozbyć niektórych pól ze wzorca.

Składania wygląda następująco:

Omit<Type, Keys>

Pierwszy parametr Type to istniejący typ danych. Drugi: Keys to pole lub pola, które nie zostaną wzięte pod uwagę, w nowo stworzonym typie danych.

Jest dostępny w TypeScript od wersji 3.5

Przykłady

Przykład 1

interface Book {
	title: string;
	author: string;
	pages: number;
}

type AudioBook = Omit<Book, 'pages'>;

// AudioBook będzie wyglądać tak:
/*
AudioBook {
	title: string;
	author: string;
}
*/

Mamy nowy typ AudioBook bez pola pages.

Przykład 2

Jeśli chcemy pozbyć się więcej niż jedno pole, piszemy:

interface Book {
	title: string;
	author: string;
	pages: number;
	weight: number;
}

type eBook = Omit<Book, 'pages' | 'weight'>;

// eBook będzie wyglądać tak:
/*
eBook {
	title: string;
	author: string;
}
*/

Przykład 3

Za pomocą Omit możemy także rozszerzać interfejsy:

interface Book {
	title: string;
	author: string;
	pages: number;
	weight: number;
}

interface AudioBook extends Omit<Book, 'pages' | 'weight'> {
	length: number;
}

// Interfejs AudioBook będzie wyglądać tak:
/*
interface AudioBook {
	title: string;
	author: string;
	length: number;
}
*/

Przykład 4

Dzięki Omit możemy też "nadpisać" dane pole:

interface Book {
	id: string;
	title: string;
	author: string;
}

interface AudioBook extends Omit<Book, 'id'> {
	id: number;
}

// Interfejs AudioBook będzie wyglądać tak:
/*
interface AudioBook {
	id: number;
	title: string;
	author: string;
}
*/

W interfejsie Book mamy pole id o typie string. A w nowym typie AudioBook potrzebujemy wszystkie pola z Book tylko pole id powinno być typu number. Dzięki Omit jak widać, można to łatwo osiągnąć.

Załóżmy, że mamy taki model danych:

{
	title: string,
	status: string | null
}

Poniżej przykład danych na podstawie tego modelu:

[
	{
		title: "Status Draft"
		status: "draft"
	}
	{
		title: "Status Null"
		status: null
	},
	{
		title: "Status Closed"
		status: "closed"
	}
]

I teraz potrzebujemy napisać zapytanie, które pobierze nam dane na podstawie pola status: pobierz rekordy dla wartości X lub dla null.

Wystarczy napisać:

db.find({
  $or: [
		{ 
			status: { $eq: 'draft' }
		},
		{
			status: { $type: 'null' } 
		}
	]
})

Korzystamy tutaj z operatora $or: sprawdzamy najpierw, czy istnieją rekordy o podanej wartości i dodatkowo informujemy za pomocą $type, że chcemy pobrać także rekordy z wartością null.

W tym przypadku zwróci dwa rekordy:

[
	{
		title: "Status Draft"
		status: "draft"
	}
	{
		title: "Status Null"
		status: null
	}
]

Jest kilka sposobów na rozwiązanie tego problemu. Tutaj podaję jeden z nich:

const data = [1, 2, 3, 1, 7, 7, 5, 1, 8, 9];

const removeDuplicates = (someData) => {
  return Array.from(new Set(someData));
};

console.log('data: ', removeDuplicates(data)); // [1, 2, 3, 7, 5, 8, 9]

Najpierw przekazujemy tablicę do klasy Set dzięki, której pozbędziemy się duplikatów. Na koniec przy użyciu metody from z klasy Array zamieniamy obiekt Set w tablicę.

Operator pluck działa bardzo podobnie do opisanego operatora map.

Jeśli potrzebujemy wyłuskać dane z jednej właściwości, ten operator idealnie się do tego nadaje.

Przykłady

Przykład 1

import { from } from 'rxjs';
import { pluck } from 'rxjs/operators';

const data = [
    {
        title: 'Foo',
        value: 1
    },
    {
        title: 'Bar',
        value: 2
    }
];

const observable = from(data).pipe(
    pluck('title')
);
observable.subscribe(console.log);
// Wynik
// Foo
// Bar

Przykład 2

Za pomocą operatora pluck możemy też pobrać zagnieżdżone wartości:

import { from } from 'rxjs';
import { pluck } from 'rxjs/operators';

const data = [
    {
        title: 'Foo',
        value: {
            amount: 100,
            currency: 'PLN'
        }
    },
    {
        title: 'Bar',
        value: {
            amount: 700,
            currency: 'EUR'
        }
    }
];

const observable = from(data).pipe(
    pluck('value', 'currency')
);
observable.subscribe(console.log);
// Wynik
// PLN
// EUR