# torf

> Small utility for checking if variables are defined and non empty

Latest version **1.0.7** (published 2015-05-26) · MIT license · 0 weekly downloads

## Install

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

## 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.7 |
| Published | 2015-05-26 |
| First published | 2015-04-19 |
| Weekly downloads | 0 |
| License | MIT |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 3 |
| Author | Besart Hoxhaj, William Fisher |
| Maintainers | bes, filwisher |

## Links

- npm: https://www.npmjs.com/package/torf
- Repository: https://github.com/besarthoxhaj/torf
- Issues: https://github.com/besarthoxhaj/torf/issues
- npm.io page: https://npm.io/package/torf

## Recent versions

- 1.0.7 (latest) — 2015-05-26
- 1.0.6 — 2015-04-25
- 1.0.5 — 2015-04-25
- 1.0.4 — 2015-04-25
- 1.0.3 — 2015-04-19
- 1.0.2 — 2015-04-19
- 1.0.1 — 2015-04-19
- 1.0.0 — 2015-04-19

## README

# torf

[![Build Status](https://travis-ci.org/besarthoxhaj/torf.svg?branch=master)](https://travis-ci.org/besarthoxhaj/torf) 
[![Code Climate](https://codeclimate.com/github/besarthoxhaj/torf/badges/gpa.svg)](https://codeclimate.com/github/besarthoxhaj/torf) 
[![Test Coverage](https://codeclimate.com/github/besarthoxhaj/torf/badges/coverage.svg)](https://codeclimate.com/github/besarthoxhaj/torf) 
[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/besarthoxhaj/torf/issues)


Small library for cheking if a variable is ***ok***.

	npm install torf --save

For readability I suggest to save the module in a variable called `is`.

##is.ok();

This method simply checks if a variable is ***ok*** in general terms. ***Is ok*** means that a variable is defined and in case it is an object (or array) that it is not empty or the content is not undifined or null. 

```js
var is = require('torf');

is.ok([]);            // false
is.ok({});            // false
is.ok([{}]);          // false
is.ok(NaN);           // false
is.ok(null);          // false
is.ok(Infinity);      // false
is.ok(undefined);     // false
is.ok([NaN]);         // false
is.ok([null]);        // false
is.ok([Infinity]);    // false
is.ok([undefined]);   // false
```

You can pass functions as well. In that case the function will be invoked and the test will be performed on what the function returns.

```js
is.ok(function(){});                    // false
is.ok(function(){return NaN;});         // false
is.ok(function(){return false;});       // false
is.ok(function(){return null;});        // false
is.ok(function(){return Infinity;});    // false
is.ok(function(){return undefined;});   // false
is.ok(function(){return [undefined];}); // false
```

This is done recursively, which means it is possible to nest functions.

```js
is.ok(function(){ return function(){ return false;}}); // false
is.ok(function(){ return function(){ return true;}});  // true
```


##is.type();

This method simply checks the first argument class or primitive value against the second argument.

```js
var is = require('torf');

is.type('string', 'string'); // true
is.type(['fooo'], 'array');  // true
is.type({a:'hi'}, 'string'); // false
```

It is possible to pass an array of classes as second argument, in which case it will return true if one of the classes is matched.

```js
var is = require('torf');

is.type('string', ['string', 'number', 'object']); // true
is.type(['fooo'], ['null', 'array', 'date']);      // true
is.type({a:'hi'}, ['string', 'number', 'array']);  // false
```


The comparison is done by calling the `Object.prototype.toString()` to detect object class so it's possible
to test alse `undefined === null`.

```js
is.type(undefined, 'null');  // false
is.type(null, 'null');       // true
```


##is.email();

Internally it uses a regular expression `/\S+@\S+\.\S+/` which is pretty ***generous***. If you need more restriction I suggest to look at the second example.

```js
var is = require('torf');

is.email('foo@bar.com');      // true;
is.email('foo.zoo@bar.com');  // true;
is.email('foo.zoo@bar');      // false;
is.email(null);               // false;
is.email(undefined);          // false;

```

Optionally you can pass a regular expression to check against as second parameter.

```js
var is = require('torf');

is.email('foo@bar.com', new RegExp(/[\s\S]/));  // true

```

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