'BooksReview'에 해당되는 글 10건

함수형에서 for 와 if 의 변화

1. for에서 filter로 if에서 predicate로

1) 기존 문장

var users = [ {id :1, name :'ID', age:32}, {id :2, name :'ha', age:30}, {id :3, name :'bj', age:29}, ] //30살 이하의 데이터를 추출하여 새로운 배열에 넣는다 var temp_user = []; for(var i = 0, len = users.length; i<len; i++){ if(users[i].age<30){ temp_user.push(users[i]); } } console.log(temp_user.length);

2) filter 함수로 변환

var users = [ {id :1, name :'ID', age:32}, {id :2, name :'ha', age:30}, {id :3, name :'bj', age:29}, ] function filter(list, predicate){ var new_list = []; for(var i = 0, len = list.length; i<len; i++){ if(predicate(list[i])){ new_list.push(list[i]); } } return new_list; } var users_under_30 = filter(users, function(user) { return user.age < 30 }); var users_over_30 = filter(users, function(user){return user.age > 30}); console.log(users_under_30.length);  

- 새로운 배열을 생성하여 반환한다.

- predicate 함수를 이용하여 원하는 반환 값을 얻는다.

2. 중복 코드를 map 함수로 제거한다

1) 기존 문장

var ages = []; for(var i = 0, len = temp_user.length; i<len; i++){ ages.push(temp_user[i].age); } console.log(ages);  

- 새로 만든 배열에서 이름을 추출한다.

2) map 함수로 변환

function map(list, iteratee){ var new_list = []; for(var i=0, len = list.length; i<len; i++){ new_list.push(iteratee(list[i])) } return new_list; } var ages = map(users_under_30, function(user){return user.age}); var name = map(filter(users, function(user) { return user.age < 30 }), function(user){return user.name}); console.log(ages);  

- 코드가 더욱 단순해 졌다. 또한 함수를 합쳐서 실행결과로 바로 실행할 수 있다.

3. 클로저를 이용한 map 함수 줄이기

1) 클로저 함수 패턴

function bvalue(key){ return function(obj){ return obj[key]; } } var b = bvalue('b'); console.log(b({a:'hi',b:'hello'})); console.log(bvalue('a')({a:'hi',b:'hello'}));  

2) filter, map, bvalue 

var name = map(filter(users, function(user) { return user.age < 30 }), bvalue('name'));  

- 더욱 간결해 졌다.

클로저란?(Closure)

1. 클로저란?

- 자신이 생성될 떄의 스코프에서 알 수 있었던 변수 중 언젠가 자신이 실행될 때 사용할 변수들만 기억하여 유지시키는 함수

2. 예제

function f6(){ var a = 10; function f7(b){ return a + b; } return f7; } var f8 = f6(10); f8(10); //20 f8(20); //30

- f7이 변수 a를 기억하는 클로저로 작동하고 있다. f8을 실행 할 때마다 새로운 변수인 b와 함께 실행된다.

생성자의 builder패턴 적용(builder pattern)

1. 생성자의 문제

1) 선택적 인자가 많은 상황에 잘 적응하지 못한다

2. 점층적 생성자 패턴(telescroping constructor pattern)

- 필요한 생성자를 하나씩 추가하는 방식

public class NutritionFacts { private final int servingSize; private final int servings; private final int calories; private final int fat; public NutritionFacts(int servingSize, int servings) { this(servingSize, servings, 0, 0); } public NutritionFacts(int servingSize, int servings, int calories) { this(servingSize, servings, calories, 0); } public NutritionFacts(int servingSize, int servings, int calories, int fat) { this.servingSize = servingSize; this.servings = servings; this.calories = calories; this.fat = fat; } }

1) 문제점

- 설정할 필요없는 값(위의 0 같은)을 설정해야한다. 

- 점층적 생성자 패턴은 잘 동작하지만 클라이언트 코드 작성이 어렵고 가독성이 떨어진다.

3. 자바빈 패턴(JavaBeans pattern)

- 인자 없는 생성자를 호출하여 객체를 만든다음 설정 메소드로 필드값을 추가하는 방식

public class NutritionFacts { private int servingSize = -1; private int servings = -1; private int calories = 0; private int fat = 0; public int getServingSize() { return servingSize; } public void setServingSize(int servingSize) { this.servingSize = servingSize; } public int getServings() { return servings; } public void setServings(int servings) { this.servings = servings; } public int getCalories() { return calories; } public void setCalories(int calories) { this.calories = calories; } public int getFat() { return fat; } public void setFat(int fat) { this.fat = fat; } }

- 사용

NutritionFacts coke = new NutritionFacts(); cock.setServingSize(240); cock.setServings(100); ....

1) 문제점

- 1회의 함수 호출로 객체 생성을 끝낼수 없다.(객체의 일관성이 일시적으로 깨진다)

- 변경 불가능 클래스(immutable)를 만들 수 없다.

4. 빌더패턴(builder pattern)

- 점층적 생성자 패턴 + 자바빈 패턴

- 필요한 객체를 직접 생성하는 대신, 클라이언트는 먼저 필수 인자들을 생성자에 전부 전달하여 빌더 객체를 만든다.

- 빌더 객체에 정의된 설정 메소드를 호출하어 선택적 인자를 추가한다.

public class NutritionFacts { private final int servingSize; private final int servings; private final int calories; private final int fat; //빌더 패턴 정의 public static class Builder{ private int servingSize; private int servings; private int calories; private int fat; public Builder(int servingSize, int servings) { this.servingSize = servingSize; this.servings = servings; } //설정 메소드 public Builder calories(int val) { calories = val; return this; } public Builder fat(int val) { fat = val; return this; } //최종값 반 public NutritionFacts build() { return new NutritionFacts(this); } } private NutritionFacts(Builder builder) { servingSize = builder.servingSize; servings = builder.servings; calories = builder.calories; fat = builder.fat; } }

- 사용

NutritionFacts coke = new NutritionFacts.Builder(240, 8).calories(100).fat(0).build();

1) 장점

- 불변식(invariant) 적용이 가능하다. build() 해당 불변식이 위반되었는지 검사가 가능하다.

- 여러개의 varargs 인자를 받을 수 있다.

- 유연하다. 하나의 빌더 객체로 여러 객체를 만들 수 있다.

2) 단점

- 객체를 생성하려면 먼저 빌더 객체를 생성해야한다.

생성자 vs 정적팩토리메소드(Constructor vs static factory method)

- 기존에 객체를 만드는 방법은 public 생성자를 이용하는 방법이다. 그러나 public 으로 선언된 정적 팩토리 매소드를 이용한 객체 생성방법으로 여러 장점을 얻을 수 있다.

1. 정적 팩토리 메소드 예제

public class Test { int max; //Origin public Test(int max){ this.max = max; } //static factory method public static Test getInstance(int max){ return new Test(max); } public int getInt(){ return max; } public static void main(String[]args){ //Origin Test instance = new Test(10); System.out.println(instance.getInt()); //static Factory method System.out.println(Test.getInstance(20).getInt()); } }

2. 정적 팩토리 메소드의 장점

1) 생성자와 달리 이름이 있다.

- 생정자와 달리 사용하기 쉽고 가독성을 높일 수 있다.

- 여러 생성자를 만들었을 때 나타나는 문제를 해결 할 수 있다.

2) 호출 할 때 마다 새로운 객체를 생성할 필요가 없다

- 불필요하게 같은 객체가 생성되는 것을 막을 수 있다.

- 개체 통제 클래스(instance-controlled class) 화 할 수 있다.

* 개체 통제 클래스

- 어떤 시점에 어떤 객체가 얼마나 존재할 지 통제 할 수 있다

3) 생성자와 달리 반환 값 자료형의 하위 자료형 객체를 반환 할 수 있다.

- 반환 되는 객체 클래스를 유연하게 결정

public class Test { //static factory method public static Test getInstance(int max){ return new Test(); } public static Test getTestType(String name){ if(name.equals("English")){ return new EnglishTest(); }else{ return new MathTest(); } } } class EnglishTest extends Test{ } class MathTest extends Test{ }

4) 형인자 자료형(parameterized type) 객체를 만들 때 편하다

//origin Map<String, List<String>> m = new HashMap<String, List<String>>(); //static factory method Map<String, List<String>> m = HashMap.newInstance();

- 기존에는 형인자가 늘어 짐에 따라 길고 복잡한 코드가 만들어진다.

- 정적팩토리 메소드를 사용하면 컴파일러가 형인자를 스스로 알아낸다(자료형 유추( type inference))

3. 정적 팩토리 메소드의 단점

1) 정적 팩토리 메소드만 있는 클래스는 하위 클래스를 만들 수 없다

2) 다른 정적 메소드와 확연히 구분되지 않는다