console源码

⑴ 如何做到本地保持，使得下一次打开小程序后，仍旧能看到以前的数据，代码该如何实现（附有源码）

使用html5的localStorage。将数据JSON.stringify后储存到localStorage。

⑵ 浏览器 console 怎么引用js

这里拿网络音乐VIP兑换页面来做演示。
首先打开网络音乐VIP兑换页面，然后按F12调出切换到Console控制台。如图：

然后在Console控制台里输入如下代码，再回车它就会自动点击,如演示图：
setInterval(function () {$('#exchange-submit').click(); },800);setInterval(function () {$('.txt').click(); },800)
----------分隔符------------
代码讲解：
#exchange-submit，这说的是ID如：源码中的 <span id="exchange-submit"></span>
.inner(把inner改成txt也行看代码)，这说的是CLASS如：源码中的<span class="inner"><span class="txt">关闭</span> </span>
这里的数字是毫秒
“;”代码中是上下隔一段代码，如您要循环点击3个不一样顺序的东西就再最后加个“;”再继续输入代码就行了。

⑶ 如何看c#console的类源码

除了MSDN以外一般还真没太好的办法，也有头文件，不过C#叫命名空间（nameSpace）
跟C差不多，引入命名空间以后就可以使用这个命名空间里面的类和函数，这点跟C的库很像，不过封装更厉害一点而已。
如果你知道你要用的类在哪个命名空间的话其实还是好办的，因为在VS环境下，只要你引入了命名空间，随便瞧一个字母就能给出你能创建的所有类，枚举，结构的提示，方向键选中相关的内容就有描述，包括作用，参数名称，类型，返回值等信息。
假如你想知道函数的的参数和返回值还有个办法就是在函数的括号中按下组合键（ctrl+shift+space）也能调出函数的重载列表，通过方向键上下就可以看每个重载的参数和返回值了。
假设你完全不知道你要实现的功能来自哪个命名空间的哪个类，估计你就只能借助MSDN和度娘了。
最后如果你用的是第三方的东西，只能借助第三方的文档并且寄希望于第三方的开发工程师有个良好的文档注释习惯了。不得已只能问度娘了，不过比较冷僻的第三方东西度娘一般不知道。

⑷ 为什么无法反汇编从c++编写的Console程序....

多给点信息……
用的什么反汇编程序？
什么平台下的？Windows、Linux还是Mac
Console就是控制台的意思……但究竟是怎样的一个控制台……

我猜可能是Win平台下用OD反汇编的……
如果是的话，问题可能处在控制台本身的运行级别上
虽然我不太清楚你要调试的是怎样一个控制台
但很有可能控制台是运行在ring0层上的，
而OD作为一个ring3层的调试器是无法加载的……

如果不是我猜的这样，你最好还是多给点信息
我也好根据情况帮你想想

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

这样啊～～
说实话我对控制台的概念并不很清楚～～
但如果OD无法加载的话
就直接用IDA吧～～
既然是自己写的，肯定也没有加密～～
静态反汇编就可以了～～没必要用OD这种动态调试器～～

另外，如果是作业的话
应该是要求交源码吧？
反汇编出来的汇编代码和正向写出来的代码可是有差别的～～
而且用高级语言写的代码明显带有高级语言编译器的自身风格
如果是精通逆向工程的人一眼就能看出来反汇编出来的代码是出自哪款编译器
即便你们老师不懂逆向，看不出编译器
也明显能看出这不是W32ASM的作品
毕竟高级语言编译成机器码后都是很罗唆的～～
不可能像直接编写汇编那样简洁明了。

⑸ 如何修改consolecmdvm函数的源代码

关闭cmd窗口，打开注册表编辑器，展开子项
HKEY_CURRENT_USER\Console\%SystemRoot%_system32_cmd.exe
删除 CodePage 、FaceName 、FontFamily 、FontSize 这些键值，
再打开cmd窗口，属性字体中就有新宋体了。

⑹ 编写一个C#程序，实现从键盘中输入两个数字，屏幕输出这两个数值的和、差、积、商。

C#程序源码：

static void Main(string[] args)

{

Console.Write("a=");

string a = Console.ReadLine();

Console.Write("b=");

string b = Console.ReadLine();

double x = Convert.ToDouble(a);

double y = Convert.ToDouble(b);

Console.WriteLine("a+b=" + (x + y));

Console.WriteLine("a-b="+ (x-y));

Console.WriteLine("a*b=" + (x * y));

Console.WriteLine("a/b=" + x / y);

Console.ReadKey();

}

程序运行结果：

(6)console源码扩展阅读：

C语言实现方法：

#include "pch.h"

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>

int main()

{

int num1, num2;

char operate;

scanf("%d %c %d", &num1, &operate, &num2);

switch (operate) {

case '+':

printf("%d", num1 + num2);

break;

case '-':

printf("%d", num1 - num2);

break;

case '*':

printf("%d", num1*num2);

break;

case '/':

printf("%d", num1 / num2);

break;

case '%':

printf("%d", num1%num2);

break;

default:

printf("ERROR");

}

return 0;

}

⑺ bat查看网页源代码

@echo off
>tmp.vbs echo Dim Mx, cAS
>>tmp.vbs echo Set Mx = CreateObject("MsXml2.XmlHttp")
>>tmp.vbs echo Mx.open "get", "网络不给放网址自己放啊", False:Mx.send()
>>tmp.vbs echo Do Until Mx.readyState = 4 : WScript.Sleep 200 :Loop:WScript.Sleep 1000
>>tmp.vbs echo Set cAS = CreateObject("Adodb.Stream")
>>tmp.vbs echo cAS.Type = 1:cAS.Mode = 3:cAS.Open():cAS.Write Mx.responseBody:cAS.SaveToFile "tmp.txt", 2:Mx.abort:Set Mx = Nothing:cAS.Close
tmp.vbs
for /f "tokens=2 delims=[]" %%i in (tmp.txt) do >1.txt echo %%i
del tmp.*
start "" 1.txt

⑻ 如何学习TensorFlow源码

如果从源码构建TensorFlow会需要执行如下命令：
bazel build -c opt //tensorflow/tools/pip_package:build_pip_package

对应的BUILD文件的rule为：
sh_binary(
name = "build_pip_package",
srcs = ["build_pip_package.sh"],
data = [
"MANIFEST.in",
"README",
"setup.py",
"//tensorflow/core:framework_headers",
":other_headers",
":simple_console",
"//tensorflow:tensorflow_py",
"//tensorflow/examples/tutorials/mnist:package",
"//tensorflow/models/embedding:package",
"//tensorflow/models/image/cifar10:all_files",
"//tensorflow/models/image/mnist:convolutional",
"//tensorflow/models/rnn:package",
"//tensorflow/models/rnn/ptb:package",
"//tensorflow/models/rnn/translate:package",
"//tensorflow/tensorboard",
],
)

sh_binary在这里的主要作用是生成data的这些依赖。一个一个来看，一开始的三个文件MANIFEST.in、README、setup.py是直接存在的，因此不会有什么操作。
“//tensorflow/core:framework_headers”:其对应的rule为：
filegroup(
name = "framework_headers",
srcs = [
"framework/allocator.h",
......
"util/device_name_utils.h",
],
)

这里filegroup的作用是给这一堆头文件一个别名，方便其他rule引用。
“:other_headers”:rule为：
transitive_hdrs(
name = "other_headers",
deps = [
"//third_party/eigen3",
"//tensorflow/core:protos_all_cc",
],
)

transitive_hdrs的定义在：
load("//tensorflow:tensorflow.bzl", "transitive_hdrs")

实现为：
# Bazel rule for collecting the header files that a target depends on.
def _transitive_hdrs_impl(ctx):
outputs = set()
for dep in ctx.attr.deps:
outputs += dep.cc.transitive_headers
return struct(files=outputs)

_transitive_hdrs = rule(attrs={
"deps": attr.label_list(allow_files=True,
providers=["cc"]),
},
implementation=_transitive_hdrs_impl,)

def transitive_hdrs(name, deps=[], **kwargs):
_transitive_hdrs(name=name + "_gather",
deps=deps)
native.filegroup(name=name,
srcs=[":" + name + "_gather"])

其作用依旧是收集依赖需要的头文件。
“:simple_console”:其rule为：
py_binary(
name = "simple_console",
srcs = ["simple_console.py"],
srcs_version = "PY2AND3",
deps = ["//tensorflow:tensorflow_py"],
)
py_library(
name = "tensorflow_py",
srcs = ["__init__.py"],
srcs_version = "PY2AND3",
visibility = ["//visibility:public"],
deps = ["//tensorflow/python"],
)

simple_console.py的代码的主要部分是：
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import code
import sys

def main(_):
"""Run an interactive console."""
code.interact()
return 0

if __name__ == '__main__':
sys.exit(main(sys.argv))

可以看到起通过deps = [“//tensorflow/python”]构建了依赖包，然后生成了对应的执行文件。看下依赖的rule规则。//tensorflow/python对应的rule为：
py_library(
name = "python",
srcs = [
"__init__.py",
],
srcs_version = "PY2AND3",
visibility = ["//tensorflow:__pkg__"],
deps = [
":client",
":client_testlib",
":framework",
":framework_test_lib",
":kernel_tests/gradient_checker",
":platform",
":platform_test",
":summary",
":training",
"//tensorflow/contrib:contrib_py",
],
)

这里如果仔细看的话会发现其主要是生成一堆python的模块。从这里貌似可以看出每个python的mole都对应了一个rule，且mole依赖的mole都写在了deps里。特别的，作为一个C++的切入，我们关注下training这个依赖：
py_library(
name = "training",
srcs = glob(
["training/**/*.py"],
exclude = ["**/*test*"],
),
srcs_version = "PY2AND3",
deps = [
":client",
":framework",
":lib",
":ops",
":protos_all_py",
":pywrap_tensorflow",
":training_ops",
],
)

这里其依赖的pywrap_tensorflow的rule为：
tf_py_wrap_cc(
name = "pywrap_tensorflow",
srcs = ["tensorflow.i"],
swig_includes = [
"client/device_lib.i",
"client/events_writer.i",
"client/server_lib.i",
"client/tf_session.i",
"framework/python_op_gen.i",
"lib/core/py_func.i",
"lib/core/status.i",
"lib/core/status_helper.i",
"lib/core/strings.i",
"lib/io/py_record_reader.i",
"lib/io/py_record_writer.i",
"platform/base.i",
"platform/numpy.i",
"util/port.i",
"util/py_checkpoint_reader.i",
],
deps = [
":py_func_lib",
":py_record_reader_lib",
":py_record_writer_lib",
":python_op_gen",
":tf_session_helper",
"//tensorflow/core/distributed_runtime:server_lib",
"//tensorflow/core/distributed_runtime/rpc:grpc_server_lib",
"//tensorflow/core/distributed_runtime/rpc:grpc_session",
"//util/python:python_headers",
],
)

tf_py_wrap_cc为其自己实现的一个rule，这里的.i就是SWIG的interface文件。来看下其实现：
def tf_py_wrap_cc(name, srcs, swig_includes=[], deps=[], copts=[], **kwargs):
mole_name = name.split("/")[-1]
# Convert a rule name such as foo/bar/baz to foo/bar/_baz.so
# and use that as the name for the rule procing the .so file.
cc_library_name = "/".join(name.split("/")[:-1] + ["_" + mole_name + ".so"])
extra_deps = []
_py_wrap_cc(name=name + "_py_wrap",
srcs=srcs,
swig_includes=swig_includes,
deps=deps + extra_deps,
mole_name=mole_name,
py_mole_name=name)
native.cc_binary(
name=cc_library_name,
srcs=[mole_name + ".cc"],
copts=(copts + ["-Wno-self-assign", "-Wno-write-strings"]
+ tf_extension_copts()),
linkopts=tf_extension_linkopts(),
linkstatic=1,
linkshared=1,
deps=deps + extra_deps)
native.py_library(name=name,
srcs=[":" + name + ".py"],
srcs_version="PY2AND3",
data=[":" + cc_library_name])

按照SWIG的正常流程，先要通过swig命令生成我们的wrap的c文件，然后和依赖生成我们的so文件，最后生成一个同名的python文件用于import。这里native.cc_binary和native.py_library做了我们后面的两件事情，而swig命令的执行则交给了_py_wrap_cc。其实现为：
_py_wrap_cc = rule(attrs={
"srcs": attr.label_list(mandatory=True,
allow_files=True,),
"swig_includes": attr.label_list(cfg=DATA_CFG,
allow_files=True,),
"deps": attr.label_list(allow_files=True,
providers=["cc"],),
"swig_deps": attr.label(default=Label(
"//tensorflow:swig")), # swig_templates
"mole_name": attr.string(mandatory=True),
"py_mole_name": attr.string(mandatory=True),
"swig_binary": attr.label(default=Label("//tensorflow:swig"),
cfg=HOST_CFG,
executable=True,
allow_files=True,),
},
outputs={
"cc_out": "%{mole_name}.cc",
"py_out": "%{py_mole_name}.py",
},
implementation=_py_wrap_cc_impl,)

_py_wrap_cc_impl的实现为：
# Bazel rules for building swig files.
def _py_wrap_cc_impl(ctx):
srcs = ctx.files.srcs
if len(srcs) != 1:
fail("Exactly one SWIG source file label must be specified.", "srcs")
mole_name = ctx.attr.mole_name
cc_out = ctx.outputs.cc_out
py_out = ctx.outputs.py_out
src = ctx.files.srcs[0]
args = ["-c++", "-python"]
args += ["-mole", mole_name]
args += ["-l" + f.path for f in ctx.files.swig_includes]
cc_include_dirs = set()
cc_includes = set()
for dep in ctx.attr.deps:
cc_include_dirs += [h.dirname for h in dep.cc.transitive_headers]
cc_includes += dep.cc.transitive_headers
args += ["-I" + x for x in cc_include_dirs]
args += ["-I" + ctx.label.workspace_root]
args += ["-o", cc_out.path]
args += ["-outdir", py_out.dirname]
args += [src.path]
outputs = [cc_out, py_out]
ctx.action(executable=ctx.executable.swig_binary,
arguments=args,
mnemonic="PythonSwig",
inputs=sorted(set([src]) + cc_includes + ctx.files.swig_includes +
ctx.attr.swig_deps.files),
outputs=outputs,
progress_message="SWIGing {input}".format(input=src.path))
return struct(files=set(outputs))

这里的ctx.executable.swig_binary是一个shell脚本，内容为：
# If possible, read swig path out of "swig_path" generated by configure
SWIG=swig
SWIG_PATH=tensorflow/tools/swig/swig_path
if [ -e $SWIG_PATH ]; then
SWIG=`cat $SWIG_PATH`
fi

# If this line fails, rerun configure to set the path to swig correctly
"$SWIG" "$@"

可以看到起就是调用了swig命令。
“//tensorflow:tensorflow_py”:其rule为：
py_library(
name = "tensorflow_py",
srcs = ["__init__.py"],
srcs_version = "PY2AND3",
visibility = ["//visibility:public"],
deps = ["//tensorflow/python"],
)

⑼ logback之Appender源码解读

在logback日志框架中，每一个Logger都会去关联一个Appender，Appender是真正把日志内容输出到控制台，文件等，可以说在日常应用中非常重要和拓展的一个组件。

其中最重要的就是 doAppend() 方法，每一个日志事件输出，都会调用到这个接口。

其中，有我们熟悉的 ConsoleAppender 和 FileAppender ，还有 RollingFileAppender 。另外，有一个很重要的 AsyncAppender 接口，异步输出，这也是logback日志受欢迎的一个非常重要的特性。他们都继承与抽象类 UnsynchronizedAppenderBase 类。

在 UnsynchronizedAppenderBase 中，我们看一下其中实现了最重要的一个方法 doAppend()

其实这个方法没有东西也没有做，只是使用模版方法，让具体的子类交给子类的 append() 方法实现具体的逻辑。

在 OutputStreamAppender 类中，有几个比较重要的成员变量。

其中 encoder 最主要的作用就是把日志事件要输出的内容变成字节数组，然后把字节数组写入到 outputStream 。

其中 outputStream 可以是控制台或者文件等。

接着看 append() 方法

这个方法也是没有做什么，接着具体看 subAppend() 方法。

在这个方法中，可以看到 encoder 的作用，同时还有一个重要的方法 writeBytes()

这个方法就是把字节数组写入到outputStream中。

总结一下：一个日志事件记录的流程就是，要需要输出的内容通过encoder变成字节数组，然后写入到具体的输出流中。

ConsoleAppender 继承了 OutputStreamAppender ，唯一不一样的就是输出的位置， ConsoleAppender 是输出到控制台，outputStream输出流也应该是控制台。

其中， start() 方法会在初始化logback.xml配置的时候去调用，在 start() 方法中就设置了outputStream输出流——控制台。

FileAppender ,如果一个日志事件需要输出到文件中，那么它就需要一个文件输出流FileOutStream。

需要设置一个文件名。在看看 start() 方法对 FileAppender 进行初始化工作。

主要看 openFile() 方法

在这个方法中，通过文件名去 new File() 文件，然后封装到 ResilientFileOutputStream 中，然后设置 setOutputStream() ，这样子就可以把日志输出到文件中了。

异步输出，也就意味着会把日志事件先放入到一个队列中，然后由专门的线程去队列中拿日志事件消费。

看类 AsyncAppenderBase 中几个重要的成员变量

AppenderAttachableImpl 里面包含一个Appender列表，列表是具体的Appender，如上面讲到的ConsoleAppender和FileAppender。

BlockingQueue是一个队列，Worker是一个消费线程。

例如，在配置文件中定义一个异步的Appender

接下来看看具体是如何实现异步输出的。

start() 方法初始化中，定义了一个 ArrayBlockingQueue 队列，以及启动了一个worker线程。

接着看 append() 方法

在 append() 方法中，并没有马上处理日志事件，而是调用 put() 方法

接着把日志事件放进去消息队列中。然后由 Worker 线程去处理

Worker 线程从队列中take()取出事件，然后由具体的Appender去处理

看到调用 doAppend() ，已经和之前的Appender是一样的啦。
本文是笔者个人的理解，若有不正确指出请多多纠正。