拷贝

从容器里面拷文件到宿主机 语法： docker cp 容器名：要拷贝的文件在容器里面的路径 要拷贝到宿主机的相应路径 例子：容器名为ubuntu,要从容器里面拷贝的文件路为： /usr/local/tomcat/webapps/test/js/test.js , 现在要将 test.js 从容器里面拷到宿主机的 /opt 路径下面 在宿主机上面执行命令 docker cp ubuntu:/usr/local/tomcat/webapps/test/js/test.js /opt 从宿主机拷文件到容器里面 语法： docker cp 要拷贝的文件路径 容器名:要拷贝到容器里面对应的路径 例子：容器名为 ubuntu ,现在要将宿主机 /opt/test.js 文件拷贝到容器里面的 /usr/local/tomcat/webapps/test/js 路径下面 在宿主机上面执行命令 docker cp /opt/test.js ubuntu:/usr/local/tomcat/webapps/test/js 来源： https://www.cnblogs.com/haima/p/12244575.html

在了解JS的浅拷贝与深拷贝之前，我们需要先知道什么是值传递与引用传递。 在JS中，基本类型值的拷贝是按值传递的，而引用类型值的拷贝则是按引用传递的。通过值传递的变量间不会有任何牵连，互相独立；但是引用传递拷贝的变量间则会相互影响，修改其中任何一方所引用的对象的值都会在另一方中体现，之所以会有这样的表现和JS的内存机制有关。 JS的内存也分为堆和栈，但是注意这里的堆栈和数据结构的堆栈是不同的概念。 栈：由系统自动分配，自动回收，效率高，但容量小 堆：由程序员手动分配内存，并且手动销毁（高级语言如JS中有垃圾自动回收机制），效率不如栈，但容量大 JS定义的基本类型值会被存放在栈内存中，JS可以直接访问栈内存，所以访问存放基本类型值的变量可以直接访问到基本类型值。而引用类型因为其大小不固定，系统会为引用类型分配堆内存存放，而只将指向该堆内存空间的指针（引用）存放在栈中，JS不予许直接访问存放引用类型值的堆内存，只能通过访问引用间接的访问引用类型值。这样一来，我们访问引用类型值时，实质上只是在访问它的引用，然后再按照这个引用地址去堆中找到它的实际内容。 因此进行拷贝的时候，对于基本类型值变量，系统会为新变量单独开辟一个新的栈内存空间，并将源变量保存的基本类型值拷贝一份保存到里面。而对于引用类型值，新变量拷贝得到的只是引用对象的引用而已，这么一来

1.数据分为基本数据类型（String, Number, Boolean, Null, Undefined, Symbol）和引用数据类型。深拷贝和浅拷贝只针对像Object和Array这样的引用数据类型。 2.浅拷贝只复制指向某个对象的指针，不复制对象本身，两个对象共享同一块内存。深拷贝会创建一个相同的对象，与原对象不共享内存，修改新对象不影响原对象。 3.浅拷贝的实现： 1）Object.assign() (当object只有一层时是深拷贝)； 2）Array.prototype.concat() 3) Array.prototype.slice() 4.深拷贝的实现： 1) JSON.parse(JSON.stringify()) 2) 采用递归方式； 3）函数库lodash 来源： https://www.cnblogs.com/JM25/p/10242035.html

extern const int ci =42; const int * p2 = &ci; extern const int *const p3= p2;　　 int *p= p3; 　　　　　//错，p没有底层const。 书上的解释是： p3是顶层const 也是底层const，拷贝p3可以不在乎其顶层const， 但是p3指向的是一个常量，因此不能用P3初始化p, 而p 只能指向非常量。 理解他说的意思是因为一个指向常量一个指向非常量。 但自己仔细想想， 底层const也可以指向一个非常量， 那是不是当p3一开始就用非常量初始化时，此时p3和p 都指向非常量了， int *p= p3; 是不是就正确了呢？ 如果按书上的解释，给人的误解是当他俩都指向常量或非常量时就没问题了， 这是误解，产生误解是因为他没说清楚。 　　我是这么理解： 指向常量的指针既可以指向常量 也可以指向非常量， 而一般普通指针只能指向非常量。 1、假设 不同时具有底层const也可以拷贝： 当有底层const的指针给 没有底层const的指针赋值时， 因为 前者 可以指向常量或非常量， 后者只能指向非常量， 所以前者无关紧要。感觉没啥不对的。 现在反过来： 当没有底层const的指针 给 有底层const的指针 赋值时， 因为前者 只能指向非常量， 后者可以指向常量或非常量，问题来了： 当后者指向非常量

修改标准输入输出流拷贝图片(了解) package com.heima.test; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintStream; public class Test02 { /** * @param args * @throws IOException */ public static void main(String[] args) throws IOException { System.setIn(new FileInputStream("双元.jpg")); //改变标准输入流 System.setOut(new PrintStream("copy.jpg")); //改变标准输出流 InputStream is = System.in; PrintStream ps = System.out; byte[] arr = new byte[1024]; int len; while((len = is.read(arr)) != -1) { ps.write(arr, 0, len); } is.close(); ps.close(); } } 来源： CSDN 作者： 左绍骏 链接：

deque：双端队列 底层是一个双向链表。 常用的有队列的尾部入队、首部出队。 普通队列：queue queue 模板类的定义在<queue>头文件中。 与stack 模板类很相似，queue 模板类也需要两个模板参数，一个是元素类型，一个容器类 型，元素类型是必要的，容器类型是可选的，默认为deque 类型。 定义queue 对象的示例代码如下： queue<int> q1; queue<double> q2; queue 的基本操作有： 入队，如例：q.push(x); 将x 接到队列的末端。 出队，如例：q.pop(); 弹出队列的第一个元素，注意，并不会返回被弹出元素的值。 访问队首元素，如例：q.front()，即最早被压入队列的元素。 访问队尾元素，如例：q.back()，即最后被压入队列的元素。 判断队列空，如例：q.empty()，当队列空时，返回true。 访问队列中的元素个数，如例：q.size() 摘自： http://www.cnblogs.com/liubilan/p/9461141.html deque - 双向队列 1.构造 无参构造： deque<T> a;　　//<>内自定义数据类型； 带参构造： deque(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。 deque(n,elem); /

文章目录 形参与实参 形参初始化 传引用参数 const 形参和实参 指针或引用形参与 const 尽量使用常量引用 数组形参 和 const 传递多维数组 形参与实参 形参 是在定义函数名和函数体的时候使用的参数，目的是用来接收调函数时传递的参数。 实参 是在调用时传递给函数的参数，即传递给被调用函数的值。实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。 形参初始化 形参初始化的机理与变量初始化一样。 形参的类型决定了形参和实参交互的方式。 如果形参是 引用 类型，它将绑定到对应的实参上；否则，将实参的值拷贝后赋给形参。 形参若是引用类型，也就是 引用形参 是 它对应的实参的别名。 否则，在实参的值拷贝给形参后，形参 和 实参分别是两个 独立 的对象。 而对于指针形参，与拷贝赋值同理，但是可以通过形参指针改变对象的值。(对象不是 const 或者指针不是 const int*) 传引用参数 即将 实参的对象绑定个形参，和 普通引用没有区别。 但是 传递引用参数 可以 避免拷贝 。 拷贝大的类类型或者容器对象是比较低效的，或者有些根本不支持拷贝。 使用 引用参数 返回额外的信息。 可知，一个函数只能返回一个值，但是利用 引用形参， 可以达到 等效的 返回多个值的结果。 如：求一个字符串中，a 和 b

Java数组的基本拷贝 Java中数组的拷贝主要使用了System.arraycopy(src, srcPos, dest, destPos, length)类。其中，src(Object对象)是操作数组源地址，dest(Object对象)是拷贝数组的目标地址，srcPos(int型)是开始拷贝的位置，destPos(int型)是拷贝到的位置，length(int型)是数组中拷贝数据的长度。 从一个数组拷贝到另一个数组 public static void testArrayCopy(){ String[] a1 = {"a","b","c","d"}; String[] a2 = new String[10]; System.arraycopy(a1, 1, a2, 6, 3); for (int i = 0; i < a2.length; i++) { System.out.println(i+"--"+a2[i]); } } 删除数组指定位置元素（本质是数组的自身拷贝） public static void testArrayCopy2(){ String[] a1 = {"a","b","c","d","e"}; //String[] a2 = new String[5]; System.arraycopy(a1, 3, a1, 2, 2); a1[a1.length-1]

< ! DOCTYPE html > < html > < head > < meta charset = "UTF-8" > < title > < / title > < / head > < body > < script type = "text/javascript" > function checkType ( data ) { return Object . prototype . toString . call ( data ) . slice ( 8 , - 1 ) ; //[object Object] } function deepCopy ( data ) { //拷贝的都是对象数据类型 let dataType = checkType ( data ) ; let result ; if ( dataType == 'Array' ) { result = [ ] ; } else if ( dataType == 'Object' ) { result = { } ; } else { result = data ; return result ; } for ( let key in data ) { if ( checkType ( data [ key ] ) == 'Array' || 'Object' ) { result [ key ] =

找工作这么多天了，贴一下常见基础题吧，谁找工作了还可以复习下。答案有的是缺少很多，想看全百度之谷歌之... 1.进程与线程的区别： 　　很长重点写了：一个程序必须有一个进程，一个进程要有一个线程。 　　进程在运行时有独立的内存单元，而线程则是共享内存单元，所以一个线程死掉这个进程就会死掉，但是一个进程死掉程序无所谓。所以多进程程序比多线程要　　　　 　稳定。　　 2.c++函数传递参数的方式： 　　1.直接传递、引用、指针。 　　他们的优缺点： 　　1.按值传递，在传递的时候实参被复制了一份，然后在函数体内使用。如果修改函数体内的拷贝，而实参是没有改变的。 　　2.引用是别名，所以效率别指针快，也比指针安全。(优先使用引用而不使用指针) 　　3.按值传递和引用传递在传参过程中，都执行强类型检查，而指针传递的类型比较弱，如果参数被声明为void*基本上没有类型检查，只要是指针编译器就认为是合法的，所以这会造成BUG。 　　4.指针可以干引用的活，而且还可以传递空指针，特别函数特别应用。但是指针用起来本身就很麻烦，如非需要还是不用。 *3.什么是深拷贝和浅拷贝 　　　深拷贝：拷贝了对象的资源，在新对象中又建立了一个新的字段把资源放进去，如果修改其一，另一个不会改变。 　　　浅拷贝：没有拷贝对象资源，它们共享资源，如果改变其一另一个也会随之改变。 4.面向对象的三个基本特征 　　1）封装