在写二叉树的最后判断二叉树是否为空的时候遇到if语句的判断竟然跟想得不一样！于是深入地了解了下if语句的判断真假的几种情况，发现还真有点东西…(自己果然是菜鸡hhhhhhhh）

这个是书本上的
	i = Root(T);//i 为int型，这里Root函数返回的是空格字符
	if (！i) 
		printf("树空，无根\n");

这个是我写的
e = Root(T);//e为char型
 if(!e)
 		printf("树为空，无根\n");


没错，书本上写错了，判断语句应该是if（i）（我是不会告诉你这本书是《大话数据结构》的 ），也亏这里弄得我的程序总是不对，我才能发现原来在if语句真假的判断这种自认为简单的东西上自己也好菜啊…(手动狗头）
之后找了下资料，发现判断竟然有九种之多…好吧 ，任重而道远~~~~


已定义的变量，赋值为空字符串在if中认为是假，赋值为其他的字符串，也就是字符串中有字符（即使是"空格字符"）就认为是真；

这个就是上面第二个代码那个；


已定义的变量，赋值为0（不管是0，还是0.0）在if中则为假，其他数值认为是真，这和c语言中数值的类型的变量是一样的；

这个就是上面第一个代码那个；


然后补充一句，上面第一个代码Root函数返回的是空格字符，ascll码为32，所以i为32，所以判断if（！i）判断肯定为假啦；若把i改为字符型（就像上面第二个代码），然后空格字符型判断为假，if（！e）就没错了。


已定义的变量但未赋值在if中认为是假；

酱紫




已定义的对象，未赋值时在if中则为假，赋值后是真（其实由于在js中变量在没有赋值时是没有类型的，因此和第一种情况是一样的）；


js中的特殊值null，undefined，都是假（由于在js中未定义的变量默认值是undefined，因此这也就解释了第一类情况）；

嗷呜，这个都懂；


已定义的变量，赋值为true在if中认为是真，赋值为false，则为假，这和其他语言中bool的类型的变量是一样的；

这个应该是最常见的；


已定义的函数，根据调用方式又分为两种

第一种：不带括号的，如果定义了就是真，没有定义会报错，

第二种：带括号的，其实相当于调用函数，自然是根据函数的返回值判断真假；

emmmmmmmmm，这个，原谅在下弱鸡，没注意过…


已定义的对象的属性字段，和单独的变量是一样的，例如数值型为0时是假，其他为真，字符串型是为空值时是假，其他为真；


已定义的对象的方法，和单独的函数是一样的，不加括号是如果没定义就是假，加了括号相当于调用方法，就是根据返回值判断真假；


总结:最基本是null，undefined，if判断都是假；对于数值类型，0是假，其他为真；对于字符类型空字符串是假，其他为真，对于方法属性，如果定义了就是真，否则就是假，其他所有都可以看做是这些的变相应用。
（弱鸡的第一篇CSDN博客…莫名的激动…望各位大佬多多指教）

强引用：无论内存是否足够，不会回收。

软引用：内存不足时，回收该引用关联的对象。

弱引用：垃圾回收时，无论内存是否足够，都会回收。

虚引用：任何时候都可能被垃圾回收器回收。





在Java中，虽然不需要程序员手动去管理对象的生命周期，但是如果希望某些对象具备一定的生命周期的话（比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误）就需要用到软引用和弱引用了。

　　从Java SE2开始，就提供了四种类型的引用：强引用、软引用、弱引用和虚引用。Java中提供这四种引用类型主要有两个目的：第一是可以让程序员通过代码的方式决定某些对象的生命周期；第二是有利于JVM进行垃圾回收。下面来阐述一下这四种类型引用的概念：

　　1.强引用（StrongReference）

　　强引用就是指在程序代码之中普遍存在的，比如下面这段代码中的object和str都是强引用：








1

2




Object
 object = new Object();

String
 str = "hello";









　　只要某个对象有强引用与之关联，JVM必定不会回收这个对象，即使在内存不足的情况下，JVM宁愿抛出OutOfMemory错误也不会回收这种对象。比如下面这段代码：








1

2

3

4

5

6

7

8

9

10




public class Main
 {

    public static void main(String[]
 args) {

        new Main().fun1();

    }

     

    public void fun1()
 {

        Object
 object = new Object();

        Object[]
 objArr = new Object[1000];

    }

}









　　当运行至Object[] objArr = new Object[1000];这句时，如果内存不足，JVM会抛出OOM错误也不会回收object指向的对象。不过要注意的是，当fun1运行完之后，object和objArr都已经不存在了，所以它们指向的对象都会被JVM回收。

　　如果想中断强引用和某个对象之间的关联，可以显示地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

　　比如Vector类的clear方法中就是通过将引用赋值为null来实现清理工作的：




 /**
     * Removes the element at the specified position in this Vector.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).  Returns the element that was removed from the Vector.
     *
     * @throws ArrayIndexOutOfBoundsException if the index is out of range
     *         ({@code index < 0 || index >= size()})
     * @param index the index of the element to be removed
     * @return element that was removed
     * @since 1.2
     */
    public synchronized E remove(int index) {
    modCount++;
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);
    Object oldValue = elementData[index];

    int numMoved = elementCount - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                 numMoved);
    elementData[--elementCount] = null; // Let gc do its work

    return (E)oldValue;
    }




　　2.软引用（SoftReference）

　　软引用是用来描述一些有用但并不是必需的对象，在Java中用java.lang.ref.SoftReference类来表示。对于软引用关联着的对象，只有在内存不足的时候JVM才会回收该对象。因此，这一点可以很好地用来解决OOM的问题，并且这个特性很适合用来实现缓存：比如网页缓存、图片缓存等。

　　软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。下面是一个使用示例：








1

2

3

4

5

6

7

8

9




import java.lang.ref.SoftReference;

 

public class Main
 {

    public static void main(String[]
 args) {

         

        SoftReference<String>
 sr = new SoftReference<String>(new String("hello"));

        System.out.println(sr.get());

    }

}









　　3.弱引用（WeakReference）

　　弱引用也是用来描述非必需对象的，当JVM进行垃圾回收时，无论内存是否充足，都会回收被弱引用关联的对象。在java中，用java.lang.ref.WeakReference类来表示。下面是使用示例：








1

2

3

4

5

6

7

8

9

10

11

12




import java.lang.ref.WeakReference;

 

public class Main
 {

    public static void main(String[]
 args) {

     

        WeakReference<String>
 sr = new WeakReference<String>(new String("hello"));

         

        System.out.println(sr.get());

        System.gc();                //通知JVM的gc进行垃圾回收

        System.out.println(sr.get());

    }

}









　　第二个输出结果是null，这说明只要JVM进行垃圾回收，被弱引用关联的对象必定会被回收掉。不过要注意的是，这里所说的被弱引用关联的对象是指只有弱引用与之关联，如果存在强引用同时与之关联，则进行垃圾回收时也不会回收该对象（软引用也是如此）。

　　弱引用可以和一个引用队列（ReferenceQueue）联合使用，如果弱引用所引用的对象被JVM回收，这个软引用就会被加入到与之关联的引用队列中。

　　4.虚引用（PhantomReference）

　　虚引用和前面的软引用、弱引用不同，它并不影响对象的生命周期。在java中用java.lang.ref.PhantomReference类表示。如果一个对象与虚引用关联，则跟没有引用与之关联一样，在任何时候都可能被垃圾回收器回收。

　　要注意的是，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。








1

2

3

4

5

6

7

8

9

10

11




import java.lang.ref.PhantomReference;

import java.lang.ref.ReferenceQueue;

 

 

public class Main
 {

    public static void main(String[]
 args) {

        ReferenceQueue<String>
 queue = new ReferenceQueue<String>();

        PhantomReference<String>
 pr = new PhantomReference<String>(new String("hello"),
 queue);

        System.out.println(pr.get());

    }

}









二.进一步理解软引用和弱引用

　　对于强引用，我们平时在编写代码时经常会用到。而对于其他三种类型的引用，使用得最多的就是软引用和弱引用，这2种既有相似之处又有区别。它们都是用来描述非必需对象的，但是被软引用关联的对象只有在内存不足时才会被回收，而被弱引用关联的对象在JVM进行垃圾回收时总会被回收。

　　在SoftReference类中，有三个方法，两个构造方法和一个get方法（WekReference类似）：

　　两个构造方法：








1

2

3

4

5

6

7

8

9




public SoftReference(T
 referent) {

    super(referent);

    this.timestamp
 = clock;

    }

 

public SoftReference(T
 referent, ReferenceQueue<? super T>
 q) {

    super(referent,
 q);

    this.timestamp
 = clock;

    }









　　get方法用来获取与软引用关联的对象的引用，如果该对象被回收了，则返回null。

 　　在使用软引用和弱引用的时候，我们可以显示地通过System.gc()来通知JVM进行垃圾回收，但是要注意的是，虽然发出了通知，JVM不一定会立刻执行，也就是说这句是无法确保此时JVM一定会进行垃圾回收的。

首先我们简单的说一下js中的几种数据类型
数据类型分为基本类型和引用类型：
基本类型：String、Number、Boolean、Null、Undefined
引用类型：Object、Array、Date、Function、Error、RegExp、Math、Number、String、Boolean、Globle。
然后判断数据类型的方法一般可以通过：typeof、instanceof、constructor、toString四种常用方法
1、typeof:（可以对基本类型做出准确的判断，但对于引用类型，用它就有点力不从心了）
typeof 返回一个表示数据类型的字符串，返回结果包括：number、boolean、string、object、undefined、function等6种数据类型。
typeof 可以对JS基本数据类型做出准确的判断（除了null），而对于引用类型返回的基本上都是object, 其实返回object也没有错，因为所有对象的原型链最终都指向了Object,Object是所有对象的`祖宗`。 但当我们需要知道某个对象的具体类型时，typeof 就显得有些力不从心了。
注意：typeof  null会返回object，因为特殊值null被认为是一个空的对象引用

2、instanceof
判断对象和构造函数在原型链上是否有关系，如果有关系，返回真，否则返回假
function Aaa(){
}

var a1 = new Aaa();

//alert( a1 instanceof Aaa);  //true判断a1和Aaa是否在同一个原型链上，是的话返回真，否则返回假

var arr = [];

alert( arr instanceof Aaa);//false
我们来看一下
    var str = 'hello';
    alert(str instanceof String);//false
    var bool = true;
    alert(bool instanceof Boolean);//false
    var num = 123;
    alert(num instanceof Number);//false
    var nul = null;
    alert(nul instanceof Object);//false
    var und = undefined;
    alert(und instanceof Object);//false
    var oDate = new Date();
    alert(oDate instanceof Date);//true
    var json = {};
    alert(json instanceof Object);//true
    var arr = [];
    alert(arr instanceof Array);//true
    var reg = /a/;
    alert(reg instanceof RegExp);//true
    var fun = function(){};
    alert(fun instanceof Function);//true
    var error = new Error();
    alert(error instanceof Error);//true

从上面的运行结果我们可以看到，基本数据类型是没有检测出他们的类型，但是我们使用下面的方式创建num、str、boolean，是可以检测出类型的：
var num = new Number(123);
var str = new String('abcdef');
var boolean = new Boolean(true);
3、constructor：查看对象对应的构造函数
constructor 在其对应对象的原型下面，是自动生成的。当我们写一个构造函数的时候，程序会自动添加：构造函数名.prototype.constructor = 构造函数名
function Aaa(){
}
//Aaa.prototype.constructor = Aaa;   //每一个函数都会有的，都是自动生成的

//Aaa.prototype.constructor = Aaa;

判断数据类型的方法
    var str = 'hello';
    alert(str.constructor == String);//true
    var bool = true;
    alert(bool.constructor == Boolean);//true
    var num = 123;
    alert(num.constructor ==Number);//true
   // var nul = null;
   // alert(nul.constructor == Object);//报错
    //var und = undefined;
    //alert(und.constructor == Object);//报错
    var oDate = new Date();
    alert(oDate.constructor == Date);//true
    var json = {};
    alert(json.constructor == Object);//true
    var arr = [];
    alert(arr.constructor == Array);//true
    var reg = /a/;
    alert(reg.constructor == RegExp);//true
    var fun = function(){};
    alert(fun.constructor ==Function);//true
    var error = new Error();
    alert(error.constructor == Error);//true
从上面的测试中我们可以看到，undefined和null是不能够判断出类型的，并且会报错。因为null和undefined是无效的对象，因此是不会有constructor存在的
同时我们也需要注意到的是：使用constructor是不保险的，因为constructor属性是可以被修改的，会导致检测出的结果不正确
function Aaa(){
}
Aaa.prototype.constructor = Aaa;//程序可以自动添加，当我们写个构造函数的时候，程序会自动添加这句代码
function BBB(){}
Aaa.prototype.constructor = BBB;//此时我们就修改了Aaa构造函数的指向问题
alert(Aaa.construtor==Aaa);//false
可以看出，constructor并没有正确检测出正确的构造函数
4、Object.prototype.toString(可以说不管是什么类型，它都可以立即判断出)
toString是Object原型对象上的一个方法，该方法默认返回其调用者的具体类型，更严格的讲，是 toString运行时this指向的对象类型, 返回的类型
格式为[object xxx],xxx是具体的数据类型，其中包括：
String,Number,Boolean,Undefined,Null,Function,Date,Array,RegExp,Error,HTMLDocument,... 基本上所有对象的类型都可以通过这个方法获取到。 
    var str = 'hello';
    console.log(Object.prototype.toString.call(str));//[object String]
    var bool = true;
    console.log(Object.prototype.toString.call(bool))//[object Boolean]
    var num = 123;
    console.log(Object.prototype.toString.call(num));//[object Number]
    var nul = null;
    console.log(Object.prototype.toString.call(nul));//[object Null]
    var und = undefined;
    console.log(Object.prototype.toString.call(und));//[object Undefined]
    var oDate = new Date();
    console.log(Object.prototype.toString.call(oDate));//[object Date]
    var json = {};
    console.log(Object.prototype.toString.call(json));//[object Object]
    var arr = [];
    console.log(Object.prototype.toString.call(arr));//[object Array]
    var reg = /a/;
    console.log(Object.prototype.toString.call(reg));//[object RegExp]
    var fun = function(){};
    console.log(Object.prototype.toString.call(fun));//[object Function]
    var error = new Error();
    console.log(Object.prototype.toString.call(error));//[object Error]
从这个结果也可以看出，不管是什么类型的，Object.prototype.toString.call();都可以判断出其具体的类型。
接下来我们分析一下四种方法各自的优缺点
不同类型的优缺点
typeof
instanceof
constructor
Object.prototype.toString.call
优点
使用简单
能检测出引用类型
基本能检测所有的类型（除了null和undefined）
检测出所有的类型
缺点
只能检测出基本类型（出null）
不能检测出基本类型，且不能跨iframe
constructor易被修改，也不能跨iframe
IE6下，undefined和null均为Object
从上表中我们看到了，instanceof和constructor不能跨iframe,上面没有细说，所以下面我们直接上例子喽
例：跨页面判断是否是数组
window.onload = function(){
	
	var oF = document.createElement('iframe');
	document.body.appendChild( oF );
	
	var ifArray = window.frames[0].Array;
	
	var arr = new ifArray();
	
	//alert( arr.constructor == Array );  //false
	
	//alert( arr instanceof Array );  //false
	
	alert( Object.prototype.toString.call(arr) == '[object Array]' );  //true
	
	
};
从结果中可以看出，constructor和instanceof都没有正确的判断出类型，只有object.prototype.toString.call()；正确判断出了
其实面试官也经常喜欢让说一种最简单的判断是数组的方法，记住喽是object.prototype.toString.call()哦！
好了，今天就分享这些了！

1，利用00截断，brupsuite上传
利用00截断就是利用程序员在写程序时对文件的上传路径过滤不严格，产生0X00上传截断漏洞。

假设文件的上传路径为http://xx.xx.xx.xx/upfiles/lubr.php.jpg ,通过Burpsuite抓包截断将lubr.php后面的“.”换成“0X00”。在上传的时候，当文件系统读到”0X00″时，会认为文件已经结束，从而将lubr.php.jpg 的内容写到lubr.php中，从而达到攻击的目的。
2，构造服务器端扩展名检测上传
当浏览器将文件提交到服务器端的时候，服务器端会根据设定的黑名单对浏览器提交上来的文件扩展名进行检测，如果上传的文件扩展名不符合黑名单的限制，则不予上传，否则上传成功。

本例讲解，将一句话木马的文件名lubr.php改成lubr.php.abc。首先，服务器验证文件扩展名的时候，验证的是.abc，只要改扩展名符合服务器端黑名单规则，即可上传。另外，当在浏览器端访问该文件时，Apache如果解析不了.abc扩展名，会向前寻找可解析的扩展名，即”.php”。一句话木马可以被解析，即可通过中国菜刀连接。
3，绕过Content-Type检测文件类型上传
当浏览器在上传文件到服务器端的时候，服务器对上传的文件Content-Type类型进行检测，如果是白名单允许的，则可以正常上传，否则上传失效。绕过Content-Type文件类型检测，就是用Burpsuite截取并修改数据包中文件的Content-Type类型，使其符合白名单的规则，达到上传的目的。
4，构造图片木马，绕过文件内容检测上传Shell
一般文件内容验证使用getimeagesize()函数检测，会判断文件是否一个有效的文件图片，如果是，则允许上传，否则的话不允许上传。
制作图片木马： copy 1.jpg/b+2.php/a 3.jpg