Go 's Declaration Syntax (Go 의 성명 문법)

Rob Pike 가 작성 한 Go 's Declaration Syntax (Go 의 성명 문법)
소개 하 다.
Go 의 신인 들 은 왜 성명 문법 이 C 시리즈 에서 만들어 진 전통 과 다른 지 알 고 싶 어 합 니 다.이 글 에서 우 리 는 두 가지 방법 을 비교 하고 왜 Go 의 성명 이 비슷 해 보 이 는 지 설명 할 것 이다.
C 문법
우선 C 문법 을 말 해 보 세 요.C. 예 사 롭 지 않 고 똑똑 한 방법 으로 생명 문법 을 사용 했다.특수 한 문법 으로 형식 을 설명 하 는 것 이 아니 라 성명 과 관련 된 표현 식 을 작성 하고 이 표현 식 이 가 질 유형 을 설명 합 니 다. 예 를 들 어

  int x;

x 를 int 로 설명 합 니 다: 표현 식 'x' 는 int 형식 을 가 집 니 다.일반적으로 새로운 변 수 를 만 드 는 방법 을 알 고 싶 습 니 다. 변수 와 관련 된 표현 식 을 만 드 십시오. 이 변 수 는 계산 결 과 를 기본 형식 으로 한 다음 기본 형식 을 왼쪽 에 두 고 표현 식 을 오른쪽 에 두 십시오.다음 성명

  int *p;
  int a[3];

성명 p 는 int 를 가리 키 는 지침 입 니 다. '* p' 의 유형 은 int 이 고 a [3] 는 int 형식의 배열 입 니 다. 유형 int (특정한 색인 값 을 무시 하고 배열 의 크기 로 여 겨 집 니 다) 가 있 기 때 문 입 니 다.함 수 는 어떤 모양 일 까요?처음에 C 의 함수 성명 재 괄호 외 에 매개 변수 형식 을 작 성 했 습 니 다. 다음 과 같 습 니 다.

  int main(argc, argv)
    int argc;
    char *argv[];
  { /* ... */ }

마찬가지 로 main 은 함수 입 니 다. 표현 식 main (argc, argv) 이 int 형식의 값 을 되 돌려 주기 때문에 현재 기호 에서 작성 합 니 다.

  int main(int argc, char *argv[]) { /* ... */ }

그러나 기본 적 인 구 조 는 일치한다.이것 은 똑똑 한 구법 개념 으로 간단 한 유형 에 적용 되 지만 곧 헷 갈 렸 다.하나의 유명한 예 는 함수 지침 을 설명 하 는 것 이다.규칙 에 따라 당신 은 다음 과 같은 것 을 볼 수 있 습 니 다.

  int (*fp)(int a, int b);

여기 서 fp 는 함 수 를 가리 키 는 지침 입 니 다. 표현 식 (* fp) (a, b) 을 작성 하면 int 로 돌아 가 는 함 수 를 호출 할 것 입 니 다.만약 fp 의 매개 변수 자체 가 함수 라면 어떻게 합 니까?

  int (*fp)(int (*ff)(int x, int y), int b)

이해 하기 어렵다.물론, 우 리 는 함 수 를 설명 할 때 인자 의 이름 을 생략 할 수 있 기 때문에 main 을 다음 과 같이 설명 할 수 있 습 니 다.

  int main(int, char *[])

돌 이 켜 보면 argv 는 이렇게 성명 했다.

  char *argv[]

그래서 성명 에서 이름 을 삭제 해서 형식 을 만 듭 니 다.그러나 그 이름 을 중간 에 놓 아 char * [] 유형의 것 을 설명 하 는 것 은 뚜렷 하지 않다.이름 을 가 진 인자 가 없다 면 fp 의 성명 이 어떻게 되 는 지 보 세 요.

  int (*fp)(int (*)(int, int), int)

이름 을 어디 에 두 었 는 지 는 분명 하지 않 을 뿐만 아니 라

  int (*)(int, int)

함수 포인터 성명 인지 전혀 모 르 겠 습 니 다.반환 형식 이 함수 포인터 라면 어떻게 합 니까?

  int (*(*fp)(int (*)(int, int), int))(int, int)

심지어 이 성명 이 fp 에 관 한 것 이라는 것 을 보기 어렵다.더 자세 한 예 시 를 구성 할 수 있 지만, 이 예 들 은 C 의 성명 문법 이 가 져 올 수 있 는 어려움 을 설명 할 것 입 니 다.하지만 아직 해 야 할 일이 있 습 니 다.형식 과 성명 문법 이 같 기 때문에 중간 형식의 표현 식 을 해석 하기 어렵다.이것 이 바로 C 강제 변환 이 항상 유형 을 묶 는 이유 입 니 다. 예 를 들 어:

  (int)M_PI

Go 문법
C 시리즈 이외 의 언어 는 일반적으로 성명 에서 서로 다른 유형의 문법 을 사용한다.비록 그것 은 하나의 단독 점 이지 만, 통상 적 으로 먼저 명칭 이 나타 나 는데, 통상 적 으로 뒤에 사칭 을 따른다.그래서 우리 위의 예 는 비슷 해 졌 다.

  x: int
  p: pointer to int
  a: array[3] of int

이 성명 들 은 매우 명확 하 다. 만약 상세 하 다 면 - 너 는 그것들 을 왼쪽 에서 오른쪽으로 읽 기만 하면 된다.Go 는 여기 서부 터 알림 을 시작 하지만 간결 하 게 보기 위해 서 는 콜론 을 삭제 하고 키 워드 를 삭제 합 니 다.

  x int
  p *int
  a [3]int

[3] int 표면 은 표현 식 에서 a 를 어떻게 사용 하 는 지 와 직접적인 대응 관계 가 없습니다.(우 리 는 다음 절 에 지적 으로 돌아 갈 것 입 니 다.) 당신 은 단독 문법 비용 을 잘 알 수 있 습 니 다.지금 함 수 를 고려 하 다.Go 에서 main 의 설명 을 읽 습 니 다. Go 의 진정한 주요 함수 에 인자 가 없 음 에 도 불구 하고:

  func main(argc int, argv []string) int

겉 으로 는 C 와 다 르 지 않 습 니 다. char 배열 에서 문자열 로 변화 하 는 것 을 제외 하고 왼쪽 에서 오른쪽으로 잘 읽 습 니 다. function main 은 int 와 문자열 을 받 아들 여 int 를 되 돌려 줍 니 다.매개 변수 이름 을 삭제 하 는 것 도 잘 알 고 있 습 니 다. - 항상 첫 번 째 이기 때문에 헷 갈 리 지 않 습 니 다.

  func main(int, []string) int

왼쪽 에서 오른쪽으로 이어지는 이런 스타일 의 장점 중 하 나 는 작업 효과 가 유형 에 따라 더욱 복잡 해진 다 는 것 이다.이것 은 함수 변수의 성명 입 니 다. (C 의 함수 포인터 와 유사 합 니 다.)

  f func(func(int,int) int, int) int

혹은 f 가 함 수 를 되 돌려 준다 면

  f func(func(int,int) int, int) func(int, int) int

그것 은 여전히 왼쪽 에서 오른쪽으로 분명하게 읽 고 있 으 며, 어떤 이름 - 이름 이 먼저 나 타 났 는 지 분명 하 다.형식 과 표현 식 문법 간 의 차이 로 인해 Go 에서 패 키 지 를 작성 하고 호출 하 는 것 이 쉬 워 집 니 다.

  sum := func(a, b int) int { return a+b } (3, 4)

포인터
지침 은 규칙 을 증명 하 는 예외 이다.예 를 들 어 배열 과 절편 에서 Go 의 유형 문법 은 괄호 를 형식의 왼쪽 에 놓 지만 표현 식 문법 은 표현 식 오른쪽 에 놓 습 니 다.

  var a []int
  x = a[1]

잘 알 기 위해 Go 의 지침 은 C 에서 온 * 표현법 을 사용 하지만 우 리 는 지침 유형 에 대해 비슷 한 반전 을 할 수 없습니다.그래서 지침 은 이렇게 일한다.

  var p *int
  x = *p

우 리 는 이렇게 표현 할 수 없다.

  var p *int
  x = p*

접미사 * 는 곱셈 과 헷 갈 리 기 때문이다.우 리 는 Pascal ^ 를 사용 할 수 있 습 니 다. 예 를 들 어:

  var p ^int
  x = p^

아마도 우 리 는 형식 과 표현 식 의 접두사 별표 가 여러 가지 방식 으로 일 을 복잡 하 게 하기 때문에 (그리고 xor 를 위해 다른 연산 자 를 선택해 야 할 것 이다.)쓸 수 있 지만

  []int("hi")

변환 으로 * 로 시작 하면 이 유형 을 묶 어야 합 니 다.

  (*int)(nil)

만약 우리 가 * 를 지침 문법 으로 포기 하고 싶다 면, 이 괄호 들 은 불필요 할 것 이다.따라서 Go 의 포인터 문법 은 익숙 한 C 형식 과 관련 이 있 지만 이러한 관 계 는 우리 가 괄호 를 사용 하여 문법 중의 유형 과 표현 식 의 나 쁜 의 미 를 완전히 벗 어 날 수 없다 는 것 을 의미한다.전체적으로 말 하면 우 리 는 Go 의 유형 문법 이 C 언어 보다 이해 하기 쉽다 고 믿는다. 특히 일이 복잡 해 질 때.
마지막.
Go 의 성명 은 왼쪽 에서 오른쪽으로 읽 습 니 다.C 는 나선형 읽 기 라 는 지적 이 있 습 니 다!David Anderson 의 "The" Clock wise / Spiral Rule (시계 방향 / 나선형 규칙) "참조