notas de estudio del cliente iOS (6): flujo de trabajo del cliente iOS

El flujo de trabajo del cliente iOS se puede resumir simplemente como:
operación del usuario -> visualización de visualización -> procesamiento interactivo -> adquisición de datos -> procesamiento de datos -> visualización de datos.

Combinado con el código, se proporciona una descripción más específica y completa de cada flujo de trabajo:

1) Operación del usuario

Los usuarios operan a través de elementos interactivos como botones, cuadros de texto y diapositivas en la interfaz y activan los eventos correspondientes.
Las operaciones del usuario incluyen clics en botones, entrada de texto, reconocimiento de gestos, etc., que se realizan agregando controles correspondientes y métodos de procesamiento de eventos.

Cada categoría se describirá en detalle a continuación y se dará un ejemplo de código específico.

evento de clic de botón

El evento de clic de botón significa que el usuario hace clic en el botón en la interfaz para activar el evento correspondiente. El método se puede usar en el cliente de iOS addTargetpara agregar un método de manejo de eventos para el botón. A continuación se muestra un ejemplo que demuestra cómo agregar un controlador de eventos de clic a un botón.

// 添加按钮控件
let button = UIButton()
button.setTitle("Click me", for: .normal)
button.addTarget(self, action: #selector(buttonClicked), for: .touchUpInside)
view.addSubview(button)

// 处理按钮点击事件
@objc func buttonClicked() {
    print("Button clicked")
}

En el código anterior, creamos un control de botón y addTargetle agregamos un método de manejo de eventos de clic usando el método. En el método de procesamiento de eventos, podemos implementar la lógica de interacción correspondiente, como abrir un cuadro emergente, cambiar la interfaz, etc.

evento de entrada de cuadro de texto

El evento de entrada de cuadro de texto significa que el usuario ingresa texto en el cuadro de texto y activa el evento correspondiente. El método se puede usar en el cliente de iOS addTargetpara agregar un método de procesamiento de eventos para el cuadro de texto. A continuación se muestra un ejemplo que demuestra cómo agregar controladores de eventos de entrada a un cuadro de texto.

// 添加文本框控件
let textField = UITextField()
textField.placeholder = "Enter your name"
textField.addTarget(self, action: #selector(textFieldChanged), for: .editingChanged)
view.addSubview(textField)

// 处理文本框输入事件
@objc func textFieldChanged() {
    guard let text = textField.text else { return }
    print("Text changed: \(text)")
}

En el código anterior, creamos un control de cuadro de texto y addTargetle agregamos un método de manejo de eventos de entrada usando el método. En el método de procesamiento de eventos, podemos obtener el contenido de entrada en el cuadro de texto e implementar la lógica de interacción correspondiente.

evento de diapositiva

El evento de deslizamiento se refiere a que el usuario realiza una operación de deslizamiento en la interfaz para activar un evento correspondiente. Las clases se pueden usar en clientes de iOS UIGestureRecognizerpara agregar reconocedores de gestos a las vistas para manejar eventos deslizantes. A continuación se muestra un ejemplo que muestra cómo agregar un reconocedor de gestos de deslizamiento a una vista.

// 添加视图控件
let view = UIView()
view.backgroundColor = UIColor.red
self.view.addSubview(view)

// 添加滑动手势识别器
let swipeGesture = UISwipeGestureRecognizer(target: self, action: #selector(swipe))
swipeGesture.direction = .right
view.addGestureRecognizer(swipeGesture)

// 处理滑动事件
@objc func swipe() {
    print("Swiped")
}

En el código anterior, creamos un control de vista y le agregamos un reconocimiento de gestos de deslizamiento. En el método de procesamiento de eventos del reconocedor de gestos, podemos implementar la lógica de interacción correspondiente, como cambiar el color de la vista, cambiar la interfaz, etc.

2) ver pantalla

De acuerdo con las operaciones del usuario y el contenido de los datos, el cliente muestra las vistas correspondientes, incluido el diseño de la interfaz, los estilos de control, los íconos, las imágenes, etc.
La visualización de la vista incluye el diseño de la interfaz, el estilo de control, los iconos, las imágenes, etc., y se realiza agregando los controles correspondientes y configurando las propiedades.

El diseño de la interfaz, los estilos de control, los íconos y las imágenes se describirán en detalle a continuación y se brindarán ejemplos de código específicos.

diseño de la interfaz

El diseño de la interfaz se refiere a la posición, tamaño, disposición, etc. de cada control en el cliente. Hay varias formas de implementar el diseño de la interfaz en el cliente de iOS, incluido el diseño manual, el diseño automático y el diseño de cuadrícula. Entre ellos, el diseño automático es el método más utilizado y el diseño automático se puede realizar estableciendo la relación de restricción entre los controles.

// 添加文本框控件
let textField = UITextField()
textField.translatesAutoresizingMaskIntoConstraints = false
view.addSubview(textField)

// 添加约束关系
NSLayoutConstraint.activate([
    textField.topAnchor.constraint(equalTo: view.topAnchor, constant: 50),
    textField.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
    textField.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20),
    textField.heightAnchor.constraint(equalToConstant: 40)
])

En el código anterior, primero creamos un control de cuadro de texto y lo agregamos a la vista principal. Luego, realice el diseño automático del control de cuadro de texto estableciendo la relación de restricción entre el control de cuadro de texto y la vista principal.

estilo de control

El estilo de control se refiere a la apariencia, color, fuente, etc. de cada control en el cliente. En el cliente de iOS, el estilo del control se puede cambiar configurando la propiedad del control. El siguiente es un ejemplo que demuestra cómo crear un control de botón y establecer su estilo.

// 添加按钮控件
let button = UIButton()
button.setTitle("Click me", for: .normal)
button.setTitleColor(UIColor.white, for: .normal)
button.backgroundColor = UIColor.blue
button.layer.cornerRadius = 5
button.clipsToBounds = true
view.addSubview(button)

En el código anterior, primero creamos un control de botón y configuramos su título, color de texto, color de fondo, esquinas redondeadas y otras propiedades para cambiar su estilo.

icono

El ícono se refiere al ícono, color del ícono, etc. de cada control en el cliente. En el cliente de iOS, el icono del control se puede cambiar configurando la propiedad del icono del control. El siguiente es un ejemplo para demostrar cómo crear un control de etiqueta y configurar su icono.

// 添加标签控件
let label = UILabel()
label.text = "Hello, world!"
label.textColor = UIColor.black
label.font = UIFont.systemFont(ofSize: 20)
label.layer.cornerRadius = 5
label.clipsToBounds = true
view.addSubview(label)

// 添加图标
let image = UIImage(named: "icon.png")
let imageView = UIImageView(image: image)
imageView.contentMode = .scaleAspectFit
imageView.translatesAutoresizingMaskIntoConstraints = false
label.addSubview(imageView)

// 添加约束关系
NSLayoutConstraint.activate([
    imageView.centerYAnchor.constraint(equalTo: label.centerYAnchor),
    imageView.leadingAnchor.constraint(equalTo: label.leadingAnchor, constant: 10),
    imageView.widthAnchor.constraint(equalToConstant: 20),
    imageView.heightAnchor.constraint(equalToConstant: 20)
])

En el código anterior, primero creamos un control de etiqueta y configuramos su texto, color de texto, fuente y otras propiedades para cambiar su estilo. Luego, creamos un ícono y lo agregamos al control de etiqueta, y realizamos el diseño del ícono estableciendo la relación de restricción entre el control de ícono y el control de etiqueta.

imagen

La imagen se refiere a la imagen de fondo, el color de la imagen, etc. de cada control en el cliente. En el cliente de iOS, la imagen se puede cambiar configurando la propiedad de imagen de fondo del control. El siguiente es un ejemplo para demostrar cómo crear un control de botón y establecer su imagen de fondo.

// 添加按钮控件
let button = UIButton()
button.setTitle("Click me", for: .normal)
button.setTitleColor(UIColor.white, for: .normal)
button.setBackgroundImage(UIImage(named: "button.png"), for: .normal)
button.layer.cornerRadius = 5
button.clipsToBounds = true
view.addSubview(button)

En el código anterior, creamos un control de botón y configuramos su título, color de texto, imagen de fondo y otras propiedades para cambiar su estilo.

3) procesamiento interactivo

El cliente procesa la lógica de interacción correspondiente de acuerdo con la operación del usuario y la visualización de la vista, incluida la verificación de la entrada del usuario, el cambio de interfaz, la respuesta al evento de control, etc.
El procesamiento de interacciones incluye la verificación de la entrada del usuario, el cambio de interfaz, la respuesta de eventos de control, etc., y se realiza agregando los controles correspondientes y los métodos de procesamiento de eventos.
La verificación de la entrada del usuario, el cambio de interfaz y la respuesta del evento de control se describirán en detalle a continuación, y se darán ejemplos de códigos específicos.

Validación de entrada de usuario

La validación de la entrada del usuario significa que el cliente verifica la entrada del usuario para garantizar que los datos de entrada cumplan con los requisitos. El cliente de iOS puede verificar el contenido de entrada después de que se completa la entrada del usuario al agregar un método de procesamiento de eventos y dar un mensaje de aviso cuando falla la verificación. El siguiente es un ejemplo que demuestra cómo crear un control de cuadro de texto y validar la entrada del usuario.

// 添加文本框控件
let textField = UITextField()
textField.placeholder = "Enter your name"
textField.addTarget(self, action: #selector(textFieldChanged), for: .editingChanged)
view.addSubview(textField)

// 处理文本框输入事件
@objc func textFieldChanged() {
    guard let text = textField.text else { return }
    if text.count < 5 {
        textField.layer.borderColor = UIColor.red.cgColor
        textField.layer.borderWidth = 1
    } else {
        textField.layer.borderColor = UIColor.green.cgColor
        textField.layer.borderWidth = 1
    }
}

En el código anterior, creamos un control de cuadro de texto y agregamos un método de manejo de eventos para validar el contenido de entrada después de que se complete la entrada del usuario. Cuando falla la validación, cambiamos el color del borde y el ancho del control del cuadro de texto para dar un mensaje rápido de falla de validación.

conmutación de interfaz

El cambio de interfaz significa que el cliente cambia entre diferentes interfaces. En el cliente iOS, el cambio de interfaz se puede realizar mediante el uso de controles como un controlador de navegación y un controlador de pestañas. A continuación se muestra un ejemplo que muestra cómo crear un controlador de navegación y cambiar entre diferentes pantallas.

// 添加导航控制器
let vc1 = UIViewController()
vc1.title = "First"
let vc2 = UIViewController()
vc2.title = "Second"
let navController = UINavigationController(rootViewController: vc1)
view.addSubview(navController.view)

// 切换界面
navController.pushViewController(vc2, animated: true)

En el código anterior, creamos un controlador de navegación y agregamos la primera interfaz como su controlador de vista raíz. Luego, usamos pushViewControllerel método para insertar la segunda interfaz en el controlador de navegación, realizando así el cambio de interfaz.

Respuesta al evento de control

La respuesta al evento de control significa que el cliente responde a las operaciones del usuario para implementar la lógica de interacción correspondiente. El cliente de iOS puede responder a los eventos de control agregando métodos de procesamiento de eventos. A continuación se muestra un ejemplo que demuestra cómo crear un control de botón que responde cuando el usuario hace clic en el botón.

// 添加按钮控件
let button = UIButton()
button.setTitle("Click me", for: .normal)
button.addTarget(self, action: #selector(buttonClicked), for: .touchUpInside)
view.addSubview(button)

// 处理按钮点击事件
@objc func buttonClicked() {
    // ...
}

En el código anterior, creamos un control de botón y agregamos un controlador de eventos para responder cuando el usuario hace clic en el botón. En el método de procesamiento de eventos, podemos implementar la lógica de interacción correspondiente, como abrir un cuadro emergente, cambiar la interfaz, etc.

4) Adquisición de datos

El cliente obtiene datos del servidor o localmente, incluidas solicitudes de red, consultas de bases de datos, lectura de archivos, etc.
La adquisición de datos incluye solicitudes de red, consultas de bases de datos, lectura de archivos, etc., y se realiza mediante el uso de las API y los protocolos correspondientes.

// 发送GET请求
let url = URL(string: "https://api.example.com/data")
let task = URLSession.shared.dataTask(with: url!) { data, response, error in
    if let error = error {
        print(error.localizedDescription)
        return
    }
    guard let data = data else { return }
    // 处理返回的数据
}

// 执行查询语句
let db = try! Connection("path/to/database.sqlite")
let users = try! db.prepare("SELECT * FROM users")
for user in users {
    print(user["name"])
}

// 读取文件内容
let text = try! String(contentsOfFile: "path/to/file.txt")
print(text)

La solicitud de red, la consulta de la base de datos y la lectura de archivos se describirán en detalle a continuación, y se darán ejemplos de códigos específicos.

solicitud de red

Una solicitud de red significa que el cliente se conecta al servidor a través de la red para obtener datos. Las clases se pueden usar en clientes de iOS URLSessionpara implementar solicitudes de red. A continuación se muestra un ejemplo que demuestra cómo usar URLSessionla clase para obtener datos del servidor.

// 创建URL对象
let url = URL(string: "https://www.example.com/data.json")!

// 创建URLSession对象
let session = URLSession.shared

// 创建请求对象
let request = URLRequest(url: url)

// 发送请求
let task = session.dataTask(with: request) { (data, response, error) in
    if let error = error {
        print("Error: \(error.localizedDescription)")
        return
    }
    guard let data = data else {
        print("Error: data is nil")
        return
    }
    // 处理数据
}

// 启动任务
task.resume()

En el código anterior, creamos un URLSessionobjeto, luego usamos dataTaskel método para enviar una solicitud y procesamos los datos devueltos una vez que se completa la solicitud.

consulta de base de datos

Consulta de base de datos significa que el cliente obtiene datos de la base de datos local. Se pueden usar Core Datamarcos o bibliotecas en clientes de iOS SQLitepara implementar consultas de bases de datos. A continuación se muestra un ejemplo que demuestra cómo usar Core Datael marco para obtener datos de una base de datos local.

// 获取NSManagedObjectContext对象
let appDelegate = UIApplication.shared.delegate as! AppDelegate
let context = appDelegate.persistentContainer.viewContext

// 创建查询请求
let request = NSFetchRequest<NSFetchRequestResult>(entityName: "Person")

// 执行查询
do {
    let result = try context.fetch(request)
    for data in result as! [NSManagedObject] {
        let name = data.value(forKey: "name") as! String
        let age = data.value(forKey: "age") as! Int
        print("Name: \(name), Age: \(age)")
    }
} catch {
    print("Error: \(error)")
}

En el código anterior, primero obtuvimos un NSManagedObjectContextobjeto, luego creamos una solicitud de consulta y usamos fetchel método para ejecutar la consulta. Después de que se devuelven los resultados de la consulta, iteramos a través del conjunto de resultados y generamos el nombre y la edad de cada persona.

archivo leído

La lectura de archivos significa que el cliente obtiene datos de un archivo local. Las clases se pueden usar en clientes iOS FileManagerpara leer archivos. El siguiente es un ejemplo que demuestra cómo usar FileManagerla clase para obtener datos de un archivo local.

// 获取文件路径
let path = Bundle.main.path(forResource: "data", ofType: "txt")!

// 读取文件内容
do {
    let content = try String(contentsOfFile: path)
    print("File content: \(content)")
} catch {
    print("Error: \(error)")
}

En el código anterior, primero obtuvimos una ruta de archivo, luego usamos el método Stringde la clase contentsOfFilepara leer el contenido del archivo y generar el contenido del archivo.

5) Tratamiento de datos

El cliente procesa los datos adquiridos, incluido el análisis de datos, la conversión de datos y el filtrado de datos.
El procesamiento de datos incluye el análisis de datos, la conversión de datos, el filtrado de datos, etc., y se realiza mediante el uso de las API y los métodos correspondientes.

Bien, el análisis de datos, la conversión de datos y el filtrado de datos se describirán en detalle a continuación, y se darán ejemplos de código específicos.

análisis de los datos

El análisis de datos se refiere a los datos sin procesar obtenidos por el cliente del servidor o localmente, analizados y extraídos de la información requerida. Las clases se pueden usar en clientes de iOS JSONSerializationpara analizar datos con formato JSON en diccionarios o matrices. A continuación se muestra un ejemplo que demuestra cómo usar JSONSerializationla clase para analizar datos con formato JSON en un diccionario.

// 假设从服务器获取到了以下JSON格式的数据
let jsonData = """
{
    "name": "John",
    "age": 30,
    "address": {
        "street": "123 Main St",
        "city": "New York",
        "state": "NY"
    }
}
""".data(using: .utf8)!

// 解析JSON数据
do {
    let json = try JSONSerialization.jsonObject(with: jsonData, options: [])
    if let dict = json as? [String: Any] {
        let name = dict["name"] as! String
        let age = dict["age"] as! Int
        let address = dict["address"] as! [String: Any]
        let street = address["street"] as! String
        let city = address["city"] as! String
        let state = address["state"] as! String
        print("Name: \(name), Age: \(age), Street: \(street), City: \(city), State: \(state)")
    }
} catch {
    print("Error: \(error)")
}

En el código anterior, usamos JSONSerializationla clase para analizar los datos en formato JSON en un diccionario y extraer la información de nombre, edad, calle, ciudad y estado.

conversión de datos

La conversión de datos significa que el cliente convierte el formato de los datos adquiridos para satisfacer las necesidades comerciales. El método se puede utilizar en el cliente de iOS mappara convertir los elementos de la matriz. El siguiente es un ejemplo para demostrar cómo usar mapel método para convertir los elementos de la matriz.

// 假设从服务器获取到了以下JSON格式的数据
let jsonData = """
[
    { "name": "John", "age": 30 },
    { "name": "Mary", "age": 25 },
    { "name": "Tom", "age": 35 }
]
""".data(using: .utf8)!

// 解析JSON数据
do {
    let json = try JSONSerialization.jsonObject(with: jsonData, options: [])
    if let array = json as? [[String: Any]] {
        let persons = array.map { dict -> Person in
            let name = dict["name"] as! String
            let age = dict["age"] as! Int
            return Person(name: name, age: age)
        }
        print("Persons: \(persons)")
    }
} catch {
    print("Error: \(error)")
}

// Person结构体
struct Person {
    var name: String
    var age: Int
}

En el código anterior, usamos JSONSerializationla clase para analizar los datos en formato JSON en una matriz y usamos mapel método para convertir cada diccionario de la matriz en Personuna estructura. Después de la conversión, podemos realizar un procesamiento adicional de los datos convertidos, como ordenar, filtrar, etc.

filtrado de datos

El filtrado de datos significa que el cliente filtra los datos adquiridos para satisfacer las necesidades comerciales. Los métodos se pueden utilizar en el cliente de iOS filterpara filtrar los elementos de la matriz. El siguiente es un ejemplo que demuestra cómo usar filterel método para filtrar elementos en una matriz.

// 假设从服务器获取到了以下JSON格式的数据
let jsonData = """
[
    { "name": "John", "age": 30 },
    { "name": "Mary", "age": 25 },
    { "name": "Tom", "age": 35 }
]
""".data(using: .utf8)!

// 解析JSON数据
do {
    let json = try JSONSerialization.jsonObject(with: jsonData, options: [])
    if let array = json as? [[String: Any]] {
        let persons = array.map { dict -> Person in
            let name = dict["name"] as! String
            let age = dict["age"] as! Int
            return Person(name: name, age: age)
        }
        let filteredPersons = persons.filter { $0.age > 30 }
        print("Filtered persons: \(filteredPersons)")
    }
} catch {
    print("Error: \(error)")
}

// Person结构体
struct Person {
    var name: String
    var age: Int
}

En el código anterior, usamos JSONSerializationla clase para analizar los datos en formato JSON en una matriz y usamos mapel método para convertir cada diccionario de la matriz en Personuna estructura. Después de la transformación, usamos filterel método para filtrar los datos transformados y solo conservamos a las personas cuya edad es mayor de 30 años. Después del filtrado, podemos realizar un procesamiento adicional de los datos filtrados, como ordenar, agrupar, etc.

6) visualización de datos

El cliente muestra los datos procesados en la interfaz, incluidas listas, detalles, gráficos, mapas, etc.
La visualización de datos incluye listas, detalles, gráficos, mapas, etc., y se realiza utilizando los controles y métodos correspondientes.

Ok, a continuación describiré cada categoría en detalle y daré ejemplos de código específicos.

pantalla de lista

Visualización de lista significa que el cliente muestra los datos procesados en la interfaz en forma de lista. Las clases se pueden usar en clientes iOS UITableViewpara crear una vista de tabla para mostrar datos de lista. A continuación se muestra un ejemplo que muestra cómo usar UITableViewla clase, mostrando una lista simple de personas.

// 创建表格视图
let tableView = UITableView(frame: view.bounds, style: .plain)
tableView.dataSource = self
tableView.delegate = self
view.addSubview(tableView)

// 实现数据源方法
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    return persons.count
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = UITableViewCell(style: .subtitle, reuseIdentifier: nil)
    let person = persons[indexPath.row]
    cell.textLabel?.text = person.name
    cell.detailTextLabel?.text = "Age: \(person.age)"
    return cell
}

// 实现委托方法
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let person = persons[indexPath.row]
    print("Selected person: \(person)")
}

En el código anterior, creamos una vista de tabla e implementamos el método de fuente de datos y el método de delegado. En el método de fuente de datos, devolvimos el número de filas en la lista y configuramos los datos correspondientes para cada fila. En el método de delegado, manejamos el evento de que el usuario haga clic en el elemento de la lista y generamos la información de la persona seleccionada.

Detalles

Visualización detallada significa que el cliente muestra los datos procesados en la interfaz en forma de detalles. La clase se puede usar en el cliente de iOS UILabelpara crear una vista de etiqueta para mostrar datos detallados. A continuación se muestra un ejemplo que muestra cómo usar UILabella clase para mostrar el detalle de una persona.

// 创建标签视图
let nameLabel = UILabel(frame: CGRect(x: 0, y: 100, width: view.bounds.width, height: 30))
let ageLabel = UILabel(frame: CGRect(x: 0, y: 150, width: view.bounds.width, height: 30))
view.addSubview(nameLabel)
view.addSubview(ageLabel)

// 设置标签内容
let person = Person(name: "John", age: 30)
nameLabel.text = person.name
ageLabel.text = "Age: \(person.age)"

En el código anterior, creamos dos vistas de etiquetas y configuramos el contenido correspondiente para mostrar el nombre y la edad de una persona.

Visualización de gráfico

Visualización de gráficos significa que el cliente muestra los datos procesados en la interfaz en forma de gráficos. Se puede usar una biblioteca de gráficos de terceros en el cliente de iOS, por ejemplo Charts, para crear una vista de gráfico para mostrar los datos del gráfico. A continuación se muestra un ejemplo que muestra cómo usar Chartsla biblioteca, mostrando un histograma simple.

// 创建柱状图视图
let barChartView = BarChartView(frame: CGRect(x: 0, y: 100, width: view.bounds.width, height: 300))
view.addSubview(barChartView)

// 设置柱状图数据
let values = [BarChartDataEntry(x: 1, y: 10), BarChartDataEntry(x: 2, y: 20), BarChartDataEntry(x: 3, y: 30)]
let dataSet = BarChartDataSet(entries: values, label: "Values")
let data = BarChartData(dataSet: dataSet)
barChartView.data = data

En el código anterior, usamos Chartsla biblioteca, creamos una vista de histograma y configuramos los datos correspondientes para ella. Una vez que se configuran los datos, podemos personalizar aún más la vista del gráfico, como configurar colores, títulos, etc.

visualización del mapa

La visualización del mapa significa que el cliente muestra los datos procesados en la interfaz en forma de mapa. Las clases se pueden usar en clientes de iOS MKMapViewpara crear una vista de mapa para mostrar datos de mapas. A continuación se muestra un ejemplo que muestra cómo usar MKMapViewla clase, mostrando un mapa simple.

// 创建地图视图
let mapView = MKMapView(frame: view.bounds)
view.addSubview(mapView)

// 设置地图区域和标注
let location = CLLocationCoordinate2D(latitude: 37.7749, longitude: -122.4194)
let span = MKCoordinateSpan(latitudeDelta: 0.1, longitudeDelta: 0.1)
let region = MKCoordinateRegion(center: location, span: span)
mapView.setRegion(region, animated: true)

let annotation = MKPointAnnotation()
annotation.coordinate = location
annotation.title = "San Francisco"
mapView.addAnnotation(annotation)

En el código anterior, creamos una vista de mapa y establecemos el área del mapa y las etiquetas para ella. Después de la configuración, podemos personalizar aún más la vista del mapa, como agregar rutas, cambiar estilos de etiquetas, etc.

Resumir:

En este flujo de trabajo, cada enlace es muy importante. Si hay algún problema en algún enlace, afectará la experiencia de todo el cliente. Por lo tanto, los desarrolladores de clientes deben diseñar y desarrollar cuidadosamente cada enlace, y optimizarlo y mejorarlo continuamente para mejorar el rendimiento y la experiencia del usuario del cliente.