ruby復習

ruby復習

#-------------------------------------------------------------------------------
# ruby - relearn
#-------------------------------------------------------------------------------
print("ruby−開始\n");

str = "abcdefg";
p str.upcase();
puts(str[0,2]);


str_char = "b";
if str_char == "b"
  puts("equal");
elsif str_char == "c"
  puts("equal");
else
  puts("not equal");
end

str_case = "a";
case str_case
  when "a"
    puts("equal a");
  when "b"
    puts("equal b");
end

for i in 5.times()
  puts(i);
end

w_count = 0;
while w_count < 5
  puts(w_count);
  w_count += 1;
end

puts("配列");
a_datas = [];
a_datas.push(1);
a_datas.push(2);
a_datas.push(3);

a_datas.each do |d|
  puts(d);
end

puts("abcdef".length());
puts(a_datas.join("-"));

a_datas.unshift(100);
a_datas.push(999);
puts(a_datas.join("-"));
a_datas.shift();
puts(a_datas.join("-"));


#関数
def test_func(aa)
  puts("->" + aa);
end

test_func("atack");

puts("------------------------------------------------------------ 関数");
# ===  テストメソッド
#   本メソッドは、テスト用の
#   メソッドである。
# ====  引数
#  bin_data:  チェックサム生成対象となるバイナリデータ
# ====  戻り値
#   生成されたチェックサムを文字列として戻す
def sakura1()
    puts("sakura1")
end

def sakura2
  puts("sakura2")
end

sakura1
sakura2



puts("------------------------------------------------------------ 配列");

fruits = ["apple", "orange", "banana"];

puts("---------- join");
puts(fruits.join("-"));

puts("---------- push/pop");
fruits.push("melon");
puts(fruits.join("-"));
puts(fruits.pop());
puts(fruits.join("-"));
puts(fruits.length);

puts("---------- unshift/shift");
fruits.shift();
puts(fruits.join("-"));
fruits.unshift("apple");
puts(fruits.join("-"));

puts("---------- 部分抽出");
puts(fruits[0,2]);

puts("---------- clear");
fruits.clear();
puts(fruits.join("-"))

puts("---------- 配列動詞の結合");
fruits = ["apple", "orange", "banana"];
fruits2 = ["mikan", "nashi"];
fruits.concat(fruits2);
puts(fruits.join("-"));

puts("---------- 複数の要素を同時に変更");
cs1 = "100";
cs2 = "200";
index1,index2 = 1,2;
fruits[index1, index2] = [cs1, cs2];
puts(fruits.join("-"));

puts("---------- simple sort");
num_array = [5,3,1,4,2];
puts(num_array.sort());

puts("---------- 条件 sort");
str_num_array = ["Hitoshi,045", "Sizuo,046", "Yoshi,0138"]
puts(str_num_array.sort{ |a,b| b.split(",")[1] <=> a.split(",")[1] });

puts("----------  reverse");
num_array = [1, 2, 3, 4, 5];
puts(num_array.reverse());

puts("----------  指定位置を削除");
puts(fruits.join("-"));
fruits.delete_at(3);
puts(fruits.join("-"));

puts("----------  一致する要素を削除");
puts(fruits.join("-"));
fruits.delete("nashi");
puts(fruits.join("-"));

puts("----------  配列をユニーク化");
num_array = [1,2,3,1,2,3,4];
puts(num_array.uniq());

puts("----------  配列から指定条件を満たす要素を取り除く(真になった要素を取り除いた要素を返す)");
num_array = [1,2,3,4,5];
puts(num_array.delete_if{|x| x < 3});

puts("---------- 指定条件を満たす要素を抽出する");
num_array = [1,2,3,4,5];
puts(num_array.select{|x| x < 3});

puts("---------- 配列の要素を探す");
num_array = [1,2,3,4,5];
puts(num_array.index(3));
puts(num_array.index(100));


puts("------------------------------------------------------------ ハッシュ");
puts("---------- ハッシュを定義、取得");
fruits_hash = {"apple" => 10, "orange" => 20, "banana" => 30};
puts(fruits_hash['apple']);
puts(fruits_hash.fetch('pear', 40));  #初期値を設定

puts("---------- ハッシュに要素を追加");
tmp_hash = Hash::new;
tmp_hash['first'] = 1;
puts(tmp_hash['first']);
tmp_hash.store('second',2);
puts(tmp_hash['second']);

puts("---------- ハッシュにキーが存在するかどうか");
puts(fruits_hash.has_key?("apple"));
puts(fruits_hash.has_key?("pear"));

puts("---------- ハッシュの要素数");
puts(fruits_hash.length);

puts("---------- キーが存在しない場合のデフォルトを設定");
fruits_hash.default = -99;
puts(fruits_hash['nashi']);

puts("---------- ハッシュからエントリーを削除");
fruits_hash.store("kaki", 99);
p (fruits_hash);
fruits_hash.delete("kaki")
p (fruits_hash);

puts("----- キーが存在しなければブロックを実行");
fruits_hash.delete("kaki") {|key| puts("#{key} not exists!")};

puts("----- ブロックを評価、真なら要素を削除");
p fruits_hash;
fruits_hash.delete_if{|key,value| value < 30};
p fruits_hash;

puts("---------- ハッシュの全エントリに対してブロックを実行");
fruits_hash = {"apple" => 10, "orange" => 20, "banana" => 30};
fruits_hash.each_key{|key| puts(fruits_hash[key]); }
fruits_hash.each_pair{|key, value| puts( "#{key}:#{value}") }

puts("---------- ハッシュのキー、値を配列へ変換");
p fruits_hash.keys
p fruits_hash.values

puts("---------- ハッシュのクリア");
fruits_hash = {}
p fruits_hash
fruits_hash = {"apple" => 10, "orange" => 20, "banana" => 30};
p fruits_hash
fruits_hash.clear
p fruits_hash

puts("---------- ハッシュのソート");
fruits_hash = {"apple" => 10, "orange" => 20, "banana" => 30};
fruits_hash.each { |key,value|
  puts("#{key}:#{value}")
}

puts("---------- ハッシュのキーによる昇順ソート");
fruits_hash.sort.each { |key, value|
  puts("#{key}:#{value}")
}

puts("---------- ハッシュのキーによる降順ソート");
fruits_hash.sort.reverse.each { |key, value|
  puts("#{key}:#{value}")
}

puts("---------- ハッシュの値による昇順ソート");
fruits_hash.sort{|a,b|
  a[1] <=> b[1]
}.each { |name, value|
  puts("#{name}:#{value}")
}

puts("---------- ハッシュの値による降順ソート");
fruits_hash.sort{|a,b|
  b[1] <=> a[1]
}.each { |name, value|
  puts("#{name}:#{value}")
}


puts("------------------------------------------------------------　文字列");

puts("---------- 文字列の結合");
str="abc"
puts(str)
str = str + "def"
puts(str)

puts("---------- upcase/downcase");
str="abcdefg"
puts(str);
puts(str.upcase);
puts(str.downcase);

puts("---------- コマンドの実行結果を文字列へ");
s = `ls -al`
puts(s)

puts("---------- 部分文字列を取り出す");
s = "abcdefg"
p s[0,2]
p s[3,3]
p s[-1,1]

puts("---------- 文字列中の式を評価して展開");
val = 123
puts("val:#{val}")

puts("---------- 先頭と末尾の空白を削除");
s = " a d c d "
p s
p s.strip

puts("---------- 文字列を整数に変換");
i = 1
s = "999";
i = i+ s.to_i;
p i

puts("---------- 文字列を少数に変換");
ff1 = "10.2"
ff2 = 0.8
ff2 += ff1.to_f
puts ff2

puts("---------- 文字列を置換");
s = " apple banana orange apple pear"
puts(s.sub("apple", "APPLE"))
puts(s.gsub("apple", "APPLE"))

puts("---------- 文字列に含まれてる任意の文字列の位置を求める");
s = "apple banana orange apple pear"
p s.index("banana")
p s.rindex("apple")

puts("---------- 区切り（split）");
s = "apple,banana,orange,apple,pear"
p s.split(',')

puts("---------- パターンマッチ");
s = "apple_1 orange_2 apple_3 pear_4"
p s.scan(/ (p.+_\d{1})/);


puts("------------------------------------------------------------　制御構造");
puts("---------- if")
a = 0
if a == 0
  puts("a equal 0");
elsif a == 1
  puts("a equal 1");
else
  puts("a no equal 0 or 1");
end

puts("---------- case")
score = 81
case score
  when 0..49
    puts("failure")
  when 50..79
    puts("pass")
  else
    puts("excellent")
end

puts("---------- while")
count = 0
while count < 3
  count += 1
  puts(count)
end

puts("---------- for .." )
for i in 0..5
  puts(i)
end

puts("---------- for times" )
for i in 3.times
  puts(i)
end

puts("---------- times")
5.times{|n|
  puts(n)
}


puts("------------------------------------------------------------　クラス");

class SampleClass

  #get/set
  attr_accessor :count;

  #get
  #attr_reader :


  #set
  #attr_writer

  def initialize(count)
    #クラス変数
    @@max_count = 100;

    #インスタンス変数
    @count = count
    @msg = "";

  end

  #-------------------- public
  public


  def get_count
    @count
  end

  def set_msg(msg = "default msg")
    @msg = msg
  end

  def get_msg()
    return "get_msg -> " + @msg
  end

  #-------------------- protected
  protected

  #-------------------- private
  private

  def get_msg_2()
    return "get_msg_2 -> "+ @msg + @msg
  end

end

c = SampleClass.new(999)
#p c.get_count
#p c.count

puts("---------- メソッドの仮引数でデフォルトを指定")
c.set_msg("hello test")
p c.get_msg
c.set_msg()
p c.get_msg


puts("---------- 可変引数")
def order (id, *list)
  puts("id:#{id}");
  list.each{|data|
    puts("#{data}")
  }
end

order("abc123", 100, 200, 300)

puts("---------- 引数にブロックを渡す")
def func_block(x, y, &block)
  return x + block.call(y, 2)
end

p func_block(1,2){|a,b| a * b}


puts("------------------------------------------------------------　ファイル");
puts("---------- テキストファイルをオープン、内容を出力、書き込み")
File::open("data.txt", "r:utf8"){|f|
  f.each{|line|
    puts(line)
  }
}

File::open("data.txt", "a:utf8"){|f|
  f.puts("add text");
}


puts("---------- ファイル名解析")
p File::dirname("/hoge/data.txt")
p File::basename("/hoge/data.txt", ".txt")
p File::extname("/hoge/data.txt")

puts("---------- ファイルパスの結合")
p File.join("data_dir_1","data_dir_2", "file.txt")


puts("---------- ファイル名の存在チェック")
p File.exist?("data.txt")


puts("------------------------------------------------------------　ディレクトリ");
#Dir::mkdir("dir_test")
#Dir::rmdir("dir_test")


puts("---------- ディレクトリのファイル名の配列を取得")
p Dir.glob("*.txt")


puts("------------------------------------------------------------　モジュール");
require "./lib/sample_module"
include SampleModule
SampleModule.hello()



puts("------------------------------------------------------------　例外");
begin
  #---------- 処理
  puts("job")
  r = 1 / 0
rescue => exec
  #---------- 例外発生時
  puts("rescue")
  puts(" -> error!" + exec)

else
  #---------- 例外未発生
  puts("else")

ensure
  #---------- 必須最終処理
  puts("ensure")
end


puts("------------------------------------------------------------
外部クラスファイル読み込み");
require("./lib/test_class")
tc = TestClass.new("suzki")
puts(tc.get_name())
puts(tc.get_name2())




puts("");
puts("------------------------------------------------------------");
puts("end / ruby "+ RUBY_VERSION)
puts("------------------------------------------------------------");

ruby db処理

#-------------------------------------------------------------------------------
# mysql-test
#-------------------------------------------------------------------------------
require 'rubygems'
require 'mysql'

puts("========== mysql test start");
db = Mysql.connect("127.0.0.1", "root", "1234","db1")

# select-1 / each do
db.query("select bang, name, tosi from tb1").each do |bang, name, tosi|
    puts(bang + ":" + name + ":" +  tosi)
end

#select-2 / each
rows = db.query("select bang, name, tosi from tb1")
rows.each do |row|
    puts(row[0] + ":" + row[1] + ":" + row[2]);
end

#select-3 / each_hash
rows = db.query("select bang, name, tosi from tb1")
rows.each_hash do |row|
    puts("#{row['bang']} #{row['name']} #{row['tosi']}");
end

# count
res = db.query("select count(*) from tb1")
puts("data_count:" + res.fetch_row[0].to_s)


#insert / テーブル設定:InnoDB
db.query("START TRANSACTION")
db.query("insert into tb1 (bang,name,tosi) values('C101','mimura',31)");
#例外テスト
reigai_val = 1 / 0

rescue => exec
  puts("例外発生")
  puts("exception:" + exec)
  db.query("ROLLBACK")
else
  puts("正常終了")
  db.query("COMMIT")
ensure
  puts("最終処理")
  db.close if db
end

puts("========== mysql test end")