Ramda

一个实用的 JavaScript 程序员函数库。(A practical functional library for JavaScript programmers.)

  • 所有者: ramda/ramda
  • 平台: Linux, Mac, Web browsers, Windows
  • 许可证: MIT License
  • 分类:
  • 主题:
  • 喜欢:
    0
      比较:

Github星跟踪图

Ramda(拉姆达)是一个实用的 JavaScript 函数式编程库。

为什么 Ramda?

已经有几个具有函数风格的优秀库。通常,它们是通用的工具包,适用于多种范式的工作。 Ramda 有一个更明确的目标。我们想要一个专门为函数编程风格设计的库,一个可以轻松创建函数管道的库,一个永远不会改变用户数据的库。

有什么不同?

Ramda 的主要特性是:

  • Ramda 强调更纯粹的函数风格。不变性和无副作用的函数是其设计理念的核心。这可以帮助您使用简单、优雅的代码完成这项工作。
  • Ramda 函数自动 curry。通过不提供最终参数,您可以轻松地从旧函数构建新函数。
  • 布置了 Ramda 函数的参数,方便 curry。要操作的数据通常最后提供。

最后两点结合在一起使得将函数构建为更简单的函数序列变得非常容易,每个函数都转换数据并将其传递给下一个函数。Ramda 旨在支持这种编码风格。

主要指标

概览
名称与所有者ramda/ramda
主编程语言JavaScript
编程语言JavaScript (语言数: 4)
平台Linux, Mac, Web browsers, Windows
许可证MIT License
所有者活动
创建于2013-06-21 20:32:35
推送于2025-02-07 00:17:21
最后一次提交2025-02-06 17:17:21
发布数58
最新版本名称v0.30.1 (发布于 2024-06-02 14:44:13)
第一版名称v0.1.0 (发布于 )
用户参与
星数24k
关注者数261
派生数1.4k
提交数3k
已启用问题?
问题数1641
打开的问题数126
拉请求数1322
打开的拉请求数25
关闭的拉请求数446
项目设置
已启用Wiki?
已存档?
是复刻?
已锁定?
是镜像?
是私有?

Ramda

A practical functional library for JavaScript programmers.

Build Status
npm module
dependencies
Gitter

Why Ramda?

There are already several excellent libraries with a functional flavor. Typically, they are meant to be general-purpose toolkits, suitable for working in multiple paradigms. Ramda has a more focused goal. We wanted a library designed specifically for a functional programming style, one that makes it easy to create functional pipelines, one that never mutates user data.

What's Different?

The primary distinguishing features of Ramda are:

  • Ramda emphasizes a purer functional style. Immutability and side-effect free functions
    are at the heart of its design philosophy. This can help you get the job done with simple,
    elegant code.

  • Ramda functions are automatically curried. This allows you to easily build up new functions
    from old ones simply by not supplying the final parameters.

  • The parameters to Ramda functions are arranged to make it convenient for currying. The data
    to be operated on is generally supplied last.

The last two points together make it very easy to build functions as sequences of simpler functions, each of which transforms the data and passes it along to the next. Ramda is designed to support this style of coding.

Introductions

Philosophy

Using Ramda should feel much like just using JavaScript.
It is practical, functional JavaScript. We're not introducing
lambda expressions in strings, we're not borrowing consed
lists, we're not porting over all of the Clojure functions.

Our basic data structures are plain JavaScript objects, and our
usual collections are JavaScript arrays. We also keep other
native features of JavaScript, such as functions as objects
with properties.

Functional programming is in good part about immutable objects and
side-effect free functions. While Ramda does not enforce this, it
enables such style to be as frictionless as possible.

We aim for an implementation both clean and elegant, but the API is king.
We sacrifice a great deal of implementation elegance for even a slightly
cleaner API.

Last but not least, Ramda strives for performance. A reliable and quick
implementation wins over any notions of functional purity.

Installation

To use with node:

$ npm install ramda

Then in the console:

const R = require('ramda');

To use directly in the browser:

<script src="path/to/yourCopyOf/ramda.js"></script>

or the minified version:

<script src="path/to/yourCopyOf/ramda.min.js"></script>

or from a CDN, either cdnjs:

<script src="//cdnjs.cloudflare.com/ajax/libs/ramda/0.25.0/ramda.min.js"></script>

or one of the below links from jsDelivr:

<script src="//cdn.jsdelivr.net/npm/ramda@0.25.0/dist/ramda.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/ramda@0.25/dist/ramda.min.js"></script>
<script src="//cdn.jsdelivr.net/npm/ramda@latest/dist/ramda.min.js"></script>

(note that using latest is taking a significant risk that ramda API changes could break your code.)

These script tags add the variable R on the browser's global scope.

Or you can inject ramda into virtually any unsuspecting website using the bookmarklet.

Note for versions > 0.25
Ramda versions > 0.25 don't have a default export.
So instead of import R from 'ramda';, one has to use import * as R from 'ramda';
Or better yet, import only the required functions via import { functionName } from 'ramda';

Build

npm run build creates es, src directories and updates both dist/ramda.js and dist/ramda.min.js

Partial Builds

It is possible to build Ramda with a subset of the functionality to reduce its file size. Ramda's build system supports this with command line flags. For example if you're using R.compose, R.reduce, and R.filter you can create a partial build with:

npm run --silent partial-build compose reduce filter > dist/ramda.custom.js

This requires having Node/io.js installed and ramda's dependencies installed (just use npm install before running partial build).

Install specific functions

Install individual functions with bit, npm and yarn without installing the whole library.

Documentation

Please review the API documentation.

Also available is our Cookbook of functions built from Ramda that you may find useful.

The Name

Ok, so we like sheep. That's all. It's a short name, not already
taken. It could as easily have been eweda, but then we would be
forced to say eweda lamb!, and no one wants that. For non-English
speakers, lambs are baby sheep, ewes are female sheep, and rams are male
sheep. So perhaps ramda is a grown-up lambda... but probably not.

Running The Test Suite

Console:

To run the test suite from the console, you need to have mocha installed:

npm install -g mocha

Then from the root of the project, you can just call

mocha

Alternately, if you've installed the dependencies, via:

npm install

then you can run the tests (and get detailed output) by running:

npm test

Browser:

You can use testem to
test across different browsers (or even headlessly), with livereloading of
tests. Install testem (npm install -g testem) and run testem. Open the
link provided in your browser and you will see the results in your terminal.

If you have PhantomJS installed, you can run testem -l phantomjs to run the
tests completely headlessly.

Usage

For v0.25 and up, import the whole library or pick ES modules directly from the library:

import * as R from 'ramda'

const {identity} = R
R.map(identity, [1, 2, 3])

Destructuring imports from ramda does not necessarily prevent importing the entire library. You can manually cherry-pick methods like the following, which would only grab the parts necessary for identity to work:

import identity from 'ramda/src/identity'

identity()

Manually cherry picking methods is cumbersome, however. Most bundlers like Webpack and Rollup offer tree-shaking as a way to drop unused Ramda code and reduce bundle size, but their performance varies, discussed here. Here is a summary of the optimal setup based on what technology you are using:

  1. Webpack + Babel - use babel-plugin-ramda to automatically cherry pick methods. Discussion here, example here
  2. Webpack only - use UglifyJS plugin for treeshaking along with the ModuleConcatenationPlugin. Discussion here, with an example setup here
  3. Rollup - does a fine job properly treeshaking, no special work needed; example here

Typings

Translations

Acknowledgements

Thanks to J. C. Phillipps for the Ramda logo.
Ramda logo artwork © 2014 J. C. Phillipps. Licensed Creative Commons
CC BY-NC-SA 3.0.