Learn JavaScript

lesson ā§Ē / ā§Ž ¡ āĻĒā§āϰāĻĨāĻŽ program: console, let āφāϰ const, type, typeof

Module ā§§ ¡ āĻĒā§āϰāĻĨāĻŽ program: console, let āφāϰ const, type, typeof

typeof, undefined āφāϰ null: āĻāĻ•āϟāĻž value-āϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰāĻž āϏ⧇ āϕ⧀

FreeāĻĒāĻĄāĻŧāĻž

āĻāχ lesson-āĻ āϝāĻž āĻļāĻŋāĻ–āĻŦ⧇

  • āϏāĻŦ āϰāĻ•āĻŽā§‡āϰ value-āϰ āωāĻĒāϰ typeof āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āĻāϰ āωāĻ¤ā§āϤāϰāϗ⧁āϞ⧋ āĻĒāĻĄāĻŧāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āϚāĻŽāϕ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻĻ⧁āχāϟāĻžāϏāĻšāĨ¤
  • undefined āϰ⧋āϜ āϝ⧇ āϤāĻŋāύ āϜāĻžāϝāĻŧāĻ—āĻž āĻĨ⧇āϕ⧇ āφāϏ⧇, āϏ⧇āϗ⧁āϞ⧋āϰ āύāĻžāĻŽ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āĻāĻ•āϟāĻž null āϕ⧇ āĻŦāϏāĻžāϝāĻŧāĨ¤
  • āĻ•āĻ–āύ⧋ declare āύāĻž āĻšāĻ“āϝāĻŧāĻž āύāĻžāĻŽ āφāϰ undefined āϧāϰ⧇ āĻĨāĻžāĻ•āĻž āύāĻžāĻŽā§‡āϰ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϧāϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ crash āĻ›āĻžāĻĄāĻŧāĻžāχ āĻĻ⧁āχāϟāĻž check āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

David-āĻāϰ āĻĻā§‹āĻ•āĻžāύ āĻĒā§āϰāϤāĻŋāϟāĻž āϰāϏāĻŋāĻĻ⧇āϰ āϏāĻ™ā§āϗ⧇ āĻāĻ•āϟāĻž āĻļ⧁āϭ⧇āĻšā§āĻ›āĻž āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤ āĻāĻ• āϏāĻ•āĻžāϞ⧇ āĻĻ⧇āĻ–āĻž āϗ⧇āϞ, āϰāϏāĻŋāĻĻ⧇ āĻ•āĻžāĻ¸ā§āϟāĻŽāĻžāϰ⧇āϰ āύāĻžāĻŽā§‡āϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āϞ⧇āĻ–āĻž Hello, undefinedāĨ¤ āĻ•āĻŋāϛ⧁ crash āĻ•āϰ⧇āύāĻŋ, āϕ⧇āω āϏāϤāĻ°ā§āĻ•āĻ“ āĻ•āϰ⧇āύāĻŋ, āφāϰ āĻļāĻŦā§āĻĻāϟāĻž āĻĻ⧇āϖ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ printer-āĻāϰ āϕ⧋āύ⧋ bugāĨ¤ āφāϏāϞ⧇ āϤāĻž āύāĻžāĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž value, āĻāĻ•āĻĻāĻŽ āĻ āĻŋāĻ•āĻ āĻžāĻ• āĻ›āĻžāĻĒāĻž āĻšāϝāĻŧ⧇āϛ⧇, āφāϰ āĻāχ lesson āĻ“āϟāĻžāϰ āĻĒāĻŋāϛ⧁ āύāĻŋāϝāĻŧ⧇ āĻĒ⧌āρāĻ›āĻžāĻŦ⧇ āϏ⧇āχ āϞāĻžāχāύ⧇, āϝ⧇āϟāĻžāϰ āĻ“āϤ⧇ value āĻŦāϏāĻžāύ⧋āϰ āĻ•āĻĨāĻž āĻ›āĻŋāϞāĨ¤

typeof: value-āϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋ āϏ⧇ āϕ⧀

Lesson 03-āĻ typeof āĻāĻ• āĻāϞāĻ• āĻĻ⧇āϖ⧇āĻ›āĨ¤ āĻāϟāĻž āĻāĻ•āϟāĻž operator, --āĻāϰ āĻŽāϤ⧋, āϝ⧇āϟāĻž āĻāĻ•āϟāĻž value-āϰ āϏāĻžāĻŽāύ⧇ āĻŦāϏ⧇ āφāϰ āϤāĻžāϰ type-āĻāϰ āύāĻžāĻŽ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ, āĻāĻ•āϟāĻž string āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤

typeof operator

typeof value
  • typeof āĻāĻ•āϟāĻž keyword, āϝ⧇āϟāĻž operator-āĻāϰ āĻ•āĻžāϜ āĻ•āϰ⧇; āĻāϰ āϜāĻ¨ā§āϝ bracket āϞāĻžāϗ⧇ āύāĻžāĨ¤
  • value āϝ⧇āϕ⧋āύ⧋ expression: āĻāĻ•āϟāĻž literal, āĻāĻ•āϟāĻž āύāĻžāĻŽ, āĻāĻ•āϟāĻž āϝ⧋āĻ—āĻĢāϞāĨ¤
  • āĻĢāϞ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻāĻ•āϟāĻž string, āϝ⧇āĻŽāύ "number" āĻŦāĻž "string", āϤāĻžāχ āĻāϟāĻž āĻ›āĻžāĻĒāϤ⧇ āĻĒāĻžāϰ⧋, āϤ⧁āϞāύāĻžāĻ“ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧋āĨ¤

āĻāχ āĻšāϞ⧋ āϏ⧇āχ āĻāĻ•āϟāĻž program, āϝ⧇āϟāĻž āĻŦāĻžāϰ⧋āϟāĻž value-āϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇, āĻāχ track-āĻ āϝāϤ āϰāĻ•āĻŽā§‡āϰ value-āϰ āϏāĻ™ā§āϗ⧇ āϤ⧋āĻŽāĻžāϰ āĻĻ⧇āĻ–āĻž āĻšāĻŦ⧇, āϤāĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āĻāĻ•āϟāĻž āĻ•āϰ⧇āĨ¤

console.log(typeof 42);
console.log(typeof 3.14);
console.log(typeof NaN);
console.log(typeof "hi");
console.log(typeof "");
console.log(typeof true);
console.log(typeof undefined);
console.log(typeof null);
console.log(typeof 10n);
console.log(typeof Symbol("id"));
console.log(typeof { name: "Zara" });
console.log(typeof console.log);
number
number
number
string
string
boolean
undefined
object
bigint
symbol
object
function

āĻāĻ•āχ āωāĻ¤ā§āϤāϰāϗ⧁āϞ⧋, āĻāĻ•āϟāĻž table-āĻ, āĻšāĻžāϤ⧇āϰ āĻ•āĻžāϛ⧇ āϰāĻžāĻ–āĻžāϰ āĻŽāϤ⧋ āĻ•āϰ⧇:

Valuetypeof āĻŦāϞ⧇āĻāϟāĻž āĻ•āĻŋ lesson 03-āĻāϰ type?
42, 3.14, NaN, Infinity"number"āĻšā§āϝāĻžāρ
"hi", """string"āĻšā§āϝāĻžāρ
true, false"boolean"āĻšā§āϝāĻžāρ
undefined"undefined"āĻšā§āϝāĻžāρ
null"object"āύāĻž: type āĻšāϞ⧋ null
10n"bigint"āĻšā§āϝāĻžāρ
Symbol("id")"symbol"āĻšā§āϝāĻžāρ
{ name: "Zara" }, [1, 2]"object"āĻšā§āϝāĻžāρ
console.log, āϝ⧇āϕ⧋āύ⧋ function"function"āύāĻž: function āφāϏāϞ⧇ āĻāĻ•āϟāĻž object

āϤāĻžāχ typeof āĻāĻ•āϟāĻž type-āĻāϰ āύāĻžāĻŽ āĻĻ⧇āϝāĻŧ string āĻšāĻŋāϏ⧇āĻŦ⧇, āφāϰ āĻāϰ āϏāĻžāϤāϟāĻž āωāĻ¤ā§āϤāϰ lesson 03-āĻāϰ table-āĻāϰ āϏāĻ™ā§āϗ⧇ āĻšā§āĻŦāĻšā§ āĻŽā§‡āϞ⧇āĨ¤

āϝ⧇ āĻĻ⧁āχāϟāĻž āωāĻ¤ā§āϤāϰ āϚāĻŽāϕ⧇ āĻĻ⧇āϝāĻŧ

typeof null āĻšāϞ⧋ "object", āφāϰ āĻāϟāĻž āĻāĻ•āϟāĻž bugāĨ¤ āĻĒā§āϰāĻĨāĻŽ JavaScript engine, 1995-āĻ Netscape-āĻ āϞ⧇āĻ–āĻž, āĻĒā§āϰāϤāĻŋāϟāĻž value-āϰ āĻĒāĻžāĻļ⧇ āϛ⧋āϟ āĻāĻ•āϟāĻž type tag āϰāĻžāĻ–āϤāĨ¤ Object-āĻāϰ tag āĻ›āĻŋāϞ 0, āφāϰ null āϰāĻžāĻ–āĻž āĻšāϤ⧋ zero pointer āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āϤāĻžāχ check-āϟāĻž null-āϕ⧇ object āĻŦāϞ⧇ āĻĒāĻĄāĻŧāϤāĨ¤ āϝāϤāĻĻāĻŋāύ⧇ āϕ⧇āω āĻāϟāĻž āϏāĻžāϰāĻžāϤ⧇ āϚāĻžāχāϞ, āϤāϤāĻĻāĻŋāύ⧇ āϞāĻžāĻ– āϞāĻžāĻ– page āĻĒ⧁āϰ⧋āύ⧋ āωāĻ¤ā§āϤāϰ⧇āϰ āωāĻĒāϰ āĻ­āϰ āĻ•āϰ⧇ āĻŦāϏ⧇ āφāϛ⧇āĨ¤ ES2015-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž fix āĻĒā§āϰāĻ¸ā§āϤāĻžāĻŦ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āĻ›āĻŋāϞ, āφāϰ āĻ āĻŋāĻ• āĻāχ āĻ•āĻžāϰāϪ⧇āχ āϏ⧇āϟāĻž āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇āĨ¤ āϤāĻžāχ bug-āϟāĻž āĻāĻ–āύ standard-āĻāϰ āĻ…āĻ‚āĻļ, āφāϰ āĻāϟāĻž āĻĨ⧇āϕ⧇āχ āϝāĻžāĻŦ⧇āĨ¤

āĻāĻ•āϟāĻž function-āĻāϰ typeof āĻšāϞ⧋ "function"āĨ¤ Function āĻāĻ• āϰāĻ•āĻŽā§‡āϰ object, āϤāĻžāχ table āĻŽāĻžāύāϞ⧇ āωāĻ¤ā§āϤāϰ āĻšāĻ“āϝāĻŧāĻžāϰ āĻ•āĻĨāĻž "object"āĨ¤ āĻ­āĻžāώāĻžāϟāĻž āĻāĻ–āĻžāύ⧇ āĻœā§‡āύ⧇āĻŦ⧁āĻā§‡ āĻŦā§āϝāϤāĻŋāĻ•ā§āϰāĻŽ āϰ⧇āϖ⧇āϛ⧇, āĻ•āĻžāϰāĻŖ "āĻāϟāĻž āĻ•āĻŋ call āĻ•āϰāĻž āϝāĻžāϝāĻŧ?" āĻĒā§āϰāĻļā§āύāϟāĻž program-āϕ⧇ āĻĒā§āϰāĻžāϝāĻŧāχ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤ āĻāϟāĻž feature, bug āύāĻžāĨ¤

āϤāĻžāχ typeof āĻāĻ•āϟāĻž null āϚāĻŋāύāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž, āĻ•āĻŋāĻ¨ā§āϤ⧁ function āϚāĻŋāύāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ null-āĻāϰ āĻ āĻŋāĻ• test āĻĻ⧇āĻ–āĻžāĻŦ⧇ "āĻĒā§āϰāϤāĻŋāϟāĻž āĻĢāĻžāρāĻ•āĻž āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ check āĻ•āϰāĻž" āĻ…āĻ‚āĻļāĨ¤

undefined āϕ⧋āĻĨāĻž āĻĨ⧇āϕ⧇ āφāϏ⧇

undefined āĻŽāĻžāύ⧇ "āĻāĻ–āύ⧋ āϕ⧋āύ⧋ value āύ⧇āχ"āĨ¤ āĻāϟāĻž āϤ⧁āĻŽāĻŋ āϖ⧁āĻŦ āĻ•āĻŽāχ āύāĻŋāĻœā§‡ āϞ⧇āĻ–ā§‹āĨ¤ Engine āĻāϟāĻž āĻŦāϏāĻžāϝāĻŧ āϰ⧋āϜāĻ•āĻžāϰ āϤāĻŋāύāϟāĻž āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ, āφāϰ David-āĻāϰ bug āĻāϏ⧇āĻ›āĻŋāϞ āĻĒā§āϰāĻĨāĻŽāϟāĻž āĻĨ⧇āϕ⧇āĨ¤

let customerName;
console.log("Hello,", customerName);

function greet(name) {
  console.log("Hello,", name);
}
greet();

const customer = { name: "David" };
console.log(customer.phone);
Hello, undefined
Hello, undefined
undefined
  1. Value āĻ›āĻžāĻĄāĻŧāĻž declare āĻ•āϰāĻž āύāĻžāĻŽāĨ¤ let customerName; āύāĻžāĻŽāϟāĻž āĻŦāĻžāύāĻžāϝāĻŧ, āφāϰ āϤāĻžāϤ⧇ āϰāĻžāϖ⧇ undefinedāĨ¤ David āϭ⧇āĻŦ⧇āĻ›āĻŋāϞ order āĻĨ⧇āϕ⧇ āĻāϟāĻž āĻ­āϰ⧇ āĻĻ⧇āĻŦ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•āĻ–āύ⧋ āĻĻ⧇āϝāĻŧāύāĻŋāĨ¤
  2. āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧāĻž argumentāĨ¤ greet āĻāĻ•āϟāĻž function, āϝ⧇āϟāĻž āĻāĻ•āϟāĻž name āφāĻļāĻž āĻ•āϰ⧇ (function āĻļ⧇āĻ–āĻžāĻŦ⧇ Module 5)āĨ¤ Bracket-āĻ āĻ•āĻŋāϛ⧁ āύāĻž āĻĻāĻŋāϝāĻŧ⧇ call āĻ•āϰāϞ⧇ āĻ“āϰ name-āĻ āĻĨāĻžāϕ⧇ undefinedāĨ¤
  3. āύāĻž āĻĨāĻžāĻ•āĻž propertyāĨ¤ customer āĻāĻ•āϟāĻž object, āϝāĻžāϤ⧇ āφāϛ⧇ āĻāĻ•āϟāĻž name, āφāϰ āĻ•āĻŋāϛ⧁ āύāĻž (Module 8)āĨ¤ customer.phone āϚāĻžāχāϞ⧇ āφāϏ⧇ undefined, āϕ⧋āύ⧋ error āύāĻžāĨ¤
āϤāĻŋāύāϟāĻž āϰāĻžāĻ¸ā§āϤāĻž āϝāĻžāϝāĻŧ undefined-āĻ, āϝ⧇āϟāĻž āĻŦāϏāĻžāϝāĻŧ engine; āĻāĻ•āϟāĻž āϰāĻžāĻ¸ā§āϤāĻž āϝāĻžāϝāĻŧ null-āĻ, āϝ⧇āϟāĻž āĻŦāϏāĻžāĻ“ āϤ⧁āĻŽāĻŋ āĻĻ⧁āχ āϰāĻ•āĻŽā§‡āϰ āĻĢāĻžāρāĻ•āĻž āϕ⧋āĻĨāĻž āĻĨ⧇āϕ⧇ āφāϏ⧇ let customerName; (value āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋ) greet(); (argument āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇āϛ⧇) customer.phone (āĻāĻŽāύ property āύ⧇āχ) undefined āĻāĻ–āύ⧋ value āύ⧇āχ, āĻŦāϏāĻŋāϝāĻŧ⧇āϛ⧇ engine const middleName = null; (āϤ⧁āĻŽāĻŋ) null āχāĻšā§āĻ›āĻž āĻ•āϰ⧇āχ value āύ⧇āχ, āĻŦāϏāĻŋāϝāĻŧ⧇āĻ› āϤ⧁āĻŽāĻŋ

āϤāĻžāχ undefined āĻĻ⧇āĻ–āĻž āĻĻāĻŋāϞ⧇ āϤāĻŋāύāϟāĻž āĻĒā§āϰāĻļā§āύ āĻ•āϰ⧋āĨ¤ āύāĻžāĻŽāϟāĻž āĻ•āĻŋ āĻ•āĻ–āύ⧋ value āĻĒ⧇āϝāĻŧ⧇āĻ›āĻŋāϞ? āϕ⧋āύ⧋ argument āĻ•āĻŋ āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇āϛ⧇? Property-āϟāĻž āĻ•āĻŋ āϏāĻ¤ā§āϝāĻŋāχ āφāϛ⧇?

null: āϕ⧋āύ⧋ value āύ⧇āχ, āχāĻšā§āĻ›āĻž āĻ•āϰ⧇āχ

Engine āύāĻŋāĻœā§‡ āĻĨ⧇āϕ⧇ āϕ⧋āύ⧋ āύāĻžāĻŽā§‡ null āĻŦāϏāĻžāϝāĻŧ āύāĻž, āϝ⧇āĻ­āĻžāĻŦ⧇ undefined āĻŦāϏāĻžāϝāĻŧāĨ¤ null āϏāĻŦ āϏāĻŽāϝāĻŧ āĻ•āĻžāϰāĻ“ āĻāĻ•āϟāĻž āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ: āϤ⧋āĻŽāĻžāϰ, āϤ⧋āĻŽāĻžāϰ code āϝ⧇ data āĻĒ⧇āϝāĻŧ⧇āϛ⧇ āϤāĻžāϰ āϞ⧇āĻ–āϕ⧇āϰ, āύāϝāĻŧāϤ⧋ āĻāĻŽāύ āϕ⧋āύ⧋ built-in tool-āĻāϰ, āϝ⧇āϟāĻž "āĻ•āĻŋāϛ⧁ āĻĒāĻžāχāύāĻŋ" āĻŦā§‹āĻāĻžāϤ⧇ āĻāϟāĻž āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϰ āĻŽāĻžāύ⧇ "āĻĻ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āϛ⧇, āφāϰ āĻ•āĻŋāϛ⧁ āύ⧇āχ"āĨ¤

const form = { name: "Amara", middleName: null };
console.log(form.middleName);
console.log(form.nickname);
console.log(typeof form.middleName);
console.log(typeof form.nickname);
null
undefined
object
undefined

Form-āϟāĻž Amara-āϕ⧇ āĻŽāĻžāĻā§‡āϰ āύāĻžāĻŽ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇āĻ›āĻŋāϞ, āφāϰ āĻ“āϰ āϕ⧋āύ⧋ āĻŽāĻžāĻā§‡āϰ āύāĻžāĻŽ āύ⧇āχ: nullāĨ¤ āĻĄāĻžāĻ•āύāĻžāĻŽ āĻ•āĻ–āύ⧋ āϜāĻŋāĻœā§āĻžā§‡āϏāχ āĻ•āϰ⧇āύāĻŋ: undefinedāĨ¤ āĻĻ⧁āχāϟāĻžāϰ āĻŽāĻžāύ⧇āχ "āĻ•āĻŋāϛ⧁ āύ⧇āχ", āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĻ⧁āχāϟāĻž āφāϞāĻžāĻĻāĻž āĻĒā§āϰāĻļā§āύ⧇āϰ āωāĻ¤ā§āϤāϰāĨ¤ āφāϰ null-āĻāϰ āϜāĻ¨ā§āϝ typeof āĻŦāϞ⧇ "object", āωāĻĒāϰ⧇āϰ āĻ…āĻ‚āĻļ⧇āϰ āϏ⧇āχ bugāĨ¤ āϤāĻžāχ null āϏāĻŦ āϏāĻŽāϝāĻŧ āĻ•āĻžāϰāĻ“ āĻāĻ•āϟāĻž āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ, āφāϰ āĻāϜāĻ¨ā§āϝāχ āĻ“āϟāĻž āĻĒāĻĄāĻŧ⧇ āĻ•āĻžāĻœā§‡āϰ āĻ–āĻŦāϰ āĻĒāĻžāĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻž āĻĢāĻžāρāĻ•āĻž āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ check āĻ•āϰāĻž

"āĻāϟāĻž āĻ•āĻŋ undefined?" āĻŦāĻž "āĻāϟāĻž āĻ•āĻŋ null?" āϜāĻžāύāϤ⧇ āϚāĻžāχāϞ⧇ === āĻĻāĻŋāϝāĻŧ⧇ āϤ⧁āϞāύāĻž āĻ•āϰ⧋āĨ¤ Lesson 03 āĻāϟāĻž āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧁āχāϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āϤ⧁āϞāύāĻž āĻ•āϰ⧇āĻ›āĻŋāϞ, āφāϰ āĻāχ āĻĻ⧁āχāϟāĻž value-āϤ⧇āĻ“ āĻāϟāĻž āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

let phone;
const middleName = null;
console.log(phone === undefined);
console.log(middleName === null);
console.log(typeof middleName === "object");
console.log(typeof phone === "undefined");
true
true
true
true

āϤ⧃āϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž true, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϟāĻž null-āĻāϰ āϕ⧋āύ⧋ test āύāĻž: āĻĒā§āϰāϤāĻŋāϟāĻž object-āĻ“ "object" āĻĻ⧇āϝāĻŧāĨ¤ āϤāĻžāχ null test āĻ•āϰ⧋ === null āĻĻāĻŋāϝāĻŧ⧇, āφāϰ undefined āĻ•āϰ⧋ === undefined āĻĻāĻŋāϝāĻŧ⧇āĨ¤

Program āϏāĻžāϧāĻžāϰāĻŖāϤ āωāĻ¤ā§āϤāϰāϟāĻž āύāĻŋāϝāĻŧ⧇ āĻ•āĻŋāϛ⧁ āĻāĻ•āϟāĻž āĻ•āϰāϤ⧇ āϚāĻžāϝāĻŧ, āĻļ⧁āϧ⧁ true āϛ⧇āĻĒ⧇ āĻŦāϏ⧇ āĻĨāĻžāĻ•āϤ⧇ āύāĻžāĨ¤ āĻ“āϟāĻž if-āĻāϰ āĻ•āĻžāϜ, āϝ⧇āϟāĻž āĻļ⧇āĻ–āĻžāĻŦ⧇ Module 4āĨ¤ āĻāĻ–āĻžāύ⧇ āĻļ⧁āϧ⧁ āĻāϰ āĻ—āĻĄāĻŧāύāϟāĻž āĻĻāĻŋāϞāĻžāĻŽ, āĻāĻ–āύ āĻĒāĻĄāĻŧ⧇ āϰāĻžāĻ–ā§‹, āφāϰ āϝ⧇āĻŽāύ āφāϛ⧇ āϤ⧇āĻŽāύāχ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋: āĻĒā§āϰāĻĨāĻŽ āϝ⧇ test true āĻšāϝāĻŧ, āϏ⧇āϟāĻžāχ āĻ āĻŋāĻ• āĻ•āϰ⧇ āϕ⧋āύ block āϚāϞāĻŦ⧇āĨ¤

const value = null;
if (value === undefined) {
  console.log("missing");
} else if (value === null) {
  console.log("empty");
} else {
  console.log("value:", value);
}
empty

āϤāĻžāχ === undefined āφāϰ === null āĻšāϞ⧋ āĻĻ⧁āχāϟāĻž āĻšā§āĻŦāĻšā§ test, āφāϰ if āĻĻāĻŋāϝāĻŧ⧇ program āĻ āĻŋāĻ• āĻ•āϰ⧇, āĻ“āϗ⧁āϞ⧋āϰ āωāĻ¤ā§āϤāϰ āύāĻŋāϝāĻŧ⧇ āϕ⧀ āĻ•āϰāĻŦ⧇āĨ¤

āϝ⧇ āύāĻžāĻŽ āĻ•āĻ–āύ⧋ declare āĻ•āϰāĻž āĻšāϝāĻŧāύāĻŋ

āύāĻž āĻĨāĻžāĻ•āĻžāϰ āφāϰāĻ“ āĻāĻ•āϟāĻž āϰāĻ•āĻŽ āφāϛ⧇: āĻāĻŽāύ āύāĻžāĻŽ, āϝ⧇āϟāĻž āϕ⧇āω āĻ•āĻ–āύ⧋ declare āĻ•āϰ⧇āύāĻŋāĨ¤ Lesson 02-āĻ āĻĻ⧇āϖ⧇āĻ›, āĻ“āϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āϗ⧇āϞ⧇ program āĻĨ⧇āĻŽā§‡ āϝāĻžāϝāĻŧāĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ“āϟāĻžāϰ āĻŦā§āϝāĻžāĻĒāĻžāϰ⧇ typeof-āϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰāϞ⧇ āĻĨāĻžāĻŽā§‡ āύāĻžāĨ¤

console.log(typeof discountCode);
console.log(typeof window);
console.log(typeof process);
undefined
undefined
object

discountCode āĻ•āĻ–āύ⧋ declare āĻ•āϰāĻž āĻšāϝāĻŧāύāĻŋ, āφāϰ typeof error throw āύāĻž āĻ•āϰ⧇ āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ "undefined"āĨ¤ typeof āϏāϰāĻŋāϝāĻŧ⧇ āĻĻāĻžāĻ“, āϤāĻžāĻšāϞ⧇ āĻāĻ•āχ āϞāĻžāχāύ program āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻŦ⧇ ReferenceError: discountCode is not defined āĻĻāĻŋāϝāĻŧ⧇āĨ¤

āĻĒāϰ⧇āϰ āĻĻ⧁āχāϟāĻž āϞāĻžāχāύ āĻĻ⧇āĻ–āĻžāϝāĻŧ, āĻāϟāĻž āϕ⧇āύ āϜāϰ⧁āϰāĻŋāĨ¤ window āĻšāϞ⧋ browser-āĻāϰ global object, āφāϰ process āĻšāϞ⧋ Node-āĻāϰāĨ¤ āĻāχ program āϚāϞ⧇āϛ⧇ Node 22-āĻ, āϤāĻžāχ window āύ⧇āχ, āφāϰ process āφāϛ⧇āĨ¤ āϝ⧇ library-āϕ⧇ āĻĻ⧁āχ āϜāĻžāϝāĻŧāĻ—āĻžāϤ⧇āχ āϚāϞāϤ⧇ āĻšāϝāĻŧ, āϏ⧇ āφāϗ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇ āύ⧇āϝāĻŧ typeof windowāĨ¤ āϤāĻžāχ āϝ⧇ āύāĻžāĻŽ āĻšāϝāĻŧāϤ⧋ āύ⧇āχ, āϤāĻžāϰ āĻ–ā§‹āρāϜ āύ⧇āĻ“āϝāĻŧāĻžāϰ āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āύāĻŋāϰāĻžāĻĒāĻĻ āωāĻĒāĻžāϝāĻŧ typeofāĨ¤

Example 1: āĻāĻ• āĻĒā§āϰāĻļā§āύ, āĻāĻ• āωāĻ¤ā§āϤāϰ

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āĻŦā§āϝāĻŦāĻšāĻžāϰ: āĻāĻ•āϟāĻž value āϰāĻžāĻ–ā§‹, āϤāĻžāϰ type āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧋, āĻĻ⧁āχāϟāĻžāχ āĻ›āĻžāĻĒā§‹āĨ¤

const temperature = 36.6;
console.log(temperature, "is a", typeof temperature);
36.6 is a number

36.6-āϕ⧇ quote-āϏāĻš "36.6" āĻ•āϰ⧇ āĻĻāĻžāĻ“, āωāĻ¤ā§āϤāϰ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ stringāĨ¤

Run in Compiler
Example 2: David-āĻāϰ āϰāϏāĻŋāĻĻ, āĻ—ā§‹āĻĄāĻŧāĻž āϖ⧁āρāĻœā§‡ āϏāĻžāϰāĻžāύ⧋

David-āĻāϰ program āύāĻžāĻŽāϟāĻž āφāϗ⧇āĻ­āĻžāϗ⧇ declare āĻ•āϰ⧇āĻ›āĻŋāϞ, āϭ⧇āĻŦ⧇āĻ›āĻŋāϞ āĻĒāϰ⧇ āĻ­āϰāĻŦ⧇āĨ¤ āϏāĻŽāĻžāϧāĻžāύ āĻšāϞ⧋, āύāĻžāĻŽāϟāĻž āϝ⧇āĻ–āĻžāύ⧇ āĻŦāĻžāύāĻžāύ⧋ āĻšāϝāĻŧ āϏ⧇āĻ–āĻžāύ⧇āχ āϤāĻžāϕ⧇ value āĻĻ⧇āĻ“āϝāĻŧāĻž, āφāϰ āϤāĻžāϕ⧇ const āĻ•āϰāĻžāĨ¤

let customerName;
console.log("Before:", typeof customerName);

const fixedName = "Maria";
console.log("Hello,", fixedName);
console.log("After:", typeof fixedName);
Before: undefined
Hello, Maria
After: string

typeof-āĻāϰ āϞāĻžāχāύāϗ⧁āϞ⧋āχ trace: āφāϗ⧇ undefined āĻŽāĻžāύ⧇ āύāĻžāĻŽāϟāĻž declare āĻšāϝāĻŧ⧇āĻ›āĻŋāϞ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•āĻ–āύ⧋ value āĻĒāĻžāϝāĻŧāύāĻŋāĨ¤ const value āĻ›āĻžāĻĄāĻŧāĻž declare āĻ•āϰāĻžāχ āϝāĻžāϝāĻŧ āύāĻž, āϤāĻžāχ āĻāχ āĻ—ā§‹āϟāĻž bug-āϟāĻž āĻ“āϰ āĻŦ⧇āϞāĻžāϝāĻŧ āϘāϟāϤ⧇āχ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

Run in Compiler
Example 3: āĻāĻ•āϟāĻž profile, āϝāĻžāϤ⧇ āϏāĻŦ āϰāĻ•āĻŽā§‡āϰ āĻĢāĻžāρāĻ•āĻž āφāϛ⧇

Zara āϏāĻŦāĻžāϰ āφāϗ⧇ āĻ•āĻŋāύāĻžāϰāĻžāϗ⧁āϞ⧋ test āĻ•āϰ⧇āĨ¤ āĻ“āϰ profile-āĻ āφāϛ⧇ āĻāĻ•āϟāĻž āύāĻžāĻŽ, āύāĻŋāĻœā§‡ āĻŦ⧇āϛ⧇ āύ⧇āĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž null, āφāϰ āĻāĻ•āϟāĻž property, āϝ⧇āϟāĻž āĻ“ āĻ•āĻ–āύ⧋ āϝ⧋āĻ—āχ āĻ•āϰ⧇āύāĻŋāĨ¤

const profile = { name: "Zara", school: null };
console.log("name:", profile.name, typeof profile.name);
console.log("school:", profile.school, profile.school === null);
console.log("city:", profile.city, profile.city === undefined);
name: Zara string
school: null true
city: undefined true

āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ āĻāĻ•āϟāĻž value-āϰ āĻĒāĻžāĻļ⧇ āϤāĻžāϰ āĻ āĻŋāĻ• test-āϟāĻž āĻŦāϏāĻžāϝāĻŧāĨ¤ school āĻšāϞ⧋ null, āĻ•āĻžāϰāĻŖ Zara āĻāĻ–āύ āĻāĻ• āĻ¸ā§āϕ⧁āϞ āϛ⧇āĻĄāĻŧ⧇ āφāϰ⧇āĻ• āĻ¸ā§āϕ⧁āϞ⧇ āϝāĻžāĻ“āϝāĻŧāĻžāϰ āĻŽāĻžāĻāĻ–āĻžāύ⧇; city āĻšāϞ⧋ undefined, āĻ•āĻžāϰāĻŖ āϕ⧇āω āϜāĻŋāĻœā§āĻžā§‡āϏāχ āĻ•āϰ⧇āύāĻŋāĨ¤

Run in Compiler
Example 4: āĻāĻ•āϟāĻž value āϕ⧀, āĻ•āĻĨāĻžāϝāĻŧ āĻŦāϞ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž

Kenji āĻĒā§āϰāϤāĻŋāϟāĻž value-āϰ āϜāĻ¨ā§āϝ āĻāĻŽāύ āĻāĻ•āϟāĻž āϞāĻžāχāύ āϚāĻžāϝāĻŧ, āϝ⧇āϟāĻž āĻŦāϞāĻŦ⧇ āĻ“āϤ⧇ āϕ⧀ āφāϛ⧇, āĻāĻ•āϟāĻž form checker āϝ⧇āĻ­āĻžāĻŦ⧇ āĻŦāϞ⧇āĨ¤ āϏ⧇ āωāĻĒāϰ⧇āϰ if-āĻāϰ āĻ—āĻĄāĻŧāύāϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤

const value = undefined;
if (value === undefined) {
  console.log("missing");
} else if (value === null) {
  console.log("empty");
} else {
  console.log(typeof value);
}
missing

āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύāϟāĻž āĻāϕ⧇ āĻāϕ⧇ null, 42 āφāϰ "hi" āĻ•āϰ⧇ āĻĻāĻžāĻ“, āφāϰ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ run āĻ•āϰ⧋āĨ¤ āĻĻ⧇āĻ–āĻŦ⧇ empty, number āφāϰ stringāĨ¤

Run in Compiler

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇

  • lodash. āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻāχ helper library isString(value)-āĻāϰ āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ āĻāĻŽāύ āĻāĻ•āϟāĻž āϞāĻžāχāύ āĻĻāĻŋāϝāĻŧ⧇, āϝ⧇āϟāĻž āĻļ⧁āϰ⧁ āĻšāϝāĻŧ typeof value == 'string' āĻĻāĻŋāϝāĻŧ⧇āĨ¤ āĻāϰ isNil āĻāĻ•āϏāĻ™ā§āϗ⧇ null āφāϰ undefined āĻĻ⧁āχāϟāĻžāχ test āĻ•āϰ⧇āĨ¤
  • GitHub-āĻāϰ REST API. āĻāĻ•āϟāĻž user profile āĻĢ⧇āϰāϤ āφāϏ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž field āϏāĻšāĨ¤ User āϝ⧇ field āĻĢāĻžāρāĻ•āĻž āϰ⧇āϖ⧇āϛ⧇, āϝ⧇āĻŽāύ bio, āϏ⧇āϟāĻž āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧ⧇ āύāĻž, āφāϏ⧇ null āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āĻāϟāĻžāχ "āĻĻ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āϛ⧇, āφāϰ āĻ•āĻŋāϛ⧁ āύ⧇āχ", data āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻ āĻžāύ⧋ (āĻāϟāĻž āĻĒāĻĄāĻŧāĻž āĻļ⧇āĻ–āĻžāĻŦ⧇ Module 8)āĨ¤
  • Next.js. āĻāϰ code server-āĻāĻ“ āϚāϞāϤ⧇ āĻĒāĻžāϰ⧇, browser-āĻāĻ“, āφāϰ āϕ⧋āĻĨāĻžāϝāĻŧ āϚāϞāϛ⧇ āϏ⧇āϟāĻž āϜāĻžāύāĻžāϰ āϚāϞāϤāĻŋ check āĻšāϞ⧋ typeof window, "āϝ⧇ āύāĻžāĻŽ āĻ•āĻ–āύ⧋ declare āĻ•āϰāĻž āĻšāϝāĻŧāύāĻŋ" āĻ…āĻ‚āĻļ⧇āϰ āϏ⧇āχ check-āϟāĻžāχāĨ¤ Next.js-āĻāϰ documentation āĻŦāϞ⧇, rendering-āĻāϰ logic-āĻāϰ āϭ⧇āϤāϰ⧇ āĻāχ check hydration error āϘāϟāĻžāϝāĻŧ, āϤāĻžāχ āĻ“āϟāĻž āĻŦāϏ⧇ āĻ…āĻ¨ā§āϝ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧāĨ¤

āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇

ā§§. typeof āĻĻāĻŋāϝāĻŧ⧇ null test āĻ•āϰāĻžāĨ¤

const school = null;
console.log(typeof school === "null");

āϕ⧋āύ⧋ message āύ⧇āχ: āĻāϟāĻž āĻ›āĻžāĻĒ⧇ false, āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ, āĻĒā§āϰāϤāĻŋāϟāĻž value-āϰ āϜāĻ¨ā§āϝāĨ¤ typeof āĻ•āĻ–āύ⧋ "null" āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ āύāĻžāĨ¤ āϞ⧇āĻ–ā§‹ school === nullāĨ¤ āϤ⧁āĻŽāĻŋ typeof-āχ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻŦāĻžāĻ•āĻŋ āĻĒā§āϰāϤāĻŋāϟāĻž type-āĻāϰ āĻŦ⧇āϞāĻžāϝāĻŧ āĻ“āϟāĻž āĻ āĻŋāĻ• āωāĻ¤ā§āϤāϰ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤

⧍. undefined-āĻāϰ property āĻĒāĻĄāĻŧāĻžāĨ¤

let user;
console.log(user.name);

TypeError: Cannot read properties of undefined (reading 'name')āĨ¤ user-āĻ null āĻĨāĻžāĻ•āϞ⧇ message-āĻ āĻāϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āϞ⧇āĻ–āĻž āĻĨāĻžāϕ⧇ nullāĨ¤ āύāĻž āĻĨāĻžāĻ•āĻž property āĻĻ⧇āϝāĻŧ undefined, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ–ā§‹āĻĻ undefined-āĻāϰ āĻ•āĻžāϛ⧇ āĻ•āĻŋāϛ⧁ āϚāĻžāχāϞ⧇āχ program āĻĨ⧇āĻŽā§‡ āϝāĻžāϝāĻŧāĨ¤ āĻĒ⧁āϰ⧋ JavaScript-āĻ āĻāϟāĻž āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻĻ⧇āĻ–āĻž error-āϗ⧁āϞ⧋āϰ āĻāĻ•āϟāĻž; āĻāϟāĻž āϠ⧇āĻ•āĻžāύ⧋āϰ ?. operator āĻĻ⧇āĻ–āĻžāĻŦ⧇ Module 8āĨ¤ āϭ⧁āϞāϟāĻž āϤ⧁āĻŽāĻŋ āĻ•āϰāĻŦ⧇, āĻ•āĻžāϰāĻŖ āύāĻžāĻŽāϟāĻž āĻĻ⧇āϖ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ āĻ“āϤ⧇ value āφāϛ⧇: declare āϤ⧋ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇, āĻļ⧁āϧ⧁ āϕ⧋āύ⧋ object āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋāĨ¤

ā§Š. Type-āĻāϰ āύāĻžāĻŽā§‡ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāĨ¤

const price = 450;
console.log(typeof price === "Number");

āϕ⧋āύ⧋ message āύ⧇āχ: falseāĨ¤ typeof āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇, "number", āφāϰ string āϤ⧁āϞāύāĻžāϝāĻŧ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāĻ“ āĻšāĻŋāϏāĻžāĻŦ⧇ āϧāϰāĻž āĻšāϝāĻŧāĨ¤ āϤ⧁āĻŽāĻŋ āĻŦāĻĄāĻŧ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ type-āĻāϰ āύāĻžāĻŽ āĻĻ⧇āĻ–āϤ⧇ āĻŽāĻžāύ⧁āώ⧇āϰ āύāĻžāĻŽā§‡āϰ āĻŽāϤ⧋ āϞāĻžāϗ⧇āĨ¤

ā§Ē. āĻ•āĻ–āύ⧋ value āύāĻž āĻĒāĻžāĻ“āϝāĻŧāĻž āύāĻžāĻŽ āĻĻāĻŋāϝāĻŧ⧇ āĻšāĻŋāϏāĻžāĻŦāĨ¤

let count;
count = count + 1;
console.log(count);

āϕ⧋āύ⧋ message āύ⧇āχ: āĻāϟāĻž āĻ›āĻžāĻĒ⧇ NaNāĨ¤ undefined + 1-āĻāϰ āϕ⧋āύ⧋ āĻ āĻŋāĻ•āĻ āĻžāĻ• āωāĻ¤ā§āϤāϰ āύ⧇āχ, āφāϰ lesson 03 āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āϛ⧇, NaN āϤāĻžāϰāĻĒāϰ āĻ›āĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻĒāĻĄāĻŧ⧇āĨ¤ āĻ—ā§‹āύāĻž āĻļ⧁āϰ⧁ āĻ•āϰ⧋ āĻāĻ•āϟāĻž value āĻĻāĻŋāϝāĻŧ⧇: let count = 0;āĨ¤ = 0 āϤ⧁āĻŽāĻŋ āϭ⧁āϞāĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻ—ā§‹āύāĻž āϝ⧇ āĻļā§‚āĻ¨ā§āϝ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāϝāĻŧ, āϏ⧇āϟāĻž āϤ⧋āĻŽāĻžāϰ āĻ•āĻžāϛ⧇ āĻĒāϰāĻŋāĻˇā§āĻ•āĻžāϰ, engine-āĻāϰ āĻ•āĻžāϛ⧇ āύāĻžāĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

Bob āĻāχ āϞāĻžāχāύāϟāĻž āĻĒāĻĄāĻŧ⧇ āĻŦāϞ⧇, āĻāϟāĻž āĻ›āĻžāĻĒāĻŦ⧇ numberāĨ¤ Maria āĻŦāϞ⧇, āĻ›āĻžāĻĒāĻŦ⧇ "number", quote-āϏāĻšāĨ¤ āĻĻ⧁āχāϜāύ⧇āχ āϭ⧁āϞāĨ¤

console.log(typeof typeof 1);

āĻāϟāĻž āϕ⧀ āĻ›āĻžāĻĒ⧇? āφāϰ 1-āĻāϰ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āϝ⧇ value-āχ āĻŦāϏāĻžāĻ“, āωāĻ¤ā§āϤāϰ āϕ⧇āύ āĻ•āĻ–āύ⧋ āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž?

āĻĄāĻžāύ āĻĻāĻŋāĻ• āĻĨ⧇āϕ⧇ āϧāϰ⧋āĨ¤ āĻĒā§āϰāĻĨāĻŽ typeof āϕ⧋āύ āϰāĻ•āĻŽā§‡āϰ value āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧ? Syntax card-āϟāĻž āφāĻŦāĻžāϰ āĻĒāĻĄāĻŧā§‹āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

Amara-āϰ form checker āĻĒāĻžāρāϚāϟāĻž value āĻĻ⧇āϖ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āϜāĻ¨ā§āϝ āĻ›āĻžāĻĒā§‹: undefined āĻšāϞ⧇ missing, null āĻšāϞ⧇ empty, āφāϰ āĻŦāĻžāĻ•āĻŋ āϏāĻŦ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ value-āϟāĻžāχāĨ¤

Output. āĻšā§āĻŦāĻšā§ āĻāχ āĻĒāĻžāρāϚ āϞāĻžāχāύāĨ¤

missing
empty
0
false
Zara
let nickname;
const school = null;
const siblings = 0;
const subscribed = false;
const name = "Zara";

// Use the if shape from "Checking for each kind of nothing", once per value.
// 0 and false are real values, not nothing: they print as themselves.

Grade āĻšāϝāĻŧ āύāĻžāĨ¤ āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋, 0 āφāϰ false "āĻ•āĻŋāϛ⧁ āύ⧇āχ" āύāĻžāĨ¤ Module 2 āĻāĻŽāύ āĻāĻ•āϟāĻž operator āĻĻ⧇āĻ–āĻžāĻŦ⧇, āϝ⧇āϟāĻž āĻāĻĻ⧇āϰ āϏāĻ™ā§āϗ⧇ āĻāĻŽāύ āφāϚāϰāĻŖ āĻ•āϰ⧇, āϝ⧇āύ āĻāϰāĻž āĻ•āĻŋāϛ⧁āχ āύāĻžāĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āĻŽāĻžāĻāĻžāϰāĻŋ

Form-āĻāϰ field āϏāĻŦ āϏāĻŽāϝāĻŧ āφāϏ⧇ āϞ⧇āĻ–āĻž āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ Alice āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧ, āϤāĻžāϤ⧇ āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž āφāϛ⧇ āĻ•āĻŋ āύāĻžāĨ¤ Input āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻž āĻļāĻŦā§āĻĻ āĻĒāĻĄāĻŧā§‹, Number() āĻĻāĻŋāϝāĻŧ⧇ āϏ⧇āϟāĻžāϕ⧇ number āĻŦāĻžāύāĻžāύ⧋āϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰ⧋, āφāϰ āĻ•āĻžāϜ āĻšāϞ⧇ āĻ›āĻžāĻĒā§‹ number, NaN āĻāϞ⧇ stringāĨ¤

Input. āĻāĻ•āϟāĻž āĻļāĻŦā§āĻĻ, āϕ⧋āύ⧋ space āĻ›āĻžāĻĄāĻŧāĻžāĨ¤

Output. number āĻŦāĻž stringāĨ¤

Sample. Input 42 āĻĻāĻŋāϞ⧇ number; input Zara āĻĻāĻŋāϞ⧇ stringāĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out
const word = next();
const asNumber = Number(word);
// Number.isNaN(asNumber) is true when the word did not convert.
// Push "string" in that case, and typeof asNumber otherwise.

console.log(out.join("\n"));

āĻĒā§āϰāĻĨāĻŽ āĻ›āϝāĻŧāϟāĻž āϞāĻžāχāύ āϤ⧋āĻŽāĻžāϰ āĻšāϝāĻŧ⧇ input āĻĒāĻĄāĻŧ⧇ āĻĻ⧇āϝāĻŧ; āĻĒā§āϰāϤāĻŋāϟāĻž āϞāĻžāχāύ āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ āĻŦāϞāĻŦ⧇ lesson 05āĨ¤ Input-āϟāĻž Playground-āĻāϰ stdin box-āĻ āϟāĻžāχāĻĒ āĻ•āϰ⧋āĨ¤ āĻāϟāĻž āύāĻŋāĻœā§‡ āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ grade āĻšāϝāĻŧ āύāĻž: grade āĻšāĻ“āϝāĻŧāĻž version-āϟāĻž, type-of-each, true, false, null āφāϰ undefined-āϕ⧇āĻ“ āϤāĻžāĻĻ⧇āϰ āφāϏāϞ value-āϤ⧇ āĻŦāĻĻāϞāĻžāϝāĻŧāĨ¤

Run in Compiler

āϏāϚāϰāĻžāϚāϰ āϝ⧇ āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋ āφāϏ⧇

  • typeof null āϝāĻĻāĻŋ bug-āχ āĻšāϝāĻŧ, āϤāĻžāĻšāϞ⧇ āϏāĻžāϰāĻžāύ⧋ āĻšāϝāĻŧ āύāĻž āϕ⧇āύ?

    āĻĒ⧁āϰ⧋āύ⧋ page-āϗ⧁āϞ⧋ typeof x === "object" check āĻ•āϰ⧇, āφāϰ āφāĻļāĻž āĻ•āϰ⧇ null-āĻ“ āĻĒāĻžāϰ āĻĒ⧇āϝāĻŧ⧇ āϝāĻžāĻŦ⧇āĨ¤ āωāĻ¤ā§āϤāϰ āĻŦāĻĻāϞāĻžāϞ⧇ āĻ“āϗ⧁āϞ⧋ āϕ⧋āύ⧋ āϏāϤāĻ°ā§āĻ•āϤāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ āϭ⧇āϙ⧇ āϝāĻžāĻŦ⧇āĨ¤ Web āĻĒā§āϰāĻžāϝāĻŧ āϏāĻŦ āϏāĻŽāϝāĻŧ āϤāĻžāϰ āĻĒ⧁āϰ⧋āύ⧋ āφāϚāϰāĻŖ āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧ, āφāϰ āĻāϟāĻž āϤāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦāĻŋāĻ–ā§āϝāĻžāϤ āωāĻĻāĻžāĻšāϰāĻŖāĨ¤

  • āφāĻŽāĻŋ āĻ•āĻŋ āĻ•āĻ–āύ⧋ āύāĻŋāĻœā§‡ undefined āϞāĻŋāĻ–āĻŦ, āϝ⧇āĻŽāύ let x = undefined;?

    āϚāϞāĻŦ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϤāĻžāϤ⧇ āĻĻ⧁āχāϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧇ āĻāĻ•āϟāĻž āĻ•āĻžāĻœā§‡āϰ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āφāϛ⧇, āϏ⧇āϟāĻž āĻ˜ā§‹āϞāĻž āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ "āύ⧇āχ" āĻŦā§‹āĻāĻžāϤ⧇ āϚāĻžāχāϞ⧇ null āϞ⧇āĻ–ā§‹, āϝāĻžāϤ⧇ undefined āĻŽāĻžāύ⧇ āϏāĻŦ āϏāĻŽāϝāĻŧ āĻšāϝāĻŧ "āĻ•āĻ–āύ⧋ value āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāύāĻŋ"āĨ¤

  • typeof āωāĻ¤ā§āϤāϰ āĻĻ⧇āϝāĻŧ string-āĻ, āĻ…āĻ¨ā§āϝ āĻ•āĻŋāϛ⧁āϤ⧇ āύāĻž āϕ⧇āύ?

    String āĻ›āĻžāĻĒāĻž āϝāĻžāϝāĻŧ, === āĻĻāĻŋāϝāĻŧ⧇ āϤ⧁āϞāύāĻž āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϰ⧇āϖ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āϝāĻžāϝāĻŧāĨ¤ āĻāĻ•āϟāĻž type-āĻāϰ āύāĻžāĻŽ āύāĻŋāϝāĻŧ⧇ program-āĻāϰ āĻāϰ āĻŦ⧇āĻļāĻŋ āĻ•āĻŋāϛ⧁ āĻ•āϰāĻžāϰ āĻĻāϰāĻ•āĻžāϰāχ āύ⧇āχāĨ¤

  • āφāĻŽāĻŋ āϤ⧋ typeof(x) āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰāĻŋ, āϤāĻžāĻšāϞ⧇ typeof āĻ•āĻŋ āĻāĻ•āϟāĻž function?

    āύāĻž, āĻāϟāĻž operatorāĨ¤ typeof(x) āĻ•āĻžāϜ āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ bracket āĻļ⧁āϧ⧁ x-āϕ⧇ āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ āϘāĻŋāϰ⧇ āϰāĻžāϖ⧇, āϝ⧇āĻ­āĻžāĻŦ⧇ (2 + 3)-āϕ⧇ āϰāĻžāϖ⧇āĨ¤ āĻāχ track āϞ⧇āϖ⧇ typeof xāĨ¤

āĻŽā§‚āϞ āĻ•āĻĨāĻž

  • typeof value type-āĻāϰ āύāĻžāĻŽ āĻĻ⧇āϝāĻŧ string āĻšāĻŋāϏ⧇āĻŦ⧇, āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰ⧇āĨ¤
  • āĻĻ⧁āχāϟāĻž āωāĻ¤ā§āϤāϰ āϚāĻŽāϕ⧇ āĻĻ⧇āϝāĻŧ: typeof null āĻšāϞ⧋ "object", 1995 āĻĨ⧇āϕ⧇ āϰ⧇āϖ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻāĻ•āϟāĻž bug, āφāϰ function āĻĻ⧇āϝāĻŧ "function"āĨ¤
  • undefined āφāϏ⧇ value āĻ›āĻžāĻĄāĻŧāĻž āύāĻžāĻŽ, āĻŦāĻžāĻĻ āĻĒāĻĄāĻŧāĻž argument āĻŦāĻž āύāĻž āĻĨāĻžāĻ•āĻž property āĻĨ⧇āϕ⧇āĨ¤
  • null āĻ•āĻ–āύ⧋ engine-āĻāϰ default āύāĻž; āϕ⧇āω āĻāĻ•āϜāύ āĻ“āϟāĻž āĻŦāϏāĻžāϝāĻŧ, āφāϰ āĻāϰ āĻŽāĻžāύ⧇ "āύ⧇āχ, āχāĻšā§āĻ›āĻž āĻ•āϰ⧇āχ"āĨ¤
  • āĻāĻĻ⧇āϰ test āĻ•āϰ⧋ === undefined āφāϰ === null āĻĻāĻŋāϝāĻŧ⧇; āωāĻ¤ā§āϤāϰ āύāĻŋāϝāĻŧ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ ifāĨ¤
  • Declare āύāĻž āĻšāĻ“āϝāĻŧāĻž āύāĻžāĻŽā§‡āϰ typeof āĻĻ⧇āϝāĻŧ "undefined"; āύāĻžāĻŽāϟāĻž āϏāϰāĻžāϏāϰāĻŋ āĻĒāĻĄāĻŧāϞ⧇ āφāϏ⧇ āĻāĻ•āϟāĻž ReferenceErrorāĨ¤

āĻāϰāĻĒāϰ lesson 05 input āĻĒāĻĄāĻŧāĻžāϰ āϏ⧇āχ āĻ›āϝāĻŧāϟāĻž āϞāĻžāχāύ āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ āĻŦāϞāĻŦ⧇, āϝāĻžāϤ⧇ āĻāχ track-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž problem āĻļ⧁āϰ⧁ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤

lesson ā§Ē āĻļ⧇āώ

āĻļ⧇āώ āĻšāϞ⧇ āϚāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ…āĻ—ā§āϰāĻ—āϤāĻŋ āφāĻĒāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āĻĒāϰ⧇āϰāϟāĻž: input āĻĒāĻĄāĻŧāĻž: āϝ⧇ starter āĻĒā§āϰāϤāĻŋāϟāĻž problem-āĻ āĻĨāĻžāϕ⧇, āĻāĻ• āϞāĻžāχāύ āĻ•āϰ⧇

typeof, undefined āφāϰ null: āĻāĻ•āϟāĻž value-āϕ⧇ āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰāĻž āϏ⧇ āϕ⧀ | Learn JavaScript | Progsity