Javascript: function calls not having parameters, but declaration do have parameters - javascript

I was wondering about how functions work in javascript, I noticed in some cases, things like array.sort, array.filter, and event listeners the code that calls (not declares) the function (not using functionless or inline), usually FunctionName have parenthesis with the arguments in there (FunctionName(arg1, arg2, arg3...)). Are parameters “automatically” passed into the function?

Now I understand, looking wikipedia's article on callback looking at the alert, it looks like it first calls "calculate" first, supplies the 2 numbers and the function (that function name only, without the open and then closing parenthesis), and THEN uses the parameters for callbackFunction. So without the parenthesis on the function name is like without using bracket on an array name.

Related

JQuery 3.3.1 attr with 3 parameters. What it does?

I'm trying to update some old code someone left before, at some point, it made a call to the attr function of an old 3.3.1 JQuery like this:
$("#myiframe").attr("src", url, function () {
$(window).on("unload", function () {
// Some function stuff
});
});
My problem is than I want to know what exactly this does (I already know what attr does when it has 2 parameters, but not 3) before adapt it to a newer version, but when I search about the .attr function in JQuery, all I found is with only two parameters, not 3 like this, I don't know if is properly a callback function (unlikely, because none of the parameters this function accepts is a callback function), or other thing.
The JQuery file is the one served by googleapis, so is not likely it has been specially modified for this.
Please, can someone explain me what it does?
No signature of attr() accepts 3 arguments. The last argument is redundant. Even if it did serve a purpose, putting a window.unload event handler in there would not do anything useful.
Regards your comment under the question:
Why doesn't it launch a fatal error for the number of arguments?
It's because JS is a very permissive language. You can pass as many arguments to a function as you like, JS will ignore any extras and only bind those which you defined in the function definition (up to 2 in this case using attr()). Although note that it's still possible to retrieve all arguments that were used in the function invocation using the arguments keyword

What are all the ways you can pass arguments into functions in JavaScript?

Coming from Python into some JavaScript-based APIs I'm confused by some of the syntax. And I can't find an answer in all of the noise of random information about declaring functions.
In Python, you can mix specifying arguments to a function base on the order and based on the name:
np.arange(1,5,step = 5)
Can you do something like that in Javascript?
If there is a function like:
ee.List.sequence(start,end, step, count)
and it only needs three out of the four arguments I can really easily specify the start, end, step, like so:
ee.List.sequence(1,100,2)
But, do I have to use the object notation to specify the count?
ee.List.sequence({start=1,end=100, count=50})
Is there a shorthand, like in Python, such as:
ee.List.sequence(1,100,{count=50})
or
ee.List.sequence(1,100,,50)?
It seems that what you are really asking is less about JavaScript as a language and more about specific APIs. So, here's some things to know:
In JavaScript, all arguments are optional. In other words, there is no way to enforce that a function is called with the proper amount or order of arguments. It's up to the caller to know the signature of the function its calling and call it appropriately. It's also up to the creator of the function to be prepared for some or all of the arguments to not be passed. There is an arguments array-like object that all functions have that can assist with this, but checking the inputs is also pretty easy. Here's an example:
// Here's an example of a function that does not explicitly declare any arguments
function foo1(){
// However, arguments might still be passed and they can be accessed
// through the arguments object:
console.log("Arguments.length = ", arguments.length);
console.log(arguments);
}
foo1("test", "boo!"); // Call the function and pass args even though it doesn't want any
// ***********************************************
// Here's an example of a function that needs the first arg to work,
// but the seond one is optional
function foo2(x, y){
if(y){
console.log(x + y);
} else {
console.log(x);
}
}
foo2(3);
foo2(4, 5);
In JavaScript, your functions can take any valid primitive or object. Again, it's up to the caller to know what the API is and call it correctly:
function foo1(string1, number1, object1, string2){
console.log(arguments);
}
foo1("test", 3.14, {val:"John Doe"}, "ing");
I've found the answer in this JavaScript tutorial.
In general, yes, the default JavaScript function can take anything as an argument. But any well-written API function, with specified arguments (and default values), will not allow this to happen.
So the two options are
Supply the arguments in order, without naming them.
`ee.List.sequence(1,100,2)`
Pass them in a named object (where suddenly order doesn't matter)
`ee.List.sequence({start=1,end=100, count=50})`
There is no mixed notation like Python has
ee.List.sequence(1,100,{count=50})
BUT there is a workaround for 1
In case you want to use a different combination of arguments, one can supply null values to the arguments that are omitted. So the following can be used:
`ee.List.sequence(1,100,null,50)`

Javascript ES6 fat arrows empty parameter f instead of ()

I've noticed that when creating functions in Java Script ES5 you can specify parameters that will not necessarily have to be used, e.g.
function foo(uselessParam) {
// code that will not use uselessParam
}
If I'm correct - if I wont use this parameter within my function I can call that function without passing that parameter and "foo" will still run without throwing errors. This gave me idea to use fat arrows in ES6 like this:
let foo = f => {
// code not using f parameter
}
"f" in my opinion points that this piece of code is a function in more intuitive way than "()" I like doing so, even that "()" suppose to be used when no parameters are specified.
Here is my question: is there any scenario when using empty parameter instead of no parameters passed at all could be a problem? Could using this pattern cause any problems? What do you think?
The function will have a different .length, so if any introspective code is using that property for anything, you may see unexpected results.

When using AngularJS filter service in JavaScript, why are the parameters in closed parenthesis of their own?

I am used to seeing parameters being passed to functions within one set of parenthesis. I'm used to this from C# and also from starting to learn JavaScript.
Here is one example:
functionName(parameter1, parameter2, parameter3) {
code to be executed
}
But I came across this AngularJS example where using filters from the JavaScript code is done by passing parameters in a parenthesis of their own.
$scope.filteredText = $filter('uppercase')($scope.originalText);
I would expect the parameter to be passed as:
$scope.filteredText = $filter('uppercase', $scope.originalText);
Why it it passed in a parenthesis of its own instead? What kind of syntax is that? Is it JavaScript or is it AngularJS specific?
($scope.originalText) is not a second parameter to the $filter function.
The $filter('uppercase') function returns another function and you are passing $scope.originalText as a parameter to this returned function. It's just a shortened version of:
var f = $filter('uppercase');
f($scope.originalText);

Variable / optional airity function in Haskell though "argument object" introspection?

Imagine you have a function addTogether that can take any number of parameters, and adds them all after the last parameter. I know this could be done ridiculously easily with a List, but I'm just trying out a concept here. I think I remember being able to do so in JavaScript by accessing the arguments object (here). Would it be possible to implement an argument object monad in haskell that translates the arguments applied to a native function (syntactically, so you don't have to explicitly use >>=) into a list of arguments?
http://chris-taylor.github.io/blog/2013/03/01/how-haskell-printf-works/ - a good link "Polyvariadic Functions and Printf"

Categories