`

js基础知识集1

正则表达式F#JavaScript 
阅读更多

主要知识点：js数组，数字函数，字符串函数，表单验证，hashMap，堆栈，日期函数，call函数 等。

next：js正则表达式，闭包，apply，callee，事件相关函数，Cookie等

 

文章原地址

 

1.javascript的数组API

Js代码 复制代码
  1. //定义数组   
  2.         var pageIds = new Array();   
  3.         pageIds.push('A');   
  4.   
  5.         数组长度   
  6.         pageIds.length;   
  7.   
  8. //shift：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined    
  9. var a = [1,2,3,4,5];    
  10. var b = a.shift(); //a：[2,3,4,5]   b：1    
  11.   
  12. //unshift：将参数添加到原数组开头，并返回数组的长度    
  13. var a = [1,2,3,4,5];    
  14. var b = a.unshift(-2,-1); //a：[-2,-1,1,2,3,4,5]   b：7    
  15. //注：在IE6.0下测试返回值总为undefined，FF2.0下测试返回值为7，所以这个方法的返回值不可靠，需要用返回值时可用splice代替本方法来使用。    
  16.   
  17. //pop：删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined    
  18. var a = [1,2,3,4,5];    
  19. var b = a.pop(); //a：[1,2,3,4]   b：5    
  20.   
  21. //push：将参数添加到原数组末尾，并返回数组的长度    
  22. var a = [1,2,3,4,5];    
  23. var b = a.push(6,7); //a：[1,2,3,4,5,6,7]   b：7    
  24.   
  25. //concat：返回一个新数组，是将参数添加到原数组中构成的    
  26. var a = [1,2,3,4,5];    
  27. var b = a.concat(6,7); //a：[1,2,3,4,5]   b：[1,2,3,4,5,6,7]    
  28.   
  29. //splice(start,deleteCount,val1,val2,)：从start位置开始删除deleteCount项，并从该位置起插入val1,val2,    
  30. var a = [1,2,3,4,5];    
  31. var b = a.splice(2,2,7,8,9); //a：[1,2,7,8,9,5]   b：[3,4]    
  32. var b = a.splice(0,1); //同shift    
  33. a.splice(0,0,-2,-1); var b = a.length; //同unshift    
  34. var b = a.splice(a.length-1,1); //同pop    
  35. a.splice(a.length,0,6,7); var b = a.length; //同push    
  36.   
  37. //reverse：将数组反序    
  38. var a = [1,2,3,4,5];    
  39. var b = a.reverse(); //a：[5,4,3,2,1]   b：[5,4,3,2,1]    
  40.   
  41. //sort(orderfunction)：按指定的参数对数组进行排序    
  42. var a = [1,2,3,4,5];    
  43. var b = a.sort(); //a：[1,2,3,4,5]   b：[1,2,3,4,5]    
  44.   
  45. //slice(start,end)：返回从原数组中指定开始下标到结束下标之间的项组成的新数组    
  46. var a = [1,2,3,4,5];    
  47. var b = a.slice(2,5); //a：[1,2,3,4,5]   b：[3,4,5]    
  48.   
  49. //join(separator)：将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符    
  50. var a = [1,2,3,4,5];    
  51. var b = a.join("|"); //a：[1,2,3,4,5]   b："1|2|3|4|5"    
//定义数组
        var pageIds = new Array();
        pageIds.push('A');

        数组长度
        pageIds.length;

//shift：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined 
var a = [1,2,3,4,5]; 
var b = a.shift(); //a：[2,3,4,5]   b：1 

//unshift：将参数添加到原数组开头，并返回数组的长度 
var a = [1,2,3,4,5]; 
var b = a.unshift(-2,-1); //a：[-2,-1,1,2,3,4,5]   b：7 
//注：在IE6.0下测试返回值总为undefined，FF2.0下测试返回值为7，所以这个方法的返回值不可靠，需要用返回值时可用splice代替本方法来使用。 

//pop：删除原数组最后一项，并返回删除元素的值；如果数组为空则返回undefined 
var a = [1,2,3,4,5]; 
var b = a.pop(); //a：[1,2,3,4]   b：5 

//push：将参数添加到原数组末尾，并返回数组的长度 
var a = [1,2,3,4,5]; 
var b = a.push(6,7); //a：[1,2,3,4,5,6,7]   b：7 

//concat：返回一个新数组，是将参数添加到原数组中构成的 
var a = [1,2,3,4,5]; 
var b = a.concat(6,7); //a：[1,2,3,4,5]   b：[1,2,3,4,5,6,7] 

//splice(start,deleteCount,val1,val2,)：从start位置开始删除deleteCount项，并从该位置起插入val1,val2, 
var a = [1,2,3,4,5]; 
var b = a.splice(2,2,7,8,9); //a：[1,2,7,8,9,5]   b：[3,4] 
var b = a.splice(0,1); //同shift 
a.splice(0,0,-2,-1); var b = a.length; //同unshift 
var b = a.splice(a.length-1,1); //同pop 
a.splice(a.length,0,6,7); var b = a.length; //同push 

//reverse：将数组反序 
var a = [1,2,3,4,5]; 
var b = a.reverse(); //a：[5,4,3,2,1]   b：[5,4,3,2,1] 

//sort(orderfunction)：按指定的参数对数组进行排序 
var a = [1,2,3,4,5]; 
var b = a.sort(); //a：[1,2,3,4,5]   b：[1,2,3,4,5] 

//slice(start,end)：返回从原数组中指定开始下标到结束下标之间的项组成的新数组 
var a = [1,2,3,4,5]; 
var b = a.slice(2,5); //a：[1,2,3,4,5]   b：[3,4,5] 

//join(separator)：将数组的元素组起一个字符串，以separator为分隔符，省略的话则用默认用逗号为分隔符 
var a = [1,2,3,4,5]; 
var b = a.join("|"); //a：[1,2,3,4,5]   b："1|2|3|4|5"

 

2.dom最常用API

Js代码 复制代码
  1. document方法：    
  2. getElementById(id) Node 返回指定结点的引用    
  3. getElementsByTagName(name) NodeList 返回文档中所有匹配的元素的集合    
  4. createElement(name) Node Node    
  5. createTextNode(text) Node 创建一个纯文本结点    
  6. ownerDocument Document 指向这个节点所属的文档    
  7. documentElement Node 返回html节点    
  8. document.body Node 返回body节点    
  9.   
  10. element方法：    
  11. getAttribute(attributeName) String 返回指定属性的值    
  12. setAttribute(attributeName,value) String 给属性赋值    
  13. removeAttribute(attributeName) String 移除指定属性和它的值    
  14. getElementsByTagName(name) NodeList 返回结点内所有匹配的元素的集合    
  15.   
  16. node方法：    
  17. appendChild(child) Node 给指定结点添加一个新的子结点    
  18. removeChild(child) Node 移除指定结点的子结点    
  19. replaceChild(newChild,oldChild) Node 替换指定结点的子结点    
  20. insertBefore(newChild,refChild) Node 在同一层级的结点前面插入新结点    
  21. hasChildNodes() Boolean 如果结点有子结点则返回true    
  22.   
  23. node属性：    
  24. nodeName String 以字符串的格式存放结点的名称    
  25. nodeType String 以整型数据格式存放结点的类型    
  26. nodeValue String 以可用的格式存放结点的值    
  27. parentNode Node 指向结点的父结点的引用    
  28. childNodes NodeList 指向子结点的引用的集合    
  29. firstChild Node 指向子结点结合中的第一个子结点的引用    
  30. lastChild Node 指向子结点结合中的最后一个子结点的引用    
  31. previousSibling Node 指向前一个兄弟节点；如果这个节点就是兄弟节点，那么该值为null    
  32. nextSibling Node 指向后一个兄弟节点；如果这个节点就是兄弟节点，那么该值为null    
document方法： 
getElementById(id) Node 返回指定结点的引用 
getElementsByTagName(name) NodeList 返回文档中所有匹配的元素的集合 
createElement(name) Node Node 
createTextNode(text) Node 创建一个纯文本结点 
ownerDocument Document 指向这个节点所属的文档 
documentElement Node 返回html节点 
document.body Node 返回body节点 

element方法： 
getAttribute(attributeName) String 返回指定属性的值 
setAttribute(attributeName,value) String 给属性赋值 
removeAttribute(attributeName) String 移除指定属性和它的值 
getElementsByTagName(name) NodeList 返回结点内所有匹配的元素的集合 

node方法： 
appendChild(child) Node 给指定结点添加一个新的子结点 
removeChild(child) Node 移除指定结点的子结点 
replaceChild(newChild,oldChild) Node 替换指定结点的子结点 
insertBefore(newChild,refChild) Node 在同一层级的结点前面插入新结点 
hasChildNodes() Boolean 如果结点有子结点则返回true 

node属性： 
nodeName String 以字符串的格式存放结点的名称 
nodeType String 以整型数据格式存放结点的类型 
nodeValue String 以可用的格式存放结点的值 
parentNode Node 指向结点的父结点的引用 
childNodes NodeList 指向子结点的引用的集合 
firstChild Node 指向子结点结合中的第一个子结点的引用 
lastChild Node 指向子结点结合中的最后一个子结点的引用 
previousSibling Node 指向前一个兄弟节点；如果这个节点就是兄弟节点，那么该值为null 
nextSibling Node 指向后一个兄弟节点；如果这个节点就是兄弟节点，那么该值为null

 

3.网上搜藏的一个map对象:

Js代码 复制代码
  1. function HashMap()      
  2.  {      
  3.      /** Map 大小 **/     
  4.      var size = 0;      
  5.      /** 对象 **/     
  6.      var entry = new Object();      
  7.            
  8.      /** 存 **/     
  9.      this.put = function (key , value)      
  10.      {      
  11.          if(!this.containsKey(key))      
  12.          {      
  13.              size ++ ;      
  14.          }      
  15.          entry[key] = value;      
  16.      }      
  17.            
  18.      /** 取 **/     
  19.      this.get = function (key)      
  20.      {      
  21.          return this.containsKey(key) ? entry[key] : null;      
  22.      }      
  23.            
  24.      /** 删除 **/     
  25.      this.remove = function ( key )      
  26.      {      
  27.          if( this.containsKey(key) && ( delete entry[key] ) )      
  28.          {      
  29.              size --;      
  30.          }      
  31.      }      
  32.            
  33.      /** 是否包含 Key **/     
  34.      this.containsKey = function ( key )      
  35.      {      
  36.          return (key in entry);      
  37.      }      
  38.            
  39.      /** 是否包含 Value **/     
  40.      this.containsValue = function ( value )      
  41.      {      
  42.          for(var prop in entry)      
  43.          {      
  44.              if(entry[prop] == value)      
  45.              {      
  46.                  return true;      
  47.              }      
  48.          }      
  49.          return false;      
  50.      }      
  51.            
  52.      /** 所有 Value **/     
  53.      this.values = function ()      
  54.      {      
  55.          var values = new Array();      
  56.          for(var prop in entry)      
  57.          {      
  58.              values.push(entry[prop]);      
  59.          }      
  60.          return values;      
  61.      }      
  62.            
  63.      /** 所有 Key **/     
  64.      this.keys = function ()      
  65.      {      
  66.          var keys = new Array();      
  67.          for(var prop in entry)      
  68.          {      
  69.              keys.push(prop);      
  70.          }      
  71.          return keys;      
  72.      }      
  73.            
  74.      /** Map Size **/     
  75.      this.size = function ()      
  76.      {      
  77.          return size;      
  78.      }      
  79.            
  80.      /* 清空 */     
  81.      this.clear = function ()      
  82.      {      
  83.          size = 0;      
  84.          entry = new Object();      
  85.      }      
  86.  }      
  87.        
  88.  var map = new HashMap();      
  89.        
  90.  /*    
  91.  map.put("A","1");    
  92.  map.put("B","2");    
  93.  map.put("A","5");    
  94.  map.put("C","3");    
  95.  map.put("A","4");    
  96.  */     
  97.  /*    
  98.  alert(map.containsKey("XX"));    
  99.  alert(map.size());    
  100.  alert(map.get("A"));    
  101.  alert(map.get("XX"));    
  102.  map.remove("A");    
  103.  alert(map.size());    
  104.  alert(map.get("A"));    
  105.  */     
  106.        
  107.  /** 同时也可以把对象作为 Key **/     
  108.  /*    
  109.  var arrayKey = new Array("1","2","3","4");    
  110.  var arrayValue = new Array("A","B","C","D");    
  111.  map.put(arrayKey,arrayValue);    
  112.  var value = map.get(arrayKey);    
  113.  for(var i = 0 ; i < value.length ; i++)    
  114.  {    
  115.      //alert(value[i]);    
  116.  }    
  117.  */     
  118.  /** 把对象做为Key时 ，自动调用了该对象的 toString() 方法 其实最终还是以String对象为Key**/     
  119.        
  120.  /** 如果是自定义对象 那自己得重写 toString() 方法 否则 . 就是下面的结果 **/     
  121.        
  122.  function MyObject(name)      
  123.  {      
  124.      this.name = name;      
  125.  }      
  126.        
  127.  /**    
  128.  function MyObject(name)    
  129.  {    
  130.      this.name = name;    
  131.          
  132.      this.toString = function ()    
  133.      {    
  134.          return this.name;    
  135.      }    
  136.  }    
  137.  **/     
  138.  var object1 = new MyObject("小张");      
  139.  var object2 = new MyObject("小名");      
  140.        
  141.  map.put(object1,"小张");      
  142.  map.put(object2,"小名");      
  143.  alert(map.get(object1));      
  144.  alert(map.get(object2));      
  145.  map.remove("xxxxx");      
  146.  alert(map.size());      
  147.        
  148.  /** 运行结果 小名 小名 size = 1 **/     
  149.        
  150.  /** 如果改成复写toString()方法的对象 , 效果就完全不一样了 **/     
  151.        
  152.  </script>    
function HashMap()   
 {   
     /** Map 大小 **/  
     var size = 0;   
     /** 对象 **/  
     var entry = new Object();   
        
     /** 存 **/  
     this.put = function (key , value)   
     {   
         if(!this.containsKey(key))   
         {   
             size ++ ;   
         }   
         entry[key] = value;   
     }   
        
     /** 取 **/  
     this.get = function (key)   
     {   
         return this.containsKey(key) ? entry[key] : null;   
     }   
        
     /** 删除 **/  
     this.remove = function ( key )   
     {   
         if( this.containsKey(key) && ( delete entry[key] ) )   
         {   
             size --;   
         }   
     }   
        
     /** 是否包含 Key **/  
     this.containsKey = function ( key )   
     {   
         return (key in entry);   
     }   
        
     /** 是否包含 Value **/  
     this.containsValue = function ( value )   
     {   
         for(var prop in entry)   
         {   
             if(entry[prop] == value)   
             {   
                 return true;   
             }   
         }   
         return false;   
     }   
        
     /** 所有 Value **/  
     this.values = function ()   
     {   
         var values = new Array();   
         for(var prop in entry)   
         {   
             values.push(entry[prop]);   
         }   
         return values;   
     }   
        
     /** 所有 Key **/  
     this.keys = function ()   
     {   
         var keys = new Array();   
         for(var prop in entry)   
         {   
             keys.push(prop);   
         }   
         return keys;   
     }   
        
     /** Map Size **/  
     this.size = function ()   
     {   
         return size;   
     }   
        
     /* 清空 */  
     this.clear = function ()   
     {   
         size = 0;   
         entry = new Object();   
     }   
 }   
    
 var map = new HashMap();   
    
 /*  
 map.put("A","1");  
 map.put("B","2");  
 map.put("A","5");  
 map.put("C","3");  
 map.put("A","4");  
 */  
 /*  
 alert(map.containsKey("XX"));  
 alert(map.size());  
 alert(map.get("A"));  
 alert(map.get("XX"));  
 map.remove("A");  
 alert(map.size());  
 alert(map.get("A"));  
 */  
    
 /** 同时也可以把对象作为 Key **/  
 /*  
 var arrayKey = new Array("1","2","3","4");  
 var arrayValue = new Array("A","B","C","D");  
 map.put(arrayKey,arrayValue);  
 var value = map.get(arrayKey);  
 for(var i = 0 ; i < value.length ; i++)  
 {  
     //alert(value[i]);  
 }  
 */  
 /** 把对象做为Key时 ，自动调用了该对象的 toString() 方法 其实最终还是以String对象为Key**/  
    
 /** 如果是自定义对象 那自己得重写 toString() 方法 否则 . 就是下面的结果 **/  
    
 function MyObject(name)   
 {   
     this.name = name;   
 }   
    
 /**  
 function MyObject(name)  
 {  
     this.name = name;  
       
     this.toString = function ()  
     {  
         return this.name;  
     }  
 }  
 **/  
 var object1 = new MyObject("小张");   
 var object2 = new MyObject("小名");   
    
 map.put(object1,"小张");   
 map.put(object2,"小名");   
 alert(map.get(object1));   
 alert(map.get(object2));   
 map.remove("xxxxx");   
 alert(map.size());   
    
 /** 运行结果 小名 小名 size = 1 **/  
    
 /** 如果改成复写toString()方法的对象 , 效果就完全不一样了 **/  
    
 </script>

 

4.常用的数字函数:

Js代码 复制代码
  1. ·数字型(Number)    
  2.   1.声明    
  3.     var i = 1;    
  4.     var i = new Number(1);    
  5.   
  6.   2.字符串与数字间的转换    
  7.     var i = 1;    
  8.     var str = i.toString();     //结果: "1"    
  9.     var str = new String(i);    //结果: "1"    
  10.     i = parseInt(str);          //结果: 1    
  11.     i = parseFloat(str);        //结果: 1.0    
  12.        
  13.     //注意: parseInt,parseFloat会把一个类似于"32G"的字符串,强制转换成32    
  14.   
  15.   3.判断是否为有效的数字    
  16.     var i = 123;  var str = "string";    
  17.     if( typeof i == "number" ){ }   //true    
  18.        
  19.     //某些方法(如:parseInt,parseFloat)会返回一个特殊的值NaN(Not a Number)    
  20.     //请注意第2点中的[注意],此方法不完全适合判断一个字符串是否是数字型!!    
  21.     i = parseInt(str);    
  22.     if( isNaN(i) ){ }    
  23.        
  24.   4.数字型比较    
  25.     //此知识与[字符串比较]相同    
  26.   
  27.   5.小数转整数    
  28.     var f = 1.5;    
  29.     var i = Math.round(f);  //结果:2 (四舍五入)    
  30.     var i = Math.ceil(f);   //结果:2 (返回大于f的最小整数)    
  31.     var i = Math.floor(f);  //结果:1 (返回小于f的最大整数)    
  32.   
  33.   6.格式化显示数字    
  34.     var i = 3.14159;    
  35.        
  36.     //格式化为两位小数的浮点数    
  37.     var str = i.toFixed(2);     //结果: "3.14"    
  38.        
  39.     //格式化为五位数字的浮点数(从左到右五位数字,不够补零)    
  40.     var str = i.toPrecision(5); //结果: "3.1415"    
  41.   
  42.   7.X进制数字的转换    
  43.     //不是很懂 -.-    
  44.     var i = parseInt("0x1f",16);    
  45.     var i = parseInt(i,10);    
  46.     var i = parseInt("11010011",2);    
  47.   
  48.   8.随机数    
  49.     //返回0-1之间的任意小数    
  50.     var rnd = Math.random();    
  51.     //返回0-n之间的任意整数(不包括n)       
  52.     var rnd = Math.floor(Math.random() * n)    
·数字型(Number) 
  1.声明 
    var i = 1; 
    var i = new Number(1); 

  2.字符串与数字间的转换 
    var i = 1; 
    var str = i.toString();     //结果: "1" 
    var str = new String(i);    //结果: "1" 
    i = parseInt(str);          //结果: 1 
    i = parseFloat(str);        //结果: 1.0 
    
    //注意: parseInt,parseFloat会把一个类似于"32G"的字符串,强制转换成32 

  3.判断是否为有效的数字 
    var i = 123;  var str = "string"; 
    if( typeof i == "number" ){ }   //true 
    
    //某些方法(如:parseInt,parseFloat)会返回一个特殊的值NaN(Not a Number) 
    //请注意第2点中的[注意],此方法不完全适合判断一个字符串是否是数字型!! 
    i = parseInt(str); 
    if( isNaN(i) ){ } 
    
  4.数字型比较 
    //此知识与[字符串比较]相同 

  5.小数转整数 
    var f = 1.5; 
    var i = Math.round(f);  //结果:2 (四舍五入) 
    var i = Math.ceil(f);   //结果:2 (返回大于f的最小整数) 
    var i = Math.floor(f);  //结果:1 (返回小于f的最大整数) 

  6.格式化显示数字 
    var i = 3.14159; 
    
    //格式化为两位小数的浮点数 
    var str = i.toFixed(2);     //结果: "3.14" 
    
    //格式化为五位数字的浮点数(从左到右五位数字,不够补零) 
    var str = i.toPrecision(5); //结果: "3.1415" 

  7.X进制数字的转换 
    //不是很懂 -.- 
    var i = parseInt("0x1f",16); 
    var i = parseInt(i,10); 
    var i = parseInt("11010011",2); 

  8.随机数 
    //返回0-1之间的任意小数 
    var rnd = Math.random(); 
    //返回0-n之间的任意整数(不包括n)    
    var rnd = Math.floor(Math.random() * n)

 

5.网上搜藏的js堆栈:

Js代码 复制代码
  1. function stack(){   
  2.       if(this.top==undefined){   
  3.       //初始化堆栈的顶部指针和数据存放域   
  4.             this.top=0;   
  5.             this.unit=new Array();   
  6.       }   
  7.       this.push=function(pushvalue){   
  8.       //定义压入堆栈的方法               
  9.             this.unit[this.top]=pushvalue;   
  10.             this.top+=1;               
  11.       }   
  12.       this.readAllElements=function(){   
  13.       //定义读取所有数据的方法   
  14.             if(this.top==0){   
  15.                   alert("当前栈空，无法读取数据");   
  16.                   return("");   
  17.             }   
  18.             var count=0;   
  19.             var outStr="";   
  20.                            
  21.             for(count=0;count<this.top;count++){   
  22.                   outStr+=this.unit[count]+",";   
  23.             }               
  24.             return(outStr);   
  25.       }   
  26.       this.pop=function(){   
  27.       //定义弹出堆栈的方法   
  28.             if(this.top==0){   
  29.                   alert("当前栈空，无法弹出数据");   
  30.                   return("");   
  31.             }   
  32.             var      popTo=this.unit[this.top-1];   
  33.             this.top--;   
  34.             return(popTo);   
  35.             /* 从堆栈弹出数据，顶部指针减一，不过这里没有做到资源的释放，也  
  36.             就是说数据仍然存在于this.unit的数组中，只不过无法访问罢了。目前  
  37.             我也没想到好的办法解决。*/  
  38.       }   
  39. }  
function stack(){
      if(this.top==undefined){
      //初始化堆栈的顶部指针和数据存放域
            this.top=0;
            this.unit=new Array();
      }
      this.push=function(pushvalue){
      //定义压入堆栈的方法            
            this.unit[this.top]=pushvalue;
            this.top+=1;            
      }
      this.readAllElements=function(){
      //定义读取所有数据的方法
            if(this.top==0){
                  alert("当前栈空，无法读取数据");
                  return("");
            }
            var count=0;
            var outStr="";
                        
            for(count=0;count<this.top;count++){
                  outStr+=this.unit[count]+",";
            }            
            return(outStr);
      }
      this.pop=function(){
      //定义弹出堆栈的方法
            if(this.top==0){
                  alert("当前栈空，无法弹出数据");
                  return("");
            }
            var      popTo=this.unit[this.top-1];
            this.top--;
            return(popTo);
            /* 从堆栈弹出数据，顶部指针减一，不过这里没有做到资源的释放，也
            就是说数据仍然存在于this.unit的数组中，只不过无法访问罢了。目前
            我也没想到好的办法解决。*/
      }
}

 

6.最常用的JavaScript日期函数:

Js代码 复制代码
  1. ·日期型(Date)    
  2.   1.声明    
  3.     var myDate = new Date();    //系统当前时间     
  4.     var myDate = new Date(yyyy, mm, dd, hh, mm, ss);    
  5.     var myDate = new Date(yyyy, mm, dd);    
  6.     var myDate = new Date("monthName dd, yyyy hh:mm:ss");    
  7.     var myDate = new Date("monthName dd, yyyy");    
  8.     var myDate = new Date(epochMilliseconds);    
  9.   
  10.   2.获取时间的某部份    
  11.     var myDate = new Date();    
  12.     myDate.getYear();       //获取当前年份(2位)    
  13.     myDate.getFullYear();   //获取完整的年份(4位,1970-????)    
  14.     myDate.getMonth();      //获取当前月份(0-11,0代表1月)    
  15.     myDate.getDate();       //获取当前日(1-31)    
  16.     myDate.getDay();        //获取当前星期X(0-6,0代表星期天)      
  17.     myDate.getTime();       //获取当前时间(从1970.1.1开始的毫秒数)   时间戳！！   
  18.     myDate.getHours();      //获取当前小时数(0-23)    
  19.     myDate.getMinutes();    //获取当前分钟数(0-59)    
  20.     myDate.getSeconds();    //获取当前秒数(0-59)    
  21.     myDate.getMilliseconds();   //获取当前毫秒数(0-999)    
  22.     myDate.toLocaleDateString();    //获取当前日期    
  23.     myDate.toLocaleTimeString();    //获取当前时间    
  24.     myDate.toLocaleString( );       //获取日期与时间    
  25.   
  26.   3.计算之前或未来的时间    
  27.     var myDate = new Date();    
  28.     myDate.setDate(myDate.getDate() + 10);  //当前时间加10天    
  29.     //类似的方法都基本相同,以set开头,具体参考第2点    
  30.   
  31.   4.计算两个日期的偏移量    
  32.     var i = daysBetween(beginDate,endDate); //返回天数    
  33.     var i = beginDate.getTimezoneOffset(endDate); //返回分钟数    
  34.   
  35.   5.检查有效日期    
  36.     //checkDate() 只允许"mm-dd-yyyy"或"mm/dd/yyyy"两种格式的日期    
  37.     if( checkDate("2006-01-01") ){ }    
  38.        
  39.     //正则表达式(自己写的检查 yyyy-mm-dd, yy-mm-dd, yyyy/mm/dd, yy/mm/dd 
    分享到：
    | js基础知识集
    评论
    发表评论

    您还没有登录,请您登录后再发表评论

相关推荐

    简单的js 基础知识

    JS的基础知识是所有开发者入门时必须掌握的，这包括了词法结构、数据类型和值、对象、函数以及事件处理。 首先，让我们详细探讨JavaScript的词法结构。JavaScript的字符集基于Unicode，这意味着它支持多种国际字符...

    javascript基础视频80集8

    本套“JavaScript基础视频80集8”将深入浅出地介绍这一语言的基础知识，帮助初学者建立坚实的编程基础。 视频内容可能涵盖以下几个方面： 1. **变量与数据类型**：JavaScript支持多种数据类型，包括基本类型（如...

    javascript基础视频80集11

    在“javascript基础视频80集8”中，可能涵盖了以上部分或全部内容，并且可能深入讲解了一些实际案例和最佳实践，帮助学习者将理论知识应用到实际项目中。 压缩包内的“js视频54-56”可能分别对应JavaScript中的特定...

    前端基础知识讲解.pdf

    JS基础知识讲解： JavaScript（JS）是一种动态的脚本语言，用于在网页上实现交互效果和动态内容。 1. JS基础： - 变量用于存储数据值。 - 数据类型包括数字、字符串、布尔值、数组、对象等。 - 控制结构如if...

    计算机基础知识(全集)

    html基础教程.chm HTML页面修改注册表解密.chm JAVASCRIPT教程.chm JAVASCRIPT语言教程.chm javascript源码大全.chm java联想（中文）.chm java语言入门.chm JSP由浅入深(CHM).chm JSP语法.chm 编程技术.chm 完全...

    javascript基础视频80集7

    学习这些内容对于掌握JavaScript基础知识至关重要，无论是初学者还是有一定经验的开发者，都能从中受益。通过观看这套视频教程，你应该能够系统地理解JavaScript的核心概念，并具备编写基本Web交互功能的能力。在...

    javascript基础视频80集1

    这个"javascript基础视频80集1"的资源很可能是为初学者准备的一个全面教程，旨在帮助学习者从零开始掌握JavaScript的基本概念和应用技巧。 首先，JavaScript的基础部分通常包括以下几个关键知识点： 1. **变量和...

    javascript基础视频80集4

    "javascript基础视频80集4"显然是一系列教学资源，旨在帮助初学者系统地学习JavaScript的基础知识。通过观看这80集的视频教程，学习者可以逐步掌握JavaScript的核心概念和实际应用。 JavaScript的基础部分通常涵盖...

    javascript基础视频80集2

    JavaScript，作为全球最广泛使用的编程语言之一，是Web开发的核心技术，尤其...同时，文件名"js视频3-5"表明这部分内容可能是系列的前几节，通常会讲解基础知识和语言入门概念，例如变量声明、基本运算符、流程控制等。

    javascript基础视频80集10

    标题提到的“javascript基础视频80集10”和描述中的“javascript基础视频80集8”，暗示这是一个系列教程，涵盖了JavaScript的基础知识，可能包括变量、数据类型、控制流、函数、对象、数组、DOM操作等核心概念。...

    JavaScript源代码集

    1. **基础语法**：包括变量声明（var, let, const）、数据类型（Number, String, Boolean, Object, Array, Null, Undefined）以及基本操作符（算术、比较、逻辑、赋值等）。 2. **控制流程**：如条件语句（if......

    javascript基础视频80集9

    在"javascript基础视频80集9"中，我们可以推测这是系列教程的一部分，旨在深入浅出地教授JavaScript的基础知识。 在JavaScript的学习中，通常会涵盖以下几个核心知识点： 1. **变量与数据类型**：JavaScript支持...

    javascript前端知识汇总

    1. **基础语法**：JavaScript的基础包括变量、数据类型（如字符串、数字、布尔、null、undefined、对象和数组）、操作符（算术、比较、逻辑、赋值等）、流程控制（条件语句if...else、switch，循环for、while、do......

    javascript基础视频80集5

    "javascript基础视频80集5"很显然是一系列教程的第五部分，旨在帮助初学者系统地学习和理解JavaScript的核心概念。在这个部分中，你可能会接触到以下关键知识点： 1. 变量与数据类型：JavaScript支持七种数据类型，...

    D3.js实现知识图谱

    **D3.js 实现知识图谱** D3.js（Data-Driven Documents）是一个强大的...通过理解D3.js的基础概念和方法，结合实际数据，开发者可以构建出具有交互性和视觉吸引力的知识图谱，以直观的方式展示和探索复杂的数据关系。

    JavaScript 学习笔记集和代码库

    这个“JavaScript学习笔记集和代码库”涵盖了该语言的基础知识、进阶技巧以及实用示例，对于想要深入理解和掌握JavaScript的初学者或有经验的开发者来说，都是一个宝贵的资源。 首先，让我们来讨论JavaScript的基础...

    javascript实例代码集

    1. **基础语法**: JavaScript的基础包括变量声明、数据类型（如字符串、数字、布尔值、对象和数组）、控制结构（如条件语句if/else，循环for/while），以及函数定义和调用。这些是所有编程的基石，理解它们对于编写...

    js和html部分代码集.doc

    二、JavaScript基础知识点 1. JavaScript基础语法：JavaScript基础语法包括变量、数据类型、运算符、控制结构、函数等。 2. JavaScript事件处理：JavaScript事件处理包括onBlur、onFocus、onchange、onselect等，...

    JS基础练习1-7

    【标题】"JS基础练习1-7"涵盖了JavaScript语言的核心基础知识，从基本语法到常见操作，是学习者巩固和提升JavaScript技能的重要环节。这个练习集可能包括了变量声明、数据类型、运算符、控制流（条件语句和循环）、...

Magicbox
Global site tag (gtag.js) - Google Analytics