from electron 2 web

インターネットのリソースを無駄遣いして検索におけるUXを下げてごめんなさい

圧倒的文章力のNASAでゴミみたいなチラ裏のようなメモを量産してしまい全ての"Web開発者"にごめんなさい

ES6 In Depthを翻訳した。

公開記事:

dev.mozilla.jp

 

黄色は訳すのに時間がかかった文、紫は訳がおかしいかもしれない文。紫であまりにも変なものは翻訳記事では直してある。

原文:

ES6 In Depth Articles ★ Mozilla Hacks – the Web developer blog

ES6 In DepthECMAScript標準, ES6でjavascriptプログラミング言語に加えられた機能のシリーズです。
Arrowsは初期からJavascriptの一部とされて進められてきました。最初のJavaScriptチュートリアルは"インラインスクリプトをHTMLコメントで囲め"と助言していました。これはjavascriptをサポートしていないブラウザが誤ってjsのコードをテキストとして表示されるのを防ぐためです。あなたはこんなコードを書いたと思います。
Arrows have been part of JavaScript from the very beginning. The first JavaScript tutorials/ advised wrapping inline scripts/ in HTML comments. This would prevent browsers that didn’t support JS from erroneously displaying your JS code as text. You would write something like this:
<code>&lt;script language="javascript"&gt;
&lt;!--
  document.bgColor = "brown";  // red
// --&gt;
&lt;/script&gt;
</code>

古いブラウザには2つのサポートしていないタグとコメントに見えます。新しいブラウザのみjsコードと解釈します。

Old browsers would see two unsupported tags and a comment; only new browsers would see JS code.

この妙なハックのためには、あなたのブラウザのJavascriptエンジンで<!--という文字列を一行コメントとして扱える必要があります。ジョークじゃないです。これは当初から今日におけるまで言語の一部として寄り添っています。そして、インライン<script>だけではありません、JSのコードのどこでも動きます。さらにNode.jsでさえも動きます。

To support this odd hack, the JavaScript engine in your browser treats the characters <!-- as the start of a one-line comment. No joke. This has really been part of the language all along, and it works to this day, not just at the top of an inline <script> but everywhere in JS code. It even works in Node.

たまたまこのスタイルのコメントは初めてES6で標準化されました。しかしこれは今日話す内容のarrowではありません。

As it happens, this style of comment is standardized for the first time in ES6. But this isn’t the arrow we’re here to talk about.

arrow sequence -->もまた一行コメントとして表示(解釈)されます。奇妙なことにHTML文字列では-->の"前"がコメントで、JSでは行の残り、-->"後"がコメントです。

The arrow sequence --> also denotes a one-line comment. Weirdly, while in HTML characters before the --> are part of the comment, in JS the rest of the line after the --> is a comment.

これは奇妙です。このarrowは行の開始に現れた時のみコメントとして適用されます。これは他の文脈では-->はJSの演算子、"goes to"演算子として働きます!

It gets stranger. This arrow indicates a comment only when it appears at the start of a line. That’s because in other contexts, --> is an operator in JS, the “goes to” operator!

<code>function countdown(n) {
  while (n --&gt; 0)  // "n goes to zero"
    alert(n);
  blastoff();
}
</code>
このコードは本当に動きます
ループはnが0になるまで回ります。これはES6標準ではありません、しかし

This code really works. The loop runs until n gets to 0. This too is not a new feature in ES6,

少しの間違いとともに複数のおなじみの機能に投げ込まれています。あなたはこれがわかりますか?

but a combination of familiar features, with a little misdirection thrown in.

あなたはこれがわかりますか?普通、パズルの答えはStack Overflowで見つかります。

Can you figure out what’s going on here? As usual, the answer to the puzzle can be found on Stack Overflow.

もちろんここにはイコール大なり、<=演算子もあります。多分あなたはJSコードのなかで画像のような矢印をもっと見つけることができます、しかし立ち止まって矢印が欠落していることを観察してみましょう。

Of course there is also the less-than-or-equal-to operator, <=. Perhaps you can find more arrows in your JS code, Hidden Pictures style, but let’s stop here and observe that an arrow is missing.

<!-- single-line comment
--> “goes to” operator
<= less than or equal to
=> ???

=>では何が起こるのでしょうか?今日、その謎を解決していきましょう。

What happened to =>? Today, we find out.

最初に、functionについて少し話しましょう。

First, let’s talk a bit about functions.

 

Function expressions are everywhere

function表現はどこでも

Javascriptの楽しい特徴として、あなたが関数を必要とした時、いつでも動いているコードの中でfunctionとタイプするだけでいいことです。

A fun feature of JavaScript is that any time you need a function, you can just type that function right in the middle of running code.

例としてあなたは、ブラウザにユーザーが特定のボタンをクリックした時、何をしたいか伝えたいとします。こんなコードを書きますよね?

For example, suppose you are trying to tell the browser what to do when the user clicks on a particular button. You start typing:

<code>$("#confetti-btn").click(
</code>

jQuery’s .click() は引数を一つ取ります:functionです。あなたはここにfunctionとタイプするだけで良いのです。

jQuery’s .click() method takes one argument: a function. No problem. You can just type in a function right here:

<code>$("#confetti-btn").click(function (event) {
  playTrumpet();
  fireConfettiCannon();
});
</code>

このようなコードを書くことは私達にとってとても自然なことです。なのでJavascriptがこの種類のプログラミングをはやらせる前は、多くの言語はこの機能を持っていませんでした。もちろんLispはfunction表現を持っていますが、それはラムダ式と呼ばれるものです。1958年のことです。しかしC++やPython,C#やJavaはこの機能を持っていませんでした。

Writing code like this comes quite naturally to us now. So it’s strange to recall that before JavaScript popularized this kind of programming, many languages did not have this feature. Of course Lisp had function expressions, also called lambda functions, in 1958. But C++, Python, C#, and Java all existed for years without them.

でももう違います。上記4つともラムダ式を持っています。新しい言語は普遍的に組み込まれたラムダ式(注:ビルドイン関数ではない)を持っています。そして以前のJSプログラマが作った大胆なライブラリは深くラムダ式に依存し、この機能の採用を広く助けました。

Not anymore. All four have lambdas now. Newer languages universally have lambdas built in. We have JavaScript to thank for this—and early JavaScript programmers who fearlessly built libraries that depended heavily on lambdas, leading to widespread adoption of the feature.

これはちょっと残念です。その後、上の4つの全ての言語に私はメンションをして JavaScriptのラムダは、消滅しました。

 

It is just slightly sad, then, that of all the languages I’ve mentioned, JavaScript’s syntax for lambdas has turned out to be the wordiest.

<code>// A very simple function in six languages.
function (a) { return a &gt; 0; } // JS
[](int a) { return a &gt; 0; }  // C++
(lambda (a) (&gt; a 0))  ;; Lisp
lambda a: a &gt; 0  # Python
a =&gt; a &gt; 0  // C#
a -&gt; a &gt; 0  // Java
</code>

A new arrow in your quiver

ES6はfunctionに新しい記法を導入しました。

ES6 introduces a new syntax for writing functions.

&lt;code&gt;// ES5
var selected = allJobs.filter(&lt;strong&gt;function (job) {
  return job.isSelected();
}&lt;/strong&gt;);

// ES6
var selected = allJobs.filter(&lt;strong&gt;job =&amp;gt; job.isSelected()&lt;/strong&gt;);
&lt;/code&gt;
あなたが引数が一つでSimpleな関数を必要とする時、新しいarrow function記法は<code><i>Identifier</i> =&gt; <i>Expression</i></code>. と書くだけで済みます。
あなたはfunctionやreturnをスキップ出来ます。同様に、幾つかの括弧、braces、そしてセミコロンも。

When you just need a simple function with one argument, the new arrow function syntax is simply Identifier => Expression. You get to skip typing function and return, as well as some parentheses, braces, and a semicolon.

個人的にこの機能は素晴らしい物だと思っています。 functionとタイプする必要がないことは私にとって重要です。なぜなら私は代わりにfunctoinとタイプしてしまい、戻って修正する必要があるからです。

(I am personally very grateful for this feature. Not having to type function is important to me, because I inevitably type functoin instead and have to go back and correct it.)

複数の引数 (or no arguments, or rest parameters or defaults, or a destructuring argument)を取るfunctionを書くためには、複数の引数を括弧で囲むことが必要です。

To write a function with multiple arguments (or no arguments, or rest parameters or defaults, or a destructuring argument) you’ll need to add parentheses around the argument list.

<code>// ES5
var total = values.reduce(<strong>function (a, b) {
  return a + b;
}</strong>, 0);

// ES6
var total = values.reduce(<strong>(a, b) =&gt; a + b</strong>, 0);
</code>

I think it looks pretty nice.

私はこれをとても素晴らしい物だと思います。

Arrow functionは美しい機能的なツールと一緒に Underscore.js and Immutable。などのライブラリから提供されています。実際に、この例は全てES6で書かれている Immutable’s documentation に載っています。なのでこれら多くはすでにarrow functionを使えます。

Arrow functions work just as beautifully with functional tools provided by libraries, like Underscore.js and Immutable. In fact, the examples in Immutable’s documentation are all written in ES6, so many of them already use arrow functions.

not-so-functional settingsとは?Arrow functionはexpressionの代わりにstatementsのブロック含むことが出来ます。以前の例を思い出して下さい。

What about not-so-functional settings? Arrow functions can contain a block of statements instead of just an expression.Recall our earlier example:

<code>// ES5
$("#confetti-btn").click(<strong>function (event)</strong> {
  playTrumpet();
  fireConfettiCannon();
});
</code>

ES6ではこのようにします。
<code>// ES6
$("#confetti-btn").click(<strong>event =&gt;</strong> {
  playTrumpet();
  fireConfettiCannon();
});
</code>

わずかな改善です。このコードの効果は Promises を使用するともっと劇的に上昇します、 }).then(function (result) {のようなラインを重ね合わせることが出来ます

A minor improvement. The effect on code using Promises can be more dramatic, as the }).then(function (result) { lines can pile up.

ブロック付きarrow functionは自動で値を返さないことに注意して下さい。その場合はreturn文を使用します。

Note that an arrow function with a block body does not automatically return a value. Use a return statement for that.

arrow functionを使用しplainなオブジェクトを作る時に警告があります。オブジェクトは括弧で囲まなければいけません。

There is one caveat when using arrow functions to create plain objects. Always wrap the object in parentheses:

<code>// create a new empty object for each puppy to play with
var chewToys = puppies.map(puppy =&gt; {});   // BUG!
var chewToys = puppies.map(puppy =&gt; ({})); // ok
</code>
//訳者解説:引数を取らず、ブロックステートメント({})を使わずにplainなオブジェクトを返す時のコードは括弧が必要です。

不幸にも、空のオブジェクト{}と空のブロック{}はちょうど同じです。ES6のルールに{arrowの直後にある{はブロックの開始として扱われる、オブジェクトで始まってはいけないという物があります。したがってpuppy => {}というコードはundefinedを返すarrow functionとして静的にインタプリタされます。

Unfortunately, an empty object {} and an empty block {} look exactly the same. The rule in ES6 is that { immediately following an arrow is always treated as the start of a block, never the start of an object. The code puppy => {} is therefore silently interpreted as an arrow function that does nothing and returns undefined.

さらに混乱させるのが、{key:vaue}のようなオブジェクトリテラルはlabelを含んだブロックステートメントと同じということです。これはあなたのJSエンジンにはどのように見えるでしょうか?幸運にも{は曖昧な文字ですなのでオブジェクトリテラルを括弧で囲むというトリックを覚えておくだけで通用します。

Even more confusing, an object literal like {key: value} looks exactly like a block containing a labeled statement—at least, that’s how it looks to your JavaScript engine. Fortunately { is the only ambiguous character, so wrapping object literals in parentheses is the only trick you need to remember.

What’s this?

Thisって何?(原文:What's this?)

従来のfunctionとarrow functionには微妙な違いが存在します。Arrow functionは自分自身のthisを持ちません!arrow function内の値thisはいつもその外側のスコープの値を継承します。

There is one subtle difference in behavior between ordinary function functions and arrow functions. Arrow functions do not have their own this value. The value of this inside an arrow function is always inherited from the enclosing scope.

試して実際に何を意味するのか理解する前に、すこし復習してみましょう。

Before we try and figure out what that means in practice, let’s back up a bit.

JavaScriptでthisはどのように動作する?この値はどこから来てるの?この疑問を短い答えで返すことは出来ません。もしこの答えが頭のなかで出せるなら、それはあなたが長い間thisと一緒にいたからでしょう!

How does this work in JavaScript? Where does its value come from? There’s no short answer. If it seems simple in your head, it’s because you’ve been dealing with it for a long time!

この疑問の理由はだいたいfunction functionがthisの値を自動で受け取ることに由来します。あなたはこんなハックを書いたことがありますか?

One reason this question comes up so often is that function functions receive a this value automatically, whether they want one or not. Have you ever written this hack?

<code>{
  ...
  addAll: function addAll(pieces) {
    var self = this;
    _.each(pieces, function (piece) {
      self.add(piece);
    });
  },
  ...
}
</code>

ほら、あなたが内部関数に書けばいいはものはthis.add(piece)だけです。不運にも、内部関数は外部のfunctionのthisの値を継承しません。inner functionの内部ではthisはwindowやundefinedです。

Here, what you’d like to write in the inner function is just this.add(piece). Unfortunately, the inner function doesn’t inherit the outer function’s this value. Inside the inner function, this will be window or undefined.

一時的な値selfは外側の値thisを内部に密輸します。(他の方法としてはbindを内部関数に使う方法があります。どちらの方法も綺麗です)

The temporary variable self serves to smuggle the outer value of this into the inner function. (Another way is to use .bind(this) on the inner function. Neither way is particularly pretty.)

ES6ではもしあなたが下のルールを使用しているならだいたいthisハックは必要ありません。

In ES6, this hacks mostly go away if you follow these rules:

  • Use non-arrow functions for methods that will be called using the object.method() syntax. Those are the functions that will receive a meaningful this value from their caller.
  • object.method()記法を使って呼ばれるメソッドでnon-arrow function(いわゆるレキシカルなfunction)を使用している。これらのfunctionは意味のあるthisをcallerから受け取ります。
  • Use arrow functions for everything else.
  • それ以外ではarrow functionを使用している。
<code>// ES6
{
  ...
  addAll: function addAll(pieces) {
    _.each(pieces, piece =&gt; this.add(piece));
  },
  ...
}
</code>

ES6バージョンではaddAllメソッドはthisをcaller(function.caller)から受け取ります。内部関数はarrow functionです、なのでthisを外部のスコープから継承します。

In the ES6 version, note that the addAll method receives this from its caller. The inner function is an arrow function, so it inherits this from the enclosing scope.

ボーナスとしてES6はオブジェクトリテラルのメソッドを短く書く方法が提供されます!なのでこのコードは更にシンプルにすることが出来ます。

As a bonus, ES6 also provides a shorter way to write methods in object literals! So the code above can be simplified further:

<code>// ES6 with method syntax
{
  ...
  addAll(pieces) {
    _.each(pieces, piece =&gt; this.add(piece));
  },
  ...
}
</code>

メソッドとarrowsの間では、私は"functoin"と書くことはもうないと思います、これはいい考えです。

Between methods and arrows, I might never type functoin again. It’s a nice thought.

それらは arrow と non-arrow functionsのもっとマイナーな違いとしてarrow functionは自分自身のargumentsを受け取りません。

もちろん、ES6ではあなたは多分デフォルト引数や可変長引数を使用することでしょう。

There’s one more minor difference between arrow and non-arrow functions: arrow functions don’t get their own arguments object, either. Of course, in ES6, you’d probably rather use a rest parameter or default value anyway.

Using arrows to pierce the dark heart of computer science

私達はarrow functionの実践的な使用方法について話してきました。これらのもっといろんなユースケース:ES6のarrow functionのlearning toolとして、計算科学の深いところまで話そうかと思います。あなたが参加するかどうかはアナタ次第です。

 

We’ve talked about the many practical uses of arrow functions. There’s one more possible use case I’d like to talk about: ES6 arrow functions as a learning tool, to uncover something deep about the nature of computation. Whether that is practical or not, you’ll have to decide for yourself.

1936年にAlonzo ChurchとAlan Turingは依存はせずに協力な計算モデルを開発しました。Turing はa-machinesと呼びました。しかし、人々はすぐにこのモデルをチューリングマシンと呼び始めました。Churchは代わりにfunctionについて書きました。彼のモデルは λ-calculus.と呼ばれています。この成果はLispでLAMBDAという文字が使われているのに由来します。

In 1936, Alonzo Church and Alan Turing independently developed powerful mathematical models of computation. Turing called his model a-machines, but everyone instantly started calling them Turing machines. Church wrote instead about functions. His model was called the λ-calculus. (λ is the lowercase Greek letter lambda.) This work was the reason Lisp used the word LAMBDA to denote functions, which is why we call function expressions “lambdas” today.

しかしラムダ式とは何でしょうか?計算モデルとは何を意味するのでしょう?

But what is the λ-calculus? What is “model of computation” supposed to mean?

これを幾つかの言葉で説明するのは難しいですが、挑戦してみました:ラムダ式は最初のプログラミング言語です。これはプログラミング言語として設計されていません。_

It’s hard to explain in just a few words, but here is my attempt: the λ-calculus is one of the first programming languages. It was not designed to be a programming language—

結局、10、20年経ってもプログラム内蔵コンピューターは来ませんでした

after all, stored-program computers wouldn’t come along for another decade or two—

しかし、あなたがやりたいと願った全ての計算の表現出来る言語はこれ以上無いほどSimpleで、必要最小限の、純粋な数学的アイデアです。

but rather a ruthlessly simple, stripped-down, purely mathematical idea of a language that could express any kind of computation you wished to do.

Churchはcomputation in generalを証明するためにこのモデルが必要でした。

Church wanted this model in order to prove things about computation in general.

そして彼は彼のシステムにおいてfunctionのみが必要とされることを発見しました。

And he found that he only needed one thing in his system: functions.

彼の主張がいかに特別だったかがわかります。オブジェクトなし、配列なし、数字なし、if文もwhileループもセミコロンもassignmentも、論理式もイベントループもです。

Think how extraordinary this claim is. Without objects, without arrays, without numbers, without if statements, while loops, semicolons, assignment, logical operators, or an event loop,

これは全てのJavascriptが出来る全ての種類の計算をfunctionのみを使用して一から設計することが可能です。

it is possible/ to rebuild every kind of computation JavaScript can do/, from scratch, using only functions.

これがChurchのラムダ式表記法を使い数学者が書くことが出来るタイプの"プログラム"の例です

Here is an example of the sort of “program” a mathematician could write, using Church’s λ notation:

<code>fix = λf.(λx.f(λv.x(x)(v)))(λx.f(λv.x(x)(v)))
</code>

これと同等のJavascriptのfunctionです。

The equivalent JavaScript function looks like this:

<code>var fix = f =&gt; (x =&gt; f(v =&gt; x(x)(v)))
               (x =&gt; f(v =&gt; x(x)(v)));
</code>
これはJavaScriptにはλ-calculusの実装が含まれていて実際に実行できます。JavaScriptのラムダ式です。

That is, JavaScript contains an implementation of the λ-calculus that actually runs. The λ-calculus is in JavaScript.

 このAlonzo Churchとその後の研究者がラムダ式で何をしたか、そしてそれがどのように大抵のメジャーなプログラミング言語に入り込む(実装される)かはこのブログの範囲を超えてしまいます。

The stories of what Alonzo Church and later researchers did with the λ-calculus,

and how it has quietly insinuated itself into almost every major programming language,

are beyond the scope of this blog post.

 しかしもしあなたがコンピューターサイエンスの基版に興味があるなら、

But if you’re interested in the foundations of computer science,

 もしくはあなたがちょうどfunctionのみでループや再帰のようなこと出来る言語を見たいなら

or you’d just /like to see how a/ language with/ nothing but functions can do things like loops and recursion,

あなたは 雨の午後を費やして、 Church numerals and fixed-point combinators,を探して、あなたのFirefoxコンソールや Scratchpadで試すことが出来ます。

you could do worse than to spend some rainy afternoon looking into Church numerals and fixed-point combinators,

 そしてあなたのFirefoxコンソールや Scratchpadで試すことが出来ます。

and playing with them in your Firefox console or Scratchpad.

ES6のarrowsの他の強みとともに。

With ES6 arrows on top of its other strengths,

 JavaScriptはラムダ式を研究するための最良の言語です。

JavaScript can reasonably claim to be the best language for exploring the λ-calculus.

いつからarrowsを使えるの?When can I use arrows?

firefoxにおけるES6のarrow functionsは私が実装しました 。2013年頃です。 Jan de Mooijは実装を早くしてくれました。 パッチを投げてくださったTooru Fujisawa氏とziyunfei氏に感謝します。

 

Arrow functionsはMicrosoft Edgeのプレビューリリースでも実装されています。もしarrowをWebで使うことに興味があり、今すぐ使いたいなら BabelTraceurTypeScript,を使うことが出来ます。 in case you’re interested in using them on the Web right now.

次のトピックはES6の中でも奇妙なものです。typeof x が全く新しい値を返してきます。私達は尋ねます。なぜこれはstringじゃないの?私達は"同じ"の意味に悩むでしょう

Our next topic is one of the stranger features in ES6. We’ll get to see typeof x return a totally new value. We’ll ask: When is a name not a string? We’ll puzzle over the meaning of equality.

これらは奇妙です。次の週は私達と一緒にES6のシンボルについて見ていきましょう。

It’ll be weird. So please join us next week as we look at ES6 symbols in depth.

About Jason Orendorff

 

weird:奇妙な

odd:妙な
 
As it happens
 
denote:表示する
 
Not having to type function is important to me,
 
 improvement
 
not anymore.:でももう違います。
 
universally:普遍的な
 
slightly sad:ちょっと残念です。
 
Arrow functions work just as beautifully with functional tools provided by libraries, like Underscore.js and Immutable.
 
caveat:警告
 

 quiver

ambiguous:

 

fearlessly

The rule in ES6 is that/ { immediately following an arrow is always treated as the start of a block/, never the start of an object. The code puppy => {} is therefore silently interpreted as an arrow function that does nothing and returns undefined.

/arrowの直後にある{はブロックの開始として扱われる、/オブジェクトで始まってはいけない。/したがってpuppy => {}というコードはundefinedを返すarrow functionとして静的にインタプリタされます。

 

Here, what you’d like to write in the inner function is just this.add(piece).

 JavaScript /can reasonably claim /to be the best language for exploring the λ-calculus.

smuggle

nothing but

技術
 
<!--:es6で標準化されたコメントとして認められた。nodeでも動く。
-->:arrowシーケンスという。こちらもコメント。
 
arrow シーケンスは行の先頭で出てくるとコメントだが、whileとかの中で出てくるとgoes on演算子として働く。(標準ではないので注意。)
 
arrow secence はhtmlだと-->の前がコメントかされるのに対してjsだと-->の後がコメントとされる。不思議ですね。
 
矢とそれ以外のマイナーな違いとして、argumentsを受け取るかどうかの違いがある。
 
Simple矢でオブジェクトを返したい時は()で囲むこと。
 
()=({})
 
key:valueがあるときも同様。よく見るとラベルと同じだからね。
 
 
 go away:どこかに行く→必要ありません
 
nature of computation:計算機の性質
 
arrow functions don’t get their own arguments object,
 
It is just slightly sad, then, that of all the languages I’ve mentioned, JavaScript’s syntax for lambdas has turned out to be the wordiest.
 
Not anymore. All four have lambdas now. Newer languages universally have lambdas built in. We have JavaScript to thank for this—and early JavaScript programmers who fearlessly built libraries that depended heavily on lambdas, leading to widespread adoption of the feature.
 
The arrow sequence --> also denotes a one-line comment. Weirdly, while in HTML characters before the --> are part of the comment, in JS the rest of the line after the --> is a comment.
 
Between methods and arrows, I might never type functoin again. It’s a nice thought.

感想

この原作は素晴らしいと思う。流石firefoxにarrow function実装した人だ。感動した。ていうか今までかなりすごい人たちのブログ訳してんだな俺って。

ちょうどMDNの歴史のページ訳してたんだけどそこに載ってるような人たち。ありがたい&責任感ある。

 

今回は約8時間で終わった。昨日1時間程、今日10時から17時まで。

最初にmozhacksの翻訳した時は一週間ぐらいかかったからだいぶ進歩だと思う。

今回は翻訳すら出来ないような所はなかった。

翻訳がわかんなくて最後に回してスラッシュリーディングしたら溶けた所はあったけど。

 

ただ、一文翻訳して、それを書き終わったら次に行くみたいなスタイルなので(普通日本語の文章書く時は書きながら次の文考えるでしょ?)日本語書きながら次の文を見ることができればこの2倍早く出来る余地はあるんだろうね。

まあ普通に訳すのも怪しいのでまだまだだけど。

 

最初の-->は解けなかった。。。ていうか英訳が死んでた。

 

JavaScriptでthisはどのように動作する?この値はどこから来てるの?この疑問を短い答えで返すことは出来ません。もしこの答えが頭のなかで出せるなら、それはあなたが長い間thisと一緒にいたからでしょう!

 

確かにね。thisは深いよ。俺もまだ完璧に分かるわけじゃない。

 

ちなみに今回の総文字数は2万字超えてる。俺しゅごい。