diff --git a/docs/reference/predicate/isBoolean.md b/docs/reference/predicate/isBoolean.md
new file mode 100644
index 0000000..a93993c
--- /dev/null
+++ b/docs/reference/predicate/isBoolean.md
@@ -0,0 +1,26 @@
+# isBoolean
+
+The `isBoolean` function checks if a value is a boolean.
+
+## Signature
+
+```typescript
+function isBoolean(val: any): val is boolean
+```
+
+## Parameters
+
+- **`val`**: `unknown` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is boolean, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isBoolean } from 'js-utils-es/predicate';
+
+isBoolean(1); // false
+isBoolean(true); // true
+```
diff --git a/docs/reference/predicate/isDate.md b/docs/reference/predicate/isDate.md
new file mode 100644
index 0000000..f4c1cb4
--- /dev/null
+++ b/docs/reference/predicate/isDate.md
@@ -0,0 +1,27 @@
+# isDate
+
+The `isDate` function checks if a value is a `Date` object.
+
+## Signature
+
+```typescript
+function isDate(val: any): val is Date
+```
+
+## Parameters
+
+- **`val`**: `unknown` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `Date`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isDate } from 'js-utils-es/predicate';
+
+isDate(1); // false
+isDate(true); // false
+isDate(new Date()); // true
+```
diff --git a/docs/reference/predicate/isFunction.md b/docs/reference/predicate/isFunction.md
new file mode 100644
index 0000000..ff769fe
--- /dev/null
+++ b/docs/reference/predicate/isFunction.md
@@ -0,0 +1,28 @@
+# isFunction
+
+The `isFunction` function checks if a value is a `Function` object.
+
+## Signature
+
+```typescript
+function isFunction(val: any)
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `Function`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isFunction } from 'js-utils-es/predicate';
+
+isFunction(1); // false
+isFunction(true); // false
+isFunction(new Date()); // false
+isFunction(() => {}); // true
+```
diff --git a/docs/reference/predicate/isNull.md b/docs/reference/predicate/isNull.md
index 8ad6b02..0592557 100644
--- a/docs/reference/predicate/isNull.md
+++ b/docs/reference/predicate/isNull.md
@@ -10,7 +10,7 @@ This function can also serve as a type predicate in TypeScript, narrowing the ty
 ## Signature
 
 ```typescript
-function isNull(x: unknown): x is null;
+function isNull(val: any): val is null
 ```
 
 ### Parameters
diff --git a/docs/reference/predicate/isNumber.md b/docs/reference/predicate/isNumber.md
new file mode 100644
index 0000000..efa95e7
--- /dev/null
+++ b/docs/reference/predicate/isNumber.md
@@ -0,0 +1,28 @@
+# isNumber
+
+The `isNumber` function checks if a value is a `number`.
+
+## Signature
+
+```typescript
+function isNumber(val: any): val is number
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `number`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isNumber } from 'js-utils-es/predicate';
+
+isNumber(1); // true
+isNumber(true); // false
+isNumber(new Date()); // false
+isNumber(() => {}); // false
+```
diff --git a/docs/reference/predicate/isObject.md b/docs/reference/predicate/isObject.md
new file mode 100644
index 0000000..2396622
--- /dev/null
+++ b/docs/reference/predicate/isObject.md
@@ -0,0 +1,30 @@
+# isObject
+
+The `isObject` function checks if a value is a plain object.
+
+## Signature
+
+```typescript
+function isObject(val: any): val is object
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a plain object, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isObject } from 'js-utils-es/predicate';
+
+isObject({}); // true
+
+isObject(1); // false
+isObject(true); // false
+isObject(new Date()); // false
+isObject(() => {}); // false
+```
diff --git a/docs/reference/predicate/isRegExp.md b/docs/reference/predicate/isRegExp.md
new file mode 100644
index 0000000..6f7de23
--- /dev/null
+++ b/docs/reference/predicate/isRegExp.md
@@ -0,0 +1,30 @@
+# isRegExp
+
+The `isRegExp` function checks if a value is a `RegExp`.
+
+## Signature
+
+```typescript
+function isRegExp(val: any): val is RegExp
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `RegExp`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isRegExp } from 'js-utils-es/predicate';
+
+isRegExp(/[az]/g); // true
+
+isRegExp(1); // false
+isRegExp(true); // false
+isRegExp(new Date()); // false
+isRegExp(() => {}); // false
+```
diff --git a/docs/reference/predicate/isString.md b/docs/reference/predicate/isString.md
new file mode 100644
index 0000000..772ed73
--- /dev/null
+++ b/docs/reference/predicate/isString.md
@@ -0,0 +1,30 @@
+# isString
+
+The `isString` function checks if a value is a `string`.
+
+## Signature
+
+```typescript
+function isString(val: unknown): val is string
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `string`, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isString } from 'js-utils-es/predicate';
+
+isString('1'); // true
+
+isString(1); // false
+isString(true); // false
+isString(new Date()); // false
+isString(() => {}); // false
+```
diff --git a/docs/reference/predicate/isUndefined.md b/docs/reference/predicate/isUndefined.md
index ef1649a..2325f1b 100644
--- a/docs/reference/predicate/isUndefined.md
+++ b/docs/reference/predicate/isUndefined.md
@@ -10,12 +10,12 @@ This function can also serve as a type predicate in TypeScript, narrowing the ty
 ## Signature
 
 ```typescript
-function isUndefined(x: unknown): x is undefined;
+function isUndefined(val: any): val is undefined
 ```
 
 ### Parameters
 
-- `x` (`unknown`): The value to test if it is `undefined`.
+- `x` (`any`): The value to test if it is `undefined`.
 
 ### Returns
 
diff --git a/docs/reference/predicate/isWindow.md b/docs/reference/predicate/isWindow.md
new file mode 100644
index 0000000..c8ca072
--- /dev/null
+++ b/docs/reference/predicate/isWindow.md
@@ -0,0 +1,28 @@
+# isWindow
+
+The `isWindow` function checks if a value is a `window` object.
+
+## Signature
+
+```typescript
+function isWindow(val: any): boolean
+```
+
+## Parameters
+
+- **`val`**: `any` - The value to check.
+
+## Returns
+
+- **`boolean`** - Returns `true` if the value is a `window` object, otherwise `false`.
+
+## Examples
+
+```typescript
+import { isWindow } from 'js-utils-es/predicate';
+
+isWindow(window); // true
+isWindow(true); // false
+isWindow(new Date()); // false
+isWindow(() => {}); // false
+```
diff --git a/src/predicate/_internal/toString.spec.ts b/src/predicate/_internal/toString.spec.ts
new file mode 100644
index 0000000..5ba6d41
--- /dev/null
+++ b/src/predicate/_internal/toString.spec.ts
@@ -0,0 +1,33 @@
+/* eslint-disable prefer-regex-literals */
+import { describe, expect, it } from 'vitest';
+import { toString } from './toString';
+
+describe('toString', () => {
+  it('case1', async () => {
+    expect(toString(1)).toEqual('[object Number]');
+  });
+
+  it('case2', async () => {
+    expect(toString('1')).toEqual('[object String]');
+  });
+
+  it('case3', async () => {
+    expect(toString(true)).toEqual('[object Boolean]');
+  });
+
+  it('case4', async () => {
+    expect(toString([])).toEqual('[object Array]');
+  });
+
+  it('case5', async () => {
+    expect(toString({})).toEqual('[object Object]');
+  });
+
+  it('case6', async () => {
+    expect(toString(new Date())).toEqual('[object Date]');
+  });
+
+  it('case7', async () => {
+    expect(toString(new RegExp(/[a-z]/g))).toEqual('[object RegExp]');
+  });
+});
diff --git a/src/predicate/_internal/toString.ts b/src/predicate/_internal/toString.ts
new file mode 100644
index 0000000..baadb3e
--- /dev/null
+++ b/src/predicate/_internal/toString.ts
@@ -0,0 +1,7 @@
+/**
+ * Convert value to string.
+ * @param {any} v - The value to convert to string.
+ * @returns {string} - return string
+ */
+
+export const toString = (v: any) => Object.prototype.toString.call(v);
diff --git a/src/predicate/isBoolean.spec.ts b/src/predicate/isBoolean.spec.ts
new file mode 100644
index 0000000..95493d4
--- /dev/null
+++ b/src/predicate/isBoolean.spec.ts
@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { isBoolean } from './isBoolean';
+
+describe('isBoolean', () => {
+  it('case1', () => {
+    expect(isBoolean(null)).toBe(false);
+    expect(isBoolean(undefined)).toBe(false);
+    expect(isBoolean({})).toBe(false);
+    expect(isBoolean('1')).toBe(false);
+    expect(isBoolean(1)).toBe(false);
+    expect(isBoolean(true)).toBe(true);
+    expect(isBoolean(false)).toBe(true);
+  });
+});
diff --git a/src/predicate/isBoolean.ts b/src/predicate/isBoolean.ts
new file mode 100644
index 0000000..d169011
--- /dev/null
+++ b/src/predicate/isBoolean.ts
@@ -0,0 +1,3 @@
+export function isBoolean(val: any): val is boolean {
+  return typeof val === 'boolean';
+}
diff --git a/src/predicate/isDate.spec.ts b/src/predicate/isDate.spec.ts
new file mode 100644
index 0000000..16ee9df
--- /dev/null
+++ b/src/predicate/isDate.spec.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { isDate } from './isDate';
+
+describe('isDate', () => {
+  it('case1', () => {
+    expect(isDate(null)).toBe(false);
+    expect(isDate(undefined)).toBe(false);
+    expect(isDate({})).toBe(false);
+    expect(isDate('1')).toBe(false);
+    expect(isDate(1)).toBe(false);
+    expect(isDate(true)).toBe(false);
+    expect(isDate(false)).toBe(false);
+    expect(isDate(new Date())).toBe(true);
+  });
+});
diff --git a/src/predicate/isDate.ts b/src/predicate/isDate.ts
new file mode 100644
index 0000000..b97c328
--- /dev/null
+++ b/src/predicate/isDate.ts
@@ -0,0 +1,5 @@
+import { toString } from './_internal/toString';
+
+export function isDate(val: any): val is Date {
+  return toString(val) === '[object Date]';
+}
diff --git a/src/predicate/isFunction.spec.ts b/src/predicate/isFunction.spec.ts
new file mode 100644
index 0000000..8d087d8
--- /dev/null
+++ b/src/predicate/isFunction.spec.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { isFunction } from './isFunction';
+
+describe('isFunction', () => {
+  it('case1', () => {
+    expect(isFunction(null)).toBe(false);
+    expect(isFunction(undefined)).toBe(false);
+    expect(isFunction({})).toBe(false);
+    expect(isFunction('1')).toBe(false);
+    expect(isFunction(1)).toBe(false);
+    expect(isFunction(true)).toBe(false);
+    expect(isFunction(false)).toBe(false);
+    expect(isFunction(new Date())).toBe(false);
+    expect(isFunction(() => {
+      return 2;
+    })).toBe(true);
+  });
+});
diff --git a/src/predicate/isFunction.ts b/src/predicate/isFunction.ts
new file mode 100644
index 0000000..54f771c
--- /dev/null
+++ b/src/predicate/isFunction.ts
@@ -0,0 +1,4 @@
+// eslint-disable-next-line ts/no-unsafe-function-type
+export function isFunction<T extends Function>(val: any): val is T {
+  return typeof val === 'function';
+}
diff --git a/src/predicate/isNull.ts b/src/predicate/isNull.ts
index e04084e..ac29e89 100644
--- a/src/predicate/isNull.ts
+++ b/src/predicate/isNull.ts
@@ -1,3 +1,5 @@
+import { toString } from './_internal/toString';
+
 /**
  * Checks if the given value is null.
  *
@@ -18,6 +20,7 @@
  * console.log(isNull(value2)); // false
  * console.log(isNull(value3)); // false
  */
-export function isNull(x: unknown): x is null {
-  return x === null;
+
+export function isNull(val: any): val is null {
+  return toString(val) === '[object Null]';
 }
diff --git a/src/predicate/isNumber.spec.ts b/src/predicate/isNumber.spec.ts
new file mode 100644
index 0000000..68c174e
--- /dev/null
+++ b/src/predicate/isNumber.spec.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { isNumber } from './isNumber';
+
+describe('isNumber', () => {
+  it('case1', () => {
+    expect(isNumber(null)).toBe(false);
+    expect(isNumber(undefined)).toBe(false);
+    expect(isNumber({})).toBe(false);
+    expect(isNumber('1')).toBe(false);
+    expect(isNumber(1)).toBe(true);
+    expect(isNumber(true)).toBe(false);
+    expect(isNumber(false)).toBe(false);
+    expect(isNumber(new Date())).toBe(false);
+    expect(isNumber(() => {
+      return 2;
+    })).toBe(false);
+  });
+});
diff --git a/src/predicate/isNumber.ts b/src/predicate/isNumber.ts
new file mode 100644
index 0000000..8c28f3e
--- /dev/null
+++ b/src/predicate/isNumber.ts
@@ -0,0 +1,3 @@
+export function isNumber(val: any): val is number {
+  return typeof val === 'number';
+}
diff --git a/src/predicate/isObject.spec.ts b/src/predicate/isObject.spec.ts
new file mode 100644
index 0000000..707f7b0
--- /dev/null
+++ b/src/predicate/isObject.spec.ts
@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+import { isObject } from './isObject';
+
+describe('isObject', () => {
+  it('case1', () => {
+    expect(isObject(null)).toBe(false);
+    expect(isObject(undefined)).toBe(false);
+    expect(isObject({})).toBe(true);
+    expect(isObject('1')).toBe(false);
+    expect(isObject(1)).toBe(false);
+    expect(isObject(true)).toBe(false);
+    expect(isObject(false)).toBe(false);
+    expect(isObject(new Date())).toBe(false);
+    expect(isObject(() => {
+      return 2;
+    })).toBe(false);
+  });
+});
diff --git a/src/predicate/isObject.ts b/src/predicate/isObject.ts
new file mode 100644
index 0000000..01bb0b0
--- /dev/null
+++ b/src/predicate/isObject.ts
@@ -0,0 +1,5 @@
+import { toString } from './_internal/toString';
+
+export function isObject(val: any): val is object {
+  return toString(val) === '[object Object]';
+}
diff --git a/src/predicate/isRegExp.spec.ts b/src/predicate/isRegExp.spec.ts
new file mode 100644
index 0000000..e03a26a
--- /dev/null
+++ b/src/predicate/isRegExp.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { isRegExp } from './isRegExp';
+
+describe('isRegExp', () => {
+  it('case1', () => {
+    expect(isRegExp(null)).toBe(false);
+    expect(isRegExp(undefined)).toBe(false);
+    expect(isRegExp({})).toBe(false);
+    expect(isRegExp('1')).toBe(false);
+    expect(isRegExp(1)).toBe(false);
+    expect(isRegExp(true)).toBe(false);
+    expect(isRegExp(false)).toBe(false);
+    expect(isRegExp(new Date())).toBe(false);
+    expect(isRegExp(() => {
+      return 2;
+    })).toBe(false);
+
+    expect(isRegExp(/[ab]/g)).toBe(true);
+  });
+});
diff --git a/src/predicate/isRegExp.ts b/src/predicate/isRegExp.ts
new file mode 100644
index 0000000..b603532
--- /dev/null
+++ b/src/predicate/isRegExp.ts
@@ -0,0 +1,5 @@
+import { toString } from './_internal/toString';
+
+export function isRegExp(val: any): val is RegExp {
+  return toString(val) === '[object RegExp]';
+}
diff --git a/src/predicate/isString.spec.ts b/src/predicate/isString.spec.ts
new file mode 100644
index 0000000..dae5c80
--- /dev/null
+++ b/src/predicate/isString.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { isString } from './isString';
+
+describe('isString', () => {
+  it('case1', () => {
+    expect(isString(null)).toBe(false);
+    expect(isString(undefined)).toBe(false);
+    expect(isString({})).toBe(false);
+    expect(isString('1')).toBe(true);
+    expect(isString(1)).toBe(false);
+    expect(isString(true)).toBe(false);
+    expect(isString(false)).toBe(false);
+    expect(isString(new Date())).toBe(false);
+    expect(isString(() => {
+      return 2;
+    })).toBe(false);
+
+    expect(isString(/[ab]/g)).toBe(false);
+  });
+});
diff --git a/src/predicate/isString.ts b/src/predicate/isString.ts
new file mode 100644
index 0000000..5283fc0
--- /dev/null
+++ b/src/predicate/isString.ts
@@ -0,0 +1,3 @@
+export function isString(val: unknown): val is string {
+  return typeof val === 'string';
+}
diff --git a/src/predicate/isUndefined.ts b/src/predicate/isUndefined.ts
index 8856847..f93adc9 100644
--- a/src/predicate/isUndefined.ts
+++ b/src/predicate/isUndefined.ts
@@ -1,3 +1,5 @@
+import { toString } from './_internal/toString';
+
 /**
  * Checks if the given value is undefined.
  *
@@ -18,6 +20,7 @@
  * console.log(isUndefined(value2)); // false
  * console.log(isUndefined(value3)); // false
  */
-export function isUndefined(x: unknown): x is undefined {
-  return x === undefined;
+
+export function isUndefined(val: any): val is undefined {
+  return toString(val) === '[object Undefined]';
 }
diff --git a/src/predicate/isWindow.spec.ts b/src/predicate/isWindow.spec.ts
new file mode 100644
index 0000000..dda089a
--- /dev/null
+++ b/src/predicate/isWindow.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { isWindow } from './isWindow';
+
+describe('isWindow', () => {
+  it('case1', () => {
+    expect(isWindow(null)).toBe(false);
+    expect(isWindow(undefined)).toBe(false);
+    expect(isWindow({})).toBe(false);
+    expect(isWindow('1')).toBe(false);
+    expect(isWindow(1)).toBe(false);
+    expect(isWindow(true)).toBe(false);
+    expect(isWindow(false)).toBe(false);
+    expect(isWindow(new Date())).toBe(false);
+    expect(isWindow(() => {
+      return 2;
+    })).toBe(false);
+
+    expect(isWindow(/[ab]/g)).toBe(false);
+  });
+});
diff --git a/src/predicate/isWindow.ts b/src/predicate/isWindow.ts
new file mode 100644
index 0000000..badeb7c
--- /dev/null
+++ b/src/predicate/isWindow.ts
@@ -0,0 +1,6 @@
+import { toString } from './_internal/toString';
+
+export function isWindow(val: any): boolean {
+  // @ts-expect-error
+  return typeof window !== 'undefined' && toString(val) === '[object Window]';
+}