고두

이 글은 "JavaScript Patterns" 책을 공부하며 요약해 쓴 글입니다.

for

for 루프는 배열, arguments, HTMLCollection 등 배열과 비슷한 객체를 순회한다.

*HTMLCollection: HTML 요소들의 리스트로 유사배열객체이다.

 
ex) var x = document.getElementByTagName('div');
// getElementByTagName 메서드가 div 요소들의 리스트인 HTMLCollection을 반환한다.
// 변수 x에 담긴 HTMLCollection 객체는 인덱스 번호로 접근할 수 있다.
var y = x[1];

일반적인 for 문

 
xxxxxxxxxx
for(var i=0; i < arr.length; i++) {
  // arr[i]를 다루는 코드
}

이 패턴은 루프 순회시마다 arr의 length에 접근한다.

만약 arr이 배열이 아닌 HTMLCollection이라면 코드가 느려질 수 있다.

• 실제 DOM의 접근 비용은 일반적으로 크다.
• HTMLCollection 객체의 length 속성 접근은 실제 DOM에 질의를 요청하는 것과 같다.
• 실제 DOM 질의는 실시간으로 처리된다. 브라우저는 DOM 조작이 일어나면 다시 브라우저에 렌더링하는데에 수 많은 처리 과정을 거치는데, 이는 많은 비용이 요구된다. (reflow를 참고)

arr.length의 값이 10000이라면 브라우저를 10000번 렌더링하는 것과 같다.

여러 최적화 방법들

1. 배열(또는 콜렉션)의 length를 캐시

 
​x
for(var i=0, length=arr.length; i<length; i++) {
  // here code
}
​
// 단일 var 패턴
function test() {
  var i,
      length,
      arr = [];
      
  for(i=0, length=arr.length; i<length; i++) {
    // here code
  }
}

HTMLCollection 객체의 length 값을 초기화 변수에 저장하여 한 번의 DOM 접근만이 이루어진다.

2. 변수 갯수 줄이기, 배열을 거꾸로 순회

 
xxxxxxxxxx
var i, arr = [];
​
for(i=arr.length-1; i<0; i--) {
  // here code
}

length 변수를 없애고, 배열의 카운트를 감소시켜 0으로 내려간다. (미세 최적화)

• 0과 비교하는 것이 배열의 length 또는 0이 아닌 값과 비교하는 것보다 대게 더 빠르다.
• 성능이 결정적인 요소가 되는 작업에서 사용하는 것을 권장

for-in

for-in 루프는 배열이 아닌 객체를 순회할 때 사용해야 한다.

• 자바스크립트의 배열은 객체이기 때문에 for-in 루프를 통해 순회할 수 있지만, 권장사항이 아니다.
• 배열 객체에 사용자가 정의한 기능이 추가되면 논리적인 오류가 발생할 수 있다.
• 열거 순서가 정해져있지 않다. 실제로 배열은 for-in이 아닌 for 루프로 순회하는 것이 좀 더 빠르다.

 
xxxxxxxxxx
var fruits = {
  apple: 3,
  tomato: 1,
  grape: 2
};
​
for(var i in fruits)
    console.log(fruits[i]);

일어날 수 있는 오류 피하기

코드 내에 'Object.prototype.메서드명'이라는 사용자가 지정한 메서드가 모든 객체에 추가되었다고 가정하자.

이 메서드 프로퍼티는 프로토타입 체인을 따라 상속되어 모든 객체의 프로퍼티로 사용할 수 있게 된다.

이 문제로 인해 어떤 객체가 for-in 루프로 순회하는 과정에서 의도치 않게 메서드가 사용될 수 있다.

ex)

 
xxxxxxxxxx
var fruits = {
  apple: 3,
  tomato: 1,
  grape: 2
};
// helloWorld 메서드 추가
Object.protype.helloWorld = function() {
  console.log('Hello World!');
};
​
for(var i in fruits)
    console.log(fruits[i]);
    
// 출력
3
1
2
f () {
  console.log('Hello World!');
}

1. hasOwnProperty() 사용

Object의 hasOwnProperty 메서드를 사용하여 객체 변수의 고유 프로퍼티만을 사용할 수 있다.

 
xxxxxxxxxx
for(var i in fruits) {
  if(fruits.hasOwnProperty(i)) {
    console.log(fruits[i]);
  }
}
​
// 출력
3
1
2

2. Object.prototype.hasOwnProperty.call() 사용

이 패턴은 만약 fruits 객체의 hasOwnProperty 메서드를 오버라이딩 했을 경우에도, 온전한 hasOwnProperty 메서드를 사용할 수 있게 해준다.

 
xxxxxxxxxx
console.log(fruits.hasOwnProperty('apple')); // true
​
// hasOwnProperty 메서드 오버라이딩
fruits.hasOwnProperty = function() {
  console.log("overwriting this method");
}
​
console.log(fruits.hasOwnProperty()); // overwriting this method
​
// 더 이상 fruits 객체의 hasOwnProperty를 통해 프로퍼티 존재를 알 수 없으므로
for(var i in fruits) {
  if(Object.prototype.hasOwnProperty.call(fruits, i)) {
    console.log(fruits[i]);
  }
}
​
// 출력
3
1
2

3. Object.prototype.hasOwnProperty 캐시

프로퍼티 탐색이 체인을 따라 Object까지 거슬러 올라가지 않게 하기 위해, 지역 변수를 사용하여 메서드를 캐시한다.

 
xxxxxxxxxx
var i,
    hasProperty = Object.prototype.hasOwnProperty;
    
for(i in fruits) {
  if(hasProperty.call(fruits, i)) {
    console.log(fruits[i]);
  }
}

hasOwnProperty()를 사용하지 않았다고 해서 오류가 발생하지는 않으며, 루프 속도가 약간 감소될 수 있지만, 객체와 객체 프로토타입 체인의 내용을 보장할 수 없다면 hasOwnProperty()로 확인하는 것이 좀 더 안전한 방법이다.

Ruby koans의 about_objects.rb를 정리한 내용

is_a

 
xxxxxxxxxx
def test_everything_is_an_object
  assert_equal true, 1.is_a?(Object)
  assert_equal true, 1.5.is_a?(Object)
  assert_equal true, "string".is_a?(Object)
  assert_equal true, nil.is_a?(Object)
  assert_equal true, Object.is_a?(Object)
end

인수의 클래스가 오브젝트의 클래스이거나 부모 클래스의 오브젝트 중 하나 혹은 모듈이 오브젝트에 속해 있으면 true를 반환한다.

=> 위의 예제는 Integer, Float, String, nil, Object 모두 Object 클래스를 부모 클래스로 가지고 있으므로 true를 반환한다.

to_s

 
xxxxxxxxxx
def test_objects_can_be_converted_to_strings
  assert_equal "123", 123.to_s
  assert_equal "", nil.to_s
end

to_s는 어떤 오브젝트든 문자열로 표현할 수 있는 메서드이다.

=> 위의 예제는 숫자 123(Integer)을 문자열 "123"로, nil("아무것도 없음"을 의미, nothing)을 문자열 ""로 변환한다.

inspect

 
xxxxxxxxxx
def test_objects_can_be_inspected
  assert_equal "123", 123.inspect
  assert_equal "nil", nil.inspect
end

inspect는 to_s처럼 오브젝트를 문자열로 변환한다. 하지만 차이점이 있다.

to_s는 오브젝트의 내용 자체를 문자열 변환하며, 객체 클래스의 경우 obejct_id를 문자열로 변환한다.

반면, inspect는 객체에 기록된 내용을 지정된 형식의 문자열 형태로 변환한다. 즉, 개발자가 디버깅하는데에 좀 더 친숙한 문자열 형태로 반환해준다.

ex) inspect user obj

 
xxxxxxxxxx
user = User.first
puts "This is #{user.inspect} information"
This is #<User id: 1, email: "username@example.com", encrypted_password: "$2a$10$D57y73Q9HUXG9Hym3bLl8.MizOdTRxd6NQH6snHi4Q....", reset_password_token: nil, reset_password_sent_at: nil, remember_created_at: "2014-10-15 11:19:09", sign_in_count: 13, current_sign_in_at: "2014-10-21 20:10:18", last_sign_in_at: "2014-10-20 17:37:27", current_sign_in_ip: "127.0.0.1", last_sign_in_ip: "127.0.0.1", created_at: "2014-06-30 17:41:06", updated_at: "2014-10-21 20:10:18"> information"

=> 위의 예제에서 nil.inspect의 경우는 개발자가 읽기 쉬운 형태로 값을 변환해주기 때문에 nil을 문자열 형태로 변환하여 표현한다.

obj.object_id.class ==? Fixnum

 
xxxxxxxxxx
def test_every_object_has_an_id
  obj = Object.new
  assert_equal Fixnum, obj.object_id.class
end

Ruby의 Fixnum은 'Lisp'에서 온 것으로 32bit(in VM)의 고정된 정수 값을 나타낸다. 정수 값의 범위는 -((2^30)-1)에서 (2^30)-1로 -1073741824에서 1073741824의 정수를 표현한다. (그 외의 작고 큰 정수 값은 Bignum으로 표현한다.)

ex)

 
xxxxxxxxxx
puts 1073741823.class.name
=> "Fixnum"
puts 1073741824.class.name
=> "Fixnum"
puts 1073741825.class.name
=> "Bignum"
puts -1073741824.class.name
=> "Fixnum"
puts -1073741825.class.name
=> "Bignum"

=> 위의 예제에서 object_id는 일반적으로 Fixnum이 표현할 수 있는 범위 내의 정수 값을 할당받게 되므로 object_id의 클래스명은 Fixnum이다.

object has different id

 
xxxxxxxxxx
def test_every_object_has_different_id
  obj = Object.new
  another_obj = Object.new
  assert_equal true, obj.object_id != another_obj.object_id
end

모든 객체 인스턴스는 자신을 유일하게 식별할 수 있는 고유한 object_id를 갖는다. 여기서 object_id는 정수(Interger) 값으로 표현한다. 고유한 정수 값이기 때문에 메모리 주소 값을 할당 받는다고 생각할 수 있다.

=> 위의 예제에서 obj와 another_obj 객체 인스턴스는 생성될 때 서로 다른 object_id를 갖기 때문에 not 비교문에서 true를 반환한다.

object_id pattern for small integers

 
xxxxxxxxxx
def test_small_integers_have_fixed_ids
  assert_equal 1, 0.object_id
  assert_equal 3, 1.object_id
  assert_equal 5, 2.object_id
  assert_equal 201, 100.object_id
​
  # THINK ABOUT IT:
  # What pattern do the object IDs for small integers follow?
end

위의 몇 가지 예제를 통해 객체 인스턴스는 고유한 obejct_id를 갖고 Fixnum을 통한 정수 값을 할당받는다고 설명했다. 그렇다면 true, false, nil과 같이 항상 같은 값을 갖는 오브젝트들은 어떻게 object_id 값을 설정할까? 또한 Fixnum 범위 내에서 정수(Integer)의 object_id 값은 어떻게 설정할까?

이렇게 객체 인스턴스뿐만 아니라 고정 오브젝트 타입의 obejct_id 값들을 설정하기 위해 bit pattern을 사용했다. (여러 참고 문서를 통한 추측일뿐 확실한 정보는 아님)

object_id는 "(Fixnum * 2) + 1"의 연산 결과값이 할당된다.

아래의 예제를 보면, Ruby에서 false는 값을 0으로 하드코딩한 것이 아니라 상단의 비트패턴 연산을 사용하여 값을 구한 것을 알 수 있다.

ex)

 
xxxxxxxxxx
puts false.object_id
=> 0
puts true.object_id
=> 2
puts nil.object_id
=> 4
​
puts 1.object_id
=> 3
puts 2.object_id
=> 5
puts 3.object_id
=> 7

그러면 (Fixnum * 2) + 1의 비트 연산 과정을 자세히 살펴보자.

먼저 Fixnum은 32bit를 사용한다고 했다. 여기서 흥미로운 점은 만약 Fixnum의 마지막 비트가 0인 경우에는 31bit만을 사용하고, Fixnum의 마지막 비트가 1인 경우 32bit 모두를 사용한다.

아래는 정수 4와 5의 비트연산 예제이다.

ex) object_id of 4

 
xxxxxxxxxx
# 4는 2진수로 100이다. 
# 마지막 비트가 0이므로 31비트만을 사용하고 앞에 28비트를 0으로 채운다.
0000000000000000000000000000100
​
# 그 다음, 좌측 시프팅을 통해 끝 비트에 1을 추가한다.
00000000000000000000000000001001
​
# 비트 연산의 결과는 9로 정수 4의 object_id는 9인 것을 알 수 있다.

ex) object_id of 5

 
xxxxxxxxxx
# 5는 2진수로 101이다. 
# 마지막 비트가 1이므로 32비트 모두를 사용한다.
00000000000000000000000000000101
​
# 그 다음, 좌측 시프팅을 통해 끝 비트에 1을 추가한다. 오버비트는 생략한다.
00000000000000000000000000001011
​
# 비트 연산의 결과는 11로 정수 5의 object_id는 11인 것을 알 수 있다.

이러한 계산 방식에는 2 가지의 부작용이 있다.

첫 번째로 위의 Fixnum 연산은 마지막에 1을 추가하므로 모든 Fixnum object_id는 홀수이다. 이를 통해 시스템에 다른 모든 객체의 object_id는 짝수라는 것을 알 수 있다.

두 번째로 홀수 Fixnum만이 Fixnum object_id로 사용된다. Fixnum 절반이 Fixnum object_id로 채워져 있고 나머지 절반에 다른 object_id를 채워넣어야 하는데, 다른 모든 obejct_id가 너무 커서 31비트에 들어가지 않는다는 것이다. 만약 시스템이 짝수 Fixnum 공간에 충분한 객체들을 인스턴스화 하는데에 써버린다면, 일반 객체의 object_id는 Bignum을 얻게 된다.

clone object

 
xxxxxxxxxx
def test_clone_creates_a_different_object
  obj = Object.new
  copy = obj.clone
​
  assert_equal true, obj           != copy
  assert_equal true, obj.object_id != copy.object_id
end

obj.clone을 사용하면 인스턴스 객체의 복사본을 생성할 수 있다.

일반적으로 객체는 주소값을 참조하기 때문에 코드 범위내에서 값을 공유한다. 객체의 값을 수정하면 같은 변수명을 가진 객체의 값 또한 변경된다.

하지만 객체의 복사본을 생성하면 서로 다른 주소값(object_id)을 할당 받기 때문에 값이 공유될 수 없으며 서로 다른 객체로 인식한다.

=> 그러므로 위의 예제의 비교문들은 true를 반환한다.

참고 자료

• Diffrence between to_s and inspect in Ruby - https://rubyinrails.com/2014/11/01/difference-between-to_s-and-inspect-in-ruby/
• What is nil in Ruby? - https://www.reddit.com/r/learnprogramming/comments/1lxam0/what_is_nil_in_ruby/
• What is the meaning of i.to_s in Ruby? - https://stackoverflow.com/questions/8209194/what-is-the-meaning-of-i-to-s-in-ruby
• Object IDs and Fixnums - http://www.sarahmei.com/blog/2009/04/21/object-ids-and-fixnums/