【C++杂货铺】详解string

f9b4d418a2c44c5d892c11ad88c04306.png

目录

 🌈前言🌈

📁 为什么学习string

📁 认识string（了解）

📁 string的常用接口

 📂 构造函数

 📂 string类对象的容量操作

 📂 string类对象的访问以及遍历操作​编辑

 📂 string类对象的修改操作

📁 模拟实现string

📁 总结

 🌈前言🌈

        欢迎观看本期【C++杂货铺】，本期内容将全面string，包含了解string，如何操作string，最后会模拟实现string。

        因为计算机行业的不断发展，许多程序员不仅仅要掌握string这些容器的使用方法，有的公司会要求阅读底层源码，模拟实现这些容器，所以本期内容将会从零开始，带大家了解使用string。

        当然，本篇内容的参考文献主要来源于网站：<string> - C++ Reference (cplusplus.com)

        如果，你只想掌握string的具体使用方法，可以阅读下面这篇文章：

【C++杂货铺】详解string的接口-CSDN博客

b9fef61f29b6488b95f0417ce2f9f96a.gif

📁 为什么学习string

        在C语言中，字符串是以‘\0’结尾的一些字符的结合，为了操作方便，C标准库提供了一些str系列的库函数，但这些库函数与字符串是分开的，底层空间需要用户自己管理，可能造成越界访问等。

        在日常生活中，为了简单，方便，快捷，基本都会使用string类，很少会有人去使用C库中的字符串操作函数。

📁 认识string（了解）

        string是表示字符串的字符串类。该类的接口与常规容器的接口基本相同，在添加了一系列专门用来操作string的常规操作。

        string是basic_string模板类的一个别名，用char来实例化basic_string模板类。

        string不能操作多字节或者边长字符的序列。

        在使用string时，必须包括#include头文件以及using namespace std;

📁 string的常用接口

        string接口有上百种，这里我们只介绍常用的，以及需要了解的。

 📂 构造函数

94c2d4027e764186a34f52cd9ceb244e.png

//函数名称                                      功能说明
string()   重点                       构造空的string类对象，即空字符串
string(const string* s)  重点         用C_string来构造string类对象
string(size_t n,char c)               string类对象中把包含了n个字符c
string(const string& s) 重点          拷贝构造
string s1;                //构造空的string类对象s1

string s2("hello string");    //用C风格字符串构造string类对象s2
    
string s3(s2);            //拷贝构造s3

 📂 string类对象的容量操作

46b6cf8bc8304be089e07124345df30b.png

1. size()

        size函数求的是字符串中元素的个数，不包含‘\0’。

//打印 5
string s("hello");
cout<<s.size()<<endl;

        其中length 和 size作用都是一样的，都是求有效字符串的字符长度，不包含 ‘\0’。size和length方法底层实现原理完全相同。引入size的原因是为了和其他容器接口保持一致。基本使用size。

2. reserve()

        reverse的作用就是为字符串预留空间，应用场景就是已知数据元素有多少，可以减少扩容的操作，减少消耗。

        但reserve()相当于手动扩容，但要注意的是，扩容量不能小于现有的容量。

    string  s;
	size_t cnt = s.capacity();
	cout << cnt << endl;
	cout<<"change:" << endl;
	for (int i = 0;i < 100;i++)
	{
		s.push_back('a');
		if (cnt != s.capacity())
		{
			cout << s.capacity() << endl;
			cnt = s.capacity();
		}
	}

  8959243b79514a498db05f97e3a0144f.png

        以上是没有reserve的对象，第一次扩容两倍，之后是扩容1.5倍每次（vs是1.5倍扩容，Linux下按照2倍扩容）。

    string  s;
	s.reserve(100);
	size_t cnt = s.capacity();
	cout << cnt << endl;
	cout<<"change:" << endl;
	for (int i = 0;i < 100;i++)
	{
		s.push_back('a');
		if (cnt != s.capacity())
		{
			cnt = s.capacity();
			cout << cnt << endl;
		}
	}

76ae8d032fa844fc8e7d51fa4370109b.png

        上图可知reseve的结果并不一定是准确的扩容数，可能会增加一些。

3. resize()

fd5cfaebfdbb48129b71f15ac22dcbd7.png

        resiz的功能是将有效字符的个数改成n；如果n大于有效字符个数，即n>size，则会插入；如果空间不够，即n>capacity，则会扩容+插入。当然传参没有char c则没有插入。

a0472b95a7344ece9b8f5cb577716288.png

 📂 string类对象的访问以及遍历操作53cbfa3de4c54b5f838ae2c2534c36ad.png

1. operator[ ]

8d0d5d06b8894d5498dfc3b08b75de88.png

        string类对象支持下标访问，[ ]支持读写pos位置的数据；const修饰为只读，不能修改。

//非const的对象使用[]，可读可写
string s1("hello world");

for(int i =0;i<s1.size();i++)
{
    s1[i] = 'a';
}

for(int i=0;i<s1.size();i++)
{
    cout<<s1[i]<<' '<<endl;
}

//const对象，只读
const string s2("hello world");
for(int i =0;i<s2.size();i++)
{
    cout<<s2[i]<<' '<<endl;
}

2. 迭代器 begin + end

        迭代器iterator，容器中类似与指针的东西，通过迭代器可以访问容器中的数据，使用方法也类似于指针。迭代器可能是指针，也可能不是。

        begin指向容器中第一个数据的位置；end指向容器中最后一个有效字符的下一个位置，即‘\0’（ '\0'不算有效字符 ）。

c501dc89adbf4b9eb59e346302bd0a54.png

31f9eae604264f03bd9f0167f9924950.png

        3601242138554ae385012930325f9ab3.png

string  s("hello world");

for (string::iterator it = s.begin();it != s.end();it++)
{
	cout << *it << ' ';
}

//打印 h e l l o  w o r l d

3. 迭代器 rbegin + rend

        rbegin就是reverse_begin的缩写，rbegin和rend主要用于逆序遍历。反向迭代器则是reverse_iterator. b27ad7dab610411ca76d3861e89667ac.png

379a62fdea0847dfa55a431c511bbb89.png

a6f25de948744222b636008eb1dfc728.png

string s("hello world");
for (string::reverse_iterator it = s.rbegin();it != s.rend();it++)
{
	cout << *it << ' ';
}

4. 范围for

        范围for的底层就是迭代器，将s的迭代器赋值给e(auto类型是编译器自动推导的数据类型)。

string  s("hello world");
for (auto e : s)
{
	cout << e << ' ';
}
cout << endl;

 📂 string类对象的修改操作

810008c5395c420c816d859acfee812b.png

1. push_back()

        尾部插入一个字符

//打印 hello w
string s("hello ");

s.push_back('w');

cout<<s<<endl;

2. append()2c9ea7a4c9e9406e9d73ac892bfc5197.png

        尾部插入一个字符串。

string s1("hello ");
s.append("world");
//打印 hello  world

string s2("hello ");
s2.append(10, 'x');
//打印helloxxxxxxxxxx

string s3("hello ");
s3.append(s1.begin(),s1.end());
//打印hello hello world

3. operator+=

        尾部插入一个字符或者字符串。

5790d019892d4e2088de7605594ff040.png

string s1("hello ");
s1 += "world";

string s2("aaaaa");
s2 += ' ';

string s3("bbbbb");
s3 += s2;

4. insert()

        前面之前插入字符或者字符串。

c889e508d7984fbda77ca868f7f5195d.png

5. erase()

        删除从pos位置开始，len个字符，如果len没有传参赋初值，npos就代表着有多少删多少。

npos是string里面的一个静态成员变量
 
static const size_t npos = -1; size_t是无符号整数，所以-1代表整数最大值。

51639864a48a4f56a5a2a45f5ab24c7b.png

        从pos位置开始，删除len个字符。或者从first迭代器开始，到last迭代器结束的字符删除。

string s("a bcd");
s.erase(0,1);
cout << s << endl;
//打印 bcd

6. replace()fbc3d5f790df44f889c01f4227581627.png

        将字符替换。

string s1("a bcd");
s1.replace(1,1,"a");
cout << s1 << endl;
//打印aabc

string s2("a bcd");
s2.replace(1,1,1,'a');
cout << s2 << endl;
//打印aabc

 insert，earse，replace等函数尽量少用，因为涉及数据元素的移动，效率太低。

5cc14a3430b541348fc2972e5e0bd43b.png

7. c_str()

        因为C++是要兼容C语言的，在C语言中，表示字符串使用char* 来表示的，所以C语言库中许多操作使用的是char* 来操作的。而在C++中，我们大多数使用的是string，那么如何将string类型转为C语言字符串类型呢？

        c_str()的作用就是从string中返回C格式字符串。

string filename("test.txt");
/*
FILE* file = fopen(filename,"r");
filename是string类型，而fopen函数的第一个参数类型是C格式字符串。
*/
FILE* file = fopen(filename.c_str(),"r");

8. find()bb80bcdcbcf246c3894ded0015662303.png

        find()作用就是查找字符或者字符串，从pos位置开始。默认情况下，pos位置是从0开始。

        rfind()作用与find几乎相同，不过是从字符串尾开始查找。

9. sub_str()

a978d148b9ef41aeba186d74d2d8ae3f.png

        在str中从pos位置开始，截取len个字符，将其作为字符串返回。如果len没有给或者大于npos（-1）,含义则是从pos位置截取到字符串尾。

#include <iostream>
#include <string>

int main ()
{
  std::string str="We think in generalities, but we live in details.";
                                           // (quoting Alfred N. Whitehead)

  std::string str2 = str.substr (3,5);     // "think"

  std::size_t pos = str.find("live");      // position of "live" in str

  std::string str3 = str.substr (pos);     // get from "live" to the end

  std::cout << str2 << ' ' << str3 << '\n';

  return 0;
}

📁 模拟实现string

        下面会有大量的string接口的模拟实现，模拟实现是为了更好的从里层理解string，使用string。

📂 拓展知识 :  编码

028e6539116b40fa82cc8b81324f4d7b.png

        常见的编码有：ASCII编码，GBK编码，UTF编码。

        所谓的编码，就是文字在计算机中的存储和表示。我们通过编码将计算机0 1 表示成日常生活中的文字。

        但随着越来越多国家的加入，简单的ASCII编码已经不能满足需求。所以有了UTF编码，UTF编码有UTF-8,UTG-16（2B）,UTF-32（4B），它们主要的区别就是UTF-8是可变字节，utf-16和utf-32是不变字节。

        我们常用的string的底层就是使用utf-8的编码方式的char实例化的。

模拟实现string类，并完成测试

namespace bit

{

  class string

  {

    friend ostream& operator<<(ostream& _cout, const bit::string& s);

    friend istream& operator>>(istream& _cin, bit::string& s);

  public:

    typedef char* iterator;

  public:

    string(const char* str = "")；

    string(const string& s)；

    string& operator=(const string &s)；

    ~string()；



    //

    // iterator

    iterator begin()；

    iterator end()；



    /

    // modify

    void push_back(char c);

    string& operator+=(char c);

    void append(const char* str);

    string& operator+=(const char* str);

    void clear();

    void swap(string& s);

    const char* c_str()const;



    /

    // capacity

    size_t size()const

    size_t capacity()const

    bool empty()const

    void resize(size_t n, char c = '\0');

    void reserve(size_t n);



    /

    // access

    char& operator[](size_t index);

    const char& operator[](size_t index)const;



    /

    //relational operators

    bool operator<(const string& s);

    bool operator<=(const string& s);

    bool operator>(const string& s);

    bool operator>=(const string& s);

    bool operator==(const string& s);

    bool operator!=(const string& s);



    // 返回c在string中第一次出现的位置

    size_t find (char c, size_t pos = 0) const;

    // 返回子串s在string中第一次出现的位置

    size_t find (const char* s, size_t pos = 0) const;

    // 在pos位置上插入字符c/字符串str，并返回该字符的位置

    string& insert(size_t pos, char c);

    string& insert(size_t pos, const char* str);

     

    // 删除pos位置上的元素，并返回该元素的下一个位置

    string& erase(size_t pos, size_t len);

  private:

    char* _str;

    size_t _capacity;

    size_t _size;

  }

}；

📂 默认成员函数的模拟实现

//构造函数
		string(const char* str = "")
			:_size(strlen(str))
		{
			_str = new char[_size + 1];
			strcpy(_str, str);
			_capacity = _size;
		}

		//拷贝构造函数
		string(const string& s)
		{
			string temp(s._str);
			swap(temp);
		}

		//赋值重载
		string& operator=(string temp)
		{
			swap(temp);
			return *this;
		}

		//析构函数
		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

📂 iterator模拟实现

        iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

📂 insert 和 erase的模拟实现

//再字符串的pos位置插入字符
		string& insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				reserve(_capacity == 0? 4:2 * _capacity);
			}

			size_t end = _size + 1;

			while (end > pos)
			{
				_str[end] = _str[end - 1];
				end--;
			}
			_str[end] = ch;
			_size++;
			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);

			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}

			size_t end = _size + len;

			while (end > pos+len-1)
			{
				_str[end] = _str[end - len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;

			return *this;
		}

		//删除pos位置后len个元素
		string& erase(size_t pos=0, size_t len=npos)
		{
			assert(pos < _size);
			if (len >= _size - pos || len == npos)
			{
				_str[pos] = '\0';
				_size = pos;
				return *this;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
				return *this;
			}
		}

📂 modify模拟实现

//modify
		void swap(string& s)
		{
			std::swap(this->_str, s._str);
			std::swap(this->_size, s._size);
			std::swap(this->_capacity, s._capacity);
		}

		const char* c_str() const
		{
			return _str;
		}

		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}

		void push_back(char ch)
		{
			//扩容2倍
			/*if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';*/

			insert(_size, ch);
		}

		void append(const char* str)
		{
			//扩容
			/*size_t len = strlen(str);
			if(_size >= _capacity - len)
			{
				reserve(_size + len);
			}

			strcpy(_str + _size, str);
			_size += len;*/
			insert(_size, str);
		}

		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}

📂 capacity模拟实现

//capacity
		size_t size() const
		{
			return _size;
		}

		size_t capacity() const 
		{
			return _capacity;
		}

		bool empty() const
		{
			return _size == 0;
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* temp = new char[n + 1];
				strcpy(temp, _str);
				delete[] _str;
				_str = temp;
				_capacity = n;
			}
		}

		void resize(size_t n, const char ch = '\0')
		{
			if (n <= _size)
			{
				_str[n] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);

				for (size_t i = _size;i < n;i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

📂  relational operators的模拟实现

//relational operators
		bool operator<(const string& s)
		{
			return strcmp(this->c_str(), s.c_str()) < 0;
		}

		bool operator<=(const string& s)
		{
			return *this < s  || *this == s;
		}

		bool operator>(const string& s)
		{
			return !(*this <= s);
		}

		bool operator>=(const string& s)
		{
			return !(*this < s);
		}

		bool operator==(const string& s)
		{
			return strcmp(this->c_str(), s.c_str()) == 0;
		}

		bool operator!=(const string& s)
		{
			return !(*this == s);
		}

📂 find 的模拟实现

//返回字符c在字符串中出现的第一次位置
		size_t find(char ch, int pos = 0)
		{
			assert(pos < _size);
			for (size_t i = pos;i < _size;i++)
			{
				if (_str[i] == ch)
				{
					return i;
				}
			}
			return npos;
		}

		//返回子串s在字符串中出现的第一次位置
		size_t find(const char* s, size_t pos = 0)
		{
			assert(pos < _size);
			
			char* ps = strstr(_str + pos, s);
			if (ps != nullptr)
			{
				return ps - _str;
			}
			else
			{
				return npos;
			}
		}

📂 substr的模拟实现

string substr(size_t pos=0, size_t len=npos)
		{
			string temp;
			if (len == npos || _size - pos < len)
			{
				for (size_t i = pos;i < _size;i++)
				{
					temp += _str[i];
				}
			}
			else
			{
				for (size_t i = pos;i < pos + len;i++)
				{
					temp += _str[i];
				}
			}

			return temp;
		}

📁 总结

        以上，我们就对string进行了全面的讲解，介绍了string的常用接口，string的底层实现，以及string相关的拓展知识。

        如果你能看到这里，恭喜你，你已经对string有了全面的了解，可以说已经上手了string。剩下的就是不断调试模拟实现string了，当然模拟实现只是为了更好的理解string。

        如果感觉本期内容对你有帮助，欢迎点赞，收藏，关注。Thanks♪(･ω･)ﾉ

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

（MATLAB）应用实例13-时域信号的频谱分析

（MATLAB）应用实例13-时域信号的频谱分析

采用傅里叶变换来计算存在噪声的适于信号频谱。 假设数据采样频率为1000Hz&#xff0c;一个信号包含两个正弦波&#xff0c;频率50Hz、120Hz&#xff0c;振幅0.7、1&#xff0c;噪声为零平均值的随机噪声&#xff0c;采用FFT方法分析其频谱。 clearFs 1000; …
阅读更多...
分享axios+signalr简单封装示例

分享axios+signalr简单封装示例

Ajax Axios Axios 是一个基于 promise 网络请求库&#xff0c;作用于node.js 和浏览器中。 它是 isomorphic 的(即同一套代码可以运行在浏览器和node.js中)。在服务端它使用原生 node.js http 模块, 而在客户端 (浏览端) 则使用 XMLHttpRequests。 从浏览器创建 XMLHttpReque…
阅读更多...
kafka 可视化工具

kafka 可视化工具

kafka可视化工具 随着科技发展&#xff0c;中间件也百花齐放。平时我们用的redis&#xff0c;我就会通过redisInsight-v2 来查询数据&#xff0c;mysql就会使用goland-ide插件来查询&#xff0c;都挺方便。但是kafka可视化工具就找了半天&#xff0c;最后还是觉得redpandadata…
阅读更多...
一招教你优化TCP提高大文件传输效率

一招教你优化TCP提高大文件传输效率

在当今企业的数据传输实践中&#xff0c;传统的传输控制协议&#xff08;TCP&#xff09;在处理大型文件传输时&#xff0c;其固有的可靠性和复杂性有时会导致效率不足。为了提升大文件传输的效率&#xff0c;对TCP进行优化成为了一个关键任务。 TCP传输的可靠性是其核心优势&a…
阅读更多...
Kubernetes-2

Kubernetes-2

Kubernetes学习第二天 k8s-21、Kubernetes的核心组件2、pod2.1、什么是pod 3、3种启动pod的方式3.1、命令行启动pod3.1.1、执行下面命令&#xff0c;背后发生了什么&#xff1f; 3.2、启动一个pod背后发生了什么3.3、使用yml文件3.3.1、标准的pod3.3.2、使用部署控制器启动pod3…
阅读更多...
windows部署腾讯tmagic-editor01-Hello world

windows部署腾讯tmagic-editor01-Hello world

之前写过一篇使用yarn实现的https://blog.csdn.net/qq_36437991/article/details/133644558&#xff0c;后面的两个没有写&#xff0c;这次准备重新实现 环境 pnpm 8.15.1 node 18.19.0 创建vue项目 pnpm create vitecd hello-world pnpm install执行pnpm dev启动项目 安…
阅读更多...
[PTA] 分解质因子

[PTA] 分解质因子

输入一个正整数n&#xff08;1≤n≤1e15&#xff09;&#xff0c;编程将其分解成若干个质因子&#xff08;素数因子&#xff09;积的形式。 输入格式: 任意给定一个正整数n&#xff08;1≤n≤1e15&#xff09;。 输出格式: 将输入的正整数分解成若干个质因子积的形式&#…
阅读更多...
TypeScript 基础（一）

TypeScript 基础（一）

目录 一、概述 二、开发环境 三、数据类型 1.boolean 2.number 3.string 4.Array 5.type 6.tuple 7.enum 8.any 9.null / undefined 10.never 11.object 结束 一、概述 TypeScript 是一种由微软开发的开源编程语言。它是 JavaScript 的一个超集&#xff0c;这意…
阅读更多...
正则表达式-分组

正则表达式-分组

1、oracle-正则表达式&#xff1a;将09/29/2008 用正则表达式转换成2008-09-29 select regexp_replace(09/29/2008, ^([0-9]{2})/([0-9]{2})/([0-9]{4})$, \3-\1-\2) replace from dual; 解析&#xff1a;regexp_replace-替换&#xff0c; 第一个参数&#xff1a;需要进行处…
阅读更多...
5个实用的PyCharm插件

5个实用的PyCharm插件

大家好&#xff0c;本文向大家推荐五个顶级插件&#xff0c;帮助开发人员提升PyCharm工作流程&#xff0c;将生产力飞升到新高度。 1.CodiumAI 安装链接&#xff1a;https://plugins.jetbrains.com/plugin/21206-codiumate--code-test-and-review-with-confidence--by-codium…
阅读更多...
项目的搭建与配置

项目的搭建与配置

vue create calendar_pro 选择如下配置选项 安装 vue3 支持 vue add vue-next package.json 关闭 eslint 检测。 vue.config.js 配置跨域同源策略。 const { defineConfig } require(vue/cli-service) module.exports defineConfig({transpileDependencies: true,devServe…
阅读更多...
【uni-app】condition 启动模式配置，生产环境无效，仅开发期间生效

【uni-app】condition 启动模式配置，生产环境无效，仅开发期间生效

在小程序开发过程中&#xff0c;每次代码修改后&#xff0c;都会启动到首页&#xff0c;有时非常不方便&#xff0c;为了更高效的开发&#xff0c;有时需要模拟直接跳转到指定的页面&#xff0c; 操作方法如下&#xff1a; 在pages.joson里面配置下列代码&#xff1a; "…
阅读更多...
【自然语言处理六-最重要的模型-transformer-上】

【自然语言处理六-最重要的模型-transformer-上】

自然语言处理六-最重要的模型-transformer-上 什么是transformer模型transformer 模型在自然语言处理领域的应用transformer 架构encoderinput处理部分&#xff08;词嵌入和postional encoding&#xff09;attention部分addNorm Feedforward & add && NormFeedforw…
阅读更多...
24/03/07总结

24/03/07总结

esayx: 贪吃蛇: #include "iostream" #include "cmath" #include "conio.h" #include "easyx.h" #include "time.h" #define NODE_WIDTH 40 using namespace std; typedef struct {int x;int y; }node; enum direction /…
阅读更多...
Python笔记｜基础算数运算+数字类型（1）

Python笔记｜基础算数运算+数字类型（1）

重新整理记录一下python的基础知识 基础运算符 、-、*、/ &#xff1b;括号 ()用来分组。 >>>2 2 4 >>>50 - 5*6 20 >>>(50 - 5*6) / 4 5.0 >>>8 / 5 1.6向下取整除法&#xff1a;向下舍入到最接近的整数的数学除法。运算符是 //。比如1…
阅读更多...
力扣面试经典150 —— 6-10题

力扣面试经典150 —— 6-10题

力扣面试经典150题在 VScode 中安装 LeetCode 插件即可使用 VScode 刷题&#xff0c;安装 Debug LeetCode 插件可以免费 debug本文使用 python 语言解题&#xff0c;文中 “数组” 通常指 python 列表&#xff1b;文中 “指针” 通常指 python 列表索引 文章目录 6. [中等] 轮转…
阅读更多...
谷歌浏览器打包扩展插件，提示清单文件缺失或不可读取

谷歌浏览器打包扩展插件，提示清单文件缺失或不可读取

今天想把谷歌浏览器的扩展打包一下&#xff0c;放到我虚拟机的谷歌浏览器&#xff0c;但是一直打包不成功。 问题 打包扩展程序错误 提示‘清单文件缺失或不可读取’ 原因 路径没有选择正确&#xff01; 解决办法 1.首先找到google浏览器的安装路径。在谷歌浏览器地址栏输…
阅读更多...
穷人想赚钱该怎么选打工VS创业？2024年如何把握新机遇？

穷人想赚钱该怎么选打工VS创业？2024年如何把握新机遇？

在贫穷的困境中&#xff0c;打工与创业似乎成为了两条截然不同的道路&#xff0c;摆在每一个渴望改变命运的人面前。然而&#xff0c;这并非简单的选择题&#xff0c;而是一场关于勇气、智慧与机遇的较量。打工&#xff0c;对于许多人来说&#xff0c;是稳定且相对安全的收入来…
阅读更多...
XSS靶场-DOM型初级关卡

XSS靶场-DOM型初级关卡

一、环境 XSS靶场 二、闯关 1、第一关 先看源码 使用DOM型&#xff0c;获取h2标签&#xff0c;使用innerHTML将内容插入到h2中 我们直接插入<script>标签试一下 明显插入到h2标签中了&#xff0c;为什么不显示呢&#xff1f;看一下官方文档 尽管插入进去了&#xff0…
阅读更多...
Java后端八股笔记

Java后端八股笔记

Java后端八股笔记 Redis八股 上两种都有可能导致脏数据 所以使用两次删除缓存的技术&#xff0c;延时是因为数据库有主从问题需要更新&#xff0c;无法达到完全的强一致性&#xff0c;只能达到控制一致性。 一般放入缓存中的数据都是读多写少的数据 业务逻辑代码&#x1f44…
阅读更多...
最新文章

Copyright @ 2022~2023