https://github.com/astoilkov/good-try
Tries to execute a sync/async function, returns a specified default value if the function throws
https://github.com/astoilkov/good-try
error-handling errors nice-try try-catch
Last synced: 10 months ago
JSON representation
Tries to execute a sync/async function, returns a specified default value if the function throws
- Host: GitHub
- URL: https://github.com/astoilkov/good-try
- Owner: astoilkov
- License: mit
- Created: 2022-07-02T15:52:51.000Z (over 3 years ago)
- Default Branch: main
- Last Pushed: 2022-12-19T13:04:48.000Z (about 3 years ago)
- Last Synced: 2025-04-14T02:07:06.498Z (10 months ago)
- Topics: error-handling, errors, nice-try, try-catch
- Language: TypeScript
- Homepage:
- Size: 28.3 KB
- Stars: 18
- Watchers: 2
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
- License: license
Awesome Lists containing this project
README
# `good-try`
> Tries to execute a sync/async function, returns a specified default value if the function throws.
[](https://bundlephobia.com/result?p=good-try)
[](https://github.com/astoilkov/good-try/actions/workflows/main.yml)
## Why
Why not [`nice-try`](https://github.com/electerious/nice-try) with it's 70+ million downloads per month?
- `good-try` supports async functions.
- `good-try` supports an optional default value.
- `good-try` allows you to capture the thrown error.
- `good-try` is written in TypeScript. The types are written in a way that reduce developer errors. For example, I sometimes incorrectly type `goodTry(readFileSync())`, but the types don't allow this.
- `good-try` has a friend — [`settle-it`](https://github.com/astoilkov/settle-it).
- I aim for high-quality with [my open-source principles](https://astoilkov.com/my-open-source-principles).
Why not just `try`/`catch`?
- In a lot of cases, `try`/`catch` is still the better option.
- Nested `try`/`catch` statements are hard to process mentally. They also indent the code and make it hard to read. A single `try`/`catch` does the same but to a lesser degree.
- If you [prefer const](https://eslint.org/docs/latest/rules/prefer-const), `try`/`catch` statements get in the way because you need to use `let` if you need the variable outside of the `try`/`catch` scope:
```ts
let todos;
try {
todos = JSON.parse(localStorage.getItem('todos'))
} catch {}
return todos.filter(todo => todo.done)
```
- It takes more space. It's slower to type.
## Install
```bash
npm install good-try
```
## Usage
```ts
import goodTry from 'good-try'
// tries to parse todos, returns empty array if it fails
const value = goodTry(() => JSON.parse(todos), [])
// fetch todos, on error, fallback to empty array
const todos = await goodTry(fetchTodos(), [])
// fetch todos, fallback to empty array, send error to your error tracking service
const todos = await goodTry(fetchTodos(), (err) => {
sentToErrorTrackingService(err)
return []
})
```
## API
**First parameter** accepts:
- synchronous function `goodTry(() => JSON.parse(value))`
- asynchronous function / Promise
- synchronous function that returns a promise
**Second parameter** accepts:
- any value that will be returned if the first parameter throws
- a callback that receives `err` as first parameter (the return value of the callback is returned if the first parameter throws)
If you use TypeScript, the types are well defined and won't let you make a mistake.
## Related
- [settle-it](https://github.com/astoilkov/settle-it) – Like `Promise.allSettled()` but for sync and async functions. Similarly to `good-try` it handles sync/async functions that throw an error. However, it returns an object so you know if and what error was thrown.