非同期処理を挟み、`window.open()`を実行すると、ポップアップブロックに引っかかる。

（Reactで実装）

```ts
const handleClick = async () => {
  try {
    const url = await getURL() // 非同期処理
    open.window(url, '_blank')
  } catch (e) {
    console.error(e)
  }
}
```

とにかく別タブで開きたい。

## 回避策1

先に空のwindowを開き、後でurlを入れる。

errorなどでcloseなどを行う。

（手元のChrome,Safari,Edge,Firefoxでは機能した）

```ts
const handleClick = async () => {
  try {
    let openWindow = window.open('', '_blank')
    const url = await getURL() // 非同期処理
    openWindow.localtion.href = openWindow
  } catch (e) {
    openWindow.close()
    console.error(e)
  }
}
```

https://stackoverflow.com/questions/2587677/avoid-browser-popup-blockers#answer-25050893

## 回避策2

諦めて、処理を分ける。

```ts
const [targetURL, setTargetURL] = useState('')

const handleGenerateURL = async () => {
    try {
    const url = await getURL() // 非同期処理
    setTargetURL(url)
  } catch (e) {
    console.error(e)
  }
}

const handleClick = async () => {
  targetURL && window.open(targetURL, '_blank')
}
```

## 回避策3

`useEffect()`を使用して、`{ href && <a href={href} />}`のようにセットしておく

window.open時のポップアップブロックの回避

```js
const arr = [
  {
    id: 1,
    age: 18
  },
  {
    id: 2,
    age: 20
  }
];

// idが消える
const output = arr.map(({ id, ...a }) => a);
console.log("output:", output);
```

[javascript - スプレッド演算子からプロパティを削除するには? - スタックオーバーフロー](https://stackoverflow.com/questions/56155922/how-to-delete-property-from-spread-operator)

[Destructuring assignment - JavaScript | MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Rest_in_Object_Destructuring)

JS Objectの配列から特定のKeyを消す

## 特定の単語を抽出する

[danger/danger-js: ⚠️ Stop saying "you forgot to …" in code review](https://github.com/danger/danger-js)などで抽出するときに使用する。

```js
const keyword = "lookup";
const content = "aaaa lookup"
console.log('1:',content.match(new RegExp(`\b${keyword}\b`))) // Bad
console.log('2:', content.match(new RegExp(`\\b${keyword}\\b`))) // Good

// https://stackoverflow.com/questions/25938990/regex-b-word-boundary-not-works
const keyword2 = "lookup";
const content2 = "aaaa \blookup\b"
console.log('2-1:',content2.match(new RegExp(`\b${keyword2}\b`))) // match
```

`\b`: 単語境界マッチ。空白のことかな？

テンプレートリテラルが最初に実行されるのでエスケープしないといけない？

https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/RegExp#%E3%82%B3%E3%83%B3%E3%82%B9%E3%83%88%E3%83%A9%E3%82%AF%E3%82%BF%E3%83%BC%E3%81%AE%E3%83%95%E3%83%A9%E3%82%B0 書いてあった

> コンストラクター関数を使用する場合は、通常の文字エスケープ規則 (文字列内に特殊文字が含まれるとき、前に \ を付加する) が必須です。

JS 正規表現まとめ

- [regex - Using JavaScript to check whether a string contains Japanese characters (including kanji) - Stack Overflow](https://stackoverflow.com/questions/15033196/using-javascript-to-check-whether-a-string-contains-japanese-characters-includi)
- [Unicode Kanji Code Table](http://www.rikai.com/library/kanjitables/kanji_codes.unicode.shtml)

```ts
// ひらがな・全角カタカナ・漢字・アルファベットを許容
value.match(/^[a-zA-Z\u3040-\u309f\u30a0-\u30ff\u4e00-\u9faf\u3400-\u4dbf]+$/))
```

全角１や全角！を排除しやすくするために、半角カタカナも排除している。

 JS 日本語のバリデーション

JSで最後の文字列を取得する

https://github.com/remarkjs/react-markdown

[GitHub](https://github.com/remarkjs/react-markdown)

Markdownでいい感じにOGPを表示する

再起関数を書く機会にパフォーマンスが気になったのでメモ。

```js
const startTime = performance.now(); // 開始時間
someFunc(); // 計測する処理
const endTime = performance.now(); // 終了時間
console.log(endTime - startTime); // 何ミリ秒かかったかを表示する
```

計測結果

```
map: 0.19999998807907104
for: 0.7000000476837158
```

結論: mapの方が早い

forEachとfor...ofとforの中では、forEachが一番パフォーマンスがよく。forEachとmapでは、mapの方が良いみたい。

他のもの

```ts
if (Array.isArray(action.payload)) {
  state.items = [...state.items, ...action.payload]
} else {
  state.items = [...state.items, action.payload]
}
```

```ts
const payload = action.payload
const pushed = Array.isArray(payload) ? payload : [payload]
state.items.push(...pushed)
```

```
0.20000004768371582
0.30000007152557373
```

- [Performance of JavaScript .forEach, .map and .reduce vs for and for..of](https://leanylabs.com/blog/js-forEach-map-reduce-vs-for-for_of/)
- [JavaScriptで任意の処理にかかる時間を計測する](https://sbfl.net/blog/2017/12/01/javascript-measure-time/)


JSで関数の実行時間を調べる

## 問題

重い処理と軽い処理が混在するケースで、いい感じにローディングを表示させたいが、__処理が早い場合、ローディングがチラついてしまう。__

## 解決策

処理が早すぎる場合を考慮して、`1000ms(1秒)　-　実行時間`表示を遅延させ、`1000ms以上`実行時間がある場合は、遅延時間`0ms`にする。

## コード

```tsx
const [isLoading, setIsLoading] = useState(false)

const handleUpdate = () => {
  setIsLoading(true) // ローディング状態にする
  const startTime = new Date().getTime()　// 計測開始時間
  dispatch(update())
    .then(() => {})
    .catch(() => {})
    .finally(() => {
      const currentTime = new Date().getTime()　// 計測終了時間
      const executionTime = currentTime - startTime　// 実行時間
      const delayTime = 1000 - executionTime　// 表示を遅延させる時間
      // ローディング状態を解除する
      setTimeout(() => setIsLoading(false), Math.max(delayTime, 0))
    })
}
```

### ショートコード

```tsx
setTimeout(() => setIsLoading(false), Math.max(1000 - (currentTime - startTime), 0))
```

## hooksを作る

凝縮性

[javascript-useStatesetメソッドは変更をすぐには反映しません-StackOverflow](https://stackoverflow.com/questions/54069253/the-usestate-set-method-is-not-reflecting-a-change-immediately)

```ts
import { useState } from 'react'

export const useLoading = () => {
  const [isLoading, setIsLoading] = useState(false)
  let startTime = 0

  const startLoading = () => {
    setIsLoading(true)
    startTime = new Date().getTime()
  }

  /**
   * ローディングを終了する
   * @param minWaitTime ローディングが完了するまでの最小待ち時間
   */
  const endLoading = (minWaitTime: number = 1000) => {
    const currentTime = new Date().getTime()
    const executionTime = currentTime - startTime
    const delayTime = minWaitTime - executionTime
    setTimeout(() => {
      setIsLoading(false)
      startTime = 0
    }, Math.max(delayTime, 0))
  }

  return { isLoading, startLoading, endLoading }
}

```

## 解説

実行時間が1000ms以下の場合、`delayTime`は、`0 ~ 999`の値になる。

実行時間が1000ms以上の場合、`delayTime`は、`-(マイナス)`になるので、`Math.max(delayTime, 0))`で0が返され、遅延時間が0msになる。

## 参考

- [Math.max() - JavaScript | MDN](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Math/max)
- [javascript-useStatesetメソッドは変更をすぐには反映しません-StackOverflow](https://stackoverflow.com/questions/54069253/the-usestate-set-method-is-not-reflecting-a-change-immediately)

JavaScript 実行時間・遅延時間の計算

## Formula

1, 1, 2, 3, 5, 8, 13, 21.... と続いていく数式

$
Fn = Fn-1 + Fn-2 
$

## Noob

```js
function fib(n) {
  if (n === 0 || n === 1) {
    return 1;
  } else {
    return fib(n - 1) + fib(n - 2);
  }
}

// 出力
console.log(fib(0)); // 1
console.log(fib(1)); // 1
console.log(fib(2)); // 2
console.log(fib(3)); // 3
console.log(fib(4)); // 5
console.log(fib(50)); // stackoverflow
```

> スタックオーバーフロー ≒ メモリ不足。コールスタックを超えていった

## Student

```ts
const fib = (n: number): number => (n <= 1 ? n : fib(n - 1) + fib(n - 2));

console.log("fib:", fib(50)); // stackoverflow
```

## Expert

```ts
  const memoFib = (n: number) => {
    const memo = new Map();
    memo.set(0, 0);
    memo.set(1, 1);
    const fib_ = (n: number) => {
      if (memo.has(n)) {
        return memo.get(n);
      }
      const result: number = fib_(n - 1) + fib_(n - 2);
      memo.set(n, result);
      return result;
    };
    return fib_(n);
  };

  console.log(memoFib(50)); // 👌
```

## 学び

- __参照透過性__: 入力(渡す値)が同じであれば、出力（戻り値）が同じであるという性質
- __副作用__: 関数とは引数を受け取り、値を返すものである。それ以外の振る舞いを副作用と名付けた。望まれない子か救世主か。それは、生みの親に委ねられた。子供に罪はないと人々は豪語する。
- __純粋関数__: 副作用のないピュアな関数 


JavaScript フィボナッチでスタックオーバーフローをちょっと観察

```js
const getLengthOfOptiomalCompression = function(str) {
  if (str.length === 0) {
    console.log('Please enter valid string.');
    return;
  }

  let output = '';
  let count = '';
  for (let i = 0; i < str.length; i++) {
    count++;
    if (str[i] !== str[i+1]) {
      output += str[i] + count;
      count = 0;
    }
  }
  console.log(output);
}

getLengthOfOptiomalCompression('aaaa');
getLengthOfOptiomalCompression('aaaabbccddd');

```

JavaScript Run-length encoding

- [クロージャ - JavaScript | MDN](https://developer.mozilla.org/ja/docs/Web/JavaScript/Closures)
- [You-Dont-Know-JS/README.md at 2nd-ed · getify/You-Dont-Know-JS](https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/scope-closures/README.md)

> クロージャは「関数」と「その関数が作られた環境」という 2 つのものの組み合わせです。

```js
function makeFunc(name) {
  return function(age) {
    return `${name}の年齢は、${age}ですね！`;
  };
}

const func1 = makeFunc("田中太郎");
const func2 = makeFunc("山田太郎");

console.log(func1(22)); // 田中太郎の年齢は、22ですね！
console.log(func2(23)); // 山田太郎の年齢は、23ですね！
```

## クロージャでプライベートメソッドの模倣

```js
// Module Pattern
const counterModule = (function() {
  let count = 0;

  return {
    increment: function() {
      count++;
    },
    show: function() {
      console.log(count);
    }
  };
})();

counterModule.show(); // 0
counterModule.increment();
counterModule.show(); // 1
console.log(count); // ReferenceError: count is not defined
```

[IIFE (Immediately Executed Function Expression) --MDN Web Docs Glossary: Definition of Web-related Terms | MDN](https://developer-mozilla-org.translate.goog/ja/docs/Glossary/IIFE?_x_tr_sl=ja&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=nui,sc)

Bad Case:

> アロー関数 call、apply、bind のような、一般にスコープの設定のためのメソッドには適していません。

[アロー関数式 - JavaScript | MDN](https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Functions/Arrow_functions)

JavaScript Closure

```js
str = "http://example.com";
str = str.replace("http://", "https://");

console.log(str);
// "https://example.com"
```

正規表現で先頭だけでも良いかも

JavaScript http https replace

```js
let lastElement = array.slice(-1)[0];
// or 
let lastElement = array[array.length - 1];
```

JavaScript 配列の最後の要素 取得

```js
const str = "-";
const valid = /^[0-9a-zA-Z\-]*$/.test(str);

console.log(valid);
// true
```

JavaScript 半角英数字ハイフンのみ

```js
// 予約リスト(APIから取得した想定)
const reservationList = [
  { startTime: new Date('2021-10-01 09:00:00'), endTime: new Date('2021-10-01 10:00:00') },
  { startTime: new Date('2021-10-01 10:00:00'), endTime: new Date('2021-10-01 11:00:00') },
  { startTime: new Date('2021-10-01 14:00:00'), endTime: new Date('2021-10-01 15:00:00') },
];

/**
 * 予約可能かを判定して返す
 * 予約リストにレコードがない場合は、予約できる true
 * 予約リストにレコードがある場合は、予約できない false
 * @param {Object} params
 * @param {Date} params.startTime - 予約の開始時間
 * @param {Date} params.endTime - 予約の終了時間
 * @returns {boolean}
 */
function searchReservation(params) {
  const { startTime, endTime } = params;

  let canReserve = true;
  for (reservation of reservationList) {
    // 予約可能な条件の逆の場合、予約できないフラグを立てる
    if (!((reservation.endTime <= startTime) || (endTime <= reservation.startTime))) {
      canReserve = false;
      break; // falseになった場合、ループを終了する
    };
  }
  return canReserve;
};

// 実行
// 予約が埋まっていない場合、true
console.log(searchReservation({
  startTime: new Date('2021-10-01 11:00:00'),
  endTime: new Date('2021-10-01 12:00:00')
})); // true

// 予約が埋まっている場合、false
console.log(searchReservation({
  startTime: new Date('2021-10-01 09:00:00'),
  endTime: new Date('2021-10-01 10:00:00')
})); // false
```