document.cookie = 'ppkcookie1=testcookie; expires=Thu, 2 Aug 2001 20:47:11 UTC; path=/'

document.cookie = 'ppkcookie2=another test; expires=Fri, 3 Aug 2001 20:47:11 UTC; path=/'

var cookieEnabled = (function() {
	var id = new Date().getTime();
	
	document.cookie = 'cookieprobe=' + id + ' ;path=/';
	
	return (document.cookie.indexOf(id) != -1);
})();

속성
unsigned int length

메소드 
DOMString  key(unsigned int index)
any getItem(DOMString  key)
void setItem(DOMString key, data)
void removeItem(DOMString  key)
void clear()

sessionStorage.setItem(‘twitter’, ‘@rem’);
sessionStorage.twitter = ‘@rem’;

sessionStorage.getItem(‘cost’);
sessionStorage.twitter

for (var i = 0; i < sessionStorage.length; i++) {
	alert(sessionStorage.key(i) + ‘=’ + sessionStorage.getItem(sessionStorage.key(i)));
}

function stringify() {
	var videoDetails = {
		author: '감우성',
		description: '무법자',
		rating: '5.51'
 	};
 
		
 	sessionStorage.setItem('videoDetails', JSON.stringify(videoDetails));
}

function parse() {
	var videoDetails = JSON.parse(sessionStorage.getItem('videoDetails') || 'null');
	alert(videoDetails.author + "\n" + videoDetails.description + "\n" +  videoDetails.rating);
}

var db; 
if (window.openDatabase) {
	db = openDatabase(‘mydb’, ‘1.0’, ‘My first database’, 2 * 1024 * 1024);
}

db.transaction(
    function(tx) {
  tx.executeSql(sql, [], function () {
  // 실행코드
  }); 
  },
  function(tx, error) { 
      alert(‘에러: ‘ + error.message);   
  }
});

my_string.c

import java.util.*;

// 모든 Set 컬렉션은
// 중복 회피를 위해 equals()를 재정의 해야함
class SetType {
        int i;
        public SetType(int n) {
                i = n;
        }
        public boolean equals(Object o) {
                return o instanceof SetType && (i == ((SetType)o).i);
        }
        public String toString() {
                return Integer.toString(i);
        }
}

// HashSet 계열은 equals() 외에 hasCode()를 재정의 해야함
// 그렇지 않을 경우 equals()를 정의했어도, 데이터 중복이 발생
class HashType extends SetType {
        public HashType(int n) {
                super(n);
        }
        public int hashCode() {
                return i;
        }
}

// TreeSet 계열은 equals() 외에 compareTo()를 재정의 해야함
// compareTo()를 재정의 하지않으면 실행시 ClassCastException 발생
class TreeType extends SetType implements Comparable<treetype>
 {
        public TreeType(int n) {
                super(n);
        }
        public int compareTo(TreeType arg) {
                return (i > arg.i ? 1 : (i == arg.i) ? 0 : -1);
        }
}


public class TypesForSets {
        
        static <t> Set<t> fill(Set<t> set, Class<t> type) {
                try {
                        for (int i = 0; i < 10; i++) {
                                // int형 인자를 갖는 생성자를 얻어서, 객체 생성
                                set.add(type.getConstructor(int.class).newInstance(i));
                        }
                } catch(Exception e) {
                        throw new RuntimeException(e);
                }
                return set;
        }
        
        static <t> void test(Set<t> set, Class<t> type) {
                // 객체 중복저장 시도 - 셋의 특성을 알아보기 위함
                fill(set, type);
                fill(set, type);
                fill(set, type);
                System.out.println(set);
        }
        
        public static void main(String[] args) {
                // HashSet 계열은 equals() 와 hashCode()를 재정의 해야함
                test(new HashSet(), HashType.class);
                test(new LinkedHashSet(), HashType.class);
                // TreeSet 계열은 equals() 와 compareTo()를 재정의 해야함
                test(new TreeSet(), TreeType.class);
                
                // 아래메소드들은 각 Set 컬렉션의 특성이 파괴됨
                test(new HashSet(), SetType.class);
                test(new HashSet(), TreeType.class);
                test(new LinkedHashSet(), SetType.class);
                test(new LinkedHashSet(), TreeType.class);
                
                try {
                        test(new TreeSet(), SetType.class);
                } catch (Exception e) {
                        System.out.println(e.getMessage());
                }
                try {
                        test(new TreeSet(), HashType.class);
                } catch (Exception e) {
                        System.out.println(e.getMessage());
                }
        }
}

package com.tistory.hiddenviewer.reflection.executor;

import java.lang.reflect.Method;
import com.tistory.hiddenviewer.reflection.Board;

public class GetterSetterPrinter {

	public static void main(String[] args) {
		printGettersSetters(Board.class);
	}

	public static void printGettersSetters(Class aClass){
		Method[] methods = aClass.getMethods();

		for(Method method : methods){

			if(isGetter(method)) {
				System.out.println("getter: " + method);
			} 

			if(isSetter(method)) {
				System.out.println("setter: " + method);
			}
		} // for
	}
	

	public static boolean isGetter(Method method){
		// get 으로 시작하지 않으면 반환
		if(!method.getName().startsWith("get")) {
			return false;
		}
		// 파라미터가 있으면 반환 
		if(method.getParameterTypes().length != 0) {
			return false;  
		}
		// 반환값이 없으면 반환
		if(void.class.equals(method.getReturnType())) {
			return false;
		}
		return true;
	}
	public static boolean isSetter(Method method){
		// set 으로 시작하지 않으면 반환 
		if(!method.getName().startsWith("set")) {
			return false;
		}
		// 파라미터가 개수가 1이 아니면 반환 
		if(method.getParameterTypes().length != 1) {
			return false;
		}
		return true;
	}
}

// 생성자 목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor[] constructors = aClass.getConstructors();

// 특정 파라미터를 갖는 생성자 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Constructor constructor =
        aClass.getConstructor(new Class[]{String.class});

// 생성자의 파라미터 타입목록 얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Class[] parameterTypes = constructor.getParameterTypes();

// 하나의 String 파라미터를 갖는 생성자를 얻는다. 
Constructor constructor = MyObject.class.getConstructor(String.class);
// 생성 
MyObject myObject = (MyObject)constructor.newInstance("constructor-arg1");

// 클래스에 선언된 public 속성의 Field 객체얻기
Class aClass = ... // 이전에 얻은 클래스 객체
Field[] fields = aClass.getFields();

public class MyObject{
  public String someField = null;
}

// Field 이름 얻기
Field field = ... // Field 객체를 얻는다. 
String fieldName = field.getName();

// Field 타입 얻기 
Field field = aClass.getField("someField");
Object fieldType = field.getType();

// Field 값 설정하고 조회하기
Class  aClass = MyObject.class
Field field = aClass.getField("someField");
MyObject objectInstance = new MyObject();
Object value = field.get(objectInstance);
field.set(objetInstance, value);

Board board = new Board();
board.setContents("test contents...");
		
Field field = cls.getDeclaredField("contents");
field.setAccessible(true);
String contents = (String) field.get(board);
		
System.out.println("Private Contents Field: " + contents);

// Method 객체목록 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method[] methods = aClass.getMethods();

// 파라미터를 갖는 메소드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", new Class[]{String.class});

// 파라미터가 없는 메서드의 Method 객체 얻기 
Class aClass = ... // 이전에 얻은 클래스 객체
Method method = aClass.getMethod("doSomething", null);

// 메서드의 파라미터 타입목록 얻기 
Method method = ... //
Class[] parameterTypes = method.getParameterTypes();

// 메서드의 반환값 타입 얻기 
Method method = ... //
Class returnType = method.getReturnType();

// 메서드 호출 
Method method = MyObject.class.getMethod("doSomething", String.class);
Object returnValue = method.invoke(null, "parameter-value1");