HarmonyOS第一课-对比Kotlin，快速入门TypeScript

news2024/12/26 21:45:37

编程语言简介

ArkTS

基础类型

1. 布尔值

  • TypeScript 和 Kotlin: 两者都有 boolean 类型，用于表示 true 或 false。

ts示例：

let isDone:boolean = false

kotlin示例：

val isDone: Boolean = false

2. 数字

  • TypeScript: 有 number 类型，它包括整数和浮点数。它还支持二进制、八进制和十六进制字面量；
  • Kotlin: 有更精细的数字类型，包括 Byte、Short、Int、Long、Float、Double。其中 Int、Long、Float 和 Double 最常用。Kotlin 同样支持十进制、二进制、十六进制和八进制字面量。

ts示例：

let decLiteral: number = 2024

kotlin示例：

val int: Int = 123
val long: Long = 123L
val double: Double = 123.0
val float: Float = 123.0f

3. 字符串

  • TypeScript: 有 string 类型，使用双引号 (“”) 或单引号 (‘’) 来包围字符串。TS中可以使用反引号来创建多行字符串；

  • Kotlin: 也有 String 类型，可以使用双引号 (“”) 包围字符串。此外，Kotlin 支持三引号 (“”") 创建多行字符串。

ts示例：

let name:string = "wangzhengyi"

kotlin示例：

val str: String = "Hello"

4. 数组

  • TypeScript: 使用 Array 类型，可以通过两种方式定义：number[] 或 Array；
  • Kotlin: 使用 Array 类型，有特定的函数用于创建数组，如 arrayOf()、intArrayOf() 等。

ts示例：

// 定义数组
let arr: number[] = [1, 2, 3];

// 增加元素
arr.push(4); // arr is now [1, 2, 3, 4]

// 删除元素
arr.pop(); // removes the last element, arr is now [1, 2, 3]

// 修改元素
arr[0] = 0; // arr is now [0, 2, 3]

// 检索元素
let firstElement = arr[0]; // firstElement is 0

// 遍历数组
arr.forEach((value, index) => {
    console.log(`Element at index ${index} is ${value}`);
});

kotlin示例：

// 定义数组
val arr = mutableListOf(1, 2, 3)

// 增加元素
arr.add(4) // arr is now [1, 2, 3, 4]

// 删除元素
arr.removeAt(arr.size - 1) // removes the last element, arr is now [1, 2, 3]

// 修改元素
arr[0] = 0 // arr is now [0, 2, 3]

// 检索元素
val firstElement = arr[0] // firstElement is 0

// 遍历数组
for ((index, value) in arr.withIndex()) {
    println("Element at index $index is $value")
}

5. 元组

  • TypeScript: 支持元组，元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。
  • Kotlin: 不直接支持元组，但可以使用 Pair 或 Triple 类来模拟二元组和三元组。

ts示例：

// 定义 Pair
let pair: [number, string] = [1, "one"];

// 访问元素
let firstElement = pair[0];  // firstElement is 1
let secondElement = pair[1]; // secondElement is "one"

// 修改元素
pair[0] = 2; // pair is now [2, "one"]
pair[1] = "two"; // pair is now [2, "two"]

// 遍历 Pair
for (let value of pair) {
    console.log(`Value is ${value}`);
}

// TypeScript 中的元组是固定长度的，所以不能直接添加或删除元素。如果需要改变元组的长度，需要创建一个新的元组。

kotlin示例：

// 定义 Pair
var pair = Pair(1, "one")

// 访问元素
val firstElement = pair.first  // firstElement is 1
val secondElement = pair.second // secondElement is "one"

// 修改元素 - Kotlin 中的 Pair 是只读的，所以不能直接修改。如果需要改变 Pair 的值，需要创建一个新的 Pair。
pair = Pair(2, "two")  // pair is now (2, "two")

// 遍历 Pair
for (value in pair.toList()) {
    println("Value is $value")
}

6. 枚举

enum类型是对JavaScript标准数据类型的一个补充，使用枚举类型可以为一组数值赋予友好的名字。

ts示例：

// 定义枚举
enum Color {
  Red,
  Green,
  Blue
}

// 检索值
let color: Color = Color.Red; // color is Color.Red

// 修改值
color = Color.Blue; // color is Color.Blue

// TypeScript 中的枚举是不可变的，无法添加或删除成员
// 遍历枚举
for (let name in Color) {
  if (typeof Color[name] === 'number') {
    console.log(Color[name]); // 输出枚举值
  }
}

kotlin：

// 定义枚举
enum class Color {
  RED,
  GREEN,
  BLUE
}

// 检索值
var color: Color = Color.RED // color is Color.RED

// 修改值
color = Color.BLUE // color is Color.BLUE

// Kotlin 中的枚举是不可变的，无法添加或删除成员
// 遍历枚举
for (enumValue in Color.values()) {
  println(enumValue.name) // 输出枚举名称
}

需要注意的是，TypeScript 和 Kotlin 中的枚举都是不可变的，一旦定义就不能添加或删除成员。这是因为枚举的设计就是为了定义一组固定的值，不应该在运行时改变这些值。

7. null和undefined

  • 在 TypeScript 和 Kotlin 中，null 和 undefined 都表示变量没有值，但它们的使用和语义有所不同；
  • 在 TypeScript 中，null 和 undefined 是两种不同的类型，它们都可以被用作变量的值，表示变量没有值。默认情况下，它们是所有其他类型的子类型，可以赋值给其他类型的变量。
  • 在 Kotlin 中，null 是一个特殊的值，可以被用作所有可空类型的值。Kotlin 提供了空安全的特性，只有明确声明类型为可空的变量才能被赋值为 null。Kotlin 没有 undefined 这个概念，如果一个变量没有值，那么它的值就是 null。

ts示例：

let a: number = null;      // Ok
let b: string = undefined; // Ok

但是，如果在 TypeScript 中启用了 strictNullChecks 选项，那么 null 和 undefined 就只能赋值给它们自己的类型和 void 类型。

let a: number = null;      // Error
let b: string = undefined; // Error
let c: void = undefined;   // Ok

kotlin示例:

var a: String = null  // Error
var b: String? = null // Ok

8. void

  • 在 TypeScript ，void 类型的主要用途是表示函数没有返回值。你可以声明一个 void 类型的变量，但是它只能赋值为 undefined 或 null。
  • 在 Kotlin 中，如果一个函数没有返回任何有用的值，它的返回类型就是 Unit。这个和 TypeScript 中的 void 是类似的

ts示例：

function warnUser(): void {
    console.log("This is a warning message");
}

let unusable: void = undefined;

kotlin示例:

fun warnUser(): Unit {
    println("This is a warning message")
}

9. unknown和Any

  • 有时候，我们会想要为那些在编程阶段还不清楚类型的变量指定一个类型，那么我们可以使用unknown类型来标识这些变量。
  • 在 TypeScript 中，unknown 是最顶级的类型（top type）。这意味着在启用了严格的类型检查时，可以将任何类型的值赋值给 unknown 类型的变量，但是不能将 unknown 类型的变量赋值给其他类型的变量，并且不能访问 unknown 类型的变量的任何属性，除非你使用类型断言或类型守卫。
  • 在 Kotlin 中，没有一个与 TypeScript 的 unknown 类型完全对应的类型。Kotlin 是静态类型语言，每个变量的类型都在编译时确定。如果你需要一个可以容纳任何类型的变量，可以使用 Any 类型，它是 Kotlin 中所有非空类型的超类。

ts示例：

let value: unknown;

value = "Hello"; // OK
value = 123; // OK
value = true; // OK

let valueString: string = value; // Error
value.length; // Error

if (typeof value === "string") {
    valueString = value; // OK inside this block
    console.log(value.length); // OK inside this block
}

kotlin示例：

var value: Any

value = "Hello" // OK
value = 123 // OK
value = true // OK

val valueString: String = value // Error, type mismatch

if (value is String) {
    println(value.length) // OK inside this block
}

10. 联合类型

  • 联合类型（Union Types）表示取值可以为多种类型中的一种；
  • 在 TypeScript 中，联合类型使用 | 字符分隔各个类型；
  • 在 Kotlin 中，没有直接的联合类型的概念。但是你可以使用 sealed class 或者 Any 来模拟联合类型。

ts示例：

let value: string | number | boolean;

value = "Hello"; // OK
value = 123; // OK
value = true; // OK

if (typeof value === "string") {
    console.log(value.substr(2)); // OK
}

kotlin示例：

// 使用sealed class
sealed class UnionType {
    data class TypeString(val value: String) : UnionType()
    data class TypeInt(val value: Int) : UnionType()
    data class TypeBoolean(val value: Boolean) : UnionType()
}

var value: UnionType = UnionType.TypeString("Hello")

when (value) {
    is UnionType.TypeString -> println(value.value.length)
    is UnionType.TypeInt -> println(value.value + 1)
    is UnionType.TypeBoolean -> println(!value.value)
}

// 使用Any
var value: Any = "Hello"

when (value) {
    is String -> println(value.length)
    is Int -> println(value + 1)
    is Boolean -> println(!value)
}

条件语句

TypeScript 和 Kotlin 都支持传统的条件语句，例如 if-else 和 switch-case，但是在某些方面，它们有一些相似和不同的地方。

if-else 语句

在 TypeScript 和 Kotlin 中，if-else 语句的用法非常相似，都用于进行条件判断。

TypeScript 的 if-else 示例

let number = 5;
if (number > 0) {
    console.log("Number is positive.");
} else {
    console.log("Number is not positive.");
}

Kotlin 的 if-else 示例

val number = 5
if (number > 0) {
    println("Number is positive.")
} else {
    println("Number is not positive.")
}

但是，Kotlin 的 if-else 还可以作为表达式使用，返回一个值。这在 TypeScript 中是不可能的。

val number = 5
val result = if (number > 0) {
    "Number is positive."
} else {
    "Number is not positive."
}
println(result)

switch-case 语句

TypeScript 支持 switch-case 语句，而 Kotlin 使用 when 作为相应的替代。

TypeScript 的 switch-case 示例：

let fruit = "apple";
switch (fruit) {
    case "banana":
        console.log("I am a banana.");
        break;
    case "apple":
        console.log("I am an apple.");
        break;
    default:
        console.log("I am not a banana or an apple.");
        break;
}

Kotlin 的 when 示例

val fruit = "apple"
when (fruit) {
    "banana" -> println("I am a banana.")
    "apple" -> println("I am an apple.")
    else -> println("I am not a banana or an apple.")
}

Kotlin 的 when 表达式比 TypeScript 的 switch-case 更强大，它可以处理更复杂的条件，例如检查一个值是否在某个范围内，或者是否满足某个条件。

Kotlin 的 when 进阶示例:

val x = 10
when {
    x in 1..10 -> println("x is in the range.")
    x is Int -> println("x is an Int.")
    else -> println("None of the above.")
}

函数

函数定义

在 TypeScript 和 Kotlin 中，函数的定义都包括函数名、参数列表和函数体。

TypeScript 函数定义示例

function add(x: number, y: number): number {
    return x + y;
}

kotlin函数定义

fun add(x: Int, y: Int): Int {
    return x + y
}

可选参数

在 TypeScript 中，函数的参数可以被标记为可选的，这意味着如果在调用函数时没有提供这个参数，那么这个参数的值为 undefined。

TypeScript 可选参数示例

function greet(name?: string): void {
    if (name) {
        console.log(`Hello, ${name}!`);
    } else {
        console.log("Hello, world!");
    }
}

然而，在 Kotlin 中，没有直接的 “可选参数” 的概念，但是可以通过设置参数的默认值来达到类似的效果。

Kotlin 默认参数示例

fun greet(name: String = "world") {
    println("Hello, $name!")
}

变长参数

TypeScript 和 Kotlin 都支持变长参数，也就是你可以将任意数量的参数作为一个数组传递给函数。

TypeScript 变长参数示例：

function addNumbers(...numbers: number[]): number {
    let result = 0;
    for (let number of numbers) {
        result += number;
    }
    return result;
}

Kotlin 变长参数示例：

fun addNumbers(vararg numbers: Int): Int {
    var result = 0
    for (number in numbers) {
        result += number
    }
    return result
}

箭头函数

在 TypeScript 和 Kotlin 中，都可以使用箭头函数（又称为 Lambda 表达式），但是他们的语法和行为有些许不同。

TypeScript箭头函数

在 TypeScript 中，箭头函数使用 => 符号，它有以下特性：

  • 它不绑定自己的 this，arguments，super 或 new.target。这些函数内部的关键字将引用最接近的包含它们的非箭头函数。
  • 它不能用作构造函数，也就是说，不能使用 new 关键字调用箭头函数。
  • 它没有 prototype 属性。
  • yield 关键字通常不能在其主体中使用（除非它们被包含在一个允许使用的函数内）。

TS的箭头函数示例：

let add = (x: number, y: number): number => {
    return x + y;
};
console.log(add(1, 2)); // 输出 "3"

kotlin箭头函数

在 Kotlin 中，Lambda 表达式用 {} 包围，箭头函数使用 -> 符号，例如：

val add = { x: Int, y: Int ->
    x + y
}

println(add(1, 2)) // 输出 "3"

Kotlin Lambda 表达式的一些特性：

  • 如果 Lambda 只有一个参数，那么可以使用默认的参数名 it（如果没有显式地给参数命名的话）。
  • 如果一个函数的最后一个参数是一个函数，那么 Lambda 表达式可以在函数括号外部传入。
  • 如果函数只有一个 Lambda 表达式参数，那么可以完全省略括号。

函数参数

在 TypeScript 和 Kotlin 中，你都可以将函数作为参数传递给另一个函数。以下是一些例子：

TypeScript函数参数

在 TypeScript 中，可以定义一个函数类型，然后将一个匹配此类型的函数作为参数传递给另一个函数。下面是一个例子，其中一个函数接受另一个函数作为参数：

function applyFunction(value: number, func: (x: number) => number): number {
    return func(value);
}

const double = (x: number) => x * 2;

console.log(applyFunction(5, double));  // 输出 10

在此例子中，applyFunction 接受一个数字和一个函数作为参数。这个函数接受一个数字并返回一个数字。然后，applyFunction 将其第一个参数传递给这个函数，并返回结果。

kotlin函数参数

在 Kotlin 中，可以使用函数类型来定义一个可以接受其他函数作为参数的函数。以下是一个例子：

fun applyFunction(value: Int, func: (Int) -> Int): Int {
    return func(value)
}

val double = { x: Int -> x * 2 }

println(applyFunction(5, double))  // 输出 10

在这个例子中，applyFunction 接受一个整数和一个函数作为参数。这个函数接受一个整数并返回一个整数。然后，applyFunction 将其第一个参数传递给这个函数，并返回结果。

这两个例子展示了 TypeScript 和 Kotlin 中函数作为一等公民的概念，即函数可以被赋值给变量，可以作为参数传递给其他函数，也可以作为其他函数的返回值。

类

TypeScript 类定义和构造函数

在 TypeScript 中，类定义包括类名、构造函数和成员变量或方法。构造函数在 TypeScript 中被命名为 constructor。示例如下：

class Person {
    constructor(public name: string, private age: number) {}

    greet() {
        console.log(`Hello, my name is ${this.name}`);
    }
}

class Employee extends Person {
    constructor(name: string, age: number, public department: string) {
        super(name, age);
    }

    greet() {
        super.greet();
        console.log(`I work in ${this.department}`);
    }
}

let employee = new Employee("Alice", 25, "Engineering");
employee.greet();  
// 输出 "Hello, my name is Alice"
// 输出 "I work in Engineering"

在上述示例中，Person 类有两个成员变量 name 和 age（age 是私有的），一个公共方法 greet 和一个私有方法 getAge。greet 可以被类的实例访问，而 getAge 只能在类的内部访问。

Kotlin 类定义和构造函数

在 Kotlin 中，主构造函数是类头部的一部分，可以直接在类名后面定义。示例如下：

open class Person(val name: String, private val age: Int) {
    open fun greet() {
        println("Hello, my name is $name")
    }
}

class Employee(name: String, age: Int, val department: String) : Person(name, age) {
    override fun greet() {
        super.greet()
        println("I work in $department.")
    }
}

val employee = Employee("Alice", 25, "Engineering")
employee.greet()  
// 输出 "Hello, my name is Alice"
// 输出 "I work in Engineering."

模块

TypeScript 和 Kotlin 中的模块概念主要用于代码的组织和封装，有助于提高代码的可维护性和可重用性。

TypeScript模块

在 TypeScript 中，一个模块就是一个文件。每个 TypeScript 文件都是一个独立的作用域，文件中的变量、函数、类等默认都是私有的。如果你想在其他 TypeScript 文件中使用它们，那么你必须使用 export 关键字来导出它们，然后在其他文件中使用 import 关键字来导入它们。

例如，你可能有一个名为add.ts 的模块，它导出一个 add 函数：

// add.ts
export function add(x: number, y: number): number {
    return x + y;
}

然后在另一个名为 main.ts 的模块中，你可以导入并使用 add 函数：

// main.ts
import { add } from './math';
console.log(add(1, 2));  // 输出 3

Kotlin模块

在 Kotlin 中，模块（Module）是一种组织代码的方式，它可以包含多个文件、包和类。一个模块可以有自己的构建和测试过程。

Kotlin 中的模块概念更接近于项目或子项目的概念，比如在 IntelliJ IDEA 或 Android Studio 中创建的项目或者子项目就是模块。

此外，Kotlin 还有包（Package）的概念，用于组织相关的类、接口和函数。包名通常与文件的物理布局相匹配，但这并不是必须的。

例如，你可能有一个包含 add 函数的包 com.example.math：

// 在 com/example/math.kt 文件中
package com.example

fun add(x: Int, y: Int): Int {
    return x + y
}

然后在其他地方，你可以通过 import 关键字来导入并使用 add 函数：

// 在其他文件中
import com.example.add

fun main() {
    println(add(1, 2))  // 输出 3
}

容器类

TypeScript 和 Kotlin 都提供了丰富的容器类，比如数组和集合，用于存储和操作数据。以下是一些示例。

TypeScript

数组

在 TypeScript 中，数组是最常见的容器类，可以用于存储多个元素。数组元素可以通过索引访问和修改，可以添加和删除元素，并且可以使用 for…of 循环进行遍历。

let arr = [1, 2, 3];

// 增加元素
arr.push(4);  // arr 现在是 [1, 2, 3, 4]

// 删除元素
arr.pop();  // arr 现在是 [1, 2, 3]

// 修改元素
arr[0] = 10;  // arr 现在是 [10, 2, 3]

// 查询元素
console.log(arr[0]);  // 输出 10

// 遍历元素
for (let x of arr) {
    console.log(x);
}

Map

在 TypeScript 中，Map 是一种内置的集合类型，可以保存键值对，并且键可以是任意类型。

创建 Map、添加、删除、修改和查询元素的示例：

// 创建一个新的 Map
let map = new Map<string, number>();

// 增加元素
map.set('One', 1);

// 查询元素
console.log(map.get('One'));  // 输出 1

// 修改元素
map.set('One', 100);
console.log(map.get('One'));  // 输出 100

// 删除元素
map.delete('One');
console.log(map.get('One'));  // 输出 undefined

// 遍历 Map
map.set('Two', 2);
map.set('Three', 3);
for (let [key, value] of map) {
    console.log(`${key}: ${value}`);
}

Set

在 TypeScript 中，Set 是一种内置的集合类型，可以保存无重复的元素。
创建 Set、添加、删除和查询元素的示例：

// 创建一个新的 Set
let set = new Set<number>();

// 增加元素
set.add(1);

// 查询元素
console.log(set.has(1));  // 输出 true

// 删除元素
set.delete(1);
console.log(set.has(1));  // 输出 false

// 遍历 Set
set.add(2);
set.add(3);
for (let value of set) {
    console.log(value);
}

Kotlin

List

在 Kotlin 中，有两种类型的容器：不可变的（例如 List）和可变的（例如 MutableList）。不可变容器只能进行查询和遍历，不能进行添加、删除和修改。可变容器则支持所有操作。

val list = mutableListOf(1, 2, 3)

// 增加元素
list.add(4)  // list 现在是 [1, 2, 3, 4]

// 删除元素
list.removeAt(list.lastIndex)  // list 现在是 [1, 2, 3]

// 修改元素
list[0] = 10  // list 现在是 [10, 2, 3]

// 查询元素
println(list[0])  // 输出 10

// 遍历元素
for (x in list) {
    println(x)
}

Map

在 Kotlin 中，有两个 Map 接口：Map 和 MutableMap。Map 是不可变的，只提供了查询操作，不能添加、删除和修改元素。MutableMap 是可变的，可以添加、删除和修改元素。

创建 MutableMap、添加、删除、修改和查询元素的示例：

// 创建一个新的 MutableMap
val map = mutableMapOf<String, Int>()

// 增加元素
map["One"] = 1

// 查询元素
println(map["One"])  // 输出 1

// 修改元素
map["One"] = 100
println(map["One"])  // 输出 100

// 删除元素
map.remove("One")
println(map["One"])  // 输出 null

// 遍历 Map
map["Two"] = 2
map["Three"] = 3
for ((key, value) in map) {
    println("$key: $value")
}

Set

在 Kotlin 中，有两个 Set 接口：Set 和 MutableSet。Set 是不可变的，只提供了查询操作，不能添加和删除元素。MutableSet 是可变的，可以添加和删除元素。

创建 MutableSet、添加、删除和查询元素的示例：

// 创建一个新的 MutableSet
val set = mutableSetOf<Int>()

// 增加元素
set.add(1)

// 查询元素
println(set.contains(1))  // 输出 true

// 删除元素
set.remove(1)
println(set.contains(1))  // 输出 false

// 遍历 Set
set.add(2)
set.add(3)
for (value in set) {
    println(value)
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1232994.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

二进制位(计算机存储数据最小单位)

二进制位(计算机存储数据最小单位)

二进制数据中的一个位(bit)简写为b&#xff0c;音译为比特&#xff0c;是计算机存储数据的最小单位。一个二进制位只能表示0或1两种状态&#xff0c;要表示更多的信息&#xff0c;就要把多个位组合成一个整体&#xff0c;一般以8位二进制组成一个基本单位。计算机内部数据以二进…
阅读更多...
Camtasia2024喀秋莎软件注册机

Camtasia2024喀秋莎软件注册机

真的要被录屏软件给搞疯了&#xff0c;本来公司说要给新人做个培训视频&#xff0c;想着把视频录屏一下&#xff0c;然后简单的剪辑一下就可以了。可谁知道录屏软件坑这么多&#xff0c;弄来弄去头都秃了&#xff0c;不过在头秃了几天之后&#xff0c;终于让我发现了一个值得“…
阅读更多...
品尝葡萄酒要注意的重点事项有哪些？

品尝葡萄酒要注意的重点事项有哪些？

给自己倒一杯葡萄酒&#xff0c;抿一口&#xff0c;这很容易就知道这是不是你喜欢的了。通过一些练习和微调可以加深你对葡萄酒特性的理解&#xff0c;并在品尝时挖掘出葡萄酒中所有的味道。任何品酒师在分析新酒时都会遵循一系列步骤和规则&#xff0c;从外观到香气、味道和特…
阅读更多...
DAY59 503.下一个更大元素II + 42. 接雨水

DAY59 503.下一个更大元素II + 42. 接雨水

503.下一个更大元素II 题目要求&#xff1a; 给定一个循环数组&#xff08;最后一个元素的下一个元素是数组的第一个元素&#xff09;&#xff0c;输出每个元素的下一个更大元素。数字 x 的下一个更大的元素是按数组遍历顺序&#xff0c;这个数字之后的第一个比它更大的数&am…
阅读更多...
django ModelSerializer自定义显示字段

django ModelSerializer自定义显示字段

文章目录 前言一、问题二、解决 前言 最近在复习django的时候&#xff0c;发现了一个有趣的问题&#xff0c;解决了之后特意记录下来&#xff0c;以供以后参考。 一、问题 相信大家使用django的时候&#xff0c;被其DRF的强大功能所折服&#xff0c;因为它能通过简单的代码就…
阅读更多...
行列式某一行（列）的元素与另一行（列）对应元素的代数余子式的乘积之和等于0

行列式某一行（列）的元素与另一行（列）对应元素的代数余子式的乘积之和等于0

阅读更多...
生产环境_移动目标轨迹压缩应用和算法处理-Douglas-Peucker轨迹压缩算法

生产环境_移动目标轨迹压缩应用和算法处理-Douglas-Peucker轨迹压缩算法

场景&#xff1a; 我目前设计到的场景是&#xff1a;即在地图应用中&#xff0c;对GPS轨迹数据进行压缩&#xff0c;减少数据传输和存储开销&#xff0c;因为轨迹点太频繁了&#xff0c;占用空间太大&#xff0c;运行节点太慢了&#xff0c;经过小组讨论需要上这个算法&#x…
阅读更多...
Nosql的redis概述及基本操作

Nosql的redis概述及基本操作

关系数据库与非关系型数据库概述 关系型数据库 关系型数据库是一个结构化的数据库&#xff0c;创建在关系模型&#xff08;二维表格模型&#xff09;基础上&#xff0c;一般面向于记录。SQL语句(标准数据查询语言)就是一种基于关系型数据库的语言&#xff0c;用于执行对关系型…
阅读更多...
【Linux专题】退出bash后再运行jobs命令为什么不会显示后台任务

【Linux专题】退出bash后再运行jobs命令为什么不会显示后台任务

【Linux专题】firewalld 过滤出接口流量-CSDN博客文章浏览阅读214次。风和日丽&#xff0c;小微给你送福利~如果你是小微的老粉&#xff0c;这里有一份粉丝福利待领取...如果你是新粉关注到了小微&#xff0c;那恭喜你&#xff0c;你赚到了&#xff01;[欢迎关注微信公众号&…
阅读更多...
技巧大揭秘！如何优雅地应对Redis读写超时问题

技巧大揭秘！如何优雅地应对Redis读写超时问题

大家好&#xff0c;我是小米&#xff01;今天我们要聊的话题是在Java中如何优雅地处理Redis读写超时问题。这可是个让人头疼的问题&#xff0c;但别担心&#xff0c;我会在这里和大家一起揭开它的神秘面纱&#xff0c;分享一些超实用的技巧和优雅的处理方法。 问题背景 在我们…
阅读更多...
陶瓷行业废污水处理使用MES系统的作用

陶瓷行业废污水处理使用MES系统的作用

陶瓷行业属于高能耗、高污染行业&#xff0c;生产过程中消耗大量矿产资源和能源&#xff0c;产生的废气、废水、废渣、粉尘等对环境造成严重污染。在近年来&#xff0c;全社会环保意识增强&#xff0c;政府出台了一系列政策、措施加大节能、减排力度&#xff0c;整治行业污染。…
阅读更多...
NX二次开发UF_CAM_ask_lower_limit_plane_usage 函数介绍

NX二次开发UF_CAM_ask_lower_limit_plane_usage 函数介绍

文章作者&#xff1a;里海 来源网站&#xff1a;里海NX二次开发3000例专栏 UF_CAM_ask_lower_limit_plane_usage Defined in: uf_cam_planes.h int UF_CAM_ask_lower_limit_plane_usage(tag_t object_tag, UF_PARAM_lwplane_usage_t * usage ) overview 概述 Query the usa…
阅读更多...
Nginx解决跨域问题的一些想法

Nginx解决跨域问题的一些想法

参考博客https://blog.csdn.net/agonie201218/article/details/112562252&#xff0c;https://blog.csdn.net/Zisson_no_error/article/details/119357629。都是写得非常很好的文章 重中之重&#xff1a;一定要长眼睛&#xff0c;带脑子 通过跨域访问的报错&#xff0c;看清楚…
阅读更多...
H5生成二维码（HTML、CSS、QrCodeJs内含源码）

H5生成二维码（HTML、CSS、QrCodeJs内含源码）

H5生成二维码 前言二维码实现过程页面实现关键点全部源码 前言 本文主要讲解如何通过原生HTML、CSS、Js中的qrcodejs二维码生成库&#xff0c;实现一个输入URL按下回车后输出URL。文章底部有全部源码&#xff0c;需要可以自取。 实现效果图&#xff1a; 上述实现效果为&#…
阅读更多...
2023年11月中旬大模型新动向集锦

2023年11月中旬大模型新动向集锦

2023年11月中旬大模型新动向集锦 2023.11.21版权声明&#xff1a;本文为博主chszs的原创文章&#xff0c;未经博主允许不得转载。 1、谷歌生成式 AI 搜索生成体验&#xff08;SGE&#xff09;扩展到 120 多个新国家/地区 近日&#xff0c;Google 扩展了其由生成式人工智能驱…
阅读更多...
无法打开 “XXXX“ ,因为Apple 无法检测其是否包含恶意软件

无法打开 “XXXX“ ,因为Apple 无法检测其是否包含恶意软件

解决方案 设置 - > 隐私和安全性 这里会显示这个,点击仍要打开
阅读更多...
高压放大器使用方法介绍

高压放大器使用方法介绍

高压放大器是一种用于放大高压信号的电子设备&#xff0c;常用于科学研究、工业应用和医疗设备等领域。它可以将低电压信号放大到较高的电压水平&#xff0c;以满足特定应用的需求。 使用高压放大器需要注意以下几个方面&#xff1a; 1.了解设备规格&#xff1a;在使用高压放大…
阅读更多...
Linux操作系统使用及C高级编程-D9D10Linux 服务搭建与使用

Linux操作系统使用及C高级编程-D9D10Linux 服务搭建与使用

TFTP服务器 TFTP&#xff08;Trivial File Transfer Protocol&#xff09;即简单文件传输协议&#xff0c;是TCP/IP协议中一个用来在客户机与服务器之间进行简单文件传输的协议&#xff0c;提供不复杂、开销不大的文件传输服务。端口号为69 1、使用客户服务器方式和使用UDP数据…
阅读更多...
Vue项目Jenkins自动化部署

Vue项目Jenkins自动化部署

1. 需求描述 我们希望提交uat分支时，UAT项目能够自动发布，提交master分支时，无需自动发布，管理员手工发布 2. 效果展示 3. 采用技术 Jenkins + K8S + Docker + Nginx 4. 具体实现 4.1 编写default.conf 在Vue项目根目录新建default.conf文件，主要进行代理配置、首页…
阅读更多...
yum 搭建仓库 http/ftp

yum 搭建仓库 http/ftp

目录 http ftp http 服务端 1. 下载 httpd 服务&#xff0c;记得将防火墙和安全终端全部关掉 2. 开启 httpd 服务 3. 临时挂载 客户端 1. 下载 httpd 服务&#xff0c;记得将防火墙和安全终端全部关掉 2. 开启 httpd 服务 3. 进入 /etc/yum.repos.d 4. 新建一个目录 mhy&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023