Add Concept Exercise for type checking.

concepts/type-checking/.meta/config.json

@@ -0,0 +1,8 @@
+{
+  "blurb": "Learn how to check the type of a value or object in JavaScript",
+  "authors": [
+    "quintuple-mallard",
+    "SleeplessByte"
+  ],
+  "contributors": []
+}

concepts/type-checking/about.md

@@ -0,0 +1,164 @@
+# About
+
+Knowning what the type of a piece of data is, is often very important for code to run smoothly and without errors.
+
+Javascript has several ways to check the type of a value or object.
+
+```exercism/note
+Javascript's type checking mechanisms can be somewhat unreliable.
+
+For better type safety and stronger types, you should probably use TypeScript, a language that builds on JavaScript, but with the type syntax of a static-typed language.
+```
+
+## The `typeof` operator
+
+The `typeof` operator returns the type of its operand.
+The output is a string matching the name of one of the [primitive data types][primitives], except for `"null"`.
+It can also be `"function"` or `"object"`.
+
+```javascript
+typeof undefined;
+// => "undefined"
+
+typeof true;
+// => "boolean"
+
+typeof 42;
+// => "number"
+
+typeof 'Hello, World!';
+// => "string"
+
+typeof function () {
+  return 'Hello, World';
+};
+// => "function"
+
+typeof [1, 2, 3, 4];
+// => "object"
+
+typeof { city: 'Stockholm', country: 'Sweden' };
+// => "object"
+```
+
+For [historical reasons][`typeof null` is `"object"`].
+
+## The `instanceof` operator
+
+For checking the type of an object, you can use the `instanceof` operator.
+It evaluates into a `boolean` depending on whether the second operand is included in the first operands' [prototype chain][prototype chain].
+To clarify, `instanceof` will return whether the first operand is an instance of second operand or one of its child classes.
+`instanceof` only works on objects.
+
+```javascript
+class Beverage {
+  // ...
+}
+
+// The Coffee class is a child of the Beverage class.
+class Coffee extends Beverage {
+  // ...
+}
+
+const java = new Coffee();
+
+java instanceof Coffee;
+// => true
+
+java instanceof Beverage;
+// => true
+```
+
+````exercism/advanced
+The `Array` class has a method called `Array.isArray()` that checks if its argument is an array.
+
+While `instanceof Array` will not work with an array created in a different realm such as an `iframe` in a webpage, `Array.isArray()` will.
+
+This is because the Array class has a different constructor in each realm, and each `iframe` has its own ream, meaning that the function in the prototype chain will be different, causing `instanceof Array` to fail.
+`Array.isArray()` is capable of ignoring this, and should always be used when possible.
+
+It can also survive false positives where an object isn't actually an `Array`, and merely has `Array` in its prototype chain.
+
+```javascript
+({ __proto__: Array.prototype }) instanceof Array
+// => true
+
+Array.isArray({ __proto__: Array.prototype })
+// => false
+```
+
+````
+
+## The `in` operator
+
+The `in` operator returns whether the first operand is a property of the second operand.
+It does not check that the property has a defined value.
+A property set to `undefined` will still be detected by `in`.
+
+```javascript
+class Coffee {
+  constructor() {
+    this.temperature = 'hot';
+    this.isDarkMatter = undefined;
+  }
+
+  coolDown() {
+    this.temperature = 'warm';
+  }
+}
+
+const espresso = new Coffee();
+
+'temperature' in espresso;
+// => true
+
+'color' in espresso;
+// => false
+
+'isDarkMatter' in espresso;
+// => true
+```
+
+````exercism/note
+`in` will return `true` for inherited properties and methods.
+
+```javascript
+"coolDown" in espresso
+// => true
+
+"constructor" in espresso
+// => true
+```
+
+To avoid this, use `Object.hasOwn()` instead
+````
+
+## The `Object.hasOwn()` function
+
+The `Object.hasOwn()` method returns whether the specified object _owns the given property_ (it is not inherited or a method).
+
+```javascript
+class Coffee {
+  constructor() {
+    this.temperature = 'hot';
+  }
+
+  coolDown() {
+    this.temperature = 'warm';
+  }
+}
+const cappuccino = new Coffee();
+
+Object.hasOwn(cappucino, 'temperature');
+// => true
+
+Object.hasOwn(cappucino, 'constructor');
+// => false
+
+Object.hasOwn(cappucino, 'coolDown');
+// => false
+```
+
+[primitives]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive
+[typeof null is object]: https://2ality.com/2013/10/typeof-null.html
+[prototype chain]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain

concepts/type-checking/introduction.md

@@ -0,0 +1,164 @@
+# About
+
+Knowning what the type of a piece of data is, is often very important for code to run smoothly and without errors.
+
+Javascript has several ways to check the type of a value or object.
+
+```exercism/note
+Javascript's type checking mechanisms can be somewhat unreliable.
+
+For better type safety and stronger types, you should probably use TypeScript, a language that builds on JavaScript, but with the type syntax of a static-typed language.
+```
+
+## The `typeof` operator
+
+The `typeof` operator returns the type of its operand.
+The output is a string matching the name of one of the [primitive data types][primitives], except for `"null"`.
+It can also be `"function"` or `"object"`.
+
+```javascript
+typeof undefined;
+// => "undefined"
+
+typeof true;
+// => "boolean"
+
+typeof 42;
+// => "number"
+
+typeof 'Hello, World!';
+// => "string"
+
+typeof function () {
+  return 'Hello, World';
+};
+// => "function"
+
+typeof [1, 2, 3, 4];
+// => "object"
+
+typeof { city: 'Stockholm', country: 'Sweden' };
+// => "object"
+```
+
+For [historical reasons][`typeof null` is `"object"`].
+
+## The `instanceof` operator
+
+For checking the type of an object, you can use the `instanceof` operator.
+It evaluates into a `boolean` depending on whether the second operand is included in the first operands' [prototype chain][prototype chain].
+To clarify, `instanceof` will return whether the first operand is an instance of second operand or one of its child classes.
+`instanceof` only works on objects.
+
+```javascript
+class Beverage {
+  // ...
+}
+
+// The Coffee class is a child of the Beverage class.
+class Coffee extends Beverage {
+  // ...
+}
+
+const java = new Coffee();
+
+java instanceof Coffee;
+// => true
+
+java instanceof Beverage;
+// => true
+```
+
+````exercism/advanced
+The `Array` class has a method called `Array.isArray()` that checks if its argument is an array.
+
+While `instanceof Array` will not work with an array created in a different realm such as an `iframe` in a webpage, `Array.isArray()` will.
+
+This is because the Array class has a different constructor in each realm, and each `iframe` has its own ream, meaning that the function in the prototype chain will be different, causing `instanceof Array` to fail.
+`Array.isArray()` is capable of ignoring this, and should always be used when possible.
+
+It can also survive false positives where an object isn't actually an `Array`, and merely has `Array` in its prototype chain.
+
+```javascript
+({ __proto__: Array.prototype }) instanceof Array
+// => true
+
+Array.isArray({ __proto__: Array.prototype })
+// => false
+```
+
+````
+
+## The `in` operator
+
+The `in` operator returns whether the first operand is a property of the second operand.
+It does not check that the property has a defined value.
+A property set to `undefined` will still be detected by `in`.
+
+```javascript
+class Coffee {
+  constructor() {
+    this.temperature = 'hot';
+    this.isDarkMatter = undefined;
+  }
+
+  coolDown() {
+    this.temperature = 'warm';
+  }
+}
+
+const espresso = new Coffee();
+
+'temperature' in espresso;
+// => true
+
+'color' in espresso;
+// => false
+
+'isDarkMatter' in espresso;
+// => true
+```
+
+````exercism/note
+`in` will return `true` for inherited properties and methods.
+
+```javascript
+"coolDown" in espresso
+// => true
+
+"constructor" in espresso
+// => true
+```
+
+To avoid this, use `Object.hasOwn()` instead
+````
+
+## The `Object.hasOwn()` function
+
+The `Object.hasOwn()` method returns whether the specified object _owns the given property_ (it is not inherited or a method).
+
+```javascript
+class Coffee {
+  constructor() {
+    this.temperature = 'hot';
+  }
+
+  coolDown() {
+    this.temperature = 'warm';
+  }
+}
+const cappuccino = new Coffee();
+
+Object.hasOwn(cappucino, 'temperature');
+// => true
+
+Object.hasOwn(cappucino, 'constructor');
+// => false
+
+Object.hasOwn(cappucino, 'coolDown');
+// => false
+```
+
+[primitives]: https://developer.mozilla.org/en-US/docs/Glossary/Primitive
+[typeof null is object]: https://2ality.com/2013/10/typeof-null.html
+[prototype chain]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain

concepts/type-checking/links.json

@@ -0,0 +1,14 @@
+[
+  {
+    "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof",
+    "description": "MDN: The typeof operator"
+  },
+  {
+    "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof",
+    "description": "MDN: The instanceof operator"
+  },
+  {
+    "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty",
+    "description": "MDN: The object.hasOwnProperty() method"
+  }
+]

config.json

@@ -436,6 +436,22 @@
           "objects",
           "functions"
         ]
+      },
+      {
+        "slug": "recycling-robot",
+        "name": "Recycling Robot",
+        "uuid": "16114449-52fe-470e-af11-cf9dc3689a93",
+        "concepts": [
+          "type-checking"
+        ],
+        "prerequisites": [
+          "basics",
+          "errors",
+          "objects",
+          "arrays",
+          "classes",
+          "inheritance"
+        ]
       }
     ],
     "practice": [
@@ -2887,6 +2903,11 @@
       "uuid": "ca322d6f-0f7e-4a2d-a058-e98a59cdae93",
       "slug": "randomness",
       "name": "Randomness"
+    },
+    {
+      "uuid": "72e51fbe-db98-492e-b155-8ef21623f741",
+      "slug": "type-checking",
+      "name": "Type Checking"
     }
   ],
   "key_features": [