首页 > 编程语言 >javascript（js）入门指南

javascript（js）入门指南

时间：2024-08-28 19:27:42浏览次数：14  
标签：console log 函数 javascript name let const js 入门

JavaScript 常用知识点全面指南

1. 变量声明

在 JavaScript 中，变量用于存储数据。你可以使用 var、let 或 const 来声明变量。

  • var：早期使用的变量声明方式，有函数作用域。声明的变量可以在其所在的函数内任何地方访问，存在变量提升。

    var x = 10;

  • let：推荐的声明方式，有块级作用域，不存在变量提升。只能在声明后使用。

    let y = 20;

  • const：用于声明常量，声明后不能重新赋值。也有块级作用域。

    const z = 30;

2. 数据类型

JavaScript 中有多种数据类型，主要包括以下几类：

  • 原始类型（Primitive Types）：

    • 字符串 (String)：用于表示文本，如 "Hello", 'World'。
    • 数字 (Number)：用于表示整数和浮点数，如 42, 3.14。
    • 布尔值 (Boolean)：用于表示真值 (true) 和假值 (false)。
    • 空值 (Null)：表示一个空对象引用。
    • 未定义 (Undefined)：表示变量未赋值。
    • 符号 (Symbol)：用于创建唯一的标识符。

  • 引用类型（Reference Types）：

    • 对象 (Object)：用于存储键值对的集合或更复杂的实体。
    • 数组 (Array)：特殊类型的对象，用于存储有序集合。
    • 函数 (Function)：可调用的对象，用于封装逻辑代码。

3. 运算符

JavaScript 提供了多种运算符，用于执行不同的操作：

  • 算术运算符：用于执行数学运算，如加 (+)、减 (-)、乘 (*)、除 (/)、取余 (%)。

    let sum = 10 + 20;  // 30

  • 比较运算符：用于比较两个值的大小或相等性，如 ==、===、!=、!==、>、< 等。

    let isEqual = (5 === 5);  // true

  • 逻辑运算符：用于布尔值的逻辑操作，如与 (&&)、或 (||)、非 (!)。

    let result = true && false;  // false

  • 赋值运算符：用于给变量赋值，如 =、+=、-=、*= 等。

    let x = 10;
x += 5;  // 15

4、 模板字符串

4.1 模板字符串的基本概念

模板字符串是用反引号（` `）包裹的字符串，可以包含插值表达式、换行符以及其他更复杂的字符串处理功能。

定义模板字符串

模板字符串由反引号（` `）包裹，支持多行字符串和嵌入表达式。

// 定义模板字符串
const greeting = `Hello, world!`;
const multiLine = `This is a string
that spans multiple lines.`;
嵌入表达式

使用 ${} 语法可以在模板字符串中嵌入变量和表达式。表达式会被计算，并将结果插入到字符串中。

const name = "Alice";
const age = 30;
const message = `Hello, ${name}. You are ${age} years old.`;
console.log(message);  // 输出 "Hello, Alice. You are 30 years old."

4.2 模板字符串的功能

多行字符串

模板字符串允许直接书写多行字符串，无需使用换行符或转义字符。

const poem = `Roses are red,
Violets are blue,
Sugar is sweet,
And so are you.`;
console.log(poem);
插入变量和表达式

通过 ${} 语法插入 JavaScript 表达式，支持动态生成字符串内容。

const price = 100;
const discount = 20;
const finalPrice = `The final price after discount is $${price - discount}.`;
console.log(finalPrice);  // 输出 "The final price after discount is $80."
字符串插值和格式化

可以利用模板字符串进行复杂的字符串插值和格式化操作，例如生成动态 SQL 查询、HTML 内容等。

const userId = 42;
const query = `SELECT * FROM users WHERE id = ${userId};`;
console.log(query);  // 输出 "SELECT * FROM users WHERE id = 42;"

4.3 模板字符串的应用场景

动态内容生成

模板字符串非常适合用来生成动态内容，例如用户界面、报告生成等。

const userName = "John";
const userAge = 25;
const profile = `<div>
                    <h1>${userName}</h1>
                    <p>Age: ${userAge}</p>
                 </div>`;
document.body.innerHTML = profile;
多行文本处理

处理多行文本时，模板字符串的自然换行和格式化功能使代码更加整洁。

const htmlTemplate = `
    <header>
        <h1>Welcome to my website</h1>
    </header>
    <main>
        <p>This is the main content area.</p>
    </main>
    <footer>
        <p>&copy; 2024 My Website</p>
    </footer>`;

5. 控制结构

控制结构决定代码的执行流程。常用的控制结构包括条件语句和循环语句。

  • 条件语句 (if-else)：用于根据条件的真假来执行不同的代码块。

    let age = 18;
if (age >= 18) {
    console.log("You are an adult.");
} else {
    console.log("You are a minor.");
}

  • switch 语句：用于基于不同的情况执行代码块。

    let day = 3;
switch (day) {
    case 1:
        console.log("Monday");
        break;
    case 2:
        console.log("Tuesday");
        break;
    case 3:
        console.log("Wednesday");
        break;
    default:
        console.log("Unknown day");
}

  • 循环语句 (for, while)：用于重复执行代码块，直到条件不成立。

    • for 循环：

      for (let i = 0; i < 5; i++) {
    console.log(i);  // 输出 0 到 4
}

    • while 循环：

      let i = 0;
while (i < 5) {
    console.log(i);
    i++;
}

6. 函数

1. 函数的定义

在 JavaScript 中，可以通过多种方式定义函数：

  • 函数声明：使用 function 关键字定义函数。这种方式定义的函数会在代码执行之前被提升，因此可以在函数声明之前调用它。

    function greet(name) {
    return "Hello, " + name;
}
console.log(greet("Alice"));  // 输出 "Hello, Alice"

  • 函数表达式：将函数赋值给变量。这种方式定义的函数不会被提升，因此只能在函数表达式之后调用。

    const greet = function(name) {
    return "Hello, " + name;
};
console.log(greet("Bob"));  // 输出 "Hello, Bob"

  • 箭头函数

    箭头函数的基本语法

    箭头函数的语法非常简洁，用 => 符号代替了传统函数的 function 关键字。基本形式如下：

    const functionName = (parameters) => {
    // 函数体
};

    如果函数体只有一行表达式，并且需要返回这个表达式的值，可以省略大括号 {} 和 return 关键字：

    const add = (a, b) => a + b;
console.log(add(2, 3));  // 输出 5

    如果没有参数，可以用空括号 () 表示：

    const greet = () => "Hello, World!";
console.log(greet());  // 输出 "Hello, World!"

    如果只有一个参数，括号 () 也可以省略：

    const square = x => x * x;
console.log(square(4));  // 输出 16
    箭头函数与 this

    箭头函数最大的特点之一是它没有自己的 this 绑定，而是从定义时的上下文中继承 this。这意味着在箭头函数中，this 的值与箭头函数定义所在的作用域中的 this 相同。

    • 传统函数中的 this：

      在传统函数中，this 的值取决于函数的调用方式。

      function TraditionalFunction() {
    console.log(this);
}
const obj = { method: TraditionalFunction };
obj.method();  // 输出 obj 对象

    • 箭头函数中的 this：

      在箭头函数中，this 是静态的，即它不会随调用方式改变，而是继承自箭头函数定义时的上下文。

      const obj = {
    name: "Alice",
    greet: function() {
        const innerFunc = () => {
            console.log(this.name);  // 继承自 obj
        };
        innerFunc();
    }
};
obj.greet();  // 输出 "Alice"

    箭头函数中的 this

    如果将示例中的箭头函数 innerFunc 替换为传统的 function 函数，它的行为会有所不同。具体来说，传统的 function 函数会有自己的 this 绑定，而不是继承自外部函数。因此，在使用传统函数时，this 的值将不再指向 obj 对象，而是根据函数调用的方式来决定。

    示例代码及其解释

    const obj = {
    name: "Alice",
    greet: function() {
        const innerFunc = function() {
            console.log(this.name);
        };
        innerFunc();
    }
};

obj.greet();  // 输出 undefined
    解释

    • this 在 greet 方法中：
      在 greet 方法中，this 绑定到 obj 对象，因此 this.name 正确地指向了 obj 的 name 属性，即 "Alice"。

    • this 在 innerFunc 中：
      当 innerFunc 使用传统函数（function）定义时，它的 this 绑定与其调用方式有关。由于 innerFunc 是作为普通函数调用的（即没有通过对象调用），它的 this 默认为全局对象（在浏览器中是 window，在严格模式下是 undefined）。
      因此，this.name 在 innerFunc 中会指向 undefined，因为全局对象（或严格模式下的 undefined）没有 name 属性。

    修复方法

    要解决这个问题并确保 innerFunc 中的 this 继续指向 obj 对象，可以使用以下几种方法：

    • 使用箭头函数（推荐）：
      继续使用箭头函数，因为箭头函数不会有自己的 this 绑定，始终继承自外部作用域的 this。

      const innerFunc = () => {
    console.log(this.name);  // 继承自 obj
};

    • 使用 bind 方法：
      可以通过 Function.prototype.bind 方法显式地将 this 绑定到 obj。

      const innerFunc = function() {
    console.log(this.name);
}.bind(this);

    • 使用闭包：
      在外部函数中保存 this 的引用，然后在内部函数中使用这个引用。

      const greet = function() {
    const self = this;
    const innerFunc = function() {
        console.log(self.name);  // 使用 self 来指代外部函数的 this
    };
    innerFunc();
};
2. 函数的参数

函数可以接收多个参数，并在函数体内使用这些参数。参数在定义时指定，在调用函数时传递实际的值。

  • 参数与默认值：在函数定义时可以为参数指定默认值，如果调用时没有传递该参数，则使用默认值。

    function greet(name = "Guest") {
    return "Hello, " + name;
}
console.log(greet());  // 输出 "Hello, Guest"

  • 剩余参数 (...rest)：当你不确定函数会接收多少参数时，可以使用剩余参数语法来处理。

    function sum(...numbers) {
    return numbers.reduce((acc, curr) => acc + curr, 0);
}
console.log(sum(1, 2, 3, 4));  // 输出 10
3. 函数的返回值

函数可以通过 return 语句返回一个值。return 语句会终止函数的执行，并将结果返回给调用者。

  • 返回单个值：

    function square(x) {
    return x * x;
}
console.log(square(4));  // 输出 16

  • 返回多个值：JavaScript 中不能直接返回多个值，但可以使用数组或对象来实现类似的功能。

    • 使用数组：

      function getCoordinates() {
    return [10, 20];
}
const [x, y] = getCoordinates();
console.log(x, y);  // 输出 10 20

    • 使用对象：

      function getUser() {
    return { name: "Alice", age: 25 };
}
const { name, age } = getUser();
console.log(name, age);  // 输出 "Alice" 25
4. 函数的作用域

  • 局部作用域：在函数内部声明的变量具有局部作用域，只能在函数内部访问。

    function greet() {
    let message = "Hello!";
    console.log(message);  // 输出 "Hello!"
}
greet();
// console.log(message);  // 报错：message 未定义

  • 全局作用域：在函数外部声明的变量具有全局作用域，可以在任何地方访问。

    let message = "Hello, World!";
function greet() {
    console.log(message);  // 输出 "Hello, World!"
}
greet();

  • 嵌套函数：函数可以嵌套在其他函数中，内部函数可以访问外部函数的变量，但外部函数无法访问内部函数的变量。

    function outer() {
    let outerVar = "Outside";
    function inner() {
        let innerVar = "Inside";
        console.log(outerVar);  // 输出 "Outside"
    }
    inner();
    // console.log(innerVar);  // 报错：innerVar 未定义
}
outer();
6. 回调函数

回调函数是作为参数传递给另一个函数的函数，通常在异步操作中使用。

  • 异步回调：

    function fetchData(callback) {
    setTimeout(() => {
        callback("Data received");  // 回调函数
    }, 1000);
}
fetchData((data) => {
    console.log(data);  // 输出 "Data received"
});

7. 高阶函数

高阶函数是指接受函数作为参数或返回一个函数的函数。在 JavaScript 中，函数是一等公民，因此你可以将函数作为参数传递给其他函数，也可以从函数中返回一个新的函数。

  • 函数作为参数：

    function repeat(action, times) {
    for (let i = 0; i < times; i++) {
        action();
    }
}
repeat(() => console.log("Hello!"), 3);  // 输出三次 "Hello!"

  • 函数返回函数：

    function createGreeting(message) {
    return function(name) {
        return message + ", " + name;
    };
}
const greet = createGreeting("Good morning");
console.log(greet("Alice"));  // 输出 "Good morning, Alice"

8、 JavaScript 数组

数组的定义与初始化

数组是一个有序的数据集合，其中的每个元素都有一个索引。数组中的元素可以是任意数据类型，例如字符串、数字、对象，甚至其他数组。

// 数组的创建方式
let arr1 = [];  // 创建一个空数组
let arr2 = [1, 2, 3];  // 创建一个包含数字的数组
let arr3 = ["apple", "banana", "cherry"];  // 创建一个包含字符串的数组
let arr4 = [1, "hello", true, { name: "Alice" }, [2, 3]];  // 混合类型数组
访问和修改数组元素

通过索引可以访问数组中的元素，索引从 0 开始计数。可以使用索引来获取或修改元素的值。

let fruits = ["apple", "banana", "cherry"];
console.log(fruits[0]);  // 输出 "apple"

fruits[1] = "blueberry";  // 修改第二个元素
console.log(fruits);  // 输出 ["apple", "blueberry", "cherry"]
数组的常用方法

JavaScript 提供了多种数组方法来操作数组，包括添加、删除元素，查找元素，排序等。

  • push() 和 pop()：

    • push()：向数组末尾添加一个或多个元素。
    • pop()：删除数组末尾的元素并返回该元素。
    let numbers = [1, 2, 3];
numbers.push(4);  // 添加元素
console.log(numbers);  // 输出 [1, 2, 3, 4]

let last = numbers.pop();  // 删除末尾元素
console.log(last);  // 输出 4

  • unshift() 和 shift()：

    • unshift()：在数组开头添加一个或多个元素。
    • shift()：删除数组第一个元素并返回该元素。
    let colors = ["red", "green", "blue"];
colors.unshift("yellow");  // 在开头添加元素
console.log(colors);  // 输出 ["yellow", "red", "green", "blue"]

let first = colors.shift();  // 删除第一个元素
console.log(first);  // 输出 "yellow"

  • slice() 和 splice()：

    • slice()：返回数组的一个子数组，不修改原数组。
    • splice()：可以删除、替换或添加元素到数组中，会修改原数组。
    let arr = [1, 2, 3, 4, 5];
let sliced = arr.slice(1, 3);  // 提取索引 1 到 3 之间的元素，不包括索引 3
console.log(sliced);  // 输出 [2, 3]

arr.splice(2, 2, "a", "b");  // 从索引 2 开始删除 2 个元素，然后插入 "a", "b"
console.log(arr);  // 输出 [1, 2, "a", "b", 5]

  • forEach()：用于对数组中的每个元素执行一次提供的函数。

    let names = ["Alice", "Bob", "Charlie"];
names.forEach(name => {
    console.log(name);
});
// 输出 "Alice", "Bob", "Charlie"

  • map()：返回一个新数组，新数组中的元素是原数组中每个元素经过函数处理后的结果。

    let numbers = [1, 2, 3];
let doubled = numbers.map(x => x * 2);
console.log(doubled);  // 输出 [2, 4, 6]

  • filter()：返回一个新数组，包含所有通过指定函数测试的元素。

    let numbers = [1, 2, 3, 4, 5];
let evenNumbers = numbers.filter(x => x % 2 === 0);
console.log(evenNumbers);  // 输出 [2, 4]
数组的遍历

数组遍历是指依次访问数组中的每个元素。常用的遍历方式包括 for 循环、for...of 循环、forEach() 方法。

let fruits = ["apple", "banana", "cherry"];

// 使用 for 循环
for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]);
}

// 使用 for...of 循环
for (let fruit of fruits) {
    console.log(fruit);
}

// 使用 forEach 方法
fruits.forEach(fruit => console.log(fruit));

9、 对象

对象的定义与初始化

对象是 JavaScript 中的一种数据结构，用于存储键值对。每个键（也称为属性名）都对应一个值，值可以是任何数据类型，包括另一个对象或函数。

let person = {
    name: "Alice",
    age: 25,
    greet: function() {
        console.log("Hello, my name is " + this.name);
    }
};
访问和修改对象属性

可以通过点符号或方括号符号来访问或修改对象的属性。

let person = {
    name: "Alice",
    age: 25
};

console.log(person.name);  // 输出 "Alice"
console.log(person["age"]);  // 输出 25

person.name = "Bob";  // 修改属性值
console.log(person.name);  // 输出 "Bob"
动态添加和删除属性

可以随时为对象添加或删除属性。

let person = {
    name: "Alice"
};

// 动态添加属性
person.age = 25;
console.log(person);  // 输出 { name: "Alice", age: 25 }

// 删除属性
delete person.name;
console.log(person);  // 输出 { age: 25 }
对象的常用方法

对象是 JavaScript 中的核心概念之一，因此有许多方法可以用于操作对象。

  • Object.keys()：返回对象自身可枚举属性的键组成的数组。

    let person = { name: "Alice", age: 25 };
let keys = Object.keys(person);
console.log(keys);  // 输出 ["name", "age"]

  • Object.values()：返回对象自身可枚举属性的值组成的数组。

    let values = Object.values(person);
console.log(values);  // 输出 ["Alice", 25]

  • Object.entries()：返回对象自身可枚举属性的键值对数组。

    let entries = Object.entries(person);
console.log(entries);  // 输出 [["name", "Alice"], ["age", 25]]

  • hasOwnProperty()：判断对象是否拥有指定的属性（不包括原型链上的属性）。

    let person = { name: "Alice" };
console.log(person.hasOwnProperty("name"));  // 输出 true
console.log(person.hasOwnProperty("age"));  // 输出 false
对象的遍历

可以使用 for...in 循环来遍历对象的属性。

let person = {
    name: "Alice",
    age: 25
};

for (let key in person) {
    console.log(key + ": " + person[key]);
}
// 输出 "name: Alice" 和 "age: 25"

10. 输入与输出

JavaScript 提供了多种方式与用户交互，获取输入或显示输出。

  • prompt()：获取用户输入。

    let name = prompt("Enter your name:");
console.log("Your name is " + name);

  • alert()：显示警告框。

    alert("This is an alert!");

  • console.log()：在控制台输出信息，常用于调试。

    console.log("Hello, World!");

11、JavaScript 类详解

JavaScript 的类为开发者提供了一种更清晰、更面向对象的方式来组织和管理代码。通过类，你可以创建对象的模板，封装数据和行为，并通过继承实现代码复用。

1. 类的定义与实例化

类的定义

类通过 class 关键字定义，类的主体包括构造函数（constructor）和方法。构造函数在创建类的实例时被调用，用于初始化对象的属性。

class Person {
    constructor(name, age) {
        this.name = name;  // 定义实例属性
        this.age = age;
    }

    greet() {  // 定义方法
        console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
    }
}
实例化类

使用 new 关键字可以实例化一个类，这会调用构造函数并返回一个新对象。

let alice = new Person("Alice", 25);  // 创建一个 Person 类的实例
alice.greet();  // 输出 "Hello, my name is Alice and I am 25 years old."

2. 类的属性与方法

实例属性与方法

  • 实例属性：在类的构造函数中使用 this 关键字定义的属性称为实例属性，每个实例都有自己独立的实例属性。

  • 实例方法：在类中定义的函数被称为方法，这些方法可以通过实例调用。

class Animal {
    constructor(type, sound) {
        this.type = type;  // 实例属性
        this.sound = sound;
    }

    makeSound() {  // 实例方法
        console.log(`${this.type} makes a ${this.sound} sound.`);
    }
}

let dog = new Animal("Dog", "bark");
dog.makeSound();  // 输出 "Dog makes a bark sound."
静态属性与方法

静态属性和方法是类本身拥有的，而不是实例拥有的。静态方法使用 static 关键字定义，可以通过类名直接调用，而不是通过实例。

class MathUtil {
	static count = 0; // 静态变量
	
    static add(a, b) {
        return a + b;
    }
}

console.log(MathUtil.add(3, 4));  // 输出 7
console.log(MathUtil.count); // 输出 0

3. 继承与多态

类的继承

JavaScript 支持类的继承，可以使用 extends 关键字创建一个继承自另一个类的新类。继承使得子类能够继承父类的属性和方法，还可以重写父类的方法或添加新的方法。

class Animal {
    constructor(type) {
        this.type = type;
    }

    makeSound() {
        console.log(`${this.type} makes a sound.`);
    }
}

class Dog extends Animal {
    constructor(name) {
        super("Dog");  // 调用父类的构造函数
        this.name = name;
    }

    makeSound() {
        console.log(`${this.name} barks.`);
    }
}

let myDog = new Dog("Buddy");
myDog.makeSound();  // 输出 "Buddy barks."
super 关键字

super 关键字用于调用父类的构造函数或方法。在子类的构造函数中，调用 super() 必须先于使用 this 关键字。

class Cat extends Animal {
    constructor(name) {
        super("Cat");  // 调用父类的构造函数
        this.name = name;
    }

    makeSound() {
        super.makeSound();  // 调用父类的方法
        console.log(`${this.name} meows.`);
    }
}

let myCat = new Cat("Whiskers");
myCat.makeSound();
// 输出:
// "Cat makes a sound."
// "Whiskers meows."
多态

多态性允许我们使用相同的方法名但在不同的类中实现不同的行为。当调用一个方法时，实际执行的是该方法在对象所属类中的实现。这使得代码更加灵活和可扩展。

class Animal {
    makeSound() {
        console.log("Some generic animal sound.");
    }
}

class Cow extends Animal {
    makeSound() {
        console.log("Moo!");
    }
}

let genericAnimal = new Animal();
let cow = new Cow();

genericAnimal.makeSound();  // 输出 "Some generic animal sound."
cow.makeSound();  // 输出 "Moo!"

4. 类的访问控制与封装

JavaScript 在类中提供了对属性和方法的访问控制，通过使用 # 前缀来定义私有属性或方法，这些属性和方法只能在类的内部访问。

class BankAccount {
    #balance = 0;  // 私有属性

    deposit(amount) {
        this.#balance += amount;
        console.log(`Deposited: $${amount}. New balance: $${this.#balance}`);
    }

    withdraw(amount) {
        if (amount <= this.#balance) {
            this.#balance -= amount;
            console.log(`Withdrew: $${amount}. New balance: $${this.#balance}`);
        } else {
            console.log("Insufficient funds.");
        }
    }

    getBalance() {  // 公有方法访问私有属性
        return this.#balance;
    }
}

let myAccount = new BankAccount();
myAccount.deposit(100);
myAccount.withdraw(30);
console.log(myAccount.getBalance());  // 输出 70

标签：console,log,函数,javascript,name,let,const,js,入门
From： https://blog.csdn.net/m0_74065705/article/details/141272536

相关文章

  • 基于springboot+vue.js的超市购物系统附带文章源码部署视频讲解等
    文章目录前言详细视频演示具体实现截图核心技术介绍后端框架SpringBoot前端框架Vue持久层框架MyBaits为什么选择我代码参考数据库参考测试用例参考源码获取前言......
  • 基于springboot+vue.js的短文写作竞赛管理系统附带文章源码部署视频讲解等
    文章目录前言详细视频演示具体实现截图核心技术介绍后端框架SpringBoot前端框架Vue持久层框架MyBaits为什么选择我代码参考数据库参考测试用例参考源码获取前言......
  • Java 入门指南：Java Socket 网络通信编程
    SocketSocket（套接字）是用于网络通信的编程接口、网络通信的基础，通过它可以实现不同计算机之间的数据传输，应用程序可以通过它发送或接收数据；就像操作文件那样可以打开、读写和关闭。它提供了一种机制，使得计算机之间可以进行数据的发送和接收。套接字允许应用程序将I/O应用......
  • 【亲测有效】JS Uncaught TypeError: [function] is not a constructor
    【亲测有效】JSUncaughtTypeError:[function]isnotaconstructor在JavaScript编程中，`UncaughtTypeError:[function]isnotaconstructor`是一个相对常见的错误，通常发生在尝试使用某个值作为构造函数，但实际上它不是构造函数的情况下。这个错误可能由多种原......
  • 零基础国产GD32单片机编程入门(六)PWM波输出实战含源码
    文章目录一.概要二.PWM产生框架图三.配置一个TIME输出1KHZ，占空比50%PWM波例程四.工程源代码下载五.小结一.概要脉冲宽度调制(PWM)，是英文“PulseWidthModulation”的缩写，简称脉宽调制，是利用单片机数字输出（1或0）来对外部模拟电路进行控制的一种非常有效的技术。PWM......
  • AOP快速入门
    1需求分析案例设定：测算接口执行效率，但是这个案例稍微复杂了点，我们对其进行简化。简化设定：在方法执行前输出当前系统时间。对于SpringAOP的开发有两种方式，XML和注解总结需求为:使用SpringAOP的注解方式完成在方法执行的前打印出当前系统时间。2思路分析需求明确后，......
  • C/C++实现JSON格式数据解析
    参考文章推荐以下几篇，针对Cjson的应用写的很详细，感谢！！！https://blog.csdn.net/xiaopengX6/article/details/104629606https://liang.blog.csdn.net/article/details/86605234运用场景在做C的项目时，对方通过TCP套接字将内容按照帧头+帧体的格式发送过来，其中帧体的内容是JSON格式......
  • js的10个使用技巧
    js技巧01如果仅在变量为true的情况下调用函数，你就可以使用与(&&)的短路形式作为替代方法。 02如果期望值不正确，我们可以使用OR（丨丨）短路运算，为变量分配默认值。03将多个变量赋值我们可以通过数组解构来对一行中的多个变量赋值。 04箭头函数 05对于多值匹配来......
  • postman 发送json数据时，数据为随机数(雪花算法生成)
    要在Postman中发送由雪花算法计算出的随机数，您可以通过在预请求脚本中使用JavaScript代码来实现。首先，您需要添加一个script部分模拟雪花算法生成随机数的函数。可以在请求的"Pre-requestScript"选项卡中添加以下代码：functiongenerateRandomNumber(){constepoch=16094......
  • 会员通知短信怎么利用NodeJS发送短信
    会员通知群发短信以其即时高效、高打开率、个性化定制、成本效益高、跨平台兼容以及法律合规等优势，在现代会员管理和营销策略中占据了重要地位。对于希望提升会员沟通效率、增强用户粘性和促进业务增长的企业而言，合理利用群发短信工具无疑是一个明智的选择。支持免费试用下乐......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99