redspacecat wrote:

-ComplexNumbers- wrote:

Programming in JavaScript is living hell. Programming in Python is pretty nice.

I think both javascript and python are pretty good. I use both.

>>> [1, 2, 3, 4] in [[1, 2, 3, 4]]
True
>>> [1, 2, 3, 4] == [1, 2, 3, 4]
True
>>> # normal!

> [[1, 2, 3, 4]].includes([1, 2, 3, 4])
< false
> [1, 2, 3, 4] === [1, 2, 3, 4]
< false
> // whar??

-ComplexNumbers- wrote:

Programming in JavaScript is living hell. Programming in Python is pretty nice.

BigNate469 wrote:

-ComplexNumbers- wrote:

Programming in JavaScript is living hell. Programming in Python is pretty nice.

JavaScript isn't bad. It has really good cross-platform support, and is used on the web. Also, it's C-based.

ajskateboarder wrote:

>>> [1, 2, 3, 4] in [[1, 2, 3, 4]]
True
>>> [1, 2, 3, 4] == [1, 2, 3, 4]
True
>>> # normal!

> [[1, 2, 3, 4]].includes([1, 2, 3, 4])
< false
> [1, 2, 3, 4] === [1, 2, 3, 4]
< false
> // whar??

mybearworld wrote:

I'd argue JS's behavior makes more sense in this case. Compare:

>>> a = [[1,2,3,4]]
>>> b = [1,2,3,4]
>>> b in a
True
>>> b.append(5)
>>> b in a
False
>>> # so b isn't _actually_ in a!
>>> 
>>> c = [b]
>>> b in c
True
>>> b.append(6)
>>> b in c
True
>>> # but b actually _is_ in c.
>>> # however, before appending `b in a` and `b in c` are the same.

> let a = [[1,2,3,4]]
undefined
> let b = [1,2,3,4]
undefined
> a.includes(b)
false
> b.push(5)
5
> a.includes(b)
false
> // b isn't in a, and we know that from the beginning
undefined
>
> let c = [b]
undefined
> c.includes(b)
true
> b.push(6)
6
> c.includes(b)
true
> // and b _is_ in c, which we also know from the beginning
undefined

> [1, 2, 3, 4] == [1, 2, 3, 4]
false

>>> [1, 2, 3, 4] == [1, 2, 3, 4]
True

BigNate469 wrote:

ajskateboarder wrote:

>>> [1, 2, 3, 4] in [[1, 2, 3, 4]]
True
>>> [1, 2, 3, 4] == [1, 2, 3, 4]
True
>>> # normal!

> [[1, 2, 3, 4]].includes([1, 2, 3, 4])
< false
> [1, 2, 3, 4] === [1, 2, 3, 4]
< false
> // whar??

In JavaScript you have to iterate through the array manually. Python does the same, just you don't have to write the code yourself.

console.log("some log statement which I like")
console.log(1)
console.log(2)
console.log(3)
console.log(4)

console.log("some log statement which I like")
[1, 2, 3, 4].forEach(ele => {
  // ...
})

index.js:2
[1, 2, 3, 4].forEach(ele => {
^

TypeError: Cannot read properties of undefined (reading '4')

console.log("some log statement which I like")
(
    [1, 2, 3, 4].forEach(ele => {
      // ...
    })
)()

index.js:2
([1, 2, 3, 4].forEach(ele => {
^

TypeError: console.log(...) is not a function

Mryellowdoggy wrote:

Python is much simpler to use and can be used almost anywhere. And it has better backend functionality and extensive libraries. JavaScript is pretty good too though.

ajskateboarder wrote:

redspacecat wrote:

-ComplexNumbers- wrote:

Programming in JavaScript is living hell. Programming in Python is pretty nice.

I think both javascript and python are pretty good. I use both.

You thought

>>> [1, 2, 3, 4] in [[1, 2, 3, 4]]
True
>>> [1, 2, 3, 4] == [1, 2, 3, 4]
True
>>> # normal!

> [[1, 2, 3, 4]].includes([1, 2, 3, 4])
< false
> [1, 2, 3, 4] === [1, 2, 3, 4]
< false
> // whar??

let a1 = []
let a2 = [a1]
a1.push(a2)
console.log(a1)
> [a2>[a1>[a2>etc]]]

#help me I am weak

AHypnoman wrote:

This is actually really useful if you look deeper than simple comparisons: this lets objects (which arrays are) to be self referencing allowing for 2-way references between objects without a need for infinite memory.

Simple example of coupled arrays:

let a1 = []
let a2 = [a1]
a1.push(a2)
console.log(a1)
> [a2>[a1>[a2>etc]]]

Python:

#help me I am weak

a = []
b = [a]
a.append(b)
print(a) # output: [[[...]]]

Maximouse wrote:

(#573)
This works in Python too. All Python variables are references.

AHypnoman wrote:

Another advantage is that you can modify arguments without returning (which is normally insane practice but has some legitimate uses)

def append_1(l):
    l += [1]
a = []
append_1(a)
print(a) # [1]

mybearworld wrote:

Maximouse wrote:

(#573)
This works in Python too. All Python variables are references.

Yep, so in Python, ` == ` being true is a lie. ` == ` being false in JS makes more sense.

mybearworld wrote:

Maximouse wrote:

(#573)
This works in Python too. All Python variables are references.

Yep, so in Python, `[] == []` being true is a lie. `[] == []` being false in JS makes more sense.

Maximouse wrote:

(#577)
Python's == operator compares values, but there's also the identity operator “is” which only returns true if both operands are the same object.

Maximouse wrote:

~Snip~

>>> x = "hi"
... y = "hi"
>>> id(x)
4414027184
>>> id(y)
4414027184
>>> def z(a):
...     a += "hhhh"
... z(x)
... x
'hi'

AHypnoman wrote:

Maximouse wrote:

~Snip~

My mistake (I'm not deeply familiar with Python), although given all python vars are references then why does this happen?

>>> x = "hi"
... y = "hi"
>>> id(x)
4414027184
>>> id(y)
4414027184
>>> def z(a):
...     a += "hhhh"
... z(x)
... x
'hi'

This means that strings are immutable while lists and dictionaries are mutable, but they're both passed in as refs. A string is a reference, but mostly acts as a primitive?

a += "hhhh"
# shorthand for a = a + "hhhh"

let a = "a"
function addhhhh(b) {
    b += "hhhh"
}
addhhhh(a)
console.log(a) // a

class Main {
    public static void addhhhh(String b) {
        b += "hhhh";
    }    
    public static void main(String[] args) {
        String a = "a";
        addhhhh(a);
        System.out.println(a); // a
    }
}

AHypnoman wrote:

Also creating two separate strings assigns them the same reference if they are equivalent meaning that == and ‘is’ comparisons return the same, meaning that for almost every purpose a string acts as a js-like primitive, but isn't.

ajskateboarder wrote:

AHypnoman wrote:

Maximouse wrote:

~Snip~

My mistake (I'm not deeply familiar with Python), although given all python vars are references then why does this happen?

>>> x = "hi"
... y = "hi"
>>> id(x)
4414027184
>>> id(y)
4414027184
>>> def z(a):
...     a += "hhhh"
... z(x)
... x
'hi'

This means that strings are immutable while lists and dictionaries are mutable, but they're both passed in as refs. A string is a reference, but mostly acts as a primitive?

FYI,

a += "hhhh"
# shorthand for a = a + "hhhh"

does not mutate the variable, it just reassigns the value of a. Oh by the way, JavaScript also acts the same way

let a = "a"
function addhhhh(b) {
    b += "hhhh"
}
addhhhh(a)
console.log(a) // a

And Java while we're at it

class Main {
    public static void addhhhh(String b) {
        b += "hhhh";
    }    
    public static void main(String[] args) {
        String a = "a";
        addhhhh(a);
        System.out.println(a); // a
    }
}

AHypnoman wrote:

Also creating two separate strings assigns them the same reference if they are equivalent meaning that == and ‘is’ comparisons return the same, meaning that for almost every purpose a string acts as a js-like primitive, but isn't.

That's most likely for optimization purposes - when would you need to compare memory locations for two equivalent strings anyways?