zwitch

What is zwitch?

The zwitch npm package is a utility for handling polymorphic dispatch based on a property value. It allows you to define a default handler and specific handlers for different values of a given property. This can be particularly useful for tasks like routing, handling different types of data structures, or implementing pattern matching in your code.

What are zwitch's main functionalities?

Handling different types of messages

This feature demonstrates how zwitch can be used to handle different types of messages based on their 'type' property. It shows setting up handlers for specific types and handling invalid or unknown types.

{"const zwitch = require('zwitch');\nconst handle = zwitch('type');\n\nhandle.invalid = (value) => { console.error('Invalid type:', value); };\nhandle.unknown = (value) => { console.error('Unknown type:', value); };\nhandle.handlers.string = (value) => { console.log('String:', value); };\nhandle.handlers.number = (value) => { console.log('Number:', value); };\n\nhandle({type: 'string', value: 'Hello, world!'});\nhandle({type: 'number', value: 42});\nhandle({type: 'boolean', value: true});"}

Default and specific handling

This feature illustrates using zwitch to define a default handler and a specific handler for the 'foo' key. It demonstrates how unhandled keys are processed by the default handler.

{"const zwitch = require('zwitch');\nconst handle = zwitch('key');\n\nhandle.default = (value) => { console.log('Default handler:', value); };\nhandle.handlers.foo = (value) => { console.log('Handled foo:', value); };\n\nhandle({key: 'foo', value: 'bar'});\nhandle({key: 'baz', value: 'qux'});"}

Other packages similar to zwitch

pattern-match

This package provides functionality for pattern matching in JavaScript, similar to functional programming languages. It's comparable to zwitch in enabling conditional logic based on values, but it uses a different syntax and approach, focusing on matching patterns rather than dispatching based on property values.

README

zwitch

Handle values based on a property.

Installation

npm:

npm install zwitch

Usage

var zwitch = require('zwitch');
var handle = zwitch('type');

handle.invalid = invalid;
handle.unknown = unknown;
handle.handlers.alpha = handle;

handle({type: 'alpha'});

Or, with a switch statement:

function handle(value) {
  var fn;

  if (!value || typeof value !== 'object' || !(type in value)) {
    fn = invalid;
  } else {
    switch (value.type) {
      case 'alpha':
        fn = handle;
        break;
      default:
        fn = unknown;
        break;
    }
  }

  return fn.apply(this, arguments);
}

handle({type: 'alpha'});

API

zwitch(key[, options])

Create a functional switch, based on a key (string).

options

Options can be omitted and added later to one.

• handlers (Object.<Function>, optional) — Object mapping values to handle, stored on one.handlers;
• invalid (Function, optional) — Handle values without key, stored on one.invalid;
• unknown (Function, optional) — Handle values with an unhandled key, stored on one.unknown;

Returns

Function — See one.

one(value[, rest...])

Handle one value. Based on the bound key, a respective handler will be invoked. If value is not an object, or doesn’t have a key property, the special “invalid” handler will be invoked. If value has an unknown key, the special “unknown” handler will be invoked.

All arguments, and the context object, are passed through to the handler, and it’s result is returned.

one.handlers

Map of handlers (Object.<string, Function>).

one.invalid

Special handler invoked if a value doesn’t have a key property. If not set, undefined is returned for invalid values.

one.unknown

Special handler invoked if a value does not have a matching handler. If not set, undefined is returned for unknown values.

function handler(value[, rest...])

Handle one value.

License

MIT © Titus Wormer