JavaScriptの型強制は何ですか?

JavaScriptが他のプログラミング言語のように偽に見えると言うのは正しくありません.C +のような言語とは異なります/Java/C経線、JavaScriptはそれらの言語のようなものです.それは別の概念、別の考え方、別のパラダイムです.JavaScriptを学んだり、JavaScriptを使用している多くのプログラマがその要素のいくつかを見つける間、彼らはより高度な機能に奇妙なまたは奇妙な学習や奇妙に掘る.あなたは本当にそれを理解するとき、JavaScriptがどのように動作し、どのようにそれがJavaScriptは、一見強力で美しいプログラミング言語であることを発見する方法を動作するかを見つけることになるでしょう.これはまた、最も人気のあるプログラミング言語の一つである理由です.
JavaScriptコードを正しく書くことができるように、JavaScriptがフードの下でどのように機能しているかを理解する必要があります深い高度なJavaScriptコード.我々は、ちょうど基礎を越えています.だから、このポストの間に瞬間に見えるかもしれませんが、「ああ、あなたは本当にそれを知っている必要はありません!」あなたは、我々は、基本的な基礎知識は、あなたのためのパスを明るくする予定ですので、非常に迅速に、彼らは本当にどのように実際に表示されます.
JavaScriptの学習にDEVSを与えるのは奇妙な部分を理解している.私たちが今日話しているような概念の一つはJavaScriptの型強制です.JavaScript言語を使用した開発中には、以下のようなことに遭遇しているはずです.

console.log(5 + '5'); // '55'
console.log(5 - '5'); // 0

console.log('2' * 2); // 4
console.log('2' / 2); // 1
console.log('2' - 2); // 0
console.log('2' + 2); // '22' 😳huh??..
console.log('' + 2); // '2'

強制型:
Type強制は、あるデータ型から別のデータ型への値の自動または暗黙の変換です.Type conversion のいずれかのデータ型から別のキー差で値を変換するので、型強制型に似ています.型強制は暗黙のうちに明示的であるか明示的であるかもしれません.
簡単に言えば、我々は開発者として明示的に実行しないtype coercion . これは、JavaScriptエンジン内部で行われます.

型強制の原因は何ですか?
まず、私は間違っていない場合は、任意の(コンパイルされた)言語で別の型の2つのオペランドに対して数学的操作を行うことはできません.コンパイルされた言語では、コンパイラ自身がコンパイル中にエラーをスローします.

// In any compiled language like C#, this is not possible

var operand1 = 2; // int
var operand2 = '5'; // char
var result = operand1 + operand2; // compilation error

でも、これはJavaScriptです.それはダイナミックで、すべてがここで可能です😛. JavaScriptでは、同じ型の2つの変数に対していくつかの数学演算を実行するとき、結果は他のどの言語にも似ています.しかし、オペランドが異なったタイプのとき、JavaScriptは内部的に同じタイプのオペランドを作ることによってさえ物事をしようとします.これはオペランドのどちらかを第2オペランドの型にマッチさせることによって行われる.
上の例を考える.

// number 5 is coerced to string '5'
console.log(5 + '5'); //'55'

// string 5 is coerced to number 5
console.log(5 - '5'); //0

上の例では、JavaScriptはnumber to string 両方のオペランド文字列型を作成し、結果として'5' + '5' => '55' . 同様に、2番目の例では、JavaScriptはオペランドのいずれかを強制し、もう一方の型にマッチします.でも今回は'5' が強制される5 評価5 - 5 => 0 .
JavaScriptは弱いタイプの言語であるため、値は異なる型の間で自動的に、またはむしろ暗黙のうちに変換されます.演算子を異なる型の値に適用すると、通常発生します.JavaScriptタイプは、2つのカテゴリーに広く分類されることができます

Primitive Types :
( number , string , boolean , null , undefined , symbol )

複合/構造型:
(オブジェクト、配列、マップ、セット、日付など).基本的にほとんどすべてnew キーワード

変換の種類
任意の型にかかわらず、基本的な構造体であれば型強制を実行すると、オペランド型をこれらの型のいずれかに変換します.

結ぶ

数える

boolean

プリミティブとオブジェクトの変換ロジックは異なりますが、両方のプリミティブとオブジェクトはこれらの3つの方法でのみ変換できます.

Primitive to String coercion:
2つのオペランドをbinary(+) 演算子の場合、JavaScriptエンジンはnumber 種類

console.log(3 + 2); // 5
console.log(20 + 10); // 30

しかし、オペランドのどちらかがAであるときstring 「JavaScript」と入力し、その両方を文字列に変換します.したがって、結果は2文字列の連結です.オペランドの順序は重要ではない.

// number,string
console.log(5 + 'hi'); // '5hi'
console.log('5' + 5); // '55'

// boolean, string
console.log('hi' + false); // 'hifalse'
console.log('12' + true); // '12true';

// number, boolean, string
console.log(1 + 'two' + false); // '1twofalse'
console.log(2 + true + '3'); // '2true3'
console.log('Three' + 4 + false); // 'Three4false'

// null, string
console.log(null + '123'); // 'null123'

// undefined, string
console.log('123' + undefined); // '123undefined'

オペランドが数値でない場合、あるいはその両方が文字列でなくても、binary(+) 演算子

console.log(null + undefined); //NaN

我々が加える試みnull and undefined , JavaScriptエンジンは値を整数に変換し、NaNを返します.

整数型強制数:
原始的な値が強制される複数のシナリオがありますnumber 種類どんな原始もnumber 次の演算子が含まれている型

比較演算子'>','<','>=','<=' )

単項演算子'+','-' )

算術演算子'+','-','*','/','%' )つのオペランドが文字列であるときに

ビット演算子('|','&','^','~' )

緩やかな等値演算子'==' )両方の引数が既に同じプリミティブである場合を除きます

比較演算子

7 <= '3' // false
'5' > 4 // true

// true becomes 1
true > '1' 
1 > 1 // false

// false becomes 0
false < 1 // true

// string 'true' becomes NaN
'true' > 1
NaN > 1 // false

// null becomes 0
null < 5 // true

// undefined becomes NaN
undefined > 10 
NaN > 10 // false

単項演算子

+2
// 2

+"123"
// 123

+true
// 1

+null
// 0

+undefined
// NaN

3算数演算子

'33' - 10
33 - 10 
=> 23

'9' / 3
9 / 3 
=> 3

// false becomes 0
5 / false
5 / 0 
=> Infinity

5 % '3'
5 % 3 
=> 2

// true becomes 1
'true' * 10
1 * 10 
=> 10

// undefined becomes NaN
1 - undefined
1 - NaN 
=> NaN

ビット演算子

true & 0 => 0
true & 1 => 1
true | 0 => 1
true | 1 => 1
true ^ 0 => 1
true ^ 1 => 0

ゆるい等級演算子

/*In JS, == operator is very common to compare values. It compares the values based on their values ignoring their types*/
54 == '54'
54 == 54
//true

true == '1'
1 == 1
//true

false == '0'
0 == 0
//true

/* complex cases*/
//null can only be coerced to null and undefined
null == 0
=> false

// 'true' becomes NaN
true == 'true'
=> false

boolean型の強制的強制
プリミティブは使用時にbooleanに強制されるlogical 演算子'&&', '||', '!' . ここで覚えておくべき最も重要な点は、論理演算子が内部的にブール値変換を行うにもかかわらず、実際にはbooleanでない場合でも、元のオペランドの値を返すことです.最後の評価オペランドは各式から返されます.

!(NOT)
!0 => ! (false) // true
!1 => ! (true) // false

&&(AND)
true && '20'
true && true
=> '20'

0 && false
false && false
=> 0

45 && 'hi'
true && true
=> 'hi'

||(OR)
null || 'hello'
false || true
=> 'hello'

null || undefined
false || false
=> undefined

ここでのもう一つの興味深いことは、プリミティブ型強制型Booleanが周囲のコンテクストによって引き起こされることもあります.そこでは、型/値はif(value) 文.Truthy & Falsy値はBoolean型強制の最良の例です.あなたが彼らが何であるかについて、わからないならば、あなたは彼らについてここで速い読むことができます

// undefined evaluates to false
if(undefined){
   console.log('truthy');
}
else{
   console.log('falsy'); // falsy
}

特別なケース

ナンは何にも匹敵しない

console.log(NaN == NaN); // false

側注:
今までナンはなぜそれ自体を含む何かに匹敵しないのだろうか?
さて、NaNの2種類があります.Quiet NaN とはSignalling NaN (例外をスローします).しかし、どちらもNaN値であり、それらのビットは内部表現において異なるので、SANE NaNとシグナルナンとを比較することができます.したがって、JavaScriptは、それ自体を含む何かとNaNを比較することを拒否します.
V 8エンジン内部関数JequalTyperを見てみましょう.2番目のif文は、==のどちらかの側がNaNの場合、まっすぐにfalseを返します.

Type Typer::Visitor::JSEqualTyper(Type lhs, Type rhs, Typer* t) {
  if (lhs.IsNone() || rhs.IsNone()) return Type::None();
  if (lhs.Is(Type::NaN()) || rhs.Is(Type::NaN())) return t->singleton_false_;
  if (lhs.Is(Type::NullOrUndefined()) && rhs.Is(Type::NullOrUndefined())) {
    return t->singleton_true_;
  }
  if (lhs.Is(Type::Number()) && rhs.Is(Type::Number()) &&
      (lhs.Max() < rhs.Min() || lhs.Min() > rhs.Max())) {
    return t->singleton_false_;
  }
  if (lhs.IsSingleton() && rhs.Is(lhs)) {
    // Types are equal and are inhabited only by a single semantic value,
    // which is not NaN due to the earlier check.
    DCHECK(lhs.Is(rhs));
    return t->singleton_true_;
  }
  return Type::Boolean();
}

適用時== to null or undefined , 数値変換は起こりません.null に等しいnull or undefined , そして、他の何にも匹敵しません.

null == 0               // false, null is not converted to 0
null == null            // true
undefined == undefined  // true
null == undefined       // true

これはNULLと未定義の両方がJavaScriptのBooleanでfalseとして評価されるためです.したがって、値を暗黙のうちにboolean値に変換します.

Boolean(null)       // false
Boolean(undefined)  // false

ヒント:
オペランドを特定の型に変換するという決定はJavaScriptエンジンで完全に行われるので、型強制は時々混乱することがあります.現実世界のアプリケーションでは、これは怖いことができます.暗黙型型強制をトリガーしない演算子は=== , これは' strict quality operator 'と呼ばれます.したがって、常に'==演算子を使用します.この記事が役に立ちましたように.あなたが人々に質問があるならば知らせてください.ハッピーラーニング😊😊...