Kiểm tra kiểu dữ liệu

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0,-1).toLowerCase()
}
 
const values = [
  true,
  10,
  'foo',
  Symbol('bar'),
  null,
  undefined,
  NaN,
  {},
  [],
  function(){},
  new Error(),
  new Date(),
  /a/,
  new Map(),
  new Set(),
  Promise.resolve(),
  function *() {},
  class {},
]
 
for (const value of values) {
  console.log(typeOf(value))
}

package main
 
import (
	"fmt"
	"reflect"
	"regexp"
	"time"
)
 
func main() {
	values := []any{
		true,
		int8(10),
		int16(10),
		int32(10),
		int64(10),
		uint(10),
		uint8(10),
		uint16(10),
		uint32(10),
		uint64(10),
		uintptr(10),
		float32(10.5),
		float64(10.5),
		complex64(-1 + 10i),
		complex128(-1 + 10i),
		"foo",
		byte(10),
		'a',
		rune('a'),
		struct{}{},
		[]string{},
		map[string]int{},
		func() {},
		make(chan bool),
		nil,
		new(int),
		time.Now(),
		regexp.MustCompile(`^a$`),
	}
 
	for _, value := range values {
		fmt.Println(reflect.TypeOf(value))
	}
}

// Cargo.toml: regex = "1"
use std::collections::HashMap;
use std::time::Instant;
 
// `type_name` được suy ra tại compile-time từ tham số generic T — không phải reflection
// thật lúc chạy như `reflect.TypeOf`, nên không thể lặp qua một danh sách giá trị "any" kiểu Go.
fn type_of<T>(_: &T) -> &'static str {
    std::any::type_name::<T>()
}
 
fn main() {
    println!("{}", type_of(&true));
    println!("{}", type_of(&10i32));
    println!("{}", type_of(&10.5f64));
    println!("{}", type_of(&"foo"));
    println!("{}", type_of(&String::from("foo")));
    println!("{}", type_of(&Option::<i32>::None));
    println!("{}", type_of(&Vec::<i32>::new()));
    println!("{}", type_of(&HashMap::<String, i32>::new()));
    println!("{}", type_of(&(|| {})));
    println!("{}", type_of(&Instant::now()));
    println!("{}", type_of(&regex::Regex::new("^a$").unwrap()));
}

import Foundation
 
let values: [Any] = [
    true,
    10,
    10.5,
    "foo",
    Optional<Int>.none as Any,
    [1, 2, 3],
    ["a": 1],
    { () -> Void in } as () -> Void,
    Date(),
    try! Regex("^a$"),
]
 
for value in values {
    print(type(of: value))
}

void main() {
    List<Object> values = List.of(
            true,
            10,
            10.5,
            "foo",
            List.of(1, 2, 3),
            Map.of("a", 1),
            (Runnable) () -> {},
            Instant.now(),
            Pattern.compile("^a$"));
 
    for (Object value : values) {
        IO.println(value.getClass().getSimpleName());
    }
}