다트 프로그래밍-퀵 가이드

Dart는 선택적으로 JavaScript로 컴파일 할 수있는 C 스타일 구문을 사용하는 객체 지향 언어입니다. 인터페이스, 클래스, 컬렉션, 제네릭 및 선택적 입력과 같은 다양한 프로그래밍 지원을 지원합니다.

Dart는 단일 페이지 애플리케이션을 만드는 데 광범위하게 사용될 수 있습니다. 단일 페이지 응용 프로그램은 웹 사이트 및 웹 응용 프로그램에만 적용됩니다. 단일 페이지 애플리케이션을 사용하면 브라우저에서 다른 웹 페이지를로드하지 않고도 웹 사이트의 여러 화면 사이를 탐색 할 수 있습니다. 전형적인 예는GMail ─받은 편지함에서 메시지를 클릭하면 브라우저는 동일한 웹 페이지에 유지되지만 JavaScript 코드는받은 편지함을 숨기고 메시지 본문을 화면에 표시합니다.

Google은 Chromium – Dart VM. Dartium을 사용하면 다른 브라우저에서 테스트 할 준비가 될 때까지 코드를 JavaScript로 컴파일 할 필요가 없습니다.

다음 표는 Dart와 JavaScript의 기능을 비교합니다.

특색 다트 자바 스크립트
유형 시스템 선택적, 동적 약하고 동적
클래스 예, 단일 상속 프로토 타입
인터페이스 예, 여러 인터페이스 아니
동시성 예, 분리 물 포함 예, HTML5 웹 작업자 사용

이 튜토리얼은 Dart 프로그래밍 언어에 대한 기본적인 수준의 이해를 제공합니다.

이 장에서는 Windows 플랫폼에서 Dart의 실행 환경을 설정하는 방법에 대해 설명합니다.

DartPad로 온라인 스크립트 실행

온라인 편집기를 사용하여 스크립트를 온라인으로 테스트 할 수 있습니다. https://dartpad.dartlang.org/. Dart 편집기는 스크립트를 실행하고 HTML과 콘솔 출력을 모두 표시합니다. 온라인 편집기는 사전 설정 코드 샘플 세트와 함께 제공됩니다.

의 스크린 샷 Dartpad 편집자는 아래에 주어진다-

Dartpad는 또한 더 제한적인 방식으로 코딩 할 수 있습니다. 에디터 오른쪽 하단의 Strong 모드 옵션을 선택하면됩니다. 강력한 모드는 다음과 같은 도움이됩니다.

  • 보다 강력한 정적 및 동적 검사
  • 더 나은 상호 운용성을위한 관용적 JavaScript 코드 생성.

Dartpad를 사용하여 다음 예제를 시도해 볼 수 있습니다.

void main() { 
   print('hello world'); 
}

코드는 다음 출력을 표시합니다.

hello world

로컬 환경 설정

이 섹션에서는 로컬 환경을 설정하는 방법을 살펴 보겠습니다.

텍스트 편집기 사용

몇 가지 편집기의 예로는 Windows Notepad, Notepad ++, Emacs, vim 또는 vi 등이 있습니다. 편집기는 운영 체제마다 다를 수 있습니다. 소스 파일의 이름은 일반적으로 ".dart"확장자로 지정됩니다.

Dart SDK 설치

현재 안정된 버전의 Dart는 1.21.0. 그만큼dart sdk -에서 다운로드 할 수 있습니다.

  • https://www.dartlang.org/install/archive

  • http://www.gekorm.com/dart-windows/

Dart SDK 설치의 스크린 샷은 다음과 같습니다.

SDK 설치가 완료되면 PATH 환경 변수를-

<dart-sdk-path>\bin

설치 확인

Dart가 성공적으로 설치되었는지 확인하려면 명령 프롬프트를 열고 다음 명령을 입력하십시오.

Dart

설치에 성공하면 dart 런타임이 표시됩니다.

IDE 지원

수많은 IDE가 Dart에서 스크립팅을 지원합니다. 예는 다음과 같습니다.Eclipse, IntelliJ, 및 WebStorm 제트 두뇌에서.

다음은 다음을 사용하여 Dart 환경을 구성하는 단계입니다. WebStrom IDE.

WebStorm 설치

WebStorm 용 설치 파일은 다음 위치에서 다운로드 할 수 있습니다. https://www.jetbrains.com/webstorm/download/#section=windows-version.

WebStorm 설치 파일은 Mac OS, Windows 및 Linux에서 사용할 수 있습니다.

설치 파일을 다운로드 한 후 아래 단계를 따르십시오.

  • Dart SDK 설치 : 위에 나열된 단계를 참조하십시오.

  • 새 Dart 프로젝트를 만들고 Dart 지원 구성

  • 새 Dart 프로젝트를 생성하려면

    • 딸깍 하는 소리 Create New Project 시작 화면에서

    • 다음 대화 상자에서 Dart

  • 에 지정된 값이없는 경우 Dart SDK경로를 입력 한 다음 SDK 경로를 제공하십시오. 예를 들어 SDK 경로는<dart installation directory>/dart/dartsdk.

프로젝트에 Dart 파일 추가

프로젝트에 Dart 파일을 추가하려면-

  • 프로젝트를 마우스 오른쪽 버튼으로 클릭하십시오.
  • 신규 → 다트 파일
  • Dart 스크립트의 이름을 입력하십시오.

WebStorm 편집기의 스크린 샷은 다음과 같습니다.

dart2js 도구

그만큼 dart2js도구는 Dart 코드를 JavaScript로 컴파일합니다. Dart 코드를 JS로 컴파일하면 Dart VM을 지원하지 않는 브라우저에서 Dart 스크립트를 실행할 수 있습니다.

dart2js 도구는 Dart SDK의 일부로 제공되며 다음에서 찾을 수 있습니다. /dartsdk/bin folder.

Dart를 JavaScript로 컴파일하려면 터미널에 다음 명령을 입력하십시오.

dart2js - - out = <output_file>.js  <dart_script>.dart

이 명령은 Dart 코드에 해당하는 JavaScript가 포함 된 파일을 생성합니다. 이 유틸리티 사용에 대한 전체 자습서는 공식 Dart 웹 사이트에서 찾을 수 있습니다.

구문은 프로그램 작성을위한 일련의 규칙을 정의합니다. 모든 언어 사양은 자체 구문을 정의합니다. Dart 프로그램은 다음과 같이 구성됩니다.

  • 변수와 연산자
  • Classes
  • Functions
  • 식 및 프로그래밍 구문
  • 의사 결정 및 반복 구조
  • Comments
  • 라이브러리 및 패키지
  • Typedefs
  • 컬렉션 / 제네릭으로 표현되는 데이터 구조

첫 번째 Dart 코드

전통적인 "Hello World"예제부터 시작하겠습니다.

main() { 
   print("Hello World!"); 
}

그만큼 main()함수는 Dart에서 미리 정의 된 방법입니다. 이 메서드는 응용 프로그램의 진입 점 역할을합니다. Dart 스크립트에는main() 실행 방법. print() 지정된 문자열 또는 값을 표준 출력 즉, 터미널에 인쇄하는 미리 정의 된 함수입니다.

위 코드의 출력은 다음과 같습니다.

Hello World!

Dart 프로그램 실행

두 가지 방법으로 Dart 프로그램을 실행할 수 있습니다.

  • 터미널을 통해
  • WebStorm IDE를 통해

터미널을 통해

터미널을 통해 Dart 프로그램을 실행하려면-

  • 현재 프로젝트의 경로로 이동
  • 터미널 창에 다음 명령을 입력하십시오.
dart file_name.dart

WebStorm IDE를 통해

WebStorm IDE를 통해 Dart 프로그램을 실행하려면-

  • IDE에서 Dart 스크립트 파일을 마우스 오른쪽 버튼으로 클릭합니다. (파일에는main() 실행을 가능하게하는 기능)

  • 클릭 ‘Run <file_name>’선택권. 동일한 스크린 샷이 아래에 나와 있습니다.

하나는 대안으로 클릭 할 수 있습니다

버튼 또는 바로 가기를 사용Ctrl+Shift+F10 Dart 스크립트를 실행합니다.

Dart 명령 줄 옵션

Dart 명령 줄 옵션은 Dart 스크립트 실행을 수정하는 데 사용됩니다. Dart의 일반적인 명령 줄 옵션은 다음과 같습니다.

Sr. 아니요 명령 줄 옵션 및 설명
1 -c or --c

어설 션 및 유형 검사를 모두 활성화합니다 (선택 모드).
2 --version

VM 버전 정보를 표시합니다.
삼 --packages <path>

패키지 확인 구성 파일의 경로를 지정합니다.
4 -p <path>

가져온 라이브러리를 찾을 위치를 지정합니다. 이 옵션은 --packages와 함께 사용할 수 없습니다.
5 -h or --help

도움말을 표시합니다.

체크 모드 활성화

Dart 프로그램은 두 가지 모드로 실행됩니다.

  • 체크 모드
  • 프로덕션 모드 (기본값)

Dart VM을 실행하는 것이 좋습니다. checked mode개발 및 테스트 중에 개발 및 디버깅 프로세스를 지원하기 위해 경고 및 오류를 추가하기 때문입니다. 선택 모드는 유형 검사 등과 같은 다양한 검사를 시행합니다. 선택 모드를 켜려면 스크립트를 실행하는 동안 스크립트 파일 이름 앞에 -c 또는 –-checked 옵션을 추가합니다.

그러나 스크립트를 실행하는 동안 성능 이점을 보장하려면 다음에서 스크립트를 실행하는 것이 좋습니다. production mode.

다음을 고려하세요 Test.dart 스크립트 파일-

void main() { 
   int n = "hello"; 
   print(n); 
}

다음을 입력하여 스크립트를 실행하십시오.

dart Test.dart

유형 불일치가 있더라도 체크 모드가 꺼지면 스크립트가 성공적으로 실행됩니다. 스크립트 결과는 다음과 같습니다.

hello

이제 "--선택"또는 "-c"옵션을 사용하여 스크립트를 실행 해보십시오.

dart -c Test.dart

또는,

dart - - checked Test.dart

Dart VM은 유형이 일치하지 않는다는 오류를 표시합니다.

Unhandled exception: 
type 'String' is not a subtype of type 'int' of 'n' where 
   String is from dart:core 
   int is from dart:core 
#0  main (file:///C:/Users/Administrator/Desktop/test.dart:3:9) 
#1  _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart :261) 
#2  _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

Dart의 식별자

식별자는 변수, 함수 등과 같은 프로그램의 요소에 부여되는 이름입니다. 식별자에 대한 규칙은 다음과 같습니다.

식별자에는 문자와 숫자가 모두 포함될 수 있습니다. 그러나 식별자는 숫자로 시작할 수 없습니다.

  • 식별자는 밑줄 (_) 또는 달러 기호 ($)를 제외한 특수 기호를 포함 할 수 없습니다.

  • 식별자는 키워드가 될 수 없습니다.

  • 고유해야합니다.

  • 식별자는 대소 문자를 구분합니다.

  • 식별자는 공백을 포함 할 수 없습니다.

다음 표는 유효하고 유효하지 않은 식별자의 몇 가지 예를 나열합니다.

유효한 식별자 잘못된 식별자
이름 Var
이름 이름
num1 이름
$ result 1 번호

Dart의 키워드

키워드는 언어 맥락에서 특별한 의미를 갖습니다. 다음 표는 Dart의 일부 키워드를 나열합니다.

초록 1 계속하다 그릇된 새로운 이
1로 기본 결정적인 없는 던지다
주장하다 지연 1 드디어 연산자 1 진실
비동기 2 하다 ...에 대한 1 부 시험
비동기 * 2 동적 1 1을 얻다 다시 던지다 typedef 1
2 기다립니다 그밖에 만약 반환 var
단절 열거 형 구현 1 세트 1 빈
케이스 수출 1 수입 1 정적 1 동안
잡기 외부 1 에 감독자 와
수업 연장하다 이다 스위치 수익률 2
const 공장 1 도서관 1 동기화 * 2 수율 * 2

공백 및 줄 바꿈

Dart는 프로그램에 나타나는 공백, 탭 및 줄 바꿈을 무시합니다. 프로그램에서 공백, 탭 및 줄 바꿈을 자유롭게 사용할 수 있으며 코드를 쉽게 읽고 이해할 수 있도록 깔끔하고 일관된 방식으로 프로그램을 형식화하고 들여 쓰기 할 수 있습니다.

Dart는 대소 문자를 구분합니다.

Dart는 대소 문자를 구분합니다. 이것은 Dart가 대문자와 소문자를 구분한다는 것을 의미합니다.

세미콜론으로 끝납니다.

각 명령 행을 명령문이라고합니다. 각 dart 문은 세미콜론 (;)으로 끝나야합니다. 한 줄에 여러 문을 포함 할 수 있습니다. 그러나 이러한 문은 세미콜론으로 구분해야합니다.

Dart의 댓글

주석은 프로그램의 가독성을 향상시키는 방법입니다. 주석은 코드 작성자, 함수 / 구조에 대한 힌트 등과 같은 프로그램에 대한 추가 정보를 포함하는 데 사용할 수 있습니다. 주석은 컴파일러에서 무시됩니다.

Dart는 다음 유형의 주석을 지원합니다.

  • Single-line comments ( // ) − "//"와 줄 끝 사이의 모든 텍스트는 주석으로 처리됩니다.

  • Multi-line comments (/* */) − 이러한 주석은 여러 줄에 걸쳐있을 수 있습니다.

예

// this is single line comment  
  
/* This is a   
   Multi-line comment  
*/

Dart의 객체 지향 프로그래밍

Dart는 객체 지향 언어입니다. Object Orientation은 실제 모델링을 따르는 소프트웨어 개발 패러다임입니다. 객체 지향은 프로그램을 메소드라는 메커니즘을 통해 서로 통신하는 객체 모음으로 간주합니다.

  • Object− 개체는 모든 개체의 실시간 표현입니다. Grady Brooch에 따르면 모든 개체에는 세 가지 기능이 있어야합니다.

    • State − 객체의 속성으로 설명됩니다.

    • Behavior − 물체가 어떻게 작동하는지 설명합니다.

    • Identity − 유사한 객체 세트와 객체를 구별하는 고유 한 값.

  • Class− OOP 측면에서 클래스는 객체 생성을위한 청사진입니다. 클래스는 객체에 대한 데이터를 캡슐화합니다.

  • Method − 방법은 객체 간의 의사 소통을 용이하게합니다.

예 : 다트 및 개체 방향

class TestClass {   
   void disp() {     
      print("Hello World"); 
   } 
}  
void main() {   
   TestClass c = new TestClass();   
   c.disp();  
}

위의 예는 클래스를 정의합니다. TestClass. 클래스에는 메소드가 있습니다.disp(). 이 메서드는 터미널에 "Hello World"문자열을 인쇄합니다. new 키워드는 클래스의 객체를 만듭니다. 객체는 메소드를 호출합니다.disp().

코드는 다음을 생성해야합니다. output −

Hello World

프로그래밍 언어의 가장 기본적인 특성 중 하나는 지원하는 데이터 유형 집합입니다. 이는 프로그래밍 언어로 표현하고 조작 할 수있는 값 유형입니다.

Dart 언어는 다음 유형을 지원합니다.

  • Numbers
  • Strings
  • Booleans
  • Lists
  • Maps

번호

Dart의 숫자는 숫자 리터럴을 나타내는 데 사용됩니다. 넘버 다트는 두 가지 종류가 있습니다.

  • Integer− 정수 값은 분수가 아닌 값, 즉 소수점이없는 숫자 값을 나타냅니다. 예를 들어 값 "10"은 정수입니다. 정수 리터럴은int 예어.

  • Double− Dart는 소수점이있는 값과 같은 분수 값도 지원합니다. Dart의 Double 데이터 유형은 64 비트 (배정 밀도) 부동 소수점 숫자를 나타냅니다. 예 : "10.10"값. 키워드double 부동 소수점 리터럴을 나타내는 데 사용됩니다.

문자열

문자열은 일련의 문자를 나타냅니다. 예를 들어, 이름, 주소 등과 같은 일부 데이터를 저장하려면 문자열 데이터 유형을 사용해야합니다. Dart 문자열은 일련의 UTF-16 코드 단위입니다.Runes UTF-32 코드 단위의 시퀀스를 나타내는 데 사용됩니다.

키워드 String문자열 리터럴을 나타내는 데 사용됩니다. 문자열 값은 작은 따옴표 또는 큰 따옴표로 포함됩니다.

부울

부울 데이터 유형은 부울 값 true 및 false를 나타냅니다. 다트는bool 부울 값을 나타내는 키워드입니다.

목록 및지도

데이터 유형 목록 및 맵은 개체 컬렉션을 나타내는 데 사용됩니다. ㅏList정렬 된 개체 그룹입니다. Dart의 List 데이터 유형은 다른 프로그래밍 언어의 배열 개념과 동의어입니다. 그만큼Map데이터 유형은 값 집합을 키-값 쌍으로 나타냅니다. 그만큼dart: core 라이브러리는 각각 미리 정의 된 List 및 Map 클래스를 통해 이러한 컬렉션을 만들고 조작 할 수 있도록합니다.

동적 유형

Dart는 선택적으로 입력되는 언어입니다. 변수 유형이 명시 적으로 지정되지 않은 경우 변수 유형은 다음과 같습니다.dynamic. 그만큼dynamic 키워드는 명시 적으로 유형 주석으로 사용할 수도 있습니다.

변수는 값을 저장하는 "메모리의 명명 된 공간"입니다. 즉, 프로그램에서 값에 대한 컨테이너 역할을합니다. 변수 이름을 식별자라고합니다. 다음은 식별자에 대한 명명 규칙입니다-

  • 식별자는 키워드가 될 수 없습니다.

  • 식별자에는 알파벳과 숫자가 포함될 수 있습니다.

  • 식별자는 밑줄 (_) 및 달러 ($) 기호를 제외하고 공백과 특수 문자를 포함 할 수 없습니다.

  • 변수 이름은 숫자로 시작할 수 없습니다.

유형 구문

변수는 사용하기 전에 선언해야합니다. Dart는 var 키워드를 사용하여 동일한 결과를 얻습니다. 변수를 선언하는 구문은 다음과 같습니다.

var name = 'Smith';

dart의 모든 변수는 값을 포함하지 않고 값에 대한 참조를 저장합니다. name이라는 변수는 값이 "Smith"인 String 개체에 대한 참조를 포함합니다.

다트 지원 type-checking변수 이름 앞에 데이터 유형을 추가합니다. 유형 검사는 변수가 데이터 유형에 특정한 데이터 만 보유하도록합니다. 동일한 구문은 다음과 같습니다.

String name = 'Smith'; 
int num = 10;

다음 예를 고려하십시오-

void main() { 
   String name = 1; 
}

위의 코드 조각은 변수에 할당 된 값이 변수의 데이터 유형과 일치하지 않기 때문에 경고를 발생시킵니다.

산출

Warning: A value of type 'String' cannot be assigned to a variable of type 'int'

초기화되지 않은 모든 변수는 초기 값이 null입니다. Dart는 모든 값을 객체로 간주하기 때문입니다. 다음 예제는 동일한 것을 보여줍니다-

void main() { 
   int num; 
   print(num); 
}

산출

Null

동적 키워드

정적 유형없이 선언 된 변수는 암시 적으로 동적으로 선언됩니다. var 키워드 대신 dynamic 키워드를 사용하여 변수를 선언 할 수도 있습니다.

다음 예제는 동일한 내용을 보여줍니다.

void main() { 
   dynamic x = "tom"; 
   print(x);  
}

산출

tom

최종 및 Const

그만큼 final 과 const키워드는 상수를 선언하는 데 사용됩니다. Dart는 final 또는 const 키워드를 사용하여 선언 된 변수의 값을 수정하는 것을 방지합니다. 이러한 키워드는 변수의 데이터 유형과 함께 사용하거나var 예어.

그만큼 const키워드는 컴파일 타임 상수를 나타내는 데 사용됩니다. 다음을 사용하여 선언 된 변수const 키워드는 암시 적으로 최종적입니다.

구문 : 최종 키워드

final variable_name

또는

final data_type  variable_name

구문 : const 키워드

const variable_name

또는

const data_type variable_name

예 – 최종 키워드

void main() { 
   final val1 = 12; 
   print(val1); 
}

산출

12

예 – const 키워드

void main() { 
   const pi = 3.14; 
   const area = pi*12*12; 
   print("The output is ${area}"); 
}

위의 예는 두 개의 상수를 선언합니다. pi 과 area, 사용 const예어. 그만큼area 변수의 값은 컴파일 타임 상수입니다.

산출

The output is 452.15999999999997

Note − 만 const변수를 사용하여 컴파일 시간 상수를 계산할 수 있습니다. 컴파일 시간 상수는 컴파일 시간에 값이 결정되는 상수입니다.

예

Dart에서 선언 된 변수를 수정하려고하면 예외가 발생합니다. final또는 const 키워드. 아래 주어진 예는 같은 것을 설명합니다-

void main() { 
   final v1 = 12; 
   const v2 = 13; 
   v2 = 12; 
}

위에 주어진 코드는 다음과 같은 오류를 발생시킵니다. output −

Unhandled exception: 
cannot assign to final variable 'v2='.  
NoSuchMethodError: cannot assign to final variable 'v2=' 
#0  NoSuchMethodError._throwNew (dart:core-patch/errors_patch.dart:178) 
#1      main (file: Test.dart:5:3) 
#2    _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#3    _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

식은 값으로 평가되는 특수한 종류의 문입니다. 모든 표현은-

  • Operands − 데이터를 나타냅니다.

  • Operator − 값을 생성하기 위해 피연산자가 처리되는 방식을 정의합니다.

다음 표현식을 고려하십시오 – "2 + 3". 이 식에서 2와 3은operands 기호 "+"(더하기)는 operator.

이 장에서는 Dart에서 사용할 수있는 연산자에 대해 설명합니다.

  • 산술 연산자
  • 평등 및 관계 연산자
  • 유형 테스트 연산자
  • 비트 연산자
  • 할당 연산자
  • 논리 연산자

산술 연산자

다음 표는 Dart에서 지원하는 산술 연산자를 보여줍니다.

예시보기

Sr. 아니요 연산자 및 의미
1 +

더하다
2 −

덜다
삼 -expr

부정이라고도하는 단항 마이너스 (표현식의 부호 반전)
4 *

곱하다
5 /

나누기
6 ~/

나누기, 정수 결과 반환
7 %

정수 나눗셈의 나머지를 가져옵니다 (모듈로).
8 ++

증가
9 --

감소

평등 및 관계 연산자

관계 연산자는 두 항목 간의 관계 유형을 테스트하거나 정의합니다. 관계 연산자는 부울 값, 즉 true / false를 반환합니다.

A의 값이 10이고 B가 20이라고 가정합니다.

예시보기

운영자 기술 예
> 보다 큰 (A> B)는 False입니다.
< 보다 작음 (A <B)는 참입니다
> = 크거나 같음 (A> = B)는 False입니다.
<= 작거나 같음 (A <= B)는 참입니다
== 평등 (A == B)는 False입니다.
! = 같지 않음 (A! = B)는 참입니다

유형 테스트 연산자

이러한 연산자는 런타임에 유형을 확인하는 데 편리합니다.

예시보기

운영자 의미
이다 객체에 지정된 유형이 있으면 참
이다! 객체에 지정된 유형이있는 경우 False

비트 연산자

다음 표는 Dart에서 사용할 수있는 비트 연산자와 그 역할을 나열합니다.

예시보기

운영자 기술 예
비트 AND a & b 두 피연산자의 해당 비트가 1 인 각 비트 위치에서 1을 반환합니다.
비트 OR a | 비 피연산자 중 하나 또는 둘 다의 해당 비트가 1 인 각 비트 위치에서 1을 반환합니다.
비트 XOR a ^ b 두 피연산자 중 하나만 해당하는 비트가 1 인 각 비트 위치에서 1을 반환합니다.
비트 NOT ~ a 피연산자의 비트를 반전합니다.
왼쪽 시프트 a ≪ b 이진 표현 b (<32) 비트에서 a를 왼쪽으로 이동하고 오른쪽에서 0으로 이동합니다.
오른쪽 시프트 전파 a ≫ b 이진 표현 b (<32) 비트에서 a를 오른쪽으로 이동하여 이동 한 비트를 버립니다.

할당 연산자

다음 표는 Dart에서 사용할 수있는 할당 연산자를 나열합니다.

예시보기

Sr. 아니요 연산자 및 설명
1 =(Simple Assignment )

오른쪽 피연산자의 값을 왼쪽 피연산자에 할당합니다.

Ex: C = A + B는 A + B의 값을 C에 할당합니다.
2 ??=

변수가 널인 경우에만 값을 지정하십시오.
삼 +=(Add and Assignment)

왼쪽 피연산자에 오른쪽 피연산자를 추가하고 결과를 왼쪽 피연산자에 할당합니다.

Ex: C + = A는 C = C + A와 같습니다.

4 ─=(Subtract and Assignment)

왼쪽 피연산자에서 오른쪽 피연산자를 빼고 결과를 왼쪽 피연산자에 할당합니다.

Ex: C-= A는 C = C – A와 동일합니다.
5 *=(Multiply and Assignment)

오른쪽 피연산자와 왼쪽 피연산자를 곱하고 결과를 왼쪽 피연산자에 할당합니다.

Ex: C * = A는 C = C * A와 동일합니다.
6 /=(Divide and Assignment)

왼쪽 피연산자를 오른쪽 피연산자로 나누고 결과를 왼쪽 피연산자에 할당합니다.

Note − Bitwise 연산자에도 동일한 논리가 적용되므로 ≪ =, ≫ =, ≫ =, ≫ =, | = 및 ^ =가됩니다.

논리 연산자

논리 연산자는 둘 이상의 조건을 결합하는 데 사용됩니다. 논리 연산자는 부울 값을 반환합니다. 변수 A의 값이 10이고 B가 20이라고 가정합니다.

예시보기

운영자 기술 예
&&

And − 연산자는 지정된 모든 표현식이 참을 반환하는 경우에만 참을 반환합니다.

 (A> 10 && B> 10)은 거짓입니다.
||

OR − 연산자는 지정된 표현식 중 하나 이상이 참을 반환하면 참을 반환합니다.

 (A> 10 || B> 10)은 참입니다.
!

NOT− 연산자는 식 결과의 역을 반환합니다. 예 :! (7> 5)는 false를 반환합니다.

 ! (A> 10)은 True입니다.

조건식

Dart에는 ifelse 문이 필요할 수있는 표현식을 평가할 수있는 두 개의 연산자가 있습니다.

질환 ? expr1 : expr2

조건이 참이면 표현식은 다음을 평가합니다. expr1(그리고 그 값을 반환합니다); 그렇지 않으면 다음 값을 평가하고 반환합니다.expr2.

expr1 ?? expr2

만약 expr1null이 아닌 경우 해당 값을 반환합니다. 그렇지 않으면 다음 값을 평가하고 반환합니다.expr2

예

다음 예제는 Dart에서 조건식을 사용하는 방법을 보여줍니다.

void main() { 
   var a = 10; 
   var res = a > 12 ? "value greater than 10":"value lesser than or equal to 10"; 
   print(res); 
}

다음 출력을 생성합니다-

value lesser than or equal to 10

예

다른 예를 들어 보겠습니다.

void main() { 
   var a = null; 
   var b = 12; 
   var res = a ?? b; 
   print(res); 
}

다음 출력을 생성합니다-

12

때때로 특정 명령은 반복 실행이 필요합니다. 루프는 동일한 작업을 수행하는 이상적인 방법입니다. 루프는 반복해야하는 명령어 세트를 나타냅니다. 루프의 맥락에서 반복은iteration.

다음 그림은 루프의 분류를 보여줍니다-

Definite Loops로 토론을 시작하겠습니다. 반복 횟수가 확정 / 고정 된 루프는definite loop.

Sr. 아니요 루프 및 설명
1 for 루프

그만큼 for루프는 명확한 루프의 구현입니다. for 루프는 지정된 횟수만큼 코드 블록을 실행합니다. 배열과 같은 고정 된 값 집합을 반복하는 데 사용할 수 있습니다.
2 for… in 루프

for ... in 루프는 객체의 속성을 반복하는 데 사용됩니다.

계속해서 이제 무한 루프에 대해 논의 해 보겠습니다. 무한 루프는 루프의 반복 횟수가 불확실하거나 알 수없는 경우에 사용됩니다. 무한 루프는 다음을 사용하여 구현할 수 있습니다.

Sr. 아니요 루프 및 설명
1 while 루프

while 루프는 지정된 조건이 참으로 평가 될 때마다 명령을 실행합니다. 즉, 루프는 코드 블록이 실행되기 전에 조건을 평가합니다.
2 do… while 루프

do ... while 루프는 do ... while 루프가 루프가 처음 실행될 때 조건을 평가하지 않는다는 점을 제외하고 while 루프와 유사합니다.

이제 계속해서 Loop Control Statements 다트

Sr. 아니요 제어문 및 설명
1 break 문

그만큼 break문은 구문에서 제어를 가져 오는 데 사용됩니다. 사용break루프에서 프로그램이 루프를 종료합니다. 다음은break 성명서.
2 계속 진술

그만큼 continue 문은 현재 반복에서 후속 문을 건너 뛰고 제어를 루프의 시작 부분으로 되돌립니다.

레이블을 사용하여 흐름 제어

ㅏ label문이나 코드 블록에 적용되는 단순히 식별자 뒤에 콜론 (:)이 붙습니다. 레이블은 다음과 함께 사용할 수 있습니다.break 과 continue 흐름을보다 정확하게 제어합니다.

줄 바꿈은 ‘continue’ 또는 ‘break’문 및 레이블 이름. 또한 레이블 이름과 관련 루프 사이에 다른 문이 없어야합니다.

예 : 구분이있는 레이블

void main() { 
   outerloop: // This is the label name 
   
   for (var i = 0; i < 5; i++) { 
      print("Innerloop: ${i}"); innerloop: for (var j = 0; j < 5; j++) { if (j > 3 ) break ; // Quit the innermost loop if (i == 2) break innerloop; // Do the same thing if (i == 4) break outerloop; // Quit the outer loop print("Innerloop: ${j}"); 
      } 
   } 
}

다음과 같은 output 위 코드가 성공적으로 실행되면이 표시됩니다.

Innerloop: 0
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 1
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 2
Innerloop: 3
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 4

예 : 계속 레이블

void main() { 
   outerloop: // This is the label name 
   
   for (var i = 0; i < 3; i++) { 
      print("Outerloop:${i}"); for (var j = 0; j < 5; j++) { if (j == 3){ continue outerloop; } print("Innerloop:${j}"); 
      } 
   } 
}

위 코드가 성공적으로 실행되면 다음 출력이 표시됩니다.

Outerloop: 0 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2 

Outerloop: 1 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2 

Outerloop: 2 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2

조건부 / 의사 결정 구조는 명령이 실행되기 전에 조건을 평가합니다.

Dart의 조건부 구성은 다음 표에 분류됩니다.

Sr. 아니요 성명 및 설명
1 if 성명서

안 if 문은 부울 식과 하나 이상의 문으로 구성됩니다.
2 If ... Else 문

안 if 뒤에 선택 사항이 올 수 있습니다. else블록. 그만큼else 블록은 Boolean 표현식이 if 블록은 거짓으로 평가됩니다.
삼 그렇지 않으면… 사다리라면

그만큼 else…if ladder여러 조건을 테스트하는 데 유용합니다. 다음은 동일한 구문입니다.
4 switch… case 문

switch 문은 식을 평가하고 식의 값을 case 절에 일치시키고 해당 case와 관련된 문을 실행합니다.

다트 번호는 다음과 같이 분류 할 수 있습니다.

  • int− 임의 크기의 정수. 그만큼int 데이터 유형은 정수를 나타내는 데 사용됩니다.

  • double− IEEE 754 표준에 지정된 64 비트 (배정 밀도) 부동 소수점 숫자. 그만큼double 데이터 유형은 분수를 나타내는 데 사용됩니다.

그만큼 num 유형은 int 과 double유형. 그만큼dart core library 숫자 값에 대한 수많은 작업을 허용합니다.

숫자를 선언하는 구문은 다음과 같습니다.

int var_name;      // declares an integer variable 
double var_name;   // declares a double variable

예

void main() {
   // declare an integer
   int num1 = 10;             
     
   // declare a double value
   double num2 = 10.50;  

   // print the values
   print(num1);
   print(num2);
}

다음 출력을 생성합니다-

10 
10.5

Note − Dart VM 분수 값이 정수 변수에 할당되면 예외가 발생합니다.

파싱

그만큼 parse()정적 함수를 사용하면 숫자 리터럴이 포함 된 문자열을 숫자로 구문 분석 할 수 있습니다. 다음 그림은 동일한 것을 보여줍니다-

void main() { 
   print(num.parse('12')); 
   print(num.parse('10.91')); 
}

위의 코드는 다음과 같이 출력됩니다.

12 
10.91

구문 분석 함수는 FormatException숫자 이외의 값이 전달 된 경우. 다음 코드는 영숫자 값을parse() 함수.

예

void main() { 
   print(num.parse('12A')); 
   print(num.parse('AAAA')); 
}

위의 코드는 다음과 같이 출력됩니다.

Unhandled exception: 
FormatException: 12A 
#0 num.parse (dart:core/num.dart:446) 
#1 main (file:///D:/Demos/numbers.dart:4:13) 
#2 _startIsolate.<anonymous closure> (dart:isolatepatch/isolate_patch.dart:261) 
#3 _RawReceivePortImpl._handleMessage (dart:isolatepatch/isolate_patch.dart:148)

숫자 속성

다음 표는 Dart 번호에서 지원하는 속성을 나열합니다.

Sr. 아니요 속성 및 설명
1 해시 코드

숫자 값에 대한 해시 코드를 반환합니다.
2 isFinite

숫자가 유한 한 경우 참; 그렇지 않으면 거짓입니다.
삼 isInfinite

숫자가 양의 무한대 또는 음의 무한대이면 참입니다. 그렇지 않으면 거짓입니다.
4 isNan

숫자가 이중 Not-a-Number 값이면 참; 그렇지 않으면 거짓입니다.
5 isNegative

숫자가 음수이면 참; 그렇지 않으면 거짓입니다.
6 기호

숫자의 부호와 숫자 값에 따라 마이너스 1, 0 또는 플러스 1을 반환합니다.
7 짝수이다

숫자가 짝수이면 true를 반환합니다.
8 isOdd

숫자가 홀수이면 true를 반환합니다.

번호 방법

다음은 숫자로 지원되는 일반적으로 사용되는 방법 목록입니다.

Sr. 아니요 방법 및 설명
1 복근

숫자의 절대 값을 반환합니다.
2 올림

숫자보다 작지 않은 최소 정수를 반환합니다.
삼 compareTo

이것을 다른 숫자와 비교합니다.
4 바닥

현재 숫자보다 크지 않은 가장 큰 정수를 반환합니다.
5 나머지

두 숫자를 나눈 후 잘린 나머지를 반환합니다.
6 일주

현재 숫자에 가장 가까운 정수를 반환합니다.
7 toDouble

숫자에 해당하는 double을 반환합니다.
8 toInt

숫자에 해당하는 정수를 반환합니다.
9

숫자에 해당하는 문자열 표현을 반환합니다.
10 자르다

소수 자릿수를 제거한 후 정수를 반환합니다.

문자열 데이터 유형은 일련의 문자를 나타냅니다. Dart 문자열은 일련의 UTF 16 코드 단위입니다.

Dart의 문자열 값은 작은 따옴표 나 큰 따옴표 또는 삼중 따옴표를 사용하여 나타낼 수 있습니다. 단일 라인 문자열은 작은 따옴표 또는 큰 따옴표를 사용하여 표시됩니다. 삼중 따옴표는 여러 줄 문자열을 나타내는 데 사용됩니다.

Dart에서 문자열 값을 나타내는 구문은 다음과 같습니다.

통사론

String  variable_name = 'value'  

OR  

String  variable_name = ''value''  

OR  

String  variable_name = '''line1 
line2'''  

OR  

String  variable_name= ''''''line1 
line2''''''

다음 예제는 Dart에서 문자열 데이터 유형의 사용을 보여줍니다.

void main() { 
   String str1 = 'this is a single line string'; 
   String str2 = "this is a single line string"; 
   String str3 = '''this is a multiline line string'''; 
   String str4 = """this is a multiline line string"""; 
   
   print(str1);
   print(str2); 
   print(str3); 
   print(str4); 
}

다음을 생성합니다. Output −

this is a single line string 
this is a single line string 
this is a multiline line string 
this is a multiline line string

문자열은 변경할 수 없습니다. 그러나 문자열은 다양한 연산을받을 수 있으며 결과 문자열은 새 값으로 저장 될 수 있습니다.

문자열 보간

정적 문자열에 값을 추가하여 새 문자열을 만드는 프로세스를 다음과 같이합니다. concatenation 또는 interpolation. 즉, 다른 문자열에 문자열을 추가하는 과정입니다.

연산자 더하기 (+)는 문자열을 연결 / 보간하는 데 일반적으로 사용되는 메커니즘입니다.

예 1

void main() { 
   String str1 = "hello"; 
   String str2 = "world"; 
   String res = str1+str2; 
   
   print("The concatenated string : ${res}"); 
}

다음을 생성합니다. output −

The concatenated string : Helloworld

예 2

"$ {}"를 사용하여 문자열 내에서 Dart 표현식의 값을 보간 할 수 있습니다. 다음 예제는 동일한 내용을 보여줍니다.

void main() { 
   int n=1+1; 
   
   String str1 = "The sum of 1 and 1 is ${n}"; print(str1); String str2 = "The sum of 2 and 2 is ${2+2}"; 
   print(str2); 
}

다음을 생성합니다. output −

The sum of 1 and 1 is 2 
The sum of 2 and 2 is 4

문자열 속성

다음 표에 나열된 속성은 모두 읽기 전용입니다.

Sr. 아니요 속성 및 설명
1 codeUnits

이 문자열의 UTF-16 코드 단위의 수정 불가능한 목록을 리턴합니다.
2 비었다

이 문자열이 비어 있으면 true를 반환합니다.
삼 길이

공백, 탭 및 개행 문자를 포함한 문자열의 길이를 반환합니다.

문자열을 조작하는 방법

의 String 클래스 dart: core library또한 문자열을 조작하는 방법을 제공합니다. 이러한 방법 중 일부는 다음과 같습니다.

Sr. 아니요 방법 및 설명
1 toLowerCase ()

이 문자열의 모든 문자를 소문자로 변환합니다.
2 toUpperCase ()

이 문자열의 모든 문자를 대문자로 변환합니다.
삼 손질()

선행 및 후행 공백없이 문자열을 반환합니다.
4 compareTo ()

이 개체를 다른 개체와 비교합니다.
5 모두 다 바꿔()

지정된 패턴과 일치하는 모든 하위 문자열을 지정된 값으로 바꿉니다.
6 스플릿()

지정된 구분 기호와 일치하는 부분에서 문자열을 분할하고 하위 문자열 목록을 반환합니다.
7 부분 문자열 ()

startIndex (포함)에서 endIndex (포함)까지 확장되는이 문자열의 하위 문자열을 반환합니다.
8 toString ()

이 객체의 문자열 표현을 반환합니다.
9 codeUnitAt ()

주어진 인덱스에서 16 비트 UTF-16 코드 단위를 반환합니다.

Dart는 부울 데이터 유형에 대한 내장 지원을 제공합니다. DART의 부울 데이터 유형은 true와 false의 두 값만 지원합니다. 키워드 bool은 DART에서 부울 리터럴을 나타내는 데 사용됩니다.

DART에서 부울 변수를 선언하는 구문은 다음과 같습니다.

bool var_name = true;  
OR  
bool var_name = false

예

void main() { 
   bool test; 
   test = 12 > 5; 
   print(test); 
}

다음을 생성합니다. output −

true

예

JavaScript와 달리 Boolean 데이터 유형은 리터럴 true 만 true로 인식합니다. 다른 값은 거짓으로 간주됩니다. 다음 예를 고려하십시오-

var str = 'abc'; 
if(str) { 
   print('String is not empty'); 
} else { 
   print('Empty String'); 
}

위의 스 니펫은 JavaScript에서 실행되는 경우 if 구문이 문자열이 비어 있지 않은 경우 true를 반환하므로 'String is not empty'메시지를 인쇄합니다.

그러나 Dart에서는 strstr! = true 로 false로 변환됩니다 . 따라서 스 니펫은 '빈 문자열' 메시지를 인쇄합니다 (선택되지 않은 모드에서 실행될 때).

예

실행되는 경우 위의 스 니펫 checked모드는 예외를 발생시킵니다. 동일한 내용이 아래에 설명되어 있습니다.

void main() { 
   var str = 'abc'; 
   if(str) { 
      print('String is not empty'); 
   } else { 
      print('Empty String'); 
   } 
}

다음을 생성합니다. output, 에 Checked Mode −

Unhandled exception: 
type 'String' is not a subtype of type 'bool' of 'boolean expression' where 
   String is from dart:core 
   bool is from dart:core  
#0 main (file:///D:/Demos/Boolean.dart:5:6) 
#1 _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#2 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

다음을 생성합니다. output, 에 Unchecked Mode −

Empty String

Note − WebStorm IDE는 기본적으로 선택 모드로 실행됩니다.

프로그래밍에서 매우 일반적으로 사용되는 컬렉션은 array. Dart는 다음과 같은 형태로 배열을 나타냅니다.List사물. ㅏList단순히 정렬 된 개체 그룹입니다. 그만큼dart:core 라이브러리는 목록을 만들고 조작 할 수있는 List 클래스를 제공합니다.

Dart에서 목록의 논리적 표현은 다음과 같습니다.

  • test_list − 컬렉션을 참조하는 식별자입니다.

  • 목록에는 값 12, 13 및 14가 포함되어 있습니다. 이러한 값을 보유하는 메모리 블록은 다음과 같이 알려져 있습니다. elements.

  • 목록의 각 요소는 index. 색인은zero 최대 확장 n-1 어디 n목록의 총 요소 수입니다. 색인은 또한subscript.

목록은 다음과 같이 분류 할 수 있습니다-

  • 고정 길이 목록
  • 성장 가능한 목록

이제이 두 가지 유형에 대해 논의하겠습니다. lists 상세히.

고정 길이 목록

고정 길이 목록의 길이는 런타임에 변경할 수 없습니다. 고정 길이 목록을 생성하는 구문은 다음과 같습니다.

Step 1 − Declaring a list

고정 길이 목록을 선언하는 구문은 다음과 같습니다.

var list_name = new List(initial_size)

위의 구문은 지정된 크기의 목록을 만듭니다. 목록은 런타임에 늘어나거나 줄어들 수 없습니다. 목록 크기를 조정하려고하면 예외가 발생합니다.

Step 2 − Initializing a list

목록을 초기화하는 구문은 다음과 같습니다.

lst_name[index] = value;

예

void main() { 
   var lst = new List(3); 
   lst[0] = 12; 
   lst[1] = 13; 
   lst[2] = 11; 
   print(lst); 
}

다음을 생성합니다. output −

[12, 13, 11]

성장 가능한 목록

확장 가능한 목록의 길이는 런타임에 변경 될 수 있습니다. 확장 가능한 목록을 선언하고 초기화하는 구문은 다음과 같습니다.

Step 1 − Declaring a List

var list_name = [val1,val2,val3]   
--- creates a list containing the specified values  
OR  
var list_name = new List() 
--- creates a list of size zero

Step 2 − Initializing a List

색인 / 아래 첨자는 값으로 채워야하는 요소를 참조하는 데 사용됩니다. 목록을 초기화하는 구문은 다음과 같습니다.

list_name[index] = value;

예

다음 예제는 3 개의 요소 목록을 작성하는 방법을 보여줍니다.

void main() { 
   var num_list = [1,2,3]; 
   print(num_list); 
}

다음을 생성합니다. output −

[1, 2, 3]

예

다음 예제에서는 다음을 사용하여 길이가 0 인 목록을 만듭니다. empty List() constructor. 그만큼add() 기능 List 클래스는 목록에 요소를 동적으로 추가하는 데 사용됩니다.

void main() { 
   var lst = new List(); 
   lst.add(12); 
   lst.add(13); 
   print(lst); 
}

다음을 생성합니다. output −

[12, 13]

목록 속성

다음 표에는 일반적으로 사용되는 List 클래스 dart:core library.

Sr. 아니요 방법 및 설명
1 먼저

첫 번째 요소 케이스를 반환합니다.
2 비었다

컬렉션에 요소가 없으면 true를 반환합니다.
삼 isNotEmpty

컬렉션에 요소가 하나 이상 있으면 true를 반환합니다.
4 길이

목록의 크기를 반환합니다.
5 마지막

목록의 마지막 요소를 반환합니다.
6 반전

역순으로 목록 값을 포함하는 반복 가능한 객체를 반환합니다.
7 단일

목록에 요소가 하나만 있는지 확인하고 반환합니다.

이 장에서는 다음과 같은 목록에 대한 몇 가지 기본 작업을 수행하는 방법에 대해 설명합니다.

Sr. 아니요 기본 작동 및 설명
1 목록에 요소 삽입

변경 가능한 목록은 런타임에 동적으로 증가 할 수 있습니다. 그만큼List.add() 함수는 지정된 값을 List 끝에 추가하고 수정 된 List 객체를 반환합니다.
2 목록 업데이트

Dart의 목록은 다음에 의해 업데이트 될 수 있습니다.

  • 인덱스 업데이트
  • List.replaceRange () 함수 사용
삼 목록 항목 제거

dart : core 라이브러리의 List 클래스에서 지원하는 다음 함수를 사용하여 목록에서 항목을 제거 할 수 있습니다.

Map 객체는 간단한 키 / 값 쌍입니다. 맵의 키와 값은 모든 유형이 될 수 있습니다. 지도는 동적 컬렉션입니다. 즉,지도는 런타임에 늘어나거나 줄어들 수 있습니다.

지도는 두 가지 방법으로 선언 할 수 있습니다.

  • 지도 리터럴 사용
  • 지도 생성자 사용

지도 리터럴을 사용하여지도 선언

맵 리터럴을 사용하여 맵을 선언하려면 한 쌍의 중괄호로 키-값 쌍을 묶어야합니다. "{ }".

여기에 syntax −

var identifier = { key1:value1, key2:value2 [,…..,key_n:value_n] }

지도 생성자를 사용하여지도 선언

Map 생성자를 사용하여 Map을 선언하려면 두 단계가 있습니다. 먼저지도를 선언하고 두 번째로지도를 초기화합니다.

그만큼 syntax ...에 declare a map 다음과 같습니다-

var identifier = new Map()

이제 다음 구문을 사용하여 initialize the map −

map_name[key] = value

예 :지도 리터럴

void main() { 
   var details = {'Usrname':'tom','Password':'pass@123'}; 
   print(details); 
}

다음을 생성합니다. output −

{Usrname: tom, Password: pass@123}

예 : 런타임시 맵 리터럴에 값 추가

void main() { 
   var details = {'Usrname':'tom','Password':'pass@123'}; 
   details['Uid'] = 'U1oo1'; 
   print(details); 
}

다음을 생성합니다. output −

{Usrname: tom, Password: pass@123, Uid: U1oo1}

예 :지도 생성자

void main() { 
   var details = new Map(); 
   details['Usrname'] = 'admin'; 
   details['Password'] = 'admin@123'; 
   print(details); 
}

다음을 생성합니다. output −

{Usrname: admin, Password: admin@123}

Note − 맵 값은 NULL을 포함한 모든 객체가 될 수 있습니다.

지도 – 속성

그만큼 Map dart : core 패키지의 클래스는 다음 속성을 정의합니다.

Sr. 아니요 속성 및 설명
1 키

키를 나타내는 반복 가능한 객체를 반환합니다.
2 가치

값을 나타내는 반복 가능한 객체를 반환합니다.
삼 길이

지도의 크기를 반환합니다.
4 비었다

지도가 빈지도이면 true를 반환합니다.
5 isNotEmpty

지도가 빈지도이면 true를 반환합니다.

지도-기능

다음은 Dart에서지도를 조작하는 데 일반적으로 사용되는 기능입니다.

Sr. 아니요 기능 이름 및 설명
1 addAll ()

다른 모든 키-값 쌍을이 맵에 추가합니다.
2 맑은()

맵에서 모든 쌍을 제거합니다.
삼 없애다()

지도에서 키 및 관련 값 (있는 경우)을 제거합니다.
4 각각()

맵의 각 키-값 쌍에 f를 적용합니다.

Dart의 심볼은 라이브러리에서 메타 데이터를 반영하는 데 사용되는 불투명하고 동적 문자열 이름입니다. 간단히 말해 기호는 사람이 읽을 수있는 문자열과 컴퓨터에서 사용하도록 최적화 된 문자열 간의 관계를 저장하는 방법입니다.

리플렉션은 클래스의 메서드 수, 생성자 수 또는 함수의 매개 변수 수와 같이 런타임에 유형의 메타 데이터를 가져 오는 메커니즘입니다. 런타임에로드되는 유형의 메서드를 호출 할 수도 있습니다.

Dart 리플렉션에서 특정 클래스는 dart:mirrors꾸러미. 이 라이브러리는 웹 애플리케이션과 명령 줄 애플리케이션 모두에서 작동합니다.

통사론

Symbol obj = new Symbol('name');  
// expects a name of class or function or library to reflect

그만큼 name 유효한 공개 Dart 멤버 이름, 공개 생성자 이름 또는 라이브러리 이름이어야합니다.

예

다음 예를 고려하십시오. 코드는 클래스를 선언합니다.Foo 도서관에서 foo_lib. 클래스는 메소드를 정의합니다.m1, m2, 과 m3.

Foo.dart

library foo_lib;   
// libarary name can be a symbol   

class Foo {         
   // class name can be a symbol  
   m1() {        
      // method name can be a symbol 
      print("Inside m1"); 
   } 
   m2() { 
      print("Inside m2"); 
   } 
   m3() { 
      print("Inside m3"); 
   } 
}

다음 코드가로드됩니다. Foo.dart라이브러리 및 기호 유형의 도움으로 Foo 클래스를 검색합니다. 위 라이브러리의 메타 데이터를 반영하고 있으므로 코드는dart:mirrors 도서관.

FooSymbol.dart

import 'dart:core'; 
import 'dart:mirrors'; 
import 'Foo.dart';  

main() { 
   Symbol lib = new Symbol("foo_lib");   
   //library name stored as Symbol 
   
   Symbol clsToSearch = new Symbol("Foo");  
   // class name stored as Symbol  
   
   if(checkIf_classAvailableInlibrary(lib, clsToSearch))  
   // searches Foo class in foo_lib library 
      print("class found.."); 
}  
   
bool checkIf_classAvailableInlibrary(Symbol libraryName, Symbol className) { 
   MirrorSystem mirrorSystem = currentMirrorSystem(); 
   LibraryMirror libMirror = mirrorSystem.findLibrary(libraryName); 
      
   if (libMirror != null) { 
      print("Found Library"); 
      print("checkng...class details.."); 
      print("No of classes found is : ${libMirror.declarations.length}"); 
      libMirror.declarations.forEach((s, d) => print(s));  
         
      if (libMirror.declarations.containsKey(className)) return true; 
      return false; 
   } 
}

줄 libMirror.declarations.forEach ((s, d) => print (s)); 런타임에 라이브러리의 모든 선언을 반복하고 선언을 다음 유형으로 인쇄합니다.Symbol.

이 코드는 다음을 생성해야합니다. output −

Found Library 
checkng...class details.. 
No of classes found is : 1 
Symbol("Foo") // class name displayed as symbol  
class found.

예 : 클래스의 인스턴스 메서드 수 표시

이제 클래스의 인스턴스 메서드 수를 표시하는 것을 고려해 보겠습니다. 미리 정의 된 클래스ClassMirror 우리가 같은 것을 성취하도록 도와줍니다.

import 'dart:core'; 
import 'dart:mirrors'; 
import 'Foo.dart';  

main() { 
   Symbol lib = new Symbol("foo_lib"); 
   Symbol clsToSearch = new Symbol("Foo");  
   reflect_InstanceMethods(lib, clsToSearch); 
}  
void reflect_InstanceMethods(Symbol libraryName, Symbol className) { 
   MirrorSystem mirrorSystem = currentMirrorSystem(); 
   LibraryMirror libMirror = mirrorSystem.findLibrary(libraryName); 
   
   if (libMirror != null) { 
      print("Found Library"); 
      print("checkng...class details.."); 
      print("No of classes found is : ${libMirror.declarations.length}"); 
      libMirror.declarations.forEach((s, d) => print(s));  
      
      if (libMirror.declarations.containsKey(className)) print("found class");
      ClassMirror classMirror = libMirror.declarations[className]; 
      
      print("No of instance methods found is ${classMirror.instanceMembers.length}");
      classMirror.instanceMembers.forEach((s, v) => print(s)); 
   } 
}

이 코드는 다음을 생성해야합니다. output −

Found Library 
checkng...class details.. 
No of classes found is : 1 
Symbol("Foo") 
found class 
No of instance methods found is 8 
Symbol("==") 
Symbol("hashCode") 
Symbol("toString") 
Symbol("noSuchMethod") 
Symbol("runtimeType") 
Symbol("m1") 
Symbol("m2") 
Symbol("m3")

기호를 문자열로 변환

기호에 저장된 클래스 또는 라이브러리와 같은 유형의 이름을 다시 문자열로 변환 할 수 있습니다. MirrorSystem수업. 다음 코드는 기호를 문자열로 변환하는 방법을 보여줍니다.

import 'dart:mirrors'; 
void main(){ 
   Symbol lib = new Symbol("foo_lib"); 
   String name_of_lib = MirrorSystem.getName(lib); 
   
   print(lib); 
   print(name_of_lib); 
}

다음을 생성해야합니다. output −

Symbol("foo_lib")   

foo_lib

문자열은 일련의 문자입니다. Dart는 문자열을 유니 코드 UTF-16 코드 단위의 시퀀스로 나타냅니다. 유니 코드는 각 문자, 숫자 및 기호에 대해 고유 한 숫자 값을 정의하는 형식입니다.

Dart 문자열은 일련의 UTF-16 코드 단위이므로 문자열 내의 32 비트 유니 코드 값은 특수 구문을 사용하여 표시됩니다. ㅏrune 유니 코드 코드 포인트를 나타내는 정수입니다.

의 String 클래스 dart:core 라이브러리는 액세스 할 수있는 메커니즘을 제공합니다. runes. 문자열 코드 단위 / 룬은 세 가지 방법으로 액세스 할 수 있습니다.

  • String.codeUnitAt () 함수 사용
  • String.codeUnits 속성 사용
  • String.runes 속성 사용

String.codeUnitAt () 함수

문자열의 코드 단위는 인덱스를 통해 액세스 할 수 있습니다. 주어진 인덱스에서 16 비트 UTF-16 코드 단위를 반환합니다.

통사론

String.codeUnitAt(int index);

예

import 'dart:core'; 
void main(){ 
   f1(); 
} 
f1() { 
   String x = 'Runes'; 
   print(x.codeUnitAt(0)); 
}

다음을 생성합니다. output −

82

String.codeUnits 속성

이 속성은 지정된 문자열의 UTF-16 코드 단위에 대한 수정 불가능한 목록을 반환합니다.

통사론

String. codeUnits;

예

import 'dart:core';  
void main(){ 
   f1(); 
}  
f1() { 
   String x = 'Runes'; 
   print(x.codeUnits); 
}

다음을 생성합니다. output −

[82, 117, 110, 101, 115]

String.runes 속성

이 속성은이 항목의 유니 코드 코드 포인트의 이터 러블을 반환합니다. string.Runes iterable을 확장합니다.

통사론

String.runes

예

void main(){ 
   "A string".runes.forEach((int rune) { 
      var character=new String.fromCharCode(rune); 
      print(character); 
   });  
}

다음을 생성합니다. output −

A 
s 
t 
r 
i 
n 
g

Unicode code points are usually expressed as \uXXXX, where XXXX is a 4-digit hexadecimal value. To specify more or less than 4 hex digits, place the value in curly brackets. One can use the constructor of the Runes class in the dart:core library for the same.

Example

main() { 
   Runes input = new Runes(' \u{1f605} '); 
   print(new String.fromCharCodes(input)); 
}

It will produce the following output −

An enumeration is used for defining named constant values. An enumerated type is declared using the enum keyword.

Syntax

enum enum_name {  
   enumeration list 
}

Where,

  • The enum_name specifies the enumeration type name
  • The enumeration list is a comma-separated list of identifiers

Each of the symbols in the enumeration list stands for an integer value, one greater than the symbol that precedes it. By default, the value of the first enumeration symbol is 0.

For example

enum Status { 
   none, 
   running, 
   stopped, 
   paused 
}

Example

enum Status { 
   none, 
   running, 
   stopped, 
   paused 
}  
void main() { 
   print(Status.values); 
   Status.values.forEach((v) => print('value: $v, index: ${v.index}')); print('running: ${Status.running}, ${Status.running.index}'); print('running index: ${Status.values[1]}'); 
}

It will produce the following output −

[Status.none, Status.running, Status.stopped, Status.paused] 
value: Status.none, index: 0 
value: Status.running, index: 1 
value: Status.stopped, index: 2 
value: Status.paused, index: 3 
running: Status.running, 1 
running index: Status.running

Functions are the building blocks of readable, maintainable, and reusable code. A function is a set of statements to perform a specific task. Functions organize the program into logical blocks of code. Once defined, functions may be called to access code. This makes the code reusable. Moreover, functions make it easy to read and maintain the program’s code.

A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.

Sr.No Functions & Description
1 Defining a Function

A function definition specifies what and how a specific task would be done.
2 Calling a Function

A function must be called so as to execute it.
3 Returning Functions

Functions may also return value along with control, back to the caller.
4 Parameterized Function

Parameters are a mechanism to pass values to functions.

Optional Parameters

Optional parameters can be used when arguments need not be compulsorily passed for a function’s execution. A parameter can be marked optional by appending a question mark to its name. The optional parameter should be set as the last argument in a function.

We have three types of optional parameters in Dart −

Sr.No Parameter & Description
1 Optional Positional Parameter

To specify optional positional parameters, use square [] brackets.
2 Optional named parameter

Unlike positional parameters, the parameter's name must be specified while the value is being passed. Curly brace {} can be used to specify optional named parameters.
3 Optional Parameters with Default Values

Function parameters can also be assigned values by default. However, such parameters can also be explicitly passed values.

Recursive Dart Functions

Recursion is a technique for iterating over an operation by having a function call to itself repeatedly until it arrives at a result. Recursion is best applied when you need to call the same function repeatedly with different parameters from within a loop.

Example

void main() { 
   print(factorial(6));
}  
factorial(number) { 
   if (number <= 0) {         
      // termination case 
      return 1; 
   } else { 
      return (number * factorial(number - 1));    
      // function invokes itself 
   } 
}

It should produce the following output −

720

Lambda Functions

Lambda functions are a concise mechanism to represent functions. These functions are also called as Arrow functions.

Syntax

[return_type]function_name(parameters)=>expression;

Example

void main() { 
   printMsg(); 
   print(test()); 
}  
printMsg()=>
print("hello"); 

int test()=>123;                       
// returning function

It should produce the following output −

hello 123

An interface defines the syntax that any entity must adhere to. Interfaces define a set of methods available on an object. Dart does not have a syntax for declaring interfaces. Class declarations are themselves interfaces in Dart.

Classes should use the implements keyword to be able to use an interface. It is mandatory for the implementing class to provide a concrete implementation of all the functions of the implemented interface. In other words, a class must redefine every function in the interface it wishes to implement.

Syntax: Implementing an Interface

class identifier implements interface_name

Example

In the following program, we are declaring a class Printer. The ConsolePrinter class implements the implicit interface declaration for the Printer class. The main function creates an object of the ConsolePrinter class using the new keyword. This object is used to invoke the function print_data defined in the ConsolePrinter class.

void main() { 
   ConsolePrinter cp= new ConsolePrinter(); 
   cp.print_data(); 
}  
class Printer { 
   void print_data() { 
      print("__________Printing Data__________"); 
   } 
}  
class ConsolePrinter implements Printer { 
   void print_data() {  
      print("__________Printing to Console__________"); 
   } 
}

It should produce the following output −

__________Printing to Console__________

Implementing Multiple Interfaces

A class can implement multiple interfaces. The interfaces are separated by a comma. The syntax for the same is given below −

class identifier implements interface-1,interface_2,interface_4…….

The following example shows how you can implement multiple interfaces in Dart −

void main() { 
   Calculator c = new Calculator(); 
   print("The gross total : ${c.ret_tot()}"); print("Discount :${c.ret_dis()}"); 
}  
class Calculate_Total { 
   int ret_tot() {} 
}  
class Calculate_Discount { 
   int ret_dis() {} 
}
class Calculator  implements Calculate_Total,Calculate_Discount { 
   int ret_tot() { 
      return 1000; 
   } 
   int ret_dis() { 
      return 50; 
   } 
}

It should produce the following output −

The gross total: 1000 
Discount:50

Dart is an object-oriented language. It supports object-oriented programming features like classes, interfaces, etc. A class in terms of OOP is a blueprint for creating objects. A class encapsulates data for the object. Dart gives built-in support for this concept called class.

Declaring a Class

Use the class keyword to declare a class in Dart. A class definition starts with the keyword class followed by the class name; and the class body enclosed by a pair of curly braces. The syntax for the same is given below −

Syntax

class class_name {  
   <fields> 
   <getters/setters> 
   <constructors> 
   <functions> 
}

The class keyword is followed by the class name. The rules for identifiers must be considered while naming a class.

A class definition can include the following −

  • Fields − A field is any variable declared in a class. Fields represent data pertaining to objects.

  • Setters and Getters − Allows the program to initialize and retrieve the values of the fields of a class. A default getter/ setter is associated with every class. However, the default ones can be overridden by explicitly defining a setter/ getter.

  • Constructors − responsible for allocating memory for the objects of the class.

  • Functions − Functions represent actions an object can take. They are also at times referred to as methods.

These components put together are termed as the data members of the class.

Example: Declaring a class

class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

The example declares a class Car. The class has a field named engine. The disp() is a simple function that prints the value of the field engine.

Creating Instance of the class

To create an instance of the class, use the new keyword followed by the class name. The syntax for the same is given below −

Syntax

var object_name = new class_name([ arguments ])

  • The new keyword is responsible for instantiation.

  • The right-hand side of the expression invokes the constructor. The constructor should be passed values if it is parameterized.

Example: Instantiating a class

var obj = new Car("Engine 1")

Accessing Attributes and Functions

A class’s attributes and functions can be accessed through the object. Use the ‘.’ dot notation (called as the period) to access the data members of a class.

//accessing an attribute 
obj.field_name  

//accessing a function 
obj.function_name()

Example

Take a look at the following example to understand how to access attributes and functions in Dart −

void main() { 
   Car c= new Car(); 
   c.disp(); 
}  
class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

The output of the above code is as follows −

E1001

Dart Constructors

A constructor is a special function of the class that is responsible for initializing the variables of the class. Dart defines a constructor with the same name as that of the class. A constructor is a function and hence can be parameterized. However, unlike a function, constructors cannot have a return type. If you don’t declare a constructor, a default no-argument constructor is provided for you.

Syntax

Class_name(parameter_list) { 
   //constructor body 
}

Example

The following example shows how to use constructors in Dart −

void main() { 
   Car c = new Car('E1001'); 
} 
class Car { 
   Car(String engine) { 
      print(engine); 
   } 
}

It should produce the following output −

E1001

Named Constructors

Dart provides named constructors to enable a class define multiple constructors. The syntax of named constructors is as given below −

Syntax : Defining the constructor

Class_name.constructor_name(param_list)

Example

The following example shows how you can use named constructors in Dart −

void main() {           
   Car c1 = new Car.namedConst('E1001');                                       
   Car c2 = new Car(); 
}           
class Car {                   
   Car() {                           
      print("Non-parameterized constructor invoked");
   }                                   
   Car.namedConst(String engine) { 
      print("The engine is : ${engine}");    
   }                               
}

It should produce the following output −

The engine is : E1001 
Non-parameterized constructor invoked

The this Keyword

The this keyword refers to the current instance of the class. Here, the parameter name and the name of the class’s field are the same. Hence to avoid ambiguity, the class’s field is prefixed with the this keyword. The following example explains the same −

Example

The following example explains how to use the this keyword in Dart −

void main() { 
   Car c1 = new Car('E1001'); 
}  
class Car { 
   String engine; 
   Car(String engine) { 
      this.engine = engine; 
      print("The engine is : ${engine}"); 
   } 
}

It should produce the following output −

The engine is : E1001

Dart Class ─ Getters and Setters

Getters and Setters, also called as accessors and mutators, allow the program to initialize and retrieve the values of class fields respectively. Getters or accessors are defined using the get keyword. Setters or mutators are defined using the set keyword.

A default getter/setter is associated with every class. However, the default ones can be overridden by explicitly defining a setter/ getter. A getter has no parameters and returns a value, and the setter has one parameter and does not return a value.

Syntax: Defining a getter

Return_type  get identifier 
{ 
}

Syntax: Defining a setter

set identifier 
{ 
}

Example

The following example shows how you can use getters and setters in a Dart class −

class Student { 
   String name; 
   int age; 
    
   String get stud_name { 
      return name; 
   } 
    
   void set stud_name(String name) { 
      this.name = name; 
   } 
   
   void set stud_age(int age) { 
      if(age<= 0) { 
        print("Age should be greater than 5"); 
      }  else { 
         this.age = age; 
      } 
   } 
   
   int get stud_age { 
      return age;     
   } 
}  
void main() { 
   Student s1 = new Student(); 
   s1.stud_name = 'MARK'; 
   s1.stud_age = 0; 
   print(s1.stud_name); 
   print(s1.stud_age); 
}

This program code should produce the following output −

Age should be greater than 5 
MARK 
Null

Class Inheritance

Dart supports the concept of Inheritance which is the ability of a program to create new classes from an existing class. The class that is extended to create newer classes is called the parent class/super class. The newly created classes are called the child/sub classes.

A class inherits from another class using the ‘extends’ keyword. Child classes inherit all properties and methods except constructors from the parent class.

Syntax

class child_class_name extends parent_class_name

Note − Dart doesn’t support multiple inheritance.

Example: Class Inheritance

In the following example, we are declaring a class Shape. The class is extended by the Circle class. Since there is an inheritance relationship between the classes, the child class, i.e., the class Car gets an implicit access to its parent class data member.

void main() { 
   var obj = new Circle(); 
   obj.cal_area(); 
}  
class Shape { 
   void cal_area() { 
      print("calling calc area defined in the Shape class"); 
   } 
}  
class Circle extends Shape {}

It should produce the following output −

calling calc area defined in the Shape class

Types of Inheritance

Inheritance can be of the following three types −

  • Single − Every class can at the most extend from one parent class.

  • Multiple − A class can inherit from multiple classes. Dart doesn’t support multiple inheritance.

  • Multi-level − A class can inherit from another child class.

Example

The following example shows how multi-level inheritance works −

void main() { 
   var obj = new Leaf(); 
   obj.str = "hello"; 
   print(obj.str); 
}  
class Root { 
   String str; 
}  
class Child extends Root {}  
class Leaf extends Child {}  
//indirectly inherits from Root by virtue of inheritance

The class Leaf derives the attributes from Root and Child classes by virtue of multi-level inheritance. Its output is as follows −

hello

Dart – Class Inheritance and Method Overriding

Method Overriding is a mechanism by which the child class redefines a method in its parent class. The following example illustrates the same −

Example

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} } class Child extends Parent { @override void m1(int b) { print("value of b ${b}"); 
   } 
}

It should produce the following output −

value of b 12

The number and type of the function parameters must match while overriding the method. In case of a mismatch in the number of parameters or their data type, the Dart compiler throws an error. The following illustration explains the same −

import 'dart:io'; 
void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} } class Child extends Parent { @override void m1(String b) { print("value of b ${b}");
   } 
}

It should produce the following output −

value of b 12

The static Keyword

The static keyword can be applied to the data members of a class, i.e., fields and methods. A static variable retains its values till the program finishes execution. Static members are referenced by the class name.

Example

class StaticMem { 
   static int num;  
   static disp() { 
      print("The value of num is ${StaticMem.num}")  ; 
   } 
}  
void main() { 
   StaticMem.num = 12;  
   // initialize the static variable } 
   StaticMem.disp();   
   // invoke the static method 
}

It should produce the following output −

The value of num is 12

The super Keyword

The super keyword is used to refer to the immediate parent of a class. The keyword can be used to refer to the super class version of a variable, property, or method. The following example illustrates the same −

Example

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   String msg = "message variable from the parent class"; 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); super.m1(13); print("${super.msg}")   ; 
   } 
}

It should produce the following output −

value of b 12 
value of a 13 
message variable from the parent class

Object-Oriented Programming defines an object as “any entity that has a defined boundary.” An object has the following −

  • State − Describes the object. The fields of a class represent the object’s state.

  • Behavior − Describes what an object can do.

  • Identity − A unique value that distinguishes an object from a set of similar other objects. Two or more objects can share the state and behavior but not the identity.

The period operator (.) is used in conjunction with the object to access a class’ data members.

Example

Dart represents data in the form of objects. Every class in Dart extends the Object class. Given below is a simple example of creating and using an object.

class Student { 
   void test_method() { 
      print("This is a  test method"); 
   } 
   
   void test_method1() { 
      print("This is a  test method1"); 
   } 
}  
void main()    { 
   Student s1 = new Student(); 
   s1.test_method(); 
   s1.test_method1(); 
}

It should produce the following output −

This is a test method 
This is a test method1

The Cascade operator (..)

The above example invokes the methods in the class. However, every time a function is called, a reference to the object is required. The cascade operator can be used as a shorthand in cases where there is a sequence of invocations.

The cascade ( .. ) operator can be used to issue a sequence of calls via an object. The above example can be rewritten in the following manner.

class Student { 
   void test_method() { 
      print("This is a  test method"); 
   } 
   
   void test_method1() { 
      print("This is a  test method1"); 
   } 
}  
void main() { 
   new Student() 
   ..test_method() 
   ..test_method1(); 
}

It should produce the following output −

This is a test method 
This is a test method1

The toString() method

This function returns a string representation of an object. Take a look at the following example to understand how to use the toString method.

void main() { 
   int n = 12; 
   print(n.toString()); 
}

It should produce the following output −

12

Dart, unlike other programming languages, doesn’t support arrays. Dart collections can be used to replicate data structures like an array. The dart:core library and other classes enable Collection support in Dart scripts.

Dart collections can be basically classified as −

Sr.No Dart collection & Description
1 List

A List is simply an ordered group of objects. The dart:core library provides the List class that enables creation and manipulation of lists.

  • Fixed Length List − The list’s length cannot change at run-time.

  • Growable List − The list’s length can change at run-time.
2 Set

Set represents a collection of objects in which each object can occur only once. The dart:core library provides the Set class to implement the same.
3 Maps

The Map object is a simple key/value pair. Keys and values in a map may be of any type. A Map is a dynamic collection. In other words, Maps can grow and shrink at runtime. The Map class in the dart:core library provides support for the same.
4 Queue

A Queue is a collection that can be manipulated at both ends. Queues are useful when you want to build a first-in, first-out collection. Simply put, a queue inserts data from one end and deletes from another end. The values are removed / read in the order of their insertion.

Iterating Collections

The Iterator class from the dart:core library enables easy collection traversal. Every collection has an iterator property. This property returns an iterator that points to the objects in the collection.

Example

The following example illustrates traversing a collection using an iterator object.

import 'dart:collection'; 
void main() { 
   Queue numQ = new Queue(); 
   numQ.addAll([100,200,300]);  
   Iterator i= numQ.iterator; 
   
   while(i.moveNext()) { 
      print(i.current); 
   } 
}

The moveNext() function returns a Boolean value indicating whether there is a subsequent entry. The current property of the iterator object returns the value of the object that the iterator currently points to.

This program should produce the following output −

100 
200 
300

Dart is an optionally typed language. Collections in Dart are heterogeneous by default. In other words, a single Dart collection can host values of various types. However, a Dart collection can be made to hold homogenous values. The concept of Generics can be used to achieve the same.

The use of Generics enforces a restriction on the data type of the values that can be contained by the collection. Such collections are termed as type-safe collections. Type safety is a programming feature which ensures that a memory block can only contain data of a specific data type.

All Dart collections support type-safety implementation via generics. A pair of angular brackets containing the data type is used to declare a type-safe collection. The syntax for declaring a type-safe collection is as given below.

Syntax

Collection_name <data_type> identifier= new Collection_name<data_type>

The type-safe implementations of List, Map, Set and Queue is given below. This feature is also supported by all implementations of the above-mentioned collection types.

Example: Generic List

void main() { 
   List <String> logTypes = new List <String>(); 
   logTypes.add("WARNING"); 
   logTypes.add("ERROR"); 
   logTypes.add("INFO");  
   
   // iterating across list 
   for (String type in logTypes) { 
      print(type); 
   } 
}

It should produce the following output −

WARNING 
ERROR 
INFO

An attempt to insert a value other than the specified type will result in a compilation error. The following example illustrates this.

Example

void main() { 
   List <String> logTypes = new List <String>(); 
   logTypes.add(1); 
   logTypes.add("ERROR"); 
   logTypes.add("INFO"); 
  
   //iterating across list 
   for (String type in logTypes) { 
      print(type); 
   } 
}

It should produce the following output −

1                                                                                     
ERROR                                                                             
INFO

Example: Generic Set

void main() { 
   Set <int>numberSet = new  Set<int>(); 
   numberSet.add(100); 
   numberSet.add(20); 
   numberSet.add(5); 
   numberSet.add(60);
   numberSet.add(70); 
   
   // numberSet.add("Tom"); 
   compilation error; 
   print("Default implementation  :${numberSet.runtimeType}");  
   
   for(var no in numberSet) { 
      print(no); 
   } 
}

It should produce the following output −

Default implementation :_CompactLinkedHashSet<int> 
100 
20 
5 
60 
70

Example: Generic Queue

import 'dart:collection'; 
void main() { 
   Queue<int> queue = new Queue<int>(); 
   print("Default implementation ${queue.runtimeType}");  
   queue.addLast(10); 
   queue.addLast(20); 
   queue.addLast(30); 
   queue.addLast(40); 
   queue.removeFirst();  
   
   for(int no in queue){ 
      print(no); 
   } 
}

It should produce the following output −

Default implementation ListQueue<int> 
20 
30 
40

Generic Map

A type-safe map declaration specifies the data types of −

  • The key
  • The value

Syntax

Map <Key_type, value_type>

Example

void main() { 
   Map <String,String>m={'name':'Tom','Id':'E1001'}; 
   print('Map :${m}'); 
}

It should produce the following output −

Map :{name: Tom, Id: E1001}

A package is a mechanism to encapsulate a group of programming units. Applications might at times need integration of some third-party libraries or plugins. Every language has a mechanism for managing external packages like Maven or Gradle for Java, Nuget for .NET, npm for Node.js, etc. The package manager for Dart is pub.

Pub helps to install packages in the repository. The repository of packages hosted can be found at https://pub.dartlang.org/.

The package metadata is defined in a file, pubsec.yaml. YAML is the acronym for Yet Another Markup Language. The pub tool can be used to download all various libraries that an application requires.

Every Dart application has a pubspec.yaml file which contains the application dependencies to other libraries and metadata of applications like application name, author, version, and description.

The contents of a pubspec.yaml file should look something like this −

name: 'vector_victor' 
version: 0.0.1 
description: An absolute bare-bones web app. 
... 
dependencies: browser: '>=0.10.0 <0.11.0'

The important pub commands are as follows −

Sr.No Command & Description
1

‘pub get’

Helps to get all packages your application is depending on.
2

‘pub upgrade’

Upgrades all your dependencies to a newer version.
3

‘pub build’

This s used for building your web application and it will create a build folder , with all related scripts in it.
4

‘pub help’

This will give you help for all different pub commands.

If you are using an IDE like WebStorm, then you can right-click on the pubspec.yaml to get all the commands directly −

Installing a Package

Consider an example where an application needs to parse xml. Dart XML is a lightweight library that is open source and stable for parsing, traversing, querying and building XML documents.

The steps for achieving the said task is as follows −

Step 1 − Add the following to the pubsec.yaml file.

name: TestApp 
version: 0.0.1 
description: A simple console application. 
#dependencies: 
#  foo_bar: '>=1.0.0 <2.0.0' 
dependencies: https://mail.google.com/mail/u/0/images/cleardot.gif
xml:

Right-click on the pubsec.yaml and get dependencies. This will internally fire the pub get command as shown below.

The downloaded packages and its dependent packages can be verified under the packages folder.

Since installation is completed now, we need to refer the dart xml in the project. The syntax is as follows −

import 'package:xml/xml.dart' as xml;

Read XML String

To read XML string and verify the input, Dart XML uses a parse() method. The syntax is as follows −

xml.parse(String input):

Example : Parsing XML String Input

The following example shows how to parse XML string input −

import 'package:xml/xml.dart' as xml; 
void main(){ 
   print("xml"); 
   var bookshelfXml = '''<?xml version = "1.0"?> 
   <bookshelf> 
      <book> 
         <title lang = "english">Growing a Language</title> 
         <price>29.99</price> 
      </book> 
      
      <book> 
         <title lang = "english">Learning XML</title> 
         <price>39.95</price> 
      </book> 
      <price>132.00</price> 
   </bookshelf>'''; 
   
   var document = xml.parse(bookshelfXml); 
   print(document.toString()); 
}

It should produce the following output −

xml 
<?xml version = "1.0"?><bookshelf> 
   <book> 
      <title lang = "english">Growing a Language</title> 
      <price>29.99</price> 
   </book> 

   <book> 
      <title lang = "english">Learning XML</title> 
      <price>39.95</price> 
   </book> 
   <price>132.00</price> 
</bookshelf>

An exception (or exceptional event) is a problem that arises during the execution of a program. When an Exception occurs the normal flow of the program is disrupted and the program/Application terminates abnormally.

Built-in Dart exceptions include −

Sr.No Exceptions & Description
1

DeferredLoadException

Thrown when a deferred library fails to load.
2

FormatException

Exception thrown when a string or some other data does not have an expected format and cannot be parsed or processed.
3

IntegerDivisionByZeroException

Thrown when a number is divided by zero.
4

IOException

Base class for all Inupt-Output related exceptions.
5

IsolateSpawnException

Thrown when an isolate cannot be created.
6

Timeout

Thrown when a scheduled timeout happens while waiting for an async result.

Every exception in Dart is a subtype of the pre-defined class Exception. Exceptions must be handled to prevent the application from terminating abruptly.

The try / on / catch Blocks

The try block embeds code that might possibly result in an exception. The on block is used when the exception type needs to be specified. The catch block is used when the handler needs the exception object.

The try block must be followed by either exactly one on / catch block or one finally block (or one of both). When an exception occurs in the try block, the control is transferred to the catch.

The syntax for handling an exception is as given below −

try { 
   // code that might throw an exception 
}  
on Exception1 { 
   // code for handling exception 
}  
catch Exception2 { 
   // code for handling exception 
}

Following are some points to remember −

  • A code snippet can have more than one on / catch blocks to handle multiple exceptions.

  • The on block and the catch block are mutually inclusive, i.e. a try block can be associated with both- the on block and the catch block.

The following code illustrates exception handling in Dart −

Example: Using the ON Block

The following program divides two numbers represented by the variables x and y respectively. The code throws an exception since it attempts division by zero. The on block contains the code to handle this exception.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try {
      res = x ~/ y; 
   } 
   on IntegerDivisionByZeroException { 
      print('Cannot divide by zero'); 
   } 
}

It should produce the following output −

Cannot divide by zero

Example: Using the catch Block

In the following example, we have used the same code as above. The only difference is that the catch block (instead of the ON block) here contains the code to handle the exception. The parameter of catch contains the exception object thrown at runtime.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try {  
      res = x ~/ y; 
   }  
   catch(e) { 
      print(e); 
   } 
}

It should produce the following output −

IntegerDivisionByZeroException

Example: on…catch

The following example shows how to use the on...catch block.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try { 
      res = x ~/ y; 
   }  
   on IntegerDivisionByZeroException catch(e) { 
      print(e); 
   } 
}

다음을 생성해야합니다. output −

IntegerDivisionByZeroException

마지막 블록

그만큼 finally블록에는 예외 발생에 관계없이 실행되어야하는 코드가 포함됩니다. 선택 사항finally 블록은 다음에 무조건 실행됩니다. try/on/catch.

사용 구문 finally 블록은 다음과 같습니다-

try { 
   // code that might throw an exception 
}  
on Exception1 { 
   // exception handling code 
}  
catch Exception2 { 
   //  exception handling 
}  
finally { 
   // code that should always execute; irrespective of the exception 
}

다음 예는 finally 블록.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try { 
      res = x ~/ y; 
   } 
   on IntegerDivisionByZeroException { 
      print('Cannot divide by zero'); 
   } 
   finally { 
      print('Finally block executed'); 
   } 
}

다음을 생성해야합니다. output −

Cannot divide by zero 
Finally block executed

예외 던지기

그만큼 throw키워드는 명시 적으로 예외를 발생시키는 데 사용됩니다. 프로그램이 갑자기 종료되는 것을 방지하기 위해 발생한 예외를 처리해야합니다.

그만큼 syntax 예외를 명시 적으로 발생시키는 것은-

throw new Exception_name()

예

다음 예는 throw 예외를 던지는 키워드-

main() { 
   try { 
      test_age(-2); 
   } 
   catch(e) { 
      print('Age cannot be negative'); 
   } 
}  
void test_age(int age) { 
   if(age<0) { 
      throw new FormatException(); 
   } 
}

다음을 생성해야합니다. output −

Age cannot be negative

사용자 지정 예외

위에서 지정한 것처럼 Dart의 모든 예외 유형은 내장 클래스의 하위 유형입니다. Exception. Dart는 기존 예외를 확장하여 사용자 지정 예외를 만들 수 있습니다. 사용자 정의 예외를 정의하는 구문은 다음과 같습니다.

구문 : 예외 정의

class Custom_exception_Name implements Exception { 
   // can contain constructors, variables and methods 
}

사용자 지정 예외는 명시 적으로 발생해야하며 코드에서 동일하게 처리되어야합니다.

예

다음 예제는 사용자 정의 예외를 정의하고 처리하는 방법을 보여줍니다.

class AmtException implements Exception { 
   String errMsg() => 'Amount should be greater than zero'; 
}  
void main() { 
   try { 
      withdraw_amt(-1); 
   } 
   catch(e) { 
      print(e.errMsg()); 
   }  
finally { 
      print('Ending requested operation.....'); 
   } 
}  
void withdraw_amt(int amt) { 
   if (amt <= 0) { 
      throw new AmtException(); 
   } 
}

위의 코드에서 우리는 커스텀 예외를 정의하고 있습니다. AmtException. 코드는 전달 된 금액이 예외 범위 내에 있지 않은 경우 예외를 발생시킵니다. 그만큼main 함수는 함수 호출을 try...catch 블록.

코드는 다음을 생성해야합니다. output −

Amount should be greater than zero 
Ending requested operation....

때때로 개발자는 코딩 중에 실수를합니다. 프로그램의 실수를 버그라고합니다. 버그를 찾고 수정하는 프로세스를 디버깅이라고하며 개발 프로세스의 일반적인 부분입니다. 이 섹션에서는 디버깅 작업에 도움이되는 도구와 기술을 다룹니다.

WebStorm 편집기는 중단 점 및 단계별 디버깅을 활성화합니다. 프로그램은 중단 점이 첨부 된 지점에서 중단됩니다. 이 기능은 Java 또는 C # 애플리케이션 개발에서 기대할 수있는 것과 유사합니다. WebStorm 편집기에서 변수를 관찰하고, 스택을 탐색하고, 메서드 및 함수 호출을 단계별로 실행할 수 있습니다.

중단 점 추가

다음 코드 스 니펫을 고려하십시오. (TestString.dart)

void main() { 
   int a = 10, b = 20, c = 5; 
   c = c * c * c; 
   
   print("$a + $b = ${a+b}"); 
   print("$a%$b = ${a%b}"); // Add a break point here print("$a*$b = ${a*b}"); 
   print("$a/$b = ${a/b}"); 
   print(c); 
}

에 add a breakpoint, 왼쪽 여백을 클릭합니다. 아래 그림에서 줄 번호 7에는 중단 점이 있습니다.

Run the program in debug mode. 프로젝트 탐색기에서 TestString.dart의 dart 프로그램을 마우스 오른쪽 버튼으로 클릭합니다.

프로그램이 디버그 모드에서 실행되면 다음 스크린 샷과 같이 Debugger 창이 나타납니다. 변수 탭에는 현재 컨텍스트의 변수 값이 표시됩니다. 특정 변수에 대한 감시자를 추가하고 감시 창을 사용하여 해당 값 변경을 수신 할 수 있습니다.

Step Into디버그 메뉴의 (F7) 화살표 아이콘은 코드를 한 번에 하나씩 실행하는 데 도움이됩니다. 메인 메소드가 서브 루틴을 호출하면 이것은 서브 루틴 코드에도 들어갑니다.

Step over (F8) : 다음과 유사합니다. Step Into. 사용의 차이는 현재 명령문에 서브 루틴에 대한 호출이 포함되어있을 때 발생합니다. 메인 메소드가 서브 루틴을 호출하는 경우 스텝 오버는 서브 루틴으로 드릴하지 않습니다. 서브 루틴을 건너 뜁니다.

Step Out(Shift + F8) : 현재 실행 지점이있는 함수의 나머지 줄을 실행합니다. 표시되는 다음 명령문은 서브 루틴 호출 다음에 나오는 명령문입니다.

디버그 모드에서 실행 한 후 프로그램은 다음을 제공합니다. output −

10 + 20 = 30 
10 % 20 = 10 
10 * 20 = 200 
10 / 20 = 0.5 
125

ㅏ typedef또는 함수 유형 별칭은 메모리 내에서 실행 가능한 코드에 대한 포인터를 정의하는 데 도움이됩니다. 간단히 말해서,typedef 함수를 참조하는 포인터로 사용할 수 있습니다.

다음은 구현 단계입니다. typedefs 다트 프로그램에서.

Step 1: Defining a typedef

ㅏ typedef특정 함수와 일치시킬 함수 서명을 지정하는 데 사용할 수 있습니다. 함수 서명은 함수의 매개 변수 (유형 포함)로 정의됩니다. 반환 유형은 함수 서명의 일부가 아닙니다. 구문은 다음과 같습니다.

typedef function_name(parameters)

Step 2: Assigning a Function to a typedef Variable

변수 typedef 동일한 서명을 가진 모든 함수를 가리킬 수 있습니다. typedef. 다음 서명을 사용하여 기능을 할당 할 수 있습니다.typedef 변하기 쉬운.

type_def  var_name = function_name

Step 3: Invoking a Function

그만큼 typedef변수를 사용하여 함수를 호출 할 수 있습니다. 다음은 함수를 호출하는 방법입니다.

var_name(parameters)

예

이제 더 많은 것을 이해하기 위해 예를 들어 보겠습니다. typedef 다트에서.

처음에는 typedef. 여기서 우리는 함수 시그니처를 정의합니다. 이 함수는 유형의 두 입력 매개 변수를 사용합니다.integer. 반환 유형은 함수 서명의 일부가 아닙니다.

typedef ManyOperation(int firstNo , int secondNo); //function signature

다음으로 함수를 정의하겠습니다. 동일한 기능 시그니처로 일부 기능을 정의하십시오.ManyOperation typedef.

Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); 
}  
Subtract(int firstNo,int second){ 
   print("Subtract result is ${firstNo-second}"); } Divide(int firstNo,int second){ print("Add result is ${firstNo/second}"); 
}

마지막으로 다음을 통해 함수를 호출합니다. typedef. ManyOperations 유형의 변수를 선언하십시오. 선언 된 변수에 함수 이름을 지정하십시오.

ManyOperation oper ;  

//can point to any method of same signature 
oper = Add; 
oper(10,20); 
oper = Subtract; 
oper(30,20); 
oper = Divide; 
oper(50,5);

그만큼 oper변수는 두 개의 정수 매개 변수를 사용하는 모든 메소드를 가리킬 수 있습니다. 그만큼Add함수의 참조가 변수에 할당됩니다. Typedef는 런타임에 함수 참조를 전환 할 수 있습니다.

이제 모든 부품을 모아 전체 프로그램을 살펴 보겠습니다.

typedef ManyOperation(int firstNo , int secondNo); 
//function signature  

Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); } Subtract(int firstNo,int second){ print("Subtract result is ${firstNo-second}"); 
}
Divide(int firstNo,int second){ 
   print("Divide result is ${firstNo/second}"); 
}  
Calculator(int a, int b, ManyOperation oper){ 
   print("Inside calculator"); 
   oper(a,b); 
}  
void main(){ 
   ManyOperation oper = Add; 
   oper(10,20); 
   oper = Subtract; 
   oper(30,20); 
   oper = Divide; 
   oper(50,5); 
}

프로그램은 다음을 생성해야합니다. output −

Add result is 30 
Subtract result is 10 
Divide result is 10.0

Note − 위 코드는 다음과 같은 경우 오류가 발생합니다. typedef 변수는 다른 함수 시그니처를 가진 함수를 가리 키려고합니다.

예

Typedefs매개 변수로 함수에 전달할 수도 있습니다. 다음 예를 고려하십시오-

typedef ManyOperation(int firstNo , int secondNo);   //function signature 
Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); 
}  
Subtract(int firstNo,int second){
   print("Subtract result is ${firstNo-second}"); } Divide(int firstNo,int second){ print("Divide result is ${firstNo/second}"); 
}  
Calculator(int a,int b ,ManyOperation oper){ 
   print("Inside calculator"); 
   oper(a,b); 
}  
main(){ 
   Calculator(5,5,Add); 
   Calculator(5,5,Subtract); 
   Calculator(5,5,Divide); 
}

다음을 생성합니다. output −

Inside calculator 
Add result is 10 
Inside calculator 
Subtract result is 0 
Inside calculator 
Divide result is 1.0

프로그래밍 언어의 라이브러리는 루틴 모음 (프로그래밍 명령 집합)을 나타냅니다. Dart에는 자주 사용되는 루틴을 저장하는 데 유용한 내장 라이브러리 세트가 있습니다. Dart 라이브러리는 클래스, 상수, 함수, typedef, 속성 및 예외 집합으로 구성됩니다.

라이브러리 가져 오기

가져 오면 라이브러리의 구성 요소를 호출자 코드에서 사용할 수 있습니다. 가져 오기 키워드는 동일한 작업을 수행하는 데 사용됩니다. dart 파일에는 여러 개의 import 문이있을 수 있습니다.

내장 된 Dart 라이브러리 URI는 dart : 체계를 사용하여 라이브러리를 참조합니다. 다른 라이브러리는 파일 시스템 경로 또는 package : 체계를 사용하여 URI를 지정할 수 있습니다. pub 도구와 같은 패키지 관리자가 제공하는 라이브러리는 package : scheme을 사용합니다 .

Dart에서 라이브러리를 가져 오는 구문은 다음과 같습니다.

import 'URI'

다음 코드 스 니펫을 고려하십시오-

import 'dart:io' 
import 'package:lib1/libfile.dart'

라이브러리의 일부만 사용하려는 경우 라이브러리를 선택적으로 가져올 수 있습니다. 동일한 구문은 다음과 같습니다.

import 'package: lib1/lib1.dart' show foo, bar;  
// Import only foo and bar. 

import 'package: mylib/mylib.dart' hide foo;  
// Import all names except foo

일반적으로 사용되는 일부 라이브러리는 다음과 같습니다.

Sr. 아니요 도서관 및 설명
1

dart:io

서버 응용 프로그램에 대한 파일, 소켓, HTTP 및 기타 I / O 지원. 이 라이브러리는 브라우저 기반 애플리케이션에서 작동하지 않습니다. 이 라이브러리는 기본적으로 가져옵니다.
2

dart:core

모든 Dart 프로그램에 내장 된 유형, 컬렉션 및 기타 핵심 기능. 이 라이브러리는 자동으로 가져옵니다.
삼

dart: math

수학 상수 및 함수와 난수 생성기.
4

dart: convert

JSON 및 UTF-8을 포함하여 서로 다른 데이터 표현 간 변환을위한 인코더 및 디코더.
5

dart: typed_data

고정 크기 데이터 (예 : 부호없는 8 바이트 정수)를 효율적으로 처리하는 목록입니다.

예 : 라이브러리 가져 오기 및 사용

다음 예제는 내장 라이브러리를 가져옵니다. dart: math. 스 니펫은sqrt() 기능 math도서관. 이 함수는 전달 된 숫자의 제곱근을 반환합니다.

import 'dart:math'; 
void main() { 
   print("Square root of 36 is: ${sqrt(36)}"); 
}

Output

Square root of 36 is: 6.0

라이브러리의 캡슐화

Dart 스크립트는 식별자 앞에 밑줄 (_)을 붙여 구성 요소를 비공개로 표시 할 수 있습니다. 간단히 말해, Dart 라이브러리는 외부 스크립트에 의한 콘텐츠 액세스를 제한 할 수 있습니다. 이것은 다음과 같이 불립니다.encapsulation. 동일한 구문은 다음과 같습니다.

통사론

_identifier

예

먼저 개인 함수로 라이브러리를 정의하십시오.

library loggerlib;                            
void _log(msg) {
   print("Log method called in loggerlib msg:$msg");      
}

다음으로 라이브러리 가져 오기

import 'test.dart' as web; 
void main() { 
   web._log("hello from webloggerlib"); 
}

위의 코드는 오류를 발생시킵니다.

Unhandled exception: 
No top-level method 'web._log' declared.  
NoSuchMethodError: method not found: 'web._log' 
Receiver: top-level 
Arguments: [...] 
#0 NoSuchMethodError._throwNew (dart:core-patch/errors_patch.dart:184) 
#1 main (file:///C:/Users/Administrator/WebstormProjects/untitled/Assertion.dart:6:3) 
#2 _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#3 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

사용자 지정 라이브러리 생성

Dart를 사용하면 자신의 코드를 라이브러리로 사용할 수도 있습니다. 사용자 정의 라이브러리를 생성하려면 다음 단계가 포함됩니다.

Step 1: Declaring a Library

라이브러리를 명시 적으로 선언하려면 library statement. 라이브러리를 선언하는 구문은 다음과 같습니다.

library library_name  
// library contents go here

Step 2: Associating a Library

두 가지 방법으로 라이브러리를 연결할 수 있습니다.

  • 동일한 디렉토리 내
import 'library_name'
  • 다른 디렉토리에서
import 'dir/library_name'

예 : 사용자 지정 라이브러리

먼저 커스텀 라이브러리를 정의하겠습니다. calculator.dart.

library calculator_lib;  
import 'dart:math'; 

//import statement after the libaray statement  
int add(int firstNumber,int secondNumber){ 
   print("inside add method of Calculator Library ") ; 
   return firstNumber+secondNumber; 
}  
int modulus(int firstNumber,int secondNumber){ 
   print("inside modulus method of Calculator Library ") ; 
   return firstNumber%secondNumber; 
}  
int random(int no){ 
   return new Random().nextInt(no); 
}

다음으로 라이브러리를 가져옵니다.

import 'calculator.dart';  
void main() {
   var num1 = 10; 
   var num2 = 20; 
   var sum = add(num1,num2); 
   var mod = modulus(num1,num2); 
   var r = random(10);  
   
   print("$num1 + $num2 = $sum"); print("$num1 % $num2= $mod"); 
   print("random no $r"); 
}

프로그램은 다음을 생성해야합니다. output −

inside add method of Calculator Library  
inside modulus method of Calculator Library  
10 + 20 = 30 
10 % 20= 10 
random no 0

라이브러리 접두사

식별자가 충돌하는 두 라이브러리를 가져 오는 경우 하나 또는 두 라이브러리 모두에 접두사를 지정할 수 있습니다. 사용'as'접두사를 지정하기위한 키워드. 동일한 구문은 다음과 같습니다.

통사론

import 'library_uri' as prefix

예

먼저 라이브러리를 정의하겠습니다. loggerlib.dart.

library loggerlib;  
void log(msg){ 
   print("Log method called in loggerlib msg:$msg");
}

다음으로 다른 라이브러리를 정의합니다. webloggerlib.dart.

library webloggerlib; 
void log(msg){ 
   print("Log method called in webloggerlib msg:$msg"); 
}

마지막으로 접두사가있는 라이브러리를 가져옵니다.

import 'loggerlib.dart'; 
import 'webloggerlib.dart' as web;  

// prefix avoids function name clashes 
void main(){ 
   log("hello from loggerlib"); 
   web.log("hello from webloggerlib"); 
}

다음을 생성합니다. output −

Log method called in loggerlib msg:hello from loggerlib 
Log method called in webloggerlib msg:hello from webloggerlib

안 asynchronous operation 스레드에서 실행되며 main응용 프로그램 스레드. 응용 프로그램이 작업을 비동기 적으로 수행하기 위해 메서드를 호출하면 비동기 메서드가 작업을 수행하는 동안 응용 프로그램이 계속 실행될 수 있습니다.

예

이 개념을 이해하기 위해 예를 들어 보겠습니다. 여기서 프로그램은IO library.

import 'dart:io'; 
void main() { 
   print("Enter your name :");            
   
   // prompt for user input 
   String name = stdin.readLineSync();  
   
   // this is a synchronous method that reads user input 
   print("Hello Mr. ${name}"); 
   print("End of main"); 
}

그만큼 readLineSync()동기 메서드입니다. 이것은 다음을 따르는 모든 명령의 실행을 의미합니다.readLineSync() 함수 호출은 readLineSync() 메소드가 실행을 완료합니다.

그만큼 stdin.readLineSync입력을 기다립니다. 트랙에서 멈추고 사용자의 입력을받을 때까지 더 이상 실행되지 않습니다.

위의 예는 다음과 같습니다. output −

Enter your name :     
Tom                   

// reads user input  
Hello Mr. Tom 
End of main

컴퓨팅에서 우리는 무언가가 synchronous계속하기 전에 이벤트가 발생하기를 기다릴 때. 이 접근 방식의 단점은 코드의 일부를 실행하는 데 너무 오래 걸리면 후속 블록이 관련이 없더라도 실행이 차단된다는 것입니다. 자원에 대한 여러 요청에 응답해야하는 웹 서버를 고려하십시오.

동기 실행 모델은 현재 요청 처리가 완료 될 때까지 다른 모든 사용자의 요청을 차단합니다. 이러한 경우 웹 서버와 마찬가지로 모든 요청은 다른 요청과 독립적이어야합니다. 즉, 웹 서버는 다른 사용자의 요청에 응답하기 전에 현재 요청의 실행이 완료 될 때까지 기다리지 않아야합니다.

간단히 말해, 이전 사용자의 요청을 반드시 완료하기 전에 새 사용자의 요청을 수락해야합니다. 이를 비동기식이라고합니다. 비동기 프로그래밍은 기본적으로 대기 또는 비 차단 프로그래밍 모델이 없음을 의미합니다. 그만큼dart:async 패키지는 Dart 스크립트에서 비동기 프로그래밍 블록을 구현하는 것을 용이하게합니다.

예

다음 예제는 비동기 블록의 기능을 더 잘 보여줍니다.

Step 1 − 만들기 contact.txt 아래에 주어진 파일 and 현재 프로젝트의 데이터 폴더에 저장합니다.

1, Tom 
2, John 
3, Tim 
4, Jane

Step 2 − 응용 프로그램의 다른 부분을 차단하지 않고 파일을 읽을 프로그램을 작성하십시오.

import "dart:async"; 
import "dart:io";  

void main(){ 
   File file = new File( Directory.current.path+"\\data\\contact.txt"); 
   Future<String> f = file.readAsString();  
  
   // returns a futrue, this is Async method 
   f.then((data)=>print(data));  
   
   // once file is read , call back method is invoked  
   print("End of main");  
   // this get printed first, showing fileReading is non blocking or async 
}

그만큼 output 이 프로그램의 다음과 같습니다-

End of main 
1, Tom 
2, John 
3, Tim 
4, Jan

스크립트가 파일을 계속 읽는 동안 "end of main"이 먼저 실행됩니다. 그만큼Future 클래스, 일부 dart:async, 비동기 작업이 완료된 후 계산 결과를 가져 오는 데 사용됩니다. 이Future 그런 다음 계산이 완료된 후 값을 사용하여 작업을 수행합니다.

읽기 작업이 완료되면 실행 제어가 "then()". 읽기 작업에 더 많은 시간이 소요될 수 있으므로 프로그램의 다른 부분을 차단하고 싶지 않기 때문입니다.

다트 퓨처

Dart 커뮤니티는 Future"미래에 가치를 얻기위한 수단"으로. 간단히 말해서,Future objects나중에 실행이 완료되는 표현식에서 반환 된 값을 나타내는 메커니즘입니다. Dart의 내장 클래스 중 일부는Future 비동기 메서드가 호출 될 때.

Dart는 단일 스레드 프로그래밍 언어입니다. 코드가 실행 스레드를 차단하면 (예 : 시간이 많이 걸리는 작업을 기다리거나 I / O를 차단하여) 프로그램이 효과적으로 정지됩니다.

비동기 작업을 통해 프로그램이 차단되지 않고 실행됩니다. 다트 사용Future objects 비동기 작업을 나타냅니다.

Concurrency동시에 여러 명령 시퀀스를 실행하는 것입니다. 두 개 이상의 작업을 동시에 수행하는 것이 포함됩니다.

다트 사용 Isolates병렬로 작업을 수행하는 도구로. 그만큼dart:isolate package는 단일 스레드 Dart 코드를 가져와 응용 프로그램이 사용 가능한 하드웨어를 더 많이 사용할 수 있도록하는 Dart의 솔루션입니다.

Isolates이름에서 알 수 있듯이는 코드를 실행하는 격리 된 단위입니다. 그들간에 데이터를 보내는 유일한 방법은 클라이언트와 서버간에 메시지를 전달하는 방식과 같이 메시지를 전달하는 것입니다. 안isolate 프로그램이 즉시 멀티 코어 마이크로 프로세서를 활용할 수 있도록 도와줍니다.

예

이 개념을 더 잘 이해하기 위해 예를 들어 보겠습니다.

import 'dart:isolate';  
void foo(var message){ 
   print('execution from foo ... the message is :${message}'); 
}  
void main(){ 
   Isolate.spawn(foo,'Hello!!'); 
   Isolate.spawn(foo,'Greetings!!'); 
   Isolate.spawn(foo,'Welcome!!'); 
   
   print('execution from main1'); 
   print('execution from main2'); 
   print('execution from main3'); 
}

여기, spawn 의 방법 Isolate 클래스는 함수 실행을 용이하게합니다. foo, 나머지 코드와 병행합니다. 그만큼spawn 함수는 두 개의 매개 변수를 취합니다-

  • 스폰 될 함수
  • 생성 된 함수에 전달 될 객체.

생성 된 함수에 전달할 객체가없는 경우 NULL 값을 전달할 수 있습니다.

두 가지 기능 (foo and main)매번 같은 순서로 실행되지 않을 수도 있습니다. 언제에 대한 보장이 없습니다foo 실행되고 언제 main()실행됩니다. 실행할 때마다 출력이 달라집니다.

출력 1

execution from main1 
execution from main2 
execution from main3 
execution from foo ... the message is :Hello!!

출력 2

execution from main1 
execution from main2 
execution from main3 
execution from foo ... the message is :Welcome!! 
execution from foo ... the message is :Hello!! 
execution from foo ... the message is :Greetings!!

출력에서 Dart 코드가 새로운 isolate Java 또는 C # 코드가 새 스레드를 시작할 수있는 방식과 같은 코드 실행에서.

Isolates 실과 다르다는 점에서 isolate자체 메모리가 있습니다. 변수를 공유 할 방법이 없습니다.isolates—간에 통신 할 수있는 유일한 방법 isolates 메시지 전달을 통한 것입니다.

Note − 위의 출력은 하드웨어 및 운영 체제 구성에 따라 다릅니다.

v / s 미래 분리

복잡한 계산 작업을 비동기 적으로 수행하는 것은 애플리케이션의 응답 성을 보장하는 데 중요합니다. Dart Future 완료 후 비동기 작업의 값을 검색하는 메커니즘입니다. Dart Isolates 병렬 처리를 추상화하고 실용적인 고수준 기반으로 구현하는 도구입니다.

단위 테스트에는 애플리케이션의 모든 개별 단위 테스트가 포함됩니다. 개발자가 복잡한 애플리케이션 전체를 실행하지 않고도 작은 기능을 테스트 할 수 있도록 도와줍니다.

다트 external library "test"라는 이름은 단위 테스트를 작성하고 실행하는 표준 방법을 제공합니다.

Dart 단위 테스트에는 다음 단계가 포함됩니다.

Step 1: Installing the "test" package

현재 프로젝트에 타사 패키지를 설치하려면 다음이 필요합니다. pubspec.yaml파일. 설치하기 위해서test packages, 먼저 다음 항목을 pubspec.yaml 파일-

dependencies: 
test:

입력 한 후 마우스 오른쪽 버튼으로 pubspec.yaml파일 및 종속성을 가져옵니다. 그것은 설치합니다"test"꾸러미. 아래에 주어진 스크린 샷은WebStorm 편집자.

패키지는 다음에서 설치할 수 있습니다. command line너무. 터미널에 다음을 입력하십시오-

pub get

Step 2: Importing the "test" package

import "package:test/test.dart";

Step 3 Writing Tests

테스트는 최상위 함수를 사용하여 지정됩니다. test(), 동안 test assertions 사용하여 만들어집니다 expect()함수. 이러한 방법을 사용하려면pub 의존.

통사론

test("Description of the test ", () {  
   expect(actualValue , matchingValue) 
});

그만큼 group()기능을 사용하여 테스트를 그룹화 할 수 있습니다. 각 그룹의 설명은 테스트 설명의 시작 부분에 추가됩니다.

통사론

group("some_Group_Name", () { 
   test("test_name_1", () { 
      expect(actual, equals(exptected)); 
   });  
   test("test_name_2", () { 
      expect(actual, equals(expected)); 
   }); 
})

예 1 : 합격 테스트

다음 예제는 메소드를 정의합니다. Add(). 이 메서드는 두 개의 정수 값을 취하고 다음을 나타내는 정수를 반환합니다.sum. 이것을 테스트하려면add() 방법-

Step 1 − 가져 오기 test 아래에 주어진대로 포장.

Step 2 − 다음을 사용하여 테스트 정의 test()함수. 여기,test() 함수는 expect() 주장을 강제하는 기능.

import 'package:test/test.dart';      
// Import the test package 

int Add(int x,int y)                  
// Function to be tested { 
   return x+y; 
}  
void main() { 
   // Define the test 
   test("test to check add method",(){  
      // Arrange 
      var expected = 30; 
      
      // Act 
      var actual = Add(10,20); 
      
      // Asset 
      expect(actual,expected); 
   }); 
}

다음을 생성해야합니다. output −

00:00 +0: test to check add method 
00:00 +1: All tests passed!

예 2 : 실패한 테스트

그만큼 subtract()아래 정의 된 방법은 논리적 실수가 있습니다. 다음과 같은test 동일하게 확인합니다.

import 'package:test/test.dart'; 
int Add(int x,int y){ 
   return x+y; 
}
int Sub(int x,int y){ 
   return x-y-1; 
}  
void main(){ 
   test('test to check sub',(){ 
      var expected = 10;   
      // Arrange 
      
      var actual = Sub(30,20);  
      // Act 
      
      expect(actual,expected);  
      // Assert 
   }); 
   test("test to check add method",(){ 
      var expected = 30;   
      // Arrange 
      
      var actual = Add(10,20);  
      // Act 
      
      expect(actual,expected);  
      // Asset 
   }); 
}

Output − 기능에 대한 테스트 케이스 add() 통과하지만 테스트 subtract() 아래와 같이 실패합니다.

00:00 +0: test to check sub 
00:00 +0 -1: test to check sub 
Expected: <10> 
Actual: <9> 
package:test  expect 
bin\Test123.dart 18:5  main.<fn> 
   
00:00 +0 -1: test to check add method 
00:00 +1 -1: Some tests failed.  
Unhandled exception: 
Dummy exception to set exit code. 
#0  _rootHandleUncaughtError.<anonymous closure> (dart:async/zone.dart:938) 
#1  _microtaskLoop (dart:async/schedule_microtask.dart:41)
#2  _startMicrotaskLoop (dart:async/schedule_microtask.dart:50) 
#3  _Timer._runTimers (dart:isolate-patch/timer_impl.dart:394) 
#4  _Timer._handleMessage (dart:isolate-patch/timer_impl.dart:414) 
#5  _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

테스트 케이스 그룹화

그룹화 할 수 있습니다. test cases테스트 코드에 더 많은 의미를 추가합니다. 당신이 많은 경우test cases 이것은 훨씬 더 깨끗한 코드를 작성하는 데 도움이됩니다.

주어진 코드에서 우리는 split() 기능과 trim함수. 따라서 우리는 이러한 테스트 케이스를 논리적으로 그룹화하고String.

예

import "package:test/test.dart"; 
void main() { 
   group("String", () { 
      test("test on split() method of string class", () { 
         var string = "foo,bar,baz"; 
         expect(string.split(","), equals(["foo", "bar", "baz"])); 
      }); 
      test("test on trim() method of string class", () { 
         var string = "  foo "; 
         expect(string.trim(), equals("foo")); 
      }); 
   }); 
}

Output − 출력은 아래에 주어진대로 각 테스트 케이스에 대한 그룹 이름을 추가합니다 −

00:00 +0: String test on split() method of string class 
00:00 +1: String test on trim() method of string class 
00:00 +2: All tests passed

모든 웹 페이지는 객체로 간주 될 수있는 브라우저 창 안에 있습니다.

ㅏ Document object해당 창에 표시되는 HTML 문서를 나타냅니다. Document 개체에는 문서 콘텐츠에 대한 액세스 및 수정을 허용하는 다른 개체를 참조하는 다양한 속성이 있습니다.

문서 콘텐츠에 액세스하고 수정하는 방식을 Document Object Model, 또는 DOM. 개체는 계층 구조로 구성됩니다. 이 계층 구조는 웹 문서의 개체 구성에 적용됩니다.

  • Window− 계층의 최상위. 개체 계층 구조의 가장 바깥 쪽 요소입니다.

  • Document− 창에로드되는 각 HTML 문서는 문서 객체가됩니다. 문서에는 페이지의 내용이 포함되어 있습니다.

  • Elements− 웹 페이지의 콘텐츠를 나타냅니다. 예를 들면 텍스트 상자, 페이지 제목 등이 있습니다.

  • Nodes − 종종 요소이지만 속성, 텍스트, 주석 및 기타 DOM 유형일 수도 있습니다.

다음은 몇 가지 중요한 DOM 객체의 간단한 계층 구조입니다.

Dart는 dart:htmlDOM에서 객체와 요소를 조작하는 라이브러리. 콘솔 기반 응용 프로그램은dart:html도서관. 웹 애플리케이션에서 HTML 라이브러리를 사용하려면dart:html −

import 'dart:html';

계속해서 몇 가지 DOM Operations 다음 섹션에서.

DOM 요소 찾기

그만큼 dart:html 도서관은 querySelector DOM에서 요소를 검색하는 함수입니다.

Element querySelector(String selectors);

그만큼 querySelector() 함수는 지정된 선택기 그룹과 일치하는 첫 번째 요소를 반환합니다. "selectors 아래와 같이 CSS 선택기 구문을 사용하는 문자열이어야합니다.

var element1 = document.querySelector('.className'); 
var element2 = document.querySelector('#id');

예 : DOM 조작

Webstorm IDE에서 아래 단계를 따르십시오.

Step 1 − File NewProject → 위치에서 프로젝트 이름을 다음과 같이 입력하십시오. DemoWebApp.

Step 1 − "샘플 콘텐츠 생성"섹션에서 SimpleWebApplication.

샘플 프로젝트를 생성하고 DemoWebApp. 이있다pubspec.yaml 다운로드해야하는 종속성이 포함 된 파일.

name: 'DemoWebApp' 
version: 0.0.1 
description: An absolute bare-bones web app. 

#author: Your Name <[email protected]> 
#homepage: https://www.example.com  
environment:   
   sdk: '>=1.0.0 <2.0.0'  
dependencies:   
   browser: '>=0.10.0 <0.11.0'   dart_to_js_script_rewriter: '^1.0.1'  
transformers: 
- dart_to_js_script_rewriter

웹에 연결되어 있으면 자동으로 다운로드됩니다. 그렇지 않으면 pubspec.yaml 의존성을 얻습니다.

웹 폴더에는 세 개의 파일이 있습니다. Index.html, main.dart, 및 style.css

Index.html

<!DOCTYPE html>   
<html> 
   <head>     
      <meta charset = "utf-8">     
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge">     
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0">
      <meta name = "scaffolded-by" content = "https://github.com/google/stagehand">
      <title>DemoWebApp</title>     
      <link rel = "stylesheet" href = "styles.css">     
      <script defer src = "main.dart" type = "application/dart"></script>
      <script defer src = "packages/browser/dart.js"></script> 
   </head>
   
   <body>   
      <h1>
         <div id = "output"></div> 
      </h1>  
   </body> 
</html>

Main.dart

import 'dart:html';  
void main() {   
   querySelector('#output').text = 'Your Dart web dom app is running!!!.'; 
}

실행 index.html파일; 화면에 다음 출력이 표시됩니다.

이벤트 처리

그만큼 dart:html 도서관은 onClickDOM 요소에 대한 이벤트. 구문은 요소가 클릭 이벤트 스트림을 처리하는 방법을 보여줍니다.

querySelector('#Id').onClick.listen(eventHanlderFunction);

그만큼 querySelector() 함수는 주어진 DOM에서 요소를 반환하고 onClick.listen() 걸릴 것이다 eventHandler클릭 이벤트가 발생할 때 호출되는 메서드입니다. 구문eventHandler 아래에 주어진다-

void eventHanlderFunction (MouseEvent event){ }

이제 Dart의 이벤트 처리 개념을 이해하기위한 예를 들어 보겠습니다.

TestEvent.html

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0"> 
      <meta name = "scaffolded-by" content ="https://github.com/google/stagehand"> 
      <title>DemoWebApp</title> 
      <link rel = "stylesheet" href = "styles.css"> 
      <script defer src = "TestEvent.dart" type="application/dart"></script> 
      <script defer src = "packages/browser/dart.js"></script> 
   </head> 
   
   <body> 
      <div id = "output"></div> 
      <h1> 
         <div> 
            Enter you name : <input type = "text" id = "txtName"> 
            <input type = "button" id = "btnWish" value="Wish"> 
         </div> 
      </h1> 
      <h2 id = "display"></h2> 
   </body>
   
</html>

TestEvent.dart

import 'dart:html'; 
void main() { 
   querySelector('#btnWish').onClick.listen(wishHandler); 
}  
void wishHandler(MouseEvent event){ 
   String name = (querySelector('#txtName')  as InputElement).value; 
   querySelector('#display').text = 'Hello Mr.'+ name; 
}

산출

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved