精华内容
下载资源
问答
  • java字符串常用方法
    千次阅读
    2018-10-30 22:09:27

    什么是String类

    Striing是一个引用数据类型(通常叫做字符串),或者说是一由java自带的功能类。其底层是char类型(字符类型)的数组进行实现的。其所在位置为java的java.lang包中,在java中 String类是由final修饰的,所以其不能有子类。

    String类创建对象的两种方法

    (1).直接赋值:该方式创建一个对象-->"aa"
            String s1 = "aa";
        (2).new对象:该方式创建了两个对象-->new String和"aa"
            String s1 = new String("aa");

    字符串是常量,当其被赋值后,值不能被改变,所以当我们对其更改后,其实是返回了一个新的字符串。

    String类的常用方法

    (1).length方法:获得字符串的长度,数组没有length方法
        (2).charAt方法:返回指定下角标(索引)处的字符值
        (3).indexOf方法:返回指定字符或字符串第一次出现的位置(如果找不到位置,则返回-1)
        (4).substring方法:截位(根据光标的位置,截取原有字符串,并生成新的字符串)
        (5).replace方法:将原有字符串中的指定字符或者字符串替换,并生成新的字符串
        (6).trim方法:去除字符串前后空格
        (7).split方法:根据指定字符串或正则表达式将原有字符串分割,返回数组
        (8).startsWith方法:判断指定参数是否为原字符串前缀
        (9).endsWith方法:判断指定参数是否为原字符串后缀
        (10).valueOf方法:将整数转换成字符串

     

    String中==和equals的区别

    ==:比较的是两个字符串栈上的值(内存地址)

    equals:比较的是真实的字符串内容(堆内的值)

     

    更多相关内容
  • python字符串常用方法及汇总

    万次阅读 多人点赞 2019-06-18 18:57:03
    字符串常用方法常用的查找方法去除首尾信息大小写转换格式排版其他方法字符串的格式化format()基本用法填充与对齐数字格式化其他格式,供大家参考:可变字符串 常用的查找方法 我们以一段文本作为测试: a=’’‘我...

    字符串基本特点

    很多人初学编程时,总是担心自己数学不行,潜意识里认为数学好才能编程。实际上,
    大多数程序员打交道最多的是“字符串”而不是“数字”。因为,编程是用来解决现实问题
    的,因此逻辑思维的重要性远远超过数学能力。
    字符串的本质是:字符序列。Python 的字符串是不可变的,我们无法对原字符串做任
    何修改。但,可以将字符串的一部分复制到新创建的字符串,达到“看起来修改”的效果。
    Python 不支持单字符类型,单字符也是作为一个字符串使用的。

    字符串的编码
    Python3 直接支持 Unicode,可以表示世界上任何书面语言的字符。Python3 的字符默认就是 16 位 Unicode 编码,ASCII 码是 Unicode 编码的子集。
    使用内置函数 ord()可以把字符转换成对应的 Unicode 码;
    使用内置函数 chr()可以把十进制数字转换成对应的字符。

    >>> ord('A')
    65
    >>> ord('高')
    39640
    >>> chr(66)
    'B'
    >>> ord('淇')
    28103
    

    引号创建字符串

    我们可以通过单引号或双引号创建字符串。例如:a=’abc’; b=”sxt”
    使用两种引号的好处是可以创建本身就包含引号的字符串,而不用使用转义字符。例如:

    >>> a = "I'm a teacher!"
    >>> print(a)
    I'm a teacher!
    >>> b = 'my_name is "TOM"'
    >>> print(b)
    my_name is "TOM"
    

    连续三个单引号或三个双引号,可以帮助我们创建多行字符串。例如:

    >>> resume = ''' name="gaoqi"
    company="sxt" age=18
    lover="Tom"'''
    >>> print(resume)
    name="gaoqi"
    company="sxt" age=18
    lover="Tom"
    

    空字符串和 len()函数

    Python 允许空字符串的存在,不包含任何字符且长度为 0。例如:

    >>> c = ''
    >>> len(c)
    0
    

    len()用于计算字符串含有多少字符。例如:

    >>> d = 'abc 尚学堂'
    >>> len(d)
    6
    

    转义字符

    我们可以使用“+特殊字符”,实现某些难以用字符表示的效果。比如:换行等。常见的
    转义字符有这些:

    转义字符描述
    (在行尾时)续行符
    \反斜杠符号
    单引号
    "双引号
    \b退格(Backspace)
    \n换行
    \t横向制表符
    \r回车

    【操作】测试转义字符的使用

    >>> a = 'I\nlove\nU'
    >>> a
    'I\nlove\nU'
    >>> print(a)
    I
    love
    U
    >>> print('aaabb\
    cccddd')
    aaabbcccddd
    

    字符串拼接

    1. 可以使用+将多个字符串拼接起来。例如:’aa’+ ’bb’ ==>’aabb’。
      (1) 如果+两边都是字符串,则拼接。
      (2) 如果+两边都是数字,则加法运算。
      (3) 如果+两边类型不同,则抛出异常。
    2. 可以将多个字面字符串直接放到一起实现拼接。例如:’aa’’bb’==>’aabb’
      【操作】字符串拼接操作
    >>> a = 'sxt'+'gaoqi'
    >>> a
    'sxtgaoqi'
    >>> b = 'sxt''gaoqi'
    >>> b
    'sxtgaoqi'
    

    字符串复制

    使用*可以实现字符串复制。
    【操作】字符串复制操作

    >>> a = 'Sxt'*3
    >>> a
    'SxtSxtSxt'
    

    不换行打印

    我们前面调用 print 时,会自动打印一个换行符。有时,我们不想换行,不想自动添加换行符。我们可以自己通过参数 end = “任意字符串”。实现末尾添加任何内容:
    建立源文件 mypy_06.py:

    print("sxt",end=' ')
    print("sxt",end='##')
    print("sxt")
    -----------------------------------
    运行结果:
    sxt sxt##sxt
    

    从控制台读取字符串

    我们可以使用 input()从控制台读取键盘输入的内容。

    >>> myname = input("请输入名字:")
    请输入名字:高淇
    >>> myname
    '高淇'
    

    str()实现数字转型字符串

    str()可以帮助我们将其他数据类型转换为字符串。例如:

    str(5.20) ==>5.20str(3.14e2)==>314.0str(True) ==>True

    当我们调用 print()函数时,解释器自动调用了 str()将非字符串的对象转成了字符串。我们
    在面向对象章节中详细讲解这部分内容。

    使用[]提取字符

    字符串的本质就是字符序列,我们可以通过在字符串后面添加[],在[]里面指定偏移量,
    可以提取该位置的单个字符。
    正向搜索:

    • 最左侧第一个字符,偏移量是 0,第二个偏移量是 1,以此类推。直到 len(str)-1
      为止。

    反向搜索:

    • 最右侧第一个字符,偏移量是-1,倒数第二个偏移量是-2,以此类推,直到-len(str)
      为止。

    【操作】使用[]提取字符串中的字符

    >>> a = 'abcdefghijklmnopqrstuvwxyz'
    >>> a
    'abcdefghijklmnopqrstuvwxyz'
    >>> a[0]
    'a'
    >>> a[3]
    'd'
    >>> a[26-1]
    'z'
    >>> a[-1]
    
    'z'
    >>> a[-26]
    'a'
    >>> a[-30]
    Traceback (most recent call last):
    File "<pyshell#91>", line 1, in <module>
    a[-30]
    IndexError: string index out of range
    

    replace()实现字符串替换

    字符串是“不可改变”的,我们通过[]可以获取字符串指定位置的字符,但是我们不能改变
    字符串。我们尝试改变字符串中某个字符,发现报错了:

    >>> a = 'abcdefghijklmnopqrstuvwxyz'
    >>> a
    'abcdefghijklmnopqrstuvwxyz'
    >>> a[3]='高'
    Traceback (most recent call last):
    File "<pyshell#94>", line 1, in <module>
    a[3]='高'
    TypeError: 'str' object does not support item assignment
    

    字符串不可改变。但是,我们确实有时候需要替换某些字符。这时,只能通过创建新的字符串来实现。

    >>> a = 'abcdefghijklmnopqrstuvwxyz'
    >>> a
    'abcdefghijklmnopqrstuvwxyz'
    >>> a = a.replace('c','高')
    'ab 高 defghijklmnopqrstuvwxyz'
    

    整个过程中,实际上我们是创建了新的字符串对象,并指向了变量 a,而不是修改了以前的字符串。 内存图如下:
    在这里插入图片描述

    字符串切片 slice 操作

    切片 slice 操作可以让我们快速的提取子字符串。标准格式为:

    [起始偏移量 start:终止偏移量 end:步长 step]
    

    典型操作(三个量为正数的情况)如下:

    操作和说明示例结果
    [:] 提取整个字符串“abcdef”[:]“abcdef”
    [start:]从 start 索引开始到结尾“abcdef”[2:]“cdef”
    [:end]从头开始知道 end-1“abcdef”[:2]“ab”
    [start:end]从 start 到 end-1“abcdef”[2:4]“cd”
    [start: end:step]从 start 提取到end-1,步长是 step“abcdef”[1:5:2]“bd”

    其他操作(三个量为负数)的情况:

    示例说明结果
    “abcdefghijklmnopqrstuvwxyz”[-3:]倒数三个“xyz”
    “abcdefghijklmnopqrstuvwxyz”[-8:-3]倒数第八个到倒数第三个(包头不包尾)‘stuvw’
    “abcdefghijklmnopqrstuvwxyz”[::-1]步长为负,从右到左反向提取‘zyxwvutsrqponmlkjihgfedcba’

    切片操作时,起始偏移量和终止偏移量不在[0,字符串长度-1]这个范围,也不会报错。起始偏移量小于 0 则会当做 0,终止偏移量大于“长度-1”会被当成-1。例如:

    >>> "abcdefg"[3:50]
    'defg'
    

    我们发现正常输出了结果,没有报错。
    【操作】

    1. 将”to be or not to be”字符串倒序输出
    2. 将”sxtsxtsxtsxtsxt”字符串中所有的 s 输出

    split()分割和 join()合并

    split()可以基于指定分隔符将字符串分隔成多个子字符串(存储到列表中)。如果不指定分隔
    符,则默认使用空白字符(换行符/空格/制表符)。示例代码如下:

    >>> a = "to be or not to be"
    >>> a.split()
    ['to', 'be', 'or', 'not', 'to', 'be']
    >>> a.split('be')
    ['to ', ' or not to ', '']
    

    join()的作用和 split()作用刚好相反,用于将一系列子字符串连接起来。示例代码如下:

    >>> a = ['sxt','sxt100','sxt200']
    >>> '*'.join(a)
    'sxt*sxt100*sxt200'
    

    拼接字符串要点:

    使用字符串拼接符+,会生成新的字符串对象,因此不推荐使用+来拼接字符串。推荐
    使用 join 函数,因为 join 函数在拼接字符串之前会计算所有字符串的长度,然后逐一拷贝,仅新建一次对象。
    【操作】测试+拼接符和 join(),不同的效率 (mypy_07.py)

    import time
    
    time01 = time.time() #起始时刻
    a = ""
    for i in range(1000000):
    
    a += "sxt"
    time02 = time.time() #终止时刻
    print("运算时间:"+str(time02-time01))
    time03 = time.time() #起始时刻
    li = []
    for i in range(1000000):
    li.append("sxt")
    a = "".join(li)
    time04 = time.time() #终止时刻
    print("运算时间:"+str(time04-time03))
    

    字符串驻留机制和字符串比较

    字符串驻留:仅保存一份相同且不可变字符串的方法,不同的值被存放在字符串驻留池中。Python 支持字符串驻留机制,对于符合标识符规则的字符串(仅包含下划线(_)、字母和数字)会启用字符串驻留机制驻留机制。

    >>> a = "abd_33"
    >>> b = "abd_33"
    >>> a is b
    True
    >>> c = "dd#"
    >>> d = "dd#"
    >>> c is d
    False
    >>> str1 = "aa"
    >>> str2 = "bb"
    >>> str1+str2 is "aabb"
    False
    >>> str1+str2 == "aabb"
    True
    

    字符串比较和同一性

    我们可以直接使用==,!=对字符串进行比较,是否含有相同的字符。
    我们使用 is / not is,判断两个对象是否同一个对象。比较的是对象的地址,即 id(obj1)是否和 id(obj2)相等。

    成员操作符

    in /not in 关键字,判断某个字符(子字符串)是否存在于字符串中。

    字符串常用方法汇总

    常用的查找方法

    我们以一段文本作为测试:
    a=’’‘我是高兴,今年 18 岁了,我在北京尚学堂科技上班。我的儿子叫高洛希,他 6 岁了。我是一个编程教育的普及者,希望影响 6000 万学习编程的中国人。我儿子现在也开始学习编程,希望他 18 岁的时候可以超过我’’’

    方法和使用示例说明结果
    len(a)字符串长度96
    a.startwith(‘我是高兴’)以指定字符串开头True
    a.endwith(‘过我’)以指定字符串结尾True
    a.find(‘高’)第一次出现指定字符串的位置2
    a.rfind(‘高’)最后一次出现指定字符串的位置29
    a.count(‘编程’)指定字符串出现了几次3
    a.isalnum()所有字符全是字母或数字False

    去除首尾信息

    我们可以通过 strip()去除字符串首尾指定信息。通过 lstrip()去除字符串左边指定信息,rstrip()去除字符串右边指定信息。
    【操作】去除字符串首尾信息

    >>> "*s*x*t*".strip("*")
    's*x*t'
    >>> "*s*x*t*".lstrip("*")
    's*x*t*'
    >>> "*s*x*t*".rstrip("*")
    '*s*x*t'
    >>> " sxt ".strip()
    'sxt'
    

    大小写转换

    编程中关于字符串大小写转换的情况,经常遇到。我们将相关方法汇总到这里。为了方便学习,先设定一个测试变量:a = “gaoqi love programming, loveSXT”

    示例说明结果
    a.capitalize()产生新的字符串,首字母大写‘Gaoqi love programming, love sxt’
    a.title()产生新的字符串,每个单词都首字母大写‘Gaoqi Love Programming, Love Sxt’
    a.upper()产生新的字符串,所有字符全转成大写‘GAOQI LOVE PROGRAMMING,LOVESXT’
    a.lower()产生新的字符串,所有字符全转成小写‘gaoqi love programming, love sxt’
    a.swapcase()产生新的,所有字母大小写转换‘GAOQI LOVE PROGRAMMING, LOVEsxt’

    格式排版

    center()、ljust()、rjust()这三个函数用于对字符串实现排版。示例如下:

    >>> a="SXT"
    >>> a.center(10,"*")
    '***SXT****'
    >>> a.center(10)
    ' SXT '
    >>> a.ljust(10,"*")
    'SXT*******'
    

    其他方法

    1. isalnum() 是否为字母或数字
    2. isalpha() 检测字符串是否只由字母组成(含汉字)。
    3. isdigit() 检测字符串是否只由数字组成。
    4. isspace() 检测是否为空白符
    5. isupper() 是否为大写字母
    6. islower() 是否为小写字母
    >>> "sxt100".isalnum()
    True
    >>> "sxt 尚学堂".isalpha()
    True
    >>> "234.3".isdigit()
    False
    >>> "23423".isdigit()
    True
    >>> "aB".isupper()
    False
    >>> "A".isupper()
    True
    >>> "\t\n".isspace()
    True
    

    字符串的格式化

    format()基本用法

    Python2.6 开始,新增了一种格式化字符串的函数 str.format(),它增强了字符串格式化的
    功能。
    基本语法是通过 {} 和 : 来代替以前的 % 。
    format 函数可以接受不限个参数,位置可以不按顺序。
    我们通过示例进行格式化的学习。

    >>> a = "名字是:{0},年龄是:{1}"
    >>> a.format("高淇",18)
    '名字是:高淇,年龄是:18'
    >>> a.format("高希希",6)
    '名字是:高希希,年龄是:6'
    >>> b = "名字是:{0},年龄是{1}。{0}是个好小伙"
    >>> b.format("高淇",18)
    '名字是:高淇,年龄是 18。高淇是个好小伙'
    >>> c = "名字是{name},年龄是{age}"
    >>> c.format(age=19,name='高淇')
    '名字是高淇,年龄是 19'
    

    我们可以通过{索引}/{参数名},直接映射参数值,实现对字符串的格式化,非常方便。

    填充与对齐

    填充常跟对齐一起使用
    ^、<、>分别是居中、左对齐、右对齐,后面带宽度
    :号后面带填充的字符,只能是一个字符,不指定的话默认是用空格填充

    >>> "{:*>8}".format("245")
    '*****245'
    >>> "我是{0},我喜欢数字{1:*^8}".format("高淇","666")
    '我是高淇,我喜欢数字**666***'
    

    数字格式化

    浮点数通过 f,整数通过 d 进行需要的格式化。案例如下:

    >>> a = "我是{0},我的存款有{1:.2f}"
    >>> a.format("高淇",3888.234342)
    '我是高淇,我的存款有 3888.23'
    

    其他格式,供大家参考:

    数字格式输出描述
    3.1415926{:.2f}3.14保留小数点后两位
    3.1415926{:+.2f}3.14带符号保留小数点后两位
    2.71828{:.0f}3不带小数
    5{:0>2d}05数字补零 (填充左边, 宽度为 2)
    5{:x<4d}5xxx数字补 x (填充右边, 宽度为 4)
    10{:x<4d}10xx数字补 x (填充右边, 宽度为 4)
    1000000{:,}1,000,000以逗号分隔的数字格式
    0.25{:.2%}25.00%百分比格式
    1000000000{:.2e}1.00E+09指数记法
    13{:10d}13右对齐 (默认, 宽度为 10)
    13{:<10d}13左对齐 (宽度为 10)
    13{:^10d}13中间对齐 (宽度为 10)

    可变字符串

    在 Python 中,字符串属于不可变对象,不支持原地修改,如果需要修改其中的值,智
    能创建新的字符串对象。但是,经常我们确实需要原地修改字符串,可以使用 io.StringIO
    对象或 array 模块。

    >>> import io
    >>> s = "hello, sxt"
    >>> sio = io.StringIO(s)
    >>> sio
    <_io.StringIO object at 0x02F462B0>
    >>> sio.getvalue()
    'hello, sxt'
    >>> sio.seek(7)
    7
    >>> sio.write("g")
    1
    >>> sio.getvalue()
    'hello, gxt'
    

    Python的字符串内建函数

    方法参数描述
    关于字母的内置函数
    capitalize()将字符串的第一个字符转换为大写
    title()NA单词都是以大写开始,其余字母均为小写
    upper()NA转换字符串中的小写字母为大写
    swapcase()NA将字符串中大写转换为小写,小写转换为大写
    max(str)str – 字符串方法返回字符串中最大的字母
    min(str)str – 字符串方法返回字符串中最小的字母
    关于判断的内置函数
    isalnum()字符串中只有字母或数字则返 回 True,否则返回 False
    isalpha()检测字符串是否只由字母组成。是则返回 True, 否则返回 False
    isdigit()字符串是否只由数字组成,是则返回 True 否则返回 False。
    islower()检测字符串是否由小写字母组成,是则返回 True,否则返回 False
    isnumeric()字符串是否只由数字组成。这种方法是只针对unicode对象。是返回 True, False
    isdecimal()字符串是否只包含十进制字符。这种方法只存在于unicode对象.是返回 True, False
    isspace()字符串是否只由空白字符组成。是返回 True, 否则False
    istitle()检测字符串中所有的单词拼写首字母是否为大写,且其他字母为小写。是返回 True, 否则False
    isupper()字符串中所有的字母是否都为大写 .是返回 True, 否则False
    替换
    replace(old, new[, max])old – 将被替换的子字符串。new – 新字符串,用于替换old子字符串。max – 可选字符串, 替换不超过 max 次把字符串中的 old(旧字符串) 替换成 new(新字符串),如果指定第三个参数max,则替换不超过 max 次。
    expandtabs(tabsize=8)tabsize – 指定转换字符串中的 tab 符号(’\t’)转为空格的字符数。把字符串中的 tab 符号(’\t’)转为空格,tab 符号(’\t’)默认的空格数是 8。
    maketrans(intab, outtab)intab – 字符串中要替代的字符组成的字符串。outtab – 相应的映射字符的字符串。用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。两个字符串的长度必须相同,为一一对应的关系。
    位置对齐
    zfill(width)width – 指定字符串的长度。原字符串右对齐,前面填充0。返回指定长度的字符串,原字符串右对齐,前面填充0。
    rjust(width[, fillchar])1.width – 指定填充指定字符后中字符串的总长度.2.fillchar – 填充的字符,默认为空格。返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。
    center(width[, fillchar])width – 字符串的总宽度。fillchar – 填充字符。返回一个指定的宽度 width 居中的字符串,fillchar 为填充的字符,默认为空格。
    ljust(width[, fillchar])width – 指定字符串长度。fillchar – 填充字符,默认为空格。返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
    检查查找
    startswith(substr, beg=0,end=len(string))str – 检测的字符串。substr – 指定的子字符串。strbeg – 可选参数用于设置字符串检测的起始位置。strend – 可选参数用于设置字符串检测的结束位置。用于检查字符串是否是以指定子字符串开头,如果是则返回 True,否则返回 False。如果参数 beg 和 end 指定值,则在指定范围内检查。
    endswith(suffix[, start[, end]])suffix – 该参数可以是一个字符串或者是一个元素。start – 字符串中的开始位置。end – 字符中结束位置。用于判断字符串是否以指定后缀结尾,如果以指定后缀结尾返回 True,否则返回 False。可选参数 “start” 与 “end” 为检索字符串的开始与结束位置。
    find(str, beg=0, end=len(string))str – 指定检索的字符串beg – 开始索引,默认为0。end – 结束索引,默认为字符串的长度检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,如果指定范围内如果包含指定索引值,返回的是索引值在字符串中的起始位置。如果不包含索引值,返回-1。
    rfind(str, beg=0 end=len(string))str – 查找的字符串beg – 开始查找的位置,默认为0end – 结束查找位置,默认为字符串的长度。返回字符串最后一次出现的位置,如果没有匹配项则返回-1
    index(str, beg=0, end=len(string))str – 指定检索的字符串beg – 开始索引,默认为0。end – 结束索引,默认为字符串的长度。检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,该方法与 python find()方法一样,只不过如果str不在 string中会报一个异常。
    rindex(str, beg=0 end=len(string))str – 查找的字符串beg – 开始查找的位置,默认为0end – 结束查找位置,默认为字符串的长度。返回子字符串 str 在字符串中最后出现的位置,如果没有匹配的字符串会报异常,你可以指定可选参数[beg:end]设置查找的区间。
    删除
    rstrip([chars])chars – 指定删除的字符(默认为空格)删除 string 字符串末尾的指定字符(默认为空格)
    lstrip([chars])chars – 指定删除的字符(默认为空格)删除 string 字符串开头的指定字符(默认为空格)
    strip([chars])chars – 移除字符串头尾指定的字符序列。用于移除字符串头尾指定的字符(默认为空格)或字符序列。
    拼接
    join(sequence)sequence – 要连接的元素序列。用于将序列中的元素以指定的字符连接生成一个新的字符串。
    分割
    split(str="", num=string.count(str))1.str – 分隔符,默认为所有的空字符,包括空格、换行(\n)、制表符(\t)等。2.num – 分割次数。默认为 -1, 即分隔所有。通过指定分隔符对字符串进行切片,如果第二个参数 num 有指定值,则分割为 num+1 个子字符串。
    返回元素列表
    splitlines([keepends])keepends – 在输出结果里是否去掉换行符(’\r’, ‘\r\n’, \n’),默认为 False,不包含换行符,如果为 True,则保留换行符。按照行(’\r’, ‘\r\n’, \n’)分隔,返回一个包含各行作为元素的列表,如果参数 keepends 为 False,不包含换行符,如果为 True,则保留换行符。
    计算数量
    count(sub, start= 0,end=len(string))sub – 搜索的子字符串start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
    len( s )s – 对象。返回对象(字符、列表、元组等)长度或项目个数。
    过滤
    1.translate(table) 2.bytes.translate(table[, delete]) 3.bytearray.translate(table[, delete])table – 翻译表,翻译表是通过 maketrans() 方法转换而来。 deletechars – 字符串中要过滤的字符列表。根据参数table给出的表(包含 256 个字符)转换字符串的字符,要过滤掉的字符放到 deletechars 参数中。
    编码解码
    bytes.decode(encoding=“utf-8”, errors=“strict”)encoding – 要使用的编码,如"UTF-8"。errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’,‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。以指定的编码格式解码 bytes 对象。默认编码为 ‘utf-8’。
    encode(encoding=‘UTF-8’,errors=‘strict’)encoding – 要使用的编码,如: UTF-8。errors – 设置不同错误的处理方案。默认为 ‘strict’,意为编码错误引起一个UnicodeError。 其他可能得值有 ‘ignore’, ‘replace’,‘xmlcharrefreplace’, ‘backslashreplace’ 以及通过 codecs.register_error() 注册的任何值。以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。
    展开全文
  • JS字符串常用方法汇总

    千次阅读 2019-03-13 21:53:54
    1、length获取字符串的长度 let myString = "hello kitty"; myString.length; // 输出11 2、indexOf(searchvalue,fromindex)在字符串中查找子字符串,如果存在则返回指定的子字符串值在字符串中首次...

    1、length获取字符串的长度

    let myString = "hello kitty";
    myString.length;  // 输出11
    

    2、indexOf(searchvalue,fromindex) 在字符串中查找子字符串,如果存在则返回指定的子字符串值在字符串中首次出现的位置,否则返回-1

    其中searchvalue(必需)规定需检索的字符串值。

    fromindex可选的整数参数。规定在字符串中开始检索的位置。合法取值是 0 到 stringObject.length - 1。如省略该参数,则将从字符串的首字符开始检索。

     let myString = "hello kitty";
    myString.indexOf('kitty');    // 6
    myString.indexOf('Hello');    //-1
    myString.indexOf('hello');    //0
    myString.indexOf('hello',3);    //-1

    3、lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置,在一个字符串中的指定位置从后向前搜索。

    let myString = "hello kitty";
    myString.lastIndexOf('hello')    // 0
    myString.lastIndexOf('world')    // -1
    myString.lastIndexOf('kitty')    // 6
    myString.lastIndexOf('kitty',3)    // -1

    4、slice(start,end) 方法可提取字符串的某个部分,并以新的字符串返回被提取的部分。

    start  要抽取片断的起始下标。如果是负数,则规定从字符串的尾部开始算起的位置。-1 指字符串的最后一个字符,-2 指倒数第二个字符,以此类推。

    end 要抽取片段的结尾下标。若未指定此参数,则要提取的是从 start 到原字符串结尾的字符串。如果是负数,则从字符串的尾部开始算起的位置。

    let myString = "hello kitty";
    myString.slice(0,5)    // "hello"
    myString.slice(6)    // "kitty"
    myString.slice(3,-1)    // "lo kitt"
    

    5、subbstring(start,stop) 方法用于提取字符串中介于两个指定下标之间的字符

    start:非负整数,规定截取子串的起始位置。stop:可选,非负整数,截取子串的结束位置,但不包括stop处的字符串

     let myString = "Hello kitty";
     myString.substring(1,5)    // "ello"
     myString.substring(3)    // "lo kitty"

    6、charAt() 方法返回指定索引的字符

    7、concat() 方法用于连接两个或多个字符串。返回连接后的新字符串。

    let myString = "Hello kitty";
    
    //charAt
    myString.charAt(6)    // "k"
    myString.charAt(7)    // "i"
    
    //concat()
    let str = "aabbcc"
    let str2 = " ccddeeff"
    myString.concat(str)    // "Hello kittyaabbcc"
    myString.concat(str,str2)    // "Hello kittyaabbcc ccddeeff"

    8、split() 方法用于把一个字符串分割成字符串数组

    let myString = "Hello kitty";
    myString.split("");    // ["H", "e", "l", "l", "o", " ", "k", "i", "t", "t", "y"]
    myString.split(" ");    // ["Hello", "kitty"]
    
    let str2 = "23:34:56:78";
    str2.split(":",3)     // ["23", "34", "56"]
    
    let str3 = "How,are,you,doing,today?"
    str3.split(",")    // ["How", "are", "you", "doing", "today?"]

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

    let myString = "Hello kitty";
    myString.replace(/kitty/,"world")    //  "Hello world"
    
    let name = "Doe, John";
    name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1");    // "John Doe"

    10、match() 方法可在字符串内检索指定的值,或找到一个或多个正则表达式的匹配。

    let myString = "hello kitty";
    myString.match("hello");    //hello
    myString.match("Hello");    //null
    
    let str = "2 plus 3 equal 5"
    str.match(/\d+/g)    //["2", "3", "5"]

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

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

    let myName = "My Name IS HAnmeimei"
    myName.toLowerCase();    // "my name is hanmeimei"
    myName.toUpperCase();    // "MY NAME IS HANMEIMEI"

    6、

    展开全文
  • JS数组、对象、字符串常用方法汇总

    千次阅读 2019-09-26 00:10:35
    JS数组常用方法总结前言操作数据功能快捷键插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的...

    前言

    2018年的中秋过后,开始从事前端,2018年9月25日实习到2019年5月15日转正,到今天刚好一年,但是前端能力上的提升却非常有限,这点得反思.得有危机意识.

    工作中,样式和结构写得多,js逻辑相对少,时不时用到数组相关的方法还得上网搜,于是今天整理下来,希望以后常见的方法不再需要上网搜

    Ctrl + F快速搜索定位

    数组常用方法

    ps:
    箭头函数函数体加了{} 就需要加上return 不然返回undefined
    箭头函数函数体不加{} 就可以不加return
    方法传入的回调函数有三个参数:(当前的数组元素, 当前索引值, 调用方法的数组)

    arrayObject.slice(start,end)

    slice() 方法可从已有的数组中返回选定的元素。
    请注意,该方法并不会修改数组,而是返回一个子数组。如果想删除数组中的一段元素,应该使用方法 Array.splice()。

    let arr = [1, 2, 3, 4, 5]
    let newArr = arr.slice(1)
    // arr= [1, 2, 3, 4, 5]   原数组保持不变
    // newArr = [2, 3, 4, 5] 返回新数组
    

    arrayObject.map()

    将数组中的每个元素调用一个提供的函数,结果作为一个新的数组返回不改变原来的数组

    let arr = [1, 2, 3, 4, 5]
    let newArr = arr.map(x => x * 2)
    // arr= [1, 2, 3, 4, 5]   原数组保持不变
    // newArr = [2, 4, 6, 8, 10] 返回新数组
    

    arrayObject.forEach()

    将数组中的每个元素调用一个提供的函数,没有返回值,返回值为undefined,不会改变原数组,注意和map方法区分

    let arr = [1, 2, 3, 4, 5]
    arr.forEach(x => x * 2)
    // arr = [1, 2, 3, 4, 5]  原数组不改变,注意和map区分
    

    arrayObject.filter()

    将所有元素进行判断,将满足条件的元素作为一个新的数组返回

    let arr = [1, 2, 3, 4, 5]
    let newArr = arr.filter(x => {
    	return x >= 3
    })
    // 箭头函数加了{} 就需要加上return 不然返回undefined
    // 箭头函数不加{} 就可以不加return
    let newArr = arr.filter(x => x >= 3)
    //newNum = [3, 4, 5] 满足条件的元素返回为一个新的数组
    
    //数组去重
    let myArr = [1,3,4,5,6,3,7,4];
    console.log(myArr.filter((value,index,arr)=>arr.indexOf(value)===index));
    //[ 1, 3, 4, 5, 6, 7 ]
    

    arrayObject.every()

    将所有元素进行判断返回一个布尔值,如果所有元素都满足判断条件,则返回true,否则为false:

    let arr = [1, 2, 3, 4, 5]
    const isLessThan4 = value => value < 4
    const isLessThan6 = value => value < 6
    arr.every(isLessThan4 ) //false
    arr.every(isLessThan6 ) //true
    

    arrayObject.some()

    将所有元素进行判断返回一个布尔值,如果存在元素都满足判断条件,则返回true,若所有元素都不满足判断条件,则返回false

    let arr= [1, 2, 3, 4, 5]
    const isLessThan4 = value => value < 4
    const isLessThan6 = value => value > 6
    arr.some(isLessThan4 ) //true
    arr.some(isLessThan6 ) //false
    

    arrayObject.reduce()

    将所有元素调用返回函数,返回值为最后结果,传入的值必须是函数类型

    let arr = [1, 2, 3, 4, 5]
    const add = (a, b) => {
    	console.log("a:" + a + ";b:" + b)
    	return a + b
    }
    let sum = arr.reduce(add)
    // a:1;b:2
    // a:3;b:3
    // a:6;b:4
    // a:10;b:5
    // console.log(sum) // 15  相当于累加的效果
    // 与之相对应的还有一个 Array.reduceRight() 方法,区别是这个是从右向左操作的
    

    arrayObject.push()

    在数组的后面添加新加元素,此方法改变了数组的长度

    let arr = [1, 2, 3, 4, 5]
    arr.push(6, 7, 8)
    console.log(arr) // [1, 2, 3, 4, 5, 6, 7, 8]
    

    arrayObject.pop()

    此方法删除数组最后一个元素,并返回数组,此方法改变了数组的长度

    let arr = [1, 2, 3, 4, 5]
    arr.pop()
    console.log(arr) //[1, 2, 3, 4]
    console.log(arr.length) //4
    

    arrayObject.shift()

    此方法删除数组第一个元素,并返回数组,此方法改变了数组的长度

    let arr = [1, 2, 3, 4, 5]
    arr.shift()
    console.log(arr) // [2, 3, 4, 5]
    console.log(arr.length) // 4 
    

    arrayObject.unshift()

    此方法是将一个或多个元素添加到数组的开头,并返回新数组的长度:

    let arr = [1, 2, 3, 4, 5]
    arr.unshift(6, 7)
    console.log(arr) //[6, 7, 1, 2, 3, 4, 5]
    console.log(arr.length) //7
    

    Array.isArray()

    判断一个对象是不是数组,返回的是布尔值

    let str1 = 'hello world'
    let arr1 = ['hello', 'world']
    Array.isArray(str1) // false
    Array.isArray(arr1) // true
    

    arrayObject.concat()

    此方法可以将多个数组拼接成一个数组:
    “concat creates a new array consisting of the elements in the object on which it is called, followed in order by, for each argument, the elements of that argument (if the argument is an array) or the argument itself (if the argument is not an array).”
    concat
    如果concat方法的参数是一个元素,该元素会被直接插入到新数组中;如果参数是一个数组,该数组的各个元素将被插入到新数组中;

    let arr1 = [1, 2, 3]
    arr2 = [4, 5]
    let arr = arr1.concat(arr2)
    console.log(arr)//[1, 2, 3, 4, 5]
    

    二维数组降维

    let arr = [1, 2, 3, [4, 5, 6], 7, 8, [9, 10]];
    function reduceDimen(arr) {
      let reduce = [];
      for (let i = 0; i < arr.length; i++) {
        reduce = reduce.concat(arr[i]);
      }
      return reduce;
    }
    reduceDimen(arr); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    

    arrayObject.toString()

    此方法将数组转化为字符串

    let arr = [1, 2, 3, 4, 5];
    let str = arr.toString()
    console.log(str)// '1,2,3,4,5'
    

    arrayObject.join()

    此方法也是将数组转化为字符串

    let arr = [1, 2, 3, 4, 5];
    let str1 = arr.join()
    let str2 = arr.join(',')
    let str3 = arr.join('##')
    console.log(str1) // '1,2,3,4,5'   默认分隔符为,
    console.log(str2)// '1,2,3,4,5'
    console.log(str3)// '1##2##3##4##5'
    // 可以跟toString()对比
    

    arrayObject.splice(开始删除的位置, 删除的个数,删除后新插入的元素)

    这方法可以实现增删改

    该方法会改变原始数组

    let arr = [1, 2, 3, 4, 5];
    let arr1 = arr.splice(2, 0 'haha')
    let arr2 = arr.splice(2, 3)
    let arr1 = arr.splice(2, 1 'haha')
    console.log(arr1) //[1, 2, 'haha', 3, 4, 5]新增一个元素
    console.log(arr2) //[1, 2] 删除三个元素
    console.log(arr3) //[1, 2, 'haha', 4, 5] 替换一个元素
    

    arrayObject.sort()

    这方法可以将数组元素排序,传进一个函数,函数带两个参数
    第一参数a, 第二参数b
    a-b升序 b-a降序

    // 升序
    let arr = [77, 99, 115, 135, 147, 191, 197, 219, 221, 227, 229, 233, 237, 269, 30, 189, 63, 87, 121, 143, 201, 211, 243, 12, 17, 9, 171, 279, 23, 24, 31, 34, 35, 37, 53, 55, 59, 60, 61, 62, 67, 68, 71, 75, 89, 91, 95, 107, 109, 123, 137, 139, 149, 165, 173, 175, 185, 205, 213, 217, 225, 239, 293, 294, 275, 296, 297]
    arr.sort((a,b) => {
    	return a - b
    	})
    console.log(arr) 
    // [9, 12, 17, 23, 24, 30, 31, 34, 35, 37, 53, 55, 59, 60, 61, 62, 63, 67, 68, 71, 75, 77, 87, 89, 91, 95, 99, 107, 109, 115, 121, 123, 135, 137, 139, 143, 147, 149, 165, 171, 173, 175, 185, 189, 191, 197, 201, 205, 211, 213, 217, 219, 221, 225, 227, 229, 233, 237, 239, 243, 269, 275, 279, 293, 294, 296, 297]
    
    // 降序
    arr.sort((a, b) => {
    	return b - a
    	})
    console.log(arr) 
    // [297, 296, 294, 293, 279, 275, 269, 243, 239, 237, 233, 229, 227, 225, 221, 219, 217, 213, 211, 205, 201, 197, 191, 189, 185, 175, 173, 171, 165, 149, 147, 143, 139, 137, 135, 123, 121, 115, 109, 107, 99, 95, 91, 89, 87, 77, 75, 71, 68, 67, 63, 62, 61, 60, 59, 55, 53, 37, 35, 34, 31, 30, 24, 23, 17, 12, 9]
    

    arrayObject.find()

    此方法返回通过函数判断的数组第一个元素的值。

    let arr1 = [1, 2, 3, 4]
    let str = arr1.find((x) => {
    	return x > 2
    	})
    console.log(str ) // 3
    // 如果没有符合条件的元素 返回undefined
    

    arrayObject.findIndex()

    findIndex()与find()的使用方法相同,只是当条件为true时findIndex()返回的是索引值,而find()返回的是元素。如果没有符合条件元素时findIndex()返回的是-1,而find()返回的是undefined。

    const bookArr=[
        {
            id:1,
            bookName:"三国演义"
        },
        {
            id:2,
            bookName:"水浒传"
        },
        {
            id:3,
            bookName:"红楼梦"
        },
        {
            id:4,
            bookName:"西游记"
        }
    ];
    var i=bookArr.findIndex((value)=>value.id==4);
    console.log(i);// 3
    var i2=bookArr.findIndex((value)=>value.id==100);
    console.log(i2);// -1
    

    arrayObject.includes()

    用来判断一个数组是否包含一个指定的值,如果是返回 true,否则false。

    let site = ['runoob', 'google', 'taobao']
    site.includes('runoob') // true 
    site.includes('baidu')  // false
    

    arrayObject.reverse()

    用于颠倒数组中元素的顺序

    var arr = new Array(3)
    arr[0] = "George"
    arr[1] = "John"
    arr[2] = "Thomas"
    
    document.write(arr + "<br />") // George,John,Thomas
    document.write(arr.reverse()) // Thomas,John,George
    

    arrayObject.fill(value, start, end)

    fill() 方法用于将一个固定值替换数组的元素。

    value	必需。填充的值。
    start	可选。开始填充位置。
    end 	可选。停止填充位置 (默认为 array.length)
    
    var fruits = ["Banana", "Orange", "Apple", "Mango"];
    fruits.fill("Runoob", 2, 4); // ["Banana", "Orange", "Runoob", "Runoob"]
    

    Array.from()

    Array.from()就是将一个类数组对象或者可遍历对象转换成一个真正的数组。(ES6)

    let arrayLike = {
        0: 'tom', 
        1: '65',
        2: '男',
        3: ['jane','john','Mary'],
        'length': 4
    }
    let arr = Array.from(arrayLike)
    console.log(arr) // ['tom','65','男',['jane','john','Mary']]
    

    对象常用方法

    Object.keys()

    会返回一个由一个给定对象的自身可枚举属性组成的数组,数组中属性名的排列顺序和使用 for…in 循环遍历该对象时返回的顺序一致 。

    // simple array
    var arr = ['a', 'b', 'c'];
    console.log(Object.keys(arr)); // console: ['0', '1', '2']
     
    // array like object
    var obj = { 0: 'a', 1: 'b', 2: 'c' };
    console.log(Object.keys(obj)); // console: ['0', '1', '2']
     
    // array like object with random key ordering
    var anObj = { 100: 'a', 2: 'b', 7: 'c' };
    console.log(Object.keys(anObj)); // console: ['2', '7', '100']
     
    // getFoo is a property which isn't enumerable
    var myObj = Object.create({}, {
      getFoo: {
        value: function () { return this.foo; }
      } 
    });
    myObj.foo = 1;
    console.log(Object.keys(myObj)); // console: ['foo']
    

    Object.values()

    方法返回一个给定对象自身的所有可枚举属性值的数组,值的顺序与使用for…in循环的顺序相同 ( 区别在于 for-in 循环枚举原型链中的属性 )。

    var obj = { foo: 'bar', baz: 42 };
    console.log(Object.values(obj)); // ['bar', 42]
     
    // array like object
    var obj = { 0: 'a', 1: 'b', 2: 'c' };
    console.log(Object.values(obj)); // ['a', 'b', 'c']
     
    // array like object with random key ordering
    // when we use numeric keys, the value returned in a numerical order according to the keys
    var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
    console.log(Object.values(an_obj)); // ['b', 'c', 'a']
     
    // getFoo is property which isn't enumerable
    var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
    my_obj.foo = 'bar';
    console.log(Object.values(my_obj)); // ['bar']
     
    // non-object argument will be coerced to an object
    console.log(Object.values('foo')); // ['f', 'o', 'o']
    

    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 }
    

    Object.create()

    创建一个新对象,使用现有的对象来提供新创建的对象的__proto__。

    const person = {
    isHuman: false,
    printIntroduction () {
    	console.log(`My name is ${this.name},Am I Human? ${this.isHuman}`)
    	}
    }
    const me = Object.create(person)
    me.name = "Matthew"; // "name" is a property set on "me", but not on "person"
    me.isHuman = true; // inherited properties can be overwritten
     
    me.printIntroduction();
    // expected output: "My name is Matthew. Am I human? true"
    

    Object.defineProperty()

    直接在一个对象上定义新的属性或修改现有属性,并返回该对象

    一般通过为对象的属性赋值的情况下,对象的属性可以修改也可以删除,但是通过Object.defineProperty()定义属性,通过描述符的设置可以进行更精准的控制对象属性

    Object.defineProperty(obj, prop, desc)
    
    • obj 需要定义属性的当前对象
    • prop 当前需要定义的属性名
    • desc 属性描述符,是一个对象

    描述符中的某些属性被省略,会使用以下默认规则
    在这里插入图片描述
    存取描述符 --是由一对 getter、setter 函数功能来描述的属性
    get:一个给属性提供getter的方法,如果没有getter则为undefined。该方法返回值被用作属性值。默认为undefined。
    set:一个给属性提供setter的方法,如果没有setter则为undefined。该方法将接受唯一参数,并将该参数的新值分配给该属性。默认值为undefined。

    let Person = {}
    let temp = null
    Object.defineProperty(Person, 'name', {
      get: function () {
        return temp
      },
      set: function (val) {
        temp = val
      }
    })
    Person.name // null
    Person.name = 'Web泓' // Web泓
    

    最近看Vue元源码看到了上面的内容,Vue之所以可以通过this.message来访问到data选项中定义的message变量,实现方法中用到了Object.defineProperty()方法

    部分源码如下,

    export function proxy (target: Object, sourceKey: string, key: string) {
      sharedPropertyDefinition.get = function proxyGetter () {
        return this[sourceKey][key]
      }
      sharedPropertyDefinition.set = function proxySetter (val) {
        this[sourceKey][key] = val
      }
      Object.defineProperty(target, key, sharedPropertyDefinition)
    }
    

    target参数可以理解为Vue实例对象
    sourceKey参数可以理解为data选项
    key参数可以理解为data选项里定义的变量名

    有兴趣可以看下面的博客
    Vue源码学习(持续更新中)

    Object.entries()

    返回一个给定对象自身可枚举属性的键值对数组,其排列与使用 for…in 循环遍历该对象时返回的顺序一致(区别在于 for-in 循环也枚举原型链中的属性)

    const obj = { foo: 'bar', baz: 42 };
    console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
    
    // array like object
    const obj = { 0: 'a', 1: 'b', 2: 'c' };
    console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
    
    // array like object with random key ordering
    const anObj = { 100: 'a', 2: 'b', 7: 'c' };
    console.log(Object.entries(anObj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]
    
    // getFoo is property which isn't enumerable
    const myObj = Object.create({}, { getFoo: { value() { return this.foo; } } });
    myObj.foo = 'bar';
    console.log(Object.entries(myObj)); // [ ['foo', 'bar'] ]
    
    // non-object argument will be coerced to an object
    console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]
    
    // iterate through key-value gracefully
    const obj = { a: 5, b: 7, c: 9 };
    for (const [key, value] of Object.entries(obj)) {
      console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
    }
    
    // Or, using array extras
    Object.entries(obj).forEach(([key, value]) => {
    console.log(`${key} ${value}`); // "a 5", "b 7", "c 9"
    });
    

    Object.freeze()

    可以冻结一个对象。一个被冻结的对象再也不能被修改;冻结了一个对象则不能向这个对象添加新的属性,不能删除已有属性,不能修改该对象已有属性的可枚举性、可配置性、可写性,以及不能修改已有属性的值。此外,冻结一个对象后该对象的原型也不能被修改。freeze() 返回和传入的参数相同的对象。

    const object1 = {
      property1: 42
    };
     
    const object2 = Object.freeze(object1);
     
    object2.property1 = 33;
    // Throws an error in strict mode
     
    console.log(object2.property1);
    // expected output: 42
    

    Object.fromEntries()

    把键值对列表转换为一个对象。

     Map 转化为 Object
    通过 Object.fromEntries, 可以将 Map 转化为 Object:
     
    const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
    const obj = Object.fromEntries(map);
    console.log(obj); // { foo: "bar", baz: 42 }
     
    Array 转化为 Object
    通过 Object.fromEntries, 可以将 Array 转化为 Object:
     
    const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
    const obj = Object.fromEntries(arr);
    console.log(obj); // { 0: "a", 1: "b", 2: "c" }
    对象转换为Object
    Object.fromEntries 是 Object.entries() 的反转函数, 借用 array manipulation methods 可以转换对象,如下:
     
    const object1 = { a: 1, b: 2, c: 3 };
     
    const object2 = Object.fromEntries(
      Object.entries(object1)
      .map(([ key, val ]) => [ key, val * 2 ])
    );
     
    console.log(object2);
    // { a: 2, b: 4, c: 6 }
    

    Object.is()

    判断两个值是否是相同的值

    Object.is('foo', 'foo');     // true
    Object.is(window, window);   // true
     
    Object.is('foo', 'bar');     // false
    Object.is([], []);           // false
     
    var foo = { a: 1 };
    var bar = { a: 1 };
    Object.is(foo, foo);         // true
    Object.is(foo, bar);         // false
     
    Object.is(null, null);       // true
     
    // 特例
    Object.is(0, -0);            // false
    Object.is(-0, -0);           // true
    Object.is(NaN, 0/0);         // true
    

    Object.isFrozen()

    判断一个对象是否被冻结

    // 使用Object.freeze是冻结一个对象最方便的方法.
    var frozen = { 1: 81 };
    Object.isFrozen(frozen) //=== false
    Object.freeze(frozen);
    Object.isFrozen(frozen) //=== true
     
    // 一个冻结对象也是一个密封对象.
    Object.isSealed(frozen) //=== true
     
    // 当然,更是一个不可扩展的对象.
    Object.isExtensible(frozen) //=== falseES5 中,如果参数不是一个对象类型,将抛出一个TypeError异常。在 ES2015 中,非对象参数将被视为一个冻结的普通对象,因此会返回true。
     
    Object.isFrozen(1);
    // TypeError: 1 is not an object (ES5 code)
     
    Object.isFrozen(1);
    // true                          (ES2015 code)
    

    字符串常用方法

    concat()

    将两个或多个字符的文本组合起来,返回一个新的字符串。

    var a = "hello";
    var b = ",world";
    var c = a.concat(b); // c = "hello,world"
    

    indexOf(searchvalue, fromindex)

    返回字符串中一个子串第一处出现的索引(从左到右搜索)。如果没有匹配项,返回 -1 。

    var a = "hello";
    var index1 = a.indexOf("l");
    //index1 = 2
    var index2 = a.indexOf("l",3);
    //index2 = 3
    

    charAt(index)

    返回指定位置的字符,index范围为从 0 到 length() - 1,否则返回空字符串.

    var a = "hello";
    var get_char = a.charAt(0);
    //get_char = "h"
    

    string.lastIndexOf(searchvalue,start)

    返回字符串中一个子串最后一处出现的索引(从右到左搜索),如果没有匹配项,返回 -1 。

    var a = "hello";
    var index1 = a.lastIndexOf('l');
    //index1 = 3
    var index2 = a.lastIndexOf('l',2)
    //index2 = 2
    
    // 这里好像有点问题 试了好像不是从右到左搜索
    

    match

    检查一个字符串匹配一个正则表达式内容,如果没有匹配返回 null。

    var a = "hello";
    var b = ",world";
    var re = new RegExp(/^\w+$/);
    var is_alpha1 = a.match(re);
    //is_alpha1 = "hello"
    var is_alpha2 = b.match(re);
    //is_alpha2 = null 
    
    // 这里正则表达式 还得补补 
    

    string.substring(start,stop)

    返回字符串的一个子串,传入参数是起始位置和结束位置。

    var a = "hello";
    var sub_string1 = a.substring(1);
    //sub_string1 = "ello"
    var sub_string2 = a.substring(1,4);
    //sub_string2 = "ell"
    

    string.substr(start,length)

    返回字符串的一个子串,传入参数是起始位置和长度

    var a = "hello";
    var sub_string1 = a.substr(1);
    //sub_string1 = "ello"
    var sub_string2 = a.substr(1,4);
    //sub_string2 = "ello"
    

    string.replace(regexp/substr, replacement)

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

    var a = "hello";
    var b = ',World'
    var re = new RegExp(/^\w+$/);
    var result1 = a.replace(re,"Hello");
    //result1 = "Hello"
    var result2 = a.replace('o',"o, Hello");
    //result2 = "hello, Hello"
    

    string.search()

    search() 方法用于检索字符串中指定的子字符串,或检索与正则表达式相匹配的子字符串,否则返回 -1 。

    var a = "hello";
    var b = ",world";
    var re = new RegExp(/^\w+$/);
    var index1 = a.search(re);
    //index1 = 0
    var index2 = b.search(re);
    //index2 = -1
    
    

    ###. string.slice(start, end)
    提取字符串的一部分,并返回一个新字符串(与 substring 相同)。
    从start开始到end,不包括end

    var a = "hello";
    var sub_string1 = a.slice(1);
    //sub_string1 = "ello"
    var sub_string2 = a.slice(1,4);
    //sub_string2 = "ell"
    

    从身份证获取出生年月日,性别(第17位,偶数为男,奇数为女)

    const idcard = '445281199508071556'
    const year = idcard.slice(6, 10) // 1995
    const month = idcard.slice(10, 12) // 08
    const day = idcard.slice(12, 14) // 07
    const sex = (idcard.slice(16, 17)) % 2 === 0 ? '女' : '男' // 男
    

    string.split(separator,howmany)

    通过将字符串划分成子串,将一个字符串做成一个字符串数组。
    separator:字符串或正则表达式,从该参数指定的地方分割
    howmany:该参数可指定返回的数组的最大长度。如果设置了该参数,返回的子串不会多于这个参数指定的数组。如果没有设置该参数,整个字符串都会被分割,不考虑它的长度。

    var a = "hello";
    var arr1 = a.split("");
    //arr1 = [h,e,l,l,o]
    

    string.length()

    返回字符串的长度,所谓字符串的长度是指其包含的字符的个数。

    var a = "hello";
    var len = a.length();
    //len = 5
    

    string.toLowerCase()

    将整个字符串转成小写字母。

    var a = "hello";
    var lower_string = a.toLowerCase();
    //lower_string = "hello"
    

    string.toUpperCase()

    将整个字符串转成大写字母。

    var a = "hello";
    var upper_string = a.toUpperCase();
    //upper_string = "HELLO"
    

    string.includes()

    用于判断字符串是否包含指定的子字符串。(区分大小写)

    let str = "Hello world, welcome to the Runoob。";
    let n = str.includes("world"); // true
    

    string.startsWith()

    用于判断字符串是否以指定的子字符串开头。(区分大小写)

    let str = "Hello world, welcome to the Runoob。";
    let n = str.startsWith("h"); // true
    

    string.endsWith()

    用于判断字符串是否以指定的子字符串结尾。(区分大小写)

    let str = "Hello world, welcome to the Runoob";
    let n = str.endsWith("Runoob"); // true
    

    string.padStart()

    ES2017 引入了字符串补全长度的功能。如果某个字符串不够指定长度,会在头部或尾部补全。padStart()用于头部补全,padEnd()用于尾部补全。

    • padStart()和padStart()一共接受两个参数,第一个参数用来指定字符串的最小长度,第二个参数是用来补全的字符串
    • 如果原字符串的长度,等于或大于指定的最小长度,则返回原字符串。
    • 如果用来补全的字符串与原字符串,两者的长度之和超过了指定的最小长度,则会截去超出位数的补全字符串。
    • 如果省略第二个参数,默认使用空格补全长度。
    'x'.padStart(5, 'ab') // 'ababx'
    'x'.padStart(4, 'ab') // 'abax'
    

    string.padEnd()

    'x'.padEnd(5, 'ab') // 'xabab'
    'x'.padEnd(4, 'ab') // 'xaba'
    '1304909'.padEnd(11, '0') // '13049090000'
    

    结尾

    这些都是比较常用的数组方法,有时候用得少了,再次用时就会忘记,需要上网搜,现在整理一下,希望这些常用的数组方法可以不用再搜

    参考

    1. js中数组常用方法总结
    2. js对象方法大全
    3. js 字符串常用方法
    展开全文
  • 字符串常用方法

    千次阅读 多人点赞 2020-12-07 20:56:02
    目录一、字符串遍历二、字符串查找的方法(1)indexOf()和lastIndexOf()(2)search()查找三、元素替换方法----replace()方法四、字符串去空-----trim()方法五、字符串拼接方法(1)使用+号来进行字符串拼接(2)...
  • C# 字符串常用方法的详细讲解和应用

    千次阅读 多人点赞 2021-07-13 22:15:08
    字符串使用频率特别特别的频繁,基本每次写代码都得使用到,比如读取到的文本文件赋值给字符串,然后在使用字符串去分析拿到想要的内容,接收用户输入的内容等,拿到内容我们就可以使用他里面的方法字符串进行分析...
  • 常用字符串方法大全

    千次阅读 2020-11-15 11:10:28
    JavaScript中字符串作为基本类型,它为我们提供了很多好用的API,本期就来总结一下一些常见的字符串方法字符串方法按照功能来划分,可分为增删改查四个部分 写在前面:了解一个方法,我们可以通过三个方面,1....
  • JavaScript字符串常用方法

    千次阅读 2021-02-08 13:11:35
    charAt() concat() indexOf(), lastIndexOf() localeCompare() slice() split() substr(), substring() match() replace() search() toLocaleLowerCase(), toLocaleUpperCase(),toLowerCase(),... 模板字符
  • JS字符串常用方法总结

    千次阅读 多人点赞 2020-06-02 16:00:26
    JS字符串常用方法总结 1、toLowerCase(): 把字符串转为小写,返回新的字符串。 var str="Hello World"; var str1=str.toLowerCase(); console.log(str); //Hello World console.log(str1); //hello world 2、...
  • JavaScript常用的几种字符串方法

    千次阅读 多人点赞 2021-04-07 00:22:08
    JavaScript常用的几种字符串方法 字符串是一种只读数据,只能查 常用的几种字符串方法: 1、charAt:根据指定的下标获取到对应的字符; 2、charCodeAt:根据指定的下标获取到字符对应的阿斯克码;(底部有ASCII对照...
  • 终于有时间总结一下常用字符串方法了, 好多时候 老是想用 却 老是忘记。 烦了毁灭吧! 跳过 像 一些length的属性 我就不记录了 prototype 允许向对象添加属性和方法 constructor 返回创建字符串属性的函数 字符...
  • js裁剪(分隔)字符串常用方法

    万次阅读 2022-02-07 09:19:12
    前言:在开发中我们经常会遇到对于字符串的部分取舍问题,今天我们来看看3中常用方法来解决这个问题。 目录:一.Slice1.两个参数:2.参数为负:3.一个参数:4.注意:二.Substring1.两个参数:2.一个参数:3.注意...
  • java字符串常用方法总结

    万次阅读 2019-02-11 11:19:25
    java常见方法函数的实例,代码及运行结果如下: (不理解的看注释) public static void main(String args[]){ String str1 = &amp;quot;Hello World&amp;quot;; String str2 = &amp;quot;Hello World...
  • C# 查找字符串常用方法

    万次阅读 2018-08-15 19:36:50
    Indexof(Char C): 找到第一个字符c的index,如果没找到返回-1 Indexof(string str): 找到str的index,如果没找到返回-1 ...LastIndexof(string str): 返回当前字符或字符串的最后一个匹配项位置 具体如下: ...
  • 总结 | Java字符串常用操作(方法)

    千次阅读 多人点赞 2020-05-03 18:17:43
    创建字符串 创建一个String对象,并初始化一个值。 String类是不可改变的,一旦创建了一个String对象,它的值就不能改变了。 如果想对字符串做修改,需要使用StringBuffer&StringBuilder类。 //直接创建方式 ...
  • 字符串常用方法总结

    万次阅读 多人点赞 2017-12-07 10:16:20
    自己在写js的时候,经常会用到的字符串的一些方法,这里总结了一下我自己常用到的方法,分享一下。 先定义一个字符串 var str = "abbcalgldkjgldgehlgjldf"; 1,indexOf(),返回指定字符创第一次出现的位置。 str...
  • Java中的字符串及其中的常用方法

    万次阅读 多人点赞 2019-04-23 15:41:09
    字符串是常量,一旦被创建就不能改变,这是因为字符串的值是存放在方法区的常量池里面,但是引用可以改变。 字符串字面值"ab"也可以看成是一个字符串对象。 内存图如下(例子) 这样可以更好的理解字符串常量...
  • 功能:使用一个指定的分隔符把一个字符串分割存储到数组 例子: str=”jpg|bmp|gif|ico|png”; arr=theString.split(”|”); //arr是一个包含字符值”jpg”、”bmp”、”gif”、”ico”和”png”的数组 函数:Join()...
  • Csharp进阶:字符串常用方法

    万次阅读 多人点赞 2017-08-19 20:38:38
    字符串常用方法总结
  • JS分割字符串常用方法总结

    千次阅读 2018-10-10 20:39:06
    定义:substring(start,end)表示从start到end之间的字符串,包括start位置的字符但是不包括end位置的字符。 功能:字符串截取,比如想从"MinidxSearchEngine"中得到"Minidx"就要用到substring...
  • Java中字符串常用方法

    万次阅读 多人点赞 2018-01-02 15:11:27
    1、equals():比较两个字符串是否相等它具有如下的一般形式:boolean equals(Object str)str是一个用来与调用字符串(String)对象做比较的字符串(String)对象。如果两个字符串具有相同的字符和长度,它返回true,...
  • 常用JS——string字符串方法

    万次阅读 多人点赞 2018-08-21 10:47:36
    一、关于字符串分割 1、slice(start,end); 关于这个方法,一定要搞懂四个关键点: (1)截取字符串时不包括下标为end的元素。...其中第3点其实就是在JavaScript中字符串和数组都具有这个方法,它们...
  • 目录 1.0 capitalize()函数 2.0 title()函数 3.0swapcase()函数 4.0 lower()函数 5.0upper()函数 6.0 casefold()函数 7.0 center()函数 8.0ljust()函数 9.0 rjust()函数 ...12.0 encode()...
  • java中获取随机数、随机字符串常用方法

    万次阅读 多人点赞 2016-07-22 17:23:24
    在日常工作当中,经常会有需要获取随机数、随机字符的需求,如:生成随机数验证码、生成随机字符串签名、生成2个数字之间的随机数等。这些场景其根本都在于随机数的生成,本文将对java当中生成随机数、随机字符等...
  • JS截取字符串常用方法详细整理

    万次阅读 2017-12-20 19:59:19
    功能:使用一个指定的分隔符把一个字符串分割存储到数组  例子:  str=”jpg|bmp|gif|ico|png”;  arr=theString.split(”|”);  //arr是一个包含字符值”jpg”、”bmp”、”gif”、”ico”和”png”的数组  ...
  • Groovy字符串及其常用方法

    万次阅读 多人点赞 2016-10-22 23:27:28
    文本文字以字符链的形式表示被称作字符串。脚本语言在字符串处理方面比主流的应用程序开发语言做的更好。Groovy就提供了许多附加的特性。在Groovy中有两种风格的字符串:String(java.lang.String)和GString...
  • 1. 字符串对齐——center、ljust、rjust 通过在两边填充字符(默认空格)让字符串居中、左对齐、右对齐。 2. 查找子串——find、index、count find:查找子串,返回子串第一个字符的索引,如果没找到返回-1。 ...
  • 字符串的find方法

    千次阅读 2020-02-21 22:57:27
    我们在Excel中,会使用find函数查找某些元素在一个字符串中的坐标,这种方法在python的字符串中也可以使用,我们使用以下代码来查找字母v在字符串中的坐标。 s = "I love python!" num = s.find('v') print(num) ...
  • Python常用字符串操作

    千次阅读 2021-03-18 00:49:56
    我们在学习Python语言时会遇到各种各样的字符串方法处理,下面列出几种常用字符串方法,供大家参考1.字符串首字母大写2.统计字符串中某个字母的个数统计字符串中某个字母的个数又分两种情况,在整个字符串中统计和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,247,577
精华内容 499,030
关键字:

字符串常用方法

友情链接: TouchScript-9.0.zip