// 以下のようなもの
12
1.2
'Hello'
true

return
true; 
// 上記は return; true; というふうに解釈されてしまう 

let y = x + f
(a+b).toString()
// 上記も同じ let y = x + f(a+b).toString() と解釈される
// 構文によっては、予期せぬエラーになる。

// 基本型は不変である
// 文字列を変更するように見えるが、文字列そのものを変更するのではなく、新たな文字列を返す
let s = "hello";
s.toUpperCase(); // "HELLO" と値が返される
s // => "hello" : 元の文字列は変更されない

// オブジェクト・配列は可変である。
let o = { x: 1 };
o.x = 2 // 2 
// プロパティの値を変更して、オブジェクトを更新する

// 配列も可変
// ただし、2つのオブジェクトは同じプロパティを持ち、値が同じだったとしても異なるオブジェクトとして判断される;
let a = [1, 2, 3]
o === p // false
// 別々の空の配列
let a = [], b = [];
a === b // false

let x = 1;
if (x === 1) {
  let x = 2;
  console.log(x);
  // expected output: 2
}
console.log(x);
// expected output: 1

var x = 1;
if (x === 1) {
  var x = 2;
  console.log(x);
  // expected output: 2
}
console.log(x);
// expected output: 2

var japan = true;
japan = false;
console.log(japan); // false
// 上記だと、再代入可能な変数。
// constが登場で定数で宣言できる(値が不変であることが証明できる)。

const japan = true;
japan = false;
// Uncaught TypeError: Assignment to constant variable.
// エラーになる

let square = function(x) {
  return x * x;
};
// ES6以降ではアロー関数をよく使用する

let o = {x:1, y: {z: 3}};
o.x // 1
o.y.z // 3

let a = { b: null };
a.b?.c.d // undefined

f(0); // 通常の関数呼び出し
// `null`や`undefined`のときに `// TypeError`が出る
f?.(); // このように呼び出せば、`null`や`undefined`のときに`undefined`を返す

// 等値演算子（`==`）
// オペランドが等しい場合に true を返す
let test = 3;
3 == test // true
"3" == test // true
3 == '3' // true

// 同値演算子(`===`)
// オペランドが等しく、かつ同じ型である場合に true を返す
let test = 3;
3 === test  // true
3 == '3' // false

// in演算子
// 左辺の値が右辺のオブジェクトのプロパティ名にあれば`true`を返す
let point = {x: 1, y:1}
"x" in point // true

// instanceof演算子
// 左辺のオブジェクトが右辺のクラスのインスタンスなら`true`を返す
let d = new Date();
d instanceof Date // true

// &&
// 両方`true`なら`true`を返す

// ||
// 一方または両方`true`なら`true`を返す

// !
// 論理値が反転する

// 三項演算子
// よく見るやつ
x > 0 ? x: -x // x

// ファーストデファインド演算子
// 左辺が`null`や`undefined`のときは左辺を返し、`null`や`undefined`のときは右辺を返す
let options = { timeout: 0 }
options.timeout ?? 1000 // 0
options.n ?? 1000 // 1000

// typeof演算子
データ型を表す文字列を返す
// P102一覧表参考に

// delete演算子
// 指定したオブジェクトやプロパティを削除する。ただし、長さは変わらないので注意が必要
let a = [1, 2, 3];
delete a[2];
2in a // false
a.length // 3 長さは変更されない
// 値が`undefined`に変更されるだけ

// カンマ演算子
i = 0, j = 1, k = 2;
// 上記と同じ
i = 0; j = 1; k = 2;

if (n === 1) {
  console.log('数値は1です。');
} else if (n === 2){
 console.log('数値は2です。');
} else {
 console.log('値が入力されていません');
}

// 値が多くないときは三項演算子を使用できる
const selectNum = n === 1 ? console.log('数値は1です。') : console.log('値が入力されていません');

switch(n) {
  // n === 1の場合
  case 1: 
    console.log('数値は1です。');
    break; // ここで中断する
  case 2:
    console.log('数値は2です。');
    break;
  default:
    // if文のelseと同じ役割
    console.log('値が入力されていません');
    break;
}
// その次の文~~~~

while (expression)
　statement

// countの値が変わらなければ無限ループになる
// 一般にfor文を使用する方が多い
let count  = 0;
while(count < 10){
  console.log(count);
  count ++;
}

for(initialize ; test ; increment)
  statement
// initialize ; test ; increment
// 初期化、テスト、更新

// より具体では以下のようになる
for (let count = 0; count < 10; count++) {
  console.log(count);
}

let i = 0;
while (i < 6) {
  if (i === 3) {
    break;
  }
  i = i + 1;
}
console.log(i);
// expected output: 3

let text = [];
for (let i = 0; i < 10; i++) {
  if (i === 3) {
    continue;
  }
  text.push(i);
}
console.log(text);
// expected output: Array [0, 1, 2, 4, 5, 6, 7, 8, 9]

function getRectArea(width, height) {
  if (width > 0 && height > 0) {
   return width * height;
  }
  return 0;
}
console.log(getRectArea(3, 4));
// expected output: 12
console.log(getRectArea(-3, 4));
// expected output: 0

// returnがないとundefinedを返す
function getRectArea(width, height) {
  if (width > 0 && height > 0) {
   width * height;
  }
  return 0;
}
console.log(getRectArea(3, 4));
// expected output: 0
console.log(getRectArea(-3, 4));
// expected output: 0

let myCar = {
  make: 'Ford',
  model: 'Mustang',
  year: 1969
}

// 以下のようにもオブジェクトを宣言することができる
// オブジェクトの初期化子を使用している。
// オブジェクト初期化子は、中括弧 ({}) で囲まれたオブジェクトのプロパティ名と関連する値の 0 個以上のペアをカンマで区切ったリストです。
lat myCar = new Object();
myCar.make = 'Ford';
myCar.model = 'Mustang';
myCar.yaer = 1969;

// オブジェクトに割り当てられていないプロパティは undefined を返す (null ではない)。
myCar.color; // undefined

// 2 つの変数は、同じプロパティを持つ 2 つの異なるオブジェクト
let fruit = {name: 'apple'};
let fruitbear = {name: 'apple'};

fruit == fruitbear; // false が返される
fruit === fruitbear; // false が返される

// 2 つの変数、オブジェクトは 1 つ
let fruit = {name: 'apple'};
let fruitbear = fruit;  // fruitbear に fruit オブジェクトへの参照を代入

// fruit と fruitbear は同じオブジェクトを指している
fruit == fruitbear; // true が返される
fruit === fruitbear; // true が返される

fruit.name = 'grape';
console.log(fruitbear); // { name: "apple" } ではなく { name: "grape" } と出力される

// 以下の文は同じ配列を生成する
let arr = new Array(element0, element1, ..., elementN)
let arr = Array(element0, element1, ..., elementN)
let arr = [element0, element1, ..., elementN]

// 空の配列の作り方（配列リテラル）
// すべて同じ意味
let arr = new Array()
let arr = Array()
let arr = []
// => undefinedを返す

let obj = {}
// ...
obj.prop = [element0, element1, ..., elementN]
// または
let obj = {prop: [element0, element1, ...., elementN]}

let arr = Array(9.3)   // RangeError: Invalid array length
// エラーになる

// `Array.of`メソッドを使用すれば使える
let wisenArray = Array.of(9.3)   // wisenArray は 1 つの要素 9.3 だけを持つ配列

let myArray = ['Wind', 'Rain', 'Fire']
console.log(myArray[0]) // => Wind

let emp = []
emp[0] = 'Casey Jones'
emp[1] = 'Phil Lesh'
emp[2] = 'August West'
// => ['Casey Jones', 'Phil Lesh', August West']

// pushメソッドを使用することでもできる
let emp = ['Casey Jones', 'Phil Lesh']
emp.push('August West')
// => ['Casey Jones', 'Phil Lesh', August West']

// 通常のforメソッドを使う
let colors = ['red', 'green', 'blue']
for (let i = 0; i < colors.length; i++) {
  console.log(colors[i])
}
// => red
// => green
// => blue

// forEach()メソッド
let colors = ['red', 'green', 'blue']
colors.forEach(function(color) {
  console.log(color)
})
// red
// green
// blue

// アロー関数でもっと短く記述できる
let colors = ['red', 'green', 'blue']
colors.forEach(color => console.log(color))
// red
// green
// blue

// 配列を定義する
let vegetables = ['キャベツ', 'かぶ', '大根', 'にんじん']
console.log(vegetables);
// => Array(4) [ "キャベツ", "かぶ", "大根", "にんじん" ]

 // スプレット演算子を使うと以下のようにfor文など使用しなくても出力できる。
console.log(...vegetables)
// => キャベツ
// => かぶ
// => 大根
// => にんじん

// スプレット演算子を使って配列をマージすることもできる。
let vegetables = ['キャベツ', 'かぶ', '大根', 'にんじん'];
let fruits = ['りんご', 'バナナ'];
const mergeFood = [...vegetables, ...fruits];
console.log(mergeFood);
// => Array(6) [ "キャベツ", "かぶ", "大根", "にんじん", "りんご", "バナナ" ]

// ほかにもこんな使い方もできる
let vegetables = ['キャベツ', 'かぶ', '大根', 'にんじん'];
let [firstFood, ...rest] = vegetables;
console.log(firstFood);
// => キャベツ
console.log(rest);
// => Array(3) [ "かぶ", "大根", "にんじん" ]

// 関数は無名にすることもできる
const square = function(number) { 
  return number * number;
}
var x = square(4); 
console.log(x); // x の値は 16 となる

// 名前を指定することで再帰的に使用する（自分自身を呼ぶ）こともできる
const factorial = function fac(n) { 
  return n < 2 ? 1 : n * fac(n - 1) 
}
console.log(factorial(3))

let a = [
  'Hydrogen',
  'Helium',
  'Lithium',
  'Beryllium'
];

// map() メソッドは、与えられた関数を配列のすべての要素に対して呼び出し、その結果からなる新しい配列を生成する。

// 通常の記述
let a2 = a.map(function(s) { return s.length; });
console.log(a2); // logs [8, 6, 7, 9]

// アロー関数
let a3 = a.map(s => s.length);
console.log(a3); // logs [8, 6, 7, 9]
// 関数本体がreturn文だけの場合は、returnとセミコロンを省略できる。

// アロー関数の引数が1つだけの場合は、丸括弧も省略できる
const polynomial = x => 
  x*x + 2*x + 3; 

//  引数のないアロー関数は、丸括弧を記述する必要がある
const constantFunc = () => 42;

// 関数を呼び出すとき
square(5);

 // 関数を呼び出すときはスコープ内になければいけませんが、次の例のように、関数の宣言を巻き上げる (呼び出しより後に置く) ことができる
console.log(square(5));
/* ... */
function square(n) { return n * n }

// 以下の変数はグローバルスコープで定義
let num1 = 20;
let num2 = 3;

// この関数はグローバルスコープで定義
function multiply() {
  return num1 * num2;
}
multiply(); // 60 を返す

// // 以下の変数はローカルスコープ（関数内）で定義
// この関数はグローバルスコープで定義
function multiply() {
  let num1 = 20;
  let num2 = 3;
  return num1 * num2;
}
multiply(); // 60 を返す
// 以下のように関数外で関数内で定義した変数を呼び出すとエラーになる
console.log(num1); // Uncaught ReferenceError: num1 is not defined

var pet = function(name) {   // 外側の関数は変数 "name" を定義
  var getName = function() {
    return name;             // 内側の関数は外側の関数の変数 "name" にアクセス可能
  }
  return getName;            // 内側の関数を返すことで、外側の関数に公開する
}
myPet = pet('Vivie');
myPet();

function multiply(a, b = 1) {
  return a * b;
}
multiply(5); // 5

function multiply(multiplier, ...theArgs) {
  return theArgs.map(x => multiplier * x);
}
var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]

function max(x) {
  let maxValue = -Infinity;
  for(let i = 0, i < arguments.length, i++){
    if(arguments[i] > maxValue) maxValue = arguments[i];
  }
  return maxValue;
}
max(1, 10, 100, 4, 5, 1000) // => 1000

function vectorAdd([x1, y1], [x2, y2]){
  return [x1 + x2, y1 + y2];
}
vectorAdd([1, 2], [3, 4]); // => [4, 6]

// メソッドチェーンを使用しないコード
const a = [ 1 , 2 , 3 , 4 ];
const result = a.map( value=>value*3 );
const result2 = result.filter( value => value % 2 === 0 );
const result3 = result2.join( "," );
console.log( result3 ); // 6,12

// メソッドチェーンを使用したコード
const a = [ 1 , 2 , 3 , 4 ];
const result = a.map( value=>value*3 ).filter( value => value % 2 === 0 ).join( "," ); 
console.log( result ); // 6,12

// 定数、変数、関数、クラスのエクスポートは宣言前にexportを追加する
export const PI = Math.PI;

// 複数をまとめてエクスポートする
export { Circle, degreesToRadians, PI };

// 値は1つの場合は以下のように記述するとインポートしやすくなる
export default class BitSet {
  // 実装...
}

// デフォルトエクスポートを定義しているモジュールをインポートするとき
import BitSet from './bitset.js';

// 複数の値をエクスポートするモジュールから値をインポートするとき
import { mean, stddev } from "./stats.js";

// インポートする値を変更したい場合
import { render as renderImage } from "./imageutils.js";

// 動的にインポートを利用する（ES2020）
// 通常のインポート
import * as stats from "./states.js";
// 動的にインポート
import("./stats.js").then(stats => {
  let average = stats.mean(date);
})