Javascript の奇妙な点をご存知ですか?

typeof Function.prototype === 'function'; // true

関数 People() {}
typeof People.prototype === 'object'; // true

// わかりました 
const noop = Function.prototype;
// わかりました
定数 noop = () => {};

定数x = NaN;
x !== x // 真

isNaN('abc'); // 真
Number.isNaN('abc') // false

// 関数 People() を返さない {}
const people = new People(); // 人 {}

// 数値を返す function People() {
 1 を返します。
}
const people = new People(); // 人 {}

// 新しいオブジェクトを返す function Animal() {
 戻る {
  こんにちは世界'、
 };
}
const animal = new Animal(); // { hello: 'world' }

関数fn1() {
 コンソールログ(1);
}

関数fn2() {
 コンソールログ(2);
}

fn1.call.call(fn2); // 2

関数 People() {}

const lili = new People(); // People {}
const lucy = new lili.constructor(); // 人 {}

コンソールログ(0, Date.now());

タイムアウトを設定する(() => {
 コンソールログ(1, Date.now());
 タイムアウトを設定する(() => {
  コンソールログ(2, Date.now());
  タイムアウトを設定する(() => {
   コンソールログ(3, Date.now());
   タイムアウトを設定する(() => {
    コンソールログ(4, Date.now());
    タイムアウトを設定する(() => {
     コンソールログ(5, Date.now());
     タイムアウトを設定する(() => {
      コンソールログ(6, Date.now());
     });
    });
   });
  });
 });
});

var x = 10;

関数 fn(x = 2, y = 関数 () { 戻り値 x + 1 }) {
 var x = 5;
 y() を返します。
}

fn(); // 3

定数 c = 関数 CC() {
 CC = 123;
 CC を返します。
};

c(); // 関数

// 非厳密関数 fn1() {
 これを返します。
}
fn1(); // ウィンドウ

// 厳密な関数 fn2() {
 '厳密な使用';
 これを返します。
}
fn2(); // 未定義

var x = 1.23 | 0; // 1

定数arr = [1, 2, 3];

// 存在する、> -1 と同等
（〜arr.indexOf（1））の場合{

}

// 存在しない、=== -1 と同等
!~arr.indexOf(1);

クラスHello {
 _name = 'ルーシー';
 
 取得名() {
  this._name を返します。
 }
 
 // 静的ゲッター
 IDを取得する() {
  1 を返します。
 }
}

定数 hel = 新しい Hello();

hel.name; // 未定義
hel.getName(); // ルーシー

// 動的ゲッター
Hello.prototype.__defineGetter__('name', function() {
 this._name を返します。
});

Hello.prototype.__defineSetter__('name', 関数(値) {
 this._name = 値;
});

hel.name; // ルーシー
hel.getName(); // ルーシー

hel.name = 'ジミ';
hel.name; // ジミ
hel.getName(); // ジミ

0.3 - 0.2 !== 0.1 // 真

0.3 - 0.2 - 0.1 <= Number.EPSILON // 真

関数Super() {
 1 を返します。
}

関数Child() {
 // プロパティ継承 Super.call(this);
 2 を 0 にします。
}
// プロトタイプ継承 Child.prototype = new Super();

定数child = 新しいChild();
子.a; // 1

const extends = (Child, Super) => {
 定数fn = 関数（）{};
 
 fn.prototype = スーパープロトタイプ;
 Child.prototype = 新しい fn();
 Child.prototype.constructor = Child;
};

定数オブジェクト = {
 a: {
  1 です
 },
 2: 2 です
};

定数 a: { b }, a } = obj;

関数 CustomFn() {}

const isCrashed = typeof CustomFn.name === 'string' && CustomFn.name === 'CustomFn';

{} === {} // 偽

// 暗黙的な変換 toString()
{} >= {} // 真

関数 People() {}
関数 Man() {}
Man.prototype = 新しい People();
Man.prototype.constructor = Man;

man を新しい Man() に追加します。
man instanceof People; // true

//People のプロトタイプを置き換えます People.prototype = {};
man instanceof People; // false

Object.prototype.__proto__ === null; // true

parseInt(0.00000000454); // 4
parseInt(10.23); // 10

1 + ヌル // 1
1 + 未定義 // NaN

数値(null) // 0
数値(未定義) // NaN

関数テスト(a, b, c) {
 console.log(a, b, c); // 2, 3, 未定義
 
 引数[0] = 100;
 引数[1] = 200;
 引数[2] = 300;
 
 console.log(a, b, c); // 100、200、未定義
}
テスト(2, 3);

void 0 === 未定義 // 真
void 1 === 未定義 // 真
void {} === 未定義 // true
void 'hello' === 未定義 // true
void void 0 === 未定義 // true

関数fn1() {
 コンソールログ('fn1');
 1 を返します。
}

関数fn2() {
 コンソールログ('fn2');
 2を返します。
}

関数 getData() {
 試す {
  新しいエラーをスローします('');
 } キャッチ (e) {
  fn1() を返します。
 ついに
  fn2() を返します。
 }
}

コンソールにログ出力します。

// 印刷順序: 'fn1'、'fn2'、2

定数x = {
 値: 0,
 文字列を渡す
  ++this.value を返します。
 }
}

x == 1 && x == 2 && x == 3; // 真

var タイムアウト = setTimeout(() => console.log(1), 1000);
var 間隔 = setInterval(() => console.log(2), 800);

クリアインターバル(タイムアウト);
clearTimeout(間隔);

タイムアウトを設定する(() => {
 コンソールログ(1);
}, 0);

新しいPromise((resolve) => {
 コンソールログ(2);
 解決する（）;
}).then(() => console.log(3));

関数callMe() {
 コンソールログ(4);
}

(非同期() => {
 callMe() を待機します。
 コンソールログ(5);
})();

typeof null === 'object'; // true
Object.prototype.toString.call(null); // [オブジェクト Null]
null インスタンスオブオブジェクト; // false

'abc'.substr(1);
（１２３）固定（２）

定数データ = 'abc';
データ.x = 'y';
console.log(data.x); // 未定義

データ.__proto__.x = 'z';
console.log(data.x); // 'z'

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // 真

// 2 ** 53 === 2 ** 53 + 1 と同等です。// true

関数テスト(a, b = 1) {
 // エイリアス同期、非厳密モードでは同期されることが期待されます arguments[0] = 20;
 コンソールログ(a); // 2
}
// 関数パラメータの数を確認します。期待値は 2 です。
console.log(テストの長さ); // 1

テスト(123);

1 | 0 // 1
1.234 | 0 // 1
1.234 | 0.6 // 1

1 & 1 // 1
1.23 & 1.456 // 1

~1 // -2
~1.234 // -2

場所 = 'http://baidu.com';

関数テスト() {
 console.log(new.target === Test); // true
}

新しいテスト();

1/+0 === 無限大
1/-0 === -無限大