스칼라의 VAR와 val 정의의 차이점은 무엇입니까?

언어가 모두 필요 않는 이유를 무엇 스칼라의 VAR와 val 정의의 차이이고? 왜 당신은 VAR 그 반대를 통해 발을 선택할 것인가?

해결법

==============================
1.그래서 많은 사람들이 말한 것처럼, 발에 할당 된 객체를 교체하고, VAR 캔에 할당 된 오브젝트 수 없습니다. 그러나, 객체가 내부 상태가 수정 한 수 있다고 말했다. 예를 들면 :

그래서 많은 사람들이 말한 것처럼, 발에 할당 된 객체를 교체하고, VAR 캔에 할당 된 오브젝트 수 없습니다. 그러나, 객체가 내부 상태가 수정 한 수 있다고 말했다. 예를 들면 :
```
class A(n: Int) {
  var value = n
}

class B(n: Int) {
  val value = new A(n)
}

object Test {
  def main(args: Array[String]) {
    val x = new B(5)
    x = new B(6) // Doesn't work, because I can't replace the object created on the line above with this new one.
    x.value = new A(6) // Doesn't work, because I can't replace the object assigned to B.value for a new one.
    x.value.value = 6 // Works, because A.value can receive a new object.
  }
}
```
그래서, 우리는 X에 할당 된 객체를 변경할 수 있지만, 우리는 그 개체의 상태를 변경할 수 있습니다. 그것의 루트에서, 그러나, VAR이 있었다.

이제, 불변성은 여러 가지 이유로 좋은 일이다. 객체가 내부 상태를 변경하지 않는 경우 첫째, 당신은 당신의 코드의 다른 부분을 변경하는 경우 걱정할 필요가 없습니다. 예를 들면 :
```
x = new B(0)
f(x)
if (x.value.value == 0)
  println("f didn't do anything to x")
else
  println("f did something to x")
```
이는 멀티 스레드 시스템에 특히 중요합니다. 다중 스레드 시스템에서, 다음과 같은 상황이 발생할 수 있습니다 :
```
x = new B(1)
f(x)
if (x.value.value == 1) {
  print(x.value.value) // Can be different than 1!
}
```
당신이 독점적으로 발을 사용하고 불변적인 데이터 구조를 사용하는 경우, 당신은이 일어나지 않을 것입니다 안심하실 수 있습니다 (즉, 등 배열, scala.collection.mutable에 모든 것을 피하기). 반사 트릭을하고, 심지어, 프레임 워크 일부 코드가 아니라면 즉, - 반사 불행하게도, "불변"값을 변경할 수 있습니다.

즉, 하나의 이유이지만 또 다른 이유가있다. 당신이 VAR를 사용하면 여러 목적을 위해 같은 VAR를 재사용으로 유혹 할 수있다. 이것은 몇 가지 문제가 있습니다 :

간단히 발은 더 안전하고 더 읽을 수있는 코드로 연결 사용했습니다.

우리는, 다음, 다른 방향으로 갈 수 있습니다. 발은 것이 더 나은 경우, 왜 모든 VAR이? 음, 일부 언어는 그 길을했지만 가변성은 성능이 많이 향상되는 경우가 있습니다.

예를 들어, 불변 큐 걸릴. 거기에 인큐 또는 디큐 때 두 가지 새 대기열 객체를 얻는다. 당신은 모든 항목의 처리에 대해 어떻게 다음을 갈 것?

내가 예와 그 통해 갈 수 있습니다. 의 당신이 숫자의 큐를 가지고 있고, 당신이 그들 중 다수를 구성하기를 원하는 경우를 생각 해보자. 예를 들어, 2, 1, 3, 순서대로, 내가 수 (213)하자 처음으로 다시 얻을 mutable.Queue으로 해결하려는로 내가 대기열이있는 경우 :
```
def toNum(q: scala.collection.mutable.Queue[Int]) = {
  var num = 0
  while (!q.isEmpty) {
    num *= 10
    num += q.dequeue
  }
  num
}
```
이 코드는 빠르고 이해하기 쉽다. 주요 단점은 전달 된 큐가 toNum에 의해 수정된다는 것이다, 그래서 당신은 미리의 사본을해야한다. 즉 불변부터 무료 만드는 객체 관리의 종류.

이제,이 immutable.Queue로 변환하자 :
```
def toNum(q: scala.collection.immutable.Queue[Int]) = {
  def recurse(qr: scala.collection.immutable.Queue[Int], num: Int): Int = {
    if (qr.isEmpty)
      num
    else {
      val (digit, newQ) = qr.dequeue
      recurse(newQ, num * 10 + digit)
    }
  }
  recurse(q, 0)
}
```
나는 앞의 예처럼, 내 NUM을 추적하기 위해 몇 가지 변수를 재사용 할 수 없기 때문에, 나는 재귀에 의지 할 필요가있다. 이 경우, 꽤 좋은 성능을 가지고 꼬리 재귀입니다. 하지만 그 사건은 항상되지 않습니다 : 때로는 좋은 (읽기, 간단한) 꼬리 재귀 솔루션이 없습니다.

나도 같은 시간에 immutable.Queue과 VAR를 사용하는 코드를 다시 작성할 수 있다는 점에 유의하십시오! 예를 들면 :
```
def toNum(q: scala.collection.immutable.Queue[Int]) = {
  var qr = q
  var num = 0
  while (!qr.isEmpty) {
    val (digit, newQ) = qr.dequeue
    num *= 10
    num += digit
    qr = newQ
  }
  num
}
```
이 코드는 재귀를 필요로하지 않는, 여전히 효율적이고, 당신이 toNum를 호출하기 전에 당신의 큐의 복사 여부를 확인해야합니다 여부를 걱정할 필요가 없습니다. 당연히, 나는 다른 목적으로 재사용 변수를 피해야하고,이 기능 밖에있는 코드를 볼 수 없습니다, 그래서 한 줄에서 다음에 변화 그 값에 대해 걱정할 필요가 없습니다 - 내가 명시 적으로 수행 할 때를 제외하고.

스칼라는 프로그래머가 프로그래머가있는 것으로 간주 경우가 최고의 솔루션으로, 그렇게 할 수 있도록 선택했다. 다른 언어는 같은 코드를 어렵게하기 위해 선택했습니다. 가격 스칼라 (그리고 광범위한 가변성과 모든 언어) 지불 컴파일러가 코드가 다른 수 등을 최적화에 많은 여유가없는 것입니다. 이 자바의 대답은 실행시 프로필을 기반으로 코드를 최적화한다. 우리는 각 측면에 장점과 단점에 대해 계속적으로 갈 수 있었다.

개인적으로, 나는 스칼라 지금은 오른쪽 균형을 생각합니다. 그것은 지금까지, 완벽하지 않습니다. 나는 Clojure의와 하스켈 모두 스칼라에 의해 채택되지 매우 흥미로운 개념을 가지고 있다고 생각하지만, 스칼라뿐만 아니라 자신의 강점을 가지고있다. 우리는 미래에 등장 것을 볼 수 있습니다.
==============================
2.발은 즉, 설정할 수 없습니다, 마지막이다. 자바 최종 생각해보십시오.

발은 즉, 설정할 수 없습니다, 마지막이다. 자바 최종 생각해보십시오.
==============================
3.간단한 용어로 :

간단한 용어로 :

했다 = 변수

브로 = + 최종 변수
==============================
4.차이점은 VAR은 발은 할 수있는 반면에 재 할당 될 수 있다는 것이다. 또는 그렇지 않으면 실제로 할당 된 어떤의 가변성은 측면의 문제입니다 :

차이점은 VAR은 발은 할 수있는 반면에 재 할당 될 수 있다는 것이다. 또는 그렇지 않으면 실제로 할당 된 어떤의 가변성은 측면의 문제입니다 :
```
import collection.immutable
import collection.mutable
var m = immutable.Set("London", "Paris")
m = immutable.Set("New York") //Reassignment - I have change the "value" at m.
```
그런데, ...한데:
```
val n = immutable.Set("London", "Paris")
n = immutable.Set("New York") //Will not compile as n is a val.
```
따라서 :
```
val n = mutable.Set("London", "Paris")
n = mutable.Set("New York") //Will not compile, even though the type of n is mutable.
```
당신은 데이터 구조를 구축하고 모든 필드가 발스 경우 상태가 변경되지 수, 그 데이터 구조, 따라서 변경할 수 없습니다.
==============================
5.발 불변 수단 VAR은 가변 수단.

발 불변 수단 VAR은 가변 수단.

전체 토론.
==============================
6.C ++의 관점에서 생각,

C ++의 관점에서 생각,
```
val x: T
```
일정하지 않은 데이터에 일정한 포인터 유사
```
T* const x;
```
동안
```
var x: T 
```
일정하지 않은 데이터에 일정하지 않은 포인터 유사
```
T* x;
```
VAR 이상 발을 호의 자사의 정확성, 동시성 및 이해 가능성을 촉진 할 수있는 코드베이스의 불변성을 증가시킨다.

다음 스칼라 조각을 고려해 일정하지 않은 데이터에 대한 상수 포인터를 갖는 의미를 이해하려면 :
```
val m = scala.collection.mutable.Map(1 -> "picard")
m // res0: scala.collection.mutable.Map[Int,String] = HashMap(1 -> picard)
```
여기에 "포인터"발 분은 지금과 같은 다른 뭔가를 가리 키도록 그래서 우리는 그것을 다시 할당 할 수 없습니다 일정
```
m = n // error: reassignment to val
```
그러나 우리는 참 m 지점과 같이 할 수있는 상수가 아닌 데이터 자체를 변경할 수 있습니다
```
m.put(2, "worf")
m // res1: scala.collection.mutable.Map[Int,String] = HashMap(1 -> picard, 2 -> worf)
```
==============================
7."발은 불변의 의미와 VAR는 변경할 것을 의미합니다."

"발은 불변의 의미와 VAR는 변경할 것을 의미합니다."

의역하려면 "발은 가치와 VAR 변수 수단".

어떻게 구별 컴퓨팅에서 매우 중요합니다 (이 두 개념은 프로그래밍에 관한 모든 일의 본질을 정의하기 때문에)와 OO은 OO에 유일한 공리는 모든이입니다 "라는 때문에, 거의 완전히 흐리게하는 데 성공했다고 목적". 그리고 그 결과로, 프로그래머의 많은 요즘 / 이해하지 않는 경향이 있음을 그들이 독점적으로 "객체 지향 방법을 생각"에 세뇌 되었기 때문에, 인식 / 주셔서 감사합니다. 종종 변수에 선도적 인 / 변경 가능한 객체가 사방처럼 사용하고, 가치 / 불변의 객체가 / 자주 더 좋았을 것입니다 수있는 경우.
==============================
8.당신은 자바 프로그래밍 언어 최종 키 세계 또는 C ++ 언어 CONST 키 세계로 발을 생각할 수 있습니다.

당신은 자바 프로그래밍 언어 최종 키 세계 또는 C ++ 언어 CONST 키 세계로 발을 생각할 수 있습니다.
==============================
9.그것은 이름처럼 간단합니다.

그것은 이름처럼 간단합니다.
==============================
10.발은 - 값은 저장 상수를 입력합니다. 일단 그 값을 다시 할당 할 수 어차피 만들었습니다. 새 값은 키워드 발 정의 할 수 있습니다.

발은 - 값은 저장 상수를 입력합니다. 일단 그 값을 다시 할당 할 수 어차피 만들었습니다. 새 값은 키워드 발 정의 할 수 있습니다.

예를 들면. 발의 X : = 5 지능

여기 유형은 스칼라가 할당 된 값에서 추론 수있는 선택 사항입니다.

VAR - 변수만큼의 메모리 공간이 확보 될 때 다시 값을 할당 할 수있는 저장 유닛을 입력한다.

예를 들면. var에 X : 지능 = 5

이 더 이상 필요 일단 저장 장치 모두에 저장된 데이터는 자동으로 JVM에 의해 할당 해제되지 않습니다.

스칼라 값이 안정 변수 때문에 선호되는 이러한 특히 동시 멀티 스레드 코드의 코드를 가져온다.
==============================
11.많은하지만 이미 발과 VAR 사이의 차이를 대답했다. 그러나 주목해야 할 한 점은 발 정확히 최종 키워드처럼되지 않는 것입니다.

많은하지만 이미 발과 VAR 사이의 차이를 대답했다. 그러나 주목해야 할 한 점은 발 정확히 최종 키워드처럼되지 않는 것입니다.

우리는 재귀를 사용하여 발의 값을 변경할 수 있지만, 우리는 최종의 값을 변경할 수 없다. 마지막은 발보다 더 많은 상수이다.
```
def factorial(num: Int): Int = {
 if(num == 0) 1
 else factorial(num - 1) * num
}
```
메소드 파라미터는 기본 발에 의해하고 모든 호출 값으로 변경되고있다.
==============================
12.발은 최종 의미, 다시 할당 할 수 없습니다

발은 최종 의미, 다시 할당 할 수 없습니다

반면, 바르 나중에 재 할당 할 수 있습니다.

from https://stackoverflow.com/questions/1791408/what-is-the-difference-between-a-var-and-val-definition-in-scala by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] 어떻게하게 IntelliJ IDEA와 함께 SBT를 사용하여 동네 짱의 JAR (지방 JAR)을 구축? (0)	2019.10.30
[SCALA] 은`#`연산자는 스칼라에서 무엇을 의미합니까? (0)	2019.10.30
[SCALA] 중첩 된 구조를 업데이트 할 클리너 방법 (0)	2019.10.29
[SCALA] (왜) 우리는 캐시를 호출하거나 RDD에 유지해야합니까 (0)	2019.10.29
[SCALA] 스칼라의 숨겨진 기능 (0)	2019.10.29

복붙노트

[SCALA] 스칼라의 VAR와 val 정의의 차이점은 무엇입니까?

스칼라의 VAR와 val 정의의 차이점은 무엇입니까?

해결법

1.그래서 많은 사람들이 말한 것처럼, 발에 할당 된 객체를 교체하고, VAR 캔에 할당 된 오브젝트 수 없습니다. 그러나, 객체가 내부 상태가 수정 한 수 있다고 말했다. 예를 들면 :

2.발은 즉, 설정할 수 없습니다, 마지막이다. 자바 최종 생각해보십시오.

3.간단한 용어로 :

4.차이점은 VAR은 발은 할 수있는 반면에 재 할당 될 수 있다는 것이다. 또는 그렇지 않으면 실제로 할당 된 어떤의 가변성은 측면의 문제입니다 :

5.발 불변 수단 VAR은 가변 수단.

6.C ++의 관점에서 생각,

7."발은 불변의 의미와 VAR는 변경할 것을 의미합니다."

8.당신은 자바 프로그래밍 언어 최종 키 세계 또는 C ++ 언어 CONST 키 세계로 발을 생각할 수 있습니다.

9.그것은 이름처럼 간단합니다.

10.발은 - 값은 저장 상수를 입력합니다. 일단 그 값을 다시 할당 할 수 어차피 만들었습니다. 새 값은 키워드 발 정의 할 수 있습니다.

11.많은하지만 이미 발과 VAR 사이의 차이를 대답했다. 그러나 주목해야 할 한 점은 발 정확히 최종 키워드처럼되지 않는 것입니다.

12.발은 최종 의미, 다시 할당 할 수 없습니다

'SCALA' 카테고리의 다른 글

티스토리툴바