ascii码对照表

ASCII控制字符

二进制 十进制 十六进制 缩写 可以显示的表示法 名称/意义
0000 0000 0 00 NUL 空字符(Null)
0000 0001 1 01 SOH 标题开始
0000 0010 2 02 STX 本文开始
0000 0011 3 03 ETX 本文结束
0000 0100 4 04 EOT 传输结束
0000 0101 5 05 ENQ 请求
0000 0110 6 06 ACK 确认回应
0000 0111 7 07 BEL 响铃
0000 1000 8 08 BS 退格
0000 1001 9 09 HT 水平定位符号
0000 1010 10 0A LF 换行键
0000 1011 11 0B VT 垂直定位符号
0000 1100 12 0C FF 换页键
0000 1101 13 0D CR 归位键
0000 1110 14 0E SO 取消变换(Shift out)
0000 1111 15 0F SI 启用变换(Shift in)
0001 0000 16 10 DLE 跳出数据通讯
0001 0001 17 11 DC1 设备控制一(XON 启用软件速度控制)
0001 0010 18 12 DC2 设备控制二
0001 0011 19 13 DC3 设备控制三(XOFF 停用软件速度控制)
0001 0100 20 14 DC4 设备控制四
0001 0101 21 15 NAK 确认失败回应
0001 0110 22 16 SYN 同步用暂停
0001 0111 23 17 ETB 区块传输结束
0001 1000 24 18 CAN 取消
0001 1001 25 19 EM 连接介质中断
0001 1010 26 1A SUB 替换
0001 1011 27 1B ESC 跳出
0001 1100 28 1C FS 文件分割符
0001 1101 29 1D GS 组群分隔符
0001 1110 30 1E RS 记录分隔符
0001 1111 31 1F US 单元分隔符
0111 1111 127 7F DEL 删除

ASCII可显示字符

二进制 十进制 十六进制 图形
0010 0000 32 20 (空格)(␠)
0010 0001 33 21 !
0010 0010 34 22
0010 0011 35 23 #
0010 0100 36 24 $
0010 0101 37 25  %
0010 0110 38 26 &
0010 0111 39 27
0010 1000 40 28 (
0010 1001 41 29 )
0010 1010 42 2A *
0010 1011 43 2B +
0010 1100 44 2C ,
0010 1101 45 2D
0010 1110 46 2E .
0010 1111 47 2F /
0011 0000 48 30 0
0011 0001 49 31 1
0011 0010 50 32 2
0011 0011 51 33 3
0011 0100 52 34 4
0011 0101 53 35 5
0011 0110 54 36 6
0011 0111 55 37 7
0011 1000 56 38 8
0011 1001 57 39 9
0011 1010 58 3A :
0011 1011 59 3B ;
0011 1100 60 3C <
0011 1101 61 3D =
0011 1110 62 3E >
0011 1111 63 3F ?
二进制 十进制 十六进制 图形
0100 0000 64 40 @
0100 0001 65 41 A
0100 0010 66 42 B
0100 0011 67 43 C
0100 0100 68 44 D
0100 0101 69 45 E
0100 0110 70 46 F
0100 0111 71 47 G
0100 1000 72 48 H
0100 1001 73 49 I
0100 1010 74 4A J
0100 1011 75 4B K
0100 1100 76 4C L
0100 1101 77 4D M
0100 1110 78 4E N
0100 1111 79 4F O
0101 0000 80 50 P
0101 0001 81 51 Q
0101 0010 82 52 R
0101 0011 83 53 S
0101 0100 84 54 T
0101 0101 85 55 U
0101 0110 86 56 V
0101 0111 87 57 W
0101 1000 88 58 X
0101 1001 89 59 Y
0101 1010 90 5A Z
0101 1011 91 5B [
0101 1100 92 5C \
0101 1101 93 5D ]
0101 1110 94 5E ^
0101 1111 95 5F _
二进制 十进制 十六进制 图形
0110 0000 96 60 `
0110 0001 97 61 a
0110 0010 98 62 b
0110 0011 99 63 c
0110 0100 100 64 d
0110 0101 101 65 e
0110 0110 102 66 f
0110 0111 103 67 g
0110 1000 104 68 h
0110 1001 105 69 i
0110 1010 106 6A j
0110 1011 107 6B k
0110 1100 108 6C l
0110 1101 109 6D m
0110 1110 110 6E n
0110 1111 111 6F o
0111 0000 112 70 p
0111 0001 113 71 q
0111 0010 114 72 r
0111 0011 115 73 s
0111 0100 116 74 t
0111 0101 117 75 u
0111 0110 118 76 v
0111 0111 119 77 w
0111 1000 120 78 x
0111 1001 121 79 y
0111 1010 122 7A z
0111 1011 123 7B {
0111 1100 124 7C |
0111 1101 125 7D }
0111 1110 126 7E ~

PHP实现页面静态化

1-1 明确动态页面和静态页面

静态网页是由浏览器直接从服务器下载到浏览者所在机器上浏览的。
动态网页需要服务器执行(运算)成静态网页的内容,然后由浏览器下载到浏览者所在机器上浏览。
静态网页是任何网站的根基,因为浏览者浏览的内容永远是从服务器传回的静态网页的内容。
动态与静态网页并不矛盾,网站设计中往往是先使用DreamWeaver等工具设计静态网页,之后将PHP等程序嵌入静态网页中完成网站设计。
动态网页中一般会包含静态网页的内容,比如:PHP代码中通常包含HTML或CSS。
静态网页中不能包含动态网页的内容。比如:如果HTML中包含PHP的内容,那就是动态网页了。
动态网页通常与数据库相连,来完成页面的显示。比如:一个文章显示系统,可以只通过一个动态网页Display.php显示数据库中的多篇文章。而静态网页无法实现此功能。
采用动态网页可以实现很多动态功能,比如Blog登录,BBS讨论,购物车等。
由于动态网页需要服务器执行(运算),因此将消耗服务器资源,访问速度会慢于静态网页。
当网站有大数据量时,应该使用动态网页管理,减少网站维护工作量。
当网站服务器压力过大或者访问量太大时,应该使用静态页面显示。
当网站有大的数据量而且访问量很大时,应该使用动态页面管理维护网站内容,同时生成静态页面用于显示。
动态网页的网址显示方式通常带有”?”,比如http://www.mangolau.com/mangolau.php?id=999&name=monkey ,这种网址属于搜索引擎不友好的URL,应该使用urlrewrite改为静态网页的URL显示方式,比如类似于 http://www.mangolau.com/mangolau_999_monkey.html 的URL。
动态网页是需要服务器端执行的程序,由于人的原因可能使动态网页程序产生漏洞,这些漏洞可能会被黑客利用。比如我们常说的”挂马”。

1-2 关于优化页面相应时间

 

1-3 关于动态URL地址设置静态形式

1-4 静态化详细介绍

2-1 buffer认知

2-2 PHP实现页面纯静态化原理

2-3 纯静态化案例简介

2-4 纯静态化案例之步骤解析

2-5 纯静态化案例实现

2-6 触发系统生成纯静态化页面的三种方式

2-7 方式一:页面添加缓存时间

2-8 方式二:手动触发方式

2-9 方式三:crontab定时扫描程序

2-10 局部动态化案例实现(一)

2-11 局部动态化案例实现(二)

2-12 局部动态化案例实现(三)

3-1 PHP处理伪静态

3-2 WEB服务器rewrite配置

3-3 Apache下rewrite配置

3-4 Nginx下rewrite配置

回车提交表单

// 键盘事件
1、keydown()
keydown事件会在键盘按下时触发.

2、keyup()
keyup事件会在按键释放时触发,也就是你按下键盘起来后的事件

3、keypress()
keypress事件会在敲击按键时触发,我们可以理解为按下并抬起同一个按键

// 回车键事件
// 绑定键盘按下事件 
   $(document).keypress(function(e) { 
    // 回车键事件 
       if(e.which == 13) { 
   jQuery(“.confirmButton”).click(); 
       } 
   });
// 上下键事件
$(document).keydown(function(event){ 
  //判断当event.keyCode 为37时(即左方面键),执行函数to_left(); 
  //判断当event.keyCode 为39时(即右方面键),执行函数to_right(); 

  if(event.keyCode == 37){ 
     to_left();  
  }else if (event.keyCode == 39){  
     to_right();  
  }  
});

说明:由于浏览器键盘按下事件的不同,可能导致部分事件不能正常操作,所以推荐keydown事件进行操作!

Jquery 监视按键,按下回车键触发某方法

<script type=”text/javascript”>
$(function () {
    $(‘input:text:first’).focus(); //把焦点放在第一个文本框
    var $inp = $(‘input’); //所有的input元素
    $inp.keypress(function (e) { //这里给function一个事件参数命名为e,叫event也行,随意的,e就是IE窗口发生的事件。
        var key = e.which; //e.which是按键的值
        if (key == 13) {
            alert(“aaa”);
        }
    });
});

linux下开启apache的url重写

Apache 2.x 中URL重写,是通过mod_rewrite.so 来实现的,所以您要查看您的Apache 是否已经被编译进去这个模块了,并且在Apache的配置文件httpd.conf 中已经调用了这个模块。

Linux开启url重写的方法:

1、打开 apache 里httpd.conf(通常是在/etc/httpd/conf目录里)

2、找到 #LoadModule rewrite_module modules/mod_rewrite.so 去掉前面的#

3、找到 AllowOverride None 改成 AllowOverride All , 有两个全部改掉

注:AllowOverride 的参数设置为ALL,表示整台服务器上都支持URL规则重写。Apache 服务器要读每个网站下目录下的 .htaccess 文件。如果没有这个文件,或者这个文档没有定义任何关于URL重写的规则就不会有任何效果。

重启apache (用命令:service httpd restart)。

Apache开启URL重写功能方法详细篇

1、关于rewrite模块的调用:
Apache 2.x 中URL重写,是通过mod_rewrite.so 来实现的,所以您要查看您的Apache 是否已经被编译进去这个模块了,并且在Apache的配置文件httpd.conf 中已经调用了这个模块。在大多数主流发行版中,Apache 2.x 是把rewrite模块已经编入进去了。比如我用的是Slackware。Apache 2.x的配置文件,放在 /etc/httpd 目录下。

在 httpd.conf 中,我们会发现类似如下的一行,是有关rewrite模块的,模块名是 mod_rewrite.so 。

LoadModule rewrite_module lib/httpd/modules/mod_rewrite.so

LoadModule rewrite_module lib/apache2/modules/mod_rewrite.so 如果前面有#号,您要去掉。对于大多数发行版来说,Apache 2的模块一般是位于如下的两个位置

/usr/lib/apache2/modules


/usr/lib/httpd/modules 如果在httpd中打开调用rewrite_module的设置,查看一下是不是能调用了,要通过 httpd -M的参数来查看;

#/usr/sbin/httpd -M

如果发现有如下一行,说明模块已经能被调用了

rewrite_module (shared)

2、设置DocumentRoot的Directory:

在Apache 2.x 中,我们会看到 DocumentRoot设置的一行。这行就是存放网页程序的地方。比如LinuxSir.Org 存放在 /opt/www 目录中。那么我们就要设置 DocumentRoot为如下的。

DocumentRoot “/opt/www” 然后我们再还要对 DocumentRoot做针对性的行为设置。在一般的情况下,httpd.conf 会给一个默认的。如果你要改 DocumentRoot的路径,同时也要改针对DocumentRoot的Directory的设置,也就是

比如我们把DocumentRoot的路径改为了 “/opt/www”,那我们也要把Directory做针对性的行为设置也要改成这个路径。

Options FollowSymLinks
#AllowOverride None 注:把这行前面加#号,然后加下面的一行 ,也就是 AllowOverride ALL
AllowOverride ALL
Order allow,deny
Allow from all
我们把AllowOverride 的参数设置为ALL,表示整台服务器上的,都支持URL规则重写。Apache 服务器要读每个网站根目录下的 .htaccess 文件。如果没有这个文件,或者这个文档没有定义任何关于URL重写的规则,则不会有任何效果。在一般的情况下,成熟的Web 服务器应用套件,都支持URL重写的,比如drupal和joomla 。当我们用这些程序时,会发现在安装包中有 .htaccess中有这个文件。我们把Apache配置好后,只是需要在这些程序的后台打开此功能就行了。

3、重启httpd服务器:

在一般情况下,在各个发行版中,都有httpd服务器启动脚本,比如
# /etc/rc.d/rc.httpd restart 注:Slackware Linux

# /etc/init.d/apache2 restart 注:ubuntu、Debian 等;
# /etc/init.d/httpd start 注:Fedora 、Redhat、CentOS

转自:http://blog.sina.com.cn/s/blog_70ac6bec01018mqa.html

PHP中将字符串转化为整数(int) intval() printf() 性能测试

背景、概述
  早在Sql注入横行的前几年,字符串转化为整数就已经被列为每个web程序必备的操作了。web程序将get或post来的id、整数等值强制经过转化函数转化为整数,过滤掉危险字符,尽可能降低系统本身被Sql注入的可能性。
现如今,虽然Sql注入已经逐渐淡出历史舞台,但是,为了保证web程序的正常运行,减少出错概率,更好的保证用的满意度,我们同样需要将用户的不正确输入转化为我们所需要的。
转化方式
在PHP中,我们可以使用3种方式将字符串转化为整数。
1.强制类型转换方式
  强制类型转换方式,就是“在要转换的变量之前加上用括号括起来的目标类型”(摘自PHP手册“类型戏法”节)的方式。

<?php
$foo = “1”; // $foo 是字符串类型
$bar = (int)$foo; // $bar 是整型
?>

对于整型来说,强制转换类型名称为int或者integer。

2.内置函数方式
  内置函数方式,就是使用PHP的内置函数intval进行变量的转换操作。

<?php
$foo = “1”; // $foo 是字符串类型
$bar = intval($foo); // $bar 是整型
?>

intval函数的格式为:
  int intval(mixed $var [, int $base]); (摘自PHP手册)
虽然PHP手册中明确指出,intval()不能用于array和object的转换。但是经过我测试,转换array的时候不会出任何问题,转换值为1,而不是想象中的0。恐怕是因为在PHP内部,array类型的变量也被认为是非零值得缘故吧。转换object的时候,PHP会给出如下的 notice:
Object of class xxxx could not be converted to int in xxxxx.php on line xx
转换值同样为1。
3.格式化字符串方式
格式化字符串方式,是利用sprintf的%d格式化指定的变量,以达到类型转换的目的。

<?php
$foo = “1”; // $foo 是字符串类型
$bar = sprintf(“%d”, $foo); // $bar 是字符串类型
?>

严格意义上讲sprintf的转换结果还是string型,因此它不应该算是字符串转化为整数的方式。但是经过他处理之后的字符串值确实已经成为了“被强制转化为字符串类型的整数”。
实际测试
上面介绍了PHP中,将字符串转化为整数的3种方式。对于一般的程序员来说,看到这里就算结束了,下面的部分是针对变态程序员的。
1.基本功能测试
  设定以下数组:

<?php
$a[] = “1”;
$a[] = “a1”;
$a[] = “1a”;
$a[] = “1a2”;
$a[] = “0”;
$a[] = array(‘4’,2);
$a[] = “2.3”;
$a[] = “-1”;
$a[] = new Directory();
?>

使用三种方式依次转化上面给出的数组中的元素,查看转换情况。程序源代码如下:

<?php
$a[] = “1”;
$a[] = “a1”;
$a[] = “1a”;
$a[] = “1a2”;
$a[] = “0”;
$a[] = array(‘4’,2);
$a[] = “2.3”;
$a[] = “-1”;
$a[] = new Directory();
// int
print “(int)<br />”;
foreach($a as $v)
{
var_dump((int)$v);
print “<br />”;
}
// intval
print “intval();<br />”;
foreach($a as $v)
{
var_dump(intval($v));
print “<br />”;
}
// sprintf
print “sprintf();<br />”;
foreach($a as $v)
{
var_dump(sprintf(“%d”, $v));
print “<br />”;
}
?>

 

程序的最终运行结果如下(已经去掉转换object时出现的notice):

(int)
int(1)
int(0)
int(1)
int(1)
int(0)
int(1)
int(2)
int(-1)
int(1)
intval();
int(1)
int(0)
int(1)
int(1)
int(0)
int(1)
int(2)
int(-1)
int(1)
sprintf();
string(1) “1”
string(1) “0”
string(1) “1”
string(1) “1”
string(1) “0”
string(1) “1”
string(1) “2”
string(2) “-1”
string(1) “1”
由此可以看出,三种转换的结果是完全一样的。那么从功能上讲,3种方式都可以胜任转换工作,那么接下来的工作就是看哪一种效率更高了。
2.性能测试
被测试字符串是我们在注入工作中可能会使用到的一种:

<?php
$foo = “1′;Select * …”;
?>
获取时间点的函数如下(用于获取测试起始点和结束点,以计算消耗时间):

<?php
**
* Simple function to replicate PHP 5 behaviour
*/
function microtime_float()
{
list($usec, $sec) = explode(” “, microtime());
return ((float)$usec + (float)$sec);
}
?>

(摘自PHP手册microtime()函数节)
测试过程是使用每种方式转换变量$foo 1000000次(100万次),并将各自的消耗时间输出,总共进行三组测试,尽可能降低误差。测试程序如下:
<?php
function microtime_float()
{
list($usec, $sec) = explode(” “, microtime());
return ((float)$usec + (float)$sec);
}
$foo = “1′;Select * …”;

// (int)
$fStart = microtime_float();
for($i=0;$i<1000000;$i++)
{
$bar = (int)$foo;
}
$fEnd = microtime_float();
print “(int):” . ($fEnd – $fStart) . “s<br />”;
// intval()
$fStart = microtime_float();
for($i=0;$i<1000000;$i++)
{
$bar = intval($foo);
}
$fEnd = microtime_float();
print “intval():” . ($fEnd – $fStart) . “s<br />”;
// sprintf()
$fStart = microtime_float();
for($i=0;$i<1000000;$i++)
{
$bar = sprintf(“%d”, $foo);
}
$fEnd = microtime_float();
print “sprintf():” . ($fEnd – $fStart) . “s<br />”;
?>

最终的测试结果:
(int):0.67205619812012s
intval():1.1603000164032s
sprintf():2.1068270206451s
(int):0.66051411628723s
intval():1.1493890285492s
sprintf():2.1008238792419s
(int):0.66878795623779s
intval():1.1613430976868s
sprintf():2.0976209640503s

虽然这个测试有点变态(谁会连续转换100w次的整数?),但是由此可以看出,使用强制类型转换将字符串转化为整数速度是最快的。
总结
使用强制类型转换方式将字符串转化为整数是最直接的转化方式之一(可以直接获得整型的变量值)。从代码可读性角度上讲,sprintf方式代码比较长,而且其结果有可能还需要再次进行强制类型转换,而intval函数是典型的面向过程式转换,强制类型转换则比较直接的将“我要转化”这个思想传递给阅读者。从效率上讲,强制类型转换方式也是最快速的转化方式。因此,对于经常进行转化工作的程序员,我推荐使用这种方式。

算法

一、冒泡排序:

1、算法思想:

对要排序的数据,从上到下依次比较两个相邻的数并加以调整,将最大的数向下移动,较小的数向上冒起。即:每一趟依次比较相邻的两个数据元素,将较小的数放在左边,循环进行同样的操作,直到全部待排序的数据元素排完。

2、实例分析:

例如:我们要将身高不等的十个人站在一排,要求他们按照身高由低到高排队,设将10个人编号为0—9 ,相邻的两个人依次比较,如果左边的比右边的人高,则交换两个人的位置,否则不交换,直到最后两个人,即此时完成了一趟排序。一趟排序后,最高的人已经在最右边了。

 

一趟排序后的结果:(将最高者一趟排序后移动到最后位置)

如此都多趟的排序,最终就完成了整个的排序。

3、算法分析:(有小到大排序)

1>、每一趟过程中,就是依次比较两个相邻的数,若a[i]>a[i+1],则交换两数,否则不换;

2>、每一趟就是一重循环,而由于要经过多趟过程,即外面还有一重循环,所以就存在双重循环。

4、算法代码:(Java版)

  1. /**
  2.  * 冒泡排序 算法
  3.  * @author xcbeyond
  4.  *
  5.  */
  6. public class BubbleSort {
  7.     public static void main(String[] args) {
  8.         // TODO Auto-generated method stub
  9.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;
  10.         int i = 0;
  11.         int j = 0;
  12.         for(i=0;i<10;i++)
  13.             System.out.print(a[i]+”  “);
  14.         System.out.println();
  15.         for(i=0;i<a.length;i++)
  16.             for(j=0;j<a.length-i-1;j++)
  17.             {
  18.                 if(a[j]>a[j+1])
  19.                 {
  20.                     int temp;
  21.                     temp=a[j];
  22.                     a[j]=a[j+1];
  23.                     a[j+1]=temp;
  24.                 }
  25.             }
  26.         for(i=0;i<10;i++)
  27.             System.out.print(a[i]+”  “);
  28.     }
  29. }

二、选择排序

1、算法思想:

将待排序序列分为两部分,一部分为有序序列,另一部分为无序序列。第一趟:从a[0]到a[n-1]中找到最小的数a[i],然后将a[i]与a[0]交换,第二趟:从a[1]到a[n-1]中找到最小的数a[j],然后将a[j]与a[1]交换,第三趟:从a[2]到a[n-1]中找到最小的数a[k],然后将a[k]与a[2]交换 ……

2、实例分析:

{13,15,37,89,60,39,12,109,56,72}

第一趟 :12  {15,37,89,60,39,13,109,56,72}

第二趟:12 ,13 {37,89,60,39,15,109,56,72}

第三趟:12 ,13 ,15 {89,60,39,37,109,56,72}

……

3、算法代码:

 

  1. /**
  2.  * 选择排序
  3.  * @author xcbeyond
  4.  *
  5.  */
  6. public class SelectSort {
  7.     public static void main(String[] args) {
  8.         // TODO Auto-generated method stub
  9.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;
  10.         int i;
  11.         int j;
  12.         for(i = 0;i<a.length;i++)
  13.             System.out.print(a[i]+”  “);
  14.         System.out.println();
  15.         for(i = 0;i<a.length;i++){
  16.             int min = a[i];
  17.             for(j = i+1;j<a.length;j++){
  18.                 if(min>a[j]){
  19.                     int temp;
  20.                     temp = min;
  21.                     min = a[j];
  22.                     a[j] = temp;
  23.                 }
  24.             }
  25.             a[i] = min;
  26.         }
  27.         for(i = 0;i<a.length;i++)
  28.             System.out.print(a[i]+”  “);
  29.     }
  30. }

三、插入排序

1、算法思想:

1〉从第一个元素开始,该元素可以认为已经被排序

2〉取出第一个未排序元素存放在临时变量temp中,在已经排序的元素序列中从后往前扫描,逐一比较

3〉如果temp小于已排序元素,将该元素移到下个位置

4〉重复步骤3〉,直到找到已排序的元素小于或者等于

2、实例分析:

{13,15,37,89,60,39,12,109,56,72}

第一趟:   13 {15,37,89,60,39,12,109,56,72}     temp = 15

temp>13

第二趟:   13 ,15 { 37,89,60,39,12,109,56,72}      temp = 37

temp>15         temp>13
第三趟: 13,15 ,37  {89,60,39,12,109,56,72}     temp = 89

temp>37       temp>15       temp>13

第三趟: 13,15 ,37 ,89 {60,39,12,109,56,72}     temp =60

temp< 89:60<->89          13,15 ,37 , 60,89 {39,12,109,56,72}

temp>37        temp>15        temp>13

第四趟: 13,15 ,37 , 60,89  {39,12,109,56,72}        temp = 39

temp<89:  39<->89           13,15 ,37 , 60,39,89 {12,109,56,72}

temp<60  :   39<->60           13,15 ,37 , 39,60,89 {12,109,56,72}

temp>37      temp>15         temp >13

第五趟:    13,15 ,37 , 39,60,89 {12,109,56,72}       temp = 12

temp<89 :12<->89                   13,15 ,37 ,39,60, 12,89 {109,56,72}

temp<60:12<->60                    13,15 ,37 ,39,12,60,89 {109,56,72}

temp<39 :12<->39                   13,15 ,37 ,12,39,60,89 {109,56,72}

temp<37 :12<->37                    13,15 ,12 ,37 ,39,60,89 {109,56,72}

temp<15: 12<->15                   13,12,15 ,37 ,39,60,89 {109,56,72}

temp<13 :12<->13                     12,13,15 ,37 ,39,60,89 {109,56,72}

第六趟:  12,13,15 ,37 ,39,60,89 {109,56,72}           temp = 109

……

 

3、算法代码:

  1. import java.util.Arrays;
  2. /**
  3.  * 插入排序
  4.  * @author xcbeyond
  5.  *
  6.  */
  7. public class InsertSort {
  8.     public static void main(String[] args) {
  9.         // TODO Auto-generated method stub
  10.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;
  11.         a = insertSort(a);
  12.         String s = Arrays.toString(a);
  13.         System.out.println(s);
  14.     }
  15.     public static int[] insertSort(int[] ary){
  16.         for(int i = 1;i < ary.length;i++){
  17.             int temp = ary[i];
  18.             int j;
  19.             for(j = i-1;j>=0 && temp < ary[j];j–){
  20.                 ary[j+1] = ary[j];
  21.             }
  22.             ary[j+1] = temp;
  23.         }
  24.         return ary;
  25.     }
  26. }

 

  1. import java.util.Arrays;
  2. /**
  3.  * 插入排序
  4.  * @author xcbeyond
  5.  *
  6.  */
  7. public class InsertSort {
  8.     public static void main(String[] args) {
  9.         // TODO Auto-generated method stub
  10.         int a[] ={13,15,37,89,60,39,12,109,56,72} ;
  11.         a = insertSort(a);
  12.         String s = Arrays.toString(a);
  13.         System.out.println(s);
  14.     }
  15.     public static int[] insertSort(int[] ary){
  16.         for(int i = 1;i < ary.length;i++){
  17.             int temp = ary[i];
  18.             int j;
  19.             for(j = i-1;j>=0;j–){
  20.                 if(temp < ary[j]){
  21.                     ary[j+1] = ary[j];
  22.                 }
  23.                 else
  24.                     break//找到插入位置
  25.             }
  26.             ary[j+1] = temp;
  27.         }
  28.         return ary;
  29.     }
  30. }

PHP浮点数计算精度问题

$i = 2.3;
echo ($i*100).”<br>”;
$r = intval($i*100, 2);
echo $r;

//输出结构

230
229

原因:浮点数的不精确存储造成的

存储是近似值或者有些近似值=真实值 有些不等于

解决方案,使用 round() 函数

或者 设置
ini_set(“precision”, “12”);
ini_set(“precision”, “4”);

规定浮点数 通用精度为4
这样 所有计算 比如 1.234* 0.511

总是会得到1个4位小数的数值,后面的会四舍五入

如果你的计算 确定了最后的小数点 可以设置PHP支持到最后的一位 剩下的后一位会自动四舍五入

一般来讲 你可以定义到 4位或者 更高的12位 确定下来后 就不会出现 299.9999999 这样的值了

$num = 0.12345600000000000;
//整数部分为0 ,位数为 0 ,小数部分末尾的 0 不计入位数,所以总位数为 6
ini_set(“precision”, “12”);
echo $num; // 0.123456
//未超过精度值,显示的结果为 0.123456
ini_set(“precision”, “3”);
echo $num; // 0.123
//超过精度值,保留3位
ini_set(“precision”, “5”);
echo $num; // 0.12346
//超过精度值,保留5位
这种情况下,精度值等价于小数点后保留几位。
整数部分大于 0 情况
$num = 12.12345600000000000;
//整数部分为12 ,位数为 2 ,小数部分末尾的 0 不计入位数,位数为6,所以总位数为 2 + 6
ini_set(“precision”, “12”);
echo $num; // 12.123456
//未超过精度值,显示的结果为 12.123456

 

计算机存储 浮点数都是这样! 要么确定精度 要么自己用 round 四舍五入
一个是按需 一个是全局

Linux下压缩某个文件夹(文件夹打包)

tar -zcvf  打包后生成的文件名全路径 要打包的目录
例子:tar -zcvf /home/xahot.tar.gz   /xahot

把/xahot文件夹打包后生成一个/home/xahot.tar.gz的文件。

zip 压缩方法:

linux zip命令的基本用法是:
压缩当前的文件夹 zip -r ./xahot.zip ./* -r表示递归
zip [参数] [打包后的文件名] [打包的目录路径]
解压 unzip xahot.zip 不解释

linux zip命令参数列表:

-a 将文件转成ASCII模式
-F 尝试修复损坏的压缩文件
-h 显示帮助界面
-m 将文件压缩之后,删除源文件

-n 特定字符串 不压缩具有特定字尾字符串的文件
-o 将压缩文件内的所有文件的最新变动时间设为压缩时候的时间
-q 安静模式,在压缩的时候不显示指令的执行过程
-r 将指定的目录下的所有子目录以及文件一起处理
-S 包含系统文件和隐含文件(S是大写)
-t 日期 把压缩文件的最后修改日期设为指定的日期,日期格式为mmddyyyy

举例:

将/home/wwwroot/xahot/ 这个目录下所有文件和文件夹打包为当前目录下的xahot.zip

zip –q –r xahot.zip /home/wwwroot/xahot

上面的命令操作是将绝对地址的文件及文件夹进行压缩.以下给出压缩相对路径目录

比如目前在Bliux这个目录下,执行以下操作可以达到以上同样的效果.

zip –q –r xahot.zip xahot

比如现在我的xahot目录下,我操作的zip压缩命令是

zip –q –r xahot.zip *

以上是在安静模式下进行的,而且包含系统文件和隐含文件
继续阅读“Linux下压缩某个文件夹(文件夹打包)”

kohana数据库操作

数据库配置

在配置文件夹里新增一个database.php文件

<?php defined(‘SYSPATH’) OR die(‘No direct script access.’);

return array(
‘default’ => array(
‘type’ => ‘MySQLi’,
‘connection’ => array(
‘hostname’ => ‘localhost’,
‘database’ => ‘kohana’,
‘username’ => ‘root’,
‘password’ => ‘password’,
‘persistent’ => FALSE,
‘ssl’ => NULL,
),
‘table_prefix’ => ‘db_’,
‘charset’ => ‘utf8’,
‘caching’ => FALSE,
),
);

 

有两种数据库实例

1.DB数据库实例

2. database数据库实例

其中DB是对database的再次封装

下面描述两个数据库实例的使用

Database

取得方法:

<?php
$database=Database::instance();//可以取得database实例
#例外在模型中,dababase做为模型构造函数的唯一一个传递参数,并在模型中有$this->_db属性
$database=$this->_db;
使用方法:(假设在模型中)
插入数据:

<?php
$sql="INSERT INTO `kohana`.`user` (`name` ,`age` )VALUES ( 'test', '1'), ( 'test2', '2')";
$dat=$this->_db->query(Database::INSERT,$sql,false);
# return 返回的两个值中,第一个是自动增长的ID,如果有的话,第二是影响的行数
更新数据:
<?php
$sql="UPDATE `ko_users` SET `user_name` = 'test111q1'  ";
$dat=$this->_db->query(Database::UPDATE,$sql,false);
#return 返回影响行数

删除数据:
<?php $sql="DELETE FROM `kohana`.`user` WHERE `user`.`id` = 1"; $dat=$this->_db->query(Database::DELETE,$sql,false); #return 返回影响行数
查询数据:
<?php
$sql="select * from ko_com_var";
$res=$this->_db->query(Database::SELECT,$sql,false);
#得到所有查询数据
$res->as_array();
#得到一条查询结果
$res->offsetGet(0);
#取得特定记录的指定字段值
$res->get("name");
#移动指针并取得指定字段
$res->next()->get("name");
$res->prev()->get("name");
#计算取得结果总数
$res->count();
#还有其他方法不在一一罗列,请查看手册
其他常用帮助函数:
<?php
#过滤字符串用,不知道为什么放到这个单例中,该是公用才对~,或许是每中数据库的过滤的东西有差别吧
$str=$this->_db->escape("ddddd  ddd");
#表前缀,这个常用~
$str=$this->_db->table_prefix();
#还有其他查看帮助,不介绍咯
DB实例使用(以下演示在Kohana环境即可)
有两种方式:
第一种:
以下的execute(); 有一个数据库适配器参数,当有多个数据连接的时候指定操作那个数据库,就是配置文件的那个KEY值
插入数据:
<?php
$sql="INSERT INTO `kohana`.`user` (`name` ,`age` )VALUES ( 'test', '1'), ( 'test2', '2')";
#其实也可以用Database::UPDATE,结果只返回影响行数,不过还是按规范好.呵呵~,上述Database也可以
$dat=DB::query(Database::INSERT,$sql);
$row=$dat->execute();
#返回的两个值中,第一个是自动增长的ID,如果有的话,第二是影响的行数
Kohana::debug($row);
数据更新:
<?php
$sql="UPDATE `user` SET `name` = 'test2' WHERE `user`.`id` =1 ";
$dat=DB::query(Database::UPDATE,$sql);
$row=$dat->execute();
#返回影响行数
echo Kohana::debug($row);
数据删除:
<?php
$sql="DELETE FROM `kohana`.`user` WHERE `user`.`id` = 1";
$dat=DB::query(Database::DELETE,$sql);
$row=$dat->execute();
#返回影响行数
echo Kohana::debug($row);

数据查询:

<?php
$sql="select * from user";
$dat=DB::query(Database::SELECT,$sql);
#指定数据库取数据
$row=$dat->execute($database)->offsetGet(0);
#默认数据库取数据,和上面的Database一样,都是返回Database_Result_Cached对象,实现了迭代器模式
$rus=$dat->execute();
#取得部分结果
$row=$rus->offsetGet(0);
#取得所有结果
$allrow=$rus->as_array();
#取得特定记录的指定字段值
$no1name=$rus->get("name");
#移动数组指针,并取指定字段值
$no2name=$rus->next()->get("name");
#当前指针
echo $rus->key();
#移动数组指针,并取指定字段值
echo $no1name=$rus->prev()->get('name');
#取行数
echo $rus->count();
第二种:(官网文档称之为查询器模式,不好用,呵呵,简单的可以用下)
插入数据:
<?php
$query = DB::insert('user', array('user', 'age'))
		->values(array('test1', '11'));
$query->execute();
#返回和上面一样

 

更新数据:
<?php
$query = DB::update('user')
		->set(array('age' => '100'))
		->where('user', '=', 'test1');
$query->execute();
#返回和上面一样

删除数据:

<?php
$query = DB::delete('user')
		->where('age', 'IN', array('100', '11'));
$query->execute();
#返回和上面一样

查询数据:

<?php
$query = DB::select()->from('user')->where("id","=","1");
$res=$query->execute();
#和上面一样,$res是Database_Result_Cached对象
$res->as_array();
#其他方法不演示了~

 

附注:
数据绑定,抄官方实例一个,该很简单,比较容易看懂
<?php
$query = DB::query(Database::INSERT, 'INSERT INTO users (username, password) VALUES (:user, :pass)')      
->bind(':user', $username)    
->bind(':pass', $password);  
foreach ($new_users as $username => $password){    
	$query->execute();
}