前面的话

　　碰撞运动可能是运动系列里面比较复杂的运动了。碰撞可以分为碰壁和互碰两种形式，而碰撞前后的运动形式也可以分为变速和匀速两种，如果再涉及到阻力，具有速度损耗的话，就更加复杂了。本文先介绍碰壁运动

匀速碰壁

　　碰壁是一种常见的碰撞形式，匀速碰壁是最简单的碰撞运动

　　假设一个密闭空间内一个弹性小球，小球有一个随机方向随机大小的初始速度。当小球碰壁时，速度不损失，而是做反向的匀速运动

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Document</title>
  6. </head>
  7. <body>
  8. <div id="test" style="height: 100px;width: 100px;background:lightblue;position:absolute;top:60px;left:20px;border-radius:50%;"></div>
  9.  
  10. <button id="btn1">开始运动</button>
  11. <button id="btn2">停止运动</button>
  12. <span>游戏说明：当小球开始运动后，点击小球一次得一分</span>
  13. <div id="result"></div>
  14. <script>
  15. var timer,i=0;
  16. //声明得分
  17. var key = 0;
  18. var arr = ['orange','lightgreen','lightcoyal','pink','lightcyan','lightgray','lightseagreen','lightsteelblue'];
  19.  
  20. function changeColor(){
  21.     i++;
  22.     if(i == arr.length){
  23.         i = 0;
  24.     }
  25.     test.style.background = arr[i];
  26. }
  27. document.onmousemove = function(){
  28.     return false;
  29. }
  30. test.onclick = function(){
  31.     //当小球开始运动后，开始记分
  32.     if(test.timer){
  33.         result.innerHTML = '当前得分为:' + ++key + '分'
  34.     }
  35.     changeColor();
  36. }
  37. btn1.onclick = function(){
  38.     result.innerHTML = ''
  39.     //将分数清零
  40.     key = 0;
  41.     collisionMove({
  42.         obj:test
  43.     })
  44.     clearInterval(timer);
  45.     timer = setInterval(function(){
  46.         changeColor();
  47.     },500);
  48. }
  49. btn2.onclick = function(){
  50.     clearInterval(timer);
  51.     clearInterval(test.timer);
  52.     test.timer = 0;
  53.     result.innerHTML = '你得到:' + key + '分，再接再厉！'
  54. }
  55. function getCSS(obj,style){
  56.     if(window.getComputedStyle){
  57.         return getComputedStyle(obj)[style];
  58.     }
  59.     return obj.currentStyle[style];
  60. }
  61. function collisionMove(json){
  62.     var obj = json.obj;
  63.     var fn = json.fn;
  64.     //声明x、y轴的当前值
  65.     var curX = parseFloat(getCSS(obj,'left'));
  66.     var curY = parseFloat(getCSS(obj,'top'));
  67.     //声明x、y轴的步长值
  68.     var stepX = json.stepX;
  69.     var stepY = json.stepY;
  70.     //步长值默认值为[-25,-20,-15,-10,-5,0,5,10,15,20]中的一个随机数
  71.     stepX = Number(stepX) || 5*Math.floor(Math.random() * 10 - 5);
  72.     stepY = Number(stepY) || 5*Math.floor(Math.random() * 10 - 5);
  73.     //声明x、y轴方向
  74.     var dirX = json.dirX;
  75.     var dirY = json.dirY;
  76.     dirX = stepX > 0 ? '+' : '-';
  77.     dirY = stepY > 0 ? '+' : '-';
  78.     //声明offset宽高
  79.     var offsetWidth = obj.offsetWidth;
  80.     var offsetHeight = obj.offsetHeight;
  81.     //声明元素活动区域宽高
  82.     var activeWidth = json.activeWidth;
  83.     var activeHeight = json.activeHeight;
  84.     //元素获取区域宽高默认值为可视区域宽高
  85.     activeWidth = Number(activeWidth) || document.documentElement.clientWidth;
  86.     activeHeight = Number(activeHeight) || document.documentElement.clientHeight;
  87.     //声明left、top样式值
  88.     var left;
  89.     var top;
  90.     //清除定时器
  91.     if(obj.timer){return;}
  92.      //开启定时器
  93.     obj.timer = setInterval(function(){
  94.         //获取x、y轴的当前值
  95.         curX = parseFloat(getCSS(obj,'left'));
  96.         curY = parseFloat(getCSS(obj,'top'));
  97.         //更新left、top值
  98.         left = curX + stepX;
  99.         top = curY + stepY;
  100.         //右侧碰壁前一刻，步长大于剩余距离，且元素向右运动时
  101.         if((left > activeWidth - offsetWidth) && (dirX == '+')){
  102.             left = activeWidth - offsetWidth;
  103.         }
  104.         //左侧碰壁前一刻，步长大于剩余距离，且元素向左运动时
  105.         if((Math.abs(stepX) > curX) && (dirX == '-')){
  106.             left = curX;
  107.         }
  108.         //下侧碰壁前一刻，步长大于剩余距离，且元素向下运动时
  109.         if((top > activeHeight - offsetHeight) && (dirY == '+')){
  110.             top = activeHeight - offsetHeight;
  111.         }
  112.         //上侧碰壁前一刻，步长大于剩余距离，且元素向上运动时
  113.         if((Math.abs(stepY) > curY) && (dirY == '-')){
  114.             top = curY;
  115.         }
  116.         obj.style.left= left + 'px';
  117.         obj.style.top = top + 'px';
  118.         //左侧或右侧碰撞瞬间
  119.         if(left == activeWidth - offsetWidth || left == curX){
  120.             stepX = -stepX;
  121.         }
  122.         //上侧或下侧碰撞瞬间
  123.         if(top == activeHeight - offsetHeight || top == curY){
  124.             stepY = -stepY;
  125.         }
  126.         //更新运动方向
  127.         dirX = stepX > 0 ? '+' : '-';
  128.         dirY = stepY > 0 ? '+' : '-';
  129.     },20);
  130. }
  131. </script>
  132. </body>
  133. </html>

自由落体

　　元素在实际运动中，并不是保持匀速运动的，更多的是变速运动，而且会有速度损耗。典型的场景是自由落体运动，物体落地之后会反方向弹几下，最终停在地上

　　自由落体运动可以看做是重力与阻力合作的结果。在空中运动时，向下运动时，做匀加速运动；向上运动时，做匀减速运动。与地面碰撞的瞬间，产生速度损耗

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Document</title>
  6. </head>
  7. <body>
  8. <div id="test" style="height:50px;width: 50px;background:lightblue;position:absolute;top:60px;border-radius:50%;"></div>
  9. <button id="btn1">开始运动</button>
  10. <button id="btn2">还原</button>
  11. <script>
  12. document.onmousedown = function(){
  13.     return false;
  14. }
  15. btn1.onclick = function(){
  16.     collisionMove({
  17.         obj:test
  18.     })
  19. }
  20. btn2.onclick = function(){
  21.     history.go();
  22. }
  23. function getCSS(obj,style){
  24.     if(window.getComputedStyle){
  25.         return getComputedStyle(obj)[style];
  26.     }
  27.     return obj.currentStyle[style];
  28. }
  29. function collisionMove(json){
  30.     var obj = json.obj;
  31.     var fn = json.fn;
  32.     //声明y轴的当前值
  33.     var curY = parseFloat(getCSS(obj,'top'));
  34.     //声明offset高
  35.     var offsetHeight = obj.offsetHeight;
  36.     //声明元素活动区域高
  37.     var activeHeight = json.activeHeight;
  38.     //元素获取区域宽高默认值为可视区域高
  39.     activeHeight = Number(activeHeight) || document.documentElement.clientHeight;
  40.     //声明y轴的步长值
  41.     var stepY = 0;
  42.     //声明top样式值
  43.     var top;
  44.     //声明减速系数
  45.     var k = 0.8;
  46.     //声明碰撞次数
  47.     var i = 0;
  48.     //清除定时器
  49.     if(obj.timer){return;}
  50.      //开启定时器
  51.     obj.timer = setInterval(function(){
  52.         //获取y轴的当前值
  53.         curY = parseFloat(getCSS(obj,'top'));
  54.         //更新步长值stepY
  55.         stepY+= 5;
  56.         //更新top值
  57.         top = curY + stepY;
  58.         //下侧碰壁前一刻，步长大于剩余距离，且元素向下运动时
  59.         if(top > activeHeight - offsetHeight){
  60.             top = activeHeight - offsetHeight;
  61.         }
  62.         obj.style.top = top + 'px';
  63.         //下侧碰撞瞬间，改变运动方向，并产生速度损耗
  64.         if(top == activeHeight - offsetHeight){
  65.             //若碰撞10次后，则停止运动
  66.             i++;
  67.             if(i== 10){
  68.                 clearInterval(obj.timer)
  69.                 obj.timer = 0;
  70.                 fn && fn.call(obj);
  71.             }
  72.             stepY = -stepY * k;
  73.         }
  74.     },20);
  75. }
  76. </script>
  77. </body>
  78. </html>

投掷碰壁

　　如果一个物体向空中投掷出去，会呈现一个抛物线的效果，最终经过与地面碰撞多次后停止

　　投掷碰撞效果是x轴和y轴的合效果。x轴做匀速运动，当物体碰到地面后，x轴速度发生损耗；y轴做匀加速运动，当物体碰到地面后，y轴速度同样发生损耗

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Document</title>
  6. </head>
  7. <body>
  8. <div id="test" style="height: 50px;width: 50px;background:lightblue;position:absolute;top:200px;left:20px;border-radius:50%;"></div>
  9. <button id="btn1">开始运动</button>
  10. <button id="btn2">还原</button>
  11. <script>
  12. document.onmousedown = function(){
  13.     return false;
  14. }
  15. btn1.onclick = function(){
  16.     collisionMove({
  17.         obj:test
  18.     })
  19. }
  20. btn2.onclick = function(){
  21.     history.go();
  22. }
  23. function getCSS(obj,style){
  24.     if(window.getComputedStyle){
  25.         return getComputedStyle(obj)[style];
  26.     }
  27.     return obj.currentStyle[style];
  28. }
  29. function collisionMove(json){
  30.     var obj = json.obj;
  31.     var fn = json.fn;
  32.     //声明y轴的当前值
  33.     var curY = parseFloat(getCSS(obj,'top'));
  34.     //声明offset高
  35.     var offsetHeight = obj.offsetHeight;
  36.     //声明元素活动区域高
  37.     var activeHeight = json.activeHeight;
  38.     //元素获取区域宽高默认值为可视区域高
  39.     activeHeight = Number(activeHeight) || document.documentElement.clientHeight;
  40.     //声明x、y轴的步长值
  41.     var stepY = -50;
  42.     var stepX = 10;
  43.     //声明top、left样式值
  44.     var top;
  45.     var left;
  46.     //声明减速系数
  47.     var k = 0.8;
  48.     //声明碰撞次数
  49.     var i = 0;
  50.     //清除定时器
  51.     if(obj.timer){return;}
  52.      //开启定时器
  53.     obj.timer = setInterval(function(){
  54.         //获取x、y轴的当前值
  55.         curX = parseFloat(getCSS(obj,'left'));
  56.         curY = parseFloat(getCSS(obj,'top'));
  57.         //更新步长值stepY
  58.         stepY+= 5;
  59.         //更新top、left值
  60.         top = curY + stepY;
  61.         left = curX + stepX;
  62.         //下侧碰壁前一刻，步长大于剩余距离，且元素向下运动时
  63.         if(top > activeHeight - offsetHeight){
  64.             top = activeHeight - offsetHeight;
  65.         }
  66.         obj.style.top = top + 'px';
  67.         obj.style.left = left + 'px';
  68.         //下侧碰撞瞬间，改变运动方向，并产生速度损耗
  69.         if(top == activeHeight - offsetHeight){
  70.             //若碰撞10次后，则停止运动
  71.             i++;
  72.             if(i== 10){
  73.                 clearInterval(obj.timer)
  74.                 obj.timer = 0;
  75.                 fn && fn.call(obj);
  76.             }
  77.             //速度损耗
  78.             stepY = -stepY * k;
  79.             stepX = stepX * k;
  80.         }
  81.     },20);
  82. }
  83. </script>
  84. </body>
  85. </html>

拖拽碰壁

　　实际情况下，一个物体默认具有重力效果。物体的重力效果是时时刻刻都在发生的，相当于定时器的每次运动，都有向下的匀加速运动

　  如果投掷速度不同，则运动速度也不相同。在碰壁的情况下，速度会有损耗，并且发生速度方向变化。最终，物体会落到地上

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Document</title>
  6. </head>
  7. <body>
  8. <div id="test" style="height: 100px;width: 100px;border-radius:50%;background:pink;position:absolute;top:40px;left:0;"></div>
  9. <script>
  10. //声明元素投掷步长值
  11. var stepX=0,stepY=0;
  12. //默认情况下，也存在重力效果
  13. collisionMove({
  14.     obj:test,
  15.     stepX:stepX,
  16.     stepY:stepY
  17. })
  18. function getCSS(obj,style){
  19.     if(window.getComputedStyle){
  20.         return getComputedStyle(obj)[style];
  21.     }
  22.     return obj.currentStyle[style];
  23. }
  24. //碰撞运动函数
  25. function collisionMove(json){
  26.     var obj = json.obj;
  27.     var fn = json.fn;
  28.     //声明x、y轴的当前值
  29.     var curX = parseFloat(getCSS(obj,'left'));
  30.     var curY = parseFloat(getCSS(obj,'top'));
  31.     //声明x、y轴的步长值
  32.     var stepX = json.stepX;
  33.     var stepY = json.stepY;
  34.        //声明元素的重要加速度
  35.        var g = json.g || 3;
  36.     //步长值默认值为10
  37.     if(isNaN(Number(stepX))){
  38.         stepX = 10;
  39.     }else{
  40.         stepX = Number(stepX);
  41.     }
  42.     if(isNaN(Number(stepY))){
  43.         stepY = 10;
  44.     }else{
  45.         stepY = Number(stepY);
  46.     }
  47.     //声明x、y轴方向
  48.     var dirX = json.dirX;
  49.     var dirY = json.dirY;
  50.     dirX = stepX > 0 ? '+' : '-';
  51.     dirY = stepY > 0 ? '+' : '-';
  52.     //声明offset宽高
  53.     var offsetWidth = obj.offsetWidth;
  54.     var offsetHeight = obj.offsetHeight;
  55.     //声明元素活动区域宽高
  56.     var activeWidth = json.activeWidth;
  57.     var activeHeight = json.activeHeight;
  58.     //元素获取区域宽高默认值为可视区域宽高
  59.     activeWidth = Number(activeWidth) || document.documentElement.clientWidth;
  60.     activeHeight = Number(activeHeight) || document.documentElement.clientHeight;
  61.     //声明left、top样式值
  62.     var left;
  63.     var top;
  64.     //声明减速系数
  65.     var k = 0.8;
  66.     //声明碰撞次数
  67.     var i = 0;
  68.     //清除定时器
  69.     if(obj.timer){return;}
  70.      //开启定时器
  71.     obj.timer = setInterval(function(){
  72.         //获取x、y轴的当前值
  73.         curX = parseFloat(getCSS(obj,'left'));
  74.         curY = parseFloat(getCSS(obj,'top'));
  75.         //受到重力影响，更新步长值stepY
  76.         stepY += g;
  77.         //更新left、top值
  78.         left = curX + stepX;
  79.         top = curY + stepY;
  80.         //右侧碰壁前一刻，步长大于剩余距离，且元素向右运动时
  81.         if((left > activeWidth - offsetWidth) && (dirX == '+')){
  82.             left = activeWidth - offsetWidth;
  83.         }
  84.         //左侧碰壁前一刻，步长大于剩余距离，且元素向左运动时
  85.         if((Math.abs(stepX) > curX) && (dirX == '-')){
  86.             left = curX;
  87.         }
  88.         //下侧碰壁前一刻，步长大于剩余距离，且元素向下运动时
  89.         if((top > activeHeight - offsetHeight) && (dirY == '+')){
  90.             top = activeHeight - offsetHeight;
  91.         }
  92.         //上侧碰壁前一刻，步长大于剩余距离，且元素向上运动时
  93.         if((Math.abs(stepY) > curY) && (dirY == '-')){
  94.             top = curY;
  95.         }
  96.         obj.style.left= left + 'px';
  97.         obj.style.top = top + 'px';
  98.         //左侧或右侧碰撞瞬间
  99.         if(left == activeWidth - offsetWidth || left == curX){
  100.             //x轴方向速度损耗，并发生方向变化
  101.             stepX = -stepX * k;
  102.         }
  103.         //上侧或下侧碰撞瞬间
  104.         if(top == activeHeight - offsetHeight || top == curY){
  105.             //y轴方向速度损耗，并发生方向变化
  106.             stepY = -stepY * k;
  107.             //x轴方向速度损耗
  108.             stepX = stepX * k;
  109.         }
  110.         //元素与地面碰撞10次后，则停止运动
  111.         if(top == activeHeight - offsetHeight){
  112.             i++;
  113.             if(i== 10){
  114.                 clearInterval(obj.timer)
  115.                 obj.timer = 0;
  116.                 fn && fn.call(obj);
  117.             }
  118.         }
  119.         //更新运动方向
  120.         dirX = stepX > 0 ? '+' : '-';
  121.         dirY = stepY > 0 ? '+' : '-';
  122.     },20);
  123. }
  124. //初始抛掷
  125. test.onmousedown = function(e){
  126.     e = e || event;
  127.     //声明上一次mousemove事件的坐标位置
  128.     var lastX2 = e.clientX;
  129.     var lastY2 = e.clientY;
  130.     //获取元素距离定位父级的x轴及y轴距离
  131.     var x0 = this.offsetLeft;
  132.     var y0 = this.offsetTop;
  133.     //获取此时鼠标距离视口左上角的x轴及y轴距离
  134.     var x1 = e.clientX;
  135.     var y1 = e.clientY;
  136.     //鼠标按下时，获得此时的页面区域
  137.     var L0 = 0;
  138.     var R0 = document.documentElement.clientWidth;
  139.     var T0 = 0;
  140.     var B0 = document.documentElement.clientHeight;
  141.     //鼠标按下时，获得此时的元素宽高
  142.     var EH = this.offsetHeight;
  143.     var EW = this.offsetWidth;
  144.     document.onmousemove = function(e){
  145.         e = e || event;
  146.         //获取此时鼠标距离视口左上角的x轴及y轴距离
  147.         var x2 = e.clientX;
  148.         var y2 = e.clientY;
  149.         stepX = x2 - lastX2;
  150.         stepY = y2 - lastY2;
  151.         lastX2 = e.clientX;
  152.         lastY2 = e.clientY;
  153.         //计算此时元素应该距离视口左上角的x轴及y轴距离
  154.         var X = x0 + (x2 - x1);
  155.         var Y = y0 + (y2 - y1);
  156.         /******范围限定*******/
  157.         //获取鼠标移动时元素四边的瞬时值
  158.         var L = X;
  159.         var R = X + EW;
  160.         var T = Y;
  161.         var B = Y + EH;
  162.         //在将X和Y赋值给left和top之前，进行范围限定
  163.         //只有在范围内时，才进行相应的移动
  164.         //如果脱离左侧范围，则left置L0
  165.         if(L < L0){X = L0;}
  166.         //如果脱离右侧范围，则left置为R0
  167.         if(R > R0){X = R0 - EW;}
  168.         //如果脱离上侧范围，则top置T0
  169.         if(T < T0){Y = T0;}
  170.         //如果脱离下侧范围，则top置为B0
  171.         if(B > B0){Y = B0 - EH;}
  172.         //将X和Y的值赋给left和top，使元素移动到相应位置
  173.         test.style.left = X + 'px';
  174.         test.style.top = Y + 'px';
  175.     }
  176.     document.onmouseup = function(e){
  177.         e = e || event;
  178.         var maxHeight = document.documentElement.clientHeight - test.offsetHeight;
  179.         var maxWidth = document.documentElement.clientWidth - test.offsetWidth;
  180.         //以设置的投掷速度来进行碰撞运动
  181.         collisionMove({
  182.             obj:test,
  183.             stepX:stepX,
  184.             stepY:stepY
  185.         })
  186.         //当鼠标抬起时，拖拽结束，则将onmousemove赋值为null即可
  187.         document.onmousemove = null;
  188.         //释放全局捕获
  189.         if(test.releaseCapture){
  190.             test.releaseCapture();
  191.         }
  192.     }
  193.     //阻止默认行为
  194.     return false;
  195.     //IE8-浏览器阻止默认行为
  196.     if(test.setCapture){
  197.         test.setCapture();
  198.     }
  199. }
  200. </script>
  201. </body>
  202. </html>

javascript运动系列第八篇——碰壁运动的更多相关文章

  1. javascript运动系列第五篇——缓冲运动和弹性运动

    × 目录 [1]缓冲运动 [2]弹性运动 [3]距离分析[4]步长分析[5]弹性过界[6]弹性菜单[7]弹性拖拽 前面的话 缓冲运动指的是减速运动,减速到0的时候,元素正好停在目标点.而弹性运动同样是 ...

  2. javascript面向对象系列第三篇——实现继承的3种形式

    × 目录 [1]原型继承 [2]伪类继承 [3]组合继承 前面的话 学习如何创建对象是理解面向对象编程的第一步,第二步是理解继承.本文是javascript面向对象系列第三篇——实现继承的3种形式 [ ...

  3. 深入理解javascript函数系列第三篇——属性和方法

    × 目录 [1]属性 [2]方法 前面的话 函数是javascript中的特殊的对象,可以拥有属性和方法,就像普通的对象拥有属性和方法一样.甚至可以用Function()构造函数来创建新的函数对象.本 ...

  4. 深入理解javascript作用域系列第四篇——块作用域

    × 目录 [1]let [2]const [3]try 前面的话 尽管函数作用域是最常见的作用域单元,也是现行大多数javascript最普遍的设计方法,但其他类型的作用域单元也是存在的,并且通过使用 ...

  5. 深入理解javascript作用域系列第三篇——声明提升(hoisting)

    × 目录 [1]变量 [2]函数 [3]优先 前面的话 一般认为,javascript代码在执行时是由上到下一行一行执行的.但实际上这并不完全正确,主要是因为声明提升的存在.本文是深入理解javasc ...

  6. 深入理解javascript作用域系列第三篇

    前面的话 一般认为,javascript代码在执行时是由上到下一行一行执行的.但实际上这并不完全正确,主要是因为声明提升的存在.本文是深入理解javascript作用域系列第三篇——声明提升(hois ...

  7. 深入理解javascript作用域系列第四篇

    前面的话 尽管函数作用域是最常见的作用域单元,也是现行大多数javascript最普遍的设计方法,但其他类型的作用域单元也是存在的,并且通过使用其他类型的作用域单元甚至可以实现维护起来更加优秀.简洁的 ...

  8. 深入理解javascript函数系列第三篇

    前面的话 函数是javascript中特殊的对象,可以拥有属性和方法,就像普通的对象拥有属性和方法一样.甚至可以用Function()构造函数来创建新的函数对象.本文是深入理解javascript函数 ...

  9. 【JavaScript数据结构系列】00-开篇

    [JavaScript数据结构系列]00-开篇 码路工人 CoderMonkey 转载请注明作者与出处 ## 0. 开篇[JavaScript数据结构与算法] 大的计划,写以下两部分: 1[JavaS ...

随机推荐

  1. linux shell basic command

    Learning basic Linux commands Command Description $ ls This command is used to check the contents of ...

  2. js实现简单的图片轮播

    js代码如下 <script type="text/javascript"> var n=1; var map=new Array(); map[0]=new Imag ...

  3. SRM 628 DIV2

    250  想想就发现规律了. 500  暴力,括号匹配. 1000 给一个f数组,如果i存在,那么f[i]也得存在,问这样的集合有多少种. 先拓扑一下,dp[i] = mul(dp[son]+1)最后 ...

  4. 懒加载lazyload

    什么是懒加载 懒加载就是当你做滚动到页面某个位置,然后再显示当前位置的图片,这样做可以减少页面请求. 懒加载:主要目的是作为服务器前端的优化,减少请求数或延迟请求数,一些图片非常多的网站中非常有用,在 ...

  5. 无法加载 DLL“SQLite.Interop.dll”: 找不到指定的模块。 (异常来自 HRESULT:0x8007007E)

    SQLite部署-无法加载 DLL“SQLite.Interop.dll”: 找不到指定的模块 近期刚使用SQLite,主要引用的是System.Data.SQLite.dll这个dll,在部署到测试 ...

  6. 也来说说关于未在本地计算机上注册“VFPOLEDB.1”的程序的解决方法

    大家都知道VFP是一个非常古老的数据库.但是,还有一些单位用到这些数据库. 前段时间,也做了一个关于DBF数据导出的功能的测试.程序以前有同事写好了,但当我进行修改调试的时候,问题就出来了. 调试的时 ...

  7. HUAS_ACM 个人训练#4

    A 题目连接:http://acm.hust.edu.cn/vjudge/contest/view.action?cid=117542#problem/A 题意:给出n个单词(字符串),选出最长的字符 ...

  8. （转）什么是“黑客” by 王珢

    什么是“黑客” by 王垠很多程序员自豪的把自己叫做“黑客”(hacker),把编程叫做 hack.可是殊不知,其实在最高级的程序员眼里,“黑客”其实是一个贬义词.他们更愿意被叫做“程序员”(prog ...

  9. form data和request payload的区别

    HTML <form> 标签的 enctype 属性 在下面的例子中,表单数据会在未编码的情况下进行发送: <form action="form_action.asp&qu ...

  10. Android课程---远程服务器存储

    在使用Volley进行获取数据时,需要事先准备环境:在libs里面导入一个Volley.jar包,在网上都有,可以下载下来导入,或者自己电脑上有DT的,自己合成一个包也行. WebActivity.j ...