parse-function

What is parse-function?

The parse-function npm package is a utility for parsing JavaScript functions to extract their name, parameters, and body. It is useful for analyzing and manipulating functions programmatically.

What are parse-function's main functionalities?

Parse Function

This feature allows you to parse a JavaScript function to extract its name, parameters, and body. The code sample demonstrates how to parse a simple function and log the parsed details.

const parseFunction = require('parse-function')();
const parsed = parseFunction.parse(function example(a, b) { return a + b; });
console.log(parsed);

Parse Arrow Function

This feature allows you to parse an arrow function. The code sample demonstrates how to parse an arrow function and log the parsed details.

const parseFunction = require('parse-function')();
const parsed = parseFunction.parse((a, b) => a + b);
console.log(parsed);

Parse Async Function

This feature allows you to parse an async function. The code sample demonstrates how to parse an async function and log the parsed details.

const parseFunction = require('parse-function')();
const parsed = parseFunction.parse(async function example(a, b) { return a + b; });
console.log(parsed);

Other packages similar to parse-function

esprima

Esprima is a high-performance, standard-compliant ECMAScript parser. It can parse JavaScript code into an abstract syntax tree (AST), which can then be analyzed or transformed. Compared to parse-function, Esprima provides a more comprehensive parsing capability but requires more effort to extract specific function details.

acorn

Acorn is a small, fast, JavaScript-based JavaScript parser. It generates an abstract syntax tree (AST) from JavaScript code. Similar to Esprima, Acorn offers a broader parsing capability but requires additional steps to extract function-specific information compared to parse-function.

README

parse-function

Parse a function into an object using espree, acorn or babylon parsers. Extensible through Smart Plugins

You might also be interested in function-arguments library if you need more lightweight solution and need for just getting the names of the function arguments.

Quality Assurance :100:

If you have any how-to kind of questions, please read Code of Conduct and join the chat room or open an issue.
You may also read the Contributing Guide. There, beside "How to contribute?", we describe everything stated by the badges.

Features

• Always up-to-date: auto-publish new version when new version of dependency is out, Renovate
• Standard: using StandardJS, Prettier, SemVer, Semantic Release and conventional commits
• Smart Plugins: for extending the core API or the end Result, see .use method and Plugins Architecture
• Extensible: using plugins for working directly on AST nodes, see the Plugins Architecture
• ES2017 Ready: by using .parseExpression method of the babylon v7.x parser
• Customization: allows switching the parser, through options.parse
• Support for: arrow functions, default parameters, generators and async/await functions
• Stable: battle-tested in production and against all parsers - espree, acorn, babylon
• Tested: with 275+ tests for 200% coverage

Table of Contents

• Install
• API
  • parseFunction
  • .parse
  • .use
  • .define
• Related
• Contributing
• Author
• License

(TOC generated by verb using markdown-toc)

Install

This project requires Node.js v6 and above. Use npm to install it.

$ npm install parse-function

API

Review carefully the provided examples and the working tests.

parseFunction

Initializes with optional opts object which is passed directly to the desired parser and returns an object with .use and .parse methods. The default parse which is used is babylon's .parseExpression method from v7.

Params

• opts {Object}: optional, merged with options passed to .parse method
• returns {Object}

Example

const parseFunction = require('parse-function')

const app = parseFunction({
  ecmaVersion: 2017
})

const fixtureFn = (a, b, c) => {
  a = b + c
  return a + 2
}

const result = app.parse(fixtureFn)
console.log(result)

// see more
console.log(result.name) // => null
console.log(result.isNamed) // => false
console.log(result.isArrow) // => true
console.log(result.isAnonymous) // => true

// array of names of the arguments
console.log(result.args) // => ['a', 'b', 'c']

// comma-separated names of the arguments
console.log(result.params) // => 'a, b, c'

.parse

Parse a given code and returns a result object with useful properties - such as name, body and args. By default it uses Babylon parser, but you can switch it by passing options.parse - for example options.parse: acorn.parse. In the below example will show how to use acorn parser, instead of the default one.

Params

• code {Function|String}: any kind of function or string to be parsed
• options {Object}: directly passed to the parser - babylon, acorn, espree
• options.parse {Function}: by default babylon.parseExpression, all options are passed as second argument to that provided function
• returns {Object}

Example

const acorn = require('acorn')
const parseFn = require('parse-function')
const app = parseFn()

const fn = function foo (bar, baz) { return bar * baz }
const result = app.parse(fn, {
  parse: acorn.parse,
  ecmaVersion: 2017
})

console.log(result.name) // => 'foo'
console.log(result.args) // => ['bar', 'baz']
console.log(result.body) // => ' return bar * baz '
console.log(result.isNamed) // => true
console.log(result.isArrow) // => false
console.log(result.isAnonymous) // => false
console.log(result.isGenerator) // => false

.use

Add a plugin fn function for extending the API or working on the AST nodes. The fn is immediately invoked and passed with app argument which is instance of parseFunction() call. That fn may return another function that accepts (node, result) signature, where node is an AST node and result is an object which will be returned result from the .parse method. This retuned function is called on each node only when .parse method is called.

See Plugins Architecture section.

Params

• fn {Function}: plugin to be called
• returns {Object}

Example

// plugin extending the `app`
app.use((app) => {
  app.define(app, 'hello', (place) => `Hello ${place}!`)
})

const hi = app.hello('World')
console.log(hi) // => 'Hello World!'

// or plugin that works on AST nodes
app.use((app) => (node, result) => {
  if (node.type === 'ArrowFunctionExpression') {
    result.thatIsArrow = true
  }
  return result
})

const result = app.parse((a, b) => (a + b + 123))
console.log(result.name) // => null
console.log(result.isArrow) // => true
console.log(result.thatIsArrow) // => true

const result = app.parse(function foo () { return 123 })
console.log(result.name) // => 'foo'
console.log(result.isArrow) // => false
console.log(result.thatIsArrow) // => undefined

.define

Define a non-enumerable property on an object. Just a convenience mirror of the define-property library, so check out its docs. Useful to be used in plugins.

Params

• obj {Object}: the object on which to define the property
• prop {String}: the name of the property to be defined or modified
• val {Any}: the descriptor for the property being defined or modified
• returns {Object}

Example

const parseFunction = require('parse-function')
const app = parseFunction()

// use it like `define-property` lib
const obj = {}
app.define(obj, 'hi', 'world')
console.log(obj) // => { hi: 'world' }

// or define a custom plugin that adds `.foo` property
// to the end result, returned from `app.parse`
app.use((app) => {
  return (node, result) => {
    // this function is called
    // only when `.parse` is called

    app.define(result, 'foo', 123)

    return result
  }
})

// fixture function to be parsed
const asyncFn = async (qux) => {
  const bar = await Promise.resolve(qux)
  return bar
}

const result = app.parse(asyncFn)

console.log(result.name) // => null
console.log(result.foo) // => 123
console.log(result.args) // => ['qux']

console.log(result.isAsync) // => true
console.log(result.isArrow) // => true
console.log(result.isNamed) // => false
console.log(result.isAnonymous) // => true

Related

• acorn: ECMAScript parser | homepage
• babylon: A JavaScript parser | homepage
• charlike-cli: Command line interface for the charlike project scaffolder. | homepage
• espree: An Esprima-compatible JavaScript parser built on Acorn | homepage
• hela: Task runner based on execa. Includes few predefined tasks for linting, testing… more | homepage
• parse-semver: Parse, normalize and validate given semver shorthand (e.g. gulp@v3.8.10) to object. | homepage

Contributing

Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.
Please read the Contributing Guide and Code of Conduct documents for advices.

Author

• github/tunnckoCore
• twitter/tunnckoCore
• codementor/tunnckoCore

License

Copyright © 2016-2017, Charlike Mike Reagent. Released under the MIT License.

---

This file was generated by verb-generate-readme, v0.6.0, on August 11, 2017.
Project scaffolded using charlike-cli.