Javascript Versus

| | | | | | | | | | | | | | |

👻 Check our latest review to choose the best laptop for Machine Learning engineers and Deep learning tasks!

Summary JavaScript and C++

JavaScript is made for the web, interpreted and high level. Its code usually only runs in browsers. C++ is extremely fast, compiled, mid-level, and statically typed. It serves as the backbone of many programs, operating systems, and other languages.

JavaScript and C++ are two very different, but very popular languages. However, they are both widely used by professional programmers. Both have extensive applications, are used around the world, and are listed as among the best languages ‚Äã‚Äãto learn . So how do they compare? Let’s take a look at them individually, then compare the two languages.


javascript logo

C++ is used everywhere, from AAA video games to space probes. It is even used to write compilers for other languages; including many engines that interpret JavaScript. While many languages ‚Äã‚Äãhave a specific use case in which they shine best, C++, along with its other C language cousins, is often the backbone of many programs and languages ‚Äã‚Äãthat let other languages ‚Äã‚Äãshine.

Comparison of JavaScript and C++

Although these languages ‚Äã‚Äãare quite different and used for different applications, they can still be contrasted with each other to find out which one is right for you.

C++ vs JavaScript: speed and reliability

JavaScript is a higher level language than C++, which is considered medium means that JavaScript is closer to a human language than C++, which is closer to ones and zeros. This means that JavaScript is able to do more with a single line than C++, and JavaScript code is generally much shorter than C++

C++ has something that JavaScript is not: the configuration. If you code in C++, you code at a medium level, which means less road is paved for you. If you want to create something for something different from Windows, you will have more work to do.

While there is a lot of pre-existing code for C++, it isn’t always promised that you will find the integration you are looking for and that you won’t have to code something p Custom to from scratch to fit your application. JavaScript has a lot of cushioning, almost everything has a browser, and all modern browsers run JavaScript.

C++ is also statically typed. This means that you must declare each type of variable when encoding. JavaScript, on the other hand, is dynamically typed, which means that variables can change types at runtime. You don’t have to worry as much about whether something is a string or an integer in JavaScript, and you can then type it a bit faster than in C++.

It should be mentioned that C++ is a compiled language (and, ironically, a compilation language). This means that after you type the code, you will need to compile it before you can run it. This can take anywhere from a few seconds to an hour, depending on the length and complexity of the code. And you have to do this every time you make a change for troubleshooting or bug testing.

JavaScript is not overloaded by any compiler, it runs when you press play. Now, this isn’t necessarily a fair comparison, as JavaScript code is usually much shorter than the sometimes massive C++ programs that take so long to compile; but it is still relevant today.

JavaScript vs C++: syntax

JavaScript is a multi-paradigm language. It is designed to support event, functional, and imperative programming styles. It also has all the APIs needed to work with text, tables, dates, and regular expressions. However, it does not include any type of input or output like storage or graphics, these are all handled by the engine that runs it.

C++ is rigid; this leaves much less room for maneuver. C++ is object oriented. It looks like old school programming (braces and all) and has less tolerance (read: no tolerance) for missing a semicolon. It has objects, classes, methods, and instance variables.

C++ vs JavaScript: performance

For performance, in the sense of the speed at which a compiled program can run, there is no absolutely no competition. C++ is ten times faster than JavaScript in all areas. There is no argument that it is faster. In fact, very often when comparing two languages ‚Äã‚Äãit will be the C language with the fastest compilation times.

This result is because C++ is mid-level and compiled. It’s already closer to machine code, so it’s compiled into machine code, ready to run JavaScript is a replicated code interface . The thing you had to wait for before your C++ code was ready is what JavaScript does at run time.

Also, being a high level language, JavaScript is easier to type, but more work for the Duration interpreter. So while you can type a program in JavaScript much faster than in C++, JavaScript code runs much slower.

An important thing to note about performance is that for JavaScript it is normal to be a little slower. JavaScript is not designed for heavy calculations in a limited environment like C++. Do not program any moon lander in JavaScript.

JavaScript is used for interactivity in web pages, not for drawing a route to Jupiter or trying to mimic artificial intelligence. So a little delay is not a big problem if you were to use C++ for the same JavaScript application.

C++ vs JavaScript: application

The two languages ‚Äã‚Äãare used for very different things. JavaScript is for the web and C++ generally is for everything else. However, they overlap in a few places. One of those places is in the backend (or " server side "), where the data that you press on the front end of a web page is processed on a server.

JavaScript can form the backend along with Node.js and Express.js, all of which are part of a front-end to back-end web stack. This is useful because the front end is usually written in JavaScript; so having the backend written in JavaScript makes sense. It’s easier to fit in and there are fewer issues along the way. Plus, it comes with all the modern features offered by today’s web development stacks.

However, many backends have high resource requirements. They process tens of thousands of requests simultaneously. In these cases, having a faster, more efficient language like C++ is an advantage, as less resources are needed to handle all of these threads. C++ is compact and predictable and requires fewer resources than JavaScript.

The other point where you overlap is in game design. Modern AAA games are at the forefront of gaming technology and most of them are programmed in C++. This is because these games have very complex calculations that have to be done at a very fast pace, especially for online games where a fraction of a second could make the difference.

C++ is fast and efficient, it does a good job by doing quick but complicated calculations without consuming too much of your already strained hardware.

JavaScript is the opposite. It’s easy to type and learn, but in comparison, it’s slow and limited in functionality. JavaScript is only intended for browsers, so most of the games that could be created with JavaScript would be 2D games intended for browsers. You can create 3D games with JavaScript, but I would twist it to do something that is already a well-supported and established standard for C++.

JavaScript vs. C++: Community

Although C++ is much older than JavaScript, both have been around and have been widely used for over 20 years. They have communities everywhere.

They both have huge libraries and sample code. If you’re having a problem someone else has been there and if you need an integration chances are it has been created.

However, if we compare the two languages, C++ has more application and has been around longer, so it has a larger pool of people behind it. Either way, they’re both taken care of so well that there’s a good chance you won’t notice the difference.

Last word

JavaScript C++
Designed for the web Designed for everything < / td>
Multi-paradigm Object oriented
Type dynamically Static type
Runs slower than C++ Runs faster than JavaScript
Easy to learn Difficult to learn
Interpreted Compiled

These two languages ‚Äã‚Äãhave unique properties and particular strengths and weaknesses, so choosing one comes down to knowing what tool you need.

Need something fast ? Something widely supported for a desktop program, rocket launch footage, or video game ? C++ supports you.

If you need flexible, web-supported, easy-to-write, and easy-to-debug front-end programs for the web, JavaScript should be at the top of your list a mile away. Neither choice is bad, they are just different.

👻 Read also: what is the best laptop for engineering students?

Javascript Versus __del__: Questions


How can I make a time delay in Python?

5 answers

I would like to know how to put a time delay in a Python script.


Answer #1

import time
time.sleep(5)   # Delays for 5 seconds. You can also use a float value.

Here is another example where something is run approximately once a minute:

import time
while True:
    print("This prints once a minute.")
    time.sleep(60) # Delay for 1 minute (60 seconds).


Answer #2

You can use the sleep() function in the time module. It can take a float argument for sub-second resolution.

from time import sleep
sleep(0.1) # Time in seconds

Javascript Versus __del__: Questions


How to delete a file or folder in Python?

5 answers

How do I delete a file or folder in Python?


Answer #1

Path objects from the Python 3.4+ pathlib module also expose these instance methods:


How do I merge two dictionaries in a single expression (taking union of dictionaries)?

5 answers

Carl Meyer By Carl Meyer

I have two Python dictionaries, and I want to write a single expression that returns these two dictionaries, merged (i.e. taking the union). The update() method would be what I need, if it returned its result instead of modifying a dictionary in-place.

>>> x = {"a": 1, "b": 2}
>>> y = {"b": 10, "c": 11}
>>> z = x.update(y)
>>> print(z)
>>> x
{"a": 1, "b": 10, "c": 11}

How can I get that final merged dictionary in z, not x?

(To be extra-clear, the last-one-wins conflict-handling of dict.update() is what I"m looking for as well.)


Answer #1

How can I merge two Python dictionaries in a single expression?

For dictionaries x and y, z becomes a shallowly-merged dictionary with values from y replacing those from x.

  • In Python 3.9.0 or greater (released 17 October 2020): PEP-584, discussed here, was implemented and provides the simplest method:

    z = x | y          # NOTE: 3.9+ ONLY
  • In Python 3.5 or greater:

    z = {**x, **y}
  • In Python 2, (or 3.4 or lower) write a function:

    def merge_two_dicts(x, y):
        z = x.copy()   # start with keys and values of x
        z.update(y)    # modifies z with keys and values of y
        return z

    and now:

    z = merge_two_dicts(x, y)


Say you have two dictionaries and you want to merge them into a new dictionary without altering the original dictionaries:

x = {"a": 1, "b": 2}
y = {"b": 3, "c": 4}

The desired result is to get a new dictionary (z) with the values merged, and the second dictionary"s values overwriting those from the first.

>>> z
{"a": 1, "b": 3, "c": 4}

A new syntax for this, proposed in PEP 448 and available as of Python 3.5, is

z = {**x, **y}

And it is indeed a single expression.

Note that we can merge in with literal notation as well:

z = {**x, "foo": 1, "bar": 2, **y}

and now:

>>> z
{"a": 1, "b": 3, "foo": 1, "bar": 2, "c": 4}

It is now showing as implemented in the release schedule for 3.5, PEP 478, and it has now made its way into the What"s New in Python 3.5 document.

However, since many organizations are still on Python 2, you may wish to do this in a backward-compatible way. The classically Pythonic way, available in Python 2 and Python 3.0-3.4, is to do this as a two-step process:

z = x.copy()
z.update(y) # which returns None since it mutates z

In both approaches, y will come second and its values will replace x"s values, thus b will point to 3 in our final result.

Not yet on Python 3.5, but want a single expression

If you are not yet on Python 3.5 or need to write backward-compatible code, and you want this in a single expression, the most performant while the correct approach is to put it in a function:

def merge_two_dicts(x, y):
    """Given two dictionaries, merge them into a new dict as a shallow copy."""
    z = x.copy()
    return z

and then you have a single expression:

z = merge_two_dicts(x, y)

You can also make a function to merge an arbitrary number of dictionaries, from zero to a very large number:

def merge_dicts(*dict_args):
    Given any number of dictionaries, shallow copy and merge into a new dict,
    precedence goes to key-value pairs in latter dictionaries.
    result = {}
    for dictionary in dict_args:
    return result

This function will work in Python 2 and 3 for all dictionaries. e.g. given dictionaries a to g:

z = merge_dicts(a, b, c, d, e, f, g) 

and key-value pairs in g will take precedence over dictionaries a to f, and so on.

Critiques of Other Answers

Don"t use what you see in the formerly accepted answer:

z = dict(x.items() + y.items())

In Python 2, you create two lists in memory for each dict, create a third list in memory with length equal to the length of the first two put together, and then discard all three lists to create the dict. In Python 3, this will fail because you"re adding two dict_items objects together, not two lists -

>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: "dict_items" and "dict_items"

and you would have to explicitly create them as lists, e.g. z = dict(list(x.items()) + list(y.items())). This is a waste of resources and computation power.

Similarly, taking the union of items() in Python 3 (viewitems() in Python 2.7) will also fail when values are unhashable objects (like lists, for example). Even if your values are hashable, since sets are semantically unordered, the behavior is undefined in regards to precedence. So don"t do this:

>>> c = dict(a.items() | b.items())

This example demonstrates what happens when values are unhashable:

>>> x = {"a": []}
>>> y = {"b": []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: "list"

Here"s an example where y should have precedence, but instead the value from x is retained due to the arbitrary order of sets:

>>> x = {"a": 2}
>>> y = {"a": 1}
>>> dict(x.items() | y.items())
{"a": 2}

Another hack you should not use:

z = dict(x, **y)

This uses the dict constructor and is very fast and memory-efficient (even slightly more so than our two-step process) but unless you know precisely what is happening here (that is, the second dict is being passed as keyword arguments to the dict constructor), it"s difficult to read, it"s not the intended usage, and so it is not Pythonic.

Here"s an example of the usage being remediated in django.

Dictionaries are intended to take hashable keys (e.g. frozensets or tuples), but this method fails in Python 3 when keys are not strings.

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

From the mailing list, Guido van Rossum, the creator of the language, wrote:

I am fine with declaring dict({}, **{1:3}) illegal, since after all it is abuse of the ** mechanism.


Apparently dict(x, **y) is going around as "cool hack" for "call x.update(y) and return x". Personally, I find it more despicable than cool.

It is my understanding (as well as the understanding of the creator of the language) that the intended usage for dict(**y) is for creating dictionaries for readability purposes, e.g.:

dict(a=1, b=10, c=11)

instead of

{"a": 1, "b": 10, "c": 11}

Response to comments

Despite what Guido says, dict(x, **y) is in line with the dict specification, which btw. works for both Python 2 and 3. The fact that this only works for string keys is a direct consequence of how keyword parameters work and not a short-coming of dict. Nor is using the ** operator in this place an abuse of the mechanism, in fact, ** was designed precisely to pass dictionaries as keywords.

Again, it doesn"t work for 3 when keys are not strings. The implicit calling contract is that namespaces take ordinary dictionaries, while users must only pass keyword arguments that are strings. All other callables enforced it. dict broke this consistency in Python 2:

>>> foo(**{("a", "b"): None})
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{("a", "b"): None})
{("a", "b"): None}

This inconsistency was bad given other implementations of Python (PyPy, Jython, IronPython). Thus it was fixed in Python 3, as this usage could be a breaking change.

I submit to you that it is malicious incompetence to intentionally write code that only works in one version of a language or that only works given certain arbitrary constraints.

More comments:

dict(x.items() + y.items()) is still the most readable solution for Python 2. Readability counts.

My response: merge_two_dicts(x, y) actually seems much clearer to me, if we"re actually concerned about readability. And it is not forward compatible, as Python 2 is increasingly deprecated.

{**x, **y} does not seem to handle nested dictionaries. the contents of nested keys are simply overwritten, not merged [...] I ended up being burnt by these answers that do not merge recursively and I was surprised no one mentioned it. In my interpretation of the word "merging" these answers describe "updating one dict with another", and not merging.

Yes. I must refer you back to the question, which is asking for a shallow merge of two dictionaries, with the first"s values being overwritten by the second"s - in a single expression.

Assuming two dictionaries of dictionaries, one might recursively merge them in a single function, but you should be careful not to modify the dictionaries from either source, and the surest way to avoid that is to make a copy when assigning values. As keys must be hashable and are usually therefore immutable, it is pointless to copy them:

from copy import deepcopy

def dict_of_dicts_merge(x, y):
    z = {}
    overlapping_keys = x.keys() & y.keys()
    for key in overlapping_keys:
        z[key] = dict_of_dicts_merge(x[key], y[key])
    for key in x.keys() - overlapping_keys:
        z[key] = deepcopy(x[key])
    for key in y.keys() - overlapping_keys:
        z[key] = deepcopy(y[key])
    return z


>>> x = {"a":{1:{}}, "b": {2:{}}}
>>> y = {"b":{10:{}}, "c": {11:{}}}
>>> dict_of_dicts_merge(x, y)
{"b": {2: {}, 10: {}}, "a": {1: {}}, "c": {11: {}}}

Coming up with contingencies for other value types is far beyond the scope of this question, so I will point you at my answer to the canonical question on a "Dictionaries of dictionaries merge".

Less Performant But Correct Ad-hocs

These approaches are less performant, but they will provide correct behavior. They will be much less performant than copy and update or the new unpacking because they iterate through each key-value pair at a higher level of abstraction, but they do respect the order of precedence (latter dictionaries have precedence)

You can also chain the dictionaries manually inside a dict comprehension:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

or in Python 2.6 (and perhaps as early as 2.4 when generator expressions were introduced):

dict((k, v) for d in dicts for k, v in d.items()) # iteritems in Python 2

itertools.chain will chain the iterators over the key-value pairs in the correct order:

from itertools import chain
z = dict(chain(x.items(), y.items())) # iteritems in Python 2

Performance Analysis

I"m only going to do the performance analysis of the usages known to behave correctly. (Self-contained so you can copy and paste yourself.)

from timeit import repeat
from itertools import chain

x = dict.fromkeys("abcdefg")
y = dict.fromkeys("efghijk")

def merge_two_dicts(x, y):
    z = x.copy()
    return z

min(repeat(lambda: {**x, **y}))
min(repeat(lambda: merge_two_dicts(x, y)))
min(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))
min(repeat(lambda: dict(chain(x.items(), y.items()))))
min(repeat(lambda: dict(item for d in (x, y) for item in d.items())))

In Python 3.8.1, NixOS:

>>> min(repeat(lambda: {**x, **y}))
>>> min(repeat(lambda: merge_two_dicts(x, y)))
>>> min(repeat(lambda: {k: v for d in (x, y) for k, v in d.items()}))
>>> min(repeat(lambda: dict(chain(x.items(), y.items()))))
>>> min(repeat(lambda: dict(item for d in (x, y) for item in d.items())))
$ uname -a
Linux nixos 4.19.113 #1-NixOS SMP Wed Mar 25 07:06:15 UTC 2020 x86_64 GNU/Linux

Resources on Dictionaries


Answer #2

In your case, what you can do is:

z = dict(list(x.items()) + list(y.items()))

This will, as you want it, put the final dict in z, and make the value for key b be properly overridden by the second (y) dict"s value:

>>> x = {"a":1, "b": 2}
>>> y = {"b":10, "c": 11}
>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{"a": 1, "c": 11, "b": 10}

If you use Python 2, you can even remove the list() calls. To create z:

>>> z = dict(x.items() + y.items())
>>> z
{"a": 1, "c": 11, "b": 10}

If you use Python version 3.9.0a4 or greater, then you can directly use:

x = {"a":1, "b": 2}
y = {"b":10, "c": 11}
z = x | y
{"a": 1, "c": 11, "b": 10}


Answer #3

An alternative:

z = x.copy()

We hope this article has helped you to resolve the problem. Apart from Javascript Versus, check other __del__-related topics.

Want to excel in Python? See our review of the best Python online courses 2022. If you are interested in Data Science, check also how to learn programming in R.

By the way, this material is also available in other languages:

Olivia Galleotti

Warsaw | 2022-12-10

zeros is always a bit confusing 😭 Javascript Versus is not the only problem I encountered. Will get back tomorrow with feedback

Oliver Gonzalez

Prague | 2022-12-10

Thanks for explaining! I was stuck with Javascript Versus for some hours, finally got it done 🤗. Checked yesterday, it works!

Javier OConnell

Warsaw | 2022-12-10

Simply put and clear. Thank you for sharing. Javascript Versus and other issues with around was always my weak point 😁. I just hope that will not emerge anymore


Learn programming in R: courses


Best Python online courses for 2022


Best laptop for Fortnite


Best laptop for Excel


Best laptop for Solidworks


Best laptop for Roblox


Best computer for crypto mining


Best laptop for Sims 4


Latest questions


Common xlabel/ylabel for matplotlib subplots

12 answers


How to specify multiple return types using type-hints

12 answers


Why do I get "Pickle - EOFError: Ran out of input" reading an empty file?

12 answers


Flake8: Ignore specific warning for entire file

12 answers


glob exclude pattern

12 answers


How to avoid HTTP error 429 (Too Many Requests) python

12 answers


Python CSV error: line contains NULL byte

12 answers


csv.Error: iterator should return strings, not bytes

12 answers



Python | How to copy data from one Excel sheet to another

Common xlabel/ylabel for matplotlib subplots

Check if one list is a subset of another in Python


How to specify multiple return types using type-hints


Printing words vertically in Python


Python Extract words from a given string

Cyclic redundancy check in Python

Finding mean, median, mode in Python without libraries


Python add suffix / add prefix to strings in a list

Why do I get "Pickle - EOFError: Ran out of input" reading an empty file?

Python - Move item to the end of the list

Python - Print list vertically