# switchee

> Switch on Steroids

Latest version **1.0.2** (published 2018-11-02) · MIT license · 0 weekly downloads

## Install

```sh
npm install switchee
pnpm add switchee
yarn add switchee
bun add switchee
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.0.2 |
| Published | 2018-11-02 |
| First published | 2018-11-02 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 15 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Author | JoniBR |
| Maintainers | jonibr |

## Links

- npm: https://www.npmjs.com/package/switchee
- npm.io page: https://npm.io/package/switchee

## Recent versions

- 1.0.2 (latest) — 2018-11-02

## README

# Switchee

Powerful alternative to JavaScript's vanilla switch statement.
Lets you create different cases that will match on one of this **_matchers:_**

- [isEqual](#basic-usage)
- [inRange](#inrange)
- [isType](#istype)

Checkout the [examples](./examples/) directory for a working examples.

## Install

    npm install switchee

## Basic Usage

```javascript
import $switch from "switchee";

/**
$switch(cases :Array *required , defaultAction : object | function)
$switch expects an array of case object,
and can use a default action that will be called when there is no match
**/
const switchee = $switch(
  [
    {
      matcher: "isEqual",
      params: ["hello", "hey", "yo"], // will call action if one of the params is equal to switch input
      action: () => console.log("Recived a greeting!")
    },
    {
      matcher: "isEqual",
      params: "goodbye", // can also recieve only one value to match
      action: () => console.log("farwell"),
      break: true // will break and not look for any more matches
    },
    {
      matcher: "isEqual",
      params: "goodbye",
      action: () => console.log("arrivederci")
    },
    {
      matcher: "isEqual",
      params: ["don't you repeat me!"],
      useVal: true, // when useVal is true action is called with the value matched
      action: val => console.log(val)
    }
  ],
  () => console.log("No match!?!") // defaultAction will be called when there is no match
);

const words = [
  "hello",
  "hey",
  "lets try this",
  "don't you repeat me!",
  "goodbye"
];

words.forEach(word => switchee(word));
```

```
output:
Recived a greeting!
Recived a greeting!
No match!?!
don't you repeat me!
farwell
```

## The case object

```javascript
  {
  matcher: string , // *required - the type of matcher to be used in this case
  params : array // *required -  array of paramaters for the matcher | one param for the matcher
  action: function // *required - the function that will be called in the event of a match
  useVal : boolean // when true action is called using the switch argument as an argument
  break: boolean // when true if this case is matched , it will be that last one checked
  op: string // used in case mathcers have multiple operations
  useProperty : string // when provided the matcher will use the switch argument at the property
  }
```

## Other matchers

### inRange

Will match case if number is in given range
uses the following ops:

```
'between'- params[0] < val < params[1]
'between-inclusive'-params[0] <= val <= params[1]
'between-left-inclusive-params[0] <= val < params[1]
'between-right-inclusive'-params[0] < val <= params[1]
'bigger'-params[0] < val
'bigger-equals'- params[0] <= val
'smaller'- params[0] > val
'smaller-equals'-params[0] => val
```

For example , lets sort people to groups by age :

```javascript
import $switch from "switchee";

// lets sort people into groups by age
const ageGroups = {
  infants: [],
  kids: [],
  teens: [],
  adults: [],
  oldTimers: [],
  epics: []
};
const switchee = $switch([
  {
    matcher: "inRange",
    params: 4,
    op: "smaller-equals",
    useVal: true,
    action: infant => ageGroups.infants.push(infant),
    useProperty: "age" // uses the properety provided for to match the case
  },
  {
    matcher: "inRange",
    params: [5, 12],
    op: "between-inclusive",
    useVal: true,
    action: kid => ageGroups.kids.push(kid),
    useProperty: "age"
  },
  {
    matcher: "inRange",
    params: [12, 20],
    op: "between",
    useVal: true,
    action: teen => ageGroups.teens.push(teen),
    useProperty: "age"
  },
  {
    matcher: "inRange",
    params: [20, 70],
    op: "between-inclusive",
    useVal: true,
    action: adult => ageGroups.adults.push(adult),
    useProperty: "age"
  },
  {
    matcher: "inRange",
    params: [70, 100],
    op: "between",
    useVal: true,
    action: oldTimer => ageGroups.oldTimers.push(oldTimer),
    useProperty: "age"
  },
  {
    matcher: "inRange",
    params: 100,
    op: "bigger-equals",
    useVal: true,
    action: epic => ageGroups.epics.push(epic),
    useProperty: "age"
  }
]);

const people = [
  { name: "Yoni", age: 26 },
  { name: "Anna", age: 28 },
  { name: "Alon", age: 4 },
  { name: "Nava", age: 12 },
  { name: "George", age: 55 },
  { name: "Billi", age: 72 },
  { name: "Pablo", age: 120 }
];

people.forEach(person => switchee(person));
console.log(ageGroups);
```

```
output :
{ infants: [ { name:  'Alon', age:  4 } ],

kids: [ { name:  'Nava', age:  12 } ],

teens: [],

adults:

[ { name:  'Yoni', age:  26 },

{ name:  'Anna', age:  28 },

{ name:  'George', age:  55 } ],

oldTimers: [ { name:  'Billi', age:  72 } ],

epics: [ { name:  'Pablo', age:  120 } ] }
```

### isType

will match if type the of switch argument equals one of the params provided,
will also match on ES6 classes :

```javascript
import $switch from "switchee";

class Test {
  test() {
    console.log("this is a test");
  }
}

const switchee = $switch([
  {
    matcher: "isType",
    params: "number",
    useVal: true,
    action: num => console.log(num + 1)
  },
  {
    matcher: "isType",
    params: ["string"],
    useVal: true,
    action: name => console.log(`hello ${name}`)
  },
  {
    matcher: "isType",
    params: "Test", // isType mathcer will also match to the class of the switch argument
    useVal: true,
    action: test => test.test()
  }
]);

const things = [1, 2, "Trump", new Test()];

things.forEach(thing => switchee(thing));
```

> Written with [StackEdit](https://stackedit.io/).

---
_Source: https://npm.io/package/switchee · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._