var의 문제점.

헷갈리는 함수 레벨 스코프.

if 문 안에서 선언 했지만 if 문 밖에서 사용 가능.
var는 코드 블럭을 무시하기 때문에 전역 변수가 됨.
01.js

  (function() {
    if( true ) {
      var variable = 'function scope';
    }
    console.log( variable );
  })();

중복 선언이 가능.

전역 변수가 된 var가 중복 선언 까지 됨.
02.js

  (function() {
    var variable = 'function scope';
    var variable = 'duplicated';
    console.log( variable );
  })();

var keyword 생략 가능

var keyword 를 생략해도 변수가 선언됨.
03.js

  (function () {
    variable = 'no keyword';
    console.log(variable);
  })();

Hoisting 문제

Hoisting?
선언은 코드 처음에 실행되지만, 변수에 값을 할당한 곳에서 값이 할당하는 문제.
04.js

  (function() {
    console.log( variable );
    var variable = 'hoisted';
  })();

  //  -> 위 코드는 호이스팅에 의해 아래와 같다.

  (function() {
    var variable;
    console.log( variable );
    variable = 'hoisted';
  })();

let keyword

let keyword를 사용하면, 문제가 해결됨.
05.js

//  1. 블록 레벨 스코프
{
  let variable = 'block scope';
  console.log( variable );
}

//  2. 중복 선언 => syntax error
{
  let variable = 'block scope';
  let variable = 'duplicated';
  console.log( variable );
}

//  3. 호이스팅   => syntax error
{
  console.log( variable );
  let variable = 'hoisted';
}

const keyword

상수 선언 키워드로 재 할당이 불가능하고, 선언과 동시에 할당이 이루어 져야 한다.
06.js

  //  Privitive
  let a = 'a';
  a = 'b';
  console.log( a );

  const c = 'c';
  c = 'd'; // ->  TypeError

const 는 call by value로 주로 Object나 Array를 선언하는데 사용되며,
내부의 요소는 재할당 가능하다.
07.js

  //  Reference
  let e = {
    foo : 'foo',
  };
  e = {
    bar : 'bar'
  };

  console.log( e );

  const f = {
    foo : 'foo',
  };
  /*
  f = {
    foo : 'bar'
  };  //  -> TypeError
  */
  f.foo = 'bar'

  console.log( f );
  /**
  * const c = { c : 'c' };
  * c    -> call by ref
  * c.c  -> call by value
  */

회사에서 ES5 이상의 문법을 팀 내부 교육을 진행하게 됐음.
부담스럽긴 하지만 하라고 하면 해야 하니, 내용을 정리했고.
정리하다 블로그에 올리면 좋을 거 같아서 포스팅하기로 함.

모오오던 JS

일반적으로 사용하는 JS 문법은 ES5 문법으로 2009년 12월에 출판되었음.
2015년 ES6가 출판되었고, ES6 이후의 문법을 Modern JavaScript라고 부르는 추세임.
(과연 언제까지 이 문법이 모던하다고 할진 모르겠지만)
그 후로 매년 새로운 업데이트가 있었고.
IE 같은 구형 브라우져는 최신 문법을 지원하지 않지만, babel과 같은 도구를 이용하면 구형 브라우져에서도 작동하게 변환할 수 있음.

목차

• var || ( let && const )
• Template Literal
• Arrow Function
• 비구조화 할당
• spread와 rest
• Promise
• async && await

아랫부분은 더 포스팅 하고 싶지만, 일하면서 여기까지 정리 할 수 있을지 모르겠으므로 보류.

• truthy and falsy
• 단축 평가 논리 연산
• 함수의 기본 파라미터
• 조건문 더 스마트하게 쓰기

그외 버전별 주요 문법

버전별로 발행된 문법이나 함수들은 많지만, 주로 알아야 하는 것들은 다음과 같음.
한번씩 찾아 보기를 권장함.

• ES6
  • let, const
  • module (import, export)
  • Promise
  • template literal
  • arrow function
  • class
  • generater
  • default parameters
  • for...of
  • map, set, weakMap, weakSet
• ES7
  • 구조 분해 할당. (비구조화 할당 ||Destructuring Assignment)
  • 비동기를 위한 await, async
  • 변수와 함수의 블록 스코프
• ES8
  • Generator와 Promise를 위한 await, async 구조체
• ES9
  • rest, spread 문법
  • 비동기 이터레이션
  • Promise.prototype.finally()
• ES10
  • Object와 Array

Java ArrayList Sort

개요

한동안 JS 만 만지다 Java ArrayList를 sort 해야 하는 일이 생김.
DB 에서 이미 ORDER BY 해서 꺼내온 두 개의 List를 merge 한 List 였는데,
요소들은 항적 데이터 { 선박 ID(ship_id), 위치정보(geom), 항적 시간(date(초)) } 로 이루어 져 있고, 시간으로 정렬 해야 했음.

  public class Record {
    String  tbship_id;
    String  geom;
    int     sec;
  }

하도 JS 만 만졌더니 간단한 로직인데 1시간 정도 삽질 했고 블로그에 남기기로 함.

방법 1

Record 객체를 Comparable 상속 받게 한 뒤, compareTo 메소드를 오버라이드, 필요한 곳에서 정렬 메소드를 호출.
compareTo 메소드는 int를 반환해야 하며 오름차순 정렬일 경우, 다음을 반환해야 함.

• 기준점이 비교대상보다 크다면 양수.
• 기준점이 비교대상과 같다면 0.
• 기준점이 비교대상보다 작다면 음수.

Record.java

  public class Record implements Comparable<Record> {
    String  tbship_id;
    String  geom;
    int     sec;

    /* ... */

    @Override
    public int compareTo(Record o) {
      if( this.cal < o.cal ) return -1;
      else if (this.cal == o.cal ) return 0;
      else return 1;
    }
  }

TrackDAOImpl.java

  /* ... */
  Collections.sort(mergedList);

방법 2

정렬이 필요한 곳에서 Comparator 객체를 생성한 뒤, compare 메소드를 오버라이드 후, 정렬 메소드를 호출.
compare 메소드는 int를 반환하며, 앞의 방법과 같이 기준점 대비 비교점으로 짜야함.

• 기준점이 비교대상보다 크다면 양수.
• 기준점이 비교대상과 같다면 0.
• 기준점이 비교대상보다 작다면 음수.

  Comparator<Record> compare = new Comparator<Record>() {

  @Override
  public int compare(Record prev, Record curr) {
    if( prev.getCal() < curr.getCal() ) return -1;
    else if (prev.getCal() == curr.getCal() ) return 0;
    else return 1;
    }
  };

  Collections.sort(mergedList, compare);

방법 3

Collection.sort() 메소드의 두번째 인자로 익명 객체를 넣어 줌..
방법 1, 2를 보면 쉽게 이해할 수 있음.

  Collections.sort(mergedList, (Comparator<Record>) (Record prv, Record cur) -> {
    if( prv.getCal() < cur.getCal() ) return -1;
    else if (prv.getCal() == cur.getCal() ) return 0;
    else return 1;
  });

그 외

개인적으로는 세번째 방법이 낫겠다 싶은데 이유는 객체의 compareTo 메소드에 다른 필드 값 대한 비교가 필요할 경우가 있기 때문.
메소드를 구현 할때, 다른 비교 구분이 필요할 경우가 있기 때문.