文章 专题 AI工具 学习 下载 问答 源码 最近更新
PHP
会员中心 讲师中心 微信公众号
首页 > web前端 > js教程 > 正文

Javascript MD4_基础知识

php中文网
发布： 2016-05-16 19:23:15
原创
1362人浏览过
From:http://pajhome.org.uk/crypt/md5/md4src.html
<SPAN class=comment>/*
 * A JavaScript implementation of the RSA Data Security, Inc. MD4 Message
 * Digest Algorithm, as defined in RFC 1320.
 * Version 2.1 Copyright (C) Jerrad Pierce, Paul Johnston 1999 - 2002.
 * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
 * Distributed under the BSD License
 * See http://pajhome.org.uk/crypt/md5 for more info.
 */</SPAN>

<SPAN class=comment>/*
 * Configurable variables. You may need to tweak these to be compatible with
 * the server-side, but the defaults work in most cases.
 */</SPAN>
<SPAN class=reserved_word>var</SPAN> hexcase <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=comment>/* hex output format. 0 - lowercase; 1 - uppercase    */</SPAN>
<SPAN class=reserved_word>var</SPAN> b64pad <SPAN class=symbol>=</SPAN> <SPAN class=string>""</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=comment>/* base-64 pad character. "=" for strict RFC compliance  */</SPAN>
<SPAN class=reserved_word>var</SPAN> chrsz  <SPAN class=symbol>=</SPAN> <SPAN class=numeric>8</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=comment>/* bits per input character. 8 - ASCII; 16 - Unicode   */</SPAN>

<SPAN class=comment>/*
 * These are the functions you'll usually want to call
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> hex_md4<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN><SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2hex<SPAN class=braces>(</SPAN>core_md4<SPAN class=braces>(</SPAN>str2binl<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN>, s.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN><SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> b64_md4<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN><SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2b64<SPAN class=braces>(</SPAN>core_md4<SPAN class=braces>(</SPAN>str2binl<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN>, s.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN><SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> str_md4<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN><SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2str<SPAN class=braces>(</SPAN>core_md4<SPAN class=braces>(</SPAN>str2binl<SPAN class=braces>(</SPAN>s<SPAN class=braces>)</SPAN>, s.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN><SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> hex_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN> <SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2hex<SPAN class=braces>(</SPAN>core_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> b64_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN> <SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2b64<SPAN class=braces>(</SPAN>core_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> str_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN> <SPAN class=braces>{</SPAN> <SPAN class=reserved_word>return</SPAN> binl2str<SPAN class=braces>(</SPAN>core_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN> <SPAN class=braces>}</SPAN>

<SPAN class=comment>/* 
 * Perform a simple self-test to see if the VM is working 
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> md4_vm_test<SPAN class=braces>(</SPAN><SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> hex_md4<SPAN class=braces>(</SPAN><SPAN class=string>"abc"</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>=</SPAN><SPAN class=symbol>=</SPAN> <SPAN class=string>"a448017aaf21d8525fc10ae87aa6729d"</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Calculate the MD4 of an array of little-endian words, and a bit length
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> core_md4<SPAN class=braces>(</SPAN>x, len<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=comment>/* append padding */</SPAN>
 x[len <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>5</SPAN>] <SPAN class=symbol>|</SPAN><SPAN class=symbol>=</SPAN> <SPAN class=numeric>0x80</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=braces>(</SPAN>len % <SPAN class=numeric>32</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 x[<SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>len + <SPAN class=numeric>64</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>9</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN> + <SPAN class=numeric>14</SPAN>] <SPAN class=symbol>=</SPAN> len<SPAN class=symbol>;</SPAN>
 
 <SPAN class=reserved_word>var</SPAN> a <SPAN class=symbol>=</SPAN> <SPAN class=numeric>1732584193</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> b <SPAN class=symbol>=</SPAN> -<SPAN class=numeric>271733879</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> c <SPAN class=symbol>=</SPAN> -<SPAN class=numeric>1732584194</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> d <SPAN class=symbol>=</SPAN> <SPAN class=numeric>271733878</SPAN><SPAN class=symbol>;</SPAN>

 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> x.<SPAN class=predefined_identifier>length</SPAN><SPAN class=symbol>;</SPAN> i +<SPAN class=symbol>=</SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN>
 <SPAN class=braces>{</SPAN>
  <SPAN class=reserved_word>var</SPAN> olda <SPAN class=symbol>=</SPAN> a<SPAN class=symbol>;</SPAN>
  <SPAN class=reserved_word>var</SPAN> oldb <SPAN class=symbol>=</SPAN> b<SPAN class=symbol>;</SPAN>
  <SPAN class=reserved_word>var</SPAN> oldc <SPAN class=symbol>=</SPAN> c<SPAN class=symbol>;</SPAN>
  <SPAN class=reserved_word>var</SPAN> oldd <SPAN class=symbol>=</SPAN> d<SPAN class=symbol>;</SPAN>

  a <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>0</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>1</SPAN>], <SPAN class=numeric>7</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>2</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>b, c, d, a, x[i+ <SPAN class=numeric>3</SPAN>], <SPAN class=numeric>19</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>4</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>5</SPAN>], <SPAN class=numeric>7</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>6</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>b, c, d, a, x[i+ <SPAN class=numeric>7</SPAN>], <SPAN class=numeric>19</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>8</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>9</SPAN>], <SPAN class=numeric>7</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>c, d, a, b, x[i+<SPAN class=numeric>10</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>11</SPAN>], <SPAN class=numeric>19</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>a, b, c, d, x[i+<SPAN class=numeric>12</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>d, a, b, c, x[i+<SPAN class=numeric>13</SPAN>], <SPAN class=numeric>7</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>c, d, a, b, x[i+<SPAN class=numeric>14</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_ff<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>15</SPAN>], <SPAN class=numeric>19</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

  a <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>0</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>4</SPAN>], <SPAN class=numeric>5</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>8</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>12</SPAN>], <SPAN class=numeric>13</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>1</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>5</SPAN>], <SPAN class=numeric>5</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>9</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>13</SPAN>], <SPAN class=numeric>13</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>2</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>6</SPAN>], <SPAN class=numeric>5</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>c, d, a, b, x[i+<SPAN class=numeric>10</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>14</SPAN>], <SPAN class=numeric>13</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>3</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>7</SPAN>], <SPAN class=numeric>5</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>c, d, a, b, x[i+<SPAN class=numeric>11</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_gg<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>15</SPAN>], <SPAN class=numeric>13</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

  a <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>0</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>8</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>4</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>12</SPAN>], <SPAN class=numeric>15</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>2</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>d, a, b, c, x[i+<SPAN class=numeric>10</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>6</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>14</SPAN>], <SPAN class=numeric>15</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>1</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>d, a, b, c, x[i+ <SPAN class=numeric>9</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>5</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>13</SPAN>], <SPAN class=numeric>15</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  a <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>a, b, c, d, x[i+ <SPAN class=numeric>3</SPAN>], <SPAN class=numeric>3</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>d, a, b, c, x[i+<SPAN class=numeric>11</SPAN>], <SPAN class=numeric>9</SPAN> <SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>c, d, a, b, x[i+ <SPAN class=numeric>7</SPAN>], <SPAN class=numeric>11</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> md4_hh<SPAN class=braces>(</SPAN>b, c, d, a, x[i+<SPAN class=numeric>15</SPAN>], <SPAN class=numeric>15</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

  a <SPAN class=symbol>=</SPAN> safe_add<SPAN class=braces>(</SPAN>a, olda<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  b <SPAN class=symbol>=</SPAN> safe_add<SPAN class=braces>(</SPAN>b, oldb<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  c <SPAN class=symbol>=</SPAN> safe_add<SPAN class=braces>(</SPAN>c, oldc<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  d <SPAN class=symbol>=</SPAN> safe_add<SPAN class=braces>(</SPAN>d, oldd<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

 <SPAN class=braces>}</SPAN>
 <SPAN class=reserved_word>return</SPAN> <SPAN class=predefined_type>Array</SPAN><SPAN class=braces>(</SPAN>a, b, c, d<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * These functions implement the basic operation for each round of the
 * algorithm.
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> md4_cmn<SPAN class=braces>(</SPAN>q, a, b, x, s, t<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> safe_add<SPAN class=braces>(</SPAN>rol<SPAN class=braces>(</SPAN>safe_add<SPAN class=braces>(</SPAN>safe_add<SPAN class=braces>(</SPAN>a, q<SPAN class=braces>)</SPAN>, safe_add<SPAN class=braces>(</SPAN>x, t<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN>, s<SPAN class=braces>)</SPAN>, b<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> md4_ff<SPAN class=braces>(</SPAN>a, b, c, d, x, s<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> md4_cmn<SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>b <SPAN class=symbol>&</SPAN> c<SPAN class=braces>)</SPAN> <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>~b<SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> d<SPAN class=braces>)</SPAN>, a, <SPAN class=numeric>0</SPAN>, x, s, <SPAN class=numeric>0</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> md4_gg<SPAN class=braces>(</SPAN>a, b, c, d, x, s<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> md4_cmn<SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>b <SPAN class=symbol>&</SPAN> c<SPAN class=braces>)</SPAN> <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN>b <SPAN class=symbol>&</SPAN> d<SPAN class=braces>)</SPAN> <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN>c <SPAN class=symbol>&</SPAN> d<SPAN class=braces>)</SPAN>, a, <SPAN class=numeric>0</SPAN>, x, s, <SPAN class=numeric>1518500249</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>
<SPAN class=reserved_word>function</SPAN> md4_hh<SPAN class=braces>(</SPAN>a, b, c, d, x, s<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> md4_cmn<SPAN class=braces>(</SPAN>b ^ c ^ d, a, <SPAN class=numeric>0</SPAN>, x, s, <SPAN class=numeric>1859775393</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Calculate the HMAC-MD4, of a key and some data
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> core_hmac_md4<SPAN class=braces>(</SPAN>key, data<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> bkey <SPAN class=symbol>=</SPAN> str2binl<SPAN class=braces>(</SPAN>key<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>if</SPAN><SPAN class=braces>(</SPAN>bkey.<SPAN class=predefined_identifier>length</SPAN> <SPAN class=symbol>></SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN> bkey <SPAN class=symbol>=</SPAN> core_md4<SPAN class=braces>(</SPAN>bkey, key.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>

 <SPAN class=reserved_word>var</SPAN> ipad <SPAN class=symbol>=</SPAN> <SPAN class=predefined_type>Array</SPAN><SPAN class=braces>(</SPAN><SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN>, opad <SPAN class=symbol>=</SPAN> <SPAN class=predefined_type>Array</SPAN><SPAN class=braces>(</SPAN><SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> <SPAN class=numeric>16</SPAN><SPAN class=symbol>;</SPAN> i++<SPAN class=braces>)</SPAN> 
 <SPAN class=braces>{</SPAN>
  ipad[i] <SPAN class=symbol>=</SPAN> bkey[i] ^ <SPAN class=numeric>0x36363636</SPAN><SPAN class=symbol>;</SPAN>
  opad[i] <SPAN class=symbol>=</SPAN> bkey[i] ^ <SPAN class=numeric>0x5C5C5C5C</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=braces>}</SPAN>

 <SPAN class=reserved_word>var</SPAN> <SPAN class=predefined_identifier>hash</SPAN> <SPAN class=symbol>=</SPAN> core_md4<SPAN class=braces>(</SPAN>ipad.concat<SPAN class=braces>(</SPAN>str2binl<SPAN class=braces>(</SPAN>data<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN>, <SPAN class=numeric>512</SPAN> + data.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>return</SPAN> core_md4<SPAN class=braces>(</SPAN>opad.concat<SPAN class=braces>(</SPAN><SPAN class=predefined_identifier>hash</SPAN><SPAN class=braces>)</SPAN>, <SPAN class=numeric>512</SPAN> + <SPAN class=numeric>128</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Add integers, wrapping at 2^32. This uses 16-bit operations internally
 * to work around bugs in some JS interpreters.
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> safe_add<SPAN class=braces>(</SPAN>x, y<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> lsw <SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN>x <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFFFF</SPAN><SPAN class=braces>)</SPAN> + <SPAN class=braces>(</SPAN>y <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFFFF</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> msw <SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN>x <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN> + <SPAN class=braces>(</SPAN>y <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN> + <SPAN class=braces>(</SPAN>lsw <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>return</SPAN> <SPAN class=braces>(</SPAN>msw <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN>lsw <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFFFF</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Bitwise rotate a 32-bit number to the left.
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> rol<SPAN class=braces>(</SPAN>num, cnt<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>return</SPAN> <SPAN class=braces>(</SPAN>num <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> cnt<SPAN class=braces>)</SPAN> <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN>num <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=braces>(</SPAN><SPAN class=numeric>32</SPAN> - cnt<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Convert a string to an array of little-endian words
 * If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> str2binl<SPAN class=braces>(</SPAN>str<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> bin <SPAN class=symbol>=</SPAN> <SPAN class=predefined_type>Array</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> mask <SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN><SPAN class=numeric>1</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> chrsz<SPAN class=braces>)</SPAN> - <SPAN class=numeric>1</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> str.<SPAN class=predefined_identifier>length</SPAN> * chrsz<SPAN class=symbol>;</SPAN> i +<SPAN class=symbol>=</SPAN> chrsz<SPAN class=braces>)</SPAN>
  bin[i<SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=numeric>5</SPAN>] <SPAN class=symbol>|</SPAN><SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN>str.charCodeAt<SPAN class=braces>(</SPAN>i <SPAN class=symbol>/</SPAN> chrsz<SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> mask<SPAN class=braces>)</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=braces>(</SPAN>i%<SPAN class=numeric>32</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>return</SPAN> bin<SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Convert an array of little-endian words to a string
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> binl2str<SPAN class=braces>(</SPAN>bin<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> str <SPAN class=symbol>=</SPAN> <SPAN class=string>""</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> mask <SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN><SPAN class=numeric>1</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> chrsz<SPAN class=braces>)</SPAN> - <SPAN class=numeric>1</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> bin.<SPAN class=predefined_identifier>length</SPAN> * <SPAN class=numeric>32</SPAN><SPAN class=symbol>;</SPAN> i +<SPAN class=symbol>=</SPAN> chrsz<SPAN class=braces>)</SPAN>
  str +<SPAN class=symbol>=</SPAN> String.fromCharCode<SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>bin[i<SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=numeric>5</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=braces>(</SPAN>i % <SPAN class=numeric>32</SPAN><SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> mask<SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>return</SPAN> str<SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Convert an array of little-endian words to a hex string.
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> binl2hex<SPAN class=braces>(</SPAN>binarray<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> hex_tab <SPAN class=symbol>=</SPAN> hexcase ? <SPAN class=string>"0123456789ABCDEF"</SPAN> : <SPAN class=string>"0123456789abcdef"</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> str <SPAN class=symbol>=</SPAN> <SPAN class=string>""</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> binarray.<SPAN class=predefined_identifier>length</SPAN> * <SPAN class=numeric>4</SPAN><SPAN class=symbol>;</SPAN> i++<SPAN class=braces>)</SPAN>
 <SPAN class=braces>{</SPAN>
  str +<SPAN class=symbol>=</SPAN> hex_tab.<SPAN class=library_function>charAt</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>binarray[i<SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=numeric>2</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>i%<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN>*<SPAN class=numeric>8</SPAN>+<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xF</SPAN><SPAN class=braces>)</SPAN> +
      hex_tab.<SPAN class=library_function>charAt</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>binarray[i<SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN><SPAN class=numeric>2</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>i%<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN>*<SPAN class=numeric>8</SPAN> <SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xF</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=braces>}</SPAN>
 <SPAN class=reserved_word>return</SPAN> str<SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>

<SPAN class=comment>/*
 * Convert an array of little-endian words to a base-64 string
 */</SPAN>
<SPAN class=reserved_word>function</SPAN> binl2b64<SPAN class=braces>(</SPAN>binarray<SPAN class=braces>)</SPAN>
<SPAN class=braces>{</SPAN>
 <SPAN class=reserved_word>var</SPAN> tab <SPAN class=symbol>=</SPAN> <SPAN class=string>"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>var</SPAN> str <SPAN class=symbol>=</SPAN> <SPAN class=string>""</SPAN><SPAN class=symbol>;</SPAN>
 <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> i <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> i <SPAN class=symbol><</SPAN> binarray.<SPAN class=predefined_identifier>length</SPAN> * <SPAN class=numeric>4</SPAN><SPAN class=symbol>;</SPAN> i +<SPAN class=symbol>=</SPAN> <SPAN class=numeric>3</SPAN><SPAN class=braces>)</SPAN>
 <SPAN class=braces>{</SPAN>
  <SPAN class=reserved_word>var</SPAN> triplet <SPAN class=symbol>=</SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>binarray[i  <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>2</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>8</SPAN> * <SPAN class=braces>(</SPAN> i  %<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFF</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=numeric>16</SPAN><SPAN class=braces>)</SPAN>
        <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>binarray[i+<SPAN class=numeric>1</SPAN> <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>2</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>8</SPAN> * <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>i+<SPAN class=numeric>1</SPAN><SPAN class=braces>)</SPAN>%<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFF</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol><</SPAN><SPAN class=symbol><</SPAN> <SPAN class=numeric>8</SPAN> <SPAN class=braces>)</SPAN>
        <SPAN class=symbol>|</SPAN> <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>binarray[i+<SPAN class=numeric>2</SPAN> <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>2</SPAN>] <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>8</SPAN> * <SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>i+<SPAN class=numeric>2</SPAN><SPAN class=braces>)</SPAN>%<SPAN class=numeric>4</SPAN><SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0xFF</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  <SPAN class=reserved_word>for</SPAN><SPAN class=braces>(</SPAN><SPAN class=reserved_word>var</SPAN> j <SPAN class=symbol>=</SPAN> <SPAN class=numeric>0</SPAN><SPAN class=symbol>;</SPAN> j <SPAN class=symbol><</SPAN> <SPAN class=numeric>4</SPAN><SPAN class=symbol>;</SPAN> j++<SPAN class=braces>)</SPAN>
  <SPAN class=braces>{</SPAN>
   <SPAN class=reserved_word>if</SPAN><SPAN class=braces>(</SPAN>i * <SPAN class=numeric>8</SPAN> + j * <SPAN class=numeric>6</SPAN> <SPAN class=symbol>></SPAN> binarray.<SPAN class=predefined_identifier>length</SPAN> * <SPAN class=numeric>32</SPAN><SPAN class=braces>)</SPAN> str +<SPAN class=symbol>=</SPAN> b64pad<SPAN class=symbol>;</SPAN>
   <SPAN class=reserved_word>else</SPAN> str +<SPAN class=symbol>=</SPAN> tab.<SPAN class=library_function>charAt</SPAN><SPAN class=braces>(</SPAN><SPAN class=braces>(</SPAN>triplet <SPAN class=symbol>></SPAN><SPAN class=symbol>></SPAN> <SPAN class=numeric>6</SPAN>*<SPAN class=braces>(</SPAN><SPAN class=numeric>3</SPAN>-j<SPAN class=braces>)</SPAN><SPAN class=braces>)</SPAN> <SPAN class=symbol>&</SPAN> <SPAN class=numeric>0x3F</SPAN><SPAN class=braces>)</SPAN><SPAN class=symbol>;</SPAN>
  <SPAN class=braces>}</SPAN>
 <SPAN class=braces>}</SPAN>
 <SPAN class=reserved_word>return</SPAN> str<SPAN class=symbol>;</SPAN>
<SPAN class=braces>}</SPAN>
登录后复制
java速学教程(入门到精通)
java速学教程(入门到精通)

java怎么学习？java怎么入门？java在哪学？java怎么学才快？不用担心，这里为大家提供了java速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！

下载
来源：php中文网
收藏 点赞
上一篇：使用脚本控制网页Table的显示隐藏(全代码)_AX_javascript技巧 下一篇：用Javascript轻松制作一套简单的抽奖系统_javascript技巧
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
最新问题
js怎样实现视频截图功能 视频画面截取的3种技术方案 JavaScript实现视频截图主要有三种方案：1.Canvas绘制视频帧，通过播放视频并用Canvas的drawImage方法绘制当前帧，兼容性好但性能有限；2.requestVideoFrameCallbackAPI，在视频帧渲染前执行回调以提升效率，但兼容性较差且需手动控制；3.服务端处理，适用于支持更多格式、复杂处理或批量操作场景，常用FFmpeg工具实现，但需搭建服务器并承担额外负载和延迟。选择应根据具体需求权衡优缺点。
2025-06-14 08:03:01
201
js怎样实现平滑滚动效果 页面平滑滚动的4种实现方式分享 页面平滑滚动可通过多种方式实现。1.CSSscroll-behavior，优点是使用方便，缺点兼容性差且不可定制；2.JS原生方法window.scrollTo或element.scrollTo，兼容性好且灵活控制，但需自行编写动画逻辑；3.第三方库如jQuery.animate()、GSAP等，功能丰富但需学习成本；4.性能优化方面需避免频繁操作DOM、使用硬件加速、减少计算、优化图片加载及使用passiveeventlisteners。每种方案各有优劣，根据需求选择。
2025-06-13 23:54:02
435
js如何实现粒子动画 Canvas粒子动画效果制作指南 Canvas粒子动画效果通过Canvas绘制能力与JavaScript定时器及数学函数结合实现。首先创建Canvas元素并获取2D上下文，接着定义Particle类设置粒子属性，然后创建多个Particle实例存入数组，最后使用requestAnimationFrame循环更新并重绘画布。为优化性能：1.减少粒子数量；2.使用简单形状；3.缩小重绘区域；4.利用离屏Canvas；5.避免循环内新建对象；6.采用WebWorkers处理计算。要实现更复杂效果可引入力场模拟、粒子系统、碰撞检测、纹理
2025-06-13 20:27:01
993
js如何检测音频是否可播放 判断音频状态的3种检测方法！ 音频能否播放可通过JavaScript检测，具体方法有：1.使用canPlayType方法判断浏览器是否支持特定格式，返回"probably"、"maybe"或空字符串；2.监听canplay、error、stalled等事件以确定播放状态；3.结合readyState属性获取加载进度。此外，还需注意跨域问题、浏览器兼容性、网络不稳定、文件损坏及移动端自动播放限制等常见坑点，处理加载失败时应检查URL与CORS设置，并提供备用音频或用户提示。播放过程中的状态变化可通过playing、pause、
2025-06-13 19:33:01
394
js如何实现Markdown编辑器 多功能Markdown编辑器开发 实现Markdown编辑器的核心在于选择解析器和编辑器。①解析器可选用marked.js、showdown.js或markdown-it.js等现成库，能快速将Markdown转换为HTML；②编辑器可通过实现基础功能，或使用CodeMirror、Ace等富文本编辑器提升体验；③实时预览需监听input事件并调用解析器转换内容；④图片上传需前后端协作，前端处理文件读取与上传，后端接收并存储文件，返回URL生成Markdown链接插入编辑器；⑤选型解析器时应考虑性能、兼容性、扩展性等因素；⑥实现多
2025-06-13 19:15:01
385
js如何实现静脉识别 生物识别技术前沿应用探索 JavaScript无法直接实现静脉识别，因其无法访问底层硬件。解决方案分为五步：1.集成红外摄像头等硬件获取静脉图像；2.使用Python等后端语言开发服务进行图像预处理；3.通过LBP、CNN等算法提取并匹配特征向量；4.前端使用JavaScript开发交互界面上传图像并接收结果；5.采用HTTPS和AES加密保障数据安全。挑战包括图像质量受环境影响、成本高、活体检测难及算法鲁棒性问题。提升准确率需优化算法、引入深度学习与多模态识别、应用数据增强技术并定期更新数据库。静脉识别可应用于金融身份
2025-06-13 18:09:01
512
js中如何优雅地处理多重条件分支 处理多重条件分支的优雅方法包括使用查找表、策略模式、状态模式和短路求值。1.查找表通过键值对结构替代冗长的if-else或switch语句，将条件判断转化为数据查询，提高代码可读性和扩展性；2.策略模式将不同算法封装为独立策略对象，实现逻辑解耦与灵活替换，适用于支付方式等场景；3.状态模式将状态变化封装在独立类中，使对象行为随状态改变而自然变化，清晰管理复杂状态转换；4.利用JavaScript短路求值特性（&&、||）及空值合并运算符（??），可简化简单条件判断，提升代码简洁性与可读性；5.避
2025-06-13 17:33:01
422
js如何检测网络延迟 前端网络延迟检测实现方法 检测JavaScript中网络延迟的核心方法是利用时间戳记录请求往返时间。具体步骤为：1.使用fetch或XMLHttpRequest发送请求前记录开始时间；2.收到响应后记录结束时间；3.计算两者差值得到延迟。此外，可采用多次测量取平均值、选择小资源、避免缓存、后台执行等策略提高准确性。延迟结果可用于动态加载资源、优化网络请求、提供更好用户体验等场景。
2025-06-13 15:51:01
950
js如何实现文字选中高亮 文本高亮的5种实现技巧！ js实现文字选中高亮的核心在于监听mouseup事件并获取Selection信息，再用span包裹选中文字添加样式。1.处理重叠高亮时可采用分割策略，仅高亮未覆盖部分；2.实现撤销功能需记录高亮信息并移除对应span；3.跨标签高亮需遍历节点并分割文本节点；4.性能优化可通过减少DOM操作、使用CSS和懒加载等方式；5.兼容不同浏览器可借助polyfill和特性检测。上述策略需综合考虑用户体验与性能平衡。
2025-06-13 13:54:01
510
js中if判断如何实现短路评估 短路评估是JavaScript中逻辑运算符&&和||的特性，当第一个操作数能确定结果时，不再执行后续表达式。1.&&运算符在第一个操作数为false时直接返回false，不执行第二个操作数；2.||运算符在第一个操作数为true时直接返回true，不执行第二个操作数。这种机制可用于避免访问不存在的对象属性、提供默认值及简化条件判断，例如letcity=user&&user.address&&user.address.city防止报错，或letname=userName||"Guest"设置默认值
2025-06-13 13:27:01
227
相关专题
更多>
热门推荐
开源免费商场系统广告
热门教程
更多>
相关推荐
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责申明 意见反馈 讲师合作 广告合作 最新更新
php中文网：公益在线php培训，帮助PHP学习者快速成长！
关注服务号 技术交流群
app下载
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习
PHP中文网抖音号
发现有趣的

Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号

  • PHP学习

  • 技术支持

  • 返回顶部