https://github.com/aneldev/dyna-count

For loop replacement
https://github.com/aneldev/dyna-count

Last synced: 1 day ago
JSON representation

For loop replacement

• Host: GitHub
• URL: https://github.com/aneldev/dyna-count
• Owner: aneldev
• License: mit
• Created: 2020-06-05T08:19:19.000Z (over 4 years ago)
• Default Branch: master
• Last Pushed: 2022-12-12T23:56:25.000Z (almost 2 years ago)
• Last Synced: 2023-02-27T01:31:41.162Z (over 1 year ago)
• Language: JavaScript
• Size: 3.46 MB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 20
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# About dyna-count

Simplifies the `for` loop.

It also offers a `map`.

# for

Instead of

`for (let i = 0; i < 1000; i++) console.log(i);`

you can

`count(1000).for(i => console.log(i))`

or simpler

`count(1000).for(console.log)`

You can `for` with step

`count(10, 2).for(index => console.log(index))` // consoles: 0, 2, 4, 6, 8

You can `break` a `for`, calling the 2nd argument of the `for`'s callback

```

let collected = [];

count(20).for((index, breakIt) => {

    collected.push(index);

    if (index === 9) breakIt();

});

// 0..9 items are only collected

```

# map

You can `map` also the iteration, useful for data generation.

```

let items = [];

count(3).map(i => items.push(i));

// items is now [0, 1, 2]

```

In Typescript, `map` supports types, for example:

```

let items: string[] = [];

count(3).map(i => items.push(i.toString()));

// items is now ['0', '1', '2']

```

You can `map` with `step` in the same way as with `for`.

You can `break` in the same way as with `for`.

# countFromTo

Similarly, we have and the  `countFromTo`

- `for`

`countFromTo(100, 200).for(i => console.log(i))`

- `map`

```

let items = [];

countFromTo(10, 13).map(i => items.push(i));

// items is now [10, 11, 12]

```

# reduce

```

reduced = count(3).reduce>((acc, index) => {

  acc[`key-${index}`] = `Key is ${index}`;

  return acc;

}, {});

// reduced is equal to {"key-0": "Key is 0", "key-1": "Key is 1", "key-2": "Key is 2" }

```

# Import

`import {count, countFromTo} from "dyna-count";`

# Signatures

`count/countFromTo(countTo: number).for: (cb: (index: number, cbBreak: () => void) => void): void`

`count/countFromTo(countTo: number).map: (cb: (index: number, cbBreak: () => void) => T): T[]`

`count/countFromTo(countTo: number).reduce: (cb: (acc: T, index: number) => T, initialValue: T): T`