Socket
Book a DemoInstallSign in
Socket

lazy-getter

Package Overview
Dependencies
Maintainers
1
Versions
4
Alerts
File Explorer

Advanced tools

Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

lazy-getter

[![npm version](https://badge.fury.io/js/lazy-getter.svg)](https://badge.fury.io/js/lazy-getter) [![GitHub version](https://badge.fury.io/gh/briandamaged%2Fnode-lazy-getter.svg)](https://badge.fury.io/gh/briandamaged%2Fnode-lazy-getter)

1.0.0
latest
Source
npmnpm
Version published
Maintainers
1
Created
Source

lazy-getter

npm version GitHub version

Lazily evaluate properties and cache the results.

Installation

npm install lazy-getter

Usage

Plain-Old Javascript

If you're using plain-old Javascript, then you can inject lazy getters into your objects via the injectLazyGetter(...) function:

const { injectLazyGetter } = require('lazy-getter');

const x = {};

// Notice: this getter is computationally expensive to run!
injectLazyGetter(x, "expensive", function() {
  console.log("Starting calculations");
  let k = 0;
  for(let i = 0; i < 100000; ++i) {
    for(let j = 0; j < 100000; ++j) {
      ++k;
    }
  }

  console.log("Finished expensive calculation!");
  return k;
});


// The getter will be evaluated the first time it is invoked
console.log(x.expensive);  // Super SLOW!


// Now the result is cached.  So, all subsequent calls will
// just be regular property lookups.
console.log(x.expensive);  // Super FAST!

Decorators

If you're using Babel's Decorators Transform, then you can convert your getters to lazy getters via the @lazyGetter decorator:

const { lazyGetter } = require('lazy-getter');

const x = {
  @lazyGetter
  get expensive() {
    console.log("Starting calculations");
    let k = 0;
    for(let i = 0; i < 100000; ++i) {
      for(let j = 0; j < 100000; ++j) {
        ++k;
      }
    }

    console.log("Finished expensive calculation!");
    return k;
  },
};

console.log(x.expensive); // Super SLOW!
console.log(x.expensive); // Super FAST!

...Why?

Lazy Getters might seem a bit esoteric, but they are definitely very handy in certain scenarios. Here are a few examples:

Rarely-needed, but Computationally-Expensive Property

For example:

class HumongousNumber {

  @lazyGetter
  get primeFactorization() {
    // Algorithm that returns an Array of prime factors
    // for the number.  Might take years to run.
  }
}

Infinite Object Graphs

Sometimes, it's useful to model a problem as an infinite graph of Objects. Obviously, you can't actually contruct this infinite graph since it would require an unlimited about of time and memory. Fortunately, you can "fake it" using lazy getters:


function integerNode(i) {
  return {
    value: i,

    @lazyGetter
    get next() {
      return integerNode(i + 1);
    },
  }
}

const x = integerNode(0);

console.log(x.next.next.next.next.value); // Prints: 4

Now the object graph will be constructed as needed.

FYI: zelda-lists leverages this technique to convert any iterable Object into a linked list. This allows infinite iterators to be converted into infinite object graphs, which makes it significantly easier to implement recursive algorithms.

Keywords

lazy

FAQs

Package last updated on 19 Feb 2018

Did you know?

Socket

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc

U.S. Patent No. 12,346,443 & 12,314,394. Other pending.