lodash.LoDashStatic.isBuffer JavaScript and Node.js code examples

function testGetStringSync(declaration) {
      var getString = lib.interface.getString;
      assert(_.isFunction(getString));
      assert(getString.function);
      assert.equal(getString.function.toString(), declaration);
      var string = getString();
      assert(_.isBuffer(string));
      assert(_.isObject(string.type));
      assert.equal(string.type.name, 'char');
      assert.equal(string.type.indirection, 1);
      assert.equal(string.length, 0);
      assert.equal(ref.readCString(string), 'world');
    }

async(function* (declaration) {
      const getString = lib.interface.getString;
      assert(_.isFunction(getString));
      assert.equal(getString.function.toString(), declaration);
      const string = yield getString();
      assert(_.isBuffer(string));
      assert(_.isObject(string.type));
      assert.equal(string.type.name, 'char');
      assert.equal(string.type.indirection, 1);
      assert.equal(ref.readCString(string), 'world');
    })

function toHex(v) {
  if (_.isNumber(v))
    return '0x'+(new ethjs.BN(v).toString(16));
  if (_.isString(v)) {
    if (v.startsWith('0x'))
      return v.toLowerCase();
    return '0x'+(new ethjs.BN(v).toString(16));
  }
  if (_.isBuffer(v) || _.isArrayLike(v))
    return ethjs.bufferToHex(v);
  throw new Error(`Can't convert value to hex: ${v}`);
}

Promise.all(
   files.map(async stream => {
    const parts = await toArray(fs.createReadStream(stream.path));
    const buffers = parts.map(
     part => (_.isBuffer(part) ? part : Buffer.from(part)),
    );

    const buffer = Buffer.concat(buffers);

    return {
     tmpPath: stream.path,
     name: stream.name,
     sha256: niceHash(buffer),
     hash: uuid().replace(/-/g, ''),
     ext:
      stream.name.split('.').length > 1
       ? `.${_.last(stream.name.split('.'))}`
       : '',
     buffer,
     mime: stream.type,
     size: (stream.size / 1000).toFixed(2),
    };
   }),
  )

// void getNumbers(double** nums, size_t* size)
    function testGetNumbersSync(declaration) {
      var getNumbers = lib.interface.getNumbers;
      assert(_.isFunction(getNumbers));
      assert.equal(getNumbers.function.toString(), declaration);

      var double = ref.types.double;
      var doublePtrType = ref.refType(double);
      var doublePtrPtr = ref.alloc(doublePtrType);
      var sizeTPtr = ref.alloc('size_t');
      getNumbers(doublePtrPtr, sizeTPtr);

      var size = ref.deref(sizeTPtr);
      assert.equal(size, 3);
      var doublePtr = ref.deref(doublePtrPtr);
      assert(_.isBuffer(doublePtr));
      var first = ref.deref(doublePtr);
      assert(_.isNumber(first));
      assert.equal(first, 1.1);
      doublePtr = ref.reinterpret(doublePtr, size * double.size);
      assert.equal(double.get(doublePtr, 1 * double.size), 2.2);
      assert.equal(double.get(doublePtr, 2 * double.size), 3.3);
    }

function testRefInterface() {
    assert(_.isFunction(lib.interface.TFloats));
    assert(_.isObject(lib.interface.TFloats.array));
    assert.strictEqual(lib.interface.TFloats.array, lib.arrays.TFloats);
    assert.equal(lib.interface.TFloats.array.name, 'TFloats');
    var buff = lib.interface.TFloats([1, 2, 3]);
    assert(_.isBuffer(buff));
    assert.equal(buff.length, 3 * ref.types.float.size);

    assert(_.isFunction(lib.interface.TStuff));
    assert(_.isObject(lib.interface.TStuff.struct));
    assert.strictEqual(lib.interface.TStuff.struct, lib.structs.TStuff);
    assert.equal(lib.interface.TStuff.struct.name, 'TStuff');
    var rec = lib.structs.TStuff.type({ more: [1, 2, 3, 4] });
    assert.strictEqual(rec.more, rec.more);
    assert.equal(rec.more.get(0), 1);
    assert.equal(rec.more.get(1), 2);
    assert.equal(rec.more.get(2), 3);
    assert.equal(rec.more.get(3), 4);
    assert.equal(rec.more.length, 4);

    assert(_.isFunction(lib.interface.T42));
    assert(_.isObject(lib.interface.T42.union));
    assert.strictEqual(lib.interface.T42.union, lib.unions.T42);
    assert.equal(lib.interface.T42.union.name, 'T42');
    var uni = lib.unions.T42.type({ v1: 42 });
    assert.strictEqual(uni.v1, uni.v1);
    assert.equal(uni.v1, 42);
  }

assert(_.isBuffer(pLib));
assert.equal(pLib.length, 0);
const pMul = dynload.findSymbol(pLib, 'mul');
assert.ok(pMul);
assert(_.isBuffer(pMul));
assert.equal(pMul.length, 0);
dynload.freeLibrary(pLib);

async(function* (declaration) {
      const getNumbers = lib.interface.getNumbers;
      assert(_.isFunction(getNumbers));
      assert.equal(getNumbers.function.toString(), declaration);

      const double = ref.types.double;
      const doublePtrType = ref.refType(double);
      const doublePtrPtr = ref.alloc(doublePtrType);
      const sizeTPtr = ref.alloc('size_t');
      yield getNumbers(doublePtrPtr, sizeTPtr);

      const size = ref.deref(sizeTPtr);
      assert.equal(size, 3);
      let doublePtr = ref.deref(doublePtrPtr);
      assert(_.isBuffer(doublePtr));
      const first = ref.deref(doublePtr);
      assert(_.isNumber(first));
      assert.equal(first, 1.1);
      doublePtr = ref.reinterpret(doublePtr, size * double.size);
      assert.equal(double.get(doublePtr, 1 * double.size), 2.2);
      assert.equal(double.get(doublePtr, 2 * double.size), 3.3);
    })

async(regeneratorRuntime.mark(function _callee5(declaration) {
      var getString, string;
      return regeneratorRuntime.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              getString = lib.interface.getString;

              assert(_.isFunction(getString));
              assert.equal(getString.function.toString(), declaration);
              _context5.next = 5;
              return getString();

            case 5:
              string = _context5.sent;

              assert(_.isBuffer(string));
              assert(_.isObject(string.type));
              assert.equal(string.type.name, 'char');
              assert.equal(string.type.indirection, 1);
              assert.equal(ref.readCString(string), 'world');

            case 11:
            case 'end':
              return _context5.stop();
          }
        }
      }, _callee5, this);
    }))

function testGetStringSync(declaration) {
      var getString = lib.interface.getString;
      assert(_.isFunction(getString));
      assert(getString.function);
      assert.equal(getString.function.toString(), declaration);
      var string = getString();
      assert(_.isBuffer(string));
      assert(_.isObject(string.type));
      assert.equal(string.type.name, 'char');
      assert.equal(string.type.indirection, 1);
      assert.equal(string.length, 0);
      assert.equal(ref.readCString(string), 'world');
    }

function testGetStringSync(declaration) {
      const getString = lib.interface.getString;
      assert(_.isFunction(getString));
      assert(getString.function);
      assert.equal(getString.function.toString(), declaration);
      const string = getString();
      assert(_.isBuffer(string));
      assert(_.isObject(string.type));
      assert.equal(string.type.name, 'char');
      assert.equal(string.type.indirection, 1);
      assert.equal(string.length, 0);
      assert.equal(ref.readCString(string), 'world');
    }

// void getNumbers(double** nums, size_t* size)
    function testGetNumbersSync(declaration) {
      var getNumbers = lib.interface.getNumbers;
      assert(_.isFunction(getNumbers));
      assert.equal(getNumbers.function.toString(), declaration);

      var double = ref.types.double;
      var doublePtrType = ref.refType(double);
      var doublePtrPtr = ref.alloc(doublePtrType);
      var sizeTPtr = ref.alloc('size_t');
      getNumbers(doublePtrPtr, sizeTPtr);

      var size = ref.deref(sizeTPtr);
      assert.equal(size, 3);
      var doublePtr = ref.deref(doublePtrPtr);
      assert(_.isBuffer(doublePtr));
      var first = ref.deref(doublePtr);
      assert(_.isNumber(first));
      assert.equal(first, 1.1);
      doublePtr = ref.reinterpret(doublePtr, size * double.size);
      assert.equal(double.get(doublePtr, 1 * double.size), 2.2);
      assert.equal(double.get(doublePtr, 2 * double.size), 3.3);
    }

// void getNumbers(double** nums, size_t* size)
    function testGetNumbersSync(declaration) {
      const getNumbers = lib.interface.getNumbers;
      assert(_.isFunction(getNumbers));
      assert.equal(getNumbers.function.toString(), declaration);

      const double = ref.types.double;
      const doublePtrType = ref.refType(double);
      const doublePtrPtr = ref.alloc(doublePtrType);
      const sizeTPtr = ref.alloc('size_t');
      getNumbers(doublePtrPtr, sizeTPtr);

      const size = ref.deref(sizeTPtr);
      assert.equal(size, 3);
      let doublePtr = ref.deref(doublePtrPtr);
      assert(_.isBuffer(doublePtr));
      const first = ref.deref(doublePtr);
      assert(_.isNumber(first));
      assert.equal(first, 1.1);
      doublePtr = ref.reinterpret(doublePtr, size * double.size);
      assert.equal(double.get(doublePtr, 1 * double.size), 2.2);
      assert.equal(double.get(doublePtr, 2 * double.size), 3.3);
    }

function testRefInterface() {
    assert(_.isFunction(lib.interface.TFloats));
    assert(_.isObject(lib.interface.TFloats.array));
    assert.strictEqual(lib.interface.TFloats.array, lib.arrays.TFloats);
    assert.equal(lib.interface.TFloats.array.name, 'TFloats');
    let buff = lib.interface.TFloats([1, 2, 3]);
    assert(_.isBuffer(buff));
    assert.equal(buff.length, 3 * ref.types.float.size);

    assert(_.isFunction(lib.interface.TStuff));
    assert(_.isObject(lib.interface.TStuff.struct));
    assert.strictEqual(lib.interface.TStuff.struct, lib.structs.TStuff);
    assert.equal(lib.interface.TStuff.struct.name, 'TStuff');
    let rec = lib.structs.TStuff.type({ more: [1, 2, 3, 4] });
    assert.strictEqual(rec.more, rec.more);
    assert.equal(rec.more.get(0), 1);
    assert.equal(rec.more.get(1), 2);
    assert.equal(rec.more.get(2), 3);
    assert.equal(rec.more.get(3), 4);
    assert.equal(rec.more.length, 4);

    assert(_.isFunction(lib.interface.T42));
    assert(_.isObject(lib.interface.T42.union));
    assert.strictEqual(lib.interface.T42.union, lib.unions.T42);
    assert.equal(lib.interface.T42.union.name, 'T42');
    let uni = lib.unions.T42.type({ v1: 42 });
    assert.strictEqual(uni.v1, uni.v1);
    assert.equal(uni.v1, 42);
  }

async( /*#__PURE__*/regeneratorRuntime.mark(function _callee7(declaration) {
      var getString, string;
      return regeneratorRuntime.wrap(function _callee7$(_context7) {
        while (1) {
          switch (_context7.prev = _context7.next) {
            case 0:
              getString = lib.interface.getString;

              assert(_.isFunction(getString));
              assert.equal(getString.function.toString(), declaration);
              _context7.next = 5;
              return getString();

            case 5:
              string = _context7.sent;

              assert(_.isBuffer(string));
              assert(_.isObject(string.type));
              assert.equal(string.type.name, 'char');
              assert.equal(string.type.indirection, 1);
              assert.equal(ref.readCString(string), 'world');

            case 11:
            case 'end':
              return _context7.stop();
          }
        }
      }, _callee7, this);
    }))

JSDoc

Checks if value is a buffer.

Most used lodash functions

LoDashStatic.map
Creates an array of values by running each element in collection through iteratee. The iteratee is
LoDashStatic.isEmpty
Checks if value is empty. A value is considered empty unless it’s an arguments object, array, string
LoDashStatic.forEach
Iterates over elements of collection invoking iteratee for each element. The iteratee is invoked wit
LoDashStatic.find
Iterates over elements of collection, returning the first element predicate returns truthy for.
LoDashStatic.pick
Creates an object composed of the picked `object` properties.

Popular in JavaScript

crypto
webpack
Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.
chalk
Terminal string styling done right
colors
get colors in your node.js console
cheerio
Tiny, fast, and elegant implementation of core jQuery designed specifically for the server
through2
A tiny wrapper around Node.js streams.Transform (Streams2/3) to avoid explicit subclassing noise
mime-types
The ultimate javascript content-type utility.
aws-sdk
AWS SDK for JavaScript
express
Fast, unopinionated, minimalist web framework
From CI to AI: The AI layer in your organization

How to use isBufferfunctionin LoDashStatic

Best JavaScript code snippets using lodash.LoDashStatic.isBuffer(Showing top 15 results out of 315)

How to use
isBuffer
function
in
LoDashStatic