javascript转c,javascript转c语言

JavaScript改写为C

MFC里面有个CTime类，你可以拿来直接用

进贤网站建设公司成都创新互联,进贤网站设计制作，有大型网站制作公司丰富经验。已为进贤超过千家提供企业网站建设服务。企业网站搭建\外贸营销网站建设要多少钱，请找那个售后服务好的进贤做网站的公司定做！

#include time.h

#include assert.h

#include stdio.h

class CTimeSpan

{

public:

CTimeSpan() throw();

CTimeSpan( __time64_t time ) throw();

CTimeSpan( long lDays, int nHours, int nMins, int nSecs ) throw();

__int64 GetDays() const throw();

__int64 GetTotalHours() const throw();

long GetHours() const throw();

__int64 GetTotalMinutes() const throw();

long GetMinutes() const throw();

__int64 GetTotalSeconds() const throw();

long GetSeconds() const throw();

__time64_t GetTimeSpan() const throw();

CTimeSpan operator+( CTimeSpan span ) const throw();

CTimeSpan operator-( CTimeSpan span ) const throw();

CTimeSpan operator+=( CTimeSpan span ) throw();

CTimeSpan operator-=( CTimeSpan span ) throw();

bool operator==( CTimeSpan span ) const throw();

bool operator!=( CTimeSpan span ) const throw();

bool operator( CTimeSpan span ) const throw();

bool operator( CTimeSpan span ) const throw();

bool operator=( CTimeSpan span ) const throw();

bool operator=( CTimeSpan span ) const throw();

private:

__time64_t m_timeSpan;

};

inline CTimeSpan::CTimeSpan() throw() : 

m_timeSpan(0)

{

}

inline CTimeSpan::CTimeSpan( __time64_t time ) throw() : 

m_timeSpan( time )

{

}

inline CTimeSpan::CTimeSpan(long lDays, int nHours, int nMins, int nSecs) throw()

{

m_timeSpan = nSecs + 60* (nMins + 60* (nHours + __int64(24) * lDays));

}

inline __int64 CTimeSpan::GetDays() const throw()

{

return( m_timeSpan/(24*3600) );

}

inline __int64 CTimeSpan::GetTotalHours() const throw()

{

return( m_timeSpan/3600 );

}

inline long CTimeSpan::GetHours() const throw()

{

return( long( GetTotalHours()-(GetDays()*24) ) );

}

inline __int64 CTimeSpan::GetTotalMinutes() const throw()

{

return( m_timeSpan/60 );

}

inline long CTimeSpan::GetMinutes() const throw()

{

return( long( GetTotalMinutes()-(GetTotalHours()*60) ) );

}

inline __int64 CTimeSpan::GetTotalSeconds() const throw()

{

return( m_timeSpan );

}

inline long CTimeSpan::GetSeconds() const throw()

{

return( long( GetTotalSeconds()-(GetTotalMinutes()*60) ) );

}

inline __time64_t CTimeSpan::GetTimeSpan() const throw()

{

return( m_timeSpan );

}

inline CTimeSpan CTimeSpan::operator+( CTimeSpan span ) const throw()

{

return( CTimeSpan( m_timeSpan+span.m_timeSpan ) );

}

inline CTimeSpan CTimeSpan::operator-( CTimeSpan span ) const throw()

{

return( CTimeSpan( m_timeSpan-span.m_timeSpan ) );

}

inline CTimeSpan CTimeSpan::operator+=( CTimeSpan span ) throw()

{

m_timeSpan += span.m_timeSpan;

return( *this );

}

inline CTimeSpan CTimeSpan::operator-=( CTimeSpan span ) throw()

{

m_timeSpan -= span.m_timeSpan;

return( *this );

}

inline bool CTimeSpan::operator==( CTimeSpan span ) const throw()

{

return( m_timeSpan == span.m_timeSpan );

}

inline bool CTimeSpan::operator!=( CTimeSpan span ) const throw()

{

return( m_timeSpan != span.m_timeSpan );

}

inline bool CTimeSpan::operator( CTimeSpan span ) const throw()

{

return( m_timeSpan  span.m_timeSpan );

}

inline bool CTimeSpan::operator( CTimeSpan span ) const throw()

{

return( m_timeSpan  span.m_timeSpan );

}

inline bool CTimeSpan::operator=( CTimeSpan span ) const throw()

{

return( m_timeSpan = span.m_timeSpan );

}

inline bool CTimeSpan::operator=( CTimeSpan span ) const throw()

{

return( m_timeSpan = span.m_timeSpan );

}

class CTime

{

public:

static CTime __stdcall GetCurrentTime() throw();

CTime() throw();

CTime( __time64_t time ) throw();

CTime( int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec,

int nDST = -1 );

CTime( unsigned short wDosDate, unsigned short wDosTime, int nDST = -1 );

CTime operator=( __time64_t time ) throw();

CTime operator+=( CTimeSpan span ) throw();

CTime operator-=( CTimeSpan span ) throw();

CTimeSpan operator-( CTime time ) const throw();

CTime operator-( CTimeSpan span ) const throw();

CTime operator+( CTimeSpan span ) const throw();

bool operator==( CTime time ) const throw();

bool operator!=( CTime time ) const throw();

bool operator( CTime time ) const throw();

bool operator( CTime time ) const throw();

bool operator=( CTime time ) const throw();

bool operator=( CTime time ) const throw();

struct tm* GetGmtTm( struct tm* ptm ) const;

struct tm* GetLocalTm( struct tm* ptm ) const;

__time64_t GetTime() const throw();

int GetYear() const throw();

int GetMonth() const throw();

int GetDay() const throw();

int GetHour() const throw();

int GetMinute() const throw();

int GetSecond() const throw();

int GetDayOfWeek() const throw();

private:

__time64_t m_time;

};

inline CTime __stdcall CTime::GetCurrentTime() throw()

{

return( CTime( ::_time64( NULL ) ) );

}

inline CTime::CTime() throw() : 

m_time(0)

{

}

inline CTime::CTime( __time64_t time ) throw(): 

m_time( time )

{

}

inline CTime::CTime(int nYear, int nMonth, int nDay, int nHour, int nMin, int nSec,

int nDST)

{

#pragma warning (push)

#pragma warning (disable: 4127) // conditional expression constant

assert( nYear = 1900 );

assert( nMonth = 1  nMonth = 12 );

assert( nDay = 1  nDay = 31 );

assert( nHour = 0  nHour = 23 );

assert( nMin = 0  nMin = 59 );

assert( nSec = 0  nSec = 59 );

#pragma warning (pop)

struct tm atm;

atm.tm_sec = nSec;

atm.tm_min = nMin;

atm.tm_hour = nHour;

atm.tm_mday = nDay;

atm.tm_mon = nMonth - 1; // tm_mon is 0 based

atm.tm_year = nYear - 1900; // tm_year is 1900 based

atm.tm_isdst = nDST;

m_time = _mktime64(atm);

assert(m_time != -1); // indicates an illegal input time

}

inline CTime::CTime(unsigned short wDosDate, unsigned short wDosTime, int nDST)

{

struct tm atm;

atm.tm_sec = (wDosTime  ~0xFFE0)  1;

atm.tm_min = (wDosTime  ~0xF800)  5;

atm.tm_hour = wDosTime  11;

atm.tm_mday = wDosDate  ~0xFFE0;

atm.tm_mon = ((wDosDate  ~0xFE00)  5) - 1;

atm.tm_year = (wDosDate  9) + 80;

atm.tm_isdst = nDST;

m_time = _mktime64(atm);

assert(m_time != -1); // indicates an illegal input time

}

inline CTime CTime::operator=( __time64_t time ) throw()

{

m_time = time;

return( *this );

}

inline CTime CTime::operator+=( CTimeSpan span ) throw()

{

m_time += span.GetTimeSpan();

return( *this );

}

inline CTime CTime::operator-=( CTimeSpan span ) throw()

{

m_time -= span.GetTimeSpan();

return( *this );

}

inline CTimeSpan CTime::operator-( CTime time ) const throw()

{

return( CTimeSpan( m_time-time.m_time ) );

}

inline CTime CTime::operator-( CTimeSpan span ) const throw()

{

return( CTime( m_time-span.GetTimeSpan() ) );

}

inline CTime CTime::operator+( CTimeSpan span ) const throw()

{

return( CTime( m_time+span.GetTimeSpan() ) );

}

inline bool CTime::operator==( CTime time ) const throw()

{

return( m_time == time.m_time );

}

inline bool CTime::operator!=( CTime time ) const throw()

{

return( m_time != time.m_time );

}

inline bool CTime::operator( CTime time ) const throw()

{

return( m_time  time.m_time );

}

inline bool CTime::operator( CTime time ) const throw()

{

return( m_time  time.m_time );

}

inline bool CTime::operator=( CTime time ) const throw()

{

return( m_time = time.m_time );

}

inline bool CTime::operator=( CTime time ) const throw()

{

return( m_time = time.m_time );

}

inline struct tm* CTime::GetGmtTm(struct tm* ptm) const

{

// Ensure ptm is valid

assert( ptm != NULL );

if (ptm != NULL)

{

struct tm ptmTemp;

errno_t err = _gmtime64_s(ptmTemp, m_time);

// Be sure the call succeeded

if(err != 0) { return NULL; }

*ptm = ptmTemp;

return ptm;

}

return NULL;

}

inline struct tm* CTime::GetLocalTm(struct tm* ptm) const

{

// Ensure ptm is valid

assert( ptm != NULL );

if (ptm != NULL)

{

struct tm ptmTemp;

errno_t err = _localtime64_s(ptmTemp, m_time);

if (err != 0)

{

return NULL; // indicates that m_time was not initialized!

}

*ptm = ptmTemp;

return ptm;

}

return NULL;

}

inline __time64_t CTime::GetTime() const throw()

{

return( m_time );

}

inline int CTime::GetYear() const

{ 

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? (ptm-tm_year) + 1900 : 0 ; 

}

inline int CTime::GetMonth() const

{ 

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_mon + 1 : 0;

}

inline int CTime::GetDay() const

{

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_mday : 0 ; 

}

inline int CTime::GetHour() const

{

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_hour : -1 ; 

}

inline int CTime::GetMinute() const

{

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_min : -1 ; 

}

inline int CTime::GetSecond() const

{ 

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_sec : -1 ;

}

inline int CTime::GetDayOfWeek() const

{ 

struct tm ttm;

struct tm * ptm;

ptm = GetLocalTm(ttm);

return ptm ? ptm-tm_wday + 1 : 0 ;

}

void date()

{

CTime together = CTime(2013, 6, 22, 12, 30, 30);

CTime now = CTime::GetCurrentTime();

CTimeSpan left=now-together;

printf("%ld天",left.GetDays());

printf("%02ld时",left.GetHours());

printf("%02ld分",left.GetMinutes());

printf("%02ld秒",left.GetSeconds());

}

void main()

{

date();

}

用js写出a b c转化为c b a

var a = ["a","b","c"];

var b = a.reverse(); // b的结果为["c", "b", "a"]

这个地址可以完美的给你回答，另外你要学会百度，先百度再提问。你的问题可以描述为数组反转

如何将javascript代码编译为c++或java

java是不能够编译C/C++文件的。他们原理完全不同。背后的运行机制也完全不一样。

C/C++源文件只能够用C/C++的编译器来编译。

以GCC编译器为例，整个编译可以分为四步。

第一步是预处理，包括语法检查等工作。

gcc -P abc.c

第二步由源程序生产汇编语言代码。

gcc -S abc.c

会生成abc.s文件，这个文件里就是汇编代码。

第三步编译器生成目标代码，一个源文件生成一个目标代码。

gcc -c abc.c

会生成abc.o

第四步连接器从目标代码生成可执行文件。

gcc abc.o

目标代码包括机器码和符号表（函数及变量名）。连接器的主要作用是通过符号表在库文件和其他模块中找到在目标代码中引入或未定义的符号（函数及变量名），将几个目标代码合成可执行文件。