CodeBlanks Logo Icon CodeBlanks
Login Register

Integration

Build the working library by combining all parts.

Combine all parts

The library project has four main functions: addBook (add), searchByTitle (search), borrowBook (borrow), returnBook (return). In a session you first add books, then borrow, and finally return.

function addBook(lib: Library, book: Book): void { /* ... */ }
function searchByTitle(lib: Library, title: string): Book[] { /* ... */ }
function borrowBook(lib: Library, bookId: string): boolean { /* ... */ }
function returnBook(lib: Library, bookId: string): boolean { /* ... */ }

Working example

Let's add two books, borrow one, return it, and finally search by title. Borrowing and returning change the available field.

const lib: Library = { books: [] };
addBook(lib, { id: "b1", title: "TypeScript", author: "Ada", available: true });
addBook(lib, { id: "b2", title: "Python", author: "Bob", available: true });
borrowBook(lib, "b1");
returnBook(lib, "b1");
const results = searchByTitle(lib, "Script");
console.log(results.length);

Practice Write the working library

Define Book, Member, Library interfaces. Write addBook, searchByTitle, borrowBook, returnBook functions. Add two books ("TypeScript", "Python"), borrow one ("b1") and return it, search for "Script" and print the number of matches.

Starter code

index.ts
// Book, Member, Library arayüzlerini tanımla
// addBook, searchByTitle, borrowBook, returnBook fonksiyonlarını yaz
// iki kitap ekle (TypeScript ve Python)
// birini ödünç al, iade et
// "Script" ile ara ve eşleşen sayısını yazdır

Sample solution

index.ts
interface Book { id: string; title: string; author: string; available: boolean; }
interface Member { id: string; name: string; }
interface Library { books: Book[]; }

function addBook(lib: Library, book: Book): void {
  lib.books.push(book);
}

function searchByTitle(lib: Library, title: string): Book[] {
  return lib.books.filter(b => b.title.includes(title));
}

function borrowBook(lib: Library, bookId: string): boolean {
  const book = lib.books.find(b => b.id === bookId);
  if (book && book.available) {
    book.available = false;
    return true;
  }
  return false;
}

function returnBook(lib: Library, bookId: string): boolean {
  const book = lib.books.find(b => b.id === bookId);
  if (book && !book.available) {
    book.available = true;
    return true;
  }
  return false;
}

const lib: Library = { books: [] };
addBook(lib, { id: "b1", title: "TypeScript", author: "Ada", available: true });
addBook(lib, { id: "b2", title: "Python", author: "Bob", available: true });
borrowBook(lib, "b1");
returnBook(lib, "b1");
const results = searchByTitle(lib, "Script");
console.log(results.length);

Expected output

1

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What is a sensible flow for a library session?

  • Add → borrow → return Correct answer
  • Return → add → borrow
  • Borrow → return → add
  • Add → return → borrow

Explanation: You first add a book, then borrow it, and finally return it. This order makes a sensible library session.

2 Complete the return call

Question 
const result = ____(lib, "b1");
Answer 
const result = returnBook(lib, "b1");

Explanation: To return a book you call returnBook. borrowBook lends it, addBook adds a new book, and searchByTitle only searches.

3 Integration flow

Term Meaning
addBook First step: add
borrowBook Second step: borrow
returnBook Third step: return
searchByTitle Search tool

All lessons in Beginner

1 TypeScript intro and setup

  1. What is TypeScript?
  2. Why TypeScript?
  3. tsc compiler
  4. tsconfig basics
  5. Summary - TypeScript basics

2 Primitive types

  1. string type
  2. number type
  3. boolean type
  4. let and const
  5. Summary - Primitive types

3 Arrays

  1. Array type
  2. Array methods
  3. readonly arrays
  4. Multidimensional arrays
  5. Summary - Arrays

4 Tuples

  1. What is a tuple?
  2. Tuple usage
  3. readonly tuple
  4. Summary - Tuple

5 Enums

  1. Numeric enum
  2. String enum
  3. const enum
  4. Enum members
  5. Summary - Enum

6 any, unknown, never

  1. any type
  2. unknown type
  3. never type
  4. void type
  5. Summary - Special types

7 Type annotation

  1. Variable annotation
  2. Parameter annotation
  3. Return type annotation
  4. Summary - Type annotation

8 Type inference

  1. Basic inference
  2. Inference with const
  3. Best common type
  4. Summary - Type inference

9 Objects

  1. Object type
  2. Optional properties
  3. Readonly properties
  4. Summary - Objects

10 Functions

  1. Function declaration
  2. Optional and default params
  3. Rest params
  4. Function overloads
  5. Summary - Functions

11 Arrow functions

  1. Arrow syntax
  2. this with arrow
  3. Arrow type
  4. Summary - Arrow functions

12 Interfaces

  1. What is an interface?
  2. Property types
  3. Interface vs type alias
  4. Summary - Interfaces

13 Type alias

  1. What is a type alias?
  2. Composition with alias
  3. Alias vs interface
  4. Summary - Type alias

14 Union and intersection

  1. Union types
  2. Intersection types
  3. Literal types
  4. Summary - Union & intersection

15 null and undefined

  1. null vs undefined
  2. Optional chaining
  3. Nullish coalescing
  4. Summary - null & undefined

16 Strict mode

  1. strict: true
  2. strictNullChecks
  3. strictFunctionTypes
  4. Summary - Strict mode

17 Project: Shopping cart

  1. Cart design
  2. Add product
  3. Total calculation
  4. Apply discount
  5. Integration

18 Project: Todo CLI

  1. Task model
  2. Add and list
  3. Completion
  4. Filtering
  5. Integration

19 Project: Library

  1. Book model
  2. Add and search
  3. Borrow
  4. Return
  5. Integration

20 Beginner final

  1. Challenge 1: Types
  2. Challenge 2: Functions
  3. Challenge 3: Unions
  4. Challenge 4: Mini app