Compiler Explorer

Source code

// Okay, C++.  Just skip ahead to main(), I need to do a little work first.

#include <string> // string, to_string
#include <type_traits> // is_same_v
#include <cassert> // assert
#include <iostream> // cout
#include <typeinfo> // typeid internal jank
#include <cmath> // NAN, nan, isnan
#include <cstring> // strcat
#include <cstdlib> // strtof
#include <algorithm> // sort
#include <limits> // numeric_limits<T>::infinity
using namespace std::string_literals;

// Needed for later.
struct NannyStr {
    std::string data;
    NannyStr(std::string s) : data(s) {}
    NannyStr(const char* c) : data(c) {}

operator std::string() const { return data; }

float floatify() const {
        char* end = nullptr;
        float ret = strtof(data.c_str(), &end);

if (end == data.c_str()) {
            return nan(data.c_str());
        } else { return ret; }
    }

NannyStr operator+() const { return std::to_string(+floatify()); }

NannyStr& operator+=(NannyStr& s) { data += s.data; return *this; }
    friend NannyStr operator+(const NannyStr& l, const NannyStr& r) { return { l.data + r.data }; }
    friend std::ostream& operator<<(std::ostream& os, const NannyStr& n) { return os << n.data; }
    friend bool operator==(const NannyStr& l, const NannyStr& r) { return l.data == r.data; }
};

int main() {
    // 10 + "1" == "101"
    // Not directly portable, but same logic exists.
    // In C++, numerical types can be implicitly promoted to larger types, to make both operands match.  (Simplified.)
    // JS is similar, but also allows all types to be promoted to strings.  And adding strings is string concatenation.
    // This is just type promotion, nothing more.  Equivalent to:

short a = 10;
    long long b = 1;
    auto c = a + b; // c is long long.
    static_assert(std::is_same_v<decltype(c), long long>, "Assertion fails if c isn't long long."); // Proof.
    std::cout << "c is: " << typeid(decltype(c)).name() << ".  Same logic as 10 + \"1\" == \"101\".\n";

// =====

// 10 - "1" == 9
    // ...Okay, this one doesn't exist in C++, but we can make it pretty easily.
    // String subtraction is an invalid operation, thus operands cannot be promoted to string.
    // JS thus uses a built-in conversion operator to turn the string into a number.
    // Something like this.

struct NumString {
        std::string data = {};

NumString(std::string s) : data(s) {}
        NumString(const char* c) : data(c) {}

operator int() const { return std::stoi(data); }
    };

int d = 10;
    NumString e = "1";
    assert((d - e) == 9);
    std::cout << "\n10 - \"1\" is: " << d - e << '\n';

// =====

// typeof NaN == number
    // This is completely correct, normal, and reasonable, yes.
    // NaN is a special value that allows a numerical field to indicate that it was given non-numerical data.
    // It must, by definition, be a number.  (A poisoned, invalid number, specifically.)
    // If it's not a number, floating-point types can't store it.

std::cout << "\nNaN is: " << typeid(NAN).name() << '\n'
              << "Is it a number?  " << (std::is_arithmetic_v<decltype(NAN)> ? "Yes" : "No" ) << ".\n";

// The _real_ weirdness is that JS doesn't know the difference between quiet & signaling NaNs.

// =====

// [] + [] == ""
    // Looks like string concatenation with empty strings to me.
    // Makes sense for a language where everything is convertible to strings.  Empty array is empty string.

const char f[] = "";
    const char g[] = "";

char h[20] = "";
    strcat(h, f);
    strcat(h, g);
    assert(strlen(h) == 0);
    std::cout << "\nAdding two empty arrays results in size: " << strlen(h) << '\n';

// Also, std::string is just an array in a fancy suit, so this.
    std::string i = "";
    std::string j = "";
    std::string k = i + j;
    assert(k.size() == 0);
    std::cout << "Even with C++ strings, length is still: " << k.size() << '\n';

// =====

// [] + {} == [object Object]
    // Assuming {} is still the "create instance" syntax, this makes perfect sense.
    // JS is based on Java's object-obsessed programming design, thus every class inherits from Object.
    // One of JS' main goals is to minimise errors by providing fallbacks, so {} falls back to Object{}.
    // JS arrays store Object and use dynamic type reflection, so this adds an Object to the Object[].
    // Just plain ol' array concatenation, we're concatenating a single element onto the array.
    // Gonna use std::string to demonstrate, it's the only array with a built-in addition operator.

std::string l;
    assert(l.size() == 0);
    std::cout << "\nArray has " << l.size() << " elements.\n";
    l += '\0';
    assert(l.size() == 1);
    std::cout << "Array now has " << l.size() << " element.\n";

// =====

// {} + [] == 0
    // Okay, you got me, this one's dumb.
    // Clearly not array concatenation, because of ordering.
    // The left-hand operand isn't implicitly numeric.
    // In most languages, the only inherent value an array has is its memory address, which is nonzero.
    // This appears to be an implicit conversion followed by a type promotion.
    // If (and only if) "+ []" is equivalent to "+ [].size()", then this makes perfect sense: 
    // Right-hand operand evaluates to a number, so left-hand gets promoted to number.
    // Otherwise... you won the thread, congrats!

std::cout << "\nObject plus array equals number?  Not in my C++!\n";

// =====

// true + true == 2
    // So, fun fact, in the C family, booleans are a numeric type.
    // `false` is 0 (and all numeric zeroes double as `false`), and nonzero is `true` (and `true` is 1).
    // `bool` can be promoted to `int` in both C and C++.
    // (And in C, `bool` actually WAS just `int` in disguise for literal decades.  C defined `TRUE` as integer 1.)
    // This is literally just type promotion.

int m = true + true;
    assert(m == 2);
    std::cout << '\n' << m << " is doubly true.\n";

// =====

// "b" + "a" + +"a" + "a" == "baNaNa"
    // This is one of the use cases of NaN: Trapping invalid numbers.
    // It attempts to provide the positive numerical value of "a".  However, strings aren't numbers.
    // The `+"a"` is replaced with a NaN, which is then promoted to string because of string concatenation.
    // Looks stupid, but makes perfect sense.
    // It's actually smarter than C & C++ here, since it implicitly recognises any non-numeric string as NaN.
    // C would convert it to '0', C++ would either convert it to '0' or explode.
    // This is what the NannyStr thing up there was for, it's a string class that does what JS does for free,
    //  since C++ doesn't implicitly NaN-ify invalid strings on conversion or stringify NaNs on concatenation.

NannyStr n = "b";
    NannyStr o = "a";

NannyStr p = n + o + +o + o;
    assert(p == "banana"s);
    std::cout << "\nIf strings can become NaN, they taste like: " << p << '\n';

// =====

// (9999999999999999 === 10000000000000000) == true
    // So, fun fact, JS' only numeric type is floating-point.

double q = 9999999999999999;
    double r = 10000000000000000;
    assert(q == r);
    std::cout << "\nAre 9999999999999999 and 10000000000000000 equal?  " << (q == r ? "Yes" : "No") << ".\n";

// Out of the three "main" compilers, clang is the only one nice enough to warn that q changes to 1.0E+16 here.

// =====

// [1, 2, 10].sort() == [1, 10, 2]
    // Looks like string sorting to me.

std::string s[3] = { "1", "2", "10" };
    std::sort(std::begin(s), std::end(s));
    assert(s[1] == "10");
    std::cout << "\nElements are: ";
    for (auto ss : s) { std::cout << ss << ", "; }
    std::cout << '\n';

// =====

// Array(16).join("wat" - 1) == "NaNNaNNaNNaN..." (16 times)
    // Banana thing again.  Trying to convert "wat" into a number, resulting in a NaN.
    // Thus, you have an array of 16 invalid numbers.
    // Not making a custom class to demonstrate, since it's the same reason as the banana.

std::cout << "\nI am NaN and wat is this?\n";

// =====

// Undefined silliness.
    // This one actually makes perfect sense, it just looks stupid.
    // `undefined` means the value is missing, and `null` means the object is missing.
    // Semantically identical, but mechanically different.
    // Thus, semantic comparison returns true, and literal comparison returns false.
    // Can't actually replicate in C/C++, since dereferencing undefined values is undefined behavior, and makes
    //  cats and dogs live together.
    // Could make a class to demonstrate, but that would just be a tautology here.
    // Best comparison would be after-the-end pointers/values.  They're as invalid as null pointers, and often
    //  used to represent invalid indexes or elements, such as an undefined search result.
    // Imagine int arr[5].  Imagine trying to dereference arr[5] or arr[nullptr].
    //  Both break things, but in different ways, and it doesn't mean &arr[5] is a nullptr.

std::cout << "\nC++ doesn't have a single distinct definition for the lack of definition, sadly."
              << "\nCan't compare cleanly to null because of that, sorry.\n";

// =====

// ({} === {}) == false
    // Makes sense if it's checking the object identities, which I believe it does.
    // Both objects have the same value, but they're still different objects.
    // Is equivalent to comparing memory addresses.

std::string t{};
    std::string u{};
    assert(t == u);
    assert(!(&t == &u));
    std::cout << "\nt and u have " << (t == u ? "the same" : "different") << " values, and are "
              << (&t == &u ? "the same" : "different") << " objects.\n";

// =====

// Infinity - Infinity == NaN
    // Yes, that's correct.
    // Remember, infinity is not a number.  It's the concept of a number too large to be a number, and there are
    //  an infinite number of distinct "infinity" numbers.
    // Hence, division by zero.  No matter how many zeroes you subtract from a number, you will NEVER reduce that number to zero.
    // Infinity plus infinity equals infinity.  Now consider "(infinity plus infinity) minus infinity."
    // We expect the result to be "infinity", because we added two infinities and subtracted one infinity.
    // But because infinity plus infinity equals infinity, this reduces to "infinity minus infinity"... which expects zero.
    // Thus, depending on whether you simplify the math or not, infinity minus infinity should equal either zero or infinity.
    // This means that the expected result is "zero and infinity, at the same time, but also zero OR infinity but not both".
    // This doesn't break JavaScript, it breaks math itself; a scalar operation can only have one result, but this one has two.
    // The result is formally defined as "undefined", and is thus not something we can reasonably call a number.
    // All sane languages will provide this result, if using sane floating-point types.

float v = std::numeric_limits<float>::infinity();
    assert(std::isnan(v - v));
    std::cout << "\nTo ∞ and beyond, but when we return how many shall there be?  Truly, the answer is: " << v - v << '\n';

// =====

// (+"" === 0) == true
    // Type promotion strikes again!
    // An empty string has a value of zero when promoted to number, apparently.  Thus doth JavaScript decree.
    // This is a distinct break with C.  In C (and C++), only _non-empty_ strings can be converted to numbers.
    // C would give you a 0, but as a fallback to prevent a crash; it indicates that the conversion is invalid.
    // My NannyStr up there would catch it and turn it into a NaN.  C++ would either copy C or explode.
    // JS is being lenient here, probably because its type promotion rules mean this NEEDS to be well-defined.

NannyStr w = "";
    std::cout << "\nWhere JavaScript sees a zero, C/C++ sees either a " << strtof(""s.c_str(), nullptr)
              << " or a " << +w << '\n';

// =====

std::cout << "\n\nI shall now dereference a nullptr, and let the undefined behaviour change your mind!";

struct Struct {
        void func() { std::cout << "\nYour mind has now been changed.  Ta~da~!\n"; }
    };

static_cast<Struct*>(nullptr)->func();
};