JS 对象
- 对象由若干个键值对组成
对象的获取对象
- company.name
- company['name']
新增对象属性
- company.addr = '杭州市'
- company['business']='前端课程'
for(var key in compay) {
console.log(key)
console.log(company[key])
}
详细介绍
键名
- 键名为数字的时候，会被强制转化为字符串
- 键名不符合标识名的时候，必须加上引号，否则会报错
属性
表达式还是语句？
＞ ｛ foo: 123 ｝
- 这是一个表达式
- 这是一个语句
如果要解释为表达式的话，必须要在大括号前加上圆括号
检查变量是否声明
- 所有全局变量都是window的变量
查看所有属性
- Object.keys(o)//
delete删除属性
- delete o.p
JSON格式
什么是JSON格式
（JavaScript Object Noation）是一种用于数据交换的文本格式，目的是取代繁琐笨重的XML格式
{
"name": "jirengu",
"age": 3
}
{
<people>
<name>jirengu</name>
<age>3</age>
</people>
}
- 属性名必须使用双引号
- 不能使用十六进制
- 不能使用undefined
- 不能使用函数和日期
JSON.stringify()
Json.stringyfy
Json.parse
深拷贝的另一种写法
var obj = {
name: 'hunger',
age: 3,
friends: ['aa', 'bb', 'cc']
}
var obj2 = JSON.parse(JSON.stringify(obj))
obj.age = 4
console.log(obj2.age)
JavaScript对象和JSON的关系
JavaScript对象的字面写法只是长的很像JSON格式数据，二者属于不同的范畴
JS数组操作
声明一个数组
- var arr = [3,4,5]
数组的清空
- arr.length = 0
arr.push('jirengu')
- 在数组最后添加一个元素，返回数组的长度
arr.pop()
- 删除数组的最后一个元素
arr.unshift('ruoyu')
- 在数组的前面添加一个元素，返回数组的长度
arr.splice(2,2)
- 在arr[2]开始替换掉2个数字
arr.splice(2,0,1,2,3)
- 在arr[2]的前面添加1，2，3
arr.join('')
- 列初所有的数组
arr.reverse()
- 将所有的数组进行反转
数组的属性
- 数组的底层就是一个对象
concat
- 数组的拼接
- 返回的数组是不变的
sort
- a.sort 基于快速排序的算法进行排序
- 除了排序数字，还可以排序字符串
- 当作字符串作为排序，7，8，9在1011前面
var arr=[10,11,7,8,9]
a.sort(function(v1,v2)){
return v1-v2
}
\\ 当v1比v2大的时候，会调用替换方法，当v1比v2小的时候，则不会调用sort方法
a.sort(function(v1,v2)){
return 1
}
\\所有的位置都会进行交换
ES5数组拓展
Array.isArray(obj)
.indexOf(element)/.lastIndexOf(element)
- 查找是否有这个数组，并返回这个索引的位置
.forEach(element, index, array)
- element 当前元素
- index 当前元素索引值
- 整个数组
var a = new Array(1,2,3,4,5,6);
a.forEach(function(e,i,array){
array[i]= e + 1;
});
console.log(a); //[2, 3, 4, 5, 6, 7]
.every(function(element, index, array)) / .some(function(element, index, array))
[3,4,-1,0,5].every(function(val){
return val>0?true:false
})
//false
[3,4,-1,0,5].some(function(val){
return val>0?true:false
})
//true
var arr2 = [1,2,3,4,5,6].map(function(val)){
return val*val
}
arr2 [1, 4, ,9, 16, 25, 36]
.filter(function(element))
- 过滤好元素
例子
var a = [1, 2, 3, 4, 5, 6]
console.log(a.filter(function(e){
return e % 2 == 0;
})) // [2, 4, 6]
console.log(a) //[1, 2, 3, 4, 5, 6]
.reduce(function(v1, v2), value) / .reduceRight(function(v1, v2), value)
var arr = [3,4,5]
arr.reduce(function(v1,v2){
return v1 + v2
})
//12
手写一个数组的reduce方法
js数组的拍平
- 运用递归的方法实现
Question
JSON格式的数据需要遵循什么规则？
- 复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
- 简单类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和null（不能使用NaN, Infinity, -Infinity和undefined）。
- 字符串必须使用双引号表示，不能使用单引号。
- 对象的键名必须放在双引号里面。
- 数组或对象最后一个成员的后面，不能加逗号。
遍历 company 对象，输出里面每一项的值
var company = {
name: '饥人谷',
age: 3,
sex: '男'
}
for (var i in company) {
console.log(company[i])
}
使用 JSON 对象实现一个简单的深拷贝函数(deepCopy)。
var obj = {
name: 'hunger',
age: 3,
friends: ['aa', 'bb', 'cc']
}
var obj2 = JSON.parse(JSON.stringify(obj))
console.log(obj2);
JSON.stringify方法用于将一个值转为字符串。该字符串符合 JSON 格式，并且可以被JSON.parse方法还原。
JSON.parse方法用于将JSON字符串转化成对象。
分别举例说明数组方法push、pop、shift、unshift、join、splice、sort、reverse、concat的作用？
push 在数组后面添加一个元素
var a = [1, 2, 3];
a.push(4);
console.log(a);//[1, 2, 3, 4]
pop 删除数组后面的最后一个元素 并返回它的值
var a = [1, 2, 3];
a.push(4);
console.log(a);//[1, 2, 3, 4]
console.log(a.pop())//4
console.log(a) //[1,2,3]
shift 删除数组中前面第一个元素 并返回它的值
unshift 在数组前面的第一个位置插入这个数，并返回他的值
var a=[1, 2, 3];
a.unshift(4);
console.log(a);//[4, 1, 2, 3]
console.log(a.length);//4
console.log(a.shift());//4
console.log(a); //[1, 2, 3]
console.log(a.length);//3
join 作用是把数组元素（对象调用其toString()方法）使用参数作为连接符连接成一字符串，不会修改原数组内容
var a = [1,2,3,4,5];
console.log(a.join(',')); //1,2,3,4,5
console.log(a.join(' ')); //1 2 3 4 5
splice 用于一次性解决数组添加、删除（这两种方法一结合就可以达到替换效果
//删除
var a = [1, 2, 3, 4, 5];
console.log(a.splice(1,3))//[2,3,4]
console.log(a.length) //2
console.log(a) //[1,5]
//插入和替换
var a = [1,2,3,4,5];
a.splice(1,0,9,99,999);
console.log(a.length); //8
console.log(a);//[1, 9, 99, 999, 2, 3, 4, 5]
a.splice(1,3,8,88,888);
console.log(a.length);//8
console.log(a);//[1, 8, 88, 888, 2, 3, 4, 5]
sort 用于对数组进行排序，
var a = [7,8,9,10,11]
a.sort(function(a,b){
if (a < b ) {
return -1
}
if (a > b ) {
return 1
}
return 0
})
console.log(a) //[7, 8, 9, 10, 11]
reverse 方法用于将数组逆序，与之前不同的是它会修改原数组
var a = [1,2,3,4,5];
a.reverse();
console.log(a); //[5, 4, 3, 2, 1]
concat 看起来像是剪切，但这个真不是形声字，concat方法用于拼接数组，a.concat(b)返回一个a和b共同组成的新数组，同样不会修改任何一个原始数组，也不会递归连接数组内部数组
var a = [1,2,3,4,5];
var b = [6,7,8,9];
console.log(a.concat(b));//[1, 2, 3, 4, 5, 6, 7, 8, 9]
console.log(a); //[1, 2, 3, 4, 5]
console.log(b); //[6, 7, 8, 9]
写一个函数，操作数组，返回一个新数组，新数组中只包含正数。
function filterPositive(arr){
var newarr= []
for(var i in arr){
if(typeof(arr[i]) === "number"&&arr[i]>0){
newarr.push(arr[i])
}
}
return newarr;
}
var arr = [3, -1, 2, '饥人谷', true]
filterPositive(arr)
console.log(filterPositive(arr)) //[3, 2]
用 splice函数分别实现 push、pop、shift、unshift方法。
push
function push(arr, value){
arr.splice(arr.length,0,value)
return arr.length
}
var arr = [1, 2, 3, 4, 5]
arr.push(10)
console.log(arr)
pop
function pop(arr, value){
arr.splice(arr.length-1,1)
return arr.length
}
var arr = [1, 2, 3, 4, 5]
arr.pop()
console.log(arr)
unshift
function unshitf(arr, value) {
arr.splice(0,0,value)
return value
}
var arr = [1, 2, 3, 4, 5]
arr.unshift(2)
console.log(arr)
shift
function shift(arr){
return arr[0]
arr.splice(0,1)
}
var arr = [1,2,3,4,5]
arr.shift()
console.log(arr)
对以下代码 users中的对象，分别以 name 字段、age 字段、company 字段进行排序
var users = [
{ name: "John", age: 20, company: "Baidu" },
{ name: "Pete", age: 18, company: "Alibaba" },
{ name: "Ann", age: 19, company: "Tecent" }
]
var sortByName = users.sort(function(v1, v2){
if(v1.name>v2.name){
return 1
}
if(v1.name<v2.name){
return -1
}
return 0
})
var sortByAge = users.sort(function(v1, v2){
if(v1.age>v2.age){
return 1
}
if(v1.age<v2.age){
return -1
}
return 0
})
var sortByCompany = users.sort(function(v1, v2){
if(v1.company>v2.copmpany){
return 1
}
if(v1.company<v2.company){
return -1
}
return 0
})
console.log(sortByName)
console.log(sortByAge)
console.log(sortByCompany)
分别举例说明ES5数组方法 indexOf、forEach、map、every、some、filter、reduce的用法？
indexof 顾名思义，这两个方法用于查找数组内指定元素位置，查找到第一个后返回其索引，没有查找到返回-1，indexOf从头至尾搜索，lastIndexOf反向搜索
var a = [1,2,3,3,2,1]
console.log(a.indexOf(2)) //1
console.log(a.lastIndexOf(2)) //4
.forEach(element, index, array)
- 当前元素
- 当前元素索引值
- 整个数组
var a = new Array(1,2,3,4,5,6);
a.forEach(function(e,i,array){
array[i]= e + 1;
});
console.log(a); //[2, 3, 4, 5, 6, 7]
.map(function(element))
与forEach类似，遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变
var a = [1, 2, 3, 4, 5, 6]
console.log(a.map(function(e){
return e * e
})) // [1, 4, 9, 16, 25, 36]
console.log(a) //[1, 2, 3, 4, 5, 6]
.every(function(element, index, array)) / .some(function(element, index, array))
这两个函数类似于离散数学中的逻辑判定，回调函数返回一个布尔值
every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false
some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false
在空数组上调用every返回true，some返回false
var a = [1, 2, 3, 4, 5, 6]
console.log(a.every(function(e, i, arr){
return e < 5
}))
console.log(a.some(function(e,i,arr){
return e > 4
.filter(function(element))
返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加
新数组只包含返回true的值，索引缺失的不包括，原数组保持不变
var a = [1, 2, 3, 4, 5, 6]
console.log(a.filter(function(e){
return e % 2 == 0;
})) // [2, 4, 6]
console.log(a) //[1, 2, 3, 4, 5, 6]
.reduce(function(v1, v2), value) / .reduceRight(function(v1, v2), value)
遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始，reduceRight反向，方法有两个参数
回调函数：把两个值合为一个，返回结果
value，一个初始值,可选
var a = [1, 2, 3, 4, 5, 6]
var b = a.reduce(function(v1, v2){ return v1 + v2 }) console.log(a) // 21
var b = a.reduceRight(function(v1, v2){ return v1 - v2 }, 100)
console.log(b) // 79
以下代码输出什么
var name = 'sex'
var company = {
name: '饥人谷',
age: 3,
sex: '男'
}
console.log(company[name])
男
写补全sortString函数，实现字符串倒序
function sortString(str){
//补全
}
var str = 'jirenguhungervalley'
var str2 = sortString(str)
console.log(str2) // 'yellavregnuhugnerij'
function sortString(str) {
return str.split('').reverse().join('')
}
