更多关于STL的文章：STL专栏
 

 
文章目录
 
介绍
array成员函数
成员函数用法示例
array用法及初始化
array元素的获取
Tuple接口
array元素的修改
array迭代器
array元素的比较
   
  
 


 为了防止学习的过程中出现学后忘的情况，我将接触到的知识进行整理，作该笔记，由于本人水平有限，如果出现错误，还望赐正。
 
介绍
 
数组是固定大小的序列容器:它们包含按严格的线性顺序排列的特定数量的元素。一个array——也就是容器类array<>的一份实体——模塑出一个static array。它包覆一个寻常的static C-style array 并提供一个STL容器接口。
 
通用格式：array<类型名, 元素个数> 数组名;
 
注意，因为长度固定，这里的元素个数不能是变量。
 
在内部，数组除了它所包含的元素之外不保留任何数据(甚至不保留它的大小，这是一个模板参数，在编译时固定)。就存储大小而言，它与使用该语言的括号语法([])声明的普通数组一样有效。这个类只是向它添加了一层成员和全局函数，它比寻常的数组安全，而且效率并没有因此变差，因此数组可以用作标准容器。
 
与其他标准容器不同，数组具有固定的大小，并且不通过分配器管理其元素的分配:它们是封装固定大小的元素数组的聚合类型。因此，它们不能动态地展开或收缩。
 
大小为零的数组是有效的，但是不应该取消对它们的引用(成员 front, back, 和 data)。
 
数组容器的另一个独特的特性是它们可以被视为元组对象:array头文件重载get函数来访问数组的元素，就好像它是一个元组一样，还有专门的tuple_size和tuple_element类型。
 
array并不支持（也就是不允许你指定）分配器（allocator）
 
array成员函数
 
函数
功能
begin()，end() ,cbegin()，cend()
提供正向迭代器支持
rbegin()，rend()，crbegin()，crend()
提供反向迭代器支持
size()
返回数组大小
max_size()
返回数组最大大小（由于array为固定序列，该函数返回值与size()相同）
empty()
判断数组是否为空 (几乎没用)
at()，operator[]
获取数组元素
front()
返回数组第一个元素的引用
back()
返回数组最后一个元素的引用
data()
返回指向数组对象包含的数据的指针
fill()
用值填充数组
swap()
交换两个数组元素
get(array)
返回某一个数组元素的引用
array会把元素复制到其内部的 static C-style array 中。这些元素总是拥有一个明确次序。因此 array 是一种有序集合。array 允许随机访问，也就是你可以在常量时间内直接访问任何元素， 前提是你得知道元素位置。 array 的迭代器属于随机访问迭代器，所以你可以对它运用任何STL算法。
 
成员函数用法示例
 
array用法及初始化
 
 
 
template < class T, size_t N > class array;
 //T为所包含元素的类型，别名为成员类型value_type 。N为数组的大小，以元素数表示。
 
 
在使用array前，首先要添加array这个头文件，即#include <array>。
 
注意：array<>是唯一一个无任何东西被指定为初值时，会被预初始化的容器。这意味着对于基础类型，初值可能不明确，而不是0，例如：下面定义一个有妖妖灵个int元素的数组arr：
 
     std::array<int,110> arr;
 
上面定义的arr并未进行初始化。未初始化将会分配随机值，如图：
 

 所以尽量不要定义未初始化的数组，否则访问数组元素，而该元素恰好未初始化时，可能出现意想不到的错误。
 
array数组对象初始化与标准数组初始化一模一样，如：
 
    std::array<int,110> arr  { };//将数组所有元素初始化为0
 
    std::array<int,110> arr{1,2,3,4};//将数组前4个元素分别初始化为1，2，3，4，其余全部为0
 

 另外由于没有提供针对初值而写的构造函数或assignment 操作符，因此“ 在array声明期间完成初始化”是使用初值列的唯一途径。基于这个原因，你无法使用小括号指明初值（此不同于其他容器类型）
 
std::array<int,5> a({1,2,3,4,5})  //错误
 
fill()
 fiil() 函数可以用指定值给数组中所有元素赋值。
 
fill()函数原型如下：
 
 
 
void fill(const value_type & u); //value_type为数组元素类型；
 
 
【例】
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,110> arr{1,2,4,5,6,7,8,9};
    arr.fill(3); //用3对数组所有元素赋值
    for(auto i:arr)
        cout<<i<<" ";
    cout<<endl;
    
    return 0;
}
 
输出结果为：
 
 
 
3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3
 
 
array元素的获取
 
特别注意！array，string，vector等容器的第一个元素下标为0！！！
 
array元素的获取可以使用下标[]（与标准数组用法相同），以及STL容器特有的at()。
 [] 与 at() 的区别在于，[]不会进行检查数字是否越界，而 at() 会进行检查（时间开销很少），如果越界则抛出 std::out_of_rang 异常。
 因此，除非确定访问没有越界，否则应该尽量使用更安全的 at() 。
 
 
 
reference at(size_type n);
 const_reference at(size_type __n) const;
 
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,11> arr{1,2,3,4,5,6,7,8,9};
    arr.at(9) = arr.at(3) + arr.at(5);
    arr[10] = arr[1] + arr[8];
    cout<<arr.at(9)<<endl;
    cout<<arr[10]<<endl;

    //arr[11] = 6;越界访问，程序异常，但Qt Creator并未报错
    arr.at(11) = 6; //异常
    return 0;
}
 
程序运行结果为：
 
 
 
10
 11
 
 terminate called after throwing an instance of ‘std::out_of_range’
 what(): array::at: __n (which is 11) >= _Nm (which is 11)
 
 
front() 和 back()
 front() 返回数组第一个元素的引用。
 back() 返回数组最后一个元素的引用。
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,11> arr{1,2,3,4,5,6,7,8,9};
    arr.front() = 666;
    arr.back() = 666;
    for(auto i:arr)
        cout<<i<<" ";
    cout<<endl;
    return 0;
}
 
程序运行结果为：
 
 
 
666 2 3 4 5 6 7 8 9 0 666
 
 
（注：这两个函数极少使用）
 
data()
 返回指向数组对象中第一个元素的指针。
 该函数无参数。
 
#include<iostream>
#include<array>
#include<cstring>
using namespace std;

int main()
{   
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};

    cout<< *arr.data()<<endl;
    cout<< *(arr.data()+6)<<endl;//获取元素

    const char* cstr = "Test string";
    std::array<char,12> charray;
    std::memcpy (charray.data(),cstr,charray.size());

    cout << charray.data() << endl;


    return 0;
}

 
程序运行结果为：
 
 
 
1
 7
 Test string
 
 
size() 和 max_size()
 由于array在创建的时候必须明确指定大小，而且array为固定容器，因此max_size()与size()的返回值相同。
 通常使用 size() 函数。
 返回值类型为size_t 即无符号整数
 
使用size()可以有效避免使用for遍历数组时，发生越界的情况。同时它也使得你在写程序的时候，不必去花心思记忆数组的大小。
 
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};

    for(unsigned int i(0);i< arr.size();++i)
        cout<< arr[i] <<" ";
    cout<<endl;
//程序运行结果为1 2 3 4 5 6 7 8 9 10
 
empty()
 该函数在array中为鸡肋函数。这是因为array在定义的时候已经指明了大小，不可能为空。除非你写出如此代码std::array<int,0> var;但这毫无意义。
 然而，对于其他元素可变或者元素可删除的容器来说，它们使用 empty() 时的机制是一样的，因此为它们提供了一个一致性的操作。
 
Tuple接口
 
array 提供 tuple 接口。因此可以使用表达式 tuple_size<>::value 取得元素个数，用 tuple_element<>::type 取得某特定元素的类型，用 get<>() 取得某特定元素。
 
get()
 get() 函数为非成员函数重载 。
 该函数返回array中指定元素的引用
 
函数原型如下：
 
 
 
template <size_t I, class T, size_t N> T& get (array<T,N>& arr) noexcept;
 template <size_t I, class T, size_t N> T&& get (array<T,N>&& arr) noexcept;
 template <size_t I, class T, size_t N> const T& get (const array<T,N>& arr) noexcept;
 //参数l为：元素在数组中的位置，第一个元素的位置为0 。
 //参数 T为：数组中包含的元素类型（通常从arr隐式获得）。
 //参数 N为：数组的大小，以元素数为单位（通常从arr隐式获得）。
 
 
由于参数T，N可以从arr中隐式获得。因此在使用时一般不显式指定二者。
 【例】
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};

    //int a = std::get<6,int,10>(arr); 一般不这么写

    int a = std::get<6>(arr);
    cout<<a<<endl;

    std::get<5>(arr) = 666;
    for(auto i:arr)
        cout<<i<<" ";
    cout<<endl;

    return 0;
}
 
程序运行结果为：
 
 
 
7
 1 2 3 4 5 666 7 8 9 10
 
 
另外参数l必须是明确的数字，不能使用变量。如：
 
    int n = 3;
    std::get<n>(arr);//错误写法
 
tuple_size<>::value 和 tuple_element<>::type
 在array中用途不大，示例如下：
 
#include <iostream>
#include <array>
#include <string>
using namespace std;

int main()
{   

    std::array<string,5> arr = {"one","two","three","four","five"};;
    //返回元素个数
    cout<< std::tuple_size<decltype(arr)>::value <<endl;
    
    //获取第3个元素类型
    std::tuple_element<1,decltype(arr)>::type type = get<3>(arr);
    cout<< type <<endl;

    return 0;
}
 
程序运行结果为：
 
 
 
5
 four
 
 
array元素的修改
 
array元素的修改与标准数组用法几乎相同。
 如：
 
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    arr[3] = 6;
    arr[2] = arr[0] + arr[1];
 
同样也可以使用指针、引用对其进行修改。
 
不同与标准数组的是：只要两个array类型的数组的数据类型和大小相同，就可以用 = 赋值。
 如：
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,3> arr_1 {1,2,3};
    std::array<int,3> arr_2 {4,5,6};

    arr_1 = arr_2; //用arr_2的元素覆盖arr_1的元素

    for(auto i:arr_1)
        cout<<i<<" ";
    cout<<endl;

    for(auto i:arr_2)
        cout<<i<<" ";
    cout<<endl;

    return 0;
}
 
输出结果为：
 
 
 
4 5 6
 4 5 6
 
 
swap()
 交换两个array的值。注：这两个数组的大小，数据类型必须相同！
 无返回值，无参数。
 
与标准库中的其他容器不同，交换两个数组容器是一种线性操作，涉及单独交换范围内的所有元素，这通常效率较低
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};
    std::array<int,10> var{0,0,0,0,0,0,0,0,0,1};

    arr.swap(var);

    for(auto i:arr)
        cout<<i<<" ";
    cout<<endl;

    for(auto i:var)
        cout<<i<<" ";
    cout<<endl;

    return 0;
}

 
运行结果为：
 
 
 
0 0 0 0 0 0 0 0 0 1
 1 2 3 4 5 6 7 8 9 10
 
 
array迭代器
 
名称
功能
begin( )
返回指向数组第一个元素的迭代器。
end()
返回指向数组最后一个元素后紧跟的的理论元素的迭代器。
cbegin()
返回指向数组第一个元素的const类型迭代器。
cend()
返回指向数组最后一个元素后紧跟的的理论元素的const类型迭代器。
rbegin()
返回一个反向迭代器，该迭代器指向数组的最后一个元素（即它的反向开始）。
rend()
返回一个反向迭代器，该迭代器指向数组第一个元素之前的理论元素（该元素被视为反向元素）。
crbegin()
返回一个const类型反向迭代器，该迭代器指向数组的最后一个元素（即它的反向开始）。
crend()
返回一个const类型反向迭代器，该迭代器指向数组第一个元素之前的理论元素（该元素被视为反向元素）。
下面为数组迭代器的简单用法：
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,10> arr{1,2,3,4,5,6,7,8,9,10};

    array<int,10>::iterator it_beg = arr.begin();  //或者 auto it_beg = arr.begin();
    array<int,10>::reverse_iterator rit_beg = arr.rbegin(); //或者 auto rit_brg = arr.rbegin();

    for(;it_beg!=arr.end();it_beg++)
        cout<< *it_beg * 2<<" "; //二倍输出数组所有元素
    cout<<endl;

    for(;rit_beg != arr.rend();rit_beg++)
        cout<< *rit_beg << " "; //倒序输出数组元素
    cout<<endl;

    return 0;
}
 
输出结果为：
 
 
 
2 4 6 8 10 12 14 16 18 20
 10 9 8 7 6 5 4 3 2 1
 
 
在使用时最好用全局的 begin() 和 end() 函数从容器中获取迭代器，因为它们是通用的。
 如上述array<int,10>::iterator it_beg = arr.begin(); 可以写为array<int,10>::iterator it_beg = std::begin(arr);
 
array元素的比较
 
可以用任何比较运算符比较两个数组容器，只要它们有相同的大小，保存的是相同类型的元素，而且这种类型的元素还要支持比较运算符。示例如下：
 
#include<iostream>
#include<array>
using namespace std;

int main()
{   
    std::array<int,3> arr_1 {1,2,3};
    std::array<int,3> arr_2 {1,2,3};
    std::array<int,3> arr_3 {1,3,2};

    if (arr_1 == arr_2)
        cout << "arr_1 = arr_2" << endl;
    if (arr_1 != arr_3)
        cout << "arr_1 != arr_3"<< endl;
    if (arr_1 < arr_3)
        cout << "arr_1 < arr_3"<< endl;

    return 0;
}
 
输出结果为：
 
 
 
arr_1 = arr_2
 arr_1 != arr_3
 arr_1 < arr_3
 
 
容器被逐元素地比较。对 ==,如果两个数组对应的元素都相等，会返回 true。对于 !=，两个数组中只要有一个元素不相等，就会返回 true。这也是字典中单词排序的根本方式，两个单词中相关联字母的不同决定了单词的顺序。

欢迎关注WX公众号：【程序员管小亮】
 
np.mat()函数用于将输入解释为矩阵。
 
np.matrix()函数用于从类数组对象或数据字符串返回矩阵。
 
np.array()函数用于创建一个数组。
 
1、np.mat()
 
np.mat(data, dtype=None)
 
不同于np.matrix，如果输入本身就已经是matrix或ndarray ，则np.asmatrix不会复制输入，而是仅仅创建了一个新的引用。
 
相当于np.matrix(data, copy=False)。
 
参数：
 
 
data：array_like。输入数据。
 
 
dtype：数据类型。输出矩阵的数据类型。
 
 
返回：
 
mat：矩阵。数据被解释为矩阵。
 
例子1：
 
>>> x = np.array([[1, 2], [3, 4]])
>>> m = np.asmatrix(x)
>>> x[0,0] = 5
>>> m
matrix([[5, 2],
        [3, 4]])
 
2、np.matrix()
 
class numpy.matrix(data, dtype=None, copy=True)
 
 
 
注意
 不再建议使用此类，即使对于线性代数也是如此。而是使用常规数组。该课程将来可能会被删除。
 
 
矩阵是一种专用的二维阵列，通过操作保留其二维特性。
 
它有一些特殊的运算符，如* （矩阵乘法）和 **（矩阵幂）。
 
参数：
 
 
data ： array_like或string。如果data是字符串，则将其解释为以逗号或空格分隔列的矩阵，以及分隔行的分号。
 
 
dtype ： 数据类型。输出矩阵的数据类型。
 
 
copy ： 布尔。如果data已经是ndarray，则此标志确定是复制数据（默认值）还是构造视图。
 
 
例子2：
 
>>> a = np.matrix('1 2; 3 4')
>>> a
matrix([[1, 2],
        [3, 4]])

>>> np.matrix([[1, 2], [3, 4]])
matrix([[1, 2],
        [3, 4]])
 
3、np.array()
 
numpy.array(object, 
			dtype=None, 
			copy=True, 
			order='K', 
			subok=False, 
			ndmin=0)
 
参数：
 
 
object ： array_like
 数组，公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。
 
 
dtype ： 数据类型，可选
 数组所需的数据类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型。此参数只能用于“upcast”数组。对于向下转换，请使用.astype（t）方法。
 
 
copy ： bool，可选
 如果为true（默认值），则复制对象。否则，只有当__array__返回副本，obj是嵌套序列，或者需要副本来满足任何其他要求（dtype，顺序等）时，才会进行复制。
 
 
order ： {‘K’，‘A’，‘C’，‘F’}，可选
 指定阵列的内存布局。如果object不是数组，则新创建的数组将按C顺序排列（行主要），除非指定了’F’，在这种情况下，它将采用Fortran顺序（专业列）。如果object是一个数组，则以下成立。
 
 
order
no copy
copy=True
‘K’
unchanged
F & C order preserved, otherwise most similar order
‘A’
unchanged
F order if input is F and not C, otherwise C order
‘C’
C order
C order
‘F’
F order
F order
当copy=False出于其他原因而复制时，结果copy=True与对A的一些例外情况相同。默认顺序为“K”。
 
 
subok ： bool，可选。如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。
 
 
ndmin ： int，可选。指定结果数组应具有的最小维数。为满足此要求，将根据需要预先设置形状。
 
 
返回：
 
out ： ndarray。满足指定要求的数组对象。
 
例子3：
 
>>>
>>> np.array([1, 2, 3])
array([1, 2, 3])
 
上溯造型：
 
>>>
>>> np.array([1, 2, 3.0])
array([ 1.,  2.,  3.])
 
不止一个方面：
 
>>>
>>> np.array([[1, 2], [3, 4]])
array([[1, 2],
       [3, 4]])
 
最小尺寸2：
 
>>>
>>> np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])
 
提供的类型：
 
>>>
>>> np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j,  2.+0.j,  3.+0.j])
 
由多个元素组成的数据类型：
 
>>>
>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])
```py
从子类创建数组：
```py
>>>
>>> np.array(np.mat('1 2; 3 4'))
array([[1, 2],
       [3, 4]])
>>>
>>> np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
        [3, 4]])
 
python课程推荐。
 

JS array es6方法
 
定义数组
 
const array = [1, 2, 3];
 或者
 const array = new Array();
 array[0] = ‘1’;
 建议尽量使用第一种形式定义数组，采用new的形式在大量的数组定义时，会比较耗时。
 new关键字的使用，除了在需要实例化一个对象，或罕见的需要延时加载数据的情况外，你基本上不需要使用new关键字。在Javascript里分配大量的new变量地址是一项很慢的操作，为了效率起见，你应该始终使用对象符号。
 
在另外一个搜索结果中，有提到这样的一个说法：“很简单，Array()是一个对象，[]是一个数据原型。使用new Array()系统每次都会新生成一个对象（浏览器每生成一个对象都会耗费资源去构造他的属性和方法），他的子集是[]；个人推荐使用[]，效率高。浏览器对于CPU很吃紧，所以很多时候要有技巧。比如数字转换成字符只要a=a+’’;就可以了，比用String效率高了很多。
 检测数组
 
Array.isArray([]); // true
 Array.isArray(undefined); // false;
 
或者
 array instanceof Array; // true 检测对象的原型链是否指向构造函数的prototype对象
 或者
 array.constructor === Array; // true
 
终极大招：
 if (!Array.isArray) {
 Array.isArray = function(arg) {
 return Object.prototype.toString.call(arg) === ‘[object Array]’;
 };
 }
 
注意：typeof []; // “object” 不可以用此方法检查！！！
 
常用方法
 1. array.concat(array1, array2,…arrayN);
 合并多个数组，返回合并后的新数组，原数组没有变化。
 
const array = [1,2].concat([‘a’, ‘b’], [‘name’]);
 // [1, 2, “a”, “b”, “name”]
 
2. array.every(callback[, thisArg]);
 检测数组中的每一个元素是否都通过了callback测试，全部通过返回true，否则返回false。
 
// callback定义如下： element:当前元素值；index：当前元素下标； array:当前数组
 function callback(element, index, array) {
 // callback函数必须返回true或者false告知every是否通过测试
 return true || false;
 }
 
3. array.filter(callback[, thisArg]);
 返回一个新数组，包含通过callback函数测试的所有元素。
 
// callback定义如下，三个参数： element:当前元素值；index：当前元素下标； array:当前数组
 function callback(element, index, array) {
 // callback函数必须返回true或者false，返回true保留该元素，false则不保留。
 return true || false;
 }
 const filtered = [1, 2, 3].filter(element => element > 1);
 // filtered: [2, 3];
 
4. array.find(callback[, thisArg]);
 返回通过callback函数测试的第一个元素，否则返回undefined，callback函数定义同上。
 
const finded = [1, 2, 3].find(element => element > 1);
 // finded: 2
 
如果你需要找到一个元素的位置或者一个元素是否存在于数组中，使用Array.prototype.indexOf() 或 Array.prototype.includes()。
 5. array.findIndex(callback[, thisArg]);
 返回通过callback函数测试的第一个元素的索引，否则返回-1，callback函数定义同上。
 
const findIndex = [1, 2, 3].findIndex(element => element > 1);
 // findIndex: 1
 
6. array.includes(searchElement, fromIndex);
 includes() 方法用来判断一个数组是否包含一个指定的值，返回 true或 false。searchElement：要查找的元素；fromIndex：开始查找的索引位置。
 
[1, 2, 3].includes(2, 2);
 // false
 
7. array.indexOf(searchElement[, fromIndex = 0]);
 返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。searchElement：要查找的元素；fromIndex：开始查找的索引位置。
 
[2, 9, 7, 8, 9].indexOf(9);
 // 1
 
8. array.join(separator=’,’);
 将数组中的元素通过separator连接成字符串，并返回该字符串，separator默认为","。
 
[1, 2, 3].join(’;’);
 // “1;2;3”
 
9. array.map(callback[, thisArg]);
 返回一个新数组，新数组中的每个元素都是调用callback函数后返回的结果。注意：如果没有return值，则新数组会插入一个undefined值。
 array.map由于不具有过滤的功能，因此array调用map函数时，如果array中的数据并不是每一个都会return，则必须先filter，然后再map，即map调用时必须是对数组中的每一个元素都有效。
 
const maped = [{name: ‘aa’, age: 18}, {name: ‘bb’, age: 20}].map(item => item.name + ‘c’);
 // maped: [‘aac’, ‘bbc’];
 
10. array.pop() 与 array.shift();
 pop为从数组中删除最后一个元素，并返回最后一个元素的值，原数组的最后一个元素被删除。数组为空时返回undefined。
 
[1, 2, 3].pop();
 // 3
 
shift删除数组的第一个元素，并返回第一个元素，原数组的第一个元素被删除。数组为空返回undefined。
 
const shifted = [‘one’, ‘two’, ‘three’].shift();
 // shifted: ‘one’
 
11. array.push(element1, element2, …elementN) 与 array.unshift(element1, element2, …elementN);
 push是将一个或多个元素添加到数组的末尾，并返回新数组的长度; unshift将一个或多个元素添加到数组的开头，并返回新数组的长度。唯一的区别就是插入的位置不同。
 
const arr = [1, 2, 3];
 const length = arr.push(4, 5);
 // arr: [1, 2, 3, 4, 5]; length: 5
 
push和unshift方法具有通用性，通过call()或者apply()方法调用可以完成合并两个数组的操作。
 
const vegetables = [‘parsnip’, ‘potato’];
 const moreVegs = [‘celery’, ‘beetroot’];
 
// 将第二个数组融合进第一个数组
 // 相当于 vegetables.push(‘celery’, ‘beetroot’);
 Array.prototype.push.apply(vegetables, moreVegs);
 或者
 [].push.apply(vegetables, moreVegs);
 // vegetables: [‘parsnip’, ‘potato’, ‘celery’, ‘beetroot’]
 
12. array.reduce(callback[, initialValue]);
 对数组中的每个元素（从左到右）执行callback函数累加，将其减少为单个值。
 
const total = [0, 1, 2, 3].reduce((sum, value) => {
 return sum + value;
 }, 0);
 // total is 6
 
const flattened = [[0, 1], [2, 3], [4, 5]].reduce((a, b) => {
 return a.concat(b);
 }, []);
 // flattened is [0, 1, 2, 3, 4, 5]
 
// initialValue累加器初始值， callback函数定义：
 function callback(accumulator, currentValue, currentIndex, array) {
 }
 accumulator代表累加器的值，初始化时，如果initialValue有值，则accumulator初始化的值为initialValue，整个循环从第一个元素开始；initialValue无值，则accumulator初始化的
 值为数组第一个元素的值，currentValue为数组第二个元素的值，整个循环从第二个元素开始。initialValue的数据类型可以是任意类型，不需要跟原数组内的元素值类型一致。
 
const newArray = [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].reduce((arr, element) => {
 if (element.age >= 2) {
 arr.push(element.name);
 }
 return arr; // 必须有return，因为return的返回值会被赋给新的累加器，否则累加器的值会为undefined。
 }, []);
 
// newArray is [“bb”, “cc”];
 
上面代码的同等写法：
 const newArray = [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].filter(element => element.age >= 2).map(item => item.name);
 // newArray is [“bb”, “cc”];
 
对于reduce的特殊用法，其实类似于省略了一个变量初始化步骤，然后通过每次的callback的返回修改该变量，最后返回最终变量值的过程，类似于一个变量声明 + 一个forEach执行过程。
 const newArray = [];
 [{ name: ‘aa’, age: 1 }, { name: ‘bb’, age: 2 }, { name: ‘cc’, age: 3 }].forEach(item => {
 if (item.age >=2) {
 newArray.push(item.name);
 }
 });
 
13. array.reverse();
 将数组中元素的位置颠倒。
 
[‘one’, ‘two’, ‘three’].reverse();
 // [‘three’, ‘two’, ‘one’]，原数组被翻转
 
14. array.slice(begin, end)
 返回一个新数组，包含原数组从begin 到 end(不包含end)索引位置的所有元素。
 
const newArray = [‘zero’, ‘one’, ‘two’, ‘three’].slice(1, 3);
 // newArray: [‘one’, ‘two’];
 
15. array.some(callback[, thisArg]);
 判断数组中是否包含可以通过callback测试的元素，与every不同的是，这里只要某一个元素通过测试，即返回true。callback定义同上。
 
[2, 5, 8, 1, 4].some(item => item > 6);
 // true
 
16. array.sort([compareFunction]);
 对数组中的元素进行排序，compareFunction不存在时，元素按照转换为的字符串的诸个字符的Unicode位点进行排序，慎用！请使用时一定要加compareFunction函数，而且该排序是不稳定的。
 
[1, 8, 5].sort((a, b) => {
 return a-b; // 从小到大排序
 });
 // [1, 5, 8]
 
17. array.splice(start[, deleteCount, item1, item2, …]);
 通过删除现有元素和/或添加新元素来更改一个数组的内容。start:指定修改的开始位置；deleteCount：从 start位置开始要删除的元素个数；item…：要添加进数组的元素,从start 位置开始。
 返回值是由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。
 如果 deleteCount 大于start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
 
const myFish = [‘angel’, ‘clown’, ‘mandarin’, ‘sturgeon’];
 
const deleted = myFish.splice(2, 0, ‘drum’); // 在索引为2的位置插入’drum’
 // myFish 变为 [“angel”, “clown”, “drum”, “mandarin”, “sturgeon”]，deleted为[]
 
小结
 
push、 shift、 pop、 unshift、 reverse、 sort、 splice方法会对原来的数组进行修改，其他的数组操作方法只有返回值不同，对原数组都没有影响，即原数组不变。
 
小结
 
在看vue代码的时候，发现vue教程里面Array.apply(null, {length: 20})的用法，apply一直以为第二个参数只能是[]或者Arguments这样的类数组，了解了下发现{length: 20}也是类数组。 带有length属性的obj在apply函数里都被认定为类数组。可以理解为这里的{length: 20}会被默认为是一个数组了。下图的slice操作是只能在数组对象执行的操作，所以这里是一个数组。
 
 
看了下代码，apply生成的数组里面被初始化为了undefined，就是生成了长度为5的数组，而且数组的每个元素都被初始化为了undefined。
 Array(5)和new Array(5)调用效果是一致的。官网解释为：当把构造函数作为函数调用，不使用 new 运算符时，它的行为与使用 new 运算符调用它时的行为完全一样。 它们也生成了长度为5的数组，但是是个空数组，数组中的每个元素都没有初始化。
 
为什么要这么写？
 map函数并不会遍历数组中没有初始化或者被delete的元素（有相同限制还有forEach, reduce方法）。
 Array.apply(null, { length: 5 }) 是用来初始化一个长度为5，每项的初始值都是undefined的数组。
 
render (createElement) {
  return createElement('div',
  // 这里apply第一个对象为null, 当调用的函数不需要this对象时，可以传null，在es5之前浏览器会将null代表的this指向window。es5之后，浏览器不会再将this指向window。这里传null是因为Array构造函数会重新创建this，不需要传入this对象。
    Array.apply(null, { length: 20 }).map(function () {
     // 这里如果用Array(2)的形式，map的回调函数不会被执行
      return createElement('p', 'hi')
    })
  )
}

记录一下numpy.array()的详细用法，以及与np.asarray()和np.ndarray()的区别。
 
目录
 
1. Numpy.array()详解
 
1.1 函数形式
 
1.2 参数详解
 
1.3 具体用法
 
2. Asarray和Array辨析
 
2.1 object对象是普通迭代序列时
 
2.2 object对象是ndarray对象时
 
3.Numpy.ndarray()
 

1. Numpy.array()详解
 
该函数的作用一言蔽之就是用来产生数组。
 
1.1 函数形式
 
numpy.array(object, 
    dtype=None, 
    copy=True, 
    order='K', 
    subok=False, 
    ndmin=0)
 
1.2 参数详解
 
object：必选参数，类型为array_like，可以有四种类型：数组，公开数组接口的任何对象，__array__方法返回数组的对象，或任何（嵌套）序列。np.array()的作用就是按照一定要求将object转换为数组。
 
dtype：可选参数，用来表示数组元素的类型。如果没有给出，那么类型将被确定为保持序列中的对象所需的最小类型。注： This argument can only be used to ‘upcast’ the array. For downcasting, use the .astype(t) method.
 
copy：可选参数，类型为bool值。如果为true（默认值），则复制对象。否则的话只有在以下三种情况下才会返回副本：（1）.if __array__ returns a copy；（2）. if obj is a nested sequence；（3）. if a copy is needed to satisfy any of the other requirements (dtype, order, etc.)
 
order：{‘K’, ‘A’, ‘C’, ‘F’}，optional 。指定阵列的内存布局。该参数我至今还没有遇到过具体用法，这句话的意思就是我不会，故在此省略。
 
subok：可选参数，类型为bool值。如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）。或者说，True：使用object的内部数据类型，False：使用object数组的数据类型。
 
ndmin：可选参数，类型为int型。指定结果数组应具有的最小维数。
 
返回对象
 
out：输出ndarray，满足指定要求的数组对象。
 
1.3 具体用法
 
简单示例
 
import numpy as np

arr01 = np.array([1,2,3])
print(arr01) #[1 2 3]
print(type(arr01))  #<class 'numpy.ndarray'>
print(arr01.dtype)  #int32

#Upcasting
arr02 = np.array([1.,2.,3.])
print(arr02) #[1. 2. 3.]
print(arr02.dtype)  #float64

#More than one dimension:
arr03 = np.array([[1,2],[3,4]])
print(arr03)
"""
[[1 2]
 [3 4]]
"""

 
 dtype参数使用示例
 
import numpy as np

#指定数组元素类型为复数类型
DYX= np.array([1,2,3],dtype = complex)
print(DYX) #[1.+0.j 2.+0.j 3.+0.j]
print(DYX.dtype)  #complex128

#由多个元素组成的数据类型：
HXH = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i8')])
print(HXH)  #[(1, 2) (3, 4)]
#下面的输出有点神奇，我也只能记住规律了。
print(HXH["a"]) #[1 3]
print(HXH["b"])  #[2 4]
print(HXH.dtype)  #[('a', '<i4'), ('b', '<i8')]
print(HXH["a"].dtype) #int32
print(HXH["b"].dtype) #int64

TSL = np.array([(1,2,3),(4,5,6)],dtype=[("a","i"),("b","i"),("c","i")])
print(TSL["a"]) #[1 4]
print(TSL["a"].dtype)  #int32
 
上述代码中，numpy的数据类型，可以参看： http://www.runoob.com/numpy/numpy-dtype.html
 
subok参数使用示例
 
import numpy as np

DYX = np.array(np.mat('1 2; 3 4'))
#没有显示的写出subok的值，但是默认为False
print(DYX)
#数组类型
print(type(DYX))  #<class 'numpy.ndarray'>
"""
[[1 2]
 [3 4]]
"""

HXH = np.array(np.mat('1 2; 3 4'), subok=True)
print(HXH)
#矩阵类型
print(type(HXH))  #<class 'numpy.matrixlib.defmatrix.matrix'>
"""
[[1 2]
 [3 4]]
"""
 
前文对subok的描述是这样的：“如果为True，则子类将被传递，否则返回的数组将被强制为基类数组（默认）”。
 
在上文的代码中“np.mat('1 2; 3 4')”，就是子类，是矩阵类型。DYX = np.array(np.mat('1 2; 3 4'))中subok为False，返回的数组类型被强制为基类数组，所以DYX的类型是<class 'numpy.ndarray'>，是数组；HXH = np.array(np.mat('1 2; 3 4'), subok=True)中subok为True，子类被传递，所以HXH的类型是矩阵<class 'numpy.matrixlib.defmatrix.matrix'>。
 
这就是区别所在。
 
ndmin参数使用示例
 
import numpy as np

DYX = np.array([1,2,3],ndmin=0)
print(DYX,DYX.shape) #[1 2 3] (3,)

HXH = np.array([1,2,3],ndmin=1)
print(HXH,HXH.shape) #[1 2 3] (3,)

TSL = np.array([1,2,3],ndmin=2)
print(TSL,TSL.shape) #[[1 2 3]] (1, 3)
 
其他两个参数copy和order，我至今还没有遇到过，所以暂且不表。谁有介绍这两个参数用法的博客吗？
 
2. Asarray和Array辨析
 
Numpy.asaray的用法不再赘述，主要介绍一下二者的区别。
 
2.1 object对象是普通迭代序列时
 
import numpy as np

data = [1,1,1]
print(type(data)) #<class 'list'> 列表类型
arr_ar = np.array(data)
arr_as = np.asarray(data)

#输出上没有区别
print(arr_ar) #[1 1 1]
print(arr_as) #[1 1 1]

data[1]=2
#改变原序列对arr_ar和arr_as没影响
print(arr_ar) #[1 1 1]
print(arr_as) #[1 1 1]

#此时data是[1, 2, 1]
#改变arr_ar和arr_as对原序列没有影响
arr_ar[1]=3
print(data) #[1, 2, 1]
arr_as[1]=3
print(data)  #[1, 2, 1]
 
可见在参数对象是普通迭代序列时，asarray和array没有区别（在我的理解范围内）。
 
2.2 object对象是ndarray对象时
 
import numpy as np

data = np.ones((3,))
#print(type(data)) #<class 'numpy.ndarray'> 数组类型
arr_ar = np.array(data)
arr_as = np.asarray(data)

print(arr_ar) #[1. 1. 1.]
print(arr_as) #[1. 1. 1.]

"""
这边区别就出来了。修改原始序列后，
np.array()产生的数组不变，
但是np.asarray()产生的数组发生了变化
"""
data[1]=2
print(arr_ar) #[1. 1. 1.]
print(arr_as) #[1. 2. 1.]  !!!


"""
这边也有区别，修改array产生的数组，不影响原始序列
修改asarray产生的数组，会影响原始序列
"""
#此时data=[1. 2. 1.]
arr_ar[2]=3
print(data)  #[1. 2. 1.]
arr_as[2]=3
print(data)  #[1. 2. 3.]
 
 
 
我们总结一下：相同点：array和asarray都可以将数组转化为ndarray对象。区别：当参数为一般数组时，两个函数结果相同；当参数本身就是ndarray类型时，array会新建一个ndarray对象，作为参数的副本，但是asarray不会新建，而是与参数共享同一个内存。重点就是这个共享内存。
 
3.Numpy.ndarray()
 
这是最近在一个项目里看到的用法，搜索了一下用法，只在stackoverflow看到了一个问题：“What is the difference between ndarray and array in numpy?”。
 
地址如下：https://stackoverflow.com/questions/15879315/what-is-the-difference-between-ndarray-and-array-in-numpy
 
numpy.array只是一个创建ndarray的便利函数；它本身不是一个类。他讲到也可以使用numpy.ndarray创建一个数组，但这不是推荐的方法。 numpy.ndarray() 是一个类，而numpy.array() 是一个创建ndarray的方法/函数。
 
在numpy docs中，如果你想从ndarray类创建一个数组，你可以用引用的2种方式来做：
 
（1）.using array(), zeros() or empty() methods: Arrays should be constructed using array, zeros or empty (refer to the See Also section below). The parameters given here refer to a low-level method (ndarray(…)) for instantiating an array.【1-使用array()， zeros()或empty()方法：数组应该使用array, zeros()或empty()构造。这里给出的参数引用用于实例化数组的低级方法(ndarray(…))。】
 
（2）.from ndarray class directly: There are two modes of creating an array using new: If buffer is None, then only shape, dtype, and order are used. If buffer is an object exposing the buffer interface, then all keywords are interpreted.【2-来自ndarray类：使用new创建数组有两种模式：如果buffer是None，则只使用shape，dtype和order。 如果buffer是公开buffer接口的对象，则解释所有关键字。】
 
所以说老老实实用numpy.array()吧。
 
 
 
本篇完结，行笔匆忙，如有错误，还望指出。