在PHP中单引号和双引号并非是互通的,具体区别如下:
” ” 双引号里面的字段会经过编译器解释,然后再当作HTML代码输出。
‘ ‘ 单引号里面的不进行解释,直接输出。
从字面意思上就可以看出,单引号比双引号要快了。
例如:
$abc=’my name is tome’;
echo $abc //结果是:my name is tom
echo ‘$abc’ //结果是:$abc
echo “$abc” //结果是:my name is tom
在SQL语句中
这是会经常遇到的问题,在插入数据库的SQL语句是采用单引号来定义字符串,如果要将一个含有单引号的字符串插入数据库,这个SQL语句就会出错。
如:$sql="insert into userinfo (username,password) Values('O'Kefee','123456')"
此时,处理的方法之一是在SQL语句中加入转义符反斜线,
即:……Values('O\'Kefee',……
当然也可以使用函数 addslashes(),该函数的功能就是加入转义符,
即:$s = addslashes("O'Kefee") ……Values('".$s."',……
还有一种方法是设置php.ini中的magic-quotes选项,打开该选项,则通过表单提交的信息中如果有单引号是,将会自动加上如转义符。因此不用使用其他函数了。
补充: 这就要从双引号和单引号的作用讲起: 双引号里面的字段会经过编译器解释然后再当作HTML代码输出,但是单引号里面的不需要解释,直接输出。
$val ='a';
sql =" select * from table where name like '%$val%'"; //将自动替换里面的$val,但如果要用单引号来组织语句则表示为:
sql =' select * from table where name like \'%'.$val.'%\''; //麻烦很多
但用单引号代替双引号来包含字符串,这样做会更快一些,因为PHP会在双引号包围的字符串中搜寻变量,单引号则不会。
假设查询条件中使用的是常量,例如:
select * from abc_table where user_name=’abc’;
SQL语句可以写成:
SQLstr = “select * from abc_table where user _name= ‘abc’” ;
假设查询条件中使用的是变量,例如:
$user_name = $_REQUEST['user_name']; //字符串变量
或
$user=array (”name”=> $_REQUEST['user_name‘,"age"=>$_REQUEST['age'];//数组变量
SQL语句就可以写成:
SQLstr = “select * from abc_table where user_name = ‘ ” . $user_name . ” ‘ “;
SQLstr = “select * from abc_table where user_name = ‘ ” . $user["name"] . ” ‘ “;
对比一下:
SQLstr=”select * from abc_table where user_name = ‘ abc ‘ ” ;
SQLstr=”select * from abc_table where user_name =’ ” . $user _name . ” ‘ “;
SQLstr=”select * from abc_table where user_name =’ ” . $user["name"] . ” ‘ “;
SQLstr可以分解为以下3个部分:
1:”select * from table where user_name = ‘ ” //固定SQL语句
2:$user //变量
3:” ‘ ”
1,2,3部分字符串之间用”.” 来连接
PHP效率计:从引号开始(单引号、双引号效率区别)
实验一:在普通情况下的效率
我们的实验是5000次执行10000个字节的文件,获得解析过程中的速度。
首先,本实验特别规定一个单位,这是为了更好地表示以及排除计算机本身效率的差异。
时间单位 TT,表示约 7.2×10[sup]-8[/sup]s 。
我们获得四组实验数据,可理解为表示 'a' 比 "a" 快的时间:
0.29 TT,大概0.0000000206s
0.46 TT,大概0.0000000328s
0.38 TT,大概0.0000000275s
0.41 TT,大概0.0000000292s
平均值:0.39 TT ('aaaa....(139个)' 的效率接近于 "aaa...(100个)" )
结论:在数据量相同,并且在普通情况下(不借助转义),使用单引号速度更快。
实验二:单引号转义的效率
我们的实验是5000次分别以「单引号、双引号」执行两份数据相同,但其中一份特别用\'表示单引号。
时间单位 TT,表示约 7.2×10[sup]-8[/sup]s 。
我们获得四组实验数据,可理解为表示 " ' " 比 ' \' ' 快的时间:
0.19 TT,大概0.0000000138s
0.15 TT,大概0.0000000110s
0.23 TT,大概0.0000000162s
0.24 TT,大概0.0000000173s
平均值:0.2 TT (” ''''...(12个) " 的效率接近于 ' \'\'...(10个)" )
结论:如果字符串中需要表示单引号(MySQL查询),应尽可能避免转义,所以应使用双引号。
实验三:花括号的效率
我们的实验是1000次执行含有数量一定的变量标记的文件,获得解析过程中的速度。
时间单位 TT,表示约 1.581×10[sup]-7[/sup]s~1.666×10[sup]-7[/sup]s 。(TT 变化)
得到三组数据,表示 "{$abc}" 比 "$abc" 快。
15.3 TT,大概0.0000024186s
14.5 TT,大概0.0000024093s
15.3 TT,大概0.0000024152s
这数据是十分惊人的,平均结果 15 TT。
这意味着:使用花括号的解析速度,大约是不使用花括号的16倍。
结论:在双引号中表示变量,尽可能使用花括号。
实验四:连续与非连续的效率
我们的实验是1000次执行含有数量一定的变量标记的文件,获得解析过程中的速度。
时间单位 TT,表示约 1.581×10[sup]-7[/sup]s~1.666×10[sup]-7[/sup]s 。(TT 变化)
第一组实验数据,表示 "{$abc}{$abc}{$abc}..." 比 $abc.$abc.$abc 平均每个变量解析快
22.45 TT,大概0.0000035498s
21.03 TT,大概0.0000035037s
22.12 TT,大概0.0000034930s
花括号(连续)比单引号(非连续)快的时间,平均结果 22 TT。
这意味着:使用花括号的解析速度,大约是使用不连续的单引号的23倍。
结论:在单引号中表示多个变量(或数据总量少),尽可能换用双引用,并使用花括号。
第二组实验数据,表示 "...$abc$abc$abc..." 比 ‘...’.$abc.$abc.$abc.'...' 平均每个变量解析快
7.15 TT,大概0.0000011311s
6.57 TT,大概0.0000010943s
6.83 TT,大概0.0000010777s
双引号(连续)比单引号(非连续)快的时间,平均结果 7 TT。(该数据变化)
这意味着:变量多时,使用双引号(不使用花括号)的解析速度,大约是使用不连续的单引号的8倍。
结论:在双引号中表示多个变量(或数据总量少),比使用单引号而需要用「连接运算符」要快。
结论:表示多个变量时(或数据总量少),应可能范围内使用双引号,并使用花括号。
(附:作者推测,这可能和内存空间的分配有关系,连续符可能会使内存不断调整)
最终结论:
首先,表示简单的数据时(不需要转义),尽量用单引号。
'Cal: Are you good at long jump?'
但如果因为使用单引号,而需要进行转义(即包含单引号),考虑使用双引号。
'Cal: Yes. But, you know, it\'s written.' => "Cal: Yes. But, you know, it's written."
如果需要表示变量,应尽量使用花括号。
"Cal: $to" => "Cal: {$to}, you shouldn't go shopping."
尽量使其连续:
'Cal: '.$calsaid => "Cal: $calsaid" => "Cal: {$calsaid}"
例子
代码如下 | 复制代码 |
$fid = intval(isset($_GET['fid'])?$_GET['fid']:0); |
如果有404页面我们还可以这样
PHP实现404未找到方法
代码如下 | 复制代码 |
header('HTTP/1.1 404 Not Found'); header("status: 404 Not Found"); include('404.php'); //404提示页 exit(); |
然后去这里测试HTTP状态:
http://tool.chinaz.com/pagestatus/
PHP中抽象类和接口在应用中会有什么区别呢,对于这个问题我们一起来给各位介绍PHP中抽象类和接口区别及它的例子,具体的细节如下。PHP中抽象类和接口区别:
1、对接口的使用是通过关键字implements。对抽象类的使用是通过关键字extends。当然接口也可以用extends继承。abstract 关键字来定义个一个抽象类或者抽象方法。抽象类不能被实例化。
2、接口中不可以声明成员变量(包括类静态变量),但是可以声明类常量。抽象类中可以声明各种类型成员变量,实现数据的封装。(另JAVA接口中的成员变量都要声明为public static final类型).抽象类中可以有成员属性和成员方法,而接口中只能有未实现的方法和常量。
3、接口没有构造函数,抽象类可以有构造函数。(抽象类中可以有非抽象的方法,而接口中只能够有抽象的方法!)
4、抽象类只允许单继承,而接口可以多继承
5。在写法上
一、接口中的抽象方法前不用也不能加abstract关键字,默认隐式就是抽象方法,也不能加final关键字来防止抽象方法的继承.而抽象类中抽象方法前则必须加上abstract表示
显示声明为抽象方法.
二、接口中的抽象方法默认是public的,也只能是public的,不能用private、protected修饰符修饰.而抽象类则可以。
抽象类还是接口
如果要创建一个模型,这个模型将由一些紧密相关的对象采用,就可以使用抽象类。如果要创建由一些不相关对象采用的功能,就使用接口。
如果必须从多个来源继承行为,就使用接口。
如果知道所有类都会共享一个公共的行为实现,就可以使用抽象类,并在其中实现该行为。
Explain:
abstract class Father {
function meth1() {
echo "meth1...<br>";
}
abstract function meth2();
public $var1="var1";
public static $var2="var2";
const Var3="Var3";
}
class Son extends Father {
function meth2() {
echo "meth2 of Son...<br>";
}
}
$s=new Son();
echo $s->var1."<br>";
echo Father::$var2."<br>";
echo Father::Var3."<br>";
Interface IFather {
//public $iVar1="iVar1"; 此处接口定义中不能包含成员变量
//public static $iVar2="iVar2"; 此处接口定义中不能包含静态变量
const iVar3="iVar3";
function iMeth1();
}
Class ISon implements IFather {
function iMeth1() {
echo "iMeth1...<br>";
}
}
$is=new ISon();
echo IFather::iVar3;
//抽象类的定义:
abstract class ku{ //定义一个抽象类
abstract function kx();
......
}
function aa extends ku{
//实现抽象类的方法
function kx(){
echo
'sdsf';
}
}
//使用方法
$aa=new aa;
$aa->kx();
//1.定义一些方法,子类必须完全实现这个抽象中所有的方法
//2.不能从抽象类创建对象,它的意义在于被扩展
//3.抽象类通常具有抽象方法,方法中没有大括号
//4.抽象方法不必实现具体的功能,由子类来完成
//5.在子类实现抽象类的方法时,其子类的可见性必须大于或等于抽象方法的定义
//6.抽象类的方法可以有参数,也可以为空
//7.如果抽象方法有参数,那么子类的实现也必须有相同的参数个数
//////////////////////////////接口类的定义:
interface Shop{
public function buy($gid);
public function sell($gid);
abstract function view($gid);
}
//如果要使用接口,必须定义接口类中的所以方法少一个都不可以(abstract除外)。
//这样如果在一个大项目中不管别人怎么去做下面的方法,但是他必须实现本接口中的所有方法才可以!
//例:实现上面的接口的一种方法
class BaseShop implements Shop{
public function buy($gid){
echo '你购买了ID为 :' . $gid . '的商品';
}
public function sell($gid){
echo '你购卖ID为 :' . $gid . '的商品';
}
public function view($gid){
echo '你浏览了ID为 :' . $gid . '的商品';
}
}
//接口的多重继承示例:
interface staff_i1{ //接口1
function setID();
function getID();
}
interface staff_i2{ //接口2
function setName();
function getName();
}
class staff implements staff_i1,staff_i2{
private $id;
private $name;
function setID($id){
$this->id = $id;
}
function getID(){
return $this->id;
}
function setName($name){
$this->name = $name;
}
function getName(){
return $this->name;
}
function otherFunc(){ //这是一个接口中不存在的方法
echo 'Test';
}
}
总结
在学习PHP面向对象时,都会在抽象类与接口上迷惑,作用差不多为什么还那么容易混淆,何不留一去一?但是事实上两者的区别还是很大的,如果能够很好地运用PHP的两个方法,面向对象的程序设计将会更加合理、清晰高效。
对接口的使用方式是通过关键字implements来实现的,而对于抽象类的操作是使用类继承的关键字exotends实现的,使用时要特别注意。
接口没有数据成员,但是抽象类有数据成员,抽象类可以实现数据的封装。
接口没有构造函数,抽象类可以有构造函数。
接口中的方法都是public类型,而抽象类中的方法可以使用private、protected或public来修饰。
一个类可以同时实现多个接口,但是只能实现一个抽象类。
相同点:函数体内不能写任何东西,连两个大括号都不能写!!!如:function getName();这样就行了
1. 接口
(1)对接口的使用是通过关键字implements
(2)接口不能定义成员变量(包括类静态变量),能定义常量
(3)子类必须实现接口定义的所有方法
(4)接口只能定义不能实现该方法
(5)接口没有构造函数
(6)接口中的方法和实现它的类默认都是public类型的
2. 抽象类
(1)对抽象类的使用是通过关键字extends
(2)不能被实例化,可以定义子类必须实现的方法
(3)子类必须定义父类中的所有抽象方法,这些方法的访问控制必须和父类中一样(或者更为宽松)
(4)如一个类中有一个抽象方法,则该类必须定义为抽象类
(5)抽象类可以有构造函数
(6)抽象类中的方法可以使用private,protected,public来修饰。
(7)一个类可以同时实现多个接口,但一个类只能继承于一个抽象类。
3. Final类/方法
(1)final类不能被继承
(2)final方法不能被重写
4. Static类/方法
(1)可以不实例化类而直接访问
(2)静态属性不可以由对象通过->操作符来访问,用::方式调用
例子
<?php
# 接口
interface Human{
const TEST_CONST = "test const"; // 定义常量
// public $v; // error,不能定义变量
// static $count; // error,不能定义变量
public function speak();
public function walk();
public function run();
}
# 抽象类
abstract class Father implements Human{
public function __construct(){
echo "father init n";
}
abstract public function walk(); // 抽象方法
public function speak(){
echo "father speak skill n";
}
public function run(){
echo "father run skill n";
}
}
# 非抽象类
class Mother implements Human{
public function __construct(){
echo "mother init n";
}
# 这里必须实现walk方法
public function walk(){
echo "mother walk skill n";
}
public function speak(){
echo "mother speak skill n";
}
public function run(){
echo "mother run skill n";
}
}
class Son extends Father{
public function walk(){
echo "son walk skill. n";
}
public function speak($name = ''){
echo "son: ". $name ." speak skill. n";
}
# 访问控制必须和父类中一样(或者更为宽松)
protected function sport(){
echo "son sport skill. n";
}
final public function notTeach(){
echo 'son has not to teach skill';
}
}
class Daughter extends Mother{
public function run($name = ''){
echo "daughter run skill. n";
}
}
final class GrandChild extends Son{
# 访问控制必须和父类中一样(或者更为宽松)
public function sport(){
echo "GrandChild sport skill. n";
}
# Cannot override final method Son::notTeach()
// public function notTeach(){} // error
}
# Class Orphan may not inherit from final class (GrandChild)
// class Orphan extends GrandChild{} // error
$son = new Son();
$son->speak("Suly");
$daughter = new Daughter();
$daughter->run('Lily');
$grandChild = new GrandChild();
$grandChild->sport();
抽象类和接口的区别
1、对接口的使用是通过关键字implements。对抽象类的使用是通过关键字extends。当然接口也可以通过关键字extends继承。
2、接口中不可以声明成员变量(包括类静态变量),但是可以声明类常量。抽象类中可以声明各种类型成员变量,实现数据的封装。(另JAVA接口中的成员变量都要声明为public static final类型)
3、接口没有构造函数,抽象类可以有构造函数。
4、接口中的方法默认都是public类型的,而抽象类中的方法可以使用private,protected,public来修饰。
5、一个类可以同时实现多个接口,但一个类只能继承于一个抽象类。
抽象类还是接口。
如果要创建一个模型,这个模型将由一些紧密相关的对象采用,就可以使用抽象类。如果要创建将由一些不相关对象采用的功能,就使用接口。
如果必须从多个来源继承行为,就使用接口。
如果知道所有类都会共享一个公共的行为实现,就使用抽象类,并在其中实现该行为。