2022-02-14

(ruby) 2つの変数の内容を入れ替える

使う機会があるかどうかは別として挙動の理解として、
2つの変数の値を入れ替えるいわゆるswapをrubyで書くにはどうすればいいか？、
考え方的には参照先を入れ替えればいいわけなので a,b = [b,a] という風に書けます。
確認のために以下を実行すると、2つの変数の object_idもポインタも入れ替わっているのがわかります。

require "fiddle"
a = "hello"
b = "world"
puts(a.object_id)
puts(b.object_id)
puts(Fiddle::Pointer[a].to_i)
puts(Fiddle::Pointer[b].to_i)
a,b = [b,a]
puts(a.object_id)
puts(b.object_id)
puts(Fiddle::Pointer[a].to_i)
puts(Fiddle::Pointer[b].to_i)

2021-12-24

Base64エンコードデコードをいろんな言語で書いてみた

まとめリンク：同じことをいろんな言語で書いてみたシリーズ

C++ (Base64エンコード)

// Base64 は CLX C++ Libraries
// http://clx.cielquis.net/index.html or https://github.com/clown/clx を利用
#include "./clx/base64.h"
#include <fstream>
int main(int argc, char *argv[])
{
  std::string filename = "./data_file_name"; // Base64を取得したいファイル名
  std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
  if (!ifs)
  {
    std::cout << "ファイルが見つかりませんでした" << std::endl;
    return 1;
  }
  ifs.seekg(0, std::ios::end);
  long long int dat_size = ifs.tellg();
  ifs.seekg(0);
  char *dat = new char[dat_size];
  ifs.read(dat, dat_size);
  std::cout << clx::base64::encode(dat, dat_size);
}

C++ (Base64デコード)

// Base64 は CLX C++ Libraries
// http://clx.cielquis.net/index.html or https://github.com/clown/clx を利用
#include "./clx/base64.h"
#include <fstream>
int main(int argc, char *argv[])
{
  std::string filename = "./base64_text_data";   // デコードしたいBase64ファイル名
  std::string output_filename = "./decode_data"; // 出力ファイル名
  std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
  if (!ifs)
  {
    std::cout << "ファイルが見つかりませんでした" << std::endl;
    return 1;
  }
  std::string dat = std::string(
      std::istreambuf_iterator<char>(ifs),
      std::istreambuf_iterator<char>()
  );
  std::ofstream ofs(output_filename, std::ios_base::binary);
  std::ostreambuf_iterator<char> output(ofs);
  clx::base64::decode(dat.begin(), dat.end(), output);
}

Ruby (Base64エンコード)

require "base64"
filename = "./data_file_name" # Base64を取得したいファイル名
dat = File.read(filename)
print Base64.encode64(dat)

Ruby (Base64デコード)

require "base64"
filename = "./base64_text_data" # デコードしたいBase64ファイル名
output_filename = "./decode_data" # 出力ファイル名
dat = File.read(filename)
File.open(output_filename, "w") { |f|
  f.write(Base64.decode64(dat))
}

Crystal (Base64エンコード)

require "base64"
filename = "./data_file_name" # Base64を取得したいファイル名
dat = File.read(filename)
print Base64.encode(dat)

Crystal (Base64デコード)

require "base64"
filename = "./base64_text_data" # デコードしたいBase64ファイル名
output_filename = "./decode_data" # 出力ファイル名
dat = File.read(filename)
File.open(output_filename, "w") { |f|
  f.write(Base64.decode(dat))
}

Rust (Base64エンコード)

// base64クレート -> https://crates.io/crates/base64
use std::io::prelude::*;
fn main() {
    let filename: &str = "./data_file_name"; // Base64を取得したいファイル名
    let mut f = std::fs::File::open(filename).expect("ファイルが見つかりませんでした");
    let mut dat = Vec::new();
    f.read_to_end(&mut dat).expect("ファイルの読み込みで問題が発生しました");
    print!("{}", base64::encode(dat));
}

Rust (Base64デコード)

// base64クレート -> https://crates.io/crates/base64
use std::io::Write;
fn main() {
    let filename: &str = "./base64_text_data"; // デコードしたいBase64ファイル名
    let output_filename: &str = "./decode_data"; // 出力ファイル名
    let dat = std::fs::read_to_string(&filename).expect("ファイルを読み込めませんでした");
    let bytes = base64::decode(dat).expect("デコード作業に失敗しました");
    let mut f = std::fs::File::create(&output_filename).expect("ファイルの確保に失敗しました");
    f.write_all(&bytes).expect("ファイルの書き出しに失敗しました");
}

Python3 (Base64エンコード)

import base64
filename = "./data_file_name" # Base64を取得したいファイル名
dat = open(filename, "rb").read()
print(base64.b64encode(dat).decode("utf-8"), end="")

Python3 (Base64デコード)

import base64
filename = "./base64_text_data" # デコードしたいBase64ファイル名
output_filename = "./decode_data" # 出力ファイル名
dat = open(filename, "rb").read()
with open(output_filename, "wb") as f:
  f.write(base64.b64decode(dat))

Node.js (Base64エンコード)

'use strict'
const filename = "./data_file_name" // Base64を取得したいファイル名
process.stdout.write(
  require("fs").readFileSync(filename, 'base64')
);

Node.js (Base64デコード)

'use strict'
const fs = require("fs");
const filename = "./base64_text_data" // デコードしたいBase64ファイル名
const output_filename = "./decode_data" // 出力ファイル名
const dat = fs.readFileSync(filename, 'utf8');
fs.promises.writeFile(output_filename, dat, { encoding: "base64" });

C# (Base64エンコード)

String filename = "./data_file_name"; // MD5を取得したいファイル名
byte[] dat = File.ReadAllBytes(filename);
Console.Write(Convert.ToBase64String(dat));

C# (Base64デコード)

String filename = "./base64_text_data"; // デコードしたいBase64ファイル名
String output_filename = "./decode_data"; // 出力ファイル名
String dat = System.IO.File.ReadAllText(filename, System.Text.Encoding.UTF8);
using (var fs = new FileStream(output_filename, FileMode.Create))
using (var bw = new BinaryWriter(fs))
{
  bw.Write(Convert.FromBase64String(dat));
}

2021-12-11

MD5を取得して表示するのをいろんな言語で書いてみた

まとめリンク：同じことをいろんな言語で書いてみたシリーズ

C++

// g++ -lcrypto md5.cpp -o md5 などとしてコンパイル
#include <iostream>
#include <openssl/md5.h>
int main(int argc, char *argv[])
{
  std::string dat = "Hello World!"; // MD5を取得するデータ
  unsigned char md5_result[MD5_DIGEST_LENGTH];
  MD5((unsigned char*) dat.c_str(), dat.length(), md5_result);
  for(int i = 0; i < MD5_DIGEST_LENGTH; i++)
    std::cout << std::hex << (unsigned int) md5_result[i];
  std::cout << std::endl;
  return 0;
}

C++ (ファイル入力バージョン)

// g++ -lcrypto md5.cpp -o md5 などとしてコンパイル
#include <iostream>
#include <fstream>
#include <openssl/md5.h>
int main(int argc, char *argv[])
{
  std::string filename = "./data_file_name";  // MD5を取得したいファイル名
  std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
  if (!ifs){
    std::cout << "ファイルが見つかりませんでした" << std::endl;
    return 1;
  }
  ifs.seekg(0, std::ios::end);
  long long int dat_size = ifs.tellg();
  ifs.seekg(0);
  char *dat = new char[dat_size];
  ifs.read(dat, dat_size);
  unsigned char md5_result[MD5_DIGEST_LENGTH];
  MD5((unsigned char*) dat, dat_size, md5_result);
  for(int i = 0; i < MD5_DIGEST_LENGTH; i++)
    std::cout << std::hex << (unsigned int) md5_result[i];
  std::cout << std::endl;
  delete[] dat;
  ifs.close();
  return 0;
}

Ruby

require "digest/md5"
dat = "Hello World!" # MD5を取得するデータ
puts(Digest::MD5.hexdigest(dat))

Ruby (ファイル入力バージョン)

require "digest/md5"
filename = "./data_file_name" # MD5を取得したいファイル名
dat = File.read(filename)
puts(Digest::MD5.hexdigest(dat))

Crystal

require "digest"
dat = "Hello World!" # MD5を取得するデータ
puts(Digest::MD5.hexdigest(dat))

Crystal (ファイル入力バージョン)

require "digest"
filename = "./data_file_name" # MD5を取得したいファイル名
dat = File.read(filename)
puts(Digest::MD5.hexdigest(dat))

Rust

// https://crates.io/crates/md5 を使用した例
fn main() {
  let dat: &str = "Hello World!"; // MD5を取得するデータ
  println!("{}", format!("{:x}", md5::compute(&dat)));
}

Rust (ファイル入力バージョン)

// https://crates.io/crates/md5 を使用した例
use std::io::prelude::*;
fn main() {
  let filename: &str = "./data_file_name"; // MD5を取得したいファイル名
  let mut f = std::fs::File::open(filename).expect("ファイルが見つかりませんでした");
  let mut dat = Vec::new();
  let _ = f.read_to_end(&mut dat).expect("ファイルの読み込みで問題が発生しました");
  println!("{}", format!("{:x}", md5::compute(&dat)));
}

Python3

import hashlib
dat = b'Hello World!' # MD5を取得するデータ
print(hashlib.md5(dat).hexdigest())

Python3 (ファイル入力バージョン)

import hashlib
filename = "./data_file_name" # MD5を取得したいファイル名
dat = open(filename, "rb").read()
print(hashlib.md5(dat).hexdigest())

Node.js

'use strict'
const dat = "Hello World!"; // MD5を取得するデータ
console.log(
  require("crypto").createHash("md5").update(dat, "binary").digest("hex")
);

Node.js (ファイル入力バージョン)

'use strict'
const filename = "./data_file_name" // MD5を取得したいファイル名
require("fs").readFile(
  filename,
  "binary",
  (err, dat) => {
    console.log(
      require("crypto").createHash("md5").update(dat, "binary").digest("hex")
    );
  }
);

using System.Security.Cryptography;
using System.Text;
String dat = "Hello World!"; // MD5を取得するデータ
byte[] dat_byte = Encoding.GetEncoding("UTF-8").GetBytes(dat);
MD5 md5 = MD5.Create();
byte[] md5_result = md5.ComputeHash(dat_byte);
for (int i=0; i < md5_result.Length; i++) {
  Console.Write(md5_result[i].ToString("x2"));
}
Console.WriteLine("");

C# (ファイル入力バージョン)

using System.Security.Cryptography;
using System.Text;
String filename = "./data_file_name"; // MD5を取得したいファイル名
byte[] dat_byte = File.ReadAllBytes(filename);
MD5 md5 = MD5.Create();
byte[] md5_result = md5.ComputeHash(dat_byte);
for (int i=0; i < md5_result.Length; i++) {
  Console.Write(md5_result[i].ToString("x2"));
}
Console.WriteLine("");

2021-11-22

JSONの文字列をパースするのをいろんな言語で書いてみた

まとめリンク：同じことをいろんな言語で書いてみたシリーズ

C++

#include <iostream>
// https://github.com/nlohmann/json.git をcloneして
// single_include/nlohmann/json.hppをソースと同じところに置いておく
#include "json.hpp"
int main(int argc, char* argv[]){
    std::string json_text = \
u8R"##({
  "mysql" : {
    "host" : "192.168.0.3",
    "port" : 3306,
    "user" : "hoge",
    "password" : "fuga",
    "database" : "hige",
    "table" : "hage"
  }
})##";
    auto json_data = nlohmann::json::parse(json_text);
    std::cout << json_data["mysql"]["host"] << std::endl;
}

Ruby

#!/usr/local/bin/ruby -Ku
require 'json'
json_text = <<'EOJSON'
{
  "mysql" : {
    "host" : "192.168.0.3",
    "port" : 3306,
    "user" : "hoge",
    "password" : "fuga",
    "database" : "hige",
    "table" : "hage"
  }
}
EOJSON
json_data = JSON.parse(json_text)
puts(json_data['mysql']['host'])

Crystal

require "json"
json_text = <<-EOJSON
  {
    "mysql" : {
      "host" : "192.168.0.3",
      "port" : 3306,
      "user" : "hoge",
      "password" : "fuga",
      "database" : "hige",
      "table" : "hage"
    }
  }
  EOJSON
json_data = JSON.parse(json_text)
puts(json_data["mysql"]["host"])

Rust

use serde::{Deserialize};  // https://github.com/serde-rs/json
#[derive(Deserialize, Debug)]
struct MysqlConfig {
  host: String,
  port: u16,
  user: String,
  password: String,
  database: String,
  table: String
}
#[derive(Deserialize, Debug)]
struct MysqlData {
  mysql: MysqlConfig
}
fn main() {
  let json_text =
r#"{
  "mysql" : {
    "host" : "192.168.0.3",
    "port" : 3306,
    "user" : "hoge",
    "password" : "fuga",
    "database" : "hige",
    "table" : "hage"
  }
}"#;
  let json_data: MysqlData = serde_json::from_str(&json_text).unwrap();
  println!("{}", json_data.mysql.host);
}

Python3

#!/usr/bin/python3
import json
json_text = """{
  "mysql" : {
    "host" : "192.168.0.3",
    "port" : 3306,
    "user" : "hoge",
    "password" : "fuga",
    "database" : "hige",
    "table" : "hage"
  }
}"""
json_data = json.loads(json_text)
print(json_data['mysql']['host'])

Node.js

#!/usr/local/bin/node
"use strict";
const json_text = `{
  "mysql" : {
    "host" : "192.168.0.3",
    "port" : 3306,
    "user" : "hoge",
    "password" : "fuga",
    "database" : "hige",
    "table" : "hage"
  }
}`;
const json_data = JSON.parse(json_text);
console.log(json_data['mysql']['host']);

using System;
using System.Text.Json;
namespace json_test
{
  class Program
  {
    static void Main(string[] args)
    {
      string json_text =
@"{
  ""mysql"" : {
    ""host"" : ""192.168.0.3"",
    ""port"" : 3306,
    ""user"" : ""hoge"",
    ""password"" : ""fuga"",
    ""database"" : ""hige"",
    ""table"" : ""hage""
  }
}";
      JsonDocument json_data = JsonDocument.Parse(json_text);
      Console.WriteLine(
        json_data.RootElement.GetProperty("mysql").GetProperty("host").GetString()
      );
    }
  }
}