Dart (2) - Propiedades y métodos comunes de expresiones de bucle, lista, conjunto y mapa
definición de método
dart自定义方法的基本格式：
返回类型 方法名称（参数1，参数2,...）{
方法体
return 返回值 / 或无返回值;
}
Algunos ejemplos de métodos de definición:
void printInfo(){
print('我是一个自定义方法');
}
int getNum(){
var count = 123;
return count;
}
String printUserInfo(){
return 'this is str';
}
List getList(){
return ['111','2222','333'];
}
Dart no tiene palabras clave como public , etc., y la horizontal inferior lo representa directamente .private_private
alcance del método
void main(){
void outFun(){
innerFun(){
print('aaa');
}
innerFun();
}
// innerFun(); 错误写法
outFun(); //调用方法
}
parámetro del método
Definición general:
String getUserInfo(String username, int age) {
//形参
return "姓名:$username -> 年龄:$age";
}
print(printUserInfo('小明', 23)); //实参
En Dart, puede definir un método con parámetros opcionales. Los parámetros opcionales deben especificar el valor predeterminado del tipo:
void main() {
String printUserInfo(String username, [int age = 0]) { //age格式表示可选
//形参
if (age != 0) {
return "姓名:$username -> 年龄:$age";
}
return "姓名:$username -> 年龄不详";
}
print(printUserInfo('小明', 28)); //实参
//可选就可以不传了
print(printUserInfo('李四'));
}
Defina un método con parámetros predeterminados:
String getUserInfo(String username,[String sex='男',int age=0]){ //形参
if(age!=0){
return "姓名:$username -> 性别:$sex -> 年龄:$age";
}
return "姓名:$username -> 性别:$sex -> 年龄不详";
}
print(getUserInfo('张三'));
print(getUserInfo('李四','男'));
print(getUserInfo('李梅梅','女',25));
Para definir un método de parámetros con nombre, definir un parámetro con nombre requiere especificar un valor predeterminado de tipo:
La ventaja de los parámetros con nombre es que se pueden usar sin asignarlos en orden, consulte el siguiente código:
String getUserInfo(String username, {int age = 0, String sex = '男'}) {//形参
if (age != 0) {
return "姓名:$username -> 性别:$sex -> 年龄:$age";
}
return "姓名:$username -> 性别:$sex -> 年龄保密";
}
print(getUserInfo('张三',sex: '男',age: 20));
Defina un método que tome un método como parámetro:
De hecho, los métodos se pueden usar como parámetros, lo que Kotlines lo mismo que:
//方法1 随便打印一下
fun1() {
print('fun1');
}
//方法2 参数是一个方法
fun2(fun) {
fun();
}
//调用fun2这个方法 把fun1这个方法当做参数传入
fun2(fun1());
La función de flecha y la función se llaman entre sí
función de flecha
En el estudio anterior, sabemos que podemos usar forEachpara recorrer List, el formato general es el siguiente:
List list = ['a', 'b', 'c'];
list.forEach((value) {
print(value);
});
Las funciones de flecha se pueden acortar a este formato:
list.forEach((value) => print(value));
La flecha detrás de la flecha apunta al valor de retorno del método. Cabe señalar aquí que:
Solo se puede escribir una declaración en una función de flecha, y no hay punto y coma (;) después de la declaración
mapEl método de la flecha también se puede utilizar para simplificar el ejemplo de conversión anterior :
List list = [1, 3, 6, 8, 9];
var newList = list.map((value) {
if (value > 3) {
return value * 2;
}
return value;
});
Aquí hay que modificar Listlos datos del interior, multiplicar los valores mayores de 3 en la matriz por 2. Eso se puede simplificar con funciones de flecha y se puede escribir como:
var newList = list.map((value) => value > 3 ? value*2 : value);
Una oración de finalización de código, muy interesante.
Llamada mutua de funciones
// 定义一个方法来判断一个数是否是偶数
bool isEvenNumber(int n) {
if (n % 2 == 0) {
return true;
}
return false;
}
// 定义一个方法打印1-n以内的所有偶数
prinEvenNumber(int n) {
for (var i = 1; i <= n; i++) {
if (isEvenNumber(i)) {
print(i);
}
}
}
prinEvenNumber(10);
Métodos anónimos, métodos autoejecutables y recursión de métodos
método anónimo
var printNum = (){
print(12);
};
printNum();
Es obvio aquí Kotlinque las características son básicamente las mismas que en . Método anónimo con parámetros:
var printNum = (int n) {
print(n + 2);
};
printNum(3);
método de ejecución automática
Como su nombre lo indica, no es necesario llamar al método autoejecutable y se ejecutará automáticamente, porque la definición y la invocación de la función autoejecutable están integradas. Cuando creamos una función anónima y la ejecutamos, dado que no se puede hacer referencia a sus variables internas desde el exterior, se liberará poco después de la ejecución y este enfoque no contaminará el objeto global. Ver el siguiente código:
((int n) {
print("这是一个自执行方法 + $n");
})(666);
}
recursividad del método
La recursividad del método no es más que seguir llamándose a sí mismo dentro del método bajo la condición de que se cumpla la condición, ver el siguiente código:
var sum = 0;
void fn(int n) {
sum += n;
if (n == 0) {
return;
}
fn(n - 1);
}
fn(100);
print(sum);
La implementación es sumar 1 a 100.
Cierre
El cierre es un concepto de front-end. En la etapa inicial de desarrollo del cliente, Javase puede decir que no admite el cierre, o un cierre incompleto, Kotlinpero puede admitir la operación de cierre.
El cierre significa que la función es una función anidada, la función interna llamará a las variables o parámetros de la función externa, y el sistema no reclamará las variables o parámetros (la memoria no se liberará) . Así que los dos problemas que resuelven los cierres son:
- memoria residente variable
- Las variables no contaminan lo global
La forma general de escribir un cierre es:
- Las funciones anidan funciones y devuelven las funciones dentro, formando así un cierre .
Escritura de cierre:
Function func() {
var a = 1; /*不会污染全局 常驻内存*/
return () {
a++;
print(a);
};
}
Después de devolver el método anónimo aquí, el valor de a puede residir en la memoria:
var mFun = func();
mFun();
mFun();
mFun();
Imprimir: 2, 3, 4.