Who Add _ Single Underscore Query Parameter?
jQuery adds a parameter like that to get around IE's caching.
edit:
it only adds it for get requests, and only if the option cache is false:
cache: false
How to remove “_” Single Underscore Query Parameter when perfoming ajax requests?
The underline are appearing because you set the cache: false
option, as denoted on jQuery Documentation for Ajax Settings.
What is the purpose of the single underscore _ variable in Python?
_
has 3 main conventional uses in Python:
To hold the result of the last executed expression in an interactive
interpreter session (see docs). This precedent was set by the standard CPython
interpreter, and other interpreters have followed suitFor translation lookup in i18n (see the
gettext
documentation for example), as in code likeraise forms.ValidationError(_("Please enter a correct username"))
As a general purpose "throwaway" variable name:
To indicate that part
of a function result is being deliberately ignored (Conceptually, it is being discarded.), as in code like:label, has_label, _ = text.partition(':')
As part of a function definition (using either
def
orlambda
), where
the signature is fixed (e.g. by a callback or parent class API), but
this particular function implementation doesn't need all of the
parameters, as in code like:def callback(_):
return True[For a long time this answer didn't list this use case, but it came up often enough, as noted here, to be worth listing explicitly.]
This use case can conflict with the translation lookup use case, so it is necessary to avoid using
_
as a throwaway variable in any code block that also uses it for i18n translation (many folks prefer a double-underscore,__
, as their throwaway variable for exactly this reason).Linters often recognize this use case. For example
year, month, day = date()
will raise a lint warning ifday
is not used later in the code. The fix, ifday
is truly not needed, is to writeyear, month, _ = date()
. Same with lambda functions,lambda arg: 1.0
creates a function requiring one argument but not using it, which will be caught by lint. The fix is to writelambda _: 1.0
. An unused variable is often hiding a bug/typo (e.g. setday
but usedya
in the next line).The pattern matching feature added in Python 3.10 elevated this usage from "convention" to "language syntax" where
match
statements are concerned: in match cases,_
is a wildcard pattern, and the runtime doesn't even bind a value to the symbol in that case.For other use cases, remember that
_
is still a valid variable name, and hence will still keep objects alive. In cases where this is undesirable (e.g. to release memory or external resources) an explicitdel name
call will both satisfy linters that the name is being used, and promptly clear the reference to the object.
_' parameter in GET requests
Adding a random numerical param to requests is a common way to defeat browser caching of AJAX result sets.
What is the meaning of single and double underscore before an object name?
Single Underscore
In a class, names with a leading underscore indicate to other programmers that the attribute or method is intended to be be used inside that class. However, privacy is not enforced in any way.
Using leading underscores for functions in a module indicates it should not be imported from somewhere else.
From the PEP-8 style guide:
_single_leading_underscore
: weak "internal use" indicator. E.g.from M import *
does not import objects whose name starts with an underscore.
Double Underscore (Name Mangling)
From the Python docs:
Any identifier of the form
__spam
(at least two leading underscores, at most one trailing underscore) is textually replaced with_classname__spam
, whereclassname
is the current class name with leading underscore(s) stripped. This mangling is done without regard to the syntactic position of the identifier, so it can be used to define class-private instance and class variables, methods, variables stored in globals, and even variables stored in instances. private to this class on instances of other classes.
And a warning from the same page:
Name mangling is intended to give classes an easy way to define “private” instance variables and methods, without having to worry about instance variables defined by derived classes, or mucking with instance variables by code outside the class. Note that the mangling rules are designed mostly to avoid accidents; it still is possible for a determined soul to access or modify a variable that is considered private.
Example
>>> class MyClass():
... def __init__(self):
... self.__superprivate = "Hello"
... self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}
Why is a single underscore character an illegal name for a lambda parameter?
The reason is expressed in this post from Brian Goetz himself:
We are "reclaiming" the syntactic real estate of "_" from the space of identifiers for use in future language features. However, because there are existing programs that might use it, it is a warning for identifiers that occur in existing syntactic positions for 8, and an error for lambda formals (since there is no existing code with lambdas.)
Using _ (underscore) variable with arrow functions in ES6/Typescript
The reason why this style can be used (and possibly why it was used here) is that _
is one character shorter than ()
.
Optional parentheses fall into the same style issue as optional curly brackets. This is a matter of taste and code style for the most part, but verbosity is favoured here because of consistency.
While arrow functions allow a single parameter without parentheses, it is inconsistent with zero, single destructured, single rest and multiple parameters:
let zeroParamFn = () => { ... };
let oneParamFn = param1 => { ... };
let oneParamDestructuredArrFn = ([param1]) => { ... };
let oneParamDestructuredObjFn = ({ param1 }) => { ... };
let twoParamsFn = (param1, param2) => { ... };
let restParamsFn = (...params) => { ... };
Although is declared but never used
error was fixed in TypeScript 2.0 for underscored parameters, _
can also trigger unused variable/parameter
warning from a linter or IDE. This is a considerable argument against doing this.
_
can be conventionally used for ignored parameters (as the other answer already explained). While this may be considered acceptable, this habit may result in a conflict with _
Underscore/Lodash namespace, also looks confusing when there are multiple ignored parameters. For this reason it is beneficial to have properly named underscored parameters (supported in TS 2.0), also saves time on figuring out function signature and why the parameters are marked as ignored (this defies the purpose of _
parameter as a shortcut):
let fn = (param1, _unusedParam2, param3) => { ... };
For the reasons listed above, I would personally consider _ => { ... }
code style a bad tone that should be avoided.
What's the meaning of passing underscore _ _ (_) when calling a function in dart/flutter?
Underscore is normally an indication that you are not going to use that parameter inside the block it is just a good way to write code, for instance:
method(int useful, int useless) {
// say I am only going to use 'useful' in this block
}
Above code can also be written as:
method(int useful, int _) {
// using '_' means I'm not going to use 2nd parameter in the block
}
Answer to your question now:
builder: (_, counter, __) => Translations(counter.value),
means you have 3 parameters _
, counter
and __
, and only counter
is what you are using, so 1st and 3rd parameters are denoted with _
and __
. This is just cleaner way to write code.
What is the meaning of an Underscore in javascript function parameter?
The underscore symbol _
is a valid identifier in JavaScript, and in your example, it is being used as a function parameter.
A single underscore is a convention used by some javascript programmers to indicate to other programmers that they should "ignore this binding/parameter". Since JavaScript doesn't do parameter-count checking the parameter could have been omitted entirely.
This symbol is often used (by convention again) in conjunction with fat-arrow functions to make them even terser and readable, like this:
const fun = _ => console.log('Hello, World!')
fun()
In this case, the function needs no params to run, so the developer has used the underscore as a convention to indicate this. The same thing could be written like this:
const fun = () => console.log('Hello, World!')
fun()
The difference is that the second version is a function with no parameters, but the first version has a parameter called _ that is ignored. These are different though and the second version is safer, if slightly more verbose (1 extra character).
Also, consider a case like
arr.forEach(function (_, i) {..})
Where _
indicates the first parameter is not to be used.
The use of underscores like this can get very confusing when using the popular lodash or underscore libraries.
Related Topics
PHP How to Retrieve Array Values
How to Run Multiple Insert Query in SQL Using PHP in One Go
How to Execute Raw Queries with Laravel 5.1
MySQL Select from Tables Based on Multiple Rows
How to Do Multiple SQL Statements in One MySQL_Query
Get Repeated Matches with Preg_Match_All()
Fatal Error - 'Mongo' Class Not Found
Sort Array in PHP by Value and Maintain Index Association
Format Text in Excel File via PHP
Codeigniter Sessions Not Working After Migration
Convert Number to Letter with PHP
What's the Difference Between Array_Merge and Array + Array
Deny Ajax File Access Using Htaccess
Check Whether an Array Is Empty