软件架构设计之Utility模块——DateTime

最新推荐文章于 2019-01-26 10:26:29 发布
最新推荐文章于 2019-01-26 10:26:29 发布
阅读量51 收藏
点赞数

这里的日期实现比较简单：采用的是UTC日期（现在还不涉及到其他日期格式的转换如Gregorian日历），且以星期一作为每周的第一天。剩下的就看代码吧：

头文件：

class UTIL_API YKDateTime
{
public:
	enum DT_FORM
	{
		DTF_YMDHMS1,		//%Y-%m-%d %H:%M:%S，中文格式选此
		DTF_YMDHMS2,		//%m/%d/%Y %H:%M:%S
		DTF_YMDHM1,		//%Y-%m-%d %H:%M，中文格式选此
		DTF_YMDHM2,		//%Y/%m/%d %H:%M
		DTF_YMD1,		//%Y-%m-%d，中文格式选此
		DTF_YMD2,		//%Y/%m/%d
		DTF_HMS1,		//%H:%M:%S，中文格式选此
		DTF_HM1,			//%H:%M，中文格式选此
		DTF_MDYHMS1,		//%m-%d-%Y %H:%M:%S
		DTF_MDYHMS2,		//%m/%d/%Y %H:%M:%S
		DTF_MDYHM1,		//%m-%d-%Y %H:%M
		DTF_MDYHM2,		//%m/%d/%Y %H:%M
		DTF_MDY1,		//%m-%d-%Y
		DTF_MDY2,		//%m/%d/%Y
	};

	static YK_UINT PER_SECOND;
	static YK_UINT PER_MINUTE;
	static YK_UINT PER_HOUR;
	static YK_UINT PER_DAY;
	//static YK_UINT PER_MONTH;	每个月的天数并不相同，因此不定义
	static YK_UINT PER_YEAR;
public:
	YKDateTime(YK_TM tm = 0);
	YKDateTime(YK_INT nYear, YK_INT nMonth, YK_INT nDay, 
		YK_INT nHour = 0, YK_INT nMinute = 0, YK_INT nSecond = 0);

	~YKDateTime(void);

	static YKDateTime GetLocalTime();

	YKDateTime& operator=(YK_TM tm)
	{ m_time = tm; return *this; }

	// 是否是有效日期
	YK_BOOL ValidDateTime();

	YK_TM GetDateTime() const { return m_time; }
	YKDateTime GetDate();			// 获取年月日
	YK_INT GetYear() const;			// 获取年
	YK_INT GetMonth() const;		// 获取月
	YK_INT GetDay() const;			// 获取天
	YK_INT GetHour() const;			// 获取小时
	YK_INT GetMinute() const;		// 获取分钟
	YK_INT GetSecond() const;		// 获取秒
	YK_INT GetDayOfYear() const;	// 获取时间所在年的第几天
	YK_INT GetDayOfMonth() const;	// 获取时间所在月的第几天
	YK_INT GetDayOfWeek() const;	// 获取时间所在周的第几天，星期一作为第一天，（1~7）
	YK_INT GetWeekOfYear() const;	// 获取时间所在年的第几周，星期一作为第一天，（1~54）
	YK_INT GetWeekOfMonth() const;	// 获取时间所在月的第几周
	YK_INT GetFirstDayOfWeek() const; // 获取时间所在周的第一天

	YKString Format(DT_FORM dtf = DTF_YMDHMS1);
	// 日期或时间中文格式化 XXXX年XX月XX日 XX时XX分XX秒
	YKString FormatChs(DT_FORM dtf = DTF_YMDHMS1);
	YKString FormatPostfix(YK_WCHAR postfix);
	
	// 从字符串中提取日期时间
	static YKDateTime ParseDateTime(const YKString& str, DT_FORM tf = DTF_YMDHMS1);
	static YKDateTime ParseDateTimeChs(const YKString& str, DT_FORM tf = DTF_YMDHMS1);

	// 与当前时间相比，是否流逝了val秒
	YK_BOOL IsElapsed(YK_TM val) const;
	void AddSecond(YK_INT second)
	{ *this += (second); }
	void AddMinute(YK_INT minute)
	{ AddSecond(minute*PER_MINUTE); }
	void AddHour(YK_INT hour)
	{ AddMinute(hour*PER_HOUR); }
	void AddDay(YK_INT day)
	{ AddHour(day*PER_DAY); }
	void AddMonth(YK_INT month);
	void AddYear(YK_INT year)
	{ AddMonth(year*PER_YEAR); }

	YKDateTime& operator+=(const YKDateTime& tm)
	{ this->m_time += tm.m_time; return *this; }
	YKDateTime& operator-=(const YKDateTime& tm)
	{ this->m_time -= tm.m_time; return *this; }

	YK_BOOL operator==(const YKDateTime& tm) const
	{ return this->m_time == tm.m_time; }
	YK_BOOL operator!=(const YKDateTime& tm ) const
	{ return !(*this == tm); }
	YK_BOOL operator>(const YKDateTime& tm ) const
	{ return this->m_time > tm.m_time; }
	YK_BOOL operator>=(const YKDateTime& tm ) const
	{ return !(*this < tm); }
	YK_BOOL operator<(const YKDateTime& tm ) const
	{ return tm > *this ; }
	YK_BOOL operator<=(const YKDateTime& tm ) const
	{ return !(*this > tm); }

protected:
	YKString GetDTFormValue(DT_FORM dtf);

private:
	YK_TM	m_time;
};

实现部分：

YK_UINT YKDateTime::PER_SECOND  = 1000;
YK_UINT YKDateTime::PER_MINUTE = 60;
YK_UINT YKDateTime::PER_HOUR = 60;
YK_UINT YKDateTime::PER_DAY = 24;
YK_UINT YKDateTime::PER_YEAR = 12;
YKDateTime::YKDateTime( YK_TM tm /* = 0 */ )
	: m_time(tm)
{

}

YKDateTime::YKDateTime( YK_INT nYear, YK_INT nMonth, YK_INT nDay, YK_INT nHour /*= 0*/, YK_INT nMinute /*= 0*/, YK_INT nSecond /*= 0*/ )
{
	tm t1;
	t1.tm_year = nYear-1900;
	t1.tm_mon = nMonth-1;
	t1.tm_mday = nDay;
	t1.tm_hour = nHour;
	t1.tm_min = nMinute;
	t1.tm_sec = nSecond;

	m_time = _mktime64(&t1);
}

YKDateTime::~YKDateTime(void)
{
}

YKDateTime YKDateTime::GetLocalTime()
{
	return YKDateTime(time(NULL));
}

YK_BOOL YKDateTime::ValidDateTime()
{
	YKDateTime dtTemp(1900, 1, 1);
	return m_time >= dtTemp.m_time;
}

YKDateTime YKDateTime::GetDate()
{
	return YKDateTime(GetYear(), GetMonth(), GetDay());
}

YK_INT YKDateTime::GetYear() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_year + 1900;
}

YK_INT YKDateTime::GetMonth() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_mon + 1;
}

YK_INT YKDateTime::GetDay() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_mday;
}

YK_INT YKDateTime::GetHour() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_hour;
}

YK_INT YKDateTime::GetMinute() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_min;
}

YK_INT YKDateTime::GetSecond() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_sec;
}

YK_INT YKDateTime::GetDayOfYear() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	char temp[128];
	strftime(temp, 128, "%j", &t1);
	return atoi(temp);
}

YK_INT YKDateTime::GetDayOfMonth() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_mday;
}

YK_INT YKDateTime::GetDayOfWeek() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	return t1.tm_wday == 0 ? 7 : t1.tm_wday;
}

YK_INT YKDateTime::GetWeekOfYear() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	char temp[128];
	strftime(temp, 128, "%W", &t1);
	return atoi(temp)+1;
}

YK_INT YKDateTime::GetWeekOfMonth() const
{
	tm t1;
	localtime_s(&t1, &m_time);
	char temp[128];
	strftime(temp, 128, "%w", &t1);
	return atoi(temp);
}

YK_INT YKDateTime::GetFirstDayOfWeek() const
{
	YKDateTime dt(m_time);
	YK_INT dayDiff = GetDayOfWeek()-1;
	assert(dayDiff > 0);
	dt.AddDay(-dayDiff);
	return dt.GetDay();
}

YKString YKDateTime::Format( DT_FORM dtf /* = TF_YMDHMS1 */ )
{
	tm t1;
	localtime_s(&t1, &m_time);
	YK_WCHAR temp[128];
	wcsftime(temp, 128, GetDTFormValue(dtf).c_str(), &t1);
	return temp;
}

YKString YKDateTime::FormatChs( DT_FORM dtf /* = DTF_YMDHMS1 */ )
{
	tm t1;
	localtime_s(&t1, &m_time);
	YKString str;
	YK_BOOL bDate = false;
	switch (dtf)
	{
	case DTF_YMDHMS1:
	case DTF_YMDHM1:
	case DTF_YMD1:
		{
			str += YKString::Format(t1.tm_year+1900) + L"年";
			str += YKString::FormatDigit(t1.tm_mon+1, 2) + L"月";
			str += YKString::FormatDigit(t1.tm_mday, 2) + L"日";
			bDate = true;
		}
		break;
	}

	switch (dtf)
	{
	case DTF_YMDHMS1:
	case DTF_YMDHM1:
	case DTF_HMS1:
	case DTF_HM1:
		{
			if (bDate) str += L" ";
			str += YKString::FormatDigit(t1.tm_hour, 2) + L"时";
			str += YKString::FormatDigit(t1.tm_min, 2) + L"分";
		}
		break;

	}

	switch (dtf)
	{
	case DTF_YMDHMS1:
	case DTF_HMS1:
		{
			str += YKString::FormatDigit(t1.tm_sec, 2) + L"秒";
		}
		break;
	}

	return str;
}

YKString YKDateTime::FormatPostfix(YK_WCHAR postfix)
{
	YKString str;
	switch (postfix)
	{
	case L'S':
		str = YKString::Format(m_time);
		break;
	case L'M':
		str = YKString::Format(((YK_DOUBLE)m_time)/PER_MINUTE);
		break;
	case L'H':
		str = YKString::Format(((YK_DOUBLE)m_time)/(PER_HOUR*PER_MINUTE));
		break;
	case L'D':
		str = YKString::Format(((YK_DOUBLE)m_time)/(PER_DAY*PER_HOUR*PER_MINUTE));
		break;
	default: return str;
	}

	str += postfix;
	return str;
}

YKDateTime YKDateTime::ParseDateTime(const YKString& str, DT_FORM tf /* = TF_YMDHMS1 */)
{
	switch (tf)
	{
	case DTF_YMDHMS1:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"-");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 3)
				{
					return YKDateTime(vecDate[0], vecDate[1], vecDate[2], vecTime[0], vecTime[1], vecTime[2]);
				}
			}
		}
		break;
	case DTF_YMDHMS2:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"/");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 3)
				{
					return YKDateTime(vecDate[0], vecDate[1], vecDate[2], vecTime[0], vecTime[1], vecTime[2]);
				}
			}
		}
		break;
	case DTF_YMDHM1:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"-");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 2)
				{
					return YKDateTime(vecDate[0], vecDate[1], vecDate[2], vecTime[0], vecTime[1]);
				}
			}
		}
		break;
	case DTF_YMDHM2:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"/");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 2)
				{
					return YKDateTime(vecDate[0], vecDate[1], vecDate[2], vecTime[0], vecTime[1]);
				}
			}
		}
		break;
	case DTF_YMD1:
		{
			std::vector<YK_ULONG> vecDate = str.Parse<YK_ULONG>(L"-");
			if (vecDate.size() == 3)
			{
				return YKDateTime(vecDate[0], vecDate[1], vecDate[2]);
			}
		}
		break;
	case DTF_YMD2:
		{
			std::vector<YK_ULONG> vecDate = str.Parse<YK_ULONG>(L"/");
			if (vecDate.size() == 3)
			{
				return YKDateTime(vecDate[0], vecDate[1], vecDate[2]);
			}
		}
		break;
	case DTF_HMS1:
		{
			std::vector<YK_ULONG> vecTime = str.Parse<YK_ULONG>(L":");
			if (vecTime.size() == 3)
			{
				return YKDateTime(1970, 1, 1, vecTime[0], vecTime[1], vecTime[2]);
			}
		}
		break;
	case DTF_HM1:
		{
			std::vector<YK_ULONG> vecTime = str.Parse<YK_ULONG>(L":");
			if (vecTime.size() == 2)
			{
				return YKDateTime(1970, 1, 1, vecTime[0], vecTime[1]);
			}
		}
		break;
	case DTF_MDYHMS1:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"-");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 3)
				{
					return YKDateTime(vecDate[2], vecDate[0], vecDate[1], vecTime[0], vecTime[1], vecTime[2]);
				}
			}
		}
		break;
	case DTF_MDYHMS2:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"/");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 3)
				{
					return YKDateTime(vecDate[2], vecDate[0], vecDate[1], vecTime[0], vecTime[1], vecTime[2]);
				}
			}
		}
		break;
	case DTF_MDYHM1:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"-");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 2)
				{
					return YKDateTime(vecDate[2], vecDate[0], vecDate[1], vecTime[0], vecTime[1]);
				}
			}
		}
		break;
	case DTF_MDYHM2:
		{
			std::vector<YKString> vecDT = str.Parse<YKString>(L" ");
			if (vecDT.size() == 2)
			{
				std::vector<YK_ULONG> vecDate = vecDT[0].Parse<YK_ULONG>(L"/");
				std::vector<YK_ULONG> vecTime = vecDT[1].Parse<YK_ULONG>(L":");
				if (vecDate.size() == 3 && vecTime.size() == 2)
				{
					return YKDateTime(vecDate[2], vecDate[0], vecDate[1], vecTime[0], vecTime[1]);
				}
			}
		}
		break;
	case DTF_MDY1:
		{
			std::vector<YK_ULONG> vecDate = str.Parse<YK_ULONG>(L"-");
			if (vecDate.size() == 3)
			{
				return YKDateTime(vecDate[2], vecDate[0], vecDate[1]);
			}
		}
		break;
	case DTF_MDY2:
		{
			std::vector<YK_ULONG> vecDate = str.Parse<YK_ULONG>(L"/");
			if (vecDate.size() == 3)
			{
				return YKDateTime(vecDate[2], vecDate[0], vecDate[1]);
			}
		}
		break;
	}
	
	return 0;
}

YKString YKDateTime::GetDTFormValue( DT_FORM dtf )
{
	YKString str;
	switch (dtf)
	{
	case DTF_YMDHMS1:
		str = L"%Y-%m-%d %H:%M:%S";
		break;
	case DTF_YMDHMS2:
		str = L"%Y/%m/%d %H:%M:%S";
		break;
	case DTF_YMDHM1:
		str = L"%Y-%m-%d %H:%M";
		break;
	case DTF_YMDHM2:
		str = L"%Y/%m/%d %H:%M";
		break;
	case DTF_YMD1:
		str = L"%Y-%m-%d";
		break;
	case DTF_YMD2:
		str = L"%Y/%m/%d";
		break;
	case DTF_HMS1:
		str = L"%H:%M:%S";
		break;
	case DTF_HM1:
		str = L"%H:%M";
		break;
	case DTF_MDYHMS1:
		str = L"%m-%d-%Y %H:%M:%S";
		break;
	case DTF_MDYHMS2:
		str = L"%m/%d/%Y %H:%M:%S";
		break;
	case DTF_MDYHM1:
		str = L"%m-%d-%Y %H:%M";
		break;
	case DTF_MDYHM2:
		str = L"%m/%d/%Y %H:%M";
		break;
	case DTF_MDY1:
		str = L"%m-%d-%Y";
		break;
	case DTF_MDY2:
		str = L"%m/%d/%Y";
		break;
	}

	return str;
}

YKDateTime YKDateTime::ParseDateTimeChs( const YKString& str, DT_FORM tf /*= DTF_YMDHMS1*/ )
{
	YKString::size_type fPos = 0, lPos = 0;
	std::vector<YK_UINT> vecVal;
	for (; lPos < str.size(); ++lPos)
	{
		if (str.IsAlpha(lPos))
		{
			YKString strTemp = str.substr(fPos, lPos-fPos);
			strTemp.TrimLeft();
			vecVal.push_back(strTemp.Convert<YK_UINT>());
			fPos = lPos+1;
		}
	}

	switch (tf)
	{
	case DTF_YMDHMS1:
		return YKDateTime(vecVal[0], vecVal[1], vecVal[2], vecVal[3], vecVal[4], vecVal[5]);
		break;
	case DTF_YMDHM1:
		return YKDateTime(vecVal[0], vecVal[1], vecVal[2], vecVal[3], vecVal[4]);
		break;
	case DTF_YMD1:
		return YKDateTime(vecVal[0], vecVal[1], vecVal[2]);
		break;
	case DTF_HMS1:
		return YKDateTime(1970, 1, 1, vecVal[0], vecVal[1], vecVal[2]);
		break;
	case DTF_HM1:
		return YKDateTime(1970, 1, 1, vecVal[0], vecVal[1]);
		break;
	default: break;
	}
	return 0;
}

YK_BOOL YKDateTime::IsElapsed( YK_TM val ) const
{
	YKDateTime dtNow = YKDateTime::GetLocalTime();
	return (dtNow.m_time-m_time) >= val;
}

void YKDateTime::AddMonth( YK_INT month )
{
	tm t1;
	localtime_s(&t1, &m_time);

	YK_INT absMonth = month;
	if (month < 0)
		absMonth = abs(month);

	YK_INT year = absMonth / PER_YEAR;
	YK_INT mon = absMonth % PER_YEAR;
	if (month > 0)
	{
		*this = YKDateTime(t1.tm_year+1900+year, t1.tm_mon+mon, t1.tm_mday, t1.tm_hour, t1.tm_min, t1.tm_sec);
	}
	else
	{
		*this = YKDateTime(t1.tm_year+1900-year, t1.tm_mon-mon, t1.tm_mday, t1.tm_hour, t1.tm_min, t1.tm_sec);
	}
}


 

weixin_34380296
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python基础——time模块和datetime模块.pdf
11-27
python基础——time模块和datetime模块
C# 最牛逼的Utility工具类
dingtuo8679的博客
03-12 1257
完整代码: using System; using System.Collections.Specialized; using System.IO; using System.Net; using System.Text; using System.Text.RegularExpressions; using System.Collections.Generi...
软件架构设计之Utility模块——智能指针
backo880607的专栏
03-18 1277
一：前言          大家应该明白智能指针的用途（管理动态对象的生命期）及好处。其他话就不多说了，直接看如何实现吧。你将会看到一个基于策略而实作出的无比强大，灵活的智能指针。参考的依然是《Modern C++ Design》一书。 二：原理说明          软件工程比其他工程有更丰富的多样性。你可以采用多种正确的方法去完成一件事情。一旦你选择了一种解决方案，便会有一大堆变化随之涌
InsusDateTimeUtility
weixin_33800593的博客
05-14 53
一个日期时间自定义组件。 用法:using Insus.NET; 类别名称：InsusDateTimeUtility 下载地址: http://download.cnblogs.com/insus/library/InsusDateTimeUtility.zip  
渗透之——Metasploit命令及模块
热门推荐
冰河的专栏
01-26 2万+
show exploits 列出metasploit框架中的所有渗透攻击模块。 show payloads 列出metasploit框架中的所有攻击载荷。 show auxiliary 列出metasploit框架中的所有辅助攻击载荷。 search name 查找metasploit框架中所有的渗透攻击和其他模块。 info 展示出制定渗透攻击或模块的相关信息。 use name 装载一个渗透攻...
python的time模块和datetime模块实例解析
09-18
主要介绍了python的time模块和datetime模块实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
详解python时间模块中的datetime模块
09-21
主要为大家介绍了python时间模块中的datetime模块，datetime模块的接口则更直观、更容易调用，想要了解datetime模块的朋友可以参考一下
python3_系统时间调用_datetime模块
05-14
datetime模块使用案例源码、# 得到当前日期时间（两种方法）、# 得到当前日期 # 得到当前时间 # 得到当前年份用year_变量接收 # 得到当前月份用month_变量接收 # 得到当前天用day_变量接收 # 使用-拼接年月日得到...
Python Datetime模块和Calendar模块用法实例分析
09-19
主要介绍了Python Datetime模块和Calendar模块用法,结合实例形式分析了Python日期时间及日历相关的Datetime模块和Calendar模块原理、用法及操作注意事项,需要的朋友可以参考下
软件架构设计之Utility模块——Any
backo880607的专栏
03-23 1591
YKAny类用于保存任意类型的变量类似于variant_t。这里采用的是boost库中的Any实现原理，增加了两个Any之间比较的功能。看代码吧： class UTIL_API YKAny { class PlaceHolder { public: PlaceHolder() {} virtual ~PlaceHolder() {} virtual const std::ty
软件架构设计之Utility模块——string
backo880607的专栏
03-23 1932
YKString类是对STL 中的std::wstring的功能扩展，没有什么好解释的了，就直接看代码吧。 头文件： class YKString : public std::wstring { public: typedef std::wstring::size_type size_type; YKString() : std::wstring() {} YKString(const
串口到以太网模块：WIZ1000配置及测试
WIZnet2012专栏
12-03 3074
1.    简介 WIZ1000是一个串口到以太网设备服务器的模块，它是WIZnet的一款产品，并且该产品得到了CE, FCC和 KCC的认证。WIZ1000在RS-232和以太网之间扮演网关的角色。通过用RS-232串口连接到现有的设备，WIZ1000可以通过基于以太网和TCP/IP的网络对设备进行远程测量、管理和控制。换句话说, WIZ1000是一个协议转换器，把串口设备发来的数据转换成
2023年美赛特等奖论文-F-2305794-解密.pdf
05-06
大学生，数学建模，美国大学生数学建模竞赛，MCM/ICM，2023年美赛特等奖O奖论文
亚太经社会：2024年亚太贸易便利化报告.pdf
05-06
亚太经社会：2024年亚太贸易便利化报告.pdf
消费者价格指数下的年通货膨胀率（1960-2021年）.xls
05-06
消费者价格指数（CPI）：按消费者价格指数衡量的通货膨胀反映出普通消费者在指定时间间隔（如年度）内购买固定或变动的一篮子货物和服务的成本的年百分比变化。通常采用拉斯佩尔公式进行计算。
node-v8.10.0-linux-x86.tar.xz
最新发布
05-06
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
网页制作基础学习--HTML+CSS常用代码.txt
05-06
网页制作基础学习--HTML+CSS常用代码
如何用datetime模块设计到时自动运行的程序
05-30
你可以使用Python中的datetime和time模块来实现到时自动运行程序。具体实现过程如下： 1. 导入datetime和time模块： ```python import datetime import time ``` 2. 定义一个目标时间，如下所示： ```python ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值