源码解析容器以及面门模式Facade深度解刨,反射机制

最新推荐文章于 2020-11-25 20:59:57 发布
最新推荐文章于 2020-11-25 20:59:57 发布
阅读量173 收藏
点赞数
分类专栏： TP5/TP6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012164509/article/details/104118539
版权

单利模式

解决场景就是如何在整个项目创建一个唯一对象实例

拥有一个构造函数，并且为privare
拥有一个静态成员变量用来保持类的实例
拥有一个访问这个实例的静态方法

注册树模式

注册树模式通过将对象实例注册到一棵全局的对象树上
需要的时候从对象树上采摘下来使用

把一些常用的基础类库或者对象统一挂载这个树上，不用new直接用树上取出来

后续把对象挂载到$objects上

#A.php A类

class A { 
	public function abc() { 
		return "abcd";
	}
}

A类挂载到数下面

class SingwaRegister {
	/*
		注册树池子	
	*/
	protected static $object = null;
	
	/*
		将对象挂到树上 
	*/
	#第一个参数是key，第二个参数是对象
	public static function set($key,$object){ 
		self::$object[$key] = $object;
	}

	/*
		从树上获取对象，如果没有的时候 注册
	*/
    public static function get($key) {
    	if(!isset(self::$object[$key])){
    	#挂载
    		self::$object[$key] = new $key;
    	}
    	return self::$object[$key];
    }

   public static function __unset($key) { 
   		unset(self::$object[$key]);
   }  
}

public function register() { 

	$a = new \A();

	\SingwaRegister::set("singwa",$a);

	$abc = \SingwaRegister::get("singwa")->abc();

	var_dump($abc);
}

在这里插入图片描述

如何理解依赖注入和控制反转

依赖注入和控制反转是同一个东西，就是编程思想不同

依赖注入主要用来减少代码间的耦合
有效分离对象和它所需的外部资源

注入谁注入谁呢

class Person { 
	/*
		依赖   Person类依赖于 Car
		注入  car类注入到Person
	*/
	#传入对象 
	public function buy($obj) { 
		#$bmw = new Car();
		#return $bmw->pay();
		return $obj->pay(); 
	}
}

#M.php 或者Car.php

namespace di;
class M { 
	public function pay() { 
		return 345;
	}
}

public function personbuy() { 
	$signwa = new \di\Person();
	$bmw = new \di\M;
	echo $singwa->buy($bmw);
}

在这里插入图片描述
在这里插入图片描述

PHP反射机制深入学习

一、什么是反射？
它是指在PHP运行状态中，扩展分析PHP程序，导出或提取出关于类、方法、属性、参数等的详细信息，包括注释。这种动态获取的信息以及动态调用对象的方法的功能称为反射API。
在PHP中，反射是指在PHP运行状态中，扩展分析PHP程序，导出或者提取出关于类、属性、方法、参数等的详细信息，包括注释。这种动态获取信息以及动态调用对象方法的功能，被称为反射API。

#文章
https://www.php.net/manual/zh/book.reflection.php

class A { 

	public $ab =1;
	private $bc =2;

	public static $instance = null;

	public function abc() { 
		return "abcd";
	}

	public function abcd($a,$b) { 
		return $a."|".$b;
	}

	// 
	public function mf($type = 1) { 
		return "type:".$type;
	}

	public function ddd() { 
		return "ddd";
	}

}

public function rel() { 
	$obj = new \A();
	##建立一个A类的反射类   是反射ReflectionClass
	$obje2 = new \ReflectionClass($obj);
	$instance = $obj2->newInstance(); //相当于实例化这个类
	//dump($instance);

	#获取类当中的所有方法
	$methods = $obj2->getMethods();

	#获取方法的注释 
	foreach($methods as $method){
		dump($method->getDocComment());
	}

	#类下的所有属性 
	$properties = $obj2->getProperties();

	//方法一 
	#echo $instance->abc(1,2);

	//方法二
	#$method = $obj2->getMethod("abcd");
	#echo $method->invokeArgs($instance,["mmm","4444m"]);

	//方法三 
	#$method = $obj2->getMethod("ddd");
	#echo $method->invoke($instance);


	#判断某个方法是私有方法和共有方法 
	$method = new \ReflectionMethod($obj,"ddd");
	if ($method->isPublic()) {
		echo "ddd方法是公共";
	}
}

#基于A类的反射类

	##建立一个A类的反射类   是反射ReflectionClass
	$obje2 = new \ReflectionClass($obj);
	$instance = $obj2->newInstance(); //相当于实例化这个类
	//dump($instance);

在这里插入图片描述

#获取类当中的所有方法
$methods = $obj2->getMethods();

#获取方法的注释 
foreach($methods as $method){
	dump($method->getDocComment());
}

在这里插入图片描述

#类下的所有属性 
	$properties = $obj2->getProperties();

在这里插入图片描述

在这里插入图片描述

var_dump($method->getParameters());
在这里插入图片描述

传入几个参数
var_dump($method->getNumberOfParameters())

方法一、不使用反射的写法

public function initialize(array $config = array(), $reset = TRUE)
{
    $reflection = new ReflectionClass($this);
...
    #遍历config，如果存在set_方法调用set方法，没有则直接赋值
    foreach ($config as $key => $v) {
        if (method_exists($this, 'set_' . $key)) {
            $this->{'set_' . $key}($v);
        }else{
            $this->$key =$v;
        }
    }

这种方法有个弊端：无法判断config数组的所有key是否合法，是否是类的成员属性

方法二 框架内的实现

反射在这里的体现的好处是：可以判断类是否存在属性（hasProperty），和判断类是否存在方法（hasMethod）。

public function initialize(array $config = array(), $reset = TRUE)
{
    $reflection = new ReflectionClass($this);
...
    foreach ($config as $key => &$value)
    {
        if ($key[0] !== '_' && $reflection->hasProperty($key))
        {
            if ($reflection->hasMethod('set_'.$key))
            {
                $this->{'set_'.$key}($value);
            }
            else
            {
                $this->$key = $value;
            }
        }
    }

容器类

在这里插入图片描述
Container.php

namespace di;
class Container { 

	/*存放容器的数据
		把我们实例化的类放到这里面去 $instances 
	*/
	public $instances = [];


	/*容器中的对象实例*/
	protected static $instance;


	private function __construct() { 

	}

	/*获取当前容器的实例  单利模式*/
	public static function getInstance() { 
		if (is_null(static::$instance)) { 
				#new static   都是new 一个对象
				static::$instance = new static;
		}

		return static::$instance;
	}

	public function set($key,$value) { 

		$this->instances[$key] = $value;
	}
	
	//反射机制 获取容器里面的实例
	public function get($key) { 
		if(!empty($this->instances[$key])) { 
			$key = $this->instances[$key];
		}
		$reflect = new \ReflectionClass($key);
		//获取类的构造函数 没有构造函数直接new 类就行了
		$c = $reflect->getConstructor();
		if(!$c) {
				return new $key;
		}
		
		//获取构造函数里面的参数  $obj
		$params = $c->getParameters();
		if(empty($params)) { 
			return new $key;
		}
		#反射机制 
		foreach($prams as $param) {
			#不加Car判断不到是对象形式
			$class = $params->getClass();
			if(!$class){
				 
			}else{
				#name 就是 di\Car
				$args[] = $this->get($class->name);
				#var_dump($class);exit;
			}
		}
			#再用反射
		 return $reflect->newInstanceArgs($args);
	}
}

构造函数里面有这个类，需要转换成对象，做个反射把它实例化
到时候再去实例化某些类的时候(例如Person)，把数据传递给参数就可以了

var_dump($class);exit; 打印的是
在这里插入图片描述

Person类下构造方法,就会把Car $obj ,场景转换成实例，通过实例调用newInstanceArgs做成实例化，它的参数就传递过来了 —下面的代码

 return $reflect->newInstanceArgs($args)

Car.php

namespace di;
class Car { 
	public function pay() { 
		return 123;
	}
}

Person.php

namespace di;
class Person{ 
	#加Car 满足是对象形式   默认的是Car的类
	public function __construct(Car $obj , $a = 12){
		$this->obj = $obj;  #是123
		$this->a = $a;
	}
	public function buy() {
		#return $this->$obj->pay();
		return $this->a ."|".$this->obj->pay();
	}
}

在这里插入图片描述

index.php
这是应用层
把实例set进去，用的时候get

键名 =>person 对象和实例 new \di\Person()

public function personbuy() { 
	#\di\Container::getInstance()->set("person", new \di\Person());
	#\di\Container::getInstance()->set("car", new \di\Car());

	\di\Container::getInstance()->set("person", "\di\Person");
	\di\Container::getInstance()->set("car", "\di\Car");
	
	#这传的事类名字  person类的
	$obj = \di\Container::getInstance()->get('person');
	#var_dump($obj->buy(\di\Container::getInstance()->get("car")));
	dump($obj->buy());
}

use ArrayAccess; 数组一样使用对象

#接口

interface Countable { 
	public function count();
}

#SingwaCount.php

class SingwaCount implements Countable { 
	public function count() { 
		return 234;
	}
}

#index.php

public function acount() { 
	$obj = new \SingwaCount;
	echo count($obj);
}

在这里插入图片描述
在这里插入图片描述

获取容器里面实例分析

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
app 就是类名和标识

   public static function get($abstract, $vars = [], $newInstance = false)
    {	
    	#本类调用make方法 
        return static::getInstance()->make($abstract, $vars, $newInstance);
    }

 if (true === $vars) {
            // 总是创建新的实例化对象
            $newInstance = true;  #为true 每次都要实例化这个类 
            $vars        = [];
        }

#是反射
use ReflectionClass;

$this->instances 容器里面

/**
     * 创建类的实例
     * @access public
     * @param  string        $abstract       类名或者标识
     * @param  array|true    $vars           变量
     * @param  bool          $newInstance    是否每次创建新的实例
     * @return object
     */
    public function make($abstract, $vars = [], $newInstance = false)
    {
        if (true === $vars) {
            // 总是创建新的实例化对象
            $newInstance = true;
            $vars        = [];
        }

        #默认第一次值都是   $this->name里面是app
        $abstract = isset($this->name[$abstract]) ? $this->name[$abstract] : $abstract;
        //第二次 就成为 $abstract => think\App;

        #看$this->instances有没有这个key    第三次再走就会走到这，因为容器里面有this->instances[think\App]
        if (isset($this->instances[$abstract]) && !$newInstance) { 
            #有值在容器里面就返回 可能是实例或者可能是app或者其他的
            return $this->instances[$abstract];
        }
		
		#如果没有就走下面的逻辑创建,创建并放到容器在返回
        if (isset($this->bind[$abstract])) {
            #绑定  concrete => think\App
            $concrete = $this->bind[$abstract];

            #instanceof (1）判断一个对象是否是某个类的实例，（2）判断一个对象是否实现了某个接口。
            #如果是命名函数走这里或者闭包时候 
            if ($concrete instanceof Closure) {//闭包场景
                $object = $this->invokeFunction($concrete, $vars);
            } else {
                //$this->name['app'] = think\App;
                $this->name[$abstract] = $concrete;
                return $this->make($concrete, $vars, $newInstance);
            }
        } else {
            //返回对象，没有实例 
            $object = $this->invokeClass($abstract, $vars);
        }

        if (!$newInstance) {
            #是对象 $object    
            $this->instances[$abstract] = $object;
            // $this->instances[think\App] = object;

        }
        return $object;
    }

 /**
     * 调用反射执行类的实例化 支持依赖注入
     * @access public
     * @param  string    $class 类名
     * @param  array     $vars  参数
     * @return mixed
     */
    public function invokeClass($class, $vars = [])
    {
        try {
            //实现这个反射类
            $reflect = new ReflectionClass($class);

            //当中是否存在__make方法 
            if ($reflect->hasMethod('__make')) {
                    #反射这个类实现这个方法
                $method = new ReflectionMethod($class, '__make');

                if ($method->isPublic() && $method->isStatic()) {
                    $args = $this->bindParams($method, $vars);
                    #就实例化了
                    return $method->invokeArgs(null, $args);
                }
            }

            $constructor = $reflect->getConstructor();

            $args = $constructor ? $this->bindParams($constructor, $vars) : [];

            return $reflect->newInstanceArgs($args);

        } catch (ReflectionException $e) {
            throw new ClassNotFoundException('class not exists: ' . $class, $class);
        }
    }

 /**
     * 调用反射执行类的实例化 支持依赖注入
     * @access public
     * @param  string    $class 类名
     * @param  array     $vars  参数
     * @return mixed
     */
    public function invokeClass($class, $vars = [])
    {
        try {
            //实现这个反射类
            $reflect = new ReflectionClass($class);

            //当中是否存在__make方法 
            if ($reflect->hasMethod('__make')) {
                    #反射这个类实现这个方法
                $method = new ReflectionMethod($class, '__make');

                if ($method->isPublic() && $method->isStatic()) {
                    $args = $this->bindParams($method, $vars);
                    #就实例化了
                    return $method->invokeArgs(null, $args);
                }
            }

            $constructor = $reflect->getConstructor();

            $args = $constructor ? $this->bindParams($constructor, $vars) : [];
            #实例化这个类
            return $reflect->newInstanceArgs($args);

        } catch (ReflectionException $e) {
            throw new ClassNotFoundException('class not exists: ' . $class, $class);
        }
    }

在这里插入图片描述

在这里插入图片描述

门面模式Facade

门面为容器中的类提供了一个静态调用接口
相比于传统的静态方法调用，带来了更好的可测试性和扩展性

thinkphp/library/think/facade/Config.php

public function facade() { 
	dump(\think\facade\Config::get("app."));
}

thinkphp/library/think/facade/Config.php 根本没有get方法,包括父类Facade也没有get方法就会执行下面的方法

 //调用实际类的方法 也就说在应用层调用一个不存在静态方法的时候就会走到__callStatic
    public static function __callStatic($method, $params)
    {
        return call_user_func_array([static::createFacade(), $method], $params);
    }

在这里插入图片描述
在这里插入图片描述

打印出

在这里插入图片描述

如果加一个 abcd 方法

在这里插入图片描述
应用层在调用 输出就下面的
在这里插入图片描述

/**
     * 创建Facade实例
     * @static
     * @access protected
     * @param  string    $class          类名或标识
     * @param  array     $args           变量
     * @param  bool      $newInstance    是否每次创建新的实例
     * @return object
     */
    protected static function createFacade($class = '', $args = [], $newInstance = false)
    {
        $class = $class ?: static::class;

        $facadeClass = static::getFacadeClass();

        if ($facadeClass) {
            $class = $facadeClass;
            #否则看上层self::$bind的属性，如果有就把值付给它$class
        } elseif (isset(self::$bind[$class])) {
            $class = self::$bind[$class];
        }

        if (static::$alwaysNewInstance) {
            $newInstance = true;
        }

        #容器拿到我们想要的这么一个类，比如容器有，我就返回容器里面的实例，容器理由config实例我就返回，如果没有走容器里的创建的实例逻辑
        return Container::getInstance()->make($class, $args, $newInstance);
    }

好处:我们能够通过静态的方式去调用类的一些方法

在这里插入图片描述

在这里插入图片描述
facade\Singwa.php

namespace app\facade;
use think\Facade;

class Singwa extends Facade { 

	 /**
     * 获取当前Facade对应类名（或者已经绑定的容器对象标识）
     * @access protected
     * @return string
     */
     protected static function getFacadeClass(){ 

     	return "singwa";#没有绑定Singwa
     	return '\app\common\Singwa';
     }
}

application\common\Singwa.php

namespace app\common;
class Singwa {
	public function abcd() { 
		return "abcd";
	}
}

通过静态的方式去调用实际方法里面的内容 门面模式的思想

public function facade() { 

	// 实际的 singwa调用
	#$obj = new \app\common\Singwa();
	#echo $obj->abcd();

	//需要把上面的内容转换为门面模式思想来调用
	echo \app\facade\Singwa::abcd();
}

在这里插入图片描述

第二种 如何绑定呢

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public function facade(){

	\think\Faade::bind('app\facade\Sing','app\common\Sing');
	dump(\app\facade\Sing::abcd());
}

在这里插入图片描述

伟伟哦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
laravel源码解析之Facade
蛐蛐的博客
12-18 207
文档：Facades - Laravel - The PHP Framework For Web Artisans 1.简介 Facades 为应用程序的服务容器中可用的类提供“静态”接口。 也就是Facade为容器中注册的对象提供静态代理 2.RegisterFacades Illuminate\Foundation\Bootstrap\RegisterFacades是初始引导器之一，作用就是初始化Facade public function bootstrap(Ap
C++设计模式——门面模式（facade pattern）
净无邪博客
09-04 1040
一、原理讲解 门面模式也叫做外观模式，实质就是一个封装接口，通常是将一类功能或者一个层次功能用一个函数封装起来，供客户端统一调用。 1.1意图 为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个借口使得这一子系统更加容易使用。 1.2应用场景 当你要为一个复杂子系统提供一个简单接口时； 客户程序与抽象类的实现部分之间存在着很大依赖性； 当你需要构建一个层次的子系统时，使用Facade模式定义子系统中每层的入口点； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义一
使用反射技术和Facade模式演示封装数据库操作--ORM原理
03-05
本人在教Java方向课程时，发现现组长们不能象以前班级的学长写出封装得比较好的DAO工具类。于是，使用Facade模式和反射技术模拟Hibernate框架技术演示怎样书封装数据库的操作。 环境：Windows XP Professional, JDK 1.6, Eclipse 3.3 Europa, SQL Server 2000 使用步骤： 1. 下载解压之后，使用Eclipse导入工程 2. 打开SQL server 2000的查询分析器 3. 把工程中的demospl.sql放到查询分析器中 4. 编辑com.jb.arklis.dao.MyDBConnection中的数据库名 5. 运行SQL脚本生成演示应用所需的数据库表与测试数据 6. 运行com.jb.arklis.app.DemoApplication类 7. 如果一切正常，那么可以看一个弹出的对话框，里面数据库表userinfo的十二记录 设计思路： 该自定的框架对书写客户端代码的人员只有两个要求： 1. 清楚数据库的表userinfo结构--有多少个字段和类型 2. 根据表可以书写一个对应的POJO类 如果以上两个条件成立，那么书写操作数据库的代码很简单：只需呼叫FacadeForDAO.findModel(表名)方法，在表名参数给出实际数据库中表的名称就可以返回一个包含对应POJO类的对象的集合--非常简单--输入表名得到Java对象的集合，然后根据需要使用这些对象。 给客户端代码方式是通过Facade对象封装DAO类，以及业务逻辑接口来实现的。对于数据库表与POJO类的映射是使用反射技术来完成。metainform部分使用.properties文档来对应Hibernate的xml影射档。我偷懒没有把jdbc部分和POJO的setter方法名写到.properties文档中去，jdbc部分使用com.jb.arklis.dao.MyDBConnection类来代理完成。 所以，重点看com.jb.arklis.dao.BaseDAO类中的public List findAll(String tableName)方法。该类注释非常详细，一行注释一行代码。如果还看不懂，那么你可以把工程中的“BaseDAO.未完全使用反向的写法”文档替换原来的BaseDAO试看看，我想如果替换之后，你一定能看懂反射的代码了。如果还看不懂？？？？那我也没有办法了^_^ 阅读对象：所有立志学习Java技术的学员。 God bless you!
php的反射机制
littlexiaoshuishui的博客
11-27 676
在PHP中，反射是指在PHP运行状态中，扩展分析PHP程序，导出或者提取出关于类、属性、方法、参数等的详细信息，包括注释。这种动态获取信息以及动态调用对象方法的功能，被称为反射API。 其实就是通过一个对象，获取到实例化这个对象的类的所有信息。包括所有属性（共有，私有，静态），所有方法（构造函数，私有函数），还有对应方法的参数信息，还有方法的注释信息等等。 1.反射类对象ReflectionC...
tp5.1 Facade - 门面（四）
坚持
07-07 1214
作用 门面为容器中的类提供了一个静态调用接口，相比传统了静态方式调用，带来了更好的可测试性和扩展性。 代码使用 （这样写可以直接调用）两段代码执行的结果一样，实际执行的是在\think\Facade\Config $apps = \Config::get('app.'); halt($apps); $apps = \think\Facade\Config::get('ap...
tp5.1 IOC容器解析（三）
坚持
07-03 943
一、学习内容 1、单列模式。 2、注册树模式。 3、php 反射机制。 二、容器中图分解Container.png 大体上就这么几点： 1、设计模式：单列模式、注册数模式。 2、php 反射思想（对应的方法）。 3、依赖注入。 三、分析主要的几个方法 1、get方法 =》make方法 /** * 获...
static关键字与newinstance（）
zy1104560031的专栏
11-29 2796
“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。” 这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是： 方便在没有创建对象的情况下来进行调用（方法/变量）。 很...
ThinkPHP5.1之容器注入(IOC)和门面模式(facade)
阅读之后，对你有帮助，那就点个赞再走吧
01-18 1193
容器注入：也叫 依赖注入容器， 用户在客户端使用容器来进行类管理，还可以将类的实例（对象）做为参数，传递给类方法，自动触发依赖注入。 简单的讲就是将工具类打包成一个容器，在客户端完成工具类的实例化为对象，再以参数的方式直接传递给工作类的方法。 容器：也称服务容器，简称（IOC）类似于:[即插即用]的工具，最大限度的简化外部对象的调用 实现步骤有三步： 创建工具类 /...
Facade模式框架源码
s2008100262
11-25 1131
1、Facade模式概念 2、优缺点 3、类图 4、开源框架引例 4.1 common-beanutils * Licensed to the Apache Software Foundation (ASF) under one or more package org.apache.commons.beanutils.converters; import org.apache.commons.beanutils.Converter; /** ...
C++设计模式编程中Facade外观模式的使用实例解析
09-02
Facade外观模式是设计模式中的一种，它的主要目标是为复杂的子系统提供一个简洁的接口，使得客户端（调用者）能更容易地使用这些子系统。在本文中，我们将深入探讨Facade模式的原理、应用场景及其实现方式。 Facade...
解析C#设计模式编程中外观模式Facade Pattern的应用
09-02
外观模式（Facade Pattern）是设计模式中的一种结构型模式，其主要目的是为了简化客户端与复杂系统之间的交互。在C#编程中，外观模式通常用于减少客户端对子系统组件的依赖，提供一个统一的、高层次的接口，使得...
Java设计模式之外观模式（Facade模式）介绍
09-03
外观模式（Facade模式）是一种设计模式，主要用于简化子系统或组件之间的交互，为复杂的系统提供一个简单的接口。在Java中，这种模式可以帮助我们管理和组织大量的类和接口，使其对外呈现简洁的交互方式。 外观模式...
PHP设计模式之外观模式（Facade）入门与应用详解
10-15
主要介绍了PHP设计模式之外观模式（Facade）,结合实例形式详细分析了PHP外观模式的具体原来、用法及相关操作注意事项,需要的朋友可以参考下
分布式电网动态电压恢复器模拟装置设计与实现.doc
最新发布
07-06
本装置采用DC-AC及AC-DC-AC双重结构，前级采用功率因数校正（PFC）电路完成AC-DC变换，改善输入端电网电能质量。后级采用单相全桥逆变加变压器输出的拓扑结构，输出功率50W。整个系统以TI公司的浮点数字信号控制器TMS320F28335为控制电路核心，采用规则采样法和DSP片内ePWM模块功能实现SPWM波，采用DSP片内12位A/D对各模拟信号进行采集检测，简化了系统设计和成本。本装置具有良好的数字显示功能，采用CPLD自行设计驱动的4.3英寸彩色液晶TFT-LCD非常直观地完成了输出信号波形、频谱特性的在线实时显示，以及输入电压、电流、功率，输出电压、电流、功率，效率，频率，相位差，失真度参数的正确显示。本装置具有开机自检、输入电压欠压及输出过流保护，在过流、欠压故障排除后能自动恢复。
【无人机通信】基于matlab Stackelberg算法无人机边缘计算抗干扰信道分配【含Matlab源码 4957期】.mp4
07-06
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
电网公司数字化转型规划与实践两个文件.pptx
07-05
电网公司数字化转型规划与实践两个文件.pptx
React Native Ruby 前后端分离系统案例介绍文档
07-06
React Native Ruby 前后端分离系统案例介绍文档
http请求方法.docx
07-06
HTTP（Hypertext Transfer Protocol）定义了一些常见的请求方法（也称为动词或谓词），用于指示对服务器执行的操作类型。以下是常见的 HTTP 请求方法： GET：从服务器获取资源。GET 方法的请求参数一般附在 URL 后面，通过问号传参形式传递。 POST：向服务器提交数据，常用于提交表单或上传文件等操作。POST 方法的请求参数一般包含在请求体中。 PUT：向服务器发送数据，用来创建或更新资源。通常用于更新整个资源，但不限于此。 DELETE：请求服务器删除指定的资源。 HEAD：类似于 GET 方法，但服务器只返回响应头部，不返回实际内容。主要用于获取资源的元信息。 PATCH：部分更新资源，用来对资源进行局部修改。 OPTIONS：获取目标资源所支持的通信选项，常用于跨域请求的预检。 TRACE：回显服务器收到的请求，主要用于测试或诊断。 CONNECT：HTTP/1.1 协议中预留给能够将连接改为管道方式的代理服务器。 这些方法定义了客户端与服务器之间的交互方式，每种方法都有特定的语义和使用场景。在实际开发中，选择合适的方法非常重
ROS的一些基本概念和语法介绍 ROS提供了丰富的工具和库，用于构建复杂的机器人应用.docx
07-06
ROS的一些基本概念和语法介绍。ROS提供了丰富的工具和库，用于构建复杂的机器人应用.docx
Java23种设计模式
09-01
- **外观模式 (Facade)**：为子系统提供一个统一的接口，简化客户端与其交互。 - **桥接模式 (Bridge)**：将抽象部分与实现部分解耦，使得它们可以独立地变化。 - **组合模式 (Composite)**：允许你将对象组合成...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

伟伟哦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值