首页 > 其他分享 >dart的语法

dart的语法

时间：2023-08-03 15:47:16浏览次数：38  
标签：String age dart 语法 var print main void

dart的语法

main方法

main(){
  print("有返回值");
}
void main() {
   print("没有返回值");
}
字符串的定义的方式
//字符串定义的几种方式
var str1 = "this is str1";
var str2 = "this is str2";
//2.字符串的拼接 2 种
 var str3 = str1 + str2;
 print("$str1 $str2");
//字符串 双引号与单引号三个
list类型
 //创建list
var l1 = [1,3,5];
print(l1[1]);
​
//创建指定类型的list
var l2 = <String>["123","ecfff"];
​
 //定义一个null的list
var l3 = [];
​
// 创建固定长度的list
var l5 =List.filled(4, "");
map类型
//第一种定义map的方式
var person = {"name":"张三丰","age":180,"work":["程序员","外卖员"]};
print(person);
print(person["name"]);
​
//创建新的map
var p = new Map();
p["name"]="李四";
print(p);
is 关键字来判断类型
// Dart 判断数据类型
//is 关键字来判断类型
var a1 = "ssssssss";
var a2 = 4.0;
​
print(a1 is String); //true
print(a2 is int);  //false
print(a2 is double); //true
算数运算符
   int a =5;
   int b = 3;
   print(a/b); //1.6666666666666667  
   print(a%b); //2
   print(a~/b); //1
逻辑运算符
//  ！取反
//  &&并且
//  ||或者
基础赋值运算符
//1.基础赋值运算符 =    ??=
//b ?? =23 表示如果b为null 把23赋值给b
​
//2.复合赋值运算符 +=  -=  *=  /=   %=  ~/=
var c=13;
c+=10; //表示c = c+10
条件表达式
   int a =5;
   int b = 3;
   print(a/b); //1.6666666666666667  
   print(a%b); //2
   print(a~/b); //1
算数运算符
   int a =5;
   int b = 3;
   print(a/b); //1.6666666666666667  
   print(a%b); //2
   print(a~/b); //1
​
//1.    if (a>b) { } else { }
//2 switch
       var sex ="男1";
       switch (sex) {
         case "男" : 
         print("这是男");
           
           break;
         default:
            print("传入参数错误");
           break;
       }
​
//2、 三目运算符
      String vv = 1>2 ? '我是true' : '我是FALSE';
      print(vv);
​
//3、 ?? 运算符
//  b ?? =23 表示如果b为null 把23赋值给b
类型转换
//1、Number与string类型之间的转换
//Number类型转换成string类型 tostring()
// string类型转成Number类型parse
​
 String str= '123';
 var myNum=int.parse( str);
 print(myNum is int); //true
​
//如何str 为null 就会报错 处理方法
​
 String str= '';
​
try{
 var myNum=int.parse( str);
print(myNum is int); //true
 }catch(e){
 print("报错");
​
 }
​
// 2、其他类型转换成Booleans类型
// isEmpty :判断字符串是否为空
​
var str=' ';
if(str.isEmpty){
  print( 'str空');
  }else{
print(
   'str不为空');
}
​
//判断是否为 NaN
var myNum=0/0;
print(myNum);
​
if(myNum.isNaN){
  print( 'Nan ');
  }
循环语句
while 和 do while的有区别
continue;跳过当前循环体然后循环还会继续执行
break;跳出循环体
List里面常用的属性和方法:
常用属性:

length； 长度 reversed； 翻转 isEmpty； 是否为空 isNotEmpty； 是否不为空

常用方法:
add 增加 addAll；

拼接数组 indexof ；

查找传入具体值 remove ；

删除传入具体值 removeAt；

删除传入索引值 fillRange；

修改 insert(index, value);

指定位置插入 insertAl1(index,list)；

指定位置插入List toList() ；

其他类型转换成List join() ；

List转换成字符串 split() ；

字符串转化成List
常用的循环数据的方式
forEach map where any every 
var list = ["123","张三","李四"];
list.forEach((value){
  print("----------$value");
 });
map
var list = [2,888,34];
var newList = list.map((value){
return value*2;
});
print(newList.toList()); //[4, 1776, 68]
any
List myList=[1,3,4,5,7,8,9];
var f=myList.any((value){ //只要集合里面有满足条件的就返回true
return value>9;
});
print(f);
every
List myList=[1,3,4,5,7,8,9];
var f=myList.every((value){ //集合里面都满足条件的就返回true
return value>1;
});
print(f);
自定义方法
void main() {
​
printInfo();
String printString(){
  return 'this is str';
}
print(printString());
​
var ss = printString();
print(ss);
​
}
void printInfo(){
print("111111111111");
​
// 111111111111
// this is str
// this is str
}
定义一个带可选参数的方法
void main() {
​
print(printUserInfo('2222',2));
}
​
String printUserInfo(String username,[int ? age]){//行参
if(age!= null){
return "姓名:$username---年龄:$age";
}
return "姓名:$username---年龄保密";
}
定义一个带默认参数的方法[]
void main() {
​
print(printUsersInfo('2222',1));
}
​
​
String printUsersInfo(String username,[int ? age,String ? sex='男']){//行参
if(age!= null){
return "姓名:$username---年龄:$age------性别 $sex";
}
return "姓名:$username---年龄保密";
​
}
定义一个命名参效的方法{}
void main() {
​
print(printUserInfo('2222',age:1));
}
​
String printUserInfo(String username,{int ? age,String ? sex='男'}){//行参
if(age!= null){
return "姓名:$username---年龄:$age------性别 $sex";
}
return "姓名:$username---年龄保密";
​
}
实现一个把方法当做参数的方法
void main() {
fn2(fn1);
}
​
fn1(){
  print("fn16666666");
}
​
fn2(fn){
fn();
}
自执行方法
  (() {
    print('我是自执行方法');
  })();
​
  ((int n) {
    print(n);
    print('我是自执行方法');
  })(12);
箭头函数
void main() {
​
var list = ["123","张三","李四"];
​
list.forEach((value)=> {
  print(value)
});
}
1、全局变量特点: 全局变量常驻内存、全局变量污染全局
2、局部变量的特点： 不常驻内存会被垃圾机制回收、不会污染全局

想实现的功能：

1.常驻内存        
2.不污染全局   
​
  产生了闭包,闭包可以解决这个问题.....  
​
  闭包: 函数嵌套函数, 内部函数会调用外部函数的变量或参数, 变量或参数不会被系统回收(不会释放内存)

 

闭包的写法： 函数嵌套函数，并return 里面的函数，这样就形成了闭包。

  fn() {
    var a = 123; /*不会污染全局   常驻内存*/
    return () {
      a++;
      print(a);
    };
  }
​
  var b = fn();
  b();
  b();
  b();
​
类与对象

dart是面向对象的编程

自定义类
class PerSion{
  String name = '李四';
  int age = 44;
​
  void getInfo(){
    print("${this.name}==========${this.age}");
  }
}
void main() {
//实例化
var P1 = new PerSion();
​
print(P1.name);
P1.getInfo();
​
// 李四
// 李四==========44
}
命名构造函数
class PerSion{
​
  String name = '李四';
  int age = 44;
  PerSion(this.name);
  PerSion.onw(){
    print("这是一个命名函数");
  }
​
  void getInfo(String name){ 
    print("${name}==========${this.age}");
  }
}
void main() {
​
new PerSion.onw();  //这是一个命名函数
​
}
把类单独抽成一个文件
import 'lib/Person.dart';
私有方法前加‘_’，并且单独抽成一个文件 才会生效（间接公有调私有）
get与set
class PerSion{
  num height;
  num width;
​
PerSion(this.height,this.width);
 area(){
  return this.height*this.width;
}
 set areaHeight(value){
  this.height = value;
}
 get areas{
  return this.height*this.width;
}
​
}
void main() {
PerSion p = new PerSion(10,4);
​
print("面积：${p.area()}");  //面积：40
​
p.areaHeight=2;
print("面积_：${p.area()}"); //面积_：8
​
print("面积_2：${p.areas}"); //面积_2：8
​
}
构造函数体运行之前初始化实例变量
class PerSion{
  num height;
  num width;
​
PerSion():height=5,width=10;
 area(){
  return this.height*this.width;
}
​
}
void main() {
PerSion p = new PerSion();
print(p.area()); //50
​
}
Dart中的对象操作符：
?   条件运算符(了解)
as  类型转换
is  类型判断
..  级联操作(连缀)
   Person p1 = new Person();
p1..name = "李四"
  ..age  = 20
  ..printInfo();
类的继承
1.子类使用extends关键词来继承父类

2.子类会继承父类里面可见的属性和方法，但是不会继承构造函数

3.子类能复写父类的方法 getter和setter （ @override // 可以写 可以不写）
super关键字的使用
class Person {
  String name;
  num age;
  Person(this.name, this.age);
  void printInfo() {
    print('${this.name}----${this.age}');
  }
}
​
class Web extends Person {
  Web(String name, num age) : super(name, age);
}
​
main() {
  Web w = new Web('年龄：', 12);
  w.printInfo(); // 年龄----12
}
Dart抽象类

使用关键字 abstract 标识类可以让该类成为 抽象类，抽象类将无法被实例化 

abstract class Animal {
  speak(); /// 抽象方法, 子类必须实现该方法
  
  printInfo() {  /// 不是抽象方法, 子类不需要实现
    print('---- Animal, not abstract method');
    /// 调用了speak方法
    speak();
  }
}
​
class Dog extends Animal{
   @override
  speak() {
    print('---- Dog, 实现了抽象方法speak');
  }
}
void main() {  
  Dog d1 = Dog();
  d1.speak();
  d1.printInfo(); /// 方法内部调用了speak()方法
  
}
dart接口
/*
和Java一样，dart也有接口，但是和Java还是有区别的。
​
  首先，dart的接口没有interface关键字定义接口，而是普通类或抽象类都可以作为接口被实现。
​
  同样使用implements关键字进行实现。
​
  但是dart的接口有点奇怪，如果实现的类是普通类，会将普通类和抽象中的属性的方法全部需要覆写一遍。
  
  而因为抽象类可以定义抽象方法，普通类不可以，所以一般如果要实现像Java接口那样的方式，一般会使用抽象类。
​
  建议 使用抽象类定义接口。
​
*/
​
/*
定义一个DB库 支持 mysql  mssql  mongodb
​
mysql  mssql  mongodb三个类里面都有同样的方法
​
*/
​
​
abstract class Db{   //当做接口   接口：就是约定 、规范
    String uri;      //数据库的链接地址
    add(String data);
    save();
    delete();
}
​
class Mysql implements Db{
  
  @override
  String uri;
  Mysql(this.uri);
​
  @override
  add(data) {
    // TODO: implement add
    print('这是mysql的add方法'+data);
  }
  @override
  delete() {
    // TODO: implement delete
    return null;
  }
  @override
  save() {
    // TODO: implement save
    return null;
  }
  remove(){
      
  }
}
​
class MsSql implements Db{
  @override
  String uri;
  @override
  add(String data) {
    print('这是mssql的add方法'+data);
  }
​
  @override
  delete() {
    // TODO: implement delete
    return null;
  }
​
  @override
  save() {
    // TODO: implement save
    return null;
  }
}
​
main() {
​
  Mysql mysql=new Mysql('xxxxxx');
​
  mysql.add('1243214');
 
}
extends抽象类和implements的区别:

1、如果要复用抽象类里面的方法，并且要用抽象方法约束自类的话我们就用extends继承抽象类 2、如果只是把抽象类当做标准的话我们就用implements实现抽象类

一个类实现多个接口
class C implements A,B{}
在Dart中可以使用mixins实现类似多继承的功能

因为mixins使用的条件，随着Dart版本一直在变，这里讲的是Dart2.x中使用mixins的条件: 1、作为mixins的类只能继承自object，不能继承其他类 2、作为mixins的类不能有构造函数 3、一个类可以mixins多个mixins类 4、mixins绝不是继承，也不是接口，而是一种全新的特性

class C with A,B{}
泛型
泛型就是解决类接口方法的复用性、以及对不特定数据类型的支持(类型校验)
T getDate<T>(T value){
  return value;
}
void main() {  

  print(getDate(22)); //22
  print(getDate<String>("张三")); //张三
  print(getDate<int>(22)); //22

}
泛型类

实现数据缓存的功能:有文件缓存、和内存缓存:内存缓存和文件缓存按照接口约束实现。

Dart中的库主要有三种：
1、自定义的库
import 'lib/xxx.dart';
2、系统内置库
import 'dart:math';    
import 'dart:io'; 
import 'dart:convert';
3、第三方库——Pub包管理系统中的库

需要在自己想项目根目录新建一个pubspec.yaml

在pubspec.yaml文件 然后配置名称 、描述、依赖等信息 然后运行 pub get 获取包下载到本地 项目中引入库 import 'package:http/http.dart' as http; 看文档使用

1、从下面网址找到要用的库

https : // pub.dev/ packages

https ://pub.flutter-io.cn/packages

https:// pub.dartlang.org/flutter/

2、创建一个pubspec.yaml文件，内容如下
    name: xxx
    description: A new flutter module project.
    dependencies:  
        http: ^0.12.0+2
        date_format: ^1.0.6
3、配置dependencies
4、运行pub get 获取远程库
5、看文档引入库使用
async和await

这两个关键字的使用只需要记住两点:

只有async方法才能使用await关键字调用方法

如果调用别的async方法必须使用await关键字

async是让方法变成异步。

await是等待异步方法执行完成。

Dart库的重命名 Dart冲突解决 
import 'lib/Person1.dart';
import 'lib/Person2.dart' as lib;
​
main(List<String> args) {
  Person p1=new Person('张三', 20);
  p1.printInfo();
​
  lib.Person p2=new lib.Person('李四', 20);
  p2.printInfo();
部分引入库
/*
部分导入
  如果只需要导入库的一部分，有两种模式：
     模式一：只导入需要的部分，使用show关键字，如下例子所示：
      import 'package:lib1/lib1.dart' show foo;
     模式二：隐藏不需要的部分，使用hide关键字，如下例子所示：
      import 'package:lib2/lib2.dart' hide foo;      
*/
​
// import 'lib/myMath.dart' show getAge;
延迟加载 
/*
延迟加载
​
    也称为懒加载，可以在需要的时候再进行加载。
    懒加载的最大好处是可以减少APP的启动时间。
​
    懒加载使用deferred as关键字来指定，如下例子所示：
​
    import 'package:deferred/hello.dart' deferred as hello;
​
    当需要使用的时候，需要使用loadLibrary()方法来加载：
​
    greet() async {
      await hello.loadLibrary();
      hello.printGreeting();
    }
*/
Null safety
/*
Null safety翻译成中文的意思是空安全。
null safety 可以帮助开发者避免一些日常开发中很难被发现的错误，并且额外的好处是可以改善性能
Flutter2.2.0 （2021年5月19日发布）之后的版本都要求使用null safety。
?可空类型
!类型断言
*/
?可空类型
void main() {  
String? username = "张三";
int? age =8;
username = null;
age = null;
}
!类型断言
void main() {  
String? username = "张三";
int? age =8;
username = null;
age = null;
print("username:${username}"); //username:null
print("age:${age}"); //age:null
​
print(username !.length); //如果username为null 抛异常
​
}
late关键字主要用于延迟初始化
class getLate{
late String name;
}
required关键词

主要用于允许根据需要标记任何命名参数（函数或类)，使得 它们不为空。因为可选参数中必须有个 require

void debugger({required String message}) {}
Dart 性能优化之常量、常量构造函数详解
/*
Dart常量:final 和const修饰符
const声明的常量是在编译时确定的,永远不会改变
final声明的常量允许声明后再赋值，赋值后不可改变，final 声明的变量是在运行时确定的
final不仅有const的编译时常量的特性，最重要的它是运行时常量，并且final是惰性初始化
​
const关键词在多个地方创建相同的对象的时候，内存中只保留了一个对象
*/
identical函数 :检查两个引用是否指向同一个对象
void main() {  
var o1 = new Object();
var o2 = new Object();
print(identical(o1, o2)); //false
print(identical(o1, o1)); //true
}
//表示实例化常量构造函数
//o1和 o2共享了存储空间
void main() {  
var o1 = const Object();
var o2 = const Object();
print(identical(o1, o2)); //true
print(identical(o1, o1)); //true
}
dart中普通构造函数
class Container{
  int width;
  int height;
Container({required this.width,required this.height});
}
​
void main() {  
var o1 = new Container(width: 100,height: 20);
var o2 = new Container(width: 100,height: 20);
print(identical(o1, o2)); //false
print(identical(o1, o1)); //true
}
dart中常量构造函数
/**
 1、常量构造函数需以const关键字修饰
 2、const构造函数必须用于成员变量都是final的类
 3、如果实例化时不加const修饰符，即使调用的是常量构造函数，实例化的对象也不是常量实例
 4、实例化常量构造函数的时候，多个地方创建这个对象，如果传入的值相同,如果传入的值相同，只会保留一个对象
 5、Flutter中const修饰不仅仅是节省组件构建时的内存开销,Flutter 在需要重新构建const组件是不应该改变的，重新构建没有任何意义，因此·Flutter·不会重建构建·const·组件
​
 */
​
class Container{
 final int width;
 final int height;
const  Container({required this.width,required this.height});
}
​
void main() {  
var o1 = new Container(width: 100,height: 20);
var o2 = new Container(width: 100,height: 20);
print(identical(o1, o2)); //false
print(identical(o1, o1)); //true
​
var o3 = const Container(width: 100,height: 20);
var o4 = const Container(width: 100,height: 20);
print(identical(o3, o4)); //true
print(identical(o3, o4)); //true
}

 


​
 

 

标签：String,age,dart,语法,var,print,main,void
From： https://www.cnblogs.com/xbinbin/p/17603494.html

相关文章

  • Go 语言入门指南: 环境搭建、基础语法和常用特性解析 ｜ 青训营
    Go语言入门指南:环境搭建、基础语法和常用特性解析｜青训营从零开始Go语言简介Go是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。Go是从2007年末由RobertGriesemer,RobPike,KenThompson主持开发，后来还加入了IanLanceTaylor,RussCox等人，并最终......
  • 【python_4】基础语法：字面量和注释！
    1.字面量的含义字面量：在代码中，被写下来的固定的值，称之为字面量。2.常见的字面量类型类型描述说明数字Number支持：整数int浮点数float复数complex布尔bool整数int，如10，-10浮点数float，如13.14，-13.14复数complex，如4+3j布尔bool，表达现实生活中的逻辑，即真和假，True表示真，False表示假。True......
  • SQL语法
    1、sql语句||的用法select(mc||xuehao)efromstudent;就是将两个字段的数据拼接在一起变成一个字段内容2、日期操作1：日期和字符转换函数（to_date,to_char）https://blog.csdn.net/m0_49273322/article/details/119006677......
  • Linux su命令：su命令语法、su root与su - root区别、su与sudo区别、su -c 参数的使用理
    https://www.cnblogs.com/goloving/p/15150206.html Linuxsu（英文全拼：switchuser）命令用于变更为其他使用者的身份，除root外，需要键入该使用者的密码。使用权限：所有使用者。一、语法su[-fmp][-ccommand][-sshell][--help][--version][-][USER[ARG]]1、参数说......
  • Python | 基础语法
    1.字面量字面量：在代码中，被写下来的固定的值1.1Python常用的6种值（数据）的类型类型描述说明数字整数(int)、浮点数(float)、复数(complex)、布尔(bool)字符串描述文本的一种数据类型由任意数量的字符组成列表有序的可变序列元组有序的不可变序列可......
  • Dart vs Kotlin vs Swift 语法比较
    原文地址juejin.cn"世界上只有两种编程语言：一种经常被人喷，一种没人用。”——BjarneStroustrup现代原生移动应用主要由Swift(iOS)或者Kotlin(Android)编程语言开发。另外有两种主要的跨平台应用开发框架——ReactNative(JavaScript)和Flutter，后者以Dart......
  • Kotlin与Java语法对比学习
    定义变量//Kotlinvali:Int=10//定义一个整数变量vald:Double=10.0//定义一个双精度浮点数变量valb:Boolean=true//定义一个布尔变量valc:Char='a'//定义一个字符变量vals:String="Hello,World!"//定义一个字符串变量valarr:Array<I......
  • Kotlin/Swift语法对比
    原文地址juejin.cn变量和常量SwiftvarmyVariable=42letmyConstant=42KotlinvarmyVariable=42valmyConstant=42对比：变量都是variable，常量kotlin是val，swift是let，let在js中主要是做局部变量，js中常量有const类型声明SwiftletexplicitD......
  • MySQL8_SQL语法
    MySQL8_SQL语法SQL全称StructuredQueryLanguage，结构化查询语言。操作关系型数据库的编程语言，定义了一套操作关系型数据库统一标准。 一、SQL通用语法在学习具体的SQL语句之前，先来了解一下SQL语言的同于语法。1).SQL语句可以单行或多行书写，以分号结尾。2).SQL语句可......
  • shell基本语法
    shell定义变量不能=号之间不能有空格定义：弱语言输出变量：echo${变量名称}（花括号可以省略）作用域：在外面定义的变量，在里面没有环境变量为全局变量判断命令是否执行成功：$?=0说明上条命令执行成功$?=1~255说明上条命令执行失败单引号和双引号的区别：单引号不能识别特殊语法......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99