JavaScript

2020.12.21

JavascriptのPromise.all()が並列処理していることの確認

'use strict';

const p = console.log;

const startTime = Date.now();

const timeoutPromise = (ms, callback) => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(callback());
    }, ms);
  });
};

const getTimeLapse = () => {
  const lapse = Date.now() - startTime;
  return `${lapse} ミリ秒経ちました`;
};

const promises = [];
promises.push(timeoutPromise(30, getTimeLapse));
promises.push(timeoutPromise(15, getTimeLapse));
promises.push(timeoutPromise(10, getTimeLapse));

Promise.all(promises).then(results => {
  p(results);
  p(getTimeLapse());
});

'use strict';

const p = console.log;

const startTime = Date.now();

const timeoutPromise = (ms, callback) => {

return new Promise(resolve => {

setTimeout(() => {

resolve(callback());

}, ms);

});

};

const getTimeLapse = () => {

const lapse = Date.now() - startTime;

return `${lapse} ミリ秒経ちました`;

};

const promises = [];

promises.push(timeoutPromise(30, getTimeLapse));

promises.push(timeoutPromise(15, getTimeLapse));

promises.push(timeoutPromise(10, getTimeLapse));

Promise.all(promises).then(results => {

p(results);

p(getTimeLapse());

});

[ '31 ミリ秒経ちました', '16 ミリ秒経ちました', '11 ミリ秒経ちました' ]
35 ミリ秒経ちました

1 2	[ '31 ミリ秒経ちました', '16 ミリ秒経ちました', '11 ミリ秒経ちました' ] 35 ミリ秒経ちました

2020.12.11

テンキーのないキーボードにテンキーをもたらすスクリプト

const p = console.log;
const map = {
  ' ': 0,
  'm': 1,
  ',': 2,
  '.': 3,
  'j': 4,
  'k': 5,
  'l': 6,
  'u': 7,
  'i': 8,
  'o': 9,
};
const c2n = c => {
  return map[c];
};
const c2nLine = str => {
  let s = '';
  for (const c of str) {
    s += c2n(c);
  }
  return s;
};
p(c2nLine(' m,.jkluio')); // 0123456789
p(c2nLine('oiulkj.,m ')); // 9876543210
p(c2nLine(' ..,  ,,,,')); // 0332002222

const p = console.log;

const map = {

' ': 0,

'm': 1,

',': 2,

'.': 3,

'j': 4,

'k': 5,

'l': 6,

'u': 7,

'i': 8,

'o': 9,

};

const c2n = c => {

return map[c];

};

const c2nLine = str => {

let s = '';

for (const c of str) {

s += c2n(c);

}

return s;

};

p(c2nLine(' m,.jkluio')); // 0123456789

p(c2nLine('oiulkj.,m ')); // 9876543210

p(c2nLine(' .., ,,,,')); // 0332002222

0123456789
9876543210
0332002222

0123456789

9876543210

0332002222

2020.12.04

nodejsでimage-1.jpgから100.jpgにリネームするスクリプト

相対パス ./testdir 配下に image-1.jpg から image-777.jpg まであるファイルをそれぞれ 001.jpg から 777.jpg にリネームするスクリプト

'use strict';

const fs = require('fs');

const p = console.log;

const rename = (fs, oldFilePath, newFilePath) => {
  fs.rename(oldFilePath, newFilePath, (err) => {
    err ? p(err) : null;
  });
};

const getPaddedStr = (n) => {
  if (n < 10) {
    return '00' + n;
  }
  if (n < 100) {
    return '0' + n;
  }
  return '' + n;
};

/** image-1.jpg -> 100.jpg */
const getNewFileName = (oldFileName) => {
  const _1_jpg = oldFileName.split('-')[1];
  const _1_jpgArr = _1_jpg.split('.');
  const num = _1_jpgArr[0];
  const ext = _1_jpgArr[1];
  const newFileName = getPaddedStr(num) + '.' + ext;
  return newFileName;
};

const renameForFiles = (rPath, files) => {
  files.forEach((oldFileName) => {
    const newFileName = getNewFileName(oldFileName);
    const oldFilePath = rPath + '/' + oldFileName;
    const newFilePath = rPath + '/' + newFileName;
    rename(fs, oldFilePath, newFilePath);
    p(oldFilePath + ' => ' + newFilePath);
  });
};

const rPath = './testdir';

fs.readdir(rPath, (err, files) => {
  if (err) throw err;

  renameForFiles(rPath, files);
});

'use strict';

const fs = require('fs');

const p = console.log;

const rename = (fs, oldFilePath, newFilePath) => {

fs.rename(oldFilePath, newFilePath, (err) => {

err ? p(err) : null;

});

};

const getPaddedStr = (n) => {

if (n < 10) {

return '00' + n;

}

if (n < 100) {

return '0' + n;

}

return '' + n;

};

/** image-1.jpg -> 100.jpg */

const getNewFileName = (oldFileName) => {

const _1_jpg = oldFileName.split('-')[1];

const _1_jpgArr = _1_jpg.split('.');

const num = _1_jpgArr[0];

const ext = _1_jpgArr[1];

const newFileName = getPaddedStr(num) + '.' + ext;

return newFileName;

};

const renameForFiles = (rPath, files) => {

files.forEach((oldFileName) => {

const newFileName = getNewFileName(oldFileName);

const oldFilePath = rPath + '/' + oldFileName;

const newFilePath = rPath + '/' + newFileName;

rename(fs, oldFilePath, newFilePath);

p(oldFilePath + ' => ' + newFilePath);

});

};

const rPath = './testdir';

fs.readdir(rPath, (err, files) => {

if (err) throw err;

renameForFiles(rPath, files);

});

2020.12.02

ジェネレータ関数はアロー関数でラップして使える

'use strict';

const p = console.log;

const generatorFunction = function* () {
  yield 1;
  yield 2;
  yield 3;
};

const generatorArrowFunction = () => {
  const generatorInnerFunction = function* () {
    yield 1;
    yield 2;
    yield 3;
  };
  return generatorInnerFunction();
};

const generator3main = () => {
  const g1 = generatorFunction();
  const g2 = generatorArrowFunction();

  p(g1.next().value);
  p(g1.next().value);
  p(g1.next().value);
  p(g1.next().value);

  p(g2.next().value);
  p(g2.next().value);
  p(g2.next().value);
  p(g2.next().value);
};

// module.exports = generator3main;
generator3main();

'use strict';

const p = console.log;

const generatorFunction = function* () {

yield 1;

yield 2;

yield 3;

};

const generatorArrowFunction = () => {

const generatorInnerFunction = function* () {

yield 1;

yield 2;

yield 3;

};

return generatorInnerFunction();

};

const generator3main = () => {

const g1 = generatorFunction();

const g2 = generatorArrowFunction();

p(g1.next().value);

p(g2.next().value);

};

// module.exports = generator3main;

generator3main();

1
2
3
undefined
1
2
3
undefined

undefined

2020.12.02

自作のイテラブルなオブジェクトをジェネレータ関数から返してみる

// 自作のイテラブルなオブジェクトをジェネレータ関数から返してみる
'use strict';

const p = console.log;

const getIterableObject = () => {
  const iterableObject = {
    [Symbol.iterator]: () => {
      let cnt = 0;
      const iterator = {
        next: () => {
          if (cnt < 5) {
            return { value: cnt++, done: false };
          }
          return { value: undefined, done: true };
        },
      };
      return iterator;
    },
  };
  return iterableObject;
};

const simpleGeneratorFunction = (iterableObject) => {
  return (function* (iterableObjectParameter) {
    yield* iterableObjectParameter;
  })(iterableObject);
};

const generator2main = () => {
  const myIteratorObject1 = getIterableObject();
  p(...simpleGeneratorFunction(myIteratorObject1));
  p(...simpleGeneratorFunction(myIteratorObject1));
  p(...simpleGeneratorFunction(myIteratorObject1));
};

// module.exports = generator2main;
generator2main();

// 自作のイテラブルなオブジェクトをジェネレータ関数から返してみる

'use strict';

const p = console.log;

const getIterableObject = () => {

const iterableObject = {

[Symbol.iterator]: () => {

let cnt = 0;

const iterator = {

next: () => {

if (cnt < 5) {

return { value: cnt++, done: false };

}

return { value: undefined, done: true };

};

return iterator;

};

return iterableObject;

};

const simpleGeneratorFunction = (iterableObject) => {

return (function* (iterableObjectParameter) {

yield* iterableObjectParameter;

})(iterableObject);

};

const generator2main = () => {

const myIteratorObject1 = getIterableObject();

p(...simpleGeneratorFunction(myIteratorObject1));

};

// module.exports = generator2main;

generator2main();

0 1 2 3 4
0 1 2 3 4
0 1 2 3 4

0 1 2 3 4

2020.11.29

JavaScriptのコンストラクタは、子クラスのインスタンス化を検知できる

'use strict';

const p = console.log;

/**
 * Abstract Class Animal.
 *
 * @class Animal
 */
class Animal {
  constructor() {
    p(this.constructor, 'Animalのコンストラクタ');
  }
}

/**
 * Concrete Class Cat.
 *
 * @class Cat
 */
class Cat extends Animal {
  constructor() {
    super();

    p(this.constructor, 'Catのコンストラクタ');
  }
}

/**
 * Concrete Class Mike.
 *
 * @class Mike
 */
class Mike extends Cat {
  constructor() {
    super();

    p(this.constructor, 'Mikeのコンストラクタ');
  }
}

const constructorsTest1 = () => {
  p('Mikeのインスタンス化前', new Mike(), 'Mikeのインスタンス化後');
};

// module.exports = constructorsTest1;
constructorsTest1();

'use strict';

const p = console.log;

/**

* Abstract Class Animal.

* @class Animal

class Animal {

constructor() {

p(this.constructor, 'Animalのコンストラクタ');

}

/**

* Concrete Class Cat.

* @class Cat

class Cat extends Animal {

constructor() {

super();

p(this.constructor, 'Catのコンストラクタ');

}

/**

* Concrete Class Mike.

* @class Mike

class Mike extends Cat {

constructor() {

super();

p(this.constructor, 'Mikeのコンストラクタ');

}

const constructorsTest1 = () => {

p('Mikeのインスタンス化前', new Mike(), 'Mikeのインスタンス化後');

};

// module.exports = constructorsTest1;

constructorsTest1();

[class Mike extends Cat] Animalのコンストラクタ
[class Mike extends Cat] Catのコンストラクタ
[class Mike extends Cat] Mikeのコンストラクタ
Mikeのインスタンス化前 Mike {} Mikeのインスタンス化後

[class Mike extends Cat] Animalのコンストラクタ

[class Mike extends Cat] Catのコンストラクタ

[class Mike extends Cat] Mikeのコンストラクタ

Mikeのインスタンス化前 Mike {} Mikeのインスタンス化後

2020.11.25

JSの分割代入の練習

'use strict';

const p = console.log;
const getArray = () => [123, () => 'hello', 'あいう'];

const [a, b] = getArray();
const [c, d, e, f] = getArray();

p('a b() :', a, b());
p('c d() e f :', c, d(), e, f);

'use strict';

const p = console.log;

const getArray = () => [123, () => 'hello', 'あいう'];

const [a, b] = getArray();

const [c, d, e, f] = getArray();

p('a b() :', a, b());

p('c d() e f :', c, d(), e, f);

a b() : 123 hello
c d() e f : 123 hello あいう undefined

1 2	a b() : 123 hello c d() e f : 123 hello あいう undefined

2020.11.24

自作のイテレータを自作のジェネレータ関数にかけてみる

/* 自作のイテレータを自作のジェネレータ関数にかけてみる */
'use strict';

const p = console.log;

const generatorFunction = function* (a) {
  yield* a;
};

const createIterableObject = () => {
  const iterableObject = {
    [Symbol.iterator]: () => {
      let cnt = 0;
      const iterator = {
        next: () => {
          if (cnt < 5) {
            return { value: cnt++, done: false };
          }
          return { value: undefined, done: true };
        },
      };
      return iterator;
    },
  };
  return iterableObject;
};

const mainIteratorAndGenerator = () => {
  const myIterableObject = createIterableObject();
  const myGenerator = generatorFunction(myIterableObject);
  p(...myGenerator); // 0 1 2 3 4
  p(...myGenerator); //
  p(...myIterableObject); // 0 1 2 3 4
  p(...myIterableObject); // 0 1 2 3 4
};

// module.exports = mainIteratorAndGenerator;
mainIteratorAndGenerator();

/* 自作のイテレータを自作のジェネレータ関数にかけてみる */

'use strict';

const p = console.log;

const generatorFunction = function* (a) {

yield* a;

};

const createIterableObject = () => {

const iterableObject = {

[Symbol.iterator]: () => {

let cnt = 0;

const iterator = {

next: () => {

if (cnt < 5) {

return { value: cnt++, done: false };

}

return { value: undefined, done: true };

};

return iterator;

};

return iterableObject;

};

const mainIteratorAndGenerator = () => {

const myIterableObject = createIterableObject();

const myGenerator = generatorFunction(myIterableObject);

p(...myGenerator); // 0 1 2 3 4

p(...myGenerator); //

p(...myIterableObject); // 0 1 2 3 4

};

// module.exports = mainIteratorAndGenerator;

mainIteratorAndGenerator();

0 1 2 3 4

2020.11.23

JavaScriptのGenerator(ジェネレータ)の練習

'use strict';

const p = console.log;

// ジェネレータはアロー関数にできないとのこと
const gfn = function* (from, to) {
  while (from <= to) {
    yield from++;
  }
};

const mainGenerator = () => {
  const g = gfn(0, 4);

  const iterator1 = g[Symbol.iterator]();
  const iterator2 = g[Symbol.iterator]();

  p(iterator1 === g); // true
  p(iterator2 === g); // true

  p(iterator1.next()); // { value: 0, done: false }
  p(iterator1.next()); // { value: 1, done: false }
  p(iterator1.next()); // { value: 2, done: false }
  p(iterator1.next()); // { value: 3, done: false }
  p(iterator1.next()); // { value: 4, done: false }
  p(iterator1.next()); // { value: undefined, done: true }

  p(iterator2.next()); // { value: undefined, done: true }
  p(iterator2.next()); // { value: undefined, done: true }
  p(iterator2.next()); // { value: undefined, done: true }
  p(iterator2.next()); // { value: undefined, done: true }
  p(iterator2.next()); // { value: undefined, done: true }
  p(iterator2.next()); // { value: undefined, done: true }
};

// module.exports = mainGenerator;
mainGenerator();

'use strict';

const p = console.log;

// ジェネレータはアロー関数にできないとのこと

const gfn = function* (from, to) {

while (from <= to) {

yield from++;

}

};

const mainGenerator = () => {

const g = gfn(0, 4);

const iterator1 = g[Symbol.iterator]();

const iterator2 = g[Symbol.iterator]();

p(iterator1 === g); // true

p(iterator2 === g); // true

p(iterator1.next()); // { value: 0, done: false }

p(iterator1.next()); // { value: 1, done: false }

p(iterator1.next()); // { value: 2, done: false }

p(iterator1.next()); // { value: 3, done: false }

p(iterator1.next()); // { value: 4, done: false }

p(iterator1.next()); // { value: undefined, done: true }

p(iterator2.next()); // { value: undefined, done: true }

};

// module.exports = mainGenerator;

mainGenerator();

true
true
{ value: 0, done: false }
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }
{ value: undefined, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }
{ value: undefined, done: true }

true

{ value: 0, done: false }

{ value: 1, done: false }

{ value: 2, done: false }

{ value: 3, done: false }

{ value: 4, done: false }

{ value: undefined, done: true }

2020.11.23

JavaScriptのIterator(イテレータ)の練習

'use strict';

const p = console.log;

const myIterableObject = {
  [Symbol.iterator]: () => {
    let cnt = 0;
    const iterator = {
      next: () => {
        const done = 5 <= cnt;
        return { value: cnt++, done };
      },
    };
    return iterator;
  },
};

const processIterable = (iterableObject, callback) => {
  const iterator = iterableObject[Symbol.iterator]();
  let ir = iterator.next();
  while (!ir.done) {
    callback(ir);
    ir = iterator.next();
  }
};

const mainIterator = () => {
  p(...myIterableObject);
  p(...myIterableObject);

  processIterable(myIterableObject, p);
  processIterable(myIterableObject, p);
};

// module.exports = mainIterator;
mainIterator();

'use strict';

const p = console.log;

const myIterableObject = {

[Symbol.iterator]: () => {

let cnt = 0;

const iterator = {

next: () => {

const done = 5 <= cnt;

return { value: cnt++, done };

};

return iterator;

};

const processIterable = (iterableObject, callback) => {

const iterator = iterableObject[Symbol.iterator]();

let ir = iterator.next();

while (!ir.done) {

callback(ir);

ir = iterator.next();

}

};

const mainIterator = () => {

p(...myIterableObject);

processIterable(myIterableObject, p);

};

// module.exports = mainIterator;

mainIterator();

0 1 2 3 4
0 1 2 3 4
{ value: 0, done: false }
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }
{ value: 0, done: false }
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }

0 1 2 3 4

{ value: 0, done: false }

{ value: 1, done: false }

{ value: 2, done: false }

{ value: 3, done: false }

{ value: 4, done: false }

{ value: 0, done: false }

{ value: 1, done: false }

{ value: 2, done: false }

{ value: 3, done: false }

{ value: 4, done: false }

1 234 5 6 7

JavaScript

JavascriptのPromise.all()が並列処理していることの確認

テンキーのないキーボードにテンキーをもたらすスクリプト

nodejsでimage-1.jpgから100.jpgにリネームするスクリプト

ジェネレータ関数はアロー関数でラップして使える

自作のイテラブルなオブジェクトをジェネレータ関数から返してみる

JavaScriptのコンストラクタは、子クラスのインスタンス化を検知できる

JSの分割代入の練習

自作のイテレータを自作のジェネレータ関数にかけてみる

JavaScriptのGenerator(ジェネレータ)の練習

JavaScriptのIterator(イテレータ)の練習

最近の投稿

サイトマップ

カテゴリー

アーカイブ

人気の投稿とページ

Twitter