ramda了解一下？2)当第二个参数为方法时，function(key,value){}表示每个属性对应的key-val

R.propSatisfies

返回布尔值

如果指定的对象属性满足 predicate，返回 true；否则返回 false。可以使用 R.where 进行多个属性的判断。

R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true

R.where Object -> Boolean

接受一个测试规范对象和一个待检测对象，如果测试满足规范，则返回 true，否则返回 false。测试规范对象的每个属性值都必须是 predicate 。每个 predicate 作用于待检测对象对应的属性值，如果所有 predicate 都返回 true，则 where 返回 true，否则返回 false 。where 非常适合于需要声明式表示约束的函数，比如 filter 和 find

// pred :: Object -> Boolean
const pred = R.where({
  a: R.equals('foo'),
  b: R.complement(R.equals('bar')),
  x: R.gt(R.__, 10),
  y: R.lt(R.__, 20)
});

pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false

R.when

const truncate = R.when(
  R.propSatisfies(R.gt(R.__, 10), 'length'),
  R.pipe(R.take(10), R.append('…'), R.join(''))
);
truncate('12345');         //=> '12345'
truncate('0123456789ABC'); //=> '0123456789…'

R.unless

判断是否满足第一个条件，满足原样返回。不满足执行第二个参数函数

let safeInc = R.unless(R.isNil, R.inc);
safeInc(null); //=> null
safeInc(1); //=> 2

R.ifElse

案例1

接口调用并处理

 async onLineNum(id){
      let onLineNumData = await service.onLineNum(id)
      const onLineMiddle=R.ifElse(
        R.equals(200),
        () => this.onLineNumData = R.slice(0,3)(onLineNum.data),
        R.F
)
onLineMiddle(R.prop('code')(onLineNumData))

案例2

const printFn = R.ifElse(
          R.equals('development'),
          ()=>{return this.consoleFn()},
          ()=>{R.F}
)
printFn('development')

R.cond

注意and的两个参数都为对象时，只会走第一个分支

错误用法

   const isAndroidOrIos = R.cond([
        [R.and({}),   ()=>{alert(1)}],
        [R.and({}), ()=>{alert(2)}],
        [R.T,()=>console.warn('no ios and android!')]
    ]);
    isAndroidOrIos({})
    isAndroidOrIos({})

正确用法

 const Typefn = R.cond([
          [R.equals('1'), () =>last = 1],
          [R.equals('2'), () =>last = 2],
          [R.equals('3'),  () =>last = 3],
          [R.T,           () =>last = 4]
  ]);
Typefn(3);

正确用法2

  var Fn1 = R.cond([
        [R.equals(0),  ()=>alert(0)],
        [R.equals(1), ()=>alert(1) ],
        [R.equals(2), ()=>alert(2) ],
        [R.T,   R.F]
      ]);
     Fn1(0)

正确用法3 传参版本

R.cond 条件回调的第二个参数必须是一个可执行的函数。如果是箭头函数中嵌套函数，里面的函数需要调用一下。

function fnn0(x){alert(x)}
function fnn1(){alert(1)}
function fnn2(){alert(2)}
var Fn1 = R.cond([
        [R.equals(0), ()=>fnn0(0)],
        [R.equals(1), ()=>fnn1() ],
        [R.equals(2), fnn2 ],
        [R.T,   R.F]
]);
Fn1(0)

其他逻辑运算函数

R.and
R.T
R.F
R.both
R.propEq
R.equals
R.and

总结

没有if elseif else
cond使用必须是明确的条件，否则只会执行第一个分支

其他

R.pipe

function fnn0(){alert(0)}
function fnn1(){alert(1)}
function fnn2(){alert(2)}
var fn = R.pipe(fnn0,fnn1,fnn2)()

safari 下被转义字符串的处理

var str = JSON.stringify({'OD':'aaaa'});
//"{\"OD\":\"aaaa\"}"

JSON.stringify

 JSON.stringify(obj, fn|arr);

1)当第二个参数为数组时，表示需要被序列化的对象的属性列表；

2)当第二个参数为方法时，function(key,value){}表示每个属性对应的key-value值，最终的返回值可以用来改变原来的结果。

该方法可以用来在序列化之前改变对象的内容。

可以接受第三个参数,这个可以用来按格式打印对象

JSON.stringify(obj,null,number|string)

console.log(JSON.stringify({a:{b:1}},null,2))
{
  "a": {
    "b": 1
  }
}

1）当第三个参数为数值时，表示每个属性前的空格数（<10）

当第三个参数为字符串时，表示在每个属性前添加该字符串（<10）

console.log(JSON.stringify({a:{b:1}},null,"==="))
{
==="a": {
======"b": 1
===}
}

其他案例

function replacer(key, value) {
   console.log(value,typeof value)
  //return value.replace(/[^\w\s]/gi, '');
}

var foo = {"a":"1","b":"2"};
var jsonString = JSON.stringify(foo, replacer);

// {a: "1", b: "2"}  "object"

当我在JavaScript中的复杂对象上调用JSON.stringify（）时，它会生成一个带有很多转义序列（\“，\”等）的字符串。

如何使它创建人类可读的JSON字符串呢？即，您可以将其复制/粘贴到网络上许多JSON验证器之一中吗？

为了明确起见，我的首要考虑是删除转义序列。您可以使用替换器。JSON.stringify.Replacer提供的第二个参数可以是函数或数组。

在您的情况下，我们可以创建一个将所有特殊字符替换为空格的函数。以下示例替换了空格和下划线。


function replacer(key, value) {
  return value.replace(/[^\w\s]/gi, '');
}

var foo = {"a":"1","b":2};
var jsonString = JSON.stringify(foo, replacer);

var o = {a: {b: 1}};

function f(key, value) {
  console.log("["+ key +"]:" + value);
  return value;
}

JSON.stringify(o, f)

打印结果

R.isNil

只判断是不是 null 、 undefined 只有传入null 、 undefined时返回true


R.isNil(undefined)
true
R.isNil(null)
true
R.isNil(0)
false
R.isNil(1)
false
R.isNil('')
false
R.isNil(true)
false
R.isNil(false)
false

R.or 逻辑或运算


R.or(true, true); //=> true
R.or(true, false); //=> true
R.or(false, true); //=> true
R.or(false, false); //=> false

R.either 逻辑或运算

返回由 || 运算符连接的两个函数的包装函数。如果两个函数中任一函数的执行结果为 truth-y，则返回其执行结果。注意，这个是短路表达式，意味着如果第一个函数返回 truth-y 值的话，第二个函数将不会执行。


const gt10 = x => x > 10;
const even = x => x % 2 === 0;
const f = R.either(gt10, even);
f(101); //=> true
f(8); //=> true

R.empty()

根据传入参数的类型返回其对应的空值


R.or(true, true); //=> true
R.or(true, false); //=> true
R.or(false, true); //=> true
R.or(false, false); //=> false

R.unless()

判断输入值是否满足 predicate，若不符合，则将输入值传给 whenFalseFn 处理，并将处理结果作为返回；若符合，则将输入值原样返回。返回其对应的空值

let safeInc = R.unless(R.isNil, R.inc);
safeInc(null); //=> null
safeInc(1); //=> 2