バイト列を16進数の文字列にするには

text = "Aあ\n"
data = text.encode("utf-8")
hex_str = data.hex()
print(hex_str)                                    # 41e381820a
print(data.hex(" "))                              # 41 e3 81 82 0a
print(bytes.fromhex(hex_str).decode("utf-8") == text)  # True
print(format(10, "02x"), hex(10))                 # 0a 0xa
 
try:
    bytes.fromhex("zz")
except ValueError as e:
    print(e)  # non-hexadecimal number found in fromhex() arg at position 0

const text = "Aあ\n";
const data = Buffer.from(text, "utf8");
const hex = data.toString("hex");
console.log(hex); // 41e381820a
console.log(Buffer.from(hex, "hex").toString("utf8") === text); // true
 
// Buffer を使えないブラウザでは、1 バイトずつ 2 桁にそろえて連結する
const hex2 = Array.from(new TextEncoder().encode(text), (b) => b.toString(16).padStart(2, "0")).join("");
console.log(hex2 === hex);   // true
console.log((10).toString(16)); // a（桁がそろわない）
 
console.log(Buffer.from("zz", "hex").length);  // 0（例外にならず空になる）
console.log(Buffer.from("41e", "hex").length); // 1（端数の桁は黙って捨てられる）

const text: string = "Aあ\n";
const data: Uint8Array = new TextEncoder().encode(text);
const hex: string = Array.from(data, (b) => b.toString(16).padStart(2, "0")).join("");
console.log(hex); // 41e381820a
 
const pairs: string[] = hex.match(/../g) ?? [];
const back: Uint8Array = Uint8Array.from(pairs, (h) => parseInt(h, 16));
console.log(new TextDecoder().decode(back) === text); // true
console.log((10).toString(16)); // a（padStart を付けないと桁がそろわない）
 
console.log(parseInt("zz", 16)); // NaN（例外にならない）
console.log(Uint8Array.from(["zz"], (h) => parseInt(h, 16))[0]); // 0（NaN は 0 のバイトになる）

package main
 
import (
	"encoding/hex"
	"fmt"
)
 
func main() {
	text := "Aあ\n"
	hexStr := hex.EncodeToString([]byte(text))
	fmt.Println(hexStr) // 41e381820a
 
	data, err := hex.DecodeString(hexStr)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data) == text) // true
 
	_, err = hex.DecodeString("zz")
	fmt.Println(err) // encoding/hex: invalid byte: U+007A 'z'
	_, err = hex.DecodeString("41e")
	fmt.Println(err) // encoding/hex: odd length hex string
}

use std::fmt::Write;
 
fn main() {
    let text = "Aあ\n";
    let mut hex = String::new();
    for b in text.as_bytes() {
        write!(hex, "{:02x}", b).unwrap();
    }
    println!("{}", hex); // 41e381820a
 
    let data: Vec<u8> = (0..hex.len())
        .step_by(2)
        .map(|i| u8::from_str_radix(&hex[i..i + 2], 16).unwrap())
        .collect();
    println!("{}", String::from_utf8(data).unwrap() == text); // true
    println!("{:x} {:02x}", 10, 10); // a 0a
 
    match u8::from_str_radix("zz", 16) {
        Ok(_) => println!("ok"),
        Err(e) => println!("{}", e), // invalid digit found in string
    }
}

import java.nio.charset.StandardCharsets;
import java.util.HexFormat;
 
public class Main {
    public static void main(String[] args) {
        String text = "Aあ\n";
        byte[] data = text.getBytes(StandardCharsets.UTF_8);
        String hex = HexFormat.of().formatHex(data);
        System.out.println(hex); // 41e381820a
        System.out.println(HexFormat.of().withUpperCase().formatHex(data)); // 41E381820A
 
        byte[] back = HexFormat.of().parseHex(hex);
        System.out.println(new String(back, StandardCharsets.UTF_8).equals(text)); // true
 
        try {
            HexFormat.of().parseHex("zz");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage()); // not a hexadecimal digit: "z" = 122
        }
    }
}

using System;
using System.Text;
 
var text = "Aあ\n";
byte[] data = Encoding.UTF8.GetBytes(text);
string hex = Convert.ToHexString(data);
Console.WriteLine(hex);                    // 41E381820A（大文字で返る）
Console.WriteLine(hex.ToLowerInvariant()); // 41e381820a
 
byte[] back = Convert.FromHexString(hex);
Console.WriteLine(Encoding.UTF8.GetString(back) == text); // True
 
try { Convert.FromHexString("zz"); }
catch (FormatException e) { Console.WriteLine(e.GetType().Name); } // FormatException
try { Convert.FromHexString("41e"); }
catch (FormatException e) { Console.WriteLine(e.GetType().Name); } // FormatException