JS/ES – 関数式／無名関数／即時関数

2020-12-08 / tau / コメントする

関数式～関数の変数への代入

ユーザー定義関数はfunctionキーワードの後に関数名を指定して関数を定義し、その関数名で関数を呼び出して実行した。

これに対して、関数を変数に代入して、その変数名を用いて関数を実行することができる（関数式：function formula）。

func1 = function user_defined() {
  console.log('named function!');
}

func1();

// named function!

func1 = function user_defined() {

console.log('named function!');

}

func1();

// named function!

無名関数

このような使い方で、関数名自体を指定せずに関数の実体を変数に代入することもできる。

func2 = function () {
  console.log('anonymus function!');
}

func2();

// anonymous function!

func2 = function () {

console.log('anonymus function!');

}

func2();

// anonymous function!

このように名前を持たない関数を無名関数／匿名関数(anonymous function)と呼んでいる。

このような無名関数を変数に与える関数式は、メソッドや関数の引数に関数を与えることが想定されている場合に用いる。たとえばDOMに対するイベントリスナーの登録や、配列オブジェクトのreduce()メソッドに合計を計算するためのreducerを与える例など、その活用場面は多い。

array = [1, 2, 3, 4, 5];
sum = function (accumulator, current_value) {
  return accumulator + current_value;
}
console.log(array.reduce(sum));

// 15

array = [1, 2, 3, 4, 5];

sum = function (accumulator, current_value) {

return accumulator + current_value;

}

console.log(array.reduce(sum));

// 15

即時関数

さらに、関数の変数への代入自体も省いて、無名関数のまま実行させてしまう書き方を即時関数(immediately-invoked function express: IIFE)と呼んでいる。

(function () {
  console.log('immediately-invoked!')
})()

// immediately-invoked!

(function () {

console.log('immediately-invoked!')

})()

// immediately-invoked!

この記法は、varによる変数定義が関数スコープであることを利用して、変数の汚染を防ぐために使われる。

ES6以降導入されたブロックスコープより前にはグローバルスコープと関数スコープしかなかったため、必要なコード全体をIIFEの中に納めて、そのスコープ外の変数と独立させようという考え。

JS/ES – 変数のスコープ

2020-12-08 / tau / コメントする

スコープの種類と宣言キーワード

スコープの種類

グローバルスコープ

ドキュメント内のどこからでも参照可能。

関数スコープ

宣言された関数内でのみ参照可能。関数内の入れ子の関数・ブロックからは参照可能。

ブロックスコープ

宣言されたブロック内でのみ参照可能。ブロック内の入れ子の関数・ブロックからは参照可能。

宣言キーワードとスコープ

キーワードなしの宣言

ドキュメント内のどこからでも参照可能なグローバルスコープ。

`var`

宣言された関数内の関数スコープ。

ドキュメント直下で宣言した場合、グローバルスコープ
関数で宣言した場合、その関数内のスコープ
ブロック内で宣言した場合、そのすぐ外側の関数のスコープ（ブロックがドキュメント直下にあればグローバルスコープ）

`let, const`

宣言されたブロック内のブロックスコープ。

ドキュメント直下で宣言した場合、グローバルスコープ
関数で宣言した場合、その関数内のスコープ

確認

グローバルスコープ

JSコード

function func() {
  console.log('--- in function ---')
  console.log(global_none);
  console.log(global_var);
  console.log(global_let);
  console.log(global_const);

  global_none = 'global_none: rev in func';
  global_var = 'global_var: rev in func';
  global_let = 'global_let: rev in func';
  //global_const = 'global_const: rev in func';
  // -> Uncaught TypeError: Assignment to constant variable
  console.log('global_const: CANNOT assign')
}

global_none = 'global_none: init in global';
var global_var = 'global_var: init in global';
let global_let = 'global_let: init in global';
const global_const = 'global_const: init in global';

console.log('--- global ---')
console.log(global_none);
console.log(global_var);
console.log(global_let);
console.log(global_const);

func();

console.log('--- after function call ---')
console.log(global_none);
console.log(global_var);
console.log(global_let);
console.log(global_const);

{
  console.log('--- in block ---')
  console.log(global_none);
  console.log(global_var);
  console.log(global_let);
  console.log(global_const);

  global_none = 'global_none: rev in block';
  global_var = 'global_var: rev in block';
  global_let = 'global_let: rev in block';
  //global_const = 'global_const: rev in func';
  // -> Uncaught TypeError: Assignment to constant variable
  console.log('global_const: CANNOT assign')
}

console.log('--- after block ---')
console.log(global_none);
console.log(global_var);
console.log(global_let);
console.log(global_const);

function func() {

console.log('--- in function ---')

console.log(global_none);

console.log(global_var);

console.log(global_let);

console.log(global_const);

global_none = 'global_none: rev in func';

global_var = 'global_var: rev in func';

global_let = 'global_let: rev in func';

//global_const = 'global_const: rev in func';

// -> Uncaught TypeError: Assignment to constant variable

console.log('global_const: CANNOT assign')

}

global_none = 'global_none: init in global';

var global_var = 'global_var: init in global';

let global_let = 'global_let: init in global';

const global_const = 'global_const: init in global';

console.log('--- global ---')

console.log(global_none);

console.log(global_var);

console.log(global_let);

console.log(global_const);

func();

console.log('--- after function call ---')

console.log(global_none);

console.log(global_var);

console.log(global_let);

console.log(global_const);

{

console.log('--- in block ---')

console.log(global_none);

console.log(global_var);

console.log(global_let);

console.log(global_const);

global_none = 'global_none: rev in block';

global_var = 'global_var: rev in block';

global_let = 'global_let: rev in block';

//global_const = 'global_const: rev in func';

// -> Uncaught TypeError: Assignment to constant variable

console.log('global_const: CANNOT assign')

}

console.log('--- after block ---')

console.log(global_none);

console.log(global_var);

console.log(global_let);

console.log(global_const);

実行結果

--- global ---
global_none: init in global
global_var: init in global
global_let: init in global
global_const: init in global
--- in function ---
global_none: init in global
global_var: init in global
global_let: init in global
global_const: init in global
global_const: CANNOT assign
--- after function call ---
global_none: rev in func
global_var: rev in func
global_let: rev in func
global_const: init in global
--- in block ---
global_none: rev in func
global_var: rev in func
global_let: rev in func
global_const: init in global
global_const: CANNOT assign
--- after block ---
global_none: rev in block
global_var: rev in block
global_let: rev in block
global_const: init in global

--- global ---

global_none: init in global

global_var: init in global

global_let: init in global

global_const: init in global

--- in function ---

global_none: init in global

global_var: init in global

global_let: init in global

global_const: init in global

global_const: CANNOT assign

--- after function call ---

global_none: rev in func

global_var: rev in func

global_let: rev in func

global_const: init in global

--- in block ---

global_none: rev in func

global_var: rev in func

global_let: rev in func

global_const: init in global

global_const: CANNOT assign

--- after block ---

global_none: rev in block

global_var: rev in block

global_let: rev in block

global_const: init in global

関数スコープ

var, let, constとも関数内で宣言された場合はその関数内のみのスコープ
宣言された関数の中に入れ子で宣言された関数からは参照可能
入れ子の内側の関数内で宣言されたvar, let, constは、外側の関数からは参照できない

JSコード

function func() {
  console.log('--- in function ---')

  var func_var = 'func_var: init in function';
  let func_let = 'func_let: init in function';
  const func_const = 'func_const init in function';

  console.log(func_var);
  console.log(func_let);
  console.log(func_const);

  (function() {
    var nested_func_var = 'nested_func_var: init in nested function';
    let nested_func_let = 'nested_func_var: init in nested function';
    const nested_func_const = 'nested_func_const: init in nested function';

    console.log('--- in nested function ---')
    func_var = 'func_var: rev in nested function'
    func_let = 'func_let: rev in nested function'
    console.log(func_const);
  })()

  console.log('--- after nested function ---')
  console.log(func_var);
  console.log(func_let);
  console.log(func_const);

  //console.log(nested_func_var);
  console.log('nested_func_var: NOT defined');
  //console.log(nested_func_let);
  console.log('nested_func_let: NOT defined');
  //console.log(nested_func_const);
  console.log('nested_func_const: NOT defined');
}

func();

console.log('--- after function call ---')
//console.log(func_let);
// -> Uncaught ReferenceError: func_let is not defined
console.log('func_var: NOT defined');
//console.log(func_let);
// -> Uncaught ReferenceError: func_let is not defined
console.log('func_let: NOT defined');
//console.log(func_const);
// -> Uncaught ReferenceError: func_cost is not defined
console.log('func_cost: NOT defined');

function func() {

console.log('--- in function ---')

var func_var = 'func_var: init in function';

let func_let = 'func_let: init in function';

const func_const = 'func_const init in function';

console.log(func_var);

console.log(func_let);

console.log(func_const);

(function() {

var nested_func_var = 'nested_func_var: init in nested function';

let nested_func_let = 'nested_func_var: init in nested function';

const nested_func_const = 'nested_func_const: init in nested function';

console.log('--- in nested function ---')

func_var = 'func_var: rev in nested function'

func_let = 'func_let: rev in nested function'

console.log(func_const);

})()

console.log('--- after nested function ---')

console.log(func_var);

console.log(func_let);

console.log(func_const);

//console.log(nested_func_var);

console.log('nested_func_var: NOT defined');

//console.log(nested_func_let);

console.log('nested_func_let: NOT defined');

//console.log(nested_func_const);

console.log('nested_func_const: NOT defined');

}

func();

console.log('--- after function call ---')

//console.log(func_let);

// -> Uncaught ReferenceError: func_let is not defined

console.log('func_var: NOT defined');

//console.log(func_let);

// -> Uncaught ReferenceError: func_let is not defined

console.log('func_let: NOT defined');

//console.log(func_const);

// -> Uncaught ReferenceError: func_cost is not defined

console.log('func_cost: NOT defined');

実行結果

--- global ---
--- in function ---
func_var: init in function
func_let: init in function
func_const init in function
--- in nested function ---
func_const init in function
--- after nested function ---
func_var: rev in nested function
func_let: rev in nested function
func_const init in function
nested_func_var: NOT defined
nested_func_let: NOT defined
nested_func_const: NOT defined
--- after function call ---
func_var: NOT defined
func_let: NOT defined
func_cost: NOT defined

--- global ---

--- in function ---

func_var: init in function

func_let: init in function

func_const init in function

--- in nested function ---

func_const init in function

--- after nested function ---

func_var: rev in nested function

func_let: rev in nested function

func_const init in function

nested_func_var: NOT defined

nested_func_let: NOT defined

nested_func_const: NOT defined

--- after function call ---

func_var: NOT defined

func_let: NOT defined

func_cost: NOT defined

ブロックスコープ

var宣言はブロック内外に関わらず参照可能
let, constは宣言されたブロック内のみのスコープ
宣言されたブロックの中の入れ子のブロックからは参照可能
入れ子の内側のブロック内で宣言されたvar, let, constは、外側のブロックからは参照できない

JSコード

console.log('--- global ---')
{
  console.log('--- in block ---');
  var block_var = 'block_var: init in block';
  let block_let = 'block_let: init in block';
  const block_const = 'block_const: init in block';

  console.log(block_var);
  console.log(block_let);
  console.log(block_const);

  {
    console.log('--- in nested block ---');
    var nested_block_var = 'nested_block_var: init in nested block';
    let nested_block_let = 'nested_block_let: init in nested block';
    const nested_block_const = 'nested_block_const: init in nested block';

    block_var = 'block_var: rev in nested block';
    block_let = 'block_let: rev in nested block';
    console.log(block_const);
  }

  console.log('--- after nested block ---');
  console.log(block_var);
  console.log(block_let);
  console.log(block_const);

  console.log(nested_block_var);
  //console.log(nested_block_let);
  console.log('nested_block_let: NOT defined');
  //console.log(nested_block_const);
  console.log('nested_block_const: NOT defined');
}

console.log('--- after block ---');
console.log(block_var);
//console.log(block_let);
// -> Uncaught ReferenceError: block_let is not defined
console.log('block_let: NOT defined');
//console.log(block_const);
// -> Uncaught ReferenceError: func_var is not defined
console.log('block_const: NOT defined');

console.log('--- global ---')

{

console.log('--- in block ---');

var block_var = 'block_var: init in block';

let block_let = 'block_let: init in block';

const block_const = 'block_const: init in block';

console.log(block_var);

console.log(block_let);

console.log(block_const);

{

console.log('--- in nested block ---');

var nested_block_var = 'nested_block_var: init in nested block';

let nested_block_let = 'nested_block_let: init in nested block';

const nested_block_const = 'nested_block_const: init in nested block';

block_var = 'block_var: rev in nested block';

block_let = 'block_let: rev in nested block';

console.log(block_const);

}

console.log('--- after nested block ---');

console.log(block_var);

console.log(block_let);

console.log(block_const);

console.log(nested_block_var);

//console.log(nested_block_let);

console.log('nested_block_let: NOT defined');

//console.log(nested_block_const);

console.log('nested_block_const: NOT defined');

}

console.log('--- after block ---');

console.log(block_var);

//console.log(block_let);

// -> Uncaught ReferenceError: block_let is not defined

console.log('block_let: NOT defined');

//console.log(block_const);

// -> Uncaught ReferenceError: func_var is not defined

console.log('block_const: NOT defined');

実行結果

--- global ---
--- in block ---
block_var: init in block
block_let: init in block
block_const: init in block
--- in nested block ---
block_const: init in block
--- after nested block ---
block_var: rev in nested block
block_let: rev in nested block
block_const: init in block
nested_block_var: init in nested block
nested_block_let: NOT defined
nested_block_const: NOT defined
--- after block ---
block_var: rev in nested block
block_let: NOT defined
block_const: NOT defined

--- global ---

--- in block ---

block_var: init in block

block_let: init in block

block_const: init in block

--- in nested block ---

block_const: init in block

--- after nested block ---

block_var: rev in nested block

block_let: rev in nested block

block_const: init in block

nested_block_var: init in nested block

nested_block_let: NOT defined

nested_block_const: NOT defined

--- after block ---

block_var: rev in nested block

block_let: NOT defined

block_const: NOT defined

Ruby – ファイル操作

2020-11-28 / tau / コメントする

要点

Fileクラスを使うことで、開いたファイルをオブジェクトとして扱える
Fileはopenメソッドで開き、closeメソッドで閉じる
openメソッドで開いたファイルオブジェクトに対して、行単位の読み込みなどの処理を行う

ファイルのオープン／クローズ

ファイルのオープンにはFile#openメソッドを使う。第1引数でファイルのパス、第2引数でファイルを開くモードを文字列で指定。

変数 = File.open("ファイルへのパス", "モード")

モード指定の例は以下の通り。

`"r"`	読込	デフォルト
`"w"`	書込	ファイルが存在している場合は内容を空にする
`"a"`	追加	ファイルが存在している場合は末尾に追加する
`"r+"`	読書	ポインターはファイルの先頭にセット
`"w+"`	読書	ファイルが存在している場合は内容を空にする
`"a+"`	読書	読込位置は先頭、書き込み位置は末尾にセット

ファイルのクローズにはcloseメソッドを使う。

ファイルオブジェクトの変数.close

以下はファイル名を指定してファイルを開き、何もせずにクローズする例。

file = File.open("read_file.txt", "r")

# file operations

file.close

file = File.open("read_file.txt", "r")

# file operations

file.close

以下の構文は、ファイルのクローズを明示しなくても完結する。

File.open("read_file.txt", "r") do |file|

  # file operations

end

File.open("read_file.txt", "r") do |file|

# file operations

end

ただしこれには注意が必要。このブロックの中で定義した変数でファイルの内容を読み込むと、ブロックの外ではその変数は使えない（ブロック内スコープ）。

ブロック内で読んだ内容を外で参照するためには、ブロック外で変数が定義されている必要がある。

text = ""
# ブロック外での変数定義が必要

File.open("read_file.txt", "r") do |file|
  text = file.read
end

puts(text)

# ABCDEFGHIJKLMNOP
# BCDEFGHJIKLMNOPQ
# CDEFGHIJKLMNOPQR
# DEFGHIJKLMNOPQRS

text = ""

# ブロック外での変数定義が必要

File.open("read_file.txt", "r") do |file|

text = file.read

end

puts(text)

# ABCDEFGHIJKLMNOP

# BCDEFGHJIKLMNOPQ

# CDEFGHIJKLMNOPQR

# DEFGHIJKLMNOPQRS

ファイルの読み込み

一括読込

ファイルの読み込みは、ファイルオブジェクトのreadメソッドを使う。

file = File.open("read_file.txt", "r")
text = file.read
file.close

puts(text)

# ABCDEFGHIJKLMNOP
# BCDEFGHJIKLMNOPQ
# CDEFGHIJKLMNOPQR
# DEFGHIJKLMNOPQRS

file = File.open("read_file.txt", "r")

text = file.read

file.close

puts(text)

# ABCDEFGHIJKLMNOP

# BCDEFGHJIKLMNOPQ

# CDEFGHIJKLMNOPQR

# DEFGHIJKLMNOPQRS

行ごとの読み込み

Fileオブジェクトのeach_lineメソッドを使うと、行単位で読み込んでくれる。

file = File.open("read_file.txt", "r")

file.each_line do |line|
  puts(line)
end

file.close

# ABCDEFGHIJKLMNOP
# BCDEFGHJIKLMNOPQ
# CDEFGHIJKLMNOPQR
# DEFGHIJKLMNOPQRS

file = File.open("read_file.txt", "r")

file.each_line do |line|

puts(line)

end

file.close

# ABCDEFGHIJKLMNOP

# BCDEFGHJIKLMNOPQ

# CDEFGHIJKLMNOPQR

# DEFGHIJKLMNOPQRS

行番号

Fileオブジェクトのlinenoプロパティーは、現在読んでいる位置の行番号を持っている。

file = File.open("read_file.txt", "r")

file.each_line do |line|
  puts("#{file.lineno}:#{line}")
end

file.close

# 1:ABCDEFGHIJKLMNOP
# 2:BCDEFGHJIKLMNOPQ
# 3:CDEFGHIJKLMNOPQR
# 4:DEFGHIJKLMNOPQRS

file = File.open("read_file.txt", "r")

file.each_line do |line|

puts("#{file.lineno}:#{line}")

end

file.close

# 1:ABCDEFGHIJKLMNOP

# 2:BCDEFGHJIKLMNOPQ

# 3:CDEFGHIJKLMNOPQR

# 4:DEFGHIJKLMNOPQRS

ファイルの書き込み

ファイルの書き込みはopenの第2引数で"w"を指定する。ファイルが存在すればその内容が空にされ、ファイルが存在しなければ新たに作られる。

file = File.open("write_file.txt", "w")
line = ""
for n in 1..100
  line += "#{n} "
  if n % 10 == 0
    file.puts(line)
    line = ""
  end
end
file.close

# write_file.txtの内容
# 1 2 3 4 5 6 7 8 9 10 
# 11 12 13 14 15 16 17 18 19 20 
# 21 22 23 24 25 26 27 28 29 30 
# 31 32 33 34 35 36 37 38 39 40 
# 41 42 43 44 45 46 47 48 49 50 
# 51 52 53 54 55 56 57 58 59 60 
# 61 62 63 64 65 66 67 68 69 70 
# 71 72 73 74 75 76 77 78 79 80 
# 81 82 83 84 85 86 87 88 89 90 
# 91 92 93 94 95 96 97 98 99 100

file = File.open("write_file.txt", "w")

line = ""

for n in 1..100

line += "#{n} "

if n % 10 == 0

file.puts(line)

line = ""

end

file.close

# write_file.txtの内容

# 1 2 3 4 5 6 7 8 9 10

# 11 12 13 14 15 16 17 18 19 20

# 21 22 23 24 25 26 27 28 29 30

# 31 32 33 34 35 36 37 38 39 40

# 41 42 43 44 45 46 47 48 49 50

# 51 52 53 54 55 56 57 58 59 60

# 61 62 63 64 65 66 67 68 69 70

# 71 72 73 74 75 76 77 78 79 80

# 81 82 83 84 85 86 87 88 89 90

# 91 92 93 94 95 96 97 98 99 100

Ruby – dateライブラリー

2020-11-28 / tau / コメントする

導入

require("date")でライブラリーを読み込むとDateクラスが使えるようになる。

Dateオブジェクトの生成

Dateクラスのコンストラクターの引数で年、月、日を指定する。

d = Date.new(2020, 5, 30)

p(d)
# #<Date: 2020-05-30 ((2459000j,0s,0n),+0s,2299161j)>

puts(d)
# 2020-05-30

d = Date.new(2020, 5, 30)

p(d)

# #<Date: 2020-05-30 ((2459000j,0s,0n),+0s,2299161j)>

puts(d)

# 2020-05-30

parseクラスメソッドに様々な形の日付文字列を与えてDateオブジェクトを生成。

puts(Date.parse("2020-5-30"))
puts(Date.parse("2020/05/30"))
puts(Date.parse("2020.5.30"))
puts(Date.parse("20200530"))

# 以上はすべて2020-05-30を表示

puts(Date.parse("2020-5-30"))

puts(Date.parse("2020/05/30"))

puts(Date.parse("2020.5.30"))

puts(Date.parse("20200530"))

# 以上はすべて2020-05-30を表示

todayクラスメソッドは今日の日付でDateオブジェクトを生成。

puts(Date.today)
# 2020-11-28

1 2	puts(Date.today) # 2020-11-28

値の取り出し

年月日や曜日番号を個別に取り出し。

d = Date.new(2020, 5, 30)
puts(
  d.year,   # 年
  d.month,  # 月
  d.day,    # 日
  d.wday    # 曜日番号（日曜＝0）
)

d = Date.new(2020, 5, 30)

puts(

d.year, # 年

d.month, # 月

d.day, # 日

d.wday # 曜日番号（日曜＝0）

)

日付の書式付表示

strftimeメソッドの引数で書式を設定。

d = Date.new(2020, 5, 30)

puts(d.strftime("%Y/%m/%d(%a)"))
2020/05/30(Sat)

d = Date.new(2020, 5, 30)

puts(d.strftime("%Y/%m/%d(%a)"))

2020/05/30(Sat)

主な書式文字

%C	世紀
%Y	西暦年
%y	西暦年の下2桁
%m	月(01-12)
%d	日(01-31)
%w	曜日番号(日曜：0～土曜：6)
%u	曜日番号(月曜：1～日曜：7)
%A	曜日の名称(Monday, Tuesday, …)
%a	曜日の略称(Mon, Tue, …)

Ruby – ハッシュ

2020-11-28 / tau / コメントする

ハッシュの定義

ハッシュは{}で囲み、key => valueをカンマで連ねて定義する。

h = {"one" => 1, "two" => 2, "three" => 3 }

1	h = {"one" => 1, "two" => 2, "three" => 3 }

空のハッシュは次のいずれかで。

h = {}
h = Hash.new

1 2	h = {} h = Hash.new

ハッシュのサイズ

ハッシュのサイズはsizeかlengthで取得。

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.size)
# 3

p(h.length)
# 3

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.size)

# 3

p(h.length)

# 3

ハッシュが空かどうかはempty?で確認できる。

h = {}

p(h.empty?)
# true

h = {}

p(h.empty?)

# true

キーと値のリスト

keys、valuesでキーや値のリストが得られる。

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.keys)
# ["one", "two", "three"]

p(h.values)
# [1, 2, 3]

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.keys)

# ["one", "two", "three"]

p(h.values)

# [1, 2, 3]

キーと値の検索

has_key?、has_value?でキーや値の存在を確認。

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.has_key?("two"))
# true

p(h.has_value?(4))
# false

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h.has_key?("two"))

# true

p(h.has_value?(4))

# false

値の参照・追加・変更

キーを指定して値を参照。存在しない場合はnil。

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h["two"])
# 2

p(h["ten"])
# nil

h = {"one" => 1, "two" => 2, "three" => 3 }

p(h["two"])

# 2

p(h["ten"])

# nil

新たなキーを指定してアイテムを追加。

h["four"] = 4

p(h)
# {"one"=>1, "two"=>2, "three"=>3, "four"=>4}

h["four"] = 4

p(h)

# {"one"=>1, "two"=>2, "three"=>3, "four"=>4}

キーを指定してアイテムを削除。

h.delete("one")

p(h)
# {"two"=>2, "three"=>3, "four"=>4}

h.delete("one")

p(h)

# {"two"=>2, "three"=>3, "four"=>4}

キーを指定して値を変更。

h["three"] = "参"

p(h)
# {"two"=>2, "three"=>"参", "four"=>4}

h["three"] = "参"

p(h)

# {"two"=>2, "three"=>"参", "four"=>4}

キーと値の順次取り出し

eachメソッドでキーと値のセットを順次取り出す。

h = {"one" => 1, "two" => 2, "three" => 3 }

h.each do |key, value|
  puts("#{key} -> #{value}")
end

# one -> 1
# two -> 2
# three -> 3

h = {"one" => 1, "two" => 2, "three" => 3 }

h.each do |key, value|

puts("#{key} -> #{value}")

end

# one -> 1

# two -> 2

# three -> 3

シンボルによるキーの設定

:key => valueの形で、キーをシンボルで設定できる。

h = {:one => 1, :two => 2, :three => 3}

p(h)
# {:one=>1, :two=>2, :three=>3}

p(h[:one])
# 1

h = {:one => 1, :two => 2, :three => 3}

p(h)

# {:one=>1, :two=>2, :three=>3}

p(h[:one])

# 1

シンボルで設定する場合、key: valueの形でも設定できる。ただし参照する場合は:keyの形で。

h = {one: 1, two: 2, three: 3}

puts h
# {:one=>1, :two=>2, :three=>3}

p(h[:two])
# 2

h = {one: 1, two: 2, three: 3}

puts h

# {:one=>1, :two=>2, :three=>3}

p(h[:two])

# 2

キーのリストもシンボルで表示される。

h = {one: 1, two: 2, three: 3}

p(h.keys)
# [:one, :two, :three]

h = {one: 1, two: 2, three: 3}

p(h.keys)

# [:one, :two, :three]

Ruby – chop/chop!～末尾文字の削除

2020-11-28 / tau / コメントする

chopは文字列の末尾1文字を削除する。

p("abcd".chop)
#"abc"

p("いろはに".chop)
# "いろは"

p("abcd".chop)

#"abc"

p("いろはに".chop)

# "いろは"

末尾に改行文字がある場合は、それらが削除される。ただし"\n\r"の場合だけは"\n"が削除されずに残る。

p("abcd\n".chop)
# "abcd"

p("abcd\r".chop)
# "abcd"

p("abcd\r\n".chop)
# "abcd"

p("abcd\n\r".chop)
# "abcd\n"

p("abcd\n".chop)

# "abcd"

p("abcd\r".chop)

# "abcd"

p("abcd\r\n".chop)

# "abcd"

p("abcd\n\r".chop)

# "abcd\n"

chopは非破壊的であり、元の文字列は変更されない。

s = "abcd"

p(s.chop)
# "abc"

p(s)
# "abcd"

s = "abcd"

p(s.chop)

# "abc"

p(s)

# "abcd"

chop!にすると破壊的メソッドになり、戻り値も変更後の文字列。

s = "abcd"

p(s.chop!)
# "abc"

p(s)
# "abc"

s = "abcd"

p(s.chop!)

# "abc"

p(s)

# "abc"

Ruby – 配列の演算

2020-11-27 / tau / コメントする

概要

Rubyの配列同士の演算はPythonのようにブロードキャストされない。加算／減算はそれぞれ和集合／差集合のように扱われる。

配列同士の加算

`+`～加算は和集合

配列同士を⁺で加算すると双方の和集合となる。

a = [1, 2, 3, 4, 5]
b = [3, 4, 5, 6, 7]

p(a + b)
# [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]

a = [1, 2, 3, 4, 5]

b = [3, 4, 5, 6, 7]

p(a + b)

# [1, 2, 3, 4, 5, 3, 4, 5, 6, 7]

必ずしも重複が削除されるわけではない。

c = [1, 1, 2, 3, 4]
d = [4, 4, 5, 5, 6, 6]

p(c + d)
# [1, 1, 2, 3, 4, 4, 4, 5, 5, 6, 6]

c = [1, 1, 2, 3, 4]

d = [4, 4, 5, 5, 6, 6]

p(c + d)

# [1, 1, 2, 3, 4, 4, 4, 5, 5, 6, 6]

`−`～減算は差集合

減算の場合、元の配列から重なる要素だけが削除される。下の例ではaとbに共通な[3, 4]が削除され、[5, 6]はもともとaに含まれていないので無視される。

p(a - b)
# [1, 2]

1 2	p(a - b) # [1, 2]

積集合の求め方

加算と減算を組み合わせて、2つの配列の席集合に相当する配列が得られる。

p(a - (a - b))
# [3, 4, 5]

1 2	p(a - (a - b)) # [3, 4, 5]

要素の追加

<<演算子は左辺の配列に右辺の要素を追加する。連続して複数の要素も追加可能。push()と同じ動作。

a = [1, 2, 3]
a << 4
p(a)
// [1, 2, 3, 4]

a << 5 << 6
p(a)
// [1, 2, 3, 4, 5, 6]

a = [1, 2, 3]

a << 4

p(a)

// [1, 2, 3, 4]

a << 5 << 6

p(a)

// [1, 2, 3, 4, 5, 6]

Ruby – 配列メソッド

2020-11-27 / tau / コメントする

概要

配列オブジェクトのメソッドのには破壊系と非破壊系があり、注意を要する。

パラメーター系

`size/length`～要素数の取得

sizeメソッド、lengthメソッドとも配列の要素数を返すエイリアス。

a = [1, 2, 3]
puts(a.size)
# 3

puts(a.length)
# 3

a = [1, 2, 3]

puts(a.size)

# 3

puts(a.length)

# 3

`sum`～合計値の取得

sumメソッドは配列要素の合計値を返す。

puts(a.sum)
# 6

1 2	puts(a.sum) # 6

要素抽出系

`first/last`～先頭要素／末尾要素の取得

firstメソッドは配列の先頭の要素、lastメソッドは末尾の要素を返す。

a = [1, 2, 3]
p(a.first)
# 1

p(a.last)
# 3

a = [1, 2, 3]

p(a.first)

# 1

p(a.last)

# 3

sample～ランダムな要素取得

sampleメソッドは配列からランダムに1つ要素を返す。引数を指定すると重複なしでその個数分のサンプル配列を返すが、引数が要素数を超えた場合は全要素がランダムに並べられた配列が返される。

p(a.sample)
# 1

p(a.sample(2))
# [3, 1]

p(a.sample(5))
# [2, 1, 3]

p(a.sample)

# 1

p(a.sample(2))

# [3, 1]

p(a.sample(5))

# [2, 1, 3]

破壊的メソッド

`push/unshift`～要素の追加

pushメソッドは配列の末尾に要素を追加し、unshiftメソッドは配列の先頭に要素を追加する。いずれも元の配列を変更する（要素の追加は<<演算子でもできる）。

a = [1, 2, 3]
a.push(4)
# [1, 2, 3, 4]

p(a)
# [0, 1, 2, 3, 4]

a.unshift(0)
# 4

p(a)
# [0, 1, 2, 3]

a = [1, 2, 3]

a.push(4)

# [1, 2, 3, 4]

p(a)

# [0, 1, 2, 3, 4]

a.unshift(0)

# 4

p(a)

# [0, 1, 2, 3]

`pop/shift`～要素の取出し

popメソッドは配列の末尾から要素を取り出し、shiftメソッドは配列の先頭から要素を取り出す。いずれも元の配列が変更され、取り出された要素が戻り値となる。

p(a.pop)
# 4

p(a)
# [0, 1, 2, 3]

p(a.shift)
# 0

p(a)
# [1, 2, 3]

p(a.pop)

# 4

p(a)

# [0, 1, 2, 3]

p(a.shift)

# 0

p(a)

# [1, 2, 3]

非破壊的メソッド

`reverse`～要素の順番の反転

reverseメソッドは、元の配列の要素の順番を反転した配列を新たに生成して返す。

a = [1, 2, 3, 4, 5]
p(a.reverse)
# [5, 4, 3, 2, 1]

p(a)
# [1, 2, 3, 4, 5]

a = [1, 2, 3, 4, 5]

p(a.reverse)

# [5, 4, 3, 2, 1]

p(a)

# [1, 2, 3, 4, 5]

`sort`～昇順ソート

sortメソッドは、元の配列を昇順でソートした配列を生成して返す。文字列オブジェクトの場合は辞書順で、大文字→小文字の順。

a = [3, 1, 5, 2, 4]
p(a.sort)
# [1, 2, 3, 4, 5]

p(a)
# [3, 1, 5, 2, 4]

a = [3, 1, 5, 2, 4]

p(a.sort)

# [1, 2, 3, 4, 5]

p(a)

# [3, 1, 5, 2, 4]

`sort.reverse`～降順ソート

sortメソッドとreverseメソッドの組み合わせで、降順にソートされた配列が生成されて返される。

p(a.sort.reverse)
# [5, 4, 3, 2, 1]

p(a)
#[3, 1, 5, 2, 4]

p(a.sort.reverse)

# [5, 4, 3, 2, 1]

p(a)

#[3, 1, 5, 2, 4]

`uniq`～重複要素の削除

uniqは配列中の重複した要素を削除して1つにし、重複のない配列とする。元の配列は変更されず、新たな配列が生成される。

a = [1, 2, 2, 3, 3, 3, 4, 4, 5]
p(a.uniq)
# [1, 2, 3, 4, 5]

p(a)
# [1, 2, 2, 3, 3, 3, 4, 4, 5]

a = [1, 2, 2, 3, 3, 3, 4, 4, 5]

p(a.uniq)

# [1, 2, 3, 4, 5]

p(a)

# [1, 2, 2, 3, 3, 3, 4, 4, 5]

`shuffle`～要素のシャッフル

shuffleメソッドは、元の配列の要素をランダムに並べ替えた配列を生成して返す。

a = [1, 2, 3, 4, 5]
p(a.shuffle)
# [1, 5, 4, 2, 3]

p(a)
# [1, 2, 3, 4, 5]

a = [1, 2, 3, 4, 5]

p(a.shuffle)

# [1, 5, 4, 2, 3]

p(a)

# [1, 2, 3, 4, 5]

文字列化・配列化

`split`～文字列の配列への分解

splitメソッドは、指定した文字列で元の文字列を区切って、それぞれが要素となる配列を生成する。

p("い,ろ,はに,ab,c".split(","))
# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))
# ["a-b", "c", "-d", "e-f"]

p("い,ろ,はに,ab,c".split(","))

# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))

# ["a-b", "c", "-d", "e-f"]

`join`～配列要素の文字列への結合

joinメソッドは、配列の各要素を指定した文字列でつないだ文字列を生成する。

a = ["ABC", "KLM", "XYZ"]
puts(a.join("および"))
# ABCおよびKLMおよびXYZ

a = ["ABC", "KLM", "XYZ"]

puts(a.join("および"))

# ABCおよびKLMおよびXYZ

Ruby – 文字列メソッド

2020-11-26 / tau / コメントする

`length`～文字列の長さ

半角も全角も1文字。

puts("abcdefg".length)
# 7

puts("いろはにほへと".length)
# 7

puts("Rubyルビー".length)
# 7

puts("abcdefg".length)

# 7

puts("いろはにほへと".length)

# 7

puts("Rubyルビー".length)

# 7

結合系

`+`～文字列の連結

+演算子は文字列同士を結合する。半角と全角の連結もok。

puts("ABCD" + "EFG")
# ABCDEFG

puts("いろはに" + "ほへと")
# いろはにほへと

puts("Ruby" + "ルビー")
# Rubyルビー

puts("ABCD" + "EFG")

# ABCDEFG

puts("いろはに" + "ほへと")

# いろはにほへと

puts("Ruby" + "ルビー")

# Rubyルビー

`join`～配列要素の文字列化

配列のメソッドだが、joinメソッドは配列要素を指定した文字列で結合して文字列にする。

a = ["ABC", "KLM", "XYZ"]
puts(a.join("および"))
# ABCおよびKLMおよびXYZ

a = ["ABC", "KLM", "XYZ"]

puts(a.join("および"))

# ABCおよびKLMおよびXYZ

分割系

`split`～文字列の配列への分割

引数で指定した文字列で元の文字列を分解して配列化。

p("い,ろ,はに,ab,c".split(","))
# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))
# ["a-b", "c", "-d", "e-f"]

p("い,ろ,はに,ab,c".split(","))

# ["い", "ろ", "はに", "ab", "c"]

p("a-b--c---d--e-f".split("--"))

# ["a-b", "c", "-d", "e-f"]

2つ目の例から、引数で指定した文字列"--"が見つかるたびに、そこまでの文字列を要素として配列に加えていることがわかる。

削除系

`delete`～特定の文字の削除

引数で指定した文字列を削除。

puts("a,b,c,d".delete(","))
# abcd

puts("The rain in Spain stays mainly in the plain.".delete("ain"))
# The r  Sp stys mly  the pl.

puts("a,b,c,d".delete(","))

# abcd

puts("The rain in Spain stays mainly in the plain.".delete("ain"))

# The r Sp stys mly the pl.

`strip`～前後のスペースの削除

半角スペースを削除。全角スペースは削除されない。

puts(" a b c ".strip)
# a b c

puts("　い　ろ　は　".strip)
# 　い　ろ　は　
# 最後にも全角スペースが残っている

puts(" a b c ".strip)

# a b c

puts("　い　ろ　は　".strip)

# 　い　ろ　は　

# 最後にも全角スペースが残っている

chop/chop!～末尾文字の削除

chop/chop!は末尾文字を削除する。

chomp/chomp!～末尾の改行文字の削除

chomp/chomp!は末尾文字を削除する。

変換系

`upcase/downcase`～大文字化／小文字化

アルファベットの大文字化／小文字化。

puts("Ruby".upcase)
# RUBY

puts("Ruby".downcase)
# ruby

puts("Ruby".upcase)

# RUBY

puts("Ruby".downcase)

# ruby

Ruby – コメント

2020-11-26 / tau / コメントする

1行コメント～`#`

文頭に'#'があると、以降行末までコメントになる。

# 1行コメント
# one line comment

1 2	# 1行コメント # one line comment

複数行コメント～`=begin/=end`

=begin～=endの間の行は埋め込みドキュメントとして実行時には無視される。=beginと=endはそれぞれ行頭になければならない。

=begin
複数行コメント
multi line comments
=end

=begin

複数行コメント

multi line comments

=end

`END`の応用

__END__はコードの終端を示し、それ以降の記述は実行対象にならない。

puts "some executions"

__END__

以降は全てコメント
いくら書いても無視される

puts "some executions"

__END__

以降は全てコメント

いくら書いても無視される

関数式～関数の変数への代入

無名関数

即時関数

スコープの種類と宣言キーワード

スコープの種類

グローバルスコープ

関数スコープ

ブロックスコープ

宣言キーワードとスコープ

キーワードなしの宣言

var

let, const

確認

グローバルスコープ

関数スコープ

JSコード

ブロックスコープ

JSコード

要点

ファイルのオープン／クローズ

ファイルの読み込み

一括読込

行ごとの読み込み

行番号

ファイルの書き込み

導入

Dateオブジェクトの生成

値の取り出し

日付の書式付表示

ハッシュの定義

ハッシュのサイズ

キーと値のリスト

キーと値の検索

値の参照・追加・変更

キーと値の順次取り出し

シンボルによるキーの設定

概要

配列同士の加算

+～加算は和集合

−～減算は差集合

積集合の求め方

要素の追加

概要

パラメーター系

size/length～要素数の取得

sum～合計値の取得

要素抽出系

first/last～先頭要素／末尾要素の取得

sample～ランダムな要素取得

破壊的メソッド

push/unshift～要素の追加

pop/shift～要素の取出し

非破壊的メソッド

reverse～要素の順番の反転

sort～昇順ソート

sort.reverse～降順ソート

uniq～重複要素の削除

shuffle～要素のシャッフル

文字列化・配列化

split～文字列の配列への分解

join～配列要素の文字列への結合

length～文字列の長さ

結合系

+～文字列の連結

join～配列要素の文字列化

分割系

split～文字列の配列への分割

削除系

delete～特定の文字の削除

strip～前後のスペースの削除

chop/chop!～末尾文字の削除

chomp/chomp!～末尾の改行文字の削除

変換系

upcase/downcase～大文字化／小文字化

1行コメント～#

複数行コメント～=begin/=end

__END__の応用

`var`

`let, const`

`+`～加算は和集合

`−`～減算は差集合

`size/length`～要素数の取得

`sum`～合計値の取得

`first/last`～先頭要素／末尾要素の取得

`push/unshift`～要素の追加

`pop/shift`～要素の取出し

`reverse`～要素の順番の反転

`sort`～昇順ソート

`sort.reverse`～降順ソート

`uniq`～重複要素の削除

`shuffle`～要素のシャッフル

`split`～文字列の配列への分解

`join`～配列要素の文字列への結合

`length`～文字列の長さ

`+`～文字列の連結

`join`～配列要素の文字列化

`split`～文字列の配列への分割

`delete`～特定の文字の削除

`strip`～前後のスペースの削除

`upcase/downcase`～大文字化／小文字化

1行コメント～`#`

複数行コメント～`=begin/=end`

`END`の応用