一：代码如下
 
 --定义变量
  Dim J As Long  
  J = 0
  Dim sSQL As String
  Dim rs As ADODB.Recordset  ’--定义Recordset对象
  Dim sList() As String    '--定义数组      
  
  sSQL = "select WarehouseId from paraDBWarehouseId "     
  Set rs = K3Conn.Execute(sWarehouseIdSQL)
           
  While Not rs.EOF
       ReDim Preserve  sList(0 To J) As String '--重定义数组大小
       sList(J) = rs("name")           '--name 为表中的字段名
       J = J + 1
       rs .MoveNext
 Wend

  For c = 0 To UBound(sList)
       print sList(c)          
  Next c
 
二：笔记：
 
dim是声明私有变量的意思，另外还有公有变量和保护型变量，分别是public和private.
ReDim 语句用来定义或重定义原来已经用带空圆括号（没有维数下标）的 Private、Public 或 Dim 语句声明过的动态数组的大小。
EOF：指当前记录位置位于Recordset对象的最后一个记录之后。
UBound 函数返回数组中指定数组维的最大下标值。

  
 

  '如要输入表示    "aa"
 
 
 

  '理论表达方式如：
 
 
 

  a=""aa""  ‘但会出错
 
 
 

  'ASC码可能达到效果
 
 
 

  kk=chr(34)   &   "aa "   &   chr(34) 
 
 

 

   
 
 
 
相关文章参考：
 
 

   
 
 
 
※VB中的指针技术
 
 
※一个VB数组指针类
 
 
※VB Environ系统环境变量函数大全
 
 
※变量、常数和数据类型及过程概述 
 
 
※VB小技巧：字符变量中双引号的输入 
 
 
※深入了解VB中的变量和指针
 
 

   
 
 
 
 
 
VB部分相关文章推荐  
 
 
 
 
 
 
 
 
 
※VB快速读取 TextBox 第 N 行的资料
 
 
※VB禁止使用 Alt-Tab 或 Ctrl-Alt-Del
 
 
※生成迷宫的程序
 
 
※另一方法转换大小写
 
 
※VB控件注册 - 利用资源文件将dll、ocx打包进exe文件
 
 
※VB利用资源文件进行工作
 
 
※[转]vb高效编程（优化）
 
 
※VB阳历转阴历
 
 
※纯VB代码取得硬盘的物理序列号
 
 
※VB获得磁盘的文件系统
 
 
※做VB的，经常注册和反注册OCX控件和DLL链
 
 
※VB从程序中生成Exe文件
 
 
※VB6监视/操作剪贴板示例(VB6.0代码)
 
 
※VB6里自动提交/自动填表的一种相对通用的方案
 
 
※VB移动没有标题的窗体
 
 
※VB随机字母的函数
 
 
※VB删除带子文件夹和文件的文件夹
 
 
※VB怎样屏蔽 Alt+F4键
 
 
※VB 隐藏进程
 
 
※vb屏蔽文本框点右键时的弹出菜单
 
 
※VB手控Combobox的打开或收起
 
 
※在VB中INI文件的读写、删除（对中文支持很好）
 
 
※vb全局热键的写法（占很少的资源）
 
 
※vb取消文本框的粘贴功能
 
 
※VB常用文件操作类
 
 
※VB获取特殊文件夹
 
 
※VB获取windows各常用目录的函数（模块）
 
 
※VB生成太极图
 
 
※VB:常用内部函数大全,你会了几个呢?
 
 
※vb中SendMessage函数
 
 
※精简VB程序的代码
 
 
※VB:将数字转换为大写中文
 
 
※VB:设定 MsgBox 在若干时间之后若无回应则自动关闭
 
 
※VB:读取及设定NumLock/CapsLock/ScrollLock的值
 
 
※VB:您知道 Mid$ 函量可以放在 '=' 的左方吗
 
 
※VB后台获得按键,并执行自己的函数(非钩子及热键)
 
 
※VB:将短文件名格式转成长文件名
 
 
※在vb中使用Iphlpapi.dll获取网络信息(上）
 ※
 在vb中使用Iphlpapi.dll获取网络信息(下）  
 

  
 

 
 
 

 
 ★VB小技巧：字符变量中双引号的输入  
 
★VB将自定义资源中的文件释放出来 
 
 
★VB在菜单上增加图标 
 
 
★Visual Basic 十年风云 
 
 
★VB表格控件总览与例程分析 
 
 
★利用VB函数Dir()实现递归搜索目 
 
 
★Visual Basic里与Print有关的函数 
 
 
★VB输入文本文件实现右对齐 
 
 
★VB查找替代字符串的函数 
 
 
★vb 换行气泡提示类
 
 
 
 
 
  

    
   更多精彩>>>
  
 

 

  
 
 

  
阅读 PEP 是理解 Python 特性的绝好方式。Python 3.8 引入了赋值表达式，它是什么？怎么用？有什么限制？话不多说，直接看 PEP。
 
 

 
一、简介
 
本提案建议在 Python 中增加 := 运算符，使我们可以在表达式中直接赋值给变量。
 
增加这个运算符后，字典推导式的计算顺序也将作出调整，从而确保 键 的计算先于 值 的计算(因为 键 的值可能会被绑定在一个变量名称上，用于 值 的计算)。
 
在本提案的讨论过程中，:= 被非正式地称为“海象符”("the walrus operator")。带这种运算符的表达式，正式名称是“赋值表达式”("Assignment Expressions"，即本提议的标题)，有时也被称为“命名表达式”("Named Expressions"，例如 CPython 实现中即以此作为内部名称)。
 

 
二、必要性说明
 
命名某个表达式的结果是编程中的重要一环，使我们只需记住一个简单的名称，而不是一长串的表达式，并且也容易复用。目前，Python 只能在赋值声明中进行命名，因而在列表推导式或一些其它场景下，就无法进行命名。
 
另外，在交互式 debug 过程中，命名某个大型表达式的一部分可以帮助我们做一些深入的检查。如果无法获取表达式的局部结果，就往往需要在调试过程中重构代码；通过赋值表达式，这些重构将被几个简单的 := 替代。
 
由于不再需要重构代码，我们在调试过程中不经意地改变代码逻辑的几率也降低了(调试过程中的重构，是导致 海森堡Bug  的常见原因)，同时让我们更容易向别的程序员解释程序逻辑。
 
(译注：所谓 Heisenbugs，就是当我们调试的时候，这个 bug 会莫名其妙地消失，命名取自 维尔纳·海森堡 提出的量子力学观察者效应：观察系统的行为将不可避免地将改变其状态。)
 
2.1 使用真实代码进行讨论的重要性
 
在本提案的讨论过程中，许多人(不管是支持者还是反对者)都有一种使用过度简化，或者过度复杂的例子的倾向。
 
使用过度简化的例子时，往往让人感觉是在吹毛求疵，或者可以直接反驳“我反正是绝不会写出这样的代码来的”。而使用过度复杂的例子时，也容易让人感觉含混不清。
 
当然，这两种例子依然是有意义的：它们可以帮助我们澄清一些语义学的上的概念。因此，我们还是会用到一些这样的示例。
 
不论如何，讨论中使用的例子，最好还是来自真实的代码。也就是说，来自大大小小的真实应用，并且在写这些代码时，还没有考虑到本提案的存在。
 
Tim Peters 检查了他自己的代码库，找出许多(在他看来)可以通过赋值表达式写得更清楚的案例，他的最终结论是：本提案确实可以，虽然在比较小的程度上，改进不少代码。
 
使用真实代码的另一个好处是，我们可以间接地观察程序员们对紧凑的理解。Guido van Rossum 检查了 Dropbox 的代码库，发现程序员们更倾向于少写一些代码行，而不是缩短每行代码的长度。
 
比方说，Guido 发现，有些程序员宁肯重复地写几个短表达式，导致程序变慢，也不愿多写一行代码。例如，与其写这样的代码：
 
match = re.match(data)group = match.group(1) if match else None
 
程序员更喜欢这样写：
 
group = re.match(data).group(1) if re.match(data) else None
 
另一种情况是，程序员有时宁肯多跑一些代码，也不愿多写一层缩进：
 
match1 = pattern1.match(data)match2 = pattern2.match(data)if match1:    result = match1.group(1)elif match2:    result = match2.group(2)else:    result = None
 
在上面的代码中，match2 在 match1 已经 match 的时候依然会 match，实际上是没有必要的，更高效的写法应该是：
 
match1 = pattern1.match(data)if match1:    result = match1.group(1)else:    match2 = pattern2.match(data)    if match2:        result = match2.group(2)    else:        result = None
 

 
三、句法与语义
 
在可以使用 Python 表达式的大多数地方，都可以使用命名表达式。具体形式为 NAME := expr ，expr 是一个有效的 Python 表达式，NAME 是一个标识符。
 
命名表达式的值与对应表达式是一样的，只是可以同时赋值给某个变量：
 
# 正则匹配if (match := pattern.search(data)) is not None:    # Do something with match# 迭代器循环while chunk := file.read(8192):   process(chunk)# 重用一个计算复杂的变量[y := f(x), y**2, y**3]# 重用推导式过滤器中的计算结果filtered_data = [y for x in data if (y := f(x)) is not None]
 
3.1 例外情况
 
赋值表达式不能用于一些特定场景，主要是为了避免语义混淆：
 
不能用于直接的赋值声明，除非用括号括起来。例如：
 
y := f(x)  # 错误(y := f(x))  # 正确，但不推荐
 
这个设定主要是帮助大家区别 赋值声明 与 赋值表达式 ——任何情况下，它们中最多只有一个符合语法规范。
 
不能用于直接的赋值声明的右侧，除非用括号括起来。例如：
 
y0 = y1 := f(x)  # 错误y0 = (y1 := f(x))  # 正确，但不鼓励
 
理由同上。
 
不能用于调用函数时的关键字参数，除非用括号括起来。例如：
 
foo(x = y := f(x))  # 错误foo(x=(y := f(x)))  # 正确，但很奇怪
 
这个设定主要是为了避免一些容易引起混淆的代码，并且获取函数参数的过程本身已经很复杂了。
 
不能用于函数参数的默认值，除非用括号括起来。例如：
 
def foo(answer = p := 42):  # 错误    ...def foo(answer=(p := 42)):  # 正确，但有点丑陋    ...
 
函数参数的具体语法对很多用户来说已经很难理解了(例如，可变对象作为参数默认值等)，因此，避免赋值表达式再来添乱，并且也与前一个设定相呼应。
 
不能用于函数参数的类型注解，除非用括号括起来：
 
def foo(answer: p := 42 = 5):  # 错误    ...def foo(answer: (p := 42) = 5):  # 正确，但可能没人会这么写    ...
 
理由与前面两点的理由相似，各种各样的 : 和 = 堆在一起，影响代码可读性。
 
不能用于匿名函数，除非用括号括起来。例如：
 
(lambda: x := 1) # 错误lambda: (x := 1) # 正确，但好像没什么用(x := lambda: 1) # 正确lambda line: (m := re.match(pattern, line)) and m.group(1) # 正确
 
在匿名函数的最外层命名一个变量没有意义，因为无法使用这个变量。为了复用这个变量，总是要加一个括号的，因此，这个设定应该不会影响到大家的代码。
 
在 f-strings 格式化中使用赋值表达式时，必须使用括号。例如：
 
>>> f'{(x:=10)}'  # 正确，使用了赋值表达式'10'>>> x = 10>>> f'{x:=10}'    # 正确，正常使用格式化定义，将 '=10' 作为格式化参数'        10'
 
这也意味着，在 f-string 中，带 := 不一定就是赋值表达式。f-string 使用 : 传递格式化参数，为了向后兼容，这里的赋值表达式必须使用括号括起来。当然，这种用法并不推荐。
 
3.2 作用域
 
赋值表达式并不会引入新的作用域。大多数情况下，它所在的作用域是很明确的：就是当前作用域，如果这个作用域中使用了 nolocal 或 global 变量，赋值表达式也可以使用。而一个匿名函数(虽然是匿名的，但也是一个函数)本身也会引入一个作用域。
 
但有一种特殊情况，列表、集合、字典推导式与生成器表达式(一下统一称为推导式)中的赋值表达式，作用域为这些推导式所在的作用域，并且可以使用原作用域中的 nolocal 或 global 变量。为了更好地支持这一规则，递归推导式中的赋值表达式，作用域在最外层推导式所在的作用域。当然，如果最外层推导式是在一个匿名函数中的话，赋值表达式的作用域就是这个匿名函数自身的作用域。
 
这样设计有两个目的，一是使我们能方便地调用 any() 或 all() 函数，例如：
 
if any((comment := line).startswith('#') for line in lines):    print("First comment:", comment)else:    print("There are no comments")if all((nonblank := line).strip() == '' for line in lines):    print("All lines are blank")else:    print("First non-blank line:", nonblank)
 
二是使我们能很容易地计算推导式中的累计状态，例如：
 
# 计算列表推导式中的累计和total = 0partial_sums = [total := total + v for v in values]print("Total:", total)
 
当然，赋值表达式中的标识符名称不能与推导式所用的变量名称相同。因为推导式本身所用的变量，作用域只在推导式中，而命名表达式中的标识符，作用域在最外层推导式所在的作用域中，两者相同必然会产生冲突。
 
例如，[i := i+1 for i in range(5)] 是错误的，推导过程中所用的变量名 i 作用域在推导式中，而 i := 部分的 i 的作用域并不局限于这个推导式。同样，以下这些示例也都是错误的：
 
[[(j := j) for i in range(5)] for j in range(5)] # 错误[i := 0 for i, j in stuff]                       # 错误[i+1 for i in (i := stuff)]                      # 错误
 
就以上示例来说，技术上，我们也可以为它们设计一个统一的语法规则，但很难说这种规则在实践中有什么用处。因此，内核实现中，遇到这些场景，会直接抛出 SyntaxError。
 
这个限制即使在赋值表达式并不会被执行时也是生效的：
 
[False and (i := 0) for i, j in stuff]     # 错误[i for i, j in stuff if True or (j := 1)]  # 错误
 
对于推导式中的推导部分(第一个 for 之前的部分)或过滤器部分( if 之后，任意嵌套的 for 之前的部分)，不能重名的限制只针对推导式中的迭代变量。如果在这些地方有匿名函数，则由于匿名函数引入了新的作用域，因此依然可以无限制地使用赋值表达式。
 
由于内核实现上的设计限制(符号表分析器 symbol table analyser 很难判断推导式最左侧的迭代部分是否与其它部分重用名称 )，推导式的迭代部分完全禁用命名表达式( in 之后，并在可能的 if 或 for 之前的部分)：
 
[i+1 for i in (j := stuff)]                    # 错误[i+1 for i in range(2) for j in (k := stuff)]  # 错误[i+1 for i in [j for j in (k := stuff)]]       # 错误[i+1 for i in (lambda: (j := stuff))()]        # 错误
 
另外一个特例就是，如果推导式在一个类作用域中，并且其中的赋值表达式的赋值结果也在这个类作用域中，也会抛出 SyntaxError：
 
class Example:    [(j := i) for i in range(5)]  # 错误
 
(这个特例是由推导式所创建的隐式函数作用域导致的——目前还没有让函数直接调用该函数所在的类作用域中的变量的运行时机制，并且我们也无意于增加这种机制。如果之后这个问题解决了，针对赋值表达式的这个限制也可能会取消。请注意，在推导式中无法使用其所在的类作用域中所定义的变量，是一个已经存在的问题。)
 
(译注：这个问题有历史原因，与生成器表达式的设计有关，想要理解具体是什么问题可以参考 stackover上的回答，想要理解这样设计的原因，可以参考 PEP289，之后有机会的话，也会翻译推荐给大家。)
 
参考附录 B ，可以看到一些将推导式转换为等效代码，从而绕过命名冲突的例子。
 
3.3 := 运算符的优先级
 
:= 的优先级高于逗号，低于其它所有操作符，包括 or，and，以及条件表达式(A if C else B)。如前文所说，:= 永远不会与 = 比较优先级(除非通过括号分隔开了)。
 
:= 可直接用于函数的位置参数，但不能用于关键字参数。
 
以下例子或许有助于我们理解这些规则：
 
# 错误x := 0# 替代写法(x := 0)# 错误x = y := 0# 替代写法x = (y := 0)# 正确len(lines := f.readlines())# 正确foo(x := 3, cat='vector')# 错误foo(cat=category := 'vector')# 替代写法foo(cat=(category := 'vector'))
 
以上大多数所谓“正确”的写法都是不推荐的写法，因为阅读代码的人往往一扫而过，可能容易看混。但在一些简单场景中还是可以使用的：
 
# 正确if any(len(longline := line) >= 100 for line in lines):    print("Extremely long line:", longline)
 
本提案推荐大家在 := 两侧分别留一个空格，正如 PEP8 对 = 作为赋值符号时的建议一样。当然，在指定关键字参数时，= 的两侧不用留空格 : )
 
3.4 计算顺序的调整
 
为确保语法定义精确，计算顺序也需要被精确定义。技术上说，计算顺序不是一个新问题，因为函数调用过程可能本身就要有一些控制。Python 已有的规则是，子表达式会逐步从左往右计算。赋值表达式使我们在函数调用过程中进行控制的需要更明确了，因此，我们对当前计算顺序做了一个调整：
 
在字典推导式 {X: Y for ...} 中，按原来的规则，Y 是先于 X 计算的，我们建议让 X 的计算先于 Y。(其实，在形如 {X: Y} 或 dict((X, Y) for ...) 的字典创建过程中，X 的计算就是先于 Y 的，我们只是把同样的规则也推广到字典推导式中。)
 
3.5 赋值表达式与赋值声明的区别
 
最重要的区别是，:= 是一个表达式，因此可以被用于很多赋值声明不能使用的场景，包括匿名函数与推导式。
 
反过来说，赋值表达式也不能支持一些赋值声明的特性：
 
不直接支持多个对象赋值：
 
x = y = z = 0  # 等效代码： (z := (y := (x := 0)))
 
不支持非名称的赋值对象：
 
# 无对应的等效代码a[i] = xself.rest = []
 
对逗号的运算优先级不同：
 
x = 1, 2  # x 为 (1, 2)(x := 1, 2)  # x 为 1
 
不支持迭代器拆包(包括常规形式与扩展形式)：
 
# 等效代码需要加括号loc = x, y  # 等效代码 (loc := (x, y))info = name, phone, *rest  # 等效代码 (info := (name, phone, *rest))# 无等效代码px, py, pz = positionname, phone, email, *other_info = contact
 
不支持行内类型注释：Inline type annotations are not supported:
 
# 最接近的等效代码是单独声明 "p: Optional[int]" 然后赋值p: Optional[int] = None
 
不支持增量赋值：
 
total += tax  # 等效代码 (total := total + tax)
 

 
四、使用示例
 
4.1 标准库中的使用示例
 
site.py
 
env_base 只在这个判断语句中使用，因此直接放到 if 之后：
 
原代码：
 
env_base = os.environ.get("PYTHONUSERBASE", None)if env_base:    return env_base
 
改进后：
 
if env_base := os.environ.get("PYTHONUSERBASE", None):    return env_base
 
_pydecimal.py
 
取消 if 语句的嵌套，减少一层缩进：
 
原代码：
 
if self._is_special:    ans = self._check_nans(context=context)    if ans:        return ans
 
改进后：
 
if self._is_special and (ans := self._check_nans(context=context)):    return ans
 
copy.py
 
避免 if 语句的多层嵌套。(本例还可以参考附录 A )
 
原代码：
 
reductor = dispatch_table.get(cls)if reductor:    rv = reductor(x)else:    reductor = getattr(x, "__reduce_ex__", None)    if reductor:        rv = reductor(4)    else:        reductor = getattr(x, "__reduce__", None)        if reductor:            rv = reductor()        else:            raise Error(                "un(deep)copyable object of type %s" % cls)
 
改进后：
 
if reductor := dispatch_table.get(cls):    rv = reductor(x)elif reductor := getattr(x, "__reduce_ex__", None):    rv = reductor(4)elif reductor := getattr(x, "__reduce__", None):    rv = reductor()else:    raise Error("un(deep)copyable object of type %s" % cls)
 
datetime.py
 
tz 只在 s += tz 中使用，把赋值放到 if 语句中使作用域更明确。
 
原代码：
 
s = _format_time(self._hour, self._minute,                 self._second, self._microsecond,                 timespec)tz = self._tzstr()if tz:    s += tzreturn s
 
改进后：
 
s = _format_time(self._hour, self._minute,                 self._second, self._microsecond,                 timespec)if tz := self._tzstr():    s += tzreturn s
 
sysconfig.py
 
在 while 语句调用 fp.readling()，在 if 语句调用 match() ，使代码更紧凑：
 
原代码：
 
while True:    line = fp.readline()    if not line:        break    m = define_rx.match(line)    if m:        n, v = m.group(1, 2)        try:            v = int(v)        except ValueError:            pass        vars[n] = v    else:        m = undef_rx.match(line)        if m:            vars[m.group(1)] = 0
 
改进后：
 
while line := fp.readline():    if m := define_rx.match(line):        n, v = m.group(1, 2)        try:            v = int(v)        except ValueError:            pass        vars[n] = v    elif m := undef_rx.match(line):        vars[m.group(1)] = 0
 
4.2 简化列表推导式
 
通过获取过滤器计算结果，可以更高效地进行列表推导：
 
results = [(x, y, x/y) for x in input_data if (y := f(x)) > 0]
 
类似地，可以引入赋值表达式，使子表达式在主表达式中复用：
 
stuff = [[y := f(x), x/y] for x in range(5)]
 
注意，在以上两个例子中，变量 y 的作用域都是推导式所在的作用域(即与 results 或 stuff 为同一个作用域)。
 
4.3 获取条件计算结果Capturing condition values
 
赋值表达式可用于获取 if 或 while 语句中的条件计算结果：
 
# 循环交互while (command := input("> ")) != "quit":    print("You entered:", command)# 获取正则表达式的 match 结果# 可以查看 Lib/pydoc.py 中的更多示例if match := re.search(pat, text):    print("Found:", match.group(0))# 把 match 赋值放在 elif 语句中，避免了多层缩进elif match := re.search(otherpat, text):    print("Alternate found:", match.group(0))elif match := re.search(third, text):    print("Fallback found:", match.group(0))# 读取 socket 数据，直到遇到空字符串：while data := sock.recv(8192):    print("Received data:", data)
 
在 while 循环中，赋值表达式往往可以避免无限循环的引入。用户可以直接调用函数作为循环条件，并在之后的循环体中使用函数调用的结果。
 
4.4 Fork
 
一个来自 UNIX 底层的示例：
 
if pid := os.fork():    # Parent codeelse:    # Child code
 

 
五、代码风格建议
 
有些地方可以等效地使用赋值表达式与赋值声明，那么，应该优先使用哪一种呢？我们有以下两条建议：
 
如果可以，优先使用赋值声明，它可以更清楚地表明意图。
如果使用赋值表达式可能导致计算顺序不明确，应重构为使用赋值声明的代码。
 
(译注：本提案还有 3 个附录，本文已经较长，之后再翻译推荐给大家，请多多见谅！)

 
字符串是所有编程语言中都经常需要处理的问题之一，字符串指的是什么呢?下面是学习啦小编整理字符串变量的内容，欢迎阅读。
 
字符串的简介
 
字符串主要用于编程，概念说明、函数解释、用法详述见正文，这里补充一点：字符串在存储上类似字符数组，所以它每一位的单个元素都是可以提取的，如s=“abcdefghij”，则s[0]=“a”，s[9]="j"，而字符串的零位正是它的长度，如s[0]=10(※上述功能Ansistring没有。)，这可以给我们提供很多方便，如高精度运算时每一位都可以转化为数字存入数组。
 
什么是变量
 
变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量可以通过变量名访问。在指令式语言中，变量通常是可变的;但在纯函数式语言(如Haskell)中，变量可能是不可变(immutable)的。在一些语言中，变量可能被明确为是能表示可变状态、具有存储空间的抽象(如在Java和Visual Basic中);但另外一些语言可能使用其它概念(如C的对象)来指称这种抽象，而不严格地定义“变量”的准确外延。
 
变量介绍
 
由于变量让你能够把程序中准备使用的每一段数据都赋给一个简短、易于记忆的名字，因此它们十分有用。变量可以保存程序运行时用户输入的数据(如使用InputBox函数在屏幕上显示一个对话框，然后把用户键入的文本保存到变量中)、特定运算的结果以及要在窗体上显示的一段数据等。简而言之，变量是用于跟踪几乎所有类型信息的简单工具。
 
变量声明后没有赋值的话 编译器会自动提示并赋予默认值
 
变量是一种使用方便的占位符，用于引用计算机内存地址，该地址可以存储Script运行时可更改的程序信息。例如，可以创建一个名为Click Count的变量来存储用户单击Web页面上某个对象的次数。使用变量并不需要了解变量在计算机内存中的地址，只要通过变量名引用变量就可以查看或更改变量的值。在VB Script中只有一个基本数据类型，即Variant，因此所有变量的数据类型都是Variant。
 
变量简介
 
字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。在程序设计中，字符串(string)为符号或数值的一个连续序列，如符号串(一串字符)或二进制数字串(一串二进制数字)。
 
通常以串的整体作为操作对象，如：在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。两个字符串相等的充要条件是：长度相等，并且各个对应位置上的字符都相等。设p、q是两个串，求q在p中首次出现的位置的运算叫做模式匹配。串的两种最基本的存储方式是顺序存储方式和链接存储方式。
 
c语言字符型常量与变量
 
字符常量：一个字符常量代表ASCII字符集中的一个字符，在程序中用单引号把一个字符括起来作为字符常量。例如’A’ ‘b’等都是合法的字符常量。
 
注意： 1、C语言区分大小写：单引号中的大小写字母代表不同的字符常量，例如’A’与’a’是不同的字符常量;2、单引号中的空格符也是一个字符常量3、字符常量只能包括一个字符，所以’ab’是非法的;4、字符常量只能用单引号括起来，不能用双引号。比如”a”不是一个字符常量而是一个字符串。
 
转义字符常量：转义字符又称反斜线字符，这些字符常量总是以一个反斜线开头后跟一个特定的字符，用来代表某一个特定的ASCII字符，这些字符常量也必须扩在一对单引号内。
 
注意：1:转义字符常量只代表一个字符，例如’\n’、’\101’; 2:反斜线后的八进制数可以不用0开头;
 
3:反斜线后的十六进制数只可由小写字母x开头，不能以大写字母X或0X开头。
 
字符串常量：字符串常量是由双引号括起来的一串字符。在C语言中，字符串是用字符型一维数组来存放的。系统在每个字符串的末尾自动加上一个字符’\0’作为字符串结束标志，’\0’在这里占用存储空间但不计入字符串的实际长度。两个连续的双引号(” ”)也是一个字符串常量：称为空串，占一个字节，该字节用来存放’\0’。
 
在C语言中，字符常量可以参与任何整数运算以及关系运算。
 
字符变量：C语言中，字符变量是用关键字char来定义的，例如：char a=’b’,字符变量在内存中占一个字节，当把一个字符放入字符变量中时，字符变量的值就是该字符的ASCII码值，所以字符变量可以作为整型变量来处理，可以参与任何整形变量的运算。
 
看过“什么是字符串变量”的人还看了：