JavaScript设计模式快速参考指南

揭开 JavaScript 设计模式秘密的旅程,探索它们的意义、实现和实际应用。

创建模式是一种设计模式类别,用于解决与对象创建情况相关的常见问题。

1、单例模式
将特定对象的实例数量限制为一个。单例减少了对全局变量的需求,从而避免了名称冲突的风险。

class Animal {
constructor() {
if (typeof Animal.instance === 'object') {
return Animal.instance;
}

    Animal.instance = this;

    return this;
}
}

export default Animal;

2、Prototype
原型模式在现有对象的基础上创建新对象,并设置默认属性值。

在本例中,我们可以使用 clone() 方法创建一个新对象 Fruit,其名称和权重与父对象相同。

class Fruit {
constructor(name, weight) {
this.name = name;
this.weight = weight;
}

  clone() {
return new Fruit(this.name, this.weight);
}
}

export default Fruit;

3、Factory
工厂模式创建新对象,委托子类实例化哪个类。

在本例中,MovieFactory 决定创建哪种类型的影片。

class MovieFactory {
create(genre) {
if (genre === 'Adventure') return new Movie(genre, 10000);
if (genre === 'Action') return new Movie(genre, 11000);
}
}

class Movie {
constructor(type, price) {
this.type = type;
this.price = price;
}
}

export default MovieFactory;

4、Abstract Factory
抽象工厂创建按主题分组的新对象,而不指定其具体类别。

function foodProducer(kind) {
if (kind === 'protein') return proteinPattern;
if (kind === 'fat') return fatPattern;
return carbohydratesPattern;
}

function proteinPattern() {
return new Protein();
}

function fatPattern() {
return new Fat();
}

function carbohydratesPattern() {
return new Carbohydrates();
}

class Protein {
info() {
return 'I am Protein.';
}
}

class Fat {
info() {
return 'I am Fat.';
}
}

class Carbohydrates {
info() {
return 'I am carbohydrates.';
}
}

export default foodProducer;

结构模式是设计模式的一个类别,用于解决与对象和类的组成情况有关的常见问题。

5、Adapter
适配器模式允许类协同工作,将一个类接口创建为另一个接口。

在本例中,我们使用 SoldierAdapter 来使用当前系统中的传统方法 attack(),并支持新版本的士兵 SuperSoldiers。

class Soldier {
constructor(level) {
this.level = level;
}

  attack() {
return this.level * 1;
}
}

class SuperSoldier {
constructor(level) {
this.level = level;
}

  attackWithShield() {
return this.level * 10;
}
}

class SoldierAdapter {
constructor(superSoldier) {
this.superSoldier = superSoldier;
}

  attack() {
return this.superSoldier.attackWithShield();
}
}

export { Soldier, SuperSoldier, SoldierAdapter };

6、Bridge
桥接模式允许在我们的类中使用一个接口,并根据我们接收的实例和需要返回的实例构建不同的实现。

在本例中,我们在士兵类型和武器类型之间创建了一座桥,这样我们就可以将武器实例正确地传递给我们的士兵。

class Soldier {
constructor(weapon) {
this.weapon = weapon;
}
}

class SuperSoldier extends Soldier {
constructor(weapon) {
super(weapon);
}

  attack() {
return 'SuperSoldier, Weapon: ' + this.weapon.get();
}
}

class IronMan extends Soldier {
constructor(weapon) {
super(weapon);
}

  attack() {
return 'Ironman, Weapon: ' + this.ink.get();
}
}

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

  get() {
return this.type;
}
}

class Shield extends Weapon {
constructor() {
super('shield');
}
}

class Rocket extends Weapon {
constructor() {
super('rocket');
}
}

export { SuperSoldier, IronMan, Shield, Rocket };

当您需要在运行时使用抽象中的特定实现时,请使用此模式。

7、Composite
复合模式允许创建具有原始项或对象集合属性的对象。集合中的每个项都可以包含其他集合,从而创建深嵌套结构。

在本例中,我们创建的计算设备子系统存储在一个内阁中,每个元素都可以是不同的实例。

//Equipment
class Equipment {
getPrice() {
return this.price || 0;
}

  getName() {
return this.name;
}

  setName(name) {
this.name = name;
}
}

class Pattern extends Equipment {
constructor() {
super();
this.equipments = [];
}

  add(equipment) {
this.equipments.push(equipment);
}

  getPrice() {
return this.equipments
.map(equipment => {
return equipment.getPrice();
})
.reduce((a, b) => {
return a + b;
});
}
}

class Cabbinet extends Pattern {
constructor() {
super();
this.setName('cabbinet');
}
}

// --- leafs ---
class FloppyDisk extends Equipment {
constructor() {
super();
this.setName('Floppy Disk');
this.price = 70;
}
}

class HardDrive extends Equipment {
constructor() {
super();
this.setName('Hard Drive');
this.price = 250;
}
}

class Memory extends Equipment {
constructor() {
super();
this.setName('Memory');
this.price = 280;
}
}

export { Cabbinet, FloppyDisk, HardDrive, Memory };

当您想表示对象的层次结构时,请使用这种模式。

8、Decorator
装饰器模式允许在运行时动态扩展对象的行为。

在本示例中,我们使用装饰器来扩展 Facebook 通知中的行为。

class Notification {
constructor(kind) {
this.kind = kind || "Generic";
}

getInfo() {
return `I'm a ${this.kind} Notification`;
}
}

class FacebookNotification extends Notification {
constructor() {
super("Facebook");
}

setNotification(msg) {
this.message = msg;
}

getInfo() {
return `${super.getInfo()} with the message: ${this.message}`;
}
}

class SMSNotification extends Notification {
constructor() {
super("SMS");
}

getInfo() {
return super.getInfo();
}
}

export { FacebookNotification, SMSNotification };

当您想在运行时为对象添加扩展而不影响其他对象时,请使用此模式。

9、Facade
Facade 模式为子系统中的一组接口提供了简化接口。门面定义了更高级别的接口,使子系统更易于使用

在本例中,我们创建了一个简单的界面 Cart,它抽象了折扣、发货和费用等几个子系统的所有复杂功能。

class Cart {
constructor() {
this.discount = new Discount();
this.shipping = new Shipping();
this.fees = new Fees();
}

  calc(price) {
price = this.discount.calc(price);
price = this.fees.calc(price);
price += this.shipping.calc();

    return price;
}
}

class Discount {
calc(value) {
return value * 0.85;
}
}

class Shipping {
calc() {
return 500;
}
}

class Fees {
calc(value) {
return value * 1.1;
}
}

export default Cart;

当您想为复杂的子系统提供一个简单的接口时,请使用这种模式。

10、Flyweight
Flyweight 模式通过高效共享大量细粒度对象来节省内存。共享的 Flyweight 对象是不可变的,也就是说,它们无法更改,因为它们代表了与其他对象共享的特征。

在这个示例中,我们正在管理和创建某种食谱或烹饪应用程序的配料。

class Ingredient {
constructor(name) {
this.name = name;
}

getInfo() {
return `I'm a ${this.name}`
}
}

class Ingredients {
constructor() {
this.ingredients = {};
}

  create(name) {
let ingredient = this.ingredients[name];
if (ingredient) return ingredient;

    this.ingredients[name] = new Ingredient(name);

    return this.ingredients[name];
}
}

export { Ingredients };

当应用程序使用大量小对象,而这些对象的存储成本又很高,或者它们的身份并不重要时,就可以使用这种模式。

11、Proxy
代理模式为另一个对象提供一个代理或占位符对象,并控制对该另一个对象的访问。

在本例中,我们使用这种模式来限制飞行员的年龄。

class Plane {
fly() {
return 'flying';
}
}

class PilotProxy {
constructor(pilot) {
this.pilot = pilot;
}

  fly() {
return this.pilot.age < 18 ? `too young to fly` : new Plane().fly();
}
}

class Pilot {
constructor(age) {
this.age = age;
}
}

export { Plane, PilotProxy, Pilot };

当一个对象受到严重限制,无法履行其职责时,可以使用这种模式。

行为模式是设计模式的一个类别,用于解决与通信和对象间分配相关的常见问题。

12、Chain of Responsibility
责任链模式允许将请求沿着有机会处理请求的对象链传递。收到请求后,每个处理程序都会决定是处理该请求还是将其传递给链中的下一个处理程序。

在本例中,我们将 Discount 类作为责任链对象来处理购物车中折扣多少的请求。

class ShoppingCart {
constructor() {
this.products = [];
}

  addProduct(p) {
this.products.push(p);
}
}

class Discount {
calc(products) {
let ndiscount = new NumberDiscount();
let pdiscount = new PriceDiscount();
let none = new NoneDiscount();
ndiscount.setNext(pdiscount);
pdiscount.setNext(none);

    return ndiscount.exec(products);
}
}

class NumberDiscount {
constructor() {
this.next = null;
}

  setNext(fn) {
this.next = fn;
}

  exec(products) {
let result = 0;
if (products.length > 3) result = 0.05;

    return result + this.next.exec(products);
}
}

class PriceDiscount {
constructor() {
this.next = null;
}

  setNext(fn) {
this.next = fn;
}

  exec(products) {
let result = 0;
let total = products.reduce((a, b) => (a + b), 0);

    if (total >= 500) result = 0.1;

    return result + this.next.exec(products);
}
}

class NoneDiscount {
exec() {
return 0;
}
}

export { ShoppingCart, Discount };

当不止一个对象可以处理一个请求,且运行时已知道该信息时,可使用此模式。

13、Command
命令模式允许将请求封装为对象。通过这种转换,您可以将请求作为方法参数传递,延迟或排队执行请求,并支持可撤销操作。

在本例中,我们将 on/off 指令封装为对象,并将其作为参数传递给汽车构造函数。

class Car {
constructor(instruction) {
this.instruction = instruction;
}

  execute() {
this.instruction.execute();
}
}

class Engine {
constructor() {
this.state = false;
}

  on() {
this.state = true;
}

  off() {
this.state = false;
}
}

class OnInstruction {
constructor(engine) {
this.engine = engine;
}

  execute() {
this.engine.on();
}
}

class OffInstruction {
constructor(engine) {
this.engine = engine;
}

  execute() {
this.engine.off();
}
}

export { Car, Engine, OnInstruction, OffInstruction };

当需要处理大量请求队列或需要批撤销操作时,请使用此模式。

14、Interpreter
当问题经常出现时,解释器模式可以为简单语言创建一个语法;可以考虑用简单语言的句子来表示问题,这样解释器就可以通过解释句子来解决问题。

在本例中,我们将创建一个简单的数字,用于对几个数字进行乘幂运算。

class Mul {
constructor(left, right) {
this.left = left;
this.right = right;
}

  interpreter() {
return this.left.interpreter() * this.right.interpreter();
}
}

class Pow {
constructor(left, right) {
this.left = left;
this.right = right;
}

  interpreter() {
return this.left.interpreter() - this.right.interpreter();
}
}

class Num {
constructor(val) {
this.val = val;
}

  interpreter() {
return this.val;
}
}

export { Num, Mul, Pow };

当您要解释给定的语言时,可以用这种模式将语句表示为抽象语法树。

15、Iterator
迭代器模式允许访问集合中的元素,而不暴露其底层表示。

在这个示例中,我们创建了一个简单的迭代器,它将包含一个数组中的元素,使用 next() 和 hasNext() 方法,我们可以遍历所有元素。

class Iterator {
constructor(el) {
this.index = 0;
this.elements = el;
}

  next() {
return this.elements[this.index++];
}

  hasNext() {
return this.index < this.elements.length;
}
}

export default Iterator;

当您想访问对象的内容集合而又不知道其内部表示方式时,请使用这种模式。

16、Mediator
调解器模式可以通过定义一个对象来封装一组对象的交互方式,从而减少对象之间的混乱依赖关系。

在本例中,我们创建了一个类 Mediator TrafficTower,它将允许我们从飞机实例中获取所有位置信息。

class TrafficTower {
constructor() {
this.airplanes = [];
}

  getPositions() {
return this.airplanes.map(airplane => {
return airplane.position.showPosition();
});
}
}

class Airplane {
constructor(position, trafficTower) {
this.position = position;
this.trafficTower = trafficTower;
this.trafficTower.airplanes.push(this);
}

  getPositions() {
return this.trafficTower.getPositions();
}
}

class Position {
constructor(x,y) {
this.x = x;
this.y = y;
}

showPosition() {
return `My Position is ${x} and ${y}`;
}
}

export { TrafficTower, Airplane, Position };

当一组对象以复杂的方式进行通信时,可使用这种模式。

17、Memento
记忆模式允许捕捉对象的内部状态并将其外部化,以便以后可以将对象恢复到这种状态。

在本例中,我们将创建一种简单的方法来存储值,并在需要时恢复快照。

class Memento {
constructor(value) {
this.value = value;
}
}

const originator = {
store: function(val) {
return new Memento(val);
},
restore: function(memento) {
return memento.value;
}
};

class Keeper {
constructor() {
this.values = [];
}

  addMemento(memento) {
this.values.push(memento);
}

  getMemento(index) {
return this.values[index];
}
}

export { originator, Keeper };

当您想制作对象状态的快照以恢复对象以前的状态时,请使用此模式。

18、Observer
观察者模式允许在对象之间定义一对多的依赖关系,这样当一个对象改变状态时,它的所有依赖对象都会收到通知并自动更新。

在这个示例中,我们创建了一个简单的类产品,其他类可以通过 register() 方法观察注册的变化,而当某个对象更新时,notifyAll() 方法将与所有观察者交流这些变化。

class ObservedProduct {
constructor() {
this.price = 0;
this.actions = [];
}

  setBasePrice(val) {
this.price = val;
this.notifyAll();
}

  register(observer) {
this.actions.push(observer);
}

  unregister(observer) {
this.actions.remove.filter(function(el) {
return el !== observer;
});
}

  notifyAll() {
return this.actions.forEach(
function(el) {
el.update(this);
}.bind(this)
);
}
}

class fees {
update(product) {
product.price = product.price * 1.2;
}
}

class profit {
update(product) {
product.price = product.price * 2;
}
}

export { ObservedProduct, fees, profit };

当改变一个对象的状态可能需要改变其他对象,而实际对象集事先未知或动态变化时,使用这种模式。

19、State
状态模式允许对象在其内部状态发生变化时改变其行为。

在本示例中,我们将创建一个简单的状态模式,其中的 Order 类将使用 next() 方法更新状态。

class OrderStatus {
constructor(name, nextStatus) {
this.name = name;
this.nextStatus = nextStatus;
}

  next() {
return new this.nextStatus();
}
}

class WaitingForPayment extends OrderStatus {
constructor() {
super('waitingForPayment', Shipping);
}
}

class Shipping extends OrderStatus {
constructor() {
super('shipping', Delivered);
}
}

class Delivered extends OrderStatus {
constructor() {
super('delivered', Delivered);
}
}

class Order {
constructor() {
this.state = new WaitingForPayment();
}

  nextPattern() {
this.state = this.state.next();
}
}

export default Order;

当对象的行为取决于其状态,而其行为在运行时的变化又取决于该状态时,使用这种模式。

20、Strategy
策略模式允许定义一系列算法,对每种算法进行封装,并使它们可以互换。

在这个例子中,我们有一组折扣,可以应用到 ShoppingCart 中,这里的诀窍在于我们可以将要应用的函数传递给构造函数,从而改变折扣的金额。

class ShoppingCart {
constructor(discount) {
this.discount = discount;
this.amount = 0;
}

  checkout() {
return this.discount(this.amount);
}

  setAmount(amount) {
this.amount = amount;
}
}

function guest(amount) {
return amount;
}

function regular(amount) {
return amount * 0.9;
}

function premium(amount) {
return amount * 0.8;
}

export { ShoppingCart, guest, regular, premium };

当你有很多相似的类,只是执行某些行为的方式不同时,就可以使用这种模式。

21、Template
模板模式允许在超类中定义算法的骨架,但允许子类在不改变算法结构的情况下覆盖算法的特定步骤。

在本例中,我们创建了一个简单的模板方法来计算税金,并在增值税和消费税(税金类型)中扩展了该模板,这样我们就可以在多个税金类中重复使用相同的结构。

class Tax {
calc(value) {
if (value >= 1000) value = this.overThousand(value);

    return this.complementaryFee(value);
}

  complementaryFee(value) {
return value + 10;
}
}

class VAT extends Tax {
constructor() {
super();
}

  overThousand(value) {
return value * 1.1;
}
}

class GST extends Tax {
constructor() {
super();
}

  overThousand(value) {
return value * 1.2;
}
}

export { VAT, GST };

如果只想让客户扩展算法的特定步骤,而不想扩展整个算法或其结构,请使用这种模式。

22、Visitor
访问者模式允许将算法与操作对象分开。

在本例中,我们创建了一个结构来计算两类员工的奖金,通过这种方法,我们可以将奖金方法扩展到更多类型的员工,如 CEO 奖金、VP 奖金等。

function bonusPattern(employee) {
if (employee instanceof Manager) employee.bonus = employee.salary * 2;
if (employee instanceof Developer) employee.bonus = employee.salary;
}

class Employee {
constructor(salary) {
this.bonus = 0;
this.salary = salary;
}

  accept(item) {
item(this);
}
}

class Manager extends Employee {
constructor(salary) {
super(salary);
}
}

class Developer extends Employee {
constructor(salary) {
super(salary);
}
}

export { Developer, Manager, bonusPattern };

当一个对象结构包含许多类,而您想对该结构的元素执行依赖于其类的操作时,请使用此模式。

原文更多设计模式:https://www.jdon.com/69246.html

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Go语言入门心法(十三): 反射认知升维

Go语言入门心法(一): 基础语法 Go语言入门心法(二): 结构体 Go语言入门心法(三): 接口 Go语言入门心法(四): 异常体系 Go语言入门心法(五): 函数 Go语言入门心法(六): HTTP面向客户端|服务端编程 Go语言入门心法(七): 并发与通道 Go语言入门心法(八): mysql驱动安装报错o…

Win安装protobuf和IDEA使用protobuf插件

一、Win安装protobuf 1、下载编译器 protobuf下载地址&#xff1a;https://github.com/protocolbuffers/protobuf/releases 选择自己需要的版本下载&#xff0c;这里下载的是 protoc-3.19.1-win64.zip&#xff0c;下载之后进行解压即可。 2、配置环境变量 path 系统变量中添加…

分布式、集群、微服务

分布式是以缩短单个任务的执行时间来提升效率的&#xff1b;而集群则是通过提高单位时间内执行的任务数来提升效率。 分布式是指将不同的业务分布在不同的地方。 集群指的是将几台服务器集中在一起&#xff0c;实现同一业务。 分布式中的每一个节点&#xff0c;都可以做集群…

RT-Thread 7. RT-Thread Studio ENV修改MCU型号

1. 修改MCU型号 2.在ENV界面输入 scons -c scons --dist3. dist下为更新后完整源代码 4.导入RT-Thread Studio 发现GD32F330已经生效了。 5. 自己编写startup_gd32f3x0.S&#xff0c;准确性待验证 ;/* ; * Copyright (c) 2006-2021, RT-Thread Development Team ; * ; * SPD…

如何将Mysql数据库的表导出并导入到另外的架构

如何将Mysql数据库的表导出并导入到另外的架构 准备一、解决方法1.右键->导出->用mysqldump导出2.注意路径一般为&#xff1a;C:/Program Files/MySQL/MySQL Server 8.0/bin/mysqldump.exe和导出的sql文件位置3.右键->SQL脚本->运行SQL脚本4.找到SQL脚本并点击确定…

通过实例理解Go Web身份认证的几种方式

在2023年Q1 Go官方用户调查报告[1]中&#xff0c;API/RPC services、Websites/web services都位于使用Go开发的应用类别的头部(如下图)&#xff1a; 我个人使用Go开发已很多年&#xff0c;但一直从事底层基础设施、分布式中间件等方向&#xff0c;Web应用开发领域涉及较少&…

SD-WAN跨境网络专线|跨境访问无忧!让海外SaaS平台与视频会议更稳定轻松的解决方案

在现如今全球化的时代&#xff0c;企业都有布局全球或是有潜力的国家&#xff0c;在海外开分公司必不可少&#xff0c;那与海外合作伙伴进行沟通与合作已经成为企业的常态。但是&#xff0c;访问海外的SaaS平台和进行视频会议时&#xff0c;我们经常会遇到网络不稳定、速度慢的…

idea 中配置 maven

前文叙述&#xff1a; 配置 maven 一共要设置两个地方&#xff1a;1、为当前项目设置2、为新项目设置maven 的下载和安装可参考我之前写过的文章&#xff0c;具体的配置文章中也都有讲解。1、为当前项目进行 maven 配置 配置 VM Options: -DarchetypeCataloginternal2、为新项…

spring sharding JDBC 动态调整数据库连接

spring sharding JDBC 动态调整数据库连接 通过重写ShardingSphereDataSource类来实现 代码 package org.apache.shardingsphere.driver.jdbc.core.datasource;import com.alibaba.druid.pool.DruidDataSource; import lombok.extern.slf4j.Slf4j; import org.apache.shardi…

CleanMyMac X免费macOS清理系统管家

近些年伴随着苹果生态的蓬勃发展&#xff0c;越来越多的用户开始尝试接触Mac电脑。然而很多人上手Mac后会发现&#xff0c;它的使用逻辑与Windows存在很多不同&#xff0c;而且随着使用时间的增加&#xff0c;一些奇奇怪怪的文件也会占据有限的磁盘空间&#xff0c;进而影响使用…

心理咨询医院预约和挂号系统

源码下载地址 支持&#xff1a;远程部署/安装/调试、讲解、二次开发/修改/定制 系统分为&#xff1a;患者端、医生端、管理员端。 患者端 医生端 管理员端

JAVA基础(JAVA SE)学习笔记(九)异常处理

前言 1. 学习视频&#xff1a; 尚硅谷Java零基础全套视频教程(宋红康2023版&#xff0c;java入门自学必备)_哔哩哔哩_bilibili 2023最新Java学习路线 - 哔哩哔哩 第三阶段&#xff1a;Java高级应用 9.异常处理 10.多线程 11.常用类和基础API 12.集合框架 13.泛型 14…

虚拟机VMware Workstation Pro安装配置使用服务器系统ubuntu-22.04.3-live-server-amd64.iso

虚拟机里安装ubuntu-23.04-beta-desktop-amd64开启SSH(换源和备份)配置中文以及中文输入法等 ​一、获取Ubuntu服务器版 获取Ubuntu服务器版 二、配置虚拟机 选择Custom(advanced)&#xff1a; 选择Workstation 17.x: 选择“I will install the operating system later.”…

原型制作的软件 Experience Design mac( XD ) 中文版软件特色

​XD是一个直观、功能强大的UI/UX开发工具&#xff0c;旨在设计、原型、用户之间共享材料以及通过数字技术进行设计交互。Adobe XD提供了开发网站、应用程序、语音界面、游戏界面、电子邮件模板等所需的一切。xd mac软件特色 体验设计的未来。 使用 Adobe XD 中快速直观、即取即…

上市公司员工及工资数据(2000-2022年)

参照《经济研究》中毛其淋等&#xff08;2023&#xff09;的做法&#xff0c;团队对上市公司员工、工资数据测算。用上市公司&#xff49;在&#xff54;年的员工人数的对数衡量企业的就业水平&#xff0c;采用企业应付职工薪酬与员工人数的比值衡量企业工资水平 一、数据介绍 …

计算机网络原理

2015-04 40&#xff0e;简述面向连接服务的特点。 答&#xff1a;面向连接服务的特点是&#xff1a;数据传输过程前必须经过建立连接&#xff0c;维护连接和释放连接三个过程&#xff1b;数据传输过程中&#xff0c;各分组不需要携带目的节点的地址&#xff1b;面向连接数据传…

html内连框架

src:引用页面地址 name&#xff1a;框架标识名称 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title> </head> <body> <!--iframe src&#xff1a;地址 w-h&#xff…

点云处理【七】(点云配准)

点云处理 第一章 点云数据采集 1.点云配准 点云配准是将两个或多个点云数据集融合到一个统一的坐标系统中的过程。这通常是为了创建一个完整的模型或融合从不同视角采集的数据。 点云配准一般分为粗配准和精配准&#xff0c;粗配准指的是在两幅点云之间的变换完全未知的情况下…

数组知识点以及leetcode刷题

数组 二分查找 题目 力扣题目链接 给定一个 n 个元素有序的&#xff08;升序&#xff09;整型数组 nums 和一个目标值 target &#xff0c;写一个函数搜索 nums 中的 target&#xff0c;如果目标值存在返回下标&#xff0c;否则返回 -1。 适用范围 数组有序&#xff0c;数…

【LeetCode】881 救生艇 中等题

给定数组 people 。people[i]表示第 i 个人的体重 &#xff0c;船的数量不限&#xff0c;每艘船可以承载的最大重量为 limit。 每艘船最多可同时载两人&#xff0c;但条件是这些人的重量之和最多为 limit。 返回 承载所有人所需的最小船数 。 示例 1&#xff1a; 输入&#…