C++STL详解(10) -- 使用哈希表封装unordered_set和unordered_map

news2024/9/20 20:21:59

文章目录

  • 哈希表模板参数改造
    • 针对模板参数V改造
    • 增加仿函数获取具体数据类型.
  • 哈希表的正向迭代器
    • 正向迭代器中的内置成员:
    • 正向迭代器的成员函数
  • 哈希表插入函数的修改(适用于unordered_map)
  • 一个类型K去做set和unordered_set他的模板参数的必备条件.
  • unordered_set的模拟实现(完整代码)
  • unordered_map的实现(完整代码)
  • 适用于unordered_set和unordered_map的哈希表代码

哈希表模板参数改造

针对模板参数V改造

因为不同容器的类型不同,如果是unordered_map,V代表一个键值对,如果unordered_set,V代表Key值,而底层哈希表并不知道上层容器所要传递的
V模板参数类型,为了与哈希表的模板参数区分,我们将哈希表中的V模板参
数改为T.
在这里插入图片描述

增加仿函数获取具体数据类型.

例如: 在哈希表中当我们使用Find函数进行查找时:
如果上层传递的数据类型为Key值,我们就可以直接与查找数据比较.
如果上层传递的数据类型为pair<K,V>键值对,我们就不可以直接比较,需要利用仿函数获取键值对的first进行比较.
unordered_set仿函数SetKeyOfT代码:

struct SetKeyOfT              //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

unordered_map仿函数MapKeyOfT代码:

struct MapKeyOfT                   //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;   //获取pair<K,V>键值对中的first.
			}
		};

所以,我们要在哈希表模板参数中增加一个仿函数KeyOfT.
如果是unordered_set,就传 SetKeyOfT类型的仿函数.
如果是unordered_map,就传MapKeyOfT类型的仿函数.

模板参数转换图示如下:
在这里插入图片描述
额外说明:
1: 我们对原先哈希表中的Hash进行了修改,不要缺省值,因为我们肯定是使用上层容器传递不同的仿函数类型,所以在unordered_set与unordered_map中传递仿函数类型.

哈希表的正向迭代器

正向迭代器中的内置成员:

哈希表正向迭代器有两个内置成员:
1: 结点指针
2: 哈希表的指针


template < class K, class T, class Hash, class KeyOfT >
class HashTable;                   //重新声明哈希表类模板.
//正向迭代器
template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
struct __HTIterator
{
	typedef HashNode<T> Node; //重新定义哈希结点的类型为Node.
	typedef HashTable<K, T, KeyOfT, HashFunc> HT; //重新定义哈希表的类型为HT.
	typedef __HTIterator<K, T, KeyOfT, HashFunc> Self; //重新定义正向迭代器的类型为Self.

	Node* _node; //结点指针
	HT* _pht; //哈希表指针
};

注意:
因为迭代器中要使用到哈希表类型,所以我们在哈希表迭代器前面必须声明一下哈希表类模板.

正向迭代器的成员函数

以下成员函数较为简单,就不另外说明:


		_HashIterator( Node* node,HT* pht )  //初始化列表
			:_node(node)
			, _pht(pht)
		{
		}
        
		T& operator*()                     //解引用运算符重载
		{
			return _node->_data;
		}

		T* operator->()                 //->运算符重载
		{
			return &_node->_data;
		}

		bool operator!=( const Self& s ) const  //外面增加const可以使const对象也能调用该成员函数.
		{
			return _node != s._node;  //实质上是迭代器中的_node比较
		}


		bool operator==( const Self& s )const 
		{
			return _node == s._node;
		}

前置++运算符重载:
前置++运算符重载主要有两个步骤:
1: 如果当前结点指针的下一个结点存在,则结点指针指向下一个结点.

2: 如果当前结点指针的下一个结点不存在:
(1): 通过哈希函数计算哈希桶的位置.

(2): 在哈希表中,从哈希桶中的下一个位置开始遍历查找.
如果哈希桶存在,则将结点指针指向该哈希桶.
如果哈希表遍历完还没有找到,则说明这是哈希表中的最后一个数据的迭代器,则结点指针指向空,表明最后一个数据的下一个结点.

Self& operator++()
		{
			if (_node->_next)  //在当前桶中迭代
			{
				_node = _node->_next;
			}
			                  //如果该哈希桶迭代完毕，则在哈希表中找下一个哈希桶迭代寻找．
			else
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员
				size_t i = hashi + 1;
				
				for (;  i < _pht->_table.size(); ++i)
				{
					if (_pht->_table[i])
					{
						_node = _pht->_table[i];
						break;                       //++完就退出.
					}
			        
				}
				if (i == _pht->_table.size())        //此时,这也说明正式哈希桶迭代器的end.
				{
					_node = nullptr;
				}

			}

			return *this;
		}

哈希表插入函数的修改(适用于unordered_map)

为了支持unordered_map中的[]操作符重载,我们针对哈希表中的插入函数返回值进行修改
(1): 如果哈希表中已有所给数据,则返回已有数据的迭代器与插入结果(失败)所构成的键值对.

(2): 如果哈希表没有所给数据,则将新数据头插该哈希桶组成的单链表上,返回新插入结点指针构造与插入结果(成功)组成的键值对.

插入函数代码如下:


	      pair< Iterator,bool> Insert(const T& data)
		   {
			Hash hash;
			KeyOfT kot;		                                                   
			Iterator ret = Find(kot(data));                    
			if (ret != end())
			{
				return make_pair( ret, false);
			}
			if (_size == _table.size())                                //扩容.
			{
				//	size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();
				vector<Node*> newTable;
				newTable.resize(GetNextPrime(_table.size()), nullptr); 

				Hash hash;
				//从旧表结点移动映射新表.
				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(kot(cur->_data)) % newTable.size();
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newTable);
               
			}
			size_t hashi = hash(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[hashi];
			_table[hashi] = newNode;
			++_size;
			return make_pair(Iterator(newNode,this),true);                //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.
		}

一个类型K去做set和unordered_set他的模板参数的必备条件.

set容器模板参数:
(1):set模板参数要求能够支持小于比较,例如:二叉搜索树查找成员函数中,我们可以利用compare仿函数将当前结点值与所给值比较,从而决定cur遍历左子树还是右子树,为了能够支持大于比较的,我们可以交换一下实参位置,这也间接支持了大于比较.并且条件判断,进而也支持了等于.
unordered_set容器模板参数要求:
(1)针对于K类型(指针,打浮点数,有符号整型)可以转换为无符号整数取模.对于string,日期类类型,这两个类型与整型类型无关的,此时不可以直接强转为整数,需要相应的提供将该类型转换为整数的仿函数.

(2):K类型对象能够支持等于比较(因为在查找中就是要确定存储的对象与所传的对象是否相等,例如Data日期类),如果不支持需要额外提供等于比较的仿函数.

unordered_set的模拟实现(完整代码)

在上述中,我们已经将unordered_set重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.

namespace yzh
{
	//2:因为我们使用map,set是将实参传给,map,set的所以当string类型取模时要在map,set中写仿函数.
	template < class K,class Hash = HashFunc<K>> //1:由第二个模板参数决定要存储的数据.
	class unordered_set
	{
		struct SetKeyOfT                                  //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename HashBucket::HashTable< K,K,Hash,SetKeyOfT>::Iterator iterator;  //重新定义一下迭代器类型为iterator.

		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		
		pair<iterator,bool> Insert(const K& key)
		{
			return _ht.Insert(key);
		}
	private:
		HashBucket::HashTable<K,K,Hash,SetKeyOfT> _ht;
	};
	void test_set()                      //测试
	{
		unordered_set<int> set;
		set.Insert(1);
		set.Insert(2);
		set.Insert(3);
		
		unordered_set<int>::iterator it = set.begin();
		while ( it != set.end() )
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	
}

unordered_map的实现(完整代码)

在上述中,我们已经将unordered_map重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.

namespace yzh
{
	template < class K, class V, class Hash = HashFunc<K> >            //由第二个模板参数决定要存储的数据类型,
	class unordered_map
	{
		struct MapKeyOfT                                             //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
		
	public:
		typedef typename HashBucket::HashTable< K, pair<K, V>, Hash, MapKeyOfT>::Iterator iterator;//重新定义一下迭代器类型为iterator.
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
	   pair<iterator,bool> Insert( const pair<K, V>& kv )
		{
			return _ht.Insert(kv);
		}
	   V& operator[]( const K& key  )                      //给一个key,返回V的引用.
	   {
		   pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));   //如果插入失败,返回已有数据的迭代器与返回结果组成的pair.                                                 //如果插入成功,返回新插入数据的迭代器与返回结果组成的pair.
		   return ret.first->second;
	   }
	   
	private:
		HashBucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;     //map和set都知道传递什么来类型的仿函数,以及要传递的数据类型.
	};
	void test_map()
	{
		unordered_map<string, string> dict;
		dict.Insert(make_pair("sort", "排序"));
		dict.Insert(make_pair("string", "排序"));

		unordered_map<string,string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << ":" << it->second  << endl;
     		++it;
		}
	}

	void testmap1()
	{
		unordered_map<string, int> countMap;
		string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","西瓜","苹果","香蕉" };
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
    }


	
}

适用于unordered_set和unordered_map的哈希表代码

#include <map>
#include <vector>
#include <string>
#include <string>
#include <iostream>
using namespace std;
template < class K >                   //仿函数的默认值,如果不显示传就会默认调用.
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template< >                                 //1:对于常见类型,为了方便,我们可以对类模板进行特化.
struct HashFunc <string>                    //并且根据实参所传类型,优先走特化版本.	                                     
{
	size_t operator()(const string& key)
	{
		size_t  val = 0;
		for (auto& ch : key) //遍历string,将一个个字母替换成ASCI码进行相加.
		{
			val += ch;
		}
		return val;
	}
};
namespace HashBucket
{

	template < class T >
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

	template < class K, class T, class Hash, class KeyOfT >
	class HashTable;
	
	template < class K, class T, class Hash, class KeyOfT >
	struct _HashIterator
	{
		typedef HashNode<T> Node;
		typedef HashTable< K, T, Hash, KeyOfT> HT;
		typedef _HashIterator< K, T, Hash, KeyOfT> Self;
		Node* _node;
	    HT* _pht;
		
		_HashIterator( Node* node,HT* pht )
			:_node(node)
			, _pht(pht)
		{
		}
        
		T& operator*()
		{
			return _node->_data;
		}

		T* operator->()
		{
			return &_node->_data;
		}

		Self& operator++()
		{
			if (_node->_next)  //在当前桶中迭代
			{
				_node = _node->_next;
			}
			                  //如果该哈希桶迭代完毕，则在哈希表中找下一个哈希桶迭代寻找．
			else
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员
				size_t i = hashi + 1;
				
				for (;  i < _pht->_table.size(); ++i)
				{
					if (_pht->_table[i])
					{
						_node = _pht->_table[i];
						break;                       //++完就退出.
					}
			        
				}
				if (i == _pht->_table.size())        //此时,这也说明正式哈希桶迭代器的end.
				{
					_node = nullptr;
				}

			}

			return *this;
		}

		bool operator!=( const Self& s ) const
		{
			return _node != s._node;
		}


		bool operator==( const Self& s )const 
		{
			return _node == s._node;
		}

		
	};
	
	template < class K, class T, class Hash, class KeyOfT >
	struct HashTable
	{
		typedef HashNode<T> Node;
		template < class K, class T, class Hash, class KeyOfT > //为了迭代器能够访问哈希表的私有成员,我们设为迭代器是哈希表的
		                                                        //友元,类模板声明友元需要增加类模板.
		friend struct  _HashIterator;
		
	public:
		typedef _HashIterator< K, T, Hash, KeyOfT> Iterator;
		
		Iterator begin()//获取第一个迭代器
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					return Iterator( _table[i], this );
				}
			}
			return end();
		}

		Iterator end()  //获取最后一个迭代器
		{
			return Iterator(nullptr, this);
		}

		size_t GetNextPrime(size_t prime)
		{
			const int PRIMECOUNT = 28;
			//素数序列
			const size_t primeList[PRIMECOUNT] =
			{
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};
			size_t i = 0;
			for (i = 0; i < PRIMECOUNT; i++)
			{
				if (primeList[i] > prime)         //从这个数组里面取第一个大于prime的值.
					return primeList[i];
			}
			return primeList[i];                 //虽然数据不可能那么大,但是也有可能不会走if判断,
												 // 所以从语法上来说还要考虑所给值prime大于素数数组整个数据的情况.
		}

		~HashTable()         //vvector会调用析构函数,但是哈希桶必须自己写.
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
			//	cout << "~HushTable()" << endl;

		}

		bool  Erase(const K& key)
		{
			if (_table.size() == 0)
			{
				return true;
			}
			Hash hash;
			size_t hashi = hash(key) % _table.size();
			Node* prev = nullptr;
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_size;
					return true;
				}

				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

	      pair< Iterator,bool> Insert(const T& data)
		   {
			Hash hash;
			KeyOfT kot;
			
			                                                   //去重
			Iterator ret = Find(kot(data));                    //如果该数据已经有了,则返回已有数据的迭代器与插入结果构成的pair.
			if (ret != end())
			{
				return make_pair( ret, false);
			}
			if (_size == _table.size())                                //扩容.
			{
				//	size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();
				vector<Node*> newTable;
				newTable.resize(GetNextPrime(_table.size()), nullptr);    //扩容

				Hash hash;
				//从旧表结点移动映射新表.
				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(kot(cur->_data)) % newTable.size();
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newTable);
               
			}
			size_t hashi = hash(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[hashi];
			_table[hashi] = newNode;
			++_size;
			return make_pair(Iterator(newNode,this),true);                //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.
		}

	     Iterator Find(const K& key)
		{
			if (_table.size() == 0)        //表为空,就返回nullptr.
			{
				return end();
			}
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return Iterator(cur, this);
				}
				cur = cur->_next;
			}
			return end();
		}

		size_t size()
		{
			return _size;
		}
		size_t TablesSize()          //表的长度
		{
			return  _table.size();
		}

		size_t BucketNum()           //有多少个桶被用了.
		{
			size_t Num = 0;
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					++Num;
				}
			}
			return Num;
		}
		size_t MaxBucketLenth()
		{
			size_t maxLen = 0;
			for (size_t i = 0; i < _table.size(); ++i)
			{
				size_t len = 0;
				Node* cur = _table[i];
				while (cur)
				{
					++len;
					cur = cur->_next;
				}
				if (len > maxLen)
				{
					maxLen = len;
				}
			}
			return maxLen;
		}
	private:
		vector<Node*> _table;
		size_t _size = 0;
	};
}

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

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

相关文章

看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（LeetCode刷题242有效的字母异位词） 2023.4.25

看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（LeetCode刷题242有效的字母异位词） 2023.4.25

目录 前言算法题&#xff08;LeetCode刷题242有效的字母异位词&#xff09;—&#xff08;保姆级别讲解&#xff09;分析题目&#xff1a;有效的字母异位词代码&#xff1a;算法思想&#xff1a; 结束语 前言 本文章一部分内容参考于《代码随想录》----如有侵权请联系作者删除…
阅读更多...
详解js跨页面传参以及API的解释

详解js跨页面传参以及API的解释

详解js跨页面传参 前言什么是跨页面传参&#xff1f;跨页面传参本质是什么&#xff1f;常见的跨页面传参方法URL参数传递localStorage和sessionStorage参数传递Cookie传递 经常听到API&#xff0c;那么到底的什么是API&#xff1f; 前几天有粉丝私信我&#xff0c;希望能把js跨…
阅读更多...
超越YOLOv8，飞桨推出精度最高的实时检测器RT-DETR！

超越YOLOv8，飞桨推出精度最高的实时检测器RT-DETR！

‍‍ 众所周知&#xff0c;实时目标检测( Real-Time Object Detection )一直由 YOLO 系列模型主导。 飞桨在去年 3 月份推出了高精度通用目标检测模型 PP-YOLOE &#xff0c;同年在 PP-YOLOE 的基础上提出了 PP-YOLOE 。后者在训练收敛速度、下游任务泛化能力以及高性能部署能力…
阅读更多...
搞懂 API ，地图 API 制作方法分享

搞懂 API ，地图 API 制作方法分享

地图 API 是一种基于 Web 开发的应用程序编程接口&#xff0c;可以用于创建和展示地图及地理信息。以下是一些地图 API 制作的方法&#xff1a; 选择地图 API 平台&#xff1a;目前市场上有很多地图 API 平台供选择&#xff0c;比如 Google Maps API、百度地图 API、高德地图 A…
阅读更多...
Chess.com：象棋社区网站每月访问量达 2.8 亿，年收入在 5000 万至 1 亿之间

Chess.com：象棋社区网站每月访问量达 2.8 亿，年收入在 5000 万至 1 亿之间

Chess.com是世界领先的国际象棋社区。它始于 2007 年&#xff0c;目前年收入超过 5000 万美元。 核心功能 Live Chess 花了 5 个多月才发布。到那时&#xff0c;该网站已经拥有近100,000名会员。Chess.com 域名的重要性他们 80% 的用户来自过去 4 年 Chess.com的故事是如何开…
阅读更多...
[算法前沿]--004-transformer的前世今生

[算法前沿]--004-transformer的前世今生

文章目录 1.transformer介绍1.1 注意力机制1.2 Transformer架构1.2.1编码器1.2.2解码器 2. Transformer中的模块2.1 注意模块2.1.1 缩放点积注意事项2.1.2 多头注意 2.2 Transformer中的注意事项2.2.1 自注意2.2.2 掩蔽的自注意&#xff08;自回归或因果注意&#xff09;2.2.3 …
阅读更多...
027：Mapbox GL加载circle样式图层，用data-driven风格绘制圆形

027：Mapbox GL加载circle样式图层，用data-driven风格绘制圆形

第027个 点击查看专栏目录 本示例的目的是介绍演示如何在vue+mapbox中加载circle样式图层。圆形样式图层在地图上呈现一个或多个实心圆。 您可以使用圆形图层来配置矢量切片中点或点集合要素的视觉外观。 圆形层渲染其半径以屏幕单位测量的圆形。 直接复制下面的 vue+mapbox源…
阅读更多...
HTML5 ＜label＞ 标签、HTML5 ＜map＞ 标签

HTML5 ＜label＞ 标签、HTML5 ＜map＞ 标签

HTML5 <label> 标签 实例 HTML5 <label>标签用于为 input 元素做出标记。 带有两个输入字段和相关标记的简单 HTML 表单&#xff1a; <form action"demo_form.asp"><label for"male">Male</label><input type"ra…
阅读更多...
【libuv】入门：queue work 的跨线程异步通信

【libuv】入门：queue work 的跨线程异步通信

通过阅读2012年的uv book 入门。有中文版 Handles and Requests libuv works by the user expressing interest in particular events. This is usually done by creating a handle to an I/O device, timer or process. Handles are opaque structs named as uv_TYPE_t where…
阅读更多...
【分布式搜索引擎ES01】

【分布式搜索引擎ES01】

分布式搜索引擎ES 分布式搜索引擎ES1.elasticsearch概念1.1.ES起源1.2.倒排索引1.2.1.正向索引1.2.2.倒排索引 1.3.es的一些概念1.3.1.文档和字段1.3.2.索引和映射1.3.3.mysql与elasticsearch 1.4.1安装es、kibana、IK分词器1.4.2扩展词词典与停用词词典 2.索引库操作2.1.mappi…
阅读更多...
设置网格旋转轴心【Babylonjs】

设置网格旋转轴心【Babylonjs】

推荐&#xff1a;用 NSDT场景设计器 快速搭建3D场景。 Babylon.js 中的轴心&#xff08;Pivot Point&#xff09;是使用父节点设置网格变换中心的替代方法&#xff0c;即用作旋转中心或放大中心的点。 注意&#xff1a;使用 setPivotPoint 产生的行为不同于在 3DS Max 和 Maya …
阅读更多...
vue-cli的使用和单页面应用程序、使用vue-cli脚手架创建vue项目步骤

vue-cli的使用和单页面应用程序、使用vue-cli脚手架创建vue项目步骤

1.vue-cli的使用 vue-cli是Vue.js开发的标准工具。它简化了程序员基于webpack创建工程化的Vue项目的过程。 引用自vue-cli官网上的一句话: 程序员可以专注在撰写应用上&#xff0c;而不必花好几天去纠结webpack配置的问题。 中文官网: https://cli.vuejs.org/zh/ 1.1 安装 …
阅读更多...
WTI纽约原油CFD是什么？交易技巧有哪些？

WTI纽约原油CFD是什么？交易技巧有哪些？

WTI常称为美国原油或纽约原油&#xff0c;WTI是West Texas Intermediate 的简称&#xff0c;代表西德州中级原油(West Texas Intermediate)&#xff0c;偶尔称为德州轻甜原油(Texas Light Sweet)&#xff0c;它是大宗商品交易中核心的石油基准。那么本文就来具体的聊聊&#xf…
阅读更多...
接口自动化【四】（在接口自动化【三】上的优化_加入了类前置，表格中替换数据，断言）

接口自动化【四】（在接口自动化【三】上的优化_加入了类前置，表格中替换数据，断言）

前言 一、使用 unittest框架结合setUpClass前置条件上传图片 二、一个类里面同时有类方法和实例方法----补充知识点&#xff08;需要引用类方法中的变量&#xff09; 三、结合类前置setUpClass&#xff0c;ddt&#xff0c;Excel表格数据&#xff0c;进行上传图片 四、加入l…
阅读更多...
铁路应答器传输系统介绍

铁路应答器传输系统介绍

应答器传输系统 应答器传输系统是安全点式信息传输系统&#xff0c;通过应答器实现地面设备向车载设备传输信息。 应答器可根据应用需求向车载设备传输固定的&#xff08;通过无源应答器&#xff09;或可变的&#xff08;通过有源应答器&#xff09;上行链路数据。 当天线单…
阅读更多...
【gitee】安装依赖报错

【gitee】安装依赖报错

gitee地址 安装依赖时报错 Error while executing: npm ERR! D:\gongju\Git\cmd\git.EXE ls-remote -h -t git://github.com/adobe-web npm ERR! Error while executing: npm ERR! D:\git\Git\cmd\git.EXE ls-remote -h -t https://github.com/nhn/raphael.git npm ERR! npm…
阅读更多...
数据分析实战 205 ：项目分析思路 —— 某在线教育机构经营分析

数据分析实战 205 ：项目分析思路 —— 某在线教育机构经营分析

版权声明&#xff1a;本文为博主原创文章&#xff0c;未经博主允许不得转载。 文章目录 一、思路分析1.1 教育行业营收转化模型1.2 某教育机构利润结构1.3 问题确认与指标拆解&#xff1a;业务逻辑图1.3.1 确认毛利额数据异常的问题1.3.2 提升毛利额的方案 1.4 问题解决思路 一…
阅读更多...
vue大屏开发系列—使用echart开发省市地图数据，并点击省获取市地图数据

vue大屏开发系列—使用echart开发省市地图数据，并点击省获取市地图数据

1. 本文在基础上进行改进&#xff0c;后端使用若依后端 IofTV-Screen: &#x1f525;一个基于 vue、datav、Echart 框架的物联网可视化&#xff08;大屏展示&#xff09;模板&#xff0c;提供数据动态刷新渲染、屏幕适应、数据滚动配置&#xff0c;内部图表自由替换、Mixins注入…
阅读更多...
JS Array数组常用方法（附上相应的用法及示例）

JS Array数组常用方法（附上相应的用法及示例）

会改变原数组的方法 1、array.push(需要在末尾添加的数据)【给数组末尾添加一个元素】 2、array.unshift(需要在首位添加的数据)【给数组首位添加一个元素】 3、array.pop()【从数组末尾删除元素,不需要传参】 4、array.shift()【从数组首位开始删除元素,不需要传参】 5、arra…
阅读更多...
【算法与数据结构】5 常见的时间复杂度，你知道吗？

【算法与数据结构】5 常见的时间复杂度，你知道吗？

欢迎来到爱书不爱输的程序猿的博客, 本博客致力于知识分享&#xff0c;与更多的人进行学习交流 本文收录于算法与数据结构体系专栏,本专栏对于0基础者极为友好,欢迎与我一起完成算法与数据结构的从0到1的跨越 时间复杂度与空间复杂度 一、前情回顾二、常见的时间复杂度1.常见的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023