input
stringlengths 0
929
| output
stringlengths 0
10.3k
| task
stringclasses 3
values | index
int64 0
5.38k
| liscence
stringclasses 4
values | source
stringclasses 15
values | instruction
stringlengths 13
3.45k
|
|---|---|---|---|---|---|---|
答え：`{}` `""` `[]`
演算子 `||` を使えば、最初の真偽値のオペランドを返すことができる。すべての値が偽の場合、最後のオペランドが返されます。
`(false || {} || null)`: 空のオブジェクト `{}` は真理値です。これは最初の（そして唯一の）真理値であり、これが返される。one` は `{}` と等しい。
`(null || false || "")`: すべてのオペランドは偽の値です。これは最後のオペランド `""` が返されることを意味する。`two` は `""` に等しい。
`([] || 0 || "")`: 空の配列`[]`は真理値です。これは最初に返される真理値である。`three`は `[]` に等しい。
|
check_code_behavor
| 400 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const one = false || {} || null;
const two = null || false || '';
const three = [] || 0 || true;
console.log(one, two, three);
```
|
|
答え：`second`, `I have resolved!` and `I have resolved!`, `second`
プロミスでは、基本的に「この関数を実行したいが、時間がかかるかもしれないので、実行中はとりあえず置いておく。ある値が解決され（あるいは拒否され）、コールスタックが空になったときだけ、この値を使いたい。
この値は `.then` と `async` 関数の `await` キーワードの両方で取得できます。プロミスの値は `.then` と `await` の両方で取得できるが、その動作は少し異なる。
firstFunction`では、myPromise関数が実行されている間は（ある意味）脇に置いて、他のコード（この場合は`console.log('second')`）を実行し続けた。その後、関数は文字列 `I have resolved` で解決し、コールスタックが空であることを確認した後にログに記録された。
secondFunction`のawaitキーワードを使うと、文字通り、値が解決されるまで非同期関数の実行を一時停止してから次の行に移ることができる。
つまり、`myPromise` が `I have resolved` という値で解決されるのを待ち、解決された時点で次の行に移る。
|
check_code_behavor
| 401 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const myPromise = () => Promise.resolve('I have resolved!');
function firstFunction() {
myPromise().then(res => console.log(res));
console.log('second');
}
async function secondFunction() {
console.log(await myPromise());
console.log('second');
}
firstFunction();
secondFunction();
```
|
|
答え：`3`, `Lydia2`, `[object Object]2`
演算子 `+` は数値の足し算に使われるだけでなく、文字列の連結にも使うことができる。JavaScriptエンジンは、1つ以上の値が数値でないと判断すると、その数値を文字列に強制的に変換する。
最初は `1` で、これは数値である。1 + 2`は数字の3を返す。
しかし、2番目の値は文字列 `"Lydia"` である。`2`は文字列に強制される。`Lydia"`と`"2"`は連結され、`"Lydia2"`という文字列になる。
名前: "Lydia" はオブジェクトである。数値もオブジェクトも文字列ではないので、両方を文字列化する。通常のオブジェクトを文字列化すると、必ず `"[object Object]"` となる。"[オブジェクト`"[object Object]"` に `"2"` を連結すると `"[object Object]2"` となる。
|
check_code_behavor
| 402 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const set = new Set();
set.add(1);
set.add('Lydia');
set.add({ name: 'Lydia' });
for (let item of set) {
console.log(item + 2);
}
```
|
|
答え：`Promise {<fulfilled>: 5}`
`Promise.resolve`には、プロミスでもプロミスでなくても、どんな型の値でも渡すことができる。メソッド自体は解決された値(`<fulfilled>`)を持つプロミスを返します。通常の関数を渡すと、解決されたプロミスと通常の値が返されます。プロミスを渡した場合は、そのプロミスの解決された値を持つ解決されたプロミスになります。
この例では、数値 `5` を渡しました。これは値 `5` で解決されたプロミスを返します。
|
check_code_behavor
| 403 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
Promise.resolve(5);
```
|
|
答え：`They are the same!`
オブジェクトは参照渡しである。オブジェクトが厳密に等しいかどうか（`===`）をチェックするとき、その参照を比較することになる。
`person2`のデフォルト値を`person`オブジェクトと等しく設定し、`person1`の値として`person`オブジェクトを渡した。
つまり、どちらの値もメモリ上の同じ場所を参照しているので、等しいことになる。
`else`文のコードブロックが実行され、`They are the same!`はログを得る。
|
check_code_behavor
| 404 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
function compareMembers(person1, person2 = person) {
if (person1 !== person2) {
console.log('Not the same!');
} else {
console.log('They are the same!');
}
}
const person = { name: 'Lydia' };
compareMembers(person);
```
|
|
答え：`TypeError`
JavaScript では、オブジェクトのプロパティにアクセスする方法が 2 つあります。括弧表記とドット表記です。 この例では、括弧表記 (`colorConfig["colors"]`) の代わりにドット表記 (`colorConfig.colors`) を使用します。
ドット表記を使用すると、JavaScript はその正確な名前を持つオブジェクトのプロパティを検索しようとします。 この例では、JavaScript は `colorConfig` オブジェクトで `colors` というプロパティを見つけようとします。 `colors` というプロパティはないため、これは `unknown` を返します。 次に、`[1]` を使用して最初の要素の値にアクセスしようとします。 「未定義」の値に対してこれを行うことはできないため、「TypeError」「未定義のプロパティ '1' を読み取れません」がスローされます。
JavaScript はステートメントを解釈 (またはボックス化解除) します。 括弧表記を使用すると、最初の開始括弧 `[` が表示され、閉じ括弧 `]` が見つかるまで処理が続けられます。 その場合にのみ、ステートメントが評価されます。 `colorConfig[colors[1]]` を使用した場合は、`colorConfig` オブジェクトの `red` プロパティの値が返されるでしょう。
|
check_code_behavor
| 405 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const colorConfig = {
red: true,
blue: false,
green: true,
black: true,
yellow: false,
};
const colors = ['pink', 'red', 'blue'];
console.log(colorConfig.colors[1]);
```
|
|
答え：`true`
内部的には、絵文字は Unicode です。 ハートの絵文字の Unicode は「U+2764 U+FE0F」です。 これらは同じ絵文字では常に同じであるため、2 つの等しい文字列を相互に比較し、true を返します。
|
check_code_behavor
| 406 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
console.log('❤️' === '❤️');
```
|
|
答え：`splice`
「splice」メソッドでは、要素を削除、置換、追加することで元の配列を変更します。 この場合、インデックス 1 から 2 つのアイテムを削除し (`'🥑'` と `'😍'` を削除しました)、代わりに ✨ 絵文字を追加しました。
`map`、`filter`、`slice` は新しい配列を返し、`find` は要素を返し、`reduce` は縮小された値を返します。
|
check_code_behavor
| 407 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。元の配列を変更するメソッドは次のうちどれですか?
```javascript
const emojis = ['✨', '🥑', '😍'];
emojis.map(x => x + '✨');
emojis.filter(x => x !== '🥑');
emojis.find(x => x !== '🥑');
emojis.reduce((acc, cur) => acc + '✨');
emojis.slice(1, 2, '✨');
emojis.splice(1, 2, '✨');
```
|
|
答え：`['🍕', '🍫', '🥑', '🍔']`
「info」オブジェクトの「favoriteFood」プロパティの値を、ピザの絵文字「🍕」を含む文字列と等しく設定します。 文字列はプリミティブなデータ型です。 JavaScript では、プリミティブ データ型は参照によって相互作用しません。
JavaScript では、プリミティブ データ型 (オブジェクトではないすべてのもの) は、_value_ によって相互作用します。 この場合、`info` オブジェクトの `favoriteFood` プロパティの値を、`food` 配列の最初の要素の値、この場合はピザの絵文字を含む文字列 (`'🍕'`) に設定します。 ）。 文字列はプリミティブ データ型であり、値によって対話します 。
次に、「info」オブジェクトの「favoriteFood」プロパティの値を変更します。 `food` 配列は変更されていません。これは、`favoriteFood` の値が配列内の最初の要素の値の単に _copy_ であり、 `food[0]`の要素とメモリ内の同じ場所への参照がないためです。 食事を記録するときは、元の配列 `['🍕', '🍫', '🥑', '🍔']` のままです。
|
check_code_behavor
| 408 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const food = ['🍕', '🍫', '🥑', '🍔'];
const info = { favoriteFood: food[0] };
info.favoriteFood = '🍝';
console.log(food);
```
|
|
答え：Parses JSON to a JavaScript value
`JSON.parse()`メソッドを使うと、JSON文字列をJavaScriptの値にパースすることができる。
```javascript
// 数値を有効なJSONに文字列化し、JSON文字列をJavaScriptの値にパースする：
const jsonNumber = JSON.stringify(4); // '4'
JSON.parse(jsonNumber); // 4
// 配列の値を有効な JSON に文字列化し、その JSON 文字列を JavaScript の値にパースします：
const jsonArray = JSON.stringify([1, 2, 3]); // '[1, 2, 3]'
JSON.parse(jsonArray); // [1, 2, 3]
// オブジェクトを有効なJSONに文字列化し、JSON文字列をJavaScriptの値にパースします：
const jsonArray = JSON.stringify({ name: 'Lydia' }); // '{"name":"Lydia"}'
JSON.parse(jsonArray); // { name: 'Lydia' }
```
|
check_code_behavor
| 409 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。この方法は何をするためのものでしょうか?
```javascript
JSON.parse();
```
|
|
答え：`ReferenceError`
各関数には独自の_実行コンテキスト_ (または_スコープ_) があります。 `getName` 関数は、まず独自のコンテキスト (スコープ) 内を調べて、アクセスしようとしている変数 `name` が含まれているかどうかを確認します。 この場合、`getName` 関数には独自の `name` 変数が含まれています。`let` キーワードと `'Sarah'` の値を使用して変数 `name` を宣言します。
`let` キーワード (および `const`) を持つ変数はホイストされますが、`var` とは異なり<i>初期化</i>されません。 これらは、宣言 (初期化) する行より前にはアクセスできません。 これを「時間的デッドゾーン」と呼びます。 変数が宣言される前に変数にアクセスしようとすると、JavaScript は `ReferenceError` をスローします。
`getName` 関数内で `name` 変数を宣言しなかった場合、JavaScript エンジンは _scopechain_ を調べていたでしょう。 外側のスコープには、「Lydia」という値を持つ「name」という変数があります。 その場合、「Lydia」が記録されることになります。
```javascript
let name = 'Lydia';
function getName() {
console.log(name);
}
getName(); // Lydia
```
|
check_code_behavor
| 410 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
let name = 'Lydia';
function getName() {
console.log(name);
let name = 'Sarah';
}
getName();
```
|
|
答え：`['a', 'b', 'c']` and `a`
`yield` キーワードを使用すると、ジェネレータ関数の値を `yield` します。`yield*` キーワードを使用すると、別のジェネレータ関数や反復可能なオブジェクト (配列など) から値を取得することができます。
generatorOne` では、`yield` キーワードを使用して配列 `['a', 'b', 'c']` 全体を降伏させている。`one` の `next` メソッドが返すオブジェクトの `value` プロパティの値（`one.next().value`）は配列 `['a', 'b', 'c']` 全体と等しい。
```javascript
console.log(one.next().value); // ['a', 'b', 'c']
console.log(one.next().value); // undefined
```
`generatorTwo` では、`yield*` キーワードを使用する。これは、`two` の最初の値がイテレータの最初の値と等しいことを意味する。イテレータは配列 `['a', 'b', 'c']` である。したがって、最初に `two.next().value` を呼び出すと、`a` が返される。
```javascript
console.log(two.next().value); // 'a'
console.log(two.next().value); // 'b'
console.log(two.next().value); // 'c'
console.log(two.next().value); // undefined
```
|
check_code_behavor
| 411 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
function* generatorOne() {
yield ['a', 'b', 'c'];
}
function* generatorTwo() {
yield* ['a', 'b', 'c'];
}
const one = generatorOne();
const two = generatorTwo();
console.log(one.next().value);
console.log(two.next().value);
```
|
|
答え：`I love to program`
テンプレート・リテラル内の式は最初に評価されます。つまり、文字列には式の戻り値が含まれることになり、この場合はすぐに呼び出される関数 `(x => x)('I love')` が含まれます。`x => x` 矢印関数の引数として `'I love'` という値を渡します。`x` は `'I love'` と等しく、これが返される。この結果、`I love to program`となる。
|
check_code_behavor
| 412 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
console.log(`${(x => x)('I love')} to program`);
```
|
|
答え：setInterval` コールバックが1秒ごとに呼び出されます。
通常、オブジェクトを「null」に設定すると、そのオブジェクトへの参照がなくなるため、それらのオブジェクトは「ガベージ コレクション」されます。 ただし、`setInterval` 内のコールバック関数はアロー関数 (したがって、`config` オブジェクトにバインドされている) であるため、コールバック関数は引き続き `config` オブジェクトへの参照を保持します。
参照がある限り、オブジェクトはガベージ コレクションされません。
これはインターバルであるため、「config」を「null」に設定するか、「config.alert」を「削除」してもインターバルはガベージコレクトされないため、インターバルは引き続き呼び出されます。
メモリから削除するには、`clearInterval(config.alert)` を使用してクリアする必要があります。
クリアされていないため、「setInterval」コールバック関数は引き続き 1000 ミリ秒 (1 秒) ごとに呼び出されます。
|
check_code_behavor
| 413 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が起こるでしょうか？
```javascript
let config = {
alert: setInterval(() => {
console.log('Alert!');
}, 1000),
};
config = null;
```
|
|
答え：2
`set` メソッドを使用してキーと値のペアを追加する場合、キーは `set` 関数に渡される最初の引数の値になり、値は `set` 関数に渡される 2 番目の引数になります。 この場合、キーは _function_ `() => 'greeting'` であり、値 `'Hello world'` です。 `myMap` は `{ () => 'greeting' => 'Hello world!' になりました。 }`。
1 は間違っています。キーは `'greeting'` ではなく `() => 'greeting'` です。
3 は間違っています。新しい関数をパラメータとして `get` メソッドに渡して作成しているからです。 オブジェクトは_reference_によって相互作用します。 関数はオブジェクトです。そのため、2 つの関数はたとえ同一であっても厳密に等しくなりません。これらの関数はメモリ内の異なる場所への参照を持っています。
|
check_code_behavor
| 414 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。どのメソッドが `'Hello world!`を返しますか？
```javascript
const myMap = new Map();
const myFunc = () => 'greeting';
myMap.set(myFunc, 'Hello world!');
//1
myMap.get('greeting');
//2
myMap.get(myFunc);
//3
myMap.get(() => 'greeting');
```
|
|
答え：`{name: "Lydia", age: 22}`
`changeAge` と `changeAgeAndName` の両関数にはデフォルトのパラメータがあり、新しく作成されたオブジェクト `{ ...person }` が渡される。このオブジェクトは `person` オブジェクトのすべてのキー/値のコピーを持っている。
まず、 `changeAge` 関数を呼び出して、引数として `person` オブジェクトを渡す。これで `person` は `{ name: "Lydia", age: 22 }` となる。
次に `changeAgeAndName` 関数を呼び出すが、パラメータは渡さない。その代わりに、`x` の値は `{ ...person }` という _new_ オブジェクトに等しくなる。これは新しいオブジェクトなので、`person`オブジェクトのプロパティの値には影響しない。`person` は `{ name: "Lydia", age: 22 }` に等しい。
|
check_code_behavor
| 415 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const person = {
name: 'Lydia',
age: 21,
};
const changeAge = (x = { ...person }) => (x.age += 1);
const changeAgeAndName = (x = { ...person }) => {
x.age += 1;
x.name = 'Sarah';
};
changeAge(person);
changeAgeAndName();
console.log(person);
```
|
|
答え：C: `sumValues(...[1, 2, 3])`
スプレッド演算子 `...` を使用すると、イテレート可能な要素を個別にスプレッドすることができる。sumValues`関数は3つの引数を受け取る： `x`、`y`、`z`である。`...[1,2,3]`は `1,2,3`となり、これを `sumValues` 関数に渡す。
|
check_code_behavor
| 416 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。6`を返すオプションはどれですか？
```javascript
function sumValues(x, y, z) {
return x + y + z;
}
```
- A: `sumValues([...1, 2, 3])`
- B: `sumValues([...[1, 2, 3]])`
- C: `sumValues(...[1, 2, 3])`
- D: `sumValues([1, 2, 3])`
|
|
答え：`🥰`
`+=` オペランドを使用すると、`num` の値が `1` ずつ増加します。 `num` の初期値は `1` なので、`1 + 1` は `2` になります。 `list` 配列の 2 番目のインデックスの項目は 🥰 であり、`console.log(list[2])` は 🥰 を出力します。
|
check_code_behavor
| 417 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
let num = 1;
const list = ['🥳', '🤠', '🥰', '🤪'];
console.log(list[(num += 1)]);
```
|
|
答え：`Mara` `undefined` `Lydia Hallie` `ReferenceError`
オプションの連鎖演算子 `?.` を使用すると、ネストされた深い値が有効かどうかを明示的にチェックする必要がなくなります。もし `undefined` または `null` 値（_nullish_）のプロパティにアクセスしようとすると、式は短絡して `undefined` を返します。
`person.pet?.name`: `person` は `pet` という名前のプロパティを持っています。`person.pet`は`name`というプロパティを持ち、`Mara`を返す。
`person.pet?.family?.name`：`person`は`pet`というプロパティを持つ：`person.pet`はnullishではない。pet` は `family` というプロパティを持っていないので、`person.pet.family` は NULL である。式は `undefined` を返す。
`person.getFullName?.()`: `person` は `getFullName` という名前のプロパティを持っています: `person.getFullName()` は NULL ではないので、呼び出すことができます。
`member.getLastName?.()`: 変数 `member` は存在しないので、 `ReferenceError` がスローされます。
|
check_code_behavor
| 418 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const person = {
firstName: 'Lydia',
lastName: 'Hallie',
pet: {
name: 'Mara',
breed: 'Dutch Tulip Hound',
},
getFullName() {
return `${this.firstName} ${this.lastName}`;
},
};
console.log(person.pet?.name);
console.log(person.pet?.family?.name);
console.log(person.getFullName?.());
console.log(member.getLastName?.());
```
|
|
答え：`We don't have to buy bananas`
groceries.indexOf("banana")`という条件をif文に渡しました。groceries.indexOf("banana")` は `0` を返し、これは不正な値です。if文の条件が偽なので、`else`ブロックのコードが実行され、`We don't have to buy bananas`がログに記録される。
|
check_code_behavor
| 419 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const groceries = ['banana', 'apple', 'peanuts'];
if (groceries.indexOf('banana')) {
console.log('We have to buy bananas!');
} else {
console.log(`We don't have to buy bananas!`);
}
```
|
|
答え：`undefined`
`language`メソッドは`setter`である。setterは実際の値を保持するのではなく、プロパティを変更することが目的である。`setter` メソッドを呼び出すと、 `undefined` が返される。
|
check_code_behavor
| 420 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const config = {
languages: [],
set language(lang) {
return this.languages.push(lang);
},
};
console.log(config.language);
```
|
|
答え：`false` `false`
`typeof name` は `"string"` を返す。文字列 `"string"` は真理値なので、 `!typeof name` は真偽値 `false` を返す。`false === "object"` と `false === "string"` はどちらも `false` を返す。
|
check_code_behavor
| 421 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const name = 'Lydia Hallie';
console.log(!typeof name === 'object');
console.log(!typeof name === 'string');
```
|
|
答え：`4` `5` `6`
`add`関数はアロー関数を返し、アロー関数はアロー関数を返す。最初の関数は引数 `x` に値 `4` を受け取る。番目の関数を呼び出すと、引数 `y` に値 `5` が渡される。次に3番目の関数を呼び出すと、引数 `z` に値 `6` が渡される。最後の関数の中で `x`、`y`、`z` の値にアクセスしようとすると、JSエンジンはスコープ・チェーンをさかのぼって `x` と `y` の値を探す。これは `4` `5` `6` を返す。
|
check_code_behavor
| 422 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const add = x => y => z => {
console.log(x, y, z);
return x + y + z;
};
add(4)(5)(6);
```
|
|
答え：`1` `2` `3`
ジェネレータ関数 `range` は、渡した範囲内の各項目のプロミスを持つ非同期オブジェクトを返す： `Promise{1}`, `Promise{2}`, `Promise{3}` である。変数 `gen` に非同期オブジェクトをセットし、`for await ... of` ループを使ってループさせる。変数 `item` に返された Promise の値をセットする。最初に `Promise{1}`、次に `Promise{2}`、次に `Promise{3}` とする。解決されたプロミスである `item` の値を待っているので、解決されたプロミスの値が返される。
|
check_code_behavor
| 423 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
async function* range(start, end) {
for (let i = start; i <= end; i++) {
yield Promise.resolve(i);
}
}
(async () => {
const gen = range(1, 3);
for await (const item of gen) {
console.log(item);
}
})();
```
|
|
答え：`undefined` `undefined` `undefined`
`myFunc` は引数として、プロパティ `x`、`y`、`z` を持つオブジェクトを受け取る。`x`, `y`, `z` のプロパティを持つ1つのオブジェクト（{x: 1, y: 2, z: 3}）ではなく、3つの別々の数値（1, 2, 3）を渡しているだけなので、`x`, `y`, `z` のデフォルト値は `undefined` となる。
|
check_code_behavor
| 424 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const myFunc = ({ x, y, z }) => {
console.log(x, y, z);
};
myFunc(1, 2, 3);
```
|
|
答え：`The driver drove 130 mph and has to pay \$300.00`
`Intl.NumberFormat` メソッドを使うと、数値を任意のロケールにフォーマットすることができる。ここでは、数値 `130` を `en-US` ロケールの `unit`` として `mile-per-hour` にフォーマットし、`130 mph` とします。数値 `300` を `en-US` ロケールに `currency`の`USD` として変換すると `$300.00` となる。
|
check_code_behavor
| 425 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
function getFine(speed, amount) {
const formattedSpeed = new Intl.NumberFormat('en-US', {
style: 'unit',
unit: 'mile-per-hour'
}).format(speed);
const formattedAmount = new Intl.NumberFormat('en-US', {
style: 'currency',
currency: 'USD'
}).format(amount);
return `The driver drove ${formattedSpeed} and has to pay ${formattedAmount}`;
}
console.log(getFine(130, 300))
```
|
|
答え：`["👻", "🎃", "🕸", "💀"]`
オブジェクトを分割することで、右側のオブジェクトから値を解凍し、その解凍された値を左側のオブジェクトの同じプロパティ名の値に割り当てることができます。 この場合、値 "💀" を `spookyItems[3]` に割り当てます。 これは、`spookyItems` 配列を変更し、それに「💀」を追加していることを意味します。 `spookyItems` をログに記録すると、`["👻", "🎃", "🕸", "💀"]` がログに記録されます。
|
check_code_behavor
| 426 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const spookyItems = ['👻', '🎃', '🕸'];
({ item: spookyItems[3] } = { item: '💀' });
console.log(spookyItems);
```
|
|
答え：`false` `false` `true` `false`
`Number.isNaN`メソッドを使うと、渡された値が_数値_であり、`NaN`と等しいかどうかをチェックすることができる。name` は数値ではないので、 `Number.isNaN(name)` は `false` を返す。`age` は数値だが `NaN` と等しくないので `Number.isNaN(age)` は `false` を返す。
`isNaN` メソッドを使うと、渡された値が数値でないかどうかを調べることができる。`name` は数値ではないので、 `isNaN(name)` は true を返す。`age`は数値なので、`isNaN(age)`は `false` を返す。
|
check_code_behavor
| 427 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const name = 'Lydia Hallie';
const age = 21;
console.log(Number.isNaN(name));
console.log(Number.isNaN(age));
console.log(isNaN(name));
console.log(isNaN(age));
```
|
|
答え：`ReferenceError`
`const`キーワードで宣言された変数は、初期化される前は参照することができない。`getInfo`関数では、変数 `randomValue` は `getInfo` の関数スコープにスコープされている。`typeof randomValue` の値を記録する行では、変数 `randomValue` はまだ初期化されていない！`getInfo`関数の中で変数 `randomValue` を宣言したので、エンジンはスコープチェーンを下っていない。
|
check_code_behavor
| 428 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const randomValue = 21;
function getInfo() {
console.log(typeof randomValue);
const randomValue = 'Lydia Hallie';
}
getInfo();
```
|
|
答え：`Woah some cool data` `Oh finally!`
`try`ブロックでは、変数`myPromise`の待ちに待った値を記録している： `"Woah some cool data" `try`ブロックではエラーがスローされなかったので、`catch`ブロックのコードは実行されない。`finally`ブロックのコードは常に実行され、`"Oh finally!"`がログに記録される。
|
check_code_behavor
| 429 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const myPromise = Promise.resolve('Woah some cool data');
(async () => {
try {
console.log(await myPromise);
} catch {
throw new Error(`Oops didn't work`);
} finally {
console.log('Oh finally!');
}
})();
```
|
|
答え：`['🥑', '✨', '✨', ['🍕', '🍕']]`
「 flat 」メソッドを使用すると、新しいフラット化された配列を作成できます。 平坦化された配列の深さは、渡す値によって異なります。 この場合、値 `1` を渡しました (そうする必要はありませんでした。これはデフォルト値です)。これは、最初の深さの配列のみが連結されることを意味します。 この場合、`['🥑']` と `['✨', '✨', ['🍕', '🍕']]` です。 これら 2 つの配列を連結すると、`['🥑', '✨', '✨', ['🍕', '🍕']]` になります。
|
check_code_behavor
| 430 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const emojis = ['🥑', ['✨', '✨', ['🍕', '🍕']]];
console.log(emojis.flat(1));
```
|
|
答え：`3`
`counterOne` は `Counter` クラスのインスタンスである。カウンタクラスはコンストラクタに `count` プロパティを持ち、 `increment` メソッドを持つ。まず、`counterOne.increment()` を呼び出して `increment` メソッドを 2 回呼び出す。現在の `counterOne.count` は `2` である。
次に、新しい変数 `counterTwo` を作成し、これを `counterOne` と等しくする。オブジェクトは参照によって相互作用するので、`counterOne`が指すメモリ上の同じ場所への新しい参照を作成するだけである。メモリ上の同じ場所を指すので、`counterTwo`が参照するオブジェクトに加えられた変更は、`counterOne`にも適用される。現在、`counterTwo.count`は`2`である。
そこで、`counterTwo.increment()`を呼び出して `count` を `3` に設定する。そして、`counterOne`にカウントを記録し、`3`を記録する。
|
check_code_behavor
| 431 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
class Counter {
constructor() {
this.count = 0;
}
increment() {
this.count++;
}
}
const counterOne = new Counter();
counterOne.increment();
counterOne.increment();
const counterTwo = counterOne;
counterTwo.increment();
console.log(counterOne.count);
```
|
|
答え：`Last line 1! Promise 2! Last line 2! Promise 1! Timeout 1! Timeout 2!`
まず、「funcOne」を呼び出します。 `funcOne` の最初の行では、_asynchronous_ `setTimeout` 関数を呼び出し、そこからコールバックが Web API に送信されます。 (イベント ループに関する私の記事は<a href="https://dev.to/lydiahallie/javascript-visualized-event-loop-3dif">こちら</a>を参照してください。)
次に、非同期操作である「myPromise」プロミスを呼び出します。
Promise と Timeout は両方とも非同期操作であり、関数は Promise の完了と `setTimeout` コールバックの処理で忙しい間も実行を続けます。 これは、非同期操作ではないため、「最後の行 1!」が最初にログに記録されることを意味します。
コールスタックはまだ空ではないため、`funcOne` の `setTimeout` 関数と Promise をまだコールスタックに追加できません。
`funcTwo` では、変数 `res` は `Promise` を取得します。これは、`Promise.resolve(Promise.resolve('Promise'))` が `Promise.resolve('Promise')` と同等であるためです。 価値。 この行の `await` は、Promise の解決を受け取るまで関数の実行を停止し、完了するまで同期的に実行し続けるため、`Promise 2!` と `Last line 2!` がログに記録され、`setTimeout ` が Web API に送信されます。
その後、呼び出しスタックは空になります。 Promise は _microtasks_ なので、呼び出しスタックが空のときに最初に解決され、「Promise 1!」がログに記録されます。
ここで、`funcTwo` が呼び出しスタックからポップされたため、呼び出しスタックは空です。 キューで待機しているコールバック (`funcOne` からの `() => console.log("Timeout 1!")`、および `funcTwo` からの `() => console.log("Timeout 2!")`) 呼び出しスタックに 1 つずつ追加されます。 最初のコールバックは「タイムアウト 1!」をログに記録し、スタックからポップされます。 次に、2 番目のコールバックは「タイムアウト 2!」をログに記録し、スタックからポップされます。
|
check_code_behavor
| 432 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const myPromise = Promise.resolve(Promise.resolve('Promise'));
function funcOne() {
setTimeout(() => console.log('Timeout 1!'), 0);
myPromise.then(res => res).then(res => console.log(`${res} 1!`));
console.log('Last line 1!');
}
async function funcTwo() {
const res = await myPromise;
console.log(`${res} 2!`)
setTimeout(() => console.log('Timeout 2!'), 0);
console.log('Last line 2!');
}
funcOne();
funcTwo();
```
|
|
答え：`sum.default(4)`
アスタリスク`*`をつけると、そのファイルからエクスポートされたすべての値（デフォルトも名前付きも）をインポートする。次のようなファイルがあったとする：
```javascript
// info.js
export const name = 'Lydia';
export const age = 21;
export default 'I love JavaScript';
// index.js
import * as info from './info';
console.log(info);
```
以下のようにログに記録される：
```javascript
{
default: "I love JavaScript",
name: "Lydia",
age: 21
}
```
`sum`の例では、インポートされた値 `sum` は以下のようになる：
```javascript
{ default: function sum(x) { return x + x } }
```
`sum.default`を呼び出せば、この関数を呼び出すことができる。
|
check_code_behavor
| 433 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。どうすれば `index.js` から `sum.js` の `sum` を呼び出せますか？
```javascript
// sum.js
export default function sum(x) {
return x + x;
}
// index.js
import * as sum from './sum';
```
|
|
答え：`Added a new property!` `Accessed a property!`
Proxyオブジェクトを使えば、第2引数として渡したオブジェクトにカスタムの動作を追加することができる。この例では、2つのプロパティを持つ `handler` オブジェクトを渡している： `set` と `get` である。`set` はプロパティの値を _set_ したときに呼び出され、`get` はプロパティの値を _get_ (access) したときに呼び出される。
最初の引数は空のオブジェクト `{}` で、これは `person` の値である。このオブジェクトに `handler` オブジェクトで指定されたカスタムの振る舞いが追加される。person` オブジェクトにプロパティを追加すると、 `set` が呼び出される。`person` オブジェクトのプロパティにアクセスすると、 `get` が呼び出される。
まず、プロキシオブジェクトに新しいプロパティ `name` を追加した（`person.name = "Lydia"`）。`set`が呼び出され、`"新しいプロパティを追加しました！"`とログに記録される。
次に、プロキシオブジェクトのプロパティ値にアクセスすると、ハンドラオブジェクトの `get` プロパティが呼び出されます。プロパティにアクセスしました！`がログに記録されます。
|
check_code_behavor
| 434 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const handler = {
set: () => console.log('Added a new property!'),
get: () => console.log('Accessed a property!'),
};
|
|
答え：A: `person.name = "Evan Bacon"`
`Object.seal`を使えば、新しいプロパティが_追加されたり、既存のプロパティが_削除されたりするのを防ぐことができる。
ただし、既存のプロパティの値を変更することはできる。
|
check_code_behavor
| 435 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。`person`オブジェクトを変更するのはどれか。
```javascript
const person = { name: 'Lydia Hallie' };
Object.seal(person);
```
- A: `person.name = "Evan Bacon"`
- B: `person.age = 21`
- C: `delete person.name`
- D: `Object.assign(person, { age: 21 })`
|
|
答え：`person.address.street = "101 Main St"`
`Object.freeze`メソッドはオブジェクトを凍結する。プロパティの追加、変更、削除はできません。
つまり、オブジェクトの _直接的なプロパティだけが凍結されます。プロパティが別のオブジェクト（この場合は`address`）の場合、そのオブジェクトのプロパティは凍結されず、変更することができます。
|
check_code_behavor
| 436 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。`person`オブジェクトを変更するのはどれですか。
```javascript
const person = {
name: 'Lydia Hallie',
address: {
street: '100 Main St',
},
};
Object.freeze(person);
```
- A: `person.name = "Evan Bacon"`
- B: `delete person.address`
- C: `person.address.street = "101 Main St"`
- D: `person.pet = { name: "Mara" }`
|
|
答え：`2` `4` and `3` `6`
まず、引数を渡さずに `myFunc()` を呼び出した。引数を渡さなかったので、 `num` と `value` はデフォルトの値になった： num は `2` で、 `value` は関数 `add` の戻り値である。`num`は `2`、`value`は関数 `add` の戻り値である。`add`は `value` の値である `4` を返す。
次に `myFunc(3)` を呼び出し、引数 `num` の値として `3` を渡した。引数 `value` には値を渡さなかった。引数 `value` には値を渡さなかったので、デフォルトの値、つまり `add` 関数の戻り値が渡された。`add`には `num` を渡す。`add`は `value` の値である `6` を返す。
|
check_code_behavor
| 437 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const add = x => x + x;
function myFunc(num = 2, value = add(num)) {
console.log(num, value);
}
myFunc();
myFunc(3);
```
|
|
答え：`SyntaxError`
ES2020では、`#`を使ってクラス内にプライベート変数を追加することができる。クラスの外からこれらの変数にアクセスすることはできない。`counter.#number`を記録しようとすると、SyntaxErrorがスローされる！
|
check_code_behavor
| 438 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
class Counter {
#number = 10
increment() {
this.#number++
}
getNum() {
return this.#number
}
}
const counter = new Counter()
counter.increment()
console.log(counter.#number)
```
|
|
答え：`yield* getMembers(teams[i].members)`
`teams`配列の各要素に含まれる `members` を繰り返し処理するには、 `getMembers` ジェネレーター関数に `teams[i].members` を渡す必要がある。ジェネレータ関数はジェネレータオブジェクトを返す。このジェネレーターオブジェクトの各要素を繰り返し処理するには、 `yield*` を使用する必要がある。
もし `yield`、`return yield`、`return` と記述していたら、最初に `next` メソッドを呼び出したときにジェネレーター関数全体が返されていただろう。
|
check_code_behavor
| 439 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が足りないでしょうか？
```javascript
const teams = [
{ name: 'Team 1', members: ['Paul', 'Lisa'] },
{ name: 'Team 2', members: ['Laura', 'Tim'] },
];
function* getMembers(members) {
for (let i = 0; i < members.length; i++) {
yield members[i];
}
}
function* getTeams(teams) {
for (let i = 0; i < teams.length; i++) {
// ✨ SOMETHING IS MISSING HERE ✨
}
}
const obj = getTeams(teams);
obj.next(); // { value: "Paul", done: false }
obj.next(); // { value: "Lisa", done: false }
```
|
|
答え：`["coding", "dancing", "baking"]`
`addHobby` 関数は `hobby` と `hobbies` の2つの引数と、`person` オブジェクトの `hobbies` 配列のデフォルト値を受け取る。
まず、 `addHobby` 関数を呼び出し、`hobby` の値として `"running"` を、`hobbies` の値として空の配列を渡す。`hobbies`の値として空の配列を渡しているので、`"running"`はこの空の配列に追加される。
次に `addHobby` 関数を呼び出して、`hobby` の値として `"dancing"` を渡す。`hobby` に値を渡さなかったので、デフォルト値である `person` オブジェクトの `hobbies` プロパティを取得する。趣味の `dancing` を `person.hobbies` 配列にプッシュする。
最後に `addHobby` 関数を呼び出して、`hobby` の値として `"baking"` を、`hobbies` の値として `person.hobbies` 配列を渡す。趣味の `baking` を `person.hobbies` 配列にプッシュする。
dancing` と `baking` をプッシュすると、 `person.hobbies` の値は `["coding", "dancing", "baking"]` となる。
|
check_code_behavor
| 440 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const person = {
name: 'Lydia Hallie',
hobbies: ['coding'],
};
function addHobby(hobby, hobbies = person.hobbies) {
hobbies.push(hobby);
return hobbies;
}
addHobby('running', []);
addHobby('dancing');
addHobby('baking', person.hobbies);
console.log(person.hobbies);
```
|
|
答え：`I'm pink. 🌸` `I'm a bird. 🦢`
`Flamingo` クラスのインスタンスである変数 `pet` を作成します。 このインスタンスをインスタンス化すると、「Flamingo」の「コンストラクター」が呼び出されます。 まず、「私はピンクです。🌸」` がログに記録され、その後、`super()` を呼び出します。 `super()` は、親クラス `Bird` のコンストラクターを呼び出します。 `Bird` のコンストラクターが呼び出され、"I'm a bird. 🦢" をログに記録します。
|
check_code_behavor
| 441 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
class Bird {
constructor() {
console.log("I'm a bird. 🦢");
}
}
class Flamingo extends Bird {
constructor() {
console.log("I'm pink. 🌸");
super();
}
}
const pet = new Flamingo();
```
|
|
答え：D: 3
`const`キーワードは単に、その変数の値を再宣言できないことを意味する。しかし、値自体は不変ではありません。`emojis`配列のプロパティは変更することができます。例えば、新しい値をプッシュしたり、スプライスしたり、配列の長さを0にしたりすることができます。
|
check_code_behavor
| 442 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。どのオプションがエラーになりますか？
```javascript
const emojis = ['🎄', '🎅🏼', '🎁', '⭐'];
/* 1 */ emojis.push('🦌');
/* 2 */ emojis.splice(0, 2);
/* 3 */ emojis = [...emojis, '🥂'];
/* 4 */ emojis.length = 0;
```
- A: 1
- B: 1 and 2
- C: 3 and 4
- D: 3
|
|
答え：`*[Symbol.iterator]() { yield* Object.values(this) }`
オブジェクトはデフォルトでは反復可能ではない。イテレータ・プロトコルが存在すれば、イテレート可能です。イテレータシンボル `[Symbol.iterator]` を追加して、ジェネレータオブジェクトを返すようにすることで、手動で追加することができます。このジェネレータ関数は、配列 `["Lydia Hallie", 21]`: `yield* Object.values(this)` を返したい場合、 `person` オブジェクトの `Object.values` を返さなければならない。
|
check_code_behavor
| 443 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。`person`オブジェクトに何を追加すれば、`[...person]`の出力として`["Lydia Hallie", 21]`を得ることができますか？
```javascript
const person = {
name: "Lydia Hallie",
age: 21
}
[...person] // ["Lydia Hallie", 21]
```
|
|
答え：3
`forEach`ループ内の `if` 条件では `num` の値が真理か偽りかをチェックする。`nums` 配列の最初の数字は `0` で、偽の値なので、`if` 文のコードブロックは実行されない。`count` は `nums` 配列の残りの3つの数値、`1`, `2`, `3` に対してのみインクリメントされる。`count` は `1` だけ 3 回インクリメントされるので、`count` の値は `3` となる。
|
check_code_behavor
| 444 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
let count = 0;
const nums = [0, 1, 2, 3];
nums.forEach(num => {
if (num) count += 1
})
console.log(count)
```
|
|
答え：`undefined`, `undefined`, 🍌
`?` を使用すると、オブジェクト内のさらに深くネストされたプロパティにオプションでアクセスできます。 `fruits` 配列のインデックス `1` にあるサブ配列内のインデックス `1` に項目を記録しようとしています。 `fruits` 配列内のインデックス `1` の部分配列が存在しない場合は、単純に `undefined` を返します。 `fruits` 配列のインデックス `1` にあるサブ配列が存在するが、このサブ配列のインデックス `1` に項目がない場合も、`undefined` を返します。
まず、`[['🍊', '🍌'], ['🍍']]` の `['🍍']` サブ配列の 2 番目の項目を記録しようとしています。 この部分配列には項目が 1 つだけ含まれています。これは、インデックス `1` に項目がないことを意味し、`undefined` を返します。
次に、引数として値を渡さずに `getFruits` 関数を呼び出します。これは、`fruits` の値がデフォルトで `undefined` であることを意味します。 「fruits」のインデックス「1」にある項目を条件付きで連鎖しているため、インデックス「1」にあるこの項目は存在しないため、「未定義」が返されます。
最後に、`['🍍'], ['🍊', '🍌']` のサブ配列 `['🍊', '🍌']` の 2 番目の項目を記録しようとしています。 この部分配列内のインデックス `1` の項目は `🍌` であり、ログに記録されます。
|
check_code_behavor
| 445 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
function getFruit(fruits) {
console.log(fruits?.[1]?.[1])
}
getFruit([['🍊', '🍌'], ['🍍']])
getFruit()
getFruit([['🍍'], ['🍊', '🍌']])
```
|
|
答え：`0`
変数 `calc` を `Calc` クラスの新しいインスタンスと等しく設定します。 次に、`Calc` の新しいインスタンスをインスタンス化し、このインスタンスに対して `increase` メソッドを呼び出します。 count プロパティは `Calc` クラスのコンストラクター内にあるため、count プロパティは `Calc` のプロトタイプでは共有されません。 これは、calc が指すインスタンスの count の値が更新されておらず、count がまだ「0」であることを意味します。
|
check_code_behavor
| 446 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
class Calc {
constructor() {
this.count = 0
}
increase() {
this.count ++
}
}
const calc = new Calc()
new Calc().increase()
console.log(calc.count)
```
|
|
答え：`true`
`updateUser` 関数は、ユーザの `email` プロパティと `password` プロパティの値を更新する。updateUser` 関数の戻り値は `user` オブジェクトであり、`updatedUser の値は `user` が指す `user` オブジェクトへの参照であることを意味する。`updateUser === user` は `true` に等しい。
|
check_code_behavor
| 447 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const user = {
email: "[email protected]",
password: "12345"
}
const updateUser = ({ email, password }) => {
if (email) {
Object.assign(user, { email })
}
if (password) {
user.password = password
}
return user
}
const updatedUser = updateUser({ email: "[email protected]" })
console.log(updatedUser === user)
```
|
|
答え：`['🍇', '🍊', '🍎']`
まず、フルーツ配列に対して `slice` メソッドを呼び出します。 スライス メソッドは元の配列を変更しませんが、配列から切り取った値 (バナナの絵文字) を返します。
次に、フルーツ配列に対して `splice` メソッドを呼び出します。 splice メソッドは元の配列を変更します。つまり、フルーツ配列は `['🍊', '🍎']` で構成されることになります。
最後に、`fruit` 配列に対して `unshift` メソッドを呼び出します。これにより、指定された値 (この場合は '🍇') を配列の最初の要素として追加することで、元の配列が変更されます。 フルーツ配列は `['🍇', '🍊', '🍎']` で構成されています。
|
check_code_behavor
| 448 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const fruit = ['🍌', '🍊', '🍎']
fruit.slice(0, 1)
fruit.splice(0, 1)
fruit.unshift('🍇')
console.log(fruit)
```
|
|
答え：`{ emoji: "🐈", name: "Sara" }`
オブジェクトのキーは文字列に変換されます。
`dog` の値はオブジェクトであるため、`animals[dog]` は実際には、新しいオブジェクトに等しい `"[object Object]"` という名前の新しいプロパティを作成していることを意味します。 `animals["[object Object]"]` は、`{ emoji: "🐶"、name: "Mara"}` と等しくなります。
`cat` もオブジェクトです。つまり、`animals[cat]` は実際には、`animals["[object Object]"]` の値を新しい cat プロパティで上書きすることを意味します。
`animals[dog]`、または実際には `animals["[object Object]"]` をログすると、`dog` オブジェクトを文字列結果 `"[object Object]"` に変換すると、`{ emoji: "🐈" が返されます。 、名前: "サラ" }`。
|
check_code_behavor
| 449 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const animals = {};
let dog = { emoji: '🐶' }
let cat = { emoji: '🐈' }
animals[dog] = { ...dog, name: "Mara" }
animals[cat] = { ...cat, name: "Sara" }
console.log(animals[dog])
```
|
|
答え：`[email protected]`
`updateEmail` 関数はアロー関数であり、`user` オブジェクトにバインドされていない。つまり、`this` キーワードは `user` オブジェクトを指すのではなく、この場合はグローバルスコープを指す。`user` オブジェクト内の `email` の値は更新されない。`user.email`の値をロギングする場合、元の値である `[email protected]` が返される。
|
check_code_behavor
| 450 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const user = {
email: "[email protected]",
updateEmail: email => {
this.email = email
}
}
user.updateEmail("[email protected]")
console.log(user.email)
```
|
|
答え：`'Third'`
`Promise.all`メソッドは渡されたプロミスを並列に実行する。1つのプロミスが失敗した場合、`Promise.all` メソッドは拒否されたプロミスの値で _reject_ します。この場合、`promise3` は `"Third"` という値でリジェクトされた。このリジェクトされた値を `runPromises` 呼び出しの `catch` メソッドでキャッチして、`runPromises` 関数内のエラーをキャッチしています。この値で `promise3` が拒否されたので、`"Third"` だけがログに記録されます。
|
check_code_behavor
| 451 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const promise1 = Promise.resolve('First')
const promise2 = Promise.resolve('Second')
const promise3 = Promise.reject('Third')
const promise4 = Promise.resolve('Fourth')
const runPromises = async () => {
const res1 = await Promise.all([promise1, promise2])
const res2 = await Promise.all([promise3, promise4])
return [res1, res2]
}
runPromises()
.then(res => console.log(res))
.catch(err => console.log(err))
```
|
|
答え：`fromEntries`
`fromEntries`メソッドは2次元配列をオブジェクトに変換する。各サブ配列の最初の要素がキーになり、各サブ配列の2番目の要素が値になる。この場合、`keys` 配列をマッピングしているので、最初の要素が現在のインデックスの key 配列の項目で、2 番目の要素が現在のインデックスの values 配列の項目である配列を返します。
これにより、正しいキーと値を含む部分配列の配列が作成され、結果として `{ name: "Lydia", age: 22 }` となる。
|
check_code_behavor
| 452 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。name: "Lydia", age: 22 }`のログを記録するには、`method`の値をどうすればいいでしょうか？
```javascript
const keys = ["name", "age"]
const values = ["Lydia", 22]
const method = /* ?? */
Object[method](keys.map((_, i) => {
return [keys[i], values[i]]
})) // { name: "Lydia", age: 22 }
```
|
|
答え：`{ email: "[email protected]", address: {} }`
`address` のデフォルト値は空のオブジェクト `{}` である。変数 `member` に `createMember` 関数が返すオブジェクトを設定したとき、address には値を渡さなかった。空のオブジェクトは真理値であり、`address ? address : null` の条件式が `true` を返すことを意味する。addressの値は空のオブジェクト `{}` である。
|
check_code_behavor
| 453 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
const createMember = ({ email, address = {}}) => {
const validEmail = /.+\@.+\..+/.test(email)
if (!validEmail) throw new Error("Valid email pls")
return {
email,
address: address ? address : null
}
}
const member = createMember({ email: "[email protected]" })
console.log(member)
```
|
|
答え：`Yay it's a string!`
`if` 文の条件 `!typeof randomValue` の値が `"string"` に等しいかどうかをチェックする。演算子 `!` は値をブール値に変換する。値が真であれば戻り値は `false` となり、偽であれば戻り値は `true` となる。この場合、 `typeof randomValue` の戻り値は真理値 `"number"` であり、 `!typeof randomValue` の値は真偽値 `false` となる。
`typeof randomValue === "string"` は常に false を返します。条件が `false` を返したので、`else` ステートメントのコードブロックが実行され、`Yay it's a string!`がログを得ます。
|
check_code_behavor
| 454 |
MIT
|
javascript_questions
|
次に示すのはJavaScriptのコードです。何が出力されるでしょうか？
```javascript
let randomValue = { name: "Lydia" }
randomValue = 23
if (!typeof randomValue === "string") {
console.log("It's not a string!")
} else {
console.log("Yay it's a string!")
}
```
|
|
````julia
import LinearAlgebra as LA;
````
|
code_generation
| 455 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、LinearAlgebraというパッケージをLA名前でパッケージをインポートしなさい。
|
|
````julia
println(VERSION);
````
|
code_generation
| 456 |
The Unliscence
|
100_julia_exercises
|
Julia のバージョンを出力しなさい。
|
|
````julia
vA = Vector{Float64}(undef, 10)
````
|
code_generation
| 457 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、サイズ 10 の初期化されていないベクトルをFloat64で作成しなさい。
|
|
````julia
sizeof(vA)
````
|
code_generation
| 458 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、任意の配列（VA）のメモリ サイズを確認しなさい。
|
|
````julia
@doc +
````
|
code_generation
| 459 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、+(Add) メソッドのドキュメントを表示しなさい。
|
|
````julia
vA = zeros(10);
vA[5] = 1.0;
vA
````
|
code_generation
| 460 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、サイズ 10 のゼロのベクトルを作成し、5 番目の要素の値を1にしなさい。
|
|
````julia
vA = 7:12
````
ベクトルを明示的に作成する場合は以下のようになる。
````julia
vA = collect(7:12)
````
|
code_generation
| 461 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、7 から 12 までの範囲の値を持つベクトルを作成しなさい。
|
|
````julia
vA = collect(1:3);
vB = vA[end:-1:1];
vB
````
（別解）
````julia
vB = reverse(vA);
````
|
code_generation
| 462 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、ベクトルを反転しなさい(最初の要素が最後にする)。
|
|
````julia
mA = reshape(0:8, 3, 3)
````
別の方法は次のようになります。
````julia
mA = Matrix{Float64}(undef, 3, 3);
mA[:] = 0:8;
````
|
code_generation
| 463 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、3x3で値0 ～ 8 の範囲の値を含む行列を作成しなさい。
|
|
````julia
findall(!iszero, [1, 2, 0, 0, 4, 0])
````
|
code_generation
| 464 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、[1, 2, 0, 0, 4, 0]から非ゼロ要素のインデックスを見つけなさい。
|
|
````julia
mA = I(3)
````
代替方法 (明示的行列) は次のようになります。
````julia
mA = Matrix(I, 3, 3) #<! For Float64: Matrix{Float64}(I, 3, 3)
````
|
code_generation
| 465 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、3x3の単位行列を作成します。
|
|
````julia
mA = randn(2, 2, 2)
````
|
code_generation
| 466 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、2x2x2のランダムな値を含む配列を作成しなさい。
|
|
````julia
mA = rand(5, 5);
minVal = minimum(mA)
````
extrema()両方の値を一度に取得できます。
````julia
maxVal = maximum(mA)
````
|
code_generation
| 467 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、5x5のランダムな値を含む配列を作成し、最小値と最大値を見つけなさい。
|
|
````julia
meanVal = mean(randn(30))
````
|
code_generation
| 468 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、サイズ 30 のランダム ベクトルを作成し、平均値を見つけなさい。
|
|
````julia
mA = zeros(4, 4);
mA[:, [1, end]] .= 1;
mA[[1, end], :] .= 1;
mA
````
別の方法 (異なる次元)
````julia
mA = ones(4, 5);
mA[2:(end - 1), 2:(end - 1)] .= 0;
````
1 行のコードにすると、次のようになります。
````julia
mA = zeros(4, 5);
mA[[LinearIndices(mA)[cartIdx] for cartIdx in CartesianIndices(mA) if (any(cartIdx.I .== 1) || cartIdx.I[1] == size(mA, 1) || cartIdx.I[2] == size(mA, 2))]] .= 1;
````
|
code_generation
| 469 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、境界に 1、内側に 0 を含む 2 次元配列を作成しなさい。
|
|
````julia
mB = zeros(size(mA) .+ 2);
mB[2:(end - 1), 2:(end - 1)] = mA;
mB
````
|
code_generation
| 470 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、配列の周囲にゼロの境界線を追加して下さい。
|
|
Answer1.
````
NaN
````
Answer2.
````
false
````
Answer3.
````
false
````
Answer4.
````
NaN
````
|
code_generation
| 471 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、次の式を評価しなさい。
Question1.
````julia
0 * NaN
````
Question2.
````julia
NaN == NaN
````
Question3.
````julia
Inf > NaN
````
Question4.
````julia
NaN - NaN
````
|
|
````julia
mA = diagm(5, 5, -1 => 1:4)
````
|
code_generation
| 472 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、対角線のすぐ下の要素が[1, 2, 3, 4]になっている5x5の行列を作成しなさい。
|
|
````julia
mA = zeros(8, 8);
mA[2:2:end, 1:2:end] .= 1;
mA[1:2:end, 2:2:end] .= 1;
mA
````
|
code_generation
| 473 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、8x8のマトリックスを作成し、市松模様のパターンで塗りつぶしなさい。
|
|
````julia
mA = rand(6, 7, 8);
cartIdx = CartesianIndices(mA)[100]; #<! See https://discourse.julialang.org/t/14666
mA[cartIdx] == mA[100]
````
|
code_generation
| 474 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、線形インデックス 100 をサイズ の_Cartesianインデックス(6,7,8)に変換しなさい。
|
|
````julia
mA = repeat([0 1; 1 0], 4, 4)
````
|
code_generation
| 475 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`repeat()`関数を使って `8x8` のチェッカーボード行列を作成しなさい。
|
|
````julia
mA = rand(4, 4);
mA .= (mA .- mean(mA)) ./ std(mA) #<! Pay attention that `@.` will yield error (`std()` and `mean()`)
````
|
code_generation
| 476 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`4x4` のランダム行列を正規化しなさい。
|
|
````julia
struct sColor
R::UInt8;
G::UInt8;
B::UInt8;
A::UInt8;
end
sMyColor = sColor(rand(UInt8, 4)...)
````
|
code_generation
| 477 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、色を4つの符号なしバイト（`RGBA`）として記述するカスタム型を作成しなさい。
|
|
````julia
mA = rand(2, 4) * randn(4, 3)
````
|
code_generation
| 478 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`2x4` の行列と `4x3` の行列を乗算しなさい。
|
|
````julia
vA = rand(1:10, 8);
map!(x -> ((x > 3) && (x < 8)) ? -x : x, vA, vA)
````
|
code_generation
| 479 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、1次元の配列が与えられたとき、3より大きく8より小さい要素をすべてマイナスにしなさい。
|
|
````julia
sum(1:4, init = -10)
````
|
code_generation
| 480 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、配列 `1:4` を初期値 -10 で合計しなさい。
|
|
````julia
vZ .^ vZ
````
````
3-element Vector{Int64}:
387420489
387420489
46656
````
````julia
try
2 << vZ >> 2
catch e
println(e)
end
````
````
MethodError(<<, (2, [9, 9, 6]), 0x0000000000007f1f)
````
````julia
vZ <- vZ
````
````
false
````
````julia
1im * vZ
````
````
3-element Vector{Complex{Int64}}:
0 + 9im
0 + 9im
0 + 6im
````
````julia
vZ / 1 / 1
````
````
3-element Vector{Float64}:
9.0
9.0
6.0
````
````julia
vZ < vZ > vZ
````
````
false
````
|
code_generation
| 481 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、次の式を満たす整数ベクトル `vZ` を検証しなさい。
````julia
vZ = rand(1:10, 3);
````
```julia
vZ .^ vZ
2 << vZ >> 2
vZ <- vZ
1im * vZ
vZ / 1 / 1
vZ < Z > Z
```
|
|
````julia
[0] ./ [0]
````
````
1-element Vector{Float64}:
NaN
````
````julia
try
[0] .÷ [0]
catch e
println(e)
end
````
````
DivideError()
````
|
code_generation
| 482 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、次の式を評価しなさい。
````julia
[0] ./ [0]
````
````julia
try
[0] .÷ [0]
catch e
println(e)
end
````
|
|
````julia
vA = randn(10);
map(x -> x > 0 ? ceil(x) : floor(x), vA)
````
|
code_generation
| 483 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、float 配列(vA)をゼロから四捨五入しなさい。
vA = randn(10);
|
|
````julia
vA = rand(1:10, 6);
vB = rand(1:10, 6);
vA[findall(in(vB), vA)]
````
|
code_generation
| 484 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、2 つの配列間で共通の値を見つけなさい。
|
|
`Suppressor.jl`を使用することで対応できます。
|
code_generation
| 485 |
The Unliscence
|
100_julia_exercises
|
Juliaの警告を抑えて下さい。
|
|
````julia
try
sqrt(-1)
catch e
println(e)
end
````
|
code_generation
| 486 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`sqrt(-1)` と `sqrt(-1 + 0im)` を比較しなさい。
|
|
````julia
println("Yesterday: $(today() - Day(1))");
println("Today: $(today())");
println("Tomorrow: $(today() + Day(1))");
````
|
code_generation
| 487 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、昨日、今日、明日の日付を表示しなさい。
|
|
````julia
println("Yesterday: $(today() - Day(1))");
println("Today: $(today())");
println("Tomorrow: $(today() + Day(1))");
````
|
code_generation
| 488 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、2016 年 7 月に該当する日付をすべて表示しなさい。
|
|
````julia
mA = rand(2, 2);
mB = rand(2, 2);
mA .= ((mA .+ mB) .* (.-mA ./ 2))
````
|
code_generation
| 489 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`((mA + mB) * (-mA / 2))` を計算しなさい。
|
|
Option 1:
````julia
floor.(mA)
````
Option 2:
````julia
round.(mA .- 0.5) #<! Generates -0.0 for numbers smaller than 0.5
````
Option 3:
````julia
mA .÷ 1
````
Option 4:
````julia
mA .- rem.(mA, 1)
````
|
code_generation
| 490 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、4 つの異なる方法を使用して、正の数のランダムな配列(mA)の整数部分を抽出しなさい。
|
|
````julia
mA = repeat(reshape(0:4, 1, 5), 5, 1)
````
転置を使用して範囲のような行を生成することもできます。
````julia
mA = repeat((0:4)', 5, 1);
````
|
code_generation
| 491 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、5x5で値が 0 ～ 4 の範囲の行列を作成しなさい。
|
|
````julia
vA = LinRange(0, 1, 12)[2:(end - 1)]
````
|
code_generation
| 492 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、10 個の数値ジェネレーターを使用して配列を生成しなさい。
|
|
````julia
vA = LinRange(0, 1, 12)[2:(end - 1)]
````
|
code_generation
| 493 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、0 から 1 の範囲の値を含むサイズ 10 のベクトルを作成しなさい。
|
|
````julia
vA = rand(1:10, 10);
sort(vA) #<! Use `sort!()` for inplace sorting
````
|
code_generation
| 494 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、サイズ 10 のランダムなベクトルを作成し、並べ替えなさい。
|
|
````julia
vA = rand(100);
function MySum(vA::Vector{T}) where{T <: Number}
sumVal = vA[1];
for ii in 2:length(vA)
sumVal += vA[ii];
end
return sumVal;
end
MySum(vA)
````
|
code_generation
| 495 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、`sum()`関数を手動で実装しなさい。
|
|
````julia
vA = rand(10);
vB = rand(10);
all(vA .== vB)
````
|
code_generation
| 496 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、2 つの配列が等しいかどうかを確認しなさい。
|
|
````julia
try
convert(Float, convert(Int, NaN))
catch e
println(e)
end
````
````
InexactError(:Int64, Int64, NaN)
````
|
code_generation
| 497 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、次の式を評価しなさい。
````julia
try
convert(Float, convert(Int, NaN))
catch e
println(e)
end
````
|
|
````julia
mA = rand(10, 2);
ConvToPolar = vX -> [hypot(vX[1], vX[2]), atan(vX[2], vX[1])]
mB = [ConvToPolar(vX) for vX in eachrow(mA)]
````
|
code_generation
| 498 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、デカルト座標を表す10x2のランダム行列を考え、それらを極座標に変換しなさい。
|
|
````julia
vA = randn(10);
````
単一の最大値またはすべて異なる値の場合
````julia
vA[argmax(vA)] = 0;
vA
````
|
code_generation
| 499 |
The Unliscence
|
100_julia_exercises
|
Juliaを用いて、サイズ 10 のランダムなベクトルを作成し、最大値を 0 に置き換えなさい。
|
Subsets and Splits
Python Code Generation
Provides a structured view of code generation tasks specific to a Python-focused course, helping to understand the nature and sequence of the instructions and outputs.
Filtered Code Generation Tasks
The query extracts code generation questions and answers from a specific dataset source, offering structured insights into its contents.
Code Generation Instruction Split
The query processes and splits code generation outputs into separate answers, providing a structured view of potential alternative solutions for each instruction.
Filtered Code Generation Task
The query performs basic filtering and returns formatted data related to code generation tasks, which is helpful but does not provide deep insights into the dataset's underlying structure or patterns.
Code Generation Instructions
The query performs basic filtering to select code generation tasks and organizes them by license, source, and index, providing a simple overview but lacking deeper analytical insight.
Code Generation Instructions
The query performs basic filtering and selects specific columns, providing limited insight into the dataset's structure but not revealing deeper patterns or relationships.
Code Generation Instructions
The query performs basic filtering and selection, organizing code generation tasks by license and source but does not provide deep insights into the data.
^_Call_Call:::^_Call_Call:
The query performs basic filtering and selection, organizing code generation tasks by license, source, and index without revealing deeper insights.
^^^_Call.FromSeconds:^^ withheld^
The query performs basic filtering and ordering of dataset entries, providing a structured view but lacking deeper insights.
_Call^^^^^ serotonin^:^
The query performs basic data retrieval and organization, presenting specific fields in a structured format but without providing significant analytical insights.