数组操作

数组API

instanceof

A instanceof B //判断A是否是B造出来的例：

function Car(make, model, year) {
  this.make = make;
  this.model = model;
  this.year = year;
}
const auto = new Car('Honda', 'Accord', 1998);

console.log(auto instanceof Car);//true

console.log(auto instanceof Object);//true

typeof

typeof A //判断A的数据类型null也会判定为object 数组对象和null的结果都会判定为object 例：

console.log(typeof '');//string
console.log(typeof []);//object
console.log(typeof {});//object
console.log(typeof 1);//number
console.log(typeof null);//object
console.log(typeof undefined);//undefined
console.log(typeof true);//boolean
console.log(typeof function(){});//function
console.log(typeof /\d/);//object

Array.isArray()

Array.isArray(A) //判断A是否是数组，返回结果为布尔值例： Array.isArray([1, 2, 3]); // true

toString

A.toString() //返回A的字符串形式例：

//数组
var array = ["CodePlayer", true, 12, -5];
console.log(array.toString()); 
// CodePlayer,true,12,-5

valueOf()

A.valueOf() //返回A的原始值例：

// Array：返回数组对象本身
var array = ["CodePlayer", true, 12, -5];
console.log( array.valueOf() === array ); // true

join(参数)

数组.join(参数) //数组元素可以按照参数连接成一个字符串例：

const elements = ['Fire', 'Air', 'Water'];

console.log(elements.join());
// expected output: "Fire,Air,Water"

console.log(elements.join(''));
// expected output: "FireAirWater"

console.log(elements.join('-'));
// expected output: "Fire-Air-Water"

push()和pop()

数组.push() //在数组末尾添加元素,返回数组长度例：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi") //Banana,Orange,Apple,Mango,Kiwi

数组.pop() //删除数组末尾的一项，并返回删除的元素

例:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop(); //Mango

unshift()和shift()

数组.unshift(参数1,参数2...) //添加到数组开头的一个或者多个元素，返回数组的长度例：

const array1 = [1, 2, 3];

console.log(array1.unshift(4, 5));
// expected output: 5

console.log(array1);
// expected output: Array [4, 5, 1, 2, 3]

数组.shift() //删除数组最前面的一项，返回被删除的元素例：

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var arr = fruits.shift() //被删除的第一项Banana

reverse()

数组.reverse() //反转数组里的每一项

var fruits = ["Banana", "Orange", "Apple", "Mango"];
var arr = fruits.reverse();
//arr结果为Mango,Apple,Orange,Banana

sort()

数组.sort(指定排序的函数)
如果没有指定排序的函数，则数组元素会转化为字符串按Unicode位点进行排序，如果指明了排序函数，则会按照排序函数的返回值排序，即a和b是两个将要被比较的函数

如果 compareFunction(a, b) 小于 0 ，那么 a 会被排列到 b 之前
如果 compareFunction(a, b) 大于 0 ， b 会被排列到 a 之前例：

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
console.log(numbers);
//[1, 2, 3, 4, 5]

concat()

数组.concat(数组1，数组2) //合并两个或者多个数组，返回新数组例：

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3);
// expected output: Array ["a", "b", "c", "d", "e", "f"]

slice()

数组.slice()(开始索引，结束索引) //从开始索引到结束索引浅拷贝原数组（包括开始索引值，不包括结束索引值），返回一个新的数组对象例：

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

splice()

数组.splice(开始索引，删除个数，添加/替换内容1，添加/替换内容2...) //删除、替换、添加元素，并以数组的形式返回被修改的内容，改变原数组例：

//从第 2 位开始删除 0 个元素，插入“drum”
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");

// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除

//从第 2 位开始删除 1 个元素，插入“trumpet”
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
var removed = myFish.splice(2, 1, "trumpet");

// 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]
// 被删除的元素: ["drum"]

indexOf()/lastIndexOf()

数组.indexOf(查询元素) //从数组第一位开始查元素索引数组.lastIndexOf(查询元素) //从数组最后一项往前查索引

例：

var nums=[1,7,5,7,8,1,6,9];
var pos = nums.indexOf(7);   
consol.log(pos);　　　　　　//输出 1，查询不到返回结果为-1
var email= "marry@163.com";
consol.log(email.indexOf("@"));　　//输出 5，查询不到返回结果为-1

every()

数组.every(function() {指定函数}) //测试数组内的所有元素是否通过指定函数，放回布尔值例：

// 检测所有数组元素的大小
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
//箭头函数写法
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true

filter()

数组.filter(function() {指定函数} //返回一个新数组，包含通过指定函数，返回为ture的所有元素例：

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

forEach()

对数组每个元素执行一次给定函数,没有返回值例：

const array1 = ['a', 'b', 'c'];

array1.forEach(element => console.log(element));

// expected output: "a"
// expected output: "b"
// expected output: "c"

map()

对数组每一项执行运行一次函数，return返回的值组成一个行的数组，没有返回值则为undefined 例：

var arr = [8, 10, 13, 10, 8, 1, 5];
 function double(num){
     return num * 2;
 }
 alert(arr.map(double));

some()

测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值例：

const array = [1, 2, 3, 4, 5];

// checks whether an element is even
const even = (element) => element % 2 === 0;

console.log(array.some(even));
// expected output: true

清空数组

arr.length = 0; //伪数组无法清空
arr.splice(0);  //伪数组没有这个方法
arr = []; //可以操作伪数组

对象

对象操作方法

字面量声明

var test2 = {x:123,y:345};
console.log(test2);//{x:123,y:345};
console.log(test2.x);//123

构造函数声明

var test1 = new Object({x:123,y:345});
console.log(test1);//{x:123,y:345}
console.log(test1.x);//123

对象中使用this

var obj = {
    name : '张三',
    age : 20,
    sayHello : function () {
        console.log(this.name)
        console.log(this)
    }
}
obj.sayHello();

删除对象属性

delete 语法的使用方式

var obj = {
  name: 'twoheart',
  gender: 'male'
}
delete obj.gender
delete obj['gender']

for/in遍历对象

语法： for (变量 in 对象){在此执行代码}

var obj = {a: 'ss', b: 'bb', c: 'cc'};
for (var i in obj){
  console.log(i+':'+obj[i]);
  //a:ss  b:bb  c:cc
}

Object.keys(obj)

返回一个所有元素为字符串的数组，其元素来自给定对象可直接枚举的属性例：

var obj = { k: '0', j: '9', c: '8' };
console.log(Object.keys(obj)); // ['k', 'j', 'c']

Object.create()

创建一个新对象，使用现有的对象来提供新创建对象的__proto___ 例：

// new 和 object.create创建方式对比
// new Object() 方式创建
var a = {  rep : 'apple' }
var b = new Object(a)
console.log(b) // {rep: "apple"}
console.log(b.__proto__) // {}
console.log(b.rep) // {rep: "apple"}

// Object.create() 方式创建
var a = { rep: 'apple' }
var b = Object.create(a)
console.log(b)  // {}
console.log(b.__proto__) // {rep: "apple"}
console.log(b.rep) // {rep: "apple"}

object.values

遍历可以枚举的属性值，不包含原型链的可枚举属性值例：

let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};

Object.values(arr)      // ["a", "b", "c"]
Object.values(obj)          // ["bar",42]
Object.values(ArrayLike)    // ["a", "b", "c"]

object.assign()

用于将所有可枚举的属性值从一个或多个源对象分配到目标对象，返回目标对象语法：Object.assign(目标对象, ...源对象) 例：

const target = { a: 1, b: 2 };
const source = { b: 4, c: 5 };
const returnedTarget = Object.assign(target, source);
console.log(target);
// expected output: Object { a: 1, b: 4, c: 5 }
console.log(returnedTarget);
// expected output: Object { a: 1, b: 4, c: 5 }

函数

函数操作

函数调用

function f(x,y) {  //定义函数
    return x * y;  //返回值
}
console.log(f(f(5,6), f(7,8)));  //返回1680。重复调用函数

//作为对象调用
var myObject = {
    firstName:"Bill",
    lastName: "Gates",
    fullName: function () {
        return this.firstName + " " + this.lastName;
    }
}
myObject.fullName(); 

//通过构造函数调用
// 这是函数构造器：
function myFunction(arg1, arg2) {
    this.firstName = arg1;
    this.lastName  = arg2;
}

// 创建了一个新对象：
var x = new myFunction("Bill", "Gates");
x.firstName;

匿名函数

//匿名函数自执行方法
//使用小括号
(function(x,y){
    return x+y;
}(3,4));

//使用运算符
-function(x,y){
    return x+y;
}(3,4);

+function(x,y){
    return x+y;
}(3,4);

--function(x,y){
    return x+y;
}(3,4);

++function(x,y){
    return x+y;
}(3,4); 

//使用波浪号
~function(x, y) {
    return x+y;
}(3, 4); 

//放中括号内
[function(){
    console.log(this) // 浏览器得控制台输出window
}(this)] 

//自执行函数在后面加()

字符串

字符串操作

charAt()

arr.charAt() //返回字符串中x位置的字符，下标从 0 开始。

//charAt(x)
var myString = 'jQuery FTW!!!';
console.log(myString.charAt(7));
//output: F

concat(str1,str2..)

//方法用于连接两个或多个字符串，原字符串不变，返回拼接后的新的字符串

var message="Sam"
var final=message.concat(" is a"," hopeless romantic.")
//alerts "Sam is a hopeless romantic."
alert(final)

indexOf(substr, [start]) 和 lastIndexOf(substr, [start])

indexOf方法搜索并(如果找到)返回字符串中搜索到的字符或子字符串的索引。如果没有找到，则返回-1。Start是一个可选参数，指定字符串中开始搜索的位置，默认值为0

//indexOf(char/substring)
var sentence="Hi, my name is Sam!"
if (sentence.indexOf("Sam")!=-1)
alert("Sam is in there!")

lastIndexOf() 方法返回指定文本在字符串中最后一次出现的索引, 如果未找到，则返回-1。 “Start”是一个可选参数，指定字符串中开始搜索的位置, 默认值为string.length-1。

//lastIndexOf(substr, [start])
var myString = 'javascript rox';
console.log(myString.lastIndexOf('r'));
//output: 11

slice(start, [end])

slice() 方法可提取字符串的某个部分，返回一个新的字符串。包括字符串从 start 开始（包括 start）到 end 结束（不包括 end）为止的所有字符。

//slice(start, end)
var text="excellent"
text.slice(0,4) //returns "exce"
text.slice(2,4) //returns "ce"

split(delimiter, [limit])

使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。

const str = 'The quick brown fox jumps over the lazy dog.';

const words = str.split(' ');
console.log(words[3]);
// expected output: "fox"

const chars = str.split('');
console.log(chars[8]);
// expected output: "k"

const strCopy = str.split();
console.log(strCopy);
// expected output: Array ["The quick brown fox jumps over the lazy dog."]

toLowerCase() 和 toUpperCase()

toLowerCase() 方法用于把字符串转换为小写。

var myString = 'JAVASCRIPT ROX';
myString = myString.toLowerCase();
console.log(myString)
//output: javascript rox

toUpperCase() 方法用于把字符串转换为大写。

var myString = 'javascript rox';
myString = myString.toUpperCase();
console.log(myString)
//output: JAVASCRIPT ROX

includes()

includes() 方法用于检查字符串是否包含指定的字符串或字符。

var mystring = "Hello, welcome to edureka";
var n = mystring.includes("edureka");
//output: True

endsWith()

endsWith()函数检查字符串是否以指定的字符串或字符结束。

var mystr = "List of javascript functions";
var n = mystr.endsWith("functions");
//output: True

repeat()

repeat() 构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本。

var string = "Welcome to Edureka";
string.repeat(2);
//output: Welcome to Edureka Welcome to Edureka

valueOf()

valueOf() 方法返回一个String对象的原始值（primitive value），该值等同于String.prototype.toString()。

//valueOf()
var mystr = "Hello World!";
var res = mystr.valueOf();
//output: Hello World!

replace(regexp/substr, replacetext)

replace() 方法用于在字符串中用一些字符替换另一些字符，或替换一个与正则表达式匹配的子串。

//replace(substr, replacetext)
var myString = '999 JavaScript Coders';
console.log(myString.replace(/JavaScript/i, "jQuery"));
//output: 999 jQuery Coders
 
//replace(regexp, replacetext)
var myString = '999 JavaScript Coders';
console.log(myString.replace(new RegExp( "999", "gi" ), "The"));
//output: The JavaScript Coders

substr(start, [length])

substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符。返回一个新的字符串，包含从 start（包括 start 所指的字符）处开始的 length 个字符。如果没有指定 length，那么返回的字符串包含从 start 到该字符串的结尾的字符。

//substr(from, to)
var text="excellent"
text.substr(0,4) //returns "exce"
text.substr(2,4) //returns "cell"

substring(from, [to])

substring() 方法用于提取字符串中介于两个指定下标之间的字符，方返回的子串包括 start 处的字符，但不包括 stop 处的字符，to 可选，如果省略该参数，那么返回的子串会一直到字符串的结尾。

//substring(from, [to])
var myString = 'javascript rox';
myString = myString.substring(0,10);
console.log(myString)
//output: javascript

数组，对象，函数，字符串基本操作（代码的搬运工）

数组操作

数组API

instanceof

typeof

Array.isArray()

toString

valueOf()

join(参数)

push()和pop()

unshift()和shift()

reverse()

sort()

concat()

slice()

splice()

indexOf()/lastIndexOf()

every()

filter()

forEach()

map()

some()

清空数组

对象

对象操作方法

字面量声明

构造函数声明

对象中使用this

删除对象属性

for/in遍历对象

Object.keys(obj)

Object.create()

object.values

object.assign()

函数

函数操作

函数调用

匿名函数

字符串

字符串操作

charAt()

concat(str1,str2..)

indexOf(substr, [start]) 和 lastIndexOf(substr, [start])

slice(start, [end])

split(delimiter, [limit])

toLowerCase() 和 toUpperCase()

includes()

endsWith()

repeat()

valueOf()

replace(regexp/substr, replacetext)

substr(start, [length])

substring(from, [to])