myesn

## animate-on-hover.html
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css" />
    <style>
        .container {

## BinaryTreeTraversal.cs

var root = new TreeNode(1)
{
    Left = new TreeNode(2)
    {
        Left = new TreeNode(4),
        Right = new TreeNode(5)
    },
    Right = new TreeNode(3)
    {

## SearchIn2DMatrix.cs
/*
  Q: 给定一个的目标值，在一个横向有序和纵向有序的二维数组（矩阵 matrix）中找到该目标值的坐标


  可以从矩阵的右上角或者左下角开始查找。
  假设从右上角开始查询：
    如果当前元素大于目标值，则可以排除当前元素所在的列，因为这一列都会比目标值大；
    如果当前元素小于目标值，则可以排除当前元素所在的行，因为这一行都会比目标值小。
  通过这种方式，每次都可以排除一整行或者一整列，大大减少了比较的次数，时间复杂度为 O(m+n)
*/

## BinarySearch.cs
int[] array = { 1,11,21,31,41 };

foreach(int num in array) {
  Console.WriteLine(BinarySearchMatrix(array, num));
}

// 二分查找：在一维数组中找到目标值的索引
int BinarySearch(int[] array,int target)
{
    // 初始化指针，定义头指针 left、尾指针 right = 二维数组中一维数组的数量-1=4-1，双闭区间 [0, array.Length - 1]

## node-dns-benchmark.js
const { Resolver } = require('node:dns').promises;
const { performance } = require('perf_hooks');

const domain = 'giao.com';

const resolver = new Resolver();
resolver.setServers(['192.168.31.117']);

async function main() {
  const numIterations = 1;

## logging.middleware.ts
// logging.middleware.ts
import { Injectable, NestMiddleware } from '@nestjs/common';
import { NextFunction, Request, Response } from 'express';

@Injectable()
export class LoggingMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log(`start [${req.method}] ${req.url}`);
    const oldSend = res.send;
    res.send = (body: any): any => {

## logto-auth.guard.ts
import {
  Injectable,
  CanActivate,
  ExecutionContext,
  HttpStatus,
  BadRequestException,
  UnauthorizedException,
} from '@nestjs/common';
import { Request } from 'express';
import { ConfigService } from '@nestjs/config';

## Vue3-CRUD.vue
<script setup lang="ts">
import { reactive, shallowRef, watchEffect } from "vue";

interface Item {
  id: number;
  name: string;
}

const name = shallowRef<string>("");
const itemLength = shallowRef<number>(0);

## vue3-watchEffect.vue
<script setup>
import { ref, watchEffect } from 'vue'

const number = ref(0);
const unwatch = watchEffect((onCleanup) => {
  const id = setInterval(() => {
    number.value++;
  }, 1000);

  onCleanup(() => clearInterval(id));

## diff-between-datetime-by-rules.js

    getTimes(val) {
      const [startDateRaw, endDateRaw] = val;
      const startDate = new Date(startDateRaw);
      const endDate = new Date(endDateRaw);
      const diffOfMilliseconds = endDate - startDate; // 时间差，单位毫秒
      const hoursOfDay = 24; // 一天的小时数
      const millisencondsOfMinute = 60 * 1000; // 每分钟的毫秒数
      const millisencondsOfHour = 60 * millisencondsOfMinute; // 每小时的毫秒数
      const millisencondsOfDay = hoursOfDay * millisencondsOfHour; // 每天的毫秒数
	<!DOCTYPE html>
	<html lang="en">

	<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<title>Document</title>
	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css" />
	<style>
	.container {

	var root = new TreeNode(1)
	{
	Left = new TreeNode(2)
	{
	Left = new TreeNode(4),
	Right = new TreeNode(5)
	},
	Right = new TreeNode(3)
	{
	/*
	Q: 给定一个的目标值，在一个横向有序和纵向有序的二维数组（矩阵 matrix）中找到该目标值的坐标


	可以从矩阵的右上角或者左下角开始查找。
	假设从右上角开始查询：
	如果当前元素大于目标值，则可以排除当前元素所在的列，因为这一列都会比目标值大；
	如果当前元素小于目标值，则可以排除当前元素所在的行，因为这一行都会比目标值小。
	通过这种方式，每次都可以排除一整行或者一整列，大大减少了比较的次数，时间复杂度为 O(m+n)
	*/
	int[] array = { 1,11,21,31,41 };

	foreach(int num in array) {
	Console.WriteLine(BinarySearchMatrix(array, num));
	}

	// 二分查找：在一维数组中找到目标值的索引
	int BinarySearch(int[] array,int target)
	{
	// 初始化指针，定义头指针 left、尾指针 right = 二维数组中一维数组的数量-1=4-1，双闭区间 [0, array.Length - 1]
	const { Resolver } = require('node:dns').promises;
	const { performance } = require('perf_hooks');

	const domain = 'giao.com';

	const resolver = new Resolver();
	resolver.setServers(['192.168.31.117']);

	async function main() {
	const numIterations = 1;
	// logging.middleware.ts
	import { Injectable, NestMiddleware } from '@nestjs/common';
	import { NextFunction, Request, Response } from 'express';

	@Injectable()
	export class LoggingMiddleware implements NestMiddleware {
	use(req: Request, res: Response, next: NextFunction) {
	console.log(`start [${req.method}] ${req.url}`);
	const oldSend = res.send;
	res.send = (body: any): any => {
	import {
	Injectable,
	CanActivate,
	ExecutionContext,
	HttpStatus,
	BadRequestException,
	UnauthorizedException,
	} from '@nestjs/common';
	import { Request } from 'express';
	import { ConfigService } from '@nestjs/config';
	<script setup lang="ts">
	import { reactive, shallowRef, watchEffect } from "vue";

	interface Item {
	id: number;
	name: string;
	}

	const name = shallowRef<string>("");
	const itemLength = shallowRef<number>(0);
	<script setup>
	import { ref, watchEffect } from 'vue'

	const number = ref(0);
	const unwatch = watchEffect((onCleanup) => {
	const id = setInterval(() => {
	number.value++;
	}, 1000);

	onCleanup(() => clearInterval(id));

	getTimes(val) {
	const [startDateRaw, endDateRaw] = val;
	const startDate = new Date(startDateRaw);
	const endDate = new Date(endDateRaw);
	const diffOfMilliseconds = endDate - startDate; // 时间差，单位毫秒
	const hoursOfDay = 24; // 一天的小时数
	const millisencondsOfMinute = 60 * 1000; // 每分钟的毫秒数
	const millisencondsOfHour = 60 * millisencondsOfMinute; // 每小时的毫秒数
	const millisencondsOfDay = hoursOfDay * millisencondsOfHour; // 每天的毫秒数