Dart는 클래스와 믹스 인 기반 상속이있는 _객체 지향 언어_입니다. 모든 객체는 클래스의 인스턴스이며 모든 클래스는 _Object_의 자손입니다. Mixin 기반 상속은 모든 클래스 (Object 제외)에 정확히 하나의 수퍼 클래스가 있지만 클래스 본문은 여러 클래스 계층에서 재사용 될 수 있음을 의미합니다. 확장 메서드는 클래스를 변경하거나 하위 클래스를 만들지 않고 클래스에 기능을 추가하는 방법입니다.

클래스 멤버 사용

개체에는 함수와 데이터 (각각 메서드 및 인스턴스 변수)로 구성된 멤버가 있습니다. 메소드를 호출하면 객체에서 호출합니다. 메소드는 해당 객체의 함수와 데이터에 액세스 할 수 있습니다.

인스턴스 변수 또는 메서드를 참조하려면 점(.)을 사용합니다.

var p = Point(2, 2);

// Set the value of the instance variable y.
p.y = 3;

// Get the value of y.
assert(p.y == 3);

// Invoke distanceTo() on p.
double distance = p.distanceTo(Point(4, 4));

왼쪽 피연산자가 null 일 때 예외를 방지하려면 . 대신에 ?. 를 사용하세요.

p?.y = 4;

생성자 사용

생성자를 사용하여 개체를 만들 수 있습니다. 생성자 이름은 ClassName 또는 ClassName.identifier 일 수 있습니다. 예를 들어 다음 코드는 Point() 및 Point.fromJson() 생성자를 사용하여 Point 객체를 만듭니다.

var p1 = Point(2, 2);
var p2 = Point.fromJson({'x': 1, 'y': 2});

아래 코드는 동일한 효과가 있지만 생성자 이름 앞에 선택적 new 키워드를 사용합니다.

var p1 = new Point(2, 2);
var p2 = new Point.fromJson({'x': 1, 'y': 2});

new 키워드는 Dart2 에서 선택 사항이 되었습니다.

일부 클래스는 _상수 생성자_를 제공합니다. _상수 생성자_를 사용하여 _컴파일 타임 상수_를 만들려면 생성자 이름 앞에 const 키워드를 넣으십시오.

var p = const ImmutablePoint(2, 2);

두 개의 동일한 컴파일 타임 상수를 생성하면 단일 표준 인스턴스가 생성됩니다.

var a = const ImmutablePoint(1, 1);
var b = const ImmutablePoint(1, 1);

assert(identical(a, b)); // 두 객체는 같습니다.

상수 컨텍스트 내에서 생성자 또는 리터럴 앞에 const를 생략 할 수 있습니다. 예를 들어, Map 상수를 만드는 다음 코드를 살펴보십시오.

// const 키워드를 아주 많이 사용합니다.
const pointAndLine = const {
  'point': const [const ImmutablePoint(0, 0)],
  'line': const [const ImmutablePoint(1, 10), const ImmutablePoint(-2, 11)],
};

const 키워드의 첫 번째 사용을 제외하고 모두 생략 할 수 있습니다.

// const 키워드를 단 한번만 사용하여도 위 코드와 같습니다.
const pointAndLine = {
  'point': [ImmutablePoint(0, 0)],
  'line': [ImmutablePoint(1, 10), ImmutablePoint(-2, 11)],
};

상수 생성자가 상수 컨텍스트 외부에 있고 const없이 호출되면 상수가 아닌 객체를 만듭니다.

var a = const ImmutablePoint(1, 1); // 상수 생성
var b = ImmutablePoint(1, 1); // 비 상수 생성

assert(!identical(a, b)); // 같지 않습니다.

const 키워드는 Dart2의 상수 컨텍스트 내에서 선택 사항이되었습니다.

객체 유형 가져오기

런타임에 객체의 유형을 가져 오려면 Type 객체를 반환하는 _Object_의 runtimeType 속성을 사용할 수 있습니다.

print('The type of a is ${a.runtimeType}');

여기까지 클래스 사용 방법을 살펴 보았습니다. 이 섹션의 나머지 부분에서는 클래스를 구현하는 방법을 보여줍니다.

인스턴스 변수

인스턴스 변수를 선언하는 방법은 다음과 같습니다.

class Point {
  double x; // Declare instance variable x, initially null.
  double y; // Declare y, initially null.
  double z = 0; // Declare z, initially 0.
}

초기화되지 않은 모든 인스턴스 변수의 값은 null입니다.

모든 인스턴스 변수는 암시 적 getter 메서드를 생성합니다. 최종 인스턴스 변수가 아닌 경우에도 암시 적 setter 메서드가 생성됩니다. 자세한 내용은 Getters 및 Setters를 참조하십시오.

class Point {
  double x;
  double y;
}

void main() {
  var point = Point();
  point.x = 4; // Use the setter method for x.
  assert(point.x == 4); // Use the getter method for x.
  assert(point.y == null); // Values default to null.
}

(생성자나 메서드 대신) 선언 된 인스턴스 변수를 초기화하면 인스턴스가 생성될 때 값이 설정되며, 생성자 및 초기화 목록이 실행되기 전입니다.

생성자

클래스와 이름이 같은 함수를 생성하여 생성자를 선언합니다 (명시 된 생성자에 설명 된 추가 식별자도 추가 할 수 있음). 생성자의 가장 일반적인 형태인 _일반 생성자_는 클래스의 새 인스턴스를 만듭니다.

class Point {
  double x, y;

  Point(double x, double y) {
    // There's a better way to do this, stay tuned.
    this.x = x;
    this.y = y;
  }
}

this 키워드는 현재 인스턴스를 참조합니다.

this는 이름 충돌이있는 경우에만 사용하십시오. 그렇지 않으면 Dart 스타일은 this를 생략합니다.

생성자 인수를 인스턴스 변수에 할당하는 패턴은 매우 일반적이므로 Dart에는 이를 쉽게 하기위한 _문법적 설탕_이 있습니다.

class Point {
  double x, y;

  // Syntactic sugar for setting x and y
  // before the constructor body runs.
  Point(this.x, this.y);
}

기본 생성자

생성자를 선언하지 않으면 기본 생성자가 제공됩니다. 기본 생성자에는 인수가 없으며 수퍼 클래스에서 인수가없는 생성자를 호출합니다.

상속되지 않는 생성자

하위 클래스는 수퍼 클래스에서 생성자를 상속하지 않습니다. 생성자를 선언하지 않는 하위 클래스에는 기본 (인수, 이름 없음) 생성자 만 있습니다.

명시된 생성자

명시된 생성자를 사용하여 클래스에 대해 여러 생성자를 구현하거나 추가 명확성을 제공합니다.

class Point {
  double x, y;

  Point(this.x, this.y);

  // Named constructor
  Point.origin() {
    x = 0;
    y = 0;
  }
}

생성자는 상속되지 않습니다. 즉, 수퍼 클래스의 명시된 생성자가 하위 클래스에서 상속되지 않습니다. 슈퍼 클래스에 정의된 명시된 생성자로 서브 클래스를 생성하려면 해당 생성자를 서브 클래스에서 구현해야합니다.

기본이 아닌 슈퍼 클래스 생성자 호출

기본적으로 하위 클래스의 생성자는 수퍼 클래스의 명시되지 않은 인수없는 생성자를 호출합니다. 슈퍼 클래스의 생성자는 생성자 본문의 시작 부분에서 호출됩니다. 이니셜라이저 목록도 사용중인 경우 수퍼 클래스가 호출되기 전에 실행됩니다. 요약하면 실행 순서는 다음과 같습니다.

1. 이니셜 라이저 목록
2. 슈퍼 클래스의 인수없는 생성자
3. 메인 클래스의 인수없는 생성자

수퍼 클래스에 이름이 지정되지 않은 인수없는 생성자가 없으면 수퍼 클래스의 생성자 중 하나를 수동으로 호출해야합니다. 생성자 본문 (있는 경우) 바로 앞에 콜론 (:) 뒤에 수퍼 클래스 생성자를 지정합니다.

다음 예제에서 Employee 클래스의 생성자는 수퍼 클래스 _Person_에 대해 명명 된 생성자를 호출합니다. 실행을 클릭하여 코드를 실행합니다.

코드

class Person {
  String firstName;

  Person.fromJson(Map data) {
    print('in Person');
  }
}

class Employee extends Person {
  // Person does not have a default constructor;
  // you must call super.fromJson(data).
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

main() {
  var emp = new Employee.fromJson({});

  // Prints:
  // in Person
  // in Employee
  if (emp is Person) {
    // Type check
    emp.firstName = 'Bob';
  }
  (emp as Person).firstName = 'Bob';
}

결과

in Person
in Employee

슈퍼 클래스 생성자에 대한 인수는 생성자를 호출하기 전에 평가되기 때문에 인수는 함수 호출과 같은 표현식이 될 수 있습니다.

class Employee extends Person {
  Employee() : super.fromJson(defaultData);
  // ···
}

슈퍼 클래스 생성자에 대한 인수는 this에 액세스 할 수 없습니다. 예를 들어, 인수는 인스턴스 메서드가 아닌 정적 메서드를 호출 할 수 있습니다.

이니셜라이저 목록

슈퍼 클래스 생성자를 호출하는 것 외에도 생성자 본문이 실행되기 전에 인스턴스 변수를 초기화 할 수도 있습니다. _이니셜라이저_는 쉼표로 구분하십시오.

// Initializer list sets instance variables before
// the constructor body runs.
Point.fromJson(Map<String, double> json)
    : x = json['x'],
      y = json['y'] {
  print('In Point.fromJson(): ($x, $y)');
}

이니셜라이저의 오른쪽에는 this에 대한 액세스 권한이 없습니다.

개발 중에 이니셜 라이저 목록에서 assert를 사용하여 입력의 유효성을 검사 할 수 있습니다.

Point.withAssert(this.x, this.y) : assert(x >= 0) {
  print('In Point.withAssert(): ($x, $y)');
}

이니셜라이저 목록은 최종 필드를 설정할 때 편리합니다. 다음 예제는 이니셜라이저 목록에서 세 개의 마지막 필드를 초기화합니다. 실행을 클릭하여 코드를 실행합니다.

코드

import 'dart:math';

class Point {
  final num x;
  final num y;
  final num distanceFromOrigin;

  Point(x, y)
      : x = x,
        y = y,
        distanceFromOrigin = sqrt(x * x + y * y);
}

main() {
  var p = new Point(2, 3);
  print(p.distanceFromOrigin);
}

결과

3.605551275463989

생성자 리디렉션

때때로 생성자의 유일한 목적은 동일한 클래스의 다른 생성자로 리디렉션하는 것입니다. 리디렉션 생성자의 본문이 비어 있으며 생성자 호출이 콜론 (:) 뒤에 표시됩니다.

class Point {
  double x, y;

  // The main constructor for this class.
  Point(this.x, this.y);

  // Delegates to the main constructor.
  Point.alongXAxis(double x) : this(x, 0);
}

상수 생성자

클래스가 변경되지 않는 객체를 생성하는 경우 이러한 객체를 컴파일 시간 상수로 만들 수 있습니다. 이렇게 하려면 상수 생성자를 정의하고 모든 인스턴스 변수가 최종 변수인지 확인해야 합니다.

class ImmutablePoint {
  static final ImmutablePoint origin =
      const ImmutablePoint(0, 0);

  final double x, y;

  const ImmutablePoint(this.x, this.y);
}

상수 생성자가 항상 상수를 만드는 것은 아닙니다. 자세한 내용은 생성자 사용 섹션을 참조하세요.

팩토리 생성자

항상 클래스의 새 인스턴스를 만들지는 않는 생성자를 구현할 때 factory 키워드를 사용합니다. 예를 들어 팩토리 생성자는 캐시에서 인스턴스를 반환하거나 하위 유형의 인스턴스를 반환 할 수 있습니다. 팩토리 생성자의 또 다른 사용 사례는 이니셜라이저 목록에서 처리 할 수없는 로직을 사용하여 최종 변수를 초기화하는 것입니다.

다음 예제에서 Logger 팩토리 생성자는 캐시에서 객체를 반환하고 Logger.fromJson 팩토리 생성자는 JSON 객체에서 최종 변수를 초기화합니다.

class Logger {
  final String name;
  bool mute = false;

  // _cache is library-private, thanks to
  // the _ in front of its name.
  static final Map<String, Logger> _cache =
      <String, Logger>{};

  factory Logger(String name) {
    return _cache.putIfAbsent(
        name, () => Logger._internal(name));
  }

  factory Logger.fromJson(Map<String, Object> json) {
    return Logger(json['name'].toString());
  }

  Logger._internal(this.name);

  void log(String msg) {
    if (!mute) print(msg);
  }
}

팩토리 생성자는 this에 액세스 할 수 없습니다.

다른 생성자와 마찬가지로 팩토리 생성자를 호출합니다.

var logger = Logger('UI');
logger.log('Button clicked');

var logMap = {'name': 'UI'};
var loggerJson = Logger.fromJson(logMap);

메서드

메서드는 개체에 동작을 제공하는 함수입니다.

인스턴스 메서드

객체의 인스턴스 메서드는 인스턴스 변수와 이에 액세스 할 수 있습니다. 다음 샘플의 distanceTo() 메서드는 인스턴스 메서드의 예시입니다.

import 'dart:math';

class Point {
  double x, y;

  Point(this.x, this.y);

  double distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
}

Getters 및 setters

Getter 및 Setter는 개체 속성에 대한 읽기 및 쓰기 액세스를 제공하는 특수 메서드입니다. 각 인스턴스 변수에는 암시 적 getter와 적절한 경우 setter 가 있습니다. get 및 set 키워드를 사용하여 getter 및 setter를 구현하여 추가 속성을 만들 수 있습니다.

class Rectangle {
  double left, top, width, height;

  Rectangle(this.left, this.top, this.width, this.height);

  // Define two calculated properties: right and bottom.
  double get right => left + width;
  set right(double value) => left = value - width;
  double get bottom => top + height;
  set bottom(double value) => top = value - height;
}

void main() {
  var rect = Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);
  rect.right = 12;
  assert(rect.left == -8);
}

getter 및 setter를 사용하면 인스턴스 변수로 시작하고 나중에 클라이언트 코드를 변경하지 않고 메서드로 래핑 할 수 있습니다.

증가(++)와 같은 연산자는 getter가 명시 적으로 정의되었는지 여부에 관계없이 예상 된 방식으로 작동합니다. 예기치 못한 부작용을 방지하기 위해 연산자는 getter를 정확히 한 번 호출하여 해당 값을 임시 변수에 저장합니다.

추상 메서드

인스턴스, getter 및 setter 메서드는 추상적 일 수 있으며 인터페이스를 정의하지만 구현은 다른 클래스에 맡깁니다. 추상 메서드는 _추상 클래스_에만 존재할 수 있습니다.

메서드를 추상적으로 만들려면 메서드 본문 대신 세미콜론 (;)을 사용합니다.

abstract class Doer {
  // Define instance variables and methods...

  void doSomething(); // Define an abstract method.
}

class EffectiveDoer extends Doer {
  void doSomething() {
    // Provide an implementation, so the method is not abstract here...
  }
}

추상 클래스

abstract 한정자를 사용하여 인스턴스화가 불가능한 추상 클래스를 정의합니다. 추상 클래스는 종종 일부 구현과 함께 인터페이스를 정의하는 데 유용합니다. 추상 클래스가 인스턴스화 가능한 것처럼 보이게하려면 _팩토리 생성자_를 정의하십시오.

추상 클래스에는 종종 _추상 메서드_가 있습니다. 다음은 _추상 메서드_가있는 추상 클래스를 선언하는 예시입니다.

// This class is declared abstract and thus
// can't be instantiated.
abstract class AbstractContainer {
  // Define constructors, fields, methods...

  void updateChildren(); // Abstract method.
}

암묵적 인터페이스

모든 클래스는 클래스의 모든 인스턴스 멤버와 구현하는 인터페이스를 포함하는 인터페이스를 암시 적으로 정의합니다. B의 구현을 상속하지 않고 클래스 B의 API를 지원하는 클래스 A를 만들려면 클래스 A가 B 인터페이스를 구현해야합니다.

클래스는 하나 이상의 인터페이스를 _구현_절에서 선언 한 다음 인터페이스에 필요한 API를 제공하여 구현합니다. 예시를 들면,

// A person. The implicit interface contains greet().
class Person {
  // In the interface, but visible only in this library.
  final _name;

  // Not in the interface, since this is a constructor.
  Person(this._name);

  // In the interface.
  String greet(String who) => 'Hello, $who. I am $_name.';
}

// An implementation of the Person interface.
class Impostor implements Person {
  get _name => '';

  String greet(String who) => 'Hi $who. Do you know who I am?';
}

String greetBob(Person person) => person.greet('Bob');

void main() {
  print(greetBob(Person('Kathy')));
  print(greetBob(Impostor()));
}

다음은 클래스가 여러 인터페이스를 구현하도록 지정하는 예시입니다.

class Point implements Comparable, Location {...}

클래스 확장

extends를 사용하여 하위 클래스를 만들고 super를 사용하여 수퍼 클래스를 참조합니다.

class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ···
}

class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
  // ···
}

멤버 재정의

하위 클래스는 인스턴스 메서드, getter 및 setter를 재정의 할 수 있습니다. @override 주석을 사용하여 의도적으로 멤버를 재정의하고 있음을 나타낼 수 있습니다

class SmartTelevision extends Television {
  @override
  void turnOn() {...}
  // ···
}

형식이 안전한 코드에서 메서드 매개 변수 또는 인스턴스 변수의 형식을 좁히려면 covariant 키워드를 사용할 수 있습니다.

재정의 가능한 연산자

다음 표에 표시된 연산자를 재정의 할 수 있습니다. 예를 들어 Vector 클래스를 정의하는 경우 + 메서드를 정의하여 두 개의 벡터를 추가 할 수 있습니다.

!= 가 재정의 할 수있는 연산자가 아니라는 것을 알 수 있습니다. e1! = e2 표현식은! (e1 == e2)에 대한 _문법적 설탕_입니다.

다음은 + 및 - 연산자를 재정의하는 클래스의 예시입니다.

class Vector {
  final int x, y;

  Vector(this.x, this.y);

  Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => Vector(x - v.x, y - v.y);

  // Operator == and hashCode not shown. For details, see note below.
  // ···
}

void main() {
  final v = Vector(2, 3);
  final w = Vector(2, 2);

  assert(v + w == Vector(4, 5));
  assert(v - w == Vector(0, 1));
}

==를 재정의하는 경우 _Object_의 hashCode getter도 재정의해야합니다. == 및 hashCode를 재정의하는 예시는 맵 키 구현을 참조하세요.

일반적으로 재정의에 대한 자세한 내용은 클래스 확장을 참조하십시오.

noSuchMethod()

코드가 존재하지 않는 메서드 나 인스턴스 변수를 사용하려고 할 때마다 감지하거나 반응하려면 noSuchMethod()를 재정의 할 수 있습니다.

class A {
  // Unless you override noSuchMethod, using a
  // non-existent member results in a NoSuchMethodError.
  @override
  void noSuchMethod(Invocation invocation) {
    print('You tried to use a non-existent member: ' +
        '${invocation.memberName}');
  }
}

다음 중 하나에 해당하지 않으면 구현되지 않은 메서드를 호출 할 수 없습니다.

• 수신자는 동적 정적 유형을 갖습니다.

• 수신기에는 구현되지 않은 메서드를 정의하는 정적 유형이 있고 (추상은 괜찮음) 수신기의 동적 유형에는 Object 클래스의 것과 다른 noSuchMethod() 구현이 있습니다.

자세한 내용은 비공식적 인 noSuchMethod 전달 사양을 참조하세요.

확장메서드

Dart 2.7에 도입 된 _확장 메서드_는 기존 라이브러리에 기능을 추가하는 방법입니다. 자신도 모르게 확장 메서드를 사용할 수 있습니다. 예를 들어 IDE에서 코드 완성을 사용하는 경우 일반 메서드와 함께 확장 메서드를 제안합니다.

다음은 string_apis.dart에 정의 된 parseInt()라는 문자열에 확장 메서드를 사용하는 예시입니다.

import 'string_apis.dart';
...
print('42'.padLeft(5)); // Use a String method.
print('42'.parseInt()); // Use an extension method.

확장 메서드 사용 및 구현에 대한 자세한 내용은 확장 메서드 페이지를 참조하세요.

열거 타입

종종 열거 타입 또는 _열거 형_이라고 하는 열거 타입은 고정 된 수의 상수 값을 나타내는 데 사용되는 특수한 종류의 클래스입니다.

열거 타입 사용

enum 키워드를 사용하여 열거 타입을 선언합니다.

enum Color { red, green, blue }

열거 타입의 각 값에는 열거 타입 선언에서 값의 0부터 시작하는 위치를 반환하는 _인덱스 getter_가 있습니다. 예를 들어 첫 번째 인덱스 값은 0이고 두 번째 인덱스 값은 1입니다.

assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);

열거 타입의 모든 값 목록을 가져 오려면 열거 타입의 값 상수를 사용합니다.

List <Color> 색상 = Color.values;
assert (colors [2] == Color.blue);

switch 문에서 열거 타입을 사용할 수 있으며 열거 타입의 모든 값을 처리하지 않으면 경고가 표시됩니다.

var aColor = Color.blue;

switch (aColor) {
  case Color.red:
    print('Red as roses!');
    break;
  case Color.green:
    print('Green as grass!');
    break;
  default: // Without this, you see a WARNING.
    print(aColor); // 'Color.blue'
}

열거 타입에는 다음과 같은 제한이 있습니다.

• 열거 타입을 하위 클래스 화하거나 혼합하거나 구현할 수 없습니다.
• 열거 타입을 명시 적으로 인스턴스화 할 수 없습니다.

자세한 내용은 Dart 언어 사양을 참조하세요.

클래스에 기능 추가 : mixins

믹스 인은 여러 클래스 계층에서 클래스의 코드를 재사용하는 방법입니다.

믹스 인을 사용하려면 with 키워드 다음에 하나 이상의 믹스 인 이름을 사용하십시오. 다음 예제는 믹스 인을 사용하는 두 개의 클래스를 보여줍니다.

class Musician extends Performer with Musical {
  // ···
}

class Maestro extends Person
    with Musical, Aggressive, Demented {
  Maestro(String maestroName) {
    name = maestroName;
    canConduct = true;
  }
}

믹스 인을 구현하려면 _Object_를 확장하고 생성자를 선언하지 않는 클래스를 만듭니다. mixin을 일반 클래스로 사용하려면 class 대신 mixin 키워드를 사용하십시오. 예를 들면,

mixin Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;

  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}

특정 유형 만 mixin을 사용할 수 있도록 지정하려면 (예: mixin이 정의하지 않은 메소드를 호출 할 수 있도록) on을 사용하여 필수 수퍼 클래스를 지정하십시오.

mixin MusicalPerformer on Musician {
  // ···
}

mixin 키워드에 대한 지원은 Dart 2.1에서 도입되었습니다. 이전 릴리스의 코드는 일반적으로 _추상 클래스_를 대신 사용했습니다. 2.1 믹스 인 변경에 대한 자세한 내용은 Dart SDK 변경 로그 및 2.1 믹스 인 사양을 참조하세요.

클래스 변수 및 메서드

static 키워드를 사용하여 클래스 전체 변수 및 메서드를 구현합니다.

정적 변수

정적 변수 (클래스 변수)는 클래스 전체 상태 및 상수에 유용합니다.

class Queue {
  static const initialCapacity = 16;
  // ···
}

void main() {
  assert(Queue.initialCapacity == 16);
}

정적 변수는 사용될 때까지 초기화되지 않습니다.

이 페이지는 상수 이름에 대해 _lowerCamelCase_를 선호하는 스타일 가이드 권장 사항을 따릅니다.

정적 메서드

정적 메서드 (클래스 메서드)는 인스턴스에서 작동하지 않으므로 이에 대한 액세스 권한이 없습니다. 예를 들면,

import 'dart:math';

class Point {
  double x, y;
  Point(this.x, this.y);

  static double distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

void main() {
  var a = Point(2, 2);
  var b = Point(4, 4);
  var distance = Point.distanceBetween(a, b);
  assert(2.8 < distance && distance < 2.9);
  print(distance);
}

일반적이거나 널리 사용되는 유틸리티 및 기능에 대해 정적 메서드 대신 최상위 수준 함수를 사용하는 것이 좋습니다.

정적 메서드를 컴파일 타임 상수로 사용할 수 있습니다. 예를 들어 정적 메서드를 상수 생성자에 매개 변수로 전달할 수 있습니다.

다음 중 하나를 사용하여 Dart 코드의 흐름을 제어 할 수 있습니다.

• if 와 else
• for 반복문
• white과 do-while 반복문
• break과 continue
• switch와 case문
• assert

예외에 설명 된대로 try-catch 및 throw를 사용하여 흐름제어에 영향을 줄 수도 있습니다.

if와 else

Dart는 아래 샘플에서 볼 수 있듯이 선택적 else 문이있는 if 문을 지원합니다. 조건식도 참조하십시오.

if (isRaining()) {
  you.bringRainCoat();
} else if (isSnowing()) {
  you.wearJacket();
} else {
  car.putTopDown();
}

_JavaScript_와 달리 조건식은 부울 값을 사용해야합니다. 자세한 내용은 부울을 참조하십시오.

for

일반적인 for 문으로 반복할 수 있습니다. 예시를 들면

var message = StringBuffer('Dart is fun');
for (var i = 0; i < 5; i++) {
  message.write('!');
}

Dart for문 내부의 클로저는 인덱스의 가치를 포착하여 _Javascript_에서 발견되는 일반적인 함정을 피합니다. 예를 들어 다음을 고려하십시오.

var callbacks = [];
for (var i = 0; i < 2; i++) {
  callbacks.add(() => print(i));
}
callbacks.forEach((c) => c());

예상대로 출력은 0과 1입니다. 반대로 이 예제는 _Javascript_에서 2를 인쇄 한 다음 2를 인쇄합니다.

반복하는 객체가 _Iterable_이면 forEach() 메서드를 사용할 수 있습니다. 현재 반복 카운터를 알 필요가 없는 경우 forEach()를 사용하는 것이 좋습니다.

candidates.forEach((candidate) => candidate.interview());

List 및 _Set_과 같은 반복 가능한 클래스는 for-in 형식의 반복도 지원합니다.

var collection = [1, 2, 3];
for (var x in collection) {
  print(x); // 1 2 3
}

while 과 do-while

while문은 반복 이전에 조건을 평가합니다.

while (!isDone()) {
  doSomething();
}

do-while문는 반복 이후에 조건을 평가합니다.

do {
  printLine();
} while (!atEndOfPage());

break 과 continue

반복을 중지하려면 break를 사용합니다.

while (true) {
  if (shutDownRequested()) break;
  processIncomingRequests();
}

다음 반복으로 건너 뛰려면 continue를 사용하십시오.

for (int i = 0; i < candidates.length; i++) {
  var candidate = candidates[i];
  if (candidate.yearsExperience < 5) {
    continue;
  }
  candidate.interview();
}

List 또는 _Set_와 같은 _Iterable_을 사용하는 경우, 이 예제를 다르게 작성할 수 있습니다.

candidates
    .where((c) => c.yearsExperience >= 5)
    .forEach((c) => c.interview());

switch 와 case

Dart의 switch 문은 ==를 사용하여 정수, 문자열 또는 컴파일 시간 상수를 비교합니다. 비교 된 객체는 모두 동일한 클래스의 인스턴스 여야하며 (하위 유형이 아님) 클래스가 ==를 재정의해서는 안됩니다. 열거 형은 switch 문에서 잘 작동합니다.

Dart의 Switch 문은 통역사 또는 스캐너와 같은 제한된 상황을위한 것입니다.

비어 있지 않은 각 case 문은 일반적으로 break 문으로 끝납니다. 비어 있지 않은 case 문을 종료하는 다른 유효한 방법은 continue, throw 또는 return 문입니다.

case 문이 일치하지 않을 때 default 문을 사용하여 코드를 실행합니다.

var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    executeClosed();
    break;
  case 'PENDING':
    executePending();
    break;
  case 'APPROVED':
    executeApproved();
    break;
  case 'DENIED':
    executeDenied();
    break;
  case 'OPEN':
    executeOpen();
    break;
  default:
    executeUnknown();
}

다음 예시에서는 case 절에서 break 문을 생략하여 오류를 생성합니다.

var command = 'OPEN';
switch (command) {
  case 'OPEN':
    executeOpen();
    // ERROR: Missing break

  case 'CLOSED':
    executeClosed();
    break;
}

그러나 Dart는 빈 case 문을 지원하여 다음과 같은 폴 스루 형식을 허용합니다.

var command = 'CLOSED';
switch (command) {
  case 'CLOSED': // Empty case falls through.
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}

정말로 폴 스루를 원한다면 continue 문과 레이블을 사용할 수 있습니다.

var command = 'CLOSED';
switch (command) {
  case 'CLOSED':
    executeClosed();
    continue nowClosed;
  // Continues executing at the nowClosed label.

  nowClosed:
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}

case 문에는 해당 문의 범위 내에서만 볼 수 있는 지역 변수가 있을 수 있습니다.

assert

개발 중에는 assert 문을 사용하십시오 — assert (condition, optionalMessage); — 부울 조건이 거짓 인 경우 정상적인 실행을 방해합니다. 이 둘러보기를 통해 assert 문 예제를 찾을 수 있습니다. 다음은 몇 가지 더 있습니다.

// 변수에 null이 아닌 값이 있는지 확인하십시오.
assert(text != null);

// 변수가 100보다 작은지 확인하십시오.
assert(number < 100);

// https URL인지 확인하십시오.
assert(urlString.startsWith('https'));

assert에 메시지를 첨부하려면 assert 할 두 번째 인수로 문자열을 추가합니다.

assert(urlString.startsWith('https'),
    'URL ($urlString) should start with "https".');

주장 할 첫 번째 인수는 부울 값으로 확인되는 모든 표현식이 될 수 있습니다. 식의 값이true 이면 _Assertion_이 성공하고 실행이 계속됩니다. false 이면 _Assertion_이 실패하고 _예외 (AssertionError)_가 발생합니다.

_Assertion_은 정확히 언제 작동합니까? 사용중인 도구와 프레임 워크에 따라 다릅니다.

• _Flutter_는 디버그 모드에서 _Assertion_을 활성화합니다.
• _dartdevc_와 같은 개발 전용 도구는 일반적으로 기본적으로 _Assertion_을 활성화합니다.
• dart 및 _dart2js_와 같은 일부 도구는 명령 줄 플래그 --enable-asserts를 통해 _Assertion_을 지원합니다.

프로덕션 코드에서는 Assertion_이 무시되고 _Assertion 할 인수가 평가되지 않습니다.

예외처리

Dart 코드는 예외를 발생시키고 포착 할 수 있습니다. 예외는 예기치 않은 일이 발생했음을 나타내는 오류입니다. 예외가 포착되지 않으면 예외를 발생시킨 격리가 일시 중지되고 일반적으로 격리와 해당 프로그램이 종료됩니다.

Java와 달리 Dart의 모든 예외는 확인되지 않은 예외입니다. 메서드는 throw 할 수있는 예외를 선언하지 않으며 예외를 포착 할 필요가 없습니다.

Dart는 Exception 및 Error 유형은 물론 사전 정의 된 수많은 하위 유형을 제공합니다. 물론 자신 만의 예외를 정의 할 수 있습니다. 그러나 Dart 프로그램은 Exception 및 Error 개체뿐만 아니라 null이 아닌 개체를 예외로 throw 할 수 있습니다.

Throw

다음은 예외를 던지거나 발생시키는 예시입니다.

throw FormatException('Expected at least 1 section');
throw 'Out of llamas!'; // 임의의 객체를 던질 수도 있습니다.

프로덕션 품질 코드는 일반적으로 오류 또는 예외를 구현하는 유형을 발생시킵니다.

예외를 던지는 것은 표현식이므로 => 문은 물론 표현식을 허용하는 다른 모든 곳에서 예외를 던질 수 있습니다.

void distanceTo(Point other) => throw UnimplementedError();

Catch

예외를 포착나 캡처하면 예외가 전파되는 것을 중지합니다 (예외를 다시 던지지 않는 한). 예외를 포착하면 처리 할 수있는 기회가 제공됩니다.

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  buyMoreLlamas();
}

둘 이상의 예외 유형을 발생시킬 수있는 코드를 처리하기 위해 여러 catch 절을 지정할 수 있습니다. throw 된 객체의 유형과 일치하는 첫 번째 catch 절이 예외를 처리합니다. catch 절이 유형을 지정하지 않으면 해당 절은 모든 유형의 throw 된 객체를 처리 할 수 있습니다.

try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // A specific exception
  buyMoreLlamas();
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

앞의 코드에서 볼 수 있듯이 on, catch 또는 둘 다를 사용할 수 있습니다. 예외 유형을 지정해야 할 때 on을 사용하십시오. 예외 처리기에 예외 개체가 필요한 경우 catch를 사용합니다.

catch()에 하나 또는 두 개의 매개 변수를 지정할 수 있습니다. 첫 번째는 throw 된 예외이고 두 번째는 스택 추적 (StackTrace 객체)입니다.

try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

예외를 부분적으로 처리하고 전파를 허용하려면 rethrow 키워드를 사용하십시오.

void misbehave() {
  try {
    dynamic foo = true;
    print(foo++); // 런타임 에러
  } catch (e) {
    print('misbehave() partially handled ${e.runtimeType}.');
    rethrow; // 에러의 전파 허용
  }
}

void main() {
  try {
    misbehave(); // 에러 전파로 인한 에러 발생
  } catch (e) {
    print('main() finished handling ${e.runtimeType}.');
  }
}

Finally

예외 발생 여부에 관계없이 일부 코드가 실행되도록하려면 finally절을 사용하십시오. 예외와 일치하는 catch 절이 없으면 finally 절이 실행 된 후 예외가 전파됩니다.

`try {
  breedMoreLlamas();
} finally {
  // Always clean up, even if an exception is thrown.
  cleanLlamaStalls();
}

finally 절은 일치하는 catch 절 이후에 실행됩니다.

try {
  breedMoreLlamas();
} catch (e) {
  print('Error: $e'); // Handle the exception first.
} finally {
  cleanLlamaStalls(); // Then clean up.
}

라이브러리 둘러보기의 예외 섹션을 읽고 자세히 알아보세요.

Dart는 아래 표에 표시된 연산자를 정의합니다. 재정의 가능한 연산자에 설명 된대로 이러한 연산자 중 다수를 재정의 할 수 있습니다.

주의: 연산자 우선 순위는 Dart 파서 동작의 근사치입니다. 확실한 답은 Dart 언어 사양의 문법을 참조하십시오.

연산자를 사용하면 표현식이 생성됩니다. 다음은 연산자 표현식의 몇 가지 예시입니다.

a++
a + b
a = b
a == b
c ? a : b
a is T

연산자 테이블에서 각 연산자는 뒤에 오는 행의 연산자보다 우선 순위가 높습니다. 예를 들어 곱셈 연산자 %는 논리 AND 연산자 &&보다 우선 순위가 높은 같음 연산자 ==보다 우선 순위가 더 높습니다 (따라서 이전에 실행 됨). 이 우선 순위는 다음 두 줄의 코드가 동일한 방식으로 실행됨을 의미합니다.

// 괄호로 가독성을 향상시킵니다.
if ((n % i == 0) && (d % i == 0)) ...

// 가독성이 떨어지지만, 같은 논리식입니다.
if (n % i == 0 && d % i == 0) ...

주의: 두 개의 피연산자에 대해 작업하는 연산자의 경우 가장 왼쪽에있는 피연산자가 사용되는 연산자 버전을 결정합니다. 예를 들어 Vector 객체와 Point 객체가있는 경우 aVector + aPoint는 Vector 버전의 +를 사용합니다.

산술연산자

Dart는 다음 표와 같이 일반적인 산술 연산자를 지원합니다.

assert(2 + 3 == 5);
assert(2 - 3 == -1);
assert(2 * 3 == 6);
assert(5 / 2 == 2.5); // Result is a double
assert(5 ~/ 2 == 2); // Result is an int
assert(5 % 2 == 1); // Remainder

assert('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');

Dart는 또한 접두사 및 접미사 증가 및 감소 연산자를 모두 지원합니다.

var a, b;

a = 0;
b = ++a; // Increment a before b gets its value.
assert(a == b); // 1 == 1

a = 0;
b = a++; // Increment a AFTER b gets its value.
assert(a != b); // 1 != 0

a = 0;
b = --a; // Decrement a before b gets its value.
assert(a == b); // -1 == -1

a = 0;
b = a--; // Decrement a AFTER b gets its value.
assert(a != b); // -1 != 0

평등 및 관계 연산자

다음 표에는 같음 및 관계 연산자의 의미가 나열되어 있습니다.

두 객체 x와 y가 같은 것을 나타내는 지 테스트하려면 == 연산자를 사용하십시오. (드물게 두 객체가 정확히 동일한 객체인지 알아야하는 경우에는 대신 same() 함수를 사용하십시오.) == 연산자의 작동 방식은 다음과 같습니다.

• x 또는 y가 둘 다 null이면 true를 반환하고 하나만 null이면 false를 반환합니다.
• 메서드 호출 x. == (y)의 결과를 반환합니다. (맞습니다. ==와 같은 연산자는 첫 번째 피연산자에서 호출되는 메서드입니다. 재정의 가능 연산자에서 볼 수 있듯이 ==를 비롯한 많은 연산자를 재정의 할 수도 있습니다.)

다음은 같음 및 관계 연산자를 각각 사용하는 예입니다.

assert(2 == 2);
assert(2 != 3);
assert(3 > 2);
assert(2 < 3);
assert(3 >= 3);
assert(2 <= 3);

유형 테스트 연산자

as, is, is! 연산자는 런타임에 유형을 확인하는 데 편리합니다.

obj is T로 지정된 인터페이스를 구현하는 경우 obj의 결과는 T가 true입니다. 예를 들어 obj is Object가 항상 true입니다.

객체가 해당 유형인지 확신하는 경우에만 as 연산자를 사용하여 객체를 특정 유형으로 캐스트하십시오.

(emp as Person).firstName = 'Bob';

개체가 T 유형인지 확실하지 않은 경우 개체를 사용하기 전에 is T를 사용하여 유형을 확인합니다.

if (emp is Person) {
  // Type check
  emp.firstName = 'Bob';
}

코드가 동일하지 않습니다. emp가 null이거나 Person이 아니면 첫 번째 예제는 예외를 던집니다. 두 번째는 아무것도 하지 않습니다.

할당 연산자

이미 살펴본 것처럼 = 연산자를 사용하여 값을 할당 할 수 있습니다. 할당 대상 변수가 null 인 경우에만 할당하려면 ??= 연산자를 사용합니다.

// Assign value to a
a = value;
// Assign value to b if b is null; otherwise, b stays the same
b ??= value;

+=와 같은 복합 할당 연산자는 연산과 할당을 결합합니다.

복합 할당 연산자의 작동 방식은 다음과 같습니다.

다음 예에서는 할당 및 복합 할당 연산자를 사용합니다.

var a = 2; // Assign using =
a *= 3; // Assign and multiply: a = a * 3
assert(a == 6);

논리 연산자

논리 연산자를 사용하여 부울 식을 반전하거나 결합 할 수 있습니다.

다음은 논리 연산자를 사용하는 예입니다.

if (!done && (col == 0 || col == 3)) {
  // ...Do something...
}

비트 및 시프트 연산자

Dart에서 개별 숫자 비트를 조작 할 수 있습니다. 일반적으로 정수와 함께 이러한 비트 및 시프트 연산자를 사용합니다.

다음은 비트 및 시프트 연산자를 사용하는 예입니다.

final value = 0x22;
final bitmask = 0x0f;

assert((value & bitmask) == 0x02); // AND
assert((value & ~bitmask) == 0x20); // AND NOT
assert((value | bitmask) == 0x2f); // OR
assert((value ^ bitmask) == 0x2d); // XOR
assert((value << 4) == 0x220); // Shift left
assert((value >> 4) == 0x02); // Shift right

조건식

Dart에는 if-else 문이 필요할 수있는 표현식을 간결하게 평가할 수있는 두 개의 연산자가 있습니다.

condition ? expr1 : expr2

조건이 참이면 expr1을 평가하고 그 값을 반환합니다. 그렇지 않으면 expr2의 값을 평가하고 반환합니다.

expr1 ?? expr2

expr1이 null이 아니면 값을 리턴합니다. 그렇지 않으면 expr2의 값을 평가하고 반환합니다.

부울 표현식을 기반으로 값을 할당해야하는 경우 ? ~ : 사용을 고려하십시오.

var visibility = isPublic ? 'public' : 'private';

부울식이 null을 테스트하는 경우 ??를 사용하는 것이 좋습니다.

String playerName(String name) => name ?? 'Guest';

위 예제는 적어도 두 가지 다른 방법으로 작성되었을 수 있지만 간결하지는 않습니다.

// Slightly longer version uses ?: operator.
String playerName(String name) => name != null ? name : 'Guest';

// Very long version uses if-else statement.
String playerName(String name) {
  if (name != null) {
    return name;
  } else {
    return 'Guest';
  }
}

캐스케이드 표기법 (..)

캐스케이드 (..)를 사용하면 동일한 개체에서 일련의 작업을 수행 할 수 있습니다. 함수 호출 외에도 동일한 객체의 필드에 액세스 할 수 있습니다. 이것은 종종 임시 변수를 만드는 단계를 절약하고 더 유동적 인 코드를 작성할 수있게합니다.

아래 코드를 보면,

querySelector('#confirm') // Get an object.
  ..text = 'Confirm' // Use its members.
  ..classes.add('important')
  ..onClick.listen((e) => window.alert('Confirmed!'));

첫 번째 메서드 호출 인 querySelector()는 선택기 객체를 반환합니다. 계단식 표기법을 따르는 코드는 반환 될 수있는 모든 후속 값을 무시하고이 선택기 개체에서 작동합니다.

위 예시는 다음과 같습니다.

var sb = StringBuffer();
sb.write('foo')
  ..write('bar'); // Error: method 'write' isn't defined for 'void'.

sb.write() 호출은 void를 반환하며 void에 계단식을 구성할 수 없습니다.

엄밀히 말해서 캐스케이드에 대한 "이중 점" 표기법은 연산자가 아닙니다. Dart 구문의 일부 일 뿐입니다.

기타 연산자

다른 예시에서 나머지 연산자의 대부분을 확인했습니다.

., ?. 및 .. 연산자에 대한 자세한 내용은 클래스를 참조하십시오.

Dart는 진정한 객체지향 언어이므로 함수조차도 객체이고 타입인 _Function_을 갖습니다. 이는 함수를 변수에 할당하거나 다른 함수에 인수로 전달할 수 있음을 의미합니다. 함수인 것처럼 Dart 클래스의 인스턴스를 호출할 수도 있습니다. 자세한 내용은 Callable 클래스를 참조하십시오.

다음은 함수 구현의 예입니다.

bool isNoble(int atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

Dart를 효율적으로 사용하기 위해서는 공용 API에 대한 타입 명시을 권장하지만 타입 명시를 생략해도 함수는 계속 작동합니다.

isNoble(atomicNumber) {
  return _nobleGases[atomicNumber] != null;
}

표현식이 하나만 포함 된 함수의 경우 약식 구문을 사용할 수 있습니다.

bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

=> expr 구문은 {return expr; }. => 표기법은 때때로 _화살표구문_이라고도합니다.

구문이 아닌 표현식만 화살표 =>와 세미콜론 ; 사이에 나타날 수 있습니다. 예를 들어 여기에 if 문을 넣을 수 없지만 조건식을 사용할 수 있습니다.

함수는 필수 및 선택의 두 가지 유형의 매개변수를 가질 수 있습니다. 필수 매개변수가 먼저 나열되고 그 뒤에 선택적 매개변수가 나열됩니다. 선택적 매개변수는 이름이 지정되거나 위치가 지정될 수 있습니다.

일부 API (특히 Flutter 위젯 생성자)는 필수 매개변수에 대해서도 명시 된 매개변수만 사용합니다. 자세한 내용은 다음 섹션을 참조하십시오.

선택적 매개변수

선택적 매개변수는 이름 또는 위치가 될 수 있지만 둘 다는 아닙니다.

명시적 매개변수

함수를 호출할 때 paramName: value를 사용하여 매개변수를 지정할 수 있습니다. 예를 들어

enableFlags(bold: true, hidden: false);

함수를 정의할 때 {param1, param2, ...} 를 사용하여 명시적 매개변수를 지정합니다.

/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold, bool hidden}) {...}

명시적 매개변수는 일종의 선택적 매개변수이지만 매개변수가 필수임을 나타내기 위해 @required로 주석을 달 수 있습니다. 사용자는 매개변수에 대한 값을 제공해야합니다. 예를 들면 :

const Scrollbar({Key key, @required Widget child})

만약 자식인자를 지정하지 않고 스크롤바를 만들려고 하면 분석기가 문제를 보고합니다.

@required 주석을 사용하려면 메타 패키지에 의존하고 package: meta/meta.dart를 가져옵니다.

위치적 매개변수

함수 매개변수 세트를 []로 감싸면 선택적 위치 매개변수로 표시됩니다.

String say(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

다음은 선택적 매개변수 없이 위 함수를 호출하는 예시입니다.

assert(say('Bob', 'Howdy') == 'Bob says Howdy');

다음은 세 번째 매개변수를 사용하여 위 함수를 호출하는 예시입니다.

assert(say('Bob', 'Howdy', 'smoke signal') ==
    'Bob says Howdy with a smoke signal');

매개변수의 기본 값

함수는 =를 사용하여 명시적 매개변수와 위치 매개변수 모두에 대한 기본값을 정의할 수 있습니다. 기본 값은 컴파일타임 상수여야 하며, 기본값이 제공되지 않으면 기본값은 null입니다.

다음은 명시적 매개변수에 대한 기본값을 설정하는 예시입니다.

/// Sets the [bold] and [hidden] flags ...
void enableFlags({bool bold = false, bool hidden = false}) {...}

// bold will be true; hidden will be false.
enableFlags(bold: true);
 Deprecation note: Old code might use a colon (:) instead of = to set d

사용중단 참고: 이전 코드는 명시적 매개 변수의 기본값을 설정하기 위해 = 대신 콜론:을 사용할 수 있습니다. 그 이유는 원래 이름이 지정된 매개 변수에 대해:만 지원 되었기 때문입니다. 해당 지원은 더 이상 사용되지 않을 수 있으므로 =를 사용하여 기본값을 지정하는 것이 좋습니다.

다음 예시는 위치 매개변수의 기본값을 설정하는 방법입니다.

String say(String from, String msg,
    [String device = 'carrier pigeon', String mood]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  if (mood != null) {
    result = '$result (in a $mood mood)';
  }
  return result;
}

assert(say('Bob', 'Howdy') ==
    'Bob says Howdy with a carrier pigeon');

_List_이나 _Map_을 기본값으로 전달할 수도 있습니다. 다음 예제는 list 매개변수에 대한 기본 _List_과 gifts 매개 변수에 대한 기본 _Map_을 지정하는 함수 doStuff()를 정의합니다.

void doStuff(
    {List<int> list = const [1, 2, 3],
    Map<String, String> gifts = const {
      'first': 'paper',
      'second': 'cotton',
      'third': 'leather'
    }}) {
  print('list:  $list');
  print('gifts: $gifts');
}

main() 함수

모든 앱에는 앱의 진입점 역할을하는 최상위 main() 함수가 있어야 합니다. main() 함수는 void를 반환하고 인수에 대한 선택적 List<String> 매개변수를 갖습니다.

다음은 웹 앱에 대한 main() 함수의 예시입니다.

void main() {
  querySelector('#sample_text_id')
    ..text = 'Click me!'
    ..onClick.listen(reverseText);
}

위 코드에서, ...구문을 캐스케이드라고 합니다. 캐스케이드를 사용하면 단일 개체의 멤버에 대해 여러 작업을 수행할 수 있습니다.

다음은 인수를 받는 명령줄 앱에 대한 main() 함수의 예시입니다.

// Run the app like this: dart args.dart 1 test
void main(List<String> arguments) {
  print(arguments);

  assert(arguments.length == 2);
  assert(int.parse(arguments[0]) == 1);
  assert(arguments[1] == 'test');
}

args 라이브러리를 사용하여 명령줄 인수를 정의하고 구문분석 할 수 있습니다.

객체로서의 함수 사용

함수를 매개변수로 다른 함수에 전달할 수 있습니다. 예를 들면,

void printElement(int element) {
  print(element);
}

var list = [1, 2, 3];

// Pass printElement as a parameter.
list.forEach(printElement);

다음과 같이 변수에 함수를 할당할 수도 있습니다.

var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
assert(loudify('hello') == '!!! HELLO !!!');

이 예시에서는 익명함수를 사용합니다. 다음 섹션에서 이에 대해 자세히 알아보십시오.

익명함수

대부분의 함수는 main() 또는 printElement()와 같이 이름이 지정됩니다. 익명함수 또는 때때로 람다 또는 클로저라고하는 이름 없는 함수를 만들 수도 있습니다. 예를 들어 컬렉션에서 추가하거나 제거할 수 있도록 변수에 익명함수를 할당 할 수 있습니다.

익명 함수는 명시적 함수와 비슷합니다. 쉼표로 구분된 0개 이상의 매개변수와 괄호 사이의 선택적 유형 주석입니다.

다음 코드 블록에는 함수의 본문이 포함됩니다.

([[Type] param1[, …]]) {
  codeBlock;
};

다음 예제는 유형이 지정되지 않은 매개변수 인 item을 사용하여 익명함수를 정의합니다. _List_의 각 항목에 대해 호출되는 함수는 지정된 인덱스의 값을 포함하는 문자열을 출력합니다.

var list = ['apples', 'bananas', 'oranges'];

list.forEach((item) {
  print('${list.indexOf(item)}: $item');
});

// list.forEach(
//    (item) => print('${list.indexOf(item)}: $item')
// ); 
// 함수에 명령문이 하나만 있는 경우 화살표 표기법을 사용하여 줄일 수 있습니다. 

// 출력 결과
// 0: apples
// 1: bananas
// 2: oranges

렉시컬 스코프

Dart는 Javascript 처럼 렉시컬 스코프 언어입니다. 즉, 변수의 스코프가 코드 레이아웃에 따라 정적으로 결정됩니다. 변수가 범위 내에 있는지 확인하려면 "중괄호를 바깥쪽으로" 따라갈 수 있습니다.

다음은 각 스코프 수준에서 변수가 있는 중첩 함수의 예입니다.

bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

      assert(topLevel);
      assert(insideMain);
      assert(insideFunction);
      assert(insideNestedFunction);
    }
  }
}

nestedFunction()이 어떻게 모든 수준의 변수를 최상위 수준까지 사용할 수 있는지 확인하세요.

렉시컬 클로저

클로저는 함수가 원래 스코프 밖에서 사용되는 경우에도 어휘 범위의 변수에 액세스 할 수있는 함수 객체입니다.

함수는 주변 범위에 정의 된 변수를 통해 닫힐 수 있습니다. 다음 예제에서 makeAdder()는 변수 addBy를 캡처합니다. 반환 된 함수가 가는 곳마다 addBy를 기억합니다.

/// Returns a function that adds [addBy] to the
/// function's argument.
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}

void main() {
  // Create a function that adds 2.
  var add2 = makeAdder(2);

  // Create a function that adds 4.
  var add4 = makeAdder(4);

  assert(add2(3) == 5);
  assert(add4(3) == 7);
}

동등성 테스트

다음은 최상위 함수, 정적 메서드, 인스턴스 메서드가 같은지 테스트하는 예시입니다.

void foo() {} // A top-level function

class A { static void bar() {} // A static method void baz() {} // An instance method }

void main() {
  var x;

  // 최상위 함수 비교.
  x = foo;
  assert(foo == x);

  // 정적 메서드 비교
  x = A.bar;
  assert(A.bar == x);

  // 인스턴스 메서드 비교
  var v = A(); // Instance #1 of A
  var w = A(); // Instance #2 of A
  var y = w;
  x = w.baz;

  // 이러한 클로저는 동일한 인스턴스(#2)를 참조합니다.
  // 그래서 같음
  assert(y.baz == x);

  // 이러한 클로저는 다른 인스턴스를 참조합니다.
  // 그래서 다름
  assert(v.baz != w.baz);
}

반환 값

모든 함수는 값을 반환합니다. 반환 값을 지정하지 않으면 명령문은 null을 반환합니다. 함수 본문에 암시 적으로 추가됩니다.

foo() {}

assert(foo() == null);

변수는 다음과 같이 선언합니다.

var name = 'Bob'; 

String 타입의 값인 'Bob'을 name 변수에 넣어줍니다. 타입이 String 이지만 충분히 유추가능하기 때문에, 명시해주지 않았습니다. 변수가 유동적이거나 하나의 타입에 국한되어있지 않다면, Object나 dynamic 타입으로 명시해주면 됩니다.

dynamic name = 'Bob';

아니면, String 타입으로 명시해줄 수도 있습니다.

String name = 'Bob';

초기값 설정

Dart에서 초기값 설정이 안된 변수는 null의 초기값을 가지게 됩니다.

int lineCount;
assert(lineCount == null); // development 모드에서만 실행되는 구문 (예외를 throw)

Final_과 _Const

변수를 변경하지 않으려는 경우, var대신에 final이나 const 타입을 사용합니다. final 타입의 변수는 초기값만 설정할 수 있습니다. const 타입의 변수는 컴파일 타입 상수입니다. (상수 변수는 암시적으로 final입니다.) 최상위 final 또는 클래스 변수는 처음 사용될 때 초기화됩니다.

final name = 'Bob'; // 타입이 없어도 선언 가능
final String nickname = 'Bobby'; 

name = 'Alice'; // Error: a final variable can only be set once.
// final 변수는 한 번만 값을 가질 수 있음.

컴파일 타임 상수가 될 변수에는 const를 사용합니다. const 변수가 클래스 수준에 있으면 static const로 표기합니다.

변수를 선언하는 경우 값을 숫자 또는 문자열 상수, const 변수 또는 숫자 상수에 대한 산술 연산의 결과와 같은 컴파일타임 상수로 설정합니다.

const bar = 1000000; // Unit of pressure (dynes/cm2)
const double atm = 1.01325 * bar; // Standard atmosphere

const 키워드는 상수 변수를 선언하기 위한 것이 아닙니다. 이를 이용하여 상수 값을 생성하고, 상수 값을 생성하는 생성자를 선언할 수도 있습니다. 모든 변수는 상수 값을 가질 수 있습니다.

var foo = const [];
final bar = const [];

const baz = []; 
// 결국 []는 const [] 와 똑같기 때문에, 초기화 표현식에서 const를 생략함 (중복사용 방지)

foo 는 상수 값을 가졌었지만, const 타입의 변수가 아니기 때문에 값 변경이 가능합니다.

foo = [1, 2, 3]; // Was const []

baz 는 const 타입 변수이기 때문에, 값 변경이 불가능합니다.

baz = [42]; // Error: Constant variables can't be assigned a value.

Dart 2.5버전 부터 유형검사 및 캐스트 (is 와 as), 컬렉션 if 및 스프레드 연산자 (... 와 ...?)를 사용하는 상수를 정의할 수 있습니다.

// Valid compile-time constants as of Dart 2.5.
const Object i = 3; // Where i is a const Object with an int value...
const list = [i as int]; // Use a typecast.
const map = {if (i is int) i: "int"}; // Use is and collection if.
const set = {if (list is List<int>) ...list}; // ...and a spread.

빌트-인 타입

Dart는 아래와 같은 타입들을 지원합니다.

• numbers
• strings
• booleans
• lists (also known as arrays)
• sets
• maps
• runes (for expressing Unicode characters in a string)
• symbols

상수를 사용하여 이러한 타입들의 개체를 초기화할 수 있습니다. 예를 들어 'this is a string'은 문자열 상수이고, true 는 부울 상수입니다.

Dart의 모든 변수는 객체 (클래스의 인스턴스)를 참조하기 때문에, 일반적으로 생성자를 사용하여 변수를 초기화할 수 있습니다. 일부 내장 타입에는 자체 생성자가 있습니다.

예를 들어, Map() 생성자를 사용하여 Map 객체를 만들 수 있습니다.

Numbers

Dart에서 숫자 타입은 두 가지로 나뉩니다.

int

플랫폼에 따라 64비트 이하의 정수 값입니다. Dart VM에서 값은 $-2^{63}$ ~ $2^{63}-1$ 까지 가능합니다. Javascript로 컴파일된 Dart는 Javascript 숫자를 사용하며, $-2^{53}$ ~ $2^{53}-1$의 값을 허용합니다.

double

IEEE 754 표준에 지정된 64비트 (배정 밀도) 부동 소수점 값을 허용합니다.

num

int와 double 모두 num의 하위 타입입니다. num 타입에는 +, -, /, * 같은 기본 연산자가 포함되며, 다른 메소드 중에서도 abs(), ceil(), floor()를 찾을 수 있습니다. (>>와 같은 비트 연산자는 int 클래스에 정의되어 있습니다.)

num 및 해당 하위 타입에 원하는 항목이 없는 경우 dart:math 라이브러리에 있을 수 있습니다.

var x = 1;
var hex = 0xDEADBEEF;

// 상수 int 예시

var y = 1.1;
var exponents = 1.42e5;

// 상수 double 예시

Dart 2.1 이후에서는 double 타입에 int 상수를 넣으면 자동으로 double로 변환됨.

double z = 1;

아래와 같이 문자열을 숫자로, 숫자를 문자로 바꿀 수 있습니다.

// String -> int
var one = int.parse('1');
assert(one == 1);

// String -> double
var onePointOne = double.parse('1.1');
assert(onePointOne == 1.1);

// int -> String
String oneAsString = 1.toString();
assert(oneAsString == '1');

// double -> String
String piAsString = 3.14159.toStringAsFixed(2);
assert(piAsString == '3.14');

int 타입은 기존 비트 Shift(<<, >>), And(&), Or(|) 연산자를 지원합니다.

assert((3 << 1) == 6); // 0011 << 1 == 0110
assert((3 >> 1) == 1); // 0011 >> 1 == 0001
assert((3 | 4) == 7); // 0011 | 0100 == 0111

상수 숫자는 컴파일 타임 상수입니다. 피연산자가 숫자로 평가되는 컴파일 타임 상수로 인한 많은 산술식도 컴파일타임 상수입니다.

const msPerSecond = 1000;
const secondsUntilRetry = 5;
const msUntilRetry = secondsUntilRetry * msPerSecond;

String

Dart에서의 문자열은 일련의 UTF-16 코드 단위입니다. 작은 따옴표 또는 큰 따옴표를 사용하여 문자열을 만들 수 있습니다.

var s1 = 'Single quotes work well for string literals.';
var s2 = "Double quotes work just as well.";
var s3 = 'It\'s easy to escape the string delimiter.';
var s4 = "It's even easier to use the other delimiter.";

${expr} 를 사용하여 문자열 안에 표현식의 값을 넣을 수 있습니다.

표현식이 식별자인 경우, {}를 건너뛸 수 있습니다. 객체에 해당하는 문자열을 얻기위해 Dart는 객체의 toString() 함수를 호출합니다.

var s = 'string interpolation';

assert('Dart has $s, which is very handy.' ==
    'Dart has string interpolation, ' +
        'which is very handy.');
assert('That deserves all caps. ' +
        '${s.toUpperCase()} is very handy!' ==
    'That deserves all caps. ' +
        'STRING INTERPOLATION is very handy!');

==연산자는 두 개체가 동일한 지 테스트합니다. 동일한 코드 단위 시퀀스를 포함하는 두 문자열은 동일합니다.

인접한 문자열 리터럴 또는 + 연산자를 사용하여 문자열을 연결할 수 있습니다.

var s1 = 'String '
    'concatenation'
    " works even over line breaks.";
assert(s1 ==
    'String concatenation works even over '
        'line breaks.');

var s2 = 'The + operator ' + 'works, as well.';
assert(s2 == 'The + operator works, as well.');

여러 줄의 문자열을 만드는 또 다른 방법으로, 작은 따옴표 또는 큰 따옴표로 삼중따옴표를 사용합니다.

var s1 = '''
You can create
multi-line strings like this one.
''';

var s2 = """This is also a
multi-line string.""";

r을 접두사로 붙여 _Raw String_을 만들 수 있습니다.

var s = r'In a raw string, not even \n gets special treatment.';

문자열에 유니코드 문자를 표현하는 방법에 대한 자세한 내용은, 여기를 참조하세요.

리터럴 문자열은 보간된 표현식이 null 또는 숫자, 문자열 또는 부울 값으로 평가되는 컴파일 타임 상수

// These work in a const string.
const aConstNum = 0;
const aConstBool = true;
const aConstString = 'a constant string';

// These do NOT work in a const string.
var aNum = 0;
var aBool = true;
var aString = 'a string';
const aConstList = [1, 2, 3];

const validConstString = '$aConstNum $aConstBool $aConstString';
// const invalidConstString = '$aNum $aBool $aString $aConstList';

Boolean

Dart에는 부울값을 나타내기 위해 true, false 값만을 가지는 bool 타입이 있습니다. 두 값 모두 컴파일타임 상수입니다.

Dart의 유형 안정성은 if(nonbooleanValue) 또는 assert(nonbooleanValue)와 같은 코드를 사용할 수 없음을 의미합니다. 대신 아래와 같이 명시적으로 값을 확인하십시오.

// 빈 문자열 검사.
var fullName = '';
assert(fullName.isEmpty);

// 숫자 0 검사.
var hitPoints = 0;
assert(hitPoints <= 0);

// null 인지 검사.
var unicorn;
assert(unicorn == null);

// 계산 결과 값이 NaN인지 검사.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);

List

거의 모든 프로그래밍 언어에서 가장 일반적인 컬렉션은 배열 또는 정렬된 객체 그룹일 것입니다. Dart에서 배열은 List 객체입니다.

Dart List 리터럴은 Javascript Array 리터럴처럼 보입니다.

var list = [1, 2, 3];
// Dart 배열 객체 선언

Dart는 배열에 List<int> 유형이 있다고 추론합니다. 이 배열에 정수가 아닌 개체를 추가하려고하면 분석기 또는 런타임에서 오류가 발생합니다. 자세한 내용은 유형추론을 참조하세요.

배열은 0부터 시작하는 인덱싱을 사용합니다. 0은 첫 요소의 인덱스이고, list.length - 1은 마지막 요소의 인덱스입니다. Javascript에서와 마찬가지로, 배열의 길이를 가져오고 목록 요소를 참조할 수 있습니다.

var list = [1, 2, 3];
assert(list.length == 3);
assert(list[1] == 2);

list[1] = 1;
assert(list[1] == 1);

컴파일타임 상수인 배열을 만들려면 배열 리터럴 앞에 const를 추가합니다.

var constantList = const [1, 2, 3];
// constantList[1] = 1; // Error! 컴파일타임 상수배열의 요소를 변경할 수 없음.

Dart 2.3은 배열에 여러 요소를 삽입하는 간결한 방법을 제공하는 스프레드 연산자 ...와 null 인식 확산 연산자 ...?를 도입했습니다.

예를 들어 스프레드 연산자 ...를 사용하여 목록의 모든 요소를 다른 목록에 삽입 할 수 있습니다.

var list = [1, 2, 3];
var list2 = [0, ...list];
assert(list2.length == 4);

스프레드 연산자 오른쪽에 있는 식이 null일 수 있는 경우, null인식 스프레드 연산자 ...? 를 사용하여 예외를 피할 수 있습니다.

var list;
var list2 = [0, ...?list];
assert(list2.length == 1);

스프레드 연산자 사용에 대한 자세한 내용과 예는 스프레드 연산자 제안을 참조하세요.

Dart 2.3은 또한 조건부 if 및 반복 for_을 사용하여 배열 구축하는 데 사용할 수 있는 _collection if 및 _collection for_를 도입했습니다.

다음은 3개 또는 4개의 항목이있는 목록을 만드는 경우 배열을 사용하는 예시입니다.

var nav = [
  'Home',
  'Furniture',
  'Plants',
  if (promoActive) 'Outlet'
];

다음은 배열 사용하여 목록의 항목을 다른 배열에 추가하기 전에 변경하는 예시입니다.

var listOfInts = [1, 2, 3];
var listOfStrings = [
  '#0',
  for (var i in listOfInts) '#$i'
];
assert(listOfStrings[1] == '#1');

배열 사용에 대한 자세한 내용과 예제는 제어 흐름 컬렉션 제안을 참조하세요.

배열 유형에는 배열을 조작하는 여러 가지 편리한 방법이 있습니다. 배열에 대한 자세한 내용은 제네릭 및 컬렉션을 참조하세요.

Sets

Dart의 Set_는 순서가 지정되지 않은 고유한 아이템 모음입니다. 집합에 대한 Dart 지원은 _Set 리터럴과 Set 타입에 의해 제공됩니다.

Set 유형은 항상 Dart의 핵심 부분 이었지만 Set 리터럴은 Dart 2.2에서 도입되었습니다.

간단한 _Set_의 예시입니다.

var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

Dart는 halogens의 타입이 Set<String>이라고 추론합니다. _Set_에 잘못된 타입의 값을 추가하려고하면 분석기 또는 런타임에서 오류가 발생합니다. 자세한 내용은 유형 추론을 참조하세요.

빈 Set_을 만들려면 타입 인수 앞에 {}를 사용하거나 {}를 _Set 타입의 변수에 할당합니다.

var names = <String>{};
// Set<String> names = {}; // 이렇게 써도 됩니다.
// var names = {}; // Map을 만듭니다.

Set 또는 Map? Map 리터럴의 구문은 Set 리터럴의 구문과 유사합니다. Map 리터럴이 먼저 왔기 때문에 {}는 기본적으로 Map 유형입니다. {}의 타입 주석 또는 할당 된 변수를 잊어 버린 경우 Dart는 Map <dynamic, dynamic> 타입의 개체를 만듭니다.

add () 또는 addAll () 메서드를 사용하여 기존 _Set_에 항목을 추가합니다.

var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);

.length를 사용하여 _Set_의 항목 수를 가져옵니다.

var elements = <String>{};
elements.add('fluorine');
elements.addAll(halogens);
assert(elements.length == 5);

컴파일타임 상수 인 Set_을 만들려면 _Set 리터럴 앞에 const를 추가합니다.

final constantSet = const {
  'fluorine',
  'chlorine',
  'bromine',
  'iodine',
  'astatine',
};
// constantSet.add('helium'); // Uncommenting this causes an error.

Dart 2.3부터 Set_는 _List_과 마찬가지로 스프레드 연산자 (... 및 ...?)와 _collection if 및 collection for_를 지원합니다. 자세한 내용은 [_List 스프레드 연산자](https://dart.dev/guides/language/language-tour#spread-operator) 및 List 수집 연산자 토론을 참조하세요.

_Set_에 대한 자세한 내용은 제네릭 및 Set을 참조하십시오.

Maps

일반적으로 Map_은 키와 값으로 이루어진 객체입니다. 키와 값은 모든 유형의 객체가 될 수 있습니다. 각 키는 한 번만 발생하지만 동일한 값을 여러 번 사용할 수 있습니다. _Map_에 대한 Dart 지원은 _Map 리터럴과 Map 타입에 의해 제공됩니다.

다음은 Map 리터럴을 사용하여 만든 몇 가지 간단한 Dart _Map_입니다.

var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};

var nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

//Javascript Object와 유사함.

Dart는 gifts의 타입이 Map <String, String>이고 nobleGases의 유형이 Map <int, String>이라고 추론합니다. 잘못된 타입의 값을 _Map_에 추가하려고하면 분석기 또는 런타임에서 오류가 발생합니다. 자세한 내용은 유형 추론을 참조하세요.

Map 생성자를 사용하여 동일한 객체를 만들 수 있습니다.

var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';

var nobleGases = Map();
nobleGases[2] = 'helium';
nobleGases[10] = 'neon';
nobleGases[18] = 'argon';

Map () 대신 new Map ()이 표시 될 것으로 예상 할 수 있습니다. Dart 2에서 new 키워드는 선택 사항입니다. 자세한 내용은 생성자 사용을 참조하세요.

Javascript에서와 같이 기존 _Map_에 새로운 키-값 쌍을 추가할 수 있습니다.

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds'; // Add a key-value pair

JavaScript 에서와 같은 방식으로 _Map_에서 값을 검색합니다.

var gifts = {'first': 'partridge'};
assert(gifts['first'] == 'partridge');

_Map_에 없는 키를 찾으면 null이 반환됩니다.

var gifts = {'first': 'partridge'};
assert(gifts['fifth'] == null);

.length를 사용하여 _Map_에서 키-값 쌍의 수를 가져옵니다

var gifts = {'first': 'partridge'};
gifts['fourth'] = 'calling birds';
assert(gifts.length == 2);

컴파일타임 상수 인 Map_을 만들려면 _Map 리터럴 앞에 const를 추가합니다.

final constantMap = const {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

// constantMap[2] = 'Helium'; // Uncommenting this causes an error.

Dart 2.3부터 Map_은 _List 마찬가지로 스프레드 연산자 (... 및 ...?) 및 수집을 지원합니다. 자세한 내용과 예시는 스프레드 운영자 제안 및 제어 흐름 수집 제안을 참조하십시오.

_Map_에 대한 자세한 내용은 제네릭 및 Map을 참조하십시오.

Runes and grpheme clusters

Dart에서 _Rune_은 문자열의 유니코드 코드포인트를 노출합니다. Dart 2.6부터는 문자 패키지를 사용하여 유니 코드 (확장) 자소 클러스터라고도하는 사용자 인식 문자를 보거나 조작합니다.

유니코드는 전 세계의 모든 문자 체계에서 사용되는 각 문자, 숫자 및 기호에 대해 고유 한 숫자 값을 정의합니다. Dart 문자열은 일련의 UTF-16 코드 단위이므로 문자열 내에서 유니코드 코드포인트를 표현하려면 특수 구문이 필요합니다. 유니코드 코드포인트를 표현하는 일반적인 방법은 \uXXXX입니다. 여기서 XXXX는 4 자리 16진수 값입니다. 예를 들어 하트 (♥)는 \u2665입니다. 4자리 이하의 16진수를 지정하려면 값을 중괄호 안에 넣으십시오. 예를 들어 웃는 이모티콘 (😆)은 \u{1f606}입니다.

개별 유니 코드 문자를 읽거나 써야하는 경우 characters 패키지에 의해 String에 정의 된 문자 getter를 사용하십시오. 반환 된 Characters 객체는 문자 소 클러스터의 시퀀스로서의 문자열입니다. 다음은 characters API 사용의 예입니다.

import 'package:characters/characters.dart';
...
var hi = 'Hi 🇩🇰';
print(hi);
print('The end of the string: ${hi.substring(hi.length - 1)}');
print('The last character: ${hi.characters.last}\n');

환경에 따라 출력은 다음과 같습니다.

문자 패키지를 사용하여 문자열을 조작하는 방법에 대한 자세한 내용은 문자 패키지의 예제 및 API 참조를 참조하십시오.

Symbols

Symbol 객체는 Dart 프로그램에서 선언 된 연산자 또는 식별자를 나타냅니다. 기호를 사용할 필요는 없지만 이름으로 식별자를 참조하는 API에는 매우 유용합니다. 축소화는 식별자 이름을 변경하지만 식별자 기호는 변경하지 않기 때문입니다.

식별자에 대한 기호를 얻으려면 기호 리터럴을 사용하십시오. 기호 리터럴은 # 뒤에 식별자가옵니다.

#radix
#bar
// Symbol 리터럴은 컴파일 타임 상수입니다.

간단한 다트 프로그램

// 함수의 정의
printInteger(int aNumber) {
  print('The number is $aNumber.'); 
  // print(~)로 콘솔에 출력
  // 문자열 안에 "$변수명"으로 변수를 출력가능
}

// dart의 메인 함수
main() {
  var number = 42; 
  // 변수 선언/초기화
  // dart에는 JS와 같이 var가 있음
  printInteger(number); // 함수 호출
}

중요 개념

Dart에 대해 알아야할 개념을 간단히 살펴보자

• 변수에 넣을 수 있는 모든 것은 _객체_이고, 모든 객체는 _클래스_의 인스턴스이다. 심지어 숫자, 함수, null도 객체이다. 모든 객체들은 Object클래스를 상속한다.
• Dart는 타입이 강력히 정해져있지만, 타입 명시는 Dart는 유형을 추론할 수 있을 땐 선택사항입니다. 예상되는 유형이 없다고 명시적으로 말하려면 특수 유형 dynamic을 사용하십시오.
• Dart는 List<int>또는 List<dynamic>과 같은 관용적인 타입을 지원합니다.
• Dart는 최상위 함수(main())과 클래스 또는 객체에 연결된 함수(각각 정적 및 인스턴스 메서드)를 지원합니다. 함수 내에서 함수 (중첩 또는 로컬 함수)를 만들 수도 있습니다.
• 마찬가지로 Dart는 최상위 변수와 클래스 또는 객체에 연결된 변수 (정적 및 인스턴스 변수)를 지원합니다. 인스턴스 변수는 필드 또는 _속성_이라고도 합니다.
• Java와 달리 Dart에는 public,protected, private 키워드가 없습니다. 식별자가 밑줄(_)로 시작하면 라이브러리에 비공개입니다.
• 식별자는 문자 또는 밑줄(_)로 시작하고 그 뒤에 해당 문자와 숫자의 조합이 올 수 있습니다.
• Dart에는 표현식(런타임 값이 있음)과 구문(없음)이 모두 있습니다.

  이는 JS에서의 함수표현식과 함수선언식과 비슷합니다. 예를 들어, condition ? exprTrue : exprFalse의 값은 exprTrue 또는 exprFalse입니다. 런타임 값이 없는 if-else문과 비교하십시오.

• 구문은 종종 하나 이상의 표현식을 포함하지만, 표현식은 구문을 포함할 수 없습니다.
• Dart 도구는 _경고_와 _오류_의 두가지 문제를 보고할 수 있습니다. _경고_는 코드가 작동하지 않을 수도 잇음을 나타내는 것일 뿐, 프로그램 실행을 방해하지 않습니다. _오류_는 컴파일 타임 또는 런타임일 수 있습니다. 컴파일 타임 오류는 코드가 전혀 실행되지 않습니다. 런타임 오류는 코드가 실행되는 동안 예외가 발생합니다.

키워드

참조 : https://dart.dev/guides/language/language-tour#keywords