关注公众号《云爬虫技术研究笔记》，获取更多干货~
 
 
 
号主介绍
 多年反爬虫破解经验，AKA“逆向小学生”，沉迷数据分析和黑客增长不能自拔，虚名有CSDN博客专家和华为云享专家。
 
 
今天我们的题目是《由一个简单的Python合并字典问题引发的思考，如何优化我们的代码？》，为什么会有这个话题呢？起因是今天和一位刚刚面试完Python开发岗位的朋友交流，这个问题也是他在面试中遇到的问题：
 
 
 
怎么用一个简单的表达式合并Python中的两个Dict？
 
 
这个问题虽然是一道很简单的问题，并且解题的思路也有很多种。不过问题虽小，但是我们也借此分析一下更深层次的东西，关于代码如何优化，优化思路等等。
 
首先我们简单的思考一下，Python中合并两个Dict有哪些方法？我们分别举Python3和Python2的例子。
 
案例
 
假设我们现在有DictXX和DictYY，我们想要合并它们得到新的DictZZ，我们会这么做：
 
在Python 3.5或更高版本中：
 
z = {**x, **y}
 
在Python 2（或3.4或更低版本）中，编写一个函数：
 
def merge_two_dicts(x, y):
    z = x.copy()   # start with x's keys and values
    z.update(y)    # modifies z with y's keys and values & returns None
    return z
z = merge_two_dicts(x, y)
 
Python3.5版本以上方法分析
 
假设我们有两个字典，并且想要将它们合并为新字典而不更改原始字典：
 
x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
 
理想的结果是获得一个z是合并后的新字典，第二个Dict的值覆盖第一个字典Dict的值。
 
>>> z
{'a': 1, 'b': 3, 'c': 4}
 
在PEP 448中提出并从Python 3.5开始可用的新语法是：
 
z = {**x, **y}
 
它只需要一个非常简洁的表达式就可以完成，另外，我们也可以使用解包来进行操作：
 
z = {**x, 'foo': 1, 'bar': 2, **y}
 
结果如下：
 
>>> z
{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}
 
它现在正式的在3.5的发布时间表中实现，PEP 478，并且已进入Python 3.5的新功能文档。
 
我们大致看一下这个新功能的使用方式
 
 
这个功能允许我们在同一个表达式中使用多个解包表达式，能够很方便的合并迭代器和普通的列表，而不需要将迭代器先转化成列表再进行合并。
 
但是，由于许多组织仍在使用Python 2，因此我们可能希望以向后兼容的方式进行操作。在Python 2和Python 3.0-3.4中可用的经典Pythonic方法是分两个步骤完成的：
 
z = x.copy()
z.update(y) # which returns None since it mutates z
 
这种方法中，我们拷贝x生成新的对象z，再使用dict的update的方法合并两个dict。
 
Python3.5版本以下方法分析
 
如果我们尚未使用Python 3.5，或者需要编写向后兼容的代码，并且希望在单个表达式中使用它，则最有效的方法是将其放入函数中：
 
def merge_two_dicts(x, y):
    """Given two dicts, merge them into a new dict as a shallow copy."""
    z = x.copy()
    z.update(y)
    return z
 
然后我们需要这样使用函数：
 
z = merge_two_dicts(x, y)
 
您还可以创建一个合并多个dict的函数，并且我们可以指定任意数量的dict：
 
def merge_dicts(*dict_args):
    """
    Given any number of dicts, shallow copy and merge into a new dict,
    precedence goes to key value pairs in latter dicts.
    """
    result = {}
    for dictionary in dict_args:
        result.update(dictionary)
    return result
 
此函数将在Python 2和3中适用于所有字典。我们可以这样使用：
 
z = merge_dicts(a, b, c, d, e, f, g) 
 
不过注意的是：越往后的dict的键值优先度越高，会覆盖前面的键值。
 
发散脑洞，我们想象其他回答
 
在Python 2中，我们还可以这么操作：
 
z = dict(x.items() + y.items())
 
在Python 2中，我们使用.items()会得到list，也就是我们将会在内存中创建两个列表，然后在内存中创建第三个列表，其长度等于前两个字典的长度，最后丢弃所有三个列表以创建字典，就是我们需要的Dict。
 但是注意，我们决不能在Python 3中这么使用，在Python 3中，这会失败失败是因为我们是将两个dict_items对象而不是两个列表加在一起。
 
>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'
 
当然，我们真的想要实现的话，我们也可以强制转换，将它们明确创建为列表，例如z = dict(list(x.items()) + list(y.items()))，但是这反而浪费了资源和计算能力。
 
类似地，当值是不可散列的对象（例如列表）时，items()在Python 3（viewitems()在Python 2.7中）进行联合也将失败。即使您的值是可哈希的，由于集合在语义上是无序的，因此关于优先级的行为是不确定的。所以不要这样做：
 
>>> c = dict(a.items() | b.items())
 
我们演示一下值不可散列时会发生的情况：
 
>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
 
这是一个示例，其中y应该优先，但是由于集合的任意顺序，保留了x的值：
 
>>> x = {'a': 2}
>>> y = {'a': 1}
>>> x.items() | y.items()
{('a', 1), ('a', 2)}
>>> dict(x.items() | y.items())
{'a': 2}
 
另外一种我们不应该使用的另一种技巧：
 
z = dict(x, **y)
 
这使用了dict构造函数，并且非常快速且具有内存效率（甚至比我们的两步过程略高），但是除非我们确切地知道里面正在发生什么（也就是说，第二个dict作为关键字参数传递给dict，构造函数）我们才能使用，要不然这个表达式很难阅读，有时我们并不能很快的理解这算什么用法，因此不算Pythonic。
 
由于这种情况的存在，我们看看在django中修复的用法示例。
 
字典旨在获取可散列的键（例如，frozenset或tuple），但是当键不是字符串时，此方法在Python 3中失败。
 
>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings
 
在邮件列表中，大佬Guido van Rossum写道：
 
我宣布dict（{}，** {1：3}）是非法的使用方式，因为这是对**机制的滥用。
显然dict（x，** y）和直接调用x.update（y）并返回x这种“酷”的操作很类似。
但是我个人觉得它比“酷”的操作更低俗。
 
不过根据我的理解（以及对大佬的话的理解），dict(**y)命令的预期用途是为了创建可读性强的字典，例如：
 
dict(a=1, b=10, c=11)
 
用来代替
 
{'a': 1, 'b': 10, 'c': 11}
 
在这个地方使用**运算符也不会滥用该机制，我们使用**正是为了将dict作为关键字传递而设计的。
 
最后看看那些性能较差的实现方案
 
这些方法的性能较差，但是它们将提供正确的行为。它们的性能将不及copy和update或新的解包方式，因为它们在更高的抽象级别上遍历每个键值对，但它们确实遵循优先级的顺序（后者决定了优先级）
 
我们可以在使用生成式来做：
 
{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7
 
或在python 2.6中（也许在引入生成器表达式时早在2.4中）：
 
dict((k, v) for d in dicts for k, v in d.items())
 
itertools.chain 迭代器的骚操作：
 
import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))
 
ChainMap的骚操作：
 
>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = ChainMap({}, y, x)
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11
 
####我们做做时间分析
 我将仅对已知行为正确的用法进行性能分析。
 
import timeit
 
在Ubuntu 18上完成以下操作
 在Python 2.7（系统Python）中：
 
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934
 
在Python 3.5中：
 
>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287
 
结论
 
经过我们之前的一系列分析和实验，我们可以得到这个问题的结论
 
Python 2中我们就采用copy加上update的方案
Python 3中我们就采用多重解包的方案
 
不过对比以上两种，显然多重解包更快而且更简洁，针对大家不熟悉Python 3可以参考我之前的一篇文章Python2寿命只剩一个月啦！还不快赶紧学起Python3酷炫到爆的新特性！，可以帮助大家快速的切换成Python 3开发，不过注意的是Python 3高版本和Python 2.7差别也是比较大，因此大家要是涉及线上业务的切换，请谨慎注意！
 
最后我们来谈谈优化代码的问题，从这个问题入手，我们可以总结出优化代码的思路：
 
我们分析出有哪些解决方案？
哪些解决方案是有效的？
这些有效的方案怎么做对比？
最佳的方案需要我们做出哪些牺牲？

k倍多重正整数集
 牛客网：k倍多重正整数集
 
题目描述
 
k倍多重正整数集合的定义是：在一个多重集合（元素可以重复）中，不存在一个正整数是另一个正整数的k倍。 现在小M有n个正整数，你可以选择其中一些数构成k倍多重正整数集合。请求出最多能选出多少数来构成它。
 
输入描述:
 第一行有两个整数n, k(1 <= n <= 10^5, 1 <= k <= 10^9)。
 
接下来一行有n个正整数a1, a2, …, an (1 <= ai <= 10^9)。
 
输出描述:
 最多能选出多少数构成k倍多重正整数集合。
 
示例1
 
输入
 6 2
 2 3 6 5 4 10
 
输出
 3
 
思路：
 首先声明，这个思路用python超时了，但是一定是正确的思路。
 我们将连续的符合k倍多重正整数归为同类，比如k=2时，【2，4，8，16】就是一类，但是如果没有32，那么64和上面的数组元素不属于同一类。因此，即便有k倍的关系，必须要连续才可以。
 
因此我们先用哈希表存储数据和对应的次数，然后将哈希表的键值排序（排序的目的是为了保证后面不会出现比前面小的元素。比如【4，8，16】已经整理好，但是后面又出现了2，那么2是可以和他们归为一类，但是出现的顺序不对，那么就会出现自己单独归为一类，出现错误），用一个while循环将同一类的元素归为一类，record记录出现过的元素，并用temp记录相应键值的次数。
 
temp这个数组很有用，它记录的是同一类连续元素出现的次数。那么对于这个数组，我用了动态规划计算其最大的次数。比如dp=【3，1，3，4】，我们取max（dp【-1】，dp【-2】）。dp的舒适化很重要，当dp的长度小于3时，取其中的最大值即可。dp长度大于等于3时，dp【0】= num【0】，dp【1】=max（num【0】，num【1】），dp【2】=num【0】+num【2】，之后的dp【i】= max（dp【i-2】，dp【i-3】）+num【i】。
 
对每一类的temp，我们用select_num 计算最大的出现次数即可。简而言之，select_num实现了如下功能：计算出不连续子数组最大和。用res累加所有类的次数就是答案。python通过了95%的例子，最后那个例子一定是一万多以上的数字，不然的话不会如此耗时。而且，牛客网中python2版本运行速度往往优于python3。
 
def select_num(num):
    tem = [num[i] for i in range(len(num))]
    if len(tem)<=2:
        return max(tem)
    else:
        dp = [0 for _ in range(len(tem))]
        dp[0] = tem[0]
        dp[1] = max(tem[0],tem[1])
        dp[2] = dp[0]+tem[2]
        for j in range(3,len(tem)):
            dp[j] = max(dp[j-2],dp[j-3])+tem[j]
    return max(dp[-1],dp[-2])
#数据的读取
n, k = list(map(int,input().split()))
num = list(map(int,input().split()))
if n==1:
    print(1) # 只有一个数时，直接输出1
elif k==1:
    print(len(set(num))) #k=1时，输出集合元素个数就行
else:
    dirc = {}
    for i in num: # 用哈希表存储元素及其相应出现的次数
        dirc[i] = dirc.get(i,0)+1
    record = [] #记录出现过的元素
    ans = 0
    new = sorted(dirc) #对哈希表的键值排序，保证循环时大的数只在后面出现
    for i in new:
        if i not in record: # 若已经在记录中出现过，那么就属于已经在temp中统计过的，不再重复统计。
            temp = [dirc[i]] #不在记录中，那就用temp记录相应的次数。
            number = i*k
            record.append(i)
            while number in dirc and number not in record: # 若i及其同类在字典中出现但不在temp中
                temp.append( dirc[number])
                record.append(number)
                number = number * k
            ans += select_num(temp)
    print(ans)

 
文章目录
 
字典数据类型
字典与列表
keys， values 和 item() 方法
检查字典中是否存在键或值
get() 方法
setdefault() 方法
  
使用数据结构对真实世界建模
井字棋盘
嵌套的字典和列表
 

 
字典数据类型
 
像列表一样，“字典”是许多值的集合。但不像列表的下标，字典的索引可以使用许多不同数据类型，不只是整数。字典的索引被称为“键”，键及其关联的值称为“键-值”对。
 在代码中，字典输入时带花括号{}。在交互式环境中输入以下代码：
 
>>> myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
>>>> type(myCat)
<class 'dict'>
 
这将一个字典赋给 myCat 变量。这个字典的键是 ‘size’、‘color’ 和 ‘disposition’。这些键对应的值是 ‘fat’、‘gray’ 和 ‘loud’。可以通过它们的键访问这些值：
 
>>> myCat = {'size': 'fat', 'color': 'gray', 'disposition': 'loud'}
>>> myCat['size']
'fat'
>>> 'My cat has ' + myCat['color'] + ' fur.'
'My cat has gray fur.'
 
字典仍然可以用整数值作为键，就像列表使用整数值作为下标一样，但它们不必从 0 开始，可以是任何数字。
 
>>> spam = {12345: 'Luggage Combination', 42: 'The Answer'}
>>> spam[42]
'The Answer'
 
字典与列表
 
不像列表，字典中的表项是不排序的。名为 spam 的列表中，第一个表项是 spam[0]。但字典中没有“第一个”表项。虽然确定两个列表是否相同时，表项的顺序很重要，但在字典中，键-值对输入的顺序并不重要。
 
>>> spam = ['cats', 'dogs', 'moose']
>>> bacon = ['dogs', 'moose', 'cats']
>>> spam == bacon
False
>>> eggs = {'name': 'Zophie', 'species': 'cat', 'age': '8'}
>>> ham = {'species': 'cat', 'age': '8', 'name': 'Zophie'}
>>> eggs == ham
True
 
因为字典是不排序的，所以不能像列表那样切片。
 尝试访问字典中不存在的键，将导致 KeyError 出错信息。这很像列表的“越界” IndexError 出错信息。
 
>>> spam = {'name': 'Zophie', 'age': 7}
>>> spam['color']
Traceback (most recent call last):
  File "<pyshell#114>", line 1, in <module>
    spam['color']
KeyError: 'color'
 
尽管字典是不排序的，但可以用任意值作为键，这一点可以让我们用强大的方式来组织数据。
 假定你希望程序保存朋友生日的数据，就可以使用一个字典，用名字作为键，用生日作为值。
 打开一个新的文件编辑窗口，输入以下代码，并保存为 birthdays.py。
 
birthdays = {'Alice': 'Apr 1', 'Bob': 'Dec 12', 'Carol': 'Mar 4'}

while True:
    print('Enter a name: (blank to quit)')
    name = input()
    if name == '':
        break

    if name in birthdays:
        print(birthdays[name] + ' is the birthday of ' + name)
    else:
        print('I do not have birthday information for ' + name)
        print('What is their birthday?')
        bday = input()
        birthdays[name] = bday
        print('Birthday database updated.')
print('Quit the program')
 
在上面的代码中，创建了一个初始的字典，将它保存在 birthdays 中。用 in 关键字，可以看看输入的名字是否作为键存在于字典中，就像查看列表一样。如果该名字在字典中，可以用方括号访问关联的值。如果不在，可以用同样的方括号语法和赋值操作符添加它。
 
Enter a name: (blank to quit)
Alice
Apr 1 is the birthday of Alice
Enter a name: (blank to quit)
Eve
I do not have birthday information for Eve
What is their birthday?
Dec 5
Birthday database updated.
Enter a name: (blank to quit)
Eve
Dec 5 is the birthday of Eve
Enter a name: (blank to quit)
 
keys， values 和 item() 方法
 
有 3 个字典方法，它们将返回类似列表的值，分别对应于字典的键、值和键-值对：keys(), values() 和 items()。这些方法返回的值不是真正的列表，它们不能被修改，没有 append() 方法。但这些数据类型(分别是 dict_keys, dict_values 和 dict_items) 可以用于 for 循环。
 
>>> spam = {'color': 'red', 'age':42}
>>> for v in spam.values():
	print(v)

	
red
42
>>> type(spam.values())
<class 'dict_values'>
 
这里，for 循环迭代了 spam 字典中的每个值。for 循环也可以迭代每个键或者键-值对：
 
>>> for k in spam.keys():
	print(k)

	
color
age
>>> type(spam.keys())
<class 'dict_keys'>
>>> for i in spam.items():
	print(i)

	
('color', 'red')
('age', 42)
>>> type(spam.items())
<class 'dict_items'>
 
请注意，items() 方法返回的 dict_items 值中，包含的是键和值的元组。
 如果希望通过这些方法得到一个真正的列表，就把类似列表的返回值传递给 list 函数。
 
>>> spam = {'color': 'red', 'age': 42}
>>> spam.keys()
dict_keys(['color', 'age'])
>>> list(spam.keys())
['color', 'age']
 
也可以利用多重赋值的技巧，在 for 循环中将键和值赋给不同的变量。
 
>>> spam = {'color': 'red', 'age': 42}
>>> for k, v in spam.items():
	print('Key: ' + k + ' Value: ' + str(v))

	
Key: color Value: red
Key: age Value: 42
 
检查字典中是否存在键或值
 
可以使用 in 和 not in 操作符检查某个键或值是否存在于字典中。
 
>>> spam.items()
dict_items([('name', 'Zophie'), ('age', 7)])
>>> spam.keys()
dict_keys(['name', 'age'])
>>> spam.values()
dict_values(['Zophie', 7])
>>> spam = {'name': 'Zophie', 'age': 7}
>>> 'name' in spam.keys()
True
>>> 'Zophie' in spam.values()
True
>>> 'color' in spam.keys()
False
>>> 'color' not in spam.keys()
True
>>> 'color' in spam
False
>>> 'name' in spam
True
>>> ('age', 7) in spam.items()
True
 
请注意，在上面的例子中，'color' in spam 本质上是一个简写版本。相当于 'color' in spam.keys()。
 如果想要检查一个值是否为字典中的键，就可以用关键字 in 或 not in，作用于该字典本身。
 
get() 方法
 
在访问一个键的值之前，检查该键是否存在于字典中，这很麻烦。字典有一个 gets() 方法，它有两个参数：要取得其值的键，以及如果该键不存在时，返回的备用值。
 
>>> picnicItems = {'apples': 5, 'cups': 2}
>>> 'I am bringing ' + str(picnicItems.get('cups', 0)) + ' cups.'
'I am bringing 2 cups.'
>>> 'I am bringing ' + str(picnicItems.get('eggs', 0)) + ' eggs.'
'I am bringing 0 eggs.'
 
因为 picnicItems 字典中没有 egg 键，gets() 方法返回的默认值是 0.不使用 gets()，代码就会产生一个错误信息。
 
>>> picnicItems = {'apples': 5, 'cups': 2}
>>> 'I am bringing ' + str(picnicItems['eggs']) + ' eggs.'
Traceback (most recent call last):
  File "<pyshell#159>", line 1, in <module>
    'I am bringing ' + str(picnicItems['eggs']) + ' eggs.'
KeyError: 'eggs'
 
setdefault() 方法
 
我们常常需要为字典中某个键设置一个默认值，当该键没有任何值时使用它。代码看起来像这样：
 
spam = {'name': 'Pooka', 'age': 5}
if 'color' not in spam:
    spam['color'] = 'black'
 
setdefault() 方法提供了一种方式，在一行中完成这件事。传递给该方法的第一个参数,是要检查的键，第二个参数，是如果该键不存在时要设置的值。如果该键确实存在，方法就会返回键的值。
 
>>> spam = {'name': 'Pooka', 'age': 5}
>>> spam.setdefault('color', 'black')
'black'
>>> spam
{'name': 'Pooka', 'age': 5, 'color': 'black'}
>>> spam.setdefault('color', 'white')
'black'
>>> spam
{'name': 'Pooka', 'age': 5, 'color': 'black'}
 
第一次调用 setdefault 时，spam 变量中的字典变为 {'name': 'Pooka', 'age': 5, 'color': 'black'}。该方法返回值为 'black',因为现在该值被赋给键 'color'。当 spam.setdefault('color', 'white') 接下来被调用时，该键的值没有被改变为 'white',因为 spam 变量已经有名为 'color' 的键。
 
下面是一个小程序，计算一个字符串中每个字符出现的次数。
 
message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
count = {}
for character in message:
    count.setdefault(character, 0)
    count[character] += 1

print(count)
 
程序循环迭代 message 字符串中的每个字符，计算每个字符出现的次数。setdefault() 方法调用确保了键存在于 count 中(默认值是 0)，这样在执行 count[character] += 1 时，就不会抛出 KeyError 错误。
 程序运行是输出如下：
 
{'I': 1, 't': 6, ' ': 13, 'w': 2, 'a': 4, 's': 3, 'b': 1, 'r': 5, 'i': 6, 'g': 2, 'h': 3, 'c': 3, 'o': 2, 'l': 3, 'd': 3, 'y': 1, 'n': 4, 'A': 1, 'p': 1, ',': 1, 'e': 5, 'k': 2, '.': 1}
 
使用数据结构对真实世界建模
 
井字棋盘
 
嵌套的字典和列表

1.document.write(""); 输出语句 
2.JS中的注释为// 
3.传统的HTML文档顺序是:document->html->(head,body) 
4.一个浏览器窗口中的DOM顺序是:window->(navigator,screen,history,location,document) 
5.得到表单中元素的名称和值:document.getElementById("表单中元素的ID号").name(或value) 
6.一个小写转大写的JS: document.getElementById("output").value = document.getElementById("input").value.toUpperCase(); 
7.JS中的值类型:String,Number,Boolean,Null,Object,Function 
8.JS中的字符型转换成数值型:parseInt(),parseFloat() 
9.JS中的数字转换成字符型:(""+变量) 
10.JS中的取字符串长度是:(length) 
11.JS中的字符与字符相连接使用+号. 
12.JS中的比较操作符有:==等于,!=不等于,>,>=, <. <= 
13.JS中声明变量使用:var来进行声明 
14.JS中的判断语句结构:if(condition){}else{} 
15.JS中的循环结构:for([initial e xpression];[condition];[upadte e xpression]) {inside loop} 
16.循环中止的命令是:break 
17.JS中的函数定义:function functionName([parameter],...){statement[s]} 
18.当文件中出现多个form表单时.可以用document.forms[0],document.forms[1]来代替. 
19.窗口:打开窗口window.open(), 关闭一个窗口:window.close(), 窗口本身:self 
20.状态栏的设置:window.status="字符"; 
21.弹出提示信息:window.alert("字符"); 
22.弹出确认框:window.confirm(); 
23.弹出输入提示框:window.prompt(); 
24.指定当前显示链接的位置:window.location.href="/blog/URL" 
25.取出窗体中的所有表单的数量:document.forms.length 
26.关闭文档的输出流:document.close(); 
27.字符串追加连接符:+= 
28.创建一个文档元素:document.createElement(),document.createTextNode() 
29.得到元素的方法:document.getElementById() 
30.设置表单中所有文本型的成员的值为空: 
var form = window.document.forms[0] 
for (var i = 0; i <form.elements.length;i++){ 
    if (form.elements.type == "text"){ 
        form.elements.value = ""; 
    } 
} 
31.复选按钮在JS中判断是否选中:document.forms[0].checkThis.checked (checked属性代表为是否选中返回TRUE或FALSE) 
32.单选按钮组(单选按钮的名称必须相同):取单选按钮组的长度document.forms[0].groupName.length 
33.单选按钮组判断是否被选中也是用checked. 
34.下拉列表框的值:document.forms[0].selectName.options[n].value (n有时用下拉列表框名称加上.selectedIndex来确定被选中的值) 
35.字符串的定义:var myString = new String("This is lightsword"); 
36.字符串转成大写:string.toUpperCase(); 字符串转成小写:string.toLowerCase(); 
37.返回字符串2在字符串1中出现的位置:String1.indexOf("String2")!=-1则说明没找到. 
38.取字符串中指定位置的一个字符:StringA.charAt(9); 
39.取出字符串中指定起点和终点的子字符串:stringA.substring(2,6); 
40.数学函数:Math.PI(返回圆周率),Math.SQRT2(返回开方),Math.max(value1,value2)返回两个数中的最在值,Math.pow(value1,10)返回value1的十次方,Math.round(value1)四舍五入函数,Math.floor(Math.random()*(n+1))返回随机数 
41.定义日期型变量:var today = new Date(); 
42.日期函数列表:dateObj.getTime()得到时间,dateObj.getYear()得到年份,dateObj.getFullYear()得到四位的年份,dateObj.getMonth()得到月份,dateObj.getDate()得到日,dateObj.getDay()得到日期几,dateObj.getHours()得到小时,dateObj.getMinutes()得到分,dateObj.getSeconds()得到秒,dateObj.setTime(value)设置时间,dateObj.setYear(val)设置年,dateObj.setMonth(val)设置月,dateObj.setDate(val)设置日,dateObj.setDay(val)设置星期几,dateObj.setHours设置小时,dateObj.setMinutes(val)设置分,dateObj.setSeconds(val)设置秒  [注意:此日期时间从0开始计] 
43.FRAME的表示方式: [window.]frames[n].ObjFuncVarName,frames["frameName"].ObjFuncVarName,frameName.ObjFuncVarName 
44.parent代表父亲对象,top代表最顶端对象 
45.打开子窗口的父窗口为:opener 
46.表示当前所属的位置:this 
47.当在超链接中调用JS函数时用:(javascript :)来开头后面加函数名 
48.在老的浏览器中不执行此JS: <!--      //--> 
49.引用一个文件式的JS: <script type="text/javascript" src="/blog/aaa.js"> </script> 
50.指定在不支持脚本的浏览器显示的HTML: <noscript> </noscript> 
51.当超链和onCLICK事件都有时,则老版本的浏览器转向a.html,否则转向b.html.例: <a href="/blog/a.html" οnclick="location.href="/blog/b.html";return false">dfsadf </a> 
52.JS的内建对象有:Array,Boolean,Date,Error,EvalError,Function,Math,Number,Object,RangeError,ReferenceError,RegExp, 
String,SyntaxError,TypeError,URIError 
53.JS中的换行:/n 
54.窗口全屏大小: <script>function fullScreen(){ this.moveTo(0,0);this.outerWidth=screen.availWidth;this.outerHeight=screen.availHeight;}window.maximize=fullScreen; </script> 
55.JS中的all代表其下层的全部元素 
56.JS中的焦点顺序:document.getElementByid("表单元素").tabIndex = 1 
57.innerHTML的值是表单元素的值:如 <p id="para">"how are <em>you </em>" </p>,则innerHTML的值就是:how are <em>you </em> 
58.innerTEXT的值和上面的一样,只不过不会把 <em>这种标记显示出来. 
59.contentEditable可设置元素是否可被修改,isContentEditable返回是否可修改的状态. 
60.isDisabled判断是否为禁止状态.disabled设置禁止状态 
61.length取得长度,返回整型数值 
62.addBehavior()是一种JS调用的外部函数文件其扩展名为.htc 
63.window.focus()使当前的窗口在所有窗口之前. 
64.blur()指失去焦点.与FOCUS()相反. 
65.select()指元素为选中状态. 
66.防止用户对文本框中输入文本:οnfοcus="this.blur()" 
67.取出该元素在页面中出现的数量:document.all.tags("div(或其它HTML标记符)").length 
68.JS中分为两种窗体输出:模态和非模态.window.showModaldialog(),window.showModeless() 
69.状态栏文字的设置:window.status='文字',默认的状态栏文字设置:window.defaultStatus = '文字.'; 
70.添加到收藏夹:external.AddFavorite("http://www.cnblogs.com/css/";,"jaskdlf"); 
71.JS中遇到脚本错误时不做任何操作:window.onerror = doNothing; 指定错误句柄的语法为:window.onerror = handleError; 
72.JS中指定当前打开窗口的父窗口:window.opener,支持opener.opener...的多重继续. 
73.JS中的self指的是当前的窗口 
74.JS中状态栏显示内容:window.status="内容" 
75.JS中的top指的是框架集中最顶层的框架 
76.JS中关闭当前的窗口:window.close(); 
77.JS中提出是否确认的框:if(confirm("Are you sure?")){alert("ok");}else{alert("Not Ok");} 
78.JS中的窗口重定向:window.navigate("http://www.cnblogs.com/css/";); 
79.JS中的打印:window.print() 
80.JS中的提示输入框:window.prompt("message","defaultReply"); 
81.JS中的窗口滚动条:window.scroll(x,y) 
82.JS中的窗口滚动到位置:window.scrollby 
83.JS中设置时间间隔:setInterval("expr",msecDelay)或setInterval(funcRef,msecDelay)或setTimeout 
84.JS中的模态显示在IE4+行,在NN中不行:showModalDialog("URL"[,arguments][,features]); 
85.JS中的退出之前使用的句柄:function verifyClose(){event.returnValue="we really like you and hope you will stay longer.";}}  window.οnbefοreunlοad=verifyClose; 
86.当窗体第一次调用时使用的文件句柄:onload() 
87.当窗体关闭时调用的文件句柄:onunload() 
88.window.location的属性: protocol(http:),hostname(www.example.com),port(80),host(www.example.com:80),pathname("/a/a.html"),hash("#giantGizmo",指跳转到相应的锚记),href(全部的信息) 
89.window.location.reload()刷新当前页面. 
90.window.history.back()返回上一页,window.history.forward()返回下一页,window.history.go(返回第几页,也可以使用访问过的URL) 
91.document.write()不换行的输出,document.writeln()换行输出 
92.document.body.noWrap=true;防止链接文字折行. 
93.变量名.charAt(第几位),取该变量的第几位的字符. 
94."abc".charCodeAt(第几个),返回第几个字符的ASCii码值. 
95.字符串连接:string.concat(string2),或用+=进行连接 
96.变量.indexOf("字符",起始位置),返回第一个出现的位置(从0开始计算) 
97.string.lastIndexOf(searchString[,startIndex])最后一次出现的位置. 
98.string.match(regExpression),判断字符是否匹配. 
99.string.replace(regExpression,replaceString)替换现有字符串. 
100.string.split(分隔符)返回一个数组存储值. 
101.string.substr(start[,length])取从第几位到指定长度的字符串. 
102.string.toLowerCase()使字符串全部变为小. 
103.string.toUpperCase()使全部字符变为大写. 
104.parseInt(string[,radix(代表进制)])强制转换成整型. 
105.parseFloat(string[,radix])强制转换成浮点型. 
106.isNaN(变量):测试是否为数值型. 
107.定义常量的关键字:const,定义变量的关键字:var