# How to translate this bit of Python to idiomatic Javascript

My code so far:

```
// The q constant of the Glicko system.
var q = Math.log(10) / 400;
function Player(rating, rd) {
this.rating = rating || 1500;
this.rd = rd || 200;
}
Player.prototype.preRatingRD = function(this, t, c) {
// Set default values of t and c
this.t = t || 1;
this.c = c || 63.2;
// Calculate the new rating deviation
this.rd = Math.sqrt(Math.pow(this.rd, 2) + (Math.pow(c, 2) * t));
// Ensure RD doesn't rise above that of an unrated player
this.rd = Math.min(this.rd, 350);
// Ensure RD doesn't drop too low so that rating can still change
// appreciably
this.rd = Math.max(this.rd, 30);
};
Player.prototype.g = function(this, rd) {
return 1 / Math.sqrt(1 + 3 * Math.pow(q, 2) * Math.pow(rd, 2) / Math.pow(Math.PI, 2));
};
Player.prototype.e = function(this, p2rating, p2rd) {
return 1 / (1 + Math.pow(10, (-1 * this.g(p2rd) * (this.rating - p2rating) / 400)));
};
```

I'm working on a JS/HTML implementation of the Glicko rating system and am heavily borrowing from pyglicko -- which is to say, completely ripping it off.

It's rather short (probably less than 100 LoC without comments) but I'm having my misgivings about whether my translation will work because honestly, I have no idea how Javascript scoping and `this`

actually work. You can see what I have at the link at the top.

But in specific I'm wondering how you would express this bit of Python code in Javascript. Basically `_d2`

is inside a class definition for `Player`

.

```
def _d2(self, rating_list, RD_list):
tempSum = 0
for i in range(len(rating_list)):
tempE = self._E(rating_list[i], RD_list[i])
tempSum += math.pow(self._g(RD_list[1]), 2) * tempE * (1 - tempE)
return 1 / (math.pow(self._q, 2) * tempSum)
```

I've got the functions `e`

and `g`

defined like so, and `q`

is a constant:

```
Player.prototype.e = function(this, ratingList, rdList) {
// Stuff goes here
}
```

## Paul-

2019-11-16

In Javascript you don't need o pass the self explicitly (Python is the "weird" one here, actually)

This should work all right. The only tricky thing you need to know about

`this`

is that it is very promiscuous. This means that is is determined by how you call the function:However, there is no magic binding behind the scenes. The following works in python but does

notwork in Javascript: