Я хочу сделать этот синтаксис возможным:
var a = add(2)(3); //5
основанный на том, что я читал на http://dmitry.baranovskiy.com/post/31797647
Я не знаю, как это сделать.
Как я могу сделать var a = add (2) (3); //5 работать?
Ответ 1
Вам нужно добавить функцию, которая принимает аргумент и возвращает функцию, которая принимает аргумент, который добавляет аргумент для добавления и сам.
var add = function(x) {
return function(y) { return x + y; };
}
Ответ 2
function add(x) {
return function(y) {
return x + y;
};
}
А, красота JavaScript
Этот синтаксис также довольно опрятен
function add(x) {
return function(y) {
if (typeof y !== 'undefined') {
x = x + y;
return arguments.callee;
} else {
return x;
}
};
}
add(1)(2)(3)(); //6
add(1)(1)(1)(1)(1)(1)(); //6
Ответ 3
function add(x){
return function(y){
return x+y
}
}
Первоклассные функции и закрытия выполняют работу.
Ответ 4
попробуйте, это поможет вам двумя способами добавить (2) (3) и добавить (2,3)
1).
function add(a){ return function (b){return a+b;} }
add(2)(3) // 5
2.)
function add(a,b){
var ddd = function (b){return a+b;};
if(typeof b =='undefined'){
return ddd;
}else{
return ddd(b);
}
}
add(2)(3) // 5
add(2,3) // 5
Ответ 5
function add(n) {
sum = n;
const proxy = new Proxy(function a () {}, {
get (obj, key) {
return () => sum;
},
apply (receiver, ...args) {
sum += args[1][0];
return proxy;
},
});
return proxy
}
Работает для всего и не нуждается в final() в конце функции, как некоторые другие решения.
console.log(add(1)(2)(3)(10)); // 16
console.log(add(10)(10)); // 20
Ответ 6
Синтаксис ES6 делает это приятным и простым:
const add = (a, b) => a + b;
console.log(add(2, 5));
// output: 7
const add2 = a => b => a + b;
console.log(add2(2)(5));
// output: 7
Ответ 7
Это о JS curring и немного строгом с valueOf:
function add(n){
var addNext = function(x) {
return add(n + x);
};
addNext.valueOf = function() {
return n;
};
return addNext;
}
console.log(add(1)(2)(3)==6);//true
console.log(add(1)(2)(3)(4)==10);//true
Он работает как шарм с неограниченной цепочкой добавления!
Ответ 8
в дополнение к уже сказанному, здесь решение с общим каррированием (на основе http://github.com/sstephenson/prototype/blob/master/src/lang/function.js#L180)
Function.prototype.curry = function() {
if (!arguments.length) return this;
var __method = this, args = [].slice.call(arguments, 0);
return function() {
return __method.apply(this, [].concat(
[].slice.call(args, 0),
[].slice.call(arguments, 0)));
}
}
add = function(x) {
return (function (x, y) { return x + y }).curry(x)
}
console.log(add(2)(3))
Ответ 9
Это будет
add(2,3) // 5
или
add(2)(3) // 5
Это пример карри ES6...
const add = (a, b) => (b || b === 0) ? a + b : (b) => a + b;
Ответ 10
Это обобщенное решение, которое решит добавить (2,3)(), добавить (2) (3)() или любую комбинацию, такую как add (2,1,3) (1) (1) (2, 3) (4) (4,1,1)(). Обратите внимание, что несколько проверок безопасности не выполняются, и их можно оптимизировать далее.
function add() {
var total = 0;
function sum(){
if( arguments.length ){
var arr = Array.prototype.slice.call(arguments).sort();
total = total + arrayAdder(arr);
return sum;
}
else{
return total;
}
}
if(arguments.length) {
var arr1 = Array.prototype.slice.call(arguments).sort();
var mytotal = arrayAdder(arr1);
return sum(mytotal);
}else{
return sum();
}
function arrayAdder(arr){
var x = 0;
for (var i = 0; i < arr.length; i++) {
x = x + arr[i];
};
return x;
}
}
add(2,3)(1)(1)(1,2,3)();Ответ 11
В этом случае можно использовать концепцию CLOSURES.
Функция "добавить" возвращает другую функцию. Возвращаемая функция может получить доступ к переменной в родительской области (в этом случае переменная a).
function add(a){
return function(b){
console.log(a + b);
}
}
add(2)(3);
Вот ссылка, чтобы понять закрытие http://www.w3schools.com/js/js_function_closures.asp
Ответ 12
С помощью ES6 spread ... оператор и функция .reduce. С этим вариантом вы получите синтаксис цепочки, но здесь требуется последний вызов (), потому что функция всегда возвращается:
function add(...args) {
if (!args.length) return 0;
const result = args.reduce((accumulator, value) => accumulator + value, 0);
const sum = (...innerArgs) => {
if (innerArgs.length === 0) return result;
return add(...args, ...innerArgs);
};
return sum;
}
// it just for fiddle output
document.getElementById('output').innerHTML = '
<br><br>add() === 0: ${add() === 0 ? 'true' : 'false, res=' + add()}
<br><br>add(1)(2)() === 3: ${add(1)(2)() === 3 ? 'true' : 'false, res=' + add(1)(2)()}
<br><br>add(1,2)() === 3: ${add(1,2)() === 3 ? 'true' : 'false, res=' + add(1,2)()}
<br><br>add(1)(1,1)() === 3: ${add(1)(1,1)() === 3 ? 'true' : 'false, res=' + add(1)(1,1)()}
<br><br>add(2,3)(1)(1)(1,2,3)() === 13: ${add(2,3)(1)(1)(1,2,3)() === 13 ? 'true' : 'false, res=' + add(2,3)(1)(1)(1,2,3)()}
';<div id='output'></div>Ответ 13
function add(a, b){
return a && b ? a+b : function(c){return a+c;}
}
console.log(add(2, 3));
console.log(add(2)(3));
Ответ 14
Функции стрелок, несомненно, значительно упрощают получение требуемого результата:
const Sum = a => b => b ? Sum( a + b ) : a;
console.log(Sum(3)(4)(2)(5)()); //19
console.log(Sum(3)(4)(1)()); //8
Ответ 15
function add() { var sum = 0;
function add() {
for (var i=0; i<arguments.length; i++) {
sum += Number(arguments[i]);
}
return add;
}
add.valueOf = function valueOf(){
return parseInt(sum);
};
return add.apply(null,arguments);
}
// ...
console.log(add() + 0); // 0
console.log(add(1) + 0);/* // 1
console.log(add(1,2) + 0); // 3
Ответ 16
function A(a){
return function B(b){
return a+b;
}
}
Я нашел приятное объяснение для этого типа метода. Он известен как Синтаксис закрытий
пожалуйста, перейдите по этой ссылке Синтаксис закрытий
Ответ 17
const add = a => b => b ? add(a+b) : a;
console.log(add(1)(2)(3)());
Или (`${a} ${b}`) для строк.
Ответ 18
Просто мы можем написать такую функцию
function sum(x){
return function(y){
return function(z){
return x+y+z;
}
}
}
sum(2)(3)(4)//Output->9
Ответ 19
Не будь сложным.
var add = (a)=>(b)=> b ? add(a+b) : a;
console.log(add(2)(3)()); // Output:5
это будет работать в последней версии JavaScript (ES6), это функция рекурсии.
Ответ 20
Здесь мы используем концепцию замыкания, где все функции, вызываемые внутри основной функции iter, ссылаются на u и обновляют x, так как они имеют замыкание над ним. независимо от того, как долго проходит цикл, до последней функции, есть доступ к х.
function iter(x){
return function innfunc(y){
//if y is not undefined
if(y){
//closure over ancestor x
x = y+x;
return innfunc;
}
else{
//closure over ancestor x
return x;
}
}
}
iter (2) (3) (4)()//9 iter (1) (3) (4) (5)()//13
Ответ 21
function add () {
var args = Array.prototype.slice.call(arguments);
var fn = function () {
var arg_fn = Array.prototype.slice.call(arguments);
return add.apply(null, args.concat(arg_fn));
}
fn.valueOf = function () {
return args.reduce(function(a, b) {
return a + b;
})
}
return fn;
}
console.log(add(1));
console.log(add(1)(2));
console.log(add(1)(2)(5));Ответ 22
let total = 0;
const add = (n) => {
if (n) {
total += n;
return add;
}
}
add(1)(2)(3);
console.log(total);
Это неправильно?